Made the Drag&Drop cursors' rubber band visible on a white background.
[wine] / 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 and IRpcStubBuffer from an object. the caller must
369  * release the references to both objects */
370 IRpcStubBuffer *ipid_to_apt_and_stubbuffer(const IPID *ipid, APARTMENT **stub_apt)
371 {
372     IRpcStubBuffer *ret = NULL;
373     struct stub_manager *stubmgr;
374     struct ifstub *ifstub;
375     HRESULT hr;
376
377     *stub_apt = NULL;
378
379     hr = ipid_to_stub_manager(ipid, stub_apt, &stubmgr);
380     if (hr != S_OK) return NULL;
381
382     ifstub = stub_manager_ipid_to_ifstub(stubmgr, ipid);
383     if (ifstub)
384         ret = ifstub->stubbuffer;
385
386     if (ret) IRpcStubBuffer_AddRef(ret);
387
388     stub_manager_int_release(stubmgr);
389
390     return ret;
391 }
392
393 /* generates an ipid in the following format (similar to native version):
394  * Data1 = apartment-local ipid counter
395  * Data2 = apartment creator thread ID
396  * Data3 = process ID
397  * Data4 = random value
398  */
399 static inline HRESULT generate_ipid(struct stub_manager *m, IPID *ipid)
400 {
401     HRESULT hr;
402     hr = UuidCreate(ipid);
403     if (FAILED(hr))
404     {
405         ERR("couldn't create IPID for stub manager %p\n", m);
406         UuidCreateNil(ipid);
407         return hr;
408     }
409
410     ipid->Data1 = InterlockedIncrement(&m->apt->ipidc);
411     ipid->Data2 = (USHORT)m->apt->tid;
412     ipid->Data3 = (USHORT)GetCurrentProcessId();
413     return S_OK;
414 }
415
416 /* registers a new interface stub COM object with the stub manager and returns registration record */
417 struct ifstub *stub_manager_new_ifstub(struct stub_manager *m, IRpcStubBuffer *sb, IUnknown *iptr, REFIID iid, MSHLFLAGS flags)
418 {
419     struct ifstub *stub;
420
421     TRACE("oid=%s, stubbuffer=%p, iptr=%p, iid=%s\n",
422           wine_dbgstr_longlong(m->oid), sb, iptr, debugstr_guid(iid));
423
424     stub = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct ifstub));
425     if (!stub) return NULL;
426
427     stub->stubbuffer = sb;
428     if (sb) IRpcStubBuffer_AddRef(sb);
429
430     IUnknown_AddRef(iptr);
431     stub->iface = iptr;
432     stub->flags = flags;
433     stub->iid = *iid;
434
435     /* 
436      * FIXME: this is a hack for marshalling IRemUnknown. In real
437      * DCOM, the IPID of the IRemUnknown interface is generated like
438      * any other and passed to the OXID resolver which then returns it
439      * when queried. We don't have an OXID resolver yet so instead we
440      * use a magic IPID reserved for IRemUnknown.
441      */
442     if (IsEqualIID(iid, &IID_IRemUnknown))
443     {
444         stub->ipid.Data1 = 0xffffffff;
445         stub->ipid.Data2 = 0xffff;
446         stub->ipid.Data3 = 0xffff;
447         assert(sizeof(stub->ipid.Data4) == sizeof(m->apt->oxid));
448         memcpy(&stub->ipid.Data4, &m->apt->oxid, sizeof(OXID));
449     }
450     else
451         generate_ipid(m, &stub->ipid);
452
453     EnterCriticalSection(&m->lock);
454     list_add_head(&m->ifstubs, &stub->entry);
455     /* every normal marshal is counted so we don't allow more than we should */
456     if (flags & MSHLFLAGS_NORMAL) m->norm_refs++;
457     LeaveCriticalSection(&m->lock);
458
459     TRACE("ifstub %p created with ipid %s\n", stub, debugstr_guid(&stub->ipid));
460
461     return stub;
462 }
463
464 static void stub_manager_delete_ifstub(struct stub_manager *m, struct ifstub *ifstub)
465 {
466     TRACE("m=%p, m->oid=%s, ipid=%s\n", m, wine_dbgstr_longlong(m->oid), debugstr_guid(&ifstub->ipid));
467
468     list_remove(&ifstub->entry);
469
470     RPC_UnregisterInterface(&ifstub->iid);
471         
472     if (ifstub->stubbuffer) IUnknown_Release(ifstub->stubbuffer);
473     IUnknown_Release(ifstub->iface);
474
475     HeapFree(GetProcessHeap(), 0, ifstub);
476 }
477
478 /* returns TRUE if it is possible to unmarshal, FALSE otherwise. */
479 BOOL stub_manager_notify_unmarshal(struct stub_manager *m, const IPID *ipid)
480 {
481     BOOL ret = TRUE;
482     struct ifstub *ifstub;
483
484     if (!(ifstub = stub_manager_ipid_to_ifstub(m, ipid)))
485     {
486         ERR("attempted unmarshal of unknown IPID %s\n", debugstr_guid(ipid));
487         return FALSE;
488     }
489
490     EnterCriticalSection(&m->lock);
491
492     /* track normal marshals so we can enforce rules whilst in-process */
493     if (ifstub->flags & MSHLFLAGS_NORMAL)
494     {
495         if (m->norm_refs)
496             m->norm_refs--;
497         else
498         {
499             ERR("attempted invalid normal unmarshal, norm_refs is zero\n");
500             ret = FALSE;
501         }
502     }
503
504     LeaveCriticalSection(&m->lock);
505
506     return ret;
507 }
508
509 /* handles refcounting for CoReleaseMarshalData */
510 void stub_manager_release_marshal_data(struct stub_manager *m, ULONG refs, const IPID *ipid)
511 {
512     struct ifstub *ifstub;
513  
514     if (!(ifstub = stub_manager_ipid_to_ifstub(m, ipid)))
515         return;
516  
517     if (ifstub->flags & MSHLFLAGS_TABLEWEAK)
518         refs = 0;
519     else
520         refs = 1;
521
522     stub_manager_ext_release(m, refs);
523 }
524
525 /* is an ifstub table marshaled? */
526 BOOL stub_manager_is_table_marshaled(struct stub_manager *m, const IPID *ipid)
527 {
528     struct ifstub *ifstub = stub_manager_ipid_to_ifstub(m, ipid);
529  
530     assert( ifstub );
531     
532     return ifstub->flags & (MSHLFLAGS_TABLESTRONG | MSHLFLAGS_TABLEWEAK);
533 }
534
535
536 /*****************************************************************************
537  *
538  * IRemUnknown implementation
539  *
540  *
541  * Note: this object is not related to the lifetime of a stub_manager, but it
542  * interacts with stub managers.
543  */
544
545 const IID IID_IRemUnknown = { 0x00000131, 0, 0, {0xc0, 0, 0, 0, 0, 0, 0, 0x46} };
546
547 typedef struct rem_unknown
548 {
549     const IRemUnknownVtbl *lpVtbl;
550     LONG refs;
551 } RemUnknown;
552
553 static const IRemUnknownVtbl RemUnknown_Vtbl;
554
555
556 /* construct an IRemUnknown object with one outstanding reference */
557 static HRESULT RemUnknown_Construct(IRemUnknown **ppRemUnknown)
558 {
559     RemUnknown *This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
560
561     if (!This) return E_OUTOFMEMORY;
562
563     This->lpVtbl = &RemUnknown_Vtbl;
564     This->refs = 1;
565
566     *ppRemUnknown = (IRemUnknown *)This;
567     return S_OK;
568 }
569
570 static HRESULT WINAPI RemUnknown_QueryInterface(IRemUnknown *iface, REFIID riid, void **ppv)
571 {
572     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
573
574     if (IsEqualIID(riid, &IID_IUnknown) ||
575         IsEqualIID(riid, &IID_IRemUnknown))
576     {
577         *ppv = (LPVOID)iface;
578         IRemUnknown_AddRef(iface);
579         return S_OK;
580     }
581
582     FIXME("No interface for iid %s\n", debugstr_guid(riid));
583
584     *ppv = NULL;
585     return E_NOINTERFACE;
586 }
587
588 static ULONG WINAPI RemUnknown_AddRef(IRemUnknown *iface)
589 {
590     ULONG refs;
591     RemUnknown *This = (RemUnknown *)iface;
592
593     refs = InterlockedIncrement(&This->refs);
594
595     TRACE("%p before: %ld\n", iface, refs-1);
596     return refs;
597 }
598
599 static ULONG WINAPI RemUnknown_Release(IRemUnknown *iface)
600 {
601     ULONG refs;
602     RemUnknown *This = (RemUnknown *)iface;
603
604     refs = InterlockedDecrement(&This->refs);
605     if (!refs)
606         HeapFree(GetProcessHeap(), 0, This);
607
608     TRACE("%p after: %ld\n", iface, refs);
609     return refs;
610 }
611
612 static HRESULT WINAPI RemUnknown_RemQueryInterface(IRemUnknown *iface,
613     REFIPID ripid, ULONG cRefs, USHORT cIids, IID *iids /* [size_is(cIids)] */,
614     REMQIRESULT **ppQIResults /* [size_is(,cIids)] */)
615 {
616     HRESULT hr;
617     USHORT i;
618     USHORT successful_qis = 0;
619     APARTMENT *apt;
620     struct stub_manager *stubmgr;
621
622     TRACE("(%p)->(%s, %ld, %d, %p, %p)\n", iface, debugstr_guid(ripid), cRefs, cIids, iids, ppQIResults);
623
624     hr = ipid_to_stub_manager(ripid, &apt, &stubmgr);
625     if (hr != S_OK) return hr;
626
627     *ppQIResults = CoTaskMemAlloc(sizeof(REMQIRESULT) * cIids);
628
629     for (i = 0; i < cIids; i++)
630     {
631         HRESULT hrobj = marshal_object(apt, &(*ppQIResults)[i].std, &iids[i],
632                                        stubmgr->object, MSHLFLAGS_NORMAL);
633         if (hrobj == S_OK)
634             successful_qis++;
635         (*ppQIResults)[i].hResult = hrobj;
636     }
637
638     stub_manager_int_release(stubmgr);
639     apartment_release(apt);
640
641     if (successful_qis == cIids)
642         return S_OK; /* we got all requested interfaces */
643     else if (successful_qis == 0)
644         return E_NOINTERFACE; /* we didn't get any interfaces */
645     else
646         return S_FALSE; /* we got some interfaces */
647 }
648
649 static HRESULT WINAPI RemUnknown_RemAddRef(IRemUnknown *iface,
650     USHORT cInterfaceRefs,
651     REMINTERFACEREF* InterfaceRefs /* [size_is(cInterfaceRefs)] */,
652     HRESULT *pResults /* [size_is(cInterfaceRefs)] */)
653 {
654     HRESULT hr = S_OK;
655     USHORT i;
656
657     TRACE("(%p)->(%d, %p, %p)\n", iface, cInterfaceRefs, InterfaceRefs, pResults);
658
659     for (i = 0; i < cInterfaceRefs; i++)
660     {
661         APARTMENT *apt;
662         struct stub_manager *stubmgr;
663
664         pResults[i] = ipid_to_stub_manager(&InterfaceRefs[i].ipid, &apt, &stubmgr);
665         if (pResults[i] != S_OK)
666         {
667             hr = S_FALSE;
668             continue;
669         }
670
671         stub_manager_ext_addref(stubmgr, InterfaceRefs[i].cPublicRefs);
672         if (InterfaceRefs[i].cPrivateRefs)
673             FIXME("Adding %ld refs securely not implemented\n", InterfaceRefs[i].cPrivateRefs);
674
675         stub_manager_int_release(stubmgr);
676         apartment_release(apt);
677     }
678
679     return hr;
680 }
681
682 static HRESULT WINAPI RemUnknown_RemRelease(IRemUnknown *iface,
683     USHORT cInterfaceRefs,
684     REMINTERFACEREF* InterfaceRefs /* [size_is(cInterfaceRefs)] */)
685 {
686     HRESULT hr = S_OK;
687     USHORT i;
688
689     TRACE("(%p)->(%d, %p)\n", iface, cInterfaceRefs, InterfaceRefs);
690
691     for (i = 0; i < cInterfaceRefs; i++)
692     {
693         APARTMENT *apt;
694         struct stub_manager *stubmgr;
695
696         hr = ipid_to_stub_manager(&InterfaceRefs[i].ipid, &apt, &stubmgr);
697         if (hr != S_OK)
698         {
699             hr = E_INVALIDARG;
700             /* FIXME: we should undo any changes already made in this function */
701             break;
702         }
703
704         stub_manager_ext_release(stubmgr, InterfaceRefs[i].cPublicRefs);
705         if (InterfaceRefs[i].cPrivateRefs)
706             FIXME("Releasing %ld refs securely not implemented\n", InterfaceRefs[i].cPrivateRefs);
707
708         stub_manager_int_release(stubmgr);
709         apartment_release(apt);
710     }
711
712     return hr;
713 }
714
715 static const IRemUnknownVtbl RemUnknown_Vtbl =
716 {
717     RemUnknown_QueryInterface,
718     RemUnknown_AddRef,
719     RemUnknown_Release,
720     RemUnknown_RemQueryInterface,
721     RemUnknown_RemAddRef,
722     RemUnknown_RemRelease
723 };
724
725 /* starts the IRemUnknown listener for the current apartment */
726 HRESULT start_apartment_remote_unknown()
727 {
728     IRemUnknown *pRemUnknown;
729     HRESULT hr = S_OK;
730     APARTMENT *apt = COM_CurrentApt();
731
732     EnterCriticalSection(&apt->cs);
733     if (!apt->remunk_exported)
734     {
735         /* create the IRemUnknown object */
736         hr = RemUnknown_Construct(&pRemUnknown);
737         if (hr == S_OK)
738         {
739             STDOBJREF stdobjref; /* dummy - not used */
740             /* register it with the stub manager */
741             hr = marshal_object(apt, &stdobjref, &IID_IRemUnknown, (IUnknown *)pRemUnknown, MSHLFLAGS_NORMAL);
742             /* release our reference to the object as the stub manager will manage the life cycle for us */
743             IRemUnknown_Release(pRemUnknown);
744             if (hr == S_OK)
745                 apt->remunk_exported = TRUE;
746         }
747     }
748     LeaveCriticalSection(&apt->cs);
749     return hr;
750 }