git.oblomov.eu Git - wine/blob - dlls/ole32/marshal.c

   1 /*
   2  *      Marshaling library
   3  *
   4  *  Copyright 2002  Marcus Meissner
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <string.h>
  26 #include <assert.h>
  27
  28 #include "windef.h"
  29 #include "objbase.h"
  30 #include "ole2.h"
  31 #include "ole2ver.h"
  32 #include "rpc.h"
  33 #include "winerror.h"
  34 #include "winreg.h"
  35 #include "wownt32.h"
  36 #include "wtypes.h"
  37 #include "wine/unicode.h"
  38 #include "wine/obj_base.h"
  39 #include "wine/obj_clientserver.h"
  40 #include "wine/obj_misc.h"
  41 #include "wine/obj_marshal.h"
  42 #include "wine/obj_storage.h"
  43 #include "wine/obj_channel.h"
  44 #include "wine/winbase16.h"
  45 #include "compobj_private.h"
  46 #include "ifs.h"
  47
  48 #include "wine/debug.h"
  49
  50 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  51
  52 /* Marshaling just passes a unique identifier to the remote client,
  53  * that makes it possible to find the passed interface again.
  54  *
  55  * So basically we need a set of values that make it unique.
  56  *
  57  *      Process Identifier, Object IUnknown ptr, IID
  58  *
  59  * Note that the IUnknown_QI(ob,xiid,&ppv) always returns the SAME ppv value!
  60  */
  61
  62 typedef struct _mid2unknown {
  63     wine_marshal_id     mid;
  64     LPUNKNOWN           pUnk;
  65 } mid2unknown;
  66
  67 typedef struct _mid2stub {
  68     wine_marshal_id     mid;
  69     IRpcStubBuffer      *stub;
  70     LPUNKNOWN           pUnkServer;
  71 } mid2stub;
  72
  73 static mid2stub *stubs = NULL;
  74 static int nrofstubs = 0;
  75
  76 static mid2unknown *proxies = NULL;
  77 static int nrofproxies = 0;
  78
  79 HRESULT
  80 MARSHAL_Find_Stub_Server(wine_marshal_id *mid,LPUNKNOWN *punk) {
  81     int i;
  82
  83     for (i=0;i<nrofstubs;i++) {
  84         if (MARSHAL_Compare_Mids_NoInterface(mid,&(stubs[i].mid))) {
  85             *punk = stubs[i].pUnkServer;
  86             IUnknown_AddRef((*punk));
  87             return S_OK;
  88         }
  89     }
  90     return E_FAIL;
  91 }
  92
  93 HRESULT
  94 MARSHAL_Find_Stub_Buffer(wine_marshal_id *mid,IRpcStubBuffer **stub) {
  95     int i;
  96
  97     for (i=0;i<nrofstubs;i++) {
  98         if (MARSHAL_Compare_Mids(mid,&(stubs[i].mid))) {
  99             *stub = stubs[i].stub;
 100             IUnknown_AddRef((*stub));
 101             return S_OK;
 102         }
 103     }
 104     return E_FAIL;
 105 }
 106
 107 HRESULT
 108 MARSHAL_Find_Stub(wine_marshal_id *mid,LPUNKNOWN *pUnk) {
 109     int i;
 110
 111     for (i=0;i<nrofstubs;i++) {
 112         if (MARSHAL_Compare_Mids(mid,&(stubs[i].mid))) {
 113             *pUnk = stubs[i].pUnkServer;
 114             IUnknown_AddRef((*pUnk));
 115             return S_OK;
 116         }
 117     }
 118     return E_FAIL;
 119 }
 120
 121 HRESULT
 122 MARSHAL_Register_Stub(wine_marshal_id *mid,LPUNKNOWN pUnk,IRpcStubBuffer *stub) {
 123     LPUNKNOWN   xPunk;
 124     if (!MARSHAL_Find_Stub(mid,&xPunk)) {
 125         FIXME("Already have entry for (%lx/%s)!\n",mid->objectid,debugstr_guid(&(mid->iid)));
 126         return S_OK;
 127     }
 128     if (nrofstubs)
 129         stubs=HeapReAlloc(GetProcessHeap(),0,stubs,sizeof(stubs[0])*(nrofstubs+1));
 130     else
 131         stubs=HeapAlloc(GetProcessHeap(),0,sizeof(stubs[0]));
 132     if (!stubs) return E_OUTOFMEMORY;
 133     stubs[nrofstubs].stub = stub;
 134     stubs[nrofstubs].pUnkServer = pUnk;
 135     memcpy(&(stubs[nrofstubs].mid),mid,sizeof(*mid));
 136     nrofstubs++;
 137     return S_OK;
 138 }
 139
 140 HRESULT
 141 MARSHAL_Find_Proxy(wine_marshal_id *mid,LPUNKNOWN *punk) {
 142     int i;
 143
 144     for (i=0;i<nrofproxies;i++)
 145         if (MARSHAL_Compare_Mids(mid,&(proxies[i].mid))) {
 146             *punk = proxies[i].pUnk;
 147             IUnknown_AddRef((*punk));
 148             return S_OK;
 149         }
 150     return E_FAIL;
 151 }
 152
 153 HRESULT
 154 MARSHAL_Find_Proxy_Object(wine_marshal_id *mid,LPUNKNOWN *punk) {
 155     int i;
 156
 157     for (i=0;i<nrofproxies;i++)
 158         if (MARSHAL_Compare_Mids_NoInterface(mid,&(proxies[i].mid))) {
 159             *punk = proxies[i].pUnk;
 160             IUnknown_AddRef((*punk));
 161             return S_OK;
 162         }
 163     return E_FAIL;
 164 }
 165
 166 HRESULT
 167 MARSHAL_Register_Proxy(wine_marshal_id *mid,LPUNKNOWN punk) {
 168     int i;
 169
 170     for (i=0;i<nrofproxies;i++) {
 171         if (MARSHAL_Compare_Mids(mid,&(proxies[i].mid))) {
 172             ERR("Already have mid?\n");
 173             return E_FAIL;
 174         }
 175     }
 176     if (nrofproxies)
 177         proxies = HeapReAlloc(GetProcessHeap(),0,proxies,sizeof(proxies[0])*(nrofproxies+1));
 178     else
 179         proxies = HeapAlloc(GetProcessHeap(),0,sizeof(proxies[0]));
 180     memcpy(&(proxies[nrofproxies].mid),mid,sizeof(*mid));
 181     proxies[nrofproxies].pUnk = punk;
 182     nrofproxies++;
 183     IUnknown_AddRef(punk);
 184     return S_OK;
 185 }
 186
 187 /********************** StdMarshal implementation ****************************/
 188 typedef struct _StdMarshalImpl {
 189   ICOM_VTABLE(IMarshal) *lpvtbl;
 190   DWORD                 ref;
 191
 192   IID                   iid;
 193   DWORD                 dwDestContext;
 194   LPVOID                pvDestContext;
 195   DWORD                 mshlflags;
 196 } StdMarshalImpl;
 197
 198 HRESULT WINAPI
 199 StdMarshalImpl_QueryInterface(LPMARSHAL iface,REFIID riid,LPVOID *ppv) {
 200   *ppv = NULL;
 201   if (IsEqualIID(&IID_IUnknown,riid) || IsEqualIID(&IID_IMarshal,riid)) {
 202     *ppv = iface;
 203     IUnknown_AddRef(iface);
 204     return S_OK;
 205   }
 206   FIXME("No interface for %s.\n",debugstr_guid(riid));
 207   return E_NOINTERFACE;
 208 }
 209
 210 ULONG WINAPI
 211 StdMarshalImpl_AddRef(LPMARSHAL iface) {
 212   ICOM_THIS(StdMarshalImpl,iface);
 213   This->ref++;
 214   return This->ref;
 215 }
 216
 217 ULONG WINAPI
 218 StdMarshalImpl_Release(LPMARSHAL iface) {
 219   ICOM_THIS(StdMarshalImpl,iface);
 220   This->ref--;
 221
 222   if (This->ref)
 223     return This->ref;
 224   HeapFree(GetProcessHeap(),0,This);
 225   return 0;
 226 }
 227
 228 HRESULT WINAPI
 229 StdMarshalImpl_GetUnmarshalClass(
 230   LPMARSHAL iface, REFIID riid, void* pv, DWORD dwDestContext,
 231   void* pvDestContext, DWORD mshlflags, CLSID* pCid
 232 ) {
 233   memcpy(pCid,&CLSID_DfMarshal,sizeof(CLSID_DfMarshal));
 234   return S_OK;
 235 }
 236
 237 HRESULT WINAPI
 238 StdMarshalImpl_GetMarshalSizeMax(
 239   LPMARSHAL iface, REFIID riid, void* pv, DWORD dwDestContext,
 240   void* pvDestContext, DWORD mshlflags, DWORD* pSize
 241 ) {
 242   *pSize = sizeof(wine_marshal_id)+sizeof(wine_marshal_data);
 243   return S_OK;
 244 }
 245
 246 HRESULT WINAPI
 247 StdMarshalImpl_MarshalInterface(
 248   LPMARSHAL iface, IStream *pStm,REFIID riid, void* pv, DWORD dwDestContext,
 249   void* pvDestContext, DWORD mshlflags
 250 ) {
 251   wine_marshal_id       mid;
 252   wine_marshal_data     md;
 253   IUnknown              *pUnk;
 254   ULONG                 res;
 255   HRESULT               hres;
 256   IRpcStubBuffer        *stub;
 257   IPSFactoryBuffer      *psfacbuf;
 258
 259   TRACE("(...,%s,...)\n",debugstr_guid(riid));
 260   IUnknown_QueryInterface((LPUNKNOWN)pv,&IID_IUnknown,(LPVOID*)&pUnk);
 261   mid.processid = GetCurrentProcessId();
 262   mid.objectid = (DWORD)pUnk; /* FIXME */
 263   IUnknown_Release(pUnk);
 264   memcpy(&mid.iid,riid,sizeof(mid.iid));
 265   md.dwDestContext      = dwDestContext;
 266   md.mshlflags          = mshlflags;
 267   hres = IStream_Write(pStm,&mid,sizeof(mid),&res);
 268   if (hres) return hres;
 269   hres = IStream_Write(pStm,&md,sizeof(md),&res);
 270   if (hres) return hres;
 271
 272   if (SUCCEEDED(MARSHAL_Find_Stub(&mid,&pUnk))) {
 273       IUnknown_Release(pUnk);
 274       return S_OK;
 275   }
 276   hres = get_facbuf_for_iid(riid,&psfacbuf);
 277   if (hres) return hres;
 278   hres = IPSFactoryBuffer_CreateStub(psfacbuf,riid,pv,&stub);
 279   IPSFactoryBuffer_Release(psfacbuf);
 280   if (hres) {
 281     FIXME("Failed to create a stub for %s\n",debugstr_guid(riid));
 282     return hres;
 283   }
 284   IUnknown_QueryInterface((LPUNKNOWN)pv,riid,(LPVOID*)&pUnk);
 285   MARSHAL_Register_Stub(&mid,pUnk,stub);
 286   IUnknown_Release(pUnk);
 287   return S_OK;
 288 }
 289
 290 HRESULT WINAPI
 291 StdMarshalImpl_UnmarshalInterface(
 292   LPMARSHAL iface, IStream *pStm, REFIID riid, void **ppv
 293 ) {
 294   wine_marshal_id       mid;
 295   wine_marshal_data     md;
 296   ULONG                 res;
 297   HRESULT               hres;
 298   IPSFactoryBuffer      *psfacbuf;
 299   IRpcProxyBuffer       *rpcproxy;
 300   IRpcChannelBuffer     *chanbuf;
 301
 302   TRACE("(...,%s,....)\n",debugstr_guid(riid));
 303   hres = IStream_Read(pStm,&mid,sizeof(mid),&res);
 304   if (hres) return hres;
 305   hres = IStream_Read(pStm,&md,sizeof(md),&res);
 306   if (hres) return hres;
 307   if (SUCCEEDED(MARSHAL_Find_Stub(&mid,(LPUNKNOWN*)ppv))) {
 308       FIXME("Calling back to ourselves for %s!\n",debugstr_guid(riid));
 309       return S_OK;
 310   }
 311   hres = get_facbuf_for_iid(riid,&psfacbuf);
 312   if (hres) return hres;
 313   hres = IPSFactoryBuffer_CreateProxy(psfacbuf,NULL,riid,&rpcproxy,ppv);
 314   if (hres) {
 315     FIXME("Failed to create a proxy for %s\n",debugstr_guid(riid));
 316     return hres;
 317   }
 318   hres = PIPE_GetNewPipeBuf(&mid,&chanbuf);
 319   if (hres) {
 320     ERR("Failed to get an rpc channel buffer for %s\n",debugstr_guid(riid));
 321   } else {
 322     IRpcProxyBuffer_Connect(rpcproxy,chanbuf);
 323     IRpcProxyBuffer_Release(rpcproxy); /* no need */
 324   }
 325   IPSFactoryBuffer_Release(psfacbuf);
 326   return hres;
 327 }
 328
 329 HRESULT WINAPI
 330 StdMarshalImpl_ReleaseMarshalData(LPMARSHAL iface, IStream *pStm) {
 331   FIXME("(), stub!\n");
 332   return S_OK;
 333 }
 334
 335 HRESULT WINAPI
 336 StdMarshalImpl_DisconnectObject(LPMARSHAL iface, DWORD dwReserved) {
 337   FIXME("(), stub!\n");
 338   return S_OK;
 339 }
 340
 341 ICOM_VTABLE(IMarshal) stdmvtbl = {
 342     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 343     StdMarshalImpl_QueryInterface,
 344     StdMarshalImpl_AddRef,
 345     StdMarshalImpl_Release,
 346     StdMarshalImpl_GetUnmarshalClass,
 347     StdMarshalImpl_GetMarshalSizeMax,
 348     StdMarshalImpl_MarshalInterface,
 349     StdMarshalImpl_UnmarshalInterface,
 350     StdMarshalImpl_ReleaseMarshalData,
 351     StdMarshalImpl_DisconnectObject
 352 };
 353
 354 /***********************************************************************
 355  *              CoGetStandardMarshal    [OLE32.23]
 356  *
 357  * When the COM library in the client process receives a marshaled
 358  * interface pointer, it looks for a CLSID to be used in creating a proxy
 359  * for the purposes of unmarshaling the packet. If the packet does not
 360  * contain a CLSID for the proxy, COM calls CoGetStandardMarshal, passing a
 361  * NULL pUnk value.
 362  * This function creates a standard proxy in the client process and returns
 363  * a pointer to that proxy's implementation of IMarshal.
 364  * COM uses this pointer to call CoUnmarshalInterface to retrieve the pointer
 365  * to the requested interface.
 366  */
 367 HRESULT WINAPI
 368 CoGetStandardMarshal(
 369   REFIID riid,IUnknown *pUnk,DWORD dwDestContext,LPVOID pvDestContext,
 370   DWORD mshlflags, LPMARSHAL *pMarshal
 371 ) {
 372   StdMarshalImpl *dm;
 373
 374   if (pUnk == NULL) {
 375     FIXME("(%s,NULL,%lx,%p,%lx,%p), unimplemented yet.\n",
 376       debugstr_guid(riid),dwDestContext,pvDestContext,mshlflags,pMarshal
 377     );
 378     return E_FAIL;
 379   }
 380   TRACE("(%s,%p,%lx,%p,%lx,%p)\n",
 381     debugstr_guid(riid),pUnk,dwDestContext,pvDestContext,mshlflags,pMarshal
 382   );
 383   dm = (StdMarshalImpl*) *pMarshal = HeapAlloc(GetProcessHeap(),0,sizeof(StdMarshalImpl));
 384   if (!dm) return E_FAIL;
 385   dm->lpvtbl            = &stdmvtbl;
 386   dm->ref               = 1;
 387
 388   memcpy(&dm->iid,riid,sizeof(dm->iid));
 389   dm->dwDestContext     = dwDestContext;
 390   dm->pvDestContext     = pvDestContext;
 391   dm->mshlflags         = mshlflags;
 392   return S_OK;
 393 }
 394
 395 /* Helper function for getting Marshaler */
 396 static HRESULT WINAPI
 397 _GetMarshaller(REFIID riid, IUnknown *pUnk,DWORD dwDestContext,
 398   void *pvDestContext, DWORD mshlFlags, LPMARSHAL *pMarshal
 399 ) {
 400   HRESULT hres;
 401
 402   if (!pUnk)
 403       return E_POINTER;
 404   hres = IUnknown_QueryInterface(pUnk,&IID_IMarshal,(LPVOID*)pMarshal);
 405   if (hres)
 406     hres = CoGetStandardMarshal(riid,pUnk,dwDestContext,pvDestContext,mshlFlags,pMarshal);
 407   return hres;
 408 }
 409
 410 /***********************************************************************
 411  *              CoGetMarshalSizeMax     [OLE32.21]
 412  */
 413 HRESULT WINAPI
 414 CoGetMarshalSizeMax(ULONG *pulSize, REFIID riid, IUnknown *pUnk,
 415   DWORD dwDestContext, void *pvDestContext, DWORD mshlFlags
 416 ) {
 417   HRESULT       hres;
 418   LPMARSHAL     pMarshal;
 419
 420   hres = _GetMarshaller(riid,pUnk,dwDestContext,pvDestContext,mshlFlags,&pMarshal);
 421   if (hres)
 422     return hres;
 423   hres = IMarshal_GetMarshalSizeMax(pMarshal,riid,pUnk,dwDestContext,pvDestContext,mshlFlags,pulSize);
 424   *pulSize += sizeof(wine_marshal_id)+sizeof(wine_marshal_data)+sizeof(CLSID);
 425   IMarshal_Release(pMarshal);
 426   return hres;
 427 }
 428
 429
 430 /***********************************************************************
 431  *              CoMarshalInterface      [OLE32.34]
 432  */
 433 HRESULT WINAPI
 434 CoMarshalInterface( IStream *pStm, REFIID riid, IUnknown *pUnk,
 435   DWORD dwDestContext, void *pvDestContext, DWORD mshlflags
 436 ) {
 437   HRESULT               hres;
 438   LPMARSHAL             pMarshal;
 439   CLSID                 xclsid;
 440   ULONG                 writeres;
 441   wine_marshal_id       mid;
 442   wine_marshal_data     md;
 443   ULONG                 res;
 444   IUnknown              *pUnknown;
 445
 446   TRACE("(%p, %s, %p, %lx, %p, %lx)\n",
 447     pStm,debugstr_guid(riid),pUnk,dwDestContext,pvDestContext,mshlflags
 448   );
 449   STUBMGR_Start(); /* Just to be sure we have one running. */
 450   mid.processid = GetCurrentProcessId();
 451   IUnknown_QueryInterface(pUnk,&IID_IUnknown,(LPVOID*)&pUnknown);
 452   mid.objectid = (DWORD)pUnknown;
 453   IUnknown_Release(pUnknown);
 454   memcpy(&mid.iid,riid,sizeof(mid.iid));
 455   md.dwDestContext      = dwDestContext;
 456   md.mshlflags          = mshlflags;
 457   hres = IStream_Write(pStm,&mid,sizeof(mid),&res);
 458   if (hres) return hres;
 459   hres = IStream_Write(pStm,&md,sizeof(md),&res);
 460   if (hres) return hres;
 461   hres = _GetMarshaller(riid,pUnk,dwDestContext,pvDestContext,mshlflags,&pMarshal);
 462   if (hres) {
 463     FIXME("Failed to get marshaller, %lx?\n",hres);
 464     return hres;
 465   }
 466   hres = IMarshal_GetUnmarshalClass(pMarshal,riid,pUnk,dwDestContext,pvDestContext,mshlflags,&xclsid);
 467   if (hres) {
 468     FIXME("IMarshal:GetUnmarshalClass failed, %lx\n",hres);
 469     goto release_marshal;
 470   }
 471   hres = IStream_Write(pStm,&xclsid,sizeof(xclsid),&writeres);
 472   if (hres) {
 473     FIXME("Stream write failed, %lx\n",hres);
 474     goto release_marshal;
 475   }
 476   hres = IMarshal_MarshalInterface(pMarshal,pStm,riid,pUnk,dwDestContext,pvDestContext,mshlflags);
 477   if (hres) {
 478     if (IsEqualGUID(riid,&IID_IClassFactory)) {
 479         MESSAGE("\nERROR: You need to merge the 'winedefault.reg' file into your\n");
 480         MESSAGE("       Wine registry by running: `regedit winedefault.reg'\n\n");
 481     } else {
 482         if (IsEqualGUID(riid,&IID_IOleObject)) {
 483             ERR("WINE currently cannot marshal IOleObject interfaces. This means you cannot embed/link OLE objects between applications.\n");
 484         } else {
 485             FIXME("Failed to marshal the interface %s, %lx?\n",debugstr_guid(riid),hres);
 486         }
 487     }
 488     goto release_marshal;
 489   }
 490 release_marshal:
 491   IMarshal_Release(pMarshal);
 492   return hres;
 493 }
 494
 495
 496 /***********************************************************************
 497  *              CoUnmarshalInterface    [OLE32.50]
 498  */
 499 HRESULT WINAPI
 500 CoUnmarshalInterface(IStream *pStm, REFIID riid, LPVOID *ppv) {
 501   HRESULT               hres;
 502   wine_marshal_id       mid;
 503   wine_marshal_data     md;
 504   ULONG                 res;
 505   LPMARSHAL             pMarshal;
 506   LPUNKNOWN             pUnk;
 507   CLSID                 xclsid;
 508
 509   TRACE("(%p,%s,%p)\n",pStm,debugstr_guid(riid),ppv);
 510
 511   hres = IStream_Read(pStm,&mid,sizeof(mid),&res);
 512   if (hres) {
 513       FIXME("Stream read 1 failed, %lx, (%ld of %d)\n",hres,res,sizeof(mid));
 514       return hres;
 515   }
 516   hres = IStream_Read(pStm,&md,sizeof(md),&res);
 517   if (hres) {
 518       FIXME("Stream read 2 failed, %lx, (%ld of %d)\n",hres,res,sizeof(md));
 519       return hres;
 520   }
 521   hres = IStream_Read(pStm,&xclsid,sizeof(xclsid),&res);
 522   if (hres) {
 523       FIXME("Stream read 3 failed, %lx, (%ld of %d)\n",hres,res,sizeof(xclsid));
 524       return hres;
 525   }
 526   hres=CoCreateInstance(&xclsid,NULL,CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER | CLSCTX_LOCAL_SERVER,&IID_IMarshal,(void**)&pUnk);
 527   if (hres) {
 528       FIXME("Failed to create instance of unmarshaller %s.\n",debugstr_guid(&xclsid));
 529       return hres;
 530   }
 531   hres = _GetMarshaller(riid,pUnk,md.dwDestContext,NULL,md.mshlflags,&pMarshal);
 532   if (hres) {
 533       FIXME("Failed to get unmarshaller, %lx?\n",hres);
 534       return hres;
 535   }
 536   hres = IMarshal_UnmarshalInterface(pMarshal,pStm,riid,ppv);
 537   if (hres) {
 538     FIXME("Failed to Unmarshal the interface, %lx?\n",hres);
 539     goto release_marshal;
 540   }
 541 release_marshal:
 542   IMarshal_Release(pMarshal);
 543   return hres;
 544 }
 545
 546 /***********************************************************************
 547  *              CoMarshalInterThreadInterfaceInStream   [OLE32.33]
 548  *
 549  * Marshal interfaces across threads. We don't have a thread distinction,
 550  * meaning most interfaces just work across different threads, the RPC
 551  * handles it.
 552  */
 553 HRESULT WINAPI
 554 CoMarshalInterThreadInterfaceInStream(
 555   REFIID riid, LPUNKNOWN pUnk, LPSTREAM * ppStm
 556 ) {
 557   ULONG res;
 558   ULARGE_INTEGER        xpos;
 559   LARGE_INTEGER         seekto;
 560   HRESULT               hres;
 561
 562   TRACE("(,%s,)\n",debugstr_guid(riid));
 563   hres = CreateStreamOnHGlobal(0, TRUE, ppStm);
 564   if (hres) return hres;
 565   /* CoMarshalInterface(...); */
 566   hres = IStream_Write(*ppStm,&pUnk,sizeof(LPUNKNOWN),&res);
 567   if (hres) return hres;
 568   memset(&seekto,0,sizeof(seekto));
 569   IStream_Seek(*ppStm,seekto,SEEK_SET,&xpos);
 570   return S_OK;
 571 }
 572
 573 /***********************************************************************
 574  *              CoGetInterfaceAndReleaseStream  [OLE32.19]
 575  */
 576 HRESULT WINAPI
 577 CoGetInterfaceAndReleaseStream(LPSTREAM pStm,REFIID riid, LPVOID *ppv) {
 578   ULONG res;
 579   HRESULT               hres;
 580   LPUNKNOWN             pUnk;
 581
 582   TRACE("(,%s,)\n",debugstr_guid(riid));
 583   /* CoUnmarshalInterface(...); */
 584   hres = IStream_Read(pStm,&pUnk,sizeof(LPUNKNOWN),&res);
 585   if (hres) return hres;
 586   IStream_Release(pStm);
 587   return IUnknown_QueryInterface(pUnk,riid,ppv);
 588 }
 589
 590 static HRESULT WINAPI
 591 SMCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid, LPVOID *ppv) {
 592   *ppv = NULL;
 593   if (IsEqualIID(riid,&IID_IUnknown) || IsEqualIID(riid,&IID_IClassFactory)) {
 594     *ppv = (LPVOID)iface;
 595     return S_OK;
 596   }
 597   return E_NOINTERFACE;
 598 }
 599 static ULONG WINAPI SMCF_AddRef(LPCLASSFACTORY iface) { return 2; }
 600 static ULONG WINAPI SMCF_Release(LPCLASSFACTORY iface) { return 1; }
 601
 602 static HRESULT WINAPI
 603 SMCF_CreateInstance(
 604   LPCLASSFACTORY iface, LPUNKNOWN pUnk, REFIID riid, LPVOID *ppv
 605 ) {
 606   if (IsEqualIID(riid,&IID_IMarshal)) {
 607       StdMarshalImpl    *dm;
 608       dm=(StdMarshalImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(StdMarshalImpl));
 609       if (!dm)
 610           return E_FAIL;
 611       dm->lpvtbl        = &stdmvtbl;
 612       dm->ref           = 1;
 613       *ppv = (LPVOID)dm;
 614       return S_OK;
 615   }
 616   FIXME("(%s), not supported.\n",debugstr_guid(riid));
 617   return E_NOINTERFACE;
 618 }
 619
 620 static HRESULT WINAPI
 621 SMCF_LockServer(LPCLASSFACTORY iface, BOOL fLock) {
 622     FIXME("(%d), stub!\n",fLock);
 623     return S_OK;
 624 }
 625
 626 static ICOM_VTABLE(IClassFactory) dfmarshalcfvtbl = {
 627     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 628     SMCF_QueryInterface,
 629     SMCF_AddRef,
 630     SMCF_Release,
 631     SMCF_CreateInstance,
 632     SMCF_LockServer
 633 };
 634 static ICOM_VTABLE(IClassFactory) *pdfmarshalcfvtbl = &dfmarshalcfvtbl;
 635
 636 HRESULT
 637 MARSHAL_GetStandardMarshalCF(LPVOID *ppv) {
 638   *ppv = &pdfmarshalcfvtbl;
 639   return S_OK;
 640 }