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