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