source4/torture/rpc/lsa.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    test suite for lsa rpc operations
   4
   5    Copyright (C) Andrew Tridgell 2003
   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 2 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, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23
  24 static void init_lsa_Name(struct lsa_Name *name, const char *s)
  25 {
  26         name->name = s;
  27 }
  28
  29 static BOOL test_OpenPolicy(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
  30 {
  31         struct lsa_ObjectAttribute attr;
  32         struct policy_handle handle;
  33         struct lsa_QosInfo qos;
  34         struct lsa_OpenPolicy r;
  35         NTSTATUS status;
  36         uint16 system_name = '\\';
  37
  38         printf("\ntesting OpenPolicy\n");
  39
  40         qos.len = 0;
  41         qos.impersonation_level = 2;
  42         qos.context_mode = 1;
  43         qos.effective_only = 0;
  44
  45         attr.len = 0;
  46         attr.root_dir = NULL;
  47         attr.object_name = NULL;
  48         attr.attributes = 0;
  49         attr.sec_desc = NULL;
  50         attr.sec_qos = &qos;
  51
  52         r.in.system_name = &system_name;
  53         r.in.attr = &attr;
  54         r.in.desired_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
  55         r.out.handle = &handle;
  56
  57         status = dcerpc_lsa_OpenPolicy(p, mem_ctx, &r);
  58         if (!NT_STATUS_IS_OK(status)) {
  59                 printf("OpenPolicy failed - %s\n", nt_errstr(status));
  60                 return False;
  61         }
  62
  63         return True;
  64 }
  65
  66
  67 static BOOL test_OpenPolicy2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
  68                              struct policy_handle *handle)
  69 {
  70         struct lsa_ObjectAttribute attr;
  71         struct lsa_QosInfo qos;
  72         struct lsa_OpenPolicy2 r;
  73         NTSTATUS status;
  74
  75         printf("\ntesting OpenPolicy2\n");
  76
  77         qos.len = 0;
  78         qos.impersonation_level = 2;
  79         qos.context_mode = 1;
  80         qos.effective_only = 0;
  81
  82         attr.len = 0;
  83         attr.root_dir = NULL;
  84         attr.object_name = NULL;
  85         attr.attributes = 0;
  86         attr.sec_desc = NULL;
  87         attr.sec_qos = &qos;
  88
  89         r.in.system_name = "\\";
  90         r.in.attr = &attr;
  91         r.in.desired_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
  92         r.out.handle = handle;
  93
  94         status = dcerpc_lsa_OpenPolicy2(p, mem_ctx, &r);
  95         if (!NT_STATUS_IS_OK(status)) {
  96                 printf("OpenPolicy2 failed - %s\n", nt_errstr(status));
  97                 return False;
  98         }
  99
 100         return True;
 101 }
 102
 103 static BOOL test_LookupNames(struct dcerpc_pipe *p,
 104                             TALLOC_CTX *mem_ctx,
 105                             struct policy_handle *handle,
 106                             struct lsa_TransNameArray *tnames)
 107 {
 108         struct lsa_LookupNames r;
 109         struct lsa_TransSidArray sids;
 110         struct lsa_Name *names;
 111         uint32 count = 0;
 112         NTSTATUS status;
 113         int i;
 114
 115         printf("\nTesting LookupNames\n");
 116
 117         sids.count = 0;
 118         sids.sids = NULL;
 119
 120         names = talloc(mem_ctx, tnames->count * sizeof(names[0]));
 121         for (i=0;i<tnames->count;i++) {
 122                 init_lsa_Name(&names[i], tnames->names[i].name.name);
 123         }
 124
 125         r.in.handle = handle;
 126         r.in.num_names = tnames->count;
 127         r.in.names = names;
 128         r.in.sids = &sids;
 129         r.in.level = 1;
 130         r.in.count = &count;
 131         r.out.count = &count;
 132         r.out.sids = &sids;
 133
 134         status = dcerpc_lsa_LookupNames(p, mem_ctx, &r);
 135         if (!NT_STATUS_IS_OK(status) && !NT_STATUS_EQUAL(status, STATUS_SOME_UNMAPPED)) {
 136                 printf("LookupNames failed - %s\n", nt_errstr(status));
 137                 return False;
 138         }
 139
 140         printf("\n");
 141
 142         return True;
 143 }
 144
 145
 146 static BOOL test_LookupSids(struct dcerpc_pipe *p,
 147                             TALLOC_CTX *mem_ctx,
 148                             struct policy_handle *handle,
 149                             struct lsa_SidArray *sids)
 150 {
 151         struct lsa_LookupSids r;
 152         struct lsa_TransNameArray names;
 153         uint32 count = sids->num_sids;
 154         NTSTATUS status;
 155
 156         printf("\nTesting LookupSids\n");
 157
 158         names.count = 0;
 159         names.names = NULL;
 160
 161         r.in.handle = handle;
 162         r.in.sids = sids;
 163         r.in.names = &names;
 164         r.in.level = 1;
 165         r.in.count = &count;
 166         r.out.count = &count;
 167         r.out.names = &names;
 168
 169         status = dcerpc_lsa_LookupSids(p, mem_ctx, &r);
 170         if (!NT_STATUS_IS_OK(status) && !NT_STATUS_EQUAL(status, STATUS_SOME_UNMAPPED)) {
 171                 printf("LookupSids failed - %s\n", nt_errstr(status));
 172                 return False;
 173         }
 174
 175         printf("\n");
 176
 177         if (!test_LookupNames(p, mem_ctx, handle, &names)) {
 178                 return False;
 179         }
 180
 181         return True;
 182 }
 183
 184 static BOOL test_LookupPrivName(struct dcerpc_pipe *p,
 185                                 TALLOC_CTX *mem_ctx,
 186                                 struct policy_handle *handle,
 187                                 struct lsa_LUID *luid)
 188 {
 189         NTSTATUS status;
 190         struct lsa_LookupPrivName r;
 191
 192         r.in.handle = handle;
 193         r.in.luid = luid;
 194
 195         status = dcerpc_lsa_LookupPrivName(p, mem_ctx, &r);
 196         if (!NT_STATUS_IS_OK(status)) {
 197                 printf("\nLookupPrivName failed - %s\n", nt_errstr(status));
 198                 return False;
 199         }
 200
 201         return True;
 202 }
 203
 204 static BOOL test_EnumPrivsAccount(struct dcerpc_pipe *p,
 205                                   TALLOC_CTX *mem_ctx,
 206                                   struct policy_handle *handle,
 207                                   struct policy_handle *acct_handle)
 208 {
 209         NTSTATUS status;
 210         struct lsa_EnumPrivsAccount r;
 211
 212         printf("Testing EnumPrivsAccount\n");
 213
 214         r.in.handle = acct_handle;
 215
 216         status = dcerpc_lsa_EnumPrivsAccount(p, mem_ctx, &r);
 217         if (!NT_STATUS_IS_OK(status)) {
 218                 printf("EnumPrivsAccount failed - %s\n", nt_errstr(status));
 219                 return False;
 220         }
 221
 222         if (r.out.privs) {
 223                 int i;
 224                 for (i=0;i<r.out.privs->count;i++) {
 225                         test_LookupPrivName(p, mem_ctx, handle,
 226                                             &r.out.privs->set[i].luid);
 227                 }
 228         }
 229
 230         return True;
 231 }
 232
 233 static BOOL test_Delete(struct dcerpc_pipe *p,
 234                        TALLOC_CTX *mem_ctx,
 235                        struct policy_handle *handle)
 236 {
 237         NTSTATUS status;
 238         struct lsa_Delete r;
 239
 240         printf("\ntesting Delete\n");
 241
 242         r.in.handle = handle;
 243         status = dcerpc_lsa_Delete(p, mem_ctx, &r);
 244         if (!NT_STATUS_IS_OK(status)) {
 245                 printf("Delete failed - %s\n", nt_errstr(status));
 246                 return False;
 247         }
 248
 249         printf("\n");
 250
 251         return True;
 252 }
 253
 254
 255 static BOOL find_domain_sid(struct dcerpc_pipe *p,
 256                             TALLOC_CTX *mem_ctx,
 257                             struct policy_handle *handle,
 258                             struct dom_sid2 **sid)
 259 {
 260         struct lsa_QueryInfoPolicy r;
 261         NTSTATUS status;
 262
 263         r.in.handle = handle;
 264         r.in.level = LSA_POLICY_INFO_DOMAIN;
 265
 266         status = dcerpc_lsa_QueryInfoPolicy(p, mem_ctx, &r);
 267
 268         if (!NT_STATUS_IS_OK(status)) {
 269                 printf("LSA_POLICY_INFO_DOMAIN failed - %s\n", nt_errstr(status));
 270                 return False;
 271         }
 272
 273         *sid = r.out.info->domain.sid;
 274
 275         return True;
 276 }
 277
 278 static struct dom_sid *sid_add_auth(TALLOC_CTX *mem_ctx,
 279                                     const struct dom_sid *sid,
 280                                     uint32 sub_auth)
 281 {
 282         struct dom_sid *ret;
 283
 284         ret = talloc_p(mem_ctx, struct dom_sid);
 285         if (!ret) {
 286                 return NULL;
 287         }
 288
 289         *ret = *sid;
 290
 291         ret->sub_auths = talloc_array_p(mem_ctx, uint32, ret->num_auths+1);
 292         if (!ret->sub_auths) {
 293                 return NULL;
 294         }
 295
 296         memcpy(ret->sub_auths, sid->sub_auths,
 297                ret->num_auths * sizeof(sid->sub_auths[0]));
 298         ret->sub_auths[ret->num_auths] = sub_auth;
 299         ret->num_auths++;
 300
 301         return ret;
 302 }
 303
 304 static BOOL test_CreateAccount(struct dcerpc_pipe *p,
 305                                TALLOC_CTX *mem_ctx,
 306                                struct policy_handle *handle)
 307 {
 308         NTSTATUS status;
 309         struct lsa_CreateAccount r;
 310         struct dom_sid2 *domsid, *newsid;
 311         struct policy_handle acct_handle;
 312
 313         if (!find_domain_sid(p, mem_ctx, handle, &domsid)) {
 314                 return False;
 315         }
 316
 317         newsid = sid_add_auth(mem_ctx, domsid, 0x1234abcd);
 318         if (!newsid) {
 319                 printf("Failed to create newsid\n");
 320                 return False;
 321         }
 322
 323         printf("Testing CreateAccount\n");
 324
 325         r.in.handle = handle;
 326         r.in.sid = newsid;
 327         r.in.desired_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
 328         r.out.acct_handle = &acct_handle;
 329
 330         status = dcerpc_lsa_CreateAccount(p, mem_ctx, &r);
 331         if (!NT_STATUS_IS_OK(status)) {
 332                 printf("CreateAccount failed - %s\n", nt_errstr(status));
 333                 return False;
 334         }
 335
 336         if (!test_Delete(p, mem_ctx, &acct_handle)) {
 337                 return False;
 338         }
 339
 340         return True;
 341 }
 342
 343
 344 static BOOL test_CreateTrustedDomain(struct dcerpc_pipe *p,
 345                                      TALLOC_CTX *mem_ctx,
 346                                      struct policy_handle *handle)
 347 {
 348         NTSTATUS status;
 349         struct lsa_CreateTrustedDomain r;
 350         struct lsa_TrustInformation trustinfo;
 351         struct dom_sid *domsid;
 352         struct policy_handle dom_handle;
 353
 354         printf("Testing CreateTrustedDomain\n");
 355
 356         if (!find_domain_sid(p, mem_ctx, handle, &domsid)) {
 357                 return False;
 358         }
 359
 360         domsid->sub_auths[domsid->num_auths-1] ^= 0xF0F0F0F0;
 361
 362         trustinfo.sid = domsid;
 363         init_lsa_Name(&trustinfo.name, "torturedomain");
 364
 365         r.in.handle = handle;
 366         r.in.info = &trustinfo;
 367         r.in.desired_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
 368         r.out.dom_handle = &dom_handle;
 369
 370         status = dcerpc_lsa_CreateTrustedDomain(p, mem_ctx, &r);
 371         if (!NT_STATUS_IS_OK(status)) {
 372                 printf("CreateTrustedDomain failed - %s\n", nt_errstr(status));
 373                 return False;
 374         }
 375
 376         if (!test_Delete(p, mem_ctx, &dom_handle)) {
 377                 return False;
 378         }
 379
 380         return True;
 381 }
 382
 383 static BOOL test_CreateSecret(struct dcerpc_pipe *p,
 384                               TALLOC_CTX *mem_ctx,
 385                               struct policy_handle *handle)
 386 {
 387         NTSTATUS status;
 388         struct lsa_CreateSecret r;
 389         struct policy_handle sec_handle;
 390
 391         printf("Testing CreateSecret\n");
 392
 393         init_lsa_Name(&r.in.name, "torturesecret");
 394
 395         r.in.handle = handle;
 396         r.in.desired_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
 397         r.out.sec_handle = &sec_handle;
 398
 399         status = dcerpc_lsa_CreateSecret(p, mem_ctx, &r);
 400         if (!NT_STATUS_IS_OK(status)) {
 401                 printf("CreateSecret failed - %s\n", nt_errstr(status));
 402                 return False;
 403         }
 404
 405         if (!test_Delete(p, mem_ctx, &sec_handle)) {
 406                 return False;
 407         }
 408
 409         return True;
 410 }
 411
 412 static BOOL test_EnumAccountRights(struct dcerpc_pipe *p,
 413                                    TALLOC_CTX *mem_ctx,
 414                                    struct policy_handle *acct_handle,
 415                                    struct dom_sid *sid)
 416 {
 417         NTSTATUS status;
 418         struct lsa_EnumAccountRights r;
 419         struct lsa_RightSet rights;
 420
 421         printf("Testing EnumAccountRights\n");
 422
 423         r.in.handle = acct_handle;
 424         r.in.sid = sid;
 425         r.out.rights = &rights;
 426
 427         status = dcerpc_lsa_EnumAccountRights(p, mem_ctx, &r);
 428         if (!NT_STATUS_IS_OK(status)) {
 429                 printf("EnumAccountRights failed - %s\n", nt_errstr(status));
 430                 return False;
 431         }
 432
 433         return True;
 434 }
 435
 436
 437 static BOOL test_QuerySecObj(struct dcerpc_pipe *p,
 438                              TALLOC_CTX *mem_ctx,
 439                              struct policy_handle *handle,
 440                              struct policy_handle *acct_handle)
 441 {
 442         NTSTATUS status;
 443         struct lsa_QuerySecObj r;
 444
 445         printf("Testing QuerySecObj\n");
 446
 447         r.in.handle = acct_handle;
 448         r.in.sec_info = 7;
 449
 450         status = dcerpc_lsa_QuerySecObj(p, mem_ctx, &r);
 451         if (!NT_STATUS_IS_OK(status)) {
 452                 printf("QuerySecObj failed - %s\n", nt_errstr(status));
 453                 return False;
 454         }
 455
 456         return True;
 457 }
 458
 459 static BOOL test_OpenAccount(struct dcerpc_pipe *p,
 460                              TALLOC_CTX *mem_ctx,
 461                              struct policy_handle *handle,
 462                              struct dom_sid *sid)
 463 {
 464         NTSTATUS status;
 465         struct lsa_OpenAccount r;
 466         struct policy_handle acct_handle;
 467
 468         printf("Testing OpenAccount\n");
 469
 470         r.in.handle = handle;
 471         r.in.sid = sid;
 472         r.in.desired_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
 473         r.out.acct_handle = &acct_handle;
 474
 475         status = dcerpc_lsa_OpenAccount(p, mem_ctx, &r);
 476         if (!NT_STATUS_IS_OK(status)) {
 477                 printf("OpenAccount failed - %s\n", nt_errstr(status));
 478                 return False;
 479         }
 480
 481         if (!test_EnumPrivsAccount(p, mem_ctx, handle, &acct_handle)) {
 482                 return False;
 483         }
 484
 485         if (!test_QuerySecObj(p, mem_ctx, handle, &acct_handle)) {
 486                 return False;
 487         }
 488
 489         return True;
 490 }
 491
 492 static BOOL test_EnumAccounts(struct dcerpc_pipe *p,
 493                           TALLOC_CTX *mem_ctx,
 494                           struct policy_handle *handle)
 495 {
 496         NTSTATUS status;
 497         struct lsa_EnumAccounts r;
 498         struct lsa_SidArray sids1, sids2;
 499         uint32 resume_handle = 0;
 500         int i;
 501
 502         printf("\ntesting EnumAccounts\n");
 503
 504         r.in.handle = handle;
 505         r.in.resume_handle = &resume_handle;
 506         r.in.num_entries = 100;
 507         r.out.resume_handle = &resume_handle;
 508         r.out.sids = &sids1;
 509
 510         resume_handle = 0;
 511         status = dcerpc_lsa_EnumAccounts(p, mem_ctx, &r);
 512         if (!NT_STATUS_IS_OK(status)) {
 513                 printf("EnumAccounts failed - %s\n", nt_errstr(status));
 514                 return False;
 515         }
 516
 517         if (!test_LookupSids(p, mem_ctx, handle, &sids1)) {
 518                 return False;
 519         }
 520
 521         printf("testing all accounts\n");
 522         for (i=0;i<sids1.num_sids;i++) {
 523                 test_OpenAccount(p, mem_ctx, handle, sids1.sids[i].sid);
 524                 test_EnumAccountRights(p, mem_ctx, handle, sids1.sids[i].sid);
 525         }
 526         printf("\n");
 527
 528         if (sids1.num_sids < 3) {
 529                 return True;
 530         }
 531
 532         printf("trying EnumAccounts partial listing (asking for 1 at 2)\n");
 533         resume_handle = 2;
 534         r.in.num_entries = 1;
 535         r.out.sids = &sids2;
 536
 537         status = dcerpc_lsa_EnumAccounts(p, mem_ctx, &r);
 538         if (!NT_STATUS_IS_OK(status)) {
 539                 printf("EnumAccounts failed - %s\n", nt_errstr(status));
 540                 return False;
 541         }
 542
 543         if (sids2.num_sids != 1) {
 544                 printf("Returned wrong number of entries (%d)\n", sids2.num_sids);
 545                 return False;
 546         }
 547
 548         return True;
 549 }
 550
 551
 552 static BOOL test_EnumPrivs(struct dcerpc_pipe *p,
 553                            TALLOC_CTX *mem_ctx,
 554                            struct policy_handle *handle)
 555 {
 556         NTSTATUS status;
 557         struct lsa_EnumPrivs r;
 558         struct lsa_PrivArray privs1;
 559         uint32 resume_handle = 0;
 560
 561         printf("\ntesting EnumPrivs\n");
 562
 563         r.in.handle = handle;
 564         r.in.resume_handle = &resume_handle;
 565         r.in.max_count = 1000;
 566         r.out.resume_handle = &resume_handle;
 567         r.out.privs = &privs1;
 568
 569         resume_handle = 0;
 570         status = dcerpc_lsa_EnumPrivs(p, mem_ctx, &r);
 571         if (!NT_STATUS_IS_OK(status)) {
 572                 printf("EnumPrivs failed - %s\n", nt_errstr(status));
 573                 return False;
 574         }
 575
 576         return True;
 577 }
 578
 579
 580 static BOOL test_EnumTrustDom(struct dcerpc_pipe *p,
 581                               TALLOC_CTX *mem_ctx,
 582                               struct policy_handle *handle)
 583 {
 584         struct lsa_EnumTrustDom r;
 585         NTSTATUS status;
 586         uint32 resume_handle = 0;
 587         struct lsa_DomainList domains;
 588
 589         printf("\nTesting EnumTrustDom\n");
 590
 591         r.in.handle = handle;
 592         r.in.resume_handle = &resume_handle;
 593         r.in.num_entries = 1000;
 594         r.out.domains = &domains;
 595         r.out.resume_handle = &resume_handle;
 596
 597         status = dcerpc_lsa_EnumTrustDom(p, mem_ctx, &r);
 598
 599         /* NO_MORE_ENTRIES is allowed */
 600         if (NT_STATUS_EQUAL(status, NT_STATUS_NO_MORE_ENTRIES)) {
 601                 return True;
 602         }
 603
 604         if (!NT_STATUS_IS_OK(status)) {
 605                 printf("EnumTrustDom failed - %s\n", nt_errstr(status));
 606                 return False;
 607         }
 608
 609         return True;
 610 }
 611
 612 static BOOL test_QueryInfoPolicy(struct dcerpc_pipe *p,
 613                                  TALLOC_CTX *mem_ctx,
 614                                  struct policy_handle *handle)
 615 {
 616         struct lsa_QueryInfoPolicy r;
 617         NTSTATUS status;
 618         int i;
 619         BOOL ret = True;
 620         printf("\nTesting QueryInfoPolicy\n");
 621
 622         for (i=1;i<13;i++) {
 623                 r.in.handle = handle;
 624                 r.in.level = i;
 625
 626                 printf("\ntrying QueryInfoPolicy level %d\n", i);
 627
 628                 status = dcerpc_lsa_QueryInfoPolicy(p, mem_ctx, &r);
 629
 630                 if ((i == 9 || i == 10 || i == 11) &&
 631                     NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) {
 632                         printf("server failed level %u (OK)\n", i);
 633                         continue;
 634                 }
 635
 636                 if (!NT_STATUS_IS_OK(status)) {
 637                         printf("QueryInfoPolicy failed - %s\n", nt_errstr(status));
 638                         ret = False;
 639                         continue;
 640                 }
 641         }
 642
 643         return ret;
 644 }
 645
 646 static BOOL test_Close(struct dcerpc_pipe *p,
 647                        TALLOC_CTX *mem_ctx,
 648                        struct policy_handle *handle)
 649 {
 650         NTSTATUS status;
 651         struct lsa_Close r;
 652         struct policy_handle handle2;
 653
 654         printf("\ntesting Close\n");
 655
 656         r.in.handle = handle;
 657         r.out.handle = &handle2;
 658
 659         status = dcerpc_lsa_Close(p, mem_ctx, &r);
 660         if (!NT_STATUS_IS_OK(status)) {
 661                 printf("Close failed - %s\n", nt_errstr(status));
 662                 return False;
 663         }
 664
 665         status = dcerpc_lsa_Close(p, mem_ctx, &r);
 666         /* its really a fault - we need a status code for rpc fault */
 667         if (!NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
 668                 printf("Close failed - %s\n", nt_errstr(status));
 669                 return False;
 670         }
 671
 672         printf("\n");
 673
 674         return True;
 675 }
 676
 677 BOOL torture_rpc_lsa(int dummy)
 678 {
 679         NTSTATUS status;
 680         struct dcerpc_pipe *p;
 681         TALLOC_CTX *mem_ctx;
 682         BOOL ret = True;
 683         struct policy_handle handle;
 684
 685         mem_ctx = talloc_init("torture_rpc_lsa");
 686
 687         status = torture_rpc_connection(&p,
 688                                         DCERPC_LSARPC_NAME,
 689                                         DCERPC_LSARPC_UUID,
 690                                         DCERPC_LSARPC_VERSION);
 691         if (!NT_STATUS_IS_OK(status)) {
 692                 return False;
 693         }
 694
 695         if (!test_OpenPolicy(p, mem_ctx)) {
 696                 ret = False;
 697         }
 698
 699         if (!test_OpenPolicy2(p, mem_ctx, &handle)) {
 700                 ret = False;
 701         }
 702
 703         if (!test_CreateAccount(p, mem_ctx, &handle)) {
 704                 ret = False;
 705         }
 706
 707         if (!test_CreateSecret(p, mem_ctx, &handle)) {
 708                 ret = False;
 709         }
 710
 711         if (!test_CreateTrustedDomain(p, mem_ctx, &handle)) {
 712                 ret = False;
 713         }
 714
 715         if (!test_EnumAccounts(p, mem_ctx, &handle)) {
 716                 ret = False;
 717         }
 718
 719         if (!test_EnumPrivs(p, mem_ctx, &handle)) {
 720                 ret = False;
 721         }
 722
 723         if (!test_EnumTrustDom(p, mem_ctx, &handle)) {
 724                 ret = False;
 725         }
 726
 727         if (!test_QueryInfoPolicy(p, mem_ctx, &handle)) {
 728                 ret = False;
 729         }
 730
 731 #if 0
 732         if (!test_Delete(p, mem_ctx, &handle)) {
 733                 ret = False;
 734         }
 735 #endif
 736
 737         if (!test_Close(p, mem_ctx, &handle)) {
 738                 ret = False;
 739         }
 740
 741         talloc_destroy(mem_ctx);
 742
 743         torture_rpc_close(p);
 744
 745         return ret;
 746 }