git.oblomov.eu Git - wine/blob - 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 #include "windef.h"
  30 #include "winbase.h"
  31 #include "objbase.h"
  32
  33 #include "wine/debug.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  36
  37 typedef struct _FTMarshalImpl {
  38         ICOM_VFIELD (IUnknown);
  39         DWORD ref;
  40         ICOM_VTABLE (IMarshal) * lpvtblFTM;
  41
  42         IUnknown *pUnkOuter;
  43 } FTMarshalImpl;
  44
  45 #define _IFTMUnknown_(This)(IUnknown*)&(This->lpVtbl)
  46 #define _IFTMarshal_(This) (IMarshal*)&(This->lpvtblFTM)
  47
  48 #define _IFTMarshall_Offset ((int)(&(((FTMarshalImpl*)0)->lpvtblFTM)))
  49 #define _ICOM_THIS_From_IFTMarshal(class, name) class* This = (class*)(((char*)name)-_IFTMarshall_Offset);
  50
  51 /* inner IUnknown to handle aggregation */
  52 HRESULT WINAPI IiFTMUnknown_fnQueryInterface (IUnknown * iface, REFIID riid, LPVOID * ppv)
  53 {
  54
  55     ICOM_THIS (FTMarshalImpl, iface);
  56
  57     TRACE ("\n");
  58     *ppv = NULL;
  59
  60     if (IsEqualIID (&IID_IUnknown, riid))
  61         *ppv = _IFTMUnknown_ (This);
  62     else if (IsEqualIID (&IID_IMarshal, riid))
  63         *ppv = _IFTMarshal_ (This);
  64     else {
  65         FIXME ("No interface for %s.\n", debugstr_guid (riid));
  66         return E_NOINTERFACE;
  67     }
  68     IUnknown_AddRef ((IUnknown *) * ppv);
  69     return S_OK;
  70 }
  71
  72 ULONG WINAPI IiFTMUnknown_fnAddRef (IUnknown * iface)
  73 {
  74
  75     ICOM_THIS (FTMarshalImpl, iface);
  76
  77     TRACE ("\n");
  78     return InterlockedIncrement (&This->ref);
  79 }
  80
  81 ULONG WINAPI IiFTMUnknown_fnRelease (IUnknown * iface)
  82 {
  83
  84     ICOM_THIS (FTMarshalImpl, iface);
  85
  86     TRACE ("\n");
  87     if (InterlockedDecrement (&This->ref))
  88         return This->ref;
  89     HeapFree (GetProcessHeap (), 0, This);
  90     return 0;
  91 }
  92
  93 static ICOM_VTABLE (IUnknown) iunkvt =
  94 {
  95         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
  96         IiFTMUnknown_fnQueryInterface,
  97         IiFTMUnknown_fnAddRef,
  98         IiFTMUnknown_fnRelease
  99 };
 100
 101 HRESULT WINAPI FTMarshalImpl_QueryInterface (LPMARSHAL iface, REFIID riid, LPVOID * ppv)
 102 {
 103
 104     _ICOM_THIS_From_IFTMarshal (FTMarshalImpl, iface);
 105
 106     TRACE ("(%p)->(\n\tIID:\t%s,%p)\n", This, debugstr_guid (riid), ppv);
 107     return IUnknown_QueryInterface (This->pUnkOuter, riid, ppv);
 108 }
 109
 110 ULONG WINAPI FTMarshalImpl_AddRef (LPMARSHAL iface)
 111 {
 112
 113     _ICOM_THIS_From_IFTMarshal (FTMarshalImpl, iface);
 114
 115     TRACE ("\n");
 116     return IUnknown_AddRef (This->pUnkOuter);
 117 }
 118
 119 ULONG WINAPI FTMarshalImpl_Release (LPMARSHAL iface)
 120 {
 121
 122     _ICOM_THIS_From_IFTMarshal (FTMarshalImpl, iface);
 123
 124     TRACE ("\n");
 125     return IUnknown_Release (This->pUnkOuter);
 126 }
 127
 128 HRESULT WINAPI FTMarshalImpl_GetUnmarshalClass (LPMARSHAL iface, REFIID riid, void *pv, DWORD dwDestContext,
 129                                                 void *pvDestContext, DWORD mshlflags, CLSID * pCid)
 130 {
 131     FIXME ("(), stub!\n");
 132     return S_OK;
 133 }
 134
 135 HRESULT WINAPI FTMarshalImpl_GetMarshalSizeMax (LPMARSHAL iface, REFIID riid, void *pv, DWORD dwDestContext,
 136                                                 void *pvDestContext, DWORD mshlflags, DWORD * pSize)
 137 {
 138
 139     IMarshal *pMarshal = NULL;
 140     HRESULT hres;
 141
 142     _ICOM_THIS_From_IFTMarshal (FTMarshalImpl, iface);
 143
 144     FIXME ("(), stub!\n");
 145
 146     /* if the marshalling happens inside the same process the interface pointer is
 147        copied between the apartments */
 148     if (dwDestContext == MSHCTX_INPROC || dwDestContext == MSHCTX_CROSSCTX) {
 149         *pSize = sizeof (This);
 150         return S_OK;
 151     }
 152
 153     /* use the standard marshaller to handle all other cases */
 154     CoGetStandardMarshal (riid, pv, dwDestContext, pvDestContext, mshlflags, &pMarshal);
 155     hres = IMarshal_GetMarshalSizeMax (pMarshal, riid, pv, dwDestContext, pvDestContext, mshlflags, pSize);
 156     IMarshal_Release (pMarshal);
 157     return hres;
 158
 159     return S_OK;
 160 }
 161
 162 HRESULT WINAPI FTMarshalImpl_MarshalInterface (LPMARSHAL iface, IStream * pStm, REFIID riid, void *pv,
 163                                                DWORD dwDestContext, void *pvDestContext, DWORD mshlflags)
 164 {
 165
 166     IMarshal *pMarshal = NULL;
 167     HRESULT hres;
 168
 169     _ICOM_THIS_From_IFTMarshal (FTMarshalImpl, iface);
 170
 171     FIXME ("(), stub!\n");
 172
 173     /* if the marshalling happens inside the same process the interface pointer is
 174        copied between the apartments */
 175     if (dwDestContext == MSHCTX_INPROC || dwDestContext == MSHCTX_CROSSCTX) {
 176         return IStream_Write (pStm, This, sizeof (This), 0);
 177     }
 178
 179     /* use the standard marshaler to handle all other cases */
 180     CoGetStandardMarshal (riid, pv, dwDestContext, pvDestContext, mshlflags, &pMarshal);
 181     hres = IMarshal_MarshalInterface (pMarshal, pStm, riid, pv, dwDestContext, pvDestContext, mshlflags);
 182     IMarshal_Release (pMarshal);
 183     return hres;
 184 }
 185
 186 HRESULT WINAPI FTMarshalImpl_UnmarshalInterface (LPMARSHAL iface, IStream * pStm, REFIID riid, void **ppv)
 187 {
 188     FIXME ("(), stub!\n");
 189     return S_OK;
 190 }
 191
 192 HRESULT WINAPI FTMarshalImpl_ReleaseMarshalData (LPMARSHAL iface, IStream * pStm)
 193 {
 194     FIXME ("(), stub!\n");
 195     return S_OK;
 196 }
 197
 198 HRESULT WINAPI FTMarshalImpl_DisconnectObject (LPMARSHAL iface, DWORD dwReserved)
 199 {
 200     FIXME ("(), stub!\n");
 201     return S_OK;
 202 }
 203
 204 ICOM_VTABLE (IMarshal) ftmvtbl =
 205 {
 206         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 207         FTMarshalImpl_QueryInterface,
 208         FTMarshalImpl_AddRef,
 209         FTMarshalImpl_Release,
 210         FTMarshalImpl_GetUnmarshalClass,
 211         FTMarshalImpl_GetMarshalSizeMax,
 212         FTMarshalImpl_MarshalInterface,
 213         FTMarshalImpl_UnmarshalInterface,
 214         FTMarshalImpl_ReleaseMarshalData,
 215         FTMarshalImpl_DisconnectObject
 216 };
 217
 218 /***********************************************************************
 219  *          CoCreateFreeThreadedMarshaler [OLE32.5]
 220  *
 221  */
 222 HRESULT WINAPI CoCreateFreeThreadedMarshaler (LPUNKNOWN punkOuter, LPUNKNOWN * ppunkMarshal)
 223 {
 224
 225     FTMarshalImpl *ftm;
 226
 227     TRACE ("(%p %p)\n", punkOuter, ppunkMarshal);
 228
 229     ftm = (FTMarshalImpl *) HeapAlloc (GetProcessHeap (), 0, sizeof (FTMarshalImpl));
 230     if (!ftm)
 231         return E_OUTOFMEMORY;
 232
 233     ftm->lpVtbl = &iunkvt;
 234     ftm->lpvtblFTM = &ftmvtbl;
 235     ftm->ref = 1;
 236     ftm->pUnkOuter = punkOuter;
 237
 238     *ppunkMarshal = _IFTMUnknown_ (ftm);
 239     return S_OK;
 240 }