librpc/idl/clusapi.idl

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