marshal.c 63.3 KB
Newer Older
1
/*
2
 *	Marshalling library
3
 *
4 5 6
 * Copyright 2002 Marcus Meissner
 * Copyright 2004 Mike Hearn, for CodeWeavers
 * Copyright 2004 Rob Shearman, for CodeWeavers
7 8 9 10 11 12 13 14 15 16 17 18 19
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 22
 */

23
#include <stdarg.h>
24 25 26
#include <string.h>
#include <assert.h>

27 28
#define COBJMACROS

29
#include "windef.h"
30
#include "winbase.h"
31
#include "winuser.h"
32 33 34 35
#include "objbase.h"
#include "ole2.h"
#include "winerror.h"
#include "wine/unicode.h"
36

37 38
#include "compobj_private.h"

39
#include "wine/debug.h"
40

41
WINE_DEFAULT_DEBUG_CHANNEL(ole);
42

43 44
extern const CLSID CLSID_DfMarshal;

45
/* number of refs given out for normal marshaling */
46
#define NORMALEXTREFS 5
47

48 49 50 51
/* private flag indicating that the caller does not want to notify the stub
 * when the proxy disconnects or is destroyed */
#define SORFP_NOLIFETIMEMGMT SORF_OXRES1

52 53
static HRESULT unmarshal_object(const STDOBJREF *stdobjref, APARTMENT *apt,
                                MSHCTX dest_context, void *dest_context_data,
54 55
                                REFIID riid, const OXID_INFO *oxid_info,
                                void **object);
56

57
/* Marshalling just passes a unique identifier to the remote client,
58 59 60 61 62
 * that makes it possible to find the passed interface again.
 *
 * So basically we need a set of values that make it unique.
 *
 * Note that the IUnknown_QI(ob,xiid,&ppv) always returns the SAME ppv value!
63
 *
64 65
 * A triple is used: OXID (apt id), OID (stub manager id),
 * IPID (interface ptr/stub id).
66 67 68 69
 *
 * OXIDs identify an apartment and are network scoped
 * OIDs identify a stub manager and are apartment scoped
 * IPIDs identify an interface stub and are apartment scoped
70 71
 */

72
static inline HRESULT get_facbuf_for_iid(REFIID riid, IPSFactoryBuffer **facbuf)
73 74 75
{
    HRESULT       hr;
    CLSID         clsid;
76

77 78 79 80
    if ((hr = CoGetPSClsid(riid, &clsid)))
        return hr;
    return CoGetClassObject(&clsid, CLSCTX_INPROC_SERVER, NULL,
        &IID_IPSFactoryBuffer, (LPVOID*)facbuf);
81 82
}

83
/* marshals an object into a STDOBJREF structure */
84
HRESULT marshal_object(APARTMENT *apt, STDOBJREF *stdobjref, REFIID riid, IUnknown *object, MSHLFLAGS mshlflags)
85
{
86
    struct stub_manager *manager;
87
    struct ifstub       *ifstub;
88
    BOOL                 tablemarshal;
89
    IRpcStubBuffer      *stub = NULL;
90
    HRESULT              hr;
91
    IUnknown            *iobject = NULL; /* object of type riid */
92

93 94 95 96
    hr = apartment_getoxid(apt, &stdobjref->oxid);
    if (hr != S_OK)
        return hr;

97 98 99 100
    hr = apartment_createwindowifneeded(apt);
    if (hr != S_OK)
        return hr;

101 102 103
    hr = IUnknown_QueryInterface(object, riid, (void **)&iobject);
    if (hr != S_OK)
    {
104
        ERR("object doesn't expose interface %s, failing with error 0x%08x\n",
105 106 107 108
            debugstr_guid(riid), hr);
        return E_NOINTERFACE;
    }
  
109 110 111
    /* IUnknown doesn't require a stub buffer, because it never goes out on
     * the wire */
    if (!IsEqualIID(riid, &IID_IUnknown))
112
    {
113
        IPSFactoryBuffer *psfb;
114

115 116 117 118
        hr = get_facbuf_for_iid(riid, &psfb);
        if (hr != S_OK)
        {
            ERR("couldn't get IPSFactory buffer for interface %s\n", debugstr_guid(riid));
119
            IUnknown_Release(iobject);
120 121 122
            return hr;
        }
    
123
        hr = IPSFactoryBuffer_CreateStub(psfb, riid, iobject, &stub);
124 125 126
        IPSFactoryBuffer_Release(psfb);
        if (hr != S_OK)
        {
127 128
            ERR("Failed to create an IRpcStubBuffer from IPSFactory for %s with error 0x%08x\n",
                debugstr_guid(riid), hr);
129
            IUnknown_Release(iobject);
130 131
            return hr;
        }
132 133 134 135 136 137 138
    }

    if (mshlflags & MSHLFLAGS_NOPING)
        stdobjref->flags = SORF_NOPING;
    else
        stdobjref->flags = SORF_NULL;

139
    if ((manager = get_stub_manager_from_object(apt, object)))
140 141 142
        TRACE("registering new ifstub on pre-existing manager\n");
    else
    {
143 144
        TRACE("constructing new stub manager\n");

145
        manager = new_stub_manager(apt, object);
146
        if (!manager)
147
        {
148
            if (stub) IRpcStubBuffer_Release(stub);
149
            IUnknown_Release(iobject);
150
            return E_OUTOFMEMORY;
151
        }
152
    }
153
    stdobjref->oid = manager->oid;
154

155 156
    tablemarshal = ((mshlflags & MSHLFLAGS_TABLESTRONG) || (mshlflags & MSHLFLAGS_TABLEWEAK));

157 158
    /* make sure ifstub that we are creating is unique */
    ifstub = stub_manager_find_ifstub(manager, riid, mshlflags);
159
    if (!ifstub)
160
        ifstub = stub_manager_new_ifstub(manager, stub, iobject, riid, mshlflags);
161 162 163 164 165 166 167 168 169 170 171

    if (stub) IRpcStubBuffer_Release(stub);
    IUnknown_Release(iobject);

    if (!ifstub)
    {
        stub_manager_int_release(manager);
        /* destroy the stub manager if it has no ifstubs by releasing
         * zero external references */
        stub_manager_ext_release(manager, 0, TRUE);
        return E_OUTOFMEMORY;
172 173
    }

174
    if (!tablemarshal)
175 176 177 178 179 180 181 182 183 184
    {
        stdobjref->cPublicRefs = NORMALEXTREFS;
        stub_manager_ext_addref(manager, stdobjref->cPublicRefs);
    }
    else
    {
        stdobjref->cPublicRefs = 0;
        if (mshlflags & MSHLFLAGS_TABLESTRONG)
            stub_manager_ext_addref(manager, 1);
    }
185

186 187 188
    /* FIXME: check return value */
    RPC_RegisterInterface(riid);

189
    stdobjref->ipid = ifstub->ipid;
190 191

    stub_manager_int_release(manager);
192
    return S_OK;
193 194
}

195 196


197 198
/* Client-side identity of the server object */

199
static HRESULT proxy_manager_get_remunknown(struct proxy_manager * This, IRemUnknown **remunk);
200 201
static void proxy_manager_destroy(struct proxy_manager * This);
static HRESULT proxy_manager_find_ifproxy(struct proxy_manager * This, REFIID riid, struct ifproxy ** ifproxy_found);
202
static HRESULT proxy_manager_query_local_interface(struct proxy_manager * This, REFIID riid, void ** ppv);
203

204
static HRESULT WINAPI ClientIdentity_QueryInterface(IMultiQI * iface, REFIID riid, void ** ppv)
205 206
{
    HRESULT hr;
207
    MULTI_QI mqi;
208 209 210

    TRACE("%s\n", debugstr_guid(riid));

211 212 213
    mqi.pIID = riid;
    hr = IMultiQI_QueryMultipleInterfaces(iface, 1, &mqi);
    *ppv = (void *)mqi.pItf;
214

215
    return hr;
216 217
}

218
static ULONG WINAPI ClientIdentity_AddRef(IMultiQI * iface)
219 220
{
    struct proxy_manager * This = (struct proxy_manager *)iface;
221
    TRACE("%p - before %d\n", iface, This->refs);
222 223 224
    return InterlockedIncrement(&This->refs);
}

225
static ULONG WINAPI ClientIdentity_Release(IMultiQI * iface)
226 227 228
{
    struct proxy_manager * This = (struct proxy_manager *)iface;
    ULONG refs = InterlockedDecrement(&This->refs);
229
    TRACE("%p - after %d\n", iface, refs);
230 231 232 233 234
    if (!refs)
        proxy_manager_destroy(This);
    return refs;
}

235
static HRESULT WINAPI ClientIdentity_QueryMultipleInterfaces(IMultiQI *iface, ULONG cMQIs, MULTI_QI *pMQIs)
236
{
237 238 239 240 241 242 243 244 245
    struct proxy_manager * This = (struct proxy_manager *)iface;
    REMQIRESULT *qiresults = NULL;
    ULONG nonlocal_mqis = 0;
    ULONG i;
    ULONG successful_mqis = 0;
    IID *iids = HeapAlloc(GetProcessHeap(), 0, cMQIs * sizeof(*iids));
    /* mapping of RemQueryInterface index to QueryMultipleInterfaces index */
    ULONG *mapping = HeapAlloc(GetProcessHeap(), 0, cMQIs * sizeof(*mapping));

246
    TRACE("cMQIs: %d\n", cMQIs);
247 248 249 250 251

    /* try to get a local interface - this includes already active proxy
     * interfaces and also interfaces exposed by the proxy manager */
    for (i = 0; i < cMQIs; i++)
    {
252
        TRACE("iid[%d] = %s\n", i, debugstr_guid(pMQIs[i].pIID));
253 254 255 256 257 258 259 260 261 262 263
        pMQIs[i].hr = proxy_manager_query_local_interface(This, pMQIs[i].pIID, (void **)&pMQIs[i].pItf);
        if (pMQIs[i].hr == S_OK)
            successful_mqis++;
        else
        {
            iids[nonlocal_mqis] = *pMQIs[i].pIID;
            mapping[nonlocal_mqis] = i;
            nonlocal_mqis++;
        }
    }

264
    TRACE("%d interfaces not found locally\n", nonlocal_mqis);
265 266 267 268 269 270 271 272 273 274 275 276

    /* if we have more than one interface not found locally then we must try
     * to query the remote object for it */
    if (nonlocal_mqis != 0)
    {
        IRemUnknown *remunk;
        HRESULT hr;
        IPID *ipid;

        /* get the ipid of the first entry */
        /* FIXME: should we implement ClientIdentity on the ifproxies instead
         * of the proxy_manager so we use the correct ipid here? */
277
        ipid = &LIST_ENTRY(list_head(&This->interfaces), struct ifproxy, entry)->stdobjref.ipid;
278 279 280 281 282 283 284 285 286

        /* get IRemUnknown proxy so we can communicate with the remote object */
        hr = proxy_manager_get_remunknown(This, &remunk);

        if (hr == S_OK)
        {
            hr = IRemUnknown_RemQueryInterface(remunk, ipid, NORMALEXTREFS,
                                               nonlocal_mqis, iids, &qiresults);
            if (FAILED(hr))
287
                ERR("IRemUnknown_RemQueryInterface failed with error 0x%08x\n", hr);
288 289 290 291 292 293 294 295 296 297 298 299 300
        }

        /* IRemUnknown_RemQueryInterface can return S_FALSE if only some of
         * the interfaces were returned */
        if (SUCCEEDED(hr))
        {
            /* try to unmarshal each object returned to us */
            for (i = 0; i < nonlocal_mqis; i++)
            {
                ULONG index = mapping[i];
                HRESULT hrobj = qiresults[i].hResult;
                if (hrobj == S_OK)
                    hrobj = unmarshal_object(&qiresults[i].std, This->parent,
301 302
                                             This->dest_context,
                                             This->dest_context_data,
303
                                             pMQIs[index].pIID, &This->oxid_info,
304 305 306 307 308 309 310 311 312 313 314 315 316 317
                                             (void **)&pMQIs[index].pItf);

                if (hrobj == S_OK)
                    successful_mqis++;
                else
                    ERR("Failed to get pointer to interface %s\n", debugstr_guid(pMQIs[index].pIID));
                pMQIs[index].hr = hrobj;
            }
        }

        /* free the memory allocated by the proxy */
        CoTaskMemFree(qiresults);
    }

318
    TRACE("%d/%d successfully queried\n", successful_mqis, cMQIs);
319 320 321 322 323 324 325 326 327 328

    HeapFree(GetProcessHeap(), 0, iids);
    HeapFree(GetProcessHeap(), 0, mapping);

    if (successful_mqis == cMQIs)
        return S_OK; /* we got all requested interfaces */
    else if (successful_mqis == 0)
        return E_NOINTERFACE; /* we didn't get any interfaces */
    else
        return S_FALSE; /* we got some interfaces */
329 330
}

331
static const IMultiQIVtbl ClientIdentity_Vtbl =
332 333 334 335
{
    ClientIdentity_QueryInterface,
    ClientIdentity_AddRef,
    ClientIdentity_Release,
336
    ClientIdentity_QueryMultipleInterfaces
337 338
};

339 340 341 342 343 344 345
/* FIXME: remove these */
static HRESULT WINAPI StdMarshalImpl_GetUnmarshalClass(LPMARSHAL iface, REFIID riid, void* pv, DWORD dwDestContext, void* pvDestContext, DWORD mshlflags, CLSID* pCid);
static HRESULT WINAPI StdMarshalImpl_GetMarshalSizeMax(LPMARSHAL iface, REFIID riid, void* pv, DWORD dwDestContext, void* pvDestContext, DWORD mshlflags, DWORD* pSize);
static HRESULT WINAPI StdMarshalImpl_UnmarshalInterface(LPMARSHAL iface, IStream *pStm, REFIID riid, void **ppv);
static HRESULT WINAPI StdMarshalImpl_ReleaseMarshalData(LPMARSHAL iface, IStream *pStm);
static HRESULT WINAPI StdMarshalImpl_DisconnectObject(LPMARSHAL iface, DWORD dwReserved);

346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374
static HRESULT WINAPI Proxy_QueryInterface(IMarshal *iface, REFIID riid, void **ppvObject)
{
    ICOM_THIS_MULTI(struct proxy_manager, lpVtblMarshal, iface);
    return IMultiQI_QueryInterface((IMultiQI *)&This->lpVtbl, riid, ppvObject);
}

static ULONG WINAPI Proxy_AddRef(IMarshal *iface)
{
    ICOM_THIS_MULTI(struct proxy_manager, lpVtblMarshal, iface);
    return IMultiQI_AddRef((IMultiQI *)&This->lpVtbl);
}

static ULONG WINAPI Proxy_Release(IMarshal *iface)
{
    ICOM_THIS_MULTI(struct proxy_manager, lpVtblMarshal, iface);
    return IMultiQI_Release((IMultiQI *)&This->lpVtbl);
}

static HRESULT WINAPI Proxy_MarshalInterface(
    LPMARSHAL iface, IStream *pStm, REFIID riid, void* pv, DWORD dwDestContext,
    void* pvDestContext, DWORD mshlflags)
{
    ICOM_THIS_MULTI(struct proxy_manager, lpVtblMarshal, iface);
    HRESULT hr;
    struct ifproxy *ifproxy;

    TRACE("(...,%s,...)\n", debugstr_guid(riid));

    hr = proxy_manager_find_ifproxy(This, riid, &ifproxy);
375
    if (SUCCEEDED(hr))
376
    {
377
        STDOBJREF stdobjref = ifproxy->stdobjref;
378 379 380 381
        ULONG cPublicRefs = ifproxy->refs;
        ULONG cPublicRefsOld;

        /* optimization - share out proxy's public references if possible
382
         * instead of making new proxy do a roundtrip through the server */
383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407
        do
        {
            ULONG cPublicRefsNew;
            cPublicRefsOld = cPublicRefs;
            stdobjref.cPublicRefs = cPublicRefs / 2;
            cPublicRefsNew = cPublicRefs - stdobjref.cPublicRefs;
            cPublicRefs = InterlockedCompareExchange(
                (LONG *)&ifproxy->refs, cPublicRefsNew, cPublicRefsOld);
        } while (cPublicRefs != cPublicRefsOld);

        if (!stdobjref.cPublicRefs)
        {
            IRemUnknown *remunk;
            hr = proxy_manager_get_remunknown(This, &remunk);
            if (hr == S_OK)
            {
                HRESULT hrref = S_OK;
                REMINTERFACEREF rif;
                rif.ipid = ifproxy->stdobjref.ipid;
                rif.cPublicRefs = NORMALEXTREFS;
                rif.cPrivateRefs = 0;
                hr = IRemUnknown_RemAddRef(remunk, 1, &rif, &hrref);
                if (hr == S_OK && hrref == S_OK)
                    stdobjref.cPublicRefs = rif.cPublicRefs;
                else
408
                    ERR("IRemUnknown_RemAddRef returned with 0x%08x, hrref = 0x%08x\n", hr, hrref);
409 410
            }
        }
411

412 413 414 415 416 417 418 419 420
        if (SUCCEEDED(hr))
        {
            TRACE("writing stdobjref:\n\tflags = %04lx\n\tcPublicRefs = %ld\n\toxid = %s\n\toid = %s\n\tipid = %s\n",
                stdobjref.flags, stdobjref.cPublicRefs,
                wine_dbgstr_longlong(stdobjref.oxid),
                wine_dbgstr_longlong(stdobjref.oid),
                debugstr_guid(&stdobjref.ipid));
            hr = IStream_Write(pStm, &stdobjref, sizeof(stdobjref), NULL);
        }
421
    }
422 423 424 425 426 427 428 429 430 431 432 433 434
    else
    {
        /* we don't have the interface already unmarshaled so we have to
         * request the object from the server */
        IRemUnknown *remunk;
        IPID *ipid;
        REMQIRESULT *qiresults = NULL;
        IID iid = *riid;

        /* get the ipid of the first entry */
        /* FIXME: should we implement ClientIdentity on the ifproxies instead
         * of the proxy_manager so we use the correct ipid here? */
        ipid = &LIST_ENTRY(list_head(&This->interfaces), struct ifproxy, entry)->stdobjref.ipid;
435

436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456
        /* get IRemUnknown proxy so we can communicate with the remote object */
        hr = proxy_manager_get_remunknown(This, &remunk);

        if (hr == S_OK)
        {
            hr = IRemUnknown_RemQueryInterface(remunk, ipid, NORMALEXTREFS,
                                               1, &iid, &qiresults);
            if (SUCCEEDED(hr))
            {
                hr = IStream_Write(pStm, &qiresults->std, sizeof(qiresults->std), NULL);
                if (FAILED(hr))
                {
                    REMINTERFACEREF rif;
                    rif.ipid = qiresults->std.ipid;
                    rif.cPublicRefs = qiresults->std.cPublicRefs;
                    rif.cPrivateRefs = 0;
                    IRemUnknown_RemRelease(remunk, 1, &rif);
                }
                CoTaskMemFree(qiresults);
            }
            else
457
                ERR("IRemUnknown_RemQueryInterface failed with error 0x%08x\n", hr);
458 459
        }
    }
460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476

    return hr;
}

static const IMarshalVtbl ProxyMarshal_Vtbl =
{
    Proxy_QueryInterface,
    Proxy_AddRef,
    Proxy_Release,
    StdMarshalImpl_GetUnmarshalClass,
    StdMarshalImpl_GetMarshalSizeMax,
    Proxy_MarshalInterface,
    StdMarshalImpl_UnmarshalInterface,
    StdMarshalImpl_ReleaseMarshalData,
    StdMarshalImpl_DisconnectObject
};

477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542
static HRESULT WINAPI ProxyCliSec_QueryInterface(IClientSecurity *iface, REFIID riid, void **ppvObject)
{
    ICOM_THIS_MULTI(struct proxy_manager, lpVtblCliSec, iface);
    return IMultiQI_QueryInterface((IMultiQI *)&This->lpVtbl, riid, ppvObject);
}

static ULONG WINAPI ProxyCliSec_AddRef(IClientSecurity *iface)
{
    ICOM_THIS_MULTI(struct proxy_manager, lpVtblCliSec, iface);
    return IMultiQI_AddRef((IMultiQI *)&This->lpVtbl);
}

static ULONG WINAPI ProxyCliSec_Release(IClientSecurity *iface)
{
    ICOM_THIS_MULTI(struct proxy_manager, lpVtblCliSec, iface);
    return IMultiQI_Release((IMultiQI *)&This->lpVtbl);
}

static HRESULT WINAPI ProxyCliSec_QueryBlanket(IClientSecurity *iface,
                                               IUnknown *pProxy,
                                               DWORD *pAuthnSvc,
                                               DWORD *pAuthzSvc,
                                               OLECHAR **pServerPrincName,
                                               DWORD *pAuthnLevel,
                                               DWORD *pImpLevel,
                                               void **pAuthInfo,
                                               DWORD *pCapabilities)
{
    FIXME("(%p, %p, %p, %p, %p, %p, %p, %p): stub\n", pProxy, pAuthnSvc,
          pAuthzSvc, pServerPrincName, pAuthnLevel, pImpLevel, pAuthInfo,
          pCapabilities);
    return E_NOTIMPL;
}

static HRESULT WINAPI ProxyCliSec_SetBlanket(IClientSecurity *iface,
                                             IUnknown *pProxy, DWORD AuthnSvc,
                                             DWORD AuthzSvc,
                                             OLECHAR *pServerPrincName,
                                             DWORD AuthnLevel, DWORD ImpLevel,
                                             void *pAuthInfo,
                                             DWORD Capabilities)
{
    FIXME("(%p, %d, %d, %s, %d, %d, %p, 0x%x): stub\n", pProxy, AuthnSvc,
          AuthzSvc, debugstr_w(pServerPrincName), AuthnLevel, ImpLevel,
          pAuthInfo, Capabilities);
    return E_NOTIMPL;
}

static HRESULT WINAPI ProxyCliSec_CopyProxy(IClientSecurity *iface,
                                            IUnknown *pProxy, IUnknown **ppCopy)
{
    FIXME("(%p, %p): stub\n", pProxy, ppCopy);
    *ppCopy = NULL;
    return E_NOTIMPL;
}

static const IClientSecurityVtbl ProxyCliSec_Vtbl =
{
    ProxyCliSec_QueryInterface,
    ProxyCliSec_AddRef,
    ProxyCliSec_Release,
    ProxyCliSec_QueryBlanket,
    ProxyCliSec_SetBlanket,
    ProxyCliSec_CopyProxy
};

543 544
static HRESULT ifproxy_get_public_ref(struct ifproxy * This)
{
545
    HRESULT hr = S_OK;
546 547 548 549 550 551 552

    if (WAIT_OBJECT_0 != WaitForSingleObject(This->parent->remoting_mutex, INFINITE))
    {
        ERR("Wait failed for ifproxy %p\n", This);
        return E_UNEXPECTED;
    }

553 554
    if (This->refs == 0)
    {
555
        IRemUnknown *remunk = NULL;
556 557 558

        TRACE("getting public ref for ifproxy %p\n", This);

559 560
        hr = proxy_manager_get_remunknown(This->parent, &remunk);
        if (hr == S_OK)
561
        {
562
            HRESULT hrref = S_OK;
563
            REMINTERFACEREF rif;
564
            rif.ipid = This->stdobjref.ipid;
565 566 567 568
            rif.cPublicRefs = NORMALEXTREFS;
            rif.cPrivateRefs = 0;
            hr = IRemUnknown_RemAddRef(remunk, 1, &rif, &hrref);
            if (hr == S_OK && hrref == S_OK)
569
                InterlockedExchangeAdd((LONG *)&This->refs, NORMALEXTREFS);
570
            else
571
                ERR("IRemUnknown_RemAddRef returned with 0x%08x, hrref = 0x%08x\n", hr, hrref);
572 573
        }
    }
574
    ReleaseMutex(This->parent->remoting_mutex);
575

576
    return hr;
577 578
}

579 580
static HRESULT ifproxy_release_public_refs(struct ifproxy * This)
{
581
    HRESULT hr = S_OK;
582
    LONG public_refs;
583

584 585 586 587 588 589
    if (WAIT_OBJECT_0 != WaitForSingleObject(This->parent->remoting_mutex, INFINITE))
    {
        ERR("Wait failed for ifproxy %p\n", This);
        return E_UNEXPECTED;
    }

590 591
    public_refs = This->refs;
    if (public_refs > 0)
592
    {
593 594
        IRemUnknown *remunk = NULL;

595
        TRACE("releasing %d refs\n", public_refs);
596 597 598 599 600

        hr = proxy_manager_get_remunknown(This->parent, &remunk);
        if (hr == S_OK)
        {
            REMINTERFACEREF rif;
601
            rif.ipid = This->stdobjref.ipid;
602
            rif.cPublicRefs = public_refs;
603 604 605
            rif.cPrivateRefs = 0;
            hr = IRemUnknown_RemRelease(remunk, 1, &rif);
            if (hr == S_OK)
606
                InterlockedExchangeAdd((LONG *)&This->refs, -public_refs);
607 608 609 610 611
            else if (hr == RPC_E_DISCONNECTED)
                WARN("couldn't release references because object was "
                     "disconnected: oxid = %s, oid = %s\n",
                     wine_dbgstr_longlong(This->parent->oxid),
                     wine_dbgstr_longlong(This->parent->oid));
612
            else
613
                ERR("IRemUnknown_RemRelease failed with error 0x%08x\n", hr);
614
        }
615
    }
616
    ReleaseMutex(This->parent->remoting_mutex);
617 618

    return hr;
619 620
}

621
/* should be called inside This->parent->cs critical section */
622 623
static void ifproxy_disconnect(struct ifproxy * This)
{
624
    ifproxy_release_public_refs(This);
625
    if (This->proxy) IRpcProxyBuffer_Disconnect(This->proxy);
626 627 628

    IRpcChannelBuffer_Release(This->chan);
    This->chan = NULL;
629 630
}

631
/* should be called in This->parent->cs critical section if it is an entry in parent's list */
632 633
static void ifproxy_destroy(struct ifproxy * This)
{
634 635
    TRACE("%p\n", This);

636 637 638 639 640 641
    /* release public references to this object so that the stub can know
     * when to destroy itself */
    ifproxy_release_public_refs(This);

    list_remove(&This->entry);

642 643 644 645 646 647
    if (This->chan)
    {
        IRpcChannelBuffer_Release(This->chan);
        This->chan = NULL;
    }

648
    if (This->proxy) IRpcProxyBuffer_Release(This->proxy);
649

650 651 652
    HeapFree(GetProcessHeap(), 0, This);
}

653 654
static HRESULT proxy_manager_construct(
    APARTMENT * apt, ULONG sorflags, OXID oxid, OID oid,
655
    const OXID_INFO *oxid_info, struct proxy_manager ** proxy_manager)
656 657 658 659
{
    struct proxy_manager * This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
    if (!This) return E_OUTOFMEMORY;

660 661 662 663 664 665 666
    This->remoting_mutex = CreateMutexW(NULL, FALSE, NULL);
    if (!This->remoting_mutex)
    {
        HeapFree(GetProcessHeap(), 0, This);
        return HRESULT_FROM_WIN32(GetLastError());
    }

667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685
    if (oxid_info)
    {
        This->oxid_info.dwPid = oxid_info->dwPid;
        This->oxid_info.dwTid = oxid_info->dwTid;
        This->oxid_info.ipidRemUnknown = oxid_info->ipidRemUnknown;
        This->oxid_info.dwAuthnHint = oxid_info->dwAuthnHint;
        This->oxid_info.psa = NULL /* FIXME: copy from oxid_info */;
    }
    else
    {
        HRESULT hr = RPC_ResolveOxid(oxid, &This->oxid_info);
        if (FAILED(hr))
        {
            CloseHandle(This->remoting_mutex);
            HeapFree(GetProcessHeap(), 0, This);
            return hr;
        }
    }

686
    This->lpVtbl = &ClientIdentity_Vtbl;
687
    This->lpVtblMarshal = &ProxyMarshal_Vtbl;
688
    This->lpVtblCliSec = &ProxyCliSec_Vtbl;
689 690 691 692 693

    list_init(&This->entry);
    list_init(&This->interfaces);

    InitializeCriticalSection(&This->cs);
694
    DEBUG_SET_CRITSEC_NAME(&This->cs, "proxy_manager");
695 696 697 698 699 700 701 702

    /* the apartment the object was unmarshaled into */
    This->parent = apt;

    /* the source apartment and id of the object */
    This->oxid = oxid;
    This->oid = oid;

703
    This->refs = 1;
704

705 706
    /* the DCOM draft specification states that the SORF_NOPING flag is
     * proxy manager specific, not ifproxy specific, so this implies that we
707
     * should store the STDOBJREF flags here in the proxy manager. */
708 709 710 711 712
    This->sorflags = sorflags;

    /* we create the IRemUnknown proxy on demand */
    This->remunk = NULL;

713 714 715 716 717
    /* initialise these values to the weakest values and they will be
     * overwritten in proxy_manager_set_context */
    This->dest_context = MSHCTX_INPROC;
    This->dest_context_data = NULL;

718
    EnterCriticalSection(&apt->cs);
Robert Shearman's avatar
Robert Shearman committed
719 720 721 722 723 724
    /* FIXME: we are dependent on the ordering in here to make sure a proxy's
     * IRemUnknown proxy doesn't get destroyed before the regual proxy does
     * because we need the IRemUnknown proxy during the destruction of the
     * regular proxy. Ideally, we should maintain a separate list for the
     * IRemUnknown proxies that need late destruction */
    list_add_tail(&apt->proxies, &This->entry);
725 726
    LeaveCriticalSection(&apt->cs);

727 728 729
    TRACE("%p created for OXID %s, OID %s\n", This,
        wine_dbgstr_longlong(oxid), wine_dbgstr_longlong(oid));

730 731 732 733
    *proxy_manager = This;
    return S_OK;
}

734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790
static inline void proxy_manager_set_context(struct proxy_manager *This, MSHCTX dest_context, void *dest_context_data)
{
    MSHCTX old_dest_context = This->dest_context;
    MSHCTX new_dest_context;

    do
    {
        new_dest_context = old_dest_context;
        /* "stronger" values overwrite "weaker" values. stronger values are
         * ones that disable more optimisations */
        switch (old_dest_context)
        {
        case MSHCTX_INPROC:
            new_dest_context = dest_context;
            break;
        case MSHCTX_CROSSCTX:
            switch (dest_context)
            {
            case MSHCTX_INPROC:
                break;
            default:
                new_dest_context = dest_context;
            }
            break;
        case MSHCTX_LOCAL:
            switch (dest_context)
            {
            case MSHCTX_INPROC:
            case MSHCTX_CROSSCTX:
                break;
            default:
                new_dest_context = dest_context;
            }
            break;
        case MSHCTX_NOSHAREDMEM:
            switch (dest_context)
            {
            case MSHCTX_DIFFERENTMACHINE:
                new_dest_context = dest_context;
                break;
            default:
                break;
            }
            break;
        default:
            break;
        }

        if (old_dest_context == new_dest_context) break;

        old_dest_context = InterlockedCompareExchange((PLONG)&This->dest_context, new_dest_context, old_dest_context);
    } while (new_dest_context != old_dest_context);

    if (dest_context_data)
        InterlockedExchangePointer(&This->dest_context_data, dest_context_data);
}

791 792 793 794 795 796 797 798 799 800 801
static HRESULT proxy_manager_query_local_interface(struct proxy_manager * This, REFIID riid, void ** ppv)
{
    HRESULT hr;
    struct ifproxy * ifproxy;

    TRACE("%s\n", debugstr_guid(riid));

    if (IsEqualIID(riid, &IID_IUnknown) ||
        IsEqualIID(riid, &IID_IMultiQI))
    {
        *ppv = (void *)&This->lpVtbl;
802
        IUnknown_AddRef((IUnknown *)*ppv);
803 804
        return S_OK;
    }
805 806 807 808 809 810 811 812
    if (IsEqualIID(riid, &IID_IMarshal))
    {
        *ppv = (void *)&This->lpVtblMarshal;
        IUnknown_AddRef((IUnknown *)*ppv);
        return S_OK;
    }
    if (IsEqualIID(riid, &IID_IClientSecurity))
    {
813 814 815
        *ppv = (void *)&This->lpVtblCliSec;
        IUnknown_AddRef((IUnknown *)*ppv);
        return S_OK;
816
    }
817 818 819 820 821 822 823 824 825 826 827 828 829

    hr = proxy_manager_find_ifproxy(This, riid, &ifproxy);
    if (hr == S_OK)
    {
        *ppv = ifproxy->iface;
        IUnknown_AddRef((IUnknown *)*ppv);
        return S_OK;
    }

    *ppv = NULL;
    return E_NOINTERFACE;
}

830
static HRESULT proxy_manager_create_ifproxy(
831
    struct proxy_manager * This, const STDOBJREF *stdobjref, REFIID riid,
832
    IRpcChannelBuffer * channel, struct ifproxy ** iif_out)
833 834 835 836 837 838 839 840
{
    HRESULT hr;
    IPSFactoryBuffer * psfb;
    struct ifproxy * ifproxy = HeapAlloc(GetProcessHeap(), 0, sizeof(*ifproxy));
    if (!ifproxy) return E_OUTOFMEMORY;

    list_init(&ifproxy->entry);

841
    ifproxy->parent = This;
842
    ifproxy->stdobjref = *stdobjref;
843
    ifproxy->iid = *riid;
844
    ifproxy->refs = 0;
845 846
    ifproxy->proxy = NULL;

847 848 849
    assert(channel);
    ifproxy->chan = channel; /* FIXME: we should take the binding strings and construct the channel in this function */

850
    /* the IUnknown interface is special because it does not have a
851 852
     * proxy associated with the ifproxy as we handle IUnknown ourselves */
    if (IsEqualIID(riid, &IID_IUnknown))
853
    {
854
        ifproxy->iface = (void *)&This->lpVtbl;
855
        IMultiQI_AddRef((IMultiQI *)&This->lpVtbl);
856
        hr = S_OK;
857
    }
858
    else
859 860 861 862 863 864 865 866 867 868 869 870
    {
        hr = get_facbuf_for_iid(riid, &psfb);
        if (hr == S_OK)
        {
            /* important note: the outer unknown is set to the proxy manager.
             * This ensures the COM identity rules are not violated, by having a
             * one-to-one mapping of objects on the proxy side to objects on the
             * stub side, no matter which interface you view the object through */
            hr = IPSFactoryBuffer_CreateProxy(psfb, (IUnknown *)&This->lpVtbl, riid,
                                              &ifproxy->proxy, &ifproxy->iface);
            IPSFactoryBuffer_Release(psfb);
            if (hr != S_OK)
871
                ERR("Could not create proxy for interface %s, error 0x%08x\n",
872 873 874
                    debugstr_guid(riid), hr);
        }
        else
875
            ERR("Could not get IPSFactoryBuffer for interface %s, error 0x%08x\n",
876
                debugstr_guid(riid), hr);
877

878
        if (hr == S_OK)
879
            hr = IRpcProxyBuffer_Connect(ifproxy->proxy, ifproxy->chan);
880
    }
881 882 883 884 885 886 887 888

    if (hr == S_OK)
    {
        EnterCriticalSection(&This->cs);
        list_add_tail(&This->interfaces, &ifproxy->entry);
        LeaveCriticalSection(&This->cs);

        *iif_out = ifproxy;
889
        TRACE("ifproxy %p created for IPID %s, interface %s with %lu public refs\n",
890
              ifproxy, debugstr_guid(&stdobjref->ipid), debugstr_guid(riid), stdobjref->cPublicRefs);
891 892
    }
    else
893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922
        ifproxy_destroy(ifproxy);

    return hr;
}

static HRESULT proxy_manager_find_ifproxy(struct proxy_manager * This, REFIID riid, struct ifproxy ** ifproxy_found)
{
    HRESULT hr = E_NOINTERFACE; /* assume not found */
    struct list * cursor;

    EnterCriticalSection(&This->cs);
    LIST_FOR_EACH(cursor, &This->interfaces)
    {
        struct ifproxy * ifproxy = LIST_ENTRY(cursor, struct ifproxy, entry);
        if (IsEqualIID(riid, &ifproxy->iid))
        {
            *ifproxy_found = ifproxy;
            hr = S_OK;
            break;
        }
    }
    LeaveCriticalSection(&This->cs);

    return hr;
}

static void proxy_manager_disconnect(struct proxy_manager * This)
{
    struct list * cursor;

923 924
    TRACE("oxid = %s, oid = %s\n", wine_dbgstr_longlong(This->oxid),
        wine_dbgstr_longlong(This->oid));
925

926 927
    EnterCriticalSection(&This->cs);

928 929 930 931
    /* SORFP_NOLIFTIMEMGMT proxies (for IRemUnknown) shouldn't be
     * disconnected - it won't do anything anyway, except cause
     * problems for other objects that depend on this proxy always
     * working */
932
    if (!(This->sorflags & SORFP_NOLIFETIMEMGMT))
933
    {
934 935 936 937 938
        LIST_FOR_EACH(cursor, &This->interfaces)
        {
            struct ifproxy * ifproxy = LIST_ENTRY(cursor, struct ifproxy, entry);
            ifproxy_disconnect(ifproxy);
        }
939 940 941 942 943 944 945 946
    }

    /* apartment is being destroyed so don't keep a pointer around to it */
    This->parent = NULL;

    LeaveCriticalSection(&This->cs);
}

947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973
static HRESULT proxy_manager_get_remunknown(struct proxy_manager * This, IRemUnknown **remunk)
{
    HRESULT hr = S_OK;

    /* we don't want to try and unmarshal or use IRemUnknown if we don't want
     * lifetime management */
    if (This->sorflags & SORFP_NOLIFETIMEMGMT)
        return S_FALSE;

    EnterCriticalSection(&This->cs);
    if (This->remunk)
        /* already created - return existing object */
        *remunk = This->remunk;
    else if (!This->parent)
        /* disconnected - we can't create IRemUnknown */
        hr = S_FALSE;
    else
    {
        STDOBJREF stdobjref;
        /* Don't want IRemUnknown lifetime management as this is IRemUnknown!
         * We also don't care about whether or not the stub is still alive */
        stdobjref.flags = SORFP_NOLIFETIMEMGMT | SORF_NOPING;
        stdobjref.cPublicRefs = 1;
        /* oxid of destination object */
        stdobjref.oxid = This->oxid;
        /* FIXME: what should be used for the oid? The DCOM draft doesn't say */
        stdobjref.oid = (OID)-1;
974 975
        stdobjref.ipid = This->oxid_info.ipidRemUnknown;

976
        /* do the unmarshal */
977 978
        hr = unmarshal_object(&stdobjref, This->parent, This->dest_context,
                              This->dest_context_data, &IID_IRemUnknown,
979
                              &This->oxid_info, (void**)&This->remunk);
980 981 982 983 984
        if (hr == S_OK)
            *remunk = This->remunk;
    }
    LeaveCriticalSection(&This->cs);

985
    TRACE("got IRemUnknown* pointer %p, hr = 0x%08x\n", *remunk, hr);
986 987 988 989 990 991 992 993

    return hr;
}

/* destroys a proxy manager, freeing the memory it used.
 * Note: this function should not be called from a list iteration in the
 * apartment, due to the fact that it removes itself from the apartment and
 * it could add a proxy to IRemUnknown into the apartment. */
994 995 996 997
static void proxy_manager_destroy(struct proxy_manager * This)
{
    struct list * cursor;

998 999 1000
    TRACE("oxid = %s, oid = %s\n", wine_dbgstr_longlong(This->oxid),
        wine_dbgstr_longlong(This->oid));

1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018
    if (This->parent)
    {
        EnterCriticalSection(&This->parent->cs);

        /* remove ourself from the list of proxy objects in the apartment */
        LIST_FOR_EACH(cursor, &This->parent->proxies)
        {
            if (cursor == &This->entry)
            {
                list_remove(&This->entry);
                break;
            }
        }

        LeaveCriticalSection(&This->parent->cs);
    }

    /* destroy all of the interface proxies */
1019
    while ((cursor = list_head(&This->interfaces)))
1020 1021 1022 1023 1024
    {
        struct ifproxy * ifproxy = LIST_ENTRY(cursor, struct ifproxy, entry);
        ifproxy_destroy(ifproxy);
    }

1025
    if (This->remunk) IRemUnknown_Release(This->remunk);
1026
    CoTaskMemFree(This->oxid_info.psa);
1027

1028
    DEBUG_CLEAR_CRITSEC_NAME(&This->cs);
1029 1030
    DeleteCriticalSection(&This->cs);

1031 1032
    CloseHandle(This->remoting_mutex);

1033 1034 1035
    HeapFree(GetProcessHeap(), 0, This);
}

1036 1037 1038
/* finds the proxy manager corresponding to a given OXID and OID that has
 * been unmarshaled in the specified apartment. The caller must release the
 * reference to the proxy_manager when the object is no longer used. */
1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050
static BOOL find_proxy_manager(APARTMENT * apt, OXID oxid, OID oid, struct proxy_manager ** proxy_found)
{
    BOOL found = FALSE;
    struct list * cursor;

    EnterCriticalSection(&apt->cs);
    LIST_FOR_EACH(cursor, &apt->proxies)
    {
        struct proxy_manager * proxy = LIST_ENTRY(cursor, struct proxy_manager, entry);
        if ((oxid == proxy->oxid) && (oid == proxy->oid))
        {
            *proxy_found = proxy;
1051
            ClientIdentity_AddRef((IMultiQI *)&proxy->lpVtbl);
1052 1053 1054 1055 1056 1057 1058 1059
            found = TRUE;
            break;
        }
    }
    LeaveCriticalSection(&apt->cs);
    return found;
}

1060
HRESULT apartment_disconnectproxies(struct apartment *apt)
1061 1062 1063 1064 1065 1066 1067 1068 1069
{
    struct list * cursor;

    LIST_FOR_EACH(cursor, &apt->proxies)
    {
        struct proxy_manager * proxy = LIST_ENTRY(cursor, struct proxy_manager, entry);
        proxy_manager_disconnect(proxy);
    }

1070 1071 1072 1073
    return S_OK;
}

/********************** StdMarshal implementation ****************************/
1074 1075 1076
typedef struct _StdMarshalImpl
{
    const IMarshalVtbl	*lpvtbl;
1077
    LONG		ref;
1078 1079 1080 1081 1082

    IID			iid;
    DWORD		dwDestContext;
    LPVOID		pvDestContext;
    DWORD		mshlflags;
1083 1084
} StdMarshalImpl;

1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096
static HRESULT WINAPI 
StdMarshalImpl_QueryInterface(LPMARSHAL iface, REFIID riid, LPVOID *ppv)
{
    *ppv = NULL;
    if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IMarshal, riid))
    {
        *ppv = iface;
        IUnknown_AddRef(iface);
        return S_OK;
    }
    FIXME("No interface for %s.\n", debugstr_guid(riid));
    return E_NOINTERFACE;
1097 1098
}

1099
static ULONG WINAPI
1100 1101 1102 1103
StdMarshalImpl_AddRef(LPMARSHAL iface)
{
    StdMarshalImpl *This = (StdMarshalImpl *)iface;
    return InterlockedIncrement(&This->ref);
1104 1105
}

1106
static ULONG WINAPI
1107 1108 1109 1110
StdMarshalImpl_Release(LPMARSHAL iface)
{
    StdMarshalImpl *This = (StdMarshalImpl *)iface;
    ULONG ref = InterlockedDecrement(&This->ref);
1111

1112 1113
    if (!ref) HeapFree(GetProcessHeap(),0,This);
    return ref;
1114 1115
}

1116
static HRESULT WINAPI
1117
StdMarshalImpl_GetUnmarshalClass(
1118 1119 1120 1121 1122
    LPMARSHAL iface, REFIID riid, void* pv, DWORD dwDestContext,
    void* pvDestContext, DWORD mshlflags, CLSID* pCid)
{
    *pCid = CLSID_DfMarshal;
    return S_OK;
1123 1124
}

1125
static HRESULT WINAPI
1126
StdMarshalImpl_GetMarshalSizeMax(
1127 1128
    LPMARSHAL iface, REFIID riid, void* pv, DWORD dwDestContext,
    void* pvDestContext, DWORD mshlflags, DWORD* pSize)
1129 1130 1131
{
    *pSize = sizeof(STDOBJREF);
    return S_OK;
1132 1133
}

1134
static HRESULT WINAPI
1135
StdMarshalImpl_MarshalInterface(
1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154
    LPMARSHAL iface, IStream *pStm,REFIID riid, void* pv, DWORD dwDestContext,
    void* pvDestContext, DWORD mshlflags)
{
    STDOBJREF             stdobjref;
    ULONG                 res;
    HRESULT               hres;
    APARTMENT            *apt = COM_CurrentApt();

    TRACE("(...,%s,...)\n", debugstr_guid(riid));

    if (!apt)
    {
        ERR("Apartment not initialized\n");
        return CO_E_NOTINITIALIZED;
    }

    /* make sure this apartment can be reached from other threads / processes */
    RPC_StartRemoting(apt);

1155
    hres = marshal_object(apt, &stdobjref, riid, (IUnknown *)pv, mshlflags);
1156 1157
    if (hres)
    {
1158
        ERR("Failed to create ifstub, hres=0x%x\n", hres);
1159 1160
        return hres;
    }
1161

1162 1163
    hres = IStream_Write(pStm, &stdobjref, sizeof(stdobjref), &res);
    if (hres) return hres;
1164

1165
    return S_OK;
1166 1167
}

1168 1169 1170
/* helper for StdMarshalImpl_UnmarshalInterface - does the unmarshaling with
 * no questions asked about the rules surrounding same-apartment unmarshals
 * and table marshaling */
1171 1172
static HRESULT unmarshal_object(const STDOBJREF *stdobjref, APARTMENT *apt,
                                MSHCTX dest_context, void *dest_context_data,
1173 1174
                                REFIID riid, const OXID_INFO *oxid_info,
                                void **object)
1175 1176 1177 1178
{
    struct proxy_manager *proxy_manager = NULL;
    HRESULT hr = S_OK;

1179 1180 1181 1182 1183 1184 1185 1186
    assert(apt);

    TRACE("stdobjref:\n\tflags = %04lx\n\tcPublicRefs = %ld\n\toxid = %s\n\toid = %s\n\tipid = %s\n",
        stdobjref->flags, stdobjref->cPublicRefs,
        wine_dbgstr_longlong(stdobjref->oxid),
        wine_dbgstr_longlong(stdobjref->oid),
        debugstr_guid(&stdobjref->ipid));

1187
    /* create a new proxy manager if one doesn't already exist for the
1188 1189 1190
     * object */
    if (!find_proxy_manager(apt, stdobjref->oxid, stdobjref->oid, &proxy_manager))
    {
1191
        hr = proxy_manager_construct(apt, stdobjref->flags,
1192
                                     stdobjref->oxid, stdobjref->oid, oxid_info,
1193
                                     &proxy_manager);
1194
    }
1195 1196
    else
        TRACE("proxy manager already created, using\n");
1197 1198 1199

    if (hr == S_OK)
    {
1200
        struct ifproxy * ifproxy;
1201 1202 1203

        proxy_manager_set_context(proxy_manager, dest_context, dest_context_data);

1204 1205
        hr = proxy_manager_find_ifproxy(proxy_manager, riid, &ifproxy);
        if (hr == E_NOINTERFACE)
1206 1207
        {
            IRpcChannelBuffer *chanbuf;
1208
            hr = RPC_CreateClientChannel(&stdobjref->oxid, &stdobjref->ipid,
1209
                                         &proxy_manager->oxid_info,
1210 1211 1212
                                         proxy_manager->dest_context,
                                         proxy_manager->dest_context_data,
                                         &chanbuf);
1213
            if (hr == S_OK)
1214 1215
                hr = proxy_manager_create_ifproxy(proxy_manager, stdobjref,
                                                  riid, chanbuf, &ifproxy);
1216
        }
1217 1218
        else
            IUnknown_AddRef((IUnknown *)ifproxy->iface);
1219

1220 1221 1222 1223 1224 1225 1226 1227 1228
        if (hr == S_OK)
        {
            InterlockedExchangeAdd((LONG *)&ifproxy->refs, stdobjref->cPublicRefs);
            /* get at least one external reference to the object to keep it alive */
            hr = ifproxy_get_public_ref(ifproxy);
            if (FAILED(hr))
                ifproxy_destroy(ifproxy);
        }

1229 1230
        if (hr == S_OK)
            *object = ifproxy->iface;
1231 1232 1233 1234
    }

    /* release our reference to the proxy manager - the client/apartment
     * will hold on to the remaining reference for us */
1235
    if (proxy_manager) ClientIdentity_Release((IMultiQI*)&proxy_manager->lpVtbl);
1236 1237 1238 1239

    return hr;
}

1240
static HRESULT WINAPI
1241 1242
StdMarshalImpl_UnmarshalInterface(LPMARSHAL iface, IStream *pStm, REFIID riid, void **ppv)
{
1243
    StdMarshalImpl *This = (StdMarshalImpl *)iface;
1244
    struct stub_manager *stubmgr = NULL;
1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262
    STDOBJREF stdobjref;
    ULONG res;
    HRESULT hres;
    APARTMENT *apt = COM_CurrentApt();
    APARTMENT *stub_apt;
    OXID oxid;

    TRACE("(...,%s,....)\n", debugstr_guid(riid));

    /* we need an apartment to unmarshal into */
    if (!apt)
    {
        ERR("Apartment not initialized\n");
        return CO_E_NOTINITIALIZED;
    }

    /* read STDOBJREF from wire */
    hres = IStream_Read(pStm, &stdobjref, sizeof(stdobjref), &res);
1263
    if (hres) return STG_E_READFAULT;
1264 1265 1266 1267 1268 1269 1270 1271 1272

    hres = apartment_getoxid(apt, &oxid);
    if (hres) return hres;

    /* check if we're marshalling back to ourselves */
    if ((oxid == stdobjref.oxid) && (stubmgr = get_stub_manager(apt, stdobjref.oid)))
    {
        TRACE("Unmarshalling object marshalled in same apartment for iid %s, "
              "returning original object %p\n", debugstr_guid(riid), stubmgr->object);
1273
    
1274
        hres = IUnknown_QueryInterface(stubmgr->object, riid, ppv);
1275
      
1276
        /* unref the ifstub. FIXME: only do this on success? */
1277
        if (!stub_manager_is_table_marshaled(stubmgr, &stdobjref.ipid))
1278
            stub_manager_ext_release(stubmgr, stdobjref.cPublicRefs, TRUE);
1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292

        stub_manager_int_release(stubmgr);
        return hres;
    }

    /* notify stub manager about unmarshal if process-local object.
     * note: if the oxid is not found then we and native will quite happily
     * ignore table marshaling and normal marshaling rules regarding number of
     * unmarshals, etc, but if you abuse these rules then your proxy could end
     * up returning RPC_E_DISCONNECTED. */
    if ((stub_apt = apartment_findfromoxid(stdobjref.oxid, TRUE)))
    {
        if ((stubmgr = get_stub_manager(stub_apt, stdobjref.oid)))
        {
1293
            if (!stub_manager_notify_unmarshal(stubmgr, &stdobjref.ipid))
1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305
                hres = CO_E_OBJNOTCONNECTED;
        }
        else
        {
            WARN("Couldn't find object for OXID %s, OID %s, assuming disconnected\n",
                wine_dbgstr_longlong(stdobjref.oxid),
                wine_dbgstr_longlong(stdobjref.oid));
            hres = CO_E_OBJNOTCONNECTED;
        }
    }
    else
        TRACE("Treating unmarshal from OXID %s as inter-process\n",
1306
            wine_dbgstr_longlong(stdobjref.oxid));
1307

1308
    if (hres == S_OK)
1309
        hres = unmarshal_object(&stdobjref, apt, This->dwDestContext,
1310 1311 1312 1313 1314
                                This->pvDestContext, riid,
                                stubmgr ? &stubmgr->oxid_info : NULL, ppv);

    if (stubmgr) stub_manager_int_release(stubmgr);
    if (stub_apt) apartment_release(stub_apt);
1315

1316
    if (hres) WARN("Failed with error 0x%08x\n", hres);
1317
    else TRACE("Successfully created proxy %p\n", *ppv);
1318

1319
    return hres;
1320 1321
}

1322
static HRESULT WINAPI
1323 1324
StdMarshalImpl_ReleaseMarshalData(LPMARSHAL iface, IStream *pStm)
{
1325
    STDOBJREF            stdobjref;
1326 1327 1328
    ULONG                res;
    HRESULT              hres;
    struct stub_manager *stubmgr;
1329
    APARTMENT           *apt;
1330

1331 1332
    TRACE("iface=%p, pStm=%p\n", iface, pStm);
    
1333
    hres = IStream_Read(pStm, &stdobjref, sizeof(stdobjref), &res);
1334
    if (hres) return STG_E_READFAULT;
1335

1336 1337 1338 1339 1340
    TRACE("oxid = %s, oid = %s, ipid = %s\n",
        wine_dbgstr_longlong(stdobjref.oxid),
        wine_dbgstr_longlong(stdobjref.oid),
        wine_dbgstr_guid(&stdobjref.ipid));

1341
    if (!(apt = apartment_findfromoxid(stdobjref.oxid, TRUE)))
1342
    {
1343 1344
        WARN("Could not map OXID %s to apartment object\n",
            wine_dbgstr_longlong(stdobjref.oxid));
1345 1346 1347
        return RPC_E_INVALID_OBJREF;
    }

1348
    if (!(stubmgr = get_stub_manager(apt, stdobjref.oid)))
1349
    {
1350
        ERR("could not map object ID to stub manager, oxid=%s, oid=%s\n",
1351
            wine_dbgstr_longlong(stdobjref.oxid), wine_dbgstr_longlong(stdobjref.oid));
1352 1353
        return RPC_E_INVALID_OBJREF;
    }
1354

1355
    stub_manager_release_marshal_data(stubmgr, stdobjref.cPublicRefs, &stdobjref.ipid);
1356 1357

    stub_manager_int_release(stubmgr);
1358
    apartment_release(apt);
1359

1360
    return S_OK;
1361 1362
}

1363
static HRESULT WINAPI
1364 1365 1366 1367
StdMarshalImpl_DisconnectObject(LPMARSHAL iface, DWORD dwReserved)
{
    FIXME("(), stub!\n");
    return S_OK;
1368 1369
}

1370 1371
static const IMarshalVtbl VT_StdMarshal =
{
1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382
    StdMarshalImpl_QueryInterface,
    StdMarshalImpl_AddRef,
    StdMarshalImpl_Release,
    StdMarshalImpl_GetUnmarshalClass,
    StdMarshalImpl_GetMarshalSizeMax,
    StdMarshalImpl_MarshalInterface,
    StdMarshalImpl_UnmarshalInterface,
    StdMarshalImpl_ReleaseMarshalData,
    StdMarshalImpl_DisconnectObject
};

1383 1384 1385 1386 1387 1388
static HRESULT StdMarshalImpl_Construct(REFIID riid, void** ppvObject)
{
    StdMarshalImpl * pStdMarshal = 
        HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(StdMarshalImpl));
    if (!pStdMarshal)
        return E_OUTOFMEMORY;
1389
    pStdMarshal->lpvtbl = &VT_StdMarshal;
1390 1391 1392 1393
    pStdMarshal->ref = 0;
    return IMarshal_QueryInterface((IMarshal*)pStdMarshal, riid, ppvObject);
}

1394
/***********************************************************************
1395
 *		CoGetStandardMarshal	[OLE32.@]
1396
 *
1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415
 * Gets or creates a standard marshal object.
 *
 * PARAMS
 *  riid          [I] Interface identifier of the pUnk object.
 *  pUnk          [I] Optional. Object to get the marshal object for.
 *  dwDestContext [I] Destination. Used to enable or disable optimizations.
 *  pvDestContext [I] Reserved. Must be NULL.
 *  mshlflags     [I] Flags affecting the marshaling process.
 *  ppMarshal     [O] Address where marshal object will be stored.
 *
 * RETURNS
 *  Success: S_OK.
 *  Failure: HRESULT code.
 *
 * NOTES
 *
 * The function retrieves the IMarshal object associated with an object if
 * that object is currently an active stub, otherwise a new marshal object is
 * created.
1416
 */
1417 1418 1419 1420
HRESULT WINAPI CoGetStandardMarshal(REFIID riid, IUnknown *pUnk,
                                    DWORD dwDestContext, LPVOID pvDestContext,
                                    DWORD mshlflags, LPMARSHAL *ppMarshal)
{
1421 1422 1423 1424
    StdMarshalImpl *dm;

    if (pUnk == NULL)
    {
1425
        FIXME("(%s,NULL,%x,%p,%x,%p), unimplemented yet.\n",
1426 1427 1428
            debugstr_guid(riid),dwDestContext,pvDestContext,mshlflags,ppMarshal);
        return E_NOTIMPL;
    }
1429
    TRACE("(%s,%p,%x,%p,%x,%p)\n",
1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441
        debugstr_guid(riid),pUnk,dwDestContext,pvDestContext,mshlflags,ppMarshal);
    *ppMarshal = HeapAlloc(GetProcessHeap(),0,sizeof(StdMarshalImpl));
    dm = (StdMarshalImpl*) *ppMarshal;
    if (!dm) return E_FAIL;
    dm->lpvtbl		= &VT_StdMarshal;
    dm->ref		= 1;

    dm->iid		= *riid;
    dm->dwDestContext	= dwDestContext;
    dm->pvDestContext	= pvDestContext;
    dm->mshlflags	= mshlflags;
    return S_OK;
1442 1443
}

1444 1445 1446 1447 1448 1449 1450 1451 1452 1453
/***********************************************************************
 *		get_marshaler	[internal]
 *
 * Retrieves an IMarshal interface for an object.
 */
static HRESULT get_marshaler(REFIID riid, IUnknown *pUnk, DWORD dwDestContext,
                             void *pvDestContext, DWORD mshlFlags,
                             LPMARSHAL *pMarshal)
{
    HRESULT hr;
1454

1455 1456 1457 1458 1459 1460 1461
    if (!pUnk)
        return E_POINTER;
    hr = IUnknown_QueryInterface(pUnk, &IID_IMarshal, (LPVOID*)pMarshal);
    if (hr)
        hr = CoGetStandardMarshal(riid, pUnk, dwDestContext, pvDestContext,
                                  mshlFlags, pMarshal);
    return hr;
1462 1463
}

1464 1465 1466 1467 1468 1469 1470
/***********************************************************************
 *		get_unmarshaler_from_stream	[internal]
 *
 * Creates an IMarshal* object according to the data marshaled to the stream.
 * The function leaves the stream pointer at the start of the data written
 * to the stream by the IMarshal* object.
 */
1471
static HRESULT get_unmarshaler_from_stream(IStream *stream, IMarshal **marshal, IID *iid)
1472 1473 1474 1475 1476 1477 1478 1479 1480
{
    HRESULT hr;
    ULONG res;
    OBJREF objref;

    /* read common OBJREF header */
    hr = IStream_Read(stream, &objref, FIELD_OFFSET(OBJREF, u_objref), &res);
    if (hr || (res != FIELD_OFFSET(OBJREF, u_objref)))
    {
1481
        ERR("Failed to read common OBJREF header, 0x%08x\n", hr);
1482 1483 1484 1485 1486 1487 1488 1489 1490 1491
        return STG_E_READFAULT;
    }

    /* sanity check on header */
    if (objref.signature != OBJREF_SIGNATURE)
    {
        ERR("Bad OBJREF signature 0x%08lx\n", objref.signature);
        return RPC_E_INVALID_OBJREF;
    }

1492 1493
    if (iid) *iid = objref.iid;

1494 1495 1496 1497 1498 1499 1500 1501
    /* FIXME: handler marshaling */
    if (objref.flags & OBJREF_STANDARD)
    {
        TRACE("Using standard unmarshaling\n");
        hr = StdMarshalImpl_Construct(&IID_IMarshal, (LPVOID*)marshal);
    }
    else if (objref.flags & OBJREF_CUSTOM)
    {
1502
        ULONG custom_header_size = FIELD_OFFSET(OBJREF, u_objref.u_custom.pData) - 
1503 1504 1505 1506 1507 1508 1509
                                   FIELD_OFFSET(OBJREF, u_objref.u_custom);
        TRACE("Using custom unmarshaling\n");
        /* read constant sized OR_CUSTOM data from stream */
        hr = IStream_Read(stream, &objref.u_objref.u_custom,
                          custom_header_size, &res);
        if (hr || (res != custom_header_size))
        {
1510
            ERR("Failed to read OR_CUSTOM header, 0x%08x\n", hr);
1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525
            return STG_E_READFAULT;
        }
        /* now create the marshaler specified in the stream */
        hr = CoCreateInstance(&objref.u_objref.u_custom.clsid, NULL,
                              CLSCTX_INPROC_SERVER, &IID_IMarshal,
                              (LPVOID*)marshal);
    }
    else
    {
        FIXME("Invalid or unimplemented marshaling type specified: %lx\n",
            objref.flags);
        return RPC_E_INVALID_OBJREF;
    }

    if (hr)
1526
        ERR("Failed to create marshal, 0x%08x\n", hr);
1527 1528 1529 1530

    return hr;
}

1531
/***********************************************************************
1532
 *		CoGetMarshalSizeMax	[OLE32.@]
1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549
 *
 * Gets the maximum amount of data that will be needed by a marshal.
 *
 * PARAMS
 *  pulSize       [O] Address where maximum marshal size will be stored.
 *  riid          [I] Identifier of the interface to marshal.
 *  pUnk          [I] Pointer to the object to marshal.
 *  dwDestContext [I] Destination. Used to enable or disable optimizations.
 *  pvDestContext [I] Reserved. Must be NULL.
 *  mshlFlags     [I] Flags that affect the marshaling. See CoMarshalInterface().
 *
 * RETURNS
 *  Success: S_OK.
 *  Failure: HRESULT code.
 *
 * SEE ALSO
 *  CoMarshalInterface().
1550
 */
1551 1552 1553 1554 1555 1556 1557 1558
HRESULT WINAPI CoGetMarshalSizeMax(ULONG *pulSize, REFIID riid, IUnknown *pUnk,
                                   DWORD dwDestContext, void *pvDestContext,
                                   DWORD mshlFlags)
{
    HRESULT hr;
    LPMARSHAL pMarshal;
    CLSID marshaler_clsid;

1559
    hr = get_marshaler(riid, pUnk, dwDestContext, pvDestContext, mshlFlags, &pMarshal);
1560 1561 1562 1563 1564 1565 1566
    if (hr)
        return hr;

    hr = IMarshal_GetUnmarshalClass(pMarshal, riid, pUnk, dwDestContext,
                                    pvDestContext, mshlFlags, &marshaler_clsid);
    if (hr)
    {
1567
        ERR("IMarshal::GetUnmarshalClass failed, 0x%08x\n", hr);
1568 1569 1570
        IMarshal_Release(pMarshal);
        return hr;
    }
1571

1572 1573
    hr = IMarshal_GetMarshalSizeMax(pMarshal, riid, pUnk, dwDestContext,
                                    pvDestContext, mshlFlags, pulSize);
1574 1575 1576 1577 1578 1579 1580
    if (IsEqualCLSID(&marshaler_clsid, &CLSID_DfMarshal))
        /* add on the size of the common header */
        *pulSize += FIELD_OFFSET(OBJREF, u_objref);
    else
        /* custom marshaling: add on the size of the whole OBJREF structure
         * like native does */
        *pulSize += sizeof(OBJREF);
1581 1582 1583

    IMarshal_Release(pMarshal);
    return hr;
1584 1585 1586
}


1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598
static void dump_MSHLFLAGS(MSHLFLAGS flags)
{
    if (flags & MSHLFLAGS_TABLESTRONG)
        TRACE(" MSHLFLAGS_TABLESTRONG");
    if (flags & MSHLFLAGS_TABLEWEAK)
        TRACE(" MSHLFLAGS_TABLEWEAK");
    if (!(flags & (MSHLFLAGS_TABLESTRONG|MSHLFLAGS_TABLEWEAK)))
        TRACE(" MSHLFLAGS_NORMAL");
    if (flags & MSHLFLAGS_NOPING)
        TRACE(" MSHLFLAGS_NOPING");
}

1599
/***********************************************************************
1600
 *		CoMarshalInterface	[OLE32.@]
1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629
 *
 * Marshals an interface into a stream so that the object can then be
 * unmarshaled from another COM apartment and used remotely.
 *
 * PARAMS
 *  pStream       [I] Stream the object will be marshaled into.
 *  riid          [I] Identifier of the interface to marshal.
 *  pUnk          [I] Pointer to the object to marshal.
 *  dwDestContext [I] Destination. Used to enable or disable optimizations.
 *  pvDestContext [I] Reserved. Must be NULL.
 *  mshlFlags     [I] Flags that affect the marshaling. See notes.
 *
 * RETURNS
 *  Success: S_OK.
 *  Failure: HRESULT code.
 *
 * NOTES
 *
 * The mshlFlags parameter can take one or more of the following flags:
 *| MSHLFLAGS_NORMAL - Unmarshal once, releases stub on last proxy release.
 *| MSHLFLAGS_TABLESTRONG - Unmarshal many, release when CoReleaseMarshalData() called.
 *| MSHLFLAGS_TABLEWEAK - Unmarshal many, releases stub on last proxy release.
 *| MSHLFLAGS_NOPING - No automatic garbage collection (and so reduces network traffic).
 *
 * If a marshaled object is not unmarshaled, then CoReleaseMarshalData() must
 * be called in order to release the resources used in the marshaling.
 *
 * SEE ALSO
 *  CoUnmarshalInterface(), CoReleaseMarshalData().
1630
 */
1631 1632 1633 1634 1635 1636 1637 1638 1639
HRESULT WINAPI CoMarshalInterface(IStream *pStream, REFIID riid, IUnknown *pUnk,
                                  DWORD dwDestContext, void *pvDestContext,
                                  DWORD mshlFlags)
{
    HRESULT	hr;
    CLSID marshaler_clsid;
    OBJREF objref;
    LPMARSHAL pMarshal;

1640
    TRACE("(%p, %s, %p, %x, %p,", pStream, debugstr_guid(riid), pUnk,
1641 1642 1643
        dwDestContext, pvDestContext);
    dump_MSHLFLAGS(mshlFlags);
    TRACE(")\n");
1644

1645
    if (!pUnk || !pStream)
1646 1647 1648 1649 1650 1651
        return E_INVALIDARG;

    objref.signature = OBJREF_SIGNATURE;
    objref.iid = *riid;

    /* get the marshaler for the specified interface */
1652
    hr = get_marshaler(riid, pUnk, dwDestContext, pvDestContext, mshlFlags, &pMarshal);
1653 1654
    if (hr)
    {
1655
        ERR("Failed to get marshaller, 0x%08x\n", hr);
1656 1657
        return hr;
    }
1658

1659 1660 1661 1662
    hr = IMarshal_GetUnmarshalClass(pMarshal, riid, pUnk, dwDestContext,
                                    pvDestContext, mshlFlags, &marshaler_clsid);
    if (hr)
    {
1663
        ERR("IMarshal::GetUnmarshalClass failed, 0x%08x\n", hr);
1664 1665
        goto cleanup;
    }
1666

1667 1668 1669 1670 1671
    /* FIXME: implement handler marshaling too */
    if (IsEqualCLSID(&marshaler_clsid, &CLSID_DfMarshal))
    {
        TRACE("Using standard marshaling\n");
        objref.flags = OBJREF_STANDARD;
1672 1673 1674 1675 1676

        /* write the common OBJREF header to the stream */
        hr = IStream_Write(pStream, &objref, FIELD_OFFSET(OBJREF, u_objref), NULL);
        if (hr)
        {
1677
            ERR("Failed to write OBJREF header to stream, 0x%08x\n", hr);
1678 1679
            goto cleanup;
        }
1680 1681 1682 1683 1684
    }
    else
    {
        TRACE("Using custom marshaling\n");
        objref.flags = OBJREF_CUSTOM;
1685 1686 1687 1688 1689 1690
        objref.u_objref.u_custom.clsid = marshaler_clsid;
        objref.u_objref.u_custom.cbExtension = 0;
        objref.u_objref.u_custom.size = 0;
        hr = IMarshal_GetMarshalSizeMax(pMarshal, riid, pUnk, dwDestContext,
                                        pvDestContext, mshlFlags,
                                        &objref.u_objref.u_custom.size);
1691 1692
        if (hr)
        {
1693
            ERR("Failed to get max size of marshal data, error 0x%08x\n", hr);
1694 1695 1696 1697 1698 1699 1700
            goto cleanup;
        }
        /* write constant sized common header and OR_CUSTOM data into stream */
        hr = IStream_Write(pStream, &objref,
                          FIELD_OFFSET(OBJREF, u_objref.u_custom.pData), NULL);
        if (hr)
        {
1701
            ERR("Failed to write OR_CUSTOM header to stream with 0x%08x\n", hr);
1702 1703 1704
            goto cleanup;
        }
    }
1705

1706 1707
    TRACE("Calling IMarshal::MarshalInterace\n");
    /* call helper object to do the actual marshaling */
1708
    hr = IMarshal_MarshalInterface(pMarshal, pStream, riid, pUnk, dwDestContext,
1709
                                   pvDestContext, mshlFlags);
1710

1711 1712
    if (hr)
    {
1713
        ERR("Failed to marshal the interface %s, %x\n", debugstr_guid(riid), hr);
1714 1715 1716 1717 1718
        goto cleanup;
    }

cleanup:
    IMarshal_Release(pMarshal);
1719

1720
    TRACE("completed with hr 0x%08x\n", hr);
1721
    
1722 1723
    return hr;
}
1724 1725

/***********************************************************************
1726
 *		CoUnmarshalInterface	[OLE32.@]
1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743
 *
 * Unmarshals an object from a stream by creating a proxy to the remote
 * object, if necessary.
 *
 * PARAMS
 *
 *  pStream [I] Stream containing the marshaled object.
 *  riid    [I] Interface identifier of the object to create a proxy to.
 *  ppv     [O] Address where proxy will be stored.
 *
 * RETURNS
 *
 *  Success: S_OK.
 *  Failure: HRESULT code.
 *
 * SEE ALSO
 *  CoMarshalInterface().
1744
 */
1745 1746
HRESULT WINAPI CoUnmarshalInterface(IStream *pStream, REFIID riid, LPVOID *ppv)
{
1747
    HRESULT hr;
1748
    LPMARSHAL pMarshal;
1749 1750
    IID iid;
    IUnknown *object;
1751

1752
    TRACE("(%p, %s, %p)\n", pStream, debugstr_guid(riid), ppv);
1753

1754 1755 1756
    if (!pStream || !ppv)
        return E_INVALIDARG;

1757
    hr = get_unmarshaler_from_stream(pStream, &pMarshal, &iid);
1758 1759 1760 1761
    if (hr != S_OK)
        return hr;

    /* call the helper object to do the actual unmarshaling */
1762
    hr = IMarshal_UnmarshalInterface(pMarshal, pStream, &iid, (LPVOID*)&object);
1763
    if (hr)
1764
        ERR("IMarshal::UnmarshalInterface failed, 0x%08x\n", hr);
1765

1766 1767
    if (hr == S_OK)
    {
1768 1769
        /* IID_NULL means use the interface ID of the marshaled object */
        if (!IsEqualIID(riid, &IID_NULL) && !IsEqualIID(riid, &iid))
1770 1771
        {
            TRACE("requested interface != marshalled interface, additional QI needed\n");
1772
            hr = IUnknown_QueryInterface(object, riid, ppv);
1773
            if (hr)
1774
                ERR("Couldn't query for interface %s, hr = 0x%08x\n",
1775 1776 1777 1778 1779 1780 1781
                    debugstr_guid(riid), hr);
            IUnknown_Release(object);
        }
        else
        {
            *ppv = object;
        }
1782 1783
    }

1784
    IMarshal_Release(pMarshal);
1785

1786
    TRACE("completed with hr 0x%x\n", hr);
1787
    
1788
    return hr;
1789 1790
}

1791 1792
/***********************************************************************
 *		CoReleaseMarshalData	[OLE32.@]
1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812
 *
 * Releases resources associated with an object that has been marshaled into
 * a stream.
 *
 * PARAMS
 *
 *  pStream [I] The stream that the object has been marshaled into.
 *
 * RETURNS
 *  Success: S_OK.
 *  Failure: HRESULT error code.
 *
 * NOTES
 * 
 * Call this function to release resources associated with a normal or
 * table-weak marshal that will not be unmarshaled, and all table-strong
 * marshals when they are no longer needed.
 *
 * SEE ALSO
 *  CoMarshalInterface(), CoUnmarshalInterface().
1813
 */
1814 1815 1816 1817
HRESULT WINAPI CoReleaseMarshalData(IStream *pStream)
{
    HRESULT	hr;
    LPMARSHAL pMarshal;
1818

1819
    TRACE("(%p)\n", pStream);
1820

1821
    hr = get_unmarshaler_from_stream(pStream, &pMarshal, NULL);
1822 1823 1824 1825 1826 1827
    if (hr != S_OK)
        return hr;

    /* call the helper object to do the releasing of marshal data */
    hr = IMarshal_ReleaseMarshalData(pMarshal, pStream);
    if (hr)
1828
        ERR("IMarshal::ReleaseMarshalData failed with error 0x%08x\n", hr);
1829 1830 1831

    IMarshal_Release(pMarshal);
    return hr;
1832 1833 1834
}


1835
/***********************************************************************
1836
 *		CoMarshalInterThreadInterfaceInStream	[OLE32.@]
1837
 *
1838 1839 1840 1841 1842
 * Marshal an interface across threads in the same process.
 *
 * PARAMS
 *  riid  [I] Identifier of the interface to be marshalled.
 *  pUnk  [I] Pointer to IUnknown-derived interface that will be marshalled.
Huw Davies's avatar
Huw Davies committed
1843
 *  ppStm [O] Pointer to IStream object that is created and then used to store the marshalled interface.
1844 1845 1846 1847 1848
 *
 * RETURNS
 *  Success: S_OK
 *  Failure: E_OUTOFMEMORY and other COM error codes
 *
1849
 * SEE ALSO
1850
 *   CoMarshalInterface(), CoUnmarshalInterface() and CoGetInterfaceAndReleaseStream()
1851
 */
1852 1853
HRESULT WINAPI CoMarshalInterThreadInterfaceInStream(
    REFIID riid, LPUNKNOWN pUnk, LPSTREAM * ppStm)
1854 1855 1856 1857
{
    ULARGE_INTEGER	xpos;
    LARGE_INTEGER		seekto;
    HRESULT		hres;
1858

1859 1860
    TRACE("(%s, %p, %p)\n",debugstr_guid(riid), pUnk, ppStm);

1861
    hres = CreateStreamOnHGlobal(NULL, TRUE, ppStm);
1862 1863 1864
    if (FAILED(hres)) return hres;
    hres = CoMarshalInterface(*ppStm, riid, pUnk, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);

1865 1866 1867
    if (SUCCEEDED(hres))
    {
        memset(&seekto, 0, sizeof(seekto));
1868
        IStream_Seek(*ppStm, seekto, STREAM_SEEK_SET, &xpos);
1869 1870 1871 1872 1873 1874
    }
    else
    {
        IStream_Release(*ppStm);
        *ppStm = NULL;
    }
1875 1876

    return hres;
1877 1878 1879
}

/***********************************************************************
1880
 *		CoGetInterfaceAndReleaseStream	[OLE32.@]
1881
 *
Huw Davies's avatar
Huw Davies committed
1882
 * Unmarshalls an interface from a stream and then releases the stream.
1883 1884
 *
 * PARAMS
Huw Davies's avatar
Huw Davies committed
1885
 *  pStm [I] Stream that contains the marshalled interface.
1886 1887 1888 1889 1890 1891 1892
 *  riid [I] Interface identifier of the object to unmarshall.
 *  ppv  [O] Address of pointer where the requested interface object will be stored.
 *
 * RETURNS
 *  Success: S_OK
 *  Failure: A COM error code
 *
1893
 * SEE ALSO
Huw Davies's avatar
Huw Davies committed
1894
 *  CoMarshalInterThreadInterfaceInStream() and CoUnmarshalInterface()
1895
 */
1896 1897
HRESULT WINAPI CoGetInterfaceAndReleaseStream(LPSTREAM pStm, REFIID riid,
                                              LPVOID *ppv)
1898 1899
{
    HRESULT hres;
1900

1901 1902
    TRACE("(%p, %s, %p)\n", pStm, debugstr_guid(riid), ppv);

1903
    if(!pStm) return E_INVALIDARG;
1904 1905 1906
    hres = CoUnmarshalInterface(pStm, riid, ppv);
    IStream_Release(pStm);
    return hres;
1907 1908
}

1909 1910 1911 1912 1913 1914 1915 1916 1917 1918
static HRESULT WINAPI StdMarshalCF_QueryInterface(LPCLASSFACTORY iface,
                                                  REFIID riid, LPVOID *ppv)
{
    *ppv = NULL;
    if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IClassFactory))
    {
        *ppv = (LPVOID)iface;
        return S_OK;
    }
    return E_NOINTERFACE;
1919 1920
}

1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933
static ULONG WINAPI StdMarshalCF_AddRef(LPCLASSFACTORY iface)
{
    return 2; /* non-heap based object */
}

static ULONG WINAPI StdMarshalCF_Release(LPCLASSFACTORY iface)
{
    return 1; /* non-heap based object */
}

static HRESULT WINAPI StdMarshalCF_CreateInstance(LPCLASSFACTORY iface,
    LPUNKNOWN pUnk, REFIID riid, LPVOID *ppv)
{
1934 1935
    if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IMarshal))
        return StdMarshalImpl_Construct(riid, ppv);
1936

1937 1938
    FIXME("(%s), not supported.\n",debugstr_guid(riid));
    return E_NOINTERFACE;
1939 1940
}

1941 1942
static HRESULT WINAPI StdMarshalCF_LockServer(LPCLASSFACTORY iface, BOOL fLock)
{
1943 1944 1945 1946
    FIXME("(%d), stub!\n",fLock);
    return S_OK;
}

1947
static const IClassFactoryVtbl StdMarshalCFVtbl =
1948 1949 1950 1951 1952 1953
{
    StdMarshalCF_QueryInterface,
    StdMarshalCF_AddRef,
    StdMarshalCF_Release,
    StdMarshalCF_CreateInstance,
    StdMarshalCF_LockServer
1954
};
1955
static const IClassFactoryVtbl *StdMarshalCF = &StdMarshalCFVtbl;
1956

1957 1958 1959 1960
HRESULT MARSHAL_GetStandardMarshalCF(LPVOID *ppv)
{
    *ppv = &StdMarshalCF;
    return S_OK;
1961
}
1962 1963 1964 1965 1966 1967 1968

/***********************************************************************
 *		CoMarshalHresult	[OLE32.@]
 *
 * Marshals an HRESULT value into a stream.
 *
 * PARAMS
1969 1970
 *  pStm    [I] Stream that hresult will be marshalled into.
 *  hresult [I] HRESULT to be marshalled.
1971 1972 1973 1974 1975
 *
 * RETURNS
 *  Success: S_OK
 *  Failure: A COM error code
 *
1976
 * SEE ALSO
1977 1978
 *  CoUnmarshalHresult().
 */
1979
HRESULT WINAPI CoMarshalHresult(LPSTREAM pStm, HRESULT hresult)
1980 1981 1982 1983 1984 1985 1986 1987 1988 1989
{
    return IStream_Write(pStm, &hresult, sizeof(hresult), NULL);
}

/***********************************************************************
 *		CoUnmarshalHresult	[OLE32.@]
 *
 * Unmarshals an HRESULT value from a stream.
 *
 * PARAMS
1990 1991
 *  pStm     [I] Stream that hresult will be unmarshalled from.
 *  phresult [I] Pointer to HRESULT where the value will be unmarshalled to.
1992 1993 1994 1995 1996
 *
 * RETURNS
 *  Success: S_OK
 *  Failure: A COM error code
 *
1997
 * SEE ALSO
1998 1999
 *  CoMarshalHresult().
 */
2000
HRESULT WINAPI CoUnmarshalHresult(LPSTREAM pStm, HRESULT * phresult)
2001 2002 2003
{
    return IStream_Read(pStm, phresult, sizeof(*phresult), NULL);
}