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