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