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