Headers diff for clusapi.dll between 5.2.3790.3959-Windows 5.0 and 6.0.6001.18000-Windows 6.0 versions



 clusapi.h (5.2.3790.3959-Windows 5.0)   clusapi.h (6.0.6001.18000-Windows 6.0) 
skipping to change at line 21 skipping to change at line 21
This module defines the common management and application interface to This module defines the common management and application interface to
the Microsoft Cluster Server services. the Microsoft Cluster Server services.
Revision History: Revision History:
--*/ --*/
#ifndef _CLUSTER_API_ #ifndef _CLUSTER_API_
#define _CLUSTER_API_ #define _CLUSTER_API_
#define CLUSAPI_VERSION 0x0500 #define CLUSAPI_VERSION 0x0600
#if _MSC_VER > 1000 #if _MSC_VER > 1000
#pragma once #pragma once
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#ifndef MIDL_PASS #if ( !MIDL_PASS && !__midl )
#if _MSC_VER >= 1200 #if _MSC_VER >= 1200
#pragma warning(push) #pragma warning(push)
#endif #endif
#pragma warning( disable : 4200 ) // nonstandard extension used : zero-sized arr ay in struct/union #pragma warning( disable : 4200 ) // nonstandard extension used : zero-sized arr ay in struct/union
#pragma warning( disable : 4201 ) // nonstandard extension used : nameless struc t/union #pragma warning( disable : 4201 ) // nonstandard extension used : nameless struc t/union
#endif // MIDL_PASS #endif // MIDL_PASS
// //
// General cluster definitions // General cluster definitions
// //
#ifndef _CLUSTER_API_TYPES_ #ifndef _CLUSTER_API_TYPES_
// //
// Defined cluster handle types. // Defined cluster handle types.
// //
typedef struct _HCLUSTER *HCLUSTER; typedef struct _HCLUSTER *HCLUSTER;
typedef struct _HNODE *HNODE; typedef struct _HNODE *HNODE;
typedef struct _HRESOURCE *HRESOURCE; typedef struct _HRESOURCE *HRESOURCE;
typedef struct _HGROUP *HGROUP; typedef struct _HGROUP *HGROUP;
//typedef struct _HRESTYPE *HRESTYPE;
typedef struct _HNETWORK *HNETWORK; typedef struct _HNETWORK *HNETWORK;
typedef struct _HNETINTERFACE *HNETINTERFACE; typedef struct _HNETINTERFACE *HNETINTERFACE;
typedef struct _HCHANGE *HCHANGE; typedef struct _HCHANGE *HCHANGE;
typedef struct _HCLUSENUM *HCLUSENUM; typedef struct _HCLUSENUM *HCLUSENUM;
typedef struct _HGROUPENUM *HGROUPENUM; typedef struct _HGROUPENUM *HGROUPENUM;
typedef struct _HRESENUM *HRESENUM; typedef struct _HRESENUM *HRESENUM;
typedef struct _HNETWORKENUM *HNETWORKENUM; typedef struct _HNETWORKENUM *HNETWORKENUM;
typedef struct _HNODEENUM *HNODEENUM; typedef struct _HNODEENUM *HNODEENUM;
typedef struct _HRESTYPEENUM *HRESTYPEENUM; typedef struct _HRESTYPEENUM *HRESTYPEENUM;
typedef struct _HREGBATCH *HREGBATCH;
#endif // _CLUSTER_API_TYPES_ #endif // _CLUSTER_API_TYPES_
// //
// Definitions used in cluster management routines. // Definitions used in cluster management routines.
// //
#define MAX_CLUSTERNAME_LENGTH MAX_COMPUTERNAME_LENGTH #define MAX_CLUSTERNAME_LENGTH DNS_MAX_LABEL_LENGTH
#ifndef _CLUSTER_API_TYPES_ #ifndef _CLUSTER_API_TYPES_
// //
// Cluster-related structures and types // Cluster-related structures and types
// //
typedef enum CLUSTER_QUORUM_TYPE { typedef enum CLUSTER_QUORUM_TYPE {
OperationalQuorum, OperationalQuorum,
ModifyQuorum ModifyQuorum
} CLUSTER_QUORUM_TYPE; } CLUSTER_QUORUM_TYPE;
#ifndef MIDL_PASS #if ( !MIDL_PASS && !__midl )
typedef struct CLUSTERVERSIONINFO_NT4 { typedef struct CLUSTERVERSIONINFO_NT4 {
DWORD dwVersionInfoSize; DWORD dwVersionInfoSize;
WORD MajorVersion; WORD MajorVersion;
WORD MinorVersion; WORD MinorVersion;
WORD BuildNumber; WORD BuildNumber;
WCHAR szVendorId[64]; WCHAR szVendorId[64];
WCHAR szCSDVersion[64]; WCHAR szCSDVersion[64];
}CLUSTERVERSIONINFO_NT4, *PCLUSTERVERSIONINFO_NT4; }CLUSTERVERSIONINFO_NT4, *PCLUSTERVERSIONINFO_NT4;
skipping to change at line 115 skipping to change at line 115
BOOL bForm; BOOL bForm;
BOOL bFirst; BOOL bFirst;
} CLUS_STARTING_PARAMS, * PCLUS_STARTING_PARAMS; } CLUS_STARTING_PARAMS, * PCLUS_STARTING_PARAMS;
#define CLUSTER_VERSION_FLAG_MIXED_MODE 0x00000001 #define CLUSTER_VERSION_FLAG_MIXED_MODE 0x00000001
#define NT4_MAJOR_VERSION 1 #define NT4_MAJOR_VERSION 1
#define NT4SP4_MAJOR_VERSION 2 #define NT4SP4_MAJOR_VERSION 2
#define NT5_MAJOR_VERSION 3 #define NT5_MAJOR_VERSION 3
#define NT51_MAJOR_VERSION 4 #define NT51_MAJOR_VERSION 4
#define LONGHORN_MAJOR_VERSION 5
#define CLUSTER_VERSION_UNKNOWN 0xFFFFFFFF #define CLUSTER_VERSION_UNKNOWN 0xFFFFFFFF
// //
// Version number macros // Version number macros
// //
#define CLUSTER_MAKE_VERSION( _maj, _min ) ((( _maj ) << 16 ) | ( _min )) #define CLUSTER_MAKE_VERSION( _maj, _min ) ((( _maj ) << 16 ) | ( _min ))
#define CLUSTER_GET_MAJOR_VERSION( _ver ) (( _ver ) >> 16 ) #define CLUSTER_GET_MAJOR_VERSION( _ver ) (( _ver ) >> 16 )
#define CLUSTER_GET_MINOR_VERSION( _ver ) (( _ver ) & 0xFFFF ) #define CLUSTER_GET_MINOR_VERSION( _ver ) (( _ver ) & 0xFFFF )
skipping to change at line 142 skipping to change at line 143
#define CLUSTER_CONFIGURED 0x00000002 #define CLUSTER_CONFIGURED 0x00000002
#define CLUSTER_RUNNING 0x00000010 #define CLUSTER_RUNNING 0x00000010
typedef enum NODE_CLUSTER_STATE { typedef enum NODE_CLUSTER_STATE {
ClusterStateNotInstalled = 0x00000000, ClusterStateNotInstalled = 0x00000000,
ClusterStateNotConfigured = CLUSTER_INSTALLED, ClusterStateNotConfigured = CLUSTER_INSTALLED,
ClusterStateNotRunning = CLUSTER_INSTALLED | CLUSTER_CONFIG URED, ClusterStateNotRunning = CLUSTER_INSTALLED | CLUSTER_CONFIG URED,
ClusterStateRunning = CLUSTER_INSTALLED | CLUSTER_CONFIG URED | CLUSTER_RUNNING ClusterStateRunning = CLUSTER_INSTALLED | CLUSTER_CONFIG URED | CLUSTER_RUNNING
} NODE_CLUSTER_STATE; } NODE_CLUSTER_STATE;
// Quorum mode flags for SetClusterQuorumResource API
#define CLUS_HYBRID_QUORUM 1024 // 0xFFFFFFFF
#define CLUS_NODE_MAJORITY_QUORUM 0 // 0xFFFFFFFE
#define CLUS_LEGACY_QUORUM (4 * 1024 * 1024) // 0xFFFFFFFD
// //
// Resource state change reason related types and defines // Resource state change reason related types and defines
// //
#define CLUSCTL_RESOURCE_STATE_CHANGE_REASON_VERSION_1 1 #define CLUSCTL_RESOURCE_STATE_CHANGE_REASON_VERSION_1 1
typedef enum CLUSTER_RESOURCE_STATE_CHANGE_REASON { typedef enum CLUSTER_RESOURCE_STATE_CHANGE_REASON {
eResourceStateChangeReasonUnknown, eResourceStateChangeReasonUnknown,
eResourceStateChangeReasonMove, eResourceStateChangeReasonMove,
eResourceStateChangeReasonFailover, eResourceStateChangeReasonFailover,
eResourceStateChangeReasonFailedMove, eResourceStateChangeReasonFailedMove,
eResourceStateChangeReasonShutdown, eResourceStateChangeReasonShutdown,
eResourceStateChangeReasonRundown eResourceStateChangeReasonRundown
} CLUSTER_RESOURCE_STATE_CHANGE_REASON; } CLUSTER_RESOURCE_STATE_CHANGE_REASON;
#ifndef MIDL_PASS typedef enum _CLUSTER_REG_COMMAND
{
CLUSREG_COMMAND_NONE = 0,
CLUSREG_SET_VALUE = 1,
CLUSREG_CREATE_KEY,
CLUSREG_DELETE_KEY,
CLUSREG_DELETE_VALUE,
CLUSREG_SET_KEY_SECURITY,
CLUSREG_LAST_COMMAND
} CLUSTER_REG_COMMAND;
#if ( !MIDL_PASS && !__midl )
typedef struct _CLUSCTL_RESOURCE_STATE_CHANGE_REASON_STRUCT { typedef struct _CLUSCTL_RESOURCE_STATE_CHANGE_REASON_STRUCT {
DWORD dwSize; DWORD dwSize;
DWORD dwVersion; DWORD dwVersion;
CLUSTER_RESOURCE_STATE_CHANGE_REASON eReason; CLUSTER_RESOURCE_STATE_CHANGE_REASON eReason;
} CLUSCTL_RESOURCE_STATE_CHANGE_REASON_STRUCT, *PCLUSCTL_RESOURCE_STATE_CHANGE_R EASON_STRUCT; } CLUSCTL_RESOURCE_STATE_CHANGE_REASON_STRUCT, *PCLUSCTL_RESOURCE_STATE_CHANGE_R EASON_STRUCT;
#endif // MIDL_PASS #endif // MIDL_PASS
#endif // _CLUSTER_API_TYPES_ #endif // _CLUSTER_API_TYPES_
skipping to change at line 181 skipping to change at line 202
// //
// Cluster API Specific Access Rights // Cluster API Specific Access Rights
// //
#define CLUSAPI_READ_ACCESS 0x00000001L #define CLUSAPI_READ_ACCESS 0x00000001L
#define CLUSAPI_CHANGE_ACCESS 0x00000002L #define CLUSAPI_CHANGE_ACCESS 0x00000002L
#define CLUSAPI_NO_ACCESS 0x00000004L #define CLUSAPI_NO_ACCESS 0x00000004L
#define CLUSAPI_ALL_ACCESS (CLUSAPI_READ_ACCESS | CLUSAPI_CHANGE_ACCESS) #define CLUSAPI_ALL_ACCESS (CLUSAPI_READ_ACCESS | CLUSAPI_CHANGE_ACCESS)
// //
// Flags that control the behavior of SetClusterServiceAccountPassword // Return values for CLUSCTL_CLUSTER_CHECK_VOTER_DOWN and CLUSCTL_CLUSTER_CHECK_ VOTER_EVICT
// //
typedef enum CLUSTER_SET_PASSWORD_FLAGS { typedef enum CLUSTER_QUORUM_VALUE {
CLUSTER_SET_PASSWORD_IGNORE_DOWN_NODES = 1 CLUSTER_QUORUM_MAINTAINED = 0,
} CLUSTER_SET_PASSWORD_FLAGS; CLUSTER_QUORUM_LOST = 1,
} CLUSTER_QUORUM_VALUE;
#ifndef MIDL_PASS #if ( !MIDL_PASS && !__midl )
// //
// Structure used to return the status of a request to set the // Structure used to return the status of a request to set the
// password on the account used by the Cluster Service on each // password on the account used by the Cluster Service on each
// cluster node. // cluster node.
// //
typedef struct CLUSTER_SET_PASSWORD_STATUS { typedef struct CLUSTER_SET_PASSWORD_STATUS {
DWORD NodeId; DWORD NodeId;
BOOLEAN SetAttempted; BOOLEAN SetAttempted;
DWORD ReturnStatus; DWORD ReturnStatus;
} CLUSTER_SET_PASSWORD_STATUS, *PCLUSTER_SET_PASSWORD_STATUS; } CLUSTER_SET_PASSWORD_STATUS, *PCLUSTER_SET_PASSWORD_STATUS;
#ifndef _CLUSTER_API_TYPES_
typedef struct _CLUSTER_IP_ENTRY
{
PCWSTR lpszIpAddress;
DWORD dwPrefixLength;
} CLUSTER_IP_ENTRY, *PCLUSTER_IP_ENTRY;
typedef struct _CREATE_CLUSTER_CONFIG
{
DWORD dwVersion;
PCWSTR lpszClusterName;
DWORD cNodes;
PCWSTR * ppszNodeNames;
DWORD cIpEntries;
PCLUSTER_IP_ENTRY pIpEntries;
PCWSTR lpszQuorumVolume;
} CREATE_CLUSTER_CONFIG, *PCREATE_CLUSTER_CONFIG;
#endif // _CLUSTER_API_TYPES_
DWORD DWORD
WINAPI WINAPI
GetNodeClusterState( GetNodeClusterState(
IN LPCWSTR lpszNodeName, __in_opt LPCWSTR lpszNodeName,
OUT DWORD *pdwClusterState __out LPDWORD pdwClusterState
);
typedef DWORD
(WINAPI * PCLUSAPI_GET_NODE_CLUSTER_STATE)(
__in_opt LPCWSTR lpszNodeName,
__out LPDWORD pdwClusterState
); );
HCLUSTER HCLUSTER
WINAPI WINAPI
OpenCluster( OpenCluster(
IN LPCWSTR lpszClusterName __in_opt LPCWSTR lpszClusterName
);
typedef HCLUSTER
(WINAPI * PCLUSAPI_OPEN_CLUSTER)(
__in_opt LPCWSTR lpszClusterName
); );
BOOL BOOL
WINAPI WINAPI
CloseCluster( CloseCluster(
IN HCLUSTER hCluster __in HCLUSTER hCluster
);
typedef BOOL
(WINAPI * PCLUSAPI_CLOSE_CLUSTER)(
__in HCLUSTER hCluster
); );
DWORD DWORD
WINAPI WINAPI
SetClusterName( SetClusterName(
IN HCLUSTER hCluster, __in HCLUSTER hCluster,
IN LPCWSTR lpszNewClusterName __in LPCWSTR lpszNewClusterName
); );
typedef DWORD
(WINAPI * PCLUSAPI_SetClusterName)(
__in HCLUSTER hCluster,
__in LPCWSTR lpszNewClusterName
);
__success(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
GetClusterInformation( GetClusterInformation(
__in HCLUSTER hCluster, __in HCLUSTER hCluster,
__out_ecount_part(*lpcchClusterName, *lpcchClusterName + 1) LPWSTR lpszClust erName, __out_ecount_part(*lpcchClusterName, *lpcchClusterName + 1) LPWSTR lpszClust erName,
__inout LPDWORD lpcchClusterName, __inout LPDWORD lpcchClusterName,
__out_opt LPCLUSTERVERSIONINFO lpClusterInfo __out_opt LPCLUSTERVERSIONINFO lpClusterInfo
); );
typedef DWORD
(WINAPI * PCLUSAPI_GET_CLUSTER_INFORMATION)(
__in HCLUSTER hCluster,
__out_ecount_part(*lpcchClusterName, *lpcchClusterName + 1) LPWSTR lpszClust
erName,
__inout LPDWORD lpcchClusterName,
__out_opt LPCLUSTERVERSIONINFO lpClusterInfo
);
__success(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
GetClusterQuorumResource( GetClusterQuorumResource(
__in HCLUSTER hCluster, __in HCLUSTER hCluster,
__out_ecount_part(*lpcchResourceName, *lpcchResourceName + 1) LPWSTR lpszRes ourceName, __out_ecount_part(*lpcchResourceName, *lpcchResourceName + 1) LPWSTR lpszRes ourceName,
__inout LPDWORD lpcchResourceName, __inout LPDWORD lpcchResourceName,
__out_ecount_part(*lpcchDeviceName, *lpcchDeviceName + 1) LPWSTR lpszDeviceN ame, __out_ecount_part(*lpcchDeviceName, *lpcchDeviceName + 1) LPWSTR lpszDeviceN ame,
__inout LPDWORD lpcchDeviceName, __inout LPDWORD lpcchDeviceName,
__out LPDWORD lpdwMaxQuorumLogSize __out LPDWORD lpdwMaxQuorumLogSize
); );
typedef DWORD
(WINAPI * PCLUSAPI_GET_CLUSTER_QUORUM_RESOURCE)(
__in HCLUSTER hCluster,
__out_ecount_part(*lpcchResourceName, *lpcchResourceName + 1) LPWSTR lpszRes
ourceName,
__inout LPDWORD lpcchResourceName,
__out_ecount_part(*lpcchDeviceName, *lpcchDeviceName + 1) LPWSTR lpszDeviceN
ame,
__inout LPDWORD lpcchDeviceName,
__out LPDWORD lpdwMaxQuorumLogSize
);
DWORD DWORD
WINAPI WINAPI
SetClusterQuorumResource( SetClusterQuorumResource(
IN HRESOURCE hResource, __in HRESOURCE hResource,
IN LPCWSTR lpszDeviceName, __in_opt LPCWSTR lpszDeviceName,
IN DWORD dwMaxQuoLogSize __in DWORD dwMaxQuoLogSize
);
typedef DWORD
(WINAPI * PCLUSAPI_SET_CLUSTER_QUORUM_RESOURCE)(
__in HRESOURCE hResource,
__in_opt LPCWSTR lpszDeviceName,
__in DWORD dwMaxQuoLogSize
); );
DWORD DWORD
WINAPI WINAPI
BackupClusterDatabase( BackupClusterDatabase(
IN HCLUSTER hCluster, __in HCLUSTER hCluster,
IN LPCWSTR lpszPathName __in LPCWSTR lpszPathName
);
typedef DWORD
(WINAPI * PCLUSAPI_BACKUP_CLUSTER_DATABASE)(
__in HCLUSTER hCluster,
__in LPCWSTR lpszPathName
); );
DWORD DWORD
WINAPI WINAPI
RestoreClusterDatabase( RestoreClusterDatabase(
IN LPCWSTR lpszPathName, __in LPCWSTR lpszPathName,
IN BOOL bForce, __in BOOL bForce,
IN OPTIONAL LPCWSTR lpszQuorumDriveLetter __in_opt LPCWSTR lpszQuorumDriveLetter
);
typedef DWORD
(WINAPI * PCLUSAPI_RESTORE_CLUSTER_DATABASE)(
__in LPCWSTR lpszPathName,
__in BOOL bForce,
__in_opt LPCWSTR lpszQuorumDriveLetter
); );
DWORD DWORD
WINAPI WINAPI
SetClusterNetworkPriorityOrder( SetClusterNetworkPriorityOrder(
IN HCLUSTER hCluster, __in HCLUSTER hCluster,
IN DWORD NetworkCount, __in DWORD NetworkCount,
IN HNETWORK NetworkList[] __in_ecount( NetworkCount ) HNETWORK NetworkList[]
);
typedef DWORD
(WINAPI * PCLUSAPI_SET_CLUSTER_NETWORK_PRIORITY_ORDER)(
__in HCLUSTER hCluster,
__in DWORD NetworkCount,
__in_ecount( NetworkCount ) HNETWORK NetworkList[]
); );
DWORD DWORD
WINAPI WINAPI
SetClusterServiceAccountPassword( SetClusterServiceAccountPassword(
__in LPCWSTR lpszClusterName, __in LPCWSTR lpszClusterName,
__in LPCWSTR lpszNewPassword, __in LPCWSTR lpszNewPassword,
__in DWORD dwFlags, __in DWORD dwFlags,
__out_bcount_part_opt(*lpcbReturnStatusBufferSize, *lpcbReturnStatusBufferSi ze) PCLUSTER_SET_PASSWORD_STATUS lpReturnStatusBuffer, __out_bcount_part_opt(*lpcbReturnStatusBufferSize, *lpcbReturnStatusBufferSi ze) PCLUSTER_SET_PASSWORD_STATUS lpReturnStatusBuffer,
__inout LPDWORD lpcbReturnStatusBufferSize __inout LPDWORD lpcbReturnStatusBufferSize
); );
typedef DWORD
(WINAPI * PCLUSAPI_SET_CLUSTER_SERVICE_ACCOUNT_PASSWORD)(
__in LPCWSTR lpszClusterName,
__in LPCWSTR lpszNewPassword,
__in DWORD dwFlags,
__out_bcount_part_opt(*lpcbReturnStatusBufferSize, *lpcbReturnStatusBufferSi
ze) PCLUSTER_SET_PASSWORD_STATUS lpReturnStatusBuffer,
__inout LPDWORD lpcbReturnStatusBufferSize
);
DWORD DWORD
WINAPI WINAPI
ClusterControl( ClusterControl(
__in HCLUSTER hCluster, __in HCLUSTER hCluster,
__in_opt HNODE hHostNode, __in_opt HNODE hHostNode,
__in DWORD dwControlCode, __in DWORD dwControlCode,
__in_bcount_opt(nInBufferSize) LPVOID lpInBuffer, __in_bcount_opt(nInBufferSize) LPVOID lpInBuffer,
__in DWORD nInBufferSize, __in DWORD nInBufferSize,
__out_bcount_part_opt(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer, __out_bcount_part_opt(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer,
__in DWORD nOutBufferSize, __in DWORD nOutBufferSize,
__out LPDWORD lpBytesReturned __out_opt LPDWORD lpBytesReturned
);
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_CONTROL)(
__in HCLUSTER hCluster,
__in_opt HNODE hHostNode,
__in DWORD dwControlCode,
__in_bcount_opt(nInBufferSize) LPVOID lpInBuffer,
__in DWORD nInBufferSize,
__out_bcount_part_opt(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer,
__in DWORD nOutBufferSize,
__out_opt LPDWORD lpBytesReturned
); );
#endif // MIDL_PASS #endif // MIDL_PASS
// //
// Cluster Event Notification API // Cluster Event Notification API
// //
#ifndef _CLUSTER_API_TYPES_ #ifndef _CLUSTER_API_TYPES_
// //
skipping to change at line 390 skipping to change at line 521
CLUSTER_CHANGE_QUORUM_STATE | CLUSTER_CHANGE_QUORUM_STATE |
CLUSTER_CHANGE_CLUSTER_STATE | CLUSTER_CHANGE_CLUSTER_STATE |
CLUSTER_CHANGE_CLUSTER_PROPERTY | CLUSTER_CHANGE_CLUSTER_PROPERTY |
CLUSTER_CHANGE_CLUSTER_RECONNECT | CLUSTER_CHANGE_CLUSTER_RECONNECT |
CLUSTER_CHANGE_HANDLE_CLOSE) CLUSTER_CHANGE_HANDLE_CLOSE)
} CLUSTER_CHANGE; } CLUSTER_CHANGE;
#endif // _CLUSTER_API_TYPES_ #endif // _CLUSTER_API_TYPES_
#ifndef MIDL_PASS #if ( !MIDL_PASS && !__midl )
HCHANGE HCHANGE
WINAPI WINAPI
CreateClusterNotifyPort( CreateClusterNotifyPort(
IN OPTIONAL HCHANGE hChange, __in HCHANGE hChange,
IN OPTIONAL HCLUSTER hCluster, __in HCLUSTER hCluster,
IN DWORD dwFilter, __in DWORD dwFilter,
IN DWORD_PTR dwNotifyKey __in DWORD_PTR dwNotifyKey
);
typedef HCHANGE
(WINAPI * PCLUSAPI_CREATE_CLUSTER_NOTIFY_PORT)(
__in HCHANGE hChange,
__in HCLUSTER hCluster,
__in DWORD dwFilter,
__in DWORD_PTR dwNotifyKey
); );
DWORD DWORD
WINAPI WINAPI
RegisterClusterNotify( RegisterClusterNotify(
IN HCHANGE hChange, __in HCHANGE hChange,
IN DWORD dwFilterType, __in DWORD dwFilterType,
IN HANDLE hObject, __in HANDLE hObject,
IN DWORD_PTR dwNotifyKey __in DWORD_PTR dwNotifyKey
); );
typedef DWORD
(WINAPI * PCLUSAPI_REGISTER_CLUSTER_NOTIFY)(
__in HCHANGE hChange,
__in DWORD dwFilterType,
__in HANDLE hObject,
__in DWORD_PTR dwNotifyKey
);
__success(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
GetClusterNotify( GetClusterNotify(
__in HCHANGE hChange, __in HCHANGE hChange,
__out DWORD_PTR *lpdwNotifyKey, __out DWORD_PTR *lpdwNotifyKey,
__out LPDWORD lpdwFilterType, __out LPDWORD lpdwFilterType,
__out_ecount(*lpcchName) LPWSTR lpszName,
__inout LPDWORD lpcchName,
__in DWORD dwMilliseconds
);
typedef DWORD
(WINAPI * PCLUSAPI_GET_CLUSTER_NOTIFY)(
__in HCHANGE hChange,
__out DWORD_PTR *lpdwNotifyKey,
__out LPDWORD lpdwFilterType,
__out_ecount_part_opt(*lpcchName, *lpcchName + 1) LPWSTR lpszName, __out_ecount_part_opt(*lpcchName, *lpcchName + 1) LPWSTR lpszName,
__inout LPDWORD lpcchName, __inout LPDWORD lpcchName,
__in DWORD dwMilliseconds __in DWORD dwMilliseconds
); );
BOOL BOOL
WINAPI WINAPI
CloseClusterNotifyPort( CloseClusterNotifyPort(
IN HCHANGE hChange __in HCHANGE hChange
); );
typedef BOOL
(WINAPI * PCLUSAPI_CLOSE_CLUSTER_NOTIFY_PORT)(
__in HCHANGE hChange
);
#endif // MIDL_PASS #endif // MIDL_PASS
// //
// Enumeration routines // Enumeration routines
// //
#ifndef _CLUSTER_API_TYPES_ #ifndef _CLUSTER_API_TYPES_
// //
// Define enumerable types // Define enumerable types
// //
skipping to change at line 455 skipping to change at line 619
CLUSTER_ENUM_RESTYPE | CLUSTER_ENUM_RESTYPE |
CLUSTER_ENUM_RESOURCE | CLUSTER_ENUM_RESOURCE |
CLUSTER_ENUM_GROUP | CLUSTER_ENUM_GROUP |
CLUSTER_ENUM_NETWORK | CLUSTER_ENUM_NETWORK |
CLUSTER_ENUM_NETINTERFACE) CLUSTER_ENUM_NETINTERFACE)
} CLUSTER_ENUM; } CLUSTER_ENUM;
#endif // _CLUSTER_API_TYPES_ #endif // _CLUSTER_API_TYPES_
#ifndef MIDL_PASS #if ( !MIDL_PASS && !__midl )
HCLUSENUM HCLUSENUM
WINAPI WINAPI
ClusterOpenEnum( ClusterOpenEnum(
IN HCLUSTER hCluster, __in HCLUSTER hCluster,
IN DWORD dwType __in DWORD dwType
);
typedef HCLUSENUM
(WINAPI * PCLUSAPI_CLUSTER_OPEN_ENUM)(
__in HCLUSTER hCluster,
__in DWORD dwType
); );
DWORD DWORD
WINAPI WINAPI
ClusterGetEnumCount( ClusterGetEnumCount(
IN HCLUSENUM hEnum __in HCLUSENUM hEnum
); );
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_GET_ENUM_COUNT)(
__in HCLUSENUM hEnum
);
__success(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
ClusterEnum( ClusterEnum(
__in HCLUSENUM hEnum, __in HCLUSENUM hEnum,
__in DWORD dwIndex, __in DWORD dwIndex,
__out LPDWORD lpdwType, __out LPDWORD lpdwType,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszName, __out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszName,
__inout LPDWORD lpcchName __inout LPDWORD lpcchName
); );
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_ENUM)(
__in HCLUSENUM hEnum,
__in DWORD dwIndex,
__out LPDWORD lpdwType,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszName,
__inout LPDWORD lpcchName
);
DWORD DWORD
WINAPI WINAPI
ClusterCloseEnum( ClusterCloseEnum(
IN HCLUSENUM hEnum __in HCLUSENUM hEnum
); );
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_CLOSE_ENUM)(
__in HCLUSENUM hEnum
);
#endif // MIDL_PASS #endif // MIDL_PASS
#ifndef _CLUSTER_API_TYPES_ #ifndef _CLUSTER_API_TYPES_
// //
// Define enumerable node types // Define enumerable node types
// //
typedef enum CLUSTER_NODE_ENUM { typedef enum CLUSTER_NODE_ENUM {
CLUSTER_NODE_ENUM_NETINTERFACES = 0x00000001, CLUSTER_NODE_ENUM_NETINTERFACES = 0x00000001,
CLUSTER_NODE_ENUM_ALL = (CLUSTER_NODE_ENUM_NETINTERFACES) CLUSTER_NODE_ENUM_ALL = (CLUSTER_NODE_ENUM_NETINTERFACES)
skipping to change at line 514 skipping to change at line 705
ClusterNodePaused, ClusterNodePaused,
ClusterNodeJoining ClusterNodeJoining
} CLUSTER_NODE_STATE; } CLUSTER_NODE_STATE;
#endif // _CLUSTER_API_TYPES_ #endif // _CLUSTER_API_TYPES_
// //
// Interfaces for managing the nodes of a cluster. // Interfaces for managing the nodes of a cluster.
// //
#ifndef MIDL_PASS #if ( !MIDL_PASS && !__midl )
HNODE HNODE
WINAPI WINAPI
OpenClusterNode( OpenClusterNode(
IN HCLUSTER hCluster, __in HCLUSTER hCluster,
IN LPCWSTR lpszNodeName __in LPCWSTR lpszNodeName
);
typedef HNODE
(WINAPI * PCLUSAPI_OPEN_CLUSTER_NODE)(
__in HCLUSTER hCluster,
__in LPCWSTR lpszNodeName
); );
BOOL BOOL
WINAPI WINAPI
CloseClusterNode( CloseClusterNode(
IN HNODE hNode __in HNODE hNode
);
typedef BOOL
(WINAPI * PCLUSAPI_CLOSE_CLUSTER_NODE)(
__in HNODE hNode
); );
CLUSTER_NODE_STATE CLUSTER_NODE_STATE
WINAPI WINAPI
GetClusterNodeState( GetClusterNodeState(
IN HNODE hNode __in HNODE hNode
);
typedef CLUSTER_NODE_STATE
(WINAPI * PCLUSAPI_GET_CLUSTER_NODE_STATE)(
__in HNODE hNode
); );
__success(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
GetClusterNodeId( GetClusterNodeId(
__in HNODE hNode, __in HNODE hNode,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszNodeId, __out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszNodeId,
__inout LPDWORD lpcchName __inout LPDWORD lpcchName
); );
typedef DWORD
(WINAPI * PCLUSAPI_GET_CLUSTER_NODE_ID)(
__in HNODE hNode,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszNodeId,
__inout LPDWORD lpcchName
);
#define GetCurrentClusterNodeId(_lpszNodeId_, _lpcchName_) \ #define GetCurrentClusterNodeId(_lpszNodeId_, _lpcchName_) \
GetClusterNodeId(NULL, (_lpszNodeId_), (_lpcchName_)) GetClusterNodeId(NULL, (_lpszNodeId_), (_lpcchName_))
HCLUSTER HCLUSTER
WINAPI WINAPI
GetClusterFromNode( GetClusterFromNode(
IN HNODE hNode __in HNODE hNode
);
typedef HCLUSTER
(WINAPI * PCLUSAPI_GET_CLUSTER_FROM_NODE)(
__in HNODE hNode
); );
DWORD DWORD
WINAPI WINAPI
PauseClusterNode( PauseClusterNode(
IN HNODE hNode __in HNODE hNode
);
typedef DWORD
(WINAPI * PCLUSAPI_PAUSE_CLUSTER_NODE)(
__in HNODE hNode
); );
DWORD DWORD
WINAPI WINAPI
ResumeClusterNode( ResumeClusterNode(
IN HNODE hNode __in HNODE hNode
);
typedef DWORD
(WINAPI * PCLUSAPI_RESUME_CLUSTER_NODE)(
__in HNODE hNode
); );
DWORD DWORD
WINAPI WINAPI
EvictClusterNode( EvictClusterNode(
IN HNODE hNode __in HNODE hNode
);
typedef DWORD
(WINAPI * PCLUSAPI_EVICT_CLUSTER_NODE)(
__in HNODE hNode
); );
HNODEENUM HNODEENUM
WINAPI WINAPI
ClusterNodeOpenEnum( ClusterNodeOpenEnum(
IN HNODE hNode, __in HNODE hNode,
IN DWORD dwType __in DWORD dwType
);
typedef HNODEENUM
(WINAPI * PCLUSAPI_CLUSTER_NODE_OPEN_ENUM)(
__in HNODE hNode,
__in DWORD dwType
); );
DWORD DWORD
WINAPI WINAPI
ClusterNodeGetEnumCount( ClusterNodeGetEnumCount(
IN HNODEENUM hNodeEnum __in HNODEENUM hNodeEnum
);
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_NODE_GET_ENUM_COUNT)(
__in HNODEENUM hNodeEnum
); );
DWORD DWORD
WINAPI WINAPI
ClusterNodeCloseEnum( ClusterNodeCloseEnum(
IN HNODEENUM hNodeEnum __in HNODEENUM hNodeEnum
); );
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_NODE_CLOSE_ENUM)(
__in HNODEENUM hNodeEnum
);
__success(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
ClusterNodeEnum( ClusterNodeEnum(
__in HNODEENUM hNodeEnum, __in HNODEENUM hNodeEnum,
__in DWORD dwIndex, __in DWORD dwIndex,
__out LPDWORD lpdwType, __out LPDWORD lpdwType,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszName, __out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszName,
__inout LPDWORD lpcchName __inout LPDWORD lpcchName
); );
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_NODE_ENUM)(
__in HNODEENUM hNodeEnum,
__in DWORD dwIndex,
__out LPDWORD lpdwType,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszName,
__inout LPDWORD lpcchName
);
DWORD DWORD
WINAPI WINAPI
EvictClusterNodeEx( EvictClusterNodeEx(
IN HNODE hNode, __in HNODE hNode,
IN DWORD dwTimeOut, __in DWORD dwTimeOut,
OUT HRESULT* phrCleanupStatus __out HRESULT * phrCleanupStatus
);
typedef DWORD
(WINAPI * PCLUSAPI_EVICT_CLUSTER_NODE_EX)(
__in HNODE hNode,
__in DWORD dwTimeOut,
__out HRESULT * phrCleanupStatus
); );
#endif // MIDL_PASS #endif // MIDL_PASS
// //
// Interfaces for managing the resource types in a cluster // Interfaces for managing the resource types in a cluster
// //
#ifndef MIDL_PASS #if ( !MIDL_PASS && !__midl )
HKEY HKEY
WINAPI WINAPI
GetClusterResourceTypeKey( GetClusterResourceTypeKey(
IN HCLUSTER hCluster, __in HCLUSTER hCluster,
IN LPCWSTR lpszTypeName, __in LPCWSTR lpszTypeName,
IN REGSAM samDesired __in REGSAM samDesired
); );
typedef HKEY
(WINAPI * PCLUSAPI_GET_CLUSTER_RESOURCE_TYPE_KEY)(
__in HCLUSTER hCluster,
__in LPCWSTR lpszTypeName,
__in REGSAM samDesired
);
#endif // MIDL_PASS #endif // MIDL_PASS
#ifndef _CLUSTER_API_TYPES_ #ifndef _CLUSTER_API_TYPES_
// //
// Define enumerable group types // Define enumerable group types
// //
typedef enum CLUSTER_GROUP_ENUM { typedef enum CLUSTER_GROUP_ENUM {
CLUSTER_GROUP_ENUM_CONTAINS = 0x00000001, CLUSTER_GROUP_ENUM_CONTAINS = 0x00000001,
CLUSTER_GROUP_ENUM_NODES = 0x00000002, CLUSTER_GROUP_ENUM_NODES = 0x00000002,
skipping to change at line 655 skipping to change at line 931
typedef enum CLUSTER_GROUP_AUTOFAILBACK_TYPE typedef enum CLUSTER_GROUP_AUTOFAILBACK_TYPE
{ {
ClusterGroupPreventFailback = 0, ClusterGroupPreventFailback = 0,
ClusterGroupAllowFailback, ClusterGroupAllowFailback,
ClusterGroupFailbackTypeCount ClusterGroupFailbackTypeCount
} CLUSTER_GROUP_AUTOFAILBACK_TYPE, CGAFT; } CLUSTER_GROUP_AUTOFAILBACK_TYPE, CGAFT;
#endif // _CLUSTER_API_TYPES_ #endif // _CLUSTER_API_TYPES_
#ifndef MIDL_PASS #if ( !MIDL_PASS && !__midl )
HGROUP HGROUP
WINAPI WINAPI
CreateClusterGroup( CreateClusterGroup(
IN HCLUSTER hCluster, __in HCLUSTER hCluster,
IN LPCWSTR lpszGroupName __in LPCWSTR lpszGroupName
);
typedef HGROUP
(WINAPI * PCLUSAPI_CREATE_CLUSTER_GROUP)(
__in HCLUSTER hCluster,
__in LPCWSTR lpszGroupName
); );
HGROUP HGROUP
WINAPI WINAPI
OpenClusterGroup( OpenClusterGroup(
IN HCLUSTER hCluster, __in HCLUSTER hCluster,
IN LPCWSTR lpszGroupName __in LPCWSTR lpszGroupName
);
typedef HGROUP
(WINAPI * PCLUSAPI_OPEN_CLUSTER_GROUP)(
__in HCLUSTER hCluster,
__in LPCWSTR lpszGroupName
); );
BOOL BOOL
WINAPI WINAPI
CloseClusterGroup( CloseClusterGroup(
IN HGROUP hGroup __in HGROUP hGroup
);
typedef BOOL
(WINAPI * PCLUSAPI_CLOSE_CLUSTER_GROUP)(
__in HGROUP hGroup
); );
HCLUSTER HCLUSTER
WINAPI WINAPI
GetClusterFromGroup( GetClusterFromGroup(
IN HGROUP hGroup __in HGROUP hGroup
); );
typedef HCLUSTER
(WINAPI * PCLUSAPI_GET_CLUSTER_FROM_GROUP)(
__in HGROUP hGroup
);
__success(return >= 0) //!= ClusterGroupStateUnknown
CLUSTER_GROUP_STATE CLUSTER_GROUP_STATE
WINAPI WINAPI
GetClusterGroupState( GetClusterGroupState(
__in HGROUP hGroup, __in HGROUP hGroup,
__out_ecount_part_opt(*lpcchNodeName, *lpcchNodeName + 1) LPWSTR lpszNodeNam e, __out_ecount_part_opt(*lpcchNodeName, *lpcchNodeName + 1) LPWSTR lpszNodeNam e,
__inout LPDWORD lpcchNodeName __inout_opt LPDWORD lpcchNodeName
);
typedef CLUSTER_GROUP_STATE
(WINAPI * PCLUSAPI_GET_CLUSTER_GROUP_STATE)(
__in HGROUP hGroup,
__out_ecount_part_opt(*lpcchNodeName, *lpcchNodeName + 1) LPWSTR lpszNodeNam
e,
__inout_opt LPDWORD lpcchNodeName
); );
DWORD DWORD
WINAPI WINAPI
SetClusterGroupName( SetClusterGroupName(
IN HGROUP hGroup, __in HGROUP hGroup,
IN LPCWSTR lpszGroupName __in LPCWSTR lpszGroupName
);
typedef DWORD
(WINAPI * PCLUSAPI_SET_CLUSTER_GROUP_NAME)(
HGROUP hGroup,
LPCWSTR lpszGroupName
); );
DWORD DWORD
WINAPI WINAPI
SetClusterGroupNodeList( SetClusterGroupNodeList(
IN HGROUP hGroup, __in HGROUP hGroup,
IN DWORD NodeCount, __in DWORD NodeCount,
IN HNODE NodeList[] __in_ecount( NodeCount ) HNODE NodeList[]
);
typedef DWORD
(WINAPI * PCLUSAPI_SET_CLUSTER_GROUP_NODE_LIST)(
__in HGROUP hGroup,
__in DWORD NodeCount,
__in_ecount( NodeCount ) HNODE NodeList[]
); );
DWORD DWORD
WINAPI WINAPI
OnlineClusterGroup( OnlineClusterGroup(
IN HGROUP hGroup, __in HGROUP hGroup,
IN OPTIONAL HNODE hDestinationNode __in_opt HNODE hDestinationNode
);
typedef DWORD
(WINAPI * PCLUSAPI_ONLINE_CLUSTER_GROUP)(
__in HGROUP hGroup,
__in_opt HNODE hDestinationNode
); );
DWORD DWORD
WINAPI WINAPI
MoveClusterGroup( MoveClusterGroup(
IN HGROUP hGroup, __in HGROUP hGroup,
IN OPTIONAL HNODE hDestinationNode __in_opt HNODE hDestinationNode
);
typedef DWORD
(WINAPI * PCLUSAPI_MOVE_CLUSTER_GROUP)(
__in HGROUP hGroup,
__in_opt HNODE hDestinationNode
); );
DWORD DWORD
WINAPI WINAPI
OfflineClusterGroup( OfflineClusterGroup(
IN HGROUP hGroup __in HGROUP hGroup
);
typedef DWORD
(WINAPI * PCLUSAPI_OFFLINE_CLUSTER_GROUP)(
HGROUP hGroup
); );
DWORD DWORD
WINAPI WINAPI
DeleteClusterGroup( DeleteClusterGroup(
IN HGROUP hGroup __in HGROUP hGroup
);
typedef DWORD
(WINAPI * PCLUSAPI_DELETE_CLUSTER_GROUP)(
HGROUP hGroup
); );
HGROUPENUM HGROUPENUM
WINAPI WINAPI
ClusterGroupOpenEnum( ClusterGroupOpenEnum(
IN HGROUP hGroup, __in HGROUP hGroup,
IN DWORD dwType __in DWORD dwType
);
typedef HGROUPENUM
(WINAPI * PCLUSAPI_CLUSTER_GROUP_OPEN_ENUM)(
HGROUP hGroup,
DWORD dwType
); );
DWORD DWORD
WINAPI WINAPI
ClusterGroupGetEnumCount( ClusterGroupGetEnumCount(
IN HGROUPENUM hGroupEnum __in HGROUPENUM hGroupEnum
);
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_GROUP_GET_ENUM_COUNT)(
__in HGROUPENUM hGroupEnum
); );
__success(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
ClusterGroupEnum( ClusterGroupEnum(
__in HGROUPENUM hGroupEnum, __in HGROUPENUM hGroupEnum,
__in DWORD dwIndex, __in DWORD dwIndex,
__out LPDWORD lpdwType, __out LPDWORD lpdwType,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszResourceName, __out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszResourceName,
__inout LPDWORD lpcchName __inout LPDWORD lpcchName
); );
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_GROUP_ENUM)(
__in HGROUPENUM hGroupEnum,
__in DWORD dwIndex,
__out LPDWORD lpdwType,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszResourceName,
__inout LPDWORD lpcchName
);
DWORD DWORD
WINAPI WINAPI
ClusterGroupCloseEnum( ClusterGroupCloseEnum(
IN HGROUPENUM hGroupEnum __in HGROUPENUM hGroupEnum
);
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_GROUP_CLOSE_ENUM)(
HGROUPENUM hGroupEnum
); );
#endif // MIDL_PASS #endif // MIDL_PASS
// //
// Definitions used in resource management routines. // Definitions used in resource management routines.
// //
#ifndef _CLUSTER_API_TYPES_ #ifndef _CLUSTER_API_TYPES_
// //
// Resource-related structures and types // Resource-related structures and types
// //
skipping to change at line 785 skipping to change at line 1153
ClusterResourceFailed, ClusterResourceFailed,
ClusterResourcePending = 128, ClusterResourcePending = 128,
ClusterResourceOnlinePending, ClusterResourceOnlinePending,
ClusterResourceOfflinePending ClusterResourceOfflinePending
} CLUSTER_RESOURCE_STATE; } CLUSTER_RESOURCE_STATE;
typedef enum CLUSTER_RESOURCE_RESTART_ACTION { typedef enum CLUSTER_RESOURCE_RESTART_ACTION {
ClusterResourceDontRestart = 0, ClusterResourceDontRestart = 0,
ClusterResourceRestartNoNotify, ClusterResourceRestartNoNotify,
ClusterResourceRestartNotify, ClusterResourceRestartNotify,
ClusterResourceRestartNotifyIfNotInORexpression,
ClusterResourceRestartActionCount ClusterResourceRestartActionCount
} CLUSTER_RESOURCE_RESTART_ACTION, CRRA; } CLUSTER_RESOURCE_RESTART_ACTION, CRRA;
// //
// Flags for resource creation // Flags for resource creation
// //
typedef enum CLUSTER_RESOURCE_CREATE_FLAGS { typedef enum CLUSTER_RESOURCE_CREATE_FLAGS {
CLUSTER_RESOURCE_DEFAULT_MONITOR = 0, CLUSTER_RESOURCE_DEFAULT_MONITOR = 0,
CLUSTER_RESOURCE_SEPARATE_MONITOR = 1, CLUSTER_RESOURCE_SEPARATE_MONITOR = 1,
CLUSTER_RESOURCE_VALID_FLAGS = CLUSTER_RESOURCE_SEPARATE_MONITOR CLUSTER_RESOURCE_VALID_FLAGS = CLUSTER_RESOURCE_SEPARATE_MONITOR
} CLUSTER_RESOURCE_CREATE_FLAGS; } CLUSTER_RESOURCE_CREATE_FLAGS;
#endif // _CLUSTER_API_TYPES_ #endif // _CLUSTER_API_TYPES_
// //
// Interfaces for managing the resources in a cluster // Interfaces for managing the resources in a cluster
// //
#ifndef MIDL_PASS #if ( !MIDL_PASS && !__midl )
HRESOURCE HRESOURCE
WINAPI WINAPI
CreateClusterResource( CreateClusterResource(
IN HGROUP hGroup, __in HGROUP hGroup,
IN LPCWSTR lpszResourceName, __in LPCWSTR lpszResourceName,
IN LPCWSTR lpszResourceType, __in LPCWSTR lpszResourceType,
IN DWORD dwFlags __in DWORD dwFlags
);
typedef HRESOURCE
(WINAPI * PCLUSAPI_CREATE_CLUSTER_RESOURCE)(
HGROUP hGroup,
LPCWSTR lpszResourceName,
LPCWSTR lpszResourceType,
DWORD dwFlags
); );
HRESOURCE HRESOURCE
WINAPI WINAPI
OpenClusterResource( OpenClusterResource(
IN HCLUSTER hCluster, __in HCLUSTER hCluster,
IN LPCWSTR lpszResourceName __in LPCWSTR lpszResourceName
);
typedef HRESOURCE
(WINAPI * PCLUSAPI_OPEN_CLUSTER_RESOURCE)(
HCLUSTER hCluster,
LPCWSTR lpszResourceName
); );
BOOL BOOL
WINAPI WINAPI
CloseClusterResource( CloseClusterResource(
IN HRESOURCE hResource __in HRESOURCE hResource
);
typedef BOOL
(WINAPI * PCLUSAPI_CLOSE_CLUSTER_RESOURCE)(
HRESOURCE hResource
); );
HCLUSTER HCLUSTER
WINAPI WINAPI
GetClusterFromResource( GetClusterFromResource(
IN HRESOURCE hResource __in HRESOURCE hResource
);
typedef HCLUSTER
(WINAPI * PCLUSAPI_GET_CLUSTER_FROM_RESOURCE)(
__in HRESOURCE hResource
); );
DWORD DWORD
WINAPI WINAPI
DeleteClusterResource( DeleteClusterResource(
IN HRESOURCE hResource __in HRESOURCE hResource
); );
typedef DWORD
(WINAPI * PCLUSAPI_DELETE_CLUSTER_RESOURCE)(
HRESOURCE hResource
);
__success(return >= 0) // != ClusterResourceStateUnknown
CLUSTER_RESOURCE_STATE CLUSTER_RESOURCE_STATE
WINAPI WINAPI
GetClusterResourceState( GetClusterResourceState(
__in HRESOURCE hResource, __in HRESOURCE hResource,
__out_ecount_part_opt(*lpcchNodeName, *lpcchNodeName + 1) LPWSTR lpszNodeNam e, __out_ecount_part_opt(*lpcchNodeName, *lpcchNodeName + 1) LPWSTR lpszNodeNam e,
__inout LPDWORD lpcchNodeName, __inout_opt LPDWORD lpcchNodeName,
__out_ecount_part_opt(*lpcchGroupName, *lpcchGroupName + 1) LPWSTR lpszGroup Name, __out_ecount_part_opt(*lpcchGroupName, *lpcchGroupName + 1) LPWSTR lpszGroup Name,
__inout LPDWORD lpcchGroupName __inout_opt LPDWORD lpcchGroupName
);
typedef CLUSTER_RESOURCE_STATE
(WINAPI * PCLUSAPI_GET_CLUSTER_RESOURCE_STATE)(
__in HRESOURCE hResource,
__out_ecount_part_opt(*lpcchNodeName, *lpcchNodeName + 1) LPWSTR lpszNodeNam
e,
__inout_opt LPDWORD lpcchNodeName,
__out_ecount_part_opt(*lpcchGroupName, *lpcchGroupName + 1) LPWSTR lpszGroup
Name,
__inout_opt LPDWORD lpcchGroupName
); );
DWORD DWORD
WINAPI WINAPI
SetClusterResourceName( SetClusterResourceName(
IN HRESOURCE hResource, __in HRESOURCE hResource,
IN LPCWSTR lpszResourceName __in LPCWSTR lpszResourceName
);
typedef DWORD
(WINAPI * PCLUSAPI_SET_CLUSTER_RESOURCE_NAME)(
HRESOURCE hResource,
LPCWSTR lpszResourceName
); );
DWORD DWORD
WINAPI WINAPI
FailClusterResource( FailClusterResource(
IN HRESOURCE hResource __in HRESOURCE hResource
);
typedef DWORD
(WINAPI * PCLUSAPI_FAIL_CLUSTER_RESOURCE)(
HRESOURCE hResource
); );
DWORD DWORD
WINAPI WINAPI
OnlineClusterResource( OnlineClusterResource(
IN HRESOURCE hResource __in HRESOURCE hResource
);
typedef DWORD
(WINAPI * PCLUSAPI_ONLINE_CLUSTER_RESOURCE)(
HRESOURCE hResource
); );
DWORD DWORD
WINAPI WINAPI
OfflineClusterResource( OfflineClusterResource(
IN HRESOURCE hResource __in HRESOURCE hResource
);
typedef DWORD
(WINAPI * PCLUSAPI_OFFLINE_CLUSTER_RESOURCE)(
HRESOURCE hResource
); );
DWORD DWORD
WINAPI WINAPI
ChangeClusterResourceGroup( ChangeClusterResourceGroup(
IN HRESOURCE hResource, __in HRESOURCE hResource,
IN HGROUP hGroup __in HGROUP hGroup
);
typedef DWORD
(WINAPI * PCLUSAPI_CHANGE_CLUSTER_RESOURCE_GROUP)(
HRESOURCE hResource,
HGROUP hGroup
); );
DWORD DWORD
WINAPI WINAPI
AddClusterResourceNode( AddClusterResourceNode(
IN HRESOURCE hResource, __in HRESOURCE hResource,
IN HNODE hNode __in HNODE hNode
);
typedef DWORD
(WINAPI * PCLUSAPI_ADD_CLUSTER_RESOURCE_NODE)(
HRESOURCE hResource,
HNODE hNode
); );
DWORD DWORD
WINAPI WINAPI
RemoveClusterResourceNode( RemoveClusterResourceNode(
IN HRESOURCE hResource, __in HRESOURCE hResource,
IN HNODE hNode __in HNODE hNode
);
typedef DWORD
(WINAPI * PCLUSAPI_REMOVE_CLUSTER_RESOURCE_NODE)(
HRESOURCE hResource,
HNODE hNode
); );
DWORD DWORD
WINAPI WINAPI
AddClusterResourceDependency( AddClusterResourceDependency(
IN HRESOURCE hResource, __in HRESOURCE hResource,
IN HRESOURCE hDependsOn __in HRESOURCE hDependsOn
);
typedef DWORD
(WINAPI * PCLUSAPI_ADD_CLUSTER_RESOURCE_DEPENDENCY)(
HRESOURCE hResource,
HRESOURCE hDependsOn
); );
DWORD DWORD
WINAPI WINAPI
RemoveClusterResourceDependency( RemoveClusterResourceDependency(
IN HRESOURCE hResource, __in HRESOURCE hResource,
IN HRESOURCE hDependsOn __in HRESOURCE hDependsOn
);
typedef DWORD
(WINAPI * PCLUSAPI_REMOVE_CLUSTER_RESOURCE_DEPENDENCY)(
HRESOURCE hResource,
HRESOURCE hDependsOn
);
DWORD
WINAPI
SetClusterResourceDependencyExpression(
__in HRESOURCE hResource,
__in LPCWSTR lpszDependencyExpression
);
typedef DWORD
(WINAPI * PCLUSAPI_SET_CLUSTER_RESOURCE_DEPENDENCY_EXPRESSION)(
__in HRESOURCE hResource,
__in LPCWSTR lpszDependencyExpression
);
__success(return == ERROR_SUCCESS)
DWORD
WINAPI
GetClusterResourceDependencyExpression(
__in HRESOURCE hResource,
__out_ecount_part_opt(*lpcchDependencyExpression, *lpcchDependencyExpression
+ 1)
LPWSTR lpszDependencyExpression,
__inout LPDWORD lpcchDependencyExpression
);
typedef DWORD
(WINAPI * PCLUSAPI_GET_CLUSTER_RESOURCE_DEPENDENCY_EXPRESSION)(
__in HRESOURCE hResource,
__out_ecount_part_opt(*lpcchDependencyExpression, *lpcchDependencyExpression
+ 1)
LPWSTR lpszDependencyExpression,
__inout LPDWORD lpcchDependencyExpression
); );
BOOL BOOL
WINAPI WINAPI
CanResourceBeDependent( CanResourceBeDependent(
IN HRESOURCE hResource, __in HRESOURCE hResource,
IN HRESOURCE hResourceDependent __in HRESOURCE hResourceDependent
); );
typedef BOOL
(WINAPI * PCLUSAPI_CAN_RESOURCE_BE_DEPENDENT)(
HRESOURCE hResource,
HRESOURCE hResourceDependent
);
__success(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
ClusterResourceControl( ClusterResourceControl(
__in HRESOURCE hResource, __in HRESOURCE hResource,
__in_opt HNODE hHostNode, __in_opt HNODE hHostNode,
__in DWORD dwControlCode, __in DWORD dwControlCode,
__in_bcount_opt(cbInBufferSize) LPVOID lpInBuffer, __in_bcount_opt(cbInBufferSize) LPVOID lpInBuffer,
__in DWORD cbInBufferSize, __in DWORD cbInBufferSize,
__out_bcount_part_opt(cbOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer, __out_bcount_part_opt(cbOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer,
__in DWORD cbOutBufferSize, __in DWORD cbOutBufferSize,
__out LPDWORD lpBytesReturned __out_opt LPDWORD lpBytesReturned
);
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_RESOURCE_CONTROL)(
__in HRESOURCE hResource,
__in_opt HNODE hHostNode,
__in DWORD dwControlCode,
__in_bcount_opt(cbInBufferSize) LPVOID lpInBuffer,
__in DWORD cbInBufferSize,
__out_bcount_part_opt(cbOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer,
__in DWORD cbOutBufferSize,
__out_opt LPDWORD lpBytesReturned
); );
__success(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
ClusterResourceTypeControl( ClusterResourceTypeControl(
__in HCLUSTER hCluster, __in HCLUSTER hCluster,
__in LPCWSTR lpszResourceTypeName, __in LPCWSTR lpszResourceTypeName,
__in_opt HNODE hHostNode, __in_opt HNODE hHostNode,
__in DWORD dwControlCode, __in DWORD dwControlCode,
__in_bcount_opt(nInBufferSize) LPVOID lpInBuffer, __in_bcount_opt(nInBufferSize) LPVOID lpInBuffer,
__in DWORD nInBufferSize, __in DWORD nInBufferSize,
__out_bcount_part_opt(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer, __out_bcount_part_opt(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer,
__in DWORD nOutBufferSize, __in DWORD nOutBufferSize,
__out LPDWORD lpBytesReturned __out_opt LPDWORD lpBytesReturned
); );
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_RESOURCE_TYPE_CONTROL)(
__in HCLUSTER hCluster,
__in LPCWSTR lpszResourceTypeName,
__in_opt HNODE hHostNode,
__in DWORD dwControlCode,
__in_bcount_opt(nInBufferSize) LPVOID lpInBuffer,
__in DWORD nInBufferSize,
__out_bcount_part_opt(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer,
__in DWORD nOutBufferSize,
__out_opt LPDWORD lpBytesReturned
);
__success(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
ClusterGroupControl( ClusterGroupControl(
__in HGROUP hGroup, __in HGROUP hGroup,
__in_opt HNODE hHostNode, __in_opt HNODE hHostNode,
__in DWORD dwControlCode, __in DWORD dwControlCode,
__in_bcount_opt(nInBufferSize) LPVOID lpInBuffer, __in_bcount_opt(nInBufferSize) LPVOID lpInBuffer,
__in DWORD nInBufferSize, __in DWORD nInBufferSize,
__out_bcount_part_opt(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer, __out_bcount_part_opt(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer,
__in DWORD nOutBufferSize, __in DWORD nOutBufferSize,
__out LPDWORD lpBytesReturned __out_opt LPDWORD lpBytesReturned
); );
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_GROUP_CONTROL)(
__in HGROUP hGroup,
__in_opt HNODE hHostNode,
__in DWORD dwControlCode,
__in_bcount_opt(nInBufferSize) LPVOID lpInBuffer,
__in DWORD nInBufferSize,
__out_bcount_part_opt(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer,
__in DWORD nOutBufferSize,
__out_opt LPDWORD lpBytesReturned
);
__success(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
ClusterNodeControl( ClusterNodeControl(
__in HNODE hNode, __in HNODE hNode,
__in_opt HNODE hHostNode, __in_opt HNODE hHostNode,
__in DWORD dwControlCode, __in DWORD dwControlCode,
__in_bcount_opt(nInBufferSize) LPVOID lpInBuffer, __in_bcount_opt(nInBufferSize) LPVOID lpInBuffer,
__in DWORD nInBufferSize, __in DWORD nInBufferSize,
__out_bcount_part_opt(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer, __out_bcount_part_opt(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer,
__in DWORD nOutBufferSize, __in DWORD nOutBufferSize,
__out LPDWORD lpBytesReturned __out_opt LPDWORD lpBytesReturned
);
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_NODE_CONTROL)(
__in HNODE hNode,
__in_opt HNODE hHostNode,
__in DWORD dwControlCode,
__in_bcount_opt(nInBufferSize) LPVOID lpInBuffer,
__in DWORD nInBufferSize,
__out_bcount_part_opt(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer,
__in DWORD nOutBufferSize,
__out_opt LPDWORD lpBytesReturned
); );
BOOL BOOL
WINAPI WINAPI
GetClusterResourceNetworkName( GetClusterResourceNetworkName(
__in HRESOURCE hResource, __in HRESOURCE hResource,
__out_ecount_part(*nSize, *nSize + 1) LPWSTR lpBuffer, __out_ecount_part(*nSize, *nSize + 1) LPWSTR lpBuffer,
__inout LPDWORD nSize __inout LPDWORD nSize
); );
typedef BOOL
(WINAPI * PCLUSAPI_GET_CLUSTER_RESOURCE_NETWORK_NAME)(
__in HRESOURCE hResource,
__out_ecount_part(*nSize, *nSize + 1) LPWSTR lpBuffer,
__inout LPDWORD nSize
);
#endif // MIDL_PASS #endif // MIDL_PASS
// //
// Cluster control properties // Cluster control properties
// //
#ifndef _CLUSTER_API_TYPES_ #ifndef _CLUSTER_API_TYPES_
// //
// Cluster Control Property Data - Types (a WORD) // Cluster Control Property Data - Types (a WORD)
// //
skipping to change at line 999 skipping to change at line 1555
CLUSPROP_TYPE_LIST_VALUE, CLUSPROP_TYPE_LIST_VALUE,
CLUSPROP_TYPE_RESCLASS, CLUSPROP_TYPE_RESCLASS,
CLUSPROP_TYPE_RESERVED1, CLUSPROP_TYPE_RESERVED1,
CLUSPROP_TYPE_NAME, CLUSPROP_TYPE_NAME,
CLUSPROP_TYPE_SIGNATURE, CLUSPROP_TYPE_SIGNATURE,
CLUSPROP_TYPE_SCSI_ADDRESS, CLUSPROP_TYPE_SCSI_ADDRESS,
CLUSPROP_TYPE_DISK_NUMBER, CLUSPROP_TYPE_DISK_NUMBER,
CLUSPROP_TYPE_PARTITION_INFO, CLUSPROP_TYPE_PARTITION_INFO,
CLUSPROP_TYPE_FTSET_INFO, CLUSPROP_TYPE_FTSET_INFO,
CLUSPROP_TYPE_DISK_SERIALNUMBER, CLUSPROP_TYPE_DISK_SERIALNUMBER,
CLUSPROP_TYPE_DISK_GUID,
CLUSPROP_TYPE_DISK_SIZE,
CLUSPROP_TYPE_PARTITION_INFO_EX,
CLUSPROP_TYPE_USER=32768 CLUSPROP_TYPE_USER=32768
} CLUSTER_PROPERTY_TYPE; } CLUSTER_PROPERTY_TYPE;
// //
// Cluster Control Property Data - Formats (a WORD) // Cluster Control Property Data - Formats (a WORD)
// //
typedef enum CLUSTER_PROPERTY_FORMAT { typedef enum CLUSTER_PROPERTY_FORMAT {
CLUSPROP_FORMAT_UNKNOWN = 0, CLUSPROP_FORMAT_UNKNOWN = 0,
CLUSPROP_FORMAT_BINARY, CLUSPROP_FORMAT_BINARY,
CLUSPROP_FORMAT_DWORD, CLUSPROP_FORMAT_DWORD,
CLUSPROP_FORMAT_SZ, CLUSPROP_FORMAT_SZ,
CLUSPROP_FORMAT_EXPAND_SZ, CLUSPROP_FORMAT_EXPAND_SZ,
CLUSPROP_FORMAT_MULTI_SZ, CLUSPROP_FORMAT_MULTI_SZ,
CLUSPROP_FORMAT_ULARGE_INTEGER, CLUSPROP_FORMAT_ULARGE_INTEGER,
CLUSPROP_FORMAT_LONG, CLUSPROP_FORMAT_LONG,
CLUSPROP_FORMAT_EXPANDED_SZ, CLUSPROP_FORMAT_EXPANDED_SZ,
CLUSPROP_FORMAT_SECURITY_DESCRIPTOR, CLUSPROP_FORMAT_SECURITY_DESCRIPTOR,
CLUSPROP_FORMAT_LARGE_INTEGER, CLUSPROP_FORMAT_LARGE_INTEGER,
CLUSPROP_FORMAT_WORD, CLUSPROP_FORMAT_WORD,
CLUSPROP_FORMAT_FILETIME,
CLUSPROP_FORMAT_USER=32768 CLUSPROP_FORMAT_USER=32768
} CLUSTER_PROPERTY_FORMAT; } CLUSTER_PROPERTY_FORMAT;
#endif // _CLUSTER_API_TYPES_ #endif // _CLUSTER_API_TYPES_
// //
// Cluster Control Property Data - Syntax // Cluster Control Property Data - Syntax
// //
#define CLUSPROP_SYNTAX_VALUE( type, format ) ((DWORD) ((type << 16) | format)) #define CLUSPROP_SYNTAX_VALUE( type, format ) ((DWORD) ((type << 16) | format))
skipping to change at line 1046 skipping to change at line 1606
CLUSPROP_SYNTAX_LIST_VALUE_SZ = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_SZ ), CLUSPROP_SYNTAX_LIST_VALUE_SZ = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_SZ ),
CLUSPROP_SYNTAX_LIST_VALUE_EXPAND_SZ = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_EXPAND_SZ ), CLUSPROP_SYNTAX_LIST_VALUE_EXPAND_SZ = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_EXPAND_SZ ),
CLUSPROP_SYNTAX_LIST_VALUE_DWORD = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_DWORD ), CLUSPROP_SYNTAX_LIST_VALUE_DWORD = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_DWORD ),
CLUSPROP_SYNTAX_LIST_VALUE_BINARY = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_BINARY ), CLUSPROP_SYNTAX_LIST_VALUE_BINARY = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_BINARY ),
CLUSPROP_SYNTAX_LIST_VALUE_MULTI_SZ = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_MULTI_SZ ), CLUSPROP_SYNTAX_LIST_VALUE_MULTI_SZ = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_MULTI_SZ ),
CLUSPROP_SYNTAX_LIST_VALUE_LONG = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_LONG ), CLUSPROP_SYNTAX_LIST_VALUE_LONG = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_LONG ),
CLUSPROP_SYNTAX_LIST_VALUE_EXPANDED_SZ = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_EXPANDED_SZ ), CLUSPROP_SYNTAX_LIST_VALUE_EXPANDED_SZ = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_EXPANDED_SZ ),
CLUSPROP_SYNTAX_LIST_VALUE_SECURITY_DESCRIPTOR = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_SECURITY_DESCRIPTOR ), CLUSPROP_SYNTAX_LIST_VALUE_SECURITY_DESCRIPTOR = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_SECURITY_DESCRIPTOR ),
CLUSPROP_SYNTAX_LIST_VALUE_LARGE_INTEGER = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_LARGE_INTEGER ), CLUSPROP_SYNTAX_LIST_VALUE_LARGE_INTEGER = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_LARGE_INTEGER ),
CLUSPROP_SYNTAX_LIST_VALUE_ULARGE_INTEGER = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_ULARGE_INTEGER ), CLUSPROP_SYNTAX_LIST_VALUE_ULARGE_INTEGER = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_ULARGE_INTEGER ),
CLUSPROP_SYNTAX_LIST_VALUE_WORD = CLUSPROP_SYNTAX_VALUE( CLU SPROP_TYPE_LIST_VALUE, CLUSPROP_FORMAT_WORD ),
// Storage syntax values // Storage syntax values
CLUSPROP_SYNTAX_DISK_SIGNATURE = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_S IGNATURE, CLUSPROP_FORMAT_DWORD ), CLUSPROP_SYNTAX_DISK_SIGNATURE = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_S IGNATURE, CLUSPROP_FORMAT_DWORD ),
CLUSPROP_SYNTAX_SCSI_ADDRESS = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_S CSI_ADDRESS, CLUSPROP_FORMAT_DWORD ), CLUSPROP_SYNTAX_SCSI_ADDRESS = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_S CSI_ADDRESS, CLUSPROP_FORMAT_DWORD ),
CLUSPROP_SYNTAX_DISK_NUMBER = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_D ISK_NUMBER, CLUSPROP_FORMAT_DWORD ), CLUSPROP_SYNTAX_DISK_NUMBER = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_D ISK_NUMBER, CLUSPROP_FORMAT_DWORD ),
CLUSPROP_SYNTAX_PARTITION_INFO = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_P ARTITION_INFO, CLUSPROP_FORMAT_BINARY ), CLUSPROP_SYNTAX_PARTITION_INFO = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_P ARTITION_INFO, CLUSPROP_FORMAT_BINARY ),
CLUSPROP_SYNTAX_FTSET_INFO = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_F TSET_INFO, CLUSPROP_FORMAT_BINARY ), CLUSPROP_SYNTAX_FTSET_INFO = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_F TSET_INFO, CLUSPROP_FORMAT_BINARY ),
CLUSPROP_SYNTAX_DISK_SERIALNUMBER = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_D CLUSPROP_SYNTAX_DISK_SERIALNUMBER = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_D
ISK_SERIALNUMBER, CLUSPROP_FORMAT_SZ ) ISK_SERIALNUMBER, CLUSPROP_FORMAT_SZ ),
CLUSPROP_SYNTAX_DISK_GUID = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_D
ISK_GUID, CLUSPROP_FORMAT_SZ ),
CLUSPROP_SYNTAX_DISK_SIZE = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_D
ISK_SIZE, CLUSPROP_FORMAT_ULARGE_INTEGER ),
CLUSPROP_SYNTAX_PARTITION_INFO_EX = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_P
ARTITION_INFO_EX, CLUSPROP_FORMAT_BINARY ),
CLUSPROP_SYNTAX_LIST_VALUE_FILETIME = CLUSPROP_SYNTAX_VALUE( CLUSPROP_TYPE_L
IST_VALUE, CLUSPROP_FORMAT_FILETIME ),
} CLUSTER_PROPERTY_SYNTAX; } CLUSTER_PROPERTY_SYNTAX;
#endif // _CLUSTER_API_TYPES_ #endif // _CLUSTER_API_TYPES_
// //
// Define Cluster Control Code access methods // Define Cluster Control Code access methods
// //
#define CLUS_ACCESS_ANY 0 #define CLUS_ACCESS_ANY 0
#define CLUS_ACCESS_READ 0x01 #define CLUS_ACCESS_READ 0x01
skipping to change at line 1172 skipping to change at line 1737
CLCTL_GET_REQUIRED_DEPENDENCIES = CLCTL_EXTERNAL_CODE( 4, CLUS_ACCES S_READ, CLUS_NO_MODIFY ), CLCTL_GET_REQUIRED_DEPENDENCIES = CLCTL_EXTERNAL_CODE( 4, CLUS_ACCES S_READ, CLUS_NO_MODIFY ),
CLCTL_GET_ARB_TIMEOUT = CLCTL_EXTERNAL_CODE( 5, CLUS_ACCES S_READ, CLUS_NO_MODIFY ), CLCTL_GET_ARB_TIMEOUT = CLCTL_EXTERNAL_CODE( 5, CLUS_ACCES S_READ, CLUS_NO_MODIFY ),
CLCTL_GET_NAME = CLCTL_EXTERNAL_CODE( 10, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ), CLCTL_GET_NAME = CLCTL_EXTERNAL_CODE( 10, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
CLCTL_GET_RESOURCE_TYPE = CLCTL_EXTERNAL_CODE( 11, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ), CLCTL_GET_RESOURCE_TYPE = CLCTL_EXTERNAL_CODE( 11, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
CLCTL_GET_NODE = CLCTL_EXTERNAL_CODE( 12, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ), CLCTL_GET_NODE = CLCTL_EXTERNAL_CODE( 12, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
CLCTL_GET_NETWORK = CLCTL_EXTERNAL_CODE( 13, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ), CLCTL_GET_NETWORK = CLCTL_EXTERNAL_CODE( 13, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
CLCTL_GET_ID = CLCTL_EXTERNAL_CODE( 14, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ), CLCTL_GET_ID = CLCTL_EXTERNAL_CODE( 14, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
CLCTL_GET_FQDN = CLCTL_EXTERNAL_CODE( 15, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ), CLCTL_GET_FQDN = CLCTL_EXTERNAL_CODE( 15, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
CLCTL_GET_CLUSTER_SERVICE_ACCOUNT_NAME = CLCTL_EXTERNAL_CODE( 16, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ), CLCTL_GET_CLUSTER_SERVICE_ACCOUNT_NAME = CLCTL_EXTERNAL_CODE( 16, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
CLCTL_CHECK_VOTER_EVICT = CLCTL_EXTERNAL_CODE( 17, CLUS_ACCE
SS_READ, CLUS_NO_MODIFY ),
CLCTL_CHECK_VOTER_DOWN = CLCTL_EXTERNAL_CODE( 18, CLUS_ACCE
SS_READ, CLUS_NO_MODIFY ),
CLCTL_SHUTDOWN = CLCTL_EXTERNAL_CODE( 19, CLUS_ACCE
SS_READ, CLUS_NO_MODIFY ),
CLCTL_ENUM_COMMON_PROPERTIES = CLCTL_EXTERNAL_CODE( 20, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ), CLCTL_ENUM_COMMON_PROPERTIES = CLCTL_EXTERNAL_CODE( 20, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
CLCTL_GET_RO_COMMON_PROPERTIES = CLCTL_EXTERNAL_CODE( 21, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ), CLCTL_GET_RO_COMMON_PROPERTIES = CLCTL_EXTERNAL_CODE( 21, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
CLCTL_GET_COMMON_PROPERTIES = CLCTL_EXTERNAL_CODE( 22, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ), CLCTL_GET_COMMON_PROPERTIES = CLCTL_EXTERNAL_CODE( 22, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
CLCTL_SET_COMMON_PROPERTIES = CLCTL_EXTERNAL_CODE( 23, CLUS_ACCE SS_WRITE, CLUS_MODIFY ), CLCTL_SET_COMMON_PROPERTIES = CLCTL_EXTERNAL_CODE( 23, CLUS_ACCE SS_WRITE, CLUS_MODIFY ),
CLCTL_VALIDATE_COMMON_PROPERTIES = CLCTL_EXTERNAL_CODE( 24, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ), CLCTL_VALIDATE_COMMON_PROPERTIES = CLCTL_EXTERNAL_CODE( 24, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
CLCTL_GET_COMMON_PROPERTY_FMTS = CLCTL_EXTERNAL_CODE( 25, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ), CLCTL_GET_COMMON_PROPERTY_FMTS = CLCTL_EXTERNAL_CODE( 25, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
CLCTL_GET_COMMON_RESOURCE_PROPERTY_FMTS = CLCTL_EXTERNAL_CODE( 26, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ), CLCTL_GET_COMMON_RESOURCE_PROPERTY_FMTS = CLCTL_EXTERNAL_CODE( 26, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
CLCTL_ENUM_PRIVATE_PROPERTIES = CLCTL_EXTERNAL_CODE( 30, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ), CLCTL_ENUM_PRIVATE_PROPERTIES = CLCTL_EXTERNAL_CODE( 30, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
skipping to change at line 1204 skipping to change at line 1772
CLCTL_DELETE_CRYPTO_CHECKPOINT = CLCTL_EXTERNAL_CODE( 44, CLUS_ACCE SS_WRITE, CLUS_MODIFY ), CLCTL_DELETE_CRYPTO_CHECKPOINT = CLCTL_EXTERNAL_CODE( 44, CLUS_ACCE SS_WRITE, CLUS_MODIFY ),
CLCTL_GET_CRYPTO_CHECKPOINTS = CLCTL_EXTERNAL_CODE( 45, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ), CLCTL_GET_CRYPTO_CHECKPOINTS = CLCTL_EXTERNAL_CODE( 45, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
CLCTL_RESOURCE_UPGRADE_DLL = CLCTL_EXTERNAL_CODE( 46, CLUS_ACCE SS_WRITE, CLUS_MODIFY ), CLCTL_RESOURCE_UPGRADE_DLL = CLCTL_EXTERNAL_CODE( 46, CLUS_ACCE SS_WRITE, CLUS_MODIFY ),
CLCTL_ADD_REGISTRY_CHECKPOINT_64BIT = CLCTL_EXTERNAL_CODE( 47, CLUS_ACCE SS_WRITE, CLUS_MODIFY ), CLCTL_ADD_REGISTRY_CHECKPOINT_64BIT = CLCTL_EXTERNAL_CODE( 47, CLUS_ACCE SS_WRITE, CLUS_MODIFY ),
CLCTL_ADD_REGISTRY_CHECKPOINT_32BIT = CLCTL_EXTERNAL_CODE( 48, CLUS_ACCE SS_WRITE, CLUS_MODIFY ), CLCTL_ADD_REGISTRY_CHECKPOINT_32BIT = CLCTL_EXTERNAL_CODE( 48, CLUS_ACCE SS_WRITE, CLUS_MODIFY ),
CLCTL_GET_LOADBAL_PROCESS_LIST = CLCTL_EXTERNAL_CODE( 50, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ), CLCTL_GET_LOADBAL_PROCESS_LIST = CLCTL_EXTERNAL_CODE( 50, CLUS_ACCE SS_READ, CLUS_NO_MODIFY ),
CLCTL_GET_NETWORK_NAME = CLCTL_EXTERNAL_CODE( 90, CLUS_ACCE CLCTL_GET_NETWORK_NAME = CLCTL_EXTERNAL_CODE( 90, CLUS_ACCE
SS_READ, CLUS_NO_MODIFY ), SS_READ, CLUS_NO_MODIFY ),
CLCTL_NETNAME_GET_VIRTUAL_SERVER_TOKEN = CLCTL_EXTERNAL_CODE( 91, CLUS_ACCE CLCTL_NETNAME_GET_VIRTUAL_SERVER_TOKEN = CLCTL_EXTERNAL_CODE( 91, CLUS_ACCE
SS_READ, CLUS_NO_MODIFY ), SS_READ, CLUS_NO_MODIFY ),
CLCTL_NETNAME_REGISTER_DNS_RECORDS = CLCTL_EXTERNAL_CODE( 92, CLUS_ACCE SS_WRITE, CLUS_NO_MODIFY ), CLCTL_NETNAME_REGISTER_DNS_RECORDS = CLCTL_EXTERNAL_CODE( 92, CLUS_ACCE SS_WRITE, CLUS_NO_MODIFY ),
CLCTL_GET_DNS_NAME = CLCTL_EXTERNAL_CODE( 93, CLUS_ACCE
SS_READ, CLUS_NO_MODIFY ),
CLCTL_NETNAME_SET_PWD_INFO = CLCTL_EXTERNAL_CODE( 94, CLUS_ACCE
SS_WRITE, CLUS_NO_MODIFY ),
CLCTL_NETNAME_DELETE_CO = CLCTL_EXTERNAL_CODE( 95, CLUS_ACCE
SS_WRITE, CLUS_NO_MODIFY ),
CLCTL_NETNAME_VALIDATE_VCO = CLCTL_EXTERNAL_CODE( 96, CLUS_ACCE
SS_READ, CLUS_NO_MODIFY ),
CLCTL_STORAGE_GET_DISK_INFO = CLCTL_EXTERNAL_CODE( 100, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ), CLCTL_STORAGE_GET_DISK_INFO = CLCTL_EXTERNAL_CODE( 100, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ),
CLCTL_STORAGE_GET_AVAILABLE_DISKS = CLCTL_EXTERNAL_CODE( 101, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ), CLCTL_STORAGE_GET_AVAILABLE_DISKS = CLCTL_EXTERNAL_CODE( 101, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ),
CLCTL_STORAGE_IS_PATH_VALID = CLCTL_EXTERNAL_CODE( 102, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ), CLCTL_STORAGE_IS_PATH_VALID = CLCTL_EXTERNAL_CODE( 102, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ),
CLCTL_STORAGE_GET_ALL_AVAILABLE_DISKS = (CLCTL_EXTERNAL_CODE( 103, CLUS_AC CLCTL_STORAGE_GET_ALL_AVAILABLE_DISKS = CLCTL_EXTERNAL_CODE( 103, CLUS_ACC
CESS_READ, CLUS_NO_MODIFY ) | CLCTL_GLOBAL_MASK), ESS_READ, CLUS_NO_MODIFY ),
CLCTL_STORAGE_SYNC_CLUSDISK_DB = (CLCTL_EXTERNAL_CODE( 103, CLUS_AC
CESS_WRITE, CLUS_MODIFY ) | CLCTL_GLOBAL_MASK),
CLCTL_QUERY_DELETE = CLCTL_EXTERNAL_CODE( 110, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ), CLCTL_QUERY_DELETE = CLCTL_EXTERNAL_CODE( 110, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ),
CLCTL_IPADDRESS_RENEW_LEASE = CLCTL_EXTERNAL_CODE( 111, CLUS_ACC
ESS_WRITE, CLUS_MODIFY ),
CLCTL_IPADDRESS_RELEASE_LEASE = CLCTL_EXTERNAL_CODE( 112, CLUS_ACC
ESS_WRITE, CLUS_MODIFY ),
CLCTL_QUERY_MAINTENANCE_MODE = CLCTL_EXTERNAL_CODE( 120, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ), CLCTL_QUERY_MAINTENANCE_MODE = CLCTL_EXTERNAL_CODE( 120, CLUS_ACC ESS_READ, CLUS_NO_MODIFY ),
CLCTL_SET_MAINTENANCE_MODE = CLCTL_EXTERNAL_CODE( 121, CLUS_ACC ESS_WRITE, CLUS_MODIFY ), CLCTL_SET_MAINTENANCE_MODE = CLCTL_EXTERNAL_CODE( 121, CLUS_ACC ESS_WRITE, CLUS_MODIFY ),
CLCTL_STORAGE_SET_DRIVELETTER = CLCTL_EXTERNAL_CODE( 122, CLUS_ACC
ESS_WRITE, CLUS_MODIFY ),
CLCTL_STORAGE_GET_DRIVELETTERS = CLCTL_EXTERNAL_CODE( 123, CLUS_ACC
ESS_READ, CLUS_NO_MODIFY ),
CLCTL_STORAGE_GET_DISK_INFO_EX = CLCTL_EXTERNAL_CODE( 124, CLUS_ACC
ESS_READ, CLUS_NO_MODIFY ),
CLCTL_STORAGE_GET_AVAILABLE_DISKS_EX = CLCTL_EXTERNAL_CODE( 125, CLUS_ACC
ESS_READ, CLUS_NO_MODIFY ),
CLCTL_STORAGE_REMAP_DRIVELETTER = CLCTL_EXTERNAL_CODE( 128, CLUS_ACC
ESS_READ, CLUS_NO_MODIFY ),
// //
// Internal control codes // Internal control codes
// //
CLCTL_DELETE = CLCTL_INTERNAL_CODE( 1, CLUS_ACCES S_WRITE, CLUS_MODIFY ), CLCTL_DELETE = CLCTL_INTERNAL_CODE( 1, CLUS_ACCES S_WRITE, CLUS_MODIFY ),
CLCTL_INSTALL_NODE = CLCTL_INTERNAL_CODE( 2, CLUS_ACCES S_WRITE, CLUS_MODIFY ), CLCTL_INSTALL_NODE = CLCTL_INTERNAL_CODE( 2, CLUS_ACCES S_WRITE, CLUS_MODIFY ),
CLCTL_EVICT_NODE = CLCTL_INTERNAL_CODE( 3, CLUS_ACCES S_WRITE, CLUS_MODIFY ), CLCTL_EVICT_NODE = CLCTL_INTERNAL_CODE( 3, CLUS_ACCES S_WRITE, CLUS_MODIFY ),
CLCTL_ADD_DEPENDENCY = CLCTL_INTERNAL_CODE( 4, CLUS_ACCES S_WRITE, CLUS_MODIFY ), CLCTL_ADD_DEPENDENCY = CLCTL_INTERNAL_CODE( 4, CLUS_ACCES S_WRITE, CLUS_MODIFY ),
CLCTL_REMOVE_DEPENDENCY = CLCTL_INTERNAL_CODE( 5, CLUS_ACCES S_WRITE, CLUS_MODIFY ), CLCTL_REMOVE_DEPENDENCY = CLCTL_INTERNAL_CODE( 5, CLUS_ACCES S_WRITE, CLUS_MODIFY ),
CLCTL_ADD_OWNER = CLCTL_INTERNAL_CODE( 6, CLUS_ACCES S_WRITE, CLUS_MODIFY ), CLCTL_ADD_OWNER = CLCTL_INTERNAL_CODE( 6, CLUS_ACCES S_WRITE, CLUS_MODIFY ),
skipping to change at line 1239 skipping to change at line 1820
CLCTL_SET_NAME = CLCTL_INTERNAL_CODE( 9, CLUS_ACCES S_WRITE, CLUS_MODIFY ), CLCTL_SET_NAME = CLCTL_INTERNAL_CODE( 9, CLUS_ACCES S_WRITE, CLUS_MODIFY ),
CLCTL_CLUSTER_NAME_CHANGED = CLCTL_INTERNAL_CODE( 10, CLUS_ACCE SS_WRITE, CLUS_MODIFY ), CLCTL_CLUSTER_NAME_CHANGED = CLCTL_INTERNAL_CODE( 10, CLUS_ACCE SS_WRITE, CLUS_MODIFY ),
CLCTL_CLUSTER_VERSION_CHANGED = CLCTL_INTERNAL_CODE( 11, CLUS_ACCE SS_WRITE, CLUS_MODIFY ), CLCTL_CLUSTER_VERSION_CHANGED = CLCTL_INTERNAL_CODE( 11, CLUS_ACCE SS_WRITE, CLUS_MODIFY ),
CLCTL_FIXUP_ON_UPGRADE = CLCTL_INTERNAL_CODE( 12, CLUS_ACCE SS_WRITE, CLUS_MODIFY ), CLCTL_FIXUP_ON_UPGRADE = CLCTL_INTERNAL_CODE( 12, CLUS_ACCE SS_WRITE, CLUS_MODIFY ),
CLCTL_STARTING_PHASE1 = CLCTL_INTERNAL_CODE( 13, CLUS_ACCE SS_WRITE, CLUS_MODIFY ), CLCTL_STARTING_PHASE1 = CLCTL_INTERNAL_CODE( 13, CLUS_ACCE SS_WRITE, CLUS_MODIFY ),
CLCTL_STARTING_PHASE2 = CLCTL_INTERNAL_CODE( 14, CLUS_ACCE SS_WRITE, CLUS_MODIFY ), CLCTL_STARTING_PHASE2 = CLCTL_INTERNAL_CODE( 14, CLUS_ACCE SS_WRITE, CLUS_MODIFY ),
CLCTL_HOLD_IO = CLCTL_INTERNAL_CODE( 15, CLUS_ACCE SS_WRITE, CLUS_MODIFY ), CLCTL_HOLD_IO = CLCTL_INTERNAL_CODE( 15, CLUS_ACCE SS_WRITE, CLUS_MODIFY ),
CLCTL_RESUME_IO = CLCTL_INTERNAL_CODE( 16, CLUS_ACCE SS_WRITE, CLUS_MODIFY ), CLCTL_RESUME_IO = CLCTL_INTERNAL_CODE( 16, CLUS_ACCE SS_WRITE, CLUS_MODIFY ),
CLCTL_FORCE_QUORUM = CLCTL_INTERNAL_CODE( 17, CLUS_ACCE SS_WRITE, CLUS_MODIFY ), CLCTL_FORCE_QUORUM = CLCTL_INTERNAL_CODE( 17, CLUS_ACCE SS_WRITE, CLUS_MODIFY ),
CLCTL_INITIALIZE = CLCTL_INTERNAL_CODE( 18, CLUS_ACCE SS_WRITE, CLUS_MODIFY ), CLCTL_INITIALIZE = CLCTL_INTERNAL_CODE( 18, CLUS_ACCE SS_WRITE, CLUS_MODIFY ),
CLCTL_STATE_CHANGE_REASON = CLCTL_INTERNAL_CODE( 19, CLUS_ACCE CLCTL_STATE_CHANGE_REASON = CLCTL_INTERNAL_CODE( 19, CLUS_ACCE
SS_WRITE, CLUS_MODIFY ) SS_WRITE, CLUS_MODIFY ),
CLCTL_PROVIDER_STATE_CHANGE = CLCTL_INTERNAL_CODE( 20, CLUS_ACCE
SS_WRITE, CLUS_MODIFY ),
} CLCTL_CODES; } CLCTL_CODES;
#endif // _CLUSTER_API_TYPES_ #endif // _CLUSTER_API_TYPES_
// //
// Define macros to generate object specific control codes // Define macros to generate object specific control codes
// //
#define CLUSCTL_RESOURCE_CODE( Function ) ( \ #define CLUSCTL_RESOURCE_CODE( Function ) ( \
((CLUS_OBJECT_RESOURCE << CLUSCTL_OBJECT_SHIFT) | Function) ) ((CLUS_OBJECT_RESOURCE << CLUSCTL_OBJECT_SHIFT) | Function) )
skipping to change at line 1378 skipping to change at line 1960
CLUSCTL_RESOURCE_GET_LOADBAL_PROCESS_LIST = CLUSCTL_RESOURCE_GET_LOADBAL_PROCESS_LIST =
CLUSCTL_RESOURCE_CODE( CLCTL_GET_LOADBAL_PROCESS_LIST ), CLUSCTL_RESOURCE_CODE( CLCTL_GET_LOADBAL_PROCESS_LIST ),
CLUSCTL_RESOURCE_GET_NETWORK_NAME = CLUSCTL_RESOURCE_GET_NETWORK_NAME =
CLUSCTL_RESOURCE_CODE( CLCTL_GET_NETWORK_NAME ), CLUSCTL_RESOURCE_CODE( CLCTL_GET_NETWORK_NAME ),
CLUSCTL_RESOURCE_NETNAME_GET_VIRTUAL_SERVER_TOKEN = CLUSCTL_RESOURCE_NETNAME_GET_VIRTUAL_SERVER_TOKEN =
CLUSCTL_RESOURCE_CODE( CLCTL_NETNAME_GET_VIRTUAL_SERVER_TOKEN ), CLUSCTL_RESOURCE_CODE( CLCTL_NETNAME_GET_VIRTUAL_SERVER_TOKEN ),
CLUSCTL_RESOURCE_NETNAME_SET_PWD_INFO =
CLUSCTL_RESOURCE_CODE( CLCTL_NETNAME_SET_PWD_INFO ),
CLUSCTL_RESOURCE_NETNAME_DELETE_CO =
CLUSCTL_RESOURCE_CODE( CLCTL_NETNAME_DELETE_CO ),
CLUSCTL_RESOURCE_NETNAME_VALIDATE_VCO =
CLUSCTL_RESOURCE_CODE( CLCTL_NETNAME_VALIDATE_VCO ),
CLUSCTL_RESOURCE_NETNAME_REGISTER_DNS_RECORDS = CLUSCTL_RESOURCE_NETNAME_REGISTER_DNS_RECORDS =
CLUSCTL_RESOURCE_CODE( CLCTL_NETNAME_REGISTER_DNS_RECORDS ), CLUSCTL_RESOURCE_CODE( CLCTL_NETNAME_REGISTER_DNS_RECORDS ),
CLUSCTL_RESOURCE_GET_DNS_NAME =
CLUSCTL_RESOURCE_CODE( CLCTL_GET_DNS_NAME ),
CLUSCTL_RESOURCE_STORAGE_GET_DISK_INFO = CLUSCTL_RESOURCE_STORAGE_GET_DISK_INFO =
CLUSCTL_RESOURCE_CODE( CLCTL_STORAGE_GET_DISK_INFO ), CLUSCTL_RESOURCE_CODE( CLCTL_STORAGE_GET_DISK_INFO ),
CLUSCTL_RESOURCE_STORAGE_IS_PATH_VALID = CLUSCTL_RESOURCE_STORAGE_IS_PATH_VALID =
CLUSCTL_RESOURCE_CODE( CLCTL_STORAGE_IS_PATH_VALID ), CLUSCTL_RESOURCE_CODE( CLCTL_STORAGE_IS_PATH_VALID ),
CLUSCTL_RESOURCE_QUERY_DELETE = CLUSCTL_RESOURCE_QUERY_DELETE =
CLUSCTL_RESOURCE_CODE( CLCTL_QUERY_DELETE ), CLUSCTL_RESOURCE_CODE( CLCTL_QUERY_DELETE ),
CLUSCTL_RESOURCE_UPGRADE_DLL = CLUSCTL_RESOURCE_UPGRADE_DLL =
CLUSCTL_RESOURCE_CODE( CLCTL_RESOURCE_UPGRADE_DLL ), CLUSCTL_RESOURCE_CODE( CLCTL_RESOURCE_UPGRADE_DLL ),
CLUSCTL_RESOURCE_IPADDRESS_RENEW_LEASE =
CLUSCTL_RESOURCE_CODE( CLCTL_IPADDRESS_RENEW_LEASE ),
CLUSCTL_RESOURCE_IPADDRESS_RELEASE_LEASE =
CLUSCTL_RESOURCE_CODE( CLCTL_IPADDRESS_RELEASE_LEASE ),
CLUSCTL_RESOURCE_ADD_REGISTRY_CHECKPOINT_64BIT = CLUSCTL_RESOURCE_ADD_REGISTRY_CHECKPOINT_64BIT =
CLUSCTL_RESOURCE_CODE( CLCTL_ADD_REGISTRY_CHECKPOINT_64BIT ), CLUSCTL_RESOURCE_CODE( CLCTL_ADD_REGISTRY_CHECKPOINT_64BIT ),
CLUSCTL_RESOURCE_ADD_REGISTRY_CHECKPOINT_32BIT = CLUSCTL_RESOURCE_ADD_REGISTRY_CHECKPOINT_32BIT =
CLUSCTL_RESOURCE_CODE( CLCTL_ADD_REGISTRY_CHECKPOINT_32BIT ), CLUSCTL_RESOURCE_CODE( CLCTL_ADD_REGISTRY_CHECKPOINT_32BIT ),
CLUSCTL_RESOURCE_QUERY_MAINTENANCE_MODE = CLUSCTL_RESOURCE_QUERY_MAINTENANCE_MODE =
CLUSCTL_RESOURCE_CODE( CLCTL_QUERY_MAINTENANCE_MODE ), CLUSCTL_RESOURCE_CODE( CLCTL_QUERY_MAINTENANCE_MODE ),
CLUSCTL_RESOURCE_SET_MAINTENANCE_MODE = CLUSCTL_RESOURCE_SET_MAINTENANCE_MODE =
CLUSCTL_RESOURCE_CODE( CLCTL_SET_MAINTENANCE_MODE ), CLUSCTL_RESOURCE_CODE( CLCTL_SET_MAINTENANCE_MODE ),
CLUSCTL_RESOURCE_STORAGE_SET_DRIVELETTER =
CLUSCTL_RESOURCE_CODE( CLCTL_STORAGE_SET_DRIVELETTER ),
CLUSCTL_RESOURCE_STORAGE_GET_DISK_INFO_EX =
CLUSCTL_RESOURCE_CODE( CLCTL_STORAGE_GET_DISK_INFO_EX ),
// Internal // Internal
CLUSCTL_RESOURCE_DELETE = CLUSCTL_RESOURCE_DELETE =
CLUSCTL_RESOURCE_CODE( CLCTL_DELETE ), CLUSCTL_RESOURCE_CODE( CLCTL_DELETE ),
CLUSCTL_RESOURCE_INSTALL_NODE = CLUSCTL_RESOURCE_INSTALL_NODE =
CLUSCTL_RESOURCE_CODE( CLCTL_INSTALL_NODE ), CLUSCTL_RESOURCE_CODE( CLCTL_INSTALL_NODE ),
CLUSCTL_RESOURCE_EVICT_NODE = CLUSCTL_RESOURCE_EVICT_NODE =
CLUSCTL_RESOURCE_CODE( CLCTL_EVICT_NODE ), CLUSCTL_RESOURCE_CODE( CLCTL_EVICT_NODE ),
skipping to change at line 1443 skipping to change at line 2049
CLUSCTL_RESOURCE_CLUSTER_VERSION_CHANGED = CLUSCTL_RESOURCE_CLUSTER_VERSION_CHANGED =
CLUSCTL_RESOURCE_CODE( CLCTL_CLUSTER_VERSION_CHANGED ), CLUSCTL_RESOURCE_CODE( CLCTL_CLUSTER_VERSION_CHANGED ),
CLUSCTL_RESOURCE_FORCE_QUORUM = CLUSCTL_RESOURCE_FORCE_QUORUM =
CLUSCTL_RESOURCE_CODE( CLCTL_FORCE_QUORUM ), CLUSCTL_RESOURCE_CODE( CLCTL_FORCE_QUORUM ),
CLUSCTL_RESOURCE_INITIALIZE = CLUSCTL_RESOURCE_INITIALIZE =
CLUSCTL_RESOURCE_CODE( CLCTL_INITIALIZE ), CLUSCTL_RESOURCE_CODE( CLCTL_INITIALIZE ),
CLUSCTL_RESOURCE_STATE_CHANGE_REASON = CLUSCTL_RESOURCE_STATE_CHANGE_REASON =
CLUSCTL_RESOURCE_CODE( CLCTL_STATE_CHANGE_REASON ) CLUSCTL_RESOURCE_CODE( CLCTL_STATE_CHANGE_REASON ),
CLUSCTL_RESOURCE_PROVIDER_STATE_CHANGE =
CLUSCTL_RESOURCE_CODE( CLCTL_PROVIDER_STATE_CHANGE ),
} CLUSCTL_RESOURCE_CODES; } CLUSCTL_RESOURCE_CODES;
// //
// Cluster Control Codes for Resource Types // Cluster Control Codes for Resource Types
// //
typedef enum CLUSCTL_RESOURCE_TYPE_CODES { typedef enum CLUSCTL_RESOURCE_TYPE_CODES {
// External // External
CLUSCTL_RESOURCE_TYPE_UNKNOWN = CLUSCTL_RESOURCE_TYPE_UNKNOWN =
skipping to change at line 1522 skipping to change at line 2131
CLUSCTL_RESOURCE_TYPE_GET_REGISTRY_CHECKPOINTS = CLUSCTL_RESOURCE_TYPE_GET_REGISTRY_CHECKPOINTS =
CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_GET_REGISTRY_CHECKPOINTS ), CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_GET_REGISTRY_CHECKPOINTS ),
CLUSCTL_RESOURCE_TYPE_GET_CRYPTO_CHECKPOINTS = CLUSCTL_RESOURCE_TYPE_GET_CRYPTO_CHECKPOINTS =
CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_GET_CRYPTO_CHECKPOINTS ), CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_GET_CRYPTO_CHECKPOINTS ),
CLUSCTL_RESOURCE_TYPE_STORAGE_GET_AVAILABLE_DISKS = CLUSCTL_RESOURCE_TYPE_STORAGE_GET_AVAILABLE_DISKS =
CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_STORAGE_GET_AVAILABLE_DISKS ), CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_STORAGE_GET_AVAILABLE_DISKS ),
CLUSCTL_RESOURCE_TYPE_STORAGE_SYNC_CLUSDISK_DB =
CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_STORAGE_SYNC_CLUSDISK_DB ),
CLUSCTL_RESOURCE_TYPE_QUERY_DELETE = CLUSCTL_RESOURCE_TYPE_QUERY_DELETE =
CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_QUERY_DELETE ), CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_QUERY_DELETE ),
CLUSCTL_RESOURCE_TYPE_STORAGE_GET_DRIVELETTERS =
CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_STORAGE_GET_DRIVELETTERS ),
CLUSCTL_RESOURCE_TYPE_STORAGE_GET_AVAILABLE_DISKS_EX =
CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_STORAGE_GET_AVAILABLE_DISKS_EX ),
CLUSCTL_RESOURCE_TYPE_STORAGE_REMAP_DRIVELETTER =
CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_STORAGE_REMAP_DRIVELETTER ),
// Internal // Internal
CLUSCTL_RESOURCE_TYPE_INSTALL_NODE = CLUSCTL_RESOURCE_TYPE_INSTALL_NODE =
CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_INSTALL_NODE ), CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_INSTALL_NODE ),
CLUSCTL_RESOURCE_TYPE_EVICT_NODE = CLUSCTL_RESOURCE_TYPE_EVICT_NODE =
CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_EVICT_NODE ), CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_EVICT_NODE ),
CLUSCTL_RESOURCE_TYPE_CLUSTER_VERSION_CHANGED = CLUSCTL_RESOURCE_TYPE_CLUSTER_VERSION_CHANGED =
CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_CLUSTER_VERSION_CHANGED ), CLUSCTL_RESOURCE_TYPE_CODE( CLCTL_CLUSTER_VERSION_CHANGED ),
skipping to change at line 1848 skipping to change at line 2469
CLUSCTL_CLUSTER_SET_PRIVATE_PROPERTIES = CLUSCTL_CLUSTER_SET_PRIVATE_PROPERTIES =
CLUSCTL_CLUSTER_CODE( CLCTL_SET_PRIVATE_PROPERTIES ), CLUSCTL_CLUSTER_CODE( CLCTL_SET_PRIVATE_PROPERTIES ),
CLUSCTL_CLUSTER_VALIDATE_PRIVATE_PROPERTIES = CLUSCTL_CLUSTER_VALIDATE_PRIVATE_PROPERTIES =
CLUSCTL_CLUSTER_CODE( CLCTL_VALIDATE_PRIVATE_PROPERTIES ), CLUSCTL_CLUSTER_CODE( CLCTL_VALIDATE_PRIVATE_PROPERTIES ),
CLUSCTL_CLUSTER_GET_COMMON_PROPERTY_FMTS= CLUSCTL_CLUSTER_GET_COMMON_PROPERTY_FMTS=
CLUSCTL_CLUSTER_CODE( CLCTL_GET_COMMON_PROPERTY_FMTS ), CLUSCTL_CLUSTER_CODE( CLCTL_GET_COMMON_PROPERTY_FMTS ),
CLUSCTL_CLUSTER_GET_PRIVATE_PROPERTY_FMTS= CLUSCTL_CLUSTER_GET_PRIVATE_PROPERTY_FMTS=
CLUSCTL_CLUSTER_CODE( CLCTL_GET_PRIVATE_PROPERTY_FMTS ) CLUSCTL_CLUSTER_CODE( CLCTL_GET_PRIVATE_PROPERTY_FMTS ),
CLUSCTL_CLUSTER_CHECK_VOTER_EVICT=
CLUSCTL_CLUSTER_CODE( CLCTL_CHECK_VOTER_EVICT ),
CLUSCTL_CLUSTER_CHECK_VOTER_DOWN=
CLUSCTL_CLUSTER_CODE( CLCTL_CHECK_VOTER_DOWN ),
CLUSCTL_CLUSTER_SHUTDOWN=
CLUSCTL_CLUSTER_CODE( CLCTL_SHUTDOWN ),
} CLUSCTL_CLUSTER_CODES; } CLUSCTL_CLUSTER_CODES;
// //
// Cluster Resource Class types // Cluster Resource Class types
// //
typedef enum CLUSTER_RESOURCE_CLASS { typedef enum CLUSTER_RESOURCE_CLASS {
CLUS_RESCLASS_UNKNOWN = 0, CLUS_RESCLASS_UNKNOWN = 0,
CLUS_RESCLASS_STORAGE, CLUS_RESCLASS_STORAGE,
CLUS_RESCLASS_NETWORK,
CLUS_RESCLASS_USER = 32768 CLUS_RESCLASS_USER = 32768
} CLUSTER_RESOURCE_CLASS; } CLUSTER_RESOURCE_CLASS;
// //
// Define Resource SubClass bits // Define Resource SubClass bits
// //
// legacy subclass struct
//
typedef enum CLUS_RESSUBCLASS { typedef enum CLUS_RESSUBCLASS {
CLUS_RESSUBCLASS_SHARED = 0x80000000 CLUS_RESSUBCLASS_SHARED = 0x80000000
} CLUS_RESSUBCLASS; } CLUS_RESSUBCLASS;
typedef enum CLUS_RESSUBCLASS_STORAGE {
CLUS_RESSUBCLASS_STORAGE_SHARED_BUS = 0x80000000
} CLUS_RESSUBCLASS_STORAGE;
typedef enum CLUS_RESSUBCLASS_NETWORK {
CLUS_RESSUBCLASS_NETWORK_INTERNET_PROTOCOL = 0x80000000 // Identifies
IP address providers
} CLUS_RESSUBCLASS_NETWORK;
// //
// Cluster Characteristics // Cluster Characteristics
// //
typedef enum CLUS_CHARACTERISTICS { typedef enum CLUS_CHARACTERISTICS {
CLUS_CHAR_UNKNOWN = 0x00000000, CLUS_CHAR_UNKNOWN = 0x00000000,
CLUS_CHAR_QUORUM = 0x00000001, CLUS_CHAR_QUORUM = 0x00000001,
CLUS_CHAR_DELETE_REQUIRES_ALL_NODES = 0x00000002, CLUS_CHAR_DELETE_REQUIRES_ALL_NODES = 0x00000002,
CLUS_CHAR_LOCAL_QUORUM = 0x00000004, CLUS_CHAR_LOCAL_QUORUM = 0x00000004,
CLUS_CHAR_LOCAL_QUORUM_DEBUG = 0x00000008, CLUS_CHAR_LOCAL_QUORUM_DEBUG = 0x00000008,
CLUS_CHAR_REQUIRES_STATE_CHANGE_REASON = 0x00000010 CLUS_CHAR_REQUIRES_STATE_CHANGE_REASON = 0x00000010
skipping to change at line 1891 skipping to change at line 2532
// Cluster Flags // Cluster Flags
// //
typedef enum CLUS_FLAGS { typedef enum CLUS_FLAGS {
CLUS_FLAG_CORE = 0x00000001 CLUS_FLAG_CORE = 0x00000001
} CLUS_FLAGS; } CLUS_FLAGS;
// //
// Cluster Resource Property Helper Structures // Cluster Resource Property Helper Structures
// //
#ifndef MIDL_PASS #if ( !MIDL_PASS && !__midl )
// Property syntax. Used for property names and values. // Property syntax. Used for property names and values.
typedef union CLUSPROP_SYNTAX { typedef union CLUSPROP_SYNTAX {
DWORD dw; DWORD dw;
struct { struct {
WORD wFormat; WORD wFormat;
WORD wType; WORD wType;
}; };
} CLUSPROP_SYNTAX, *PCLUSPROP_SYNTAX; } CLUSPROP_SYNTAX, *PCLUSPROP_SYNTAX;
skipping to change at line 1973 skipping to change at line 2614
// Unsigned large Integer property value. // Unsigned large Integer property value.
#ifdef __cplusplus #ifdef __cplusplus
typedef struct CLUSPROP_ULARGE_INTEGER typedef struct CLUSPROP_ULARGE_INTEGER
: public CLUSPROP_VALUE { : public CLUSPROP_VALUE {
#else #else
typedef struct CLUSPROP_ULARGE_INTEGER { typedef struct CLUSPROP_ULARGE_INTEGER {
CLUSPROP_VALUE; CLUSPROP_VALUE;
#endif #endif
ULARGE_INTEGER li; ULARGE_INTEGER li;
} CLUSPROP_ULARGE_INTEGER, *PCLUSPROP_ULARGE_INTEGER; } CLUSPROP_ULARGE_INTEGER;
typedef CLUSPROP_ULARGE_INTEGER UNALIGNED *PCLUSPROP_ULARGE_INTEGER;
// Signed large Integer property value. // Signed large Integer property value.
#ifdef __cplusplus #ifdef __cplusplus
typedef struct CLUSPROP_LARGE_INTEGER typedef struct CLUSPROP_LARGE_INTEGER
: public CLUSPROP_VALUE { : public CLUSPROP_VALUE {
#else #else
typedef struct CLUSPROP_LARGE_INTEGER { typedef struct CLUSPROP_LARGE_INTEGER {
CLUSPROP_VALUE; CLUSPROP_VALUE;
#endif #endif
LARGE_INTEGER li; LARGE_INTEGER li;
} CLUSPROP_LARGE_INTEGER, *PCLUSPROP_LARGE_INTEGER; } CLUSPROP_LARGE_INTEGER;
typedef CLUSPROP_LARGE_INTEGER UNALIGNED *PCLUSPROP_LARGE_INTEGER;
// Security Descriptor property value. // Security Descriptor property value.
#ifdef __cplusplus #ifdef __cplusplus
typedef struct CLUSPROP_SECURITY_DESCRIPTOR : public CLUSPROP_VALUE { typedef struct CLUSPROP_SECURITY_DESCRIPTOR : public CLUSPROP_VALUE {
#else #else
typedef struct CLUSPROP_SECURITY_DESCRIPTOR { typedef struct CLUSPROP_SECURITY_DESCRIPTOR {
CLUSPROP_VALUE; CLUSPROP_VALUE;
#endif #endif
union { union {
SECURITY_DESCRIPTOR_RELATIVE sd; SECURITY_DESCRIPTOR_RELATIVE sd;
BYTE rgbSecurityDescriptor[]; BYTE rgbSecurityDescriptor[];
}; };
} CLUSPROP_SECURITY_DESCRIPTOR, *PCLUSPROP_SECURITY_DESCRIPTOR; } CLUSPROP_SECURITY_DESCRIPTOR, *PCLUSPROP_SECURITY_DESCRIPTOR;
// FILETIME Time property value.
#ifdef __cplusplus
typedef struct CLUSPROP_FILETIME
: public CLUSPROP_VALUE {
#else
typedef struct CLUSPROP_FILETIME {
CLUSPROP_VALUE;
#endif
FILETIME ft;
} CLUSPROP_FILETIME, *PCLUSPROP_FILETIME;
// Resource class info returned by CLCTL_GET_CLASS_INFO control functions. // Resource class info returned by CLCTL_GET_CLASS_INFO control functions.
typedef struct CLUS_RESOURCE_CLASS_INFO { typedef struct CLUS_RESOURCE_CLASS_INFO {
union { union {
struct { struct {
union { union {
DWORD dw; DWORD dw;
CLUSTER_RESOURCE_CLASS rc; CLUSTER_RESOURCE_CLASS rc;
}; };
DWORD SubClass; DWORD SubClass;
}; };
skipping to change at line 2048 skipping to change at line 2704
CLUSPROP_VALUE Value; CLUSPROP_VALUE Value;
CLUSPROP_RESOURCE_CLASS ResClass; CLUSPROP_RESOURCE_CLASS ResClass;
CLUSPROP_SZ ResTypeName; CLUSPROP_SZ ResTypeName;
} CLUSPROP_REQUIRED_DEPENDENCY, *PCLUSPROP_REQUIRED_DEPENDENCY; } CLUSPROP_REQUIRED_DEPENDENCY, *PCLUSPROP_REQUIRED_DEPENDENCY;
typedef CLUSPROP_DWORD CLUSPROP_DISK_NUMBER, *PCLUSPROP_DISK_NUMBER; typedef CLUSPROP_DWORD CLUSPROP_DISK_NUMBER, *PCLUSPROP_DISK_NUMBER;
#endif // MIDL_PASS #endif // MIDL_PASS
#endif // _CLUSTER_API_TYPES_ #endif // _CLUSTER_API_TYPES_
//#ifdef MIDL_PASS
//#ifndef MAX_PATH
//#define MAX_PATH 260
//#endif
//#endif // if MIDL_PASS
#ifndef _CLUSTER_API_TYPES_ #ifndef _CLUSTER_API_TYPES_
// Disk partition information flags. // Disk partition information flags.
typedef enum CLUSPROP_PIFLAGS { typedef enum CLUSPROP_PIFLAGS {
CLUSPROP_PIFLAG_STICKY = 0x00000001, CLUSPROP_PIFLAG_STICKY = 0x00000001,
CLUSPROP_PIFLAG_REMOVABLE = 0x00000002, CLUSPROP_PIFLAG_REMOVABLE = 0x00000002,
CLUSPROP_PIFLAG_USABLE = 0x00000004, CLUSPROP_PIFLAG_USABLE = 0x00000004,
CLUSPROP_PIFLAG_DEFAULT_QUORUM = 0x00000008 CLUSPROP_PIFLAG_DEFAULT_QUORUM = 0x00000008
} CLUSPROP_PIFLAGS; } CLUSPROP_PIFLAGS;
#ifndef MIDL_PASS #if ( !MIDL_PASS && !__midl )
//force quorum information, useful for QON type resources //force quorum information, useful for QON type resources
//to be able to continue operation without the quorum //to be able to continue operation without the quorum
typedef struct CLUS_FORCE_QUORUM_INFO { typedef struct CLUS_FORCE_QUORUM_INFO {
DWORD dwSize; // size of this struct including the node s list. DWORD dwSize; // size of this struct including the nod es list.
DWORD dwNodeBitMask; // a bit mask representing the max assum ed node set DWORD dwNodeBitMask; // a bit mask representing the max assum ed node set
DWORD dwMaxNumberofNodes; // the number of bits set in the mask DWORD dwMaxNumberofNodes; // the number of bits set in the mask
WCHAR multiszNodeList[1]; // Multi sz list of nodes WCHAR multiszNodeList[1]; // Multi sz list of nodes
} CLUS_FORCE_QUORUM_INFO, *PCLUS_FORCE_QUORUM_INFO; } CLUS_FORCE_QUORUM_INFO, *PCLUS_FORCE_QUORUM_INFO;
// Disk partition information. // Disk partition information.
typedef struct CLUS_PARTITION_INFO { typedef struct CLUS_PARTITION_INFO {
DWORD dwFlags; DWORD dwFlags;
WCHAR szDeviceName[MAX_PATH]; WCHAR szDeviceName[MAX_PATH];
WCHAR szVolumeLabel[MAX_PATH]; WCHAR szVolumeLabel[MAX_PATH];
DWORD dwSerialNumber; DWORD dwSerialNumber;
DWORD rgdwMaximumComponentLength; DWORD rgdwMaximumComponentLength;
DWORD dwFileSystemFlags; DWORD dwFileSystemFlags;
WCHAR szFileSystem[32]; WCHAR szFileSystem[32];
} CLUS_PARTITION_INFO, *PCLUS_PARTITION_INFO; } CLUS_PARTITION_INFO, *PCLUS_PARTITION_INFO;
// Disk partition information ex
typedef struct CLUS_PARTITION_INFO_EX {
DWORD dwFlags;
WCHAR szDeviceName[MAX_PATH];
WCHAR szVolumeLabel[MAX_PATH];
DWORD dwSerialNumber;
DWORD rgdwMaximumComponentLength;
DWORD dwFileSystemFlags;
WCHAR szFileSystem[32];
ULARGE_INTEGER TotalSizeInBytes;
ULARGE_INTEGER FreeSizeInBytes;
DWORD DeviceNumber;
DWORD PartitionNumber;
GUID VolumeGuid;
} CLUS_PARTITION_INFO_EX, *PCLUS_PARTITION_INFO_EX;
// Disk partition information property value. // Disk partition information property value.
#ifdef __cplusplus #ifdef __cplusplus
typedef struct CLUSPROP_PARTITION_INFO typedef struct CLUSPROP_PARTITION_INFO
: public CLUSPROP_VALUE : public CLUSPROP_VALUE
, public CLUS_PARTITION_INFO { , public CLUS_PARTITION_INFO {
#else #else
typedef struct CLUSPROP_PARTITION_INFO { typedef struct CLUSPROP_PARTITION_INFO {
CLUSPROP_VALUE; CLUSPROP_VALUE;
CLUS_PARTITION_INFO; CLUS_PARTITION_INFO;
#endif #endif
} CLUSPROP_PARTITION_INFO, *PCLUSPROP_PARTITION_INFO; } CLUSPROP_PARTITION_INFO, *PCLUSPROP_PARTITION_INFO;
// Disk partition information ex property value.
#ifdef __cplusplus
typedef struct CLUSPROP_PARTITION_INFO_EX
: public CLUSPROP_VALUE
, public CLUS_PARTITION_INFO_EX {
#else
typedef struct CLUSPROP_PARTITION_INFO_EX {
CLUSPROP_VALUE;
CLUS_PARTITION_INFO_EX;
#endif
} CLUSPROP_PARTITION_INFO_EX;
typedef CLUSPROP_PARTITION_INFO_EX UNALIGNED *PCLUSPROP_PARTITION_INFO_EX;
// //
// FT set information. // FT set information.
// //
typedef struct CLUS_FTSET_INFO { typedef struct CLUS_FTSET_INFO {
DWORD dwRootSignature; DWORD dwRootSignature;
DWORD dwFtType; DWORD dwFtType;
} CLUS_FTSET_INFO, *PCLUS_FTSET_INFO; } CLUS_FTSET_INFO, *PCLUS_FTSET_INFO;
// Disk partition information property value. // Disk partition information property value.
#ifdef __cplusplus #ifdef __cplusplus
skipping to change at line 2155 skipping to change at line 2834
// //
// input structure for CLUSCTL_RESOURCE_NETNAME_GET_VIRTUAL_SERVER_TOKEN // input structure for CLUSCTL_RESOURCE_NETNAME_GET_VIRTUAL_SERVER_TOKEN
// //
typedef struct CLUS_NETNAME_VS_TOKEN_INFO { typedef struct CLUS_NETNAME_VS_TOKEN_INFO {
DWORD ProcessID; DWORD ProcessID;
DWORD DesiredAccess; DWORD DesiredAccess;
BOOL InheritHandle; BOOL InheritHandle;
} CLUS_NETNAME_VS_TOKEN_INFO, *PCLUS_NETNAME_VS_TOKEN_INFO; } CLUS_NETNAME_VS_TOKEN_INFO, *PCLUS_NETNAME_VS_TOKEN_INFO;
// //
// input structure for CLUSCTL_RESOURCE_NETNAME_SET_PWD
//
#define MAX_OBJECTID 64
#define MAX_CO_PASSWORD_LENGTH 16
#define GUID_PRESENT 0x1
#define CREATEDC_PRESENT 0x2
#define MAX_CREATINGDC_LENGTH 256
typedef struct CLUS_NETNAME_PWD_INFO {
DWORD Flags;
WCHAR Password[MAX_CO_PASSWORD_LENGTH];
WCHAR CreatingDC[MAX_CREATINGDC_LENGTH+2]; // including the '\\' prefix
WCHAR ObjectGuid[MAX_OBJECTID]; //
} CLUS_NETNAME_PWD_INFO, *PCLUS_NETNAME_PWD_INFO;
//
// input/output structure associated with Maintenance Mode // input/output structure associated with Maintenance Mode
// //
typedef struct CLUS_MAINTENANCE_MODE_INFO { typedef struct CLUS_MAINTENANCE_MODE_INFO {
BOOL InMaintenance; BOOL InMaintenance;
} CLUS_MAINTENANCE_MODE_INFO, *PCLUS_MAINTENANCE_MODE_INFO; } CLUS_MAINTENANCE_MODE_INFO, *PCLUS_MAINTENANCE_MODE_INFO;
#define MAINTENANCE_MODE_V2_SIG 0xabbaf00f
typedef enum _MAINTENANCE_MODE_TYPE_ENUM {
MaintenanceModeTypeDisableIsAliveCheck=1,
MaintenanceModeTypeOfflineResource=2,
MaintenanceModeTypeUnclusterResource=3,
} MAINTENANCE_MODE_TYPE_ENUM, *PMAINTENANCE_MODE_TYPE_ENUM;
typedef struct _CLUS_MAINTENANCE_MODE_INFOEX {
BOOL InMaintenance;
MAINTENANCE_MODE_TYPE_ENUM MaintainenceModeType;
CLUSTER_RESOURCE_STATE InternalState;
DWORD Signature;
} CLUS_MAINTENANCE_MODE_INFOEX, *PCLUS_MAINTENANCE_MODE_INFOEX;
typedef struct _CLUS_STORAGE_SET_DRIVELETTER {
DWORD PartitionNumber;
DWORD DriveLetterMask;
} CLUS_STORAGE_SET_DRIVELETTER, *PCLUS_STORAGE_SET_DRIVELETTER;
typedef struct _CLUS_STORAGE_GET_AVAILABLE_DRIVELETTERS {
DWORD AvailDrivelettersMask;
} CLUS_STORAGE_GET_AVAILABLE_DRIVELETTERS, *PCLUS_STORAGE_GET_AVAILABLE_DRIVELET
TERS;
typedef struct _CLUS_STORAGE_REMAP_DRIVELETTER {
DWORD CurrentDriveLetterMask;
DWORD TargetDriveLetterMask;
} CLUS_STORAGE_REMAP_DRIVELETTER, *PCLUS_STORAGE_REMAP_DRIVELETTER;
typedef struct _CLUS_PROVIDER_STATE_CHANGE_INFO {
DWORD dwSize; // size of this struct including
the provider name.
CLUSTER_RESOURCE_STATE resourceState;
WCHAR szProviderId[1];
} CLUS_PROVIDER_STATE_CHANGE_INFO, *PCLUS_PROVIDER_STATE_CHANGE_INFO;
// Beginning of a property list. // Beginning of a property list.
typedef struct CLUSPROP_LIST { typedef struct CLUSPROP_LIST {
DWORD nPropertyCount; DWORD nPropertyCount;
CLUSPROP_PROPERTY_NAME PropertyName; CLUSPROP_PROPERTY_NAME PropertyName;
} CLUSPROP_LIST, *PCLUSPROP_LIST; } CLUSPROP_LIST, *PCLUSPROP_LIST;
//
// values for IP Address' EnableNetbios property
//
typedef enum CLUSPROP_IPADDR_ENABLENETBIOS {
CLUSPROP_IPADDR_ENABLENETBIOS_DISABLED = 0,
CLUSPROP_IPADDR_ENABLENETBIOS_ENABLED,
CLUSPROP_IPADDR_ENABLENETBIOS_TRACK_NIC
} CLUSPROP_IPADDR_ENABLENETBIOS;
// Helper for building or parsing a property list buffer. // Helper for building or parsing a property list buffer.
typedef union CLUSPROP_BUFFER_HELPER { typedef union CLUSPROP_BUFFER_HELPER {
BYTE * pb; BYTE * pb;
WORD * pw; WORD * pw;
DWORD * pdw; DWORD * pdw;
LONG * pl; LONG * pl;
LPWSTR psz; LPWSTR psz;
PCLUSPROP_LIST pList; PCLUSPROP_LIST pList;
PCLUSPROP_SYNTAX pSyntax; PCLUSPROP_SYNTAX pSyntax;
PCLUSPROP_PROPERTY_NAME pName; PCLUSPROP_PROPERTY_NAME pName;
skipping to change at line 2194 skipping to change at line 2934
PCLUSPROP_SZ pStringValue; PCLUSPROP_SZ pStringValue;
PCLUSPROP_MULTI_SZ pMultiSzValue; PCLUSPROP_MULTI_SZ pMultiSzValue;
PCLUSPROP_SECURITY_DESCRIPTOR pSecurityDescriptor; PCLUSPROP_SECURITY_DESCRIPTOR pSecurityDescriptor;
PCLUSPROP_RESOURCE_CLASS pResourceClassValue; PCLUSPROP_RESOURCE_CLASS pResourceClassValue;
PCLUSPROP_RESOURCE_CLASS_INFO pResourceClassInfoValue; PCLUSPROP_RESOURCE_CLASS_INFO pResourceClassInfoValue;
PCLUSPROP_DISK_SIGNATURE pDiskSignatureValue; PCLUSPROP_DISK_SIGNATURE pDiskSignatureValue;
PCLUSPROP_SCSI_ADDRESS pScsiAddressValue; PCLUSPROP_SCSI_ADDRESS pScsiAddressValue;
PCLUSPROP_DISK_NUMBER pDiskNumberValue; PCLUSPROP_DISK_NUMBER pDiskNumberValue;
PCLUSPROP_PARTITION_INFO pPartitionInfoValue; PCLUSPROP_PARTITION_INFO pPartitionInfoValue;
PCLUSPROP_REQUIRED_DEPENDENCY pRequiredDependencyValue; PCLUSPROP_REQUIRED_DEPENDENCY pRequiredDependencyValue;
PCLUSPROP_PARTITION_INFO_EX pPartitionInfoValueEx;
PCLUSPROP_FILETIME pFileTimeValue;
} CLUSPROP_BUFFER_HELPER, *PCLUSPROP_BUFFER_HELPER; } CLUSPROP_BUFFER_HELPER, *PCLUSPROP_BUFFER_HELPER;
#endif // MIDL_PASS #endif // MIDL_PASS
#endif // _CLUSTER_API_TYPES_ #endif // _CLUSTER_API_TYPES_
// Macro for aligning CLUSPROP buffers on a DWORD boundary. // Macro for aligning CLUSPROP buffers on a DWORD boundary.
#define ALIGN_CLUSPROP( count ) ((count + 3) & ~3) #define ALIGN_CLUSPROP( count ) ((count + 3) & ~3)
// Macros for declaring array format values // Macros for declaring array format values
skipping to change at line 2246 skipping to change at line 2988
} CLUSTER_RESOURCE_ENUM; } CLUSTER_RESOURCE_ENUM;
typedef enum CLUSTER_RESOURCE_TYPE_ENUM { typedef enum CLUSTER_RESOURCE_TYPE_ENUM {
CLUSTER_RESOURCE_TYPE_ENUM_NODES = 0x00000001, CLUSTER_RESOURCE_TYPE_ENUM_NODES = 0x00000001,
CLUSTER_RESOURCE_TYPE_ENUM_ALL = (CLUSTER_RESOURCE_TYPE_ENUM_NODES) CLUSTER_RESOURCE_TYPE_ENUM_ALL = (CLUSTER_RESOURCE_TYPE_ENUM_NODES)
} CLUSTER_RESOURCE_TYPE_ENUM; } CLUSTER_RESOURCE_TYPE_ENUM;
#endif // _CLUSTER_API_TYPES_ #endif // _CLUSTER_API_TYPES_
#ifndef MIDL_PASS #if ( !MIDL_PASS && !__midl )
HRESENUM HRESENUM
WINAPI WINAPI
ClusterResourceOpenEnum( ClusterResourceOpenEnum(
IN HRESOURCE hResource, __in HRESOURCE hResource,
IN DWORD dwType __in DWORD dwType
);
typedef HRESENUM
(WINAPI * PCLUSAPI_CLUSTER_RESOURCE_OPEN_ENUM)(
HRESOURCE hResource,
DWORD dwType
); );
DWORD DWORD
WINAPI WINAPI
ClusterResourceGetEnumCount( ClusterResourceGetEnumCount(
IN HRESENUM hResEnum __in HRESENUM hResEnum
); );
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_RESOURCE_GET_ENUM_COUNT)(
__in HRESENUM hResEnum
);
__success(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
ClusterResourceEnum( ClusterResourceEnum(
__in HRESENUM hResEnum, __in HRESENUM hResEnum,
__in DWORD dwIndex, __in DWORD dwIndex,
__out LPDWORD lpdwType, __out LPDWORD lpdwType,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszName, __out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszName,
__inout LPDWORD lpcchName __inout LPDWORD lpcchName
); );
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_RESOURCE_ENUM)(
__in HRESENUM hResEnum,
__in DWORD dwIndex,
__out LPDWORD lpdwType,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszName,
__inout LPDWORD lpcchName
);
DWORD DWORD
WINAPI WINAPI
ClusterResourceCloseEnum( ClusterResourceCloseEnum(
IN HRESENUM hResEnum __in HRESENUM hResEnum
);
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_RESOURCE_CLOSE_ENUM)(
HRESENUM hResEnum
); );
DWORD DWORD
WINAPI WINAPI
CreateClusterResourceType( CreateClusterResourceType(
IN HCLUSTER hCluster, __in HCLUSTER hCluster,
IN LPCWSTR lpszResourceTypeName, __in LPCWSTR lpszResourceTypeName,
IN LPCWSTR lpszDisplayName, __in LPCWSTR lpszDisplayName,
IN LPCWSTR lpszResourceTypeDll, __in LPCWSTR lpszResourceTypeDll,
IN DWORD dwLooksAlivePollInterval, __in DWORD dwLooksAlivePollInterval,
IN DWORD dwIsAlivePollInterval __in DWORD dwIsAlivePollInterval
);
typedef DWORD
(WINAPI * PCLUSAPI_CREATE_CLUSTER_RESOURCE_TYPE)(
__in HCLUSTER hCluster,
__in LPCWSTR lpszResourceTypeName,
__in LPCWSTR lpszDisplayName,
__in LPCWSTR lpszResourceTypeDll,
__in DWORD dwLooksAlivePollInterval,
__in DWORD dwIsAlivePollInterval
); );
DWORD DWORD
WINAPI WINAPI
DeleteClusterResourceType( DeleteClusterResourceType(
IN HCLUSTER hCluster, __in HCLUSTER hCluster,
IN LPCWSTR lpszResourceTypeName __in LPCWSTR lpszResourceTypeName
);
typedef DWORD
(WINAPI * PCLUSAPI_DELETE_CLUSTER_RESOURCE_TYPE)(
HCLUSTER hCluster,
LPCWSTR lpszResourceTypeName
); );
HRESTYPEENUM HRESTYPEENUM
WINAPI WINAPI
ClusterResourceTypeOpenEnum( ClusterResourceTypeOpenEnum(
IN HCLUSTER hCluster, __in HCLUSTER hCluster,
IN LPCWSTR lpszResourceTypeName, __in LPCWSTR lpszResourceTypeName,
IN DWORD dwType __in DWORD dwType
);
typedef HRESTYPEENUM
(WINAPI * PCLUSAPI_CLUSTER_RESOURCE_TYPE_OPEN_ENUM)(
__in HCLUSTER hCluster,
__in LPCWSTR lpszResourceTypeName,
__in DWORD dwType
); );
DWORD DWORD
WINAPI WINAPI
ClusterResourceTypeGetEnumCount( ClusterResourceTypeGetEnumCount(
IN HRESTYPEENUM hResTypeEnum __in HRESTYPEENUM hResTypeEnum
); );
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_RESOURCE_TYPE_GET_ENUM_COUNT)(
__in HRESTYPEENUM hResTypeEnum
);
__success(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
ClusterResourceTypeEnum( ClusterResourceTypeEnum(
__in HRESTYPEENUM hResTypeEnum, __in HRESTYPEENUM hResTypeEnum,
__in DWORD dwIndex, __in DWORD dwIndex,
__out LPDWORD lpdwType, __out LPDWORD lpdwType,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszName, __out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszName,
__inout LPDWORD lpcchName __inout LPDWORD lpcchName
); );
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_RESOURCE_TYPE_ENUM)(
__in HRESTYPEENUM hResTypeEnum,
__in DWORD dwIndex,
__out LPDWORD lpdwType,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszName,
__inout LPDWORD lpcchName
);
DWORD DWORD
WINAPI WINAPI
ClusterResourceTypeCloseEnum( ClusterResourceTypeCloseEnum(
IN HRESTYPEENUM hResTypeEnum __in HRESTYPEENUM hResTypeEnum
);
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_RESOURCE_TYPE_CLOSE_ENUM)(
__in HRESTYPEENUM hResTypeEnum
); );
#endif // MIDL_PASS #endif // MIDL_PASS
// //
// Network-related structures and types. // Network-related structures and types.
// //
#ifndef _CLUSTER_API_TYPES_ #ifndef _CLUSTER_API_TYPES_
// //
skipping to change at line 2362 skipping to change at line 3173
ClusterNetworkRoleClientAccess = 0x00000002, ClusterNetworkRoleClientAccess = 0x00000002,
ClusterNetworkRoleInternalAndClient = 0x00000003 ClusterNetworkRoleInternalAndClient = 0x00000003
} CLUSTER_NETWORK_ROLE; } CLUSTER_NETWORK_ROLE;
#endif // _CLUSTER_API_TYPES_ #endif // _CLUSTER_API_TYPES_
// //
// Interfaces for managing the networks of a cluster. // Interfaces for managing the networks of a cluster.
// //
#ifndef MIDL_PASS #if ( !MIDL_PASS && !__midl )
HNETWORK HNETWORK
WINAPI WINAPI
OpenClusterNetwork( OpenClusterNetwork(
IN HCLUSTER hCluster, __in HCLUSTER hCluster,
IN LPCWSTR lpszNetworkName __in LPCWSTR lpszNetworkName
);
typedef HNETWORK
(WINAPI * PCLUSAPI_OPEN_CLUSTER_NETWORK)(
__in HCLUSTER hCluster,
__in LPCWSTR lpszNetworkName
); );
BOOL BOOL
WINAPI WINAPI
CloseClusterNetwork( CloseClusterNetwork(
IN HNETWORK hNetwork __in HNETWORK hNetwork
);
typedef BOOL
(WINAPI * PCLUSAPI_CLOSE_CLUSTER_NETWORK)(
__in HNETWORK hNetwork
); );
HCLUSTER HCLUSTER
WINAPI WINAPI
GetClusterFromNetwork( GetClusterFromNetwork(
IN HNETWORK hNetwork __in HNETWORK hNetwork
);
typedef HCLUSTER
(WINAPI * PCLUSAPI_GET_CLUSTER_FROM_NETWORK)(
__in HNETWORK hNetwork
); );
HNETWORKENUM HNETWORKENUM
WINAPI WINAPI
ClusterNetworkOpenEnum( ClusterNetworkOpenEnum(
IN HNETWORK hNetwork, __in HNETWORK hNetwork,
IN DWORD dwType __in DWORD dwType
);
typedef HNETWORKENUM
(WINAPI * PCLUSAPI_CLUSTER_NETWORK_OPEN_ENUM)(
__in HNETWORK hNetwork,
__in DWORD dwType
); );
DWORD DWORD
WINAPI WINAPI
ClusterNetworkGetEnumCount( ClusterNetworkGetEnumCount(
IN HNETWORKENUM hNetworkEnum __in HNETWORKENUM hNetworkEnum
); );
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_NETWORK_GET_ENUM_COUNT)(
__in HNETWORKENUM hNetworkEnum
);
__success (return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
ClusterNetworkEnum( ClusterNetworkEnum(
__in HNETWORKENUM hNetworkEnum, __in HNETWORKENUM hNetworkEnum,
__in DWORD dwIndex, __in DWORD dwIndex,
__out LPDWORD lpdwType, __out LPDWORD lpdwType,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszName, __out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszName,
__inout LPDWORD lpcchName __inout LPDWORD lpcchName
); );
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_NETWORK_ENUM)(
__in HNETWORKENUM hNetworkEnum,
__in DWORD dwIndex,
__out LPDWORD lpdwType,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszName,
__inout LPDWORD lpcchName
);
DWORD DWORD
WINAPI WINAPI
ClusterNetworkCloseEnum( ClusterNetworkCloseEnum(
IN HNETWORKENUM hNetworkEnum __in HNETWORKENUM hNetworkEnum
);
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_NETWORK_CLOSE_ENUM)(
__in HNETWORKENUM hNetworkEnum
); );
CLUSTER_NETWORK_STATE CLUSTER_NETWORK_STATE
WINAPI WINAPI
GetClusterNetworkState( GetClusterNetworkState(
IN HNETWORK hNetwork __in HNETWORK hNetwork
);
typedef CLUSTER_NETWORK_STATE
(WINAPI * PCLUSAPI_GET_CLUSTER_NETWORK_STATE)(
__in HNETWORK hNetwork
); );
DWORD DWORD
WINAPI WINAPI
SetClusterNetworkName( SetClusterNetworkName(
IN HNETWORK hNetwork, __in HNETWORK hNetwork,
IN LPCWSTR lpszName __in LPCWSTR lpszName
);
typedef DWORD
(WINAPI * PCLUSAPI_SET_CLUSTER_NETWORK_NAME)(
__in HNETWORK hNetwork,
__in LPCWSTR lpszName
); );
__success(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
GetClusterNetworkId( GetClusterNetworkId(
__in HNETWORK hNetwork, __in HNETWORK hNetwork,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszNetworkId, __out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszNetworkId,
__inout LPDWORD lpcchName __inout LPDWORD lpcchName
); );
typedef DWORD
(WINAPI * PCLUSAPI_GET_CLUSTER_NETWORK_ID)(
__in HNETWORK hNetwork,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszNetworkId,
__inout LPDWORD lpcchName
);
DWORD DWORD
WINAPI WINAPI
ClusterNetworkControl( ClusterNetworkControl(
__in HNETWORK hNetwork, __in HNETWORK hNetwork,
__in_opt HNODE hHostNode, __in_opt HNODE hHostNode,
__in DWORD dwControlCode, __in DWORD dwControlCode,
__in_bcount_opt(nInBufferSize) LPVOID lpInBuffer, __in_bcount_opt(nInBufferSize) LPVOID lpInBuffer,
__in DWORD nInBufferSize, __in DWORD nInBufferSize,
__out_bcount_part_opt(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer, __out_bcount_part_opt(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer,
__in DWORD nOutBufferSize, __in DWORD nOutBufferSize,
__out LPDWORD lpBytesReturned __out_opt LPDWORD lpBytesReturned
);
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_NETWORK_CONTROL)(
__in HNETWORK hNetwork,
__in_opt HNODE hHostNode,
__in DWORD dwControlCode,
__in_bcount_opt(nInBufferSize) LPVOID lpInBuffer,
__in DWORD nInBufferSize,
__out_bcount_part_opt(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer,
__in DWORD nOutBufferSize,
__out_opt LPDWORD lpBytesReturned
); );
#endif // MIDL_PASS #endif // MIDL_PASS
#ifndef _CLUSTER_API_TYPES_ #ifndef _CLUSTER_API_TYPES_
// //
// Network interface-related structures and types. // Network interface-related structures and types.
// //
typedef enum CLUSTER_NETINTERFACE_STATE { typedef enum CLUSTER_NETINTERFACE_STATE {
ClusterNetInterfaceStateUnknown = -1, ClusterNetInterfaceStateUnknown = -1,
ClusterNetInterfaceUnavailable, ClusterNetInterfaceUnavailable,
ClusterNetInterfaceFailed, ClusterNetInterfaceFailed,
skipping to change at line 2464 skipping to change at line 3349
ClusterNetInterfaceUnreachable, ClusterNetInterfaceUnreachable,
ClusterNetInterfaceUp ClusterNetInterfaceUp
} CLUSTER_NETINTERFACE_STATE; } CLUSTER_NETINTERFACE_STATE;
#endif // _CLUSTER_API_TYPES_ #endif // _CLUSTER_API_TYPES_
// //
// Interfaces for managing the network interfaces of a cluster. // Interfaces for managing the network interfaces of a cluster.
// //
#ifndef MIDL_PASS #if ( !MIDL_PASS && !__midl )
HNETINTERFACE HNETINTERFACE
WINAPI WINAPI
OpenClusterNetInterface( OpenClusterNetInterface(
IN HCLUSTER hCluster, __in HCLUSTER hCluster,
IN LPCWSTR lpszInterfaceName __in LPCWSTR lpszInterfaceName
); );
typedef HNETINTERFACE
(WINAPI * PCLUSAPI_OPEN_CLUSTER_NET_INTERFACE)(
__in HCLUSTER hCluster,
__in LPCWSTR lpszInterfaceName
);
__success(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
GetClusterNetInterface( GetClusterNetInterface(
__in HCLUSTER hCluster, __in HCLUSTER hCluster,
__in LPCWSTR lpszNodeName, __in LPCWSTR lpszNodeName,
__in LPCWSTR lpszNetworkName, __in LPCWSTR lpszNetworkName,
__out_ecount_part(*lpcchInterfaceName, *lpcchInterfaceName + 1) LPWSTR lpszI nterfaceName, __out_ecount_part(*lpcchInterfaceName, *lpcchInterfaceName + 1) LPWSTR lpszI nterfaceName,
__inout LPDWORD lpcchInterfaceName __inout LPDWORD lpcchInterfaceName
); );
typedef DWORD
(WINAPI * PCLUSAPI_GET_CLUSTER_NET_INTERFACE)(
__in HCLUSTER hCluster,
__in LPCWSTR lpszNodeName,
__in LPCWSTR lpszNetworkName,
__out_ecount_part_opt(*lpcchInterfaceName, *lpcchInterfaceName + 1) LPWSTR l
pszInterfaceName,
__inout LPDWORD lpcchInterfaceName
);
BOOL BOOL
WINAPI WINAPI
CloseClusterNetInterface( CloseClusterNetInterface(
IN HNETINTERFACE hNetInterface __in HNETINTERFACE hNetInterface
);
typedef BOOL
(WINAPI * PCLUSAPI_CLOSE_CLUSTER_NET_INTERFACE)(
__in HNETINTERFACE hNetInterface
); );
HCLUSTER HCLUSTER
WINAPI WINAPI
GetClusterFromNetInterface( GetClusterFromNetInterface(
IN HNETINTERFACE hNetInterface __in HNETINTERFACE hNetInterface
);
typedef HCLUSTER
(WINAPI * PCLUSAPI_GET_CLUSTER_FROM_NET_INTERFACE)(
__in HNETINTERFACE hNetInterface
); );
CLUSTER_NETINTERFACE_STATE CLUSTER_NETINTERFACE_STATE
WINAPI WINAPI
GetClusterNetInterfaceState( GetClusterNetInterfaceState(
IN HNETINTERFACE hNetInterface __in HNETINTERFACE hNetInterface
);
typedef CLUSTER_NETINTERFACE_STATE
(WINAPI * PCLUSAPI_GET_CLUSTER_NET_INTERFACE_STATE)(
__in HNETINTERFACE hNetInterface
); );
DWORD DWORD
WINAPI WINAPI
ClusterNetInterfaceControl( ClusterNetInterfaceControl(
__in HNETINTERFACE hNetInterface, __in HNETINTERFACE hNetInterface,
__in_opt HNODE hHostNode, __in_opt HNODE hHostNode,
__in DWORD dwControlCode, __in DWORD dwControlCode,
__in_bcount_opt(nInBufferSize) LPVOID lpInBuffer, __in_bcount_opt(nInBufferSize) LPVOID lpInBuffer,
__in DWORD nInBufferSize, __in DWORD nInBufferSize,
__out_bcount_part_opt(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer, __out_bcount_part_opt(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer,
__in DWORD nOutBufferSize, __in DWORD nOutBufferSize,
__out LPDWORD lpBytesReturned __out_opt LPDWORD lpBytesReturned
);
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_NET_INTERFACE_CONTROL)(
__in HNETINTERFACE hNetInterface,
__in_opt HNODE hHostNode,
__in DWORD dwControlCode,
__in_bcount_opt(nInBufferSize) LPVOID lpInBuffer,
__in DWORD nInBufferSize,
__out_bcount_part_opt(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer,
__in DWORD nOutBufferSize,
__out_opt LPDWORD lpBytesReturned
); );
#endif // MIDL_PASS #endif // MIDL_PASS
// //
// Cluster registry update and access routines // Cluster registry update and access routines
// //
#ifndef MIDL_PASS #if ( !MIDL_PASS && !__midl )
HKEY HKEY
WINAPI WINAPI
GetClusterKey( GetClusterKey(
IN HCLUSTER hCluster, __in HCLUSTER hCluster,
IN REGSAM samDesired __in REGSAM samDesired
); );
typedef HKEY
(WINAPI * PCLUSAPI_GET_CLUSTER_KEY)(
HCLUSTER hCluster,
REGSAM samDesired
);
HKEY HKEY
WINAPI WINAPI
GetClusterGroupKey( GetClusterGroupKey(
IN HGROUP hGroup, __in HGROUP hGroup,
IN REGSAM samDesired __in REGSAM samDesired
);
typedef HKEY
(WINAPI * PCLUSAPI_GET_CLUSTER_GROUP_KEY)(
HGROUP hGroup,
REGSAM samDesired
); );
HKEY HKEY
WINAPI WINAPI
GetClusterResourceKey( GetClusterResourceKey(
IN HRESOURCE hResource, __in HRESOURCE hResource,
IN REGSAM samDesired __in REGSAM samDesired
);
typedef HKEY
(WINAPI * PCLUSAPI_GET_CLUSTER_RESOURCE_KEY)(
HRESOURCE hResource,
REGSAM samDesired
); );
HKEY HKEY
WINAPI WINAPI
GetClusterNodeKey( GetClusterNodeKey(
IN HNODE hNode, __in HNODE hNode,
IN REGSAM samDesired __in REGSAM samDesired
);
typedef HKEY
(WINAPI * PCLUSAPI_GET_CLUSTER_NODE_KEY)(
HNODE hNode,
REGSAM samDesired
); );
HKEY HKEY
WINAPI WINAPI
GetClusterNetworkKey( GetClusterNetworkKey(
IN HNETWORK hNetwork, __in HNETWORK hNetwork,
IN REGSAM samDesired __in REGSAM samDesired
);
typedef HKEY
(WINAPI * PCLUSAPI_GET_CLUSTER_NETWORK_KEY)(
__in HNETWORK hNetwork,
__in REGSAM samDesired
); );
HKEY HKEY
WINAPI WINAPI
GetClusterNetInterfaceKey( GetClusterNetInterfaceKey(
IN HNETINTERFACE hNetInterface, __in HNETINTERFACE hNetInterface,
IN REGSAM samDesired __in REGSAM samDesired
);
typedef HKEY
(WINAPI * PCLUSAPI_GET_CLUSTER_NET_INTERFACE_KEY)(
__in HNETINTERFACE hNetInterface,
__in REGSAM samDesired
); );
LONG LONG
WINAPI WINAPI
ClusterRegCreateKey( ClusterRegCreateKey(
IN HKEY hKey, __in HKEY hKey,
IN LPCWSTR lpszSubKey, __in LPCWSTR lpszSubKey,
IN DWORD dwOptions, __in DWORD dwOptions,
IN REGSAM samDesired, __in REGSAM samDesired,
IN LPSECURITY_ATTRIBUTES lpSecurityAttributes, __in_opt LPSECURITY_ATTRIBUTES lpSecurityAttributes,
OUT PHKEY phkResult, __out PHKEY phkResult,
OUT OPTIONAL LPDWORD lpdwDisposition __out_opt LPDWORD lpdwDisposition
);
typedef LONG
(WINAPI * PCLUSAPI_CLUSTER_REG_CREATE_KEY)(
__in HKEY hKey,
__in LPCWSTR lpszSubKey,
__in DWORD dwOptions,
__in REGSAM samDesired,
__in_opt LPSECURITY_ATTRIBUTES lpSecurityAttributes,
__out PHKEY phkResult,
__out_opt LPDWORD lpdwDisposition
); );
LONG LONG
WINAPI WINAPI
ClusterRegOpenKey( ClusterRegOpenKey(
IN HKEY hKey, __in HKEY hKey,
IN LPCWSTR lpszSubKey, __in LPCWSTR lpszSubKey,
IN REGSAM samDesired, __in REGSAM samDesired,
OUT PHKEY phkResult __out PHKEY phkResult
);
typedef LONG
(WINAPI * PCLUSAPI_CLUSTER_REG_OPEN_KEY)(
HKEY hKey,
LPCWSTR lpszSubKey,
REGSAM samDesired,
PHKEY phkResult
); );
LONG LONG
WINAPI WINAPI
ClusterRegDeleteKey( ClusterRegDeleteKey(
IN HKEY hKey, __in HKEY hKey,
IN LPCWSTR lpszSubKey __in LPCWSTR lpszSubKey
);
typedef LONG
(WINAPI * PCLUSAPI_CLUSTER_REG_DELETE_KEY)(
HKEY hKey,
LPCWSTR lpszSubKey
); );
LONG LONG
WINAPI WINAPI
ClusterRegCloseKey( ClusterRegCloseKey(
IN HKEY hKey __in HKEY hKey
); );
typedef LONG
(WINAPI * PCLUSAPI_CLUSTER_REG_CLOSE_KEY)(
HKEY hKey
);
__success(return == ERROR_SUCCESS)
LONG LONG
WINAPI WINAPI
ClusterRegEnumKey( ClusterRegEnumKey(
__in HKEY hKey, __in HKEY hKey,
__in DWORD dwIndex, __in DWORD dwIndex,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszName, __out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszName,
__inout LPDWORD lpcchName, __inout LPDWORD lpcchName,
__out_opt PFILETIME lpftLastWriteTime
);
typedef LONG
(WINAPI * PCLUSAPI_CLUSTER_REG_ENUM_KEY)(
__in HKEY hKey,
__in DWORD dwIndex,
__out_ecount_part(*lpcchName, *lpcchName + 1) LPWSTR lpszName,
__inout LPDWORD lpcchName,
__out PFILETIME lpftLastWriteTime __out PFILETIME lpftLastWriteTime
); );
DWORD DWORD
WINAPI WINAPI
ClusterRegSetValue( ClusterRegSetValue(
IN HKEY hKey, __in HKEY hKey,
IN LPCWSTR lpszValueName, __in LPCWSTR lpszValueName,
IN DWORD dwType, __in DWORD dwType,
IN CONST BYTE* lpData, __in CONST BYTE* lpData,
IN DWORD cbData __in DWORD cbData
);
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_REG_SET_VALUE)(
HKEY hKey,
LPCWSTR lpszValueName,
DWORD dwType,
CONST BYTE* lpData,
DWORD cbData
); );
DWORD DWORD
WINAPI WINAPI
ClusterRegDeleteValue( ClusterRegDeleteValue(
IN HKEY hKey, __in HKEY hKey,
IN LPCWSTR lpszValueName __in LPCWSTR lpszValueName
);
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_REG_DELETE_VALUE)(
HKEY hKey,
LPCWSTR lpszValueName
); );
LONG LONG
WINAPI WINAPI
ClusterRegQueryValue( ClusterRegQueryValue(
__in HKEY hKey, __in HKEY hKey,
__in LPCWSTR lpszValueName, __in LPCWSTR lpszValueName,
__out LPDWORD lpdwValueType, __out_opt LPDWORD lpdwValueType,
__out_bcount_part_opt(*lpcbData, *lpcbData) LPBYTE lpData,
__inout_opt LPDWORD lpcbData
);
typedef LONG
(WINAPI * PCLUSAPI_CLUSTER_REG_QUERY_VALUE)(
__in HKEY hKey,
__in LPCWSTR lpszValueName,
__out_opt LPDWORD lpdwValueType,
__out_bcount_part_opt(*lpcbData, *lpcbData) LPBYTE lpData, __out_bcount_part_opt(*lpcbData, *lpcbData) LPBYTE lpData,
__inout_opt LPDWORD lpcbData __inout_opt LPDWORD lpcbData
); );
__success(return == ERROR_SUCCESS)
DWORD DWORD
WINAPI WINAPI
ClusterRegEnumValue( ClusterRegEnumValue(
__in HKEY hKey, __in HKEY hKey,
__in DWORD dwIndex, __in DWORD dwIndex,
__out_ecount_part(*lpcchValueName, *lpcchValueName + 1) LPWSTR lpszValueName , __out_ecount_part(*lpcchValueName, *lpcchValueName + 1) LPWSTR lpszValueName ,
__inout LPDWORD lpcchValueName, __inout LPDWORD lpcchValueName,
__out_opt LPDWORD lpdwType,
__out_bcount_part_opt(*lpcbData, *lpcbData) LPBYTE lpData,
__inout_opt LPDWORD lpcbData
);
typedef DWORD
(WINAPI * PCLUSAPI_CLUSTER_REG_ENUM_VALUE)(
__in HKEY hKey,
__in DWORD dwIndex,
__out_ecount_part(*lpcchValueName, *lpcchValueName + 1) LPWSTR lpszValueName
,
__inout LPDWORD lpcchValueName,
__out LPDWORD lpdwType, __out LPDWORD lpdwType,
__out_bcount_part_opt(*lpcbData, *lpcbData) LPBYTE lpData, __out_bcount_part_opt(*lpcbData, *lpcbData) LPBYTE lpData,
__inout_opt LPDWORD lpcbData __inout_opt LPDWORD lpcbData
); );
LONG LONG
WINAPI WINAPI
ClusterRegQueryInfoKey( ClusterRegQueryInfoKey(
IN HKEY hKey, __in HKEY hKey,
IN LPDWORD lpcSubKeys, __in LPDWORD lpcSubKeys,
IN LPDWORD lpcchMaxSubKeyLen, __in LPDWORD lpcchMaxSubKeyLen,
IN LPDWORD lpcValues, __in LPDWORD lpcValues,
IN LPDWORD lpcchMaxValueNameLen, __in LPDWORD lpcchMaxValueNameLen,
IN LPDWORD lpcbMaxValueLen, __in LPDWORD lpcbMaxValueLen,
IN LPDWORD lpcbSecurityDescriptor, __in LPDWORD lpcbSecurityDescriptor,
IN PFILETIME lpftLastWriteTime __in PFILETIME lpftLastWriteTime
);
typedef LONG
(WINAPI * PCLUSAPI_CLUSTER_REG_QUERY_INFO_KEY)(
HKEY hKey,
LPDWORD lpcSubKeys,
LPDWORD lpcbMaxSubKeyLen,
LPDWORD lpcValues,
LPDWORD lpcbMaxValueNameLen,
LPDWORD lpcbMaxValueLen,
LPDWORD lpcbSecurityDescriptor,
PFILETIME lpftLastWriteTime
); );
LONG LONG
WINAPI WINAPI
ClusterRegGetKeySecurity ( ClusterRegGetKeySecurity (
__in HKEY hKey, __in HKEY hKey,
__in SECURITY_INFORMATION RequestedInformation, __in SECURITY_INFORMATION RequestedInformation,
__out_bcount_part(*lpcbSecurityDescriptor, *lpcbSecurityDescriptor) PSECURIT Y_DESCRIPTOR pSecurityDescriptor, __out_bcount_part(*lpcbSecurityDescriptor, *lpcbSecurityDescriptor) PSECURIT Y_DESCRIPTOR pSecurityDescriptor,
__inout LPDWORD lpcbSecurityDescriptor __inout LPDWORD lpcbSecurityDescriptor
); );
typedef LONG
(WINAPI * PCLUSAPI_CLUSTER_REG_GET_KEY_SECURITY)(
__in HKEY hKey,
__in SECURITY_INFORMATION RequestedInformation,
__out_bcount_part(*lpcbSecurityDescriptor, *lpcbSecurityDescriptor) PSECURIT
Y_DESCRIPTOR pSecurityDescriptor,
__inout LPDWORD lpcbSecurityDescriptor
);
LONG LONG
WINAPI WINAPI
ClusterRegSetKeySecurity( ClusterRegSetKeySecurity(
IN HKEY hKey, __in HKEY hKey,
IN SECURITY_INFORMATION SecurityInformation, __in SECURITY_INFORMATION SecurityInformation,
IN PSECURITY_DESCRIPTOR pSecurityDescriptor __in PSECURITY_DESCRIPTOR pSecurityDescriptor
);
typedef LONG
(WINAPI * PCLUSAPI_CLUSTER_REG_SET_KEY_SECURITY)(
HKEY hKey,
SECURITY_INFORMATION SecurityInformation,
PSECURITY_DESCRIPTOR pSecurityDescriptor
);
LONG WINAPI ClusterRegCreateBatch(
__in_opt HKEY hKey,
__out HREGBATCH* pHREGBATCH
);
typedef LONG
(WINAPI *PCLUSAPI_CLUSTER_REG_CREATE_BATCH)(
__in_opt HKEY hKey,
__out HREGBATCH* pHREGBATCH
);
LONG WINAPI ClusterRegAddCommand(
__in HREGBATCH HREGBATCH,
__in CLUSTER_REG_COMMAND dwCommand,
__in_opt LPCWSTR wzName,
__in DWORD dwOptions,
__in VOID CONST * lpData,
__in DWORD cbData
); );
typedef LONG
(WINAPI *PCLUSTER_REG_ADD_COMMAND)(
__in HREGBATCH HREGBATCH,
__in CLUSTER_REG_COMMAND dwCommand,
__in DWORD dwOptions,
__in_opt LPWSTR wzName,
__in VOID CONST * lpData,
__in DWORD cbData
);
LONG WINAPI ClusterRegCloseBatch(
__in HREGBATCH HREGBATCH,
__in BOOL bCommit,
__out_opt INT * failedCommandNumber
);
typedef LONG
(WINAPI *PCLUSTER_REG_CLOSE_BATCH)(
__in HREGBATCH HREGBATCH,
__in BOOL bCommit,
__out_opt INT * failedCommandNumber
);
//
// Cluster Create, Add Node and Destroy Cluster
//
//
// Phases that changes in cluster persistent membership will go through.
// Phase numbers may arrive in any order via the callback function.
//
typedef enum _CLUSTER_MEMBERSHIP_CHANGE_PHASE {
MembershipChangePhaseValidateNodeState = 1,
MembershipChangePhaseNodeInitialize = 3,
MembershipChangePhaseValidateNetft = 4,
MembershipChangePhaseValidateClusDisk = 5,
MembershipChangePhaseConfigureClusSvc = 6,
MembershipChangePhaseStartingClusSvc = 7,
MembershipChangePhaseInitialize = 8,
MembershipChangePhaseWaitForServiceStart = 9,
MembershipChangePhaseNodeUp = 10,
MembershipChangePhaseAddClusterProperties = 11,
MembershipChangePhaseCreateResourceTypes = 12,
MembershipChangePhaseCreateClusterGroup = 13,
MembershipChangePhaseCreateQuorumResource = 14,
MembershipChangePhaseCreateIPAddressResources = 15,
MembershipChangePhaseCreateNetworkName = 16,
MembershipChangePhaseClusterGroupOnline = 17,
MembershipChangePhaseGettingCurrentMembership = 18,
MembershipChangePhaseAddNodeToCluster = 19,
MembershipChangePhaseOfflineGroup = 20,
MembershipChangePhaseEvictNode = 21,
MembershipChangePhaseFailureCleanup = 22
} CLUSTER_MEMBERSHIP_CHANGE_PHASE;
typedef BOOL
(WINAPI *PCLUSTER_MEMBERSHIP_CHANGE_PROGRESS)(
PVOID pvCallbackArg,
CLUSTER_MEMBERSHIP_CHANGE_PHASE eMembershipPhase,
DWORD dwPercentComplete,
__in PCWSTR lpszObjectName,
DWORD dwStatus );
HCLUSTER
WINAPI
CreateCluster(
__in PCREATE_CLUSTER_CONFIG pConfig,
__in BOOL fAcceptPartialFailure,
__in_opt PCLUSTER_MEMBERSHIP_CHANGE_PROGRESS pfnProgressCallback,
__in_opt PVOID pvCallbackArg
);
typedef HCLUSTER
(WINAPI * PCLUSAPI_CREATE_CLUSTER)(
__in PCREATE_CLUSTER_CONFIG pConfig,
__in BOOL fAcceptPartialFailure,
__in_opt PCLUSTER_MEMBERSHIP_CHANGE_PROGRESS pfnProgressCallback,
__in_opt PVOID pvCallbackArg
);
HNODE
WINAPI
AddClusterNode(
__in HCLUSTER hCluster,
__in PCWSTR lpszNodeName,
__in_opt PCLUSTER_MEMBERSHIP_CHANGE_PROGRESS pfnProgressCallback,
__in_opt PVOID pvCallbackArg
);
typedef HNODE
(WINAPI * PCLUSAPI_ADD_CLUSTER_NODE)(
__in HCLUSTER hCluster,
__in PCWSTR lpszNodeName,
__in_opt PCLUSTER_MEMBERSHIP_CHANGE_PROGRESS pfnProgressCallback,
__in_opt PVOID pvCallbackArg
);
DWORD
WINAPI
DestroyCluster(
__in HCLUSTER hCluster,
__in_opt PCLUSTER_MEMBERSHIP_CHANGE_PROGRESS pfnProgressCallback,
__in_opt PVOID pvCallbackArg
);
typedef DWORD
(WINAPI * PCLUSAPI_DESTROY_CLUSTER)(
__in HCLUSTER hCluster,
__in_opt PCLUSTER_MEMBERSHIP_CHANGE_PROGRESS pfnProgressCallback,
__in_opt PVOID pvCallbackArg
);
//
// Standard Resource Type Names
//
#define CLUS_RESTYPE_NAME_GENAPP L"Generic Application"
#define CLUS_RESTYPE_NAME_GENSVC L"Generic Service"
#define CLUS_RESTYPE_NAME_GENSCRIPT L"Generic Script"
#define CLUS_RESTYPE_NAME_IPADDR L"IP Address"
#define CLUS_RESTYPE_NAME_NETNAME L"Network Name"
#define CLUS_RESTYPE_NAME_FILESHR L"File Share"
#define CLUS_RESTYPE_NAME_PRTSPLR L"Print Spooler"
#define CLUS_RESTYPE_NAME_LKQUORUM L"Local Quorum"
#define CLUS_RESTYPE_NAME_IPV6_NATIVE L"IPv6 Address"
#define CLUS_RESTYPE_NAME_IPV6_TUNNEL L"IPv6 Tunnel Address"
#define CLUS_RESTYPE_NAME_VSSTASK L"Volume Shadow Copy Service Task"
#define CLUS_RESTYPE_NAME_WINS L"WINS Service"
#define CLUS_RESTYPE_NAME_DHCP L"DHCP Service"
#define CLUS_RESTYPE_NAME_MSMQ L"Microsoft Message Queue Server"
#define CLUS_RESTYPE_NAME_NEW_MSMQ L"MSMQ"
#define CLUS_RESTYPE_NAME_MSMQ_TRIGGER L"MSMQTriggers"
#define CLUS_RESTYPE_NAME_MSDTC L"Distributed Transaction Coordinato
r"
#define CLUS_RESTYPE_NAME_NFS L"NFS Share"
#define CLUS_RESTYPE_NAME_ISNS L"Microsoft iSNS"
#define CLUS_RESTYPE_NAME_HARDDISK L"Physical Disk"
#define CLUS_RESTYPE_NAME_PHYS_DISK CLUS_RESTYPE_NAME_HARDDISK
//
// Cluster common property names
//
#define CLUSREG_NAME_ADMIN_EXT L"AdminExtensions"
#define CLUSREG_NAME_CLUS_DESC L"Description"
#define CLUSREG_NAME_CLUS_SD L"Security Descriptor"
#define CLUSREG_NAME_CLUS_DEFAULT_NETWORK_ROLE L"DefaultNetworkRole"
#define CLUSREG_NAME_QUORUM_ARBITRATION_TIMEOUT L"QuorumArbitrationTimeMax"
#define CLUSREG_NAME_QUORUM_ARBITRATION_EQUALIZER L"QuorumArbitrationTimeMin"
#define CLUSTER_HEARTBEAT_TIMEOUT_KEYNAME L"ClusSvcHeartbeatTimeout"
#define CLUSTER_HANG_RECOVERY_ACTION_KEYNAME L"HangRecoveryAction"
#define CLUSTER_CSA_VSS_STATE L"BackupInProgress"
#define CLUSREG_NAME_DISABLE_GROUP_PREFERRED_OWNER_RANDOMIZATION L"DisableGro
upPreferredOwnerRandomization"
//
// Properties and defaults for single and multi subnet delays and thresholds.
//
#define CLUSREG_NAME_SAME_SUBNET_DELAY L"SameSubnetDelay"
#define CLUSREG_NAME_CROSS_SUBNET_DELAY L"CrossSubnetDelay"
#define CLUSREG_NAME_SAME_SUBNET_THRESHOLD L"SameSubnetThreshold"
#define CLUSREG_NAME_CROSS_SUBNET_THRESHOLD L"CrossSubnetThreshold"
//
// Node common property names
//
#define CLUSREG_NAME_NODE_NAME L"NodeName"
#define CLUSREG_NAME_NODE_HIGHEST_VERSION L"NodeHighestVersion"
#define CLUSREG_NAME_NODE_LOWEST_VERSION L"NodeLowestVersion"
#define CLUSREG_NAME_NODE_DESC L"Description"
#define CLUSREG_NAME_NODE_MAJOR_VERSION L"MajorVersion"
#define CLUSREG_NAME_NODE_MINOR_VERSION L"MinorVersion"
#define CLUSREG_NAME_NODE_BUILD_NUMBER L"BuildNumber"
#define CLUSREG_NAME_NODE_CSDVERSION L"CSDVersion"
//
// Group common property names
//
#define CLUSREG_NAME_GRP_NAME L"Name"
#define CLUSREG_NAME_GRP_DESC L"Description"
#define CLUSREG_NAME_GRP_PERSISTENT_STATE L"PersistentState"
#define CLUSREG_NAME_GRP_FAILBACK_TYPE L"AutoFailbackType"
#define CLUSREG_NAME_GRP_FAILBACK_WIN_START L"FailbackWindowStart"
#define CLUSREG_NAME_GRP_FAILBACK_WIN_END L"FailbackWindowEnd"
#define CLUSREG_NAME_GRP_FAILOVER_THRESHOLD L"FailoverThreshold"
#define CLUSREG_NAME_GRP_FAILOVER_PERIOD L"FailoverPeriod"
#define CLUSREG_NAME_GRP_ANTI_AFFINITY_CLASS_NAME L"AntiAffinityClassNames"
//
// Resource common property names
//
#define CLUSREG_NAME_RES_NAME L"Name"
#define CLUSREG_NAME_RES_TYPE L"Type"
#define CLUSREG_NAME_RES_DESC L"Description"
#define CLUSREG_NAME_RES_SEPARATE_MONITOR L"SeparateMonitor"
#define CLUSREG_NAME_RES_PERSISTENT_STATE L"PersistentState"
#define CLUSREG_NAME_RES_LOOKS_ALIVE L"LooksAlivePollInterval"
#define CLUSREG_NAME_RES_IS_ALIVE L"IsAlivePollInterval"
#define CLUSREG_NAME_RES_RESTART_ACTION L"RestartAction"
#define CLUSREG_NAME_RES_RESTART_THRESHOLD L"RestartThreshold"
#define CLUSREG_NAME_RES_RESTART_PERIOD L"RestartPeriod"
#define CLUSREG_NAME_RES_RETRY_PERIOD_ON_FAILURE L"RetryPeriodOnFailure"
#define CLUSREG_NAME_RES_PENDING_TIMEOUT L"PendingTimeout"
#define CLUSREG_NAME_RES_DEADLOCK_TIMEOUT L"DeadlockTimeout"
#define CLUSREG_NAME_RES_MONITOR_PID L"MonitorProcessId"
#define CLUSREG_NAME_RES_INTERNAL_STATE L"InternalState"
//
// Resource Type common property names
//
#define CLUSREG_NAME_RESTYPE_NAME L"Name"
#define CLUSREG_NAME_RESTYPE_DESC L"Description"
#define CLUSREG_NAME_RESTYPE_DLL_NAME L"DllName"
#define CLUSREG_NAME_RESTYPE_ADMIN_EXTENSIONS L"AdminExtensions"
#define CLUSREG_NAME_RESTYPE_LOOKS_ALIVE CLUSREG_NAME_RES_LOOKS_ALIVE
#define CLUSREG_NAME_RESTYPE_IS_ALIVE CLUSREG_NAME_RES_IS_ALIVE
#define CLUSREG_NAME_RESTYPE_PENDING_TIMEOUT CLUSREG_NAME_RES_PENDING_TIMEOUT
#define CLUSREG_NAME_RESTYPE_DEADLOCK_TIMEOUT CLUSREG_NAME_RES_DEADLOCK_TIMEOU
T
//
// Network common property names
//
#define CLUSREG_NAME_NET_NAME L"Name"
#define CLUSREG_NAME_NET_IPV6_ADDRESSES L"IPv6Addresses"
#define CLUSREG_NAME_NET_IPV6_PREFIXLENGTHS L"IPv6PrefixLengths"
#define CLUSREG_NAME_NET_IPV4_ADDRESSES L"IPv4Addresses"
#define CLUSREG_NAME_NET_IPV4_PREFIXLENGTHS L"IPv4PrefixLengths"
#define CLUSREG_NAME_NET_ADDRESS L"Address"
#define CLUSREG_NAME_NET_ADDRESS_MASK L"AddressMask"
#define CLUSREG_NAME_NET_DESC L"Description"
#define CLUSREG_NAME_NET_ROLE L"Role"
//
// Network Interface common property names
//
#define CLUSREG_NAME_NETIFACE_NAME L"Name"
#define CLUSREG_NAME_NETIFACE_NODE L"Node"
#define CLUSREG_NAME_NETIFACE_NETWORK L"Network"
#define CLUSREG_NAME_NETIFACE_ADAPTER_NAME L"Adapter"
#define CLUSREG_NAME_NETIFACE_ADAPTER_ID L"AdapterId"
#define CLUSREG_NAME_NETIFACE_DHCP_ENABLED L"DhcpEnabled"
#define CLUSREG_NAME_NETIFACE_IPV6_ADDRESSES L"IPv6Addresses"
#define CLUSREG_NAME_NETIFACE_IPV4_ADDRESSES L"IPv4Addresses"
#define CLUSREG_NAME_NETIFACE_ADDRESS L"Address"
#define CLUSREG_NAME_NETIFACE_DESC L"Description"
//
// Resource private property names
//
//
// Physical Disk
//
#define CLUSREG_NAME_PHYSDISK_DISKIDTYPE L"DiskIdType"
#define CLUSREG_NAME_PHYSDISK_DISKSIGNATURE L"DiskSignature"
#define CLUSREG_NAME_PHYSDISK_DISKIDGUID L"DiskIdGuid"
#define CLUSREG_NAME_PHYSDISK_DISKRUNCHKDSK L"DiskRunChkDsk"
#define CLUSREG_NAME_PHYSDISK_DISKUNIQUEIDS L"DiskUniqueIds"
#define CLUSREG_NAME_PHYSDISK_DISKVOLUMEINFO L"DiskVolumeInfo"
#define CLUSREG_NAME_PHYSDISK_DISKARBTYPE L"DiskArbType"
#define CLUSREG_NAME_PHYSDISK_DISKARBINTERVAL L"DiskArbInterval"
#define CLUSREG_NAME_PHYSDISK_DISKPATH L"DiskPath"
#define CLUSREG_NAME_PHYSDISK_DISKRELOAD L"DiskReload"
#define CLUSREG_NAME_PHYSDISK_MAINTMODE L"MainteanceMode"
#define CLUSREG_NAME_PHYSDISK_DISKIODELAY L"MaxIoLatency"
#define CLUSREG_NAME_PHYSDISK_MIGRATEFIXUP L"MigrateDriveLetters"
//
// Generic Application
//
#define CLUSREG_NAME_GENAPP_COMMAND_LINE L"CommandLine"
#define CLUSREG_NAME_GENAPP_CURRENT_DIRECTORY L"CurrentDirectory"
#define CLUSREG_NAME_GENAPP_INTERACT_WITH_DESKTOP L"InteractWithDesktop"
#define CLUSREG_NAME_GENAPP_USE_NETWORK_NAME L"UseNetworkName"
//
// Generic Script
//
#define CLUSREG_NAME_GENSCRIPT_SCRIPT_FILEPATH L"ScriptFilepath"
//
// Generic Service
//
#define CLUSREG_NAME_GENSVC_SERVICE_NAME L"ServiceName"
#define CLUSREG_NAME_GENSVC_STARTUP_PARAMS L"StartupParameters"
#define CLUSREG_NAME_GENSVC_USE_NETWORK_NAME L"UseNetworkName"
//
// IPv4 Address
//
#define CLUSREG_NAME_IPADDR_NETWORK L"Network"
#define CLUSREG_NAME_IPADDR_ADDRESS L"Address"
#define CLUSREG_NAME_IPADDR_SUBNET_MASK L"SubnetMask"
#define CLUSREG_NAME_IPADDR_ENABLE_NETBIOS L"EnableNetBIOS"
#define CLUSREG_NAME_IPADDR_OVERRIDE_ADDRMATCH L"OverrideAddressMatch"
#define CLUSREG_NAME_IPADDR_ENABLE_DHCP L"EnableDhcp"
#define CLUSREG_NAME_IPADDR_LEASE_OBTAINED_TIME L"LeaseObtainedTime"
#define CLUSREG_NAME_IPADDR_LEASE_TERMINATES_TIME L"LeaseExpiresTime"
#define CLUSREG_NAME_IPADDR_T1 L"T1"
#define CLUSREG_NAME_IPADDR_T2 L"T2"
#define CLUSREG_NAME_IPADDR_DHCP_SERVER L"DhcpServer"
#define CLUSREG_NAME_IPADDR_DHCP_ADDRESS L"DhcpAddress"
#define CLUSREG_NAME_IPADDR_DHCP_SUBNET_MASK L"DhcpSubnetMask"
//
// IPv6 Address
//
#define CLUSREG_NAME_IPV6_NATIVE_NETWORK L"Network"
#define CLUSREG_NAME_IPV6_NATIVE_ADDRESS L"Address"
#define CLUSREG_NAME_IPV6_NATIVE_PREFIX_LENGTH L"PrefixLength"
#define CLUSREG_NAME_IPV6_TUNNEL_ADDRESS L"Address"
#define CLUSREG_NAME_IPV6_TUNNEL_TUNNELTYPE L"TunnelType"
//
// Network Name
//
#define CLUSREG_NAME_NETNAME_NAME L"Name"
#define CLUSREG_NAME_NETNAME_CREATING_DC L"CreatingDC"
#define CLUSREG_NAME_NETNAME_OBJECT_ID L"ObjectGUID"
#define CLUSREG_NAME_NETNAME_DNS_NAME L"DnsName"
#define CLUSREG_NAME_NETNAME_REMAP_PIPE_NAMES L"RemapPipeNames"
#define CLUSREG_NAME_NETNAME_RESOURCE_DATA L"ResourceData"
#define CLUSREG_NAME_NETNAME_REQUIRE_DNS L"RequireDNS"
#define CLUSREG_NAME_NETNAME_REQUIRE_KERBEROS L"RequireKerberos"
#define CLUSREG_NAME_NETNAME_SCOPED_NAME L"ScopedName"
#define CLUSREG_NAME_NETNAME_STATUS_NETBIOS L"StatusNetBIOS"
#define CLUSREG_NAME_NETNAME_STATUS_DNS L"StatusDNS"
#define CLUSREG_NAME_NETNAME_STATUS_KERBEROS L"StatusKerberos"
#define CLUSREG_NAME_NETNAME_VCO_CONTAINER L"VcoContainer"
#define CLUSREG_NAME_NETNAME_LAST_DNS_UPDATE L"LastDNSUpdateTime"
#define CLUSREG_NAME_NETNAME_CONTAINERGUID L"CryptoContainerGUID"
#define CLUSREG_NAME_NETNAME_HOST_TTL L"HostRecordTTL"
#define CLUSREG_NAME_NETNAME_PUBLISH_PTR L"PublishPTRRecords"
//
// Print Spooler
//
#define CLUSREG_NAME_PRTSPOOL_DEFAULT_SPOOL_DIR L"DefaultSpoolDirectory"
#define CLUSREG_NAME_PRTSPOOL_TIMEOUT L"JobCompletionTimeout"
//
// File Share
//
#define CLUSREG_NAME_FILESHR_SHARE_NAME L"ShareName"
#define CLUSREG_NAME_FILESHR_PATH L"Path"
#define CLUSREG_NAME_FILESHR_REMARK L"Remark"
#define CLUSREG_NAME_FILESHR_MAX_USERS L"MaxUsers"
#define CLUSREG_NAME_FILESHR_SD L"Security Descriptor"
#define CLUSREG_NAME_FILESHR_SHARE_SUBDIRS L"ShareSubDirs"
#define CLUSREG_NAME_FILESHR_HIDE_SUBDIR_SHARES L"HideSubDirShares"
#define CLUSREG_NAME_FILESHR_IS_DFS_ROOT L"IsDfsRoot"
#define CLUSREG_NAME_FILESHR_SHARE_FLAGS L"ShareFlags"
//
// DHCP Service
//
#define CLUSREG_NAME_DHCP_DATABASE_PATH L"DatabasePath"
#define CLUSREG_NAME_DHCP_BACKUP_PATH L"BackupPath"
#define CLUSREG_NAME_LOG_FILE_PATH L"LogFilePath"
//
// WINS Service
//
#define CLUSREG_NAME_WINS_DATABASE_PATH L"DatabasePath"
#define CLUSREG_NAME_WINS_BACKUP_PATH L"BackupPath"
//
// Local Quorum
//
#define CLUSREG_NAME_LKQUORUM_PATH L"Path"
#define CLUSREG_NAME_LKQUORUM_DEBUG L"Debug"
//
// Volume Shadow Copy Service Task
//
#define CLUSREG_NAME_VSSTASK_CURRENTDIRECTORY L"CurrentDirectory"
#define CLUSREG_NAME_VSSTASK_APPNAME L"ApplicationName"
#define CLUSREG_NAME_VSSTASK_APPPARAMS L"ApplicationParams"
#define CLUSREG_NAME_VSSTASK_TRIGGERARRAY L"TriggerArray"
#if _MSC_VER >= 1200 #if _MSC_VER >= 1200
#pragma warning(pop) // restore 4200/4201 #pragma warning(pop) // restore 4200/4201
#else #else
#pragma warning( default : 4200 ) // nonstandard extension used : zero-sized arr ay in struct/union #pragma warning( default : 4200 ) // nonstandard extension used : zero-sized arr ay in struct/union
#pragma warning( default : 4201 ) // nonstandard extension used : nameless struc t/union #pragma warning( default : 4201 ) // nonstandard extension used : nameless struc t/union
#endif #endif
#endif // MIDL_PASS #endif // MIDL_PASS
#ifdef __cplusplus #ifdef __cplusplus
} } // extern "C"
#endif #endif
#ifndef _CLUSTER_API_TYPES_ #ifndef _CLUSTER_API_TYPES_
#define _CLUSTER_API_TYPES_ #define _CLUSTER_API_TYPES_
#endif // _CLUSTER_API_TYPES_ #endif // _CLUSTER_API_TYPES_
#endif // _CLUSTER_API_ #endif // _CLUSTER_API_
 End of changes. 203 change blocks. 
229 lines changed or deleted 1764 lines changed or added

This html diff was produced by rfcdiff 1.41.