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