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