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_OpenGroup_int(struct torture_context *tctx,
 353                                struct dcerpc_pipe *p,
 354                                struct policy_handle *hGroup);
 355 static bool test_CloseGroup_int(struct torture_context *tctx,
 356                                 struct dcerpc_pipe *p,
 357                                 struct policy_handle *Group);
 358
 359 static bool test_CreateResource_int(struct torture_context *tctx,
 360                                     struct dcerpc_pipe *p,
 361                                     struct policy_handle *hResource)
 362 {
 363         struct dcerpc_binding_handle *b = p->binding_handle;
 364         struct clusapi_CreateResource r;
 365         const char *lpszResourceName = "wurst";
 366         const char *lpszResourceType = "Generic Service";
 367         WERROR Status;
 368         WERROR rpc_status;
 369         struct policy_handle hGroup;
 370
 371         torture_assert(tctx,
 372                 test_OpenGroup_int(tctx, p, &hGroup),
 373                 "failed to open group");
 374
 375         r.in.hGroup = hGroup;
 376         r.in.lpszResourceName = lpszResourceName;
 377         r.in.lpszResourceType = lpszResourceType;
 378         r.in.dwFlags = 0; /* FIXME */
 379         r.out.rpc_status = &rpc_status;
 380         r.out.Status = &Status;
 381         r.out.hResource = hResource;
 382
 383         torture_assert_ntstatus_ok(tctx,
 384                 dcerpc_clusapi_CreateResource_r(b, tctx, &r),
 385                 "CreateResource failed");
 386         torture_assert_werr_ok(tctx,
 387                 *r.out.Status,
 388                 "CreateResource failed");
 389
 390         test_CloseGroup_int(tctx, p, &hGroup);
 391
 392         return true;
 393 }
 394
 395 static bool test_DeleteResource_int(struct torture_context *tctx,
 396                                     struct dcerpc_pipe *p,
 397                                     struct policy_handle *hResource)
 398 {
 399         struct dcerpc_binding_handle *b = p->binding_handle;
 400         struct clusapi_DeleteResource r;
 401         WERROR rpc_status;
 402
 403         r.in.hResource = *hResource;
 404         r.out.rpc_status = &rpc_status;
 405
 406         torture_assert_ntstatus_ok(tctx,
 407                 dcerpc_clusapi_DeleteResource_r(b, tctx, &r),
 408                 "DeleteResource failed");
 409         torture_assert_werr_ok(tctx,
 410                 r.out.result,
 411                 "DeleteResource failed");
 412
 413         return true;
 414 }
 415
 416 static bool test_CreateResource(struct torture_context *tctx,
 417                                 struct dcerpc_pipe *p)
 418 {
 419         struct policy_handle hResource;
 420
 421         if (!test_CreateResource_int(tctx, p, &hResource)) {
 422                 return false;
 423         }
 424
 425         test_DeleteResource_int(tctx, p, &hResource);
 426
 427         return true;
 428 }
 429
 430 static bool test_DeleteResource(struct torture_context *tctx,
 431                                 struct dcerpc_pipe *p)
 432 {
 433         struct policy_handle hResource;
 434
 435         if (!test_CreateResource_int(tctx, p, &hResource)) {
 436                 return false;
 437         }
 438
 439         return test_DeleteResource_int(tctx, p, &hResource);
 440 }
 441
 442 static bool test_GetResourceState_int(struct torture_context *tctx,
 443                                       struct dcerpc_pipe *p,
 444                                       struct policy_handle *hResource)
 445 {
 446         struct dcerpc_binding_handle *b = p->binding_handle;
 447         struct clusapi_GetResourceState r;
 448         uint32_t State;
 449         const char *NodeName;
 450         const char *GroupName;
 451         WERROR rpc_status;
 452
 453         r.in.hResource = *hResource;
 454         r.out.State = &State;
 455         r.out.NodeName = &NodeName;
 456         r.out.GroupName = &GroupName;
 457         r.out.rpc_status = &rpc_status;
 458
 459         torture_assert_ntstatus_ok(tctx,
 460                 dcerpc_clusapi_GetResourceState_r(b, tctx, &r),
 461                 "GetResourceState failed");
 462         torture_assert_werr_ok(tctx,
 463                 r.out.result,
 464                 "GetResourceState failed");
 465
 466         return true;
 467 }
 468
 469 static bool test_GetResourceState(struct torture_context *tctx,
 470                                   struct dcerpc_pipe *p)
 471 {
 472         struct policy_handle hResource;
 473         bool ret = true;
 474
 475         if (!test_OpenResource_int(tctx, p, &hResource)) {
 476                 return false;
 477         }
 478
 479         ret = test_GetResourceState_int(tctx, p, &hResource);
 480
 481         test_CloseResource_int(tctx, p, &hResource);
 482
 483         return ret;
 484 }
 485
 486 static bool test_GetResourceId_int(struct torture_context *tctx,
 487                                    struct dcerpc_pipe *p,
 488                                    struct policy_handle *hResource)
 489 {
 490         struct dcerpc_binding_handle *b = p->binding_handle;
 491         struct clusapi_GetResourceId r;
 492         const char *pGuid;
 493         WERROR rpc_status;
 494
 495         r.in.hResource = *hResource;
 496         r.out.pGuid = &pGuid;
 497         r.out.rpc_status = &rpc_status;
 498
 499         torture_assert_ntstatus_ok(tctx,
 500                 dcerpc_clusapi_GetResourceId_r(b, tctx, &r),
 501                 "GetResourceId failed");
 502         torture_assert_werr_ok(tctx,
 503                 r.out.result,
 504                 "GetResourceId failed");
 505
 506         return true;
 507 }
 508
 509 static bool test_GetResourceId(struct torture_context *tctx,
 510                                struct dcerpc_pipe *p)
 511 {
 512         struct policy_handle hResource;
 513         bool ret = true;
 514
 515         if (!test_OpenResource_int(tctx, p, &hResource)) {
 516                 return false;
 517         }
 518
 519         ret = test_GetResourceId_int(tctx, p, &hResource);
 520
 521         test_CloseResource_int(tctx, p, &hResource);
 522
 523         return ret;
 524 }
 525
 526 static bool test_GetResourceType_int(struct torture_context *tctx,
 527                                      struct dcerpc_pipe *p,
 528                                      struct policy_handle *hResource)
 529 {
 530         struct dcerpc_binding_handle *b = p->binding_handle;
 531         struct clusapi_GetResourceType r;
 532         const char *lpszResourceType;
 533         WERROR rpc_status;
 534
 535         r.in.hResource = *hResource;
 536         r.out.lpszResourceType = &lpszResourceType;
 537         r.out.rpc_status = &rpc_status;
 538
 539         torture_assert_ntstatus_ok(tctx,
 540                 dcerpc_clusapi_GetResourceType_r(b, tctx, &r),
 541                 "GetResourceType failed");
 542         torture_assert_werr_ok(tctx,
 543                 r.out.result,
 544                 "GetResourceType failed");
 545
 546         return true;
 547 }
 548
 549 static bool test_GetResourceType(struct torture_context *tctx,
 550                                  struct dcerpc_pipe *p)
 551 {
 552         struct policy_handle hResource;
 553         bool ret = true;
 554
 555         if (!test_OpenResource_int(tctx, p, &hResource)) {
 556                 return false;
 557         }
 558
 559         ret = test_GetResourceType_int(tctx, p, &hResource);
 560
 561         test_CloseResource_int(tctx, p, &hResource);
 562
 563         return ret;
 564 }
 565
 566 static bool test_FailResource_int(struct torture_context *tctx,
 567                                   struct dcerpc_pipe *p,
 568                                   struct policy_handle *hResource)
 569 {
 570         struct dcerpc_binding_handle *b = p->binding_handle;
 571         struct clusapi_FailResource r;
 572         WERROR rpc_status;
 573
 574         r.in.hResource = *hResource;
 575         r.out.rpc_status = &rpc_status;
 576
 577         torture_assert_ntstatus_ok(tctx,
 578                 dcerpc_clusapi_FailResource_r(b, tctx, &r),
 579                 "FailResource failed");
 580         torture_assert_werr_ok(tctx,
 581                 r.out.result,
 582                 "FailResource failed");
 583
 584         return true;
 585 }
 586
 587 static bool test_FailResource(struct torture_context *tctx,
 588                               struct dcerpc_pipe *p)
 589 {
 590         struct policy_handle hResource;
 591         bool ret = true;
 592
 593         if (!test_OpenResource_int(tctx, p, &hResource)) {
 594                 return false;
 595         }
 596
 597         ret = test_FailResource_int(tctx, p, &hResource);
 598
 599         test_CloseResource_int(tctx, p, &hResource);
 600
 601         return ret;
 602 }
 603
 604 static bool test_OnlineResource_int(struct torture_context *tctx,
 605                                     struct dcerpc_pipe *p,
 606                                     struct policy_handle *hResource)
 607 {
 608         struct dcerpc_binding_handle *b = p->binding_handle;
 609         struct clusapi_OnlineResource r;
 610         WERROR rpc_status;
 611
 612         r.in.hResource = *hResource;
 613         r.out.rpc_status = &rpc_status;
 614
 615         torture_assert_ntstatus_ok(tctx,
 616                 dcerpc_clusapi_OnlineResource_r(b, tctx, &r),
 617                 "OnlineResource failed");
 618         torture_assert_werr_ok(tctx,
 619                 r.out.result,
 620                 "OnlineResource failed");
 621
 622         return true;
 623 }
 624
 625 static bool test_OnlineResource(struct torture_context *tctx,
 626                                 struct dcerpc_pipe *p)
 627 {
 628         struct policy_handle hResource;
 629         bool ret = true;
 630
 631         if (!test_OpenResource_int(tctx, p, &hResource)) {
 632                 return false;
 633         }
 634
 635         ret = test_OnlineResource_int(tctx, p, &hResource);
 636
 637         test_CloseResource_int(tctx, p, &hResource);
 638
 639         return ret;
 640 }
 641
 642 static bool test_OfflineResource_int(struct torture_context *tctx,
 643                                      struct dcerpc_pipe *p,
 644                                      struct policy_handle *hResource)
 645 {
 646         struct dcerpc_binding_handle *b = p->binding_handle;
 647         struct clusapi_OfflineResource r;
 648         WERROR rpc_status;
 649
 650         r.in.hResource = *hResource;
 651         r.out.rpc_status = &rpc_status;
 652
 653         torture_assert_ntstatus_ok(tctx,
 654                 dcerpc_clusapi_OfflineResource_r(b, tctx, &r),
 655                 "OfflineResource failed");
 656         torture_assert_werr_ok(tctx,
 657                 r.out.result,
 658                 "OfflineResource failed");
 659
 660         return true;
 661 }
 662
 663 static bool test_OfflineResource(struct torture_context *tctx,
 664                                  struct dcerpc_pipe *p)
 665 {
 666         struct policy_handle hResource;
 667         bool ret = true;
 668
 669         if (!test_OpenResource_int(tctx, p, &hResource)) {
 670                 return false;
 671         }
 672
 673         ret = test_OfflineResource_int(tctx, p, &hResource);
 674
 675         test_CloseResource_int(tctx, p, &hResource);
 676
 677         return ret;
 678 }
 679
 680 static bool test_CreateResEnum(struct torture_context *tctx,
 681                                struct dcerpc_pipe *p)
 682 {
 683         struct dcerpc_binding_handle *b = p->binding_handle;
 684         struct clusapi_CreateResEnum r;
 685         struct policy_handle hResource;
 686         uint32_t dwType = CLUSTER_ENUM_RESOURCE;
 687         struct ENUM_LIST *ReturnEnum;
 688         WERROR rpc_status;
 689
 690         torture_assert(tctx,
 691                 test_OpenResource_int(tctx, p, &hResource),
 692                 "OpenResource failed");
 693
 694         r.in.hResource = hResource;
 695         r.in.dwType = dwType;
 696         r.out.ReturnEnum = &ReturnEnum;
 697         r.out.rpc_status = &rpc_status;
 698
 699         torture_assert_ntstatus_ok(tctx,
 700                 dcerpc_clusapi_CreateResEnum_r(b, tctx, &r),
 701                 "CreateResEnum failed");
 702         torture_assert_werr_ok(tctx,
 703                 r.out.result,
 704                 "CreateResEnum failed");
 705
 706         test_CloseResource_int(tctx, p, &hResource);
 707
 708         return true;
 709 }
 710
 711 static bool test_OpenNode_int(struct torture_context *tctx,
 712                               struct dcerpc_pipe *p,
 713                               struct policy_handle *hNode)
 714 {
 715         struct dcerpc_binding_handle *b = p->binding_handle;
 716         struct clusapi_OpenNode r;
 717         const char *lpszNodeName = "NODE1";
 718         WERROR Status;
 719         WERROR rpc_status;
 720
 721         r.in.lpszNodeName = lpszNodeName;
 722         r.out.rpc_status = &rpc_status;
 723         r.out.Status = &Status;
 724         r.out.hNode= hNode;
 725
 726         torture_assert_ntstatus_ok(tctx,
 727                 dcerpc_clusapi_OpenNode_r(b, tctx, &r),
 728                 "OpenNode failed");
 729         torture_assert_werr_ok(tctx,
 730                 *r.out.Status,
 731                 "OpenNode failed");
 732
 733         return true;
 734 }
 735
 736 static bool test_CloseNode_int(struct torture_context *tctx,
 737                                struct dcerpc_pipe *p,
 738                                struct policy_handle *Node)
 739 {
 740         struct dcerpc_binding_handle *b = p->binding_handle;
 741         struct clusapi_CloseNode r;
 742
 743         r.in.Node = Node;
 744         r.out.Node = Node;
 745
 746         torture_assert_ntstatus_ok(tctx,
 747                 dcerpc_clusapi_CloseNode_r(b, tctx, &r),
 748                 "CloseNode failed");
 749         torture_assert_werr_ok(tctx,
 750                 r.out.result,
 751                 "CloseNode failed");
 752         torture_assert(tctx,
 753                 ndr_policy_handle_empty(Node),
 754                 "policy_handle non empty after CloseNode");
 755
 756         return true;
 757 }
 758
 759 static bool test_OpenNode(struct torture_context *tctx,
 760                           struct dcerpc_pipe *p)
 761 {
 762         struct policy_handle hNode;
 763
 764         if (!test_OpenNode_int(tctx, p, &hNode)) {
 765                 return false;
 766         }
 767
 768         test_CloseNode_int(tctx, p, &hNode);
 769
 770         return true;
 771 }
 772
 773 static bool test_CloseNode(struct torture_context *tctx,
 774                            struct dcerpc_pipe *p)
 775 {
 776         struct policy_handle hNode;
 777
 778         if (!test_OpenNode_int(tctx, p, &hNode)) {
 779                 return false;
 780         }
 781
 782         return test_CloseNode_int(tctx, p, &hNode);
 783 }
 784
 785 static bool test_GetNodeState_int(struct torture_context *tctx,
 786                                   struct dcerpc_pipe *p,
 787                                   struct policy_handle *hNode)
 788 {
 789         struct dcerpc_binding_handle *b = p->binding_handle;
 790         struct clusapi_GetNodeState r;
 791         uint32_t State;
 792         WERROR rpc_status;
 793
 794         r.in.hNode = *hNode;
 795         r.out.State = &State;
 796         r.out.rpc_status = &rpc_status;
 797
 798         torture_assert_ntstatus_ok(tctx,
 799                 dcerpc_clusapi_GetNodeState_r(b, tctx, &r),
 800                 "GetNodeState failed");
 801         torture_assert_werr_ok(tctx,
 802                 r.out.result,
 803                 "GetNodeState failed");
 804
 805         return true;
 806 }
 807
 808 static bool test_GetNodeState(struct torture_context *tctx,
 809                               struct dcerpc_pipe *p)
 810 {
 811         struct policy_handle hNode;
 812         bool ret = true;
 813
 814         if (!test_OpenNode_int(tctx, p, &hNode)) {
 815                 return false;
 816         }
 817
 818         ret = test_GetNodeState_int(tctx, p, &hNode);
 819
 820         test_CloseNode_int(tctx, p, &hNode);
 821
 822         return ret;
 823 }
 824
 825 static bool test_GetNodeId_int(struct torture_context *tctx,
 826                                struct dcerpc_pipe *p,
 827                                struct policy_handle *hNode)
 828 {
 829         struct dcerpc_binding_handle *b = p->binding_handle;
 830         struct clusapi_GetNodeId r;
 831         const char *pGuid;
 832         WERROR rpc_status;
 833
 834         r.in.hNode = *hNode;
 835         r.out.pGuid = &pGuid;
 836         r.out.rpc_status = &rpc_status;
 837
 838         torture_assert_ntstatus_ok(tctx,
 839                 dcerpc_clusapi_GetNodeId_r(b, tctx, &r),
 840                 "GetNodeId failed");
 841         torture_assert_werr_ok(tctx,
 842                 r.out.result,
 843                 "GetNodeId failed");
 844
 845         return true;
 846 }
 847
 848 static bool test_GetNodeId(struct torture_context *tctx,
 849                            struct dcerpc_pipe *p)
 850 {
 851         struct policy_handle hNode;
 852         bool ret = true;
 853
 854         if (!test_OpenNode_int(tctx, p, &hNode)) {
 855                 return false;
 856         }
 857
 858         ret = test_GetNodeId_int(tctx, p, &hNode);
 859
 860         test_CloseNode_int(tctx, p, &hNode);
 861
 862         return ret;
 863 }
 864
 865 static bool test_PauseNode_int(struct torture_context *tctx,
 866                                struct dcerpc_pipe *p,
 867                                struct policy_handle *hNode)
 868 {
 869         struct dcerpc_binding_handle *b = p->binding_handle;
 870         struct clusapi_PauseNode r;
 871         WERROR rpc_status;
 872
 873         r.in.hNode = *hNode;
 874         r.out.rpc_status = &rpc_status;
 875
 876         torture_assert_ntstatus_ok(tctx,
 877                 dcerpc_clusapi_PauseNode_r(b, tctx, &r),
 878                 "PauseNode failed");
 879         torture_assert_werr_ok(tctx,
 880                 r.out.result,
 881                 "PauseNode failed");
 882
 883         return true;
 884 }
 885
 886 static bool test_PauseNode(struct torture_context *tctx,
 887                            struct dcerpc_pipe *p)
 888 {
 889         struct policy_handle hNode;
 890         bool ret = true;
 891
 892         if (!test_OpenNode_int(tctx, p, &hNode)) {
 893                 return false;
 894         }
 895
 896         ret = test_PauseNode_int(tctx, p, &hNode);
 897
 898         test_CloseNode_int(tctx, p, &hNode);
 899
 900         return ret;
 901 }
 902
 903 static bool test_ResumeNode_int(struct torture_context *tctx,
 904                                 struct dcerpc_pipe *p,
 905                                 struct policy_handle *hNode)
 906 {
 907         struct dcerpc_binding_handle *b = p->binding_handle;
 908         struct clusapi_ResumeNode r;
 909         WERROR rpc_status;
 910
 911         r.in.hNode = *hNode;
 912         r.out.rpc_status = &rpc_status;
 913
 914         torture_assert_ntstatus_ok(tctx,
 915                 dcerpc_clusapi_ResumeNode_r(b, tctx, &r),
 916                 "ResumeNode failed");
 917         torture_assert_werr_equal(tctx,
 918                 r.out.result,
 919                 WERR_CLUSTER_NODE_NOT_PAUSED,
 920                 "ResumeNode gave unexpected result");
 921
 922         return true;
 923 }
 924
 925 static bool test_ResumeNode(struct torture_context *tctx,
 926                             struct dcerpc_pipe *p)
 927 {
 928         struct policy_handle hNode;
 929         bool ret = true;
 930
 931         if (!test_OpenNode_int(tctx, p, &hNode)) {
 932                 return false;
 933         }
 934
 935         ret = test_ResumeNode_int(tctx, p, &hNode);
 936
 937         test_CloseNode_int(tctx, p, &hNode);
 938
 939         return ret;
 940 }
 941
 942 static bool test_EvictNode_int(struct torture_context *tctx,
 943                                struct dcerpc_pipe *p,
 944                                struct policy_handle *hNode)
 945 {
 946         struct dcerpc_binding_handle *b = p->binding_handle;
 947         struct clusapi_EvictNode r;
 948         WERROR rpc_status;
 949
 950         r.in.hNode = *hNode;
 951         r.out.rpc_status = &rpc_status;
 952
 953         torture_assert_ntstatus_ok(tctx,
 954                 dcerpc_clusapi_EvictNode_r(b, tctx, &r),
 955                 "EvictNode failed");
 956         torture_assert_werr_ok(tctx,
 957                 r.out.result,
 958                 "EvictNode failed");
 959
 960         return true;
 961 }
 962
 963 static bool test_EvictNode(struct torture_context *tctx,
 964                            struct dcerpc_pipe *p)
 965 {
 966         struct policy_handle hNode;
 967         bool ret = true;
 968
 969         if (!test_OpenNode_int(tctx, p, &hNode)) {
 970                 return false;
 971         }
 972
 973         ret = test_EvictNode_int(tctx, p, &hNode);
 974
 975         test_CloseNode_int(tctx, p, &hNode);
 976
 977         return ret;
 978 }
 979
 980 static bool test_OpenGroup_int(struct torture_context *tctx,
 981                                struct dcerpc_pipe *p,
 982                                struct policy_handle *hGroup)
 983 {
 984         struct dcerpc_binding_handle *b = p->binding_handle;
 985         struct clusapi_OpenGroup r;
 986         const char *lpszGroupName = "Cluster Group";
 987         WERROR Status;
 988         WERROR rpc_status;
 989
 990         r.in.lpszGroupName = lpszGroupName;
 991         r.out.rpc_status = &rpc_status;
 992         r.out.Status = &Status;
 993         r.out.hGroup= hGroup;
 994
 995         torture_assert_ntstatus_ok(tctx,
 996                 dcerpc_clusapi_OpenGroup_r(b, tctx, &r),
 997                 "OpenGroup failed");
 998         torture_assert_werr_ok(tctx,
 999                 *r.out.Status,
1000                 "OpenGroup failed");
1001
1002         return true;
1003 }
1004
1005 static bool test_CloseGroup_int(struct torture_context *tctx,
1006                                 struct dcerpc_pipe *p,
1007                                 struct policy_handle *Group)
1008 {
1009         struct dcerpc_binding_handle *b = p->binding_handle;
1010         struct clusapi_CloseGroup r;
1011
1012         r.in.Group = Group;
1013         r.out.Group = Group;
1014
1015         torture_assert_ntstatus_ok(tctx,
1016                 dcerpc_clusapi_CloseGroup_r(b, tctx, &r),
1017                 "CloseGroup failed");
1018         torture_assert_werr_ok(tctx,
1019                 r.out.result,
1020                 "CloseGroup failed");
1021         torture_assert(tctx,
1022                 ndr_policy_handle_empty(Group),
1023                 "policy_handle non empty after CloseGroup");
1024
1025         return true;
1026 }
1027
1028 static bool test_OpenGroup(struct torture_context *tctx,
1029                            struct dcerpc_pipe *p)
1030 {
1031         struct policy_handle hGroup;
1032
1033         if (!test_OpenGroup_int(tctx, p, &hGroup)) {
1034                 return false;
1035         }
1036
1037         test_CloseGroup_int(tctx, p, &hGroup);
1038
1039         return true;
1040 }
1041
1042 static bool test_CloseGroup(struct torture_context *tctx,
1043                             struct dcerpc_pipe *p)
1044 {
1045         struct policy_handle hGroup;
1046
1047         if (!test_OpenGroup_int(tctx, p, &hGroup)) {
1048                 return false;
1049         }
1050
1051         return test_CloseGroup_int(tctx, p, &hGroup);
1052 }
1053
1054 struct torture_suite *torture_rpc_clusapi(TALLOC_CTX *mem_ctx)
1055 {
1056         struct torture_rpc_tcase *tcase;
1057         struct torture_suite *suite = torture_suite_create(mem_ctx, "clusapi");
1058         struct torture_test *test;
1059
1060         tcase = torture_suite_add_rpc_iface_tcase(suite, "cluster",
1061                                                   &ndr_table_clusapi);
1062
1063         torture_rpc_tcase_add_test(tcase, "OpenCluster",
1064                                    test_OpenCluster);
1065         torture_rpc_tcase_add_test(tcase, "CloseCluster",
1066                                    test_CloseCluster);
1067         torture_rpc_tcase_add_test(tcase, "SetClusterName",
1068                                    test_SetClusterName);
1069         torture_rpc_tcase_add_test(tcase, "GetClusterName",
1070                                    test_GetClusterName);
1071         torture_rpc_tcase_add_test(tcase, "GetClusterVersion",
1072                                    test_GetClusterVersion);
1073         torture_rpc_tcase_add_test(tcase, "CreateEnum",
1074                                    test_CreateEnum);
1075
1076         tcase = torture_suite_add_rpc_iface_tcase(suite, "resource",
1077                                                   &ndr_table_clusapi);
1078
1079         torture_rpc_tcase_add_test(tcase, "GetQuorumResource",
1080                                    test_GetQuorumResource);
1081         torture_rpc_tcase_add_test(tcase, "SetQuorumResource",
1082                                    test_SetQuorumResource);
1083         torture_rpc_tcase_add_test(tcase, "OpenResource",
1084                                    test_OpenResource);
1085         torture_rpc_tcase_add_test(tcase, "CloseResource",
1086                                    test_CloseResource);
1087         torture_rpc_tcase_add_test(tcase, "CreateResource",
1088                                    test_CreateResource);
1089         torture_rpc_tcase_add_test(tcase, "DeleteResource",
1090                                    test_DeleteResource);
1091         torture_rpc_tcase_add_test(tcase, "GetResourceState",
1092                                    test_GetResourceState);
1093         torture_rpc_tcase_add_test(tcase, "GetResourceId",
1094                                    test_GetResourceId);
1095         torture_rpc_tcase_add_test(tcase, "GetResourceType",
1096                                    test_GetResourceType);
1097         test = torture_rpc_tcase_add_test(tcase, "FailResource",
1098                                    test_FailResource);
1099         test->dangerous = true;
1100         torture_rpc_tcase_add_test(tcase, "OnlineResource",
1101                                    test_OnlineResource);
1102         test = torture_rpc_tcase_add_test(tcase, "OfflineResource",
1103                                    test_OfflineResource);
1104         test->dangerous = true;
1105
1106         torture_rpc_tcase_add_test(tcase, "GetClusterVersion2",
1107                                    test_GetClusterVersion2);
1108         torture_rpc_tcase_add_test(tcase, "CreateResEnum",
1109                                    test_CreateResEnum);
1110
1111         tcase = torture_suite_add_rpc_iface_tcase(suite, "node",
1112                                                   &ndr_table_clusapi);
1113
1114         torture_rpc_tcase_add_test(tcase, "OpenNode",
1115                                    test_OpenNode);
1116         torture_rpc_tcase_add_test(tcase, "CloseNode",
1117                                    test_CloseNode);
1118         torture_rpc_tcase_add_test(tcase, "GetNodeState",
1119                                    test_GetNodeState);
1120         torture_rpc_tcase_add_test(tcase, "GetNodeId",
1121                                    test_GetNodeId);
1122         test = torture_rpc_tcase_add_test(tcase, "PauseNode",
1123                                           test_PauseNode);
1124         test->dangerous = true;
1125         torture_rpc_tcase_add_test(tcase, "ResumeNode",
1126                                    test_ResumeNode);
1127         test = torture_rpc_tcase_add_test(tcase, "EvictNode",
1128                                           test_EvictNode);
1129         test->dangerous = true;
1130
1131         tcase = torture_suite_add_rpc_iface_tcase(suite, "group",
1132                                                   &ndr_table_clusapi);
1133
1134         torture_rpc_tcase_add_test(tcase, "OpenGroup",
1135                                    test_OpenGroup);
1136         torture_rpc_tcase_add_test(tcase, "CloseGroup",
1137                                    test_CloseGroup);
1138
1139
1140         return suite;
1141 }