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