librpc/idl/clusapi.idl

   1 import "security.idl";
   2
   3 #include "idl_types.h"
   4
   5 [
   6         uuid(b97db8b2-4c63-11cf-bff6-08002be23f2f),
   7         version(3.0),
   8         pointer_default(unique),
   9         helpstring("Failover Cluster Management API (clusapi)")
  10 ]
  11         interface clusapi
  12 {
  13 #if 0
  14         typedef [context_handle] void *HCLUSTER_RPC;
  15         typedef [context_handle] void *HNODE_RPC;
  16         typedef [context_handle] void *HGROUP_RPC;
  17         typedef [context_handle] void *HRES_RPC;
  18         typedef [context_handle] void *HKEY_RPC;
  19         typedef [context_handle] void *HNOTIFY_RPC;
  20         typedef [context_handle] void *HNETWORK_RPC;
  21         typedef [context_handle] void *HNETINTERFACE_RPC;
  22         typedef [context_handle] void *HBATCH_PORT_RPC;
  23 #else
  24         #define HCLUSTER_RPC policy_handle
  25         #define HNODE_RPC policy_handle
  26         #define HGROUP_RPC policy_handle
  27         #define HRES_RPC policy_handle
  28         #define HKEY_RPC policy_handle
  29         #define HNOTIFY_RPC policy_handle
  30         #define HNETWORK_RPC policy_handle
  31         #define HNETINTERFACE_RPC policy_handle
  32         #define HBATCH_PORT_RPC policy_handle
  33 #endif
  34
  35         typedef struct {
  36                 [ size_is( cbInSecurityDescriptor ), length_is( cbOutSecurityDescriptor ) ] uint8 *lpSecurityDescriptor;
  37                 uint32 cbInSecurityDescriptor;
  38                 uint32 cbOutSecurityDescriptor;
  39         } RPC_SECURITY_DESCRIPTOR;
  40
  41         typedef struct {
  42                 uint32 nLength;
  43                 RPC_SECURITY_DESCRIPTOR RpcSecurityDescriptor;
  44                 long bInheritHandle;
  45         } RPC_SECURITY_ATTRIBUTES;
  46
  47         typedef struct {
  48                 [value(20)] uint32 dwSize;
  49                 uint32 dwClusterHighestVersion;
  50                 uint32 dwClusterLowestVersion;
  51                 uint32 dwFlags;
  52                 uint32 dwReserved;
  53         } CLUSTER_OPERATIONAL_VERSION_INFO;
  54
  55         typedef struct {
  56                 uint32   NodeId;
  57                 boolean8  SetAttempted;
  58                 uint32   ReturnStatus;
  59         } IDL_CLUSTER_SET_PASSWORD_STATUS;
  60
  61         typedef enum {
  62                 IDL_CLUSTER_SET_PASSWORD_IGNORE_DOWN_NODES = 1
  63         } IDL_CLUSTER_SET_PASSWORD_FLAGS;
  64
  65         typedef struct {
  66                 uint32  dwVersion;
  67                 uint32  dwGroupType;
  68         } CLUSTER_CREATE_GROUP_INFO_RPC;
  69
  70         /*****************/
  71         /* Function 0x00 */
  72
  73 #if 0
  74         HCLUSTER_RPC
  75         clusapi_OpenCluster(
  76                 [ out ] WERROR *Status
  77         );
  78 #else
  79         void
  80         clusapi_OpenCluster(
  81                 [ out ] WERROR *Status,
  82                 [ out ] HCLUSTER_RPC *Cluster
  83         );
  84 #endif
  85
  86         /*****************/
  87         /* Function 0x01 */
  88
  89         WERROR
  90         clusapi_CloseCluster(
  91                 [ in, out ] HCLUSTER_RPC *Cluster
  92         );
  93
  94         /*****************/
  95         /* Function 0x02 */
  96
  97         WERROR
  98         clusapi_SetClusterName(
  99                 [ in, string ] [charset(UTF16)] uint16 *NewClusterName,
 100                 [ out ] WERROR *rpc_status
 101         );
 102
 103         /*****************/
 104         /* Function 0x03 */
 105
 106         WERROR
 107         clusapi_GetClusterName(
 108                 [ out, string ] [charset(UTF16)] uint16 **ClusterName,
 109                 [ out, string ] [charset(UTF16)] uint16 **NodeName
 110         );
 111
 112         /*****************/
 113         /* Function 0x04 */
 114
 115         WERROR
 116         clusapi_GetClusterVersion(
 117                 [ out ] uint16 *lpwMajorVersion,
 118                 [ out ] uint16 *lpwMinorVersion,
 119                 [ out ] uint16 *lpwBuildNumber,
 120                 [ out, string ] [charset(UTF16)] uint16 **lpszVendorId,
 121                 [ out, string ] [charset(UTF16)] uint16 **lpszCSDVersion
 122         );
 123
 124         /*****************/
 125         /* Function 0x05 */
 126
 127         WERROR
 128         clusapi_GetQuorumResource(
 129                 [ out, string ] [charset(UTF16)] uint16 **lpszResourceName,
 130                 [ out, string ] [charset(UTF16)] uint16 **lpszDeviceName,
 131                 [ out ] uint32 *pdwMaxQuorumLogSize,
 132                 [ out ] WERROR *rpc_status
 133         );
 134
 135         /*****************/
 136         /* Function 0x06 */
 137
 138         WERROR
 139         clusapi_SetQuorumResource(
 140                 [ in ] HRES_RPC hResource,
 141                 [ in, string ] [charset(UTF16)] uint16 *lpszDeviceName,
 142                 [ in ] uint32    dwMaxQuorumLogSize,
 143                 [ out ] WERROR *rpc_status
 144         );
 145
 146         typedef [bitmap32bit] bitmap {
 147                 CLUSTER_ENUM_NODE                       = 0x00000001,
 148                 CLUSTER_ENUM_RESTYPE                    = 0x00000002,
 149                 CLUSTER_ENUM_RESOURCE                   = 0x00000004,
 150                 CLUSTER_ENUM_GROUP                      = 0x00000008,
 151                 CLUSTER_ENUM_NETWORK                    = 0x00000010,
 152                 CLUSTER_ENUM_NETINTERFACE               = 0x00000020,
 153                 CLUSTER_ENUM_INTERNAL_NETWORK           = 0x80000000,
 154                 CLUSTER_ENUM_SHARED_VOLUME_RESOURCE     = 0x40000000
 155         } ClusterEnumType;
 156
 157         typedef struct {
 158                 ClusterEnumType Type;
 159                 [string] [charset(UTF16)] uint16 *Name;
 160         } ENUM_ENTRY;
 161
 162         typedef struct {
 163                 uint32 EntryCount;
 164                 [size_is(EntryCount)] ENUM_ENTRY Entry[*];
 165         } ENUM_LIST;
 166
 167         typedef struct {
 168                 [string] [charset(UTF16)] uint16 *Name;
 169                 [string] [charset(UTF16)] uint16 *Id;
 170                 uint32 dwState;
 171                 [string] [charset(UTF16)] uint16 *Owner;
 172                 uint32 dwFlags;
 173                 uint32 cbProperties;
 174                 [size_is(cbProperties)] uint8* Properties;
 175                 uint32 cbRoProperties;
 176                 [size_is(cbRoProperties)] uint8* RoProperties;
 177         } GROUP_ENUM_ENTRY;
 178
 179         typedef struct {
 180                 [string] [charset(UTF16)] uint16 *Name;
 181                 [string] [charset(UTF16)] uint16 *Id;
 182                 [string] [charset(UTF16)] uint16 *OwnerName;
 183                 [string] [charset(UTF16)] uint16 *OwnerId;
 184                 uint32 cbProperties;
 185                 [size_is(cbProperties)] uint8* Properties;
 186                 uint32 cbRoProperties;
 187                 [size_is(cbRoProperties)] uint8* RoProperties;
 188         } RESOURCE_ENUM_ENTRY;
 189
 190         typedef struct {
 191                 uint32 EntryCount;
 192                 [size_is(EntryCount)] GROUP_ENUM_ENTRY Entry[*];
 193         } GROUP_ENUM_LIST;
 194
 195         typedef struct {
 196                 uint32 EntryCount;
 197                 [size_is(EntryCount)] RESOURCE_ENUM_ENTRY Entry[*];
 198         } RESOURCE_ENUM_LIST;
 199
 200         /*****************/
 201         /* Function 0x07 */
 202
 203         WERROR
 204         clusapi_CreateEnum(
 205                 [ in ] ClusterEnumType dwType,
 206                 [ out ] ENUM_LIST **ReturnEnum,
 207                 [ out ] WERROR *rpc_status
 208         );
 209
 210         /*****************/
 211         /* Function 0x08 */
 212
 213 #if 0
 214         HRES_RPC
 215         clusapi_OpenResource(
 216                 [ in, string ] [charset(UTF16)] uint16 *lpszResourceName,
 217                 [ out ] WERROR *Status,
 218                 [ out ] WERROR *rpc_status
 219         );
 220 #else
 221         void
 222         clusapi_OpenResource(
 223                 [ in, string ] [charset(UTF16)] uint16 *lpszResourceName,
 224                 [ out ] WERROR *Status,
 225                 [ out ] WERROR *rpc_status,
 226                 [ out ] HRES_RPC *hResource
 227         );
 228 #endif
 229         /*****************/
 230         /* Function 0x09 */
 231
 232 #if 0
 233         HRES_RPC
 234         clusapi_CreateResource(
 235                 [ in ] HGROUP_RPC hGroup,
 236                 [ in, string ] [charset(UTF16)] uint16 *lpszResourceName,
 237                 [ in, string ] [charset(UTF16)] uint16 *lpszResourceType,
 238                 [ in ] uint32 dwFlags,
 239                 [ out ] WERROR *Status,
 240                 [ out ] WERROR *rpc_status
 241         );
 242 #else
 243         void
 244         clusapi_CreateResource(
 245                 [ in ] HGROUP_RPC hGroup,
 246                 [ in, string ] [charset(UTF16)] uint16 *lpszResourceName,
 247                 [ in, string ] [charset(UTF16)] uint16 *lpszResourceType,
 248                 [ in ] uint32 dwFlags,
 249                 [ out ] WERROR *Status,
 250                 [ out ] WERROR *rpc_status,
 251                 [ out ] HRES_RPC *hResource
 252         );
 253 #endif
 254         /*****************/
 255         /* Function 0x0A */
 256
 257         WERROR
 258         clusapi_DeleteResource(
 259                 [ in ] HRES_RPC hResource,
 260                 [ out ] WERROR *rpc_status
 261         );
 262
 263         /*****************/
 264         /* Function 0x0B */
 265
 266         WERROR
 267         clusapi_CloseResource(
 268                 [ in, out ] HRES_RPC *Resource
 269         );
 270
 271         /*****************/
 272         /* Function 0x0C */
 273
 274         typedef [v1_enum] enum {
 275                 ClusterResourceInitializing     = 0x00000001,
 276                 ClusterResourceOnline           = 0x00000002,
 277                 ClusterResourceOffline          = 0x00000003,
 278                 ClusterResourceFailed           = 0x00000004,
 279                 ClusterResourceOnlinePending    = 0x00000081,
 280                 ClusterResourceOfflinePending   = 0x00000082,
 281                 ClusterResourceStateUnknown     = 0xFFFFFFFF
 282         } clusapi_ClusterResourceState;
 283
 284         WERROR
 285         clusapi_GetResourceState(
 286                 [ in ] HRES_RPC hResource,
 287                 [ out ] clusapi_ClusterResourceState *State,
 288                 [ out, string ] [charset(UTF16)] uint16 **NodeName,
 289                 [ out, string ] [charset(UTF16)] uint16 **GroupName,
 290                 [ out ] WERROR *rpc_status
 291         );
 292
 293         /*****************/
 294         /* Function 0x0D */
 295
 296         WERROR
 297         clusapi_SetResourceName(
 298                 [ in ] HRES_RPC hResource,
 299                 [ in, string ] [charset(UTF16)] uint16 *lpszResourceName,
 300                 [ out ] WERROR *rpc_status
 301         );
 302
 303         /*****************/
 304         /* Function 0x0E */
 305
 306         WERROR
 307         clusapi_GetResourceId(
 308                 [ in ] HRES_RPC hResource,
 309                 [ out, string ] [charset(UTF16)] uint16 **pGuid,
 310                 [ out ] WERROR *rpc_status
 311         );
 312
 313         /*****************/
 314         /* Function 0x0F */
 315
 316         WERROR
 317         clusapi_GetResourceType(
 318                 [ in ] HRES_RPC hResource,
 319                 [ out, string ] [charset(UTF16)] uint16 **lpszResourceType,
 320                 [ out ] WERROR *rpc_status
 321         );
 322
 323         /*****************/
 324         /* Function 0x10 */
 325
 326         WERROR
 327         clusapi_FailResource(
 328                 [ in ] HRES_RPC hResource,
 329                 [ out ] WERROR *rpc_status
 330         );
 331
 332         /*****************/
 333         /* Function 0x11 */
 334
 335         WERROR
 336         clusapi_OnlineResource(
 337                 [ in ] HRES_RPC hResource,
 338                 [ out ] WERROR *rpc_status
 339         );
 340
 341         /*****************/
 342         /* Function 0x12 */
 343
 344         WERROR
 345         clusapi_OfflineResource(
 346                 [ in ] HRES_RPC hResource,
 347                 [ out ] WERROR *rpc_status
 348         );
 349
 350         /*****************/
 351         /* Function 0x13 */
 352
 353         WERROR
 354         clusapi_AddResourceDependency(
 355                 [ in ] HRES_RPC hResource,
 356                 [ in ] HRES_RPC hDependsOn,
 357                 [ out ] WERROR *rpc_status
 358         );
 359
 360         /*****************/
 361         /* Function 0x14 */
 362
 363         WERROR
 364         clusapi_RemoveResourceDependency(
 365                 [ in ] HRES_RPC hResource,
 366                 [ in ] HRES_RPC hDependsOn,
 367                 [ out ] WERROR *rpc_status
 368         );
 369
 370         /*****************/
 371         /* Function 0x15 */
 372
 373         WERROR
 374         clusapi_CanResourceBeDependent(
 375                 [ in ] HRES_RPC hResource,
 376                 [ in ] HRES_RPC hResourceDependent,
 377                 [ out ] WERROR *rpc_status
 378         );
 379
 380         /*****************/
 381         /* Function 0x16 */
 382
 383         WERROR
 384         clusapi_CreateResEnum(
 385                 [ in ] HRES_RPC hResource,
 386                 [ in ] uint32 dwType,
 387                 [ out ] ENUM_LIST **ReturnEnum,
 388                 [ out ] WERROR *rpc_status
 389         );
 390
 391         /*****************/
 392         /* Function 0x17 */
 393
 394         WERROR
 395         clusapi_AddResourceNode(
 396                 [ in ] HRES_RPC hResource,
 397                 [ in ] HNODE_RPC hNode,
 398                 [ out ] WERROR *rpc_status
 399         );
 400
 401         /*****************/
 402         /* Function 0x18 */
 403
 404         WERROR
 405         clusapi_RemoveResourceNode(
 406                 [ in ] HRES_RPC hResource,
 407                 [ in ] HNODE_RPC hNode,
 408                 [ out ] WERROR *rpc_status
 409         );
 410
 411         /*****************/
 412         /* Function 0x19 */
 413
 414         WERROR
 415         clusapi_ChangeResourceGroup(
 416                 [ in ] HRES_RPC hResource,
 417                 [ in ] HGROUP_RPC hGroup,
 418                 [ out ] WERROR *rpc_status
 419         );
 420
 421         /*****************/
 422         /* Function 0x1A */
 423
 424         WERROR
 425         clusapi_CreateResourceType(
 426                 [ in, string ] [charset(UTF16)] uint16 *lpszTypeName,
 427                 [ in, string ] [charset(UTF16)] uint16 *lpszDisplayName,
 428                 [ in, string ] [charset(UTF16)] uint16 *lpszDllName,
 429                 [ in ] uint32 dwLooksAlive,
 430                 [ in ] uint32 dwIsAlive,
 431                 [ out ] WERROR *rpc_status
 432         );
 433
 434         /*****************/
 435         /* Function 0x1B */
 436
 437         WERROR
 438         clusapi_DeleteResourceType(
 439                 [ in, string ] [charset(UTF16)] uint16 *lpszTypeName,
 440                 [ out ] WERROR *rpc_status
 441         );
 442
 443         /*****************/
 444         /* Function 0x1C */
 445 #if 0
 446         HKEY_RPC
 447         clusapi_GetRootKey(
 448                 [ in ] uint32 samDesired,
 449                 [ out ] WERROR *Status,
 450                 [ out ] WERROR *rpc_status
 451         );
 452 #else
 453         void
 454         clusapi_GetRootKey(
 455                 [ in ] uint32 samDesired,
 456                 [ out ] WERROR *Status,
 457                 [ out ] WERROR *rpc_status,
 458                 [ out ] HKEY_RPC *phKey
 459         );
 460 #endif
 461         /*****************/
 462         /* Function 0x1D */
 463 #if 0
 464         HKEY_RPC
 465         clusapi_CreateKey(
 466                 [ in ] HKEY_RPC hKey,
 467                 [ in, string ] [charset(UTF16)] uint16 *lpSubKey,
 468                 [ in ] uint32 dwOptions,
 469                 [ in ] uint32 samDesired,
 470                 [ in, unique ] RPC_SECURITY_ATTRIBUTES *lpSecurityAttributes,
 471                 [ out ] uint32 *lpdwDisposition,
 472                 [ out ] WERROR *Status,
 473                 [ out ] WERROR *rpc_status
 474         );
 475 #else
 476         void
 477         clusapi_CreateKey(
 478                 [ in ] HKEY_RPC hKey,
 479                 [ in, string ] [charset(UTF16)] uint16 *lpSubKey,
 480                 [ in ] uint32 dwOptions,
 481                 [ in ] uint32 samDesired,
 482                 [ in, unique ] RPC_SECURITY_ATTRIBUTES *lpSecurityAttributes,
 483                 [ out ] uint32 *lpdwDisposition,
 484                 [ out ] WERROR *Status,
 485                 [ out ] WERROR *rpc_status,
 486                 [ out ] HKEY_RPC *phKey
 487         );
 488 #endif
 489         /*****************/
 490         /* Function 0x1E */
 491 #if 0
 492         HKEY_RPC
 493         clusapi_OpenKey(
 494                 [ in ] HKEY_RPC hKey,
 495                 [ in, string ] [charset(UTF16)] uint16 *lpSubKey,
 496                 [ in ] uint32 samDesired,
 497                 [ out ] WERROR *Status,
 498                 [ out ] WERROR *rpc_status
 499         );
 500 #else
 501         void
 502         clusapi_OpenKey(
 503                 [ in ] HKEY_RPC hKey,
 504                 [ in, string ] [charset(UTF16)] uint16 *lpSubKey,
 505                 [ in ] uint32 samDesired,
 506                 [ out ] WERROR *Status,
 507                 [ out ] WERROR *rpc_status,
 508                 [ out ] HKEY_RPC *phKey
 509         );
 510 #endif
 511         /*****************/
 512         /* Function 0x1F */
 513
 514         WERROR
 515         clusapi_EnumKey(
 516                 [ in ] HKEY_RPC hKey,
 517                 [ in ] uint32 dwIndex,
 518                 [ out, string ] [charset(UTF16)] uint16 **KeyName,
 519                 [ out ] NTTIME *lpftLastWriteTime,
 520                 [ out ] WERROR *rpc_status
 521         );
 522
 523         /*****************/
 524         /* Function 0x20 */
 525
 526         WERROR
 527         clusapi_SetValue(
 528                 [ in ] HKEY_RPC hKey,
 529                 [ in, string ] [charset(UTF16)] uint16 *lpValueName,
 530                 [ in ] uint32 dwType,
 531                 [ in, size_is(cbData) ] uint8 *lpData,
 532                 [ in ] uint32 cbData,
 533                 [ out ] WERROR *rpc_status
 534         );
 535
 536         /*****************/
 537         /* Function 0x21 */
 538
 539         WERROR
 540         clusapi_DeleteValue(
 541                 [ in ] HKEY_RPC hKey,
 542                 [ in, string ] [charset(UTF16)] uint16 *lpValueName,
 543                 [ out ] WERROR *rpc_status
 544         );
 545
 546         /*****************/
 547         /* Function 0x22 */
 548
 549         WERROR
 550         clusapi_QueryValue(
 551                 [ in ] HKEY_RPC hKey,
 552                 [ in, string ] [charset(UTF16)] uint16 *lpValueName,
 553                 [ out ] uint32 *lpValueType,
 554                 [ out, size_is(cbData) ] uint8 *lpData,
 555                 [ in ] uint32 cbData,
 556                 [ out ] uint32 *lpcbRequired,
 557                 [ out ] WERROR *rpc_status
 558         );
 559
 560         /*****************/
 561         /* Function 0x23 */
 562
 563         WERROR
 564         clusapi_DeleteKey(
 565                 [ in ] HKEY_RPC hKey,
 566                 [ in, string ] [charset(UTF16)] uint16 *lpSubKey,
 567                 [ out ] WERROR *rpc_status
 568         );
 569
 570         /*****************/
 571         /* Function 0x24 */
 572
 573         WERROR
 574         clusapi_EnumValue(
 575                 [ in ] HKEY_RPC hKey,
 576                 [ in ] uint32 dwIndex,
 577                 [ out, string ] [charset(UTF16)] uint16 **lpValueName,
 578                 [ out ] uint32 *lpType,
 579                 [ out, size_is(*lpcbData) ] uint8 *lpData,
 580                 [ in, out ] uint32 *lpcbData,
 581                 [ out ] uint32 *TotalSize,
 582                 [ out ] WERROR *rpc_status
 583         );
 584
 585         /*****************/
 586         /* Function 0x25 */
 587
 588         WERROR
 589         clusapi_CloseKey(
 590                 [ in, out ] HKEY_RPC *pKey
 591         );
 592
 593         /*****************/
 594         /* Function 0x26 */
 595
 596         WERROR
 597         clusapi_QueryInfoKey(
 598                 [ in ] HKEY_RPC hKey,
 599                 [ out ] uint32 *lpcSubKeys,
 600                 [ out ] uint32 *lpcbMaxSubKeyLen,
 601                 [ out ] uint32 *lpcValues,
 602                 [ out ] uint32 *lpcbMaxValueNameLen,
 603                 [ out ] uint32 *lpcbMaxValueLen,
 604                 [ out ] uint32 *lpcbSecurityDescriptor,
 605                 [ out ] NTTIME *lpftLastWriteTime,
 606                 [ out ] WERROR *rpc_status
 607         );
 608
 609         /*****************/
 610         /* Function 0x27 */
 611
 612         WERROR
 613         clusapi_SetKeySecurity(
 614                 [ in ] HKEY_RPC hKey,
 615                 [ in ] uint32 SecurityInformation,
 616                 [ in ] RPC_SECURITY_DESCRIPTOR *pRpcSecurityDescriptor,
 617                 [ out ] WERROR *rpc_status
 618         );
 619
 620         /*****************/
 621         /* Function 0x28 */
 622
 623         WERROR
 624         clusapi_GetKeySecurity(
 625                 [ in ] HKEY_RPC hKey,
 626                 [ in ] uint32 SecurityInformation,
 627                 [ in, out ] RPC_SECURITY_DESCRIPTOR *pRpcSecurityDescriptor,
 628                 [ out ] WERROR *rpc_status
 629         );
 630
 631         /*****************/
 632         /* Function 0x29 */
 633 #if 0
 634         HGROUP_RPC
 635         clusapi_OpenGroup(
 636                 [ in, string ] [charset(UTF16)] uint16 *lpszGroupName,
 637                 [ out ] WERROR *Status,
 638                 [ out ] WERROR *rpc_status
 639         );
 640 #else
 641         void
 642         clusapi_OpenGroup(
 643                 [ in, string ] [charset(UTF16)] uint16 *lpszGroupName,
 644                 [ out ] WERROR *Status,
 645                 [ out ] WERROR *rpc_status,
 646                 [ out ] HGROUP_RPC *hGroup
 647         );
 648 #endif
 649         /*****************/
 650         /* Function 0x2A */
 651 #if 0
 652         HGROUP_RPC
 653         clusapi_CreateGroup(
 654                 [ in, string ] [charset(UTF16)] uint16 *lpszGroupName,
 655                 [ out ] WERROR *Status,
 656                 [ out ] WERROR *rpc_status
 657         );
 658 #else
 659         void
 660         clusapi_CreateGroup(
 661                 [ in, string ] [charset(UTF16)] uint16 *lpszGroupName,
 662                 [ out ] WERROR *Status,
 663                 [ out ] WERROR *rpc_status,
 664                 [ out ] HGROUP_RPC *hGroup
 665         );
 666 #endif
 667         /*****************/
 668         /* Function 0x2B */
 669
 670         WERROR
 671         clusapi_DeleteGroup(
 672                 [ in ] HGROUP_RPC Group,
 673                 [ in ] boolean8 force,
 674                 [ out ] WERROR *rpc_status
 675         );
 676
 677         /*****************/
 678         /* Function 0x2C */
 679
 680         WERROR
 681         clusapi_CloseGroup(
 682                 [ in, out ] HGROUP_RPC *Group
 683         );
 684
 685         /*****************/
 686         /* Function 0x2D */
 687
 688         WERROR
 689         clusapi_GetGroupState(
 690                 [ in ] HGROUP_RPC hGroup,
 691                 [ out ] uint32 *State,
 692                 [ out, string ] [charset(UTF16)] uint16 **NodeName,
 693                 [ out ] WERROR *rpc_status
 694         );
 695
 696         /*****************/
 697         /* Function 0x2E */
 698
 699         WERROR
 700         clusapi_SetGroupName(
 701                 [ in ] HGROUP_RPC hGroup,
 702                 [ in, string ] [charset(UTF16)] uint16 *lpszGroupName,
 703                 [ out ] WERROR *rpc_status
 704         );
 705
 706         /*****************/
 707         /* Function 0x2F */
 708
 709         WERROR
 710         clusapi_GetGroupId(
 711                 [ in ] HGROUP_RPC hGroup,
 712                 [ out, string ] [charset(UTF16)] uint16 **pGuid,
 713                 [ out ] WERROR *rpc_status
 714         );
 715
 716         /*****************/
 717         /* Function 0x30 */
 718
 719         WERROR
 720         clusapi_GetNodeId(
 721                 [ in ] HNODE_RPC hNode,
 722                 [ out, string ] [charset(UTF16)] uint16 **pGuid,
 723                 [ out ] WERROR *rpc_status
 724         );
 725
 726         /*****************/
 727         /* Function 0x31 */
 728
 729         WERROR
 730         clusapi_OnlineGroup(
 731                 [ in ] HGROUP_RPC hGroup,
 732                 [ out ] WERROR *rpc_status
 733         );
 734
 735         /*****************/
 736         /* Function 0x32 */
 737
 738         WERROR
 739         clusapi_OfflineGroup(
 740                 [ in ] HGROUP_RPC hGroup,
 741                 [ out ] WERROR *rpc_status
 742         );
 743
 744         /*****************/
 745         /* Function 0x33 */
 746
 747         WERROR
 748         clusapi_MoveGroup(
 749                 [ in ] HGROUP_RPC hGroup,
 750                 [ out ] WERROR *rpc_status
 751         );
 752
 753         /*****************/
 754         /* Function 0x34 */
 755
 756         WERROR
 757         clusapi_MoveGroupToNode(
 758                 [ in ] HGROUP_RPC hGroup,
 759                 [ in ] HNODE_RPC hNode,
 760                 [ out ] WERROR *rpc_status
 761         );
 762
 763         /*****************/
 764         /* Function 0x35 */
 765
 766         WERROR
 767         clusapi_CreateGroupResourceEnum(
 768                 [ in ] HGROUP_RPC hGroup,
 769                 [ in ] uint32 dwType,
 770                 [ out ] ENUM_LIST **ReturnEnum,
 771                 [ out ] WERROR *rpc_status
 772         );
 773
 774         /*****************/
 775         /* Function 0x36 */
 776
 777         WERROR
 778         clusapi_SetGroupNodeList(
 779                 [ in ] HGROUP_RPC hGroup,
 780                 [ in, unique, size_is(cchListSize) ] uint16 *multiSzNodeList,
 781                 [ in ] uint32 cchListSize,
 782                 [ out ] WERROR *rpc_status
 783         );
 784
 785         /*****************/
 786         /* Function 0x37 */
 787 #if 0
 788         HNOTIFY_RPC
 789         clusapi_CreateNotify(
 790                 [ out ] WERROR *Status,
 791                 [ out ] WERROR *rpc_status
 792         );
 793 #else
 794         void
 795         clusapi_CreateNotify(
 796                 [ out ] WERROR *Status,
 797                 [ out ] WERROR *rpc_status,
 798                 [ out ] HNOTIFY_RPC *hNotify
 799         );
 800 #endif
 801         /*****************/
 802         /* Function 0x38 */
 803
 804         WERROR
 805         clusapi_CloseNotify(
 806                 [ in, out ] HNOTIFY_RPC *Notify
 807         );
 808
 809         /*****************/
 810         /* Function 0x39 */
 811
 812         WERROR
 813         clusapi_AddNotifyCluster(
 814                 [ in ] HNOTIFY_RPC hNotify,
 815                 [ in ] HCLUSTER_RPC hCluster,
 816                 [ in ] uint32 dwFilter,
 817                 [ in ] uint32 dwNotifyKey,
 818                 [ out ] WERROR *rpc_status
 819         );
 820
 821         /*****************/
 822         /* Function 0x3A */
 823
 824         WERROR
 825         clusapi_AddNotifyNode(
 826                 [ in ] HNOTIFY_RPC hNotify,
 827                 [ in ] HNODE_RPC hNode,
 828                 [ in ] uint32 dwFilter,
 829                 [ in ] uint32 dwNotifyKey,
 830                 [ out ] uint32 *dwStateSequence,
 831                 [ out ] WERROR *rpc_status
 832         );
 833
 834         /*****************/
 835         /* Function 0x3B */
 836
 837         WERROR
 838         clusapi_AddNotifyGroup(
 839                 [ in ] HNOTIFY_RPC hNotify,
 840                 [ in ] HGROUP_RPC hGroup,
 841                 [ in ] uint32 dwFilter,
 842                 [ in ] uint32 dwNotifyKey,
 843                 [ out ] uint32 *dwStateSequence,
 844                 [ out ] WERROR *rpc_status
 845         );
 846
 847         /*****************/
 848         /* Function 0x3C */
 849
 850         WERROR
 851         clusapi_AddNotifyResource(
 852                 [ in ] HNOTIFY_RPC hNotify,
 853                 [ in ] HRES_RPC hResource,
 854                 [ in ] uint32 dwFilter,
 855                 [ in ] uint32 dwNotifyKey,
 856                 [ out ] uint32 *dwStateSequence,
 857                 [ out ] WERROR *rpc_status
 858         );
 859
 860         /*****************/
 861         /* Function 0x3D */
 862
 863         WERROR
 864         clusapi_AddNotifyKey(
 865                 [ in ] HNOTIFY_RPC hNotify,
 866                 [ in ] HKEY_RPC hKey,
 867                 [ in ] uint32 dwNotifyKey,
 868                 [ in ] uint32 Filter,
 869                 [ in ] boolean8 WatchSubTree,
 870                 [ out ] WERROR *rpc_status
 871         );
 872
 873         /*****************/
 874         /* Function 0x3E */
 875
 876         WERROR
 877         clusapi_ReAddNotifyNode(
 878                 [ in ] HNOTIFY_RPC hNotify,
 879                 [ in ] HNODE_RPC hNode,
 880                 [ in ] uint32 dwFilter,
 881                 [ in ] uint32 dwNotifyKey,
 882                 [ in ] uint32 StateSequence,
 883                 [ out ] WERROR *rpc_status
 884         );
 885
 886         /*****************/
 887         /* Function 0x3F */
 888
 889         WERROR
 890         clusapi_ReAddNotifyGroup(
 891                 [ in ] HNOTIFY_RPC hNotify,
 892                 [ in ] HGROUP_RPC hGroup,
 893                 [ in ] uint32 dwFilter,
 894                 [ in ] uint32 dwNotifyKey,
 895                 [ in ] uint32 StateSequence,
 896                 [ out ] WERROR *rpc_status
 897         );
 898
 899         /*****************/
 900         /* Function 0x40 */
 901
 902         WERROR
 903         clusapi_ReAddNotifyResource(
 904                 [ in ] HNOTIFY_RPC hNotify,
 905                 [ in ] HRES_RPC hResource,
 906                 [ in ] uint32 dwFilter,
 907                 [ in ] uint32 dwNotifyKey,
 908                 [ in ] uint32 StateSequence,
 909                 [ out ] WERROR *rpc_status
 910         );
 911
 912         /*****************/
 913         /* Function 0x41 */
 914
 915         WERROR
 916         clusapi_GetNotify(
 917                 [ in ] HNOTIFY_RPC hNotify,
 918                 [ out ] uint32 *dwNotifyKey,
 919                 [ out ] uint32 *dwFilter,
 920                 [ out ] uint32 *dwStateSequence,
 921                 [ out, string ] [charset(UTF16)] uint16 **Name,
 922                 [ out ] WERROR *rpc_status
 923         );
 924
 925         /*****************/
 926         /* Function 0x42 */
 927 #if 0
 928         HNODE_RPC
 929         clusapi_OpenNode(
 930                 [ in, string ] [charset(UTF16)] uint16 *lpszNodeName,
 931                 [ out ] WERROR *Status,
 932                 [ out ] WERROR *rpc_status
 933         );
 934 #else
 935         void
 936         clusapi_OpenNode(
 937                 [ in, string ] [charset(UTF16)] uint16 *lpszNodeName,
 938                 [ out ] WERROR *Status,
 939                 [ out ] WERROR *rpc_status,
 940                 [ out ] HNODE_RPC *hNode
 941         );
 942 #endif
 943         /*****************/
 944         /* Function 0x43 */
 945
 946         WERROR
 947         clusapi_CloseNode(
 948                 [ in, out ] HNODE_RPC *Node
 949         );
 950
 951         /*****************/
 952         /* Function 0x44 */
 953
 954         typedef [v1_enum] enum {
 955                 ClusterNodeUp           = 0x00000000,
 956                 ClusterNodeDown         = 0x00000001,
 957                 ClusterNodePaused       = 0x00000002,
 958                 ClusterNodeJoining      = 0x00000003,
 959                 ClusterNodeStateUnknown = 0xFFFFFFFF
 960         } clusapi_ClusterNodeState;
 961
 962         WERROR
 963         clusapi_GetNodeState(
 964                 [ in ] HNODE_RPC hNode,
 965                 [ out ] clusapi_ClusterNodeState *State,
 966                 [ out ] WERROR *rpc_status
 967         );
 968
 969         /*****************/
 970         /* Function 0x45 */
 971
 972         WERROR
 973         clusapi_PauseNode(
 974                 [ in ] HNODE_RPC hNode,
 975                 [ out ] WERROR *rpc_status
 976         );
 977
 978         /*****************/
 979         /* Function 0x46 */
 980
 981         WERROR
 982         clusapi_ResumeNode(
 983                 [ in ] HNODE_RPC hNode,
 984                 [ out ] WERROR *rpc_status
 985         );
 986
 987         /*****************/
 988         /* Function 0x47 */
 989
 990         WERROR
 991         clusapi_EvictNode(
 992                 [ in ] HNODE_RPC hNode,
 993                 [ out ] WERROR *rpc_status
 994         );
 995
 996         /*****************/
 997         /* Function 0x48 */
 998
 999         WERROR
1000         clusapi_NodeResourceControl(
1001                 [ in ] HRES_RPC hResource,
1002                 [ in ] HNODE_RPC hNode,
1003                 [ in ] uint32 dwControlCode,
1004                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1005                 [ in ] uint32 nInBufferSize,
1006                 [ out, size_is(nOutBufferSize),
1007                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1008                 [ in ] uint32 nOutBufferSize,
1009                 [ out ] uint32 *lpBytesReturned,
1010                 [ out ] uint32 *lpcbRequired,
1011                 [ out ] WERROR *rpc_status
1012         );
1013
1014         /*****************/
1015         /* Function 0x49 */
1016
1017         WERROR
1018         clusapi_ResourceControl(
1019                 [ in ] HRES_RPC hResource,
1020                 [ in ] uint32 dwControlCode,
1021                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1022                 [ in ] uint32 nInBufferSize,
1023                 [ out, size_is(nOutBufferSize),
1024                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1025                 [ in ] uint32 nOutBufferSize,
1026                 [ out ] uint32 *lpBytesReturned,
1027                 [ out ] uint32 *lpcbRequired,
1028                 [ out ] WERROR *rpc_status
1029         );
1030
1031         /*****************/
1032         /* Function 0x4A */
1033
1034         WERROR
1035         clusapi_NodeResourceTypeControl(
1036                 [ in ] HCLUSTER_RPC hCluster,
1037                 [ in, string ] [charset(UTF16)] uint16 *lpszResourceTypeName,
1038                 [ in ] HNODE_RPC hNode,
1039                 [ in ] uint32 dwControlCode,
1040                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1041                 [ in ] uint32 nInBufferSize,
1042                 [ out, size_is(nOutBufferSize),
1043                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1044                 [ in ] uint32 nOutBufferSize,
1045                 [ out ] uint32 *lpBytesReturned,
1046                 [ out ] uint32 *lpcbRequired,
1047                 [ out ] WERROR *rpc_status
1048         );
1049
1050         /*****************/
1051         /* Function 0x4B */
1052
1053         WERROR
1054         clusapi_ResourceTypeControl(
1055                 [ in ] HCLUSTER_RPC hCluster,
1056                 [ in, string ] [charset(UTF16)] uint16 *lpszResourceTypeName,
1057                 [ in ] uint32 dwControlCode,
1058                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1059                 [ in ] uint32 nInBufferSize,
1060                 [ out, size_is(nOutBufferSize),
1061                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1062                 [ in ] uint32 nOutBufferSize,
1063                 [ out ] uint32 *lpBytesReturned,
1064                 [ out ] uint32 *lpcbRequired,
1065                 [ out ] WERROR *rpc_status
1066         );
1067
1068         /*****************/
1069         /* Function 0x4C */
1070
1071         WERROR
1072         clusapi_NodeGroupControl(
1073                 [ in ] HGROUP_RPC hGroup,
1074                 [ in ] HNODE_RPC hNode,
1075                 [ in ] uint32 dwControlCode,
1076                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1077                 [ in ] uint32 nInBufferSize,
1078                 [ out, size_is(nOutBufferSize),
1079                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1080                 [ in ] uint32 nOutBufferSize,
1081                 [ out ] uint32 *lpBytesReturned,
1082                 [ out ] uint32 *lpcbRequired,
1083                 [ out ] WERROR *rpc_status
1084         );
1085
1086         /*****************/
1087         /* Function 0x4D */
1088
1089         WERROR
1090         clusapi_GroupControl(
1091                 [ in ] HGROUP_RPC hGroup,
1092                 [ in ] uint32 dwControlCode,
1093                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1094                 [ in ] uint32 nInBufferSize,
1095                 [ out, size_is(nOutBufferSize),
1096                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1097                 [ in ] uint32 nOutBufferSize,
1098                 [ out ] uint32 *lpBytesReturned,
1099                 [ out ] uint32 *lpcbRequired,
1100                 [ out ] WERROR *rpc_status
1101         );
1102
1103         /*****************/
1104         /* Function 0x4E */
1105
1106         WERROR
1107         clusapi_NodeNodeControl(
1108                 [ in ] HNODE_RPC hNode,
1109                 [ in ] HNODE_RPC hHostNode,
1110                 [ in ] uint32 dwControlCode,
1111                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1112                 [ in ] uint32 nInBufferSize,
1113                 [ out, size_is(nOutBufferSize),
1114                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1115                 [ in ] uint32 nOutBufferSize,
1116                 [ out ] uint32 *lpBytesReturned,
1117                 [ out ] uint32 *lpcbRequired,
1118                 [ out ] WERROR *rpc_status
1119         );
1120
1121         /*****************/
1122         /* Function 0x4F */
1123
1124         WERROR
1125         clusapi_NodeControl(
1126                 [ in ] HNODE_RPC hNode,
1127                 [ in ] uint32 dwControlCode,
1128                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1129                 [ in ] uint32 nInBufferSize,
1130                 [ out, size_is(nOutBufferSize),
1131                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1132                 [ in ] uint32 nOutBufferSize,
1133                 [ out ] uint32 *lpBytesReturned,
1134                 [ out ] uint32 *lpcbRequired,
1135                 [ out ] WERROR *rpc_status
1136         );
1137
1138         /*****************/
1139         /* Function 0x50 */
1140
1141         WERROR
1142         Opnum80NotUsedOnWire(void);
1143
1144         /*****************/
1145         /* Function 0x51 */
1146 #if 0
1147         HNETWORK_RPC
1148         clusapi_OpenNetwork(
1149                 [ in, string ] [charset(UTF16)] uint16 *lpszNetworkName,
1150                 [ out ] WERROR *Status,
1151                 [ out ] WERROR *rpc_status
1152         );
1153 #else
1154         void
1155         clusapi_OpenNetwork(
1156                 [ in, string ] [charset(UTF16)] uint16 *lpszNetworkName,
1157                 [ out ] WERROR *Status,
1158                 [ out ] WERROR *rpc_status,
1159                 [ out ] HNETWORK_RPC *hNetwork
1160         );
1161 #endif
1162         /*****************/
1163         /* Function 0x52 */
1164
1165         WERROR
1166         clusapi_CloseNetwork(
1167                 [ in, out ] HNETWORK_RPC *Network
1168         );
1169
1170         /*****************/
1171         /* Function 0x53 */
1172
1173         WERROR
1174         clusapi_GetNetworkState(
1175                 [ in ] HNETWORK_RPC hNetwork,
1176                 [ out ] uint32 *State,
1177                 [ out ] WERROR *rpc_status
1178         );
1179
1180         /*****************/
1181         /* Function 0x54 */
1182
1183         WERROR
1184         clusapi_SetNetworkName(
1185                 [ in ] HNETWORK_RPC hNetwork,
1186                 [ in, string ] [charset(UTF16)] uint16 *lpszNetworkName,
1187                 [ out ] WERROR *rpc_status
1188         );
1189
1190         /*****************/
1191         /* Function 0x55 */
1192
1193         WERROR
1194         clusapi_CreateNetworkEnum(
1195                 [ in ] HNETWORK_RPC hNetwork,
1196                 [ in ] uint32 dwType,
1197                 [ out ] ENUM_LIST **ReturnEnum,
1198                 [ out ] WERROR *rpc_status
1199         );
1200
1201         /*****************/
1202         /* Function 0x56 */
1203
1204         WERROR
1205         clusapi_GetNetworkId(
1206                 [ in ] HNETWORK_RPC hNetwork,
1207                 [ out, string ] [charset(UTF16)] uint16 **pGuid,
1208                 [ out ] WERROR *rpc_status
1209         );
1210
1211         /*****************/
1212         /* Function 0x57 */
1213
1214         WERROR
1215         clusapi_SetNetworkPriorityOrder(
1216                 [ in, range(0, 1000)] uint32 NetworkCount,
1217                 [ in, string, size_is(NetworkCount) ] [charset(UTF16)] uint16 NetworkIdList[*],
1218                 [ out ] WERROR *rpc_status
1219         );
1220
1221         /*****************/
1222         /* Function 0x58 */
1223
1224         WERROR
1225         clusapi_NodeNetworkControl(
1226                 [ in ] HNETWORK_RPC hNetwork,
1227                 [ in ] HNODE_RPC hNode,
1228                 [ in ] uint32 dwControlCode,
1229                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1230                 [ in ] uint32 nInBufferSize,
1231                 [ out, size_is(nOutBufferSize),
1232                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1233                 [ in ] uint32 nOutBufferSize,
1234                 [ out ] uint32 *lpBytesReturned,
1235                 [ out ] uint32 *lpcbRequired,
1236                 [ out ] WERROR *rpc_status
1237         );
1238
1239         /*****************/
1240         /* Function 0x59 */
1241
1242         WERROR
1243         clusapi_NetworkControl(
1244                 [ in ] HNETWORK_RPC hNetwork,
1245                 [ in ] uint32 dwControlCode,
1246                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1247                 [ in ] uint32 nInBufferSize,
1248                 [ out, size_is(nOutBufferSize),
1249                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1250                 [ in ] uint32 nOutBufferSize,
1251                 [ out ] uint32 *lpBytesReturned,
1252                 [ out ] uint32 *lpcbRequired,
1253                 [ out ] WERROR *rpc_status
1254         );
1255
1256         /*****************/
1257         /* Function 0x5A */
1258
1259         WERROR
1260         clusapi_AddNotifyNetwork(
1261                 [ in ] HNOTIFY_RPC hNotify,
1262                 [ in ] HNETWORK_RPC hNetwork,
1263                 [ in ] uint32 dwFilter,
1264                 [ in ] uint32 dwNotifyKey,
1265                 [ out ] uint32 *dwStateSequence,
1266                 [ out ] WERROR *rpc_status
1267         );
1268
1269         /*****************/
1270         /* Function 0x5B */
1271
1272         WERROR
1273         clusapi_ReAddNotifyNetwork(
1274                 [ in ] HNOTIFY_RPC hNotify,
1275                 [ in ] HNETWORK_RPC hNetwork,
1276                 [ in ] uint32 dwFilter,
1277                 [ in ] uint32 dwNotifyKey,
1278                 [ in ] uint32 StateSequence,
1279                 [ out ] WERROR *rpc_status
1280         );
1281
1282         /*****************/
1283         /* Function 0x5C */
1284 #if 0
1285         HNETINTERFACE_RPC
1286         clusapi_OpenNetInterface(
1287                 [ in, string ] [charset(UTF16)] uint16 *lpszNetInterfaceName,
1288                 [ out ] WERROR *Status,
1289                 [ out ] WERROR *rpc_status
1290         );
1291 #else
1292         void
1293         clusapi_OpenNetInterface(
1294                 [ in, string ] [charset(UTF16)] uint16 *lpszNetInterfaceName,
1295                 [ out ] WERROR *Status,
1296                 [ out ] WERROR *rpc_status,
1297                 [ out ] HNETINTERFACE_RPC *hNetInterface
1298         );
1299 #endif
1300         /*****************/
1301         /* Function 0x5D */
1302
1303         WERROR
1304         clusapi_CloseNetInterface(
1305                 [ in, out ] HNETINTERFACE_RPC *NetInterface
1306         );
1307
1308         /*****************/
1309         /* Function 0x5E */
1310
1311         WERROR
1312         clusapi_GetNetInterfaceState(
1313                 [ in ] HNETINTERFACE_RPC hNetInterface,
1314                 [ out ] uint32 *State,
1315                 [ out ] WERROR *rpc_status
1316         );
1317
1318         /*****************/
1319         /* Function 0x5F */
1320
1321         WERROR
1322         clusapi_GetNetInterface(
1323                 [ in, string ] [charset(UTF16)] uint16 *lpszNodeName,
1324                 [ in, string ] [charset(UTF16)] uint16 *lpszNetworkName,
1325                 [ out, string ] [charset(UTF16)] uint16 **lppszInterfaceName,
1326                 [ out ] WERROR *rpc_status
1327         );
1328
1329         /*****************/
1330         /* Function 0x60 */
1331
1332         WERROR
1333         clusapi_GetNetInterfaceId(
1334                 [ in ] HNETINTERFACE_RPC hNetInterface,
1335                 [ out, string ] [charset(UTF16)] uint16 **pGuid,
1336                 [ out ] WERROR *rpc_status
1337         );
1338
1339         /*****************/
1340         /* Function 0x61 */
1341
1342         WERROR
1343         clusapi_NodeNetInterfaceControl(
1344                 [ in ] HNETINTERFACE_RPC hNetInterface,
1345                 [ in ] HNODE_RPC hNode,
1346                 [ in ] uint32 dwControlCode,
1347                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1348                 [ in ] uint32 nInBufferSize,
1349                 [ out, size_is(nOutBufferSize),
1350                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1351                 [ in ] uint32 nOutBufferSize,
1352                 [ out ] uint32 *lpBytesReturned,
1353                 [ out ] uint32 *lpcbRequired,
1354                 [ out ] WERROR *rpc_status
1355         );
1356
1357         /*****************/
1358         /* Function 0x62 */
1359
1360         WERROR
1361         clusapi_NetInterfaceControl(
1362                 [ in ] HNETINTERFACE_RPC hNetInterface,
1363                 [ in ] uint32 dwControlCode,
1364                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1365                 [ in ] uint32 nInBufferSize,
1366                 [ out, size_is(nOutBufferSize),
1367                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1368                 [ in ] uint32 nOutBufferSize,
1369                 [ out ] uint32 *lpBytesReturned,
1370                 [ out ] uint32 *lpcbRequired,
1371                 [ out ] WERROR *rpc_status
1372         );
1373
1374         /*****************/
1375         /* Function 0x63 */
1376
1377         WERROR
1378         clusapi_AddNotifyNetInterface(
1379                 [ in ] HNOTIFY_RPC hNotify,
1380                 [ in ] HNETINTERFACE_RPC hNetInterface,
1381                 [ in ] uint32 dwFilter,
1382                 [ in ] uint32 dwNotifyKey,
1383                 [ out ] uint32 *dwStateSequence,
1384                 [ out ] WERROR *rpc_status
1385         );
1386
1387         /*****************/
1388         /* Function 0x64 */
1389
1390         WERROR
1391         clusapi_ReAddNotifyNetInterface(
1392                 [ in ] HNOTIFY_RPC hNotify,
1393                 [ in ] HNETINTERFACE_RPC hNetInterface,
1394                 [ in ] uint32 dwFilter,
1395                 [ in ] uint32 dwNotifyKey,
1396                 [ in ] uint32 StateSequence,
1397                 [ out ] WERROR *rpc_status
1398         );
1399
1400         /*****************/
1401         /* Function 0x65 */
1402
1403         WERROR
1404         clusapi_CreateNodeEnum(
1405                 [ in ] HNODE_RPC hNode,
1406                 [ in ] uint32 dwType,
1407                 [ out ] ENUM_LIST **ReturnEnum,
1408                 [ out ] WERROR *rpc_status
1409         );
1410
1411         /*****************/
1412         /* Function 0x66 */
1413
1414         WERROR
1415         clusapi_GetClusterVersion2(
1416                 [ out ] uint16 *lpwMajorVersion,
1417                 [ out ] uint16 *lpwMinorVersion,
1418                 [ out ] uint16 *lpwBuildNumber,
1419                 [ out, string ] [charset(UTF16)] uint16 **lpszVendorId,
1420                 [ out, string ] [charset(UTF16)] uint16 **lpszCSDVersion,
1421                 [ out ] CLUSTER_OPERATIONAL_VERSION_INFO **ppClusterOpVerInfo,
1422                 [ out ] WERROR *rpc_status
1423         );
1424
1425         /*****************/
1426         /* Function 0x67 */
1427
1428         WERROR
1429         clusapi_CreateResTypeEnum(
1430                 [ in, string ] [charset(UTF16)] uint16 *lpszTypeName,
1431                 [ in ] uint32 dwType,
1432                 [ out ] ENUM_LIST **ReturnEnum,
1433                 [ out ] WERROR *rpc_status
1434         );
1435
1436         /*****************/
1437         /* Function 0x68 */
1438
1439         WERROR
1440         clusapi_BackupClusterDatabase(
1441                 [ in, string ] [charset(UTF16)] uint16 *lpszPathName,
1442                 [ out ] WERROR *rpc_status
1443         );
1444
1445         /*****************/
1446         /* Function 0x69 */
1447
1448         WERROR
1449         clusapi_NodeClusterControl(
1450                 [ in ] HCLUSTER_RPC hCluster,
1451                 [ in ] HNODE_RPC hHostNode,
1452                 [ in ] uint32 dwControlCode,
1453                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1454                 [ in ] uint32 nInBufferSize,
1455                 [ out, size_is(nOutBufferSize),
1456                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1457                 [ in ] uint32 nOutBufferSize,
1458                 [ out ] uint32 *lpBytesReturned,
1459                 [ out ] uint32 *lpcbRequired,
1460                 [ out ] WERROR *rpc_status
1461         );
1462
1463         /*****************/
1464         /* Function 0x6A */
1465
1466         WERROR
1467         clusapi_ClusterControl(
1468                 [ in ] HCLUSTER_RPC hCluster,
1469                 [ in ] uint32 dwControlCode,
1470                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1471                 [ in ] uint32 nInBufferSize,
1472                 [ out, size_is(nOutBufferSize),
1473                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1474                 [ in ] uint32 nOutBufferSize,
1475                 [ out ] uint32 *lpBytesReturned,
1476                 [ out ] uint32 *lpcbRequired,
1477                 [ out ] WERROR *rpc_status
1478         );
1479
1480         /*****************/
1481         /* Function 0x6B */
1482
1483         WERROR
1484         clusapi_UnblockGetNotifyCall(
1485                 [ in ] HNOTIFY_RPC hNotify
1486         );
1487
1488         /*****************/
1489         /* Function 0x6C */
1490
1491         WERROR
1492         clusapi_SetServiceAccountPassword(
1493                 [ in, string ] [charset(UTF16)] uint16 *lpszNewPassword,
1494                 [ in ]  IDL_CLUSTER_SET_PASSWORD_FLAGS dwFlags,
1495                 [ out, size_is(ReturnStatusBufferSize), length_is(*SizeReturned) ]
1496                          IDL_CLUSTER_SET_PASSWORD_STATUS ReturnStatusBufferPtr[*],
1497                 [ in, range(0, (64 * 1024)) ] uint32 ReturnStatusBufferSize,
1498                 [ out ] uint32 *SizeReturned,
1499                 [ out ] uint32 *ExpectedBufferSize
1500         );
1501
1502         /*****************/
1503         /* Function 0x6D */
1504
1505         WERROR
1506         clusapi_SetResourceDependencyExpression(
1507                 [ in ] HRES_RPC hResource,
1508                 [ in, string, unique ] [charset(UTF16)] uint16 *lpszDependencyExpression,
1509                 [ out ] WERROR *rpc_status
1510         );
1511
1512         /*****************/
1513         /* Function 0x6E */
1514
1515         WERROR
1516         clusapi_GetResourceDependencyExpression(
1517                 [ in ] HRES_RPC hResource,
1518                 [ out, string ] [charset(UTF16)] uint16 **lpszDependencyExpression,
1519                 [ out ] WERROR *rpc_status
1520         );
1521
1522         /*****************/
1523         /* Function 0x6F */
1524
1525         WERROR
1526         Opnum111NotUsedOnWire(void);
1527
1528         /*****************/
1529         /* Function 0x70 */
1530
1531         WERROR
1532         clusapi_GetResourceNetworkName(
1533                 [ in ] HRES_RPC hResource,
1534                 [ out, string ] [charset(UTF16)] uint16 **lpszName,
1535                 [ out ] WERROR *rpc_status
1536         );
1537
1538         /*****************/
1539         /* Function 0x71 */
1540
1541         WERROR
1542         clusapi_ExecuteBatch(
1543                 [ in ] HKEY_RPC hKey,
1544                 [ in ] uint32 cbData,
1545                 [ in, size_is(cbData)] uint8 *lpData,
1546                 [ out ] int *pdwFailedCommand,
1547                 [ out ] WERROR *rpc_status
1548         );
1549
1550         /*****************/
1551         /* Function 0x72 */
1552
1553         WERROR
1554         clusapi_CreateBatchPort(
1555                 [ in ] HKEY_RPC hKey,
1556                 [ out ] HBATCH_PORT_RPC *phBatchPort,
1557                 [ out ] WERROR *rpc_status
1558         );
1559
1560         /*****************/
1561         /* Function 0x73 */
1562
1563         WERROR
1564         clusapi_GetBatchNotification(
1565                  [ in ] HBATCH_PORT_RPC hBatchNotify,
1566                  [ out ] uint32 *cbData,
1567                  [ out, size_is(,*cbData) ] uint8 ** lpData
1568         );
1569
1570         /*****************/
1571         /* Function 0x74 */
1572
1573         WERROR
1574         clusapi_CloseBatchPort(
1575                  [ in, out ] HBATCH_PORT_RPC *phBatchPort
1576         );
1577
1578         /*****************/
1579         /* Function 0x75 */
1580 #if 0
1581         HCLUSTER_RPC
1582         clusapi_OpenClusterEx(
1583                 [ in ] uint32 dwDesiredAccess,
1584                 [ out ] uint32 *lpdwGrantedAccess,
1585                 [ out ] WERROR *Status
1586         );
1587 #else
1588         void
1589         clusapi_OpenClusterEx(
1590                 [ in ] uint32 dwDesiredAccess,
1591                 [ out ] uint32 *lpdwGrantedAccess,
1592                 [ out ] WERROR *Status,
1593                 [ out ] HCLUSTER_RPC *hCluster
1594         );
1595 #endif
1596
1597         /*****************/
1598         /* Function 0x76 */
1599 #if 0
1600         HNODE_RPC
1601         clusapi_OpenNodeEx(
1602                 [ in, string ] [charset(UTF16)] uint16 *lpszNodeName,
1603                 [ in ] uint32 dwDesiredAccess,
1604                 [ out ] uint32 *lpdwGrantedAccess,
1605                 [ out ] WERROR *Status,
1606                 [ out ] WERROR *rpc_status
1607         );
1608 #else
1609         void
1610         clusapi_OpenNodeEx(
1611                 [ in, string ] [charset(UTF16)] uint16 *lpszNodeName,
1612                 [ in ] uint32 dwDesiredAccess,
1613                 [ out ] uint32 *lpdwGrantedAccess,
1614                 [ out ] WERROR *Status,
1615                 [ out ] WERROR *rpc_status,
1616                 [ out ] HNODE_RPC *hNode
1617         );
1618 #endif
1619         /*****************/
1620         /* Function 0x77 */
1621 #if 0
1622         HGROUP_RPC
1623         clusapi_OpenGroupEx(
1624                 [ in, string ] [charset(UTF16)] uint16 *lpszGroupName,
1625                 [ in ] uint32 dwDesiredAccess,
1626                 [ out ] uint32 *lpdwGrantedAccess,
1627                 [ out ] WERROR *Status,
1628                 [ out ] WERROR *rpc_status
1629         );
1630 #else
1631         void
1632         clusapi_OpenGroupEx(
1633                 [ in, string ] [charset(UTF16)] uint16 *lpszGroupName,
1634                 [ in ] uint32 dwDesiredAccess,
1635                 [ out ] uint32 *lpdwGrantedAccess,
1636                 [ out ] WERROR *Status,
1637                 [ out ] WERROR *rpc_status,
1638                 [ out ] HGROUP_RPC *hGroup
1639         );
1640 #endif
1641         /*****************/
1642         /* Function 0x78 */
1643 #if 0
1644         HRES_RPC
1645         clusapi_OpenResourceEx(
1646                 [ in, string ] [charset(UTF16)] uint16 *lpszResourceName,
1647                 [ in ] uint32 dwDesiredAccess,
1648                 [ out ] uint32 *lpdwGrantedAccess,
1649                 [ out ] WERROR *Status,
1650                 [ out ] WERROR *rpc_status
1651         );
1652 #else
1653         void
1654         clusapi_OpenResourceEx(
1655                 [ in, string ] [charset(UTF16)] uint16 *lpszResourceName,
1656                 [ in ] uint32 dwDesiredAccess,
1657                 [ out ] uint32 *lpdwGrantedAccess,
1658                 [ out ] WERROR *Status,
1659                 [ out ] WERROR *rpc_status,
1660                 [ out ] HRES_RPC *hResource
1661         );
1662 #endif
1663         /*****************/
1664         /* Function 0x79 */
1665 #if 0
1666         HNETWORK_RPC
1667         clusapi_OpenNetworkEx(
1668                 [ in, string ] [charset(UTF16)] uint16 *lpszNetworkName,
1669                 [ in ] uint32 dwDesiredAccess,
1670                 [ out ] uint32 *lpdwGrantedAccess,
1671                 [ out ] WERROR *Status,
1672                 [ out ] WERROR *rpc_status
1673         );
1674 #else
1675         void
1676         clusapi_OpenNetworkEx(
1677                 [ in, string ] [charset(UTF16)] uint16 *lpszNetworkName,
1678                 [ in ] uint32 dwDesiredAccess,
1679                 [ out ] uint32 *lpdwGrantedAccess,
1680                 [ out ] WERROR *Status,
1681                 [ out ] WERROR *rpc_status,
1682                 [ out ] HNETWORK_RPC *hNetwork
1683         );
1684 #endif
1685         /*****************/
1686         /* Function 0x7A */
1687 #if 0
1688         HNETINTERFACE_RPC
1689         clusapi_OpenNetInterfaceEx(
1690                 [ in, string ] [charset(UTF16)] uint16 *lpszNetInterfaceName,
1691                 [ in ] uint32 dwDesiredAccess,
1692                 [ out ] uint32 *lpdwGrantedAccess,
1693                 [ out ] WERROR *Status,
1694                 [ out ] WERROR *rpc_status
1695         );
1696 #else
1697         void
1698         clusapi_OpenNetInterfaceEx(
1699                 [ in, string ] [charset(UTF16)] uint16 *lpszNetInterfaceName,
1700                 [ in ] uint32 dwDesiredAccess,
1701                 [ out ] uint32 *lpdwGrantedAccess,
1702                 [ out ] WERROR *Status,
1703                 [ out ] WERROR *rpc_status,
1704                 [ out ] HNETINTERFACE_RPC *hNetInterface
1705         );
1706 #endif
1707         /*****************/
1708         /* Function 0x7B */
1709
1710         WERROR
1711         clusapi_ChangeCsvState(
1712                 [ in ] HRES_RPC hResource,
1713                 [ in ] uint32 dwState,
1714                 [ out ] WERROR *rpc_status
1715         );
1716
1717         /*****************/
1718         /* Function 0x7C */
1719
1720         WERROR
1721         clusapi_CreateNodeEnumEx(
1722                 [in] HNODE_RPC hNode,
1723                 [in] uint32 dwType,
1724                 [in] uint32 dwOptions,
1725                 [out] ENUM_LIST **ReturnIdEnum,
1726                 [out] ENUM_LIST **ReturnNameEnum,
1727                 [out] WERROR* rpc_status
1728         );
1729
1730         /*****************/
1731         /* Function 0x7D */
1732
1733         WERROR
1734         clusapi_CreateEnumEx(
1735                 [in] HCLUSTER_RPC hCluster,
1736                 [in] uint32 dwType,
1737                 [in] uint32 dwOptions,
1738                 [out] ENUM_LIST **ReturnIdEnum,
1739                 [out] ENUM_LIST **ReturnNameEnum,
1740                 [out] WERROR* rpc_status
1741         );
1742
1743         /*****************/
1744         /* Function 0x7E */
1745
1746         WERROR
1747         clusapi_PauseNodeEx(
1748                 [ in ] HNODE_RPC hNode,
1749                 [ in ] boolean8 bDrainNode,
1750                 [ in ] uint32 dwPauseFlags,
1751                 [ out ] WERROR *rpc_status
1752         );
1753
1754         /*****************/
1755         /* Function 0x7F */
1756
1757         WERROR
1758         clusapi_PauseNodeWithDrainTarget(
1759                 [ in ] HNODE_RPC hNode,
1760                 [ in ] uint32 dwPauseFlags,
1761                 [ in ] HNODE_RPC hNodeDrainTarget,
1762                 [ out ] WERROR *rpc_status
1763         );
1764
1765         /*****************/
1766         /* Function 0x80 */
1767
1768         WERROR
1769         clusapi_ResumeNodeEx(
1770                 [ in ] HNODE_RPC hNode,
1771                 [ in ] uint32 dwResumeFailbackType,
1772                 [ in ] uint32 dwResumeFlagsReserved,
1773                 [ out ] WERROR *rpc_status
1774         );
1775
1776         /*****************/
1777         /* Function 0x81 */
1778 #if 0
1779         HGROUP_RPC
1780         clusapi_CreateGroupEx(
1781                 [ in, string ] [charset(UTF16)] uint16 *lpszGroupName,
1782                 [ in, unique ] CLUSTER_CREATE_GROUP_INFO_RPC *pGroupInfo,
1783                 [ out ] WERROR *Status,
1784                 [ out ] WERROR *rpc_status
1785         );
1786 #else
1787         void
1788         clusapi_CreateGroupEx(
1789                 [ in, string ] [charset(UTF16)] uint16 *lpszGroupName,
1790                 [ in, unique ] CLUSTER_CREATE_GROUP_INFO_RPC *pGroupInfo,
1791                 [ out ] WERROR *Status,
1792                 [ out ] WERROR *rpc_status,
1793                 [ out ] HGROUP_RPC *hGroup
1794         );
1795 #endif
1796         /*****************/
1797         /* Function 0x82 */
1798
1799         WERROR
1800         clusapi_OnlineGroupEx(
1801                 [ in ] HGROUP_RPC hGroup,
1802                 [ in ] uint32     dwOnlineFlags,
1803                 [ in, size_is(cbInBufferSize) ] uint8* lpInBuffer,
1804                 [ in ] uint32     cbInBufferSize,
1805                 [ out ] WERROR *rpc_status
1806         );
1807
1808         /*****************/
1809         /* Function 0x83 */
1810
1811         WERROR
1812         clusapi_OfflineGroupEx(
1813                 [ in ] HGROUP_RPC hGroup,
1814                 [ in ] uint32     dwOfflineFlags,
1815                 [ in, size_is(cbInBufferSize) ] uint8* lpInBuffer,
1816                 [ in ] uint32     cbInBufferSize,
1817                 [ out ] WERROR *rpc_status
1818         );
1819
1820         /*****************/
1821         /* Function 0x84 */
1822
1823         WERROR
1824         clusapi_MoveGroupEx(
1825                 [ in ] HGROUP_RPC hGroup,
1826                 [ in ] uint32           dwMoveFlags,
1827                 [ in, size_is(cbInBufferSize) ] uint8* lpInBuffer,
1828                 [ in ] uint32           cbInBufferSize,
1829                 [ out ] WERROR *rpc_status
1830         );
1831
1832         /*****************/
1833         /* Function 0x85 */
1834
1835         WERROR
1836         clusapi_MoveGroupToNodeEx(
1837                 [ in ] HGROUP_RPC hGroup,
1838                 [ in ] HNODE_RPC  hNode,
1839                 [ in ] uint32           dwMoveFlags,
1840                 [ in, size_is(cbInBufferSize) ] uint8* lpInBuffer,
1841                 [ in ] uint32           cbInBufferSize,
1842                 [ out ] WERROR *rpc_status
1843         );
1844
1845         /*****************/
1846         /* Function 0x86 */
1847
1848         WERROR
1849         clusapi_CancelClusterGroupOperation(
1850                 [ in ] HGROUP_RPC       hGroup,
1851                 [ in ] uint32            dwCancelFlags,
1852                 [ out ] WERROR *rpc_status
1853         );
1854
1855         /*****************/
1856         /* Function 0x87 */
1857
1858         WERROR
1859         clusapi_OnlineResourceEx(
1860                 [ in ] HRES_RPC hResource,
1861                 [ in ] uint32     dwOnlineFlags,
1862                 [ in, size_is(cbInBufferSize) ] uint8* lpInBuffer,
1863                 [ in ] uint32     cbInBufferSize,
1864                 [ out ] WERROR *rpc_status
1865         );
1866
1867         /*****************/
1868         /* Function 0x88 */
1869
1870         WERROR
1871         clusapi_OfflineResourceEx(
1872                 [ in ] HRES_RPC hResource,
1873                 [ in ] uint32     dwOfflineFlags,
1874                 [ in, size_is(cbInBufferSize) ] uint8* lpInBuffer,
1875                 [ in ] uint32     cbInBufferSize,
1876                 [ out ] WERROR *rpc_status
1877         );
1878
1879 #define HGENERIC_RPC policy_handle
1880 #if 0
1881         typedef [context_handle] void *HGENERIC_RPC;
1882 #endif
1883
1884         typedef struct {
1885                 uint32 dwObjectType;      // really of type CLUSTER_OBJECT_TYPE_RPC
1886                 hyper FilterFlags;
1887         } NOTIFY_FILTER_AND_TYPE_RPC;
1888
1889         typedef struct {
1890                 NOTIFY_FILTER_AND_TYPE_RPC FilterAndType;
1891                 [ size_is(dwBufferSize ) ] uint8* buffer;
1892                 uint32 dwBufferSize;
1893                 [string] [charset(UTF16)] uint16 *ObjectId;
1894                 [string] [charset(UTF16)] uint16 *ParentId;
1895                 [string] [charset(UTF16)] uint16 *Name;
1896                 [string] [charset(UTF16)] uint16 *Type;
1897         } NOTIFICATION_DATA_RPC;
1898
1899         typedef struct {
1900                 uint32 *dwNotifyKey;
1901                 NOTIFICATION_DATA_RPC NotificationData;
1902         } NOTIFICATION_RPC;
1903
1904         /*****************/
1905         /* Function 0x89 */
1906
1907         //
1908         // Notify interface V2 functions
1909         //
1910 #if 0
1911         HNOTIFY_RPC
1912         clusapi_CreateNotifyV2(
1913                 [ out ] WERROR *rpc_error,
1914                 [ out ] WERROR *rpc_status
1915         );
1916 #else
1917         void
1918         clusapi_CreateNotifyV2(
1919                 [ out ] WERROR *rpc_error,
1920                 [ out ] WERROR *rpc_status,
1921                 [ out ] HNOTIFY_RPC *hNotify
1922         );
1923
1924 #endif
1925         /*****************/
1926         /* Function 0x8A */
1927
1928         WERROR
1929         clusapi_AddNotifyV2(
1930                 [ in ] HNOTIFY_RPC hNotify,
1931                 [ in ] HGENERIC_RPC hObject,
1932                 [ in ] NOTIFY_FILTER_AND_TYPE_RPC filter,
1933                 [ in ] uint32 dwNotifyKey,
1934                 [ in ] uint32 dwVersion,
1935                 [ in ] boolean8 isTargetedAtObject,
1936                 [ out ] WERROR *rpc_status
1937         );
1938
1939         /*****************/
1940         /* Function 0x8B */
1941
1942         WERROR
1943         clusapi_GetNotifyV2(
1944                 [ in ] HNOTIFY_RPC hNotify,
1945                 [ out, size_is(,*dwNumNotifications) ] NOTIFICATION_RPC **Notifications,
1946                 [ out ] uint32 *dwNumNotifications
1947         );
1948
1949         /*****************/
1950         /* Function 0x8C */
1951
1952         WERROR
1953         clusapi_QueryAllValues(
1954                 [ in ] HKEY_RPC hKey,
1955                 [ out ] uint32 *pcbData,
1956                 [ out, size_is(1, *pcbData) ] uint8 ** ppData,
1957                 [ out ] WERROR *rpc_status
1958         );
1959
1960         typedef struct {
1961                 uint32 DiskIdType;
1962                 uint8  DiskIdBlob[16];
1963         } CLUSTER_DISKID;
1964
1965         /*****************/
1966         /* Function 0x8D */
1967
1968         WERROR
1969         clusapi_StmFindDisk(
1970                 [ in ] HCLUSTER_RPC hCluster,
1971                 [ in ] uint32 dwFlags,
1972                 [ in, out, unique ] CLUSTER_DISKID *pDiskId,
1973                 [ in, size_is(uniqueIdSize), unique ] uint8 *pUniqueId,
1974                 [ in ] uint32 uniqueIdSize,
1975                 [ out, ref, string ] [charset(UTF16)] uint16 **ppszDeviceName,
1976                 [ out ] WERROR *rpc_status
1977         );
1978
1979         typedef struct{
1980                 [string] [charset(UTF16)] uint16 *pszNodeName;
1981                 HRESULT ResultCode;
1982                 uint32  ResultSize;
1983                 [unique, size_is(ResultSize)]   uint8    *pResultData;
1984         } CLUSTER_MRR_NODE_RESPONSE;
1985
1986         typedef struct {
1987                 uint32 NodeCount;
1988                 [size_is(NodeCount)] CLUSTER_MRR_NODE_RESPONSE *pNodes;
1989         } CLUSTER_MRR_RESPONSE;
1990
1991         /*****************/
1992         /* Function 0x8E */
1993
1994         WERROR
1995         clusapi_ClusterMrr(
1996                 [ in ] HCLUSTER_RPC hCluster,
1997                 [ in ] boolean8 fExcludeSelf,
1998                 [ in ] hyper nodeSet,
1999                 [ in ] uint32 dwTimeout,
2000                 [ in ] uint32 dwComponent,
2001                 [ in ] uint32 dwControlCode,
2002                 [ in ] uint32 inSize,
2003                 [ in, unique, size_is(inSize) ] uint8 *pInData,
2004                 [ out, ref, size_is(1, 1) ] CLUSTER_MRR_RESPONSE **ppInfo,
2005                 [ out ] WERROR *rpc_status
2006         );
2007
2008         /*****************/
2009         /* Function 0x8F */
2010
2011         WERROR
2012         clusapi_CreateGroupEnum(
2013                 [ in ] HCLUSTER_RPC hCluster,
2014                 [ in, unique, size_is(cbProperties)] uint8* pProperties,
2015                 [ in ] uint32 cbProperties,
2016                 [ in, unique, size_is(cbRoProperties)] uint8* pRoProperties,
2017                 [ in ] uint32 cbRoProperties,
2018                 [ out ] GROUP_ENUM_LIST **ppResultList,
2019                 [ out ] WERROR *rpc_status
2020         );
2021
2022         /*****************/
2023         /* Function 0x90 */
2024
2025         WERROR
2026         clusapi_CreateResourceEnum(
2027                 [ in ] HCLUSTER_RPC hCluster,
2028                 [ in, unique, size_is(cbProperties)] uint8* pProperties,
2029                 [ in ] uint32 cbProperties,
2030                 [ in, unique, size_is(cbRoProperties)] uint8* pRoProperties,
2031                 [ in ] uint32 cbRoProperties,
2032                 [ out ] RESOURCE_ENUM_LIST **ppResultList,
2033                 [ out ] WERROR *rpc_status
2034         );
2035
2036         /*****************/
2037         /* Function 0x91 */
2038
2039         WERROR
2040         clusapi_ExecuteReadBatch(
2041                 [ in ] HKEY_RPC hKey,
2042                 [ in ] uint32 cbInData,
2043                 [ in, size_is(cbInData)] uint8 *lpInData,
2044                 [ out ] uint32 *cbOutData,
2045                 [ out, size_is(,*cbOutData) ] uint8 ** lpOutData,
2046                 [ out ] WERROR *rpc_status
2047         );
2048
2049         /*****************/
2050         /* Function 0x92 */
2051
2052         WERROR
2053         clusapi_RestartResource(
2054                 [ in ] HRES_RPC hResource,
2055                 [ in ] uint32 dwFlags,
2056                 [ out ] WERROR *rpc_status
2057         );
2058
2059         typedef struct {
2060                 uint32 dwNotifyKey;
2061                 uint32 dwFilter;
2062                 [string] [charset(UTF16)] uint16 *Name;
2063         } NOTIFICATION_DATA_ASYNC_RPC;
2064
2065         /*****************/
2066         /* Function 0x93 */
2067
2068         WERROR
2069         clusapi_GetNotifyAsync(
2070                 [ in ] HNOTIFY_RPC hNotify,
2071                 [ out, size_is(,*dwNumNotifications) ] NOTIFICATION_DATA_ASYNC_RPC **Notifications,
2072                 [ out ] uint32 *dwNumNotifications
2073         );
2074
2075         typedef enum {
2076                 DiskIdSignature = 0x00000001,
2077                 DiskIdGuid = 0x00000002,
2078                 DiskIdUnKnown = 0x00001388
2079         } CLUSDSK_DISKID_ENUM;
2080
2081 #if 0
2082         typedef struct {
2083                 CLUSDSK_DISKID_ENUM DiskIdType;
2084                 [switch_is(DiskIdType)] union {
2085                         [case(DiskIdSignature)] uint32 DiskSignature;
2086                         [case(DiskIdGuid)] GUID DiskGuid;
2087                 };
2088         } CLUSDSK_DISKID;
2089 #endif
2090         typedef enum {
2091                 CLUSPROP_TYPE_ENDMARK = 0x0000,
2092                 CLUSPROP_TYPE_LIST_VALUE = 0x0001,
2093                 CLUSPROP_TYPE_RESCLASS = 0x0002,
2094                 CLUSPROP_TYPE_NAME = 0x0004,
2095                 CLUSPROP_TYPE_SIGNATURE = 0x0005,
2096                 CLUSPROP_TYPE_SCSIADDRESS = 0x0006,
2097                 CLUSPROP_TYPE_DISK_NUMBER = 0x0007,
2098                 CLUSPROP_TYPE_PARTITION_INFO = 0x0008,
2099                 CLUSPROP_TYPE_DISK_SERIALNUMBER = 0x000a,
2100                 CLUSPROP_TYPE_DISK_GUID = 0x000b,
2101                 CLUSPROP_TYPE_DISK_SIZE = 0x000c,
2102                 CLUSPROP_TYPE_PARTITION_INFO_EX = 0x000d
2103         } CLUSTER_PROPERTY_TYPE;
2104
2105         typedef enum {
2106                 CLUSPROP_FORMAT_UNKNOWN = 0x0000,
2107                 CLUSPROP_FORMAT_BINARY = 0x0001,
2108                 CLUSPROP_FORMAT_DWORD = 0x0002,
2109                 CLUSPROP_FORMAT_SZ = 0x0003,
2110                 CLUSPROP_FORMAT_EXPAND_SZ = 0x0004,
2111                 CLUSPROP_FORMAT_MULTI_SZ = 0x0005,
2112                 CLUSPROP_FORMAT_ULARGE_INTEGER = 0x0006,
2113                 CLUSPROP_FORMAT_LONG = 0x0007,
2114                 CLUSPROP_FORMAT_EXPANDED_SZ = 0x0008,
2115                 CLUSPROP_FORMAT_SECURITY_DESCRIPTOR = 0x0009,
2116                 CLUSPROP_FORMAT_LARGE_INTEGER = 0x000a,
2117                 CLUSPROP_FORMAT_WORD = 0x000b,
2118                 CLUSPROP_FORMAT_FILETIME = 0x000c
2119         } CLUSTER_PROPERTY_FORMAT;
2120
2121         typedef enum {
2122                 CLUSPROP_SYNTAX_ENDMARK = 0x00000000,
2123                 CLUSPROP_SYNTAX_NAME = 0x00040003,
2124                 CLUSPROP_SYNTAX_RESCLASS = 0x00020002,
2125                 CLUSPROP_SYNTAX_LIST_VALUE_SZ = 0x00010003,
2126                 CLUSPROP_SYNTAX_LIST_VALUE_EXPAND_SZ = 0x00010004,
2127                 CLUSPROP_SYNTAX_LIST_VALUE_DWORD = 0x00010002,
2128                 CLUSPROP_SYNTAX_LIST_VALUE_BINARY = 0x00010001,
2129                 CLUSPROP_SYNTAX_LIST_VALUE_MULTI_SZ = 0x00010005,
2130                 CLUSPROP_SYNTAX_LIST_VALUE_LONG = 0x00010007,
2131                 CLUSPROP_SYNTAX_LIST_VALUE_EXPANDED_SZ = 0x00010008,
2132                 CLUSPROP_SYNTAX_LIST_VALUE_SECURITY_DESCRIPTOR = 0x00010009,
2133                 CLUSPROP_SYNTAX_LIST_VALUE_LARGE_INTEGER = 0x0001000a,
2134                 CLUSPROP_SYNTAX_LIST_VALUE_ULARGE_INTEGER = 0x00010006,
2135                 CLUSPROP_SYNTAX_LIST_VALUE_WORD = 0x0001000b,
2136                 CLUSPROP_SYNTAX_LIST_VALUE_FILETIME = 0x0001000c,
2137                 CLUSPROP_SYNTAX_DISK_SIGNATURE = 0x00050002,
2138                 CLUSPROP_SYNTAX_SCSI_ADDRESS = 0x00060002,
2139                 CLUSPROP_SYNTAX_DISK_NUMBER = 0x00070002,
2140                 CLUSPROP_SYNTAX_PARTITION_INFO = 0x00080001,
2141                 CLUSPROP_SYNTAX_DISK_SERIALNUMBER = 0x000a0003,
2142                 CLUSPROP_SYNTAX_DISK_GUID = 0x000b0003,
2143                 CLUSPROP_SYNTAX_DISK_SIZE = 0x000c0006,
2144                 CLUSPROP_SYNTAX_PARTITION_INFO_EX = 0x000d0001
2145         } CLUSTER_PROPERTY_SYNTAX;
2146
2147         typedef enum {
2148                 CLUS_CHAR_UNKNOWN = 0x00000000,
2149                 CLUS_CHAR_QUORUM = 0x00000001,
2150                 CLUS_CHAR_DELETE_REQUIRES_ALL_NODES = 0x00000002,
2151                 CLUS_CHAR_LOCAL_QUORUM = 0x00000004,
2152                 CLUS_CHAR_BROADCAST_DELETE = 0x00000020,
2153                 CLUS_CHAR_SINGLE_CLUSTER_INSTANCE = 0x00000040,
2154                 CLUS_CHAR_SINGLE_GROUP_INSTANCE = 0x00000080,
2155                 CLUS_CHAR_COEXIST_IN_SHARED_VOLUME_GROUP = 0x00000100,
2156                 CLUS_CHAR_RESERVED1 = 0x00000200,
2157                 CLUS_CHAR_MONITOR_DETACH = 0x00000400,
2158                 CLUS_CHAR_RESERVED2 = 0x00000800,
2159                 CLUS_CHAR_RESERVED3 = 0x00001000,
2160                 CLUS_CHAR_RESERVED4 = 0x00002000
2161         } CLUS_CHARACTERISTICS;
2162
2163         typedef enum {
2164                 CLUS_FLAG_CORE = 0x00000001
2165         } CLUS_FLAGS;
2166
2167         typedef enum {
2168                 MaintenanceModeTypeDisableIsAliveCheck = 1,
2169                 MaintenanceModeTypeOfflineResource = 2,
2170                 MaintenanceModeTypeUnclusterResource = 3
2171         } MAINTENANCE_MODE_TYPE;
2172
2173         typedef enum {
2174                 CLUSTER_CHANGE_NODE_STATE = 0x00000001,
2175                 CLUSTER_CHANGE_NODE_DELETED = 0x00000002,
2176                 CLUSTER_CHANGE_NODE_ADDED = 0x00000004,
2177                 CLUSTER_CHANGE_NODE_PROPERTY = 0x00000008,
2178                 CLUSTER_CHANGE_REGISTRY_NAME = 0x00000010,
2179                 CLUSTER_CHANGE_REGISTRY_ATTRIBUTES = 0x00000020,
2180                 CLUSTER_CHANGE_REGISTRY_VALUE = 0x00000040,
2181                 CLUSTER_CHANGE_REGISTRY_SUBTREE = 0x00000080,
2182                 CLUSTER_CHANGE_RESOURCE_STATE = 0x00000100,
2183                 CLUSTER_CHANGE_RESOURCE_DELETED = 0x00000200,
2184                 CLUSTER_CHANGE_RESOURCE_ADDED = 0x00000400,
2185                 CLUSTER_CHANGE_RESOURCE_PROPERTY = 0x00000800,
2186                 CLUSTER_CHANGE_GROUP_STATE = 0x00001000,
2187                 CLUSTER_CHANGE_GROUP_DELETED = 0x00002000,
2188                 CLUSTER_CHANGE_GROUP_ADDED = 0x00004000,
2189                 CLUSTER_CHANGE_GROUP_PROPERTY = 0x00008000,
2190                 CLUSTER_CHANGE_RESOURCE_TYPE_DELETED = 0x00010000,
2191                 CLUSTER_CHANGE_RESOURCE_TYPE_ADDED = 0x00020000,
2192                 CLUSTER_CHANGE_RESOURCE_TYPE_PROPERTY = 0x00040000,
2193                 CLUSTER_CHANGE_CLUSTER_RECONNECT = 0x00080000,
2194                 CLUSTER_CHANGE_NETWORK_STATE = 0x00100000,
2195                 CLUSTER_CHANGE_NETWORK_DELETED = 0x00200000,
2196                 CLUSTER_CHANGE_NETWORK_ADDED = 0x00400000,
2197                 CLUSTER_CHANGE_NETWORK_PROPERTY = 0x00800000,
2198                 CLUSTER_CHANGE_NETINTERFACE_STATE = 0x01000000,
2199                 CLUSTER_CHANGE_NETINTERFACE_DELETED = 0x02000000,
2200                 CLUSTER_CHANGE_NETINTERFACE_ADDED = 0x04000000,
2201                 CLUSTER_CHANGE_NETINTERFACE_PROPERTY = 0x08000000,
2202                 CLUSTER_CHANGE_QUORUM_STATE = 0x10000000,
2203                 CLUSTER_CHANGE_CLUSTER_STATE = 0x20000000,
2204                 CLUSTER_CHANGE_CLUSTER_PROPERTY = 0x40000000,
2205                 CLUSTER_CHANGE_HANDLE_CLOSE = 0x80000000
2206         } CLUSTER_CHANGE;
2207
2208         typedef enum {
2209                 CLUSREG_SET_VALUE = 1,
2210                 CLUSREG_CREATE_KEY = 2,
2211                 CLUSREG_DELETE_KEY = 3,
2212                 CLUSREG_DELETE_VALUE = 4,
2213                 CLUSREG_VALUE_DELETED = 6,
2214                 CLUSREG_READ_KEY = 7,
2215                 CLUSREG_READ_VALUE = 8,
2216                 CLUSREG_READ_ERROR = 9
2217         } CLUSTER_REG_BATCH_COMMAND;
2218 #if 0
2219         typedef enum {
2220                 IDL_CLUSTER_SET_PASSWORD_IGNORE_DOWN_NODES = 1
2221         } IDL_CLUSTER_SET_PASSWORD_FLAGS;
2222 #endif
2223         typedef enum {
2224                 CLUSTER_QUORUM_MAINTAINED = 0,
2225                 CLUSTER_QUORUM_LOST = 1
2226         } CLUSTER_QUORUM_VALUE;
2227
2228         typedef enum {
2229                 CLUSTER_OBJECT_TYPE_CLUSTER = 0x00000001,
2230                 CLUSTER_OBJECT_TYPE_GROUP = 0x00000002,
2231                 CLUSTER_OBJECT_TYPE_RESOURCE = 0x00000003,
2232                 CLUSTER_OBJECT_TYPE_RESOURCE_TYPE = 0x00000004,
2233                 CLUSTER_OBJECT_TYPE_NETWORK_INTERFACE = 0x00000005,
2234                 CLUSTER_OBJECT_TYPE_NETWORK = 0x00000006,
2235                 CLUSTER_OBJECT_TYPE_NODE = 0x00000007,
2236                 CLUSTER_OBJECT_TYPE_REGISTRY = 0x00000008,
2237                 CLUSTER_OBJECT_TYPE_QUORUM = 0x00000009,
2238                 CLUSTER_OBJECT_TYPE_SHARED_VOLUME = 0x0000000a
2239         } CLUSTER_OBJECT_TYPE;
2240
2241         typedef enum {
2242                 CLUSTER_CHANGE_CLUSTER_RECONNECT_V2 = 0x00000001,
2243                 CLUSTER_CHANGE_CLUSTER_STATE_V2 = 0x00000002,
2244                 CLUSTER_CHANGE_CLUSTER_GROUP_ADDED_V2 = 0x00000004,
2245                 CLUSTER_CHANGE_CLUSTER_HANDLE_CLOSE_V2 = 0x00000008,
2246                 CLUSTER_CHANGE_CLUSTER_NETWORK_ADDED_V2 = 0x00000010,
2247                 CLUSTER_CHANGE_CLUSTER_NODE_ADDED_V2 = 0x00000020,
2248                 CLUSTER_CHANGE_CLUSTER_RESOURCE_TYPE_ADDED_V2 = 0x00000040,
2249                 CLUSTER_CHANGE_CLUSTER_COMMON_PROPERTY_V2 = 0x00000080,
2250                 CLUSTER_CHANGE_CLUSTER_PRIVATE_PROPERTY_V2 = 0x00000100,
2251                 CLUSTER_CHANGE_CLUSTER_LOST_NOTIFICATIONS_V2 = 0x00000200,
2252                 CLUSTER_CHANGE_CLUSTER_RENAME_V2 = 0x00000400
2253         } CLUSTER_CHANGE_CLUSTER_V2;
2254
2255         typedef enum {
2256                 CLUSTER_CHANGE_GROUP_DELETED_V2 = 0x00000001,
2257                 CLUSTER_CHANGE_GROUP_COMMON_PROPERTY_V2 = 0x00000002,
2258                 CLUSTER_CHANGE_GROUP_PRIVATE_PROPERTY_V2 = 0x00000004,
2259                 CLUSTER_CHANGE_GROUP_STATE_V2 = 0x00000008,
2260                 CLUSTER_CHANGE_GROUP_OWNER_NODE_V2 = 0x00000010,
2261                 CLUSTER_CHANGE_GROUP_PREFERRED_OWNERS_V2 = 0x00000020,
2262                 CLUSTER_CHANGE_GROUP_RESOURCE_ADDED_V2 = 0x00000040,
2263                 CLUSTER_CHANGE_GROUP_RESOURCE_GAINED_V2 = 0x00000080,
2264                 CLUSTER_CHANGE_GROUP_RESOURCE_LOST_V2 = 0x00000100,
2265                 CLUSTER_CHANGE_GROUP_HANDLE_CLOSE_V2 = 0x00000200
2266         } CLUSTER_CHANGE_GROUP_V2;
2267
2268         typedef enum {
2269                 CLUSTER_CHANGE_RESOURCE_COMMON_PROPERTY_V2 = 0x00000001,
2270                 CLUSTER_CHANGE_RESOURCE_PRIVATE_PROPERTY_V2 = 0x00000002,
2271                 CLUSTER_CHANGE_RESOURCE_STATE_V2 = 0x00000004,
2272                 CLUSTER_CHANGE_RESOURCE_OWNER_GROUP_V2 = 0x00000008,
2273                 CLUSTER_CHANGE_RESOURCE_DEPENDENCIES_V2 = 0x00000010,
2274                 CLUSTER_CHANGE_RESOURCE_DEPENDENTS_V2 = 0x00000020,
2275                 CLUSTER_CHANGE_RESOURCE_POSSIBLE_OWNERS_V2 = 0x00000040,
2276                 CLUSTER_CHANGE_RESOURCE_DELETED_V2 = 0x00000080,
2277                 CLUSTER_CHANGE_RESOURCE_DLL_UPGRADED_V2 = 0x00000100,
2278                 CLUSTER_CHANGE_RESOURCE_HANDLE_CLOSE_V2 = 0x00000200
2279         } CLUSTER_CHANGE_RESOURCE_V2;
2280
2281         typedef enum {
2282                 CLUSTER_CHANGE_RESOURCE_TYPE_DELETED_V2 = 0x00000001,
2283                 CLUSTER_CHANGE_RESOURCE_TYPE_COMMON_PROPERTY_V2 = 0x00000002,
2284                 CLUSTER_CHANGE_RESOURCE_TYPE_PRIVATE_PROPERTY_V2 = 0x00000004,
2285                 CLUSTER_CHANGE_RESOURCE_TYPE_POSSIBLE_OWNERS_V2 = 0x00000008,
2286                 CLUSTER_CHANGE_RESOURCE_TYPE_DLL_UPGRADED_V2 = 0x00000010
2287         } CHANGE_RESOURCE_TYPE_V2;
2288
2289         typedef enum {
2290                 CLUSTER_CHANGE_NETINTERFACE_DELETED_V2 = 0x00000001,
2291                 CLUSTER_CHANGE_NETINTERFACE_COMMON_PROPERTY_V2 = 0x00000002,
2292                 CLUSTER_CHANGE_NETINTERFACE_PRIVATE_PROPERTY_V2 = 0x00000004,
2293                 CLUSTER_CHANGE_NETINTERFACE_STATE_V2 = 0x00000008,
2294                 CLUSTER_CHANGE_NETINTERFACE_HANDLE_CLOSE_V2 = 0x00000010
2295         } CLUSTER_CHANGE_NETINTERFACE_V2;
2296
2297         typedef enum {
2298                 CLUSTER_CHANGE_NETWORK_DELETED_V2 = 0x00000001,
2299                 CLUSTER_CHANGE_NETWORK_COMMON_PROPERTY_V2 = 0x00000002,
2300                 CLUSTER_CHANGE_NETWORK_PRIVATE_PROPERTY_V2 = 0x00000004,
2301                 CLUSTER_CHANGE_NETWORK_STATE_V2 = 0x00000008,
2302                 CLUSTER_CHANGE_NETWORK_HANDLE_CLOSE_V2 = 0x00000010
2303         } CLUSTER_CHANGE_NETWORK_V2;
2304
2305         typedef enum {
2306                 CLUSTER_CHANGE_NODE_NETINTERFACE_ADDED_V2 = 0x00000001,
2307                 CLUSTER_CHANGE_NODE_DELETED_V2 = 0x00000002,
2308                 CLUSTER_CHANGE_NODE_COMMON_PROPERTY_V2 = 0x00000004,
2309                 CLUSTER_CHANGE_NODE_PRIVATE_PROPERTY_V2 = 0x00000008,
2310                 CLUSTER_CHANGE_NODE_STATE_V2 = 0x00000010,
2311                 CLUSTER_CHANGE_NODE_GROUP_GAINED_V2 = 0x00000020,
2312                 CLUSTER_CHANGE_NODE_GROUP_LOST_V2 = 0x00000040,
2313                 CLUSTER_CHANGE_NODE_HANDLE_CLOSE_V2 = 0x00000080
2314         } CLUSTER_CHANGE_NODE_V2;
2315
2316         typedef enum {
2317                 CLUSTER_CHANGE_REGISTRY_ATTRIBUTES_V2 = 0x00000001,
2318                 CLUSTER_CHANGE_REGISTRY_NAME_V2 = 0x00000002,
2319                 CLUSTER_CHANGE_REGISTRY_SUBTREE_V2 = 0x00000004,
2320                 CLUSTER_CHANGE_REGISTRY_VALUE_V2 = 0x00000008,
2321                 CLUSTER_CHANGE_REGISTRY_HANDLE_CLOSE_V2 = 0x00000010
2322         } CLUSTER_CHANGE_REGISTRY_V2;
2323
2324         typedef enum {
2325                 CLUSTER_CHANGE_QUORUM_STATE_V2 = 0x00000001
2326         } CLUSTER_CHANGE_QUORUM_V2;
2327
2328         typedef enum {
2329                 CLUSTER_CHANGE_SHARED_VOLUME_STATE_V2 = 0x00000001
2330         } CLUSTER_CHANGE_SHARED_VOLUME_V2;
2331 #if 0
2332         typedef enum {
2333                 DiskIdSignature = 0x00000001,
2334                 DiskIdGuid = 0x00000002,
2335                 DiskIdUnKnown = 0x00001388
2336         } CLUSDSK_DISKID_ENUM;
2337 #endif
2338 }