7a65fc5c37a240f37dd6d4bd7a099aaf60429684
[samba.git] / source / 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