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 = (IStream*)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   if (This->streamSize.u.LowPart == libNewSize.u.LowPart)
 579     return S_OK;
 580
 581   /*
 582    * This will happen if we're creating a stream
 583    */
 584   if ((This->smallBlockChain == 0) && (This->bigBlockChain == 0))
 585   {
 586     if (libNewSize.u.LowPart < LIMIT_TO_USE_SMALL_BLOCK)
 587     {
 588       This->smallBlockChain = SmallBlockChainStream_Construct(
 589                                     This->parentStorage->ancestorStorage,
 590                                     This->ownerProperty);
 591     }
 592     else
 593     {
 594       This->bigBlockChain = BlockChainStream_Construct(
 595                                 This->parentStorage->ancestorStorage,
 596                                 NULL,
 597                                 This->ownerProperty);
 598     }
 599   }
 600
 601   /*
 602    * Read this stream's property to see if it's small blocks or big blocks
 603    */
 604   Success = StorageImpl_ReadProperty(This->parentStorage->ancestorStorage,
 605                                        This->ownerProperty,
 606                                        &curProperty);
 607   /*
 608    * Determine if we have to switch from small to big blocks or vice versa
 609    */
 610   if ( (This->smallBlockChain!=0) &&
 611        (curProperty.size.u.LowPart < LIMIT_TO_USE_SMALL_BLOCK) )
 612   {
 613     if (libNewSize.u.LowPart >= LIMIT_TO_USE_SMALL_BLOCK)
 614     {
 615       /*
 616        * Transform the small block chain into a big block chain
 617        */
 618       This->bigBlockChain = Storage32Impl_SmallBlocksToBigBlocks(
 619                                 This->parentStorage->ancestorStorage,
 620                                 &This->smallBlockChain);
 621     }
 622   }
 623
 624   if (This->smallBlockChain!=0)
 625   {
 626     Success = SmallBlockChainStream_SetSize(This->smallBlockChain, libNewSize);
 627   }
 628   else
 629   {
 630     Success = BlockChainStream_SetSize(This->bigBlockChain, libNewSize);
 631   }
 632
 633   /*
 634    * Write the new information about this stream to the property
 635    */
 636   Success = StorageImpl_ReadProperty(This->parentStorage->ancestorStorage,
 637                                        This->ownerProperty,
 638                                        &curProperty);
 639
 640   curProperty.size.u.HighPart = libNewSize.u.HighPart;
 641   curProperty.size.u.LowPart = libNewSize.u.LowPart;
 642
 643   if (Success)
 644   {
 645     StorageImpl_WriteProperty(This->parentStorage->ancestorStorage,
 646                                 This->ownerProperty,
 647                                 &curProperty);
 648   }
 649
 650   This->streamSize = libNewSize;
 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 static HRESULT WINAPI StgStreamImpl_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   StgStreamImpl* const This=(StgStreamImpl*)iface;
 670   HRESULT        hr = S_OK;
 671   BYTE           tmpBuffer[128];
 672   ULONG          bytesRead, bytesWritten, copySize;
 673   ULARGE_INTEGER totalBytesRead;
 674   ULARGE_INTEGER totalBytesWritten;
 675
 676   TRACE("(%p, %p, %d, %p, %p)\n",
 677         iface, pstm, cb.u.LowPart, pcbRead, pcbWritten);
 678
 679   /*
 680    * Sanity check
 681    */
 682
 683   if (!This->parentStorage)
 684   {
 685     WARN("storage reverted\n");
 686     return STG_E_REVERTED;
 687   }
 688
 689   if ( pstm == 0 )
 690     return STG_E_INVALIDPOINTER;
 691
 692   totalBytesRead.u.LowPart = totalBytesRead.u.HighPart = 0;
 693   totalBytesWritten.u.LowPart = totalBytesWritten.u.HighPart = 0;
 694
 695   /*
 696    * use stack to store data temporarily
 697    * there is surely a more performant way of doing it, for now this basic
 698    * implementation will do the job
 699    */
 700   while ( cb.u.LowPart > 0 )
 701   {
 702     if ( cb.u.LowPart >= 128 )
 703       copySize = 128;
 704     else
 705       copySize = cb.u.LowPart;
 706
 707     IStream_Read(iface, tmpBuffer, copySize, &bytesRead);
 708
 709     totalBytesRead.u.LowPart += bytesRead;
 710
 711     IStream_Write(pstm, tmpBuffer, bytesRead, &bytesWritten);
 712
 713     totalBytesWritten.u.LowPart += bytesWritten;
 714
 715     /*
 716      * Check that read & write operations were successful
 717      */
 718     if (bytesRead != bytesWritten)
 719     {
 720       hr = STG_E_MEDIUMFULL;
 721       WARN("medium full\n");
 722       break;
 723     }
 724
 725     if (bytesRead!=copySize)
 726       cb.u.LowPart = 0;
 727     else
 728       cb.u.LowPart -= bytesRead;
 729   }
 730
 731   /*
 732    * Update number of bytes read and written
 733    */
 734   if (pcbRead)
 735   {
 736     pcbRead->u.LowPart = totalBytesRead.u.LowPart;
 737     pcbRead->u.HighPart = totalBytesRead.u.HighPart;
 738   }
 739
 740   if (pcbWritten)
 741   {
 742     pcbWritten->u.LowPart = totalBytesWritten.u.LowPart;
 743     pcbWritten->u.HighPart = totalBytesWritten.u.HighPart;
 744   }
 745   return hr;
 746 }
 747
 748 /***
 749  * This method is part of the IStream interface.
 750  *
 751  * For streams contained in structured storages, this method
 752  * does nothing. This is what the documentation tells us.
 753  *
 754  * See the documentation of IStream for more info.
 755  */
 756 static HRESULT WINAPI StgStreamImpl_Commit(
 757                   IStream*      iface,
 758                   DWORD           grfCommitFlags)  /* [in] */
 759 {
 760   StgStreamImpl* const This=(StgStreamImpl*)iface;
 761
 762   if (!This->parentStorage)
 763   {
 764     WARN("storage reverted\n");
 765     return STG_E_REVERTED;
 766   }
 767
 768   return S_OK;
 769 }
 770
 771 /***
 772  * This method is part of the IStream interface.
 773  *
 774  * For streams contained in structured storages, this method
 775  * does nothing. This is what the documentation tells us.
 776  *
 777  * See the documentation of IStream for more info.
 778  */
 779 static HRESULT WINAPI StgStreamImpl_Revert(
 780                   IStream* iface)
 781 {
 782   return S_OK;
 783 }
 784
 785 static HRESULT WINAPI StgStreamImpl_LockRegion(
 786                                         IStream*     iface,
 787                                         ULARGE_INTEGER libOffset,   /* [in] */
 788                                         ULARGE_INTEGER cb,          /* [in] */
 789                                         DWORD          dwLockType)  /* [in] */
 790 {
 791   StgStreamImpl* const This=(StgStreamImpl*)iface;
 792
 793   if (!This->parentStorage)
 794   {
 795     WARN("storage reverted\n");
 796     return STG_E_REVERTED;
 797   }
 798
 799   FIXME("not implemented!\n");
 800   return E_NOTIMPL;
 801 }
 802
 803 static HRESULT WINAPI StgStreamImpl_UnlockRegion(
 804                                           IStream*     iface,
 805                                           ULARGE_INTEGER libOffset,   /* [in] */
 806                                           ULARGE_INTEGER cb,          /* [in] */
 807                                           DWORD          dwLockType)  /* [in] */
 808 {
 809   StgStreamImpl* const This=(StgStreamImpl*)iface;
 810
 811   if (!This->parentStorage)
 812   {
 813     WARN("storage reverted\n");
 814     return STG_E_REVERTED;
 815   }
 816
 817   FIXME("not implemented!\n");
 818   return E_NOTIMPL;
 819 }
 820
 821 /***
 822  * This method is part of the IStream interface.
 823  *
 824  * This method returns information about the current
 825  * stream.
 826  *
 827  * See the documentation of IStream for more info.
 828  */
 829 static HRESULT WINAPI StgStreamImpl_Stat(
 830                   IStream*     iface,
 831                   STATSTG*       pstatstg,     /* [out] */
 832                   DWORD          grfStatFlag)  /* [in] */
 833 {
 834   StgStreamImpl* const This=(StgStreamImpl*)iface;
 835
 836   StgProperty    curProperty;
 837   BOOL         readSuccessful;
 838
 839   TRACE("%p %p %d\n", This, pstatstg, grfStatFlag);
 840
 841   /*
 842    * if stream has no parent, return STG_E_REVERTED
 843    */
 844
 845   if (!This->parentStorage)
 846   {
 847     WARN("storage reverted\n");
 848     return STG_E_REVERTED;
 849   }
 850
 851   /*
 852    * Read the information from the property.
 853    */
 854   readSuccessful = StorageImpl_ReadProperty(This->parentStorage->ancestorStorage,
 855                                              This->ownerProperty,
 856                                              &curProperty);
 857
 858   if (readSuccessful)
 859   {
 860     StorageUtl_CopyPropertyToSTATSTG(pstatstg,
 861                                      &curProperty,
 862                                      grfStatFlag);
 863
 864     pstatstg->grfMode = This->grfMode;
 865
 866     return S_OK;
 867   }
 868
 869   WARN("failed to read properties\n");
 870   return E_FAIL;
 871 }
 872
 873 /***
 874  * This method is part of the IStream interface.
 875  *
 876  * This method returns a clone of the interface that allows for
 877  * another seek pointer
 878  *
 879  * See the documentation of IStream for more info.
 880  *
 881  * I am not totally sure what I am doing here but I presume that this
 882  * should be basically as simple as creating a new stream with the same
 883  * parent etc and positioning its seek cursor.
 884  */
 885 static HRESULT WINAPI StgStreamImpl_Clone(
 886                                    IStream*     iface,
 887                                    IStream**    ppstm) /* [out] */
 888 {
 889   StgStreamImpl* const This=(StgStreamImpl*)iface;
 890   HRESULT hres;
 891   StgStreamImpl* new_stream;
 892   LARGE_INTEGER seek_pos;
 893
 894   TRACE("%p %p\n", This, ppstm);
 895
 896   /*
 897    * Sanity check
 898    */
 899
 900   if (!This->parentStorage)
 901     return STG_E_REVERTED;
 902
 903   if ( ppstm == 0 )
 904     return STG_E_INVALIDPOINTER;
 905
 906   new_stream = StgStreamImpl_Construct (This->parentStorage, This->grfMode, This->ownerProperty);
 907
 908   if (!new_stream)
 909     return STG_E_INSUFFICIENTMEMORY; /* Currently the only reason for new_stream=0 */
 910
 911   *ppstm = (IStream*) new_stream;
 912   IStream_AddRef(*ppstm);
 913
 914   seek_pos.QuadPart = This->currentPosition.QuadPart;
 915
 916   hres=StgStreamImpl_Seek (*ppstm, seek_pos, STREAM_SEEK_SET, NULL);
 917
 918   assert (SUCCEEDED(hres));
 919
 920   return S_OK;
 921 }
 922
 923 /*
 924  * Virtual function table for the StgStreamImpl class.
 925  */
 926 static const IStreamVtbl StgStreamImpl_Vtbl =
 927 {
 928     StgStreamImpl_QueryInterface,
 929     StgStreamImpl_AddRef,
 930     StgStreamImpl_Release,
 931     StgStreamImpl_Read,
 932     StgStreamImpl_Write,
 933     StgStreamImpl_Seek,
 934     StgStreamImpl_SetSize,
 935     StgStreamImpl_CopyTo,
 936     StgStreamImpl_Commit,
 937     StgStreamImpl_Revert,
 938     StgStreamImpl_LockRegion,
 939     StgStreamImpl_UnlockRegion,
 940     StgStreamImpl_Stat,
 941     StgStreamImpl_Clone
 942 };
 943
 944 /******************************************************************************
 945 ** StgStreamImpl implementation
 946 */
 947
 948 /***
 949  * This is the constructor for the StgStreamImpl class.
 950  *
 951  * Params:
 952  *    parentStorage - Pointer to the storage that contains the stream to open
 953  *    ownerProperty - Index of the property that points to this stream.
 954  */
 955 StgStreamImpl* StgStreamImpl_Construct(
 956                 StorageBaseImpl* parentStorage,
 957     DWORD            grfMode,
 958     ULONG            ownerProperty)
 959 {
 960   StgStreamImpl* newStream;
 961
 962   newStream = HeapAlloc(GetProcessHeap(), 0, sizeof(StgStreamImpl));
 963
 964   if (newStream!=0)
 965   {
 966     /*
 967      * Set-up the virtual function table and reference count.
 968      */
 969     newStream->lpVtbl    = &StgStreamImpl_Vtbl;
 970     newStream->ref       = 0;
 971
 972     newStream->parentStorage = parentStorage;
 973
 974     /*
 975      * We want to nail-down the reference to the storage in case the
 976      * stream out-lives the storage in the client application.
 977      *
 978      * -- IStorage_AddRef((IStorage*)newStream->parentStorage);
 979      *
 980      * No, don't do this. Some apps call IStorage_Release without
 981      * calling IStream_Release first. If we grab a reference the
 982      * file is not closed, and the app fails when it tries to
 983      * reopen the file (Easy-PC, for example)
 984      */
 985
 986     newStream->grfMode = grfMode;
 987     newStream->ownerProperty = ownerProperty;
 988
 989     /*
 990      * Start the stream at the beginning.
 991      */
 992     newStream->currentPosition.u.HighPart = 0;
 993     newStream->currentPosition.u.LowPart = 0;
 994
 995     /*
 996      * Initialize the rest of the data.
 997      */
 998     newStream->streamSize.u.HighPart = 0;
 999     newStream->streamSize.u.LowPart  = 0;
1000     newStream->bigBlockChain       = 0;
1001     newStream->smallBlockChain     = 0;
1002
1003     /*
1004      * Read the size from the property and determine if the blocks forming
1005      * this stream are large or small.
1006      */
1007     StgStreamImpl_OpenBlockChain(newStream);
1008
1009     /* add us to the storage's list of active streams */
1010     StorageBaseImpl_AddStream(parentStorage, newStream);
1011   }
1012
1013   return newStream;
1014 }