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