source: branches/samba-3.2.x/source/rpcclient/cmd_srvsvc.c

Last change on this file was 133, checked in by Paul Smedley, 17 years ago

Update trunk to 3.2.0pre3
File size: 20.1 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 RPC pipe client
4
5 Copyright (C) Andrew Tridgell 1992-1999
6 Copyright (C) Luke Kenneth Casson Leighton 1996 - 1999
7 Copyright (C) Tim Potter 2000,2002
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
21*/
22
23#include "includes.h"
24#include "rpcclient.h"
25
26/* Display server query info */
27
28static char *get_server_type_str(uint32 type)
29{
30 static fstring typestr;
31 int i;
32
33 if (type == SV_TYPE_ALL) {
34 fstrcpy(typestr, "All");
35 return typestr;
36 }
37
38 typestr[0] = 0;
39
40 for (i = 0; i < 32; i++) {
41 if (type & (1 << i)) {
42 switch (1 << i) {
43 case SV_TYPE_WORKSTATION:
44 fstrcat(typestr, "Wk ");
45 break;
46 case SV_TYPE_SERVER:
47 fstrcat(typestr, "Sv ");
48 break;
49 case SV_TYPE_SQLSERVER:
50 fstrcat(typestr, "Sql ");
51 break;
52 case SV_TYPE_DOMAIN_CTRL:
53 fstrcat(typestr, "PDC ");
54 break;
55 case SV_TYPE_DOMAIN_BAKCTRL:
56 fstrcat(typestr, "BDC ");
57 break;
58 case SV_TYPE_TIME_SOURCE:
59 fstrcat(typestr, "Tim ");
60 break;
61 case SV_TYPE_AFP:
62 fstrcat(typestr, "AFP ");
63 break;
64 case SV_TYPE_NOVELL:
65 fstrcat(typestr, "Nov ");
66 break;
67 case SV_TYPE_DOMAIN_MEMBER:
68 fstrcat(typestr, "Dom ");
69 break;
70 case SV_TYPE_PRINTQ_SERVER:
71 fstrcat(typestr, "PrQ ");
72 break;
73 case SV_TYPE_DIALIN_SERVER:
74 fstrcat(typestr, "Din ");
75 break;
76 case SV_TYPE_SERVER_UNIX:
77 fstrcat(typestr, "Unx ");
78 break;
79 case SV_TYPE_NT:
80 fstrcat(typestr, "NT ");
81 break;
82 case SV_TYPE_WFW:
83 fstrcat(typestr, "Wfw ");
84 break;
85 case SV_TYPE_SERVER_MFPN:
86 fstrcat(typestr, "Mfp ");
87 break;
88 case SV_TYPE_SERVER_NT:
89 fstrcat(typestr, "SNT ");
90 break;
91 case SV_TYPE_POTENTIAL_BROWSER:
92 fstrcat(typestr, "PtB ");
93 break;
94 case SV_TYPE_BACKUP_BROWSER:
95 fstrcat(typestr, "BMB ");
96 break;
97 case SV_TYPE_MASTER_BROWSER:
98 fstrcat(typestr, "LMB ");
99 break;
100 case SV_TYPE_DOMAIN_MASTER:
101 fstrcat(typestr, "DMB ");
102 break;
103 case SV_TYPE_SERVER_OSF:
104 fstrcat(typestr, "OSF ");
105 break;
106 case SV_TYPE_SERVER_VMS:
107 fstrcat(typestr, "VMS ");
108 break;
109 case SV_TYPE_WIN95_PLUS:
110 fstrcat(typestr, "W95 ");
111 break;
112 case SV_TYPE_ALTERNATE_XPORT:
113 fstrcat(typestr, "Xpt ");
114 break;
115 case SV_TYPE_LOCAL_LIST_ONLY:
116 fstrcat(typestr, "Dom ");
117 break;
118 case SV_TYPE_DOMAIN_ENUM:
119 fstrcat(typestr, "Loc ");
120 break;
121 }
122 }
123 }
124
125 i = strlen(typestr) - 1;
126
127 if (typestr[i] == ' ')
128 typestr[i] = 0;
129
130 return typestr;
131}
132
133static void display_server(const char *sname, uint32 type, const char *comment)
134{
135 printf("\t%-15.15s%-20s %s\n", sname, get_server_type_str(type),
136 comment);
137}
138
139static void display_srv_info_101(struct srvsvc_NetSrvInfo101 *r)
140{
141 display_server(r->server_name, r->server_type, r->comment);
142
143 printf("\tplatform_id :\t%d\n", r->platform_id);
144 printf("\tos version :\t%d.%d\n",
145 r->version_major, r->version_minor);
146 printf("\tserver type :\t0x%x\n", r->server_type);
147}
148
149static void display_srv_info_102(struct srvsvc_NetSrvInfo102 *r)
150{
151 display_server(r->server_name, r->server_type, r->comment);
152
153 printf("\tplatform_id :\t%d\n", r->platform_id);
154 printf("\tos version :\t%d.%d\n",
155 r->version_major, r->version_minor);
156 printf("\tserver type :\t0x%x\n", r->server_type);
157
158 printf("\tusers :\t%x\n", r->users);
159 printf("\tdisc, hidden :\t%x, %x\n", r->disc, r->hidden);
160 printf("\tannounce, delta :\t%d, %d\n", r->announce,
161 r->anndelta);
162 printf("\tlicenses :\t%d\n", r->licenses);
163 printf("\tuser path :\t%s\n", r->userpath);
164}
165
166/* Server query info */
167static WERROR cmd_srvsvc_srv_query_info(struct rpc_pipe_client *cli,
168 TALLOC_CTX *mem_ctx,
169 int argc, const char **argv)
170{
171 uint32 info_level = 101;
172 union srvsvc_NetSrvInfo info;
173 WERROR result;
174 NTSTATUS status;
175 const char *server_name;
176
177 if (argc > 2) {
178 printf("Usage: %s [infolevel]\n", argv[0]);
179 return WERR_OK;
180 }
181
182 if (argc == 2)
183 info_level = atoi(argv[1]);
184
185 server_name = talloc_asprintf_strupper_m(mem_ctx, "\\\\%s",
186 cli->cli->desthost);
187 W_ERROR_HAVE_NO_MEMORY(server_name);
188
189 status = rpccli_srvsvc_NetSrvGetInfo(cli, mem_ctx,
190 server_name,
191 info_level,
192 &info,
193 &result);
194 if (!NT_STATUS_IS_OK(status)) {
195 return ntstatus_to_werror(status);
196 }
197
198 if (!W_ERROR_IS_OK(result)) {
199 goto done;
200 }
201
202 /* Display results */
203
204 switch (info_level) {
205 case 101:
206 display_srv_info_101(info.info101);
207 break;
208 case 102:
209 display_srv_info_102(info.info102);
210 break;
211 default:
212 printf("unsupported info level %d\n", info_level);
213 break;
214 }
215
216 done:
217 return result;
218}
219
220static void display_share_info_1(struct srvsvc_NetShareInfo1 *r)
221{
222 printf("netname: %s\n", r->name);
223 printf("\tremark:\t%s\n", r->comment);
224}
225
226static void display_share_info_2(struct srvsvc_NetShareInfo2 *r)
227{
228 printf("netname: %s\n", r->name);
229 printf("\tremark:\t%s\n", r->comment);
230 printf("\tpath:\t%s\n", r->path);
231 printf("\tpassword:\t%s\n", r->password);
232}
233
234static void display_share_info_502(struct srvsvc_NetShareInfo502 *r)
235{
236 printf("netname: %s\n", r->name);
237 printf("\tremark:\t%s\n", r->comment);
238 printf("\tpath:\t%s\n", r->path);
239 printf("\tpassword:\t%s\n", r->password);
240
241 printf("\ttype:\t0x%x\n", r->type);
242 printf("\tperms:\t%d\n", r->permissions);
243 printf("\tmax_uses:\t%d\n", r->max_users);
244 printf("\tnum_uses:\t%d\n", r->current_users);
245
246 if (r->sd_buf.sd)
247 display_sec_desc(r->sd_buf.sd);
248
249}
250
251static WERROR cmd_srvsvc_net_share_enum_int(struct rpc_pipe_client *cli,
252 TALLOC_CTX *mem_ctx,
253 int argc, const char **argv,
254 uint32_t opcode)
255{
256 uint32 info_level = 2;
257 struct srvsvc_NetShareInfoCtr info_ctr;
258 struct srvsvc_NetShareCtr0 ctr0;
259 struct srvsvc_NetShareCtr1 ctr1;
260 struct srvsvc_NetShareCtr2 ctr2;
261 struct srvsvc_NetShareCtr501 ctr501;
262 struct srvsvc_NetShareCtr502 ctr502;
263 struct srvsvc_NetShareCtr1004 ctr1004;
264 struct srvsvc_NetShareCtr1005 ctr1005;
265 struct srvsvc_NetShareCtr1006 ctr1006;
266 struct srvsvc_NetShareCtr1007 ctr1007;
267 struct srvsvc_NetShareCtr1501 ctr1501;
268 WERROR result;
269 NTSTATUS status;
270 uint32_t totalentries = 0;
271 uint32_t resume_handle = 0;
272 uint32_t *resume_handle_p = NULL;
273 uint32 preferred_len = 0xffffffff, i;
274
275 if (argc > 3) {
276 printf("Usage: %s [infolevel] [resume_handle]\n", argv[0]);
277 return WERR_OK;
278 }
279
280 if (argc >= 2) {
281 info_level = atoi(argv[1]);
282 }
283
284 if (argc == 3) {
285 resume_handle = atoi(argv[2]);
286 resume_handle_p = &resume_handle;
287 }
288
289 ZERO_STRUCT(info_ctr);
290
291 info_ctr.level = info_level;
292
293 switch (info_level) {
294 case 0:
295 ZERO_STRUCT(ctr0);
296 info_ctr.ctr.ctr0 = &ctr0;
297 break;
298 case 1:
299 ZERO_STRUCT(ctr1);
300 info_ctr.ctr.ctr1 = &ctr1;
301 break;
302 case 2:
303 ZERO_STRUCT(ctr2);
304 info_ctr.ctr.ctr2 = &ctr2;
305 break;
306 case 501:
307 ZERO_STRUCT(ctr501);
308 info_ctr.ctr.ctr501 = &ctr501;
309 break;
310 case 502:
311 ZERO_STRUCT(ctr502);
312 info_ctr.ctr.ctr502 = &ctr502;
313 break;
314 case 1004:
315 ZERO_STRUCT(ctr1004);
316 info_ctr.ctr.ctr1004 = &ctr1004;
317 break;
318 case 1005:
319 ZERO_STRUCT(ctr1005);
320 info_ctr.ctr.ctr1005 = &ctr1005;
321 break;
322 case 1006:
323 ZERO_STRUCT(ctr1006);
324 info_ctr.ctr.ctr1006 = &ctr1006;
325 break;
326 case 1007:
327 ZERO_STRUCT(ctr1007);
328 info_ctr.ctr.ctr1007 = &ctr1007;
329 break;
330 case 1501:
331 ZERO_STRUCT(ctr1501);
332 info_ctr.ctr.ctr1501 = &ctr1501;
333 break;
334 }
335
336 switch (opcode) {
337 case NDR_SRVSVC_NETSHAREENUM:
338 status = rpccli_srvsvc_NetShareEnum(cli, mem_ctx,
339 cli->cli->desthost,
340 &info_ctr,
341 preferred_len,
342 &totalentries,
343 resume_handle_p,
344 &result);
345 break;
346 case NDR_SRVSVC_NETSHAREENUMALL:
347 status = rpccli_srvsvc_NetShareEnumAll(cli, mem_ctx,
348 cli->cli->desthost,
349 &info_ctr,
350 preferred_len,
351 &totalentries,
352 resume_handle_p,
353 &result);
354 break;
355 default:
356 return WERR_INVALID_PARAM;
357 }
358
359 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {
360 goto done;
361 }
362
363 /* Display results */
364
365 switch (info_level) {
366 case 1:
367 for (i = 0; i < totalentries; i++)
368 display_share_info_1(&info_ctr.ctr.ctr1->array[i]);
369 break;
370 case 2:
371 for (i = 0; i < totalentries; i++)
372 display_share_info_2(&info_ctr.ctr.ctr2->array[i]);
373 break;
374 case 502:
375 for (i = 0; i < totalentries; i++)
376 display_share_info_502(&info_ctr.ctr.ctr502->array[i]);
377 break;
378 default:
379 printf("unsupported info level %d\n", info_level);
380 break;
381 }
382
383 done:
384 return result;
385}
386
387static WERROR cmd_srvsvc_net_share_enum(struct rpc_pipe_client *cli,
388 TALLOC_CTX *mem_ctx,
389 int argc, const char **argv)
390{
391 return cmd_srvsvc_net_share_enum_int(cli, mem_ctx,
392 argc, argv,
393 NDR_SRVSVC_NETSHAREENUM);
394}
395
396static WERROR cmd_srvsvc_net_share_enum_all(struct rpc_pipe_client *cli,
397 TALLOC_CTX *mem_ctx,
398 int argc, const char **argv)
399{
400 return cmd_srvsvc_net_share_enum_int(cli, mem_ctx,
401 argc, argv,
402 NDR_SRVSVC_NETSHAREENUMALL);
403}
404
405static WERROR cmd_srvsvc_net_share_get_info(struct rpc_pipe_client *cli,
406 TALLOC_CTX *mem_ctx,
407 int argc, const char **argv)
408{
409 uint32 info_level = 502;
410 union srvsvc_NetShareInfo info;
411 WERROR result;
412 NTSTATUS status;
413
414 if (argc < 2 || argc > 3) {
415 printf("Usage: %s [sharename] [infolevel]\n", argv[0]);
416 return WERR_OK;
417 }
418
419 if (argc == 3)
420 info_level = atoi(argv[2]);
421
422 status = rpccli_srvsvc_NetShareGetInfo(cli, mem_ctx,
423 cli->cli->desthost,
424 argv[1],
425 info_level,
426 &info,
427 &result);
428
429 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {
430 goto done;
431 }
432
433 /* Display results */
434
435 switch (info_level) {
436 case 1:
437 display_share_info_1(info.info1);
438 break;
439 case 2:
440 display_share_info_2(info.info2);
441 break;
442 case 502:
443 display_share_info_502(info.info502);
444 break;
445 default:
446 printf("unsupported info level %d\n", info_level);
447 break;
448 }
449
450 done:
451 return result;
452}
453
454static WERROR cmd_srvsvc_net_share_set_info(struct rpc_pipe_client *cli,
455 TALLOC_CTX *mem_ctx,
456 int argc, const char **argv)
457{
458 uint32 info_level = 502;
459 union srvsvc_NetShareInfo info_get;
460 WERROR result;
461 NTSTATUS status;
462 uint32_t parm_err = 0;
463
464 if (argc > 3) {
465 printf("Usage: %s [sharename] [comment]\n", argv[0]);
466 return WERR_OK;
467 }
468
469 /* retrieve share info */
470 status = rpccli_srvsvc_NetShareGetInfo(cli, mem_ctx,
471 cli->cli->desthost,
472 argv[1],
473 info_level,
474 &info_get,
475 &result);
476
477 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {
478 goto done;
479 }
480
481 info_get.info502->comment = argv[2];
482
483 /* set share info */
484 status = rpccli_srvsvc_NetShareSetInfo(cli, mem_ctx,
485 cli->cli->desthost,
486 argv[1],
487 info_level,
488 &info_get,
489 &parm_err,
490 &result);
491
492 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {
493 goto done;
494 }
495
496 /* re-retrieve share info and display */
497 status = rpccli_srvsvc_NetShareGetInfo(cli, mem_ctx,
498 cli->cli->desthost,
499 argv[1],
500 info_level,
501 &info_get,
502 &result);
503
504 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {
505 goto done;
506 }
507
508 display_share_info_502(info_get.info502);
509
510 done:
511 return result;
512}
513
514static WERROR cmd_srvsvc_net_remote_tod(struct rpc_pipe_client *cli,
515 TALLOC_CTX *mem_ctx,
516 int argc, const char **argv)
517{
518 struct srvsvc_NetRemoteTODInfo *tod = NULL;
519 WERROR result;
520 NTSTATUS status;
521
522 if (argc > 1) {
523 printf("Usage: %s\n", argv[0]);
524 return WERR_OK;
525 }
526
527 status = rpccli_srvsvc_NetRemoteTOD(cli, mem_ctx,
528 cli->cli->srv_name_slash,
529 &tod,
530 &result);
531 if (!NT_STATUS_IS_OK(status)) {
532 result = ntstatus_to_werror(status);
533 goto done;
534 }
535
536 if (!W_ERROR_IS_OK(result))
537 goto done;
538
539 done:
540 return result;
541}
542
543static WERROR cmd_srvsvc_net_file_enum(struct rpc_pipe_client *cli,
544 TALLOC_CTX *mem_ctx,
545 int argc, const char **argv)
546{
547 uint32 info_level = 3;
548 struct srvsvc_NetFileInfoCtr info_ctr;
549 struct srvsvc_NetFileCtr3 ctr3;
550 WERROR result;
551 NTSTATUS status;
552 uint32 preferred_len = 0xffff;
553 uint32_t total_entries = 0;
554 uint32_t resume_handle = 0;
555
556 if (argc > 2) {
557 printf("Usage: %s [infolevel]\n", argv[0]);
558 return WERR_OK;
559 }
560
561 if (argc == 2)
562 info_level = atoi(argv[1]);
563
564 ZERO_STRUCT(info_ctr);
565 ZERO_STRUCT(ctr3);
566
567 info_ctr.level = info_level;
568 info_ctr.ctr.ctr3 = &ctr3;
569
570 status = rpccli_srvsvc_NetFileEnum(cli, mem_ctx,
571 cli->cli->desthost,
572 NULL,
573 NULL,
574 &info_ctr,
575 preferred_len,
576 &total_entries,
577 &resume_handle,
578 &result);
579
580 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result))
581 goto done;
582
583 done:
584 return result;
585}
586
587static WERROR cmd_srvsvc_net_name_validate(struct rpc_pipe_client *cli,
588 TALLOC_CTX *mem_ctx,
589 int argc, const char **argv)
590{
591 WERROR result;
592 NTSTATUS status;
593 uint32_t name_type = 9;
594 uint32_t flags = 0;
595
596 if (argc < 2 || argc > 3) {
597 printf("Usage: %s [sharename] [type]\n", argv[0]);
598 return WERR_OK;
599 }
600
601 if (argc == 3) {
602 name_type = atoi(argv[2]);
603 }
604
605 status = rpccli_srvsvc_NetNameValidate(cli, mem_ctx,
606 cli->cli->desthost,
607 argv[1],
608 name_type,
609 flags,
610 &result);
611
612 if (!W_ERROR_IS_OK(result))
613 goto done;
614
615 done:
616 return result;
617}
618
619static WERROR cmd_srvsvc_net_file_get_sec(struct rpc_pipe_client *cli,
620 TALLOC_CTX *mem_ctx,
621 int argc, const char **argv)
622{
623 WERROR result;
624 NTSTATUS status;
625 struct sec_desc_buf *sd_buf = NULL;
626
627 if (argc < 2 || argc > 4) {
628 printf("Usage: %s [sharename] [file]\n", argv[0]);
629 return WERR_OK;
630 }
631
632 status = rpccli_srvsvc_NetGetFileSecurity(cli, mem_ctx,
633 cli->cli->desthost,
634 argv[1],
635 argv[2],
636 SECINFO_DACL,
637 &sd_buf,
638 &result);
639
640 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {
641 goto done;
642 }
643
644 display_sec_desc(sd_buf->sd);
645
646 done:
647 return result;
648}
649
650static WERROR cmd_srvsvc_net_sess_del(struct rpc_pipe_client *cli,
651 TALLOC_CTX *mem_ctx,
652 int argc, const char **argv)
653{
654 WERROR result;
655 NTSTATUS status;
656
657 if (argc < 2 || argc > 4) {
658 printf("Usage: %s [client] [user]\n", argv[0]);
659 return WERR_OK;
660 }
661
662 status = rpccli_srvsvc_NetSessDel(cli, mem_ctx,
663 cli->cli->desthost,
664 argv[1],
665 argv[2],
666 &result);
667
668 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {
669 goto done;
670 }
671
672 done:
673 return result;
674}
675
676static WERROR cmd_srvsvc_net_sess_enum(struct rpc_pipe_client *cli,
677 TALLOC_CTX *mem_ctx,
678 int argc, const char **argv)
679{
680 WERROR result;
681 NTSTATUS status;
682 struct srvsvc_NetSessInfoCtr info_ctr;
683 struct srvsvc_NetSessCtr0 ctr0;
684 struct srvsvc_NetSessCtr1 ctr1;
685 struct srvsvc_NetSessCtr2 ctr2;
686 struct srvsvc_NetSessCtr10 ctr10;
687 struct srvsvc_NetSessCtr502 ctr502;
688 uint32_t total_entries = 0;
689 uint32_t resume_handle = 0;
690 uint32_t *resume_handle_p = NULL;
691 uint32_t level = 1;
692 const char *client = NULL;
693 const char *user = NULL;
694
695 if (argc > 6) {
696 printf("Usage: %s [client] [user] [level] [resume_handle]\n", argv[0]);
697 return WERR_OK;
698 }
699
700 if (argc >= 2) {
701 client = argv[1];
702 }
703
704 if (argc >= 3) {
705 user = argv[2];
706 }
707
708 if (argc >= 4) {
709 level = atoi(argv[3]);
710 }
711
712 if (argc >= 5) {
713 resume_handle = atoi(argv[4]);
714 resume_handle_p = &resume_handle;
715 }
716
717 ZERO_STRUCT(info_ctr);
718
719 info_ctr.level = level;
720
721 d_printf("trying level: %d\n", level);
722
723 switch (level) {
724 case 0:
725 ZERO_STRUCT(ctr0);
726 info_ctr.ctr.ctr0 = &ctr0;
727 break;
728 case 1:
729 ZERO_STRUCT(ctr1);
730 info_ctr.ctr.ctr1 = &ctr1;
731 break;
732 case 2:
733 ZERO_STRUCT(ctr2);
734 info_ctr.ctr.ctr2 = &ctr2;
735 break;
736 case 10:
737 ZERO_STRUCT(ctr10);
738 info_ctr.ctr.ctr10 = &ctr10;
739 break;
740 case 502:
741 ZERO_STRUCT(ctr502);
742 info_ctr.ctr.ctr502 = &ctr502;
743 break;
744 }
745
746 status = rpccli_srvsvc_NetSessEnum(cli, mem_ctx,
747 cli->cli->desthost,
748 client,
749 user,
750 &info_ctr,
751 0xffffffff,
752 &total_entries,
753 resume_handle_p,
754 &result);
755
756 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {
757 goto done;
758 }
759
760 done:
761 return result;
762}
763
764static WERROR cmd_srvsvc_net_disk_enum(struct rpc_pipe_client *cli,
765 TALLOC_CTX *mem_ctx,
766 int argc, const char **argv)
767{
768 struct srvsvc_NetDiskInfo info;
769 WERROR result;
770 NTSTATUS status;
771 uint32_t total_entries = 0;
772 uint32_t resume_handle = 0;
773 uint32_t level = 0;
774
775 if (argc > 4) {
776 printf("Usage: %s [level] [resume_handle]\n", argv[0]);
777 return WERR_OK;
778 }
779
780 if (argc >= 2) {
781 level = atoi(argv[1]);
782 }
783
784 if (argc >= 3) {
785 resume_handle = atoi(argv[2]);
786 }
787
788 ZERO_STRUCT(info);
789
790 status = rpccli_srvsvc_NetDiskEnum(cli, mem_ctx,
791 cli->cli->desthost,
792 level,
793 &info,
794 0xffffffff,
795 &total_entries,
796 &resume_handle,
797 &result);
798
799 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {
800 goto done;
801 }
802
803 done:
804 return result;
805}
806
807static WERROR cmd_srvsvc_net_conn_enum(struct rpc_pipe_client *cli,
808 TALLOC_CTX *mem_ctx,
809 int argc, const char **argv)
810{
811 struct srvsvc_NetConnInfoCtr info_ctr;
812 struct srvsvc_NetConnCtr0 ctr0;
813 struct srvsvc_NetConnCtr1 ctr1;
814 WERROR result;
815 NTSTATUS status;
816 uint32_t total_entries = 0;
817 uint32_t resume_handle = 0;
818 uint32_t *resume_handle_p = NULL;
819 uint32_t level = 1;
820 const char *path = "IPC$";
821
822 if (argc > 4) {
823 printf("Usage: %s [level] [path] [resume_handle]\n", argv[0]);
824 return WERR_OK;
825 }
826
827 if (argc >= 2) {
828 level = atoi(argv[1]);
829 }
830
831 if (argc >= 3) {
832 path = argv[2];
833 }
834
835 if (argc >= 4) {
836 resume_handle = atoi(argv[3]);
837 resume_handle_p = &resume_handle;
838 }
839
840 ZERO_STRUCT(info_ctr);
841
842 info_ctr.level = level;
843
844 switch (level) {
845 case 0:
846 ZERO_STRUCT(ctr0);
847 info_ctr.ctr.ctr0 = &ctr0;
848 break;
849 case 1:
850 ZERO_STRUCT(ctr1);
851 info_ctr.ctr.ctr1 = &ctr1;
852 break;
853 default:
854 return WERR_INVALID_PARAM;
855 }
856
857 status = rpccli_srvsvc_NetConnEnum(cli, mem_ctx,
858 cli->cli->desthost,
859 path,
860 &info_ctr,
861 0xffffffff,
862 &total_entries,
863 resume_handle_p,
864 &result);
865
866 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {
867 goto done;
868 }
869
870 done:
871 return result;
872}
873
874
875/* List of commands exported by this module */
876
877struct cmd_set srvsvc_commands[] = {
878
879 { "SRVSVC" },
880
881 { "srvinfo", RPC_RTYPE_WERROR, NULL, cmd_srvsvc_srv_query_info, PI_SRVSVC, NULL, "Server query info", "" },
882 { "netshareenum",RPC_RTYPE_WERROR, NULL, cmd_srvsvc_net_share_enum, PI_SRVSVC, NULL, "Enumerate shares", "" },
883 { "netshareenumall",RPC_RTYPE_WERROR, NULL, cmd_srvsvc_net_share_enum_all, PI_SRVSVC, NULL, "Enumerate all shares", "" },
884 { "netsharegetinfo",RPC_RTYPE_WERROR, NULL, cmd_srvsvc_net_share_get_info, PI_SRVSVC, NULL, "Get Share Info", "" },
885 { "netsharesetinfo",RPC_RTYPE_WERROR, NULL, cmd_srvsvc_net_share_set_info, PI_SRVSVC, NULL, "Set Share Info", "" },
886 { "netfileenum", RPC_RTYPE_WERROR, NULL, cmd_srvsvc_net_file_enum, PI_SRVSVC, NULL, "Enumerate open files", "" },
887 { "netremotetod",RPC_RTYPE_WERROR, NULL, cmd_srvsvc_net_remote_tod, PI_SRVSVC, NULL, "Fetch remote time of day", "" },
888 { "netnamevalidate", RPC_RTYPE_WERROR, NULL, cmd_srvsvc_net_name_validate, PI_SRVSVC, NULL, "Validate sharename", "" },
889 { "netfilegetsec", RPC_RTYPE_WERROR, NULL, cmd_srvsvc_net_file_get_sec, PI_SRVSVC, NULL, "Get File security", "" },
890 { "netsessdel", RPC_RTYPE_WERROR, NULL, cmd_srvsvc_net_sess_del, PI_SRVSVC, NULL, "Delete Session", "" },
891 { "netsessenum", RPC_RTYPE_WERROR, NULL, cmd_srvsvc_net_sess_enum, PI_SRVSVC, NULL, "Enumerate Sessions", "" },
892 { "netdiskenum", RPC_RTYPE_WERROR, NULL, cmd_srvsvc_net_disk_enum, PI_SRVSVC, NULL, "Enumerate Disks", "" },
893 { "netconnenum", RPC_RTYPE_WERROR, NULL, cmd_srvsvc_net_conn_enum, PI_SRVSVC, NULL, "Enumerate Connections", "" },
894
895 { NULL }
896};
Note: See TracBrowser for help on using the repository browser.