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_PauseNode_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_PauseNode r;
1432         WERROR rpc_status;
1433
1434         r.in.hNode = *hNode;
1435         r.out.rpc_status = &rpc_status;
1436
1437         torture_assert_ntstatus_ok(tctx,
1438                 dcerpc_clusapi_PauseNode_r(b, tctx, &r),
1439                 "PauseNode failed");
1440         torture_assert_werr_ok(tctx,
1441                 r.out.result,
1442                 "PauseNode failed");
1443
1444         return true;
1445 }
1446
1447 static bool test_PauseNode(struct torture_context *tctx,
1448                            void *data)
1449 {
1450         struct torture_clusapi_context *t =
1451                 talloc_get_type_abort(data, struct torture_clusapi_context);
1452         struct policy_handle hNode;
1453         bool ret = true;
1454
1455         if (!test_OpenNode_int(tctx, t->p, t->NodeName, &hNode)) {
1456                 return false;
1457         }
1458
1459         ret = test_PauseNode_int(tctx, t->p, &hNode);
1460
1461         test_CloseNode_int(tctx, t->p, &hNode);
1462
1463         return ret;
1464 }
1465
1466 static bool test_ResumeNode_int(struct torture_context *tctx,
1467                                 struct dcerpc_pipe *p,
1468                                 struct policy_handle *hNode)
1469 {
1470         struct dcerpc_binding_handle *b = p->binding_handle;
1471         struct clusapi_ResumeNode r;
1472         WERROR rpc_status;
1473
1474         r.in.hNode = *hNode;
1475         r.out.rpc_status = &rpc_status;
1476
1477         torture_assert_ntstatus_ok(tctx,
1478                 dcerpc_clusapi_ResumeNode_r(b, tctx, &r),
1479                 "ResumeNode failed");
1480         torture_assert_werr_equal(tctx,
1481                 r.out.result,
1482                 WERR_CLUSTER_NODE_NOT_PAUSED,
1483                 "ResumeNode gave unexpected result");
1484
1485         return true;
1486 }
1487
1488 static bool test_ResumeNode(struct torture_context *tctx,
1489                             void *data)
1490 {
1491         struct torture_clusapi_context *t =
1492                 talloc_get_type_abort(data, struct torture_clusapi_context);
1493         struct policy_handle hNode;
1494         bool ret = true;
1495
1496         if (!test_OpenNode_int(tctx, t->p, t->NodeName, &hNode)) {
1497                 return false;
1498         }
1499
1500         ret = test_ResumeNode_int(tctx, t->p, &hNode);
1501
1502         test_CloseNode_int(tctx, t->p, &hNode);
1503
1504         return ret;
1505 }
1506
1507 static bool test_EvictNode_int(struct torture_context *tctx,
1508                                struct dcerpc_pipe *p,
1509                                struct policy_handle *hNode)
1510 {
1511         struct dcerpc_binding_handle *b = p->binding_handle;
1512         struct clusapi_EvictNode r;
1513         WERROR rpc_status;
1514
1515         r.in.hNode = *hNode;
1516         r.out.rpc_status = &rpc_status;
1517
1518         torture_assert_ntstatus_ok(tctx,
1519                 dcerpc_clusapi_EvictNode_r(b, tctx, &r),
1520                 "EvictNode failed");
1521         torture_assert_werr_ok(tctx,
1522                 r.out.result,
1523                 "EvictNode failed");
1524
1525         return true;
1526 }
1527
1528 static bool test_EvictNode(struct torture_context *tctx,
1529                            void *data)
1530 {
1531         struct torture_clusapi_context *t =
1532                 talloc_get_type_abort(data, struct torture_clusapi_context);
1533         struct policy_handle hNode;
1534         bool ret = true;
1535
1536         if (!test_OpenNode_int(tctx, t->p, t->NodeName, &hNode)) {
1537                 return false;
1538         }
1539
1540         ret = test_EvictNode_int(tctx, t->p, &hNode);
1541
1542         test_CloseNode_int(tctx, t->p, &hNode);
1543
1544         return ret;
1545 }
1546
1547 static bool test_one_node(struct torture_context *tctx,
1548                           struct dcerpc_pipe *p,
1549                           const char *node_name)
1550 {
1551         struct policy_handle hNode;
1552
1553         torture_assert(tctx,
1554                 test_OpenNode_int(tctx, p, node_name, &hNode),
1555                 "failed to open node");
1556         test_CloseNode_int(tctx, p, &hNode);
1557
1558         torture_assert(tctx,
1559                 test_OpenNodeEx_int(tctx, p, node_name, &hNode),
1560                 "failed to openex node");
1561
1562         torture_assert(tctx,
1563                 test_GetNodeId_int(tctx, p, &hNode),
1564                 "failed to query node id");
1565         torture_assert(tctx,
1566                 test_GetNodeState_int(tctx, p, &hNode),
1567                 "failed to query node id");
1568
1569         test_CloseNode_int(tctx, p, &hNode);
1570
1571         return true;
1572 }
1573
1574 static bool test_all_nodes(struct torture_context *tctx,
1575                            void *data)
1576 {
1577         struct torture_clusapi_context *t =
1578                 talloc_get_type_abort(data, struct torture_clusapi_context);
1579         struct dcerpc_binding_handle *b = t->p->binding_handle;
1580         struct clusapi_CreateEnum r;
1581         uint32_t dwType = CLUSTER_ENUM_NODE;
1582         struct ENUM_LIST *ReturnEnum;
1583         WERROR rpc_status;
1584         int i;
1585
1586         r.in.dwType = dwType;
1587         r.out.ReturnEnum = &ReturnEnum;
1588         r.out.rpc_status = &rpc_status;
1589
1590         torture_assert_ntstatus_ok(tctx,
1591                 dcerpc_clusapi_CreateEnum_r(b, tctx, &r),
1592                 "CreateEnum failed");
1593         torture_assert_werr_ok(tctx,
1594                 r.out.result,
1595                 "CreateEnum failed");
1596
1597         for (i=0; i < ReturnEnum->EntryCount; i++) {
1598
1599                 struct ENUM_ENTRY e = ReturnEnum->Entry[i];
1600
1601                 torture_assert_int_equal(tctx, e.Type, CLUSTER_ENUM_NODE, "type mismatch");
1602
1603                 torture_assert(tctx,
1604                         test_one_node(tctx, t->p, e.Name),
1605                         "failed to test one node");
1606         }
1607
1608         return true;
1609 }
1610
1611 static bool test_OpenGroup_int(struct torture_context *tctx,
1612                                struct dcerpc_pipe *p,
1613                                const char *lpszGroupName,
1614                                struct policy_handle *hGroup)
1615 {
1616         struct dcerpc_binding_handle *b = p->binding_handle;
1617         struct clusapi_OpenGroup r;
1618         WERROR Status;
1619         WERROR rpc_status;
1620
1621         r.in.lpszGroupName = lpszGroupName;
1622         r.out.rpc_status = &rpc_status;
1623         r.out.Status = &Status;
1624         r.out.hGroup= hGroup;
1625
1626         torture_assert_ntstatus_ok(tctx,
1627                 dcerpc_clusapi_OpenGroup_r(b, tctx, &r),
1628                 "OpenGroup failed");
1629         torture_assert_werr_ok(tctx,
1630                 *r.out.Status,
1631                 "OpenGroup failed");
1632
1633         return true;
1634 }
1635
1636 static bool test_OpenGroupEx_int(struct torture_context *tctx,
1637                                  struct dcerpc_pipe *p,
1638                                  const char *lpszGroupName,
1639                                  struct policy_handle *hGroup)
1640 {
1641         struct dcerpc_binding_handle *b = p->binding_handle;
1642         struct clusapi_OpenGroupEx r;
1643         uint32_t lpdwGrantedAccess;
1644         WERROR Status;
1645         WERROR rpc_status;
1646
1647         r.in.lpszGroupName = lpszGroupName;
1648         r.in.dwDesiredAccess = SEC_FLAG_MAXIMUM_ALLOWED;
1649         r.out.lpdwGrantedAccess = &lpdwGrantedAccess;
1650         r.out.rpc_status = &rpc_status;
1651         r.out.Status = &Status;
1652         r.out.hGroup= hGroup;
1653
1654         torture_assert_ntstatus_ok(tctx,
1655                 dcerpc_clusapi_OpenGroupEx_r(b, tctx, &r),
1656                 "OpenGroupEx failed");
1657         torture_assert_werr_ok(tctx,
1658                 *r.out.Status,
1659                 "OpenGroupEx failed");
1660
1661         return true;
1662 }
1663
1664 static bool test_CloseGroup_int(struct torture_context *tctx,
1665                                 struct dcerpc_pipe *p,
1666                                 struct policy_handle *Group)
1667 {
1668         struct dcerpc_binding_handle *b = p->binding_handle;
1669         struct clusapi_CloseGroup r;
1670
1671         r.in.Group = Group;
1672         r.out.Group = Group;
1673
1674         torture_assert_ntstatus_ok(tctx,
1675                 dcerpc_clusapi_CloseGroup_r(b, tctx, &r),
1676                 "CloseGroup failed");
1677         torture_assert_werr_ok(tctx,
1678                 r.out.result,
1679                 "CloseGroup failed");
1680         torture_assert(tctx,
1681                 ndr_policy_handle_empty(Group),
1682                 "policy_handle non empty after CloseGroup");
1683
1684         return true;
1685 }
1686
1687 static bool test_OpenGroup(struct torture_context *tctx,
1688                            void *data)
1689 {
1690         struct torture_clusapi_context *t =
1691                 talloc_get_type_abort(data, struct torture_clusapi_context);
1692         struct policy_handle hGroup;
1693
1694         if (!test_OpenGroup_int(tctx, t->p, "Cluster Group", &hGroup)) {
1695                 return false;
1696         }
1697
1698         test_CloseGroup_int(tctx, t->p, &hGroup);
1699
1700         return true;
1701 }
1702
1703 static bool test_OpenGroupEx(struct torture_context *tctx,
1704                              void *data)
1705 {
1706         struct torture_clusapi_context *t =
1707                 talloc_get_type_abort(data, struct torture_clusapi_context);
1708         struct policy_handle hGroup;
1709
1710         if (!test_OpenGroupEx_int(tctx, t->p, "Cluster Group", &hGroup)) {
1711                 return false;
1712         }
1713
1714         test_CloseGroup_int(tctx, t->p, &hGroup);
1715
1716         return true;
1717 }
1718
1719 static bool test_CloseGroup(struct torture_context *tctx,
1720                             void *data)
1721 {
1722         struct torture_clusapi_context *t =
1723                 talloc_get_type_abort(data, struct torture_clusapi_context);
1724         struct policy_handle hGroup;
1725
1726         if (!test_OpenGroup_int(tctx, t->p, "Cluster Group", &hGroup)) {
1727                 return false;
1728         }
1729
1730         return test_CloseGroup_int(tctx, t->p, &hGroup);
1731 }
1732
1733 static bool test_GetGroupState_int(struct torture_context *tctx,
1734                                    struct dcerpc_pipe *p,
1735                                    struct policy_handle *hGroup)
1736 {
1737         struct dcerpc_binding_handle *b = p->binding_handle;
1738         struct clusapi_GetGroupState r;
1739         enum clusapi_ClusterGroupState State;
1740         const char *NodeName;
1741         WERROR rpc_status;
1742
1743         r.in.hGroup = *hGroup;
1744         r.out.State = &State;
1745         r.out.NodeName = &NodeName;
1746         r.out.rpc_status = &rpc_status;
1747
1748         torture_assert_ntstatus_ok(tctx,
1749                 dcerpc_clusapi_GetGroupState_r(b, tctx, &r),
1750                 "GetGroupState failed");
1751         torture_assert_werr_ok(tctx,
1752                 r.out.result,
1753                 "GetGroupState failed");
1754
1755         return true;
1756 }
1757
1758 static bool test_GetGroupState(struct torture_context *tctx,
1759                                void *data)
1760 {
1761         struct torture_clusapi_context *t =
1762                 talloc_get_type_abort(data, struct torture_clusapi_context);
1763         struct policy_handle hGroup;
1764         bool ret = true;
1765
1766         if (!test_OpenGroup_int(tctx, t->p, "Cluster Group", &hGroup)) {
1767                 return false;
1768         }
1769
1770         ret = test_GetGroupState_int(tctx, t->p, &hGroup);
1771
1772         test_CloseGroup_int(tctx, t->p, &hGroup);
1773
1774         return ret;
1775 }
1776
1777 static bool test_GetGroupId_int(struct torture_context *tctx,
1778                                 struct dcerpc_pipe *p,
1779                                 struct policy_handle *hGroup)
1780 {
1781         struct dcerpc_binding_handle *b = p->binding_handle;
1782         struct clusapi_GetGroupId r;
1783         const char *pGuid;
1784         WERROR rpc_status;
1785
1786         r.in.hGroup = *hGroup;
1787         r.out.pGuid = &pGuid;
1788         r.out.rpc_status = &rpc_status;
1789
1790         torture_assert_ntstatus_ok(tctx,
1791                 dcerpc_clusapi_GetGroupId_r(b, tctx, &r),
1792                 "GetGroupId failed");
1793         torture_assert_werr_ok(tctx,
1794                 r.out.result,
1795                 "GetGroupId failed");
1796
1797         return true;
1798 }
1799
1800 static bool test_GetGroupId(struct torture_context *tctx,
1801                             void *data)
1802 {
1803         struct torture_clusapi_context *t =
1804                 talloc_get_type_abort(data, struct torture_clusapi_context);
1805         struct policy_handle hGroup;
1806         bool ret = true;
1807
1808         if (!test_OpenGroup_int(tctx, t->p, "Cluster Group", &hGroup)) {
1809                 return false;
1810         }
1811
1812         ret = test_GetGroupId_int(tctx, t->p, &hGroup);
1813
1814         test_CloseGroup_int(tctx, t->p, &hGroup);
1815
1816         return ret;
1817 }
1818
1819 static bool test_OnlineGroup_int(struct torture_context *tctx,
1820                                  struct dcerpc_pipe *p,
1821                                  struct policy_handle *hGroup)
1822 {
1823         struct dcerpc_binding_handle *b = p->binding_handle;
1824         struct clusapi_OnlineGroup r;
1825         WERROR rpc_status;
1826
1827         r.in.hGroup = *hGroup;
1828         r.out.rpc_status = &rpc_status;
1829
1830         torture_assert_ntstatus_ok(tctx,
1831                 dcerpc_clusapi_OnlineGroup_r(b, tctx, &r),
1832                 "OnlineGroup failed");
1833         torture_assert_werr_ok(tctx,
1834                 r.out.result,
1835                 "OnlineGroup failed");
1836
1837         return true;
1838 }
1839
1840 static bool test_OnlineGroup(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_OnlineGroup_int(tctx, t->p, &hGroup);
1853
1854         test_CloseGroup_int(tctx, t->p, &hGroup);
1855
1856         return ret;
1857 }
1858
1859 static bool test_OfflineGroup_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_OfflineGroup r;
1865         WERROR rpc_status;
1866
1867         r.in.hGroup = *hGroup;
1868         r.out.rpc_status = &rpc_status;
1869
1870         torture_assert_ntstatus_ok(tctx,
1871                 dcerpc_clusapi_OfflineGroup_r(b, tctx, &r),
1872                 "OfflineGroup failed");
1873         torture_assert_werr_ok(tctx,
1874                 r.out.result,
1875                 "OfflineGroup failed");
1876
1877         return true;
1878 }
1879
1880 static bool test_OfflineGroup(struct torture_context *tctx,
1881                               void *data)
1882 {
1883         struct torture_clusapi_context *t =
1884                 talloc_get_type_abort(data, struct torture_clusapi_context);
1885         struct policy_handle hGroup;
1886         bool ret = true;
1887
1888         if (!test_OpenGroup_int(tctx, t->p, "Cluster Group", &hGroup)) {
1889                 return false;
1890         }
1891
1892         ret = test_OfflineGroup_int(tctx, t->p, &hGroup);
1893
1894         test_CloseGroup_int(tctx, t->p, &hGroup);
1895
1896         return ret;
1897 }
1898
1899 static bool test_one_group(struct torture_context *tctx,
1900                            struct dcerpc_pipe *p,
1901                            const char *node_name)
1902 {
1903         struct policy_handle hGroup;
1904
1905         torture_assert(tctx,
1906                 test_OpenGroup_int(tctx, p, node_name, &hGroup),
1907                 "failed to open group");
1908         test_CloseGroup_int(tctx, p, &hGroup);
1909
1910         torture_assert(tctx,
1911                 test_OpenGroupEx_int(tctx, p, node_name, &hGroup),
1912                 "failed to openex group");
1913
1914         torture_assert(tctx,
1915                 test_GetGroupId_int(tctx, p, &hGroup),
1916                 "failed to query group id");
1917         torture_assert(tctx,
1918                 test_GetGroupState_int(tctx, p, &hGroup),
1919                 "failed to query group id");
1920
1921         test_CloseGroup_int(tctx, p, &hGroup);
1922
1923         return true;
1924 }
1925
1926 static bool test_all_groups(struct torture_context *tctx,
1927                             void *data)
1928 {
1929         struct torture_clusapi_context *t =
1930                 talloc_get_type_abort(data, struct torture_clusapi_context);
1931         struct dcerpc_binding_handle *b = t->p->binding_handle;
1932         struct clusapi_CreateEnum r;
1933         uint32_t dwType = CLUSTER_ENUM_GROUP;
1934         struct ENUM_LIST *ReturnEnum;
1935         WERROR rpc_status;
1936         int i;
1937
1938         r.in.dwType = dwType;
1939         r.out.ReturnEnum = &ReturnEnum;
1940         r.out.rpc_status = &rpc_status;
1941
1942         torture_assert_ntstatus_ok(tctx,
1943                 dcerpc_clusapi_CreateEnum_r(b, tctx, &r),
1944                 "CreateEnum failed");
1945         torture_assert_werr_ok(tctx,
1946                 r.out.result,
1947                 "CreateEnum failed");
1948
1949         for (i=0; i < ReturnEnum->EntryCount; i++) {
1950
1951                 struct ENUM_ENTRY e = ReturnEnum->Entry[i];
1952
1953                 torture_assert_int_equal(tctx, e.Type, CLUSTER_ENUM_GROUP, "type mismatch");
1954
1955                 torture_assert(tctx,
1956                         test_one_group(tctx, t->p, e.Name),
1957                         "failed to test one group");
1958         }
1959
1960         return true;
1961 }
1962
1963 static bool test_BackupClusterDatabase(struct torture_context *tctx,
1964                                        void *data)
1965 {
1966         struct torture_clusapi_context *t =
1967                 talloc_get_type_abort(data, struct torture_clusapi_context);
1968         struct dcerpc_binding_handle *b = t->p->binding_handle;
1969         struct clusapi_BackupClusterDatabase r;
1970         WERROR rpc_status;
1971
1972         r.in.lpszPathName = "c:\\cluster_backup";
1973         r.out.rpc_status = &rpc_status;
1974
1975         torture_assert_ntstatus_ok(tctx,
1976                 dcerpc_clusapi_BackupClusterDatabase_r(b, tctx, &r),
1977                 "BackupClusterDatabase failed");
1978         torture_assert_werr_equal(tctx,
1979                 r.out.result,
1980                 WERR_CALL_NOT_IMPLEMENTED,
1981                 "BackupClusterDatabase failed");
1982
1983         return true;
1984 }
1985
1986 static bool test_SetServiceAccountPassword(struct torture_context *tctx,
1987                                            void *data)
1988 {
1989         struct torture_clusapi_context *t =
1990                 talloc_get_type_abort(data, struct torture_clusapi_context);
1991         struct dcerpc_binding_handle *b = t->p->binding_handle;
1992         struct clusapi_SetServiceAccountPassword r;
1993         uint32_t SizeReturned;
1994         uint32_t ExpectedBufferSize;
1995
1996         r.in.lpszNewPassword = "P@ssw0rd!";
1997         r.in.dwFlags = IDL_CLUSTER_SET_PASSWORD_IGNORE_DOWN_NODES;
1998         r.in.ReturnStatusBufferSize = 1024;
1999         r.out.ReturnStatusBufferPtr = NULL;
2000         r.out.SizeReturned = &SizeReturned;
2001         r.out.ExpectedBufferSize = &ExpectedBufferSize;
2002
2003         torture_assert_ntstatus_ok(tctx,
2004                 dcerpc_clusapi_SetServiceAccountPassword_r(b, tctx, &r),
2005                 "SetServiceAccountPassword failed");
2006         torture_assert_werr_equal(tctx,
2007                 r.out.result,
2008                 WERR_CALL_NOT_IMPLEMENTED,
2009                 "SetServiceAccountPassword failed");
2010
2011         return true;
2012 }
2013
2014 static bool test_ClusterControl_int(struct torture_context *tctx,
2015                                     struct dcerpc_pipe *p,
2016                                     struct policy_handle *Cluster)
2017 {
2018         struct dcerpc_binding_handle *b = p->binding_handle;
2019         struct clusapi_ClusterControl r;
2020         uint32_t lpBytesReturned;
2021         uint32_t lpcbRequired;
2022         WERROR rpc_status;
2023
2024         r.in.hCluster = *Cluster;
2025         r.in.dwControlCode = 0;
2026         r.in.lpInBuffer = NULL;
2027         r.in.nInBufferSize = 0;
2028         r.in.nOutBufferSize = 0;
2029         r.out.lpOutBuffer = NULL;
2030         r.out.lpBytesReturned = &lpBytesReturned;
2031         r.out.lpcbRequired = &lpcbRequired;
2032         r.out.rpc_status = &rpc_status;
2033
2034         torture_assert_ntstatus_ok(tctx,
2035                 dcerpc_clusapi_ClusterControl_r(b, tctx, &r),
2036                 "ClusterControl failed");
2037         torture_assert_werr_equal(tctx,
2038                 r.out.result,
2039                 WERR_INVALID_FUNCTION,
2040                 "ClusterControl failed");
2041
2042         r.in.dwControlCode = CLUSCTL_CLUSTER_GET_RO_COMMON_PROPERTIES;
2043
2044         torture_assert_ntstatus_ok(tctx,
2045                 dcerpc_clusapi_ClusterControl_r(b, tctx, &r),
2046                 "ClusterControl failed");
2047
2048         if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
2049                 r.out.lpOutBuffer = talloc_zero_array(tctx, uint8_t, *r.out.lpcbRequired);
2050                 r.in.nOutBufferSize = *r.out.lpcbRequired;
2051                 torture_assert_ntstatus_ok(tctx,
2052                         dcerpc_clusapi_ClusterControl_r(b, tctx, &r),
2053                         "ClusterControl failed");
2054         }
2055         torture_assert_werr_ok(tctx,
2056                 r.out.result,
2057                 "ClusterControl failed");
2058
2059         return true;
2060 }
2061
2062 static bool test_ClusterControl(struct torture_context *tctx,
2063                                 void *data)
2064 {
2065         struct torture_clusapi_context *t =
2066                 talloc_get_type_abort(data, struct torture_clusapi_context);
2067         struct policy_handle Cluster;
2068         bool ret;
2069
2070         if (!test_OpenCluster_int(tctx, t->p, &Cluster)) {
2071                 return false;
2072         }
2073
2074         ret = test_ClusterControl_int(tctx, t->p, &Cluster);
2075
2076         test_CloseCluster_int(tctx, t->p, &Cluster);
2077
2078         return ret;
2079 }
2080
2081 static bool test_OpenNetwork_int(struct torture_context *tctx,
2082                                  struct dcerpc_pipe *p,
2083                                  const char *lpszNetworkName,
2084                                  struct policy_handle *hNetwork)
2085 {
2086         struct dcerpc_binding_handle *b = p->binding_handle;
2087         struct clusapi_OpenNetwork r;
2088         WERROR Status;
2089         WERROR rpc_status;
2090
2091         r.in.lpszNetworkName = lpszNetworkName;
2092         r.out.rpc_status = &rpc_status;
2093         r.out.Status = &Status;
2094         r.out.hNetwork = hNetwork ;
2095
2096         torture_assert_ntstatus_ok(tctx,
2097                 dcerpc_clusapi_OpenNetwork_r(b, tctx, &r),
2098                 "OpenNetwork failed");
2099         torture_assert_werr_ok(tctx,
2100                 *r.out.Status,
2101                 "OpenNetwork failed");
2102
2103         return true;
2104 }
2105
2106 static bool test_OpenNetworkEx_int(struct torture_context *tctx,
2107                                    struct dcerpc_pipe *p,
2108                                    const char *lpszNetworkName,
2109                                    struct policy_handle *hNetwork)
2110 {
2111         struct dcerpc_binding_handle *b = p->binding_handle;
2112         struct clusapi_OpenNetworkEx r;
2113         uint32_t lpdwGrantedAccess;
2114         WERROR Status;
2115         WERROR rpc_status;
2116
2117         r.in.lpszNetworkName = lpszNetworkName;
2118         r.in.dwDesiredAccess = SEC_FLAG_MAXIMUM_ALLOWED;
2119         r.out.lpdwGrantedAccess = &lpdwGrantedAccess;
2120         r.out.rpc_status = &rpc_status;
2121         r.out.Status = &Status;
2122         r.out.hNetwork = hNetwork ;
2123
2124         torture_assert_ntstatus_ok(tctx,
2125                 dcerpc_clusapi_OpenNetworkEx_r(b, tctx, &r),
2126                 "OpenNetworkEx failed");
2127         torture_assert_werr_ok(tctx,
2128                 *r.out.Status,
2129                 "OpenNetworkEx failed");
2130
2131         return true;
2132 }
2133
2134 static bool test_CloseNetwork_int(struct torture_context *tctx,
2135                                   struct dcerpc_pipe *p,
2136                                   struct policy_handle *Network)
2137 {
2138         struct dcerpc_binding_handle *b = p->binding_handle;
2139         struct clusapi_CloseNetwork r;
2140
2141         r.in.Network = Network;
2142         r.out.Network = Network;
2143
2144         torture_assert_ntstatus_ok(tctx,
2145                 dcerpc_clusapi_CloseNetwork_r(b, tctx, &r),
2146                 "CloseNetwork failed");
2147         torture_assert_werr_ok(tctx,
2148                 r.out.result,
2149                 "CloseNetwork failed");
2150         torture_assert(tctx,
2151                 ndr_policy_handle_empty(Network),
2152                 "policy_handle non empty after CloseNetwork");
2153
2154         return true;
2155 }
2156
2157 static bool test_OpenNetwork(struct torture_context *tctx,
2158                              void *data)
2159 {
2160         struct torture_clusapi_context *t =
2161                 talloc_get_type_abort(data, struct torture_clusapi_context);
2162         struct policy_handle hNetwork;
2163
2164         if (!test_OpenNetwork_int(tctx, t->p, "Cluster Network 1", &hNetwork)) {
2165                 return false;
2166         }
2167
2168         test_CloseNetwork_int(tctx, t->p, &hNetwork);
2169
2170         return true;
2171 }
2172
2173 static bool test_OpenNetworkEx(struct torture_context *tctx,
2174                                void *data)
2175 {
2176         struct torture_clusapi_context *t =
2177                 talloc_get_type_abort(data, struct torture_clusapi_context);
2178         struct policy_handle hNetwork;
2179
2180         if (!test_OpenNetworkEx_int(tctx, t->p, "Cluster Network 1", &hNetwork)) {
2181                 return false;
2182         }
2183
2184         test_CloseNetwork_int(tctx, t->p, &hNetwork);
2185
2186         return true;
2187 }
2188
2189 static bool test_CloseNetwork(struct torture_context *tctx,
2190                               void *data)
2191 {
2192         struct torture_clusapi_context *t =
2193                 talloc_get_type_abort(data, struct torture_clusapi_context);
2194         struct policy_handle hNetwork;
2195
2196         if (!test_OpenNetwork_int(tctx, t->p, "Cluster Network 1", &hNetwork)) {
2197                 return false;
2198         }
2199
2200         return test_CloseNetwork_int(tctx, t->p, &hNetwork);
2201 }
2202
2203 static bool test_GetNetworkState_int(struct torture_context *tctx,
2204                                      struct dcerpc_pipe *p,
2205                                      struct policy_handle *hNetwork)
2206 {
2207         struct dcerpc_binding_handle *b = p->binding_handle;
2208         struct clusapi_GetNetworkState r;
2209         enum clusapi_ClusterNetworkState State;
2210         WERROR rpc_status;
2211
2212         r.in.hNetwork = *hNetwork;
2213         r.out.State = &State;
2214         r.out.rpc_status = &rpc_status;
2215
2216         torture_assert_ntstatus_ok(tctx,
2217                 dcerpc_clusapi_GetNetworkState_r(b, tctx, &r),
2218                 "GetNetworkState failed");
2219         torture_assert_werr_ok(tctx,
2220                 r.out.result,
2221                 "GetNetworkState failed");
2222
2223         return true;
2224 }
2225
2226 static bool test_GetNetworkState(struct torture_context *tctx,
2227                                  void *data)
2228 {
2229         struct torture_clusapi_context *t =
2230                 talloc_get_type_abort(data, struct torture_clusapi_context);
2231         struct policy_handle hNetwork;
2232         bool ret = true;
2233
2234         if (!test_OpenNetwork_int(tctx, t->p, "Cluster Network 1", &hNetwork)) {
2235                 return false;
2236         }
2237
2238         ret = test_GetNetworkState_int(tctx, t->p, &hNetwork);
2239
2240         test_CloseNetwork_int(tctx, t->p, &hNetwork);
2241
2242         return ret;
2243 }
2244
2245 static bool test_GetNetworkId_int(struct torture_context *tctx,
2246                                   struct dcerpc_pipe *p,
2247                                   struct policy_handle *hNetwork)
2248 {
2249         struct dcerpc_binding_handle *b = p->binding_handle;
2250         struct clusapi_GetNetworkId r;
2251         const char *pGuid;
2252         WERROR rpc_status;
2253
2254         r.in.hNetwork = *hNetwork;
2255         r.out.pGuid = &pGuid;
2256         r.out.rpc_status = &rpc_status;
2257
2258         torture_assert_ntstatus_ok(tctx,
2259                 dcerpc_clusapi_GetNetworkId_r(b, tctx, &r),
2260                 "GetNetworkId failed");
2261         torture_assert_werr_ok(tctx,
2262                 r.out.result,
2263                 "GetNetworkId failed");
2264
2265         return true;
2266 }
2267
2268 static bool test_GetNetworkId(struct torture_context *tctx,
2269                               void *data)
2270 {
2271         struct torture_clusapi_context *t =
2272                 talloc_get_type_abort(data, struct torture_clusapi_context);
2273         struct policy_handle hNetwork;
2274         bool ret = true;
2275
2276         if (!test_OpenNetwork_int(tctx, t->p, "Cluster Network 1", &hNetwork)) {
2277                 return false;
2278         }
2279
2280         ret = test_GetNetworkId_int(tctx, t->p, &hNetwork);
2281
2282         test_CloseNetwork_int(tctx, t->p, &hNetwork);
2283
2284         return ret;
2285 }
2286
2287 static bool test_one_network(struct torture_context *tctx,
2288                              struct dcerpc_pipe *p,
2289                              const char *network_name)
2290 {
2291         struct policy_handle hNetwork;
2292
2293         torture_assert(tctx,
2294                 test_OpenNetwork_int(tctx, p, network_name, &hNetwork),
2295                 "failed to open network");
2296         test_CloseNetwork_int(tctx, p, &hNetwork);
2297
2298         torture_assert(tctx,
2299                 test_OpenNetworkEx_int(tctx, p, network_name, &hNetwork),
2300                 "failed to openex network");
2301
2302         torture_assert(tctx,
2303                 test_GetNetworkId_int(tctx, p, &hNetwork),
2304                 "failed to query network id");
2305         torture_assert(tctx,
2306                 test_GetNetworkState_int(tctx, p, &hNetwork),
2307                 "failed to query network id");
2308
2309         test_CloseNetwork_int(tctx, p, &hNetwork);
2310
2311         return true;
2312 }
2313
2314 static bool test_all_networks(struct torture_context *tctx,
2315                               void *data)
2316 {
2317         struct torture_clusapi_context *t =
2318                 talloc_get_type_abort(data, struct torture_clusapi_context);
2319         struct dcerpc_binding_handle *b = t->p->binding_handle;
2320         struct clusapi_CreateEnum r;
2321         uint32_t dwType = CLUSTER_ENUM_NETWORK;
2322         struct ENUM_LIST *ReturnEnum;
2323         WERROR rpc_status;
2324         int i;
2325
2326         r.in.dwType = dwType;
2327         r.out.ReturnEnum = &ReturnEnum;
2328         r.out.rpc_status = &rpc_status;
2329
2330         torture_assert_ntstatus_ok(tctx,
2331                 dcerpc_clusapi_CreateEnum_r(b, tctx, &r),
2332                 "CreateEnum failed");
2333         torture_assert_werr_ok(tctx,
2334                 r.out.result,
2335                 "CreateEnum failed");
2336
2337         for (i=0; i < ReturnEnum->EntryCount; i++) {
2338
2339                 struct ENUM_ENTRY e = ReturnEnum->Entry[i];
2340
2341                 torture_assert_int_equal(tctx, e.Type, CLUSTER_ENUM_NETWORK, "type mismatch");
2342
2343                 torture_assert(tctx,
2344                         test_one_network(tctx, t->p, e.Name),
2345                         "failed to test one network");
2346         }
2347
2348         return true;
2349 }
2350
2351 static bool test_OpenNetInterface_int(struct torture_context *tctx,
2352                                       struct dcerpc_pipe *p,
2353                                       const char *lpszNetInterfaceName,
2354                                       struct policy_handle *hNetInterface)
2355 {
2356         struct dcerpc_binding_handle *b = p->binding_handle;
2357         struct clusapi_OpenNetInterface r;
2358         WERROR Status;
2359         WERROR rpc_status;
2360
2361         r.in.lpszNetInterfaceName = lpszNetInterfaceName;
2362         r.out.rpc_status = &rpc_status;
2363         r.out.Status = &Status;
2364         r.out.hNetInterface = hNetInterface;
2365
2366         torture_assert_ntstatus_ok(tctx,
2367                 dcerpc_clusapi_OpenNetInterface_r(b, tctx, &r),
2368                 "OpenNetInterface failed");
2369         torture_assert_werr_ok(tctx,
2370                 *r.out.Status,
2371                 "OpenNetInterface failed");
2372
2373         return true;
2374 }
2375
2376 static bool test_OpenNetInterfaceEx_int(struct torture_context *tctx,
2377                                         struct dcerpc_pipe *p,
2378                                         const char *lpszNetInterfaceName,
2379                                         struct policy_handle *hNetInterface)
2380 {
2381         struct dcerpc_binding_handle *b = p->binding_handle;
2382         struct clusapi_OpenNetInterfaceEx r;
2383         uint32_t lpdwGrantedAccess;
2384         WERROR Status;
2385         WERROR rpc_status;
2386
2387         r.in.lpszNetInterfaceName = lpszNetInterfaceName;
2388         r.in.dwDesiredAccess = SEC_FLAG_MAXIMUM_ALLOWED;
2389         r.out.lpdwGrantedAccess = &lpdwGrantedAccess;
2390         r.out.rpc_status = &rpc_status;
2391         r.out.Status = &Status;
2392         r.out.hNetInterface = hNetInterface;
2393
2394         torture_assert_ntstatus_ok(tctx,
2395                 dcerpc_clusapi_OpenNetInterfaceEx_r(b, tctx, &r),
2396                 "OpenNetInterfaceEx failed");
2397         torture_assert_werr_ok(tctx,
2398                 *r.out.Status,
2399                 "OpenNetInterfaceEx failed");
2400
2401         return true;
2402 }
2403
2404 static bool test_CloseNetInterface_int(struct torture_context *tctx,
2405                                        struct dcerpc_pipe *p,
2406                                        struct policy_handle *NetInterface)
2407 {
2408         struct dcerpc_binding_handle *b = p->binding_handle;
2409         struct clusapi_CloseNetInterface r;
2410
2411         r.in.NetInterface = NetInterface;
2412         r.out.NetInterface = NetInterface;
2413
2414         torture_assert_ntstatus_ok(tctx,
2415                 dcerpc_clusapi_CloseNetInterface_r(b, tctx, &r),
2416                 "CloseNetInterface failed");
2417         torture_assert_werr_ok(tctx,
2418                 r.out.result,
2419                 "CloseNetInterface failed");
2420         torture_assert(tctx,
2421                 ndr_policy_handle_empty(NetInterface),
2422                 "policy_handle non empty after CloseNetInterface");
2423
2424         return true;
2425 }
2426
2427 static bool test_OpenNetInterface(struct torture_context *tctx,
2428                                   void *data)
2429 {
2430         struct torture_clusapi_context *t =
2431                 talloc_get_type_abort(data, struct torture_clusapi_context);
2432         struct policy_handle hNetInterface;
2433
2434         if (!test_OpenNetInterface_int(tctx, t->p, "node1 - Ethernet", &hNetInterface)) {
2435                 return false;
2436         }
2437
2438         test_CloseNetInterface_int(tctx, t->p, &hNetInterface);
2439
2440         return true;
2441 }
2442
2443 static bool test_OpenNetInterfaceEx(struct torture_context *tctx,
2444                                     void *data)
2445 {
2446         struct torture_clusapi_context *t =
2447                 talloc_get_type_abort(data, struct torture_clusapi_context);
2448         struct policy_handle hNetInterface;
2449
2450         if (!test_OpenNetInterfaceEx_int(tctx, t->p, "node1 - Ethernet", &hNetInterface)) {
2451                 return false;
2452         }
2453
2454         test_CloseNetInterface_int(tctx, t->p, &hNetInterface);
2455
2456         return true;
2457 }
2458
2459 static bool test_CloseNetInterface(struct torture_context *tctx,
2460                                    void *data)
2461 {
2462         struct torture_clusapi_context *t =
2463                 talloc_get_type_abort(data, struct torture_clusapi_context);
2464         struct policy_handle hNetInterface;
2465
2466         if (!test_OpenNetInterface_int(tctx, t->p, "node1 - Ethernet", &hNetInterface)) {
2467                 return false;
2468         }
2469
2470         return test_CloseNetInterface_int(tctx, t->p, &hNetInterface);
2471 }
2472
2473 static bool test_GetNetInterfaceState_int(struct torture_context *tctx,
2474                                           struct dcerpc_pipe *p,
2475                                           struct policy_handle *hNetInterface)
2476 {
2477         struct dcerpc_binding_handle *b = p->binding_handle;
2478         struct clusapi_GetNetInterfaceState r;
2479         enum clusapi_ClusterNetInterfaceState State;
2480         WERROR rpc_status;
2481
2482         r.in.hNetInterface = *hNetInterface;
2483         r.out.State = &State;
2484         r.out.rpc_status = &rpc_status;
2485
2486         torture_assert_ntstatus_ok(tctx,
2487                 dcerpc_clusapi_GetNetInterfaceState_r(b, tctx, &r),
2488                 "GetNetInterfaceState failed");
2489         torture_assert_werr_ok(tctx,
2490                 r.out.result,
2491                 "GetNetInterfaceState failed");
2492
2493         return true;
2494 }
2495
2496 static bool test_GetNetInterfaceState(struct torture_context *tctx,
2497                                       void *data)
2498 {
2499         struct torture_clusapi_context *t =
2500                 talloc_get_type_abort(data, struct torture_clusapi_context);
2501         struct policy_handle hNetInterface;
2502         bool ret = true;
2503
2504         if (!test_OpenNetInterface_int(tctx, t->p, "node1 - Ethernet", &hNetInterface)) {
2505                 return false;
2506         }
2507
2508         ret = test_GetNetInterfaceState_int(tctx, t->p, &hNetInterface);
2509
2510         test_CloseNetInterface_int(tctx, t->p, &hNetInterface);
2511
2512         return ret;
2513 }
2514
2515 static bool test_GetNetInterfaceId_int(struct torture_context *tctx,
2516                                        struct dcerpc_pipe *p,
2517                                        struct policy_handle *hNetInterface)
2518 {
2519         struct dcerpc_binding_handle *b = p->binding_handle;
2520         struct clusapi_GetNetInterfaceId r;
2521         const char *pGuid;
2522         WERROR rpc_status;
2523
2524         r.in.hNetInterface = *hNetInterface;
2525         r.out.pGuid = &pGuid;
2526         r.out.rpc_status = &rpc_status;
2527
2528         torture_assert_ntstatus_ok(tctx,
2529                 dcerpc_clusapi_GetNetInterfaceId_r(b, tctx, &r),
2530                 "GetNetInterfaceId failed");
2531         torture_assert_werr_ok(tctx,
2532                 r.out.result,
2533                 "GetNetInterfaceId failed");
2534
2535         return true;
2536 }
2537
2538 static bool test_GetNetInterfaceId(struct torture_context *tctx,
2539                                    void *data)
2540 {
2541         struct torture_clusapi_context *t =
2542                 talloc_get_type_abort(data, struct torture_clusapi_context);
2543         struct policy_handle hNetInterface;
2544         bool ret = true;
2545
2546         if (!test_OpenNetInterface_int(tctx, t->p, "node1 - Ethernet", &hNetInterface)) {
2547                 return false;
2548         }
2549
2550         ret = test_GetNetInterfaceId_int(tctx, t->p, &hNetInterface);
2551
2552         test_CloseNetInterface_int(tctx, t->p, &hNetInterface);
2553
2554         return ret;
2555 }
2556
2557 static bool test_one_netinterface(struct torture_context *tctx,
2558                                   struct dcerpc_pipe *p,
2559                                   const char *netinterface_name)
2560 {
2561         struct policy_handle hNetInterface;
2562
2563         torture_assert(tctx,
2564                 test_OpenNetInterface_int(tctx, p, netinterface_name, &hNetInterface),
2565                 "failed to open netinterface");
2566         test_CloseNetInterface_int(tctx, p, &hNetInterface);
2567
2568         torture_assert(tctx,
2569                 test_OpenNetInterfaceEx_int(tctx, p, netinterface_name, &hNetInterface),
2570                 "failed to openex netinterface");
2571
2572         torture_assert(tctx,
2573                 test_GetNetInterfaceId_int(tctx, p, &hNetInterface),
2574                 "failed to query netinterface id");
2575         torture_assert(tctx,
2576                 test_GetNetInterfaceState_int(tctx, p, &hNetInterface),
2577                 "failed to query netinterface id");
2578
2579         test_CloseNetInterface_int(tctx, p, &hNetInterface);
2580
2581         return true;
2582 }
2583
2584 static bool test_all_netinterfaces(struct torture_context *tctx,
2585                                    void *data)
2586 {
2587         struct torture_clusapi_context *t =
2588                 talloc_get_type_abort(data, struct torture_clusapi_context);
2589         struct dcerpc_binding_handle *b = t->p->binding_handle;
2590         struct clusapi_CreateEnum r;
2591         uint32_t dwType = CLUSTER_ENUM_NETINTERFACE;
2592         struct ENUM_LIST *ReturnEnum;
2593         WERROR rpc_status;
2594         int i;
2595
2596         r.in.dwType = dwType;
2597         r.out.ReturnEnum = &ReturnEnum;
2598         r.out.rpc_status = &rpc_status;
2599
2600         torture_assert_ntstatus_ok(tctx,
2601                 dcerpc_clusapi_CreateEnum_r(b, tctx, &r),
2602                 "CreateEnum failed");
2603         torture_assert_werr_ok(tctx,
2604                 r.out.result,
2605                 "CreateEnum failed");
2606
2607         for (i=0; i < ReturnEnum->EntryCount; i++) {
2608
2609                 struct ENUM_ENTRY e = ReturnEnum->Entry[i];
2610
2611                 torture_assert_int_equal(tctx, e.Type, CLUSTER_ENUM_NETINTERFACE, "type mismatch");
2612
2613                 torture_assert(tctx,
2614                         test_one_netinterface(tctx, t->p, e.Name),
2615                         "failed to test one netinterface");
2616         }
2617
2618         return true;
2619 }
2620
2621 static bool test_CloseKey_int(struct torture_context *tctx,
2622                               struct dcerpc_pipe *p,
2623                               struct policy_handle *pKey)
2624 {
2625         struct dcerpc_binding_handle *b = p->binding_handle;
2626         struct clusapi_CloseKey r;
2627
2628         r.in.pKey = pKey;
2629         r.out.pKey = pKey;
2630
2631         torture_assert_ntstatus_ok(tctx,
2632                 dcerpc_clusapi_CloseKey_r(b, tctx, &r),
2633                 "CloseKey failed");
2634         torture_assert_werr_ok(tctx,
2635                 r.out.result,
2636                 "CloseKey failed");
2637         torture_assert(tctx,
2638                 ndr_policy_handle_empty(pKey),
2639                 "policy_handle non empty after CloseKey");
2640
2641         return true;
2642 }
2643
2644 static bool test_GetRootKey_int(struct torture_context *tctx,
2645                                 struct dcerpc_pipe *p,
2646                                 struct policy_handle *phKey)
2647 {
2648         struct dcerpc_binding_handle *b = p->binding_handle;
2649         struct clusapi_GetRootKey r;
2650         WERROR Status;
2651         WERROR rpc_status;
2652
2653         r.in.samDesired = SEC_FLAG_MAXIMUM_ALLOWED;
2654         r.out.Status = &Status;
2655         r.out.rpc_status = &rpc_status;
2656         r.out.phKey = phKey;
2657
2658         torture_assert_ntstatus_ok(tctx,
2659                 dcerpc_clusapi_GetRootKey_r(b, tctx, &r),
2660                 "GetRootKey failed");
2661         torture_assert_werr_ok(tctx,
2662                 *r.out.Status,
2663                 "GetRootKey failed");
2664
2665         return true;
2666 }
2667
2668 static bool test_EnumKey_int(struct torture_context *tctx,
2669                              struct dcerpc_pipe *p,
2670                              struct policy_handle *hKey)
2671 {
2672         struct dcerpc_binding_handle *b = p->binding_handle;
2673         struct clusapi_EnumKey r;
2674         const char *KeyName;
2675         NTTIME lpftLastWriteTime;
2676         WERROR rpc_status;
2677
2678         r.in.hKey = *hKey;
2679         r.in.dwIndex = 0;
2680         r.out.KeyName = &KeyName;
2681         r.out.lpftLastWriteTime = &lpftLastWriteTime;
2682         r.out.rpc_status = &rpc_status;
2683
2684         torture_assert_ntstatus_ok(tctx,
2685                 dcerpc_clusapi_EnumKey_r(b, tctx, &r),
2686                 "EnumKey failed");
2687         torture_assert_werr_ok(tctx,
2688                 r.out.result,
2689                 "EnumKey failed");
2690
2691         return true;
2692 }
2693
2694 static bool test_OpenKey_int(struct torture_context *tctx,
2695                              struct dcerpc_pipe *p,
2696                              struct policy_handle *hKey,
2697                              const char *lpSubKey,
2698                              struct policy_handle *phKey)
2699 {
2700         struct dcerpc_binding_handle *b = p->binding_handle;
2701         struct clusapi_OpenKey r;
2702         WERROR Status;
2703         WERROR rpc_status;
2704
2705         r.in.hKey = *hKey;
2706         r.in.lpSubKey = lpSubKey;
2707         r.in.samDesired = SEC_FLAG_MAXIMUM_ALLOWED;
2708         r.out.Status = &Status;
2709         r.out.rpc_status = &rpc_status;
2710         r.out.phKey = phKey;
2711
2712         torture_assert_ntstatus_ok(tctx,
2713                 dcerpc_clusapi_OpenKey_r(b, tctx, &r),
2714                 "OpenKey failed");
2715         torture_assert_werr_ok(tctx,
2716                 *r.out.Status,
2717                 "OpenKey failed");
2718
2719         return true;
2720 }
2721
2722 static bool test_EnumValue_int(struct torture_context *tctx,
2723                                struct dcerpc_pipe *p,
2724                                struct policy_handle *hKey)
2725 {
2726         struct dcerpc_binding_handle *b = p->binding_handle;
2727         struct clusapi_EnumValue r;
2728         const char *lpValueName;
2729         uint32_t lpType;
2730         uint32_t TotalSize;
2731         WERROR rpc_status;
2732         int i = 0;
2733
2734         do {
2735                 uint32_t lpcbData = 1024;
2736
2737                 r.in.hKey = *hKey;
2738                 r.in.dwIndex = i++;
2739                 r.in.lpcbData = &lpcbData;
2740                 r.out.lpValueName = &lpValueName;
2741                 r.out.lpType = &lpType;
2742                 r.out.lpData = talloc_array(tctx, uint8_t, lpcbData);
2743                 r.out.TotalSize = &TotalSize;
2744                 r.out.rpc_status = &rpc_status;
2745                 r.out.lpcbData = &lpcbData;
2746
2747                 torture_assert_ntstatus_ok(tctx,
2748                         dcerpc_clusapi_EnumValue_r(b, tctx, &r),
2749                         "EnumValue failed");
2750
2751         } while (W_ERROR_IS_OK(r.out.result));
2752
2753         torture_assert_werr_equal(tctx,
2754                 r.out.result,
2755                 WERR_NO_MORE_ITEMS,
2756                 "EnumValue failed");
2757
2758         return true;
2759 }
2760
2761 static bool test_QueryInfoKey_int(struct torture_context *tctx,
2762                                   struct dcerpc_pipe *p,
2763                                   struct policy_handle *hKey)
2764 {
2765         struct dcerpc_binding_handle *b = p->binding_handle;
2766         struct clusapi_QueryInfoKey r;
2767         uint32_t lpcSubKeys;
2768         uint32_t lpcbMaxSubKeyLen;
2769         uint32_t lpcValues;
2770         uint32_t lpcbMaxValueNameLen;
2771         uint32_t lpcbMaxValueLen;
2772         uint32_t lpcbSecurityDescriptor;
2773         NTTIME lpftLastWriteTime;
2774         WERROR rpc_status;
2775
2776         r.in.hKey = *hKey;
2777         r.out.lpcSubKeys = &lpcSubKeys;
2778         r.out.lpcbMaxSubKeyLen = &lpcbMaxSubKeyLen;
2779         r.out.lpcValues = &lpcValues;
2780         r.out.lpcbMaxValueNameLen = &lpcbMaxValueNameLen;
2781         r.out.lpcbMaxValueLen = &lpcbMaxValueLen;
2782         r.out.lpcbSecurityDescriptor = &lpcbSecurityDescriptor;
2783         r.out.lpftLastWriteTime = &lpftLastWriteTime;
2784         r.out.rpc_status = &rpc_status;
2785
2786         torture_assert_ntstatus_ok(tctx,
2787                 dcerpc_clusapi_QueryInfoKey_r(b, tctx, &r),
2788                 "QueryInfoKey failed");
2789         torture_assert_werr_ok(tctx,
2790                 r.out.result,
2791                 "QueryInfoKey failed");
2792
2793         return true;
2794 }
2795
2796 static bool test_GetKeySecurity_int(struct torture_context *tctx,
2797                                     struct dcerpc_pipe *p,
2798                                     struct policy_handle *hKey)
2799 {
2800         struct dcerpc_binding_handle *b = p->binding_handle;
2801         struct clusapi_GetKeySecurity r;
2802         uint32_t SecurityInformation = SECINFO_DACL | SECINFO_OWNER | SECINFO_GROUP;
2803         struct RPC_SECURITY_DESCRIPTOR pRpcSecurityDescriptor;
2804         WERROR rpc_status;
2805
2806         ZERO_STRUCT(pRpcSecurityDescriptor);
2807
2808         r.in.hKey = *hKey;
2809         r.in.SecurityInformation = SecurityInformation;
2810         r.in.pRpcSecurityDescriptor = &pRpcSecurityDescriptor;
2811         r.out.rpc_status = &rpc_status;
2812         r.out.pRpcSecurityDescriptor = &pRpcSecurityDescriptor;
2813
2814         torture_assert_ntstatus_ok(tctx,
2815                 dcerpc_clusapi_GetKeySecurity_r(b, tctx, &r),
2816                 "GetKeySecurity failed");
2817
2818         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
2819                 pRpcSecurityDescriptor.lpSecurityDescriptor = talloc_array(tctx,
2820                 uint8_t, pRpcSecurityDescriptor.cbInSecurityDescriptor);
2821
2822                 torture_assert_ntstatus_ok(tctx,
2823                         dcerpc_clusapi_GetKeySecurity_r(b, tctx, &r),
2824                         "GetKeySecurity failed");
2825         }
2826
2827         torture_assert_werr_ok(tctx,
2828                 r.out.result,
2829                 "GetKeySecurity failed");
2830
2831         return true;
2832 }
2833
2834 static bool test_GetRootKey(struct torture_context *tctx,
2835                             void *data)
2836 {
2837         struct torture_clusapi_context *t =
2838                 talloc_get_type_abort(data, struct torture_clusapi_context);
2839         struct policy_handle hKey;
2840
2841         if (!test_GetRootKey_int(tctx, t->p, &hKey)) {
2842                 return false;
2843         }
2844
2845         test_CloseKey_int(tctx, t->p, &hKey);
2846
2847         return true;
2848 }
2849
2850 static bool test_CloseKey(struct torture_context *tctx,
2851                           void *data)
2852 {
2853         struct torture_clusapi_context *t =
2854                 talloc_get_type_abort(data, struct torture_clusapi_context);
2855         struct policy_handle hKey;
2856
2857         if (!test_GetRootKey_int(tctx, t->p, &hKey)) {
2858                 return false;
2859         }
2860
2861         return test_CloseKey_int(tctx, t->p, &hKey);
2862 }
2863
2864 static bool test_EnumKey(struct torture_context *tctx,
2865                          void *data)
2866 {
2867         struct torture_clusapi_context *t =
2868                 talloc_get_type_abort(data, struct torture_clusapi_context);
2869         struct policy_handle hKey;
2870         bool ret = true;
2871
2872         if (!test_GetRootKey_int(tctx, t->p, &hKey)) {
2873                 return false;
2874         }
2875
2876         ret = test_EnumKey_int(tctx, t->p, &hKey);
2877
2878         test_CloseKey_int(tctx, t->p, &hKey);
2879
2880         return ret;
2881 }
2882
2883 static bool test_QueryValue_int(struct torture_context *tctx,
2884                                 struct dcerpc_pipe *p,
2885                                 struct policy_handle *hKey,
2886                                 const char *ValueName)
2887 {
2888         struct dcerpc_binding_handle *b = p->binding_handle;
2889         struct clusapi_QueryValue r;
2890         uint32_t lpValueType;
2891         uint32_t lpcbRequired;
2892         WERROR rpc_status;
2893
2894         r.in.hKey = *hKey;
2895         r.in.lpValueName = ValueName;
2896         r.in.cbData = 0;
2897         r.out.lpValueType = &lpValueType;
2898         r.out.lpData = NULL;
2899         r.out.lpcbRequired = &lpcbRequired;
2900         r.out.rpc_status = &rpc_status;
2901
2902         torture_assert_ntstatus_ok(tctx,
2903                 dcerpc_clusapi_QueryValue_r(b, tctx, &r),
2904                 "QueryValue failed");
2905
2906         if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
2907
2908                 r.in.cbData = lpcbRequired;
2909                 r.out.lpData = talloc_zero_array(tctx, uint8_t, r.in.cbData);
2910
2911                 torture_assert_ntstatus_ok(tctx,
2912                         dcerpc_clusapi_QueryValue_r(b, tctx, &r),
2913                         "QueryValue failed");
2914         }
2915
2916         torture_assert_werr_ok(tctx,
2917                 r.out.result,
2918                 "QueryValue failed");
2919
2920         if (lpValueType == REG_SZ) {
2921                 const char *s;
2922                 DATA_BLOB blob = data_blob_const(r.out.lpData, lpcbRequired);
2923                 pull_reg_sz(tctx, &blob, &s);
2924                 torture_comment(tctx, "got: %s\n", s);
2925         }
2926
2927         return true;
2928 }
2929
2930 static bool test_QueryValue(struct torture_context *tctx,
2931                             void *data)
2932 {
2933         struct torture_clusapi_context *t =
2934                 talloc_get_type_abort(data, struct torture_clusapi_context);
2935         struct policy_handle hKey;
2936         bool ret = true;
2937
2938         if (!test_GetRootKey_int(tctx, t->p, &hKey)) {
2939                 return false;
2940         }
2941
2942         ret = test_QueryValue_int(tctx, t->p, &hKey, "ClusterInstanceID");
2943
2944         test_CloseKey_int(tctx, t->p, &hKey);
2945
2946         return ret;
2947 }
2948
2949
2950 static bool test_one_key(struct torture_context *tctx,
2951                          struct dcerpc_pipe *p,
2952                          struct policy_handle *hKey,
2953                          const char *KeyName)
2954 {
2955         struct policy_handle phKey;
2956
2957         torture_assert(tctx,
2958                 test_OpenKey_int(tctx, p, hKey, KeyName, &phKey),
2959                 "failed to open key");
2960
2961         torture_assert(tctx,
2962                 test_QueryInfoKey_int(tctx, p, &phKey),
2963                 "failed to enum values");
2964         torture_assert(tctx,
2965                 test_GetKeySecurity_int(tctx, p, &phKey),
2966                 "failed to get key security");
2967
2968         torture_assert(tctx,
2969                 test_EnumValue_int(tctx, p, &phKey),
2970                 "failed to enum values");
2971
2972         torture_assert(tctx,
2973                 test_CloseKey_int(tctx, p, &phKey),
2974                 "failed to close key");
2975
2976         return true;
2977 }
2978
2979 static bool test_all_keys(struct torture_context *tctx,
2980                           void *data)
2981 {
2982         struct torture_clusapi_context *t =
2983                 talloc_get_type_abort(data, struct torture_clusapi_context);
2984         struct dcerpc_binding_handle *b = t->p->binding_handle;
2985         struct policy_handle hKey;
2986         struct clusapi_EnumKey r;
2987         const char *KeyName;
2988         NTTIME lpftLastWriteTime;
2989         WERROR rpc_status;
2990         int i = 0;
2991
2992         if (!test_GetRootKey_int(tctx, t->p, &hKey)) {
2993                 return false;
2994         }
2995
2996         do {
2997                 r.in.hKey = hKey;
2998                 r.in.dwIndex = i++;
2999                 r.out.KeyName = &KeyName;
3000                 r.out.lpftLastWriteTime = &lpftLastWriteTime;
3001                 r.out.rpc_status = &rpc_status;
3002
3003                 torture_assert_ntstatus_ok(tctx,
3004                         dcerpc_clusapi_EnumKey_r(b, tctx, &r),
3005                         "EnumKey failed");
3006
3007                 if (W_ERROR_IS_OK(r.out.result)) {
3008                         torture_assert(tctx,
3009                                 test_one_key(tctx, t->p, &hKey, KeyName),
3010                                 "failed to test one key");
3011                 }
3012
3013         } while (W_ERROR_IS_OK(r.out.result));
3014
3015         torture_assert_werr_equal(tctx,
3016                 r.out.result,
3017                 WERR_NO_MORE_ITEMS,
3018                 "EnumKey failed");
3019
3020         test_CloseKey_int(tctx, t->p, &hKey);
3021
3022         return true;
3023 }
3024
3025 static bool torture_rpc_clusapi_setup_common(struct torture_context *tctx,
3026                                              struct torture_clusapi_context *t)
3027 {
3028         struct dcerpc_binding_handle *b;
3029
3030         torture_assert_ntstatus_ok(tctx,
3031                 torture_rpc_connection(tctx, &t->p, &ndr_table_clusapi),
3032                 "Error connecting to server");
3033
3034         {
3035                 struct clusapi_GetClusterName r;
3036
3037                 b = t->p->binding_handle;
3038
3039                 r.out.ClusterName = &t->ClusterName;
3040                 r.out.NodeName = &t->NodeName;
3041
3042                 torture_assert_ntstatus_ok(tctx,
3043                         dcerpc_clusapi_GetClusterName_r(b, tctx, &r),
3044                         "GetClusterName failed");
3045                 torture_assert_werr_ok(tctx,
3046                         r.out.result,
3047                         "GetClusterName failed");
3048         }
3049
3050         return true;
3051 }
3052
3053 static bool torture_rpc_clusapi_setup(struct torture_context *tctx,
3054                                       void **data)
3055 {
3056         struct torture_clusapi_context *t;
3057
3058         *data = t = talloc_zero(tctx, struct torture_clusapi_context);
3059
3060         return torture_rpc_clusapi_setup_common(tctx, t);
3061 }
3062
3063 static bool torture_rpc_clusapi_teardown(struct torture_context *tctx,
3064                                          void *data)
3065 {
3066         talloc_free(data);
3067
3068         return true;
3069 }
3070
3071 void torture_tcase_cluster(struct torture_tcase *tcase)
3072 {
3073         torture_tcase_add_simple_test(tcase, "OpenCluster",
3074                                       test_OpenCluster);
3075         torture_tcase_add_simple_test(tcase, "OpenClusterEx",
3076                                       test_OpenClusterEx);
3077         torture_tcase_add_simple_test(tcase, "CloseCluster",
3078                                       test_CloseCluster);
3079         torture_tcase_add_simple_test(tcase, "SetClusterName",
3080                                       test_SetClusterName);
3081         torture_tcase_add_simple_test(tcase, "GetClusterName",
3082                                       test_GetClusterName);
3083         torture_tcase_add_simple_test(tcase, "GetClusterVersion",
3084                                       test_GetClusterVersion);
3085         torture_tcase_add_simple_test(tcase, "CreateEnum",
3086                                       test_CreateEnum);
3087         torture_tcase_add_simple_test(tcase, "CreateEnumEx",
3088                                       test_CreateEnumEx);
3089         torture_tcase_add_simple_test(tcase, "GetClusterVersion2",
3090                                       test_GetClusterVersion2);
3091         torture_tcase_add_simple_test(tcase, "BackupClusterDatabase",
3092                                       test_BackupClusterDatabase);
3093         torture_tcase_add_simple_test(tcase, "SetServiceAccountPassword",
3094                                       test_SetServiceAccountPassword);
3095         torture_tcase_add_simple_test(tcase, "ClusterControl",
3096                                       test_ClusterControl);
3097
3098 }
3099
3100 void torture_tcase_resource(struct torture_tcase *tcase)
3101 {
3102         struct torture_test *test;
3103
3104         torture_tcase_add_simple_test(tcase, "GetQuorumResource",
3105                                       test_GetQuorumResource);
3106         torture_tcase_add_simple_test(tcase, "SetQuorumResource",
3107                                       test_SetQuorumResource);
3108         torture_tcase_add_simple_test(tcase, "OpenResource",
3109                                       test_OpenResource);
3110         torture_tcase_add_simple_test(tcase, "OpenResourceEx",
3111                                       test_OpenResourceEx);
3112         torture_tcase_add_simple_test(tcase, "CloseResource",
3113                                       test_CloseResource);
3114         torture_tcase_add_simple_test(tcase, "CreateResource",
3115                                       test_CreateResource);
3116         torture_tcase_add_simple_test(tcase, "DeleteResource",
3117                                       test_DeleteResource);
3118         torture_tcase_add_simple_test(tcase, "SetResourceName",
3119                                       test_SetResourceName);
3120         torture_tcase_add_simple_test(tcase, "GetResourceState",
3121                                       test_GetResourceState);
3122         torture_tcase_add_simple_test(tcase, "GetResourceId",
3123                                       test_GetResourceId);
3124         torture_tcase_add_simple_test(tcase, "GetResourceType",
3125                                       test_GetResourceType);
3126         torture_tcase_add_simple_test(tcase, "CreateResEnum",
3127                                       test_CreateResEnum);
3128         test = torture_tcase_add_simple_test(tcase, "FailResource",
3129                                       test_FailResource);
3130         test->dangerous = true;
3131         torture_tcase_add_simple_test(tcase, "OnlineResource",
3132                                       test_OnlineResource);
3133         test = torture_tcase_add_simple_test(tcase, "OfflineResource",
3134                                       test_OfflineResource);
3135         test->dangerous = true;
3136         torture_tcase_add_simple_test(tcase, "GetResourceDependencyExpression",
3137                                       test_GetResourceDependencyExpression);
3138         torture_tcase_add_simple_test(tcase, "GetResourceNetworkName",
3139                                       test_GetResourceNetworkName);
3140         torture_tcase_add_simple_test(tcase, "all_resources",
3141                                       test_all_resources);
3142 }
3143
3144 void torture_tcase_node(struct torture_tcase *tcase)
3145 {
3146         struct torture_test *test;
3147
3148         torture_tcase_add_simple_test(tcase, "OpenNode",
3149                                       test_OpenNode);
3150         torture_tcase_add_simple_test(tcase, "OpenNodeEx",
3151                                       test_OpenNodeEx);
3152         torture_tcase_add_simple_test(tcase, "CloseNode",
3153                                       test_CloseNode);
3154         torture_tcase_add_simple_test(tcase, "GetNodeState",
3155                                       test_GetNodeState);
3156         torture_tcase_add_simple_test(tcase, "GetNodeId",
3157                                       test_GetNodeId);
3158         test = torture_tcase_add_simple_test(tcase, "PauseNode",
3159                                              test_PauseNode);
3160         test->dangerous = true;
3161         torture_tcase_add_simple_test(tcase, "ResumeNode",
3162                                       test_ResumeNode);
3163         test = torture_tcase_add_simple_test(tcase, "EvictNode",
3164                                              test_EvictNode);
3165         test->dangerous = true;
3166         torture_tcase_add_simple_test(tcase, "all_nodes",
3167                                       test_all_nodes);
3168 }
3169
3170 void torture_tcase_group(struct torture_tcase *tcase)
3171 {
3172         struct torture_test *test;
3173
3174         torture_tcase_add_simple_test(tcase, "OpenGroup",
3175                                       test_OpenGroup);
3176         torture_tcase_add_simple_test(tcase, "OpenGroupEx",
3177                                       test_OpenGroupEx);
3178         torture_tcase_add_simple_test(tcase, "CloseGroup",
3179                                       test_CloseGroup);
3180         torture_tcase_add_simple_test(tcase, "GetGroupState",
3181                                       test_GetGroupState);
3182         torture_tcase_add_simple_test(tcase, "GetGroupId",
3183                                       test_GetGroupId);
3184         torture_tcase_add_simple_test(tcase, "OnlineGroup",
3185                                       test_OnlineGroup);
3186         test = torture_tcase_add_simple_test(tcase, "OfflineGroup",
3187                                       test_OfflineGroup);
3188         test->dangerous = true;
3189         torture_tcase_add_simple_test(tcase, "all_groups",
3190                                       test_all_groups);
3191 }
3192
3193 void torture_tcase_network(struct torture_tcase *tcase)
3194 {
3195         torture_tcase_add_simple_test(tcase, "OpenNetwork",
3196                                       test_OpenNetwork);
3197         torture_tcase_add_simple_test(tcase, "OpenNetworkEx",
3198                                       test_OpenNetworkEx);
3199         torture_tcase_add_simple_test(tcase, "CloseNetwork",
3200                                       test_CloseNetwork);
3201         torture_tcase_add_simple_test(tcase, "GetNetworkState",
3202                                       test_GetNetworkState);
3203         torture_tcase_add_simple_test(tcase, "GetNetworkId",
3204                                       test_GetNetworkId);
3205         torture_tcase_add_simple_test(tcase, "all_networks",
3206                                       test_all_networks);
3207 }
3208
3209 void torture_tcase_netinterface(struct torture_tcase *tcase)
3210 {
3211         torture_tcase_add_simple_test(tcase, "OpenNetInterface",
3212                                       test_OpenNetInterface);
3213         torture_tcase_add_simple_test(tcase, "OpenNetInterfaceEx",
3214                                       test_OpenNetInterfaceEx);
3215         torture_tcase_add_simple_test(tcase, "CloseNetInterface",
3216                                       test_CloseNetInterface);
3217         torture_tcase_add_simple_test(tcase, "GetNetInterfaceState",
3218                                       test_GetNetInterfaceState);
3219         torture_tcase_add_simple_test(tcase, "GetNetInterfaceId",
3220                                       test_GetNetInterfaceId);
3221         torture_tcase_add_simple_test(tcase, "all_netinterfaces",
3222                                       test_all_netinterfaces);
3223 }
3224
3225 void torture_tcase_registry(struct torture_tcase *tcase)
3226 {
3227         torture_tcase_add_simple_test(tcase, "GetRootKey",
3228                                       test_GetRootKey);
3229         torture_tcase_add_simple_test(tcase, "CloseKey",
3230                                       test_CloseKey);
3231         torture_tcase_add_simple_test(tcase, "EnumKey",
3232                                       test_EnumKey);
3233         torture_tcase_add_simple_test(tcase, "QueryValue",
3234                                       test_QueryValue);
3235         torture_tcase_add_simple_test(tcase, "all_keys",
3236                                       test_all_keys);
3237 }
3238
3239 struct torture_suite *torture_rpc_clusapi(TALLOC_CTX *mem_ctx)
3240 {
3241         struct torture_tcase *tcase;
3242         struct torture_suite *suite = torture_suite_create(mem_ctx, "clusapi");
3243
3244         tcase = torture_suite_add_tcase(suite, "cluster");
3245
3246         torture_tcase_set_fixture(tcase,
3247                                   torture_rpc_clusapi_setup,
3248                                   torture_rpc_clusapi_teardown);
3249
3250         torture_tcase_cluster(tcase);
3251
3252         tcase = torture_suite_add_tcase(suite, "resource");
3253
3254         torture_tcase_set_fixture(tcase,
3255                                   torture_rpc_clusapi_setup,
3256                                   torture_rpc_clusapi_teardown);
3257
3258         torture_tcase_resource(tcase);
3259
3260         tcase = torture_suite_add_tcase(suite, "node");
3261
3262         torture_tcase_set_fixture(tcase,
3263                                   torture_rpc_clusapi_setup,
3264                                   torture_rpc_clusapi_teardown);
3265
3266         torture_tcase_node(tcase);
3267
3268         tcase = torture_suite_add_tcase(suite, "group");
3269
3270         torture_tcase_set_fixture(tcase,
3271                                   torture_rpc_clusapi_setup,
3272                                   torture_rpc_clusapi_teardown);
3273
3274         torture_tcase_group(tcase);
3275
3276         tcase = torture_suite_add_tcase(suite, "network");
3277
3278         torture_tcase_set_fixture(tcase,
3279                                   torture_rpc_clusapi_setup,
3280                                   torture_rpc_clusapi_teardown);
3281
3282         torture_tcase_network(tcase);
3283
3284         tcase = torture_suite_add_tcase(suite, "netinterface");
3285
3286         torture_tcase_set_fixture(tcase,
3287                                   torture_rpc_clusapi_setup,
3288                                   torture_rpc_clusapi_teardown);
3289
3290         torture_tcase_netinterface(tcase);
3291
3292         tcase = torture_suite_add_tcase(suite, "registry");
3293
3294         torture_tcase_set_fixture(tcase,
3295                                   torture_rpc_clusapi_setup,
3296                                   torture_rpc_clusapi_teardown);
3297
3298         torture_tcase_registry(tcase);
3299
3300         return suite;
3301 }