/*
 * Copyright 2002 Ove Kaaven
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */

#ifndef DO_NO_IMPORTS
import "unknwn.idl";
#endif

cpp_quote("#ifndef _OBJIDLBASE_")
cpp_quote("#define _OBJIDLBASE_")

interface IStream;
interface IEnumString;

interface IAsyncManager;
interface ISynchronize;

typedef struct _COSERVERINFO {
  DWORD dwReserved1;
  LPWSTR pwszName;
  COAUTHINFO *pAuthInfo;
  DWORD dwReserved2;
} COSERVERINFO;

/******************** Fundamentals ********************/

[
  local,
  object,
  uuid(00000003-0000-0000-C000-000000000046)
]
interface IMarshal : IUnknown
{
  typedef [unique] IMarshal *LPMARSHAL;

  HRESULT GetUnmarshalClass(
    [in] REFIID riid,
    [in, unique] void *pv,
    [in] DWORD dwDestContext,
    [in, unique] void *pvDestContext,
    [in] DWORD mshlflags,
    [out] CLSID *pCid);

  HRESULT GetMarshalSizeMax(
    [in] REFIID riid,
    [in, unique] void *pv,
    [in] DWORD dwDestContext,
    [in, unique] void *pvDestContext,
    [in] DWORD mshlflags,
    [out] DWORD *pSize);

  HRESULT MarshalInterface(
    [in, unique] IStream *pStm,
    [in] REFIID riid,
    [in, unique] void *pv,
    [in] DWORD dwDestContext,
    [in, unique] void *pvDestContext,
    [in] DWORD mshlflags);

  HRESULT UnmarshalInterface(
    [in, unique] IStream *pStm,
    [in] REFIID riid,
    [out] void **ppv);

  HRESULT ReleaseMarshalData(
    [in, unique] IStream *pStm);

  HRESULT DisconnectObject(
    [in] DWORD dwReserved);
}

[
    local,
    object,
    uuid(94ea2b94-e9cc-49e0-c0ff-ee64ca8f5b90)
]
interface IAgileObject : IUnknown
{
}

[
    local,
    object,
    uuid(c03f6a43-65a4-9818-987e-e0b810d2a6f2),
    pointer_default(unique)
]
interface IAgileReference : IUnknown
{
    HRESULT Resolve([in] REFIID riid, [out, retval, iid_is(riid)] void **object);
}

[
    local,
    object,
    uuid(ecc8691b-c1db-4dc0-855e-65f6c551af49)
]
interface INoMarshal : IUnknown
{
}

[
    local,
    object,
    uuid(000001cf-0000-0000-C000-000000000046)
]
interface IMarshal2 : IMarshal
{
    typedef [unique] IMarshal2 *LPMARSHAL2;
}

[
  local,
  object,
  uuid(00000018-0000-0000-C000-000000000046)
]
interface IStdMarshalInfo : IUnknown
{
  typedef [unique] IStdMarshalInfo *LPSTDMARSHALINFO;

  HRESULT GetClassForHandler(
    [in] DWORD dwDestContext,
    [in, unique] void *pvDestContext,
    [out] CLSID *pClsid);
}

[
  local,
  object,
  uuid(00000019-0000-0000-C000-000000000046)
]
interface IExternalConnection : IUnknown
{
  typedef [unique] IExternalConnection *LPEXTERNALCONNECTION;

  typedef enum tagEXTCONN {
    EXTCONN_STRONG   = 0x0001,
    EXTCONN_WEAK     = 0x0002,
    EXTCONN_CALLABLE = 0x0004
  } EXTCONN;

  DWORD AddConnection(
    [in] DWORD extconn,
    [in] DWORD reserved);

  DWORD ReleaseConnection(
    [in] DWORD extconn,
    [in] DWORD reserved,
    [in] BOOL fLastReleaseCloses);
}

[
  local,
  object,
  uuid(00000020-0000-0000-C000-000000000046)
]
interface IMultiQI : IUnknown
{
  typedef [unique] IMultiQI *LPMULTIQI;

  typedef struct tagMULTI_QI {
    const IID *pIID;
    IUnknown *pItf;
    HRESULT hr;
  } MULTI_QI;

  HRESULT QueryMultipleInterfaces(
    [in] ULONG cMQIs,
    [in, out] MULTI_QI *pMQIs);
}

[
  local,
  object,
  uuid(00000002-0000-0000-C000-000000000046)
]
interface IMalloc : IUnknown
{
  typedef [unique] IMalloc *LPMALLOC;

  LPVOID Alloc(
    [in] SIZE_T cb);

  LPVOID Realloc(
    [in] LPVOID pv,
    [in] SIZE_T cb);

  void Free(
    [in] LPVOID pv);

  SIZE_T GetSize(
    [in] LPVOID pv);

  int DidAlloc(LPVOID pv);

  void HeapMinimize();
}

[
  local,
  object,
  uuid(00000021-0000-0000-C000-000000000046)
]
interface IInternalUnknown : IUnknown
{
  HRESULT QueryInternalInterface(
    [in] REFIID riid,
    [out] void **ppv);
}

[
  object,
  uuid(00000100-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface IEnumUnknown : IUnknown
{
  typedef [unique] IEnumUnknown *LPENUMUNKNOWN;

  [local]
  HRESULT Next(
    [in] ULONG celt,
    [out] IUnknown **rgelt,
    [out] ULONG *pceltFetched);

  [call_as(Next)]
  HRESULT RemoteNext(
    [in] ULONG celt,
    [out, size_is(celt), length_is(*pceltFetched)]
    IUnknown **rgelt,
    [out] ULONG *pceltFetched);

  HRESULT Skip(
    [in] ULONG celt);

  HRESULT Reset();

  HRESULT Clone(
    [out] IEnumUnknown **ppenum);
}

[
  object,
  uuid(00000022-0000-0000-C000-000000000046),
  version(1.0),
  pointer_default(unique)
]
interface ISurrogate : IUnknown
{
  typedef [unique] ISurrogate *LPSURROGATE;

  HRESULT LoadDllServer(
    [in] REFCLSID Clsid);
  HRESULT FreeSurrogate();
}

[
  local,
  object,
  uuid(00000146-0000-0000-C000-000000000046)
]
interface IGlobalInterfaceTable : IUnknown
{
  typedef [unique] IGlobalInterfaceTable *LPGLOBALINTERFACETABLE;

  HRESULT RegisterInterfaceInGlobal(
    [in] IUnknown *pUnk,
    [in] REFIID riid,
    [out] DWORD *pdwCookie);

  HRESULT RevokeInterfaceFromGlobal(
    [in] DWORD dwCookie);

  HRESULT GetInterfaceFromGlobal(
    [in] DWORD dwCookie,
    [in] REFIID riid,
    [out, iid_is(riid)] void **ppv);
}

[
  object,
  uuid(00000101-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface IEnumString : IUnknown
{
  typedef [unique] IEnumString *LPENUMSTRING;

  [local]
  HRESULT Next(
    [in] ULONG celt,
    [out, size_is(celt), length_is(*pceltFetched)]
    LPOLESTR *rgelt,
    [out] ULONG *pceltFetched);

  [call_as(Next)]
  HRESULT RemoteNext(
    [in] ULONG celt,
    [out, size_is(celt), length_is(*pceltFetched)]
    LPOLESTR *rgelt,
    [out] ULONG *pceltFetched);

  HRESULT Skip(
    [in] ULONG celt);

  HRESULT Reset();

  HRESULT Clone(
    [out] IEnumString **ppenum);
}

/******************** Storage ********************/

[
  object,
  uuid(0c733a30-2a1c-11ce-ade5-00aa0044773d),
  pointer_default(unique)
]
interface ISequentialStream : IUnknown
{
  [local]
  HRESULT Read(
    [out, size_is(cb), length_is(*pcbRead)]
    void *pv,
    [in] ULONG cb,
    [out] ULONG *pcbRead);

  [call_as(Read)]
  HRESULT RemoteRead(
    [out, size_is(cb), length_is(*pcbRead)]
    byte *pv,
    [in] ULONG cb,
    [out] ULONG *pcbRead);

  [local]
  HRESULT Write(
    [in, size_is(cb)] const void *pv,
    [in] ULONG cb,
    [out] ULONG *pcbWritten);

  [call_as(Write)]
  HRESULT RemoteWrite(
    [in, size_is(cb)] const byte *pv,
    [in] ULONG cb,
    [out] ULONG *pcbWritten);
}

[
  object,
  uuid(0000000c-0000-0000-C000-000000000046),
  pointer_default(unique)
]
interface IStream : ISequentialStream
{
  typedef [unique] IStream *LPSTREAM;

  typedef struct tagSTATSTG {
    LPOLESTR pwcsName;
    DWORD type;
    ULARGE_INTEGER cbSize;
    FILETIME mtime;
    FILETIME ctime;
    FILETIME atime;
    DWORD grfMode;
    DWORD grfLocksSupported;
    CLSID clsid;
    DWORD grfStateBits;
    DWORD reserved;
  } STATSTG;

  typedef enum tagSTGTY {
    STGTY_STORAGE   = 1,
    STGTY_STREAM    = 2,
    STGTY_LOCKBYTES = 3,
    STGTY_PROPERTY  = 4
  } STGTY;

  typedef enum tagSTREAM_SEEK {
    STREAM_SEEK_SET = 0,
    STREAM_SEEK_CUR = 1,
    STREAM_SEEK_END = 2
  } STREAM_SEEK;

  /* these are defined in Linux's fcntl.h,
   * undefine them to avoid conflicts */
  cpp_quote("#undef LOCK_MAND")
  cpp_quote("#undef LOCK_READ")
  cpp_quote("#undef LOCK_WRITE")
  cpp_quote("#undef LOCK_RW")

  typedef enum tagLOCKTYPE {
    LOCK_WRITE      = 1,
    LOCK_EXCLUSIVE  = 2,
    LOCK_ONLYONCE   = 4
  } LOCKTYPE;

  [local]
  HRESULT Seek(
    [in] LARGE_INTEGER dlibMove,
    [in] DWORD dwOrigin,
    [out] ULARGE_INTEGER *plibNewPosition);

  [call_as(Seek)]
  HRESULT RemoteSeek(
    [in] LARGE_INTEGER dlibMove,
    [in] DWORD dwOrigin,
    [out] ULARGE_INTEGER *plibNewPosition);

  HRESULT SetSize(
    [in] ULARGE_INTEGER libNewSize);

  [local]
  HRESULT CopyTo(
    [in, unique] IStream *pstm,
    [in] ULARGE_INTEGER cb,
    [out] ULARGE_INTEGER *pcbRead,
    [out] ULARGE_INTEGER *pcbWritten);

  [call_as(CopyTo)]
  HRESULT RemoteCopyTo(
    [in, unique] IStream *pstm,
    [in] ULARGE_INTEGER cb,
    [out] ULARGE_INTEGER *pcbRead,
    [out] ULARGE_INTEGER *pcbWritten);

  HRESULT Commit(
    [in] DWORD grfCommitFlags);

  HRESULT Revert();

  HRESULT LockRegion(
    [in] ULARGE_INTEGER libOffset,
    [in] ULARGE_INTEGER cb,
    [in] DWORD dwLockType);

  HRESULT UnlockRegion(
    [in] ULARGE_INTEGER libOffset,
    [in] ULARGE_INTEGER cb,
    [in] DWORD dwLockType);

  HRESULT Stat(
    [out] STATSTG *pstatstg,
    [in] DWORD grfStatFlag);

  HRESULT Clone(
    [out] IStream **ppstm);
}




[
  local,
  object,
  uuid(D5F56B60-593B-101A-B569-08002B2DBF7A)
]
interface IRpcChannelBuffer : IUnknown
{
  typedef [unique] IRpcChannelBuffer *LPRPCCHANNELBUFFER;

  typedef unsigned long RPCOLEDATAREP;

  typedef struct tagRPCOLEMESSAGE {
    void *reserved1;
    RPCOLEDATAREP dataRepresentation;
    void *Buffer;
    ULONG cbBuffer;
    ULONG iMethod;
    void *reserved2[5];
    ULONG rpcFlags;
  } RPCOLEMESSAGE;

  typedef RPCOLEMESSAGE *PRPCOLEMESSAGE;

  HRESULT GetBuffer(
    [in] RPCOLEMESSAGE *pMessage,
    [in] REFIID riid);

  HRESULT SendReceive(
    [in,out] RPCOLEMESSAGE *pMessage,
    [out] ULONG *pStatus);

  HRESULT FreeBuffer(
    [in] RPCOLEMESSAGE *pMessage);

  HRESULT GetDestCtx(
    [out] DWORD *pdwDestContext,
    [out] void **ppvDestContext);

  HRESULT IsConnected();
}

[
  local,
  object,
  uuid(594f31d0-7f19-11d0-b194-00a0c90dc8bf)
]
interface IRpcChannelBuffer2 : IRpcChannelBuffer
{
  typedef [unique] IRpcChannelBuffer2 *LPRPCCHANNELBUFFER2;

  HRESULT GetProtocolVersion(
    [in,out] DWORD *pdwVersion);
}

[
  local,
  object,
  uuid(25B15600-0115-11d0-BF0D-00AA00B8DFD2)
]
interface IRpcChannelBuffer3 : IRpcChannelBuffer2
{
  typedef [unique] IRpcChannelBuffer3 *LPRPCCHANNELBUFFER3;

  HRESULT Send(
    [in,out] RPCOLEMESSAGE *pMsg,
    [out] ULONG *pulStatus);

  HRESULT Receive(
    [in,out] RPCOLEMESSAGE *pMsg,
    [in] ULONG ulSize,
    [out] ULONG *pulStatus);

  HRESULT Cancel(
    [in] RPCOLEMESSAGE *pMsg);

  HRESULT GetCallContext(
    [in] RPCOLEMESSAGE *pMsg,
    [in] REFIID riid,
    [out] void **pInterface);

  HRESULT GetDestCtxEx(
    [in] RPCOLEMESSAGE *pMsg,
    [out] DWORD *pdwDestContext,
    [out] void **ppvDestContext);

  HRESULT GetState(
    [in] RPCOLEMESSAGE *pMsg,
    [out] DWORD *pState);

  HRESULT RegisterAsync(
    [in] RPCOLEMESSAGE *pMsg,
    [in] IAsyncManager *pAsyncMgr);
}

[
    local,
    object,
    uuid(a5029fb6-3c34-11d1-9c99-00c04fb998aa),
    pointer_default(unique)
]
interface IAsyncRpcChannelBuffer : IRpcChannelBuffer2
{
    HRESULT Send(
        [in, out] RPCOLEMESSAGE *pMsg,
        [in] ISynchronize *pSync,
        [out] ULONG *pulStatus);

    HRESULT Receive(
        [in, out] RPCOLEMESSAGE *pMsg,
        [out] ULONG *pulStatus);

    HRESULT GetDestCtxEx(
        [in] RPCOLEMESSAGE *pMsg,
        [out] DWORD *pdwDestContext,
        [out] void **ppvDestContext);
}

[
    local,
    object,
    uuid(58a08519-24c8-4935-b482-3fd823333a4f)
]
interface IRpcSyntaxNegotiate : IUnknown
{
    HRESULT NegotiateSyntax(
        [in, out] RPCOLEMESSAGE *pMsg);
}

[
  local,
  object,
  uuid(D5F56A34-593B-101A-B569-08002B2DBF7A)
]
interface IRpcProxyBuffer : IUnknown
{
  typedef [unique] IRpcProxyBuffer *LPRPCPROXYBUFFER;

  HRESULT Connect(
    [in, unique] IRpcChannelBuffer *pRpcChannelBuffer);

  void Disconnect();
}

[
  local,
  object,
  uuid(D5F56AFC-593B-101A-B569-08002B2DBF7A)
]
interface IRpcStubBuffer : IUnknown
{
  typedef [unique] IRpcStubBuffer *LPRPCSTUBBUFFER;

  HRESULT Connect(
    [in] IUnknown *pUnkServer);

  void Disconnect();

  HRESULT Invoke(
    [in] RPCOLEMESSAGE *_prpcmsg,
    [in] IRpcChannelBuffer *_pRpcChannelBuffer);

  IRpcStubBuffer *IsIIDSupported(
    [in] REFIID riid);

  ULONG CountRefs();

  HRESULT DebugServerQueryInterface(
    void **ppv);

  void DebugServerRelease(
    void *pv);
}

[
  local,
  object,
  uuid(D5F569D0-593B-101A-B569-08002B2DBF7A)
]
interface IPSFactoryBuffer : IUnknown
{
  typedef [unique] IPSFactoryBuffer *LPPSFACTORYBUFFER;

  HRESULT CreateProxy(
    [in] IUnknown *pUnkOuter,
    [in] REFIID riid,
    [out] IRpcProxyBuffer **ppProxy,
    [out] void **ppv);

  HRESULT CreateStub(
    [in] REFIID riid,
    [in, unique] IUnknown *pUnkServer,
    [out] IRpcStubBuffer **ppStub);
}

[
  local,
  object,
  uuid(1008c4a0-7613-11cf-9af1-0020af6e72f4)
]
interface IChannelHook : IUnknown
{
  typedef [unique] IChannelHook *LPCHANNELHOOK;

  typedef struct SChannelHookCallInfo {
    IID iid;
    DWORD cbSize;
    GUID uCausality;
    DWORD dwServerPid;
    DWORD iMethod;
    void *pObject;
  } SChannelHookCallInfo;

  void ClientGetSize(
    [in] REFGUID uExtent,
    [in] REFIID riid,
    [out] ULONG *pDataSize);

  void ClientFillBuffer(
    [in] REFGUID uExtent,
    [in] REFIID riid,
    [in, out] ULONG *pDataSize,
    [in] void *pDataBuffer);

  void ClientNotify(
    [in] REFGUID uExtent,
    [in] REFIID riid,
    [in] ULONG cbDataSize,
    [in] void *pDataBuffer,
    [in] DWORD lDataRep,
    [in] HRESULT hrFault);

  void ServerNotify(
    [in] REFGUID uExtent,
    [in] REFIID riid,
    [in] ULONG cbDataSize,
    [in] void *pDataBuffer,
    [in] DWORD lDataRep);

  void ServerGetSize(
    [in] REFGUID uExtent,
    [in] REFIID riid,
    [in] HRESULT hrFault,
    [out] ULONG *pDataSize);

  void ServerFillBuffer(
    [in] REFGUID uExtent,
    [in] REFIID riid,
    [in, out] ULONG *pDataSize,
    [in] void *pDataBuffer,
    [in] HRESULT hrFault );
}

extern const FMTID FMTID_SummaryInformation;
extern const FMTID FMTID_DocSummaryInformation;
extern const FMTID FMTID_UserDefinedProperties;


/******************** Connection Points ********************/
/* FIXME */

/******************** DCOM ********************/

[
  local,
  object,
  uuid(0000013D-0000-0000-C000-000000000046)
]
interface IClientSecurity : IUnknown
{
  typedef struct tagSOLE_AUTHENTICATION_SERVICE {
    DWORD dwAuthnSvc;
    DWORD dwAuthzSvc;
    OLECHAR *pPrincipalName;
    HRESULT hr;
  } SOLE_AUTHENTICATION_SERVICE;

  typedef SOLE_AUTHENTICATION_SERVICE *PSOLE_AUTHENTICATION_SERVICE;

  typedef struct tagSOLE_AUTHENTICATION_INFO {
    DWORD dwAuthnSvc;
    DWORD dwAuthzSvc;
    void *pAuthInfo;
  } SOLE_AUTHENTICATION_INFO;

  const OLECHAR *COLE_DEFAULT_PRINCIPAL = (OLECHAR*) -1;
  const void *COLE_DEFAULT_AUTHINFO = (void*) -1;

  typedef struct tagSOLE_AUTHENTICATION_LIST {
    DWORD cAuthInfo;
    SOLE_AUTHENTICATION_INFO *aAuthInfo;
  } SOLE_AUTHENTICATION_LIST;

  typedef enum tagEOLE_AUTHENTICATION_CAPABILITIES {
    EOAC_NONE               = 0x0,
    EOAC_MUTUAL_AUTH        = 0x1,
    EOAC_SECURE_REFS        = 0x2, /* CoInitializeSecurity only */
    EOAC_ACCESS_CONTROL     = 0x4, /* CoInitializeSecurity only */
    EOAC_APPID              = 0x8, /* CoInitializeSecurity only */
    EOAC_DYNAMIC            = 0x10, /* CoInitializeSecurity only */
    EOAC_STATIC_CLOAKING    = 0x20,
    EOAC_DYNAMIC_CLOAKING   = 0x40,
    EOAC_ANY_AUTHORITY      = 0x80,
    EOAC_MAKE_FULLSIC       = 0x100,
    EOAC_REQUIRE_FULLSIC    = 0x200, /* CoInitializeSecurity only */
    EOAC_AUTO_IMPERSONATE   = 0x400, /* CoInitializeSecurity only */
    EOAC_DEFAULT            = 0x800,
    EOAC_DISABLE_AAA        = 0x1000, /* CoInitializeSecurity only */
    EOAC_NO_CUSTOM_MARSHAL  = 0x2000, /* CoInitializeSecurity only */
  } EOLE_AUTHENTICATION_CAPABILITIES;

  HRESULT QueryBlanket(
    [in] IUnknown *pProxy,
    [out] DWORD *pAuthnSvc,
    [out] DWORD *pAuthzSvc,
    [out] OLECHAR **pServerPrincName,
    [out] DWORD *pAuthnLevel,
    [out] DWORD *pImpLevel,
    [out] void **pAuthInfo,
    [out] DWORD *pCapabilities);

  HRESULT SetBlanket(
    [in] IUnknown *pProxy,
    [in] DWORD AuthnSvc,
    [in] DWORD AuthzSvc,
    [in] OLECHAR *pServerPrincName,
    [in] DWORD AuthnLevel,
    [in] DWORD ImpLevel,
    [in] void *pAuthInfo,
    [in] DWORD Capabilities);

  HRESULT CopyProxy(
    [in] IUnknown *pProxy,
    [out] IUnknown **ppCopy);
}

[
  local,
  object,
  uuid(0000013E-0000-0000-C000-000000000046)
]
interface IServerSecurity : IUnknown
{
  HRESULT QueryBlanket(
    [out] DWORD *pAuthnSvc,
    [out] DWORD *pAuthzSvc,
    [out] OLECHAR **pServerPrincName,
    [out] DWORD *pAuthnLevel,
    [out] DWORD *pImpLevel,
    [out] void **pPrivs,
    [out] DWORD *pCapabilities);

  HRESULT ImpersonateClient();

  HRESULT RevertToSelf();

  BOOL IsImpersonating();
}

[
  local,
  object,
  uuid(00000024-0000-0000-C000-000000000046)
]
interface IAsyncSetup : IUnknown
{
  HRESULT GetAsyncManager(
    [in] REFIID riid,
    [in] IUnknown *pOuter,
    [in] DWORD dwFlags,
    [out] IUnknown **ppInner,
    [out] IAsyncManager **ppAsyncMgr);
}

[
    object,
    uuid(00000030-0000-0000-C000-000000000046)
]

interface ISynchronize : IUnknown
{
    HRESULT Wait(
        [in] DWORD dwFlags,
        [in] DWORD dwMilliseconds);

    HRESULT Signal();

    HRESULT Reset();
}


[
    local,
    object,
    uuid(00000031-0000-0000-C000-000000000046)
]
interface ISynchronizeHandle : IUnknown
{
    HRESULT GetHandle(
        [out] HANDLE *ph);
}


[
    local,
    object,
    uuid(00000032-0000-0000-C000-000000000046)
]
interface ISynchronizeEvent : ISynchronizeHandle
{
    HRESULT SetEventHandle(
        [in] HANDLE *ph);
}


[
    local,
    object,
    uuid(00000033-0000-0000-C000-000000000046)
]
interface ISynchronizeContainer : IUnknown
{
    HRESULT AddSynchronize(
        [in] ISynchronize *pSync);

    HRESULT WaitMultiple(
        [in] DWORD dwFlags,
        [in] DWORD dwTimeOut,
        [out] ISynchronize **ppSync);
}

[
    local,
    object,
    uuid(00000025-0000-0000-C000-000000000046)
]
interface ISynchronizeMutex : ISynchronize
{
    HRESULT ReleaseMutex();
}

[
    local,
    object,
    uuid(00000029-0000-0000-C000-000000000046)
]

interface ICancelMethodCalls : IUnknown
{
    typedef [unique] ICancelMethodCalls *LPCANCELMETHODCALLS;

    HRESULT Cancel(
        [in] ULONG ulSeconds);

    HRESULT TestCancel();
}

[
  local,
  object,
  uuid(0000002A-0000-0000-C000-000000000046)
]
interface IAsyncManager : IUnknown
{
  typedef enum tagDCOM_CALL_STATE {
    DCOM_NONE          = 0,
    DCOM_CALL_COMPLETE = 1,
    DCOM_CALL_CANCELED = 2
  } DCOM_CALL_STATE;

  HRESULT CompleteCall(
    [in] HRESULT Result);

  HRESULT GetCallContext(
    [in] REFIID riid,
    [out] void **pInterface);

  HRESULT GetState(
    [out] ULONG *pulStateFlags);
}

[
    local,
    object,
    uuid(1c733a30-2a1c-11ce-ade5-00aa0044773d),
    pointer_default(unique)
]
interface ICallFactory : IUnknown
{
    HRESULT CreateCall(
        [in] REFIID riid,
        [in] IUnknown *pCtrlUnk,
        [in] REFIID riid2,
        [out, iid_is(riid2)] IUnknown **ppv);
}

[
    local,
    object,
    uuid(00000144-0000-0000-C000-000000000046)
]
interface IRpcOptions : IUnknown
{
    HRESULT Set(
        [in] IUnknown *pPrx,
        [in] DWORD dwProperty,
        [in] ULONG_PTR dwValue);

    HRESULT Query(
        [in] IUnknown *pPrx,
        [in] DWORD dwProperty,
        [out] ULONG_PTR *pdwValue);
}

enum {
   COMBND_RPCTIMEOUT = 1,
   COMBND_SERVER_LOCALITY = 2
};

enum {
   SERVER_LOCALITY_PROCESS_LOCAL = 0,
   SERVER_LOCALITY_MACHINE_LOCAL = 1,
   SERVER_LOCALITY_REMOTE = 2
};

[
    local,
    object,
    uuid(00000149-0000-0000-C000-000000000046),
    pointer_default(unique)
]
interface IRpcHelper : IUnknown
{
    HRESULT GetDCOMProtocolVersion(
        [out] DWORD *pComVersion);

    HRESULT GetIIDFromOBJREF(
        [in] void *pObjRef,
        [out] IID **piid);
}

[
    local,
    object,
    uuid(eb0cb9e8-7996-11d2-872e-0000f8080859)
]
interface IReleaseMarshalBuffers : IUnknown
{
    HRESULT ReleaseMarshalBuffer(
        [in] RPCOLEMESSAGE *pMsg,
        [in] DWORD dwFlags,
        [in, unique] IUnknown *pChnl);
}

[
    local,
    object,
    uuid(0000002B-0000-0000-C000-000000000046)
]
interface IWaitMultiple : IUnknown
{
    HRESULT WaitMultiple(
        [in] DWORD timeout,
        [out] ISynchronize **pSync);
    HRESULT AddSynchronize(
        [in] ISynchronize *pSync);
}


[
    local,
    object,
    uuid(00000147-0000-0000-C000-000000000046)
]
interface IAddrTrackingControl : IUnknown
{
    typedef [unique] IAddrTrackingControl *LPADDRTRACKINGCONTROL;

    HRESULT EnableCOMDynamicAddrTracking();
    HRESULT DisableCOMDynamicAddrTracking();
}

[
    local,
    object,
    uuid(00000148-0000-0000-C000-000000000046)
]
interface IAddrExclusionControl : IUnknown
{
    typedef [unique] IAddrExclusionControl *LPADDREXCLUSIONCONTROL;

    HRESULT GetCurrentAddrExclusionList(
        [in] REFIID riid,
        [out, iid_is(riid)] void **ppEnumerator);
    HRESULT UpdateAddrExclusionList(
        [in] IUnknown *pEnumerator);
}

typedef enum _APTTYPE {
    APTTYPE_CURRENT = -1,
    APTTYPE_STA     = 0,
    APTTYPE_MTA     = 1,
    APTTYPE_NA      = 2,
    APTTYPE_MAINSTA = 3
} APTTYPE;

typedef enum _APTTYPEQUALIFIER {
    APTTYPEQUALIFIER_NONE,
    APTTYPEQUALIFIER_IMPLICIT_MTA,
    APTTYPEQUALIFIER_NA_ON_MTA,
    APTTYPEQUALIFIER_NA_ON_STA,
    APTTYPEQUALIFIER_NA_ON_IMPLICIT_MTA,
    APTTYPEQUALIFIER_NA_ON_MAINSTA
} APTTYPEQUALIFIER;

typedef enum _THDTYPE {
    THDTYPE_BLOCKMESSAGES   = 0,
    THDTYPE_PROCESSMESSAGES = 1
} THDTYPE;

[
    local,
    object,
    uuid(000001ce-0000-0000-C000-000000000046),
    pointer_default(unique)
]
interface IComThreadingInfo : IUnknown
{
    HRESULT GetCurrentApartmentType(
        [out] APTTYPE *pAptType);
    HRESULT GetCurrentThreadType(
        [out] THDTYPE *pThreadType);
    HRESULT GetCurrentLogicalThreadId(
        [out] GUID *pguidLogicalThreadId);
    HRESULT SetCurrentLogicalThreadId(
        [in] REFGUID rguid);
}


[
    object,
    pointer_default(unique),
    uuid(72380d55-8d2b-43a3-8513-2b6ef31434e9)
]
interface IProcessInitControl : IUnknown
{
    HRESULT ResetInitializerTimeout(
        [in] DWORD dwSecondsRemaining);
}

typedef enum tagGLOBALOPT_PROPERTIES
{
    COMGLB_EXCEPTION_HANDLING     = 1,
    COMGLB_APPID                  = 2,
    COMGLB_RPC_THREADPOOL_SETTING = 3,
    COMGLB_RO_SETTINGS            = 4,
    COMGLB_UNMARSHALING_POLICY    = 5,
    COMGLB_PROPERTIES_RESERVED1   = 6,
    COMGLB_PROPERTIES_RESERVED2   = 7,
    COMGLB_PROPERTIES_RESERVED3   = 8,
} GLOBALOPT_PROPERTIES;

typedef enum tagGLOBALOPT_EH_VALUES
{
    COMGLB_EXCEPTION_HANDLE               = 0,
    COMGLB_EXCEPTION_DONOT_HANDLE_FATAL   = 1,
    COMGLB_EXCEPTION_DONOT_HANDLE         = COMGLB_EXCEPTION_DONOT_HANDLE_FATAL,
    COMGLB_EXCEPTION_DONOT_HANDLE_ANY     = 2
} GLOBALOPT_EH_VALUES;

typedef enum tagGLOBALOPT_RPCTP_VALUES
{
    COMGLB_RPC_THREADPOOL_SETTING_DEFAULT_POOL = 0,
    COMGLB_RPC_THREADPOOL_SETTING_PRIVATE_POOL = 1
} GLOBALOPT_RPCTP_VALUES;

typedef enum tagGLOBALOPT_RO_FLAGS
{
    COMGLB_STA_MODALLOOP_REMOVE_TOUCH_MESSAGES = 0x1,
    COMGLB_STA_MODALLOOP_SHARED_QUEUE_REMOVE_INPUT_MESSAGES = 0x2,
    COMGLB_STA_MODALLOOP_SHARED_QUEUE_DONOT_REMOVE_INPUT_MESSAGES = 0x4,
    COMGLB_FAST_RUNDOWN = 0x8,
    COMGLB_RESERVED1 = 0x10,
    COMGLB_RESERVED2 = 0x20,
    COMGLB_RESERVED3 = 0x40,
    COMGLB_STA_MODALLOOP_SHARED_QUEUE_REORDER_POINTER_MESSAGES = 0x80,
    COMGLB_RESERVED4 = 0x100,
    COMGLB_RESERVED5 = 0x200,
    COMGLB_RESERVED6 = 0x400,
} GLOBALOPT_RO_FLAGS;

typedef enum tagGLOBALOPT_UNMARSHALING_POLICY_VALUES
{
    COMGLB_UNMARSHALING_POLICY_NORMAL = 0,
    COMGLB_UNMARSHALING_POLICY_STRONG = 1,
    COMGLB_UNMARSHALING_POLICY_HYBRID = 2,
} GLOBALOPT_UNMARSHALING_POLICY_VALUES;

[
    object,
    local,
    pointer_default(unique),
    uuid(0000015B-0000-0000-C000-000000000046)
]
interface IGlobalOptions : IUnknown
{
    HRESULT Set([in] GLOBALOPT_PROPERTIES property, [in] ULONG_PTR value);
    HRESULT Query([in] GLOBALOPT_PROPERTIES property, [out ] ULONG_PTR *value);
}

cpp_quote("#ifdef USE_COM_CONTEXT_DEF")

typedef DWORD CPFLAGS;

typedef struct tagContextProperty
{
    GUID policyId;
    CPFLAGS flags;
    [unique] IUnknown *pUnk;
} ContextProperty;

[
    local,
    object,
    uuid(000001c1-0000-0000-C000-000000000046)
]
interface IEnumContextProps : IUnknown
{
    typedef [unique] IEnumContextProps *LPENUMCONTEXTPROPS;

    HRESULT Next(
        [in] ULONG celt,
        [out, size_is(celt), length_is(*pceltFetched)] ContextProperty *pContextProperties,
        [out] ULONG *pceltFetched);

    HRESULT Skip(
        [in] ULONG celt);

    HRESULT Reset();

    HRESULT Clone(
        [out] IEnumContextProps **ppEnumContextProps);

    HRESULT Count(
        [out] ULONG *pcelt);
}

[
    local,
    object,
    uuid(000001c0-0000-0000-C000-000000000046)
]
interface IContext : IUnknown
{
    HRESULT SetProperty(
        [in] REFGUID policyId,
        [in] CPFLAGS flags,
        [in] IUnknown *pUnk);

    HRESULT RemoveProperty(
        [in] REFGUID policyId);

    HRESULT GetProperty(
        [in] REFGUID guid,
        [out] CPFLAGS *pFlags,
        [out] IUnknown **ppUnk);

    HRESULT EnumContextProps(
        [out] IEnumContextProps **ppEnumContextProps);
}

[
    local,
    object,
    uuid(000001c6-0000-0000-c000-000000000046),
    pointer_default(unique)
]
interface IObjContext : IContext
{
    void Reserved1();
    void Reserved2();
    void Reserved3();
    void Reserved4();
    void Reserved5();
    void Reserved6();
    void Reserved7();
}

[
    local,
    object,
    uuid(00000017-0000-0000-c000-000000000046)
]
interface IActivationFilter : IUnknown
{
  typedef enum tagACTIVATIONTYPE {
    ACTIVATIONTYPE_UNCATEGORIZED  = 0x0,
    ACTIVATIONTYPE_FROM_MONIKER   = 0x1,
    ACTIVATIONTYPE_FROM_DATA      = 0x2,
    ACTIVATIONTYPE_FROM_STORAGE   = 0x4,
    ACTIVATIONTYPE_FROM_STREAM    = 0x8,
    ACTIVATIONTYPE_FROM_FILE      = 0x10
  } ACTIVATIONTYPE;

  HRESULT HandleActivation(
    [in] DWORD dwActivationType,
    [in] REFCLSID rclsid,
    [out] CLSID *pReplacementClsId);
}

cpp_quote("#endif /* defined USE_COM_CONTEXT_DEF */")
cpp_quote("#endif /* defined _OBJIDLBASE_ */")
