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         typedef [v1_enum] enum {
 689                 ClusterGroupOnline              = 0x00000000,
 690                 ClusterGroupOffline             = 0x00000001,
 691                 ClusterGroupFailed              = 0x00000002,
 692                 ClusterGroupPartialOnline       = 0x00000003,
 693                 ClusterGroupPending             = 0x00000004,
 694                 ClusterGroupStateUnknown        = 0xFFFFFFFF
 695         } clusapi_ClusterGroupState;
 696
 697         WERROR
 698         clusapi_GetGroupState(
 699                 [ in ] HGROUP_RPC hGroup,
 700                 [ out ] clusapi_ClusterGroupState *State,
 701                 [ out, string ] [charset(UTF16)] uint16 **NodeName,
 702                 [ out ] WERROR *rpc_status
 703         );
 704
 705         /*****************/
 706         /* Function 0x2E */
 707
 708         WERROR
 709         clusapi_SetGroupName(
 710                 [ in ] HGROUP_RPC hGroup,
 711                 [ in, string ] [charset(UTF16)] uint16 *lpszGroupName,
 712                 [ out ] WERROR *rpc_status
 713         );
 714
 715         /*****************/
 716         /* Function 0x2F */
 717
 718         WERROR
 719         clusapi_GetGroupId(
 720                 [ in ] HGROUP_RPC hGroup,
 721                 [ out, string ] [charset(UTF16)] uint16 **pGuid,
 722                 [ out ] WERROR *rpc_status
 723         );
 724
 725         /*****************/
 726         /* Function 0x30 */
 727
 728         WERROR
 729         clusapi_GetNodeId(
 730                 [ in ] HNODE_RPC hNode,
 731                 [ out, string ] [charset(UTF16)] uint16 **pGuid,
 732                 [ out ] WERROR *rpc_status
 733         );
 734
 735         /*****************/
 736         /* Function 0x31 */
 737
 738         WERROR
 739         clusapi_OnlineGroup(
 740                 [ in ] HGROUP_RPC hGroup,
 741                 [ out ] WERROR *rpc_status
 742         );
 743
 744         /*****************/
 745         /* Function 0x32 */
 746
 747         WERROR
 748         clusapi_OfflineGroup(
 749                 [ in ] HGROUP_RPC hGroup,
 750                 [ out ] WERROR *rpc_status
 751         );
 752
 753         /*****************/
 754         /* Function 0x33 */
 755
 756         WERROR
 757         clusapi_MoveGroup(
 758                 [ in ] HGROUP_RPC hGroup,
 759                 [ out ] WERROR *rpc_status
 760         );
 761
 762         /*****************/
 763         /* Function 0x34 */
 764
 765         WERROR
 766         clusapi_MoveGroupToNode(
 767                 [ in ] HGROUP_RPC hGroup,
 768                 [ in ] HNODE_RPC hNode,
 769                 [ out ] WERROR *rpc_status
 770         );
 771
 772         /*****************/
 773         /* Function 0x35 */
 774
 775         WERROR
 776         clusapi_CreateGroupResourceEnum(
 777                 [ in ] HGROUP_RPC hGroup,
 778                 [ in ] uint32 dwType,
 779                 [ out ] ENUM_LIST **ReturnEnum,
 780                 [ out ] WERROR *rpc_status
 781         );
 782
 783         /*****************/
 784         /* Function 0x36 */
 785
 786         WERROR
 787         clusapi_SetGroupNodeList(
 788                 [ in ] HGROUP_RPC hGroup,
 789                 [ in, unique, size_is(cchListSize) ] uint16 *multiSzNodeList,
 790                 [ in ] uint32 cchListSize,
 791                 [ out ] WERROR *rpc_status
 792         );
 793
 794         /*****************/
 795         /* Function 0x37 */
 796 #if 0
 797         HNOTIFY_RPC
 798         clusapi_CreateNotify(
 799                 [ out ] WERROR *Status,
 800                 [ out ] WERROR *rpc_status
 801         );
 802 #else
 803         void
 804         clusapi_CreateNotify(
 805                 [ out ] WERROR *Status,
 806                 [ out ] WERROR *rpc_status,
 807                 [ out ] HNOTIFY_RPC *hNotify
 808         );
 809 #endif
 810         /*****************/
 811         /* Function 0x38 */
 812
 813         WERROR
 814         clusapi_CloseNotify(
 815                 [ in, out ] HNOTIFY_RPC *Notify
 816         );
 817
 818         /*****************/
 819         /* Function 0x39 */
 820
 821         WERROR
 822         clusapi_AddNotifyCluster(
 823                 [ in ] HNOTIFY_RPC hNotify,
 824                 [ in ] HCLUSTER_RPC hCluster,
 825                 [ in ] uint32 dwFilter,
 826                 [ in ] uint32 dwNotifyKey,
 827                 [ out ] WERROR *rpc_status
 828         );
 829
 830         /*****************/
 831         /* Function 0x3A */
 832
 833         WERROR
 834         clusapi_AddNotifyNode(
 835                 [ in ] HNOTIFY_RPC hNotify,
 836                 [ in ] HNODE_RPC hNode,
 837                 [ in ] uint32 dwFilter,
 838                 [ in ] uint32 dwNotifyKey,
 839                 [ out ] uint32 *dwStateSequence,
 840                 [ out ] WERROR *rpc_status
 841         );
 842
 843         /*****************/
 844         /* Function 0x3B */
 845
 846         WERROR
 847         clusapi_AddNotifyGroup(
 848                 [ in ] HNOTIFY_RPC hNotify,
 849                 [ in ] HGROUP_RPC hGroup,
 850                 [ in ] uint32 dwFilter,
 851                 [ in ] uint32 dwNotifyKey,
 852                 [ out ] uint32 *dwStateSequence,
 853                 [ out ] WERROR *rpc_status
 854         );
 855
 856         /*****************/
 857         /* Function 0x3C */
 858
 859         WERROR
 860         clusapi_AddNotifyResource(
 861                 [ in ] HNOTIFY_RPC hNotify,
 862                 [ in ] HRES_RPC hResource,
 863                 [ in ] uint32 dwFilter,
 864                 [ in ] uint32 dwNotifyKey,
 865                 [ out ] uint32 *dwStateSequence,
 866                 [ out ] WERROR *rpc_status
 867         );
 868
 869         /*****************/
 870         /* Function 0x3D */
 871
 872         WERROR
 873         clusapi_AddNotifyKey(
 874                 [ in ] HNOTIFY_RPC hNotify,
 875                 [ in ] HKEY_RPC hKey,
 876                 [ in ] uint32 dwNotifyKey,
 877                 [ in ] uint32 Filter,
 878                 [ in ] boolean8 WatchSubTree,
 879                 [ out ] WERROR *rpc_status
 880         );
 881
 882         /*****************/
 883         /* Function 0x3E */
 884
 885         WERROR
 886         clusapi_ReAddNotifyNode(
 887                 [ in ] HNOTIFY_RPC hNotify,
 888                 [ in ] HNODE_RPC hNode,
 889                 [ in ] uint32 dwFilter,
 890                 [ in ] uint32 dwNotifyKey,
 891                 [ in ] uint32 StateSequence,
 892                 [ out ] WERROR *rpc_status
 893         );
 894
 895         /*****************/
 896         /* Function 0x3F */
 897
 898         WERROR
 899         clusapi_ReAddNotifyGroup(
 900                 [ in ] HNOTIFY_RPC hNotify,
 901                 [ in ] HGROUP_RPC hGroup,
 902                 [ in ] uint32 dwFilter,
 903                 [ in ] uint32 dwNotifyKey,
 904                 [ in ] uint32 StateSequence,
 905                 [ out ] WERROR *rpc_status
 906         );
 907
 908         /*****************/
 909         /* Function 0x40 */
 910
 911         WERROR
 912         clusapi_ReAddNotifyResource(
 913                 [ in ] HNOTIFY_RPC hNotify,
 914                 [ in ] HRES_RPC hResource,
 915                 [ in ] uint32 dwFilter,
 916                 [ in ] uint32 dwNotifyKey,
 917                 [ in ] uint32 StateSequence,
 918                 [ out ] WERROR *rpc_status
 919         );
 920
 921         /*****************/
 922         /* Function 0x41 */
 923
 924         WERROR
 925         clusapi_GetNotify(
 926                 [ in ] HNOTIFY_RPC hNotify,
 927                 [ out ] uint32 *dwNotifyKey,
 928                 [ out ] uint32 *dwFilter,
 929                 [ out ] uint32 *dwStateSequence,
 930                 [ out, string ] [charset(UTF16)] uint16 **Name,
 931                 [ out ] WERROR *rpc_status
 932         );
 933
 934         /*****************/
 935         /* Function 0x42 */
 936 #if 0
 937         HNODE_RPC
 938         clusapi_OpenNode(
 939                 [ in, string ] [charset(UTF16)] uint16 *lpszNodeName,
 940                 [ out ] WERROR *Status,
 941                 [ out ] WERROR *rpc_status
 942         );
 943 #else
 944         void
 945         clusapi_OpenNode(
 946                 [ in, string ] [charset(UTF16)] uint16 *lpszNodeName,
 947                 [ out ] WERROR *Status,
 948                 [ out ] WERROR *rpc_status,
 949                 [ out ] HNODE_RPC *hNode
 950         );
 951 #endif
 952         /*****************/
 953         /* Function 0x43 */
 954
 955         WERROR
 956         clusapi_CloseNode(
 957                 [ in, out ] HNODE_RPC *Node
 958         );
 959
 960         /*****************/
 961         /* Function 0x44 */
 962
 963         typedef [v1_enum] enum {
 964                 ClusterNodeUp           = 0x00000000,
 965                 ClusterNodeDown         = 0x00000001,
 966                 ClusterNodePaused       = 0x00000002,
 967                 ClusterNodeJoining      = 0x00000003,
 968                 ClusterNodeStateUnknown = 0xFFFFFFFF
 969         } clusapi_ClusterNodeState;
 970
 971         WERROR
 972         clusapi_GetNodeState(
 973                 [ in ] HNODE_RPC hNode,
 974                 [ out ] clusapi_ClusterNodeState *State,
 975                 [ out ] WERROR *rpc_status
 976         );
 977
 978         /*****************/
 979         /* Function 0x45 */
 980
 981         WERROR
 982         clusapi_PauseNode(
 983                 [ in ] HNODE_RPC hNode,
 984                 [ out ] WERROR *rpc_status
 985         );
 986
 987         /*****************/
 988         /* Function 0x46 */
 989
 990         WERROR
 991         clusapi_ResumeNode(
 992                 [ in ] HNODE_RPC hNode,
 993                 [ out ] WERROR *rpc_status
 994         );
 995
 996         /*****************/
 997         /* Function 0x47 */
 998
 999         WERROR
1000         clusapi_EvictNode(
1001                 [ in ] HNODE_RPC hNode,
1002                 [ out ] WERROR *rpc_status
1003         );
1004
1005         /*****************/
1006         /* Function 0x48 */
1007
1008         WERROR
1009         clusapi_NodeResourceControl(
1010                 [ in ] HRES_RPC hResource,
1011                 [ in ] HNODE_RPC hNode,
1012                 [ in ] uint32 dwControlCode,
1013                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1014                 [ in ] uint32 nInBufferSize,
1015                 [ out, size_is(nOutBufferSize),
1016                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1017                 [ in ] uint32 nOutBufferSize,
1018                 [ out ] uint32 *lpBytesReturned,
1019                 [ out ] uint32 *lpcbRequired,
1020                 [ out ] WERROR *rpc_status
1021         );
1022
1023         /*****************/
1024         /* Function 0x49 */
1025
1026         WERROR
1027         clusapi_ResourceControl(
1028                 [ in ] HRES_RPC hResource,
1029                 [ in ] uint32 dwControlCode,
1030                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1031                 [ in ] uint32 nInBufferSize,
1032                 [ out, size_is(nOutBufferSize),
1033                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1034                 [ in ] uint32 nOutBufferSize,
1035                 [ out ] uint32 *lpBytesReturned,
1036                 [ out ] uint32 *lpcbRequired,
1037                 [ out ] WERROR *rpc_status
1038         );
1039
1040         /*****************/
1041         /* Function 0x4A */
1042
1043         WERROR
1044         clusapi_NodeResourceTypeControl(
1045                 [ in ] HCLUSTER_RPC hCluster,
1046                 [ in, string ] [charset(UTF16)] uint16 *lpszResourceTypeName,
1047                 [ in ] HNODE_RPC hNode,
1048                 [ in ] uint32 dwControlCode,
1049                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1050                 [ in ] uint32 nInBufferSize,
1051                 [ out, size_is(nOutBufferSize),
1052                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1053                 [ in ] uint32 nOutBufferSize,
1054                 [ out ] uint32 *lpBytesReturned,
1055                 [ out ] uint32 *lpcbRequired,
1056                 [ out ] WERROR *rpc_status
1057         );
1058
1059         /*****************/
1060         /* Function 0x4B */
1061
1062         WERROR
1063         clusapi_ResourceTypeControl(
1064                 [ in ] HCLUSTER_RPC hCluster,
1065                 [ in, string ] [charset(UTF16)] uint16 *lpszResourceTypeName,
1066                 [ in ] uint32 dwControlCode,
1067                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1068                 [ in ] uint32 nInBufferSize,
1069                 [ out, size_is(nOutBufferSize),
1070                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1071                 [ in ] uint32 nOutBufferSize,
1072                 [ out ] uint32 *lpBytesReturned,
1073                 [ out ] uint32 *lpcbRequired,
1074                 [ out ] WERROR *rpc_status
1075         );
1076
1077         /*****************/
1078         /* Function 0x4C */
1079
1080         WERROR
1081         clusapi_NodeGroupControl(
1082                 [ in ] HGROUP_RPC hGroup,
1083                 [ in ] HNODE_RPC hNode,
1084                 [ in ] uint32 dwControlCode,
1085                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1086                 [ in ] uint32 nInBufferSize,
1087                 [ out, size_is(nOutBufferSize),
1088                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1089                 [ in ] uint32 nOutBufferSize,
1090                 [ out ] uint32 *lpBytesReturned,
1091                 [ out ] uint32 *lpcbRequired,
1092                 [ out ] WERROR *rpc_status
1093         );
1094
1095         /*****************/
1096         /* Function 0x4D */
1097
1098         WERROR
1099         clusapi_GroupControl(
1100                 [ in ] HGROUP_RPC hGroup,
1101                 [ in ] uint32 dwControlCode,
1102                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1103                 [ in ] uint32 nInBufferSize,
1104                 [ out, size_is(nOutBufferSize),
1105                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1106                 [ in ] uint32 nOutBufferSize,
1107                 [ out ] uint32 *lpBytesReturned,
1108                 [ out ] uint32 *lpcbRequired,
1109                 [ out ] WERROR *rpc_status
1110         );
1111
1112         /*****************/
1113         /* Function 0x4E */
1114
1115         WERROR
1116         clusapi_NodeNodeControl(
1117                 [ in ] HNODE_RPC hNode,
1118                 [ in ] HNODE_RPC hHostNode,
1119                 [ in ] uint32 dwControlCode,
1120                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1121                 [ in ] uint32 nInBufferSize,
1122                 [ out, size_is(nOutBufferSize),
1123                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1124                 [ in ] uint32 nOutBufferSize,
1125                 [ out ] uint32 *lpBytesReturned,
1126                 [ out ] uint32 *lpcbRequired,
1127                 [ out ] WERROR *rpc_status
1128         );
1129
1130         /*****************/
1131         /* Function 0x4F */
1132
1133         WERROR
1134         clusapi_NodeControl(
1135                 [ in ] HNODE_RPC hNode,
1136                 [ in ] uint32 dwControlCode,
1137                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1138                 [ in ] uint32 nInBufferSize,
1139                 [ out, size_is(nOutBufferSize),
1140                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1141                 [ in ] uint32 nOutBufferSize,
1142                 [ out ] uint32 *lpBytesReturned,
1143                 [ out ] uint32 *lpcbRequired,
1144                 [ out ] WERROR *rpc_status
1145         );
1146
1147         /*****************/
1148         /* Function 0x50 */
1149
1150         WERROR
1151         Opnum80NotUsedOnWire(void);
1152
1153         /*****************/
1154         /* Function 0x51 */
1155 #if 0
1156         HNETWORK_RPC
1157         clusapi_OpenNetwork(
1158                 [ in, string ] [charset(UTF16)] uint16 *lpszNetworkName,
1159                 [ out ] WERROR *Status,
1160                 [ out ] WERROR *rpc_status
1161         );
1162 #else
1163         void
1164         clusapi_OpenNetwork(
1165                 [ in, string ] [charset(UTF16)] uint16 *lpszNetworkName,
1166                 [ out ] WERROR *Status,
1167                 [ out ] WERROR *rpc_status,
1168                 [ out ] HNETWORK_RPC *hNetwork
1169         );
1170 #endif
1171         /*****************/
1172         /* Function 0x52 */
1173
1174         WERROR
1175         clusapi_CloseNetwork(
1176                 [ in, out ] HNETWORK_RPC *Network
1177         );
1178
1179         /*****************/
1180         /* Function 0x53 */
1181
1182         WERROR
1183         clusapi_GetNetworkState(
1184                 [ in ] HNETWORK_RPC hNetwork,
1185                 [ out ] uint32 *State,
1186                 [ out ] WERROR *rpc_status
1187         );
1188
1189         /*****************/
1190         /* Function 0x54 */
1191
1192         WERROR
1193         clusapi_SetNetworkName(
1194                 [ in ] HNETWORK_RPC hNetwork,
1195                 [ in, string ] [charset(UTF16)] uint16 *lpszNetworkName,
1196                 [ out ] WERROR *rpc_status
1197         );
1198
1199         /*****************/
1200         /* Function 0x55 */
1201
1202         WERROR
1203         clusapi_CreateNetworkEnum(
1204                 [ in ] HNETWORK_RPC hNetwork,
1205                 [ in ] uint32 dwType,
1206                 [ out ] ENUM_LIST **ReturnEnum,
1207                 [ out ] WERROR *rpc_status
1208         );
1209
1210         /*****************/
1211         /* Function 0x56 */
1212
1213         WERROR
1214         clusapi_GetNetworkId(
1215                 [ in ] HNETWORK_RPC hNetwork,
1216                 [ out, string ] [charset(UTF16)] uint16 **pGuid,
1217                 [ out ] WERROR *rpc_status
1218         );
1219
1220         /*****************/
1221         /* Function 0x57 */
1222
1223         WERROR
1224         clusapi_SetNetworkPriorityOrder(
1225                 [ in, range(0, 1000)] uint32 NetworkCount,
1226                 [ in, string, size_is(NetworkCount) ] [charset(UTF16)] uint16 NetworkIdList[*],
1227                 [ out ] WERROR *rpc_status
1228         );
1229
1230         /*****************/
1231         /* Function 0x58 */
1232
1233         WERROR
1234         clusapi_NodeNetworkControl(
1235                 [ in ] HNETWORK_RPC hNetwork,
1236                 [ in ] HNODE_RPC hNode,
1237                 [ in ] uint32 dwControlCode,
1238                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1239                 [ in ] uint32 nInBufferSize,
1240                 [ out, size_is(nOutBufferSize),
1241                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1242                 [ in ] uint32 nOutBufferSize,
1243                 [ out ] uint32 *lpBytesReturned,
1244                 [ out ] uint32 *lpcbRequired,
1245                 [ out ] WERROR *rpc_status
1246         );
1247
1248         /*****************/
1249         /* Function 0x59 */
1250
1251         WERROR
1252         clusapi_NetworkControl(
1253                 [ in ] HNETWORK_RPC hNetwork,
1254                 [ in ] uint32 dwControlCode,
1255                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1256                 [ in ] uint32 nInBufferSize,
1257                 [ out, size_is(nOutBufferSize),
1258                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1259                 [ in ] uint32 nOutBufferSize,
1260                 [ out ] uint32 *lpBytesReturned,
1261                 [ out ] uint32 *lpcbRequired,
1262                 [ out ] WERROR *rpc_status
1263         );
1264
1265         /*****************/
1266         /* Function 0x5A */
1267
1268         WERROR
1269         clusapi_AddNotifyNetwork(
1270                 [ in ] HNOTIFY_RPC hNotify,
1271                 [ in ] HNETWORK_RPC hNetwork,
1272                 [ in ] uint32 dwFilter,
1273                 [ in ] uint32 dwNotifyKey,
1274                 [ out ] uint32 *dwStateSequence,
1275                 [ out ] WERROR *rpc_status
1276         );
1277
1278         /*****************/
1279         /* Function 0x5B */
1280
1281         WERROR
1282         clusapi_ReAddNotifyNetwork(
1283                 [ in ] HNOTIFY_RPC hNotify,
1284                 [ in ] HNETWORK_RPC hNetwork,
1285                 [ in ] uint32 dwFilter,
1286                 [ in ] uint32 dwNotifyKey,
1287                 [ in ] uint32 StateSequence,
1288                 [ out ] WERROR *rpc_status
1289         );
1290
1291         /*****************/
1292         /* Function 0x5C */
1293 #if 0
1294         HNETINTERFACE_RPC
1295         clusapi_OpenNetInterface(
1296                 [ in, string ] [charset(UTF16)] uint16 *lpszNetInterfaceName,
1297                 [ out ] WERROR *Status,
1298                 [ out ] WERROR *rpc_status
1299         );
1300 #else
1301         void
1302         clusapi_OpenNetInterface(
1303                 [ in, string ] [charset(UTF16)] uint16 *lpszNetInterfaceName,
1304                 [ out ] WERROR *Status,
1305                 [ out ] WERROR *rpc_status,
1306                 [ out ] HNETINTERFACE_RPC *hNetInterface
1307         );
1308 #endif
1309         /*****************/
1310         /* Function 0x5D */
1311
1312         WERROR
1313         clusapi_CloseNetInterface(
1314                 [ in, out ] HNETINTERFACE_RPC *NetInterface
1315         );
1316
1317         /*****************/
1318         /* Function 0x5E */
1319
1320         WERROR
1321         clusapi_GetNetInterfaceState(
1322                 [ in ] HNETINTERFACE_RPC hNetInterface,
1323                 [ out ] uint32 *State,
1324                 [ out ] WERROR *rpc_status
1325         );
1326
1327         /*****************/
1328         /* Function 0x5F */
1329
1330         WERROR
1331         clusapi_GetNetInterface(
1332                 [ in, string ] [charset(UTF16)] uint16 *lpszNodeName,
1333                 [ in, string ] [charset(UTF16)] uint16 *lpszNetworkName,
1334                 [ out, string ] [charset(UTF16)] uint16 **lppszInterfaceName,
1335                 [ out ] WERROR *rpc_status
1336         );
1337
1338         /*****************/
1339         /* Function 0x60 */
1340
1341         WERROR
1342         clusapi_GetNetInterfaceId(
1343                 [ in ] HNETINTERFACE_RPC hNetInterface,
1344                 [ out, string ] [charset(UTF16)] uint16 **pGuid,
1345                 [ out ] WERROR *rpc_status
1346         );
1347
1348         /*****************/
1349         /* Function 0x61 */
1350
1351         WERROR
1352         clusapi_NodeNetInterfaceControl(
1353                 [ in ] HNETINTERFACE_RPC hNetInterface,
1354                 [ in ] HNODE_RPC hNode,
1355                 [ in ] uint32 dwControlCode,
1356                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1357                 [ in ] uint32 nInBufferSize,
1358                 [ out, size_is(nOutBufferSize),
1359                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1360                 [ in ] uint32 nOutBufferSize,
1361                 [ out ] uint32 *lpBytesReturned,
1362                 [ out ] uint32 *lpcbRequired,
1363                 [ out ] WERROR *rpc_status
1364         );
1365
1366         /*****************/
1367         /* Function 0x62 */
1368
1369         WERROR
1370         clusapi_NetInterfaceControl(
1371                 [ in ] HNETINTERFACE_RPC hNetInterface,
1372                 [ in ] uint32 dwControlCode,
1373                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1374                 [ in ] uint32 nInBufferSize,
1375                 [ out, size_is(nOutBufferSize),
1376                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1377                 [ in ] uint32 nOutBufferSize,
1378                 [ out ] uint32 *lpBytesReturned,
1379                 [ out ] uint32 *lpcbRequired,
1380                 [ out ] WERROR *rpc_status
1381         );
1382
1383         /*****************/
1384         /* Function 0x63 */
1385
1386         WERROR
1387         clusapi_AddNotifyNetInterface(
1388                 [ in ] HNOTIFY_RPC hNotify,
1389                 [ in ] HNETINTERFACE_RPC hNetInterface,
1390                 [ in ] uint32 dwFilter,
1391                 [ in ] uint32 dwNotifyKey,
1392                 [ out ] uint32 *dwStateSequence,
1393                 [ out ] WERROR *rpc_status
1394         );
1395
1396         /*****************/
1397         /* Function 0x64 */
1398
1399         WERROR
1400         clusapi_ReAddNotifyNetInterface(
1401                 [ in ] HNOTIFY_RPC hNotify,
1402                 [ in ] HNETINTERFACE_RPC hNetInterface,
1403                 [ in ] uint32 dwFilter,
1404                 [ in ] uint32 dwNotifyKey,
1405                 [ in ] uint32 StateSequence,
1406                 [ out ] WERROR *rpc_status
1407         );
1408
1409         /*****************/
1410         /* Function 0x65 */
1411
1412         WERROR
1413         clusapi_CreateNodeEnum(
1414                 [ in ] HNODE_RPC hNode,
1415                 [ in ] uint32 dwType,
1416                 [ out ] ENUM_LIST **ReturnEnum,
1417                 [ out ] WERROR *rpc_status
1418         );
1419
1420         /*****************/
1421         /* Function 0x66 */
1422
1423         WERROR
1424         clusapi_GetClusterVersion2(
1425                 [ out ] uint16 *lpwMajorVersion,
1426                 [ out ] uint16 *lpwMinorVersion,
1427                 [ out ] uint16 *lpwBuildNumber,
1428                 [ out, string ] [charset(UTF16)] uint16 **lpszVendorId,
1429                 [ out, string ] [charset(UTF16)] uint16 **lpszCSDVersion,
1430                 [ out ] CLUSTER_OPERATIONAL_VERSION_INFO **ppClusterOpVerInfo,
1431                 [ out ] WERROR *rpc_status
1432         );
1433
1434         /*****************/
1435         /* Function 0x67 */
1436
1437         WERROR
1438         clusapi_CreateResTypeEnum(
1439                 [ in, string ] [charset(UTF16)] uint16 *lpszTypeName,
1440                 [ in ] uint32 dwType,
1441                 [ out ] ENUM_LIST **ReturnEnum,
1442                 [ out ] WERROR *rpc_status
1443         );
1444
1445         /*****************/
1446         /* Function 0x68 */
1447
1448         WERROR
1449         clusapi_BackupClusterDatabase(
1450                 [ in, string ] [charset(UTF16)] uint16 *lpszPathName,
1451                 [ out ] WERROR *rpc_status
1452         );
1453
1454         /*****************/
1455         /* Function 0x69 */
1456
1457         WERROR
1458         clusapi_NodeClusterControl(
1459                 [ in ] HCLUSTER_RPC hCluster,
1460                 [ in ] HNODE_RPC hHostNode,
1461                 [ in ] uint32 dwControlCode,
1462                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1463                 [ in ] uint32 nInBufferSize,
1464                 [ out, size_is(nOutBufferSize),
1465                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1466                 [ in ] uint32 nOutBufferSize,
1467                 [ out ] uint32 *lpBytesReturned,
1468                 [ out ] uint32 *lpcbRequired,
1469                 [ out ] WERROR *rpc_status
1470         );
1471
1472         /*****************/
1473         /* Function 0x6A */
1474
1475         WERROR
1476         clusapi_ClusterControl(
1477                 [ in ] HCLUSTER_RPC hCluster,
1478                 [ in ] uint32 dwControlCode,
1479                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1480                 [ in ] uint32 nInBufferSize,
1481                 [ out, size_is(nOutBufferSize),
1482                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1483                 [ in ] uint32 nOutBufferSize,
1484                 [ out ] uint32 *lpBytesReturned,
1485                 [ out ] uint32 *lpcbRequired,
1486                 [ out ] WERROR *rpc_status
1487         );
1488
1489         /*****************/
1490         /* Function 0x6B */
1491
1492         WERROR
1493         clusapi_UnblockGetNotifyCall(
1494                 [ in ] HNOTIFY_RPC hNotify
1495         );
1496
1497         /*****************/
1498         /* Function 0x6C */
1499
1500         WERROR
1501         clusapi_SetServiceAccountPassword(
1502                 [ in, string ] [charset(UTF16)] uint16 *lpszNewPassword,
1503                 [ in ]  IDL_CLUSTER_SET_PASSWORD_FLAGS dwFlags,
1504                 [ out, size_is(ReturnStatusBufferSize), length_is(*SizeReturned) ]
1505                          IDL_CLUSTER_SET_PASSWORD_STATUS ReturnStatusBufferPtr[*],
1506                 [ in, range(0, (64 * 1024)) ] uint32 ReturnStatusBufferSize,
1507                 [ out ] uint32 *SizeReturned,
1508                 [ out ] uint32 *ExpectedBufferSize
1509         );
1510
1511         /*****************/
1512         /* Function 0x6D */
1513
1514         WERROR
1515         clusapi_SetResourceDependencyExpression(
1516                 [ in ] HRES_RPC hResource,
1517                 [ in, string, unique ] [charset(UTF16)] uint16 *lpszDependencyExpression,
1518                 [ out ] WERROR *rpc_status
1519         );
1520
1521         /*****************/
1522         /* Function 0x6E */
1523
1524         WERROR
1525         clusapi_GetResourceDependencyExpression(
1526                 [ in ] HRES_RPC hResource,
1527                 [ out, string ] [charset(UTF16)] uint16 **lpszDependencyExpression,
1528                 [ out ] WERROR *rpc_status
1529         );
1530
1531         /*****************/
1532         /* Function 0x6F */
1533
1534         WERROR
1535         Opnum111NotUsedOnWire(void);
1536
1537         /*****************/
1538         /* Function 0x70 */
1539
1540         WERROR
1541         clusapi_GetResourceNetworkName(
1542                 [ in ] HRES_RPC hResource,
1543                 [ out, string ] [charset(UTF16)] uint16 **lpszName,
1544                 [ out ] WERROR *rpc_status
1545         );
1546
1547         /*****************/
1548         /* Function 0x71 */
1549
1550         WERROR
1551         clusapi_ExecuteBatch(
1552                 [ in ] HKEY_RPC hKey,
1553                 [ in ] uint32 cbData,
1554                 [ in, size_is(cbData)] uint8 *lpData,
1555                 [ out ] int *pdwFailedCommand,
1556                 [ out ] WERROR *rpc_status
1557         );
1558
1559         /*****************/
1560         /* Function 0x72 */
1561
1562         WERROR
1563         clusapi_CreateBatchPort(
1564                 [ in ] HKEY_RPC hKey,
1565                 [ out ] HBATCH_PORT_RPC *phBatchPort,
1566                 [ out ] WERROR *rpc_status
1567         );
1568
1569         /*****************/
1570         /* Function 0x73 */
1571
1572         WERROR
1573         clusapi_GetBatchNotification(
1574                  [ in ] HBATCH_PORT_RPC hBatchNotify,
1575                  [ out ] uint32 *cbData,
1576                  [ out, size_is(,*cbData) ] uint8 ** lpData
1577         );
1578
1579         /*****************/
1580         /* Function 0x74 */
1581
1582         WERROR
1583         clusapi_CloseBatchPort(
1584                  [ in, out ] HBATCH_PORT_RPC *phBatchPort
1585         );
1586
1587         /*****************/
1588         /* Function 0x75 */
1589 #if 0
1590         HCLUSTER_RPC
1591         clusapi_OpenClusterEx(
1592                 [ in ] uint32 dwDesiredAccess,
1593                 [ out ] uint32 *lpdwGrantedAccess,
1594                 [ out ] WERROR *Status
1595         );
1596 #else
1597         void
1598         clusapi_OpenClusterEx(
1599                 [ in ] uint32 dwDesiredAccess,
1600                 [ out ] uint32 *lpdwGrantedAccess,
1601                 [ out ] WERROR *Status,
1602                 [ out ] HCLUSTER_RPC *hCluster
1603         );
1604 #endif
1605
1606         /*****************/
1607         /* Function 0x76 */
1608 #if 0
1609         HNODE_RPC
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         );
1617 #else
1618         void
1619         clusapi_OpenNodeEx(
1620                 [ in, string ] [charset(UTF16)] uint16 *lpszNodeName,
1621                 [ in ] uint32 dwDesiredAccess,
1622                 [ out ] uint32 *lpdwGrantedAccess,
1623                 [ out ] WERROR *Status,
1624                 [ out ] WERROR *rpc_status,
1625                 [ out ] HNODE_RPC *hNode
1626         );
1627 #endif
1628         /*****************/
1629         /* Function 0x77 */
1630 #if 0
1631         HGROUP_RPC
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         );
1639 #else
1640         void
1641         clusapi_OpenGroupEx(
1642                 [ in, string ] [charset(UTF16)] uint16 *lpszGroupName,
1643                 [ in ] uint32 dwDesiredAccess,
1644                 [ out ] uint32 *lpdwGrantedAccess,
1645                 [ out ] WERROR *Status,
1646                 [ out ] WERROR *rpc_status,
1647                 [ out ] HGROUP_RPC *hGroup
1648         );
1649 #endif
1650         /*****************/
1651         /* Function 0x78 */
1652 #if 0
1653         HRES_RPC
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         );
1661 #else
1662         void
1663         clusapi_OpenResourceEx(
1664                 [ in, string ] [charset(UTF16)] uint16 *lpszResourceName,
1665                 [ in ] uint32 dwDesiredAccess,
1666                 [ out ] uint32 *lpdwGrantedAccess,
1667                 [ out ] WERROR *Status,
1668                 [ out ] WERROR *rpc_status,
1669                 [ out ] HRES_RPC *hResource
1670         );
1671 #endif
1672         /*****************/
1673         /* Function 0x79 */
1674 #if 0
1675         HNETWORK_RPC
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         );
1683 #else
1684         void
1685         clusapi_OpenNetworkEx(
1686                 [ in, string ] [charset(UTF16)] uint16 *lpszNetworkName,
1687                 [ in ] uint32 dwDesiredAccess,
1688                 [ out ] uint32 *lpdwGrantedAccess,
1689                 [ out ] WERROR *Status,
1690                 [ out ] WERROR *rpc_status,
1691                 [ out ] HNETWORK_RPC *hNetwork
1692         );
1693 #endif
1694         /*****************/
1695         /* Function 0x7A */
1696 #if 0
1697         HNETINTERFACE_RPC
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         );
1705 #else
1706         void
1707         clusapi_OpenNetInterfaceEx(
1708                 [ in, string ] [charset(UTF16)] uint16 *lpszNetInterfaceName,
1709                 [ in ] uint32 dwDesiredAccess,
1710                 [ out ] uint32 *lpdwGrantedAccess,
1711                 [ out ] WERROR *Status,
1712                 [ out ] WERROR *rpc_status,
1713                 [ out ] HNETINTERFACE_RPC *hNetInterface
1714         );
1715 #endif
1716         /*****************/
1717         /* Function 0x7B */
1718
1719         WERROR
1720         clusapi_ChangeCsvState(
1721                 [ in ] HRES_RPC hResource,
1722                 [ in ] uint32 dwState,
1723                 [ out ] WERROR *rpc_status
1724         );
1725
1726         /*****************/
1727         /* Function 0x7C */
1728
1729         WERROR
1730         clusapi_CreateNodeEnumEx(
1731                 [in] HNODE_RPC hNode,
1732                 [in] uint32 dwType,
1733                 [in] uint32 dwOptions,
1734                 [out] ENUM_LIST **ReturnIdEnum,
1735                 [out] ENUM_LIST **ReturnNameEnum,
1736                 [out] WERROR* rpc_status
1737         );
1738
1739         /*****************/
1740         /* Function 0x7D */
1741
1742         WERROR
1743         clusapi_CreateEnumEx(
1744                 [in] HCLUSTER_RPC hCluster,
1745                 [in] uint32 dwType,
1746                 [in] uint32 dwOptions,
1747                 [out] ENUM_LIST **ReturnIdEnum,
1748                 [out] ENUM_LIST **ReturnNameEnum,
1749                 [out] WERROR* rpc_status
1750         );
1751
1752         /*****************/
1753         /* Function 0x7E */
1754
1755         WERROR
1756         clusapi_PauseNodeEx(
1757                 [ in ] HNODE_RPC hNode,
1758                 [ in ] boolean8 bDrainNode,
1759                 [ in ] uint32 dwPauseFlags,
1760                 [ out ] WERROR *rpc_status
1761         );
1762
1763         /*****************/
1764         /* Function 0x7F */
1765
1766         WERROR
1767         clusapi_PauseNodeWithDrainTarget(
1768                 [ in ] HNODE_RPC hNode,
1769                 [ in ] uint32 dwPauseFlags,
1770                 [ in ] HNODE_RPC hNodeDrainTarget,
1771                 [ out ] WERROR *rpc_status
1772         );
1773
1774         /*****************/
1775         /* Function 0x80 */
1776
1777         WERROR
1778         clusapi_ResumeNodeEx(
1779                 [ in ] HNODE_RPC hNode,
1780                 [ in ] uint32 dwResumeFailbackType,
1781                 [ in ] uint32 dwResumeFlagsReserved,
1782                 [ out ] WERROR *rpc_status
1783         );
1784
1785         /*****************/
1786         /* Function 0x81 */
1787 #if 0
1788         HGROUP_RPC
1789         clusapi_CreateGroupEx(
1790                 [ in, string ] [charset(UTF16)] uint16 *lpszGroupName,
1791                 [ in, unique ] CLUSTER_CREATE_GROUP_INFO_RPC *pGroupInfo,
1792                 [ out ] WERROR *Status,
1793                 [ out ] WERROR *rpc_status
1794         );
1795 #else
1796         void
1797         clusapi_CreateGroupEx(
1798                 [ in, string ] [charset(UTF16)] uint16 *lpszGroupName,
1799                 [ in, unique ] CLUSTER_CREATE_GROUP_INFO_RPC *pGroupInfo,
1800                 [ out ] WERROR *Status,
1801                 [ out ] WERROR *rpc_status,
1802                 [ out ] HGROUP_RPC *hGroup
1803         );
1804 #endif
1805         /*****************/
1806         /* Function 0x82 */
1807
1808         WERROR
1809         clusapi_OnlineGroupEx(
1810                 [ in ] HGROUP_RPC hGroup,
1811                 [ in ] uint32     dwOnlineFlags,
1812                 [ in, size_is(cbInBufferSize) ] uint8* lpInBuffer,
1813                 [ in ] uint32     cbInBufferSize,
1814                 [ out ] WERROR *rpc_status
1815         );
1816
1817         /*****************/
1818         /* Function 0x83 */
1819
1820         WERROR
1821         clusapi_OfflineGroupEx(
1822                 [ in ] HGROUP_RPC hGroup,
1823                 [ in ] uint32     dwOfflineFlags,
1824                 [ in, size_is(cbInBufferSize) ] uint8* lpInBuffer,
1825                 [ in ] uint32     cbInBufferSize,
1826                 [ out ] WERROR *rpc_status
1827         );
1828
1829         /*****************/
1830         /* Function 0x84 */
1831
1832         WERROR
1833         clusapi_MoveGroupEx(
1834                 [ in ] HGROUP_RPC hGroup,
1835                 [ in ] uint32           dwMoveFlags,
1836                 [ in, size_is(cbInBufferSize) ] uint8* lpInBuffer,
1837                 [ in ] uint32           cbInBufferSize,
1838                 [ out ] WERROR *rpc_status
1839         );
1840
1841         /*****************/
1842         /* Function 0x85 */
1843
1844         WERROR
1845         clusapi_MoveGroupToNodeEx(
1846                 [ in ] HGROUP_RPC hGroup,
1847                 [ in ] HNODE_RPC  hNode,
1848                 [ in ] uint32           dwMoveFlags,
1849                 [ in, size_is(cbInBufferSize) ] uint8* lpInBuffer,
1850                 [ in ] uint32           cbInBufferSize,
1851                 [ out ] WERROR *rpc_status
1852         );
1853
1854         /*****************/
1855         /* Function 0x86 */
1856
1857         WERROR
1858         clusapi_CancelClusterGroupOperation(
1859                 [ in ] HGROUP_RPC       hGroup,
1860                 [ in ] uint32            dwCancelFlags,
1861                 [ out ] WERROR *rpc_status
1862         );
1863
1864         /*****************/
1865         /* Function 0x87 */
1866
1867         WERROR
1868         clusapi_OnlineResourceEx(
1869                 [ in ] HRES_RPC hResource,
1870                 [ in ] uint32     dwOnlineFlags,
1871                 [ in, size_is(cbInBufferSize) ] uint8* lpInBuffer,
1872                 [ in ] uint32     cbInBufferSize,
1873                 [ out ] WERROR *rpc_status
1874         );
1875
1876         /*****************/
1877         /* Function 0x88 */
1878
1879         WERROR
1880         clusapi_OfflineResourceEx(
1881                 [ in ] HRES_RPC hResource,
1882                 [ in ] uint32     dwOfflineFlags,
1883                 [ in, size_is(cbInBufferSize) ] uint8* lpInBuffer,
1884                 [ in ] uint32     cbInBufferSize,
1885                 [ out ] WERROR *rpc_status
1886         );
1887
1888 #define HGENERIC_RPC policy_handle
1889 #if 0
1890         typedef [context_handle] void *HGENERIC_RPC;
1891 #endif
1892
1893         typedef struct {
1894                 uint32 dwObjectType;      // really of type CLUSTER_OBJECT_TYPE_RPC
1895                 hyper FilterFlags;
1896         } NOTIFY_FILTER_AND_TYPE_RPC;
1897
1898         typedef struct {
1899                 NOTIFY_FILTER_AND_TYPE_RPC FilterAndType;
1900                 [ size_is(dwBufferSize ) ] uint8* buffer;
1901                 uint32 dwBufferSize;
1902                 [string] [charset(UTF16)] uint16 *ObjectId;
1903                 [string] [charset(UTF16)] uint16 *ParentId;
1904                 [string] [charset(UTF16)] uint16 *Name;
1905                 [string] [charset(UTF16)] uint16 *Type;
1906         } NOTIFICATION_DATA_RPC;
1907
1908         typedef struct {
1909                 uint32 *dwNotifyKey;
1910                 NOTIFICATION_DATA_RPC NotificationData;
1911         } NOTIFICATION_RPC;
1912
1913         /*****************/
1914         /* Function 0x89 */
1915
1916         //
1917         // Notify interface V2 functions
1918         //
1919 #if 0
1920         HNOTIFY_RPC
1921         clusapi_CreateNotifyV2(
1922                 [ out ] WERROR *rpc_error,
1923                 [ out ] WERROR *rpc_status
1924         );
1925 #else
1926         void
1927         clusapi_CreateNotifyV2(
1928                 [ out ] WERROR *rpc_error,
1929                 [ out ] WERROR *rpc_status,
1930                 [ out ] HNOTIFY_RPC *hNotify
1931         );
1932
1933 #endif
1934         /*****************/
1935         /* Function 0x8A */
1936
1937         WERROR
1938         clusapi_AddNotifyV2(
1939                 [ in ] HNOTIFY_RPC hNotify,
1940                 [ in ] HGENERIC_RPC hObject,
1941                 [ in ] NOTIFY_FILTER_AND_TYPE_RPC filter,
1942                 [ in ] uint32 dwNotifyKey,
1943                 [ in ] uint32 dwVersion,
1944                 [ in ] boolean8 isTargetedAtObject,
1945                 [ out ] WERROR *rpc_status
1946         );
1947
1948         /*****************/
1949         /* Function 0x8B */
1950
1951         WERROR
1952         clusapi_GetNotifyV2(
1953                 [ in ] HNOTIFY_RPC hNotify,
1954                 [ out, size_is(,*dwNumNotifications) ] NOTIFICATION_RPC **Notifications,
1955                 [ out ] uint32 *dwNumNotifications
1956         );
1957
1958         /*****************/
1959         /* Function 0x8C */
1960
1961         WERROR
1962         clusapi_QueryAllValues(
1963                 [ in ] HKEY_RPC hKey,
1964                 [ out ] uint32 *pcbData,
1965                 [ out, size_is(1, *pcbData) ] uint8 ** ppData,
1966                 [ out ] WERROR *rpc_status
1967         );
1968
1969         typedef struct {
1970                 uint32 DiskIdType;
1971                 uint8  DiskIdBlob[16];
1972         } CLUSTER_DISKID;
1973
1974         /*****************/
1975         /* Function 0x8D */
1976
1977         WERROR
1978         clusapi_StmFindDisk(
1979                 [ in ] HCLUSTER_RPC hCluster,
1980                 [ in ] uint32 dwFlags,
1981                 [ in, out, unique ] CLUSTER_DISKID *pDiskId,
1982                 [ in, size_is(uniqueIdSize), unique ] uint8 *pUniqueId,
1983                 [ in ] uint32 uniqueIdSize,
1984                 [ out, ref, string ] [charset(UTF16)] uint16 **ppszDeviceName,
1985                 [ out ] WERROR *rpc_status
1986         );
1987
1988         typedef struct{
1989                 [string] [charset(UTF16)] uint16 *pszNodeName;
1990                 HRESULT ResultCode;
1991                 uint32  ResultSize;
1992                 [unique, size_is(ResultSize)]   uint8    *pResultData;
1993         } CLUSTER_MRR_NODE_RESPONSE;
1994
1995         typedef struct {
1996                 uint32 NodeCount;
1997                 [size_is(NodeCount)] CLUSTER_MRR_NODE_RESPONSE *pNodes;
1998         } CLUSTER_MRR_RESPONSE;
1999
2000         /*****************/
2001         /* Function 0x8E */
2002
2003         WERROR
2004         clusapi_ClusterMrr(
2005                 [ in ] HCLUSTER_RPC hCluster,
2006                 [ in ] boolean8 fExcludeSelf,
2007                 [ in ] hyper nodeSet,
2008                 [ in ] uint32 dwTimeout,
2009                 [ in ] uint32 dwComponent,
2010                 [ in ] uint32 dwControlCode,
2011                 [ in ] uint32 inSize,
2012                 [ in, unique, size_is(inSize) ] uint8 *pInData,
2013                 [ out, ref, size_is(1, 1) ] CLUSTER_MRR_RESPONSE **ppInfo,
2014                 [ out ] WERROR *rpc_status
2015         );
2016
2017         /*****************/
2018         /* Function 0x8F */
2019
2020         WERROR
2021         clusapi_CreateGroupEnum(
2022                 [ in ] HCLUSTER_RPC hCluster,
2023                 [ in, unique, size_is(cbProperties)] uint8* pProperties,
2024                 [ in ] uint32 cbProperties,
2025                 [ in, unique, size_is(cbRoProperties)] uint8* pRoProperties,
2026                 [ in ] uint32 cbRoProperties,
2027                 [ out ] GROUP_ENUM_LIST **ppResultList,
2028                 [ out ] WERROR *rpc_status
2029         );
2030
2031         /*****************/
2032         /* Function 0x90 */
2033
2034         WERROR
2035         clusapi_CreateResourceEnum(
2036                 [ in ] HCLUSTER_RPC hCluster,
2037                 [ in, unique, size_is(cbProperties)] uint8* pProperties,
2038                 [ in ] uint32 cbProperties,
2039                 [ in, unique, size_is(cbRoProperties)] uint8* pRoProperties,
2040                 [ in ] uint32 cbRoProperties,
2041                 [ out ] RESOURCE_ENUM_LIST **ppResultList,
2042                 [ out ] WERROR *rpc_status
2043         );
2044
2045         /*****************/
2046         /* Function 0x91 */
2047
2048         WERROR
2049         clusapi_ExecuteReadBatch(
2050                 [ in ] HKEY_RPC hKey,
2051                 [ in ] uint32 cbInData,
2052                 [ in, size_is(cbInData)] uint8 *lpInData,
2053                 [ out ] uint32 *cbOutData,
2054                 [ out, size_is(,*cbOutData) ] uint8 ** lpOutData,
2055                 [ out ] WERROR *rpc_status
2056         );
2057
2058         /*****************/
2059         /* Function 0x92 */
2060
2061         WERROR
2062         clusapi_RestartResource(
2063                 [ in ] HRES_RPC hResource,
2064                 [ in ] uint32 dwFlags,
2065                 [ out ] WERROR *rpc_status
2066         );
2067
2068         typedef struct {
2069                 uint32 dwNotifyKey;
2070                 uint32 dwFilter;
2071                 [string] [charset(UTF16)] uint16 *Name;
2072         } NOTIFICATION_DATA_ASYNC_RPC;
2073
2074         /*****************/
2075         /* Function 0x93 */
2076
2077         WERROR
2078         clusapi_GetNotifyAsync(
2079                 [ in ] HNOTIFY_RPC hNotify,
2080                 [ out, size_is(,*dwNumNotifications) ] NOTIFICATION_DATA_ASYNC_RPC **Notifications,
2081                 [ out ] uint32 *dwNumNotifications
2082         );
2083
2084         typedef enum {
2085                 DiskIdSignature = 0x00000001,
2086                 DiskIdGuid = 0x00000002,
2087                 DiskIdUnKnown = 0x00001388
2088         } CLUSDSK_DISKID_ENUM;
2089
2090 #if 0
2091         typedef struct {
2092                 CLUSDSK_DISKID_ENUM DiskIdType;
2093                 [switch_is(DiskIdType)] union {
2094                         [case(DiskIdSignature)] uint32 DiskSignature;
2095                         [case(DiskIdGuid)] GUID DiskGuid;
2096                 };
2097         } CLUSDSK_DISKID;
2098 #endif
2099         typedef enum {
2100                 CLUSPROP_TYPE_ENDMARK = 0x0000,
2101                 CLUSPROP_TYPE_LIST_VALUE = 0x0001,
2102                 CLUSPROP_TYPE_RESCLASS = 0x0002,
2103                 CLUSPROP_TYPE_NAME = 0x0004,
2104                 CLUSPROP_TYPE_SIGNATURE = 0x0005,
2105                 CLUSPROP_TYPE_SCSIADDRESS = 0x0006,
2106                 CLUSPROP_TYPE_DISK_NUMBER = 0x0007,
2107                 CLUSPROP_TYPE_PARTITION_INFO = 0x0008,
2108                 CLUSPROP_TYPE_DISK_SERIALNUMBER = 0x000a,
2109                 CLUSPROP_TYPE_DISK_GUID = 0x000b,
2110                 CLUSPROP_TYPE_DISK_SIZE = 0x000c,
2111                 CLUSPROP_TYPE_PARTITION_INFO_EX = 0x000d
2112         } CLUSTER_PROPERTY_TYPE;
2113
2114         typedef enum {
2115                 CLUSPROP_FORMAT_UNKNOWN = 0x0000,
2116                 CLUSPROP_FORMAT_BINARY = 0x0001,
2117                 CLUSPROP_FORMAT_DWORD = 0x0002,
2118                 CLUSPROP_FORMAT_SZ = 0x0003,
2119                 CLUSPROP_FORMAT_EXPAND_SZ = 0x0004,
2120                 CLUSPROP_FORMAT_MULTI_SZ = 0x0005,
2121                 CLUSPROP_FORMAT_ULARGE_INTEGER = 0x0006,
2122                 CLUSPROP_FORMAT_LONG = 0x0007,
2123                 CLUSPROP_FORMAT_EXPANDED_SZ = 0x0008,
2124                 CLUSPROP_FORMAT_SECURITY_DESCRIPTOR = 0x0009,
2125                 CLUSPROP_FORMAT_LARGE_INTEGER = 0x000a,
2126                 CLUSPROP_FORMAT_WORD = 0x000b,
2127                 CLUSPROP_FORMAT_FILETIME = 0x000c
2128         } CLUSTER_PROPERTY_FORMAT;
2129
2130         typedef enum {
2131                 CLUSPROP_SYNTAX_ENDMARK = 0x00000000,
2132                 CLUSPROP_SYNTAX_NAME = 0x00040003,
2133                 CLUSPROP_SYNTAX_RESCLASS = 0x00020002,
2134                 CLUSPROP_SYNTAX_LIST_VALUE_SZ = 0x00010003,
2135                 CLUSPROP_SYNTAX_LIST_VALUE_EXPAND_SZ = 0x00010004,
2136                 CLUSPROP_SYNTAX_LIST_VALUE_DWORD = 0x00010002,
2137                 CLUSPROP_SYNTAX_LIST_VALUE_BINARY = 0x00010001,
2138                 CLUSPROP_SYNTAX_LIST_VALUE_MULTI_SZ = 0x00010005,
2139                 CLUSPROP_SYNTAX_LIST_VALUE_LONG = 0x00010007,
2140                 CLUSPROP_SYNTAX_LIST_VALUE_EXPANDED_SZ = 0x00010008,
2141                 CLUSPROP_SYNTAX_LIST_VALUE_SECURITY_DESCRIPTOR = 0x00010009,
2142                 CLUSPROP_SYNTAX_LIST_VALUE_LARGE_INTEGER = 0x0001000a,
2143                 CLUSPROP_SYNTAX_LIST_VALUE_ULARGE_INTEGER = 0x00010006,
2144                 CLUSPROP_SYNTAX_LIST_VALUE_WORD = 0x0001000b,
2145                 CLUSPROP_SYNTAX_LIST_VALUE_FILETIME = 0x0001000c,
2146                 CLUSPROP_SYNTAX_DISK_SIGNATURE = 0x00050002,
2147                 CLUSPROP_SYNTAX_SCSI_ADDRESS = 0x00060002,
2148                 CLUSPROP_SYNTAX_DISK_NUMBER = 0x00070002,
2149                 CLUSPROP_SYNTAX_PARTITION_INFO = 0x00080001,
2150                 CLUSPROP_SYNTAX_DISK_SERIALNUMBER = 0x000a0003,
2151                 CLUSPROP_SYNTAX_DISK_GUID = 0x000b0003,
2152                 CLUSPROP_SYNTAX_DISK_SIZE = 0x000c0006,
2153                 CLUSPROP_SYNTAX_PARTITION_INFO_EX = 0x000d0001
2154         } CLUSTER_PROPERTY_SYNTAX;
2155
2156         typedef enum {
2157                 CLUS_CHAR_UNKNOWN = 0x00000000,
2158                 CLUS_CHAR_QUORUM = 0x00000001,
2159                 CLUS_CHAR_DELETE_REQUIRES_ALL_NODES = 0x00000002,
2160                 CLUS_CHAR_LOCAL_QUORUM = 0x00000004,
2161                 CLUS_CHAR_BROADCAST_DELETE = 0x00000020,
2162                 CLUS_CHAR_SINGLE_CLUSTER_INSTANCE = 0x00000040,
2163                 CLUS_CHAR_SINGLE_GROUP_INSTANCE = 0x00000080,
2164                 CLUS_CHAR_COEXIST_IN_SHARED_VOLUME_GROUP = 0x00000100,
2165                 CLUS_CHAR_RESERVED1 = 0x00000200,
2166                 CLUS_CHAR_MONITOR_DETACH = 0x00000400,
2167                 CLUS_CHAR_RESERVED2 = 0x00000800,
2168                 CLUS_CHAR_RESERVED3 = 0x00001000,
2169                 CLUS_CHAR_RESERVED4 = 0x00002000
2170         } CLUS_CHARACTERISTICS;
2171
2172         typedef enum {
2173                 CLUS_FLAG_CORE = 0x00000001
2174         } CLUS_FLAGS;
2175
2176         typedef enum {
2177                 MaintenanceModeTypeDisableIsAliveCheck = 1,
2178                 MaintenanceModeTypeOfflineResource = 2,
2179                 MaintenanceModeTypeUnclusterResource = 3
2180         } MAINTENANCE_MODE_TYPE;
2181
2182         typedef enum {
2183                 CLUSTER_CHANGE_NODE_STATE = 0x00000001,
2184                 CLUSTER_CHANGE_NODE_DELETED = 0x00000002,
2185                 CLUSTER_CHANGE_NODE_ADDED = 0x00000004,
2186                 CLUSTER_CHANGE_NODE_PROPERTY = 0x00000008,
2187                 CLUSTER_CHANGE_REGISTRY_NAME = 0x00000010,
2188                 CLUSTER_CHANGE_REGISTRY_ATTRIBUTES = 0x00000020,
2189                 CLUSTER_CHANGE_REGISTRY_VALUE = 0x00000040,
2190                 CLUSTER_CHANGE_REGISTRY_SUBTREE = 0x00000080,
2191                 CLUSTER_CHANGE_RESOURCE_STATE = 0x00000100,
2192                 CLUSTER_CHANGE_RESOURCE_DELETED = 0x00000200,
2193                 CLUSTER_CHANGE_RESOURCE_ADDED = 0x00000400,
2194                 CLUSTER_CHANGE_RESOURCE_PROPERTY = 0x00000800,
2195                 CLUSTER_CHANGE_GROUP_STATE = 0x00001000,
2196                 CLUSTER_CHANGE_GROUP_DELETED = 0x00002000,
2197                 CLUSTER_CHANGE_GROUP_ADDED = 0x00004000,
2198                 CLUSTER_CHANGE_GROUP_PROPERTY = 0x00008000,
2199                 CLUSTER_CHANGE_RESOURCE_TYPE_DELETED = 0x00010000,
2200                 CLUSTER_CHANGE_RESOURCE_TYPE_ADDED = 0x00020000,
2201                 CLUSTER_CHANGE_RESOURCE_TYPE_PROPERTY = 0x00040000,
2202                 CLUSTER_CHANGE_CLUSTER_RECONNECT = 0x00080000,
2203                 CLUSTER_CHANGE_NETWORK_STATE = 0x00100000,
2204                 CLUSTER_CHANGE_NETWORK_DELETED = 0x00200000,
2205                 CLUSTER_CHANGE_NETWORK_ADDED = 0x00400000,
2206                 CLUSTER_CHANGE_NETWORK_PROPERTY = 0x00800000,
2207                 CLUSTER_CHANGE_NETINTERFACE_STATE = 0x01000000,
2208                 CLUSTER_CHANGE_NETINTERFACE_DELETED = 0x02000000,
2209                 CLUSTER_CHANGE_NETINTERFACE_ADDED = 0x04000000,
2210                 CLUSTER_CHANGE_NETINTERFACE_PROPERTY = 0x08000000,
2211                 CLUSTER_CHANGE_QUORUM_STATE = 0x10000000,
2212                 CLUSTER_CHANGE_CLUSTER_STATE = 0x20000000,
2213                 CLUSTER_CHANGE_CLUSTER_PROPERTY = 0x40000000,
2214                 CLUSTER_CHANGE_HANDLE_CLOSE = 0x80000000
2215         } CLUSTER_CHANGE;
2216
2217         typedef enum {
2218                 CLUSREG_SET_VALUE = 1,
2219                 CLUSREG_CREATE_KEY = 2,
2220                 CLUSREG_DELETE_KEY = 3,
2221                 CLUSREG_DELETE_VALUE = 4,
2222                 CLUSREG_VALUE_DELETED = 6,
2223                 CLUSREG_READ_KEY = 7,
2224                 CLUSREG_READ_VALUE = 8,
2225                 CLUSREG_READ_ERROR = 9
2226         } CLUSTER_REG_BATCH_COMMAND;
2227 #if 0
2228         typedef enum {
2229                 IDL_CLUSTER_SET_PASSWORD_IGNORE_DOWN_NODES = 1
2230         } IDL_CLUSTER_SET_PASSWORD_FLAGS;
2231 #endif
2232         typedef enum {
2233                 CLUSTER_QUORUM_MAINTAINED = 0,
2234                 CLUSTER_QUORUM_LOST = 1
2235         } CLUSTER_QUORUM_VALUE;
2236
2237         typedef enum {
2238                 CLUSTER_OBJECT_TYPE_CLUSTER = 0x00000001,
2239                 CLUSTER_OBJECT_TYPE_GROUP = 0x00000002,
2240                 CLUSTER_OBJECT_TYPE_RESOURCE = 0x00000003,
2241                 CLUSTER_OBJECT_TYPE_RESOURCE_TYPE = 0x00000004,
2242                 CLUSTER_OBJECT_TYPE_NETWORK_INTERFACE = 0x00000005,
2243                 CLUSTER_OBJECT_TYPE_NETWORK = 0x00000006,
2244                 CLUSTER_OBJECT_TYPE_NODE = 0x00000007,
2245                 CLUSTER_OBJECT_TYPE_REGISTRY = 0x00000008,
2246                 CLUSTER_OBJECT_TYPE_QUORUM = 0x00000009,
2247                 CLUSTER_OBJECT_TYPE_SHARED_VOLUME = 0x0000000a
2248         } CLUSTER_OBJECT_TYPE;
2249
2250         typedef enum {
2251                 CLUSTER_CHANGE_CLUSTER_RECONNECT_V2 = 0x00000001,
2252                 CLUSTER_CHANGE_CLUSTER_STATE_V2 = 0x00000002,
2253                 CLUSTER_CHANGE_CLUSTER_GROUP_ADDED_V2 = 0x00000004,
2254                 CLUSTER_CHANGE_CLUSTER_HANDLE_CLOSE_V2 = 0x00000008,
2255                 CLUSTER_CHANGE_CLUSTER_NETWORK_ADDED_V2 = 0x00000010,
2256                 CLUSTER_CHANGE_CLUSTER_NODE_ADDED_V2 = 0x00000020,
2257                 CLUSTER_CHANGE_CLUSTER_RESOURCE_TYPE_ADDED_V2 = 0x00000040,
2258                 CLUSTER_CHANGE_CLUSTER_COMMON_PROPERTY_V2 = 0x00000080,
2259                 CLUSTER_CHANGE_CLUSTER_PRIVATE_PROPERTY_V2 = 0x00000100,
2260                 CLUSTER_CHANGE_CLUSTER_LOST_NOTIFICATIONS_V2 = 0x00000200,
2261                 CLUSTER_CHANGE_CLUSTER_RENAME_V2 = 0x00000400
2262         } CLUSTER_CHANGE_CLUSTER_V2;
2263
2264         typedef enum {
2265                 CLUSTER_CHANGE_GROUP_DELETED_V2 = 0x00000001,
2266                 CLUSTER_CHANGE_GROUP_COMMON_PROPERTY_V2 = 0x00000002,
2267                 CLUSTER_CHANGE_GROUP_PRIVATE_PROPERTY_V2 = 0x00000004,
2268                 CLUSTER_CHANGE_GROUP_STATE_V2 = 0x00000008,
2269                 CLUSTER_CHANGE_GROUP_OWNER_NODE_V2 = 0x00000010,
2270                 CLUSTER_CHANGE_GROUP_PREFERRED_OWNERS_V2 = 0x00000020,
2271                 CLUSTER_CHANGE_GROUP_RESOURCE_ADDED_V2 = 0x00000040,
2272                 CLUSTER_CHANGE_GROUP_RESOURCE_GAINED_V2 = 0x00000080,
2273                 CLUSTER_CHANGE_GROUP_RESOURCE_LOST_V2 = 0x00000100,
2274                 CLUSTER_CHANGE_GROUP_HANDLE_CLOSE_V2 = 0x00000200
2275         } CLUSTER_CHANGE_GROUP_V2;
2276
2277         typedef enum {
2278                 CLUSTER_CHANGE_RESOURCE_COMMON_PROPERTY_V2 = 0x00000001,
2279                 CLUSTER_CHANGE_RESOURCE_PRIVATE_PROPERTY_V2 = 0x00000002,
2280                 CLUSTER_CHANGE_RESOURCE_STATE_V2 = 0x00000004,
2281                 CLUSTER_CHANGE_RESOURCE_OWNER_GROUP_V2 = 0x00000008,
2282                 CLUSTER_CHANGE_RESOURCE_DEPENDENCIES_V2 = 0x00000010,
2283                 CLUSTER_CHANGE_RESOURCE_DEPENDENTS_V2 = 0x00000020,
2284                 CLUSTER_CHANGE_RESOURCE_POSSIBLE_OWNERS_V2 = 0x00000040,
2285                 CLUSTER_CHANGE_RESOURCE_DELETED_V2 = 0x00000080,
2286                 CLUSTER_CHANGE_RESOURCE_DLL_UPGRADED_V2 = 0x00000100,
2287                 CLUSTER_CHANGE_RESOURCE_HANDLE_CLOSE_V2 = 0x00000200
2288         } CLUSTER_CHANGE_RESOURCE_V2;
2289
2290         typedef enum {
2291                 CLUSTER_CHANGE_RESOURCE_TYPE_DELETED_V2 = 0x00000001,
2292                 CLUSTER_CHANGE_RESOURCE_TYPE_COMMON_PROPERTY_V2 = 0x00000002,
2293                 CLUSTER_CHANGE_RESOURCE_TYPE_PRIVATE_PROPERTY_V2 = 0x00000004,
2294                 CLUSTER_CHANGE_RESOURCE_TYPE_POSSIBLE_OWNERS_V2 = 0x00000008,
2295                 CLUSTER_CHANGE_RESOURCE_TYPE_DLL_UPGRADED_V2 = 0x00000010
2296         } CHANGE_RESOURCE_TYPE_V2;
2297
2298         typedef enum {
2299                 CLUSTER_CHANGE_NETINTERFACE_DELETED_V2 = 0x00000001,
2300                 CLUSTER_CHANGE_NETINTERFACE_COMMON_PROPERTY_V2 = 0x00000002,
2301                 CLUSTER_CHANGE_NETINTERFACE_PRIVATE_PROPERTY_V2 = 0x00000004,
2302                 CLUSTER_CHANGE_NETINTERFACE_STATE_V2 = 0x00000008,
2303                 CLUSTER_CHANGE_NETINTERFACE_HANDLE_CLOSE_V2 = 0x00000010
2304         } CLUSTER_CHANGE_NETINTERFACE_V2;
2305
2306         typedef enum {
2307                 CLUSTER_CHANGE_NETWORK_DELETED_V2 = 0x00000001,
2308                 CLUSTER_CHANGE_NETWORK_COMMON_PROPERTY_V2 = 0x00000002,
2309                 CLUSTER_CHANGE_NETWORK_PRIVATE_PROPERTY_V2 = 0x00000004,
2310                 CLUSTER_CHANGE_NETWORK_STATE_V2 = 0x00000008,
2311                 CLUSTER_CHANGE_NETWORK_HANDLE_CLOSE_V2 = 0x00000010
2312         } CLUSTER_CHANGE_NETWORK_V2;
2313
2314         typedef enum {
2315                 CLUSTER_CHANGE_NODE_NETINTERFACE_ADDED_V2 = 0x00000001,
2316                 CLUSTER_CHANGE_NODE_DELETED_V2 = 0x00000002,
2317                 CLUSTER_CHANGE_NODE_COMMON_PROPERTY_V2 = 0x00000004,
2318                 CLUSTER_CHANGE_NODE_PRIVATE_PROPERTY_V2 = 0x00000008,
2319                 CLUSTER_CHANGE_NODE_STATE_V2 = 0x00000010,
2320                 CLUSTER_CHANGE_NODE_GROUP_GAINED_V2 = 0x00000020,
2321                 CLUSTER_CHANGE_NODE_GROUP_LOST_V2 = 0x00000040,
2322                 CLUSTER_CHANGE_NODE_HANDLE_CLOSE_V2 = 0x00000080
2323         } CLUSTER_CHANGE_NODE_V2;
2324
2325         typedef enum {
2326                 CLUSTER_CHANGE_REGISTRY_ATTRIBUTES_V2 = 0x00000001,
2327                 CLUSTER_CHANGE_REGISTRY_NAME_V2 = 0x00000002,
2328                 CLUSTER_CHANGE_REGISTRY_SUBTREE_V2 = 0x00000004,
2329                 CLUSTER_CHANGE_REGISTRY_VALUE_V2 = 0x00000008,
2330                 CLUSTER_CHANGE_REGISTRY_HANDLE_CLOSE_V2 = 0x00000010
2331         } CLUSTER_CHANGE_REGISTRY_V2;
2332
2333         typedef enum {
2334                 CLUSTER_CHANGE_QUORUM_STATE_V2 = 0x00000001
2335         } CLUSTER_CHANGE_QUORUM_V2;
2336
2337         typedef enum {
2338                 CLUSTER_CHANGE_SHARED_VOLUME_STATE_V2 = 0x00000001
2339         } CLUSTER_CHANGE_SHARED_VOLUME_V2;
2340 #if 0
2341         typedef enum {
2342                 DiskIdSignature = 0x00000001,
2343                 DiskIdGuid = 0x00000002,
2344                 DiskIdUnKnown = 0x00001388
2345         } CLUSDSK_DISKID_ENUM;
2346 #endif
2347 }