6 Appendix A: Full IDL

 For ease of implementation, the full IDL follows, where "ms-oaut.idl" refers to the IDL found in [MS-OAUT] Appendix A. The syntax uses the IDL syntax extensions defined in [MS-RPCE] sections 2.2.4 and 3.1.1.5.1. For example, as noted in [MS-RPCE] section 2.2.4.9, a pointer_default declaration is not required and pointer_default(unique) is assumed.

This IDL imports the IDL from the OLE Automation Protocol [MS-OAUT] section 6, to provide support for the SAFEARRAY type definition.

 import "ms-oaut.idl";
    #define SAFEARRAY(type) SAFEARRAY
    
    typedef enum _CPREP_DISKID_ENUM {
        CprepIdSignature = 0x00000000,
        CprepIdGuid      = 0x00000001,
        CprepIdNumber    = 0x00000fa0,
        CprepIdUnknown   = 0x00001388
    } CPREP_DISKID_ENUM, *PCPREP_DISKID_ENUM;
    
    typedef struct _CPREP_DISKID {
        CPREP_DISKID_ENUM       DiskIdType;
        [switch_is(DiskIdType)] union {
            [case(CprepIdSignature)]    unsigned long DiskSignature;
            [case(CprepIdGuid)]         GUID          DiskGuid;
            [case(CprepIdNumber)]       unsigned long DeviceNumber;
            [case(CprepIdUnknown)]      unsigned long Junk;
        };
    } CPREP_DISKID, *PCPREP_DISKID;
    
    typedef enum _DiskStackType {
        DiskStackScsiPort = 0x00000000,
        DiskStackStorPort = 0x00000001,
        DiskStackFullPort = 0x00000002
    } DiskStackType;
    
    typedef struct _CPREP_SCSI_ADDRESS {
        unsigned long  Length;
        unsigned char  PortNumber;
        unsigned char  PathId;
        unsigned char  TargetId;
        unsigned char  Lun;
    } CPREP_SCSI_ADDRESS, *PCPREP_SCSI_ADDRESS;
    
    typedef struct _DISK_PROPS {
        unsigned long       DiskNumber;
        CPREP_DISKID        DiskId;
        unsigned long       DiskBusType;
        DiskStackType       StackType;
        CPREP_SCSI_ADDRESS  ScsiAddress;
        long                DiskIsClusterable;
        wchar_t             AdapterDesc[260];
        unsigned long       NumPaths; 
        unsigned long       Flags;
    } DISK_PROPS, * PDISK_PROPS;
    
    typedef struct _DISK_PROPS_EX {
        ULONG               DiskNumber;
        CPREP_DISKID        DiskId;
        ULONG               DiskBusType;
        DiskStackType       StackType;
        CPREP_SCSI_ADDRESS  ScsiAddress;
        BOOL                DiskIsClusterable;
        wchar_t             AdapterDesc[260];
        [string] LPWSTR     pwszFriendlyName;
        unsigned long       NumPaths;
        unsigned long       Flags;
        unsigned long       ExtendedFlags;
        [string] LPWSTR     pwszPoolName;
        [string] LPWSTR     pwszPage83Id;
        [string] LPWSTR     pwszSerialNumber;
        GUID                guidPoolId;
    } DISK_PROPS_EX, * PDISK_PROPS_EX;
    
    typedef  enum _CLUSTER_NETWORK_PROFILE {
      ClusterNetworkProfilePublic = 0x00,
      ClusterNetworkProfilePrivate = 0x01,
      ClusterNetworkProfileDomainAuthenticated = 0x02
    } CLUSTER_NETWORK_PROFILE, *PCLUSTER_NETWORK_PROFILE;
    
    [
        object,
        uuid(12108A88-6858-4467-B92F-E6CF4568DFB6),
        pointer_default(unique)
    ]
    interface IClusterStorage2 : IUnknown
    {
        HRESULT CprepDiskRawRead(
          [in] CPREP_DISKID DiskId,
          [in] unsigned long ulSector,
          [in] unsigned long cbData, 
          [out, size_is(cbData), length_is(*pcbDataRead)] byte *pbData,
          [out] unsigned long *pcbDataRead,
          [out] unsigned long *ulLatency
        );
    
        HRESULT CprepDiskRawWrite(
          [in] CPREP_DISKID DiskId, 
          [in] unsigned long ulSector, 
          [in] unsigned long cbData, 
          [in, size_is(cbData)] byte* pbData,
          [out] unsigned long* pcbDataWritten,
          [out] unsigned long *ulLatency
        );
    
        HRESULT CprepPrepareNode(
          [out] unsigned long* pulMajorVersion,
          [out] unsigned long* pulMinorVersion,
          [out] unsigned long* pdwCPrepVersion
        );
    
        HRESULT CprepPrepareNodePhase2(
          [in] unsigned long Flags, 
          [out] unsigned long* pulNumDisks
        );
    
        HRESULT CprepDiskGetProps(
          [in] CPREP_DISKID DiskId, 
          [out] DISK_PROPS * DiskProps
        );
    
        HRESULT Opnum8NotUsedOnWire();
        HRESULT Opnum9NotUsedOnWire();
        HRESULT Opnum10NotUsedOnWire();
        HRESULT Opnum11NotUsedOnWire();
    
        HRESULT CprepDiskStopDefense(
          [in] CPREP_DISKID DiskId
        );
    
        HRESULT CprepDiskOnline(
          [in] CPREP_DISKID DiskId, 
          [out] unsigned long* MaxPartitionNumber
        );
    
        HRESULT CprepDiskVerifyUnique(
          [in] CPREP_DISKID DiskId
        );
    
        HRESULT Opnum15NotUsedOnWire();
        HRESULT Opnum16NotUsedOnWire();
    
        HRESULT CprepDiskWriteFileData(
          [in] CPREP_DISKID DiskId, 
          [in] unsigned long ulPartition,
          [in, string] wchar_t* FileName,
          [in] unsigned long cbDataIn, 
          [in, size_is(cbDataIn)] byte* DataIn
        );
    
        HRESULT CprepDiskVerifyFileData(
          [in] CPREP_DISKID DiskId, 
          [in] unsigned long ulPartition,
          [in, string] wchar_t* FileName,
          [in] unsigned long cbDataIn, 
          [in, size_is(cbDataIn)] byte* DataIn
        );
    
        HRESULT CprepDiskDeleteFile(
          [in] CPREP_DISKID DiskId,
          [in] unsigned long ulPartition,
          [in, string] wchar_t* FileName
        );
    
        HRESULT CprepDiskOffline(
          [in] CPREP_DISKID DiskId
        );
    
        HRESULT Opnum21NotUsedOnWire();
    
        HRESULT CprepDiskGetUniqueIds(
          [in] CPREP_DISKID DiskId, 
          [in] unsigned long cbData, 
          [out, size_is(cbData), length_is(*pcbDataOut)] byte* pbData,
          [out] unsigned long *pcbDataOut,
          [out] unsigned long *pcbNeeded
        );
    
        HRESULT CprepDiskAttach(
          [in] CPREP_DISKID DiskId
        );
    
        HRESULT CprepDiskPRArbitrate(
          [in] CPREP_DISKID DiskId
        );
    
        HRESULT CprepDiskPRRegister(
          [in] CPREP_DISKID DiskId
        );
    
        HRESULT CprepDiskPRUnRegister(
          [in] CPREP_DISKID DiskId
        );
    
        HRESULT CprepDiskPRReserve(
          [in] CPREP_DISKID DiskId
        );
    
        HRESULT CprepDiskPRRelease(
          [in] CPREP_DISKID DiskId
        );
    
        HRESULT CprepDiskDiskPartitionIsNtfs(
          [in] CPREP_DISKID DiskId, 
          [in] unsigned long ulPartition
        );
    
        HRESULT CprepDiskGetArbSectors(
          [in] CPREP_DISKID DiskId, 
          [out] unsigned long *SectorX,
          [out] unsigned long *SectorY
        );
    
        HRESULT CprepDiskIsPRPresent(
          [in] CPREP_DISKID DiskId, 
          [out] unsigned long *Present
        );
    
        HRESULT CprepDiskPRPreempt(
          [in] CPREP_DISKID DiskId
        );
    
        HRESULT CprepDiskPRClear(
          [in] CPREP_DISKID DiskId
        );
    
        HRESULT CprepDiskIsOnline(
          [in] CPREP_DISKID DiskId
        );
    
        HRESULT CprepDiskSetOnline(
          [in] CPREP_DISKID DiskId
        );
    
        HRESULT CprepDiskGetFSName(
          [in] CPREP_DISKID DiskId,
          [in] unsigned long Partition,
          [out] wchar_t FsName[100]
        );
    
        HRESULT CprepDiskIsReadable(
          [in] CPREP_DISKID DiskId
        );
    
        HRESULT CprepDiskGetDsms(
          [in] unsigned long Size,
          [out] unsigned long *pReserved,
          [out, size_is(Size), length_is(*pReserved)] byte *RegisteredDsms
        );
    };
    
    
    [
      object,
      uuid(11942D87-A1DE-4E7F-83FB-A840D9C5928D),
      helpstring("IClusterStorage3 Interface"),
      pointer_default(unique)
    ]
    
    interface IClusterStorage3 : IUnknown{
    
      [helpstring("method DiskGetUniqueIds3")]
        HRESULT CprepDiskGetUniqueIds3(
          [in]                           CPREP_DISKID      DiskId,
          [out, size_is( ,*pcbDihSize)]  BYTE              **ppbDeviceIdHeader,
          [out]                          ULONG             *pcbDihSize,
          [out, size_is( ,*pcbDdSize)]   BYTE              **ppDeviceDescriptor,
          [out]                          ULONG             *pcbDdSize
        );
    
        [helpstring("method CprepCheckNetFtBindings3")]
        HRESULT CprepCheckNetFtBindings3( 
             void 
        );
    
        [helpstring("method CprepCsvTestSetup3")]
        HRESULT CprepCsvTestSetup3(
          [in]                                GUID       TestShareGuid,
          [in, string]                        LPWSTR     Reserved
        );
    
        [helpstring("method CprepIsNodeClustered3")]
        HRESULT CprepIsNodeClustered3(
          [out]                                BOOLEAN     *pbIsClusterNode
        );
    
        [helpstring("method CprepCreateNewSmbShares3")]
        HRESULT CprepCreateNewSmbShares3(
          [out, string, size_is(,*pdwNumberOfPaths)]  LPWSTR      **ppwszSharePaths,
          [out]                                       DWORD       *pdwNumberOfPaths
        );
    
        [helpstring("method CprepConnectToNewSmbShares3")]
        HRESULT CprepConnectToNewSmbShares3(
          [in, string, size_is(dwNumberOfPaths,)]  LPWSTR      *ppwszSharePaths,
          [in]                                     DWORD       dwNumberOfPaths
                );
    
        [helpstring("method CprepDiskGetProps3")]
        HRESULT CprepDiskGetProps3(
          [in]                            CPREP_DISKID    DiskId,
          [out]                           DISK_PROPS_EX   *pDiskProps
        );
    
    
        [helpstring("method CprepDiskIsReadOnly3")]
        HRESULT CprepDiskIsReadOnly3(
          [in]                             CPREP_DISKID    DiskId,
          [out]                            BOOLEAN         *pbReadOnly
        );
    
    
        [helpstring("method CprepDiskPRRegister3")]
        HRESULT CprepDiskPRRegister3(
          [in]                             CPREP_DISKID    DiskId,
          [in]                             ULONGLONG       OldPrKey,
          [in]                             ULONGLONG       NewPrKey
        );
    
        [helpstring("method CprepDiskFindKey3")]
        HRESULT CprepDiskFindKey3(
          [in]                             CPREP_DISKID    DiskId,
          [in]                             ULONGLONG       Key,
          [out]                            BOOLEAN         *pbFound
        );
    
        [helpstring("method CprepDiskPRPreempt3")]
        HRESULT CprepDiskPRPreempt3(
          [in]                              CPREP_DISKID    DiskId,
          [in]                              ULONGLONG       OwnerKey,
          [in]                              ULONGLONG       NewKey
        );
    
        [helpstring("method CprepDiskPRReserve3")]
        HRESULT CprepDiskPRReserve3(
          [in]                             CPREP_DISKID    DiskId,
          [in]                             ULONGLONG       Key
        );
    
        [helpstring("method CprepDiskIsPRPresent3")]
        HRESULT CprepDiskIsPRPresent3(
          [in]                             CPREP_DISKID    DiskId,
          [in]                             ULONGLONG       Key
        );
    
        [helpstring("method CprepDiskPRRelease3")]
        HRESULT CprepDiskPRRelease3(
          [in]                             CPREP_DISKID    DiskId,
          [in]                             ULONGLONG       Key
        );
    
        [helpstring("method CprepDiskPRClear3")]
        HRESULT CprepDiskPRClear3(
          [in]                             CPREP_DISKID    DiskId,
          [in]                             ULONGLONG       Key
        );
    };
    
    typedef struct NODE_ROUTE_INFO {
      BSTR                    remoteVirtualIP;
      SAFEARRAY(BSTR)         localUnicastIPs;
      SAFEARRAY(BSTR)         remoteUnicastIPs;
      SAFEARRAY(ULONG)        indices;
    } NODE_ROUTE_INFO;
    
    typedef struct ADD_ROUTES_REQUEST {
       BSTR                        localVirtualIP;
       SAFEARRAY(NODE_ROUTE_INFO)  nodeRouteInfos;
    } ADD_ROUTES_REQUEST;
    
    typedef enum ROUTE_STATUS {
       DOWN,
       UP,
       UP_DOWN
    } ROUTE_STATUS;
    
    typedef struct ROUTE_LOSS_AND_STATE {
       ULONG            packetLoss;
       ROUTE_STATUS     status;
    } ROUTE_LOSS_AND_STATE;
    
    typedef struct ADD_ROUTES_REPLY {
       SAFEARRAY(ULONG)                    indices;
       SAFEARRAY(ROUTE_LOSS_AND_STATE)     replies;
       BOOLEAN                             routeUnavailable;
    } ADD_ROUTES_REPLY;
                  
    typedef enum DiskMediaType {
       DiskMediaTypeUnknown = 0x00000000,
       DiskMediaTypeHDD = 0x00000001,
       DiskMediaTypeSSD = 0x00000002,
       DiskMediaTypeSCM = 0x00000003
    } DiskMediaType;
    
    typedef enum _ClusterLogExFlag {
       ClusterLogFlagNone = 0,
       ClusterLogFlagLocalTime = 1,
       ClusterLogFlagSkipClusterState = 2,
    } ClusterLogExFlag;
    
    typedef enum _ClusterLogType {
      ClusterLogTypeCluster = 0,
      ClusterLogTypeHealth = 1,
      ClusterLogTypeClusterSet = 2,
      ClusterLogTypeNetwork = 3,
      ClusterLogType = 4
   } ClusterLogType;
    
    typedef enum CLUSTER_CERTTYPE {
      Cluster_SChannel = 0,
      ClusterSet_SChannel = 1,
      Cluster_PKU2U = 2,
      ClusterSet_PKU2U = 3
    } CLUSTER_CERTTYPE;
    
    typedef struct _CLUSTER_CERT {
      ULONG  CbCertData;
      ULONG  CbKeyData;
      BYTE  CertData[1024 * 5];
      BYTE  KeyData[1024 * 10];
      WCHAR  ClusterSecret[32 + 1];
    } CLUSTER_CERT;
    
    [
      object,
      uuid(2931C32C-F731-4c56-9FEB-3D5F1C5E72BF),
      pointer_default(unique)
    ]
    interface IClusterNetwork2 : IUnknown
    {
        HRESULT SendRTMessage(
          [in] BSTR SourceIPAddress,
          [in] BSTR DestIPAddress,
          [in] unsigned short DestPort,
          [in] unsigned short AddressFamily,
          [in] unsigned long MessageSize, 
          [in] unsigned long Timeout,
          [out] unsigned long* RTElapsedTime
        );
    
        HRESULT InitializeNode(
          [in] unsigned short RequestUDPPort,
          [out] unsigned short *BoundUDPPort,
          [out] unsigned long* NodeMajorVersion,
          [out] unsigned long* NodeMinorVersion,
          [out] unsigned long* ClusprepVersion
        );
    
        HRESULT GetIpConfigSerialized(
          [in]  BOOLEAN ApplyClusterFilter,
          [out] SAFEARRAY(byte) * Data,
          [out] int* pcbOut
        );
    
        HRESULT CleanupNode ();
    
        HRESULT QueryFirewallConfiguration(
          [out] BOOLEAN* serverRulesEnabled,
          [out] BOOLEAN* mgmtRulesEnabled
        );
    
        HRESULT ProcessAddRoutes(
          [in]  const ADD_ROUTES_REQUEST* request
        );
    
        HRESULT GetAddRoutesStatus(
          [out] ADD_ROUTES_REPLY* reply
        );
    
        HRESULT Opnum10Reserved();
    
        HRESULT CancelAddRoutesRequest();
    };
    
    [
        object,
        uuid(D6105110-8917-41A5-AA32-8E0AA2933DC9),
        pointer_default(unique)
    ]
    
    interface IClusterCleanup : IUnknown
    {
        HRESULT CleanUpEvictedNode(
          [in] unsigned long DelayBeforeCleanup,
          [in] unsigned long TimeOut,
          [in] unsigned long Flags
        );
    
        HRESULT ClearPR(
          [in] unsigned long DeviceNumber
        );
    };
    
    [
        object,
        uuid(491260B5-05C9-40D9-B7F2-1F7BDAE0927F),
        pointer_default(unique)
    ]
    interface IClusterSetup : IUnknown
    {
        HRESULT ConfigSvcSecret(
          [in] BSTR SecretBLOB
        );
    
        HRESULT RetrieveSvcSecret(
          [out] BSTR* SecretBLOB
        );
    
        HRESULT RetrieveHostLabel(
          [out] BSTR* HostLabel
        );
    
        HRESULT GetFunctionalLevel(
          [out] WORD* FunctionalLevel
        );
         HRESULT Opnum7Reserved();
    
         HRESULT Opnum8Reserved();
    
        HRESULT ConfigClusterCert(
          [in] CLUSTER_CERT * ClusterCert
        );
    
        HRESULT RetrieveClusterCert(
          [out] CLUSTER_CERT * ClusterCert
        );
    
        HRESULT GenerateClusterCert(
          [in,out] CLUSTER_CERT * ClusterCert
        );
    
          HRESULT GetUpgradeVersion(
          [out] WORD* UpgradeVersion
        );
    
        HRESULT Opnum13Reserved();
    
        HRESULT ConfigClusterCerV2(
          [in] CLUSTER_CERT * ClusterCert,
          [in] CLUSTER_CERTTYPE certType
        );
    
        HRESULT RetrieveClusterCertV2(
          [in] CLUSTER_CERT * ClusterCert,
          [out] CLUSTER_CERTTYPE *certType
        );
    
        HRESULT GenerateClusterCertV2(
          [in, out] CLUSTER_CERT * ClusterCert,
          [in] CLUSTER_CERTTYPE certType
        );
    };
    
    [
        object,
        uuid(85923CA7-1B6B-4E83-A2E4-F5BA3BFBB8A3),
        pointer_default(unique)
    ]
    interface IClusterLog : IUnknown
    {
        HRESULT GenerateClusterLog(
          [out] BSTR* LogFilePath
        );
    
        HRESULT GenerateTimeSpanLog(
          [in] unsigned long SpanMinutes, 
          [out] BSTR* LogFilePath
        );
    
        HRESULT GenerateClusterLogInLocalTime(
          [out] BSTR* LogFilePath
        );
    
        HRESULT GenerateTimeSpanLogInLocalTime(
          [in] ULONG SpanMinutes,
          [out] BSTR* LogFilePath
        );
    };
    
    [
        object,
        uuid (BD7C23C2-C805-457C-8F86-D17FE6B9D19F),
        pointer_default(unique)
    ]
    interface IClusterLogEx : IUnknown{
        HRESULT GenerateClusterLog(
          [in] ULONG SpanMinutes,
          [in] ClusterLogExFlag flags,
          [out] BSTR* LogFilePath
        );
    
        HRESULT GenerateClusterHealthLog(
          [in] ULONG SpanMinutes,
          [in] ClusterLogExFlag flags,
          [out] BSTR* LogFilePath
        );
    };
    
        HRESULT GenerateClusterSetLog(
          [in] ULONG SpanMinutes,
          [in] ClusterLogExFlag flags,
          [out] BSTR* LogFilePath
        );
    
        HRESULT GenerateClusterNetworkhLog(
          [in] ULONG SpanMinutes,
          [in] int NetworkDiagnosticsLevel,
          [in] ClusterLogExFlag flags,
          [out] BSTR* LogFilePath
        );
    
        HRESULT ExportClusterPerformanceHistory(
          [in] BSTR Pattern,
          [in] BSTER StreamName,
          [in] ClusterLogExFlag flags,
          [out] BSTR* LogFilePath
        );
    
        HRESULT GenerateNetftLog(
          [in] ULONG SpanMinutes,
          [in] ClusterLogExFlag flags,
          [out] BSTR* LogFilePath
        );
    };
    
     [
        object,
        uuid(2510EA7D-C355-40C9-852C-E3B1B1338D67),
        pointer_default(unique)
    ]
    interface IClusterLogEx2 : IClusterLogEx{
        HRESULT GenerateLogEx(
          [in] ClusterLogType Type,
          [in] ULONG SpanMinutes,
          [in] ClusterLogExFlag flags,
          [out] BSTR* LogFilePath,
          [in] BOOL NoCollate
        );
    
        HRESULT GetCountLogs(
          [out] ULONG* Count
        );
    
        HRESULT GetLogFilePath(
          [in] ULONG Index,
          [out] BSTR* LogFilePath
        );
    };
    
    [
        object,
        uuid(F1D6C29C-8FBE-4691-8724-F6D8DEAEAFC8),
        pointer_default(unique)
    ]
    interface IClusterFirewall : IUnknown{
        HRESULT InitializeAdapterConfiguration (
          [out] unsigned long* cRetAdapters
        );
        HRESULT GetNextAdapterFirewallConfiguration (
          [in] unsigned long idx,
          [out] GUID * adapterId,
          [out] CLUSTER_NETWORK_PROFILE * adapterProfile,
          [out] BOOLEAN* serverRulesEnabled,
          [out] BOOLEAN* managementRulesEnabled,
          [out] BOOLEAN* commonRulesEnabled
        );
    };
    
    [
        object,
        uuid(E3C9B851-C442-432B-8FC6-A7FAAFC09D3B),
        pointer_default(unique)
    ]
    interface IClusterUpdate : IUnknown {
      
        HRESULT GetUpdates(
          [out] ULONG* UpdateCount,
          [out] BSTR* updates 
        );  
    
        HRESULT Count(
          [out] LONG* Count
        );
    };  
        [
            uuid(C72B09DB-4D53-4f41-8DCC-2D752AB56F7C),
        ]
        coclass ClusterStorage2
        {
            [default] interface IClusterStorage2;
        };
    
        [
            uuid(E1568352-586D-43e4-933F-8E6DC4DE317A),
        ]
        coclass ClusterNetwork2
        {
            [default] interface IClusterNetwork2;
        };
    
        [
            uuid(A6D3E32B-9814-4409-8DE3-CFA673E6D3DE),
        ]
        coclass ClusterCleanup
        {
            [default] interface IClusterCleanup;
        };
    
        [
            uuid(04D55210-B6AC-4248-9E69-2A569D1D2AB6),
        ]
        coclass ClusterSetup
        {
            [default] interface IClusterSetup;
        };
    
        [
            uuid(88E7AC6D-C561-4F03-9A60-39DD768F867D),
        ]
        coclass ClusterLog
        {
            [default] interface IClusterLog;
        };
    
        [
            uuid(3CFEE98C-FB4B-44C6-BD98-A1DB14ABCA3F),
        ]
        coclass ClusterFirewall
        {
            [default] interface IClusterFirewall;
        };
        [
            uuid(4142DD5D-3472-4370-8641-DE7856431FB0),  
        ]
        coclass ClusterUpdate  
        {
            [default] interface IClusterUpdate;  
        };