git.oblomov.eu Git - wine/blob - dlls/ole32/ifs.c

   1 /*
   2  *      basic interfaces
   3  *
   4  *      Copyright 1997  Marcus Meissner
   5  */
   6
   7 #include <ctype.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <assert.h>
  11 #include "winerror.h"
  12 #include "ldt.h"
  13 #include "heap.h"
  14 #include "wine/winbase16.h"
  15 #include "wine/obj_base.h"
  16 #include "debugtools.h"
  17
  18 #include "ole.h"
  19 #include "ifs.h"
  20
  21 DEFAULT_DEBUG_CHANNEL(relay);
  22
  23 /* --- IUnknown implementation */
  24
  25 typedef struct
  26 {
  27     /* IUnknown fields */
  28     ICOM_VFIELD(IUnknown);
  29     DWORD                  ref;
  30 } IUnknownImpl;
  31
  32 /******************************************************************************
  33  *              IUnknown_AddRef [VTABLE:IUNKNOWN.1]
  34  */
  35 static ULONG WINAPI IUnknown_fnAddRef(LPUNKNOWN iface) {
  36         ICOM_THIS(IUnknownImpl,iface);
  37         TRACE("(%p)->AddRef()\n",This);
  38         return ++(This->ref);
  39 }
  40
  41 /******************************************************************************
  42  * IUnknown_Release [VTABLE:IUNKNOWN.2]
  43  */
  44 static ULONG WINAPI IUnknown_fnRelease(LPUNKNOWN iface) {
  45         ICOM_THIS(IUnknownImpl,iface);
  46         TRACE("(%p)->Release()\n",This);
  47         if (!--(This->ref)) {
  48                 HeapFree(GetProcessHeap(),0,This);
  49                 return 0;
  50         }
  51         return This->ref;
  52 }
  53
  54 /******************************************************************************
  55  * IUnknown_QueryInterface [VTABLE:IUNKNOWN.0]
  56  */
  57 static HRESULT WINAPI IUnknown_fnQueryInterface(LPUNKNOWN iface,REFIID refiid,LPVOID *obj) {
  58         ICOM_THIS(IUnknownImpl,iface);
  59
  60         TRACE("(%p)->QueryInterface(%s,%p)\n",This,debugstr_guid(refiid),obj);
  61
  62         if (!memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown))) {
  63                 *obj = This;
  64                 return 0;
  65         }
  66         return OLE_E_ENUM_NOMORE;
  67 }
  68
  69 static ICOM_VTABLE(IUnknown) uvt =
  70 {
  71         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
  72         IUnknown_fnQueryInterface,
  73         IUnknown_fnAddRef,
  74         IUnknown_fnRelease
  75 };
  76
  77 /******************************************************************************
  78  * IUnknown_Constructor [INTERNAL]
  79  */
  80 LPUNKNOWN
  81 IUnknown_Constructor() {
  82         IUnknownImpl*   unk;
  83
  84         unk = (IUnknownImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(IUnknownImpl));
  85         ICOM_VTBL(unk)  = &uvt;
  86         unk->ref        = 1;
  87         return (LPUNKNOWN)unk;
  88 }
  89
  90
  91 /* --- IMalloc16 implementation */
  92
  93
  94 typedef struct
  95 {
  96         /* IUnknown fields */
  97         ICOM_VFIELD(IMalloc16);
  98         DWORD                   ref;
  99         /* IMalloc16 fields */
 100 } IMalloc16Impl;
 101
 102 /******************************************************************************
 103  *              IMalloc16_QueryInterface        [COMPOBJ.500]
 104  */
 105 HRESULT WINAPI IMalloc16_fnQueryInterface(IMalloc16* iface,REFIID refiid,LPVOID *obj) {
 106         ICOM_THIS(IMalloc16Impl,iface);
 107
 108         TRACE("(%p)->QueryInterface(%s,%p)\n",This,debugstr_guid(refiid),obj);
 109         if (    !memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown)) ||
 110                 !memcmp(&IID_IMalloc,refiid,sizeof(IID_IMalloc))
 111         ) {
 112                 *obj = This;
 113                 return 0;
 114         }
 115         return OLE_E_ENUM_NOMORE;
 116 }
 117
 118 /******************************************************************************
 119  *              IMalloc16_AddRef        [COMPOBJ.501]
 120  */
 121 ULONG WINAPI IMalloc16_fnAddRef(IMalloc16* iface) {
 122         ICOM_THIS(IMalloc16Impl,iface);
 123         TRACE("(%p)->AddRef()\n",This);
 124         return 1; /* cannot be freed */
 125 }
 126
 127 /******************************************************************************
 128  *              IMalloc16_Release       [COMPOBJ.502]
 129  */
 130 ULONG WINAPI IMalloc16_fnRelease(IMalloc16* iface) {
 131         ICOM_THIS(IMalloc16Impl,iface);
 132         TRACE("(%p)->Release()\n",This);
 133         return 1; /* cannot be freed */
 134 }
 135
 136 /******************************************************************************
 137  * IMalloc16_Alloc [COMPOBJ.503]
 138  */
 139 SEGPTR WINAPI IMalloc16_fnAlloc(IMalloc16* iface,DWORD cb) {
 140         ICOM_THIS(IMalloc16Impl,iface);
 141         TRACE("(%p)->Alloc(%ld)\n",This,cb);
 142         return MapLS( HeapAlloc( GetProcessHeap(), HEAP_WINE_SEGPTR, cb ) );
 143 }
 144
 145 /******************************************************************************
 146  * IMalloc16_Realloc [COMPOBJ.504]
 147  */
 148 SEGPTR WINAPI IMalloc16_fnRealloc(IMalloc16* iface,SEGPTR pv,DWORD cb) {
 149         ICOM_THIS(IMalloc16Impl,iface);
 150         TRACE("(%p)->Realloc(%08lx,%ld)\n",This,pv,cb);
 151         return MapLS( HeapReAlloc( GetProcessHeap(), HEAP_WINE_SEGPTR, PTR_SEG_TO_LIN(pv), cb ) );
 152 }
 153
 154 /******************************************************************************
 155  * IMalloc16_Free [COMPOBJ.505]
 156  */
 157 VOID WINAPI IMalloc16_fnFree(IMalloc16* iface,SEGPTR pv) {
 158         ICOM_THIS(IMalloc16Impl,iface);
 159         TRACE("(%p)->Free(%08lx)\n",This,pv);
 160         HeapFree( GetProcessHeap(), HEAP_WINE_SEGPTR, PTR_SEG_TO_LIN(pv) );
 161 }
 162
 163 /******************************************************************************
 164  * IMalloc16_GetSize [COMPOBJ.506]
 165  */
 166 DWORD WINAPI IMalloc16_fnGetSize(const IMalloc16* iface,LPVOID pv) {
 167         ICOM_CTHIS(IMalloc16Impl,iface);
 168         TRACE("(%p)->GetSize(%p)\n",This,pv);
 169         return HeapSize( GetProcessHeap(), HEAP_WINE_SEGPTR, PTR_SEG_TO_LIN(pv) );
 170 }
 171
 172 /******************************************************************************
 173  * IMalloc16_DidAlloc [COMPOBJ.507]
 174  */
 175 INT16 WINAPI IMalloc16_fnDidAlloc(const IMalloc16* iface,LPVOID pv) {
 176         ICOM_CTHIS(IMalloc16,iface);
 177         TRACE("(%p)->DidAlloc(%p)\n",This,pv);
 178         return (INT16)-1;
 179 }
 180
 181 /******************************************************************************
 182  * IMalloc16_HeapMinimize [COMPOBJ.508]
 183  */
 184 LPVOID WINAPI IMalloc16_fnHeapMinimize(IMalloc16* iface) {
 185         ICOM_THIS(IMalloc16Impl,iface);
 186         TRACE("(%p)->HeapMinimize()\n",This);
 187         return NULL;
 188 }
 189
 190 static ICOM_VTABLE(IMalloc16)* msegvt16 = NULL;
 191
 192 /******************************************************************************
 193  * IMalloc16_Constructor [VTABLE]
 194  */
 195 LPMALLOC16
 196 IMalloc16_Constructor() {
 197         IMalloc16Impl*  This;
 198         HMODULE16       hcomp = GetModuleHandle16("COMPOBJ");
 199
 200         This = (IMalloc16Impl*)SEGPTR_NEW(IMalloc16Impl);
 201         if (!msegvt16) {
 202             msegvt16 = SEGPTR_NEW(ICOM_VTABLE(IMalloc16));
 203
 204 #define VTENT(x) msegvt16->fn##x = (void*)GetProcAddress16(hcomp,"IMalloc16_"#x);assert(msegvt16->fn##x)
 205             VTENT(QueryInterface);
 206             VTENT(AddRef);
 207             VTENT(Release);
 208             VTENT(Alloc);
 209             VTENT(Realloc);
 210             VTENT(Free);
 211             VTENT(GetSize);
 212             VTENT(DidAlloc);
 213             VTENT(HeapMinimize);
 214 #undef VTENT
 215         }
 216         ICOM_VTBL(This) = (ICOM_VTABLE(IMalloc16)*)SEGPTR_GET(msegvt16);
 217         This->ref = 1;
 218         return (LPMALLOC16)SEGPTR_GET(This);
 219 }
 220
 221
 222 /* --- IMalloc32 implementation */
 223
 224 typedef struct
 225 {
 226         /* IUnknown fields */
 227         ICOM_VFIELD(IMalloc);
 228         DWORD                   ref;
 229 } IMalloc32Impl;
 230
 231 /******************************************************************************
 232  *              IMalloc32_QueryInterface        [VTABLE]
 233  */
 234 static HRESULT WINAPI IMalloc_fnQueryInterface(LPMALLOC iface,REFIID refiid,LPVOID *obj) {
 235         ICOM_THIS(IMalloc32Impl,iface);
 236
 237         TRACE("(%p)->QueryInterface(%s,%p)\n",This,debugstr_guid(refiid),obj);
 238         if (    !memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown)) ||
 239                 !memcmp(&IID_IMalloc,refiid,sizeof(IID_IMalloc))
 240         ) {
 241                 *obj = This;
 242                 return S_OK;
 243         }
 244         return OLE_E_ENUM_NOMORE;
 245 }
 246
 247 /******************************************************************************
 248  *              IMalloc32_AddRef        [VTABLE]
 249  */
 250 static ULONG WINAPI IMalloc_fnAddRef(LPMALLOC iface) {
 251         ICOM_THIS(IMalloc32Impl,iface);
 252         TRACE("(%p)->AddRef()\n",This);
 253         return 1; /* cannot be freed */
 254 }
 255
 256 /******************************************************************************
 257  *              IMalloc32_Release       [VTABLE]
 258  */
 259 static ULONG WINAPI IMalloc_fnRelease(LPMALLOC iface) {
 260         ICOM_THIS(IMalloc32Impl,iface);
 261         TRACE("(%p)->Release()\n",This);
 262         return 1; /* cannot be freed */
 263 }
 264
 265 /******************************************************************************
 266  * IMalloc32_Alloc [VTABLE]
 267  */
 268 static LPVOID WINAPI IMalloc_fnAlloc(LPMALLOC iface,DWORD cb) {
 269         LPVOID addr;
 270         ICOM_THIS(IMalloc32Impl,iface);
 271         addr = HeapAlloc(GetProcessHeap(),0,cb);
 272         TRACE("(%p)->Alloc(%ld) -> %p\n",This,cb,addr);
 273         return addr;
 274 }
 275
 276 /******************************************************************************
 277  * IMalloc32_Realloc [VTABLE]
 278  */
 279 static LPVOID WINAPI IMalloc_fnRealloc(LPMALLOC iface,LPVOID pv,DWORD cb) {
 280         ICOM_THIS(IMalloc32Impl,iface);
 281         TRACE("(%p)->Realloc(%p,%ld)\n",This,pv,cb);
 282         return HeapReAlloc(GetProcessHeap(),0,pv,cb);
 283 }
 284
 285 /******************************************************************************
 286  * IMalloc32_Free [VTABLE]
 287  */
 288 static VOID WINAPI IMalloc_fnFree(LPMALLOC iface,LPVOID pv) {
 289         ICOM_THIS(IMalloc32Impl,iface);
 290         TRACE("(%p)->Free(%p)\n",This,pv);
 291         HeapFree(GetProcessHeap(),0,pv);
 292 }
 293
 294 /******************************************************************************
 295  * IMalloc32_GetSize [VTABLE]
 296  */
 297 static DWORD WINAPI IMalloc_fnGetSize(LPMALLOC iface,LPVOID pv) {
 298         ICOM_CTHIS(IMalloc,iface);
 299         TRACE("(%p)->GetSize(%p)\n",This,pv);
 300         return HeapSize(GetProcessHeap(),0,pv);
 301 }
 302
 303 /******************************************************************************
 304  * IMalloc32_DidAlloc [VTABLE]
 305  */
 306 static INT WINAPI IMalloc_fnDidAlloc(LPMALLOC iface,LPVOID pv) {
 307         ICOM_CTHIS(IMalloc32Impl,iface);
 308         TRACE("(%p)->DidAlloc(%p)\n",This,pv);
 309         return -1;
 310 }
 311
 312 /******************************************************************************
 313  * IMalloc32_HeapMinimize [VTABLE]
 314  */
 315 static VOID WINAPI IMalloc_fnHeapMinimize(LPMALLOC iface) {
 316         ICOM_THIS(IMalloc32Impl,iface);
 317         TRACE("(%p)->HeapMinimize()\n",This);
 318 }
 319
 320 static ICOM_VTABLE(IMalloc) VT_IMalloc32 =
 321 {
 322     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 323     IMalloc_fnQueryInterface,
 324     IMalloc_fnAddRef,
 325   IMalloc_fnRelease,
 326   IMalloc_fnAlloc,
 327   IMalloc_fnRealloc,
 328   IMalloc_fnFree,
 329   IMalloc_fnGetSize,
 330   IMalloc_fnDidAlloc,
 331   IMalloc_fnHeapMinimize
 332 };
 333
 334 /******************************************************************************
 335  * IMalloc32_Constructor [VTABLE]
 336  */
 337 LPMALLOC
 338 IMalloc_Constructor() {
 339         IMalloc32Impl* This;
 340
 341         This = (IMalloc32Impl*)HeapAlloc(GetProcessHeap(),0,sizeof(IMalloc32Impl));
 342         ICOM_VTBL(This) = &VT_IMalloc32;
 343         This->ref = 1;
 344         return (LPMALLOC)This;
 345 }
 346
 347 /****************************************************************************
 348  * API Functions
 349  */
 350
 351 /******************************************************************************
 352  *              IsValidInterface        [OLE32.78]
 353  *
 354  * RETURNS
 355  *  True, if the passed pointer is a valid interface
 356  */
 357 BOOL WINAPI IsValidInterface(
 358         LPUNKNOWN punk  /* [in] interface to be tested */
 359 ) {
 360         return !(
 361                 IsBadReadPtr(punk,4)                                    ||
 362                 IsBadReadPtr(ICOM_VTBL(punk),4)                         ||
 363                 IsBadReadPtr(ICOM_VTBL(punk)->fnQueryInterface,9)       ||
 364                 IsBadCodePtr(ICOM_VTBL(punk)->fnQueryInterface)
 365         );
 366 }