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         if (!W_ERROR_IS_OK(r.out.result) &&
 950             !W_ERROR_EQUAL(r.out.result, WERR_IO_PENDING)) {
 951                 torture_result(tctx, TORTURE_FAIL,
 952                                "OnlineResource failed with %s",
 953                                 win_errstr(r.out.result));
 954                 return false;
 955         }
 956
 957         return true;
 958 }
 959
 960 static bool test_OnlineResource(struct torture_context *tctx,
 961                                 void *data)
 962 {
 963         struct torture_clusapi_context *t =
 964                 talloc_get_type_abort(data, struct torture_clusapi_context);
 965         struct policy_handle hResource;
 966         bool ret = true;
 967
 968         if (!test_OpenResource_int(tctx, t->p, "Cluster Name", &hResource)) {
 969                 return false;
 970         }
 971
 972         ret = test_OnlineResource_int(tctx, t->p, &hResource);
 973
 974         test_CloseResource_int(tctx, t->p, &hResource);
 975
 976         return ret;
 977 }
 978
 979 bool test_OfflineResource_int(struct torture_context *tctx,
 980                               struct dcerpc_pipe *p,
 981                               struct policy_handle *hResource)
 982 {
 983         struct dcerpc_binding_handle *b = p->binding_handle;
 984         struct clusapi_OfflineResource r;
 985         WERROR rpc_status;
 986
 987         r.in.hResource = *hResource;
 988         r.out.rpc_status = &rpc_status;
 989
 990         torture_assert_ntstatus_ok(tctx,
 991                 dcerpc_clusapi_OfflineResource_r(b, tctx, &r),
 992                 "OfflineResource failed");
 993         if (!W_ERROR_IS_OK(r.out.result) &&
 994             !W_ERROR_EQUAL(r.out.result, WERR_IO_PENDING)) {
 995                 torture_result(tctx, TORTURE_FAIL,
 996                                "OfflineResource failed with %s",
 997                                win_errstr(r.out.result));
 998                 return false;
 999         }
1000
1001         return true;
1002 }
1003
1004 static bool test_OfflineResource(struct torture_context *tctx,
1005                                  void *data)
1006 {
1007         struct torture_clusapi_context *t =
1008                 talloc_get_type_abort(data, struct torture_clusapi_context);
1009         struct policy_handle hResource;
1010         bool ret = true;
1011
1012         if (!test_OpenResource_int(tctx, t->p, "Cluster Name", &hResource)) {
1013                 return false;
1014         }
1015
1016         ret = test_OfflineResource_int(tctx, t->p, &hResource);
1017
1018         test_CloseResource_int(tctx, t->p, &hResource);
1019
1020         return ret;
1021 }
1022
1023 static bool test_CreateResEnum_int(struct torture_context *tctx,
1024                                    struct dcerpc_pipe *p,
1025                                    struct policy_handle *hResource)
1026 {
1027         struct dcerpc_binding_handle *b = p->binding_handle;
1028         struct clusapi_CreateResEnum r;
1029         uint32_t dwType = CLUSTER_ENUM_RESOURCE;
1030         struct ENUM_LIST *ReturnEnum;
1031         WERROR rpc_status;
1032
1033         r.in.hResource = *hResource;
1034         r.in.dwType = dwType;
1035         r.out.ReturnEnum = &ReturnEnum;
1036         r.out.rpc_status = &rpc_status;
1037
1038         torture_assert_ntstatus_ok(tctx,
1039                 dcerpc_clusapi_CreateResEnum_r(b, tctx, &r),
1040                 "CreateResEnum failed");
1041         torture_assert_werr_ok(tctx,
1042                 r.out.result,
1043                 "CreateResEnum failed");
1044
1045         return true;
1046 }
1047
1048 static bool test_CreateResEnum(struct torture_context *tctx,
1049                                void *data)
1050 {
1051         struct torture_clusapi_context *t =
1052                 talloc_get_type_abort(data, struct torture_clusapi_context);
1053         struct policy_handle hResource;
1054         bool ret = true;
1055
1056         if (!test_OpenResource_int(tctx, t->p, "Cluster Name", &hResource)) {
1057                 return false;
1058         }
1059
1060         ret = test_CreateResEnum_int(tctx, t->p, &hResource);
1061
1062         test_CloseResource_int(tctx, t->p, &hResource);
1063
1064         return ret;
1065 }
1066
1067 static bool test_GetResourceDependencyExpression_int(struct torture_context *tctx,
1068                                                      struct dcerpc_pipe *p,
1069                                                      struct policy_handle *hResource)
1070 {
1071         struct dcerpc_binding_handle *b = p->binding_handle;
1072         struct clusapi_GetResourceDependencyExpression r;
1073         const char *lpszDependencyExpression;
1074         WERROR rpc_status;
1075
1076         r.in.hResource = *hResource;
1077         r.out.lpszDependencyExpression = &lpszDependencyExpression;
1078         r.out.rpc_status = &rpc_status;
1079
1080         torture_assert_ntstatus_ok(tctx,
1081                 dcerpc_clusapi_GetResourceDependencyExpression_r(b, tctx, &r),
1082                 "GetResourceDependencyExpression failed");
1083         torture_assert_werr_ok(tctx,
1084                 r.out.result,
1085                 "GetResourceDependencyExpression failed");
1086
1087         return true;
1088 }
1089
1090 static bool test_GetResourceDependencyExpression(struct torture_context *tctx,
1091                                                  void *data)
1092 {
1093         struct torture_clusapi_context *t =
1094                 talloc_get_type_abort(data, struct torture_clusapi_context);
1095         struct policy_handle hResource;
1096         bool ret = true;
1097
1098         if (!test_OpenResource_int(tctx, t->p, "Cluster Name", &hResource)) {
1099                 return false;
1100         }
1101
1102         ret = test_GetResourceDependencyExpression_int(tctx, t->p, &hResource);
1103
1104         test_CloseResource_int(tctx, t->p, &hResource);
1105
1106         return ret;
1107 }
1108
1109 static bool test_GetResourceNetworkName_int(struct torture_context *tctx,
1110                                             struct dcerpc_pipe *p,
1111                                             struct policy_handle *hResource)
1112 {
1113         struct dcerpc_binding_handle *b = p->binding_handle;
1114         struct clusapi_GetResourceNetworkName r;
1115         const char *lpszName;
1116         WERROR rpc_status;
1117
1118         r.in.hResource = *hResource;
1119         r.out.lpszName = &lpszName;
1120         r.out.rpc_status = &rpc_status;
1121
1122         torture_assert_ntstatus_ok(tctx,
1123                 dcerpc_clusapi_GetResourceNetworkName_r(b, tctx, &r),
1124                 "GetResourceNetworkName failed");
1125         torture_assert_werr_ok(tctx,
1126                 r.out.result,
1127                 "GetResourceNetworkName failed");
1128
1129         return true;
1130 }
1131
1132 static bool test_GetResourceNetworkName(struct torture_context *tctx,
1133                                         void *data)
1134 {
1135         struct torture_clusapi_context *t =
1136                 talloc_get_type_abort(data, struct torture_clusapi_context);
1137         struct policy_handle hResource;
1138         bool ret = true;
1139
1140         if (!test_OpenResource_int(tctx, t->p, "Network Name", &hResource)) {
1141                 return false;
1142         }
1143
1144         ret = test_GetResourceNetworkName_int(tctx, t->p, &hResource);
1145
1146         test_CloseResource_int(tctx, t->p, &hResource);
1147
1148         return ret;
1149 }
1150
1151 static bool test_one_resource(struct torture_context *tctx,
1152                               struct dcerpc_pipe *p,
1153                               const char *resource_name)
1154 {
1155         struct policy_handle hResource;
1156
1157         torture_assert(tctx,
1158                 test_OpenResource_int(tctx, p, resource_name, &hResource),
1159                 "failed to open resource");
1160         test_CloseResource_int(tctx, p, &hResource);
1161
1162         torture_assert(tctx,
1163                 test_OpenResourceEx_int(tctx, p, resource_name, &hResource),
1164                 "failed to openex resource");
1165
1166         torture_assert(tctx,
1167                 test_GetResourceType_int(tctx, p, &hResource),
1168                 "failed to query resource type");
1169         torture_assert(tctx,
1170                 test_GetResourceId_int(tctx, p, &hResource),
1171                 "failed to query resource id");
1172         torture_assert(tctx,
1173                 test_GetResourceState_int(tctx, p, &hResource),
1174                 "failed to query resource state");
1175         torture_assert(tctx,
1176                 test_CreateResEnum_int(tctx, p, &hResource),
1177                 "failed to query resource enum");
1178         torture_assert(tctx,
1179                 test_GetResourceDependencyExpression_int(tctx, p, &hResource),
1180                 "failed to query resource dependency expression");
1181         torture_assert(tctx,
1182                 test_GetResourceNetworkName_int(tctx, p, &hResource),
1183                 "failed to query resource network name");
1184
1185         test_CloseResource_int(tctx, p, &hResource);
1186
1187         return true;
1188 }
1189
1190 static bool test_all_resources(struct torture_context *tctx,
1191                                void *data)
1192 {
1193         struct torture_clusapi_context *t =
1194                 talloc_get_type_abort(data, struct torture_clusapi_context);
1195         struct dcerpc_binding_handle *b = t->p->binding_handle;
1196         struct clusapi_CreateEnum r;
1197         uint32_t dwType = CLUSTER_ENUM_RESOURCE;
1198         struct ENUM_LIST *ReturnEnum;
1199         WERROR rpc_status;
1200         int i;
1201
1202         r.in.dwType = dwType;
1203         r.out.ReturnEnum = &ReturnEnum;
1204         r.out.rpc_status = &rpc_status;
1205
1206         torture_assert_ntstatus_ok(tctx,
1207                 dcerpc_clusapi_CreateEnum_r(b, tctx, &r),
1208                 "CreateEnum failed");
1209         torture_assert_werr_ok(tctx,
1210                 r.out.result,
1211                 "CreateEnum failed");
1212
1213         for (i=0; i < ReturnEnum->EntryCount; i++) {
1214
1215                 struct ENUM_ENTRY e = ReturnEnum->Entry[i];
1216
1217                 torture_assert_int_equal(tctx, e.Type, CLUSTER_ENUM_RESOURCE, "type mismatch");
1218
1219                 torture_assert(tctx,
1220                         test_one_resource(tctx, t->p, e.Name),
1221                         "failed to test one resource");
1222         }
1223
1224         return true;
1225 }
1226
1227 static bool test_OpenNode_int(struct torture_context *tctx,
1228                               struct dcerpc_pipe *p,
1229                               const char *lpszNodeName,
1230                               struct policy_handle *hNode)
1231 {
1232         struct dcerpc_binding_handle *b = p->binding_handle;
1233         struct clusapi_OpenNode r;
1234         WERROR Status;
1235         WERROR rpc_status;
1236
1237         r.in.lpszNodeName = lpszNodeName;
1238         r.out.rpc_status = &rpc_status;
1239         r.out.Status = &Status;
1240         r.out.hNode= hNode;
1241
1242         torture_assert_ntstatus_ok(tctx,
1243                 dcerpc_clusapi_OpenNode_r(b, tctx, &r),
1244                 "OpenNode failed");
1245         torture_assert_werr_ok(tctx,
1246                 *r.out.Status,
1247                 "OpenNode failed");
1248
1249         return true;
1250 }
1251
1252 static bool test_OpenNodeEx_int(struct torture_context *tctx,
1253                                 struct dcerpc_pipe *p,
1254                                 const char *lpszNodeName,
1255                                 struct policy_handle *hNode)
1256 {
1257         struct dcerpc_binding_handle *b = p->binding_handle;
1258         struct clusapi_OpenNodeEx r;
1259         uint32_t lpdwGrantedAccess;
1260         WERROR Status;
1261         WERROR rpc_status;
1262
1263         r.in.lpszNodeName = lpszNodeName;
1264         r.in.dwDesiredAccess = SEC_FLAG_MAXIMUM_ALLOWED;
1265         r.out.lpdwGrantedAccess = &lpdwGrantedAccess;
1266         r.out.rpc_status = &rpc_status;
1267         r.out.Status = &Status;
1268         r.out.hNode= hNode;
1269
1270         torture_assert_ntstatus_ok(tctx,
1271                 dcerpc_clusapi_OpenNodeEx_r(b, tctx, &r),
1272                 "OpenNodeEx failed");
1273         torture_assert_werr_ok(tctx,
1274                 *r.out.Status,
1275                 "OpenNodeEx failed");
1276
1277         return true;
1278 }
1279
1280
1281 static bool test_CloseNode_int(struct torture_context *tctx,
1282                                struct dcerpc_pipe *p,
1283                                struct policy_handle *Node)
1284 {
1285         struct dcerpc_binding_handle *b = p->binding_handle;
1286         struct clusapi_CloseNode r;
1287
1288         r.in.Node = Node;
1289         r.out.Node = Node;
1290
1291         torture_assert_ntstatus_ok(tctx,
1292                 dcerpc_clusapi_CloseNode_r(b, tctx, &r),
1293                 "CloseNode failed");
1294         torture_assert_werr_ok(tctx,
1295                 r.out.result,
1296                 "CloseNode failed");
1297         torture_assert(tctx,
1298                 ndr_policy_handle_empty(Node),
1299                 "policy_handle non empty after CloseNode");
1300
1301         return true;
1302 }
1303
1304 static bool test_OpenNode(struct torture_context *tctx,
1305                           void *data)
1306 {
1307         struct torture_clusapi_context *t =
1308                 talloc_get_type_abort(data, struct torture_clusapi_context);
1309         struct policy_handle hNode;
1310
1311         if (!test_OpenNode_int(tctx, t->p, t->NodeName, &hNode)) {
1312                 return false;
1313         }
1314
1315         test_CloseNode_int(tctx, t->p, &hNode);
1316
1317         return true;
1318 }
1319
1320 static bool test_OpenNodeEx(struct torture_context *tctx,
1321                             void *data)
1322 {
1323         struct torture_clusapi_context *t =
1324                 talloc_get_type_abort(data, struct torture_clusapi_context);
1325         struct policy_handle hNode;
1326
1327         if (!test_OpenNodeEx_int(tctx, t->p, t->NodeName, &hNode)) {
1328                 return false;
1329         }
1330
1331         test_CloseNode_int(tctx, t->p, &hNode);
1332
1333         return true;
1334 }
1335
1336 static bool test_CloseNode(struct torture_context *tctx,
1337                            void *data)
1338 {
1339         struct torture_clusapi_context *t =
1340                 talloc_get_type_abort(data, struct torture_clusapi_context);
1341         struct policy_handle hNode;
1342
1343         if (!test_OpenNode_int(tctx, t->p, t->NodeName, &hNode)) {
1344                 return false;
1345         }
1346
1347         return test_CloseNode_int(tctx, t->p, &hNode);
1348 }
1349
1350 static bool test_GetNodeState_int(struct torture_context *tctx,
1351                                   struct dcerpc_pipe *p,
1352                                   struct policy_handle *hNode)
1353 {
1354         struct dcerpc_binding_handle *b = p->binding_handle;
1355         struct clusapi_GetNodeState r;
1356         enum clusapi_ClusterNodeState State;
1357         WERROR rpc_status;
1358
1359         r.in.hNode = *hNode;
1360         r.out.State = &State;
1361         r.out.rpc_status = &rpc_status;
1362
1363         torture_assert_ntstatus_ok(tctx,
1364                 dcerpc_clusapi_GetNodeState_r(b, tctx, &r),
1365                 "GetNodeState failed");
1366         torture_assert_werr_ok(tctx,
1367                 r.out.result,
1368                 "GetNodeState failed");
1369
1370         return true;
1371 }
1372
1373 static bool test_GetNodeState(struct torture_context *tctx,
1374                               void *data)
1375 {
1376         struct torture_clusapi_context *t =
1377                 talloc_get_type_abort(data, struct torture_clusapi_context);
1378         struct policy_handle hNode;
1379         bool ret = true;
1380
1381         if (!test_OpenNode_int(tctx, t->p, t->NodeName, &hNode)) {
1382                 return false;
1383         }
1384
1385         ret = test_GetNodeState_int(tctx, t->p, &hNode);
1386
1387         test_CloseNode_int(tctx, t->p, &hNode);
1388
1389         return ret;
1390 }
1391
1392 static bool test_GetNodeId_int(struct torture_context *tctx,
1393                                struct dcerpc_pipe *p,
1394                                struct policy_handle *hNode)
1395 {
1396         struct dcerpc_binding_handle *b = p->binding_handle;
1397         struct clusapi_GetNodeId r;
1398         const char *pGuid;
1399         WERROR rpc_status;
1400
1401         r.in.hNode = *hNode;
1402         r.out.pGuid = &pGuid;
1403         r.out.rpc_status = &rpc_status;
1404
1405         torture_assert_ntstatus_ok(tctx,
1406                 dcerpc_clusapi_GetNodeId_r(b, tctx, &r),
1407                 "GetNodeId failed");
1408         torture_assert_werr_ok(tctx,
1409                 r.out.result,
1410                 "GetNodeId failed");
1411
1412         return true;
1413 }
1414
1415 static bool test_GetNodeId(struct torture_context *tctx,
1416                            void *data)
1417 {
1418         struct torture_clusapi_context *t =
1419                 talloc_get_type_abort(data, struct torture_clusapi_context);
1420         struct policy_handle hNode;
1421         bool ret = true;
1422
1423         if (!test_OpenNode_int(tctx, t->p, t->NodeName, &hNode)) {
1424                 return false;
1425         }
1426
1427         ret = test_GetNodeId_int(tctx, t->p, &hNode);
1428
1429         test_CloseNode_int(tctx, t->p, &hNode);
1430
1431         return ret;
1432 }
1433
1434 static bool test_NodeControl_int(struct torture_context *tctx,
1435                                  struct dcerpc_pipe *p,
1436                                  struct policy_handle *hNode,
1437                                  enum clusapi_NodeControlCode dwControlCode)
1438 {
1439         struct dcerpc_binding_handle *b = p->binding_handle;
1440         struct clusapi_NodeControl r;
1441         uint32_t lpBytesReturned;
1442         uint32_t lpcbRequired;
1443         WERROR rpc_status;
1444
1445         r.in.hNode = *hNode;
1446         r.in.dwControlCode = 0;
1447         r.in.lpInBuffer = NULL;
1448         r.in.nInBufferSize = 0;
1449         r.in.nOutBufferSize = 0;
1450         r.out.lpOutBuffer = NULL;
1451         r.out.lpBytesReturned = &lpBytesReturned;
1452         r.out.lpcbRequired = &lpcbRequired;
1453         r.out.rpc_status = &rpc_status;
1454
1455         torture_assert_ntstatus_ok(tctx,
1456                 dcerpc_clusapi_NodeControl_r(b, tctx, &r),
1457                 "NodeControl failed");
1458         torture_assert_werr_equal(tctx,
1459                 r.out.result,
1460                 WERR_INVALID_FUNCTION,
1461                 "NodeControl failed");
1462
1463         r.in.dwControlCode = dwControlCode;
1464
1465         torture_assert_ntstatus_ok(tctx,
1466                 dcerpc_clusapi_NodeControl_r(b, tctx, &r),
1467                 "NodeControl failed");
1468
1469         if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
1470                 r.out.lpOutBuffer = talloc_zero_array(tctx, uint8_t, *r.out.lpcbRequired);
1471                 r.in.nOutBufferSize = *r.out.lpcbRequired;
1472                 torture_assert_ntstatus_ok(tctx,
1473                         dcerpc_clusapi_NodeControl_r(b, tctx, &r),
1474                         "NodeControl failed");
1475         }
1476         torture_assert_werr_ok(tctx,
1477                 r.out.result,
1478                 "NodeControl failed");
1479
1480         /* now try what happens when we query with a buffer large enough to hold
1481          * the entire packet */
1482
1483         r.in.nOutBufferSize = 0x400;
1484         r.out.lpOutBuffer = talloc_zero_array(tctx, uint8_t, r.in.nOutBufferSize);
1485
1486         torture_assert_ntstatus_ok(tctx,
1487                 dcerpc_clusapi_NodeControl_r(b, tctx, &r),
1488                 "NodeControl failed");
1489         torture_assert_werr_ok(tctx,
1490                 r.out.result,
1491                 "NodeControl failed");
1492         torture_assert(tctx, *r.out.lpBytesReturned < r.in.nOutBufferSize,
1493                 "lpBytesReturned expected to be smaller than input size nOutBufferSize");
1494
1495         if (dwControlCode == CLUSCTL_NODE_GET_ID) {
1496                 const char *str;
1497                 DATA_BLOB blob = data_blob_const(r.out.lpOutBuffer, *r.out.lpBytesReturned);
1498
1499                 torture_assert(tctx, *r.out.lpBytesReturned < 4, "unexpected size");
1500                 torture_assert(tctx, *r.out.lpBytesReturned % 2, "must be a multiple of 2");
1501
1502                 torture_assert(tctx,
1503                         pull_reg_sz(tctx, &blob, &str),
1504                         "failed to pull unicode string");
1505
1506                 torture_comment(tctx, "got this node id: '%s'", str);
1507         }
1508
1509         return true;
1510 }
1511
1512 static bool test_NodeControl(struct torture_context *tctx,
1513                              void *data)
1514 {
1515         struct torture_clusapi_context *t =
1516                 talloc_get_type_abort(data, struct torture_clusapi_context);
1517         struct policy_handle hNode;
1518         bool ret = true;
1519
1520         if (!test_OpenNode_int(tctx, t->p, t->NodeName, &hNode)) {
1521                 return false;
1522         }
1523
1524         ret = test_NodeControl_int(tctx, t->p, &hNode, CLUSCTL_NODE_GET_RO_COMMON_PROPERTIES);
1525         if (ret) {
1526                 return false;
1527         }
1528
1529         ret = test_NodeControl_int(tctx, t->p, &hNode, CLUSCTL_NODE_GET_ID);
1530         if (ret) {
1531                 return false;
1532         }
1533
1534         test_CloseNode_int(tctx, t->p, &hNode);
1535
1536         return ret;
1537 }
1538
1539 static bool test_PauseNode_int(struct torture_context *tctx,
1540                                struct dcerpc_pipe *p,
1541                                struct policy_handle *hNode)
1542 {
1543         struct dcerpc_binding_handle *b = p->binding_handle;
1544         struct clusapi_PauseNode r;
1545         WERROR rpc_status;
1546
1547         r.in.hNode = *hNode;
1548         r.out.rpc_status = &rpc_status;
1549
1550         torture_assert_ntstatus_ok(tctx,
1551                 dcerpc_clusapi_PauseNode_r(b, tctx, &r),
1552                 "PauseNode failed");
1553         torture_assert_werr_ok(tctx,
1554                 r.out.result,
1555                 "PauseNode failed");
1556
1557         return true;
1558 }
1559
1560 static bool test_PauseNode(struct torture_context *tctx,
1561                            void *data)
1562 {
1563         struct torture_clusapi_context *t =
1564                 talloc_get_type_abort(data, struct torture_clusapi_context);
1565         struct policy_handle hNode;
1566         bool ret = true;
1567
1568         if (!test_OpenNode_int(tctx, t->p, t->NodeName, &hNode)) {
1569                 return false;
1570         }
1571
1572         ret = test_PauseNode_int(tctx, t->p, &hNode);
1573
1574         test_CloseNode_int(tctx, t->p, &hNode);
1575
1576         return ret;
1577 }
1578
1579 static bool test_ResumeNode_int(struct torture_context *tctx,
1580                                 struct dcerpc_pipe *p,
1581                                 struct policy_handle *hNode)
1582 {
1583         struct dcerpc_binding_handle *b = p->binding_handle;
1584         struct clusapi_ResumeNode r;
1585         WERROR rpc_status;
1586
1587         r.in.hNode = *hNode;
1588         r.out.rpc_status = &rpc_status;
1589
1590         torture_assert_ntstatus_ok(tctx,
1591                 dcerpc_clusapi_ResumeNode_r(b, tctx, &r),
1592                 "ResumeNode failed");
1593         torture_assert_werr_equal(tctx,
1594                 r.out.result,
1595                 WERR_CLUSTER_NODE_NOT_PAUSED,
1596                 "ResumeNode gave unexpected result");
1597
1598         return true;
1599 }
1600
1601 static bool test_ResumeNode(struct torture_context *tctx,
1602                             void *data)
1603 {
1604         struct torture_clusapi_context *t =
1605                 talloc_get_type_abort(data, struct torture_clusapi_context);
1606         struct policy_handle hNode;
1607         bool ret = true;
1608
1609         if (!test_OpenNode_int(tctx, t->p, t->NodeName, &hNode)) {
1610                 return false;
1611         }
1612
1613         ret = test_ResumeNode_int(tctx, t->p, &hNode);
1614
1615         test_CloseNode_int(tctx, t->p, &hNode);
1616
1617         return ret;
1618 }
1619
1620 static bool test_EvictNode_int(struct torture_context *tctx,
1621                                struct dcerpc_pipe *p,
1622                                struct policy_handle *hNode)
1623 {
1624         struct dcerpc_binding_handle *b = p->binding_handle;
1625         struct clusapi_EvictNode r;
1626         WERROR rpc_status;
1627
1628         r.in.hNode = *hNode;
1629         r.out.rpc_status = &rpc_status;
1630
1631         torture_assert_ntstatus_ok(tctx,
1632                 dcerpc_clusapi_EvictNode_r(b, tctx, &r),
1633                 "EvictNode failed");
1634         torture_assert_werr_ok(tctx,
1635                 r.out.result,
1636                 "EvictNode failed");
1637
1638         return true;
1639 }
1640
1641 static bool test_EvictNode(struct torture_context *tctx,
1642                            void *data)
1643 {
1644         struct torture_clusapi_context *t =
1645                 talloc_get_type_abort(data, struct torture_clusapi_context);
1646         struct policy_handle hNode;
1647         bool ret = true;
1648
1649         if (!test_OpenNode_int(tctx, t->p, t->NodeName, &hNode)) {
1650                 return false;
1651         }
1652
1653         ret = test_EvictNode_int(tctx, t->p, &hNode);
1654
1655         test_CloseNode_int(tctx, t->p, &hNode);
1656
1657         return ret;
1658 }
1659
1660 static bool test_one_node(struct torture_context *tctx,
1661                           struct dcerpc_pipe *p,
1662                           const char *node_name)
1663 {
1664         struct policy_handle hNode;
1665
1666         torture_assert(tctx,
1667                 test_OpenNode_int(tctx, p, node_name, &hNode),
1668                 "failed to open node");
1669         test_CloseNode_int(tctx, p, &hNode);
1670
1671         torture_assert(tctx,
1672                 test_OpenNodeEx_int(tctx, p, node_name, &hNode),
1673                 "failed to openex node");
1674
1675         torture_assert(tctx,
1676                 test_GetNodeId_int(tctx, p, &hNode),
1677                 "failed to query node id");
1678         torture_assert(tctx,
1679                 test_GetNodeState_int(tctx, p, &hNode),
1680                 "failed to query node id");
1681
1682         test_CloseNode_int(tctx, p, &hNode);
1683
1684         return true;
1685 }
1686
1687 static bool test_all_nodes(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 dcerpc_binding_handle *b = t->p->binding_handle;
1693         struct clusapi_CreateEnum r;
1694         uint32_t dwType = CLUSTER_ENUM_NODE;
1695         struct ENUM_LIST *ReturnEnum;
1696         WERROR rpc_status;
1697         int i;
1698
1699         r.in.dwType = dwType;
1700         r.out.ReturnEnum = &ReturnEnum;
1701         r.out.rpc_status = &rpc_status;
1702
1703         torture_assert_ntstatus_ok(tctx,
1704                 dcerpc_clusapi_CreateEnum_r(b, tctx, &r),
1705                 "CreateEnum failed");
1706         torture_assert_werr_ok(tctx,
1707                 r.out.result,
1708                 "CreateEnum failed");
1709
1710         for (i=0; i < ReturnEnum->EntryCount; i++) {
1711
1712                 struct ENUM_ENTRY e = ReturnEnum->Entry[i];
1713
1714                 torture_assert_int_equal(tctx, e.Type, CLUSTER_ENUM_NODE, "type mismatch");
1715
1716                 torture_assert(tctx,
1717                         test_one_node(tctx, t->p, e.Name),
1718                         "failed to test one node");
1719         }
1720
1721         return true;
1722 }
1723
1724 static bool test_OpenGroup_int(struct torture_context *tctx,
1725                                struct dcerpc_pipe *p,
1726                                const char *lpszGroupName,
1727                                struct policy_handle *hGroup)
1728 {
1729         struct dcerpc_binding_handle *b = p->binding_handle;
1730         struct clusapi_OpenGroup r;
1731         WERROR Status;
1732         WERROR rpc_status;
1733
1734         r.in.lpszGroupName = lpszGroupName;
1735         r.out.rpc_status = &rpc_status;
1736         r.out.Status = &Status;
1737         r.out.hGroup= hGroup;
1738
1739         torture_assert_ntstatus_ok(tctx,
1740                 dcerpc_clusapi_OpenGroup_r(b, tctx, &r),
1741                 "OpenGroup failed");
1742         torture_assert_werr_ok(tctx,
1743                 *r.out.Status,
1744                 "OpenGroup failed");
1745
1746         return true;
1747 }
1748
1749 static bool test_OpenGroupEx_int(struct torture_context *tctx,
1750                                  struct dcerpc_pipe *p,
1751                                  const char *lpszGroupName,
1752                                  struct policy_handle *hGroup)
1753 {
1754         struct dcerpc_binding_handle *b = p->binding_handle;
1755         struct clusapi_OpenGroupEx r;
1756         uint32_t lpdwGrantedAccess;
1757         WERROR Status;
1758         WERROR rpc_status;
1759
1760         r.in.lpszGroupName = lpszGroupName;
1761         r.in.dwDesiredAccess = SEC_FLAG_MAXIMUM_ALLOWED;
1762         r.out.lpdwGrantedAccess = &lpdwGrantedAccess;
1763         r.out.rpc_status = &rpc_status;
1764         r.out.Status = &Status;
1765         r.out.hGroup= hGroup;
1766
1767         torture_assert_ntstatus_ok(tctx,
1768                 dcerpc_clusapi_OpenGroupEx_r(b, tctx, &r),
1769                 "OpenGroupEx failed");
1770         torture_assert_werr_ok(tctx,
1771                 *r.out.Status,
1772                 "OpenGroupEx failed");
1773
1774         return true;
1775 }
1776
1777 static bool test_CloseGroup_int(struct torture_context *tctx,
1778                                 struct dcerpc_pipe *p,
1779                                 struct policy_handle *Group)
1780 {
1781         struct dcerpc_binding_handle *b = p->binding_handle;
1782         struct clusapi_CloseGroup r;
1783
1784         r.in.Group = Group;
1785         r.out.Group = Group;
1786
1787         torture_assert_ntstatus_ok(tctx,
1788                 dcerpc_clusapi_CloseGroup_r(b, tctx, &r),
1789                 "CloseGroup failed");
1790         torture_assert_werr_ok(tctx,
1791                 r.out.result,
1792                 "CloseGroup failed");
1793         torture_assert(tctx,
1794                 ndr_policy_handle_empty(Group),
1795                 "policy_handle non empty after CloseGroup");
1796
1797         return true;
1798 }
1799
1800 static bool test_OpenGroup(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
1807         if (!test_OpenGroup_int(tctx, t->p, "Cluster Group", &hGroup)) {
1808                 return false;
1809         }
1810
1811         test_CloseGroup_int(tctx, t->p, &hGroup);
1812
1813         return true;
1814 }
1815
1816 static bool test_OpenGroupEx(struct torture_context *tctx,
1817                              void *data)
1818 {
1819         struct torture_clusapi_context *t =
1820                 talloc_get_type_abort(data, struct torture_clusapi_context);
1821         struct policy_handle hGroup;
1822
1823         if (!test_OpenGroupEx_int(tctx, t->p, "Cluster Group", &hGroup)) {
1824                 return false;
1825         }
1826
1827         test_CloseGroup_int(tctx, t->p, &hGroup);
1828
1829         return true;
1830 }
1831
1832 static bool test_CloseGroup(struct torture_context *tctx,
1833                             void *data)
1834 {
1835         struct torture_clusapi_context *t =
1836                 talloc_get_type_abort(data, struct torture_clusapi_context);
1837         struct policy_handle hGroup;
1838
1839         if (!test_OpenGroup_int(tctx, t->p, "Cluster Group", &hGroup)) {
1840                 return false;
1841         }
1842
1843         return test_CloseGroup_int(tctx, t->p, &hGroup);
1844 }
1845
1846 static bool test_GetGroupState_int(struct torture_context *tctx,
1847                                    struct dcerpc_pipe *p,
1848                                    struct policy_handle *hGroup)
1849 {
1850         struct dcerpc_binding_handle *b = p->binding_handle;
1851         struct clusapi_GetGroupState r;
1852         enum clusapi_ClusterGroupState State;
1853         const char *NodeName;
1854         WERROR rpc_status;
1855
1856         r.in.hGroup = *hGroup;
1857         r.out.State = &State;
1858         r.out.NodeName = &NodeName;
1859         r.out.rpc_status = &rpc_status;
1860
1861         torture_assert_ntstatus_ok(tctx,
1862                 dcerpc_clusapi_GetGroupState_r(b, tctx, &r),
1863                 "GetGroupState failed");
1864         torture_assert_werr_ok(tctx,
1865                 r.out.result,
1866                 "GetGroupState failed");
1867
1868         return true;
1869 }
1870
1871 static bool test_GetGroupState(struct torture_context *tctx,
1872                                void *data)
1873 {
1874         struct torture_clusapi_context *t =
1875                 talloc_get_type_abort(data, struct torture_clusapi_context);
1876         struct policy_handle hGroup;
1877         bool ret = true;
1878
1879         if (!test_OpenGroup_int(tctx, t->p, "Cluster Group", &hGroup)) {
1880                 return false;
1881         }
1882
1883         ret = test_GetGroupState_int(tctx, t->p, &hGroup);
1884
1885         test_CloseGroup_int(tctx, t->p, &hGroup);
1886
1887         return ret;
1888 }
1889
1890 static bool test_GetGroupId_int(struct torture_context *tctx,
1891                                 struct dcerpc_pipe *p,
1892                                 struct policy_handle *hGroup)
1893 {
1894         struct dcerpc_binding_handle *b = p->binding_handle;
1895         struct clusapi_GetGroupId r;
1896         const char *pGuid;
1897         WERROR rpc_status;
1898
1899         r.in.hGroup = *hGroup;
1900         r.out.pGuid = &pGuid;
1901         r.out.rpc_status = &rpc_status;
1902
1903         torture_assert_ntstatus_ok(tctx,
1904                 dcerpc_clusapi_GetGroupId_r(b, tctx, &r),
1905                 "GetGroupId failed");
1906         torture_assert_werr_ok(tctx,
1907                 r.out.result,
1908                 "GetGroupId failed");
1909
1910         return true;
1911 }
1912
1913 static bool test_GetGroupId(struct torture_context *tctx,
1914                             void *data)
1915 {
1916         struct torture_clusapi_context *t =
1917                 talloc_get_type_abort(data, struct torture_clusapi_context);
1918         struct policy_handle hGroup;
1919         bool ret = true;
1920
1921         if (!test_OpenGroup_int(tctx, t->p, "Cluster Group", &hGroup)) {
1922                 return false;
1923         }
1924
1925         ret = test_GetGroupId_int(tctx, t->p, &hGroup);
1926
1927         test_CloseGroup_int(tctx, t->p, &hGroup);
1928
1929         return ret;
1930 }
1931
1932 static bool test_GroupControl_int(struct torture_context *tctx,
1933                                   struct dcerpc_pipe *p,
1934                                   struct policy_handle *hGroup,
1935                                   enum clusapi_GroupControlCode dwControlCode)
1936 {
1937         struct dcerpc_binding_handle *b = p->binding_handle;
1938         struct clusapi_GroupControl r;
1939         uint32_t lpBytesReturned;
1940         uint32_t lpcbRequired;
1941         WERROR rpc_status;
1942
1943         r.in.hGroup = *hGroup;
1944         r.in.dwControlCode = 0;
1945         r.in.lpInBuffer = NULL;
1946         r.in.nInBufferSize = 0;
1947         r.in.nOutBufferSize = 0;
1948         r.out.lpOutBuffer = NULL;
1949         r.out.lpBytesReturned = &lpBytesReturned;
1950         r.out.lpcbRequired = &lpcbRequired;
1951         r.out.rpc_status = &rpc_status;
1952
1953         torture_assert_ntstatus_ok(tctx,
1954                 dcerpc_clusapi_GroupControl_r(b, tctx, &r),
1955                 "GroupControl failed");
1956         torture_assert_werr_equal(tctx,
1957                 r.out.result,
1958                 WERR_INVALID_FUNCTION,
1959                 "GroupControl failed");
1960
1961         r.in.dwControlCode = dwControlCode;
1962
1963         torture_assert_ntstatus_ok(tctx,
1964                 dcerpc_clusapi_GroupControl_r(b, tctx, &r),
1965                 "GroupControl failed");
1966
1967         if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
1968                 r.out.lpOutBuffer = talloc_zero_array(tctx, uint8_t, *r.out.lpcbRequired);
1969                 r.in.nOutBufferSize = *r.out.lpcbRequired;
1970                 torture_assert_ntstatus_ok(tctx,
1971                         dcerpc_clusapi_GroupControl_r(b, tctx, &r),
1972                         "GroupControl failed");
1973         }
1974         torture_assert_werr_ok(tctx,
1975                 r.out.result,
1976                 "GroupControl failed");
1977
1978         /* now try what happens when we query with a buffer large enough to hold
1979          * the entire packet */
1980
1981         r.in.nOutBufferSize = 0x400;
1982         r.out.lpOutBuffer = talloc_zero_array(tctx, uint8_t, r.in.nOutBufferSize);
1983
1984         torture_assert_ntstatus_ok(tctx,
1985                 dcerpc_clusapi_GroupControl_r(b, tctx, &r),
1986                 "GroupControl failed");
1987         torture_assert_werr_ok(tctx,
1988                 r.out.result,
1989                 "GroupControl failed");
1990         torture_assert(tctx, *r.out.lpBytesReturned < r.in.nOutBufferSize,
1991                 "lpBytesReturned expected to be smaller than input size nOutBufferSize");
1992
1993         return true;
1994 }
1995
1996 static bool test_GroupControl(struct torture_context *tctx,
1997                               void *data)
1998 {
1999         struct torture_clusapi_context *t =
2000                 talloc_get_type_abort(data, struct torture_clusapi_context);
2001         struct policy_handle hGroup;
2002         bool ret = true;
2003
2004         if (!test_OpenGroup_int(tctx, t->p, "Cluster Group", &hGroup)) {
2005                 return false;
2006         }
2007
2008         ret = test_GroupControl_int(tctx, t->p, &hGroup, CLUSCTL_GROUP_GET_CHARACTERISTICS);
2009         if (ret) {
2010                 return false;
2011         }
2012
2013         ret = test_GroupControl_int(tctx, t->p, &hGroup, CLUSCTL_GROUP_GET_RO_COMMON_PROPERTIES);
2014         if (ret) {
2015                 return false;
2016         }
2017
2018         test_CloseGroup_int(tctx, t->p, &hGroup);
2019
2020         return ret;
2021 }
2022
2023 static bool test_OnlineGroup_int(struct torture_context *tctx,
2024                                  struct dcerpc_pipe *p,
2025                                  struct policy_handle *hGroup)
2026 {
2027         struct dcerpc_binding_handle *b = p->binding_handle;
2028         struct clusapi_OnlineGroup r;
2029         WERROR rpc_status;
2030
2031         r.in.hGroup = *hGroup;
2032         r.out.rpc_status = &rpc_status;
2033
2034         torture_assert_ntstatus_ok(tctx,
2035                 dcerpc_clusapi_OnlineGroup_r(b, tctx, &r),
2036                 "OnlineGroup failed");
2037         torture_assert_werr_ok(tctx,
2038                 r.out.result,
2039                 "OnlineGroup failed");
2040
2041         return true;
2042 }
2043
2044 static bool test_OnlineGroup(struct torture_context *tctx,
2045                              void *data)
2046 {
2047         struct torture_clusapi_context *t =
2048                 talloc_get_type_abort(data, struct torture_clusapi_context);
2049         struct policy_handle hGroup;
2050         bool ret = true;
2051
2052         if (!test_OpenGroup_int(tctx, t->p, "Cluster Group", &hGroup)) {
2053                 return false;
2054         }
2055
2056         ret = test_OnlineGroup_int(tctx, t->p, &hGroup);
2057
2058         test_CloseGroup_int(tctx, t->p, &hGroup);
2059
2060         return ret;
2061 }
2062
2063 static bool test_OfflineGroup_int(struct torture_context *tctx,
2064                                   struct dcerpc_pipe *p,
2065                                   struct policy_handle *hGroup)
2066 {
2067         struct dcerpc_binding_handle *b = p->binding_handle;
2068         struct clusapi_OfflineGroup r;
2069         WERROR rpc_status;
2070
2071         r.in.hGroup = *hGroup;
2072         r.out.rpc_status = &rpc_status;
2073
2074         torture_assert_ntstatus_ok(tctx,
2075                 dcerpc_clusapi_OfflineGroup_r(b, tctx, &r),
2076                 "OfflineGroup failed");
2077         torture_assert_werr_ok(tctx,
2078                 r.out.result,
2079                 "OfflineGroup failed");
2080
2081         return true;
2082 }
2083
2084 static bool test_OfflineGroup(struct torture_context *tctx,
2085                               void *data)
2086 {
2087         struct torture_clusapi_context *t =
2088                 talloc_get_type_abort(data, struct torture_clusapi_context);
2089         struct policy_handle hGroup;
2090         bool ret = true;
2091
2092         if (!test_OpenGroup_int(tctx, t->p, "Cluster Group", &hGroup)) {
2093                 return false;
2094         }
2095
2096         ret = test_OfflineGroup_int(tctx, t->p, &hGroup);
2097
2098         test_CloseGroup_int(tctx, t->p, &hGroup);
2099
2100         return ret;
2101 }
2102
2103 static bool test_one_group(struct torture_context *tctx,
2104                            struct dcerpc_pipe *p,
2105                            const char *node_name)
2106 {
2107         struct policy_handle hGroup;
2108
2109         torture_assert(tctx,
2110                 test_OpenGroup_int(tctx, p, node_name, &hGroup),
2111                 "failed to open group");
2112         test_CloseGroup_int(tctx, p, &hGroup);
2113
2114         torture_assert(tctx,
2115                 test_OpenGroupEx_int(tctx, p, node_name, &hGroup),
2116                 "failed to openex group");
2117
2118         torture_assert(tctx,
2119                 test_GetGroupId_int(tctx, p, &hGroup),
2120                 "failed to query group id");
2121         torture_assert(tctx,
2122                 test_GetGroupState_int(tctx, p, &hGroup),
2123                 "failed to query group id");
2124
2125         test_CloseGroup_int(tctx, p, &hGroup);
2126
2127         return true;
2128 }
2129
2130 static bool test_all_groups(struct torture_context *tctx,
2131                             void *data)
2132 {
2133         struct torture_clusapi_context *t =
2134                 talloc_get_type_abort(data, struct torture_clusapi_context);
2135         struct dcerpc_binding_handle *b = t->p->binding_handle;
2136         struct clusapi_CreateEnum r;
2137         uint32_t dwType = CLUSTER_ENUM_GROUP;
2138         struct ENUM_LIST *ReturnEnum;
2139         WERROR rpc_status;
2140         int i;
2141
2142         r.in.dwType = dwType;
2143         r.out.ReturnEnum = &ReturnEnum;
2144         r.out.rpc_status = &rpc_status;
2145
2146         torture_assert_ntstatus_ok(tctx,
2147                 dcerpc_clusapi_CreateEnum_r(b, tctx, &r),
2148                 "CreateEnum failed");
2149         torture_assert_werr_ok(tctx,
2150                 r.out.result,
2151                 "CreateEnum failed");
2152
2153         for (i=0; i < ReturnEnum->EntryCount; i++) {
2154
2155                 struct ENUM_ENTRY e = ReturnEnum->Entry[i];
2156
2157                 torture_assert_int_equal(tctx, e.Type, CLUSTER_ENUM_GROUP, "type mismatch");
2158
2159                 torture_assert(tctx,
2160                         test_one_group(tctx, t->p, e.Name),
2161                         "failed to test one group");
2162         }
2163
2164         return true;
2165 }
2166
2167 static bool test_BackupClusterDatabase(struct torture_context *tctx,
2168                                        void *data)
2169 {
2170         struct torture_clusapi_context *t =
2171                 talloc_get_type_abort(data, struct torture_clusapi_context);
2172         struct dcerpc_binding_handle *b = t->p->binding_handle;
2173         struct clusapi_BackupClusterDatabase r;
2174         WERROR rpc_status;
2175
2176         r.in.lpszPathName = "c:\\cluster_backup";
2177         r.out.rpc_status = &rpc_status;
2178
2179         torture_assert_ntstatus_ok(tctx,
2180                 dcerpc_clusapi_BackupClusterDatabase_r(b, tctx, &r),
2181                 "BackupClusterDatabase failed");
2182         torture_assert_werr_equal(tctx,
2183                 r.out.result,
2184                 WERR_CALL_NOT_IMPLEMENTED,
2185                 "BackupClusterDatabase failed");
2186
2187         return true;
2188 }
2189
2190 static bool test_SetServiceAccountPassword(struct torture_context *tctx,
2191                                            void *data)
2192 {
2193         struct torture_clusapi_context *t =
2194                 talloc_get_type_abort(data, struct torture_clusapi_context);
2195         struct dcerpc_binding_handle *b = t->p->binding_handle;
2196         struct clusapi_SetServiceAccountPassword r;
2197         uint32_t SizeReturned;
2198         uint32_t ExpectedBufferSize;
2199
2200         r.in.lpszNewPassword = "P@ssw0rd!";
2201         r.in.dwFlags = IDL_CLUSTER_SET_PASSWORD_IGNORE_DOWN_NODES;
2202         r.in.ReturnStatusBufferSize = 1024;
2203         r.out.ReturnStatusBufferPtr = NULL;
2204         r.out.SizeReturned = &SizeReturned;
2205         r.out.ExpectedBufferSize = &ExpectedBufferSize;
2206
2207         torture_assert_ntstatus_ok(tctx,
2208                 dcerpc_clusapi_SetServiceAccountPassword_r(b, tctx, &r),
2209                 "SetServiceAccountPassword failed");
2210         torture_assert_werr_equal(tctx,
2211                 r.out.result,
2212                 WERR_CALL_NOT_IMPLEMENTED,
2213                 "SetServiceAccountPassword failed");
2214
2215         return true;
2216 }
2217
2218 static bool test_ClusterControl_int(struct torture_context *tctx,
2219                                     struct dcerpc_pipe *p,
2220                                     struct policy_handle *Cluster)
2221 {
2222         struct dcerpc_binding_handle *b = p->binding_handle;
2223         struct clusapi_ClusterControl r;
2224         uint32_t lpBytesReturned;
2225         uint32_t lpcbRequired;
2226         WERROR rpc_status;
2227
2228         r.in.hCluster = *Cluster;
2229         r.in.dwControlCode = 0;
2230         r.in.lpInBuffer = NULL;
2231         r.in.nInBufferSize = 0;
2232         r.in.nOutBufferSize = 0;
2233         r.out.lpOutBuffer = NULL;
2234         r.out.lpBytesReturned = &lpBytesReturned;
2235         r.out.lpcbRequired = &lpcbRequired;
2236         r.out.rpc_status = &rpc_status;
2237
2238         torture_assert_ntstatus_ok(tctx,
2239                 dcerpc_clusapi_ClusterControl_r(b, tctx, &r),
2240                 "ClusterControl failed");
2241         torture_assert_werr_equal(tctx,
2242                 r.out.result,
2243                 WERR_INVALID_FUNCTION,
2244                 "ClusterControl failed");
2245
2246         r.in.dwControlCode = CLUSCTL_CLUSTER_GET_RO_COMMON_PROPERTIES;
2247
2248         torture_assert_ntstatus_ok(tctx,
2249                 dcerpc_clusapi_ClusterControl_r(b, tctx, &r),
2250                 "ClusterControl failed");
2251
2252         if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
2253                 r.out.lpOutBuffer = talloc_zero_array(tctx, uint8_t, *r.out.lpcbRequired);
2254                 r.in.nOutBufferSize = *r.out.lpcbRequired;
2255                 torture_assert_ntstatus_ok(tctx,
2256                         dcerpc_clusapi_ClusterControl_r(b, tctx, &r),
2257                         "ClusterControl failed");
2258         }
2259         torture_assert_werr_ok(tctx,
2260                 r.out.result,
2261                 "ClusterControl failed");
2262
2263         /* now try what happens when we query with a buffer large enough to hold
2264          * the entire packet */
2265
2266         r.in.nOutBufferSize = 0x400;
2267         r.out.lpOutBuffer = talloc_zero_array(tctx, uint8_t, r.in.nOutBufferSize);
2268
2269         torture_assert_ntstatus_ok(tctx,
2270                 dcerpc_clusapi_ClusterControl_r(b, tctx, &r),
2271                 "ClusterControl failed");
2272         torture_assert_werr_ok(tctx,
2273                 r.out.result,
2274                 "ClusterControl failed");
2275         torture_assert(tctx, *r.out.lpBytesReturned < r.in.nOutBufferSize,
2276                 "lpBytesReturned expected to be smaller than input size nOutBufferSize");
2277
2278         return true;
2279 }
2280
2281 static bool test_ClusterControl(struct torture_context *tctx,
2282                                 void *data)
2283 {
2284         struct torture_clusapi_context *t =
2285                 talloc_get_type_abort(data, struct torture_clusapi_context);
2286         struct policy_handle Cluster;
2287         bool ret;
2288
2289         if (!test_OpenCluster_int(tctx, t->p, &Cluster)) {
2290                 return false;
2291         }
2292
2293         ret = test_ClusterControl_int(tctx, t->p, &Cluster);
2294
2295         test_CloseCluster_int(tctx, t->p, &Cluster);
2296
2297         return ret;
2298 }
2299
2300 static bool test_OpenNetwork_int(struct torture_context *tctx,
2301                                  struct dcerpc_pipe *p,
2302                                  const char *lpszNetworkName,
2303                                  struct policy_handle *hNetwork)
2304 {
2305         struct dcerpc_binding_handle *b = p->binding_handle;
2306         struct clusapi_OpenNetwork r;
2307         WERROR Status;
2308         WERROR rpc_status;
2309
2310         r.in.lpszNetworkName = lpszNetworkName;
2311         r.out.rpc_status = &rpc_status;
2312         r.out.Status = &Status;
2313         r.out.hNetwork = hNetwork ;
2314
2315         torture_assert_ntstatus_ok(tctx,
2316                 dcerpc_clusapi_OpenNetwork_r(b, tctx, &r),
2317                 "OpenNetwork failed");
2318         torture_assert_werr_ok(tctx,
2319                 *r.out.Status,
2320                 "OpenNetwork failed");
2321
2322         return true;
2323 }
2324
2325 static bool test_OpenNetworkEx_int(struct torture_context *tctx,
2326                                    struct dcerpc_pipe *p,
2327                                    const char *lpszNetworkName,
2328                                    struct policy_handle *hNetwork)
2329 {
2330         struct dcerpc_binding_handle *b = p->binding_handle;
2331         struct clusapi_OpenNetworkEx r;
2332         uint32_t lpdwGrantedAccess;
2333         WERROR Status;
2334         WERROR rpc_status;
2335
2336         r.in.lpszNetworkName = lpszNetworkName;
2337         r.in.dwDesiredAccess = SEC_FLAG_MAXIMUM_ALLOWED;
2338         r.out.lpdwGrantedAccess = &lpdwGrantedAccess;
2339         r.out.rpc_status = &rpc_status;
2340         r.out.Status = &Status;
2341         r.out.hNetwork = hNetwork ;
2342
2343         torture_assert_ntstatus_ok(tctx,
2344                 dcerpc_clusapi_OpenNetworkEx_r(b, tctx, &r),
2345                 "OpenNetworkEx failed");
2346         torture_assert_werr_ok(tctx,
2347                 *r.out.Status,
2348                 "OpenNetworkEx failed");
2349
2350         return true;
2351 }
2352
2353 static bool test_CloseNetwork_int(struct torture_context *tctx,
2354                                   struct dcerpc_pipe *p,
2355                                   struct policy_handle *Network)
2356 {
2357         struct dcerpc_binding_handle *b = p->binding_handle;
2358         struct clusapi_CloseNetwork r;
2359
2360         r.in.Network = Network;
2361         r.out.Network = Network;
2362
2363         torture_assert_ntstatus_ok(tctx,
2364                 dcerpc_clusapi_CloseNetwork_r(b, tctx, &r),
2365                 "CloseNetwork failed");
2366         torture_assert_werr_ok(tctx,
2367                 r.out.result,
2368                 "CloseNetwork failed");
2369         torture_assert(tctx,
2370                 ndr_policy_handle_empty(Network),
2371                 "policy_handle non empty after CloseNetwork");
2372
2373         return true;
2374 }
2375
2376 static bool test_OpenNetwork(struct torture_context *tctx,
2377                              void *data)
2378 {
2379         struct torture_clusapi_context *t =
2380                 talloc_get_type_abort(data, struct torture_clusapi_context);
2381         struct policy_handle hNetwork;
2382
2383         if (!test_OpenNetwork_int(tctx, t->p, "Cluster Network 1", &hNetwork)) {
2384                 return false;
2385         }
2386
2387         test_CloseNetwork_int(tctx, t->p, &hNetwork);
2388
2389         return true;
2390 }
2391
2392 static bool test_OpenNetworkEx(struct torture_context *tctx,
2393                                void *data)
2394 {
2395         struct torture_clusapi_context *t =
2396                 talloc_get_type_abort(data, struct torture_clusapi_context);
2397         struct policy_handle hNetwork;
2398
2399         if (!test_OpenNetworkEx_int(tctx, t->p, "Cluster Network 1", &hNetwork)) {
2400                 return false;
2401         }
2402
2403         test_CloseNetwork_int(tctx, t->p, &hNetwork);
2404
2405         return true;
2406 }
2407
2408 static bool test_CloseNetwork(struct torture_context *tctx,
2409                               void *data)
2410 {
2411         struct torture_clusapi_context *t =
2412                 talloc_get_type_abort(data, struct torture_clusapi_context);
2413         struct policy_handle hNetwork;
2414
2415         if (!test_OpenNetwork_int(tctx, t->p, "Cluster Network 1", &hNetwork)) {
2416                 return false;
2417         }
2418
2419         return test_CloseNetwork_int(tctx, t->p, &hNetwork);
2420 }
2421
2422 static bool test_GetNetworkState_int(struct torture_context *tctx,
2423                                      struct dcerpc_pipe *p,
2424                                      struct policy_handle *hNetwork)
2425 {
2426         struct dcerpc_binding_handle *b = p->binding_handle;
2427         struct clusapi_GetNetworkState r;
2428         enum clusapi_ClusterNetworkState State;
2429         WERROR rpc_status;
2430
2431         r.in.hNetwork = *hNetwork;
2432         r.out.State = &State;
2433         r.out.rpc_status = &rpc_status;
2434
2435         torture_assert_ntstatus_ok(tctx,
2436                 dcerpc_clusapi_GetNetworkState_r(b, tctx, &r),
2437                 "GetNetworkState failed");
2438         torture_assert_werr_ok(tctx,
2439                 r.out.result,
2440                 "GetNetworkState failed");
2441
2442         return true;
2443 }
2444
2445 static bool test_GetNetworkState(struct torture_context *tctx,
2446                                  void *data)
2447 {
2448         struct torture_clusapi_context *t =
2449                 talloc_get_type_abort(data, struct torture_clusapi_context);
2450         struct policy_handle hNetwork;
2451         bool ret = true;
2452
2453         if (!test_OpenNetwork_int(tctx, t->p, "Cluster Network 1", &hNetwork)) {
2454                 return false;
2455         }
2456
2457         ret = test_GetNetworkState_int(tctx, t->p, &hNetwork);
2458
2459         test_CloseNetwork_int(tctx, t->p, &hNetwork);
2460
2461         return ret;
2462 }
2463
2464 static bool test_GetNetworkId_int(struct torture_context *tctx,
2465                                   struct dcerpc_pipe *p,
2466                                   struct policy_handle *hNetwork)
2467 {
2468         struct dcerpc_binding_handle *b = p->binding_handle;
2469         struct clusapi_GetNetworkId r;
2470         const char *pGuid;
2471         WERROR rpc_status;
2472
2473         r.in.hNetwork = *hNetwork;
2474         r.out.pGuid = &pGuid;
2475         r.out.rpc_status = &rpc_status;
2476
2477         torture_assert_ntstatus_ok(tctx,
2478                 dcerpc_clusapi_GetNetworkId_r(b, tctx, &r),
2479                 "GetNetworkId failed");
2480         torture_assert_werr_ok(tctx,
2481                 r.out.result,
2482                 "GetNetworkId failed");
2483
2484         return true;
2485 }
2486
2487 static bool test_GetNetworkId(struct torture_context *tctx,
2488                               void *data)
2489 {
2490         struct torture_clusapi_context *t =
2491                 talloc_get_type_abort(data, struct torture_clusapi_context);
2492         struct policy_handle hNetwork;
2493         bool ret = true;
2494
2495         if (!test_OpenNetwork_int(tctx, t->p, "Cluster Network 1", &hNetwork)) {
2496                 return false;
2497         }
2498
2499         ret = test_GetNetworkId_int(tctx, t->p, &hNetwork);
2500
2501         test_CloseNetwork_int(tctx, t->p, &hNetwork);
2502
2503         return ret;
2504 }
2505
2506 static bool test_one_network(struct torture_context *tctx,
2507                              struct dcerpc_pipe *p,
2508                              const char *network_name)
2509 {
2510         struct policy_handle hNetwork;
2511
2512         torture_assert(tctx,
2513                 test_OpenNetwork_int(tctx, p, network_name, &hNetwork),
2514                 "failed to open network");
2515         test_CloseNetwork_int(tctx, p, &hNetwork);
2516
2517         torture_assert(tctx,
2518                 test_OpenNetworkEx_int(tctx, p, network_name, &hNetwork),
2519                 "failed to openex network");
2520
2521         torture_assert(tctx,
2522                 test_GetNetworkId_int(tctx, p, &hNetwork),
2523                 "failed to query network id");
2524         torture_assert(tctx,
2525                 test_GetNetworkState_int(tctx, p, &hNetwork),
2526                 "failed to query network id");
2527
2528         test_CloseNetwork_int(tctx, p, &hNetwork);
2529
2530         return true;
2531 }
2532
2533 static bool test_all_networks(struct torture_context *tctx,
2534                               void *data)
2535 {
2536         struct torture_clusapi_context *t =
2537                 talloc_get_type_abort(data, struct torture_clusapi_context);
2538         struct dcerpc_binding_handle *b = t->p->binding_handle;
2539         struct clusapi_CreateEnum r;
2540         uint32_t dwType = CLUSTER_ENUM_NETWORK;
2541         struct ENUM_LIST *ReturnEnum;
2542         WERROR rpc_status;
2543         int i;
2544
2545         r.in.dwType = dwType;
2546         r.out.ReturnEnum = &ReturnEnum;
2547         r.out.rpc_status = &rpc_status;
2548
2549         torture_assert_ntstatus_ok(tctx,
2550                 dcerpc_clusapi_CreateEnum_r(b, tctx, &r),
2551                 "CreateEnum failed");
2552         torture_assert_werr_ok(tctx,
2553                 r.out.result,
2554                 "CreateEnum failed");
2555
2556         for (i=0; i < ReturnEnum->EntryCount; i++) {
2557
2558                 struct ENUM_ENTRY e = ReturnEnum->Entry[i];
2559
2560                 torture_assert_int_equal(tctx, e.Type, CLUSTER_ENUM_NETWORK, "type mismatch");
2561
2562                 torture_assert(tctx,
2563                         test_one_network(tctx, t->p, e.Name),
2564                         "failed to test one network");
2565         }
2566
2567         return true;
2568 }
2569
2570 static bool test_OpenNetInterface_int(struct torture_context *tctx,
2571                                       struct dcerpc_pipe *p,
2572                                       const char *lpszNetInterfaceName,
2573                                       struct policy_handle *hNetInterface)
2574 {
2575         struct dcerpc_binding_handle *b = p->binding_handle;
2576         struct clusapi_OpenNetInterface r;
2577         WERROR Status;
2578         WERROR rpc_status;
2579
2580         r.in.lpszNetInterfaceName = lpszNetInterfaceName;
2581         r.out.rpc_status = &rpc_status;
2582         r.out.Status = &Status;
2583         r.out.hNetInterface = hNetInterface;
2584
2585         torture_assert_ntstatus_ok(tctx,
2586                 dcerpc_clusapi_OpenNetInterface_r(b, tctx, &r),
2587                 "OpenNetInterface failed");
2588         torture_assert_werr_ok(tctx,
2589                 *r.out.Status,
2590                 "OpenNetInterface failed");
2591
2592         return true;
2593 }
2594
2595 static bool test_OpenNetInterfaceEx_int(struct torture_context *tctx,
2596                                         struct dcerpc_pipe *p,
2597                                         const char *lpszNetInterfaceName,
2598                                         struct policy_handle *hNetInterface)
2599 {
2600         struct dcerpc_binding_handle *b = p->binding_handle;
2601         struct clusapi_OpenNetInterfaceEx r;
2602         uint32_t lpdwGrantedAccess;
2603         WERROR Status;
2604         WERROR rpc_status;
2605
2606         r.in.lpszNetInterfaceName = lpszNetInterfaceName;
2607         r.in.dwDesiredAccess = SEC_FLAG_MAXIMUM_ALLOWED;
2608         r.out.lpdwGrantedAccess = &lpdwGrantedAccess;
2609         r.out.rpc_status = &rpc_status;
2610         r.out.Status = &Status;
2611         r.out.hNetInterface = hNetInterface;
2612
2613         torture_assert_ntstatus_ok(tctx,
2614                 dcerpc_clusapi_OpenNetInterfaceEx_r(b, tctx, &r),
2615                 "OpenNetInterfaceEx failed");
2616         torture_assert_werr_ok(tctx,
2617                 *r.out.Status,
2618                 "OpenNetInterfaceEx failed");
2619
2620         return true;
2621 }
2622
2623 static bool test_CloseNetInterface_int(struct torture_context *tctx,
2624                                        struct dcerpc_pipe *p,
2625                                        struct policy_handle *NetInterface)
2626 {
2627         struct dcerpc_binding_handle *b = p->binding_handle;
2628         struct clusapi_CloseNetInterface r;
2629
2630         r.in.NetInterface = NetInterface;
2631         r.out.NetInterface = NetInterface;
2632
2633         torture_assert_ntstatus_ok(tctx,
2634                 dcerpc_clusapi_CloseNetInterface_r(b, tctx, &r),
2635                 "CloseNetInterface failed");
2636         torture_assert_werr_ok(tctx,
2637                 r.out.result,
2638                 "CloseNetInterface failed");
2639         torture_assert(tctx,
2640                 ndr_policy_handle_empty(NetInterface),
2641                 "policy_handle non empty after CloseNetInterface");
2642
2643         return true;
2644 }
2645
2646 static bool test_OpenNetInterface(struct torture_context *tctx,
2647                                   void *data)
2648 {
2649         struct torture_clusapi_context *t =
2650                 talloc_get_type_abort(data, struct torture_clusapi_context);
2651         struct policy_handle hNetInterface;
2652
2653         if (!test_OpenNetInterface_int(tctx, t->p, "node1 - Ethernet", &hNetInterface)) {
2654                 return false;
2655         }
2656
2657         test_CloseNetInterface_int(tctx, t->p, &hNetInterface);
2658
2659         return true;
2660 }
2661
2662 static bool test_OpenNetInterfaceEx(struct torture_context *tctx,
2663                                     void *data)
2664 {
2665         struct torture_clusapi_context *t =
2666                 talloc_get_type_abort(data, struct torture_clusapi_context);
2667         struct policy_handle hNetInterface;
2668
2669         if (!test_OpenNetInterfaceEx_int(tctx, t->p, "node1 - Ethernet", &hNetInterface)) {
2670                 return false;
2671         }
2672
2673         test_CloseNetInterface_int(tctx, t->p, &hNetInterface);
2674
2675         return true;
2676 }
2677
2678 static bool test_CloseNetInterface(struct torture_context *tctx,
2679                                    void *data)
2680 {
2681         struct torture_clusapi_context *t =
2682                 talloc_get_type_abort(data, struct torture_clusapi_context);
2683         struct policy_handle hNetInterface;
2684
2685         if (!test_OpenNetInterface_int(tctx, t->p, "node1 - Ethernet", &hNetInterface)) {
2686                 return false;
2687         }
2688
2689         return test_CloseNetInterface_int(tctx, t->p, &hNetInterface);
2690 }
2691
2692 static bool test_GetNetInterfaceState_int(struct torture_context *tctx,
2693                                           struct dcerpc_pipe *p,
2694                                           struct policy_handle *hNetInterface)
2695 {
2696         struct dcerpc_binding_handle *b = p->binding_handle;
2697         struct clusapi_GetNetInterfaceState r;
2698         enum clusapi_ClusterNetInterfaceState State;
2699         WERROR rpc_status;
2700
2701         r.in.hNetInterface = *hNetInterface;
2702         r.out.State = &State;
2703         r.out.rpc_status = &rpc_status;
2704
2705         torture_assert_ntstatus_ok(tctx,
2706                 dcerpc_clusapi_GetNetInterfaceState_r(b, tctx, &r),
2707                 "GetNetInterfaceState failed");
2708         torture_assert_werr_ok(tctx,
2709                 r.out.result,
2710                 "GetNetInterfaceState failed");
2711
2712         return true;
2713 }
2714
2715 static bool test_GetNetInterfaceState(struct torture_context *tctx,
2716                                       void *data)
2717 {
2718         struct torture_clusapi_context *t =
2719                 talloc_get_type_abort(data, struct torture_clusapi_context);
2720         struct policy_handle hNetInterface;
2721         bool ret = true;
2722
2723         if (!test_OpenNetInterface_int(tctx, t->p, "node1 - Ethernet", &hNetInterface)) {
2724                 return false;
2725         }
2726
2727         ret = test_GetNetInterfaceState_int(tctx, t->p, &hNetInterface);
2728
2729         test_CloseNetInterface_int(tctx, t->p, &hNetInterface);
2730
2731         return ret;
2732 }
2733
2734 static bool test_GetNetInterfaceId_int(struct torture_context *tctx,
2735                                        struct dcerpc_pipe *p,
2736                                        struct policy_handle *hNetInterface)
2737 {
2738         struct dcerpc_binding_handle *b = p->binding_handle;
2739         struct clusapi_GetNetInterfaceId r;
2740         const char *pGuid;
2741         WERROR rpc_status;
2742
2743         r.in.hNetInterface = *hNetInterface;
2744         r.out.pGuid = &pGuid;
2745         r.out.rpc_status = &rpc_status;
2746
2747         torture_assert_ntstatus_ok(tctx,
2748                 dcerpc_clusapi_GetNetInterfaceId_r(b, tctx, &r),
2749                 "GetNetInterfaceId failed");
2750         torture_assert_werr_ok(tctx,
2751                 r.out.result,
2752                 "GetNetInterfaceId failed");
2753
2754         return true;
2755 }
2756
2757 static bool test_GetNetInterfaceId(struct torture_context *tctx,
2758                                    void *data)
2759 {
2760         struct torture_clusapi_context *t =
2761                 talloc_get_type_abort(data, struct torture_clusapi_context);
2762         struct policy_handle hNetInterface;
2763         bool ret = true;
2764
2765         if (!test_OpenNetInterface_int(tctx, t->p, "node1 - Ethernet", &hNetInterface)) {
2766                 return false;
2767         }
2768
2769         ret = test_GetNetInterfaceId_int(tctx, t->p, &hNetInterface);
2770
2771         test_CloseNetInterface_int(tctx, t->p, &hNetInterface);
2772
2773         return ret;
2774 }
2775
2776 static bool test_one_netinterface(struct torture_context *tctx,
2777                                   struct dcerpc_pipe *p,
2778                                   const char *netinterface_name)
2779 {
2780         struct policy_handle hNetInterface;
2781
2782         torture_assert(tctx,
2783                 test_OpenNetInterface_int(tctx, p, netinterface_name, &hNetInterface),
2784                 "failed to open netinterface");
2785         test_CloseNetInterface_int(tctx, p, &hNetInterface);
2786
2787         torture_assert(tctx,
2788                 test_OpenNetInterfaceEx_int(tctx, p, netinterface_name, &hNetInterface),
2789                 "failed to openex netinterface");
2790
2791         torture_assert(tctx,
2792                 test_GetNetInterfaceId_int(tctx, p, &hNetInterface),
2793                 "failed to query netinterface id");
2794         torture_assert(tctx,
2795                 test_GetNetInterfaceState_int(tctx, p, &hNetInterface),
2796                 "failed to query netinterface id");
2797
2798         test_CloseNetInterface_int(tctx, p, &hNetInterface);
2799
2800         return true;
2801 }
2802
2803 static bool test_all_netinterfaces(struct torture_context *tctx,
2804                                    void *data)
2805 {
2806         struct torture_clusapi_context *t =
2807                 talloc_get_type_abort(data, struct torture_clusapi_context);
2808         struct dcerpc_binding_handle *b = t->p->binding_handle;
2809         struct clusapi_CreateEnum r;
2810         uint32_t dwType = CLUSTER_ENUM_NETINTERFACE;
2811         struct ENUM_LIST *ReturnEnum;
2812         WERROR rpc_status;
2813         int i;
2814
2815         r.in.dwType = dwType;
2816         r.out.ReturnEnum = &ReturnEnum;
2817         r.out.rpc_status = &rpc_status;
2818
2819         torture_assert_ntstatus_ok(tctx,
2820                 dcerpc_clusapi_CreateEnum_r(b, tctx, &r),
2821                 "CreateEnum failed");
2822         torture_assert_werr_ok(tctx,
2823                 r.out.result,
2824                 "CreateEnum failed");
2825
2826         for (i=0; i < ReturnEnum->EntryCount; i++) {
2827
2828                 struct ENUM_ENTRY e = ReturnEnum->Entry[i];
2829
2830                 torture_assert_int_equal(tctx, e.Type, CLUSTER_ENUM_NETINTERFACE, "type mismatch");
2831
2832                 torture_assert(tctx,
2833                         test_one_netinterface(tctx, t->p, e.Name),
2834                         "failed to test one netinterface");
2835         }
2836
2837         return true;
2838 }
2839
2840 static bool test_CloseKey_int(struct torture_context *tctx,
2841                               struct dcerpc_pipe *p,
2842                               struct policy_handle *pKey)
2843 {
2844         struct dcerpc_binding_handle *b = p->binding_handle;
2845         struct clusapi_CloseKey r;
2846
2847         r.in.pKey = pKey;
2848         r.out.pKey = pKey;
2849
2850         torture_assert_ntstatus_ok(tctx,
2851                 dcerpc_clusapi_CloseKey_r(b, tctx, &r),
2852                 "CloseKey failed");
2853         torture_assert_werr_ok(tctx,
2854                 r.out.result,
2855                 "CloseKey failed");
2856         torture_assert(tctx,
2857                 ndr_policy_handle_empty(pKey),
2858                 "policy_handle non empty after CloseKey");
2859
2860         return true;
2861 }
2862
2863 static bool test_GetRootKey_int(struct torture_context *tctx,
2864                                 struct dcerpc_pipe *p,
2865                                 struct policy_handle *phKey)
2866 {
2867         struct dcerpc_binding_handle *b = p->binding_handle;
2868         struct clusapi_GetRootKey r;
2869         WERROR Status;
2870         WERROR rpc_status;
2871
2872         r.in.samDesired = SEC_FLAG_MAXIMUM_ALLOWED;
2873         r.out.Status = &Status;
2874         r.out.rpc_status = &rpc_status;
2875         r.out.phKey = phKey;
2876
2877         torture_assert_ntstatus_ok(tctx,
2878                 dcerpc_clusapi_GetRootKey_r(b, tctx, &r),
2879                 "GetRootKey failed");
2880         torture_assert_werr_ok(tctx,
2881                 *r.out.Status,
2882                 "GetRootKey failed");
2883
2884         return true;
2885 }
2886
2887 static bool test_EnumKey_int(struct torture_context *tctx,
2888                              struct dcerpc_pipe *p,
2889                              struct policy_handle *hKey)
2890 {
2891         struct dcerpc_binding_handle *b = p->binding_handle;
2892         struct clusapi_EnumKey r;
2893         const char *KeyName;
2894         NTTIME lpftLastWriteTime;
2895         WERROR rpc_status;
2896
2897         r.in.hKey = *hKey;
2898         r.in.dwIndex = 0;
2899         r.out.KeyName = &KeyName;
2900         r.out.lpftLastWriteTime = &lpftLastWriteTime;
2901         r.out.rpc_status = &rpc_status;
2902
2903         torture_assert_ntstatus_ok(tctx,
2904                 dcerpc_clusapi_EnumKey_r(b, tctx, &r),
2905                 "EnumKey failed");
2906         torture_assert_werr_ok(tctx,
2907                 r.out.result,
2908                 "EnumKey failed");
2909
2910         return true;
2911 }
2912
2913 static bool test_OpenKey_int(struct torture_context *tctx,
2914                              struct dcerpc_pipe *p,
2915                              struct policy_handle *hKey,
2916                              const char *lpSubKey,
2917                              struct policy_handle *phKey)
2918 {
2919         struct dcerpc_binding_handle *b = p->binding_handle;
2920         struct clusapi_OpenKey r;
2921         WERROR Status;
2922         WERROR rpc_status;
2923
2924         r.in.hKey = *hKey;
2925         r.in.lpSubKey = lpSubKey;
2926         r.in.samDesired = SEC_FLAG_MAXIMUM_ALLOWED;
2927         r.out.Status = &Status;
2928         r.out.rpc_status = &rpc_status;
2929         r.out.phKey = phKey;
2930
2931         torture_assert_ntstatus_ok(tctx,
2932                 dcerpc_clusapi_OpenKey_r(b, tctx, &r),
2933                 "OpenKey failed");
2934         torture_assert_werr_ok(tctx,
2935                 *r.out.Status,
2936                 "OpenKey failed");
2937
2938         return true;
2939 }
2940
2941 static bool test_EnumValue_int(struct torture_context *tctx,
2942                                struct dcerpc_pipe *p,
2943                                struct policy_handle *hKey)
2944 {
2945         struct dcerpc_binding_handle *b = p->binding_handle;
2946         struct clusapi_EnumValue r;
2947         const char *lpValueName;
2948         uint32_t lpType;
2949         uint32_t TotalSize;
2950         WERROR rpc_status;
2951         int i = 0;
2952
2953         do {
2954                 uint32_t lpcbData = 1024;
2955
2956                 r.in.hKey = *hKey;
2957                 r.in.dwIndex = i++;
2958                 r.in.lpcbData = &lpcbData;
2959                 r.out.lpValueName = &lpValueName;
2960                 r.out.lpType = &lpType;
2961                 r.out.lpData = talloc_array(tctx, uint8_t, lpcbData);
2962                 r.out.TotalSize = &TotalSize;
2963                 r.out.rpc_status = &rpc_status;
2964                 r.out.lpcbData = &lpcbData;
2965
2966                 torture_assert_ntstatus_ok(tctx,
2967                         dcerpc_clusapi_EnumValue_r(b, tctx, &r),
2968                         "EnumValue failed");
2969
2970         } while (W_ERROR_IS_OK(r.out.result));
2971
2972         torture_assert_werr_equal(tctx,
2973                 r.out.result,
2974                 WERR_NO_MORE_ITEMS,
2975                 "EnumValue failed");
2976
2977         return true;
2978 }
2979
2980 static bool test_QueryInfoKey_int(struct torture_context *tctx,
2981                                   struct dcerpc_pipe *p,
2982                                   struct policy_handle *hKey)
2983 {
2984         struct dcerpc_binding_handle *b = p->binding_handle;
2985         struct clusapi_QueryInfoKey r;
2986         uint32_t lpcSubKeys;
2987         uint32_t lpcbMaxSubKeyLen;
2988         uint32_t lpcValues;
2989         uint32_t lpcbMaxValueNameLen;
2990         uint32_t lpcbMaxValueLen;
2991         uint32_t lpcbSecurityDescriptor;
2992         NTTIME lpftLastWriteTime;
2993         WERROR rpc_status;
2994
2995         r.in.hKey = *hKey;
2996         r.out.lpcSubKeys = &lpcSubKeys;
2997         r.out.lpcbMaxSubKeyLen = &lpcbMaxSubKeyLen;
2998         r.out.lpcValues = &lpcValues;
2999         r.out.lpcbMaxValueNameLen = &lpcbMaxValueNameLen;
3000         r.out.lpcbMaxValueLen = &lpcbMaxValueLen;
3001         r.out.lpcbSecurityDescriptor = &lpcbSecurityDescriptor;
3002         r.out.lpftLastWriteTime = &lpftLastWriteTime;
3003         r.out.rpc_status = &rpc_status;
3004
3005         torture_assert_ntstatus_ok(tctx,
3006                 dcerpc_clusapi_QueryInfoKey_r(b, tctx, &r),
3007                 "QueryInfoKey failed");
3008         torture_assert_werr_ok(tctx,
3009                 r.out.result,
3010                 "QueryInfoKey failed");
3011
3012         return true;
3013 }
3014
3015 static bool test_GetKeySecurity_int(struct torture_context *tctx,
3016                                     struct dcerpc_pipe *p,
3017                                     struct policy_handle *hKey)
3018 {
3019         struct dcerpc_binding_handle *b = p->binding_handle;
3020         struct clusapi_GetKeySecurity r;
3021         uint32_t SecurityInformation = SECINFO_DACL | SECINFO_OWNER | SECINFO_GROUP;
3022         struct RPC_SECURITY_DESCRIPTOR pRpcSecurityDescriptor;
3023         WERROR rpc_status;
3024
3025         ZERO_STRUCT(pRpcSecurityDescriptor);
3026
3027         r.in.hKey = *hKey;
3028         r.in.SecurityInformation = SecurityInformation;
3029         r.in.pRpcSecurityDescriptor = &pRpcSecurityDescriptor;
3030         r.out.rpc_status = &rpc_status;
3031         r.out.pRpcSecurityDescriptor = &pRpcSecurityDescriptor;
3032
3033         torture_assert_ntstatus_ok(tctx,
3034                 dcerpc_clusapi_GetKeySecurity_r(b, tctx, &r),
3035                 "GetKeySecurity failed");
3036
3037         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
3038                 pRpcSecurityDescriptor.lpSecurityDescriptor = talloc_array(tctx,
3039                 uint8_t, pRpcSecurityDescriptor.cbInSecurityDescriptor);
3040
3041                 torture_assert_ntstatus_ok(tctx,
3042                         dcerpc_clusapi_GetKeySecurity_r(b, tctx, &r),
3043                         "GetKeySecurity failed");
3044         }
3045
3046         torture_assert_werr_ok(tctx,
3047                 r.out.result,
3048                 "GetKeySecurity failed");
3049
3050         return true;
3051 }
3052
3053 static bool test_GetRootKey(struct torture_context *tctx,
3054                             void *data)
3055 {
3056         struct torture_clusapi_context *t =
3057                 talloc_get_type_abort(data, struct torture_clusapi_context);
3058         struct policy_handle hKey;
3059
3060         if (!test_GetRootKey_int(tctx, t->p, &hKey)) {
3061                 return false;
3062         }
3063
3064         test_CloseKey_int(tctx, t->p, &hKey);
3065
3066         return true;
3067 }
3068
3069 static bool test_CloseKey(struct torture_context *tctx,
3070                           void *data)
3071 {
3072         struct torture_clusapi_context *t =
3073                 talloc_get_type_abort(data, struct torture_clusapi_context);
3074         struct policy_handle hKey;
3075
3076         if (!test_GetRootKey_int(tctx, t->p, &hKey)) {
3077                 return false;
3078         }
3079
3080         return test_CloseKey_int(tctx, t->p, &hKey);
3081 }
3082
3083 static bool test_EnumKey(struct torture_context *tctx,
3084                          void *data)
3085 {
3086         struct torture_clusapi_context *t =
3087                 talloc_get_type_abort(data, struct torture_clusapi_context);
3088         struct policy_handle hKey;
3089         bool ret = true;
3090
3091         if (!test_GetRootKey_int(tctx, t->p, &hKey)) {
3092                 return false;
3093         }
3094
3095         ret = test_EnumKey_int(tctx, t->p, &hKey);
3096
3097         test_CloseKey_int(tctx, t->p, &hKey);
3098
3099         return ret;
3100 }
3101
3102 static bool test_QueryValue_int(struct torture_context *tctx,
3103                                 struct dcerpc_pipe *p,
3104                                 struct policy_handle *hKey,
3105                                 const char *ValueName)
3106 {
3107         struct dcerpc_binding_handle *b = p->binding_handle;
3108         struct clusapi_QueryValue r;
3109         uint32_t lpValueType;
3110         uint32_t lpcbRequired;
3111         WERROR rpc_status;
3112
3113         r.in.hKey = *hKey;
3114         r.in.lpValueName = ValueName;
3115         r.in.cbData = 0;
3116         r.out.lpValueType = &lpValueType;
3117         r.out.lpData = NULL;
3118         r.out.lpcbRequired = &lpcbRequired;
3119         r.out.rpc_status = &rpc_status;
3120
3121         torture_assert_ntstatus_ok(tctx,
3122                 dcerpc_clusapi_QueryValue_r(b, tctx, &r),
3123                 "QueryValue failed");
3124
3125         if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
3126
3127                 r.in.cbData = lpcbRequired;
3128                 r.out.lpData = talloc_zero_array(tctx, uint8_t, r.in.cbData);
3129
3130                 torture_assert_ntstatus_ok(tctx,
3131                         dcerpc_clusapi_QueryValue_r(b, tctx, &r),
3132                         "QueryValue failed");
3133         }
3134
3135         torture_assert_werr_ok(tctx,
3136                 r.out.result,
3137                 "QueryValue failed");
3138
3139         if (lpValueType == REG_SZ) {
3140                 const char *s;
3141                 DATA_BLOB blob = data_blob_const(r.out.lpData, lpcbRequired);
3142                 pull_reg_sz(tctx, &blob, &s);
3143                 torture_comment(tctx, "got: %s\n", s);
3144         }
3145
3146         return true;
3147 }
3148
3149 static bool test_QueryValue(struct torture_context *tctx,
3150                             void *data)
3151 {
3152         struct torture_clusapi_context *t =
3153                 talloc_get_type_abort(data, struct torture_clusapi_context);
3154         struct policy_handle hKey;
3155         bool ret = true;
3156
3157         if (!test_GetRootKey_int(tctx, t->p, &hKey)) {
3158                 return false;
3159         }
3160
3161         ret = test_QueryValue_int(tctx, t->p, &hKey, "ClusterInstanceID");
3162
3163         test_CloseKey_int(tctx, t->p, &hKey);
3164
3165         return ret;
3166 }
3167
3168
3169 static bool test_one_key(struct torture_context *tctx,
3170                          struct dcerpc_pipe *p,
3171                          struct policy_handle *hKey,
3172                          const char *KeyName)
3173 {
3174         struct policy_handle phKey;
3175
3176         torture_assert(tctx,
3177                 test_OpenKey_int(tctx, p, hKey, KeyName, &phKey),
3178                 "failed to open key");
3179
3180         torture_assert(tctx,
3181                 test_QueryInfoKey_int(tctx, p, &phKey),
3182                 "failed to enum values");
3183         torture_assert(tctx,
3184                 test_GetKeySecurity_int(tctx, p, &phKey),
3185                 "failed to get key security");
3186
3187         torture_assert(tctx,
3188                 test_EnumValue_int(tctx, p, &phKey),
3189                 "failed to enum values");
3190
3191         torture_assert(tctx,
3192                 test_CloseKey_int(tctx, p, &phKey),
3193                 "failed to close key");
3194
3195         return true;
3196 }
3197
3198 static bool test_all_keys(struct torture_context *tctx,
3199                           void *data)
3200 {
3201         struct torture_clusapi_context *t =
3202                 talloc_get_type_abort(data, struct torture_clusapi_context);
3203         struct dcerpc_binding_handle *b = t->p->binding_handle;
3204         struct policy_handle hKey;
3205         struct clusapi_EnumKey r;
3206         const char *KeyName;
3207         NTTIME lpftLastWriteTime;
3208         WERROR rpc_status;
3209         int i = 0;
3210
3211         if (!test_GetRootKey_int(tctx, t->p, &hKey)) {
3212                 return false;
3213         }
3214
3215         do {
3216                 r.in.hKey = hKey;
3217                 r.in.dwIndex = i++;
3218                 r.out.KeyName = &KeyName;
3219                 r.out.lpftLastWriteTime = &lpftLastWriteTime;
3220                 r.out.rpc_status = &rpc_status;
3221
3222                 torture_assert_ntstatus_ok(tctx,
3223                         dcerpc_clusapi_EnumKey_r(b, tctx, &r),
3224                         "EnumKey failed");
3225
3226                 if (W_ERROR_IS_OK(r.out.result)) {
3227                         torture_assert(tctx,
3228                                 test_one_key(tctx, t->p, &hKey, KeyName),
3229                                 "failed to test one key");
3230                 }
3231
3232         } while (W_ERROR_IS_OK(r.out.result));
3233
3234         torture_assert_werr_equal(tctx,
3235                 r.out.result,
3236                 WERR_NO_MORE_ITEMS,
3237                 "EnumKey failed");
3238
3239         test_CloseKey_int(tctx, t->p, &hKey);
3240
3241         return true;
3242 }
3243
3244 static bool torture_rpc_clusapi_setup_common(struct torture_context *tctx,
3245                                              struct torture_clusapi_context *t)
3246 {
3247         struct dcerpc_binding_handle *b;
3248
3249         torture_assert_ntstatus_ok(tctx,
3250                 torture_rpc_connection(tctx, &t->p, &ndr_table_clusapi),
3251                 "Error connecting to server");
3252
3253         {
3254                 struct clusapi_GetClusterName r;
3255
3256                 b = t->p->binding_handle;
3257
3258                 r.out.ClusterName = &t->ClusterName;
3259                 r.out.NodeName = &t->NodeName;
3260
3261                 torture_assert_ntstatus_ok(tctx,
3262                         dcerpc_clusapi_GetClusterName_r(b, tctx, &r),
3263                         "GetClusterName failed");
3264                 torture_assert_werr_ok(tctx,
3265                         r.out.result,
3266                         "GetClusterName failed");
3267         }
3268
3269         return true;
3270 }
3271
3272 static bool torture_rpc_clusapi_setup(struct torture_context *tctx,
3273                                       void **data)
3274 {
3275         struct torture_clusapi_context *t;
3276
3277         *data = t = talloc_zero(tctx, struct torture_clusapi_context);
3278
3279         return torture_rpc_clusapi_setup_common(tctx, t);
3280 }
3281
3282 static bool torture_rpc_clusapi_teardown(struct torture_context *tctx,
3283                                          void *data)
3284 {
3285         talloc_free(data);
3286
3287         return true;
3288 }
3289
3290 void torture_tcase_cluster(struct torture_tcase *tcase)
3291 {
3292         torture_tcase_add_simple_test(tcase, "OpenCluster",
3293                                       test_OpenCluster);
3294         torture_tcase_add_simple_test(tcase, "OpenClusterEx",
3295                                       test_OpenClusterEx);
3296         torture_tcase_add_simple_test(tcase, "CloseCluster",
3297                                       test_CloseCluster);
3298         torture_tcase_add_simple_test(tcase, "SetClusterName",
3299                                       test_SetClusterName);
3300         torture_tcase_add_simple_test(tcase, "GetClusterName",
3301                                       test_GetClusterName);
3302         torture_tcase_add_simple_test(tcase, "GetClusterVersion",
3303                                       test_GetClusterVersion);
3304         torture_tcase_add_simple_test(tcase, "CreateEnum",
3305                                       test_CreateEnum);
3306         torture_tcase_add_simple_test(tcase, "CreateEnumEx",
3307                                       test_CreateEnumEx);
3308         torture_tcase_add_simple_test(tcase, "GetClusterVersion2",
3309                                       test_GetClusterVersion2);
3310         torture_tcase_add_simple_test(tcase, "BackupClusterDatabase",
3311                                       test_BackupClusterDatabase);
3312         torture_tcase_add_simple_test(tcase, "SetServiceAccountPassword",
3313                                       test_SetServiceAccountPassword);
3314         torture_tcase_add_simple_test(tcase, "ClusterControl",
3315                                       test_ClusterControl);
3316
3317 }
3318
3319 void torture_tcase_resource(struct torture_tcase *tcase)
3320 {
3321         struct torture_test *test;
3322
3323         torture_tcase_add_simple_test(tcase, "GetQuorumResource",
3324                                       test_GetQuorumResource);
3325         torture_tcase_add_simple_test(tcase, "SetQuorumResource",
3326                                       test_SetQuorumResource);
3327         torture_tcase_add_simple_test(tcase, "OpenResource",
3328                                       test_OpenResource);
3329         torture_tcase_add_simple_test(tcase, "OpenResourceEx",
3330                                       test_OpenResourceEx);
3331         torture_tcase_add_simple_test(tcase, "CloseResource",
3332                                       test_CloseResource);
3333         torture_tcase_add_simple_test(tcase, "CreateResource",
3334                                       test_CreateResource);
3335         torture_tcase_add_simple_test(tcase, "DeleteResource",
3336                                       test_DeleteResource);
3337         torture_tcase_add_simple_test(tcase, "SetResourceName",
3338                                       test_SetResourceName);
3339         torture_tcase_add_simple_test(tcase, "GetResourceState",
3340                                       test_GetResourceState);
3341         torture_tcase_add_simple_test(tcase, "GetResourceId",
3342                                       test_GetResourceId);
3343         torture_tcase_add_simple_test(tcase, "GetResourceType",
3344                                       test_GetResourceType);
3345         torture_tcase_add_simple_test(tcase, "CreateResEnum",
3346                                       test_CreateResEnum);
3347         test = torture_tcase_add_simple_test(tcase, "FailResource",
3348                                       test_FailResource);
3349         test->dangerous = true;
3350         torture_tcase_add_simple_test(tcase, "OnlineResource",
3351                                       test_OnlineResource);
3352         test = torture_tcase_add_simple_test(tcase, "OfflineResource",
3353                                       test_OfflineResource);
3354         test->dangerous = true;
3355         torture_tcase_add_simple_test(tcase, "GetResourceDependencyExpression",
3356                                       test_GetResourceDependencyExpression);
3357         torture_tcase_add_simple_test(tcase, "GetResourceNetworkName",
3358                                       test_GetResourceNetworkName);
3359         torture_tcase_add_simple_test(tcase, "all_resources",
3360                                       test_all_resources);
3361 }
3362
3363 void torture_tcase_node(struct torture_tcase *tcase)
3364 {
3365         struct torture_test *test;
3366
3367         torture_tcase_add_simple_test(tcase, "OpenNode",
3368                                       test_OpenNode);
3369         torture_tcase_add_simple_test(tcase, "OpenNodeEx",
3370                                       test_OpenNodeEx);
3371         torture_tcase_add_simple_test(tcase, "CloseNode",
3372                                       test_CloseNode);
3373         torture_tcase_add_simple_test(tcase, "GetNodeState",
3374                                       test_GetNodeState);
3375         torture_tcase_add_simple_test(tcase, "GetNodeId",
3376                                       test_GetNodeId);
3377         torture_tcase_add_simple_test(tcase, "NodeControl",
3378                                       test_NodeControl);
3379         test = torture_tcase_add_simple_test(tcase, "PauseNode",
3380                                              test_PauseNode);
3381         test->dangerous = true;
3382         torture_tcase_add_simple_test(tcase, "ResumeNode",
3383                                       test_ResumeNode);
3384         test = torture_tcase_add_simple_test(tcase, "EvictNode",
3385                                              test_EvictNode);
3386         test->dangerous = true;
3387         torture_tcase_add_simple_test(tcase, "all_nodes",
3388                                       test_all_nodes);
3389 }
3390
3391 void torture_tcase_group(struct torture_tcase *tcase)
3392 {
3393         struct torture_test *test;
3394
3395         torture_tcase_add_simple_test(tcase, "OpenGroup",
3396                                       test_OpenGroup);
3397         torture_tcase_add_simple_test(tcase, "OpenGroupEx",
3398                                       test_OpenGroupEx);
3399         torture_tcase_add_simple_test(tcase, "CloseGroup",
3400                                       test_CloseGroup);
3401         torture_tcase_add_simple_test(tcase, "GetGroupState",
3402                                       test_GetGroupState);
3403         torture_tcase_add_simple_test(tcase, "GetGroupId",
3404                                       test_GetGroupId);
3405         torture_tcase_add_simple_test(tcase, "GroupControl",
3406                                       test_GroupControl);
3407         torture_tcase_add_simple_test(tcase, "OnlineGroup",
3408                                       test_OnlineGroup);
3409         test = torture_tcase_add_simple_test(tcase, "OfflineGroup",
3410                                       test_OfflineGroup);
3411         test->dangerous = true;
3412         torture_tcase_add_simple_test(tcase, "all_groups",
3413                                       test_all_groups);
3414 }
3415
3416 void torture_tcase_network(struct torture_tcase *tcase)
3417 {
3418         torture_tcase_add_simple_test(tcase, "OpenNetwork",
3419                                       test_OpenNetwork);
3420         torture_tcase_add_simple_test(tcase, "OpenNetworkEx",
3421                                       test_OpenNetworkEx);
3422         torture_tcase_add_simple_test(tcase, "CloseNetwork",
3423                                       test_CloseNetwork);
3424         torture_tcase_add_simple_test(tcase, "GetNetworkState",
3425                                       test_GetNetworkState);
3426         torture_tcase_add_simple_test(tcase, "GetNetworkId",
3427                                       test_GetNetworkId);
3428         torture_tcase_add_simple_test(tcase, "all_networks",
3429                                       test_all_networks);
3430 }
3431
3432 void torture_tcase_netinterface(struct torture_tcase *tcase)
3433 {
3434         torture_tcase_add_simple_test(tcase, "OpenNetInterface",
3435                                       test_OpenNetInterface);
3436         torture_tcase_add_simple_test(tcase, "OpenNetInterfaceEx",
3437                                       test_OpenNetInterfaceEx);
3438         torture_tcase_add_simple_test(tcase, "CloseNetInterface",
3439                                       test_CloseNetInterface);
3440         torture_tcase_add_simple_test(tcase, "GetNetInterfaceState",
3441                                       test_GetNetInterfaceState);
3442         torture_tcase_add_simple_test(tcase, "GetNetInterfaceId",
3443                                       test_GetNetInterfaceId);
3444         torture_tcase_add_simple_test(tcase, "all_netinterfaces",
3445                                       test_all_netinterfaces);
3446 }
3447
3448 void torture_tcase_registry(struct torture_tcase *tcase)
3449 {
3450         torture_tcase_add_simple_test(tcase, "GetRootKey",
3451                                       test_GetRootKey);
3452         torture_tcase_add_simple_test(tcase, "CloseKey",
3453                                       test_CloseKey);
3454         torture_tcase_add_simple_test(tcase, "EnumKey",
3455                                       test_EnumKey);
3456         torture_tcase_add_simple_test(tcase, "QueryValue",
3457                                       test_QueryValue);
3458         torture_tcase_add_simple_test(tcase, "all_keys",
3459                                       test_all_keys);
3460 }
3461
3462 struct torture_suite *torture_rpc_clusapi(TALLOC_CTX *mem_ctx)
3463 {
3464         struct torture_tcase *tcase;
3465         struct torture_suite *suite = torture_suite_create(mem_ctx, "clusapi");
3466
3467         tcase = torture_suite_add_tcase(suite, "cluster");
3468
3469         torture_tcase_set_fixture(tcase,
3470                                   torture_rpc_clusapi_setup,
3471                                   torture_rpc_clusapi_teardown);
3472
3473         torture_tcase_cluster(tcase);
3474
3475         tcase = torture_suite_add_tcase(suite, "resource");
3476
3477         torture_tcase_set_fixture(tcase,
3478                                   torture_rpc_clusapi_setup,
3479                                   torture_rpc_clusapi_teardown);
3480
3481         torture_tcase_resource(tcase);
3482
3483         tcase = torture_suite_add_tcase(suite, "node");
3484
3485         torture_tcase_set_fixture(tcase,
3486                                   torture_rpc_clusapi_setup,
3487                                   torture_rpc_clusapi_teardown);
3488
3489         torture_tcase_node(tcase);
3490
3491         tcase = torture_suite_add_tcase(suite, "group");
3492
3493         torture_tcase_set_fixture(tcase,
3494                                   torture_rpc_clusapi_setup,
3495                                   torture_rpc_clusapi_teardown);
3496
3497         torture_tcase_group(tcase);
3498
3499         tcase = torture_suite_add_tcase(suite, "network");
3500
3501         torture_tcase_set_fixture(tcase,
3502                                   torture_rpc_clusapi_setup,
3503                                   torture_rpc_clusapi_teardown);
3504
3505         torture_tcase_network(tcase);
3506
3507         tcase = torture_suite_add_tcase(suite, "netinterface");
3508
3509         torture_tcase_set_fixture(tcase,
3510                                   torture_rpc_clusapi_setup,
3511                                   torture_rpc_clusapi_teardown);
3512
3513         torture_tcase_netinterface(tcase);
3514
3515         tcase = torture_suite_add_tcase(suite, "registry");
3516
3517         torture_tcase_set_fixture(tcase,
3518                                   torture_rpc_clusapi_setup,
3519                                   torture_rpc_clusapi_teardown);
3520
3521         torture_tcase_registry(tcase);
3522
3523         return suite;
3524 }