?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
vfs: Make function pointer names consistent. They all end in _fn
[Samba/gebeck_regimport.git] / source3 / utils / net_rpc_conf.c
blob68d5df2edf85e4a0aec0f3dd4999f4735071f3ea
1 /*
2 * Samba Unix/Linux SMB client library
3 * Distributed SMB/CIFS Server Management Utility
4 * Local configuration interface
5 * Copyright (C) Vicentiu Ciorbaru 2011
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 /*
22 * This is an interface to Samba's configuration.
23 *
24 * This tool supports local as well as remote interaction via rpc
25 * with the configuration stored in the registry.
26 */
27
28
29 #include "includes.h"
30 #include "utils/net.h"
31 #include "rpc_client/cli_pipe.h"
32 #include "../librpc/gen_ndr/ndr_samr_c.h"
33 #include "rpc_client/init_samr.h"
34 #include "../librpc/gen_ndr/ndr_winreg_c.h"
35 #include "../libcli/registry/util_reg.h"
36 #include "rpc_client/cli_winreg.h"
37 #include "lib/smbconf/smbconf.h"
38 #include "lib/smbconf/smbconf_init.h"
39 #include "lib/smbconf/smbconf_reg.h"
40 #include "lib/param/loadparm.h"
41
42
43
44 /* internal functions */
45 /**********************************************************
46 *
47 * usage functions
48 *
49 **********************************************************/
50 const char confpath[100] = "Software\\Samba\\smbconf";
51
52 static int rpc_conf_list_usage(struct net_context *c, int argc,
53 const char **argv)
54 {
55 d_printf("%s net rpc conf list\n", _("Usage:"));
56 return -1;
57 }
58
59 static int rpc_conf_listshares_usage(struct net_context *c, int argc,
60 const char **argv)
61 {
62 d_printf("%s net rpc conf listshares\n", _("Usage:"));
63 return -1;
64 }
65
66 static int rpc_conf_delshare_usage(struct net_context *c, int argc,
67 const char **argv)
68 {
69 d_printf("%s\n%s",
70 _("Usage:"),
71 _("net rpc conf delshare <sharename>\n"));
72 return -1;
73 }
74
75 static int rpc_conf_addshare_usage(struct net_context *c, int argc,
76 const char **argv)
77 {
78 d_printf("%s\n%s",
79 _("Usage:"),
80 _(" net rpc conf addshare <sharename> <path> "
81 "[writeable={y|N} [guest_ok={y|N} [<comment>]]]\n"
82 "\t<sharename> the new share name.\n"
83 "\t<path> the path on the filesystem to export.\n"
84 "\twriteable={y|N} set \"writeable to \"yes\" or "
85 "\"no\" (default) on this share.\n"
86 "\tguest_ok={y|N} set \"guest ok\" to \"yes\" or "
87 "\"no\" (default) on this share.\n"
88 "\t<comment> optional comment for the new share.\n"));
89 return -1;
90
91 }
92
93 static int rpc_conf_import_usage(struct net_context *c, int argc,
94 const char**argv)
95 {
96 d_printf("%s\n%s",
97 _("Usage:"),
98 _(" net rpc conf import [--test|-T] <filename> "
99 "[<servicename>]\n"
100 "\t[--test|-T] testmode - do not act, just print "
101 "what would be done\n"
102 "\t<servicename> only import service <servicename>, "
103 "ignore the rest\n"));
104 return -1;
105 }
106
107 static int rpc_conf_showshare_usage(struct net_context *c, int argc,
108 const char **argv)
109 {
110 d_printf("%s\n%s",
111 _("Usage:"),
112 _("net rpc conf showshare <sharename>\n"));
113 return -1;
114 }
115
116 static int rpc_conf_drop_usage(struct net_context *c, int argc,
117 const char **argv)
118 {
119 d_printf("%s\nnet rpc conf drop\n", _("Usage:"));
120 return -1;
121 }
122
123 static int rpc_conf_getparm_usage(struct net_context *c, int argc,
124 const char **argv)
125 {
126 d_printf("%s\nnet rpc conf getparm <sharename> <parameter>\n",
127 _("Usage:"));
128 return -1;
129 }
130
131 static int rpc_conf_setparm_usage(struct net_context *c, int argc,
132 const char **argv)
133 {
134 d_printf("%s\n%s",
135 _("Usage:"),
136 _(" net rpc conf setparm <section> <param> <value>\n"));
137 return -1;
138 }
139
140 static int rpc_conf_delparm_usage(struct net_context *c, int argc,
141 const char **argv)
142 {
143 d_printf("%s\nnet rpc conf delparm <sharename> <parameter>\n",
144 _("Usage:"));
145 return -1;
146 }
147
148 static int rpc_conf_getincludes_usage(struct net_context *c, int argc,
149 const char **argv)
150 {
151 d_printf("%s\nnet rpc conf getincludes <sharename>\n",
152 _("Usage:"));
153 return -1;
154 }
155
156 static int rpc_conf_setincludes_usage(struct net_context *c, int argc,
157 const char **argv)
158 {
159 d_printf("%s\nnet rpc conf setincludes <sharename> [<filename>]*\n",
160 _("Usage:"));
161 return -1;
162 }
163
164 static int rpc_conf_delincludes_usage(struct net_context *c, int argc,
165 const char **argv)
166 {
167 d_printf("%s\nnet rpc conf delincludes <sharename>\n",
168 _("Usage:"));
169 return -1;
170 }
171
172 /**********************************************************
173 *
174 * helper functions
175 *
176 **********************************************************/
177
178 static bool rpc_conf_reg_valname_forbidden(const char * valname)
179 {
180 const char *forbidden_valnames[] = {
181 "lock directory",
182 "lock dir",
183 "config backend",
184 "include",
185 "includes", /* this has a special meaning internally */
186 NULL
187 };
188 const char **forbidden = NULL;
189
190 for (forbidden = forbidden_valnames; *forbidden != NULL; forbidden++) {
191 if (strwicmp(valname, *forbidden) == 0) {
192 return true;
193 }
194 }
195 return false;
196
197 }
198
199 /*
200 * The function deletes a registry value with the name 'value' from the share
201 * with the name 'share_name'. 'parent_hnd' is the handle for the smbconf key.
202 */
203 static NTSTATUS rpc_conf_del_value(TALLOC_CTX *mem_ctx,
204 struct dcerpc_binding_handle *b,
205 struct policy_handle *parent_hnd,
206 const char *share_name,
207 const char *value,
208 WERROR *werr)
209 {
210
211 TALLOC_CTX *frame = talloc_stackframe();
212 NTSTATUS status = NT_STATUS_OK;
213 WERROR result = WERR_OK;
214 WERROR _werr;
215
216 struct winreg_String keyname, valuename;
217 struct policy_handle child_hnd;
218
219 ZERO_STRUCT(child_hnd);
220 ZERO_STRUCT(keyname);
221 ZERO_STRUCT(valuename);
222
223 keyname.name = share_name;
224 valuename.name = value;
225
226 status = dcerpc_winreg_OpenKey(b, frame, parent_hnd, keyname, 0,
227 REG_KEY_WRITE, &child_hnd, &result);
228
229 if (!(NT_STATUS_IS_OK(status))) {
230 d_fprintf(stderr, _("Failed to open key '%s': %s\n"),
231 keyname.name, nt_errstr(status));
232 goto error;
233 }
234
235 if (!(W_ERROR_IS_OK(result))) {
236 d_fprintf(stderr, _("Failed to open key '%s': %s\n"),
237 keyname.name, win_errstr(result));
238 goto error;
239 }
240
241 status = dcerpc_winreg_DeleteValue(b,
242 frame,
243 &child_hnd,
244 valuename,
245 &result);
246
247 if (!(NT_STATUS_IS_OK(status))) {
248 d_fprintf(stderr, _("Failed to delete value %s\n"),
249 nt_errstr(status));
250 goto error;
251 }
252
253 if (!(W_ERROR_IS_OK(result))) {
254 if (W_ERROR_EQUAL(result, WERR_BADFILE)){
255 result = WERR_OK;
256 goto error;
257 }
258
259 d_fprintf(stderr, _("Failed to delete value %s\n"),
260 win_errstr(result));
261 goto error;
262 }
263
264 error:
265 *werr = result;
266
267 dcerpc_winreg_CloseKey(b, frame, &child_hnd, &_werr);
268
269 TALLOC_FREE(frame);
270 return status;;
271
272 }
273
274 /*
275 * The function sets a share in the registry with the parameters
276 * held in the smbconf_service struct
277 */
278 static NTSTATUS rpc_conf_set_share(TALLOC_CTX *mem_ctx,
279 struct dcerpc_binding_handle *b,
280 struct policy_handle *parent_hnd,
281 struct smbconf_service *service,
282 WERROR *werr)
283 {
284 TALLOC_CTX *frame = talloc_stackframe();
285
286 NTSTATUS status = NT_STATUS_OK;
287 WERROR result = WERR_OK;
288 WERROR _werr;
289 enum winreg_CreateAction action;
290 uint32_t i, j;
291
292 const char **includes;
293
294 struct winreg_String wkey, wkeyclass;
295 struct policy_handle share_hnd;
296
297 ZERO_STRUCT(share_hnd);
298 ZERO_STRUCT(wkey);
299 ZERO_STRUCT(wkeyclass);
300
301 wkey.name = service->name;
302 wkeyclass.name = "";
303 action = REG_ACTION_NONE;
304
305 status = dcerpc_winreg_CreateKey(b,
306 frame,
307 parent_hnd,
308 wkey,
309 wkeyclass,
310 0,
311 REG_KEY_ALL,
312 NULL,
313 &share_hnd,
314 &action,
315 &result);
316
317 if (!NT_STATUS_IS_OK(status)) {
318 d_printf("winreg_CreateKey: Could not create smbconf key\n");
319 goto error;
320 }
321
322 if (!W_ERROR_IS_OK(result)) {
323 d_printf("winreg_CreateKey: Could not create smbconf key\n");
324 goto error;
325 }
326
327 for (i = 0; i < service->num_params; i++) {
328 if (strequal(service->param_names[i], "include") == 0)
329 {
330
331 status = dcerpc_winreg_set_sz(frame, b, &share_hnd,
332 service->param_names[i],
333 service->param_values[i],
334 &result);
335
336 if (!(NT_STATUS_IS_OK(status))) {
337 d_fprintf(stderr,
338 "ERROR: Share: '%s'\n"
339 "Could not set parameter '%s'"
340 " with value %s\n %s\n",
341 service->name,
342 service->param_names[i],
343 service->param_values[i],
344 nt_errstr(status));
345 goto error;
346 }
347
348 if (!(W_ERROR_IS_OK(result))) {
349 d_fprintf(stderr,
350 "ERROR: Share: '%s'\n"
351 "Could not set parameter '%s'"
352 " with value %s\n %s\n",
353 service->name,
354 service->param_names[i],
355 service->param_values[i],
356 win_errstr(result));
357 goto error;
358 }
359 } else {
360
361 includes = talloc_zero_array(frame,
362 const char *,
363 service->num_params + 1);
364 if (includes == NULL) {
365 result = WERR_NOMEM;
366 d_fprintf(stderr, "ERROR: out of memory\n");
367 goto error;
368 }
369
370 for (j = i; j < service->num_params; j++) {
371
372 includes[j - i] = talloc_strdup(
373 frame,
374 service->param_values[j]);
375
376 if (includes[j-i] == NULL) {
377 result = WERR_NOMEM;
378 d_fprintf(stderr, "ERROR: out of memory\n");
379 goto error;
380 }
381 }
382
383 status = dcerpc_winreg_set_multi_sz(frame, b, &share_hnd,
384 "includes",
385 includes,
386 &result);
387
388 if (!(NT_STATUS_IS_OK(status))) {
389 d_fprintf(stderr, "ERROR: Share: '%s'\n"
390 "Could not set includes\n %s\n",
391 service->name,
392 nt_errstr(status));
393 goto error;
394 }
395
396 if (!(W_ERROR_IS_OK(result))) {
397 d_fprintf(stderr, "ERROR: Share: '%s'\n"
398 "Could not set includes\n %s\n",
399 service->name,
400 win_errstr(result));
401 goto error;
402 }
403
404 i = service->num_params;
405 }
406 }
407
408 error:
409 /* in case of error, should it delete the created key? */
410 if (!(W_ERROR_IS_OK(result))) {
411 status = werror_to_ntstatus(result);
412
413 }
414
415 dcerpc_winreg_CloseKey(b, frame, &share_hnd, &_werr);
416
417 TALLOC_FREE(frame);
418 return status;
419
420 }
421
422 /*
423 * The function opens the registry database and retrieves
424 * as a smbconf_service struct the share with the name
425 * 'share_name'
426 */
427 static NTSTATUS rpc_conf_get_share(TALLOC_CTX *mem_ctx,
428 struct dcerpc_binding_handle *b,
429 struct policy_handle *parent_hnd,
430 const char *share_name,
431 struct smbconf_service *share,
432 WERROR *werr)
433 {
434 TALLOC_CTX *frame = talloc_stackframe();
435
436 NTSTATUS status = NT_STATUS_OK;
437 WERROR result = WERR_OK;
438 WERROR _werr;
439 struct policy_handle child_hnd;
440 int32_t includes_cnt, includes_idx = -1;
441 uint32_t num_vals, i, param_cnt = 0;
442 const char **val_names;
443 enum winreg_Type *types;
444 DATA_BLOB *data;
445 struct winreg_String key;
446 const char **multi_s = NULL;
447 const char *s = NULL;
448 struct smbconf_service tmp_share;
449
450 ZERO_STRUCT(tmp_share);
451
452 key.name = share_name;
453 status = dcerpc_winreg_OpenKey(b, frame, parent_hnd, key, 0,
454 REG_KEY_READ, &child_hnd, &result);
455
456 if (!(NT_STATUS_IS_OK(status))) {
457 d_fprintf(stderr, _("Failed to open subkey: %s\n"),
458 nt_errstr(status));
459 goto error;
460 }
461 if (!(W_ERROR_IS_OK(result))) {
462 d_fprintf(stderr, _("Failed to open subkey: %s\n"),
463 win_errstr(result));
464 goto error;
465 }
466 /* get all the info from the share key */
467 status = dcerpc_winreg_enumvals(frame,
468 b,
469 &child_hnd,
470 &num_vals,
471 &val_names,
472 &types,
473 &data,
474 &result);
475
476 if (!(NT_STATUS_IS_OK(status))) {
477 d_fprintf(stderr, _("Failed to enumerate values: %s\n"),
478 nt_errstr(status));
479 goto error;
480 }
481 if (!(W_ERROR_IS_OK(result))) {
482 d_fprintf(stderr, _("Failed to enumerate values: %s\n"),
483 win_errstr(result));
484 goto error;
485 }
486 /* check for includes */
487 for (i = 0; i < num_vals; i++) {
488 if (strcmp(val_names[i], "includes") == 0){
489 if (!pull_reg_multi_sz(frame,
490 &data[i],
491 &multi_s))
492 {
493 result = WERR_NOMEM;
494 d_fprintf(stderr,
495 _("Failed to enumerate values: %s\n"),
496 win_errstr(result));
497 goto error;
498 }
499 includes_idx = i;
500 }
501 }
502 /* count the number of includes */
503 includes_cnt = 0;
504 if (includes_idx != -1) {
505 for (includes_cnt = 0;
506 multi_s[includes_cnt] != NULL;
507 includes_cnt ++);
508 }
509 /* place the name of the share in the smbconf_service struct */
510 tmp_share.name = talloc_strdup(frame, share_name);
511 if (tmp_share.name == NULL) {
512 result = WERR_NOMEM;
513 d_fprintf(stderr, _("Failed to create share: %s\n"),
514 win_errstr(result));
515 goto error;
516 }
517 /* place the number of parameters in the smbconf_service struct */
518 tmp_share.num_params = num_vals;
519 if (includes_idx != -1) {
520 tmp_share.num_params = num_vals + includes_cnt - 1;
521 }
522 /* allocate memory for the param_names and param_values lists */
523 tmp_share.param_names = talloc_zero_array(frame, char *, tmp_share.num_params);
524 if (tmp_share.param_names == NULL) {
525 result = WERR_NOMEM;
526 d_fprintf(stderr, _("Failed to create share: %s\n"),
527 win_errstr(result));
528 goto error;
529 }
530 tmp_share.param_values = talloc_zero_array(frame, char *, tmp_share.num_params);
531 if (tmp_share.param_values == NULL) {
532 result = WERR_NOMEM;
533 d_fprintf(stderr, _("Failed to create share: %s\n"),
534 win_errstr(result));
535 goto error;
536 }
537 /* place all params except includes */
538 for (i = 0; i < num_vals; i++) {
539 if (strcmp(val_names[i], "includes") != 0) {
540 if (!pull_reg_sz(frame, &data[i], &s)) {
541 result = WERR_NOMEM;
542 d_fprintf(stderr,
543 _("Failed to enumerate values: %s\n"),
544 win_errstr(result));
545 goto error;
546 }
547 /* place param_names */
548 tmp_share.param_names[param_cnt] = talloc_strdup(frame, val_names[i]);
549 if (tmp_share.param_names[param_cnt] == NULL) {
550 result = WERR_NOMEM;
551 d_fprintf(stderr, _("Failed to create share: %s\n"),
552 win_errstr(result));
553 goto error;
554 }
555
556 /* place param_values */
557 tmp_share.param_values[param_cnt++] = talloc_strdup(frame, s);
558 if (tmp_share.param_values[param_cnt - 1] == NULL) {
559 result = WERR_NOMEM;
560 d_fprintf(stderr, _("Failed to create share: %s\n"),
561 win_errstr(result));
562 goto error;
563 }
564 }
565 }
566 /* place the includes last */
567 for (i = 0; i < includes_cnt; i++) {
568 tmp_share.param_names[param_cnt] = talloc_strdup(frame, "include");
569 if (tmp_share.param_names[param_cnt] == NULL) {
570 result = WERR_NOMEM;
571 d_fprintf(stderr, _("Failed to create share: %s\n"),
572 win_errstr(result));
573 goto error;
574 }
575
576 tmp_share.param_values[param_cnt++] = talloc_strdup(frame, multi_s[i]);
577 if (tmp_share.param_values[param_cnt - 1] == NULL) {
578 result = WERR_NOMEM;
579 d_fprintf(stderr, _("Failed to create share: %s\n"),
580 win_errstr(result));
581 goto error;
582 }
583 }
584
585 /* move everything to the main memory ctx */
586 for (i = 0; i < param_cnt; i++) {
587 tmp_share.param_names[i] = talloc_move(mem_ctx, &tmp_share.param_names[i]);
588 tmp_share.param_values[i] = talloc_move(mem_ctx, &tmp_share.param_values[i]);
589 }
590
591 tmp_share.name = talloc_move(mem_ctx, &tmp_share.name);
592 tmp_share.param_names = talloc_move(mem_ctx, &tmp_share.param_names);
593 tmp_share.param_values = talloc_move(mem_ctx, &tmp_share.param_values);
594 /* out parameter */
595 *share = tmp_share;
596 error:
597 /* close child */
598 dcerpc_winreg_CloseKey(b, frame, &child_hnd, &_werr);
599 *werr = result;
600 TALLOC_FREE(frame);
601 return status;
602 }
603
604 /*
605 * The function prints the shares held as smbconf_service structs
606 * in a smbconf file format.
607 */
608 static int rpc_conf_print_shares(uint32_t num_shares,
609 struct smbconf_service *shares)
610 {
611
612 uint32_t share_count, param_count;
613 const char *indent = "\t";
614
615 if (num_shares == 0) {
616 return 0;
617 }
618
619 for (share_count = 0; share_count < num_shares; share_count++) {
620 d_printf("\n");
621 if (shares[share_count].name != NULL) {
622 d_printf("[%s]\n", shares[share_count].name);
623 }
624
625 for (param_count = 0;
626 param_count < shares[share_count].num_params;
627 param_count++)
628 {
629 d_printf("%s%s = %s\n",
630 indent,
631 shares[share_count].param_names[param_count],
632 shares[share_count].param_values[param_count]);
633 }
634 }
635 d_printf("\n");
636
637 return 0;
638
639 }
640
641 /*
642 * The function openes the registry key
643 * HKLM/Software/Samba/smbconf with the give access_mask
644 */
645 static NTSTATUS rpc_conf_open_conf(TALLOC_CTX *mem_ctx,
646 struct dcerpc_binding_handle *b,
647 uint32_t access_mask,
648 struct policy_handle *hive_hnd,
649 struct policy_handle *key_hnd,
650 WERROR *werr)
651 {
652 TALLOC_CTX *frame = talloc_stackframe();
653 NTSTATUS status = NT_STATUS_OK;
654 WERROR result = WERR_OK;
655 WERROR _werr;
656 struct policy_handle tmp_hive_hnd, tmp_key_hnd;
657 struct winreg_String key;
658
659 ZERO_STRUCT(key);
660
661 status = dcerpc_winreg_OpenHKLM(b, frame, NULL,
662 access_mask, &tmp_hive_hnd, &result);
663
664 /*
665 * print no error messages if it is a read only open
666 * and key does not exist
667 * error still gets returned
668 */
669
670 if (access_mask == REG_KEY_READ &&
671 W_ERROR_EQUAL(result, WERR_BADFILE))
672 {
673 goto error;
674 }
675
676 if (!(NT_STATUS_IS_OK(status))) {
677 d_fprintf(stderr, _("Failed to open hive: %s\n"),
678 nt_errstr(status));
679 goto error;
680 }
681 if (!W_ERROR_IS_OK(result)) {
682 d_fprintf(stderr, _("Failed to open hive: %s\n"),
683 win_errstr(result));
684 goto error;
685 }
686
687 key.name = confpath;
688 status = dcerpc_winreg_OpenKey(b, frame, &tmp_hive_hnd, key, 0,
689 access_mask, &tmp_key_hnd, &result);
690
691 /*
692 * print no error messages if it is a read only open
693 * and key does not exist
694 * error still gets returned
695 */
696
697 if (access_mask == REG_KEY_READ &&
698 W_ERROR_EQUAL(result, WERR_BADFILE))
699 {
700 goto error;
701 }
702
703 if (!(NT_STATUS_IS_OK(status))) {
704 d_fprintf(stderr, _("Failed to open smbconf key: %s\n"),
705 nt_errstr(status));
706 dcerpc_winreg_CloseKey(b, frame, &tmp_hive_hnd, &_werr);
707 goto error;
708 }
709 if (!(W_ERROR_IS_OK(result))) {
710 d_fprintf(stderr, _("Failed to open smbconf key: %s\n"),
711 win_errstr(result));
712 dcerpc_winreg_CloseKey(b, frame, &tmp_hive_hnd, &_werr);
713 goto error;
714 }
715
716 *hive_hnd = tmp_hive_hnd;
717 *key_hnd = tmp_key_hnd;
718
719 error:
720 TALLOC_FREE(frame);
721 *werr = result;
722
723 return status;
724 }
725
726 /**********************************************************
727 *
728 * internal functions that provide the functionality
729 * net rpc conf
730 *
731 **********************************************************/
732
733 static NTSTATUS rpc_conf_listshares_internal(struct net_context *c,
734 const struct dom_sid *domain_sid,
735 const char *domain_name,
736 struct cli_state *cli,
737 struct rpc_pipe_client *pipe_hnd,
738 TALLOC_CTX *mem_ctx,
739 int argc,
740 const char **argv )
741 {
742
743 TALLOC_CTX *frame = talloc_stackframe();
744 NTSTATUS status = NT_STATUS_OK;
745 WERROR werr = WERR_OK;
746 WERROR _werr;
747
748 struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
749
750 /* key info */
751 struct policy_handle hive_hnd, key_hnd;
752 uint32_t num_subkeys;
753 uint32_t i;
754 const char **subkeys = NULL;
755
756
757 ZERO_STRUCT(hive_hnd);
758 ZERO_STRUCT(key_hnd);
759
760
761 if (argc != 0 || c->display_usage) {
762 rpc_conf_listshares_usage(c, argc, argv);
763 status = NT_STATUS_INVALID_PARAMETER;
764 goto error;
765 }
766
767
768 status = rpc_conf_open_conf(frame,
769 b,
770 REG_KEY_READ,
771 &hive_hnd,
772 &key_hnd,
773 &werr);
774
775 if (!(NT_STATUS_IS_OK(status))) {
776 goto error;
777 }
778
779 if (!(W_ERROR_IS_OK(werr))) {
780 goto error;
781 }
782
783 status = dcerpc_winreg_enum_keys(frame,
784 b,
785 &key_hnd,
786 &num_subkeys,
787 &subkeys,
788 &werr);
789
790 if (!(NT_STATUS_IS_OK(status))) {
791 d_fprintf(stderr, _("Failed to enumerate keys: %s\n"),
792 nt_errstr(status));
793 goto error;
794 }
795
796 if (!(W_ERROR_IS_OK(werr))) {
797 d_fprintf(stderr, _("Failed to enumerate keys: %s\n"),
798 win_errstr(werr));
799 goto error;
800 }
801
802 for (i = 0; i < num_subkeys; i++) {
803 d_printf("%s\n", subkeys[i]);
804 }
805
806 error:
807 if (!(W_ERROR_IS_OK(werr))) {
808 status = werror_to_ntstatus(werr);
809 }
810
811 dcerpc_winreg_CloseKey(b, frame, &hive_hnd, &_werr);
812 dcerpc_winreg_CloseKey(b, frame, &key_hnd, &_werr);
813
814 TALLOC_FREE(frame);
815 return status;;
816 }
817
818 static NTSTATUS rpc_conf_delshare_internal(struct net_context *c,
819 const struct dom_sid *domain_sid,
820 const char *domain_name,
821 struct cli_state *cli,
822 struct rpc_pipe_client *pipe_hnd,
823 TALLOC_CTX *mem_ctx,
824 int argc,
825 const char **argv )
826 {
827
828 TALLOC_CTX *frame = talloc_stackframe();
829 NTSTATUS status = NT_STATUS_OK;
830 WERROR werr = WERR_OK;
831 WERROR _werr;
832
833 struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
834
835 /* key info */
836 struct policy_handle hive_hnd, key_hnd;
837
838 ZERO_STRUCT(hive_hnd);
839 ZERO_STRUCT(key_hnd);
840
841
842 if (argc != 1 || c->display_usage) {
843 rpc_conf_delshare_usage(c, argc, argv);
844 status = NT_STATUS_INVALID_PARAMETER;
845 goto error;
846 }
847
848 status = rpc_conf_open_conf(frame,
849 b,
850 REG_KEY_ALL,
851 &hive_hnd,
852 &key_hnd,
853 &werr);
854
855 if (!(NT_STATUS_IS_OK(status))) {
856 goto error;
857 }
858
859 if (!(W_ERROR_IS_OK(werr))) {
860 goto error;
861 }
862
863 status = dcerpc_winreg_delete_subkeys_recursive(frame,
864 b,
865 &key_hnd,
866 REG_KEY_ALL,
867 argv[0],
868 &werr);
869
870 if (!NT_STATUS_IS_OK(status)) {
871 d_fprintf(stderr,
872 "winreg_delete_subkeys: Could not delete key %s: %s\n",
873 argv[0], nt_errstr(status));
874 goto error;
875 }
876
877 if (W_ERROR_EQUAL(werr, WERR_BADFILE)){
878 d_fprintf(stderr, _("ERROR: Key does not exist\n"));
879 }
880
881
882 if (!W_ERROR_IS_OK(werr)) {
883 d_fprintf(stderr,
884 "winreg_delete_subkeys: Could not delete key %s: %s\n",
885 argv[0], win_errstr(werr));
886 goto error;
887 }
888
889 error:
890 if (!(W_ERROR_IS_OK(werr))) {
891 status = werror_to_ntstatus(werr);
892 }
893
894 dcerpc_winreg_CloseKey(b, frame, &hive_hnd, &_werr);
895 dcerpc_winreg_CloseKey(b, frame, &key_hnd, &_werr);
896
897 TALLOC_FREE(frame);
898
899 return status;
900 }
901
902 static NTSTATUS rpc_conf_list_internal(struct net_context *c,
903 const struct dom_sid *domain_sid,
904 const char *domain_name,
905 struct cli_state *cli,
906 struct rpc_pipe_client *pipe_hnd,
907 TALLOC_CTX *mem_ctx,
908 int argc,
909 const char **argv )
910 {
911
912 TALLOC_CTX *frame = talloc_stackframe();
913 NTSTATUS status = NT_STATUS_OK;
914 WERROR werr = WERR_OK;
915 WERROR _werr;
916
917 struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
918
919 /* key info */
920 struct policy_handle hive_hnd, key_hnd;
921 uint32_t num_subkeys;
922 uint32_t i;
923 struct smbconf_service *shares;
924 const char **subkeys = NULL;
925
926
927 ZERO_STRUCT(hive_hnd);
928 ZERO_STRUCT(key_hnd);
929
930
931 if (argc != 0 || c->display_usage) {
932 rpc_conf_list_usage(c, argc, argv);
933 status = NT_STATUS_INVALID_PARAMETER;
934 goto error;
935 }
936
937 status = rpc_conf_open_conf(frame,
938 b,
939 REG_KEY_READ,
940 &hive_hnd,
941 &key_hnd,
942 &werr);
943
944 if (!(NT_STATUS_IS_OK(status))) {
945 goto error;
946 }
947
948 if (!(W_ERROR_IS_OK(werr))) {
949 goto error;
950 }
951
952 status = dcerpc_winreg_enum_keys(frame,
953 b,
954 &key_hnd,
955 &num_subkeys,
956 &subkeys,
957 &werr);
958
959 if (!(NT_STATUS_IS_OK(status))) {
960 d_fprintf(stderr, _("Failed to enumerate keys: %s\n"),
961 nt_errstr(status));
962 goto error;
963 }
964
965 if (!(W_ERROR_IS_OK(werr))) {
966 d_fprintf(stderr, _("Failed to enumerate keys: %s\n"),
967 win_errstr(werr));
968 goto error;
969 }
970
971 if (num_subkeys == 0) {
972 dcerpc_winreg_CloseKey(b, frame, &hive_hnd, &_werr);
973 dcerpc_winreg_CloseKey(b, frame, &key_hnd, &_werr);
974 TALLOC_FREE(frame);
975 return NT_STATUS_OK;
976 }
977
978 /* get info from each subkey */
979 shares = talloc_zero_array(frame, struct smbconf_service, num_subkeys);
980 if (shares == NULL) {
981 werr = WERR_NOMEM;
982 d_fprintf(stderr, _("Failed to create shares: %s\n"),
983 win_errstr(werr));
984 goto error;
985
986 }
987
988 for (i = 0; i < num_subkeys; i++) {
989 /* get each share and place it in the shares array */
990 status = rpc_conf_get_share(frame,
991 b,
992 &key_hnd,
993 subkeys[i],
994 &shares[i],
995 &werr);
996 if (!(NT_STATUS_IS_OK(status))) {
997 goto error;
998 }
999 if (!(W_ERROR_IS_OK(werr))) {
1000 goto error;
1001 }
1002
1003 }
1004 /* print the shares array */
1005 rpc_conf_print_shares(num_subkeys, shares);
1006
1007 error:
1008 if (!(W_ERROR_IS_OK(werr))) {
1009 status = werror_to_ntstatus(werr);
1010 }
1011
1012 dcerpc_winreg_CloseKey(b, frame, &hive_hnd, &_werr);
1013 dcerpc_winreg_CloseKey(b, frame, &key_hnd, &_werr);
1014
1015 TALLOC_FREE(frame);
1016 return status;
1017
1018 }
1019
1020 static NTSTATUS rpc_conf_drop_internal(struct net_context *c,
1021 const struct dom_sid *domain_sid,
1022 const char *domain_name,
1023 struct cli_state *cli,
1024 struct rpc_pipe_client *pipe_hnd,
1025 TALLOC_CTX *mem_ctx,
1026 int argc,
1027 const char **argv )
1028 {
1029 TALLOC_CTX *frame = talloc_stackframe();
1030 NTSTATUS status = NT_STATUS_OK;
1031 WERROR werr = WERR_OK;
1032 WERROR _werr;
1033
1034 struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
1035
1036 /* key info */
1037 struct policy_handle hive_hnd, key_hnd;
1038 const char *keyname = confpath;
1039 struct winreg_String wkey, wkeyclass;
1040 enum winreg_CreateAction action = REG_ACTION_NONE;
1041
1042
1043 ZERO_STRUCT(hive_hnd);
1044 ZERO_STRUCT(key_hnd);
1045
1046
1047 if (argc != 0 || c->display_usage) {
1048 rpc_conf_drop_usage(c, argc, argv);
1049 status = NT_STATUS_INVALID_PARAMETER;
1050 goto error;
1051 }
1052
1053 status = rpc_conf_open_conf(frame,
1054 b,
1055 REG_KEY_ALL,
1056 &hive_hnd,
1057 &key_hnd,
1058 &werr);
1059
1060 if (!(NT_STATUS_IS_OK(status))) {
1061 goto error;
1062 }
1063
1064 if (!(W_ERROR_IS_OK(werr))) {
1065 goto error;
1066 }
1067
1068 status = dcerpc_winreg_delete_subkeys_recursive(frame,
1069 b,
1070 &hive_hnd,
1071 REG_KEY_ALL,
1072 keyname,
1073 &werr);
1074
1075 if (!NT_STATUS_IS_OK(status)) {
1076 d_printf("winreg_delete_subkeys: Could not delete key %s: %s\n",
1077 keyname, nt_errstr(status));
1078 goto error;
1079 }
1080
1081 if (!W_ERROR_IS_OK(werr)) {
1082 d_printf("winreg_delete_subkeys: Could not delete key %s: %s\n",
1083 keyname, win_errstr(werr));
1084 goto error;
1085 }
1086
1087 wkey.name = keyname;
1088 ZERO_STRUCT(wkeyclass);
1089 wkeyclass.name = "";
1090 action = REG_ACTION_NONE;
1091
1092 status = dcerpc_winreg_CreateKey(b,
1093 frame,
1094 &hive_hnd,
1095 wkey,
1096 wkeyclass,
1097 0,
1098 REG_KEY_ALL,
1099 NULL,
1100 &key_hnd,
1101 &action,
1102 &werr);
1103
1104 if (!NT_STATUS_IS_OK(status)) {
1105 d_printf("winreg_CreateKey: Could not create smbconf key\n");
1106 goto error;
1107 }
1108
1109 if (!W_ERROR_IS_OK(werr)) {
1110 d_printf("winreg_CreateKey: Could not create smbconf key\n");
1111 goto error;
1112 }
1113
1114
1115 error:
1116 if (!(W_ERROR_IS_OK(werr))) {
1117 status = werror_to_ntstatus(werr);
1118 }
1119
1120 dcerpc_winreg_CloseKey(b, frame, &hive_hnd, &_werr);
1121 dcerpc_winreg_CloseKey(b, frame, &key_hnd, &_werr);
1122
1123 TALLOC_FREE(frame);
1124 return status;
1125 }
1126
1127 static NTSTATUS rpc_conf_import_internal(struct net_context *c,
1128 const struct dom_sid *domain_sid,
1129 const char *domain_name,
1130 struct cli_state *cli,
1131 struct rpc_pipe_client *pipe_hnd,
1132 TALLOC_CTX *mem_ctx,
1133 int argc,
1134 const char **argv )
1135 {
1136
1137 struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
1138
1139 struct policy_handle hive_hnd, key_hnd;
1140
1141 const char *filename = NULL;
1142 const char *servicename = NULL;
1143 char *conf_source = NULL;
1144 TALLOC_CTX *frame;
1145 struct smbconf_ctx *txt_ctx;
1146 struct smbconf_service *service = NULL;
1147 struct smbconf_service **services = NULL;
1148 uint32_t num_shares, i;
1149 sbcErr err = SBC_ERR_UNKNOWN_FAILURE;
1150
1151 WERROR werr = WERR_OK;
1152 NTSTATUS status = NT_STATUS_OK;
1153
1154 ZERO_STRUCT(hive_hnd);
1155 ZERO_STRUCT(key_hnd);
1156
1157 frame = talloc_stackframe();
1158
1159 if (c->display_usage) {
1160 rpc_conf_import_usage(c, argc, argv);
1161 status = NT_STATUS_INVALID_PARAMETER;
1162 goto error;
1163 }
1164
1165 switch (argc) {
1166 case 0:
1167 default:
1168 rpc_conf_import_usage(c, argc, argv);
1169 status = NT_STATUS_INVALID_PARAMETER;
1170 goto error;
1171 case 2:
1172 servicename = talloc_strdup(frame, argv[1]);
1173 if (servicename == NULL) {
1174 d_printf(_("error: out of memory!\n"));
1175 goto error;
1176 }
1177 case 1:
1178 filename = argv[0];
1179 break;
1180 }
1181
1182 DEBUG(3,("rpc_conf_import: reading configuration from file %s.\n",
1183 filename));
1184
1185 conf_source = talloc_asprintf(frame, "file:%s", filename);
1186 if (conf_source == NULL) {
1187 d_fprintf(stderr, _("error: out of memory!\n"));
1188 goto error;
1189 }
1190
1191 err = smbconf_init(frame, &txt_ctx, conf_source);
1192 if (!SBC_ERROR_IS_OK(err)) {
1193 d_fprintf(stderr, _("error loading file '%s': %s\n"), filename,
1194 sbcErrorString(err));
1195 goto error;
1196 }
1197
1198 if (c->opt_testmode) {
1199 d_printf(_("\nTEST MODE - "
1200 "would import the following configuration:\n\n"));
1201 }
1202
1203 if (servicename != NULL) {
1204 err = smbconf_get_share(txt_ctx, frame,
1205 servicename,
1206 &service);
1207 if (!SBC_ERROR_IS_OK(err)) {
1208 goto error;
1209 }
1210
1211 num_shares = 1;
1212
1213 } else {
1214
1215 err = smbconf_get_config(txt_ctx, frame,
1216 &num_shares,
1217 &services);
1218 if (!SBC_ERROR_IS_OK(err)) {
1219 goto error;
1220 }
1221 }
1222
1223 if (c->opt_testmode) {
1224 if (servicename != NULL) {
1225 rpc_conf_print_shares(1, service);
1226 }
1227 for (i = 0; i < num_shares; i++) {
1228 rpc_conf_print_shares(1, services[i]);
1229 }
1230 goto error;
1231 }
1232
1233 status = rpc_conf_drop_internal(c,
1234 domain_sid,
1235 domain_name,
1236 cli,
1237 pipe_hnd,
1238 frame,
1239 0,
1240 NULL );
1241
1242 if (!(NT_STATUS_IS_OK(status))) {
1243 goto error;
1244 }
1245
1246 status = rpc_conf_open_conf(frame,
1247 b,
1248 REG_KEY_READ,
1249 &hive_hnd,
1250 &key_hnd,
1251 &werr);
1252
1253 if (!(NT_STATUS_IS_OK(status))) {
1254 goto error;
1255 }
1256
1257 if (!(W_ERROR_IS_OK(werr))) {
1258 goto error;
1259 }
1260
1261 if (servicename != NULL) {
1262 status = rpc_conf_set_share(frame,
1263 b,
1264 &key_hnd,
1265 service,
1266 &werr);
1267
1268 if (!(NT_STATUS_IS_OK(status))) {
1269 goto error;
1270 }
1271
1272 if (!(W_ERROR_IS_OK(werr))) {
1273 goto error;
1274 }
1275
1276 } else {
1277
1278 for (i = 0; i < num_shares; i++) {
1279 status = rpc_conf_set_share(frame,
1280 b,
1281 &key_hnd,
1282 services[i],
1283 &werr);
1284
1285 if (!(NT_STATUS_IS_OK(status))) {
1286 goto error;
1287 }
1288
1289 if (!(W_ERROR_IS_OK(werr))) {
1290 goto error;
1291 }
1292
1293 }
1294 }
1295
1296 error:
1297 if (!SBC_ERROR_IS_OK(err)) {
1298 d_fprintf(stderr, "ERROR: %s\n", sbcErrorString(err));
1299 }
1300
1301 if (!(W_ERROR_IS_OK(werr))) {
1302 status = werror_to_ntstatus(werr);
1303 }
1304 TALLOC_FREE(frame);
1305 return status;
1306 }
1307
1308 static NTSTATUS rpc_conf_showshare_internal(struct net_context *c,
1309 const struct dom_sid *domain_sid,
1310 const char *domain_name,
1311 struct cli_state *cli,
1312 struct rpc_pipe_client *pipe_hnd,
1313 TALLOC_CTX *mem_ctx,
1314 int argc,
1315 const char **argv )
1316 {
1317 TALLOC_CTX *frame = talloc_stackframe();
1318 NTSTATUS status = NT_STATUS_OK;
1319 WERROR werr = WERR_OK;
1320 WERROR _werr;
1321
1322 struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
1323
1324 /* key info */
1325 struct policy_handle hive_hnd, key_hnd;
1326 struct smbconf_service *service = NULL;
1327 const char *sharename = NULL;
1328
1329
1330 ZERO_STRUCT(hive_hnd);
1331 ZERO_STRUCT(key_hnd);
1332
1333
1334 if (argc != 1 || c->display_usage) {
1335 rpc_conf_showshare_usage(c, argc, argv);
1336 status = NT_STATUS_INVALID_PARAMETER;
1337 goto error;
1338 }
1339
1340 status = rpc_conf_open_conf(frame,
1341 b,
1342 REG_KEY_READ,
1343 &hive_hnd,
1344 &key_hnd,
1345 &werr);
1346
1347 if (!(NT_STATUS_IS_OK(status))) {
1348 goto error;
1349 }
1350
1351 if (!(W_ERROR_IS_OK(werr))) {
1352 goto error;
1353 }
1354
1355 sharename = talloc_strdup(frame, argv[0]);
1356 if (sharename == NULL) {
1357 werr = WERR_NOMEM;
1358 d_fprintf(stderr, _("Failed to create share: %s\n"),
1359 win_errstr(werr));
1360 goto error;
1361 }
1362
1363 service = talloc(frame, struct smbconf_service);
1364 if (service == NULL) {
1365 werr = WERR_NOMEM;
1366 d_fprintf(stderr, _("Failed to create share: %s\n"),
1367 win_errstr(werr));
1368 goto error;
1369 }
1370
1371 status = rpc_conf_get_share(frame,
1372 b,
1373 &key_hnd,
1374 sharename,
1375 service,
1376 &werr);
1377
1378 if (!(NT_STATUS_IS_OK(status))) {
1379 goto error;
1380 }
1381 if (!(W_ERROR_IS_OK(werr))) {
1382 goto error;
1383 }
1384
1385 rpc_conf_print_shares(1, service);
1386
1387 error:
1388 if (!(W_ERROR_IS_OK(werr))) {
1389 status = werror_to_ntstatus(werr);
1390 }
1391
1392 dcerpc_winreg_CloseKey(b, frame, &hive_hnd, &_werr);
1393 dcerpc_winreg_CloseKey(b, frame, &key_hnd, &_werr);
1394
1395 TALLOC_FREE(frame);
1396 return status;
1397 }
1398
1399 static NTSTATUS rpc_conf_addshare_internal(struct net_context *c,
1400 const struct dom_sid *domain_sid,
1401 const char *domain_name,
1402 struct cli_state *cli,
1403 struct rpc_pipe_client *pipe_hnd,
1404 TALLOC_CTX *mem_ctx,
1405 int argc,
1406 const char **argv )
1407 {
1408 TALLOC_CTX *frame = talloc_stackframe();
1409 NTSTATUS status = NT_STATUS_OK;
1410 WERROR werr = WERR_OK;
1411 WERROR _werr;
1412
1413 struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
1414
1415 /* key info */
1416 struct policy_handle hive_hnd, key_hnd, share_hnd;
1417 char *sharename = NULL;
1418 const char *path = NULL;
1419 const char *comment = NULL;
1420 const char *guest_ok = "no";
1421 const char *read_only = "yes";
1422 struct winreg_String key, keyclass;
1423 enum winreg_CreateAction action = 0;
1424
1425
1426 ZERO_STRUCT(hive_hnd);
1427 ZERO_STRUCT(key_hnd);
1428 ZERO_STRUCT(share_hnd);
1429
1430 ZERO_STRUCT(key);
1431 ZERO_STRUCT(keyclass);
1432
1433 if (c->display_usage) {
1434 rpc_conf_addshare_usage(c, argc, argv);
1435 status = NT_STATUS_INVALID_PARAMETER;
1436 goto error;
1437 }
1438
1439 switch (argc) {
1440 case 0:
1441 case 1:
1442 default:
1443 rpc_conf_addshare_usage(c, argc, argv);
1444 status = NT_STATUS_INVALID_PARAMETER;
1445 goto error;
1446 case 5:
1447 comment = argv[4];
1448 case 4:
1449 if (!strnequal(argv[3], "guest_ok=", 9)) {
1450 rpc_conf_addshare_usage(c, argc, argv);
1451 status = NT_STATUS_INVALID_PARAMETER;
1452 goto error;
1453 }
1454 switch (argv[3][9]) {
1455 case 'y':
1456 case 'Y':
1457 guest_ok = "yes";
1458 break;
1459 case 'n':
1460 case 'N':
1461 guest_ok = "no";
1462 break;
1463 default:
1464 rpc_conf_addshare_usage(c, argc, argv);
1465 status = NT_STATUS_INVALID_PARAMETER;
1466 goto error;
1467 }
1468 case 3:
1469 if (!strnequal(argv[2], "writeable=", 10)) {
1470 rpc_conf_addshare_usage(c, argc, argv);
1471 status = NT_STATUS_INVALID_PARAMETER;
1472 goto error;
1473 }
1474 switch (argv[2][10]) {
1475 case 'y':
1476 case 'Y':
1477 read_only = "no";
1478 break;
1479 case 'n':
1480 case 'N':
1481 read_only = "yes";
1482 break;
1483 default:
1484 rpc_conf_addshare_usage(c, argc, argv);
1485 status = NT_STATUS_INVALID_PARAMETER;
1486 goto error;
1487 }
1488 case 2:
1489 path = argv[1];
1490 sharename = talloc_strdup(frame, argv[0]);
1491 if (sharename == NULL) {
1492 d_printf(_("error: out of memory!\n"));
1493 goto error;
1494 }
1495
1496 break;
1497 }
1498
1499 status = rpc_conf_open_conf(frame,
1500 b,
1501 REG_KEY_READ,
1502 &hive_hnd,
1503 &key_hnd,
1504 &werr);
1505
1506 if (!(NT_STATUS_IS_OK(status))) {
1507 goto error;
1508 }
1509
1510 if (!(W_ERROR_IS_OK(werr))) {
1511 goto error;
1512 }
1513
1514 key.name = argv[0];
1515 keyclass.name = "";
1516
1517 status = dcerpc_winreg_CreateKey(b, frame, &key_hnd, key, keyclass,
1518 0, REG_KEY_READ, NULL, &share_hnd,
1519 &action, &werr);
1520
1521 if (!(NT_STATUS_IS_OK(status))) {
1522 d_fprintf(stderr, _("ERROR: Could not create share key '%s'\n%s\n"),
1523 argv[0], nt_errstr(status));
1524 goto error;
1525 }
1526
1527 if (!W_ERROR_IS_OK(werr)) {
1528 d_fprintf(stderr, _("ERROR: Could not create share key '%s'\n%s\n"),
1529 argv[0], win_errstr(werr));
1530 goto error;
1531 }
1532
1533 switch (action) {
1534 case REG_ACTION_NONE:
1535 werr = WERR_CREATE_FAILED;
1536 d_fprintf(stderr, _("ERROR: Could not create share key '%s'\n%s\n"),
1537 argv[0], win_errstr(werr));
1538 goto error;
1539 case REG_CREATED_NEW_KEY:
1540 DEBUG(5, ("net rpc conf setincludes:"
1541 "createkey created %s\n", argv[0]));
1542 break;
1543 case REG_OPENED_EXISTING_KEY:
1544 d_fprintf(stderr, _("ERROR: Share '%s' already exists\n"), argv[0]);
1545 status = NT_STATUS_INVALID_PARAMETER;
1546 goto error;
1547 }
1548
1549 /* set the path parameter */
1550 status = dcerpc_winreg_set_sz(frame, b, &share_hnd,
1551 "path", path, &werr);
1552
1553 if (!(NT_STATUS_IS_OK(status))) {
1554 d_fprintf(stderr, "ERROR: Could not set parameter '%s'"
1555 " with value %s\n %s\n",
1556 "path", path, nt_errstr(status));
1557 goto error;
1558 }
1559
1560 if (!(W_ERROR_IS_OK(werr))) {
1561 d_fprintf(stderr, "ERROR: Could not set parameter '%s'"
1562 " with value %s\n %s\n",
1563 "path", path, win_errstr(werr));
1564 goto error;
1565 }
1566
1567 /* set the writeable parameter */
1568 status = dcerpc_winreg_set_sz(frame, b, &share_hnd,
1569 "read only", read_only, &werr);
1570
1571 if (!(NT_STATUS_IS_OK(status))) {
1572 d_fprintf(stderr, "ERROR: Could not set parameter '%s'"
1573 " with value %s\n %s\n",
1574 "read only", read_only, nt_errstr(status));
1575 goto error;
1576 }
1577
1578 if (!(W_ERROR_IS_OK(werr))) {
1579 d_fprintf(stderr, "ERROR: Could not set parameter '%s'"
1580 " with value %s\n %s\n",
1581 "read only", read_only, win_errstr(werr));
1582 goto error;
1583 }
1584
1585 /* set the guest ok parameter */
1586 status = dcerpc_winreg_set_sz(frame, b, &share_hnd,
1587 "guest ok", guest_ok, &werr);
1588
1589 if (!(NT_STATUS_IS_OK(status))) {
1590 d_fprintf(stderr, "ERROR: Could not set parameter '%s'"
1591 " with value %s\n %s\n",
1592 "guest ok", guest_ok, nt_errstr(status));
1593 goto error;
1594 }
1595
1596 if (!(W_ERROR_IS_OK(werr))) {
1597 d_fprintf(stderr, "ERROR: Could not set parameter '%s'"
1598 " with value %s\n %s\n",
1599 "guest ok", guest_ok, win_errstr(werr));
1600 goto error;
1601 }
1602
1603 if (argc == 5) {
1604 /* set the comment parameter */
1605 status = dcerpc_winreg_set_sz(frame, b, &share_hnd,
1606 "comment", comment, &werr);
1607
1608 if (!(NT_STATUS_IS_OK(status))) {
1609 d_fprintf(stderr, "ERROR: Could not set parameter '%s'"
1610 " with value %s\n %s\n",
1611 "comment", comment, nt_errstr(status));
1612 goto error;
1613 }
1614
1615 if (!(W_ERROR_IS_OK(werr))) {
1616 d_fprintf(stderr, "ERROR: Could not set parameter '%s'"
1617 " with value %s\n %s\n",
1618 "comment", comment, win_errstr(werr));
1619 goto error;
1620 }
1621 }
1622 error:
1623 if (!(W_ERROR_IS_OK(werr))) {
1624 status = werror_to_ntstatus(werr);
1625 }
1626
1627 dcerpc_winreg_CloseKey(b, frame, &hive_hnd, &_werr);
1628 dcerpc_winreg_CloseKey(b, frame, &key_hnd, &_werr);
1629 dcerpc_winreg_CloseKey(b, frame, &share_hnd, &_werr);
1630
1631 TALLOC_FREE(frame);
1632 return status;
1633 }
1634
1635 static NTSTATUS rpc_conf_getparm_internal(struct net_context *c,
1636 const struct dom_sid *domain_sid,
1637 const char *domain_name,
1638 struct cli_state *cli,
1639 struct rpc_pipe_client *pipe_hnd,
1640 TALLOC_CTX *mem_ctx,
1641 int argc,
1642 const char **argv )
1643 {
1644 TALLOC_CTX *frame = talloc_stackframe();
1645 NTSTATUS status = NT_STATUS_OK;
1646 WERROR werr = WERR_OK;
1647 WERROR _werr;
1648
1649 struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
1650
1651 /* key info */
1652 struct policy_handle hive_hnd, key_hnd;
1653 struct smbconf_service *service = NULL;
1654
1655 bool param_is_set = false;
1656 uint32_t param_count;
1657
1658 ZERO_STRUCT(hive_hnd);
1659 ZERO_STRUCT(key_hnd);
1660
1661
1662 if (argc != 2 || c->display_usage) {
1663 rpc_conf_getparm_usage(c, argc, argv);
1664 status = NT_STATUS_INVALID_PARAMETER;
1665 goto error;
1666 }
1667
1668 status = rpc_conf_open_conf(frame,
1669 b,
1670 REG_KEY_READ,
1671 &hive_hnd,
1672 &key_hnd,
1673 &werr);
1674
1675 if (!(NT_STATUS_IS_OK(status))) {
1676 goto error;
1677 }
1678
1679 if (!(W_ERROR_IS_OK(werr))) {
1680 goto error;
1681 }
1682
1683
1684 service = talloc(frame, struct smbconf_service);
1685
1686 status = rpc_conf_get_share(frame,
1687 b,
1688 &key_hnd,
1689 argv[0],
1690 service,
1691 &werr);
1692
1693 if (!(NT_STATUS_IS_OK(status))) {
1694 goto error;
1695 }
1696
1697 if (W_ERROR_EQUAL(werr, WERR_BADFILE)) {
1698 d_fprintf(stderr, _("ERROR: Share %s does not exist\n"),
1699 argv[0]);
1700 goto error;
1701 }
1702
1703 if (!(W_ERROR_IS_OK(werr))) {
1704 goto error;
1705 }
1706
1707 for (param_count = 0;
1708 param_count < service->num_params;
1709 param_count++)
1710 {
1711 /* should includes also be printed? */
1712 if (strcmp(service->param_names[param_count], argv[1]) == 0) {
1713 d_printf(_("%s\n"),
1714 service->param_values[param_count]);
1715 param_is_set = true;
1716 }
1717 }
1718
1719 if (!param_is_set) {
1720 d_fprintf(stderr, _("ERROR: Given parameter '%s' has not been set\n"),
1721 argv[1]);
1722 werr = WERR_BADFILE;
1723 goto error;
1724 }
1725
1726 error:
1727
1728 if (!(W_ERROR_IS_OK(werr))) {
1729 status = werror_to_ntstatus(werr);
1730 }
1731
1732 dcerpc_winreg_CloseKey(b, frame, &hive_hnd, &_werr);
1733 dcerpc_winreg_CloseKey(b, frame, &key_hnd, &_werr);
1734
1735 TALLOC_FREE(frame);
1736 return status;
1737
1738 }
1739
1740 static NTSTATUS rpc_conf_setparm_internal(struct net_context *c,
1741 const struct dom_sid *domain_sid,
1742 const char *domain_name,
1743 struct cli_state *cli,
1744 struct rpc_pipe_client *pipe_hnd,
1745 TALLOC_CTX *mem_ctx,
1746 int argc,
1747 const char **argv )
1748 {
1749 TALLOC_CTX *frame = talloc_stackframe();
1750 NTSTATUS status = NT_STATUS_OK;
1751 WERROR werr = WERR_OK;
1752 WERROR _werr;
1753
1754 struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
1755
1756 /* key info */
1757 struct policy_handle hive_hnd, key_hnd, share_hnd;
1758
1759 struct winreg_String key, keyclass;
1760 enum winreg_CreateAction action = 0;
1761
1762 const char *canon_valname;
1763 const char *canon_valstr;
1764
1765 ZERO_STRUCT(hive_hnd);
1766 ZERO_STRUCT(key_hnd);
1767 ZERO_STRUCT(share_hnd);
1768
1769 ZERO_STRUCT(key);
1770 ZERO_STRUCT(keyclass);
1771
1772 if (argc != 3 || c->display_usage) {
1773 rpc_conf_setparm_usage(c, argc, argv);
1774 status = NT_STATUS_INVALID_PARAMETER;
1775 goto error;
1776 }
1777
1778 status = rpc_conf_open_conf(frame,
1779 b,
1780 REG_KEY_READ,
1781 &hive_hnd,
1782 &key_hnd,
1783 &werr);
1784
1785 if (!(NT_STATUS_IS_OK(status))) {
1786 goto error;
1787 }
1788
1789 if (!(W_ERROR_IS_OK(werr))) {
1790 goto error;
1791 }
1792
1793 key.name = argv[0];
1794 keyclass.name = "";
1795
1796 status = dcerpc_winreg_CreateKey(b, frame, &key_hnd, key, keyclass,
1797 0, REG_KEY_READ, NULL, &share_hnd,
1798 &action, &werr);
1799
1800 if (!(NT_STATUS_IS_OK(status))) {
1801 d_fprintf(stderr, _("ERROR: Could not create share key '%s'\n%s\n"),
1802 argv[0], nt_errstr(status));
1803 goto error;
1804 }
1805
1806 if (!W_ERROR_IS_OK(werr)) {
1807 d_fprintf(stderr, _("ERROR: Could not create share key '%s'\n%s\n"),
1808 argv[0], win_errstr(werr));
1809 goto error;
1810 }
1811
1812 switch (action) {
1813 case REG_ACTION_NONE:
1814 werr = WERR_CREATE_FAILED;
1815 d_fprintf(stderr, _("ERROR: Could not create share key '%s'\n%s\n"),
1816 argv[0], win_errstr(werr));
1817 goto error;
1818 case REG_CREATED_NEW_KEY:
1819 DEBUG(5, ("net rpc conf setparm:"
1820 "createkey created %s\n", argv[0]));
1821 break;
1822 case REG_OPENED_EXISTING_KEY:
1823 DEBUG(5, ("net rpc conf setparm:"
1824 "createkey opened existing %s\n", argv[0]));
1825
1826 /* delete posibly existing value */
1827 status = rpc_conf_del_value(frame,
1828 b,
1829 &key_hnd,
1830 argv[0],
1831 argv[1],
1832 &werr);
1833
1834 if (!(NT_STATUS_IS_OK(status))) {
1835 goto error;
1836 }
1837
1838 if (!(W_ERROR_IS_OK(werr))) {
1839 goto error;
1840 }
1841
1842 break;
1843 }
1844
1845 /* check if parameter is valid for writing */
1846 if (!lp_canonicalize_parameter_with_value(argv[1], argv[2],
1847 &canon_valname,
1848 &canon_valstr))
1849 {
1850 if (canon_valname == NULL) {
1851 d_fprintf(stderr, "invalid parameter '%s' given\n",
1852 argv[1]);
1853 } else {
1854 d_fprintf(stderr, "invalid value '%s' given for "
1855 "parameter '%s'\n", argv[1], argv[2]);
1856 }
1857 werr = WERR_INVALID_PARAM;
1858 goto error;
1859 }
1860
1861 if (rpc_conf_reg_valname_forbidden(canon_valname)) {
1862 d_fprintf(stderr, "Parameter '%s' not allowed in registry.\n",
1863 canon_valname);
1864 werr = WERR_INVALID_PARAM;
1865 goto error;
1866 }
1867
1868 if (!strequal(argv[0], "global") &&
1869 lp_parameter_is_global(argv[1]))
1870 {
1871 d_fprintf(stderr, "Global parameter '%s' not allowed in "
1872 "service definition ('%s').\n", canon_valname,
1873 argv[0]);
1874 werr = WERR_INVALID_PARAM;
1875 goto error;
1876 }
1877
1878 /* set the parameter */
1879 status = dcerpc_winreg_set_sz(frame, b, &share_hnd,
1880 argv[1], argv[2], &werr);
1881
1882 if (!(NT_STATUS_IS_OK(status))) {
1883 d_fprintf(stderr, "ERROR: Could not set parameter '%s'"
1884 " with value %s\n %s\n",
1885 argv[1], argv[2], nt_errstr(status));
1886 goto error;
1887 }
1888
1889 if (!(W_ERROR_IS_OK(werr))) {
1890 d_fprintf(stderr, "ERROR: Could not set parameter '%s'"
1891 " with value %s\n %s\n",
1892 argv[1], argv[2], win_errstr(werr));
1893 goto error;
1894 }
1895
1896 error:
1897
1898 if (!(W_ERROR_IS_OK(werr))) {
1899 status = werror_to_ntstatus(werr);
1900 }
1901
1902 dcerpc_winreg_CloseKey(b, frame, &hive_hnd, &_werr);
1903 dcerpc_winreg_CloseKey(b, frame, &key_hnd, &_werr);
1904 dcerpc_winreg_CloseKey(b, frame, &share_hnd, &_werr);
1905
1906 TALLOC_FREE(frame);
1907 return status;
1908 }
1909
1910 static NTSTATUS rpc_conf_delparm_internal(struct net_context *c,
1911 const struct dom_sid *domain_sid,
1912 const char *domain_name,
1913 struct cli_state *cli,
1914 struct rpc_pipe_client *pipe_hnd,
1915 TALLOC_CTX *mem_ctx,
1916 int argc,
1917 const char **argv )
1918 {
1919 TALLOC_CTX *frame = talloc_stackframe();
1920 NTSTATUS status = NT_STATUS_OK;
1921 WERROR werr = WERR_OK;
1922 WERROR _werr;
1923
1924 struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
1925
1926 /* key info */
1927 struct policy_handle hive_hnd, key_hnd;
1928
1929
1930 ZERO_STRUCT(hive_hnd);
1931 ZERO_STRUCT(key_hnd);
1932
1933
1934 if (argc != 2 || c->display_usage) {
1935 rpc_conf_delparm_usage(c, argc, argv);
1936 status = NT_STATUS_INVALID_PARAMETER;
1937 goto error;
1938 }
1939
1940 status = rpc_conf_open_conf(frame,
1941 b,
1942 REG_KEY_READ,
1943 &hive_hnd,
1944 &key_hnd,
1945 &werr);
1946
1947 if (!(NT_STATUS_IS_OK(status))) {
1948 goto error;
1949 }
1950
1951 if (!(W_ERROR_IS_OK(werr))) {
1952 goto error;
1953 }
1954
1955 status = rpc_conf_del_value(frame,
1956 b,
1957 &key_hnd,
1958 argv[0],
1959 argv[1],
1960 &werr);
1961
1962 error:
1963
1964 if (!(W_ERROR_IS_OK(werr))) {
1965 status = werror_to_ntstatus(werr);
1966 }
1967
1968 dcerpc_winreg_CloseKey(b, frame, &hive_hnd, &_werr);
1969 dcerpc_winreg_CloseKey(b, frame, &key_hnd, &_werr);
1970
1971 TALLOC_FREE(frame);
1972 return status;
1973
1974 }
1975
1976 static NTSTATUS rpc_conf_getincludes_internal(struct net_context *c,
1977 const struct dom_sid *domain_sid,
1978 const char *domain_name,
1979 struct cli_state *cli,
1980 struct rpc_pipe_client *pipe_hnd,
1981 TALLOC_CTX *mem_ctx,
1982 int argc,
1983 const char **argv )
1984 {
1985 TALLOC_CTX *frame = talloc_stackframe();
1986 NTSTATUS status = NT_STATUS_OK;
1987 WERROR werr = WERR_OK;
1988 WERROR _werr;
1989
1990 struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
1991
1992 /* key info */
1993 struct policy_handle hive_hnd, key_hnd;
1994 struct smbconf_service *service = NULL;
1995
1996 uint32_t param_count;
1997
1998
1999 ZERO_STRUCT(hive_hnd);
2000 ZERO_STRUCT(key_hnd);
2001
2002
2003 if (argc != 1 || c->display_usage) {
2004 rpc_conf_getincludes_usage(c, argc, argv);
2005 status = NT_STATUS_INVALID_PARAMETER;
2006 goto error;
2007 }
2008
2009 status = rpc_conf_open_conf(frame,
2010 b,
2011 REG_KEY_READ,
2012 &hive_hnd,
2013 &key_hnd,
2014 &werr);
2015
2016 if (!(NT_STATUS_IS_OK(status))) {
2017 goto error;
2018 }
2019
2020 if (!(W_ERROR_IS_OK(werr))) {
2021 goto error;
2022 }
2023
2024 service = talloc(frame, struct smbconf_service);
2025
2026 status = rpc_conf_get_share(frame,
2027 b,
2028 &key_hnd,
2029 argv[0],
2030 service,
2031 &werr);
2032
2033 if (!(NT_STATUS_IS_OK(status))) {
2034 goto error;
2035 }
2036
2037 if (!(W_ERROR_IS_OK(werr))) {
2038 goto error;
2039 }
2040
2041 for (param_count = 0;
2042 param_count < service->num_params;
2043 param_count++)
2044 {
2045 if (strcmp(service->param_names[param_count], "include") == 0) {
2046 d_printf(_("%s = %s\n"),
2047 service->param_names[param_count],
2048 service->param_values[param_count]);
2049 }
2050 }
2051
2052 error:
2053
2054 if (!(W_ERROR_IS_OK(werr))) {
2055 status = werror_to_ntstatus(werr);
2056 }
2057
2058 dcerpc_winreg_CloseKey(b, frame, &hive_hnd, &_werr);
2059 dcerpc_winreg_CloseKey(b, frame, &key_hnd, &_werr);
2060
2061 TALLOC_FREE(frame);
2062 return status;
2063
2064 }
2065
2066 static NTSTATUS rpc_conf_setincludes_internal(struct net_context *c,
2067 const struct dom_sid *domain_sid,
2068 const char *domain_name,
2069 struct cli_state *cli,
2070 struct rpc_pipe_client *pipe_hnd,
2071 TALLOC_CTX *mem_ctx,
2072 int argc,
2073 const char **argv )
2074 {
2075 TALLOC_CTX *frame = talloc_stackframe();
2076 NTSTATUS status = NT_STATUS_OK;
2077 WERROR werr = WERR_OK;
2078 WERROR _werr;
2079
2080 struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
2081
2082 /* key info */
2083 struct policy_handle hive_hnd, key_hnd, share_hnd;
2084
2085 struct winreg_String key, keyclass;
2086 enum winreg_CreateAction action = 0;
2087
2088 ZERO_STRUCT(hive_hnd);
2089 ZERO_STRUCT(key_hnd);
2090 ZERO_STRUCT(share_hnd);
2091
2092 ZERO_STRUCT(key);
2093 ZERO_STRUCT(keyclass);
2094
2095 if (argc < 1 || c->display_usage) {
2096 rpc_conf_setincludes_usage(c, argc, argv);
2097 status = NT_STATUS_INVALID_PARAMETER;
2098 goto error;
2099 }
2100
2101 status = rpc_conf_open_conf(frame,
2102 b,
2103 REG_KEY_READ,
2104 &hive_hnd,
2105 &key_hnd,
2106 &werr);
2107
2108 if (!(NT_STATUS_IS_OK(status))) {
2109 goto error;
2110 }
2111
2112 if (!(W_ERROR_IS_OK(werr))) {
2113 goto error;
2114 }
2115
2116 key.name = argv[0];
2117 keyclass.name = "";
2118
2119 status = dcerpc_winreg_CreateKey(b, frame, &key_hnd, key, keyclass,
2120 0, REG_KEY_READ, NULL, &share_hnd,
2121 &action, &werr);
2122
2123 if (!(NT_STATUS_IS_OK(status))) {
2124 d_fprintf(stderr, _("ERROR: Could not create share key '%s'\n%s\n"),
2125 argv[0], nt_errstr(status));
2126 goto error;
2127 }
2128
2129 if (!W_ERROR_IS_OK(werr)) {
2130 d_fprintf(stderr, _("ERROR: Could not create share key '%s'\n%s\n"),
2131 argv[0], win_errstr(werr));
2132 goto error;
2133 }
2134
2135 switch (action) {
2136 case REG_ACTION_NONE:
2137 /* Is there any other way to treat this? */
2138 werr = WERR_CREATE_FAILED;
2139 d_fprintf(stderr, _("ERROR: Could not create share key '%s'\n%s\n"),
2140 argv[0], win_errstr(werr));
2141 goto error;
2142 case REG_CREATED_NEW_KEY:
2143 DEBUG(5, ("net rpc conf setincludes:"
2144 "createkey created %s\n", argv[0]));
2145 break;
2146 case REG_OPENED_EXISTING_KEY:
2147 DEBUG(5, ("net rpc conf setincludes:"
2148 "createkey opened existing %s\n", argv[0]));
2149
2150 /* delete posibly existing value */
2151 status = rpc_conf_del_value(frame,
2152 b,
2153 &key_hnd,
2154 argv[0],
2155 "includes",
2156 &werr);
2157
2158 if (!(NT_STATUS_IS_OK(status))) {
2159 goto error;
2160 }
2161
2162 if (!(W_ERROR_IS_OK(werr))) {
2163 goto error;
2164 }
2165 break;
2166 }
2167
2168 /* set the 'includes' values */
2169 status = dcerpc_winreg_set_multi_sz(frame, b, &share_hnd,
2170 "includes", argv + 1, &werr);
2171 if (!(NT_STATUS_IS_OK(status))) {
2172 d_fprintf(stderr, "ERROR: Could not set includes\n %s\n",
2173 nt_errstr(status));
2174 goto error;
2175 }
2176
2177 if (!(W_ERROR_IS_OK(werr))) {
2178 d_fprintf(stderr, "ERROR: Could not set includes\n %s\n",
2179 win_errstr(werr));
2180 goto error;
2181 }
2182
2183 error:
2184
2185 if (!(W_ERROR_IS_OK(werr))) {
2186 status = werror_to_ntstatus(werr);
2187 }
2188
2189 dcerpc_winreg_CloseKey(b, frame, &hive_hnd, &_werr);
2190 dcerpc_winreg_CloseKey(b, frame, &key_hnd, &_werr);
2191 dcerpc_winreg_CloseKey(b, frame, &share_hnd, &_werr);
2192
2193 TALLOC_FREE(frame);
2194 return status;
2195 }
2196
2197 static NTSTATUS rpc_conf_delincludes_internal(struct net_context *c,
2198 const struct dom_sid *domain_sid,
2199 const char *domain_name,
2200 struct cli_state *cli,
2201 struct rpc_pipe_client *pipe_hnd,
2202 TALLOC_CTX *mem_ctx,
2203 int argc,
2204 const char **argv )
2205 {
2206 TALLOC_CTX *frame = talloc_stackframe();
2207 NTSTATUS status = NT_STATUS_OK;
2208 WERROR werr = WERR_OK;
2209 WERROR _werr;
2210
2211 struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
2212
2213 /* key info */
2214 struct policy_handle hive_hnd, key_hnd;
2215
2216
2217 ZERO_STRUCT(hive_hnd);
2218 ZERO_STRUCT(key_hnd);
2219
2220
2221 if (argc != 1 || c->display_usage) {
2222 rpc_conf_delincludes_usage(c, argc, argv);
2223 status = NT_STATUS_INVALID_PARAMETER;
2224 goto error;
2225 }
2226
2227 status = rpc_conf_open_conf(frame,
2228 b,
2229 REG_KEY_READ,
2230 &hive_hnd,
2231 &key_hnd,
2232 &werr);
2233
2234 if (!(NT_STATUS_IS_OK(status))) {
2235 goto error;
2236 }
2237
2238 if (!(W_ERROR_IS_OK(werr))) {
2239 goto error;
2240 }
2241
2242 status = rpc_conf_del_value(frame,
2243 b,
2244 &key_hnd,
2245 argv[0],
2246 "includes",
2247 &werr);
2248
2249 error:
2250
2251 if (!(W_ERROR_IS_OK(werr))) {
2252 status = werror_to_ntstatus(werr);
2253 }
2254
2255 dcerpc_winreg_CloseKey(b, frame, &hive_hnd, &_werr);
2256 dcerpc_winreg_CloseKey(b, frame, &key_hnd, &_werr);
2257
2258 TALLOC_FREE(frame);
2259 return status;
2260
2261 }
2262
2263 /**********************************************************
2264 *
2265 * Functions that run the rpc commands for net rpc conf modules
2266 *
2267 **********************************************************/
2268
2269 static int rpc_conf_drop(struct net_context *c, int argc,
2270 const char **argv)
2271 {
2272 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
2273 rpc_conf_drop_internal, argc, argv );
2274
2275 }
2276
2277 static int rpc_conf_showshare(struct net_context *c, int argc,
2278 const char **argv)
2279 {
2280 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
2281 rpc_conf_showshare_internal, argc, argv );
2282 }
2283
2284 static int rpc_conf_addshare(struct net_context *c, int argc,
2285 const char **argv)
2286 {
2287 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
2288 rpc_conf_addshare_internal, argc, argv );
2289 }
2290
2291 static int rpc_conf_listshares(struct net_context *c, int argc,
2292 const char **argv)
2293 {
2294 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
2295 rpc_conf_listshares_internal, argc, argv );
2296 }
2297
2298 static int rpc_conf_list(struct net_context *c, int argc,
2299 const char **argv)
2300 {
2301 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
2302 rpc_conf_list_internal, argc, argv );
2303 }
2304
2305 static int rpc_conf_import(struct net_context *c, int argc,
2306 const char **argv)
2307 {
2308 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
2309 rpc_conf_import_internal, argc, argv );
2310 }
2311 static int rpc_conf_delshare(struct net_context *c, int argc,
2312 const char **argv)
2313 {
2314 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
2315 rpc_conf_delshare_internal, argc, argv );
2316 }
2317
2318 static int rpc_conf_getparm(struct net_context *c, int argc,
2319 const char **argv)
2320 {
2321 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
2322 rpc_conf_getparm_internal, argc, argv );
2323 }
2324
2325 static int rpc_conf_setparm(struct net_context *c, int argc,
2326 const char **argv)
2327 {
2328 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
2329 rpc_conf_setparm_internal, argc, argv );
2330 }
2331 static int rpc_conf_delparm(struct net_context *c, int argc,
2332 const char **argv)
2333 {
2334 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
2335 rpc_conf_delparm_internal, argc, argv );
2336 }
2337
2338 static int rpc_conf_getincludes(struct net_context *c, int argc,
2339 const char **argv)
2340 {
2341 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
2342 rpc_conf_getincludes_internal, argc, argv );
2343 }
2344
2345 static int rpc_conf_setincludes(struct net_context *c, int argc,
2346 const char **argv)
2347 {
2348 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
2349 rpc_conf_setincludes_internal, argc, argv );
2350 }
2351
2352 static int rpc_conf_delincludes(struct net_context *c, int argc,
2353 const char **argv)
2354 {
2355 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
2356 rpc_conf_delincludes_internal, argc, argv );
2357 }
2358
2359 /* function calls */
2360 int net_rpc_conf(struct net_context *c, int argc,
2361 const char **argv)
2362 {
2363 struct functable func_table[] = {
2364 {
2365 "list",
2366 rpc_conf_list,
2367 NET_TRANSPORT_RPC,
2368 N_("Dump the complete remote configuration in smb.conf like "
2369 "format."),
2370 N_("net rpc conf list\n"
2371 " Dump the complete remote configuration in smb.conf "
2372 "like format.")
2373
2374 },
2375 {
2376 "import",
2377 rpc_conf_import,
2378 NET_TRANSPORT_RPC,
2379 N_("Import configuration from file in smb.conf "
2380 "format."),
2381 N_("net rpc conf import\n"
2382 " Import configuration from file in smb.conf "
2383 "format.")
2384 },
2385 {
2386 "listshares",
2387 rpc_conf_listshares,
2388 NET_TRANSPORT_RPC,
2389 N_("List the remote share names."),
2390 N_("net rpc conf list\n"
2391 " List the remote share names.")
2392
2393 },
2394 {
2395 "drop",
2396 rpc_conf_drop,
2397 NET_TRANSPORT_RPC,
2398 N_("Delete the complete remote configuration."),
2399 N_("net rpc conf drop\n"
2400 " Delete the complete remote configuration.")
2401
2402 },
2403 {
2404 "showshare",
2405 rpc_conf_showshare,
2406 NET_TRANSPORT_RPC,
2407 N_("Show the definition of a remote share."),
2408 N_("net rpc conf showshare\n"
2409 " Show the definition of a remote share.")
2410
2411 },
2412 {
2413 "addshare",
2414 rpc_conf_addshare,
2415 NET_TRANSPORT_RPC,
2416 N_("Create a new remote share."),
2417 N_("net rpc conf addshare\n"
2418 " Create a new remote share.")
2419 },
2420 {
2421 "delshare",
2422 rpc_conf_delshare,
2423 NET_TRANSPORT_RPC,
2424 N_("Delete a remote share."),
2425 N_("net rpc conf delshare\n"
2426 " Delete a remote share.")
2427 },
2428 {
2429 "getparm",
2430 rpc_conf_getparm,
2431 NET_TRANSPORT_RPC,
2432 N_("Retrieve the value of a parameter."),
2433 N_("net rpc conf getparm\n"
2434 " Retrieve the value of a parameter.")
2435 },
2436 {
2437 "setparm",
2438 rpc_conf_setparm,
2439 NET_TRANSPORT_RPC,
2440 N_("Store a parameter."),
2441 N_("net rpc conf setparm\n"
2442 " Store a parameter.")
2443 },
2444 {
2445 "delparm",
2446 rpc_conf_delparm,
2447 NET_TRANSPORT_RPC,
2448 N_("Delete a parameter."),
2449 N_("net rpc conf delparm\n"
2450 " Delete a parameter.")
2451 },
2452 {
2453 "getincludes",
2454 rpc_conf_getincludes,
2455 NET_TRANSPORT_RPC,
2456 N_("Show the includes of a share definition."),
2457 N_("net rpc conf getincludes\n"
2458 " Show the includes of a share definition.")
2459 },
2460 {
2461 "setincludes",
2462 rpc_conf_setincludes,
2463 NET_TRANSPORT_RPC,
2464 N_("Set includes for a share."),
2465 N_("net rpc conf setincludes\n"
2466 " Set includes for a share.")
2467 },
2468 {
2469 "delincludes",
2470 rpc_conf_delincludes,
2471 NET_TRANSPORT_RPC,
2472 N_("Delete includes from a share definition."),
2473 N_("net rpc conf delincludes\n"
2474 " Delete includes from a share definition.")
2475 },
2476 {NULL, NULL, 0, NULL, NULL}
2477 };
2478
2479 return net_run_function(c, argc, argv, "net rpc conf", func_table);
2480
2481 }
reg import