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   ILockBytes ILockBytes_iface;
  52   LONG ref;
  53
  54   /*
  55    * Support for the LockBytes object
  56    */
  57   HGLOBAL supportHandle;
  58
  59   /*
  60    * This flag is TRUE if the HGLOBAL is destroyed when the object
  61    * is finally released.
  62    */
  63   BOOL    deleteOnRelease;
  64
  65   /*
  66    * Helper variable that contains the size of the byte array
  67    */
  68   ULARGE_INTEGER     byteArraySize;
  69 };
  70
  71 typedef struct HGLOBALLockBytesImpl HGLOBALLockBytesImpl;
  72
  73 static inline HGLOBALLockBytesImpl *impl_from_ILockBytes( ILockBytes *iface )
  74 {
  75     return CONTAINING_RECORD(iface, HGLOBALLockBytesImpl, ILockBytes_iface);
  76 }
  77
  78 static const ILockBytesVtbl HGLOBALLockBytesImpl_Vtbl;
  79
  80 /******************************************************************************
  81  *           CreateILockBytesOnHGlobal     [OLE32.@]
  82  *
  83  * Create a byte array object which is intended to be the compound file foundation.
  84  * This object supports a COM implementation of the ILockBytes interface.
  85  *
  86  * PARAMS
  87  *  global            [ I] Global memory handle
  88  *  delete_on_release [ I] Whether the handle should be freed when the object is released.
  89  *  ret               [ O] Address of ILockBytes pointer that receives
  90  *                         the interface pointer to the new byte array object.
  91  *
  92  * RETURNS
  93  *  Success: S_OK
  94  *
  95  * NOTES
  96  *  The supplied ILockBytes pointer can be used by the StgCreateDocfileOnILockBytes
  97  *  function to build a compound file on top of this byte array object.
  98  *  The ILockBytes interface instance calls the GlobalReAlloc function to grow
  99  *  the memory block as required.
 100  */
 101 HRESULT WINAPI CreateILockBytesOnHGlobal(HGLOBAL global, BOOL delete_on_release, ILockBytes **ret)
 102 {
 103   HGLOBALLockBytesImpl* lockbytes;
 104
 105   lockbytes = HeapAlloc(GetProcessHeap(), 0, sizeof(HGLOBALLockBytesImpl));
 106   if (!lockbytes) return E_OUTOFMEMORY;
 107
 108   lockbytes->ILockBytes_iface.lpVtbl = &HGLOBALLockBytesImpl_Vtbl;
 109   lockbytes->ref = 1;
 110
 111   /*
 112    * Initialize the support.
 113    */
 114   lockbytes->supportHandle = global;
 115   lockbytes->deleteOnRelease = delete_on_release;
 116
 117   /*
 118    * This method will allocate a handle if one is not supplied.
 119    */
 120   if (lockbytes->supportHandle == 0)
 121     lockbytes->supportHandle = GlobalAlloc(GMEM_MOVEABLE | GMEM_NODISCARD, 0);
 122
 123   /*
 124    * Initialize the size of the array to the size of the handle.
 125    */
 126   lockbytes->byteArraySize.u.HighPart = 0;
 127   lockbytes->byteArraySize.u.LowPart  = GlobalSize(lockbytes->supportHandle);
 128
 129   *ret = &lockbytes->ILockBytes_iface;
 130
 131   return S_OK;
 132 }
 133
 134 /******************************************************************************
 135  *           GetHGlobalFromILockBytes     [OLE32.@]
 136  *
 137  * Retrieve a global memory handle to a byte array object created
 138  * using the CreateILockBytesOnHGlobal function.
 139  *
 140  * PARAMS
 141  *  plkbyt   [ I]  Pointer to the ILockBytes interface on byte array object
 142  *  phglobal [ O]  Address to store a global memory handle
 143  * RETURNS
 144  *  S_OK          if *phglobal has a correct value
 145  *  E_INVALIDARG  if any parameters are invalid
 146  *
 147  */
 148 HRESULT WINAPI GetHGlobalFromILockBytes(ILockBytes* iface, HGLOBAL* phglobal)
 149 {
 150   HGLOBALLockBytesImpl* This = impl_from_ILockBytes(iface);
 151   STATSTG stbuf;
 152   HRESULT hres;
 153   ULARGE_INTEGER start;
 154   ULONG xread;
 155
 156   *phglobal = 0;
 157   if (This->ILockBytes_iface.lpVtbl == &HGLOBALLockBytesImpl_Vtbl) {
 158     *phglobal = This->supportHandle;
 159     if (*phglobal == 0)
 160       return E_INVALIDARG;
 161     return S_OK;
 162   }
 163   /* It is not our lockbytes implementation, so use a more generic way */
 164   hres = ILockBytes_Stat(iface,&stbuf,STATFLAG_NONAME);
 165   if (hres != S_OK) {
 166      ERR("Cannot ILockBytes_Stat, %x\n",hres);
 167      return hres;
 168   }
 169   TRACE("cbSize is %s\n", wine_dbgstr_longlong(stbuf.cbSize.QuadPart));
 170   *phglobal = GlobalAlloc( GMEM_MOVEABLE|GMEM_SHARE, stbuf.cbSize.u.LowPart);
 171   if (!*phglobal)
 172     return E_INVALIDARG;
 173   memset(&start,0,sizeof(start));
 174   hres = ILockBytes_ReadAt(iface, start, GlobalLock(*phglobal), stbuf.cbSize.u.LowPart, &xread);
 175   GlobalUnlock(*phglobal);
 176   if (hres != S_OK) {
 177     FIXME("%p->ReadAt failed with %x\n",iface,hres);
 178     return hres;
 179   }
 180   if (stbuf.cbSize.u.LowPart != xread) {
 181     FIXME("Read size is not requested size %d vs %d?\n",stbuf.cbSize.u.LowPart, xread);
 182   }
 183   return S_OK;
 184 }
 185
 186 /******************************************************************************
 187  *
 188  * HGLOBALLockBytesImpl implementation
 189  *
 190  */
 191
 192 /******************************************************************************
 193  * This implements the IUnknown method QueryInterface for this
 194  * class
 195  */
 196 static HRESULT WINAPI HGLOBALLockBytesImpl_QueryInterface(
 197       ILockBytes*  iface,
 198       REFIID       riid,        /* [in] */
 199       void**       ppvObject)   /* [iid_is][out] */
 200 {
 201   HGLOBALLockBytesImpl* This = impl_from_ILockBytes(iface);
 202
 203   if (ppvObject==0)
 204     return E_INVALIDARG;
 205
 206   *ppvObject = 0;
 207
 208   if (IsEqualIID(riid, &IID_IUnknown) ||
 209       IsEqualIID(riid, &IID_ILockBytes))
 210   {
 211     *ppvObject = &This->ILockBytes_iface;
 212   }
 213   else
 214     return E_NOINTERFACE;
 215
 216   ILockBytes_AddRef(iface);
 217
 218   return S_OK;
 219 }
 220
 221 /******************************************************************************
 222  * This implements the IUnknown method AddRef for this
 223  * class
 224  */
 225 static ULONG WINAPI HGLOBALLockBytesImpl_AddRef(ILockBytes* iface)
 226 {
 227   HGLOBALLockBytesImpl* This = impl_from_ILockBytes(iface);
 228   return InterlockedIncrement(&This->ref);
 229 }
 230
 231 /******************************************************************************
 232  * This implements the IUnknown method Release for this
 233  * class
 234  */
 235 static ULONG WINAPI HGLOBALLockBytesImpl_Release(ILockBytes* iface)
 236 {
 237   HGLOBALLockBytesImpl* This = impl_from_ILockBytes(iface);
 238   ULONG ref;
 239
 240   ref = InterlockedDecrement(&This->ref);
 241   if (!ref)
 242   {
 243     if (This->deleteOnRelease)
 244     {
 245       GlobalFree(This->supportHandle);
 246       This->supportHandle = 0;
 247     }
 248     HeapFree(GetProcessHeap(), 0, This);
 249   }
 250
 251   return ref;
 252 }
 253
 254 /******************************************************************************
 255  * This method is part of the ILockBytes interface.
 256  *
 257  * It reads a block of information from the byte array at the specified
 258  * offset.
 259  *
 260  * See the documentation of ILockBytes for more info.
 261  */
 262 static HRESULT WINAPI HGLOBALLockBytesImpl_ReadAt(
 263       ILockBytes*    iface,
 264       ULARGE_INTEGER ulOffset,  /* [in] */
 265       void*          pv,        /* [length_is][size_is][out] */
 266       ULONG          cb,        /* [in] */
 267       ULONG*         pcbRead)   /* [out] */
 268 {
 269   HGLOBALLockBytesImpl* This = impl_from_ILockBytes(iface);
 270
 271   void* supportBuffer;
 272   ULONG bytesReadBuffer = 0;
 273   ULONG bytesToReadFromBuffer;
 274
 275   /*
 276    * If the caller is not interested in the number of bytes read,
 277    * we use another buffer to avoid "if" statements in the code.
 278    */
 279   if (pcbRead == 0)
 280     pcbRead = &bytesReadBuffer;
 281
 282   /*
 283    * Make sure the offset is valid.
 284    */
 285   if (ulOffset.u.LowPart > This->byteArraySize.u.LowPart)
 286     return E_FAIL;
 287
 288   /*
 289    * Using the known size of the array, calculate the number of bytes
 290    * to read.
 291    */
 292   bytesToReadFromBuffer = min(This->byteArraySize.u.LowPart -
 293                               ulOffset.u.LowPart, cb);
 294
 295   /*
 296    * Lock the buffer in position and copy the data.
 297    */
 298   supportBuffer = GlobalLock(This->supportHandle);
 299
 300   memcpy(pv,
 301          (char *) supportBuffer + ulOffset.u.LowPart,
 302          bytesToReadFromBuffer);
 303
 304   /*
 305    * Return the number of bytes read.
 306    */
 307   *pcbRead = bytesToReadFromBuffer;
 308
 309   /*
 310    * Cleanup
 311    */
 312   GlobalUnlock(This->supportHandle);
 313
 314   /*
 315    * The function returns S_OK if the specified number of bytes were read
 316    * or the end of the array was reached.
 317    * It returns STG_E_READFAULT if the number of bytes to read does not equal
 318    * the number of bytes actually read.
 319    */
 320   if(*pcbRead == cb)
 321     return S_OK;
 322
 323   return STG_E_READFAULT;
 324 }
 325
 326 /******************************************************************************
 327  * This method is part of the ILockBytes interface.
 328  *
 329  * It writes the specified bytes at the specified offset.
 330  * position. If the array is too small, it will be resized.
 331  *
 332  * See the documentation of ILockBytes for more info.
 333  */
 334 static HRESULT WINAPI HGLOBALLockBytesImpl_WriteAt(
 335       ILockBytes*    iface,
 336       ULARGE_INTEGER ulOffset,    /* [in] */
 337       const void*    pv,          /* [size_is][in] */
 338       ULONG          cb,          /* [in] */
 339       ULONG*         pcbWritten)  /* [out] */
 340 {
 341   HGLOBALLockBytesImpl* This = impl_from_ILockBytes(iface);
 342
 343   void*          supportBuffer;
 344   ULARGE_INTEGER newSize;
 345   ULONG          bytesWritten = 0;
 346
 347   /*
 348    * If the caller is not interested in the number of bytes written,
 349    * we use another buffer to avoid "if" statements in the code.
 350    */
 351   if (pcbWritten == 0)
 352     pcbWritten = &bytesWritten;
 353
 354   if (cb == 0)
 355   {
 356     return S_OK;
 357   }
 358   else
 359   {
 360     newSize.u.HighPart = 0;
 361     newSize.u.LowPart = ulOffset.u.LowPart + cb;
 362   }
 363
 364   /*
 365    * Verify if we need to grow the stream
 366    */
 367   if (newSize.u.LowPart > This->byteArraySize.u.LowPart)
 368   {
 369     /* grow stream */
 370     if (ILockBytes_SetSize(iface, newSize) == STG_E_MEDIUMFULL)
 371       return STG_E_MEDIUMFULL;
 372   }
 373
 374   /*
 375    * Lock the buffer in position and copy the data.
 376    */
 377   supportBuffer = GlobalLock(This->supportHandle);
 378
 379   memcpy((char *) supportBuffer + ulOffset.u.LowPart, pv, cb);
 380
 381   /*
 382    * Return the number of bytes written.
 383    */
 384   *pcbWritten = cb;
 385
 386   /*
 387    * Cleanup
 388    */
 389   GlobalUnlock(This->supportHandle);
 390
 391   return S_OK;
 392 }
 393
 394 /******************************************************************************
 395  * This method is part of the ILockBytes interface.
 396  *
 397  * See the documentation of ILockBytes for more info.
 398  */
 399 static HRESULT WINAPI HGLOBALLockBytesImpl_Flush(ILockBytes* iface)
 400 {
 401   return S_OK;
 402 }
 403
 404 /******************************************************************************
 405  * This method is part of the ILockBytes interface.
 406  *
 407  * It will change the size of the byte array.
 408  *
 409  * See the documentation of ILockBytes for more info.
 410  */
 411 static HRESULT WINAPI HGLOBALLockBytesImpl_SetSize(
 412       ILockBytes*     iface,
 413       ULARGE_INTEGER  libNewSize)   /* [in] */
 414 {
 415   HGLOBALLockBytesImpl* This = impl_from_ILockBytes(iface);
 416   HGLOBAL supportHandle;
 417
 418   /*
 419    * As documented.
 420    */
 421   if (libNewSize.u.HighPart != 0)
 422     return STG_E_INVALIDFUNCTION;
 423
 424   if (This->byteArraySize.u.LowPart == libNewSize.u.LowPart)
 425     return S_OK;
 426
 427   /*
 428    * Re allocate the HGlobal to fit the new size of the stream.
 429    */
 430   supportHandle = GlobalReAlloc(This->supportHandle, libNewSize.u.LowPart, 0);
 431
 432   if (supportHandle == 0)
 433     return STG_E_MEDIUMFULL;
 434
 435   This->supportHandle = supportHandle;
 436   This->byteArraySize.u.LowPart = libNewSize.u.LowPart;
 437
 438   return S_OK;
 439 }
 440
 441 /******************************************************************************
 442  * This method is part of the ILockBytes interface.
 443  *
 444  * The global memory implementation of ILockBytes does not support locking.
 445  *
 446  * See the documentation of ILockBytes for more info.
 447  */
 448 static HRESULT WINAPI HGLOBALLockBytesImpl_LockRegion(
 449       ILockBytes*    iface,
 450       ULARGE_INTEGER libOffset,   /* [in] */
 451       ULARGE_INTEGER cb,          /* [in] */
 452       DWORD          dwLockType)  /* [in] */
 453 {
 454   return STG_E_INVALIDFUNCTION;
 455 }
 456
 457 /******************************************************************************
 458  * This method is part of the ILockBytes interface.
 459  *
 460  * The global memory implementation of ILockBytes does not support locking.
 461  *
 462  * See the documentation of ILockBytes for more info.
 463  */
 464 static HRESULT WINAPI HGLOBALLockBytesImpl_UnlockRegion(
 465       ILockBytes*    iface,
 466       ULARGE_INTEGER libOffset,   /* [in] */
 467       ULARGE_INTEGER cb,          /* [in] */
 468       DWORD          dwLockType)  /* [in] */
 469 {
 470   return STG_E_INVALIDFUNCTION;
 471 }
 472
 473 /******************************************************************************
 474  * This method is part of the ILockBytes interface.
 475  *
 476  * This method returns information about the current
 477  * byte array object.
 478  *
 479  * See the documentation of ILockBytes for more info.
 480  */
 481 static HRESULT WINAPI HGLOBALLockBytesImpl_Stat(
 482       ILockBytes*  iface,
 483       STATSTG*     pstatstg,     /* [out] */
 484       DWORD        grfStatFlag)  /* [in] */
 485 {
 486   HGLOBALLockBytesImpl* This = impl_from_ILockBytes(iface);
 487
 488   memset(pstatstg, 0, sizeof(STATSTG));
 489
 490   pstatstg->pwcsName = NULL;
 491   pstatstg->type     = STGTY_LOCKBYTES;
 492   pstatstg->cbSize   = This->byteArraySize;
 493
 494   return S_OK;
 495 }
 496
 497 /*
 498  * Virtual function table for the HGLOBALLockBytesImpl class.
 499  */
 500 static const ILockBytesVtbl HGLOBALLockBytesImpl_Vtbl =
 501 {
 502     HGLOBALLockBytesImpl_QueryInterface,
 503     HGLOBALLockBytesImpl_AddRef,
 504     HGLOBALLockBytesImpl_Release,
 505     HGLOBALLockBytesImpl_ReadAt,
 506     HGLOBALLockBytesImpl_WriteAt,
 507     HGLOBALLockBytesImpl_Flush,
 508     HGLOBALLockBytesImpl_SetSize,
 509     HGLOBALLockBytesImpl_LockRegion,
 510     HGLOBALLockBytesImpl_UnlockRegion,
 511     HGLOBALLockBytesImpl_Stat,
 512 };