?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d2d1: Implement d2d_d3d_render_target_CreateBitmap().
[wine/multimedia.git] / dlls / oleaut32 / usrmarshal.c
blobca3bdadcb9337eb9758f7adc8a713d1f8474f789
1 /*
2 * Misc marshalling routines
3 *
4 * Copyright 2002 Ove Kaaven
5 * Copyright 2003 Mike Hearn
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include <stdarg.h>
23 #include <string.h>
24
25 #define COBJMACROS
26 #define NONAMELESSUNION
27 #define NONAMELESSSTRUCT
28
29 #include "windef.h"
30 #include "winbase.h"
31 #include "wingdi.h"
32 #include "winuser.h"
33 #include "winerror.h"
34
35 #include "ole2.h"
36 #include "oleauto.h"
37 #include "typelib.h"
38 #include "ocidl.h"
39 #include "wine/debug.h"
40
41 WINE_DEFAULT_DEBUG_CHANNEL(ole);
42
43 #define ALIGNED_LENGTH(_Len, _Align) (((_Len)+(_Align))&~(_Align))
44 #define ALIGNED_POINTER(_Ptr, _Align) ((LPVOID)ALIGNED_LENGTH((ULONG_PTR)(_Ptr), _Align))
45 #define ALIGN_LENGTH(_Len, _Align) _Len = ALIGNED_LENGTH(_Len, _Align)
46 #define ALIGN_POINTER(_Ptr, _Align) _Ptr = ALIGNED_POINTER(_Ptr, _Align)
47
48 static void dump_user_flags(const ULONG *pFlags)
49 {
50 if (HIWORD(*pFlags) == NDR_LOCAL_DATA_REPRESENTATION)
51 TRACE("MAKELONG(NDR_LOCAL_REPRESENTATION, ");
52 else
53 TRACE("MAKELONG(0x%04x, ", HIWORD(*pFlags));
54 switch (LOWORD(*pFlags))
55 {
56 case MSHCTX_LOCAL: TRACE("MSHCTX_LOCAL)"); break;
57 case MSHCTX_NOSHAREDMEM: TRACE("MSHCTX_NOSHAREDMEM)"); break;
58 case MSHCTX_DIFFERENTMACHINE: TRACE("MSHCTX_DIFFERENTMACHINE)"); break;
59 case MSHCTX_INPROC: TRACE("MSHCTX_INPROC)"); break;
60 default: TRACE("%d)", LOWORD(*pFlags));
61 }
62 }
63
64 /* CLEANLOCALSTORAGE */
65
66 #define CLS_FUNCDESC 'f'
67 #define CLS_LIBATTR 'l'
68 #define CLS_TYPEATTR 't'
69 #define CLS_VARDESC 'v'
70
71 ULONG WINAPI CLEANLOCALSTORAGE_UserSize(ULONG *pFlags, ULONG Start, CLEANLOCALSTORAGE *pstg)
72 {
73 ALIGN_LENGTH(Start, 3);
74 return Start + sizeof(DWORD);
75 }
76
77 unsigned char * WINAPI CLEANLOCALSTORAGE_UserMarshal(ULONG *pFlags, unsigned char *Buffer, CLEANLOCALSTORAGE *pstg)
78 {
79 ALIGN_POINTER(Buffer, 3);
80 *(DWORD*)Buffer = pstg->flags;
81 switch(pstg->flags)
82 {
83 case CLS_LIBATTR:
84 ITypeLib_ReleaseTLibAttr((ITypeLib*)pstg->pInterface, *(TLIBATTR**)pstg->pStorage);
85 break;
86 case CLS_TYPEATTR:
87 ITypeInfo_ReleaseTypeAttr((ITypeInfo*)pstg->pInterface, *(TYPEATTR**)pstg->pStorage);
88 break;
89 case CLS_FUNCDESC:
90 ITypeInfo_ReleaseFuncDesc((ITypeInfo*)pstg->pInterface, *(FUNCDESC**)pstg->pStorage);
91 break;
92 case CLS_VARDESC:
93 ITypeInfo_ReleaseVarDesc((ITypeInfo*)pstg->pInterface, *(VARDESC**)pstg->pStorage);
94 break;
95
96 default:
97 ERR("Unknown type %x\n", pstg->flags);
98 }
99
100 *(VOID**)pstg->pStorage = NULL;
101 IUnknown_Release(pstg->pInterface);
102 pstg->pInterface = NULL;
103
104 return Buffer + sizeof(DWORD);
105 }
106
107 unsigned char * WINAPI CLEANLOCALSTORAGE_UserUnmarshal(ULONG *pFlags, unsigned char *Buffer, CLEANLOCALSTORAGE *pstr)
108 {
109 ALIGN_POINTER(Buffer, 3);
110 pstr->flags = *(DWORD*)Buffer;
111 return Buffer + sizeof(DWORD);
112 }
113
114 void WINAPI CLEANLOCALSTORAGE_UserFree(ULONG *pFlags, CLEANLOCALSTORAGE *pstr)
115 {
116 /* Nothing to do */
117 }
118
119 /* BSTR */
120
121 typedef struct
122 {
123 DWORD len; /* No. of chars not including trailing '\0' */
124 DWORD byte_len; /* len * 2 or 0xffffffff if len == 0 */
125 DWORD len2; /* == len */
126 } bstr_wire_t;
127
128 ULONG WINAPI BSTR_UserSize(ULONG *pFlags, ULONG Start, BSTR *pstr)
129 {
130 TRACE("(%x,%d,%p) => %p\n", *pFlags, Start, pstr, *pstr);
131 if (*pstr) TRACE("string=%s\n", debugstr_w(*pstr));
132 ALIGN_LENGTH(Start, 3);
133 Start += sizeof(bstr_wire_t) + ((SysStringByteLen(*pstr) + 1) & ~1);
134 TRACE("returning %d\n", Start);
135 return Start;
136 }
137
138 unsigned char * WINAPI BSTR_UserMarshal(ULONG *pFlags, unsigned char *Buffer, BSTR *pstr)
139 {
140 bstr_wire_t *header;
141 DWORD len = SysStringByteLen(*pstr);
142
143 TRACE("(%x,%p,%p) => %p\n", *pFlags, Buffer, pstr, *pstr);
144 if (*pstr) TRACE("string=%s\n", debugstr_w(*pstr));
145
146 ALIGN_POINTER(Buffer, 3);
147 header = (bstr_wire_t*)Buffer;
148 header->len = header->len2 = (len + 1) / 2;
149 if (*pstr)
150 {
151 header->byte_len = len;
152 memcpy(header + 1, *pstr, header->len * 2);
153 }
154 else
155 header->byte_len = 0xffffffff; /* special case for a null bstr */
156
157 return Buffer + sizeof(*header) + sizeof(OLECHAR) * header->len;
158 }
159
160 unsigned char * WINAPI BSTR_UserUnmarshal(ULONG *pFlags, unsigned char *Buffer, BSTR *pstr)
161 {
162 bstr_wire_t *header;
163 TRACE("(%x,%p,%p) => %p\n", *pFlags, Buffer, pstr, *pstr);
164
165 ALIGN_POINTER(Buffer, 3);
166 header = (bstr_wire_t*)Buffer;
167 if(header->len != header->len2)
168 FIXME("len %08x != len2 %08x\n", header->len, header->len2);
169
170 if (header->byte_len == 0xffffffff)
171 {
172 SysFreeString(*pstr);
173 *pstr = NULL;
174 }
175 else SysReAllocStringLen( pstr, (OLECHAR *)(header + 1), header->len );
176
177 if (*pstr) TRACE("string=%s\n", debugstr_w(*pstr));
178 return Buffer + sizeof(*header) + sizeof(OLECHAR) * header->len;
179 }
180
181 void WINAPI BSTR_UserFree(ULONG *pFlags, BSTR *pstr)
182 {
183 TRACE("(%x,%p) => %p\n", *pFlags, pstr, *pstr);
184 SysFreeString(*pstr);
185 *pstr = NULL;
186 }
187
188 /* VARIANT */
189
190 typedef struct
191 {
192 DWORD clSize;
193 DWORD rpcReserved;
194 USHORT vt;
195 USHORT wReserved1;
196 USHORT wReserved2;
197 USHORT wReserved3;
198 DWORD switch_is;
199 } variant_wire_t;
200
201 unsigned int get_type_size(ULONG *pFlags, VARTYPE vt)
202 {
203 if (vt & VT_ARRAY) return 4;
204
205 switch (vt & ~VT_BYREF) {
206 case VT_EMPTY:
207 case VT_NULL:
208 return 0;
209 case VT_I1:
210 case VT_UI1:
211 return sizeof(CHAR);
212 case VT_I2:
213 case VT_UI2:
214 return sizeof(SHORT);
215 case VT_I4:
216 case VT_UI4:
217 case VT_HRESULT:
218 return sizeof(LONG);
219 case VT_INT:
220 case VT_UINT:
221 return sizeof(INT);
222 case VT_R4:
223 return sizeof(FLOAT);
224 case VT_R8:
225 return sizeof(DOUBLE);
226 case VT_BOOL:
227 return sizeof(VARIANT_BOOL);
228 case VT_ERROR:
229 return sizeof(SCODE);
230 case VT_DATE:
231 return sizeof(DATE);
232 case VT_CY:
233 return sizeof(CY);
234 case VT_DECIMAL:
235 return sizeof(DECIMAL);
236 case VT_BSTR:
237 return sizeof(ULONG);
238 case VT_VARIANT:
239 return sizeof(VARIANT);
240 case VT_UNKNOWN:
241 case VT_DISPATCH:
242 case VT_RECORD:
243 return 0;
244 default:
245 FIXME("unhandled VT %d\n", vt);
246 return 0;
247 }
248 }
249
250 static unsigned int get_type_alignment(ULONG *pFlags, VARTYPE vt)
251 {
252 unsigned int size = get_type_size(pFlags, vt);
253 if(vt & VT_BYREF) return 3;
254 if(size == 0) return 0;
255 if(size <= 4) return size - 1;
256 return 7;
257 }
258
259 static unsigned interface_variant_size(const ULONG *pFlags, REFIID riid, IUnknown *punk)
260 {
261 ULONG size = 0;
262 HRESULT hr;
263
264 if (punk)
265 {
266 hr = CoGetMarshalSizeMax(&size, riid, punk, LOWORD(*pFlags), NULL, MSHLFLAGS_NORMAL);
267 if (FAILED(hr))
268 {
269 ERR("interface variant buffer size calculation failed, HRESULT=0x%x\n", hr);
270 return 0;
271 }
272 }
273 size += sizeof(ULONG); /* we have to store the buffersize in the stream */
274 TRACE("wire-size extra of interface variant is %d\n", size);
275 return size;
276 }
277
278 static ULONG wire_extra_user_size(ULONG *pFlags, ULONG Start, VARIANT *pvar)
279 {
280 if (V_ISARRAY(pvar))
281 {
282 if (V_ISBYREF(pvar))
283 return LPSAFEARRAY_UserSize(pFlags, Start, V_ARRAYREF(pvar));
284 else
285 return LPSAFEARRAY_UserSize(pFlags, Start, &V_ARRAY(pvar));
286 }
287
288 switch (V_VT(pvar)) {
289 case VT_BSTR:
290 return BSTR_UserSize(pFlags, Start, &V_BSTR(pvar));
291 case VT_BSTR | VT_BYREF:
292 return BSTR_UserSize(pFlags, Start, V_BSTRREF(pvar));
293 case VT_VARIANT | VT_BYREF:
294 return VARIANT_UserSize(pFlags, Start, V_VARIANTREF(pvar));
295 case VT_UNKNOWN:
296 return Start + interface_variant_size(pFlags, &IID_IUnknown, V_UNKNOWN(pvar));
297 case VT_UNKNOWN | VT_BYREF:
298 return Start + interface_variant_size(pFlags, &IID_IUnknown, *V_UNKNOWNREF(pvar));
299 case VT_DISPATCH:
300 return Start + interface_variant_size(pFlags, &IID_IDispatch, (IUnknown*)V_DISPATCH(pvar));
301 case VT_DISPATCH | VT_BYREF:
302 return Start + interface_variant_size(pFlags, &IID_IDispatch, (IUnknown*)*V_DISPATCHREF(pvar));
303 case VT_RECORD:
304 FIXME("wire-size record\n");
305 return Start;
306 case VT_SAFEARRAY:
307 case VT_SAFEARRAY | VT_BYREF:
308 FIXME("wire-size safearray: shouldn't be marshaling this\n");
309 return Start;
310 default:
311 return Start;
312 }
313 }
314
315 /* helper: called for VT_DISPATCH variants to marshal the IDispatch* into the buffer. returns Buffer on failure, new position otherwise */
316 static unsigned char* interface_variant_marshal(const ULONG *pFlags, unsigned char *Buffer,
317 REFIID riid, IUnknown *punk)
318 {
319 IStream *working;
320 HGLOBAL working_mem;
321 void *working_memlocked;
322 unsigned char *oldpos;
323 ULONG size;
324 HRESULT hr;
325
326 TRACE("pFlags=%d, Buffer=%p, pUnk=%p\n", *pFlags, Buffer, punk);
327
328 if(!punk)
329 {
330 memset(Buffer, 0, sizeof(ULONG));
331 return Buffer + sizeof(ULONG);
332 }
333
334 oldpos = Buffer;
335
336 /* CoMarshalInterface needs a stream, whereas at this level we are operating in terms of buffers.
337 * We create a stream on an HGLOBAL, so we can simply do a memcpy to move it to the buffer.
338 * in rpcrt4/ndr_ole.c, a simple IStream implementation is wrapped around the buffer object,
339 * but that would be overkill here, hence this implementation. We save the size because the unmarshal
340 * code has no way to know how long the marshalled buffer is. */
341
342 size = interface_variant_size(pFlags, riid, punk);
343
344 working_mem = GlobalAlloc(0, size);
345 if (!working_mem) return oldpos;
346
347 hr = CreateStreamOnHGlobal(working_mem, TRUE, &working);
348 if (hr != S_OK) {
349 GlobalFree(working_mem);
350 return oldpos;
351 }
352
353 hr = CoMarshalInterface(working, riid, punk, LOWORD(*pFlags), NULL, MSHLFLAGS_NORMAL);
354 if (hr != S_OK) {
355 IStream_Release(working); /* this also releases the hglobal */
356 return oldpos;
357 }
358
359 working_memlocked = GlobalLock(working_mem);
360 memcpy(Buffer, &size, sizeof(ULONG)); /* copy the buffersize */
361 memcpy(Buffer + sizeof(ULONG), working_memlocked, size - sizeof(ULONG));
362 GlobalUnlock(working_mem);
363
364 IStream_Release(working);
365
366 /* size includes the ULONG for the size written above */
367 TRACE("done, size=%d\n", size);
368 return Buffer + size;
369 }
370
371 /* helper: called for VT_DISPATCH / VT_UNKNOWN variants to unmarshal the buffer. returns Buffer on failure, new position otherwise */
372 static unsigned char *interface_variant_unmarshal(const ULONG *pFlags, unsigned char *Buffer,
373 REFIID riid, IUnknown **ppunk)
374 {
375 IStream *working;
376 HGLOBAL working_mem;
377 void *working_memlocked;
378 unsigned char *oldpos;
379 ULONG size;
380 HRESULT hr;
381
382 TRACE("pFlags=%d, Buffer=%p, ppUnk=%p\n", *pFlags, Buffer, ppunk);
383
384 oldpos = Buffer;
385
386 /* get the buffersize */
387 memcpy(&size, Buffer, sizeof(ULONG));
388 TRACE("buffersize=%d\n", size);
389
390 if(!size)
391 {
392 *ppunk = NULL;
393 return Buffer + sizeof(ULONG);
394 }
395
396 working_mem = GlobalAlloc(0, size);
397 if (!working_mem) return oldpos;
398
399 hr = CreateStreamOnHGlobal(working_mem, TRUE, &working);
400 if (hr != S_OK) {
401 GlobalFree(working_mem);
402 return oldpos;
403 }
404
405 working_memlocked = GlobalLock(working_mem);
406
407 /* now we copy the contents of the marshalling buffer to working_memlocked, unlock it, and demarshal the stream */
408 memcpy(working_memlocked, Buffer + sizeof(ULONG), size);
409 GlobalUnlock(working_mem);
410
411 hr = CoUnmarshalInterface(working, riid, (void**)ppunk);
412 if (hr != S_OK) {
413 IStream_Release(working);
414 return oldpos;
415 }
416
417 IStream_Release(working); /* this also frees the underlying hglobal */
418
419 /* size includes the ULONG for the size written above */
420 TRACE("done, processed=%d bytes\n", size);
421 return Buffer + size;
422 }
423
424
425 ULONG WINAPI VARIANT_UserSize(ULONG *pFlags, ULONG Start, VARIANT *pvar)
426 {
427 int align;
428 TRACE("(%x,%d,%p)\n", *pFlags, Start, pvar);
429 TRACE("vt=%04x\n", V_VT(pvar));
430
431 ALIGN_LENGTH(Start, 7);
432 Start += sizeof(variant_wire_t);
433 if(V_VT(pvar) & VT_BYREF)
434 Start += 4;
435
436 align = get_type_alignment(pFlags, V_VT(pvar));
437 ALIGN_LENGTH(Start, align);
438 if(V_VT(pvar) == (VT_VARIANT | VT_BYREF))
439 Start += 4;
440 else
441 Start += get_type_size(pFlags, V_VT(pvar));
442 Start = wire_extra_user_size(pFlags, Start, pvar);
443
444 TRACE("returning %d\n", Start);
445 return Start;
446 }
447
448 unsigned char * WINAPI VARIANT_UserMarshal(ULONG *pFlags, unsigned char *Buffer, VARIANT *pvar)
449 {
450 variant_wire_t *header;
451 ULONG type_size;
452 int align;
453 unsigned char *Pos;
454
455 TRACE("(%x,%p,%p)\n", *pFlags, Buffer, pvar);
456 TRACE("vt=%04x\n", V_VT(pvar));
457
458 ALIGN_POINTER(Buffer, 7);
459
460 header = (variant_wire_t *)Buffer;
461
462 header->clSize = 0; /* fixed up at the end */
463 header->rpcReserved = 0;
464 header->vt = pvar->n1.n2.vt;
465 header->wReserved1 = pvar->n1.n2.wReserved1;
466 header->wReserved2 = pvar->n1.n2.wReserved2;
467 header->wReserved3 = pvar->n1.n2.wReserved3;
468 header->switch_is = pvar->n1.n2.vt;
469 if(header->switch_is & VT_ARRAY)
470 header->switch_is &= ~VT_TYPEMASK;
471
472 Pos = (unsigned char*)(header + 1);
473 type_size = get_type_size(pFlags, V_VT(pvar));
474 align = get_type_alignment(pFlags, V_VT(pvar));
475 ALIGN_POINTER(Pos, align);
476
477 if(header->vt & VT_BYREF)
478 {
479 *(DWORD *)Pos = max(type_size, 4);
480 Pos += 4;
481 if((header->vt & VT_TYPEMASK) != VT_VARIANT)
482 {
483 memcpy(Pos, pvar->n1.n2.n3.byref, type_size);
484 Pos += type_size;
485 }
486 else
487 {
488 *(DWORD*)Pos = 'U' | 's' << 8 | 'e' << 16 | 'r' << 24;
489 Pos += 4;
490 }
491 }
492 else
493 {
494 if((header->vt & VT_TYPEMASK) == VT_DECIMAL)
495 memcpy(Pos, pvar, type_size);
496 else
497 memcpy(Pos, &pvar->n1.n2.n3, type_size);
498 Pos += type_size;
499 }
500
501 if(header->vt & VT_ARRAY)
502 {
503 if(header->vt & VT_BYREF)
504 Pos = LPSAFEARRAY_UserMarshal(pFlags, Pos, V_ARRAYREF(pvar));
505 else
506 Pos = LPSAFEARRAY_UserMarshal(pFlags, Pos, &V_ARRAY(pvar));
507 }
508 else
509 {
510 switch (header->vt)
511 {
512 case VT_BSTR:
513 Pos = BSTR_UserMarshal(pFlags, Pos, &V_BSTR(pvar));
514 break;
515 case VT_BSTR | VT_BYREF:
516 Pos = BSTR_UserMarshal(pFlags, Pos, V_BSTRREF(pvar));
517 break;
518 case VT_VARIANT | VT_BYREF:
519 Pos = VARIANT_UserMarshal(pFlags, Pos, V_VARIANTREF(pvar));
520 break;
521 case VT_UNKNOWN:
522 /* this should probably call WdtpInterfacePointer_UserMarshal in ole32.dll */
523 Pos = interface_variant_marshal(pFlags, Pos, &IID_IUnknown, V_UNKNOWN(pvar));
524 break;
525 case VT_UNKNOWN | VT_BYREF:
526 /* this should probably call WdtpInterfacePointer_UserMarshal in ole32.dll */
527 Pos = interface_variant_marshal(pFlags, Pos, &IID_IUnknown, *V_UNKNOWNREF(pvar));
528 break;
529 case VT_DISPATCH:
530 /* this should probably call WdtpInterfacePointer_UserMarshal in ole32.dll */
531 Pos = interface_variant_marshal(pFlags, Pos, &IID_IDispatch, (IUnknown*)V_DISPATCH(pvar));
532 break;
533 case VT_DISPATCH | VT_BYREF:
534 /* this should probably call WdtpInterfacePointer_UserMarshal in ole32.dll */
535 Pos = interface_variant_marshal(pFlags, Pos, &IID_IDispatch, (IUnknown*)*V_DISPATCHREF(pvar));
536 break;
537 case VT_RECORD:
538 FIXME("handle BRECORD by val\n");
539 break;
540 case VT_RECORD | VT_BYREF:
541 FIXME("handle BRECORD by ref\n");
542 break;
543 }
544 }
545 header->clSize = ((Pos - Buffer) + 7) >> 3;
546 TRACE("marshalled size=%d\n", header->clSize);
547 return Pos;
548 }
549
550 unsigned char * WINAPI VARIANT_UserUnmarshal(ULONG *pFlags, unsigned char *Buffer, VARIANT *pvar)
551 {
552 variant_wire_t *header;
553 ULONG type_size;
554 int align;
555 unsigned char *Pos;
556
557 TRACE("(%x,%p,%p)\n", *pFlags, Buffer, pvar);
558
559 ALIGN_POINTER(Buffer, 7);
560
561 header = (variant_wire_t *)Buffer;
562
563 Pos = (unsigned char*)(header + 1);
564 type_size = get_type_size(pFlags, header->vt);
565 align = get_type_alignment(pFlags, header->vt);
566 ALIGN_POINTER(Pos, align);
567
568 if(header->vt & VT_BYREF)
569 {
570 ULONG mem_size;
571 Pos += 4;
572
573 switch (header->vt & ~VT_BYREF)
574 {
575 /* these types have a different memory size compared to wire size */
576 case VT_UNKNOWN:
577 case VT_DISPATCH:
578 case VT_BSTR:
579 mem_size = sizeof(void *);
580 break;
581 default:
582 mem_size = type_size;
583 break;
584 }
585
586 if (V_VT(pvar) != header->vt)
587 {
588 VariantClear(pvar);
589 V_BYREF(pvar) = CoTaskMemAlloc(mem_size);
590 }
591 else if (!V_BYREF(pvar))
592 V_BYREF(pvar) = CoTaskMemAlloc(mem_size);
593 memcpy(V_BYREF(pvar), Pos, type_size);
594 if((header->vt & VT_TYPEMASK) != VT_VARIANT)
595 Pos += type_size;
596 else
597 Pos += 4;
598 }
599 else
600 {
601 VariantClear(pvar);
602 if((header->vt & VT_TYPEMASK) == VT_DECIMAL)
603 memcpy(pvar, Pos, type_size);
604 else
605 memcpy(&pvar->n1.n2.n3, Pos, type_size);
606 Pos += type_size;
607 }
608
609 pvar->n1.n2.vt = header->vt;
610 pvar->n1.n2.wReserved1 = header->wReserved1;
611 pvar->n1.n2.wReserved2 = header->wReserved2;
612 pvar->n1.n2.wReserved3 = header->wReserved3;
613
614 if(header->vt & VT_ARRAY)
615 {
616 if(header->vt & VT_BYREF)
617 Pos = LPSAFEARRAY_UserUnmarshal(pFlags, Pos, V_ARRAYREF(pvar));
618 else
619 Pos = LPSAFEARRAY_UserUnmarshal(pFlags, Pos, &V_ARRAY(pvar));
620 }
621 else
622 {
623 switch (header->vt)
624 {
625 case VT_BSTR:
626 V_BSTR(pvar) = NULL;
627 Pos = BSTR_UserUnmarshal(pFlags, Pos, &V_BSTR(pvar));
628 break;
629 case VT_BSTR | VT_BYREF:
630 *V_BSTRREF(pvar) = NULL;
631 Pos = BSTR_UserUnmarshal(pFlags, Pos, V_BSTRREF(pvar));
632 break;
633 case VT_VARIANT | VT_BYREF:
634 Pos = VARIANT_UserUnmarshal(pFlags, Pos, V_VARIANTREF(pvar));
635 break;
636 case VT_UNKNOWN:
637 /* this should probably call WdtpInterfacePointer_UserUnmarshal in ole32.dll */
638 Pos = interface_variant_unmarshal(pFlags, Pos, &IID_IUnknown, &V_UNKNOWN(pvar));
639 break;
640 case VT_UNKNOWN | VT_BYREF:
641 /* this should probably call WdtpInterfacePointer_UserUnmarshal in ole32.dll */
642 Pos = interface_variant_unmarshal(pFlags, Pos, &IID_IUnknown, V_UNKNOWNREF(pvar));
643 break;
644 case VT_DISPATCH:
645 /* this should probably call WdtpInterfacePointer_UserUnmarshal in ole32.dll */
646 Pos = interface_variant_unmarshal(pFlags, Pos, &IID_IDispatch, (IUnknown**)&V_DISPATCH(pvar));
647 break;
648 case VT_DISPATCH | VT_BYREF:
649 /* this should probably call WdtpInterfacePointer_UserUnmarshal in ole32.dll */
650 Pos = interface_variant_unmarshal(pFlags, Pos, &IID_IDispatch, (IUnknown**)V_DISPATCHREF(pvar));
651 break;
652 case VT_RECORD:
653 FIXME("handle BRECORD by val\n");
654 break;
655 case VT_RECORD | VT_BYREF:
656 FIXME("handle BRECORD by ref\n");
657 break;
658 }
659 }
660 return Pos;
661 }
662
663 void WINAPI VARIANT_UserFree(ULONG *pFlags, VARIANT *pvar)
664 {
665 VARTYPE vt = V_VT(pvar);
666 PVOID ref = NULL;
667
668 TRACE("(%x,%p)\n", *pFlags, pvar);
669 TRACE("vt=%04x\n", V_VT(pvar));
670
671 if (vt & VT_BYREF) ref = pvar->n1.n2.n3.byref;
672
673 VariantClear(pvar);
674 if (!ref) return;
675
676 if(vt & VT_ARRAY)
677 {
678 if (vt & VT_BYREF)
679 LPSAFEARRAY_UserFree(pFlags, V_ARRAYREF(pvar));
680 else
681 LPSAFEARRAY_UserFree(pFlags, &V_ARRAY(pvar));
682 }
683 else
684 {
685 switch (vt)
686 {
687 case VT_BSTR | VT_BYREF:
688 BSTR_UserFree(pFlags, V_BSTRREF(pvar));
689 break;
690 case VT_VARIANT | VT_BYREF:
691 VARIANT_UserFree(pFlags, V_VARIANTREF(pvar));
692 break;
693 case VT_RECORD | VT_BYREF:
694 FIXME("handle BRECORD by ref\n");
695 break;
696 case VT_UNKNOWN | VT_BYREF:
697 case VT_DISPATCH | VT_BYREF:
698 IUnknown_Release(*V_UNKNOWNREF(pvar));
699 break;
700 }
701 }
702
703 CoTaskMemFree(ref);
704 }
705
706 /* LPSAFEARRAY */
707
708 /* Get the number of cells in a SafeArray */
709 static ULONG SAFEARRAY_GetCellCount(const SAFEARRAY *psa)
710 {
711 const SAFEARRAYBOUND* psab = psa->rgsabound;
712 USHORT cCount = psa->cDims;
713 ULONG ulNumCells = 1;
714
715 while (cCount--)
716 {
717 /* This is a valid bordercase. See testcases. -Marcus */
718 if (!psab->cElements)
719 return 0;
720 ulNumCells *= psab->cElements;
721 psab++;
722 }
723 return ulNumCells;
724 }
725
726 static inline SF_TYPE SAFEARRAY_GetUnionType(SAFEARRAY *psa)
727 {
728 VARTYPE vt;
729 HRESULT hr;
730
731 hr = SafeArrayGetVartype(psa, &vt);
732 if (FAILED(hr))
733 {
734 if(psa->fFeatures & FADF_VARIANT) return SF_VARIANT;
735
736 switch(psa->cbElements)
737 {
738 case 1: vt = VT_I1; break;
739 case 2: vt = VT_I2; break;
740 case 4: vt = VT_I4; break;
741 case 8: vt = VT_I8; break;
742 default:
743 RpcRaiseException(hr);
744 }
745 }
746
747 if (psa->fFeatures & FADF_HAVEIID)
748 return SF_HAVEIID;
749
750 switch (vt)
751 {
752 case VT_I1:
753 case VT_UI1: return SF_I1;
754 case VT_BOOL:
755 case VT_I2:
756 case VT_UI2: return SF_I2;
757 case VT_INT:
758 case VT_UINT:
759 case VT_I4:
760 case VT_UI4:
761 case VT_R4: return SF_I4;
762 case VT_DATE:
763 case VT_CY:
764 case VT_R8:
765 case VT_I8:
766 case VT_UI8: return SF_I8;
767 case VT_INT_PTR:
768 case VT_UINT_PTR: return (sizeof(UINT_PTR) == 4 ? SF_I4 : SF_I8);
769 case VT_BSTR: return SF_BSTR;
770 case VT_DISPATCH: return SF_DISPATCH;
771 case VT_VARIANT: return SF_VARIANT;
772 case VT_UNKNOWN: return SF_UNKNOWN;
773 /* Note: Return a non-zero size to indicate vt is valid. The actual size
774 * of a UDT is taken from the result of IRecordInfo_GetSize().
775 */
776 case VT_RECORD: return SF_RECORD;
777 default: return SF_ERROR;
778 }
779 }
780
781 static DWORD elem_wire_size(LPSAFEARRAY lpsa, SF_TYPE sftype)
782 {
783 if (sftype == SF_BSTR)
784 return sizeof(DWORD);
785 else if (sftype == SF_VARIANT)
786 return sizeof(variant_wire_t) - sizeof(DWORD);
787 else
788 return lpsa->cbElements;
789 }
790
791 static DWORD elem_mem_size(wireSAFEARRAY wiresa, SF_TYPE sftype)
792 {
793 if (sftype == SF_BSTR)
794 return sizeof(BSTR);
795 else if (sftype == SF_VARIANT)
796 return sizeof(VARIANT);
797 else
798 return wiresa->cbElements;
799 }
800
801 ULONG WINAPI LPSAFEARRAY_UserSize(ULONG *pFlags, ULONG StartingSize, LPSAFEARRAY *ppsa)
802 {
803 ULONG size = StartingSize;
804
805 TRACE("("); dump_user_flags(pFlags); TRACE(", %d, %p\n", StartingSize, *ppsa);
806
807 ALIGN_LENGTH(size, 3);
808 size += sizeof(ULONG);
809 if (*ppsa)
810 {
811 SAFEARRAY *psa = *ppsa;
812 ULONG ulCellCount = SAFEARRAY_GetCellCount(psa);
813 SF_TYPE sftype;
814 HRESULT hr;
815
816 size += sizeof(ULONG);
817 size += 2 * sizeof(USHORT) + 2 * sizeof(ULONG);
818
819 sftype = SAFEARRAY_GetUnionType(psa);
820 size += sizeof(ULONG);
821
822 size += sizeof(ULONG);
823 size += sizeof(ULONG);
824 if (sftype == SF_HAVEIID)
825 size += sizeof(IID);
826
827 size += sizeof(psa->rgsabound[0]) * psa->cDims;
828
829 size += sizeof(ULONG);
830
831 switch (sftype)
832 {
833 case SF_BSTR:
834 {
835 BSTR* lpBstr;
836
837 for (lpBstr = psa->pvData; ulCellCount; ulCellCount--, lpBstr++)
838 size = BSTR_UserSize(pFlags, size, lpBstr);
839
840 break;
841 }
842 case SF_DISPATCH:
843 case SF_UNKNOWN:
844 case SF_HAVEIID:
845 FIXME("size interfaces\n");
846 break;
847 case SF_VARIANT:
848 {
849 VARIANT* lpVariant;
850
851 for (lpVariant = psa->pvData; ulCellCount; ulCellCount--, lpVariant++)
852 size = VARIANT_UserSize(pFlags, size, lpVariant);
853
854 break;
855 }
856 case SF_RECORD:
857 {
858 IRecordInfo* pRecInfo = NULL;
859
860 hr = SafeArrayGetRecordInfo(psa, &pRecInfo);
861 if (FAILED(hr))
862 RpcRaiseException(hr);
863
864 if (pRecInfo)
865 {
866 FIXME("size record info %p\n", pRecInfo);
867
868 IRecordInfo_Release(pRecInfo);
869 }
870 break;
871 }
872 case SF_I8:
873 ALIGN_LENGTH(size, 7);
874 /* fallthrough */
875 case SF_I1:
876 case SF_I2:
877 case SF_I4:
878 size += ulCellCount * psa->cbElements;
879 break;
880 default:
881 break;
882 }
883
884 }
885
886 return size;
887 }
888
889 unsigned char * WINAPI LPSAFEARRAY_UserMarshal(ULONG *pFlags, unsigned char *Buffer, LPSAFEARRAY *ppsa)
890 {
891 HRESULT hr;
892
893 TRACE("("); dump_user_flags(pFlags); TRACE(", %p, &%p\n", Buffer, *ppsa);
894
895 ALIGN_POINTER(Buffer, 3);
896 *(ULONG *)Buffer = *ppsa ? 0x1 : 0x0;
897 Buffer += sizeof(ULONG);
898 if (*ppsa)
899 {
900 VARTYPE vt;
901 SAFEARRAY *psa = *ppsa;
902 ULONG ulCellCount = SAFEARRAY_GetCellCount(psa);
903 SAFEARRAYBOUND *bound;
904 SF_TYPE sftype;
905 GUID guid;
906 INT i;
907
908 sftype = SAFEARRAY_GetUnionType(psa);
909
910 *(ULONG *)Buffer = psa->cDims;
911 Buffer += sizeof(ULONG);
912 *(USHORT *)Buffer = psa->cDims;
913 Buffer += sizeof(USHORT);
914 *(USHORT *)Buffer = psa->fFeatures;
915 Buffer += sizeof(USHORT);
916 *(ULONG *)Buffer = elem_wire_size(psa, sftype);
917 Buffer += sizeof(ULONG);
918
919 hr = SafeArrayGetVartype(psa, &vt);
920 if (FAILED(hr)) vt = 0;
921
922 *(ULONG *)Buffer = (USHORT)psa->cLocks | (vt << 16);
923 Buffer += sizeof(ULONG);
924
925 *(ULONG *)Buffer = sftype;
926 Buffer += sizeof(ULONG);
927
928 *(ULONG *)Buffer = ulCellCount;
929 Buffer += sizeof(ULONG);
930 *(ULONG *)Buffer = psa->pvData ? 0x2 : 0x0;
931 Buffer += sizeof(ULONG);
932 if (sftype == SF_HAVEIID)
933 {
934 SafeArrayGetIID(psa, &guid);
935 memcpy(Buffer, &guid, sizeof(guid));
936 Buffer += sizeof(guid);
937 }
938
939 /* bounds are marshaled in opposite order comparing to storage layout */
940 bound = (SAFEARRAYBOUND*)Buffer;
941 for (i = 0; i < psa->cDims; i++)
942 {
943 memcpy(bound++, &psa->rgsabound[psa->cDims-i-1], sizeof(psa->rgsabound[0]));
944 }
945 Buffer += sizeof(psa->rgsabound[0]) * psa->cDims;
946
947 *(ULONG *)Buffer = ulCellCount;
948 Buffer += sizeof(ULONG);
949
950 if (psa->pvData)
951 {
952 switch (sftype)
953 {
954 case SF_BSTR:
955 {
956 BSTR* lpBstr;
957
958 for (lpBstr = psa->pvData; ulCellCount; ulCellCount--, lpBstr++)
959 Buffer = BSTR_UserMarshal(pFlags, Buffer, lpBstr);
960
961 break;
962 }
963 case SF_DISPATCH:
964 case SF_UNKNOWN:
965 case SF_HAVEIID:
966 FIXME("marshal interfaces\n");
967 break;
968 case SF_VARIANT:
969 {
970 VARIANT* lpVariant;
971
972 for (lpVariant = psa->pvData; ulCellCount; ulCellCount--, lpVariant++)
973 Buffer = VARIANT_UserMarshal(pFlags, Buffer, lpVariant);
974
975 break;
976 }
977 case SF_RECORD:
978 {
979 IRecordInfo* pRecInfo = NULL;
980
981 hr = SafeArrayGetRecordInfo(psa, &pRecInfo);
982 if (FAILED(hr))
983 RpcRaiseException(hr);
984
985 if (pRecInfo)
986 {
987 FIXME("write record info %p\n", pRecInfo);
988
989 IRecordInfo_Release(pRecInfo);
990 }
991 break;
992 }
993
994 case SF_I8:
995 ALIGN_POINTER(Buffer, 7);
996 /* fallthrough */
997 case SF_I1:
998 case SF_I2:
999 case SF_I4:
1000 /* Just copy the data over */
1001 memcpy(Buffer, psa->pvData, ulCellCount * psa->cbElements);
1002 Buffer += ulCellCount * psa->cbElements;
1003 break;
1004 default:
1005 break;
1006 }
1007 }
1008
1009 }
1010 return Buffer;
1011 }
1012
1013 #define FADF_AUTOSETFLAGS (FADF_HAVEIID | FADF_RECORD | FADF_HAVEVARTYPE | \
1014 FADF_BSTR | FADF_UNKNOWN | FADF_DISPATCH | \
1015 FADF_VARIANT | FADF_CREATEVECTOR)
1016
1017 unsigned char * WINAPI LPSAFEARRAY_UserUnmarshal(ULONG *pFlags, unsigned char *Buffer, LPSAFEARRAY *ppsa)
1018 {
1019 ULONG ptr;
1020 wireSAFEARRAY wiresa;
1021 ULONG cDims;
1022 HRESULT hr;
1023 SF_TYPE sftype;
1024 ULONG cell_count;
1025 GUID guid;
1026 VARTYPE vt;
1027 SAFEARRAYBOUND *wiresab;
1028
1029 TRACE("("); dump_user_flags(pFlags); TRACE(", %p, %p\n", Buffer, ppsa);
1030
1031 ALIGN_POINTER(Buffer, 3);
1032 ptr = *(ULONG *)Buffer;
1033 Buffer += sizeof(ULONG);
1034
1035 if (!ptr)
1036 {
1037 *ppsa = NULL;
1038
1039 TRACE("NULL safe array unmarshaled\n");
1040
1041 return Buffer;
1042 }
1043
1044 cDims = *(ULONG *)Buffer;
1045 Buffer += sizeof(ULONG);
1046
1047 wiresa = (wireSAFEARRAY)Buffer;
1048 Buffer += 2 * sizeof(USHORT) + 2 * sizeof(ULONG);
1049
1050 if (cDims != wiresa->cDims)
1051 RpcRaiseException(RPC_S_INVALID_BOUND);
1052
1053 /* FIXME: there should be a limit on how large cDims can be */
1054
1055 vt = HIWORD(wiresa->cLocks);
1056
1057 sftype = *(ULONG *)Buffer;
1058 Buffer += sizeof(ULONG);
1059
1060 cell_count = *(ULONG *)Buffer;
1061 Buffer += sizeof(ULONG);
1062 ptr = *(ULONG *)Buffer;
1063 Buffer += sizeof(ULONG);
1064 if (sftype == SF_HAVEIID)
1065 {
1066 memcpy(&guid, Buffer, sizeof(guid));
1067 Buffer += sizeof(guid);
1068 }
1069
1070 wiresab = (SAFEARRAYBOUND *)Buffer;
1071 Buffer += sizeof(wiresab[0]) * wiresa->cDims;
1072
1073 if(vt)
1074 {
1075 *ppsa = SafeArrayCreateEx(vt, wiresa->cDims, wiresab, NULL);
1076 if (!*ppsa) RpcRaiseException(E_OUTOFMEMORY);
1077 }
1078 else
1079 {
1080 if (FAILED(SafeArrayAllocDescriptor(wiresa->cDims, ppsa)))
1081 RpcRaiseException(E_OUTOFMEMORY);
1082 memcpy((*ppsa)->rgsabound, wiresab, sizeof(SAFEARRAYBOUND) * wiresa->cDims);
1083 }
1084
1085 /* be careful about which flags we set since they could be a security
1086 * risk */
1087 (*ppsa)->fFeatures &= FADF_AUTOSETFLAGS;
1088 (*ppsa)->fFeatures |= (wiresa->fFeatures & ~(FADF_AUTOSETFLAGS));
1089 /* FIXME: there should be a limit on how large wiresa->cbElements can be */
1090 (*ppsa)->cbElements = elem_mem_size(wiresa, sftype);
1091 (*ppsa)->cLocks = 0;
1092
1093 /* SafeArrayCreateEx allocates the data for us, but
1094 * SafeArrayAllocDescriptor doesn't */
1095 if(!vt)
1096 {
1097 hr = SafeArrayAllocData(*ppsa);
1098 if (FAILED(hr))
1099 RpcRaiseException(hr);
1100 }
1101
1102 if ((*(ULONG *)Buffer != cell_count) || (SAFEARRAY_GetCellCount(*ppsa) != cell_count))
1103 RpcRaiseException(RPC_S_INVALID_BOUND);
1104 Buffer += sizeof(ULONG);
1105
1106 if (ptr)
1107 {
1108 switch (sftype)
1109 {
1110 case SF_BSTR:
1111 {
1112 BSTR* lpBstr;
1113
1114 for (lpBstr = (*ppsa)->pvData; cell_count; cell_count--, lpBstr++)
1115 Buffer = BSTR_UserUnmarshal(pFlags, Buffer, lpBstr);
1116
1117 break;
1118 }
1119 case SF_DISPATCH:
1120 case SF_UNKNOWN:
1121 case SF_HAVEIID:
1122 FIXME("marshal interfaces\n");
1123 break;
1124 case SF_VARIANT:
1125 {
1126 VARIANT* lpVariant;
1127
1128 for (lpVariant = (*ppsa)->pvData; cell_count; cell_count--, lpVariant++)
1129 Buffer = VARIANT_UserUnmarshal(pFlags, Buffer, lpVariant);
1130
1131 break;
1132 }
1133 case SF_RECORD:
1134 {
1135 FIXME("set record info\n");
1136
1137 break;
1138 }
1139
1140 case SF_I8:
1141 ALIGN_POINTER(Buffer, 7);
1142 /* fallthrough */
1143 case SF_I1:
1144 case SF_I2:
1145 case SF_I4:
1146 /* Just copy the data over */
1147 memcpy((*ppsa)->pvData, Buffer, cell_count * (*ppsa)->cbElements);
1148 Buffer += cell_count * (*ppsa)->cbElements;
1149 break;
1150 default:
1151 break;
1152 }
1153 }
1154
1155 TRACE("safe array unmarshaled: %p\n", *ppsa);
1156
1157 return Buffer;
1158 }
1159
1160 void WINAPI LPSAFEARRAY_UserFree(ULONG *pFlags, LPSAFEARRAY *ppsa)
1161 {
1162 TRACE("("); dump_user_flags(pFlags); TRACE(", &%p\n", *ppsa);
1163
1164 SafeArrayDestroy(*ppsa);
1165 }
1166
1167
1168 ULONG WINAPI HFONT_UserSize(ULONG *pFlags, ULONG Start, HFONT *phfont)
1169 {
1170 FIXME(":stub\n");
1171 return 0;
1172 }
1173
1174 unsigned char * WINAPI HFONT_UserMarshal(ULONG *pFlags, unsigned char *Buffer, HFONT *phfont)
1175 {
1176 FIXME(":stub\n");
1177 return NULL;
1178 }
1179
1180 unsigned char * WINAPI HFONT_UserUnmarshal(ULONG *pFlags, unsigned char *Buffer, HFONT *phfont)
1181 {
1182 FIXME(":stub\n");
1183 return NULL;
1184 }
1185
1186 void WINAPI HFONT_UserFree(ULONG *pFlags, HFONT *phfont)
1187 {
1188 FIXME(":stub\n");
1189 return;
1190 }
1191
1192
1193 /* IDispatch */
1194 /* exactly how Invoke is marshalled is not very clear to me yet,
1195 * but the way I've done it seems to work for me */
1196
1197 HRESULT CALLBACK IDispatch_Invoke_Proxy(
1198 IDispatch* This,
1199 DISPID dispIdMember,
1200 REFIID riid,
1201 LCID lcid,
1202 WORD wFlags,
1203 DISPPARAMS* pDispParams,
1204 VARIANT* pVarResult,
1205 EXCEPINFO* pExcepInfo,
1206 UINT* puArgErr)
1207 {
1208 HRESULT hr;
1209 VARIANT VarResult;
1210 UINT* rgVarRefIdx = NULL;
1211 VARIANTARG* rgVarRef = NULL;
1212 UINT u, cVarRef;
1213 UINT uArgErr;
1214 EXCEPINFO ExcepInfo;
1215
1216 TRACE("(%p)->(%d,%s,%x,%x,%p,%p,%p,%p)\n", This,
1217 dispIdMember, debugstr_guid(riid),
1218 lcid, wFlags, pDispParams, pVarResult,
1219 pExcepInfo, puArgErr);
1220
1221 /* [out] args can't be null, use dummy vars if needed */
1222 if (!pVarResult) pVarResult = &VarResult;
1223 if (!puArgErr) puArgErr = &uArgErr;
1224 if (!pExcepInfo) pExcepInfo = &ExcepInfo;
1225
1226 /* count by-ref args */
1227 for (cVarRef=0,u=0; u<pDispParams->cArgs; u++) {
1228 VARIANTARG* arg = &pDispParams->rgvarg[u];
1229 if (V_ISBYREF(arg)) {
1230 cVarRef++;
1231 }
1232 }
1233 if (cVarRef) {
1234 rgVarRefIdx = CoTaskMemAlloc(sizeof(UINT)*cVarRef);
1235 rgVarRef = CoTaskMemAlloc(sizeof(VARIANTARG)*cVarRef);
1236 /* make list of by-ref args */
1237 for (cVarRef=0,u=0; u<pDispParams->cArgs; u++) {
1238 VARIANTARG* arg = &pDispParams->rgvarg[u];
1239 if (V_ISBYREF(arg)) {
1240 rgVarRefIdx[cVarRef] = u;
1241 VariantInit(&rgVarRef[cVarRef]);
1242 VariantCopy(&rgVarRef[cVarRef], arg);
1243 VariantClear(arg);
1244 cVarRef++;
1245 }
1246 }
1247 } else {
1248 /* [out] args still can't be null,
1249 * but we can point these anywhere in this case,
1250 * since they won't be written to when cVarRef is 0 */
1251 rgVarRefIdx = puArgErr;
1252 rgVarRef = pVarResult;
1253 }
1254 TRACE("passed by ref: %d args\n", cVarRef);
1255 hr = IDispatch_RemoteInvoke_Proxy(This,
1256 dispIdMember,
1257 riid,
1258 lcid,
1259 wFlags,
1260 pDispParams,
1261 pVarResult,
1262 pExcepInfo,
1263 puArgErr,
1264 cVarRef,
1265 rgVarRefIdx,
1266 rgVarRef);
1267 if (cVarRef) {
1268 for (u=0; u<cVarRef; u++) {
1269 unsigned i = rgVarRefIdx[u];
1270 VariantCopy(&pDispParams->rgvarg[i],
1271 &rgVarRef[u]);
1272 VariantClear(&rgVarRef[u]);
1273 }
1274 CoTaskMemFree(rgVarRef);
1275 CoTaskMemFree(rgVarRefIdx);
1276 }
1277
1278 if(pExcepInfo == &ExcepInfo)
1279 {
1280 SysFreeString(pExcepInfo->bstrSource);
1281 SysFreeString(pExcepInfo->bstrDescription);
1282 SysFreeString(pExcepInfo->bstrHelpFile);
1283 }
1284 return hr;
1285 }
1286
1287 HRESULT __RPC_STUB IDispatch_Invoke_Stub(
1288 IDispatch* This,
1289 DISPID dispIdMember,
1290 REFIID riid,
1291 LCID lcid,
1292 DWORD dwFlags,
1293 DISPPARAMS* pDispParams,
1294 VARIANT* pVarResult,
1295 EXCEPINFO* pExcepInfo,
1296 UINT* pArgErr,
1297 UINT cVarRef,
1298 UINT* rgVarRefIdx,
1299 VARIANTARG* rgVarRef)
1300 {
1301 HRESULT hr = S_OK;
1302 VARIANTARG *rgvarg, *arg;
1303 UINT u;
1304
1305 /* initialize out parameters, so that they can be marshalled
1306 * in case the real Invoke doesn't initialize them */
1307 VariantInit(pVarResult);
1308 memset(pExcepInfo, 0, sizeof(*pExcepInfo));
1309 *pArgErr = 0;
1310
1311 /* let the real Invoke operate on a copy of the in parameters,
1312 * so we don't risk losing pointers to allocated memory */
1313 rgvarg = pDispParams->rgvarg;
1314 arg = CoTaskMemAlloc(sizeof(VARIANTARG)*pDispParams->cArgs);
1315 if (!arg) return E_OUTOFMEMORY;
1316
1317 /* init all args so we can call VariantClear on all the args if the copy
1318 * below fails */
1319 for (u = 0; u < pDispParams->cArgs; u++)
1320 VariantInit(&arg[u]);
1321
1322 for (u = 0; u < pDispParams->cArgs; u++) {
1323 hr = VariantCopy(&arg[u], &rgvarg[u]);
1324 if (FAILED(hr))
1325 break;
1326 }
1327
1328 if (SUCCEEDED(hr)) {
1329 /* copy ref args to arg array */
1330 for (u=0; u<cVarRef; u++) {
1331 unsigned i = rgVarRefIdx[u];
1332 VariantCopy(&arg[i], &rgVarRef[u]);
1333 }
1334
1335 pDispParams->rgvarg = arg;
1336
1337 hr = IDispatch_Invoke(This,
1338 dispIdMember,
1339 riid,
1340 lcid,
1341 dwFlags,
1342 pDispParams,
1343 pVarResult,
1344 pExcepInfo,
1345 pArgErr);
1346
1347 /* copy ref args from arg array */
1348 for (u=0; u<cVarRef; u++) {
1349 unsigned i = rgVarRefIdx[u];
1350 VariantCopy(&rgVarRef[u], &arg[i]);
1351 }
1352 }
1353
1354 /* clear the duplicate argument list */
1355 for (u=0; u<pDispParams->cArgs; u++)
1356 VariantClear(&arg[u]);
1357
1358 pDispParams->rgvarg = rgvarg;
1359 CoTaskMemFree(arg);
1360
1361 return hr;
1362 }
1363
1364 /* IEnumVARIANT */
1365
1366 HRESULT CALLBACK IEnumVARIANT_Next_Proxy(
1367 IEnumVARIANT* This,
1368 ULONG celt,
1369 VARIANT* rgVar,
1370 ULONG* pCeltFetched)
1371 {
1372 ULONG fetched;
1373 if (!pCeltFetched)
1374 pCeltFetched = &fetched;
1375 return IEnumVARIANT_RemoteNext_Proxy(This,
1376 celt,
1377 rgVar,
1378 pCeltFetched);
1379 }
1380
1381 HRESULT __RPC_STUB IEnumVARIANT_Next_Stub(
1382 IEnumVARIANT* This,
1383 ULONG celt,
1384 VARIANT* rgVar,
1385 ULONG* pCeltFetched)
1386 {
1387 HRESULT hr;
1388 *pCeltFetched = 0;
1389 hr = IEnumVARIANT_Next(This,
1390 celt,
1391 rgVar,
1392 pCeltFetched);
1393 if (hr == S_OK) *pCeltFetched = celt;
1394 return hr;
1395 }
1396
1397 /* TypeInfo related freers */
1398
1399 static void free_embedded_typedesc(TYPEDESC *tdesc);
1400 static void free_embedded_arraydesc(ARRAYDESC *adesc)
1401 {
1402 switch(adesc->tdescElem.vt)
1403 {
1404 case VT_PTR:
1405 case VT_SAFEARRAY:
1406 free_embedded_typedesc(adesc->tdescElem.u.lptdesc);
1407 CoTaskMemFree(adesc->tdescElem.u.lptdesc);
1408 break;
1409 case VT_CARRAY:
1410 free_embedded_arraydesc(adesc->tdescElem.u.lpadesc);
1411 CoTaskMemFree(adesc->tdescElem.u.lpadesc);
1412 break;
1413 }
1414 }
1415
1416 static void free_embedded_typedesc(TYPEDESC *tdesc)
1417 {
1418 switch(tdesc->vt)
1419 {
1420 case VT_PTR:
1421 case VT_SAFEARRAY:
1422 free_embedded_typedesc(tdesc->u.lptdesc);
1423 CoTaskMemFree(tdesc->u.lptdesc);
1424 break;
1425 case VT_CARRAY:
1426 free_embedded_arraydesc(tdesc->u.lpadesc);
1427 CoTaskMemFree(tdesc->u.lpadesc);
1428 break;
1429 }
1430 }
1431
1432 static void free_embedded_elemdesc(ELEMDESC *edesc)
1433 {
1434 free_embedded_typedesc(&edesc->tdesc);
1435 if(edesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
1436 CoTaskMemFree(edesc->u.paramdesc.pparamdescex);
1437 }
1438
1439 /* ITypeComp */
1440
1441 HRESULT CALLBACK ITypeComp_Bind_Proxy(
1442 ITypeComp* This,
1443 LPOLESTR szName,
1444 ULONG lHashVal,
1445 WORD wFlags,
1446 ITypeInfo** ppTInfo,
1447 DESCKIND* pDescKind,
1448 BINDPTR* pBindPtr)
1449 {
1450 FIXME("not implemented\n");
1451 return E_FAIL;
1452 }
1453
1454 HRESULT __RPC_STUB ITypeComp_Bind_Stub(
1455 ITypeComp* This,
1456 LPOLESTR szName,
1457 ULONG lHashVal,
1458 WORD wFlags,
1459 ITypeInfo** ppTInfo,
1460 DESCKIND* pDescKind,
1461 LPFUNCDESC* ppFuncDesc,
1462 LPVARDESC* ppVarDesc,
1463 ITypeComp** ppTypeComp,
1464 CLEANLOCALSTORAGE* pDummy)
1465 {
1466 FIXME("not implemented\n");
1467 return E_FAIL;
1468 }
1469
1470 HRESULT CALLBACK ITypeComp_BindType_Proxy(
1471 ITypeComp* This,
1472 LPOLESTR szName,
1473 ULONG lHashVal,
1474 ITypeInfo** ppTInfo,
1475 ITypeComp** ppTComp)
1476 {
1477 FIXME("not implemented\n");
1478 return E_FAIL;
1479 }
1480
1481 HRESULT __RPC_STUB ITypeComp_BindType_Stub(
1482 ITypeComp* This,
1483 LPOLESTR szName,
1484 ULONG lHashVal,
1485 ITypeInfo** ppTInfo)
1486 {
1487 FIXME("not implemented\n");
1488 return E_FAIL;
1489 }
1490
1491 /* ITypeInfo */
1492
1493 HRESULT CALLBACK ITypeInfo_GetTypeAttr_Proxy(
1494 ITypeInfo* This,
1495 TYPEATTR** ppTypeAttr)
1496
1497 {
1498 CLEANLOCALSTORAGE stg;
1499 TRACE("(%p, %p)\n", This, ppTypeAttr);
1500
1501 stg.flags = 0;
1502 stg.pStorage = NULL;
1503 stg.pInterface = NULL;
1504
1505 return ITypeInfo_RemoteGetTypeAttr_Proxy(This, ppTypeAttr, &stg);
1506 }
1507
1508 HRESULT __RPC_STUB ITypeInfo_GetTypeAttr_Stub(
1509 ITypeInfo* This,
1510 LPTYPEATTR* ppTypeAttr,
1511 CLEANLOCALSTORAGE* pDummy)
1512 {
1513 HRESULT hr;
1514 TRACE("(%p, %p)\n", This, ppTypeAttr);
1515
1516 hr = ITypeInfo_GetTypeAttr(This, ppTypeAttr);
1517 if(hr != S_OK)
1518 return hr;
1519
1520 pDummy->flags = CLS_TYPEATTR;
1521 ITypeInfo_AddRef(This);
1522 pDummy->pInterface = (IUnknown*)This;
1523 pDummy->pStorage = ppTypeAttr;
1524 return hr;
1525 }
1526
1527 HRESULT CALLBACK ITypeInfo_GetFuncDesc_Proxy(
1528 ITypeInfo* This,
1529 UINT index,
1530 FUNCDESC** ppFuncDesc)
1531 {
1532 CLEANLOCALSTORAGE stg;
1533 TRACE("(%p, %d, %p)\n", This, index, ppFuncDesc);
1534
1535 stg.flags = 0;
1536 stg.pStorage = NULL;
1537 stg.pInterface = NULL;
1538
1539 return ITypeInfo_RemoteGetFuncDesc_Proxy(This, index, ppFuncDesc, &stg);
1540 }
1541
1542 HRESULT __RPC_STUB ITypeInfo_GetFuncDesc_Stub(
1543 ITypeInfo* This,
1544 UINT index,
1545 LPFUNCDESC* ppFuncDesc,
1546 CLEANLOCALSTORAGE* pDummy)
1547 {
1548 HRESULT hr;
1549 TRACE("(%p, %d, %p)\n", This, index, ppFuncDesc);
1550
1551 hr = ITypeInfo_GetFuncDesc(This, index, ppFuncDesc);
1552 if(hr != S_OK)
1553 return hr;
1554
1555 pDummy->flags = CLS_FUNCDESC;
1556 ITypeInfo_AddRef(This);
1557 pDummy->pInterface = (IUnknown*)This;
1558 pDummy->pStorage = ppFuncDesc;
1559 return hr;
1560 }
1561
1562 HRESULT CALLBACK ITypeInfo_GetVarDesc_Proxy(
1563 ITypeInfo* This,
1564 UINT index,
1565 VARDESC** ppVarDesc)
1566 {
1567 CLEANLOCALSTORAGE stg;
1568 TRACE("(%p, %d, %p)\n", This, index, ppVarDesc);
1569
1570 stg.flags = 0;
1571 stg.pStorage = NULL;
1572 stg.pInterface = NULL;
1573
1574 return ITypeInfo_RemoteGetVarDesc_Proxy(This, index, ppVarDesc, &stg);
1575 }
1576
1577 HRESULT __RPC_STUB ITypeInfo_GetVarDesc_Stub(
1578 ITypeInfo* This,
1579 UINT index,
1580 LPVARDESC* ppVarDesc,
1581 CLEANLOCALSTORAGE* pDummy)
1582 {
1583 HRESULT hr;
1584 TRACE("(%p, %d, %p)\n", This, index, ppVarDesc);
1585
1586 hr = ITypeInfo_GetVarDesc(This, index, ppVarDesc);
1587 if(hr != S_OK)
1588 return hr;
1589
1590 pDummy->flags = CLS_VARDESC;
1591 ITypeInfo_AddRef(This);
1592 pDummy->pInterface = (IUnknown*)This;
1593 pDummy->pStorage = ppVarDesc;
1594 return hr;
1595 }
1596
1597 HRESULT CALLBACK ITypeInfo_GetNames_Proxy(
1598 ITypeInfo* This,
1599 MEMBERID memid,
1600 BSTR* rgBstrNames,
1601 UINT cMaxNames,
1602 UINT* pcNames)
1603 {
1604 TRACE("(%p, %08x, %p, %d, %p)\n", This, memid, rgBstrNames, cMaxNames, pcNames);
1605
1606 return ITypeInfo_RemoteGetNames_Proxy(This, memid, rgBstrNames, cMaxNames, pcNames);
1607 }
1608
1609 HRESULT __RPC_STUB ITypeInfo_GetNames_Stub(
1610 ITypeInfo* This,
1611 MEMBERID memid,
1612 BSTR* rgBstrNames,
1613 UINT cMaxNames,
1614 UINT* pcNames)
1615 {
1616 TRACE("(%p, %08x, %p, %d, %p)\n", This, memid, rgBstrNames, cMaxNames, pcNames);
1617
1618 return ITypeInfo_GetNames(This, memid, rgBstrNames, cMaxNames, pcNames);
1619 }
1620
1621 HRESULT CALLBACK ITypeInfo_GetIDsOfNames_Proxy(
1622 ITypeInfo* This,
1623 LPOLESTR* rgszNames,
1624 UINT cNames,
1625 MEMBERID* pMemId)
1626 {
1627 FIXME("not implemented\n");
1628 return E_FAIL;
1629 }
1630
1631 HRESULT __RPC_STUB ITypeInfo_GetIDsOfNames_Stub(
1632 ITypeInfo* This)
1633 {
1634 FIXME("not implemented\n");
1635 return E_FAIL;
1636 }
1637
1638 HRESULT CALLBACK ITypeInfo_Invoke_Proxy(
1639 ITypeInfo* This,
1640 PVOID pvInstance,
1641 MEMBERID memid,
1642 WORD wFlags,
1643 DISPPARAMS* pDispParams,
1644 VARIANT* pVarResult,
1645 EXCEPINFO* pExcepInfo,
1646 UINT* puArgErr)
1647 {
1648 FIXME("not implemented\n");
1649 return E_FAIL;
1650 }
1651
1652 HRESULT __RPC_STUB ITypeInfo_Invoke_Stub(
1653 ITypeInfo* This)
1654 {
1655 FIXME("not implemented\n");
1656 return E_FAIL;
1657 }
1658
1659 HRESULT CALLBACK ITypeInfo_GetDocumentation_Proxy(ITypeInfo *This, MEMBERID memid,
1660 BSTR *name, BSTR *doc_string,
1661 DWORD *help_context, BSTR *help_file)
1662 {
1663 DWORD dummy_help_context, flags = 0;
1664 BSTR dummy_name, dummy_doc_string, dummy_help_file;
1665 HRESULT hr;
1666 TRACE("(%p, %08x, %p, %p, %p, %p)\n", This, memid, name, doc_string, help_context, help_file);
1667
1668 if(!name) name = &dummy_name;
1669 else flags = 1;
1670
1671 if(!doc_string) doc_string = &dummy_doc_string;
1672 else flags |= 2;
1673
1674 if(!help_context) help_context = &dummy_help_context;
1675 else flags |= 4;
1676
1677 if(!help_file) help_file = &dummy_help_file;
1678 else flags |= 8;
1679
1680 hr = ITypeInfo_RemoteGetDocumentation_Proxy(This, memid, flags, name, doc_string, help_context, help_file);
1681
1682 /* We don't need to free the dummy BSTRs since the stub ensures that these will be NULLs. */
1683
1684 return hr;
1685 }
1686
1687 HRESULT __RPC_STUB ITypeInfo_GetDocumentation_Stub(ITypeInfo *This, MEMBERID memid,
1688 DWORD flags, BSTR *name, BSTR *doc_string,
1689 DWORD *help_context, BSTR *help_file)
1690 {
1691 TRACE("(%p, %08x, %08x, %p, %p, %p, %p)\n", This, memid, flags, name, doc_string, help_context, help_file);
1692
1693 *name = *doc_string = *help_file = NULL;
1694 *help_context = 0;
1695
1696 if(!(flags & 1)) name = NULL;
1697 if(!(flags & 2)) doc_string = NULL;
1698 if(!(flags & 4)) help_context = NULL;
1699 if(!(flags & 8)) help_file = NULL;
1700
1701 return ITypeInfo_GetDocumentation(This, memid, name, doc_string, help_context, help_file);
1702 }
1703
1704 HRESULT CALLBACK ITypeInfo_GetDllEntry_Proxy(ITypeInfo *This, MEMBERID memid,
1705 INVOKEKIND invkind, BSTR *dll_name,
1706 BSTR* name, WORD *ordinal)
1707 {
1708 DWORD flags = 0;
1709 BSTR dummy_dll_name, dummy_name;
1710 WORD dummy_ordinal;
1711 HRESULT hr;
1712 TRACE("(%p, %08x, %x, %p, %p, %p)\n", This, memid, invkind, dll_name, name, ordinal);
1713
1714 if(!dll_name) dll_name = &dummy_dll_name;
1715 else flags = 1;
1716
1717 if(!name) name = &dummy_name;
1718 else flags |= 2;
1719
1720 if(!ordinal) ordinal = &dummy_ordinal;
1721 else flags |= 4;
1722
1723 hr = ITypeInfo_RemoteGetDllEntry_Proxy(This, memid, invkind, flags, dll_name, name, ordinal);
1724
1725 /* We don't need to free the dummy BSTRs since the stub ensures that these will be NULLs. */
1726
1727 return hr;
1728 }
1729
1730 HRESULT __RPC_STUB ITypeInfo_GetDllEntry_Stub(ITypeInfo *This, MEMBERID memid,
1731 INVOKEKIND invkind, DWORD flags,
1732 BSTR *dll_name, BSTR *name,
1733 WORD *ordinal)
1734 {
1735 TRACE("(%p, %08x, %x, %p, %p, %p)\n", This, memid, invkind, dll_name, name, ordinal);
1736
1737 *dll_name = *name = NULL;
1738 *ordinal = 0;
1739
1740 if(!(flags & 1)) dll_name = NULL;
1741 if(!(flags & 2)) name = NULL;
1742 if(!(flags & 4)) ordinal = NULL;
1743
1744 return ITypeInfo_GetDllEntry(This, memid, invkind, dll_name, name, ordinal);
1745 }
1746
1747 HRESULT CALLBACK ITypeInfo_AddressOfMember_Proxy(
1748 ITypeInfo* This,
1749 MEMBERID memid,
1750 INVOKEKIND invKind,
1751 PVOID* ppv)
1752 {
1753 FIXME("not implemented\n");
1754 return E_FAIL;
1755 }
1756
1757 HRESULT __RPC_STUB ITypeInfo_AddressOfMember_Stub(
1758 ITypeInfo* This)
1759 {
1760 FIXME("not implemented\n");
1761 return E_FAIL;
1762 }
1763
1764 HRESULT CALLBACK ITypeInfo_CreateInstance_Proxy(
1765 ITypeInfo* This,
1766 IUnknown* pUnkOuter,
1767 REFIID riid,
1768 PVOID* ppvObj)
1769 {
1770 FIXME("not implemented\n");
1771 return E_FAIL;
1772 }
1773
1774 HRESULT __RPC_STUB ITypeInfo_CreateInstance_Stub(
1775 ITypeInfo* This,
1776 REFIID riid,
1777 IUnknown** ppvObj)
1778 {
1779 FIXME("not implemented\n");
1780 return E_FAIL;
1781 }
1782
1783 HRESULT CALLBACK ITypeInfo_GetContainingTypeLib_Proxy(
1784 ITypeInfo* This,
1785 ITypeLib** ppTLib,
1786 UINT* pIndex)
1787 {
1788 ITypeLib *pTL;
1789 UINT index;
1790 HRESULT hr;
1791
1792 TRACE("(%p, %p, %p)\n", This, ppTLib, pIndex );
1793
1794 hr = ITypeInfo_RemoteGetContainingTypeLib_Proxy(This, &pTL, &index);
1795 if(SUCCEEDED(hr))
1796 {
1797 if(pIndex)
1798 *pIndex = index;
1799
1800 if(ppTLib)
1801 *ppTLib = pTL;
1802 else
1803 ITypeLib_Release(pTL);
1804 }
1805 return hr;
1806 }
1807
1808 HRESULT __RPC_STUB ITypeInfo_GetContainingTypeLib_Stub(
1809 ITypeInfo* This,
1810 ITypeLib** ppTLib,
1811 UINT* pIndex)
1812 {
1813 TRACE("(%p, %p, %p)\n", This, ppTLib, pIndex );
1814 return ITypeInfo_GetContainingTypeLib(This, ppTLib, pIndex);
1815 }
1816
1817 void CALLBACK ITypeInfo_ReleaseTypeAttr_Proxy(
1818 ITypeInfo* This,
1819 TYPEATTR* pTypeAttr)
1820 {
1821 TRACE("(%p, %p)\n", This, pTypeAttr);
1822 free_embedded_typedesc(&pTypeAttr->tdescAlias);
1823 CoTaskMemFree(pTypeAttr);
1824 }
1825
1826 HRESULT __RPC_STUB ITypeInfo_ReleaseTypeAttr_Stub(
1827 ITypeInfo* This)
1828 {
1829 TRACE("nothing to do\n");
1830 return S_OK;
1831 }
1832
1833 void CALLBACK ITypeInfo_ReleaseFuncDesc_Proxy(
1834 ITypeInfo* This,
1835 FUNCDESC* pFuncDesc)
1836 {
1837 SHORT param;
1838 TRACE("(%p, %p)\n", This, pFuncDesc);
1839
1840 for(param = 0; param < pFuncDesc->cParams; param++)
1841 free_embedded_elemdesc(pFuncDesc->lprgelemdescParam + param);
1842 if(param)
1843 CoTaskMemFree(pFuncDesc->lprgelemdescParam);
1844
1845 free_embedded_elemdesc(&pFuncDesc->elemdescFunc);
1846
1847 if(pFuncDesc->cScodes != 0 && pFuncDesc->cScodes != -1)
1848 CoTaskMemFree(pFuncDesc->lprgscode);
1849
1850 CoTaskMemFree(pFuncDesc);
1851 }
1852
1853 HRESULT __RPC_STUB ITypeInfo_ReleaseFuncDesc_Stub(
1854 ITypeInfo* This)
1855 {
1856 TRACE("nothing to do\n");
1857 return S_OK;
1858 }
1859
1860 void CALLBACK ITypeInfo_ReleaseVarDesc_Proxy(
1861 ITypeInfo* This,
1862 VARDESC* pVarDesc)
1863 {
1864 TRACE("(%p, %p)\n", This, pVarDesc);
1865
1866 CoTaskMemFree(pVarDesc->lpstrSchema);
1867
1868 if(pVarDesc->varkind == VAR_CONST)
1869 CoTaskMemFree(pVarDesc->u.lpvarValue);
1870
1871 free_embedded_elemdesc(&pVarDesc->elemdescVar);
1872 CoTaskMemFree(pVarDesc);
1873 }
1874
1875 HRESULT __RPC_STUB ITypeInfo_ReleaseVarDesc_Stub(
1876 ITypeInfo* This)
1877 {
1878 TRACE("nothing to do\n");
1879 return S_OK;
1880 }
1881
1882
1883 /* ITypeInfo2 */
1884
1885 HRESULT CALLBACK ITypeInfo2_GetDocumentation2_Proxy(ITypeInfo2 *This, MEMBERID memid,
1886 LCID lcid, BSTR *help_string,
1887 DWORD *help_context, BSTR *help_dll)
1888 {
1889 DWORD dummy_help_context, flags = 0;
1890 BSTR dummy_help_string, dummy_help_dll;
1891 HRESULT hr;
1892 TRACE("(%p, %08x, %08x, %p, %p, %p)\n", This, memid, lcid, help_string, help_context, help_dll);
1893
1894 if(!help_string) help_string = &dummy_help_string;
1895 else flags = 1;
1896
1897 if(!help_context) help_context = &dummy_help_context;
1898 else flags |= 2;
1899
1900 if(!help_dll) help_dll = &dummy_help_dll;
1901 else flags |= 4;
1902
1903 hr = ITypeInfo2_RemoteGetDocumentation2_Proxy(This, memid, lcid, flags, help_string, help_context, help_dll);
1904
1905 /* We don't need to free the dummy BSTRs since the stub ensures that these will be NULLs. */
1906
1907 return hr;
1908 }
1909
1910 HRESULT __RPC_STUB ITypeInfo2_GetDocumentation2_Stub(ITypeInfo2 *This, MEMBERID memid,
1911 LCID lcid, DWORD flags,
1912 BSTR *help_string, DWORD *help_context,
1913 BSTR *help_dll)
1914 {
1915 TRACE("(%p, %08x, %08x, %08x, %p, %p, %p)\n", This, memid, lcid, flags, help_string, help_context, help_dll);
1916
1917 *help_string = *help_dll = NULL;
1918 *help_context = 0;
1919
1920 if(!(flags & 1)) help_string = NULL;
1921 if(!(flags & 2)) help_context = NULL;
1922 if(!(flags & 4)) help_dll = NULL;
1923
1924 return ITypeInfo2_GetDocumentation2(This, memid, lcid, help_string, help_context, help_dll);
1925 }
1926
1927 /* ITypeLib */
1928
1929 UINT CALLBACK ITypeLib_GetTypeInfoCount_Proxy(
1930 ITypeLib* This)
1931 {
1932 UINT count = 0;
1933 TRACE("(%p)\n", This);
1934
1935 ITypeLib_RemoteGetTypeInfoCount_Proxy(This, &count);
1936
1937 return count;
1938 }
1939
1940 HRESULT __RPC_STUB ITypeLib_GetTypeInfoCount_Stub(
1941 ITypeLib* This,
1942 UINT* pcTInfo)
1943 {
1944 TRACE("(%p, %p)\n", This, pcTInfo);
1945 *pcTInfo = ITypeLib_GetTypeInfoCount(This);
1946 return S_OK;
1947 }
1948
1949 HRESULT CALLBACK ITypeLib_GetLibAttr_Proxy(
1950 ITypeLib* This,
1951 TLIBATTR** ppTLibAttr)
1952 {
1953 CLEANLOCALSTORAGE stg;
1954 TRACE("(%p, %p)\n", This, ppTLibAttr);
1955
1956 stg.flags = 0;
1957 stg.pStorage = NULL;
1958 stg.pInterface = NULL;
1959
1960 return ITypeLib_RemoteGetLibAttr_Proxy(This, ppTLibAttr, &stg);
1961 }
1962
1963 HRESULT __RPC_STUB ITypeLib_GetLibAttr_Stub(
1964 ITypeLib* This,
1965 LPTLIBATTR* ppTLibAttr,
1966 CLEANLOCALSTORAGE* pDummy)
1967 {
1968 HRESULT hr;
1969 TRACE("(%p, %p)\n", This, ppTLibAttr);
1970
1971 hr = ITypeLib_GetLibAttr(This, ppTLibAttr);
1972 if(hr != S_OK)
1973 return hr;
1974
1975 pDummy->flags = CLS_LIBATTR;
1976 ITypeLib_AddRef(This);
1977 pDummy->pInterface = (IUnknown*)This;
1978 pDummy->pStorage = ppTLibAttr;
1979 return hr;
1980 }
1981
1982 HRESULT CALLBACK ITypeLib_GetDocumentation_Proxy(ITypeLib *This, INT index, BSTR *name,
1983 BSTR *doc_string, DWORD *help_context,
1984 BSTR *help_file)
1985 {
1986 DWORD dummy_help_context, flags = 0;
1987 BSTR dummy_name, dummy_doc_string, dummy_help_file;
1988 HRESULT hr;
1989 TRACE("(%p, %d, %p, %p, %p, %p)\n", This, index, name, doc_string, help_context, help_file);
1990
1991 if(!name) name = &dummy_name;
1992 else flags = 1;
1993
1994 if(!doc_string) doc_string = &dummy_doc_string;
1995 else flags |= 2;
1996
1997 if(!help_context) help_context = &dummy_help_context;
1998 else flags |= 4;
1999
2000 if(!help_file) help_file = &dummy_help_file;
2001 else flags |= 8;
2002
2003 hr = ITypeLib_RemoteGetDocumentation_Proxy(This, index, flags, name, doc_string, help_context, help_file);
2004
2005 /* We don't need to free the dummy BSTRs since the stub ensures that these will be NULLs. */
2006
2007 return hr;
2008 }
2009
2010 HRESULT __RPC_STUB ITypeLib_GetDocumentation_Stub(ITypeLib *This, INT index, DWORD flags,
2011 BSTR *name, BSTR *doc_string,
2012 DWORD *help_context, BSTR *help_file)
2013 {
2014 TRACE("(%p, %d, %08x, %p, %p, %p, %p)\n", This, index, flags, name, doc_string, help_context, help_file);
2015
2016 *name = *doc_string = *help_file = NULL;
2017 *help_context = 0;
2018
2019 if(!(flags & 1)) name = NULL;
2020 if(!(flags & 2)) doc_string = NULL;
2021 if(!(flags & 4)) help_context = NULL;
2022 if(!(flags & 8)) help_file = NULL;
2023
2024 return ITypeLib_GetDocumentation(This, index, name, doc_string, help_context, help_file);
2025 }
2026
2027 HRESULT CALLBACK ITypeLib_IsName_Proxy(
2028 ITypeLib* This,
2029 LPOLESTR szNameBuf,
2030 ULONG lHashVal,
2031 BOOL* pfName)
2032 {
2033 FIXME("not implemented\n");
2034 return E_FAIL;
2035 }
2036
2037 HRESULT __RPC_STUB ITypeLib_IsName_Stub(
2038 ITypeLib* This,
2039 LPOLESTR szNameBuf,
2040 ULONG lHashVal,
2041 BOOL* pfName,
2042 BSTR* pBstrLibName)
2043 {
2044 FIXME("not implemented\n");
2045 return E_FAIL;
2046 }
2047
2048 HRESULT CALLBACK ITypeLib_FindName_Proxy(
2049 ITypeLib* This,
2050 LPOLESTR szNameBuf,
2051 ULONG lHashVal,
2052 ITypeInfo** ppTInfo,
2053 MEMBERID* rgMemId,
2054 USHORT* pcFound)
2055 {
2056 FIXME("not implemented\n");
2057 return E_FAIL;
2058 }
2059
2060 HRESULT __RPC_STUB ITypeLib_FindName_Stub(
2061 ITypeLib* This,
2062 LPOLESTR szNameBuf,
2063 ULONG lHashVal,
2064 ITypeInfo** ppTInfo,
2065 MEMBERID* rgMemId,
2066 USHORT* pcFound,
2067 BSTR* pBstrLibName)
2068 {
2069 FIXME("not implemented\n");
2070 return E_FAIL;
2071 }
2072
2073 void CALLBACK ITypeLib_ReleaseTLibAttr_Proxy(
2074 ITypeLib* This,
2075 TLIBATTR* pTLibAttr)
2076 {
2077 TRACE("(%p, %p)\n", This, pTLibAttr);
2078 CoTaskMemFree(pTLibAttr);
2079 }
2080
2081 HRESULT __RPC_STUB ITypeLib_ReleaseTLibAttr_Stub(
2082 ITypeLib* This)
2083 {
2084 TRACE("nothing to do\n");
2085 return S_OK;
2086 }
2087
2088
2089 /* ITypeLib2 */
2090
2091 HRESULT CALLBACK ITypeLib2_GetLibStatistics_Proxy(
2092 ITypeLib2* This,
2093 ULONG* pcUniqueNames,
2094 ULONG* pcchUniqueNames)
2095 {
2096 FIXME("not implemented\n");
2097 return E_FAIL;
2098 }
2099
2100 HRESULT __RPC_STUB ITypeLib2_GetLibStatistics_Stub(
2101 ITypeLib2* This,
2102 ULONG* pcUniqueNames,
2103 ULONG* pcchUniqueNames)
2104 {
2105 FIXME("not implemented\n");
2106 return E_FAIL;
2107 }
2108
2109 HRESULT CALLBACK ITypeLib2_GetDocumentation2_Proxy(ITypeLib2 *This, INT index,
2110 LCID lcid, BSTR *help_string,
2111 DWORD *help_context, BSTR *help_dll)
2112 {
2113 DWORD dummy_help_context, flags = 0;
2114 BSTR dummy_help_string, dummy_help_dll;
2115 HRESULT hr;
2116 TRACE("(%p, %d, %08x, %p, %p, %p)\n", This, index, lcid, help_string, help_context, help_dll);
2117
2118 if(!help_string) help_string = &dummy_help_string;
2119 else flags = 1;
2120
2121 if(!help_context) help_context = &dummy_help_context;
2122 else flags |= 2;
2123
2124 if(!help_dll) help_dll = &dummy_help_dll;
2125 else flags |= 4;
2126
2127 hr = ITypeLib2_RemoteGetDocumentation2_Proxy(This, index, lcid, flags, help_string, help_context, help_dll);
2128
2129 /* We don't need to free the dummy BSTRs since the stub ensures that these will be NULLs. */
2130
2131 return hr;
2132 }
2133
2134 HRESULT __RPC_STUB ITypeLib2_GetDocumentation2_Stub(ITypeLib2 *This, INT index, LCID lcid,
2135 DWORD flags, BSTR *help_string,
2136 DWORD *help_context, BSTR *help_dll)
2137 {
2138 TRACE("(%p, %d, %08x, %08x, %p, %p, %p)\n", This, index, lcid, flags, help_string, help_context, help_dll);
2139
2140 *help_string = *help_dll = NULL;
2141 *help_context = 0;
2142
2143 if(!(flags & 1)) help_string = NULL;
2144 if(!(flags & 2)) help_context = NULL;
2145 if(!(flags & 4)) help_dll = NULL;
2146
2147 return ITypeLib2_GetDocumentation2(This, index, lcid, help_string, help_context, help_dll);
2148 }
2149
2150 HRESULT CALLBACK IPropertyBag_Read_Proxy(
2151 IPropertyBag* This,
2152 LPCOLESTR pszPropName,
2153 VARIANT *pVar,
2154 IErrorLog *pErrorLog)
2155 {
2156 IUnknown *pUnk = NULL;
2157 TRACE("(%p, %s, %p, %p)\n", This, debugstr_w(pszPropName), pVar, pErrorLog);
2158
2159 if(!pVar)
2160 return E_POINTER;
2161
2162 if(V_VT(pVar) & (VT_BYREF | VT_ARRAY | VT_VECTOR))
2163 {
2164 FIXME("Variant type %x is byref, array or vector. Not implemented.\n", V_VT(pVar));
2165 return E_NOTIMPL;
2166 }
2167
2168 switch(V_VT(pVar))
2169 {
2170 case VT_DISPATCH:
2171 pUnk = (IUnknown*)V_DISPATCH(pVar);
2172 break;
2173 case VT_UNKNOWN:
2174 pUnk = V_UNKNOWN(pVar);
2175 break;
2176 case VT_SAFEARRAY:
2177 FIXME("Safearray support not yet implemented.\n");
2178 return E_NOTIMPL;
2179 default:
2180 FIXME("Unknown V_VT %d - support not yet implemented.\n", V_VT(pVar));
2181 return E_NOTIMPL;
2182 }
2183
2184 return IPropertyBag_RemoteRead_Proxy(This, pszPropName, pVar, pErrorLog,
2185 V_VT(pVar), pUnk);
2186 }
2187
2188 HRESULT __RPC_STUB IPropertyBag_Read_Stub(
2189 IPropertyBag* This,
2190 LPCOLESTR pszPropName,
2191 VARIANT *pVar,
2192 IErrorLog *pErrorLog,
2193 DWORD varType,
2194 IUnknown *pUnkObj)
2195 {
2196 static const WCHAR emptyWstr[] = {0};
2197 IDispatch *disp;
2198 HRESULT hr;
2199 TRACE("(%p, %s, %p, %p, %x, %p)\n", This, debugstr_w(pszPropName), pVar,
2200 pErrorLog, varType, pUnkObj);
2201
2202 if(varType & (VT_BYREF | VT_ARRAY | VT_VECTOR))
2203 {
2204 FIXME("Variant type %x is byref, array or vector. Not implemented.\n", V_VT(pVar));
2205 return E_NOTIMPL;
2206 }
2207
2208 V_VT(pVar) = varType;
2209 switch(varType)
2210 {
2211 case VT_DISPATCH:
2212 hr = IUnknown_QueryInterface(pUnkObj, &IID_IDispatch, (LPVOID*)&disp);
2213 if(FAILED(hr))
2214 return hr;
2215 IUnknown_Release(pUnkObj);
2216 V_DISPATCH(pVar) = disp;
2217 break;
2218 case VT_UNKNOWN:
2219 V_UNKNOWN(pVar) = pUnkObj;
2220 break;
2221 case VT_BSTR:
2222 V_BSTR(pVar) = SysAllocString(emptyWstr);
2223 break;
2224 case VT_SAFEARRAY:
2225 FIXME("Safearray support not yet implemented.\n");
2226 return E_NOTIMPL;
2227 default:
2228 break;
2229 }
2230 hr = IPropertyBag_Read(This, pszPropName, pVar, pErrorLog);
2231 if(FAILED(hr))
2232 VariantClear(pVar);
2233
2234 return hr;
2235 }
2236
2237 /* call_as/local stubs for ocidl.idl */
2238
2239 HRESULT CALLBACK IClassFactory2_CreateInstanceLic_Proxy(
2240 IClassFactory2* This,
2241 IUnknown *pUnkOuter,
2242 IUnknown *pUnkReserved,
2243 REFIID riid,
2244 BSTR bstrKey,
2245 PVOID *ppvObj)
2246 {
2247 TRACE("(%p, %s, %p)\n", pUnkOuter, debugstr_guid(riid), ppvObj);
2248
2249 *ppvObj = NULL;
2250
2251 if (pUnkOuter)
2252 {
2253 ERR("aggregation is not allowed on remote objects\n");
2254 return CLASS_E_NOAGGREGATION;
2255 }
2256
2257 return IClassFactory2_RemoteCreateInstanceLic_Proxy(This, riid, bstrKey, (IUnknown**)ppvObj);
2258 }
2259
2260 HRESULT __RPC_STUB IClassFactory2_CreateInstanceLic_Stub(
2261 IClassFactory2* This,
2262 REFIID riid,
2263 BSTR bstrKey,
2264 IUnknown **ppvObj)
2265 {
2266 TRACE("(%s, %p)\n", debugstr_guid(riid), ppvObj);
2267 return IClassFactory2_CreateInstanceLic(This, NULL, NULL, riid, bstrKey, (void**)ppvObj);
2268 }
2269
2270 HRESULT CALLBACK IEnumConnections_Next_Proxy(
2271 IEnumConnections* This,
2272 ULONG cConnections,
2273 LPCONNECTDATA rgcd,
2274 ULONG *pcFetched)
2275 {
2276 FIXME("not implemented\n");
2277 return E_NOTIMPL;
2278 }
2279
2280 HRESULT __RPC_STUB IEnumConnections_Next_Stub(
2281 IEnumConnections* This,
2282 ULONG cConnections,
2283 LPCONNECTDATA rgcd,
2284 ULONG *pcFetched)
2285 {
2286 FIXME("not implemented\n");
2287 return E_NOTIMPL;
2288 }
2289
2290 HRESULT CALLBACK IEnumConnectionPoints_Next_Proxy(
2291 IEnumConnectionPoints* This,
2292 ULONG cConnections,
2293 LPCONNECTIONPOINT *ppCP,
2294 ULONG *pcFetched)
2295 {
2296 FIXME("not implemented\n");
2297 return E_NOTIMPL;
2298 }
2299
2300 HRESULT __RPC_STUB IEnumConnectionPoints_Next_Stub(
2301 IEnumConnectionPoints* This,
2302 ULONG cConnections,
2303 LPCONNECTIONPOINT *ppCP,
2304 ULONG *pcFetched)
2305 {
2306 FIXME("not implemented\n");
2307 return E_NOTIMPL;
2308 }
2309
2310 HRESULT CALLBACK IPersistMemory_Load_Proxy(
2311 IPersistMemory* This,
2312 LPVOID pMem,
2313 ULONG cbSize)
2314 {
2315 FIXME("not implemented\n");
2316 return E_NOTIMPL;
2317 }
2318
2319 HRESULT __RPC_STUB IPersistMemory_Load_Stub(
2320 IPersistMemory* This,
2321 BYTE *pMem,
2322 ULONG cbSize)
2323 {
2324 FIXME("not implemented\n");
2325 return E_NOTIMPL;
2326 }
2327
2328 HRESULT CALLBACK IPersistMemory_Save_Proxy(
2329 IPersistMemory* This,
2330 LPVOID pMem,
2331 BOOL fClearDirty,
2332 ULONG cbSize)
2333 {
2334 FIXME("not implemented\n");
2335 return E_NOTIMPL;
2336 }
2337
2338 HRESULT __RPC_STUB IPersistMemory_Save_Stub(
2339 IPersistMemory* This,
2340 BYTE *pMem,
2341 BOOL fClearDirty,
2342 ULONG cbSize)
2343 {
2344 FIXME("not implemented\n");
2345 return E_NOTIMPL;
2346 }
2347
2348 void CALLBACK IAdviseSinkEx_OnViewStatusChange_Proxy(
2349 IAdviseSinkEx* This,
2350 DWORD dwViewStatus)
2351 {
2352 FIXME("not implemented\n");
2353 }
2354
2355 HRESULT __RPC_STUB IAdviseSinkEx_OnViewStatusChange_Stub(
2356 IAdviseSinkEx* This,
2357 DWORD dwViewStatus)
2358 {
2359 FIXME("not implemented\n");
2360 return E_NOTIMPL;
2361 }
2362
2363 HRESULT CALLBACK IEnumOleUndoUnits_Next_Proxy(
2364 IEnumOleUndoUnits* This,
2365 ULONG cElt,
2366 IOleUndoUnit **rgElt,
2367 ULONG *pcEltFetched)
2368 {
2369 FIXME("not implemented\n");
2370 return E_NOTIMPL;
2371 }
2372
2373 HRESULT __RPC_STUB IEnumOleUndoUnits_Next_Stub(
2374 IEnumOleUndoUnits* This,
2375 ULONG cElt,
2376 IOleUndoUnit **rgElt,
2377 ULONG *pcEltFetched)
2378 {
2379 FIXME("not implemented\n");
2380 return E_NOTIMPL;
2381 }
2382
2383 HRESULT CALLBACK IQuickActivate_QuickActivate_Proxy(
2384 IQuickActivate* This,
2385 QACONTAINER *pQaContainer,
2386 QACONTROL *pQaControl)
2387 {
2388 FIXME("not implemented\n");
2389 return E_NOTIMPL;
2390 }
2391
2392 HRESULT __RPC_STUB IQuickActivate_QuickActivate_Stub(
2393 IQuickActivate* This,
2394 QACONTAINER *pQaContainer,
2395 QACONTROL *pQaControl)
2396 {
2397 FIXME("not implemented\n");
2398 return E_NOTIMPL;
2399 }
Maarten's multimedia branch