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/ndr_srvsvc.h"
  26 #include "../librpc/gen_ndr/ndr_srvsvc_c.h"
  27 #include "../libcli/security/display_sec.h"
  28
  29 /* Display server query info */
  30
  31 static char *get_server_type_str(uint32_t type)
  32 {
  33         static fstring typestr;
  34         int i;
  35
  36         if (type == SV_TYPE_ALL) {
  37                 fstrcpy(typestr, "All");
  38                 return typestr;
  39         }
  40
  41         typestr[0] = 0;
  42
  43         for (i = 0; i < 32; i++) {
  44                 if (type & ((uint32_t)1 << i)) {
  45                         switch (1 << i) {
  46                         case SV_TYPE_WORKSTATION:
  47                                 fstrcat(typestr, "Wk ");
  48                                 break;
  49                         case SV_TYPE_SERVER:
  50                                 fstrcat(typestr, "Sv ");
  51                                 break;
  52                         case SV_TYPE_SQLSERVER:
  53                                 fstrcat(typestr, "Sql ");
  54                                 break;
  55                         case SV_TYPE_DOMAIN_CTRL:
  56                                 fstrcat(typestr, "PDC ");
  57                                 break;
  58                         case SV_TYPE_DOMAIN_BAKCTRL:
  59                                 fstrcat(typestr, "BDC ");
  60                                 break;
  61                         case SV_TYPE_TIME_SOURCE:
  62                                 fstrcat(typestr, "Tim ");
  63                                 break;
  64                         case SV_TYPE_AFP:
  65                                 fstrcat(typestr, "AFP ");
  66                                 break;
  67                         case SV_TYPE_NOVELL:
  68                                 fstrcat(typestr, "Nov ");
  69                                 break;
  70                         case SV_TYPE_DOMAIN_MEMBER:
  71                                 fstrcat(typestr, "Dom ");
  72                                 break;
  73                         case SV_TYPE_PRINTQ_SERVER:
  74                                 fstrcat(typestr, "PrQ ");
  75                                 break;
  76                         case SV_TYPE_DIALIN_SERVER:
  77                                 fstrcat(typestr, "Din ");
  78                                 break;
  79                         case SV_TYPE_SERVER_UNIX:
  80                                 fstrcat(typestr, "Unx ");
  81                                 break;
  82                         case SV_TYPE_NT:
  83                                 fstrcat(typestr, "NT ");
  84                                 break;
  85                         case SV_TYPE_WFW:
  86                                 fstrcat(typestr, "Wfw ");
  87                                 break;
  88                         case SV_TYPE_SERVER_MFPN:
  89                                 fstrcat(typestr, "Mfp ");
  90                                 break;
  91                         case SV_TYPE_SERVER_NT:
  92                                 fstrcat(typestr, "SNT ");
  93                                 break;
  94                         case SV_TYPE_POTENTIAL_BROWSER:
  95                                 fstrcat(typestr, "PtB ");
  96                                 break;
  97                         case SV_TYPE_BACKUP_BROWSER:
  98                                 fstrcat(typestr, "BMB ");
  99                                 break;
 100                         case SV_TYPE_MASTER_BROWSER:
 101                                 fstrcat(typestr, "LMB ");
 102                                 break;
 103                         case SV_TYPE_DOMAIN_MASTER:
 104                                 fstrcat(typestr, "DMB ");
 105                                 break;
 106                         case SV_TYPE_SERVER_OSF:
 107                                 fstrcat(typestr, "OSF ");
 108                                 break;
 109                         case SV_TYPE_SERVER_VMS:
 110                                 fstrcat(typestr, "VMS ");
 111                                 break;
 112                         case SV_TYPE_WIN95_PLUS:
 113                                 fstrcat(typestr, "W95 ");
 114                                 break;
 115                         case SV_TYPE_ALTERNATE_XPORT:
 116                                 fstrcat(typestr, "Xpt ");
 117                                 break;
 118                         case SV_TYPE_LOCAL_LIST_ONLY:
 119                                 fstrcat(typestr, "Dom ");
 120                                 break;
 121                         case SV_TYPE_DOMAIN_ENUM:
 122                                 fstrcat(typestr, "Loc ");
 123                                 break;
 124                         }
 125                 }
 126         }
 127
 128         i = strlen(typestr) - 1;
 129
 130         if (typestr[i] == ' ')
 131                 typestr[i] = 0;
 132
 133         return typestr;
 134 }
 135
 136 static void display_server(const char *sname, uint32_t type, const char *comment)
 137 {
 138         printf("\t%-15.15s%-20s %s\n", sname, get_server_type_str(type),
 139                comment);
 140 }
 141
 142 static void display_srv_info_101(struct srvsvc_NetSrvInfo101 *r)
 143 {
 144         display_server(r->server_name, r->server_type, r->comment);
 145
 146         printf("\tplatform_id     :\t%d\n", r->platform_id);
 147         printf("\tos version      :\t%d.%d\n",
 148                 r->version_major, r->version_minor);
 149         printf("\tserver type     :\t0x%x\n", r->server_type);
 150 }
 151
 152 static void display_srv_info_102(struct srvsvc_NetSrvInfo102 *r)
 153 {
 154         display_server(r->server_name, r->server_type, r->comment);
 155
 156         printf("\tplatform_id     :\t%d\n", r->platform_id);
 157         printf("\tos version      :\t%d.%d\n",
 158                 r->version_major, r->version_minor);
 159         printf("\tserver type     :\t0x%x\n", r->server_type);
 160
 161         printf("\tusers           :\t%x\n", r->users);
 162         printf("\tdisc, hidden    :\t%x, %x\n", r->disc, r->hidden);
 163         printf("\tannounce, delta :\t%d, %d\n", r->announce,
 164                r->anndelta);
 165         printf("\tlicenses        :\t%d\n", r->licenses);
 166         printf("\tuser path       :\t%s\n", r->userpath);
 167 }
 168
 169 /* Server query info */
 170 static WERROR cmd_srvsvc_srv_query_info(struct rpc_pipe_client *cli,
 171                                           TALLOC_CTX *mem_ctx,
 172                                           int argc, const char **argv)
 173 {
 174         uint32_t info_level = 101;
 175         union srvsvc_NetSrvInfo info;
 176         WERROR result;
 177         NTSTATUS status;
 178         const char *server_unc = cli->srv_name_slash;
 179         struct dcerpc_binding_handle *b = cli->binding_handle;
 180
 181         if (argc > 3) {
 182                 printf("Usage: %s [infolevel] [server_unc]\n", argv[0]);
 183                 return WERR_OK;
 184         }
 185
 186         if (argc >= 2) {
 187                 info_level = atoi(argv[1]);
 188         }
 189
 190         if (argc >= 3) {
 191                 server_unc = argv[2];
 192         }
 193
 194         status = dcerpc_srvsvc_NetSrvGetInfo(b, mem_ctx,
 195                                              server_unc,
 196                                              info_level,
 197                                              &info,
 198                                              &result);
 199         if (!NT_STATUS_IS_OK(status)) {
 200                 return ntstatus_to_werror(status);
 201         }
 202
 203         if (!W_ERROR_IS_OK(result)) {
 204                 goto done;
 205         }
 206
 207         /* Display results */
 208
 209         switch (info_level) {
 210         case 101:
 211                 display_srv_info_101(info.info101);
 212                 break;
 213         case 102:
 214                 display_srv_info_102(info.info102);
 215                 break;
 216         default:
 217                 printf("unsupported info level %d\n", info_level);
 218                 break;
 219         }
 220
 221  done:
 222         return result;
 223 }
 224
 225 static void display_share_info_1(struct srvsvc_NetShareInfo1 *r)
 226 {
 227         printf("netname: %s\n", r->name);
 228         printf("\tremark:\t%s\n", r->comment);
 229 }
 230
 231 static void display_share_info_2(struct srvsvc_NetShareInfo2 *r)
 232 {
 233         printf("netname: %s\n", r->name);
 234         printf("\tremark:\t%s\n", r->comment);
 235         printf("\tpath:\t%s\n", r->path);
 236         printf("\tpassword:\t%s\n", r->password);
 237 }
 238
 239 static void display_share_info_502(struct srvsvc_NetShareInfo502 *r)
 240 {
 241         printf("netname: %s\n", r->name);
 242         printf("\tremark:\t%s\n", r->comment);
 243         printf("\tpath:\t%s\n", r->path);
 244         printf("\tpassword:\t%s\n", r->password);
 245
 246         printf("\ttype:\t0x%x\n", r->type);
 247         printf("\tperms:\t%d\n", r->permissions);
 248         printf("\tmax_uses:\t%d\n", r->max_users);
 249         printf("\tnum_uses:\t%d\n", r->current_users);
 250
 251         if (r->sd_buf.sd)
 252                 display_sec_desc(r->sd_buf.sd);
 253
 254 }
 255
 256 static void display_share_info_1005(struct srvsvc_NetShareInfo1005 *r)
 257 {
 258         printf("flags: 0x%x\n", r->dfs_flags);
 259         printf("csc caching: %u\n",
 260                (r->dfs_flags & SHARE_1005_CSC_POLICY_MASK) >>
 261                SHARE_1005_CSC_POLICY_SHIFT);
 262 }
 263
 264 static WERROR cmd_srvsvc_net_share_enum_int(struct rpc_pipe_client *cli,
 265                                             TALLOC_CTX *mem_ctx,
 266                                             int argc, const char **argv,
 267                                             uint32_t opcode)
 268 {
 269         uint32_t info_level = 2;
 270         struct srvsvc_NetShareInfoCtr info_ctr;
 271         struct srvsvc_NetShareCtr0 ctr0;
 272         struct srvsvc_NetShareCtr1 ctr1;
 273         struct srvsvc_NetShareCtr2 ctr2;
 274         struct srvsvc_NetShareCtr501 ctr501;
 275         struct srvsvc_NetShareCtr502 ctr502;
 276         struct srvsvc_NetShareCtr1004 ctr1004;
 277         struct srvsvc_NetShareCtr1005 ctr1005;
 278         struct srvsvc_NetShareCtr1006 ctr1006;
 279         struct srvsvc_NetShareCtr1007 ctr1007;
 280         struct srvsvc_NetShareCtr1501 ctr1501;
 281         WERROR result;
 282         NTSTATUS status;
 283         uint32_t totalentries = 0;
 284         uint32_t count = 0;
 285         uint32_t resume_handle = 0;
 286         uint32_t *resume_handle_p = NULL;
 287         uint32_t preferred_len = 0xffffffff, i;
 288         struct dcerpc_binding_handle *b = cli->binding_handle;
 289
 290         if (argc > 3) {
 291                 printf("Usage: %s [infolevel] [resume_handle]\n", argv[0]);
 292                 return WERR_OK;
 293         }
 294
 295         if (argc >= 2) {
 296                 info_level = atoi(argv[1]);
 297         }
 298
 299         if (argc == 3) {
 300                 resume_handle = atoi(argv[2]);
 301                 resume_handle_p = &resume_handle;
 302         }
 303
 304         ZERO_STRUCT(info_ctr);
 305
 306         info_ctr.level = info_level;
 307
 308         switch (info_level) {
 309         case 0:
 310                 ZERO_STRUCT(ctr0);
 311                 info_ctr.ctr.ctr0 = &ctr0;
 312                 break;
 313         case 1:
 314                 ZERO_STRUCT(ctr1);
 315                 info_ctr.ctr.ctr1 = &ctr1;
 316                 break;
 317         case 2:
 318                 ZERO_STRUCT(ctr2);
 319                 info_ctr.ctr.ctr2 = &ctr2;
 320                 break;
 321         case 501:
 322                 ZERO_STRUCT(ctr501);
 323                 info_ctr.ctr.ctr501 = &ctr501;
 324                 break;
 325         case 502:
 326                 ZERO_STRUCT(ctr502);
 327                 info_ctr.ctr.ctr502 = &ctr502;
 328                 break;
 329         case 1004:
 330                 ZERO_STRUCT(ctr1004);
 331                 info_ctr.ctr.ctr1004 = &ctr1004;
 332                 break;
 333         case 1005:
 334                 ZERO_STRUCT(ctr1005);
 335                 info_ctr.ctr.ctr1005 = &ctr1005;
 336                 break;
 337         case 1006:
 338                 ZERO_STRUCT(ctr1006);
 339                 info_ctr.ctr.ctr1006 = &ctr1006;
 340                 break;
 341         case 1007:
 342                 ZERO_STRUCT(ctr1007);
 343                 info_ctr.ctr.ctr1007 = &ctr1007;
 344                 break;
 345         case 1501:
 346                 ZERO_STRUCT(ctr1501);
 347                 info_ctr.ctr.ctr1501 = &ctr1501;
 348                 break;
 349         }
 350
 351         switch (opcode) {
 352                 case NDR_SRVSVC_NETSHAREENUM:
 353                         status = dcerpc_srvsvc_NetShareEnum(b, mem_ctx,
 354                                                             cli->desthost,
 355                                                             &info_ctr,
 356                                                             preferred_len,
 357                                                             &totalentries,
 358                                                             resume_handle_p,
 359                                                             &result);
 360                         break;
 361                 case NDR_SRVSVC_NETSHAREENUMALL:
 362                         status = dcerpc_srvsvc_NetShareEnumAll(b, mem_ctx,
 363                                                                cli->desthost,
 364                                                                &info_ctr,
 365                                                                preferred_len,
 366                                                                &totalentries,
 367                                                                resume_handle_p,
 368                                                                &result);
 369                         break;
 370                 default:
 371                         return WERR_INVALID_PARAMETER;
 372         }
 373
 374         if (!NT_STATUS_IS_OK(status)) {
 375                 result = ntstatus_to_werror(status);
 376                 goto done;
 377         }
 378         if (!W_ERROR_IS_OK(result)) {
 379                 goto done;
 380         }
 381
 382         /* Display results */
 383
 384         switch (info_level) {
 385         case 1:
 386                 count = info_ctr.ctr.ctr1->count;
 387                 for (i = 0; i < count; i++)
 388                         display_share_info_1(&info_ctr.ctr.ctr1->array[i]);
 389                 break;
 390         case 2:
 391                 count = info_ctr.ctr.ctr2->count;
 392                 for (i = 0; i < count; i++)
 393                         display_share_info_2(&info_ctr.ctr.ctr2->array[i]);
 394                 break;
 395         case 502:
 396                 count = info_ctr.ctr.ctr502->count;
 397                 for (i = 0; i < count; i++)
 398                         display_share_info_502(&info_ctr.ctr.ctr502->array[i]);
 399                 break;
 400         default:
 401                 printf("unsupported info level %d\n", info_level);
 402                 break;
 403         }
 404
 405  done:
 406         return result;
 407 }
 408
 409 static WERROR cmd_srvsvc_net_share_enum(struct rpc_pipe_client *cli,
 410                                         TALLOC_CTX *mem_ctx,
 411                                         int argc, const char **argv)
 412 {
 413         return cmd_srvsvc_net_share_enum_int(cli, mem_ctx,
 414                                              argc, argv,
 415                                              NDR_SRVSVC_NETSHAREENUM);
 416 }
 417
 418 static WERROR cmd_srvsvc_net_share_enum_all(struct rpc_pipe_client *cli,
 419                                             TALLOC_CTX *mem_ctx,
 420                                             int argc, const char **argv)
 421 {
 422         return cmd_srvsvc_net_share_enum_int(cli, mem_ctx,
 423                                              argc, argv,
 424                                              NDR_SRVSVC_NETSHAREENUMALL);
 425 }
 426
 427 static WERROR cmd_srvsvc_net_share_get_info(struct rpc_pipe_client *cli,
 428                                             TALLOC_CTX *mem_ctx,
 429                                             int argc, const char **argv)
 430 {
 431         uint32_t info_level = 502;
 432         union srvsvc_NetShareInfo info;
 433         WERROR result;
 434         NTSTATUS status;
 435         struct dcerpc_binding_handle *b = cli->binding_handle;
 436
 437         if (argc < 2 || argc > 3) {
 438                 printf("Usage: %s sharename [infolevel 1|2|502|1005]\n",
 439                        argv[0]);
 440                 return WERR_OK;
 441         }
 442
 443         if (argc == 3)
 444                 info_level = atoi(argv[2]);
 445
 446         status = dcerpc_srvsvc_NetShareGetInfo(b, mem_ctx,
 447                                                cli->desthost,
 448                                                argv[1],
 449                                                info_level,
 450                                                &info,
 451                                                &result);
 452
 453         if (!NT_STATUS_IS_OK(status)) {
 454                 result = ntstatus_to_werror(status);
 455                 goto done;
 456         }
 457         if (!W_ERROR_IS_OK(result)) {
 458                 goto done;
 459         }
 460
 461         /* Display results */
 462
 463         switch (info_level) {
 464         case 1:
 465                 display_share_info_1(info.info1);
 466                 break;
 467         case 2:
 468                 display_share_info_2(info.info2);
 469                 break;
 470         case 502:
 471                 display_share_info_502(info.info502);
 472                 break;
 473         case 1005:
 474                 display_share_info_1005(info.info1005);
 475                 break;
 476         default:
 477                 printf("unsupported info level %d\n", info_level);
 478                 break;
 479         }
 480
 481  done:
 482         return result;
 483 }
 484
 485 static WERROR cmd_srvsvc_net_share_set_info(struct rpc_pipe_client *cli,
 486                                             TALLOC_CTX *mem_ctx,
 487                                             int argc, const char **argv)
 488 {
 489         uint32_t info_level = 502;
 490         union srvsvc_NetShareInfo info_get;
 491         WERROR result;
 492         NTSTATUS status;
 493         uint32_t parm_err = 0;
 494         struct dcerpc_binding_handle *b = cli->binding_handle;
 495
 496         if (argc > 3) {
 497                 printf("Usage: %s [sharename] [comment]\n", argv[0]);
 498                 return WERR_OK;
 499         }
 500
 501         /* retrieve share info */
 502         status = dcerpc_srvsvc_NetShareGetInfo(b, mem_ctx,
 503                                                cli->desthost,
 504                                                argv[1],
 505                                                info_level,
 506                                                &info_get,
 507                                                &result);
 508
 509         if (!NT_STATUS_IS_OK(status)) {
 510                 result = ntstatus_to_werror(status);
 511                 goto done;
 512         }
 513         if (!W_ERROR_IS_OK(result)) {
 514                 goto done;
 515         }
 516
 517         info_get.info502->comment = argv[2];
 518
 519         /* set share info */
 520         status = dcerpc_srvsvc_NetShareSetInfo(b, mem_ctx,
 521                                                cli->desthost,
 522                                                argv[1],
 523                                                info_level,
 524                                                &info_get,
 525                                                &parm_err,
 526                                                &result);
 527
 528         if (!NT_STATUS_IS_OK(status)) {
 529                 result = ntstatus_to_werror(status);
 530                 goto done;
 531         }
 532         if (!W_ERROR_IS_OK(result)) {
 533                 goto done;
 534         }
 535
 536         /* re-retrieve share info and display */
 537         status = dcerpc_srvsvc_NetShareGetInfo(b, mem_ctx,
 538                                                cli->desthost,
 539                                                argv[1],
 540                                                info_level,
 541                                                &info_get,
 542                                                &result);
 543         if (!NT_STATUS_IS_OK(status)) {
 544                 result = ntstatus_to_werror(status);
 545                 goto done;
 546         }
 547         if (!W_ERROR_IS_OK(result)) {
 548                 goto done;
 549         }
 550
 551         display_share_info_502(info_get.info502);
 552
 553  done:
 554         return result;
 555 }
 556
 557 static WERROR cmd_srvsvc_net_share_set_dfs_flags(struct rpc_pipe_client *cli,
 558                                             TALLOC_CTX *mem_ctx,
 559                                             int argc, const char **argv)
 560 {
 561         struct srvsvc_NetShareInfo1005 info1005 = { 0 };
 562         union srvsvc_NetShareInfo info = { .info1005 = &info1005 };
 563         WERROR result;
 564         NTSTATUS status;
 565         uint32_t parm_err = 0;
 566         struct dcerpc_binding_handle *b = cli->binding_handle;
 567
 568         if (argc > 3) {
 569                 printf("Usage: %s [sharename] [dfsflags]\n", argv[0]);
 570                 return WERR_OK;
 571         }
 572
 573         if (argc > 2) {
 574                 info.info1005->dfs_flags = strtol(argv[2], NULL, 0);
 575         }
 576
 577         /* set share info */
 578         status = dcerpc_srvsvc_NetShareSetInfo(b, mem_ctx,
 579                                                cli->desthost,
 580                                                argv[1],
 581                                                1005,
 582                                                &info,
 583                                                &parm_err,
 584                                                &result);
 585
 586         if (!NT_STATUS_IS_OK(status)) {
 587                 return ntstatus_to_werror(status);
 588         }
 589         if (!W_ERROR_IS_OK(result)) {
 590                 return result;
 591         }
 592
 593         /* re-retrieve share info and display */
 594         status = dcerpc_srvsvc_NetShareGetInfo(b, mem_ctx,
 595                                                cli->desthost,
 596                                                argv[1],
 597                                                1005,
 598                                                &info,
 599                                                &result);
 600         if (!NT_STATUS_IS_OK(status)) {
 601                 return ntstatus_to_werror(status);
 602         }
 603         if (!W_ERROR_IS_OK(result)) {
 604                 return result;
 605         }
 606
 607         display_share_info_1005(info.info1005);
 608
 609         return result;
 610 }
 611
 612 static WERROR cmd_srvsvc_net_remote_tod(struct rpc_pipe_client *cli,
 613                                           TALLOC_CTX *mem_ctx,
 614                                           int argc, const char **argv)
 615 {
 616         struct srvsvc_NetRemoteTODInfo *tod = NULL;
 617         WERROR result;
 618         NTSTATUS status;
 619         struct dcerpc_binding_handle *b = cli->binding_handle;
 620
 621         if (argc > 1) {
 622                 printf("Usage: %s\n", argv[0]);
 623                 return WERR_OK;
 624         }
 625
 626         status = dcerpc_srvsvc_NetRemoteTOD(b, mem_ctx,
 627                                             cli->srv_name_slash,
 628                                             &tod,
 629                                             &result);
 630         if (!NT_STATUS_IS_OK(status)) {
 631                 result = ntstatus_to_werror(status);
 632                 goto done;
 633         }
 634
 635         if (!W_ERROR_IS_OK(result))
 636                 goto done;
 637
 638  done:
 639         return result;
 640 }
 641
 642 static WERROR cmd_srvsvc_net_file_enum(struct rpc_pipe_client *cli,
 643                                          TALLOC_CTX *mem_ctx,
 644                                          int argc, const char **argv)
 645 {
 646         struct srvsvc_NetFileCtr3 ctr3 = { 0 };
 647         struct srvsvc_NetFileInfoCtr info_ctr = {
 648                 .level = 3,
 649                 .ctr = {
 650                         .ctr3 = &ctr3,
 651                 },
 652         };
 653         WERROR result;
 654         NTSTATUS status;
 655         uint32_t preferred_len = 0xffff;
 656         uint32_t total_entries = 0;
 657         uint32_t resume_handle = 0;
 658         struct dcerpc_binding_handle *b = cli->binding_handle;
 659
 660         if (argc > 2) {
 661                 printf("Usage: %s [infolevel]\n", argv[0]);
 662                 return WERR_OK;
 663         }
 664
 665         if (argc == 2) {
 666                 info_ctr.level = atoi(argv[1]);
 667         }
 668
 669         status = dcerpc_srvsvc_NetFileEnum(b, mem_ctx,
 670                                            cli->desthost,
 671                                            NULL,
 672                                            NULL,
 673                                            &info_ctr,
 674                                            preferred_len,
 675                                            &total_entries,
 676                                            &resume_handle,
 677                                            &result);
 678         if (!NT_STATUS_IS_OK(status)) {
 679                 result = ntstatus_to_werror(status);
 680                 goto done;
 681         }
 682
 683         if (!W_ERROR_IS_OK(result)) {
 684                 goto done;
 685         }
 686
 687         if (info_ctr.level == 3) {
 688                 struct srvsvc_NetFileCtr3 *ret = info_ctr.ctr.ctr3;
 689                 uint32_t i;
 690
 691                 for (i=0; i<ret->count; i++) {
 692                         printf("%s\n", ret->array[i].path);
 693                 }
 694         }
 695  done:
 696         return result;
 697 }
 698
 699 static WERROR cmd_srvsvc_net_name_validate(struct rpc_pipe_client *cli,
 700                                            TALLOC_CTX *mem_ctx,
 701                                            int argc, const char **argv)
 702 {
 703         WERROR result;
 704         NTSTATUS status;
 705         uint32_t name_type = 9;
 706         uint32_t flags = 0;
 707         struct dcerpc_binding_handle *b = cli->binding_handle;
 708
 709         if (argc < 2 || argc > 3) {
 710                 printf("Usage: %s [sharename] [type]\n", argv[0]);
 711                 return WERR_OK;
 712         }
 713
 714         if (argc == 3) {
 715                 name_type = atoi(argv[2]);
 716         }
 717
 718         status = dcerpc_srvsvc_NetNameValidate(b, mem_ctx,
 719                                                cli->desthost,
 720                                                argv[1],
 721                                                name_type,
 722                                                flags,
 723                                                &result);
 724         if (!NT_STATUS_IS_OK(status)) {
 725                 result = ntstatus_to_werror(status);
 726                 goto done;
 727         }
 728
 729         if (!W_ERROR_IS_OK(result))
 730                 goto done;
 731
 732  done:
 733         return result;
 734 }
 735
 736 static WERROR cmd_srvsvc_net_file_get_sec(struct rpc_pipe_client *cli,
 737                                           TALLOC_CTX *mem_ctx,
 738                                           int argc, const char **argv)
 739 {
 740         WERROR result;
 741         NTSTATUS status;
 742         struct sec_desc_buf *sd_buf = NULL;
 743         struct dcerpc_binding_handle *b = cli->binding_handle;
 744
 745         if (argc < 2 || argc > 4) {
 746                 printf("Usage: %s [sharename] [file]\n", argv[0]);
 747                 return WERR_OK;
 748         }
 749
 750         status = dcerpc_srvsvc_NetGetFileSecurity(b, mem_ctx,
 751                                                   cli->desthost,
 752                                                   argv[1],
 753                                                   argv[2],
 754                                                   SECINFO_DACL,
 755                                                   &sd_buf,
 756                                                   &result);
 757         if (!NT_STATUS_IS_OK(status)) {
 758                 result = ntstatus_to_werror(status);
 759                 goto done;
 760         }
 761
 762         if (!W_ERROR_IS_OK(result)) {
 763                 goto done;
 764         }
 765
 766         display_sec_desc(sd_buf->sd);
 767
 768  done:
 769         return result;
 770 }
 771
 772 static WERROR cmd_srvsvc_net_sess_del(struct rpc_pipe_client *cli,
 773                                       TALLOC_CTX *mem_ctx,
 774                                       int argc, const char **argv)
 775 {
 776         WERROR result;
 777         NTSTATUS status;
 778         struct dcerpc_binding_handle *b = cli->binding_handle;
 779
 780         if (argc < 2 || argc > 4) {
 781                 printf("Usage: %s [client] [user]\n", argv[0]);
 782                 return WERR_OK;
 783         }
 784
 785         status = dcerpc_srvsvc_NetSessDel(b, mem_ctx,
 786                                           cli->desthost,
 787                                           argv[1],
 788                                           argv[2],
 789                                           &result);
 790         if (!NT_STATUS_IS_OK(status)) {
 791                 result = ntstatus_to_werror(status);
 792                 goto done;
 793         }
 794
 795         if (!W_ERROR_IS_OK(result)) {
 796                 goto done;
 797         }
 798
 799  done:
 800         return result;
 801 }
 802
 803 static WERROR cmd_srvsvc_net_sess_enum(struct rpc_pipe_client *cli,
 804                                        TALLOC_CTX *mem_ctx,
 805                                        int argc, const char **argv)
 806 {
 807         WERROR result;
 808         NTSTATUS status;
 809         struct srvsvc_NetSessInfoCtr info_ctr;
 810         struct srvsvc_NetSessCtr0 ctr0;
 811         struct srvsvc_NetSessCtr1 ctr1;
 812         struct srvsvc_NetSessCtr2 ctr2;
 813         struct srvsvc_NetSessCtr10 ctr10;
 814         struct srvsvc_NetSessCtr502 ctr502;
 815         uint32_t total_entries = 0;
 816         uint32_t resume_handle = 0;
 817         uint32_t *resume_handle_p = NULL;
 818         uint32_t level = 1;
 819         const char *client = NULL;
 820         const char *user = NULL;
 821         struct dcerpc_binding_handle *b = cli->binding_handle;
 822
 823         if (argc > 6) {
 824                 printf("Usage: %s [client] [user] [level] [resume_handle]\n", argv[0]);
 825                 return WERR_OK;
 826         }
 827
 828         if (argc >= 2) {
 829                 client = argv[1];
 830         }
 831
 832         if (argc >= 3) {
 833                 user = argv[2];
 834         }
 835
 836         if (argc >= 4) {
 837                 level = atoi(argv[3]);
 838         }
 839
 840         if (argc >= 5) {
 841                 resume_handle = atoi(argv[4]);
 842                 resume_handle_p = &resume_handle;
 843         }
 844
 845         ZERO_STRUCT(info_ctr);
 846
 847         info_ctr.level = level;
 848
 849         d_printf("trying level: %d\n", level);
 850
 851         switch (level) {
 852         case 0:
 853                 ZERO_STRUCT(ctr0);
 854                 info_ctr.ctr.ctr0 = &ctr0;
 855                 break;
 856         case 1:
 857                 ZERO_STRUCT(ctr1);
 858                 info_ctr.ctr.ctr1 = &ctr1;
 859                 break;
 860         case 2:
 861                 ZERO_STRUCT(ctr2);
 862                 info_ctr.ctr.ctr2 = &ctr2;
 863                 break;
 864         case 10:
 865                 ZERO_STRUCT(ctr10);
 866                 info_ctr.ctr.ctr10 = &ctr10;
 867                 break;
 868         case 502:
 869                 ZERO_STRUCT(ctr502);
 870                 info_ctr.ctr.ctr502 = &ctr502;
 871                 break;
 872         }
 873
 874         status = dcerpc_srvsvc_NetSessEnum(b, mem_ctx,
 875                                           cli->desthost,
 876                                           client,
 877                                           user,
 878                                           &info_ctr,
 879                                           0xffffffff,
 880                                           &total_entries,
 881                                           resume_handle_p,
 882                                           &result);
 883
 884         if (!NT_STATUS_IS_OK(status)) {
 885                 result = ntstatus_to_werror(status);
 886                 goto done;
 887         }
 888
 889         if (!W_ERROR_IS_OK(result)) {
 890                 goto done;
 891         }
 892
 893         d_printf("Received %d entries.\n", total_entries);
 894
 895  done:
 896         return result;
 897 }
 898
 899 static WERROR cmd_srvsvc_net_disk_enum(struct rpc_pipe_client *cli,
 900                                        TALLOC_CTX *mem_ctx,
 901                                        int argc, const char **argv)
 902 {
 903         struct srvsvc_NetDiskInfo info;
 904         WERROR result;
 905         NTSTATUS status;
 906         uint32_t total_entries = 0;
 907         uint32_t resume_handle = 0;
 908         uint32_t level = 0;
 909         struct dcerpc_binding_handle *b = cli->binding_handle;
 910
 911         if (argc > 4) {
 912                 printf("Usage: %s [level] [resume_handle]\n", argv[0]);
 913                 return WERR_OK;
 914         }
 915
 916         if (argc >= 2) {
 917                 level = atoi(argv[1]);
 918         }
 919
 920         if (argc >= 3) {
 921                 resume_handle = atoi(argv[2]);
 922         }
 923
 924         ZERO_STRUCT(info);
 925
 926         status = dcerpc_srvsvc_NetDiskEnum(b, mem_ctx,
 927                                            cli->desthost,
 928                                            level,
 929                                            &info,
 930                                            0xffffffff,
 931                                            &total_entries,
 932                                            &resume_handle,
 933                                            &result);
 934         if (!NT_STATUS_IS_OK(status)) {
 935                 result = ntstatus_to_werror(status);
 936                 goto done;
 937         }
 938
 939         if (!W_ERROR_IS_OK(result)) {
 940                 goto done;
 941         }
 942
 943  done:
 944         return result;
 945 }
 946
 947 static WERROR cmd_srvsvc_net_conn_enum(struct rpc_pipe_client *cli,
 948                                        TALLOC_CTX *mem_ctx,
 949                                        int argc, const char **argv)
 950 {
 951         struct srvsvc_NetConnInfoCtr info_ctr;
 952         struct srvsvc_NetConnCtr0 ctr0;
 953         struct srvsvc_NetConnCtr1 ctr1;
 954         WERROR result;
 955         NTSTATUS status;
 956         uint32_t total_entries = 0;
 957         uint32_t resume_handle = 0;
 958         uint32_t *resume_handle_p = NULL;
 959         uint32_t level = 1;
 960         const char *path = "IPC$";
 961         struct dcerpc_binding_handle *b = cli->binding_handle;
 962
 963         if (argc > 4) {
 964                 printf("Usage: %s [level] [path] [resume_handle]\n", argv[0]);
 965                 return WERR_OK;
 966         }
 967
 968         if (argc >= 2) {
 969                 level = atoi(argv[1]);
 970         }
 971
 972         if (argc >= 3) {
 973                 path = argv[2];
 974         }
 975
 976         if (argc >= 4) {
 977                 resume_handle = atoi(argv[3]);
 978                 resume_handle_p = &resume_handle;
 979         }
 980
 981         ZERO_STRUCT(info_ctr);
 982
 983         info_ctr.level = level;
 984
 985         switch (level) {
 986                 case 0:
 987                         ZERO_STRUCT(ctr0);
 988                         info_ctr.ctr.ctr0 = &ctr0;
 989                         break;
 990                 case 1:
 991                         ZERO_STRUCT(ctr1);
 992                         info_ctr.ctr.ctr1 = &ctr1;
 993                         break;
 994                 default:
 995                         return WERR_INVALID_PARAMETER;
 996         }
 997
 998         status = dcerpc_srvsvc_NetConnEnum(b, mem_ctx,
 999                                            cli->desthost,
1000                                            path,
1001                                            &info_ctr,
1002                                            0xffffffff,
1003                                            &total_entries,
1004                                            resume_handle_p,
1005                                            &result);
1006
1007         if (!NT_STATUS_IS_OK(status)) {
1008                 result = ntstatus_to_werror(status);
1009                 goto done;
1010         }
1011
1012         if (!W_ERROR_IS_OK(result)) {
1013                 goto done;
1014         }
1015
1016  done:
1017         return result;
1018 }
1019
1020 static WERROR cmd_srvsvc_net_share_add(struct rpc_pipe_client *cli,
1021                                        TALLOC_CTX *mem_ctx,
1022                                        int argc, const char **argv)
1023 {
1024         struct srvsvc_NetShareInfo502 info502 = { 0 };
1025         union srvsvc_NetShareInfo info = { .info502 = &info502 };
1026         WERROR result;
1027         NTSTATUS status;
1028         uint32_t max_users = -1, parm_error;
1029         struct sec_desc_buf sd_buf = { 0 };
1030         const char *path, *share_name, *comment = NULL;
1031         struct dcerpc_binding_handle *b = cli->binding_handle;
1032
1033         if (argc < 3 || argc > 5) {
1034                 printf("Usage: %s path share_name [max_users] [comment]\n",
1035                        argv[0]);
1036                 return WERR_OK;
1037         }
1038
1039         path = argv[1];
1040         share_name = argv[2];
1041
1042         if (argc >= 4) {
1043                 max_users = atoi(argv[3]);
1044         }
1045
1046         if (argc >= 5) {
1047                 comment = argv[4];
1048         }
1049
1050         info.info502->name = share_name;
1051         info.info502->type = STYPE_DISKTREE;
1052         info.info502->comment = comment;
1053         info.info502->max_users = max_users;
1054         info.info502->path = path;
1055         info.info502->sd_buf = sd_buf;
1056
1057         status = dcerpc_srvsvc_NetShareAdd(b, mem_ctx, cli->desthost,
1058                                            502, &info, &parm_error, &result);
1059         if (!NT_STATUS_IS_OK(status)) {
1060                 result = ntstatus_to_werror(status);
1061         }
1062
1063         return result;
1064 }
1065
1066 static WERROR cmd_srvsvc_net_share_del(struct rpc_pipe_client *cli,
1067                                        TALLOC_CTX *mem_ctx,
1068                                        int argc, const char **argv)
1069 {
1070         const char *share_name;
1071         WERROR result;
1072         NTSTATUS status;
1073         struct dcerpc_binding_handle *b = cli->binding_handle;
1074
1075         if (argc < 2) {
1076                 printf("Usage: %s share_name\n", argv[0]);
1077                 return WERR_OK;
1078         }
1079
1080         share_name = argv[1];
1081
1082         status = dcerpc_srvsvc_NetShareDel(b, mem_ctx, cli->desthost,
1083                                            share_name, 0, &result);
1084
1085         if (!NT_STATUS_IS_OK(status)) {
1086                 result = ntstatus_to_werror(status);
1087         }
1088
1089         return result;
1090 }
1091
1092
1093 /* List of commands exported by this module */
1094
1095 struct cmd_set srvsvc_commands[] = {
1096
1097         {
1098                 .name = "SRVSVC",
1099         },
1100
1101         {
1102                 .name               = "srvinfo",
1103                 .returntype         = RPC_RTYPE_WERROR,
1104                 .ntfn               = NULL,
1105                 .wfn                = cmd_srvsvc_srv_query_info,
1106                 .table              = &ndr_table_srvsvc,
1107                 .rpc_pipe           = NULL,
1108                 .description        = "Server query info",
1109                 .usage              = "",
1110         },
1111         {
1112                 .name               = "netshareenum",
1113                 .returntype         = RPC_RTYPE_WERROR,
1114                 .ntfn               = NULL,
1115                 .wfn                = cmd_srvsvc_net_share_enum,
1116                 .table              = &ndr_table_srvsvc,
1117                 .rpc_pipe           = NULL,
1118                 .description        = "Enumerate shares",
1119                 .usage              = "",
1120         },
1121         {
1122                 .name               = "netshareenumall",
1123                 .returntype         = RPC_RTYPE_WERROR,
1124                 .ntfn               = NULL,
1125                 .wfn                = cmd_srvsvc_net_share_enum_all,
1126                 .table              = &ndr_table_srvsvc,
1127                 .rpc_pipe           = NULL,
1128                 .description        = "Enumerate all shares",
1129                 .usage              = "",
1130         },
1131         {
1132                 .name               = "netsharegetinfo",
1133                 .returntype         = RPC_RTYPE_WERROR,
1134                 .ntfn               = NULL,
1135                 .wfn                = cmd_srvsvc_net_share_get_info,
1136                 .table              = &ndr_table_srvsvc,
1137                 .rpc_pipe           = NULL,
1138                 .description        = "Get Share Info",
1139                 .usage              = "",
1140         },
1141         {
1142                 .name               = "netsharesetinfo",
1143                 .returntype         = RPC_RTYPE_WERROR,
1144                 .ntfn               = NULL,
1145                 .wfn                = cmd_srvsvc_net_share_set_info,
1146                 .table              = &ndr_table_srvsvc,
1147                 .rpc_pipe           = NULL,
1148                 .description        = "Set Share Info",
1149                 .usage              = "",
1150         },
1151         {
1152                 .name               = "netsharesetdfsflags",
1153                 .returntype         = RPC_RTYPE_WERROR,
1154                 .ntfn               = NULL,
1155                 .wfn                = cmd_srvsvc_net_share_set_dfs_flags,
1156                 .table              = &ndr_table_srvsvc,
1157                 .rpc_pipe           = NULL,
1158                 .description        = "Set DFS flags",
1159                 .usage              = "",
1160         },
1161         {
1162                 .name               = "netfileenum",
1163                 .returntype         = RPC_RTYPE_WERROR,
1164                 .ntfn               = NULL,
1165                 .wfn                = cmd_srvsvc_net_file_enum,
1166                 .table              =  &ndr_table_srvsvc,
1167                 .rpc_pipe           = NULL,
1168                 .description        = "Enumerate open files",
1169                 .usage              = "",
1170         },
1171         {
1172                 .name               = "netremotetod",
1173                 .returntype         = RPC_RTYPE_WERROR,
1174                 .ntfn               = NULL,
1175                 .wfn                = cmd_srvsvc_net_remote_tod,
1176                 .table              = &ndr_table_srvsvc,
1177                 .rpc_pipe           = NULL,
1178                 .description        = "Fetch remote time of day",
1179                 .usage              = "",
1180         },
1181         {
1182                 .name               = "netnamevalidate",
1183                 .returntype         = RPC_RTYPE_WERROR,
1184                 .ntfn               = NULL,
1185                 .wfn                = cmd_srvsvc_net_name_validate,
1186                 .table              = &ndr_table_srvsvc,
1187                 .rpc_pipe           = NULL,
1188                 .description        = "Validate sharename",
1189                 .usage              = "",
1190         },
1191         {
1192                 .name               = "netfilegetsec",
1193                 .returntype         = RPC_RTYPE_WERROR,
1194                 .ntfn               = NULL,
1195                 .wfn                = cmd_srvsvc_net_file_get_sec,
1196                 .table              = &ndr_table_srvsvc,
1197                 .rpc_pipe           = NULL,
1198                 .description        = "Get File security",
1199                 .usage              = "",
1200         },
1201         {
1202                 .name               = "netsessdel",
1203                 .returntype         = RPC_RTYPE_WERROR,
1204                 .ntfn               = NULL,
1205                 .wfn                = cmd_srvsvc_net_sess_del,
1206                 .table              = &ndr_table_srvsvc,
1207                 .rpc_pipe           = NULL,
1208                 .description        = "Delete Session",
1209                 .usage              = "",
1210         },
1211         {
1212                 .name               = "netsessenum",
1213                 .returntype         = RPC_RTYPE_WERROR,
1214                 .ntfn               = NULL,
1215                 .wfn                = cmd_srvsvc_net_sess_enum,
1216                 .table              = &ndr_table_srvsvc,
1217                 .rpc_pipe           = NULL,
1218                 .description        = "Enumerate Sessions",
1219                 .usage              = "",
1220         },
1221         {
1222                 .name               = "netdiskenum",
1223                 .returntype         = RPC_RTYPE_WERROR,
1224                 .ntfn               = NULL,
1225                 .wfn                = cmd_srvsvc_net_disk_enum,
1226                 .table              = &ndr_table_srvsvc,
1227                 .rpc_pipe           = NULL,
1228                 .description        = "Enumerate Disks",
1229                 .usage              = "",
1230         },
1231         {
1232                 .name               = "netconnenum",
1233                 .returntype         = RPC_RTYPE_WERROR,
1234                 .ntfn               = NULL,
1235                 .wfn                = cmd_srvsvc_net_conn_enum,
1236                 .table              = &ndr_table_srvsvc,
1237                 .rpc_pipe           = NULL,
1238                 .description        = "Enumerate Connections",
1239                 .usage              = "",
1240         },
1241         {
1242                 .name               = "netshareadd",
1243                 .returntype         = RPC_RTYPE_WERROR,
1244                 .ntfn               = NULL,
1245                 .wfn                = cmd_srvsvc_net_share_add,
1246                 .table              = &ndr_table_srvsvc,
1247                 .rpc_pipe           = NULL,
1248                 .description        = "Add share",
1249                 .usage              = "",
1250         },
1251         {
1252                 .name               = "netsharedel",
1253                 .returntype         = RPC_RTYPE_WERROR,
1254                 .ntfn               = NULL,
1255                 .wfn                = cmd_srvsvc_net_share_del,
1256                 .table              = &ndr_table_srvsvc,
1257                 .rpc_pipe           = NULL,
1258                 .description        = "Delete share",
1259                 .usage              = "",
1260         },
1261
1262         {
1263                 .name = NULL,
1264         }
1265 };