git.oblomov.eu Git - wine/blob - 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 "objbase.h"
  17 #include "local.h"
  18 #include "module.h"
  19 #include "debug.h"
  20
  21 #include "ifs.h"
  22
  23 /* --- IUnknown implementation */
  24
  25 typedef struct
  26 {
  27     /* IUnknown fields */
  28     ICOM_VTABLE(IUnknown)* lpvtbl;
  29     DWORD                  ref;
  30 } IUnknownImpl;
  31
  32 /******************************************************************************
  33  *              IUnknown_AddRef [VTABLE:IUNKNOWN.1]
  34  */
  35 static ULONG WINAPI IUnknown_fnAddRef(LPUNKNOWN iface) {
  36         ICOM_THIS(IUnknownImpl,iface);
  37         TRACE(relay,"(%p)->AddRef()\n",This);
  38         return ++(This->ref);
  39 }
  40
  41 /******************************************************************************
  42  * IUnknown_Release [VTABLE:IUNKNOWN.2]
  43  */
  44 static ULONG WINAPI IUnknown_fnRelease(LPUNKNOWN iface) {
  45         ICOM_THIS(IUnknownImpl,iface);
  46         TRACE(relay,"(%p)->Release()\n",This);
  47         if (!--(This->ref)) {
  48                 HeapFree(GetProcessHeap(),0,This);
  49                 return 0;
  50         }
  51         return This->ref;
  52 }
  53
  54 /******************************************************************************
  55  * IUnknown_QueryInterface [VTABLE:IUNKNOWN.0]
  56  */
  57 static HRESULT WINAPI IUnknown_fnQueryInterface(LPUNKNOWN iface,REFIID refiid,LPVOID *obj) {
  58         ICOM_THIS(IUnknownImpl,iface);
  59         char    xrefiid[50];
  60
  61         WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
  62         TRACE(relay,"(%p)->QueryInterface(%s,%p)\n",This,xrefiid,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         IUnknown_fnQueryInterface,
  73         IUnknown_fnAddRef,
  74         IUnknown_fnRelease
  75 };
  76
  77 /******************************************************************************
  78  * IUnknown_Constructor [INTERNAL]
  79  */
  80 LPUNKNOWN
  81 IUnknown_Constructor() {
  82         IUnknownImpl*   unk;
  83
  84         unk = (IUnknownImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(IUnknownImpl));
  85         unk->lpvtbl     = &uvt;
  86         unk->ref        = 1;
  87         return (LPUNKNOWN)unk;
  88 }
  89
  90
  91 /* --- IMalloc16 implementation */
  92
  93
  94 typedef struct
  95 {
  96         /* IUnknown fields */
  97         ICOM_VTABLE(IMalloc16)* lpvtbl;
  98         DWORD                   ref;
  99         /* IMalloc16 fields */
 100         /* Gmm, I think one is not enough, we should probably manage a list of
 101          * heaps
 102  */
 103         HGLOBAL16 heap;
 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         char    xrefiid[50];
 112
 113         WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
 114         TRACE(relay,"(%p)->QueryInterface(%s,%p)\n",This,xrefiid,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(relay,"(%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(relay,"(%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(relay,"(%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(relay,"(%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(relay,"(%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(relay,"(%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(relay,"(%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(relay,"(%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             This->lpvtbl = 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             msegvt16 = (ICOM_VTABLE(IMalloc16)*)SEGPTR_GET(msegvt16);
 221 #undef VTENT
 222         }
 223         This->ref = 1;
 224         /* FIXME: implement multiple heaps */
 225         This->heap = GlobalAlloc16(GMEM_MOVEABLE,64000);
 226         LocalInit(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_VTABLE(IMalloc32)* lpvtbl;
 237         DWORD                   ref;
 238 } IMalloc32Impl;
 239
 240 /******************************************************************************
 241  *              IMalloc32_QueryInterface        [VTABLE]
 242  */
 243 static HRESULT WINAPI IMalloc32_fnQueryInterface(LPMALLOC32 iface,REFIID refiid,LPVOID *obj) {
 244         ICOM_THIS(IMalloc32Impl,iface);
 245         char    xrefiid[50];
 246
 247         WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
 248         TRACE(relay,"(%p)->QueryInterface(%s,%p)\n",This,xrefiid,obj);
 249         if (    !memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown)) ||
 250                 !memcmp(&IID_IMalloc,refiid,sizeof(IID_IMalloc))
 251         ) {
 252                 *obj = This;
 253                 return S_OK;
 254         }
 255         return OLE_E_ENUM_NOMORE;
 256 }
 257
 258 /******************************************************************************
 259  *              IMalloc32_AddRef        [VTABLE]
 260  */
 261 static ULONG WINAPI IMalloc32_fnAddRef(LPMALLOC32 iface) {
 262         ICOM_THIS(IMalloc32Impl,iface);
 263         TRACE(relay,"(%p)->AddRef()\n",This);
 264         return 1; /* cannot be freed */
 265 }
 266
 267 /******************************************************************************
 268  *              IMalloc32_Release       [VTABLE]
 269  */
 270 static ULONG WINAPI IMalloc32_fnRelease(LPMALLOC32 iface) {
 271         ICOM_THIS(IMalloc32Impl,iface);
 272         TRACE(relay,"(%p)->Release()\n",This);
 273         return 1; /* cannot be freed */
 274 }
 275
 276 /******************************************************************************
 277  * IMalloc32_Alloc [VTABLE]
 278  */
 279 static LPVOID WINAPI IMalloc32_fnAlloc(LPMALLOC32 iface,DWORD cb) {
 280         ICOM_THIS(IMalloc32Impl,iface);
 281         TRACE(relay,"(%p)->Alloc(%ld)\n",This,cb);
 282         return HeapAlloc(GetProcessHeap(),0,cb);
 283 }
 284
 285 /******************************************************************************
 286  * IMalloc32_Realloc [VTABLE]
 287  */
 288 static LPVOID WINAPI IMalloc32_fnRealloc(LPMALLOC32 iface,LPVOID pv,DWORD cb) {
 289         ICOM_THIS(IMalloc32Impl,iface);
 290         TRACE(relay,"(%p)->Realloc(%p,%ld)\n",This,pv,cb);
 291         return HeapReAlloc(GetProcessHeap(),0,pv,cb);
 292 }
 293
 294 /******************************************************************************
 295  * IMalloc32_Free [VTABLE]
 296  */
 297 static VOID WINAPI IMalloc32_fnFree(LPMALLOC32 iface,LPVOID pv) {
 298         ICOM_THIS(IMalloc32Impl,iface);
 299         TRACE(relay,"(%p)->Free(%p)\n",This,pv);
 300         HeapFree(GetProcessHeap(),0,pv);
 301 }
 302
 303 /******************************************************************************
 304  * IMalloc32_GetSize [VTABLE]
 305  */
 306 static DWORD WINAPI IMalloc32_fnGetSize(const IMalloc32* iface,LPVOID pv) {
 307         ICOM_CTHIS(IMalloc32,iface);
 308         TRACE(relay,"(%p)->GetSize(%p)\n",This,pv);
 309         return HeapSize(GetProcessHeap(),0,pv);
 310 }
 311
 312 /******************************************************************************
 313  * IMalloc32_DidAlloc [VTABLE]
 314  */
 315 static INT32 WINAPI IMalloc32_fnDidAlloc(const IMalloc32* iface,LPVOID pv) {
 316         ICOM_CTHIS(IMalloc32Impl,iface);
 317         TRACE(relay,"(%p)->DidAlloc(%p)\n",This,pv);
 318         return -1;
 319 }
 320
 321 /******************************************************************************
 322  * IMalloc32_HeapMinimize [VTABLE]
 323  */
 324 static LPVOID WINAPI IMalloc32_fnHeapMinimize(LPMALLOC32 iface) {
 325         ICOM_THIS(IMalloc32Impl,iface);
 326         TRACE(relay,"(%p)->HeapMinimize()\n",This);
 327         return NULL;
 328 }
 329
 330 static ICOM_VTABLE(IMalloc32) VT_IMalloc32 = {
 331     IMalloc32_fnQueryInterface,
 332     IMalloc32_fnAddRef,
 333   IMalloc32_fnRelease,
 334   IMalloc32_fnAlloc,
 335   IMalloc32_fnRealloc,
 336   IMalloc32_fnFree,
 337   IMalloc32_fnGetSize,
 338   IMalloc32_fnDidAlloc,
 339   IMalloc32_fnHeapMinimize
 340 };
 341
 342 /******************************************************************************
 343  * IMalloc32_Constructor [VTABLE]
 344  */
 345 LPMALLOC32
 346 IMalloc32_Constructor() {
 347         IMalloc32Impl* This;
 348
 349         This = (IMalloc32Impl*)HeapAlloc(GetProcessHeap(),0,sizeof(IMalloc32Impl));
 350         This->lpvtbl = &VT_IMalloc32;
 351         This->ref = 1;
 352         return (LPMALLOC32)This;
 353 }
 354
 355 /****************************************************************************
 356  * API Functions
 357  */
 358
 359 /******************************************************************************
 360  *              IsValidInterface32      [OLE32.78]
 361  *
 362  * RETURNS
 363  *  True, if the passed pointer is a valid interface
 364  */
 365 BOOL32 WINAPI IsValidInterface32(
 366         LPUNKNOWN punk  /* [in] interface to be tested */
 367 ) {
 368         return !(
 369                 IsBadReadPtr32(punk,4)                                  ||
 370                 IsBadReadPtr32(punk->lpvtbl,4)                          ||
 371                 IsBadReadPtr32(punk->lpvtbl->fnQueryInterface,9)        ||
 372                 IsBadCodePtr32(punk->lpvtbl->fnQueryInterface)
 373         );
 374 }