git.oblomov.eu Git - wine/blob - 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 /* number of refs given out for normal marshaling */
  53 #define NORMALEXTREFS 1 /* FIXME: this should be 5, but we have to wait for IRemUnknown support first */
  54
  55 /* private flag indicating that the caller does not want to notify the stub
  56  * when the proxy disconnects or is destroyed */
  57 #define SORFP_NOLIFETIMEMGMT SORF_OXRES1
  58
  59 static HRESULT unmarshal_object(const STDOBJREF *stdobjref, APARTMENT *apt, REFIID riid, void **object);
  60
  61 /* Marshalling just passes a unique identifier to the remote client,
  62  * that makes it possible to find the passed interface again.
  63  *
  64  * So basically we need a set of values that make it unique.
  65  *
  66  * Note that the IUnknown_QI(ob,xiid,&ppv) always returns the SAME ppv value!
  67  *
  68  * A triple is used: OXID (apt id), OID (stub manager id),
  69  * IPID (interface ptr/stub id).
  70  *
  71  * OXIDs identify an apartment and are network scoped
  72  * OIDs identify a stub manager and are apartment scoped
  73  * IPIDs identify an interface stub and are apartment scoped
  74  */
  75
  76 inline static HRESULT get_facbuf_for_iid(REFIID riid, IPSFactoryBuffer **facbuf)
  77 {
  78     HRESULT       hr;
  79     CLSID         clsid;
  80
  81     if ((hr = CoGetPSClsid(riid, &clsid)))
  82         return hr;
  83     return CoGetClassObject(&clsid, CLSCTX_INPROC_SERVER, NULL,
  84         &IID_IPSFactoryBuffer, (LPVOID*)facbuf);
  85 }
  86
  87 /* marshals an object into a STDOBJREF structure */
  88 HRESULT marshal_object(APARTMENT *apt, STDOBJREF *stdobjref, REFIID riid, IUnknown *object, MSHLFLAGS mshlflags)
  89 {
  90     struct stub_manager *manager;
  91     struct ifstub       *ifstub;
  92     BOOL                 tablemarshal;
  93     IRpcStubBuffer      *stub = NULL;
  94     HRESULT              hr;
  95     IUnknown            *iobject = NULL; /* object of type riid */
  96
  97     hr = apartment_getoxid(apt, &stdobjref->oxid);
  98     if (hr != S_OK)
  99         return hr;
 100
 101     hr = apartment_createwindowifneeded(apt);
 102     if (hr != S_OK)
 103         return hr;
 104
 105     hr = IUnknown_QueryInterface(object, riid, (void **)&iobject);
 106     if (hr != S_OK)
 107     {
 108         ERR("object doesn't expose interface %s, failing with error 0x%08lx\n",
 109             debugstr_guid(riid), hr);
 110         return E_NOINTERFACE;
 111     }
 112
 113     /* IUnknown doesn't require a stub buffer, because it never goes out on
 114      * the wire */
 115     if (!IsEqualIID(riid, &IID_IUnknown))
 116     {
 117         IPSFactoryBuffer *psfb;
 118
 119         hr = get_facbuf_for_iid(riid, &psfb);
 120         if (hr != S_OK)
 121         {
 122             ERR("couldn't get IPSFactory buffer for interface %s\n", debugstr_guid(riid));
 123             IUnknown_Release(iobject);
 124             return hr;
 125         }
 126
 127         hr = IPSFactoryBuffer_CreateStub(psfb, riid, iobject, &stub);
 128         IPSFactoryBuffer_Release(psfb);
 129         if (hr != S_OK)
 130         {
 131             ERR("Failed to create an IRpcStubBuffer from IPSFactory for %s\n", debugstr_guid(riid));
 132             IUnknown_Release(iobject);
 133             return hr;
 134         }
 135     }
 136
 137     if (mshlflags & MSHLFLAGS_NOPING)
 138         stdobjref->flags = SORF_NOPING;
 139     else
 140         stdobjref->flags = SORF_NULL;
 141
 142     if ((manager = get_stub_manager_from_object(apt, object)))
 143         TRACE("registering new ifstub on pre-existing manager\n");
 144     else
 145     {
 146         TRACE("constructing new stub manager\n");
 147
 148         manager = new_stub_manager(apt, object);
 149         if (!manager)
 150         {
 151             if (stub) IRpcStubBuffer_Release(stub);
 152             IUnknown_Release(iobject);
 153             return E_OUTOFMEMORY;
 154         }
 155     }
 156     stdobjref->oid = manager->oid;
 157
 158     tablemarshal = ((mshlflags & MSHLFLAGS_TABLESTRONG) || (mshlflags & MSHLFLAGS_TABLEWEAK));
 159
 160     /* make sure ifstub that we are creating is unique */
 161     ifstub = stub_manager_find_ifstub(manager, riid, mshlflags);
 162     if (!ifstub)
 163     {
 164         ifstub = stub_manager_new_ifstub(manager, stub, iobject, riid, mshlflags);
 165         IUnknown_Release(iobject);
 166         if (stub) IRpcStubBuffer_Release(stub);
 167         if (!ifstub)
 168         {
 169             stub_manager_int_release(manager);
 170             /* FIXME: should we do another release to completely destroy the
 171              * stub manager? */
 172             return E_OUTOFMEMORY;
 173         }
 174     }
 175
 176     if (!tablemarshal)
 177     {
 178         stdobjref->cPublicRefs = NORMALEXTREFS;
 179         stub_manager_ext_addref(manager, stdobjref->cPublicRefs);
 180     }
 181     else
 182     {
 183         stdobjref->cPublicRefs = 0;
 184         if (mshlflags & MSHLFLAGS_TABLESTRONG)
 185             stub_manager_ext_addref(manager, 1);
 186     }
 187
 188     /* FIXME: check return value */
 189     RPC_RegisterInterface(riid);
 190
 191     stdobjref->ipid = ifstub->ipid;
 192
 193     stub_manager_int_release(manager);
 194     return S_OK;
 195 }
 196
 197
 198
 199 /* Client-side identity of the server object */
 200
 201 static HRESULT proxy_manager_get_remunknown(struct proxy_manager * This, IRemUnknown **remunk);
 202 static void proxy_manager_destroy(struct proxy_manager * This);
 203 static HRESULT proxy_manager_find_ifproxy(struct proxy_manager * This, REFIID riid, struct ifproxy ** ifproxy_found);
 204 static HRESULT proxy_manager_query_local_interface(struct proxy_manager * This, REFIID riid, void ** ppv);
 205
 206 static HRESULT WINAPI ClientIdentity_QueryInterface(IMultiQI * iface, REFIID riid, void ** ppv)
 207 {
 208     HRESULT hr;
 209     MULTI_QI mqi;
 210
 211     TRACE("%s\n", debugstr_guid(riid));
 212
 213     mqi.pIID = riid;
 214     hr = IMultiQI_QueryMultipleInterfaces(iface, 1, &mqi);
 215     *ppv = (void *)mqi.pItf;
 216
 217     return hr;
 218 }
 219
 220 static ULONG WINAPI ClientIdentity_AddRef(IMultiQI * iface)
 221 {
 222     struct proxy_manager * This = (struct proxy_manager *)iface;
 223     TRACE("%p - before %ld\n", iface, This->refs);
 224     return InterlockedIncrement(&This->refs);
 225 }
 226
 227 static ULONG WINAPI ClientIdentity_Release(IMultiQI * iface)
 228 {
 229     struct proxy_manager * This = (struct proxy_manager *)iface;
 230     ULONG refs = InterlockedDecrement(&This->refs);
 231     TRACE("%p - after %ld\n", iface, refs);
 232     if (!refs)
 233         proxy_manager_destroy(This);
 234     return refs;
 235 }
 236
 237 static HRESULT WINAPI ClientIdentity_QueryMultipleInterfaces(IMultiQI *iface, ULONG cMQIs, MULTI_QI *pMQIs)
 238 {
 239     struct proxy_manager * This = (struct proxy_manager *)iface;
 240     REMQIRESULT *qiresults = NULL;
 241     ULONG nonlocal_mqis = 0;
 242     ULONG i;
 243     ULONG successful_mqis = 0;
 244     IID *iids = HeapAlloc(GetProcessHeap(), 0, cMQIs * sizeof(*iids));
 245     /* mapping of RemQueryInterface index to QueryMultipleInterfaces index */
 246     ULONG *mapping = HeapAlloc(GetProcessHeap(), 0, cMQIs * sizeof(*mapping));
 247
 248     TRACE("cMQIs: %ld\n", cMQIs);
 249
 250     /* try to get a local interface - this includes already active proxy
 251      * interfaces and also interfaces exposed by the proxy manager */
 252     for (i = 0; i < cMQIs; i++)
 253     {
 254         TRACE("iid[%ld] = %s\n", i, debugstr_guid(pMQIs[i].pIID));
 255         pMQIs[i].hr = proxy_manager_query_local_interface(This, pMQIs[i].pIID, (void **)&pMQIs[i].pItf);
 256         if (pMQIs[i].hr == S_OK)
 257             successful_mqis++;
 258         else
 259         {
 260             iids[nonlocal_mqis] = *pMQIs[i].pIID;
 261             mapping[nonlocal_mqis] = i;
 262             nonlocal_mqis++;
 263         }
 264     }
 265
 266     TRACE("%ld interfaces not found locally\n", nonlocal_mqis);
 267
 268     /* if we have more than one interface not found locally then we must try
 269      * to query the remote object for it */
 270     if (nonlocal_mqis != 0)
 271     {
 272         IRemUnknown *remunk;
 273         HRESULT hr;
 274         IPID *ipid;
 275
 276         /* get the ipid of the first entry */
 277         /* FIXME: should we implement ClientIdentity on the ifproxies instead
 278          * of the proxy_manager so we use the correct ipid here? */
 279         ipid = &LIST_ENTRY(list_head(&This->interfaces), struct ifproxy, entry)->stdobjref.ipid;
 280
 281         /* get IRemUnknown proxy so we can communicate with the remote object */
 282         hr = proxy_manager_get_remunknown(This, &remunk);
 283
 284         if (hr == S_OK)
 285         {
 286             hr = IRemUnknown_RemQueryInterface(remunk, ipid, NORMALEXTREFS,
 287                                                nonlocal_mqis, iids, &qiresults);
 288             if (FAILED(hr))
 289                 ERR("IRemUnknown_RemQueryInterface failed with error 0x%08lx\n", hr);
 290         }
 291
 292         /* IRemUnknown_RemQueryInterface can return S_FALSE if only some of
 293          * the interfaces were returned */
 294         if (SUCCEEDED(hr))
 295         {
 296             /* try to unmarshal each object returned to us */
 297             for (i = 0; i < nonlocal_mqis; i++)
 298             {
 299                 ULONG index = mapping[i];
 300                 HRESULT hrobj = qiresults[i].hResult;
 301                 if (hrobj == S_OK)
 302                     hrobj = unmarshal_object(&qiresults[i].std, This->parent,
 303                                              pMQIs[index].pIID,
 304                                              (void **)&pMQIs[index].pItf);
 305
 306                 if (hrobj == S_OK)
 307                     successful_mqis++;
 308                 else
 309                     ERR("Failed to get pointer to interface %s\n", debugstr_guid(pMQIs[index].pIID));
 310                 pMQIs[index].hr = hrobj;
 311             }
 312         }
 313
 314         /* free the memory allocated by the proxy */
 315         CoTaskMemFree(qiresults);
 316     }
 317
 318     TRACE("%ld/%ld successfully queried\n", successful_mqis, cMQIs);
 319
 320     HeapFree(GetProcessHeap(), 0, iids);
 321     HeapFree(GetProcessHeap(), 0, mapping);
 322
 323     if (successful_mqis == cMQIs)
 324         return S_OK; /* we got all requested interfaces */
 325     else if (successful_mqis == 0)
 326         return E_NOINTERFACE; /* we didn't get any interfaces */
 327     else
 328         return S_FALSE; /* we got some interfaces */
 329 }
 330
 331 static const IMultiQIVtbl ClientIdentity_Vtbl =
 332 {
 333     ClientIdentity_QueryInterface,
 334     ClientIdentity_AddRef,
 335     ClientIdentity_Release,
 336     ClientIdentity_QueryMultipleInterfaces
 337 };
 338
 339 static HRESULT WINAPI Proxy_QueryInterface(IMarshal *iface, REFIID riid, void **ppvObject)
 340 {
 341     ICOM_THIS_MULTI(struct proxy_manager, lpVtblMarshal, iface);
 342     return IMultiQI_QueryInterface((IMultiQI *)&This->lpVtbl, riid, ppvObject);
 343 }
 344
 345 static ULONG WINAPI Proxy_AddRef(IMarshal *iface)
 346 {
 347     ICOM_THIS_MULTI(struct proxy_manager, lpVtblMarshal, iface);
 348     return IMultiQI_AddRef((IMultiQI *)&This->lpVtbl);
 349 }
 350
 351 /* FIXME: remove these */
 352 static HRESULT WINAPI StdMarshalImpl_GetUnmarshalClass(LPMARSHAL iface, REFIID riid, void* pv, DWORD dwDestContext, void* pvDestContext, DWORD mshlflags, CLSID* pCid);
 353 static HRESULT WINAPI StdMarshalImpl_GetMarshalSizeMax(LPMARSHAL iface, REFIID riid, void* pv, DWORD dwDestContext, void* pvDestContext, DWORD mshlflags, DWORD* pSize);
 354 static HRESULT WINAPI StdMarshalImpl_UnmarshalInterface(LPMARSHAL iface, IStream *pStm, REFIID riid, void **ppv);
 355 static HRESULT WINAPI StdMarshalImpl_ReleaseMarshalData(LPMARSHAL iface, IStream *pStm);
 356 static HRESULT WINAPI StdMarshalImpl_DisconnectObject(LPMARSHAL iface, DWORD dwReserved);
 357
 358 static ULONG WINAPI Proxy_Release(IMarshal *iface)
 359 {
 360     ICOM_THIS_MULTI(struct proxy_manager, lpVtblMarshal, iface);
 361     return IMultiQI_Release((IMultiQI *)&This->lpVtbl);
 362 }
 363
 364 static HRESULT WINAPI Proxy_MarshalInterface(
 365     LPMARSHAL iface, IStream *pStm, REFIID riid, void* pv, DWORD dwDestContext,
 366     void* pvDestContext, DWORD mshlflags)
 367 {
 368     ICOM_THIS_MULTI(struct proxy_manager, lpVtblMarshal, iface);
 369     ULONG res;
 370     HRESULT hr;
 371     STDOBJREF stdobjref;
 372     struct ifproxy *ifproxy;
 373
 374     TRACE("(...,%s,...)\n", debugstr_guid(riid));
 375
 376     hr = proxy_manager_find_ifproxy(This, riid, &ifproxy);
 377     if (FAILED(hr))
 378     {
 379         ERR("couldn't find proxy for interface %s, error 0x%08lx\n", debugstr_guid(riid), hr);
 380         return hr;
 381     }
 382
 383     stdobjref = ifproxy->stdobjref;
 384     /* FIXME: optimization - share out proxy's public references if possible
 385      * instead of making new proxy do a roundtrip through the server */
 386     stdobjref.cPublicRefs = 0; /* InterlockedDecrement(&This->stdobjref.cPublicRefs) >= 0 ? 1 : 0 */
 387     hr = IStream_Write(pStm, &stdobjref, sizeof(stdobjref), &res);
 388
 389     return hr;
 390 }
 391
 392 static const IMarshalVtbl ProxyMarshal_Vtbl =
 393 {
 394     Proxy_QueryInterface,
 395     Proxy_AddRef,
 396     Proxy_Release,
 397     StdMarshalImpl_GetUnmarshalClass,
 398     StdMarshalImpl_GetMarshalSizeMax,
 399     Proxy_MarshalInterface,
 400     StdMarshalImpl_UnmarshalInterface,
 401     StdMarshalImpl_ReleaseMarshalData,
 402     StdMarshalImpl_DisconnectObject
 403 };
 404
 405 static HRESULT ifproxy_get_public_ref(struct ifproxy * This)
 406 {
 407     HRESULT hr = S_OK;
 408
 409     if (WAIT_OBJECT_0 != WaitForSingleObject(This->parent->remoting_mutex, INFINITE))
 410     {
 411         ERR("Wait failed for ifproxy %p\n", This);
 412         return E_UNEXPECTED;
 413     }
 414
 415     if (This->refs == 0)
 416     {
 417         IRemUnknown *remunk = NULL;
 418
 419         TRACE("getting public ref for ifproxy %p\n", This);
 420
 421         hr = proxy_manager_get_remunknown(This->parent, &remunk);
 422         if (hr == S_OK)
 423         {
 424             HRESULT hrref = S_OK;
 425             REMINTERFACEREF rif;
 426             rif.ipid = This->stdobjref.ipid;
 427             rif.cPublicRefs = NORMALEXTREFS;
 428             rif.cPrivateRefs = 0;
 429             hr = IRemUnknown_RemAddRef(remunk, 1, &rif, &hrref);
 430             if (hr == S_OK && hrref == S_OK)
 431                 This->refs += NORMALEXTREFS;
 432             else
 433                 ERR("IRemUnknown_RemAddRef returned with 0x%08lx, hrref = 0x%08lx\n", hr, hrref);
 434         }
 435     }
 436     ReleaseMutex(This->parent->remoting_mutex);
 437
 438     return hr;
 439 }
 440
 441 static HRESULT ifproxy_release_public_refs(struct ifproxy * This)
 442 {
 443     HRESULT hr = S_OK;
 444
 445     if (WAIT_OBJECT_0 != WaitForSingleObject(This->parent->remoting_mutex, INFINITE))
 446     {
 447         ERR("Wait failed for ifproxy %p\n", This);
 448         return E_UNEXPECTED;
 449     }
 450
 451     if (This->refs > 0)
 452     {
 453         IRemUnknown *remunk = NULL;
 454
 455         TRACE("releasing %ld refs\n", This->refs);
 456
 457         hr = proxy_manager_get_remunknown(This->parent, &remunk);
 458         if (hr == S_OK)
 459         {
 460             REMINTERFACEREF rif;
 461             rif.ipid = This->stdobjref.ipid;
 462             rif.cPublicRefs = This->refs;
 463             rif.cPrivateRefs = 0;
 464             hr = IRemUnknown_RemRelease(remunk, 1, &rif);
 465             if (hr == S_OK)
 466                 This->refs = 0;
 467             else if (hr == RPC_E_DISCONNECTED)
 468                 WARN("couldn't release references because object was "
 469                      "disconnected: oxid = %s, oid = %s\n",
 470                      wine_dbgstr_longlong(This->parent->oxid),
 471                      wine_dbgstr_longlong(This->parent->oid));
 472             else
 473                 ERR("IRemUnknown_RemRelease failed with error 0x%08lx\n", hr);
 474         }
 475     }
 476     ReleaseMutex(This->parent->remoting_mutex);
 477
 478     return hr;
 479 }
 480
 481 /* should be called inside This->parent->cs critical section */
 482 static void ifproxy_disconnect(struct ifproxy * This)
 483 {
 484     ifproxy_release_public_refs(This);
 485     if (This->proxy) IRpcProxyBuffer_Disconnect(This->proxy);
 486
 487     IRpcChannelBuffer_Release(This->chan);
 488     This->chan = NULL;
 489 }
 490
 491 /* should be called in This->parent->cs critical section if it is an entry in parent's list */
 492 static void ifproxy_destroy(struct ifproxy * This)
 493 {
 494     TRACE("%p\n", This);
 495
 496     /* release public references to this object so that the stub can know
 497      * when to destroy itself */
 498     ifproxy_release_public_refs(This);
 499
 500     list_remove(&This->entry);
 501
 502     if (This->chan)
 503     {
 504         IRpcChannelBuffer_Release(This->chan);
 505         This->chan = NULL;
 506     }
 507
 508     /* note: we don't call Release for This->proxy because its lifetime is
 509      * controlled by the return value from ClientIdentity_Release, which this
 510      * function is always called from */
 511
 512     HeapFree(GetProcessHeap(), 0, This);
 513 }
 514
 515 static HRESULT proxy_manager_construct(
 516     APARTMENT * apt, ULONG sorflags, OXID oxid, OID oid,
 517     struct proxy_manager ** proxy_manager)
 518 {
 519     struct proxy_manager * This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 520     if (!This) return E_OUTOFMEMORY;
 521
 522     This->remoting_mutex = CreateMutexW(NULL, FALSE, NULL);
 523     if (!This->remoting_mutex)
 524     {
 525         HeapFree(GetProcessHeap(), 0, This);
 526         return HRESULT_FROM_WIN32(GetLastError());
 527     }
 528
 529     This->lpVtbl = &ClientIdentity_Vtbl;
 530     This->lpVtblMarshal = &ProxyMarshal_Vtbl;
 531
 532     list_init(&This->entry);
 533     list_init(&This->interfaces);
 534
 535     InitializeCriticalSection(&This->cs);
 536     DEBUG_SET_CRITSEC_NAME(&This->cs, "proxy_manager");
 537
 538     /* the apartment the object was unmarshaled into */
 539     This->parent = apt;
 540
 541     /* the source apartment and id of the object */
 542     This->oxid = oxid;
 543     This->oid = oid;
 544
 545     This->refs = 1;
 546
 547     /* the DCOM draft specification states that the SORF_NOPING flag is
 548      * proxy manager specific, not ifproxy specific, so this implies that we
 549      * should store the STDOBJREF flags here in the proxy manager. */
 550     This->sorflags = sorflags;
 551
 552     /* we create the IRemUnknown proxy on demand */
 553     This->remunk = NULL;
 554
 555     EnterCriticalSection(&apt->cs);
 556     /* FIXME: we are dependent on the ordering in here to make sure a proxy's
 557      * IRemUnknown proxy doesn't get destroyed before the regual proxy does
 558      * because we need the IRemUnknown proxy during the destruction of the
 559      * regular proxy. Ideally, we should maintain a separate list for the
 560      * IRemUnknown proxies that need late destruction */
 561     list_add_tail(&apt->proxies, &This->entry);
 562     LeaveCriticalSection(&apt->cs);
 563
 564     TRACE("%p created for OXID %s, OID %s\n", This,
 565         wine_dbgstr_longlong(oxid), wine_dbgstr_longlong(oid));
 566
 567     *proxy_manager = This;
 568     return S_OK;
 569 }
 570
 571 static HRESULT proxy_manager_query_local_interface(struct proxy_manager * This, REFIID riid, void ** ppv)
 572 {
 573     HRESULT hr;
 574     struct ifproxy * ifproxy;
 575
 576     TRACE("%s\n", debugstr_guid(riid));
 577
 578     if (IsEqualIID(riid, &IID_IUnknown) ||
 579         IsEqualIID(riid, &IID_IMultiQI))
 580     {
 581         *ppv = (void *)&This->lpVtbl;
 582         IUnknown_AddRef((IUnknown *)*ppv);
 583         return S_OK;
 584     }
 585     if (IsEqualIID(riid, &IID_IMarshal))
 586     {
 587         *ppv = (void *)&This->lpVtblMarshal;
 588         IUnknown_AddRef((IUnknown *)*ppv);
 589         return S_OK;
 590     }
 591     if (IsEqualIID(riid, &IID_IClientSecurity))
 592     {
 593         FIXME("requesting IClientSecurity, but it is unimplemented\n");
 594         *ppv = NULL;
 595         return E_NOINTERFACE;
 596     }
 597
 598     hr = proxy_manager_find_ifproxy(This, riid, &ifproxy);
 599     if (hr == S_OK)
 600     {
 601         *ppv = ifproxy->iface;
 602         IUnknown_AddRef((IUnknown *)*ppv);
 603         return S_OK;
 604     }
 605
 606     *ppv = NULL;
 607     return E_NOINTERFACE;
 608 }
 609
 610 static HRESULT proxy_manager_create_ifproxy(
 611     struct proxy_manager * This, const STDOBJREF *stdobjref, REFIID riid,
 612     IRpcChannelBuffer * channel, struct ifproxy ** iif_out)
 613 {
 614     HRESULT hr;
 615     IPSFactoryBuffer * psfb;
 616     struct ifproxy * ifproxy = HeapAlloc(GetProcessHeap(), 0, sizeof(*ifproxy));
 617     if (!ifproxy) return E_OUTOFMEMORY;
 618
 619     list_init(&ifproxy->entry);
 620
 621     ifproxy->parent = This;
 622     ifproxy->stdobjref = *stdobjref;
 623     ifproxy->iid = *riid;
 624     ifproxy->refs = stdobjref->cPublicRefs;
 625     ifproxy->proxy = NULL;
 626
 627     assert(channel);
 628     ifproxy->chan = channel; /* FIXME: we should take the binding strings and construct the channel in this function */
 629
 630     /* the IUnknown interface is special because it does not have a
 631      * proxy associated with the ifproxy as we handle IUnknown ourselves */
 632     if (IsEqualIID(riid, &IID_IUnknown))
 633     {
 634         ifproxy->iface = (void *)&This->lpVtbl;
 635         IMultiQI_AddRef((IMultiQI *)&This->lpVtbl);
 636         hr = S_OK;
 637     }
 638     else
 639     {
 640         hr = get_facbuf_for_iid(riid, &psfb);
 641         if (hr == S_OK)
 642         {
 643             /* important note: the outer unknown is set to the proxy manager.
 644              * This ensures the COM identity rules are not violated, by having a
 645              * one-to-one mapping of objects on the proxy side to objects on the
 646              * stub side, no matter which interface you view the object through */
 647             hr = IPSFactoryBuffer_CreateProxy(psfb, (IUnknown *)&This->lpVtbl, riid,
 648                                               &ifproxy->proxy, &ifproxy->iface);
 649             IPSFactoryBuffer_Release(psfb);
 650             if (hr != S_OK)
 651                 ERR("Could not create proxy for interface %s, error 0x%08lx\n",
 652                     debugstr_guid(riid), hr);
 653         }
 654         else
 655             ERR("Could not get IPSFactoryBuffer for interface %s, error 0x%08lx\n",
 656                 debugstr_guid(riid), hr);
 657
 658         if (hr == S_OK)
 659             hr = IRpcProxyBuffer_Connect(ifproxy->proxy, ifproxy->chan);
 660     }
 661
 662     /* get at least one external reference to the object to keep it alive */
 663     if (hr == S_OK)
 664         hr = ifproxy_get_public_ref(ifproxy);
 665
 666     if (hr == S_OK)
 667     {
 668         EnterCriticalSection(&This->cs);
 669         list_add_tail(&This->interfaces, &ifproxy->entry);
 670         LeaveCriticalSection(&This->cs);
 671
 672         *iif_out = ifproxy;
 673         TRACE("ifproxy %p created for IPID %s, interface %s with %lu public refs\n",
 674               ifproxy, debugstr_guid(&stdobjref->ipid), debugstr_guid(riid), stdobjref->cPublicRefs);
 675     }
 676     else
 677         ifproxy_destroy(ifproxy);
 678
 679     return hr;
 680 }
 681
 682 static HRESULT proxy_manager_find_ifproxy(struct proxy_manager * This, REFIID riid, struct ifproxy ** ifproxy_found)
 683 {
 684     HRESULT hr = E_NOINTERFACE; /* assume not found */
 685     struct list * cursor;
 686
 687     EnterCriticalSection(&This->cs);
 688     LIST_FOR_EACH(cursor, &This->interfaces)
 689     {
 690         struct ifproxy * ifproxy = LIST_ENTRY(cursor, struct ifproxy, entry);
 691         if (IsEqualIID(riid, &ifproxy->iid))
 692         {
 693             *ifproxy_found = ifproxy;
 694             hr = S_OK;
 695             break;
 696         }
 697     }
 698     LeaveCriticalSection(&This->cs);
 699
 700     return hr;
 701 }
 702
 703 static void proxy_manager_disconnect(struct proxy_manager * This)
 704 {
 705     struct list * cursor;
 706
 707     TRACE("oxid = %s, oid = %s\n", wine_dbgstr_longlong(This->oxid),
 708         wine_dbgstr_longlong(This->oid));
 709
 710     EnterCriticalSection(&This->cs);
 711
 712     /* SORFP_NOLIFTIMEMGMT proxies (for IRemUnknown) shouldn't be
 713      * disconnected - it won't do anything anyway, except cause
 714      * problems for other objects that depend on this proxy always
 715      * working */
 716     if (!(This->sorflags & SORFP_NOLIFETIMEMGMT))
 717     {
 718         LIST_FOR_EACH(cursor, &This->interfaces)
 719         {
 720             struct ifproxy * ifproxy = LIST_ENTRY(cursor, struct ifproxy, entry);
 721             ifproxy_disconnect(ifproxy);
 722         }
 723     }
 724
 725     /* apartment is being destroyed so don't keep a pointer around to it */
 726     This->parent = NULL;
 727
 728     LeaveCriticalSection(&This->cs);
 729 }
 730
 731 static HRESULT proxy_manager_get_remunknown(struct proxy_manager * This, IRemUnknown **remunk)
 732 {
 733     HRESULT hr = S_OK;
 734
 735     /* we don't want to try and unmarshal or use IRemUnknown if we don't want
 736      * lifetime management */
 737     if (This->sorflags & SORFP_NOLIFETIMEMGMT)
 738         return S_FALSE;
 739
 740     EnterCriticalSection(&This->cs);
 741     if (This->remunk)
 742         /* already created - return existing object */
 743         *remunk = This->remunk;
 744     else if (!This->parent)
 745         /* disconnected - we can't create IRemUnknown */
 746         hr = S_FALSE;
 747     else
 748     {
 749         STDOBJREF stdobjref;
 750         /* Don't want IRemUnknown lifetime management as this is IRemUnknown!
 751          * We also don't care about whether or not the stub is still alive */
 752         stdobjref.flags = SORFP_NOLIFETIMEMGMT | SORF_NOPING;
 753         stdobjref.cPublicRefs = 1;
 754         /* oxid of destination object */
 755         stdobjref.oxid = This->oxid;
 756         /* FIXME: what should be used for the oid? The DCOM draft doesn't say */
 757         stdobjref.oid = (OID)-1;
 758         /* FIXME: this is a hack around not having an OXID resolver yet -
 759          * the OXID resolver should give us the IPID of the IRemUnknown
 760          * interface */
 761         stdobjref.ipid.Data1 = 0xffffffff;
 762         stdobjref.ipid.Data2 = 0xffff;
 763         stdobjref.ipid.Data3 = 0xffff;
 764         assert(sizeof(stdobjref.ipid.Data4) == sizeof(stdobjref.oxid));
 765         memcpy(&stdobjref.ipid.Data4, &stdobjref.oxid, sizeof(OXID));
 766
 767         /* do the unmarshal */
 768         hr = unmarshal_object(&stdobjref, This->parent, &IID_IRemUnknown, (void**)&This->remunk);
 769         if (hr == S_OK)
 770             *remunk = This->remunk;
 771     }
 772     LeaveCriticalSection(&This->cs);
 773
 774     TRACE("got IRemUnknown* pointer %p, hr = 0x%08lx\n", *remunk, hr);
 775
 776     return hr;
 777 }
 778
 779 /* destroys a proxy manager, freeing the memory it used.
 780  * Note: this function should not be called from a list iteration in the
 781  * apartment, due to the fact that it removes itself from the apartment and
 782  * it could add a proxy to IRemUnknown into the apartment. */
 783 static void proxy_manager_destroy(struct proxy_manager * This)
 784 {
 785     struct list * cursor;
 786
 787     TRACE("oxid = %s, oid = %s\n", wine_dbgstr_longlong(This->oxid),
 788         wine_dbgstr_longlong(This->oid));
 789
 790     if (This->parent)
 791     {
 792         EnterCriticalSection(&This->parent->cs);
 793
 794         /* remove ourself from the list of proxy objects in the apartment */
 795         LIST_FOR_EACH(cursor, &This->parent->proxies)
 796         {
 797             if (cursor == &This->entry)
 798             {
 799                 list_remove(&This->entry);
 800                 break;
 801             }
 802         }
 803
 804         LeaveCriticalSection(&This->parent->cs);
 805     }
 806
 807     /* destroy all of the interface proxies */
 808     while ((cursor = list_head(&This->interfaces)))
 809     {
 810         struct ifproxy * ifproxy = LIST_ENTRY(cursor, struct ifproxy, entry);
 811         ifproxy_destroy(ifproxy);
 812     }
 813
 814     if (This->remunk) IRemUnknown_Release(This->remunk);
 815
 816     DEBUG_CLEAR_CRITSEC_NAME(&This->cs);
 817     DeleteCriticalSection(&This->cs);
 818
 819     CloseHandle(This->remoting_mutex);
 820
 821     HeapFree(GetProcessHeap(), 0, This);
 822 }
 823
 824 /* finds the proxy manager corresponding to a given OXID and OID that has
 825  * been unmarshaled in the specified apartment. The caller must release the
 826  * reference to the proxy_manager when the object is no longer used. */
 827 static BOOL find_proxy_manager(APARTMENT * apt, OXID oxid, OID oid, struct proxy_manager ** proxy_found)
 828 {
 829     BOOL found = FALSE;
 830     struct list * cursor;
 831
 832     EnterCriticalSection(&apt->cs);
 833     LIST_FOR_EACH(cursor, &apt->proxies)
 834     {
 835         struct proxy_manager * proxy = LIST_ENTRY(cursor, struct proxy_manager, entry);
 836         if ((oxid == proxy->oxid) && (oid == proxy->oid))
 837         {
 838             *proxy_found = proxy;
 839             ClientIdentity_AddRef((IMultiQI *)&proxy->lpVtbl);
 840             found = TRUE;
 841             break;
 842         }
 843     }
 844     LeaveCriticalSection(&apt->cs);
 845     return found;
 846 }
 847
 848 HRESULT apartment_disconnectproxies(struct apartment *apt)
 849 {
 850     struct list * cursor;
 851
 852     LIST_FOR_EACH(cursor, &apt->proxies)
 853     {
 854         struct proxy_manager * proxy = LIST_ENTRY(cursor, struct proxy_manager, entry);
 855         proxy_manager_disconnect(proxy);
 856     }
 857
 858     return S_OK;
 859 }
 860
 861 /********************** StdMarshal implementation ****************************/
 862 typedef struct _StdMarshalImpl
 863 {
 864     const IMarshalVtbl  *lpvtbl;
 865     LONG                ref;
 866
 867     IID                 iid;
 868     DWORD               dwDestContext;
 869     LPVOID              pvDestContext;
 870     DWORD               mshlflags;
 871 } StdMarshalImpl;
 872
 873 static HRESULT WINAPI
 874 StdMarshalImpl_QueryInterface(LPMARSHAL iface, REFIID riid, LPVOID *ppv)
 875 {
 876     *ppv = NULL;
 877     if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IMarshal, riid))
 878     {
 879         *ppv = iface;
 880         IUnknown_AddRef(iface);
 881         return S_OK;
 882     }
 883     FIXME("No interface for %s.\n", debugstr_guid(riid));
 884     return E_NOINTERFACE;
 885 }
 886
 887 static ULONG WINAPI
 888 StdMarshalImpl_AddRef(LPMARSHAL iface)
 889 {
 890     StdMarshalImpl *This = (StdMarshalImpl *)iface;
 891     return InterlockedIncrement(&This->ref);
 892 }
 893
 894 static ULONG WINAPI
 895 StdMarshalImpl_Release(LPMARSHAL iface)
 896 {
 897     StdMarshalImpl *This = (StdMarshalImpl *)iface;
 898     ULONG ref = InterlockedDecrement(&This->ref);
 899
 900     if (!ref) HeapFree(GetProcessHeap(),0,This);
 901     return ref;
 902 }
 903
 904 static HRESULT WINAPI
 905 StdMarshalImpl_GetUnmarshalClass(
 906     LPMARSHAL iface, REFIID riid, void* pv, DWORD dwDestContext,
 907     void* pvDestContext, DWORD mshlflags, CLSID* pCid)
 908 {
 909     *pCid = CLSID_DfMarshal;
 910     return S_OK;
 911 }
 912
 913 static HRESULT WINAPI
 914 StdMarshalImpl_GetMarshalSizeMax(
 915     LPMARSHAL iface, REFIID riid, void* pv, DWORD dwDestContext,
 916     void* pvDestContext, DWORD mshlflags, DWORD* pSize)
 917 {
 918     *pSize = sizeof(STDOBJREF);
 919     return S_OK;
 920 }
 921
 922 static HRESULT WINAPI
 923 StdMarshalImpl_MarshalInterface(
 924     LPMARSHAL iface, IStream *pStm,REFIID riid, void* pv, DWORD dwDestContext,
 925     void* pvDestContext, DWORD mshlflags)
 926 {
 927     STDOBJREF             stdobjref;
 928     ULONG                 res;
 929     HRESULT               hres;
 930     APARTMENT            *apt = COM_CurrentApt();
 931
 932     TRACE("(...,%s,...)\n", debugstr_guid(riid));
 933
 934     if (!apt)
 935     {
 936         ERR("Apartment not initialized\n");
 937         return CO_E_NOTINITIALIZED;
 938     }
 939
 940     /* make sure this apartment can be reached from other threads / processes */
 941     RPC_StartRemoting(apt);
 942
 943     hres = marshal_object(apt, &stdobjref, riid, (IUnknown *)pv, mshlflags);
 944     if (hres)
 945     {
 946         ERR("Failed to create ifstub, hres=0x%lx\n", hres);
 947         return hres;
 948     }
 949
 950     hres = IStream_Write(pStm, &stdobjref, sizeof(stdobjref), &res);
 951     if (hres) return hres;
 952
 953     return S_OK;
 954 }
 955
 956 /* helper for StdMarshalImpl_UnmarshalInterface - does the unmarshaling with
 957  * no questions asked about the rules surrounding same-apartment unmarshals
 958  * and table marshaling */
 959 static HRESULT unmarshal_object(const STDOBJREF *stdobjref, APARTMENT *apt, REFIID riid, void **object)
 960 {
 961     struct proxy_manager *proxy_manager = NULL;
 962     HRESULT hr = S_OK;
 963
 964     assert(apt);
 965
 966     TRACE("stdobjref:\n\tflags = %04lx\n\tcPublicRefs = %ld\n\toxid = %s\n\toid = %s\n\tipid = %s\n",
 967         stdobjref->flags, stdobjref->cPublicRefs,
 968         wine_dbgstr_longlong(stdobjref->oxid),
 969         wine_dbgstr_longlong(stdobjref->oid),
 970         debugstr_guid(&stdobjref->ipid));
 971
 972     /* create an a new proxy manager if one doesn't already exist for the
 973      * object */
 974     if (!find_proxy_manager(apt, stdobjref->oxid, stdobjref->oid, &proxy_manager))
 975     {
 976         hr = proxy_manager_construct(apt, stdobjref->flags,
 977                                      stdobjref->oxid, stdobjref->oid,
 978                                      &proxy_manager);
 979     }
 980     else
 981         TRACE("proxy manager already created, using\n");
 982
 983     if (hr == S_OK)
 984     {
 985         struct ifproxy * ifproxy;
 986         hr = proxy_manager_find_ifproxy(proxy_manager, riid, &ifproxy);
 987         if (hr == E_NOINTERFACE)
 988         {
 989             IRpcChannelBuffer *chanbuf;
 990             hr = RPC_CreateClientChannel(&stdobjref->oxid, &stdobjref->ipid, &chanbuf);
 991             if (hr == S_OK)
 992                 hr = proxy_manager_create_ifproxy(proxy_manager, stdobjref,
 993                                                   riid, chanbuf, &ifproxy);
 994         }
 995         else
 996             IUnknown_AddRef((IUnknown *)ifproxy->iface);
 997
 998         if (hr == S_OK)
 999             *object = ifproxy->iface;
1000     }
1001
1002     /* release our reference to the proxy manager - the client/apartment
1003      * will hold on to the remaining reference for us */
1004     if (proxy_manager) ClientIdentity_Release((IMultiQI*)&proxy_manager->lpVtbl);
1005
1006     return hr;
1007 }
1008
1009 static HRESULT WINAPI
1010 StdMarshalImpl_UnmarshalInterface(LPMARSHAL iface, IStream *pStm, REFIID riid, void **ppv)
1011 {
1012     struct stub_manager  *stubmgr;
1013     STDOBJREF stdobjref;
1014     ULONG res;
1015     HRESULT hres;
1016     APARTMENT *apt = COM_CurrentApt();
1017     APARTMENT *stub_apt;
1018     OXID oxid;
1019
1020     TRACE("(...,%s,....)\n", debugstr_guid(riid));
1021
1022     /* we need an apartment to unmarshal into */
1023     if (!apt)
1024     {
1025         ERR("Apartment not initialized\n");
1026         return CO_E_NOTINITIALIZED;
1027     }
1028
1029     /* read STDOBJREF from wire */
1030     hres = IStream_Read(pStm, &stdobjref, sizeof(stdobjref), &res);
1031     if (hres) return STG_E_READFAULT;
1032
1033     hres = apartment_getoxid(apt, &oxid);
1034     if (hres) return hres;
1035
1036     /* check if we're marshalling back to ourselves */
1037     if ((oxid == stdobjref.oxid) && (stubmgr = get_stub_manager(apt, stdobjref.oid)))
1038     {
1039         TRACE("Unmarshalling object marshalled in same apartment for iid %s, "
1040               "returning original object %p\n", debugstr_guid(riid), stubmgr->object);
1041
1042         hres = IUnknown_QueryInterface(stubmgr->object, riid, ppv);
1043
1044         /* unref the ifstub. FIXME: only do this on success? */
1045         if (!stub_manager_is_table_marshaled(stubmgr, &stdobjref.ipid))
1046             stub_manager_ext_release(stubmgr, stdobjref.cPublicRefs);
1047
1048         stub_manager_int_release(stubmgr);
1049         return hres;
1050     }
1051
1052     /* notify stub manager about unmarshal if process-local object.
1053      * note: if the oxid is not found then we and native will quite happily
1054      * ignore table marshaling and normal marshaling rules regarding number of
1055      * unmarshals, etc, but if you abuse these rules then your proxy could end
1056      * up returning RPC_E_DISCONNECTED. */
1057     if ((stub_apt = apartment_findfromoxid(stdobjref.oxid, TRUE)))
1058     {
1059         if ((stubmgr = get_stub_manager(stub_apt, stdobjref.oid)))
1060         {
1061             if (!stub_manager_notify_unmarshal(stubmgr, &stdobjref.ipid))
1062                 hres = CO_E_OBJNOTCONNECTED;
1063
1064             stub_manager_int_release(stubmgr);
1065         }
1066         else
1067         {
1068             WARN("Couldn't find object for OXID %s, OID %s, assuming disconnected\n",
1069                 wine_dbgstr_longlong(stdobjref.oxid),
1070                 wine_dbgstr_longlong(stdobjref.oid));
1071             hres = CO_E_OBJNOTCONNECTED;
1072         }
1073
1074         apartment_release(stub_apt);
1075     }
1076     else
1077         TRACE("Treating unmarshal from OXID %s as inter-process\n",
1078             wine_dbgstr_longlong(stdobjref.oxid));
1079
1080     if (hres == S_OK)
1081         hres = unmarshal_object(&stdobjref, apt, riid, ppv);
1082
1083     if (hres) WARN("Failed with error 0x%08lx\n", hres);
1084     else TRACE("Successfully created proxy %p\n", *ppv);
1085
1086     return hres;
1087 }
1088
1089 static HRESULT WINAPI
1090 StdMarshalImpl_ReleaseMarshalData(LPMARSHAL iface, IStream *pStm)
1091 {
1092     STDOBJREF            stdobjref;
1093     ULONG                res;
1094     HRESULT              hres;
1095     struct stub_manager *stubmgr;
1096     APARTMENT           *apt;
1097
1098     TRACE("iface=%p, pStm=%p\n", iface, pStm);
1099
1100     hres = IStream_Read(pStm, &stdobjref, sizeof(stdobjref), &res);
1101     if (hres) return STG_E_READFAULT;
1102
1103     TRACE("oxid = %s, oid = %s, ipid = %s\n",
1104         wine_dbgstr_longlong(stdobjref.oxid),
1105         wine_dbgstr_longlong(stdobjref.oid),
1106         wine_dbgstr_guid(&stdobjref.ipid));
1107
1108     if (!(apt = apartment_findfromoxid(stdobjref.oxid, TRUE)))
1109     {
1110         WARN("Could not map OXID %s to apartment object\n",
1111             wine_dbgstr_longlong(stdobjref.oxid));
1112         return RPC_E_INVALID_OBJREF;
1113     }
1114
1115     if (!(stubmgr = get_stub_manager(apt, stdobjref.oid)))
1116     {
1117         ERR("could not map object ID to stub manager, oxid=%s, oid=%s\n",
1118             wine_dbgstr_longlong(stdobjref.oxid), wine_dbgstr_longlong(stdobjref.oid));
1119         return RPC_E_INVALID_OBJREF;
1120     }
1121
1122     stub_manager_release_marshal_data(stubmgr, stdobjref.cPublicRefs, &stdobjref.ipid);
1123
1124     stub_manager_int_release(stubmgr);
1125     apartment_release(apt);
1126
1127     return S_OK;
1128 }
1129
1130 static HRESULT WINAPI
1131 StdMarshalImpl_DisconnectObject(LPMARSHAL iface, DWORD dwReserved)
1132 {
1133     FIXME("(), stub!\n");
1134     return S_OK;
1135 }
1136
1137 static const IMarshalVtbl VT_StdMarshal =
1138 {
1139     StdMarshalImpl_QueryInterface,
1140     StdMarshalImpl_AddRef,
1141     StdMarshalImpl_Release,
1142     StdMarshalImpl_GetUnmarshalClass,
1143     StdMarshalImpl_GetMarshalSizeMax,
1144     StdMarshalImpl_MarshalInterface,
1145     StdMarshalImpl_UnmarshalInterface,
1146     StdMarshalImpl_ReleaseMarshalData,
1147     StdMarshalImpl_DisconnectObject
1148 };
1149
1150 static HRESULT StdMarshalImpl_Construct(REFIID riid, void** ppvObject)
1151 {
1152     StdMarshalImpl * pStdMarshal =
1153         HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(StdMarshalImpl));
1154     if (!pStdMarshal)
1155         return E_OUTOFMEMORY;
1156     pStdMarshal->lpvtbl = &VT_StdMarshal;
1157     pStdMarshal->ref = 0;
1158     return IMarshal_QueryInterface((IMarshal*)pStdMarshal, riid, ppvObject);
1159 }
1160
1161 /***********************************************************************
1162  *              CoGetStandardMarshal    [OLE32.@]
1163  *
1164  * Gets or creates a standard marshal object.
1165  *
1166  * PARAMS
1167  *  riid          [I] Interface identifier of the pUnk object.
1168  *  pUnk          [I] Optional. Object to get the marshal object for.
1169  *  dwDestContext [I] Destination. Used to enable or disable optimizations.
1170  *  pvDestContext [I] Reserved. Must be NULL.
1171  *  mshlflags     [I] Flags affecting the marshaling process.
1172  *  ppMarshal     [O] Address where marshal object will be stored.
1173  *
1174  * RETURNS
1175  *  Success: S_OK.
1176  *  Failure: HRESULT code.
1177  *
1178  * NOTES
1179  *
1180  * The function retrieves the IMarshal object associated with an object if
1181  * that object is currently an active stub, otherwise a new marshal object is
1182  * created.
1183  */
1184 HRESULT WINAPI CoGetStandardMarshal(REFIID riid, IUnknown *pUnk,
1185                                     DWORD dwDestContext, LPVOID pvDestContext,
1186                                     DWORD mshlflags, LPMARSHAL *ppMarshal)
1187 {
1188     StdMarshalImpl *dm;
1189
1190     if (pUnk == NULL)
1191     {
1192         FIXME("(%s,NULL,%lx,%p,%lx,%p), unimplemented yet.\n",
1193             debugstr_guid(riid),dwDestContext,pvDestContext,mshlflags,ppMarshal);
1194         return E_NOTIMPL;
1195     }
1196     TRACE("(%s,%p,%lx,%p,%lx,%p)\n",
1197         debugstr_guid(riid),pUnk,dwDestContext,pvDestContext,mshlflags,ppMarshal);
1198     *ppMarshal = HeapAlloc(GetProcessHeap(),0,sizeof(StdMarshalImpl));
1199     dm = (StdMarshalImpl*) *ppMarshal;
1200     if (!dm) return E_FAIL;
1201     dm->lpvtbl          = &VT_StdMarshal;
1202     dm->ref             = 1;
1203
1204     dm->iid             = *riid;
1205     dm->dwDestContext   = dwDestContext;
1206     dm->pvDestContext   = pvDestContext;
1207     dm->mshlflags       = mshlflags;
1208     return S_OK;
1209 }
1210
1211 /***********************************************************************
1212  *              get_marshaler   [internal]
1213  *
1214  * Retrieves an IMarshal interface for an object.
1215  */
1216 static HRESULT get_marshaler(REFIID riid, IUnknown *pUnk, DWORD dwDestContext,
1217                              void *pvDestContext, DWORD mshlFlags,
1218                              LPMARSHAL *pMarshal)
1219 {
1220     HRESULT hr;
1221
1222     if (!pUnk)
1223         return E_POINTER;
1224     hr = IUnknown_QueryInterface(pUnk, &IID_IMarshal, (LPVOID*)pMarshal);
1225     if (hr)
1226         hr = CoGetStandardMarshal(riid, pUnk, dwDestContext, pvDestContext,
1227                                   mshlFlags, pMarshal);
1228     return hr;
1229 }
1230
1231 /***********************************************************************
1232  *              get_unmarshaler_from_stream     [internal]
1233  *
1234  * Creates an IMarshal* object according to the data marshaled to the stream.
1235  * The function leaves the stream pointer at the start of the data written
1236  * to the stream by the IMarshal* object.
1237  */
1238 static HRESULT get_unmarshaler_from_stream(IStream *stream, IMarshal **marshal, IID *iid)
1239 {
1240     HRESULT hr;
1241     ULONG res;
1242     OBJREF objref;
1243
1244     /* read common OBJREF header */
1245     hr = IStream_Read(stream, &objref, FIELD_OFFSET(OBJREF, u_objref), &res);
1246     if (hr || (res != FIELD_OFFSET(OBJREF, u_objref)))
1247     {
1248         ERR("Failed to read common OBJREF header, 0x%08lx\n", hr);
1249         return STG_E_READFAULT;
1250     }
1251
1252     /* sanity check on header */
1253     if (objref.signature != OBJREF_SIGNATURE)
1254     {
1255         ERR("Bad OBJREF signature 0x%08lx\n", objref.signature);
1256         return RPC_E_INVALID_OBJREF;
1257     }
1258
1259     if (iid) *iid = objref.iid;
1260
1261     /* FIXME: handler marshaling */
1262     if (objref.flags & OBJREF_STANDARD)
1263     {
1264         TRACE("Using standard unmarshaling\n");
1265         hr = StdMarshalImpl_Construct(&IID_IMarshal, (LPVOID*)marshal);
1266     }
1267     else if (objref.flags & OBJREF_CUSTOM)
1268     {
1269         ULONG custom_header_size = FIELD_OFFSET(OBJREF, u_objref.u_custom.pData) -
1270                                    FIELD_OFFSET(OBJREF, u_objref.u_custom);
1271         TRACE("Using custom unmarshaling\n");
1272         /* read constant sized OR_CUSTOM data from stream */
1273         hr = IStream_Read(stream, &objref.u_objref.u_custom,
1274                           custom_header_size, &res);
1275         if (hr || (res != custom_header_size))
1276         {
1277             ERR("Failed to read OR_CUSTOM header, 0x%08lx\n", hr);
1278             return STG_E_READFAULT;
1279         }
1280         /* now create the marshaler specified in the stream */
1281         hr = CoCreateInstance(&objref.u_objref.u_custom.clsid, NULL,
1282                               CLSCTX_INPROC_SERVER, &IID_IMarshal,
1283                               (LPVOID*)marshal);
1284     }
1285     else
1286     {
1287         FIXME("Invalid or unimplemented marshaling type specified: %lx\n",
1288             objref.flags);
1289         return RPC_E_INVALID_OBJREF;
1290     }
1291
1292     if (hr)
1293         ERR("Failed to create marshal, 0x%08lx\n", hr);
1294
1295     return hr;
1296 }
1297
1298 /***********************************************************************
1299  *              CoGetMarshalSizeMax     [OLE32.@]
1300  *
1301  * Gets the maximum amount of data that will be needed by a marshal.
1302  *
1303  * PARAMS
1304  *  pulSize       [O] Address where maximum marshal size will be stored.
1305  *  riid          [I] Identifier of the interface to marshal.
1306  *  pUnk          [I] Pointer to the object to marshal.
1307  *  dwDestContext [I] Destination. Used to enable or disable optimizations.
1308  *  pvDestContext [I] Reserved. Must be NULL.
1309  *  mshlFlags     [I] Flags that affect the marshaling. See CoMarshalInterface().
1310  *
1311  * RETURNS
1312  *  Success: S_OK.
1313  *  Failure: HRESULT code.
1314  *
1315  * SEE ALSO
1316  *  CoMarshalInterface().
1317  */
1318 HRESULT WINAPI CoGetMarshalSizeMax(ULONG *pulSize, REFIID riid, IUnknown *pUnk,
1319                                    DWORD dwDestContext, void *pvDestContext,
1320                                    DWORD mshlFlags)
1321 {
1322     HRESULT hr;
1323     LPMARSHAL pMarshal;
1324     CLSID marshaler_clsid;
1325
1326     hr = get_marshaler(riid, pUnk, dwDestContext, pvDestContext, mshlFlags, &pMarshal);
1327     if (hr)
1328         return hr;
1329
1330     hr = IMarshal_GetUnmarshalClass(pMarshal, riid, pUnk, dwDestContext,
1331                                     pvDestContext, mshlFlags, &marshaler_clsid);
1332     if (hr)
1333     {
1334         ERR("IMarshal::GetUnmarshalClass failed, 0x%08lx\n", hr);
1335         IMarshal_Release(pMarshal);
1336         return hr;
1337     }
1338
1339     hr = IMarshal_GetMarshalSizeMax(pMarshal, riid, pUnk, dwDestContext,
1340                                     pvDestContext, mshlFlags, pulSize);
1341     /* add on the size of the common header */
1342     *pulSize += FIELD_OFFSET(OBJREF, u_objref);
1343
1344     /* if custom marshaling, add on size of custom header */
1345     if (!IsEqualCLSID(&marshaler_clsid, &CLSID_DfMarshal))
1346         *pulSize += FIELD_OFFSET(OBJREF, u_objref.u_custom.pData) -
1347                     FIELD_OFFSET(OBJREF, u_objref.u_custom);
1348
1349     IMarshal_Release(pMarshal);
1350     return hr;
1351 }
1352
1353
1354 static void dump_MSHLFLAGS(MSHLFLAGS flags)
1355 {
1356     if (flags & MSHLFLAGS_TABLESTRONG)
1357         TRACE(" MSHLFLAGS_TABLESTRONG");
1358     if (flags & MSHLFLAGS_TABLEWEAK)
1359         TRACE(" MSHLFLAGS_TABLEWEAK");
1360     if (!(flags & (MSHLFLAGS_TABLESTRONG|MSHLFLAGS_TABLEWEAK)))
1361         TRACE(" MSHLFLAGS_NORMAL");
1362     if (flags & MSHLFLAGS_NOPING)
1363         TRACE(" MSHLFLAGS_NOPING");
1364 }
1365
1366 /***********************************************************************
1367  *              CoMarshalInterface      [OLE32.@]
1368  *
1369  * Marshals an interface into a stream so that the object can then be
1370  * unmarshaled from another COM apartment and used remotely.
1371  *
1372  * PARAMS
1373  *  pStream       [I] Stream the object will be marshaled into.
1374  *  riid          [I] Identifier of the interface to marshal.
1375  *  pUnk          [I] Pointer to the object to marshal.
1376  *  dwDestContext [I] Destination. Used to enable or disable optimizations.
1377  *  pvDestContext [I] Reserved. Must be NULL.
1378  *  mshlFlags     [I] Flags that affect the marshaling. See notes.
1379  *
1380  * RETURNS
1381  *  Success: S_OK.
1382  *  Failure: HRESULT code.
1383  *
1384  * NOTES
1385  *
1386  * The mshlFlags parameter can take one or more of the following flags:
1387  *| MSHLFLAGS_NORMAL - Unmarshal once, releases stub on last proxy release.
1388  *| MSHLFLAGS_TABLESTRONG - Unmarshal many, release when CoReleaseMarshalData() called.
1389  *| MSHLFLAGS_TABLEWEAK - Unmarshal many, releases stub on last proxy release.
1390  *| MSHLFLAGS_NOPING - No automatic garbage collection (and so reduces network traffic).
1391  *
1392  * If a marshaled object is not unmarshaled, then CoReleaseMarshalData() must
1393  * be called in order to release the resources used in the marshaling.
1394  *
1395  * SEE ALSO
1396  *  CoUnmarshalInterface(), CoReleaseMarshalData().
1397  */
1398 HRESULT WINAPI CoMarshalInterface(IStream *pStream, REFIID riid, IUnknown *pUnk,
1399                                   DWORD dwDestContext, void *pvDestContext,
1400                                   DWORD mshlFlags)
1401 {
1402     HRESULT     hr;
1403     CLSID marshaler_clsid;
1404     OBJREF objref;
1405     LPMARSHAL pMarshal;
1406
1407     TRACE("(%p, %s, %p, %lx, %p,", pStream, debugstr_guid(riid), pUnk,
1408         dwDestContext, pvDestContext);
1409     dump_MSHLFLAGS(mshlFlags);
1410     TRACE(")\n");
1411
1412     if (pUnk == NULL)
1413         return E_INVALIDARG;
1414
1415     objref.signature = OBJREF_SIGNATURE;
1416     objref.iid = *riid;
1417
1418     /* get the marshaler for the specified interface */
1419     hr = get_marshaler(riid, pUnk, dwDestContext, pvDestContext, mshlFlags, &pMarshal);
1420     if (hr)
1421     {
1422         ERR("Failed to get marshaller, 0x%08lx\n", hr);
1423         return hr;
1424     }
1425
1426     hr = IMarshal_GetUnmarshalClass(pMarshal, riid, pUnk, dwDestContext,
1427                                     pvDestContext, mshlFlags, &marshaler_clsid);
1428     if (hr)
1429     {
1430         ERR("IMarshal::GetUnmarshalClass failed, 0x%08lx\n", hr);
1431         goto cleanup;
1432     }
1433
1434     /* FIXME: implement handler marshaling too */
1435     if (IsEqualCLSID(&marshaler_clsid, &CLSID_DfMarshal))
1436     {
1437         TRACE("Using standard marshaling\n");
1438         objref.flags = OBJREF_STANDARD;
1439
1440         /* write the common OBJREF header to the stream */
1441         hr = IStream_Write(pStream, &objref, FIELD_OFFSET(OBJREF, u_objref), NULL);
1442         if (hr)
1443         {
1444             ERR("Failed to write OBJREF header to stream, 0x%08lx\n", hr);
1445             goto cleanup;
1446         }
1447     }
1448     else
1449     {
1450         TRACE("Using custom marshaling\n");
1451         objref.flags = OBJREF_CUSTOM;
1452         objref.u_objref.u_custom.clsid = marshaler_clsid;
1453         objref.u_objref.u_custom.cbExtension = 0;
1454         objref.u_objref.u_custom.size = 0;
1455         hr = IMarshal_GetMarshalSizeMax(pMarshal, riid, pUnk, dwDestContext,
1456                                         pvDestContext, mshlFlags,
1457                                         &objref.u_objref.u_custom.size);
1458         if (hr)
1459         {
1460             ERR("Failed to get max size of marshal data, error 0x%08lx\n", hr);
1461             goto cleanup;
1462         }
1463         /* write constant sized common header and OR_CUSTOM data into stream */
1464         hr = IStream_Write(pStream, &objref,
1465                           FIELD_OFFSET(OBJREF, u_objref.u_custom.pData), NULL);
1466         if (hr)
1467         {
1468             ERR("Failed to write OR_CUSTOM header to stream with 0x%08lx\n", hr);
1469             goto cleanup;
1470         }
1471     }
1472
1473     TRACE("Calling IMarshal::MarshalInterace\n");
1474     /* call helper object to do the actual marshaling */
1475     hr = IMarshal_MarshalInterface(pMarshal, pStream, riid, pUnk, dwDestContext,
1476                                    pvDestContext, mshlFlags);
1477
1478     if (hr)
1479     {
1480         ERR("Failed to marshal the interface %s, %lx\n", debugstr_guid(riid), hr);
1481         goto cleanup;
1482     }
1483
1484 cleanup:
1485     IMarshal_Release(pMarshal);
1486
1487     TRACE("completed with hr 0x%08lx\n", hr);
1488
1489     return hr;
1490 }
1491
1492 /***********************************************************************
1493  *              CoUnmarshalInterface    [OLE32.@]
1494  *
1495  * Unmarshals an object from a stream by creating a proxy to the remote
1496  * object, if necessary.
1497  *
1498  * PARAMS
1499  *
1500  *  pStream [I] Stream containing the marshaled object.
1501  *  riid    [I] Interface identifier of the object to create a proxy to.
1502  *  ppv     [O] Address where proxy will be stored.
1503  *
1504  * RETURNS
1505  *
1506  *  Success: S_OK.
1507  *  Failure: HRESULT code.
1508  *
1509  * SEE ALSO
1510  *  CoMarshalInterface().
1511  */
1512 HRESULT WINAPI CoUnmarshalInterface(IStream *pStream, REFIID riid, LPVOID *ppv)
1513 {
1514     HRESULT hr;
1515     LPMARSHAL pMarshal;
1516     IID iid;
1517     IUnknown *object;
1518
1519     TRACE("(%p, %s, %p)\n", pStream, debugstr_guid(riid), ppv);
1520
1521     hr = get_unmarshaler_from_stream(pStream, &pMarshal, &iid);
1522     if (hr != S_OK)
1523         return hr;
1524
1525     /* call the helper object to do the actual unmarshaling */
1526     hr = IMarshal_UnmarshalInterface(pMarshal, pStream, &iid, (LPVOID*)&object);
1527     if (hr)
1528         ERR("IMarshal::UnmarshalInterface failed, 0x%08lx\n", hr);
1529
1530     /* IID_NULL means use the interface ID of the marshaled object */
1531     if (!IsEqualIID(riid, &IID_NULL))
1532         iid = *riid;
1533
1534     if (hr == S_OK)
1535     {
1536         if (!IsEqualIID(riid, &iid))
1537         {
1538             TRACE("requested interface != marshalled interface, additional QI needed\n");
1539             hr = IUnknown_QueryInterface(object, &iid, ppv);
1540             if (hr)
1541                 ERR("Couldn't query for interface %s, hr = 0x%08lx\n",
1542                     debugstr_guid(riid), hr);
1543             IUnknown_Release(object);
1544         }
1545         else
1546         {
1547             *ppv = object;
1548         }
1549     }
1550
1551     IMarshal_Release(pMarshal);
1552
1553     TRACE("completed with hr 0x%lx\n", hr);
1554
1555     return hr;
1556 }
1557
1558 /***********************************************************************
1559  *              CoReleaseMarshalData    [OLE32.@]
1560  *
1561  * Releases resources associated with an object that has been marshaled into
1562  * a stream.
1563  *
1564  * PARAMS
1565  *
1566  *  pStream [I] The stream that the object has been marshaled into.
1567  *
1568  * RETURNS
1569  *  Success: S_OK.
1570  *  Failure: HRESULT error code.
1571  *
1572  * NOTES
1573  *
1574  * Call this function to release resources associated with a normal or
1575  * table-weak marshal that will not be unmarshaled, and all table-strong
1576  * marshals when they are no longer needed.
1577  *
1578  * SEE ALSO
1579  *  CoMarshalInterface(), CoUnmarshalInterface().
1580  */
1581 HRESULT WINAPI CoReleaseMarshalData(IStream *pStream)
1582 {
1583     HRESULT     hr;
1584     LPMARSHAL pMarshal;
1585
1586     TRACE("(%p)\n", pStream);
1587
1588     hr = get_unmarshaler_from_stream(pStream, &pMarshal, NULL);
1589     if (hr != S_OK)
1590         return hr;
1591
1592     /* call the helper object to do the releasing of marshal data */
1593     hr = IMarshal_ReleaseMarshalData(pMarshal, pStream);
1594     if (hr)
1595         ERR("IMarshal::ReleaseMarshalData failed with error 0x%08lx\n", hr);
1596
1597     IMarshal_Release(pMarshal);
1598     return hr;
1599 }
1600
1601
1602 /***********************************************************************
1603  *              CoMarshalInterThreadInterfaceInStream   [OLE32.@]
1604  *
1605  * Marshal an interface across threads in the same process.
1606  *
1607  * PARAMS
1608  *  riid  [I] Identifier of the interface to be marshalled.
1609  *  pUnk  [I] Pointer to IUnknown-derived interface that will be marshalled.
1610  *  ppStm [O] Pointer to IStream object that is created and then used to store the marshalled inteface.
1611  *
1612  * RETURNS
1613  *  Success: S_OK
1614  *  Failure: E_OUTOFMEMORY and other COM error codes
1615  *
1616  * SEE ALSO
1617  *   CoMarshalInterface(), CoUnmarshalInterface() and CoGetInterfaceAndReleaseStream()
1618  */
1619 HRESULT WINAPI CoMarshalInterThreadInterfaceInStream(
1620     REFIID riid, LPUNKNOWN pUnk, LPSTREAM * ppStm)
1621 {
1622     ULARGE_INTEGER      xpos;
1623     LARGE_INTEGER               seekto;
1624     HRESULT             hres;
1625
1626     TRACE("(%s, %p, %p)\n",debugstr_guid(riid), pUnk, ppStm);
1627
1628     hres = CreateStreamOnHGlobal(NULL, TRUE, ppStm);
1629     if (FAILED(hres)) return hres;
1630     hres = CoMarshalInterface(*ppStm, riid, pUnk, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
1631
1632     if (SUCCEEDED(hres))
1633     {
1634         memset(&seekto, 0, sizeof(seekto));
1635         IStream_Seek(*ppStm, seekto, SEEK_SET, &xpos);
1636     }
1637     else
1638     {
1639         IStream_Release(*ppStm);
1640         *ppStm = NULL;
1641     }
1642
1643     return hres;
1644 }
1645
1646 /***********************************************************************
1647  *              CoGetInterfaceAndReleaseStream  [OLE32.@]
1648  *
1649  * Unmarshalls an inteface from a stream and then releases the stream.
1650  *
1651  * PARAMS
1652  *  pStm [I] Stream that contains the marshalled inteface.
1653  *  riid [I] Interface identifier of the object to unmarshall.
1654  *  ppv  [O] Address of pointer where the requested interface object will be stored.
1655  *
1656  * RETURNS
1657  *  Success: S_OK
1658  *  Failure: A COM error code
1659  *
1660  * SEE ALSO
1661  *  CoMarshalInterThreadInterfaceInStream() and CoUnmarshalInteface()
1662  */
1663 HRESULT WINAPI CoGetInterfaceAndReleaseStream(LPSTREAM pStm, REFIID riid,
1664                                               LPVOID *ppv)
1665 {
1666     HRESULT hres;
1667
1668     TRACE("(%p, %s, %p)\n", pStm, debugstr_guid(riid), ppv);
1669
1670     hres = CoUnmarshalInterface(pStm, riid, ppv);
1671     IStream_Release(pStm);
1672     return hres;
1673 }
1674
1675 static HRESULT WINAPI StdMarshalCF_QueryInterface(LPCLASSFACTORY iface,
1676                                                   REFIID riid, LPVOID *ppv)
1677 {
1678     *ppv = NULL;
1679     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IClassFactory))
1680     {
1681         *ppv = (LPVOID)iface;
1682         return S_OK;
1683     }
1684     return E_NOINTERFACE;
1685 }
1686
1687 static ULONG WINAPI StdMarshalCF_AddRef(LPCLASSFACTORY iface)
1688 {
1689     return 2; /* non-heap based object */
1690 }
1691
1692 static ULONG WINAPI StdMarshalCF_Release(LPCLASSFACTORY iface)
1693 {
1694     return 1; /* non-heap based object */
1695 }
1696
1697 static HRESULT WINAPI StdMarshalCF_CreateInstance(LPCLASSFACTORY iface,
1698     LPUNKNOWN pUnk, REFIID riid, LPVOID *ppv)
1699 {
1700     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IMarshal))
1701         return StdMarshalImpl_Construct(riid, ppv);
1702
1703     FIXME("(%s), not supported.\n",debugstr_guid(riid));
1704     return E_NOINTERFACE;
1705 }
1706
1707 static HRESULT WINAPI StdMarshalCF_LockServer(LPCLASSFACTORY iface, BOOL fLock)
1708 {
1709     FIXME("(%d), stub!\n",fLock);
1710     return S_OK;
1711 }
1712
1713 static const IClassFactoryVtbl StdMarshalCFVtbl =
1714 {
1715     StdMarshalCF_QueryInterface,
1716     StdMarshalCF_AddRef,
1717     StdMarshalCF_Release,
1718     StdMarshalCF_CreateInstance,
1719     StdMarshalCF_LockServer
1720 };
1721 static const IClassFactoryVtbl *StdMarshalCF = &StdMarshalCFVtbl;
1722
1723 HRESULT MARSHAL_GetStandardMarshalCF(LPVOID *ppv)
1724 {
1725     *ppv = &StdMarshalCF;
1726     return S_OK;
1727 }
1728
1729 /***********************************************************************
1730  *              CoMarshalHresult        [OLE32.@]
1731  *
1732  * Marshals an HRESULT value into a stream.
1733  *
1734  * PARAMS
1735  *  pStm    [I] Stream that hresult will be marshalled into.
1736  *  hresult [I] HRESULT to be marshalled.
1737  *
1738  * RETURNS
1739  *  Success: S_OK
1740  *  Failure: A COM error code
1741  *
1742  * SEE ALSO
1743  *  CoUnmarshalHresult().
1744  */
1745 HRESULT WINAPI CoMarshalHresult(LPSTREAM pStm, HRESULT hresult)
1746 {
1747     return IStream_Write(pStm, &hresult, sizeof(hresult), NULL);
1748 }
1749
1750 /***********************************************************************
1751  *              CoUnmarshalHresult      [OLE32.@]
1752  *
1753  * Unmarshals an HRESULT value from a stream.
1754  *
1755  * PARAMS
1756  *  pStm     [I] Stream that hresult will be unmarshalled from.
1757  *  phresult [I] Pointer to HRESULT where the value will be unmarshalled to.
1758  *
1759  * RETURNS
1760  *  Success: S_OK
1761  *  Failure: A COM error code
1762  *
1763  * SEE ALSO
1764  *  CoMarshalHresult().
1765  */
1766 HRESULT WINAPI CoUnmarshalHresult(LPSTREAM pStm, HRESULT * phresult)
1767 {
1768     return IStream_Read(pStm, phresult, sizeof(*phresult), NULL);
1769 }