dlls/ole32/ifs.c

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