source3/rpcclient/cmd_netlogon.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    RPC pipe client
   4
   5    Copyright (C) Tim Potter 2000
   6    Copyright (C) Guenther Deschner 2008
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23 #include "rpcclient.h"
  24 #include "../libcli/auth/libcli_auth.h"
  25 #include "../librpc/gen_ndr/ndr_netlogon.h"
  26 #include "../librpc/gen_ndr/ndr_netlogon_c.h"
  27 #include "rpc_client/cli_netlogon.h"
  28 #include "secrets.h"
  29 #include "../libcli/auth/netlogon_creds_cli.h"
  30 #include "rpc_client/util_netlogon.h"
  31
  32 static WERROR cmd_netlogon_logon_ctrl2(struct rpc_pipe_client *cli,
  33                                        TALLOC_CTX *mem_ctx, int argc,
  34                                        const char **argv)
  35 {
  36         NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
  37         WERROR werr;
  38         const char *logon_server = cli->desthost;
  39         enum netr_LogonControlCode function_code = NETLOGON_CONTROL_REDISCOVER;
  40         uint32_t level = 1;
  41         union netr_CONTROL_DATA_INFORMATION data;
  42         union netr_CONTROL_QUERY_INFORMATION query;
  43         const char *domain = lp_workgroup();
  44         struct dcerpc_binding_handle *b = cli->binding_handle;
  45         int i;
  46 #define fn_code_level(x, item) { x, #x, #item }
  47         struct {
  48                 enum netr_LogonControlCode code;
  49                 const char *name;
  50                 const char *argument;
  51         } supported_levels[] = {
  52                 fn_code_level(NETLOGON_CONTROL_REDISCOVER, domain),
  53                 fn_code_level(NETLOGON_CONTROL_TC_QUERY, domain),
  54                 fn_code_level(NETLOGON_CONTROL_TRANSPORT_NOTIFY, domain),
  55                 fn_code_level(NETLOGON_CONTROL_FIND_USER, user),
  56                 fn_code_level(NETLOGON_CONTROL_CHANGE_PASSWORD, domain),
  57                 fn_code_level(NETLOGON_CONTROL_TC_VERIFY, domain),
  58                 fn_code_level(NETLOGON_CONTROL_SET_DBFLAG, debug_level),
  59                 {0, 0, 0}
  60         };
  61 #undef fn_code_level
  62         if ((argc > 5) || (argc < 2)) {
  63                 fprintf(stderr, "Usage: %s <logon_server> <function_code> "
  64                         "<level:1..4> <argument>\n", argv[0]);
  65                 fprintf(stderr, "Supported combinations:\n");
  66                 fprintf(stderr, "function_code\targument\n");
  67                 for(i=0; supported_levels[i].code; i++) {
  68                         fprintf(stderr, "%7d\t\t%s\t(%s)\n",
  69                                 supported_levels[i].code,
  70                                 supported_levels[i].argument,
  71                                 supported_levels[i].name);
  72                 }
  73                 return WERR_OK;
  74         }
  75
  76         if (argc >= 2) {
  77                 logon_server = argv[1];
  78         }
  79
  80         if (argc >= 3) {
  81                 function_code = atoi(argv[2]);
  82         }
  83
  84         if (argc >= 4) {
  85                 level = atoi(argv[3]);
  86         }
  87
  88         if (argc >= 5) {
  89                 domain = argv[4];
  90         }
  91
  92         switch (function_code) {
  93                 case NETLOGON_CONTROL_REDISCOVER:
  94                 case NETLOGON_CONTROL_TC_QUERY:
  95                 case NETLOGON_CONTROL_CHANGE_PASSWORD:
  96                 case NETLOGON_CONTROL_TRANSPORT_NOTIFY:
  97                 case NETLOGON_CONTROL_TC_VERIFY:
  98                         data.domain = domain;
  99                         break;
 100                 case NETLOGON_CONTROL_FIND_USER:
 101                         data.user = domain;
 102                         break;
 103                 case NETLOGON_CONTROL_SET_DBFLAG:
 104                         data.debug_level = atoi(domain);
 105                 default:
 106                         break;
 107         }
 108
 109         status = dcerpc_netr_LogonControl2(b, mem_ctx,
 110                                           logon_server,
 111                                           function_code,
 112                                           level,
 113                                           &data,
 114                                           &query,
 115                                           &werr);
 116         if (!NT_STATUS_IS_OK(status)) {
 117                 return ntstatus_to_werror(status);
 118         }
 119
 120         if (!W_ERROR_IS_OK(werr)) {
 121                 return werr;
 122         }
 123
 124         /* Display results */
 125
 126         return werr;
 127 }
 128
 129 static WERROR cmd_netlogon_getanydcname(struct rpc_pipe_client *cli,
 130                                         TALLOC_CTX *mem_ctx, int argc,
 131                                         const char **argv)
 132 {
 133         const char *dcname = NULL;
 134         WERROR werr;
 135         NTSTATUS status;
 136         int old_timeout;
 137         struct dcerpc_binding_handle *b = cli->binding_handle;
 138
 139         if (argc != 2) {
 140                 fprintf(stderr, "Usage: %s domainname\n", argv[0]);
 141                 return WERR_OK;
 142         }
 143
 144         /* Make sure to wait for our DC's reply */
 145         old_timeout = rpccli_set_timeout(cli, 30000); /* 30 seconds. */
 146         rpccli_set_timeout(cli, MAX(old_timeout, 30000)); /* At least 30 sec */
 147
 148         status = dcerpc_netr_GetAnyDCName(b, mem_ctx,
 149                                           cli->desthost,
 150                                           argv[1],
 151                                           &dcname,
 152                                           &werr);
 153         rpccli_set_timeout(cli, old_timeout);
 154
 155         if (!NT_STATUS_IS_OK(status)) {
 156                 return ntstatus_to_werror(status);
 157         }
 158
 159         if (!W_ERROR_IS_OK(werr)) {
 160                 return werr;
 161         }
 162
 163         /* Display results */
 164
 165         printf("%s\n", dcname);
 166
 167         return werr;
 168 }
 169
 170 static WERROR cmd_netlogon_getdcname(struct rpc_pipe_client *cli,
 171                                      TALLOC_CTX *mem_ctx, int argc,
 172                                      const char **argv)
 173 {
 174         const char *dcname = NULL;
 175         NTSTATUS status;
 176         WERROR werr;
 177         int old_timeout;
 178         struct dcerpc_binding_handle *b = cli->binding_handle;
 179
 180         if (argc != 2) {
 181                 fprintf(stderr, "Usage: %s domainname\n", argv[0]);
 182                 return WERR_OK;
 183         }
 184
 185         /* Make sure to wait for our DC's reply */
 186         old_timeout = rpccli_set_timeout(cli, 30000); /* 30 seconds. */
 187         rpccli_set_timeout(cli, MAX(30000, old_timeout)); /* At least 30 sec */
 188
 189         status = dcerpc_netr_GetDcName(b, mem_ctx,
 190                                        cli->desthost,
 191                                        argv[1],
 192                                        &dcname,
 193                                        &werr);
 194         rpccli_set_timeout(cli, old_timeout);
 195
 196         if (!NT_STATUS_IS_OK(status)) {
 197                 return ntstatus_to_werror(status);
 198         }
 199
 200         if (!W_ERROR_IS_OK(werr)) {
 201                 return werr;
 202         }
 203
 204         /* Display results */
 205
 206         printf("%s\n", dcname);
 207
 208         return werr;
 209 }
 210
 211 static WERROR cmd_netlogon_dsr_getdcname(struct rpc_pipe_client *cli,
 212                                          TALLOC_CTX *mem_ctx, int argc,
 213                                          const char **argv)
 214 {
 215         NTSTATUS result;
 216         WERROR werr = WERR_OK;
 217         uint32_t flags = DS_RETURN_DNS_NAME;
 218         const char *server_name = cli->desthost;
 219         const char *domain_name = NULL;
 220         struct GUID domain_guid = GUID_zero();
 221         struct GUID site_guid = GUID_zero();
 222         struct netr_DsRGetDCNameInfo *info = NULL;
 223         struct dcerpc_binding_handle *b = cli->binding_handle;
 224
 225         if (argc < 2) {
 226                 fprintf(stderr, "Usage: %s [domain_name] [domain_guid] "
 227                                 "[site_guid] [flags]\n", argv[0]);
 228                 return WERR_OK;
 229         }
 230
 231         if (argc >= 2)
 232                 domain_name = argv[1];
 233
 234         if (argc >= 3) {
 235                 if (!NT_STATUS_IS_OK(GUID_from_string(argv[2], &domain_guid))) {
 236                         return WERR_NOT_ENOUGH_MEMORY;
 237                 }
 238         }
 239
 240         if (argc >= 4) {
 241                 if (!NT_STATUS_IS_OK(GUID_from_string(argv[3], &site_guid))) {
 242                         return WERR_NOT_ENOUGH_MEMORY;
 243                 }
 244         }
 245
 246         if (argc >= 5)
 247                 sscanf(argv[4], "%x", &flags);
 248
 249         result = dcerpc_netr_DsRGetDCName(b, mem_ctx,
 250                                           server_name,
 251                                           domain_name,
 252                                           &domain_guid,
 253                                           &site_guid,
 254                                           flags,
 255                                           &info,
 256                                           &werr);
 257         if (!NT_STATUS_IS_OK(result)) {
 258                 return ntstatus_to_werror(result);
 259         }
 260
 261         if (W_ERROR_IS_OK(werr)) {
 262                 d_printf("DsGetDcName gave: %s\n",
 263                 NDR_PRINT_STRUCT_STRING(mem_ctx, netr_DsRGetDCNameInfo, info));
 264                 return WERR_OK;
 265         }
 266
 267         printf("rpccli_netlogon_dsr_getdcname returned %s\n",
 268                win_errstr(werr));
 269
 270         return werr;
 271 }
 272
 273 static WERROR cmd_netlogon_dsr_getdcnameex(struct rpc_pipe_client *cli,
 274                                            TALLOC_CTX *mem_ctx, int argc,
 275                                            const char **argv)
 276 {
 277         WERROR result;
 278         NTSTATUS status;
 279         uint32_t flags = DS_RETURN_DNS_NAME;
 280         const char *server_name = cli->desthost;
 281         const char *domain_name;
 282         const char *site_name = NULL;
 283         struct GUID domain_guid = GUID_zero();
 284         struct netr_DsRGetDCNameInfo *info = NULL;
 285         struct dcerpc_binding_handle *b = cli->binding_handle;
 286
 287         if (argc < 2) {
 288                 fprintf(stderr, "Usage: %s [domain_name] [domain_guid] "
 289                                 "[site_name] [flags]\n", argv[0]);
 290                 return WERR_OK;
 291         }
 292
 293         domain_name = argv[1];
 294
 295         if (argc >= 3) {
 296                 if (!NT_STATUS_IS_OK(GUID_from_string(argv[2], &domain_guid))) {
 297                         return WERR_NOT_ENOUGH_MEMORY;
 298                 }
 299         }
 300
 301         if (argc >= 4) {
 302                 site_name = argv[3];
 303         }
 304
 305         if (argc >= 5) {
 306                 sscanf(argv[4], "%x", &flags);
 307         }
 308
 309         status = dcerpc_netr_DsRGetDCNameEx(b, mem_ctx,
 310                                             server_name,
 311                                             domain_name,
 312                                             &domain_guid,
 313                                             site_name,
 314                                             flags,
 315                                             &info,
 316                                             &result);
 317         if (!NT_STATUS_IS_OK(status)) {
 318                 return ntstatus_to_werror(status);
 319         }
 320
 321         if (!W_ERROR_IS_OK(result)) {
 322                 return result;
 323         }
 324
 325         d_printf("DsRGetDCNameEx gave %s\n",
 326                 NDR_PRINT_STRUCT_STRING(mem_ctx, netr_DsRGetDCNameInfo, info));
 327
 328         return result;
 329 }
 330
 331 static WERROR cmd_netlogon_dsr_getdcnameex2(struct rpc_pipe_client *cli,
 332                                             TALLOC_CTX *mem_ctx, int argc,
 333                                             const char **argv)
 334 {
 335         WERROR result;
 336         NTSTATUS status;
 337         uint32_t flags = DS_RETURN_DNS_NAME;
 338         const char *server_name = cli->desthost;
 339         const char *domain_name = NULL;
 340         const char *client_account = NULL;
 341         uint32_t mask = 0;
 342         const char *site_name = NULL;
 343         struct GUID domain_guid = GUID_zero();
 344         struct netr_DsRGetDCNameInfo *info = NULL;
 345         struct dcerpc_binding_handle *b = cli->binding_handle;
 346
 347         if (argc < 2) {
 348                 fprintf(stderr, "Usage: %s [client_account] [acb_mask] "
 349                                 "[domain_name] [domain_guid] [site_name] "
 350                                 "[flags]\n", argv[0]);
 351                 return WERR_OK;
 352         }
 353
 354         if (argc >= 2) {
 355                 client_account = argv[1];
 356         }
 357
 358         if (argc >= 3) {
 359                 mask = atoi(argv[2]);
 360         }
 361
 362         if (argc >= 4) {
 363                 domain_name = argv[3];
 364         }
 365
 366         if (argc >= 5) {
 367                 if (!NT_STATUS_IS_OK(GUID_from_string(argv[4], &domain_guid))) {
 368                         return WERR_NOT_ENOUGH_MEMORY;
 369                 }
 370         }
 371
 372         if (argc >= 6) {
 373                 site_name = argv[5];
 374         }
 375
 376         if (argc >= 7) {
 377                 sscanf(argv[6], "%x", &flags);
 378         }
 379
 380         status = dcerpc_netr_DsRGetDCNameEx2(b, mem_ctx,
 381                                              server_name,
 382                                              client_account,
 383                                              mask,
 384                                              domain_name,
 385                                              &domain_guid,
 386                                              site_name,
 387                                              flags,
 388                                              &info,
 389                                              &result);
 390         if (!NT_STATUS_IS_OK(status)) {
 391                 return ntstatus_to_werror(status);
 392         }
 393
 394         if (!W_ERROR_IS_OK(result)) {
 395                 return result;
 396         }
 397
 398         d_printf("DsRGetDCNameEx2 gave %s\n",
 399                 NDR_PRINT_STRUCT_STRING(mem_ctx, netr_DsRGetDCNameInfo, info));
 400
 401         return result;
 402 }
 403
 404
 405 static WERROR cmd_netlogon_dsr_getsitename(struct rpc_pipe_client *cli,
 406                                            TALLOC_CTX *mem_ctx, int argc,
 407                                            const char **argv)
 408 {
 409         WERROR werr;
 410         NTSTATUS status;
 411         const char *sitename = NULL;
 412         struct dcerpc_binding_handle *b = cli->binding_handle;
 413
 414         if (argc != 2) {
 415                 fprintf(stderr, "Usage: %s computername\n", argv[0]);
 416                 return WERR_OK;
 417         }
 418
 419         status = dcerpc_netr_DsRGetSiteName(b, mem_ctx,
 420                                             argv[1],
 421                                             &sitename,
 422                                             &werr);
 423         if (!NT_STATUS_IS_OK(status)) {
 424                 return ntstatus_to_werror(status);
 425         }
 426
 427         if (!W_ERROR_IS_OK(werr)) {
 428                 printf("rpccli_netlogon_dsr_gesitename returned %s\n",
 429                        nt_errstr(werror_to_ntstatus(werr)));
 430                 return werr;
 431         }
 432
 433         printf("Computer %s is on Site: %s\n", argv[1], sitename);
 434
 435         return WERR_OK;
 436 }
 437
 438 static WERROR cmd_netlogon_logon_ctrl(struct rpc_pipe_client *cli,
 439                                       TALLOC_CTX *mem_ctx, int argc,
 440                                       const char **argv)
 441 {
 442         NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
 443         WERROR werr;
 444         const char *logon_server = cli->desthost;
 445         enum netr_LogonControlCode function_code = 1;
 446         uint32_t level = 1;
 447         union netr_CONTROL_QUERY_INFORMATION info;
 448         struct dcerpc_binding_handle *b = cli->binding_handle;
 449
 450         if (argc > 4) {
 451                 fprintf(stderr, "Usage: %s <logon_server> <function_code> "
 452                         "<level>\n", argv[0]);
 453                 return WERR_OK;
 454         }
 455
 456         if (argc >= 2) {
 457                 logon_server = argv[1];
 458         }
 459
 460         if (argc >= 3) {
 461                 function_code = atoi(argv[2]);
 462         }
 463
 464         if (argc >= 4) {
 465                 level = atoi(argv[3]);
 466         }
 467
 468         status = dcerpc_netr_LogonControl(b, mem_ctx,
 469                                           logon_server,
 470                                           function_code,
 471                                           level,
 472                                           &info,
 473                                           &werr);
 474         if (!NT_STATUS_IS_OK(status)) {
 475                 return ntstatus_to_werror(status);
 476         }
 477
 478         if (!W_ERROR_IS_OK(werr)) {
 479                 return werr;
 480         }
 481
 482         /* Display results */
 483
 484         return werr;
 485 }
 486
 487 /* Log on a domain user */
 488
 489 static NTSTATUS cmd_netlogon_sam_logon(struct rpc_pipe_client *cli,
 490                                        TALLOC_CTX *mem_ctx, int argc,
 491                                        const char **argv)
 492 {
 493         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 494         int logon_type = NetlogonNetworkInformation;
 495         const char *username, *password;
 496         uint32_t logon_param = 0;
 497         const char *workstation = NULL;
 498         struct netr_SamInfo3 *info3 = NULL;
 499         uint8_t authoritative = 0;
 500         uint32_t flags = 0;
 501         uint16_t validation_level;
 502         union netr_Validation *validation = NULL;
 503         uint64_t logon_id = 0;
 504
 505         /* Check arguments */
 506
 507         if (argc < 3 || argc > 6) {
 508                 fprintf(stderr, "Usage: samlogon <username> <password> [workstation]"
 509                         "[logon_type (1 or 2)] [logon_parameter]\n");
 510                 return NT_STATUS_OK;
 511         }
 512
 513         username = argv[1];
 514         password = argv[2];
 515
 516         if (argc >= 4)
 517                 workstation = argv[3];
 518
 519         if (argc >= 5)
 520                 sscanf(argv[4], "%i", &logon_type);
 521
 522         if (argc == 6)
 523                 sscanf(argv[5], "%x", &logon_param);
 524
 525         if (rpcclient_netlogon_creds == NULL) {
 526                 result = NT_STATUS_UNSUCCESSFUL;
 527                 goto done;
 528         }
 529         logon_id = generate_random_u64();
 530
 531         /* Perform the sam logon */
 532
 533         result = rpccli_netlogon_password_logon(rpcclient_netlogon_creds,
 534                                                 cli->binding_handle,
 535                                                 mem_ctx,
 536                                                 logon_param,
 537                                                 lp_workgroup(),
 538                                                 username,
 539                                                 password,
 540                                                 workstation,
 541                                                 logon_id,
 542                                                 logon_type,
 543                                                 &authoritative,
 544                                                 &flags,
 545                                                 &validation_level,
 546                                                 &validation);
 547         if (!NT_STATUS_IS_OK(result))
 548                 goto done;
 549
 550         result = map_validation_to_info3(mem_ctx,
 551                                          validation_level,
 552                                          validation,
 553                                          &info3);
 554         if (!NT_STATUS_IS_OK(result)) {
 555                 return result;
 556         }
 557
 558  done:
 559         return result;
 560 }
 561
 562 /* Change the trust account password */
 563
 564 static NTSTATUS cmd_netlogon_change_trust_pw(struct rpc_pipe_client *cli,
 565                                              TALLOC_CTX *mem_ctx, int argc,
 566                                              const char **argv)
 567 {
 568         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 569         const char *dcname = cli->desthost;
 570
 571         /* Check arguments */
 572
 573         if (argc > 1) {
 574                 fprintf(stderr, "Usage: change_trust_pw");
 575                 return NT_STATUS_OK;
 576         }
 577
 578         result = trust_pw_change(rpcclient_netlogon_creds,
 579                                  rpcclient_msg_ctx,
 580                                  cli->binding_handle,
 581                                  lp_workgroup(),
 582                                  dcname,
 583                                  true); /* force */
 584         if (!NT_STATUS_IS_OK(result))
 585                 goto done;
 586
 587  done:
 588         return result;
 589 }
 590
 591 static WERROR cmd_netlogon_gettrustrid(struct rpc_pipe_client *cli,
 592                                        TALLOC_CTX *mem_ctx, int argc,
 593                                        const char **argv)
 594 {
 595         NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
 596         WERROR werr = WERR_GEN_FAILURE;
 597         const char *server_name = cli->desthost;
 598         const char *domain_name = lp_workgroup();
 599         uint32_t rid = 0;
 600         struct dcerpc_binding_handle *b = cli->binding_handle;
 601
 602         if (argc < 1 || argc > 3) {
 603                 fprintf(stderr, "Usage: %s <server_name> <domain_name>\n",
 604                         argv[0]);
 605                 return WERR_OK;
 606         }
 607
 608         if (argc >= 2) {
 609                 server_name = argv[1];
 610         }
 611
 612         if (argc >= 3) {
 613                 domain_name = argv[2];
 614         }
 615
 616         status = dcerpc_netr_LogonGetTrustRid(b, mem_ctx,
 617                                               server_name,
 618                                               domain_name,
 619                                               &rid,
 620                                               &werr);
 621         if (!NT_STATUS_IS_OK(status)) {
 622                 werr = ntstatus_to_werror(status);
 623                 goto done;
 624         }
 625
 626         if (W_ERROR_IS_OK(werr)) {
 627                 printf("Rid: %d\n", rid);
 628         }
 629  done:
 630         return werr;
 631 }
 632
 633 static WERROR cmd_netlogon_dsr_enumtrustdom(struct rpc_pipe_client *cli,
 634                                             TALLOC_CTX *mem_ctx, int argc,
 635                                             const char **argv)
 636 {
 637         NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
 638         WERROR werr = WERR_GEN_FAILURE;
 639         const char *server_name = cli->desthost;
 640         uint32_t trust_flags = NETR_TRUST_FLAG_IN_FOREST;
 641         struct netr_DomainTrustList trusts;
 642         struct dcerpc_binding_handle *b = cli->binding_handle;
 643
 644         if (argc < 1 || argc > 3) {
 645                 fprintf(stderr, "Usage: %s <server_name> <trust_flags>\n",
 646                         argv[0]);
 647                 return WERR_OK;
 648         }
 649
 650         if (argc >= 2) {
 651                 server_name = argv[1];
 652         }
 653
 654         if (argc >= 3) {
 655                 sscanf(argv[2], "%x", &trust_flags);
 656         }
 657
 658         status = dcerpc_netr_DsrEnumerateDomainTrusts(b, mem_ctx,
 659                                                       server_name,
 660                                                       trust_flags,
 661                                                       &trusts,
 662                                                       &werr);
 663         if (!NT_STATUS_IS_OK(status)) {
 664                 werr = ntstatus_to_werror(status);
 665                 goto done;
 666         }
 667
 668         if (W_ERROR_IS_OK(werr)) {
 669                 int i;
 670
 671                 printf("%d domains returned\n", trusts.count);
 672
 673                 for (i=0; i<trusts.count; i++ ) {
 674                         printf("%s (%s)\n",
 675                                 trusts.array[i].dns_name,
 676                                 trusts.array[i].netbios_name);
 677                 }
 678         }
 679  done:
 680         return werr;
 681 }
 682
 683 static WERROR cmd_netlogon_deregisterdnsrecords(struct rpc_pipe_client *cli,
 684                                                 TALLOC_CTX *mem_ctx, int argc,
 685                                                 const char **argv)
 686 {
 687         NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
 688         WERROR werr = WERR_GEN_FAILURE;
 689         const char *server_name = cli->desthost;
 690         const char *domain = lp_workgroup();
 691         const char *dns_host = NULL;
 692         struct dcerpc_binding_handle *b = cli->binding_handle;
 693
 694         if (argc < 1 || argc > 4) {
 695                 fprintf(stderr, "Usage: %s <server_name> <domain_name> "
 696                         "<dns_host>\n", argv[0]);
 697                 return WERR_OK;
 698         }
 699
 700         if (argc >= 2) {
 701                 server_name = argv[1];
 702         }
 703
 704         if (argc >= 3) {
 705                 domain = argv[2];
 706         }
 707
 708         if (argc >= 4) {
 709                 dns_host = argv[3];
 710         }
 711
 712         status = dcerpc_netr_DsrDeregisterDNSHostRecords(b, mem_ctx,
 713                                                          server_name,
 714                                                          domain,
 715                                                          NULL,
 716                                                          NULL,
 717                                                          dns_host,
 718                                                          &werr);
 719         if (!NT_STATUS_IS_OK(status)) {
 720                 werr = ntstatus_to_werror(status);
 721                 goto done;
 722         }
 723
 724         if (W_ERROR_IS_OK(werr)) {
 725                 printf("success\n");
 726         }
 727  done:
 728         return werr;
 729 }
 730
 731 static WERROR cmd_netlogon_dsr_getforesttrustinfo(struct rpc_pipe_client *cli,
 732                                                   TALLOC_CTX *mem_ctx, int argc,
 733                                                   const char **argv)
 734 {
 735         NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
 736         WERROR werr = WERR_GEN_FAILURE;
 737         const char *server_name = cli->desthost;
 738         const char *trusted_domain_name = NULL;
 739         struct lsa_ForestTrustInformation *info = NULL;
 740         uint32_t flags = 0;
 741         struct dcerpc_binding_handle *b = cli->binding_handle;
 742
 743         if (argc < 1 || argc > 4) {
 744                 fprintf(stderr, "Usage: %s <server_name> <trusted_domain_name> "
 745                         "<flags>\n", argv[0]);
 746                 return WERR_OK;
 747         }
 748
 749         if (argc >= 2) {
 750                 server_name = argv[1];
 751         }
 752
 753         if (argc >= 3) {
 754                 trusted_domain_name = argv[2];
 755         }
 756
 757         if (argc >= 4) {
 758                 sscanf(argv[3], "%x", &flags);
 759         }
 760
 761         status = dcerpc_netr_DsRGetForestTrustInformation(b, mem_ctx,
 762                                                          server_name,
 763                                                          trusted_domain_name,
 764                                                          flags,
 765                                                          &info,
 766                                                          &werr);
 767         if (!NT_STATUS_IS_OK(status)) {
 768                 werr = ntstatus_to_werror(status);
 769                 goto done;
 770         }
 771
 772         if (W_ERROR_IS_OK(werr)) {
 773                 printf("success\n");
 774         }
 775  done:
 776         return werr;
 777 }
 778
 779 static NTSTATUS cmd_netlogon_enumtrusteddomains(struct rpc_pipe_client *cli,
 780                                                 TALLOC_CTX *mem_ctx, int argc,
 781                                                 const char **argv)
 782 {
 783         NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
 784         NTSTATUS result;
 785         const char *server_name = cli->desthost;
 786         struct netr_Blob blob;
 787         struct dcerpc_binding_handle *b = cli->binding_handle;
 788
 789
 790         if (argc < 1 || argc > 3) {
 791                 fprintf(stderr, "Usage: %s <server_name>\n", argv[0]);
 792                 return NT_STATUS_OK;
 793         }
 794
 795         if (argc >= 2) {
 796                 server_name = argv[1];
 797         }
 798
 799         status = dcerpc_netr_NetrEnumerateTrustedDomains(b, mem_ctx,
 800                                                          server_name,
 801                                                          &blob,
 802                                                          &result);
 803         if (!NT_STATUS_IS_OK(status)) {
 804                 goto done;
 805         }
 806
 807         if (!NT_STATUS_IS_OK(result)) {
 808                 status = result;
 809                 goto done;
 810         }
 811
 812         printf("success\n");
 813         dump_data(1, blob.data, blob.length);
 814  done:
 815         return status;
 816 }
 817
 818 static WERROR cmd_netlogon_enumtrusteddomainsex(struct rpc_pipe_client *cli,
 819                                                 TALLOC_CTX *mem_ctx, int argc,
 820                                                 const char **argv)
 821 {
 822         NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
 823         WERROR werr = WERR_GEN_FAILURE;
 824         const char *server_name = cli->desthost;
 825         struct netr_DomainTrustList list;
 826         struct dcerpc_binding_handle *b = cli->binding_handle;
 827
 828         if (argc < 1 || argc > 3) {
 829                 fprintf(stderr, "Usage: %s <server_name>\n", argv[0]);
 830                 return WERR_OK;
 831         }
 832
 833         if (argc >= 2) {
 834                 server_name = argv[1];
 835         }
 836
 837         status = dcerpc_netr_NetrEnumerateTrustedDomainsEx(b, mem_ctx,
 838                                                            server_name,
 839                                                            &list,
 840                                                            &werr);
 841         if (!NT_STATUS_IS_OK(status)) {
 842                 werr = ntstatus_to_werror(status);
 843                 goto done;
 844         }
 845
 846         if (W_ERROR_IS_OK(werr)) {
 847                 printf("success\n");
 848         }
 849  done:
 850         return werr;
 851 }
 852
 853 static WERROR cmd_netlogon_getdcsitecoverage(struct rpc_pipe_client *cli,
 854                                              TALLOC_CTX *mem_ctx, int argc,
 855                                              const char **argv)
 856 {
 857         NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
 858         WERROR werr = WERR_GEN_FAILURE;
 859         const char *server_name = cli->desthost;
 860         struct DcSitesCtr *ctr = NULL;
 861         struct dcerpc_binding_handle *b = cli->binding_handle;
 862
 863         if (argc < 1 || argc > 3) {
 864                 fprintf(stderr, "Usage: %s <server_name>\n", argv[0]);
 865                 return WERR_OK;
 866         }
 867
 868         if (argc >= 2) {
 869                 server_name = argv[1];
 870         }
 871
 872         status = dcerpc_netr_DsrGetDcSiteCoverageW(b, mem_ctx,
 873                                                    server_name,
 874                                                    &ctr,
 875                                                    &werr);
 876         if (!NT_STATUS_IS_OK(status)) {
 877                 werr = ntstatus_to_werror(status);
 878                 goto done;
 879         }
 880
 881         if (W_ERROR_IS_OK(werr) && ctr->num_sites) {
 882                 int i;
 883                 printf("sites covered by this DC: %d\n", ctr->num_sites);
 884                 for (i=0; i<ctr->num_sites; i++) {
 885                         printf("%s\n", ctr->sites[i].string);
 886                 }
 887         }
 888  done:
 889         return werr;
 890 }
 891
 892 static NTSTATUS cmd_netlogon_capabilities(struct rpc_pipe_client *cli,
 893                                           TALLOC_CTX *mem_ctx, int argc,
 894                                           const char **argv)
 895 {
 896         struct netlogon_creds_cli_lck *lck;
 897         union netr_Capabilities capabilities;
 898         NTSTATUS status;
 899
 900         if (argc > 1) {
 901                 fprintf(stderr, "Usage: %s\n", argv[0]);
 902                 return NT_STATUS_OK;
 903         }
 904
 905         status = netlogon_creds_cli_lck(rpcclient_netlogon_creds,
 906                                         NETLOGON_CREDS_CLI_LCK_EXCLUSIVE,
 907                                         mem_ctx, &lck);
 908         if (!NT_STATUS_IS_OK(status)) {
 909                 fprintf(stderr, "netlogon_creds_cli_lck failed: %s\n",
 910                         nt_errstr(status));
 911                 return status;
 912         }
 913
 914         status = netlogon_creds_cli_check(rpcclient_netlogon_creds,
 915                                           cli->binding_handle,
 916                                           &capabilities);
 917         if (!NT_STATUS_IS_OK(status)) {
 918                 fprintf(stderr, "netlogon_creds_cli_check failed: %s\n",
 919                         nt_errstr(status));
 920                 return status;
 921         }
 922
 923         TALLOC_FREE(lck);
 924
 925         printf("capabilities: 0x%08x\n", capabilities.server_capabilities);
 926
 927         return NT_STATUS_OK;
 928 }
 929
 930 static NTSTATUS cmd_netlogon_logongetdomaininfo(struct rpc_pipe_client *cli,
 931                                                 TALLOC_CTX *mem_ctx, int argc,
 932                                                 const char **argv)
 933 {
 934         union netr_WorkstationInfo query;
 935         struct netr_WorkstationInformation workstation_info;
 936         union netr_DomainInfo *domain_info;
 937         NTSTATUS status;
 938         char *s;
 939
 940         if (argc > 1) {
 941                 fprintf(stderr, "Usage: %s\n", argv[0]);
 942                 return NT_STATUS_OK;
 943         }
 944
 945         ZERO_STRUCT(workstation_info);
 946
 947         query.workstation_info = &workstation_info;
 948
 949         status = netlogon_creds_cli_LogonGetDomainInfo(rpcclient_netlogon_creds,
 950                                                        cli->binding_handle,
 951                                                        mem_ctx,
 952                                                        1,
 953                                                        &query,
 954                                                        &domain_info);
 955         if (!NT_STATUS_IS_OK(status)) {
 956                 fprintf(stderr, "netlogon_creds_cli_LogonGetDomainInfo failed: %s\n",
 957                         nt_errstr(status));
 958                 return status;
 959         }
 960
 961         s = NDR_PRINT_STRUCT_STRING(mem_ctx, netr_DomainInformation, domain_info->domain_info);
 962         if (s) {
 963                 printf("%s\n", s);
 964                 TALLOC_FREE(s);
 965         }
 966
 967         return NT_STATUS_OK;
 968 }
 969
 970 /* List of commands exported by this module */
 971
 972 struct cmd_set netlogon_commands[] = {
 973
 974         {
 975                 .name = "NETLOGON",
 976         },
 977
 978         {
 979                 .name               = "logonctrl2",
 980                 .returntype         = RPC_RTYPE_WERROR,
 981                 .ntfn               = NULL,
 982                 .wfn                = cmd_netlogon_logon_ctrl2,
 983                 .table              = &ndr_table_netlogon,
 984                 .rpc_pipe           = NULL,
 985                 .description        = "Logon Control 2",
 986                 .usage              = "",
 987         },
 988         {
 989                 .name               = "getanydcname",
 990                 .returntype         = RPC_RTYPE_WERROR,
 991                 .ntfn               = NULL,
 992                 .wfn                = cmd_netlogon_getanydcname,
 993                 .table              = &ndr_table_netlogon,
 994                 .rpc_pipe           = NULL,
 995                 .description        = "Get trusted DC name",
 996                 .usage              = "",
 997         },
 998         {
 999                 .name               = "getdcname",
1000                 .returntype         = RPC_RTYPE_WERROR,
1001                 .ntfn               = NULL,
1002                 .wfn                = cmd_netlogon_getdcname,
1003                 .table              = &ndr_table_netlogon,
1004                 .rpc_pipe           = NULL,
1005                 .description        = "Get trusted PDC name",
1006                 .usage              = "",
1007         },
1008         {
1009                 .name               = "dsr_getdcname",
1010                 .returntype         = RPC_RTYPE_WERROR,
1011                 .ntfn               = NULL,
1012                 .wfn                = cmd_netlogon_dsr_getdcname,
1013                 .table              = &ndr_table_netlogon,
1014                 .rpc_pipe           = NULL,
1015                 .description        = "Get trusted DC name",
1016                 .usage              = "",
1017         },
1018         {
1019                 .name               = "dsr_getdcnameex",
1020                 .returntype         = RPC_RTYPE_WERROR,
1021                 .ntfn               = NULL,
1022                 .wfn                = cmd_netlogon_dsr_getdcnameex,
1023                 .table              = &ndr_table_netlogon,
1024                 .rpc_pipe           = NULL,
1025                 .description        = "Get trusted DC name",
1026                 .usage              = "",
1027         },
1028         {
1029                 .name               = "dsr_getdcnameex2",
1030                 .returntype         = RPC_RTYPE_WERROR,
1031                 .ntfn               = NULL,
1032                 .wfn                = cmd_netlogon_dsr_getdcnameex2,
1033                 .table              = &ndr_table_netlogon,
1034                 .rpc_pipe           = NULL,
1035                 .description        = "Get trusted DC name",
1036                 .usage              = "",
1037         },
1038         {
1039                 .name               = "dsr_getsitename",
1040                 .returntype         = RPC_RTYPE_WERROR,
1041                 .ntfn               = NULL,
1042                 .wfn                = cmd_netlogon_dsr_getsitename,
1043                 .table              = &ndr_table_netlogon,
1044                 .rpc_pipe           = NULL,
1045                 .description        = "Get sitename",
1046                 .usage              = "",
1047         },
1048         {
1049                 .name               = "dsr_getforesttrustinfo",
1050                 .returntype         = RPC_RTYPE_WERROR,
1051                 .ntfn               = NULL,
1052                 .wfn                = cmd_netlogon_dsr_getforesttrustinfo,
1053                 .table              = &ndr_table_netlogon,
1054                 .rpc_pipe           = NULL,
1055                 .description        = "Get Forest Trust Info",
1056                 .usage              = "",
1057         },
1058         {
1059                 .name               = "logonctrl",
1060                 .returntype         =  RPC_RTYPE_WERROR,
1061                 .ntfn               = NULL,
1062                 .wfn                = cmd_netlogon_logon_ctrl,
1063                 .table              = &ndr_table_netlogon,
1064                 .rpc_pipe           = NULL,
1065                 .description        = "Logon Control",
1066                 .usage              = "",
1067         },
1068         {
1069                 .name               = "samlogon",
1070                 .returntype         = RPC_RTYPE_NTSTATUS,
1071                 .ntfn               = cmd_netlogon_sam_logon,
1072                 .wfn                = NULL,
1073                 .table              = &ndr_table_netlogon,
1074                 .rpc_pipe           = NULL,
1075                 .description        = "Sam Logon",
1076                 .usage              = "",
1077                 .use_netlogon_creds = true,
1078         },
1079         {
1080                 .name               = "change_trust_pw",
1081                 .returntype         = RPC_RTYPE_NTSTATUS,
1082                 .ntfn               = cmd_netlogon_change_trust_pw,
1083                 .wfn                = NULL,
1084                 .table              = &ndr_table_netlogon,
1085                 .rpc_pipe           = NULL,
1086                 .description        = "Change Trust Account Password",
1087                 .usage              = "",
1088                 .use_netlogon_creds = true,
1089         },
1090         {
1091                 .name               = "gettrustrid",
1092                 .returntype         = RPC_RTYPE_WERROR,
1093                 .ntfn               = NULL,
1094                 .wfn                = cmd_netlogon_gettrustrid,
1095                 .table              = &ndr_table_netlogon,
1096                 .rpc_pipe           = NULL,
1097                 .description        = "Get trust rid",
1098                 .usage              = "",
1099         },
1100         {
1101                 .name               = "dsr_enumtrustdom",
1102                 .returntype         = RPC_RTYPE_WERROR,
1103                 .ntfn               = NULL,
1104                 .wfn                = cmd_netlogon_dsr_enumtrustdom,
1105                 .table              = &ndr_table_netlogon,
1106                 .rpc_pipe           = NULL,
1107                 .description        = "Enumerate trusted domains",
1108                 .usage              = "",
1109         },
1110         {
1111                 .name               = "dsenumdomtrusts",
1112                 .returntype         = RPC_RTYPE_WERROR,
1113                 .ntfn               = NULL,
1114                 .wfn                = cmd_netlogon_dsr_enumtrustdom,
1115                 .table              = &ndr_table_netlogon,
1116                 .rpc_pipe           = NULL,
1117                 .description        = "Enumerate all trusted domains in an AD forest",
1118                 .usage              = "",
1119         },
1120         {
1121                 .name               = "deregisterdnsrecords",
1122                 .returntype         = RPC_RTYPE_WERROR,
1123                 .ntfn               = NULL,
1124                 .wfn                = cmd_netlogon_deregisterdnsrecords,
1125                 .table              = &ndr_table_netlogon,
1126                 .rpc_pipe           = NULL,
1127                 .description        = "Deregister DNS records",
1128                 .usage              = "",
1129         },
1130         {
1131                 .name               = "netrenumtrusteddomains",
1132                 .returntype         = RPC_RTYPE_NTSTATUS,
1133                 .ntfn               = cmd_netlogon_enumtrusteddomains,
1134                 .wfn                = NULL,
1135                 .table              = &ndr_table_netlogon,
1136                 .rpc_pipe           = NULL,
1137                 .description        = "Enumerate trusted domains",
1138                 .usage              = "",
1139         },
1140         {
1141                 .name               = "netrenumtrusteddomainsex",
1142                 .returntype         = RPC_RTYPE_WERROR,
1143                 .ntfn               = NULL,
1144                 .wfn                = cmd_netlogon_enumtrusteddomainsex,
1145                 .table              = &ndr_table_netlogon,
1146                 .rpc_pipe           = NULL,
1147                 .description        = "Enumerate trusted domains",
1148                 .usage              = "",
1149         },
1150         {
1151                 .name               = "getdcsitecoverage",
1152                 .returntype         = RPC_RTYPE_WERROR,
1153                 .ntfn               = NULL,
1154                 .wfn                = cmd_netlogon_getdcsitecoverage,
1155                 .table              = &ndr_table_netlogon,
1156                 .rpc_pipe           = NULL,
1157                 .description        = "Get the Site-Coverage from a DC",
1158                 .usage              = "",
1159         },
1160         {
1161                 .name               = "capabilities",
1162                 .returntype         = RPC_RTYPE_NTSTATUS,
1163                 .ntfn               = cmd_netlogon_capabilities,
1164                 .wfn                = NULL,
1165                 .table              = &ndr_table_netlogon,
1166                 .rpc_pipe           = NULL,
1167                 .description        = "Return Capabilities",
1168                 .usage              = "",
1169                 .use_netlogon_creds = true,
1170         },
1171         {
1172                 .name               = "logongetdomaininfo",
1173                 .returntype         = RPC_RTYPE_NTSTATUS,
1174                 .ntfn               = cmd_netlogon_logongetdomaininfo,
1175                 .wfn                = NULL,
1176                 .table              = &ndr_table_netlogon,
1177                 .rpc_pipe           = NULL,
1178                 .description        = "Return LogonGetDomainInfo",
1179                 .usage              = "",
1180                 .use_netlogon_creds = true,
1181         },
1182         {
1183                 .name = NULL,
1184         }
1185 };