dlls/ole32/stubmanager.c

   1 /*
   2  * A stub manager is an object that controls interface stubs. It is
   3  * identified by an OID (object identifier) and acts as the network
   4  * identity of the object. There can be many stub managers in a
   5  * process or apartment.
   6  *
   7  * Copyright 2002 Marcus Meissner
   8  * Copyright 2004 Mike Hearn for CodeWeavers
   9  * Copyright 2004 Robert Shearman (for CodeWeavers)
  10  *
  11  * This library is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2.1 of the License, or (at your option) any later version.
  15  *
  16  * This library is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public
  22  * License along with this library; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  24  */
  25
  26 #define COBJMACROS
  27 #define NONAMELESSUNION
  28 #define NONAMELESSSTRUCT
  29
  30 #include <assert.h>
  31 #include <stdarg.h>
  32 #include <limits.h>
  33
  34 #include "windef.h"
  35 #include "winbase.h"
  36 #include "winuser.h"
  37 #include "objbase.h"
  38 #include "rpc.h"
  39
  40 #include "wine/debug.h"
  41 #include "compobj_private.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  44
  45
  46 /* generates an ipid in the following format (similar to native version):
  47  * Data1 = apartment-local ipid counter
  48  * Data2 = apartment creator thread ID
  49  * Data3 = process ID
  50  * Data4 = random value
  51  */
  52 static inline HRESULT generate_ipid(struct stub_manager *m, IPID *ipid)
  53 {
  54     HRESULT hr;
  55     hr = UuidCreate(ipid);
  56     if (FAILED(hr))
  57     {
  58         ERR("couldn't create IPID for stub manager %p\n", m);
  59         UuidCreateNil(ipid);
  60         return hr;
  61     }
  62
  63     ipid->Data1 = InterlockedIncrement(&m->apt->ipidc);
  64     ipid->Data2 = (USHORT)m->apt->tid;
  65     ipid->Data3 = (USHORT)GetCurrentProcessId();
  66     return S_OK;
  67 }
  68
  69 /* registers a new interface stub COM object with the stub manager and returns registration record */
  70 struct ifstub *stub_manager_new_ifstub(struct stub_manager *m, IRpcStubBuffer *sb, IUnknown *iptr, REFIID iid, DWORD dest_context,
  71     void *dest_context_data, MSHLFLAGS flags)
  72 {
  73     struct ifstub *stub;
  74     HRESULT hr;
  75
  76     TRACE("oid=%s, stubbuffer=%p, iptr=%p, iid=%s\n",
  77           wine_dbgstr_longlong(m->oid), sb, iptr, debugstr_guid(iid));
  78
  79     stub = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct ifstub));
  80     if (!stub) return NULL;
  81
  82     hr = RPC_CreateServerChannel(dest_context, dest_context_data, &stub->chan);
  83     if (hr != S_OK)
  84     {
  85         HeapFree(GetProcessHeap(), 0, stub);
  86         return NULL;
  87     }
  88
  89     stub->stubbuffer = sb;
  90     if (sb) IRpcStubBuffer_AddRef(sb);
  91
  92     IUnknown_AddRef(iptr);
  93     stub->iface = iptr;
  94     stub->flags = flags;
  95     stub->iid = *iid;
  96
  97     /* FIXME: find a cleaner way of identifying that we are creating an ifstub
  98      * for the remunknown interface */
  99     if (flags & MSHLFLAGSP_REMUNKNOWN)
 100         stub->ipid = m->oxid_info.ipidRemUnknown;
 101     else
 102         generate_ipid(m, &stub->ipid);
 103
 104     EnterCriticalSection(&m->lock);
 105     list_add_head(&m->ifstubs, &stub->entry);
 106     /* every normal marshal is counted so we don't allow more than we should */
 107     if (flags & MSHLFLAGS_NORMAL) m->norm_refs++;
 108     LeaveCriticalSection(&m->lock);
 109
 110     TRACE("ifstub %p created with ipid %s\n", stub, debugstr_guid(&stub->ipid));
 111
 112     return stub;
 113 }
 114
 115 static void stub_manager_delete_ifstub(struct stub_manager *m, struct ifstub *ifstub)
 116 {
 117     TRACE("m=%p, m->oid=%s, ipid=%s\n", m, wine_dbgstr_longlong(m->oid), debugstr_guid(&ifstub->ipid));
 118
 119     list_remove(&ifstub->entry);
 120
 121     RPC_UnregisterInterface(&ifstub->iid);
 122
 123     if (ifstub->stubbuffer) IRpcStubBuffer_Release(ifstub->stubbuffer);
 124     IUnknown_Release(ifstub->iface);
 125     IRpcChannelBuffer_Release(ifstub->chan);
 126
 127     HeapFree(GetProcessHeap(), 0, ifstub);
 128 }
 129
 130 static struct ifstub *stub_manager_ipid_to_ifstub(struct stub_manager *m, const IPID *ipid)
 131 {
 132     struct list    *cursor;
 133     struct ifstub  *result = NULL;
 134
 135     EnterCriticalSection(&m->lock);
 136     LIST_FOR_EACH( cursor, &m->ifstubs )
 137     {
 138         struct ifstub *ifstub = LIST_ENTRY( cursor, struct ifstub, entry );
 139
 140         if (IsEqualGUID(ipid, &ifstub->ipid))
 141         {
 142             result = ifstub;
 143             break;
 144         }
 145     }
 146     LeaveCriticalSection(&m->lock);
 147
 148     return result;
 149 }
 150
 151 struct ifstub *stub_manager_find_ifstub(struct stub_manager *m, REFIID iid, MSHLFLAGS flags)
 152 {
 153     struct ifstub  *result = NULL;
 154     struct ifstub  *ifstub;
 155
 156     EnterCriticalSection(&m->lock);
 157     LIST_FOR_EACH_ENTRY( ifstub, &m->ifstubs, struct ifstub, entry )
 158     {
 159         if (IsEqualIID(iid, &ifstub->iid) && (ifstub->flags == flags))
 160         {
 161             result = ifstub;
 162             break;
 163         }
 164     }
 165     LeaveCriticalSection(&m->lock);
 166
 167     return result;
 168 }
 169
 170 /* creates a new stub manager and adds it into the apartment. caller must
 171  * release stub manager when it is no longer required. the apartment and
 172  * external refs together take one implicit ref */
 173 struct stub_manager *new_stub_manager(APARTMENT *apt, IUnknown *object)
 174 {
 175     struct stub_manager *sm;
 176     HRESULT hres;
 177
 178     assert( apt );
 179
 180     sm = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct stub_manager));
 181     if (!sm) return NULL;
 182
 183     list_init(&sm->ifstubs);
 184
 185     InitializeCriticalSection(&sm->lock);
 186     DEBUG_SET_CRITSEC_NAME(&sm->lock, "stub_manager");
 187
 188     IUnknown_AddRef(object);
 189     sm->object = object;
 190     sm->apt    = apt;
 191
 192     /* start off with 2 references because the stub is in the apartment
 193      * and the caller will also hold a reference */
 194     sm->refs   = 2;
 195     sm->weakrefs = 0;
 196
 197     sm->oxid_info.dwPid = GetCurrentProcessId();
 198     sm->oxid_info.dwTid = GetCurrentThreadId();
 199     /*
 200      * FIXME: this is a hack for marshalling IRemUnknown. In real
 201      * DCOM, the IPID of the IRemUnknown interface is generated like
 202      * any other and passed to the OXID resolver which then returns it
 203      * when queried. We don't have an OXID resolver yet so instead we
 204      * use a magic IPID reserved for IRemUnknown.
 205      */
 206     sm->oxid_info.ipidRemUnknown.Data1 = 0xffffffff;
 207     sm->oxid_info.ipidRemUnknown.Data2 = 0xffff;
 208     sm->oxid_info.ipidRemUnknown.Data3 = 0xffff;
 209     assert(sizeof(sm->oxid_info.ipidRemUnknown.Data4) == sizeof(apt->oxid));
 210     memcpy(sm->oxid_info.ipidRemUnknown.Data4, &apt->oxid, sizeof(OXID));
 211     sm->oxid_info.dwAuthnHint = RPC_C_AUTHN_LEVEL_NONE;
 212     sm->oxid_info.psa = NULL /* FIXME */;
 213
 214     /* Yes, that's right, this starts at zero. that's zero EXTERNAL
 215      * refs, i.e., nobody has unmarshalled anything yet. We can't have
 216      * negative refs because the stub manager cannot be explicitly
 217      * killed, it has to die by somebody unmarshalling then releasing
 218      * the marshalled ifptr.
 219      */
 220     sm->extrefs = 0;
 221
 222     hres = IUnknown_QueryInterface(object, &IID_IExternalConnection, (void**)&sm->extern_conn);
 223     if(FAILED(hres))
 224         sm->extern_conn = NULL;
 225
 226     EnterCriticalSection(&apt->cs);
 227     sm->oid = apt->oidc++;
 228     list_add_head(&apt->stubmgrs, &sm->entry);
 229     LeaveCriticalSection(&apt->cs);
 230
 231     TRACE("Created new stub manager (oid=%s) at %p for object with IUnknown %p\n", wine_dbgstr_longlong(sm->oid), sm, object);
 232
 233     return sm;
 234 }
 235
 236 /* caller must remove stub manager from apartment prior to calling this function */
 237 static void stub_manager_delete(struct stub_manager *m)
 238 {
 239     struct list *cursor;
 240
 241     TRACE("destroying %p (oid=%s)\n", m, wine_dbgstr_longlong(m->oid));
 242
 243     /* release every ifstub */
 244     while ((cursor = list_head(&m->ifstubs)))
 245     {
 246         struct ifstub *ifstub = LIST_ENTRY(cursor, struct ifstub, entry);
 247         stub_manager_delete_ifstub(m, ifstub);
 248     }
 249
 250     if(m->extern_conn)
 251         IExternalConnection_Release(m->extern_conn);
 252
 253     CoTaskMemFree(m->oxid_info.psa);
 254     IUnknown_Release(m->object);
 255
 256     DEBUG_CLEAR_CRITSEC_NAME(&m->lock);
 257     DeleteCriticalSection(&m->lock);
 258
 259     HeapFree(GetProcessHeap(), 0, m);
 260 }
 261
 262 /* increments the internal refcount */
 263 static ULONG stub_manager_int_addref(struct stub_manager *This)
 264 {
 265     ULONG refs;
 266
 267     EnterCriticalSection(&This->apt->cs);
 268     refs = ++This->refs;
 269     LeaveCriticalSection(&This->apt->cs);
 270
 271     TRACE("before %d\n", refs - 1);
 272
 273     return refs;
 274 }
 275
 276 /* decrements the internal refcount */
 277 ULONG stub_manager_int_release(struct stub_manager *This)
 278 {
 279     ULONG refs;
 280     APARTMENT *apt = This->apt;
 281
 282     EnterCriticalSection(&apt->cs);
 283     refs = --This->refs;
 284
 285     TRACE("after %d\n", refs);
 286
 287     /* remove from apartment so no other thread can access it... */
 288     if (!refs)
 289         list_remove(&This->entry);
 290
 291     LeaveCriticalSection(&apt->cs);
 292
 293     /* ... so now we can delete it without being inside the apartment critsec */
 294     if (!refs)
 295         stub_manager_delete(This);
 296
 297     return refs;
 298 }
 299
 300 /* gets the stub manager associated with an object - caller must have
 301  * a reference to the apartment while a reference to the stub manager is held.
 302  * it must also call release on the stub manager when it is no longer needed */
 303 struct stub_manager *get_stub_manager_from_object(APARTMENT *apt, void *object)
 304 {
 305     struct stub_manager *result = NULL;
 306     struct list         *cursor;
 307
 308     EnterCriticalSection(&apt->cs);
 309     LIST_FOR_EACH( cursor, &apt->stubmgrs )
 310     {
 311         struct stub_manager *m = LIST_ENTRY( cursor, struct stub_manager, entry );
 312
 313         if (m->object == object)
 314         {
 315             result = m;
 316             stub_manager_int_addref(result);
 317             break;
 318         }
 319     }
 320     LeaveCriticalSection(&apt->cs);
 321
 322     if (result)
 323         TRACE("found %p for object %p\n", result, object);
 324     else
 325         TRACE("not found for object %p\n", object);
 326
 327     return result;
 328 }
 329
 330 /* removes the apartment reference to an object, destroying it when no other
 331  * threads have a reference to it */
 332 void apartment_disconnectobject(struct apartment *apt, void *object)
 333 {
 334     BOOL found = FALSE;
 335     struct stub_manager *stubmgr;
 336
 337     EnterCriticalSection(&apt->cs);
 338     LIST_FOR_EACH_ENTRY( stubmgr, &apt->stubmgrs, struct stub_manager, entry )
 339     {
 340         if (stubmgr->object == object)
 341         {
 342             found = TRUE;
 343             stub_manager_int_release(stubmgr);
 344             break;
 345         }
 346     }
 347     LeaveCriticalSection(&apt->cs);
 348
 349     if (found)
 350         TRACE("disconnect object %p\n", object);
 351     else
 352         WARN("couldn't find object %p\n", object);
 353 }
 354
 355 /* gets the stub manager associated with an object id - caller must have
 356  * a reference to the apartment while a reference to the stub manager is held.
 357  * it must also call release on the stub manager when it is no longer needed */
 358 struct stub_manager *get_stub_manager(APARTMENT *apt, OID oid)
 359 {
 360     struct stub_manager *result = NULL;
 361     struct list         *cursor;
 362
 363     EnterCriticalSection(&apt->cs);
 364     LIST_FOR_EACH( cursor, &apt->stubmgrs )
 365     {
 366         struct stub_manager *m = LIST_ENTRY( cursor, struct stub_manager, entry );
 367
 368         if (m->oid == oid)
 369         {
 370             result = m;
 371             stub_manager_int_addref(result);
 372             break;
 373         }
 374     }
 375     LeaveCriticalSection(&apt->cs);
 376
 377     if (result)
 378         TRACE("found %p for oid %s\n", result, wine_dbgstr_longlong(oid));
 379     else
 380         TRACE("not found for oid %s\n", wine_dbgstr_longlong(oid));
 381
 382     return result;
 383 }
 384
 385 /* add some external references (ie from a client that unmarshaled an ifptr) */
 386 ULONG stub_manager_ext_addref(struct stub_manager *m, ULONG refs, BOOL tableweak)
 387 {
 388     BOOL first_extern_ref;
 389     ULONG rc;
 390
 391     EnterCriticalSection(&m->lock);
 392
 393     first_extern_ref = refs && !m->extrefs;
 394
 395     /* make sure we don't overflow extrefs */
 396     refs = min(refs, (ULONG_MAX-1 - m->extrefs));
 397     rc = (m->extrefs += refs);
 398
 399     if (tableweak)
 400         rc += ++m->weakrefs;
 401
 402     LeaveCriticalSection(&m->lock);
 403
 404     TRACE("added %u refs to %p (oid %s), rc is now %u\n", refs, m, wine_dbgstr_longlong(m->oid), rc);
 405
 406     /*
 407      * NOTE: According to tests, creating a stub causes two AddConnection calls followed by
 408      * one ReleaseConnection call (with fLastReleaseCloses=FALSE).
 409      */
 410     if(first_extern_ref && m->extern_conn)
 411         IExternalConnection_AddConnection(m->extern_conn, EXTCONN_STRONG, 0);
 412
 413     return rc;
 414 }
 415
 416 /* remove some external references */
 417 ULONG stub_manager_ext_release(struct stub_manager *m, ULONG refs, BOOL tableweak, BOOL last_unlock_releases)
 418 {
 419     BOOL last_extern_ref;
 420     ULONG rc;
 421
 422     EnterCriticalSection(&m->lock);
 423
 424     /* make sure we don't underflow extrefs */
 425     refs = min(refs, m->extrefs);
 426     rc = (m->extrefs -= refs);
 427
 428     if (tableweak)
 429         --m->weakrefs;
 430     if (!last_unlock_releases)
 431         rc += m->weakrefs;
 432
 433     last_extern_ref = refs && !m->extrefs;
 434
 435     LeaveCriticalSection(&m->lock);
 436
 437     TRACE("removed %u refs from %p (oid %s), rc is now %u\n", refs, m, wine_dbgstr_longlong(m->oid), rc);
 438
 439     if (last_extern_ref && m->extern_conn)
 440         IExternalConnection_ReleaseConnection(m->extern_conn, EXTCONN_STRONG, 0, last_unlock_releases);
 441
 442     if (rc == 0)
 443         if (!(m->extern_conn && last_unlock_releases && m->weakrefs))
 444             stub_manager_int_release(m);
 445
 446     return rc;
 447 }
 448
 449 /* gets the stub manager associated with an ipid - caller must have
 450  * a reference to the apartment while a reference to the stub manager is held.
 451  * it must also call release on the stub manager when it is no longer needed */
 452 static struct stub_manager *get_stub_manager_from_ipid(APARTMENT *apt, const IPID *ipid)
 453 {
 454     struct stub_manager *result = NULL;
 455     struct list         *cursor;
 456
 457     EnterCriticalSection(&apt->cs);
 458     LIST_FOR_EACH( cursor, &apt->stubmgrs )
 459     {
 460         struct stub_manager *m = LIST_ENTRY( cursor, struct stub_manager, entry );
 461
 462         if (stub_manager_ipid_to_ifstub(m, ipid))
 463         {
 464             result = m;
 465             stub_manager_int_addref(result);
 466             break;
 467         }
 468     }
 469     LeaveCriticalSection(&apt->cs);
 470
 471     if (result)
 472         TRACE("found %p for ipid %s\n", result, debugstr_guid(ipid));
 473     else
 474         ERR("not found for ipid %s\n", debugstr_guid(ipid));
 475
 476     return result;
 477 }
 478
 479 static HRESULT ipid_to_stub_manager(const IPID *ipid, APARTMENT **stub_apt, struct stub_manager **stubmgr_ret)
 480 {
 481     /* FIXME: hack for IRemUnknown */
 482     if (ipid->Data2 == 0xffff)
 483         *stub_apt = apartment_findfromoxid(*(const OXID *)ipid->Data4, TRUE);
 484     else
 485         *stub_apt = apartment_findfromtid(ipid->Data2);
 486     if (!*stub_apt)
 487     {
 488         TRACE("Couldn't find apartment corresponding to TID 0x%04x\n", ipid->Data2);
 489         return RPC_E_INVALID_OBJECT;
 490     }
 491     *stubmgr_ret = get_stub_manager_from_ipid(*stub_apt, ipid);
 492     if (!*stubmgr_ret)
 493     {
 494         apartment_release(*stub_apt);
 495         *stub_apt = NULL;
 496         return RPC_E_INVALID_OBJECT;
 497     }
 498     return S_OK;
 499 }
 500
 501 /* gets the apartment, stub and channel of an object. the caller must
 502  * release the references to all objects (except iface) if the function
 503  * returned success, otherwise no references are returned. */
 504 HRESULT ipid_get_dispatch_params(const IPID *ipid, APARTMENT **stub_apt,
 505                                  IRpcStubBuffer **stub, IRpcChannelBuffer **chan,
 506                                  IID *iid, IUnknown **iface)
 507 {
 508     struct stub_manager *stubmgr;
 509     struct ifstub *ifstub;
 510     APARTMENT *apt;
 511     HRESULT hr;
 512
 513     hr = ipid_to_stub_manager(ipid, &apt, &stubmgr);
 514     if (hr != S_OK) return RPC_E_DISCONNECTED;
 515
 516     ifstub = stub_manager_ipid_to_ifstub(stubmgr, ipid);
 517     if (ifstub)
 518     {
 519         *stub = ifstub->stubbuffer;
 520         IRpcStubBuffer_AddRef(*stub);
 521         *chan = ifstub->chan;
 522         IRpcChannelBuffer_AddRef(*chan);
 523         *stub_apt = apt;
 524         *iid = ifstub->iid;
 525         *iface = ifstub->iface;
 526
 527         stub_manager_int_release(stubmgr);
 528         return S_OK;
 529     }
 530     else
 531     {
 532         stub_manager_int_release(stubmgr);
 533         apartment_release(apt);
 534         return RPC_E_DISCONNECTED;
 535     }
 536 }
 537
 538 /* returns TRUE if it is possible to unmarshal, FALSE otherwise. */
 539 BOOL stub_manager_notify_unmarshal(struct stub_manager *m, const IPID *ipid)
 540 {
 541     BOOL ret = TRUE;
 542     struct ifstub *ifstub;
 543
 544     if (!(ifstub = stub_manager_ipid_to_ifstub(m, ipid)))
 545     {
 546         ERR("attempted unmarshal of unknown IPID %s\n", debugstr_guid(ipid));
 547         return FALSE;
 548     }
 549
 550     EnterCriticalSection(&m->lock);
 551
 552     /* track normal marshals so we can enforce rules whilst in-process */
 553     if (ifstub->flags & MSHLFLAGS_NORMAL)
 554     {
 555         if (m->norm_refs)
 556             m->norm_refs--;
 557         else
 558         {
 559             ERR("attempted invalid normal unmarshal, norm_refs is zero\n");
 560             ret = FALSE;
 561         }
 562     }
 563
 564     LeaveCriticalSection(&m->lock);
 565
 566     return ret;
 567 }
 568
 569 /* handles refcounting for CoReleaseMarshalData */
 570 void stub_manager_release_marshal_data(struct stub_manager *m, ULONG refs, const IPID *ipid, BOOL tableweak)
 571 {
 572     struct ifstub *ifstub;
 573
 574     if (!(ifstub = stub_manager_ipid_to_ifstub(m, ipid)))
 575         return;
 576
 577     if (ifstub->flags & MSHLFLAGS_TABLEWEAK)
 578         refs = 0;
 579     else if (ifstub->flags & MSHLFLAGS_TABLESTRONG)
 580         refs = 1;
 581
 582     stub_manager_ext_release(m, refs, tableweak, !tableweak);
 583 }
 584
 585 /* is an ifstub table marshaled? */
 586 BOOL stub_manager_is_table_marshaled(struct stub_manager *m, const IPID *ipid)
 587 {
 588     struct ifstub *ifstub = stub_manager_ipid_to_ifstub(m, ipid);
 589
 590     assert( ifstub );
 591
 592     return ifstub->flags & (MSHLFLAGS_TABLESTRONG | MSHLFLAGS_TABLEWEAK);
 593 }
 594
 595
 596 /*****************************************************************************
 597  *
 598  * IRemUnknown implementation
 599  *
 600  *
 601  * Note: this object is not related to the lifetime of a stub_manager, but it
 602  * interacts with stub managers.
 603  */
 604
 605 typedef struct rem_unknown
 606 {
 607     IRemUnknown IRemUnknown_iface;
 608     LONG refs;
 609 } RemUnknown;
 610
 611 static const IRemUnknownVtbl RemUnknown_Vtbl;
 612
 613 static inline RemUnknown *impl_from_IRemUnknown(IRemUnknown *iface)
 614 {
 615     return CONTAINING_RECORD(iface, RemUnknown, IRemUnknown_iface);
 616 }
 617
 618
 619 /* construct an IRemUnknown object with one outstanding reference */
 620 static HRESULT RemUnknown_Construct(IRemUnknown **ppRemUnknown)
 621 {
 622     RemUnknown *This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 623
 624     if (!This) return E_OUTOFMEMORY;
 625
 626     This->IRemUnknown_iface.lpVtbl = &RemUnknown_Vtbl;
 627     This->refs = 1;
 628
 629     *ppRemUnknown = &This->IRemUnknown_iface;
 630     return S_OK;
 631 }
 632
 633 static HRESULT WINAPI RemUnknown_QueryInterface(IRemUnknown *iface, REFIID riid, void **ppv)
 634 {
 635     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
 636
 637     if (IsEqualIID(riid, &IID_IUnknown) ||
 638         IsEqualIID(riid, &IID_IRemUnknown))
 639     {
 640         *ppv = iface;
 641         IRemUnknown_AddRef(iface);
 642         return S_OK;
 643     }
 644
 645     FIXME("No interface for iid %s\n", debugstr_guid(riid));
 646
 647     *ppv = NULL;
 648     return E_NOINTERFACE;
 649 }
 650
 651 static ULONG WINAPI RemUnknown_AddRef(IRemUnknown *iface)
 652 {
 653     ULONG refs;
 654     RemUnknown *This = impl_from_IRemUnknown(iface);
 655
 656     refs = InterlockedIncrement(&This->refs);
 657
 658     TRACE("%p before: %d\n", iface, refs-1);
 659     return refs;
 660 }
 661
 662 static ULONG WINAPI RemUnknown_Release(IRemUnknown *iface)
 663 {
 664     ULONG refs;
 665     RemUnknown *This = impl_from_IRemUnknown(iface);
 666
 667     refs = InterlockedDecrement(&This->refs);
 668     if (!refs)
 669         HeapFree(GetProcessHeap(), 0, This);
 670
 671     TRACE("%p after: %d\n", iface, refs);
 672     return refs;
 673 }
 674
 675 static HRESULT WINAPI RemUnknown_RemQueryInterface(IRemUnknown *iface,
 676     REFIPID ripid, ULONG cRefs, USHORT cIids, IID *iids /* [size_is(cIids)] */,
 677     REMQIRESULT **ppQIResults /* [size_is(,cIids)] */)
 678 {
 679     HRESULT hr;
 680     USHORT i;
 681     USHORT successful_qis = 0;
 682     APARTMENT *apt;
 683     struct stub_manager *stubmgr;
 684
 685     TRACE("(%p)->(%s, %d, %d, %p, %p)\n", iface, debugstr_guid(ripid), cRefs, cIids, iids, ppQIResults);
 686
 687     hr = ipid_to_stub_manager(ripid, &apt, &stubmgr);
 688     if (hr != S_OK) return hr;
 689
 690     *ppQIResults = CoTaskMemAlloc(sizeof(REMQIRESULT) * cIids);
 691
 692     for (i = 0; i < cIids; i++)
 693     {
 694         HRESULT hrobj = marshal_object(apt, &(*ppQIResults)[i].std, &iids[i],
 695                                        stubmgr->object, MSHCTX_DIFFERENTMACHINE, NULL, MSHLFLAGS_NORMAL);
 696         if (hrobj == S_OK)
 697             successful_qis++;
 698         (*ppQIResults)[i].hResult = hrobj;
 699     }
 700
 701     stub_manager_int_release(stubmgr);
 702     apartment_release(apt);
 703
 704     if (successful_qis == cIids)
 705         return S_OK; /* we got all requested interfaces */
 706     else if (successful_qis == 0)
 707         return E_NOINTERFACE; /* we didn't get any interfaces */
 708     else
 709         return S_FALSE; /* we got some interfaces */
 710 }
 711
 712 static HRESULT WINAPI RemUnknown_RemAddRef(IRemUnknown *iface,
 713     USHORT cInterfaceRefs,
 714     REMINTERFACEREF* InterfaceRefs /* [size_is(cInterfaceRefs)] */,
 715     HRESULT *pResults /* [size_is(cInterfaceRefs)] */)
 716 {
 717     HRESULT hr = S_OK;
 718     USHORT i;
 719
 720     TRACE("(%p)->(%d, %p, %p)\n", iface, cInterfaceRefs, InterfaceRefs, pResults);
 721
 722     for (i = 0; i < cInterfaceRefs; i++)
 723     {
 724         APARTMENT *apt;
 725         struct stub_manager *stubmgr;
 726
 727         pResults[i] = ipid_to_stub_manager(&InterfaceRefs[i].ipid, &apt, &stubmgr);
 728         if (pResults[i] != S_OK)
 729         {
 730             hr = S_FALSE;
 731             continue;
 732         }
 733
 734         stub_manager_ext_addref(stubmgr, InterfaceRefs[i].cPublicRefs, FALSE);
 735         if (InterfaceRefs[i].cPrivateRefs)
 736             FIXME("Adding %d refs securely not implemented\n", InterfaceRefs[i].cPrivateRefs);
 737
 738         stub_manager_int_release(stubmgr);
 739         apartment_release(apt);
 740     }
 741
 742     return hr;
 743 }
 744
 745 static HRESULT WINAPI RemUnknown_RemRelease(IRemUnknown *iface,
 746     USHORT cInterfaceRefs,
 747     REMINTERFACEREF* InterfaceRefs /* [size_is(cInterfaceRefs)] */)
 748 {
 749     HRESULT hr = S_OK;
 750     USHORT i;
 751
 752     TRACE("(%p)->(%d, %p)\n", iface, cInterfaceRefs, InterfaceRefs);
 753
 754     for (i = 0; i < cInterfaceRefs; i++)
 755     {
 756         APARTMENT *apt;
 757         struct stub_manager *stubmgr;
 758
 759         hr = ipid_to_stub_manager(&InterfaceRefs[i].ipid, &apt, &stubmgr);
 760         if (hr != S_OK)
 761         {
 762             hr = E_INVALIDARG;
 763             /* FIXME: we should undo any changes already made in this function */
 764             break;
 765         }
 766
 767         stub_manager_ext_release(stubmgr, InterfaceRefs[i].cPublicRefs, FALSE, TRUE);
 768         if (InterfaceRefs[i].cPrivateRefs)
 769             FIXME("Releasing %d refs securely not implemented\n", InterfaceRefs[i].cPrivateRefs);
 770
 771         stub_manager_int_release(stubmgr);
 772         apartment_release(apt);
 773     }
 774
 775     return hr;
 776 }
 777
 778 static const IRemUnknownVtbl RemUnknown_Vtbl =
 779 {
 780     RemUnknown_QueryInterface,
 781     RemUnknown_AddRef,
 782     RemUnknown_Release,
 783     RemUnknown_RemQueryInterface,
 784     RemUnknown_RemAddRef,
 785     RemUnknown_RemRelease
 786 };
 787
 788 /* starts the IRemUnknown listener for the current apartment */
 789 HRESULT start_apartment_remote_unknown(void)
 790 {
 791     IRemUnknown *pRemUnknown;
 792     HRESULT hr = S_OK;
 793     APARTMENT *apt = COM_CurrentApt();
 794
 795     EnterCriticalSection(&apt->cs);
 796     if (!apt->remunk_exported)
 797     {
 798         /* create the IRemUnknown object */
 799         hr = RemUnknown_Construct(&pRemUnknown);
 800         if (hr == S_OK)
 801         {
 802             STDOBJREF stdobjref; /* dummy - not used */
 803             /* register it with the stub manager */
 804             hr = marshal_object(apt, &stdobjref, &IID_IRemUnknown, (IUnknown *)pRemUnknown, MSHCTX_DIFFERENTMACHINE, NULL, MSHLFLAGS_NORMAL|MSHLFLAGSP_REMUNKNOWN);
 805             /* release our reference to the object as the stub manager will manage the life cycle for us */
 806             IRemUnknown_Release(pRemUnknown);
 807             if (hr == S_OK)
 808                 apt->remunk_exported = TRUE;
 809         }
 810     }
 811     LeaveCriticalSection(&apt->cs);
 812     return hr;
 813 }