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 struct torture_clusapi_context {
  27         struct dcerpc_pipe *p;
  28         const char *NodeName;
  29         const char *ClusterName;
  30 };
  31
  32 static bool test_OpenCluster_int(struct torture_context *tctx,
  33                                  struct dcerpc_pipe *p,
  34                                  struct policy_handle *Cluster)
  35 {
  36         struct dcerpc_binding_handle *b = p->binding_handle;
  37         struct clusapi_OpenCluster r;
  38         WERROR Status;
  39
  40         r.out.Status = &Status;
  41         r.out.Cluster = Cluster;
  42
  43         torture_assert_ntstatus_ok(tctx,
  44                 dcerpc_clusapi_OpenCluster_r(b, tctx, &r),
  45                 "OpenCluster failed");
  46         torture_assert_werr_ok(tctx,
  47                 *r.out.Status,
  48                 "OpenCluster failed");
  49
  50         return true;
  51 }
  52
  53 static bool test_OpenClusterEx_int(struct torture_context *tctx,
  54                                    struct dcerpc_pipe *p,
  55                                    struct policy_handle *Cluster)
  56 {
  57         struct dcerpc_binding_handle *b = p->binding_handle;
  58         struct clusapi_OpenClusterEx r;
  59         uint32_t lpdwGrantedAccess;
  60         WERROR Status;
  61
  62         r.in.dwDesiredAccess = SEC_FLAG_MAXIMUM_ALLOWED;
  63         r.out.lpdwGrantedAccess = &lpdwGrantedAccess;
  64         r.out.Status = &Status;
  65         r.out.hCluster = Cluster;
  66
  67         torture_assert_ntstatus_ok(tctx,
  68                 dcerpc_clusapi_OpenClusterEx_r(b, tctx, &r),
  69                 "OpenClusterEx failed");
  70         torture_assert_werr_ok(tctx,
  71                 *r.out.Status,
  72                 "OpenClusterEx failed");
  73
  74         return true;
  75 }
  76
  77 static bool test_CloseCluster_int(struct torture_context *tctx,
  78                                   struct dcerpc_pipe *p,
  79                                   struct policy_handle *Cluster)
  80 {
  81         struct dcerpc_binding_handle *b = p->binding_handle;
  82         struct clusapi_CloseCluster r;
  83
  84         r.in.Cluster = Cluster;
  85         r.out.Cluster = Cluster;
  86
  87         torture_assert_ntstatus_ok(tctx,
  88                 dcerpc_clusapi_CloseCluster_r(b, tctx, &r),
  89                 "CloseCluster failed");
  90         torture_assert_werr_ok(tctx,
  91                 r.out.result,
  92                 "CloseCluster failed");
  93
  94         torture_assert(tctx,
  95                 ndr_policy_handle_empty(Cluster),
  96                 "policy_handle non empty after CloseCluster");
  97
  98         return true;
  99 }
 100
 101 static bool test_OpenCluster(struct torture_context *tctx,
 102                              void *data)
 103 {
 104         struct torture_clusapi_context *t =
 105                 talloc_get_type_abort(data, struct torture_clusapi_context);
 106         struct policy_handle Cluster;
 107
 108         if (!test_OpenCluster_int(tctx, t->p, &Cluster)) {
 109                 return false;
 110         }
 111
 112         test_CloseCluster_int(tctx, t->p, &Cluster);
 113
 114         return true;
 115 }
 116
 117 static bool test_OpenClusterEx(struct torture_context *tctx,
 118                                void *data)
 119 {
 120         struct torture_clusapi_context *t =
 121                 talloc_get_type_abort(data, struct torture_clusapi_context);
 122         struct policy_handle Cluster;
 123
 124         if (!test_OpenClusterEx_int(tctx, t->p, &Cluster)) {
 125                 return false;
 126         }
 127
 128         test_CloseCluster_int(tctx, t->p, &Cluster);
 129
 130         return true;
 131 }
 132
 133 static bool test_CloseCluster(struct torture_context *tctx,
 134                               void *data)
 135 {
 136         struct torture_clusapi_context *t =
 137                 talloc_get_type_abort(data, struct torture_clusapi_context);
 138         struct policy_handle Cluster;
 139
 140         if (!test_OpenCluster_int(tctx, t->p, &Cluster)) {
 141                 return false;
 142         }
 143
 144         return test_CloseCluster_int(tctx, t->p, &Cluster);
 145 }
 146
 147 static bool test_GetClusterName_int(struct torture_context *tctx,
 148                                     struct dcerpc_pipe *p,
 149                                     const char **ClusterName)
 150 {
 151         struct dcerpc_binding_handle *b = p->binding_handle;
 152         struct clusapi_GetClusterName r;
 153         const char *NodeName;
 154
 155         r.out.ClusterName = ClusterName;
 156         r.out.NodeName = &NodeName;
 157
 158         torture_assert_ntstatus_ok(tctx,
 159                 dcerpc_clusapi_GetClusterName_r(b, tctx, &r),
 160                 "GetClusterName failed");
 161         torture_assert_werr_ok(tctx,
 162                 r.out.result,
 163                 "GetClusterName failed");
 164
 165         return true;
 166 }
 167
 168 static bool test_SetClusterName(struct torture_context *tctx,
 169                                 void *data)
 170 {
 171         struct torture_clusapi_context *t =
 172                 talloc_get_type_abort(data, struct torture_clusapi_context);
 173         struct dcerpc_binding_handle *b = t->p->binding_handle;
 174         struct clusapi_SetClusterName r;
 175         const char *NewClusterName;
 176         WERROR rpc_status;
 177
 178         torture_assert(tctx,
 179                 test_GetClusterName_int(tctx, t->p, &NewClusterName),
 180                 "failed to query old ClusterName");
 181
 182         r.in.NewClusterName = NewClusterName;
 183         r.out.rpc_status = &rpc_status;
 184
 185         torture_assert_ntstatus_ok(tctx,
 186                 dcerpc_clusapi_SetClusterName_r(b, tctx, &r),
 187                 "SetClusterName failed");
 188         torture_assert_werr_equal(tctx,
 189                 r.out.result,
 190                 WERR_RESOURCE_PROPERTIES_STORED,
 191                 "SetClusterName failed");
 192
 193         return true;
 194 }
 195
 196 static bool test_GetClusterName(struct torture_context *tctx,
 197                                 void *data)
 198 {
 199         struct torture_clusapi_context *t =
 200                 talloc_get_type_abort(data, struct torture_clusapi_context);
 201         const char *ClusterName;
 202
 203         return test_GetClusterName_int(tctx, t->p, &ClusterName);
 204 }
 205
 206 static bool test_GetClusterVersion(struct torture_context *tctx,
 207                                    void *data)
 208 {
 209         struct torture_clusapi_context *t =
 210                 talloc_get_type_abort(data, struct torture_clusapi_context);
 211         struct dcerpc_binding_handle *b = t->p->binding_handle;
 212         struct clusapi_GetClusterVersion r;
 213         uint16_t lpwMajorVersion;
 214         uint16_t lpwMinorVersion;
 215         uint16_t lpwBuildNumber;
 216         const char *lpszVendorId;
 217         const char *lpszCSDVersion;
 218
 219         r.out.lpwMajorVersion = &lpwMajorVersion;
 220         r.out.lpwMinorVersion = &lpwMinorVersion;
 221         r.out.lpwBuildNumber = &lpwBuildNumber;
 222         r.out.lpszVendorId = &lpszVendorId;
 223         r.out.lpszCSDVersion = &lpszCSDVersion;
 224
 225         torture_assert_ntstatus_ok(tctx,
 226                 dcerpc_clusapi_GetClusterVersion_r(b, tctx, &r),
 227                 "GetClusterVersion failed");
 228         torture_assert_werr_equal(tctx,
 229                 r.out.result,
 230                 WERR_CALL_NOT_IMPLEMENTED,
 231                 "GetClusterVersion failed");
 232
 233         return true;
 234 }
 235
 236 static bool test_GetClusterVersion2(struct torture_context *tctx,
 237                                     void *data)
 238 {
 239         struct torture_clusapi_context *t =
 240                 talloc_get_type_abort(data, struct torture_clusapi_context);
 241         struct dcerpc_binding_handle *b = t->p->binding_handle;
 242         struct clusapi_GetClusterVersion2 r;
 243         uint16_t lpwMajorVersion;
 244         uint16_t lpwMinorVersion;
 245         uint16_t lpwBuildNumber;
 246         const char *lpszVendorId;
 247         const char *lpszCSDVersion;
 248         struct CLUSTER_OPERATIONAL_VERSION_INFO *ppClusterOpVerInfo;
 249         WERROR rpc_status;
 250
 251         r.out.lpwMajorVersion = &lpwMajorVersion;
 252         r.out.lpwMinorVersion = &lpwMinorVersion;
 253         r.out.lpwBuildNumber = &lpwBuildNumber;
 254         r.out.lpszVendorId = &lpszVendorId;
 255         r.out.lpszCSDVersion = &lpszCSDVersion;
 256         r.out.ppClusterOpVerInfo = &ppClusterOpVerInfo;
 257         r.out.rpc_status = &rpc_status;
 258
 259         torture_assert_ntstatus_ok(tctx,
 260                 dcerpc_clusapi_GetClusterVersion2_r(b, tctx, &r),
 261                 "GetClusterVersion2 failed");
 262         torture_assert_werr_ok(tctx,
 263                 r.out.result,
 264                 "GetClusterVersion2 failed");
 265
 266         return true;
 267 }
 268
 269 static bool test_CreateEnum(struct torture_context *tctx,
 270                             void *data)
 271 {
 272         struct torture_clusapi_context *t =
 273                 talloc_get_type_abort(data, struct torture_clusapi_context);
 274         struct dcerpc_binding_handle *b = t->p->binding_handle;
 275         struct clusapi_CreateEnum r;
 276         uint32_t dwType = CLUSTER_ENUM_RESOURCE;
 277         struct ENUM_LIST *ReturnEnum;
 278         WERROR rpc_status;
 279
 280         r.in.dwType = dwType;
 281         r.out.ReturnEnum = &ReturnEnum;
 282         r.out.rpc_status = &rpc_status;
 283
 284         torture_assert_ntstatus_ok(tctx,
 285                 dcerpc_clusapi_CreateEnum_r(b, tctx, &r),
 286                 "CreateEnum failed");
 287         torture_assert_werr_ok(tctx,
 288                 r.out.result,
 289                 "CreateEnum failed");
 290
 291         return true;
 292 }
 293
 294 static bool test_GetQuorumResource(struct torture_context *tctx,
 295                                    void *data)
 296 {
 297         struct torture_clusapi_context *t =
 298                 talloc_get_type_abort(data, struct torture_clusapi_context);
 299         struct dcerpc_binding_handle *b = t->p->binding_handle;
 300         struct clusapi_GetQuorumResource r;
 301         const char *lpszResourceName;
 302         const char *lpszDeviceName;
 303         uint32_t pdwMaxQuorumLogSize;
 304         WERROR rpc_status;
 305
 306         r.out.lpszResourceName = &lpszResourceName;
 307         r.out.lpszDeviceName = &lpszDeviceName;
 308         r.out.pdwMaxQuorumLogSize = &pdwMaxQuorumLogSize;
 309         r.out.rpc_status = &rpc_status;
 310
 311         torture_assert_ntstatus_ok(tctx,
 312                 dcerpc_clusapi_GetQuorumResource_r(b, tctx, &r),
 313                 "GetQuorumResource failed");
 314         torture_assert_werr_ok(tctx,
 315                 r.out.result,
 316                 "GetQuorumResource failed");
 317
 318         return true;
 319 }
 320
 321 static bool test_SetQuorumResource(struct torture_context *tctx,
 322                                    void *data)
 323 {
 324         struct torture_clusapi_context *t =
 325                 talloc_get_type_abort(data, struct torture_clusapi_context);
 326         struct dcerpc_binding_handle *b = t->p->binding_handle;
 327         struct clusapi_SetQuorumResource r;
 328         const char *lpszDeviceName = "";
 329         uint32_t dwMaxQuorumLogSize = 0;
 330         WERROR rpc_status;
 331         struct policy_handle hResource;
 332
 333         /* we need to figure out how this call works and what we provide as
 334            devicename and resource handle - gd
 335          */
 336
 337         torture_skip(tctx, "skipping SetQuorumResource test");
 338
 339         ZERO_STRUCT(hResource);
 340
 341         r.in.hResource = hResource;
 342         r.in.lpszDeviceName = lpszDeviceName;
 343         r.in.dwMaxQuorumLogSize = dwMaxQuorumLogSize;
 344         r.out.rpc_status = &rpc_status;
 345
 346         torture_assert_ntstatus_ok(tctx,
 347                 dcerpc_clusapi_SetQuorumResource_r(b, tctx, &r),
 348                 "SetQuorumResource failed");
 349         torture_assert_werr_ok(tctx,
 350                 r.out.result,
 351                 "SetQuorumResource failed");
 352
 353         return true;
 354 }
 355
 356 bool test_OpenResource_int(struct torture_context *tctx,
 357                            struct dcerpc_pipe *p,
 358                            const char *lpszResourceName,
 359                            struct policy_handle *hResource)
 360 {
 361         struct dcerpc_binding_handle *b = p->binding_handle;
 362         struct clusapi_OpenResource r;
 363         WERROR Status;
 364         WERROR rpc_status;
 365
 366         r.in.lpszResourceName = lpszResourceName;
 367         r.out.rpc_status = &rpc_status;
 368         r.out.Status = &Status;
 369         r.out.hResource = hResource;
 370
 371         torture_assert_ntstatus_ok(tctx,
 372                 dcerpc_clusapi_OpenResource_r(b, tctx, &r),
 373                 "OpenResource failed");
 374         torture_assert_werr_ok(tctx,
 375                 *r.out.Status,
 376                 "OpenResource failed");
 377
 378         return true;
 379 }
 380
 381 static bool test_OpenResourceEx_int(struct torture_context *tctx,
 382                                     struct dcerpc_pipe *p,
 383                                     const char *lpszResourceName,
 384                                     struct policy_handle *hResource)
 385 {
 386         struct dcerpc_binding_handle *b = p->binding_handle;
 387         struct clusapi_OpenResourceEx r;
 388         uint32_t lpdwGrantedAccess;
 389         WERROR Status;
 390         WERROR rpc_status;
 391
 392         r.in.lpszResourceName = lpszResourceName;
 393         r.in.dwDesiredAccess = SEC_FLAG_MAXIMUM_ALLOWED;
 394         r.out.lpdwGrantedAccess = &lpdwGrantedAccess;
 395         r.out.rpc_status = &rpc_status;
 396         r.out.Status = &Status;
 397         r.out.hResource = hResource;
 398
 399         torture_assert_ntstatus_ok(tctx,
 400                 dcerpc_clusapi_OpenResourceEx_r(b, tctx, &r),
 401                 "OpenResourceEx failed");
 402         torture_assert_werr_ok(tctx,
 403                 *r.out.Status,
 404                 "OpenResourceEx failed");
 405
 406         return true;
 407 }
 408
 409 bool test_CloseResource_int(struct torture_context *tctx,
 410                             struct dcerpc_pipe *p,
 411                             struct policy_handle *hResource)
 412 {
 413         struct dcerpc_binding_handle *b = p->binding_handle;
 414         struct clusapi_CloseResource r;
 415
 416         r.in.Resource = hResource;
 417         r.out.Resource = hResource;
 418
 419         torture_assert_ntstatus_ok(tctx,
 420                 dcerpc_clusapi_CloseResource_r(b, tctx, &r),
 421                 "CloseResource failed");
 422         torture_assert_werr_ok(tctx,
 423                 r.out.result,
 424                 "CloseResource failed");
 425         torture_assert(tctx,
 426                 ndr_policy_handle_empty(hResource),
 427                 "policy_handle non empty after CloseResource");
 428
 429         return true;
 430 }
 431
 432 static bool test_OpenResource(struct torture_context *tctx,
 433                               void *data)
 434 {
 435         struct torture_clusapi_context *t =
 436                 talloc_get_type_abort(data, struct torture_clusapi_context);
 437         struct policy_handle hResource;
 438
 439         if (!test_OpenResource_int(tctx, t->p, "Cluster Name", &hResource)) {
 440                 return false;
 441         }
 442
 443         test_CloseResource_int(tctx, t->p, &hResource);
 444
 445         return true;
 446 }
 447
 448 static bool test_OpenResourceEx(struct torture_context *tctx,
 449                                 void *data)
 450 {
 451         struct torture_clusapi_context *t =
 452                 talloc_get_type_abort(data, struct torture_clusapi_context);
 453         struct policy_handle hResource;
 454
 455         if (!test_OpenResourceEx_int(tctx, t->p, "Cluster Name", &hResource)) {
 456                 return false;
 457         }
 458
 459         test_CloseResource_int(tctx, t->p, &hResource);
 460
 461         return true;
 462 }
 463
 464
 465 static bool test_CloseResource(struct torture_context *tctx,
 466                                void *data)
 467 {
 468         struct torture_clusapi_context *t =
 469                 talloc_get_type_abort(data, struct torture_clusapi_context);
 470         struct policy_handle hResource;
 471
 472         if (!test_OpenResource_int(tctx, t->p, "Cluster Name", &hResource)) {
 473                 return false;
 474         }
 475
 476         return test_CloseResource_int(tctx, t->p, &hResource);
 477 }
 478
 479 static bool test_OpenGroup_int(struct torture_context *tctx,
 480                                struct dcerpc_pipe *p,
 481                                const char *lpszGroupName,
 482                                struct policy_handle *hGroup);
 483 static bool test_CloseGroup_int(struct torture_context *tctx,
 484                                 struct dcerpc_pipe *p,
 485                                 struct policy_handle *Group);
 486
 487 static bool test_CreateResource_int(struct torture_context *tctx,
 488                                     struct dcerpc_pipe *p,
 489                                     struct policy_handle *hResource)
 490 {
 491         struct dcerpc_binding_handle *b = p->binding_handle;
 492         struct clusapi_CreateResource r;
 493         const char *lpszResourceName = "wurst";
 494         const char *lpszResourceType = "Generic Service";
 495         WERROR Status;
 496         WERROR rpc_status;
 497         struct policy_handle hGroup;
 498
 499         torture_assert(tctx,
 500                 test_OpenGroup_int(tctx, p, "Cluster Group", &hGroup),
 501                 "failed to open group");
 502
 503         r.in.hGroup = hGroup;
 504         r.in.lpszResourceName = lpszResourceName;
 505         r.in.lpszResourceType = lpszResourceType;
 506         r.in.dwFlags = CLUSTER_RESOURCE_DEFAULT_MONITOR;
 507         r.out.rpc_status = &rpc_status;
 508         r.out.Status = &Status;
 509         r.out.hResource = hResource;
 510
 511         torture_assert_ntstatus_ok(tctx,
 512                 dcerpc_clusapi_CreateResource_r(b, tctx, &r),
 513                 "CreateResource failed");
 514         torture_assert_werr_ok(tctx,
 515                 *r.out.Status,
 516                 "CreateResource failed");
 517
 518         test_CloseGroup_int(tctx, p, &hGroup);
 519
 520         return true;
 521 }
 522
 523 static bool test_DeleteResource_int(struct torture_context *tctx,
 524                                     struct dcerpc_pipe *p,
 525                                     struct policy_handle *hResource)
 526 {
 527         struct dcerpc_binding_handle *b = p->binding_handle;
 528         struct clusapi_DeleteResource r;
 529         WERROR rpc_status;
 530
 531         r.in.hResource = *hResource;
 532         r.out.rpc_status = &rpc_status;
 533
 534         torture_assert_ntstatus_ok(tctx,
 535                 dcerpc_clusapi_DeleteResource_r(b, tctx, &r),
 536                 "DeleteResource failed");
 537         torture_assert_werr_ok(tctx,
 538                 r.out.result,
 539                 "DeleteResource failed");
 540
 541         return true;
 542 }
 543
 544 static bool test_CreateResource(struct torture_context *tctx,
 545                                 void *data)
 546 {
 547         struct torture_clusapi_context *t =
 548                 talloc_get_type_abort(data, struct torture_clusapi_context);
 549         struct policy_handle hResource;
 550
 551         if (!test_CreateResource_int(tctx, t->p, &hResource)) {
 552                 return false;
 553         }
 554
 555         test_DeleteResource_int(tctx, t->p, &hResource);
 556
 557         return true;
 558 }
 559
 560 static bool test_DeleteResource(struct torture_context *tctx,
 561                                 void *data)
 562 {
 563         struct torture_clusapi_context *t =
 564                 talloc_get_type_abort(data, struct torture_clusapi_context);
 565         struct policy_handle hResource;
 566
 567         if (!test_CreateResource_int(tctx, t->p, &hResource)) {
 568                 return false;
 569         }
 570
 571         return test_DeleteResource_int(tctx, t->p, &hResource);
 572 }
 573
 574 static bool test_SetResourceName_int(struct torture_context *tctx,
 575                                      struct dcerpc_pipe *p,
 576                                      struct policy_handle *hResource)
 577 {
 578         struct dcerpc_binding_handle *b = p->binding_handle;
 579         struct clusapi_SetResourceName r;
 580         WERROR rpc_status;
 581
 582         r.in.hResource = *hResource;
 583         r.in.lpszResourceName = "wurst";
 584         r.out.rpc_status = &rpc_status;
 585
 586         torture_assert_ntstatus_ok(tctx,
 587                 dcerpc_clusapi_SetResourceName_r(b, tctx, &r),
 588                 "SetResourceName failed");
 589         torture_assert_werr_ok(tctx,
 590                 r.out.result,
 591                 "SetResourceName failed");
 592
 593         return true;
 594 }
 595
 596 static bool test_SetResourceName(struct torture_context *tctx,
 597                                  void *data)
 598 {
 599         struct torture_clusapi_context *t =
 600                 talloc_get_type_abort(data, struct torture_clusapi_context);
 601         struct policy_handle hResource;
 602         bool ret = true;
 603
 604         if (!test_CreateResource_int(tctx, t->p, &hResource)) {
 605                 return false;
 606         }
 607
 608         ret = test_SetResourceName_int(tctx, t->p, &hResource);
 609
 610         test_DeleteResource_int(tctx, t->p, &hResource);
 611
 612         return ret;
 613 }
 614
 615 static bool test_GetResourceState_int(struct torture_context *tctx,
 616                                       struct dcerpc_pipe *p,
 617                                       struct policy_handle *hResource)
 618 {
 619         struct dcerpc_binding_handle *b = p->binding_handle;
 620         struct clusapi_GetResourceState r;
 621         enum clusapi_ClusterResourceState State;
 622         const char *NodeName;
 623         const char *GroupName;
 624         WERROR rpc_status;
 625
 626         r.in.hResource = *hResource;
 627         r.out.State = &State;
 628         r.out.NodeName = &NodeName;
 629         r.out.GroupName = &GroupName;
 630         r.out.rpc_status = &rpc_status;
 631
 632         torture_assert_ntstatus_ok(tctx,
 633                 dcerpc_clusapi_GetResourceState_r(b, tctx, &r),
 634                 "GetResourceState failed");
 635         torture_assert_werr_ok(tctx,
 636                 r.out.result,
 637                 "GetResourceState failed");
 638
 639         return true;
 640 }
 641
 642 static bool test_GetResourceState(struct torture_context *tctx,
 643                                   void *data)
 644 {
 645         struct torture_clusapi_context *t =
 646                 talloc_get_type_abort(data, struct torture_clusapi_context);
 647         struct policy_handle hResource;
 648         bool ret = true;
 649
 650         if (!test_OpenResource_int(tctx, t->p, "Cluster Name", &hResource)) {
 651                 return false;
 652         }
 653
 654         ret = test_GetResourceState_int(tctx, t->p, &hResource);
 655
 656         test_CloseResource_int(tctx, t->p, &hResource);
 657
 658         return ret;
 659 }
 660
 661 static bool test_GetResourceId_int(struct torture_context *tctx,
 662                                    struct dcerpc_pipe *p,
 663                                    struct policy_handle *hResource)
 664 {
 665         struct dcerpc_binding_handle *b = p->binding_handle;
 666         struct clusapi_GetResourceId r;
 667         const char *pGuid;
 668         WERROR rpc_status;
 669
 670         r.in.hResource = *hResource;
 671         r.out.pGuid = &pGuid;
 672         r.out.rpc_status = &rpc_status;
 673
 674         torture_assert_ntstatus_ok(tctx,
 675                 dcerpc_clusapi_GetResourceId_r(b, tctx, &r),
 676                 "GetResourceId failed");
 677         torture_assert_werr_ok(tctx,
 678                 r.out.result,
 679                 "GetResourceId failed");
 680
 681         return true;
 682 }
 683
 684 static bool test_GetResourceId(struct torture_context *tctx,
 685                                void *data)
 686 {
 687         struct torture_clusapi_context *t =
 688                 talloc_get_type_abort(data, struct torture_clusapi_context);
 689         struct policy_handle hResource;
 690         bool ret = true;
 691
 692         if (!test_OpenResource_int(tctx, t->p, "Cluster Name", &hResource)) {
 693                 return false;
 694         }
 695
 696         ret = test_GetResourceId_int(tctx, t->p, &hResource);
 697
 698         test_CloseResource_int(tctx, t->p, &hResource);
 699
 700         return ret;
 701 }
 702
 703 static bool test_GetResourceType_int(struct torture_context *tctx,
 704                                      struct dcerpc_pipe *p,
 705                                      struct policy_handle *hResource)
 706 {
 707         struct dcerpc_binding_handle *b = p->binding_handle;
 708         struct clusapi_GetResourceType r;
 709         const char *lpszResourceType;
 710         WERROR rpc_status;
 711
 712         r.in.hResource = *hResource;
 713         r.out.lpszResourceType = &lpszResourceType;
 714         r.out.rpc_status = &rpc_status;
 715
 716         torture_assert_ntstatus_ok(tctx,
 717                 dcerpc_clusapi_GetResourceType_r(b, tctx, &r),
 718                 "GetResourceType failed");
 719         torture_assert_werr_ok(tctx,
 720                 r.out.result,
 721                 "GetResourceType failed");
 722
 723         return true;
 724 }
 725
 726 static bool test_GetResourceType(struct torture_context *tctx,
 727                                  void *data)
 728 {
 729         struct torture_clusapi_context *t =
 730                 talloc_get_type_abort(data, struct torture_clusapi_context);
 731         struct policy_handle hResource;
 732         bool ret = true;
 733
 734         if (!test_OpenResource_int(tctx, t->p, "Cluster Name", &hResource)) {
 735                 return false;
 736         }
 737
 738         ret = test_GetResourceType_int(tctx, t->p, &hResource);
 739
 740         test_CloseResource_int(tctx, t->p, &hResource);
 741
 742         return ret;
 743 }
 744
 745 static bool test_FailResource_int(struct torture_context *tctx,
 746                                   struct dcerpc_pipe *p,
 747                                   struct policy_handle *hResource)
 748 {
 749         struct dcerpc_binding_handle *b = p->binding_handle;
 750         struct clusapi_FailResource r;
 751         WERROR rpc_status;
 752
 753         r.in.hResource = *hResource;
 754         r.out.rpc_status = &rpc_status;
 755
 756         torture_assert_ntstatus_ok(tctx,
 757                 dcerpc_clusapi_FailResource_r(b, tctx, &r),
 758                 "FailResource failed");
 759         torture_assert_werr_ok(tctx,
 760                 r.out.result,
 761                 "FailResource failed");
 762
 763         return true;
 764 }
 765
 766 static bool test_FailResource(struct torture_context *tctx,
 767                               void *data)
 768 {
 769         struct torture_clusapi_context *t =
 770                 talloc_get_type_abort(data, struct torture_clusapi_context);
 771         struct policy_handle hResource;
 772         bool ret = true;
 773
 774         if (!test_OpenResource_int(tctx, t->p, "Cluster Name", &hResource)) {
 775                 return false;
 776         }
 777
 778         ret = test_FailResource_int(tctx, t->p, &hResource);
 779
 780         test_CloseResource_int(tctx, t->p, &hResource);
 781
 782         return ret;
 783 }
 784
 785 bool test_OnlineResource_int(struct torture_context *tctx,
 786                              struct dcerpc_pipe *p,
 787                              struct policy_handle *hResource)
 788 {
 789         struct dcerpc_binding_handle *b = p->binding_handle;
 790         struct clusapi_OnlineResource r;
 791         WERROR rpc_status;
 792
 793         r.in.hResource = *hResource;
 794         r.out.rpc_status = &rpc_status;
 795
 796         torture_assert_ntstatus_ok(tctx,
 797                 dcerpc_clusapi_OnlineResource_r(b, tctx, &r),
 798                 "OnlineResource failed");
 799         torture_assert_werr_ok(tctx,
 800                 r.out.result,
 801                 "OnlineResource failed");
 802
 803         return true;
 804 }
 805
 806 static bool test_OnlineResource(struct torture_context *tctx,
 807                                 void *data)
 808 {
 809         struct torture_clusapi_context *t =
 810                 talloc_get_type_abort(data, struct torture_clusapi_context);
 811         struct policy_handle hResource;
 812         bool ret = true;
 813
 814         if (!test_OpenResource_int(tctx, t->p, "Cluster Name", &hResource)) {
 815                 return false;
 816         }
 817
 818         ret = test_OnlineResource_int(tctx, t->p, &hResource);
 819
 820         test_CloseResource_int(tctx, t->p, &hResource);
 821
 822         return ret;
 823 }
 824
 825 bool test_OfflineResource_int(struct torture_context *tctx,
 826                               struct dcerpc_pipe *p,
 827                               struct policy_handle *hResource)
 828 {
 829         struct dcerpc_binding_handle *b = p->binding_handle;
 830         struct clusapi_OfflineResource r;
 831         WERROR rpc_status;
 832
 833         r.in.hResource = *hResource;
 834         r.out.rpc_status = &rpc_status;
 835
 836         torture_assert_ntstatus_ok(tctx,
 837                 dcerpc_clusapi_OfflineResource_r(b, tctx, &r),
 838                 "OfflineResource failed");
 839         torture_assert_werr_ok(tctx,
 840                 r.out.result,
 841                 "OfflineResource failed");
 842
 843         return true;
 844 }
 845
 846 static bool test_OfflineResource(struct torture_context *tctx,
 847                                  void *data)
 848 {
 849         struct torture_clusapi_context *t =
 850                 talloc_get_type_abort(data, struct torture_clusapi_context);
 851         struct policy_handle hResource;
 852         bool ret = true;
 853
 854         if (!test_OpenResource_int(tctx, t->p, "Cluster Name", &hResource)) {
 855                 return false;
 856         }
 857
 858         ret = test_OfflineResource_int(tctx, t->p, &hResource);
 859
 860         test_CloseResource_int(tctx, t->p, &hResource);
 861
 862         return ret;
 863 }
 864
 865 static bool test_CreateResEnum_int(struct torture_context *tctx,
 866                                    struct dcerpc_pipe *p,
 867                                    struct policy_handle *hResource)
 868 {
 869         struct dcerpc_binding_handle *b = p->binding_handle;
 870         struct clusapi_CreateResEnum r;
 871         uint32_t dwType = CLUSTER_ENUM_RESOURCE;
 872         struct ENUM_LIST *ReturnEnum;
 873         WERROR rpc_status;
 874
 875         r.in.hResource = *hResource;
 876         r.in.dwType = dwType;
 877         r.out.ReturnEnum = &ReturnEnum;
 878         r.out.rpc_status = &rpc_status;
 879
 880         torture_assert_ntstatus_ok(tctx,
 881                 dcerpc_clusapi_CreateResEnum_r(b, tctx, &r),
 882                 "CreateResEnum failed");
 883         torture_assert_werr_ok(tctx,
 884                 r.out.result,
 885                 "CreateResEnum failed");
 886
 887         return true;
 888 }
 889
 890 static bool test_CreateResEnum(struct torture_context *tctx,
 891                                void *data)
 892 {
 893         struct torture_clusapi_context *t =
 894                 talloc_get_type_abort(data, struct torture_clusapi_context);
 895         struct policy_handle hResource;
 896         bool ret = true;
 897
 898         if (!test_OpenResource_int(tctx, t->p, "Cluster Name", &hResource)) {
 899                 return false;
 900         }
 901
 902         ret = test_CreateResEnum_int(tctx, t->p, &hResource);
 903
 904         test_CloseResource_int(tctx, t->p, &hResource);
 905
 906         return ret;
 907 }
 908
 909 static bool test_one_resource(struct torture_context *tctx,
 910                               struct dcerpc_pipe *p,
 911                               const char *resource_name)
 912 {
 913         struct policy_handle hResource;
 914
 915         torture_assert(tctx,
 916                 test_OpenResource_int(tctx, p, resource_name, &hResource),
 917                 "failed to open resource");
 918         test_CloseResource_int(tctx, p, &hResource);
 919
 920         torture_assert(tctx,
 921                 test_OpenResourceEx_int(tctx, p, resource_name, &hResource),
 922                 "failed to openex resource");
 923
 924         torture_assert(tctx,
 925                 test_GetResourceType_int(tctx, p, &hResource),
 926                 "failed to query resource type");
 927         torture_assert(tctx,
 928                 test_GetResourceId_int(tctx, p, &hResource),
 929                 "failed to query resource id");
 930         torture_assert(tctx,
 931                 test_GetResourceState_int(tctx, p, &hResource),
 932                 "failed to query resource state");
 933         torture_assert(tctx,
 934                 test_CreateResEnum_int(tctx, p, &hResource),
 935                 "failed to query resource enum");
 936
 937         test_CloseResource_int(tctx, p, &hResource);
 938
 939         return true;
 940 }
 941
 942 static bool test_all_resources(struct torture_context *tctx,
 943                                void *data)
 944 {
 945         struct torture_clusapi_context *t =
 946                 talloc_get_type_abort(data, struct torture_clusapi_context);
 947         struct dcerpc_binding_handle *b = t->p->binding_handle;
 948         struct clusapi_CreateEnum r;
 949         uint32_t dwType = CLUSTER_ENUM_RESOURCE;
 950         struct ENUM_LIST *ReturnEnum;
 951         WERROR rpc_status;
 952         int i;
 953
 954         r.in.dwType = dwType;
 955         r.out.ReturnEnum = &ReturnEnum;
 956         r.out.rpc_status = &rpc_status;
 957
 958         torture_assert_ntstatus_ok(tctx,
 959                 dcerpc_clusapi_CreateEnum_r(b, tctx, &r),
 960                 "CreateEnum failed");
 961         torture_assert_werr_ok(tctx,
 962                 r.out.result,
 963                 "CreateEnum failed");
 964
 965         for (i=0; i < ReturnEnum->EntryCount; i++) {
 966
 967                 struct ENUM_ENTRY e = ReturnEnum->Entry[i];
 968
 969                 torture_assert_int_equal(tctx, e.Type, CLUSTER_ENUM_RESOURCE, "type mismatch");
 970
 971                 torture_assert(tctx,
 972                         test_one_resource(tctx, t->p, e.Name),
 973                         "failed to test one resource");
 974         }
 975
 976         return true;
 977 }
 978
 979 static bool test_OpenNode_int(struct torture_context *tctx,
 980                               struct dcerpc_pipe *p,
 981                               const char *lpszNodeName,
 982                               struct policy_handle *hNode)
 983 {
 984         struct dcerpc_binding_handle *b = p->binding_handle;
 985         struct clusapi_OpenNode r;
 986         WERROR Status;
 987         WERROR rpc_status;
 988
 989         r.in.lpszNodeName = lpszNodeName;
 990         r.out.rpc_status = &rpc_status;
 991         r.out.Status = &Status;
 992         r.out.hNode= hNode;
 993
 994         torture_assert_ntstatus_ok(tctx,
 995                 dcerpc_clusapi_OpenNode_r(b, tctx, &r),
 996                 "OpenNode failed");
 997         torture_assert_werr_ok(tctx,
 998                 *r.out.Status,
 999                 "OpenNode failed");
1000
1001         return true;
1002 }
1003
1004 static bool test_OpenNodeEx_int(struct torture_context *tctx,
1005                                 struct dcerpc_pipe *p,
1006                                 const char *lpszNodeName,
1007                                 struct policy_handle *hNode)
1008 {
1009         struct dcerpc_binding_handle *b = p->binding_handle;
1010         struct clusapi_OpenNodeEx r;
1011         uint32_t lpdwGrantedAccess;
1012         WERROR Status;
1013         WERROR rpc_status;
1014
1015         r.in.lpszNodeName = lpszNodeName;
1016         r.in.dwDesiredAccess = SEC_FLAG_MAXIMUM_ALLOWED;
1017         r.out.lpdwGrantedAccess = &lpdwGrantedAccess;
1018         r.out.rpc_status = &rpc_status;
1019         r.out.Status = &Status;
1020         r.out.hNode= hNode;
1021
1022         torture_assert_ntstatus_ok(tctx,
1023                 dcerpc_clusapi_OpenNodeEx_r(b, tctx, &r),
1024                 "OpenNodeEx failed");
1025         torture_assert_werr_ok(tctx,
1026                 *r.out.Status,
1027                 "OpenNodeEx failed");
1028
1029         return true;
1030 }
1031
1032
1033 static bool test_CloseNode_int(struct torture_context *tctx,
1034                                struct dcerpc_pipe *p,
1035                                struct policy_handle *Node)
1036 {
1037         struct dcerpc_binding_handle *b = p->binding_handle;
1038         struct clusapi_CloseNode r;
1039
1040         r.in.Node = Node;
1041         r.out.Node = Node;
1042
1043         torture_assert_ntstatus_ok(tctx,
1044                 dcerpc_clusapi_CloseNode_r(b, tctx, &r),
1045                 "CloseNode failed");
1046         torture_assert_werr_ok(tctx,
1047                 r.out.result,
1048                 "CloseNode failed");
1049         torture_assert(tctx,
1050                 ndr_policy_handle_empty(Node),
1051                 "policy_handle non empty after CloseNode");
1052
1053         return true;
1054 }
1055
1056 static bool test_OpenNode(struct torture_context *tctx,
1057                           void *data)
1058 {
1059         struct torture_clusapi_context *t =
1060                 talloc_get_type_abort(data, struct torture_clusapi_context);
1061         struct policy_handle hNode;
1062
1063         if (!test_OpenNode_int(tctx, t->p, t->NodeName, &hNode)) {
1064                 return false;
1065         }
1066
1067         test_CloseNode_int(tctx, t->p, &hNode);
1068
1069         return true;
1070 }
1071
1072 static bool test_OpenNodeEx(struct torture_context *tctx,
1073                             void *data)
1074 {
1075         struct torture_clusapi_context *t =
1076                 talloc_get_type_abort(data, struct torture_clusapi_context);
1077         struct policy_handle hNode;
1078
1079         if (!test_OpenNodeEx_int(tctx, t->p, t->NodeName, &hNode)) {
1080                 return false;
1081         }
1082
1083         test_CloseNode_int(tctx, t->p, &hNode);
1084
1085         return true;
1086 }
1087
1088 static bool test_CloseNode(struct torture_context *tctx,
1089                            void *data)
1090 {
1091         struct torture_clusapi_context *t =
1092                 talloc_get_type_abort(data, struct torture_clusapi_context);
1093         struct policy_handle hNode;
1094
1095         if (!test_OpenNode_int(tctx, t->p, t->NodeName, &hNode)) {
1096                 return false;
1097         }
1098
1099         return test_CloseNode_int(tctx, t->p, &hNode);
1100 }
1101
1102 static bool test_GetNodeState_int(struct torture_context *tctx,
1103                                   struct dcerpc_pipe *p,
1104                                   struct policy_handle *hNode)
1105 {
1106         struct dcerpc_binding_handle *b = p->binding_handle;
1107         struct clusapi_GetNodeState r;
1108         enum clusapi_ClusterNodeState State;
1109         WERROR rpc_status;
1110
1111         r.in.hNode = *hNode;
1112         r.out.State = &State;
1113         r.out.rpc_status = &rpc_status;
1114
1115         torture_assert_ntstatus_ok(tctx,
1116                 dcerpc_clusapi_GetNodeState_r(b, tctx, &r),
1117                 "GetNodeState failed");
1118         torture_assert_werr_ok(tctx,
1119                 r.out.result,
1120                 "GetNodeState failed");
1121
1122         return true;
1123 }
1124
1125 static bool test_GetNodeState(struct torture_context *tctx,
1126                               void *data)
1127 {
1128         struct torture_clusapi_context *t =
1129                 talloc_get_type_abort(data, struct torture_clusapi_context);
1130         struct policy_handle hNode;
1131         bool ret = true;
1132
1133         if (!test_OpenNode_int(tctx, t->p, t->NodeName, &hNode)) {
1134                 return false;
1135         }
1136
1137         ret = test_GetNodeState_int(tctx, t->p, &hNode);
1138
1139         test_CloseNode_int(tctx, t->p, &hNode);
1140
1141         return ret;
1142 }
1143
1144 static bool test_GetNodeId_int(struct torture_context *tctx,
1145                                struct dcerpc_pipe *p,
1146                                struct policy_handle *hNode)
1147 {
1148         struct dcerpc_binding_handle *b = p->binding_handle;
1149         struct clusapi_GetNodeId r;
1150         const char *pGuid;
1151         WERROR rpc_status;
1152
1153         r.in.hNode = *hNode;
1154         r.out.pGuid = &pGuid;
1155         r.out.rpc_status = &rpc_status;
1156
1157         torture_assert_ntstatus_ok(tctx,
1158                 dcerpc_clusapi_GetNodeId_r(b, tctx, &r),
1159                 "GetNodeId failed");
1160         torture_assert_werr_ok(tctx,
1161                 r.out.result,
1162                 "GetNodeId failed");
1163
1164         return true;
1165 }
1166
1167 static bool test_GetNodeId(struct torture_context *tctx,
1168                            void *data)
1169 {
1170         struct torture_clusapi_context *t =
1171                 talloc_get_type_abort(data, struct torture_clusapi_context);
1172         struct policy_handle hNode;
1173         bool ret = true;
1174
1175         if (!test_OpenNode_int(tctx, t->p, t->NodeName, &hNode)) {
1176                 return false;
1177         }
1178
1179         ret = test_GetNodeId_int(tctx, t->p, &hNode);
1180
1181         test_CloseNode_int(tctx, t->p, &hNode);
1182
1183         return ret;
1184 }
1185
1186 static bool test_PauseNode_int(struct torture_context *tctx,
1187                                struct dcerpc_pipe *p,
1188                                struct policy_handle *hNode)
1189 {
1190         struct dcerpc_binding_handle *b = p->binding_handle;
1191         struct clusapi_PauseNode r;
1192         WERROR rpc_status;
1193
1194         r.in.hNode = *hNode;
1195         r.out.rpc_status = &rpc_status;
1196
1197         torture_assert_ntstatus_ok(tctx,
1198                 dcerpc_clusapi_PauseNode_r(b, tctx, &r),
1199                 "PauseNode failed");
1200         torture_assert_werr_ok(tctx,
1201                 r.out.result,
1202                 "PauseNode failed");
1203
1204         return true;
1205 }
1206
1207 static bool test_PauseNode(struct torture_context *tctx,
1208                            void *data)
1209 {
1210         struct torture_clusapi_context *t =
1211                 talloc_get_type_abort(data, struct torture_clusapi_context);
1212         struct policy_handle hNode;
1213         bool ret = true;
1214
1215         if (!test_OpenNode_int(tctx, t->p, t->NodeName, &hNode)) {
1216                 return false;
1217         }
1218
1219         ret = test_PauseNode_int(tctx, t->p, &hNode);
1220
1221         test_CloseNode_int(tctx, t->p, &hNode);
1222
1223         return ret;
1224 }
1225
1226 static bool test_ResumeNode_int(struct torture_context *tctx,
1227                                 struct dcerpc_pipe *p,
1228                                 struct policy_handle *hNode)
1229 {
1230         struct dcerpc_binding_handle *b = p->binding_handle;
1231         struct clusapi_ResumeNode r;
1232         WERROR rpc_status;
1233
1234         r.in.hNode = *hNode;
1235         r.out.rpc_status = &rpc_status;
1236
1237         torture_assert_ntstatus_ok(tctx,
1238                 dcerpc_clusapi_ResumeNode_r(b, tctx, &r),
1239                 "ResumeNode failed");
1240         torture_assert_werr_equal(tctx,
1241                 r.out.result,
1242                 WERR_CLUSTER_NODE_NOT_PAUSED,
1243                 "ResumeNode gave unexpected result");
1244
1245         return true;
1246 }
1247
1248 static bool test_ResumeNode(struct torture_context *tctx,
1249                             void *data)
1250 {
1251         struct torture_clusapi_context *t =
1252                 talloc_get_type_abort(data, struct torture_clusapi_context);
1253         struct policy_handle hNode;
1254         bool ret = true;
1255
1256         if (!test_OpenNode_int(tctx, t->p, t->NodeName, &hNode)) {
1257                 return false;
1258         }
1259
1260         ret = test_ResumeNode_int(tctx, t->p, &hNode);
1261
1262         test_CloseNode_int(tctx, t->p, &hNode);
1263
1264         return ret;
1265 }
1266
1267 static bool test_EvictNode_int(struct torture_context *tctx,
1268                                struct dcerpc_pipe *p,
1269                                struct policy_handle *hNode)
1270 {
1271         struct dcerpc_binding_handle *b = p->binding_handle;
1272         struct clusapi_EvictNode r;
1273         WERROR rpc_status;
1274
1275         r.in.hNode = *hNode;
1276         r.out.rpc_status = &rpc_status;
1277
1278         torture_assert_ntstatus_ok(tctx,
1279                 dcerpc_clusapi_EvictNode_r(b, tctx, &r),
1280                 "EvictNode failed");
1281         torture_assert_werr_ok(tctx,
1282                 r.out.result,
1283                 "EvictNode failed");
1284
1285         return true;
1286 }
1287
1288 static bool test_EvictNode(struct torture_context *tctx,
1289                            void *data)
1290 {
1291         struct torture_clusapi_context *t =
1292                 talloc_get_type_abort(data, struct torture_clusapi_context);
1293         struct policy_handle hNode;
1294         bool ret = true;
1295
1296         if (!test_OpenNode_int(tctx, t->p, t->NodeName, &hNode)) {
1297                 return false;
1298         }
1299
1300         ret = test_EvictNode_int(tctx, t->p, &hNode);
1301
1302         test_CloseNode_int(tctx, t->p, &hNode);
1303
1304         return ret;
1305 }
1306
1307 static bool test_one_node(struct torture_context *tctx,
1308                           struct dcerpc_pipe *p,
1309                           const char *node_name)
1310 {
1311         struct policy_handle hNode;
1312
1313         torture_assert(tctx,
1314                 test_OpenNode_int(tctx, p, node_name, &hNode),
1315                 "failed to open node");
1316         test_CloseNode_int(tctx, p, &hNode);
1317
1318         torture_assert(tctx,
1319                 test_OpenNodeEx_int(tctx, p, node_name, &hNode),
1320                 "failed to openex node");
1321
1322         torture_assert(tctx,
1323                 test_GetNodeId_int(tctx, p, &hNode),
1324                 "failed to query node id");
1325         torture_assert(tctx,
1326                 test_GetNodeState_int(tctx, p, &hNode),
1327                 "failed to query node id");
1328
1329         test_CloseNode_int(tctx, p, &hNode);
1330
1331         return true;
1332 }
1333
1334 static bool test_all_nodes(struct torture_context *tctx,
1335                            void *data)
1336 {
1337         struct torture_clusapi_context *t =
1338                 talloc_get_type_abort(data, struct torture_clusapi_context);
1339         struct dcerpc_binding_handle *b = t->p->binding_handle;
1340         struct clusapi_CreateEnum r;
1341         uint32_t dwType = CLUSTER_ENUM_NODE;
1342         struct ENUM_LIST *ReturnEnum;
1343         WERROR rpc_status;
1344         int i;
1345
1346         r.in.dwType = dwType;
1347         r.out.ReturnEnum = &ReturnEnum;
1348         r.out.rpc_status = &rpc_status;
1349
1350         torture_assert_ntstatus_ok(tctx,
1351                 dcerpc_clusapi_CreateEnum_r(b, tctx, &r),
1352                 "CreateEnum failed");
1353         torture_assert_werr_ok(tctx,
1354                 r.out.result,
1355                 "CreateEnum failed");
1356
1357         for (i=0; i < ReturnEnum->EntryCount; i++) {
1358
1359                 struct ENUM_ENTRY e = ReturnEnum->Entry[i];
1360
1361                 torture_assert_int_equal(tctx, e.Type, CLUSTER_ENUM_NODE, "type mismatch");
1362
1363                 torture_assert(tctx,
1364                         test_one_node(tctx, t->p, e.Name),
1365                         "failed to test one node");
1366         }
1367
1368         return true;
1369 }
1370
1371 static bool test_OpenGroup_int(struct torture_context *tctx,
1372                                struct dcerpc_pipe *p,
1373                                const char *lpszGroupName,
1374                                struct policy_handle *hGroup)
1375 {
1376         struct dcerpc_binding_handle *b = p->binding_handle;
1377         struct clusapi_OpenGroup r;
1378         WERROR Status;
1379         WERROR rpc_status;
1380
1381         r.in.lpszGroupName = lpszGroupName;
1382         r.out.rpc_status = &rpc_status;
1383         r.out.Status = &Status;
1384         r.out.hGroup= hGroup;
1385
1386         torture_assert_ntstatus_ok(tctx,
1387                 dcerpc_clusapi_OpenGroup_r(b, tctx, &r),
1388                 "OpenGroup failed");
1389         torture_assert_werr_ok(tctx,
1390                 *r.out.Status,
1391                 "OpenGroup failed");
1392
1393         return true;
1394 }
1395
1396 static bool test_OpenGroupEx_int(struct torture_context *tctx,
1397                                  struct dcerpc_pipe *p,
1398                                  const char *lpszGroupName,
1399                                  struct policy_handle *hGroup)
1400 {
1401         struct dcerpc_binding_handle *b = p->binding_handle;
1402         struct clusapi_OpenGroupEx r;
1403         uint32_t lpdwGrantedAccess;
1404         WERROR Status;
1405         WERROR rpc_status;
1406
1407         r.in.lpszGroupName = lpszGroupName;
1408         r.in.dwDesiredAccess = SEC_FLAG_MAXIMUM_ALLOWED;
1409         r.out.lpdwGrantedAccess = &lpdwGrantedAccess;
1410         r.out.rpc_status = &rpc_status;
1411         r.out.Status = &Status;
1412         r.out.hGroup= hGroup;
1413
1414         torture_assert_ntstatus_ok(tctx,
1415                 dcerpc_clusapi_OpenGroupEx_r(b, tctx, &r),
1416                 "OpenGroupEx failed");
1417         torture_assert_werr_ok(tctx,
1418                 *r.out.Status,
1419                 "OpenGroupEx failed");
1420
1421         return true;
1422 }
1423
1424 static bool test_CloseGroup_int(struct torture_context *tctx,
1425                                 struct dcerpc_pipe *p,
1426                                 struct policy_handle *Group)
1427 {
1428         struct dcerpc_binding_handle *b = p->binding_handle;
1429         struct clusapi_CloseGroup r;
1430
1431         r.in.Group = Group;
1432         r.out.Group = Group;
1433
1434         torture_assert_ntstatus_ok(tctx,
1435                 dcerpc_clusapi_CloseGroup_r(b, tctx, &r),
1436                 "CloseGroup failed");
1437         torture_assert_werr_ok(tctx,
1438                 r.out.result,
1439                 "CloseGroup failed");
1440         torture_assert(tctx,
1441                 ndr_policy_handle_empty(Group),
1442                 "policy_handle non empty after CloseGroup");
1443
1444         return true;
1445 }
1446
1447 static bool test_OpenGroup(struct torture_context *tctx,
1448                            void *data)
1449 {
1450         struct torture_clusapi_context *t =
1451                 talloc_get_type_abort(data, struct torture_clusapi_context);
1452         struct policy_handle hGroup;
1453
1454         if (!test_OpenGroup_int(tctx, t->p, "Cluster Group", &hGroup)) {
1455                 return false;
1456         }
1457
1458         test_CloseGroup_int(tctx, t->p, &hGroup);
1459
1460         return true;
1461 }
1462
1463 static bool test_OpenGroupEx(struct torture_context *tctx,
1464                              void *data)
1465 {
1466         struct torture_clusapi_context *t =
1467                 talloc_get_type_abort(data, struct torture_clusapi_context);
1468         struct policy_handle hGroup;
1469
1470         if (!test_OpenGroupEx_int(tctx, t->p, "Cluster Group", &hGroup)) {
1471                 return false;
1472         }
1473
1474         test_CloseGroup_int(tctx, t->p, &hGroup);
1475
1476         return true;
1477 }
1478
1479 static bool test_CloseGroup(struct torture_context *tctx,
1480                             void *data)
1481 {
1482         struct torture_clusapi_context *t =
1483                 talloc_get_type_abort(data, struct torture_clusapi_context);
1484         struct policy_handle hGroup;
1485
1486         if (!test_OpenGroup_int(tctx, t->p, "Cluster Group", &hGroup)) {
1487                 return false;
1488         }
1489
1490         return test_CloseGroup_int(tctx, t->p, &hGroup);
1491 }
1492
1493 static bool test_GetGroupState_int(struct torture_context *tctx,
1494                                    struct dcerpc_pipe *p,
1495                                    struct policy_handle *hGroup)
1496 {
1497         struct dcerpc_binding_handle *b = p->binding_handle;
1498         struct clusapi_GetGroupState r;
1499         enum clusapi_ClusterGroupState State;
1500         const char *NodeName;
1501         WERROR rpc_status;
1502
1503         r.in.hGroup = *hGroup;
1504         r.out.State = &State;
1505         r.out.NodeName = &NodeName;
1506         r.out.rpc_status = &rpc_status;
1507
1508         torture_assert_ntstatus_ok(tctx,
1509                 dcerpc_clusapi_GetGroupState_r(b, tctx, &r),
1510                 "GetGroupState failed");
1511         torture_assert_werr_ok(tctx,
1512                 r.out.result,
1513                 "GetGroupState failed");
1514
1515         return true;
1516 }
1517
1518 static bool test_GetGroupState(struct torture_context *tctx,
1519                                void *data)
1520 {
1521         struct torture_clusapi_context *t =
1522                 talloc_get_type_abort(data, struct torture_clusapi_context);
1523         struct policy_handle hGroup;
1524         bool ret = true;
1525
1526         if (!test_OpenGroup_int(tctx, t->p, "Cluster Group", &hGroup)) {
1527                 return false;
1528         }
1529
1530         ret = test_GetGroupState_int(tctx, t->p, &hGroup);
1531
1532         test_CloseGroup_int(tctx, t->p, &hGroup);
1533
1534         return ret;
1535 }
1536
1537 static bool test_GetGroupId_int(struct torture_context *tctx,
1538                                 struct dcerpc_pipe *p,
1539                                 struct policy_handle *hGroup)
1540 {
1541         struct dcerpc_binding_handle *b = p->binding_handle;
1542         struct clusapi_GetGroupId r;
1543         const char *pGuid;
1544         WERROR rpc_status;
1545
1546         r.in.hGroup = *hGroup;
1547         r.out.pGuid = &pGuid;
1548         r.out.rpc_status = &rpc_status;
1549
1550         torture_assert_ntstatus_ok(tctx,
1551                 dcerpc_clusapi_GetGroupId_r(b, tctx, &r),
1552                 "GetGroupId failed");
1553         torture_assert_werr_ok(tctx,
1554                 r.out.result,
1555                 "GetGroupId failed");
1556
1557         return true;
1558 }
1559
1560 static bool test_GetGroupId(struct torture_context *tctx,
1561                             void *data)
1562 {
1563         struct torture_clusapi_context *t =
1564                 talloc_get_type_abort(data, struct torture_clusapi_context);
1565         struct policy_handle hGroup;
1566         bool ret = true;
1567
1568         if (!test_OpenGroup_int(tctx, t->p, "Cluster Group", &hGroup)) {
1569                 return false;
1570         }
1571
1572         ret = test_GetGroupId_int(tctx, t->p, &hGroup);
1573
1574         test_CloseGroup_int(tctx, t->p, &hGroup);
1575
1576         return ret;
1577 }
1578
1579 static bool test_OnlineGroup_int(struct torture_context *tctx,
1580                                  struct dcerpc_pipe *p,
1581                                  struct policy_handle *hGroup)
1582 {
1583         struct dcerpc_binding_handle *b = p->binding_handle;
1584         struct clusapi_OnlineGroup r;
1585         WERROR rpc_status;
1586
1587         r.in.hGroup = *hGroup;
1588         r.out.rpc_status = &rpc_status;
1589
1590         torture_assert_ntstatus_ok(tctx,
1591                 dcerpc_clusapi_OnlineGroup_r(b, tctx, &r),
1592                 "OnlineGroup failed");
1593         torture_assert_werr_ok(tctx,
1594                 r.out.result,
1595                 "OnlineGroup failed");
1596
1597         return true;
1598 }
1599
1600 static bool test_OnlineGroup(struct torture_context *tctx,
1601                              void *data)
1602 {
1603         struct torture_clusapi_context *t =
1604                 talloc_get_type_abort(data, struct torture_clusapi_context);
1605         struct policy_handle hGroup;
1606         bool ret = true;
1607
1608         if (!test_OpenGroup_int(tctx, t->p, "Cluster Group", &hGroup)) {
1609                 return false;
1610         }
1611
1612         ret = test_OnlineGroup_int(tctx, t->p, &hGroup);
1613
1614         test_CloseGroup_int(tctx, t->p, &hGroup);
1615
1616         return ret;
1617 }
1618
1619 static bool test_OfflineGroup_int(struct torture_context *tctx,
1620                                   struct dcerpc_pipe *p,
1621                                   struct policy_handle *hGroup)
1622 {
1623         struct dcerpc_binding_handle *b = p->binding_handle;
1624         struct clusapi_OfflineGroup r;
1625         WERROR rpc_status;
1626
1627         r.in.hGroup = *hGroup;
1628         r.out.rpc_status = &rpc_status;
1629
1630         torture_assert_ntstatus_ok(tctx,
1631                 dcerpc_clusapi_OfflineGroup_r(b, tctx, &r),
1632                 "OfflineGroup failed");
1633         torture_assert_werr_ok(tctx,
1634                 r.out.result,
1635                 "OfflineGroup failed");
1636
1637         return true;
1638 }
1639
1640 static bool test_OfflineGroup(struct torture_context *tctx,
1641                               void *data)
1642 {
1643         struct torture_clusapi_context *t =
1644                 talloc_get_type_abort(data, struct torture_clusapi_context);
1645         struct policy_handle hGroup;
1646         bool ret = true;
1647
1648         if (!test_OpenGroup_int(tctx, t->p, "Cluster Group", &hGroup)) {
1649                 return false;
1650         }
1651
1652         ret = test_OfflineGroup_int(tctx, t->p, &hGroup);
1653
1654         test_CloseGroup_int(tctx, t->p, &hGroup);
1655
1656         return ret;
1657 }
1658
1659 static bool test_one_group(struct torture_context *tctx,
1660                            struct dcerpc_pipe *p,
1661                            const char *node_name)
1662 {
1663         struct policy_handle hGroup;
1664
1665         torture_assert(tctx,
1666                 test_OpenGroup_int(tctx, p, node_name, &hGroup),
1667                 "failed to open group");
1668         test_CloseGroup_int(tctx, p, &hGroup);
1669
1670         torture_assert(tctx,
1671                 test_OpenGroupEx_int(tctx, p, node_name, &hGroup),
1672                 "failed to openex group");
1673
1674         torture_assert(tctx,
1675                 test_GetGroupId_int(tctx, p, &hGroup),
1676                 "failed to query group id");
1677         torture_assert(tctx,
1678                 test_GetGroupState_int(tctx, p, &hGroup),
1679                 "failed to query group id");
1680
1681         test_CloseGroup_int(tctx, p, &hGroup);
1682
1683         return true;
1684 }
1685
1686 static bool test_all_groups(struct torture_context *tctx,
1687                             void *data)
1688 {
1689         struct torture_clusapi_context *t =
1690                 talloc_get_type_abort(data, struct torture_clusapi_context);
1691         struct dcerpc_binding_handle *b = t->p->binding_handle;
1692         struct clusapi_CreateEnum r;
1693         uint32_t dwType = CLUSTER_ENUM_GROUP;
1694         struct ENUM_LIST *ReturnEnum;
1695         WERROR rpc_status;
1696         int i;
1697
1698         r.in.dwType = dwType;
1699         r.out.ReturnEnum = &ReturnEnum;
1700         r.out.rpc_status = &rpc_status;
1701
1702         torture_assert_ntstatus_ok(tctx,
1703                 dcerpc_clusapi_CreateEnum_r(b, tctx, &r),
1704                 "CreateEnum failed");
1705         torture_assert_werr_ok(tctx,
1706                 r.out.result,
1707                 "CreateEnum failed");
1708
1709         for (i=0; i < ReturnEnum->EntryCount; i++) {
1710
1711                 struct ENUM_ENTRY e = ReturnEnum->Entry[i];
1712
1713                 torture_assert_int_equal(tctx, e.Type, CLUSTER_ENUM_GROUP, "type mismatch");
1714
1715                 torture_assert(tctx,
1716                         test_one_group(tctx, t->p, e.Name),
1717                         "failed to test one group");
1718         }
1719
1720         return true;
1721 }
1722
1723 static bool test_BackupClusterDatabase(struct torture_context *tctx,
1724                                        void *data)
1725 {
1726         struct torture_clusapi_context *t =
1727                 talloc_get_type_abort(data, struct torture_clusapi_context);
1728         struct dcerpc_binding_handle *b = t->p->binding_handle;
1729         struct clusapi_BackupClusterDatabase r;
1730         WERROR rpc_status;
1731
1732         r.in.lpszPathName = "c:\\cluster_backup";
1733         r.out.rpc_status = &rpc_status;
1734
1735         torture_assert_ntstatus_ok(tctx,
1736                 dcerpc_clusapi_BackupClusterDatabase_r(b, tctx, &r),
1737                 "BackupClusterDatabase failed");
1738         torture_assert_werr_equal(tctx,
1739                 r.out.result,
1740                 WERR_CALL_NOT_IMPLEMENTED,
1741                 "BackupClusterDatabase failed");
1742
1743         return true;
1744 }
1745
1746 static bool test_SetServiceAccountPassword(struct torture_context *tctx,
1747                                            void *data)
1748 {
1749         struct torture_clusapi_context *t =
1750                 talloc_get_type_abort(data, struct torture_clusapi_context);
1751         struct dcerpc_binding_handle *b = t->p->binding_handle;
1752         struct clusapi_SetServiceAccountPassword r;
1753         uint32_t SizeReturned;
1754         uint32_t ExpectedBufferSize;
1755
1756         r.in.lpszNewPassword = "P@ssw0rd!";
1757         r.in.dwFlags = IDL_CLUSTER_SET_PASSWORD_IGNORE_DOWN_NODES;
1758         r.in.ReturnStatusBufferSize = 1024;
1759         r.out.ReturnStatusBufferPtr = NULL;
1760         r.out.SizeReturned = &SizeReturned;
1761         r.out.ExpectedBufferSize = &ExpectedBufferSize;
1762
1763         torture_assert_ntstatus_ok(tctx,
1764                 dcerpc_clusapi_SetServiceAccountPassword_r(b, tctx, &r),
1765                 "SetServiceAccountPassword failed");
1766         torture_assert_werr_equal(tctx,
1767                 r.out.result,
1768                 WERR_CALL_NOT_IMPLEMENTED,
1769                 "SetServiceAccountPassword failed");
1770
1771         return true;
1772 }
1773
1774 static bool test_OpenNetwork_int(struct torture_context *tctx,
1775                                  struct dcerpc_pipe *p,
1776                                  const char *lpszNetworkName,
1777                                  struct policy_handle *hNetwork)
1778 {
1779         struct dcerpc_binding_handle *b = p->binding_handle;
1780         struct clusapi_OpenNetwork r;
1781         WERROR Status;
1782         WERROR rpc_status;
1783
1784         r.in.lpszNetworkName = lpszNetworkName;
1785         r.out.rpc_status = &rpc_status;
1786         r.out.Status = &Status;
1787         r.out.hNetwork = hNetwork ;
1788
1789         torture_assert_ntstatus_ok(tctx,
1790                 dcerpc_clusapi_OpenNetwork_r(b, tctx, &r),
1791                 "OpenNetwork failed");
1792         torture_assert_werr_ok(tctx,
1793                 *r.out.Status,
1794                 "OpenNetwork failed");
1795
1796         return true;
1797 }
1798
1799 static bool test_OpenNetworkEx_int(struct torture_context *tctx,
1800                                    struct dcerpc_pipe *p,
1801                                    const char *lpszNetworkName,
1802                                    struct policy_handle *hNetwork)
1803 {
1804         struct dcerpc_binding_handle *b = p->binding_handle;
1805         struct clusapi_OpenNetworkEx r;
1806         uint32_t lpdwGrantedAccess;
1807         WERROR Status;
1808         WERROR rpc_status;
1809
1810         r.in.lpszNetworkName = lpszNetworkName;
1811         r.in.dwDesiredAccess = SEC_FLAG_MAXIMUM_ALLOWED;
1812         r.out.lpdwGrantedAccess = &lpdwGrantedAccess;
1813         r.out.rpc_status = &rpc_status;
1814         r.out.Status = &Status;
1815         r.out.hNetwork = hNetwork ;
1816
1817         torture_assert_ntstatus_ok(tctx,
1818                 dcerpc_clusapi_OpenNetworkEx_r(b, tctx, &r),
1819                 "OpenNetworkEx failed");
1820         torture_assert_werr_ok(tctx,
1821                 *r.out.Status,
1822                 "OpenNetworkEx failed");
1823
1824         return true;
1825 }
1826
1827 static bool test_CloseNetwork_int(struct torture_context *tctx,
1828                                   struct dcerpc_pipe *p,
1829                                   struct policy_handle *Network)
1830 {
1831         struct dcerpc_binding_handle *b = p->binding_handle;
1832         struct clusapi_CloseNetwork r;
1833
1834         r.in.Network = Network;
1835         r.out.Network = Network;
1836
1837         torture_assert_ntstatus_ok(tctx,
1838                 dcerpc_clusapi_CloseNetwork_r(b, tctx, &r),
1839                 "CloseNetwork failed");
1840         torture_assert_werr_ok(tctx,
1841                 r.out.result,
1842                 "CloseNetwork failed");
1843         torture_assert(tctx,
1844                 ndr_policy_handle_empty(Network),
1845                 "policy_handle non empty after CloseNetwork");
1846
1847         return true;
1848 }
1849
1850 static bool test_OpenNetwork(struct torture_context *tctx,
1851                              void *data)
1852 {
1853         struct torture_clusapi_context *t =
1854                 talloc_get_type_abort(data, struct torture_clusapi_context);
1855         struct policy_handle hNetwork;
1856
1857         if (!test_OpenNetwork_int(tctx, t->p, "Cluster Network 1", &hNetwork)) {
1858                 return false;
1859         }
1860
1861         test_CloseNetwork_int(tctx, t->p, &hNetwork);
1862
1863         return true;
1864 }
1865
1866 static bool test_OpenNetworkEx(struct torture_context *tctx,
1867                                void *data)
1868 {
1869         struct torture_clusapi_context *t =
1870                 talloc_get_type_abort(data, struct torture_clusapi_context);
1871         struct policy_handle hNetwork;
1872
1873         if (!test_OpenNetworkEx_int(tctx, t->p, "Cluster Network 1", &hNetwork)) {
1874                 return false;
1875         }
1876
1877         test_CloseNetwork_int(tctx, t->p, &hNetwork);
1878
1879         return true;
1880 }
1881
1882 static bool test_CloseNetwork(struct torture_context *tctx,
1883                               void *data)
1884 {
1885         struct torture_clusapi_context *t =
1886                 talloc_get_type_abort(data, struct torture_clusapi_context);
1887         struct policy_handle hNetwork;
1888
1889         if (!test_OpenNetwork_int(tctx, t->p, "Cluster Network 1", &hNetwork)) {
1890                 return false;
1891         }
1892
1893         return test_CloseNetwork_int(tctx, t->p, &hNetwork);
1894 }
1895
1896 static bool test_GetNetworkState_int(struct torture_context *tctx,
1897                                      struct dcerpc_pipe *p,
1898                                      struct policy_handle *hNetwork)
1899 {
1900         struct dcerpc_binding_handle *b = p->binding_handle;
1901         struct clusapi_GetNetworkState r;
1902         enum clusapi_ClusterNetworkState State;
1903         WERROR rpc_status;
1904
1905         r.in.hNetwork = *hNetwork;
1906         r.out.State = &State;
1907         r.out.rpc_status = &rpc_status;
1908
1909         torture_assert_ntstatus_ok(tctx,
1910                 dcerpc_clusapi_GetNetworkState_r(b, tctx, &r),
1911                 "GetNetworkState failed");
1912         torture_assert_werr_ok(tctx,
1913                 r.out.result,
1914                 "GetNetworkState failed");
1915
1916         return true;
1917 }
1918
1919 static bool test_GetNetworkState(struct torture_context *tctx,
1920                                  void *data)
1921 {
1922         struct torture_clusapi_context *t =
1923                 talloc_get_type_abort(data, struct torture_clusapi_context);
1924         struct policy_handle hNetwork;
1925         bool ret = true;
1926
1927         if (!test_OpenNetwork_int(tctx, t->p, "Cluster Network 1", &hNetwork)) {
1928                 return false;
1929         }
1930
1931         ret = test_GetNetworkState_int(tctx, t->p, &hNetwork);
1932
1933         test_CloseNetwork_int(tctx, t->p, &hNetwork);
1934
1935         return ret;
1936 }
1937
1938 static bool test_GetNetworkId_int(struct torture_context *tctx,
1939                                   struct dcerpc_pipe *p,
1940                                   struct policy_handle *hNetwork)
1941 {
1942         struct dcerpc_binding_handle *b = p->binding_handle;
1943         struct clusapi_GetNetworkId r;
1944         const char *pGuid;
1945         WERROR rpc_status;
1946
1947         r.in.hNetwork = *hNetwork;
1948         r.out.pGuid = &pGuid;
1949         r.out.rpc_status = &rpc_status;
1950
1951         torture_assert_ntstatus_ok(tctx,
1952                 dcerpc_clusapi_GetNetworkId_r(b, tctx, &r),
1953                 "GetNetworkId failed");
1954         torture_assert_werr_ok(tctx,
1955                 r.out.result,
1956                 "GetNetworkId failed");
1957
1958         return true;
1959 }
1960
1961 static bool test_GetNetworkId(struct torture_context *tctx,
1962                               void *data)
1963 {
1964         struct torture_clusapi_context *t =
1965                 talloc_get_type_abort(data, struct torture_clusapi_context);
1966         struct policy_handle hNetwork;
1967         bool ret = true;
1968
1969         if (!test_OpenNetwork_int(tctx, t->p, "Cluster Network 1", &hNetwork)) {
1970                 return false;
1971         }
1972
1973         ret = test_GetNetworkId_int(tctx, t->p, &hNetwork);
1974
1975         test_CloseNetwork_int(tctx, t->p, &hNetwork);
1976
1977         return ret;
1978 }
1979
1980 static bool test_one_network(struct torture_context *tctx,
1981                              struct dcerpc_pipe *p,
1982                              const char *network_name)
1983 {
1984         struct policy_handle hNetwork;
1985
1986         torture_assert(tctx,
1987                 test_OpenNetwork_int(tctx, p, network_name, &hNetwork),
1988                 "failed to open network");
1989         test_CloseNetwork_int(tctx, p, &hNetwork);
1990
1991         torture_assert(tctx,
1992                 test_OpenNetworkEx_int(tctx, p, network_name, &hNetwork),
1993                 "failed to openex network");
1994
1995         torture_assert(tctx,
1996                 test_GetNetworkId_int(tctx, p, &hNetwork),
1997                 "failed to query network id");
1998         torture_assert(tctx,
1999                 test_GetNetworkState_int(tctx, p, &hNetwork),
2000                 "failed to query network id");
2001
2002         test_CloseNetwork_int(tctx, p, &hNetwork);
2003
2004         return true;
2005 }
2006
2007 static bool test_all_networks(struct torture_context *tctx,
2008                               void *data)
2009 {
2010         struct torture_clusapi_context *t =
2011                 talloc_get_type_abort(data, struct torture_clusapi_context);
2012         struct dcerpc_binding_handle *b = t->p->binding_handle;
2013         struct clusapi_CreateEnum r;
2014         uint32_t dwType = CLUSTER_ENUM_NETWORK;
2015         struct ENUM_LIST *ReturnEnum;
2016         WERROR rpc_status;
2017         int i;
2018
2019         r.in.dwType = dwType;
2020         r.out.ReturnEnum = &ReturnEnum;
2021         r.out.rpc_status = &rpc_status;
2022
2023         torture_assert_ntstatus_ok(tctx,
2024                 dcerpc_clusapi_CreateEnum_r(b, tctx, &r),
2025                 "CreateEnum failed");
2026         torture_assert_werr_ok(tctx,
2027                 r.out.result,
2028                 "CreateEnum failed");
2029
2030         for (i=0; i < ReturnEnum->EntryCount; i++) {
2031
2032                 struct ENUM_ENTRY e = ReturnEnum->Entry[i];
2033
2034                 torture_assert_int_equal(tctx, e.Type, CLUSTER_ENUM_NETWORK, "type mismatch");
2035
2036                 torture_assert(tctx,
2037                         test_one_network(tctx, t->p, e.Name),
2038                         "failed to test one network");
2039         }
2040
2041         return true;
2042 }
2043
2044 static bool test_OpenNetInterface_int(struct torture_context *tctx,
2045                                       struct dcerpc_pipe *p,
2046                                       const char *lpszNetInterfaceName,
2047                                       struct policy_handle *hNetInterface)
2048 {
2049         struct dcerpc_binding_handle *b = p->binding_handle;
2050         struct clusapi_OpenNetInterface r;
2051         WERROR Status;
2052         WERROR rpc_status;
2053
2054         r.in.lpszNetInterfaceName = lpszNetInterfaceName;
2055         r.out.rpc_status = &rpc_status;
2056         r.out.Status = &Status;
2057         r.out.hNetInterface = hNetInterface;
2058
2059         torture_assert_ntstatus_ok(tctx,
2060                 dcerpc_clusapi_OpenNetInterface_r(b, tctx, &r),
2061                 "OpenNetInterface failed");
2062         torture_assert_werr_ok(tctx,
2063                 *r.out.Status,
2064                 "OpenNetInterface failed");
2065
2066         return true;
2067 }
2068
2069 static bool test_OpenNetInterfaceEx_int(struct torture_context *tctx,
2070                                         struct dcerpc_pipe *p,
2071                                         const char *lpszNetInterfaceName,
2072                                         struct policy_handle *hNetInterface)
2073 {
2074         struct dcerpc_binding_handle *b = p->binding_handle;
2075         struct clusapi_OpenNetInterfaceEx r;
2076         uint32_t lpdwGrantedAccess;
2077         WERROR Status;
2078         WERROR rpc_status;
2079
2080         r.in.lpszNetInterfaceName = lpszNetInterfaceName;
2081         r.in.dwDesiredAccess = SEC_FLAG_MAXIMUM_ALLOWED;
2082         r.out.lpdwGrantedAccess = &lpdwGrantedAccess;
2083         r.out.rpc_status = &rpc_status;
2084         r.out.Status = &Status;
2085         r.out.hNetInterface = hNetInterface;
2086
2087         torture_assert_ntstatus_ok(tctx,
2088                 dcerpc_clusapi_OpenNetInterfaceEx_r(b, tctx, &r),
2089                 "OpenNetInterfaceEx failed");
2090         torture_assert_werr_ok(tctx,
2091                 *r.out.Status,
2092                 "OpenNetInterfaceEx failed");
2093
2094         return true;
2095 }
2096
2097 static bool test_CloseNetInterface_int(struct torture_context *tctx,
2098                                        struct dcerpc_pipe *p,
2099                                        struct policy_handle *NetInterface)
2100 {
2101         struct dcerpc_binding_handle *b = p->binding_handle;
2102         struct clusapi_CloseNetInterface r;
2103
2104         r.in.NetInterface = NetInterface;
2105         r.out.NetInterface = NetInterface;
2106
2107         torture_assert_ntstatus_ok(tctx,
2108                 dcerpc_clusapi_CloseNetInterface_r(b, tctx, &r),
2109                 "CloseNetInterface failed");
2110         torture_assert_werr_ok(tctx,
2111                 r.out.result,
2112                 "CloseNetInterface failed");
2113         torture_assert(tctx,
2114                 ndr_policy_handle_empty(NetInterface),
2115                 "policy_handle non empty after CloseNetInterface");
2116
2117         return true;
2118 }
2119
2120 static bool test_OpenNetInterface(struct torture_context *tctx,
2121                                   void *data)
2122 {
2123         struct torture_clusapi_context *t =
2124                 talloc_get_type_abort(data, struct torture_clusapi_context);
2125         struct policy_handle hNetInterface;
2126
2127         if (!test_OpenNetInterface_int(tctx, t->p, "node1 - Ethernet", &hNetInterface)) {
2128                 return false;
2129         }
2130
2131         test_CloseNetInterface_int(tctx, t->p, &hNetInterface);
2132
2133         return true;
2134 }
2135
2136 static bool test_OpenNetInterfaceEx(struct torture_context *tctx,
2137                                     void *data)
2138 {
2139         struct torture_clusapi_context *t =
2140                 talloc_get_type_abort(data, struct torture_clusapi_context);
2141         struct policy_handle hNetInterface;
2142
2143         if (!test_OpenNetInterfaceEx_int(tctx, t->p, "node1 - Ethernet", &hNetInterface)) {
2144                 return false;
2145         }
2146
2147         test_CloseNetInterface_int(tctx, t->p, &hNetInterface);
2148
2149         return true;
2150 }
2151
2152 static bool test_CloseNetInterface(struct torture_context *tctx,
2153                                    void *data)
2154 {
2155         struct torture_clusapi_context *t =
2156                 talloc_get_type_abort(data, struct torture_clusapi_context);
2157         struct policy_handle hNetInterface;
2158
2159         if (!test_OpenNetInterface_int(tctx, t->p, "node1 - Ethernet", &hNetInterface)) {
2160                 return false;
2161         }
2162
2163         return test_CloseNetInterface_int(tctx, t->p, &hNetInterface);
2164 }
2165
2166 static bool test_GetNetInterfaceState_int(struct torture_context *tctx,
2167                                           struct dcerpc_pipe *p,
2168                                           struct policy_handle *hNetInterface)
2169 {
2170         struct dcerpc_binding_handle *b = p->binding_handle;
2171         struct clusapi_GetNetInterfaceState r;
2172         enum clusapi_ClusterNetInterfaceState State;
2173         WERROR rpc_status;
2174
2175         r.in.hNetInterface = *hNetInterface;
2176         r.out.State = &State;
2177         r.out.rpc_status = &rpc_status;
2178
2179         torture_assert_ntstatus_ok(tctx,
2180                 dcerpc_clusapi_GetNetInterfaceState_r(b, tctx, &r),
2181                 "GetNetInterfaceState failed");
2182         torture_assert_werr_ok(tctx,
2183                 r.out.result,
2184                 "GetNetInterfaceState failed");
2185
2186         return true;
2187 }
2188
2189 static bool test_GetNetInterfaceState(struct torture_context *tctx,
2190                                       void *data)
2191 {
2192         struct torture_clusapi_context *t =
2193                 talloc_get_type_abort(data, struct torture_clusapi_context);
2194         struct policy_handle hNetInterface;
2195         bool ret = true;
2196
2197         if (!test_OpenNetInterface_int(tctx, t->p, "node1 - Ethernet", &hNetInterface)) {
2198                 return false;
2199         }
2200
2201         ret = test_GetNetInterfaceState_int(tctx, t->p, &hNetInterface);
2202
2203         test_CloseNetInterface_int(tctx, t->p, &hNetInterface);
2204
2205         return ret;
2206 }
2207
2208 static bool test_GetNetInterfaceId_int(struct torture_context *tctx,
2209                                        struct dcerpc_pipe *p,
2210                                        struct policy_handle *hNetInterface)
2211 {
2212         struct dcerpc_binding_handle *b = p->binding_handle;
2213         struct clusapi_GetNetInterfaceId r;
2214         const char *pGuid;
2215         WERROR rpc_status;
2216
2217         r.in.hNetInterface = *hNetInterface;
2218         r.out.pGuid = &pGuid;
2219         r.out.rpc_status = &rpc_status;
2220
2221         torture_assert_ntstatus_ok(tctx,
2222                 dcerpc_clusapi_GetNetInterfaceId_r(b, tctx, &r),
2223                 "GetNetInterfaceId failed");
2224         torture_assert_werr_ok(tctx,
2225                 r.out.result,
2226                 "GetNetInterfaceId failed");
2227
2228         return true;
2229 }
2230
2231 static bool test_GetNetInterfaceId(struct torture_context *tctx,
2232                                    void *data)
2233 {
2234         struct torture_clusapi_context *t =
2235                 talloc_get_type_abort(data, struct torture_clusapi_context);
2236         struct policy_handle hNetInterface;
2237         bool ret = true;
2238
2239         if (!test_OpenNetInterface_int(tctx, t->p, "node1 - Ethernet", &hNetInterface)) {
2240                 return false;
2241         }
2242
2243         ret = test_GetNetInterfaceId_int(tctx, t->p, &hNetInterface);
2244
2245         test_CloseNetInterface_int(tctx, t->p, &hNetInterface);
2246
2247         return ret;
2248 }
2249
2250 static bool test_one_netinterface(struct torture_context *tctx,
2251                                   struct dcerpc_pipe *p,
2252                                   const char *netinterface_name)
2253 {
2254         struct policy_handle hNetInterface;
2255
2256         torture_assert(tctx,
2257                 test_OpenNetInterface_int(tctx, p, netinterface_name, &hNetInterface),
2258                 "failed to open netinterface");
2259         test_CloseNetInterface_int(tctx, p, &hNetInterface);
2260
2261         torture_assert(tctx,
2262                 test_OpenNetInterfaceEx_int(tctx, p, netinterface_name, &hNetInterface),
2263                 "failed to openex netinterface");
2264
2265         torture_assert(tctx,
2266                 test_GetNetInterfaceId_int(tctx, p, &hNetInterface),
2267                 "failed to query netinterface id");
2268         torture_assert(tctx,
2269                 test_GetNetInterfaceState_int(tctx, p, &hNetInterface),
2270                 "failed to query netinterface id");
2271
2272         test_CloseNetInterface_int(tctx, p, &hNetInterface);
2273
2274         return true;
2275 }
2276
2277 static bool test_all_netinterfaces(struct torture_context *tctx,
2278                                    void *data)
2279 {
2280         struct torture_clusapi_context *t =
2281                 talloc_get_type_abort(data, struct torture_clusapi_context);
2282         struct dcerpc_binding_handle *b = t->p->binding_handle;
2283         struct clusapi_CreateEnum r;
2284         uint32_t dwType = CLUSTER_ENUM_NETINTERFACE;
2285         struct ENUM_LIST *ReturnEnum;
2286         WERROR rpc_status;
2287         int i;
2288
2289         r.in.dwType = dwType;
2290         r.out.ReturnEnum = &ReturnEnum;
2291         r.out.rpc_status = &rpc_status;
2292
2293         torture_assert_ntstatus_ok(tctx,
2294                 dcerpc_clusapi_CreateEnum_r(b, tctx, &r),
2295                 "CreateEnum failed");
2296         torture_assert_werr_ok(tctx,
2297                 r.out.result,
2298                 "CreateEnum failed");
2299
2300         for (i=0; i < ReturnEnum->EntryCount; i++) {
2301
2302                 struct ENUM_ENTRY e = ReturnEnum->Entry[i];
2303
2304                 torture_assert_int_equal(tctx, e.Type, CLUSTER_ENUM_NETINTERFACE, "type mismatch");
2305
2306                 torture_assert(tctx,
2307                         test_one_netinterface(tctx, t->p, e.Name),
2308                         "failed to test one netinterface");
2309         }
2310
2311         return true;
2312 }
2313
2314 static bool test_CloseKey_int(struct torture_context *tctx,
2315                               struct dcerpc_pipe *p,
2316                               struct policy_handle *pKey)
2317 {
2318         struct dcerpc_binding_handle *b = p->binding_handle;
2319         struct clusapi_CloseKey r;
2320
2321         r.in.pKey = pKey;
2322         r.out.pKey = pKey;
2323
2324         torture_assert_ntstatus_ok(tctx,
2325                 dcerpc_clusapi_CloseKey_r(b, tctx, &r),
2326                 "CloseKey failed");
2327         torture_assert_werr_ok(tctx,
2328                 r.out.result,
2329                 "CloseKey failed");
2330         torture_assert(tctx,
2331                 ndr_policy_handle_empty(pKey),
2332                 "policy_handle non empty after CloseKey");
2333
2334         return true;
2335 }
2336
2337 static bool test_GetRootKey_int(struct torture_context *tctx,
2338                                 struct dcerpc_pipe *p,
2339                                 struct policy_handle *phKey)
2340 {
2341         struct dcerpc_binding_handle *b = p->binding_handle;
2342         struct clusapi_GetRootKey r;
2343         WERROR Status;
2344         WERROR rpc_status;
2345
2346         r.in.samDesired = SEC_FLAG_MAXIMUM_ALLOWED;
2347         r.out.Status = &Status;
2348         r.out.rpc_status = &rpc_status;
2349         r.out.phKey = phKey;
2350
2351         torture_assert_ntstatus_ok(tctx,
2352                 dcerpc_clusapi_GetRootKey_r(b, tctx, &r),
2353                 "GetRootKey failed");
2354         torture_assert_werr_ok(tctx,
2355                 *r.out.Status,
2356                 "GetRootKey failed");
2357
2358         return true;
2359 }
2360
2361 static bool test_EnumKey_int(struct torture_context *tctx,
2362                              struct dcerpc_pipe *p,
2363                              struct policy_handle *hKey)
2364 {
2365         struct dcerpc_binding_handle *b = p->binding_handle;
2366         struct clusapi_EnumKey r;
2367         const char *KeyName;
2368         NTTIME lpftLastWriteTime;
2369         WERROR rpc_status;
2370
2371         r.in.hKey = *hKey;
2372         r.in.dwIndex = 0;
2373         r.out.KeyName = &KeyName;
2374         r.out.lpftLastWriteTime = &lpftLastWriteTime;
2375         r.out.rpc_status = &rpc_status;
2376
2377         torture_assert_ntstatus_ok(tctx,
2378                 dcerpc_clusapi_EnumKey_r(b, tctx, &r),
2379                 "EnumKey failed");
2380         torture_assert_werr_ok(tctx,
2381                 r.out.result,
2382                 "EnumKey failed");
2383
2384         return true;
2385 }
2386
2387 static bool test_OpenKey_int(struct torture_context *tctx,
2388                              struct dcerpc_pipe *p,
2389                              struct policy_handle *hKey,
2390                              const char *lpSubKey,
2391                              struct policy_handle *phKey)
2392 {
2393         struct dcerpc_binding_handle *b = p->binding_handle;
2394         struct clusapi_OpenKey r;
2395         WERROR Status;
2396         WERROR rpc_status;
2397
2398         r.in.hKey = *hKey;
2399         r.in.lpSubKey = lpSubKey;
2400         r.in.samDesired = SEC_FLAG_MAXIMUM_ALLOWED;
2401         r.out.Status = &Status;
2402         r.out.rpc_status = &rpc_status;
2403         r.out.phKey = phKey;
2404
2405         torture_assert_ntstatus_ok(tctx,
2406                 dcerpc_clusapi_OpenKey_r(b, tctx, &r),
2407                 "OpenKey failed");
2408         torture_assert_werr_ok(tctx,
2409                 *r.out.Status,
2410                 "OpenKey failed");
2411
2412         return true;
2413 }
2414
2415 static bool test_EnumValue_int(struct torture_context *tctx,
2416                                struct dcerpc_pipe *p,
2417                                struct policy_handle *hKey)
2418 {
2419         struct dcerpc_binding_handle *b = p->binding_handle;
2420         struct clusapi_EnumValue r;
2421         const char *lpValueName;
2422         uint32_t lpType;
2423         uint32_t TotalSize;
2424         WERROR rpc_status;
2425         int i = 0;
2426
2427         do {
2428                 uint32_t lpcbData = 1024;
2429
2430                 r.in.hKey = *hKey;
2431                 r.in.dwIndex = i++;
2432                 r.in.lpcbData = &lpcbData;
2433                 r.out.lpValueName = &lpValueName;
2434                 r.out.lpType = &lpType;
2435                 r.out.lpData = talloc_array(tctx, uint8_t, lpcbData);
2436                 r.out.TotalSize = &TotalSize;
2437                 r.out.rpc_status = &rpc_status;
2438                 r.out.lpcbData = &lpcbData;
2439
2440                 torture_assert_ntstatus_ok(tctx,
2441                         dcerpc_clusapi_EnumValue_r(b, tctx, &r),
2442                         "EnumValue failed");
2443
2444         } while (W_ERROR_IS_OK(r.out.result));
2445
2446         torture_assert_werr_equal(tctx,
2447                 r.out.result,
2448                 WERR_NO_MORE_ITEMS,
2449                 "EnumValue failed");
2450
2451         return true;
2452 }
2453
2454 static bool test_QueryInfoKey_int(struct torture_context *tctx,
2455                                   struct dcerpc_pipe *p,
2456                                   struct policy_handle *hKey)
2457 {
2458         struct dcerpc_binding_handle *b = p->binding_handle;
2459         struct clusapi_QueryInfoKey r;
2460         uint32_t lpcSubKeys;
2461         uint32_t lpcbMaxSubKeyLen;
2462         uint32_t lpcValues;
2463         uint32_t lpcbMaxValueNameLen;
2464         uint32_t lpcbMaxValueLen;
2465         uint32_t lpcbSecurityDescriptor;
2466         NTTIME lpftLastWriteTime;
2467         WERROR rpc_status;
2468
2469         r.in.hKey = *hKey;
2470         r.out.lpcSubKeys = &lpcSubKeys;
2471         r.out.lpcbMaxSubKeyLen = &lpcbMaxSubKeyLen;
2472         r.out.lpcValues = &lpcValues;
2473         r.out.lpcbMaxValueNameLen = &lpcbMaxValueNameLen;
2474         r.out.lpcbMaxValueLen = &lpcbMaxValueLen;
2475         r.out.lpcbSecurityDescriptor = &lpcbSecurityDescriptor;
2476         r.out.lpftLastWriteTime = &lpftLastWriteTime;
2477         r.out.rpc_status = &rpc_status;
2478
2479         torture_assert_ntstatus_ok(tctx,
2480                 dcerpc_clusapi_QueryInfoKey_r(b, tctx, &r),
2481                 "QueryInfoKey failed");
2482         torture_assert_werr_ok(tctx,
2483                 r.out.result,
2484                 "QueryInfoKey failed");
2485
2486         return true;
2487 }
2488
2489 static bool test_GetKeySecurity_int(struct torture_context *tctx,
2490                                     struct dcerpc_pipe *p,
2491                                     struct policy_handle *hKey)
2492 {
2493         struct dcerpc_binding_handle *b = p->binding_handle;
2494         struct clusapi_GetKeySecurity r;
2495         uint32_t SecurityInformation = SECINFO_DACL | SECINFO_OWNER | SECINFO_GROUP;
2496         struct RPC_SECURITY_DESCRIPTOR pRpcSecurityDescriptor;
2497         WERROR rpc_status;
2498
2499         ZERO_STRUCT(pRpcSecurityDescriptor);
2500
2501         r.in.hKey = *hKey;
2502         r.in.SecurityInformation = SecurityInformation;
2503         r.in.pRpcSecurityDescriptor = &pRpcSecurityDescriptor;
2504         r.out.rpc_status = &rpc_status;
2505         r.out.pRpcSecurityDescriptor = &pRpcSecurityDescriptor;
2506
2507         torture_assert_ntstatus_ok(tctx,
2508                 dcerpc_clusapi_GetKeySecurity_r(b, tctx, &r),
2509                 "GetKeySecurity failed");
2510
2511         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
2512                 pRpcSecurityDescriptor.lpSecurityDescriptor = talloc_array(tctx,
2513                 uint8_t, pRpcSecurityDescriptor.cbInSecurityDescriptor);
2514
2515                 torture_assert_ntstatus_ok(tctx,
2516                         dcerpc_clusapi_GetKeySecurity_r(b, tctx, &r),
2517                         "GetKeySecurity failed");
2518         }
2519
2520         torture_assert_werr_ok(tctx,
2521                 r.out.result,
2522                 "GetKeySecurity failed");
2523
2524         return true;
2525 }
2526
2527 static bool test_GetRootKey(struct torture_context *tctx,
2528                             void *data)
2529 {
2530         struct torture_clusapi_context *t =
2531                 talloc_get_type_abort(data, struct torture_clusapi_context);
2532         struct policy_handle hKey;
2533
2534         if (!test_GetRootKey_int(tctx, t->p, &hKey)) {
2535                 return false;
2536         }
2537
2538         test_CloseKey_int(tctx, t->p, &hKey);
2539
2540         return true;
2541 }
2542
2543 static bool test_CloseKey(struct torture_context *tctx,
2544                           void *data)
2545 {
2546         struct torture_clusapi_context *t =
2547                 talloc_get_type_abort(data, struct torture_clusapi_context);
2548         struct policy_handle hKey;
2549
2550         if (!test_GetRootKey_int(tctx, t->p, &hKey)) {
2551                 return false;
2552         }
2553
2554         return test_CloseKey_int(tctx, t->p, &hKey);
2555 }
2556
2557 static bool test_EnumKey(struct torture_context *tctx,
2558                          void *data)
2559 {
2560         struct torture_clusapi_context *t =
2561                 talloc_get_type_abort(data, struct torture_clusapi_context);
2562         struct policy_handle hKey;
2563         bool ret = true;
2564
2565         if (!test_GetRootKey_int(tctx, t->p, &hKey)) {
2566                 return false;
2567         }
2568
2569         ret = test_EnumKey_int(tctx, t->p, &hKey);
2570
2571         test_CloseKey_int(tctx, t->p, &hKey);
2572
2573         return ret;
2574 }
2575
2576 static bool test_one_key(struct torture_context *tctx,
2577                          struct dcerpc_pipe *p,
2578                          struct policy_handle *hKey,
2579                          const char *KeyName)
2580 {
2581         struct policy_handle phKey;
2582
2583         torture_assert(tctx,
2584                 test_OpenKey_int(tctx, p, hKey, KeyName, &phKey),
2585                 "failed to open key");
2586
2587         torture_assert(tctx,
2588                 test_QueryInfoKey_int(tctx, p, &phKey),
2589                 "failed to enum values");
2590         torture_assert(tctx,
2591                 test_GetKeySecurity_int(tctx, p, &phKey),
2592                 "failed to get key security");
2593
2594         torture_assert(tctx,
2595                 test_EnumValue_int(tctx, p, &phKey),
2596                 "failed to enum values");
2597
2598         torture_assert(tctx,
2599                 test_CloseKey_int(tctx, p, &phKey),
2600                 "failed to close key");
2601
2602         return true;
2603 }
2604
2605 static bool test_all_keys(struct torture_context *tctx,
2606                           void *data)
2607 {
2608         struct torture_clusapi_context *t =
2609                 talloc_get_type_abort(data, struct torture_clusapi_context);
2610         struct dcerpc_binding_handle *b = t->p->binding_handle;
2611         struct policy_handle hKey;
2612         struct clusapi_EnumKey r;
2613         const char *KeyName;
2614         NTTIME lpftLastWriteTime;
2615         WERROR rpc_status;
2616         int i = 0;
2617
2618         if (!test_GetRootKey_int(tctx, t->p, &hKey)) {
2619                 return false;
2620         }
2621
2622         do {
2623                 r.in.hKey = hKey;
2624                 r.in.dwIndex = i++;
2625                 r.out.KeyName = &KeyName;
2626                 r.out.lpftLastWriteTime = &lpftLastWriteTime;
2627                 r.out.rpc_status = &rpc_status;
2628
2629                 torture_assert_ntstatus_ok(tctx,
2630                         dcerpc_clusapi_EnumKey_r(b, tctx, &r),
2631                         "EnumKey failed");
2632
2633                 if (W_ERROR_IS_OK(r.out.result)) {
2634                         torture_assert(tctx,
2635                                 test_one_key(tctx, t->p, &hKey, KeyName),
2636                                 "failed to test one key");
2637                 }
2638
2639         } while (W_ERROR_IS_OK(r.out.result));
2640
2641         torture_assert_werr_equal(tctx,
2642                 r.out.result,
2643                 WERR_NO_MORE_ITEMS,
2644                 "EnumKey failed");
2645
2646         test_CloseKey_int(tctx, t->p, &hKey);
2647
2648         return true;
2649 }
2650
2651 static bool torture_rpc_clusapi_setup_common(struct torture_context *tctx,
2652                                              struct torture_clusapi_context *t)
2653 {
2654         struct dcerpc_binding_handle *b;
2655
2656         torture_assert_ntstatus_ok(tctx,
2657                 torture_rpc_connection(tctx, &t->p, &ndr_table_clusapi),
2658                 "Error connecting to server");
2659
2660         {
2661                 struct clusapi_GetClusterName r;
2662
2663                 b = t->p->binding_handle;
2664
2665                 r.out.ClusterName = &t->ClusterName;
2666                 r.out.NodeName = &t->NodeName;
2667
2668                 torture_assert_ntstatus_ok(tctx,
2669                         dcerpc_clusapi_GetClusterName_r(b, tctx, &r),
2670                         "GetClusterName failed");
2671                 torture_assert_werr_ok(tctx,
2672                         r.out.result,
2673                         "GetClusterName failed");
2674         }
2675
2676         return true;
2677 }
2678
2679 static bool torture_rpc_clusapi_setup(struct torture_context *tctx,
2680                                       void **data)
2681 {
2682         struct torture_clusapi_context *t;
2683
2684         *data = t = talloc_zero(tctx, struct torture_clusapi_context);
2685
2686         return torture_rpc_clusapi_setup_common(tctx, t);
2687 }
2688
2689 static bool torture_rpc_clusapi_teardown(struct torture_context *tctx,
2690                                          void *data)
2691 {
2692         talloc_free(data);
2693
2694         return true;
2695 }
2696
2697 void torture_tcase_cluster(struct torture_tcase *tcase)
2698 {
2699         torture_tcase_add_simple_test(tcase, "OpenCluster",
2700                                       test_OpenCluster);
2701         torture_tcase_add_simple_test(tcase, "OpenClusterEx",
2702                                       test_OpenClusterEx);
2703         torture_tcase_add_simple_test(tcase, "CloseCluster",
2704                                       test_CloseCluster);
2705         torture_tcase_add_simple_test(tcase, "SetClusterName",
2706                                       test_SetClusterName);
2707         torture_tcase_add_simple_test(tcase, "GetClusterName",
2708                                       test_GetClusterName);
2709         torture_tcase_add_simple_test(tcase, "GetClusterVersion",
2710                                       test_GetClusterVersion);
2711         torture_tcase_add_simple_test(tcase, "CreateEnum",
2712                                       test_CreateEnum);
2713         torture_tcase_add_simple_test(tcase, "GetClusterVersion2",
2714                                       test_GetClusterVersion2);
2715         torture_tcase_add_simple_test(tcase, "BackupClusterDatabase",
2716                                       test_BackupClusterDatabase);
2717         torture_tcase_add_simple_test(tcase, "SetServiceAccountPassword",
2718                                       test_SetServiceAccountPassword);
2719 }
2720
2721 void torture_tcase_resource(struct torture_tcase *tcase)
2722 {
2723         struct torture_test *test;
2724
2725         torture_tcase_add_simple_test(tcase, "GetQuorumResource",
2726                                       test_GetQuorumResource);
2727         torture_tcase_add_simple_test(tcase, "SetQuorumResource",
2728                                       test_SetQuorumResource);
2729         torture_tcase_add_simple_test(tcase, "OpenResource",
2730                                       test_OpenResource);
2731         torture_tcase_add_simple_test(tcase, "OpenResourceEx",
2732                                       test_OpenResourceEx);
2733         torture_tcase_add_simple_test(tcase, "CloseResource",
2734                                       test_CloseResource);
2735         torture_tcase_add_simple_test(tcase, "CreateResource",
2736                                       test_CreateResource);
2737         torture_tcase_add_simple_test(tcase, "DeleteResource",
2738                                       test_DeleteResource);
2739         torture_tcase_add_simple_test(tcase, "SetResourceName",
2740                                       test_SetResourceName);
2741         torture_tcase_add_simple_test(tcase, "GetResourceState",
2742                                       test_GetResourceState);
2743         torture_tcase_add_simple_test(tcase, "GetResourceId",
2744                                       test_GetResourceId);
2745         torture_tcase_add_simple_test(tcase, "GetResourceType",
2746                                       test_GetResourceType);
2747         torture_tcase_add_simple_test(tcase, "CreateResEnum",
2748                                       test_CreateResEnum);
2749         test = torture_tcase_add_simple_test(tcase, "FailResource",
2750                                       test_FailResource);
2751         test->dangerous = true;
2752         torture_tcase_add_simple_test(tcase, "OnlineResource",
2753                                       test_OnlineResource);
2754         test = torture_tcase_add_simple_test(tcase, "OfflineResource",
2755                                       test_OfflineResource);
2756         test->dangerous = true;
2757         torture_tcase_add_simple_test(tcase, "all_resources",
2758                                       test_all_resources);
2759 }
2760
2761 void torture_tcase_node(struct torture_tcase *tcase)
2762 {
2763         struct torture_test *test;
2764
2765         torture_tcase_add_simple_test(tcase, "OpenNode",
2766                                       test_OpenNode);
2767         torture_tcase_add_simple_test(tcase, "OpenNodeEx",
2768                                       test_OpenNodeEx);
2769         torture_tcase_add_simple_test(tcase, "CloseNode",
2770                                       test_CloseNode);
2771         torture_tcase_add_simple_test(tcase, "GetNodeState",
2772                                       test_GetNodeState);
2773         torture_tcase_add_simple_test(tcase, "GetNodeId",
2774                                       test_GetNodeId);
2775         test = torture_tcase_add_simple_test(tcase, "PauseNode",
2776                                              test_PauseNode);
2777         test->dangerous = true;
2778         torture_tcase_add_simple_test(tcase, "ResumeNode",
2779                                       test_ResumeNode);
2780         test = torture_tcase_add_simple_test(tcase, "EvictNode",
2781                                              test_EvictNode);
2782         test->dangerous = true;
2783         torture_tcase_add_simple_test(tcase, "all_nodes",
2784                                       test_all_nodes);
2785 }
2786
2787 void torture_tcase_group(struct torture_tcase *tcase)
2788 {
2789         struct torture_test *test;
2790
2791         torture_tcase_add_simple_test(tcase, "OpenGroup",
2792                                       test_OpenGroup);
2793         torture_tcase_add_simple_test(tcase, "OpenGroupEx",
2794                                       test_OpenGroupEx);
2795         torture_tcase_add_simple_test(tcase, "CloseGroup",
2796                                       test_CloseGroup);
2797         torture_tcase_add_simple_test(tcase, "GetGroupState",
2798                                       test_GetGroupState);
2799         torture_tcase_add_simple_test(tcase, "GetGroupId",
2800                                       test_GetGroupId);
2801         torture_tcase_add_simple_test(tcase, "OnlineGroup",
2802                                       test_OnlineGroup);
2803         test = torture_tcase_add_simple_test(tcase, "OfflineGroup",
2804                                       test_OfflineGroup);
2805         test->dangerous = true;
2806         torture_tcase_add_simple_test(tcase, "all_groups",
2807                                       test_all_groups);
2808 }
2809
2810 void torture_tcase_network(struct torture_tcase *tcase)
2811 {
2812         torture_tcase_add_simple_test(tcase, "OpenNetwork",
2813                                       test_OpenNetwork);
2814         torture_tcase_add_simple_test(tcase, "OpenNetworkEx",
2815                                       test_OpenNetworkEx);
2816         torture_tcase_add_simple_test(tcase, "CloseNetwork",
2817                                       test_CloseNetwork);
2818         torture_tcase_add_simple_test(tcase, "GetNetworkState",
2819                                       test_GetNetworkState);
2820         torture_tcase_add_simple_test(tcase, "GetNetworkId",
2821                                       test_GetNetworkId);
2822         torture_tcase_add_simple_test(tcase, "all_networks",
2823                                       test_all_networks);
2824 }
2825
2826 void torture_tcase_netinterface(struct torture_tcase *tcase)
2827 {
2828         torture_tcase_add_simple_test(tcase, "OpenNetInterface",
2829                                       test_OpenNetInterface);
2830         torture_tcase_add_simple_test(tcase, "OpenNetInterfaceEx",
2831                                       test_OpenNetInterfaceEx);
2832         torture_tcase_add_simple_test(tcase, "CloseNetInterface",
2833                                       test_CloseNetInterface);
2834         torture_tcase_add_simple_test(tcase, "GetNetInterfaceState",
2835                                       test_GetNetInterfaceState);
2836         torture_tcase_add_simple_test(tcase, "GetNetInterfaceId",
2837                                       test_GetNetInterfaceId);
2838         torture_tcase_add_simple_test(tcase, "all_netinterfaces",
2839                                       test_all_netinterfaces);
2840 }
2841
2842 void torture_tcase_registry(struct torture_tcase *tcase)
2843 {
2844         torture_tcase_add_simple_test(tcase, "GetRootKey",
2845                                       test_GetRootKey);
2846         torture_tcase_add_simple_test(tcase, "CloseKey",
2847                                       test_CloseKey);
2848         torture_tcase_add_simple_test(tcase, "EnumKey",
2849                                       test_EnumKey);
2850         torture_tcase_add_simple_test(tcase, "all_keys",
2851                                       test_all_keys);
2852 }
2853
2854 struct torture_suite *torture_rpc_clusapi(TALLOC_CTX *mem_ctx)
2855 {
2856         struct torture_tcase *tcase;
2857         struct torture_suite *suite = torture_suite_create(mem_ctx, "clusapi");
2858
2859         tcase = torture_suite_add_tcase(suite, "cluster");
2860
2861         torture_tcase_set_fixture(tcase,
2862                                   torture_rpc_clusapi_setup,
2863                                   torture_rpc_clusapi_teardown);
2864
2865         torture_tcase_cluster(tcase);
2866
2867         tcase = torture_suite_add_tcase(suite, "resource");
2868
2869         torture_tcase_set_fixture(tcase,
2870                                   torture_rpc_clusapi_setup,
2871                                   torture_rpc_clusapi_teardown);
2872
2873         torture_tcase_resource(tcase);
2874
2875         tcase = torture_suite_add_tcase(suite, "node");
2876
2877         torture_tcase_set_fixture(tcase,
2878                                   torture_rpc_clusapi_setup,
2879                                   torture_rpc_clusapi_teardown);
2880
2881         torture_tcase_node(tcase);
2882
2883         tcase = torture_suite_add_tcase(suite, "group");
2884
2885         torture_tcase_set_fixture(tcase,
2886                                   torture_rpc_clusapi_setup,
2887                                   torture_rpc_clusapi_teardown);
2888
2889         torture_tcase_group(tcase);
2890
2891         tcase = torture_suite_add_tcase(suite, "network");
2892
2893         torture_tcase_set_fixture(tcase,
2894                                   torture_rpc_clusapi_setup,
2895                                   torture_rpc_clusapi_teardown);
2896
2897         torture_tcase_network(tcase);
2898
2899         tcase = torture_suite_add_tcase(suite, "netinterface");
2900
2901         torture_tcase_set_fixture(tcase,
2902                                   torture_rpc_clusapi_setup,
2903                                   torture_rpc_clusapi_teardown);
2904
2905         torture_tcase_netinterface(tcase);
2906
2907         tcase = torture_suite_add_tcase(suite, "registry");
2908
2909         torture_tcase_set_fixture(tcase,
2910                                   torture_rpc_clusapi_setup,
2911                                   torture_rpc_clusapi_teardown);
2912
2913         torture_tcase_registry(tcase);
2914
2915         return suite;
2916 }