[rustc.git] / vendor / winapi / src / um / combaseapi.rs

// Licensed under the Apache License, Version 2.0
// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
// All files in the project carrying such notice may not be copied, modified, or distributed
// except according to those terms.
//! Base Component Object Model defintions.
use ctypes::{c_int, c_void};
use shared::basetsd::{SIZE_T, UINT64, ULONG_PTR};
use shared::guiddef::{CLSID, GUID, LPCLSID, LPIID, REFCLSID, REFGUID, REFIID};
use shared::minwindef::{BOOL, DWORD, FILETIME, HGLOBAL, LPDWORD, LPHANDLE, LPVOID, ULONG};
use shared::rpcdce::{RPC_AUTHZ_HANDLE, RPC_AUTH_IDENTITY_HANDLE};
use shared::wtypesbase::{
    CLSCTX, CLSCTX_INPROC_HANDLER, CLSCTX_INPROC_SERVER, CLSCTX_LOCAL_SERVER, CLSCTX_REMOTE_SERVER,
    LPCOLESTR, LPOLESTR, OLECHAR,
};
use um::objidl::SOLE_AUTHENTICATION_SERVICE;
use um::objidlbase::{
    APTTYPE, APTTYPEQUALIFIER, COSERVERINFO, IActivationFilter, IAgileReference, LPMALLOC,
    LPMARSHAL, LPSTREAM, LPSURROGATE, MULTI_QI,
};
use um::propidl::PROPVARIANT;
use um::unknwnbase::{IUnknown, LPUNKNOWN};
use um::winnt::{HANDLE, HRESULT, LARGE_INTEGER, LONG, PSECURITY_DESCRIPTOR, PVOID, ULARGE_INTEGER};
#[inline]
pub fn LISet32(li: &mut LARGE_INTEGER, v: DWORD) {
    unsafe {
        li.u_mut().HighPart = if (v as LONG) < 0 {
            -1
        } else {
            0
        };
        li.u_mut().LowPart = v;
    }
}
#[inline]
pub fn ULISet32(li: &mut ULARGE_INTEGER, v: DWORD) {
    unsafe {
        li.u_mut().HighPart = 0;
        li.u_mut().LowPart = v;
    }
}
pub const CLSCTX_INPROC: CLSCTX = CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER;
pub const CLSCTX_ALL: CLSCTX = CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER | CLSCTX_LOCAL_SERVER
    | CLSCTX_REMOTE_SERVER;
pub const CLSCTX_SERVER: CLSCTX = CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER
    | CLSCTX_REMOTE_SERVER;
ENUM!{enum REGCLS {
    REGCLS_SINGLEUSE = 0,
    REGCLS_MULTIPLEUSE = 1,
    REGCLS_MULTI_SEPARATE = 2,
    REGCLS_SUSPENDED = 4,
    REGCLS_SURROGATE = 8,
    REGCLS_AGILE = 0x10,
}}
ENUM!{enum COINITBASE {
    COINITBASE_MULTITHREADED = 0x0,
}}
extern "system" {
    pub fn CoGetMalloc(
        dwMemContext: DWORD,
        ppMalloc: *mut LPMALLOC,
    ) -> HRESULT;
    pub fn CreateStreamOnHGlobal(
        hGlobal: HGLOBAL,
        fDeleteOnRelease: BOOL,
        ppstm: *mut LPSTREAM,
    ) -> HRESULT;
    pub fn GetHGlobalFromStream(
        pstm: LPSTREAM,
        phglobal: *mut HGLOBAL,
    ) -> HRESULT;
    pub fn CoUninitialize() -> ();
    pub fn CoGetCurrentProcess() -> DWORD;
    pub fn CoInitializeEx(
        pvReserved: LPVOID,
        dwCoInit: DWORD,
    ) -> HRESULT;
    pub fn CoGetCallerTID(
        lpdwTID: LPDWORD,
    ) -> HRESULT;
    pub fn CoGetCurrentLogicalThreadId(
        pguid: *mut GUID,
    ) -> HRESULT;
    pub fn CoGetContextToken(
        pToken: *mut ULONG_PTR,
    ) -> HRESULT;
    pub fn CoGetDefaultContext(
        aptType: APTTYPE,
        riid: REFIID,
        ppv: *mut *mut c_void,
    ) -> HRESULT;
    pub fn CoGetApartmentType(
        pAptType: *mut APTTYPE,
        pAptQualifier: *mut APTTYPEQUALIFIER,
    ) -> HRESULT;
}
STRUCT!{struct ServerInformation {
    dwServerPid: DWORD,
    dwServerTid: DWORD,
    ui64ServerAddress: UINT64,
}}
pub type PServerInformation = *mut ServerInformation;
extern "system" {
    pub fn CoDecodeProxy(
        dwClientPid: DWORD,
        ui64ProxyAddress: UINT64,
        pServerInformation: PServerInformation,
    ) -> HRESULT;
}
DECLARE_HANDLE!{CO_MTA_USAGE_COOKIE, CO_MTA_USAGE_COOKIE__}
extern "system" {
    pub fn CoIncrementMTAUsage(
        pCookie: *mut CO_MTA_USAGE_COOKIE,
    ) -> HRESULT;
    pub fn CoDecrementMTAUsage(
        Cookie: CO_MTA_USAGE_COOKIE,
    ) -> HRESULT;
    pub fn CoAllowUnmarshalerCLSID(
        clsid: REFCLSID,
    ) -> HRESULT;
    pub fn CoGetObjectContext(
        riid: REFIID,
        ppv: *mut LPVOID,
    ) -> HRESULT;
    pub fn CoGetClassObject(
        rclsid: REFCLSID,
        dwClsContext: DWORD,
        pvReserved: LPVOID,
        riid: REFIID,
        ppv: *mut LPVOID,
    ) -> HRESULT;
    pub fn CoRegisterClassObject(
        rclsid: REFCLSID,
        pUnk: LPUNKNOWN,
        dwClsContext: DWORD,
        flags: DWORD,
        lpdwRegister: LPDWORD,
    ) -> HRESULT;
    pub fn CoRevokeClassObject(
        dwRegister: DWORD,
    ) -> HRESULT;
    pub fn CoResumeClassObjects() -> HRESULT;
    pub fn CoSuspendClassObjects() -> HRESULT;
    pub fn CoAddRefServerProcess() -> ULONG;
    pub fn CoReleaseServerProcess() -> ULONG;
    pub fn CoGetPSClsid(
        riid: REFIID,
        pClsid: *mut CLSID,
    ) -> HRESULT;
    pub fn CoRegisterPSClsid(
        riid: REFIID,
        rclsid: REFCLSID,
    ) -> HRESULT;
    pub fn CoRegisterSurrogate(
        pSurrogate: LPSURROGATE,
    ) -> HRESULT;
    pub fn CoGetMarshalSizeMax(
        pulSize: *mut ULONG,
        riid: REFIID,
        pUnk: LPUNKNOWN,
        dwDestContext: DWORD,
        pvDestContext: LPVOID,
        mshlflags: DWORD,
    ) -> HRESULT;
    pub fn CoMarshalInterface(
        pStm: LPSTREAM,
        riid: REFIID,
        pUnk: LPUNKNOWN,
        dwDestContext: DWORD,
        pvDestContext: LPVOID,
        mshlflags: DWORD,
    ) -> HRESULT;
    pub fn CoUnmarshalInterface(
        pStm: LPSTREAM,
        riid: REFIID,
        ppv: *mut LPVOID,
    ) -> HRESULT;
    pub fn CoMarshalHresult(
        pstm: LPSTREAM,
        hresult: HRESULT,
    ) -> HRESULT;
    pub fn CoUnmarshalHresult(
        pstm: LPSTREAM,
        phresult: *mut HRESULT,
    ) -> HRESULT;
    pub fn CoReleaseMarshalData(
        pstm: LPSTREAM,
    ) -> HRESULT;
    pub fn CoDisconnectObject(
        pUnk: LPUNKNOWN,
        dwReserved: DWORD,
    ) -> HRESULT;
    pub fn CoLockObjectExternal(
        pUnk: LPUNKNOWN,
        fLock: BOOL,
        fLastUnlockReleases: BOOL,
    ) -> HRESULT;
    pub fn CoGetStandardMarshal(
        riid: REFIID,
        pUnk: LPUNKNOWN,
        dwDestContext: DWORD,
        pvDestContext: LPVOID,
        mshlflags: DWORD,
        ppMarshal: *mut LPMARSHAL,
    ) -> HRESULT;
    pub fn CoGetStdMarshalEx(
        pUnkOuter: LPUNKNOWN,
        smexflags: DWORD,
        ppUnkInner: *mut LPUNKNOWN,
    ) -> HRESULT;
}
ENUM!{enum STDMSHLFLAGS {
    SMEXF_SERVER = 0x01,
    SMEXF_HANDLER = 0x02,
}}
extern "system" {
    pub fn CoIsHandlerConnected(
        pUnk: LPUNKNOWN,
    ) -> BOOL;
    pub fn CoMarshalInterThreadInterfaceInStream(
        riid: REFIID,
        pUnk: LPUNKNOWN,
        ppStm: *mut LPSTREAM,
    ) -> HRESULT;
    pub fn CoGetInterfaceAndReleaseStream(
        pStm: LPSTREAM,
        iid: REFIID,
        ppv: *mut LPVOID,
    ) -> HRESULT;
    pub fn CoCreateFreeThreadedMarshaler(
        punkOuter: LPUNKNOWN,
        ppunkMarshal: *mut LPUNKNOWN,
    ) -> HRESULT;
    pub fn CoFreeUnusedLibraries();
    pub fn CoFreeUnusedLibrariesEx(
        dwUnloadDelay: DWORD,
        dwReserved: DWORD,
    );
    pub fn CoDisconnectContext(
        dwTimeout: DWORD,
    )-> HRESULT;
    pub fn CoInitializeSecurity(
        pSecDesc: PSECURITY_DESCRIPTOR,
        cAuthSvc: LONG,
        asAuthSvc: *mut SOLE_AUTHENTICATION_SERVICE,
        pReserved1: *mut c_void,
        dwAuthnLevel: DWORD,
        dwImpLevel: DWORD,
        pAuthList: *mut c_void,
        dwCapabilities: DWORD,
        pReserved3: *mut c_void,
    ) -> HRESULT;
    pub fn CoGetCallContext(
        riid: REFIID,
        ppInterface: *mut *mut c_void,
    ) -> HRESULT;
    pub fn CoQueryProxyBlanket(
        pProxy: *mut IUnknown,
        pwAuthnSvc: *mut DWORD,
        pAuthzSvc: *mut DWORD,
        pServerPrincName: *mut LPOLESTR,
        pAuthnLevel: *mut DWORD,
        pImpLevel: *mut DWORD,
        pAuthInfo: *mut RPC_AUTH_IDENTITY_HANDLE,
        pCapabilites: *mut DWORD,
    ) -> HRESULT;
    pub fn CoSetProxyBlanket(
        pProxy: *mut IUnknown,
        dwAuthnSvc: DWORD,
        dwAuthzSvc: DWORD,
        pServerPrincName: *mut OLECHAR,
        dwAuthnLevel: DWORD,
        dwImpLevel: DWORD,
        pAuthInfo: RPC_AUTH_IDENTITY_HANDLE,
        dwCapabilities: DWORD,
    ) -> HRESULT;
    pub fn CoCopyProxy(
        pProxy: *mut IUnknown,
        ppCopy: *mut *mut IUnknown,
    ) -> HRESULT;
    pub fn CoQueryClientBlanket(
        pAuthnSvc: *mut DWORD,
        pAuthzSvc: *mut DWORD,
        pServerPrincName: *mut LPOLESTR,
        pAuthnLevel: *mut DWORD,
        pImpLevel: *mut DWORD,
        pPrivs: *mut RPC_AUTHZ_HANDLE,
        pCapabilities: *mut DWORD,
    ) -> HRESULT;
    pub fn CoImpersonateClient() -> HRESULT;
    pub fn CoRevertToSelf() -> HRESULT;
    pub fn CoQueryAuthenticationServices(
        pcAuthSvc: *mut DWORD,
        asAuthSvc: *mut *mut SOLE_AUTHENTICATION_SERVICE,
    ) -> HRESULT;
    pub fn CoSwitchCallContext(
        pNewObject: *mut IUnknown,
        ppOldObject: *mut *mut IUnknown,
    ) -> HRESULT;
}
pub const COM_RIGHTS_EXECUTE: DWORD = 1;
pub const COM_RIGHTS_EXECUTE_LOCAL: DWORD = 2;
pub const COM_RIGHTS_EXECUTE_REMOTE: DWORD = 4;
pub const COM_RIGHTS_ACTIVATE_LOCAL: DWORD = 8;
pub const COM_RIGHTS_ACTIVATE_REMOTE: DWORD = 16;
extern "system" {
    pub fn CoCreateInstance(
        rclsid: REFCLSID,
        pUnkOuter: LPUNKNOWN,
        dwClsContext: DWORD,
        riid: REFIID,
        ppv: *mut LPVOID,
    ) -> HRESULT;
    pub fn CoCreateInstanceEx(
        Clsid: REFCLSID,
        punkOuter: *mut IUnknown,
        dwClsCtx: DWORD,
        pServerInfo: *mut COSERVERINFO,
        dwCount: DWORD,
        pResults: *mut MULTI_QI,
    ) -> HRESULT;
    pub fn CoRegisterActivationFilter(
        pActivationFilter: *mut IActivationFilter,
    ) -> HRESULT;
    pub fn CoCreateInstanceFromApp(
        Clsid: REFCLSID,
        punkOuter: *mut IUnknown,
        dwClsCtx: DWORD,
        reserved: PVOID,
        dwCount: DWORD,
        pResults: *mut MULTI_QI,
    ) -> HRESULT;
    pub fn CoGetCancelObject(
        dwThreadId: DWORD,
        iid: REFIID,
        ppUnk: *mut *mut c_void,
    ) -> HRESULT;
    pub fn CoSetCancelObject(
        pUnk: *mut *mut IUnknown,
    ) -> HRESULT;
    pub fn CoCancelCall(
        dwThreadId: DWORD,
        ulTimeout: ULONG,
    ) -> HRESULT;
    pub fn CoTestCancel() -> HRESULT;
    pub fn CoEnableCallCancellation(
        pReserved: LPVOID,
    ) -> HRESULT;
    pub fn CoDisableCallCancellation(
        pReserved: LPVOID,
    ) -> HRESULT;
    pub fn StringFromCLSID(
        rclsid: REFCLSID,
        lplpsz: *mut LPOLESTR,
    ) -> HRESULT;
    pub fn CLSIDFromString(
        lpsz: LPCOLESTR,
        pclsid: LPCLSID,
    ) -> HRESULT;
    pub fn StringFromIID(
        rclsid: REFIID,
        lplpsz: *mut LPOLESTR,
    ) -> HRESULT;
    pub fn IIDFromString(
        lpsz: LPCOLESTR,
        lpiid: LPIID,
    ) -> HRESULT;
    pub fn ProgIDFromCLSID(
        clsid: REFCLSID,
        lplpszProgID: *mut LPOLESTR,
    ) -> HRESULT;
    pub fn CLSIDFromProgID(
        lpszProgID: LPCOLESTR,
        lpclsid: LPCLSID,
    ) -> HRESULT;
    pub fn StringFromGUID2(
        rguid: REFGUID,
        lpsz: LPOLESTR,
        cchMax: c_int,
    ) -> c_int;
    pub fn CoCreateGuid(
        pguid: *mut GUID,
    ) -> HRESULT;
    pub fn PropVariantCopy(
        pvarDest: *mut PROPVARIANT,
        pvarSrc: *const PROPVARIANT,
    ) -> HRESULT;
    pub fn PropVariantClear(
        pvar: *mut PROPVARIANT,
    ) -> HRESULT;
    pub fn FreePropVariantArray(
        cVariants: ULONG,
        rgvars: *mut PROPVARIANT,
    ) -> HRESULT;
    pub fn CoWaitForMultipleHandles(
        dwFlags: DWORD,
        dwTimeout: DWORD,
        cHandles: ULONG,
        pHandles: LPHANDLE,
        lpdwindex: LPDWORD,
    ) -> HRESULT;
}
ENUM!{enum COWAIT_FLAGS {
    COWAIT_DEFAULT = 0,
    COWAIT_WAITALL = 1,
    COWAIT_ALERTABLE = 2,
    COWAIT_INPUTAVAILABLE = 4,
    COWAIT_DISPATCH_CALLS = 8,
    COWAIT_DISPATCH_WINDOW_MESSAGES = 0x10,
}}
ENUM!{enum CWMO_FLAGS {
    CWMO_DEFAULT = 0,
    CWMO_DISPATCH_CALLS = 1,
    CWMO_DISPATCH_WINDOW_MESSAGES = 2,
}}
extern "system" {
    pub fn CoWaitForMultipleObjects(
        dwFlags: DWORD,
        dwTimeout: DWORD,
        cHandles: ULONG,
        pHandles: *const HANDLE,
        lpdwindex: LPDWORD,
    ) -> HRESULT;
}
pub const CWMO_MAX_HANDLES: ULONG = 56;
extern "system" {
    pub fn CoGetTreatAsClass(
        clsidOld: REFCLSID,
        pClsidNew: LPCLSID,
    ) -> HRESULT;
    pub fn CoInvalidateRemoteMachineBindings(
        pszMachineName: LPOLESTR,
    ) -> HRESULT;
}
ENUM!{enum AgileReferenceOptions {
    AGILEREFERENCE_DEFAULT = 0,
    AGILEREFERENCE_DELAYEDMARSHAL = 1,
}}
extern "system" {
    pub fn RoGetAgileReference(
        options: AgileReferenceOptions,
        riid: REFIID,
        pUnk: *mut IUnknown,
        ppAgileReference: *mut *mut IAgileReference,
    ) -> HRESULT;
}
FN!{stdcall LPFNGETCLASSOBJECT(
    REFCLSID,
    REFIID,
    *mut LPVOID,
) -> HRESULT}
FN!{stdcall LPFNCANUNLOADNOW() -> HRESULT}
extern "system" {
    pub fn DllGetClassObject(
        rclsid: REFCLSID,
        riid: REFIID,
        ppv: *mut LPVOID,
    ) -> HRESULT;
    pub fn DllCanUnloadNow() -> HRESULT;
    pub fn CoTaskMemAlloc(
        cb: SIZE_T,
    ) -> LPVOID;
    pub fn CoTaskMemRealloc(
        pv: LPVOID,
        cb: SIZE_T,
    ) -> LPVOID;
    pub fn CoTaskMemFree(
        pv: LPVOID,
    );
    pub fn CoFileTimeNow(
        lpFileTime: *mut FILETIME,
    ) -> HRESULT;
    pub fn CLSIDFromProgIDEx(
        lpszProgID: LPCOLESTR,
        lpclsid: LPCLSID,
    ) -> HRESULT;
}
Commit	Line	Data
ff7c6d11 XL	1	// Licensed under the Apache License, Version 2.0
	2	// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
	3	// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
	4	// All files in the project carrying such notice may not be copied, modified, or distributed
	5	// except according to those terms.
	6	//! Base Component Object Model defintions.
	7	use ctypes::{c_int, c_void};
	8	use shared::basetsd::{SIZE_T, UINT64, ULONG_PTR};
	9	use shared::guiddef::{CLSID, GUID, LPCLSID, LPIID, REFCLSID, REFGUID, REFIID};
	10	use shared::minwindef::{BOOL, DWORD, FILETIME, HGLOBAL, LPDWORD, LPHANDLE, LPVOID, ULONG};
	11	use shared::rpcdce::{RPC_AUTHZ_HANDLE, RPC_AUTH_IDENTITY_HANDLE};
	12	use shared::wtypesbase::{
	13	CLSCTX, CLSCTX_INPROC_HANDLER, CLSCTX_INPROC_SERVER, CLSCTX_LOCAL_SERVER, CLSCTX_REMOTE_SERVER,
	14	LPCOLESTR, LPOLESTR, OLECHAR,
	15	};
	16	use um::objidl::SOLE_AUTHENTICATION_SERVICE;
	17	use um::objidlbase::{
	18	APTTYPE, APTTYPEQUALIFIER, COSERVERINFO, IActivationFilter, IAgileReference, LPMALLOC,
	19	LPMARSHAL, LPSTREAM, LPSURROGATE, MULTI_QI,
	20	};
	21	use um::propidl::PROPVARIANT;
	22	use um::unknwnbase::{IUnknown, LPUNKNOWN};
	23	use um::winnt::{HANDLE, HRESULT, LARGE_INTEGER, LONG, PSECURITY_DESCRIPTOR, PVOID, ULARGE_INTEGER};
	24	#[inline]
	25	pub fn LISet32(li: &mut LARGE_INTEGER, v: DWORD) {
	26	unsafe {
	27	li.u_mut().HighPart = if (v as LONG) < 0 {
	28	-1
	29	} else {
	30	0
	31	};
	32	li.u_mut().LowPart = v;
	33	}
	34	}
	35	#[inline]
	36	pub fn ULISet32(li: &mut ULARGE_INTEGER, v: DWORD) {
	37	unsafe {
	38	li.u_mut().HighPart = 0;
	39	li.u_mut().LowPart = v;
	40	}
	41	}
	42	pub const CLSCTX_INPROC: CLSCTX = CLSCTX_INPROC_SERVER \| CLSCTX_INPROC_HANDLER;
	43	pub const CLSCTX_ALL: CLSCTX = CLSCTX_INPROC_SERVER \| CLSCTX_INPROC_HANDLER \| CLSCTX_LOCAL_SERVER
	44	\| CLSCTX_REMOTE_SERVER;
	45	pub const CLSCTX_SERVER: CLSCTX = CLSCTX_INPROC_SERVER \| CLSCTX_LOCAL_SERVER
	46	\| CLSCTX_REMOTE_SERVER;
	47	ENUM!{enum REGCLS {
	48	REGCLS_SINGLEUSE = 0,
	49	REGCLS_MULTIPLEUSE = 1,
	50	REGCLS_MULTI_SEPARATE = 2,
	51	REGCLS_SUSPENDED = 4,
	52	REGCLS_SURROGATE = 8,
	53	REGCLS_AGILE = 0x10,
	54	}}
	55	ENUM!{enum COINITBASE {
	56	COINITBASE_MULTITHREADED = 0x0,
	57	}}
	58	extern "system" {
	59	pub fn CoGetMalloc(
	60	dwMemContext: DWORD,
	61	ppMalloc: *mut LPMALLOC,
	62	) -> HRESULT;
	63	pub fn CreateStreamOnHGlobal(
	64	hGlobal: HGLOBAL,
65	fDeleteOnRelease: BOOL,
66	ppstm: *mut LPSTREAM,
67	) -> HRESULT;
68	pub fn GetHGlobalFromStream(
69	pstm: LPSTREAM,
70	phglobal: *mut HGLOBAL,
71	) -> HRESULT;
72	pub fn CoUninitialize() -> ();
73	pub fn CoGetCurrentProcess() -> DWORD;
74	pub fn CoInitializeEx(
75	pvReserved: LPVOID,
76	dwCoInit: DWORD,
77	) -> HRESULT;
78	pub fn CoGetCallerTID(
79	lpdwTID: LPDWORD,
80	) -> HRESULT;
81	pub fn CoGetCurrentLogicalThreadId(
82	pguid: *mut GUID,
83	) -> HRESULT;
84	pub fn CoGetContextToken(
85	pToken: *mut ULONG_PTR,
86	) -> HRESULT;
87	pub fn CoGetDefaultContext(
88	aptType: APTTYPE,
89	riid: REFIID,
90	ppv: mut mut c_void,
91	) -> HRESULT;
92	pub fn CoGetApartmentType(
93	pAptType: *mut APTTYPE,
94	pAptQualifier: *mut APTTYPEQUALIFIER,
95	) -> HRESULT;
96	}
97	STRUCT!{struct ServerInformation {
98	dwServerPid: DWORD,
99	dwServerTid: DWORD,
100	ui64ServerAddress: UINT64,
101	}}
102	pub type PServerInformation = *mut ServerInformation;
103	extern "system" {
104	pub fn CoDecodeProxy(
105	dwClientPid: DWORD,
106	ui64ProxyAddress: UINT64,
107	pServerInformation: PServerInformation,
108	) -> HRESULT;
109	}
0bf4aa26	110	DECLARE_HANDLE!{CO_MTA_USAGE_COOKIE, CO_MTA_USAGE_COOKIE__}
ff7c6d11 XL	111	extern "system" {
	112	pub fn CoIncrementMTAUsage(
	113	pCookie: *mut CO_MTA_USAGE_COOKIE,
	114	) -> HRESULT;
	115	pub fn CoDecrementMTAUsage(
	116	Cookie: CO_MTA_USAGE_COOKIE,
	117	) -> HRESULT;
	118	pub fn CoAllowUnmarshalerCLSID(
	119	clsid: REFCLSID,
	120	) -> HRESULT;
	121	pub fn CoGetObjectContext(
	122	riid: REFIID,
	123	ppv: *mut LPVOID,
	124	) -> HRESULT;
	125	pub fn CoGetClassObject(
	126	rclsid: REFCLSID,
	127	dwClsContext: DWORD,
	128	pvReserved: LPVOID,
	129	riid: REFIID,
	130	ppv: *mut LPVOID,
	131	) -> HRESULT;
	132	pub fn CoRegisterClassObject(
	133	rclsid: REFCLSID,
	134	pUnk: LPUNKNOWN,
	135	dwClsContext: DWORD,
	136	flags: DWORD,
	137	lpdwRegister: LPDWORD,
	138	) -> HRESULT;
	139	pub fn CoRevokeClassObject(
	140	dwRegister: DWORD,
	141	) -> HRESULT;
	142	pub fn CoResumeClassObjects() -> HRESULT;
	143	pub fn CoSuspendClassObjects() -> HRESULT;
	144	pub fn CoAddRefServerProcess() -> ULONG;
	145	pub fn CoReleaseServerProcess() -> ULONG;
	146	pub fn CoGetPSClsid(
	147	riid: REFIID,
	148	pClsid: *mut CLSID,
	149	) -> HRESULT;
	150	pub fn CoRegisterPSClsid(
	151	riid: REFIID,
	152	rclsid: REFCLSID,
	153	) -> HRESULT;
	154	pub fn CoRegisterSurrogate(
	155	pSurrogate: LPSURROGATE,
	156	) -> HRESULT;
	157	pub fn CoGetMarshalSizeMax(
	158	pulSize: *mut ULONG,
	159	riid: REFIID,
	160	pUnk: LPUNKNOWN,
	161	dwDestContext: DWORD,
	162	pvDestContext: LPVOID,
	163	mshlflags: DWORD,
	164	) -> HRESULT;
	165	pub fn CoMarshalInterface(
	166	pStm: LPSTREAM,
	167	riid: REFIID,
	168	pUnk: LPUNKNOWN,
	169	dwDestContext: DWORD,
	170	pvDestContext: LPVOID,
	171	mshlflags: DWORD,
	172	) -> HRESULT;
	173	pub fn CoUnmarshalInterface(
	174	pStm: LPSTREAM,
175	riid: REFIID,
176	ppv: *mut LPVOID,
177	) -> HRESULT;
178	pub fn CoMarshalHresult(
179	pstm: LPSTREAM,
180	hresult: HRESULT,
181	) -> HRESULT;
182	pub fn CoUnmarshalHresult(
183	pstm: LPSTREAM,
184	phresult: *mut HRESULT,
185	) -> HRESULT;
186	pub fn CoReleaseMarshalData(
187	pstm: LPSTREAM,
188	) -> HRESULT;
189	pub fn CoDisconnectObject(
190	pUnk: LPUNKNOWN,
191	dwReserved: DWORD,
192	) -> HRESULT;
193	pub fn CoLockObjectExternal(
194	pUnk: LPUNKNOWN,
195	fLock: BOOL,
196	fLastUnlockReleases: BOOL,
197	) -> HRESULT;
198	pub fn CoGetStandardMarshal(
199	riid: REFIID,
200	pUnk: LPUNKNOWN,
201	dwDestContext: DWORD,
202	pvDestContext: LPVOID,
203	mshlflags: DWORD,
204	ppMarshal: *mut LPMARSHAL,
205	) -> HRESULT;
206	pub fn CoGetStdMarshalEx(
207	pUnkOuter: LPUNKNOWN,
208	smexflags: DWORD,
209	ppUnkInner: *mut LPUNKNOWN,
210	) -> HRESULT;
211	}
212	ENUM!{enum STDMSHLFLAGS {
213	SMEXF_SERVER = 0x01,
214	SMEXF_HANDLER = 0x02,
215	}}
216	extern "system" {
217	pub fn CoIsHandlerConnected(
218	pUnk: LPUNKNOWN,
219	) -> BOOL;
220	pub fn CoMarshalInterThreadInterfaceInStream(
221	riid: REFIID,
222	pUnk: LPUNKNOWN,
223	ppStm: *mut LPSTREAM,
224	) -> HRESULT;
225	pub fn CoGetInterfaceAndReleaseStream(
226	pStm: LPSTREAM,
227	iid: REFIID,
228	ppv: *mut LPVOID,
229	) -> HRESULT;
230	pub fn CoCreateFreeThreadedMarshaler(
231	punkOuter: LPUNKNOWN,
232	ppunkMarshal: *mut LPUNKNOWN,
233	) -> HRESULT;
234	pub fn CoFreeUnusedLibraries();
235	pub fn CoFreeUnusedLibrariesEx(
236	dwUnloadDelay: DWORD,
237	dwReserved: DWORD,
238	);
239	pub fn CoDisconnectContext(
240	dwTimeout: DWORD,
241	)-> HRESULT;
242	pub fn CoInitializeSecurity(
243	pSecDesc: PSECURITY_DESCRIPTOR,
244	cAuthSvc: LONG,
245	asAuthSvc: *mut SOLE_AUTHENTICATION_SERVICE,
246	pReserved1: *mut c_void,
247	dwAuthnLevel: DWORD,
248	dwImpLevel: DWORD,
249	pAuthList: *mut c_void,
250	dwCapabilities: DWORD,
251	pReserved3: *mut c_void,
252	) -> HRESULT;
253	pub fn CoGetCallContext(
254	riid: REFIID,
255	ppInterface: mut mut c_void,
256	) -> HRESULT;
257	pub fn CoQueryProxyBlanket(
258	pProxy: *mut IUnknown,
259	pwAuthnSvc: *mut DWORD,
260	pAuthzSvc: *mut DWORD,
261	pServerPrincName: *mut LPOLESTR,
262	pAuthnLevel: *mut DWORD,
263	pImpLevel: *mut DWORD,
264	pAuthInfo: *mut RPC_AUTH_IDENTITY_HANDLE,
265	pCapabilites: *mut DWORD,
266	) -> HRESULT;
267	pub fn CoSetProxyBlanket(
268	pProxy: *mut IUnknown,
269	dwAuthnSvc: DWORD,
270	dwAuthzSvc: DWORD,
271	pServerPrincName: *mut OLECHAR,
272	dwAuthnLevel: DWORD,
273	dwImpLevel: DWORD,
274	pAuthInfo: RPC_AUTH_IDENTITY_HANDLE,
275	dwCapabilities: DWORD,
276	) -> HRESULT;
277	pub fn CoCopyProxy(
278	pProxy: *mut IUnknown,
279	ppCopy: mut mut IUnknown,
280	) -> HRESULT;
281	pub fn CoQueryClientBlanket(
282	pAuthnSvc: *mut DWORD,
283	pAuthzSvc: *mut DWORD,
284	pServerPrincName: *mut LPOLESTR,
285	pAuthnLevel: *mut DWORD,
286	pImpLevel: *mut DWORD,
287	pPrivs: *mut RPC_AUTHZ_HANDLE,
288	pCapabilities: *mut DWORD,
289	) -> HRESULT;
290	pub fn CoImpersonateClient() -> HRESULT;
291	pub fn CoRevertToSelf() -> HRESULT;
292	pub fn CoQueryAuthenticationServices(
293	pcAuthSvc: *mut DWORD,
294	asAuthSvc: mut mut SOLE_AUTHENTICATION_SERVICE,
295	) -> HRESULT;
296	pub fn CoSwitchCallContext(
297	pNewObject: *mut IUnknown,
298	ppOldObject: mut mut IUnknown,
299	) -> HRESULT;
300	}
301	pub const COM_RIGHTS_EXECUTE: DWORD = 1;
302	pub const COM_RIGHTS_EXECUTE_LOCAL: DWORD = 2;
303	pub const COM_RIGHTS_EXECUTE_REMOTE: DWORD = 4;
304	pub const COM_RIGHTS_ACTIVATE_LOCAL: DWORD = 8;
305	pub const COM_RIGHTS_ACTIVATE_REMOTE: DWORD = 16;
306	extern "system" {
307	pub fn CoCreateInstance(
308	rclsid: REFCLSID,
309	pUnkOuter: LPUNKNOWN,
310	dwClsContext: DWORD,
311	riid: REFIID,
312	ppv: *mut LPVOID,
313	) -> HRESULT;
314	pub fn CoCreateInstanceEx(
315	Clsid: REFCLSID,
316	punkOuter: *mut IUnknown,
317	dwClsCtx: DWORD,
318	pServerInfo: *mut COSERVERINFO,
319	dwCount: DWORD,
320	pResults: *mut MULTI_QI,
321	) -> HRESULT;
322	pub fn CoRegisterActivationFilter(
323	pActivationFilter: *mut IActivationFilter,
324	) -> HRESULT;
325	pub fn CoCreateInstanceFromApp(
326	Clsid: REFCLSID,
327	punkOuter: *mut IUnknown,
328	dwClsCtx: DWORD,
329	reserved: PVOID,
330	dwCount: DWORD,
331	pResults: *mut MULTI_QI,
332	) -> HRESULT;
333	pub fn CoGetCancelObject(
334	dwThreadId: DWORD,
335	iid: REFIID,
336	ppUnk: mut mut c_void,
337	) -> HRESULT;
338	pub fn CoSetCancelObject(
339	pUnk: mut mut IUnknown,
340	) -> HRESULT;
341	pub fn CoCancelCall(
342	dwThreadId: DWORD,
343	ulTimeout: ULONG,
344	) -> HRESULT;
345	pub fn CoTestCancel() -> HRESULT;
346	pub fn CoEnableCallCancellation(
347	pReserved: LPVOID,
348	) -> HRESULT;
349	pub fn CoDisableCallCancellation(
350	pReserved: LPVOID,
351	) -> HRESULT;
352	pub fn StringFromCLSID(
353	rclsid: REFCLSID,
354	lplpsz: *mut LPOLESTR,
355	) -> HRESULT;
356	pub fn CLSIDFromString(
357	lpsz: LPCOLESTR,
358	pclsid: LPCLSID,
359	) -> HRESULT;
360	pub fn StringFromIID(
361	rclsid: REFIID,
362	lplpsz: *mut LPOLESTR,
363	) -> HRESULT;
364	pub fn IIDFromString(
365	lpsz: LPCOLESTR,
366	lpiid: LPIID,
367	) -> HRESULT;
368	pub fn ProgIDFromCLSID(
369	clsid: REFCLSID,
370	lplpszProgID: *mut LPOLESTR,
371	) -> HRESULT;
372	pub fn CLSIDFromProgID(
373	lpszProgID: LPCOLESTR,
374	lpclsid: LPCLSID,
375	) -> HRESULT;
376	pub fn StringFromGUID2(
377	rguid: REFGUID,
378	lpsz: LPOLESTR,
379	cchMax: c_int,
380	) -> c_int;
381	pub fn CoCreateGuid(
382	pguid: *mut GUID,
383	) -> HRESULT;
384	pub fn PropVariantCopy(
385	pvarDest: *mut PROPVARIANT,
386	pvarSrc: *const PROPVARIANT,
387	) -> HRESULT;
388	pub fn PropVariantClear(
389	pvar: *mut PROPVARIANT,
390	) -> HRESULT;
391	pub fn FreePropVariantArray(
392	cVariants: ULONG,
393	rgvars: *mut PROPVARIANT,
394	) -> HRESULT;
395	pub fn CoWaitForMultipleHandles(
396	dwFlags: DWORD,
397	dwTimeout: DWORD,
398	cHandles: ULONG,
399	pHandles: LPHANDLE,
400	lpdwindex: LPDWORD,
401	) -> HRESULT;
402	}
403	ENUM!{enum COWAIT_FLAGS {
404	COWAIT_DEFAULT = 0,
405	COWAIT_WAITALL = 1,
406	COWAIT_ALERTABLE = 2,
407	COWAIT_INPUTAVAILABLE = 4,
408	COWAIT_DISPATCH_CALLS = 8,
409	COWAIT_DISPATCH_WINDOW_MESSAGES = 0x10,
410	}}
411	ENUM!{enum CWMO_FLAGS {
412	CWMO_DEFAULT = 0,
413	CWMO_DISPATCH_CALLS = 1,
414	CWMO_DISPATCH_WINDOW_MESSAGES = 2,
415	}}
416	extern "system" {
417	pub fn CoWaitForMultipleObjects(
418	dwFlags: DWORD,
419	dwTimeout: DWORD,
420	cHandles: ULONG,
421	pHandles: *const HANDLE,
422	lpdwindex: LPDWORD,
423	) -> HRESULT;
424	}
425	pub const CWMO_MAX_HANDLES: ULONG = 56;
426	extern "system" {
427	pub fn CoGetTreatAsClass(
428	clsidOld: REFCLSID,
429	pClsidNew: LPCLSID,
430	) -> HRESULT;
431	pub fn CoInvalidateRemoteMachineBindings(
432	pszMachineName: LPOLESTR,
433	) -> HRESULT;
434	}
435	ENUM!{enum AgileReferenceOptions {
436	AGILEREFERENCE_DEFAULT = 0,
437	AGILEREFERENCE_DELAYEDMARSHAL = 1,
438	}}
439	extern "system" {
440	pub fn RoGetAgileReference(
441	options: AgileReferenceOptions,
442	riid: REFIID,
443	pUnk: *mut IUnknown,
444	ppAgileReference: mut mut IAgileReference,
445	) -> HRESULT;
446	}
447	FN!{stdcall LPFNGETCLASSOBJECT(
448	REFCLSID,
449	REFIID,
450	*mut LPVOID,
451	) -> HRESULT}
452	FN!{stdcall LPFNCANUNLOADNOW() -> HRESULT}
453	extern "system" {
454	pub fn DllGetClassObject(
455	rclsid: REFCLSID,
456	riid: REFIID,
457	ppv: *mut LPVOID,
458	) -> HRESULT;
459	pub fn DllCanUnloadNow() -> HRESULT;
460	pub fn CoTaskMemAlloc(
461	cb: SIZE_T,
462	) -> LPVOID;
463	pub fn CoTaskMemRealloc(
464	pv: LPVOID,
465	cb: SIZE_T,
466	) -> LPVOID;
467	pub fn CoTaskMemFree(
468	pv: LPVOID,
469	);
470	pub fn CoFileTimeNow(
471	lpFileTime: *mut FILETIME,
472	) -> HRESULT;
473	pub fn CLSIDFromProgIDEx(
474	lpszProgID: LPCOLESTR,
475	lpclsid: LPCLSID,
476	) -> HRESULT;
477	}