dlls/ole32/memlockbytes.c

   1 /******************************************************************************
   2  *
   3  * Global memory implementation of ILockBytes.
   4  *
   5  * Copyright 1999 Thuy Nguyen
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "config.h"
  23
  24 #include <assert.h>
  25 #include <stdarg.h>
  26 #include <string.h>
  27
  28 #define COBJMACROS
  29 #define NONAMELESSUNION
  30 #define NONAMELESSSTRUCT
  31
  32 #include "windef.h"
  33 #include "winbase.h"
  34 #include "winuser.h"
  35 #include "objbase.h"
  36 #include "ole2.h"
  37 #include "winerror.h"
  38
  39 #include "wine/debug.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  42
  43 /******************************************************************************
  44  * HGLOBALLockBytesImpl definition.
  45  *
  46  * This class implements the ILockBytes interface and represents a byte array
  47  * object supported by an HGLOBAL pointer.
  48  */
  49 struct HGLOBALLockBytesImpl
  50 {
  51   /*
  52    * Needs to be the first item in the struct
  53    * since we want to cast this in an ILockBytes pointer
  54    */
  55   const ILockBytesVtbl *lpVtbl;
  56
  57   /*
  58    * Reference count
  59    */
  60   LONG        ref;
  61
  62   /*
  63    * Support for the LockBytes object
  64    */
  65   HGLOBAL supportHandle;
  66
  67   /*
  68    * This flag is TRUE if the HGLOBAL is destroyed when the object
  69    * is finally released.
  70    */
  71   BOOL    deleteOnRelease;
  72
  73   /*
  74    * Helper variable that contains the size of the byte array
  75    */
  76   ULARGE_INTEGER     byteArraySize;
  77 };
  78
  79 typedef struct HGLOBALLockBytesImpl HGLOBALLockBytesImpl;
  80
  81 /*
  82  * Method definition for the HGLOBALLockBytesImpl class.
  83  */
  84 static HGLOBALLockBytesImpl* HGLOBALLockBytesImpl_Construct(
  85     HGLOBAL  hGlobal,
  86     BOOL     fDeleteOnRelease);
  87
  88 static void HGLOBALLockBytesImpl_Destroy(HGLOBALLockBytesImpl* This);
  89
  90 static HRESULT WINAPI HGLOBALLockBytesImpl_SetSize( ILockBytes* iface, ULARGE_INTEGER libNewSize );
  91
  92 static const ILockBytesVtbl HGLOBALLockBytesImpl_Vtbl;
  93
  94 /******************************************************************************
  95  *           CreateILockBytesOnHGlobal     [OLE32.@]
  96  *
  97  * Create a byte array object which is intended to be the compound file foundation.
  98  * This object supports a COM implementation of the ILockBytes interface.
  99  *
 100  * PARAMS
 101  *  hGlobal           [ I] Global memory handle
 102  *  fDeleteOnRelease  [ I] Whether the handle should be freed when the object is released.
 103  *  ppLkbyt           [ O] Address of ILockBytes pointer that receives
 104  *                         the interface pointer to the new byte array object.
 105  *
 106  * RETURNS
 107  *  Success: S_OK
 108  *
 109  * NOTES
 110  *  The supplied ILockBytes pointer can be used by the StgCreateDocfileOnILockBytes
 111  *  function to build a compound file on top of this byte array object.
 112  *  The ILockBytes interface instance calls the GlobalReAlloc function to grow
 113  *  the memory block as required.
 114  */
 115 HRESULT WINAPI CreateILockBytesOnHGlobal(HGLOBAL      hGlobal,
 116                                          BOOL         fDeleteOnRelease,
 117                                          LPLOCKBYTES* ppLkbyt)
 118 {
 119   HGLOBALLockBytesImpl* newLockBytes;
 120
 121   newLockBytes = HGLOBALLockBytesImpl_Construct(hGlobal, fDeleteOnRelease);
 122
 123   if (newLockBytes != NULL)
 124   {
 125     return IUnknown_QueryInterface((IUnknown*)newLockBytes,
 126                                    &IID_ILockBytes,
 127                                    (void**)ppLkbyt);
 128   }
 129
 130   return E_OUTOFMEMORY;
 131 }
 132
 133 /******************************************************************************
 134  *           GetHGlobalFromILockBytes     [OLE32.@]
 135  *
 136  * Retrieve a global memory handle to a byte array object created
 137  * using the CreateILockBytesOnHGlobal function.
 138  *
 139  * PARAMS
 140  *  plkbyt   [ I]  Pointer to the ILockBytes interface on byte array object
 141  *  phglobal [ O]  Address to store a global memory handle
 142  * RETURNS
 143  *  S_OK          if *phglobal has a correct value
 144  *  E_INVALIDARG  if any parameters are invalid
 145  *
 146  */
 147 HRESULT WINAPI GetHGlobalFromILockBytes(ILockBytes* plkbyt, HGLOBAL* phglobal)
 148 {
 149   HGLOBALLockBytesImpl* const pMemLockBytes = (HGLOBALLockBytesImpl*)plkbyt;
 150   STATSTG stbuf;
 151   HRESULT hres;
 152   ULARGE_INTEGER start;
 153   ULONG xread;
 154
 155   *phglobal = 0;
 156   if (pMemLockBytes->lpVtbl == &HGLOBALLockBytesImpl_Vtbl) {
 157     *phglobal = pMemLockBytes->supportHandle;
 158     if (*phglobal == 0)
 159       return E_INVALIDARG;
 160     return S_OK;
 161   }
 162   /* It is not our lockbytes implementation, so use a more generic way */
 163   hres = ILockBytes_Stat(plkbyt,&stbuf,0);
 164   if (hres != S_OK) {
 165      ERR("Cannot ILockBytes_Stat, %x\n",hres);
 166      return hres;
 167   }
 168   FIXME("cbSize is %d\n",stbuf.cbSize.u.LowPart);
 169   *phglobal = GlobalAlloc( GMEM_MOVEABLE|GMEM_SHARE, stbuf.cbSize.u.LowPart);
 170   if (!*phglobal)
 171     return E_INVALIDARG;
 172   memset(&start,0,sizeof(start));
 173   hres = ILockBytes_ReadAt(plkbyt, start, GlobalLock(*phglobal), stbuf.cbSize.u.LowPart, &xread);
 174   GlobalUnlock(*phglobal);
 175   if (hres != S_OK) {
 176     FIXME("%p->ReadAt failed with %x\n",plkbyt,hres);
 177     return hres;
 178   }
 179   if (stbuf.cbSize.u.LowPart != xread) {
 180     FIXME("Read size is not requested size %d vs %d?\n",stbuf.cbSize.u.LowPart, xread);
 181   }
 182   return S_OK;
 183 }
 184
 185 /******************************************************************************
 186  *
 187  * HGLOBALLockBytesImpl implementation
 188  *
 189  */
 190
 191 /******************************************************************************
 192  * This is the constructor for the HGLOBALLockBytesImpl class.
 193  *
 194  * PARAMS
 195  *    hGlobal          [ I] Handle that will support the stream. can be NULL.
 196  *    fDeleteOnRelease [ I] Flag set to TRUE if the HGLOBAL will be released
 197  *                          when the IStream object is destroyed.
 198  */
 199 static HGLOBALLockBytesImpl* HGLOBALLockBytesImpl_Construct(HGLOBAL hGlobal,
 200                                                             BOOL    fDeleteOnRelease)
 201 {
 202   HGLOBALLockBytesImpl* newLockBytes;
 203   newLockBytes = HeapAlloc(GetProcessHeap(), 0, sizeof(HGLOBALLockBytesImpl));
 204
 205   if (newLockBytes!=0)
 206   {
 207     /*
 208      * Set up the virtual function table and reference count.
 209      */
 210     newLockBytes->lpVtbl = &HGLOBALLockBytesImpl_Vtbl;
 211     newLockBytes->ref    = 0;
 212
 213     /*
 214      * Initialize the support.
 215      */
 216     newLockBytes->supportHandle = hGlobal;
 217     newLockBytes->deleteOnRelease = fDeleteOnRelease;
 218
 219     /*
 220      * This method will allocate a handle if one is not supplied.
 221      */
 222     if (newLockBytes->supportHandle == 0)
 223     {
 224       newLockBytes->supportHandle = GlobalAlloc(GMEM_MOVEABLE |
 225                                                 GMEM_NODISCARD,
 226                                                 0);
 227     }
 228
 229     /*
 230      * Initialize the size of the array to the size of the handle.
 231      */
 232     newLockBytes->byteArraySize.u.HighPart = 0;
 233     newLockBytes->byteArraySize.u.LowPart  = GlobalSize(
 234                                               newLockBytes->supportHandle);
 235   }
 236
 237   return newLockBytes;
 238 }
 239
 240 /******************************************************************************
 241  * This is the destructor of the HGLOBALStreamImpl class.
 242  *
 243  * This method will clean-up all the resources used-up by the given
 244  * HGLOBALLockBytesImpl class. The pointer passed-in to this function will be
 245  * freed and will not be valid anymore.
 246  */
 247 static void HGLOBALLockBytesImpl_Destroy(HGLOBALLockBytesImpl* This)
 248 {
 249   /*
 250    * Release the HGlobal if the constructor asked for that.
 251    */
 252   if (This->deleteOnRelease)
 253   {
 254     GlobalFree(This->supportHandle);
 255     This->supportHandle = 0;
 256   }
 257
 258   /*
 259    * Finally, free the memory used-up by the class.
 260    */
 261   HeapFree(GetProcessHeap(), 0, This);
 262 }
 263
 264 /******************************************************************************
 265  * This implements the IUnknown method QueryInterface for this
 266  * class
 267  */
 268 static HRESULT WINAPI HGLOBALLockBytesImpl_QueryInterface(
 269       ILockBytes*  iface,
 270       REFIID       riid,        /* [in] */
 271       void**       ppvObject)   /* [iid_is][out] */
 272 {
 273   HGLOBALLockBytesImpl* const This=(HGLOBALLockBytesImpl*)iface;
 274
 275   /*
 276    * Perform a sanity check on the parameters.
 277    */
 278   if (ppvObject==0)
 279     return E_INVALIDARG;
 280
 281   /*
 282    * Initialize the return parameter.
 283    */
 284   *ppvObject = 0;
 285
 286   /*
 287    * Compare the riid with the interface IDs implemented by this object.
 288    */
 289   if (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) == 0)
 290   {
 291     *ppvObject = (ILockBytes*)This;
 292   }
 293   else if (memcmp(&IID_ILockBytes, riid, sizeof(IID_ILockBytes)) == 0)
 294   {
 295     *ppvObject = (ILockBytes*)This;
 296   }
 297
 298   /*
 299    * Check that we obtained an interface.
 300    */
 301   if ((*ppvObject)==0)
 302     return E_NOINTERFACE;
 303
 304   /*
 305    * Query Interface always increases the reference count by one when it is
 306    * successful
 307    */
 308   IUnknown_AddRef(iface);
 309
 310   return S_OK;
 311 }
 312
 313 /******************************************************************************
 314  * This implements the IUnknown method AddRef for this
 315  * class
 316  */
 317 static ULONG WINAPI HGLOBALLockBytesImpl_AddRef(ILockBytes* iface)
 318 {
 319   HGLOBALLockBytesImpl* const This=(HGLOBALLockBytesImpl*)iface;
 320   return InterlockedIncrement(&This->ref);
 321 }
 322
 323 /******************************************************************************
 324  * This implements the IUnknown method Release for this
 325  * class
 326  */
 327 static ULONG WINAPI HGLOBALLockBytesImpl_Release(ILockBytes* iface)
 328 {
 329   HGLOBALLockBytesImpl* const This=(HGLOBALLockBytesImpl*)iface;
 330   ULONG ref;
 331
 332   ref = InterlockedDecrement(&This->ref);
 333
 334   /*
 335    * If the reference count goes down to 0, perform suicide.
 336    */
 337   if (ref==0)
 338   {
 339     HGLOBALLockBytesImpl_Destroy(This);
 340   }
 341
 342   return ref;
 343 }
 344
 345 /******************************************************************************
 346  * This method is part of the ILockBytes interface.
 347  *
 348  * It reads a block of information from the byte array at the specified
 349  * offset.
 350  *
 351  * See the documentation of ILockBytes for more info.
 352  */
 353 static HRESULT WINAPI HGLOBALLockBytesImpl_ReadAt(
 354       ILockBytes*    iface,
 355       ULARGE_INTEGER ulOffset,  /* [in] */
 356       void*          pv,        /* [length_is][size_is][out] */
 357       ULONG          cb,        /* [in] */
 358       ULONG*         pcbRead)   /* [out] */
 359 {
 360   HGLOBALLockBytesImpl* const This=(HGLOBALLockBytesImpl*)iface;
 361
 362   void* supportBuffer;
 363   ULONG bytesReadBuffer = 0;
 364   ULONG bytesToReadFromBuffer;
 365
 366   /*
 367    * If the caller is not interested in the number of bytes read,
 368    * we use another buffer to avoid "if" statements in the code.
 369    */
 370   if (pcbRead == 0)
 371     pcbRead = &bytesReadBuffer;
 372
 373   /*
 374    * Make sure the offset is valid.
 375    */
 376   if (ulOffset.u.LowPart > This->byteArraySize.u.LowPart)
 377     return E_FAIL;
 378
 379   /*
 380    * Using the known size of the array, calculate the number of bytes
 381    * to read.
 382    */
 383   bytesToReadFromBuffer = min(This->byteArraySize.u.LowPart -
 384                               ulOffset.u.LowPart, cb);
 385
 386   /*
 387    * Lock the buffer in position and copy the data.
 388    */
 389   supportBuffer = GlobalLock(This->supportHandle);
 390
 391   memcpy(pv,
 392          (char *) supportBuffer + ulOffset.u.LowPart,
 393          bytesToReadFromBuffer);
 394
 395   /*
 396    * Return the number of bytes read.
 397    */
 398   *pcbRead = bytesToReadFromBuffer;
 399
 400   /*
 401    * Cleanup
 402    */
 403   GlobalUnlock(This->supportHandle);
 404
 405   /*
 406    * The function returns S_OK if the specified number of bytes were read
 407    * or the end of the array was reached.
 408    * It returns STG_E_READFAULT if the number of bytes to read does not equal
 409    * the number of bytes actually read.
 410    */
 411   if(*pcbRead == cb)
 412     return S_OK;
 413
 414   return STG_E_READFAULT;
 415 }
 416
 417 /******************************************************************************
 418  * This method is part of the ILockBytes interface.
 419  *
 420  * It writes the specified bytes at the specified offset.
 421  * position. If the array is too small, it will be resized.
 422  *
 423  * See the documentation of ILockBytes for more info.
 424  */
 425 static HRESULT WINAPI HGLOBALLockBytesImpl_WriteAt(
 426       ILockBytes*    iface,
 427       ULARGE_INTEGER ulOffset,    /* [in] */
 428       const void*    pv,          /* [size_is][in] */
 429       ULONG          cb,          /* [in] */
 430       ULONG*         pcbWritten)  /* [out] */
 431 {
 432   HGLOBALLockBytesImpl* const This=(HGLOBALLockBytesImpl*)iface;
 433
 434   void*          supportBuffer;
 435   ULARGE_INTEGER newSize;
 436   ULONG          bytesWritten = 0;
 437
 438   /*
 439    * If the caller is not interested in the number of bytes written,
 440    * we use another buffer to avoid "if" statements in the code.
 441    */
 442   if (pcbWritten == 0)
 443     pcbWritten = &bytesWritten;
 444
 445   if (cb == 0)
 446   {
 447     return S_OK;
 448   }
 449   else
 450   {
 451     newSize.u.HighPart = 0;
 452     newSize.u.LowPart = ulOffset.u.LowPart + cb;
 453   }
 454
 455   /*
 456    * Verify if we need to grow the stream
 457    */
 458   if (newSize.u.LowPart > This->byteArraySize.u.LowPart)
 459   {
 460     /* grow stream */
 461     if (HGLOBALLockBytesImpl_SetSize(iface, newSize) == STG_E_MEDIUMFULL)
 462       return STG_E_MEDIUMFULL;
 463   }
 464
 465   /*
 466    * Lock the buffer in position and copy the data.
 467    */
 468   supportBuffer = GlobalLock(This->supportHandle);
 469
 470   memcpy((char *) supportBuffer + ulOffset.u.LowPart, pv, cb);
 471
 472   /*
 473    * Return the number of bytes written.
 474    */
 475   *pcbWritten = cb;
 476
 477   /*
 478    * Cleanup
 479    */
 480   GlobalUnlock(This->supportHandle);
 481
 482   return S_OK;
 483 }
 484
 485 /******************************************************************************
 486  * This method is part of the ILockBytes interface.
 487  *
 488  * See the documentation of ILockBytes for more info.
 489  */
 490 static HRESULT WINAPI HGLOBALLockBytesImpl_Flush(ILockBytes* iface)
 491 {
 492   return S_OK;
 493 }
 494
 495 /******************************************************************************
 496  * This method is part of the ILockBytes interface.
 497  *
 498  * It will change the size of the byte array.
 499  *
 500  * See the documentation of ILockBytes for more info.
 501  */
 502 static HRESULT WINAPI HGLOBALLockBytesImpl_SetSize(
 503       ILockBytes*     iface,
 504       ULARGE_INTEGER  libNewSize)   /* [in] */
 505 {
 506   HGLOBALLockBytesImpl* const This=(HGLOBALLockBytesImpl*)iface;
 507   HGLOBAL supportHandle;
 508
 509   /*
 510    * As documented.
 511    */
 512   if (libNewSize.u.HighPart != 0)
 513     return STG_E_INVALIDFUNCTION;
 514
 515   if (This->byteArraySize.u.LowPart == libNewSize.u.LowPart)
 516     return S_OK;
 517
 518   /*
 519    * Re allocate the HGlobal to fit the new size of the stream.
 520    */
 521   supportHandle = GlobalReAlloc(This->supportHandle, libNewSize.u.LowPart, 0);
 522
 523   if (supportHandle == 0)
 524     return STG_E_MEDIUMFULL;
 525
 526   This->supportHandle = supportHandle;
 527   This->byteArraySize.u.LowPart = libNewSize.u.LowPart;
 528
 529   return S_OK;
 530 }
 531
 532 /******************************************************************************
 533  * This method is part of the ILockBytes interface.
 534  *
 535  * The global memory implementation of ILockBytes does not support locking.
 536  *
 537  * See the documentation of ILockBytes for more info.
 538  */
 539 static HRESULT WINAPI HGLOBALLockBytesImpl_LockRegion(
 540       ILockBytes*    iface,
 541       ULARGE_INTEGER libOffset,   /* [in] */
 542       ULARGE_INTEGER cb,          /* [in] */
 543       DWORD          dwLockType)  /* [in] */
 544 {
 545   return STG_E_INVALIDFUNCTION;
 546 }
 547
 548 /******************************************************************************
 549  * This method is part of the ILockBytes interface.
 550  *
 551  * The global memory implementation of ILockBytes does not support locking.
 552  *
 553  * See the documentation of ILockBytes for more info.
 554  */
 555 static HRESULT WINAPI HGLOBALLockBytesImpl_UnlockRegion(
 556       ILockBytes*    iface,
 557       ULARGE_INTEGER libOffset,   /* [in] */
 558       ULARGE_INTEGER cb,          /* [in] */
 559       DWORD          dwLockType)  /* [in] */
 560 {
 561   return STG_E_INVALIDFUNCTION;
 562 }
 563
 564 /******************************************************************************
 565  * This method is part of the ILockBytes interface.
 566  *
 567  * This method returns information about the current
 568  * byte array object.
 569  *
 570  * See the documentation of ILockBytes for more info.
 571  */
 572 static HRESULT WINAPI HGLOBALLockBytesImpl_Stat(
 573       ILockBytes*  iface,
 574       STATSTG*     pstatstg,     /* [out] */
 575       DWORD        grfStatFlag)  /* [in] */
 576 {
 577   HGLOBALLockBytesImpl* const This=(HGLOBALLockBytesImpl*)iface;
 578
 579   memset(pstatstg, 0, sizeof(STATSTG));
 580
 581   pstatstg->pwcsName = NULL;
 582   pstatstg->type     = STGTY_LOCKBYTES;
 583   pstatstg->cbSize   = This->byteArraySize;
 584
 585   return S_OK;
 586 }
 587
 588 /*
 589  * Virtual function table for the HGLOBALLockBytesImpl class.
 590  */
 591 static const ILockBytesVtbl HGLOBALLockBytesImpl_Vtbl =
 592 {
 593     HGLOBALLockBytesImpl_QueryInterface,
 594     HGLOBALLockBytesImpl_AddRef,
 595     HGLOBALLockBytesImpl_Release,
 596     HGLOBALLockBytesImpl_ReadAt,
 597     HGLOBALLockBytesImpl_WriteAt,
 598     HGLOBALLockBytesImpl_Flush,
 599     HGLOBALLockBytesImpl_SetSize,
 600     HGLOBALLockBytesImpl_LockRegion,
 601     HGLOBALLockBytesImpl_UnlockRegion,
 602     HGLOBALLockBytesImpl_Stat,
 603 };