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_ResourceTypeControl_int(struct torture_context *tctx,
1152                                          struct dcerpc_pipe *p,
1153                                          struct policy_handle *Cluster,
1154                                          const char *resource_type,
1155                                          enum clusapi_ResourceTypeControlCode dwControlCode)
1156 {
1157         struct dcerpc_binding_handle *b = p->binding_handle;
1158         struct clusapi_ResourceTypeControl r;
1159         uint32_t lpBytesReturned;
1160         uint32_t lpcbRequired;
1161         WERROR rpc_status;
1162
1163         r.in.hCluster = *Cluster;
1164         r.in.lpszResourceTypeName = resource_type;
1165         r.in.dwControlCode = 0;
1166         r.in.lpInBuffer = NULL;
1167         r.in.nInBufferSize = 0;
1168         r.in.nOutBufferSize = 0;
1169         r.out.lpOutBuffer = NULL;
1170         r.out.lpBytesReturned = &lpBytesReturned;
1171         r.out.lpcbRequired = &lpcbRequired;
1172         r.out.rpc_status = &rpc_status;
1173
1174         torture_assert_ntstatus_ok(tctx,
1175                 dcerpc_clusapi_ResourceTypeControl_r(b, tctx, &r),
1176                 "ResourceTypeControl failed");
1177
1178         if (strequal(r.in.lpszResourceTypeName, "MSMQ") ||
1179             strequal(r.in.lpszResourceTypeName, "MSMQTriggers")) {
1180                 torture_assert_werr_equal(tctx,
1181                         r.out.result,
1182                         WERR_CLUSTER_RESTYPE_NOT_SUPPORTED,
1183                         "ResourceTypeControl failed");
1184                 return true;
1185         }
1186
1187         torture_assert_werr_equal(tctx,
1188                 r.out.result,
1189                 WERR_INVALID_FUNCTION,
1190                 "ResourceTypeControl failed");
1191
1192         r.in.dwControlCode = dwControlCode;
1193
1194         torture_assert_ntstatus_ok(tctx,
1195                 dcerpc_clusapi_ResourceTypeControl_r(b, tctx, &r),
1196                 "ResourceTypeControl failed");
1197
1198         if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
1199                 r.out.lpOutBuffer = talloc_zero_array(tctx, uint8_t, *r.out.lpcbRequired);
1200                 r.in.nOutBufferSize = *r.out.lpcbRequired;
1201                 torture_assert_ntstatus_ok(tctx,
1202                         dcerpc_clusapi_ResourceTypeControl_r(b, tctx, &r),
1203                         "ResourceTypeControl failed");
1204         }
1205         torture_assert_werr_ok(tctx,
1206                 r.out.result,
1207                 "ResourceTypeControl failed");
1208
1209         /* now try what happens when we query with a buffer large enough to hold
1210          * the entire packet */
1211
1212         r.in.nOutBufferSize = 0x400;
1213         r.out.lpOutBuffer = talloc_zero_array(tctx, uint8_t, r.in.nOutBufferSize);
1214
1215         torture_assert_ntstatus_ok(tctx,
1216                 dcerpc_clusapi_ResourceTypeControl_r(b, tctx, &r),
1217                 "ResourceTypeControl failed");
1218         torture_assert_werr_ok(tctx,
1219                 r.out.result,
1220                 "ResourceTypeControl failed");
1221         torture_assert(tctx, *r.out.lpBytesReturned < r.in.nOutBufferSize,
1222                 "lpBytesReturned expected to be smaller than input size nOutBufferSize");
1223
1224         return true;
1225 }
1226
1227 static bool test_ResourceTypeControl(struct torture_context *tctx,
1228                                      struct dcerpc_pipe *p,
1229                                      const char *resourcetype_name)
1230 {
1231         struct policy_handle Cluster;
1232         bool ret;
1233         uint32_t control_codes[] = {
1234                 CLUSCTL_RESOURCE_TYPE_GET_CLASS_INFO,
1235                 CLUSCTL_RESOURCE_TYPE_GET_CHARACTERISTICS,
1236                 CLUSCTL_RESOURCE_TYPE_GET_COMMON_PROPERTIES,
1237                 CLUSCTL_RESOURCE_TYPE_GET_RO_COMMON_PROPERTIES,
1238                 CLUSCTL_RESOURCE_TYPE_GET_PRIVATE_PROPERTIES
1239         };
1240         int i;
1241
1242         if (!test_OpenCluster_int(tctx, p, &Cluster)) {
1243                 return false;
1244         }
1245
1246         for (i=0; i < ARRAY_SIZE(control_codes); i++) {
1247                 ret = test_ResourceTypeControl_int(tctx, p, &Cluster,
1248                                                    resourcetype_name,
1249                                                    control_codes[i]);
1250                 if (!ret) {
1251                         goto done;
1252                 }
1253         }
1254
1255  done:
1256         test_CloseCluster_int(tctx, p, &Cluster);
1257
1258         return ret;
1259 }
1260
1261
1262
1263 static bool test_one_resourcetype(struct torture_context *tctx,
1264                                   struct dcerpc_pipe *p,
1265                                   const char *resourcetype_name)
1266 {
1267         torture_assert(tctx,
1268                 test_ResourceTypeControl(tctx, p, resourcetype_name),
1269                 "failed to query ResourceTypeControl");
1270
1271         return true;
1272 }
1273
1274 static bool test_one_resource(struct torture_context *tctx,
1275                               struct dcerpc_pipe *p,
1276                               const char *resource_name)
1277 {
1278         struct policy_handle hResource;
1279
1280         torture_assert(tctx,
1281                 test_OpenResource_int(tctx, p, resource_name, &hResource),
1282                 "failed to open resource");
1283         test_CloseResource_int(tctx, p, &hResource);
1284
1285         torture_assert(tctx,
1286                 test_OpenResourceEx_int(tctx, p, resource_name, &hResource),
1287                 "failed to openex resource");
1288
1289         torture_assert(tctx,
1290                 test_GetResourceType_int(tctx, p, &hResource),
1291                 "failed to query resource type");
1292         torture_assert(tctx,
1293                 test_GetResourceId_int(tctx, p, &hResource),
1294                 "failed to query resource id");
1295         torture_assert(tctx,
1296                 test_GetResourceState_int(tctx, p, &hResource),
1297                 "failed to query resource state");
1298         torture_assert(tctx,
1299                 test_CreateResEnum_int(tctx, p, &hResource),
1300                 "failed to query resource enum");
1301         torture_assert(tctx,
1302                 test_GetResourceDependencyExpression_int(tctx, p, &hResource),
1303                 "failed to query resource dependency expression");
1304         torture_assert(tctx,
1305                 test_GetResourceNetworkName_int(tctx, p, &hResource),
1306                 "failed to query resource network name");
1307
1308         test_CloseResource_int(tctx, p, &hResource);
1309
1310         return true;
1311 }
1312
1313 static bool test_all_resources(struct torture_context *tctx,
1314                                void *data)
1315 {
1316         struct torture_clusapi_context *t =
1317                 talloc_get_type_abort(data, struct torture_clusapi_context);
1318         struct dcerpc_binding_handle *b = t->p->binding_handle;
1319         struct clusapi_CreateEnum r;
1320         uint32_t dwType = CLUSTER_ENUM_RESOURCE;
1321         struct ENUM_LIST *ReturnEnum;
1322         WERROR rpc_status;
1323         int i;
1324
1325         r.in.dwType = dwType;
1326         r.out.ReturnEnum = &ReturnEnum;
1327         r.out.rpc_status = &rpc_status;
1328
1329         torture_assert_ntstatus_ok(tctx,
1330                 dcerpc_clusapi_CreateEnum_r(b, tctx, &r),
1331                 "CreateEnum failed");
1332         torture_assert_werr_ok(tctx,
1333                 r.out.result,
1334                 "CreateEnum failed");
1335
1336         for (i=0; i < ReturnEnum->EntryCount; i++) {
1337
1338                 struct ENUM_ENTRY e = ReturnEnum->Entry[i];
1339
1340                 torture_assert_int_equal(tctx, e.Type, CLUSTER_ENUM_RESOURCE, "type mismatch");
1341
1342                 torture_assert(tctx,
1343                         test_one_resource(tctx, t->p, e.Name),
1344                         "failed to test one resource");
1345         }
1346
1347         return true;
1348 }
1349
1350 static bool test_all_resourcetypes(struct torture_context *tctx,
1351                                    void *data)
1352 {
1353         struct torture_clusapi_context *t =
1354                 talloc_get_type_abort(data, struct torture_clusapi_context);
1355         struct dcerpc_binding_handle *b = t->p->binding_handle;
1356         struct clusapi_CreateEnum r;
1357         uint32_t dwType = CLUSTER_ENUM_RESTYPE;
1358         struct ENUM_LIST *ReturnEnum;
1359         WERROR rpc_status;
1360         int i;
1361
1362         r.in.dwType = dwType;
1363         r.out.ReturnEnum = &ReturnEnum;
1364         r.out.rpc_status = &rpc_status;
1365
1366         torture_assert_ntstatus_ok(tctx,
1367                 dcerpc_clusapi_CreateEnum_r(b, tctx, &r),
1368                 "CreateEnum failed");
1369         torture_assert_werr_ok(tctx,
1370                 r.out.result,
1371                 "CreateEnum failed");
1372
1373         for (i=0; i < ReturnEnum->EntryCount; i++) {
1374
1375                 struct ENUM_ENTRY e = ReturnEnum->Entry[i];
1376
1377                 torture_assert_int_equal(tctx, e.Type, CLUSTER_ENUM_RESTYPE, "type mismatch");
1378
1379                 torture_assert(tctx,
1380                         test_one_resourcetype(tctx, t->p, e.Name),
1381                         "failed to test one resourcetype");
1382         }
1383
1384         return true;
1385 }
1386
1387
1388 static bool test_OpenNode_int(struct torture_context *tctx,
1389                               struct dcerpc_pipe *p,
1390                               const char *lpszNodeName,
1391                               struct policy_handle *hNode)
1392 {
1393         struct dcerpc_binding_handle *b = p->binding_handle;
1394         struct clusapi_OpenNode r;
1395         WERROR Status;
1396         WERROR rpc_status;
1397
1398         r.in.lpszNodeName = lpszNodeName;
1399         r.out.rpc_status = &rpc_status;
1400         r.out.Status = &Status;
1401         r.out.hNode= hNode;
1402
1403         torture_assert_ntstatus_ok(tctx,
1404                 dcerpc_clusapi_OpenNode_r(b, tctx, &r),
1405                 "OpenNode failed");
1406         torture_assert_werr_ok(tctx,
1407                 *r.out.Status,
1408                 "OpenNode failed");
1409
1410         return true;
1411 }
1412
1413 static bool test_OpenNodeEx_int(struct torture_context *tctx,
1414                                 struct dcerpc_pipe *p,
1415                                 const char *lpszNodeName,
1416                                 struct policy_handle *hNode)
1417 {
1418         struct dcerpc_binding_handle *b = p->binding_handle;
1419         struct clusapi_OpenNodeEx r;
1420         uint32_t lpdwGrantedAccess;
1421         WERROR Status;
1422         WERROR rpc_status;
1423
1424         r.in.lpszNodeName = lpszNodeName;
1425         r.in.dwDesiredAccess = SEC_FLAG_MAXIMUM_ALLOWED;
1426         r.out.lpdwGrantedAccess = &lpdwGrantedAccess;
1427         r.out.rpc_status = &rpc_status;
1428         r.out.Status = &Status;
1429         r.out.hNode= hNode;
1430
1431         torture_assert_ntstatus_ok(tctx,
1432                 dcerpc_clusapi_OpenNodeEx_r(b, tctx, &r),
1433                 "OpenNodeEx failed");
1434         torture_assert_werr_ok(tctx,
1435                 *r.out.Status,
1436                 "OpenNodeEx failed");
1437
1438         return true;
1439 }
1440
1441
1442 static bool test_CloseNode_int(struct torture_context *tctx,
1443                                struct dcerpc_pipe *p,
1444                                struct policy_handle *Node)
1445 {
1446         struct dcerpc_binding_handle *b = p->binding_handle;
1447         struct clusapi_CloseNode r;
1448
1449         r.in.Node = Node;
1450         r.out.Node = Node;
1451
1452         torture_assert_ntstatus_ok(tctx,
1453                 dcerpc_clusapi_CloseNode_r(b, tctx, &r),
1454                 "CloseNode failed");
1455         torture_assert_werr_ok(tctx,
1456                 r.out.result,
1457                 "CloseNode failed");
1458         torture_assert(tctx,
1459                 ndr_policy_handle_empty(Node),
1460                 "policy_handle non empty after CloseNode");
1461
1462         return true;
1463 }
1464
1465 static bool test_OpenNode(struct torture_context *tctx,
1466                           void *data)
1467 {
1468         struct torture_clusapi_context *t =
1469                 talloc_get_type_abort(data, struct torture_clusapi_context);
1470         struct policy_handle hNode;
1471
1472         if (!test_OpenNode_int(tctx, t->p, t->NodeName, &hNode)) {
1473                 return false;
1474         }
1475
1476         test_CloseNode_int(tctx, t->p, &hNode);
1477
1478         return true;
1479 }
1480
1481 static bool test_OpenNodeEx(struct torture_context *tctx,
1482                             void *data)
1483 {
1484         struct torture_clusapi_context *t =
1485                 talloc_get_type_abort(data, struct torture_clusapi_context);
1486         struct policy_handle hNode;
1487
1488         if (!test_OpenNodeEx_int(tctx, t->p, t->NodeName, &hNode)) {
1489                 return false;
1490         }
1491
1492         test_CloseNode_int(tctx, t->p, &hNode);
1493
1494         return true;
1495 }
1496
1497 static bool test_CloseNode(struct torture_context *tctx,
1498                            void *data)
1499 {
1500         struct torture_clusapi_context *t =
1501                 talloc_get_type_abort(data, struct torture_clusapi_context);
1502         struct policy_handle hNode;
1503
1504         if (!test_OpenNode_int(tctx, t->p, t->NodeName, &hNode)) {
1505                 return false;
1506         }
1507
1508         return test_CloseNode_int(tctx, t->p, &hNode);
1509 }
1510
1511 static bool test_GetNodeState_int(struct torture_context *tctx,
1512                                   struct dcerpc_pipe *p,
1513                                   struct policy_handle *hNode)
1514 {
1515         struct dcerpc_binding_handle *b = p->binding_handle;
1516         struct clusapi_GetNodeState r;
1517         enum clusapi_ClusterNodeState State;
1518         WERROR rpc_status;
1519
1520         r.in.hNode = *hNode;
1521         r.out.State = &State;
1522         r.out.rpc_status = &rpc_status;
1523
1524         torture_assert_ntstatus_ok(tctx,
1525                 dcerpc_clusapi_GetNodeState_r(b, tctx, &r),
1526                 "GetNodeState failed");
1527         torture_assert_werr_ok(tctx,
1528                 r.out.result,
1529                 "GetNodeState failed");
1530
1531         return true;
1532 }
1533
1534 static bool test_GetNodeState(struct torture_context *tctx,
1535                               void *data)
1536 {
1537         struct torture_clusapi_context *t =
1538                 talloc_get_type_abort(data, struct torture_clusapi_context);
1539         struct policy_handle hNode;
1540         bool ret = true;
1541
1542         if (!test_OpenNode_int(tctx, t->p, t->NodeName, &hNode)) {
1543                 return false;
1544         }
1545
1546         ret = test_GetNodeState_int(tctx, t->p, &hNode);
1547
1548         test_CloseNode_int(tctx, t->p, &hNode);
1549
1550         return ret;
1551 }
1552
1553 static bool test_GetNodeId_int(struct torture_context *tctx,
1554                                struct dcerpc_pipe *p,
1555                                struct policy_handle *hNode)
1556 {
1557         struct dcerpc_binding_handle *b = p->binding_handle;
1558         struct clusapi_GetNodeId r;
1559         const char *pGuid;
1560         WERROR rpc_status;
1561
1562         r.in.hNode = *hNode;
1563         r.out.pGuid = &pGuid;
1564         r.out.rpc_status = &rpc_status;
1565
1566         torture_assert_ntstatus_ok(tctx,
1567                 dcerpc_clusapi_GetNodeId_r(b, tctx, &r),
1568                 "GetNodeId failed");
1569         torture_assert_werr_ok(tctx,
1570                 r.out.result,
1571                 "GetNodeId failed");
1572
1573         return true;
1574 }
1575
1576 static bool test_GetNodeId(struct torture_context *tctx,
1577                            void *data)
1578 {
1579         struct torture_clusapi_context *t =
1580                 talloc_get_type_abort(data, struct torture_clusapi_context);
1581         struct policy_handle hNode;
1582         bool ret = true;
1583
1584         if (!test_OpenNode_int(tctx, t->p, t->NodeName, &hNode)) {
1585                 return false;
1586         }
1587
1588         ret = test_GetNodeId_int(tctx, t->p, &hNode);
1589
1590         test_CloseNode_int(tctx, t->p, &hNode);
1591
1592         return ret;
1593 }
1594
1595 static bool test_NodeControl_int(struct torture_context *tctx,
1596                                  struct dcerpc_pipe *p,
1597                                  struct policy_handle *hNode,
1598                                  enum clusapi_NodeControlCode dwControlCode)
1599 {
1600         struct dcerpc_binding_handle *b = p->binding_handle;
1601         struct clusapi_NodeControl r;
1602         uint32_t lpBytesReturned;
1603         uint32_t lpcbRequired;
1604         WERROR rpc_status;
1605
1606         r.in.hNode = *hNode;
1607         r.in.dwControlCode = 0;
1608         r.in.lpInBuffer = NULL;
1609         r.in.nInBufferSize = 0;
1610         r.in.nOutBufferSize = 0;
1611         r.out.lpOutBuffer = NULL;
1612         r.out.lpBytesReturned = &lpBytesReturned;
1613         r.out.lpcbRequired = &lpcbRequired;
1614         r.out.rpc_status = &rpc_status;
1615
1616         torture_assert_ntstatus_ok(tctx,
1617                 dcerpc_clusapi_NodeControl_r(b, tctx, &r),
1618                 "NodeControl failed");
1619         torture_assert_werr_equal(tctx,
1620                 r.out.result,
1621                 WERR_INVALID_FUNCTION,
1622                 "NodeControl failed");
1623
1624         r.in.dwControlCode = dwControlCode;
1625
1626         torture_assert_ntstatus_ok(tctx,
1627                 dcerpc_clusapi_NodeControl_r(b, tctx, &r),
1628                 "NodeControl failed");
1629
1630         if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
1631                 r.out.lpOutBuffer = talloc_zero_array(tctx, uint8_t, *r.out.lpcbRequired);
1632                 r.in.nOutBufferSize = *r.out.lpcbRequired;
1633                 torture_assert_ntstatus_ok(tctx,
1634                         dcerpc_clusapi_NodeControl_r(b, tctx, &r),
1635                         "NodeControl failed");
1636         }
1637         torture_assert_werr_ok(tctx,
1638                 r.out.result,
1639                 "NodeControl failed");
1640
1641         /* now try what happens when we query with a buffer large enough to hold
1642          * the entire packet */
1643
1644         r.in.nOutBufferSize = 0x400;
1645         r.out.lpOutBuffer = talloc_zero_array(tctx, uint8_t, r.in.nOutBufferSize);
1646
1647         torture_assert_ntstatus_ok(tctx,
1648                 dcerpc_clusapi_NodeControl_r(b, tctx, &r),
1649                 "NodeControl failed");
1650         torture_assert_werr_ok(tctx,
1651                 r.out.result,
1652                 "NodeControl failed");
1653         torture_assert(tctx, *r.out.lpBytesReturned < r.in.nOutBufferSize,
1654                 "lpBytesReturned expected to be smaller than input size nOutBufferSize");
1655
1656         if (dwControlCode == CLUSCTL_NODE_GET_ID) {
1657                 const char *str;
1658                 DATA_BLOB blob = data_blob_const(r.out.lpOutBuffer, *r.out.lpBytesReturned);
1659
1660                 torture_assert(tctx, *r.out.lpBytesReturned < 4, "unexpected size");
1661                 torture_assert(tctx, *r.out.lpBytesReturned % 2, "must be a multiple of 2");
1662
1663                 torture_assert(tctx,
1664                         pull_reg_sz(tctx, &blob, &str),
1665                         "failed to pull unicode string");
1666
1667                 torture_comment(tctx, "got this node id: '%s'", str);
1668         }
1669
1670         return true;
1671 }
1672
1673 static bool test_NodeControl(struct torture_context *tctx,
1674                              void *data)
1675 {
1676         struct torture_clusapi_context *t =
1677                 talloc_get_type_abort(data, struct torture_clusapi_context);
1678         struct policy_handle hNode;
1679         bool ret = true;
1680
1681         if (!test_OpenNode_int(tctx, t->p, t->NodeName, &hNode)) {
1682                 return false;
1683         }
1684
1685         ret = test_NodeControl_int(tctx, t->p, &hNode, CLUSCTL_NODE_GET_RO_COMMON_PROPERTIES);
1686         if (!ret) {
1687                 return false;
1688         }
1689
1690         ret = test_NodeControl_int(tctx, t->p, &hNode, CLUSCTL_NODE_GET_ID);
1691         if (!ret) {
1692                 return false;
1693         }
1694
1695         test_CloseNode_int(tctx, t->p, &hNode);
1696
1697         return ret;
1698 }
1699
1700 static bool test_PauseNode_int(struct torture_context *tctx,
1701                                struct dcerpc_pipe *p,
1702                                struct policy_handle *hNode)
1703 {
1704         struct dcerpc_binding_handle *b = p->binding_handle;
1705         struct clusapi_PauseNode r;
1706         WERROR rpc_status;
1707
1708         r.in.hNode = *hNode;
1709         r.out.rpc_status = &rpc_status;
1710
1711         torture_assert_ntstatus_ok(tctx,
1712                 dcerpc_clusapi_PauseNode_r(b, tctx, &r),
1713                 "PauseNode failed");
1714         torture_assert_werr_ok(tctx,
1715                 r.out.result,
1716                 "PauseNode failed");
1717
1718         return true;
1719 }
1720
1721 static bool test_PauseNode(struct torture_context *tctx,
1722                            void *data)
1723 {
1724         struct torture_clusapi_context *t =
1725                 talloc_get_type_abort(data, struct torture_clusapi_context);
1726         struct policy_handle hNode;
1727         bool ret = true;
1728
1729         if (!test_OpenNode_int(tctx, t->p, t->NodeName, &hNode)) {
1730                 return false;
1731         }
1732
1733         ret = test_PauseNode_int(tctx, t->p, &hNode);
1734
1735         test_CloseNode_int(tctx, t->p, &hNode);
1736
1737         return ret;
1738 }
1739
1740 static bool test_ResumeNode_int(struct torture_context *tctx,
1741                                 struct dcerpc_pipe *p,
1742                                 struct policy_handle *hNode)
1743 {
1744         struct dcerpc_binding_handle *b = p->binding_handle;
1745         struct clusapi_ResumeNode r;
1746         WERROR rpc_status;
1747
1748         r.in.hNode = *hNode;
1749         r.out.rpc_status = &rpc_status;
1750
1751         torture_assert_ntstatus_ok(tctx,
1752                 dcerpc_clusapi_ResumeNode_r(b, tctx, &r),
1753                 "ResumeNode failed");
1754         torture_assert_werr_equal(tctx,
1755                 r.out.result,
1756                 WERR_CLUSTER_NODE_NOT_PAUSED,
1757                 "ResumeNode gave unexpected result");
1758
1759         return true;
1760 }
1761
1762 static bool test_ResumeNode(struct torture_context *tctx,
1763                             void *data)
1764 {
1765         struct torture_clusapi_context *t =
1766                 talloc_get_type_abort(data, struct torture_clusapi_context);
1767         struct policy_handle hNode;
1768         bool ret = true;
1769
1770         if (!test_OpenNode_int(tctx, t->p, t->NodeName, &hNode)) {
1771                 return false;
1772         }
1773
1774         ret = test_ResumeNode_int(tctx, t->p, &hNode);
1775
1776         test_CloseNode_int(tctx, t->p, &hNode);
1777
1778         return ret;
1779 }
1780
1781 static bool test_EvictNode_int(struct torture_context *tctx,
1782                                struct dcerpc_pipe *p,
1783                                struct policy_handle *hNode)
1784 {
1785         struct dcerpc_binding_handle *b = p->binding_handle;
1786         struct clusapi_EvictNode r;
1787         WERROR rpc_status;
1788
1789         r.in.hNode = *hNode;
1790         r.out.rpc_status = &rpc_status;
1791
1792         torture_assert_ntstatus_ok(tctx,
1793                 dcerpc_clusapi_EvictNode_r(b, tctx, &r),
1794                 "EvictNode failed");
1795         torture_assert_werr_ok(tctx,
1796                 r.out.result,
1797                 "EvictNode failed");
1798
1799         return true;
1800 }
1801
1802 static bool test_EvictNode(struct torture_context *tctx,
1803                            void *data)
1804 {
1805         struct torture_clusapi_context *t =
1806                 talloc_get_type_abort(data, struct torture_clusapi_context);
1807         struct policy_handle hNode;
1808         bool ret = true;
1809
1810         if (!test_OpenNode_int(tctx, t->p, t->NodeName, &hNode)) {
1811                 return false;
1812         }
1813
1814         ret = test_EvictNode_int(tctx, t->p, &hNode);
1815
1816         test_CloseNode_int(tctx, t->p, &hNode);
1817
1818         return ret;
1819 }
1820
1821 static bool test_one_node(struct torture_context *tctx,
1822                           struct dcerpc_pipe *p,
1823                           const char *node_name)
1824 {
1825         struct policy_handle hNode;
1826
1827         torture_assert(tctx,
1828                 test_OpenNode_int(tctx, p, node_name, &hNode),
1829                 "failed to open node");
1830         test_CloseNode_int(tctx, p, &hNode);
1831
1832         torture_assert(tctx,
1833                 test_OpenNodeEx_int(tctx, p, node_name, &hNode),
1834                 "failed to openex node");
1835
1836         torture_assert(tctx,
1837                 test_GetNodeId_int(tctx, p, &hNode),
1838                 "failed to query node id");
1839         torture_assert(tctx,
1840                 test_GetNodeState_int(tctx, p, &hNode),
1841                 "failed to query node id");
1842
1843         test_CloseNode_int(tctx, p, &hNode);
1844
1845         return true;
1846 }
1847
1848 static bool test_all_nodes(struct torture_context *tctx,
1849                            void *data)
1850 {
1851         struct torture_clusapi_context *t =
1852                 talloc_get_type_abort(data, struct torture_clusapi_context);
1853         struct dcerpc_binding_handle *b = t->p->binding_handle;
1854         struct clusapi_CreateEnum r;
1855         uint32_t dwType = CLUSTER_ENUM_NODE;
1856         struct ENUM_LIST *ReturnEnum;
1857         WERROR rpc_status;
1858         int i;
1859
1860         r.in.dwType = dwType;
1861         r.out.ReturnEnum = &ReturnEnum;
1862         r.out.rpc_status = &rpc_status;
1863
1864         torture_assert_ntstatus_ok(tctx,
1865                 dcerpc_clusapi_CreateEnum_r(b, tctx, &r),
1866                 "CreateEnum failed");
1867         torture_assert_werr_ok(tctx,
1868                 r.out.result,
1869                 "CreateEnum failed");
1870
1871         for (i=0; i < ReturnEnum->EntryCount; i++) {
1872
1873                 struct ENUM_ENTRY e = ReturnEnum->Entry[i];
1874
1875                 torture_assert_int_equal(tctx, e.Type, CLUSTER_ENUM_NODE, "type mismatch");
1876
1877                 torture_assert(tctx,
1878                         test_one_node(tctx, t->p, e.Name),
1879                         "failed to test one node");
1880         }
1881
1882         return true;
1883 }
1884
1885 static bool test_OpenGroup_int(struct torture_context *tctx,
1886                                struct dcerpc_pipe *p,
1887                                const char *lpszGroupName,
1888                                struct policy_handle *hGroup)
1889 {
1890         struct dcerpc_binding_handle *b = p->binding_handle;
1891         struct clusapi_OpenGroup r;
1892         WERROR Status;
1893         WERROR rpc_status;
1894
1895         r.in.lpszGroupName = lpszGroupName;
1896         r.out.rpc_status = &rpc_status;
1897         r.out.Status = &Status;
1898         r.out.hGroup= hGroup;
1899
1900         torture_assert_ntstatus_ok(tctx,
1901                 dcerpc_clusapi_OpenGroup_r(b, tctx, &r),
1902                 "OpenGroup failed");
1903         torture_assert_werr_ok(tctx,
1904                 *r.out.Status,
1905                 "OpenGroup failed");
1906
1907         return true;
1908 }
1909
1910 static bool test_OpenGroupEx_int(struct torture_context *tctx,
1911                                  struct dcerpc_pipe *p,
1912                                  const char *lpszGroupName,
1913                                  struct policy_handle *hGroup)
1914 {
1915         struct dcerpc_binding_handle *b = p->binding_handle;
1916         struct clusapi_OpenGroupEx r;
1917         uint32_t lpdwGrantedAccess;
1918         WERROR Status;
1919         WERROR rpc_status;
1920
1921         r.in.lpszGroupName = lpszGroupName;
1922         r.in.dwDesiredAccess = SEC_FLAG_MAXIMUM_ALLOWED;
1923         r.out.lpdwGrantedAccess = &lpdwGrantedAccess;
1924         r.out.rpc_status = &rpc_status;
1925         r.out.Status = &Status;
1926         r.out.hGroup= hGroup;
1927
1928         torture_assert_ntstatus_ok(tctx,
1929                 dcerpc_clusapi_OpenGroupEx_r(b, tctx, &r),
1930                 "OpenGroupEx failed");
1931         torture_assert_werr_ok(tctx,
1932                 *r.out.Status,
1933                 "OpenGroupEx failed");
1934
1935         return true;
1936 }
1937
1938 static bool test_CloseGroup_int(struct torture_context *tctx,
1939                                 struct dcerpc_pipe *p,
1940                                 struct policy_handle *Group)
1941 {
1942         struct dcerpc_binding_handle *b = p->binding_handle;
1943         struct clusapi_CloseGroup r;
1944
1945         r.in.Group = Group;
1946         r.out.Group = Group;
1947
1948         torture_assert_ntstatus_ok(tctx,
1949                 dcerpc_clusapi_CloseGroup_r(b, tctx, &r),
1950                 "CloseGroup failed");
1951         torture_assert_werr_ok(tctx,
1952                 r.out.result,
1953                 "CloseGroup failed");
1954         torture_assert(tctx,
1955                 ndr_policy_handle_empty(Group),
1956                 "policy_handle non empty after CloseGroup");
1957
1958         return true;
1959 }
1960
1961 static bool test_OpenGroup(struct torture_context *tctx,
1962                            void *data)
1963 {
1964         struct torture_clusapi_context *t =
1965                 talloc_get_type_abort(data, struct torture_clusapi_context);
1966         struct policy_handle hGroup;
1967
1968         if (!test_OpenGroup_int(tctx, t->p, "Cluster Group", &hGroup)) {
1969                 return false;
1970         }
1971
1972         test_CloseGroup_int(tctx, t->p, &hGroup);
1973
1974         return true;
1975 }
1976
1977 static bool test_OpenGroupEx(struct torture_context *tctx,
1978                              void *data)
1979 {
1980         struct torture_clusapi_context *t =
1981                 talloc_get_type_abort(data, struct torture_clusapi_context);
1982         struct policy_handle hGroup;
1983
1984         if (!test_OpenGroupEx_int(tctx, t->p, "Cluster Group", &hGroup)) {
1985                 return false;
1986         }
1987
1988         test_CloseGroup_int(tctx, t->p, &hGroup);
1989
1990         return true;
1991 }
1992
1993 static bool test_CloseGroup(struct torture_context *tctx,
1994                             void *data)
1995 {
1996         struct torture_clusapi_context *t =
1997                 talloc_get_type_abort(data, struct torture_clusapi_context);
1998         struct policy_handle hGroup;
1999
2000         if (!test_OpenGroup_int(tctx, t->p, "Cluster Group", &hGroup)) {
2001                 return false;
2002         }
2003
2004         return test_CloseGroup_int(tctx, t->p, &hGroup);
2005 }
2006
2007 static bool test_GetGroupState_int(struct torture_context *tctx,
2008                                    struct dcerpc_pipe *p,
2009                                    struct policy_handle *hGroup)
2010 {
2011         struct dcerpc_binding_handle *b = p->binding_handle;
2012         struct clusapi_GetGroupState r;
2013         enum clusapi_ClusterGroupState State;
2014         const char *NodeName;
2015         WERROR rpc_status;
2016
2017         r.in.hGroup = *hGroup;
2018         r.out.State = &State;
2019         r.out.NodeName = &NodeName;
2020         r.out.rpc_status = &rpc_status;
2021
2022         torture_assert_ntstatus_ok(tctx,
2023                 dcerpc_clusapi_GetGroupState_r(b, tctx, &r),
2024                 "GetGroupState failed");
2025         torture_assert_werr_ok(tctx,
2026                 r.out.result,
2027                 "GetGroupState failed");
2028
2029         return true;
2030 }
2031
2032 static bool test_GetGroupState(struct torture_context *tctx,
2033                                void *data)
2034 {
2035         struct torture_clusapi_context *t =
2036                 talloc_get_type_abort(data, struct torture_clusapi_context);
2037         struct policy_handle hGroup;
2038         bool ret = true;
2039
2040         if (!test_OpenGroup_int(tctx, t->p, "Cluster Group", &hGroup)) {
2041                 return false;
2042         }
2043
2044         ret = test_GetGroupState_int(tctx, t->p, &hGroup);
2045
2046         test_CloseGroup_int(tctx, t->p, &hGroup);
2047
2048         return ret;
2049 }
2050
2051 static bool test_GetGroupId_int(struct torture_context *tctx,
2052                                 struct dcerpc_pipe *p,
2053                                 struct policy_handle *hGroup)
2054 {
2055         struct dcerpc_binding_handle *b = p->binding_handle;
2056         struct clusapi_GetGroupId r;
2057         const char *pGuid;
2058         WERROR rpc_status;
2059
2060         r.in.hGroup = *hGroup;
2061         r.out.pGuid = &pGuid;
2062         r.out.rpc_status = &rpc_status;
2063
2064         torture_assert_ntstatus_ok(tctx,
2065                 dcerpc_clusapi_GetGroupId_r(b, tctx, &r),
2066                 "GetGroupId failed");
2067         torture_assert_werr_ok(tctx,
2068                 r.out.result,
2069                 "GetGroupId failed");
2070
2071         return true;
2072 }
2073
2074 static bool test_GetGroupId(struct torture_context *tctx,
2075                             void *data)
2076 {
2077         struct torture_clusapi_context *t =
2078                 talloc_get_type_abort(data, struct torture_clusapi_context);
2079         struct policy_handle hGroup;
2080         bool ret = true;
2081
2082         if (!test_OpenGroup_int(tctx, t->p, "Cluster Group", &hGroup)) {
2083                 return false;
2084         }
2085
2086         ret = test_GetGroupId_int(tctx, t->p, &hGroup);
2087
2088         test_CloseGroup_int(tctx, t->p, &hGroup);
2089
2090         return ret;
2091 }
2092
2093 static bool test_GroupControl_int(struct torture_context *tctx,
2094                                   struct dcerpc_pipe *p,
2095                                   struct policy_handle *hGroup,
2096                                   enum clusapi_GroupControlCode dwControlCode)
2097 {
2098         struct dcerpc_binding_handle *b = p->binding_handle;
2099         struct clusapi_GroupControl r;
2100         uint32_t lpBytesReturned;
2101         uint32_t lpcbRequired;
2102         WERROR rpc_status;
2103
2104         r.in.hGroup = *hGroup;
2105         r.in.dwControlCode = 0;
2106         r.in.lpInBuffer = NULL;
2107         r.in.nInBufferSize = 0;
2108         r.in.nOutBufferSize = 0;
2109         r.out.lpOutBuffer = NULL;
2110         r.out.lpBytesReturned = &lpBytesReturned;
2111         r.out.lpcbRequired = &lpcbRequired;
2112         r.out.rpc_status = &rpc_status;
2113
2114         torture_assert_ntstatus_ok(tctx,
2115                 dcerpc_clusapi_GroupControl_r(b, tctx, &r),
2116                 "GroupControl failed");
2117         torture_assert_werr_equal(tctx,
2118                 r.out.result,
2119                 WERR_INVALID_FUNCTION,
2120                 "GroupControl failed");
2121
2122         r.in.dwControlCode = dwControlCode;
2123
2124         torture_assert_ntstatus_ok(tctx,
2125                 dcerpc_clusapi_GroupControl_r(b, tctx, &r),
2126                 "GroupControl failed");
2127
2128         if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
2129                 r.out.lpOutBuffer = talloc_zero_array(tctx, uint8_t, *r.out.lpcbRequired);
2130                 r.in.nOutBufferSize = *r.out.lpcbRequired;
2131                 torture_assert_ntstatus_ok(tctx,
2132                         dcerpc_clusapi_GroupControl_r(b, tctx, &r),
2133                         "GroupControl failed");
2134         }
2135         torture_assert_werr_ok(tctx,
2136                 r.out.result,
2137                 "GroupControl failed");
2138
2139         /* now try what happens when we query with a buffer large enough to hold
2140          * the entire packet */
2141
2142         r.in.nOutBufferSize = 0x400;
2143         r.out.lpOutBuffer = talloc_zero_array(tctx, uint8_t, r.in.nOutBufferSize);
2144
2145         torture_assert_ntstatus_ok(tctx,
2146                 dcerpc_clusapi_GroupControl_r(b, tctx, &r),
2147                 "GroupControl failed");
2148         torture_assert_werr_ok(tctx,
2149                 r.out.result,
2150                 "GroupControl failed");
2151         torture_assert(tctx, *r.out.lpBytesReturned < r.in.nOutBufferSize,
2152                 "lpBytesReturned expected to be smaller than input size nOutBufferSize");
2153
2154         return true;
2155 }
2156
2157 static bool test_CreateGroupResourceEnum_int(struct torture_context *tctx,
2158                                              struct dcerpc_pipe *p,
2159                                              struct policy_handle *hGroup)
2160 {
2161         struct dcerpc_binding_handle *b = p->binding_handle;
2162         struct clusapi_CreateGroupResourceEnum r;
2163         uint32_t dwType[] = {
2164                 CLUSTER_GROUP_ENUM_CONTAINS,
2165                 CLUSTER_GROUP_ENUM_NODES
2166         };
2167         uint32_t dwType_invalid[] = {
2168                 0x00000040,
2169                 0x00000080,
2170                 0x00000100 /* and many more ... */
2171         };
2172         struct ENUM_LIST *ReturnEnum;
2173         WERROR rpc_status;
2174         int i;
2175
2176         r.in.hGroup = *hGroup;
2177
2178         for (i=0; i < ARRAY_SIZE(dwType); i++) {
2179
2180                 r.in.hGroup = *hGroup;
2181                 r.in.dwType = dwType[i];
2182                 r.out.ReturnEnum = &ReturnEnum;
2183                 r.out.rpc_status = &rpc_status;
2184
2185                 torture_assert_ntstatus_ok(tctx,
2186                         dcerpc_clusapi_CreateGroupResourceEnum_r(b, tctx, &r),
2187                         "CreateGroupResourceEnum failed");
2188                 torture_assert_werr_ok(tctx,
2189                         r.out.result,
2190                         "CreateGroupResourceEnum failed");
2191         }
2192
2193         for (i=0; i < ARRAY_SIZE(dwType_invalid); i++) {
2194
2195                 r.in.dwType = dwType_invalid[i];
2196                 r.out.ReturnEnum = &ReturnEnum;
2197                 r.out.rpc_status = &rpc_status;
2198
2199                 torture_assert_ntstatus_ok(tctx,
2200                         dcerpc_clusapi_CreateGroupResourceEnum_r(b, tctx, &r),
2201                         "CreateGroupResourceEnum failed");
2202                 torture_assert_werr_ok(tctx,
2203                         r.out.result,
2204                         "CreateGroupResourceEnum failed");
2205         }
2206
2207         return true;
2208 }
2209
2210
2211 static bool test_GroupControl(struct torture_context *tctx,
2212                               void *data)
2213 {
2214         struct torture_clusapi_context *t =
2215                 talloc_get_type_abort(data, struct torture_clusapi_context);
2216         struct policy_handle hGroup;
2217         bool ret = true;
2218
2219         if (!test_OpenGroup_int(tctx, t->p, "Cluster Group", &hGroup)) {
2220                 return false;
2221         }
2222
2223         ret = test_GroupControl_int(tctx, t->p, &hGroup, CLUSCTL_GROUP_GET_CHARACTERISTICS);
2224         if (!ret) {
2225                 return false;
2226         }
2227
2228         ret = test_GroupControl_int(tctx, t->p, &hGroup, CLUSCTL_GROUP_GET_RO_COMMON_PROPERTIES);
2229         if (!ret) {
2230                 return false;
2231         }
2232
2233         ret = test_GroupControl_int(tctx, t->p, &hGroup, CLUSCTL_GROUP_GET_FLAGS);
2234         if (!ret) {
2235                 return false;
2236         }
2237
2238         test_CloseGroup_int(tctx, t->p, &hGroup);
2239
2240         return ret;
2241 }
2242
2243 static bool test_OnlineGroup_int(struct torture_context *tctx,
2244                                  struct dcerpc_pipe *p,
2245                                  struct policy_handle *hGroup)
2246 {
2247         struct dcerpc_binding_handle *b = p->binding_handle;
2248         struct clusapi_OnlineGroup r;
2249         WERROR rpc_status;
2250
2251         r.in.hGroup = *hGroup;
2252         r.out.rpc_status = &rpc_status;
2253
2254         torture_assert_ntstatus_ok(tctx,
2255                 dcerpc_clusapi_OnlineGroup_r(b, tctx, &r),
2256                 "OnlineGroup failed");
2257         torture_assert_werr_ok(tctx,
2258                 r.out.result,
2259                 "OnlineGroup failed");
2260
2261         return true;
2262 }
2263
2264 static bool test_OnlineGroup(struct torture_context *tctx,
2265                              void *data)
2266 {
2267         struct torture_clusapi_context *t =
2268                 talloc_get_type_abort(data, struct torture_clusapi_context);
2269         struct policy_handle hGroup;
2270         bool ret = true;
2271
2272         if (!test_OpenGroup_int(tctx, t->p, "Cluster Group", &hGroup)) {
2273                 return false;
2274         }
2275
2276         ret = test_OnlineGroup_int(tctx, t->p, &hGroup);
2277
2278         test_CloseGroup_int(tctx, t->p, &hGroup);
2279
2280         return ret;
2281 }
2282
2283 static bool test_OfflineGroup_int(struct torture_context *tctx,
2284                                   struct dcerpc_pipe *p,
2285                                   struct policy_handle *hGroup)
2286 {
2287         struct dcerpc_binding_handle *b = p->binding_handle;
2288         struct clusapi_OfflineGroup r;
2289         WERROR rpc_status;
2290
2291         r.in.hGroup = *hGroup;
2292         r.out.rpc_status = &rpc_status;
2293
2294         torture_assert_ntstatus_ok(tctx,
2295                 dcerpc_clusapi_OfflineGroup_r(b, tctx, &r),
2296                 "OfflineGroup failed");
2297         torture_assert_werr_ok(tctx,
2298                 r.out.result,
2299                 "OfflineGroup failed");
2300
2301         return true;
2302 }
2303
2304 static bool test_OfflineGroup(struct torture_context *tctx,
2305                               void *data)
2306 {
2307         struct torture_clusapi_context *t =
2308                 talloc_get_type_abort(data, struct torture_clusapi_context);
2309         struct policy_handle hGroup;
2310         bool ret = true;
2311
2312         if (!test_OpenGroup_int(tctx, t->p, "Cluster Group", &hGroup)) {
2313                 return false;
2314         }
2315
2316         ret = test_OfflineGroup_int(tctx, t->p, &hGroup);
2317
2318         test_CloseGroup_int(tctx, t->p, &hGroup);
2319
2320         return ret;
2321 }
2322
2323 static bool test_one_group(struct torture_context *tctx,
2324                            struct dcerpc_pipe *p,
2325                            const char *node_name)
2326 {
2327         struct policy_handle hGroup;
2328
2329         torture_assert(tctx,
2330                 test_OpenGroup_int(tctx, p, node_name, &hGroup),
2331                 "failed to open group");
2332         test_CloseGroup_int(tctx, p, &hGroup);
2333
2334         torture_assert(tctx,
2335                 test_OpenGroupEx_int(tctx, p, node_name, &hGroup),
2336                 "failed to openex group");
2337
2338         torture_assert(tctx,
2339                 test_GetGroupId_int(tctx, p, &hGroup),
2340                 "failed to query group id");
2341         torture_assert(tctx,
2342                 test_GetGroupState_int(tctx, p, &hGroup),
2343                 "failed to query group id");
2344
2345         torture_assert(tctx,
2346                 test_GroupControl_int(tctx, p, &hGroup, CLUSCTL_GROUP_GET_FLAGS),
2347                 "failed to query group control");
2348
2349         torture_assert(tctx,
2350                 test_CreateGroupResourceEnum_int(tctx, p, &hGroup),
2351                 "failed to query resource enum");
2352
2353         test_CloseGroup_int(tctx, p, &hGroup);
2354
2355         return true;
2356 }
2357
2358 static bool test_all_groups(struct torture_context *tctx,
2359                             void *data)
2360 {
2361         struct torture_clusapi_context *t =
2362                 talloc_get_type_abort(data, struct torture_clusapi_context);
2363         struct dcerpc_binding_handle *b = t->p->binding_handle;
2364         struct clusapi_CreateEnum r;
2365         uint32_t dwType = CLUSTER_ENUM_GROUP;
2366         struct ENUM_LIST *ReturnEnum;
2367         WERROR rpc_status;
2368         int i;
2369
2370         r.in.dwType = dwType;
2371         r.out.ReturnEnum = &ReturnEnum;
2372         r.out.rpc_status = &rpc_status;
2373
2374         torture_assert_ntstatus_ok(tctx,
2375                 dcerpc_clusapi_CreateEnum_r(b, tctx, &r),
2376                 "CreateEnum failed");
2377         torture_assert_werr_ok(tctx,
2378                 r.out.result,
2379                 "CreateEnum failed");
2380
2381         for (i=0; i < ReturnEnum->EntryCount; i++) {
2382
2383                 struct ENUM_ENTRY e = ReturnEnum->Entry[i];
2384
2385                 torture_assert_int_equal(tctx, e.Type, CLUSTER_ENUM_GROUP, "type mismatch");
2386
2387                 torture_assert(tctx,
2388                         test_one_group(tctx, t->p, e.Name),
2389                         "failed to test one group");
2390         }
2391
2392         return true;
2393 }
2394
2395 static bool test_BackupClusterDatabase(struct torture_context *tctx,
2396                                        void *data)
2397 {
2398         struct torture_clusapi_context *t =
2399                 talloc_get_type_abort(data, struct torture_clusapi_context);
2400         struct dcerpc_binding_handle *b = t->p->binding_handle;
2401         struct clusapi_BackupClusterDatabase r;
2402         WERROR rpc_status;
2403
2404         r.in.lpszPathName = "c:\\cluster_backup";
2405         r.out.rpc_status = &rpc_status;
2406
2407         torture_assert_ntstatus_ok(tctx,
2408                 dcerpc_clusapi_BackupClusterDatabase_r(b, tctx, &r),
2409                 "BackupClusterDatabase failed");
2410         torture_assert_werr_equal(tctx,
2411                 r.out.result,
2412                 WERR_CALL_NOT_IMPLEMENTED,
2413                 "BackupClusterDatabase failed");
2414
2415         return true;
2416 }
2417
2418 static bool test_SetServiceAccountPassword(struct torture_context *tctx,
2419                                            void *data)
2420 {
2421         struct torture_clusapi_context *t =
2422                 talloc_get_type_abort(data, struct torture_clusapi_context);
2423         struct dcerpc_binding_handle *b = t->p->binding_handle;
2424         struct clusapi_SetServiceAccountPassword r;
2425         uint32_t SizeReturned;
2426         uint32_t ExpectedBufferSize;
2427
2428         r.in.lpszNewPassword = "P@ssw0rd!";
2429         r.in.dwFlags = IDL_CLUSTER_SET_PASSWORD_IGNORE_DOWN_NODES;
2430         r.in.ReturnStatusBufferSize = 1024;
2431         r.out.ReturnStatusBufferPtr = NULL;
2432         r.out.SizeReturned = &SizeReturned;
2433         r.out.ExpectedBufferSize = &ExpectedBufferSize;
2434
2435         torture_assert_ntstatus_ok(tctx,
2436                 dcerpc_clusapi_SetServiceAccountPassword_r(b, tctx, &r),
2437                 "SetServiceAccountPassword failed");
2438         torture_assert_werr_equal(tctx,
2439                 r.out.result,
2440                 WERR_CALL_NOT_IMPLEMENTED,
2441                 "SetServiceAccountPassword failed");
2442
2443         return true;
2444 }
2445
2446 static bool test_ClusterControl_int(struct torture_context *tctx,
2447                                     struct dcerpc_pipe *p,
2448                                     struct policy_handle *Cluster,
2449                                     enum clusapi_ClusterControlCode dwControlCode)
2450 {
2451         struct dcerpc_binding_handle *b = p->binding_handle;
2452         struct clusapi_ClusterControl r;
2453         uint32_t lpBytesReturned;
2454         uint32_t lpcbRequired;
2455         WERROR rpc_status;
2456
2457         r.in.hCluster = *Cluster;
2458         r.in.dwControlCode = 0;
2459         r.in.lpInBuffer = NULL;
2460         r.in.nInBufferSize = 0;
2461         r.in.nOutBufferSize = 0;
2462         r.out.lpOutBuffer = NULL;
2463         r.out.lpBytesReturned = &lpBytesReturned;
2464         r.out.lpcbRequired = &lpcbRequired;
2465         r.out.rpc_status = &rpc_status;
2466
2467         torture_assert_ntstatus_ok(tctx,
2468                 dcerpc_clusapi_ClusterControl_r(b, tctx, &r),
2469                 "ClusterControl failed");
2470         torture_assert_werr_equal(tctx,
2471                 r.out.result,
2472                 WERR_INVALID_FUNCTION,
2473                 "ClusterControl failed");
2474
2475         r.in.dwControlCode = dwControlCode;
2476
2477         torture_assert_ntstatus_ok(tctx,
2478                 dcerpc_clusapi_ClusterControl_r(b, tctx, &r),
2479                 "ClusterControl failed");
2480
2481         if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
2482                 r.out.lpOutBuffer = talloc_zero_array(tctx, uint8_t, *r.out.lpcbRequired);
2483                 r.in.nOutBufferSize = *r.out.lpcbRequired;
2484                 torture_assert_ntstatus_ok(tctx,
2485                         dcerpc_clusapi_ClusterControl_r(b, tctx, &r),
2486                         "ClusterControl failed");
2487         }
2488         torture_assert_werr_ok(tctx,
2489                 r.out.result,
2490                 "ClusterControl failed");
2491
2492         /* now try what happens when we query with a buffer large enough to hold
2493          * the entire packet */
2494
2495         r.in.nOutBufferSize = 0xffff;
2496         r.out.lpOutBuffer = talloc_zero_array(tctx, uint8_t, r.in.nOutBufferSize);
2497
2498         torture_assert_ntstatus_ok(tctx,
2499                 dcerpc_clusapi_ClusterControl_r(b, tctx, &r),
2500                 "ClusterControl failed");
2501         torture_assert_werr_ok(tctx,
2502                 r.out.result,
2503                 "ClusterControl failed");
2504         torture_assert(tctx, *r.out.lpBytesReturned < r.in.nOutBufferSize,
2505                 "lpBytesReturned expected to be smaller than input size nOutBufferSize");
2506
2507         return true;
2508 }
2509
2510 static bool test_ClusterControl(struct torture_context *tctx,
2511                                 void *data)
2512 {
2513         struct torture_clusapi_context *t =
2514                 talloc_get_type_abort(data, struct torture_clusapi_context);
2515         struct policy_handle Cluster;
2516         bool ret;
2517         uint32_t control_codes[] = {
2518                 CLUSCTL_CLUSTER_GET_COMMON_PROPERTIES,
2519                 CLUSCTL_CLUSTER_GET_RO_COMMON_PROPERTIES,
2520                 CLUSCTL_CLUSTER_GET_FQDN,
2521                 CLUSCTL_CLUSTER_GET_PRIVATE_PROPERTIES,
2522                 CLUSCTL_CLUSTER_CHECK_VOTER_DOWN
2523         };
2524         int i;
2525
2526         if (!test_OpenCluster_int(tctx, t->p, &Cluster)) {
2527                 return false;
2528         }
2529
2530         for (i=0; i < ARRAY_SIZE(control_codes); i++) {
2531                 ret = test_ClusterControl_int(tctx, t->p, &Cluster,
2532                                               control_codes[i]);
2533                 if (!ret) {
2534                         goto done;
2535                 }
2536         }
2537
2538  done:
2539         test_CloseCluster_int(tctx, t->p, &Cluster);
2540
2541         return ret;
2542 }
2543
2544 static bool test_CreateResTypeEnum(struct torture_context *tctx,
2545                                    void *data)
2546 {
2547         struct torture_clusapi_context *t =
2548                 talloc_get_type_abort(data, struct torture_clusapi_context);
2549         struct dcerpc_binding_handle *b = t->p->binding_handle;
2550         struct clusapi_CreateResTypeEnum r;
2551         uint32_t dwType[] = {
2552                 CLUSTER_RESOURCE_TYPE_ENUM_NODES,
2553                 CLUSTER_RESOURCE_TYPE_ENUM_RESOURCES
2554         };
2555         uint32_t dwType_invalid[] = {
2556                 0x00000040,
2557                 0x00000080,
2558                 0x00000100 /* and many more ... */
2559         };
2560         const char *valid_names[] = {
2561                 "Physical Disk",
2562                 "Storage Pool"
2563         };
2564         const char *invalid_names[] = {
2565                 "INVALID_TYPE_XXXX"
2566         };
2567         struct ENUM_LIST *ReturnEnum;
2568         WERROR rpc_status;
2569         int i, s;
2570
2571         for (s = 0; s < ARRAY_SIZE(valid_names); s++) {
2572
2573                 r.in.lpszTypeName = valid_names[s];
2574
2575                 for (i=0; i < ARRAY_SIZE(dwType); i++) {
2576
2577                         r.in.dwType = dwType[i];
2578                         r.out.ReturnEnum = &ReturnEnum;
2579                         r.out.rpc_status = &rpc_status;
2580
2581                         torture_assert_ntstatus_ok(tctx,
2582                                 dcerpc_clusapi_CreateResTypeEnum_r(b, tctx, &r),
2583                                 "CreateResTypeEnum failed");
2584                         torture_assert_werr_ok(tctx,
2585                                 r.out.result,
2586                                 "CreateResTypeEnum failed");
2587                 }
2588
2589                 for (i=0; i < ARRAY_SIZE(dwType_invalid); i++) {
2590
2591                         r.in.dwType = dwType_invalid[i];
2592                         r.out.ReturnEnum = &ReturnEnum;
2593                         r.out.rpc_status = &rpc_status;
2594
2595                         torture_assert_ntstatus_ok(tctx,
2596                                 dcerpc_clusapi_CreateResTypeEnum_r(b, tctx, &r),
2597                                 "CreateResTypeEnum failed");
2598                         torture_assert_werr_ok(tctx,
2599                                 r.out.result,
2600                                 "CreateResTypeEnum failed");
2601                 }
2602         }
2603
2604         for (s = 0; s < ARRAY_SIZE(invalid_names); s++) {
2605
2606                 r.in.lpszTypeName = invalid_names[s];
2607
2608                 for (i=0; i < ARRAY_SIZE(dwType); i++) {
2609
2610                         r.in.dwType = dwType[i];
2611                         r.out.ReturnEnum = &ReturnEnum;
2612                         r.out.rpc_status = &rpc_status;
2613
2614                         torture_assert_ntstatus_ok(tctx,
2615                                 dcerpc_clusapi_CreateResTypeEnum_r(b, tctx, &r),
2616                                 "CreateResTypeEnum failed");
2617                         torture_assert_werr_equal(tctx,
2618                                 r.out.result,
2619                                 WERR_CLUSTER_RESOURCE_TYPE_NOT_FOUND,
2620                                 "CreateResTypeEnum failed");
2621                 }
2622
2623                 for (i=0; i < ARRAY_SIZE(dwType_invalid); i++) {
2624
2625                         r.in.dwType = dwType_invalid[i];
2626                         r.out.ReturnEnum = &ReturnEnum;
2627                         r.out.rpc_status = &rpc_status;
2628
2629                         torture_assert_ntstatus_ok(tctx,
2630                                 dcerpc_clusapi_CreateResTypeEnum_r(b, tctx, &r),
2631                                 "CreateResTypeEnum failed");
2632                         torture_assert_werr_equal(tctx,
2633                                 r.out.result,
2634                                 WERR_CLUSTER_RESOURCE_TYPE_NOT_FOUND,
2635                                 "CreateResTypeEnum failed");
2636                 }
2637         }
2638
2639
2640         return true;
2641 }
2642
2643 static bool test_CreateGroupEnum_int(struct torture_context *tctx,
2644                                      struct dcerpc_pipe *p,
2645                                      struct policy_handle *Cluster,
2646                                      const char **multi_sz,
2647                                      const char **multi_sz_ro)
2648 {
2649         struct dcerpc_binding_handle *b = p->binding_handle;
2650         struct clusapi_CreateGroupEnum r;
2651         struct GROUP_ENUM_LIST *pResultList;
2652         WERROR rpc_status;
2653         DATA_BLOB blob = data_blob_null;
2654         DATA_BLOB blob_ro = data_blob_null;
2655
2656         r.in.hCluster = *Cluster;
2657         r.in.pProperties = blob.data;
2658         r.in.cbProperties = blob.length;
2659         r.in.pRoProperties = blob_ro.data;
2660         r.in.cbRoProperties = blob_ro.length;
2661         r.out.ppResultList = &pResultList;
2662         r.out.rpc_status = &rpc_status;
2663
2664         torture_assert_ntstatus_ok(tctx,
2665                 dcerpc_clusapi_CreateGroupEnum_r(b, tctx, &r),
2666                 "CreateGroupEnum failed");
2667         torture_assert_werr_ok(tctx,
2668                 r.out.result,
2669                 "CreateGroupEnum failed");
2670
2671         if (!push_reg_multi_sz(tctx, &blob, multi_sz)) {
2672                 return false;
2673         }
2674
2675         if (!push_reg_multi_sz(tctx, &blob_ro, multi_sz_ro)) {
2676                 return false;
2677         }
2678
2679         r.in.pProperties = blob.data;
2680         r.in.cbProperties = blob.length;
2681
2682         r.in.pRoProperties = blob_ro.data;
2683         r.in.cbRoProperties = blob_ro.length;
2684
2685         torture_assert_ntstatus_ok(tctx,
2686                 dcerpc_clusapi_CreateGroupEnum_r(b, tctx, &r),
2687                 "CreateGroupEnum failed");
2688         torture_assert_werr_ok(tctx,
2689                 r.out.result,
2690                 "CreateGroupEnum failed");
2691
2692 #if 0
2693         {
2694                 int i;
2695                 enum ndr_err_code ndr_err;
2696
2697                 for (i=0; i < pResultList->EntryCount; i++) {
2698                         struct clusapi_PROPERTY_LIST list;
2699                         torture_comment(tctx, "entry #%d\n", i);
2700
2701                         blob = data_blob_const(pResultList->Entry[i].Properties,
2702                                                pResultList->Entry[i].cbProperties);
2703
2704                         ndr_err = ndr_pull_struct_blob(&blob, tctx, &list,
2705                                 (ndr_pull_flags_fn_t)ndr_pull_clusapi_PROPERTY_LIST);
2706                         if (NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2707                                 NDR_PRINT_DEBUG(clusapi_PROPERTY_LIST, &list);
2708                         }
2709
2710                         blob_ro = data_blob_const(pResultList->Entry[i].RoProperties,
2711                                                   pResultList->Entry[i].cbRoProperties);
2712
2713                         ndr_err = ndr_pull_struct_blob(&blob_ro, tctx, &list,
2714                                 (ndr_pull_flags_fn_t)ndr_pull_clusapi_PROPERTY_LIST);
2715                         if (NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2716                                 NDR_PRINT_DEBUG(clusapi_PROPERTY_LIST, &list);
2717                         }
2718                 }
2719         }
2720 #endif
2721
2722         return true;
2723 }
2724
2725 static bool test_CreateGroupEnum(struct torture_context *tctx,
2726                                  void *data)
2727 {
2728         struct torture_clusapi_context *t =
2729                 talloc_get_type_abort(data, struct torture_clusapi_context);
2730         struct policy_handle Cluster;
2731         bool ret;
2732         const char *multi_sz[] = {
2733                 "Priority", NULL,
2734         };
2735         const char *multi_sz_ro[] = {
2736                 "GroupType", NULL,
2737         };
2738
2739         if (!test_OpenCluster_int(tctx, t->p, &Cluster)) {
2740                 return false;
2741         }
2742
2743         ret = test_CreateGroupEnum_int(tctx, t->p, &Cluster,
2744                                        multi_sz, multi_sz_ro);
2745         if (!ret) {
2746                 goto done;
2747         }
2748
2749  done:
2750         test_CloseCluster_int(tctx, t->p, &Cluster);
2751
2752         return ret;
2753 }
2754
2755 static bool test_OpenNetwork_int(struct torture_context *tctx,
2756                                  struct dcerpc_pipe *p,
2757                                  const char *lpszNetworkName,
2758                                  struct policy_handle *hNetwork)
2759 {
2760         struct dcerpc_binding_handle *b = p->binding_handle;
2761         struct clusapi_OpenNetwork r;
2762         WERROR Status;
2763         WERROR rpc_status;
2764
2765         r.in.lpszNetworkName = lpszNetworkName;
2766         r.out.rpc_status = &rpc_status;
2767         r.out.Status = &Status;
2768         r.out.hNetwork = hNetwork ;
2769
2770         torture_assert_ntstatus_ok(tctx,
2771                 dcerpc_clusapi_OpenNetwork_r(b, tctx, &r),
2772                 "OpenNetwork failed");
2773         torture_assert_werr_ok(tctx,
2774                 *r.out.Status,
2775                 "OpenNetwork failed");
2776
2777         return true;
2778 }
2779
2780 static bool test_OpenNetworkEx_int(struct torture_context *tctx,
2781                                    struct dcerpc_pipe *p,
2782                                    const char *lpszNetworkName,
2783                                    struct policy_handle *hNetwork)
2784 {
2785         struct dcerpc_binding_handle *b = p->binding_handle;
2786         struct clusapi_OpenNetworkEx r;
2787         uint32_t lpdwGrantedAccess;
2788         WERROR Status;
2789         WERROR rpc_status;
2790
2791         r.in.lpszNetworkName = lpszNetworkName;
2792         r.in.dwDesiredAccess = SEC_FLAG_MAXIMUM_ALLOWED;
2793         r.out.lpdwGrantedAccess = &lpdwGrantedAccess;
2794         r.out.rpc_status = &rpc_status;
2795         r.out.Status = &Status;
2796         r.out.hNetwork = hNetwork ;
2797
2798         torture_assert_ntstatus_ok(tctx,
2799                 dcerpc_clusapi_OpenNetworkEx_r(b, tctx, &r),
2800                 "OpenNetworkEx failed");
2801         torture_assert_werr_ok(tctx,
2802                 *r.out.Status,
2803                 "OpenNetworkEx failed");
2804
2805         return true;
2806 }
2807
2808 static bool test_CloseNetwork_int(struct torture_context *tctx,
2809                                   struct dcerpc_pipe *p,
2810                                   struct policy_handle *Network)
2811 {
2812         struct dcerpc_binding_handle *b = p->binding_handle;
2813         struct clusapi_CloseNetwork r;
2814
2815         r.in.Network = Network;
2816         r.out.Network = Network;
2817
2818         torture_assert_ntstatus_ok(tctx,
2819                 dcerpc_clusapi_CloseNetwork_r(b, tctx, &r),
2820                 "CloseNetwork failed");
2821         torture_assert_werr_ok(tctx,
2822                 r.out.result,
2823                 "CloseNetwork failed");
2824         torture_assert(tctx,
2825                 ndr_policy_handle_empty(Network),
2826                 "policy_handle non empty after CloseNetwork");
2827
2828         return true;
2829 }
2830
2831 static bool test_OpenNetwork(struct torture_context *tctx,
2832                              void *data)
2833 {
2834         struct torture_clusapi_context *t =
2835                 talloc_get_type_abort(data, struct torture_clusapi_context);
2836         struct policy_handle hNetwork;
2837
2838         if (!test_OpenNetwork_int(tctx, t->p, "Cluster Network 1", &hNetwork)) {
2839                 return false;
2840         }
2841
2842         test_CloseNetwork_int(tctx, t->p, &hNetwork);
2843
2844         return true;
2845 }
2846
2847 static bool test_OpenNetworkEx(struct torture_context *tctx,
2848                                void *data)
2849 {
2850         struct torture_clusapi_context *t =
2851                 talloc_get_type_abort(data, struct torture_clusapi_context);
2852         struct policy_handle hNetwork;
2853
2854         if (!test_OpenNetworkEx_int(tctx, t->p, "Cluster Network 1", &hNetwork)) {
2855                 return false;
2856         }
2857
2858         test_CloseNetwork_int(tctx, t->p, &hNetwork);
2859
2860         return true;
2861 }
2862
2863 static bool test_CloseNetwork(struct torture_context *tctx,
2864                               void *data)
2865 {
2866         struct torture_clusapi_context *t =
2867                 talloc_get_type_abort(data, struct torture_clusapi_context);
2868         struct policy_handle hNetwork;
2869
2870         if (!test_OpenNetwork_int(tctx, t->p, "Cluster Network 1", &hNetwork)) {
2871                 return false;
2872         }
2873
2874         return test_CloseNetwork_int(tctx, t->p, &hNetwork);
2875 }
2876
2877 static bool test_GetNetworkState_int(struct torture_context *tctx,
2878                                      struct dcerpc_pipe *p,
2879                                      struct policy_handle *hNetwork)
2880 {
2881         struct dcerpc_binding_handle *b = p->binding_handle;
2882         struct clusapi_GetNetworkState r;
2883         enum clusapi_ClusterNetworkState State;
2884         WERROR rpc_status;
2885
2886         r.in.hNetwork = *hNetwork;
2887         r.out.State = &State;
2888         r.out.rpc_status = &rpc_status;
2889
2890         torture_assert_ntstatus_ok(tctx,
2891                 dcerpc_clusapi_GetNetworkState_r(b, tctx, &r),
2892                 "GetNetworkState failed");
2893         torture_assert_werr_ok(tctx,
2894                 r.out.result,
2895                 "GetNetworkState failed");
2896
2897         return true;
2898 }
2899
2900 static bool test_GetNetworkState(struct torture_context *tctx,
2901                                  void *data)
2902 {
2903         struct torture_clusapi_context *t =
2904                 talloc_get_type_abort(data, struct torture_clusapi_context);
2905         struct policy_handle hNetwork;
2906         bool ret = true;
2907
2908         if (!test_OpenNetwork_int(tctx, t->p, "Cluster Network 1", &hNetwork)) {
2909                 return false;
2910         }
2911
2912         ret = test_GetNetworkState_int(tctx, t->p, &hNetwork);
2913
2914         test_CloseNetwork_int(tctx, t->p, &hNetwork);
2915
2916         return ret;
2917 }
2918
2919 static bool test_GetNetworkId_int(struct torture_context *tctx,
2920                                   struct dcerpc_pipe *p,
2921                                   struct policy_handle *hNetwork)
2922 {
2923         struct dcerpc_binding_handle *b = p->binding_handle;
2924         struct clusapi_GetNetworkId r;
2925         const char *pGuid;
2926         WERROR rpc_status;
2927
2928         r.in.hNetwork = *hNetwork;
2929         r.out.pGuid = &pGuid;
2930         r.out.rpc_status = &rpc_status;
2931
2932         torture_assert_ntstatus_ok(tctx,
2933                 dcerpc_clusapi_GetNetworkId_r(b, tctx, &r),
2934                 "GetNetworkId failed");
2935         torture_assert_werr_ok(tctx,
2936                 r.out.result,
2937                 "GetNetworkId failed");
2938
2939         return true;
2940 }
2941
2942 static bool test_GetNetworkId(struct torture_context *tctx,
2943                               void *data)
2944 {
2945         struct torture_clusapi_context *t =
2946                 talloc_get_type_abort(data, struct torture_clusapi_context);
2947         struct policy_handle hNetwork;
2948         bool ret = true;
2949
2950         if (!test_OpenNetwork_int(tctx, t->p, "Cluster Network 1", &hNetwork)) {
2951                 return false;
2952         }
2953
2954         ret = test_GetNetworkId_int(tctx, t->p, &hNetwork);
2955
2956         test_CloseNetwork_int(tctx, t->p, &hNetwork);
2957
2958         return ret;
2959 }
2960
2961 static bool test_one_network(struct torture_context *tctx,
2962                              struct dcerpc_pipe *p,
2963                              const char *network_name)
2964 {
2965         struct policy_handle hNetwork;
2966
2967         torture_assert(tctx,
2968                 test_OpenNetwork_int(tctx, p, network_name, &hNetwork),
2969                 "failed to open network");
2970         test_CloseNetwork_int(tctx, p, &hNetwork);
2971
2972         torture_assert(tctx,
2973                 test_OpenNetworkEx_int(tctx, p, network_name, &hNetwork),
2974                 "failed to openex network");
2975
2976         torture_assert(tctx,
2977                 test_GetNetworkId_int(tctx, p, &hNetwork),
2978                 "failed to query network id");
2979         torture_assert(tctx,
2980                 test_GetNetworkState_int(tctx, p, &hNetwork),
2981                 "failed to query network id");
2982
2983         test_CloseNetwork_int(tctx, p, &hNetwork);
2984
2985         return true;
2986 }
2987
2988 static bool test_all_networks(struct torture_context *tctx,
2989                               void *data)
2990 {
2991         struct torture_clusapi_context *t =
2992                 talloc_get_type_abort(data, struct torture_clusapi_context);
2993         struct dcerpc_binding_handle *b = t->p->binding_handle;
2994         struct clusapi_CreateEnum r;
2995         uint32_t dwType = CLUSTER_ENUM_NETWORK;
2996         struct ENUM_LIST *ReturnEnum;
2997         WERROR rpc_status;
2998         int i;
2999
3000         r.in.dwType = dwType;
3001         r.out.ReturnEnum = &ReturnEnum;
3002         r.out.rpc_status = &rpc_status;
3003
3004         torture_assert_ntstatus_ok(tctx,
3005                 dcerpc_clusapi_CreateEnum_r(b, tctx, &r),
3006                 "CreateEnum failed");
3007         torture_assert_werr_ok(tctx,
3008                 r.out.result,
3009                 "CreateEnum failed");
3010
3011         for (i=0; i < ReturnEnum->EntryCount; i++) {
3012
3013                 struct ENUM_ENTRY e = ReturnEnum->Entry[i];
3014
3015                 torture_assert_int_equal(tctx, e.Type, CLUSTER_ENUM_NETWORK, "type mismatch");
3016
3017                 torture_assert(tctx,
3018                         test_one_network(tctx, t->p, e.Name),
3019                         "failed to test one network");
3020         }
3021
3022         return true;
3023 }
3024
3025 static bool test_OpenNetInterface_int(struct torture_context *tctx,
3026                                       struct dcerpc_pipe *p,
3027                                       const char *lpszNetInterfaceName,
3028                                       struct policy_handle *hNetInterface)
3029 {
3030         struct dcerpc_binding_handle *b = p->binding_handle;
3031         struct clusapi_OpenNetInterface r;
3032         WERROR Status;
3033         WERROR rpc_status;
3034
3035         r.in.lpszNetInterfaceName = lpszNetInterfaceName;
3036         r.out.rpc_status = &rpc_status;
3037         r.out.Status = &Status;
3038         r.out.hNetInterface = hNetInterface;
3039
3040         torture_assert_ntstatus_ok(tctx,
3041                 dcerpc_clusapi_OpenNetInterface_r(b, tctx, &r),
3042                 "OpenNetInterface failed");
3043         torture_assert_werr_ok(tctx,
3044                 *r.out.Status,
3045                 "OpenNetInterface failed");
3046
3047         return true;
3048 }
3049
3050 static bool test_OpenNetInterfaceEx_int(struct torture_context *tctx,
3051                                         struct dcerpc_pipe *p,
3052                                         const char *lpszNetInterfaceName,
3053                                         struct policy_handle *hNetInterface)
3054 {
3055         struct dcerpc_binding_handle *b = p->binding_handle;
3056         struct clusapi_OpenNetInterfaceEx r;
3057         uint32_t lpdwGrantedAccess;
3058         WERROR Status;
3059         WERROR rpc_status;
3060
3061         r.in.lpszNetInterfaceName = lpszNetInterfaceName;
3062         r.in.dwDesiredAccess = SEC_FLAG_MAXIMUM_ALLOWED;
3063         r.out.lpdwGrantedAccess = &lpdwGrantedAccess;
3064         r.out.rpc_status = &rpc_status;
3065         r.out.Status = &Status;
3066         r.out.hNetInterface = hNetInterface;
3067
3068         torture_assert_ntstatus_ok(tctx,
3069                 dcerpc_clusapi_OpenNetInterfaceEx_r(b, tctx, &r),
3070                 "OpenNetInterfaceEx failed");
3071         torture_assert_werr_ok(tctx,
3072                 *r.out.Status,
3073                 "OpenNetInterfaceEx failed");
3074
3075         return true;
3076 }
3077
3078 static bool test_CloseNetInterface_int(struct torture_context *tctx,
3079                                        struct dcerpc_pipe *p,
3080                                        struct policy_handle *NetInterface)
3081 {
3082         struct dcerpc_binding_handle *b = p->binding_handle;
3083         struct clusapi_CloseNetInterface r;
3084
3085         r.in.NetInterface = NetInterface;
3086         r.out.NetInterface = NetInterface;
3087
3088         torture_assert_ntstatus_ok(tctx,
3089                 dcerpc_clusapi_CloseNetInterface_r(b, tctx, &r),
3090                 "CloseNetInterface failed");
3091         torture_assert_werr_ok(tctx,
3092                 r.out.result,
3093                 "CloseNetInterface failed");
3094         torture_assert(tctx,
3095                 ndr_policy_handle_empty(NetInterface),
3096                 "policy_handle non empty after CloseNetInterface");
3097
3098         return true;
3099 }
3100
3101 static bool test_OpenNetInterface(struct torture_context *tctx,
3102                                   void *data)
3103 {
3104         struct torture_clusapi_context *t =
3105                 talloc_get_type_abort(data, struct torture_clusapi_context);
3106         struct policy_handle hNetInterface;
3107
3108         if (!test_OpenNetInterface_int(tctx, t->p, "node1 - Ethernet", &hNetInterface)) {
3109                 return false;
3110         }
3111
3112         test_CloseNetInterface_int(tctx, t->p, &hNetInterface);
3113
3114         return true;
3115 }
3116
3117 static bool test_OpenNetInterfaceEx(struct torture_context *tctx,
3118                                     void *data)
3119 {
3120         struct torture_clusapi_context *t =
3121                 talloc_get_type_abort(data, struct torture_clusapi_context);
3122         struct policy_handle hNetInterface;
3123
3124         if (!test_OpenNetInterfaceEx_int(tctx, t->p, "node1 - Ethernet", &hNetInterface)) {
3125                 return false;
3126         }
3127
3128         test_CloseNetInterface_int(tctx, t->p, &hNetInterface);
3129
3130         return true;
3131 }
3132
3133 static bool test_CloseNetInterface(struct torture_context *tctx,
3134                                    void *data)
3135 {
3136         struct torture_clusapi_context *t =
3137                 talloc_get_type_abort(data, struct torture_clusapi_context);
3138         struct policy_handle hNetInterface;
3139
3140         if (!test_OpenNetInterface_int(tctx, t->p, "node1 - Ethernet", &hNetInterface)) {
3141                 return false;
3142         }
3143
3144         return test_CloseNetInterface_int(tctx, t->p, &hNetInterface);
3145 }
3146
3147 static bool test_GetNetInterfaceState_int(struct torture_context *tctx,
3148                                           struct dcerpc_pipe *p,
3149                                           struct policy_handle *hNetInterface)
3150 {
3151         struct dcerpc_binding_handle *b = p->binding_handle;
3152         struct clusapi_GetNetInterfaceState r;
3153         enum clusapi_ClusterNetInterfaceState State;
3154         WERROR rpc_status;
3155
3156         r.in.hNetInterface = *hNetInterface;
3157         r.out.State = &State;
3158         r.out.rpc_status = &rpc_status;
3159
3160         torture_assert_ntstatus_ok(tctx,
3161                 dcerpc_clusapi_GetNetInterfaceState_r(b, tctx, &r),
3162                 "GetNetInterfaceState failed");
3163         torture_assert_werr_ok(tctx,
3164                 r.out.result,
3165                 "GetNetInterfaceState failed");
3166
3167         return true;
3168 }
3169
3170 static bool test_GetNetInterfaceState(struct torture_context *tctx,
3171                                       void *data)
3172 {
3173         struct torture_clusapi_context *t =
3174                 talloc_get_type_abort(data, struct torture_clusapi_context);
3175         struct policy_handle hNetInterface;
3176         bool ret = true;
3177
3178         if (!test_OpenNetInterface_int(tctx, t->p, "node1 - Ethernet", &hNetInterface)) {
3179                 return false;
3180         }
3181
3182         ret = test_GetNetInterfaceState_int(tctx, t->p, &hNetInterface);
3183
3184         test_CloseNetInterface_int(tctx, t->p, &hNetInterface);
3185
3186         return ret;
3187 }
3188
3189 static bool test_GetNetInterfaceId_int(struct torture_context *tctx,
3190                                        struct dcerpc_pipe *p,
3191                                        struct policy_handle *hNetInterface)
3192 {
3193         struct dcerpc_binding_handle *b = p->binding_handle;
3194         struct clusapi_GetNetInterfaceId r;
3195         const char *pGuid;
3196         WERROR rpc_status;
3197
3198         r.in.hNetInterface = *hNetInterface;
3199         r.out.pGuid = &pGuid;
3200         r.out.rpc_status = &rpc_status;
3201
3202         torture_assert_ntstatus_ok(tctx,
3203                 dcerpc_clusapi_GetNetInterfaceId_r(b, tctx, &r),
3204                 "GetNetInterfaceId failed");
3205         torture_assert_werr_ok(tctx,
3206                 r.out.result,
3207                 "GetNetInterfaceId failed");
3208
3209         return true;
3210 }
3211
3212 static bool test_GetNetInterfaceId(struct torture_context *tctx,
3213                                    void *data)
3214 {
3215         struct torture_clusapi_context *t =
3216                 talloc_get_type_abort(data, struct torture_clusapi_context);
3217         struct policy_handle hNetInterface;
3218         bool ret = true;
3219
3220         if (!test_OpenNetInterface_int(tctx, t->p, "node1 - Ethernet", &hNetInterface)) {
3221                 return false;
3222         }
3223
3224         ret = test_GetNetInterfaceId_int(tctx, t->p, &hNetInterface);
3225
3226         test_CloseNetInterface_int(tctx, t->p, &hNetInterface);
3227
3228         return ret;
3229 }
3230
3231 static bool test_one_netinterface(struct torture_context *tctx,
3232                                   struct dcerpc_pipe *p,
3233                                   const char *netinterface_name)
3234 {
3235         struct policy_handle hNetInterface;
3236
3237         torture_assert(tctx,
3238                 test_OpenNetInterface_int(tctx, p, netinterface_name, &hNetInterface),
3239                 "failed to open netinterface");
3240         test_CloseNetInterface_int(tctx, p, &hNetInterface);
3241
3242         torture_assert(tctx,
3243                 test_OpenNetInterfaceEx_int(tctx, p, netinterface_name, &hNetInterface),
3244                 "failed to openex netinterface");
3245
3246         torture_assert(tctx,
3247                 test_GetNetInterfaceId_int(tctx, p, &hNetInterface),
3248                 "failed to query netinterface id");
3249         torture_assert(tctx,
3250                 test_GetNetInterfaceState_int(tctx, p, &hNetInterface),
3251                 "failed to query netinterface id");
3252
3253         test_CloseNetInterface_int(tctx, p, &hNetInterface);
3254
3255         return true;
3256 }
3257
3258 static bool test_all_netinterfaces(struct torture_context *tctx,
3259                                    void *data)
3260 {
3261         struct torture_clusapi_context *t =
3262                 talloc_get_type_abort(data, struct torture_clusapi_context);
3263         struct dcerpc_binding_handle *b = t->p->binding_handle;
3264         struct clusapi_CreateEnum r;
3265         uint32_t dwType = CLUSTER_ENUM_NETINTERFACE;
3266         struct ENUM_LIST *ReturnEnum;
3267         WERROR rpc_status;
3268         int i;
3269
3270         r.in.dwType = dwType;
3271         r.out.ReturnEnum = &ReturnEnum;
3272         r.out.rpc_status = &rpc_status;
3273
3274         torture_assert_ntstatus_ok(tctx,
3275                 dcerpc_clusapi_CreateEnum_r(b, tctx, &r),
3276                 "CreateEnum failed");
3277         torture_assert_werr_ok(tctx,
3278                 r.out.result,
3279                 "CreateEnum failed");
3280
3281         for (i=0; i < ReturnEnum->EntryCount; i++) {
3282
3283                 struct ENUM_ENTRY e = ReturnEnum->Entry[i];
3284
3285                 torture_assert_int_equal(tctx, e.Type, CLUSTER_ENUM_NETINTERFACE, "type mismatch");
3286
3287                 torture_assert(tctx,
3288                         test_one_netinterface(tctx, t->p, e.Name),
3289                         "failed to test one netinterface");
3290         }
3291
3292         return true;
3293 }
3294
3295 static bool test_CloseKey_int(struct torture_context *tctx,
3296                               struct dcerpc_pipe *p,
3297                               struct policy_handle *pKey)
3298 {
3299         struct dcerpc_binding_handle *b = p->binding_handle;
3300         struct clusapi_CloseKey r;
3301
3302         r.in.pKey = pKey;
3303         r.out.pKey = pKey;
3304
3305         torture_assert_ntstatus_ok(tctx,
3306                 dcerpc_clusapi_CloseKey_r(b, tctx, &r),
3307                 "CloseKey failed");
3308         torture_assert_werr_ok(tctx,
3309                 r.out.result,
3310                 "CloseKey failed");
3311         torture_assert(tctx,
3312                 ndr_policy_handle_empty(pKey),
3313                 "policy_handle non empty after CloseKey");
3314
3315         return true;
3316 }
3317
3318 static bool test_GetRootKey_int(struct torture_context *tctx,
3319                                 struct dcerpc_pipe *p,
3320                                 struct policy_handle *phKey)
3321 {
3322         struct dcerpc_binding_handle *b = p->binding_handle;
3323         struct clusapi_GetRootKey r;
3324         WERROR Status;
3325         WERROR rpc_status;
3326
3327         r.in.samDesired = SEC_FLAG_MAXIMUM_ALLOWED;
3328         r.out.Status = &Status;
3329         r.out.rpc_status = &rpc_status;
3330         r.out.phKey = phKey;
3331
3332         torture_assert_ntstatus_ok(tctx,
3333                 dcerpc_clusapi_GetRootKey_r(b, tctx, &r),
3334                 "GetRootKey failed");
3335         torture_assert_werr_ok(tctx,
3336                 *r.out.Status,
3337                 "GetRootKey failed");
3338
3339         return true;
3340 }
3341
3342 static bool test_EnumKey_int(struct torture_context *tctx,
3343                              struct dcerpc_pipe *p,
3344                              struct policy_handle *hKey)
3345 {
3346         struct dcerpc_binding_handle *b = p->binding_handle;
3347         struct clusapi_EnumKey r;
3348         const char *KeyName;
3349         NTTIME lpftLastWriteTime;
3350         WERROR rpc_status;
3351
3352         r.in.hKey = *hKey;
3353         r.in.dwIndex = 0;
3354         r.out.KeyName = &KeyName;
3355         r.out.lpftLastWriteTime = &lpftLastWriteTime;
3356         r.out.rpc_status = &rpc_status;
3357
3358         torture_assert_ntstatus_ok(tctx,
3359                 dcerpc_clusapi_EnumKey_r(b, tctx, &r),
3360                 "EnumKey failed");
3361         torture_assert_werr_ok(tctx,
3362                 r.out.result,
3363                 "EnumKey failed");
3364
3365         return true;
3366 }
3367
3368 static bool test_OpenKey_int(struct torture_context *tctx,
3369                              struct dcerpc_pipe *p,
3370                              struct policy_handle *hKey,
3371                              const char *lpSubKey,
3372                              struct policy_handle *phKey)
3373 {
3374         struct dcerpc_binding_handle *b = p->binding_handle;
3375         struct clusapi_OpenKey r;
3376         WERROR Status;
3377         WERROR rpc_status;
3378
3379         r.in.hKey = *hKey;
3380         r.in.lpSubKey = lpSubKey;
3381         r.in.samDesired = SEC_FLAG_MAXIMUM_ALLOWED;
3382         r.out.Status = &Status;
3383         r.out.rpc_status = &rpc_status;
3384         r.out.phKey = phKey;
3385
3386         torture_assert_ntstatus_ok(tctx,
3387                 dcerpc_clusapi_OpenKey_r(b, tctx, &r),
3388                 "OpenKey failed");
3389         torture_assert_werr_ok(tctx,
3390                 *r.out.Status,
3391                 "OpenKey failed");
3392
3393         return true;
3394 }
3395
3396 static bool test_EnumValue_int(struct torture_context *tctx,
3397                                struct dcerpc_pipe *p,
3398                                struct policy_handle *hKey)
3399 {
3400         struct dcerpc_binding_handle *b = p->binding_handle;
3401         struct clusapi_EnumValue r;
3402         const char *lpValueName;
3403         uint32_t lpType;
3404         uint32_t TotalSize;
3405         WERROR rpc_status;
3406         int i = 0;
3407
3408         do {
3409                 uint32_t lpcbData = 1024;
3410
3411                 r.in.hKey = *hKey;
3412                 r.in.dwIndex = i++;
3413                 r.in.lpcbData = &lpcbData;
3414                 r.out.lpValueName = &lpValueName;
3415                 r.out.lpType = &lpType;
3416                 r.out.lpData = talloc_array(tctx, uint8_t, lpcbData);
3417                 r.out.TotalSize = &TotalSize;
3418                 r.out.rpc_status = &rpc_status;
3419                 r.out.lpcbData = &lpcbData;
3420
3421                 torture_assert_ntstatus_ok(tctx,
3422                         dcerpc_clusapi_EnumValue_r(b, tctx, &r),
3423                         "EnumValue failed");
3424
3425         } while (W_ERROR_IS_OK(r.out.result));
3426
3427         torture_assert_werr_equal(tctx,
3428                 r.out.result,
3429                 WERR_NO_MORE_ITEMS,
3430                 "EnumValue failed");
3431
3432         return true;
3433 }
3434
3435 static bool test_QueryInfoKey_int(struct torture_context *tctx,
3436                                   struct dcerpc_pipe *p,
3437                                   struct policy_handle *hKey)
3438 {
3439         struct dcerpc_binding_handle *b = p->binding_handle;
3440         struct clusapi_QueryInfoKey r;
3441         uint32_t lpcSubKeys;
3442         uint32_t lpcbMaxSubKeyLen;
3443         uint32_t lpcValues;
3444         uint32_t lpcbMaxValueNameLen;
3445         uint32_t lpcbMaxValueLen;
3446         uint32_t lpcbSecurityDescriptor;
3447         NTTIME lpftLastWriteTime;
3448         WERROR rpc_status;
3449
3450         r.in.hKey = *hKey;
3451         r.out.lpcSubKeys = &lpcSubKeys;
3452         r.out.lpcbMaxSubKeyLen = &lpcbMaxSubKeyLen;
3453         r.out.lpcValues = &lpcValues;
3454         r.out.lpcbMaxValueNameLen = &lpcbMaxValueNameLen;
3455         r.out.lpcbMaxValueLen = &lpcbMaxValueLen;
3456         r.out.lpcbSecurityDescriptor = &lpcbSecurityDescriptor;
3457         r.out.lpftLastWriteTime = &lpftLastWriteTime;
3458         r.out.rpc_status = &rpc_status;
3459
3460         torture_assert_ntstatus_ok(tctx,
3461                 dcerpc_clusapi_QueryInfoKey_r(b, tctx, &r),
3462                 "QueryInfoKey failed");
3463         torture_assert_werr_ok(tctx,
3464                 r.out.result,
3465                 "QueryInfoKey failed");
3466
3467         return true;
3468 }
3469
3470 static bool test_GetKeySecurity_int(struct torture_context *tctx,
3471                                     struct dcerpc_pipe *p,
3472                                     struct policy_handle *hKey)
3473 {
3474         struct dcerpc_binding_handle *b = p->binding_handle;
3475         struct clusapi_GetKeySecurity r;
3476         uint32_t SecurityInformation = SECINFO_DACL | SECINFO_OWNER | SECINFO_GROUP;
3477         struct RPC_SECURITY_DESCRIPTOR pRpcSecurityDescriptor;
3478         WERROR rpc_status;
3479
3480         ZERO_STRUCT(pRpcSecurityDescriptor);
3481
3482         r.in.hKey = *hKey;
3483         r.in.SecurityInformation = SecurityInformation;
3484         r.in.pRpcSecurityDescriptor = &pRpcSecurityDescriptor;
3485         r.out.rpc_status = &rpc_status;
3486         r.out.pRpcSecurityDescriptor = &pRpcSecurityDescriptor;
3487
3488         torture_assert_ntstatus_ok(tctx,
3489                 dcerpc_clusapi_GetKeySecurity_r(b, tctx, &r),
3490                 "GetKeySecurity failed");
3491
3492         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
3493                 pRpcSecurityDescriptor.lpSecurityDescriptor = talloc_array(tctx,
3494                 uint8_t, pRpcSecurityDescriptor.cbInSecurityDescriptor);
3495
3496                 torture_assert_ntstatus_ok(tctx,
3497                         dcerpc_clusapi_GetKeySecurity_r(b, tctx, &r),
3498                         "GetKeySecurity failed");
3499         }
3500
3501         torture_assert_werr_ok(tctx,
3502                 r.out.result,
3503                 "GetKeySecurity failed");
3504
3505         return true;
3506 }
3507
3508 static bool test_GetRootKey(struct torture_context *tctx,
3509                             void *data)
3510 {
3511         struct torture_clusapi_context *t =
3512                 talloc_get_type_abort(data, struct torture_clusapi_context);
3513         struct policy_handle hKey;
3514
3515         if (!test_GetRootKey_int(tctx, t->p, &hKey)) {
3516                 return false;
3517         }
3518
3519         test_CloseKey_int(tctx, t->p, &hKey);
3520
3521         return true;
3522 }
3523
3524 static bool test_CloseKey(struct torture_context *tctx,
3525                           void *data)
3526 {
3527         struct torture_clusapi_context *t =
3528                 talloc_get_type_abort(data, struct torture_clusapi_context);
3529         struct policy_handle hKey;
3530
3531         if (!test_GetRootKey_int(tctx, t->p, &hKey)) {
3532                 return false;
3533         }
3534
3535         return test_CloseKey_int(tctx, t->p, &hKey);
3536 }
3537
3538 static bool test_EnumKey(struct torture_context *tctx,
3539                          void *data)
3540 {
3541         struct torture_clusapi_context *t =
3542                 talloc_get_type_abort(data, struct torture_clusapi_context);
3543         struct policy_handle hKey;
3544         bool ret = true;
3545
3546         if (!test_GetRootKey_int(tctx, t->p, &hKey)) {
3547                 return false;
3548         }
3549
3550         ret = test_EnumKey_int(tctx, t->p, &hKey);
3551
3552         test_CloseKey_int(tctx, t->p, &hKey);
3553
3554         return ret;
3555 }
3556
3557 static bool test_QueryValue_int(struct torture_context *tctx,
3558                                 struct dcerpc_pipe *p,
3559                                 struct policy_handle *hKey,
3560                                 const char *ValueName)
3561 {
3562         struct dcerpc_binding_handle *b = p->binding_handle;
3563         struct clusapi_QueryValue r;
3564         uint32_t lpValueType;
3565         uint32_t lpcbRequired;
3566         WERROR rpc_status;
3567
3568         r.in.hKey = *hKey;
3569         r.in.lpValueName = ValueName;
3570         r.in.cbData = 0;
3571         r.out.lpValueType = &lpValueType;
3572         r.out.lpData = NULL;
3573         r.out.lpcbRequired = &lpcbRequired;
3574         r.out.rpc_status = &rpc_status;
3575
3576         torture_assert_ntstatus_ok(tctx,
3577                 dcerpc_clusapi_QueryValue_r(b, tctx, &r),
3578                 "QueryValue failed");
3579
3580         if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
3581
3582                 r.in.cbData = lpcbRequired;
3583                 r.out.lpData = talloc_zero_array(tctx, uint8_t, r.in.cbData);
3584
3585                 torture_assert_ntstatus_ok(tctx,
3586                         dcerpc_clusapi_QueryValue_r(b, tctx, &r),
3587                         "QueryValue failed");
3588         }
3589
3590         torture_assert_werr_ok(tctx,
3591                 r.out.result,
3592                 "QueryValue failed");
3593
3594         if (lpValueType == REG_SZ) {
3595                 const char *s;
3596                 DATA_BLOB blob = data_blob_const(r.out.lpData, lpcbRequired);
3597                 pull_reg_sz(tctx, &blob, &s);
3598                 torture_comment(tctx, "got: %s\n", s);
3599         }
3600
3601         return true;
3602 }
3603
3604 static bool test_QueryValue(struct torture_context *tctx,
3605                             void *data)
3606 {
3607         struct torture_clusapi_context *t =
3608                 talloc_get_type_abort(data, struct torture_clusapi_context);
3609         struct policy_handle hKey;
3610         bool ret = true;
3611
3612         if (!test_GetRootKey_int(tctx, t->p, &hKey)) {
3613                 return false;
3614         }
3615
3616         ret = test_QueryValue_int(tctx, t->p, &hKey, "ClusterInstanceID");
3617
3618         test_CloseKey_int(tctx, t->p, &hKey);
3619
3620         return ret;
3621 }
3622
3623
3624 static bool test_one_key(struct torture_context *tctx,
3625                          struct dcerpc_pipe *p,
3626                          struct policy_handle *hKey,
3627                          const char *KeyName)
3628 {
3629         struct policy_handle phKey;
3630
3631         torture_assert(tctx,
3632                 test_OpenKey_int(tctx, p, hKey, KeyName, &phKey),
3633                 "failed to open key");
3634
3635         torture_assert(tctx,
3636                 test_QueryInfoKey_int(tctx, p, &phKey),
3637                 "failed to enum values");
3638         torture_assert(tctx,
3639                 test_GetKeySecurity_int(tctx, p, &phKey),
3640                 "failed to get key security");
3641
3642         torture_assert(tctx,
3643                 test_EnumValue_int(tctx, p, &phKey),
3644                 "failed to enum values");
3645
3646         torture_assert(tctx,
3647                 test_CloseKey_int(tctx, p, &phKey),
3648                 "failed to close key");
3649
3650         return true;
3651 }
3652
3653 static bool test_all_keys(struct torture_context *tctx,
3654                           void *data)
3655 {
3656         struct torture_clusapi_context *t =
3657                 talloc_get_type_abort(data, struct torture_clusapi_context);
3658         struct dcerpc_binding_handle *b = t->p->binding_handle;
3659         struct policy_handle hKey;
3660         struct clusapi_EnumKey r;
3661         const char *KeyName;
3662         NTTIME lpftLastWriteTime;
3663         WERROR rpc_status;
3664         int i = 0;
3665
3666         if (!test_GetRootKey_int(tctx, t->p, &hKey)) {
3667                 return false;
3668         }
3669
3670         do {
3671                 r.in.hKey = hKey;
3672                 r.in.dwIndex = i++;
3673                 r.out.KeyName = &KeyName;
3674                 r.out.lpftLastWriteTime = &lpftLastWriteTime;
3675                 r.out.rpc_status = &rpc_status;
3676
3677                 torture_assert_ntstatus_ok(tctx,
3678                         dcerpc_clusapi_EnumKey_r(b, tctx, &r),
3679                         "EnumKey failed");
3680
3681                 if (W_ERROR_IS_OK(r.out.result)) {
3682                         torture_assert(tctx,
3683                                 test_one_key(tctx, t->p, &hKey, KeyName),
3684                                 "failed to test one key");
3685                 }
3686
3687         } while (W_ERROR_IS_OK(r.out.result));
3688
3689         torture_assert_werr_equal(tctx,
3690                 r.out.result,
3691                 WERR_NO_MORE_ITEMS,
3692                 "EnumKey failed");
3693
3694         test_CloseKey_int(tctx, t->p, &hKey);
3695
3696         return true;
3697 }
3698
3699 static bool torture_rpc_clusapi_setup_common(struct torture_context *tctx,
3700                                              struct torture_clusapi_context *t)
3701 {
3702         struct dcerpc_binding_handle *b;
3703
3704         torture_assert_ntstatus_ok(tctx,
3705                 torture_rpc_connection(tctx, &t->p, &ndr_table_clusapi),
3706                 "Error connecting to server");
3707
3708         {
3709                 struct clusapi_GetClusterName r;
3710
3711                 b = t->p->binding_handle;
3712
3713                 r.out.ClusterName = &t->ClusterName;
3714                 r.out.NodeName = &t->NodeName;
3715
3716                 torture_assert_ntstatus_ok(tctx,
3717                         dcerpc_clusapi_GetClusterName_r(b, tctx, &r),
3718                         "GetClusterName failed");
3719                 torture_assert_werr_ok(tctx,
3720                         r.out.result,
3721                         "GetClusterName failed");
3722         }
3723
3724         return true;
3725 }
3726
3727 static bool torture_rpc_clusapi_setup(struct torture_context *tctx,
3728                                       void **data)
3729 {
3730         struct torture_clusapi_context *t;
3731
3732         *data = t = talloc_zero(tctx, struct torture_clusapi_context);
3733
3734         return torture_rpc_clusapi_setup_common(tctx, t);
3735 }
3736
3737 static bool torture_rpc_clusapi_teardown(struct torture_context *tctx,
3738                                          void *data)
3739 {
3740         talloc_free(data);
3741
3742         return true;
3743 }
3744
3745 void torture_tcase_cluster(struct torture_tcase *tcase)
3746 {
3747         torture_tcase_add_simple_test(tcase, "OpenCluster",
3748                                       test_OpenCluster);
3749         torture_tcase_add_simple_test(tcase, "OpenClusterEx",
3750                                       test_OpenClusterEx);
3751         torture_tcase_add_simple_test(tcase, "CloseCluster",
3752                                       test_CloseCluster);
3753         torture_tcase_add_simple_test(tcase, "SetClusterName",
3754                                       test_SetClusterName);
3755         torture_tcase_add_simple_test(tcase, "GetClusterName",
3756                                       test_GetClusterName);
3757         torture_tcase_add_simple_test(tcase, "GetClusterVersion",
3758                                       test_GetClusterVersion);
3759         torture_tcase_add_simple_test(tcase, "CreateEnum",
3760                                       test_CreateEnum);
3761         torture_tcase_add_simple_test(tcase, "CreateEnumEx",
3762                                       test_CreateEnumEx);
3763         torture_tcase_add_simple_test(tcase, "GetClusterVersion2",
3764                                       test_GetClusterVersion2);
3765         torture_tcase_add_simple_test(tcase, "BackupClusterDatabase",
3766                                       test_BackupClusterDatabase);
3767         torture_tcase_add_simple_test(tcase, "SetServiceAccountPassword",
3768                                       test_SetServiceAccountPassword);
3769         torture_tcase_add_simple_test(tcase, "ClusterControl",
3770                                       test_ClusterControl);
3771         torture_tcase_add_simple_test(tcase, "CreateResTypeEnum",
3772                                       test_CreateResTypeEnum);
3773         torture_tcase_add_simple_test(tcase, "CreateGroupEnum",
3774                                       test_CreateGroupEnum);
3775
3776 }
3777
3778 void torture_tcase_resource(struct torture_tcase *tcase)
3779 {
3780         struct torture_test *test;
3781
3782         torture_tcase_add_simple_test(tcase, "GetQuorumResource",
3783                                       test_GetQuorumResource);
3784         torture_tcase_add_simple_test(tcase, "SetQuorumResource",
3785                                       test_SetQuorumResource);
3786         torture_tcase_add_simple_test(tcase, "OpenResource",
3787                                       test_OpenResource);
3788         torture_tcase_add_simple_test(tcase, "OpenResourceEx",
3789                                       test_OpenResourceEx);
3790         torture_tcase_add_simple_test(tcase, "CloseResource",
3791                                       test_CloseResource);
3792         torture_tcase_add_simple_test(tcase, "CreateResource",
3793                                       test_CreateResource);
3794         torture_tcase_add_simple_test(tcase, "DeleteResource",
3795                                       test_DeleteResource);
3796         torture_tcase_add_simple_test(tcase, "SetResourceName",
3797                                       test_SetResourceName);
3798         torture_tcase_add_simple_test(tcase, "GetResourceState",
3799                                       test_GetResourceState);
3800         torture_tcase_add_simple_test(tcase, "GetResourceId",
3801                                       test_GetResourceId);
3802         torture_tcase_add_simple_test(tcase, "GetResourceType",
3803                                       test_GetResourceType);
3804         torture_tcase_add_simple_test(tcase, "CreateResEnum",
3805                                       test_CreateResEnum);
3806         test = torture_tcase_add_simple_test(tcase, "FailResource",
3807                                       test_FailResource);
3808         test->dangerous = true;
3809         torture_tcase_add_simple_test(tcase, "OnlineResource",
3810                                       test_OnlineResource);
3811         test = torture_tcase_add_simple_test(tcase, "OfflineResource",
3812                                       test_OfflineResource);
3813         test->dangerous = true;
3814         torture_tcase_add_simple_test(tcase, "GetResourceDependencyExpression",
3815                                       test_GetResourceDependencyExpression);
3816         torture_tcase_add_simple_test(tcase, "GetResourceNetworkName",
3817                                       test_GetResourceNetworkName);
3818         torture_tcase_add_simple_test(tcase, "all_resources",
3819                                       test_all_resources);
3820 }
3821
3822 void torture_tcase_resourcetype(struct torture_tcase *tcase)
3823 {
3824         torture_tcase_add_simple_test(tcase, "all_resourcetypes",
3825                                       test_all_resourcetypes);
3826 }
3827
3828 void torture_tcase_node(struct torture_tcase *tcase)
3829 {
3830         struct torture_test *test;
3831
3832         torture_tcase_add_simple_test(tcase, "OpenNode",
3833                                       test_OpenNode);
3834         torture_tcase_add_simple_test(tcase, "OpenNodeEx",
3835                                       test_OpenNodeEx);
3836         torture_tcase_add_simple_test(tcase, "CloseNode",
3837                                       test_CloseNode);
3838         torture_tcase_add_simple_test(tcase, "GetNodeState",
3839                                       test_GetNodeState);
3840         torture_tcase_add_simple_test(tcase, "GetNodeId",
3841                                       test_GetNodeId);
3842         torture_tcase_add_simple_test(tcase, "NodeControl",
3843                                       test_NodeControl);
3844         test = torture_tcase_add_simple_test(tcase, "PauseNode",
3845                                              test_PauseNode);
3846         test->dangerous = true;
3847         torture_tcase_add_simple_test(tcase, "ResumeNode",
3848                                       test_ResumeNode);
3849         test = torture_tcase_add_simple_test(tcase, "EvictNode",
3850                                              test_EvictNode);
3851         test->dangerous = true;
3852         torture_tcase_add_simple_test(tcase, "all_nodes",
3853                                       test_all_nodes);
3854 }
3855
3856 void torture_tcase_group(struct torture_tcase *tcase)
3857 {
3858         struct torture_test *test;
3859
3860         torture_tcase_add_simple_test(tcase, "OpenGroup",
3861                                       test_OpenGroup);
3862         torture_tcase_add_simple_test(tcase, "OpenGroupEx",
3863                                       test_OpenGroupEx);
3864         torture_tcase_add_simple_test(tcase, "CloseGroup",
3865                                       test_CloseGroup);
3866         torture_tcase_add_simple_test(tcase, "GetGroupState",
3867                                       test_GetGroupState);
3868         torture_tcase_add_simple_test(tcase, "GetGroupId",
3869                                       test_GetGroupId);
3870         torture_tcase_add_simple_test(tcase, "GroupControl",
3871                                       test_GroupControl);
3872         torture_tcase_add_simple_test(tcase, "OnlineGroup",
3873                                       test_OnlineGroup);
3874         test = torture_tcase_add_simple_test(tcase, "OfflineGroup",
3875                                       test_OfflineGroup);
3876         test->dangerous = true;
3877         torture_tcase_add_simple_test(tcase, "all_groups",
3878                                       test_all_groups);
3879 }
3880
3881 void torture_tcase_network(struct torture_tcase *tcase)
3882 {
3883         torture_tcase_add_simple_test(tcase, "OpenNetwork",
3884                                       test_OpenNetwork);
3885         torture_tcase_add_simple_test(tcase, "OpenNetworkEx",
3886                                       test_OpenNetworkEx);
3887         torture_tcase_add_simple_test(tcase, "CloseNetwork",
3888                                       test_CloseNetwork);
3889         torture_tcase_add_simple_test(tcase, "GetNetworkState",
3890                                       test_GetNetworkState);
3891         torture_tcase_add_simple_test(tcase, "GetNetworkId",
3892                                       test_GetNetworkId);
3893         torture_tcase_add_simple_test(tcase, "all_networks",
3894                                       test_all_networks);
3895 }
3896
3897 void torture_tcase_netinterface(struct torture_tcase *tcase)
3898 {
3899         torture_tcase_add_simple_test(tcase, "OpenNetInterface",
3900                                       test_OpenNetInterface);
3901         torture_tcase_add_simple_test(tcase, "OpenNetInterfaceEx",
3902                                       test_OpenNetInterfaceEx);
3903         torture_tcase_add_simple_test(tcase, "CloseNetInterface",
3904                                       test_CloseNetInterface);
3905         torture_tcase_add_simple_test(tcase, "GetNetInterfaceState",
3906                                       test_GetNetInterfaceState);
3907         torture_tcase_add_simple_test(tcase, "GetNetInterfaceId",
3908                                       test_GetNetInterfaceId);
3909         torture_tcase_add_simple_test(tcase, "all_netinterfaces",
3910                                       test_all_netinterfaces);
3911 }
3912
3913 void torture_tcase_registry(struct torture_tcase *tcase)
3914 {
3915         torture_tcase_add_simple_test(tcase, "GetRootKey",
3916                                       test_GetRootKey);
3917         torture_tcase_add_simple_test(tcase, "CloseKey",
3918                                       test_CloseKey);
3919         torture_tcase_add_simple_test(tcase, "EnumKey",
3920                                       test_EnumKey);
3921         torture_tcase_add_simple_test(tcase, "QueryValue",
3922                                       test_QueryValue);
3923         torture_tcase_add_simple_test(tcase, "all_keys",
3924                                       test_all_keys);
3925 }
3926
3927 struct torture_suite *torture_rpc_clusapi(TALLOC_CTX *mem_ctx)
3928 {
3929         struct torture_tcase *tcase;
3930         struct torture_suite *suite = torture_suite_create(mem_ctx, "clusapi");
3931
3932         tcase = torture_suite_add_tcase(suite, "cluster");
3933
3934         torture_tcase_set_fixture(tcase,
3935                                   torture_rpc_clusapi_setup,
3936                                   torture_rpc_clusapi_teardown);
3937
3938         torture_tcase_cluster(tcase);
3939
3940         tcase = torture_suite_add_tcase(suite, "resource");
3941
3942         torture_tcase_set_fixture(tcase,
3943                                   torture_rpc_clusapi_setup,
3944                                   torture_rpc_clusapi_teardown);
3945
3946         torture_tcase_resource(tcase);
3947
3948         tcase = torture_suite_add_tcase(suite, "resourcetype");
3949
3950         torture_tcase_set_fixture(tcase,
3951                                   torture_rpc_clusapi_setup,
3952                                   torture_rpc_clusapi_teardown);
3953
3954         torture_tcase_resourcetype(tcase);
3955
3956
3957         tcase = torture_suite_add_tcase(suite, "node");
3958
3959         torture_tcase_set_fixture(tcase,
3960                                   torture_rpc_clusapi_setup,
3961                                   torture_rpc_clusapi_teardown);
3962
3963         torture_tcase_node(tcase);
3964
3965         tcase = torture_suite_add_tcase(suite, "group");
3966
3967         torture_tcase_set_fixture(tcase,
3968                                   torture_rpc_clusapi_setup,
3969                                   torture_rpc_clusapi_teardown);
3970
3971         torture_tcase_group(tcase);
3972
3973         tcase = torture_suite_add_tcase(suite, "network");
3974
3975         torture_tcase_set_fixture(tcase,
3976                                   torture_rpc_clusapi_setup,
3977                                   torture_rpc_clusapi_teardown);
3978
3979         torture_tcase_network(tcase);
3980
3981         tcase = torture_suite_add_tcase(suite, "netinterface");
3982
3983         torture_tcase_set_fixture(tcase,
3984                                   torture_rpc_clusapi_setup,
3985                                   torture_rpc_clusapi_teardown);
3986
3987         torture_tcase_netinterface(tcase);
3988
3989         tcase = torture_suite_add_tcase(suite, "registry");
3990
3991         torture_tcase_set_fixture(tcase,
3992                                   torture_rpc_clusapi_setup,
3993                                   torture_rpc_clusapi_teardown);
3994
3995         torture_tcase_registry(tcase);
3996
3997         return suite;
3998 }