ReactOS 0.4.15-dev-8135-g1bc6c90
ndr_ole.c
Go to the documentation of this file.
1/*
2 * OLE32 callouts, COM interface marshalling
3 *
4 * Copyright 2001 Ove Kåven, TransGaming Technologies
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 *
20 * TODO:
21 * - fix the wire-protocol to match MS/RPC
22 */
23
24#include <stdarg.h>
25#include <stdio.h>
26#include <string.h>
27
28#define COBJMACROS
29#define NONAMELESSUNION
30
31#include "windef.h"
32#include "winbase.h"
33#include "winerror.h"
34
35#include "objbase.h"
36
37#include "ndr_misc.h"
38#include "rpcndr.h"
39#include "ndrtypes.h"
40#include "rpcproxy.h"
41#include "cpsf.h"
42
43#include "wine/debug.h"
44
46
48
49static HRESULT (WINAPI *COM_GetMarshalSizeMax)(ULONG *,REFIID,LPUNKNOWN,DWORD,LPVOID,DWORD);
50static HRESULT (WINAPI *COM_MarshalInterface)(LPSTREAM,REFIID,LPUNKNOWN,DWORD,LPVOID,DWORD);
51static HRESULT (WINAPI *COM_UnmarshalInterface)(LPSTREAM,REFIID,LPVOID*);
52static HRESULT (WINAPI *COM_ReleaseMarshalData)(LPSTREAM);
53static HRESULT (WINAPI *COM_GetClassObject)(REFCLSID,DWORD,COSERVERINFO *,REFIID,LPVOID *);
54static HRESULT (WINAPI *COM_GetPSClsid)(REFIID,CLSID *);
55static LPVOID (WINAPI *COM_MemAlloc)(ULONG);
56static void (WINAPI *COM_MemFree)(LPVOID);
57
58static HMODULE LoadCOM(void)
59{
60 if (hOLE) return hOLE;
61 hOLE = LoadLibraryA("OLE32.DLL");
62 if (!hOLE) return 0;
63 COM_GetMarshalSizeMax = (LPVOID)GetProcAddress(hOLE, "CoGetMarshalSizeMax");
64 COM_MarshalInterface = (LPVOID)GetProcAddress(hOLE, "CoMarshalInterface");
65 COM_UnmarshalInterface = (LPVOID)GetProcAddress(hOLE, "CoUnmarshalInterface");
66 COM_ReleaseMarshalData = (LPVOID)GetProcAddress(hOLE, "CoReleaseMarshalData");
67 COM_GetClassObject = (LPVOID)GetProcAddress(hOLE, "CoGetClassObject");
68 COM_GetPSClsid = (LPVOID)GetProcAddress(hOLE, "CoGetPSClsid");
69 COM_MemAlloc = (LPVOID)GetProcAddress(hOLE, "CoTaskMemAlloc");
70 COM_MemFree = (LPVOID)GetProcAddress(hOLE, "CoTaskMemFree");
71 return hOLE;
72}
73
74/* CoMarshalInterface/CoUnmarshalInterface works on streams,
75 * so implement a simple stream on top of the RPC buffer
76 * (which also implements the MInterfacePointer structure) */
77typedef struct RpcStreamImpl
78{
83 unsigned char *data;
86
88{
89 return CONTAINING_RECORD(iface, RpcStreamImpl, IStream_iface);
90}
91
94 LPVOID *obj)
95{
97 IsEqualGUID(&IID_ISequentialStream, riid) ||
98 IsEqualGUID(&IID_IStream, riid)) {
99 *obj = iface;
100 IStream_AddRef(iface);
101 return S_OK;
102 }
103
104 *obj = NULL;
105 return E_NOINTERFACE;
106}
107
109{
111 return InterlockedIncrement( &This->RefCount );
112}
113
115{
117 ULONG ref = InterlockedDecrement( &This->RefCount );
118 if (!ref) {
119 TRACE("size=%d\n", *This->size);
120 This->pMsg->Buffer = This->data + *This->size;
122 }
123 return ref;
124}
125
127 void *pv,
128 ULONG cb,
129 ULONG *pcbRead)
130{
132 HRESULT hr = S_OK;
133 if (This->pos + cb > *This->size)
134 {
135 cb = *This->size - This->pos;
136 hr = S_FALSE;
137 }
138 if (cb) {
139 memcpy(pv, This->data + This->pos, cb);
140 This->pos += cb;
141 }
142 if (pcbRead) *pcbRead = cb;
143 return hr;
144}
145
147 const void *pv,
148 ULONG cb,
149 ULONG *pcbWritten)
150{
152 if (This->data + cb > (unsigned char *)This->pMsg->RpcMsg->Buffer + This->pMsg->BufferLength)
153 return STG_E_MEDIUMFULL;
154 memcpy(This->data + This->pos, pv, cb);
155 This->pos += cb;
156 if (This->pos > *This->size) *This->size = This->pos;
157 if (pcbWritten) *pcbWritten = cb;
158 return S_OK;
159}
160
162 LARGE_INTEGER move,
164 ULARGE_INTEGER *newPos)
165{
167 switch (origin) {
168 case STREAM_SEEK_SET:
169 This->pos = move.u.LowPart;
170 break;
171 case STREAM_SEEK_CUR:
172 This->pos = This->pos + move.u.LowPart;
173 break;
174 case STREAM_SEEK_END:
175 This->pos = *This->size + move.u.LowPart;
176 break;
177 default:
179 }
180 if (newPos) {
181 newPos->u.LowPart = This->pos;
182 newPos->u.HighPart = 0;
183 }
184 return S_OK;
185}
186
188 ULARGE_INTEGER newSize)
189{
191 *This->size = newSize.u.LowPart;
192 return S_OK;
193}
194
197{
199 FIXME("(%p): stub\n", This);
200 return E_NOTIMPL;
201}
202
204{
206 FIXME("(%p)->(0x%08x): stub\n", This, flags);
207 return E_NOTIMPL;
208}
209
211{
213 FIXME("(%p): stub\n", This);
214 return E_NOTIMPL;
215}
216
219{
221 FIXME("(%p): stub\n", This);
222 return E_NOTIMPL;
223}
224
227{
229 FIXME("(%p): stub\n", This);
230 return E_NOTIMPL;
231}
232
234{
236 FIXME("(%p): stub\n", This);
237 return E_NOTIMPL;
238}
239
241{
243 FIXME("(%p): stub\n", This);
244 return E_NOTIMPL;
245}
246
247static const IStreamVtbl RpcStream_Vtbl =
248{
263};
264
266{
268
269 *stream = NULL;
271 if (!This) return E_OUTOFMEMORY;
272 This->IStream_iface.lpVtbl = &RpcStream_Vtbl;
273 This->RefCount = 1;
274 This->pMsg = pStubMsg;
275 This->size = (LPDWORD)pStubMsg->Buffer;
276 This->data = pStubMsg->Buffer + sizeof(DWORD);
277 This->pos = 0;
278 if (init) *This->size = 0;
279 TRACE("init size=%d\n", *This->size);
280
281 if (size) *size = *This->size;
282 *stream = &This->IStream_iface;
283 return S_OK;
284}
285
286static const IID* get_ip_iid(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
287{
288 const IID *riid;
289 if (!pFormat) return &IID_IUnknown;
290 TRACE("format=%02x %02x\n", pFormat[0], pFormat[1]);
291 if (pFormat[0] != FC_IP) FIXME("format=%d\n", pFormat[0]);
292 if (pFormat[1] == FC_CONSTANT_IID) {
293 riid = (const IID *)&pFormat[2];
294 } else {
295 ComputeConformance(pStubMsg, pMemory, pFormat+2, 0);
296 riid = (const IID *)pStubMsg->MaxCount;
297 }
298 if (!riid) riid = &IID_IUnknown;
299 TRACE("got %s\n", debugstr_guid(riid));
300 return riid;
301}
302
303/***********************************************************************
304 * NdrInterfacePointerMarshall [RPCRT4.@]
305 */
307 unsigned char *pMemory,
308 PFORMAT_STRING pFormat)
309{
310 const IID *riid = get_ip_iid(pStubMsg, pMemory, pFormat);
312 HRESULT hr;
313
314 TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
315 pStubMsg->MaxCount = 0;
316 if (!LoadCOM()) return NULL;
317 if (pStubMsg->Buffer + sizeof(DWORD) <= (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength) {
318 hr = RpcStream_Create(pStubMsg, TRUE, NULL, &stream);
319 if (hr == S_OK) {
320 if (pMemory)
321 hr = COM_MarshalInterface(stream, riid, (LPUNKNOWN)pMemory,
322 pStubMsg->dwDestContext, pStubMsg->pvDestContext,
323 MSHLFLAGS_NORMAL);
324 IStream_Release(stream);
325 }
326
327 if (FAILED(hr))
329 }
330 return NULL;
331}
332
333/***********************************************************************
334 * NdrInterfacePointerUnmarshall [RPCRT4.@]
335 */
337 unsigned char **ppMemory,
338 PFORMAT_STRING pFormat,
339 unsigned char fMustAlloc)
340{
341 IUnknown **unk = (IUnknown **)ppMemory;
343 HRESULT hr;
344
345 TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
346 if (!LoadCOM()) return NULL;
347
348 /* Avoid reference leaks for [in, out] pointers. */
349 if (pStubMsg->IsClient && *unk)
350 IUnknown_Release(*unk);
351
352 *unk = NULL;
353 if (pStubMsg->Buffer + sizeof(DWORD) < (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength) {
354 ULONG size;
355
356 hr = RpcStream_Create(pStubMsg, FALSE, &size, &stream);
357 if (hr == S_OK) {
358 if (size != 0)
359 hr = COM_UnmarshalInterface(stream, &IID_NULL, (void **)unk);
360
361 IStream_Release(stream);
362 }
363
364 if (FAILED(hr))
366 }
367 return NULL;
368}
369
370/***********************************************************************
371 * NdrInterfacePointerBufferSize [RPCRT4.@]
372 */
374 unsigned char *pMemory,
375 PFORMAT_STRING pFormat)
376{
377 const IID *riid = get_ip_iid(pStubMsg, pMemory, pFormat);
378 ULONG size = 0;
379
380 TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
381 if (!LoadCOM()) return;
382 COM_GetMarshalSizeMax(&size, riid, (LPUNKNOWN)pMemory,
383 pStubMsg->dwDestContext, pStubMsg->pvDestContext,
384 MSHLFLAGS_NORMAL);
385 TRACE("size=%d\n", size);
386 pStubMsg->BufferLength += sizeof(DWORD) + size;
387}
388
389/***********************************************************************
390 * NdrInterfacePointerMemorySize [RPCRT4.@]
391 */
393 PFORMAT_STRING pFormat)
394{
395 ULONG size;
396
397 TRACE("(%p,%p)\n", pStubMsg, pFormat);
398
399 size = *(ULONG *)pStubMsg->Buffer;
400 pStubMsg->Buffer += 4;
401 pStubMsg->MemorySize += 4;
402
403 pStubMsg->Buffer += size;
404
405 return pStubMsg->MemorySize;
406}
407
408/***********************************************************************
409 * NdrInterfacePointerFree [RPCRT4.@]
410 */
412 unsigned char *pMemory,
413 PFORMAT_STRING pFormat)
414{
416 TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
417 if (pUnk) IUnknown_Release(pUnk);
418}
419
420/***********************************************************************
421 * NdrOleAllocate [RPCRT4.@]
422 */
424{
425 if (!LoadCOM()) return NULL;
426 return COM_MemAlloc(Size);
427}
428
429/***********************************************************************
430 * NdrOleFree [RPCRT4.@]
431 */
432void WINAPI NdrOleFree(void *NodeToFree)
433{
434 if (!LoadCOM()) return;
435 COM_MemFree(NodeToFree);
436}
437
438/***********************************************************************
439 * Helper function to create a proxy.
440 * Probably similar to NdrpCreateProxy.
441 */
442HRESULT create_proxy(REFIID iid, IUnknown *pUnkOuter, IRpcProxyBuffer **pproxy, void **ppv)
443{
444 CLSID clsid;
445 IPSFactoryBuffer *psfac;
446 HRESULT r;
447
448 if(!LoadCOM()) return E_FAIL;
449
450 r = COM_GetPSClsid( iid, &clsid );
451 if(FAILED(r)) return r;
452
453 r = COM_GetClassObject( &clsid, CLSCTX_INPROC_SERVER, NULL, &IID_IPSFactoryBuffer, (void**)&psfac );
454 if(FAILED(r)) return r;
455
456 r = IPSFactoryBuffer_CreateProxy(psfac, pUnkOuter, iid, pproxy, ppv);
457
458 IPSFactoryBuffer_Release(psfac);
459 return r;
460}
461
462/***********************************************************************
463 * Helper function to create a stub.
464 * This probably looks very much like NdrpCreateStub.
465 */
467{
468 CLSID clsid;
469 IPSFactoryBuffer *psfac;
470 HRESULT r;
471
472 if(!LoadCOM()) return E_FAIL;
473
474 r = COM_GetPSClsid( iid, &clsid );
475 if(FAILED(r)) return r;
476
477 r = COM_GetClassObject( &clsid, CLSCTX_INPROC_SERVER, NULL, &IID_IPSFactoryBuffer, (void**)&psfac );
478 if(FAILED(r)) return r;
479
480 r = IPSFactoryBuffer_CreateStub(psfac, iid, pUnk, ppstub);
481
482 IPSFactoryBuffer_Release(psfac);
483 return r;
484}
#define read
Definition: acwin.h:96
#define InterlockedIncrement
Definition: armddk.h:53
#define InterlockedDecrement
Definition: armddk.h:52
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
const GUID IID_IUnknown
#define FIXME(fmt,...)
Definition: debug.h:114
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
#define E_NOTIMPL
Definition: ddrawi.h:99
#define E_FAIL
Definition: ddrawi.h:102
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define GetProcessHeap()
Definition: compat.h:736
#define GetProcAddress(x, y)
Definition: compat.h:753
#define HeapAlloc
Definition: compat.h:733
#define HeapFree(x, y, z)
Definition: compat.h:735
HINSTANCE WINAPI DECLSPEC_HOTPATCH LoadLibraryA(LPCSTR lpLibFileName)
Definition: loader.c:111
static void *static void *static LPDIRECTPLAY IUnknown * pUnk
Definition: dplayx.c:30
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
FxMemoryObject * pMemory
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
GLsizeiptr size
Definition: glext.h:5919
GLbitfield flags
Definition: glext.h:7161
GLenum GLsizei len
Definition: glext.h:6722
GLintptr offset
Definition: glext.h:5920
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean flag
Definition: glfuncs.h:52
REFIID riid
Definition: atlbase.h:39
REFIID LPVOID * ppv
Definition: atlbase.h:39
#define S_OK
Definition: intsafe.h:52
#define FAILED(hr)
Definition: intsafe.h:51
voidpf uLong int origin
Definition: ioapi.h:144
#define debugstr_guid
Definition: kernel32.h:35
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static HMODULE MODULEINFO DWORD cb
Definition: module.c:33
static char * dest
Definition: rtl.c:135
REFCLSID clsid
Definition: msctf.c:82
static PFORMAT_STRING ComputeConformance(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat, ULONG def)
Definition: ndr_misc.h:37
static HRESULT WINAPI RpcStream_Clone(IStream *iface, IStream **cloned)
Definition: ndr_ole.c:240
static ULONG WINAPI RpcStream_Release(LPSTREAM iface)
Definition: ndr_ole.c:114
static HRESULT WINAPI RpcStream_Revert(IStream *iface)
Definition: ndr_ole.c:210
static const IStreamVtbl RpcStream_Vtbl
Definition: ndr_ole.c:247
static HRESULT WINAPI RpcStream_Read(LPSTREAM iface, void *pv, ULONG cb, ULONG *pcbRead)
Definition: ndr_ole.c:126
static HRESULT WINAPI RpcStream_UnlockRegion(IStream *iface, ULARGE_INTEGER offset, ULARGE_INTEGER len, DWORD locktype)
Definition: ndr_ole.c:225
static HRESULT WINAPI RpcStream_SetSize(LPSTREAM iface, ULARGE_INTEGER newSize)
Definition: ndr_ole.c:187
void *WINAPI NdrOleAllocate(SIZE_T Size)
Definition: ndr_ole.c:423
HRESULT create_stub(REFIID iid, IUnknown *pUnk, IRpcStubBuffer **ppstub)
Definition: ndr_ole.c:466
static HRESULT WINAPI RpcStream_Stat(IStream *iface, STATSTG *stat, DWORD flag)
Definition: ndr_ole.c:233
unsigned char *WINAPI NdrInterfacePointerMarshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
Definition: ndr_ole.c:306
static HRESULT WINAPI RpcStream_Seek(LPSTREAM iface, LARGE_INTEGER move, DWORD origin, ULARGE_INTEGER *newPos)
Definition: ndr_ole.c:161
static HMODULE hOLE
Definition: ndr_ole.c:47
static HRESULT RpcStream_Create(PMIDL_STUB_MESSAGE pStubMsg, BOOL init, ULONG *size, IStream **stream)
Definition: ndr_ole.c:265
unsigned char *WINAPI NdrInterfacePointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
Definition: ndr_ole.c:336
HRESULT create_proxy(REFIID iid, IUnknown *pUnkOuter, IRpcProxyBuffer **pproxy, void **ppv)
Definition: ndr_ole.c:442
static HRESULT WINAPI RpcStream_QueryInterface(LPSTREAM iface, REFIID riid, LPVOID *obj)
Definition: ndr_ole.c:92
static HMODULE LoadCOM(void)
Definition: ndr_ole.c:58
static HRESULT WINAPI RpcStream_Commit(IStream *iface, DWORD flags)
Definition: ndr_ole.c:203
static DWORD
Definition: ndr_ole.c:49
static HRESULT WINAPI RpcStream_LockRegion(IStream *iface, ULARGE_INTEGER offset, ULARGE_INTEGER len, DWORD locktype)
Definition: ndr_ole.c:217
static REFIID
Definition: ndr_ole.c:49
void WINAPI NdrOleFree(void *NodeToFree)
Definition: ndr_ole.c:432
static ULONG WINAPI RpcStream_AddRef(LPSTREAM iface)
Definition: ndr_ole.c:108
void WINAPI NdrInterfacePointerBufferSize(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
Definition: ndr_ole.c:373
static HRESULT WINAPI RpcStream_Write(LPSTREAM iface, const void *pv, ULONG cb, ULONG *pcbWritten)
Definition: ndr_ole.c:146
ULONG WINAPI NdrInterfacePointerMemorySize(PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
Definition: ndr_ole.c:392
static HRESULT WINAPI RpcStream_CopyTo(IStream *iface, IStream *dest, ULARGE_INTEGER len, ULARGE_INTEGER *read, ULARGE_INTEGER *written)
Definition: ndr_ole.c:195
static LPVOID
Definition: ndr_ole.c:49
static LPUNKNOWN
Definition: ndr_ole.c:49
static const IID * get_ip_iid(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
Definition: ndr_ole.c:286
static RpcStreamImpl * impl_from_IStream(IStream *iface)
Definition: ndr_ole.c:87
void WINAPI NdrInterfacePointerFree(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
Definition: ndr_ole.c:411
#define LPDWORD
Definition: nt_native.h:46
interface IStream * LPSTREAM
Definition: objfwd.h:10
long LONG
Definition: pedump.c:60
#define IsEqualGUID(rguid1, rguid2)
Definition: guiddef.h:147
#define IID_NULL
Definition: guiddef.h:98
#define REFCLSID
Definition: guiddef.h:117
@ FC_CONSTANT_IID
Definition: ndrtypes.h:251
@ FC_IP
Definition: ndrtypes.h:189
const unsigned char * PFORMAT_STRING
Definition: rpcndr.h:176
void DECLSPEC_NORETURN WINAPI RpcRaiseException(RPC_STATUS exception)
Definition: rpcrt4_main.c:188
HRESULT hr
Definition: shlfolder.c:183
#define TRACE(s)
Definition: solgame.cpp:4
IStream IStream_iface
Definition: ndr_ole.c:79
unsigned char * data
Definition: ndr_ole.c:83
LONG RefCount
Definition: ndr_ole.c:80
PMIDL_STUB_MESSAGE pMsg
Definition: ndr_ole.c:81
DWORD pos
Definition: ndr_ole.c:84
LPDWORD size
Definition: ndr_ole.c:82
void * pvDestContext
Definition: rpcndr.h:250
unsigned char * Buffer
Definition: rpcndr.h:203
ULONG BufferLength
Definition: rpcndr.h:207
ULONG MemorySize
Definition: rpcndr.h:208
DWORD dwDestContext
Definition: rpcndr.h:249
PRPC_MESSAGE RpcMsg
Definition: rpcndr.h:202
unsigned char IsClient
Definition: rpcndr.h:210
ULONG_PTR MaxCount
Definition: rpcndr.h:221
void * Buffer
Definition: rpcdcep.h:40
struct _ULARGE_INTEGER::@4145 u
Definition: send.c:48
Definition: stat.h:55
Definition: parse.h:23
ULONG_PTR SIZE_T
Definition: typedefs.h:80
uint32_t * LPDWORD
Definition: typedefs.h:59
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
uint32_t ULONG
Definition: typedefs.h:59
struct _LARGE_INTEGER::@2300 u
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4533
#define HRESULT
Definition: msvc.h:7
#define WINAPI
Definition: msvc.h:6
#define S_FALSE
Definition: winerror.h:2357
#define E_NOINTERFACE
Definition: winerror.h:2364
#define STG_E_MEDIUMFULL
Definition: winerror.h:2581
#define STG_E_INVALIDFUNCTION
Definition: winerror.h:2564
static int init
Definition: wintirpc.c:33