fa3253edf9c39b5e1491d7af059942ab43880037
[samba.git] / 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         fstrcpy(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         fstrcpy(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         uint16 num_entries = 0;
189         uint16 unk_0 = 0x0;
190         uint16 acb_mask = 0;
191         uint16 unk_1 = 0x0;
192         uint32 admin_rid = 0x304; /* absolutely no idea. */
193         fstring tmp;
194
195         fstrcpy(sid   , info->dom.level5_sid);
196         fstrcpy(domain, info->dom.level5_dom);
197
198         if (strlen(sid) == 0)
199         {
200                 fprintf(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
201                 return;
202         }
203
204         make_dom_sid(&sid1, sid);
205
206         fstrcpy(srv_name, "\\\\");
207         fstrcat(srv_name, info->dest_host);
208         strupper(srv_name);
209
210         /* a bad way to do token parsing... */
211         if (next_token(NULL, tmp, NULL, sizeof(tmp)))
212         {
213                 request_user_info  |= strequal(tmp, "-u");
214                 request_group_info |= strequal(tmp, "-g");
215         }
216
217         if (next_token(NULL, tmp, NULL, sizeof(tmp)))
218         {
219                 request_user_info  |= strequal(tmp, "-u");
220                 request_group_info |= strequal(tmp, "-g");
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)
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].smb_userid;
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                         user_idx++;
322                 }
323         }
324
325         res = res ? do_samr_close(smb_cli,
326                     &info->dom.samr_pol_open_domain) : False;
327
328         res = res ? do_samr_close(smb_cli,
329                     &info->dom.samr_pol_connect) : False;
330
331         /* close the session */
332         cli_nt_session_close(smb_cli);
333
334         if (info->dom.sam != NULL)
335         {
336                 free(info->dom.sam);
337         }
338
339         if (res)
340         {
341                 DEBUG(5,("cmd_sam_enum_users: succeeded\n"));
342         }
343         else
344         {
345                 DEBUG(5,("cmd_sam_enum_users: failed\n"));
346         }
347 }
348
349
350 /****************************************************************************
351 experimental SAM user query.
352 ****************************************************************************/
353 void cmd_sam_query_user(struct client_info *info)
354 {
355         fstring srv_name;
356         fstring domain;
357         fstring sid;
358         DOM_SID sid1;
359         int user_idx = 0;  /* FIXME maybe ... */
360         BOOL res = True;
361         uint32 admin_rid = 0x304; /* absolutely no idea. */
362         fstring rid_str ;
363         fstring info_str;
364         uint32 user_rid = 0;
365         uint32 info_level = 0x15;
366
367         SAM_USER_INFO_21 usr;
368
369         fstrcpy(sid   , info->dom.level5_sid);
370         fstrcpy(domain, info->dom.level5_dom);
371
372         if (strlen(sid) == 0)
373         {
374                 fprintf(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
375                 return;
376         }
377
378         make_dom_sid(&sid1, sid);
379
380         fstrcpy(srv_name, "\\\\");
381         fstrcat(srv_name, info->dest_host);
382         strupper(srv_name);
383
384         if (next_token(NULL, rid_str , NULL, sizeof(rid_str )) &&
385             next_token(NULL, info_str, NULL, sizeof(info_str)))
386         {
387                 user_rid   = (uint32)strtol(rid_str , (char**)NULL, 16);
388                 info_level = (uint32)strtol(info_str, (char**)NULL, 10);
389         }
390
391         fprintf(out_hnd, "SAM Query User: rid %x info level %d\n",
392                           user_rid, info_level);
393         fprintf(out_hnd, "From: %s To: %s Domain: %s SID: %s\n",
394                           info->myhostname, srv_name, domain, sid);
395
396         /* open SAMR session.  negotiate credentials */
397         res = res ? cli_nt_session_open(smb_cli, PIPE_SAMR) : False;
398
399         /* establish a connection. */
400         res = res ? do_samr_connect(smb_cli,
401                                 srv_name, 0x00000020,
402                                 &info->dom.samr_pol_connect) : False;
403
404         /* connect to the domain */
405         res = res ? do_samr_open_domain(smb_cli,
406                     &info->dom.samr_pol_connect, admin_rid, &sid1,
407                     &info->dom.samr_pol_open_domain) : False;
408
409         fprintf(out_hnd, "User RID: %8x  User Name: %s\n",
410                           user_rid,
411                           info->dom.sam[user_idx].acct_name);
412
413         /* send user info query, level */
414         if (get_samr_query_userinfo(smb_cli,
415                                         &info->dom.samr_pol_open_domain,
416                                         info_level, user_rid, &usr))
417         {
418                 if (info_level == 0x15)
419                 {
420                         display_sam_user_info_21(out_hnd, ACTION_HEADER   , &usr);
421                         display_sam_user_info_21(out_hnd, ACTION_ENUMERATE, &usr);
422                         display_sam_user_info_21(out_hnd, ACTION_FOOTER   , &usr);
423                 }
424         }
425
426         res = res ? do_samr_close(smb_cli,
427                     &info->dom.samr_pol_connect) : False;
428
429         res = res ? do_samr_close(smb_cli,
430                     &info->dom.samr_pol_open_domain) : False;
431
432         /* close the session */
433         cli_nt_session_close(smb_cli);
434
435         if (res)
436         {
437                 DEBUG(5,("cmd_sam_query_user: succeeded\n"));
438         }
439         else
440         {
441                 DEBUG(5,("cmd_sam_query_user: failed\n"));
442         }
443 }
444
445
446 /****************************************************************************
447 experimental SAM groups query.
448 ****************************************************************************/
449 void cmd_sam_query_groups(struct client_info *info)
450 {
451         fstring srv_name;
452         fstring domain;
453         fstring sid;
454         DOM_SID sid1;
455         BOOL res = True;
456         fstring info_str;
457         uint32 switch_value = 2;
458         uint32 admin_rid = 0x304; /* absolutely no idea. */
459
460         fstrcpy(sid   , info->dom.level5_sid);
461         fstrcpy(domain, info->dom.level5_dom);
462
463         if (strlen(sid) == 0)
464         {
465                 fprintf(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
466                 return;
467         }
468
469         make_dom_sid(&sid1, sid);
470
471         fstrcpy(srv_name, "\\\\");
472         fstrcat(srv_name, info->dest_host);
473         strupper(srv_name);
474
475         if (next_token(NULL, info_str, NULL, sizeof(info_str)))
476         {
477                 switch_value = (uint32)strtol(info_str, (char**)NULL, 10);
478         }
479
480         fprintf(out_hnd, "SAM Query Groups: info level %d\n", switch_value);
481         fprintf(out_hnd, "From: %s To: %s Domain: %s SID: %s\n",
482                           info->myhostname, srv_name, domain, sid);
483
484         /* open SAMR session.  negotiate credentials */
485         res = res ? cli_nt_session_open(smb_cli, PIPE_SAMR) : False;
486
487         /* establish a connection. */
488         res = res ? do_samr_connect(smb_cli, 
489                                 srv_name, 0x00000020,
490                                 &info->dom.samr_pol_connect) : False;
491
492         /* connect to the domain */
493         res = res ? do_samr_open_domain(smb_cli, 
494                     &info->dom.samr_pol_connect, admin_rid, &sid1,
495                     &info->dom.samr_pol_open_domain) : False;
496
497         /* send a samr 0x8 command */
498         res = res ? do_samr_query_dom_info(smb_cli,
499                     &info->dom.samr_pol_open_domain, switch_value) : False;
500
501         res = res ? do_samr_close(smb_cli,
502                     &info->dom.samr_pol_connect) : False;
503
504         res = res ? do_samr_close(smb_cli, 
505                     &info->dom.samr_pol_open_domain) : False;
506
507         /* close the session */
508         cli_nt_session_close(smb_cli);
509
510         if (res)
511         {
512                 DEBUG(5,("cmd_sam_query_groups: succeeded\n"));
513         }
514         else
515         {
516                 DEBUG(5,("cmd_sam_query_groups: failed\n"));
517         }
518 }
519
520
521 /****************************************************************************
522 experimental SAM aliases query.
523 ****************************************************************************/
524 void cmd_sam_enum_aliases(struct client_info *info)
525 {
526         fstring srv_name;
527         fstring domain;
528         fstring sid;
529         DOM_SID sid1;
530         BOOL res = True;
531         BOOL request_user_info  = False;
532         BOOL request_alias_info = False;
533         uint32 admin_rid = 0x304; /* absolutely no idea. */
534         fstring tmp;
535
536         uint32 num_aliases = 3;
537         uint32 alias_rid[3] = { DOMAIN_GROUP_RID_ADMINS, DOMAIN_GROUP_RID_USERS, DOMAIN_GROUP_RID_GUESTS };
538         fstring alias_names [3];
539         uint32  num_als_usrs[3];
540
541         fstrcpy(sid   , info->dom.level3_sid);
542         fstrcpy(domain, info->dom.level3_dom);
543 #if 0
544         fstrcpy(sid   , "S-1-5-20");
545 #endif
546         if (strlen(sid) == 0)
547         {
548                 fprintf(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
549                 return;
550         }
551
552         make_dom_sid(&sid1, sid);
553
554         fstrcpy(srv_name, "\\\\");
555         fstrcat(srv_name, info->dest_host);
556         strupper(srv_name);
557
558         /* a bad way to do token parsing... */
559         if (next_token(NULL, tmp, NULL, sizeof(tmp)))
560         {
561                 request_user_info  |= strequal(tmp, "-u");
562                 request_alias_info |= strequal(tmp, "-g");
563         }
564
565         if (next_token(NULL, tmp, NULL, sizeof(tmp)))
566         {
567                 request_user_info  |= strequal(tmp, "-u");
568                 request_alias_info |= strequal(tmp, "-g");
569         }
570
571         fprintf(out_hnd, "SAM Enumerate Aliases\n");
572         fprintf(out_hnd, "From: %s To: %s Domain: %s SID: %s\n",
573                           info->myhostname, srv_name, domain, sid);
574
575         /* open SAMR session.  negotiate credentials */
576         res = res ? cli_nt_session_open(smb_cli, PIPE_SAMR) : False;
577
578         /* establish a connection. */
579         res = res ? do_samr_connect(smb_cli,
580                                 srv_name, 0x00000020,
581                                 &info->dom.samr_pol_connect) : False;
582
583         /* connect to the domain */
584         res = res ? do_samr_open_domain(smb_cli,
585                     &info->dom.samr_pol_connect, admin_rid, &sid1,
586                     &info->dom.samr_pol_open_domain) : False;
587
588         /* send a query on the aliase */
589         res = res ? do_samr_query_unknown_12(smb_cli,
590                     &info->dom.samr_pol_open_domain, admin_rid, num_aliases, alias_rid,
591                     &num_aliases, alias_names, num_als_usrs) : False;
592
593         if (res)
594         {
595                 display_alias_name_info(out_hnd, ACTION_HEADER   , num_aliases, alias_names, num_als_usrs);
596                 display_alias_name_info(out_hnd, ACTION_ENUMERATE, num_aliases, alias_names, num_als_usrs);
597                 display_alias_name_info(out_hnd, ACTION_FOOTER   , num_aliases, alias_names, num_als_usrs);
598         }
599
600 #if 0
601
602         /* read some users */
603         res = res ? do_samr_enum_dom_users(smb_cli,
604                                 &info->dom.samr_pol_open_domain,
605                     num_entries, unk_0, acb_mask, unk_1, 0xffff,
606                                 info->dom.sam, &info->dom.num_sam_entries) : False;
607
608         if (res && info->dom.num_sam_entries == 0)
609         {
610                 fprintf(out_hnd, "No users\n");
611         }
612
613         if (request_user_info || request_alias_info)
614         {
615                 /* query all the users */
616                 user_idx = 0;
617
618                 while (res && user_idx < info->dom.num_sam_entries)
619                 {
620                         uint32 user_rid = info->dom.sam[user_idx].smb_userid;
621                         SAM_USER_INFO_21 usr;
622
623                         fprintf(out_hnd, "User RID: %8x  User Name: %s\n",
624                                           user_rid,
625                                           info->dom.sam[user_idx].acct_name);
626
627                         if (request_user_info)
628                         {
629                                 /* send user info query, level 0x15 */
630                                 if (get_samr_query_userinfo(smb_cli,
631                                                         &info->dom.samr_pol_open_domain,
632                                                         0x15, user_rid, &usr))
633                                 {
634                                         display_sam_user_info_21(out_hnd, ACTION_HEADER   , &usr);
635                                         display_sam_user_info_21(out_hnd, ACTION_ENUMERATE, &usr);
636                                         display_sam_user_info_21(out_hnd, ACTION_FOOTER   , &usr);
637                                 }
638                         }
639
640                         if (request_alias_info)
641                         {
642                                 uint32 num_aliases;
643                                 DOM_GID gid[LSA_MAX_GROUPS];
644
645                                 /* send user aliase query */
646                                 if (get_samr_query_useraliases(smb_cli, 
647                                                         &info->dom.samr_pol_open_domain,
648                                                         user_rid, &num_aliases, gid))
649                                 {
650                                         display_alias_info(out_hnd, ACTION_HEADER   , num_aliases, gid);
651                                         display_alias_info(out_hnd, ACTION_ENUMERATE, num_aliases, gid);
652                                         display_alias_info(out_hnd, ACTION_FOOTER   , num_aliases, gid);
653                                 }
654                         }
655
656                         user_idx++;
657                 }
658         }
659 #endif
660
661         res = res ? do_samr_close(smb_cli, 
662                     &info->dom.samr_pol_connect) : False;
663
664         res = res ? do_samr_close(smb_cli,
665                     &info->dom.samr_pol_open_domain) : False;
666
667         /* close the session */
668         cli_nt_session_close(smb_cli);
669
670         if (res)
671         {
672                 DEBUG(5,("cmd_sam_enum_users: succeeded\n"));
673         }
674         else
675         {
676                 DEBUG(5,("cmd_sam_enum_users: failed\n"));
677         }
678 }
679
680