librpc/idl/clusapi.idl

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