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