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