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