ole/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 "debug.h"
  19
  20 #include "ifs.h"
  21
  22 /* --- IUnknown implementation */
  23
  24 typedef struct
  25 {
  26     /* IUnknown fields */
  27     ICOM_VTABLE(IUnknown)* lpvtbl;
  28     DWORD                  ref;
  29 } IUnknownImpl;
  30
  31 /******************************************************************************
  32  *              IUnknown_AddRef [VTABLE:IUNKNOWN.1]
  33  */
  34 static ULONG WINAPI IUnknown_fnAddRef(LPUNKNOWN iface) {
  35         ICOM_THIS(IUnknownImpl,iface);
  36         TRACE(relay,"(%p)->AddRef()\n",This);
  37         return ++(This->ref);
  38 }
  39
  40 /******************************************************************************
  41  * IUnknown_Release [VTABLE:IUNKNOWN.2]
  42  */
  43 static ULONG WINAPI IUnknown_fnRelease(LPUNKNOWN iface) {
  44         ICOM_THIS(IUnknownImpl,iface);
  45         TRACE(relay,"(%p)->Release()\n",This);
  46         if (!--(This->ref)) {
  47                 HeapFree(GetProcessHeap(),0,This);
  48                 return 0;
  49         }
  50         return This->ref;
  51 }
  52
  53 /******************************************************************************
  54  * IUnknown_QueryInterface [VTABLE:IUNKNOWN.0]
  55  */
  56 static HRESULT WINAPI IUnknown_fnQueryInterface(LPUNKNOWN iface,REFIID refiid,LPVOID *obj) {
  57         ICOM_THIS(IUnknownImpl,iface);
  58         char    xrefiid[50];
  59
  60         WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
  61         TRACE(relay,"(%p)->QueryInterface(%s,%p)\n",This,xrefiid,obj);
  62
  63         if (!memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown))) {
  64                 *obj = This;
  65                 return 0;
  66         }
  67         return OLE_E_ENUM_NOMORE;
  68 }
  69
  70 static ICOM_VTABLE(IUnknown) uvt = {
  71         IUnknown_fnQueryInterface,
  72         IUnknown_fnAddRef,
  73         IUnknown_fnRelease
  74 };
  75
  76 /******************************************************************************
  77  * IUnknown_Constructor [INTERNAL]
  78  */
  79 LPUNKNOWN
  80 IUnknown_Constructor() {
  81         IUnknownImpl*   unk;
  82
  83         unk = (IUnknownImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(IUnknownImpl));
  84         unk->lpvtbl     = &uvt;
  85         unk->ref        = 1;
  86         return (LPUNKNOWN)unk;
  87 }
  88
  89
  90 /* --- IMalloc16 implementation */
  91
  92
  93 typedef struct
  94 {
  95         /* IUnknown fields */
  96         ICOM_VTABLE(IMalloc16)* lpvtbl;
  97         DWORD                   ref;
  98         /* IMalloc16 fields */
  99         /* Gmm, I think one is not enough, we should probably manage a list of
 100          * heaps
 101  */
 102         HGLOBAL16 heap;
 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         char    xrefiid[50];
 111
 112         WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
 113         TRACE(relay,"(%p)->QueryInterface(%s,%p)\n",This,xrefiid,obj);
 114         if (    !memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown)) ||
 115                 !memcmp(&IID_IMalloc,refiid,sizeof(IID_IMalloc))
 116         ) {
 117                 *obj = This;
 118                 return 0;
 119         }
 120         return OLE_E_ENUM_NOMORE;
 121 }
 122
 123 /******************************************************************************
 124  *              IMalloc16_AddRef        [COMPOBJ.501]
 125  */
 126 ULONG WINAPI IMalloc16_fnAddRef(IMalloc16* iface) {
 127         ICOM_THIS(IMalloc16Impl,iface);
 128         TRACE(relay,"(%p)->AddRef()\n",This);
 129         return 1; /* cannot be freed */
 130 }
 131
 132 /******************************************************************************
 133  *              IMalloc16_Release       [COMPOBJ.502]
 134  */
 135 ULONG WINAPI IMalloc16_fnRelease(IMalloc16* iface) {
 136         ICOM_THIS(IMalloc16Impl,iface);
 137         TRACE(relay,"(%p)->Release()\n",This);
 138         return 1; /* cannot be freed */
 139 }
 140
 141 /******************************************************************************
 142  * IMalloc16_Alloc [COMPOBJ.503]
 143  */
 144 LPVOID WINAPI IMalloc16_fnAlloc(IMalloc16* iface,DWORD cb) {
 145         ICOM_THIS(IMalloc16Impl,iface);
 146         TRACE(relay,"(%p)->Alloc(%ld)\n",This,cb);
 147         return (LPVOID)PTR_SEG_OFF_TO_SEGPTR(This->heap,LOCAL_Alloc(This->heap,0,cb));
 148 }
 149
 150 /******************************************************************************
 151  * IMalloc16_Realloc [COMPOBJ.504]
 152  */
 153 LPVOID WINAPI IMalloc16_fnRealloc(IMalloc16* iface,LPVOID pv,DWORD cb) {
 154         ICOM_THIS(IMalloc16Impl,iface);
 155         TRACE(relay,"(%p)->Realloc(%p,%ld)\n",This,pv,cb);
 156         return (LPVOID)PTR_SEG_OFF_TO_SEGPTR(This->heap,LOCAL_ReAlloc(This->heap,0,LOWORD(pv),cb));
 157 }
 158
 159 /******************************************************************************
 160  * IMalloc16_Free [COMPOBJ.505]
 161  */
 162 VOID WINAPI IMalloc16_fnFree(IMalloc16* iface,LPVOID pv) {
 163         ICOM_THIS(IMalloc16Impl,iface);
 164         TRACE(relay,"(%p)->Free(%p)\n",This,pv);
 165         LOCAL_Free(This->heap,LOWORD(pv));
 166 }
 167
 168 /******************************************************************************
 169  * IMalloc16_GetSize [COMPOBJ.506]
 170  */
 171 DWORD WINAPI IMalloc16_fnGetSize(const IMalloc16* iface,LPVOID pv) {
 172         ICOM_CTHIS(IMalloc16Impl,iface);
 173         TRACE(relay,"(%p)->GetSize(%p)\n",This,pv);
 174         return LOCAL_Size(This->heap,LOWORD(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(relay,"(%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(relay,"(%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             This->lpvtbl = msegvt16 = SEGPTR_NEW(ICOM_VTABLE(IMalloc16));
 208
 209 #define VTENT(x) msegvt16->fn##x = (void*)WIN32_GetProcAddress16(hcomp,"IMalloc16_"#x);assert(msegvt16->fn##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             msegvt16 = (ICOM_VTABLE(IMalloc16)*)SEGPTR_GET(msegvt16);
 220 #undef VTENT
 221         }
 222         This->ref = 1;
 223         /* FIXME: implement multiple heaps */
 224         This->heap = GlobalAlloc16(GMEM_MOVEABLE,64000);
 225         LocalInit16(This->heap,0,64000);
 226         return (LPMALLOC16)SEGPTR_GET(This);
 227 }
 228
 229
 230 /* --- IMalloc32 implementation */
 231
 232 typedef struct
 233 {
 234         /* IUnknown fields */
 235         ICOM_VTABLE(IMalloc)* lpvtbl;
 236         DWORD                   ref;
 237 } IMalloc32Impl;
 238
 239 /******************************************************************************
 240  *              IMalloc32_QueryInterface        [VTABLE]
 241  */
 242 static HRESULT WINAPI IMalloc_fnQueryInterface(LPMALLOC iface,REFIID refiid,LPVOID *obj) {
 243         ICOM_THIS(IMalloc32Impl,iface);
 244         char    xrefiid[50];
 245
 246         WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
 247         TRACE(relay,"(%p)->QueryInterface(%s,%p)\n",This,xrefiid,obj);
 248         if (    !memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown)) ||
 249                 !memcmp(&IID_IMalloc,refiid,sizeof(IID_IMalloc))
 250         ) {
 251                 *obj = This;
 252                 return S_OK;
 253         }
 254         return OLE_E_ENUM_NOMORE;
 255 }
 256
 257 /******************************************************************************
 258  *              IMalloc32_AddRef        [VTABLE]
 259  */
 260 static ULONG WINAPI IMalloc_fnAddRef(LPMALLOC iface) {
 261         ICOM_THIS(IMalloc32Impl,iface);
 262         TRACE(relay,"(%p)->AddRef()\n",This);
 263         return 1; /* cannot be freed */
 264 }
 265
 266 /******************************************************************************
 267  *              IMalloc32_Release       [VTABLE]
 268  */
 269 static ULONG WINAPI IMalloc_fnRelease(LPMALLOC iface) {
 270         ICOM_THIS(IMalloc32Impl,iface);
 271         TRACE(relay,"(%p)->Release()\n",This);
 272         return 1; /* cannot be freed */
 273 }
 274
 275 /******************************************************************************
 276  * IMalloc32_Alloc [VTABLE]
 277  */
 278 static LPVOID WINAPI IMalloc_fnAlloc(LPMALLOC iface,DWORD cb) {
 279         ICOM_THIS(IMalloc32Impl,iface);
 280         TRACE(relay,"(%p)->Alloc(%ld)\n",This,cb);
 281         return HeapAlloc(GetProcessHeap(),0,cb);
 282 }
 283
 284 /******************************************************************************
 285  * IMalloc32_Realloc [VTABLE]
 286  */
 287 static LPVOID WINAPI IMalloc_fnRealloc(LPMALLOC iface,LPVOID pv,DWORD cb) {
 288         ICOM_THIS(IMalloc32Impl,iface);
 289         TRACE(relay,"(%p)->Realloc(%p,%ld)\n",This,pv,cb);
 290         return HeapReAlloc(GetProcessHeap(),0,pv,cb);
 291 }
 292
 293 /******************************************************************************
 294  * IMalloc32_Free [VTABLE]
 295  */
 296 static VOID WINAPI IMalloc_fnFree(LPMALLOC iface,LPVOID pv) {
 297         ICOM_THIS(IMalloc32Impl,iface);
 298         TRACE(relay,"(%p)->Free(%p)\n",This,pv);
 299         HeapFree(GetProcessHeap(),0,pv);
 300 }
 301
 302 /******************************************************************************
 303  * IMalloc32_GetSize [VTABLE]
 304  */
 305 static DWORD WINAPI IMalloc_fnGetSize(const IMalloc* iface,LPVOID pv) {
 306         ICOM_CTHIS(IMalloc,iface);
 307         TRACE(relay,"(%p)->GetSize(%p)\n",This,pv);
 308         return HeapSize(GetProcessHeap(),0,pv);
 309 }
 310
 311 /******************************************************************************
 312  * IMalloc32_DidAlloc [VTABLE]
 313  */
 314 static INT WINAPI IMalloc_fnDidAlloc(const IMalloc* iface,LPVOID pv) {
 315         ICOM_CTHIS(IMalloc32Impl,iface);
 316         TRACE(relay,"(%p)->DidAlloc(%p)\n",This,pv);
 317         return -1;
 318 }
 319
 320 /******************************************************************************
 321  * IMalloc32_HeapMinimize [VTABLE]
 322  */
 323 static LPVOID WINAPI IMalloc_fnHeapMinimize(LPMALLOC iface) {
 324         ICOM_THIS(IMalloc32Impl,iface);
 325         TRACE(relay,"(%p)->HeapMinimize()\n",This);
 326         return NULL;
 327 }
 328
 329 static ICOM_VTABLE(IMalloc) VT_IMalloc32 = {
 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         This->lpvtbl = &VT_IMalloc32;
 350         This->ref = 1;
 351         return (LPMALLOC)This;
 352 }
 353
 354 /****************************************************************************
 355  * API Functions
 356  */
 357
 358 /******************************************************************************
 359  *              IsValidInterface32      [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(punk->lpvtbl,4)                            ||
 370                 IsBadReadPtr(punk->lpvtbl->fnQueryInterface,9)  ||
 371                 IsBadCodePtr(punk->lpvtbl->fnQueryInterface)
 372         );
 373 }