source3/rpcclient/cmd_samr.c

   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    Copyright (C) Guenther Deschner                 2008
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 3 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  23 */
  24
  25 #include "includes.h"
  26 #include "rpcclient.h"
  27 #include "../libcli/auth/libcli_auth.h"
  28 #include "../librpc/gen_ndr/ndr_samr.h"
  29 #include "../librpc/gen_ndr/cli_samr.h"
  30 #include "rpc_client/cli_samr.h"
  31 #include "rpc_client/init_samr.h"
  32 #include "rpc_client/init_lsa.h"
  33
  34 extern struct dom_sid domain_sid;
  35
  36 /****************************************************************************
  37  display samr_user_info_7 structure
  38  ****************************************************************************/
  39 static void display_samr_user_info_7(struct samr_UserInfo7 *r)
  40 {
  41         printf("\tUser Name   :\t%s\n", r->account_name.string);
  42 }
  43
  44 /****************************************************************************
  45  display samr_user_info_9 structure
  46  ****************************************************************************/
  47 static void display_samr_user_info_9(struct samr_UserInfo9 *r)
  48 {
  49         printf("\tPrimary group RID   :\tox%x\n", r->primary_gid);
  50 }
  51
  52 /****************************************************************************
  53  display samr_user_info_16 structure
  54  ****************************************************************************/
  55 static void display_samr_user_info_16(struct samr_UserInfo16 *r)
  56 {
  57         printf("\tAcct Flags   :\tox%x\n", r->acct_flags);
  58 }
  59
  60 /****************************************************************************
  61  display samr_user_info_20 structure
  62  ****************************************************************************/
  63 static void display_samr_user_info_20(struct samr_UserInfo20 *r)
  64 {
  65         printf("\tRemote Dial :\n");
  66         dump_data(0, (uint8_t *)r->parameters.array, r->parameters.length*2);
  67 }
  68
  69
  70 /****************************************************************************
  71  display samr_user_info_21 structure
  72  ****************************************************************************/
  73 static void display_samr_user_info_21(struct samr_UserInfo21 *r)
  74 {
  75         printf("\tUser Name   :\t%s\n", r->account_name.string);
  76         printf("\tFull Name   :\t%s\n", r->full_name.string);
  77         printf("\tHome Drive  :\t%s\n", r->home_directory.string);
  78         printf("\tDir Drive   :\t%s\n", r->home_drive.string);
  79         printf("\tProfile Path:\t%s\n", r->profile_path.string);
  80         printf("\tLogon Script:\t%s\n", r->logon_script.string);
  81         printf("\tDescription :\t%s\n", r->description.string);
  82         printf("\tWorkstations:\t%s\n", r->workstations.string);
  83         printf("\tComment     :\t%s\n", r->comment.string);
  84         printf("\tRemote Dial :\n");
  85         dump_data(0, (uint8_t *)r->parameters.array, r->parameters.length*2);
  86
  87         printf("\tLogon Time               :\t%s\n",
  88                http_timestring(talloc_tos(), nt_time_to_unix(r->last_logon)));
  89         printf("\tLogoff Time              :\t%s\n",
  90                http_timestring(talloc_tos(), nt_time_to_unix(r->last_logoff)));
  91         printf("\tKickoff Time             :\t%s\n",
  92                http_timestring(talloc_tos(), nt_time_to_unix(r->acct_expiry)));
  93         printf("\tPassword last set Time   :\t%s\n",
  94                http_timestring(talloc_tos(), nt_time_to_unix(r->last_password_change)));
  95         printf("\tPassword can change Time :\t%s\n",
  96                http_timestring(talloc_tos(), nt_time_to_unix(r->allow_password_change)));
  97         printf("\tPassword must change Time:\t%s\n",
  98                http_timestring(talloc_tos(), nt_time_to_unix(r->force_password_change)));
  99
 100         printf("\tunknown_2[0..31]...\n"); /* user passwords? */
 101
 102         printf("\tuser_rid :\t0x%x\n"  , r->rid); /* User ID */
 103         printf("\tgroup_rid:\t0x%x\n"  , r->primary_gid); /* Group ID */
 104         printf("\tacb_info :\t0x%08x\n", r->acct_flags); /* Account Control Info */
 105
 106         printf("\tfields_present:\t0x%08x\n", r->fields_present); /* 0x00ff ffff */
 107         printf("\tlogon_divs:\t%d\n", r->logon_hours.units_per_week); /* 0x0000 00a8 which is 168 which is num hrs in a week */
 108         printf("\tbad_password_count:\t0x%08x\n", r->bad_password_count);
 109         printf("\tlogon_count:\t0x%08x\n", r->logon_count);
 110
 111         printf("\tpadding1[0..7]...\n");
 112
 113         if (r->logon_hours.bits) {
 114                 printf("\tlogon_hrs[0..%d]...\n", r->logon_hours.units_per_week/8);
 115         }
 116 }
 117
 118
 119 static void display_password_properties(uint32_t password_properties)
 120 {
 121         printf("password_properties: 0x%08x\n", password_properties);
 122
 123         if (password_properties & DOMAIN_PASSWORD_COMPLEX)
 124                 printf("\tDOMAIN_PASSWORD_COMPLEX\n");
 125
 126         if (password_properties & DOMAIN_PASSWORD_NO_ANON_CHANGE)
 127                 printf("\tDOMAIN_PASSWORD_NO_ANON_CHANGE\n");
 128
 129         if (password_properties & DOMAIN_PASSWORD_NO_CLEAR_CHANGE)
 130                 printf("\tDOMAIN_PASSWORD_NO_CLEAR_CHANGE\n");
 131
 132         if (password_properties & DOMAIN_PASSWORD_LOCKOUT_ADMINS)
 133                 printf("\tDOMAIN_PASSWORD_LOCKOUT_ADMINS\n");
 134
 135         if (password_properties & DOMAIN_PASSWORD_STORE_CLEARTEXT)
 136                 printf("\tDOMAIN_PASSWORD_STORE_CLEARTEXT\n");
 137
 138         if (password_properties & DOMAIN_REFUSE_PASSWORD_CHANGE)
 139                 printf("\tDOMAIN_REFUSE_PASSWORD_CHANGE\n");
 140 }
 141
 142 static void display_sam_dom_info_1(struct samr_DomInfo1 *info1)
 143 {
 144         printf("Minimum password length:\t\t\t%d\n",
 145                 info1->min_password_length);
 146         printf("Password uniqueness (remember x passwords):\t%d\n",
 147                 info1->password_history_length);
 148         display_password_properties(info1->password_properties);
 149         printf("password expire in:\t\t\t\t%s\n",
 150                 display_time(info1->max_password_age));
 151         printf("Min password age (allow changing in x days):\t%s\n",
 152                 display_time(info1->min_password_age));
 153 }
 154
 155 static void display_sam_dom_info_2(struct samr_DomGeneralInformation *general)
 156 {
 157         printf("Domain:\t\t%s\n", general->domain_name.string);
 158         printf("Server:\t\t%s\n", general->primary.string);
 159         printf("Comment:\t%s\n", general->oem_information.string);
 160
 161         printf("Total Users:\t%d\n", general->num_users);
 162         printf("Total Groups:\t%d\n", general->num_groups);
 163         printf("Total Aliases:\t%d\n", general->num_aliases);
 164
 165         printf("Sequence No:\t%llu\n", (unsigned long long)general->sequence_num);
 166
 167         printf("Force Logoff:\t%d\n",
 168                 (int)nt_time_to_unix_abs(&general->force_logoff_time));
 169
 170         printf("Domain Server State:\t0x%x\n", general->domain_server_state);
 171         printf("Server Role:\t%s\n", server_role_str(general->role));
 172         printf("Unknown 3:\t0x%x\n", general->unknown3);
 173 }
 174
 175 static void display_sam_dom_info_3(struct samr_DomInfo3 *info3)
 176 {
 177         printf("Force Logoff:\t%d\n",
 178                 (int)nt_time_to_unix_abs(&info3->force_logoff_time));
 179 }
 180
 181 static void display_sam_dom_info_4(struct samr_DomOEMInformation *oem)
 182 {
 183         printf("Comment:\t%s\n", oem->oem_information.string);
 184 }
 185
 186 static void display_sam_dom_info_5(struct samr_DomInfo5 *info5)
 187 {
 188         printf("Domain:\t\t%s\n", info5->domain_name.string);
 189 }
 190
 191 static void display_sam_dom_info_6(struct samr_DomInfo6 *info6)
 192 {
 193         printf("Server:\t\t%s\n", info6->primary.string);
 194 }
 195
 196 static void display_sam_dom_info_7(struct samr_DomInfo7 *info7)
 197 {
 198         printf("Server Role:\t%s\n", server_role_str(info7->role));
 199 }
 200
 201 static void display_sam_dom_info_8(struct samr_DomInfo8 *info8)
 202 {
 203         printf("Sequence No:\t%llu\n", (unsigned long long)info8->sequence_num);
 204         printf("Domain Create Time:\t%s\n",
 205                 http_timestring(talloc_tos(), nt_time_to_unix(info8->domain_create_time)));
 206 }
 207
 208 static void display_sam_dom_info_9(struct samr_DomInfo9 *info9)
 209 {
 210         printf("Domain Server State:\t0x%x\n", info9->domain_server_state);
 211 }
 212
 213 static void display_sam_dom_info_12(struct samr_DomInfo12 *info12)
 214 {
 215         printf("Bad password lockout duration:               %s\n",
 216                 display_time(info12->lockout_duration));
 217         printf("Reset Lockout after:                         %s\n",
 218                 display_time(info12->lockout_window));
 219         printf("Lockout after bad attempts:                  %d\n",
 220                 info12->lockout_threshold);
 221 }
 222
 223 static void display_sam_dom_info_13(struct samr_DomInfo13 *info13)
 224 {
 225         printf("Sequence No:\t%llu\n", (unsigned long long)info13->sequence_num);
 226         printf("Domain Create Time:\t%s\n",
 227                 http_timestring(talloc_tos(), nt_time_to_unix(info13->domain_create_time)));
 228         printf("Sequence No at last promotion:\t%llu\n",
 229                 (unsigned long long)info13->modified_count_at_last_promotion);
 230 }
 231
 232 static void display_sam_info_1(struct samr_DispEntryGeneral *r)
 233 {
 234         printf("index: 0x%x ", r->idx);
 235         printf("RID: 0x%x ", r->rid);
 236         printf("acb: 0x%08x ", r->acct_flags);
 237         printf("Account: %s\t", r->account_name.string);
 238         printf("Name: %s\t", r->full_name.string);
 239         printf("Desc: %s\n", r->description.string);
 240 }
 241
 242 static void display_sam_info_2(struct samr_DispEntryFull *r)
 243 {
 244         printf("index: 0x%x ", r->idx);
 245         printf("RID: 0x%x ", r->rid);
 246         printf("acb: 0x%08x ", r->acct_flags);
 247         printf("Account: %s\t", r->account_name.string);
 248         printf("Desc: %s\n", r->description.string);
 249 }
 250
 251 static void display_sam_info_3(struct samr_DispEntryFullGroup *r)
 252 {
 253         printf("index: 0x%x ", r->idx);
 254         printf("RID: 0x%x ", r->rid);
 255         printf("acb: 0x%08x ", r->acct_flags);
 256         printf("Account: %s\t", r->account_name.string);
 257         printf("Desc: %s\n", r->description.string);
 258 }
 259
 260 static void display_sam_info_4(struct samr_DispEntryAscii *r)
 261 {
 262         printf("index: 0x%x ", r->idx);
 263         printf("Account: %s\n", r->account_name.string);
 264 }
 265
 266 static void display_sam_info_5(struct samr_DispEntryAscii *r)
 267 {
 268         printf("index: 0x%x ", r->idx);
 269         printf("Account: %s\n", r->account_name.string);
 270 }
 271
 272 /****************************************************************************
 273  ****************************************************************************/
 274
 275 static NTSTATUS get_domain_handle(struct rpc_pipe_client *cli,
 276                                   TALLOC_CTX *mem_ctx,
 277                                   const char *sam,
 278                                   struct policy_handle *connect_pol,
 279                                   uint32_t access_mask,
 280                                   struct dom_sid *_domain_sid,
 281                                   struct policy_handle *domain_pol)
 282 {
 283
 284         if (StrCaseCmp(sam, "domain") == 0) {
 285                 return rpccli_samr_OpenDomain(cli, mem_ctx,
 286                                               connect_pol,
 287                                               access_mask,
 288                                               _domain_sid,
 289                                               domain_pol);
 290         } else if (StrCaseCmp(sam, "builtin") == 0) {
 291                 return rpccli_samr_OpenDomain(cli, mem_ctx,
 292                                               connect_pol,
 293                                               access_mask,
 294                                               CONST_DISCARD(struct dom_sid2 *, &global_sid_Builtin),
 295                                               domain_pol);
 296         }
 297
 298         return NT_STATUS_INVALID_PARAMETER;
 299 }
 300
 301 /**********************************************************************
 302  * Query user information
 303  */
 304 static NTSTATUS cmd_samr_query_user(struct rpc_pipe_client *cli,
 305                                     TALLOC_CTX *mem_ctx,
 306                                     int argc, const char **argv)
 307 {
 308         struct policy_handle connect_pol, domain_pol, user_pol;
 309         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 310         uint32 info_level = 21;
 311         uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
 312         union samr_UserInfo *info = NULL;
 313         uint32 user_rid = 0;
 314
 315         if ((argc < 2) || (argc > 4)) {
 316                 printf("Usage: %s rid [info level] [access mask] \n", argv[0]);
 317                 return NT_STATUS_OK;
 318         }
 319
 320         sscanf(argv[1], "%i", &user_rid);
 321
 322         if (argc > 2)
 323                 sscanf(argv[2], "%i", &info_level);
 324
 325         if (argc > 3)
 326                 sscanf(argv[3], "%x", &access_mask);
 327
 328
 329         result = rpccli_try_samr_connects(cli, mem_ctx,
 330                                           MAXIMUM_ALLOWED_ACCESS,
 331                                           &connect_pol);
 332
 333         if (!NT_STATUS_IS_OK(result))
 334                 goto done;
 335
 336         result = rpccli_samr_OpenDomain(cli, mem_ctx,
 337                                         &connect_pol,
 338                                         MAXIMUM_ALLOWED_ACCESS,
 339                                         &domain_sid,
 340                                         &domain_pol);
 341         if (!NT_STATUS_IS_OK(result))
 342                 goto done;
 343
 344         result = rpccli_samr_OpenUser(cli, mem_ctx,
 345                                       &domain_pol,
 346                                       access_mask,
 347                                       user_rid,
 348                                       &user_pol);
 349
 350         if (NT_STATUS_EQUAL(result, NT_STATUS_NO_SUCH_USER) &&
 351             (user_rid == 0)) {
 352
 353                 /* Probably this was a user name, try lookupnames */
 354                 struct samr_Ids rids, types;
 355                 struct lsa_String lsa_acct_name;
 356
 357                 init_lsa_String(&lsa_acct_name, argv[1]);
 358
 359                 result = rpccli_samr_LookupNames(cli, mem_ctx,
 360                                                  &domain_pol,
 361                                                  1,
 362                                                  &lsa_acct_name,
 363                                                  &rids,
 364                                                  &types);
 365
 366                 if (NT_STATUS_IS_OK(result)) {
 367                         result = rpccli_samr_OpenUser(cli, mem_ctx,
 368                                                       &domain_pol,
 369                                                       access_mask,
 370                                                       rids.ids[0],
 371                                                       &user_pol);
 372                 }
 373         }
 374
 375
 376         if (!NT_STATUS_IS_OK(result))
 377                 goto done;
 378
 379         result = rpccli_samr_QueryUserInfo(cli, mem_ctx,
 380                                            &user_pol,
 381                                            info_level,
 382                                            &info);
 383
 384         if (!NT_STATUS_IS_OK(result))
 385                 goto done;
 386
 387         switch (info_level) {
 388         case 7:
 389                 display_samr_user_info_7(&info->info7);
 390                 break;
 391         case 9:
 392                 display_samr_user_info_9(&info->info9);
 393                 break;
 394         case 16:
 395                 display_samr_user_info_16(&info->info16);
 396                 break;
 397         case 20:
 398                 display_samr_user_info_20(&info->info20);
 399                 break;
 400         case 21:
 401                 display_samr_user_info_21(&info->info21);
 402                 break;
 403         default:
 404                 printf("Unsupported infolevel: %d\n", info_level);
 405                 break;
 406         }
 407
 408         rpccli_samr_Close(cli, mem_ctx, &user_pol);
 409         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
 410         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
 411
 412 done:
 413         return result;
 414 }
 415
 416 /****************************************************************************
 417  display group info
 418  ****************************************************************************/
 419 static void display_group_info1(struct samr_GroupInfoAll *info1)
 420 {
 421         printf("\tGroup Name:\t%s\n", info1->name.string);
 422         printf("\tDescription:\t%s\n", info1->description.string);
 423         printf("\tGroup Attribute:%d\n", info1->attributes);
 424         printf("\tNum Members:%d\n", info1->num_members);
 425 }
 426
 427 /****************************************************************************
 428  display group info
 429  ****************************************************************************/
 430 static void display_group_info2(struct lsa_String *info2)
 431 {
 432         printf("\tGroup Description:%s\n", info2->string);
 433 }
 434
 435
 436 /****************************************************************************
 437  display group info
 438  ****************************************************************************/
 439 static void display_group_info3(struct samr_GroupInfoAttributes *info3)
 440 {
 441         printf("\tGroup Attribute:%d\n", info3->attributes);
 442 }
 443
 444
 445 /****************************************************************************
 446  display group info
 447  ****************************************************************************/
 448 static void display_group_info4(struct lsa_String *info4)
 449 {
 450         printf("\tGroup Description:%s\n", info4->string);
 451 }
 452
 453 /****************************************************************************
 454  display group info
 455  ****************************************************************************/
 456 static void display_group_info5(struct samr_GroupInfoAll *info5)
 457 {
 458         printf("\tGroup Name:\t%s\n", info5->name.string);
 459         printf("\tDescription:\t%s\n", info5->description.string);
 460         printf("\tGroup Attribute:%d\n", info5->attributes);
 461         printf("\tNum Members:%d\n", info5->num_members);
 462 }
 463
 464 /****************************************************************************
 465  display sam sync structure
 466  ****************************************************************************/
 467 static void display_group_info(union samr_GroupInfo *info,
 468                                enum samr_GroupInfoEnum level)
 469 {
 470         switch (level) {
 471                 case 1:
 472                         display_group_info1(&info->all);
 473                         break;
 474                 case 2:
 475                         display_group_info2(&info->name);
 476                         break;
 477                 case 3:
 478                         display_group_info3(&info->attributes);
 479                         break;
 480                 case 4:
 481                         display_group_info4(&info->description);
 482                         break;
 483                 case 5:
 484                         display_group_info5(&info->all2);
 485                         break;
 486         }
 487 }
 488
 489 /***********************************************************************
 490  * Query group information
 491  */
 492 static NTSTATUS cmd_samr_query_group(struct rpc_pipe_client *cli,
 493                                      TALLOC_CTX *mem_ctx,
 494                                      int argc, const char **argv)
 495 {
 496         struct policy_handle connect_pol, domain_pol, group_pol;
 497         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 498         enum samr_GroupInfoEnum info_level = GROUPINFOALL;
 499         uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
 500         union samr_GroupInfo *group_info = NULL;
 501         uint32 group_rid;
 502
 503         if ((argc < 2) || (argc > 4)) {
 504                 printf("Usage: %s rid [info level] [access mask]\n", argv[0]);
 505                 return NT_STATUS_OK;
 506         }
 507
 508         sscanf(argv[1], "%i", &group_rid);
 509
 510         if (argc > 2)
 511                 info_level = atoi(argv[2]);
 512
 513         if (argc > 3)
 514                 sscanf(argv[3], "%x", &access_mask);
 515
 516         result = rpccli_try_samr_connects(cli, mem_ctx,
 517                                           MAXIMUM_ALLOWED_ACCESS,
 518                                           &connect_pol);
 519
 520         if (!NT_STATUS_IS_OK(result))
 521                 goto done;
 522
 523         result = rpccli_samr_OpenDomain(cli, mem_ctx,
 524                                         &connect_pol,
 525                                         MAXIMUM_ALLOWED_ACCESS,
 526                                         &domain_sid,
 527                                         &domain_pol);
 528
 529         if (!NT_STATUS_IS_OK(result))
 530                 goto done;
 531
 532         result = rpccli_samr_OpenGroup(cli, mem_ctx,
 533                                        &domain_pol,
 534                                        access_mask,
 535                                        group_rid,
 536                                        &group_pol);
 537
 538         if (!NT_STATUS_IS_OK(result))
 539                 goto done;
 540
 541         result = rpccli_samr_QueryGroupInfo(cli, mem_ctx,
 542                                             &group_pol,
 543                                             info_level,
 544                                             &group_info);
 545         if (!NT_STATUS_IS_OK(result)) {
 546                 goto done;
 547         }
 548
 549         display_group_info(group_info, info_level);
 550
 551         rpccli_samr_Close(cli, mem_ctx, &group_pol);
 552         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
 553         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
 554 done:
 555         return result;
 556 }
 557
 558 /* Query groups a user is a member of */
 559
 560 static NTSTATUS cmd_samr_query_usergroups(struct rpc_pipe_client *cli,
 561                                           TALLOC_CTX *mem_ctx,
 562                                           int argc, const char **argv)
 563 {
 564         struct policy_handle            connect_pol,
 565                                 domain_pol,
 566                                 user_pol;
 567         NTSTATUS                result = NT_STATUS_UNSUCCESSFUL;
 568         uint32                  user_rid;
 569         uint32                  access_mask = MAXIMUM_ALLOWED_ACCESS;
 570         int                     i;
 571         struct samr_RidWithAttributeArray *rid_array = NULL;
 572
 573         if ((argc < 2) || (argc > 3)) {
 574                 printf("Usage: %s rid [access mask]\n", argv[0]);
 575                 return NT_STATUS_OK;
 576         }
 577
 578         sscanf(argv[1], "%i", &user_rid);
 579
 580         if (argc > 2)
 581                 sscanf(argv[2], "%x", &access_mask);
 582
 583         result = rpccli_try_samr_connects(cli, mem_ctx,
 584                                           MAXIMUM_ALLOWED_ACCESS,
 585                                           &connect_pol);
 586
 587         if (!NT_STATUS_IS_OK(result))
 588                 goto done;
 589
 590         result = rpccli_samr_OpenDomain(cli, mem_ctx,
 591                                         &connect_pol,
 592                                         MAXIMUM_ALLOWED_ACCESS,
 593                                         &domain_sid, &domain_pol);
 594
 595         if (!NT_STATUS_IS_OK(result))
 596                 goto done;
 597
 598         result = rpccli_samr_OpenUser(cli, mem_ctx,
 599                                       &domain_pol,
 600                                       access_mask,
 601                                       user_rid,
 602                                       &user_pol);
 603
 604         if (!NT_STATUS_IS_OK(result))
 605                 goto done;
 606
 607         result = rpccli_samr_GetGroupsForUser(cli, mem_ctx,
 608                                               &user_pol,
 609                                               &rid_array);
 610
 611         if (!NT_STATUS_IS_OK(result))
 612                 goto done;
 613
 614         for (i = 0; i < rid_array->count; i++) {
 615                 printf("\tgroup rid:[0x%x] attr:[0x%x]\n",
 616                        rid_array->rids[i].rid,
 617                        rid_array->rids[i].attributes);
 618         }
 619
 620         rpccli_samr_Close(cli, mem_ctx, &user_pol);
 621         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
 622         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
 623  done:
 624         return result;
 625 }
 626
 627 /* Query aliases a user is a member of */
 628
 629 static NTSTATUS cmd_samr_query_useraliases(struct rpc_pipe_client *cli,
 630                                            TALLOC_CTX *mem_ctx,
 631                                            int argc, const char **argv)
 632 {
 633         struct policy_handle            connect_pol, domain_pol;
 634         NTSTATUS                result = NT_STATUS_UNSUCCESSFUL;
 635         struct dom_sid                *sids;
 636         size_t                     num_sids;
 637         uint32                  access_mask = MAXIMUM_ALLOWED_ACCESS;
 638         int                     i;
 639         struct lsa_SidArray sid_array;
 640         struct samr_Ids alias_rids;
 641
 642         if (argc < 3) {
 643                 printf("Usage: %s builtin|domain sid1 sid2 ...\n", argv[0]);
 644                 return NT_STATUS_INVALID_PARAMETER;
 645         }
 646
 647         sids = NULL;
 648         num_sids = 0;
 649
 650         for (i=2; i<argc; i++) {
 651                 struct dom_sid tmp_sid;
 652                 if (!string_to_sid(&tmp_sid, argv[i])) {
 653                         printf("%s is not a legal SID\n", argv[i]);
 654                         return NT_STATUS_INVALID_PARAMETER;
 655                 }
 656                 result = add_sid_to_array(mem_ctx, &tmp_sid, &sids, &num_sids);
 657                 if (!NT_STATUS_IS_OK(result)) {
 658                         return result;
 659                 }
 660         }
 661
 662         if (num_sids) {
 663                 sid_array.sids = TALLOC_ZERO_ARRAY(mem_ctx, struct lsa_SidPtr, num_sids);
 664                 if (sid_array.sids == NULL)
 665                         return NT_STATUS_NO_MEMORY;
 666         } else {
 667                 sid_array.sids = NULL;
 668         }
 669
 670         for (i=0; i<num_sids; i++) {
 671                 sid_array.sids[i].sid = sid_dup_talloc(mem_ctx, &sids[i]);
 672                 if (!sid_array.sids[i].sid) {
 673                         return NT_STATUS_NO_MEMORY;
 674                 }
 675         }
 676
 677         sid_array.num_sids = num_sids;
 678
 679         result = rpccli_try_samr_connects(cli, mem_ctx,
 680                                           MAXIMUM_ALLOWED_ACCESS,
 681                                           &connect_pol);
 682
 683         if (!NT_STATUS_IS_OK(result))
 684                 goto done;
 685
 686         result = get_domain_handle(cli, mem_ctx, argv[1],
 687                                    &connect_pol,
 688                                    access_mask,
 689                                    &domain_sid,
 690                                    &domain_pol);
 691
 692         if (!NT_STATUS_IS_OK(result))
 693                 goto done;
 694
 695         result = rpccli_samr_GetAliasMembership(cli, mem_ctx,
 696                                                 &domain_pol,
 697                                                 &sid_array,
 698                                                 &alias_rids);
 699         if (!NT_STATUS_IS_OK(result))
 700                 goto done;
 701
 702         for (i = 0; i < alias_rids.count; i++) {
 703                 printf("\tgroup rid:[0x%x]\n", alias_rids.ids[i]);
 704         }
 705
 706         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
 707         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
 708  done:
 709         return result;
 710 }
 711
 712 /* Query members of a group */
 713
 714 static NTSTATUS cmd_samr_query_groupmem(struct rpc_pipe_client *cli,
 715                                         TALLOC_CTX *mem_ctx,
 716                                         int argc, const char **argv)
 717 {
 718         struct policy_handle connect_pol, domain_pol, group_pol;
 719         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 720         uint32 group_rid;
 721         uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
 722         int i;
 723         unsigned int old_timeout;
 724         struct samr_RidTypeArray *rids = NULL;
 725
 726         if ((argc < 2) || (argc > 3)) {
 727                 printf("Usage: %s rid [access mask]\n", argv[0]);
 728                 return NT_STATUS_OK;
 729         }
 730
 731         sscanf(argv[1], "%i", &group_rid);
 732
 733         if (argc > 2)
 734                 sscanf(argv[2], "%x", &access_mask);
 735
 736         result = rpccli_try_samr_connects(cli, mem_ctx,
 737                                           MAXIMUM_ALLOWED_ACCESS,
 738                                           &connect_pol);
 739
 740         if (!NT_STATUS_IS_OK(result))
 741                 goto done;
 742
 743         result = rpccli_samr_OpenDomain(cli, mem_ctx,
 744                                         &connect_pol,
 745                                         MAXIMUM_ALLOWED_ACCESS,
 746                                         &domain_sid,
 747                                         &domain_pol);
 748
 749         if (!NT_STATUS_IS_OK(result))
 750                 goto done;
 751
 752         result = rpccli_samr_OpenGroup(cli, mem_ctx,
 753                                        &domain_pol,
 754                                        access_mask,
 755                                        group_rid,
 756                                        &group_pol);
 757
 758         if (!NT_STATUS_IS_OK(result))
 759                 goto done;
 760
 761         /* Make sure to wait for our DC's reply */
 762         old_timeout = rpccli_set_timeout(cli, 30000); /* 30 seconds. */
 763         rpccli_set_timeout(cli, MAX(30000, old_timeout)); /* At least 30 sec */
 764
 765         result = rpccli_samr_QueryGroupMember(cli, mem_ctx,
 766                                               &group_pol,
 767                                               &rids);
 768
 769         rpccli_set_timeout(cli, old_timeout);
 770
 771         if (!NT_STATUS_IS_OK(result))
 772                 goto done;
 773
 774         for (i = 0; i < rids->count; i++) {
 775                 printf("\trid:[0x%x] attr:[0x%x]\n", rids->rids[i],
 776                        rids->types[i]);
 777         }
 778
 779         rpccli_samr_Close(cli, mem_ctx, &group_pol);
 780         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
 781         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
 782  done:
 783         return result;
 784 }
 785
 786 /* Enumerate domain users */
 787
 788 static NTSTATUS cmd_samr_enum_dom_users(struct rpc_pipe_client *cli,
 789                                         TALLOC_CTX *mem_ctx,
 790                                         int argc, const char **argv)
 791 {
 792         struct policy_handle connect_pol, domain_pol;
 793         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 794         uint32 start_idx, num_dom_users, i;
 795         struct samr_SamArray *dom_users = NULL;
 796         uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
 797         uint32 acb_mask = ACB_NORMAL;
 798         uint32_t size = 0xffff;
 799
 800         if ((argc < 1) || (argc > 4)) {
 801                 printf("Usage: %s [access_mask] [acb_mask] [size]\n", argv[0]);
 802                 return NT_STATUS_OK;
 803         }
 804
 805         if (argc > 1) {
 806                 sscanf(argv[1], "%x", &access_mask);
 807         }
 808
 809         if (argc > 2) {
 810                 sscanf(argv[2], "%x", &acb_mask);
 811         }
 812
 813         if (argc > 3) {
 814                 sscanf(argv[3], "%x", &size);
 815         }
 816
 817         /* Get sam policy handle */
 818
 819         result = rpccli_try_samr_connects(cli, mem_ctx,
 820                                           MAXIMUM_ALLOWED_ACCESS,
 821                                           &connect_pol);
 822
 823         if (!NT_STATUS_IS_OK(result))
 824                 goto done;
 825
 826         /* Get domain policy handle */
 827
 828         result = get_domain_handle(cli, mem_ctx, "domain",
 829                                    &connect_pol,
 830                                    access_mask,
 831                                    &domain_sid,
 832                                    &domain_pol);
 833         if (!NT_STATUS_IS_OK(result))
 834                 goto done;
 835
 836         /* Enumerate domain users */
 837
 838         start_idx = 0;
 839
 840         do {
 841                 result = rpccli_samr_EnumDomainUsers(cli, mem_ctx,
 842                                                      &domain_pol,
 843                                                      &start_idx,
 844                                                      acb_mask,
 845                                                      &dom_users,
 846                                                      size,
 847                                                      &num_dom_users);
 848
 849                 if (NT_STATUS_IS_OK(result) ||
 850                     NT_STATUS_V(result) == NT_STATUS_V(STATUS_MORE_ENTRIES)) {
 851
 852                         for (i = 0; i < num_dom_users; i++)
 853                                printf("user:[%s] rid:[0x%x]\n",
 854                                        dom_users->entries[i].name.string,
 855                                        dom_users->entries[i].idx);
 856                 }
 857
 858         } while (NT_STATUS_V(result) == NT_STATUS_V(STATUS_MORE_ENTRIES));
 859
 860  done:
 861         if (is_valid_policy_hnd(&domain_pol))
 862                 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
 863
 864         if (is_valid_policy_hnd(&connect_pol))
 865                 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
 866
 867         return result;
 868 }
 869
 870 /* Enumerate domain groups */
 871
 872 static NTSTATUS cmd_samr_enum_dom_groups(struct rpc_pipe_client *cli,
 873                                          TALLOC_CTX *mem_ctx,
 874                                          int argc, const char **argv)
 875 {
 876         struct policy_handle connect_pol, domain_pol;
 877         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 878         uint32 start_idx, num_dom_groups, i;
 879         uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
 880         struct samr_SamArray *dom_groups = NULL;
 881         uint32_t size = 0xffff;
 882
 883         if ((argc < 1) || (argc > 3)) {
 884                 printf("Usage: %s [access_mask] [max_size]\n", argv[0]);
 885                 return NT_STATUS_OK;
 886         }
 887
 888         if (argc > 1) {
 889                 sscanf(argv[1], "%x", &access_mask);
 890         }
 891
 892         if (argc > 2) {
 893                 sscanf(argv[2], "%x", &size);
 894         }
 895
 896         /* Get sam policy handle */
 897
 898         result = rpccli_try_samr_connects(cli, mem_ctx,
 899                                           MAXIMUM_ALLOWED_ACCESS,
 900                                           &connect_pol);
 901
 902         if (!NT_STATUS_IS_OK(result))
 903                 goto done;
 904
 905         /* Get domain policy handle */
 906
 907         result = get_domain_handle(cli, mem_ctx, "domain",
 908                                    &connect_pol,
 909                                    access_mask,
 910                                    &domain_sid,
 911                                    &domain_pol);
 912         if (!NT_STATUS_IS_OK(result))
 913                 goto done;
 914
 915         /* Enumerate domain groups */
 916
 917         start_idx = 0;
 918
 919         do {
 920                 result = rpccli_samr_EnumDomainGroups(cli, mem_ctx,
 921                                                       &domain_pol,
 922                                                       &start_idx,
 923                                                       &dom_groups,
 924                                                       size,
 925                                                       &num_dom_groups);
 926                 if (NT_STATUS_IS_OK(result) ||
 927                     NT_STATUS_V(result) == NT_STATUS_V(STATUS_MORE_ENTRIES)) {
 928
 929                         for (i = 0; i < num_dom_groups; i++)
 930                                 printf("group:[%s] rid:[0x%x]\n",
 931                                        dom_groups->entries[i].name.string,
 932                                        dom_groups->entries[i].idx);
 933                 }
 934
 935         } while (NT_STATUS_V(result) == NT_STATUS_V(STATUS_MORE_ENTRIES));
 936
 937  done:
 938         if (is_valid_policy_hnd(&domain_pol))
 939                 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
 940
 941         if (is_valid_policy_hnd(&connect_pol))
 942                 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
 943
 944         return result;
 945 }
 946
 947 /* Enumerate alias groups */
 948
 949 static NTSTATUS cmd_samr_enum_als_groups(struct rpc_pipe_client *cli,
 950                                          TALLOC_CTX *mem_ctx,
 951                                          int argc, const char **argv)
 952 {
 953         struct policy_handle connect_pol, domain_pol;
 954         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 955         uint32 start_idx, num_als_groups, i;
 956         uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
 957         struct samr_SamArray *als_groups = NULL;
 958         uint32_t size = 0xffff;
 959
 960         if ((argc < 2) || (argc > 4)) {
 961                 printf("Usage: %s builtin|domain [access mask] [max_size]\n", argv[0]);
 962                 return NT_STATUS_OK;
 963         }
 964
 965         if (argc > 2) {
 966                 sscanf(argv[2], "%x", &access_mask);
 967         }
 968
 969         if (argc > 3) {
 970                 sscanf(argv[3], "%x", &size);
 971         }
 972
 973         /* Get sam policy handle */
 974
 975         result = rpccli_try_samr_connects(cli, mem_ctx,
 976                                           MAXIMUM_ALLOWED_ACCESS,
 977                                           &connect_pol);
 978
 979         if (!NT_STATUS_IS_OK(result))
 980                 goto done;
 981
 982         /* Get domain policy handle */
 983
 984         result = get_domain_handle(cli, mem_ctx, argv[1],
 985                                    &connect_pol,
 986                                    access_mask,
 987                                    &domain_sid,
 988                                    &domain_pol);
 989
 990         if (!NT_STATUS_IS_OK(result))
 991                 goto done;
 992
 993         /* Enumerate alias groups */
 994
 995         start_idx = 0;
 996
 997         do {
 998                 result = rpccli_samr_EnumDomainAliases(cli, mem_ctx,
 999                                                        &domain_pol,
1000                                                        &start_idx,
1001                                                        &als_groups,
1002                                                        size,
1003                                                        &num_als_groups);
1004
1005                 if (NT_STATUS_IS_OK(result) ||
1006                     NT_STATUS_V(result) == NT_STATUS_V(STATUS_MORE_ENTRIES)) {
1007
1008                         for (i = 0; i < num_als_groups; i++)
1009                                 printf("group:[%s] rid:[0x%x]\n",
1010                                        als_groups->entries[i].name.string,
1011                                        als_groups->entries[i].idx);
1012                 }
1013         } while (NT_STATUS_V(result) == NT_STATUS_V(STATUS_MORE_ENTRIES));
1014
1015  done:
1016         if (is_valid_policy_hnd(&domain_pol))
1017                 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
1018
1019         if (is_valid_policy_hnd(&connect_pol))
1020                 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
1021
1022         return result;
1023 }
1024
1025 /* Enumerate domains */
1026
1027 static NTSTATUS cmd_samr_enum_domains(struct rpc_pipe_client *cli,
1028                                       TALLOC_CTX *mem_ctx,
1029                                       int argc, const char **argv)
1030 {
1031         struct policy_handle connect_pol;
1032         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1033         uint32 start_idx, size, num_entries, i;
1034         uint32 access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
1035         struct samr_SamArray *sam = NULL;
1036
1037         if ((argc < 1) || (argc > 2)) {
1038                 printf("Usage: %s [access mask]\n", argv[0]);
1039                 return NT_STATUS_OK;
1040         }
1041
1042         if (argc > 1) {
1043                 sscanf(argv[1], "%x", &access_mask);
1044         }
1045
1046         /* Get sam policy handle */
1047
1048         result = rpccli_try_samr_connects(cli, mem_ctx,
1049                                           access_mask,
1050                                           &connect_pol);
1051
1052         if (!NT_STATUS_IS_OK(result)) {
1053                 goto done;
1054         }
1055
1056         /* Enumerate alias groups */
1057
1058         start_idx = 0;
1059         size = 0xffff;
1060
1061         do {
1062                 result = rpccli_samr_EnumDomains(cli, mem_ctx,
1063                                                  &connect_pol,
1064                                                  &start_idx,
1065                                                  &sam,
1066                                                  size,
1067                                                  &num_entries);
1068
1069                 if (NT_STATUS_IS_OK(result) ||
1070                     NT_STATUS_V(result) == NT_STATUS_V(STATUS_MORE_ENTRIES)) {
1071
1072                         for (i = 0; i < num_entries; i++)
1073                                 printf("name:[%s] idx:[0x%x]\n",
1074                                        sam->entries[i].name.string,
1075                                        sam->entries[i].idx);
1076                 }
1077         } while (NT_STATUS_V(result) == NT_STATUS_V(STATUS_MORE_ENTRIES));
1078
1079  done:
1080         if (is_valid_policy_hnd(&connect_pol)) {
1081                 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
1082         }
1083
1084         return result;
1085 }
1086
1087
1088 /* Query alias membership */
1089
1090 static NTSTATUS cmd_samr_query_aliasmem(struct rpc_pipe_client *cli,
1091                                         TALLOC_CTX *mem_ctx,
1092                                         int argc, const char **argv)
1093 {
1094         struct policy_handle connect_pol, domain_pol, alias_pol;
1095         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1096         uint32 alias_rid, i;
1097         uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
1098         struct lsa_SidArray sid_array;
1099
1100         if ((argc < 3) || (argc > 4)) {
1101                 printf("Usage: %s builtin|domain rid [access mask]\n", argv[0]);
1102                 return NT_STATUS_OK;
1103         }
1104
1105         sscanf(argv[2], "%i", &alias_rid);
1106
1107         if (argc > 3)
1108                 sscanf(argv[3], "%x", &access_mask);
1109
1110         /* Open SAMR handle */
1111
1112         result = rpccli_try_samr_connects(cli, mem_ctx,
1113                                           MAXIMUM_ALLOWED_ACCESS,
1114                                           &connect_pol);
1115
1116         if (!NT_STATUS_IS_OK(result))
1117                 goto done;
1118
1119         /* Open handle on domain */
1120
1121         result = get_domain_handle(cli, mem_ctx, argv[1],
1122                                    &connect_pol,
1123                                    MAXIMUM_ALLOWED_ACCESS,
1124                                    &domain_sid,
1125                                    &domain_pol);
1126
1127         if (!NT_STATUS_IS_OK(result))
1128                 goto done;
1129
1130         /* Open handle on alias */
1131
1132         result = rpccli_samr_OpenAlias(cli, mem_ctx,
1133                                        &domain_pol,
1134                                        access_mask,
1135                                        alias_rid,
1136                                        &alias_pol);
1137         if (!NT_STATUS_IS_OK(result))
1138                 goto done;
1139
1140         result = rpccli_samr_GetMembersInAlias(cli, mem_ctx,
1141                                                &alias_pol,
1142                                                &sid_array);
1143
1144         if (!NT_STATUS_IS_OK(result))
1145                 goto done;
1146
1147         for (i = 0; i < sid_array.num_sids; i++) {
1148                 fstring sid_str;
1149
1150                 sid_to_fstring(sid_str, sid_array.sids[i].sid);
1151                 printf("\tsid:[%s]\n", sid_str);
1152         }
1153
1154         rpccli_samr_Close(cli, mem_ctx, &alias_pol);
1155         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
1156         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
1157  done:
1158         return result;
1159 }
1160
1161 /* Query alias info */
1162
1163 static NTSTATUS cmd_samr_query_aliasinfo(struct rpc_pipe_client *cli,
1164                                          TALLOC_CTX *mem_ctx,
1165                                          int argc, const char **argv)
1166 {
1167         struct policy_handle connect_pol, domain_pol, alias_pol;
1168         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1169         uint32_t alias_rid;
1170         uint32_t access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
1171         union samr_AliasInfo *info = NULL;
1172         enum samr_AliasInfoEnum level = ALIASINFOALL;
1173
1174         if ((argc < 3) || (argc > 4)) {
1175                 printf("Usage: %s builtin|domain rid [level] [access mask]\n",
1176                         argv[0]);
1177                 return NT_STATUS_OK;
1178         }
1179
1180         sscanf(argv[2], "%i", &alias_rid);
1181
1182         if (argc > 2) {
1183                 level = atoi(argv[3]);
1184         }
1185
1186         if (argc > 3) {
1187                 sscanf(argv[4], "%x", &access_mask);
1188         }
1189
1190         /* Open SAMR handle */
1191
1192         result = rpccli_try_samr_connects(cli, mem_ctx,
1193                                           SEC_FLAG_MAXIMUM_ALLOWED,
1194                                           &connect_pol);
1195
1196         if (!NT_STATUS_IS_OK(result)) {
1197                 goto done;
1198         }
1199
1200         /* Open handle on domain */
1201
1202         result = get_domain_handle(cli, mem_ctx, argv[1],
1203                                    &connect_pol,
1204                                    SEC_FLAG_MAXIMUM_ALLOWED,
1205                                    &domain_sid,
1206                                    &domain_pol);
1207
1208         if (!NT_STATUS_IS_OK(result)) {
1209                 goto done;
1210         }
1211
1212         /* Open handle on alias */
1213
1214         result = rpccli_samr_OpenAlias(cli, mem_ctx,
1215                                        &domain_pol,
1216                                        access_mask,
1217                                        alias_rid,
1218                                        &alias_pol);
1219         if (!NT_STATUS_IS_OK(result)) {
1220                 goto done;
1221         }
1222
1223         result = rpccli_samr_QueryAliasInfo(cli, mem_ctx,
1224                                             &alias_pol,
1225                                             level,
1226                                             &info);
1227
1228         if (!NT_STATUS_IS_OK(result)) {
1229                 goto done;
1230         }
1231
1232         switch (level) {
1233                 case ALIASINFOALL:
1234                         printf("Name: %s\n", info->all.name.string);
1235                         printf("Description: %s\n", info->all.description.string);
1236                         printf("Num Members: %d\n", info->all.num_members);
1237                         break;
1238                 case ALIASINFONAME:
1239                         printf("Name: %s\n", info->name.string);
1240                         break;
1241                 case ALIASINFODESCRIPTION:
1242                         printf("Description: %s\n", info->description.string);
1243                         break;
1244                 default:
1245                         break;
1246         }
1247
1248         rpccli_samr_Close(cli, mem_ctx, &alias_pol);
1249         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
1250         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
1251  done:
1252         return result;
1253 }
1254
1255
1256 /* Query delete an alias membership */
1257
1258 static NTSTATUS cmd_samr_delete_alias(struct rpc_pipe_client *cli,
1259                                       TALLOC_CTX *mem_ctx,
1260                                       int argc, const char **argv)
1261 {
1262         struct policy_handle connect_pol, domain_pol, alias_pol;
1263         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1264         uint32 alias_rid;
1265         uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
1266
1267         if (argc != 3) {
1268                 printf("Usage: %s builtin|domain [rid|name]\n", argv[0]);
1269                 return NT_STATUS_OK;
1270         }
1271
1272         alias_rid = strtoul(argv[2], NULL, 10);
1273
1274         /* Open SAMR handle */
1275
1276         result = rpccli_try_samr_connects(cli, mem_ctx,
1277                                           MAXIMUM_ALLOWED_ACCESS,
1278                                           &connect_pol);
1279
1280         if (!NT_STATUS_IS_OK(result))
1281                 goto done;
1282
1283         /* Open handle on domain */
1284
1285         result = get_domain_handle(cli, mem_ctx, argv[1],
1286                                    &connect_pol,
1287                                    MAXIMUM_ALLOWED_ACCESS,
1288                                    &domain_sid,
1289                                    &domain_pol);
1290
1291         if (!NT_STATUS_IS_OK(result))
1292                 goto done;
1293
1294         /* Open handle on alias */
1295
1296         result = rpccli_samr_OpenAlias(cli, mem_ctx,
1297                                        &domain_pol,
1298                                        access_mask,
1299                                        alias_rid,
1300                                        &alias_pol);
1301         if (!NT_STATUS_IS_OK(result) && (alias_rid == 0)) {
1302                 /* Probably this was a user name, try lookupnames */
1303                 struct samr_Ids rids, types;
1304                 struct lsa_String lsa_acct_name;
1305
1306                 init_lsa_String(&lsa_acct_name, argv[2]);
1307
1308                 result = rpccli_samr_LookupNames(cli, mem_ctx,
1309                                                  &domain_pol,
1310                                                  1,
1311                                                  &lsa_acct_name,
1312                                                  &rids,
1313                                                  &types);
1314
1315                 if (NT_STATUS_IS_OK(result)) {
1316                         result = rpccli_samr_OpenAlias(cli, mem_ctx,
1317                                                        &domain_pol,
1318                                                        access_mask,
1319                                                        rids.ids[0],
1320                                                        &alias_pol);
1321                 }
1322         }
1323
1324         result = rpccli_samr_DeleteDomAlias(cli, mem_ctx,
1325                                             &alias_pol);
1326
1327         if (!NT_STATUS_IS_OK(result))
1328                 goto done;
1329
1330         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
1331         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
1332  done:
1333         return result;
1334 }
1335
1336 /* Query display info */
1337
1338 static NTSTATUS cmd_samr_query_dispinfo_internal(struct rpc_pipe_client *cli,
1339                                                  TALLOC_CTX *mem_ctx,
1340                                                  int argc, const char **argv,
1341                                                  uint32_t opcode)
1342 {
1343         struct policy_handle connect_pol, domain_pol;
1344         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1345         uint32 start_idx=0, max_entries=250, max_size = 0xffff, num_entries = 0, i;
1346         uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
1347         uint32 info_level = 1;
1348         union samr_DispInfo info;
1349         int loop_count = 0;
1350         bool got_params = False; /* Use get_query_dispinfo_params() or not? */
1351         uint32_t total_size, returned_size;
1352
1353         if (argc > 6) {
1354                 printf("Usage: %s [info level] [start index] [max entries] [max size] [access mask]\n", argv[0]);
1355                 return NT_STATUS_OK;
1356         }
1357
1358         if (argc >= 2)
1359                 sscanf(argv[1], "%i", &info_level);
1360
1361         if (argc >= 3)
1362                 sscanf(argv[2], "%i", &start_idx);
1363
1364         if (argc >= 4) {
1365                 sscanf(argv[3], "%i", &max_entries);
1366                 got_params = True;
1367         }
1368
1369         if (argc >= 5) {
1370                 sscanf(argv[4], "%i", &max_size);
1371                 got_params = True;
1372         }
1373
1374         if (argc >= 6)
1375                 sscanf(argv[5], "%x", &access_mask);
1376
1377         /* Get sam policy handle */
1378
1379         result = rpccli_try_samr_connects(cli, mem_ctx,
1380                                           MAXIMUM_ALLOWED_ACCESS,
1381                                           &connect_pol);
1382
1383         if (!NT_STATUS_IS_OK(result))
1384                 goto done;
1385
1386         /* Get domain policy handle */
1387
1388         result = rpccli_samr_OpenDomain(cli, mem_ctx,
1389                                         &connect_pol,
1390                                         access_mask,
1391                                         &domain_sid,
1392                                         &domain_pol);
1393
1394         if (!NT_STATUS_IS_OK(result))
1395                 goto done;
1396
1397         /* Query display info */
1398
1399         do {
1400
1401                 if (!got_params)
1402                         get_query_dispinfo_params(
1403                                 loop_count, &max_entries, &max_size);
1404
1405                 switch (opcode) {
1406                 case NDR_SAMR_QUERYDISPLAYINFO:
1407                         result = rpccli_samr_QueryDisplayInfo(cli, mem_ctx,
1408                                                               &domain_pol,
1409                                                               info_level,
1410                                                               start_idx,
1411                                                               max_entries,
1412                                                               max_size,
1413                                                               &total_size,
1414                                                               &returned_size,
1415                                                               &info);
1416                         break;
1417                 case NDR_SAMR_QUERYDISPLAYINFO2:
1418                         result = rpccli_samr_QueryDisplayInfo2(cli, mem_ctx,
1419                                                                &domain_pol,
1420                                                                info_level,
1421                                                                start_idx,
1422                                                                max_entries,
1423                                                                max_size,
1424                                                                &total_size,
1425                                                                &returned_size,
1426                                                                &info);
1427
1428                         break;
1429                 case NDR_SAMR_QUERYDISPLAYINFO3:
1430                         result = rpccli_samr_QueryDisplayInfo3(cli, mem_ctx,
1431                                                                &domain_pol,
1432                                                                info_level,
1433                                                                start_idx,
1434                                                                max_entries,
1435                                                                max_size,
1436                                                                &total_size,
1437                                                                &returned_size,
1438                                                                &info);
1439
1440                         break;
1441                 default:
1442                         return NT_STATUS_INVALID_PARAMETER;
1443                 }
1444
1445                 if (!NT_STATUS_IS_OK(result) &&
1446                     !NT_STATUS_EQUAL(result, NT_STATUS_NO_MORE_ENTRIES) &&
1447                     !NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES)) {
1448                         break;
1449                 }
1450
1451                 loop_count++;
1452
1453                 switch (info_level) {
1454                         case 1:
1455                                 num_entries = info.info1.count;
1456                                 break;
1457                         case 2:
1458                                 num_entries = info.info2.count;
1459                                 break;
1460                         case 3:
1461                                 num_entries = info.info3.count;
1462                                 break;
1463                         case 4:
1464                                 num_entries = info.info4.count;
1465                                 break;
1466                         case 5:
1467                                 num_entries = info.info5.count;
1468                                 break;
1469                         default:
1470                                 break;
1471                 }
1472
1473                 start_idx += num_entries;
1474
1475                 if (num_entries == 0)
1476                         break;
1477
1478                 for (i = 0; i < num_entries; i++) {
1479                         switch (info_level) {
1480                         case 1:
1481                                 display_sam_info_1(&info.info1.entries[i]);
1482                                 break;
1483                         case 2:
1484                                 display_sam_info_2(&info.info2.entries[i]);
1485                                 break;
1486                         case 3:
1487                                 display_sam_info_3(&info.info3.entries[i]);
1488                                 break;
1489                         case 4:
1490                                 display_sam_info_4(&info.info4.entries[i]);
1491                                 break;
1492                         case 5:
1493                                 display_sam_info_5(&info.info5.entries[i]);
1494                                 break;
1495                         }
1496                 }
1497         } while ( NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES));
1498
1499         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
1500         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
1501  done:
1502         return result;
1503 }
1504
1505 static NTSTATUS cmd_samr_query_dispinfo(struct rpc_pipe_client *cli,
1506                                         TALLOC_CTX *mem_ctx,
1507                                         int argc, const char **argv)
1508 {
1509         return cmd_samr_query_dispinfo_internal(cli, mem_ctx, argc, argv,
1510                                                 NDR_SAMR_QUERYDISPLAYINFO);
1511 }
1512
1513 static NTSTATUS cmd_samr_query_dispinfo2(struct rpc_pipe_client *cli,
1514                                          TALLOC_CTX *mem_ctx,
1515                                          int argc, const char **argv)
1516 {
1517         return cmd_samr_query_dispinfo_internal(cli, mem_ctx, argc, argv,
1518                                                 NDR_SAMR_QUERYDISPLAYINFO2);
1519 }
1520
1521 static NTSTATUS cmd_samr_query_dispinfo3(struct rpc_pipe_client *cli,
1522                                          TALLOC_CTX *mem_ctx,
1523                                          int argc, const char **argv)
1524 {
1525         return cmd_samr_query_dispinfo_internal(cli, mem_ctx, argc, argv,
1526                                                 NDR_SAMR_QUERYDISPLAYINFO3);
1527 }
1528
1529 /* Query domain info */
1530
1531 static NTSTATUS cmd_samr_query_dominfo(struct rpc_pipe_client *cli,
1532                                        TALLOC_CTX *mem_ctx,
1533                                        int argc, const char **argv)
1534 {
1535         struct policy_handle connect_pol, domain_pol;
1536         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1537         uint32 switch_level = 2;
1538         uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
1539         union samr_DomainInfo *info = NULL;
1540
1541         if (argc > 3) {
1542                 printf("Usage: %s [info level] [access mask]\n", argv[0]);
1543                 return NT_STATUS_OK;
1544         }
1545
1546         if (argc > 1)
1547                 sscanf(argv[1], "%i", &switch_level);
1548
1549         if (argc > 2)
1550                 sscanf(argv[2], "%x", &access_mask);
1551
1552         /* Get sam policy handle */
1553
1554         result = rpccli_try_samr_connects(cli, mem_ctx,
1555                                           MAXIMUM_ALLOWED_ACCESS,
1556                                           &connect_pol);
1557
1558         if (!NT_STATUS_IS_OK(result))
1559                 goto done;
1560
1561         /* Get domain policy handle */
1562
1563         result = rpccli_samr_OpenDomain(cli, mem_ctx,
1564                                         &connect_pol,
1565                                         access_mask,
1566                                         &domain_sid,
1567                                         &domain_pol);
1568
1569         if (!NT_STATUS_IS_OK(result))
1570                 goto done;
1571
1572         /* Query domain info */
1573
1574         result = rpccli_samr_QueryDomainInfo(cli, mem_ctx,
1575                                              &domain_pol,
1576                                              switch_level,
1577                                              &info);
1578
1579         if (!NT_STATUS_IS_OK(result))
1580                 goto done;
1581
1582         /* Display domain info */
1583
1584         switch (switch_level) {
1585         case 1:
1586                 display_sam_dom_info_1(&info->info1);
1587                 break;
1588         case 2:
1589                 display_sam_dom_info_2(&info->general);
1590                 break;
1591         case 3:
1592                 display_sam_dom_info_3(&info->info3);
1593                 break;
1594         case 4:
1595                 display_sam_dom_info_4(&info->oem);
1596                 break;
1597         case 5:
1598                 display_sam_dom_info_5(&info->info5);
1599                 break;
1600         case 6:
1601                 display_sam_dom_info_6(&info->info6);
1602                 break;
1603         case 7:
1604                 display_sam_dom_info_7(&info->info7);
1605                 break;
1606         case 8:
1607                 display_sam_dom_info_8(&info->info8);
1608                 break;
1609         case 9:
1610                 display_sam_dom_info_9(&info->info9);
1611                 break;
1612         case 12:
1613                 display_sam_dom_info_12(&info->info12);
1614                 break;
1615         case 13:
1616                 display_sam_dom_info_13(&info->info13);
1617                 break;
1618
1619         default:
1620                 printf("cannot display domain info for switch value %d\n",
1621                        switch_level);
1622                 break;
1623         }
1624
1625  done:
1626
1627         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
1628         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
1629         return result;
1630 }
1631
1632 /* Create domain user */
1633
1634 static NTSTATUS cmd_samr_create_dom_user(struct rpc_pipe_client *cli,
1635                                          TALLOC_CTX *mem_ctx,
1636                                          int argc, const char **argv)
1637 {
1638         struct policy_handle connect_pol, domain_pol, user_pol;
1639         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1640         struct lsa_String acct_name;
1641         uint32 acb_info;
1642         uint32 acct_flags, user_rid;
1643         uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
1644         uint32_t access_granted = 0;
1645
1646         if ((argc < 2) || (argc > 3)) {
1647                 printf("Usage: %s username [access mask]\n", argv[0]);
1648                 return NT_STATUS_OK;
1649         }
1650
1651         init_lsa_String(&acct_name, argv[1]);
1652
1653         if (argc > 2)
1654                 sscanf(argv[2], "%x", &access_mask);
1655
1656         /* Get sam policy handle */
1657
1658         result = rpccli_try_samr_connects(cli, mem_ctx,
1659                                           MAXIMUM_ALLOWED_ACCESS,
1660                                           &connect_pol);
1661
1662         if (!NT_STATUS_IS_OK(result))
1663                 goto done;
1664
1665         /* Get domain policy handle */
1666
1667         result = rpccli_samr_OpenDomain(cli, mem_ctx,
1668                                         &connect_pol,
1669                                         access_mask,
1670                                         &domain_sid,
1671                                         &domain_pol);
1672
1673         if (!NT_STATUS_IS_OK(result))
1674                 goto done;
1675
1676         /* Create domain user */
1677
1678         acb_info = ACB_NORMAL;
1679         acct_flags = SEC_GENERIC_READ | SEC_GENERIC_WRITE | SEC_GENERIC_EXECUTE |
1680                      SEC_STD_WRITE_DAC | SEC_STD_DELETE |
1681                      SAMR_USER_ACCESS_SET_PASSWORD |
1682                      SAMR_USER_ACCESS_GET_ATTRIBUTES |
1683                      SAMR_USER_ACCESS_SET_ATTRIBUTES;
1684
1685         result = rpccli_samr_CreateUser2(cli, mem_ctx,
1686                                          &domain_pol,
1687                                          &acct_name,
1688                                          acb_info,
1689                                          acct_flags,
1690                                          &user_pol,
1691                                          &access_granted,
1692                                          &user_rid);
1693
1694         if (!NT_STATUS_IS_OK(result))
1695                 goto done;
1696
1697         result = rpccli_samr_Close(cli, mem_ctx, &user_pol);
1698         if (!NT_STATUS_IS_OK(result)) goto done;
1699
1700         result = rpccli_samr_Close(cli, mem_ctx, &domain_pol);
1701         if (!NT_STATUS_IS_OK(result)) goto done;
1702
1703         result = rpccli_samr_Close(cli, mem_ctx, &connect_pol);
1704         if (!NT_STATUS_IS_OK(result)) goto done;
1705
1706  done:
1707         return result;
1708 }
1709
1710 /* Create domain group */
1711
1712 static NTSTATUS cmd_samr_create_dom_group(struct rpc_pipe_client *cli,
1713                                           TALLOC_CTX *mem_ctx,
1714                                           int argc, const char **argv)
1715 {
1716         struct policy_handle connect_pol, domain_pol, group_pol;
1717         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1718         struct lsa_String grp_name;
1719         uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
1720         uint32_t rid = 0;
1721
1722         if ((argc < 2) || (argc > 3)) {
1723                 printf("Usage: %s groupname [access mask]\n", argv[0]);
1724                 return NT_STATUS_OK;
1725         }
1726
1727         init_lsa_String(&grp_name, argv[1]);
1728
1729         if (argc > 2)
1730                 sscanf(argv[2], "%x", &access_mask);
1731
1732         /* Get sam policy handle */
1733
1734         result = rpccli_try_samr_connects(cli, mem_ctx,
1735                                           MAXIMUM_ALLOWED_ACCESS,
1736                                           &connect_pol);
1737
1738         if (!NT_STATUS_IS_OK(result))
1739                 goto done;
1740
1741         /* Get domain policy handle */
1742
1743         result = rpccli_samr_OpenDomain(cli, mem_ctx,
1744                                         &connect_pol,
1745                                         access_mask,
1746                                         &domain_sid,
1747                                         &domain_pol);
1748
1749         if (!NT_STATUS_IS_OK(result))
1750                 goto done;
1751
1752         /* Create domain user */
1753         result = rpccli_samr_CreateDomainGroup(cli, mem_ctx,
1754                                                &domain_pol,
1755                                                &grp_name,
1756                                                MAXIMUM_ALLOWED_ACCESS,
1757                                                &group_pol,
1758                                                &rid);
1759
1760         if (!NT_STATUS_IS_OK(result))
1761                 goto done;
1762
1763         result = rpccli_samr_Close(cli, mem_ctx, &group_pol);
1764         if (!NT_STATUS_IS_OK(result)) goto done;
1765
1766         result = rpccli_samr_Close(cli, mem_ctx, &domain_pol);
1767         if (!NT_STATUS_IS_OK(result)) goto done;
1768
1769         result = rpccli_samr_Close(cli, mem_ctx, &connect_pol);
1770         if (!NT_STATUS_IS_OK(result)) goto done;
1771
1772  done:
1773         return result;
1774 }
1775
1776 /* Create domain alias */
1777
1778 static NTSTATUS cmd_samr_create_dom_alias(struct rpc_pipe_client *cli,
1779                                           TALLOC_CTX *mem_ctx,
1780                                           int argc, const char **argv)
1781 {
1782         struct policy_handle connect_pol, domain_pol, alias_pol;
1783         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1784         struct lsa_String alias_name;
1785         uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
1786         uint32_t rid = 0;
1787
1788         if ((argc < 2) || (argc > 3)) {
1789                 printf("Usage: %s aliasname [access mask]\n", argv[0]);
1790                 return NT_STATUS_OK;
1791         }
1792
1793         init_lsa_String(&alias_name, argv[1]);
1794
1795         if (argc > 2)
1796                 sscanf(argv[2], "%x", &access_mask);
1797
1798         /* Get sam policy handle */
1799
1800         result = rpccli_try_samr_connects(cli, mem_ctx,
1801                                           MAXIMUM_ALLOWED_ACCESS,
1802                                           &connect_pol);
1803
1804         if (!NT_STATUS_IS_OK(result))
1805                 goto done;
1806
1807         /* Get domain policy handle */
1808
1809         result = rpccli_samr_OpenDomain(cli, mem_ctx,
1810                                         &connect_pol,
1811                                         access_mask,
1812                                         &domain_sid,
1813                                         &domain_pol);
1814
1815         if (!NT_STATUS_IS_OK(result))
1816                 goto done;
1817
1818         /* Create domain user */
1819
1820         result = rpccli_samr_CreateDomAlias(cli, mem_ctx,
1821                                             &domain_pol,
1822                                             &alias_name,
1823                                             MAXIMUM_ALLOWED_ACCESS,
1824                                             &alias_pol,
1825                                             &rid);
1826
1827         if (!NT_STATUS_IS_OK(result))
1828                 goto done;
1829
1830         result = rpccli_samr_Close(cli, mem_ctx, &alias_pol);
1831         if (!NT_STATUS_IS_OK(result)) goto done;
1832
1833         result = rpccli_samr_Close(cli, mem_ctx, &domain_pol);
1834         if (!NT_STATUS_IS_OK(result)) goto done;
1835
1836         result = rpccli_samr_Close(cli, mem_ctx, &connect_pol);
1837         if (!NT_STATUS_IS_OK(result)) goto done;
1838
1839  done:
1840         return result;
1841 }
1842
1843 /* Lookup sam names */
1844
1845 static NTSTATUS cmd_samr_lookup_names(struct rpc_pipe_client *cli,
1846                                       TALLOC_CTX *mem_ctx,
1847                                       int argc, const char **argv)
1848 {
1849         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1850         struct policy_handle connect_pol, domain_pol;
1851         uint32 num_names;
1852         struct samr_Ids rids, name_types;
1853         int i;
1854         struct lsa_String *names = NULL;;
1855
1856         if (argc < 3) {
1857                 printf("Usage: %s  domain|builtin name1 [name2 [name3] [...]]\n", argv[0]);
1858                 printf("check on the domain SID: S-1-5-21-x-y-z\n");
1859                 printf("or check on the builtin SID: S-1-5-32\n");
1860                 return NT_STATUS_OK;
1861         }
1862
1863         /* Get sam policy and domain handles */
1864
1865         result = rpccli_try_samr_connects(cli, mem_ctx,
1866                                           MAXIMUM_ALLOWED_ACCESS,
1867                                           &connect_pol);
1868
1869         if (!NT_STATUS_IS_OK(result))
1870                 goto done;
1871
1872         result = get_domain_handle(cli, mem_ctx, argv[1],
1873                                    &connect_pol,
1874                                    MAXIMUM_ALLOWED_ACCESS,
1875                                    &domain_sid,
1876                                    &domain_pol);
1877
1878         if (!NT_STATUS_IS_OK(result))
1879                 goto done;
1880
1881         /* Look up names */
1882
1883         num_names = argc - 2;
1884
1885         if ((names = TALLOC_ARRAY(mem_ctx, struct lsa_String, num_names)) == NULL) {
1886                 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
1887                 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
1888                 result = NT_STATUS_NO_MEMORY;
1889                 goto done;
1890         }
1891
1892         for (i = 0; i < num_names; i++) {
1893                 init_lsa_String(&names[i], argv[i + 2]);
1894         }
1895
1896         result = rpccli_samr_LookupNames(cli, mem_ctx,
1897                                          &domain_pol,
1898                                          num_names,
1899                                          names,
1900                                          &rids,
1901                                          &name_types);
1902
1903         if (!NT_STATUS_IS_OK(result))
1904                 goto done;
1905
1906         /* Display results */
1907
1908         for (i = 0; i < num_names; i++)
1909                 printf("name %s: 0x%x (%d)\n", names[i].string, rids.ids[i],
1910                        name_types.ids[i]);
1911
1912         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
1913         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
1914  done:
1915         return result;
1916 }
1917
1918 /* Lookup sam rids */
1919
1920 static NTSTATUS cmd_samr_lookup_rids(struct rpc_pipe_client *cli,
1921                                      TALLOC_CTX *mem_ctx,
1922                                      int argc, const char **argv)
1923 {
1924         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1925         struct policy_handle connect_pol, domain_pol;
1926         uint32_t num_rids, *rids;
1927         struct lsa_Strings names;
1928         struct samr_Ids types;
1929
1930         int i;
1931
1932         if (argc < 3) {
1933                 printf("Usage: %s domain|builtin rid1 [rid2 [rid3] [...]]\n", argv[0]);
1934                 return NT_STATUS_OK;
1935         }
1936
1937         /* Get sam policy and domain handles */
1938
1939         result = rpccli_try_samr_connects(cli, mem_ctx,
1940                                           MAXIMUM_ALLOWED_ACCESS,
1941                                           &connect_pol);
1942
1943         if (!NT_STATUS_IS_OK(result))
1944                 goto done;
1945
1946         result = get_domain_handle(cli, mem_ctx, argv[1],
1947                                    &connect_pol,
1948                                    MAXIMUM_ALLOWED_ACCESS,
1949                                    &domain_sid,
1950                                    &domain_pol);
1951
1952         if (!NT_STATUS_IS_OK(result))
1953                 goto done;
1954
1955         /* Look up rids */
1956
1957         num_rids = argc - 2;
1958
1959         if ((rids = TALLOC_ARRAY(mem_ctx, uint32, num_rids)) == NULL) {
1960                 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
1961                 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
1962                 result = NT_STATUS_NO_MEMORY;
1963                 goto done;
1964         }
1965
1966         for (i = 0; i < argc - 2; i++)
1967                 sscanf(argv[i + 2], "%i", &rids[i]);
1968
1969         result = rpccli_samr_LookupRids(cli, mem_ctx,
1970                                         &domain_pol,
1971                                         num_rids,
1972                                         rids,
1973                                         &names,
1974                                         &types);
1975
1976         if (!NT_STATUS_IS_OK(result) &&
1977             !NT_STATUS_EQUAL(result, STATUS_SOME_UNMAPPED))
1978                 goto done;
1979
1980         /* Display results */
1981
1982         for (i = 0; i < num_rids; i++) {
1983                 printf("rid 0x%x: %s (%d)\n",
1984                         rids[i], names.names[i].string, types.ids[i]);
1985         }
1986
1987         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
1988         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
1989  done:
1990         return result;
1991 }
1992
1993 /* Delete domain group */
1994
1995 static NTSTATUS cmd_samr_delete_dom_group(struct rpc_pipe_client *cli,
1996                                          TALLOC_CTX *mem_ctx,
1997                                          int argc, const char **argv)
1998 {
1999         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
2000         struct policy_handle connect_pol, domain_pol, group_pol;
2001         uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
2002
2003         if ((argc < 2) || (argc > 3)) {
2004                 printf("Usage: %s groupname\n", argv[0]);
2005                 return NT_STATUS_OK;
2006         }
2007
2008         if (argc > 2)
2009                 sscanf(argv[2], "%x", &access_mask);
2010
2011         /* Get sam policy and domain handles */
2012
2013         result = rpccli_try_samr_connects(cli, mem_ctx,
2014                                           MAXIMUM_ALLOWED_ACCESS,
2015                                           &connect_pol);
2016
2017         if (!NT_STATUS_IS_OK(result))
2018                 goto done;
2019
2020         result = rpccli_samr_OpenDomain(cli, mem_ctx,
2021                                         &connect_pol,
2022                                         MAXIMUM_ALLOWED_ACCESS,
2023                                         &domain_sid,
2024                                         &domain_pol);
2025
2026         if (!NT_STATUS_IS_OK(result))
2027                 goto done;
2028
2029         /* Get handle on group */
2030
2031         {
2032                 struct samr_Ids group_rids, name_types;
2033                 struct lsa_String lsa_acct_name;
2034
2035                 init_lsa_String(&lsa_acct_name, argv[1]);
2036
2037                 result = rpccli_samr_LookupNames(cli, mem_ctx,
2038                                                  &domain_pol,
2039                                                  1,
2040                                                  &lsa_acct_name,
2041                                                  &group_rids,
2042                                                  &name_types);
2043                 if (!NT_STATUS_IS_OK(result))
2044                         goto done;
2045
2046                 result = rpccli_samr_OpenGroup(cli, mem_ctx,
2047                                                &domain_pol,
2048                                                access_mask,
2049                                                group_rids.ids[0],
2050                                                &group_pol);
2051
2052                 if (!NT_STATUS_IS_OK(result))
2053                         goto done;
2054         }
2055
2056         /* Delete group */
2057
2058         result = rpccli_samr_DeleteDomainGroup(cli, mem_ctx,
2059                                                &group_pol);
2060
2061         if (!NT_STATUS_IS_OK(result))
2062                 goto done;
2063
2064         /* Display results */
2065
2066         rpccli_samr_Close(cli, mem_ctx, &group_pol);
2067         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
2068         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
2069
2070  done:
2071         return result;
2072 }
2073
2074 /* Delete domain user */
2075
2076 static NTSTATUS cmd_samr_delete_dom_user(struct rpc_pipe_client *cli,
2077                                          TALLOC_CTX *mem_ctx,
2078                                          int argc, const char **argv)
2079 {
2080         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
2081         struct policy_handle connect_pol, domain_pol, user_pol;
2082         uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
2083
2084         if ((argc < 2) || (argc > 3)) {
2085                 printf("Usage: %s username\n", argv[0]);
2086                 return NT_STATUS_OK;
2087         }
2088
2089         if (argc > 2)
2090                 sscanf(argv[2], "%x", &access_mask);
2091
2092         /* Get sam policy and domain handles */
2093
2094         result = rpccli_try_samr_connects(cli, mem_ctx,
2095                                           MAXIMUM_ALLOWED_ACCESS,
2096                                           &connect_pol);
2097
2098         if (!NT_STATUS_IS_OK(result))
2099                 goto done;
2100
2101         result = rpccli_samr_OpenDomain(cli, mem_ctx,
2102                                         &connect_pol,
2103                                         MAXIMUM_ALLOWED_ACCESS,
2104                                         &domain_sid,
2105                                         &domain_pol);
2106
2107         if (!NT_STATUS_IS_OK(result))
2108                 goto done;
2109
2110         /* Get handle on user */
2111
2112         {
2113                 struct samr_Ids user_rids, name_types;
2114                 struct lsa_String lsa_acct_name;
2115
2116                 init_lsa_String(&lsa_acct_name, argv[1]);
2117
2118                 result = rpccli_samr_LookupNames(cli, mem_ctx,
2119                                                  &domain_pol,
2120                                                  1,
2121                                                  &lsa_acct_name,
2122                                                  &user_rids,
2123                                                  &name_types);
2124
2125                 if (!NT_STATUS_IS_OK(result))
2126                         goto done;
2127
2128                 result = rpccli_samr_OpenUser(cli, mem_ctx,
2129                                               &domain_pol,
2130                                               access_mask,
2131                                               user_rids.ids[0],
2132                                               &user_pol);
2133
2134                 if (!NT_STATUS_IS_OK(result))
2135                         goto done;
2136         }
2137
2138         /* Delete user */
2139
2140         result = rpccli_samr_DeleteUser(cli, mem_ctx,
2141                                         &user_pol);
2142
2143         if (!NT_STATUS_IS_OK(result))
2144                 goto done;
2145
2146         /* Display results */
2147
2148         rpccli_samr_Close(cli, mem_ctx, &user_pol);
2149         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
2150         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
2151
2152  done:
2153         return result;
2154 }
2155
2156 /**********************************************************************
2157  * Query user security object
2158  */
2159 static NTSTATUS cmd_samr_query_sec_obj(struct rpc_pipe_client *cli,
2160                                     TALLOC_CTX *mem_ctx,
2161                                     int argc, const char **argv)
2162 {
2163         struct policy_handle connect_pol, domain_pol, user_pol, *pol;
2164         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
2165         uint32 sec_info = SECINFO_DACL;
2166         uint32 user_rid = 0;
2167         TALLOC_CTX *ctx = NULL;
2168         struct sec_desc_buf *sec_desc_buf=NULL;
2169         bool domain = False;
2170
2171         ctx=talloc_init("cmd_samr_query_sec_obj");
2172
2173         if ((argc < 1) || (argc > 3)) {
2174                 printf("Usage: %s [rid|-d] [sec_info]\n", argv[0]);
2175                 printf("\tSpecify rid for security on user, -d for security on domain\n");
2176                 talloc_destroy(ctx);
2177                 return NT_STATUS_OK;
2178         }
2179
2180         if (argc > 1) {
2181                 if (strcmp(argv[1], "-d") == 0)
2182                         domain = True;
2183                 else
2184                         sscanf(argv[1], "%i", &user_rid);
2185         }
2186
2187         if (argc == 3) {
2188                 sec_info = atoi(argv[2]);
2189         }
2190
2191         result = rpccli_try_samr_connects(cli, mem_ctx,
2192                                           MAXIMUM_ALLOWED_ACCESS,
2193                                           &connect_pol);
2194
2195         if (!NT_STATUS_IS_OK(result))
2196                 goto done;
2197
2198         if (domain || user_rid)
2199                 result = rpccli_samr_OpenDomain(cli, mem_ctx,
2200                                                 &connect_pol,
2201                                                 MAXIMUM_ALLOWED_ACCESS,
2202                                                 &domain_sid,
2203                                                 &domain_pol);
2204
2205         if (!NT_STATUS_IS_OK(result))
2206                 goto done;
2207
2208         if (user_rid)
2209                 result = rpccli_samr_OpenUser(cli, mem_ctx,
2210                                               &domain_pol,
2211                                               MAXIMUM_ALLOWED_ACCESS,
2212                                               user_rid,
2213                                               &user_pol);
2214
2215         if (!NT_STATUS_IS_OK(result))
2216                 goto done;
2217
2218         /* Pick which query pol to use */
2219
2220         pol = &connect_pol;
2221
2222         if (domain)
2223                 pol = &domain_pol;
2224
2225         if (user_rid)
2226                 pol = &user_pol;
2227
2228         /* Query SAM security object */
2229
2230         result = rpccli_samr_QuerySecurity(cli, mem_ctx,
2231                                            pol,
2232                                            sec_info,
2233                                            &sec_desc_buf);
2234
2235         if (!NT_STATUS_IS_OK(result))
2236                 goto done;
2237
2238         display_sec_desc(sec_desc_buf->sd);
2239
2240         rpccli_samr_Close(cli, mem_ctx, &user_pol);
2241         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
2242         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
2243 done:
2244         talloc_destroy(ctx);
2245         return result;
2246 }
2247
2248 static NTSTATUS cmd_samr_get_usrdom_pwinfo(struct rpc_pipe_client *cli,
2249                                            TALLOC_CTX *mem_ctx,
2250                                            int argc, const char **argv)
2251 {
2252         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
2253         struct policy_handle connect_pol, domain_pol, user_pol;
2254         struct samr_PwInfo info;
2255         uint32_t rid;
2256
2257         if (argc != 2) {
2258                 printf("Usage: %s rid\n", argv[0]);
2259                 return NT_STATUS_OK;
2260         }
2261
2262         sscanf(argv[1], "%i", &rid);
2263
2264         result = rpccli_try_samr_connects(cli, mem_ctx,
2265                                           MAXIMUM_ALLOWED_ACCESS,
2266                                           &connect_pol);
2267
2268         if (!NT_STATUS_IS_OK(result)) {
2269                 goto done;
2270         }
2271
2272         result = rpccli_samr_OpenDomain(cli, mem_ctx,
2273                                         &connect_pol,
2274                                         MAXIMUM_ALLOWED_ACCESS,
2275                                         &domain_sid,
2276                                         &domain_pol);
2277
2278         if (!NT_STATUS_IS_OK(result)) {
2279                 goto done;
2280         }
2281
2282         result = rpccli_samr_OpenUser(cli, mem_ctx,
2283                                       &domain_pol,
2284                                       MAXIMUM_ALLOWED_ACCESS,
2285                                       rid,
2286                                       &user_pol);
2287
2288         if (!NT_STATUS_IS_OK(result)) {
2289                 goto done;
2290         }
2291
2292         result = rpccli_samr_GetUserPwInfo(cli, mem_ctx, &user_pol, &info);
2293         if (NT_STATUS_IS_OK(result)) {
2294                 printf("min_password_length: %d\n", info.min_password_length);
2295                 printf("%s\n",
2296                         NDR_PRINT_STRUCT_STRING(mem_ctx,
2297                                 samr_PasswordProperties, &info.password_properties));
2298         }
2299
2300  done:
2301         rpccli_samr_Close(cli, mem_ctx, &user_pol);
2302         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
2303         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
2304
2305         return result;
2306 }
2307
2308 static NTSTATUS cmd_samr_get_dom_pwinfo(struct rpc_pipe_client *cli,
2309                                         TALLOC_CTX *mem_ctx,
2310                                         int argc, const char **argv)
2311 {
2312         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
2313         struct lsa_String domain_name;
2314         struct samr_PwInfo info;
2315
2316         if (argc < 1 || argc > 3) {
2317                 printf("Usage: %s <domain>\n", argv[0]);
2318                 return NT_STATUS_OK;
2319         }
2320
2321         init_lsa_String(&domain_name, argv[1]);
2322
2323         result = rpccli_samr_GetDomPwInfo(cli, mem_ctx, &domain_name, &info);
2324
2325         if (NT_STATUS_IS_OK(result)) {
2326                 printf("min_password_length: %d\n", info.min_password_length);
2327                 display_password_properties(info.password_properties);
2328         }
2329
2330         return result;
2331 }
2332
2333 /* Look up domain name */
2334
2335 static NTSTATUS cmd_samr_lookup_domain(struct rpc_pipe_client *cli,
2336                                        TALLOC_CTX *mem_ctx,
2337                                        int argc, const char **argv)
2338 {
2339         struct policy_handle connect_pol, domain_pol;
2340         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
2341         uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
2342         fstring sid_string;
2343         struct lsa_String domain_name;
2344         struct dom_sid *sid = NULL;
2345
2346         if (argc != 2) {
2347                 printf("Usage: %s domain_name\n", argv[0]);
2348                 return NT_STATUS_OK;
2349         }
2350
2351         init_lsa_String(&domain_name, argv[1]);
2352
2353         result = rpccli_try_samr_connects(cli, mem_ctx,
2354                                           access_mask,
2355                                           &connect_pol);
2356
2357         if (!NT_STATUS_IS_OK(result))
2358                 goto done;
2359
2360         result = rpccli_samr_OpenDomain(cli, mem_ctx,
2361                                         &connect_pol,
2362                                         access_mask,
2363                                         &domain_sid,
2364                                         &domain_pol);
2365
2366         if (!NT_STATUS_IS_OK(result))
2367                 goto done;
2368
2369         result = rpccli_samr_LookupDomain(cli, mem_ctx,
2370                                           &connect_pol,
2371                                           &domain_name,
2372                                           &sid);
2373
2374         if (NT_STATUS_IS_OK(result)) {
2375                 sid_to_fstring(sid_string, sid);
2376                 printf("SAMR_LOOKUP_DOMAIN: Domain Name: %s Domain SID: %s\n",
2377                        argv[1], sid_string);
2378         }
2379
2380         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
2381         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
2382 done:
2383         return result;
2384 }
2385
2386 /* Change user password */
2387
2388 static NTSTATUS cmd_samr_chgpasswd(struct rpc_pipe_client *cli,
2389                                    TALLOC_CTX *mem_ctx,
2390                                    int argc, const char **argv)
2391 {
2392         struct policy_handle connect_pol, domain_pol, user_pol;
2393         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
2394         const char *user, *oldpass, *newpass;
2395         uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
2396         struct samr_Ids rids, types;
2397         struct lsa_String lsa_acct_name;
2398
2399         if (argc < 3) {
2400                 printf("Usage: %s username oldpass newpass\n", argv[0]);
2401                 return NT_STATUS_INVALID_PARAMETER;
2402         }
2403
2404         user = argv[1];
2405         oldpass = argv[2];
2406         newpass = argv[3];
2407
2408         /* Get sam policy handle */
2409
2410         result = rpccli_try_samr_connects(cli, mem_ctx,
2411                                           MAXIMUM_ALLOWED_ACCESS,
2412                                           &connect_pol);
2413
2414         if (!NT_STATUS_IS_OK(result)) {
2415                 goto done;
2416         }
2417
2418         /* Get domain policy handle */
2419
2420         result = rpccli_samr_OpenDomain(cli, mem_ctx,
2421                                         &connect_pol,
2422                                         access_mask,
2423                                         &domain_sid,
2424                                         &domain_pol);
2425
2426         if (!NT_STATUS_IS_OK(result)) {
2427                 goto done;
2428         }
2429
2430         init_lsa_String(&lsa_acct_name, user);
2431
2432         result = rpccli_samr_LookupNames(cli, mem_ctx,
2433                                          &domain_pol,
2434                                          1,
2435                                          &lsa_acct_name,
2436                                          &rids,
2437                                          &types);
2438
2439         if (!NT_STATUS_IS_OK(result)) {
2440                 goto done;
2441         }
2442
2443         result = rpccli_samr_OpenUser(cli, mem_ctx,
2444                                       &domain_pol,
2445                                       access_mask,
2446                                       rids.ids[0],
2447                                       &user_pol);
2448
2449         if (!NT_STATUS_IS_OK(result)) {
2450                 goto done;
2451         }
2452
2453         /* Change user password */
2454         result = rpccli_samr_chgpasswd_user(cli, mem_ctx,
2455                                             &user_pol,
2456                                             newpass,
2457                                             oldpass);
2458
2459         if (!NT_STATUS_IS_OK(result)) {
2460                 goto done;
2461         }
2462
2463  done:
2464         if (is_valid_policy_hnd(&user_pol)) {
2465                 rpccli_samr_Close(cli, mem_ctx, &user_pol);
2466         }
2467         if (is_valid_policy_hnd(&domain_pol)) {
2468                 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
2469         }
2470         if (is_valid_policy_hnd(&connect_pol)) {
2471                 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
2472         }
2473
2474         return result;
2475 }
2476
2477
2478 /* Change user password */
2479
2480 static NTSTATUS cmd_samr_chgpasswd2(struct rpc_pipe_client *cli,
2481                                     TALLOC_CTX *mem_ctx,
2482                                     int argc, const char **argv)
2483 {
2484         struct policy_handle connect_pol, domain_pol;
2485         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
2486         const char *user, *oldpass, *newpass;
2487         uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
2488
2489         if (argc < 3) {
2490                 printf("Usage: %s username oldpass newpass\n", argv[0]);
2491                 return NT_STATUS_INVALID_PARAMETER;
2492         }
2493
2494         user = argv[1];
2495         oldpass = argv[2];
2496         newpass = argv[3];
2497
2498         /* Get sam policy handle */
2499
2500         result = rpccli_try_samr_connects(cli, mem_ctx,
2501                                           MAXIMUM_ALLOWED_ACCESS,
2502                                           &connect_pol);
2503
2504         if (!NT_STATUS_IS_OK(result))
2505                 goto done;
2506
2507         /* Get domain policy handle */
2508
2509         result = rpccli_samr_OpenDomain(cli, mem_ctx,
2510                                         &connect_pol,
2511                                         access_mask,
2512                                         &domain_sid,
2513                                         &domain_pol);
2514
2515         if (!NT_STATUS_IS_OK(result))
2516                 goto done;
2517
2518         /* Change user password */
2519         result = rpccli_samr_chgpasswd_user2(cli, mem_ctx, user, newpass, oldpass);
2520
2521         if (!NT_STATUS_IS_OK(result))
2522                 goto done;
2523
2524         result = rpccli_samr_Close(cli, mem_ctx, &domain_pol);
2525         if (!NT_STATUS_IS_OK(result)) goto done;
2526
2527         result = rpccli_samr_Close(cli, mem_ctx, &connect_pol);
2528         if (!NT_STATUS_IS_OK(result)) goto done;
2529
2530  done:
2531         return result;
2532 }
2533
2534
2535 /* Change user password */
2536
2537 static NTSTATUS cmd_samr_chgpasswd3(struct rpc_pipe_client *cli,
2538                                     TALLOC_CTX *mem_ctx,
2539                                     int argc, const char **argv)
2540 {
2541         struct policy_handle connect_pol, domain_pol;
2542         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
2543         const char *user, *oldpass, *newpass;
2544         uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
2545         struct samr_DomInfo1 *info = NULL;
2546         struct userPwdChangeFailureInformation *reject = NULL;
2547
2548         if (argc < 3) {
2549                 printf("Usage: %s username oldpass newpass\n", argv[0]);
2550                 return NT_STATUS_INVALID_PARAMETER;
2551         }
2552
2553         user = argv[1];
2554         oldpass = argv[2];
2555         newpass = argv[3];
2556
2557         /* Get sam policy handle */
2558
2559         result = rpccli_try_samr_connects(cli, mem_ctx,
2560                                           MAXIMUM_ALLOWED_ACCESS,
2561                                           &connect_pol);
2562
2563         if (!NT_STATUS_IS_OK(result))
2564                 goto done;
2565
2566         /* Get domain policy handle */
2567
2568         result = rpccli_samr_OpenDomain(cli, mem_ctx,
2569                                         &connect_pol,
2570                                         access_mask,
2571                                         &domain_sid,
2572                                         &domain_pol);
2573
2574         if (!NT_STATUS_IS_OK(result))
2575                 goto done;
2576
2577         /* Change user password */
2578         result = rpccli_samr_chgpasswd_user3(cli, mem_ctx,
2579                                              user,
2580                                              newpass,
2581                                              oldpass,
2582                                              &info,
2583                                              &reject);
2584
2585         if (NT_STATUS_EQUAL(result, NT_STATUS_PASSWORD_RESTRICTION)) {
2586
2587                 display_sam_dom_info_1(info);
2588
2589                 switch (reject->extendedFailureReason) {
2590                         case SAM_PWD_CHANGE_PASSWORD_TOO_SHORT:
2591                                 d_printf("SAM_PWD_CHANGE_PASSWORD_TOO_SHORT\n");
2592                                 break;
2593                         case SAM_PWD_CHANGE_PWD_IN_HISTORY:
2594                                 d_printf("SAM_PWD_CHANGE_PWD_IN_HISTORY\n");
2595                                 break;
2596                         case SAM_PWD_CHANGE_NOT_COMPLEX:
2597                                 d_printf("SAM_PWD_CHANGE_NOT_COMPLEX\n");
2598                                 break;
2599                         default:
2600                                 d_printf("unknown reject reason: %d\n",
2601                                         reject->extendedFailureReason);
2602                                 break;
2603                 }
2604         }
2605
2606         if (!NT_STATUS_IS_OK(result))
2607                 goto done;
2608
2609         result = rpccli_samr_Close(cli, mem_ctx, &domain_pol);
2610         if (!NT_STATUS_IS_OK(result)) goto done;
2611
2612         result = rpccli_samr_Close(cli, mem_ctx, &connect_pol);
2613         if (!NT_STATUS_IS_OK(result)) goto done;
2614
2615  done:
2616         return result;
2617 }
2618
2619 static NTSTATUS cmd_samr_setuserinfo_int(struct rpc_pipe_client *cli,
2620                                          TALLOC_CTX *mem_ctx,
2621                                          int argc, const char **argv,
2622                                          int opcode)
2623 {
2624         struct policy_handle connect_pol, domain_pol, user_pol;
2625         NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
2626         const char *user, *param;
2627         uint32_t access_mask = MAXIMUM_ALLOWED_ACCESS;
2628         uint32_t level;
2629         uint32_t user_rid;
2630         union samr_UserInfo info;
2631         struct samr_CryptPassword pwd_buf;
2632         struct samr_CryptPasswordEx pwd_buf_ex;
2633         uint8_t nt_hash[16];
2634         uint8_t lm_hash[16];
2635         DATA_BLOB session_key;
2636         uint8_t password_expired = 0;
2637
2638         if (argc < 4) {
2639                 printf("Usage: %s username level password [password_expired]\n",
2640                         argv[0]);
2641                 return NT_STATUS_INVALID_PARAMETER;
2642         }
2643
2644         user = argv[1];
2645         level = atoi(argv[2]);
2646         param = argv[3];
2647
2648         if (argc >= 5) {
2649                 password_expired = atoi(argv[4]);
2650         }
2651
2652         status = cli_get_session_key(mem_ctx, cli, &session_key);
2653         if (!NT_STATUS_IS_OK(status)) {
2654                 return status;
2655         }
2656
2657         init_samr_CryptPassword(param, &session_key, &pwd_buf);
2658         init_samr_CryptPasswordEx(param, &session_key, &pwd_buf_ex);
2659         nt_lm_owf_gen(param, nt_hash, lm_hash);
2660
2661         switch (level) {
2662         case 18:
2663                 {
2664                         DATA_BLOB in,out;
2665                         in = data_blob_const(nt_hash, 16);
2666                         out = data_blob_talloc_zero(mem_ctx, 16);
2667                         sess_crypt_blob(&out, &in, &session_key, true);
2668                         memcpy(nt_hash, out.data, out.length);
2669                 }
2670                 {
2671                         DATA_BLOB in,out;
2672                         in = data_blob_const(lm_hash, 16);
2673                         out = data_blob_talloc_zero(mem_ctx, 16);
2674                         sess_crypt_blob(&out, &in, &session_key, true);
2675                         memcpy(lm_hash, out.data, out.length);
2676                 }
2677
2678                 memcpy(info.info18.nt_pwd.hash, nt_hash, 16);
2679                 memcpy(info.info18.lm_pwd.hash, lm_hash, 16);
2680                 info.info18.nt_pwd_active       = true;
2681                 info.info18.lm_pwd_active       = true;
2682                 info.info18.password_expired    = password_expired;
2683
2684                 break;
2685         case 21:
2686                 ZERO_STRUCT(info.info21);
2687
2688                 info.info21.fields_present = SAMR_FIELD_NT_PASSWORD_PRESENT |
2689                                              SAMR_FIELD_LM_PASSWORD_PRESENT;
2690                 if (argc >= 5) {
2691                         info.info21.fields_present |= SAMR_FIELD_EXPIRED_FLAG;
2692                         info.info21.password_expired = password_expired;
2693                 }
2694
2695                 info.info21.lm_password_set = true;
2696                 info.info21.lm_owf_password.length = 16;
2697                 info.info21.lm_owf_password.size = 16;
2698
2699                 info.info21.nt_password_set = true;
2700                 info.info21.nt_owf_password.length = 16;
2701                 info.info21.nt_owf_password.size = 16;
2702
2703                 {
2704                         DATA_BLOB in,out;
2705                         in = data_blob_const(nt_hash, 16);
2706                         out = data_blob_talloc_zero(mem_ctx, 16);
2707                         sess_crypt_blob(&out, &in, &session_key, true);
2708                         info.info21.nt_owf_password.array =
2709                                 (uint16_t *)talloc_memdup(mem_ctx, out.data, 16);
2710                 }
2711                 {
2712                         DATA_BLOB in,out;
2713                         in = data_blob_const(lm_hash, 16);
2714                         out = data_blob_talloc_zero(mem_ctx, 16);
2715                         sess_crypt_blob(&out, &in, &session_key, true);
2716                         info.info21.lm_owf_password.array =
2717                                 (uint16_t *)talloc_memdup(mem_ctx, out.data, 16);
2718                 }
2719
2720                 break;
2721         case 23:
2722                 ZERO_STRUCT(info.info23);
2723
2724                 info.info23.info.fields_present = SAMR_FIELD_NT_PASSWORD_PRESENT |
2725                                                   SAMR_FIELD_LM_PASSWORD_PRESENT;
2726                 if (argc >= 5) {
2727                         info.info23.info.fields_present |= SAMR_FIELD_EXPIRED_FLAG;
2728                         info.info23.info.password_expired = password_expired;
2729                 }
2730
2731                 info.info23.password = pwd_buf;
2732
2733                 break;
2734         case 24:
2735                 info.info24.password            = pwd_buf;
2736                 info.info24.password_expired    = password_expired;
2737
2738                 break;
2739         case 25:
2740                 ZERO_STRUCT(info.info25);
2741
2742                 info.info25.info.fields_present = SAMR_FIELD_NT_PASSWORD_PRESENT |
2743                                                   SAMR_FIELD_LM_PASSWORD_PRESENT;
2744                 if (argc >= 5) {
2745                         info.info25.info.fields_present |= SAMR_FIELD_EXPIRED_FLAG;
2746                         info.info25.info.password_expired = password_expired;
2747                 }
2748
2749                 info.info25.password = pwd_buf_ex;
2750
2751                 break;
2752         case 26:
2753                 info.info26.password            = pwd_buf_ex;
2754                 info.info26.password_expired    = password_expired;
2755
2756                 break;
2757         default:
2758                 return NT_STATUS_INVALID_INFO_CLASS;
2759         }
2760
2761         /* Get sam policy handle */
2762
2763         status = rpccli_try_samr_connects(cli, mem_ctx,
2764                                           MAXIMUM_ALLOWED_ACCESS,
2765                                           &connect_pol);
2766
2767         if (!NT_STATUS_IS_OK(status))
2768                 goto done;
2769
2770         /* Get domain policy handle */
2771
2772         status = rpccli_samr_OpenDomain(cli, mem_ctx,
2773                                         &connect_pol,
2774                                         access_mask,
2775                                         &domain_sid,
2776                                         &domain_pol);
2777
2778         if (!NT_STATUS_IS_OK(status))
2779                 goto done;
2780
2781         user_rid = strtol(user, NULL, 0);
2782         if (user_rid) {
2783                 status = rpccli_samr_OpenUser(cli, mem_ctx,
2784                                               &domain_pol,
2785                                               access_mask,
2786                                               user_rid,
2787                                               &user_pol);
2788         }
2789
2790         if (NT_STATUS_EQUAL(status, NT_STATUS_NO_SUCH_USER) ||
2791             (user_rid == 0)) {
2792
2793                 /* Probably this was a user name, try lookupnames */
2794                 struct samr_Ids rids, types;
2795                 struct lsa_String lsa_acct_name;
2796
2797                 init_lsa_String(&lsa_acct_name, user);
2798
2799                 status = rpccli_samr_LookupNames(cli, mem_ctx,
2800                                                  &domain_pol,
2801                                                  1,
2802                                                  &lsa_acct_name,
2803                                                  &rids,
2804                                                  &types);
2805                 if (!NT_STATUS_IS_OK(status)) {
2806                         return status;
2807                 }
2808
2809                 status = rpccli_samr_OpenUser(cli, mem_ctx,
2810                                               &domain_pol,
2811                                               access_mask,
2812                                               rids.ids[0],
2813                                               &user_pol);
2814                 if (!NT_STATUS_IS_OK(status)) {
2815                         return status;
2816                 }
2817         }
2818
2819         switch (opcode) {
2820         case NDR_SAMR_SETUSERINFO:
2821                 status = rpccli_samr_SetUserInfo(cli, mem_ctx,
2822                                                  &user_pol,
2823                                                  level,
2824                                                  &info);
2825                 break;
2826         case NDR_SAMR_SETUSERINFO2:
2827                 status = rpccli_samr_SetUserInfo2(cli, mem_ctx,
2828                                                   &user_pol,
2829                                                   level,
2830                                                   &info);
2831                 break;
2832         default:
2833                 return NT_STATUS_INVALID_PARAMETER;
2834         }
2835
2836  done:
2837         return status;
2838 }
2839
2840 static NTSTATUS cmd_samr_setuserinfo(struct rpc_pipe_client *cli,
2841                                      TALLOC_CTX *mem_ctx,
2842                                      int argc, const char **argv)
2843 {
2844         return cmd_samr_setuserinfo_int(cli, mem_ctx, argc, argv,
2845                                         NDR_SAMR_SETUSERINFO);
2846 }
2847
2848 static NTSTATUS cmd_samr_setuserinfo2(struct rpc_pipe_client *cli,
2849                                       TALLOC_CTX *mem_ctx,
2850                                       int argc, const char **argv)
2851 {
2852         return cmd_samr_setuserinfo_int(cli, mem_ctx, argc, argv,
2853                                         NDR_SAMR_SETUSERINFO2);
2854 }
2855
2856 static NTSTATUS cmd_samr_get_dispinfo_idx(struct rpc_pipe_client *cli,
2857                                           TALLOC_CTX *mem_ctx,
2858                                           int argc, const char **argv)
2859 {
2860         NTSTATUS status;
2861         struct policy_handle connect_handle;
2862         struct policy_handle domain_handle;
2863         uint16_t level = 1;
2864         struct lsa_String name;
2865         uint32_t idx = 0;
2866
2867         if (argc < 2 || argc > 3) {
2868                 printf("Usage: %s name level\n", argv[0]);
2869                 return NT_STATUS_INVALID_PARAMETER;
2870         }
2871
2872         init_lsa_String(&name, argv[1]);
2873
2874         if (argc == 3) {
2875                 level = atoi(argv[2]);
2876         }
2877
2878         status = rpccli_try_samr_connects(cli, mem_ctx,
2879                                           SEC_FLAG_MAXIMUM_ALLOWED,
2880                                           &connect_handle);
2881
2882         if (!NT_STATUS_IS_OK(status)) {
2883                 goto done;
2884         }
2885
2886         status = rpccli_samr_OpenDomain(cli, mem_ctx,
2887                                         &connect_handle,
2888                                         SEC_FLAG_MAXIMUM_ALLOWED,
2889                                         &domain_sid,
2890                                         &domain_handle);
2891
2892         if (!NT_STATUS_IS_OK(status))
2893                 goto done;
2894
2895
2896         status = rpccli_samr_GetDisplayEnumerationIndex(cli, mem_ctx,
2897                                                         &domain_handle,
2898                                                         level,
2899                                                         &name,
2900                                                         &idx);
2901
2902         if (NT_STATUS_IS_OK(status) ||
2903             NT_STATUS_EQUAL(status, NT_STATUS_NO_MORE_ENTRIES)) {
2904                 printf("idx: %d (0x%08x)\n", idx, idx);
2905         }
2906  done:
2907
2908         if (is_valid_policy_hnd(&domain_handle)) {
2909                 rpccli_samr_Close(cli, mem_ctx, &domain_handle);
2910         }
2911         if (is_valid_policy_hnd(&connect_handle)) {
2912                 rpccli_samr_Close(cli, mem_ctx, &connect_handle);
2913         }
2914
2915         return status;
2916
2917 }
2918 /* List of commands exported by this module */
2919
2920 struct cmd_set samr_commands[] = {
2921
2922         { "SAMR" },
2923
2924         { "queryuser",  RPC_RTYPE_NTSTATUS, cmd_samr_query_user,                NULL, &ndr_table_samr.syntax_id, NULL,  "Query user info",         "" },
2925         { "querygroup",         RPC_RTYPE_NTSTATUS, cmd_samr_query_group,               NULL, &ndr_table_samr.syntax_id, NULL,  "Query group info",        "" },
2926         { "queryusergroups",    RPC_RTYPE_NTSTATUS, cmd_samr_query_usergroups,  NULL, &ndr_table_samr.syntax_id, NULL,  "Query user groups",       "" },
2927         { "queryuseraliases",   RPC_RTYPE_NTSTATUS, cmd_samr_query_useraliases,         NULL, &ndr_table_samr.syntax_id, NULL,  "Query user aliases",      "" },
2928         { "querygroupmem",      RPC_RTYPE_NTSTATUS, cmd_samr_query_groupmem,    NULL, &ndr_table_samr.syntax_id, NULL,  "Query group membership",  "" },
2929         { "queryaliasmem",      RPC_RTYPE_NTSTATUS, cmd_samr_query_aliasmem,    NULL, &ndr_table_samr.syntax_id, NULL,  "Query alias membership",  "" },
2930         { "queryaliasinfo",     RPC_RTYPE_NTSTATUS, cmd_samr_query_aliasinfo,   NULL, &ndr_table_samr.syntax_id, NULL,  "Query alias info",       "" },
2931         { "deletealias",        RPC_RTYPE_NTSTATUS, cmd_samr_delete_alias,      NULL, &ndr_table_samr.syntax_id, NULL,  "Delete an alias",  "" },
2932         { "querydispinfo",      RPC_RTYPE_NTSTATUS, cmd_samr_query_dispinfo,    NULL, &ndr_table_samr.syntax_id, NULL,  "Query display info",      "" },
2933         { "querydispinfo2",     RPC_RTYPE_NTSTATUS, cmd_samr_query_dispinfo2,   NULL, &ndr_table_samr.syntax_id, NULL,  "Query display info",      "" },
2934         { "querydispinfo3",     RPC_RTYPE_NTSTATUS, cmd_samr_query_dispinfo3,   NULL, &ndr_table_samr.syntax_id, NULL,  "Query display info",      "" },
2935         { "querydominfo",       RPC_RTYPE_NTSTATUS, cmd_samr_query_dominfo,     NULL, &ndr_table_samr.syntax_id, NULL,  "Query domain info",       "" },
2936         { "enumdomusers",       RPC_RTYPE_NTSTATUS, cmd_samr_enum_dom_users,       NULL, &ndr_table_samr.syntax_id, NULL,       "Enumerate domain users", "" },
2937         { "enumdomgroups",      RPC_RTYPE_NTSTATUS, cmd_samr_enum_dom_groups,       NULL, &ndr_table_samr.syntax_id, NULL,      "Enumerate domain groups", "" },
2938         { "enumalsgroups",      RPC_RTYPE_NTSTATUS, cmd_samr_enum_als_groups,       NULL, &ndr_table_samr.syntax_id, NULL,      "Enumerate alias groups",  "" },
2939         { "enumdomains",        RPC_RTYPE_NTSTATUS, cmd_samr_enum_domains,          NULL, &ndr_table_samr.syntax_id, NULL,      "Enumerate domains",  "" },
2940
2941         { "createdomuser",      RPC_RTYPE_NTSTATUS, cmd_samr_create_dom_user,       NULL, &ndr_table_samr.syntax_id, NULL,      "Create domain user",      "" },
2942         { "createdomgroup",     RPC_RTYPE_NTSTATUS, cmd_samr_create_dom_group,      NULL, &ndr_table_samr.syntax_id, NULL,      "Create domain group",     "" },
2943         { "createdomalias",     RPC_RTYPE_NTSTATUS, cmd_samr_create_dom_alias,      NULL, &ndr_table_samr.syntax_id, NULL,      "Create domain alias",     "" },
2944         { "samlookupnames",     RPC_RTYPE_NTSTATUS, cmd_samr_lookup_names,          NULL, &ndr_table_samr.syntax_id, NULL,      "Look up names",           "" },
2945         { "samlookuprids",      RPC_RTYPE_NTSTATUS, cmd_samr_lookup_rids,           NULL, &ndr_table_samr.syntax_id, NULL,      "Look up names",           "" },
2946         { "deletedomgroup",     RPC_RTYPE_NTSTATUS, cmd_samr_delete_dom_group,      NULL, &ndr_table_samr.syntax_id, NULL,      "Delete domain group",     "" },
2947         { "deletedomuser",      RPC_RTYPE_NTSTATUS, cmd_samr_delete_dom_user,       NULL, &ndr_table_samr.syntax_id, NULL,      "Delete domain user",      "" },
2948         { "samquerysecobj",     RPC_RTYPE_NTSTATUS, cmd_samr_query_sec_obj,         NULL, &ndr_table_samr.syntax_id, NULL, "Query SAMR security object",   "" },
2949         { "getdompwinfo",       RPC_RTYPE_NTSTATUS, cmd_samr_get_dom_pwinfo,        NULL, &ndr_table_samr.syntax_id, NULL, "Retrieve domain password info", "" },
2950         { "getusrdompwinfo",    RPC_RTYPE_NTSTATUS, cmd_samr_get_usrdom_pwinfo,     NULL, &ndr_table_samr.syntax_id, NULL, "Retrieve user domain password info", "" },
2951
2952         { "lookupdomain",       RPC_RTYPE_NTSTATUS, cmd_samr_lookup_domain,         NULL, &ndr_table_samr.syntax_id, NULL, "Lookup Domain Name", "" },
2953         { "chgpasswd",          RPC_RTYPE_NTSTATUS, cmd_samr_chgpasswd,             NULL, &ndr_table_samr.syntax_id, NULL, "Change user password", "" },
2954         { "chgpasswd2",         RPC_RTYPE_NTSTATUS, cmd_samr_chgpasswd2,            NULL, &ndr_table_samr.syntax_id, NULL, "Change user password", "" },
2955         { "chgpasswd3",         RPC_RTYPE_NTSTATUS, cmd_samr_chgpasswd3,            NULL, &ndr_table_samr.syntax_id, NULL, "Change user password", "" },
2956         { "getdispinfoidx",     RPC_RTYPE_NTSTATUS, cmd_samr_get_dispinfo_idx,      NULL, &ndr_table_samr.syntax_id, NULL, "Get Display Information Index", "" },
2957         { "setuserinfo",        RPC_RTYPE_NTSTATUS, cmd_samr_setuserinfo,           NULL, &ndr_table_samr.syntax_id, NULL, "Set user info", "" },
2958         { "setuserinfo2",       RPC_RTYPE_NTSTATUS, cmd_samr_setuserinfo2,          NULL, &ndr_table_samr.syntax_id, NULL, "Set user info2", "" },
2959         { NULL }
2960 };