source3/rpcclient/cmd_samr.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    NT Domain Authentication SMB / MSRPC client
   5    Copyright (C) Andrew Tridgell 1994-1997
   6    Copyright (C) Luke Kenneth Casson Leighton 1996-1997
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23
  24
  25 #ifdef SYSLOG
  26 #undef SYSLOG
  27 #endif
  28
  29 #include "includes.h"
  30 #include "nterr.h"
  31
  32 extern int DEBUGLEVEL;
  33
  34 #define DEBUG_TESTING
  35
  36 extern struct cli_state *smb_cli;
  37
  38 extern FILE* out_hnd;
  39
  40
  41 /****************************************************************************
  42 SAM password change
  43 ****************************************************************************/
  44 void cmd_sam_ntchange_pwd(struct client_info *info)
  45 {
  46         fstring srv_name;
  47         fstring domain;
  48         fstring sid;
  49         char *new_passwd;
  50         BOOL res = True;
  51         char nt_newpass[516];
  52         uchar nt_hshhash[16];
  53         uchar nt_newhash[16];
  54         uchar nt_oldhash[16];
  55         char lm_newpass[516];
  56         uchar lm_newhash[16];
  57         uchar lm_hshhash[16];
  58         uchar lm_oldhash[16];
  59
  60         sid_to_string(sid, &info->dom.level5_sid);
  61         fstrcpy(domain, info->dom.level5_dom);
  62
  63         fstrcpy(srv_name, "\\\\");
  64         fstrcat(srv_name, info->dest_host);
  65         strupper(srv_name);
  66
  67         fprintf(out_hnd, "SAM NT Password Change\n");
  68
  69 #if 0
  70         struct pwd_info new_pwd;
  71         pwd_read(&new_pwd, "New Password (ONCE: this is test code!):", True);
  72 #endif
  73         new_passwd = (char*)getpass("New Password (ONCE ONLY - get it right :-)");
  74
  75         nt_lm_owf_gen(new_passwd, lm_newhash, nt_newhash);
  76         pwd_get_lm_nt_16(&(smb_cli->pwd), lm_oldhash, nt_oldhash );
  77         make_oem_passwd_hash(nt_newpass, new_passwd, nt_oldhash, True);
  78         make_oem_passwd_hash(lm_newpass, new_passwd, lm_oldhash, True);
  79         E_old_pw_hash(lm_newhash, lm_oldhash, lm_hshhash);
  80         E_old_pw_hash(lm_newhash, nt_oldhash, nt_hshhash);
  81
  82         cli_nt_set_ntlmssp_flgs(smb_cli,
  83                                     NTLMSSP_NEGOTIATE_UNICODE |
  84                                     NTLMSSP_NEGOTIATE_OEM |
  85                                     NTLMSSP_NEGOTIATE_SIGN |
  86                                     NTLMSSP_NEGOTIATE_SEAL |
  87                                     NTLMSSP_NEGOTIATE_LM_KEY |
  88                                     NTLMSSP_NEGOTIATE_NTLM |
  89                                     NTLMSSP_NEGOTIATE_ALWAYS_SIGN |
  90                                     NTLMSSP_NEGOTIATE_00001000 |
  91                                     NTLMSSP_NEGOTIATE_00002000);
  92
  93         /* open SAMR session.  */
  94         res = res ? cli_nt_session_open(smb_cli, PIPE_SAMR) : False;
  95
  96         /* establish a connection. */
  97         res = res ? do_samr_unknown_38(smb_cli, srv_name) : False;
  98
  99         /* establish a connection. */
 100         res = res ? do_samr_chgpasswd_user(smb_cli,
 101                                            srv_name, smb_cli->user_name,
 102                                            nt_newpass, nt_hshhash,
 103                                            lm_newpass, lm_hshhash) : False;
 104         /* close the session */
 105         cli_nt_session_close(smb_cli);
 106
 107         if (res)
 108         {
 109                 fprintf(out_hnd, "NT Password changed OK\n");
 110         }
 111         else
 112         {
 113                 fprintf(out_hnd, "NT Password change FAILED\n");
 114         }
 115 }
 116
 117
 118 /****************************************************************************
 119 experimental SAM encryted rpc test connection
 120 ****************************************************************************/
 121 void cmd_sam_test(struct client_info *info)
 122 {
 123         fstring srv_name;
 124         fstring domain;
 125         fstring sid;
 126         BOOL res = True;
 127
 128         sid_to_string(sid, &info->dom.level5_sid);
 129         fstrcpy(domain, info->dom.level5_dom);
 130
 131 /*
 132         if (strlen(sid) == 0)
 133         {
 134                 fprintf(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
 135                 return;
 136         }
 137 */
 138         fstrcpy(srv_name, "\\\\");
 139         fstrcat(srv_name, info->dest_host);
 140         strupper(srv_name);
 141
 142         fprintf(out_hnd, "SAM Encryption Test\n");
 143
 144         cli_nt_set_ntlmssp_flgs(smb_cli,
 145                                     NTLMSSP_NEGOTIATE_UNICODE |
 146                                     NTLMSSP_NEGOTIATE_OEM |
 147                                     NTLMSSP_NEGOTIATE_SIGN |
 148                                     NTLMSSP_NEGOTIATE_SEAL |
 149                                     NTLMSSP_NEGOTIATE_LM_KEY |
 150                                     NTLMSSP_NEGOTIATE_NTLM |
 151                                     NTLMSSP_NEGOTIATE_ALWAYS_SIGN |
 152                                     NTLMSSP_NEGOTIATE_00001000 |
 153                                     NTLMSSP_NEGOTIATE_00002000);
 154
 155         /* open SAMR session.  */
 156         res = res ? cli_nt_session_open(smb_cli, PIPE_SAMR) : False;
 157
 158         /* establish a connection. */
 159         res = res ? do_samr_unknown_38(smb_cli, srv_name) : False;
 160
 161         /* close the session */
 162         cli_nt_session_close(smb_cli);
 163
 164         if (res)
 165         {
 166                 DEBUG(5,("cmd_sam_test: succeeded\n"));
 167         }
 168         else
 169         {
 170                 DEBUG(5,("cmd_sam_test: failed\n"));
 171         }
 172 }
 173
 174
 175 /****************************************************************************
 176 experimental SAM users enum.
 177 ****************************************************************************/
 178 void cmd_sam_enum_users(struct client_info *info)
 179 {
 180         fstring srv_name;
 181         fstring domain;
 182         fstring sid;
 183         DOM_SID sid1;
 184         int user_idx;
 185         BOOL res = True;
 186         BOOL request_user_info  = False;
 187         BOOL request_group_info = False;
 188         BOOL request_alias_info = False;
 189         uint16 num_entries = 0;
 190         uint16 unk_0 = 0x0;
 191         uint16 acb_mask = 0;
 192         uint16 unk_1 = 0x0;
 193         uint32 admin_rid = 0x304; /* absolutely no idea. */
 194         fstring tmp;
 195         int i;
 196
 197         sid_copy(&sid1, &info->dom.level5_sid);
 198         sid_to_string(sid, &sid1);
 199         fstrcpy(domain, info->dom.level5_dom);
 200
 201         if (sid1.num_auths == 0)
 202         {
 203                 fprintf(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
 204                 return;
 205         }
 206
 207
 208         fstrcpy(srv_name, "\\\\");
 209         fstrcat(srv_name, info->dest_host);
 210         strupper(srv_name);
 211
 212         for (i = 0; i < 3; i++)
 213         {
 214                 /* a bad way to do token parsing... */
 215                 if (next_token(NULL, tmp, NULL, sizeof(tmp)))
 216                 {
 217                         request_user_info  |= strequal(tmp, "-u");
 218                         request_group_info |= strequal(tmp, "-g");
 219                         request_alias_info |= strequal(tmp, "-a");
 220                 }
 221         }
 222
 223 #ifdef DEBUG_TESTING
 224         if (next_token(NULL, tmp, NULL, sizeof(tmp)))
 225         {
 226                 num_entries = (uint16)strtol(tmp, (char**)NULL, 16);
 227         }
 228
 229         if (next_token(NULL, tmp, NULL, sizeof(tmp)))
 230         {
 231                 unk_0 = (uint16)strtol(tmp, (char**)NULL, 16);
 232         }
 233
 234         if (next_token(NULL, tmp, NULL, sizeof(tmp)))
 235         {
 236                 acb_mask = (uint16)strtol(tmp, (char**)NULL, 16);
 237         }
 238
 239         if (next_token(NULL, tmp, NULL, sizeof(tmp)))
 240         {
 241                 unk_1 = (uint16)strtol(tmp, (char**)NULL, 16);
 242         }
 243 #endif
 244
 245         fprintf(out_hnd, "SAM Enumerate Users\n");
 246         fprintf(out_hnd, "From: %s To: %s Domain: %s SID: %s\n",
 247                           info->myhostname, srv_name, domain, sid);
 248
 249 #ifdef DEBUG_TESTING
 250         DEBUG(5,("Number of entries:%d unk_0:%04x acb_mask:%04x unk_1:%04x\n",
 251                   num_entries, unk_0, acb_mask, unk_1));
 252 #endif
 253
 254         /* open SAMR session.  negotiate credentials */
 255         res = res ? cli_nt_session_open(smb_cli, PIPE_SAMR) : False;
 256
 257         /* establish a connection. */
 258         res = res ? do_samr_connect(smb_cli,
 259                                 srv_name, 0x00000020,
 260                                 &info->dom.samr_pol_connect) : False;
 261
 262         /* connect to the domain */
 263         res = res ? do_samr_open_domain(smb_cli,
 264                     &info->dom.samr_pol_connect, admin_rid, &sid1,
 265                     &info->dom.samr_pol_open_domain) : False;
 266
 267         /* read some users */
 268         res = res ? do_samr_enum_dom_users(smb_cli,
 269                                 &info->dom.samr_pol_open_domain,
 270                     num_entries, unk_0, acb_mask, unk_1, 0xffff,
 271                                 &info->dom.sam, &info->dom.num_sam_entries) : False;
 272
 273         if (res && info->dom.num_sam_entries == 0)
 274         {
 275                 fprintf(out_hnd, "No users\n");
 276         }
 277
 278         if (request_user_info || request_group_info || request_alias_info)
 279         {
 280                 /* query all the users */
 281                 user_idx = 0;
 282
 283                 while (res && user_idx < info->dom.num_sam_entries)
 284                 {
 285                         uint32 user_rid = info->dom.sam[user_idx].user_rid;
 286                         SAM_USER_INFO_21 usr;
 287
 288                         fprintf(out_hnd, "User RID: %8x  User Name: %s\n",
 289                                           user_rid,
 290                                           info->dom.sam[user_idx].acct_name);
 291
 292                         if (request_user_info)
 293                         {
 294                                 /* send user info query, level 0x15 */
 295                                 if (get_samr_query_userinfo(smb_cli,
 296                                                         &info->dom.samr_pol_open_domain,
 297                                                         0x15, user_rid, &usr))
 298                                 {
 299                                         display_sam_user_info_21(out_hnd, ACTION_HEADER   , &usr);
 300                                         display_sam_user_info_21(out_hnd, ACTION_ENUMERATE, &usr);
 301                                         display_sam_user_info_21(out_hnd, ACTION_FOOTER   , &usr);
 302                                 }
 303                         }
 304
 305                         if (request_group_info)
 306                         {
 307                                 uint32 num_groups;
 308                                 DOM_GID gid[LSA_MAX_GROUPS];
 309
 310                                 /* send user group query */
 311                                 if (get_samr_query_usergroups(smb_cli,
 312                                                         &info->dom.samr_pol_open_domain,
 313                                                         user_rid, &num_groups, gid))
 314                                 {
 315                                         display_group_rid_info(out_hnd, ACTION_HEADER   , num_groups, gid);
 316                                         display_group_rid_info(out_hnd, ACTION_ENUMERATE, num_groups, gid);
 317                                         display_group_rid_info(out_hnd, ACTION_FOOTER   , num_groups, gid);
 318                                 }
 319                         }
 320
 321                         if (request_alias_info)
 322                         {
 323                                 uint32 num_aliases;
 324                                 uint32 rid[LSA_MAX_GROUPS];
 325                                 DOM_SID als_sid;
 326
 327                                 sid_copy(&als_sid, &sid1);
 328                                 sid_append_rid(&als_sid, user_rid);
 329
 330                                 /* send user alias query */
 331                                 if (do_samr_query_useraliases(smb_cli,
 332                                                         &info->dom.samr_pol_open_domain,
 333                                                         &als_sid, &num_aliases, rid))
 334                                 {
 335                                         display_alias_rid_info(out_hnd, ACTION_HEADER   , &als_sid, num_aliases, rid);
 336                                         display_alias_rid_info(out_hnd, ACTION_ENUMERATE, &als_sid, num_aliases, rid);
 337                                         display_alias_rid_info(out_hnd, ACTION_FOOTER   , &als_sid, num_aliases, rid);
 338                                 }
 339                         }
 340
 341                         user_idx++;
 342                 }
 343         }
 344
 345         res = res ? do_samr_close(smb_cli,
 346                     &info->dom.samr_pol_open_domain) : False;
 347
 348         res = res ? do_samr_close(smb_cli,
 349                     &info->dom.samr_pol_connect) : False;
 350
 351         /* close the session */
 352         cli_nt_session_close(smb_cli);
 353
 354         if (info->dom.sam != NULL)
 355         {
 356                 free(info->dom.sam);
 357         }
 358
 359         if (res)
 360         {
 361                 DEBUG(5,("cmd_sam_enum_users: succeeded\n"));
 362         }
 363         else
 364         {
 365                 DEBUG(5,("cmd_sam_enum_users: failed\n"));
 366         }
 367 }
 368
 369
 370 /****************************************************************************
 371 experimental SAM user query.
 372 ****************************************************************************/
 373 void cmd_sam_query_user(struct client_info *info)
 374 {
 375         fstring srv_name;
 376         fstring domain;
 377         fstring sid;
 378         DOM_SID sid1;
 379         int user_idx = 0;  /* FIXME maybe ... */
 380         BOOL res = True;
 381         uint32 admin_rid = 0x304; /* absolutely no idea. */
 382         fstring rid_str ;
 383         fstring info_str;
 384         uint32 user_rid = 0;
 385         uint32 info_level = 0x15;
 386
 387         SAM_USER_INFO_21 usr;
 388
 389         sid_to_string(sid, &info->dom.level5_sid);
 390         fstrcpy(domain, info->dom.level5_dom);
 391
 392         if (strlen(sid) == 0)
 393         {
 394                 fprintf(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
 395                 return;
 396         }
 397
 398         string_to_sid(&sid1, sid);
 399
 400         fstrcpy(srv_name, "\\\\");
 401         fstrcat(srv_name, info->dest_host);
 402         strupper(srv_name);
 403
 404         if (next_token(NULL, rid_str , NULL, sizeof(rid_str )) &&
 405             next_token(NULL, info_str, NULL, sizeof(info_str)))
 406         {
 407                 user_rid   = (uint32)strtol(rid_str , (char**)NULL, 16);
 408                 info_level = (uint32)strtol(info_str, (char**)NULL, 10);
 409         }
 410
 411         fprintf(out_hnd, "SAM Query User: rid %x info level %d\n",
 412                           user_rid, info_level);
 413         fprintf(out_hnd, "From: %s To: %s Domain: %s SID: %s\n",
 414                           info->myhostname, srv_name, domain, sid);
 415
 416         /* open SAMR session.  negotiate credentials */
 417         res = res ? cli_nt_session_open(smb_cli, PIPE_SAMR) : False;
 418
 419         /* establish a connection. */
 420         res = res ? do_samr_connect(smb_cli,
 421                                 srv_name, 0x00000020,
 422                                 &info->dom.samr_pol_connect) : False;
 423
 424         /* connect to the domain */
 425         res = res ? do_samr_open_domain(smb_cli,
 426                     &info->dom.samr_pol_connect, admin_rid, &sid1,
 427                     &info->dom.samr_pol_open_domain) : False;
 428
 429         fprintf(out_hnd, "User RID: %8x  User Name: %s\n",
 430                           user_rid,
 431                           info->dom.sam[user_idx].acct_name);
 432
 433         /* send user info query, level */
 434         if (get_samr_query_userinfo(smb_cli,
 435                                         &info->dom.samr_pol_open_domain,
 436                                         info_level, user_rid, &usr))
 437         {
 438                 if (info_level == 0x15)
 439                 {
 440                         display_sam_user_info_21(out_hnd, ACTION_HEADER   , &usr);
 441                         display_sam_user_info_21(out_hnd, ACTION_ENUMERATE, &usr);
 442                         display_sam_user_info_21(out_hnd, ACTION_FOOTER   , &usr);
 443                 }
 444         }
 445
 446         res = res ? do_samr_close(smb_cli,
 447                     &info->dom.samr_pol_connect) : False;
 448
 449         res = res ? do_samr_close(smb_cli,
 450                     &info->dom.samr_pol_open_domain) : False;
 451
 452         /* close the session */
 453         cli_nt_session_close(smb_cli);
 454
 455         if (res)
 456         {
 457                 DEBUG(5,("cmd_sam_query_user: succeeded\n"));
 458         }
 459         else
 460         {
 461                 DEBUG(5,("cmd_sam_query_user: failed\n"));
 462         }
 463 }
 464
 465
 466 /****************************************************************************
 467 experimental SAM groups query.
 468 ****************************************************************************/
 469 void cmd_sam_query_groups(struct client_info *info)
 470 {
 471         fstring srv_name;
 472         fstring domain;
 473         fstring sid;
 474         DOM_SID sid1;
 475         BOOL res = True;
 476         fstring info_str;
 477         uint32 switch_value = 2;
 478         uint32 admin_rid = 0x304; /* absolutely no idea. */
 479
 480         sid_to_string(sid, &info->dom.level5_sid);
 481         fstrcpy(domain, info->dom.level5_dom);
 482
 483         if (strlen(sid) == 0)
 484         {
 485                 fprintf(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
 486                 return;
 487         }
 488
 489         string_to_sid(&sid1, sid);
 490
 491         fstrcpy(srv_name, "\\\\");
 492         fstrcat(srv_name, info->dest_host);
 493         strupper(srv_name);
 494
 495         if (next_token(NULL, info_str, NULL, sizeof(info_str)))
 496         {
 497                 switch_value = (uint32)strtol(info_str, (char**)NULL, 10);
 498         }
 499
 500         fprintf(out_hnd, "SAM Query Groups: info level %d\n", switch_value);
 501         fprintf(out_hnd, "From: %s To: %s Domain: %s SID: %s\n",
 502                           info->myhostname, srv_name, domain, sid);
 503
 504         /* open SAMR session.  negotiate credentials */
 505         res = res ? cli_nt_session_open(smb_cli, PIPE_SAMR) : False;
 506
 507         /* establish a connection. */
 508         res = res ? do_samr_connect(smb_cli,
 509                                 srv_name, 0x00000020,
 510                                 &info->dom.samr_pol_connect) : False;
 511
 512         /* connect to the domain */
 513         res = res ? do_samr_open_domain(smb_cli,
 514                     &info->dom.samr_pol_connect, admin_rid, &sid1,
 515                     &info->dom.samr_pol_open_domain) : False;
 516
 517         /* send a samr 0x8 command */
 518         res = res ? do_samr_query_dom_info(smb_cli,
 519                     &info->dom.samr_pol_open_domain, switch_value) : False;
 520
 521         res = res ? do_samr_close(smb_cli,
 522                     &info->dom.samr_pol_connect) : False;
 523
 524         res = res ? do_samr_close(smb_cli,
 525                     &info->dom.samr_pol_open_domain) : False;
 526
 527         /* close the session */
 528         cli_nt_session_close(smb_cli);
 529
 530         if (res)
 531         {
 532                 DEBUG(5,("cmd_sam_query_groups: succeeded\n"));
 533         }
 534         else
 535         {
 536                 DEBUG(5,("cmd_sam_query_groups: failed\n"));
 537         }
 538 }
 539
 540
 541 /****************************************************************************
 542 experimental SAM aliases query.
 543 ****************************************************************************/
 544 void cmd_sam_enum_aliases(struct client_info *info)
 545 {
 546         fstring srv_name;
 547         fstring domain;
 548         fstring sid;
 549         DOM_SID sid1;
 550         BOOL res = True;
 551         BOOL request_user_info  = False;
 552         BOOL request_alias_info = False;
 553         uint32 admin_rid = 0x304; /* absolutely no idea. */
 554         fstring tmp;
 555
 556         uint32 num_aliases = 3;
 557         uint32 alias_rid[3] = { DOMAIN_GROUP_RID_ADMINS, DOMAIN_GROUP_RID_USERS, DOMAIN_GROUP_RID_GUESTS };
 558         fstring alias_names [3];
 559         uint32  num_als_usrs[3];
 560
 561         sid_to_string(sid, &info->dom.level3_sid);
 562         fstrcpy(domain, info->dom.level3_dom);
 563 #if 0
 564         fstrcpy(sid   , "S-1-5-20");
 565 #endif
 566         if (strlen(sid) == 0)
 567         {
 568                 fprintf(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
 569                 return;
 570         }
 571
 572         string_to_sid(&sid1, sid);
 573
 574         fstrcpy(srv_name, "\\\\");
 575         fstrcat(srv_name, info->dest_host);
 576         strupper(srv_name);
 577
 578         /* a bad way to do token parsing... */
 579         if (next_token(NULL, tmp, NULL, sizeof(tmp)))
 580         {
 581                 request_user_info  |= strequal(tmp, "-u");
 582                 request_alias_info |= strequal(tmp, "-g");
 583         }
 584
 585         if (next_token(NULL, tmp, NULL, sizeof(tmp)))
 586         {
 587                 request_user_info  |= strequal(tmp, "-u");
 588                 request_alias_info |= strequal(tmp, "-g");
 589         }
 590
 591         fprintf(out_hnd, "SAM Enumerate Aliases\n");
 592         fprintf(out_hnd, "From: %s To: %s Domain: %s SID: %s\n",
 593                           info->myhostname, srv_name, domain, sid);
 594
 595         /* open SAMR session.  negotiate credentials */
 596         res = res ? cli_nt_session_open(smb_cli, PIPE_SAMR) : False;
 597
 598         /* establish a connection. */
 599         res = res ? do_samr_connect(smb_cli,
 600                                 srv_name, 0x00000020,
 601                                 &info->dom.samr_pol_connect) : False;
 602
 603         /* connect to the domain */
 604         res = res ? do_samr_open_domain(smb_cli,
 605                     &info->dom.samr_pol_connect, admin_rid, &sid1,
 606                     &info->dom.samr_pol_open_domain) : False;
 607
 608         /* send a query on the aliases */
 609         res = res ? do_samr_query_unknown_12(smb_cli,
 610                     &info->dom.samr_pol_open_domain, admin_rid, num_aliases, alias_rid,
 611                     &num_aliases, alias_names, num_als_usrs) : False;
 612
 613         if (res)
 614         {
 615                 display_alias_name_info(out_hnd, ACTION_HEADER   , num_aliases, alias_names, num_als_usrs);
 616                 display_alias_name_info(out_hnd, ACTION_ENUMERATE, num_aliases, alias_names, num_als_usrs);
 617                 display_alias_name_info(out_hnd, ACTION_FOOTER   , num_aliases, alias_names, num_als_usrs);
 618         }
 619
 620 #if 0
 621
 622         /* read some users */
 623         res = res ? do_samr_enum_dom_users(smb_cli,
 624                                 &info->dom.samr_pol_open_domain,
 625                     num_entries, unk_0, acb_mask, unk_1, 0xffff,
 626                                 info->dom.sam, &info->dom.num_sam_entries) : False;
 627
 628         if (res && info->dom.num_sam_entries == 0)
 629         {
 630                 fprintf(out_hnd, "No users\n");
 631         }
 632
 633         if (request_user_info || request_alias_info)
 634         {
 635                 /* query all the users */
 636                 user_idx = 0;
 637
 638                 while (res && user_idx < info->dom.num_sam_entries)
 639                 {
 640                         uint32 user_rid = info->dom.sam[user_idx].user_rid;
 641                         SAM_USER_INFO_21 usr;
 642
 643                         fprintf(out_hnd, "User RID: %8x  User Name: %s\n",
 644                                           user_rid,
 645                                           info->dom.sam[user_idx].acct_name);
 646
 647                         if (request_user_info)
 648                         {
 649                                 /* send user info query, level 0x15 */
 650                                 if (get_samr_query_userinfo(smb_cli,
 651                                                         &info->dom.samr_pol_open_domain,
 652                                                         0x15, user_rid, &usr))
 653                                 {
 654                                         display_sam_user_info_21(out_hnd, ACTION_HEADER   , &usr);
 655                                         display_sam_user_info_21(out_hnd, ACTION_ENUMERATE, &usr);
 656                                         display_sam_user_info_21(out_hnd, ACTION_FOOTER   , &usr);
 657                                 }
 658                         }
 659
 660                         if (request_alias_info)
 661                         {
 662                                 uint32 num_aliases;
 663                                 DOM_GID gid[LSA_MAX_GROUPS];
 664
 665                                 /* send user aliase query */
 666                                 if (get_samr_query_useraliases(smb_cli,
 667                                                         &info->dom.samr_pol_open_domain,
 668                                                         user_rid, &num_aliases, gid))
 669                                 {
 670                                         display_alias_info(out_hnd, ACTION_HEADER   , num_aliases, gid);
 671                                         display_alias_info(out_hnd, ACTION_ENUMERATE, num_aliases, gid);
 672                                         display_alias_info(out_hnd, ACTION_FOOTER   , num_aliases, gid);
 673                                 }
 674                         }
 675
 676                         user_idx++;
 677                 }
 678         }
 679 #endif
 680
 681         res = res ? do_samr_close(smb_cli,
 682                     &info->dom.samr_pol_connect) : False;
 683
 684         res = res ? do_samr_close(smb_cli,
 685                     &info->dom.samr_pol_open_domain) : False;
 686
 687         /* close the session */
 688         cli_nt_session_close(smb_cli);
 689
 690         if (res)
 691         {
 692                 DEBUG(5,("cmd_sam_enum_users: succeeded\n"));
 693         }
 694         else
 695         {
 696                 DEBUG(5,("cmd_sam_enum_users: failed\n"));
 697         }
 698 }
 699
 700