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