import "ms-dtyp.idl";
 
 
typedef GUID CLSID;
typedef GUID IID;
typedef unsigned hyper ID;
typedef unsigned hyper OXID;
       
typedef unsigned hyper OID;        
typedef unsigned hyper SETID;      
typedef GUID    IPID;
typedef GUID    CID;
 
// XXX: L.0001: define via typedef: #define REFGUID const GUID *
typedef GUID *REFGUID;

// XXX: L.0001: define via typedef: #define REFIID const IID *
typedef IID *REFIID;
 
typedef REFGUID REFIPID;
 
typedef struct tagCOMVERSION
{
    unsigned short MajorVersion;    
    unsigned short MinorVersion;    
} COMVERSION;
 
typedef struct tagORPC_EXTENT
{
    GUID                    id;     
    unsigned long           size;   
    [size_is((size+7)&~7)]  byte data[]; 
} ORPC_EXTENT;
 
typedef struct tagORPC_EXTENT_ARRAY
{
    unsigned long size;     
    unsigned long reserved;
    [size_is((size+1)&~1,), unique] ORPC_EXTENT **extent;
} ORPC_EXTENT_ARRAY;
 
typedef struct tagORPCTHIS
{
    COMVERSION      version;    
    unsigned long   flags;      
    unsigned long   reserved1;  
    CID             cid;        
    [unique] ORPC_EXTENT_ARRAY *extensions;
} ORPCTHIS;
 
typedef struct tagORPCTHAT
{
    unsigned long  flags;
    [unique] ORPC_EXTENT_ARRAY *extensions;
} ORPCTHAT;
 
typedef struct tagDUALSTRINGARRAY
{
    unsigned short wNumEntries;
    unsigned short wSecurityOffset;
    [size_is(wNumEntries)] unsigned short aStringArray[];
} DUALSTRINGARRAY;
 
enum tagCPFLAGS
{
    CPFLAG_PROPAGATE                    = 0x1,
    CPFLAG_EXPOSE                       = 0x2,
    CPFLAG_ENVOY                        = 0x4,
};
 
typedef struct tagMInterfacePointer
{
    unsigned long           ulCntData;          
    [size_is(ulCntData)] byte abData[];
} MInterfacePointer;
 
typedef [unique] MInterfacePointer * PMInterfacePointer;
 
typedef struct tagErrorObjectData
{
    DWORD  dwVersion;
    DWORD  dwHelpContext;
    IID    iid;
    DWORD dwSourceSignature;
    [switch_is(dwSourceSignature)] ErrorObjectDataString * Source;
    DWORD dwDescriptionSignature;
    [switch_is(dwDescriptionSignature)] ErrorObjectDataString * Description;
    DWORD dwHelpFileSignature;
    [switch_is(dwHelpFileSignature)] ErrorObjectDataString * HelpFile;
} ErrorObjectData;

typedef [switch_type(DWORD)] union tagErrorObjectDataString {
    [case(0xFFFFFFFF)] ErrorInfoString * String;
    [default];
} ErrorObjectDataString;

typedef struct tagErrorInfoString
{
    DWORD dwMax;
    DWORD dwOffSet;
    DWORD dwActual;
    [unique, string, size_is(dwMax)] wchar_t* Name;
} ErrorInfoString;

typedef struct tagContextORPCExtension
{
    byte Signature[4];
    unsigned long Version;
    unsigned long cPolicies;
    unsigned long cbBuffer;
    unsigned long cbSize;
    unsigned long hr;
    unsigned long hrServer;
    unsigned long reserved;
    [size_is(cPolicies)] EntryHeader * EntryHeader;
    [size_is(*)] byte * PolicyData[];
} ContextORPCExtension;

typedef struct tagEntryHeader
{
    byte Signature[4];
    unsigned long cbEHBuffer;
    unsigned long cbSize;
    unsigned long reserved;
    GUID policyID;
} EntryHeader;

[
    uuid(4d9f4ab8-7d1c-11cf-861e-0020af6e7c57),
    pointer_default(unique)
]
interface IActivation
{
    const unsigned long MAX_REQUESTED_INTERFACES = 0x8000;
    const unsigned long MAX_REQUESTED_PROTSEQS = 0x8000;
 
error_status_t RemoteActivation(
        [in] handle_t                               hRpc,
        [in] ORPCTHIS                              *ORPCthis,
        [out] ORPCTHAT                             *ORPCthat,
        [in] GUID                                  *Clsid,
        [in, string, unique] wchar_t               *pwszObjectName,
        [in, unique] MInterfacePointer             *pObjectStorage,
        [in] DWORD                                  ClientImpLevel,
        [in] DWORD                                  Mode,
        [in,range(1,MAX_REQUESTED_INTERFACES)]DWORD Interfaces,
        [in,unique,size_is(Interfaces)] IID        *pIIDs,
        [in,range(0,MAX_REQUESTED_PROTSEQS)]
             unsigned short                    cRequestedProtseqs,
        [in, size_is(cRequestedProtseqs)]
               unsigned short                  aRequestedProtseqs[],
        [out] OXID                             *pOxid,
        [out] DUALSTRINGARRAY                  **ppdsaOxidBindings,
        [out] IPID                             *pipidRemUnknown,
        [out] DWORD                                *pAuthnHint,
        [out] COMVERSION                           *pServerVersion,
        [out] HRESULT                              *phr,
        [out,size_is(Interfaces), disable_consistency_check] 
                                MInterfacePointer **ppInterfaceData,
        [out,size_is(Interfaces), disable_consistency_check] 
                                HRESULT            *pResults
        );
}
 
[
    uuid(000001A0-0000-0000-C000-000000000046),
    pointer_default(unique)
]
interface IRemoteSCMActivator 
{
 void Opnum0NotUsedOnWire(void);
 void Opnum1NotUsedOnWire(void);
 void Opnum2NotUsedOnWire(void);
 
HRESULT RemoteGetClassObject(
                    [in] handle_t rpc,
                    [in] ORPCTHIS *orpcthis,
                    [out] ORPCTHAT *orpcthat,
                    [in,unique]  MInterfacePointer *pActProperties,
                    [out] MInterfacePointer **ppActProperties
                    );
 
HRESULT RemoteCreateInstance(
                    [in] handle_t rpc,
                    [in] ORPCTHIS *orpcthis,
                    [out] ORPCTHAT *orpcthat,
                    [in,unique]  MInterfacePointer *pUnkOuter,
                    [in,unique]  MInterfacePointer *pActProperties,
                    [out] MInterfacePointer **ppActProperties
                    );
}
 
[
    uuid(99fcfec4-5260-101b-bbcb-00aa0021347a),
    pointer_default(unique)
]
 
interface IObjectExporter
{
    [idempotent] error_status_t ResolveOxid
    (
[in]       handle_t        hRpc,
[in]       OXID           *pOxid,
[in]       unsigned short  cRequestedProtseqs,
[in,  ref, size_is(cRequestedProtseqs)]
   unsigned short  arRequestedProtseqs[],
[out, ref] DUALSTRINGARRAY **ppdsaOxidBindings,
[out, ref] IPID            *pipidRemUnknown,
[out, ref] DWORD           *pAuthnHint
    );
 
[idempotent] error_status_t SimplePing
    (
[in]  handle_t  hRpc,
[in]  SETID    *pSetId 
    );
 
[idempotent] error_status_t ComplexPing
    (
[in]       handle_t        hRpc,
[in, out]  SETID          *pSetId,
[in]       unsigned short  SequenceNum,
[in]       unsigned short  cAddToSet,
[in]       unsigned short  cDelFromSet,
[in, unique, size_is(cAddToSet)]   OID AddToSet[],
[in, unique, size_is(cDelFromSet)] OID DelFromSet[],
[out]      unsigned short *pPingBackoffFactor      
    );
 
[idempotent] error_status_t ServerAlive
    (
[in]       handle_t        hRpc
    );
 
 
[idempotent] error_status_t ResolveOxid2
    (
[in]       handle_t        hRpc,
[in]       OXID           *pOxid,
[in]       unsigned short  cRequestedProtseqs,
[in,  ref, size_is(cRequestedProtseqs)]
   unsigned short  arRequestedProtseqs[],
[out, ref] DUALSTRINGARRAY **ppdsaOxidBindings,
[out, ref] IPID            *pipidRemUnknown,
[out, ref] DWORD           *pAuthnHint,
[out, ref] COMVERSION      *pComVersion
    );
 
    [idempotent] error_status_t ServerAlive2
    (
[in]       handle_t        hRpc,
[out, ref] COMVERSION      *pComVersion,
[out, ref] DUALSTRINGARRAY **ppdsaOrBindings,
[out, ref] DWORD           *pReserved
    );
}
 
typedef struct tagSTDOBJREF
{
    unsigned long  flags;              
    unsigned long  cPublicRefs;        
    OXID           oxid;               
    OID            oid;                
    IPID           ipid;               
} STDOBJREF;

/* 
 * go-midl: objref
 */

typedef enum tagOBJREFTYPE {
    OBJREF_TYPE_STANDARD = 0x00000001,
    OBJREF_TYPE_HANDLER = 0x00000002,
    OBJREF_TYPE_CUSTOM = 0x00000004,
    OBJREF_TYPE_EXTENDED = 0x00000008
} OBJREF_TYPE;

typedef struct _OBJREF_STANDARD
{
    STDOBJREF       std;
    DUALSTRINGARRAY * saResAddr;
} OBJREF_STANDARD, *POBJREF_STANDARD;


typedef struct _OBJREF_HANDLER
{
    STDOBJREF       std;
    CLSID           clsid;
    DUALSTRINGARRAY * saResAddr;
} OBJREF_HANDLER, *POBJREF_HANDLER;

typedef struct _OBJREF_CUSTOM
{
    CLSID           clsid;
    unsigned long   cbExtension;
    unsigned long   size;
    [size_is(*)] byte * pObjectData[];
} OBJREF_CUSTOM, *POBJREF_CUSTOM;

typedef struct _DATAELEMENT {
    GUID dataID;
    unsigned long cbSize;
    unsigned long cbRounded = (cbSize+7)&~7;
    [size_is((cbSize+7)&~7)] byte * Data;
} DATAELEMENT, *PDATAELEMENT;

typedef struct _OBJREF_EXTENDED
{
    STDOBJREF       std;
    byte            Signature1[4];
    DUALSTRINGARRAY * saResAddr;
    unsigned long   nElms;
    byte            Signature2[4];
    [size_is(nElms)] PDATAELEMENT ElmArray;
} OBJREF_EXTENDED, *POBJREF_EXTENDED;

typedef struct tagDATAELEMENT {
    GUID dataID;
    unsigned long cbSize;
    unsigned long cbRounded = (cbSize+7)&~7;
    [size_is((cbSize+7)&~7)] byte * Data;
} DATAELEMENT, *PDATAELEMENT;

typedef struct tagOBJREF {
    byte signature[4];
    OBJREF_TYPE flags;
    IID iid;
    [switch_is(Flags), switch_type(DWORD)] union {
    [case(OBJREF_TYPE_STANDARD)] OBJREF_STANDARD standard;
    [case(OBJREF_TYPE_HANDLER)] OBJREF_HANDLER handler;
    [case(OBJREF_TYPE_CUSTOM)] OBJREF_CUSTOM custom;
    [case(OBJREF_TYPE_EXTENDED)] OBJREF_EXTENDED extended;
    [default];
    } u_objref;
} OBJREF, *OBJPREF;

/* 
 * go-midl: objref end
 */

/*
 * go-midl: context
 */

typedef enum {
    CTXMSHLFLAGS_BYVAL = 0x00000002
} CTXMSHLFLAGS;

typedef struct tagCONTEXT
{
    unsigned short MajorVersion;
    unsigned short MinVersion;
    GUID ContextId;
    unsigned long Flags;
    unsigned long Reserved;
    unsigned long dwNumExtents;
    unsigned long cbExtents;
    unsigned long MshlFlags;
    unsigned long Count;
    BOOL Frozen;
    [size_is(Count)] PPROPMARSHALHEADER PropMarshalHeader;
} Context, *PContext;

typedef enum {
    CPFLAG_PROPAGATE = 0x00000001,
    CPFLAG_EXPOSE = 0x00000002,
    CPFLAG_ENVOY = 0x00000004
} CPFLAG;

typedef struct tagPROPMARSHALHEADER
{
    CLSID clsid;
    GUID policyId;
    unsigned long flags;
    unsigned long cb;
    [size_is(cb)] byte *ctxProperty;
} PROPMARSHALHEADER, *PPROPMARSHALHEADER;

/*
 * go-midl: context: end
 */

typedef struct tagActivationPropertiesBLOB
{
    unsigned long dwSize;
    unsigned long dwReserved;
    [size_is(dwSize)] byte *data;
} ActivationPropertiesBLOB, *PActivationPropertiesBLOB;
 
typedef struct tagREMQIRESULT
{
    HRESULT         hResult;
    STDOBJREF       std;
} REMQIRESULT;
 
typedef struct tagREMINTERFACEREF
{
    IPID            ipid;
    unsigned long   cPublicRefs;
    unsigned long   cPrivateRefs;
} REMINTERFACEREF;
 
typedef [disable_consistency_check] REMQIRESULT* PREMQIRESULT;
typedef [disable_consistency_check] MInterfacePointer* 
                                    PMInterfacePointerInternal; 
 
[
object,
uuid(00000000-0000-0000-C000-000000000046),
pointer_default(unique)
]
interface IUnknown
{
   HRESULT Opnum0NotUsedOnWire(void);
   HRESULT Opnum1NotUsedOnWire(void);
   HRESULT Opnum2NotUsedOnWire(void);
};
 
[
    object,
    uuid(00000131-0000-0000-C000-000000000046) 
]
interface IRemUnknown : IUnknown
{
    HRESULT RemQueryInterface
    (
        [in] REFIPID                         ripid,
        [in] unsigned long                   cRefs,
        [in] unsigned short                  cIids,
        [in, size_is(cIids)] IID            *iids,
        [out, size_is(,cIids)] PREMQIRESULT *ppQIResults
    );
 
HRESULT RemAddRef
    (
        [in] unsigned short cInterfaceRefs,
        [in, size_is(cInterfaceRefs)] REMINTERFACEREF
                                       InterfaceRefs[],
        [out, size_is(cInterfaceRefs)] HRESULT *pResults
    );
 
HRESULT RemRelease
    (
        [in] unsigned short cInterfaceRefs,
        [in, size_is(cInterfaceRefs)] REMINTERFACEREF 
                                      InterfaceRefs[]
    );
}
 
[
    object,
    uuid(00000143-0000-0000-C000-000000000046) 
]
interface IRemUnknown2 : IRemUnknown
{
    HRESULT RemQueryInterface2
    (
        [in] REFIPID                                      ripid,
        [in] unsigned short                               cIids,
        [in, size_is(cIids)] IID                         *iids,
        [out, size_is(cIids)] HRESULT                    *phr,
        [out, size_is(cIids)] PMInterfacePointerInternal *ppMIF
    );
}
 
const unsigned long MIN_ACTPROP_LIMIT = 1;
const unsigned long MAX_ACTPROP_LIMIT = 10;
 
typedef struct _COSERVERINFO
{
    DWORD              dwReserved1;
    [string ] wchar_t* pwszName;
    DWORD *            pdwReserved;
    DWORD              dwReserved2;
} COSERVERINFO;
 
typedef struct _customREMOTE_REQUEST_SCM_INFO
{
    DWORD                           ClientImpLevel;
    [range (0, MAX_REQUESTED_PROTSEQS)] unsigned short 
                                        cRequestedProtseqs;
    [size_is(cRequestedProtseqs)]
    unsigned short                  *pRequestedProtseqs;
} customREMOTE_REQUEST_SCM_INFO;
 
typedef struct _customREMOTE_REPLY_SCM_INFO
{
    OXID                            Oxid;
    DUALSTRINGARRAY                 *pdsaOxidBindings;
    IPID                            ipidRemUnknown;
    DWORD                           authnHint;
    COMVERSION                      serverVersion;
} customREMOTE_REPLY_SCM_INFO;

typedef enum {
    ACTVFLAGS_DISABLE_AAA = 0x00000002,
    ACTVFLAGS_ACTIVATE_32_BIT_SERVER = 0x00000004,
    ACTVFLAGS_ACTIVATE_64_BIT_SERVER = 0x00000008,
    ACTVFLAGS_NO_FAILURE_LOG = 0x00000020
} ACTVFLAGS;
 
typedef struct tagInstantiationInfoData
{
    CLSID classId;
    DWORD classCtx;
    DWORD actvflags;
    long  fIsSurrogate;
    [range (1,MAX_REQUESTED_INTERFACES)] DWORD cIID;
    DWORD instFlag;
    [size_is(cIID)] IID   *pIID;
    DWORD thisSize;
    COMVERSION clientCOMVersion;
} InstantiationInfoData;
 
typedef struct tagLocationInfoData
{
    [string] wchar_t  *machineName;
    DWORD processId;
    DWORD apartmentId;
    DWORD contextId;
} LocationInfoData;
 
typedef struct tagActivationContextInfoData
{
   long  clientOK;
   long  bReserved1;
   DWORD dwReserved1;
   DWORD dwReserved2;
   MInterfacePointer *pIFDClientCtx;
   MInterfacePointer *pIFDPrototypeCtx;
} ActivationContextInfoData;
   
typedef struct tagCustomHeader
{
    DWORD totalSize;
    DWORD headerSize;     
    DWORD dwReserved;
    DWORD destCtx;
    [range (MIN_ACTPROP_LIMIT, MAX_ACTPROP_LIMIT)] DWORD cIfs;
    CLSID classInfoClsid;
    [size_is(cIfs)] CLSID *pclsid;
    [size_is(cIfs)] DWORD *pSizes;
    DWORD *pdwReserved;
} CustomHeader;
 
typedef struct tagPropsOutInfo
{
    [range (1, MAX_REQUESTED_INTERFACES)] DWORD cIfs;
    [size_is(cIfs)] IID *piid;
    [size_is(cIfs)] HRESULT *phresults;
    [size_is(cIfs)] MInterfacePointer **ppIntfData;
} PropsOutInfo;
 
typedef struct tagSecurityInfoData
{
    DWORD           dwAuthnFlags;
    COSERVERINFO    *pServerInfo;
    DWORD           *pdwReserved;
} SecurityInfoData;
 
typedef struct tagScmRequestInfoData
{
    DWORD  *pdwReserved;
    customREMOTE_REQUEST_SCM_INFO *remoteRequest;
} ScmRequestInfoData;
 
typedef struct tagScmReplyInfoData
{
    DWORD *pdwReserved;
    customREMOTE_REPLY_SCM_INFO *remoteReply;
} ScmReplyInfoData;
 
typedef struct tagInstanceInfoData
{
    [string] wchar_t *fileName;
    DWORD   mode;
    MInterfacePointer *ifdROT;
    MInterfacePointer *ifdStg;
} InstanceInfoData;
 
typedef enum
{
    SPD_FLAG_USE_CONSOLE_SESSION   = 0x00000001,
    SPD_FLAG_USE_DEFAULT_AUTHN_LVL = 0x00000002,
} SPD_FLAGS;
    
typedef struct tagSpecialPropertiesData
{
    unsigned long dwSessionId;
    long  fRemoteThisSessionId;        
    long  fClientImpersonating;
    long  fPartitionIDPresent;  
    DWORD dwDefaultAuthnLvl;    
    GUID  guidPartition;        
    DWORD dwPRTFlags;           
    DWORD dwOrigClsctx;
    DWORD dwFlags;
    DWORD Reserved1;
    unsigned __int64 Reserved2;               
    DWORD Reserved3[5]; 
} SpecialPropertiesData;
 
typedef struct tagSpecialPropertiesData_Alternate
{
    unsigned long dwSessionId;
    long  fRemoteThisSessionId;        
    long  fClientImpersonating;
    long  fPartitionIDPresent;  
    DWORD dwDefaultAuthnLvl;    
    GUID  guidPartition;        
    DWORD dwPRTFlags;           
    DWORD dwOrigClsctx;
    DWORD dwFlags;
    DWORD Reserved3[8]; 
} SpecialPropertiesData_Alternate;
