git.oblomov.eu Git - wine/blob - dlls/ole32/stg_stream.c

   1 /*
   2  * Compound Storage (32 bit version)
   3  * Stream implementation
   4  *
   5  * This file contains the implementation of the stream interface
   6  * for streams contained in a compound storage.
   7  *
   8  * Copyright 1999 Francis Beaudet
   9  * Copyright 1999 Thuy Nguyen
  10  *
  11  * This library is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2.1 of the License, or (at your option) any later version.
  15  *
  16  * This library is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public
  22  * License along with this library; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  24  */
  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 "winerror.h"
  39 #include "winternl.h"
  40 #include "wine/debug.h"
  41
  42 #include "storage32.h"
  43
  44 WINE_DEFAULT_DEBUG_CHANNEL(storage);
  45
  46
  47 /***
  48  * This is the destructor of the StgStreamImpl class.
  49  *
  50  * This method will clean-up all the resources used-up by the given StgStreamImpl
  51  * class. The pointer passed-in to this function will be freed and will not
  52  * be valid anymore.
  53  */
  54 static void StgStreamImpl_Destroy(StgStreamImpl* This)
  55 {
  56   TRACE("(%p)\n", This);
  57
  58   /*
  59    * Release the reference we are holding on the parent storage.
  60    * IStorage_Release((IStorage*)This->parentStorage);
  61    *
  62    * No, don't do this. Some apps call IStorage_Release without
  63    * calling IStream_Release first. If we grab a reference the
  64    * file is not closed, and the app fails when it tries to
  65    * reopen the file (Easy-PC, for example). Just inform the
  66    * storage that we have closed the stream
  67    */
  68
  69   if(This->parentStorage) {
  70
  71     StorageBaseImpl_RemoveStream(This->parentStorage, This);
  72
  73   }
  74
  75   This->parentStorage = 0;
  76
  77   /*
  78    * Make sure we clean-up the block chain stream objects that we were using.
  79    */
  80   if (This->bigBlockChain != 0)
  81   {
  82     BlockChainStream_Destroy(This->bigBlockChain);
  83     This->bigBlockChain = 0;
  84   }
  85
  86   if (This->smallBlockChain != 0)
  87   {
  88     SmallBlockChainStream_Destroy(This->smallBlockChain);
  89     This->smallBlockChain = 0;
  90   }
  91
  92   /*
  93    * Finally, free the memory used-up by the class.
  94    */
  95   HeapFree(GetProcessHeap(), 0, This);
  96 }
  97
  98 /***
  99  * This implements the IUnknown method QueryInterface for this
 100  * class
 101  */
 102 static HRESULT WINAPI StgStreamImpl_QueryInterface(
 103                   IStream*     iface,
 104                   REFIID         riid,        /* [in] */
 105                   void**         ppvObject)   /* [iid_is][out] */
 106 {
 107   StgStreamImpl* const This=(StgStreamImpl*)iface;
 108
 109   /*
 110    * Perform a sanity check on the parameters.
 111    */
 112   if (ppvObject==0)
 113     return E_INVALIDARG;
 114
 115   /*
 116    * Initialize the return parameter.
 117    */
 118   *ppvObject = 0;
 119
 120   /*
 121    * Compare the riid with the interface IDs implemented by this object.
 122    */
 123   if (IsEqualIID(&IID_IUnknown, riid) ||
 124       IsEqualIID(&IID_IPersist, riid) ||
 125       IsEqualIID(&IID_IPersistStream, riid) ||
 126       IsEqualIID(&IID_ISequentialStream, riid) ||
 127       IsEqualIID(&IID_IStream, riid))
 128   {
 129     *ppvObject = This;
 130   }
 131
 132   /*
 133    * Check that we obtained an interface.
 134    */
 135   if ((*ppvObject)==0)
 136     return E_NOINTERFACE;
 137
 138   /*
 139    * Query Interface always increases the reference count by one when it is
 140    * successful
 141    */
 142   IStream_AddRef(iface);
 143
 144   return S_OK;
 145 }
 146
 147 /***
 148  * This implements the IUnknown method AddRef for this
 149  * class
 150  */
 151 static ULONG WINAPI StgStreamImpl_AddRef(
 152                 IStream* iface)
 153 {
 154   StgStreamImpl* const This=(StgStreamImpl*)iface;
 155   return InterlockedIncrement(&This->ref);
 156 }
 157
 158 /***
 159  * This implements the IUnknown method Release for this
 160  * class
 161  */
 162 static ULONG WINAPI StgStreamImpl_Release(
 163                 IStream* iface)
 164 {
 165   StgStreamImpl* const This=(StgStreamImpl*)iface;
 166
 167   ULONG ref;
 168
 169   ref = InterlockedDecrement(&This->ref);
 170
 171   /*
 172    * If the reference count goes down to 0, perform suicide.
 173    */
 174   if (ref==0)
 175   {
 176     StgStreamImpl_Destroy(This);
 177   }
 178
 179   return ref;
 180 }
 181
 182 /***
 183  * This method will open the block chain pointed by the property
 184  * that describes the stream.
 185  * If the stream's size is null, no chain is opened.
 186  */
 187 static void StgStreamImpl_OpenBlockChain(
 188         StgStreamImpl* This)
 189 {
 190   StgProperty    curProperty;
 191   BOOL         readSuccessful;
 192
 193   /*
 194    * Make sure no old object is left over.
 195    */
 196   if (This->smallBlockChain != 0)
 197   {
 198     SmallBlockChainStream_Destroy(This->smallBlockChain);
 199     This->smallBlockChain = 0;
 200   }
 201
 202   if (This->bigBlockChain != 0)
 203   {
 204     BlockChainStream_Destroy(This->bigBlockChain);
 205     This->bigBlockChain = 0;
 206   }
 207
 208   /*
 209    * Read the information from the property.
 210    */
 211   readSuccessful = StorageImpl_ReadProperty(This->parentStorage->ancestorStorage,
 212                                              This->ownerProperty,
 213                                              &curProperty);
 214
 215   if (readSuccessful)
 216   {
 217     This->streamSize = curProperty.size;
 218
 219     /*
 220      * This code supports only streams that are <32 bits in size.
 221      */
 222     assert(This->streamSize.u.HighPart == 0);
 223
 224     if(curProperty.startingBlock == BLOCK_END_OF_CHAIN)
 225     {
 226       assert( (This->streamSize.u.HighPart == 0) && (This->streamSize.u.LowPart == 0) );
 227     }
 228     else
 229     {
 230       if ( (This->streamSize.u.HighPart == 0) &&
 231            (This->streamSize.u.LowPart < LIMIT_TO_USE_SMALL_BLOCK) )
 232       {
 233         This->smallBlockChain = SmallBlockChainStream_Construct(
 234                                                                 This->parentStorage->ancestorStorage,
 235                                                                 This->ownerProperty);
 236       }
 237       else
 238       {
 239         This->bigBlockChain = BlockChainStream_Construct(
 240                                                          This->parentStorage->ancestorStorage,
 241                                                          NULL,
 242                                                          This->ownerProperty);
 243       }
 244     }
 245   }
 246 }
 247
 248 /***
 249  * This method is part of the ISequentialStream interface.
 250  *
 251  * It reads a block of information from the stream at the current
 252  * position. It then moves the current position at the end of the
 253  * read block
 254  *
 255  * See the documentation of ISequentialStream for more info.
 256  */
 257 static HRESULT WINAPI StgStreamImpl_Read(
 258                   IStream*     iface,
 259                   void*          pv,        /* [length_is][size_is][out] */
 260                   ULONG          cb,        /* [in] */
 261                   ULONG*         pcbRead)   /* [out] */
 262 {
 263   StgStreamImpl* const This=(StgStreamImpl*)iface;
 264
 265   ULONG bytesReadBuffer;
 266   ULONG bytesToReadFromBuffer;
 267   HRESULT res;
 268
 269   TRACE("(%p, %p, %d, %p)\n",
 270         iface, pv, cb, pcbRead);
 271
 272   if (!This->parentStorage)
 273   {
 274     WARN("storage reverted\n");
 275     return STG_E_REVERTED;
 276   }
 277
 278   /*
 279    * If the caller is not interested in the number of bytes read,
 280    * we use another buffer to avoid "if" statements in the code.
 281    */
 282   if (pcbRead==0)
 283     pcbRead = &bytesReadBuffer;
 284
 285   /*
 286    * Using the known size of the stream, calculate the number of bytes
 287    * to read from the block chain
 288    */
 289   bytesToReadFromBuffer = min( This->streamSize.u.LowPart - This->currentPosition.u.LowPart, cb);
 290
 291   /*
 292    * Depending on the type of chain that was opened when the stream was constructed,
 293    * we delegate the work to the method that reads the block chains.
 294    */
 295   if (This->smallBlockChain!=0)
 296   {
 297     res = SmallBlockChainStream_ReadAt(This->smallBlockChain,
 298                                  This->currentPosition,
 299                                  bytesToReadFromBuffer,
 300                                  pv,
 301                                  pcbRead);
 302
 303   }
 304   else if (This->bigBlockChain!=0)
 305   {
 306     res = BlockChainStream_ReadAt(This->bigBlockChain,
 307                  This->currentPosition,
 308                  bytesToReadFromBuffer,
 309                  pv,
 310                  pcbRead);
 311   }
 312   else
 313   {
 314     /*
 315      * Small and big block chains are both NULL. This case will happen
 316      * when a stream starts with BLOCK_END_OF_CHAIN and has size zero.
 317      */
 318
 319     *pcbRead = 0;
 320     res = S_OK;
 321     goto end;
 322   }
 323
 324   if (SUCCEEDED(res))
 325   {
 326       /*
 327        * We should always be able to read the proper amount of data from the
 328        * chain.
 329        */
 330       assert(bytesToReadFromBuffer == *pcbRead);
 331
 332       /*
 333        * Advance the pointer for the number of positions read.
 334        */
 335       This->currentPosition.u.LowPart += *pcbRead;
 336   }
 337
 338 end:
 339   TRACE("<-- %08x\n", res);
 340   return res;
 341 }
 342
 343 /***
 344  * This method is part of the ISequentialStream interface.
 345  *
 346  * It writes a block of information to the stream at the current
 347  * position. It then moves the current position at the end of the
 348  * written block. If the stream is too small to fit the block,
 349  * the stream is grown to fit.
 350  *
 351  * See the documentation of ISequentialStream for more info.
 352  */
 353 static HRESULT WINAPI StgStreamImpl_Write(
 354                   IStream*     iface,
 355                   const void*    pv,          /* [size_is][in] */
 356                   ULONG          cb,          /* [in] */
 357                   ULONG*         pcbWritten)  /* [out] */
 358 {
 359   StgStreamImpl* const This=(StgStreamImpl*)iface;
 360
 361   ULARGE_INTEGER newSize;
 362   ULONG bytesWritten = 0;
 363   HRESULT res;
 364
 365   TRACE("(%p, %p, %d, %p)\n",
 366         iface, pv, cb, pcbWritten);
 367
 368   /*
 369    * Do we have permission to write to this stream?
 370    */
 371   switch(STGM_ACCESS_MODE(This->grfMode))
 372   {
 373   case STGM_WRITE:
 374   case STGM_READWRITE:
 375       break;
 376   default:
 377       WARN("access denied by flags: 0x%x\n", STGM_ACCESS_MODE(This->grfMode));
 378       return STG_E_ACCESSDENIED;
 379   }
 380
 381   if (!pv)
 382     return STG_E_INVALIDPOINTER;
 383
 384   if (!This->parentStorage)
 385   {
 386     WARN("storage reverted\n");
 387     return STG_E_REVERTED;
 388   }
 389
 390   /*
 391    * If the caller is not interested in the number of bytes written,
 392    * we use another buffer to avoid "if" statements in the code.
 393    */
 394   if (pcbWritten == 0)
 395     pcbWritten = &bytesWritten;
 396
 397   /*
 398    * Initialize the out parameter
 399    */
 400   *pcbWritten = 0;
 401
 402   if (cb == 0)
 403   {
 404     TRACE("<-- S_OK, written 0\n");
 405     return S_OK;
 406   }
 407   else
 408   {
 409     newSize.u.HighPart = 0;
 410     newSize.u.LowPart = This->currentPosition.u.LowPart + cb;
 411   }
 412
 413   /*
 414    * Verify if we need to grow the stream
 415    */
 416   if (newSize.u.LowPart > This->streamSize.u.LowPart)
 417   {
 418     /* grow stream */
 419     res = IStream_SetSize(iface, newSize);
 420     if (FAILED(res))
 421       return res;
 422   }
 423
 424   /*
 425    * Depending on the type of chain that was opened when the stream was constructed,
 426    * we delegate the work to the method that readwrites to the block chains.
 427    */
 428   if (This->smallBlockChain!=0)
 429   {
 430     res = SmallBlockChainStream_WriteAt(This->smallBlockChain,
 431                                   This->currentPosition,
 432                                   cb,
 433                                   pv,
 434                                   pcbWritten);
 435
 436   }
 437   else if (This->bigBlockChain!=0)
 438   {
 439     res = BlockChainStream_WriteAt(This->bigBlockChain,
 440                              This->currentPosition,
 441                              cb,
 442                              pv,
 443                              pcbWritten);
 444   }
 445   else
 446   {
 447     /* this should never happen because the IStream_SetSize call above will
 448      * make sure a big or small block chain is created */
 449     assert(FALSE);
 450     res = 0;
 451   }
 452
 453   /*
 454    * Advance the position pointer for the number of positions written.
 455    */
 456   This->currentPosition.u.LowPart += *pcbWritten;
 457
 458   TRACE("<-- S_OK, written %u\n", *pcbWritten);
 459   return res;
 460 }
 461
 462 /***
 463  * This method is part of the IStream interface.
 464  *
 465  * It will move the current stream pointer according to the parameters
 466  * given.
 467  *
 468  * See the documentation of IStream for more info.
 469  */
 470 static HRESULT WINAPI StgStreamImpl_Seek(
 471                   IStream*      iface,
 472                   LARGE_INTEGER   dlibMove,         /* [in] */
 473                   DWORD           dwOrigin,         /* [in] */
 474                   ULARGE_INTEGER* plibNewPosition) /* [out] */
 475 {
 476   StgStreamImpl* const This=(StgStreamImpl*)iface;
 477
 478   ULARGE_INTEGER newPosition;
 479
 480   TRACE("(%p, %d, %d, %p)\n",
 481         iface, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
 482
 483   /*
 484    * fail if the stream has no parent (as does windows)
 485    */
 486
 487   if (!This->parentStorage)
 488   {
 489     WARN("storage reverted\n");
 490     return STG_E_REVERTED;
 491   }
 492
 493   /*
 494    * The caller is allowed to pass in NULL as the new position return value.
 495    * If it happens, we assign it to a dynamic variable to avoid special cases
 496    * in the code below.
 497    */
 498   if (plibNewPosition == 0)
 499   {
 500     plibNewPosition = &newPosition;
 501   }
 502
 503   /*
 504    * The file pointer is moved depending on the given "function"
 505    * parameter.
 506    */
 507   switch (dwOrigin)
 508   {
 509     case STREAM_SEEK_SET:
 510       plibNewPosition->u.HighPart = 0;
 511       plibNewPosition->u.LowPart  = 0;
 512       break;
 513     case STREAM_SEEK_CUR:
 514       *plibNewPosition = This->currentPosition;
 515       break;
 516     case STREAM_SEEK_END:
 517       *plibNewPosition = This->streamSize;
 518       break;
 519     default:
 520       WARN("invalid dwOrigin %d\n", dwOrigin);
 521       return STG_E_INVALIDFUNCTION;
 522   }
 523
 524   plibNewPosition->QuadPart = RtlLargeIntegerAdd( plibNewPosition->QuadPart, dlibMove.QuadPart );
 525
 526   /*
 527    * tell the caller what we calculated
 528    */
 529   This->currentPosition = *plibNewPosition;
 530
 531   return S_OK;
 532 }
 533
 534 /***
 535  * This method is part of the IStream interface.
 536  *
 537  * It will change the size of a stream.
 538  *
 539  * TODO: Switch from small blocks to big blocks and vice versa.
 540  *
 541  * See the documentation of IStream for more info.
 542  */
 543 static HRESULT WINAPI StgStreamImpl_SetSize(
 544                                      IStream*      iface,
 545                                      ULARGE_INTEGER  libNewSize)   /* [in] */
 546 {
 547   StgStreamImpl* const This=(StgStreamImpl*)iface;
 548
 549   StgProperty    curProperty;
 550   BOOL         Success;
 551
 552   TRACE("(%p, %d)\n", iface, libNewSize.u.LowPart);
 553
 554   if(!This->parentStorage)
 555   {
 556     WARN("storage reverted\n");
 557     return STG_E_REVERTED;
 558   }
 559
 560   /*
 561    * As documented.
 562    */
 563   if (libNewSize.u.HighPart != 0)
 564   {
 565     WARN("invalid value for libNewSize.u.HighPart %d\n", libNewSize.u.HighPart);
 566     return STG_E_INVALIDFUNCTION;
 567   }
 568
 569   /*
 570    * Do we have permission?
 571    */
 572   if (!(This->grfMode & (STGM_WRITE | STGM_READWRITE)))
 573   {
 574     WARN("access denied\n");
 575     return STG_E_ACCESSDENIED;
 576   }
 577
 578   /* In simple mode keep the stream size above the small block limit */
 579   if (This->parentStorage->ancestorStorage->base.openFlags & STGM_SIMPLE)
 580     libNewSize.u.LowPart = max(libNewSize.u.LowPart, LIMIT_TO_USE_SMALL_BLOCK);
 581
 582   if (This->streamSize.u.LowPart == libNewSize.u.LowPart)
 583     return S_OK;
 584
 585   /*
 586    * This will happen if we're creating a stream
 587    */
 588   if ((This->smallBlockChain == 0) && (This->bigBlockChain == 0))
 589   {
 590     if (libNewSize.u.LowPart < LIMIT_TO_USE_SMALL_BLOCK)
 591     {
 592       This->smallBlockChain = SmallBlockChainStream_Construct(
 593                                     This->parentStorage->ancestorStorage,
 594                                     This->ownerProperty);
 595     }
 596     else
 597     {
 598       This->bigBlockChain = BlockChainStream_Construct(
 599                                 This->parentStorage->ancestorStorage,
 600                                 NULL,
 601                                 This->ownerProperty);
 602     }
 603   }
 604
 605   /*
 606    * Read this stream's property to see if it's small blocks or big blocks
 607    */
 608   Success = StorageImpl_ReadProperty(This->parentStorage->ancestorStorage,
 609                                        This->ownerProperty,
 610                                        &curProperty);
 611   /*
 612    * Determine if we have to switch from small to big blocks or vice versa
 613    */
 614   if ( (This->smallBlockChain!=0) &&
 615        (curProperty.size.u.LowPart < LIMIT_TO_USE_SMALL_BLOCK) )
 616   {
 617     if (libNewSize.u.LowPart >= LIMIT_TO_USE_SMALL_BLOCK)
 618     {
 619       /*
 620        * Transform the small block chain into a big block chain
 621        */
 622       This->bigBlockChain = Storage32Impl_SmallBlocksToBigBlocks(
 623                                 This->parentStorage->ancestorStorage,
 624                                 &This->smallBlockChain);
 625     }
 626   }
 627
 628   if (This->smallBlockChain!=0)
 629   {
 630     Success = SmallBlockChainStream_SetSize(This->smallBlockChain, libNewSize);
 631   }
 632   else
 633   {
 634     Success = BlockChainStream_SetSize(This->bigBlockChain, libNewSize);
 635   }
 636
 637   /*
 638    * Write the new information about this stream to the property
 639    */
 640   Success = StorageImpl_ReadProperty(This->parentStorage->ancestorStorage,
 641                                        This->ownerProperty,
 642                                        &curProperty);
 643
 644   curProperty.size.u.HighPart = libNewSize.u.HighPart;
 645   curProperty.size.u.LowPart = libNewSize.u.LowPart;
 646
 647   if (Success)
 648   {
 649     StorageImpl_WriteProperty(This->parentStorage->ancestorStorage,
 650                                 This->ownerProperty,
 651                                 &curProperty);
 652   }
 653
 654   This->streamSize = libNewSize;
 655
 656   return S_OK;
 657 }
 658
 659 /***
 660  * This method is part of the IStream interface.
 661  *
 662  * It will copy the 'cb' Bytes to 'pstm' IStream.
 663  *
 664  * See the documentation of IStream for more info.
 665  */
 666 static HRESULT WINAPI StgStreamImpl_CopyTo(
 667                                     IStream*      iface,
 668                                     IStream*      pstm,         /* [unique][in] */
 669                                     ULARGE_INTEGER  cb,           /* [in] */
 670                                     ULARGE_INTEGER* pcbRead,      /* [out] */
 671                                     ULARGE_INTEGER* pcbWritten)   /* [out] */
 672 {
 673   StgStreamImpl* const This=(StgStreamImpl*)iface;
 674   HRESULT        hr = S_OK;
 675   BYTE           tmpBuffer[128];
 676   ULONG          bytesRead, bytesWritten, copySize;
 677   ULARGE_INTEGER totalBytesRead;
 678   ULARGE_INTEGER totalBytesWritten;
 679
 680   TRACE("(%p, %p, %d, %p, %p)\n",
 681         iface, pstm, cb.u.LowPart, pcbRead, pcbWritten);
 682
 683   /*
 684    * Sanity check
 685    */
 686
 687   if (!This->parentStorage)
 688   {
 689     WARN("storage reverted\n");
 690     return STG_E_REVERTED;
 691   }
 692
 693   if ( pstm == 0 )
 694     return STG_E_INVALIDPOINTER;
 695
 696   totalBytesRead.QuadPart = 0;
 697   totalBytesWritten.QuadPart = 0;
 698
 699   while ( cb.QuadPart > 0 )
 700   {
 701     if ( cb.QuadPart >= sizeof(tmpBuffer) )
 702       copySize = sizeof(tmpBuffer);
 703     else
 704       copySize = cb.u.LowPart;
 705
 706     IStream_Read(iface, tmpBuffer, copySize, &bytesRead);
 707
 708     totalBytesRead.QuadPart += bytesRead;
 709
 710     IStream_Write(pstm, tmpBuffer, bytesRead, &bytesWritten);
 711
 712     totalBytesWritten.QuadPart += bytesWritten;
 713
 714     /*
 715      * Check that read & write operations were successful
 716      */
 717     if (bytesRead != bytesWritten)
 718     {
 719       hr = STG_E_MEDIUMFULL;
 720       WARN("medium full\n");
 721       break;
 722     }
 723
 724     if (bytesRead!=copySize)
 725       cb.QuadPart = 0;
 726     else
 727       cb.QuadPart -= bytesRead;
 728   }
 729
 730   if (pcbRead) pcbRead->QuadPart = totalBytesRead.QuadPart;
 731   if (pcbWritten) pcbWritten->QuadPart = totalBytesWritten.QuadPart;
 732
 733   return hr;
 734 }
 735
 736 /***
 737  * This method is part of the IStream interface.
 738  *
 739  * For streams contained in structured storages, this method
 740  * does nothing. This is what the documentation tells us.
 741  *
 742  * See the documentation of IStream for more info.
 743  */
 744 static HRESULT WINAPI StgStreamImpl_Commit(
 745                   IStream*      iface,
 746                   DWORD           grfCommitFlags)  /* [in] */
 747 {
 748   StgStreamImpl* const This=(StgStreamImpl*)iface;
 749
 750   if (!This->parentStorage)
 751   {
 752     WARN("storage reverted\n");
 753     return STG_E_REVERTED;
 754   }
 755
 756   return S_OK;
 757 }
 758
 759 /***
 760  * This method is part of the IStream interface.
 761  *
 762  * For streams contained in structured storages, this method
 763  * does nothing. This is what the documentation tells us.
 764  *
 765  * See the documentation of IStream for more info.
 766  */
 767 static HRESULT WINAPI StgStreamImpl_Revert(
 768                   IStream* iface)
 769 {
 770   return S_OK;
 771 }
 772
 773 static HRESULT WINAPI StgStreamImpl_LockRegion(
 774                                         IStream*     iface,
 775                                         ULARGE_INTEGER libOffset,   /* [in] */
 776                                         ULARGE_INTEGER cb,          /* [in] */
 777                                         DWORD          dwLockType)  /* [in] */
 778 {
 779   StgStreamImpl* const This=(StgStreamImpl*)iface;
 780
 781   if (!This->parentStorage)
 782   {
 783     WARN("storage reverted\n");
 784     return STG_E_REVERTED;
 785   }
 786
 787   FIXME("not implemented!\n");
 788   return E_NOTIMPL;
 789 }
 790
 791 static HRESULT WINAPI StgStreamImpl_UnlockRegion(
 792                                           IStream*     iface,
 793                                           ULARGE_INTEGER libOffset,   /* [in] */
 794                                           ULARGE_INTEGER cb,          /* [in] */
 795                                           DWORD          dwLockType)  /* [in] */
 796 {
 797   StgStreamImpl* const This=(StgStreamImpl*)iface;
 798
 799   if (!This->parentStorage)
 800   {
 801     WARN("storage reverted\n");
 802     return STG_E_REVERTED;
 803   }
 804
 805   FIXME("not implemented!\n");
 806   return E_NOTIMPL;
 807 }
 808
 809 /***
 810  * This method is part of the IStream interface.
 811  *
 812  * This method returns information about the current
 813  * stream.
 814  *
 815  * See the documentation of IStream for more info.
 816  */
 817 static HRESULT WINAPI StgStreamImpl_Stat(
 818                   IStream*     iface,
 819                   STATSTG*       pstatstg,     /* [out] */
 820                   DWORD          grfStatFlag)  /* [in] */
 821 {
 822   StgStreamImpl* const This=(StgStreamImpl*)iface;
 823
 824   StgProperty    curProperty;
 825   BOOL         readSuccessful;
 826
 827   TRACE("%p %p %d\n", This, pstatstg, grfStatFlag);
 828
 829   /*
 830    * if stream has no parent, return STG_E_REVERTED
 831    */
 832
 833   if (!This->parentStorage)
 834   {
 835     WARN("storage reverted\n");
 836     return STG_E_REVERTED;
 837   }
 838
 839   /*
 840    * Read the information from the property.
 841    */
 842   readSuccessful = StorageImpl_ReadProperty(This->parentStorage->ancestorStorage,
 843                                              This->ownerProperty,
 844                                              &curProperty);
 845
 846   if (readSuccessful)
 847   {
 848     StorageImpl *root = This->parentStorage->ancestorStorage;
 849
 850     StorageUtl_CopyPropertyToSTATSTG(pstatstg,
 851                                      &curProperty,
 852                                      grfStatFlag);
 853
 854     pstatstg->grfMode = This->grfMode;
 855
 856     /* In simple create mode cbSize is the current pos */
 857     if((root->base.openFlags & STGM_SIMPLE) && root->create)
 858       pstatstg->cbSize = This->currentPosition;
 859
 860     return S_OK;
 861   }
 862
 863   WARN("failed to read properties\n");
 864   return E_FAIL;
 865 }
 866
 867 /***
 868  * This method is part of the IStream interface.
 869  *
 870  * This method returns a clone of the interface that allows for
 871  * another seek pointer
 872  *
 873  * See the documentation of IStream for more info.
 874  *
 875  * I am not totally sure what I am doing here but I presume that this
 876  * should be basically as simple as creating a new stream with the same
 877  * parent etc and positioning its seek cursor.
 878  */
 879 static HRESULT WINAPI StgStreamImpl_Clone(
 880                                    IStream*     iface,
 881                                    IStream**    ppstm) /* [out] */
 882 {
 883   StgStreamImpl* const This=(StgStreamImpl*)iface;
 884   HRESULT hres;
 885   StgStreamImpl* new_stream;
 886   LARGE_INTEGER seek_pos;
 887
 888   TRACE("%p %p\n", This, ppstm);
 889
 890   /*
 891    * Sanity check
 892    */
 893
 894   if (!This->parentStorage)
 895     return STG_E_REVERTED;
 896
 897   if ( ppstm == 0 )
 898     return STG_E_INVALIDPOINTER;
 899
 900   new_stream = StgStreamImpl_Construct (This->parentStorage, This->grfMode, This->ownerProperty);
 901
 902   if (!new_stream)
 903     return STG_E_INSUFFICIENTMEMORY; /* Currently the only reason for new_stream=0 */
 904
 905   *ppstm = (IStream*) new_stream;
 906   IStream_AddRef(*ppstm);
 907
 908   seek_pos.QuadPart = This->currentPosition.QuadPart;
 909
 910   hres=StgStreamImpl_Seek (*ppstm, seek_pos, STREAM_SEEK_SET, NULL);
 911
 912   assert (SUCCEEDED(hres));
 913
 914   return S_OK;
 915 }
 916
 917 /*
 918  * Virtual function table for the StgStreamImpl class.
 919  */
 920 static const IStreamVtbl StgStreamImpl_Vtbl =
 921 {
 922     StgStreamImpl_QueryInterface,
 923     StgStreamImpl_AddRef,
 924     StgStreamImpl_Release,
 925     StgStreamImpl_Read,
 926     StgStreamImpl_Write,
 927     StgStreamImpl_Seek,
 928     StgStreamImpl_SetSize,
 929     StgStreamImpl_CopyTo,
 930     StgStreamImpl_Commit,
 931     StgStreamImpl_Revert,
 932     StgStreamImpl_LockRegion,
 933     StgStreamImpl_UnlockRegion,
 934     StgStreamImpl_Stat,
 935     StgStreamImpl_Clone
 936 };
 937
 938 /******************************************************************************
 939 ** StgStreamImpl implementation
 940 */
 941
 942 /***
 943  * This is the constructor for the StgStreamImpl class.
 944  *
 945  * Params:
 946  *    parentStorage - Pointer to the storage that contains the stream to open
 947  *    ownerProperty - Index of the property that points to this stream.
 948  */
 949 StgStreamImpl* StgStreamImpl_Construct(
 950                 StorageBaseImpl* parentStorage,
 951     DWORD            grfMode,
 952     ULONG            ownerProperty)
 953 {
 954   StgStreamImpl* newStream;
 955
 956   newStream = HeapAlloc(GetProcessHeap(), 0, sizeof(StgStreamImpl));
 957
 958   if (newStream!=0)
 959   {
 960     /*
 961      * Set-up the virtual function table and reference count.
 962      */
 963     newStream->lpVtbl    = &StgStreamImpl_Vtbl;
 964     newStream->ref       = 0;
 965
 966     newStream->parentStorage = parentStorage;
 967
 968     /*
 969      * We want to nail-down the reference to the storage in case the
 970      * stream out-lives the storage in the client application.
 971      *
 972      * -- IStorage_AddRef((IStorage*)newStream->parentStorage);
 973      *
 974      * No, don't do this. Some apps call IStorage_Release without
 975      * calling IStream_Release first. If we grab a reference the
 976      * file is not closed, and the app fails when it tries to
 977      * reopen the file (Easy-PC, for example)
 978      */
 979
 980     newStream->grfMode = grfMode;
 981     newStream->ownerProperty = ownerProperty;
 982
 983     /*
 984      * Start the stream at the beginning.
 985      */
 986     newStream->currentPosition.u.HighPart = 0;
 987     newStream->currentPosition.u.LowPart = 0;
 988
 989     /*
 990      * Initialize the rest of the data.
 991      */
 992     newStream->streamSize.u.HighPart = 0;
 993     newStream->streamSize.u.LowPart  = 0;
 994     newStream->bigBlockChain       = 0;
 995     newStream->smallBlockChain     = 0;
 996
 997     /*
 998      * Read the size from the property and determine if the blocks forming
 999      * this stream are large or small.
1000      */
1001     StgStreamImpl_OpenBlockChain(newStream);
1002
1003     /* add us to the storage's list of active streams */
1004     StorageBaseImpl_AddStream(parentStorage, newStream);
1005   }
1006
1007   return newStream;
1008 }