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 use ctypes::{c_int, c_void};
8 use shared::basetsd::{SIZE_T, ULONG_PTR};
9 use shared::guiddef::{CLSID, GUID, IID, REFCLSID, REFGUID, REFIID};
10 use shared::minwindef::{BOOL, BYTE, DWORD, FILETIME, ULONG};
11 use shared::wtypesbase::{COAUTHINFO, DOUBLE, LPOLESTR, OLECHAR};
12 use um::unknwnbase::{IUnknown, IUnknownVtbl};
13 use um::winnt::{HANDLE, HRESULT, LARGE_INTEGER, LONG, LPWSTR, ULARGE_INTEGER};
14 STRUCT!{struct COSERVERINFO {
15     dwReserved1: DWORD,
16     pwszName: LPWSTR,
17     pAuthInfo: *mut COAUTHINFO,
18     dwReserved2: DWORD,
19 }}
20 pub type LPMARSHAL = *mut IMarshal;
21 RIDL!{#[uuid(0x00000003, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
22 interface IMarshal(IMarshalVtbl): IUnknown(IUnknownVtbl) {
23     fn GetUnmarshalClass(
24         riid: REFIID,
25         pv: *mut c_void,
26         dwDestContext: DWORD,
27         pvDestContext: *mut c_void,
28         mshlflags: DWORD,
29         pCid: *mut CLSID,
30     ) -> HRESULT,
31     fn GetMarshalSizeMax(
32         riid: REFIID,
33         pv: *mut c_void,
34         dwDestContext: DWORD,
35         pvDestContext: *mut c_void,
36         mshlflags: DWORD,
37         pSize: *mut DWORD,
38     ) -> HRESULT,
39     fn MarshalInterface(
40         pStm: *mut IStream,
41         riid: REFIID,
42         pv: *mut c_void,
43         dwDestContext: DWORD,
44         pvDestContext: *mut c_void,
45         mshlflags: DWORD,
46     ) -> HRESULT,
47     fn UnmarshalInterface(
48         pStm: *mut IStream,
49         riid: REFIID,
50         ppv: *mut *mut c_void,
51     ) -> HRESULT,
52     fn ReleaseMarshalData(
53         pStm: *mut IStream,
54     ) -> HRESULT,
55     fn DisconnectObject(
56         dwReserved: DWORD,
57     ) -> HRESULT,
58 }}
59 RIDL!{#[uuid(0xecc8691b, 0xc1db, 0x4dc0, 0x85, 0x5e, 0x65, 0xf6, 0xc5, 0x51, 0xaf, 0x49)]
60 interface INoMarshal(INoMarshalVtbl): IUnknown(IUnknownVtbl) {
61 }}
62 RIDL!{#[uuid(0x94ea2b94, 0xe9cc, 0x49e0, 0xc0, 0xff, 0xee, 0x64, 0xca, 0x8f, 0x5b, 0x90)]
63 interface IAgileObject(IAgileObjectVtbl): IUnknown(IUnknownVtbl) {
64 }}
65 ENUM!{enum ACTIVATIONTYPE {
66     ACTIVATIONTYPE_UNCATEGORIZED = 0,
67     ACTIVATIONTYPE_FROM_MONIKER = 0x1,
68     ACTIVATIONTYPE_FROM_DATA = 0x2,
69     ACTIVATIONTYPE_FROM_STORAGE = 0x4,
70     ACTIVATIONTYPE_FROM_STREAM = 0x8,
71     ACTIVATIONTYPE_FROM_FILE = 0x10,
72 }}
73 RIDL!{#[uuid(0x00000017, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
74 interface IActivationFilter(IActivationFilterVtbl): IUnknown(IUnknownVtbl) {
75     fn HandleActivation(
76         dwActivationType: DWORD,
77         rclsid: REFCLSID,
78         pReplacementClsId: *mut CLSID,
79     ) -> HRESULT,
80 }}
81 pub type LPMARSHAL2 = *mut IMarshal2;
82 RIDL!{#[uuid(0x000001cf, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
83 interface IMarshal2(IMarshal2Vtbl): IMarshal(IMarshalVtbl) {
84 }}
85 pub type LPMALLOC = *mut IMalloc;
86 RIDL!{#[uuid(0x00000002, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
87 interface IMalloc(IMallocVtbl): IUnknown(IUnknownVtbl) {
88     fn Alloc(
89         cb: SIZE_T,
90     ) -> *mut c_void,
91     fn Realloc(
92         pv: *mut c_void,
93         cb: SIZE_T,
94     ) -> *mut c_void,
95     fn Free(
96         pv: *mut c_void,
97     ) -> (),
98     fn GetSize(
99         pv: *mut c_void,
100     ) -> SIZE_T,
101     fn DidAlloc(
102         pv: *mut c_void,
103     ) -> c_int,
104     fn HeapMinimize() -> (),
105 }}
106 pub type LPSTDMARSHALINFO = IStdMarshalInfo;
107 RIDL!{#[uuid(0x00000018, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
108 interface IStdMarshalInfo(IStdMarshalInfoVtbl): IUnknown(IUnknownVtbl) {
109     fn GetClassForHandler(
110         dwDestContext: DWORD,
111         pvDestContext: *mut c_void,
112         pClsid: *mut CLSID,
113     ) -> HRESULT,
114 }}
115 ENUM!{enum EXTCONN {
116     EXTCONN_STRONG = 0x1,
117     EXTCONN_WEAK = 0x2,
118     EXTCONN_CALLABLE = 0x4,
119 }}
120 RIDL!{#[uuid(0x00000019, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
121 interface IExternalConnection(IExternalConnectionVtbl): IUnknown(IUnknownVtbl) {
122     fn AddConnection(
123         extconn: DWORD,
124         reserved: DWORD,
125     ) -> DWORD,
126     fn ReleaseConnection(
127         extconn: DWORD,
128         reserved: DWORD,
129         fLastReleaseCloses: BOOL,
130     ) -> DWORD,
131 }}
132 pub type LPMULTIQI = *mut IMultiQI;
133 STRUCT!{struct MULTI_QI {
134     pIID: *const IID,
135     pItf: *mut IUnknown,
136     hr: HRESULT,
137 }}
138 RIDL!{#[uuid(0x00000020, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
139 interface IMultiQI(IMultiQIVtbl): IUnknown(IUnknownVtbl) {
140     fn QueryMultipleInterfaces(
141         cMQIs: ULONG,
142         pMQIs: *mut MULTI_QI,
143     ) -> HRESULT,
144 }}
145 RIDL!{#[uuid(0x000e0020, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
146 interface AsyncIMultiQI(AsyncIMultiQIVtbl): IUnknown(IUnknownVtbl) {
147     fn Begin_QueryMultipleInterfaces(
148         cMQIs: ULONG,
149         pMQIs: *mut MULTI_QI,
150     ) -> HRESULT,
151     fn Finish_QueryMultipleInterfaces(
152         pMQIs: *mut MULTI_QI,
153     ) -> HRESULT,
154 }}
155 RIDL!{#[uuid(0x00000021, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
156 interface IInternalUnknown(IInternalUnknownVtbl): IUnknown(IUnknownVtbl) {
157     fn QueryInternalInterface(
158         riid: REFIID,
159         ppv: *mut *mut c_void,
160     ) -> HRESULT,
161 }}
162 RIDL!{#[uuid(0x00000100, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
163 interface IEnumUnknown(IEnumUnknownVtbl): IUnknown(IUnknownVtbl) {
164     fn Next(
165         celt: ULONG,
166         rgelt: *mut *mut IUnknown,
167         pceltFetched: *mut ULONG,
168     ) -> HRESULT,
169     fn Skip(
170         celt: ULONG,
171     ) -> HRESULT,
172     fn Reset() -> HRESULT,
173     fn Clone(
174         ppenum: *mut *mut IEnumUnknown,
175     ) -> HRESULT,
176 }}
177 RIDL!{#[uuid(0x00000101, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
178 interface IEnumString(IEnumStringVtbl): IUnknown(IUnknownVtbl) {
179     fn Next(
180         celt: ULONG,
181         rgelt: *mut LPOLESTR,
182         pceltFetched: *mut ULONG,
183     ) -> HRESULT,
184     fn Skip(
185         celt: ULONG,
186     ) -> HRESULT,
187     fn Reset() -> HRESULT,
188     fn Clone(
189         ppenum: *mut *mut IEnumString,
190     ) -> HRESULT,
191 }}
192 RIDL!{#[uuid(0x0c733a30, 0x2a1c, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d)]
193 interface ISequentialStream(ISequentialStreamVtbl): IUnknown(IUnknownVtbl) {
194     fn Read(
195         pv: *mut c_void,
196         cb: ULONG,
197         pcbRead: *mut ULONG,
198     ) -> HRESULT,
199     fn Write(
200         pv: *const c_void,
201         cb: ULONG,
202         pcbWritten: *mut ULONG,
203     ) -> HRESULT,
204 }}
205 STRUCT!{struct STATSTG {
206     pwcsName: LPOLESTR,
207     type_: DWORD,
208     cbSize: ULARGE_INTEGER,
209     mtime: FILETIME,
210     ctime: FILETIME,
211     atime: FILETIME,
212     grfMode: DWORD,
213     grfLocksSupported: DWORD,
214     clsid: CLSID,
215     grfStateBits: DWORD,
216     reserved: DWORD,
217 }}
218 ENUM!{enum STGTY {
219     STGTY_STORAGE = 1,
220     STGTY_STREAM = 2,
221     STGTY_LOCKBYTES = 3,
222     STGTY_PROPERTY = 4,
223 }}
224 ENUM!{enum STREAM_SEEK {
225     STREAM_SEEK_SET = 0,
226     STREAM_SEEK_CUR = 1,
227     STREAM_SEEK_END = 2,
228 }}
229 ENUM!{enum LOCKTYPE {
230     LOCK_WRITE = 1,
231     LOCK_EXCLUSIVE = 2,
232     LOCK_ONLYONCE = 4,
233 }}
234 pub type LPSTREAM = *mut IStream;
235 RIDL!{#[uuid(0x0000000c, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
236 interface IStream(IStreamVtbl): ISequentialStream(ISequentialStreamVtbl) {
237     fn Seek(
238         dlibMove: LARGE_INTEGER,
239         dwOrigin: DWORD,
240         plibNewPosition: *mut ULARGE_INTEGER,
241     ) -> HRESULT,
242     fn SetSize(
243         libNewSize: ULARGE_INTEGER,
244     ) -> HRESULT,
245     fn CopyTo(
246         pstm: *mut IStream,
247         cb: ULARGE_INTEGER,
248         pcbRead: *mut ULARGE_INTEGER,
249         pcbWritten: *mut ULARGE_INTEGER,
250     ) -> HRESULT,
251     fn Commit(
252         grfCommitFlags: DWORD,
253     ) -> HRESULT,
254     fn Revert() -> HRESULT,
255     fn LockRegion(
256         libOffset: ULARGE_INTEGER,
257         cb: ULARGE_INTEGER,
258         dwLockType: DWORD,
259     ) -> HRESULT,
260     fn UnlockRegion(
261         libOffset: ULARGE_INTEGER,
262         cb: ULARGE_INTEGER,
263         dwLockType: DWORD,
264     ) -> HRESULT,
265     fn Stat(
266         pstatstg: *mut STATSTG,
267         grfStatFlag: DWORD,
268     ) -> HRESULT,
269     fn Clone(
270         ppstm: *mut *mut IStream,
271     ) -> HRESULT,
272 }}
273 pub type RPCOLEDATAREP = ULONG;
274 STRUCT!{struct RPCOLEMESSAGE {
275     reserved1: *mut c_void,
276     dataRepresentation: RPCOLEDATAREP,
277     Buffer: *mut c_void,
278     cbBuffer: ULONG,
279     iMethod: ULONG,
280     reserved2: [*mut c_void; 5],
281     rpcFlags: ULONG,
282 }}
283 pub type PRPCOLEMESSAGE = *mut RPCOLEMESSAGE;
284 RIDL!{#[uuid(0xd5f56b60, 0x593b, 0x101a, 0xb5, 0x69, 0x08, 0x00, 0x2b, 0x2d, 0xbf, 0x7a)]
285 interface IRpcChannelBuffer(IRpcChannelBufferVtbl): IUnknown(IUnknownVtbl) {
286     fn GetBuffer(
287         pMessage: *mut RPCOLEMESSAGE,
288         riid: REFIID,
289     ) -> HRESULT,
290     fn SendReceive(
291         pMessage: *mut RPCOLEMESSAGE,
292         pStatus: *mut ULONG,
293     ) -> HRESULT,
294     fn FreeBuffer(
295         pMessage: *mut RPCOLEMESSAGE,
296     ) -> HRESULT,
297     fn GetDestCtx(
298         pdwDestContext: *mut DWORD,
299         ppvDestContext: *mut *mut c_void,
300     ) -> HRESULT,
301     fn IsConnected() -> HRESULT,
302 }}
303 RIDL!{#[uuid(0x594f31d0, 0x7f19, 0x11d0, 0xb1, 0x94, 0x00, 0xa0, 0xc9, 0x0d, 0xc8, 0xbf)]
304 interface IRpcChannelBuffer2(IRpcChannelBuffer2Vtbl): IRpcChannelBuffer(IRpcChannelBufferVtbl) {
305     fn GetProtocolVersion(
306         pdwVersion: *mut DWORD,
307     ) -> HRESULT,
308 }}
309 RIDL!{#[uuid(0xa5029fb6, 0x3c34, 0x11d1, 0x9c, 0x99, 0x00, 0xc0, 0x4f, 0xb9, 0x98, 0xaa)]
310 interface IAsyncRpcChannelBuffer(IAsyncRpcChannelBufferVtbl):
311     IRpcChannelBuffer2(IRpcChannelBuffer2Vtbl) {
312     fn Send(
313         pMsg: *mut RPCOLEMESSAGE,
314         pSync: *mut ISynchronize,
315         pulStatus: *mut ULONG,
316     ) -> HRESULT,
317     fn Receive(
318         pMsg: *mut RPCOLEMESSAGE,
319         pulStatus: *mut ULONG,
320     ) -> HRESULT,
321     fn GetDestCtxEx(
322         pMsg: *mut RPCOLEMESSAGE,
323         pdwDestContext: *mut DWORD,
324         ppvDestContext: *mut *mut c_void,
325     ) -> HRESULT,
326 }}
327 RIDL!{#[uuid(0x25b15600, 0x0115, 0x11d0, 0xbf, 0x0d, 0x00, 0xaa, 0x00, 0xb8, 0xdf, 0xd2)]
328 interface IRpcChannelBuffer3(IRpcChannelBuffer3Vtbl): IRpcChannelBuffer2(IRpcChannelBuffer2Vtbl) {
329     fn Send(
330         pMsg: *mut RPCOLEMESSAGE,
331         pulStatus: *mut ULONG,
332     ) -> HRESULT,
333     fn Receive(
334         pMsg: *mut RPCOLEMESSAGE,
335         ulSize: ULONG,
336         pulStatus: *mut ULONG,
337     ) -> HRESULT,
338     fn Cancel(
339         pMsg: *mut RPCOLEMESSAGE,
340     ) -> HRESULT,
341     fn GetCallContext(
342         pMsg: *mut RPCOLEMESSAGE,
343         riid: REFIID,
344         pInterface: *mut *mut c_void,
345     ) -> HRESULT,
346     fn GetDestCtxEx(
347         pMsg: *mut RPCOLEMESSAGE,
348         pdwDestContext: *mut DWORD,
349         ppvDestContext: *mut *mut c_void,
350     ) -> HRESULT,
351     fn GetState(
352         pMsg: *mut RPCOLEMESSAGE,
353         pState: *mut DWORD,
354     ) -> HRESULT,
355     fn RegisterAsync(
356         pMsg: *mut RPCOLEMESSAGE,
357         pAsyncMgr: *mut IAsyncManager,
358     ) -> HRESULT,
359 }}
360 RIDL!{#[uuid(0x58a08519, 0x24c8, 0x4935, 0xb4, 0x82, 0x3f, 0xd8, 0x23, 0x33, 0x3a, 0x4f)]
361 interface IRpcSyntaxNegotiate(IRpcSyntaxNegotiateVtbl): IUnknown(IUnknownVtbl) {
362     fn NegotiateSyntax(
363         pMsg: *mut RPCOLEMESSAGE,
364     ) -> HRESULT,
365 }}
366 RIDL!{#[uuid(0xd5f56a34, 0x593b, 0x101a, 0xb5, 0x69, 0x08, 0x00, 0x2b, 0x2d, 0xbf, 0x7a)]
367 interface IRpcProxyBuffer(IRpcProxyBufferVtbl): IUnknown(IUnknownVtbl) {
368     fn Connect(
369         pRpcChannelBuffer: *mut IRpcChannelBuffer,
370     ) -> HRESULT,
371     fn Disconnect() -> (),
372 }}
373 RIDL!{#[uuid(0xd5f56afc, 0x593b, 0x101a, 0xb5, 0x69, 0x08, 0x00, 0x2b, 0x2d, 0xbf, 0x7a)]
374 interface IRpcStubBuffer(IRpcStubBufferVtbl): IUnknown(IUnknownVtbl) {
375     fn Connect(
376         pUnkServer: *mut IUnknown,
377     ) -> HRESULT,
378     fn Disconnect() -> (),
379     fn Invoke(
380         _prpcmsg: *mut RPCOLEMESSAGE,
381         _pRpcChannelBuffer: *mut IRpcChannelBuffer,
382     ) -> HRESULT,
383     fn IsIIDSupported(
384         riid: REFIID,
385     ) -> *mut IRpcStubBuffer,
386     fn CountRefs() -> ULONG,
387     fn DebugServerQueryInterface(
388         ppv: *mut *mut c_void,
389     ) -> HRESULT,
390     fn DebugServerRelease(
391         pv: *mut c_void,
392     ) -> (),
393 }}
394 RIDL!{#[uuid(0xd5f569d0, 0x593b, 0x101a, 0xb5, 0x69, 0x08, 0x00, 0x2b, 0x2d, 0xbf, 0x7a)]
395 interface IPSFactoryBuffer(IPSFactoryBufferVtbl): IUnknown(IUnknownVtbl) {
396     fn CreateProxy(
397         pUnkOuter: *mut IUnknown,
398         riid: REFIID,
399         ppProxy: *mut *mut IRpcProxyBuffer,
400         ppv: *mut *mut c_void,
401     ) -> HRESULT,
402     fn CreateStub(
403         riid: REFIID,
404         pUnkServer: *mut *mut IUnknown,
405         ppStub: *mut *mut IRpcStubBuffer,
406     ) -> HRESULT,
407 }}
408 STRUCT!{struct SChannelHookCallInfo {
409     iid: IID,
410     cbSize: DWORD,
411     uCausality: GUID,
412     dwServerPid: DWORD,
413     iMethod: DWORD,
414     pObject: *mut c_void,
415 }}
416 RIDL!{#[uuid(0x1008c4a0, 0x7613, 0x11cf, 0x9a, 0xf1, 0x00, 0x20, 0xaf, 0x6e, 0x72, 0xf4)]
417 interface IChannelHook(IChannelHookVtbl): IUnknown(IUnknownVtbl) {
418     fn ClientGetSize(
419         uExtent: REFGUID,
420         riid: REFIID,
421         pDataSize: *mut ULONG,
422     ) -> (),
423     fn ClientFillBuffer(
424         uExtent: REFGUID,
425         riid: REFIID,
426         pDataSize: *mut ULONG,
427         pDataBuffer: *mut c_void,
428     ) -> (),
429     fn ClientNotify(
430         uExtent: REFGUID,
431         riid: REFIID,
432         cbDataSize: ULONG,
433         pDataBuffer: *mut c_void,
434         lDataRep: DWORD,
435         hrFault: HRESULT,
436     ) -> (),
437     fn ServerNotify(
438         uExtent: REFGUID,
439         riid: REFIID,
440         cbDataSize: ULONG,
441         pDataBuffer: *mut c_void,
442         lDataRep: DWORD,
443     ) -> (),
444     fn ServerGetSize(
445         uExtent: REFGUID,
446         riid: REFIID,
447         hrFault: HRESULT,
448         pDataSize: *mut ULONG,
449     ) -> (),
450     fn ServerFillBuffer(
451         uExtent: REFGUID,
452         riid: REFIID,
453         pDataSize: *mut ULONG,
454         pDataBuffer: *mut c_void,
455         hrFault: HRESULT,
456     ) -> (),
457 }}
458 STRUCT!{struct SOLE_AUTHENTICATION_SERVICE {
459     dwAuthnSvc: DWORD,
460     dwAuthzSvc: DWORD,
461     pPrincipalName: *mut OLECHAR,
462     hr: HRESULT,
463 }}
464 pub type PSOLE_AUTHENTICATION_SERVICE = *mut SOLE_AUTHENTICATION_SERVICE;
465 ENUM!{enum EOLE_AUTHENTICATION_CAPABILITIES {
466     EOAC_NONE = 0,
467     EOAC_MUTUAL_AUTH = 0x1,
468     EOAC_STATIC_CLOAKING = 0x20,
469     EOAC_DYNAMIC_CLOAKING = 0x40,
470     EOAC_ANY_AUTHORITY = 0x80,
471     EOAC_MAKE_FULLSIC = 0x100,
472     EOAC_DEFAULT = 0x800,
473     EOAC_SECURE_REFS = 0x2,
474     EOAC_ACCESS_CONTROL = 0x4,
475     EOAC_APPID = 0x8,
476     EOAC_DYNAMIC = 0x10,
477     EOAC_REQUIRE_FULLSIC = 0x200,
478     EOAC_AUTO_IMPERSONATE = 0x400,
479     EOAC_DISABLE_AAA = 0x1000,
480     EOAC_NO_CUSTOM_MARSHAL = 0x2000,
481     EOAC_RESERVED1 = 0x4000,
482 }}
483 pub const COLE_DEFAULT_PRINCIPAL: *mut OLECHAR = -1isize as *mut OLECHAR;
484 pub const COLE_DEFAULT_AUTHINFO: *mut c_void = -1isize as *mut c_void;
485 STRUCT!{struct SOLE_AUTHENTICATION_INFO {
486     dwAuthnSvc: DWORD,
487     dwAuthzSvc: DWORD,
488     pAuthInfo: *mut c_void,
489 }}
490 pub type PSOLE_AUTHENTICATION_INFO = *mut SOLE_AUTHENTICATION_INFO;
491 STRUCT!{struct SOLE_AUTHENTICATION_LIST {
492     cAuthInfo: DWORD,
493     aAuthInfo: *mut SOLE_AUTHENTICATION_INFO,
494 }}
495 pub type PSOLE_AUTHENTICATION_LIST = *mut SOLE_AUTHENTICATION_LIST;
496 RIDL!{#[uuid(0x0000013d, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
497 interface IClientSecurity(IClientSecurityVtbl): IUnknown(IUnknownVtbl) {
498     fn QueryBlanket(
499         pProxy: *mut IUnknown,
500         pAuthnSvc: *mut DWORD,
501         pAuthzSvc: *mut DWORD,
502         pServerPrincName: *mut *mut OLECHAR,
503         pAuthnLevel: *mut DWORD,
504         pImpLevel: *mut DWORD,
505         pAuthInfo: *mut *mut c_void,
506         pCapabilities: *mut DWORD,
507     ) -> HRESULT,
508     fn SetBlanket(
509         pProxy: *mut IUnknown,
510         dwAuthnSvc: DWORD,
511         dwAuthzSvc: DWORD,
512         pServerPrincName: *mut OLECHAR,
513         dwAuthnLevel: DWORD,
514         dwImpLevel: DWORD,
515         pAuthInfo: *mut c_void,
516         dwCapabilities: DWORD,
517     ) -> HRESULT,
518     fn CopyProxy(
519         pProxy: *mut IUnknown,
520         ppCopy: *mut *mut IUnknown,
521     ) -> HRESULT,
522 }}
523 RIDL!{#[uuid(0x0000013e, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
524 interface IServerSecurity(IServerSecurityVtbl): IUnknown(IUnknownVtbl) {
525     fn QueryBlanket(
526         pAuthnSvc: *mut DWORD,
527         pAuthzSvc: *mut DWORD,
528         pServerPrincName: *mut *mut OLECHAR,
529         pAuthnLevel: *mut DWORD,
530         pImpLevel: *mut DWORD,
531         pPrivs: *mut *mut c_void,
532         pCapabilities: *mut DWORD,
533     ) -> HRESULT,
534     fn ImpersonateClient() -> HRESULT,
535     fn RevertToSelf() -> HRESULT,
536     fn IsImpersonating() -> BOOL,
537 }}
538 ENUM!{enum RPCOPT_PROPERTIES {
539     COMBND_RPCTIMEOUT = 0x1,
540     COMBND_SERVER_LOCALITY = 0x2,
541     COMBND_RESERVED1 = 0x4,
542     COMBND_RESERVED2 = 0x5,
543     COMBND_RESERVED3 = 0x8,
544     COMBND_RESERVED4 = 0x10,
545 }}
546 ENUM!{enum RPCOPT_SERVER_LOCALITY_VALUES {
547     SERVER_LOCALITY_PROCESS_LOCAL = 0,
548     SERVER_LOCALITY_MACHINE_LOCAL = 1,
549     SERVER_LOCALITY_REMOTE = 2,
550 }}
551 RIDL!{#[uuid(0x00000144, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
552 interface IRpcOptions(IRpcOptionsVtbl): IUnknown(IUnknownVtbl) {
553     fn Set(
554         pPrx: *mut IUnknown,
555         dwProperty: RPCOPT_PROPERTIES,
556         dwValue: ULONG_PTR,
557     ) -> HRESULT,
558     fn Query(
559         pPrx: *mut IUnknown,
560         dwProperty: RPCOPT_PROPERTIES,
561         pdwValue: *mut ULONG_PTR,
562     ) -> HRESULT,
563 }}
564 ENUM!{enum GLOBALOPT_PROPERTIES {
565     COMGLB_EXCEPTION_HANDLING = 1,
566     COMGLB_APPID = 2,
567     COMGLB_RPC_THREADPOOL_SETTING = 3,
568     COMGLB_RO_SETTINGS = 4,
569     COMGLB_UNMARSHALING_POLICY = 5,
570     COMGLB_PROPERTIES_RESERVED1 = 6,
571 }}
572 ENUM!{enum GLOBALOPT_EH_VALUES {
573     COMGLB_EXCEPTION_HANDLE = 0,
574     COMGLB_EXCEPTION_DONOT_HANDLE_FATAL = 1,
575     COMGLB_EXCEPTION_DONOT_HANDLE = COMGLB_EXCEPTION_DONOT_HANDLE_FATAL,
576     COMGLB_EXCEPTION_DONOT_HANDLE_ANY = 2,
577 }}
578 ENUM!{enum GLOBALOPT_RPCTP_VALUES {
579     COMGLB_RPC_THREADPOOL_SETTING_DEFAULT_POOL = 0,
580     COMGLB_RPC_THREADPOOL_SETTING_PRIVATE_POOL = 1,
581 }}
582 ENUM!{enum GLOBALOPT_RO_FLAGS {
583     COMGLB_STA_MODALLOOP_REMOVE_TOUCH_MESSAGES = 0x1,
584     COMGLB_STA_MODALLOOP_SHARED_QUEUE_REMOVE_INPUT_MESSAGES = 0x2,
585     COMGLB_STA_MODALLOOP_SHARED_QUEUE_DONOT_REMOVE_INPUT_MESSAGES = 0x4,
586     COMGLB_FAST_RUNDOWN = 0x8,
587     COMGLB_RESERVED1 = 0x10,
588     COMGLB_RESERVED2 = 0x20,
589     COMGLB_RESERVED3 = 0x40,
590     COMGLB_STA_MODALLOOP_SHARED_QUEUE_REORDER_POINTER_MESSAGES = 0x80,
591     COMGLB_RESERVED4 = 0x100,
592     COMGLB_RESERVED5 = 0x200,
593     COMGLB_RESERVED6 = 0x400,
594 }}
595 ENUM!{enum GLOBALOPT_UNMARSHALING_POLICY_VALUES {
596     COMGLB_UNMARSHALING_POLICY_NORMAL = 0,
597     COMGLB_UNMARSHALING_POLICY_STRONG = 1,
598     COMGLB_UNMARSHALING_POLICY_HYBRID = 2,
599 }}
600 RIDL!{#[uuid(0x0000015b, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
601 interface IGlobalOptions(IGlobalOptionsVtbl): IUnknown(IUnknownVtbl) {
602     fn Set(
603         dwProperty: GLOBALOPT_PROPERTIES,
604         dwValue: ULONG_PTR,
605     ) -> HRESULT,
606     fn Query(
607         dwProperty: GLOBALOPT_PROPERTIES,
608         pdwValue: *mut ULONG_PTR,
609     ) -> HRESULT,
610 }}
611 pub type LPSURROGATE = *mut ISurrogate;
612 RIDL!{#[uuid(0x00000022, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
613 interface ISurrogate(ISurrogateVtbl): IUnknown(IUnknownVtbl) {
614     fn LoadDllServer(
615         Clsid: REFCLSID,
616     ) -> HRESULT,
617     fn FreeSurrogate() -> HRESULT,
618 }}
619 pub type LPGLOBALINTERFACETABLE = *mut IGlobalInterfaceTable;
620 RIDL!{#[uuid(0x00000146, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
621 interface IGlobalInterfaceTable(IGlobalInterfaceTableVtbl): IUnknown(IUnknownVtbl) {
622     fn RegisterInterfaceInGlobal(
623         pUnk: *mut IUnknown,
624         riid: REFIID,
625         pdwCookie: *mut DWORD,
626     ) -> HRESULT,
627     fn RevokeInterfaceFromGlobal(
628         dwCookie: DWORD,
629     ) -> HRESULT,
630     fn GetInterfaceFromGlobal(
631         dwCookie: DWORD,
632         riid: REFIID,
633         ppv: *mut *mut c_void,
634     ) -> HRESULT,
635 }}
636 RIDL!{#[uuid(0x00000030, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
637 interface ISynchronize(ISynchronizeVtbl): IUnknown(IUnknownVtbl) {
638     fn Wait(
639         dwFlags: DWORD,
640         dwMilliseconds: DWORD,
641     ) -> HRESULT,
642     fn Signal() -> HRESULT,
643     fn Reset() -> HRESULT,
644 }}
645 RIDL!{#[uuid(0x00000031, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
646 interface ISynchronizeHandle(ISynchronizeHandleVtbl): IUnknown(IUnknownVtbl) {
647     fn GetHandle(
648         ph: *mut HANDLE,
649     ) -> HRESULT,
650 }}
651 RIDL!{#[uuid(0x00000032, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
652 interface ISynchronizeEvent(ISynchronizeEventVtbl): ISynchronizeHandle(ISynchronizeHandleVtbl) {
653     fn SetEventHandle(
654         ph: *mut HANDLE,
655     ) -> HRESULT,
656 }}
657 RIDL!{#[uuid(0x00000033, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
658 interface ISynchronizeContainer(ISynchronizeContainerVtbl): IUnknown(IUnknownVtbl) {
659     fn AddSynchronize(
660         pSync: *mut ISynchronize,
661     ) -> HRESULT,
662     fn WaitMultiple(
663         dwFlags: DWORD,
664         dwTimeOut: DWORD,
665         ppSync: *mut *mut ISynchronize,
666     ) -> HRESULT,
667 }}
668 RIDL!{#[uuid(0x00000025, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
669 interface ISynchronizeMutex(ISynchronizeMutexVtbl): ISynchronize(ISynchronizeVtbl) {
670     fn ReleaseMutex() -> HRESULT,
671 }}
672 pub type LPCANCELMETHODCALLS = *mut ICancelMethodCalls;
673 RIDL!{#[uuid(0x00000029, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
674 interface ICancelMethodCalls(ICancelMethodCallsVtbl): IUnknown(IUnknownVtbl) {
675     fn Cancel(
676         ulSeconds: ULONG,
677     ) -> HRESULT,
678     fn TestCancel() -> HRESULT,
679 }}
680 ENUM!{enum DCOM_CALL_STATE {
681     DCOM_NONE = 0,
682     DCOM_CALL_COMPLETE = 0x1,
683     DCOM_CALL_CANCELED = 0x2,
684 }}
685 RIDL!{#[uuid(0x0000002a, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
686 interface IAsyncManager(IAsyncManagerVtbl): IUnknown(IUnknownVtbl) {
687     fn CompleteCall(
688         Result: HRESULT,
689     ) -> HRESULT,
690     fn GetCallContext(
691         riid: REFIID,
692         pInterface: *mut *mut c_void,
693     ) -> HRESULT,
694     fn GetState(
695         pulStateFlags: *mut ULONG,
696     ) -> HRESULT,
697 }}
698 RIDL!{#[uuid(0x1c733a30, 0x2a1c, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d)]
699 interface ICallFactory(ICallFactoryVtbl): IUnknown(IUnknownVtbl) {
700     fn CreateCall(
701         riid: REFIID,
702         pCtrlUnk: *mut IUnknown,
703         riid2: REFIID,
704         ppv: *mut *mut IUnknown,
705     ) -> HRESULT,
706 }}
707 RIDL!{#[uuid(0x00000149, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
708 interface IRpcHelper(IRpcHelperVtbl): IUnknown(IUnknownVtbl) {
709     fn GetDCOMProtocolVersion(
710         pComVersion: *mut DWORD,
711     ) -> HRESULT,
712     fn GetIIDFromOBJREF(
713         pObjRef: *mut c_void,
714         piid: *mut *mut IID,
715     ) -> HRESULT,
716 }}
717 RIDL!{#[uuid(0xeb0cb9e8, 0x7996, 0x11d2, 0x87, 0x2e, 0x00, 0x00, 0xf8, 0x08, 0x08, 0x59)]
718 interface IReleaseMarshalBuffers(IReleaseMarshalBuffersVtbl): IUnknown(IUnknownVtbl) {
719     fn ReleaseMarshalBuffer(
720         pMsg: *mut RPCOLEMESSAGE,
721         dwFlags: DWORD,
722         pChnl: *mut IUnknown,
723     ) -> HRESULT,
724 }}
725 RIDL!{#[uuid(0x0000002b, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
726 interface IWaitMultiple(IWaitMultipleVtbl): IUnknown(IUnknownVtbl) {
727     fn WaitMultiple(
728         timeout: DWORD,
729         pSync: *mut *mut ISynchronize,
730     ) -> HRESULT,
731     fn AddSynchronize(
732         pSync: *mut ISynchronize,
733     ) -> HRESULT,
734 }}
735 pub type LPADDRTRACKINGCONTROL = *mut IAddrTrackingControl;
736 RIDL!{#[uuid(0x00000147, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
737 interface IAddrTrackingControl(IAddrTrackingControlVtbl): IUnknown(IUnknownVtbl) {
738     fn EnableCOMDynamicAddrTracking() -> HRESULT,
739     fn DisableCOMDynamicAddrTracking() -> HRESULT,
740 }}
741 pub type LPADDREXCLUSIONCONTROL = *mut IAddrExclusionControl;
742 RIDL!{#[uuid(0x00000148, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
743 interface IAddrExclusionControl(IAddrExclusionControlVtbl): IUnknown(IUnknownVtbl) {
744     fn GetCurrentAddrExclusionList(
745         riid: REFIID,
746         ppEnumerator: *mut *mut c_void,
747     ) -> HRESULT,
748     fn UpdateAddrExclusionList(
749         pEnumerator: *mut IUnknown,
750     ) -> HRESULT,
751 }}
752 RIDL!{#[uuid(0xdb2f3aca, 0x2f86, 0x11d1, 0x8e, 0x04, 0x00, 0xc0, 0x4f, 0xb9, 0x98, 0x9a)]
753 interface IPipeByte(IPipeByteVtbl): IUnknown(IUnknownVtbl) {
754     fn Pull(
755         buf: *mut BYTE,
756         cRequest: ULONG,
757         pcReturned: *mut ULONG,
758     ) -> HRESULT,
759     fn Push(
760         buf: *mut BYTE,
761         cSent: ULONG,
762     ) -> HRESULT,
763 }}
764 RIDL!{#[uuid(0xdb2f3acb, 0x2f86, 0x11d1, 0x8e, 0x04, 0x00, 0xc0, 0x4f, 0xb9, 0x98, 0x9a)]
765 interface AsyncIPipeByte(AsyncIPipeByteVtbl): IUnknown(IUnknownVtbl) {
766     fn Begin_Pull(
767         cRequest: ULONG,
768     ) -> HRESULT,
769     fn Finish_Pull(
770         buf: *mut BYTE,
771         pcReturned: *mut ULONG,
772     ) -> HRESULT,
773     fn Begin_Push(
774         buf: *mut BYTE,
775         cSent: ULONG,
776     ) -> HRESULT,
777     fn Finish_Push() -> HRESULT,
778 }}
779 RIDL!{#[uuid(0xdb2f3acc, 0x2f86, 0x11d1, 0x8e, 0x04, 0x00, 0xc0, 0x4f, 0xb9, 0x98, 0x9a)]
780 interface IPipeLong(IPipeLongVtbl): IUnknown(IUnknownVtbl) {
781     fn Pull(
782         buf: *mut LONG,
783         cRequest: ULONG,
784         pcReturned: *mut ULONG,
785     ) -> HRESULT,
786     fn Push(
787         buf: *mut LONG,
788         cSent: ULONG,
789     ) -> HRESULT,
790 }}
791 RIDL!{#[uuid(0xdb2f3acd, 0x2f86, 0x11d1, 0x8e, 0x04, 0x00, 0xc0, 0x4f, 0xb9, 0x98, 0x9a)]
792 interface AsyncIPipeLong(AsyncIPipeLongVtbl): IUnknown(IUnknownVtbl) {
793     fn Begin_Pull(
794         cRequest: ULONG,
795     ) -> HRESULT,
796     fn Finish_Pull(
797         buf: *mut LONG,
798         pcReturned: *mut ULONG,
799     ) -> HRESULT,
800     fn Begin_Push(
801         buf: *mut LONG,
802         cSent: ULONG,
803     ) -> HRESULT,
804     fn Finish_Push() -> HRESULT,
805 }}
806 RIDL!{#[uuid(0xdb2f3ace, 0x2f86, 0x11d1, 0x8e, 0x04, 0x00, 0xc0, 0x4f, 0xb9, 0x98, 0x9a)]
807 interface IPipeDouble(IPipeDoubleVtbl): IUnknown(IUnknownVtbl) {
808     fn Pull(
809         buf: *mut DOUBLE,
810         cRequest: ULONG,
811         pcReturned: *mut ULONG,
812     ) -> HRESULT,
813     fn Push(
814         buf: *mut DOUBLE,
815         cSent: ULONG,
816     ) -> HRESULT,
817 }}
818 RIDL!{#[uuid(0xdb2f3acf, 0x2f86, 0x11d1, 0x8e, 0x04, 0x00, 0xc0, 0x4f, 0xb9, 0x98, 0x9a)]
819 interface AsyncIPipeDouble(AsyncIPipeDoubleVtbl): IUnknown(IUnknownVtbl) {
820     fn Begin_Pull(
821         cRequest: ULONG,
822     ) -> HRESULT,
823     fn Finish_Pull(
824         buf: *mut DOUBLE,
825         pcReturned: *mut ULONG,
826     ) -> HRESULT,
827     fn Begin_Push(
828         buf: *mut DOUBLE,
829         cSent: ULONG,
830     ) -> HRESULT,
831     fn Finish_Push() -> HRESULT,
832 }}
833 pub type CPFLAGS = DWORD;
834 STRUCT!{struct ContextProperty {
835     policyId: GUID,
836     flags: CPFLAGS,
837     pUnk: *mut IUnknown,
838 }}
839 pub type LPENUMCONTEXTPROPS = *mut IEnumContextProps;
840 RIDL!{#[uuid(0x000001c1, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
841 interface IEnumContextProps(IEnumContextPropsVtbl): IUnknown(IUnknownVtbl) {
842     fn Next(
843         celt: ULONG,
844         pContextProperties: *mut ContextProperty,
845         pceltFetched: *mut ULONG,
846     ) -> HRESULT,
847     fn Skip(
848         celt: ULONG,
849     ) -> HRESULT,
850     fn Reset() -> HRESULT,
851     fn Clone(
852         ppEnumContextProps: *mut *mut IEnumContextProps,
853     ) -> HRESULT,
854     fn Count(
855         pcelt: *mut ULONG,
856     ) -> HRESULT,
857 }}
858 RIDL!{#[uuid(0x000001c0, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
859 interface IContext(IContextVtbl): IUnknown(IUnknownVtbl) {
860     fn SetProperty(
861         rpolicyId: REFGUID,
862         flags: CPFLAGS,
863         pUnk: *mut IUnknown,
864     ) -> HRESULT,
865     fn RemoveProperty(
866         rPolicyId: REFGUID,
867     ) -> HRESULT,
868     fn GetProperty(
869         policyId: REFGUID,
870         pFlags: *mut CPFLAGS,
871         ppUnk: *mut *mut IUnknown,
872     ) -> HRESULT,
873     fn EnumContextProps(
874         ppEnumContextProps: *mut *mut IEnumContextProps,
875     ) -> HRESULT,
876 }}
877 RIDL!{#[uuid(0x000001c6, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
878 interface IObjContext(IObjContextVtbl): IContext(IContextVtbl) {
879     fn Reserved1() -> (),
880     fn Reserved2() -> (),
881     fn Reserved3() -> (),
882     fn Reserved4() -> (),
883     fn Reserved5() -> (),
884     fn Reserved6() -> (),
885     fn Reserved7() -> (),
886 }}
887 ENUM!{enum APTTYPEQUALIFIER {
888     APTTYPEQUALIFIER_NONE = 0,
889     APTTYPEQUALIFIER_IMPLICIT_MTA = 1,
890     APTTYPEQUALIFIER_NA_ON_MTA = 2,
891     APTTYPEQUALIFIER_NA_ON_STA = 3,
892     APTTYPEQUALIFIER_NA_ON_IMPLICIT_MTA = 4,
893     APTTYPEQUALIFIER_NA_ON_MAINSTA = 5,
894     APTTYPEQUALIFIER_APPLICATION_STA= 6,
895 }}
896 ENUM!{enum APTTYPE {
897     APTTYPE_CURRENT = -1i32 as u32,
898     APTTYPE_STA = 0,
899     APTTYPE_MTA = 1,
900     APTTYPE_NA = 2,
901     APTTYPE_MAINSTA = 3,
902 }}
903 ENUM!{enum THDTYPE {
904     THDTYPE_BLOCKMESSAGES = 0,
905     THDTYPE_PROCESSMESSAGES = 1,
906 }}
907 pub type APARTMENTID = DWORD;
908 RIDL!{#[uuid(0x000001ce, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
909 interface IComThreadingInfo(IComThreadingInfoVtbl): IUnknown(IUnknownVtbl) {
910     fn GetCurrentApartmentType(
911         pAptType: *mut APTTYPE,
912     ) -> HRESULT,
913     fn GetCurrentThreadType(
914         pThreadType: *mut THDTYPE,
915     ) -> HRESULT,
916     fn GetCurrentLogicalThreadId(
917         pguidLogicalThreadId: *mut GUID,
918     ) -> HRESULT,
919     fn SetCurrentLogicalThreadId(
920         rguid: REFGUID,
921     ) -> HRESULT,
922 }}
923 RIDL!{#[uuid(0x72380d55, 0x8d2b, 0x43a3, 0x85, 0x13, 0x2b, 0x6e, 0xf3, 0x14, 0x34, 0xe9)]
924 interface IProcessInitControl(IProcessInitControlVtbl): IUnknown(IUnknownVtbl) {
925     fn ResetInitializerTimeout(
926         dwSecondsRemaining: DWORD,
927     ) -> HRESULT,
928 }}
929 RIDL!{#[uuid(0x00000040, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
930 interface IFastRundown(IFastRundownVtbl): IUnknown(IUnknownVtbl) {
931 }}
932 ENUM!{enum CO_MARSHALING_CONTEXT_ATTRIBUTES {
933     CO_MARSHALING_SOURCE_IS_APP_CONTAINER = 0,
934     CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_1 = 0x80000000,
935     CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_2 = 0x80000001,
936     CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_3 = 0x80000002,
937     CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_4 = 0x80000003,
938     CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_5 = 0x80000004,
939     CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_6 = 0x80000005,
940     CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_7 = 0x80000006,
941     CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_8 = 0x80000007,
942     CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_9 = 0x80000008,
943 }}
944 RIDL!{#[uuid(0xd8f2f5e6, 0x6102, 0x4863, 0x9f, 0x26, 0x38, 0x9a, 0x46, 0x76, 0xef, 0xde)]
945 interface IMarshalingStream(IMarshalingStreamVtbl): IStream(IStreamVtbl) {
946     fn GetMarshalingContextAttribute(
947         attribute: CO_MARSHALING_CONTEXT_ATTRIBUTES,
948         pAttributeValue: *mut ULONG_PTR,
949     ) -> HRESULT,
950 }}
951 RIDL!{#[uuid(0xc03f6a43, 0x65a4, 0x9818, 0x98, 0x7e, 0xe0, 0xb8, 0x10, 0xd2, 0xa6, 0xf2)]
952 interface IAgileReference(IAgileReferenceVtbl): IUnknown(IUnknownVtbl) {
953     fn Resolve(
954         riid: REFIID,
955         ppvObjectReference: *mut *mut c_void,
956     ) -> HRESULT,
957 }}
958