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