source3/rpcclient/cmd_srvsvc.c

   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
  29 static 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
 134 static 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
 140 static 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
 150 static 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 */
 168 static 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
 216 static 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
 222 static 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
 230 static 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
 247 static 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
 383 static 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
 392 static 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
 401 static 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
 450 static 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
 510 static 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
 539 static 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
 583 static 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
 615 static 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
 646 static 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
 672 static 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
 760 static 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
 803 static 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
 873 struct 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 };