source4/torture/rpc/clusapi.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    test suite for clusapi rpc operations
   4
   5    Copyright (C) Günther Deschner 2015
   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 "librpc/gen_ndr/ndr_clusapi_c.h"
  23 #include "torture/rpc/torture_rpc.h"
  24 #include "param/param.h"
  25
  26 static bool test_OpenCluster_int(struct torture_context *tctx,
  27                                  struct dcerpc_pipe *p,
  28                                  struct policy_handle *Cluster)
  29 {
  30         struct dcerpc_binding_handle *b = p->binding_handle;
  31         struct clusapi_OpenCluster r;
  32         WERROR Status;
  33
  34         r.out.Status = &Status;
  35         r.out.Cluster = Cluster;
  36
  37         torture_assert_ntstatus_ok(tctx,
  38                 dcerpc_clusapi_OpenCluster_r(b, tctx, &r),
  39                 "OpenCluster failed");
  40         torture_assert_werr_ok(tctx,
  41                 *r.out.Status,
  42                 "OpenCluster failed");
  43
  44         return true;
  45 }
  46
  47 static bool test_CloseCluster_int(struct torture_context *tctx,
  48                                   struct dcerpc_pipe *p,
  49                                   struct policy_handle *Cluster)
  50 {
  51         struct dcerpc_binding_handle *b = p->binding_handle;
  52         struct clusapi_CloseCluster r;
  53
  54         r.in.Cluster = Cluster;
  55         r.out.Cluster = Cluster;
  56
  57         torture_assert_ntstatus_ok(tctx,
  58                 dcerpc_clusapi_CloseCluster_r(b, tctx, &r),
  59                 "CloseCluster failed");
  60         torture_assert_werr_ok(tctx,
  61                 r.out.result,
  62                 "CloseCluster failed");
  63
  64         torture_assert(tctx,
  65                 ndr_policy_handle_empty(Cluster),
  66                 "policy_handle non empty after CloseCluster");
  67
  68         return true;
  69 }
  70
  71 static bool test_OpenCluster(struct torture_context *tctx,
  72                              struct dcerpc_pipe *p)
  73 {
  74         struct policy_handle Cluster;
  75
  76         if (!test_OpenCluster_int(tctx, p, &Cluster)) {
  77                 return false;
  78         }
  79
  80         test_CloseCluster_int(tctx, p, &Cluster);
  81
  82         return true;
  83 }
  84
  85 static bool test_CloseCluster(struct torture_context *tctx,
  86                               struct dcerpc_pipe *p)
  87 {
  88         struct policy_handle Cluster;
  89
  90         if (!test_OpenCluster_int(tctx, p, &Cluster)) {
  91                 return false;
  92         }
  93
  94         return test_CloseCluster_int(tctx, p, &Cluster);
  95 }
  96
  97 static bool test_SetClusterName(struct torture_context *tctx,
  98                                 struct dcerpc_pipe *p)
  99 {
 100         struct dcerpc_binding_handle *b = p->binding_handle;
 101         struct clusapi_SetClusterName r;
 102         WERROR rpc_status;
 103
 104         r.in.NewClusterName = "wurst";
 105         r.out.rpc_status = &rpc_status;
 106
 107         torture_assert_ntstatus_ok(tctx,
 108                 dcerpc_clusapi_SetClusterName_r(b, tctx, &r),
 109                 "SetClusterName failed");
 110         torture_assert_werr_ok(tctx,
 111                 r.out.result,
 112                 "SetClusterName failed");
 113
 114         return true;
 115 }
 116
 117 static bool test_GetClusterName(struct torture_context *tctx,
 118                                 struct dcerpc_pipe *p)
 119 {
 120         struct dcerpc_binding_handle *b = p->binding_handle;
 121         struct clusapi_GetClusterName r;
 122         const char *ClusterName;
 123         const char *NodeName;
 124
 125         r.out.ClusterName = &ClusterName;
 126         r.out.NodeName = &NodeName;
 127
 128         torture_assert_ntstatus_ok(tctx,
 129                 dcerpc_clusapi_GetClusterName_r(b, tctx, &r),
 130                 "GetClusterName failed");
 131         torture_assert_werr_ok(tctx,
 132                 r.out.result,
 133                 "GetClusterName failed");
 134
 135         return true;
 136 }
 137
 138 static bool test_GetClusterVersion(struct torture_context *tctx,
 139                                    struct dcerpc_pipe *p)
 140 {
 141         struct dcerpc_binding_handle *b = p->binding_handle;
 142         struct clusapi_GetClusterVersion r;
 143         uint16_t lpwMajorVersion;
 144         uint16_t lpwMinorVersion;
 145         uint16_t lpwBuildNumber;
 146         const char *lpszVendorId;
 147         const char *lpszCSDVersion;
 148
 149         r.out.lpwMajorVersion = &lpwMajorVersion;
 150         r.out.lpwMinorVersion = &lpwMinorVersion;
 151         r.out.lpwBuildNumber = &lpwBuildNumber;
 152         r.out.lpszVendorId = &lpszVendorId;
 153         r.out.lpszCSDVersion = &lpszCSDVersion;
 154
 155         torture_assert_ntstatus_ok(tctx,
 156                 dcerpc_clusapi_GetClusterVersion_r(b, tctx, &r),
 157                 "GetClusterVersion failed");
 158         torture_assert_werr_equal(tctx,
 159                 r.out.result,
 160                 WERR_CALL_NOT_IMPLEMENTED,
 161                 "GetClusterVersion failed");
 162
 163         return true;
 164 }
 165
 166 static bool test_GetClusterVersion2(struct torture_context *tctx,
 167                                     struct dcerpc_pipe *p)
 168 {
 169         struct dcerpc_binding_handle *b = p->binding_handle;
 170         struct clusapi_GetClusterVersion2 r;
 171         uint16_t lpwMajorVersion;
 172         uint16_t lpwMinorVersion;
 173         uint16_t lpwBuildNumber;
 174         const char *lpszVendorId;
 175         const char *lpszCSDVersion;
 176         struct CLUSTER_OPERATIONAL_VERSION_INFO *ppClusterOpVerInfo;
 177         WERROR rpc_status;
 178
 179         r.out.lpwMajorVersion = &lpwMajorVersion;
 180         r.out.lpwMinorVersion = &lpwMinorVersion;
 181         r.out.lpwBuildNumber = &lpwBuildNumber;
 182         r.out.lpszVendorId = &lpszVendorId;
 183         r.out.lpszCSDVersion = &lpszCSDVersion;
 184         r.out.ppClusterOpVerInfo = &ppClusterOpVerInfo;
 185         r.out.rpc_status = &rpc_status;
 186
 187         torture_assert_ntstatus_ok(tctx,
 188                 dcerpc_clusapi_GetClusterVersion2_r(b, tctx, &r),
 189                 "GetClusterVersion2 failed");
 190         torture_assert_werr_ok(tctx,
 191                 r.out.result,
 192                 "GetClusterVersion2 failed");
 193
 194         return true;
 195 }
 196
 197 static bool test_CreateEnum(struct torture_context *tctx,
 198                             struct dcerpc_pipe *p)
 199 {
 200         struct dcerpc_binding_handle *b = p->binding_handle;
 201         struct clusapi_CreateEnum r;
 202         uint32_t dwType = CLUSTER_ENUM_RESOURCE;
 203         struct ENUM_LIST *ReturnEnum;
 204         WERROR rpc_status;
 205
 206         r.in.dwType = dwType;
 207         r.out.ReturnEnum = &ReturnEnum;
 208         r.out.rpc_status = &rpc_status;
 209
 210         torture_assert_ntstatus_ok(tctx,
 211                 dcerpc_clusapi_CreateEnum_r(b, tctx, &r),
 212                 "CreateEnum failed");
 213         torture_assert_werr_ok(tctx,
 214                 r.out.result,
 215                 "CreateEnum failed");
 216
 217         return true;
 218 }
 219
 220 static bool test_GetQuorumResource(struct torture_context *tctx,
 221                                    struct dcerpc_pipe *p)
 222 {
 223         struct dcerpc_binding_handle *b = p->binding_handle;
 224         struct clusapi_GetQuorumResource r;
 225         const char *lpszResourceName;
 226         const char *lpszDeviceName;
 227         uint32_t pdwMaxQuorumLogSize;
 228         WERROR rpc_status;
 229
 230         r.out.lpszResourceName = &lpszResourceName;
 231         r.out.lpszDeviceName = &lpszDeviceName;
 232         r.out.pdwMaxQuorumLogSize = &pdwMaxQuorumLogSize;
 233         r.out.rpc_status = &rpc_status;
 234
 235         torture_assert_ntstatus_ok(tctx,
 236                 dcerpc_clusapi_GetQuorumResource_r(b, tctx, &r),
 237                 "GetQuorumResource failed");
 238         torture_assert_werr_ok(tctx,
 239                 r.out.result,
 240                 "GetQuorumResource failed");
 241
 242         return true;
 243 }
 244
 245 static bool test_SetQuorumResource(struct torture_context *tctx,
 246                                    struct dcerpc_pipe *p)
 247 {
 248         struct dcerpc_binding_handle *b = p->binding_handle;
 249         struct clusapi_SetQuorumResource r;
 250         const char *lpszDeviceName = "";
 251         uint32_t dwMaxQuorumLogSize = 0;
 252         WERROR rpc_status;
 253         struct policy_handle hResource;
 254
 255         /* we need to figure out how this call works and what we provide as
 256            devicename and resource handle - gd
 257          */
 258
 259         torture_skip(tctx, "skipping SetQuorumResource test");
 260
 261         ZERO_STRUCT(hResource);
 262
 263         r.in.hResource = hResource;
 264         r.in.lpszDeviceName = lpszDeviceName;
 265         r.in.dwMaxQuorumLogSize = dwMaxQuorumLogSize;
 266         r.out.rpc_status = &rpc_status;
 267
 268         torture_assert_ntstatus_ok(tctx,
 269                 dcerpc_clusapi_SetQuorumResource_r(b, tctx, &r),
 270                 "SetQuorumResource failed");
 271         torture_assert_werr_ok(tctx,
 272                 r.out.result,
 273                 "SetQuorumResource failed");
 274
 275         return true;
 276 }
 277
 278 static bool test_OpenResource_int(struct torture_context *tctx,
 279                                   struct dcerpc_pipe *p,
 280                                   struct policy_handle *hResource)
 281 {
 282         struct dcerpc_binding_handle *b = p->binding_handle;
 283         struct clusapi_OpenResource r;
 284         const char *lpszResourceName = "Cluster Name";
 285         WERROR Status;
 286         WERROR rpc_status;
 287
 288         r.in.lpszResourceName = lpszResourceName;
 289         r.out.rpc_status = &rpc_status;
 290         r.out.Status = &Status;
 291         r.out.hResource = hResource;
 292
 293         torture_assert_ntstatus_ok(tctx,
 294                 dcerpc_clusapi_OpenResource_r(b, tctx, &r),
 295                 "OpenResource failed");
 296         torture_assert_werr_ok(tctx,
 297                 *r.out.Status,
 298                 "OpenResource failed");
 299
 300         return true;
 301 }
 302
 303 static bool test_CloseResource_int(struct torture_context *tctx,
 304                                    struct dcerpc_pipe *p,
 305                                    struct policy_handle *hResource)
 306 {
 307         struct dcerpc_binding_handle *b = p->binding_handle;
 308         struct clusapi_CloseResource r;
 309
 310         r.in.Resource = hResource;
 311         r.out.Resource = hResource;
 312
 313         torture_assert_ntstatus_ok(tctx,
 314                 dcerpc_clusapi_CloseResource_r(b, tctx, &r),
 315                 "CloseResource failed");
 316         torture_assert_werr_ok(tctx,
 317                 r.out.result,
 318                 "CloseResource failed");
 319         torture_assert(tctx,
 320                 ndr_policy_handle_empty(hResource),
 321                 "policy_handle non empty after CloseResource");
 322
 323         return true;
 324 }
 325
 326 static bool test_OpenResource(struct torture_context *tctx,
 327                               struct dcerpc_pipe *p)
 328 {
 329         struct policy_handle hResource;
 330
 331         if (!test_OpenResource_int(tctx, p, &hResource)) {
 332                 return false;
 333         }
 334
 335         test_CloseResource_int(tctx, p, &hResource);
 336
 337         return true;
 338 }
 339
 340 static bool test_CloseResource(struct torture_context *tctx,
 341                                struct dcerpc_pipe *p)
 342 {
 343         struct policy_handle hResource;
 344
 345         if (!test_OpenResource_int(tctx, p, &hResource)) {
 346                 return false;
 347         }
 348
 349         return test_CloseResource_int(tctx, p, &hResource);
 350 }
 351
 352 static bool test_CreateResource_int(struct torture_context *tctx,
 353                                     struct dcerpc_pipe *p,
 354                                     struct policy_handle *hResource)
 355 {
 356         struct dcerpc_binding_handle *b = p->binding_handle;
 357         struct clusapi_CreateResource r;
 358         const char *lpszResourceName = "Cluster Name";
 359         const char *lpszResourceType = "wurst";
 360         WERROR Status;
 361         WERROR rpc_status;
 362         struct policy_handle hGroup;
 363
 364         ZERO_STRUCT(hGroup); /* FIXME !!!!!! */
 365
 366         r.in.hGroup = hGroup;
 367         r.in.lpszResourceName = lpszResourceName;
 368         r.in.lpszResourceType = lpszResourceType;
 369         r.in.dwFlags = 0; /* FIXME */
 370         r.out.rpc_status = &rpc_status;
 371         r.out.Status = &Status;
 372         r.out.hResource = hResource;
 373
 374         torture_assert_ntstatus_ok(tctx,
 375                 dcerpc_clusapi_CreateResource_r(b, tctx, &r),
 376                 "CreateResource failed");
 377         torture_assert_werr_ok(tctx,
 378                 *r.out.Status,
 379                 "CreateResource failed");
 380
 381         return true;
 382 }
 383
 384 static bool test_DeleteResource_int(struct torture_context *tctx,
 385                                     struct dcerpc_pipe *p,
 386                                     struct policy_handle *hResource)
 387 {
 388         struct dcerpc_binding_handle *b = p->binding_handle;
 389         struct clusapi_DeleteResource r;
 390         WERROR rpc_status;
 391
 392         r.in.hResource = *hResource;
 393         r.out.rpc_status = &rpc_status;
 394
 395         torture_assert_ntstatus_ok(tctx,
 396                 dcerpc_clusapi_DeleteResource_r(b, tctx, &r),
 397                 "DeleteResource failed");
 398         torture_assert_werr_ok(tctx,
 399                 r.out.result,
 400                 "DeleteResource failed");
 401
 402         return true;
 403 }
 404
 405 static bool test_CreateResource(struct torture_context *tctx,
 406                                 struct dcerpc_pipe *p)
 407 {
 408         struct policy_handle hResource;
 409
 410         if (!test_CreateResource_int(tctx, p, &hResource)) {
 411                 return false;
 412         }
 413
 414         test_DeleteResource_int(tctx, p, &hResource);
 415
 416         return true;
 417 }
 418
 419 static bool test_DeleteResource(struct torture_context *tctx,
 420                                 struct dcerpc_pipe *p)
 421 {
 422         struct policy_handle hResource;
 423
 424         if (!test_CreateResource_int(tctx, p, &hResource)) {
 425                 return false;
 426         }
 427
 428         return test_DeleteResource_int(tctx, p, &hResource);
 429 }
 430
 431 static bool test_GetResourceState_int(struct torture_context *tctx,
 432                                       struct dcerpc_pipe *p,
 433                                       struct policy_handle *hResource)
 434 {
 435         struct dcerpc_binding_handle *b = p->binding_handle;
 436         struct clusapi_GetResourceState r;
 437         uint32_t State;
 438         const char *NodeName;
 439         const char *GroupName;
 440         WERROR rpc_status;
 441
 442         r.in.hResource = *hResource;
 443         r.out.State = &State;
 444         r.out.NodeName = &NodeName;
 445         r.out.GroupName = &GroupName;
 446         r.out.rpc_status = &rpc_status;
 447
 448         torture_assert_ntstatus_ok(tctx,
 449                 dcerpc_clusapi_GetResourceState_r(b, tctx, &r),
 450                 "GetResourceState failed");
 451         torture_assert_werr_ok(tctx,
 452                 r.out.result,
 453                 "GetResourceState failed");
 454
 455         return true;
 456 }
 457
 458 static bool test_GetResourceState(struct torture_context *tctx,
 459                                   struct dcerpc_pipe *p)
 460 {
 461         struct policy_handle hResource;
 462         bool ret = true;
 463
 464         if (!test_OpenResource_int(tctx, p, &hResource)) {
 465                 return false;
 466         }
 467
 468         ret = test_GetResourceState_int(tctx, p, &hResource);
 469
 470         test_CloseResource_int(tctx, p, &hResource);
 471
 472         return ret;
 473 }
 474
 475 static bool test_GetResourceId_int(struct torture_context *tctx,
 476                                    struct dcerpc_pipe *p,
 477                                    struct policy_handle *hResource)
 478 {
 479         struct dcerpc_binding_handle *b = p->binding_handle;
 480         struct clusapi_GetResourceId r;
 481         const char *pGuid;
 482         WERROR rpc_status;
 483
 484         r.in.hResource = *hResource;
 485         r.out.pGuid = &pGuid;
 486         r.out.rpc_status = &rpc_status;
 487
 488         torture_assert_ntstatus_ok(tctx,
 489                 dcerpc_clusapi_GetResourceId_r(b, tctx, &r),
 490                 "GetResourceId failed");
 491         torture_assert_werr_ok(tctx,
 492                 r.out.result,
 493                 "GetResourceId failed");
 494
 495         return true;
 496 }
 497
 498 static bool test_GetResourceId(struct torture_context *tctx,
 499                                struct dcerpc_pipe *p)
 500 {
 501         struct policy_handle hResource;
 502         bool ret = true;
 503
 504         if (!test_OpenResource_int(tctx, p, &hResource)) {
 505                 return false;
 506         }
 507
 508         ret = test_GetResourceId_int(tctx, p, &hResource);
 509
 510         test_CloseResource_int(tctx, p, &hResource);
 511
 512         return ret;
 513 }
 514
 515 static bool test_GetResourceType_int(struct torture_context *tctx,
 516                                      struct dcerpc_pipe *p,
 517                                      struct policy_handle *hResource)
 518 {
 519         struct dcerpc_binding_handle *b = p->binding_handle;
 520         struct clusapi_GetResourceType r;
 521         const char *lpszResourceType;
 522         WERROR rpc_status;
 523
 524         r.in.hResource = *hResource;
 525         r.out.lpszResourceType = &lpszResourceType;
 526         r.out.rpc_status = &rpc_status;
 527
 528         torture_assert_ntstatus_ok(tctx,
 529                 dcerpc_clusapi_GetResourceType_r(b, tctx, &r),
 530                 "GetResourceType failed");
 531         torture_assert_werr_ok(tctx,
 532                 r.out.result,
 533                 "GetResourceType failed");
 534
 535         return true;
 536 }
 537
 538 static bool test_GetResourceType(struct torture_context *tctx,
 539                                  struct dcerpc_pipe *p)
 540 {
 541         struct policy_handle hResource;
 542         bool ret = true;
 543
 544         if (!test_OpenResource_int(tctx, p, &hResource)) {
 545                 return false;
 546         }
 547
 548         ret = test_GetResourceType_int(tctx, p, &hResource);
 549
 550         test_CloseResource_int(tctx, p, &hResource);
 551
 552         return ret;
 553 }
 554
 555 static bool test_FailResource_int(struct torture_context *tctx,
 556                                   struct dcerpc_pipe *p,
 557                                   struct policy_handle *hResource)
 558 {
 559         struct dcerpc_binding_handle *b = p->binding_handle;
 560         struct clusapi_FailResource r;
 561         WERROR rpc_status;
 562
 563         r.in.hResource = *hResource;
 564         r.out.rpc_status = &rpc_status;
 565
 566         torture_assert_ntstatus_ok(tctx,
 567                 dcerpc_clusapi_FailResource_r(b, tctx, &r),
 568                 "FailResource failed");
 569         torture_assert_werr_ok(tctx,
 570                 r.out.result,
 571                 "FailResource failed");
 572
 573         return true;
 574 }
 575
 576 static bool test_FailResource(struct torture_context *tctx,
 577                               struct dcerpc_pipe *p)
 578 {
 579         struct policy_handle hResource;
 580         bool ret = true;
 581
 582         if (!test_OpenResource_int(tctx, p, &hResource)) {
 583                 return false;
 584         }
 585
 586         ret = test_FailResource_int(tctx, p, &hResource);
 587
 588         test_CloseResource_int(tctx, p, &hResource);
 589
 590         return ret;
 591 }
 592
 593 static bool test_OnlineResource_int(struct torture_context *tctx,
 594                                     struct dcerpc_pipe *p,
 595                                     struct policy_handle *hResource)
 596 {
 597         struct dcerpc_binding_handle *b = p->binding_handle;
 598         struct clusapi_OnlineResource r;
 599         WERROR rpc_status;
 600
 601         r.in.hResource = *hResource;
 602         r.out.rpc_status = &rpc_status;
 603
 604         torture_assert_ntstatus_ok(tctx,
 605                 dcerpc_clusapi_OnlineResource_r(b, tctx, &r),
 606                 "OnlineResource failed");
 607         torture_assert_werr_ok(tctx,
 608                 r.out.result,
 609                 "OnlineResource failed");
 610
 611         return true;
 612 }
 613
 614 static bool test_OnlineResource(struct torture_context *tctx,
 615                                 struct dcerpc_pipe *p)
 616 {
 617         struct policy_handle hResource;
 618         bool ret = true;
 619
 620         if (!test_OpenResource_int(tctx, p, &hResource)) {
 621                 return false;
 622         }
 623
 624         ret = test_OnlineResource_int(tctx, p, &hResource);
 625
 626         test_CloseResource_int(tctx, p, &hResource);
 627
 628         return ret;
 629 }
 630
 631 static bool test_OfflineResource_int(struct torture_context *tctx,
 632                                      struct dcerpc_pipe *p,
 633                                      struct policy_handle *hResource)
 634 {
 635         struct dcerpc_binding_handle *b = p->binding_handle;
 636         struct clusapi_OfflineResource r;
 637         WERROR rpc_status;
 638
 639         r.in.hResource = *hResource;
 640         r.out.rpc_status = &rpc_status;
 641
 642         torture_assert_ntstatus_ok(tctx,
 643                 dcerpc_clusapi_OfflineResource_r(b, tctx, &r),
 644                 "OfflineResource failed");
 645         torture_assert_werr_ok(tctx,
 646                 r.out.result,
 647                 "OfflineResource failed");
 648
 649         return true;
 650 }
 651
 652 static bool test_OfflineResource(struct torture_context *tctx,
 653                                  struct dcerpc_pipe *p)
 654 {
 655         struct policy_handle hResource;
 656         bool ret = true;
 657
 658         if (!test_OpenResource_int(tctx, p, &hResource)) {
 659                 return false;
 660         }
 661
 662         ret = test_OfflineResource_int(tctx, p, &hResource);
 663
 664         test_CloseResource_int(tctx, p, &hResource);
 665
 666         return ret;
 667 }
 668
 669 static bool test_CreateResEnum(struct torture_context *tctx,
 670                                struct dcerpc_pipe *p)
 671 {
 672         struct dcerpc_binding_handle *b = p->binding_handle;
 673         struct clusapi_CreateResEnum r;
 674         struct policy_handle hResource;
 675         uint32_t dwType = CLUSTER_ENUM_RESOURCE;
 676         struct ENUM_LIST *ReturnEnum;
 677         WERROR rpc_status;
 678
 679         torture_assert(tctx,
 680                 test_OpenResource_int(tctx, p, &hResource),
 681                 "OpenResource failed");
 682
 683         r.in.hResource = hResource;
 684         r.in.dwType = dwType;
 685         r.out.ReturnEnum = &ReturnEnum;
 686         r.out.rpc_status = &rpc_status;
 687
 688         torture_assert_ntstatus_ok(tctx,
 689                 dcerpc_clusapi_CreateResEnum_r(b, tctx, &r),
 690                 "CreateResEnum failed");
 691         torture_assert_werr_ok(tctx,
 692                 r.out.result,
 693                 "CreateResEnum failed");
 694
 695         test_CloseResource_int(tctx, p, &hResource);
 696
 697         return true;
 698 }
 699
 700 struct torture_suite *torture_rpc_clusapi(TALLOC_CTX *mem_ctx)
 701 {
 702         struct torture_rpc_tcase *tcase;
 703         struct torture_suite *suite = torture_suite_create(mem_ctx, "clusapi");
 704         struct torture_test *test;
 705
 706         tcase = torture_suite_add_rpc_iface_tcase(suite, "clusapi",
 707                                                   &ndr_table_clusapi);
 708
 709         torture_rpc_tcase_add_test(tcase, "OpenCluster",
 710                                    test_OpenCluster);
 711         torture_rpc_tcase_add_test(tcase, "CloseCluster",
 712                                    test_CloseCluster);
 713         torture_rpc_tcase_add_test(tcase, "SetClusterName",
 714                                    test_SetClusterName);
 715         torture_rpc_tcase_add_test(tcase, "GetClusterName",
 716                                    test_GetClusterName);
 717         torture_rpc_tcase_add_test(tcase, "GetClusterVersion",
 718                                    test_GetClusterVersion);
 719         torture_rpc_tcase_add_test(tcase, "CreateEnum",
 720                                    test_CreateEnum);
 721         torture_rpc_tcase_add_test(tcase, "GetQuorumResource",
 722                                    test_GetQuorumResource);
 723         torture_rpc_tcase_add_test(tcase, "SetQuorumResource",
 724                                    test_SetQuorumResource);
 725         torture_rpc_tcase_add_test(tcase, "OpenResource",
 726                                    test_OpenResource);
 727         torture_rpc_tcase_add_test(tcase, "CloseResource",
 728                                    test_CloseResource);
 729         torture_rpc_tcase_add_test(tcase, "CreateResource",
 730                                    test_CreateResource);
 731         torture_rpc_tcase_add_test(tcase, "DeleteResource",
 732                                    test_DeleteResource);
 733         torture_rpc_tcase_add_test(tcase, "GetResourceState",
 734                                    test_GetResourceState);
 735         torture_rpc_tcase_add_test(tcase, "GetResourceId",
 736                                    test_GetResourceId);
 737         torture_rpc_tcase_add_test(tcase, "GetResourceType",
 738                                    test_GetResourceType);
 739         test = torture_rpc_tcase_add_test(tcase, "FailResource",
 740                                    test_FailResource);
 741         test->dangerous = true;
 742         torture_rpc_tcase_add_test(tcase, "OnlineResource",
 743                                    test_OnlineResource);
 744         test = torture_rpc_tcase_add_test(tcase, "OfflineResource",
 745                                    test_OfflineResource);
 746         test->dangerous = true;
 747
 748         torture_rpc_tcase_add_test(tcase, "GetClusterVersion2",
 749                                    test_GetClusterVersion2);
 750         torture_rpc_tcase_add_test(tcase, "CreateResEnum",
 751                                    test_CreateResEnum);
 752
 753         return suite;
 754 }