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