source/rpcclient/cmd_samr.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 2.2
   4    RPC pipe client
   5
   6    Copyright (C) Andrew Tridgell              1992-2000,
   7    Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
   8    Copyright (C) Elrond                            2000,
   9    Copyright (C) Tim Potter                        2000
  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 2 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, write to the Free Software
  23    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24 */
  25
  26 #include "includes.h"
  27
  28 extern DOM_SID domain_sid;
  29
  30 /****************************************************************************
  31  display sam_user_info_21 structure
  32  ****************************************************************************/
  33 static void display_sam_user_info_21(SAM_USER_INFO_21 *usr)
  34 {
  35         fstring temp;
  36
  37         unistr2_to_ascii(temp, &usr->uni_user_name, sizeof(temp)-1);
  38         printf("\tUser Name   :\t%s\n", temp);
  39
  40         unistr2_to_ascii(temp, &usr->uni_full_name, sizeof(temp)-1);
  41         printf("\tFull Name   :\t%s\n", temp);
  42
  43         unistr2_to_ascii(temp, &usr->uni_home_dir, sizeof(temp)-1);
  44         printf("\tHome Drive  :\t%s\n", temp);
  45
  46         unistr2_to_ascii(temp, &usr->uni_dir_drive, sizeof(temp)-1);
  47         printf("\tDir Drive   :\t%s\n", temp);
  48
  49         unistr2_to_ascii(temp, &usr->uni_profile_path, sizeof(temp)-1);
  50         printf("\tProfile Path:\t%s\n", temp);
  51
  52         unistr2_to_ascii(temp, &usr->uni_logon_script, sizeof(temp)-1);
  53         printf("\tLogon Script:\t%s\n", temp);
  54
  55         unistr2_to_ascii(temp, &usr->uni_acct_desc, sizeof(temp)-1);
  56         printf("\tDescription :\t%s\n", temp);
  57
  58         unistr2_to_ascii(temp, &usr->uni_workstations, sizeof(temp)-1);
  59         printf("\tWorkstations:\t%s\n", temp);
  60
  61         unistr2_to_ascii(temp, &usr->uni_unknown_str, sizeof(temp)-1);
  62         printf("\tUnknown Str :\t%s\n", temp);
  63
  64         unistr2_to_ascii(temp, &usr->uni_munged_dial, sizeof(temp)-1);
  65         printf("\tRemote Dial :\t%s\n", temp);
  66
  67         printf("\tLogon Time               :\t%s\n",
  68                http_timestring(nt_time_to_unix(&usr->logon_time)));
  69         printf("\tLogoff Time              :\t%s\n",
  70                http_timestring(nt_time_to_unix(&usr->logoff_time)));
  71         printf("\tKickoff Time             :\t%s\n",
  72                http_timestring(nt_time_to_unix(&usr->kickoff_time)));
  73         printf("\tPassword last set Time   :\t%s\n",
  74                http_timestring(nt_time_to_unix(&usr->pass_last_set_time)));
  75         printf("\tPassword can change Time :\t%s\n",
  76                http_timestring(nt_time_to_unix(&usr->pass_can_change_time)));
  77         printf("\tPassword must change Time:\t%s\n",
  78                http_timestring(nt_time_to_unix(&usr->pass_must_change_time)));
  79
  80         printf("\tunknown_2[0..31]...\n"); /* user passwords? */
  81
  82         printf("\tuser_rid :\t%x\n"  , usr->user_rid ); /* User ID */
  83         printf("\tgroup_rid:\t%x\n"  , usr->group_rid); /* Group ID */
  84         printf("\tacb_info :\t%04x\n", usr->acb_info ); /* Account Control Info */
  85
  86         printf("\tunknown_3:\t%08x\n", usr->unknown_3); /* 0x00ff ffff */
  87         printf("\tlogon_divs:\t%d\n", usr->logon_divs); /* 0x0000 00a8 which is 168 which is num hrs in a week */
  88         printf("\tunknown_5:\t%08x\n", usr->unknown_5); /* 0x0002 0000 */
  89
  90         printf("\tpadding1[0..7]...\n");
  91
  92         if (usr->ptr_logon_hrs) {
  93                 printf("\tlogon_hrs[0..%d]...\n", usr->logon_hrs.len);
  94         }
  95 }
  96
  97 /**********************************************************************
  98  * Query user information
  99  */
 100 static uint32 cmd_samr_query_user(struct cli_state *cli, int argc, char **argv)
 101 {
 102         POLICY_HND connect_pol, domain_pol, user_pol;
 103         uint32  result = NT_STATUS_UNSUCCESSFUL,
 104                 info_level = 21;
 105         BOOL    got_connect_pol = False,
 106                 got_domain_pol = False,
 107                 got_user_pol = False;
 108         SAM_USERINFO_CTR user_ctr;
 109         SAM_USER_INFO_21 info_21;
 110         fstring                 server;
 111         TALLOC_CTX              *mem_ctx;
 112
 113
 114         if (argc != 1) {
 115                 printf("Usage: %s\n", argv[0]);
 116                 return 0;
 117         }
 118
 119         if (!(mem_ctx=talloc_init()))
 120         {
 121                 DEBUG(0,("cmd_samr_query_user: talloc_init returned NULL!\n"));
 122                 return NT_STATUS_UNSUCCESSFUL;
 123         }
 124
 125         fetch_domain_sid(cli);
 126
 127         /* Initialise RPC connection */
 128         if (!cli_nt_session_open (cli, PIPE_SAMR)) {
 129                 fprintf (stderr, "Could not initialize samr pipe!\n");
 130                 return NT_STATUS_UNSUCCESSFUL;
 131         }
 132
 133         slprintf (server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
 134         strupper (server);
 135
 136         if ((result = cli_samr_connect(cli, mem_ctx, server, MAXIMUM_ALLOWED_ACCESS,
 137                                        &connect_pol)) !=
 138             NT_STATUS_NOPROBLEMO) {
 139                 goto done;
 140         }
 141
 142         got_connect_pol = True;
 143
 144         if ((result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
 145                                            MAXIMUM_ALLOWED_ACCESS,
 146                                            &domain_sid, &domain_pol))
 147              != NT_STATUS_NOPROBLEMO) {
 148                 goto done;
 149         }
 150
 151         got_domain_pol = True;
 152
 153         if ((result = cli_samr_open_user(cli, mem_ctx, &domain_pol,
 154                                          MAXIMUM_ALLOWED_ACCESS,
 155                                          0x1f4, &user_pol))
 156             != NT_STATUS_NOPROBLEMO) {
 157                 goto done;
 158         }
 159
 160         got_user_pol = True;
 161
 162         ZERO_STRUCT(user_ctr);
 163         ZERO_STRUCT(info_21);
 164
 165         user_ctr.info.id21 = &info_21;
 166
 167         if ((result = cli_samr_query_userinfo(cli, mem_ctx, &user_pol, info_level,
 168                                               &user_ctr))
 169             != NT_STATUS_NOPROBLEMO) {
 170                 goto done;
 171         }
 172
 173         display_sam_user_info_21(&info_21);
 174
 175 done:
 176         if (got_user_pol) cli_samr_close(cli, mem_ctx, &user_pol);
 177         if (got_domain_pol) cli_samr_close(cli, mem_ctx, &domain_pol);
 178         if (got_connect_pol) cli_samr_close(cli, mem_ctx, &connect_pol);
 179
 180         cli_nt_session_close(cli);
 181         talloc_destroy(mem_ctx);
 182
 183         return result;
 184 }
 185
 186 /****************************************************************************
 187  display group info
 188  ****************************************************************************/
 189 static void display_group_info1(GROUP_INFO1 *info1)
 190 {
 191         fstring temp;
 192
 193         unistr2_to_ascii(temp, &info1->uni_acct_name, sizeof(temp)-1);
 194         printf("\tGroup Name:\t%s\n", temp);
 195         unistr2_to_ascii(temp, &info1->uni_acct_desc, sizeof(temp)-1);
 196         printf("\tDescription:\t%s\n", temp);
 197         printf("\tunk1:%d\n", info1->unknown_1);
 198         printf("\tNum Members:%d\n", info1->num_members);
 199 }
 200
 201 /****************************************************************************
 202  display group info
 203  ****************************************************************************/
 204 static void display_group_info4(GROUP_INFO4 *info4)
 205 {
 206         fstring desc;
 207
 208         unistr2_to_ascii(desc, &info4->uni_acct_desc, sizeof(desc)-1);
 209         printf("\tGroup Description:%s\n", desc);
 210 }
 211
 212 /****************************************************************************
 213  display sam sync structure
 214  ****************************************************************************/
 215 static void display_group_info_ctr(GROUP_INFO_CTR *ctr)
 216 {
 217         switch (ctr->switch_value1) {
 218             case 1: {
 219                     display_group_info1(&ctr->group.info1);
 220                     break;
 221             }
 222             case 4: {
 223                     display_group_info4(&ctr->group.info4);
 224                     break;
 225             }
 226         }
 227 }
 228
 229 /***********************************************************************
 230  * Query group information
 231  */
 232 static uint32 cmd_samr_query_group(struct cli_state *cli, int argc, char **argv)
 233 {
 234         POLICY_HND connect_pol, domain_pol, group_pol;
 235         uint32 result = NT_STATUS_UNSUCCESSFUL, info_level = 1;
 236         BOOL got_connect_pol = False, got_domain_pol = False,
 237                 got_group_pol = False;
 238         GROUP_INFO_CTR group_ctr;
 239         fstring                 server;
 240         TALLOC_CTX              *mem_ctx;
 241
 242         if (argc != 1) {
 243                 printf("Usage: %s\n", argv[0]);
 244                 return 0;
 245         }
 246
 247         if (!(mem_ctx=talloc_init()))
 248         {
 249                 DEBUG(0,("cmd_samr_query_group: talloc_init returned NULL!\n"));
 250                 return NT_STATUS_UNSUCCESSFUL;
 251         }
 252
 253         fetch_domain_sid(cli);
 254
 255         /* Initialise RPC connection */
 256         if (!cli_nt_session_open (cli, PIPE_SAMR)) {
 257                 fprintf (stderr, "Could not initialize samr pipe!\n");
 258                 return NT_STATUS_UNSUCCESSFUL;
 259         }
 260
 261         slprintf (server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
 262         strupper (server);
 263
 264         if ((result = cli_samr_connect(cli, mem_ctx, server, MAXIMUM_ALLOWED_ACCESS,
 265                                        &connect_pol)) !=
 266             NT_STATUS_NOPROBLEMO) {
 267                 goto done;
 268         }
 269
 270         got_connect_pol = True;
 271
 272         if ((result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
 273                                            MAXIMUM_ALLOWED_ACCESS,
 274                                            &domain_sid, &domain_pol))
 275              != NT_STATUS_NOPROBLEMO) {
 276                 goto done;
 277         }
 278
 279         got_domain_pol = True;
 280
 281         if ((result = cli_samr_open_group(cli, mem_ctx, &domain_pol,
 282                                           MAXIMUM_ALLOWED_ACCESS,
 283                                           0x202, &group_pol))
 284             != NT_STATUS_NOPROBLEMO) {
 285                 goto done;
 286         }
 287
 288         got_group_pol = True;
 289
 290         ZERO_STRUCT(group_ctr);
 291
 292         if ((result = cli_samr_query_groupinfo(cli, mem_ctx, &group_pol, info_level,
 293                                                &group_ctr))
 294             != NT_STATUS_NOPROBLEMO) {
 295                 goto done;
 296         }
 297
 298         display_group_info_ctr(&group_ctr);
 299
 300 done:
 301         if (got_group_pol) cli_samr_close(cli, mem_ctx, &group_pol);
 302         if (got_domain_pol) cli_samr_close(cli, mem_ctx, &domain_pol);
 303         if (got_connect_pol) cli_samr_close(cli, mem_ctx, &connect_pol);
 304
 305         cli_nt_session_close(cli);
 306         talloc_destroy(mem_ctx);
 307
 308         return result;
 309 }
 310
 311 /* Query groups a user is a member of */
 312
 313 static uint32 cmd_samr_query_usergroups(struct cli_state *cli, int argc, char **argv)
 314 {
 315         POLICY_HND              connect_pol,
 316                                 domain_pol,
 317                                 user_pol;
 318         uint32                  result = NT_STATUS_UNSUCCESSFUL;
 319         BOOL                    got_connect_pol = False,
 320                                 got_domain_pol = False,
 321                                 got_user_pol = False;
 322         uint32                  num_groups,
 323                                 user_rid;
 324         DOM_GID                 *user_gids;
 325         int                     i;
 326         fstring                 server;
 327         TALLOC_CTX              *mem_ctx;
 328
 329         if (argc != 2) {
 330                 printf("Usage: %s rid\n", argv[0]);
 331                 return 0;
 332         }
 333
 334         if (!(mem_ctx=talloc_init()))
 335         {
 336                 DEBUG(0,("cmd_samr_query_usergroups: talloc_init returned NULL!\n"));
 337                 return NT_STATUS_UNSUCCESSFUL;
 338         }
 339
 340         sscanf(argv[1], "%i", &user_rid);
 341
 342         fetch_domain_sid(cli);
 343
 344         /* Initialise RPC connection */
 345         if (!cli_nt_session_open (cli, PIPE_SAMR)) {
 346                 fprintf (stderr, "Could not initialize samr pipe!\n");
 347                 return NT_STATUS_UNSUCCESSFUL;
 348         }
 349
 350         slprintf (server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
 351         strupper (server);
 352
 353         if ((result = cli_samr_connect(cli, mem_ctx, server, MAXIMUM_ALLOWED_ACCESS,
 354                                        &connect_pol)) !=
 355             NT_STATUS_NOPROBLEMO) {
 356                 goto done;
 357         }
 358
 359         got_connect_pol = True;
 360
 361         if ((result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
 362                                            MAXIMUM_ALLOWED_ACCESS,
 363                                            &domain_sid, &domain_pol))
 364              != NT_STATUS_NOPROBLEMO) {
 365                 goto done;
 366         }
 367
 368         got_domain_pol = True;
 369
 370         if ((result = cli_samr_open_user(cli, mem_ctx, &domain_pol,
 371                                          MAXIMUM_ALLOWED_ACCESS,
 372                                          user_rid, &user_pol))
 373             != NT_STATUS_NOPROBLEMO) {
 374                 goto done;
 375         }
 376
 377         got_user_pol = True;
 378
 379         if ((result = cli_samr_query_usergroups(cli, mem_ctx, &user_pol,
 380                                                 &num_groups, &user_gids))
 381             != NT_STATUS_NOPROBLEMO) {
 382                 goto done;
 383         }
 384
 385         for (i = 0; i < num_groups; i++) {
 386                 printf("\tgroup rid:[0x%x] attr:[0x%x]\n",
 387                        user_gids[i].g_rid, user_gids[i].attr);
 388         }
 389
 390  done:
 391         if (got_user_pol) cli_samr_close(cli, mem_ctx, &user_pol);
 392         if (got_domain_pol) cli_samr_close(cli, mem_ctx, &domain_pol);
 393         if (got_connect_pol) cli_samr_close(cli, mem_ctx, &connect_pol);
 394
 395         cli_nt_session_close(cli);
 396         talloc_destroy(mem_ctx);
 397
 398         return result;
 399 }
 400
 401 /* Query members of a group */
 402
 403 static uint32 cmd_samr_query_groupmem(struct cli_state *cli, int argc, char **argv)
 404 {
 405         POLICY_HND connect_pol, domain_pol, group_pol;
 406         uint32 result = NT_STATUS_UNSUCCESSFUL;
 407         BOOL    got_connect_pol = False,
 408                 got_domain_pol = False,
 409                 got_group_pol = False;
 410         uint32 num_members, *group_rids, *group_attrs, group_rid;
 411         int i;
 412         fstring                 server;
 413         TALLOC_CTX              *mem_ctx;
 414
 415         if (argc != 2) {
 416                 printf("Usage: %s rid\n", argv[0]);
 417                 return 0;
 418         }
 419
 420         if (!(mem_ctx=talloc_init()))
 421         {
 422                 DEBUG(0,("cmd_samr_query_groupmem: talloc_init returned NULL!\n"));
 423                 return NT_STATUS_UNSUCCESSFUL;
 424         }
 425
 426         sscanf(argv[1], "%i", &group_rid);
 427
 428         fetch_domain_sid(cli);
 429
 430         /* Initialise RPC connection */
 431         if (!cli_nt_session_open (cli, PIPE_SAMR)) {
 432                 fprintf (stderr, "Could not initialize samr pipe!\n");
 433                 return NT_STATUS_UNSUCCESSFUL;
 434         }
 435
 436         slprintf (server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
 437         strupper (server);
 438
 439         if ((result = cli_samr_connect(cli, mem_ctx, server, MAXIMUM_ALLOWED_ACCESS,
 440                                        &connect_pol)) !=
 441             NT_STATUS_NOPROBLEMO) {
 442                 goto done;
 443         }
 444
 445         got_connect_pol = True;
 446
 447         if ((result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
 448                                            MAXIMUM_ALLOWED_ACCESS,
 449                                            &domain_sid, &domain_pol))
 450              != NT_STATUS_NOPROBLEMO) {
 451                 goto done;
 452         }
 453
 454         got_domain_pol = True;
 455
 456         if ((result = cli_samr_open_group(cli, mem_ctx, &domain_pol,
 457                                           MAXIMUM_ALLOWED_ACCESS,
 458                                           group_rid, &group_pol))
 459             != NT_STATUS_NOPROBLEMO) {
 460                 goto done;
 461         }
 462
 463         got_group_pol = True;
 464
 465         if ((result = cli_samr_query_groupmem(cli, mem_ctx, &group_pol,
 466                                               &num_members, &group_rids,
 467                                               &group_attrs))
 468             != NT_STATUS_NOPROBLEMO) {
 469                 goto done;
 470         }
 471
 472         for (i = 0; i < num_members; i++) {
 473                 printf("\trid:[0x%x] attr:[0x%x]\n", group_rids[i],
 474                        group_attrs[i]);
 475         }
 476
 477  done:
 478         if (got_group_pol) cli_samr_close(cli, mem_ctx, &group_pol);
 479         if (got_domain_pol) cli_samr_close(cli, mem_ctx, &domain_pol);
 480         if (got_connect_pol) cli_samr_close(cli, mem_ctx, &connect_pol);
 481
 482         cli_nt_session_close(cli);
 483         talloc_destroy(mem_ctx);
 484
 485         return result;
 486 }
 487
 488 /* Enumerate domain groups */
 489
 490 static uint32 cmd_samr_enum_dom_groups(struct cli_state *cli, int argc,
 491                                        char **argv)
 492 {
 493         POLICY_HND connect_pol, domain_pol;
 494         uint32 result = NT_STATUS_UNSUCCESSFUL;
 495         BOOL got_connect_pol = False, got_domain_pol = False;
 496         TALLOC_CTX *mem_ctx;
 497         fstring server;
 498         uint32 start_idx, size, num_dom_groups, i;
 499         struct acct_info *dom_groups;
 500
 501         if (argc != 1) {
 502                 printf("Usage: %s\n", argv[0]);
 503                 return 0;
 504         }
 505
 506         if (!(mem_ctx = talloc_init())) {
 507                 DEBUG(0, ("cmd_samr_enum_dom_groups: talloc_init returned "
 508                           "NULL!\n"));
 509                 return NT_STATUS_UNSUCCESSFUL;
 510         }
 511
 512         fetch_domain_sid(cli);
 513
 514         /* Initialise RPC connection */
 515
 516         if (!cli_nt_session_open (cli, PIPE_SAMR)) {
 517                 fprintf (stderr, "Could not initialize samr pipe!\n");
 518                 return NT_STATUS_UNSUCCESSFUL;
 519         }
 520
 521         slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
 522         strupper(server);
 523
 524         /* Get sam policy handle */
 525
 526         if ((result = cli_samr_connect(cli, mem_ctx, server,
 527                                        MAXIMUM_ALLOWED_ACCESS,
 528                                        &connect_pol)) !=
 529             NT_STATUS_NOPROBLEMO) {
 530                 goto done;
 531         }
 532
 533         got_connect_pol = True;
 534
 535         /* Get domain policy handle */
 536
 537         if ((result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
 538                                            MAXIMUM_ALLOWED_ACCESS,
 539                                            &domain_sid, &domain_pol))
 540              != NT_STATUS_NOPROBLEMO) {
 541                 goto done;
 542         }
 543
 544         got_domain_pol = True;
 545
 546         /* Enumerate domain groups */
 547
 548         start_idx = 0;
 549         size = 0xffff;
 550
 551         result = cli_samr_enum_dom_groups(cli, mem_ctx, &domain_pol,
 552                                           &start_idx, size,
 553                                           &dom_groups, &num_dom_groups);
 554
 555         for (i = 0; i < num_dom_groups; i++)
 556                 printf("group:[%s] rid:[0x%x]\n", dom_groups[i].acct_name,
 557                        dom_groups[i].rid);
 558
 559  done:
 560         if (got_domain_pol) cli_samr_close(cli, mem_ctx, &domain_pol);
 561         if (got_connect_pol) cli_samr_close(cli, mem_ctx, &connect_pol);
 562
 563         cli_nt_session_close(cli);
 564         talloc_destroy(mem_ctx);
 565
 566         return result;
 567 }
 568
 569 /* Query alias membership */
 570
 571 static uint32 cmd_samr_query_aliasmem(struct cli_state *cli, int argc,
 572                                       char **argv)
 573 {
 574         POLICY_HND connect_pol, domain_pol, alias_pol;
 575         BOOL got_connect_pol = False, got_domain_pol = False,
 576                 got_alias_pol = False;
 577         TALLOC_CTX *mem_ctx;
 578         uint32 result = NT_STATUS_UNSUCCESSFUL, alias_rid, num_members, i;
 579         DOM_SID *alias_sids;
 580
 581         fstring server;
 582
 583         if (argc != 2) {
 584                 printf("Usage: %s rid\n", argv[0]);
 585                 return 0;
 586         }
 587
 588         if (!(mem_ctx=talloc_init())) {
 589                 DEBUG(0,("cmd_samr_query_aliasmem: talloc_init() "
 590                          "returned NULL!\n"));
 591                 return NT_STATUS_UNSUCCESSFUL;
 592         }
 593
 594         sscanf(argv[1], "%i", &alias_rid);
 595
 596         /* Initialise RPC connection */
 597
 598         fetch_domain_sid(cli);
 599
 600         if (!cli_nt_session_open (cli, PIPE_SAMR)) {
 601                 fprintf (stderr, "Could not initialize samr pipe!\n");
 602                 return NT_STATUS_UNSUCCESSFUL;
 603         }
 604
 605         /* Open SAMR handle */
 606
 607         slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
 608         strupper(server);
 609
 610         if ((result = cli_samr_connect(cli, mem_ctx, server,
 611                                        MAXIMUM_ALLOWED_ACCESS,
 612                                        &connect_pol)) !=
 613             NT_STATUS_NOPROBLEMO) {
 614                 goto done;
 615         }
 616
 617         got_connect_pol = True;
 618
 619         /* Open handle on domain */
 620
 621         if ((result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
 622                                            MAXIMUM_ALLOWED_ACCESS,
 623                                            &domain_sid, &domain_pol))
 624              != NT_STATUS_NOPROBLEMO) {
 625                 goto done;
 626         }
 627
 628         got_domain_pol = True;
 629
 630         /* Open handle on alias */
 631
 632         if ((result = cli_samr_open_alias(cli, mem_ctx, &domain_pol,
 633                                           MAXIMUM_ALLOWED_ACCESS,
 634                                           alias_rid, &alias_pol))
 635             != NT_STATUS_NOPROBLEMO) {
 636                 goto done;
 637         }
 638
 639         got_alias_pol = True;
 640
 641         if ((result = cli_samr_query_aliasmem(cli, mem_ctx, &alias_pol,
 642                                               &num_members, &alias_sids))
 643             != NT_STATUS_NOPROBLEMO) {
 644                 goto done;
 645         }
 646
 647         for (i = 0; i < num_members; i++) {
 648                 fstring sid_str;
 649
 650                 sid_to_string(sid_str, &alias_sids[i]);
 651                 printf("\tsid:[%s]\n", sid_str);
 652         }
 653
 654  done:
 655         if (got_alias_pol) cli_samr_close(cli, mem_ctx, &alias_pol);
 656         if (got_domain_pol) cli_samr_close(cli, mem_ctx, &domain_pol);
 657         if (got_connect_pol) cli_samr_close(cli, mem_ctx, &connect_pol);
 658
 659         cli_nt_session_close(cli);
 660         talloc_destroy(mem_ctx);
 661
 662         return result;
 663 }
 664
 665 /* List of commands exported by this module */
 666
 667 struct cmd_set samr_commands[] = {
 668         { "SAMR",               NULL,                           "" },
 669
 670         { "queryuser",          cmd_samr_query_user,            "Query user info" },
 671         { "querygroup",         cmd_samr_query_group,           "Query group info" },
 672         { "queryusergroups",    cmd_samr_query_usergroups,      "Query user groups" },
 673         { "querygroupmem",      cmd_samr_query_groupmem,        "Query group membership" },
 674         { "queryaliasmem",      cmd_samr_query_aliasmem,        "Query alias membership" },
 675         { "enumdomgroups",      cmd_samr_enum_dom_groups,       "Enumerate domain groups" },
 676
 677         { NULL, NULL, NULL }
 678 };
 679