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