source: trunk-3.0/source/rpcclient/cmd_netlogon.c@ 101

Last change on this file since 101 was 44, checked in by Paul Smedley, 18 years ago

Update source to 3.0.25b
File size: 16.9 KB
Line 
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
25static 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
48static 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
73static 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
114static 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
165static 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
213static 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
272static 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
297static 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
325static 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
393static 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
428static 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
465static 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
512static 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
540struct 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};
Note: See TracBrowser for help on using the repository browser.