?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r23749: Simplify prototype of reg_setvalue_internal:
[Samba.git] / source / utils / net_conf.c
blob9d4f4601e4174b777588a20da8200b843f56eba1
1 /*
2 * Samba Unix/Linux SMB client library
3 * Distributed SMB/CIFS Server Management Utility
4 * Local configuration interface
5 * Copyright (C) Michael Adam 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 2 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, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
22 /*
23 * This is an interface to the configuration stored inside the
24 * samba registry. In the future there might be support for other
25 * configuration backends as well.
26 */
27
28 #include "includes.h"
29 #include "utils/net.h"
30
31 /*
32 * usage functions
33 */
34
35 static int net_conf_list_usage(int argc, const char **argv)
36 {
37 d_printf("USAGE: net conf list\n");
38 return -1;
39 }
40
41 static int net_conf_import_usage(int argc, const char**argv)
42 {
43 d_printf("USAGE: net conf import [--test|-T] <filename> [<servicename>]\n"
44 "\t[--test|-T] testmode - do not act, just print "
45 "what would be done\n"
46 "\t<servicename> only import service <servicename>, "
47 "ignore the rest\n");
48 return -1;
49 }
50
51 static int net_conf_listshares_usage(int argc, const char **argv)
52 {
53 d_printf("USAGE: net conf listshares\n");
54 return -1;
55 }
56
57 static int net_conf_drop_usage(int argc, const char **argv)
58 {
59 d_printf("USAGE: net conf drop\n");
60 return -1;
61 }
62
63 static int net_conf_showshare_usage(int argc, const char **argv)
64 {
65 d_printf("USAGE: net conf showshare <sharename>\n");
66 return -1;
67 }
68
69 static int net_conf_addshare_usage(int argc, const char **argv)
70 {
71 d_printf("USAGE: net conf addshare <sharename> <path> "
72 "[writeable={y|N} [guest_ok={y|N} [<comment>]]\n"
73 "\t<sharename> the new share name.\n"
74 "\t<path> the path on the filesystem to export.\n"
75 "\twriteable={y|N} set \"writeable to \"yes\" or "
76 "\"no\" (default) on this share.\n"
77 "\tguest_ok={y|N} set \"guest ok\" to \"yes\" or "
78 "\"no\" (default) on this share.\n"
79 "\t<comment> optional comment for the new share.\n");
80 return -1;
81 }
82
83 static int net_conf_delshare_usage(int argc, const char **argv)
84 {
85 d_printf("USAGE: net conf delshare <sharename>\n");
86 return -1;
87 }
88
89 static int net_conf_setparm_usage(int argc, const char **argv)
90 {
91 d_printf("USAGE: net conf setparm <section> <param> <value>\n");
92 return -1;
93 }
94
95 static int net_conf_getparm_usage(int argc, const char **argv)
96 {
97 d_printf("USAGE: net conf getparm <section> <param>\n");
98 return -1;
99 }
100
101 static int net_conf_delparm_usage(int argc, const char **argv)
102 {
103 d_printf("USAGE: net conf delparm <section> <param>\n");
104 return -1;
105 }
106
107
108 /*
109 * Helper functions
110 */
111
112 static char *format_value(TALLOC_CTX *mem_ctx, struct registry_value *value)
113 {
114 char *result = NULL;
115
116 /* what if mem_ctx = NULL? */
117
118 switch (value->type) {
119 case REG_DWORD:
120 result = talloc_asprintf(mem_ctx, "%d", value->v.dword);
121 break;
122 case REG_SZ:
123 case REG_EXPAND_SZ:
124 result = talloc_asprintf(mem_ctx, "%s", value->v.sz.str);
125 break;
126 case REG_MULTI_SZ: {
127 uint32 j;
128 for (j = 0; j < value->v.multi_sz.num_strings; j++) {
129 result = talloc_asprintf(mem_ctx, "\"%s\" ",
130 value->v.multi_sz.strings[j]);
131 }
132 break;
133 }
134 case REG_BINARY:
135 result = talloc_asprintf(mem_ctx, "binary (%d bytes)",
136 (int)value->v.binary.length);
137 break;
138 default:
139 result = talloc_asprintf(mem_ctx, "<unprintable>");
140 break;
141 }
142 return result;
143 }
144
145 /*
146 * add a value to a key.
147 */
148 static WERROR reg_setvalue_internal(struct registry_key *key,
149 const char *valname,
150 const char *valstr)
151 {
152 struct registry_value val;
153 WERROR werr = WERR_OK;
154
155 ZERO_STRUCT(val);
156
157 val.type = REG_SZ;
158 val.v.sz.str = CONST_DISCARD(char *, valstr);
159 val.v.sz.len = strlen(valstr) + 1;
160
161 if (!lp_parameter_is_valid(valname)) {
162 d_fprintf(stderr, "Invalid parameter '%s' given.\n", valname);
163 werr = WERR_INVALID_PARAM;
164 goto done;
165 }
166
167 if (registry_smbconf_valname_forbidden(valname)) {
168 d_fprintf(stderr, "Parameter '%s' not allowed in registry.\n",
169 valname);
170 werr = WERR_INVALID_PARAM;
171 goto done;
172 }
173
174 if (!strequal(strrchr_m(key->key->name, '\\')+1, GLOBAL_NAME) &&
175 lp_parameter_is_global(valname))
176 {
177 d_fprintf(stderr, "Global paramter '%s' not allowed in "
178 "service definition ('%s').\n", valname,
179 strrchr_m(key->key->name, '\\')+1);
180 werr = WERR_INVALID_PARAM;
181 goto done;
182 }
183
184 werr = reg_setvalue(key, valname, &val);
185 if (!W_ERROR_IS_OK(werr)) {
186 d_fprintf(stderr,
187 "Error adding value '%s' to "
188 "key '%s': %s\n",
189 valname, key->key->name, dos_errstr(werr));
190 }
191
192 done:
193 return werr;
194 }
195
196 /*
197 * Open a subkey of KEY_SMBCONF (i.e a service)
198 * - variant without error output (q = quiet)-
199 */
200 static WERROR smbconf_open_path_q(TALLOC_CTX *ctx, const char *subkeyname,
201 uint32 desired_access,
202 struct registry_key **key)
203 {
204 WERROR werr = WERR_OK;
205 char *path = NULL;
206 NT_USER_TOKEN *token;
207
208 if (!(token = registry_create_admin_token(ctx))) {
209 DEBUG(1, ("Error creating admin token\n"));
210 goto done;
211 }
212
213 if (subkeyname == NULL) {
214 path = talloc_strdup(ctx, KEY_SMBCONF);
215 }
216 else {
217 path = talloc_asprintf(ctx, "%s\\%s", KEY_SMBCONF, subkeyname);
218 }
219
220 werr = reg_open_path(ctx, path, desired_access,
221 token, key);
222
223 done:
224 TALLOC_FREE(path);
225 return werr;
226 }
227
228 /*
229 * Open a subkey of KEY_SMBCONF (i.e a service)
230 * - variant with error output -
231 */
232 static WERROR smbconf_open_path(TALLOC_CTX *ctx, const char *subkeyname,
233 uint32 desired_access,
234 struct registry_key **key)
235 {
236 WERROR werr = WERR_OK;
237
238 werr = smbconf_open_path_q(ctx, subkeyname, desired_access, key);
239 if (!W_ERROR_IS_OK(werr)) {
240 d_fprintf(stderr, "Error opening registry path '%s\\%s': %s\n",
241 KEY_SMBCONF,
242 (subkeyname == NULL) ? "" : subkeyname,
243 dos_errstr(werr));
244 }
245
246 return werr;
247 }
248
249 /*
250 * open the base key KEY_SMBCONF
251 */
252 static WERROR smbconf_open_basepath(TALLOC_CTX *ctx, uint32 desired_access,
253 struct registry_key **key)
254 {
255 return smbconf_open_path(ctx, NULL, desired_access, key);
256 }
257
258 /*
259 * delete a subkey of KEY_SMBCONF
260 */
261 static WERROR reg_delkey_internal(TALLOC_CTX *ctx, const char *keyname)
262 {
263 WERROR werr = WERR_OK;
264 struct registry_key *key = NULL;
265
266 werr = smbconf_open_basepath(ctx, REG_KEY_WRITE, &key);
267 if (!W_ERROR_IS_OK(werr)) {
268 goto done;
269 }
270
271 werr = reg_deletekey_recursive(key, key, keyname);
272 if (!W_ERROR_IS_OK(werr)) {
273 d_fprintf(stderr, "Error deleting registry key %s\\%s: %s\n",
274 KEY_SMBCONF, keyname, dos_errstr(werr));
275 }
276
277 done:
278 TALLOC_FREE(key);
279 return werr;
280 }
281
282 /*
283 * create a subkey of KEY_SMBCONF
284 */
285 static WERROR reg_createkey_internal(TALLOC_CTX *ctx,
286 const char * subkeyname,
287 struct registry_key **newkey)
288 {
289 WERROR werr = WERR_OK;
290 struct registry_key *create_parent = NULL;
291 TALLOC_CTX *create_ctx;
292 enum winreg_CreateAction action = REG_ACTION_NONE;
293
294 /* create a new talloc ctx for creation. it will hold
295 * the intermediate parent key (SMBCONF) for creation
296 * and will be destroyed when leaving this function... */
297 if (!(create_ctx = talloc_new(ctx))) {
298 werr = WERR_NOMEM;
299 goto done;
300 }
301
302 werr = smbconf_open_basepath(create_ctx, REG_KEY_WRITE, &create_parent);
303 if (!W_ERROR_IS_OK(werr)) {
304 goto done;
305 }
306
307 werr = reg_createkey(ctx, create_parent, subkeyname,
308 REG_KEY_WRITE, newkey, &action);
309 if (W_ERROR_IS_OK(werr) && (action != REG_CREATED_NEW_KEY)) {
310 d_fprintf(stderr, "Key '%s' already exists.\n", subkeyname);
311 werr = WERR_ALREADY_EXISTS;
312 }
313 if (!W_ERROR_IS_OK(werr)) {
314 d_fprintf(stderr, "Error creating key %s: %s\n",
315 subkeyname, dos_errstr(werr));
316 }
317
318 done:
319 TALLOC_FREE(create_ctx);
320 return werr;
321 }
322
323 /*
324 * check if a subkey of KEY_SMBCONF of a given name exists
325 */
326 static BOOL smbconf_key_exists(TALLOC_CTX *ctx, const char *subkeyname)
327 {
328 BOOL ret = False;
329 WERROR werr = WERR_OK;
330 TALLOC_CTX *mem_ctx;
331 struct registry_key *key;
332
333 if (!(mem_ctx = talloc_new(ctx))) {
334 d_fprintf(stderr, "ERROR: Out of memory...!\n");
335 goto done;
336 }
337
338 werr = smbconf_open_path_q(mem_ctx, subkeyname, REG_KEY_READ, &key);
339 if (W_ERROR_IS_OK(werr)) {
340 ret = True;
341 }
342
343 done:
344 TALLOC_FREE(mem_ctx);
345 return ret;
346 }
347
348 static BOOL smbconf_value_exists(TALLOC_CTX *ctx, struct registry_key *key,
349 const char *param)
350 {
351 BOOL ret = False;
352 WERROR werr = WERR_OK;
353 struct registry_value *value = NULL;
354
355 werr = reg_queryvalue(ctx, key, param, &value);
356 if (W_ERROR_IS_OK(werr)) {
357 ret = True;
358 }
359
360 TALLOC_FREE(value);
361 return ret;
362 }
363
364 static WERROR list_values(TALLOC_CTX *ctx, struct registry_key *key)
365 {
366 WERROR werr = WERR_OK;
367 uint32 idx = 0;
368 struct registry_value *valvalue = NULL;
369 char *valname = NULL;
370
371 for (idx = 0;
372 W_ERROR_IS_OK(werr = reg_enumvalue(ctx, key, idx, &valname,
373 &valvalue));
374 idx++)
375 {
376 d_printf("\t%s = %s\n", valname, format_value(ctx, valvalue));
377 }
378 if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
379 d_fprintf(stderr, "Error enumerating values: %s\n",
380 dos_errstr(werr));
381 goto done;
382 }
383 werr = WERR_OK;
384
385 done:
386 return werr;
387 }
388
389 static WERROR drop_smbconf_internal(TALLOC_CTX *ctx)
390 {
391 char *path, *p;
392 WERROR werr = WERR_OK;
393 NT_USER_TOKEN *token;
394 struct registry_key *parent_key = NULL;
395 struct registry_key *new_key = NULL;
396 TALLOC_CTX* tmp_ctx = NULL;
397 enum winreg_CreateAction action;
398
399 tmp_ctx = talloc_new(ctx);
400 if (tmp_ctx == NULL) {
401 werr = WERR_NOMEM;
402 goto done;
403 }
404
405 if (!(token = registry_create_admin_token(tmp_ctx))) {
406 /* what is the appropriate error code here? */
407 werr = WERR_CAN_NOT_COMPLETE;
408 goto done;
409 }
410
411 path = talloc_strdup(tmp_ctx, KEY_SMBCONF);
412 if (path == NULL) {
413 d_fprintf(stderr, "ERROR: out of memory!\n");
414 werr = WERR_NOMEM;
415 goto done;
416 }
417 p = strrchr(path, '\\');
418 *p = '\0';
419 werr = reg_open_path(tmp_ctx, path, REG_KEY_WRITE, token, &parent_key);
420
421 if (!W_ERROR_IS_OK(werr)) {
422 goto done;
423 }
424
425 werr = reg_deletekey_recursive(tmp_ctx, parent_key, p+1);
426
427 if (!W_ERROR_IS_OK(werr)) {
428 goto done;
429 }
430
431 werr = reg_createkey(tmp_ctx, parent_key, p+1, REG_KEY_WRITE,
432 &new_key, &action);
433
434 done:
435 TALLOC_FREE(tmp_ctx);
436 return werr;
437 }
438
439 static char *parm_valstr(TALLOC_CTX *ctx, struct parm_struct *parm,
440 struct share_params *share)
441 {
442 char *valstr = NULL;
443 int i = 0;
444 void *ptr = parm->ptr;
445
446 if (parm->p_class == P_LOCAL && share->service >= 0) {
447 ptr = lp_local_ptr(share->service, ptr);
448 }
449
450 switch (parm->type) {
451 case P_CHAR:
452 valstr = talloc_asprintf(ctx, "%c", *(char *)ptr);
453 break;
454 case P_STRING:
455 case P_USTRING:
456 valstr = talloc_asprintf(ctx, "%s", *(char **)ptr);
457 break;
458 case P_GSTRING:
459 case P_UGSTRING:
460 valstr = talloc_asprintf(ctx, "%s", (char *)ptr);
461 break;
462 case P_BOOL:
463 valstr = talloc_asprintf(ctx, "%s", BOOLSTR(*(BOOL *)ptr));
464 break;
465 case P_BOOLREV:
466 valstr = talloc_asprintf(ctx, "%s", BOOLSTR(!*(BOOL *)ptr));
467 break;
468 case P_ENUM:
469 for (i = 0; parm->enum_list[i].name; i++) {
470 if (*(int *)ptr == parm->enum_list[i].value)
471 {
472 valstr = talloc_asprintf(ctx, "%s",
473 parm->enum_list[i].name);
474 break;
475 }
476 }
477 break;
478 case P_OCTAL:
479 valstr = talloc_asprintf(ctx, "%s", octal_string(*(int *)ptr));
480 break;
481 case P_LIST:
482 valstr = talloc_strdup(ctx, "");
483 if ((char ***)ptr && *(char ***)ptr) {
484 char **list = *(char ***)ptr;
485 for (; *list; list++) {
486 /* surround strings with whitespace
487 * in double quotes */
488 if (strchr_m(*list, ' '))
489 {
490 valstr = talloc_asprintf_append(
491 valstr, "\"%s\"%s",
492 *list,
493 ((*(list+1))?", ":""));
494 }
495 else {
496 valstr = talloc_asprintf_append(
497 valstr, "%s%s", *list,
498 ((*(list+1))?", ":""));
499 }
500 }
501 }
502 break;
503 case P_INTEGER:
504 valstr = talloc_asprintf(ctx, "%d", *(int *)ptr);
505 break;
506 case P_SEP:
507 break;
508 default:
509 valstr = talloc_asprintf(ctx, "<type unimplemented>\n");
510 break;
511 }
512
513 return valstr;
514 }
515
516 static int import_process_service(TALLOC_CTX *ctx,
517 struct share_params *share)
518 {
519 int ret = -1;
520 struct parm_struct *parm;
521 int pnum = 0;
522 const char *servicename;
523 struct registry_key *key;
524 WERROR werr;
525 char *valstr = NULL;
526 TALLOC_CTX *tmp_ctx = NULL;
527
528 tmp_ctx = talloc_new(ctx);
529 if (tmp_ctx == NULL) {
530 werr = WERR_NOMEM;
531 goto done;
532 }
533
534 servicename = (share->service == GLOBAL_SECTION_SNUM)?
535 GLOBAL_NAME : lp_servicename(share->service);
536
537 if (opt_testmode) {
538 d_printf("[%s]\n", servicename);
539 }
540 else {
541 if (smbconf_key_exists(tmp_ctx, servicename)) {
542 werr = reg_delkey_internal(tmp_ctx, servicename);
543 if (!W_ERROR_IS_OK(werr)) {
544 goto done;
545 }
546 }
547 werr = reg_createkey_internal(tmp_ctx, servicename, &key);
548 if (!W_ERROR_IS_OK(werr)) {
549 goto done;
550 }
551 }
552
553 while ((parm = lp_next_parameter(share->service, &pnum, 0)))
554 {
555 if ((share->service < 0 && parm->p_class == P_LOCAL)
556 && !(parm->flags & FLAG_GLOBAL))
557 continue;
558
559 valstr = parm_valstr(tmp_ctx, parm, share);
560
561 if (parm->type != P_SEP) {
562 if (opt_testmode) {
563 d_printf("\t%s = %s\n", parm->label, valstr);
564 }
565 else {
566 werr = reg_setvalue_internal(key, parm->label,
567 valstr);
568 if (!W_ERROR_IS_OK(werr)) {
569 goto done;
570 }
571 }
572 }
573 }
574
575 if (opt_testmode) {
576 d_printf("\n");
577 }
578
579 ret = 0;
580
581 done:
582 TALLOC_FREE(tmp_ctx);
583 return ret;
584 }
585
586
587 /*
588 * the conf functions
589 */
590
591 int net_conf_list(int argc, const char **argv)
592 {
593 WERROR werr = WERR_OK;
594 int ret = -1;
595 TALLOC_CTX *ctx;
596 struct registry_key *base_key = NULL;
597 struct registry_key *sub_key = NULL;
598 uint32 idx_key = 0;
599 char *subkey_name = NULL;
600
601 ctx = talloc_init("list");
602
603 if (argc != 0) {
604 net_conf_list_usage(argc, argv);
605 goto done;
606 }
607
608 werr = smbconf_open_basepath(ctx, REG_KEY_READ, &base_key);
609 if (!W_ERROR_IS_OK(werr)) {
610 goto done;
611 }
612
613 if (smbconf_key_exists(ctx, GLOBAL_NAME)) {
614 werr = reg_openkey(ctx, base_key, GLOBAL_NAME,
615 REG_KEY_READ, &sub_key);
616 if (!W_ERROR_IS_OK(werr)) {
617 d_fprintf(stderr, "Error opening subkey '%s' : %s\n",
618 subkey_name, dos_errstr(werr));
619 goto done;
620 }
621 d_printf("[%s]\n", GLOBAL_NAME);
622 if (!W_ERROR_IS_OK(list_values(ctx, sub_key))) {
623 goto done;
624 }
625 d_printf("\n");
626 }
627
628 for (idx_key = 0;
629 W_ERROR_IS_OK(werr = reg_enumkey(ctx, base_key, idx_key,
630 &subkey_name, NULL));
631 idx_key++)
632 {
633 if (strequal(subkey_name, GLOBAL_NAME)) {
634 continue;
635 }
636 d_printf("[%s]\n", subkey_name);
637
638 werr = reg_openkey(ctx, base_key, subkey_name,
639 REG_KEY_READ, &sub_key);
640 if (!W_ERROR_IS_OK(werr)) {
641 d_fprintf(stderr,
642 "Error opening subkey '%s': %s\n",
643 subkey_name, dos_errstr(werr));
644 goto done;
645 }
646 if (!W_ERROR_IS_OK(list_values(ctx, sub_key))) {
647 goto done;
648 }
649 d_printf("\n");
650 }
651 if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
652 d_fprintf(stderr, "Error enumerating subkeys: %s\n",
653 dos_errstr(werr));
654 goto done;
655 }
656
657 ret = 0;
658
659 done:
660 TALLOC_FREE(ctx);
661 return ret;
662 }
663
664 int net_conf_import(int argc, const char **argv)
665 {
666 int ret = -1;
667 const char *filename = NULL;
668 const char *servicename = NULL;
669 BOOL service_found = False;
670 TALLOC_CTX *ctx;
671 struct share_iterator *shares;
672 struct share_params *share;
673 struct share_params global_share = { GLOBAL_SECTION_SNUM };
674
675 ctx = talloc_init("net_conf_import");
676
677 switch (argc) {
678 case 0:
679 default:
680 net_conf_import_usage(argc, argv);
681 goto done;
682 case 2:
683 servicename = argv[1];
684 case 1:
685 filename = argv[0];
686 break;
687 }
688
689 DEBUG(3,("net_conf_import: reading configuration from file %s.\n",
690 filename));
691
692 if (!lp_load(filename,
693 False, /* global_only */
694 True, /* save_defaults */
695 False, /* add_ipc */
696 True)) /* initialize_globals */
697 {
698 d_fprintf(stderr, "Error parsing configuration file.\n");
699 goto done;
700 }
701
702 if (opt_testmode) {
703 d_printf("\nTEST MODE - would import the following configuration:\n\n");
704 }
705
706 if ((servicename == NULL) || strequal(servicename, GLOBAL_NAME)) {
707 service_found = True;
708 if (import_process_service(ctx, &global_share) != 0) {
709 goto done;
710 }
711 }
712
713 if (service_found && (servicename != NULL)) {
714 ret = 0;
715 goto done;
716 }
717
718 if (!(shares = share_list_all(ctx))) {
719 d_fprintf(stderr, "Could not list shares...\n");
720 goto done;
721 }
722 while ((share = next_share(shares)) != NULL) {
723 if ((servicename == NULL)
724 || strequal(servicename, lp_servicename(share->service)))
725 {
726 service_found = True;
727 if (import_process_service(ctx, share)!= 0) {
728 goto done;
729 }
730 }
731 }
732
733 if ((servicename != NULL) && !service_found) {
734 d_printf("Share %s not found in file %s\n",
735 servicename, filename);
736 goto done;
737
738 }
739
740 ret = 0;
741
742 done:
743 TALLOC_FREE(ctx);
744 return ret;
745 }
746
747 int net_conf_listshares(int argc, const char **argv)
748 {
749 WERROR werr = WERR_OK;
750 int ret = -1;
751 struct registry_key *key;
752 uint32 idx = 0;
753 char *subkey_name = NULL;
754 TALLOC_CTX *ctx;
755
756 ctx = talloc_init("listshares");
757
758 if (argc != 0) {
759 net_conf_listshares_usage(argc, argv);
760 goto done;
761 }
762
763 werr = smbconf_open_basepath(ctx, SEC_RIGHTS_ENUM_SUBKEYS, &key);
764 if (!W_ERROR_IS_OK(werr)) {
765 goto done;
766 }
767
768 for (idx = 0;
769 W_ERROR_IS_OK(werr = reg_enumkey(ctx, key, idx,
770 &subkey_name, NULL));
771 idx++)
772 {
773 d_printf("%s\n", subkey_name);
774 }
775 if (! W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
776 d_fprintf(stderr, "Error enumerating subkeys: %s\n",
777 dos_errstr(werr));
778 goto done;
779 }
780
781 ret = 0;
782
783 done:
784 TALLOC_FREE(ctx);
785 return ret;
786 }
787
788 int net_conf_drop(int argc, const char **argv)
789 {
790 int ret = -1;
791 WERROR werr;
792
793 if (argc != 0) {
794 net_conf_drop_usage(argc, argv);
795 goto done;
796 }
797
798 werr = drop_smbconf_internal(NULL);
799 if (!W_ERROR_IS_OK(werr)) {
800 d_fprintf(stderr, "Error deleting configuration: %s\n",
801 dos_errstr(werr));
802 goto done;
803 }
804
805 ret = 0;
806
807 done:
808 return ret;
809 }
810
811 int net_conf_showshare(int argc, const char **argv)
812 {
813 int ret = -1;
814 WERROR werr = WERR_OK;
815 struct registry_key *key = NULL;
816 TALLOC_CTX *ctx;
817
818 ctx = talloc_init("showshare");
819
820 if (argc != 1) {
821 net_conf_showshare_usage(argc, argv);
822 goto done;
823 }
824
825 werr = smbconf_open_path(ctx, argv[0], REG_KEY_READ, &key);
826 if (!W_ERROR_IS_OK(werr)) {
827 goto done;
828 }
829
830 d_printf("[%s]\n", argv[0]);
831
832 if (!W_ERROR_IS_OK(list_values(ctx, key))) {
833 goto done;
834 }
835
836 ret = 0;
837
838 done:
839 TALLOC_FREE(ctx);
840 return ret;
841 }
842
843 int net_conf_addshare(int argc, const char **argv)
844 {
845 int ret = -1;
846 WERROR werr = WERR_OK;
847 struct registry_key *newkey = NULL;
848 char *sharename = NULL;
849 const char *path = NULL;
850 const char *comment = NULL;
851 const char *guest_ok = "no";
852 const char *writeable = "no";
853 SMB_STRUCT_STAT sbuf;
854
855 switch (argc) {
856 case 0:
857 case 1:
858 default:
859 net_conf_addshare_usage(argc, argv);
860 goto done;
861 case 5:
862 comment = argv[4];
863 case 4:
864 if (!strnequal(argv[3], "guest_ok=", 9)) {
865 net_conf_addshare_usage(argc, argv);
866 goto done;
867 }
868 switch (argv[3][9]) {
869 case 'y':
870 case 'Y':
871 guest_ok = "yes";
872 break;
873 case 'n':
874 case 'N':
875 guest_ok = "no";
876 break;
877 default:
878 net_conf_addshare_usage(argc, argv);
879 goto done;
880 }
881 case 3:
882 if (!strnequal(argv[2], "writeable=", 10)) {
883 net_conf_addshare_usage(argc, argv);
884 goto done;
885 }
886 switch (argv[2][10]) {
887 case 'y':
888 case 'Y':
889 writeable = "yes";
890 break;
891 case 'n':
892 case 'N':
893 writeable = "no";
894 break;
895 default:
896 net_conf_addshare_usage(argc, argv);
897 goto done;
898 }
899
900 case 2:
901 path = argv[1];
902 sharename = strdup_lower(argv[0]);
903 break;
904 }
905
906 /*
907 * validate arguments
908 */
909
910 /* validate share name */
911
912 if (!validate_net_name(sharename, INVALID_SHARENAME_CHARS,
913 strlen(sharename)))
914 {
915 d_fprintf(stderr, "ERROR: share name %s contains "
916 "invalid characters (any of %s)\n",
917 sharename, INVALID_SHARENAME_CHARS);
918 goto done;
919 }
920
921 if (getpwnam(sharename)) {
922 d_fprintf(stderr, "ERROR: share name %s is already a valid "
923 "system user name.\n", sharename);
924 goto done;
925 }
926
927 if (strequal(sharename, GLOBAL_NAME)) {
928 d_fprintf(stderr,
929 "ERROR: 'global' is not a valid share name.\n");
930 goto done;
931 }
932
933 /* validate path */
934
935 if (path[0] != '/') {
936 d_fprintf(stderr,
937 "Error: path '%s' is not an absolute path.\n",
938 path);
939 goto done;
940 }
941
942 if (sys_stat(path, &sbuf) != 0) {
943 d_fprintf(stderr,
944 "ERROR: cannot stat path '%s' to ensure "
945 "this is a directory.\n"
946 "Error was '%s'.\n",
947 path, strerror(errno));
948 goto done;
949 }
950
951 if (!S_ISDIR(sbuf.st_mode)) {
952 d_fprintf(stderr,
953 "ERROR: path '%s' is not a directory.\n",
954 path);
955 goto done;
956 }
957
958 /*
959 * create the share
960 */
961
962 werr = reg_createkey_internal(NULL, argv[0], &newkey);
963 if (!W_ERROR_IS_OK(werr)) {
964 goto done;
965 }
966
967 /* add config params as values */
968
969 werr = reg_setvalue_internal(newkey, "path", path);
970 if (!W_ERROR_IS_OK(werr))
971 goto done;
972
973 if (comment != NULL) {
974 werr = reg_setvalue_internal(newkey, "comment", comment);
975 if (!W_ERROR_IS_OK(werr))
976 goto done;
977 }
978
979 werr = reg_setvalue_internal(newkey, "guest ok", guest_ok);
980 if (!W_ERROR_IS_OK(werr))
981 goto done;
982
983 werr = reg_setvalue_internal(newkey, "writeable", writeable);
984 if (!W_ERROR_IS_OK(werr))
985 goto done;
986
987 ret = 0;
988
989 done:
990 TALLOC_FREE(newkey);
991 SAFE_FREE(sharename);
992 return ret;
993 }
994
995 int net_conf_delshare(int argc, const char **argv)
996 {
997 int ret = -1;
998 const char *sharename = NULL;
999
1000 if (argc != 1) {
1001 net_conf_delshare_usage(argc, argv);
1002 goto done;
1003 }
1004 sharename = argv[0];
1005
1006 if (W_ERROR_IS_OK(reg_delkey_internal(NULL, sharename))) {
1007 ret = 0;
1008 }
1009 done:
1010 return ret;
1011 }
1012
1013 static int net_conf_setparm(int argc, const char **argv)
1014 {
1015 int ret = -1;
1016 WERROR werr = WERR_OK;
1017 struct registry_key *key = NULL;
1018 char *service = NULL;
1019 char *param = NULL;
1020 const char *value_str = NULL;
1021 TALLOC_CTX *ctx;
1022
1023 ctx = talloc_init("setparm");
1024
1025 if (argc != 3) {
1026 net_conf_setparm_usage(argc, argv);
1027 goto done;
1028 }
1029 service = strdup_lower(argv[0]);
1030 param = strdup_lower(argv[1]);
1031 value_str = argv[2];
1032
1033 if (!smbconf_key_exists(ctx, service)) {
1034 werr = reg_createkey_internal(ctx, service, &key);
1035 }
1036 else {
1037 werr = smbconf_open_path(ctx, service, REG_KEY_READ, &key);
1038 }
1039 if (!W_ERROR_IS_OK(werr)) {
1040 goto done;
1041 }
1042
1043 werr = reg_setvalue_internal(key, param, value_str);
1044 if (!W_ERROR_IS_OK(werr)) {
1045 d_fprintf(stderr, "Error setting value '%s': %s\n",
1046 param, dos_errstr(werr));
1047 goto done;
1048 }
1049
1050
1051 ret = 0;
1052
1053 done:
1054 SAFE_FREE(service);
1055 TALLOC_FREE(ctx);
1056 return ret;
1057 }
1058
1059 static int net_conf_getparm(int argc, const char **argv)
1060 {
1061 int ret = -1;
1062 WERROR werr = WERR_OK;
1063 struct registry_key *key = NULL;
1064 char *service = NULL;
1065 char *param = NULL;
1066 struct registry_value *value = NULL;
1067 TALLOC_CTX *ctx;
1068
1069 ctx = talloc_init("getparm");
1070
1071 if (argc != 2) {
1072 net_conf_getparm_usage(argc, argv);
1073 goto done;
1074 }
1075 service = strdup_lower(argv[0]);
1076 param = strdup_lower(argv[1]);
1077
1078 if (!smbconf_key_exists(ctx, service)) {
1079 d_fprintf(stderr,
1080 "ERROR: given service '%s' does not exist.\n",
1081 service);
1082 goto done;
1083 }
1084
1085 werr = smbconf_open_path(ctx, service, REG_KEY_READ, &key);
1086 if (!W_ERROR_IS_OK(werr)) {
1087 goto done;
1088 }
1089
1090 werr = reg_queryvalue(ctx, key, param, &value);
1091 if (!W_ERROR_IS_OK(werr)) {
1092 d_fprintf(stderr, "Error querying value '%s': %s.\n",
1093 param, dos_errstr(werr));
1094 goto done;
1095 }
1096
1097 d_printf("%s\n", format_value(ctx, value));
1098
1099 ret = 0;
1100 done:
1101 SAFE_FREE(service);
1102 SAFE_FREE(param);
1103 TALLOC_FREE(ctx);
1104 return ret;
1105 }
1106
1107 static int net_conf_delparm(int argc, const char **argv)
1108 {
1109 int ret = -1;
1110 WERROR werr = WERR_OK;
1111 struct registry_key *key = NULL;
1112 char *service = NULL;
1113 char *param = NULL;
1114 TALLOC_CTX *ctx;
1115
1116 ctx = talloc_init("delparm");
1117
1118 if (argc != 2) {
1119 net_conf_delparm_usage(argc, argv);
1120 goto done;
1121 }
1122 service = strdup_lower(argv[0]);
1123 param = strdup_lower(argv[1]);
1124
1125 if (!smbconf_key_exists(ctx, service)) {
1126 d_fprintf(stderr,
1127 "Error: given service '%s' does not exist.\n",
1128 service);
1129 goto done;
1130 }
1131
1132 werr = smbconf_open_path(ctx, service, REG_KEY_READ, &key);
1133 if (!W_ERROR_IS_OK(werr)) {
1134 goto done;
1135 }
1136
1137 if (!smbconf_value_exists(ctx, key, param)) {
1138 d_fprintf(stderr,
1139 "Error: given parameter '%s' is not set.\n",
1140 param);
1141 goto done;
1142 }
1143 werr = reg_deletevalue(key, param);
1144 if (!W_ERROR_IS_OK(werr)) {
1145 d_fprintf(stderr, "Error deleting value '%s': %s.\n",
1146 param, dos_errstr(werr));
1147 goto done;
1148 }
1149
1150 ret = 0;
1151
1152 done:
1153 return ret;
1154 }
1155
1156 /*
1157 * Entry-point for all the CONF functions.
1158 */
1159
1160 int net_conf(int argc, const char **argv)
1161 {
1162 int ret = -1;
1163 struct functable2 func[] = {
1164 {"list", net_conf_list,
1165 "Dump the complete configuration in smb.conf like format."},
1166 {"import", net_conf_import,
1167 "Import configuration from file in smb.conf format."},
1168 {"listshares", net_conf_listshares,
1169 "List the registry shares."},
1170 {"drop", net_conf_drop,
1171 "Delete the complete configuration from registry."},
1172 {"showshare", net_conf_showshare,
1173 "Show the definition of a registry share."},
1174 {"addshare", net_conf_addshare,
1175 "Create a new registry share."},
1176 {"delshare", net_conf_delshare,
1177 "Delete a registry share."},
1178 {"setparm", net_conf_setparm,
1179 "Store a parameter."},
1180 {"getparm", net_conf_getparm,
1181 "Retrieve the value of a parameter."},
1182 {"delparm", net_conf_delparm,
1183 "Delete a parameter."},
1184 {NULL, NULL, NULL}
1185 };
1186
1187 if (!registry_init_regdb()) {
1188 d_fprintf(stderr, "Error initializing the registry!\n");
1189 goto done;
1190 }
1191
1192 ret = net_run_function2(argc, argv, "net conf", func);
1193
1194 regdb_close();
1195
1196 done:
1197 return ret;
1198 }
1199
1200 /* END */
Samba GIT mirror