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]
LISet32(li: &mut LARGE_INTEGER, v: DWORD)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]
ULISet32(li: &mut ULARGE_INTEGER, v: DWORD)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" {
CoGetMalloc( dwMemContext: DWORD, ppMalloc: *mut LPMALLOC, ) -> HRESULT59 pub fn CoGetMalloc(
60 dwMemContext: DWORD,
61 ppMalloc: *mut LPMALLOC,
62 ) -> HRESULT;
CreateStreamOnHGlobal( hGlobal: HGLOBAL, fDeleteOnRelease: BOOL, ppstm: *mut LPSTREAM, ) -> HRESULT63 pub fn CreateStreamOnHGlobal(
64 hGlobal: HGLOBAL,
65 fDeleteOnRelease: BOOL,
66 ppstm: *mut LPSTREAM,
67 ) -> HRESULT;
GetHGlobalFromStream( pstm: LPSTREAM, phglobal: *mut HGLOBAL, ) -> HRESULT68 pub fn GetHGlobalFromStream(
69 pstm: LPSTREAM,
70 phglobal: *mut HGLOBAL,
71 ) -> HRESULT;
CoUninitialize() -> ()72 pub fn CoUninitialize() -> ();
CoGetCurrentProcess() -> DWORD73 pub fn CoGetCurrentProcess() -> DWORD;
CoInitializeEx( pvReserved: LPVOID, dwCoInit: DWORD, ) -> HRESULT74 pub fn CoInitializeEx(
75 pvReserved: LPVOID,
76 dwCoInit: DWORD,
77 ) -> HRESULT;
CoGetCallerTID( lpdwTID: LPDWORD, ) -> HRESULT78 pub fn CoGetCallerTID(
79 lpdwTID: LPDWORD,
80 ) -> HRESULT;
CoGetCurrentLogicalThreadId( pguid: *mut GUID, ) -> HRESULT81 pub fn CoGetCurrentLogicalThreadId(
82 pguid: *mut GUID,
83 ) -> HRESULT;
CoGetContextToken( pToken: *mut ULONG_PTR, ) -> HRESULT84 pub fn CoGetContextToken(
85 pToken: *mut ULONG_PTR,
86 ) -> HRESULT;
CoGetDefaultContext( aptType: APTTYPE, riid: REFIID, ppv: *mut *mut c_void, ) -> HRESULT87 pub fn CoGetDefaultContext(
88 aptType: APTTYPE,
89 riid: REFIID,
90 ppv: *mut *mut c_void,
91 ) -> HRESULT;
CoGetApartmentType( pAptType: *mut APTTYPE, pAptQualifier: *mut APTTYPEQUALIFIER, ) -> HRESULT92 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" {
CoDecodeProxy( dwClientPid: DWORD, ui64ProxyAddress: UINT64, pServerInformation: PServerInformation, ) -> HRESULT104 pub fn CoDecodeProxy(
105 dwClientPid: DWORD,
106 ui64ProxyAddress: UINT64,
107 pServerInformation: PServerInformation,
108 ) -> HRESULT;
109 }
110 DECLARE_HANDLE!{CO_MTA_USAGE_COOKIE, CO_MTA_USAGE_COOKIE__}
111 extern "system" {
CoIncrementMTAUsage( pCookie: *mut CO_MTA_USAGE_COOKIE, ) -> HRESULT112 pub fn CoIncrementMTAUsage(
113 pCookie: *mut CO_MTA_USAGE_COOKIE,
114 ) -> HRESULT;
CoDecrementMTAUsage( Cookie: CO_MTA_USAGE_COOKIE, ) -> HRESULT115 pub fn CoDecrementMTAUsage(
116 Cookie: CO_MTA_USAGE_COOKIE,
117 ) -> HRESULT;
CoAllowUnmarshalerCLSID( clsid: REFCLSID, ) -> HRESULT118 pub fn CoAllowUnmarshalerCLSID(
119 clsid: REFCLSID,
120 ) -> HRESULT;
CoGetObjectContext( riid: REFIID, ppv: *mut LPVOID, ) -> HRESULT121 pub fn CoGetObjectContext(
122 riid: REFIID,
123 ppv: *mut LPVOID,
124 ) -> HRESULT;
CoGetClassObject( rclsid: REFCLSID, dwClsContext: DWORD, pvReserved: LPVOID, riid: REFIID, ppv: *mut LPVOID, ) -> HRESULT125 pub fn CoGetClassObject(
126 rclsid: REFCLSID,
127 dwClsContext: DWORD,
128 pvReserved: LPVOID,
129 riid: REFIID,
130 ppv: *mut LPVOID,
131 ) -> HRESULT;
CoRegisterClassObject( rclsid: REFCLSID, pUnk: LPUNKNOWN, dwClsContext: DWORD, flags: DWORD, lpdwRegister: LPDWORD, ) -> HRESULT132 pub fn CoRegisterClassObject(
133 rclsid: REFCLSID,
134 pUnk: LPUNKNOWN,
135 dwClsContext: DWORD,
136 flags: DWORD,
137 lpdwRegister: LPDWORD,
138 ) -> HRESULT;
CoRevokeClassObject( dwRegister: DWORD, ) -> HRESULT139 pub fn CoRevokeClassObject(
140 dwRegister: DWORD,
141 ) -> HRESULT;
CoResumeClassObjects() -> HRESULT142 pub fn CoResumeClassObjects() -> HRESULT;
CoSuspendClassObjects() -> HRESULT143 pub fn CoSuspendClassObjects() -> HRESULT;
CoAddRefServerProcess() -> ULONG144 pub fn CoAddRefServerProcess() -> ULONG;
CoReleaseServerProcess() -> ULONG145 pub fn CoReleaseServerProcess() -> ULONG;
CoGetPSClsid( riid: REFIID, pClsid: *mut CLSID, ) -> HRESULT146 pub fn CoGetPSClsid(
147 riid: REFIID,
148 pClsid: *mut CLSID,
149 ) -> HRESULT;
CoRegisterPSClsid( riid: REFIID, rclsid: REFCLSID, ) -> HRESULT150 pub fn CoRegisterPSClsid(
151 riid: REFIID,
152 rclsid: REFCLSID,
153 ) -> HRESULT;
CoRegisterSurrogate( pSurrogate: LPSURROGATE, ) -> HRESULT154 pub fn CoRegisterSurrogate(
155 pSurrogate: LPSURROGATE,
156 ) -> HRESULT;
CoGetMarshalSizeMax( pulSize: *mut ULONG, riid: REFIID, pUnk: LPUNKNOWN, dwDestContext: DWORD, pvDestContext: LPVOID, mshlflags: DWORD, ) -> HRESULT157 pub fn CoGetMarshalSizeMax(
158 pulSize: *mut ULONG,
159 riid: REFIID,
160 pUnk: LPUNKNOWN,
161 dwDestContext: DWORD,
162 pvDestContext: LPVOID,
163 mshlflags: DWORD,
164 ) -> HRESULT;
CoMarshalInterface( pStm: LPSTREAM, riid: REFIID, pUnk: LPUNKNOWN, dwDestContext: DWORD, pvDestContext: LPVOID, mshlflags: DWORD, ) -> HRESULT165 pub fn CoMarshalInterface(
166 pStm: LPSTREAM,
167 riid: REFIID,
168 pUnk: LPUNKNOWN,
169 dwDestContext: DWORD,
170 pvDestContext: LPVOID,
171 mshlflags: DWORD,
172 ) -> HRESULT;
CoUnmarshalInterface( pStm: LPSTREAM, riid: REFIID, ppv: *mut LPVOID, ) -> HRESULT173 pub fn CoUnmarshalInterface(
174 pStm: LPSTREAM,
175 riid: REFIID,
176 ppv: *mut LPVOID,
177 ) -> HRESULT;
CoMarshalHresult( pstm: LPSTREAM, hresult: HRESULT, ) -> HRESULT178 pub fn CoMarshalHresult(
179 pstm: LPSTREAM,
180 hresult: HRESULT,
181 ) -> HRESULT;
CoUnmarshalHresult( pstm: LPSTREAM, phresult: *mut HRESULT, ) -> HRESULT182 pub fn CoUnmarshalHresult(
183 pstm: LPSTREAM,
184 phresult: *mut HRESULT,
185 ) -> HRESULT;
CoReleaseMarshalData( pstm: LPSTREAM, ) -> HRESULT186 pub fn CoReleaseMarshalData(
187 pstm: LPSTREAM,
188 ) -> HRESULT;
CoDisconnectObject( pUnk: LPUNKNOWN, dwReserved: DWORD, ) -> HRESULT189 pub fn CoDisconnectObject(
190 pUnk: LPUNKNOWN,
191 dwReserved: DWORD,
192 ) -> HRESULT;
CoLockObjectExternal( pUnk: LPUNKNOWN, fLock: BOOL, fLastUnlockReleases: BOOL, ) -> HRESULT193 pub fn CoLockObjectExternal(
194 pUnk: LPUNKNOWN,
195 fLock: BOOL,
196 fLastUnlockReleases: BOOL,
197 ) -> HRESULT;
CoGetStandardMarshal( riid: REFIID, pUnk: LPUNKNOWN, dwDestContext: DWORD, pvDestContext: LPVOID, mshlflags: DWORD, ppMarshal: *mut LPMARSHAL, ) -> HRESULT198 pub fn CoGetStandardMarshal(
199 riid: REFIID,
200 pUnk: LPUNKNOWN,
201 dwDestContext: DWORD,
202 pvDestContext: LPVOID,
203 mshlflags: DWORD,
204 ppMarshal: *mut LPMARSHAL,
205 ) -> HRESULT;
CoGetStdMarshalEx( pUnkOuter: LPUNKNOWN, smexflags: DWORD, ppUnkInner: *mut LPUNKNOWN, ) -> HRESULT206 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" {
CoIsHandlerConnected( pUnk: LPUNKNOWN, ) -> BOOL217 pub fn CoIsHandlerConnected(
218 pUnk: LPUNKNOWN,
219 ) -> BOOL;
CoMarshalInterThreadInterfaceInStream( riid: REFIID, pUnk: LPUNKNOWN, ppStm: *mut LPSTREAM, ) -> HRESULT220 pub fn CoMarshalInterThreadInterfaceInStream(
221 riid: REFIID,
222 pUnk: LPUNKNOWN,
223 ppStm: *mut LPSTREAM,
224 ) -> HRESULT;
CoGetInterfaceAndReleaseStream( pStm: LPSTREAM, iid: REFIID, ppv: *mut LPVOID, ) -> HRESULT225 pub fn CoGetInterfaceAndReleaseStream(
226 pStm: LPSTREAM,
227 iid: REFIID,
228 ppv: *mut LPVOID,
229 ) -> HRESULT;
CoCreateFreeThreadedMarshaler( punkOuter: LPUNKNOWN, ppunkMarshal: *mut LPUNKNOWN, ) -> HRESULT230 pub fn CoCreateFreeThreadedMarshaler(
231 punkOuter: LPUNKNOWN,
232 ppunkMarshal: *mut LPUNKNOWN,
233 ) -> HRESULT;
CoFreeUnusedLibraries()234 pub fn CoFreeUnusedLibraries();
CoFreeUnusedLibrariesEx( dwUnloadDelay: DWORD, dwReserved: DWORD, )235 pub fn CoFreeUnusedLibrariesEx(
236 dwUnloadDelay: DWORD,
237 dwReserved: DWORD,
238 );
CoDisconnectContext( dwTimeout: DWORD, )-> HRESULT239 pub fn CoDisconnectContext(
240 dwTimeout: DWORD,
241 )-> HRESULT;
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, ) -> HRESULT242 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;
CoGetCallContext( riid: REFIID, ppInterface: *mut *mut c_void, ) -> HRESULT253 pub fn CoGetCallContext(
254 riid: REFIID,
255 ppInterface: *mut *mut c_void,
256 ) -> HRESULT;
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, ) -> HRESULT257 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;
CoSetProxyBlanket( pProxy: *mut IUnknown, dwAuthnSvc: DWORD, dwAuthzSvc: DWORD, pServerPrincName: *mut OLECHAR, dwAuthnLevel: DWORD, dwImpLevel: DWORD, pAuthInfo: RPC_AUTH_IDENTITY_HANDLE, dwCapabilities: DWORD, ) -> HRESULT267 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;
CoCopyProxy( pProxy: *mut IUnknown, ppCopy: *mut *mut IUnknown, ) -> HRESULT277 pub fn CoCopyProxy(
278 pProxy: *mut IUnknown,
279 ppCopy: *mut *mut IUnknown,
280 ) -> HRESULT;
CoQueryClientBlanket( pAuthnSvc: *mut DWORD, pAuthzSvc: *mut DWORD, pServerPrincName: *mut LPOLESTR, pAuthnLevel: *mut DWORD, pImpLevel: *mut DWORD, pPrivs: *mut RPC_AUTHZ_HANDLE, pCapabilities: *mut DWORD, ) -> HRESULT281 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;
CoImpersonateClient() -> HRESULT290 pub fn CoImpersonateClient() -> HRESULT;
CoRevertToSelf() -> HRESULT291 pub fn CoRevertToSelf() -> HRESULT;
CoQueryAuthenticationServices( pcAuthSvc: *mut DWORD, asAuthSvc: *mut *mut SOLE_AUTHENTICATION_SERVICE, ) -> HRESULT292 pub fn CoQueryAuthenticationServices(
293 pcAuthSvc: *mut DWORD,
294 asAuthSvc: *mut *mut SOLE_AUTHENTICATION_SERVICE,
295 ) -> HRESULT;
CoSwitchCallContext( pNewObject: *mut IUnknown, ppOldObject: *mut *mut IUnknown, ) -> HRESULT296 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" {
CoCreateInstance( rclsid: REFCLSID, pUnkOuter: LPUNKNOWN, dwClsContext: DWORD, riid: REFIID, ppv: *mut LPVOID, ) -> HRESULT307 pub fn CoCreateInstance(
308 rclsid: REFCLSID,
309 pUnkOuter: LPUNKNOWN,
310 dwClsContext: DWORD,
311 riid: REFIID,
312 ppv: *mut LPVOID,
313 ) -> HRESULT;
CoCreateInstanceEx( Clsid: REFCLSID, punkOuter: *mut IUnknown, dwClsCtx: DWORD, pServerInfo: *mut COSERVERINFO, dwCount: DWORD, pResults: *mut MULTI_QI, ) -> HRESULT314 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;
CoRegisterActivationFilter( pActivationFilter: *mut IActivationFilter, ) -> HRESULT322 pub fn CoRegisterActivationFilter(
323 pActivationFilter: *mut IActivationFilter,
324 ) -> HRESULT;
CoCreateInstanceFromApp( Clsid: REFCLSID, punkOuter: *mut IUnknown, dwClsCtx: DWORD, reserved: PVOID, dwCount: DWORD, pResults: *mut MULTI_QI, ) -> HRESULT325 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;
CoGetCancelObject( dwThreadId: DWORD, iid: REFIID, ppUnk: *mut *mut c_void, ) -> HRESULT333 pub fn CoGetCancelObject(
334 dwThreadId: DWORD,
335 iid: REFIID,
336 ppUnk: *mut *mut c_void,
337 ) -> HRESULT;
CoSetCancelObject( pUnk: *mut *mut IUnknown, ) -> HRESULT338 pub fn CoSetCancelObject(
339 pUnk: *mut *mut IUnknown,
340 ) -> HRESULT;
CoCancelCall( dwThreadId: DWORD, ulTimeout: ULONG, ) -> HRESULT341 pub fn CoCancelCall(
342 dwThreadId: DWORD,
343 ulTimeout: ULONG,
344 ) -> HRESULT;
CoTestCancel() -> HRESULT345 pub fn CoTestCancel() -> HRESULT;
CoEnableCallCancellation( pReserved: LPVOID, ) -> HRESULT346 pub fn CoEnableCallCancellation(
347 pReserved: LPVOID,
348 ) -> HRESULT;
CoDisableCallCancellation( pReserved: LPVOID, ) -> HRESULT349 pub fn CoDisableCallCancellation(
350 pReserved: LPVOID,
351 ) -> HRESULT;
StringFromCLSID( rclsid: REFCLSID, lplpsz: *mut LPOLESTR, ) -> HRESULT352 pub fn StringFromCLSID(
353 rclsid: REFCLSID,
354 lplpsz: *mut LPOLESTR,
355 ) -> HRESULT;
CLSIDFromString( lpsz: LPCOLESTR, pclsid: LPCLSID, ) -> HRESULT356 pub fn CLSIDFromString(
357 lpsz: LPCOLESTR,
358 pclsid: LPCLSID,
359 ) -> HRESULT;
StringFromIID( rclsid: REFIID, lplpsz: *mut LPOLESTR, ) -> HRESULT360 pub fn StringFromIID(
361 rclsid: REFIID,
362 lplpsz: *mut LPOLESTR,
363 ) -> HRESULT;
IIDFromString( lpsz: LPCOLESTR, lpiid: LPIID, ) -> HRESULT364 pub fn IIDFromString(
365 lpsz: LPCOLESTR,
366 lpiid: LPIID,
367 ) -> HRESULT;
ProgIDFromCLSID( clsid: REFCLSID, lplpszProgID: *mut LPOLESTR, ) -> HRESULT368 pub fn ProgIDFromCLSID(
369 clsid: REFCLSID,
370 lplpszProgID: *mut LPOLESTR,
371 ) -> HRESULT;
CLSIDFromProgID( lpszProgID: LPCOLESTR, lpclsid: LPCLSID, ) -> HRESULT372 pub fn CLSIDFromProgID(
373 lpszProgID: LPCOLESTR,
374 lpclsid: LPCLSID,
375 ) -> HRESULT;
StringFromGUID2( rguid: REFGUID, lpsz: LPOLESTR, cchMax: c_int, ) -> c_int376 pub fn StringFromGUID2(
377 rguid: REFGUID,
378 lpsz: LPOLESTR,
379 cchMax: c_int,
380 ) -> c_int;
CoCreateGuid( pguid: *mut GUID, ) -> HRESULT381 pub fn CoCreateGuid(
382 pguid: *mut GUID,
383 ) -> HRESULT;
PropVariantCopy( pvarDest: *mut PROPVARIANT, pvarSrc: *const PROPVARIANT, ) -> HRESULT384 pub fn PropVariantCopy(
385 pvarDest: *mut PROPVARIANT,
386 pvarSrc: *const PROPVARIANT,
387 ) -> HRESULT;
PropVariantClear( pvar: *mut PROPVARIANT, ) -> HRESULT388 pub fn PropVariantClear(
389 pvar: *mut PROPVARIANT,
390 ) -> HRESULT;
FreePropVariantArray( cVariants: ULONG, rgvars: *mut PROPVARIANT, ) -> HRESULT391 pub fn FreePropVariantArray(
392 cVariants: ULONG,
393 rgvars: *mut PROPVARIANT,
394 ) -> HRESULT;
CoWaitForMultipleHandles( dwFlags: DWORD, dwTimeout: DWORD, cHandles: ULONG, pHandles: LPHANDLE, lpdwindex: LPDWORD, ) -> HRESULT395 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" {
CoWaitForMultipleObjects( dwFlags: DWORD, dwTimeout: DWORD, cHandles: ULONG, pHandles: *const HANDLE, lpdwindex: LPDWORD, ) -> HRESULT417 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" {
CoGetTreatAsClass( clsidOld: REFCLSID, pClsidNew: LPCLSID, ) -> HRESULT427 pub fn CoGetTreatAsClass(
428 clsidOld: REFCLSID,
429 pClsidNew: LPCLSID,
430 ) -> HRESULT;
CoInvalidateRemoteMachineBindings( pszMachineName: LPOLESTR, ) -> HRESULT431 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" {
RoGetAgileReference( options: AgileReferenceOptions, riid: REFIID, pUnk: *mut IUnknown, ppAgileReference: *mut *mut IAgileReference, ) -> HRESULT440 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" {
DllGetClassObject( rclsid: REFCLSID, riid: REFIID, ppv: *mut LPVOID, ) -> HRESULT454 pub fn DllGetClassObject(
455 rclsid: REFCLSID,
456 riid: REFIID,
457 ppv: *mut LPVOID,
458 ) -> HRESULT;
DllCanUnloadNow() -> HRESULT459 pub fn DllCanUnloadNow() -> HRESULT;
CoTaskMemAlloc( cb: SIZE_T, ) -> LPVOID460 pub fn CoTaskMemAlloc(
461 cb: SIZE_T,
462 ) -> LPVOID;
CoTaskMemRealloc( pv: LPVOID, cb: SIZE_T, ) -> LPVOID463 pub fn CoTaskMemRealloc(
464 pv: LPVOID,
465 cb: SIZE_T,
466 ) -> LPVOID;
CoTaskMemFree( pv: LPVOID, )467 pub fn CoTaskMemFree(
468 pv: LPVOID,
469 );
CoFileTimeNow( lpFileTime: *mut FILETIME, ) -> HRESULT470 pub fn CoFileTimeNow(
471 lpFileTime: *mut FILETIME,
472 ) -> HRESULT;
CLSIDFromProgIDEx( lpszProgID: LPCOLESTR, lpclsid: LPCLSID, ) -> HRESULT473 pub fn CLSIDFromProgIDEx(
474 lpszProgID: LPCOLESTR,
475 lpclsid: LPCLSID,
476 ) -> HRESULT;
477 }
478