dlls/ole32/hglobalstream.c

   1 /*
   2  * HGLOBAL Stream implementation
   3  *
   4  * This file contains the implementation of the stream interface
   5  * for streams contained supported by an HGLOBAL pointer.
   6  *
   7  * Copyright 1999 Francis Beaudet
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 #include <assert.h>
  25 #include <stdlib.h>
  26 #include <stdarg.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29
  30 #define COBJMACROS
  31 #define NONAMELESSUNION
  32
  33 #include "windef.h"
  34 #include "winbase.h"
  35 #include "winuser.h"
  36 #include "objbase.h"
  37 #include "ole2.h"
  38 #include "winerror.h"
  39 #include "winternl.h"
  40
  41 #include "wine/debug.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(storage);
  44
  45 /****************************************************************************
  46  * HGLOBALStreamImpl definition.
  47  *
  48  * This class implements the IStream interface and represents a stream
  49  * supported by an HGLOBAL pointer.
  50  */
  51 typedef struct
  52 {
  53   IStream IStream_iface;
  54   LONG ref;
  55
  56   /* support for the stream */
  57   HGLOBAL supportHandle;
  58
  59   /* if TRUE the HGLOBAL is destroyed when the stream is finally released */
  60   BOOL deleteOnRelease;
  61
  62   /* size of the stream */
  63   ULARGE_INTEGER streamSize;
  64
  65   /* current position of the cursor */
  66   ULARGE_INTEGER currentPosition;
  67 } HGLOBALStreamImpl;
  68
  69 static inline HGLOBALStreamImpl *impl_from_IStream(IStream *iface)
  70 {
  71   return CONTAINING_RECORD(iface, HGLOBALStreamImpl, IStream_iface);
  72 }
  73
  74 static HRESULT WINAPI HGLOBALStreamImpl_QueryInterface(
  75                   IStream*     iface,
  76                   REFIID         riid,        /* [in] */
  77                   void**         ppvObject)   /* [iid_is][out] */
  78 {
  79   HGLOBALStreamImpl* This = impl_from_IStream(iface);
  80
  81   if (ppvObject==0)
  82     return E_INVALIDARG;
  83
  84   *ppvObject = 0;
  85
  86   if (IsEqualIID(&IID_IUnknown, riid) ||
  87       IsEqualIID(&IID_ISequentialStream, riid) ||
  88       IsEqualIID(&IID_IStream, riid))
  89   {
  90     *ppvObject = &This->IStream_iface;
  91   }
  92
  93   if ((*ppvObject)==0)
  94     return E_NOINTERFACE;
  95
  96   IStream_AddRef(iface);
  97
  98   return S_OK;
  99 }
 100
 101 static ULONG WINAPI HGLOBALStreamImpl_AddRef(IStream* iface)
 102 {
 103   HGLOBALStreamImpl* This = impl_from_IStream(iface);
 104   return InterlockedIncrement(&This->ref);
 105 }
 106
 107 static ULONG WINAPI HGLOBALStreamImpl_Release(
 108                 IStream* iface)
 109 {
 110   HGLOBALStreamImpl* This= impl_from_IStream(iface);
 111   ULONG ref = InterlockedDecrement(&This->ref);
 112
 113   if (!ref)
 114   {
 115     if (This->deleteOnRelease)
 116     {
 117       GlobalFree(This->supportHandle);
 118       This->supportHandle = NULL;
 119     }
 120
 121     HeapFree(GetProcessHeap(), 0, This);
 122   }
 123
 124   return ref;
 125 }
 126
 127 /***
 128  * This method is part of the ISequentialStream interface.
 129  *
 130  * If reads a block of information from the stream at the current
 131  * position. It then moves the current position at the end of the
 132  * read block
 133  *
 134  * See the documentation of ISequentialStream for more info.
 135  */
 136 static HRESULT WINAPI HGLOBALStreamImpl_Read(
 137                   IStream*     iface,
 138                   void*          pv,        /* [length_is][size_is][out] */
 139                   ULONG          cb,        /* [in] */
 140                   ULONG*         pcbRead)   /* [out] */
 141 {
 142   HGLOBALStreamImpl* This = impl_from_IStream(iface);
 143
 144   void* supportBuffer;
 145   ULONG bytesReadBuffer;
 146   ULONG bytesToReadFromBuffer;
 147
 148   TRACE("(%p, %p, %d, %p)\n", iface,
 149         pv, cb, pcbRead);
 150
 151   /*
 152    * If the caller is not interested in the number of bytes read,
 153    * we use another buffer to avoid "if" statements in the code.
 154    */
 155   if (pcbRead==0)
 156     pcbRead = &bytesReadBuffer;
 157
 158   /*
 159    * Using the known size of the stream, calculate the number of bytes
 160    * to read from the block chain
 161    */
 162   bytesToReadFromBuffer = min( This->streamSize.u.LowPart - This->currentPosition.u.LowPart, cb);
 163
 164   /*
 165    * Lock the buffer in position and copy the data.
 166    */
 167   supportBuffer = GlobalLock(This->supportHandle);
 168   if (!supportBuffer)
 169   {
 170       WARN("read from invalid hglobal %p\n", This->supportHandle);
 171       *pcbRead = 0;
 172       return S_OK;
 173   }
 174
 175   memcpy(pv, (char *) supportBuffer+This->currentPosition.u.LowPart, bytesToReadFromBuffer);
 176
 177   /*
 178    * Move the current position to the new position
 179    */
 180   This->currentPosition.u.LowPart+=bytesToReadFromBuffer;
 181
 182   /*
 183    * Return the number of bytes read.
 184    */
 185   *pcbRead = bytesToReadFromBuffer;
 186
 187   /*
 188    * Cleanup
 189    */
 190   GlobalUnlock(This->supportHandle);
 191
 192   /*
 193    * Always returns S_OK even if the end of the stream is reached before the
 194    * buffer is filled
 195    */
 196
 197   return S_OK;
 198 }
 199
 200 /***
 201  * This method is part of the ISequentialStream interface.
 202  *
 203  * It writes a block of information to the stream at the current
 204  * position. It then moves the current position at the end of the
 205  * written block. If the stream is too small to fit the block,
 206  * the stream is grown to fit.
 207  *
 208  * See the documentation of ISequentialStream for more info.
 209  */
 210 static HRESULT WINAPI HGLOBALStreamImpl_Write(
 211                   IStream*     iface,
 212                   const void*    pv,          /* [size_is][in] */
 213                   ULONG          cb,          /* [in] */
 214                   ULONG*         pcbWritten)  /* [out] */
 215 {
 216   HGLOBALStreamImpl* This = impl_from_IStream(iface);
 217
 218   void*          supportBuffer;
 219   ULARGE_INTEGER newSize;
 220   ULONG          bytesWritten = 0;
 221
 222   TRACE("(%p, %p, %d, %p)\n", iface, pv, cb, pcbWritten);
 223
 224   /*
 225    * If the caller is not interested in the number of bytes written,
 226    * we use another buffer to avoid "if" statements in the code.
 227    */
 228   if (pcbWritten == 0)
 229     pcbWritten = &bytesWritten;
 230
 231   if (cb == 0)
 232     goto out;
 233
 234   *pcbWritten = 0;
 235
 236   newSize.u.HighPart = 0;
 237   newSize.u.LowPart = This->currentPosition.u.LowPart + cb;
 238
 239   /*
 240    * Verify if we need to grow the stream
 241    */
 242   if (newSize.u.LowPart > This->streamSize.u.LowPart)
 243   {
 244     /* grow stream */
 245     HRESULT hr = IStream_SetSize(iface, newSize);
 246     if (FAILED(hr))
 247     {
 248       ERR("IStream_SetSize failed with error 0x%08x\n", hr);
 249       return hr;
 250     }
 251   }
 252
 253   /*
 254    * Lock the buffer in position and copy the data.
 255    */
 256   supportBuffer = GlobalLock(This->supportHandle);
 257   if (!supportBuffer)
 258   {
 259       WARN("write to invalid hglobal %p\n", This->supportHandle);
 260       return S_OK;
 261   }
 262
 263   memcpy((char *) supportBuffer+This->currentPosition.u.LowPart, pv, cb);
 264
 265   /*
 266    * Move the current position to the new position
 267    */
 268   This->currentPosition.u.LowPart+=cb;
 269
 270   /*
 271    * Cleanup
 272    */
 273   GlobalUnlock(This->supportHandle);
 274
 275 out:
 276   /*
 277    * Return the number of bytes read.
 278    */
 279   *pcbWritten = cb;
 280
 281   return S_OK;
 282 }
 283
 284 /***
 285  * This method is part of the IStream interface.
 286  *
 287  * It will move the current stream pointer according to the parameters
 288  * given.
 289  *
 290  * See the documentation of IStream for more info.
 291  */
 292 static HRESULT WINAPI HGLOBALStreamImpl_Seek(
 293                   IStream*      iface,
 294                   LARGE_INTEGER   dlibMove,         /* [in] */
 295                   DWORD           dwOrigin,         /* [in] */
 296                   ULARGE_INTEGER* plibNewPosition) /* [out] */
 297 {
 298   HGLOBALStreamImpl* This = impl_from_IStream(iface);
 299
 300   ULARGE_INTEGER newPosition = This->currentPosition;
 301   HRESULT hr = S_OK;
 302
 303   TRACE("(%p, %x%08x, %d, %p)\n", iface, dlibMove.u.HighPart,
 304         dlibMove.u.LowPart, dwOrigin, plibNewPosition);
 305
 306   /*
 307    * The file pointer is moved depending on the given "function"
 308    * parameter.
 309    */
 310   switch (dwOrigin)
 311   {
 312     case STREAM_SEEK_SET:
 313       newPosition.u.HighPart = 0;
 314       newPosition.u.LowPart = 0;
 315       break;
 316     case STREAM_SEEK_CUR:
 317       break;
 318     case STREAM_SEEK_END:
 319       newPosition = This->streamSize;
 320       break;
 321     default:
 322       hr = STG_E_SEEKERROR;
 323       goto end;
 324   }
 325
 326   /*
 327    * Move the actual file pointer
 328    * If the file pointer ends-up after the end of the stream, the next Write operation will
 329    * make the file larger. This is how it is documented.
 330    */
 331   newPosition.u.HighPart = 0;
 332   newPosition.u.LowPart += dlibMove.QuadPart;
 333
 334   if (dlibMove.u.LowPart >= 0x80000000 &&
 335       newPosition.u.LowPart >= dlibMove.u.LowPart)
 336   {
 337     /* We tried to seek backwards and went past the start. */
 338     hr = STG_E_SEEKERROR;
 339     goto end;
 340   }
 341
 342   This->currentPosition = newPosition;
 343
 344 end:
 345   if (plibNewPosition) *plibNewPosition = This->currentPosition;
 346
 347   return hr;
 348 }
 349
 350 /***
 351  * This method is part of the IStream interface.
 352  *
 353  * It will change the size of a stream.
 354  *
 355  * TODO: Switch from small blocks to big blocks and vice versa.
 356  *
 357  * See the documentation of IStream for more info.
 358  */
 359 static HRESULT WINAPI HGLOBALStreamImpl_SetSize(
 360                                      IStream*      iface,
 361                                      ULARGE_INTEGER  libNewSize)   /* [in] */
 362 {
 363   HGLOBALStreamImpl* This = impl_from_IStream(iface);
 364   HGLOBAL supportHandle;
 365
 366   TRACE("(%p, %d)\n", iface, libNewSize.u.LowPart);
 367
 368   /*
 369    * HighPart is ignored as shown in tests
 370    */
 371
 372   if (This->streamSize.u.LowPart == libNewSize.u.LowPart)
 373     return S_OK;
 374
 375   /*
 376    * Re allocate the HGlobal to fit the new size of the stream.
 377    */
 378   supportHandle = GlobalReAlloc(This->supportHandle, libNewSize.u.LowPart, 0);
 379
 380   if (supportHandle == 0)
 381     return E_OUTOFMEMORY;
 382
 383   This->supportHandle = supportHandle;
 384   This->streamSize.u.LowPart = libNewSize.u.LowPart;
 385
 386   return S_OK;
 387 }
 388
 389 /***
 390  * This method is part of the IStream interface.
 391  *
 392  * It will copy the 'cb' Bytes to 'pstm' IStream.
 393  *
 394  * See the documentation of IStream for more info.
 395  */
 396 static HRESULT WINAPI HGLOBALStreamImpl_CopyTo(
 397                                     IStream*      iface,
 398                                     IStream*      pstm,         /* [unique][in] */
 399                                     ULARGE_INTEGER  cb,           /* [in] */
 400                                     ULARGE_INTEGER* pcbRead,      /* [out] */
 401                                     ULARGE_INTEGER* pcbWritten)   /* [out] */
 402 {
 403   HRESULT        hr = S_OK;
 404   BYTE           tmpBuffer[128];
 405   ULONG          bytesRead, bytesWritten, copySize;
 406   ULARGE_INTEGER totalBytesRead;
 407   ULARGE_INTEGER totalBytesWritten;
 408
 409   TRACE("(%p, %p, %d, %p, %p)\n", iface, pstm,
 410         cb.u.LowPart, pcbRead, pcbWritten);
 411
 412   if ( pstm == 0 )
 413     return STG_E_INVALIDPOINTER;
 414
 415   totalBytesRead.QuadPart = 0;
 416   totalBytesWritten.QuadPart = 0;
 417
 418   while ( cb.QuadPart > 0 )
 419   {
 420     if ( cb.QuadPart >= sizeof(tmpBuffer) )
 421       copySize = sizeof(tmpBuffer);
 422     else
 423       copySize = cb.u.LowPart;
 424
 425     hr = IStream_Read(iface, tmpBuffer, copySize, &bytesRead);
 426     if (FAILED(hr))
 427         break;
 428
 429     totalBytesRead.QuadPart += bytesRead;
 430
 431     if (bytesRead)
 432     {
 433         hr = IStream_Write(pstm, tmpBuffer, bytesRead, &bytesWritten);
 434         if (FAILED(hr))
 435             break;
 436
 437         totalBytesWritten.QuadPart += bytesWritten;
 438     }
 439
 440     if (bytesRead!=copySize)
 441       cb.QuadPart = 0;
 442     else
 443       cb.QuadPart -= bytesRead;
 444   }
 445
 446   if (pcbRead) pcbRead->QuadPart = totalBytesRead.QuadPart;
 447   if (pcbWritten) pcbWritten->QuadPart = totalBytesWritten.QuadPart;
 448
 449   return hr;
 450 }
 451
 452 /***
 453  * This method is part of the IStream interface.
 454  *
 455  * For streams supported by HGLOBALS, this function does nothing.
 456  * This is what the documentation tells us.
 457  *
 458  * See the documentation of IStream for more info.
 459  */
 460 static HRESULT WINAPI HGLOBALStreamImpl_Commit(
 461                   IStream*      iface,
 462                   DWORD         grfCommitFlags)  /* [in] */
 463 {
 464   return S_OK;
 465 }
 466
 467 /***
 468  * This method is part of the IStream interface.
 469  *
 470  * For streams supported by HGLOBALS, this function does nothing.
 471  * This is what the documentation tells us.
 472  *
 473  * See the documentation of IStream for more info.
 474  */
 475 static HRESULT WINAPI HGLOBALStreamImpl_Revert(
 476                   IStream* iface)
 477 {
 478   return S_OK;
 479 }
 480
 481 /***
 482  * This method is part of the IStream interface.
 483  *
 484  * For streams supported by HGLOBALS, this function does nothing.
 485  * This is what the documentation tells us.
 486  *
 487  * See the documentation of IStream for more info.
 488  */
 489 static HRESULT WINAPI HGLOBALStreamImpl_LockRegion(
 490                   IStream*       iface,
 491                   ULARGE_INTEGER libOffset,   /* [in] */
 492                   ULARGE_INTEGER cb,          /* [in] */
 493                   DWORD          dwLockType)  /* [in] */
 494 {
 495   return STG_E_INVALIDFUNCTION;
 496 }
 497
 498 /*
 499  * This method is part of the IStream interface.
 500  *
 501  * For streams supported by HGLOBALS, this function does nothing.
 502  * This is what the documentation tells us.
 503  *
 504  * See the documentation of IStream for more info.
 505  */
 506 static HRESULT WINAPI HGLOBALStreamImpl_UnlockRegion(
 507                   IStream*       iface,
 508                   ULARGE_INTEGER libOffset,   /* [in] */
 509                   ULARGE_INTEGER cb,          /* [in] */
 510                   DWORD          dwLockType)  /* [in] */
 511 {
 512   return S_OK;
 513 }
 514
 515 /***
 516  * This method is part of the IStream interface.
 517  *
 518  * This method returns information about the current
 519  * stream.
 520  *
 521  * See the documentation of IStream for more info.
 522  */
 523 static HRESULT WINAPI HGLOBALStreamImpl_Stat(
 524                   IStream*     iface,
 525                   STATSTG*     pstatstg,     /* [out] */
 526                   DWORD        grfStatFlag)  /* [in] */
 527 {
 528   HGLOBALStreamImpl* This = impl_from_IStream(iface);
 529
 530   memset(pstatstg, 0, sizeof(STATSTG));
 531
 532   pstatstg->pwcsName = NULL;
 533   pstatstg->type     = STGTY_STREAM;
 534   pstatstg->cbSize   = This->streamSize;
 535
 536   return S_OK;
 537 }
 538
 539 static HRESULT WINAPI HGLOBALStreamImpl_Clone(
 540                   IStream*     iface,
 541                   IStream**    ppstm) /* [out] */
 542 {
 543   HGLOBALStreamImpl* This = impl_from_IStream(iface);
 544   ULARGE_INTEGER dummy;
 545   LARGE_INTEGER offset;
 546   HRESULT hr;
 547
 548   TRACE(" Cloning %p (deleteOnRelease=%d seek position=%ld)\n",iface,This->deleteOnRelease,(long)This->currentPosition.QuadPart);
 549   hr = CreateStreamOnHGlobal(This->supportHandle, FALSE, ppstm);
 550   if(FAILED(hr))
 551     return hr;
 552   offset.QuadPart = (LONGLONG)This->currentPosition.QuadPart;
 553   IStream_Seek(*ppstm, offset, STREAM_SEEK_SET, &dummy);
 554   return S_OK;
 555 }
 556
 557 static const IStreamVtbl HGLOBALStreamImplVtbl =
 558 {
 559     HGLOBALStreamImpl_QueryInterface,
 560     HGLOBALStreamImpl_AddRef,
 561     HGLOBALStreamImpl_Release,
 562     HGLOBALStreamImpl_Read,
 563     HGLOBALStreamImpl_Write,
 564     HGLOBALStreamImpl_Seek,
 565     HGLOBALStreamImpl_SetSize,
 566     HGLOBALStreamImpl_CopyTo,
 567     HGLOBALStreamImpl_Commit,
 568     HGLOBALStreamImpl_Revert,
 569     HGLOBALStreamImpl_LockRegion,
 570     HGLOBALStreamImpl_UnlockRegion,
 571     HGLOBALStreamImpl_Stat,
 572     HGLOBALStreamImpl_Clone
 573 };
 574
 575 /***********************************************************************
 576  *           CreateStreamOnHGlobal     [OLE32.@]
 577  */
 578 HRESULT WINAPI CreateStreamOnHGlobal(
 579                 HGLOBAL   hGlobal,
 580                 BOOL      fDeleteOnRelease,
 581                 LPSTREAM* ppstm)
 582 {
 583   HGLOBALStreamImpl* This;
 584
 585   if (!ppstm)
 586     return E_INVALIDARG;
 587
 588   This = HeapAlloc(GetProcessHeap(), 0, sizeof(HGLOBALStreamImpl));
 589   if (!This) return E_OUTOFMEMORY;
 590
 591   This->IStream_iface.lpVtbl = &HGLOBALStreamImplVtbl;
 592   This->ref = 1;
 593
 594   /* initialize the support */
 595   This->supportHandle = hGlobal;
 596   This->deleteOnRelease = fDeleteOnRelease;
 597
 598   /* allocate a handle if one is not supplied */
 599   if (!This->supportHandle)
 600     This->supportHandle = GlobalAlloc(GMEM_MOVEABLE|GMEM_NODISCARD|GMEM_SHARE, 0);
 601
 602   /* start at the beginning */
 603   This->currentPosition.u.HighPart = 0;
 604   This->currentPosition.u.LowPart = 0;
 605
 606   /* initialize the size of the stream to the size of the handle */
 607   This->streamSize.u.HighPart = 0;
 608   This->streamSize.u.LowPart = GlobalSize(This->supportHandle);
 609
 610   *ppstm = &This->IStream_iface;
 611
 612   return S_OK;
 613 }
 614
 615 /***********************************************************************
 616  *           GetHGlobalFromStream     [OLE32.@]
 617  */
 618 HRESULT WINAPI GetHGlobalFromStream(IStream* pstm, HGLOBAL* phglobal)
 619 {
 620   HGLOBALStreamImpl* pStream;
 621
 622   if (pstm == NULL)
 623     return E_INVALIDARG;
 624
 625   pStream = (HGLOBALStreamImpl*) pstm;
 626
 627   /*
 628    * Verify that the stream object was created with CreateStreamOnHGlobal.
 629    */
 630   if (pStream->IStream_iface.lpVtbl == &HGLOBALStreamImplVtbl)
 631     *phglobal = pStream->supportHandle;
 632   else
 633   {
 634     *phglobal = 0;
 635     return E_INVALIDARG;
 636   }
 637
 638   return S_OK;
 639 }