source4/torture/libnet/libnet_user.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Test suite for libnet calls.
   4
   5    Copyright (C) Rafal Szczesniak 2005
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #include "includes.h"
  22 #include "system/time.h"
  23 #include "lib/cmdline/popt_common.h"
  24 #include "libnet/libnet.h"
  25 #include "librpc/gen_ndr/ndr_samr_c.h"
  26 #include "librpc/gen_ndr/ndr_lsa_c.h"
  27 #include "torture/torture.h"
  28 #include "torture/rpc/rpc.h"
  29 #include "torture/libnet/usertest.h"
  30 #include "param/param.h"
  31
  32
  33 static bool test_cleanup(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
  34                          struct policy_handle *domain_handle, const char *username)
  35 {
  36         NTSTATUS status;
  37         struct samr_LookupNames r1;
  38         struct samr_OpenUser r2;
  39         struct samr_DeleteUser r3;
  40         struct lsa_String names[2];
  41         uint32_t rid;
  42         struct policy_handle user_handle;
  43         struct samr_Ids rids, types;
  44
  45         names[0].string = username;
  46
  47         r1.in.domain_handle  = domain_handle;
  48         r1.in.num_names      = 1;
  49         r1.in.names          = names;
  50         r1.out.rids          = &rids;
  51         r1.out.types         = &types;
  52
  53         printf("user account lookup '%s'\n", username);
  54
  55         status = dcerpc_samr_LookupNames(p, mem_ctx, &r1);
  56         if (!NT_STATUS_IS_OK(status)) {
  57                 printf("LookupNames failed - %s\n", nt_errstr(status));
  58                 return false;
  59         }
  60
  61         rid = r1.out.rids->ids[0];
  62
  63         r2.in.domain_handle  = domain_handle;
  64         r2.in.access_mask    = SEC_FLAG_MAXIMUM_ALLOWED;
  65         r2.in.rid            = rid;
  66         r2.out.user_handle   = &user_handle;
  67
  68         printf("opening user account\n");
  69
  70         status = dcerpc_samr_OpenUser(p, mem_ctx, &r2);
  71         if (!NT_STATUS_IS_OK(status)) {
  72                 printf("OpenUser failed - %s\n", nt_errstr(status));
  73                 return false;
  74         }
  75
  76         r3.in.user_handle  = &user_handle;
  77         r3.out.user_handle = &user_handle;
  78
  79         printf("deleting user account\n");
  80
  81         status = dcerpc_samr_DeleteUser(p, mem_ctx, &r3);
  82         if (!NT_STATUS_IS_OK(status)) {
  83                 printf("DeleteUser failed - %s\n", nt_errstr(status));
  84                 return false;
  85         }
  86
  87         return true;
  88 }
  89
  90
  91 static bool test_opendomain(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
  92                             struct policy_handle *handle, struct lsa_String *domname)
  93 {
  94         NTSTATUS status;
  95         struct policy_handle h, domain_handle;
  96         struct samr_Connect r1;
  97         struct samr_LookupDomain r2;
  98         struct dom_sid2 *sid = NULL;
  99         struct samr_OpenDomain r3;
 100
 101         printf("connecting\n");
 102
 103         r1.in.system_name = 0;
 104         r1.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
 105         r1.out.connect_handle = &h;
 106
 107         status = dcerpc_samr_Connect(p, mem_ctx, &r1);
 108         if (!NT_STATUS_IS_OK(status)) {
 109                 printf("Connect failed - %s\n", nt_errstr(status));
 110                 return false;
 111         }
 112
 113         r2.in.connect_handle = &h;
 114         r2.in.domain_name = domname;
 115         r2.out.sid = &sid;
 116
 117         printf("domain lookup on %s\n", domname->string);
 118
 119         status = dcerpc_samr_LookupDomain(p, mem_ctx, &r2);
 120         if (!NT_STATUS_IS_OK(status)) {
 121                 printf("LookupDomain failed - %s\n", nt_errstr(status));
 122                 return false;
 123         }
 124
 125         r3.in.connect_handle = &h;
 126         r3.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
 127         r3.in.sid = *r2.out.sid;
 128         r3.out.domain_handle = &domain_handle;
 129
 130         printf("opening domain\n");
 131
 132         status = dcerpc_samr_OpenDomain(p, mem_ctx, &r3);
 133         if (!NT_STATUS_IS_OK(status)) {
 134                 printf("OpenDomain failed - %s\n", nt_errstr(status));
 135                 return false;
 136         } else {
 137                 *handle = domain_handle;
 138         }
 139
 140         return true;
 141 }
 142
 143
 144 static bool test_samr_close(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
 145                             struct policy_handle *domain_handle)
 146 {
 147         NTSTATUS status;
 148         struct samr_Close r;
 149
 150         r.in.handle = domain_handle;
 151         r.out.handle = domain_handle;
 152
 153         status = dcerpc_samr_Close(p, mem_ctx, &r);
 154         if (!NT_STATUS_IS_OK(status)) {
 155                 printf("Close samr domain failed - %s\n", nt_errstr(status));
 156                 return false;
 157         }
 158
 159         return true;
 160 }
 161
 162
 163 static bool test_lsa_close(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
 164                            struct policy_handle *domain_handle)
 165 {
 166         NTSTATUS status;
 167         struct lsa_Close r;
 168
 169         r.in.handle = domain_handle;
 170         r.out.handle = domain_handle;
 171
 172         status = dcerpc_lsa_Close(p, mem_ctx, &r);
 173         if (!NT_STATUS_IS_OK(status)) {
 174                 printf("Close lsa domain failed - %s\n", nt_errstr(status));
 175                 return false;
 176         }
 177
 178         return true;
 179 }
 180
 181
 182 static bool test_createuser(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
 183                             struct policy_handle *handle, const char* user)
 184 {
 185         NTSTATUS status;
 186         struct policy_handle user_handle;
 187         struct lsa_String username;
 188         struct samr_CreateUser r1;
 189         struct samr_Close r2;
 190         uint32_t user_rid;
 191
 192         username.string = user;
 193
 194         r1.in.domain_handle = handle;
 195         r1.in.account_name = &username;
 196         r1.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
 197         r1.out.user_handle = &user_handle;
 198         r1.out.rid = &user_rid;
 199
 200         printf("creating user '%s'\n", username.string);
 201
 202         status = dcerpc_samr_CreateUser(p, mem_ctx, &r1);
 203         if (!NT_STATUS_IS_OK(status)) {
 204                 printf("CreateUser failed - %s\n", nt_errstr(status));
 205
 206                 if (NT_STATUS_EQUAL(status, NT_STATUS_USER_EXISTS)) {
 207                         printf("User (%s) already exists - attempting to delete and recreate account again\n", user);
 208                         if (!test_cleanup(p, mem_ctx, handle, TEST_USERNAME)) {
 209                                 return false;
 210                         }
 211
 212                         printf("creating user account\n");
 213
 214                         status = dcerpc_samr_CreateUser(p, mem_ctx, &r1);
 215                         if (!NT_STATUS_IS_OK(status)) {
 216                                 printf("CreateUser failed - %s\n", nt_errstr(status));
 217                                 return false;
 218                         }
 219                         return true;
 220                 }
 221                 return false;
 222         }
 223
 224         r2.in.handle = &user_handle;
 225         r2.out.handle = &user_handle;
 226
 227         printf("closing user '%s'\n", username.string);
 228
 229         status = dcerpc_samr_Close(p, mem_ctx, &r2);
 230         if (!NT_STATUS_IS_OK(status)) {
 231                 printf("Close failed - %s\n", nt_errstr(status));
 232                 return false;
 233         }
 234
 235         return true;
 236 }
 237
 238
 239 bool torture_createuser(struct torture_context *torture)
 240 {
 241         NTSTATUS status;
 242         TALLOC_CTX *mem_ctx;
 243         struct libnet_context *ctx;
 244         struct libnet_CreateUser req;
 245         bool ret = true;
 246
 247         mem_ctx = talloc_init("test_createuser");
 248
 249         ctx = libnet_context_init(torture->ev, torture->lp_ctx);
 250         ctx->cred = cmdline_credentials;
 251
 252         req.in.user_name = TEST_USERNAME;
 253         req.in.domain_name = lp_workgroup(torture->lp_ctx);
 254         req.out.error_string = NULL;
 255
 256         status = libnet_CreateUser(ctx, mem_ctx, &req);
 257         if (!NT_STATUS_IS_OK(status)) {
 258                 printf("libnet_CreateUser call failed: %s\n", nt_errstr(status));
 259                 ret = false;
 260                 goto done;
 261         }
 262
 263         if (!test_cleanup(ctx->samr.pipe, mem_ctx, &ctx->samr.handle, TEST_USERNAME)) {
 264                 printf("cleanup failed\n");
 265                 ret = false;
 266                 goto done;
 267         }
 268
 269         if (!test_samr_close(ctx->samr.pipe, mem_ctx, &ctx->samr.handle)) {
 270                 printf("domain close failed\n");
 271                 ret = false;
 272         }
 273
 274 done:
 275         talloc_free(ctx);
 276         talloc_free(mem_ctx);
 277         return ret;
 278 }
 279
 280
 281 bool torture_deleteuser(struct torture_context *torture)
 282 {
 283         NTSTATUS status;
 284         struct dcerpc_pipe *p;
 285         TALLOC_CTX *prep_mem_ctx, *mem_ctx;
 286         struct policy_handle h;
 287         struct lsa_String domain_name;
 288         const char *name = TEST_USERNAME;
 289         struct libnet_context *ctx;
 290         struct libnet_DeleteUser req;
 291         bool ret = true;
 292
 293         prep_mem_ctx = talloc_init("prepare test_deleteuser");
 294
 295         ctx = libnet_context_init(torture->ev, torture->lp_ctx);
 296         ctx->cred = cmdline_credentials;
 297
 298         req.in.user_name = TEST_USERNAME;
 299         req.in.domain_name = lp_workgroup(torture->lp_ctx);
 300
 301         status = torture_rpc_connection(torture,
 302                                         &p,
 303                                         &ndr_table_samr);
 304         if (!NT_STATUS_IS_OK(status)) {
 305                 ret = false;
 306                 goto done;
 307         }
 308
 309         domain_name.string = lp_workgroup(torture->lp_ctx);
 310         if (!test_opendomain(p, prep_mem_ctx, &h, &domain_name)) {
 311                 ret = false;
 312                 goto done;
 313         }
 314
 315         if (!test_createuser(p, prep_mem_ctx, &h, name)) {
 316                 ret = false;
 317                 goto done;
 318         }
 319
 320         mem_ctx = talloc_init("test_deleteuser");
 321
 322         status = libnet_DeleteUser(ctx, mem_ctx, &req);
 323         if (!NT_STATUS_IS_OK(status)) {
 324                 printf("libnet_DeleteUser call failed: %s\n", nt_errstr(status));
 325                 ret = false;
 326         }
 327
 328         talloc_free(mem_ctx);
 329
 330 done:
 331         talloc_free(ctx);
 332         talloc_free(prep_mem_ctx);
 333         return ret;
 334 }
 335
 336
 337 /*
 338   Generate testing set of random changes
 339 */
 340
 341 static void set_test_changes(TALLOC_CTX *mem_ctx, struct libnet_ModifyUser *r,
 342                              int num_changes, char **user_name, enum test_fields req_change)
 343 {
 344         const char* logon_scripts[] = { "start_login.cmd", "login.bat", "start.cmd" };
 345         const char* home_dirs[] = { "\\\\srv\\home", "\\\\homesrv\\home\\user", "\\\\pdcsrv\\domain" };
 346         const char* home_drives[] = { "H:", "z:", "I:", "J:", "n:" };
 347         const uint32_t flags[] = { (ACB_DISABLED | ACB_NORMAL | ACB_PW_EXPIRED),
 348                                    (ACB_NORMAL | ACB_PWNOEXP),
 349                                    (ACB_NORMAL | ACB_PW_EXPIRED) };
 350         const char *homedir, *homedrive, *logonscript;
 351         struct timeval now;
 352         int i, testfld;
 353
 354         printf("Fields to change: [");
 355
 356         for (i = 0; i < num_changes && i < FIELDS_NUM; i++) {
 357                 const char *fldname;
 358
 359                 testfld = (req_change == none) ? (random() % FIELDS_NUM) : req_change;
 360
 361                 /* get one in case we hit time field this time */
 362                 gettimeofday(&now, NULL);
 363
 364                 switch (testfld) {
 365                 case account_name:
 366                         continue_if_field_set(r->in.account_name);
 367                         r->in.account_name = talloc_asprintf(mem_ctx, TEST_CHG_ACCOUNTNAME,
 368                                                              (int)(random() % 100));
 369                         fldname = "account_name";
 370
 371                         /* update the test's user name in case it's about to change */
 372                         *user_name = talloc_strdup(mem_ctx, r->in.account_name);
 373                         break;
 374
 375                 case full_name:
 376                         continue_if_field_set(r->in.full_name);
 377                         r->in.full_name = talloc_asprintf(mem_ctx, TEST_CHG_FULLNAME,
 378                                                           (unsigned int)random(), (unsigned int)random());
 379                         fldname = "full_name";
 380                         break;
 381
 382                 case description:
 383                         continue_if_field_set(r->in.description);
 384                         r->in.description = talloc_asprintf(mem_ctx, TEST_CHG_DESCRIPTION,
 385                                                             (long)random());
 386                         fldname = "description";
 387                         break;
 388
 389                 case home_directory:
 390                         continue_if_field_set(r->in.home_directory);
 391                         homedir = home_dirs[random() % ARRAY_SIZE(home_dirs)];
 392                         r->in.home_directory = talloc_strdup(mem_ctx, homedir);
 393                         fldname = "home_dir";
 394                         break;
 395
 396                 case home_drive:
 397                         continue_if_field_set(r->in.home_drive);
 398                         homedrive = home_drives[random() % ARRAY_SIZE(home_drives)];
 399                         r->in.home_drive = talloc_strdup(mem_ctx, homedrive);
 400                         fldname = "home_drive";
 401                         break;
 402
 403                 case comment:
 404                         continue_if_field_set(r->in.comment);
 405                         r->in.comment = talloc_asprintf(mem_ctx, TEST_CHG_COMMENT,
 406                                                         (unsigned long)random(), (unsigned long)random());
 407                         fldname = "comment";
 408                         break;
 409
 410                 case logon_script:
 411                         continue_if_field_set(r->in.logon_script);
 412                         logonscript = logon_scripts[random() % ARRAY_SIZE(logon_scripts)];
 413                         r->in.logon_script = talloc_strdup(mem_ctx, logonscript);
 414                         fldname = "logon_script";
 415                         break;
 416
 417                 case profile_path:
 418                         continue_if_field_set(r->in.profile_path);
 419                         r->in.profile_path = talloc_asprintf(mem_ctx, TEST_CHG_PROFILEPATH,
 420                                                              (unsigned long)random(), (unsigned int)random());
 421                         fldname = "profile_path";
 422                         break;
 423
 424                 case acct_expiry:
 425                         continue_if_field_set(r->in.acct_expiry);
 426                         now = timeval_add(&now, (random() % (31*24*60*60)), 0);
 427                         r->in.acct_expiry = (struct timeval *)talloc_memdup(mem_ctx, &now, sizeof(now));
 428                         fldname = "acct_expiry";
 429                         break;
 430
 431                 case acct_flags:
 432                         continue_if_field_set(r->in.acct_flags);
 433                         r->in.acct_flags = flags[random() % ARRAY_SIZE(flags)];
 434                         fldname = "acct_flags";
 435                         break;
 436
 437                 default:
 438                         fldname = "unknown_field";
 439                 }
 440
 441                 printf(((i < num_changes - 1) ? "%s," : "%s"), fldname);
 442
 443                 /* disable requested field (it's supposed to be the only one used) */
 444                 if (req_change != none) req_change = none;
 445         }
 446
 447         printf("]\n");
 448 }
 449
 450
 451 #define TEST_STR_FLD(fld) \
 452         if (!strequal(req.in.fld, user_req.out.fld)) { \
 453                 printf("failed to change '%s'\n", #fld); \
 454                 ret = false; \
 455                 goto cleanup; \
 456         }
 457
 458 #define TEST_TIME_FLD(fld) \
 459         if (timeval_compare(req.in.fld, user_req.out.fld)) { \
 460                 printf("failed to change '%s'\n", #fld); \
 461                 ret = false; \
 462                 goto cleanup; \
 463         }
 464
 465 #define TEST_NUM_FLD(fld) \
 466         if (req.in.fld != user_req.out.fld) { \
 467                 printf("failed to change '%s'\n", #fld); \
 468                 ret = false; \
 469                 goto cleanup; \
 470         }
 471
 472
 473 bool torture_modifyuser(struct torture_context *torture)
 474 {
 475         NTSTATUS status;
 476         struct dcerpc_binding *binding;
 477         struct dcerpc_pipe *p;
 478         TALLOC_CTX *prep_mem_ctx;
 479         struct policy_handle h;
 480         struct lsa_String domain_name;
 481         char *name;
 482         struct libnet_context *ctx;
 483         struct libnet_ModifyUser req;
 484         struct libnet_UserInfo user_req;
 485         int fld;
 486         bool ret = true;
 487
 488         prep_mem_ctx = talloc_init("prepare test_deleteuser");
 489
 490         ctx = libnet_context_init(torture->ev, torture->lp_ctx);
 491         ctx->cred = cmdline_credentials;
 492
 493         status = torture_rpc_connection(torture,
 494                                         &p,
 495                                         &ndr_table_samr);
 496         if (!NT_STATUS_IS_OK(status)) {
 497                 ret = false;
 498                 goto done;
 499         }
 500
 501         name = talloc_strdup(prep_mem_ctx, TEST_USERNAME);
 502
 503         domain_name.string = lp_workgroup(torture->lp_ctx);
 504         if (!test_opendomain(p, prep_mem_ctx, &h, &domain_name)) {
 505                 ret = false;
 506                 goto done;
 507         }
 508
 509         if (!test_createuser(p, prep_mem_ctx, &h, name)) {
 510                 ret = false;
 511                 goto done;
 512         }
 513
 514         status = torture_rpc_binding(torture, &binding);
 515         if (!NT_STATUS_IS_OK(status)) {
 516                 ret = false;
 517                 goto done;
 518         }
 519
 520         printf("Testing change of all fields - each single one in turn\n");
 521
 522         for (fld = 1; fld < FIELDS_NUM - 1; fld++) {
 523                 ZERO_STRUCT(req);
 524                 req.in.domain_name = lp_workgroup(torture->lp_ctx);
 525                 req.in.user_name = name;
 526
 527                 set_test_changes(torture, &req, 1, &name, fld);
 528
 529                 status = libnet_ModifyUser(ctx, torture, &req);
 530                 if (!NT_STATUS_IS_OK(status)) {
 531                         printf("libnet_ModifyUser call failed: %s\n", nt_errstr(status));
 532                         ret = false;
 533                         continue;
 534                 }
 535
 536                 ZERO_STRUCT(user_req);
 537                 user_req.in.domain_name = lp_workgroup(torture->lp_ctx);
 538                 user_req.in.data.user_name = name;
 539                 user_req.in.level = USER_INFO_BY_NAME;
 540
 541                 status = libnet_UserInfo(ctx, torture, &user_req);
 542                 if (!NT_STATUS_IS_OK(status)) {
 543                         printf("libnet_UserInfo call failed: %s\n", nt_errstr(status));
 544                         ret = false;
 545                         continue;
 546                 }
 547
 548                 switch (fld) {
 549                 case account_name: TEST_STR_FLD(account_name);
 550                         break;
 551                 case full_name: TEST_STR_FLD(full_name);
 552                         break;
 553                 case comment: TEST_STR_FLD(comment);
 554                         break;
 555                 case description: TEST_STR_FLD(description);
 556                         break;
 557                 case home_directory: TEST_STR_FLD(home_directory);
 558                         break;
 559                 case home_drive: TEST_STR_FLD(home_drive);
 560                         break;
 561                 case logon_script: TEST_STR_FLD(logon_script);
 562                         break;
 563                 case profile_path: TEST_STR_FLD(profile_path);
 564                         break;
 565                 case acct_expiry: TEST_TIME_FLD(acct_expiry);
 566                         break;
 567                 case acct_flags: TEST_NUM_FLD(acct_flags);
 568                         break;
 569                 default:
 570                         break;
 571                 }
 572
 573                 if (fld == account_name) {
 574                         /* restore original testing username - it's useful when test fails
 575                            because it prevents from problems with recreating account */
 576                         ZERO_STRUCT(req);
 577                         req.in.domain_name = lp_workgroup(torture->lp_ctx);
 578                         req.in.user_name = name;
 579                         req.in.account_name = TEST_USERNAME;
 580
 581                         status = libnet_ModifyUser(ctx, torture, &req);
 582                         if (!NT_STATUS_IS_OK(status)) {
 583                                 printf("libnet_ModifyUser call failed: %s\n", nt_errstr(status));
 584                                 ret = false;
 585                                 goto done;
 586                         }
 587
 588                         name = talloc_strdup(torture, TEST_USERNAME);
 589                 }
 590         }
 591
 592 cleanup:
 593         if (!test_cleanup(ctx->samr.pipe, torture, &ctx->samr.handle, name)) {
 594                 printf("cleanup failed\n");
 595                 ret = false;
 596                 goto done;
 597         }
 598
 599         if (!test_samr_close(ctx->samr.pipe, torture, &ctx->samr.handle)) {
 600                 printf("domain close failed\n");
 601                 ret = false;
 602         }
 603
 604 done:
 605         talloc_free(ctx);
 606         talloc_free(prep_mem_ctx);
 607         return ret;
 608 }
 609
 610
 611 bool torture_userinfo_api(struct torture_context *torture)
 612 {
 613         const char *name = TEST_USERNAME;
 614         bool ret = true;
 615         NTSTATUS status;
 616         TALLOC_CTX *mem_ctx = NULL, *prep_mem_ctx;
 617         struct libnet_context *ctx;
 618         struct dcerpc_pipe *p;
 619         struct policy_handle h;
 620         struct lsa_String domain_name;
 621         struct libnet_UserInfo req;
 622
 623         prep_mem_ctx = talloc_init("prepare torture user info");
 624
 625         ctx = libnet_context_init(torture->ev, torture->lp_ctx);
 626         ctx->cred = cmdline_credentials;
 627
 628         status = torture_rpc_connection(torture,
 629                                         &p,
 630                                         &ndr_table_samr);
 631         if (!NT_STATUS_IS_OK(status)) {
 632                 return false;
 633         }
 634
 635         domain_name.string = lp_workgroup(torture->lp_ctx);
 636         if (!test_opendomain(p, prep_mem_ctx, &h, &domain_name)) {
 637                 ret = false;
 638                 goto done;
 639         }
 640
 641         if (!test_createuser(p, prep_mem_ctx, &h, name)) {
 642                 ret = false;
 643                 goto done;
 644         }
 645
 646         mem_ctx = talloc_init("torture user info");
 647
 648         ZERO_STRUCT(req);
 649
 650         req.in.domain_name = domain_name.string;
 651         req.in.data.user_name   = name;
 652         req.in.level = USER_INFO_BY_NAME;
 653
 654         status = libnet_UserInfo(ctx, mem_ctx, &req);
 655         if (!NT_STATUS_IS_OK(status)) {
 656                 printf("libnet_UserInfo call failed: %s\n", nt_errstr(status));
 657                 ret = false;
 658                 talloc_free(mem_ctx);
 659                 goto done;
 660         }
 661
 662         if (!test_cleanup(ctx->samr.pipe, mem_ctx, &ctx->samr.handle, TEST_USERNAME)) {
 663                 printf("cleanup failed\n");
 664                 ret = false;
 665                 goto done;
 666         }
 667
 668         if (!test_samr_close(ctx->samr.pipe, mem_ctx, &ctx->samr.handle)) {
 669                 printf("domain close failed\n");
 670                 ret = false;
 671         }
 672
 673         talloc_free(ctx);
 674
 675 done:
 676         talloc_free(mem_ctx);
 677         return ret;
 678 }
 679
 680
 681 bool torture_userlist(struct torture_context *torture)
 682 {
 683         bool ret = true;
 684         NTSTATUS status;
 685         TALLOC_CTX *mem_ctx = NULL;
 686         struct libnet_context *ctx;
 687         struct lsa_String domain_name;
 688         struct libnet_UserList req;
 689         int i;
 690
 691         ctx = libnet_context_init(torture->ev, torture->lp_ctx);
 692         ctx->cred = cmdline_credentials;
 693
 694         domain_name.string = lp_workgroup(torture->lp_ctx);
 695         mem_ctx = talloc_init("torture user list");
 696
 697         ZERO_STRUCT(req);
 698
 699         printf("listing user accounts:\n");
 700
 701         do {
 702
 703                 req.in.domain_name = domain_name.string;
 704                 req.in.page_size   = 128;
 705                 req.in.resume_index = req.out.resume_index;
 706
 707                 status = libnet_UserList(ctx, mem_ctx, &req);
 708                 if (!NT_STATUS_IS_OK(status) &&
 709                     !NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES)) break;
 710
 711                 for (i = 0; i < req.out.count; i++) {
 712                         printf("\tuser: %s, sid=%s\n",
 713                                req.out.users[i].username, req.out.users[i].sid);
 714                 }
 715
 716         } while (NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES));
 717
 718         if (!(NT_STATUS_IS_OK(status) ||
 719               NT_STATUS_EQUAL(status, NT_STATUS_NO_MORE_ENTRIES))) {
 720                 printf("libnet_UserList call failed: %s\n", nt_errstr(status));
 721                 ret = false;
 722                 goto done;
 723         }
 724
 725         if (!test_samr_close(ctx->samr.pipe, mem_ctx, &ctx->samr.handle)) {
 726                 printf("samr domain close failed\n");
 727                 ret = false;
 728                 goto done;
 729         }
 730
 731         if (!test_lsa_close(ctx->lsa.pipe, mem_ctx, &ctx->lsa.handle)) {
 732                 printf("lsa domain close failed\n");
 733                 ret = false;
 734         }
 735
 736         talloc_free(ctx);
 737
 738 done:
 739         talloc_free(mem_ctx);
 740         return ret;
 741 }