ole/memlockbytes.c

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