comm-central/third_party/rust/winapi/src/um/combaseapi.rs

Revision control

Copy as Markdown

Other Tools

// 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;
}