?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
libsmbconf: refactor autocreation of [global] into a helper function.
[Samba.git] / source / lib / smbconf / smbconf.c
blobdd044eef818008e29d7866079765b29ef1b283fb
1 /*
2 * Unix SMB/CIFS implementation.
3 * libnet smbconf registry Support
4 * Copyright (C) Michael Adam 2007-2008
5 * Copyright (C) Guenther Deschner 2007
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "includes.h"
22 #include "smbconf_private.h"
23
24 /**********************************************************************
25 *
26 * Helper functions (mostly registry related)
27 *
28 **********************************************************************/
29
30 /**
31 * add a string to a talloced array of strings.
32 */
33 static WERROR smbconf_add_string_to_array(TALLOC_CTX *mem_ctx,
34 char ***array,
35 uint32_t count,
36 const char *string)
37 {
38 char **new_array = NULL;
39
40 if ((array == NULL) || (string == NULL)) {
41 return WERR_INVALID_PARAM;
42 }
43
44 new_array = TALLOC_REALLOC_ARRAY(mem_ctx, *array, char *, count + 1);
45 if (new_array == NULL) {
46 return WERR_NOMEM;
47 }
48
49 new_array[count] = talloc_strdup(new_array, string);
50 if (new_array[count] == NULL) {
51 TALLOC_FREE(new_array);
52 return WERR_NOMEM;
53 }
54
55 *array = new_array;
56
57 return WERR_OK;
58 }
59
60 static WERROR smbconf_reg_initialize(struct smbconf_ctx *ctx)
61 {
62 WERROR werr = WERR_OK;
63
64 if (!registry_init_smbconf()) {
65 werr = WERR_REG_IO_FAILURE;
66 goto done;
67 }
68
69 werr = ntstatus_to_werror(registry_create_admin_token(ctx,
70 &(ctx->token)));
71 if (!W_ERROR_IS_OK(werr)) {
72 DEBUG(1, ("Error creating admin token\n"));
73 goto done;
74 }
75
76 done:
77 return werr;
78 }
79
80 /**
81 * Open a registry key specified by "path"
82 */
83 static WERROR smbconf_reg_open_path(TALLOC_CTX *mem_ctx,
84 struct smbconf_ctx *ctx,
85 const char *path,
86 uint32 desired_access,
87 struct registry_key **key)
88 {
89 WERROR werr = WERR_OK;
90
91 if (ctx == NULL) {
92 DEBUG(1, ("Error: configuration is not open!\n"));
93 werr = WERR_INVALID_PARAM;
94 goto done;
95 }
96
97 if (ctx->token == NULL) {
98 DEBUG(1, ("Error: token missing from smbconf_ctx. "
99 "was smbconf_open() called?\n"));
100 werr = WERR_INVALID_PARAM;
101 goto done;
102 }
103
104 if (path == NULL) {
105 DEBUG(1, ("Error: NULL path string given\n"));
106 werr = WERR_INVALID_PARAM;
107 goto done;
108 }
109
110 werr = reg_open_path(mem_ctx, path, desired_access, ctx->token, 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 KEY_SMBCONF (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", KEY_SMBCONF, 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 KEY_SMBCONF
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, KEY_SMBCONF, 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 KEY_SMBCONF
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 ZERO_STRUCT(val);
255
256 val.type = REG_SZ;
257 val.v.sz.str = CONST_DISCARD(char *, canon_valstr);
258 val.v.sz.len = strlen(canon_valstr) + 1;
259
260 if (registry_smbconf_valname_forbidden(canon_valname)) {
261 DEBUG(5, ("Parameter '%s' not allowed in registry.\n",
262 canon_valname));
263 werr = WERR_INVALID_PARAM;
264 goto done;
265 }
266
267 subkeyname = strrchr_m(key->key->name, '\\');
268 if ((subkeyname == NULL) || (*(subkeyname +1) == '\0')) {
269 DEBUG(5, ("Invalid registry key '%s' given as "
270 "smbconf section.\n", key->key->name));
271 werr = WERR_INVALID_PARAM;
272 goto done;
273 }
274 subkeyname++;
275 if (!strequal(subkeyname, GLOBAL_NAME) &&
276 lp_parameter_is_global(valname))
277 {
278 DEBUG(5, ("Global paramter '%s' not allowed in "
279 "service definition ('%s').\n", canon_valname,
280 subkeyname));
281 werr = WERR_INVALID_PARAM;
282 goto done;
283 }
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 /**
297 * format a registry_value into a string.
298 *
299 * This is intended to be used for smbconf registry values,
300 * which are ar stored as REG_SZ values, so the incomplete
301 * handling should be ok.
302 */
303 static char *smbconf_format_registry_value(TALLOC_CTX *mem_ctx,
304 struct registry_value *value)
305 {
306 char *result = NULL;
307
308 /* alternatively, create a new talloc context? */
309 if (mem_ctx == NULL) {
310 return result;
311 }
312
313 switch (value->type) {
314 case REG_DWORD:
315 result = talloc_asprintf(mem_ctx, "%d", value->v.dword);
316 break;
317 case REG_SZ:
318 case REG_EXPAND_SZ:
319 result = talloc_asprintf(mem_ctx, "%s", value->v.sz.str);
320 break;
321 case REG_MULTI_SZ: {
322 uint32 j;
323 for (j = 0; j < value->v.multi_sz.num_strings; j++) {
324 result = talloc_asprintf(mem_ctx, "%s \"%s\" ",
325 result,
326 value->v.multi_sz.strings[j]);
327 if (result == NULL) {
328 break;
329 }
330 }
331 break;
332 }
333 case REG_BINARY:
334 result = talloc_asprintf(mem_ctx, "binary (%d bytes)",
335 (int)value->v.binary.length);
336 break;
337 default:
338 result = talloc_asprintf(mem_ctx, "<unprintable>");
339 break;
340 }
341 return result;
342 }
343
344 /**
345 * Get the values of a key as a list of value names
346 * and a list of value strings (ordered)
347 */
348 static WERROR smbconf_reg_get_values(TALLOC_CTX *mem_ctx,
349 struct registry_key *key,
350 uint32_t *num_values,
351 char ***value_names,
352 char ***value_strings)
353 {
354 TALLOC_CTX *tmp_ctx = NULL;
355 WERROR werr = WERR_OK;
356 uint32_t count;
357 struct registry_value *valvalue = NULL;
358 char *valname = NULL;
359 char **tmp_valnames = NULL;
360 char **tmp_valstrings = NULL;
361
362 if ((num_values == NULL) || (value_names == NULL) ||
363 (value_strings == NULL))
364 {
365 werr = WERR_INVALID_PARAM;
366 goto done;
367 }
368
369 tmp_ctx = talloc_stackframe();
370 if (tmp_ctx == NULL) {
371 werr = WERR_NOMEM;
372 goto done;
373 }
374
375 for (count = 0;
376 W_ERROR_IS_OK(werr = reg_enumvalue(tmp_ctx, key, count, &valname,
377 &valvalue));
378 count++)
379 {
380 char *valstring;
381
382 werr = smbconf_add_string_to_array(tmp_ctx,
383 &tmp_valnames,
384 count, valname);
385 if (!W_ERROR_IS_OK(werr)) {
386 goto done;
387 }
388
389 valstring = smbconf_format_registry_value(tmp_ctx, valvalue);
390 werr = smbconf_add_string_to_array(tmp_ctx, &tmp_valstrings,
391 count, valstring);
392 if (!W_ERROR_IS_OK(werr)) {
393 goto done;
394 }
395 }
396 if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
397 goto done;
398 }
399
400 werr = WERR_OK;
401
402 *num_values = count;
403 if (count > 0) {
404 *value_names = talloc_move(mem_ctx, &tmp_valnames);
405 *value_strings = talloc_move(mem_ctx, &tmp_valstrings);
406 } else {
407 *value_names = NULL;
408 *value_strings = NULL;
409 }
410
411 done:
412 TALLOC_FREE(tmp_ctx);
413 return werr;
414 }
415
416 static int smbconf_destroy_ctx(struct smbconf_ctx *ctx)
417 {
418 return regdb_close();
419 }
420
421 /**
422 * Get the change sequence number of the given service/parameter.
423 * service and parameter strings may be NULL.
424 */
425 static void smbconf_reg_get_csn(struct smbconf_ctx *ctx,
426 struct smbconf_csn *csn,
427 const char *service, const char *param)
428 {
429 if (csn == NULL) {
430 return;
431 }
432 csn->csn = (uint64_t)regdb_get_seqnum();
433 }
434
435 static WERROR smbconf_global_check(struct smbconf_ctx *ctx)
436 {
437 if (!smbconf_share_exists(ctx, GLOBAL_NAME)) {
438 return smbconf_create_share(ctx, GLOBAL_NAME);
439 }
440 return WERR_OK;
441 }
442
443 /**********************************************************************
444 *
445 * The actual net conf api functions, that are exported.
446 *
447 **********************************************************************/
448
449 /**
450 * Open the configuration.
451 *
452 * This should be the first function in a sequence of calls to smbconf
453 * functions:
454 *
455 * Upon success, this creates and returns the conf context
456 * that should be passed around in subsequent calls to the other
457 * smbconf functions.
458 *
459 * After the work with the configuration is completed, smbconf_close()
460 * should be called.
461 */
462 WERROR smbconf_open(TALLOC_CTX *mem_ctx, struct smbconf_ctx **conf_ctx)
463 {
464 WERROR werr = WERR_OK;
465 struct smbconf_ctx *ctx;
466
467 if (conf_ctx == NULL) {
468 return WERR_INVALID_PARAM;
469 }
470
471 ctx = TALLOC_ZERO_P(mem_ctx, struct smbconf_ctx);
472 if (ctx == NULL) {
473 return WERR_NOMEM;
474 }
475
476 werr = smbconf_reg_initialize(ctx);
477 if (!W_ERROR_IS_OK(werr)) {
478 goto fail;
479 }
480
481 talloc_set_destructor(ctx, smbconf_destroy_ctx);
482
483 *conf_ctx = ctx;
484 return werr;
485
486 fail:
487 TALLOC_FREE(ctx);
488 return werr;
489 }
490
491 /**
492 * Close the configuration.
493 */
494 void smbconf_close(struct smbconf_ctx *ctx)
495 {
496 /* this also closes the registry (by destructor): */
497 TALLOC_FREE(ctx);
498 }
499
500 /**
501 * Detect changes in the configuration.
502 * The given csn struct is filled with the current csn.
503 * smbconf_changed() can also be used for initial retrieval
504 * of the csn.
505 */
506 bool smbconf_changed(struct smbconf_ctx *ctx, struct smbconf_csn *csn,
507 const char *service, const char *param)
508 {
509 struct smbconf_csn old_csn;
510
511 if (csn == NULL) {
512 return false;
513 }
514
515 old_csn = *csn;
516
517 smbconf_reg_get_csn(ctx, csn, service, param);
518 return (csn->csn != old_csn.csn);
519 }
520
521 /**
522 * Drop the whole configuration (restarting empty).
523 */
524 WERROR smbconf_drop(struct smbconf_ctx *ctx)
525 {
526 char *path, *p;
527 WERROR werr = WERR_OK;
528 struct registry_key *parent_key = NULL;
529 struct registry_key *new_key = NULL;
530 TALLOC_CTX* mem_ctx = talloc_stackframe();
531 enum winreg_CreateAction action;
532
533 path = talloc_strdup(mem_ctx, KEY_SMBCONF);
534 if (path == NULL) {
535 werr = WERR_NOMEM;
536 goto done;
537 }
538 p = strrchr(path, '\\');
539 *p = '\0';
540 werr = smbconf_reg_open_path(mem_ctx, ctx, path, REG_KEY_WRITE,
541 &parent_key);
542
543 if (!W_ERROR_IS_OK(werr)) {
544 goto done;
545 }
546
547 werr = reg_deletekey_recursive(mem_ctx, parent_key, p+1);
548
549 if (!W_ERROR_IS_OK(werr)) {
550 goto done;
551 }
552
553 werr = reg_createkey(mem_ctx, parent_key, p+1, REG_KEY_WRITE,
554 &new_key, &action);
555
556 done:
557 TALLOC_FREE(mem_ctx);
558 return werr;
559 }
560
561 /**
562 * Get the whole configuration as lists of strings with counts:
563 *
564 * num_shares : number of shares
565 * share_names : list of length num_shares of share names
566 * num_params : list of length num_shares of parameter counts for each share
567 * param_names : list of lists of parameter names for each share
568 * param_values : list of lists of parameter values for each share
569 */
570 WERROR smbconf_get_config(struct smbconf_ctx *ctx,
571 TALLOC_CTX *mem_ctx,
572 uint32_t *num_shares,
573 char ***share_names, uint32_t **num_params,
574 char ****param_names, char ****param_values)
575 {
576 WERROR werr = WERR_OK;
577 TALLOC_CTX *tmp_ctx = NULL;
578 uint32_t tmp_num_shares;
579 char **tmp_share_names;
580 uint32_t *tmp_num_params;
581 char ***tmp_param_names;
582 char ***tmp_param_values;
583 uint32_t count;
584
585 if ((num_shares == NULL) || (share_names == NULL) ||
586 (num_params == NULL) || (param_names == NULL) ||
587 (param_values == NULL))
588 {
589 werr = WERR_INVALID_PARAM;
590 goto done;
591 }
592
593 tmp_ctx = talloc_stackframe();
594 if (tmp_ctx == NULL) {
595 werr = WERR_NOMEM;
596 goto done;
597 }
598
599 werr = smbconf_get_share_names(ctx, tmp_ctx, &tmp_num_shares,
600 &tmp_share_names);
601 if (!W_ERROR_IS_OK(werr)) {
602 goto done;
603 }
604
605 tmp_num_params = TALLOC_ARRAY(tmp_ctx, uint32_t, tmp_num_shares);
606 tmp_param_names = TALLOC_ARRAY(tmp_ctx, char **, tmp_num_shares);
607 tmp_param_values = TALLOC_ARRAY(tmp_ctx, char **, tmp_num_shares);
608
609 if ((tmp_num_params == NULL) || (tmp_param_names == NULL) ||
610 (tmp_param_values == NULL))
611 {
612 werr = WERR_NOMEM;
613 goto done;
614 }
615
616 for (count = 0; count < tmp_num_shares; count++) {
617 werr = smbconf_get_share(ctx, mem_ctx,
618 tmp_share_names[count],
619 &tmp_num_params[count],
620 &tmp_param_names[count],
621 &tmp_param_values[count]);
622 if (!W_ERROR_IS_OK(werr)) {
623 goto done;
624 }
625 }
626
627 werr = WERR_OK;
628
629 *num_shares = tmp_num_shares;
630 if (tmp_num_shares > 0) {
631 *share_names = talloc_move(mem_ctx, &tmp_share_names);
632 *num_params = talloc_move(mem_ctx, &tmp_num_params);
633 *param_names = talloc_move(mem_ctx, &tmp_param_names);
634 *param_values = talloc_move(mem_ctx, &tmp_param_values);
635 } else {
636 *share_names = NULL;
637 *num_params = NULL;
638 *param_names = NULL;
639 *param_values = NULL;
640 }
641
642 done:
643 TALLOC_FREE(tmp_ctx);
644 return werr;
645 }
646
647 /**
648 * get the list of share names defined in the configuration.
649 */
650 WERROR smbconf_get_share_names(struct smbconf_ctx *ctx,
651 TALLOC_CTX *mem_ctx,
652 uint32_t *num_shares,
653 char ***share_names)
654 {
655 uint32_t count;
656 uint32_t added_count = 0;
657 TALLOC_CTX *tmp_ctx = NULL;
658 WERROR werr = WERR_OK;
659 struct registry_key *key = NULL;
660 char *subkey_name = NULL;
661 char **tmp_share_names = NULL;
662
663 if ((num_shares == NULL) || (share_names == NULL)) {
664 werr = WERR_INVALID_PARAM;
665 goto done;
666 }
667
668 tmp_ctx = talloc_stackframe();
669 if (tmp_ctx == NULL) {
670 werr = WERR_NOMEM;
671 goto done;
672 }
673
674 /* make sure "global" is always listed first */
675 if (smbconf_share_exists(ctx, GLOBAL_NAME)) {
676 werr = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
677 0, GLOBAL_NAME);
678 if (!W_ERROR_IS_OK(werr)) {
679 goto done;
680 }
681 added_count++;
682 }
683
684 werr = smbconf_reg_open_base_key(tmp_ctx, ctx,
685 SEC_RIGHTS_ENUM_SUBKEYS, &key);
686 if (!W_ERROR_IS_OK(werr)) {
687 goto done;
688 }
689
690 for (count = 0;
691 W_ERROR_IS_OK(werr = reg_enumkey(tmp_ctx, key, count,
692 &subkey_name, NULL));
693 count++)
694 {
695 if (strequal(subkey_name, GLOBAL_NAME)) {
696 continue;
697 }
698
699 werr = smbconf_add_string_to_array(tmp_ctx,
700 &tmp_share_names,
701 added_count,
702 subkey_name);
703 if (!W_ERROR_IS_OK(werr)) {
704 goto done;
705 }
706 added_count++;
707 }
708 if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
709 goto done;
710 }
711 werr = WERR_OK;
712
713 *num_shares = added_count;
714 if (added_count > 0) {
715 *share_names = talloc_move(mem_ctx, &tmp_share_names);
716 } else {
717 *share_names = NULL;
718 }
719
720 done:
721 TALLOC_FREE(tmp_ctx);
722 return werr;
723 }
724
725 /**
726 * check if a share/service of a given name exists
727 */
728 bool smbconf_share_exists(struct smbconf_ctx *ctx,
729 const char *servicename)
730 {
731 bool ret = false;
732 WERROR werr = WERR_OK;
733 TALLOC_CTX *mem_ctx = talloc_stackframe();
734 struct registry_key *key = NULL;
735
736 werr = smbconf_reg_open_service_key(mem_ctx, ctx, servicename,
737 REG_KEY_READ, &key);
738 if (W_ERROR_IS_OK(werr)) {
739 ret = true;
740 }
741
742 TALLOC_FREE(mem_ctx);
743 return ret;
744 }
745
746 /**
747 * Add a service if it does not already exist.
748 */
749 WERROR smbconf_create_share(struct smbconf_ctx *ctx,
750 const char *servicename)
751 {
752 WERROR werr;
753 TALLOC_CTX *mem_ctx = talloc_stackframe();
754 struct registry_key *key = NULL;
755
756 if (smbconf_share_exists(ctx, servicename)) {
757 werr = WERR_ALREADY_EXISTS;
758 goto done;
759 }
760
761 werr = smbconf_reg_create_service_key(mem_ctx, ctx, servicename, &key);
762
763 done:
764 TALLOC_FREE(mem_ctx);
765 return werr;
766 }
767
768 /**
769 * get a definition of a share (service) from configuration.
770 */
771 WERROR smbconf_get_share(struct smbconf_ctx *ctx,
772 TALLOC_CTX *mem_ctx,
773 const char *servicename, uint32_t *num_params,
774 char ***param_names, char ***param_values)
775 {
776 WERROR werr = WERR_OK;
777 struct registry_key *key = NULL;
778
779 werr = smbconf_reg_open_service_key(mem_ctx, ctx, servicename,
780 REG_KEY_READ, &key);
781 if (!W_ERROR_IS_OK(werr)) {
782 goto done;
783 }
784
785 werr = smbconf_reg_get_values(mem_ctx, key, num_params,
786 param_names, param_values);
787
788 done:
789 TALLOC_FREE(key);
790 return werr;
791 }
792
793 /**
794 * delete a service from configuration
795 */
796 WERROR smbconf_delete_share(struct smbconf_ctx *ctx, const char *servicename)
797 {
798 WERROR werr = WERR_OK;
799 struct registry_key *key = NULL;
800 TALLOC_CTX *mem_ctx = talloc_stackframe();
801
802 werr = smbconf_reg_open_base_key(mem_ctx, ctx, REG_KEY_WRITE, &key);
803 if (!W_ERROR_IS_OK(werr)) {
804 goto done;
805 }
806
807 werr = reg_deletekey_recursive(key, key, servicename);
808
809 done:
810 TALLOC_FREE(mem_ctx);
811 return werr;
812 }
813
814 /**
815 * set a configuration parameter to the value provided.
816 */
817 WERROR smbconf_set_parameter(struct smbconf_ctx *ctx,
818 const char *service,
819 const char *param,
820 const char *valstr)
821 {
822 WERROR werr;
823 struct registry_key *key = NULL;
824 TALLOC_CTX *mem_ctx = talloc_stackframe();
825
826 if (!smbconf_share_exists(ctx, service)) {
827 werr = WERR_NO_SUCH_SERVICE;
828 goto done;
829 }
830
831 werr = smbconf_reg_open_service_key(mem_ctx, ctx, service,
832 REG_KEY_WRITE, &key);
833 if (!W_ERROR_IS_OK(werr)) {
834 goto done;
835 }
836
837 werr = smbconf_reg_set_value(key, param, valstr);
838
839 done:
840 TALLOC_FREE(mem_ctx);
841 return werr;
842 }
843
844 /**
845 * Set a global parameter
846 * (i.e. a parameter in the [global] service).
847 *
848 * This also creates [global] when it does not exist.
849 */
850 WERROR smbconf_set_global_parameter(struct smbconf_ctx *ctx,
851 const char *param, const char *val)
852 {
853 WERROR werr;
854
855 werr = smbconf_global_check(ctx);
856 if (W_ERROR_IS_OK(werr)) {
857 werr = smbconf_set_parameter(ctx, GLOBAL_NAME, param, val);
858 }
859
860 return werr;
861 }
862
863 /**
864 * get the value of a configuration parameter as a string
865 */
866 WERROR smbconf_get_parameter(struct smbconf_ctx *ctx,
867 TALLOC_CTX *mem_ctx,
868 const char *service,
869 const char *param,
870 char **valstr)
871 {
872 WERROR werr = WERR_OK;
873 struct registry_key *key = NULL;
874 struct registry_value *value = NULL;
875
876 if (valstr == NULL) {
877 werr = WERR_INVALID_PARAM;
878 goto done;
879 }
880
881 if (!smbconf_share_exists(ctx, service)) {
882 werr = WERR_NO_SUCH_SERVICE;
883 goto done;
884 }
885
886 werr = smbconf_reg_open_service_key(mem_ctx, ctx, service,
887 REG_KEY_READ, &key);
888 if (!W_ERROR_IS_OK(werr)) {
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 * Get the value of a global parameter.
916 *
917 * Create [global] if it does not exist.
918 */
919 WERROR smbconf_get_global_parameter(struct smbconf_ctx *ctx,
920 TALLOC_CTX *mem_ctx,
921 const char *param,
922 char **valstr)
923 {
924 WERROR werr;
925
926 werr = smbconf_global_check(ctx);
927 if (W_ERROR_IS_OK(werr)) {
928 werr = smbconf_get_parameter(ctx, mem_ctx, GLOBAL_NAME, param,
929 valstr);
930 }
931
932 return werr;
933 }
934
935 /**
936 * delete a parameter from configuration
937 */
938 WERROR smbconf_delete_parameter(struct smbconf_ctx *ctx,
939 const char *service, const char *param)
940 {
941 struct registry_key *key = NULL;
942 WERROR werr = WERR_OK;
943 TALLOC_CTX *mem_ctx = talloc_stackframe();
944
945 if (!smbconf_share_exists(ctx, service)) {
946 return WERR_NO_SUCH_SERVICE;
947 }
948
949 werr = smbconf_reg_open_service_key(mem_ctx, ctx, service,
950 REG_KEY_ALL, &key);
951 if (!W_ERROR_IS_OK(werr)) {
952 goto done;
953 }
954
955 if (!smbconf_value_exists(key, param)) {
956 werr = WERR_INVALID_PARAM;
957 goto done;
958 }
959
960 werr = reg_deletevalue(key, param);
961
962 done:
963 TALLOC_FREE(mem_ctx);
964 return werr;
965 }
966
967 /**
968 * Delete a global parameter.
969 *
970 * Create [global] if it does not exist.
971 */
972 WERROR smbconf_delete_global_parameter(struct smbconf_ctx *ctx,
973 const char *param)
974 {
975 WERROR werr;
976
977 werr = smbconf_global_check(ctx);
978 if (W_ERROR_IS_OK(werr)) {
979 werr = smbconf_delete_parameter(ctx, GLOBAL_NAME, param);
980 }
981
982 return werr;
983 }
Samba GIT mirror