librpc/idl/clusapi.idl

   1 import "winreg.idl", "misc.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 ] winreg_Type 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 ] winreg_Type *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 ] winreg_Type *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         typedef [bitmap32bit] bitmap {
 795                 CLUSTER_GROUP_ENUM_CONTAINS             = 0x00000001,
 796                 CLUSTER_GROUP_ENUM_NODES                = 0x00000002
 797         } ClusterGroupEnumType;
 798
 799         WERROR
 800         clusapi_CreateGroupResourceEnum(
 801                 [ in ] HGROUP_RPC hGroup,
 802                 [ in ] ClusterGroupEnumType dwType,
 803                 [ out ] ENUM_LIST **ReturnEnum,
 804                 [ out ] WERROR *rpc_status
 805         );
 806
 807         /*****************/
 808         /* Function 0x36 */
 809
 810         WERROR
 811         clusapi_SetGroupNodeList(
 812                 [ in ] HGROUP_RPC hGroup,
 813                 [ in, unique, size_is(cchListSize) ] uint16 *multiSzNodeList,
 814                 [ in ] uint32 cchListSize,
 815                 [ out ] WERROR *rpc_status
 816         );
 817
 818         /*****************/
 819         /* Function 0x37 */
 820 #if 0
 821         HNOTIFY_RPC
 822         clusapi_CreateNotify(
 823                 [ out ] WERROR *Status,
 824                 [ out ] WERROR *rpc_status
 825         );
 826 #else
 827         void
 828         clusapi_CreateNotify(
 829                 [ out ] WERROR *Status,
 830                 [ out ] WERROR *rpc_status,
 831                 [ out ] HNOTIFY_RPC *hNotify
 832         );
 833 #endif
 834         /*****************/
 835         /* Function 0x38 */
 836
 837         WERROR
 838         clusapi_CloseNotify(
 839                 [ in, out ] HNOTIFY_RPC *Notify
 840         );
 841
 842         /*****************/
 843         /* Function 0x39 */
 844
 845         WERROR
 846         clusapi_AddNotifyCluster(
 847                 [ in ] HNOTIFY_RPC hNotify,
 848                 [ in ] HCLUSTER_RPC hCluster,
 849                 [ in ] uint32 dwFilter,
 850                 [ in ] uint32 dwNotifyKey,
 851                 [ out ] WERROR *rpc_status
 852         );
 853
 854         /*****************/
 855         /* Function 0x3A */
 856
 857         WERROR
 858         clusapi_AddNotifyNode(
 859                 [ in ] HNOTIFY_RPC hNotify,
 860                 [ in ] HNODE_RPC hNode,
 861                 [ in ] uint32 dwFilter,
 862                 [ in ] uint32 dwNotifyKey,
 863                 [ out ] uint32 *dwStateSequence,
 864                 [ out ] WERROR *rpc_status
 865         );
 866
 867         /*****************/
 868         /* Function 0x3B */
 869
 870         WERROR
 871         clusapi_AddNotifyGroup(
 872                 [ in ] HNOTIFY_RPC hNotify,
 873                 [ in ] HGROUP_RPC hGroup,
 874                 [ in ] uint32 dwFilter,
 875                 [ in ] uint32 dwNotifyKey,
 876                 [ out ] uint32 *dwStateSequence,
 877                 [ out ] WERROR *rpc_status
 878         );
 879
 880         /*****************/
 881         /* Function 0x3C */
 882
 883         WERROR
 884         clusapi_AddNotifyResource(
 885                 [ in ] HNOTIFY_RPC hNotify,
 886                 [ in ] HRES_RPC hResource,
 887                 [ in ] uint32 dwFilter,
 888                 [ in ] uint32 dwNotifyKey,
 889                 [ out ] uint32 *dwStateSequence,
 890                 [ out ] WERROR *rpc_status
 891         );
 892
 893         /*****************/
 894         /* Function 0x3D */
 895
 896         WERROR
 897         clusapi_AddNotifyKey(
 898                 [ in ] HNOTIFY_RPC hNotify,
 899                 [ in ] HKEY_RPC hKey,
 900                 [ in ] uint32 dwNotifyKey,
 901                 [ in ] uint32 Filter,
 902                 [ in ] boolean8 WatchSubTree,
 903                 [ out ] WERROR *rpc_status
 904         );
 905
 906         /*****************/
 907         /* Function 0x3E */
 908
 909         WERROR
 910         clusapi_ReAddNotifyNode(
 911                 [ in ] HNOTIFY_RPC hNotify,
 912                 [ in ] HNODE_RPC hNode,
 913                 [ in ] uint32 dwFilter,
 914                 [ in ] uint32 dwNotifyKey,
 915                 [ in ] uint32 StateSequence,
 916                 [ out ] WERROR *rpc_status
 917         );
 918
 919         /*****************/
 920         /* Function 0x3F */
 921
 922         WERROR
 923         clusapi_ReAddNotifyGroup(
 924                 [ in ] HNOTIFY_RPC hNotify,
 925                 [ in ] HGROUP_RPC hGroup,
 926                 [ in ] uint32 dwFilter,
 927                 [ in ] uint32 dwNotifyKey,
 928                 [ in ] uint32 StateSequence,
 929                 [ out ] WERROR *rpc_status
 930         );
 931
 932         /*****************/
 933         /* Function 0x40 */
 934
 935         WERROR
 936         clusapi_ReAddNotifyResource(
 937                 [ in ] HNOTIFY_RPC hNotify,
 938                 [ in ] HRES_RPC hResource,
 939                 [ in ] uint32 dwFilter,
 940                 [ in ] uint32 dwNotifyKey,
 941                 [ in ] uint32 StateSequence,
 942                 [ out ] WERROR *rpc_status
 943         );
 944
 945         /*****************/
 946         /* Function 0x41 */
 947
 948         WERROR
 949         clusapi_GetNotify(
 950                 [ in ] HNOTIFY_RPC hNotify,
 951                 [ out ] uint32 *dwNotifyKey,
 952                 [ out ] uint32 *dwFilter,
 953                 [ out ] uint32 *dwStateSequence,
 954                 [ out, string ] [charset(UTF16)] uint16 **Name,
 955                 [ out ] WERROR *rpc_status
 956         );
 957
 958         /*****************/
 959         /* Function 0x42 */
 960 #if 0
 961         HNODE_RPC
 962         clusapi_OpenNode(
 963                 [ in, string ] [charset(UTF16)] uint16 *lpszNodeName,
 964                 [ out ] WERROR *Status,
 965                 [ out ] WERROR *rpc_status
 966         );
 967 #else
 968         void
 969         clusapi_OpenNode(
 970                 [ in, string ] [charset(UTF16)] uint16 *lpszNodeName,
 971                 [ out ] WERROR *Status,
 972                 [ out ] WERROR *rpc_status,
 973                 [ out ] HNODE_RPC *hNode
 974         );
 975 #endif
 976         /*****************/
 977         /* Function 0x43 */
 978
 979         WERROR
 980         clusapi_CloseNode(
 981                 [ in, out ] HNODE_RPC *Node
 982         );
 983
 984         /*****************/
 985         /* Function 0x44 */
 986
 987         typedef [v1_enum] enum {
 988                 ClusterNodeUp           = 0x00000000,
 989                 ClusterNodeDown         = 0x00000001,
 990                 ClusterNodePaused       = 0x00000002,
 991                 ClusterNodeJoining      = 0x00000003,
 992                 ClusterNodeStateUnknown = 0xFFFFFFFF
 993         } clusapi_ClusterNodeState;
 994
 995         WERROR
 996         clusapi_GetNodeState(
 997                 [ in ] HNODE_RPC hNode,
 998                 [ out ] clusapi_ClusterNodeState *State,
 999                 [ out ] WERROR *rpc_status
1000         );
1001
1002         /*****************/
1003         /* Function 0x45 */
1004
1005         WERROR
1006         clusapi_PauseNode(
1007                 [ in ] HNODE_RPC hNode,
1008                 [ out ] WERROR *rpc_status
1009         );
1010
1011         /*****************/
1012         /* Function 0x46 */
1013
1014         WERROR
1015         clusapi_ResumeNode(
1016                 [ in ] HNODE_RPC hNode,
1017                 [ out ] WERROR *rpc_status
1018         );
1019
1020         /*****************/
1021         /* Function 0x47 */
1022
1023         WERROR
1024         clusapi_EvictNode(
1025                 [ in ] HNODE_RPC hNode,
1026                 [ out ] WERROR *rpc_status
1027         );
1028
1029         /*****************/
1030         /* Function 0x48 */
1031
1032         WERROR
1033         clusapi_NodeResourceControl(
1034                 [ in ] HRES_RPC hResource,
1035                 [ in ] HNODE_RPC hNode,
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 0x49 */
1049
1050         WERROR
1051         clusapi_ResourceControl(
1052                 [ in ] HRES_RPC hResource,
1053                 [ in ] uint32 dwControlCode,
1054                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1055                 [ in ] uint32 nInBufferSize,
1056                 [ out, size_is(nOutBufferSize),
1057                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1058                 [ in ] uint32 nOutBufferSize,
1059                 [ out ] uint32 *lpBytesReturned,
1060                 [ out ] uint32 *lpcbRequired,
1061                 [ out ] WERROR *rpc_status
1062         );
1063
1064         /*****************/
1065         /* Function 0x4A */
1066
1067         WERROR
1068         clusapi_NodeResourceTypeControl(
1069                 [ in ] HCLUSTER_RPC hCluster,
1070                 [ in, string ] [charset(UTF16)] uint16 *lpszResourceTypeName,
1071                 [ in ] HNODE_RPC hNode,
1072                 [ in ] uint32 dwControlCode,
1073                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1074                 [ in ] uint32 nInBufferSize,
1075                 [ out, size_is(nOutBufferSize),
1076                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1077                 [ in ] uint32 nOutBufferSize,
1078                 [ out ] uint32 *lpBytesReturned,
1079                 [ out ] uint32 *lpcbRequired,
1080                 [ out ] WERROR *rpc_status
1081         );
1082
1083         /*****************/
1084         /* Function 0x4B */
1085
1086         typedef [v1_enum] enum {
1087                 CLUSCTL_RESOURCE_TYPE_UNKNOWN                           = 0x02000000,
1088                 CLUSCTL_RESOURCE_TYPE_GET_CHARACTERISTICS               = 0x02000005,
1089                 CLUSCTL_RESOURCE_TYPE_GET_FLAGS                         = 0x02000009,
1090                 CLUSCTL_RESOURCE_TYPE_GET_CLASS_INFO                    = 0x0200000D,
1091                 CLUSCTL_RESOURCE_TYPE_GET_REQUIRED_DEPENDENCIES         = 0x02000011,
1092                 CLUSCTL_RESOURCE_TYPE_GET_ARB_TIMEOUT                   = 0x02000015,
1093                 CLUSCTL_RESOURCE_TYPE_ENUM_COMMON_PROPERTIES            = 0x02000051,
1094                 CLUSCTL_RESOURCE_TYPE_GET_RO_COMMON_PROPERTIES          = 0x02000055,
1095                 CLUSCTL_RESOURCE_TYPE_GET_COMMON_PROPERTIES             = 0x02000059,
1096                 CLUSCTL_RESOURCE_TYPE_SET_COMMON_PROPERTIES             = 0x0240005E,
1097                 CLUSCTL_RESOURCE_TYPE_VALIDATE_COMMON_PROPERTIES        = 0x02000061,
1098                 CLUSCTL_RESOURCE_TYPE_GET_COMMON_PROPERTY_FMTS          = 0x02000065,
1099                 CLUSCTL_RESOURCE_TYPE_GET_COMMON_RESOURCE_PROPERTY_FMTS = 0x02000069,
1100                 CLUSCTL_RESOURCE_TYPE_ENUM_PRIVATE_PROPERTIES           = 0x02000079,
1101                 CLUSCTL_RESOURCE_TYPE_GET_RO_PRIVATE_PROPERTIES         = 0x0200007D,
1102                 CLUSCTL_RESOURCE_TYPE_GET_PRIVATE_PROPERTIES            = 0x02000081,
1103                 CLUSCTL_RESOURCE_TYPE_SET_PRIVATE_PROPERTIES            = 0x02400086,
1104                 CLUSCTL_RESOURCE_TYPE_VALIDATE_PRIVATE_PROPERTIES       = 0x02000089,
1105                 CLUSCTL_RESOURCE_TYPE_GET_PRIVATE_PROPERTY_FMTS         = 0x0200008D,
1106                 CLUSCTL_RESOURCE_TYPE_GET_PRIVATE_RESOURCE_PROPERTY_FMTS= 0x02000091,
1107                 CLUSCTL_RESOURCE_TYPE_STORAGE_GET_AVAILABLE_DISKS       = 0x02000195,
1108                 CLUSCTL_RESOURCE_TYPE_NETNAME_VALIDATE_NETNAME          = 0x02000235,
1109                 CLUSCTL_RESOURCE_TYPE_VALIDATE_PATH                     = 0x02000231,
1110                 CLUSCTL_RESOURCE_TYPE_GEN_APP_VALIDATE_DIRECTORY        = 0x02000239,
1111                 CLUSCTL_RESOURCE_TYPE_STORAGE_GET_DRIVELETTERS          = 0x020001ED,
1112                 CLUSCTL_RESOURCE_TYPE_STORAGE_GET_AVAILABLE_DISKS_EX    = 0x020001F5,
1113                 CLUSCTL_RESOURCE_TYPE_STORAGE_REMAP_DRIVELETTER         = 0x02000201,
1114                 CLUSCTL_RESOURCE_TYPE_STORAGE_GET_DISKID                = 0x02000205,
1115                 CLUSCTL_RESOURCE_TYPE_STORAGE_IS_CLUSTERABLE            = 0x02000209,
1116                 CLUSCTL_RESOURCE_TYPE_STORAGE_RELEASE_OWNERSHIP         = 0x0240020E,
1117                 CLUSCTL_RESOURCE_TYPE_STORAGE_IS_CSV_FILE               = 0x1000229,
1118                 CLUSCTL_RESOURCE_TYPE_CLOUD_WITNESS_VALIDATE_CREDENTIALS= 0x020020e1,
1119                 CLUSCTL_RESOURCE_TYPE_REPLICATION_GET_ELIGIBLE_LOGDISKS = 0x02002149,
1120                 CLUSCTL_RESOURCE_TYPE_REPLICATION_GET_ELIGIBLE_TARGET_DATADISKS = 0x0200214D,
1121                 CLUSCTL_RESOURCE_TYPE_REPLICATION_GET_ELIGIBLE_SOURCE_DATADISKS = 0x02002151,
1122                 CLUSCTL_RESOURCE_TYPE_REPLICATION_GET_REPLICA_VOLUMES   = 0x02002159,
1123                 CLUSCTL_RESOURCE_TYPE_REPLICATION_GET_LOG_VOLUME        = 0x0200215D,
1124                 CLUSCTL_RESOURCE_TYPE_REPLICATION_GET_REPLICATED_DISKS  = 0x02002155,
1125                 CLUSCTL_RESOURCE_TYPE_REPLICATION_GET_RESOURCE_GROUP    = 0x02002161
1126         } clusapi_ResourceTypeControlCode;
1127
1128         WERROR
1129         clusapi_ResourceTypeControl(
1130                 [ in ] HCLUSTER_RPC hCluster,
1131                 [ in, string ] [charset(UTF16)] uint16 *lpszResourceTypeName,
1132                 [ in ] clusapi_ResourceTypeControlCode dwControlCode,
1133                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1134                 [ in ] uint32 nInBufferSize,
1135                 [ out, size_is(nOutBufferSize),
1136                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1137                 [ in ] uint32 nOutBufferSize,
1138                 [ out ] uint32 *lpBytesReturned,
1139                 [ out ] uint32 *lpcbRequired,
1140                 [ out ] WERROR *rpc_status
1141         );
1142
1143         /*****************/
1144         /* Function 0x4C */
1145
1146         WERROR
1147         clusapi_NodeGroupControl(
1148                 [ in ] HGROUP_RPC hGroup,
1149                 [ in ] HNODE_RPC hNode,
1150                 [ in ] uint32 dwControlCode,
1151                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1152                 [ in ] uint32 nInBufferSize,
1153                 [ out, size_is(nOutBufferSize),
1154                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1155                 [ in ] uint32 nOutBufferSize,
1156                 [ out ] uint32 *lpBytesReturned,
1157                 [ out ] uint32 *lpcbRequired,
1158                 [ out ] WERROR *rpc_status
1159         );
1160
1161         /*****************/
1162         /* Function 0x4D */
1163
1164         typedef [v1_enum] enum {
1165                 CLUSCTL_GROUP_UNKNOWN                           = 0x03000000,
1166                 CLUSCTL_GROUP_GET_CHARACTERISTICS               = 0x03000005,
1167                 CLUSCTL_GROUP_GET_FLAGS                         = 0x03000009,
1168                 CLUSCTL_GROUP_GET_NAME                          = 0x03000029,
1169                 CLUSCTL_GROUP_GET_ID                            = 0x03000039,
1170                 CLUSCTL_GROUP_ENUM_COMMON_PROPERTIES            = 0x03000051,
1171                 CLUSCTL_GROUP_GET_RO_COMMON_PROPERTIES          = 0x03000055,
1172                 CLUSCTL_GROUP_GET_COMMON_PROPERTIES             = 0x03000059,
1173                 CLUSCTL_GROUP_SET_COMMON_PROPERTIES             = 0x0340005E,
1174                 CLUSCTL_GROUP_VALIDATE_COMMON_PROPERTIES        = 0x03000061,
1175                 CLUSCTL_GROUP_GET_COMMON_PROPERTY_FMTS          = 0x03000065,
1176                 CLUSCTL_GROUP_ENUM_PRIVATE_PROPERTIES           = 0x03000079,
1177                 CLUSCTL_GROUP_GET_RO_PRIVATE_PROPERTIES         = 0x0300007D,
1178                 CLUSCTL_GROUP_GET_PRIVATE_PROPERTIES            = 0x03000081,
1179                 CLUSCTL_GROUP_SET_PRIVATE_PROPERTIES            = 0x03400086,
1180                 CLUSCTL_GROUP_VALIDATE_PRIVATE_PROPERTIES       = 0x03000089
1181         } clusapi_GroupControlCode;
1182
1183         WERROR
1184         clusapi_GroupControl(
1185                 [ in ] HGROUP_RPC hGroup,
1186                 [ in ] clusapi_GroupControlCode dwControlCode,
1187                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1188                 [ in ] uint32 nInBufferSize,
1189                 [ out, size_is(nOutBufferSize),
1190                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1191                 [ in ] uint32 nOutBufferSize,
1192                 [ out ] uint32 *lpBytesReturned,
1193                 [ out ] uint32 *lpcbRequired,
1194                 [ out ] WERROR *rpc_status
1195         );
1196
1197         /*****************/
1198         /* Function 0x4E */
1199
1200         WERROR
1201         clusapi_NodeNodeControl(
1202                 [ in ] HNODE_RPC hNode,
1203                 [ in ] HNODE_RPC hHostNode,
1204                 [ in ] uint32 dwControlCode,
1205                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1206                 [ in ] uint32 nInBufferSize,
1207                 [ out, size_is(nOutBufferSize),
1208                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1209                 [ in ] uint32 nOutBufferSize,
1210                 [ out ] uint32 *lpBytesReturned,
1211                 [ out ] uint32 *lpcbRequired,
1212                 [ out ] WERROR *rpc_status
1213         );
1214
1215         /*****************/
1216         /* Function 0x4F */
1217
1218         typedef [v1_enum] enum {
1219                 CLUSCTL_NODE_UNKNOWN                            = 0x04000000,
1220                 CLUSCTL_NODE_GET_CHARACTERISTICS                = 0x04000005,
1221                 CLUSCTL_NODE_GET_FLAGS                          = 0x04000009,
1222                 CLUSCTL_NODE_GET_NAME                           = 0x04000029,
1223                 CLUSCTL_NODE_GET_ID                             = 0x04000039,
1224                 CLUSCTL_NODE_GET_CLUSTER_SERVICE_ACCOUNT_NAME   = 0x04000041,
1225                 CLUSCTL_NODE_ENUM_COMMON_PROPERTIES             = 0x04000051,
1226                 CLUSCTL_NODE_GET_RO_COMMON_PROPERTIES           = 0x04000055,
1227                 CLUSCTL_NODE_GET_COMMON_PROPERTIES              = 0x04000059,
1228                 CLUSCTL_NODE_SET_COMMON_PROPERTIES              = 0x0440005E,
1229                 CLUSCTL_NODE_VALIDATE_COMMON_PROPERTIES         = 0x04000061,
1230                 CLUSCTL_NODE_ENUM_PRIVATE_PROPERTIES            = 0x04000079,
1231                 CLUSCTL_NODE_GET_RO_PRIVATE_PROPERTIES          = 0x0400007D,
1232                 CLUSCTL_NODE_GET_PRIVATE_PROPERTIES             = 0x04000081,
1233                 CLUSCTL_NODE_SET_PRIVATE_PROPERTIES             = 0x04400086,
1234                 CLUSCTL_NODE_VALIDATE_PRIVATE_PROPERTIES        = 0x04000089
1235         } clusapi_NodeControlCode;
1236
1237         WERROR
1238         clusapi_NodeControl(
1239                 [ in ] HNODE_RPC hNode,
1240                 [ in ] clusapi_NodeControlCode dwControlCode,
1241                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1242                 [ in ] uint32 nInBufferSize,
1243                 [ out, size_is(nOutBufferSize),
1244                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1245                 [ in ] uint32 nOutBufferSize,
1246                 [ out ] uint32 *lpBytesReturned,
1247                 [ out ] uint32 *lpcbRequired,
1248                 [ out ] WERROR *rpc_status
1249         );
1250
1251         /*****************/
1252         /* Function 0x50 */
1253
1254         WERROR
1255         Opnum80NotUsedOnWire(void);
1256
1257         /*****************/
1258         /* Function 0x51 */
1259 #if 0
1260         HNETWORK_RPC
1261         clusapi_OpenNetwork(
1262                 [ in, string ] [charset(UTF16)] uint16 *lpszNetworkName,
1263                 [ out ] WERROR *Status,
1264                 [ out ] WERROR *rpc_status
1265         );
1266 #else
1267         void
1268         clusapi_OpenNetwork(
1269                 [ in, string ] [charset(UTF16)] uint16 *lpszNetworkName,
1270                 [ out ] WERROR *Status,
1271                 [ out ] WERROR *rpc_status,
1272                 [ out ] HNETWORK_RPC *hNetwork
1273         );
1274 #endif
1275         /*****************/
1276         /* Function 0x52 */
1277
1278         WERROR
1279         clusapi_CloseNetwork(
1280                 [ in, out ] HNETWORK_RPC *Network
1281         );
1282
1283         /*****************/
1284         /* Function 0x53 */
1285
1286         typedef [v1_enum] enum {
1287                 ClusterNetworkUnavailable       = 0x00000000,
1288                 ClusterNetworkDown              = 0x00000001,
1289                 ClusterNetworkPartitioned       = 0x00000002,
1290                 ClusterNetworkUp                = 0x00000003,
1291                 ClusterNetworkStateUnknown      = 0xFFFFFFFF
1292         } clusapi_ClusterNetworkState;
1293
1294         WERROR
1295         clusapi_GetNetworkState(
1296                 [ in ] HNETWORK_RPC hNetwork,
1297                 [ out ] clusapi_ClusterNetworkState *State,
1298                 [ out ] WERROR *rpc_status
1299         );
1300
1301         /*****************/
1302         /* Function 0x54 */
1303
1304         WERROR
1305         clusapi_SetNetworkName(
1306                 [ in ] HNETWORK_RPC hNetwork,
1307                 [ in, string ] [charset(UTF16)] uint16 *lpszNetworkName,
1308                 [ out ] WERROR *rpc_status
1309         );
1310
1311         /*****************/
1312         /* Function 0x55 */
1313
1314         WERROR
1315         clusapi_CreateNetworkEnum(
1316                 [ in ] HNETWORK_RPC hNetwork,
1317                 [ in ] uint32 dwType,
1318                 [ out ] ENUM_LIST **ReturnEnum,
1319                 [ out ] WERROR *rpc_status
1320         );
1321
1322         /*****************/
1323         /* Function 0x56 */
1324
1325         WERROR
1326         clusapi_GetNetworkId(
1327                 [ in ] HNETWORK_RPC hNetwork,
1328                 [ out, string ] [charset(UTF16)] uint16 **pGuid,
1329                 [ out ] WERROR *rpc_status
1330         );
1331
1332         /*****************/
1333         /* Function 0x57 */
1334
1335         WERROR
1336         clusapi_SetNetworkPriorityOrder(
1337                 [ in, range(0, 1000)] uint32 NetworkCount,
1338                 [ in, string, size_is(NetworkCount) ] [charset(UTF16)] uint16 NetworkIdList[*],
1339                 [ out ] WERROR *rpc_status
1340         );
1341
1342         /*****************/
1343         /* Function 0x58 */
1344
1345         WERROR
1346         clusapi_NodeNetworkControl(
1347                 [ in ] HNETWORK_RPC hNetwork,
1348                 [ in ] HNODE_RPC hNode,
1349                 [ in ] uint32 dwControlCode,
1350                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1351                 [ in ] uint32 nInBufferSize,
1352                 [ out, size_is(nOutBufferSize),
1353                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1354                 [ in ] uint32 nOutBufferSize,
1355                 [ out ] uint32 *lpBytesReturned,
1356                 [ out ] uint32 *lpcbRequired,
1357                 [ out ] WERROR *rpc_status
1358         );
1359
1360         /*****************/
1361         /* Function 0x59 */
1362
1363         WERROR
1364         clusapi_NetworkControl(
1365                 [ in ] HNETWORK_RPC hNetwork,
1366                 [ in ] uint32 dwControlCode,
1367                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1368                 [ in ] uint32 nInBufferSize,
1369                 [ out, size_is(nOutBufferSize),
1370                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1371                 [ in ] uint32 nOutBufferSize,
1372                 [ out ] uint32 *lpBytesReturned,
1373                 [ out ] uint32 *lpcbRequired,
1374                 [ out ] WERROR *rpc_status
1375         );
1376
1377         /*****************/
1378         /* Function 0x5A */
1379
1380         WERROR
1381         clusapi_AddNotifyNetwork(
1382                 [ in ] HNOTIFY_RPC hNotify,
1383                 [ in ] HNETWORK_RPC hNetwork,
1384                 [ in ] uint32 dwFilter,
1385                 [ in ] uint32 dwNotifyKey,
1386                 [ out ] uint32 *dwStateSequence,
1387                 [ out ] WERROR *rpc_status
1388         );
1389
1390         /*****************/
1391         /* Function 0x5B */
1392
1393         WERROR
1394         clusapi_ReAddNotifyNetwork(
1395                 [ in ] HNOTIFY_RPC hNotify,
1396                 [ in ] HNETWORK_RPC hNetwork,
1397                 [ in ] uint32 dwFilter,
1398                 [ in ] uint32 dwNotifyKey,
1399                 [ in ] uint32 StateSequence,
1400                 [ out ] WERROR *rpc_status
1401         );
1402
1403         /*****************/
1404         /* Function 0x5C */
1405 #if 0
1406         HNETINTERFACE_RPC
1407         clusapi_OpenNetInterface(
1408                 [ in, string ] [charset(UTF16)] uint16 *lpszNetInterfaceName,
1409                 [ out ] WERROR *Status,
1410                 [ out ] WERROR *rpc_status
1411         );
1412 #else
1413         void
1414         clusapi_OpenNetInterface(
1415                 [ in, string ] [charset(UTF16)] uint16 *lpszNetInterfaceName,
1416                 [ out ] WERROR *Status,
1417                 [ out ] WERROR *rpc_status,
1418                 [ out ] HNETINTERFACE_RPC *hNetInterface
1419         );
1420 #endif
1421         /*****************/
1422         /* Function 0x5D */
1423
1424         WERROR
1425         clusapi_CloseNetInterface(
1426                 [ in, out ] HNETINTERFACE_RPC *NetInterface
1427         );
1428
1429         /*****************/
1430         /* Function 0x5E */
1431
1432         typedef [v1_enum] enum {
1433                 ClusterNetInterfaceFailed       = 0x00000000,
1434                 ClusterNetInterfaceUnreachable  = 0x00000001,
1435                 ClusterNetInterfaceUnavailable  = 0x00000002,
1436                 ClusterNetInterfaceUp           = 0x00000003,
1437                 ClusterNetInterfaceStateUnknown = 0xFFFFFFFF
1438         } clusapi_ClusterNetInterfaceState;
1439
1440         WERROR
1441         clusapi_GetNetInterfaceState(
1442                 [ in ] HNETINTERFACE_RPC hNetInterface,
1443                 [ out ] clusapi_ClusterNetInterfaceState *State,
1444                 [ out ] WERROR *rpc_status
1445         );
1446
1447         /*****************/
1448         /* Function 0x5F */
1449
1450         WERROR
1451         clusapi_GetNetInterface(
1452                 [ in, string ] [charset(UTF16)] uint16 *lpszNodeName,
1453                 [ in, string ] [charset(UTF16)] uint16 *lpszNetworkName,
1454                 [ out, string ] [charset(UTF16)] uint16 **lppszInterfaceName,
1455                 [ out ] WERROR *rpc_status
1456         );
1457
1458         /*****************/
1459         /* Function 0x60 */
1460
1461         WERROR
1462         clusapi_GetNetInterfaceId(
1463                 [ in ] HNETINTERFACE_RPC hNetInterface,
1464                 [ out, string ] [charset(UTF16)] uint16 **pGuid,
1465                 [ out ] WERROR *rpc_status
1466         );
1467
1468         /*****************/
1469         /* Function 0x61 */
1470
1471         WERROR
1472         clusapi_NodeNetInterfaceControl(
1473                 [ in ] HNETINTERFACE_RPC hNetInterface,
1474                 [ in ] HNODE_RPC hNode,
1475                 [ in ] uint32 dwControlCode,
1476                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1477                 [ in ] uint32 nInBufferSize,
1478                 [ out, size_is(nOutBufferSize),
1479                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1480                 [ in ] uint32 nOutBufferSize,
1481                 [ out ] uint32 *lpBytesReturned,
1482                 [ out ] uint32 *lpcbRequired,
1483                 [ out ] WERROR *rpc_status
1484         );
1485
1486         /*****************/
1487         /* Function 0x62 */
1488
1489         WERROR
1490         clusapi_NetInterfaceControl(
1491                 [ in ] HNETINTERFACE_RPC hNetInterface,
1492                 [ in ] uint32 dwControlCode,
1493                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1494                 [ in ] uint32 nInBufferSize,
1495                 [ out, size_is(nOutBufferSize),
1496                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1497                 [ in ] uint32 nOutBufferSize,
1498                 [ out ] uint32 *lpBytesReturned,
1499                 [ out ] uint32 *lpcbRequired,
1500                 [ out ] WERROR *rpc_status
1501         );
1502
1503         /*****************/
1504         /* Function 0x63 */
1505
1506         WERROR
1507         clusapi_AddNotifyNetInterface(
1508                 [ in ] HNOTIFY_RPC hNotify,
1509                 [ in ] HNETINTERFACE_RPC hNetInterface,
1510                 [ in ] uint32 dwFilter,
1511                 [ in ] uint32 dwNotifyKey,
1512                 [ out ] uint32 *dwStateSequence,
1513                 [ out ] WERROR *rpc_status
1514         );
1515
1516         /*****************/
1517         /* Function 0x64 */
1518
1519         WERROR
1520         clusapi_ReAddNotifyNetInterface(
1521                 [ in ] HNOTIFY_RPC hNotify,
1522                 [ in ] HNETINTERFACE_RPC hNetInterface,
1523                 [ in ] uint32 dwFilter,
1524                 [ in ] uint32 dwNotifyKey,
1525                 [ in ] uint32 StateSequence,
1526                 [ out ] WERROR *rpc_status
1527         );
1528
1529         /*****************/
1530         /* Function 0x65 */
1531
1532         WERROR
1533         clusapi_CreateNodeEnum(
1534                 [ in ] HNODE_RPC hNode,
1535                 [ in ] uint32 dwType,
1536                 [ out ] ENUM_LIST **ReturnEnum,
1537                 [ out ] WERROR *rpc_status
1538         );
1539
1540         /*****************/
1541         /* Function 0x66 */
1542
1543         WERROR
1544         clusapi_GetClusterVersion2(
1545                 [ out ] uint16 *lpwMajorVersion,
1546                 [ out ] uint16 *lpwMinorVersion,
1547                 [ out ] uint16 *lpwBuildNumber,
1548                 [ out, string ] [charset(UTF16)] uint16 **lpszVendorId,
1549                 [ out, string ] [charset(UTF16)] uint16 **lpszCSDVersion,
1550                 [ out ] CLUSTER_OPERATIONAL_VERSION_INFO **ppClusterOpVerInfo,
1551                 [ out ] WERROR *rpc_status
1552         );
1553
1554         /*****************/
1555         /* Function 0x67 */
1556
1557         WERROR
1558         clusapi_CreateResTypeEnum(
1559                 [ in, string ] [charset(UTF16)] uint16 *lpszTypeName,
1560                 [ in ] uint32 dwType,
1561                 [ out ] ENUM_LIST **ReturnEnum,
1562                 [ out ] WERROR *rpc_status
1563         );
1564
1565         /*****************/
1566         /* Function 0x68 */
1567
1568         WERROR
1569         clusapi_BackupClusterDatabase(
1570                 [ in, string ] [charset(UTF16)] uint16 *lpszPathName,
1571                 [ out ] WERROR *rpc_status
1572         );
1573
1574         /*****************/
1575         /* Function 0x69 */
1576
1577         WERROR
1578         clusapi_NodeClusterControl(
1579                 [ in ] HCLUSTER_RPC hCluster,
1580                 [ in ] HNODE_RPC hHostNode,
1581                 [ in ] uint32 dwControlCode,
1582                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1583                 [ in ] uint32 nInBufferSize,
1584                 [ out, size_is(nOutBufferSize),
1585                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1586                 [ in ] uint32 nOutBufferSize,
1587                 [ out ] uint32 *lpBytesReturned,
1588                 [ out ] uint32 *lpcbRequired,
1589                 [ out ] WERROR *rpc_status
1590         );
1591
1592         /*****************/
1593         /* Function 0x6A */
1594
1595         typedef [v1_enum] enum {
1596                 CLUSCTL_CLUSTER_UNKNOWN                         = 0x07000000,
1597                 CLUSCTL_CLUSTER_GET_FQDN                        = 0x0700003D,
1598                 CLUSCTL_CLUSTER_CHECK_VOTER_EVICT               = 0x07000045,
1599                 CLUSCTL_CLUSTER_CHECK_VOTER_DOWN                = 0x07000049,
1600                 CLUSCTL_CLUSTER_SHUTDOWN                        = 0x0700004D,
1601                 CLUSCTL_CLUSTER_ENUM_COMMON_PROPERTIES          = 0x07000051,
1602                 CLUSCTL_CLUSTER_GET_RO_COMMON_PROPERTIES        = 0x07000055,
1603                 CLUSCTL_CLUSTER_GET_COMMON_PROPERTIES           = 0x07000059,
1604                 CLUSCTL_CLUSTER_SET_COMMON_PROPERTIES           = 0x0740005E,
1605                 CLUSCTL_CLUSTER_VALIDATE_COMMON_PROPERTIES      = 0x07000061,
1606                 CLUSCTL_CLUSTER_GET_COMMON_PROPERTY_FMTS        = 0x07000065,
1607                 CLUSCTL_CLUSTER_ENUM_PRIVATE_PROPERTIES         = 0x07000079,
1608                 CLUSCTL_CLUSTER_GET_RO_PRIVATE_PROPERTIES       = 0x0700007D,
1609                 CLUSCTL_CLUSTER_GET_PRIVATE_PROPERTIES          = 0x07000081,
1610                 CLUSCTL_CLUSTER_SET_PRIVATE_PROPERTIES          = 0x07400086,
1611                 CLUSCTL_CLUSTER_VALIDATE_PRIVATE_PROPERTIES     = 0x07000089,
1612                 CLUSCTL_CLUSTER_GET_SHARED_VOLUME_ID            = 0x07000291,
1613                 CLUSCTL_CLUSTER_UPGRADE_CLUSTER_VERSION         = 0x074000ce,
1614                 CLUSCTL_CLUSTER_CLEAR_UPGRADE_IN_PROGRESS       = 0x074000d2,
1615                 CLUSCTL_CLUSTER_IS_READY_FOR_UPGRADE            = 0x070000d5
1616         } clusapi_ClusterControlCode;
1617
1618         typedef [v1_enum] enum {
1619                 CLUSPROP_SYNTAX_ENDMARK = 0x00000000,
1620                 CLUSPROP_SYNTAX_NAME = 0x00040003,
1621                 CLUSPROP_SYNTAX_RESCLASS = 0x00020002,
1622                 CLUSPROP_SYNTAX_LIST_VALUE_SZ = 0x00010003,
1623                 CLUSPROP_SYNTAX_LIST_VALUE_EXPAND_SZ = 0x00010004,
1624                 CLUSPROP_SYNTAX_LIST_VALUE_DWORD = 0x00010002,
1625                 CLUSPROP_SYNTAX_LIST_VALUE_BINARY = 0x00010001,
1626                 CLUSPROP_SYNTAX_LIST_VALUE_MULTI_SZ = 0x00010005,
1627                 CLUSPROP_SYNTAX_LIST_VALUE_LONG = 0x00010007,
1628                 CLUSPROP_SYNTAX_LIST_VALUE_EXPANDED_SZ = 0x00010008,
1629                 CLUSPROP_SYNTAX_LIST_VALUE_SECURITY_DESCRIPTOR = 0x00010009,
1630                 CLUSPROP_SYNTAX_LIST_VALUE_LARGE_INTEGER = 0x0001000a,
1631                 CLUSPROP_SYNTAX_LIST_VALUE_ULARGE_INTEGER = 0x00010006,
1632                 CLUSPROP_SYNTAX_LIST_VALUE_WORD = 0x0001000b,
1633                 CLUSPROP_SYNTAX_LIST_VALUE_FILETIME = 0x0001000c,
1634                 CLUSPROP_SYNTAX_DISK_SIGNATURE = 0x00050002,
1635                 CLUSPROP_SYNTAX_SCSI_ADDRESS = 0x00060002,
1636                 CLUSPROP_SYNTAX_DISK_NUMBER = 0x00070002,
1637                 CLUSPROP_SYNTAX_PARTITION_INFO = 0x00080001,
1638                 CLUSPROP_SYNTAX_DISK_SERIALNUMBER = 0x000a0003,
1639                 CLUSPROP_SYNTAX_DISK_GUID = 0x000b0003,
1640                 CLUSPROP_SYNTAX_DISK_SIZE = 0x000c0006,
1641                 CLUSPROP_SYNTAX_PARTITION_INFO_EX = 0x000d0001
1642         } CLUSTER_PROPERTY_SYNTAX;
1643
1644         typedef struct {
1645                 CLUSTER_PROPERTY_SYNTAX Syntax;
1646                 uint32 Size;
1647                 [subcontext(0),subcontext_size(Size)] [flag(NDR_REMAINING)] DATA_BLOB Buffer;
1648                 [flag(NDR_ALIGN4)] DATA_BLOB Padding;
1649         } clusapi_propertyValues;
1650
1651         typedef struct {
1652                 [value(CLUSPROP_SYNTAX_NAME)] CLUSTER_PROPERTY_SYNTAX syntax_name;
1653                 [value(strlen_m_term(buffer)*2)] uint32 size;
1654                 nstring buffer;
1655                 [flag(NDR_ALIGN2)] DATA_BLOB padding;
1656                 clusapi_propertyValues PropertyValues;
1657                 [value(CLUSPROP_SYNTAX_ENDMARK)] CLUSTER_PROPERTY_SYNTAX end_mark;
1658         } clusapi_propertyValue;
1659
1660         typedef [public] struct {
1661                 uint32 propertyCount;
1662                 clusapi_propertyValue propertyValues[propertyCount];
1663                 [value(CLUSPROP_SYNTAX_ENDMARK)] CLUSTER_PROPERTY_SYNTAX end_mark;
1664         } clusapi_PROPERTY_LIST;
1665
1666         WERROR
1667         clusapi_ClusterControl(
1668                 [ in ] HCLUSTER_RPC hCluster,
1669                 [ in ] clusapi_ClusterControlCode dwControlCode,
1670                 [ in, unique, size_is(nInBufferSize) ] uint8 *lpInBuffer,
1671                 [ in ] uint32 nInBufferSize,
1672                 [ out, size_is(nOutBufferSize),
1673                          length_is (*lpBytesReturned)] uint8 *lpOutBuffer,
1674                 [ in ] uint32 nOutBufferSize,
1675                 [ out ] uint32 *lpBytesReturned,
1676                 [ out ] uint32 *lpcbRequired,
1677                 [ out ] WERROR *rpc_status
1678         );
1679
1680         /*****************/
1681         /* Function 0x6B */
1682
1683         WERROR
1684         clusapi_UnblockGetNotifyCall(
1685                 [ in ] HNOTIFY_RPC hNotify
1686         );
1687
1688         /*****************/
1689         /* Function 0x6C */
1690
1691         WERROR
1692         clusapi_SetServiceAccountPassword(
1693                 [ in, string ] [charset(UTF16)] uint16 *lpszNewPassword,
1694                 [ in ]  IDL_CLUSTER_SET_PASSWORD_FLAGS dwFlags,
1695                 [ out, size_is(ReturnStatusBufferSize), length_is(*SizeReturned) ]
1696                          IDL_CLUSTER_SET_PASSWORD_STATUS ReturnStatusBufferPtr[*],
1697                 [ in, range(0, (64 * 1024)) ] uint32 ReturnStatusBufferSize,
1698                 [ out ] uint32 *SizeReturned,
1699                 [ out ] uint32 *ExpectedBufferSize
1700         );
1701
1702         /*****************/
1703         /* Function 0x6D */
1704
1705         WERROR
1706         clusapi_SetResourceDependencyExpression(
1707                 [ in ] HRES_RPC hResource,
1708                 [ in, string, unique ] [charset(UTF16)] uint16 *lpszDependencyExpression,
1709                 [ out ] WERROR *rpc_status
1710         );
1711
1712         /*****************/
1713         /* Function 0x6E */
1714
1715         WERROR
1716         clusapi_GetResourceDependencyExpression(
1717                 [ in ] HRES_RPC hResource,
1718                 [ out, string ] [charset(UTF16)] uint16 **lpszDependencyExpression,
1719                 [ out ] WERROR *rpc_status
1720         );
1721
1722         /*****************/
1723         /* Function 0x6F */
1724
1725         WERROR
1726         Opnum111NotUsedOnWire(void);
1727
1728         /*****************/
1729         /* Function 0x70 */
1730
1731         WERROR
1732         clusapi_GetResourceNetworkName(
1733                 [ in ] HRES_RPC hResource,
1734                 [ out, string ] [charset(UTF16)] uint16 **lpszName,
1735                 [ out ] WERROR *rpc_status
1736         );
1737
1738         /*****************/
1739         /* Function 0x71 */
1740
1741         WERROR
1742         clusapi_ExecuteBatch(
1743                 [ in ] HKEY_RPC hKey,
1744                 [ in ] uint32 cbData,
1745                 [ in, size_is(cbData)] uint8 *lpData,
1746                 [ out ] int *pdwFailedCommand,
1747                 [ out ] WERROR *rpc_status
1748         );
1749
1750         /*****************/
1751         /* Function 0x72 */
1752
1753         WERROR
1754         clusapi_CreateBatchPort(
1755                 [ in ] HKEY_RPC hKey,
1756                 [ out ] HBATCH_PORT_RPC *phBatchPort,
1757                 [ out ] WERROR *rpc_status
1758         );
1759
1760         /*****************/
1761         /* Function 0x73 */
1762
1763         WERROR
1764         clusapi_GetBatchNotification(
1765                  [ in ] HBATCH_PORT_RPC hBatchNotify,
1766                  [ out ] uint32 *cbData,
1767                  [ out, size_is(,*cbData) ] uint8 ** lpData
1768         );
1769
1770         /*****************/
1771         /* Function 0x74 */
1772
1773         WERROR
1774         clusapi_CloseBatchPort(
1775                  [ in, out ] HBATCH_PORT_RPC *phBatchPort
1776         );
1777
1778         /*****************/
1779         /* Function 0x75 */
1780
1781         typedef [bitmap32bit] bitmap {
1782                 CLUSAPI_READ_ACCESS             = 0x00000001,
1783                 CLUSAPI_CHANGE_ACCESS           = 0x00000002,
1784                 CLUSAPI_GENERIC_READ            = 0x80000000,
1785                 CLUSAPI_GENERIC_WRITE           = 0x40000000,
1786                 CLUSAPI_GENERIC_EXECUTE         = 0x20000000,
1787                 CLUSAPI_GENERIC_ALL             = 0x10000000,
1788                 CLUSAPI_MAXIMUM_ALLOWED         = 0x02000000
1789         } clusapi_DesiredAccessMask;
1790
1791 #if 0
1792         HCLUSTER_RPC
1793         clusapi_OpenClusterEx(
1794                 [ in ] clusapi_DesiredAccessMask dwDesiredAccess,
1795                 [ out ] uint32 *lpdwGrantedAccess,
1796                 [ out ] WERROR *Status
1797         );
1798 #else
1799         void
1800         clusapi_OpenClusterEx(
1801                 [ in ] clusapi_DesiredAccessMask dwDesiredAccess,
1802                 [ out ] uint32 *lpdwGrantedAccess,
1803                 [ out ] WERROR *Status,
1804                 [ out ] HCLUSTER_RPC *hCluster
1805         );
1806 #endif
1807
1808         /*****************/
1809         /* Function 0x76 */
1810 #if 0
1811         HNODE_RPC
1812         clusapi_OpenNodeEx(
1813                 [ in, string ] [charset(UTF16)] uint16 *lpszNodeName,
1814                 [ in ] clusapi_DesiredAccessMask dwDesiredAccess,
1815                 [ out ] uint32 *lpdwGrantedAccess,
1816                 [ out ] WERROR *Status,
1817                 [ out ] WERROR *rpc_status
1818         );
1819 #else
1820         void
1821         clusapi_OpenNodeEx(
1822                 [ in, string ] [charset(UTF16)] uint16 *lpszNodeName,
1823                 [ in ] clusapi_DesiredAccessMask dwDesiredAccess,
1824                 [ out ] uint32 *lpdwGrantedAccess,
1825                 [ out ] WERROR *Status,
1826                 [ out ] WERROR *rpc_status,
1827                 [ out ] HNODE_RPC *hNode
1828         );
1829 #endif
1830         /*****************/
1831         /* Function 0x77 */
1832 #if 0
1833         HGROUP_RPC
1834         clusapi_OpenGroupEx(
1835                 [ in, string ] [charset(UTF16)] uint16 *lpszGroupName,
1836                 [ in ] clusapi_DesiredAccessMask dwDesiredAccess,
1837                 [ out ] uint32 *lpdwGrantedAccess,
1838                 [ out ] WERROR *Status,
1839                 [ out ] WERROR *rpc_status
1840         );
1841 #else
1842         void
1843         clusapi_OpenGroupEx(
1844                 [ in, string ] [charset(UTF16)] uint16 *lpszGroupName,
1845                 [ in ] clusapi_DesiredAccessMask dwDesiredAccess,
1846                 [ out ] uint32 *lpdwGrantedAccess,
1847                 [ out ] WERROR *Status,
1848                 [ out ] WERROR *rpc_status,
1849                 [ out ] HGROUP_RPC *hGroup
1850         );
1851 #endif
1852         /*****************/
1853         /* Function 0x78 */
1854 #if 0
1855         HRES_RPC
1856         clusapi_OpenResourceEx(
1857                 [ in, string ] [charset(UTF16)] uint16 *lpszResourceName,
1858                 [ in ] clusapi_DesiredAccessMask dwDesiredAccess,
1859                 [ out ] uint32 *lpdwGrantedAccess,
1860                 [ out ] WERROR *Status,
1861                 [ out ] WERROR *rpc_status
1862         );
1863 #else
1864         void
1865         clusapi_OpenResourceEx(
1866                 [ in, string ] [charset(UTF16)] uint16 *lpszResourceName,
1867                 [ in ] clusapi_DesiredAccessMask dwDesiredAccess,
1868                 [ out ] uint32 *lpdwGrantedAccess,
1869                 [ out ] WERROR *Status,
1870                 [ out ] WERROR *rpc_status,
1871                 [ out ] HRES_RPC *hResource
1872         );
1873 #endif
1874         /*****************/
1875         /* Function 0x79 */
1876 #if 0
1877         HNETWORK_RPC
1878         clusapi_OpenNetworkEx(
1879                 [ in, string ] [charset(UTF16)] uint16 *lpszNetworkName,
1880                 [ in ] clusapi_DesiredAccessMask dwDesiredAccess,
1881                 [ out ] uint32 *lpdwGrantedAccess,
1882                 [ out ] WERROR *Status,
1883                 [ out ] WERROR *rpc_status
1884         );
1885 #else
1886         void
1887         clusapi_OpenNetworkEx(
1888                 [ in, string ] [charset(UTF16)] uint16 *lpszNetworkName,
1889                 [ in ] clusapi_DesiredAccessMask dwDesiredAccess,
1890                 [ out ] uint32 *lpdwGrantedAccess,
1891                 [ out ] WERROR *Status,
1892                 [ out ] WERROR *rpc_status,
1893                 [ out ] HNETWORK_RPC *hNetwork
1894         );
1895 #endif
1896         /*****************/
1897         /* Function 0x7A */
1898 #if 0
1899         HNETINTERFACE_RPC
1900         clusapi_OpenNetInterfaceEx(
1901                 [ in, string ] [charset(UTF16)] uint16 *lpszNetInterfaceName,
1902                 [ in ] clusapi_DesiredAccessMask dwDesiredAccess,
1903                 [ out ] uint32 *lpdwGrantedAccess,
1904                 [ out ] WERROR *Status,
1905                 [ out ] WERROR *rpc_status
1906         );
1907 #else
1908         void
1909         clusapi_OpenNetInterfaceEx(
1910                 [ in, string ] [charset(UTF16)] uint16 *lpszNetInterfaceName,
1911                 [ in ] clusapi_DesiredAccessMask dwDesiredAccess,
1912                 [ out ] uint32 *lpdwGrantedAccess,
1913                 [ out ] WERROR *Status,
1914                 [ out ] WERROR *rpc_status,
1915                 [ out ] HNETINTERFACE_RPC *hNetInterface
1916         );
1917 #endif
1918         /*****************/
1919         /* Function 0x7B */
1920
1921         WERROR
1922         clusapi_ChangeCsvState(
1923                 [ in ] HRES_RPC hResource,
1924                 [ in ] uint32 dwState,
1925                 [ out ] WERROR *rpc_status
1926         );
1927
1928         /*****************/
1929         /* Function 0x7C */
1930
1931         WERROR
1932         clusapi_CreateNodeEnumEx(
1933                 [in] HNODE_RPC hNode,
1934                 [in] uint32 dwType,
1935                 [in] uint32 dwOptions,
1936                 [out] ENUM_LIST **ReturnIdEnum,
1937                 [out] ENUM_LIST **ReturnNameEnum,
1938                 [out] WERROR* rpc_status
1939         );
1940
1941         /*****************/
1942         /* Function 0x7D */
1943
1944         WERROR
1945         clusapi_CreateEnumEx(
1946                 [in] HCLUSTER_RPC hCluster,
1947                 [in] ClusterEnumType dwType,
1948                 [in] uint32 dwOptions,
1949                 [out] ENUM_LIST **ReturnIdEnum,
1950                 [out] ENUM_LIST **ReturnNameEnum,
1951                 [out] WERROR* rpc_status
1952         );
1953
1954         /*****************/
1955         /* Function 0x7E */
1956
1957         WERROR
1958         clusapi_PauseNodeEx(
1959                 [ in ] HNODE_RPC hNode,
1960                 [ in ] boolean8 bDrainNode,
1961                 [ in ] uint32 dwPauseFlags,
1962                 [ out ] WERROR *rpc_status
1963         );
1964
1965         /*****************/
1966         /* Function 0x7F */
1967
1968         WERROR
1969         clusapi_PauseNodeWithDrainTarget(
1970                 [ in ] HNODE_RPC hNode,
1971                 [ in ] uint32 dwPauseFlags,
1972                 [ in ] HNODE_RPC hNodeDrainTarget,
1973                 [ out ] WERROR *rpc_status
1974         );
1975
1976         /*****************/
1977         /* Function 0x80 */
1978
1979         WERROR
1980         clusapi_ResumeNodeEx(
1981                 [ in ] HNODE_RPC hNode,
1982                 [ in ] uint32 dwResumeFailbackType,
1983                 [ in ] uint32 dwResumeFlagsReserved,
1984                 [ out ] WERROR *rpc_status
1985         );
1986
1987         /*****************/
1988         /* Function 0x81 */
1989 #if 0
1990         HGROUP_RPC
1991         clusapi_CreateGroupEx(
1992                 [ in, string ] [charset(UTF16)] uint16 *lpszGroupName,
1993                 [ in, unique ] CLUSTER_CREATE_GROUP_INFO_RPC *pGroupInfo,
1994                 [ out ] WERROR *Status,
1995                 [ out ] WERROR *rpc_status
1996         );
1997 #else
1998         void
1999         clusapi_CreateGroupEx(
2000                 [ in, string ] [charset(UTF16)] uint16 *lpszGroupName,
2001                 [ in, unique ] CLUSTER_CREATE_GROUP_INFO_RPC *pGroupInfo,
2002                 [ out ] WERROR *Status,
2003                 [ out ] WERROR *rpc_status,
2004                 [ out ] HGROUP_RPC *hGroup
2005         );
2006 #endif
2007         /*****************/
2008         /* Function 0x82 */
2009
2010         WERROR
2011         clusapi_OnlineGroupEx(
2012                 [ in ] HGROUP_RPC hGroup,
2013                 [ in ] uint32     dwOnlineFlags,
2014                 [ in, size_is(cbInBufferSize) ] uint8* lpInBuffer,
2015                 [ in ] uint32     cbInBufferSize,
2016                 [ out ] WERROR *rpc_status
2017         );
2018
2019         /*****************/
2020         /* Function 0x83 */
2021
2022         WERROR
2023         clusapi_OfflineGroupEx(
2024                 [ in ] HGROUP_RPC hGroup,
2025                 [ in ] uint32     dwOfflineFlags,
2026                 [ in, size_is(cbInBufferSize) ] uint8* lpInBuffer,
2027                 [ in ] uint32     cbInBufferSize,
2028                 [ out ] WERROR *rpc_status
2029         );
2030
2031         /*****************/
2032         /* Function 0x84 */
2033
2034         WERROR
2035         clusapi_MoveGroupEx(
2036                 [ in ] HGROUP_RPC hGroup,
2037                 [ in ] uint32           dwMoveFlags,
2038                 [ in, size_is(cbInBufferSize) ] uint8* lpInBuffer,
2039                 [ in ] uint32           cbInBufferSize,
2040                 [ out ] WERROR *rpc_status
2041         );
2042
2043         /*****************/
2044         /* Function 0x85 */
2045
2046         WERROR
2047         clusapi_MoveGroupToNodeEx(
2048                 [ in ] HGROUP_RPC hGroup,
2049                 [ in ] HNODE_RPC  hNode,
2050                 [ in ] uint32           dwMoveFlags,
2051                 [ in, size_is(cbInBufferSize) ] uint8* lpInBuffer,
2052                 [ in ] uint32           cbInBufferSize,
2053                 [ out ] WERROR *rpc_status
2054         );
2055
2056         /*****************/
2057         /* Function 0x86 */
2058
2059         WERROR
2060         clusapi_CancelClusterGroupOperation(
2061                 [ in ] HGROUP_RPC       hGroup,
2062                 [ in ] uint32            dwCancelFlags,
2063                 [ out ] WERROR *rpc_status
2064         );
2065
2066         /*****************/
2067         /* Function 0x87 */
2068
2069         WERROR
2070         clusapi_OnlineResourceEx(
2071                 [ in ] HRES_RPC hResource,
2072                 [ in ] uint32     dwOnlineFlags,
2073                 [ in, size_is(cbInBufferSize) ] uint8* lpInBuffer,
2074                 [ in ] uint32     cbInBufferSize,
2075                 [ out ] WERROR *rpc_status
2076         );
2077
2078         /*****************/
2079         /* Function 0x88 */
2080
2081         WERROR
2082         clusapi_OfflineResourceEx(
2083                 [ in ] HRES_RPC hResource,
2084                 [ in ] uint32     dwOfflineFlags,
2085                 [ in, size_is(cbInBufferSize) ] uint8* lpInBuffer,
2086                 [ in ] uint32     cbInBufferSize,
2087                 [ out ] WERROR *rpc_status
2088         );
2089
2090 #define HGENERIC_RPC policy_handle
2091 #if 0
2092         typedef [context_handle] void *HGENERIC_RPC;
2093 #endif
2094
2095         typedef struct {
2096                 uint32 dwObjectType;      /* really of type CLUSTER_OBJECT_TYPE_RPC */
2097                 hyper FilterFlags;
2098         } NOTIFY_FILTER_AND_TYPE_RPC;
2099
2100         typedef struct {
2101                 NOTIFY_FILTER_AND_TYPE_RPC FilterAndType;
2102                 [ size_is(dwBufferSize ) ] uint8* buffer;
2103                 uint32 dwBufferSize;
2104                 [string] [charset(UTF16)] uint16 *ObjectId;
2105                 [string] [charset(UTF16)] uint16 *ParentId;
2106                 [string] [charset(UTF16)] uint16 *Name;
2107                 [string] [charset(UTF16)] uint16 *Type;
2108         } NOTIFICATION_DATA_RPC;
2109
2110         typedef struct {
2111                 uint32 *dwNotifyKey;
2112                 NOTIFICATION_DATA_RPC NotificationData;
2113         } NOTIFICATION_RPC;
2114
2115         /*****************/
2116         /* Function 0x89 */
2117
2118         /*
2119          * Notify interface V2 functions
2120          */
2121 #if 0
2122         HNOTIFY_RPC
2123         clusapi_CreateNotifyV2(
2124                 [ out ] WERROR *rpc_error,
2125                 [ out ] WERROR *rpc_status
2126         );
2127 #else
2128         void
2129         clusapi_CreateNotifyV2(
2130                 [ out ] WERROR *rpc_error,
2131                 [ out ] WERROR *rpc_status,
2132                 [ out ] HNOTIFY_RPC *hNotify
2133         );
2134
2135 #endif
2136         /*****************/
2137         /* Function 0x8A */
2138
2139         WERROR
2140         clusapi_AddNotifyV2(
2141                 [ in ] HNOTIFY_RPC hNotify,
2142                 [ in ] HGENERIC_RPC hObject,
2143                 [ in ] NOTIFY_FILTER_AND_TYPE_RPC filter,
2144                 [ in ] uint32 dwNotifyKey,
2145                 [ in ] uint32 dwVersion,
2146                 [ in ] boolean8 isTargetedAtObject,
2147                 [ out ] WERROR *rpc_status
2148         );
2149
2150         /*****************/
2151         /* Function 0x8B */
2152
2153         WERROR
2154         clusapi_GetNotifyV2(
2155                 [ in ] HNOTIFY_RPC hNotify,
2156                 [ out, size_is(,*dwNumNotifications) ] NOTIFICATION_RPC **Notifications,
2157                 [ out ] uint32 *dwNumNotifications
2158         );
2159
2160         /*****************/
2161         /* Function 0x8C */
2162
2163         WERROR
2164         clusapi_QueryAllValues(
2165                 [ in ] HKEY_RPC hKey,
2166                 [ out ] uint32 *pcbData,
2167                 [ out, size_is(1, *pcbData) ] uint8 ** ppData,
2168                 [ out ] WERROR *rpc_status
2169         );
2170
2171         typedef struct {
2172                 uint32 DiskIdType;
2173                 uint8  DiskIdBlob[16];
2174         } CLUSTER_DISKID;
2175
2176         /*****************/
2177         /* Function 0x8D */
2178
2179         WERROR
2180         clusapi_StmFindDisk(
2181                 [ in ] HCLUSTER_RPC hCluster,
2182                 [ in ] uint32 dwFlags,
2183                 [ in, out, unique ] CLUSTER_DISKID *pDiskId,
2184                 [ in, size_is(uniqueIdSize), unique ] uint8 *pUniqueId,
2185                 [ in ] uint32 uniqueIdSize,
2186                 [ out, ref, string ] [charset(UTF16)] uint16 **ppszDeviceName,
2187                 [ out ] WERROR *rpc_status
2188         );
2189
2190         typedef struct{
2191                 [string] [charset(UTF16)] uint16 *pszNodeName;
2192                 HRESULT ResultCode;
2193                 uint32  ResultSize;
2194                 [unique, size_is(ResultSize)]   uint8    *pResultData;
2195         } CLUSTER_MRR_NODE_RESPONSE;
2196
2197         typedef struct {
2198                 uint32 NodeCount;
2199                 [size_is(NodeCount)] CLUSTER_MRR_NODE_RESPONSE *pNodes;
2200         } CLUSTER_MRR_RESPONSE;
2201
2202         /*****************/
2203         /* Function 0x8E */
2204
2205         WERROR
2206         clusapi_ClusterMrr(
2207                 [ in ] HCLUSTER_RPC hCluster,
2208                 [ in ] boolean8 fExcludeSelf,
2209                 [ in ] hyper nodeSet,
2210                 [ in ] uint32 dwTimeout,
2211                 [ in ] uint32 dwComponent,
2212                 [ in ] uint32 dwControlCode,
2213                 [ in ] uint32 inSize,
2214                 [ in, unique, size_is(inSize) ] uint8 *pInData,
2215                 [ out, ref, size_is(1, 1) ] CLUSTER_MRR_RESPONSE **ppInfo,
2216                 [ out ] WERROR *rpc_status
2217         );
2218
2219         /*****************/
2220         /* Function 0x8F */
2221
2222         WERROR
2223         clusapi_CreateGroupEnum(
2224                 [ in ] HCLUSTER_RPC hCluster,
2225                 [ in, unique, size_is(cbProperties)] uint8* pProperties,
2226                 [ in ] uint32 cbProperties,
2227                 [ in, unique, size_is(cbRoProperties)] uint8* pRoProperties,
2228                 [ in ] uint32 cbRoProperties,
2229                 [ out ] GROUP_ENUM_LIST **ppResultList,
2230                 [ out ] WERROR *rpc_status
2231         );
2232
2233         /*****************/
2234         /* Function 0x90 */
2235
2236         WERROR
2237         clusapi_CreateResourceEnum(
2238                 [ in ] HCLUSTER_RPC hCluster,
2239                 [ in, unique, size_is(cbProperties)] uint8* pProperties,
2240                 [ in ] uint32 cbProperties,
2241                 [ in, unique, size_is(cbRoProperties)] uint8* pRoProperties,
2242                 [ in ] uint32 cbRoProperties,
2243                 [ out ] RESOURCE_ENUM_LIST **ppResultList,
2244                 [ out ] WERROR *rpc_status
2245         );
2246
2247         /*****************/
2248         /* Function 0x91 */
2249
2250         WERROR
2251         clusapi_ExecuteReadBatch(
2252                 [ in ] HKEY_RPC hKey,
2253                 [ in ] uint32 cbInData,
2254                 [ in, size_is(cbInData)] uint8 *lpInData,
2255                 [ out ] uint32 *cbOutData,
2256                 [ out, size_is(,*cbOutData) ] uint8 ** lpOutData,
2257                 [ out ] WERROR *rpc_status
2258         );
2259
2260         /*****************/
2261         /* Function 0x92 */
2262
2263         WERROR
2264         clusapi_RestartResource(
2265                 [ in ] HRES_RPC hResource,
2266                 [ in ] uint32 dwFlags,
2267                 [ out ] WERROR *rpc_status
2268         );
2269
2270         typedef struct {
2271                 uint32 dwNotifyKey;
2272                 uint32 dwFilter;
2273                 [string] [charset(UTF16)] uint16 *Name;
2274         } NOTIFICATION_DATA_ASYNC_RPC;
2275
2276         /*****************/
2277         /* Function 0x93 */
2278
2279         WERROR
2280         clusapi_GetNotifyAsync(
2281                 [ in ] HNOTIFY_RPC hNotify,
2282                 [ out, size_is(,*dwNumNotifications) ] NOTIFICATION_DATA_ASYNC_RPC **Notifications,
2283                 [ out ] uint32 *dwNumNotifications
2284         );
2285
2286         typedef enum {
2287                 DiskIdSignature = 0x00000001,
2288                 DiskIdGuid = 0x00000002,
2289                 DiskIdUnKnown = 0x00001388
2290         } CLUSDSK_DISKID_ENUM;
2291
2292 #if 0
2293         typedef struct {
2294                 CLUSDSK_DISKID_ENUM DiskIdType;
2295                 [switch_is(DiskIdType)] union {
2296                         [case(DiskIdSignature)] uint32 DiskSignature;
2297                         [case(DiskIdGuid)] GUID DiskGuid;
2298                 };
2299         } CLUSDSK_DISKID;
2300 #endif
2301         typedef enum {
2302                 CLUSPROP_TYPE_ENDMARK = 0x0000,
2303                 CLUSPROP_TYPE_LIST_VALUE = 0x0001,
2304                 CLUSPROP_TYPE_RESCLASS = 0x0002,
2305                 CLUSPROP_TYPE_NAME = 0x0004,
2306                 CLUSPROP_TYPE_SIGNATURE = 0x0005,
2307                 CLUSPROP_TYPE_SCSIADDRESS = 0x0006,
2308                 CLUSPROP_TYPE_DISK_NUMBER = 0x0007,
2309                 CLUSPROP_TYPE_PARTITION_INFO = 0x0008,
2310                 CLUSPROP_TYPE_DISK_SERIALNUMBER = 0x000a,
2311                 CLUSPROP_TYPE_DISK_GUID = 0x000b,
2312                 CLUSPROP_TYPE_DISK_SIZE = 0x000c,
2313                 CLUSPROP_TYPE_PARTITION_INFO_EX = 0x000d
2314         } CLUSTER_PROPERTY_TYPE;
2315
2316         typedef enum {
2317                 CLUSPROP_FORMAT_UNKNOWN = 0x0000,
2318                 CLUSPROP_FORMAT_BINARY = 0x0001,
2319                 CLUSPROP_FORMAT_DWORD = 0x0002,
2320                 CLUSPROP_FORMAT_SZ = 0x0003,
2321                 CLUSPROP_FORMAT_EXPAND_SZ = 0x0004,
2322                 CLUSPROP_FORMAT_MULTI_SZ = 0x0005,
2323                 CLUSPROP_FORMAT_ULARGE_INTEGER = 0x0006,
2324                 CLUSPROP_FORMAT_LONG = 0x0007,
2325                 CLUSPROP_FORMAT_EXPANDED_SZ = 0x0008,
2326                 CLUSPROP_FORMAT_SECURITY_DESCRIPTOR = 0x0009,
2327                 CLUSPROP_FORMAT_LARGE_INTEGER = 0x000a,
2328                 CLUSPROP_FORMAT_WORD = 0x000b,
2329                 CLUSPROP_FORMAT_FILETIME = 0x000c
2330         } CLUSTER_PROPERTY_FORMAT;
2331
2332         typedef enum {
2333                 CLUS_CHAR_UNKNOWN = 0x00000000,
2334                 CLUS_CHAR_QUORUM = 0x00000001,
2335                 CLUS_CHAR_DELETE_REQUIRES_ALL_NODES = 0x00000002,
2336                 CLUS_CHAR_LOCAL_QUORUM = 0x00000004,
2337                 CLUS_CHAR_BROADCAST_DELETE = 0x00000020,
2338                 CLUS_CHAR_SINGLE_CLUSTER_INSTANCE = 0x00000040,
2339                 CLUS_CHAR_SINGLE_GROUP_INSTANCE = 0x00000080,
2340                 CLUS_CHAR_COEXIST_IN_SHARED_VOLUME_GROUP = 0x00000100,
2341                 CLUS_CHAR_RESERVED1 = 0x00000200,
2342                 CLUS_CHAR_MONITOR_DETACH = 0x00000400,
2343                 CLUS_CHAR_RESERVED2 = 0x00000800,
2344                 CLUS_CHAR_RESERVED3 = 0x00001000,
2345                 CLUS_CHAR_RESERVED4 = 0x00002000
2346         } CLUS_CHARACTERISTICS;
2347
2348         typedef enum {
2349                 CLUS_FLAG_CORE = 0x00000001
2350         } CLUS_FLAGS;
2351
2352         typedef enum {
2353                 MaintenanceModeTypeDisableIsAliveCheck = 1,
2354                 MaintenanceModeTypeOfflineResource = 2,
2355                 MaintenanceModeTypeUnclusterResource = 3
2356         } MAINTENANCE_MODE_TYPE;
2357
2358         typedef enum {
2359                 CLUSTER_CHANGE_NODE_STATE = 0x00000001,
2360                 CLUSTER_CHANGE_NODE_DELETED = 0x00000002,
2361                 CLUSTER_CHANGE_NODE_ADDED = 0x00000004,
2362                 CLUSTER_CHANGE_NODE_PROPERTY = 0x00000008,
2363                 CLUSTER_CHANGE_REGISTRY_NAME = 0x00000010,
2364                 CLUSTER_CHANGE_REGISTRY_ATTRIBUTES = 0x00000020,
2365                 CLUSTER_CHANGE_REGISTRY_VALUE = 0x00000040,
2366                 CLUSTER_CHANGE_REGISTRY_SUBTREE = 0x00000080,
2367                 CLUSTER_CHANGE_RESOURCE_STATE = 0x00000100,
2368                 CLUSTER_CHANGE_RESOURCE_DELETED = 0x00000200,
2369                 CLUSTER_CHANGE_RESOURCE_ADDED = 0x00000400,
2370                 CLUSTER_CHANGE_RESOURCE_PROPERTY = 0x00000800,
2371                 CLUSTER_CHANGE_GROUP_STATE = 0x00001000,
2372                 CLUSTER_CHANGE_GROUP_DELETED = 0x00002000,
2373                 CLUSTER_CHANGE_GROUP_ADDED = 0x00004000,
2374                 CLUSTER_CHANGE_GROUP_PROPERTY = 0x00008000,
2375                 CLUSTER_CHANGE_RESOURCE_TYPE_DELETED = 0x00010000,
2376                 CLUSTER_CHANGE_RESOURCE_TYPE_ADDED = 0x00020000,
2377                 CLUSTER_CHANGE_RESOURCE_TYPE_PROPERTY = 0x00040000,
2378                 CLUSTER_CHANGE_CLUSTER_RECONNECT = 0x00080000,
2379                 CLUSTER_CHANGE_NETWORK_STATE = 0x00100000,
2380                 CLUSTER_CHANGE_NETWORK_DELETED = 0x00200000,
2381                 CLUSTER_CHANGE_NETWORK_ADDED = 0x00400000,
2382                 CLUSTER_CHANGE_NETWORK_PROPERTY = 0x00800000,
2383                 CLUSTER_CHANGE_NETINTERFACE_STATE = 0x01000000,
2384                 CLUSTER_CHANGE_NETINTERFACE_DELETED = 0x02000000,
2385                 CLUSTER_CHANGE_NETINTERFACE_ADDED = 0x04000000,
2386                 CLUSTER_CHANGE_NETINTERFACE_PROPERTY = 0x08000000,
2387                 CLUSTER_CHANGE_QUORUM_STATE = 0x10000000,
2388                 CLUSTER_CHANGE_CLUSTER_STATE = 0x20000000,
2389                 CLUSTER_CHANGE_CLUSTER_PROPERTY = 0x40000000,
2390                 CLUSTER_CHANGE_HANDLE_CLOSE = 0x80000000
2391         } CLUSTER_CHANGE;
2392
2393         typedef enum {
2394                 CLUSREG_SET_VALUE = 1,
2395                 CLUSREG_CREATE_KEY = 2,
2396                 CLUSREG_DELETE_KEY = 3,
2397                 CLUSREG_DELETE_VALUE = 4,
2398                 CLUSREG_VALUE_DELETED = 6,
2399                 CLUSREG_READ_KEY = 7,
2400                 CLUSREG_READ_VALUE = 8,
2401                 CLUSREG_READ_ERROR = 9
2402         } CLUSTER_REG_BATCH_COMMAND;
2403 #if 0
2404         typedef enum {
2405                 IDL_CLUSTER_SET_PASSWORD_IGNORE_DOWN_NODES = 1
2406         } IDL_CLUSTER_SET_PASSWORD_FLAGS;
2407 #endif
2408         typedef enum {
2409                 CLUSTER_QUORUM_MAINTAINED = 0,
2410                 CLUSTER_QUORUM_LOST = 1
2411         } CLUSTER_QUORUM_VALUE;
2412
2413         typedef enum {
2414                 CLUSTER_OBJECT_TYPE_CLUSTER = 0x00000001,
2415                 CLUSTER_OBJECT_TYPE_GROUP = 0x00000002,
2416                 CLUSTER_OBJECT_TYPE_RESOURCE = 0x00000003,
2417                 CLUSTER_OBJECT_TYPE_RESOURCE_TYPE = 0x00000004,
2418                 CLUSTER_OBJECT_TYPE_NETWORK_INTERFACE = 0x00000005,
2419                 CLUSTER_OBJECT_TYPE_NETWORK = 0x00000006,
2420                 CLUSTER_OBJECT_TYPE_NODE = 0x00000007,
2421                 CLUSTER_OBJECT_TYPE_REGISTRY = 0x00000008,
2422                 CLUSTER_OBJECT_TYPE_QUORUM = 0x00000009,
2423                 CLUSTER_OBJECT_TYPE_SHARED_VOLUME = 0x0000000a
2424         } CLUSTER_OBJECT_TYPE;
2425
2426         typedef enum {
2427                 CLUSTER_CHANGE_CLUSTER_RECONNECT_V2 = 0x00000001,
2428                 CLUSTER_CHANGE_CLUSTER_STATE_V2 = 0x00000002,
2429                 CLUSTER_CHANGE_CLUSTER_GROUP_ADDED_V2 = 0x00000004,
2430                 CLUSTER_CHANGE_CLUSTER_HANDLE_CLOSE_V2 = 0x00000008,
2431                 CLUSTER_CHANGE_CLUSTER_NETWORK_ADDED_V2 = 0x00000010,
2432                 CLUSTER_CHANGE_CLUSTER_NODE_ADDED_V2 = 0x00000020,
2433                 CLUSTER_CHANGE_CLUSTER_RESOURCE_TYPE_ADDED_V2 = 0x00000040,
2434                 CLUSTER_CHANGE_CLUSTER_COMMON_PROPERTY_V2 = 0x00000080,
2435                 CLUSTER_CHANGE_CLUSTER_PRIVATE_PROPERTY_V2 = 0x00000100,
2436                 CLUSTER_CHANGE_CLUSTER_LOST_NOTIFICATIONS_V2 = 0x00000200,
2437                 CLUSTER_CHANGE_CLUSTER_RENAME_V2 = 0x00000400
2438         } CLUSTER_CHANGE_CLUSTER_V2;
2439
2440         typedef enum {
2441                 CLUSTER_CHANGE_GROUP_DELETED_V2 = 0x00000001,
2442                 CLUSTER_CHANGE_GROUP_COMMON_PROPERTY_V2 = 0x00000002,
2443                 CLUSTER_CHANGE_GROUP_PRIVATE_PROPERTY_V2 = 0x00000004,
2444                 CLUSTER_CHANGE_GROUP_STATE_V2 = 0x00000008,
2445                 CLUSTER_CHANGE_GROUP_OWNER_NODE_V2 = 0x00000010,
2446                 CLUSTER_CHANGE_GROUP_PREFERRED_OWNERS_V2 = 0x00000020,
2447                 CLUSTER_CHANGE_GROUP_RESOURCE_ADDED_V2 = 0x00000040,
2448                 CLUSTER_CHANGE_GROUP_RESOURCE_GAINED_V2 = 0x00000080,
2449                 CLUSTER_CHANGE_GROUP_RESOURCE_LOST_V2 = 0x00000100,
2450                 CLUSTER_CHANGE_GROUP_HANDLE_CLOSE_V2 = 0x00000200
2451         } CLUSTER_CHANGE_GROUP_V2;
2452
2453         typedef enum {
2454                 CLUSTER_CHANGE_RESOURCE_COMMON_PROPERTY_V2 = 0x00000001,
2455                 CLUSTER_CHANGE_RESOURCE_PRIVATE_PROPERTY_V2 = 0x00000002,
2456                 CLUSTER_CHANGE_RESOURCE_STATE_V2 = 0x00000004,
2457                 CLUSTER_CHANGE_RESOURCE_OWNER_GROUP_V2 = 0x00000008,
2458                 CLUSTER_CHANGE_RESOURCE_DEPENDENCIES_V2 = 0x00000010,
2459                 CLUSTER_CHANGE_RESOURCE_DEPENDENTS_V2 = 0x00000020,
2460                 CLUSTER_CHANGE_RESOURCE_POSSIBLE_OWNERS_V2 = 0x00000040,
2461                 CLUSTER_CHANGE_RESOURCE_DELETED_V2 = 0x00000080,
2462                 CLUSTER_CHANGE_RESOURCE_DLL_UPGRADED_V2 = 0x00000100,
2463                 CLUSTER_CHANGE_RESOURCE_HANDLE_CLOSE_V2 = 0x00000200
2464         } CLUSTER_CHANGE_RESOURCE_V2;
2465
2466         typedef enum {
2467                 CLUSTER_CHANGE_RESOURCE_TYPE_DELETED_V2 = 0x00000001,
2468                 CLUSTER_CHANGE_RESOURCE_TYPE_COMMON_PROPERTY_V2 = 0x00000002,
2469                 CLUSTER_CHANGE_RESOURCE_TYPE_PRIVATE_PROPERTY_V2 = 0x00000004,
2470                 CLUSTER_CHANGE_RESOURCE_TYPE_POSSIBLE_OWNERS_V2 = 0x00000008,
2471                 CLUSTER_CHANGE_RESOURCE_TYPE_DLL_UPGRADED_V2 = 0x00000010
2472         } CHANGE_RESOURCE_TYPE_V2;
2473
2474         typedef enum {
2475                 CLUSTER_CHANGE_NETINTERFACE_DELETED_V2 = 0x00000001,
2476                 CLUSTER_CHANGE_NETINTERFACE_COMMON_PROPERTY_V2 = 0x00000002,
2477                 CLUSTER_CHANGE_NETINTERFACE_PRIVATE_PROPERTY_V2 = 0x00000004,
2478                 CLUSTER_CHANGE_NETINTERFACE_STATE_V2 = 0x00000008,
2479                 CLUSTER_CHANGE_NETINTERFACE_HANDLE_CLOSE_V2 = 0x00000010
2480         } CLUSTER_CHANGE_NETINTERFACE_V2;
2481
2482         typedef enum {
2483                 CLUSTER_CHANGE_NETWORK_DELETED_V2 = 0x00000001,
2484                 CLUSTER_CHANGE_NETWORK_COMMON_PROPERTY_V2 = 0x00000002,
2485                 CLUSTER_CHANGE_NETWORK_PRIVATE_PROPERTY_V2 = 0x00000004,
2486                 CLUSTER_CHANGE_NETWORK_STATE_V2 = 0x00000008,
2487                 CLUSTER_CHANGE_NETWORK_HANDLE_CLOSE_V2 = 0x00000010
2488         } CLUSTER_CHANGE_NETWORK_V2;
2489
2490         typedef enum {
2491                 CLUSTER_CHANGE_NODE_NETINTERFACE_ADDED_V2 = 0x00000001,
2492                 CLUSTER_CHANGE_NODE_DELETED_V2 = 0x00000002,
2493                 CLUSTER_CHANGE_NODE_COMMON_PROPERTY_V2 = 0x00000004,
2494                 CLUSTER_CHANGE_NODE_PRIVATE_PROPERTY_V2 = 0x00000008,
2495                 CLUSTER_CHANGE_NODE_STATE_V2 = 0x00000010,
2496                 CLUSTER_CHANGE_NODE_GROUP_GAINED_V2 = 0x00000020,
2497                 CLUSTER_CHANGE_NODE_GROUP_LOST_V2 = 0x00000040,
2498                 CLUSTER_CHANGE_NODE_HANDLE_CLOSE_V2 = 0x00000080
2499         } CLUSTER_CHANGE_NODE_V2;
2500
2501         typedef enum {
2502                 CLUSTER_CHANGE_REGISTRY_ATTRIBUTES_V2 = 0x00000001,
2503                 CLUSTER_CHANGE_REGISTRY_NAME_V2 = 0x00000002,
2504                 CLUSTER_CHANGE_REGISTRY_SUBTREE_V2 = 0x00000004,
2505                 CLUSTER_CHANGE_REGISTRY_VALUE_V2 = 0x00000008,
2506                 CLUSTER_CHANGE_REGISTRY_HANDLE_CLOSE_V2 = 0x00000010
2507         } CLUSTER_CHANGE_REGISTRY_V2;
2508
2509         typedef enum {
2510                 CLUSTER_CHANGE_QUORUM_STATE_V2 = 0x00000001
2511         } CLUSTER_CHANGE_QUORUM_V2;
2512
2513         typedef enum {
2514                 CLUSTER_CHANGE_SHARED_VOLUME_STATE_V2 = 0x00000001
2515         } CLUSTER_CHANGE_SHARED_VOLUME_V2;
2516 #if 0
2517         typedef enum {
2518                 DiskIdSignature = 0x00000001,
2519                 DiskIdGuid = 0x00000002,
2520                 DiskIdUnKnown = 0x00001388
2521         } CLUSDSK_DISKID_ENUM;
2522 #endif
2523 }