Add some missing includes which contain used prototypes.
[wine] / dlls / oleaut32 / tmarshal.c
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         ERR("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         hres = S_OK;
512         if (debugout) TRACE_(olerelay)("%lx%lx",arg[0],arg[1]);
513         if (writeit)
514             hres = xbuf_add(buf,(LPBYTE)arg,8);
515         return hres;
516     case VT_BOOL:
517     case VT_ERROR:
518     case VT_UINT:
519     case VT_I4:
520     case VT_R4:
521     case VT_UI4:
522         hres = S_OK;
523         if (debugout) TRACE_(olerelay)("%lx",*arg);
524         if (writeit)
525             hres = xbuf_add(buf,(LPBYTE)arg,sizeof(DWORD));
526         return hres;
527     case VT_I2:
528     case VT_UI2:
529         hres = S_OK;
530         if (debugout) TRACE_(olerelay)("%04lx",*arg & 0xffff);
531         if (writeit)
532             hres = xbuf_add(buf,(LPBYTE)arg,sizeof(DWORD));
533         return hres;
534     case VT_I1:
535     case VT_UI1:
536         hres = S_OK;
537         if (debugout) TRACE_(olerelay)("%02lx",*arg & 0xff);
538         if (writeit)
539             hres = xbuf_add(buf,(LPBYTE)arg,sizeof(DWORD));
540         return hres;
541     case VT_I4|VT_BYREF:
542         hres = S_OK;
543         if (debugout) TRACE_(olerelay)("&0x%lx",*arg);
544         if (writeit)
545             hres = xbuf_add(buf,(LPBYTE)(DWORD*)*arg,sizeof(DWORD));
546         /* do not dealloc at this time */
547         return hres;
548     case VT_VARIANT: {
549         TYPEDESC        tdesc2;
550         VARIANT         *vt = (VARIANT*)arg;
551         DWORD           vttype = V_VT(vt);
552
553         if (debugout) TRACE_(olerelay)("Vt(%ld)(",vttype);
554         tdesc2.vt = vttype;
555         if (writeit) {
556             hres = xbuf_add(buf,(LPBYTE)&vttype,sizeof(vttype));
557             if (hres) return hres;
558         }
559         /* need to recurse since we need to free the stuff */
560         hres = serialize_param(tinfo,writeit,debugout,dealloc,&tdesc2,(DWORD*)&(V_I4(vt)),buf);
561         if (debugout) TRACE_(olerelay)(")");
562         return hres;
563     }
564     case VT_BSTR|VT_BYREF: {
565         if (debugout) TRACE_(olerelay)("[byref]'%s'", *(BSTR*)*arg ? relaystr(*((BSTR*)*arg)) : "<bstr NULL>");
566         if (writeit) {
567             /* ptr to ptr to magic widestring, basically */
568             BSTR *bstr = (BSTR *) *arg;
569             DWORD len;
570             if (!*bstr) {
571                 /* -1 means "null string" which is equivalent to empty string */
572                 len = -1;     
573                 hres = xbuf_add(buf, (LPBYTE)&len,sizeof(DWORD));
574                 if (hres) return hres;
575             } else {
576                 len = *((DWORD*)*bstr-1)/sizeof(WCHAR);
577                 hres = xbuf_add(buf,(LPBYTE)&len,sizeof(DWORD));
578                 if (hres) return hres;
579                 hres = xbuf_add(buf,(LPBYTE)*bstr,len * sizeof(WCHAR));
580                 if (hres) return hres;
581             }
582         }
583
584         if (dealloc && arg) {
585             BSTR *str = *((BSTR **)arg);
586             SysFreeString(*str);
587         }
588         return S_OK;
589     }
590     
591     case VT_BSTR: {
592         if (debugout) {
593             if (*arg)
594                    TRACE_(olerelay)("%s",relaystr((WCHAR*)*arg));
595             else
596                     TRACE_(olerelay)("<bstr NULL>");
597         }
598         if (writeit) {
599             BSTR bstr = (BSTR)*arg;
600             DWORD len;
601             if (!bstr) {
602                 len = -1;
603                 hres = xbuf_add(buf,(LPBYTE)&len,sizeof(DWORD));
604                 if (hres) return hres;
605             } else {
606                 len = *((DWORD*)bstr-1)/sizeof(WCHAR);
607                 hres = xbuf_add(buf,(LPBYTE)&len,sizeof(DWORD));
608                 if (hres) return hres;
609                 hres = xbuf_add(buf,(LPBYTE)bstr,len * sizeof(WCHAR));
610                 if (hres) return hres;
611             }
612         }
613
614         if (dealloc && arg)
615             SysFreeString((BSTR)*arg);
616         return S_OK;
617     }
618     case VT_PTR: {
619         DWORD cookie;
620         BOOL        derefhere = TRUE;
621
622         if (tdesc->u.lptdesc->vt == VT_USERDEFINED) {
623             ITypeInfo   *tinfo2;
624             TYPEATTR    *tattr;
625
626             hres = ITypeInfo_GetRefTypeInfo(tinfo,tdesc->u.lptdesc->u.hreftype,&tinfo2);
627             if (hres) {
628                 ERR("Could not get typeinfo of hreftype %lx for VT_USERDEFINED.\n",tdesc->u.lptdesc->u.hreftype);
629                 return hres;
630             }
631             ITypeInfo_GetTypeAttr(tinfo2,&tattr);
632             switch (tattr->typekind) {
633             case TKIND_ENUM:    /* confirmed */
634             case TKIND_RECORD:  /* FIXME: mostly untested */
635                 derefhere=TRUE;
636                 break;
637             case TKIND_ALIAS:   /* FIXME: untested */
638             case TKIND_DISPATCH:        /* will be done in VT_USERDEFINED case */
639             case TKIND_INTERFACE:       /* will be done in VT_USERDEFINED case */
640                 derefhere=FALSE;
641                 break;
642             default:
643                 FIXME("unhandled switch cases tattr->typekind %d\n", tattr->typekind);
644                 derefhere=FALSE;
645                 break;
646             }
647             ITypeInfo_Release(tinfo2);
648         }
649
650         if (debugout) TRACE_(olerelay)("*");
651         /* Write always, so the other side knows when it gets a NULL pointer.
652          */
653         cookie = *arg ? 0x42424242 : 0;
654         hres = xbuf_add(buf,(LPBYTE)&cookie,sizeof(cookie));
655         if (hres)
656             return hres;
657         if (!*arg) {
658             if (debugout) TRACE_(olerelay)("NULL");
659             return S_OK;
660         }
661         hres = serialize_param(tinfo,writeit,debugout,dealloc,tdesc->u.lptdesc,(DWORD*)*arg,buf);
662         if (derefhere && dealloc) HeapFree(GetProcessHeap(),0,(LPVOID)*arg);
663         return hres;
664     }
665     case VT_UNKNOWN:
666         if (debugout) TRACE_(olerelay)("unk(0x%lx)",*arg);
667         if (writeit)
668             hres = _marshal_interface(buf,&IID_IUnknown,(LPUNKNOWN)*arg);
669         return hres;
670     case VT_DISPATCH:
671         if (debugout) TRACE_(olerelay)("idisp(0x%lx)",*arg);
672         if (writeit)
673             hres = _marshal_interface(buf,&IID_IDispatch,(LPUNKNOWN)*arg);
674         return hres;
675     case VT_VOID:
676         if (debugout) TRACE_(olerelay)("<void>");
677         return S_OK;
678     case VT_USERDEFINED: {
679         ITypeInfo       *tinfo2;
680         TYPEATTR        *tattr;
681
682         hres = ITypeInfo_GetRefTypeInfo(tinfo,tdesc->u.hreftype,&tinfo2);
683         if (hres) {
684             ERR("Could not get typeinfo of hreftype %lx for VT_USERDEFINED.\n",tdesc->u.hreftype);
685             return hres;
686         }
687         ITypeInfo_GetTypeAttr(tinfo2,&tattr);
688         switch (tattr->typekind) {
689         case TKIND_DISPATCH:
690         case TKIND_INTERFACE:
691             if (writeit)
692                hres=_marshal_interface(buf,&(tattr->guid),(LPUNKNOWN)arg);
693             if (dealloc)
694                 IUnknown_Release((LPUNKNOWN)arg);
695             break;
696         case TKIND_RECORD: {
697             int i;
698             if (debugout) TRACE_(olerelay)("{");
699             for (i=0;i<tattr->cVars;i++) {
700                 VARDESC *vdesc;
701                 ELEMDESC *elem2;
702                 TYPEDESC *tdesc2;
703
704                 hres = ITypeInfo2_GetVarDesc(tinfo2, i, &vdesc);
705                 if (hres) {
706                     ERR("Could not get vardesc of %d\n",i);
707                     return hres;
708                 }
709                 /* Need them for hack below */
710                 /*
711                 memset(names,0,sizeof(names));
712                 hres = ITypeInfo_GetNames(tinfo2,vdesc->memid,names,sizeof(names)/sizeof(names[0]),&nrofnames);
713                 if (nrofnames > sizeof(names)/sizeof(names[0])) {
714                     ERR("Need more names!\n");
715                 }
716                 if (!hres && debugout)
717                     TRACE_(olerelay)("%s=",relaystr(names[0]));
718                 */
719                 elem2 = &vdesc->elemdescVar;
720                 tdesc2 = &elem2->tdesc;
721                 hres = serialize_param(
722                     tinfo2,
723                     writeit,
724                     debugout,
725                     dealloc,
726                     tdesc2,
727                     (DWORD*)(((LPBYTE)arg)+vdesc->u.oInst),
728                     buf
729                 );
730                 ITypeInfo_ReleaseVarDesc(tinfo2, vdesc);
731                 if (hres!=S_OK)
732                     return hres;
733                 if (debugout && (i<(tattr->cVars-1)))
734                     TRACE_(olerelay)(",");
735             }
736             if (debugout) TRACE_(olerelay)("}");
737             break;
738         }
739         case TKIND_ALIAS:
740             return serialize_param(tinfo2,writeit,debugout,dealloc,&tattr->tdescAlias,arg,buf);
741         case TKIND_ENUM:
742             hres = S_OK;
743             if (debugout) TRACE_(olerelay)("%lx",*arg);
744             if (writeit)
745                 hres = xbuf_add(buf,(LPBYTE)arg,sizeof(DWORD));
746             return hres;
747         default:
748             FIXME("Unhandled typekind %d\n",tattr->typekind);
749             hres = E_FAIL;
750             break;
751         }
752         ITypeInfo_Release(tinfo2);
753         return hres;
754     }
755     case VT_CARRAY: {
756         ARRAYDESC *adesc = tdesc->u.lpadesc;
757         int i, arrsize = 1;
758
759         if (debugout) TRACE_(olerelay)("carr");
760         for (i=0;i<adesc->cDims;i++) {
761             if (debugout) TRACE_(olerelay)("[%ld]",adesc->rgbounds[i].cElements);
762             arrsize *= adesc->rgbounds[i].cElements;
763         }
764         if (debugout) TRACE_(olerelay)("(vt %d)",adesc->tdescElem.vt);
765         if (debugout) TRACE_(olerelay)("[");
766         for (i=0;i<arrsize;i++) {
767             hres = serialize_param(tinfo, writeit, debugout, dealloc, &adesc->tdescElem, (DWORD*)((LPBYTE)arg+i*_xsize(&adesc->tdescElem)), buf);
768             if (hres)
769                 return hres;
770             if (debugout && (i<arrsize-1)) TRACE_(olerelay)(",");
771         }
772         if (debugout) TRACE_(olerelay)("]");
773         return S_OK;
774     }
775     default:
776         ERR("Unhandled marshal type %d.\n",tdesc->vt);
777         return S_OK;
778     }
779 }
780
781 static HRESULT
782 deserialize_param(
783     ITypeInfo           *tinfo,
784     BOOL                readit,
785     BOOL                debugout,
786     BOOL                alloc,
787     TYPEDESC            *tdesc,
788     DWORD               *arg,
789     marshal_state       *buf)
790 {
791     HRESULT hres = S_OK;
792
793     TRACE("vt %d at %p\n",tdesc->vt,arg);
794
795     while (1) {
796         switch (tdesc->vt) {
797         case VT_EMPTY:
798             if (debugout) TRACE_(olerelay)("<empty>");
799             return S_OK;
800         case VT_NULL:
801             if (debugout) TRACE_(olerelay)("<null>");
802             return S_OK;
803         case VT_VARIANT: {
804             VARIANT     *vt = (VARIANT*)arg;
805
806             if (readit) {
807                 DWORD   vttype;
808                 TYPEDESC        tdesc2;
809                 hres = xbuf_get(buf,(LPBYTE)&vttype,sizeof(vttype));
810                 if (hres) {
811                     FIXME("vt type not read?\n");
812                     return hres;
813                 }
814                 memset(&tdesc2,0,sizeof(tdesc2));
815                 tdesc2.vt = vttype;
816                 V_VT(vt)  = vttype;
817                 if (debugout) TRACE_(olerelay)("Vt(%ld)(",vttype);
818                 hres = deserialize_param(tinfo, readit, debugout, alloc, &tdesc2, (DWORD*)&(V_I4(vt)), buf);
819                 TRACE_(olerelay)(")");
820                 return hres;
821             } else {
822                 VariantInit(vt);
823                 return S_OK;
824             }
825         }
826         case VT_I8:
827         case VT_UI8:
828             if (readit) {
829                 hres = xbuf_get(buf,(LPBYTE)arg,8);
830                 if (hres) ERR("Failed to read integer 8 byte\n");
831             }
832             if (debugout) TRACE_(olerelay)("%lx%lx",arg[0],arg[1]);
833             return hres;
834         case VT_ERROR:
835         case VT_BOOL:
836         case VT_I4:
837         case VT_UINT:
838         case VT_R4:
839         case VT_UI4:
840             if (readit) {
841                 hres = xbuf_get(buf,(LPBYTE)arg,sizeof(DWORD));
842                 if (hres) ERR("Failed to read integer 4 byte\n");
843             }
844             if (debugout) TRACE_(olerelay)("%lx",*arg);
845             return hres;
846         case VT_I2:
847         case VT_UI2:
848             if (readit) {
849                 DWORD x;
850                 hres = xbuf_get(buf,(LPBYTE)&x,sizeof(DWORD));
851                 if (hres) ERR("Failed to read integer 4 byte\n");
852                 memcpy(arg,&x,2);
853             }
854             if (debugout) TRACE_(olerelay)("%04lx",*arg & 0xffff);
855             return hres;
856         case VT_I1:
857         case VT_UI1:
858             if (readit) {
859                 DWORD x;
860                 hres = xbuf_get(buf,(LPBYTE)&x,sizeof(DWORD));
861                 if (hres) ERR("Failed to read integer 4 byte\n");
862                 memcpy(arg,&x,1);
863             }
864             if (debugout) TRACE_(olerelay)("%02lx",*arg & 0xff);
865             return hres;
866         case VT_I4|VT_BYREF:
867             hres = S_OK;
868             if (alloc)
869                 *arg = (DWORD)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(DWORD));
870             if (readit) {
871                 hres = xbuf_get(buf,(LPBYTE)*arg,sizeof(DWORD));
872                 if (hres) ERR("Failed to read integer 4 byte\n");
873             }
874             if (debugout) TRACE_(olerelay)("&0x%lx",*(DWORD*)*arg);
875             return hres;
876         case VT_BSTR|VT_BYREF: {
877             BSTR **bstr = (BSTR **)arg;
878             WCHAR       *str;
879             DWORD       len;
880
881             if (readit) {
882                 hres = xbuf_get(buf,(LPBYTE)&len,sizeof(DWORD));
883                 if (hres) {
884                     ERR("failed to read bstr klen\n");
885                     return hres;
886                 }
887                 if (len == -1) {
888                     *bstr = CoTaskMemAlloc(sizeof(BSTR *));
889                     **bstr = NULL;
890                     if (debugout) TRACE_(olerelay)("<bstr NULL>");
891                 } else {
892                     str  = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,(len+1)*sizeof(WCHAR));
893                     hres = xbuf_get(buf,(LPBYTE)str,len*sizeof(WCHAR));
894                     if (hres) {
895                         ERR("Failed to read BSTR.\n");
896                         return hres;
897                     }
898                     *bstr = CoTaskMemAlloc(sizeof(BSTR *));
899                     **bstr = SysAllocStringLen(str,len);
900                     if (debugout) TRACE_(olerelay)("%s",relaystr(str));
901                     HeapFree(GetProcessHeap(),0,str);
902                 }
903             } else {
904                 *bstr = NULL;
905             }
906             return S_OK;
907         }
908         case VT_BSTR: {
909             WCHAR       *str;
910             DWORD       len;
911
912             if (readit) {
913                 hres = xbuf_get(buf,(LPBYTE)&len,sizeof(DWORD));
914                 if (hres) {
915                     ERR("failed to read bstr klen\n");
916                     return hres;
917                 }
918                 if (len == -1) {
919                     *arg = 0;
920                     if (debugout) TRACE_(olerelay)("<bstr NULL>");
921                 } else {
922                     str  = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,(len+1)*sizeof(WCHAR));
923                     hres = xbuf_get(buf,(LPBYTE)str,len*sizeof(WCHAR));
924                     if (hres) {
925                         ERR("Failed to read BSTR.\n");
926                         return hres;
927                     }
928                     *arg = (DWORD)SysAllocStringLen(str,len);
929                     if (debugout) TRACE_(olerelay)("%s",relaystr(str));
930                     HeapFree(GetProcessHeap(),0,str);
931                 }
932             } else {
933                 *arg = 0;
934             }
935             return S_OK;
936         }
937         case VT_PTR: {
938             DWORD       cookie;
939             BOOL        derefhere = TRUE;
940
941             if (tdesc->u.lptdesc->vt == VT_USERDEFINED) {
942                 ITypeInfo       *tinfo2;
943                 TYPEATTR        *tattr;
944
945                 hres = ITypeInfo_GetRefTypeInfo(tinfo,tdesc->u.lptdesc->u.hreftype,&tinfo2);
946                 if (hres) {
947                     ERR("Could not get typeinfo of hreftype %lx for VT_USERDEFINED.\n",tdesc->u.lptdesc->u.hreftype);
948                     return hres;
949                 }
950                 ITypeInfo_GetTypeAttr(tinfo2,&tattr);
951                 switch (tattr->typekind) {
952                 case TKIND_ENUM:        /* confirmed */
953                 case TKIND_RECORD:      /* FIXME: mostly untested */
954                     derefhere=TRUE;
955                     break;
956                 case TKIND_ALIAS:       /* FIXME: untested */
957                 case TKIND_DISPATCH:    /* will be done in VT_USERDEFINED case */
958                 case TKIND_INTERFACE:   /* will be done in VT_USERDEFINED case */
959                     derefhere=FALSE;
960                     break;
961                 default:
962                     FIXME("unhandled switch cases tattr->typekind %d\n", tattr->typekind);
963                     derefhere=FALSE;
964                     break;
965                 }
966                 ITypeInfo_Release(tinfo2);
967             }
968             /* read it in all cases, we need to know if we have 
969              * NULL pointer or not.
970              */
971             hres = xbuf_get(buf,(LPBYTE)&cookie,sizeof(cookie));
972             if (hres) {
973                 ERR("Failed to load pointer cookie.\n");
974                 return hres;
975             }
976             if (cookie != 0x42424242) {
977                 /* we read a NULL ptr from the remote side */
978                 if (debugout) TRACE_(olerelay)("NULL");
979                 *arg = 0;
980                 return S_OK;
981             }
982             if (debugout) TRACE_(olerelay)("*");
983             if (alloc) {
984                 /* Allocate space for the referenced struct */
985                 if (derefhere)
986                     *arg=(DWORD)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,_xsize(tdesc->u.lptdesc));
987             }
988             if (derefhere)
989                 return deserialize_param(tinfo, readit, debugout, alloc, tdesc->u.lptdesc, (LPDWORD)*arg, buf);
990             else
991                 return deserialize_param(tinfo, readit, debugout, alloc, tdesc->u.lptdesc, arg, buf);
992         }
993         case VT_UNKNOWN:
994             /* FIXME: UNKNOWN is unknown ..., but allocate 4 byte for it */
995             if (alloc)
996                 *arg=(DWORD)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(DWORD));
997             hres = S_OK;
998             if (readit)
999                 hres = _unmarshal_interface(buf,&IID_IUnknown,(LPUNKNOWN*)arg);
1000             if (debugout)
1001                 TRACE_(olerelay)("unk(%p)",arg);
1002             return hres;
1003         case VT_DISPATCH:
1004             hres = S_OK;
1005             if (readit)
1006                 hres = _unmarshal_interface(buf,&IID_IDispatch,(LPUNKNOWN*)arg);
1007             if (debugout)
1008                 TRACE_(olerelay)("idisp(%p)",arg);
1009             return hres;
1010         case VT_VOID:
1011             if (debugout) TRACE_(olerelay)("<void>");
1012             return S_OK;
1013         case VT_USERDEFINED: {
1014             ITypeInfo   *tinfo2;
1015             TYPEATTR    *tattr;
1016
1017             hres = ITypeInfo_GetRefTypeInfo(tinfo,tdesc->u.hreftype,&tinfo2);
1018             if (hres) {
1019                 ERR("Could not get typeinfo of hreftype %lx for VT_USERDEFINED.\n",tdesc->u.hreftype);
1020                 return hres;
1021             }
1022             hres = ITypeInfo_GetTypeAttr(tinfo2,&tattr);
1023             if (hres) {
1024                 ERR("Could not get typeattr in VT_USERDEFINED.\n");
1025             } else {
1026                 switch (tattr->typekind) {
1027                 case TKIND_DISPATCH:
1028                 case TKIND_INTERFACE:
1029                     if (readit)
1030                         hres = _unmarshal_interface(buf,&(tattr->guid),(LPUNKNOWN*)arg);
1031                     break;
1032                 case TKIND_RECORD: {
1033                     int i;
1034
1035                     if (alloc)
1036                         *arg = (DWORD)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,tattr->cbSizeInstance);
1037
1038                     if (debugout) TRACE_(olerelay)("{");
1039                     for (i=0;i<tattr->cVars;i++) {
1040                         VARDESC *vdesc;
1041
1042                         hres = ITypeInfo2_GetVarDesc(tinfo2, i, &vdesc);
1043                         if (hres) {
1044                             ERR("Could not get vardesc of %d\n",i);
1045                             return hres;
1046                         }
1047                         hres = deserialize_param(
1048                             tinfo2,
1049                             readit,
1050                             debugout,
1051                             alloc,
1052                             &vdesc->elemdescVar.tdesc,
1053                             (DWORD*)(((LPBYTE)*arg)+vdesc->u.oInst),
1054                             buf
1055                         );
1056                         ITypeInfo2_ReleaseVarDesc(tinfo2, vdesc);
1057                         if (debugout && (i<tattr->cVars-1)) TRACE_(olerelay)(",");
1058                     }
1059                     if (debugout) TRACE_(olerelay)("}");
1060                     break;
1061                 }
1062                 case TKIND_ALIAS:
1063                     return deserialize_param(tinfo2,readit,debugout,alloc,&tattr->tdescAlias,arg,buf);
1064                 case TKIND_ENUM:
1065                     if (readit) {
1066                         hres = xbuf_get(buf,(LPBYTE)arg,sizeof(DWORD));
1067                         if (hres) ERR("Failed to read enum (4 byte)\n");
1068                     }
1069                     if (debugout) TRACE_(olerelay)("%lx",*arg);
1070                     return hres;
1071                 default:
1072                     ERR("Unhandled typekind %d\n",tattr->typekind);
1073                     hres = E_FAIL;
1074                     break;
1075                 }
1076             }
1077             if (hres)
1078                 ERR("failed to stuballoc in TKIND_RECORD.\n");
1079             ITypeInfo_Release(tinfo2);
1080             return hres;
1081         }
1082         case VT_CARRAY: {
1083             /* arg is pointing to the start of the array. */
1084             ARRAYDESC *adesc = tdesc->u.lpadesc;
1085             int         arrsize,i;
1086             arrsize = 1;
1087             if (adesc->cDims > 1) FIXME("cDims > 1 in VT_CARRAY. Does it work?\n");
1088             for (i=0;i<adesc->cDims;i++)
1089                 arrsize *= adesc->rgbounds[i].cElements;
1090             for (i=0;i<arrsize;i++)
1091                 deserialize_param(
1092                     tinfo,
1093                     readit,
1094                     debugout,
1095                     alloc,
1096                     &adesc->tdescElem,
1097                     (DWORD*)((LPBYTE)(arg)+i*_xsize(&adesc->tdescElem)),
1098                     buf
1099                 );
1100             return S_OK;
1101         }
1102         default:
1103             ERR("No handler for VT type %d!\n",tdesc->vt);
1104             return S_OK;
1105         }
1106     }
1107 }
1108
1109 /* Searches function, also in inherited interfaces */
1110 static HRESULT
1111 _get_funcdesc(
1112     ITypeInfo *tinfo, int iMethod, ITypeInfo **tactual, const FUNCDESC **fdesc, BSTR *iname, BSTR *fname)
1113 {
1114     int i = 0, j = 0;
1115     HRESULT hres;
1116
1117     if (fname) *fname = NULL;
1118     if (iname) *iname = NULL;
1119
1120     *tactual = tinfo;
1121     ITypeInfo_AddRef(*tactual);
1122
1123     while (1) {
1124         hres = ITypeInfoImpl_GetInternalFuncDesc(tinfo, i, fdesc);
1125
1126         if (hres) {
1127             ITypeInfo   *tinfo2;
1128             HREFTYPE    href;
1129             TYPEATTR    *attr;
1130
1131             hres = ITypeInfo_GetTypeAttr(tinfo, &attr);
1132             if (hres) {
1133                 ERR("GetTypeAttr failed with %lx\n",hres);
1134                 return hres;
1135             }
1136             /* Not found, so look in inherited ifaces. */
1137             for (j=0;j<attr->cImplTypes;j++) {
1138                 hres = ITypeInfo_GetRefTypeOfImplType(tinfo, j, &href);
1139                 if (hres) {
1140                     ERR("Did not find a reftype for interface offset %d?\n",j);
1141                     break;
1142                 }
1143                 hres = ITypeInfo_GetRefTypeInfo(tinfo, href, &tinfo2);
1144                 if (hres) {
1145                     ERR("Did not find a typeinfo for reftype %ld?\n",href);
1146                     continue;
1147                 }
1148                 hres = _get_funcdesc(tinfo2,iMethod,tactual,fdesc,iname,fname);
1149                 ITypeInfo_Release(tinfo2);
1150                 if (!hres) return S_OK;
1151             }
1152             return hres;
1153         }
1154         if (((*fdesc)->oVft/4) == iMethod) {
1155             if (fname)
1156                 ITypeInfo_GetDocumentation(tinfo,(*fdesc)->memid,fname,NULL,NULL,NULL);
1157             if (iname)
1158                 ITypeInfo_GetDocumentation(tinfo,-1,iname,NULL,NULL,NULL);
1159             return S_OK;
1160         }
1161         i++;
1162     }
1163 }
1164
1165 static DWORD
1166 xCall(LPVOID retptr, int method, TMProxyImpl *tpinfo /*, args */)
1167 {
1168     DWORD               *args = ((DWORD*)&tpinfo)+1, *xargs;
1169     const FUNCDESC      *fdesc;
1170     HRESULT             hres;
1171     int                 i, relaydeb = TRACE_ON(olerelay);
1172     marshal_state       buf;
1173     RPCOLEMESSAGE       msg;
1174     ULONG               status;
1175     BSTR                fname,iname;
1176     BSTR                names[10];
1177     UINT                nrofnames;
1178     DWORD               remoteresult = 0;
1179     ITypeInfo           *tinfo;
1180     IRpcChannelBuffer *chanbuf;
1181
1182     EnterCriticalSection(&tpinfo->crit);
1183
1184     hres = _get_funcdesc(tpinfo->tinfo,method,&tinfo,&fdesc,&iname,&fname);
1185     if (hres) {
1186         ERR("Did not find typeinfo/funcdesc entry for method %d!\n",method);
1187         ITypeInfo_Release(tinfo);
1188         LeaveCriticalSection(&tpinfo->crit);
1189         return E_FAIL;
1190     }
1191
1192     if (!tpinfo->chanbuf)
1193     {
1194         WARN("Tried to use disconnected proxy\n");
1195         ITypeInfo_Release(tinfo);
1196         LeaveCriticalSection(&tpinfo->crit);
1197         return RPC_E_DISCONNECTED;
1198     }
1199     chanbuf = tpinfo->chanbuf;
1200     IRpcChannelBuffer_AddRef(chanbuf);
1201
1202     LeaveCriticalSection(&tpinfo->crit);
1203
1204     if (relaydeb) {
1205        TRACE_(olerelay)("->");
1206         if (iname)
1207             TRACE_(olerelay)("%s:",relaystr(iname));
1208         if (fname)
1209             TRACE_(olerelay)("%s(%d)",relaystr(fname),method);
1210         else
1211             TRACE_(olerelay)("%d",method);
1212         TRACE_(olerelay)("(");
1213     }
1214
1215     if (iname) SysFreeString(iname);
1216     if (fname) SysFreeString(fname);
1217
1218     memset(&buf,0,sizeof(buf));
1219
1220     /* normal typelib driven serializing */
1221
1222     /* Need them for hack below */
1223     memset(names,0,sizeof(names));
1224     if (ITypeInfo_GetNames(tinfo,fdesc->memid,names,sizeof(names)/sizeof(names[0]),&nrofnames))
1225         nrofnames = 0;
1226     if (nrofnames > sizeof(names)/sizeof(names[0]))
1227         ERR("Need more names!\n");
1228
1229     xargs = args;
1230     for (i=0;i<fdesc->cParams;i++) {
1231         ELEMDESC        *elem = fdesc->lprgelemdescParam+i;
1232         if (relaydeb) {
1233             if (i) TRACE_(olerelay)(",");
1234             if (i+1<nrofnames && names[i+1])
1235                 TRACE_(olerelay)("%s=",relaystr(names[i+1]));
1236         }
1237         /* No need to marshal other data than FIN and any VT_PTR. */
1238         if (!(elem->u.paramdesc.wParamFlags & PARAMFLAG_FIN || !elem->u.paramdesc.wParamFlags) && (elem->tdesc.vt != VT_PTR)) {
1239             xargs+=_argsize(elem->tdesc.vt);
1240             if (relaydeb) TRACE_(olerelay)("[out]");
1241             continue;
1242         }
1243         hres = serialize_param(
1244             tinfo,
1245             elem->u.paramdesc.wParamFlags & PARAMFLAG_FIN || !elem->u.paramdesc.wParamFlags,
1246             relaydeb,
1247             FALSE,
1248             &elem->tdesc,
1249             xargs,
1250             &buf
1251         );
1252
1253         if (hres) {
1254             ERR("Failed to serialize param, hres %lx\n",hres);
1255             break;
1256         }
1257         xargs+=_argsize(elem->tdesc.vt);
1258     }
1259     if (relaydeb) TRACE_(olerelay)(")");
1260
1261     memset(&msg,0,sizeof(msg));
1262     msg.cbBuffer = buf.curoff;
1263     msg.iMethod  = method;
1264     hres = IRpcChannelBuffer_GetBuffer(chanbuf,&msg,&(tpinfo->iid));
1265     if (hres) {
1266         ERR("RpcChannelBuffer GetBuffer failed, %lx\n",hres);
1267         goto exit;
1268     }
1269     memcpy(msg.Buffer,buf.base,buf.curoff);
1270     if (relaydeb) TRACE_(olerelay)("\n");
1271     hres = IRpcChannelBuffer_SendReceive(chanbuf,&msg,&status);
1272     if (hres) {
1273         ERR("RpcChannelBuffer SendReceive failed, %lx\n",hres);
1274         goto exit;
1275     }
1276
1277     if (relaydeb) TRACE_(olerelay)(" status = %08lx (",status);
1278     if (buf.base)
1279         buf.base = HeapReAlloc(GetProcessHeap(),0,buf.base,msg.cbBuffer);
1280     else
1281         buf.base = HeapAlloc(GetProcessHeap(),0,msg.cbBuffer);
1282     buf.size = msg.cbBuffer;
1283     memcpy(buf.base,msg.Buffer,buf.size);
1284     buf.curoff = 0;
1285
1286     /* generic deserializer using typelib description */
1287     xargs = args;
1288     status = S_OK;
1289     for (i=0;i<fdesc->cParams;i++) {
1290         ELEMDESC        *elem = fdesc->lprgelemdescParam+i;
1291
1292         if (relaydeb) {
1293             if (i) TRACE_(olerelay)(",");
1294             if (i+1<nrofnames && names[i+1]) TRACE_(olerelay)("%s=",relaystr(names[i+1]));
1295         }
1296         /* No need to marshal other data than FOUT and any VT_PTR */
1297         if (!(elem->u.paramdesc.wParamFlags & PARAMFLAG_FOUT) && (elem->tdesc.vt != VT_PTR)) {
1298             xargs += _argsize(elem->tdesc.vt);
1299             if (relaydeb) TRACE_(olerelay)("[in]");
1300             continue;
1301         }
1302         hres = deserialize_param(
1303             tinfo,
1304             elem->u.paramdesc.wParamFlags & PARAMFLAG_FOUT,
1305             relaydeb,
1306             FALSE,
1307             &(elem->tdesc),
1308             xargs,
1309             &buf
1310         );
1311         if (hres) {
1312             ERR("Failed to unmarshall param, hres %lx\n",hres);
1313             status = hres;
1314             break;
1315         }
1316         xargs += _argsize(elem->tdesc.vt);
1317     }
1318
1319     hres = xbuf_get(&buf, (LPBYTE)&remoteresult, sizeof(DWORD));
1320     if (hres != S_OK)
1321         goto exit;
1322     if (relaydeb) TRACE_(olerelay)(") = %08lx\n", remoteresult);
1323
1324     hres = remoteresult;
1325
1326 exit:
1327     HeapFree(GetProcessHeap(),0,buf.base);
1328     IRpcChannelBuffer_Release(chanbuf);
1329     ITypeInfo_Release(tinfo);
1330     TRACE("-- 0x%08lx\n", hres);
1331     return hres;
1332 }
1333
1334 HRESULT WINAPI ProxyIUnknown_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
1335 {
1336     TMProxyImpl *proxy = (TMProxyImpl *)iface;
1337
1338     TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
1339
1340     if (proxy->outerunknown)
1341         return IUnknown_QueryInterface(proxy->outerunknown, riid, ppv);
1342
1343     FIXME("No interface\n");
1344     return E_NOINTERFACE;
1345 }
1346
1347 ULONG WINAPI ProxyIUnknown_AddRef(IUnknown *iface)
1348 {
1349     TMProxyImpl *proxy = (TMProxyImpl *)iface;
1350
1351     TRACE("\n");
1352
1353     if (proxy->outerunknown)
1354         return IUnknown_AddRef(proxy->outerunknown);
1355
1356     return 2; /* FIXME */
1357 }
1358
1359 ULONG WINAPI ProxyIUnknown_Release(IUnknown *iface)
1360 {
1361     TMProxyImpl *proxy = (TMProxyImpl *)iface;
1362
1363     TRACE("\n");
1364
1365     if (proxy->outerunknown)
1366         return IUnknown_Release(proxy->outerunknown);
1367
1368     return 1; /* FIXME */
1369 }
1370
1371 static HRESULT WINAPI ProxyIDispatch_GetTypeInfoCount(LPDISPATCH iface, UINT * pctinfo)
1372 {
1373     TMProxyImpl *This = (TMProxyImpl *)iface;
1374     HRESULT hr;
1375
1376     TRACE("(%p)\n", pctinfo);
1377
1378     if (!This->dispatch)
1379     {
1380         hr = IUnknown_QueryInterface(This->outerunknown, &IID_IDispatch,
1381                                      (LPVOID *)&This->dispatch);
1382     }
1383     if (This->dispatch)
1384         hr = IDispatch_GetTypeInfoCount(This->dispatch, pctinfo);
1385
1386     return hr;
1387 }
1388
1389 static HRESULT WINAPI ProxyIDispatch_GetTypeInfo(LPDISPATCH iface, UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo)
1390 {
1391     TMProxyImpl *This = (TMProxyImpl *)iface;
1392     HRESULT hr = S_OK;
1393
1394     TRACE("(%d, %lx, %p)\n", iTInfo, lcid, ppTInfo);
1395
1396     if (!This->dispatch)
1397     {
1398         hr = IUnknown_QueryInterface(This->outerunknown, &IID_IDispatch,
1399                                      (LPVOID *)&This->dispatch);
1400     }
1401     if (This->dispatch)
1402         hr = IDispatch_GetTypeInfo(This->dispatch, iTInfo, lcid, ppTInfo);
1403
1404     return hr;
1405 }
1406
1407 static HRESULT WINAPI ProxyIDispatch_GetIDsOfNames(LPDISPATCH iface, REFIID riid, LPOLESTR * rgszNames, UINT cNames, LCID lcid, DISPID * rgDispId)
1408 {
1409     TMProxyImpl *This = (TMProxyImpl *)iface;
1410     HRESULT hr;
1411
1412     TRACE("(%s, %p, %d, 0x%lx, %p)\n", debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
1413
1414     if (!This->dispatch)
1415     {
1416         hr = IUnknown_QueryInterface(This->outerunknown, &IID_IDispatch,
1417                                      (LPVOID *)&This->dispatch);
1418     }
1419     if (This->dispatch)
1420         hr = IDispatch_GetIDsOfNames(This->dispatch, riid, rgszNames,
1421                                      cNames, lcid, rgDispId);
1422
1423     return hr;
1424 }
1425
1426 static HRESULT WINAPI ProxyIDispatch_Invoke(LPDISPATCH iface, DISPID dispIdMember, REFIID riid, LCID lcid,
1427                                             WORD wFlags, DISPPARAMS * pDispParams, VARIANT * pVarResult,
1428                                             EXCEPINFO * pExcepInfo, UINT * puArgErr)
1429 {
1430     TMProxyImpl *This = (TMProxyImpl *)iface;
1431     HRESULT hr;
1432
1433     TRACE("(%ld, %s, 0x%lx, 0x%x, %p, %p, %p, %p)\n", dispIdMember, debugstr_guid(riid), lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1434
1435     if (!This->dispatch)
1436     {
1437         hr = IUnknown_QueryInterface(This->outerunknown, &IID_IDispatch,
1438                                      (LPVOID *)&This->dispatch);
1439     }
1440     if (This->dispatch)
1441         hr = IDispatch_Invoke(This->dispatch, dispIdMember, riid, lcid,
1442                               wFlags, pDispParams, pVarResult, pExcepInfo,
1443                               puArgErr);
1444
1445     return hr;
1446 }
1447
1448 static HRESULT WINAPI
1449 PSFacBuf_CreateProxy(
1450     LPPSFACTORYBUFFER iface, IUnknown* pUnkOuter, REFIID riid,
1451     IRpcProxyBuffer **ppProxy, LPVOID *ppv)
1452 {
1453     HRESULT     hres;
1454     ITypeInfo   *tinfo;
1455     int         i, nroffuncs;
1456     const FUNCDESC *fdesc;
1457     TMProxyImpl *proxy;
1458     TYPEATTR    *typeattr;
1459
1460     TRACE("(...%s...)\n",debugstr_guid(riid));
1461     hres = _get_typeinfo_for_iid(riid,&tinfo);
1462     if (hres) {
1463         ERR("No typeinfo for %s?\n",debugstr_guid(riid));
1464         return hres;
1465     }
1466     nroffuncs = _nroffuncs(tinfo);
1467     proxy = CoTaskMemAlloc(sizeof(TMProxyImpl));
1468     if (!proxy) return E_OUTOFMEMORY;
1469
1470     assert(sizeof(TMAsmProxy) == 12);
1471
1472     proxy->dispatch = NULL;
1473     proxy->outerunknown = pUnkOuter;
1474     proxy->asmstubs = VirtualAlloc(NULL, sizeof(TMAsmProxy) * nroffuncs, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
1475     if (!proxy->asmstubs) {
1476         ERR("Could not commit pages for proxy thunks\n");
1477         CoTaskMemFree(proxy);
1478         return E_OUTOFMEMORY;
1479     }
1480
1481     InitializeCriticalSection(&proxy->crit);
1482
1483     proxy->lpvtbl = HeapAlloc(GetProcessHeap(),0,sizeof(LPBYTE)*nroffuncs);
1484     for (i=0;i<nroffuncs;i++) {
1485         TMAsmProxy      *xasm = proxy->asmstubs+i;
1486
1487         switch (i) {
1488         case 0:
1489                 proxy->lpvtbl[i] = ProxyIUnknown_QueryInterface;
1490                 break;
1491         case 1:
1492                 proxy->lpvtbl[i] = ProxyIUnknown_AddRef;
1493                 break;
1494         case 2:
1495                 proxy->lpvtbl[i] = ProxyIUnknown_Release;
1496                 break;
1497         default: {
1498                 int j;
1499                 /* nrofargs without This */
1500                 int nrofargs;
1501                 ITypeInfo *tinfo2;
1502                 hres = _get_funcdesc(tinfo,i,&tinfo2,&fdesc,NULL,NULL);
1503                 ITypeInfo_Release(tinfo2);
1504                 if (hres) {
1505                     ERR("GetFuncDesc %lx should not fail here.\n",hres);
1506                     return hres;
1507                 }
1508                 /* some args take more than 4 byte on the stack */
1509                 nrofargs = 0;
1510                 for (j=0;j<fdesc->cParams;j++)
1511                     nrofargs += _argsize(fdesc->lprgelemdescParam[j].tdesc.vt);
1512
1513 #ifdef __i386__
1514                 if (fdesc->callconv != CC_STDCALL) {
1515                     ERR("calling convention is not stdcall????\n");
1516                     return E_FAIL;
1517                 }
1518 /* popl %eax    -       return ptr
1519  * pushl <nr>
1520  * pushl %eax
1521  * call xCall
1522  * lret <nr> (+4)
1523  *
1524  *
1525  * arg3 arg2 arg1 <method> <returnptr>
1526  */
1527                 xasm->popleax   = 0x58;
1528                 xasm->pushlval  = 0x6a;
1529                 xasm->nr        = i;
1530                 xasm->pushleax  = 0x50;
1531                 xasm->lcall     = 0xe8; /* relative jump */
1532                 xasm->xcall     = (DWORD)xCall;
1533                 xasm->xcall     -= (DWORD)&(xasm->lret);
1534                 xasm->lret      = 0xc2;
1535                 xasm->bytestopop= (nrofargs+2)*4; /* pop args, This, iMethod */
1536                 proxy->lpvtbl[i] = xasm;
1537                 break;
1538 #else
1539                 FIXME("not implemented on non i386\n");
1540                 return E_FAIL;
1541 #endif
1542             }
1543         }
1544     }
1545
1546     /* if we derive from IDispatch then defer to its proxy for its methods */
1547     hres = ITypeInfo_GetTypeAttr(tinfo, &typeattr);
1548     if (hres == S_OK)
1549     {
1550         if (typeattr->wTypeFlags & TYPEFLAG_FDISPATCHABLE)
1551         {
1552             proxy->lpvtbl[3] = ProxyIDispatch_GetTypeInfoCount;
1553             proxy->lpvtbl[4] = ProxyIDispatch_GetTypeInfo;
1554             proxy->lpvtbl[5] = ProxyIDispatch_GetIDsOfNames;
1555             proxy->lpvtbl[6] = ProxyIDispatch_Invoke;
1556         }
1557         ITypeInfo_ReleaseTypeAttr(tinfo, typeattr);
1558     }
1559
1560     proxy->lpvtbl2      = &tmproxyvtable;
1561     /* one reference for the proxy */
1562     proxy->ref          = 1;
1563     proxy->tinfo        = tinfo;
1564     memcpy(&proxy->iid,riid,sizeof(*riid));
1565     proxy->chanbuf      = 0;
1566     *ppv                = (LPVOID)proxy;
1567     *ppProxy            = (IRpcProxyBuffer *)&(proxy->lpvtbl2);
1568     IUnknown_AddRef((IUnknown *)*ppv);
1569     return S_OK;
1570 }
1571
1572 typedef struct _TMStubImpl {
1573     const IRpcStubBufferVtbl   *lpvtbl;
1574     LONG                        ref;
1575
1576     LPUNKNOWN                   pUnk;
1577     ITypeInfo                   *tinfo;
1578     IID                         iid;
1579 } TMStubImpl;
1580
1581 static HRESULT WINAPI
1582 TMStubImpl_QueryInterface(LPRPCSTUBBUFFER iface, REFIID riid, LPVOID *ppv)
1583 {
1584     if (IsEqualIID(riid,&IID_IRpcStubBuffer)||IsEqualIID(riid,&IID_IUnknown)){
1585         *ppv = (LPVOID)iface;
1586         IRpcStubBuffer_AddRef(iface);
1587         return S_OK;
1588     }
1589     FIXME("%s, not supported IID.\n",debugstr_guid(riid));
1590     return E_NOINTERFACE;
1591 }
1592
1593 static ULONG WINAPI
1594 TMStubImpl_AddRef(LPRPCSTUBBUFFER iface)
1595 {
1596     TMStubImpl *This = (TMStubImpl *)iface;
1597     ULONG refCount = InterlockedIncrement(&This->ref);
1598         
1599     TRACE("(%p)->(ref before=%lu)\n", This, refCount - 1);
1600
1601     return refCount;
1602 }
1603
1604 static ULONG WINAPI
1605 TMStubImpl_Release(LPRPCSTUBBUFFER iface)
1606 {
1607     TMStubImpl *This = (TMStubImpl *)iface;
1608     ULONG refCount = InterlockedDecrement(&This->ref);
1609
1610     TRACE("(%p)->(ref before=%lu)\n", This, refCount + 1);
1611
1612     if (!refCount)
1613     {
1614         IRpcStubBuffer_Disconnect(iface);
1615         ITypeInfo_Release(This->tinfo);
1616         CoTaskMemFree(This);
1617     }
1618     return refCount;
1619 }
1620
1621 static HRESULT WINAPI
1622 TMStubImpl_Connect(LPRPCSTUBBUFFER iface, LPUNKNOWN pUnkServer)
1623 {
1624     TMStubImpl *This = (TMStubImpl *)iface;
1625
1626     TRACE("(%p)->(%p)\n", This, pUnkServer);
1627
1628     IUnknown_AddRef(pUnkServer);
1629     This->pUnk = pUnkServer;
1630     return S_OK;
1631 }
1632
1633 static void WINAPI
1634 TMStubImpl_Disconnect(LPRPCSTUBBUFFER iface)
1635 {
1636     TMStubImpl *This = (TMStubImpl *)iface;
1637
1638     TRACE("(%p)->()\n", This);
1639
1640     if (This->pUnk)
1641     {
1642         IUnknown_Release(This->pUnk);
1643         This->pUnk = NULL;
1644     }
1645 }
1646
1647 static HRESULT WINAPI
1648 TMStubImpl_Invoke(
1649     LPRPCSTUBBUFFER iface, RPCOLEMESSAGE* xmsg,IRpcChannelBuffer*rpcchanbuf)
1650 {
1651     int         i;
1652     const FUNCDESC *fdesc;
1653     TMStubImpl *This = (TMStubImpl *)iface;
1654     HRESULT     hres;
1655     DWORD       *args, res, *xargs, nrofargs;
1656     marshal_state       buf;
1657     UINT        nrofnames;
1658     BSTR        names[10];
1659     BSTR        iname = NULL;
1660     ITypeInfo   *tinfo;
1661
1662     memset(&buf,0,sizeof(buf));
1663     buf.size    = xmsg->cbBuffer;
1664     buf.base    = HeapAlloc(GetProcessHeap(), 0, xmsg->cbBuffer);
1665     memcpy(buf.base, xmsg->Buffer, xmsg->cbBuffer);
1666     buf.curoff  = 0;
1667
1668     TRACE("...\n");
1669
1670     if (xmsg->iMethod < 3) {
1671         ERR("IUnknown methods cannot be marshaled by the typelib marshaler\n");
1672         return E_UNEXPECTED;
1673     }
1674
1675     hres = _get_funcdesc(This->tinfo,xmsg->iMethod,&tinfo,&fdesc,&iname,NULL);
1676     if (hres) {
1677         ERR("GetFuncDesc on method %ld failed with %lx\n",xmsg->iMethod,hres);
1678         return hres;
1679     }
1680
1681     if (iname && !lstrcmpW(iname, IDispatchW))
1682     {
1683         ERR("IDispatch cannot be marshaled by the typelib marshaler\n");
1684         ITypeInfo_Release(tinfo);
1685         return E_UNEXPECTED;
1686     }
1687
1688     if (iname) SysFreeString (iname);
1689
1690     /* Need them for hack below */
1691     memset(names,0,sizeof(names));
1692     ITypeInfo_GetNames(tinfo,fdesc->memid,names,sizeof(names)/sizeof(names[0]),&nrofnames);
1693     if (nrofnames > sizeof(names)/sizeof(names[0])) {
1694         ERR("Need more names!\n");
1695     }
1696
1697     /*dump_FUNCDESC(fdesc);*/
1698     nrofargs = 0;
1699     for (i=0;i<fdesc->cParams;i++)
1700         nrofargs += _argsize(fdesc->lprgelemdescParam[i].tdesc.vt);
1701     args = HeapAlloc(GetProcessHeap(),0,(nrofargs+1)*sizeof(DWORD));
1702     if (!args) return E_OUTOFMEMORY;
1703
1704     /* Allocate all stuff used by call. */
1705     xargs = args+1;
1706     for (i=0;i<fdesc->cParams;i++) {
1707         ELEMDESC        *elem = fdesc->lprgelemdescParam+i;
1708
1709         hres = deserialize_param(
1710            tinfo,
1711            elem->u.paramdesc.wParamFlags & PARAMFLAG_FIN || !elem->u.paramdesc.wParamFlags,
1712            FALSE,
1713            TRUE,
1714            &(elem->tdesc),
1715            xargs,
1716            &buf
1717         );
1718         xargs += _argsize(elem->tdesc.vt);
1719         if (hres) {
1720             ERR("Failed to deserialize param %s, hres %lx\n",relaystr(names[i+1]),hres);
1721             break;
1722         }
1723     }
1724
1725     args[0] = (DWORD)This->pUnk;
1726     res = _invoke(
1727         (*((FARPROC**)args[0]))[fdesc->oVft/4],
1728         fdesc->callconv,
1729         (xargs-args),
1730         args
1731     );
1732     buf.curoff = 0;
1733
1734     xargs = args+1;
1735     for (i=0;i<fdesc->cParams;i++) {
1736         ELEMDESC        *elem = fdesc->lprgelemdescParam+i;
1737         hres = serialize_param(
1738            tinfo,
1739            elem->u.paramdesc.wParamFlags & PARAMFLAG_FOUT,
1740            FALSE,
1741            TRUE,
1742            &elem->tdesc,
1743            xargs,
1744            &buf
1745         );
1746         xargs += _argsize(elem->tdesc.vt);
1747         if (hres) {
1748             ERR("Failed to stuballoc param, hres %lx\n",hres);
1749             break;
1750         }
1751     }
1752
1753     hres = xbuf_add (&buf, (LPBYTE)&res, sizeof(DWORD));
1754     if (hres != S_OK)
1755         return hres;
1756
1757     ITypeInfo_Release(tinfo);
1758     HeapFree(GetProcessHeap(), 0, args);
1759
1760     xmsg->cbBuffer      = buf.curoff;
1761     if (rpcchanbuf)
1762     {
1763         hres = IRpcChannelBuffer_GetBuffer(rpcchanbuf, xmsg, &This->iid);
1764         if (hres != S_OK)
1765             ERR("IRpcChannelBuffer_GetBuffer failed with error 0x%08lx\n", hres);
1766     }
1767     else
1768     {
1769         /* FIXME: remove this case when we start sending an IRpcChannelBuffer
1770          * object with builtin OLE */
1771         RPC_STATUS status = I_RpcGetBuffer((RPC_MESSAGE *)xmsg);
1772         if (status != RPC_S_OK)
1773         {
1774             ERR("I_RpcGetBuffer failed with error %ld\n", status);
1775             hres = E_FAIL;
1776         }
1777     }
1778
1779     if (hres == S_OK)
1780         memcpy(xmsg->Buffer, buf.base, buf.curoff);
1781
1782     HeapFree(GetProcessHeap(), 0, buf.base);
1783
1784     TRACE("returning\n");
1785     return hres;
1786 }
1787
1788 static LPRPCSTUBBUFFER WINAPI
1789 TMStubImpl_IsIIDSupported(LPRPCSTUBBUFFER iface, REFIID riid) {
1790     FIXME("Huh (%s)?\n",debugstr_guid(riid));
1791     return NULL;
1792 }
1793
1794 static ULONG WINAPI
1795 TMStubImpl_CountRefs(LPRPCSTUBBUFFER iface) {
1796     TMStubImpl *This = (TMStubImpl *)iface;
1797
1798     FIXME("()\n");
1799     return This->ref; /*FIXME? */
1800 }
1801
1802 static HRESULT WINAPI
1803 TMStubImpl_DebugServerQueryInterface(LPRPCSTUBBUFFER iface, LPVOID *ppv) {
1804     return E_NOTIMPL;
1805 }
1806
1807 static void WINAPI
1808 TMStubImpl_DebugServerRelease(LPRPCSTUBBUFFER iface, LPVOID ppv) {
1809     return;
1810 }
1811
1812 static const IRpcStubBufferVtbl tmstubvtbl = {
1813     TMStubImpl_QueryInterface,
1814     TMStubImpl_AddRef,
1815     TMStubImpl_Release,
1816     TMStubImpl_Connect,
1817     TMStubImpl_Disconnect,
1818     TMStubImpl_Invoke,
1819     TMStubImpl_IsIIDSupported,
1820     TMStubImpl_CountRefs,
1821     TMStubImpl_DebugServerQueryInterface,
1822     TMStubImpl_DebugServerRelease
1823 };
1824
1825 static HRESULT WINAPI
1826 PSFacBuf_CreateStub(
1827     LPPSFACTORYBUFFER iface, REFIID riid,IUnknown *pUnkServer,
1828     IRpcStubBuffer** ppStub
1829 ) {
1830     HRESULT hres;
1831     ITypeInfo   *tinfo;
1832     TMStubImpl  *stub;
1833
1834     TRACE("(%s,%p,%p)\n",debugstr_guid(riid),pUnkServer,ppStub);
1835     hres = _get_typeinfo_for_iid(riid,&tinfo);
1836     if (hres) {
1837         ERR("No typeinfo for %s?\n",debugstr_guid(riid));
1838         return hres;
1839     }
1840     stub = CoTaskMemAlloc(sizeof(TMStubImpl));
1841     if (!stub)
1842         return E_OUTOFMEMORY;
1843     stub->lpvtbl        = &tmstubvtbl;
1844     stub->ref           = 1;
1845     stub->tinfo         = tinfo;
1846     memcpy(&(stub->iid),riid,sizeof(*riid));
1847     hres = IRpcStubBuffer_Connect((LPRPCSTUBBUFFER)stub,pUnkServer);
1848     *ppStub             = (LPRPCSTUBBUFFER)stub;
1849     TRACE("IRpcStubBuffer: %p\n", stub);
1850     if (hres)
1851         ERR("Connect to pUnkServer failed?\n");
1852     return hres;
1853 }
1854
1855 static const IPSFactoryBufferVtbl psfacbufvtbl = {
1856     PSFacBuf_QueryInterface,
1857     PSFacBuf_AddRef,
1858     PSFacBuf_Release,
1859     PSFacBuf_CreateProxy,
1860     PSFacBuf_CreateStub
1861 };
1862
1863 /* This is the whole PSFactoryBuffer object, just the vtableptr */
1864 static const IPSFactoryBufferVtbl *lppsfac = &psfacbufvtbl;
1865
1866 /***********************************************************************
1867  *           TMARSHAL_DllGetClassObject
1868  */
1869 HRESULT TMARSHAL_DllGetClassObject(REFCLSID rclsid, REFIID iid,LPVOID *ppv)
1870 {
1871     if (IsEqualIID(iid,&IID_IPSFactoryBuffer)) {
1872         *ppv = &lppsfac;
1873         return S_OK;
1874     }
1875     return E_NOINTERFACE;
1876 }