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 #define NONAMELESSSTRUCT
  35
  36 #include "windef.h"
  37 #include "winbase.h"
  38 #include "winuser.h"
  39 #include "objbase.h"
  40 #include "ole2.h"
  41 #include "winerror.h"
  42 #include "winternl.h"
  43
  44 #include "wine/debug.h"
  45
  46 WINE_DEFAULT_DEBUG_CHANNEL(storage);
  47
  48 /****************************************************************************
  49  * HGLOBALStreamImpl definition.
  50  *
  51  * This class implements the IStream interface and represents a stream
  52  * supported by an HGLOBAL pointer.
  53  */
  54 struct HGLOBALStreamImpl
  55 {
  56   const IStreamVtbl *lpVtbl;   /* Needs to be the first item in the struct
  57                           * since we want to cast this in an IStream pointer */
  58
  59   /*
  60    * Reference count
  61    */
  62   LONG               ref;
  63
  64   /*
  65    * Support for the stream
  66    */
  67   HGLOBAL supportHandle;
  68
  69   /*
  70    * This flag is TRUE if the HGLOBAL is destroyed when the stream
  71    * is finally released.
  72    */
  73   BOOL    deleteOnRelease;
  74
  75   /*
  76    * Helper variable that contains the size of the stream
  77    */
  78   ULARGE_INTEGER     streamSize;
  79
  80   /*
  81    * This is the current position of the cursor in the stream
  82    */
  83   ULARGE_INTEGER     currentPosition;
  84 };
  85
  86 typedef struct HGLOBALStreamImpl HGLOBALStreamImpl;
  87
  88 /***
  89  * This is the destructor of the HGLOBALStreamImpl class.
  90  *
  91  * This method will clean-up all the resources used-up by the given HGLOBALStreamImpl
  92  * class. The pointer passed-in to this function will be freed and will not
  93  * be valid anymore.
  94  */
  95 static void HGLOBALStreamImpl_Destroy(HGLOBALStreamImpl* This)
  96 {
  97   TRACE("(%p)\n", This);
  98
  99   /*
 100    * Release the HGlobal if the constructor asked for that.
 101    */
 102   if (This->deleteOnRelease)
 103   {
 104     GlobalFree(This->supportHandle);
 105     This->supportHandle=0;
 106   }
 107
 108   /*
 109    * Finally, free the memory used-up by the class.
 110    */
 111   HeapFree(GetProcessHeap(), 0, This);
 112 }
 113
 114 /***
 115  * This implements the IUnknown method AddRef for this
 116  * class
 117  */
 118 static ULONG WINAPI HGLOBALStreamImpl_AddRef(
 119                 IStream* iface)
 120 {
 121   HGLOBALStreamImpl* const This=(HGLOBALStreamImpl*)iface;
 122   return InterlockedIncrement(&This->ref);
 123 }
 124
 125 /***
 126  * This implements the IUnknown method QueryInterface for this
 127  * class
 128  */
 129 static HRESULT WINAPI HGLOBALStreamImpl_QueryInterface(
 130                   IStream*     iface,
 131                   REFIID         riid,        /* [in] */
 132                   void**         ppvObject)   /* [iid_is][out] */
 133 {
 134   HGLOBALStreamImpl* const This=(HGLOBALStreamImpl*)iface;
 135
 136   /*
 137    * Perform a sanity check on the parameters.
 138    */
 139   if (ppvObject==0)
 140     return E_INVALIDARG;
 141
 142   /*
 143    * Initialize the return parameter.
 144    */
 145   *ppvObject = 0;
 146
 147   /*
 148    * Compare the riid with the interface IDs implemented by this object.
 149    */
 150   if (IsEqualIID(&IID_IUnknown, riid) ||
 151       IsEqualIID(&IID_ISequentialStream, riid) ||
 152       IsEqualIID(&IID_IStream, riid))
 153   {
 154     *ppvObject = (IStream*)This;
 155   }
 156
 157   /*
 158    * Check that we obtained an interface.
 159    */
 160   if ((*ppvObject)==0)
 161     return E_NOINTERFACE;
 162
 163   /*
 164    * Query Interface always increases the reference count by one when it is
 165    * successful
 166    */
 167   HGLOBALStreamImpl_AddRef(iface);
 168
 169   return S_OK;
 170 }
 171
 172 /***
 173  * This implements the IUnknown method Release for this
 174  * class
 175  */
 176 static ULONG WINAPI HGLOBALStreamImpl_Release(
 177                 IStream* iface)
 178 {
 179   HGLOBALStreamImpl* const This=(HGLOBALStreamImpl*)iface;
 180   ULONG newRef;
 181
 182   newRef = InterlockedDecrement(&This->ref);
 183
 184   /*
 185    * If the reference count goes down to 0, perform suicide.
 186    */
 187   if (newRef==0)
 188   {
 189     HGLOBALStreamImpl_Destroy(This);
 190   }
 191
 192   return newRef;
 193 }
 194
 195 /***
 196  * This method is part of the ISequentialStream interface.
 197  *
 198  * If reads a block of information from the stream at the current
 199  * position. It then moves the current position at the end of the
 200  * read block
 201  *
 202  * See the documentation of ISequentialStream for more info.
 203  */
 204 static HRESULT WINAPI HGLOBALStreamImpl_Read(
 205                   IStream*     iface,
 206                   void*          pv,        /* [length_is][size_is][out] */
 207                   ULONG          cb,        /* [in] */
 208                   ULONG*         pcbRead)   /* [out] */
 209 {
 210   HGLOBALStreamImpl* const This=(HGLOBALStreamImpl*)iface;
 211
 212   void* supportBuffer;
 213   ULONG bytesReadBuffer;
 214   ULONG bytesToReadFromBuffer;
 215
 216   TRACE("(%p, %p, %d, %p)\n", iface,
 217         pv, cb, pcbRead);
 218
 219   /*
 220    * If the caller is not interested in the nubmer of bytes read,
 221    * we use another buffer to avoid "if" statements in the code.
 222    */
 223   if (pcbRead==0)
 224     pcbRead = &bytesReadBuffer;
 225
 226   /*
 227    * Using the known size of the stream, calculate the number of bytes
 228    * to read from the block chain
 229    */
 230   bytesToReadFromBuffer = min( This->streamSize.u.LowPart - This->currentPosition.u.LowPart, cb);
 231
 232   /*
 233    * Lock the buffer in position and copy the data.
 234    */
 235   supportBuffer = GlobalLock(This->supportHandle);
 236   if (!supportBuffer)
 237   {
 238       WARN("read from invalid hglobal %p\n", This->supportHandle);
 239       *pcbRead = 0;
 240       return S_OK;
 241   }
 242
 243   memcpy(pv, (char *) supportBuffer+This->currentPosition.u.LowPart, bytesToReadFromBuffer);
 244
 245   /*
 246    * Move the current position to the new position
 247    */
 248   This->currentPosition.u.LowPart+=bytesToReadFromBuffer;
 249
 250   /*
 251    * Return the number of bytes read.
 252    */
 253   *pcbRead = bytesToReadFromBuffer;
 254
 255   /*
 256    * Cleanup
 257    */
 258   GlobalUnlock(This->supportHandle);
 259
 260   /*
 261    * Always returns S_OK even if the end of the stream is reached before the
 262    * buffer is filled
 263    */
 264
 265   return S_OK;
 266 }
 267
 268 /***
 269  * This method is part of the ISequentialStream interface.
 270  *
 271  * It writes a block of information to the stream at the current
 272  * position. It then moves the current position at the end of the
 273  * written block. If the stream is too small to fit the block,
 274  * the stream is grown to fit.
 275  *
 276  * See the documentation of ISequentialStream for more info.
 277  */
 278 static HRESULT WINAPI HGLOBALStreamImpl_Write(
 279                   IStream*     iface,
 280                   const void*    pv,          /* [size_is][in] */
 281                   ULONG          cb,          /* [in] */
 282                   ULONG*         pcbWritten)  /* [out] */
 283 {
 284   HGLOBALStreamImpl* const This=(HGLOBALStreamImpl*)iface;
 285
 286   void*          supportBuffer;
 287   ULARGE_INTEGER newSize;
 288   ULONG          bytesWritten = 0;
 289
 290   TRACE("(%p, %p, %d, %p)\n", iface, pv, cb, pcbWritten);
 291
 292   /*
 293    * If the caller is not interested in the number of bytes written,
 294    * we use another buffer to avoid "if" statements in the code.
 295    */
 296   if (pcbWritten == 0)
 297     pcbWritten = &bytesWritten;
 298
 299   if (cb == 0)
 300     goto out;
 301
 302   *pcbWritten = 0;
 303
 304   newSize.u.HighPart = 0;
 305   newSize.u.LowPart = This->currentPosition.u.LowPart + cb;
 306
 307   /*
 308    * Verify if we need to grow the stream
 309    */
 310   if (newSize.u.LowPart > This->streamSize.u.LowPart)
 311   {
 312     /* grow stream */
 313     HRESULT hr = IStream_SetSize(iface, newSize);
 314     if (FAILED(hr))
 315     {
 316       ERR("IStream_SetSize failed with error 0x%08x\n", hr);
 317       return hr;
 318     }
 319   }
 320
 321   /*
 322    * Lock the buffer in position and copy the data.
 323    */
 324   supportBuffer = GlobalLock(This->supportHandle);
 325   if (!supportBuffer)
 326   {
 327       WARN("write to invalid hglobal %p\n", This->supportHandle);
 328       return S_OK;
 329   }
 330
 331   memcpy((char *) supportBuffer+This->currentPosition.u.LowPart, pv, cb);
 332
 333   /*
 334    * Move the current position to the new position
 335    */
 336   This->currentPosition.u.LowPart+=cb;
 337
 338   /*
 339    * Cleanup
 340    */
 341   GlobalUnlock(This->supportHandle);
 342
 343 out:
 344   /*
 345    * Return the number of bytes read.
 346    */
 347   *pcbWritten = cb;
 348
 349   return S_OK;
 350 }
 351
 352 /***
 353  * This method is part of the IStream interface.
 354  *
 355  * It will move the current stream pointer according to the parameters
 356  * given.
 357  *
 358  * See the documentation of IStream for more info.
 359  */
 360 static HRESULT WINAPI HGLOBALStreamImpl_Seek(
 361                   IStream*      iface,
 362                   LARGE_INTEGER   dlibMove,         /* [in] */
 363                   DWORD           dwOrigin,         /* [in] */
 364                   ULARGE_INTEGER* plibNewPosition) /* [out] */
 365 {
 366   HGLOBALStreamImpl* const This=(HGLOBALStreamImpl*)iface;
 367
 368   ULARGE_INTEGER newPosition;
 369
 370   TRACE("(%p, %x%08x, %d, %p)\n", iface, dlibMove.u.HighPart,
 371         dlibMove.u.LowPart, dwOrigin, plibNewPosition);
 372
 373   /*
 374    * The file pointer is moved depending on the given "function"
 375    * parameter.
 376    */
 377   switch (dwOrigin)
 378   {
 379     case STREAM_SEEK_SET:
 380       newPosition.u.HighPart = 0;
 381       newPosition.u.LowPart = 0;
 382       break;
 383     case STREAM_SEEK_CUR:
 384       newPosition = This->currentPosition;
 385       break;
 386     case STREAM_SEEK_END:
 387       newPosition = This->streamSize;
 388       break;
 389     default:
 390       return STG_E_INVALIDFUNCTION;
 391   }
 392
 393   /*
 394    * Move the actual file pointer
 395    * If the file pointer ends-up after the end of the stream, the next Write operation will
 396    * make the file larger. This is how it is documented.
 397    */
 398   if (dlibMove.QuadPart < 0 && newPosition.QuadPart < -dlibMove.QuadPart) return STG_E_INVALIDFUNCTION;
 399
 400   newPosition.QuadPart = RtlLargeIntegerAdd(newPosition.QuadPart, dlibMove.QuadPart);
 401
 402   if (plibNewPosition) *plibNewPosition = newPosition;
 403   This->currentPosition = newPosition;
 404
 405   return S_OK;
 406 }
 407
 408 /***
 409  * This method is part of the IStream interface.
 410  *
 411  * It will change the size of a stream.
 412  *
 413  * TODO: Switch from small blocks to big blocks and vice versa.
 414  *
 415  * See the documentation of IStream for more info.
 416  */
 417 static HRESULT WINAPI HGLOBALStreamImpl_SetSize(
 418                                      IStream*      iface,
 419                                      ULARGE_INTEGER  libNewSize)   /* [in] */
 420 {
 421   HGLOBALStreamImpl* const This=(HGLOBALStreamImpl*)iface;
 422   HGLOBAL supportHandle;
 423
 424   TRACE("(%p, %d)\n", iface, libNewSize.u.LowPart);
 425
 426   /*
 427    * HighPart is ignored as shown in tests
 428    */
 429
 430   if (This->streamSize.u.LowPart == libNewSize.u.LowPart)
 431     return S_OK;
 432
 433   /*
 434    * Re allocate the HGlobal to fit the new size of the stream.
 435    */
 436   supportHandle = GlobalReAlloc(This->supportHandle, libNewSize.u.LowPart, 0);
 437
 438   if (supportHandle == 0)
 439     return E_OUTOFMEMORY;
 440
 441   This->supportHandle = supportHandle;
 442   This->streamSize.u.LowPart = libNewSize.u.LowPart;
 443
 444   return S_OK;
 445 }
 446
 447 /***
 448  * This method is part of the IStream interface.
 449  *
 450  * It will copy the 'cb' Bytes to 'pstm' IStream.
 451  *
 452  * See the documentation of IStream for more info.
 453  */
 454 static HRESULT WINAPI HGLOBALStreamImpl_CopyTo(
 455                                     IStream*      iface,
 456                                     IStream*      pstm,         /* [unique][in] */
 457                                     ULARGE_INTEGER  cb,           /* [in] */
 458                                     ULARGE_INTEGER* pcbRead,      /* [out] */
 459                                     ULARGE_INTEGER* pcbWritten)   /* [out] */
 460 {
 461   HRESULT        hr = S_OK;
 462   BYTE           tmpBuffer[128];
 463   ULONG          bytesRead, bytesWritten, copySize;
 464   ULARGE_INTEGER totalBytesRead;
 465   ULARGE_INTEGER totalBytesWritten;
 466
 467   TRACE("(%p, %p, %d, %p, %p)\n", iface, pstm,
 468         cb.u.LowPart, pcbRead, pcbWritten);
 469
 470   /*
 471    * Sanity check
 472    */
 473   if ( pstm == 0 )
 474     return STG_E_INVALIDPOINTER;
 475
 476   totalBytesRead.u.LowPart = totalBytesRead.u.HighPart = 0;
 477   totalBytesWritten.u.LowPart = totalBytesWritten.u.HighPart = 0;
 478
 479   /*
 480    * use stack to store data temporarly
 481    * there is surely more performant way of doing it, for now this basic
 482    * implementation will do the job
 483    */
 484   while ( cb.u.LowPart > 0 )
 485   {
 486     if ( cb.u.LowPart >= 128 )
 487       copySize = 128;
 488     else
 489       copySize = cb.u.LowPart;
 490
 491     hr = IStream_Read(iface, tmpBuffer, copySize, &bytesRead);
 492     if (FAILED(hr))
 493         break;
 494
 495     totalBytesRead.u.LowPart += bytesRead;
 496
 497     if (bytesRead)
 498     {
 499         hr = IStream_Write(pstm, tmpBuffer, bytesRead, &bytesWritten);
 500         if (FAILED(hr))
 501             break;
 502
 503         totalBytesWritten.u.LowPart += bytesWritten;
 504     }
 505
 506     if (bytesRead!=copySize)
 507       cb.u.LowPart = 0;
 508     else
 509       cb.u.LowPart -= bytesRead;
 510   }
 511
 512   /*
 513    * Update number of bytes read and written
 514    */
 515   if (pcbRead)
 516   {
 517     pcbRead->u.LowPart = totalBytesRead.u.LowPart;
 518     pcbRead->u.HighPart = totalBytesRead.u.HighPart;
 519   }
 520
 521   if (pcbWritten)
 522   {
 523     pcbWritten->u.LowPart = totalBytesWritten.u.LowPart;
 524     pcbWritten->u.HighPart = totalBytesWritten.u.HighPart;
 525   }
 526   return hr;
 527 }
 528
 529 /***
 530  * This method is part of the IStream interface.
 531  *
 532  * For streams supported by HGLOBALS, this function does nothing.
 533  * This is what the documentation tells us.
 534  *
 535  * See the documentation of IStream for more info.
 536  */
 537 static HRESULT WINAPI HGLOBALStreamImpl_Commit(
 538                   IStream*      iface,
 539                   DWORD         grfCommitFlags)  /* [in] */
 540 {
 541   return S_OK;
 542 }
 543
 544 /***
 545  * This method is part of the IStream interface.
 546  *
 547  * For streams supported by HGLOBALS, this function does nothing.
 548  * This is what the documentation tells us.
 549  *
 550  * See the documentation of IStream for more info.
 551  */
 552 static HRESULT WINAPI HGLOBALStreamImpl_Revert(
 553                   IStream* iface)
 554 {
 555   return S_OK;
 556 }
 557
 558 /***
 559  * This method is part of the IStream interface.
 560  *
 561  * For streams supported by HGLOBALS, this function does nothing.
 562  * This is what the documentation tells us.
 563  *
 564  * See the documentation of IStream for more info.
 565  */
 566 static HRESULT WINAPI HGLOBALStreamImpl_LockRegion(
 567                   IStream*       iface,
 568                   ULARGE_INTEGER libOffset,   /* [in] */
 569                   ULARGE_INTEGER cb,          /* [in] */
 570                   DWORD          dwLockType)  /* [in] */
 571 {
 572   return STG_E_INVALIDFUNCTION;
 573 }
 574
 575 /*
 576  * This method is part of the IStream interface.
 577  *
 578  * For streams supported by HGLOBALS, this function does nothing.
 579  * This is what the documentation tells us.
 580  *
 581  * See the documentation of IStream for more info.
 582  */
 583 static HRESULT WINAPI HGLOBALStreamImpl_UnlockRegion(
 584                   IStream*       iface,
 585                   ULARGE_INTEGER libOffset,   /* [in] */
 586                   ULARGE_INTEGER cb,          /* [in] */
 587                   DWORD          dwLockType)  /* [in] */
 588 {
 589   return S_OK;
 590 }
 591
 592 /***
 593  * This method is part of the IStream interface.
 594  *
 595  * This method returns information about the current
 596  * stream.
 597  *
 598  * See the documentation of IStream for more info.
 599  */
 600 static HRESULT WINAPI HGLOBALStreamImpl_Stat(
 601                   IStream*     iface,
 602                   STATSTG*     pstatstg,     /* [out] */
 603                   DWORD        grfStatFlag)  /* [in] */
 604 {
 605   HGLOBALStreamImpl* const This=(HGLOBALStreamImpl*)iface;
 606
 607   memset(pstatstg, 0, sizeof(STATSTG));
 608
 609   pstatstg->pwcsName = NULL;
 610   pstatstg->type     = STGTY_STREAM;
 611   pstatstg->cbSize   = This->streamSize;
 612
 613   return S_OK;
 614 }
 615
 616 static HRESULT WINAPI HGLOBALStreamImpl_Clone(
 617                   IStream*     iface,
 618                   IStream**    ppstm) /* [out] */
 619 {
 620   ULARGE_INTEGER dummy;
 621   LARGE_INTEGER offset;
 622   HRESULT hr;
 623   HGLOBALStreamImpl* const This=(HGLOBALStreamImpl*)iface;
 624   TRACE(" Cloning %p (deleteOnRelease=%d seek position=%ld)\n",iface,This->deleteOnRelease,(long)This->currentPosition.QuadPart);
 625   hr=CreateStreamOnHGlobal(This->supportHandle, FALSE, ppstm);
 626   if(FAILED(hr))
 627     return hr;
 628   offset.QuadPart=(LONGLONG)This->currentPosition.QuadPart;
 629   HGLOBALStreamImpl_Seek(*ppstm,offset,STREAM_SEEK_SET,&dummy);
 630   return S_OK;
 631 }
 632
 633 /*
 634  * Virtual function table for the HGLOBALStreamImpl class.
 635  */
 636 static const IStreamVtbl HGLOBALStreamImpl_Vtbl =
 637 {
 638     HGLOBALStreamImpl_QueryInterface,
 639     HGLOBALStreamImpl_AddRef,
 640     HGLOBALStreamImpl_Release,
 641     HGLOBALStreamImpl_Read,
 642     HGLOBALStreamImpl_Write,
 643     HGLOBALStreamImpl_Seek,
 644     HGLOBALStreamImpl_SetSize,
 645     HGLOBALStreamImpl_CopyTo,
 646     HGLOBALStreamImpl_Commit,
 647     HGLOBALStreamImpl_Revert,
 648     HGLOBALStreamImpl_LockRegion,
 649     HGLOBALStreamImpl_UnlockRegion,
 650     HGLOBALStreamImpl_Stat,
 651     HGLOBALStreamImpl_Clone
 652 };
 653
 654 /******************************************************************************
 655 ** HGLOBALStreamImpl implementation
 656 */
 657
 658 /***
 659  * This is the constructor for the HGLOBALStreamImpl class.
 660  *
 661  * Params:
 662  *    hGlobal          - Handle that will support the stream. can be NULL.
 663  *    fDeleteOnRelease - Flag set to TRUE if the HGLOBAL will be released
 664  *                       when the IStream object is destroyed.
 665  */
 666 static HGLOBALStreamImpl* HGLOBALStreamImpl_Construct(
 667                 HGLOBAL  hGlobal,
 668                 BOOL     fDeleteOnRelease)
 669 {
 670   HGLOBALStreamImpl* newStream;
 671
 672   newStream = HeapAlloc(GetProcessHeap(), 0, sizeof(HGLOBALStreamImpl));
 673
 674   if (newStream!=0)
 675   {
 676     /*
 677      * Set-up the virtual function table and reference count.
 678      */
 679     newStream->lpVtbl = &HGLOBALStreamImpl_Vtbl;
 680     newStream->ref    = 0;
 681
 682     /*
 683      * Initialize the support.
 684      */
 685     newStream->supportHandle = hGlobal;
 686     newStream->deleteOnRelease = fDeleteOnRelease;
 687
 688     /*
 689      * This method will allocate a handle if one is not supplied.
 690      */
 691     if (!newStream->supportHandle)
 692     {
 693       newStream->supportHandle = GlobalAlloc(GMEM_MOVEABLE | GMEM_NODISCARD |
 694                                              GMEM_SHARE, 0);
 695     }
 696
 697     /*
 698      * Start the stream at the beginning.
 699      */
 700     newStream->currentPosition.u.HighPart = 0;
 701     newStream->currentPosition.u.LowPart = 0;
 702
 703     /*
 704      * Initialize the size of the stream to the size of the handle.
 705      */
 706     newStream->streamSize.u.HighPart = 0;
 707     newStream->streamSize.u.LowPart  = GlobalSize(newStream->supportHandle);
 708   }
 709
 710   return newStream;
 711 }
 712
 713
 714 /***********************************************************************
 715  *           CreateStreamOnHGlobal     [OLE32.@]
 716  */
 717 HRESULT WINAPI CreateStreamOnHGlobal(
 718                 HGLOBAL   hGlobal,
 719                 BOOL      fDeleteOnRelease,
 720                 LPSTREAM* ppstm)
 721 {
 722   HGLOBALStreamImpl* newStream;
 723
 724   if (!ppstm)
 725     return E_INVALIDARG;
 726
 727   newStream = HGLOBALStreamImpl_Construct(hGlobal,
 728                                           fDeleteOnRelease);
 729
 730   if (newStream!=NULL)
 731   {
 732     return IUnknown_QueryInterface((IUnknown*)newStream,
 733                                    &IID_IStream,
 734                                    (void**)ppstm);
 735   }
 736
 737   return E_OUTOFMEMORY;
 738 }
 739
 740 /***********************************************************************
 741  *           GetHGlobalFromStream     [OLE32.@]
 742  */
 743 HRESULT WINAPI GetHGlobalFromStream(IStream* pstm, HGLOBAL* phglobal)
 744 {
 745   HGLOBALStreamImpl* pStream;
 746
 747   if (pstm == NULL)
 748     return E_INVALIDARG;
 749
 750   pStream = (HGLOBALStreamImpl*) pstm;
 751
 752   /*
 753    * Verify that the stream object was created with CreateStreamOnHGlobal.
 754    */
 755   if (pStream->lpVtbl == &HGLOBALStreamImpl_Vtbl)
 756     *phglobal = pStream->supportHandle;
 757   else
 758   {
 759     *phglobal = 0;
 760     return E_INVALIDARG;
 761   }
 762
 763   return S_OK;
 764 }