?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
oleaut: Reduce an ERR down to a WARN since a NULL interface pointer
[wine/multimedia.git] / dlls / oleaut32 / tmarshal.c
blobe4fafa294f476deb8e4489286f8ad90fc7233336
1 /*
2 * TYPELIB Marshaler
3 *
4 * Copyright 2002,2005 Marcus Meissner
5 *
6 * The olerelay debug channel allows you to see calls marshalled by
7 * the typelib marshaller. It is not a generic COM relaying system.
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23
24 #include "config.h"
25
26 #include <assert.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <stdarg.h>
30 #include <stdio.h>
31 #include <ctype.h>
32
33 #define COBJMACROS
34 #define NONAMELESSUNION
35 #define NONAMELESSSTRUCT
36
37 #include "winerror.h"
38 #include "windef.h"
39 #include "winbase.h"
40 #include "winnls.h"
41 #include "winreg.h"
42 #include "winuser.h"
43
44 #include "ole2.h"
45 #include "typelib.h"
46 #include "wine/debug.h"
47
48 static const WCHAR IDispatchW[] = { 'I','D','i','s','p','a','t','c','h',0};
49
50 WINE_DEFAULT_DEBUG_CHANNEL(ole);
51 WINE_DECLARE_DEBUG_CHANNEL(olerelay);
52
53 #define ICOM_THIS_MULTI(impl,field,iface) impl* const This=(impl*)((char*)(iface) - offsetof(impl,field))
54
55 typedef struct _marshal_state {
56 LPBYTE base;
57 int size;
58 int curoff;
59 } marshal_state;
60
61 /* used in the olerelay code to avoid having the L"" stuff added by debugstr_w */
62 static char *relaystr(WCHAR *in) {
63 char *tmp = (char *)debugstr_w(in);
64 tmp += 2;
65 tmp[strlen(tmp)-1] = '\0';
66 return tmp;
67 }
68
69 static HRESULT
70 xbuf_add(marshal_state *buf, LPBYTE stuff, DWORD size) {
71 while (buf->size - buf->curoff < size) {
72 if (buf->base) {
73 buf->size += 100;
74 buf->base = HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,buf->base,buf->size);
75 if (!buf->base)
76 return E_OUTOFMEMORY;
77 } else {
78 buf->base = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,32);
79 buf->size = 32;
80 if (!buf->base)
81 return E_OUTOFMEMORY;
82 }
83 }
84 memcpy(buf->base+buf->curoff,stuff,size);
85 buf->curoff += size;
86 return S_OK;
87 }
88
89 static HRESULT
90 xbuf_get(marshal_state *buf, LPBYTE stuff, DWORD size) {
91 if (buf->size < buf->curoff+size) return E_FAIL;
92 memcpy(stuff,buf->base+buf->curoff,size);
93 buf->curoff += size;
94 return S_OK;
95 }
96
97 static HRESULT
98 xbuf_skip(marshal_state *buf, DWORD size) {
99 if (buf->size < buf->curoff+size) return E_FAIL;
100 buf->curoff += size;
101 return S_OK;
102 }
103
104 static HRESULT
105 _unmarshal_interface(marshal_state *buf, REFIID riid, LPUNKNOWN *pUnk) {
106 IStream *pStm;
107 ULARGE_INTEGER newpos;
108 LARGE_INTEGER seekto;
109 ULONG res;
110 HRESULT hres;
111 DWORD xsize;
112
113 TRACE("...%s...\n",debugstr_guid(riid));
114
115 *pUnk = NULL;
116 hres = xbuf_get(buf,(LPBYTE)&xsize,sizeof(xsize));
117 if (hres) {
118 ERR("xbuf_get failed\n");
119 return hres;
120 }
121
122 if (xsize == 0) return S_OK;
123
124 hres = CreateStreamOnHGlobal(0,TRUE,&pStm);
125 if (hres) {
126 ERR("Stream create failed %lx\n",hres);
127 return hres;
128 }
129
130 hres = IStream_Write(pStm,buf->base+buf->curoff,xsize,&res);
131 if (hres) {
132 ERR("stream write %lx\n",hres);
133 return hres;
134 }
135
136 memset(&seekto,0,sizeof(seekto));
137 hres = IStream_Seek(pStm,seekto,SEEK_SET,&newpos);
138 if (hres) {
139 ERR("Failed Seek %lx\n",hres);
140 return hres;
141 }
142
143 hres = CoUnmarshalInterface(pStm,riid,(LPVOID*)pUnk);
144 if (hres) {
145 ERR("Unmarshalling interface %s failed with %lx\n",debugstr_guid(riid),hres);
146 return hres;
147 }
148
149 IStream_Release(pStm);
150 return xbuf_skip(buf,xsize);
151 }
152
153 static HRESULT
154 _marshal_interface(marshal_state *buf, REFIID riid, LPUNKNOWN pUnk) {
155 LPBYTE tempbuf = NULL;
156 IStream *pStm = NULL;
157 STATSTG ststg;
158 ULARGE_INTEGER newpos;
159 LARGE_INTEGER seekto;
160 ULONG res;
161 DWORD xsize;
162 HRESULT hres;
163
164 if (!pUnk) {
165 /* this is valid, if for instance we serialize
166 * a VT_DISPATCH with NULL ptr which apparently
167 * can happen. S_OK to make sure we continue
168 * serializing.
169 */
170 WARN("pUnk is NULL\n");
171 xsize = 0;
172 return xbuf_add(buf,(LPBYTE)&xsize,sizeof(xsize));
173 }
174
175 hres = E_FAIL;
176
177 TRACE("...%s...\n",debugstr_guid(riid));
178
179 hres = CreateStreamOnHGlobal(0,TRUE,&pStm);
180 if (hres) {
181 ERR("Stream create failed %lx\n",hres);
182 goto fail;
183 }
184
185 hres = CoMarshalInterface(pStm,riid,pUnk,0,NULL,0);
186 if (hres) {
187 ERR("Marshalling interface %s failed with %lx\n", debugstr_guid(riid), hres);
188 goto fail;
189 }
190
191 hres = IStream_Stat(pStm,&ststg,0);
192 if (hres) {
193 ERR("Stream stat failed\n");
194 goto fail;
195 }
196
197 tempbuf = HeapAlloc(GetProcessHeap(), 0, ststg.cbSize.u.LowPart);
198 memset(&seekto,0,sizeof(seekto));
199 hres = IStream_Seek(pStm,seekto,SEEK_SET,&newpos);
200 if (hres) {
201 ERR("Failed Seek %lx\n",hres);
202 goto fail;
203 }
204
205 hres = IStream_Read(pStm,tempbuf,ststg.cbSize.u.LowPart,&res);
206 if (hres) {
207 ERR("Failed Read %lx\n",hres);
208 goto fail;
209 }
210
211 xsize = ststg.cbSize.u.LowPart;
212 xbuf_add(buf,(LPBYTE)&xsize,sizeof(xsize));
213 hres = xbuf_add(buf,tempbuf,ststg.cbSize.u.LowPart);
214
215 HeapFree(GetProcessHeap(),0,tempbuf);
216 IStream_Release(pStm);
217
218 return hres;
219
220 fail:
221 xsize = 0;
222 xbuf_add(buf,(LPBYTE)&xsize,sizeof(xsize));
223 if (pStm) IUnknown_Release(pStm);
224 HeapFree(GetProcessHeap(), 0, tempbuf);
225 return hres;
226 }
227
228 /********************* OLE Proxy/Stub Factory ********************************/
229 static HRESULT WINAPI
230 PSFacBuf_QueryInterface(LPPSFACTORYBUFFER iface, REFIID iid, LPVOID *ppv) {
231 if (IsEqualIID(iid,&IID_IPSFactoryBuffer)||IsEqualIID(iid,&IID_IUnknown)) {
232 *ppv = (LPVOID)iface;
233 /* No ref counting, static class */
234 return S_OK;
235 }
236 FIXME("(%s) unknown IID?\n",debugstr_guid(iid));
237 return E_NOINTERFACE;
238 }
239
240 static ULONG WINAPI PSFacBuf_AddRef(LPPSFACTORYBUFFER iface) { return 2; }
241 static ULONG WINAPI PSFacBuf_Release(LPPSFACTORYBUFFER iface) { return 1; }
242
243 static HRESULT
244 _get_typeinfo_for_iid(REFIID riid, ITypeInfo**ti) {
245 HRESULT hres;
246 HKEY ikey;
247 char tlguid[200],typelibkey[300],interfacekey[300],ver[100];
248 char tlfn[260];
249 OLECHAR tlfnW[260];
250 DWORD tlguidlen, verlen, type;
251 LONG tlfnlen;
252 ITypeLib *tl;
253
254 sprintf( interfacekey, "Interface\\{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}\\Typelib",
255 riid->Data1, riid->Data2, riid->Data3,
256 riid->Data4[0], riid->Data4[1], riid->Data4[2], riid->Data4[3],
257 riid->Data4[4], riid->Data4[5], riid->Data4[6], riid->Data4[7]
258 );
259
260 if (RegOpenKeyA(HKEY_CLASSES_ROOT,interfacekey,&ikey)) {
261 ERR("No %s key found.\n",interfacekey);
262 return E_FAIL;
263 }
264 type = (1<<REG_SZ);
265 tlguidlen = sizeof(tlguid);
266 if (RegQueryValueExA(ikey,NULL,NULL,&type,(LPBYTE)tlguid,&tlguidlen)) {
267 ERR("Getting typelib guid failed.\n");
268 RegCloseKey(ikey);
269 return E_FAIL;
270 }
271 type = (1<<REG_SZ);
272 verlen = sizeof(ver);
273 if (RegQueryValueExA(ikey,"Version",NULL,&type,(LPBYTE)ver,&verlen)) {
274 ERR("Could not get version value?\n");
275 RegCloseKey(ikey);
276 return E_FAIL;
277 }
278 RegCloseKey(ikey);
279 sprintf(typelibkey,"Typelib\\%s\\%s\\0\\win32",tlguid,ver);
280 tlfnlen = sizeof(tlfn);
281 if (RegQueryValueA(HKEY_CLASSES_ROOT,typelibkey,tlfn,&tlfnlen)) {
282 ERR("Could not get typelib fn?\n");
283 return E_FAIL;
284 }
285 MultiByteToWideChar(CP_ACP, 0, tlfn, -1, tlfnW, -1);
286 hres = LoadTypeLib(tlfnW,&tl);
287 if (hres) {
288 ERR("Failed to load typelib for %s, but it should be there.\n",debugstr_guid(riid));
289 return hres;
290 }
291 hres = ITypeLib_GetTypeInfoOfGuid(tl,riid,ti);
292 if (hres) {
293 ERR("typelib does not contain info for %s?\n",debugstr_guid(riid));
294 ITypeLib_Release(tl);
295 return hres;
296 }
297 /* FIXME: do this? ITypeLib_Release(tl); */
298 return hres;
299 }
300
301 /* Determine nr of functions. Since we use the toplevel interface and all
302 * inherited ones have lower numbers, we are ok to not to descent into
303 * the inheritance tree I think.
304 */
305 static int _nroffuncs(ITypeInfo *tinfo) {
306 int n, max = 0;
307 const FUNCDESC *fdesc;
308 HRESULT hres;
309
310 n=0;
311 while (1) {
312 hres = ITypeInfoImpl_GetInternalFuncDesc(tinfo,n,&fdesc);
313 if (hres)
314 return max+1;
315 if (fdesc->oVft/4 > max)
316 max = fdesc->oVft/4;
317 n++;
318 }
319 /*NOTREACHED*/
320 }
321
322 #ifdef __i386__
323
324 #include "pshpack1.h"
325
326 typedef struct _TMAsmProxy {
327 BYTE popleax;
328 BYTE pushlval;
329 BYTE nr;
330 BYTE pushleax;
331 BYTE lcall;
332 DWORD xcall;
333 BYTE lret;
334 WORD bytestopop;
335 } TMAsmProxy;
336
337 #include "poppack.h"
338
339 #else /* __i386__ */
340 # warning You need to implement stubless proxies for your architecture
341 typedef struct _TMAsmProxy {
342 } TMAsmProxy;
343 #endif
344
345 typedef struct _TMProxyImpl {
346 LPVOID *lpvtbl;
347 const IRpcProxyBufferVtbl *lpvtbl2;
348 LONG ref;
349
350 TMAsmProxy *asmstubs;
351 ITypeInfo* tinfo;
352 IRpcChannelBuffer* chanbuf;
353 IID iid;
354 CRITICAL_SECTION crit;
355 IUnknown *outerunknown;
356 IDispatch *dispatch;
357 } TMProxyImpl;
358
359 static HRESULT WINAPI
360 TMProxyImpl_QueryInterface(LPRPCPROXYBUFFER iface, REFIID riid, LPVOID *ppv)
361 {
362 TRACE("()\n");
363 if (IsEqualIID(riid,&IID_IUnknown)||IsEqualIID(riid,&IID_IRpcProxyBuffer)) {
364 *ppv = (LPVOID)iface;
365 IRpcProxyBuffer_AddRef(iface);
366 return S_OK;
367 }
368 FIXME("no interface for %s\n",debugstr_guid(riid));
369 return E_NOINTERFACE;
370 }
371
372 static ULONG WINAPI
373 TMProxyImpl_AddRef(LPRPCPROXYBUFFER iface)
374 {
375 ICOM_THIS_MULTI(TMProxyImpl,lpvtbl2,iface);
376 ULONG refCount = InterlockedIncrement(&This->ref);
377
378 TRACE("(%p)->(ref before=%lu)\n",This, refCount - 1);
379
380 return refCount;
381 }
382
383 static ULONG WINAPI
384 TMProxyImpl_Release(LPRPCPROXYBUFFER iface)
385 {
386 ICOM_THIS_MULTI(TMProxyImpl,lpvtbl2,iface);
387 ULONG refCount = InterlockedDecrement(&This->ref);
388
389 TRACE("(%p)->(ref before=%lu)\n",This, refCount + 1);
390
391 if (!refCount)
392 {
393 if (This->dispatch) IDispatch_Release(This->dispatch);
394 DeleteCriticalSection(&This->crit);
395 if (This->chanbuf) IRpcChannelBuffer_Release(This->chanbuf);
396 VirtualFree(This->asmstubs, 0, MEM_RELEASE);
397 CoTaskMemFree(This);
398 }
399 return refCount;
400 }
401
402 static HRESULT WINAPI
403 TMProxyImpl_Connect(
404 LPRPCPROXYBUFFER iface,IRpcChannelBuffer* pRpcChannelBuffer)
405 {
406 ICOM_THIS_MULTI(TMProxyImpl, lpvtbl2, iface);
407
408 TRACE("(%p)\n", pRpcChannelBuffer);
409
410 EnterCriticalSection(&This->crit);
411
412 IRpcChannelBuffer_AddRef(pRpcChannelBuffer);
413 This->chanbuf = pRpcChannelBuffer;
414
415 LeaveCriticalSection(&This->crit);
416
417 return S_OK;
418 }
419
420 static void WINAPI
421 TMProxyImpl_Disconnect(LPRPCPROXYBUFFER iface)
422 {
423 ICOM_THIS_MULTI(TMProxyImpl, lpvtbl2, iface);
424
425 TRACE("()\n");
426
427 EnterCriticalSection(&This->crit);
428
429 IRpcChannelBuffer_Release(This->chanbuf);
430 This->chanbuf = NULL;
431
432 LeaveCriticalSection(&This->crit);
433 }
434
435
436 static const IRpcProxyBufferVtbl tmproxyvtable = {
437 TMProxyImpl_QueryInterface,
438 TMProxyImpl_AddRef,
439 TMProxyImpl_Release,
440 TMProxyImpl_Connect,
441 TMProxyImpl_Disconnect
442 };
443
444 /* how much space do we use on stack in DWORD steps. */
445 int
446 _argsize(DWORD vt) {
447 switch (vt) {
448 case VT_UI8:
449 return 8/sizeof(DWORD);
450 case VT_R8:
451 return sizeof(double)/sizeof(DWORD);
452 case VT_CY:
453 return sizeof(CY)/sizeof(DWORD);
454 case VT_DATE:
455 return sizeof(DATE)/sizeof(DWORD);
456 case VT_VARIANT:
457 return (sizeof(VARIANT)+3)/sizeof(DWORD);
458 default:
459 return 1;
460 }
461 }
462
463 static int
464 _xsize(TYPEDESC *td) {
465 switch (td->vt) {
466 case VT_DATE:
467 return sizeof(DATE);
468 case VT_VARIANT:
469 return sizeof(VARIANT)+3;
470 case VT_CARRAY: {
471 int i, arrsize = 1;
472 ARRAYDESC *adesc = td->u.lpadesc;
473
474 for (i=0;i<adesc->cDims;i++)
475 arrsize *= adesc->rgbounds[i].cElements;
476 return arrsize*_xsize(&adesc->tdescElem);
477 }
478 case VT_UI8:
479 case VT_I8:
480 return 8;
481 case VT_UI2:
482 case VT_I2:
483 return 2;
484 case VT_UI1:
485 case VT_I1:
486 return 1;
487 default:
488 return 4;
489 }
490 }
491
492 static HRESULT
493 serialize_param(
494 ITypeInfo *tinfo,
495 BOOL writeit,
496 BOOL debugout,
497 BOOL dealloc,
498 TYPEDESC *tdesc,
499 DWORD *arg,
500 marshal_state *buf)
501 {
502 HRESULT hres = S_OK;
503
504 TRACE("(tdesc.vt %d)\n",tdesc->vt);
505
506 switch (tdesc->vt) {
507 case VT_EMPTY: /* nothing. empty variant for instance */
508 return S_OK;
509 case VT_I8:
510 case VT_UI8:
511 case VT_CY:
512 hres = S_OK;
513 if (debugout) TRACE_(olerelay)("%lx%lx",arg[0],arg[1]);
514 if (writeit)
515 hres = xbuf_add(buf,(LPBYTE)arg,8);
516 return hres;
517 case VT_BOOL:
518 case VT_ERROR:
519 case VT_UINT:
520 case VT_I4:
521 case VT_R4:
522 case VT_UI4:
523 hres = S_OK;
524 if (debugout) TRACE_(olerelay)("%lx",*arg);
525 if (writeit)
526 hres = xbuf_add(buf,(LPBYTE)arg,sizeof(DWORD));
527 return hres;
528 case VT_I2:
529 case VT_UI2:
530 hres = S_OK;
531 if (debugout) TRACE_(olerelay)("%04lx",*arg & 0xffff);
532 if (writeit)
533 hres = xbuf_add(buf,(LPBYTE)arg,sizeof(DWORD));
534 return hres;
535 case VT_I1:
536 case VT_UI1:
537 hres = S_OK;
538 if (debugout) TRACE_(olerelay)("%02lx",*arg & 0xff);
539 if (writeit)
540 hres = xbuf_add(buf,(LPBYTE)arg,sizeof(DWORD));
541 return hres;
542 case VT_I4|VT_BYREF:
543 hres = S_OK;
544 if (debugout) TRACE_(olerelay)("&0x%lx",*arg);
545 if (writeit)
546 hres = xbuf_add(buf,(LPBYTE)(DWORD*)*arg,sizeof(DWORD));
547 /* do not dealloc at this time */
548 return hres;
549 case VT_VARIANT: {
550 TYPEDESC tdesc2;
551 VARIANT *vt = (VARIANT*)arg;
552 DWORD vttype = V_VT(vt);
553
554 if (debugout) TRACE_(olerelay)("Vt(%ld)(",vttype);
555 tdesc2.vt = vttype;
556 if (writeit) {
557 hres = xbuf_add(buf,(LPBYTE)&vttype,sizeof(vttype));
558 if (hres) return hres;
559 }
560 /* need to recurse since we need to free the stuff */
561 hres = serialize_param(tinfo,writeit,debugout,dealloc,&tdesc2,(DWORD*)&(V_I4(vt)),buf);
562 if (debugout) TRACE_(olerelay)(")");
563 return hres;
564 }
565 case VT_BSTR|VT_BYREF: {
566 if (debugout) TRACE_(olerelay)("[byref]'%s'", *(BSTR*)*arg ? relaystr(*((BSTR*)*arg)) : "<bstr NULL>");
567 if (writeit) {
568 /* ptr to ptr to magic widestring, basically */
569 BSTR *bstr = (BSTR *) *arg;
570 DWORD len;
571 if (!*bstr) {
572 /* -1 means "null string" which is equivalent to empty string */
573 len = -1;
574 hres = xbuf_add(buf, (LPBYTE)&len,sizeof(DWORD));
575 if (hres) return hres;
576 } else {
577 len = *((DWORD*)*bstr-1)/sizeof(WCHAR);
578 hres = xbuf_add(buf,(LPBYTE)&len,sizeof(DWORD));
579 if (hres) return hres;
580 hres = xbuf_add(buf,(LPBYTE)*bstr,len * sizeof(WCHAR));
581 if (hres) return hres;
582 }
583 }
584
585 if (dealloc && arg) {
586 BSTR *str = *((BSTR **)arg);
587 SysFreeString(*str);
588 }
589 return S_OK;
590 }
591
592 case VT_BSTR: {
593 if (debugout) {
594 if (*arg)
595 TRACE_(olerelay)("%s",relaystr((WCHAR*)*arg));
596 else
597 TRACE_(olerelay)("<bstr NULL>");
598 }
599 if (writeit) {
600 BSTR bstr = (BSTR)*arg;
601 DWORD len;
602 if (!bstr) {
603 len = -1;
604 hres = xbuf_add(buf,(LPBYTE)&len,sizeof(DWORD));
605 if (hres) return hres;
606 } else {
607 len = *((DWORD*)bstr-1)/sizeof(WCHAR);
608 hres = xbuf_add(buf,(LPBYTE)&len,sizeof(DWORD));
609 if (hres) return hres;
610 hres = xbuf_add(buf,(LPBYTE)bstr,len * sizeof(WCHAR));
611 if (hres) return hres;
612 }
613 }
614
615 if (dealloc && arg)
616 SysFreeString((BSTR)*arg);
617 return S_OK;
618 }
619 case VT_PTR: {
620 DWORD cookie;
621 BOOL derefhere = TRUE;
622
623 if (tdesc->u.lptdesc->vt == VT_USERDEFINED) {
624 ITypeInfo *tinfo2;
625 TYPEATTR *tattr;
626
627 hres = ITypeInfo_GetRefTypeInfo(tinfo,tdesc->u.lptdesc->u.hreftype,&tinfo2);
628 if (hres) {
629 ERR("Could not get typeinfo of hreftype %lx for VT_USERDEFINED.\n",tdesc->u.lptdesc->u.hreftype);
630 return hres;
631 }
632 ITypeInfo_GetTypeAttr(tinfo2,&tattr);
633 switch (tattr->typekind) {
634 case TKIND_ENUM: /* confirmed */
635 case TKIND_RECORD: /* FIXME: mostly untested */
636 derefhere=TRUE;
637 break;
638 case TKIND_ALIAS: /* FIXME: untested */
639 case TKIND_DISPATCH: /* will be done in VT_USERDEFINED case */
640 case TKIND_INTERFACE: /* will be done in VT_USERDEFINED case */
641 derefhere=FALSE;
642 break;
643 default:
644 FIXME("unhandled switch cases tattr->typekind %d\n", tattr->typekind);
645 derefhere=FALSE;
646 break;
647 }
648 ITypeInfo_Release(tinfo2);
649 }
650
651 if (debugout) TRACE_(olerelay)("*");
652 /* Write always, so the other side knows when it gets a NULL pointer.
653 */
654 cookie = *arg ? 0x42424242 : 0;
655 hres = xbuf_add(buf,(LPBYTE)&cookie,sizeof(cookie));
656 if (hres)
657 return hres;
658 if (!*arg) {
659 if (debugout) TRACE_(olerelay)("NULL");
660 return S_OK;
661 }
662 hres = serialize_param(tinfo,writeit,debugout,dealloc,tdesc->u.lptdesc,(DWORD*)*arg,buf);
663 if (derefhere && dealloc) HeapFree(GetProcessHeap(),0,(LPVOID)*arg);
664 return hres;
665 }
666 case VT_UNKNOWN:
667 if (debugout) TRACE_(olerelay)("unk(0x%lx)",*arg);
668 if (writeit)
669 hres = _marshal_interface(buf,&IID_IUnknown,(LPUNKNOWN)*arg);
670 return hres;
671 case VT_DISPATCH:
672 if (debugout) TRACE_(olerelay)("idisp(0x%lx)",*arg);
673 if (writeit)
674 hres = _marshal_interface(buf,&IID_IDispatch,(LPUNKNOWN)*arg);
675 return hres;
676 case VT_VOID:
677 if (debugout) TRACE_(olerelay)("<void>");
678 return S_OK;
679 case VT_USERDEFINED: {
680 ITypeInfo *tinfo2;
681 TYPEATTR *tattr;
682
683 hres = ITypeInfo_GetRefTypeInfo(tinfo,tdesc->u.hreftype,&tinfo2);
684 if (hres) {
685 ERR("Could not get typeinfo of hreftype %lx for VT_USERDEFINED.\n",tdesc->u.hreftype);
686 return hres;
687 }
688 ITypeInfo_GetTypeAttr(tinfo2,&tattr);
689 switch (tattr->typekind) {
690 case TKIND_DISPATCH:
691 case TKIND_INTERFACE:
692 if (writeit)
693 hres=_marshal_interface(buf,&(tattr->guid),(LPUNKNOWN)arg);
694 if (dealloc)
695 IUnknown_Release((LPUNKNOWN)arg);
696 break;
697 case TKIND_RECORD: {
698 int i;
699 if (debugout) TRACE_(olerelay)("{");
700 for (i=0;i<tattr->cVars;i++) {
701 VARDESC *vdesc;
702 ELEMDESC *elem2;
703 TYPEDESC *tdesc2;
704
705 hres = ITypeInfo2_GetVarDesc(tinfo2, i, &vdesc);
706 if (hres) {
707 ERR("Could not get vardesc of %d\n",i);
708 return hres;
709 }
710 /* Need them for hack below */
711 /*
712 memset(names,0,sizeof(names));
713 hres = ITypeInfo_GetNames(tinfo2,vdesc->memid,names,sizeof(names)/sizeof(names[0]),&nrofnames);
714 if (nrofnames > sizeof(names)/sizeof(names[0])) {
715 ERR("Need more names!\n");
716 }
717 if (!hres && debugout)
718 TRACE_(olerelay)("%s=",relaystr(names[0]));
719 */
720 elem2 = &vdesc->elemdescVar;
721 tdesc2 = &elem2->tdesc;
722 hres = serialize_param(
723 tinfo2,
724 writeit,
725 debugout,
726 dealloc,
727 tdesc2,
728 (DWORD*)(((LPBYTE)arg)+vdesc->u.oInst),
729 buf
730 );
731 ITypeInfo_ReleaseVarDesc(tinfo2, vdesc);
732 if (hres!=S_OK)
733 return hres;
734 if (debugout && (i<(tattr->cVars-1)))
735 TRACE_(olerelay)(",");
736 }
737 if (debugout) TRACE_(olerelay)("}");
738 break;
739 }
740 case TKIND_ALIAS:
741 return serialize_param(tinfo2,writeit,debugout,dealloc,&tattr->tdescAlias,arg,buf);
742 case TKIND_ENUM:
743 hres = S_OK;
744 if (debugout) TRACE_(olerelay)("%lx",*arg);
745 if (writeit)
746 hres = xbuf_add(buf,(LPBYTE)arg,sizeof(DWORD));
747 return hres;
748 default:
749 FIXME("Unhandled typekind %d\n",tattr->typekind);
750 hres = E_FAIL;
751 break;
752 }
753 ITypeInfo_Release(tinfo2);
754 return hres;
755 }
756 case VT_CARRAY: {
757 ARRAYDESC *adesc = tdesc->u.lpadesc;
758 int i, arrsize = 1;
759
760 if (debugout) TRACE_(olerelay)("carr");
761 for (i=0;i<adesc->cDims;i++) {
762 if (debugout) TRACE_(olerelay)("[%ld]",adesc->rgbounds[i].cElements);
763 arrsize *= adesc->rgbounds[i].cElements;
764 }
765 if (debugout) TRACE_(olerelay)("(vt %d)",adesc->tdescElem.vt);
766 if (debugout) TRACE_(olerelay)("[");
767 for (i=0;i<arrsize;i++) {
768 hres = serialize_param(tinfo, writeit, debugout, dealloc, &adesc->tdescElem, (DWORD*)((LPBYTE)arg+i*_xsize(&adesc->tdescElem)), buf);
769 if (hres)
770 return hres;
771 if (debugout && (i<arrsize-1)) TRACE_(olerelay)(",");
772 }
773 if (debugout) TRACE_(olerelay)("]");
774 return S_OK;
775 }
776 default:
777 ERR("Unhandled marshal type %d.\n",tdesc->vt);
778 return S_OK;
779 }
780 }
781
782 static HRESULT
783 deserialize_param(
784 ITypeInfo *tinfo,
785 BOOL readit,
786 BOOL debugout,
787 BOOL alloc,
788 TYPEDESC *tdesc,
789 DWORD *arg,
790 marshal_state *buf)
791 {
792 HRESULT hres = S_OK;
793
794 TRACE("vt %d at %p\n",tdesc->vt,arg);
795
796 while (1) {
797 switch (tdesc->vt) {
798 case VT_EMPTY:
799 if (debugout) TRACE_(olerelay)("<empty>");
800 return S_OK;
801 case VT_NULL:
802 if (debugout) TRACE_(olerelay)("<null>");
803 return S_OK;
804 case VT_VARIANT: {
805 VARIANT *vt = (VARIANT*)arg;
806
807 if (readit) {
808 DWORD vttype;
809 TYPEDESC tdesc2;
810 hres = xbuf_get(buf,(LPBYTE)&vttype,sizeof(vttype));
811 if (hres) {
812 FIXME("vt type not read?\n");
813 return hres;
814 }
815 memset(&tdesc2,0,sizeof(tdesc2));
816 tdesc2.vt = vttype;
817 V_VT(vt) = vttype;
818 if (debugout) TRACE_(olerelay)("Vt(%ld)(",vttype);
819 hres = deserialize_param(tinfo, readit, debugout, alloc, &tdesc2, (DWORD*)&(V_I4(vt)), buf);
820 TRACE_(olerelay)(")");
821 return hres;
822 } else {
823 VariantInit(vt);
824 return S_OK;
825 }
826 }
827 case VT_I8:
828 case VT_UI8:
829 case VT_CY:
830 if (readit) {
831 hres = xbuf_get(buf,(LPBYTE)arg,8);
832 if (hres) ERR("Failed to read integer 8 byte\n");
833 }
834 if (debugout) TRACE_(olerelay)("%lx%lx",arg[0],arg[1]);
835 return hres;
836 case VT_ERROR:
837 case VT_BOOL:
838 case VT_I4:
839 case VT_UINT:
840 case VT_R4:
841 case VT_UI4:
842 if (readit) {
843 hres = xbuf_get(buf,(LPBYTE)arg,sizeof(DWORD));
844 if (hres) ERR("Failed to read integer 4 byte\n");
845 }
846 if (debugout) TRACE_(olerelay)("%lx",*arg);
847 return hres;
848 case VT_I2:
849 case VT_UI2:
850 if (readit) {
851 DWORD x;
852 hres = xbuf_get(buf,(LPBYTE)&x,sizeof(DWORD));
853 if (hres) ERR("Failed to read integer 4 byte\n");
854 memcpy(arg,&x,2);
855 }
856 if (debugout) TRACE_(olerelay)("%04lx",*arg & 0xffff);
857 return hres;
858 case VT_I1:
859 case VT_UI1:
860 if (readit) {
861 DWORD x;
862 hres = xbuf_get(buf,(LPBYTE)&x,sizeof(DWORD));
863 if (hres) ERR("Failed to read integer 4 byte\n");
864 memcpy(arg,&x,1);
865 }
866 if (debugout) TRACE_(olerelay)("%02lx",*arg & 0xff);
867 return hres;
868 case VT_I4|VT_BYREF:
869 hres = S_OK;
870 if (alloc)
871 *arg = (DWORD)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(DWORD));
872 if (readit) {
873 hres = xbuf_get(buf,(LPBYTE)*arg,sizeof(DWORD));
874 if (hres) ERR("Failed to read integer 4 byte\n");
875 }
876 if (debugout) TRACE_(olerelay)("&0x%lx",*(DWORD*)*arg);
877 return hres;
878 case VT_BSTR|VT_BYREF: {
879 BSTR **bstr = (BSTR **)arg;
880 WCHAR *str;
881 DWORD len;
882
883 if (readit) {
884 hres = xbuf_get(buf,(LPBYTE)&len,sizeof(DWORD));
885 if (hres) {
886 ERR("failed to read bstr klen\n");
887 return hres;
888 }
889 if (len == -1) {
890 *bstr = CoTaskMemAlloc(sizeof(BSTR *));
891 **bstr = NULL;
892 if (debugout) TRACE_(olerelay)("<bstr NULL>");
893 } else {
894 str = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,(len+1)*sizeof(WCHAR));
895 hres = xbuf_get(buf,(LPBYTE)str,len*sizeof(WCHAR));
896 if (hres) {
897 ERR("Failed to read BSTR.\n");
898 return hres;
899 }
900 *bstr = CoTaskMemAlloc(sizeof(BSTR *));
901 **bstr = SysAllocStringLen(str,len);
902 if (debugout) TRACE_(olerelay)("%s",relaystr(str));
903 HeapFree(GetProcessHeap(),0,str);
904 }
905 } else {
906 *bstr = NULL;
907 }
908 return S_OK;
909 }
910 case VT_BSTR: {
911 WCHAR *str;
912 DWORD len;
913
914 if (readit) {
915 hres = xbuf_get(buf,(LPBYTE)&len,sizeof(DWORD));
916 if (hres) {
917 ERR("failed to read bstr klen\n");
918 return hres;
919 }
920 if (len == -1) {
921 *arg = 0;
922 if (debugout) TRACE_(olerelay)("<bstr NULL>");
923 } else {
924 str = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,(len+1)*sizeof(WCHAR));
925 hres = xbuf_get(buf,(LPBYTE)str,len*sizeof(WCHAR));
926 if (hres) {
927 ERR("Failed to read BSTR.\n");
928 return hres;
929 }
930 *arg = (DWORD)SysAllocStringLen(str,len);
931 if (debugout) TRACE_(olerelay)("%s",relaystr(str));
932 HeapFree(GetProcessHeap(),0,str);
933 }
934 } else {
935 *arg = 0;
936 }
937 return S_OK;
938 }
939 case VT_PTR: {
940 DWORD cookie;
941 BOOL derefhere = TRUE;
942
943 if (tdesc->u.lptdesc->vt == VT_USERDEFINED) {
944 ITypeInfo *tinfo2;
945 TYPEATTR *tattr;
946
947 hres = ITypeInfo_GetRefTypeInfo(tinfo,tdesc->u.lptdesc->u.hreftype,&tinfo2);
948 if (hres) {
949 ERR("Could not get typeinfo of hreftype %lx for VT_USERDEFINED.\n",tdesc->u.lptdesc->u.hreftype);
950 return hres;
951 }
952 ITypeInfo_GetTypeAttr(tinfo2,&tattr);
953 switch (tattr->typekind) {
954 case TKIND_ENUM: /* confirmed */
955 case TKIND_RECORD: /* FIXME: mostly untested */
956 derefhere=TRUE;
957 break;
958 case TKIND_ALIAS: /* FIXME: untested */
959 case TKIND_DISPATCH: /* will be done in VT_USERDEFINED case */
960 case TKIND_INTERFACE: /* will be done in VT_USERDEFINED case */
961 derefhere=FALSE;
962 break;
963 default:
964 FIXME("unhandled switch cases tattr->typekind %d\n", tattr->typekind);
965 derefhere=FALSE;
966 break;
967 }
968 ITypeInfo_Release(tinfo2);
969 }
970 /* read it in all cases, we need to know if we have
971 * NULL pointer or not.
972 */
973 hres = xbuf_get(buf,(LPBYTE)&cookie,sizeof(cookie));
974 if (hres) {
975 ERR("Failed to load pointer cookie.\n");
976 return hres;
977 }
978 if (cookie != 0x42424242) {
979 /* we read a NULL ptr from the remote side */
980 if (debugout) TRACE_(olerelay)("NULL");
981 *arg = 0;
982 return S_OK;
983 }
984 if (debugout) TRACE_(olerelay)("*");
985 if (alloc) {
986 /* Allocate space for the referenced struct */
987 if (derefhere)
988 *arg=(DWORD)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,_xsize(tdesc->u.lptdesc));
989 }
990 if (derefhere)
991 return deserialize_param(tinfo, readit, debugout, alloc, tdesc->u.lptdesc, (LPDWORD)*arg, buf);
992 else
993 return deserialize_param(tinfo, readit, debugout, alloc, tdesc->u.lptdesc, arg, buf);
994 }
995 case VT_UNKNOWN:
996 /* FIXME: UNKNOWN is unknown ..., but allocate 4 byte for it */
997 if (alloc)
998 *arg=(DWORD)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(DWORD));
999 hres = S_OK;
1000 if (readit)
1001 hres = _unmarshal_interface(buf,&IID_IUnknown,(LPUNKNOWN*)arg);
1002 if (debugout)
1003 TRACE_(olerelay)("unk(%p)",arg);
1004 return hres;
1005 case VT_DISPATCH:
1006 hres = S_OK;
1007 if (readit)
1008 hres = _unmarshal_interface(buf,&IID_IDispatch,(LPUNKNOWN*)arg);
1009 if (debugout)
1010 TRACE_(olerelay)("idisp(%p)",arg);
1011 return hres;
1012 case VT_VOID:
1013 if (debugout) TRACE_(olerelay)("<void>");
1014 return S_OK;
1015 case VT_USERDEFINED: {
1016 ITypeInfo *tinfo2;
1017 TYPEATTR *tattr;
1018
1019 hres = ITypeInfo_GetRefTypeInfo(tinfo,tdesc->u.hreftype,&tinfo2);
1020 if (hres) {
1021 ERR("Could not get typeinfo of hreftype %lx for VT_USERDEFINED.\n",tdesc->u.hreftype);
1022 return hres;
1023 }
1024 hres = ITypeInfo_GetTypeAttr(tinfo2,&tattr);
1025 if (hres) {
1026 ERR("Could not get typeattr in VT_USERDEFINED.\n");
1027 } else {
1028 switch (tattr->typekind) {
1029 case TKIND_DISPATCH:
1030 case TKIND_INTERFACE:
1031 if (readit)
1032 hres = _unmarshal_interface(buf,&(tattr->guid),(LPUNKNOWN*)arg);
1033 break;
1034 case TKIND_RECORD: {
1035 int i;
1036
1037 if (alloc)
1038 *arg = (DWORD)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,tattr->cbSizeInstance);
1039
1040 if (debugout) TRACE_(olerelay)("{");
1041 for (i=0;i<tattr->cVars;i++) {
1042 VARDESC *vdesc;
1043
1044 hres = ITypeInfo2_GetVarDesc(tinfo2, i, &vdesc);
1045 if (hres) {
1046 ERR("Could not get vardesc of %d\n",i);
1047 return hres;
1048 }
1049 hres = deserialize_param(
1050 tinfo2,
1051 readit,
1052 debugout,
1053 alloc,
1054 &vdesc->elemdescVar.tdesc,
1055 (DWORD*)(((LPBYTE)*arg)+vdesc->u.oInst),
1056 buf
1057 );
1058 ITypeInfo2_ReleaseVarDesc(tinfo2, vdesc);
1059 if (debugout && (i<tattr->cVars-1)) TRACE_(olerelay)(",");
1060 }
1061 if (debugout) TRACE_(olerelay)("}");
1062 break;
1063 }
1064 case TKIND_ALIAS:
1065 return deserialize_param(tinfo2,readit,debugout,alloc,&tattr->tdescAlias,arg,buf);
1066 case TKIND_ENUM:
1067 if (readit) {
1068 hres = xbuf_get(buf,(LPBYTE)arg,sizeof(DWORD));
1069 if (hres) ERR("Failed to read enum (4 byte)\n");
1070 }
1071 if (debugout) TRACE_(olerelay)("%lx",*arg);
1072 return hres;
1073 default:
1074 ERR("Unhandled typekind %d\n",tattr->typekind);
1075 hres = E_FAIL;
1076 break;
1077 }
1078 }
1079 if (hres)
1080 ERR("failed to stuballoc in TKIND_RECORD.\n");
1081 ITypeInfo_Release(tinfo2);
1082 return hres;
1083 }
1084 case VT_CARRAY: {
1085 /* arg is pointing to the start of the array. */
1086 ARRAYDESC *adesc = tdesc->u.lpadesc;
1087 int arrsize,i;
1088 arrsize = 1;
1089 if (adesc->cDims > 1) FIXME("cDims > 1 in VT_CARRAY. Does it work?\n");
1090 for (i=0;i<adesc->cDims;i++)
1091 arrsize *= adesc->rgbounds[i].cElements;
1092 for (i=0;i<arrsize;i++)
1093 deserialize_param(
1094 tinfo,
1095 readit,
1096 debugout,
1097 alloc,
1098 &adesc->tdescElem,
1099 (DWORD*)((LPBYTE)(arg)+i*_xsize(&adesc->tdescElem)),
1100 buf
1101 );
1102 return S_OK;
1103 }
1104 default:
1105 ERR("No handler for VT type %d!\n",tdesc->vt);
1106 return S_OK;
1107 }
1108 }
1109 }
1110
1111 /* Searches function, also in inherited interfaces */
1112 static HRESULT
1113 _get_funcdesc(
1114 ITypeInfo *tinfo, int iMethod, ITypeInfo **tactual, const FUNCDESC **fdesc, BSTR *iname, BSTR *fname)
1115 {
1116 int i = 0, j = 0;
1117 HRESULT hres;
1118
1119 if (fname) *fname = NULL;
1120 if (iname) *iname = NULL;
1121
1122 *tactual = tinfo;
1123 ITypeInfo_AddRef(*tactual);
1124
1125 while (1) {
1126 hres = ITypeInfoImpl_GetInternalFuncDesc(tinfo, i, fdesc);
1127
1128 if (hres) {
1129 ITypeInfo *tinfo2;
1130 HREFTYPE href;
1131 TYPEATTR *attr;
1132
1133 hres = ITypeInfo_GetTypeAttr(tinfo, &attr);
1134 if (hres) {
1135 ERR("GetTypeAttr failed with %lx\n",hres);
1136 return hres;
1137 }
1138 /* Not found, so look in inherited ifaces. */
1139 for (j=0;j<attr->cImplTypes;j++) {
1140 hres = ITypeInfo_GetRefTypeOfImplType(tinfo, j, &href);
1141 if (hres) {
1142 ERR("Did not find a reftype for interface offset %d?\n",j);
1143 break;
1144 }
1145 hres = ITypeInfo_GetRefTypeInfo(tinfo, href, &tinfo2);
1146 if (hres) {
1147 ERR("Did not find a typeinfo for reftype %ld?\n",href);
1148 continue;
1149 }
1150 hres = _get_funcdesc(tinfo2,iMethod,tactual,fdesc,iname,fname);
1151 ITypeInfo_Release(tinfo2);
1152 if (!hres) return S_OK;
1153 }
1154 return hres;
1155 }
1156 if (((*fdesc)->oVft/4) == iMethod) {
1157 if (fname)
1158 ITypeInfo_GetDocumentation(tinfo,(*fdesc)->memid,fname,NULL,NULL,NULL);
1159 if (iname)
1160 ITypeInfo_GetDocumentation(tinfo,-1,iname,NULL,NULL,NULL);
1161 return S_OK;
1162 }
1163 i++;
1164 }
1165 }
1166
1167 static DWORD
1168 xCall(LPVOID retptr, int method, TMProxyImpl *tpinfo /*, args */)
1169 {
1170 DWORD *args = ((DWORD*)&tpinfo)+1, *xargs;
1171 const FUNCDESC *fdesc;
1172 HRESULT hres;
1173 int i, relaydeb = TRACE_ON(olerelay);
1174 marshal_state buf;
1175 RPCOLEMESSAGE msg;
1176 ULONG status;
1177 BSTR fname,iname;
1178 BSTR names[10];
1179 UINT nrofnames;
1180 DWORD remoteresult = 0;
1181 ITypeInfo *tinfo;
1182 IRpcChannelBuffer *chanbuf;
1183
1184 EnterCriticalSection(&tpinfo->crit);
1185
1186 hres = _get_funcdesc(tpinfo->tinfo,method,&tinfo,&fdesc,&iname,&fname);
1187 if (hres) {
1188 ERR("Did not find typeinfo/funcdesc entry for method %d!\n",method);
1189 ITypeInfo_Release(tinfo);
1190 LeaveCriticalSection(&tpinfo->crit);
1191 return E_FAIL;
1192 }
1193
1194 if (!tpinfo->chanbuf)
1195 {
1196 WARN("Tried to use disconnected proxy\n");
1197 ITypeInfo_Release(tinfo);
1198 LeaveCriticalSection(&tpinfo->crit);
1199 return RPC_E_DISCONNECTED;
1200 }
1201 chanbuf = tpinfo->chanbuf;
1202 IRpcChannelBuffer_AddRef(chanbuf);
1203
1204 LeaveCriticalSection(&tpinfo->crit);
1205
1206 if (relaydeb) {
1207 TRACE_(olerelay)("->");
1208 if (iname)
1209 TRACE_(olerelay)("%s:",relaystr(iname));
1210 if (fname)
1211 TRACE_(olerelay)("%s(%d)",relaystr(fname),method);
1212 else
1213 TRACE_(olerelay)("%d",method);
1214 TRACE_(olerelay)("(");
1215 }
1216
1217 if (iname) SysFreeString(iname);
1218 if (fname) SysFreeString(fname);
1219
1220 memset(&buf,0,sizeof(buf));
1221
1222 /* normal typelib driven serializing */
1223
1224 /* Need them for hack below */
1225 memset(names,0,sizeof(names));
1226 if (ITypeInfo_GetNames(tinfo,fdesc->memid,names,sizeof(names)/sizeof(names[0]),&nrofnames))
1227 nrofnames = 0;
1228 if (nrofnames > sizeof(names)/sizeof(names[0]))
1229 ERR("Need more names!\n");
1230
1231 xargs = args;
1232 for (i=0;i<fdesc->cParams;i++) {
1233 ELEMDESC *elem = fdesc->lprgelemdescParam+i;
1234 if (relaydeb) {
1235 if (i) TRACE_(olerelay)(",");
1236 if (i+1<nrofnames && names[i+1])
1237 TRACE_(olerelay)("%s=",relaystr(names[i+1]));
1238 }
1239 /* No need to marshal other data than FIN and any VT_PTR. */
1240 if (!(elem->u.paramdesc.wParamFlags & PARAMFLAG_FIN || !elem->u.paramdesc.wParamFlags) && (elem->tdesc.vt != VT_PTR)) {
1241 xargs+=_argsize(elem->tdesc.vt);
1242 if (relaydeb) TRACE_(olerelay)("[out]");
1243 continue;
1244 }
1245 hres = serialize_param(
1246 tinfo,
1247 elem->u.paramdesc.wParamFlags & PARAMFLAG_FIN || !elem->u.paramdesc.wParamFlags,
1248 relaydeb,
1249 FALSE,
1250 &elem->tdesc,
1251 xargs,
1252 &buf
1253 );
1254
1255 if (hres) {
1256 ERR("Failed to serialize param, hres %lx\n",hres);
1257 break;
1258 }
1259 xargs+=_argsize(elem->tdesc.vt);
1260 }
1261 if (relaydeb) TRACE_(olerelay)(")");
1262
1263 memset(&msg,0,sizeof(msg));
1264 msg.cbBuffer = buf.curoff;
1265 msg.iMethod = method;
1266 hres = IRpcChannelBuffer_GetBuffer(chanbuf,&msg,&(tpinfo->iid));
1267 if (hres) {
1268 ERR("RpcChannelBuffer GetBuffer failed, %lx\n",hres);
1269 goto exit;
1270 }
1271 memcpy(msg.Buffer,buf.base,buf.curoff);
1272 if (relaydeb) TRACE_(olerelay)("\n");
1273 hres = IRpcChannelBuffer_SendReceive(chanbuf,&msg,&status);
1274 if (hres) {
1275 ERR("RpcChannelBuffer SendReceive failed, %lx\n",hres);
1276 goto exit;
1277 }
1278
1279 if (relaydeb) TRACE_(olerelay)(" status = %08lx (",status);
1280 if (buf.base)
1281 buf.base = HeapReAlloc(GetProcessHeap(),0,buf.base,msg.cbBuffer);
1282 else
1283 buf.base = HeapAlloc(GetProcessHeap(),0,msg.cbBuffer);
1284 buf.size = msg.cbBuffer;
1285 memcpy(buf.base,msg.Buffer,buf.size);
1286 buf.curoff = 0;
1287
1288 /* generic deserializer using typelib description */
1289 xargs = args;
1290 status = S_OK;
1291 for (i=0;i<fdesc->cParams;i++) {
1292 ELEMDESC *elem = fdesc->lprgelemdescParam+i;
1293
1294 if (relaydeb) {
1295 if (i) TRACE_(olerelay)(",");
1296 if (i+1<nrofnames && names[i+1]) TRACE_(olerelay)("%s=",relaystr(names[i+1]));
1297 }
1298 /* No need to marshal other data than FOUT and any VT_PTR */
1299 if (!(elem->u.paramdesc.wParamFlags & PARAMFLAG_FOUT) && (elem->tdesc.vt != VT_PTR)) {
1300 xargs += _argsize(elem->tdesc.vt);
1301 if (relaydeb) TRACE_(olerelay)("[in]");
1302 continue;
1303 }
1304 hres = deserialize_param(
1305 tinfo,
1306 elem->u.paramdesc.wParamFlags & PARAMFLAG_FOUT,
1307 relaydeb,
1308 FALSE,
1309 &(elem->tdesc),
1310 xargs,
1311 &buf
1312 );
1313 if (hres) {
1314 ERR("Failed to unmarshall param, hres %lx\n",hres);
1315 status = hres;
1316 break;
1317 }
1318 xargs += _argsize(elem->tdesc.vt);
1319 }
1320
1321 hres = xbuf_get(&buf, (LPBYTE)&remoteresult, sizeof(DWORD));
1322 if (hres != S_OK)
1323 goto exit;
1324 if (relaydeb) TRACE_(olerelay)(") = %08lx\n", remoteresult);
1325
1326 hres = remoteresult;
1327
1328 exit:
1329 HeapFree(GetProcessHeap(),0,buf.base);
1330 IRpcChannelBuffer_Release(chanbuf);
1331 ITypeInfo_Release(tinfo);
1332 TRACE("-- 0x%08lx\n", hres);
1333 return hres;
1334 }
1335
1336 HRESULT WINAPI ProxyIUnknown_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
1337 {
1338 TMProxyImpl *proxy = (TMProxyImpl *)iface;
1339
1340 TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
1341
1342 if (proxy->outerunknown)
1343 return IUnknown_QueryInterface(proxy->outerunknown, riid, ppv);
1344
1345 FIXME("No interface\n");
1346 return E_NOINTERFACE;
1347 }
1348
1349 ULONG WINAPI ProxyIUnknown_AddRef(IUnknown *iface)
1350 {
1351 TMProxyImpl *proxy = (TMProxyImpl *)iface;
1352
1353 TRACE("\n");
1354
1355 if (proxy->outerunknown)
1356 return IUnknown_AddRef(proxy->outerunknown);
1357
1358 return 2; /* FIXME */
1359 }
1360
1361 ULONG WINAPI ProxyIUnknown_Release(IUnknown *iface)
1362 {
1363 TMProxyImpl *proxy = (TMProxyImpl *)iface;
1364
1365 TRACE("\n");
1366
1367 if (proxy->outerunknown)
1368 return IUnknown_Release(proxy->outerunknown);
1369
1370 return 1; /* FIXME */
1371 }
1372
1373 static HRESULT WINAPI ProxyIDispatch_GetTypeInfoCount(LPDISPATCH iface, UINT * pctinfo)
1374 {
1375 TMProxyImpl *This = (TMProxyImpl *)iface;
1376 HRESULT hr;
1377
1378 TRACE("(%p)\n", pctinfo);
1379
1380 if (!This->dispatch)
1381 {
1382 hr = IUnknown_QueryInterface(This->outerunknown, &IID_IDispatch,
1383 (LPVOID *)&This->dispatch);
1384 }
1385 if (This->dispatch)
1386 hr = IDispatch_GetTypeInfoCount(This->dispatch, pctinfo);
1387
1388 return hr;
1389 }
1390
1391 static HRESULT WINAPI ProxyIDispatch_GetTypeInfo(LPDISPATCH iface, UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo)
1392 {
1393 TMProxyImpl *This = (TMProxyImpl *)iface;
1394 HRESULT hr = S_OK;
1395
1396 TRACE("(%d, %lx, %p)\n", iTInfo, lcid, ppTInfo);
1397
1398 if (!This->dispatch)
1399 {
1400 hr = IUnknown_QueryInterface(This->outerunknown, &IID_IDispatch,
1401 (LPVOID *)&This->dispatch);
1402 }
1403 if (This->dispatch)
1404 hr = IDispatch_GetTypeInfo(This->dispatch, iTInfo, lcid, ppTInfo);
1405
1406 return hr;
1407 }
1408
1409 static HRESULT WINAPI ProxyIDispatch_GetIDsOfNames(LPDISPATCH iface, REFIID riid, LPOLESTR * rgszNames, UINT cNames, LCID lcid, DISPID * rgDispId)
1410 {
1411 TMProxyImpl *This = (TMProxyImpl *)iface;
1412 HRESULT hr;
1413
1414 TRACE("(%s, %p, %d, 0x%lx, %p)\n", debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
1415
1416 if (!This->dispatch)
1417 {
1418 hr = IUnknown_QueryInterface(This->outerunknown, &IID_IDispatch,
1419 (LPVOID *)&This->dispatch);
1420 }
1421 if (This->dispatch)
1422 hr = IDispatch_GetIDsOfNames(This->dispatch, riid, rgszNames,
1423 cNames, lcid, rgDispId);
1424
1425 return hr;
1426 }
1427
1428 static HRESULT WINAPI ProxyIDispatch_Invoke(LPDISPATCH iface, DISPID dispIdMember, REFIID riid, LCID lcid,
1429 WORD wFlags, DISPPARAMS * pDispParams, VARIANT * pVarResult,
1430 EXCEPINFO * pExcepInfo, UINT * puArgErr)
1431 {
1432 TMProxyImpl *This = (TMProxyImpl *)iface;
1433 HRESULT hr;
1434
1435 TRACE("(%ld, %s, 0x%lx, 0x%x, %p, %p, %p, %p)\n", dispIdMember, debugstr_guid(riid), lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1436
1437 if (!This->dispatch)
1438 {
1439 hr = IUnknown_QueryInterface(This->outerunknown, &IID_IDispatch,
1440 (LPVOID *)&This->dispatch);
1441 }
1442 if (This->dispatch)
1443 hr = IDispatch_Invoke(This->dispatch, dispIdMember, riid, lcid,
1444 wFlags, pDispParams, pVarResult, pExcepInfo,
1445 puArgErr);
1446
1447 return hr;
1448 }
1449
1450 static HRESULT WINAPI
1451 PSFacBuf_CreateProxy(
1452 LPPSFACTORYBUFFER iface, IUnknown* pUnkOuter, REFIID riid,
1453 IRpcProxyBuffer **ppProxy, LPVOID *ppv)
1454 {
1455 HRESULT hres;
1456 ITypeInfo *tinfo;
1457 int i, nroffuncs;
1458 const FUNCDESC *fdesc;
1459 TMProxyImpl *proxy;
1460 TYPEATTR *typeattr;
1461
1462 TRACE("(...%s...)\n",debugstr_guid(riid));
1463 hres = _get_typeinfo_for_iid(riid,&tinfo);
1464 if (hres) {
1465 ERR("No typeinfo for %s?\n",debugstr_guid(riid));
1466 return hres;
1467 }
1468 nroffuncs = _nroffuncs(tinfo);
1469 proxy = CoTaskMemAlloc(sizeof(TMProxyImpl));
1470 if (!proxy) return E_OUTOFMEMORY;
1471
1472 assert(sizeof(TMAsmProxy) == 12);
1473
1474 proxy->dispatch = NULL;
1475 proxy->outerunknown = pUnkOuter;
1476 proxy->asmstubs = VirtualAlloc(NULL, sizeof(TMAsmProxy) * nroffuncs, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
1477 if (!proxy->asmstubs) {
1478 ERR("Could not commit pages for proxy thunks\n");
1479 CoTaskMemFree(proxy);
1480 return E_OUTOFMEMORY;
1481 }
1482
1483 InitializeCriticalSection(&proxy->crit);
1484
1485 proxy->lpvtbl = HeapAlloc(GetProcessHeap(),0,sizeof(LPBYTE)*nroffuncs);
1486 for (i=0;i<nroffuncs;i++) {
1487 TMAsmProxy *xasm = proxy->asmstubs+i;
1488
1489 switch (i) {
1490 case 0:
1491 proxy->lpvtbl[i] = ProxyIUnknown_QueryInterface;
1492 break;
1493 case 1:
1494 proxy->lpvtbl[i] = ProxyIUnknown_AddRef;
1495 break;
1496 case 2:
1497 proxy->lpvtbl[i] = ProxyIUnknown_Release;
1498 break;
1499 default: {
1500 int j;
1501 /* nrofargs without This */
1502 int nrofargs;
1503 ITypeInfo *tinfo2;
1504 hres = _get_funcdesc(tinfo,i,&tinfo2,&fdesc,NULL,NULL);
1505 ITypeInfo_Release(tinfo2);
1506 if (hres) {
1507 ERR("GetFuncDesc %lx should not fail here.\n",hres);
1508 return hres;
1509 }
1510 /* some args take more than 4 byte on the stack */
1511 nrofargs = 0;
1512 for (j=0;j<fdesc->cParams;j++)
1513 nrofargs += _argsize(fdesc->lprgelemdescParam[j].tdesc.vt);
1514
1515 #ifdef __i386__
1516 if (fdesc->callconv != CC_STDCALL) {
1517 ERR("calling convention is not stdcall????\n");
1518 return E_FAIL;
1519 }
1520 /* popl %eax - return ptr
1521 * pushl <nr>
1522 * pushl %eax
1523 * call xCall
1524 * lret <nr> (+4)
1525 *
1526 *
1527 * arg3 arg2 arg1 <method> <returnptr>
1528 */
1529 xasm->popleax = 0x58;
1530 xasm->pushlval = 0x6a;
1531 xasm->nr = i;
1532 xasm->pushleax = 0x50;
1533 xasm->lcall = 0xe8; /* relative jump */
1534 xasm->xcall = (DWORD)xCall;
1535 xasm->xcall -= (DWORD)&(xasm->lret);
1536 xasm->lret = 0xc2;
1537 xasm->bytestopop= (nrofargs+2)*4; /* pop args, This, iMethod */
1538 proxy->lpvtbl[i] = xasm;
1539 break;
1540 #else
1541 FIXME("not implemented on non i386\n");
1542 return E_FAIL;
1543 #endif
1544 }
1545 }
1546 }
1547
1548 /* if we derive from IDispatch then defer to its proxy for its methods */
1549 hres = ITypeInfo_GetTypeAttr(tinfo, &typeattr);
1550 if (hres == S_OK)
1551 {
1552 if (typeattr->wTypeFlags & TYPEFLAG_FDISPATCHABLE)
1553 {
1554 proxy->lpvtbl[3] = ProxyIDispatch_GetTypeInfoCount;
1555 proxy->lpvtbl[4] = ProxyIDispatch_GetTypeInfo;
1556 proxy->lpvtbl[5] = ProxyIDispatch_GetIDsOfNames;
1557 proxy->lpvtbl[6] = ProxyIDispatch_Invoke;
1558 }
1559 ITypeInfo_ReleaseTypeAttr(tinfo, typeattr);
1560 }
1561
1562 proxy->lpvtbl2 = &tmproxyvtable;
1563 /* one reference for the proxy */
1564 proxy->ref = 1;
1565 proxy->tinfo = tinfo;
1566 memcpy(&proxy->iid,riid,sizeof(*riid));
1567 proxy->chanbuf = 0;
1568 *ppv = (LPVOID)proxy;
1569 *ppProxy = (IRpcProxyBuffer *)&(proxy->lpvtbl2);
1570 IUnknown_AddRef((IUnknown *)*ppv);
1571 return S_OK;
1572 }
1573
1574 typedef struct _TMStubImpl {
1575 const IRpcStubBufferVtbl *lpvtbl;
1576 LONG ref;
1577
1578 LPUNKNOWN pUnk;
1579 ITypeInfo *tinfo;
1580 IID iid;
1581 } TMStubImpl;
1582
1583 static HRESULT WINAPI
1584 TMStubImpl_QueryInterface(LPRPCSTUBBUFFER iface, REFIID riid, LPVOID *ppv)
1585 {
1586 if (IsEqualIID(riid,&IID_IRpcStubBuffer)||IsEqualIID(riid,&IID_IUnknown)){
1587 *ppv = (LPVOID)iface;
1588 IRpcStubBuffer_AddRef(iface);
1589 return S_OK;
1590 }
1591 FIXME("%s, not supported IID.\n",debugstr_guid(riid));
1592 return E_NOINTERFACE;
1593 }
1594
1595 static ULONG WINAPI
1596 TMStubImpl_AddRef(LPRPCSTUBBUFFER iface)
1597 {
1598 TMStubImpl *This = (TMStubImpl *)iface;
1599 ULONG refCount = InterlockedIncrement(&This->ref);
1600
1601 TRACE("(%p)->(ref before=%lu)\n", This, refCount - 1);
1602
1603 return refCount;
1604 }
1605
1606 static ULONG WINAPI
1607 TMStubImpl_Release(LPRPCSTUBBUFFER iface)
1608 {
1609 TMStubImpl *This = (TMStubImpl *)iface;
1610 ULONG refCount = InterlockedDecrement(&This->ref);
1611
1612 TRACE("(%p)->(ref before=%lu)\n", This, refCount + 1);
1613
1614 if (!refCount)
1615 {
1616 IRpcStubBuffer_Disconnect(iface);
1617 ITypeInfo_Release(This->tinfo);
1618 CoTaskMemFree(This);
1619 }
1620 return refCount;
1621 }
1622
1623 static HRESULT WINAPI
1624 TMStubImpl_Connect(LPRPCSTUBBUFFER iface, LPUNKNOWN pUnkServer)
1625 {
1626 TMStubImpl *This = (TMStubImpl *)iface;
1627
1628 TRACE("(%p)->(%p)\n", This, pUnkServer);
1629
1630 IUnknown_AddRef(pUnkServer);
1631 This->pUnk = pUnkServer;
1632 return S_OK;
1633 }
1634
1635 static void WINAPI
1636 TMStubImpl_Disconnect(LPRPCSTUBBUFFER iface)
1637 {
1638 TMStubImpl *This = (TMStubImpl *)iface;
1639
1640 TRACE("(%p)->()\n", This);
1641
1642 if (This->pUnk)
1643 {
1644 IUnknown_Release(This->pUnk);
1645 This->pUnk = NULL;
1646 }
1647 }
1648
1649 static HRESULT WINAPI
1650 TMStubImpl_Invoke(
1651 LPRPCSTUBBUFFER iface, RPCOLEMESSAGE* xmsg,IRpcChannelBuffer*rpcchanbuf)
1652 {
1653 int i;
1654 const FUNCDESC *fdesc;
1655 TMStubImpl *This = (TMStubImpl *)iface;
1656 HRESULT hres;
1657 DWORD *args, res, *xargs, nrofargs;
1658 marshal_state buf;
1659 UINT nrofnames;
1660 BSTR names[10];
1661 BSTR iname = NULL;
1662 ITypeInfo *tinfo;
1663
1664 memset(&buf,0,sizeof(buf));
1665 buf.size = xmsg->cbBuffer;
1666 buf.base = HeapAlloc(GetProcessHeap(), 0, xmsg->cbBuffer);
1667 memcpy(buf.base, xmsg->Buffer, xmsg->cbBuffer);
1668 buf.curoff = 0;
1669
1670 TRACE("...\n");
1671
1672 if (xmsg->iMethod < 3) {
1673 ERR("IUnknown methods cannot be marshaled by the typelib marshaler\n");
1674 return E_UNEXPECTED;
1675 }
1676
1677 hres = _get_funcdesc(This->tinfo,xmsg->iMethod,&tinfo,&fdesc,&iname,NULL);
1678 if (hres) {
1679 ERR("GetFuncDesc on method %ld failed with %lx\n",xmsg->iMethod,hres);
1680 return hres;
1681 }
1682
1683 if (iname && !lstrcmpW(iname, IDispatchW))
1684 {
1685 ERR("IDispatch cannot be marshaled by the typelib marshaler\n");
1686 ITypeInfo_Release(tinfo);
1687 return E_UNEXPECTED;
1688 }
1689
1690 if (iname) SysFreeString (iname);
1691
1692 /* Need them for hack below */
1693 memset(names,0,sizeof(names));
1694 ITypeInfo_GetNames(tinfo,fdesc->memid,names,sizeof(names)/sizeof(names[0]),&nrofnames);
1695 if (nrofnames > sizeof(names)/sizeof(names[0])) {
1696 ERR("Need more names!\n");
1697 }
1698
1699 /*dump_FUNCDESC(fdesc);*/
1700 nrofargs = 0;
1701 for (i=0;i<fdesc->cParams;i++)
1702 nrofargs += _argsize(fdesc->lprgelemdescParam[i].tdesc.vt);
1703 args = HeapAlloc(GetProcessHeap(),0,(nrofargs+1)*sizeof(DWORD));
1704 if (!args) return E_OUTOFMEMORY;
1705
1706 /* Allocate all stuff used by call. */
1707 xargs = args+1;
1708 for (i=0;i<fdesc->cParams;i++) {
1709 ELEMDESC *elem = fdesc->lprgelemdescParam+i;
1710
1711 hres = deserialize_param(
1712 tinfo,
1713 elem->u.paramdesc.wParamFlags & PARAMFLAG_FIN || !elem->u.paramdesc.wParamFlags,
1714 FALSE,
1715 TRUE,
1716 &(elem->tdesc),
1717 xargs,
1718 &buf
1719 );
1720 xargs += _argsize(elem->tdesc.vt);
1721 if (hres) {
1722 ERR("Failed to deserialize param %s, hres %lx\n",relaystr(names[i+1]),hres);
1723 break;
1724 }
1725 }
1726
1727 args[0] = (DWORD)This->pUnk;
1728 res = _invoke(
1729 (*((FARPROC**)args[0]))[fdesc->oVft/4],
1730 fdesc->callconv,
1731 (xargs-args),
1732 args
1733 );
1734 buf.curoff = 0;
1735
1736 xargs = args+1;
1737 for (i=0;i<fdesc->cParams;i++) {
1738 ELEMDESC *elem = fdesc->lprgelemdescParam+i;
1739 hres = serialize_param(
1740 tinfo,
1741 elem->u.paramdesc.wParamFlags & PARAMFLAG_FOUT,
1742 FALSE,
1743 TRUE,
1744 &elem->tdesc,
1745 xargs,
1746 &buf
1747 );
1748 xargs += _argsize(elem->tdesc.vt);
1749 if (hres) {
1750 ERR("Failed to stuballoc param, hres %lx\n",hres);
1751 break;
1752 }
1753 }
1754
1755 hres = xbuf_add (&buf, (LPBYTE)&res, sizeof(DWORD));
1756 if (hres != S_OK)
1757 return hres;
1758
1759 ITypeInfo_Release(tinfo);
1760 HeapFree(GetProcessHeap(), 0, args);
1761
1762 xmsg->cbBuffer = buf.curoff;
1763 if (rpcchanbuf)
1764 {
1765 hres = IRpcChannelBuffer_GetBuffer(rpcchanbuf, xmsg, &This->iid);
1766 if (hres != S_OK)
1767 ERR("IRpcChannelBuffer_GetBuffer failed with error 0x%08lx\n", hres);
1768 }
1769 else
1770 {
1771 /* FIXME: remove this case when we start sending an IRpcChannelBuffer
1772 * object with builtin OLE */
1773 RPC_STATUS status = I_RpcGetBuffer((RPC_MESSAGE *)xmsg);
1774 if (status != RPC_S_OK)
1775 {
1776 ERR("I_RpcGetBuffer failed with error %ld\n", status);
1777 hres = E_FAIL;
1778 }
1779 }
1780
1781 if (hres == S_OK)
1782 memcpy(xmsg->Buffer, buf.base, buf.curoff);
1783
1784 HeapFree(GetProcessHeap(), 0, buf.base);
1785
1786 TRACE("returning\n");
1787 return hres;
1788 }
1789
1790 static LPRPCSTUBBUFFER WINAPI
1791 TMStubImpl_IsIIDSupported(LPRPCSTUBBUFFER iface, REFIID riid) {
1792 FIXME("Huh (%s)?\n",debugstr_guid(riid));
1793 return NULL;
1794 }
1795
1796 static ULONG WINAPI
1797 TMStubImpl_CountRefs(LPRPCSTUBBUFFER iface) {
1798 TMStubImpl *This = (TMStubImpl *)iface;
1799
1800 FIXME("()\n");
1801 return This->ref; /*FIXME? */
1802 }
1803
1804 static HRESULT WINAPI
1805 TMStubImpl_DebugServerQueryInterface(LPRPCSTUBBUFFER iface, LPVOID *ppv) {
1806 return E_NOTIMPL;
1807 }
1808
1809 static void WINAPI
1810 TMStubImpl_DebugServerRelease(LPRPCSTUBBUFFER iface, LPVOID ppv) {
1811 return;
1812 }
1813
1814 static const IRpcStubBufferVtbl tmstubvtbl = {
1815 TMStubImpl_QueryInterface,
1816 TMStubImpl_AddRef,
1817 TMStubImpl_Release,
1818 TMStubImpl_Connect,
1819 TMStubImpl_Disconnect,
1820 TMStubImpl_Invoke,
1821 TMStubImpl_IsIIDSupported,
1822 TMStubImpl_CountRefs,
1823 TMStubImpl_DebugServerQueryInterface,
1824 TMStubImpl_DebugServerRelease
1825 };
1826
1827 static HRESULT WINAPI
1828 PSFacBuf_CreateStub(
1829 LPPSFACTORYBUFFER iface, REFIID riid,IUnknown *pUnkServer,
1830 IRpcStubBuffer** ppStub
1831 ) {
1832 HRESULT hres;
1833 ITypeInfo *tinfo;
1834 TMStubImpl *stub;
1835
1836 TRACE("(%s,%p,%p)\n",debugstr_guid(riid),pUnkServer,ppStub);
1837 hres = _get_typeinfo_for_iid(riid,&tinfo);
1838 if (hres) {
1839 ERR("No typeinfo for %s?\n",debugstr_guid(riid));
1840 return hres;
1841 }
1842 stub = CoTaskMemAlloc(sizeof(TMStubImpl));
1843 if (!stub)
1844 return E_OUTOFMEMORY;
1845 stub->lpvtbl = &tmstubvtbl;
1846 stub->ref = 1;
1847 stub->tinfo = tinfo;
1848 memcpy(&(stub->iid),riid,sizeof(*riid));
1849 hres = IRpcStubBuffer_Connect((LPRPCSTUBBUFFER)stub,pUnkServer);
1850 *ppStub = (LPRPCSTUBBUFFER)stub;
1851 TRACE("IRpcStubBuffer: %p\n", stub);
1852 if (hres)
1853 ERR("Connect to pUnkServer failed?\n");
1854 return hres;
1855 }
1856
1857 static const IPSFactoryBufferVtbl psfacbufvtbl = {
1858 PSFacBuf_QueryInterface,
1859 PSFacBuf_AddRef,
1860 PSFacBuf_Release,
1861 PSFacBuf_CreateProxy,
1862 PSFacBuf_CreateStub
1863 };
1864
1865 /* This is the whole PSFactoryBuffer object, just the vtableptr */
1866 static const IPSFactoryBufferVtbl *lppsfac = &psfacbufvtbl;
1867
1868 /***********************************************************************
1869 * TMARSHAL_DllGetClassObject
1870 */
1871 HRESULT TMARSHAL_DllGetClassObject(REFCLSID rclsid, REFIID iid,LPVOID *ppv)
1872 {
1873 if (IsEqualIID(iid,&IID_IPSFactoryBuffer)) {
1874 *ppv = &lppsfac;
1875 return S_OK;
1876 }
1877 return E_NOINTERFACE;
1878 }
Maarten's multimedia branch