projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
reshuffling of dlls
[reactos.git] / reactos / dll / win32 / 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 }
A free Windows-compatible Operating System