librpc/idl/clusapi.idl

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