source/rpcclient/cmd_netlogon.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    RPC pipe client
   4
   5    Copyright (C) Tim Potter 2000
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23 #include "rpcclient.h"
  24
  25 static NTSTATUS cmd_netlogon_logon_ctrl2(struct rpc_pipe_client *cli,
  26                                          TALLOC_CTX *mem_ctx, int argc,
  27                                          const char **argv)
  28 {
  29         uint32 query_level = 1;
  30         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
  31
  32         if (argc > 1) {
  33                 fprintf(stderr, "Usage: %s\n", argv[0]);
  34                 return NT_STATUS_OK;
  35         }
  36
  37         result = rpccli_netlogon_logon_ctrl2(cli, mem_ctx, query_level);
  38
  39         if (!NT_STATUS_IS_OK(result))
  40                 goto done;
  41
  42         /* Display results */
  43
  44  done:
  45         return result;
  46 }
  47
  48 static WERROR cmd_netlogon_getanydcname(struct rpc_pipe_client *cli,
  49                                         TALLOC_CTX *mem_ctx, int argc,
  50                                         const char **argv)
  51 {
  52         fstring dcname;
  53         WERROR result = WERR_GENERAL_FAILURE;
  54
  55         if (argc != 2) {
  56                 fprintf(stderr, "Usage: %s domainname\n", argv[0]);
  57                 return WERR_OK;
  58         }
  59
  60         result = rpccli_netlogon_getanydcname(cli, mem_ctx, cli->cli->desthost, argv[1], dcname);
  61
  62         if (!W_ERROR_IS_OK(result))
  63                 goto done;
  64
  65         /* Display results */
  66
  67         printf("%s\n", dcname);
  68
  69  done:
  70         return result;
  71 }
  72
  73 static void display_ds_domain_controller_info(TALLOC_CTX *mem_ctx, const struct DS_DOMAIN_CONTROLLER_INFO *info)
  74 {
  75         d_printf("domain_controller_name: %s\n", info->domain_controller_name);
  76         d_printf("domain_controller_address: %s\n", info->domain_controller_address);
  77         d_printf("domain_controller_address_type: %d\n", info->domain_controller_address_type);
  78         d_printf("domain_guid: %s\n", GUID_string(mem_ctx, info->domain_guid));
  79         d_printf("domain_name: %s\n", info->domain_name);
  80         d_printf("dns_forest_name: %s\n", info->dns_forest_name);
  81         d_printf("flags: 0x%08x\n"
  82                  "\tIs a PDC:                                   %s\n"
  83                  "\tIs a GC of the forest:                      %s\n"
  84                  "\tIs an LDAP server:                          %s\n"
  85                  "\tSupports DS:                                %s\n"
  86                  "\tIs running a KDC:                           %s\n"
  87                  "\tIs running time services:                   %s\n"
  88                  "\tIs the closest DC:                          %s\n"
  89                  "\tIs writable:                                %s\n"
  90                  "\tHas a hardware clock:                       %s\n"
  91                  "\tIs a non-domain NC serviced by LDAP server: %s\n"
  92                  "\tDomainControllerName is a DNS name:         %s\n"
  93                  "\tDomainName is a DNS name:                   %s\n"
  94                  "\tDnsForestName is a DNS name:                %s\n",
  95                  info->flags,
  96                  (info->flags & ADS_PDC) ? "yes" : "no",
  97                  (info->flags & ADS_GC) ? "yes" : "no",
  98                  (info->flags & ADS_LDAP) ? "yes" : "no",
  99                  (info->flags & ADS_DS) ? "yes" : "no",
 100                  (info->flags & ADS_KDC) ? "yes" : "no",
 101                  (info->flags & ADS_TIMESERV) ? "yes" : "no",
 102                  (info->flags & ADS_CLOSEST) ? "yes" : "no",
 103                  (info->flags & ADS_WRITABLE) ? "yes" : "no",
 104                  (info->flags & ADS_GOOD_TIMESERV) ? "yes" : "no",
 105                  (info->flags & ADS_NDNC) ? "yes" : "no",
 106                  (info->flags & ADS_DNS_CONTROLLER) ? "yes":"no",
 107                  (info->flags & ADS_DNS_DOMAIN) ? "yes":"no",
 108                  (info->flags & ADS_DNS_FOREST) ? "yes":"no");
 109
 110         d_printf("dc_site_name: %s\n", info->dc_site_name);
 111         d_printf("client_site_name: %s\n", info->client_site_name);
 112 }
 113
 114 static WERROR cmd_netlogon_dsr_getdcname(struct rpc_pipe_client *cli,
 115                                          TALLOC_CTX *mem_ctx, int argc,
 116                                          const char **argv)
 117 {
 118         WERROR result;
 119         uint32 flags = DS_RETURN_DNS_NAME;
 120         const char *server_name = cli->cli->desthost;
 121         const char *domain_name;
 122         struct GUID domain_guid = GUID_zero();
 123         struct GUID site_guid = GUID_zero();
 124         struct DS_DOMAIN_CONTROLLER_INFO *info = NULL;
 125
 126         if (argc < 2) {
 127                 fprintf(stderr, "Usage: %s [domainname] [domain_name] [domain_guid] [site_guid] [flags]\n", argv[0]);
 128                 return WERR_OK;
 129         }
 130
 131         if (argc >= 2)
 132                 domain_name = argv[1];
 133
 134         if (argc >= 3) {
 135                 if (!NT_STATUS_IS_OK(GUID_from_string(argv[2], &domain_guid))) {
 136                         return WERR_NOMEM;
 137                 }
 138         }
 139
 140         if (argc >= 4) {
 141                 if (!NT_STATUS_IS_OK(GUID_from_string(argv[3], &site_guid))) {
 142                         return WERR_NOMEM;
 143                 }
 144         }
 145
 146         if (argc >= 5)
 147                 sscanf(argv[4], "%x", &flags);
 148
 149         result = rpccli_netlogon_dsr_getdcname(cli, mem_ctx, server_name, domain_name,
 150                                                &domain_guid, &site_guid, flags,
 151                                                &info);
 152
 153         if (W_ERROR_IS_OK(result)) {
 154                 d_printf("DsGetDcName gave\n");
 155                 display_ds_domain_controller_info(mem_ctx, info);
 156                 return WERR_OK;
 157         }
 158
 159         printf("rpccli_netlogon_dsr_getdcname returned %s\n",
 160                dos_errstr(result));
 161
 162         return result;
 163 }
 164
 165 static WERROR cmd_netlogon_dsr_getdcnameex(struct rpc_pipe_client *cli,
 166                                            TALLOC_CTX *mem_ctx, int argc,
 167                                            const char **argv)
 168 {
 169         WERROR result;
 170         uint32 flags = DS_RETURN_DNS_NAME;
 171         const char *server_name = cli->cli->desthost;
 172         const char *domain_name;
 173         const char *site_name = NULL;
 174         struct GUID domain_guid = GUID_zero();
 175         struct DS_DOMAIN_CONTROLLER_INFO *info = NULL;
 176
 177         if (argc < 2) {
 178                 fprintf(stderr, "Usage: %s [domainname] [domain_name] [domain_guid] [site_name] [flags]\n", argv[0]);
 179                 return WERR_OK;
 180         }
 181
 182         if (argc >= 2)
 183                 domain_name = argv[1];
 184
 185         if (argc >= 3) {
 186                 if (!NT_STATUS_IS_OK(GUID_from_string(argv[2], &domain_guid))) {
 187                         return WERR_NOMEM;
 188                 }
 189         }
 190
 191         if (argc >= 4)
 192                 site_name = argv[3];
 193
 194         if (argc >= 5)
 195                 sscanf(argv[4], "%x", &flags);
 196
 197         result = rpccli_netlogon_dsr_getdcnameex(cli, mem_ctx, server_name, domain_name,
 198                                                  &domain_guid, site_name, flags,
 199                                                  &info);
 200
 201         if (W_ERROR_IS_OK(result)) {
 202                 d_printf("DsGetDcNameEx gave\n");
 203                 display_ds_domain_controller_info(mem_ctx, info);
 204                 return WERR_OK;
 205         }
 206
 207         printf("rpccli_netlogon_dsr_getdcnameex returned %s\n",
 208                dos_errstr(result));
 209
 210         return result;
 211 }
 212
 213 static WERROR cmd_netlogon_dsr_getdcnameex2(struct rpc_pipe_client *cli,
 214                                             TALLOC_CTX *mem_ctx, int argc,
 215                                             const char **argv)
 216 {
 217         WERROR result;
 218         uint32 flags = DS_RETURN_DNS_NAME;
 219         const char *server_name = cli->cli->desthost;
 220         const char *domain_name;
 221         const char *client_account = NULL;
 222         uint32 mask = 0;
 223         const char *site_name = NULL;
 224         struct GUID domain_guid = GUID_zero();
 225         struct DS_DOMAIN_CONTROLLER_INFO *info = NULL;
 226
 227         if (argc < 2) {
 228                 fprintf(stderr, "Usage: %s [domainname] [client_account] [acb_mask] [domain_name] [domain_guid] [site_name] [flags]\n", argv[0]);
 229                 return WERR_OK;
 230         }
 231
 232         if (argc >= 2)
 233                 client_account = argv[1];
 234
 235         if (argc >= 3)
 236                 mask = atoi(argv[2]);
 237
 238         if (argc >= 4)
 239                 domain_name = argv[3];
 240
 241         if (argc >= 5) {
 242                 if (!NT_STATUS_IS_OK(GUID_from_string(argv[4], &domain_guid))) {
 243                         return WERR_NOMEM;
 244                 }
 245         }
 246
 247         if (argc >= 6)
 248                 site_name = argv[5];
 249
 250         if (argc >= 7)
 251                 sscanf(argv[6], "%x", &flags);
 252
 253         result = rpccli_netlogon_dsr_getdcnameex2(cli, mem_ctx, server_name,
 254                                                   client_account, mask,
 255                                                   domain_name, &domain_guid,
 256                                                   site_name, flags,
 257                                                   &info);
 258
 259         if (W_ERROR_IS_OK(result)) {
 260                 d_printf("DsGetDcNameEx2 gave\n");
 261                 display_ds_domain_controller_info(mem_ctx, info);
 262                 return WERR_OK;
 263         }
 264
 265         printf("rpccli_netlogon_dsr_getdcnameex2 returned %s\n",
 266                dos_errstr(result));
 267
 268         return result;
 269 }
 270
 271
 272 static WERROR cmd_netlogon_dsr_getsitename(struct rpc_pipe_client *cli,
 273                                            TALLOC_CTX *mem_ctx, int argc,
 274                                            const char **argv)
 275 {
 276         WERROR result;
 277         char *sitename;
 278
 279         if (argc != 2) {
 280                 fprintf(stderr, "Usage: %s computername\n", argv[0]);
 281                 return WERR_OK;
 282         }
 283
 284         result = rpccli_netlogon_dsr_getsitename(cli, mem_ctx, argv[1], &sitename);
 285
 286         if (!W_ERROR_IS_OK(result)) {
 287                 printf("rpccli_netlogon_dsr_gesitename returned %s\n",
 288                        nt_errstr(werror_to_ntstatus(result)));
 289                 return result;
 290         }
 291
 292         printf("Computer %s is on Site: %s\n", argv[1], sitename);
 293
 294         return WERR_OK;
 295 }
 296
 297 static NTSTATUS cmd_netlogon_logon_ctrl(struct rpc_pipe_client *cli,
 298                                         TALLOC_CTX *mem_ctx, int argc,
 299                                         const char **argv)
 300 {
 301 #if 0
 302         uint32 query_level = 1;
 303 #endif
 304         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 305
 306         if (argc > 1) {
 307                 fprintf(stderr, "Usage: %s\n", argv[0]);
 308                 return NT_STATUS_OK;
 309         }
 310
 311 #if 0
 312         result = cli_netlogon_logon_ctrl(cli, mem_ctx, query_level);
 313         if (!NT_STATUS_IS_OK(result)) {
 314                 goto done;
 315         }
 316 #endif
 317
 318         /* Display results */
 319
 320         return result;
 321 }
 322
 323 /* Display sam synchronisation information */
 324
 325 static void display_sam_sync(uint32 num_deltas, SAM_DELTA_HDR *hdr_deltas,
 326                              SAM_DELTA_CTR *deltas)
 327 {
 328         fstring name;
 329         uint32 i, j;
 330
 331         for (i = 0; i < num_deltas; i++) {
 332                 switch (hdr_deltas[i].type) {
 333                 case SAM_DELTA_DOMAIN_INFO:
 334                         unistr2_to_ascii(name,
 335                                          &deltas[i].domain_info.uni_dom_name,
 336                                          sizeof(name) - 1);
 337                         printf("Domain: %s\n", name);
 338                         break;
 339                 case SAM_DELTA_GROUP_INFO:
 340                         unistr2_to_ascii(name,
 341                                          &deltas[i].group_info.uni_grp_name,
 342                                          sizeof(name) - 1);
 343                         printf("Group: %s\n", name);
 344                         break;
 345                 case SAM_DELTA_ACCOUNT_INFO:
 346                         unistr2_to_ascii(name,
 347                                          &deltas[i].account_info.uni_acct_name,
 348                                          sizeof(name) - 1);
 349                         printf("Account: %s\n", name);
 350                         break;
 351                 case SAM_DELTA_ALIAS_INFO:
 352                         unistr2_to_ascii(name,
 353                                          &deltas[i].alias_info.uni_als_name,
 354                                          sizeof(name) - 1);
 355                         printf("Alias: %s\n", name);
 356                         break;
 357                 case SAM_DELTA_ALIAS_MEM: {
 358                         SAM_ALIAS_MEM_INFO *alias = &deltas[i].als_mem_info;
 359
 360                         for (j = 0; j < alias->num_members; j++) {
 361                                 fstring sid_str;
 362
 363                                 sid_to_string(sid_str, &alias->sids[j].sid);
 364
 365                                 printf("%s\n", sid_str);
 366                         }
 367                         break;
 368                 }
 369                 case SAM_DELTA_GROUP_MEM: {
 370                         SAM_GROUP_MEM_INFO *group = &deltas[i].grp_mem_info;
 371
 372                         for (j = 0; j < group->num_members; j++)
 373                                 printf("rid 0x%x, attrib 0x%08x\n",
 374                                           group->rids[j], group->attribs[j]);
 375                         break;
 376                 }
 377                 case SAM_DELTA_MODIFIED_COUNT: {
 378                         SAM_DELTA_MOD_COUNT *mc = &deltas[i].mod_count;
 379
 380                         printf("sam sequence update: 0x%04x\n", mc->seqnum);
 381                         break;
 382                 }
 383                 default:
 384                         printf("unknown delta type 0x%02x\n",
 385                                   hdr_deltas[i].type);
 386                         break;
 387                 }
 388         }
 389 }
 390
 391 /* Perform sam synchronisation */
 392
 393 static NTSTATUS cmd_netlogon_sam_sync(struct rpc_pipe_client *cli,
 394                                       TALLOC_CTX *mem_ctx, int argc,
 395                                       const char **argv)
 396 {
 397         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 398         uint32 database_id = 0, num_deltas;
 399         SAM_DELTA_HDR *hdr_deltas;
 400         SAM_DELTA_CTR *deltas;
 401
 402         if (argc > 2) {
 403                 fprintf(stderr, "Usage: %s [database_id]\n", argv[0]);
 404                 return NT_STATUS_OK;
 405         }
 406
 407         if (argc == 2)
 408                 database_id = atoi(argv[1]);
 409
 410         /* Synchronise sam database */
 411
 412         result = rpccli_netlogon_sam_sync(cli, mem_ctx, database_id,
 413                                        0, &num_deltas, &hdr_deltas, &deltas);
 414
 415         if (!NT_STATUS_IS_OK(result))
 416                 goto done;
 417
 418         /* Display results */
 419
 420         display_sam_sync(num_deltas, hdr_deltas, deltas);
 421
 422  done:
 423         return result;
 424 }
 425
 426 /* Perform sam delta synchronisation */
 427
 428 static NTSTATUS cmd_netlogon_sam_deltas(struct rpc_pipe_client *cli,
 429                                         TALLOC_CTX *mem_ctx, int argc,
 430                                         const char **argv)
 431 {
 432         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 433         uint32 database_id, num_deltas, tmp;
 434         SAM_DELTA_HDR *hdr_deltas;
 435         SAM_DELTA_CTR *deltas;
 436         uint64 seqnum;
 437
 438         if (argc != 3) {
 439                 fprintf(stderr, "Usage: %s database_id seqnum\n", argv[0]);
 440                 return NT_STATUS_OK;
 441         }
 442
 443         database_id = atoi(argv[1]);
 444         tmp = atoi(argv[2]);
 445
 446         seqnum = tmp & 0xffff;
 447
 448         result = rpccli_netlogon_sam_deltas(cli, mem_ctx, database_id,
 449                                          seqnum, &num_deltas,
 450                                          &hdr_deltas, &deltas);
 451
 452         if (!NT_STATUS_IS_OK(result))
 453                 goto done;
 454
 455         /* Display results */
 456
 457         display_sam_sync(num_deltas, hdr_deltas, deltas);
 458
 459  done:
 460         return result;
 461 }
 462
 463 /* Log on a domain user */
 464
 465 static NTSTATUS cmd_netlogon_sam_logon(struct rpc_pipe_client *cli,
 466                                        TALLOC_CTX *mem_ctx, int argc,
 467                                        const char **argv)
 468 {
 469         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 470         int logon_type = NET_LOGON_TYPE;
 471         const char *username, *password;
 472         int auth_level = 2;
 473         uint32 logon_param = 0;
 474         const char *workstation = NULL;
 475
 476         /* Check arguments */
 477
 478         if (argc < 3 || argc > 7) {
 479                 fprintf(stderr, "Usage: samlogon <username> <password> [workstation]"
 480                         "[logon_type (1 or 2)] [auth level (2 or 3)] [logon_parameter]\n");
 481                 return NT_STATUS_OK;
 482         }
 483
 484         username = argv[1];
 485         password = argv[2];
 486
 487         if (argc >= 4)
 488                 workstation = argv[3];
 489
 490         if (argc >= 5)
 491                 sscanf(argv[4], "%i", &logon_type);
 492
 493         if (argc >= 6)
 494                 sscanf(argv[5], "%i", &auth_level);
 495
 496         if (argc == 7)
 497                 sscanf(argv[6], "%x", &logon_param);
 498
 499         /* Perform the sam logon */
 500
 501         result = rpccli_netlogon_sam_logon(cli, mem_ctx, logon_param, lp_workgroup(), username, password, workstation, logon_type);
 502
 503         if (!NT_STATUS_IS_OK(result))
 504                 goto done;
 505
 506  done:
 507         return result;
 508 }
 509
 510 /* Change the trust account password */
 511
 512 static NTSTATUS cmd_netlogon_change_trust_pw(struct rpc_pipe_client *cli,
 513                                              TALLOC_CTX *mem_ctx, int argc,
 514                                              const char **argv)
 515 {
 516         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 517
 518         /* Check arguments */
 519
 520         if (argc > 1) {
 521                 fprintf(stderr, "Usage: change_trust_pw");
 522                 return NT_STATUS_OK;
 523         }
 524
 525         /* Perform the sam logon */
 526
 527         result = trust_pw_find_change_and_store_it(cli, mem_ctx,
 528                                                    lp_workgroup());
 529
 530         if (!NT_STATUS_IS_OK(result))
 531                 goto done;
 532
 533  done:
 534         return result;
 535 }
 536
 537
 538 /* List of commands exported by this module */
 539
 540 struct cmd_set netlogon_commands[] = {
 541
 542         { "NETLOGON" },
 543
 544         { "logonctrl2", RPC_RTYPE_NTSTATUS, cmd_netlogon_logon_ctrl2, NULL, PI_NETLOGON, NULL, "Logon Control 2",     "" },
 545         { "getanydcname", RPC_RTYPE_WERROR, NULL, cmd_netlogon_getanydcname, PI_NETLOGON, NULL, "Get trusted DC name",     "" },
 546         { "dsr_getdcname", RPC_RTYPE_WERROR, NULL, cmd_netlogon_dsr_getdcname, PI_NETLOGON, NULL, "Get trusted DC name",     "" },
 547         { "dsr_getdcnameex", RPC_RTYPE_WERROR, NULL, cmd_netlogon_dsr_getdcnameex, PI_NETLOGON, NULL, "Get trusted DC name",     "" },
 548         { "dsr_getdcnameex2", RPC_RTYPE_WERROR, NULL, cmd_netlogon_dsr_getdcnameex2, PI_NETLOGON, NULL, "Get trusted DC name",     "" },
 549         { "dsr_getsitename", RPC_RTYPE_WERROR, NULL, cmd_netlogon_dsr_getsitename, PI_NETLOGON, NULL, "Get sitename",     "" },
 550         { "logonctrl",  RPC_RTYPE_NTSTATUS, cmd_netlogon_logon_ctrl,  NULL, PI_NETLOGON, NULL, "Logon Control",       "" },
 551         { "samsync",    RPC_RTYPE_NTSTATUS, cmd_netlogon_sam_sync,    NULL, PI_NETLOGON, NULL, "Sam Synchronisation", "" },
 552         { "samdeltas",  RPC_RTYPE_NTSTATUS, cmd_netlogon_sam_deltas,  NULL, PI_NETLOGON, NULL, "Query Sam Deltas",    "" },
 553         { "samlogon",   RPC_RTYPE_NTSTATUS, cmd_netlogon_sam_logon,   NULL, PI_NETLOGON, NULL, "Sam Logon",           "" },
 554         { "change_trust_pw",   RPC_RTYPE_NTSTATUS, cmd_netlogon_change_trust_pw,   NULL, PI_NETLOGON, NULL, "Change Trust Account Password",           "" },
 555
 556         { NULL }
 557 };