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         IUnknownVtbl *lpVtbl;
  39         DWORD ref;
  40         IMarshalVtbl *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     FTMarshalImpl *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     FTMarshalImpl *This = (FTMarshalImpl *)iface;
  76
  77     TRACE ("\n");
  78     return InterlockedIncrement (&This->ref);
  79 }
  80
  81 ULONG WINAPI IiFTMUnknown_fnRelease (IUnknown * iface)
  82 {
  83
  84     FTMarshalImpl *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 IUnknownVtbl iunkvt =
  94 {
  95         IiFTMUnknown_fnQueryInterface,
  96         IiFTMUnknown_fnAddRef,
  97         IiFTMUnknown_fnRelease
  98 };
  99
 100 HRESULT WINAPI FTMarshalImpl_QueryInterface (LPMARSHAL iface, REFIID riid, LPVOID * ppv)
 101 {
 102
 103     _ICOM_THIS_From_IFTMarshal (FTMarshalImpl, iface);
 104
 105     TRACE ("(%p)->(\n\tIID:\t%s,%p)\n", This, debugstr_guid (riid), ppv);
 106     return IUnknown_QueryInterface (This->pUnkOuter, riid, ppv);
 107 }
 108
 109 ULONG WINAPI FTMarshalImpl_AddRef (LPMARSHAL iface)
 110 {
 111
 112     _ICOM_THIS_From_IFTMarshal (FTMarshalImpl, iface);
 113
 114     TRACE ("\n");
 115     return IUnknown_AddRef (This->pUnkOuter);
 116 }
 117
 118 ULONG WINAPI FTMarshalImpl_Release (LPMARSHAL iface)
 119 {
 120
 121     _ICOM_THIS_From_IFTMarshal (FTMarshalImpl, iface);
 122
 123     TRACE ("\n");
 124     return IUnknown_Release (This->pUnkOuter);
 125 }
 126
 127 HRESULT WINAPI FTMarshalImpl_GetUnmarshalClass (LPMARSHAL iface, REFIID riid, void *pv, DWORD dwDestContext,
 128                                                 void *pvDestContext, DWORD mshlflags, CLSID * pCid)
 129 {
 130     FIXME ("(), stub!\n");
 131     return S_OK;
 132 }
 133
 134 HRESULT WINAPI FTMarshalImpl_GetMarshalSizeMax (LPMARSHAL iface, REFIID riid, void *pv, DWORD dwDestContext,
 135                                                 void *pvDestContext, DWORD mshlflags, DWORD * pSize)
 136 {
 137
 138     IMarshal *pMarshal = NULL;
 139     HRESULT hres;
 140
 141     _ICOM_THIS_From_IFTMarshal (FTMarshalImpl, iface);
 142
 143     FIXME ("(), stub!\n");
 144
 145     /* if the marshalling happens inside the same process the interface pointer is
 146        copied between the apartments */
 147     if (dwDestContext == MSHCTX_INPROC || dwDestContext == MSHCTX_CROSSCTX) {
 148         *pSize = sizeof (This);
 149         return S_OK;
 150     }
 151
 152     /* use the standard marshaller to handle all other cases */
 153     CoGetStandardMarshal (riid, pv, dwDestContext, pvDestContext, mshlflags, &pMarshal);
 154     hres = IMarshal_GetMarshalSizeMax (pMarshal, riid, pv, dwDestContext, pvDestContext, mshlflags, pSize);
 155     IMarshal_Release (pMarshal);
 156     return hres;
 157
 158     return S_OK;
 159 }
 160
 161 HRESULT WINAPI FTMarshalImpl_MarshalInterface (LPMARSHAL iface, IStream * pStm, REFIID riid, void *pv,
 162                                                DWORD dwDestContext, void *pvDestContext, DWORD mshlflags)
 163 {
 164
 165     IMarshal *pMarshal = NULL;
 166     HRESULT hres;
 167
 168     _ICOM_THIS_From_IFTMarshal (FTMarshalImpl, iface);
 169
 170     FIXME ("(), stub!\n");
 171
 172     /* if the marshalling happens inside the same process the interface pointer is
 173        copied between the apartments */
 174     if (dwDestContext == MSHCTX_INPROC || dwDestContext == MSHCTX_CROSSCTX) {
 175         return IStream_Write (pStm, This, sizeof (This), 0);
 176     }
 177
 178     /* use the standard marshaler to handle all other cases */
 179     CoGetStandardMarshal (riid, pv, dwDestContext, pvDestContext, mshlflags, &pMarshal);
 180     hres = IMarshal_MarshalInterface (pMarshal, pStm, riid, pv, dwDestContext, pvDestContext, mshlflags);
 181     IMarshal_Release (pMarshal);
 182     return hres;
 183 }
 184
 185 HRESULT WINAPI FTMarshalImpl_UnmarshalInterface (LPMARSHAL iface, IStream * pStm, REFIID riid, void **ppv)
 186 {
 187     FIXME ("(), stub!\n");
 188     return S_OK;
 189 }
 190
 191 HRESULT WINAPI FTMarshalImpl_ReleaseMarshalData (LPMARSHAL iface, IStream * pStm)
 192 {
 193     FIXME ("(), stub!\n");
 194     return S_OK;
 195 }
 196
 197 HRESULT WINAPI FTMarshalImpl_DisconnectObject (LPMARSHAL iface, DWORD dwReserved)
 198 {
 199     FIXME ("(), stub!\n");
 200     return S_OK;
 201 }
 202
 203 IMarshalVtbl ftmvtbl =
 204 {
 205         FTMarshalImpl_QueryInterface,
 206         FTMarshalImpl_AddRef,
 207         FTMarshalImpl_Release,
 208         FTMarshalImpl_GetUnmarshalClass,
 209         FTMarshalImpl_GetMarshalSizeMax,
 210         FTMarshalImpl_MarshalInterface,
 211         FTMarshalImpl_UnmarshalInterface,
 212         FTMarshalImpl_ReleaseMarshalData,
 213         FTMarshalImpl_DisconnectObject
 214 };
 215
 216 /***********************************************************************
 217  *          CoCreateFreeThreadedMarshaler [OLE32.@]
 218  *
 219  */
 220 HRESULT WINAPI CoCreateFreeThreadedMarshaler (LPUNKNOWN punkOuter, LPUNKNOWN * ppunkMarshal)
 221 {
 222
 223     FTMarshalImpl *ftm;
 224
 225     TRACE ("(%p %p)\n", punkOuter, ppunkMarshal);
 226
 227     ftm = (FTMarshalImpl *) HeapAlloc (GetProcessHeap (), 0, sizeof (FTMarshalImpl));
 228     if (!ftm)
 229         return E_OUTOFMEMORY;
 230
 231     ftm->lpVtbl = &iunkvt;
 232     ftm->lpvtblFTM = &ftmvtbl;
 233     ftm->ref = 1;
 234     ftm->pUnkOuter = punkOuter;
 235
 236     *ppunkMarshal = _IFTMUnknown_ (ftm);
 237     return S_OK;
 238 }