wininet/tests: Don't call GetLastError() twice.
[wine] / dlls / ole32 / ftmarshal.c
1 /*
2  *      free threaded marshaller
3  *
4  *  Copyright 2002  Juergen Schmied
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "config.h"
22
23 #include <stdlib.h>
24 #include <stdarg.h>
25 #include <stdio.h>
26 #include <string.h>
27 #include <assert.h>
28
29 #define COBJMACROS
30
31 #include "windef.h"
32 #include "winbase.h"
33 #include "objbase.h"
34
35 #include "wine/debug.h"
36
37 #include "compobj_private.h"
38
39 WINE_DEFAULT_DEBUG_CHANNEL(ole);
40
41 typedef struct _FTMarshalImpl {
42         IUnknown IUnknown_iface;
43         LONG ref;
44         IMarshal IMarshal_iface;
45
46         IUnknown *pUnkOuter;
47 } FTMarshalImpl;
48
49 static inline FTMarshalImpl *impl_from_IUnknown(IUnknown *iface)
50 {
51     return CONTAINING_RECORD(iface, FTMarshalImpl, IUnknown_iface);
52 }
53
54 static inline FTMarshalImpl *impl_from_IMarshal( IMarshal *iface )
55 {
56     return CONTAINING_RECORD(iface, FTMarshalImpl, IMarshal_iface);
57 }
58
59 /* inner IUnknown to handle aggregation */
60 static HRESULT WINAPI
61 IiFTMUnknown_fnQueryInterface (IUnknown * iface, REFIID riid, LPVOID * ppv)
62 {
63
64     FTMarshalImpl *This = impl_from_IUnknown(iface);
65
66     TRACE ("\n");
67     *ppv = NULL;
68
69     if (IsEqualIID (&IID_IUnknown, riid))
70         *ppv = &This->IUnknown_iface;
71     else if (IsEqualIID (&IID_IMarshal, riid))
72         *ppv = &This->IMarshal_iface;
73     else {
74         FIXME ("No interface for %s.\n", debugstr_guid (riid));
75         return E_NOINTERFACE;
76     }
77     IUnknown_AddRef ((IUnknown *) * ppv);
78     return S_OK;
79 }
80
81 static ULONG WINAPI IiFTMUnknown_fnAddRef (IUnknown * iface)
82 {
83
84     FTMarshalImpl *This = impl_from_IUnknown(iface);
85
86     TRACE ("\n");
87     return InterlockedIncrement (&This->ref);
88 }
89
90 static ULONG WINAPI IiFTMUnknown_fnRelease (IUnknown * iface)
91 {
92
93     FTMarshalImpl *This = impl_from_IUnknown(iface);
94
95     TRACE ("\n");
96     if (InterlockedDecrement (&This->ref))
97         return This->ref;
98     HeapFree (GetProcessHeap (), 0, This);
99     return 0;
100 }
101
102 static const IUnknownVtbl iunkvt =
103 {
104         IiFTMUnknown_fnQueryInterface,
105         IiFTMUnknown_fnAddRef,
106         IiFTMUnknown_fnRelease
107 };
108
109 static HRESULT WINAPI
110 FTMarshalImpl_QueryInterface (LPMARSHAL iface, REFIID riid, LPVOID * ppv)
111 {
112
113     FTMarshalImpl *This = impl_from_IMarshal(iface);
114
115     TRACE ("(%p)->(%s,%p)\n", This, debugstr_guid (riid), ppv);
116     return IUnknown_QueryInterface (This->pUnkOuter, riid, ppv);
117 }
118
119 static ULONG WINAPI
120 FTMarshalImpl_AddRef (LPMARSHAL iface)
121 {
122
123     FTMarshalImpl *This = impl_from_IMarshal(iface);
124
125     TRACE ("\n");
126     return IUnknown_AddRef (This->pUnkOuter);
127 }
128
129 static ULONG WINAPI
130 FTMarshalImpl_Release (LPMARSHAL iface)
131 {
132
133     FTMarshalImpl *This = impl_from_IMarshal(iface);
134
135     TRACE ("\n");
136     return IUnknown_Release (This->pUnkOuter);
137 }
138
139 static HRESULT WINAPI
140 FTMarshalImpl_GetUnmarshalClass (LPMARSHAL iface, REFIID riid, void *pv, DWORD dwDestContext,
141                                                 void *pvDestContext, DWORD mshlflags, CLSID * pCid)
142 {
143     TRACE("(%s, %p, 0x%x, %p, 0x%x, %p)\n", debugstr_guid(riid), pv,
144         dwDestContext, pvDestContext, mshlflags, pCid);
145     if (dwDestContext == MSHCTX_INPROC || dwDestContext == MSHCTX_CROSSCTX)
146         *pCid = CLSID_InProcFreeMarshaler;
147     else
148         *pCid = CLSID_DfMarshal;
149     return S_OK;
150 }
151
152 static HRESULT WINAPI
153 FTMarshalImpl_GetMarshalSizeMax (LPMARSHAL iface, REFIID riid, void *pv, DWORD dwDestContext,
154                                                 void *pvDestContext, DWORD mshlflags, DWORD * pSize)
155 {
156
157     IMarshal *pMarshal = NULL;
158     HRESULT hres;
159
160     TRACE("(%s, %p, 0x%x, %p, 0x%x, %p)\n", debugstr_guid(riid), pv,
161         dwDestContext, pvDestContext, mshlflags, pSize);
162
163     /* if the marshalling happens inside the same process the interface pointer is
164        copied between the apartments */
165     if (dwDestContext == MSHCTX_INPROC || dwDestContext == MSHCTX_CROSSCTX) {
166         *pSize = sizeof (mshlflags) + sizeof (pv) + sizeof (DWORD) + sizeof (GUID);
167         return S_OK;
168     }
169
170     /* use the standard marshaller to handle all other cases */
171     CoGetStandardMarshal (riid, pv, dwDestContext, pvDestContext, mshlflags, &pMarshal);
172     hres = IMarshal_GetMarshalSizeMax (pMarshal, riid, pv, dwDestContext, pvDestContext, mshlflags, pSize);
173     IMarshal_Release (pMarshal);
174     return hres;
175 }
176
177 static HRESULT WINAPI
178 FTMarshalImpl_MarshalInterface (LPMARSHAL iface, IStream * pStm, REFIID riid, void *pv,
179                                DWORD dwDestContext, void *pvDestContext, DWORD mshlflags)
180 {
181
182     IMarshal *pMarshal = NULL;
183     HRESULT hres;
184
185     TRACE("(%p, %s, %p, 0x%x, %p, 0x%x)\n", pStm, debugstr_guid(riid), pv,
186         dwDestContext, pvDestContext, mshlflags);
187
188     /* if the marshalling happens inside the same process the interface pointer is
189        copied between the apartments */
190     if (dwDestContext == MSHCTX_INPROC || dwDestContext == MSHCTX_CROSSCTX) {
191         void *object;
192         DWORD constant = 0;
193         GUID unknown_guid = { 0 };
194
195         hres = IUnknown_QueryInterface((IUnknown *)pv, riid, &object);
196         if (FAILED(hres))
197             return hres;
198
199         /* don't hold a reference to table-weak marshaled interfaces */
200         if (mshlflags & MSHLFLAGS_TABLEWEAK)
201             IUnknown_Release((IUnknown *)object);
202
203         hres = IStream_Write (pStm, &mshlflags, sizeof (mshlflags), NULL);
204         if (hres != S_OK) return STG_E_MEDIUMFULL;
205
206         hres = IStream_Write (pStm, &object, sizeof (object), NULL);
207         if (hres != S_OK) return STG_E_MEDIUMFULL;
208
209         if (sizeof(object) == sizeof(DWORD))
210         {
211             hres = IStream_Write (pStm, &constant, sizeof (constant), NULL);
212             if (hres != S_OK) return STG_E_MEDIUMFULL;
213         }
214
215         hres = IStream_Write (pStm, &unknown_guid, sizeof (unknown_guid), NULL);
216         if (hres != S_OK) return STG_E_MEDIUMFULL;
217
218         return S_OK;
219     }
220
221     /* use the standard marshaler to handle all other cases */
222     CoGetStandardMarshal (riid, pv, dwDestContext, pvDestContext, mshlflags, &pMarshal);
223     hres = IMarshal_MarshalInterface (pMarshal, pStm, riid, pv, dwDestContext, pvDestContext, mshlflags);
224     IMarshal_Release (pMarshal);
225     return hres;
226 }
227
228 static HRESULT WINAPI
229 FTMarshalImpl_UnmarshalInterface (LPMARSHAL iface, IStream * pStm, REFIID riid, void **ppv)
230 {
231     DWORD mshlflags;
232     IUnknown *object;
233     DWORD constant;
234     GUID unknown_guid;
235     HRESULT hres;
236
237     TRACE ("(%p, %s, %p)\n", pStm, debugstr_guid(riid), ppv);
238
239     hres = IStream_Read (pStm, &mshlflags, sizeof (mshlflags), NULL);
240     if (hres != S_OK) return STG_E_READFAULT;
241
242     hres = IStream_Read (pStm, &object, sizeof (object), NULL);
243     if (hres != S_OK) return STG_E_READFAULT;
244
245     if (sizeof(object) == sizeof(DWORD))
246     {
247         hres = IStream_Read (pStm, &constant, sizeof (constant), NULL);
248         if (hres != S_OK) return STG_E_READFAULT;
249         if (constant != 0)
250             FIXME("constant is 0x%x instead of 0\n", constant);
251     }
252
253     hres = IStream_Read (pStm, &unknown_guid, sizeof (unknown_guid), NULL);
254     if (hres != S_OK) return STG_E_READFAULT;
255
256     hres = IUnknown_QueryInterface(object, riid, ppv);
257     if (!(mshlflags & (MSHLFLAGS_TABLEWEAK|MSHLFLAGS_TABLESTRONG)))
258         IUnknown_Release(object);
259     return hres;
260 }
261
262 static HRESULT WINAPI FTMarshalImpl_ReleaseMarshalData (LPMARSHAL iface, IStream * pStm)
263 {
264     DWORD mshlflags;
265     IUnknown *object;
266     DWORD constant;
267     GUID unknown_guid;
268     HRESULT hres;
269
270     TRACE ("(%p)\n", pStm);
271
272     hres = IStream_Read (pStm, &mshlflags, sizeof (mshlflags), NULL);
273     if (hres != S_OK) return STG_E_READFAULT;
274
275     hres = IStream_Read (pStm, &object, sizeof (object), NULL);
276     if (hres != S_OK) return STG_E_READFAULT;
277
278     if (sizeof(object) == sizeof(DWORD))
279     {
280         hres = IStream_Read (pStm, &constant, sizeof (constant), NULL);
281         if (hres != S_OK) return STG_E_READFAULT;
282         if (constant != 0)
283             FIXME("constant is 0x%x instead of 0\n", constant);
284     }
285
286     hres = IStream_Read (pStm, &unknown_guid, sizeof (unknown_guid), NULL);
287     if (hres != S_OK) return STG_E_READFAULT;
288
289     IUnknown_Release(object);
290     return S_OK;
291 }
292
293 static HRESULT WINAPI FTMarshalImpl_DisconnectObject (LPMARSHAL iface, DWORD dwReserved)
294 {
295     TRACE ("()\n");
296     /* nothing to do */
297     return S_OK;
298 }
299
300 static const IMarshalVtbl ftmvtbl =
301 {
302         FTMarshalImpl_QueryInterface,
303         FTMarshalImpl_AddRef,
304         FTMarshalImpl_Release,
305         FTMarshalImpl_GetUnmarshalClass,
306         FTMarshalImpl_GetMarshalSizeMax,
307         FTMarshalImpl_MarshalInterface,
308         FTMarshalImpl_UnmarshalInterface,
309         FTMarshalImpl_ReleaseMarshalData,
310         FTMarshalImpl_DisconnectObject
311 };
312
313 /***********************************************************************
314  *          CoCreateFreeThreadedMarshaler [OLE32.@]
315  *
316  * Creates a free-threaded marshaler.
317  *
318  * PARAMS
319  *  punkOuter    [I] Optional. Outer unknown.
320  *  ppunkMarshal [O] On return, the inner unknown of the created free-threaded marshaler.
321  *
322  * RETURNS
323  *  Success: S_OK
324  *  Failure: E_OUTOFMEMORY if no memory available to create object.
325  *
326  * NOTES
327  *  Objects that ensure their state is maintained consistent when used by
328  *  multiple threads and reference no single-threaded objects are known as
329  *  free-threaded. The free-threaded marshaler enables these objects to be
330  *  efficiently marshaled within the same process, by not creating proxies
331  *  (as they aren't needed for the object to be safely used), whilst still
332  *  allowing the object to be used in inter-process and inter-machine contexts.
333  */
334 HRESULT WINAPI CoCreateFreeThreadedMarshaler (LPUNKNOWN punkOuter, LPUNKNOWN * ppunkMarshal)
335 {
336
337     FTMarshalImpl *ftm;
338
339     TRACE ("(%p %p)\n", punkOuter, ppunkMarshal);
340
341     ftm = HeapAlloc (GetProcessHeap (), 0, sizeof (FTMarshalImpl));
342     if (!ftm)
343         return E_OUTOFMEMORY;
344
345     ftm->IUnknown_iface.lpVtbl = &iunkvt;
346     ftm->IMarshal_iface.lpVtbl = &ftmvtbl;
347     ftm->ref = 1;
348     ftm->pUnkOuter = punkOuter ? punkOuter : &ftm->IUnknown_iface;
349
350     *ppunkMarshal = &ftm->IUnknown_iface;
351     return S_OK;
352 }
353
354 static HRESULT WINAPI FTMarshalCF_QueryInterface(LPCLASSFACTORY iface,
355                                                   REFIID riid, LPVOID *ppv)
356 {
357     *ppv = NULL;
358     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IClassFactory))
359     {
360         *ppv = iface;
361         IUnknown_AddRef(iface);
362         return S_OK;
363     }
364     return E_NOINTERFACE;
365 }
366
367 static ULONG WINAPI FTMarshalCF_AddRef(LPCLASSFACTORY iface)
368 {
369     return 2; /* non-heap based object */
370 }
371
372 static ULONG WINAPI FTMarshalCF_Release(LPCLASSFACTORY iface)
373 {
374     return 1; /* non-heap based object */
375 }
376
377 static HRESULT WINAPI FTMarshalCF_CreateInstance(LPCLASSFACTORY iface,
378     LPUNKNOWN pUnk, REFIID riid, LPVOID *ppv)
379 {
380     IUnknown *pUnknown;
381     HRESULT  hr;
382
383     TRACE("(%p, %s, %p)\n", pUnk, debugstr_guid(riid), ppv);
384
385     *ppv = NULL;
386
387     hr = CoCreateFreeThreadedMarshaler(pUnk, &pUnknown);
388
389     if (SUCCEEDED(hr))
390     {
391         hr = IUnknown_QueryInterface(pUnknown, riid, ppv);
392         IUnknown_Release(pUnknown);
393     }
394
395     return hr;
396 }
397
398 static HRESULT WINAPI FTMarshalCF_LockServer(LPCLASSFACTORY iface, BOOL fLock)
399 {
400     FIXME("(%d), stub!\n",fLock);
401     return S_OK;
402 }
403
404 static const IClassFactoryVtbl FTMarshalCFVtbl =
405 {
406     FTMarshalCF_QueryInterface,
407     FTMarshalCF_AddRef,
408     FTMarshalCF_Release,
409     FTMarshalCF_CreateInstance,
410     FTMarshalCF_LockServer
411 };
412 static const IClassFactoryVtbl *FTMarshalCF = &FTMarshalCFVtbl;
413
414 HRESULT FTMarshalCF_Create(REFIID riid, LPVOID *ppv)
415 {
416     return IClassFactory_QueryInterface((IClassFactory *)&FTMarshalCF, riid, ppv);
417 }