00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include "includes.h"
00023 #include "rpcclient.h"
00024
00025 static NTSTATUS cmd_netlogon_logon_ctrl2(struct rpc_pipe_client *cli,
00026 TALLOC_CTX *mem_ctx, int argc,
00027 const char **argv)
00028 {
00029 uint32 query_level = 1;
00030 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
00031
00032 if (argc > 1) {
00033 fprintf(stderr, "Usage: %s\n", argv[0]);
00034 return NT_STATUS_OK;
00035 }
00036
00037 result = rpccli_netlogon_logon_ctrl2(cli, mem_ctx, query_level);
00038
00039 if (!NT_STATUS_IS_OK(result))
00040 goto done;
00041
00042
00043
00044 done:
00045 return result;
00046 }
00047
00048 static WERROR cmd_netlogon_getanydcname(struct rpc_pipe_client *cli,
00049 TALLOC_CTX *mem_ctx, int argc,
00050 const char **argv)
00051 {
00052 fstring dcname;
00053 WERROR result = WERR_GENERAL_FAILURE;
00054
00055 if (argc != 2) {
00056 fprintf(stderr, "Usage: %s domainname\n", argv[0]);
00057 return WERR_OK;
00058 }
00059
00060 result = rpccli_netlogon_getanydcname(cli, mem_ctx, cli->cli->desthost, argv[1], dcname);
00061
00062 if (!W_ERROR_IS_OK(result))
00063 goto done;
00064
00065
00066
00067 printf("%s\n", dcname);
00068
00069 done:
00070 return result;
00071 }
00072
00073 static void display_ds_domain_controller_info(TALLOC_CTX *mem_ctx, const struct DS_DOMAIN_CONTROLLER_INFO *info)
00074 {
00075 d_printf("domain_controller_name: %s\n", info->domain_controller_name);
00076 d_printf("domain_controller_address: %s\n", info->domain_controller_address);
00077 d_printf("domain_controller_address_type: %d\n", info->domain_controller_address_type);
00078 d_printf("domain_guid: %s\n", GUID_string(mem_ctx, info->domain_guid));
00079 d_printf("domain_name: %s\n", info->domain_name);
00080 d_printf("dns_forest_name: %s\n", info->dns_forest_name);
00081 d_printf("flags: 0x%08x\n"
00082 "\tIs a PDC: %s\n"
00083 "\tIs a GC of the forest: %s\n"
00084 "\tIs an LDAP server: %s\n"
00085 "\tSupports DS: %s\n"
00086 "\tIs running a KDC: %s\n"
00087 "\tIs running time services: %s\n"
00088 "\tIs the closest DC: %s\n"
00089 "\tIs writable: %s\n"
00090 "\tHas a hardware clock: %s\n"
00091 "\tIs a non-domain NC serviced by LDAP server: %s\n"
00092 "\tDomainControllerName is a DNS name: %s\n"
00093 "\tDomainName is a DNS name: %s\n"
00094 "\tDnsForestName is a DNS name: %s\n",
00095 info->flags,
00096 (info->flags & ADS_PDC) ? "yes" : "no",
00097 (info->flags & ADS_GC) ? "yes" : "no",
00098 (info->flags & ADS_LDAP) ? "yes" : "no",
00099 (info->flags & ADS_DS) ? "yes" : "no",
00100 (info->flags & ADS_KDC) ? "yes" : "no",
00101 (info->flags & ADS_TIMESERV) ? "yes" : "no",
00102 (info->flags & ADS_CLOSEST) ? "yes" : "no",
00103 (info->flags & ADS_WRITABLE) ? "yes" : "no",
00104 (info->flags & ADS_GOOD_TIMESERV) ? "yes" : "no",
00105 (info->flags & ADS_NDNC) ? "yes" : "no",
00106 (info->flags & ADS_DNS_CONTROLLER) ? "yes":"no",
00107 (info->flags & ADS_DNS_DOMAIN) ? "yes":"no",
00108 (info->flags & ADS_DNS_FOREST) ? "yes":"no");
00109
00110 d_printf("dc_site_name: %s\n", info->dc_site_name);
00111 d_printf("client_site_name: %s\n", info->client_site_name);
00112 }
00113
00114 static WERROR cmd_netlogon_dsr_getdcname(struct rpc_pipe_client *cli,
00115 TALLOC_CTX *mem_ctx, int argc,
00116 const char **argv)
00117 {
00118 WERROR result;
00119 uint32 flags = DS_RETURN_DNS_NAME;
00120 const char *server_name = cli->cli->desthost;
00121 const char *domain_name;
00122 struct GUID domain_guid = GUID_zero();
00123 struct GUID site_guid = GUID_zero();
00124 struct DS_DOMAIN_CONTROLLER_INFO *info = NULL;
00125
00126 if (argc < 2) {
00127 fprintf(stderr, "Usage: %s [domainname] [domain_name] [domain_guid] [site_guid] [flags]\n", argv[0]);
00128 return WERR_OK;
00129 }
00130
00131 if (argc >= 2)
00132 domain_name = argv[1];
00133
00134 if (argc >= 3) {
00135 if (!NT_STATUS_IS_OK(GUID_from_string(argv[2], &domain_guid))) {
00136 return WERR_NOMEM;
00137 }
00138 }
00139
00140 if (argc >= 4) {
00141 if (!NT_STATUS_IS_OK(GUID_from_string(argv[3], &site_guid))) {
00142 return WERR_NOMEM;
00143 }
00144 }
00145
00146 if (argc >= 5)
00147 sscanf(argv[4], "%x", &flags);
00148
00149 result = rpccli_netlogon_dsr_getdcname(cli, mem_ctx, server_name, domain_name,
00150 &domain_guid, &site_guid, flags,
00151 &info);
00152
00153 if (W_ERROR_IS_OK(result)) {
00154 d_printf("DsGetDcName gave\n");
00155 display_ds_domain_controller_info(mem_ctx, info);
00156 return WERR_OK;
00157 }
00158
00159 printf("rpccli_netlogon_dsr_getdcname returned %s\n",
00160 dos_errstr(result));
00161
00162 return result;
00163 }
00164
00165 static WERROR cmd_netlogon_dsr_getdcnameex(struct rpc_pipe_client *cli,
00166 TALLOC_CTX *mem_ctx, int argc,
00167 const char **argv)
00168 {
00169 WERROR result;
00170 uint32 flags = DS_RETURN_DNS_NAME;
00171 const char *server_name = cli->cli->desthost;
00172 const char *domain_name;
00173 const char *site_name = NULL;
00174 struct GUID domain_guid = GUID_zero();
00175 struct DS_DOMAIN_CONTROLLER_INFO *info = NULL;
00176
00177 if (argc < 2) {
00178 fprintf(stderr, "Usage: %s [domainname] [domain_name] [domain_guid] [site_name] [flags]\n", argv[0]);
00179 return WERR_OK;
00180 }
00181
00182 if (argc >= 2)
00183 domain_name = argv[1];
00184
00185 if (argc >= 3) {
00186 if (!NT_STATUS_IS_OK(GUID_from_string(argv[2], &domain_guid))) {
00187 return WERR_NOMEM;
00188 }
00189 }
00190
00191 if (argc >= 4)
00192 site_name = argv[3];
00193
00194 if (argc >= 5)
00195 sscanf(argv[4], "%x", &flags);
00196
00197 result = rpccli_netlogon_dsr_getdcnameex(cli, mem_ctx, server_name, domain_name,
00198 &domain_guid, site_name, flags,
00199 &info);
00200
00201 if (W_ERROR_IS_OK(result)) {
00202 d_printf("DsGetDcNameEx gave\n");
00203 display_ds_domain_controller_info(mem_ctx, info);
00204 return WERR_OK;
00205 }
00206
00207 printf("rpccli_netlogon_dsr_getdcnameex returned %s\n",
00208 dos_errstr(result));
00209
00210 return result;
00211 }
00212
00213 static WERROR cmd_netlogon_dsr_getdcnameex2(struct rpc_pipe_client *cli,
00214 TALLOC_CTX *mem_ctx, int argc,
00215 const char **argv)
00216 {
00217 WERROR result;
00218 uint32 flags = DS_RETURN_DNS_NAME;
00219 const char *server_name = cli->cli->desthost;
00220 const char *domain_name = NULL;
00221 const char *client_account = NULL;
00222 uint32 mask = 0;
00223 const char *site_name = NULL;
00224 struct GUID domain_guid = GUID_zero();
00225 struct DS_DOMAIN_CONTROLLER_INFO *info = NULL;
00226
00227 if (argc < 2) {
00228 fprintf(stderr, "Usage: %s [domainname] [client_account] [acb_mask] [domain_name] [domain_guid] [site_name] [flags]\n", argv[0]);
00229 return WERR_OK;
00230 }
00231
00232 if (argc >= 2)
00233 client_account = argv[1];
00234
00235 if (argc >= 3)
00236 mask = atoi(argv[2]);
00237
00238 if (argc >= 4)
00239 domain_name = argv[3];
00240
00241 if (argc >= 5) {
00242 if (!NT_STATUS_IS_OK(GUID_from_string(argv[4], &domain_guid))) {
00243 return WERR_NOMEM;
00244 }
00245 }
00246
00247 if (argc >= 6)
00248 site_name = argv[5];
00249
00250 if (argc >= 7)
00251 sscanf(argv[6], "%x", &flags);
00252
00253 result = rpccli_netlogon_dsr_getdcnameex2(cli, mem_ctx, server_name,
00254 client_account, mask,
00255 domain_name, &domain_guid,
00256 site_name, flags,
00257 &info);
00258
00259 if (W_ERROR_IS_OK(result)) {
00260 d_printf("DsGetDcNameEx2 gave\n");
00261 display_ds_domain_controller_info(mem_ctx, info);
00262 return WERR_OK;
00263 }
00264
00265 printf("rpccli_netlogon_dsr_getdcnameex2 returned %s\n",
00266 dos_errstr(result));
00267
00268 return result;
00269 }
00270
00271
00272 static WERROR cmd_netlogon_dsr_getsitename(struct rpc_pipe_client *cli,
00273 TALLOC_CTX *mem_ctx, int argc,
00274 const char **argv)
00275 {
00276 WERROR result;
00277 char *sitename;
00278
00279 if (argc != 2) {
00280 fprintf(stderr, "Usage: %s computername\n", argv[0]);
00281 return WERR_OK;
00282 }
00283
00284 result = rpccli_netlogon_dsr_getsitename(cli, mem_ctx, argv[1], &sitename);
00285
00286 if (!W_ERROR_IS_OK(result)) {
00287 printf("rpccli_netlogon_dsr_gesitename returned %s\n",
00288 nt_errstr(werror_to_ntstatus(result)));
00289 return result;
00290 }
00291
00292 printf("Computer %s is on Site: %s\n", argv[1], sitename);
00293
00294 return WERR_OK;
00295 }
00296
00297 static NTSTATUS cmd_netlogon_logon_ctrl(struct rpc_pipe_client *cli,
00298 TALLOC_CTX *mem_ctx, int argc,
00299 const char **argv)
00300 {
00301 #if 0
00302 uint32 query_level = 1;
00303 #endif
00304 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
00305
00306 if (argc > 1) {
00307 fprintf(stderr, "Usage: %s\n", argv[0]);
00308 return NT_STATUS_OK;
00309 }
00310
00311 #if 0
00312 result = cli_netlogon_logon_ctrl(cli, mem_ctx, query_level);
00313 if (!NT_STATUS_IS_OK(result)) {
00314 goto done;
00315 }
00316 #endif
00317
00318
00319
00320 return result;
00321 }
00322
00323
00324
00325 static void display_sam_sync(uint32 num_deltas, SAM_DELTA_HDR *hdr_deltas,
00326 SAM_DELTA_CTR *deltas)
00327 {
00328 fstring name;
00329 uint32 i, j;
00330
00331 for (i = 0; i < num_deltas; i++) {
00332 switch (hdr_deltas[i].type) {
00333 case SAM_DELTA_DOMAIN_INFO:
00334 unistr2_to_ascii(name,
00335 &deltas[i].domain_info.uni_dom_name,
00336 sizeof(name) - 1);
00337 printf("Domain: %s\n", name);
00338 break;
00339 case SAM_DELTA_GROUP_INFO:
00340 unistr2_to_ascii(name,
00341 &deltas[i].group_info.uni_grp_name,
00342 sizeof(name) - 1);
00343 printf("Group: %s\n", name);
00344 break;
00345 case SAM_DELTA_ACCOUNT_INFO:
00346 unistr2_to_ascii(name,
00347 &deltas[i].account_info.uni_acct_name,
00348 sizeof(name) - 1);
00349 printf("Account: %s\n", name);
00350 break;
00351 case SAM_DELTA_ALIAS_INFO:
00352 unistr2_to_ascii(name,
00353 &deltas[i].alias_info.uni_als_name,
00354 sizeof(name) - 1);
00355 printf("Alias: %s\n", name);
00356 break;
00357 case SAM_DELTA_ALIAS_MEM: {
00358 SAM_ALIAS_MEM_INFO *alias = &deltas[i].als_mem_info;
00359
00360 for (j = 0; j < alias->num_members; j++) {
00361 fstring sid_str;
00362
00363 sid_to_string(sid_str, &alias->sids[j].sid);
00364
00365 printf("%s\n", sid_str);
00366 }
00367 break;
00368 }
00369 case SAM_DELTA_GROUP_MEM: {
00370 SAM_GROUP_MEM_INFO *group = &deltas[i].grp_mem_info;
00371
00372 for (j = 0; j < group->num_members; j++)
00373 printf("rid 0x%x, attrib 0x%08x\n",
00374 group->rids[j], group->attribs[j]);
00375 break;
00376 }
00377 case SAM_DELTA_MODIFIED_COUNT: {
00378 SAM_DELTA_MOD_COUNT *mc = &deltas[i].mod_count;
00379
00380 printf("sam sequence update: 0x%04x\n", mc->seqnum);
00381 break;
00382 }
00383 default:
00384 printf("unknown delta type 0x%02x\n",
00385 hdr_deltas[i].type);
00386 break;
00387 }
00388 }
00389 }
00390
00391
00392
00393 static NTSTATUS cmd_netlogon_sam_sync(struct rpc_pipe_client *cli,
00394 TALLOC_CTX *mem_ctx, int argc,
00395 const char **argv)
00396 {
00397 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
00398 uint32 database_id = 0, num_deltas;
00399 SAM_DELTA_HDR *hdr_deltas;
00400 SAM_DELTA_CTR *deltas;
00401
00402 if (argc > 2) {
00403 fprintf(stderr, "Usage: %s [database_id]\n", argv[0]);
00404 return NT_STATUS_OK;
00405 }
00406
00407 if (argc == 2)
00408 database_id = atoi(argv[1]);
00409
00410
00411
00412 result = rpccli_netlogon_sam_sync(cli, mem_ctx, database_id,
00413 0, &num_deltas, &hdr_deltas, &deltas);
00414
00415 if (!NT_STATUS_IS_OK(result))
00416 goto done;
00417
00418
00419
00420 display_sam_sync(num_deltas, hdr_deltas, deltas);
00421
00422 done:
00423 return result;
00424 }
00425
00426
00427
00428 static NTSTATUS cmd_netlogon_sam_deltas(struct rpc_pipe_client *cli,
00429 TALLOC_CTX *mem_ctx, int argc,
00430 const char **argv)
00431 {
00432 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
00433 uint32 database_id, num_deltas, tmp;
00434 SAM_DELTA_HDR *hdr_deltas;
00435 SAM_DELTA_CTR *deltas;
00436 uint64 seqnum;
00437
00438 if (argc != 3) {
00439 fprintf(stderr, "Usage: %s database_id seqnum\n", argv[0]);
00440 return NT_STATUS_OK;
00441 }
00442
00443 database_id = atoi(argv[1]);
00444 tmp = atoi(argv[2]);
00445
00446 seqnum = tmp & 0xffff;
00447
00448 result = rpccli_netlogon_sam_deltas(cli, mem_ctx, database_id,
00449 seqnum, &num_deltas,
00450 &hdr_deltas, &deltas);
00451
00452 if (!NT_STATUS_IS_OK(result))
00453 goto done;
00454
00455
00456
00457 display_sam_sync(num_deltas, hdr_deltas, deltas);
00458
00459 done:
00460 return result;
00461 }
00462
00463
00464
00465 static NTSTATUS cmd_netlogon_sam_logon(struct rpc_pipe_client *cli,
00466 TALLOC_CTX *mem_ctx, int argc,
00467 const char **argv)
00468 {
00469 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
00470 int logon_type = NET_LOGON_TYPE;
00471 const char *username, *password;
00472 int auth_level = 2;
00473 uint32 logon_param = 0;
00474 const char *workstation = NULL;
00475
00476
00477
00478 if (argc < 3 || argc > 7) {
00479 fprintf(stderr, "Usage: samlogon <username> <password> [workstation]"
00480 "[logon_type (1 or 2)] [auth level (2 or 3)] [logon_parameter]\n");
00481 return NT_STATUS_OK;
00482 }
00483
00484 username = argv[1];
00485 password = argv[2];
00486
00487 if (argc >= 4)
00488 workstation = argv[3];
00489
00490 if (argc >= 5)
00491 sscanf(argv[4], "%i", &logon_type);
00492
00493 if (argc >= 6)
00494 sscanf(argv[5], "%i", &auth_level);
00495
00496 if (argc == 7)
00497 sscanf(argv[6], "%x", &logon_param);
00498
00499
00500
00501 result = rpccli_netlogon_sam_logon(cli, mem_ctx, logon_param, lp_workgroup(), username, password, workstation, logon_type);
00502
00503 if (!NT_STATUS_IS_OK(result))
00504 goto done;
00505
00506 done:
00507 return result;
00508 }
00509
00510
00511
00512 static NTSTATUS cmd_netlogon_change_trust_pw(struct rpc_pipe_client *cli,
00513 TALLOC_CTX *mem_ctx, int argc,
00514 const char **argv)
00515 {
00516 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
00517
00518
00519
00520 if (argc > 1) {
00521 fprintf(stderr, "Usage: change_trust_pw");
00522 return NT_STATUS_OK;
00523 }
00524
00525
00526
00527 result = trust_pw_find_change_and_store_it(cli, mem_ctx,
00528 lp_workgroup());
00529
00530 if (!NT_STATUS_IS_OK(result))
00531 goto done;
00532
00533 done:
00534 return result;
00535 }
00536
00537
00538
00539
00540 struct cmd_set netlogon_commands[] = {
00541
00542 { "NETLOGON" },
00543
00544 { "logonctrl2", RPC_RTYPE_NTSTATUS, cmd_netlogon_logon_ctrl2, NULL, PI_NETLOGON, NULL, "Logon Control 2", "" },
00545 { "getanydcname", RPC_RTYPE_WERROR, NULL, cmd_netlogon_getanydcname, PI_NETLOGON, NULL, "Get trusted DC name", "" },
00546 { "dsr_getdcname", RPC_RTYPE_WERROR, NULL, cmd_netlogon_dsr_getdcname, PI_NETLOGON, NULL, "Get trusted DC name", "" },
00547 { "dsr_getdcnameex", RPC_RTYPE_WERROR, NULL, cmd_netlogon_dsr_getdcnameex, PI_NETLOGON, NULL, "Get trusted DC name", "" },
00548 { "dsr_getdcnameex2", RPC_RTYPE_WERROR, NULL, cmd_netlogon_dsr_getdcnameex2, PI_NETLOGON, NULL, "Get trusted DC name", "" },
00549 { "dsr_getsitename", RPC_RTYPE_WERROR, NULL, cmd_netlogon_dsr_getsitename, PI_NETLOGON, NULL, "Get sitename", "" },
00550 { "logonctrl", RPC_RTYPE_NTSTATUS, cmd_netlogon_logon_ctrl, NULL, PI_NETLOGON, NULL, "Logon Control", "" },
00551 { "samsync", RPC_RTYPE_NTSTATUS, cmd_netlogon_sam_sync, NULL, PI_NETLOGON, NULL, "Sam Synchronisation", "" },
00552 { "samdeltas", RPC_RTYPE_NTSTATUS, cmd_netlogon_sam_deltas, NULL, PI_NETLOGON, NULL, "Query Sam Deltas", "" },
00553 { "samlogon", RPC_RTYPE_NTSTATUS, cmd_netlogon_sam_logon, NULL, PI_NETLOGON, NULL, "Sam Logon", "" },
00554 { "change_trust_pw", RPC_RTYPE_NTSTATUS, cmd_netlogon_change_trust_pw, NULL, PI_NETLOGON, NULL, "Change Trust Account Password", "" },
00555
00556 { NULL }
00557 };