?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Use samr connect4, then fall back to samr connect if it fails. This is
[Samba/gbeck.git] / source3 / rpcclient / cmd_samr.c
blobd9251f90bd15804ac826759e3706c615decafdc9
1 /*
2 Unix SMB/CIFS implementation.
3 RPC pipe client
4
5 Copyright (C) Andrew Tridgell 1992-2000,
6 Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
7 Copyright (C) Elrond 2000,
8 Copyright (C) Tim Potter 2000
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 */
24
25 #include "includes.h"
26 #include "rpcclient.h"
27
28 extern DOM_SID domain_sid;
29
30 /****************************************************************************
31 display sam_user_info_21 structure
32 ****************************************************************************/
33 static void display_sam_user_info_21(SAM_USER_INFO_21 *usr)
34 {
35 fstring temp;
36
37 unistr2_to_ascii(temp, &usr->uni_user_name, sizeof(temp)-1);
38 printf("\tUser Name :\t%s\n", temp);
39
40 unistr2_to_ascii(temp, &usr->uni_full_name, sizeof(temp)-1);
41 printf("\tFull Name :\t%s\n", temp);
42
43 unistr2_to_ascii(temp, &usr->uni_home_dir, sizeof(temp)-1);
44 printf("\tHome Drive :\t%s\n", temp);
45
46 unistr2_to_ascii(temp, &usr->uni_dir_drive, sizeof(temp)-1);
47 printf("\tDir Drive :\t%s\n", temp);
48
49 unistr2_to_ascii(temp, &usr->uni_profile_path, sizeof(temp)-1);
50 printf("\tProfile Path:\t%s\n", temp);
51
52 unistr2_to_ascii(temp, &usr->uni_logon_script, sizeof(temp)-1);
53 printf("\tLogon Script:\t%s\n", temp);
54
55 unistr2_to_ascii(temp, &usr->uni_acct_desc, sizeof(temp)-1);
56 printf("\tDescription :\t%s\n", temp);
57
58 unistr2_to_ascii(temp, &usr->uni_workstations, sizeof(temp)-1);
59 printf("\tWorkstations:\t%s\n", temp);
60
61 unistr2_to_ascii(temp, &usr->uni_unknown_str, sizeof(temp)-1);
62 printf("\tUnknown Str :\t%s\n", temp);
63
64 unistr2_to_ascii(temp, &usr->uni_munged_dial, sizeof(temp)-1);
65 printf("\tRemote Dial :\t%s\n", temp);
66
67 printf("\tLogon Time :\t%s\n",
68 http_timestring(nt_time_to_unix(&usr->logon_time)));
69 printf("\tLogoff Time :\t%s\n",
70 http_timestring(nt_time_to_unix(&usr->logoff_time)));
71 printf("\tKickoff Time :\t%s\n",
72 http_timestring(nt_time_to_unix(&usr->kickoff_time)));
73 printf("\tPassword last set Time :\t%s\n",
74 http_timestring(nt_time_to_unix(&usr->pass_last_set_time)));
75 printf("\tPassword can change Time :\t%s\n",
76 http_timestring(nt_time_to_unix(&usr->pass_can_change_time)));
77 printf("\tPassword must change Time:\t%s\n",
78 http_timestring(nt_time_to_unix(&usr->pass_must_change_time)));
79
80 printf("\tunknown_2[0..31]...\n"); /* user passwords? */
81
82 printf("\tuser_rid :\t0x%x\n" , usr->user_rid ); /* User ID */
83 printf("\tgroup_rid:\t0x%x\n" , usr->group_rid); /* Group ID */
84 printf("\tacb_info :\t0x%04x\n", usr->acb_info ); /* Account Control Info */
85
86 printf("\tunknown_3:\t0x%08x\n", usr->unknown_3); /* 0x00ff ffff */
87 printf("\tlogon_divs:\t%d\n", usr->logon_divs); /* 0x0000 00a8 which is 168 which is num hrs in a week */
88 printf("\tunknown_5:\t0x%08x\n", usr->unknown_5); /* 0x0002 0000 */
89
90 printf("\tpadding1[0..7]...\n");
91
92 if (usr->ptr_logon_hrs) {
93 printf("\tlogon_hrs[0..%d]...\n", usr->logon_hrs.len);
94 }
95 }
96
97 static char *display_time(NTTIME nttime)
98 {
99 static fstring string;
100
101 float high;
102 float low;
103 int sec;
104 int days, hours, mins, secs;
105
106 if (nttime.high==0 && nttime.low==0)
107 return "Now";
108
109 if (nttime.high==0x80000000 && nttime.low==0)
110 return "Never";
111
112 high = 65536;
113 high = high/10000;
114 high = high*65536;
115 high = high/1000;
116 high = high * (~nttime.high);
117
118 low = ~nttime.low;
119 low = low/(1000*1000*10);
120
121 sec=high+low;
122
123 days=sec/(60*60*24);
124 hours=(sec - (days*60*60*24)) / (60*60);
125 mins=(sec - (days*60*60*24) - (hours*60*60) ) / 60;
126 secs=sec - (days*60*60*24) - (hours*60*60) - (mins*60);
127
128 snprintf(string, sizeof(string)-1, "%u days, %u hours, %u minutes, %u seconds", days, hours, mins, secs);
129 return (string);
130 }
131
132 static void display_sam_unk_info_1(SAM_UNK_INFO_1 *info1)
133 {
134
135 printf("Minimum password length: %d\n", info1->min_length_password);
136 printf("Password uniqueness (remember x passwords): %d\n", info1->password_history);
137 printf("flag: ");
138 if(info1->flag&&2==2) printf("users must open a session to change password ");
139 printf("\n");
140
141 printf("password expire in: %s\n", display_time(info1->expire));
142 printf("Min password age (allow changing in x days): %s\n", display_time(info1->min_passwordage));
143 }
144
145 static void display_sam_unk_info_2(SAM_UNK_INFO_2 *info2)
146 {
147 fstring name;
148
149 unistr2_to_ascii(name, &info2->uni_domain, sizeof(name) - 1);
150 printf("Domain:\t%s\n", name);
151
152 unistr2_to_ascii(name, &info2->uni_server, sizeof(name) - 1);
153 printf("Server:\t%s\n", name);
154
155 printf("Total Users:\t%d\n", info2->num_domain_usrs);
156 printf("Total Groups:\t%d\n", info2->num_domain_grps);
157 printf("Total Aliases:\t%d\n", info2->num_local_grps);
158
159 printf("Sequence No:\t%d\n", info2->seq_num);
160
161 printf("Unknown 0:\t0x%x\n", info2->unknown_0);
162 printf("Unknown 1:\t0x%x\n", info2->unknown_1);
163 printf("Unknown 2:\t0x%x\n", info2->unknown_2);
164 printf("Unknown 3:\t0x%x\n", info2->unknown_3);
165 printf("Unknown 4:\t0x%x\n", info2->unknown_4);
166 printf("Unknown 5:\t0x%x\n", info2->unknown_5);
167 printf("Unknown 6:\t0x%x\n", info2->unknown_6);
168 }
169
170 static void display_sam_info_1(SAM_ENTRY1 *e1, SAM_STR1 *s1)
171 {
172 fstring tmp;
173
174 printf("index: 0x%x ", e1->user_idx);
175 printf("RID: 0x%x ", e1->rid_user);
176 printf("acb: 0x%x ", e1->acb_info);
177
178 unistr2_to_ascii(tmp, &s1->uni_acct_name, sizeof(tmp)-1);
179 printf("Account: %s\t", tmp);
180
181 unistr2_to_ascii(tmp, &s1->uni_full_name, sizeof(tmp)-1);
182 printf("Name: %s\t", tmp);
183
184 unistr2_to_ascii(tmp, &s1->uni_acct_desc, sizeof(tmp)-1);
185 printf("Desc: %s\n", tmp);
186 }
187
188 static void display_sam_info_2(SAM_ENTRY2 *e2, SAM_STR2 *s2)
189 {
190 fstring tmp;
191
192 printf("index: 0x%x ", e2->user_idx);
193 printf("RID: 0x%x ", e2->rid_user);
194 printf("acb: 0x%x ", e2->acb_info);
195
196 unistr2_to_ascii(tmp, &s2->uni_srv_name, sizeof(tmp)-1);
197 printf("Account: %s\t", tmp);
198
199 unistr2_to_ascii(tmp, &s2->uni_srv_desc, sizeof(tmp)-1);
200 printf("Name: %s\n", tmp);
201
202 }
203
204 static void display_sam_info_3(SAM_ENTRY3 *e3, SAM_STR3 *s3)
205 {
206 fstring tmp;
207
208 printf("index: 0x%x ", e3->grp_idx);
209 printf("RID: 0x%x ", e3->rid_grp);
210 printf("attr: 0x%x ", e3->attr);
211
212 unistr2_to_ascii(tmp, &s3->uni_grp_name, sizeof(tmp)-1);
213 printf("Account: %s\t", tmp);
214
215 unistr2_to_ascii(tmp, &s3->uni_grp_desc, sizeof(tmp)-1);
216 printf("Name: %s\n", tmp);
217
218 }
219
220 static void display_sam_info_4(SAM_ENTRY4 *e4, SAM_STR4 *s4)
221 {
222 int i;
223
224 printf("index: %d ", e4->user_idx);
225
226 printf("Account: ");
227 for (i=0; i<s4->acct_name.str_str_len; i++)
228 printf("%c", s4->acct_name.buffer[i]);
229 printf("\n");
230
231 }
232
233 static void display_sam_info_5(SAM_ENTRY5 *e5, SAM_STR5 *s5)
234 {
235 int i;
236
237 printf("index: 0x%x ", e5->grp_idx);
238
239 printf("Account: ");
240 for (i=0; i<s5->grp_name.str_str_len; i++)
241 printf("%c", s5->grp_name.buffer[i]);
242 printf("\n");
243
244 }
245
246 /****************************************************************************
247 Try samr_connect4 first, then samr_conenct if it fails
248 ****************************************************************************/
249 static NTSTATUS try_samr_connects(struct cli_state *cli, TALLOC_CTX *mem_ctx,
250 uint32 access_mask, POLICY_HND *connect_pol)
251 {
252 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
253
254 result = cli_samr_connect4(cli, mem_ctx, access_mask, connect_pol);
255 if (!NT_STATUS_IS_OK(result)) {
256 result = cli_samr_connect(cli, mem_ctx, access_mask,
257 connect_pol);
258 }
259 return result;
260 }
261
262 /**********************************************************************
263 * Query user information
264 */
265 static NTSTATUS cmd_samr_query_user(struct cli_state *cli,
266 TALLOC_CTX *mem_ctx,
267 int argc, char **argv)
268 {
269 POLICY_HND connect_pol, domain_pol, user_pol;
270 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
271 uint32 info_level = 21;
272 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
273 SAM_USERINFO_CTR *user_ctr;
274 fstring server;
275 uint32 user_rid;
276
277 if ((argc < 2) || (argc > 4)) {
278 printf("Usage: %s rid [info level] [access mask] \n", argv[0]);
279 return NT_STATUS_OK;
280 }
281
282 sscanf(argv[1], "%i", &user_rid);
283
284 if (argc > 2)
285 sscanf(argv[2], "%i", &info_level);
286
287 if (argc > 3)
288 sscanf(argv[3], "%x", &access_mask);
289
290
291 slprintf (server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
292 strupper (server);
293
294 result = try_samr_connects(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
295 &connect_pol);
296
297 if (!NT_STATUS_IS_OK(result))
298 goto done;
299
300 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
301 MAXIMUM_ALLOWED_ACCESS,
302 &domain_sid, &domain_pol);
303
304 if (!NT_STATUS_IS_OK(result))
305 goto done;
306
307 result = cli_samr_open_user(cli, mem_ctx, &domain_pol,
308 access_mask,
309 user_rid, &user_pol);
310
311 if (!NT_STATUS_IS_OK(result))
312 goto done;
313
314 ZERO_STRUCT(user_ctr);
315
316 result = cli_samr_query_userinfo(cli, mem_ctx, &user_pol,
317 info_level, &user_ctr);
318
319 if (!NT_STATUS_IS_OK(result))
320 goto done;
321
322 display_sam_user_info_21(user_ctr->info.id21);
323
324 done:
325 return result;
326 }
327
328 /****************************************************************************
329 display group info
330 ****************************************************************************/
331 static void display_group_info1(GROUP_INFO1 *info1)
332 {
333 fstring temp;
334
335 unistr2_to_ascii(temp, &info1->uni_acct_name, sizeof(temp)-1);
336 printf("\tGroup Name:\t%s\n", temp);
337 unistr2_to_ascii(temp, &info1->uni_acct_desc, sizeof(temp)-1);
338 printf("\tDescription:\t%s\n", temp);
339 printf("\tunk1:%d\n", info1->unknown_1);
340 printf("\tNum Members:%d\n", info1->num_members);
341 }
342
343 /****************************************************************************
344 display group info
345 ****************************************************************************/
346 static void display_group_info4(GROUP_INFO4 *info4)
347 {
348 fstring desc;
349
350 unistr2_to_ascii(desc, &info4->uni_acct_desc, sizeof(desc)-1);
351 printf("\tGroup Description:%s\n", desc);
352 }
353
354 /****************************************************************************
355 display sam sync structure
356 ****************************************************************************/
357 static void display_group_info_ctr(GROUP_INFO_CTR *ctr)
358 {
359 switch (ctr->switch_value1) {
360 case 1: {
361 display_group_info1(&ctr->group.info1);
362 break;
363 }
364 case 4: {
365 display_group_info4(&ctr->group.info4);
366 break;
367 }
368 }
369 }
370
371 /***********************************************************************
372 * Query group information
373 */
374 static NTSTATUS cmd_samr_query_group(struct cli_state *cli,
375 TALLOC_CTX *mem_ctx,
376 int argc, char **argv)
377 {
378 POLICY_HND connect_pol, domain_pol, group_pol;
379 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
380 uint32 info_level = 1;
381 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
382 GROUP_INFO_CTR group_ctr;
383 fstring server;
384 uint32 group_rid;
385
386 if ((argc < 2) || (argc > 4)) {
387 printf("Usage: %s rid [info level] [access mask]\n", argv[0]);
388 return NT_STATUS_OK;
389 }
390
391 sscanf(argv[1], "%i", &group_rid);
392
393 if (argc > 2)
394 sscanf(argv[2], "%i", &info_level);
395
396 if (argc > 3)
397 sscanf(argv[3], "%x", &access_mask);
398
399 slprintf (server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
400 strupper (server);
401
402 result = try_samr_connects(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
403 &connect_pol);
404
405 if (!NT_STATUS_IS_OK(result))
406 goto done;
407
408 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
409 MAXIMUM_ALLOWED_ACCESS,
410 &domain_sid, &domain_pol);
411
412 if (!NT_STATUS_IS_OK(result))
413 goto done;
414
415 result = cli_samr_open_group(cli, mem_ctx, &domain_pol,
416 access_mask,
417 group_rid, &group_pol);
418
419 if (!NT_STATUS_IS_OK(result))
420 goto done;
421
422 ZERO_STRUCT(group_ctr);
423
424 result = cli_samr_query_groupinfo(cli, mem_ctx, &group_pol,
425 info_level, &group_ctr);
426 if (!NT_STATUS_IS_OK(result)) {
427 goto done;
428 }
429
430 display_group_info_ctr(&group_ctr);
431
432 done:
433 return result;
434 }
435
436 /* Query groups a user is a member of */
437
438 static NTSTATUS cmd_samr_query_usergroups(struct cli_state *cli,
439 TALLOC_CTX *mem_ctx,
440 int argc, char **argv)
441 {
442 POLICY_HND connect_pol,
443 domain_pol,
444 user_pol;
445 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
446 uint32 num_groups,
447 user_rid;
448 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
449 DOM_GID *user_gids;
450 int i;
451 fstring server;
452
453 if ((argc < 2) || (argc > 3)) {
454 printf("Usage: %s rid [access mask]\n", argv[0]);
455 return NT_STATUS_OK;
456 }
457
458 sscanf(argv[1], "%i", &user_rid);
459
460 if (argc > 2)
461 sscanf(argv[2], "%x", &access_mask);
462
463 slprintf (server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
464 strupper (server);
465
466 result = try_samr_connects(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
467 &connect_pol);
468
469 if (!NT_STATUS_IS_OK(result))
470 goto done;
471
472 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
473 MAXIMUM_ALLOWED_ACCESS,
474 &domain_sid, &domain_pol);
475
476 if (!NT_STATUS_IS_OK(result))
477 goto done;
478
479 result = cli_samr_open_user(cli, mem_ctx, &domain_pol,
480 access_mask,
481 user_rid, &user_pol);
482
483 if (!NT_STATUS_IS_OK(result))
484 goto done;
485
486 result = cli_samr_query_usergroups(cli, mem_ctx, &user_pol,
487 &num_groups, &user_gids);
488
489 if (!NT_STATUS_IS_OK(result))
490 goto done;
491
492 for (i = 0; i < num_groups; i++) {
493 printf("\tgroup rid:[0x%x] attr:[0x%x]\n",
494 user_gids[i].g_rid, user_gids[i].attr);
495 }
496
497 done:
498 return result;
499 }
500
501 /* Query aliases a user is a member of */
502
503 static NTSTATUS cmd_samr_query_useraliases(struct cli_state *cli,
504 TALLOC_CTX *mem_ctx,
505 int argc, char **argv)
506 {
507 POLICY_HND connect_pol, domain_pol;
508 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
509 uint32 user_rid, num_aliases, *alias_rids;
510 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
511 int i;
512 fstring server;
513 DOM_SID tmp_sid;
514 DOM_SID2 sid;
515 DOM_SID global_sid_Builtin;
516
517 string_to_sid(&global_sid_Builtin, "S-1-5-32");
518
519 if ((argc < 3) || (argc > 4)) {
520 printf("Usage: %s builtin|domain rid [access mask]\n", argv[0]);
521 return NT_STATUS_OK;
522 }
523
524 sscanf(argv[2], "%i", &user_rid);
525
526 if (argc > 3)
527 sscanf(argv[3], "%x", &access_mask);
528
529 slprintf (server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
530 strupper (server);
531
532 result = try_samr_connects(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
533 &connect_pol);
534
535 if (!NT_STATUS_IS_OK(result))
536 goto done;
537
538 if (StrCaseCmp(argv[1], "domain")==0)
539 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
540 access_mask,
541 &domain_sid, &domain_pol);
542 else if (StrCaseCmp(argv[1], "builtin")==0)
543 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
544 access_mask,
545 &global_sid_Builtin, &domain_pol);
546 else
547 return NT_STATUS_OK;
548
549 if (!NT_STATUS_IS_OK(result))
550 goto done;
551
552 sid_copy(&tmp_sid, &domain_sid);
553 sid_append_rid(&tmp_sid, user_rid);
554 init_dom_sid2(&sid, &tmp_sid);
555
556 result = cli_samr_query_useraliases(cli, mem_ctx, &domain_pol, 1, &sid, &num_aliases, &alias_rids);
557
558 if (!NT_STATUS_IS_OK(result))
559 goto done;
560
561 for (i = 0; i < num_aliases; i++) {
562 printf("\tgroup rid:[0x%x]\n", alias_rids[i]);
563 }
564
565 done:
566 return result;
567 }
568
569 /* Query members of a group */
570
571 static NTSTATUS cmd_samr_query_groupmem(struct cli_state *cli,
572 TALLOC_CTX *mem_ctx,
573 int argc, char **argv)
574 {
575 POLICY_HND connect_pol, domain_pol, group_pol;
576 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
577 uint32 num_members, *group_rids, *group_attrs, group_rid;
578 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
579 int i;
580 fstring server;
581
582 if ((argc < 2) || (argc > 3)) {
583 printf("Usage: %s rid [access mask]\n", argv[0]);
584 return NT_STATUS_OK;
585 }
586
587 sscanf(argv[1], "%i", &group_rid);
588
589 if (argc > 2)
590 sscanf(argv[2], "%x", &access_mask);
591
592 slprintf (server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
593 strupper (server);
594
595 result = try_samr_connects(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
596 &connect_pol);
597
598 if (!NT_STATUS_IS_OK(result))
599 goto done;
600
601 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
602 MAXIMUM_ALLOWED_ACCESS,
603 &domain_sid, &domain_pol);
604
605 if (!NT_STATUS_IS_OK(result))
606 goto done;
607
608 result = cli_samr_open_group(cli, mem_ctx, &domain_pol,
609 access_mask,
610 group_rid, &group_pol);
611
612 if (!NT_STATUS_IS_OK(result))
613 goto done;
614
615 result = cli_samr_query_groupmem(cli, mem_ctx, &group_pol,
616 &num_members, &group_rids,
617 &group_attrs);
618
619 if (!NT_STATUS_IS_OK(result))
620 goto done;
621
622 for (i = 0; i < num_members; i++) {
623 printf("\trid:[0x%x] attr:[0x%x]\n", group_rids[i],
624 group_attrs[i]);
625 }
626
627 done:
628 return result;
629 }
630
631 /* Enumerate domain groups */
632
633 static NTSTATUS cmd_samr_enum_dom_groups(struct cli_state *cli,
634 TALLOC_CTX *mem_ctx,
635 int argc, char **argv)
636 {
637 POLICY_HND connect_pol, domain_pol;
638 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
639 uint32 start_idx, size, num_dom_groups, i;
640 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
641 struct acct_info *dom_groups;
642 BOOL got_connect_pol = False, got_domain_pol = False;
643
644 if ((argc < 1) || (argc > 2)) {
645 printf("Usage: %s [access_mask]\n", argv[0]);
646 return NT_STATUS_OK;
647 }
648
649 if (argc > 1)
650 sscanf(argv[1], "%x", &access_mask);
651
652 /* Get sam policy handle */
653
654 result = try_samr_connects(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
655 &connect_pol);
656
657 if (!NT_STATUS_IS_OK(result))
658 goto done;
659
660 got_connect_pol = True;
661
662 /* Get domain policy handle */
663
664 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
665 access_mask,
666 &domain_sid, &domain_pol);
667
668 if (!NT_STATUS_IS_OK(result))
669 goto done;
670
671 got_domain_pol = True;
672
673 /* Enumerate domain groups */
674
675 start_idx = 0;
676 size = 0xffff;
677
678 do {
679 result = cli_samr_enum_dom_groups(
680 cli, mem_ctx, &domain_pol, &start_idx, size,
681 &dom_groups, &num_dom_groups);
682
683 if (NT_STATUS_IS_OK(result) ||
684 NT_STATUS_V(result) == NT_STATUS_V(STATUS_MORE_ENTRIES)) {
685
686 for (i = 0; i < num_dom_groups; i++)
687 printf("group:[%s] rid:[0x%x]\n",
688 dom_groups[i].acct_name,
689 dom_groups[i].rid);
690 }
691
692 } while (NT_STATUS_V(result) == NT_STATUS_V(STATUS_MORE_ENTRIES));
693
694 done:
695 if (got_domain_pol)
696 cli_samr_close(cli, mem_ctx, &domain_pol);
697
698 if (got_connect_pol)
699 cli_samr_close(cli, mem_ctx, &connect_pol);
700
701 return result;
702 }
703
704 /* Enumerate alias groups */
705
706 static NTSTATUS cmd_samr_enum_als_groups(struct cli_state *cli,
707 TALLOC_CTX *mem_ctx,
708 int argc, char **argv)
709 {
710 POLICY_HND connect_pol, domain_pol;
711 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
712 uint32 start_idx, size, num_als_groups, i;
713 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
714 struct acct_info *als_groups;
715 DOM_SID global_sid_Builtin;
716 BOOL got_connect_pol = False, got_domain_pol = False;
717
718 string_to_sid(&global_sid_Builtin, "S-1-5-32");
719
720 if ((argc < 2) || (argc > 3)) {
721 printf("Usage: %s builtin|domain [access mask]\n", argv[0]);
722 return NT_STATUS_OK;
723 }
724
725 if (argc > 2)
726 sscanf(argv[2], "%x", &access_mask);
727
728 /* Get sam policy handle */
729
730 result = try_samr_connects(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
731 &connect_pol);
732
733 if (!NT_STATUS_IS_OK(result))
734 goto done;
735
736 got_connect_pol = True;
737
738 /* Get domain policy handle */
739
740 if (StrCaseCmp(argv[1], "domain")==0)
741 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
742 access_mask,
743 &domain_sid, &domain_pol);
744 else if (StrCaseCmp(argv[1], "builtin")==0)
745 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
746 access_mask,
747 &global_sid_Builtin, &domain_pol);
748 else
749 return NT_STATUS_OK;
750
751 if (!NT_STATUS_IS_OK(result))
752 goto done;
753
754 got_domain_pol = True;
755
756 /* Enumerate alias groups */
757
758 start_idx = 0;
759 size = 0xffff; /* Number of groups to retrieve */
760
761 do {
762 result = cli_samr_enum_als_groups(
763 cli, mem_ctx, &domain_pol, &start_idx, size,
764 &als_groups, &num_als_groups);
765
766 if (NT_STATUS_IS_OK(result) ||
767 NT_STATUS_V(result) == NT_STATUS_V(STATUS_MORE_ENTRIES)) {
768
769 for (i = 0; i < num_als_groups; i++)
770 printf("group:[%s] rid:[0x%x]\n",
771 als_groups[i].acct_name,
772 als_groups[i].rid);
773 }
774 } while (NT_STATUS_V(result) == NT_STATUS_V(STATUS_MORE_ENTRIES));
775
776 done:
777 if (got_domain_pol)
778 cli_samr_close(cli, mem_ctx, &domain_pol);
779
780 if (got_connect_pol)
781 cli_samr_close(cli, mem_ctx, &connect_pol);
782
783 return result;
784 }
785
786 /* Query alias membership */
787
788 static NTSTATUS cmd_samr_query_aliasmem(struct cli_state *cli,
789 TALLOC_CTX *mem_ctx,
790 int argc, char **argv)
791 {
792 POLICY_HND connect_pol, domain_pol, alias_pol;
793 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
794 uint32 alias_rid, num_members, i;
795 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
796 DOM_SID *alias_sids;
797 DOM_SID global_sid_Builtin;
798
799 string_to_sid(&global_sid_Builtin, "S-1-5-32");
800
801 if ((argc < 3) || (argc > 4)) {
802 printf("Usage: %s builtin|domain rid [access mask]\n", argv[0]);
803 return NT_STATUS_OK;
804 }
805
806 sscanf(argv[2], "%i", &alias_rid);
807
808 if (argc > 3)
809 sscanf(argv[3], "%x", &access_mask);
810
811 /* Open SAMR handle */
812
813 result = try_samr_connects(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
814 &connect_pol);
815
816 if (!NT_STATUS_IS_OK(result))
817 goto done;
818
819 /* Open handle on domain */
820
821 if (StrCaseCmp(argv[1], "domain")==0)
822 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
823 MAXIMUM_ALLOWED_ACCESS,
824 &domain_sid, &domain_pol);
825 else if (StrCaseCmp(argv[1], "builtin")==0)
826 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
827 MAXIMUM_ALLOWED_ACCESS,
828 &global_sid_Builtin, &domain_pol);
829 else
830 return NT_STATUS_OK;
831
832 if (!NT_STATUS_IS_OK(result))
833 goto done;
834
835 /* Open handle on alias */
836
837 result = cli_samr_open_alias(cli, mem_ctx, &domain_pol,
838 access_mask,
839 alias_rid, &alias_pol);
840 if (!NT_STATUS_IS_OK(result))
841 goto done;
842
843 result = cli_samr_query_aliasmem(cli, mem_ctx, &alias_pol,
844 &num_members, &alias_sids);
845
846 if (!NT_STATUS_IS_OK(result))
847 goto done;
848
849 for (i = 0; i < num_members; i++) {
850 fstring sid_str;
851
852 sid_to_string(sid_str, &alias_sids[i]);
853 printf("\tsid:[%s]\n", sid_str);
854 }
855
856 done:
857 return result;
858 }
859
860 /* Query display info */
861
862 static NTSTATUS cmd_samr_query_dispinfo(struct cli_state *cli,
863 TALLOC_CTX *mem_ctx,
864 int argc, char **argv)
865 {
866 POLICY_HND connect_pol, domain_pol;
867 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
868 uint32 start_idx=0, max_entries=250, num_entries, i;
869 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
870 uint32 info_level = 1;
871 SAM_DISPINFO_CTR ctr;
872 SAM_DISPINFO_1 info1;
873 SAM_DISPINFO_2 info2;
874 SAM_DISPINFO_3 info3;
875 SAM_DISPINFO_4 info4;
876 SAM_DISPINFO_5 info5;
877
878 if (argc > 5) {
879 printf("Usage: %s [info level] [start index] [max entries] [access mask]\n", argv[0]);
880 return NT_STATUS_OK;
881 }
882
883 if (argc >= 2)
884 sscanf(argv[1], "%i", &info_level);
885
886 if (argc >= 3)
887 sscanf(argv[2], "%i", &start_idx);
888
889 if (argc >= 4)
890 sscanf(argv[3], "%i", &max_entries);
891
892 if (argc >= 5)
893 sscanf(argv[4], "%x", &access_mask);
894
895 /* Get sam policy handle */
896
897 result = try_samr_connects(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
898 &connect_pol);
899
900 if (!NT_STATUS_IS_OK(result))
901 goto done;
902
903 /* Get domain policy handle */
904
905 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
906 access_mask,
907 &domain_sid, &domain_pol);
908
909 if (!NT_STATUS_IS_OK(result))
910 goto done;
911
912 /* Query display info */
913
914 ZERO_STRUCT(ctr);
915 ZERO_STRUCT(info1);
916
917 switch (info_level) {
918 case 1:
919 ZERO_STRUCT(info1);
920 ctr.sam.info1 = &info1;
921 break;
922 case 2:
923 ZERO_STRUCT(info2);
924 ctr.sam.info2 = &info2;
925 break;
926 case 3:
927 ZERO_STRUCT(info3);
928 ctr.sam.info3 = &info3;
929 break;
930 case 4:
931 ZERO_STRUCT(info4);
932 ctr.sam.info4 = &info4;
933 break;
934 case 5:
935 ZERO_STRUCT(info5);
936 ctr.sam.info5 = &info5;
937 break;
938 }
939
940
941 while(1) {
942
943 result = cli_samr_query_dispinfo(cli, mem_ctx, &domain_pol,
944 &start_idx, info_level,
945 &num_entries, max_entries, &ctr);
946
947 if (!NT_STATUS_IS_OK(result) && !NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES))
948 break;
949
950 if (num_entries == 0)
951 break;
952
953 for (i = 0; i < num_entries; i++) {
954 switch (info_level) {
955 case 1:
956 display_sam_info_1(&ctr.sam.info1->sam[i], &ctr.sam.info1->str[i]);
957 break;
958 case 2:
959 display_sam_info_2(&ctr.sam.info2->sam[i], &ctr.sam.info2->str[i]);
960 break;
961 case 3:
962 display_sam_info_3(&ctr.sam.info3->sam[i], &ctr.sam.info3->str[i]);
963 break;
964 case 4:
965 display_sam_info_4(&ctr.sam.info4->sam[i], &ctr.sam.info4->str[i]);
966 break;
967 case 5:
968 display_sam_info_5(&ctr.sam.info5->sam[i], &ctr.sam.info5->str[i]);
969 break;
970 }
971 }
972 }
973
974 done:
975 return result;
976 }
977
978 /* Query domain info */
979
980 static NTSTATUS cmd_samr_query_dominfo(struct cli_state *cli,
981 TALLOC_CTX *mem_ctx,
982 int argc, char **argv)
983 {
984 POLICY_HND connect_pol, domain_pol;
985 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
986 uint32 switch_level = 2;
987 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
988 SAM_UNK_CTR ctr;
989
990 if (argc > 2) {
991 printf("Usage: %s [info level] [access mask]\n", argv[0]);
992 return NT_STATUS_OK;
993 }
994
995 if (argc > 1)
996 sscanf(argv[1], "%i", &switch_level);
997
998 if (argc > 2)
999 sscanf(argv[2], "%x", &access_mask);
1000
1001 /* Get sam policy handle */
1002
1003 result = try_samr_connects(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
1004 &connect_pol);
1005
1006 if (!NT_STATUS_IS_OK(result))
1007 goto done;
1008
1009 /* Get domain policy handle */
1010
1011 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
1012 access_mask,
1013 &domain_sid, &domain_pol);
1014
1015 if (!NT_STATUS_IS_OK(result))
1016 goto done;
1017
1018 /* Query domain info */
1019
1020 result = cli_samr_query_dom_info(cli, mem_ctx, &domain_pol,
1021 switch_level, &ctr);
1022
1023 if (!NT_STATUS_IS_OK(result))
1024 goto done;
1025
1026 /* Display domain info */
1027
1028 switch (switch_level) {
1029 case 1:
1030 display_sam_unk_info_1(&ctr.info.inf1);
1031 break;
1032 case 2:
1033 display_sam_unk_info_2(&ctr.info.inf2);
1034 break;
1035 default:
1036 printf("cannot display domain info for switch value %d\n",
1037 switch_level);
1038 break;
1039 }
1040
1041 done:
1042
1043 cli_samr_close(cli, mem_ctx, &domain_pol);
1044 cli_samr_close(cli, mem_ctx, &connect_pol);
1045 return result;
1046 }
1047
1048 /* Create domain user */
1049
1050 static NTSTATUS cmd_samr_create_dom_user(struct cli_state *cli,
1051 TALLOC_CTX *mem_ctx,
1052 int argc, char **argv)
1053 {
1054 POLICY_HND connect_pol, domain_pol, user_pol;
1055 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1056 char *acct_name;
1057 uint16 acb_info;
1058 uint32 unknown, user_rid;
1059 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
1060
1061 if ((argc < 2) || (argc > 3)) {
1062 printf("Usage: %s username [access mask]\n", argv[0]);
1063 return NT_STATUS_OK;
1064 }
1065
1066 acct_name = argv[1];
1067
1068 if (argc > 2)
1069 sscanf(argv[2], "%x", &access_mask);
1070
1071 /* Get sam policy handle */
1072
1073 result = try_samr_connects(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
1074 &connect_pol);
1075
1076 if (!NT_STATUS_IS_OK(result))
1077 goto done;
1078
1079 /* Get domain policy handle */
1080
1081 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
1082 access_mask,
1083 &domain_sid, &domain_pol);
1084
1085 if (!NT_STATUS_IS_OK(result))
1086 goto done;
1087
1088 /* Create domain user */
1089
1090 acb_info = ACB_NORMAL;
1091 unknown = 0xe005000b; /* No idea what this is - a permission mask? */
1092
1093 result = cli_samr_create_dom_user(cli, mem_ctx, &domain_pol,
1094 acct_name, acb_info, unknown,
1095 &user_pol, &user_rid);
1096
1097 if (!NT_STATUS_IS_OK(result))
1098 goto done;
1099
1100 done:
1101 return result;
1102 }
1103
1104 /* Lookup sam names */
1105
1106 static NTSTATUS cmd_samr_lookup_names(struct cli_state *cli,
1107 TALLOC_CTX *mem_ctx,
1108 int argc, char **argv)
1109 {
1110 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1111 POLICY_HND connect_pol, domain_pol;
1112 uint32 flags = 0x000003e8; /* Unknown */
1113 uint32 num_rids, num_names, *name_types, *rids;
1114 const char **names;
1115 int i;
1116 DOM_SID global_sid_Builtin;
1117
1118 string_to_sid(&global_sid_Builtin, "S-1-5-32");
1119
1120 if (argc < 3) {
1121 printf("Usage: %s domain|builtin name1 [name2 [name3] [...]]\n", argv[0]);
1122 printf("check on the domain SID: S-1-5-21-x-y-z\n");
1123 printf("or check on the builtin SID: S-1-5-32\n");
1124 return NT_STATUS_OK;
1125 }
1126
1127 /* Get sam policy and domain handles */
1128
1129 result = try_samr_connects(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
1130 &connect_pol);
1131
1132 if (!NT_STATUS_IS_OK(result))
1133 goto done;
1134
1135 if (StrCaseCmp(argv[1], "domain")==0)
1136 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
1137 MAXIMUM_ALLOWED_ACCESS,
1138 &domain_sid, &domain_pol);
1139 else if (StrCaseCmp(argv[1], "builtin")==0)
1140 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
1141 MAXIMUM_ALLOWED_ACCESS,
1142 &global_sid_Builtin, &domain_pol);
1143 else
1144 return NT_STATUS_OK;
1145
1146 if (!NT_STATUS_IS_OK(result))
1147 goto done;
1148
1149 /* Look up names */
1150
1151 num_names = argc - 2;
1152 names = (const char **)talloc(mem_ctx, sizeof(char *) * num_names);
1153
1154 for (i = 0; i < argc - 2; i++)
1155 names[i] = argv[i + 2];
1156
1157 result = cli_samr_lookup_names(cli, mem_ctx, &domain_pol,
1158 flags, num_names, names,
1159 &num_rids, &rids, &name_types);
1160
1161 if (!NT_STATUS_IS_OK(result))
1162 goto done;
1163
1164 /* Display results */
1165
1166 for (i = 0; i < num_names; i++)
1167 printf("name %s: 0x%x (%d)\n", names[i], rids[i],
1168 name_types[i]);
1169
1170 done:
1171 return result;
1172 }
1173
1174 /* Lookup sam rids */
1175
1176 static NTSTATUS cmd_samr_lookup_rids(struct cli_state *cli,
1177 TALLOC_CTX *mem_ctx,
1178 int argc, char **argv)
1179 {
1180 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1181 POLICY_HND connect_pol, domain_pol;
1182 uint32 flags = 0x000003e8; /* Unknown */
1183 uint32 num_rids, num_names, *rids, *name_types;
1184 char **names;
1185 int i;
1186
1187 if (argc < 2) {
1188 printf("Usage: %s rid1 [rid2 [rid3] [...]]\n", argv[0]);
1189 return NT_STATUS_OK;
1190 }
1191
1192 /* Get sam policy and domain handles */
1193
1194 result = try_samr_connects(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
1195 &connect_pol);
1196
1197 if (!NT_STATUS_IS_OK(result))
1198 goto done;
1199
1200 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
1201 MAXIMUM_ALLOWED_ACCESS,
1202 &domain_sid, &domain_pol);
1203
1204 if (!NT_STATUS_IS_OK(result))
1205 goto done;
1206
1207 /* Look up rids */
1208
1209 num_rids = argc - 1;
1210 rids = (uint32 *)talloc(mem_ctx, sizeof(uint32) * num_rids);
1211
1212 for (i = 0; i < argc - 1; i++)
1213 sscanf(argv[i + 1], "%i", &rids[i]);
1214
1215 result = cli_samr_lookup_rids(cli, mem_ctx, &domain_pol,
1216 flags, num_rids, rids,
1217 &num_names, &names, &name_types);
1218
1219 if (!NT_STATUS_IS_OK(result))
1220 goto done;
1221
1222 /* Display results */
1223
1224 for (i = 0; i < num_names; i++)
1225 printf("rid 0x%x: %s (%d)\n", rids[i], names[i], name_types[i]);
1226
1227 done:
1228 return result;
1229 }
1230
1231 /* Delete domain user */
1232
1233 static NTSTATUS cmd_samr_delete_dom_user(struct cli_state *cli,
1234 TALLOC_CTX *mem_ctx,
1235 int argc, char **argv)
1236 {
1237 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1238 POLICY_HND connect_pol, domain_pol, user_pol;
1239 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
1240
1241 if ((argc < 2) || (argc > 3)) {
1242 printf("Usage: %s username\n", argv[0]);
1243 return NT_STATUS_OK;
1244 }
1245
1246 if (argc > 2)
1247 sscanf(argv[2], "%x", &access_mask);
1248
1249 /* Get sam policy and domain handles */
1250
1251 result = try_samr_connects(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
1252 &connect_pol);
1253
1254 if (!NT_STATUS_IS_OK(result))
1255 goto done;
1256
1257 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
1258 MAXIMUM_ALLOWED_ACCESS,
1259 &domain_sid, &domain_pol);
1260
1261 if (!NT_STATUS_IS_OK(result))
1262 goto done;
1263
1264 /* Get handle on user */
1265
1266 {
1267 uint32 *user_rids, num_rids, *name_types;
1268 uint32 flags = 0x000003e8; /* Unknown */
1269
1270 result = cli_samr_lookup_names(cli, mem_ctx, &domain_pol,
1271 flags, 1, (const char **)&argv[1],
1272 &num_rids, &user_rids,
1273 &name_types);
1274
1275 if (!NT_STATUS_IS_OK(result))
1276 goto done;
1277
1278 result = cli_samr_open_user(cli, mem_ctx, &domain_pol,
1279 access_mask,
1280 user_rids[0], &user_pol);
1281
1282 if (!NT_STATUS_IS_OK(result))
1283 goto done;
1284 }
1285
1286 /* Delete user */
1287
1288 result = cli_samr_delete_dom_user(cli, mem_ctx, &user_pol);
1289
1290 if (!NT_STATUS_IS_OK(result))
1291 goto done;
1292
1293 /* Display results */
1294
1295 done:
1296 return result;
1297 }
1298
1299 /**********************************************************************
1300 * Query user security object
1301 */
1302 static NTSTATUS cmd_samr_query_sec_obj(struct cli_state *cli,
1303 TALLOC_CTX *mem_ctx,
1304 int argc, char **argv)
1305 {
1306 POLICY_HND connect_pol, domain_pol, user_pol, *pol;
1307 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1308 uint32 info_level = 4;
1309 fstring server;
1310 uint32 user_rid = 0;
1311 TALLOC_CTX *ctx = NULL;
1312 SEC_DESC_BUF *sec_desc_buf=NULL;
1313 BOOL domain = False;
1314
1315 ctx=talloc_init();
1316
1317 if ((argc < 1) || (argc > 2)) {
1318 printf("Usage: %s [rid|-d]\n", argv[0]);
1319 printf("\tSpecify rid for security on user, -d for security on domain\n");
1320 return NT_STATUS_OK;
1321 }
1322
1323 if (argc > 1) {
1324 if (strcmp(argv[1], "-d") == 0)
1325 domain = True;
1326 else
1327 sscanf(argv[1], "%i", &user_rid);
1328 }
1329
1330 slprintf (server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
1331 strupper (server);
1332 result = try_samr_connects(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
1333 &connect_pol);
1334
1335 if (!NT_STATUS_IS_OK(result))
1336 goto done;
1337
1338 if (domain || user_rid)
1339 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
1340 MAXIMUM_ALLOWED_ACCESS,
1341 &domain_sid, &domain_pol);
1342
1343 if (!NT_STATUS_IS_OK(result))
1344 goto done;
1345
1346 if (user_rid)
1347 result = cli_samr_open_user(cli, mem_ctx, &domain_pol,
1348 MAXIMUM_ALLOWED_ACCESS,
1349 user_rid, &user_pol);
1350
1351 if (!NT_STATUS_IS_OK(result))
1352 goto done;
1353
1354 /* Pick which query pol to use */
1355
1356 pol = &connect_pol;
1357
1358 if (domain)
1359 pol = &domain_pol;
1360
1361 if (user_rid)
1362 pol = &user_pol;
1363
1364 /* Query SAM security object */
1365
1366 result = cli_samr_query_sec_obj(cli, mem_ctx, pol, info_level, ctx,
1367 &sec_desc_buf);
1368
1369 if (!NT_STATUS_IS_OK(result))
1370 goto done;
1371
1372 display_sec_desc(sec_desc_buf->sec);
1373
1374 done:
1375 talloc_destroy(ctx);
1376 return result;
1377 }
1378
1379 static NTSTATUS cmd_samr_get_dom_pwinfo(struct cli_state *cli,
1380 TALLOC_CTX *mem_ctx,
1381 int argc, char **argv)
1382 {
1383 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1384 uint16 unk_0, unk_1, unk_2;
1385
1386 if (argc != 1) {
1387 printf("Usage: %s\n", argv[0]);
1388 return NT_STATUS_OK;
1389 }
1390
1391 result = cli_samr_get_dom_pwinfo(cli, mem_ctx, &unk_0, &unk_1, &unk_2);
1392
1393 if (NT_STATUS_IS_OK(result)) {
1394 printf("unk_0 = 0x%08x\n", unk_0);
1395 printf("unk_1 = 0x%08x\n", unk_1);
1396 printf("unk_2 = 0x%08x\n", unk_2);
1397 }
1398
1399 return result;
1400 }
1401
1402
1403 /* List of commands exported by this module */
1404
1405 struct cmd_set samr_commands[] = {
1406
1407 { "SAMR" },
1408
1409 { "queryuser", cmd_samr_query_user, PIPE_SAMR, "Query user info", "" },
1410 { "querygroup", cmd_samr_query_group, PIPE_SAMR, "Query group info", "" },
1411 { "queryusergroups", cmd_samr_query_usergroups, PIPE_SAMR, "Query user groups", "" },
1412 { "queryuseraliases", cmd_samr_query_useraliases, PIPE_SAMR, "Query user aliases", "" },
1413 { "querygroupmem", cmd_samr_query_groupmem, PIPE_SAMR, "Query group membership", "" },
1414 { "queryaliasmem", cmd_samr_query_aliasmem, PIPE_SAMR, "Query alias membership", "" },
1415 { "querydispinfo", cmd_samr_query_dispinfo, PIPE_SAMR, "Query display info", "" },
1416 { "querydominfo", cmd_samr_query_dominfo, PIPE_SAMR, "Query domain info", "" },
1417 { "enumdomgroups", cmd_samr_enum_dom_groups, PIPE_SAMR, "Enumerate domain groups", "" },
1418 { "enumalsgroups", cmd_samr_enum_als_groups, PIPE_SAMR, "Enumerate alias groups", "" },
1419
1420 { "createdomuser", cmd_samr_create_dom_user, PIPE_SAMR, "Create domain user", "" },
1421 { "samlookupnames", cmd_samr_lookup_names, PIPE_SAMR, "Look up names", "" },
1422 { "samlookuprids", cmd_samr_lookup_rids, PIPE_SAMR, "Look up names", "" },
1423 { "deletedomuser", cmd_samr_delete_dom_user, PIPE_SAMR, "Delete domain user", "" },
1424 { "samquerysecobj", cmd_samr_query_sec_obj, PIPE_SAMR, "Query SAMR security object", "" },
1425 { "getdompwinfo", cmd_samr_get_dom_pwinfo, PIPE_SAMR, "Retrieve domain password info", "" },
1426
1427 { NULL }
1428 };
WIP