vendor/winapi-0.3.3/src/um/combaseapi.rs

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