2 Unix SMB/CIFS implementation.
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
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.
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.
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.
26 #include "rpcclient.h"
28 extern DOM_SID domain_sid;
30 /****************************************************************************
31 display sam_user_info_7 structure
32 ****************************************************************************/
33 static void display_sam_user_info_7(SAM_USER_INFO_7 *usr)
37 unistr2_to_ascii(temp, &usr->uni_name, sizeof(temp)-1);
38 printf("\tUser Name :\t%s\n", temp);
41 /****************************************************************************
42 display sam_user_info_9 structure
43 ****************************************************************************/
44 static void display_sam_user_info_9(SAM_USER_INFO_9 *usr)
46 printf("\tPrimary group RID :\tox%x\n", usr->rid_group);
49 /****************************************************************************
50 display sam_user_info_21 structure
51 ****************************************************************************/
52 static void display_sam_user_info_21(SAM_USER_INFO_21 *usr)
56 unistr2_to_ascii(temp, &usr->uni_user_name, sizeof(temp)-1);
57 printf("\tUser Name :\t%s\n", temp);
59 unistr2_to_ascii(temp, &usr->uni_full_name, sizeof(temp)-1);
60 printf("\tFull Name :\t%s\n", temp);
62 unistr2_to_ascii(temp, &usr->uni_home_dir, sizeof(temp)-1);
63 printf("\tHome Drive :\t%s\n", temp);
65 unistr2_to_ascii(temp, &usr->uni_dir_drive, sizeof(temp)-1);
66 printf("\tDir Drive :\t%s\n", temp);
68 unistr2_to_ascii(temp, &usr->uni_profile_path, sizeof(temp)-1);
69 printf("\tProfile Path:\t%s\n", temp);
71 unistr2_to_ascii(temp, &usr->uni_logon_script, sizeof(temp)-1);
72 printf("\tLogon Script:\t%s\n", temp);
74 unistr2_to_ascii(temp, &usr->uni_acct_desc, sizeof(temp)-1);
75 printf("\tDescription :\t%s\n", temp);
77 unistr2_to_ascii(temp, &usr->uni_workstations, sizeof(temp)-1);
78 printf("\tWorkstations:\t%s\n", temp);
80 unistr2_to_ascii(temp, &usr->uni_unknown_str, sizeof(temp)-1);
81 printf("\tUnknown Str :\t%s\n", temp);
83 unistr2_to_ascii(temp, &usr->uni_munged_dial, sizeof(temp)-1);
84 printf("\tRemote Dial :\t%s\n", temp);
86 printf("\tLogon Time :\t%s\n",
87 http_timestring(nt_time_to_unix(&usr->logon_time)));
88 printf("\tLogoff Time :\t%s\n",
89 http_timestring(nt_time_to_unix(&usr->logoff_time)));
90 printf("\tKickoff Time :\t%s\n",
91 http_timestring(nt_time_to_unix(&usr->kickoff_time)));
92 printf("\tPassword last set Time :\t%s\n",
93 http_timestring(nt_time_to_unix(&usr->pass_last_set_time)));
94 printf("\tPassword can change Time :\t%s\n",
95 http_timestring(nt_time_to_unix(&usr->pass_can_change_time)));
96 printf("\tPassword must change Time:\t%s\n",
97 http_timestring(nt_time_to_unix(&usr->pass_must_change_time)));
99 printf("\tunknown_2[0..31]...\n"); /* user passwords? */
101 printf("\tuser_rid :\t0x%x\n" , usr->user_rid ); /* User ID */
102 printf("\tgroup_rid:\t0x%x\n" , usr->group_rid); /* Group ID */
103 printf("\tacb_info :\t0x%04x\n", usr->acb_info ); /* Account Control Info */
105 printf("\tfields_present:\t0x%08x\n", usr->fields_present); /* 0x00ff ffff */
106 printf("\tlogon_divs:\t%d\n", usr->logon_divs); /* 0x0000 00a8 which is 168 which is num hrs in a week */
107 printf("\tbad_password_count:\t0x%08x\n", usr->bad_password_count);
108 printf("\tlogon_count:\t0x%08x\n", usr->logon_count);
110 printf("\tpadding1[0..7]...\n");
112 if (usr->ptr_logon_hrs) {
113 printf("\tlogon_hrs[0..%d]...\n", usr->logon_hrs.len);
117 static const char *display_time(NTTIME nttime)
119 static fstring string;
124 int days, hours, mins, secs;
126 if (nttime.high==0 && nttime.low==0)
129 if (nttime.high==0x80000000 && nttime.low==0)
136 high = high * (~nttime.high);
139 low = low/(1000*1000*10);
144 hours=(sec - (days*60*60*24)) / (60*60);
145 mins=(sec - (days*60*60*24) - (hours*60*60) ) / 60;
146 secs=sec - (days*60*60*24) - (hours*60*60) - (mins*60);
148 fstr_sprintf(string, "%u days, %u hours, %u minutes, %u seconds", days, hours, mins, secs);
152 static void display_sam_unk_info_1(SAM_UNK_INFO_1 *info1)
155 printf("Minimum password length:\t\t\t%d\n", info1->min_length_password);
156 printf("Password uniqueness (remember x passwords):\t%d\n", info1->password_history);
157 printf("Password Properties:\t\t\t\t0x%08x\n", info1->password_properties);
159 if (info1->password_properties & DOMAIN_PASSWORD_COMPLEX)
160 printf("\tDOMAIN_PASSWORD_COMPLEX\n");
162 if (info1->password_properties & DOMAIN_PASSWORD_NO_ANON_CHANGE) {
163 printf("\tDOMAIN_PASSWORD_NO_ANON_CHANGE\n");
164 printf("users must open a session to change password ");
167 if (info1->password_properties & DOMAIN_PASSWORD_NO_CLEAR_CHANGE)
168 printf("\tDOMAIN_PASSWORD_NO_CLEAR_CHANGE\n");
170 if (info1->password_properties & DOMAIN_LOCKOUT_ADMINS)
171 printf("\tDOMAIN_LOCKOUT_ADMINS\n");
173 if (info1->password_properties & DOMAIN_PASSWORD_STORE_CLEARTEXT)
174 printf("\tDOMAIN_PASSWORD_STORE_CLEARTEXT\n");
176 if (info1->password_properties & DOMAIN_REFUSE_PASSWORD_CHANGE)
177 printf("\tDOMAIN_REFUSE_PASSWORD_CHANGE\n");
179 printf("password expire in:\t\t\t\t%s\n", display_time(info1->expire));
180 printf("Min password age (allow changing in x days):\t%s\n", display_time(info1->min_passwordage));
183 static void display_sam_unk_info_2(SAM_UNK_INFO_2 *info2)
187 unistr2_to_ascii(name, &info2->uni_domain, sizeof(name) - 1);
188 printf("Domain:\t\t%s\n", name);
190 unistr2_to_ascii(name, &info2->uni_server, sizeof(name) - 1);
191 printf("Server:\t\t%s\n", name);
193 unistr2_to_ascii(name, &info2->uni_comment, sizeof(name) - 1);
194 printf("Comment:\t%s\n", name);
196 printf("Total Users:\t%d\n", info2->num_domain_usrs);
197 printf("Total Groups:\t%d\n", info2->num_domain_grps);
198 printf("Total Aliases:\t%d\n", info2->num_local_grps);
200 printf("Sequence No:\t%d\n", info2->seq_num.low);
202 printf("Force Logoff:\t%d\n", (int)nt_time_to_unix_abs(&info2->logout));
204 printf("Unknown 4:\t0x%x\n", info2->unknown_4);
205 printf("Server Role:\t%s\n", server_role_str(info2->server_role));
206 printf("Unknown 6:\t0x%x\n", info2->unknown_6);
209 static void display_sam_unk_info_7(SAM_UNK_INFO_7 *info7)
211 printf("Server Role:\t%s\n", server_role_str(info7->server_role));
214 static void display_sam_unk_info_8(SAM_UNK_INFO_8 *info8)
216 printf("Sequence No:\t%d\n", info8->seq_num.low);
217 printf("Domain Create Time:\t%s\n",
218 http_timestring(nt_time_to_unix(&info8->domain_create_time)));
222 static void display_sam_unk_info_12(SAM_UNK_INFO_12 *info12)
224 printf("Bad password lockout duration: %s\n", display_time(info12->duration));
225 printf("Reset Lockout after: %s\n", display_time(info12->reset_count));
226 printf("Lockout after bad attempts: %d\n", info12->bad_attempt_lockout);
229 static void display_sam_info_1(SAM_ENTRY1 *e1, SAM_STR1 *s1)
233 printf("index: 0x%x ", e1->user_idx);
234 printf("RID: 0x%x ", e1->rid_user);
235 printf("acb: 0x%x ", e1->acb_info);
237 unistr2_to_ascii(tmp, &s1->uni_acct_name, sizeof(tmp)-1);
238 printf("Account: %s\t", tmp);
240 unistr2_to_ascii(tmp, &s1->uni_full_name, sizeof(tmp)-1);
241 printf("Name: %s\t", tmp);
243 unistr2_to_ascii(tmp, &s1->uni_acct_desc, sizeof(tmp)-1);
244 printf("Desc: %s\n", tmp);
247 static void display_sam_info_2(SAM_ENTRY2 *e2, SAM_STR2 *s2)
251 printf("index: 0x%x ", e2->user_idx);
252 printf("RID: 0x%x ", e2->rid_user);
253 printf("acb: 0x%x ", e2->acb_info);
255 unistr2_to_ascii(tmp, &s2->uni_srv_name, sizeof(tmp)-1);
256 printf("Account: %s\t", tmp);
258 unistr2_to_ascii(tmp, &s2->uni_srv_desc, sizeof(tmp)-1);
259 printf("Name: %s\n", tmp);
263 static void display_sam_info_3(SAM_ENTRY3 *e3, SAM_STR3 *s3)
267 printf("index: 0x%x ", e3->grp_idx);
268 printf("RID: 0x%x ", e3->rid_grp);
269 printf("attr: 0x%x ", e3->attr);
271 unistr2_to_ascii(tmp, &s3->uni_grp_name, sizeof(tmp)-1);
272 printf("Account: %s\t", tmp);
274 unistr2_to_ascii(tmp, &s3->uni_grp_desc, sizeof(tmp)-1);
275 printf("Name: %s\n", tmp);
279 static void display_sam_info_4(SAM_ENTRY4 *e4, SAM_STR4 *s4)
283 printf("index: %d ", e4->user_idx);
286 for (i=0; i<s4->acct_name.str_str_len; i++)
287 printf("%c", s4->acct_name.buffer[i]);
292 static void display_sam_info_5(SAM_ENTRY5 *e5, SAM_STR5 *s5)
296 printf("index: 0x%x ", e5->grp_idx);
299 for (i=0; i<s5->grp_name.str_str_len; i++)
300 printf("%c", s5->grp_name.buffer[i]);
305 /****************************************************************************
306 Try samr_connect4 first, then samr_conenct if it fails
307 ****************************************************************************/
308 static NTSTATUS try_samr_connects(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
309 uint32 access_mask, POLICY_HND *connect_pol)
311 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
313 result = rpccli_samr_connect4(cli, mem_ctx, access_mask, connect_pol);
314 if (!NT_STATUS_IS_OK(result)) {
315 result = rpccli_samr_connect(cli, mem_ctx, access_mask,
321 /**********************************************************************
322 * Query user information
324 static NTSTATUS cmd_samr_query_user(struct rpc_pipe_client *cli,
326 int argc, const char **argv)
328 POLICY_HND connect_pol, domain_pol, user_pol;
329 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
330 uint32 info_level = 21;
331 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
332 SAM_USERINFO_CTR *user_ctr;
336 if ((argc < 2) || (argc > 4)) {
337 printf("Usage: %s rid [info level] [access mask] \n", argv[0]);
341 user_rid = strtoul(argv[1], NULL, 10);
344 sscanf(argv[2], "%i", &info_level);
347 sscanf(argv[3], "%x", &access_mask);
350 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
353 result = try_samr_connects(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
356 if (!NT_STATUS_IS_OK(result))
359 result = rpccli_samr_open_domain(cli, mem_ctx, &connect_pol,
360 MAXIMUM_ALLOWED_ACCESS,
361 &domain_sid, &domain_pol);
363 if (!NT_STATUS_IS_OK(result))
366 result = rpccli_samr_open_user(cli, mem_ctx, &domain_pol,
368 user_rid, &user_pol);
370 if (NT_STATUS_EQUAL(result, NT_STATUS_NO_SUCH_USER) &&
373 /* Probably this was a user name, try lookupnames */
375 uint32 *rids, *types;
377 result = rpccli_samr_lookup_names(cli, mem_ctx, &domain_pol,
382 if (NT_STATUS_IS_OK(result)) {
383 result = rpccli_samr_open_user(cli, mem_ctx,
391 if (!NT_STATUS_IS_OK(result))
394 ZERO_STRUCT(user_ctr);
396 result = rpccli_samr_query_userinfo(cli, mem_ctx, &user_pol,
397 info_level, &user_ctr);
399 if (!NT_STATUS_IS_OK(result))
402 switch (user_ctr->switch_value) {
404 display_sam_user_info_21(user_ctr->info.id21);
407 display_sam_user_info_7(user_ctr->info.id7);
410 display_sam_user_info_9(user_ctr->info.id9);
413 printf("Unsupported infolevel: %d\n", info_level);
417 rpccli_samr_close(cli, mem_ctx, &user_pol);
418 rpccli_samr_close(cli, mem_ctx, &domain_pol);
419 rpccli_samr_close(cli, mem_ctx, &connect_pol);
425 /****************************************************************************
427 ****************************************************************************/
428 static void display_group_info1(GROUP_INFO1 *info1)
432 unistr2_to_ascii(temp, &info1->uni_acct_name, sizeof(temp)-1);
433 printf("\tGroup Name:\t%s\n", temp);
434 unistr2_to_ascii(temp, &info1->uni_acct_desc, sizeof(temp)-1);
435 printf("\tDescription:\t%s\n", temp);
436 printf("\tGroup Attribute:%d\n", info1->group_attr);
437 printf("\tNum Members:%d\n", info1->num_members);
440 /****************************************************************************
442 ****************************************************************************/
443 static void display_group_info3(GROUP_INFO3 *info3)
445 printf("\tGroup Attribute:%d\n", info3->group_attr);
449 /****************************************************************************
451 ****************************************************************************/
452 static void display_group_info4(GROUP_INFO4 *info4)
456 unistr2_to_ascii(desc, &info4->uni_acct_desc, sizeof(desc)-1);
457 printf("\tGroup Description:%s\n", desc);
460 /****************************************************************************
461 display sam sync structure
462 ****************************************************************************/
463 static void display_group_info_ctr(GROUP_INFO_CTR *ctr)
465 switch (ctr->switch_value1) {
467 display_group_info1(&ctr->group.info1);
471 display_group_info3(&ctr->group.info3);
475 display_group_info4(&ctr->group.info4);
481 /***********************************************************************
482 * Query group information
484 static NTSTATUS cmd_samr_query_group(struct rpc_pipe_client *cli,
486 int argc, const char **argv)
488 POLICY_HND connect_pol, domain_pol, group_pol;
489 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
490 uint32 info_level = 1;
491 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
492 GROUP_INFO_CTR *group_ctr;
496 if ((argc < 2) || (argc > 4)) {
497 printf("Usage: %s rid [info level] [access mask]\n", argv[0]);
501 sscanf(argv[1], "%i", &group_rid);
504 sscanf(argv[2], "%i", &info_level);
507 sscanf(argv[3], "%x", &access_mask);
509 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
512 result = try_samr_connects(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
515 if (!NT_STATUS_IS_OK(result))
518 result = rpccli_samr_open_domain(cli, mem_ctx, &connect_pol,
519 MAXIMUM_ALLOWED_ACCESS,
520 &domain_sid, &domain_pol);
522 if (!NT_STATUS_IS_OK(result))
525 result = rpccli_samr_open_group(cli, mem_ctx, &domain_pol,
527 group_rid, &group_pol);
529 if (!NT_STATUS_IS_OK(result))
532 result = rpccli_samr_query_groupinfo(cli, mem_ctx, &group_pol,
533 info_level, &group_ctr);
534 if (!NT_STATUS_IS_OK(result)) {
538 display_group_info_ctr(group_ctr);
540 rpccli_samr_close(cli, mem_ctx, &group_pol);
541 rpccli_samr_close(cli, mem_ctx, &domain_pol);
542 rpccli_samr_close(cli, mem_ctx, &connect_pol);
547 /* Query groups a user is a member of */
549 static NTSTATUS cmd_samr_query_usergroups(struct rpc_pipe_client *cli,
551 int argc, const char **argv)
553 POLICY_HND connect_pol,
556 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
559 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
564 if ((argc < 2) || (argc > 3)) {
565 printf("Usage: %s rid [access mask]\n", argv[0]);
569 sscanf(argv[1], "%i", &user_rid);
572 sscanf(argv[2], "%x", &access_mask);
574 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
577 result = try_samr_connects(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
580 if (!NT_STATUS_IS_OK(result))
583 result = rpccli_samr_open_domain(cli, mem_ctx, &connect_pol,
584 MAXIMUM_ALLOWED_ACCESS,
585 &domain_sid, &domain_pol);
587 if (!NT_STATUS_IS_OK(result))
590 result = rpccli_samr_open_user(cli, mem_ctx, &domain_pol,
592 user_rid, &user_pol);
594 if (!NT_STATUS_IS_OK(result))
597 result = rpccli_samr_query_usergroups(cli, mem_ctx, &user_pol,
598 &num_groups, &user_gids);
600 if (!NT_STATUS_IS_OK(result))
603 for (i = 0; i < num_groups; i++) {
604 printf("\tgroup rid:[0x%x] attr:[0x%x]\n",
605 user_gids[i].g_rid, user_gids[i].attr);
608 rpccli_samr_close(cli, mem_ctx, &user_pol);
609 rpccli_samr_close(cli, mem_ctx, &domain_pol);
610 rpccli_samr_close(cli, mem_ctx, &connect_pol);
615 /* Query aliases a user is a member of */
617 static NTSTATUS cmd_samr_query_useraliases(struct rpc_pipe_client *cli,
619 int argc, const char **argv)
621 POLICY_HND connect_pol, domain_pol;
622 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
625 uint32 num_aliases, *alias_rids;
626 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
632 printf("Usage: %s builtin|domain sid1 sid2 ...\n", argv[0]);
633 return NT_STATUS_INVALID_PARAMETER;
639 for (i=2; i<argc; i++) {
641 if (!string_to_sid(&tmp_sid, argv[i])) {
642 printf("%s is not a legal SID\n", argv[i]);
643 return NT_STATUS_INVALID_PARAMETER;
645 add_sid_to_array(mem_ctx, &tmp_sid, &sids, &num_sids);
648 sid2 = TALLOC_ARRAY(mem_ctx, DOM_SID2, num_sids);
650 return NT_STATUS_NO_MEMORY;
652 for (i=0; i<num_sids; i++) {
653 sid_copy(&sid2[i].sid, &sids[i]);
654 sid2[i].num_auths = sid2[i].sid.num_auths;
657 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
660 result = try_samr_connects(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
663 if (!NT_STATUS_IS_OK(result))
666 if (StrCaseCmp(argv[1], "domain")==0)
667 result = rpccli_samr_open_domain(cli, mem_ctx, &connect_pol,
669 &domain_sid, &domain_pol);
670 else if (StrCaseCmp(argv[1], "builtin")==0)
671 result = rpccli_samr_open_domain(cli, mem_ctx, &connect_pol,
676 printf("Usage: %s builtin|domain sid1 sid2 ...\n", argv[0]);
677 return NT_STATUS_INVALID_PARAMETER;
680 if (!NT_STATUS_IS_OK(result))
683 result = rpccli_samr_query_useraliases(cli, mem_ctx, &domain_pol,
685 &num_aliases, &alias_rids);
687 if (!NT_STATUS_IS_OK(result))
690 for (i = 0; i < num_aliases; i++) {
691 printf("\tgroup rid:[0x%x]\n", alias_rids[i]);
694 rpccli_samr_close(cli, mem_ctx, &domain_pol);
695 rpccli_samr_close(cli, mem_ctx, &connect_pol);
700 /* Query members of a group */
702 static NTSTATUS cmd_samr_query_groupmem(struct rpc_pipe_client *cli,
704 int argc, const char **argv)
706 POLICY_HND connect_pol, domain_pol, group_pol;
707 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
708 uint32 num_members, *group_rids, *group_attrs, group_rid;
709 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
713 if ((argc < 2) || (argc > 3)) {
714 printf("Usage: %s rid [access mask]\n", argv[0]);
718 sscanf(argv[1], "%i", &group_rid);
721 sscanf(argv[2], "%x", &access_mask);
723 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
726 result = try_samr_connects(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
729 if (!NT_STATUS_IS_OK(result))
732 result = rpccli_samr_open_domain(cli, mem_ctx, &connect_pol,
733 MAXIMUM_ALLOWED_ACCESS,
734 &domain_sid, &domain_pol);
736 if (!NT_STATUS_IS_OK(result))
739 result = rpccli_samr_open_group(cli, mem_ctx, &domain_pol,
741 group_rid, &group_pol);
743 if (!NT_STATUS_IS_OK(result))
746 result = rpccli_samr_query_groupmem(cli, mem_ctx, &group_pol,
747 &num_members, &group_rids,
750 if (!NT_STATUS_IS_OK(result))
753 for (i = 0; i < num_members; i++) {
754 printf("\trid:[0x%x] attr:[0x%x]\n", group_rids[i],
758 rpccli_samr_close(cli, mem_ctx, &group_pol);
759 rpccli_samr_close(cli, mem_ctx, &domain_pol);
760 rpccli_samr_close(cli, mem_ctx, &connect_pol);
765 /* Enumerate domain users */
767 static NTSTATUS cmd_samr_enum_dom_users(struct rpc_pipe_client *cli,
769 int argc, const char **argv)
771 POLICY_HND connect_pol, domain_pol;
772 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
773 uint32 start_idx, size, num_dom_users, i;
776 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
777 uint16 acb_mask = ACB_NORMAL;
778 BOOL got_connect_pol = False, got_domain_pol = False;
780 if ((argc < 1) || (argc > 3)) {
781 printf("Usage: %s [access_mask] [acb_mask]\n", argv[0]);
786 sscanf(argv[1], "%x", &access_mask);
789 sscanf(argv[2], "%hx", &acb_mask);
791 /* Get sam policy handle */
793 result = try_samr_connects(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
796 if (!NT_STATUS_IS_OK(result))
799 got_connect_pol = True;
801 /* Get domain policy handle */
803 result = rpccli_samr_open_domain(cli, mem_ctx, &connect_pol,
805 &domain_sid, &domain_pol);
807 if (!NT_STATUS_IS_OK(result))
810 got_domain_pol = True;
812 /* Enumerate domain users */
818 result = rpccli_samr_enum_dom_users(
819 cli, mem_ctx, &domain_pol, &start_idx, acb_mask,
820 size, &dom_users, &dom_rids, &num_dom_users);
822 if (NT_STATUS_IS_OK(result) ||
823 NT_STATUS_V(result) == NT_STATUS_V(STATUS_MORE_ENTRIES)) {
825 for (i = 0; i < num_dom_users; i++)
826 printf("user:[%s] rid:[0x%x]\n",
827 dom_users[i], dom_rids[i]);
830 } while (NT_STATUS_V(result) == NT_STATUS_V(STATUS_MORE_ENTRIES));
834 rpccli_samr_close(cli, mem_ctx, &domain_pol);
837 rpccli_samr_close(cli, mem_ctx, &connect_pol);
842 /* Enumerate domain groups */
844 static NTSTATUS cmd_samr_enum_dom_groups(struct rpc_pipe_client *cli,
846 int argc, const char **argv)
848 POLICY_HND connect_pol, domain_pol;
849 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
850 uint32 start_idx, size, num_dom_groups, i;
851 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
852 struct acct_info *dom_groups;
853 BOOL got_connect_pol = False, got_domain_pol = False;
855 if ((argc < 1) || (argc > 2)) {
856 printf("Usage: %s [access_mask]\n", argv[0]);
861 sscanf(argv[1], "%x", &access_mask);
863 /* Get sam policy handle */
865 result = try_samr_connects(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
868 if (!NT_STATUS_IS_OK(result))
871 got_connect_pol = True;
873 /* Get domain policy handle */
875 result = rpccli_samr_open_domain(cli, mem_ctx, &connect_pol,
877 &domain_sid, &domain_pol);
879 if (!NT_STATUS_IS_OK(result))
882 got_domain_pol = True;
884 /* Enumerate domain groups */
890 result = rpccli_samr_enum_dom_groups(
891 cli, mem_ctx, &domain_pol, &start_idx, size,
892 &dom_groups, &num_dom_groups);
894 if (NT_STATUS_IS_OK(result) ||
895 NT_STATUS_V(result) == NT_STATUS_V(STATUS_MORE_ENTRIES)) {
897 for (i = 0; i < num_dom_groups; i++)
898 printf("group:[%s] rid:[0x%x]\n",
899 dom_groups[i].acct_name,
903 } while (NT_STATUS_V(result) == NT_STATUS_V(STATUS_MORE_ENTRIES));
907 rpccli_samr_close(cli, mem_ctx, &domain_pol);
910 rpccli_samr_close(cli, mem_ctx, &connect_pol);
915 /* Enumerate alias groups */
917 static NTSTATUS cmd_samr_enum_als_groups(struct rpc_pipe_client *cli,
919 int argc, const char **argv)
921 POLICY_HND connect_pol, domain_pol;
922 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
923 uint32 start_idx, size, num_als_groups, i;
924 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
925 struct acct_info *als_groups;
926 BOOL got_connect_pol = False, got_domain_pol = False;
928 if ((argc < 2) || (argc > 3)) {
929 printf("Usage: %s builtin|domain [access mask]\n", argv[0]);
934 sscanf(argv[2], "%x", &access_mask);
936 /* Get sam policy handle */
938 result = try_samr_connects(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
941 if (!NT_STATUS_IS_OK(result))
944 got_connect_pol = True;
946 /* Get domain policy handle */
948 if (StrCaseCmp(argv[1], "domain")==0)
949 result = rpccli_samr_open_domain(cli, mem_ctx, &connect_pol,
951 &domain_sid, &domain_pol);
952 else if (StrCaseCmp(argv[1], "builtin")==0)
953 result = rpccli_samr_open_domain(cli, mem_ctx, &connect_pol,
955 &global_sid_Builtin, &domain_pol);
959 if (!NT_STATUS_IS_OK(result))
962 got_domain_pol = True;
964 /* Enumerate alias groups */
967 size = 0xffff; /* Number of groups to retrieve */
970 result = rpccli_samr_enum_als_groups(
971 cli, mem_ctx, &domain_pol, &start_idx, size,
972 &als_groups, &num_als_groups);
974 if (NT_STATUS_IS_OK(result) ||
975 NT_STATUS_V(result) == NT_STATUS_V(STATUS_MORE_ENTRIES)) {
977 for (i = 0; i < num_als_groups; i++)
978 printf("group:[%s] rid:[0x%x]\n",
979 als_groups[i].acct_name,
982 } while (NT_STATUS_V(result) == NT_STATUS_V(STATUS_MORE_ENTRIES));
986 rpccli_samr_close(cli, mem_ctx, &domain_pol);
989 rpccli_samr_close(cli, mem_ctx, &connect_pol);
994 /* Query alias membership */
996 static NTSTATUS cmd_samr_query_aliasmem(struct rpc_pipe_client *cli,
998 int argc, const char **argv)
1000 POLICY_HND connect_pol, domain_pol, alias_pol;
1001 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1002 uint32 alias_rid, num_members, i;
1003 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
1004 DOM_SID *alias_sids;
1006 if ((argc < 3) || (argc > 4)) {
1007 printf("Usage: %s builtin|domain rid [access mask]\n", argv[0]);
1008 return NT_STATUS_OK;
1011 sscanf(argv[2], "%i", &alias_rid);
1014 sscanf(argv[3], "%x", &access_mask);
1016 /* Open SAMR handle */
1018 result = try_samr_connects(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
1021 if (!NT_STATUS_IS_OK(result))
1024 /* Open handle on domain */
1026 if (StrCaseCmp(argv[1], "domain")==0)
1027 result = rpccli_samr_open_domain(cli, mem_ctx, &connect_pol,
1028 MAXIMUM_ALLOWED_ACCESS,
1029 &domain_sid, &domain_pol);
1030 else if (StrCaseCmp(argv[1], "builtin")==0)
1031 result = rpccli_samr_open_domain(cli, mem_ctx, &connect_pol,
1032 MAXIMUM_ALLOWED_ACCESS,
1033 &global_sid_Builtin, &domain_pol);
1035 return NT_STATUS_OK;
1037 if (!NT_STATUS_IS_OK(result))
1040 /* Open handle on alias */
1042 result = rpccli_samr_open_alias(cli, mem_ctx, &domain_pol,
1044 alias_rid, &alias_pol);
1045 if (!NT_STATUS_IS_OK(result))
1048 result = rpccli_samr_query_aliasmem(cli, mem_ctx, &alias_pol,
1049 &num_members, &alias_sids);
1051 if (!NT_STATUS_IS_OK(result))
1054 for (i = 0; i < num_members; i++) {
1057 sid_to_string(sid_str, &alias_sids[i]);
1058 printf("\tsid:[%s]\n", sid_str);
1061 rpccli_samr_close(cli, mem_ctx, &alias_pol);
1062 rpccli_samr_close(cli, mem_ctx, &domain_pol);
1063 rpccli_samr_close(cli, mem_ctx, &connect_pol);
1068 /* Query display info */
1070 static NTSTATUS cmd_samr_query_dispinfo(struct rpc_pipe_client *cli,
1071 TALLOC_CTX *mem_ctx,
1072 int argc, const char **argv)
1074 POLICY_HND connect_pol, domain_pol;
1075 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1076 uint32 start_idx=0, max_entries=250, max_size = 0xffff, num_entries, i;
1077 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
1078 uint32 info_level = 1;
1079 SAM_DISPINFO_CTR ctr;
1080 SAM_DISPINFO_1 info1;
1081 SAM_DISPINFO_2 info2;
1082 SAM_DISPINFO_3 info3;
1083 SAM_DISPINFO_4 info4;
1084 SAM_DISPINFO_5 info5;
1086 BOOL got_params = False; /* Use get_query_dispinfo_params() or not? */
1089 printf("Usage: %s [info level] [start index] [max entries] [max size] [access mask]\n", argv[0]);
1090 return NT_STATUS_OK;
1094 sscanf(argv[1], "%i", &info_level);
1097 sscanf(argv[2], "%i", &start_idx);
1100 sscanf(argv[3], "%i", &max_entries);
1105 sscanf(argv[4], "%i", &max_size);
1110 sscanf(argv[5], "%x", &access_mask);
1112 /* Get sam policy handle */
1114 result = try_samr_connects(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
1117 if (!NT_STATUS_IS_OK(result))
1120 /* Get domain policy handle */
1122 result = rpccli_samr_open_domain(cli, mem_ctx, &connect_pol,
1124 &domain_sid, &domain_pol);
1126 if (!NT_STATUS_IS_OK(result))
1129 /* Query display info */
1134 switch (info_level) {
1137 ctr.sam.info1 = &info1;
1141 ctr.sam.info2 = &info2;
1145 ctr.sam.info3 = &info3;
1149 ctr.sam.info4 = &info4;
1153 ctr.sam.info5 = &info5;
1161 get_query_dispinfo_params(
1162 loop_count, &max_entries, &max_size);
1164 result = rpccli_samr_query_dispinfo(cli, mem_ctx, &domain_pol,
1165 &start_idx, info_level,
1166 &num_entries, max_entries,
1171 if (NT_STATUS_IS_ERR(result))
1174 if (num_entries == 0)
1177 for (i = 0; i < num_entries; i++) {
1178 switch (info_level) {
1180 display_sam_info_1(&ctr.sam.info1->sam[i], &ctr.sam.info1->str[i]);
1183 display_sam_info_2(&ctr.sam.info2->sam[i], &ctr.sam.info2->str[i]);
1186 display_sam_info_3(&ctr.sam.info3->sam[i], &ctr.sam.info3->str[i]);
1189 display_sam_info_4(&ctr.sam.info4->sam[i], &ctr.sam.info4->str[i]);
1192 display_sam_info_5(&ctr.sam.info5->sam[i], &ctr.sam.info5->str[i]);
1196 } while ( NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES));
1198 rpccli_samr_close(cli, mem_ctx, &domain_pol);
1199 rpccli_samr_close(cli, mem_ctx, &connect_pol);
1204 /* Query domain info */
1206 static NTSTATUS cmd_samr_query_dominfo(struct rpc_pipe_client *cli,
1207 TALLOC_CTX *mem_ctx,
1208 int argc, const char **argv)
1210 POLICY_HND connect_pol, domain_pol;
1211 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1212 uint32 switch_level = 2;
1213 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
1217 printf("Usage: %s [info level] [access mask]\n", argv[0]);
1218 return NT_STATUS_OK;
1222 sscanf(argv[1], "%i", &switch_level);
1225 sscanf(argv[2], "%x", &access_mask);
1227 /* Get sam policy handle */
1229 result = try_samr_connects(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
1232 if (!NT_STATUS_IS_OK(result))
1235 /* Get domain policy handle */
1237 result = rpccli_samr_open_domain(cli, mem_ctx, &connect_pol,
1239 &domain_sid, &domain_pol);
1241 if (!NT_STATUS_IS_OK(result))
1244 /* Query domain info */
1246 result = rpccli_samr_query_dom_info(cli, mem_ctx, &domain_pol,
1247 switch_level, &ctr);
1249 if (!NT_STATUS_IS_OK(result))
1252 /* Display domain info */
1254 switch (switch_level) {
1256 display_sam_unk_info_1(&ctr.info.inf1);
1259 display_sam_unk_info_2(&ctr.info.inf2);
1262 display_sam_unk_info_7(&ctr.info.inf7);
1265 display_sam_unk_info_8(&ctr.info.inf8);
1268 display_sam_unk_info_12(&ctr.info.inf12);
1271 printf("cannot display domain info for switch value %d\n",
1278 rpccli_samr_close(cli, mem_ctx, &domain_pol);
1279 rpccli_samr_close(cli, mem_ctx, &connect_pol);
1283 /* Create domain user */
1285 static NTSTATUS cmd_samr_create_dom_user(struct rpc_pipe_client *cli,
1286 TALLOC_CTX *mem_ctx,
1287 int argc, const char **argv)
1289 POLICY_HND connect_pol, domain_pol, user_pol;
1290 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1291 const char *acct_name;
1293 uint32 unknown, user_rid;
1294 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
1296 if ((argc < 2) || (argc > 3)) {
1297 printf("Usage: %s username [access mask]\n", argv[0]);
1298 return NT_STATUS_OK;
1301 acct_name = argv[1];
1304 sscanf(argv[2], "%x", &access_mask);
1306 /* Get sam policy handle */
1308 result = try_samr_connects(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
1311 if (!NT_STATUS_IS_OK(result))
1314 /* Get domain policy handle */
1316 result = rpccli_samr_open_domain(cli, mem_ctx, &connect_pol,
1318 &domain_sid, &domain_pol);
1320 if (!NT_STATUS_IS_OK(result))
1323 /* Create domain user */
1325 acb_info = ACB_NORMAL;
1326 unknown = 0xe005000b; /* No idea what this is - a permission mask? */
1328 result = rpccli_samr_create_dom_user(cli, mem_ctx, &domain_pol,
1329 acct_name, acb_info, unknown,
1330 &user_pol, &user_rid);
1332 if (!NT_STATUS_IS_OK(result))
1335 result = rpccli_samr_close(cli, mem_ctx, &user_pol);
1336 if (!NT_STATUS_IS_OK(result)) goto done;
1338 result = rpccli_samr_close(cli, mem_ctx, &domain_pol);
1339 if (!NT_STATUS_IS_OK(result)) goto done;
1341 result = rpccli_samr_close(cli, mem_ctx, &connect_pol);
1342 if (!NT_STATUS_IS_OK(result)) goto done;
1348 /* Create domain group */
1350 static NTSTATUS cmd_samr_create_dom_group(struct rpc_pipe_client *cli,
1351 TALLOC_CTX *mem_ctx,
1352 int argc, const char **argv)
1354 POLICY_HND connect_pol, domain_pol, group_pol;
1355 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1356 const char *grp_name;
1357 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
1359 if ((argc < 2) || (argc > 3)) {
1360 printf("Usage: %s groupname [access mask]\n", argv[0]);
1361 return NT_STATUS_OK;
1367 sscanf(argv[2], "%x", &access_mask);
1369 /* Get sam policy handle */
1371 result = try_samr_connects(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
1374 if (!NT_STATUS_IS_OK(result))
1377 /* Get domain policy handle */
1379 result = rpccli_samr_open_domain(cli, mem_ctx, &connect_pol,
1381 &domain_sid, &domain_pol);
1383 if (!NT_STATUS_IS_OK(result))
1386 /* Create domain user */
1388 result = rpccli_samr_create_dom_group(cli, mem_ctx, &domain_pol,
1389 grp_name, MAXIMUM_ALLOWED_ACCESS,
1392 if (!NT_STATUS_IS_OK(result))
1395 result = rpccli_samr_close(cli, mem_ctx, &group_pol);
1396 if (!NT_STATUS_IS_OK(result)) goto done;
1398 result = rpccli_samr_close(cli, mem_ctx, &domain_pol);
1399 if (!NT_STATUS_IS_OK(result)) goto done;
1401 result = rpccli_samr_close(cli, mem_ctx, &connect_pol);
1402 if (!NT_STATUS_IS_OK(result)) goto done;
1408 /* Lookup sam names */
1410 static NTSTATUS cmd_samr_lookup_names(struct rpc_pipe_client *cli,
1411 TALLOC_CTX *mem_ctx,
1412 int argc, const char **argv)
1414 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1415 POLICY_HND connect_pol, domain_pol;
1416 uint32 flags = 0x000003e8; /* Unknown */
1417 uint32 num_rids, num_names, *name_types, *rids;
1422 printf("Usage: %s domain|builtin name1 [name2 [name3] [...]]\n", argv[0]);
1423 printf("check on the domain SID: S-1-5-21-x-y-z\n");
1424 printf("or check on the builtin SID: S-1-5-32\n");
1425 return NT_STATUS_OK;
1428 /* Get sam policy and domain handles */
1430 result = try_samr_connects(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
1433 if (!NT_STATUS_IS_OK(result))
1436 if (StrCaseCmp(argv[1], "domain")==0)
1437 result = rpccli_samr_open_domain(cli, mem_ctx, &connect_pol,
1438 MAXIMUM_ALLOWED_ACCESS,
1439 &domain_sid, &domain_pol);
1440 else if (StrCaseCmp(argv[1], "builtin")==0)
1441 result = rpccli_samr_open_domain(cli, mem_ctx, &connect_pol,
1442 MAXIMUM_ALLOWED_ACCESS,
1443 &global_sid_Builtin, &domain_pol);
1445 return NT_STATUS_OK;
1447 if (!NT_STATUS_IS_OK(result))
1452 num_names = argc - 2;
1453 names = TALLOC_ARRAY(mem_ctx, const char *, num_names);
1455 for (i = 0; i < argc - 2; i++)
1456 names[i] = argv[i + 2];
1458 result = rpccli_samr_lookup_names(cli, mem_ctx, &domain_pol,
1459 flags, num_names, names,
1460 &num_rids, &rids, &name_types);
1462 if (!NT_STATUS_IS_OK(result))
1465 /* Display results */
1467 for (i = 0; i < num_names; i++)
1468 printf("name %s: 0x%x (%d)\n", names[i], rids[i],
1471 rpccli_samr_close(cli, mem_ctx, &domain_pol);
1472 rpccli_samr_close(cli, mem_ctx, &connect_pol);
1477 /* Lookup sam rids */
1479 static NTSTATUS cmd_samr_lookup_rids(struct rpc_pipe_client *cli,
1480 TALLOC_CTX *mem_ctx,
1481 int argc, const char **argv)
1483 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1484 POLICY_HND connect_pol, domain_pol;
1485 uint32 num_rids, num_names, *rids, *name_types;
1490 printf("Usage: %s domain|builtin rid1 [rid2 [rid3] [...]]\n", argv[0]);
1491 return NT_STATUS_OK;
1494 /* Get sam policy and domain handles */
1496 result = try_samr_connects(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
1499 if (!NT_STATUS_IS_OK(result))
1502 if (StrCaseCmp(argv[1], "domain")==0)
1503 result = rpccli_samr_open_domain(cli, mem_ctx, &connect_pol,
1504 MAXIMUM_ALLOWED_ACCESS,
1505 &domain_sid, &domain_pol);
1506 else if (StrCaseCmp(argv[1], "builtin")==0)
1507 result = rpccli_samr_open_domain(cli, mem_ctx, &connect_pol,
1508 MAXIMUM_ALLOWED_ACCESS,
1509 &global_sid_Builtin, &domain_pol);
1511 return NT_STATUS_OK;
1513 if (!NT_STATUS_IS_OK(result))
1518 num_rids = argc - 2;
1519 rids = TALLOC_ARRAY(mem_ctx, uint32, num_rids);
1521 for (i = 0; i < argc - 2; i++)
1522 sscanf(argv[i + 2], "%i", &rids[i]);
1524 result = rpccli_samr_lookup_rids(cli, mem_ctx, &domain_pol, num_rids, rids,
1525 &num_names, &names, &name_types);
1527 if (!NT_STATUS_IS_OK(result) &&
1528 !NT_STATUS_EQUAL(result, STATUS_SOME_UNMAPPED))
1531 /* Display results */
1533 for (i = 0; i < num_names; i++)
1534 printf("rid 0x%x: %s (%d)\n", rids[i], names[i], name_types[i]);
1536 rpccli_samr_close(cli, mem_ctx, &domain_pol);
1537 rpccli_samr_close(cli, mem_ctx, &connect_pol);
1542 /* Delete domain user */
1544 static NTSTATUS cmd_samr_delete_dom_user(struct rpc_pipe_client *cli,
1545 TALLOC_CTX *mem_ctx,
1546 int argc, const char **argv)
1548 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1549 POLICY_HND connect_pol, domain_pol, user_pol;
1550 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
1552 if ((argc < 2) || (argc > 3)) {
1553 printf("Usage: %s username\n", argv[0]);
1554 return NT_STATUS_OK;
1558 sscanf(argv[2], "%x", &access_mask);
1560 /* Get sam policy and domain handles */
1562 result = try_samr_connects(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
1565 if (!NT_STATUS_IS_OK(result))
1568 result = rpccli_samr_open_domain(cli, mem_ctx, &connect_pol,
1569 MAXIMUM_ALLOWED_ACCESS,
1570 &domain_sid, &domain_pol);
1572 if (!NT_STATUS_IS_OK(result))
1575 /* Get handle on user */
1578 uint32 *user_rids, num_rids, *name_types;
1579 uint32 flags = 0x000003e8; /* Unknown */
1581 result = rpccli_samr_lookup_names(cli, mem_ctx, &domain_pol,
1582 flags, 1, (const char **)&argv[1],
1583 &num_rids, &user_rids,
1586 if (!NT_STATUS_IS_OK(result))
1589 result = rpccli_samr_open_user(cli, mem_ctx, &domain_pol,
1591 user_rids[0], &user_pol);
1593 if (!NT_STATUS_IS_OK(result))
1599 result = rpccli_samr_delete_dom_user(cli, mem_ctx, &user_pol);
1601 if (!NT_STATUS_IS_OK(result))
1604 /* Display results */
1606 rpccli_samr_close(cli, mem_ctx, &user_pol);
1607 rpccli_samr_close(cli, mem_ctx, &domain_pol);
1608 rpccli_samr_close(cli, mem_ctx, &connect_pol);
1614 /**********************************************************************
1615 * Query user security object
1617 static NTSTATUS cmd_samr_query_sec_obj(struct rpc_pipe_client *cli,
1618 TALLOC_CTX *mem_ctx,
1619 int argc, const char **argv)
1621 POLICY_HND connect_pol, domain_pol, user_pol, *pol;
1622 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1623 uint32 info_level = 4;
1625 uint32 user_rid = 0;
1626 TALLOC_CTX *ctx = NULL;
1627 SEC_DESC_BUF *sec_desc_buf=NULL;
1628 BOOL domain = False;
1630 ctx=talloc_init("cmd_samr_query_sec_obj");
1632 if ((argc < 1) || (argc > 2)) {
1633 printf("Usage: %s [rid|-d]\n", argv[0]);
1634 printf("\tSpecify rid for security on user, -d for security on domain\n");
1635 return NT_STATUS_OK;
1639 if (strcmp(argv[1], "-d") == 0)
1642 sscanf(argv[1], "%i", &user_rid);
1645 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
1647 result = try_samr_connects(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
1650 if (!NT_STATUS_IS_OK(result))
1653 if (domain || user_rid)
1654 result = rpccli_samr_open_domain(cli, mem_ctx, &connect_pol,
1655 MAXIMUM_ALLOWED_ACCESS,
1656 &domain_sid, &domain_pol);
1658 if (!NT_STATUS_IS_OK(result))
1662 result = rpccli_samr_open_user(cli, mem_ctx, &domain_pol,
1663 MAXIMUM_ALLOWED_ACCESS,
1664 user_rid, &user_pol);
1666 if (!NT_STATUS_IS_OK(result))
1669 /* Pick which query pol to use */
1679 /* Query SAM security object */
1681 result = rpccli_samr_query_sec_obj(cli, mem_ctx, pol, info_level, ctx,
1684 if (!NT_STATUS_IS_OK(result))
1687 display_sec_desc(sec_desc_buf->sec);
1689 rpccli_samr_close(cli, mem_ctx, &user_pol);
1690 rpccli_samr_close(cli, mem_ctx, &domain_pol);
1691 rpccli_samr_close(cli, mem_ctx, &connect_pol);
1693 talloc_destroy(ctx);
1697 static NTSTATUS cmd_samr_get_dom_pwinfo(struct rpc_pipe_client *cli,
1698 TALLOC_CTX *mem_ctx,
1699 int argc, const char **argv)
1701 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1702 uint16 min_pwd_length;
1703 uint32 password_properties;
1706 printf("Usage: %s\n", argv[0]);
1707 return NT_STATUS_OK;
1710 result = rpccli_samr_get_dom_pwinfo(cli, mem_ctx, &min_pwd_length, &password_properties) ;
1712 if (NT_STATUS_IS_OK(result)) {
1713 printf("min_pwd_length: %d\n", min_pwd_length);
1714 printf("password_properties: 0x%08x\n", password_properties);
1716 if (password_properties & DOMAIN_PASSWORD_COMPLEX)
1717 printf("\tDOMAIN_PASSWORD_COMPLEX\n");
1719 if (password_properties & DOMAIN_PASSWORD_NO_ANON_CHANGE)
1720 printf("\tDOMAIN_PASSWORD_NO_ANON_CHANGE\n");
1722 if (password_properties & DOMAIN_PASSWORD_NO_CLEAR_CHANGE)
1723 printf("\tDOMAIN_PASSWORD_NO_CLEAR_CHANGE\n");
1725 if (password_properties & DOMAIN_LOCKOUT_ADMINS)
1726 printf("\tDOMAIN_LOCKOUT_ADMINS\n");
1728 if (password_properties & DOMAIN_PASSWORD_STORE_CLEARTEXT)
1729 printf("\tDOMAIN_PASSWORD_STORE_CLEARTEXT\n");
1731 if (password_properties & DOMAIN_REFUSE_PASSWORD_CHANGE)
1732 printf("\tDOMAIN_REFUSE_PASSWORD_CHANGE\n");
1738 /* Look up domain name */
1740 static NTSTATUS cmd_samr_lookup_domain(struct rpc_pipe_client *cli,
1741 TALLOC_CTX *mem_ctx,
1742 int argc, const char **argv)
1744 POLICY_HND connect_pol, domain_pol;
1745 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1746 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
1747 fstring domain_name,sid_string;
1751 printf("Usage: %s domain_name\n", argv[0]);
1752 return NT_STATUS_OK;
1755 sscanf(argv[1], "%s", domain_name);
1757 result = try_samr_connects(cli, mem_ctx, access_mask, &connect_pol);
1759 if (!NT_STATUS_IS_OK(result))
1762 result = rpccli_samr_open_domain(cli, mem_ctx, &connect_pol,
1763 access_mask, &domain_sid, &domain_pol);
1765 if (!NT_STATUS_IS_OK(result))
1768 result = rpccli_samr_lookup_domain(
1769 cli, mem_ctx, &connect_pol, domain_name, &sid);
1771 sid_to_string(sid_string,&sid);
1773 if (NT_STATUS_IS_OK(result))
1774 printf("SAMR_LOOKUP_DOMAIN: Domain Name: %s Domain SID: %s\n",
1775 domain_name,sid_string);
1777 rpccli_samr_close(cli, mem_ctx, &domain_pol);
1778 rpccli_samr_close(cli, mem_ctx, &connect_pol);
1784 /* List of commands exported by this module */
1786 struct cmd_set samr_commands[] = {
1790 { "queryuser", RPC_RTYPE_NTSTATUS, cmd_samr_query_user, NULL, PI_SAMR, NULL, "Query user info", "" },
1791 { "querygroup", RPC_RTYPE_NTSTATUS, cmd_samr_query_group, NULL, PI_SAMR, NULL, "Query group info", "" },
1792 { "queryusergroups", RPC_RTYPE_NTSTATUS, cmd_samr_query_usergroups, NULL, PI_SAMR, NULL, "Query user groups", "" },
1793 { "queryuseraliases", RPC_RTYPE_NTSTATUS, cmd_samr_query_useraliases, NULL, PI_SAMR, NULL, "Query user aliases", "" },
1794 { "querygroupmem", RPC_RTYPE_NTSTATUS, cmd_samr_query_groupmem, NULL, PI_SAMR, NULL, "Query group membership", "" },
1795 { "queryaliasmem", RPC_RTYPE_NTSTATUS, cmd_samr_query_aliasmem, NULL, PI_SAMR, NULL, "Query alias membership", "" },
1796 { "querydispinfo", RPC_RTYPE_NTSTATUS, cmd_samr_query_dispinfo, NULL, PI_SAMR, NULL, "Query display info", "" },
1797 { "querydominfo", RPC_RTYPE_NTSTATUS, cmd_samr_query_dominfo, NULL, PI_SAMR, NULL, "Query domain info", "" },
1798 { "enumdomusers", RPC_RTYPE_NTSTATUS, cmd_samr_enum_dom_users, NULL, PI_SAMR, NULL, "Enumerate domain users", "" },
1799 { "enumdomgroups", RPC_RTYPE_NTSTATUS, cmd_samr_enum_dom_groups, NULL, PI_SAMR, NULL, "Enumerate domain groups", "" },
1800 { "enumalsgroups", RPC_RTYPE_NTSTATUS, cmd_samr_enum_als_groups, NULL, PI_SAMR, NULL, "Enumerate alias groups", "" },
1802 { "createdomuser", RPC_RTYPE_NTSTATUS, cmd_samr_create_dom_user, NULL, PI_SAMR, NULL, "Create domain user", "" },
1803 { "createdomgroup", RPC_RTYPE_NTSTATUS, cmd_samr_create_dom_group, NULL, PI_SAMR, NULL, "Create domain group", "" },
1804 { "samlookupnames", RPC_RTYPE_NTSTATUS, cmd_samr_lookup_names, NULL, PI_SAMR, NULL, "Look up names", "" },
1805 { "samlookuprids", RPC_RTYPE_NTSTATUS, cmd_samr_lookup_rids, NULL, PI_SAMR, NULL, "Look up names", "" },
1806 { "deletedomuser", RPC_RTYPE_NTSTATUS, cmd_samr_delete_dom_user, NULL, PI_SAMR, NULL, "Delete domain user", "" },
1807 { "samquerysecobj", RPC_RTYPE_NTSTATUS, cmd_samr_query_sec_obj, NULL, PI_SAMR, NULL, "Query SAMR security object", "" },
1808 { "getdompwinfo", RPC_RTYPE_NTSTATUS, cmd_samr_get_dom_pwinfo, NULL, PI_SAMR, NULL, "Retrieve domain password info", "" },
1810 { "lookupdomain", RPC_RTYPE_NTSTATUS, cmd_samr_lookup_domain, NULL, PI_SAMR, NULL, "Lookup Domain Name", "" },