dlls/ole32/marshal.c

   1 /*
   2  *      Marshalling library
   3  *
   4  * Copyright 2002 Marcus Meissner
   5  * Copyright 2004 Mike Hearn, for CodeWeavers
   6  * Copyright 2004 Rob Shearman, for CodeWeavers
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include "config.h"
  24
  25 #include <stdlib.h>
  26 #include <stdarg.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29 #include <assert.h>
  30
  31 #define COBJMACROS
  32
  33 #include "windef.h"
  34 #include "winbase.h"
  35 #include "winuser.h"
  36 #include "objbase.h"
  37 #include "ole2.h"
  38 #include "rpc.h"
  39 #include "winerror.h"
  40 #include "winreg.h"
  41 #include "wtypes.h"
  42 #include "wine/unicode.h"
  43
  44 #include "compobj_private.h"
  45
  46 #include "wine/debug.h"
  47
  48 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  49
  50 extern const CLSID CLSID_DfMarshal;
  51
  52 /* Marshalling 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  * In Windows, a different triple is used: OXID (apt id), OID (stub
  62  * manager id), IPID (interface ptr/stub id).
  63  *
  64  * OXIDs identify an apartment and are network scoped
  65  * OIDs identify a stub manager and are apartment scoped
  66  * IPIDs identify an interface stub and are apartment scoped
  67  */
  68
  69 inline static HRESULT
  70 get_facbuf_for_iid(REFIID riid,IPSFactoryBuffer **facbuf) {
  71     HRESULT       hres;
  72     CLSID         pxclsid;
  73
  74     if ((hres = CoGetPSClsid(riid,&pxclsid)))
  75         return hres;
  76     return CoGetClassObject(&pxclsid,CLSCTX_INPROC_SERVER,NULL,&IID_IPSFactoryBuffer,(LPVOID*)facbuf);
  77 }
  78
  79 IRpcStubBuffer *mid_to_stubbuffer(wine_marshal_id *mid)
  80 {
  81     IRpcStubBuffer *ret;
  82     APARTMENT *apt;
  83     struct stub_manager *m;
  84
  85     if (!(apt = COM_ApartmentFromOXID(mid->oxid, TRUE)))
  86     {
  87         WARN("Could not map OXID %s to apartment object\n", wine_dbgstr_longlong(mid->oxid));
  88         return NULL;
  89     }
  90
  91     if (!(m = get_stub_manager(apt, mid->oid)))
  92     {
  93         WARN("unknown OID %s\n", wine_dbgstr_longlong(mid->oid));
  94         return NULL;
  95     }
  96
  97     ret = stub_manager_ipid_to_stubbuffer(m, &mid->ipid);
  98
  99     stub_manager_int_release(m);
 100
 101     COM_ApartmentRelease(apt);
 102
 103     return ret;
 104 }
 105
 106 /* creates a new stub manager and sets mid->oid when mid->oid == 0 */
 107 static HRESULT register_ifstub(wine_marshal_id *mid, REFIID riid, IUnknown *obj, IRpcStubBuffer *stub, MSHLFLAGS mshlflags)
 108 {
 109     struct stub_manager *manager = NULL;
 110     struct ifstub       *ifstub;
 111     APARTMENT           *apt;
 112     BOOL                 tablemarshal;
 113
 114     if (!(apt = COM_ApartmentFromOXID(mid->oxid, TRUE)))
 115     {
 116         ERR("Could not map OXID %s to apartment object\n", wine_dbgstr_longlong(mid->oxid));
 117         return E_UNEXPECTED;
 118     }
 119
 120     /* mid->oid of zero means create a new stub manager */
 121
 122     if (mid->oid && (manager = get_stub_manager(apt, mid->oid)))
 123     {
 124         TRACE("registering new ifstub on pre-existing manager\n");
 125     }
 126     else
 127     {
 128         TRACE("constructing new stub manager\n");
 129
 130         manager = new_stub_manager(apt, obj);
 131         if (!manager)
 132         {
 133             COM_ApartmentRelease(apt);
 134             return E_OUTOFMEMORY;
 135         }
 136
 137         mid->oid = manager->oid;
 138     }
 139
 140     tablemarshal = ((mshlflags & MSHLFLAGS_TABLESTRONG) || (mshlflags & MSHLFLAGS_TABLEWEAK));
 141
 142     ifstub = stub_manager_new_ifstub(manager, stub, obj, riid, tablemarshal);
 143     if (!ifstub)
 144     {
 145         stub_manager_int_release(manager);
 146         /* FIXME: should we do another release to completely destroy the
 147          * stub manager? */
 148         COM_ApartmentRelease(apt);
 149         return E_OUTOFMEMORY;
 150     }
 151
 152     if (!tablemarshal)
 153         stub_manager_ext_addref(manager, 1);
 154     else if (mshlflags & MSHLFLAGS_TABLESTRONG)
 155         stub_manager_ext_addref(manager, 1);
 156
 157     mid->ipid = ifstub->ipid;
 158
 159     stub_manager_int_release(manager);
 160     COM_ApartmentRelease(apt);
 161     return S_OK;
 162 }
 163
 164
 165
 166 /* Client-side identity of the server object */
 167
 168 static void proxy_manager_destroy(struct proxy_manager * This);
 169 static HRESULT proxy_manager_find_ifproxy(struct proxy_manager * This, REFIID riid, struct ifproxy ** ifproxy_found);
 170
 171 static HRESULT WINAPI ClientIdentity_QueryInterface(IInternalUnknown * iface, REFIID riid, void ** ppv)
 172 {
 173     struct proxy_manager * This = (struct proxy_manager *)iface;
 174     HRESULT hr;
 175     struct ifproxy * ifproxy;
 176
 177     TRACE("%s\n", debugstr_guid(riid));
 178
 179     if (IsEqualIID(riid, &IID_IUnknown) ||
 180         IsEqualIID(riid, &IID_IInternalUnknown))
 181     {
 182         *ppv = (void *)iface;
 183         IInternalUnknown_AddRef(iface);
 184         return S_OK;
 185     }
 186
 187     hr = proxy_manager_find_ifproxy(This, riid, &ifproxy);
 188     if (hr == S_OK)
 189     {
 190         *ppv = ifproxy->iface;
 191         IUnknown_AddRef((IUnknown *)*ppv);
 192         return S_OK;
 193     }
 194
 195     FIXME("interface not found %s\n", debugstr_guid(riid));
 196
 197     /* FIXME: call IRemUnknown::RemQueryInterface */
 198     return E_NOINTERFACE;
 199 }
 200
 201 static ULONG WINAPI ClientIdentity_AddRef(IInternalUnknown * iface)
 202 {
 203     struct proxy_manager * This = (struct proxy_manager *)iface;
 204     TRACE("%p - before %ld\n", iface, This->refs);
 205     return InterlockedIncrement(&This->refs);
 206 }
 207
 208 static ULONG WINAPI ClientIdentity_Release(IInternalUnknown * iface)
 209 {
 210     struct proxy_manager * This = (struct proxy_manager *)iface;
 211     ULONG refs = InterlockedDecrement(&This->refs);
 212     TRACE("%p - after %ld\n", iface, refs);
 213     if (!refs)
 214         proxy_manager_destroy(This);
 215     return refs;
 216 }
 217
 218 static HRESULT WINAPI ClientIdentity_QueryInternalInterface(IInternalUnknown * iface, REFIID riid, void ** ppv)
 219 {
 220     FIXME("(%s, %p): stub!\n", debugstr_guid(riid), ppv);
 221     return E_NOINTERFACE;
 222 }
 223
 224 static const IInternalUnknownVtbl ClientIdentity_Vtbl =
 225 {
 226     ClientIdentity_QueryInterface,
 227     ClientIdentity_AddRef,
 228     ClientIdentity_Release,
 229     ClientIdentity_QueryInternalInterface
 230 };
 231
 232 static HRESULT ifproxy_get_public_ref(struct ifproxy * This)
 233 {
 234     EnterCriticalSection(&This->parent->cs);
 235     if (This->refs == 0)
 236     {
 237         APARTMENT * apt;
 238
 239         TRACE("getting public ref for ifproxy %p\n", This);
 240
 241         /* FIXME: call IRemUnknown::RemAddRef if necessary */
 242
 243         /* FIXME: this is a hack around not yet implemented IRemUnknown */
 244         if ((apt = COM_ApartmentFromOXID(This->parent->oxid, TRUE)))
 245         {
 246             struct stub_manager * stubmgr;
 247             if ((stubmgr = get_stub_manager(apt, This->parent->oid)))
 248             {
 249                 stub_manager_ext_addref(stubmgr, 1);
 250                 This->refs += 1;
 251
 252                 stub_manager_int_release(stubmgr);
 253             }
 254
 255             COM_ApartmentRelease(apt);
 256         }
 257         else
 258             FIXME("Need to implement IRemUnknown for inter-process table marshaling\n");
 259     }
 260     LeaveCriticalSection(&This->parent->cs);
 261
 262     return S_OK;
 263 }
 264
 265 static HRESULT ifproxy_release_public_refs(struct ifproxy * This)
 266 {
 267     EnterCriticalSection(&This->parent->cs);
 268     /*
 269     if (This->refs > 0)
 270     {
 271         // FIXME: call IRemUnknown::RemRelease
 272         This->refs = 0;
 273     }
 274     */
 275     LeaveCriticalSection(&This->parent->cs);
 276     return S_OK;
 277 }
 278
 279 static void ifproxy_disconnect(struct ifproxy * This)
 280 {
 281     IRpcProxyBuffer_Disconnect(This->proxy);
 282 }
 283
 284 static void ifproxy_destroy(struct ifproxy * This)
 285 {
 286     /* release public references to this object so that the stub can know
 287      * when to destroy itself */
 288     ifproxy_release_public_refs(This);
 289
 290     list_remove(&This->entry);
 291
 292     if (This->proxy) IRpcProxyBuffer_Release(This->proxy);
 293     HeapFree(GetProcessHeap(), 0, This);
 294 }
 295
 296 static HRESULT proxy_manager_construct(APARTMENT * apt, OXID oxid, OID oid, IRpcChannelBuffer * channel, struct proxy_manager ** proxy_manager)
 297 {
 298     struct proxy_manager * This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 299     if (!This) return E_OUTOFMEMORY;
 300
 301     This->lpVtbl = &ClientIdentity_Vtbl;
 302
 303     list_init(&This->entry);
 304     list_init(&This->interfaces);
 305
 306     InitializeCriticalSection(&This->cs);
 307
 308     /* the apartment the object was unmarshaled into */
 309     This->parent = apt;
 310
 311     /* the source apartment and id of the object */
 312     This->oxid = oxid;
 313     This->oid = oid;
 314
 315     This->refs = 0; /* will be incremented on creation of first proxy */
 316
 317     This->chan = channel; /* FIXME: we should take the binding strings and construct the channel in this function */
 318
 319     EnterCriticalSection(&apt->cs);
 320     list_add_head(&apt->proxies, &This->entry);
 321     LeaveCriticalSection(&apt->cs);
 322
 323     *proxy_manager = This;
 324     return S_OK;
 325 }
 326
 327 static HRESULT proxy_manager_create_ifproxy(struct proxy_manager * This, IPID ipid, REFIID riid, ULONG cPublicRefs, struct ifproxy ** iif_out)
 328 {
 329     HRESULT hr;
 330     IPSFactoryBuffer * psfb;
 331     struct ifproxy * ifproxy = HeapAlloc(GetProcessHeap(), 0, sizeof(*ifproxy));
 332     if (!ifproxy) return E_OUTOFMEMORY;
 333
 334     list_init(&ifproxy->entry);
 335
 336     ifproxy->parent = This;
 337     ifproxy->ipid = ipid;
 338     ifproxy->iid = *riid;
 339     ifproxy->refs = cPublicRefs;
 340     ifproxy->proxy = NULL;
 341
 342     hr = get_facbuf_for_iid(riid, &psfb);
 343     if (hr == S_OK)
 344     {
 345         /* important note: the outer unknown is set to the proxy manager.
 346          * This ensures the COM identity rules are not violated, by having a
 347          * one-to-one mapping of objects on the proxy side to objects on the
 348          * stub side, no matter which interface you view the object through */
 349         hr = IPSFactoryBuffer_CreateProxy(psfb, (IUnknown *)&This->lpVtbl, riid,
 350                                           &ifproxy->proxy, &ifproxy->iface);
 351         IPSFactoryBuffer_Release(psfb);
 352     }
 353
 354     if (hr == S_OK)
 355         hr = IRpcProxyBuffer_Connect(ifproxy->proxy, This->chan);
 356
 357     /* get at least one external reference to the object to keep it alive */
 358     if (hr == S_OK)
 359         hr = ifproxy_get_public_ref(ifproxy);
 360
 361     if (hr == S_OK)
 362     {
 363         EnterCriticalSection(&This->cs);
 364         list_add_tail(&This->interfaces, &ifproxy->entry);
 365         LeaveCriticalSection(&This->cs);
 366
 367         *iif_out = ifproxy;
 368     }
 369     else
 370         ifproxy_destroy(ifproxy);
 371
 372     return hr;
 373 }
 374
 375 static HRESULT proxy_manager_find_ifproxy(struct proxy_manager * This, REFIID riid, struct ifproxy ** ifproxy_found)
 376 {
 377     HRESULT hr = E_NOINTERFACE; /* assume not found */
 378     struct list * cursor;
 379
 380     EnterCriticalSection(&This->cs);
 381     LIST_FOR_EACH(cursor, &This->interfaces)
 382     {
 383         struct ifproxy * ifproxy = LIST_ENTRY(cursor, struct ifproxy, entry);
 384         if (IsEqualIID(riid, &ifproxy->iid))
 385         {
 386             *ifproxy_found = ifproxy;
 387             hr = S_OK;
 388             break;
 389         }
 390     }
 391     LeaveCriticalSection(&This->cs);
 392
 393     return hr;
 394 }
 395
 396 static void proxy_manager_disconnect(struct proxy_manager * This)
 397 {
 398     struct list * cursor;
 399
 400     TRACE("oid = %s\n", wine_dbgstr_longlong(This->oid));
 401
 402     EnterCriticalSection(&This->cs);
 403
 404     LIST_FOR_EACH(cursor, &This->interfaces)
 405     {
 406         struct ifproxy * ifproxy = LIST_ENTRY(cursor, struct ifproxy, entry);
 407         ifproxy_disconnect(ifproxy);
 408     }
 409
 410     /* apartment is being destroyed so don't keep a pointer around to it */
 411     This->parent = NULL;
 412
 413     /* FIXME: will this still be necessary if/when we use a real RPC
 414      * channel? */
 415     IRpcChannelBuffer_Release(This->chan);
 416     This->chan = NULL;
 417
 418     LeaveCriticalSection(&This->cs);
 419 }
 420
 421 static void proxy_manager_destroy(struct proxy_manager * This)
 422 {
 423     struct list * cursor;
 424
 425     if (This->parent)
 426     {
 427         EnterCriticalSection(&This->parent->cs);
 428
 429         /* remove ourself from the list of proxy objects in the apartment */
 430         LIST_FOR_EACH(cursor, &This->parent->proxies)
 431         {
 432             if (cursor == &This->entry)
 433             {
 434                 list_remove(&This->entry);
 435                 break;
 436             }
 437         }
 438
 439         LeaveCriticalSection(&This->parent->cs);
 440     }
 441
 442     /* destroy all of the interface proxies */
 443     while (!(cursor = list_head(&This->interfaces)))
 444     {
 445         struct ifproxy * ifproxy = LIST_ENTRY(cursor, struct ifproxy, entry);
 446         ifproxy_destroy(ifproxy);
 447     }
 448
 449     if (This->chan) IRpcChannelBuffer_Release(This->chan);
 450
 451     DeleteCriticalSection(&This->cs);
 452
 453     HeapFree(GetProcessHeap(), 0, This);
 454 }
 455
 456 static BOOL find_proxy_manager(APARTMENT * apt, OXID oxid, OID oid, struct proxy_manager ** proxy_found)
 457 {
 458     BOOL found = FALSE;
 459     struct list * cursor;
 460
 461     EnterCriticalSection(&apt->cs);
 462     LIST_FOR_EACH(cursor, &apt->proxies)
 463     {
 464         struct proxy_manager * proxy = LIST_ENTRY(cursor, struct proxy_manager, entry);
 465         if ((oxid == proxy->oxid) && (oid == proxy->oid))
 466         {
 467             *proxy_found = proxy;
 468             found = TRUE;
 469             break;
 470         }
 471     }
 472     LeaveCriticalSection(&apt->cs);
 473     return found;
 474 }
 475
 476 HRESULT MARSHAL_Disconnect_Proxies(APARTMENT *apt)
 477 {
 478     struct list * cursor;
 479
 480     EnterCriticalSection(&apt->cs);
 481     LIST_FOR_EACH(cursor, &apt->proxies)
 482     {
 483         struct proxy_manager * proxy = LIST_ENTRY(cursor, struct proxy_manager, entry);
 484         proxy_manager_disconnect(proxy);
 485     }
 486     LeaveCriticalSection(&apt->cs);
 487
 488     return S_OK;
 489 }
 490
 491 /********************** StdMarshal implementation ****************************/
 492 typedef struct _StdMarshalImpl {
 493   IMarshalVtbl  *lpvtbl;
 494   DWORD                 ref;
 495
 496   IID                   iid;
 497   DWORD                 dwDestContext;
 498   LPVOID                pvDestContext;
 499   DWORD                 mshlflags;
 500 } StdMarshalImpl;
 501
 502 static HRESULT WINAPI
 503 StdMarshalImpl_QueryInterface(LPMARSHAL iface,REFIID riid,LPVOID *ppv) {
 504   *ppv = NULL;
 505   if (IsEqualIID(&IID_IUnknown,riid) || IsEqualIID(&IID_IMarshal,riid)) {
 506     *ppv = iface;
 507     IUnknown_AddRef(iface);
 508     return S_OK;
 509   }
 510   FIXME("No interface for %s.\n",debugstr_guid(riid));
 511   return E_NOINTERFACE;
 512 }
 513
 514 static ULONG WINAPI
 515 StdMarshalImpl_AddRef(LPMARSHAL iface) {
 516   StdMarshalImpl *This = (StdMarshalImpl *)iface;
 517   return InterlockedIncrement(&This->ref);
 518 }
 519
 520 static ULONG WINAPI
 521 StdMarshalImpl_Release(LPMARSHAL iface) {
 522   StdMarshalImpl *This = (StdMarshalImpl *)iface;
 523   ULONG ref = InterlockedDecrement(&This->ref);
 524
 525   if (!ref) HeapFree(GetProcessHeap(),0,This);
 526   return ref;
 527 }
 528
 529 static HRESULT WINAPI
 530 StdMarshalImpl_GetUnmarshalClass(
 531   LPMARSHAL iface, REFIID riid, void* pv, DWORD dwDestContext,
 532   void* pvDestContext, DWORD mshlflags, CLSID* pCid
 533 ) {
 534   memcpy(pCid,&CLSID_DfMarshal,sizeof(CLSID_DfMarshal));
 535   return S_OK;
 536 }
 537
 538 static HRESULT WINAPI
 539 StdMarshalImpl_GetMarshalSizeMax(
 540   LPMARSHAL iface, REFIID riid, void* pv, DWORD dwDestContext,
 541   void* pvDestContext, DWORD mshlflags, DWORD* pSize
 542 ) {
 543   *pSize = sizeof(wine_marshal_id);
 544   return S_OK;
 545 }
 546
 547 static HRESULT WINAPI
 548 StdMarshalImpl_MarshalInterface(
 549   LPMARSHAL iface, IStream *pStm,REFIID riid, void* pv, DWORD dwDestContext,
 550   void* pvDestContext, DWORD mshlflags
 551 ) {
 552   wine_marshal_id       mid;
 553   IUnknown             *pUnk;
 554   ULONG                 res;
 555   HRESULT               hres;
 556   IRpcStubBuffer       *stubbuffer;
 557   IPSFactoryBuffer     *psfacbuf;
 558   struct stub_manager  *manager;
 559   APARTMENT            *apt = COM_CurrentApt();
 560
 561   TRACE("(...,%s,...)\n",debugstr_guid(riid));
 562
 563   if (!apt)
 564   {
 565       ERR("Apartment not initialized\n");
 566       return CO_E_NOTINITIALIZED;
 567   }
 568
 569   start_apartment_listener_thread(); /* just to be sure we have one running. */
 570
 571   hres = get_facbuf_for_iid(riid,&psfacbuf);
 572   if (hres) return hres;
 573
 574   hres = IPSFactoryBuffer_CreateStub(psfacbuf,riid,pv,&stubbuffer);
 575   IPSFactoryBuffer_Release(psfacbuf);
 576   if (hres) {
 577     FIXME("Failed to create an RpcStubBuffer from PSFactory for %s\n",debugstr_guid(riid));
 578     return hres;
 579   }
 580
 581   /* now fill out the MID */
 582   mid.oxid = apt->oxid;
 583
 584   IUnknown_QueryInterface((LPUNKNOWN)pv, riid, (LPVOID*)&pUnk);
 585
 586   if ((manager = get_stub_manager_from_object(apt, pUnk)))
 587   {
 588       mid.oid = manager->oid;
 589       stub_manager_int_release(manager);
 590   }
 591   else
 592   {
 593       mid.oid = 0;              /* will be set by register_ifstub */
 594   }
 595
 596   hres = register_ifstub(&mid, riid, pUnk, stubbuffer, mshlflags);
 597
 598   IUnknown_Release(pUnk);
 599
 600   if (hres)
 601   {
 602     FIXME("Failed to create ifstub, hres=0x%lx\n", hres);
 603     return hres;
 604   }
 605
 606   hres = IStream_Write(pStm,&mid,sizeof(mid),&res);
 607   if (hres) return hres;
 608
 609   return S_OK;
 610 }
 611
 612 static HRESULT WINAPI
 613 StdMarshalImpl_UnmarshalInterface(LPMARSHAL iface, IStream *pStm, REFIID riid, void **ppv)
 614 {
 615   struct stub_manager  *stubmgr;
 616   wine_marshal_id       mid;
 617   ULONG                 res;
 618   HRESULT               hres;
 619   IRpcChannelBuffer     *chanbuf;
 620   struct proxy_manager *proxy_manager;
 621   APARTMENT *apt = COM_CurrentApt();
 622   APARTMENT *stub_apt;
 623   ULONG cPublicRefs = 1;
 624
 625   TRACE("(...,%s,....)\n",debugstr_guid(riid));
 626
 627   if (!apt)
 628   {
 629       ERR("Apartment not initialized\n");
 630       return CO_E_NOTINITIALIZED;
 631   }
 632
 633   hres = IStream_Read(pStm,&mid,sizeof(mid),&res);
 634   if (hres) return hres;
 635
 636   /* check if we're marshalling back to ourselves */
 637   if ((apt->oxid == mid.oxid) && (stubmgr = get_stub_manager(apt, mid.oid)))
 638   {
 639       TRACE("Unmarshalling object marshalled in same apartment for iid %s, returning original object %p\n", debugstr_guid(riid), stubmgr->object);
 640
 641       hres = IUnknown_QueryInterface(stubmgr->object, riid, ppv);
 642
 643       /* unref the ifstub. FIXME: only do this on success? */
 644       if (!stub_manager_is_table_marshaled(stubmgr, &mid.ipid))
 645           stub_manager_ext_release(stubmgr, 1);
 646
 647       stub_manager_int_release(stubmgr);
 648       return hres;
 649   }
 650
 651   /* notify stub manager about unmarshal if process-local object.
 652    * note: if the oxid is not found then we and native will quite happily
 653    * ignore table marshaling and normal marshaling rules regarding number of
 654    * unmarshals, etc, but if you abuse these rules then your proxy could end
 655    * up returning RPC_E_DISCONNECTED. */
 656   if ((stub_apt = COM_ApartmentFromOXID(mid.oxid, TRUE)))
 657   {
 658       if ((stubmgr = get_stub_manager(stub_apt, mid.oid)))
 659       {
 660           if (!stub_manager_notify_unmarshal(stubmgr, &mid.ipid))
 661               hres = CO_E_OBJNOTCONNECTED;
 662
 663           /* FIXME: hack around not using STDOBJREF yet */
 664           if (stub_manager_is_table_marshaled(stubmgr, &mid.ipid))
 665               cPublicRefs = 0;
 666
 667           stub_manager_int_release(stubmgr);
 668       }
 669       else
 670       {
 671           WARN("Couldn't find object for OXID %s, OID %s, assuming disconnected\n",
 672               wine_dbgstr_longlong(mid.oxid),
 673               wine_dbgstr_longlong(mid.oid));
 674           hres = CO_E_OBJNOTCONNECTED;
 675       }
 676
 677       COM_ApartmentRelease(stub_apt);
 678   }
 679   else
 680       TRACE("Treating unmarshal from OXID %s as inter-process\n", wine_dbgstr_longlong(mid.oxid));
 681
 682   if (hres) return hres;
 683
 684   if (!find_proxy_manager(apt, mid.oxid, mid.oid, &proxy_manager))
 685   {
 686     hres = PIPE_GetNewPipeBuf(&mid,&chanbuf);
 687     if (hres == S_OK)
 688       hres = proxy_manager_construct(apt, mid.oxid, mid.oid, chanbuf, &proxy_manager);
 689   }
 690
 691   if (hres == S_OK)
 692   {
 693     struct ifproxy * ifproxy;
 694     hres = proxy_manager_find_ifproxy(proxy_manager, riid, &ifproxy);
 695     if (hres == S_OK)
 696       IUnknown_AddRef((IUnknown *)ifproxy->iface);
 697     else if (hres == E_NOINTERFACE)
 698       hres = proxy_manager_create_ifproxy(proxy_manager, mid.ipid, riid, cPublicRefs, &ifproxy);
 699
 700     if (hres == S_OK)
 701       *ppv = ifproxy->iface; /* AddRef'd above */
 702   }
 703
 704   return hres;
 705 }
 706
 707 static HRESULT WINAPI
 708 StdMarshalImpl_ReleaseMarshalData(LPMARSHAL iface, IStream *pStm) {
 709     wine_marshal_id      mid;
 710     ULONG                res;
 711     HRESULT              hres;
 712     struct stub_manager *stubmgr;
 713     APARTMENT           *apt;
 714
 715     TRACE("iface=%p, pStm=%p\n", iface, pStm);
 716
 717     hres = IStream_Read(pStm,&mid,sizeof(mid),&res);
 718     if (hres) return hres;
 719
 720     if (!(apt = COM_ApartmentFromOXID(mid.oxid, TRUE)))
 721     {
 722         WARN("Could not map OXID %s to apartment object\n", wine_dbgstr_longlong(mid.oxid));
 723         return RPC_E_INVALID_OBJREF;
 724     }
 725
 726     if (!(stubmgr = get_stub_manager(apt, mid.oid)))
 727     {
 728         ERR("could not map MID to stub manager, oxid=%s, oid=%s\n",
 729             wine_dbgstr_longlong(mid.oxid), wine_dbgstr_longlong(mid.oid));
 730         return RPC_E_INVALID_OBJREF;
 731     }
 732
 733     stub_manager_ext_release(stubmgr, 1);
 734
 735     stub_manager_int_release(stubmgr);
 736     COM_ApartmentRelease(apt);
 737
 738     return S_OK;
 739 }
 740
 741 static HRESULT WINAPI
 742 StdMarshalImpl_DisconnectObject(LPMARSHAL iface, DWORD dwReserved) {
 743   FIXME("(), stub!\n");
 744   return S_OK;
 745 }
 746
 747 IMarshalVtbl stdmvtbl = {
 748     StdMarshalImpl_QueryInterface,
 749     StdMarshalImpl_AddRef,
 750     StdMarshalImpl_Release,
 751     StdMarshalImpl_GetUnmarshalClass,
 752     StdMarshalImpl_GetMarshalSizeMax,
 753     StdMarshalImpl_MarshalInterface,
 754     StdMarshalImpl_UnmarshalInterface,
 755     StdMarshalImpl_ReleaseMarshalData,
 756     StdMarshalImpl_DisconnectObject
 757 };
 758
 759 static HRESULT StdMarshalImpl_Construct(REFIID riid, void** ppvObject)
 760 {
 761     StdMarshalImpl * pStdMarshal =
 762         HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(StdMarshalImpl));
 763     if (!pStdMarshal)
 764         return E_OUTOFMEMORY;
 765     pStdMarshal->lpvtbl = &stdmvtbl;
 766     pStdMarshal->ref = 0;
 767     return IMarshal_QueryInterface((IMarshal*)pStdMarshal, riid, ppvObject);
 768 }
 769
 770 /***********************************************************************
 771  *              CoGetStandardMarshal    [OLE32.@]
 772  *
 773  * Gets or creates a standard marshal object.
 774  *
 775  * PARAMS
 776  *  riid          [I] Interface identifier of the pUnk object.
 777  *  pUnk          [I] Optional. Object to get the marshal object for.
 778  *  dwDestContext [I] Destination. Used to enable or disable optimizations.
 779  *  pvDestContext [I] Reserved. Must be NULL.
 780  *  mshlflags     [I] Flags affecting the marshaling process.
 781  *  ppMarshal     [O] Address where marshal object will be stored.
 782  *
 783  * RETURNS
 784  *  Success: S_OK.
 785  *  Failure: HRESULT code.
 786  *
 787  * NOTES
 788  *
 789  * The function retrieves the IMarshal object associated with an object if
 790  * that object is currently an active stub, otherwise a new marshal object is
 791  * created.
 792  */
 793 HRESULT WINAPI CoGetStandardMarshal(REFIID riid, IUnknown *pUnk,
 794                                     DWORD dwDestContext, LPVOID pvDestContext,
 795                                     DWORD mshlflags, LPMARSHAL *ppMarshal)
 796 {
 797   StdMarshalImpl *dm;
 798
 799   if (pUnk == NULL) {
 800     FIXME("(%s,NULL,%lx,%p,%lx,%p), unimplemented yet.\n",
 801       debugstr_guid(riid),dwDestContext,pvDestContext,mshlflags,ppMarshal
 802     );
 803     return E_FAIL;
 804   }
 805   TRACE("(%s,%p,%lx,%p,%lx,%p)\n",
 806     debugstr_guid(riid),pUnk,dwDestContext,pvDestContext,mshlflags,ppMarshal
 807   );
 808   *ppMarshal = HeapAlloc(GetProcessHeap(),0,sizeof(StdMarshalImpl));
 809   dm = (StdMarshalImpl*) *ppMarshal;
 810   if (!dm) return E_FAIL;
 811   dm->lpvtbl            = &stdmvtbl;
 812   dm->ref               = 1;
 813
 814   memcpy(&dm->iid,riid,sizeof(dm->iid));
 815   dm->dwDestContext     = dwDestContext;
 816   dm->pvDestContext     = pvDestContext;
 817   dm->mshlflags         = mshlflags;
 818   return S_OK;
 819 }
 820
 821 /***********************************************************************
 822  *              get_marshaler   [internal]
 823  *
 824  * Retrieves an IMarshal interface for an object.
 825  */
 826 static HRESULT get_marshaler(REFIID riid, IUnknown *pUnk, DWORD dwDestContext,
 827                              void *pvDestContext, DWORD mshlFlags,
 828                              LPMARSHAL *pMarshal)
 829 {
 830     HRESULT hr;
 831
 832     if (!pUnk)
 833         return E_POINTER;
 834     hr = IUnknown_QueryInterface(pUnk, &IID_IMarshal, (LPVOID*)pMarshal);
 835     if (hr)
 836         hr = CoGetStandardMarshal(riid, pUnk, dwDestContext, pvDestContext,
 837                                   mshlFlags, pMarshal);
 838     return hr;
 839 }
 840
 841 /***********************************************************************
 842  *              get_unmarshaler_from_stream     [internal]
 843  *
 844  * Creates an IMarshal* object according to the data marshaled to the stream.
 845  * The function leaves the stream pointer at the start of the data written
 846  * to the stream by the IMarshal* object.
 847  */
 848 static HRESULT get_unmarshaler_from_stream(IStream *stream, IMarshal **marshal)
 849 {
 850     HRESULT hr;
 851     ULONG res;
 852     OBJREF objref;
 853
 854     /* read common OBJREF header */
 855     hr = IStream_Read(stream, &objref, FIELD_OFFSET(OBJREF, u_objref), &res);
 856     if (hr || (res != FIELD_OFFSET(OBJREF, u_objref)))
 857     {
 858         ERR("Failed to read common OBJREF header, 0x%08lx\n", hr);
 859         return STG_E_READFAULT;
 860     }
 861
 862     /* sanity check on header */
 863     if (objref.signature != OBJREF_SIGNATURE)
 864     {
 865         ERR("Bad OBJREF signature 0x%08lx\n", objref.signature);
 866         return RPC_E_INVALID_OBJREF;
 867     }
 868
 869     /* FIXME: handler marshaling */
 870     if (objref.flags & OBJREF_STANDARD)
 871     {
 872         TRACE("Using standard unmarshaling\n");
 873         hr = StdMarshalImpl_Construct(&IID_IMarshal, (LPVOID*)marshal);
 874     }
 875     else if (objref.flags & OBJREF_CUSTOM)
 876     {
 877         ULONG custom_header_size = FIELD_OFFSET(OBJREF, u_objref.u_custom.size) -
 878                                    FIELD_OFFSET(OBJREF, u_objref.u_custom);
 879         TRACE("Using custom unmarshaling\n");
 880         /* read constant sized OR_CUSTOM data from stream */
 881         hr = IStream_Read(stream, &objref.u_objref.u_custom,
 882                           custom_header_size, &res);
 883         if (hr || (res != custom_header_size))
 884         {
 885             ERR("Failed to read OR_CUSTOM header, 0x%08lx\n", hr);
 886             return STG_E_READFAULT;
 887         }
 888         /* now create the marshaler specified in the stream */
 889         hr = CoCreateInstance(&objref.u_objref.u_custom.clsid, NULL,
 890                               CLSCTX_INPROC_SERVER, &IID_IMarshal,
 891                               (LPVOID*)marshal);
 892     }
 893     else
 894     {
 895         FIXME("Invalid or unimplemented marshaling type specified: %lx\n",
 896             objref.flags);
 897         return RPC_E_INVALID_OBJREF;
 898     }
 899
 900     if (hr)
 901         ERR("Failed to create marshal, 0x%08lx\n", hr);
 902
 903     return hr;
 904 }
 905
 906 /***********************************************************************
 907  *              CoGetMarshalSizeMax     [OLE32.@]
 908  *
 909  * Gets the maximum amount of data that will be needed by a marshal.
 910  *
 911  * PARAMS
 912  *  pulSize       [O] Address where maximum marshal size will be stored.
 913  *  riid          [I] Identifier of the interface to marshal.
 914  *  pUnk          [I] Pointer to the object to marshal.
 915  *  dwDestContext [I] Destination. Used to enable or disable optimizations.
 916  *  pvDestContext [I] Reserved. Must be NULL.
 917  *  mshlFlags     [I] Flags that affect the marshaling. See CoMarshalInterface().
 918  *
 919  * RETURNS
 920  *  Success: S_OK.
 921  *  Failure: HRESULT code.
 922  *
 923  * SEE ALSO
 924  *  CoMarshalInterface().
 925  */
 926 HRESULT WINAPI CoGetMarshalSizeMax(ULONG *pulSize, REFIID riid, IUnknown *pUnk,
 927                                    DWORD dwDestContext, void *pvDestContext,
 928                                    DWORD mshlFlags)
 929 {
 930     HRESULT hr;
 931     LPMARSHAL pMarshal;
 932     CLSID marshaler_clsid;
 933
 934     hr = get_marshaler(riid, pUnk, dwDestContext, pvDestContext, mshlFlags, &pMarshal);
 935     if (hr)
 936         return hr;
 937
 938     hr = IMarshal_GetUnmarshalClass(pMarshal, riid, pUnk, dwDestContext,
 939                                     pvDestContext, mshlFlags, &marshaler_clsid);
 940     if (hr)
 941     {
 942         ERR("IMarshal::GetUnmarshalClass failed, 0x%08lx\n", hr);
 943         IMarshal_Release(pMarshal);
 944         return hr;
 945     }
 946
 947     hr = IMarshal_GetMarshalSizeMax(pMarshal, riid, pUnk, dwDestContext,
 948                                     pvDestContext, mshlFlags, pulSize);
 949     /* add on the size of the common header */
 950     *pulSize += FIELD_OFFSET(OBJREF, u_objref);
 951
 952     /* if custom marshaling, add on size of custom header */
 953     if (!IsEqualCLSID(&marshaler_clsid, &CLSID_DfMarshal))
 954         *pulSize += FIELD_OFFSET(OBJREF, u_objref.u_custom.size) -
 955                     FIELD_OFFSET(OBJREF, u_objref.u_custom);
 956
 957     IMarshal_Release(pMarshal);
 958     return hr;
 959 }
 960
 961
 962 /***********************************************************************
 963  *              CoMarshalInterface      [OLE32.@]
 964  *
 965  * Marshals an interface into a stream so that the object can then be
 966  * unmarshaled from another COM apartment and used remotely.
 967  *
 968  * PARAMS
 969  *  pStream       [I] Stream the object will be marshaled into.
 970  *  riid          [I] Identifier of the interface to marshal.
 971  *  pUnk          [I] Pointer to the object to marshal.
 972  *  dwDestContext [I] Destination. Used to enable or disable optimizations.
 973  *  pvDestContext [I] Reserved. Must be NULL.
 974  *  mshlFlags     [I] Flags that affect the marshaling. See notes.
 975  *
 976  * RETURNS
 977  *  Success: S_OK.
 978  *  Failure: HRESULT code.
 979  *
 980  * NOTES
 981  *
 982  * The mshlFlags parameter can take one or more of the following flags:
 983  *| MSHLFLAGS_NORMAL - Unmarshal once, releases stub on last proxy release.
 984  *| MSHLFLAGS_TABLESTRONG - Unmarshal many, release when CoReleaseMarshalData() called.
 985  *| MSHLFLAGS_TABLEWEAK - Unmarshal many, releases stub on last proxy release.
 986  *| MSHLFLAGS_NOPING - No automatic garbage collection (and so reduces network traffic).
 987  *
 988  * If a marshaled object is not unmarshaled, then CoReleaseMarshalData() must
 989  * be called in order to release the resources used in the marshaling.
 990  *
 991  * SEE ALSO
 992  *  CoUnmarshalInterface(), CoReleaseMarshalData().
 993  */
 994 HRESULT WINAPI CoMarshalInterface(IStream *pStream, REFIID riid, IUnknown *pUnk,
 995                                   DWORD dwDestContext, void *pvDestContext,
 996                                   DWORD mshlFlags)
 997 {
 998     HRESULT     hr;
 999     CLSID marshaler_clsid;
1000     OBJREF objref;
1001     IStream * pMarshalStream = NULL;
1002     LPMARSHAL pMarshal;
1003
1004     TRACE("(%p, %s, %p, %lx, %p, %lx)\n", pStream, debugstr_guid(riid), pUnk,
1005         dwDestContext, pvDestContext, mshlFlags);
1006
1007     if (pUnk == NULL)
1008         return E_INVALIDARG;
1009
1010     objref.signature = OBJREF_SIGNATURE;
1011     objref.iid = *riid;
1012
1013     /* get the marshaler for the specified interface */
1014     hr = get_marshaler(riid, pUnk, dwDestContext, pvDestContext, mshlFlags, &pMarshal);
1015     if (hr)
1016     {
1017         ERR("Failed to get marshaller, 0x%08lx\n", hr);
1018         return hr;
1019     }
1020
1021     hr = IMarshal_GetUnmarshalClass(pMarshal, riid, pUnk, dwDestContext,
1022                                     pvDestContext, mshlFlags, &marshaler_clsid);
1023     if (hr)
1024     {
1025         ERR("IMarshal::GetUnmarshalClass failed, 0x%08lx\n", hr);
1026         goto cleanup;
1027     }
1028
1029     /* FIXME: implement handler marshaling too */
1030     if (IsEqualCLSID(&marshaler_clsid, &CLSID_DfMarshal))
1031     {
1032         TRACE("Using standard marshaling\n");
1033         objref.flags = OBJREF_STANDARD;
1034         pMarshalStream = pStream;
1035     }
1036     else
1037     {
1038         TRACE("Using custom marshaling\n");
1039         objref.flags = OBJREF_CUSTOM;
1040         /* we do custom marshaling into a memory stream so that we know what
1041          * size to write into the OR_CUSTOM header */
1042         hr = CreateStreamOnHGlobal(NULL, TRUE, &pMarshalStream);
1043         if (hr)
1044         {
1045             ERR("CreateStreamOnHGLOBAL failed with 0x%08lx\n", hr);
1046             goto cleanup;
1047         }
1048     }
1049
1050     /* write the common OBJREF header to the stream */
1051     hr = IStream_Write(pStream, &objref, FIELD_OFFSET(OBJREF, u_objref), NULL);
1052     if (hr)
1053     {
1054         ERR("Failed to write OBJREF header to stream, 0x%08lx\n", hr);
1055         goto cleanup;
1056     }
1057
1058     TRACE("Calling IMarshal::MarshalInterace\n");
1059     /* call helper object to do the actual marshaling */
1060     hr = IMarshal_MarshalInterface(pMarshal, pMarshalStream, riid, pUnk, dwDestContext,
1061                                    pvDestContext, mshlFlags);
1062
1063     if (hr)
1064     {
1065         ERR("Failed to marshal the interface %s, %lx\n", debugstr_guid(riid), hr);
1066         goto cleanup;
1067     }
1068
1069     if (objref.flags & OBJREF_CUSTOM)
1070     {
1071         ULONG custom_header_size = FIELD_OFFSET(OBJREF, u_objref.u_custom.size) -
1072                                    FIELD_OFFSET(OBJREF, u_objref.u_custom);
1073         HGLOBAL hGlobal;
1074         LPVOID data;
1075         hr = GetHGlobalFromStream(pMarshalStream, &hGlobal);
1076         if (hr)
1077         {
1078             ERR("Couldn't get HGLOBAL from stream\n");
1079             hr = E_UNEXPECTED;
1080             goto cleanup;
1081         }
1082         objref.u_objref.u_custom.clsid = marshaler_clsid;
1083         objref.u_objref.u_custom.cbExtension = 0;
1084         objref.u_objref.u_custom.size = GlobalSize(hGlobal);
1085         /* write constant sized OR_CUSTOM data into stream */
1086         hr = IStream_Write(pStream, &objref.u_objref.u_custom,
1087                           custom_header_size, NULL);
1088         if (hr)
1089         {
1090             ERR("Failed to write OR_CUSTOM header to stream with 0x%08lx\n", hr);
1091             goto cleanup;
1092         }
1093
1094         data = GlobalLock(hGlobal);
1095         if (!data)
1096         {
1097             ERR("GlobalLock failed\n");
1098             hr = E_UNEXPECTED;
1099             goto cleanup;
1100         }
1101         /* write custom marshal data */
1102         hr = IStream_Write(pStream, data, objref.u_objref.u_custom.size, NULL);
1103         if (hr)
1104         {
1105             ERR("Failed to write custom marshal data with 0x%08lx\n", hr);
1106             goto cleanup;
1107         }
1108         GlobalUnlock(hGlobal);
1109     }
1110
1111 cleanup:
1112     if (pMarshalStream && (objref.flags & OBJREF_CUSTOM))
1113         IStream_Release(pMarshalStream);
1114     IMarshal_Release(pMarshal);
1115     return hr;
1116 }
1117
1118 /***********************************************************************
1119  *              CoUnmarshalInterface    [OLE32.@]
1120  *
1121  * Unmarshals an object from a stream by creating a proxy to the remote
1122  * object, if necessary.
1123  *
1124  * PARAMS
1125  *
1126  *  pStream [I] Stream containing the marshaled object.
1127  *  riid    [I] Interface identifier of the object to create a proxy to.
1128  *  ppv     [O] Address where proxy will be stored.
1129  *
1130  * RETURNS
1131  *
1132  *  Success: S_OK.
1133  *  Failure: HRESULT code.
1134  *
1135  * SEE ALSO
1136  *  CoMarshalInterface().
1137  */
1138 HRESULT WINAPI CoUnmarshalInterface(IStream *pStream, REFIID riid, LPVOID *ppv)
1139 {
1140     HRESULT     hr;
1141     LPMARSHAL pMarshal;
1142
1143     TRACE("(%p, %s, %p)\n", pStream, debugstr_guid(riid), ppv);
1144
1145     hr = get_unmarshaler_from_stream(pStream, &pMarshal);
1146     if (hr != S_OK)
1147         return hr;
1148
1149     /* call the helper object to do the actual unmarshaling */
1150     hr = IMarshal_UnmarshalInterface(pMarshal, pStream, riid, ppv);
1151     if (hr)
1152         ERR("IMarshal::UnmarshalInterface failed, 0x%08lx\n", hr);
1153
1154     IMarshal_Release(pMarshal);
1155     return hr;
1156 }
1157
1158 /***********************************************************************
1159  *              CoReleaseMarshalData    [OLE32.@]
1160  *
1161  * Releases resources associated with an object that has been marshaled into
1162  * a stream.
1163  *
1164  * PARAMS
1165  *
1166  *  pStream [I] The stream that the object has been marshaled into.
1167  *
1168  * RETURNS
1169  *  Success: S_OK.
1170  *  Failure: HRESULT error code.
1171  *
1172  * NOTES
1173  *
1174  * Call this function to release resources associated with a normal or
1175  * table-weak marshal that will not be unmarshaled, and all table-strong
1176  * marshals when they are no longer needed.
1177  *
1178  * SEE ALSO
1179  *  CoMarshalInterface(), CoUnmarshalInterface().
1180  */
1181 HRESULT WINAPI CoReleaseMarshalData(IStream *pStream)
1182 {
1183     HRESULT     hr;
1184     LPMARSHAL pMarshal;
1185
1186     TRACE("(%p)\n", pStream);
1187
1188     hr = get_unmarshaler_from_stream(pStream, &pMarshal);
1189     if (hr != S_OK)
1190         return hr;
1191
1192     /* call the helper object to do the releasing of marshal data */
1193     hr = IMarshal_ReleaseMarshalData(pMarshal, pStream);
1194     if (hr)
1195         ERR("IMarshal::ReleaseMarshalData failed with error 0x%08lx\n", hr);
1196
1197     IMarshal_Release(pMarshal);
1198     return hr;
1199 }
1200
1201
1202 /***********************************************************************
1203  *              CoMarshalInterThreadInterfaceInStream   [OLE32.@]
1204  *
1205  * Marshal an interface across threads in the same process.
1206  *
1207  * PARAMS
1208  *  riid  [I] Identifier of the interface to be marshalled.
1209  *  pUnk  [I] Pointer to IUnknown-derived interface that will be marshalled.
1210  *  ppStm [O] Pointer to IStream object that is created and then used to store the marshalled inteface.
1211  *
1212  * RETURNS
1213  *  Success: S_OK
1214  *  Failure: E_OUTOFMEMORY and other COM error codes
1215  *
1216  * SEE ALSO
1217  *   CoMarshalInterface(), CoUnmarshalInterface() and CoGetInterfaceAndReleaseStream()
1218  */
1219 HRESULT WINAPI CoMarshalInterThreadInterfaceInStream(
1220     REFIID riid, LPUNKNOWN pUnk, LPSTREAM * ppStm)
1221 {
1222     ULARGE_INTEGER      xpos;
1223     LARGE_INTEGER               seekto;
1224     HRESULT             hres;
1225
1226     TRACE("(%s, %p, %p)\n",debugstr_guid(riid), pUnk, ppStm);
1227
1228     hres = CreateStreamOnHGlobal(0, TRUE, ppStm);
1229     if (FAILED(hres)) return hres;
1230     hres = CoMarshalInterface(*ppStm, riid, pUnk, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
1231
1232     /* FIXME: is this needed? */
1233     memset(&seekto,0,sizeof(seekto));
1234     IStream_Seek(*ppStm,seekto,SEEK_SET,&xpos);
1235
1236     return hres;
1237 }
1238
1239 /***********************************************************************
1240  *              CoGetInterfaceAndReleaseStream  [OLE32.@]
1241  *
1242  * Unmarshalls an inteface from a stream and then releases the stream.
1243  *
1244  * PARAMS
1245  *  pStm [I] Stream that contains the marshalled inteface.
1246  *  riid [I] Interface identifier of the object to unmarshall.
1247  *  ppv  [O] Address of pointer where the requested interface object will be stored.
1248  *
1249  * RETURNS
1250  *  Success: S_OK
1251  *  Failure: A COM error code
1252  *
1253  * SEE ALSO
1254  *  CoMarshalInterThreadInterfaceInStream() and CoUnmarshalInteface()
1255  */
1256 HRESULT WINAPI CoGetInterfaceAndReleaseStream(LPSTREAM pStm, REFIID riid,
1257                                               LPVOID *ppv)
1258 {
1259     HRESULT hres;
1260
1261     TRACE("(%p, %s, %p)\n", pStm, debugstr_guid(riid), ppv);
1262
1263     hres = CoUnmarshalInterface(pStm, riid, ppv);
1264     IStream_Release(pStm);
1265     return hres;
1266 }
1267
1268 static HRESULT WINAPI StdMarshalCF_QueryInterface(LPCLASSFACTORY iface,
1269                                                   REFIID riid, LPVOID *ppv)
1270 {
1271     *ppv = NULL;
1272     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IClassFactory))
1273     {
1274         *ppv = (LPVOID)iface;
1275         return S_OK;
1276     }
1277     return E_NOINTERFACE;
1278 }
1279
1280 static ULONG WINAPI StdMarshalCF_AddRef(LPCLASSFACTORY iface)
1281 {
1282     return 2; /* non-heap based object */
1283 }
1284
1285 static ULONG WINAPI StdMarshalCF_Release(LPCLASSFACTORY iface)
1286 {
1287     return 1; /* non-heap based object */
1288 }
1289
1290 static HRESULT WINAPI StdMarshalCF_CreateInstance(LPCLASSFACTORY iface,
1291     LPUNKNOWN pUnk, REFIID riid, LPVOID *ppv)
1292 {
1293   if (IsEqualIID(riid,&IID_IMarshal))
1294     return StdMarshalImpl_Construct(riid, ppv);
1295
1296   FIXME("(%s), not supported.\n",debugstr_guid(riid));
1297   return E_NOINTERFACE;
1298 }
1299
1300 static HRESULT WINAPI StdMarshalCF_LockServer(LPCLASSFACTORY iface, BOOL fLock)
1301 {
1302     FIXME("(%d), stub!\n",fLock);
1303     return S_OK;
1304 }
1305
1306 static IClassFactoryVtbl StdMarshalCFVtbl =
1307 {
1308     StdMarshalCF_QueryInterface,
1309     StdMarshalCF_AddRef,
1310     StdMarshalCF_Release,
1311     StdMarshalCF_CreateInstance,
1312     StdMarshalCF_LockServer
1313 };
1314 static IClassFactoryVtbl *StdMarshalCF = &StdMarshalCFVtbl;
1315
1316 HRESULT MARSHAL_GetStandardMarshalCF(LPVOID *ppv)
1317 {
1318     *ppv = &StdMarshalCF;
1319     return S_OK;
1320 }
1321
1322 /***********************************************************************
1323  *              CoMarshalHresult        [OLE32.@]
1324  *
1325  * Marshals an HRESULT value into a stream.
1326  *
1327  * PARAMS
1328  *  pStm    [I] Stream that hresult will be marshalled into.
1329  *  hresult [I] HRESULT to be marshalled.
1330  *
1331  * RETURNS
1332  *  Success: S_OK
1333  *  Failure: A COM error code
1334  *
1335  * SEE ALSO
1336  *  CoUnmarshalHresult().
1337  */
1338 HRESULT WINAPI CoMarshalHresult(LPSTREAM pStm, HRESULT hresult)
1339 {
1340     return IStream_Write(pStm, &hresult, sizeof(hresult), NULL);
1341 }
1342
1343 /***********************************************************************
1344  *              CoUnmarshalHresult      [OLE32.@]
1345  *
1346  * Unmarshals an HRESULT value from a stream.
1347  *
1348  * PARAMS
1349  *  pStm     [I] Stream that hresult will be unmarshalled from.
1350  *  phresult [I] Pointer to HRESULT where the value will be unmarshalled to.
1351  *
1352  * RETURNS
1353  *  Success: S_OK
1354  *  Failure: A COM error code
1355  *
1356  * SEE ALSO
1357  *  CoMarshalHresult().
1358  */
1359 HRESULT WINAPI CoUnmarshalHresult(LPSTREAM pStm, HRESULT * phresult)
1360 {
1361     return IStream_Read(pStm, phresult, sizeof(*phresult), NULL);
1362 }