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