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