ole/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 #include <assert.h>
  12 #include <stdlib.h>
  13 #include <stdio.h>
  14 #include <string.h>
  15
  16 #include "winbase.h"
  17 #include "winerror.h"
  18 #include "debug.h"
  19 #include "wine/obj_storage.h"
  20
  21 #include "storage32.h"
  22
  23 DEFAULT_DEBUG_CHANNEL(storage)
  24
  25
  26 /*
  27  * Virtual function table for the StgStreamImpl class.
  28  */
  29 static ICOM_VTABLE(IStream) StgStreamImpl_Vtbl =
  30 {
  31     StgStreamImpl_QueryInterface,
  32     StgStreamImpl_AddRef,
  33     StgStreamImpl_Release,
  34     StgStreamImpl_Read,
  35     StgStreamImpl_Write,
  36     StgStreamImpl_Seek,
  37     StgStreamImpl_SetSize,
  38     StgStreamImpl_CopyTo,
  39     StgStreamImpl_Commit,
  40     StgStreamImpl_Revert,
  41     StgStreamImpl_LockRegion,
  42     StgStreamImpl_UnlockRegion,
  43     StgStreamImpl_Stat,
  44     StgStreamImpl_Clone
  45 };
  46
  47 /******************************************************************************
  48 ** StgStreamImpl implementation
  49 */
  50
  51 /***
  52  * This is the constructor for the StgStreamImpl class.
  53  *
  54  * Params:
  55  *    parentStorage - Pointer to the storage that contains the stream to open
  56  *    ownerProperty - Index of the property that points to this stream.
  57  */
  58 StgStreamImpl* StgStreamImpl_Construct(
  59                 StorageBaseImpl* parentStorage,
  60                 ULONG              ownerProperty)
  61 {
  62   StgStreamImpl* newStream;
  63
  64   newStream = HeapAlloc(GetProcessHeap(), 0, sizeof(StgStreamImpl));
  65
  66   if (newStream!=0)
  67   {
  68     /*
  69      * Set-up the virtual function table and reference count.
  70      */
  71     newStream->lpvtbl = &StgStreamImpl_Vtbl;
  72     newStream->ref    = 0;
  73
  74     /*
  75      * We want to nail-down the reference to the storage in case the
  76      * stream out-lives the storage in the client application.
  77      */
  78     newStream->parentStorage = parentStorage;
  79     IStorage_AddRef((IStorage*)newStream->parentStorage);
  80
  81     newStream->ownerProperty = ownerProperty;
  82
  83     /*
  84      * Start the stream at the begining.
  85      */
  86     newStream->currentPosition.HighPart = 0;
  87     newStream->currentPosition.LowPart = 0;
  88
  89     /*
  90      * Initialize the rest of the data.
  91      */
  92     newStream->streamSize.HighPart = 0;
  93     newStream->streamSize.LowPart  = 0;
  94     newStream->bigBlockChain       = 0;
  95     newStream->smallBlockChain     = 0;
  96
  97     /*
  98      * Read the size from the property and determine if the blocks forming
  99      * this stream are large or small.
 100      */
 101     StgStreamImpl_OpenBlockChain(newStream);
 102   }
 103
 104   return newStream;
 105 }
 106
 107 /***
 108  * This is the destructor of the StgStreamImpl class.
 109  *
 110  * This method will clean-up all the resources used-up by the given StgStreamImpl
 111  * class. The pointer passed-in to this function will be freed and will not
 112  * be valid anymore.
 113  */
 114 void StgStreamImpl_Destroy(StgStreamImpl* This)
 115 {
 116   TRACE(storage, "(%p)\n", This);
 117
 118   /*
 119    * Release the reference we are holding on the parent storage.
 120    */
 121   IStorage_Release((IStorage*)This->parentStorage);
 122   This->parentStorage = 0;
 123
 124   /*
 125    * Make sure we clean-up the block chain stream objects that we were using.
 126    */
 127   if (This->bigBlockChain != 0)
 128   {
 129     BlockChainStream_Destroy(This->bigBlockChain);
 130     This->bigBlockChain = 0;
 131   }
 132
 133   if (This->smallBlockChain != 0)
 134   {
 135     SmallBlockChainStream_Destroy(This->smallBlockChain);
 136     This->smallBlockChain = 0;
 137   }
 138
 139   /*
 140    * Finally, free the memory used-up by the class.
 141    */
 142   HeapFree(GetProcessHeap(), 0, This);
 143 }
 144
 145 /***
 146  * This implements the IUnknown method QueryInterface for this
 147  * class
 148  */
 149 HRESULT WINAPI StgStreamImpl_QueryInterface(
 150                   IStream*     iface,
 151                   REFIID         riid,        /* [in] */
 152                   void**         ppvObject)   /* [iid_is][out] */
 153 {
 154   StgStreamImpl* const This=(StgStreamImpl*)iface;
 155
 156   /*
 157    * Perform a sanity check on the parameters.
 158    */
 159   if (ppvObject==0)
 160     return E_INVALIDARG;
 161
 162   /*
 163    * Initialize the return parameter.
 164    */
 165   *ppvObject = 0;
 166
 167   /*
 168    * Compare the riid with the interface IDs implemented by this object.
 169    */
 170   if (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) == 0)
 171   {
 172     *ppvObject = (IStream*)This;
 173   }
 174   else if (memcmp(&IID_IStream, riid, sizeof(IID_IStream)) == 0)
 175   {
 176     *ppvObject = (IStream*)This;
 177   }
 178
 179   /*
 180    * Check that we obtained an interface.
 181    */
 182   if ((*ppvObject)==0)
 183     return E_NOINTERFACE;
 184
 185   /*
 186    * Query Interface always increases the reference count by one when it is
 187    * successful
 188    */
 189   StgStreamImpl_AddRef(iface);
 190
 191   return S_OK;;
 192 }
 193
 194 /***
 195  * This implements the IUnknown method AddRef for this
 196  * class
 197  */
 198 ULONG WINAPI StgStreamImpl_AddRef(
 199                 IStream* iface)
 200 {
 201   StgStreamImpl* const This=(StgStreamImpl*)iface;
 202
 203   This->ref++;
 204
 205   return This->ref;
 206 }
 207
 208 /***
 209  * This implements the IUnknown method Release for this
 210  * class
 211  */
 212 ULONG WINAPI StgStreamImpl_Release(
 213                 IStream* iface)
 214 {
 215   StgStreamImpl* const This=(StgStreamImpl*)iface;
 216
 217   ULONG newRef;
 218
 219   This->ref--;
 220
 221   newRef = This->ref;
 222
 223   /*
 224    * If the reference count goes down to 0, perform suicide.
 225    */
 226   if (newRef==0)
 227   {
 228     StgStreamImpl_Destroy(This);
 229   }
 230
 231   return newRef;
 232 }
 233
 234 /***
 235  * This method will open the block chain pointed by the property
 236  * that describes the stream.
 237  * If the stream's size is null, no chain is opened.
 238  */
 239 void StgStreamImpl_OpenBlockChain(
 240         StgStreamImpl* This)
 241 {
 242   StgProperty    curProperty;
 243   BOOL         readSucessful;
 244
 245   /*
 246    * Make sure no old object is staying behind.
 247    */
 248   if (This->smallBlockChain != 0)
 249   {
 250     SmallBlockChainStream_Destroy(This->smallBlockChain);
 251     This->smallBlockChain = 0;
 252   }
 253
 254   if (This->bigBlockChain != 0)
 255   {
 256     BlockChainStream_Destroy(This->bigBlockChain);
 257     This->bigBlockChain = 0;
 258   }
 259
 260   /*
 261    * Read the information from the property.
 262    */
 263   readSucessful = StorageImpl_ReadProperty(This->parentStorage->ancestorStorage,
 264                                              This->ownerProperty,
 265                                              &curProperty);
 266
 267   if (readSucessful)
 268   {
 269     This->streamSize = curProperty.size;
 270
 271     /*
 272      * This code supports only streams that are <32 bits in size.
 273      */
 274     assert(This->streamSize.HighPart == 0);
 275
 276     if(curProperty.startingBlock == BLOCK_END_OF_CHAIN)
 277     {
 278       assert( (This->streamSize.HighPart == 0) && (This->streamSize.LowPart == 0) );
 279     }
 280     else
 281     {
 282       if ( (This->streamSize.HighPart == 0) &&
 283            (This->streamSize.LowPart < LIMIT_TO_USE_SMALL_BLOCK) )
 284       {
 285         This->smallBlockChain = SmallBlockChainStream_Construct(
 286                                                                 This->parentStorage->ancestorStorage,
 287                                                                 This->ownerProperty);
 288       }
 289       else
 290       {
 291         This->bigBlockChain = BlockChainStream_Construct(
 292                                                          This->parentStorage->ancestorStorage,
 293                                                          NULL,
 294                                                          This->ownerProperty);
 295       }
 296     }
 297   }
 298 }
 299
 300 /***
 301  * This method is part of the ISequentialStream interface.
 302  *
 303  * If reads a block of information from the stream at the current
 304  * position. It then moves the current position at the end of the
 305  * read block
 306  *
 307  * See the documentation of ISequentialStream for more info.
 308  */
 309 HRESULT WINAPI StgStreamImpl_Read(
 310                   IStream*     iface,
 311                   void*          pv,        /* [length_is][size_is][out] */
 312                   ULONG          cb,        /* [in] */
 313                   ULONG*         pcbRead)   /* [out] */
 314 {
 315   StgStreamImpl* const This=(StgStreamImpl*)iface;
 316
 317   ULONG bytesReadBuffer;
 318   ULONG bytesToReadFromBuffer;
 319
 320   TRACE(storage, "(%p, %p, %ld, %p)\n",
 321         iface, pv, cb, pcbRead);
 322
 323   /*
 324    * If the caller is not interested in the nubmer of bytes read,
 325    * we use another buffer to avoid "if" statements in the code.
 326    */
 327   if (pcbRead==0)
 328     pcbRead = &bytesReadBuffer;
 329
 330   /*
 331    * Using the known size of the stream, calculate the number of bytes
 332    * to read from the block chain
 333    */
 334   bytesToReadFromBuffer = MIN( This->streamSize.LowPart - This->currentPosition.LowPart, cb);
 335
 336   /*
 337    * Depending on the type of chain that was opened when the stream was constructed,
 338    * we delegate the work to the method that read the block chains.
 339    */
 340   if (This->smallBlockChain!=0)
 341   {
 342     SmallBlockChainStream_ReadAt(This->smallBlockChain,
 343                                  This->currentPosition,
 344                                  bytesToReadFromBuffer,
 345                                  pv,
 346                                  pcbRead);
 347
 348   }
 349   else if (This->bigBlockChain!=0)
 350   {
 351     BlockChainStream_ReadAt(This->bigBlockChain,
 352                             This->currentPosition,
 353                             bytesToReadFromBuffer,
 354                             pv,
 355                             pcbRead);
 356   }
 357   else
 358     assert(FALSE);
 359
 360   /*
 361    * We should always be able to read the proper amount of data from the
 362    * chain.
 363    */
 364   assert(bytesToReadFromBuffer == *pcbRead);
 365
 366   /*
 367    * Advance the pointer for the number of positions read.
 368    */
 369   This->currentPosition.LowPart += *pcbRead;
 370
 371   /*
 372    * The function returns S_OK if the buffer was filled completely
 373    * it returns S_FALSE if the end of the stream is reached before the
 374    * buffer is filled
 375    */
 376   if(*pcbRead == cb)
 377     return S_OK;
 378
 379   return S_FALSE;
 380 }
 381
 382 /***
 383  * This method is part of the ISequentialStream interface.
 384  *
 385  * It writes a block of information to the stream at the current
 386  * position. It then moves the current position at the end of the
 387  * written block. If the stream is too small to fit the block,
 388  * the stream is grown to fit.
 389  *
 390  * See the documentation of ISequentialStream for more info.
 391  */
 392 HRESULT WINAPI StgStreamImpl_Write(
 393                   IStream*     iface,
 394                   const void*    pv,          /* [size_is][in] */
 395                   ULONG          cb,          /* [in] */
 396                   ULONG*         pcbWritten)  /* [out] */
 397 {
 398   StgStreamImpl* const This=(StgStreamImpl*)iface;
 399
 400   ULARGE_INTEGER newSize;
 401   ULONG bytesWritten = 0;
 402
 403   TRACE(storage, "(%p, %p, %ld, %p)\n",
 404         iface, pv, cb, pcbWritten);
 405
 406   /*
 407    * If the caller is not interested in the number of bytes written,
 408    * we use another buffer to avoid "if" statements in the code.
 409    */
 410   if (pcbWritten == 0)
 411     pcbWritten = &bytesWritten;
 412
 413   /*
 414    * Initialize the out parameter
 415    */
 416   *pcbWritten = 0;
 417
 418   if (cb == 0)
 419   {
 420     return S_OK;
 421   }
 422   else
 423   {
 424     newSize.HighPart = 0;
 425     newSize.LowPart = This->currentPosition.LowPart + cb;
 426   }
 427
 428   /*
 429    * Verify if we need to grow the stream
 430    */
 431   if (newSize.LowPart > This->streamSize.LowPart)
 432   {
 433     /* grow stream */
 434     IStream_SetSize(iface, newSize);
 435   }
 436
 437   /*
 438    * Depending on the type of chain that was opened when the stream was constructed,
 439    * we delegate the work to the method that readwrites to the block chains.
 440    */
 441   if (This->smallBlockChain!=0)
 442   {
 443     SmallBlockChainStream_WriteAt(This->smallBlockChain,
 444                                   This->currentPosition,
 445                                   cb,
 446                                   pv,
 447                                   pcbWritten);
 448
 449   }
 450   else if (This->bigBlockChain!=0)
 451   {
 452     BlockChainStream_WriteAt(This->bigBlockChain,
 453                              This->currentPosition,
 454                              cb,
 455                              pv,
 456                              pcbWritten);
 457   }
 458   else
 459     assert(FALSE);
 460
 461   /*
 462    * Advance the position pointer for the number of positions written.
 463    */
 464   This->currentPosition.LowPart += *pcbWritten;
 465
 466   return S_OK;
 467 }
 468
 469 /***
 470  * This method is part of the IStream interface.
 471  *
 472  * It will move the current stream pointer according to the parameters
 473  * given.
 474  *
 475  * See the documentation of IStream for more info.
 476  */
 477 HRESULT WINAPI StgStreamImpl_Seek(
 478                   IStream*      iface,
 479                   LARGE_INTEGER   dlibMove,         /* [in] */
 480                   DWORD           dwOrigin,         /* [in] */
 481                   ULARGE_INTEGER* plibNewPosition) /* [out] */
 482 {
 483   StgStreamImpl* const This=(StgStreamImpl*)iface;
 484
 485   ULARGE_INTEGER newPosition;
 486
 487   TRACE(storage, "(%p, %ld, %ld, %p)\n",
 488         iface, dlibMove.LowPart, dwOrigin, plibNewPosition);
 489
 490   /*
 491    * The caller is allowed to pass in NULL as the new position return value.
 492    * If it happens, we assign it to a dynamic variable to avoid special cases
 493    * in the code below.
 494    */
 495   if (plibNewPosition == 0)
 496   {
 497     plibNewPosition = &newPosition;
 498   }
 499
 500   /*
 501    * The file pointer is moved depending on the given "function"
 502    * parameter.
 503    */
 504   switch (dwOrigin)
 505   {
 506     case STREAM_SEEK_SET:
 507       plibNewPosition->HighPart = 0;
 508       plibNewPosition->LowPart  = 0;
 509       break;
 510     case STREAM_SEEK_CUR:
 511       *plibNewPosition = This->currentPosition;
 512       break;
 513     case STREAM_SEEK_END:
 514       *plibNewPosition = This->streamSize;
 515       break;
 516     default:
 517       return STG_E_INVALIDFUNCTION;
 518   }
 519
 520   /*
 521    * We don't support files with offsets of 64 bits.
 522    */
 523   assert(dlibMove.HighPart == 0);
 524
 525   /*
 526    * Check if we end-up before the beginning of the file. That should trigger an
 527    * error.
 528    */
 529   if ( (dlibMove.LowPart<0) && (plibNewPosition->LowPart < (ULONG)(-dlibMove.LowPart)) )
 530   {
 531     /*
 532      * I don't know what error to send there.
 533      */
 534     return E_FAIL;
 535   }
 536
 537   /*
 538    * Move the actual file pointer
 539    * If the file pointer ends-up after the end of the stream, the next Write operation will
 540    * make the file larger. This is how it is documented.
 541    */
 542   plibNewPosition->LowPart += dlibMove.LowPart;
 543   This->currentPosition = *plibNewPosition;
 544
 545   return S_OK;
 546 }
 547
 548 /***
 549  * This method is part of the IStream interface.
 550  *
 551  * It will change the size of a stream.
 552  *
 553  * TODO: Switch from small blocks to big blocks and vice versa.
 554  *
 555  * See the documentation of IStream for more info.
 556  */
 557 HRESULT WINAPI StgStreamImpl_SetSize(
 558                                      IStream*      iface,
 559                                      ULARGE_INTEGER  libNewSize)   /* [in] */
 560 {
 561   StgStreamImpl* const This=(StgStreamImpl*)iface;
 562
 563   StgProperty    curProperty;
 564   BOOL         Success;
 565
 566   TRACE(storage, "(%p, %ld)\n", iface, libNewSize.LowPart);
 567
 568   /*
 569    * As documented.
 570    */
 571   if (libNewSize.HighPart != 0)
 572     return STG_E_INVALIDFUNCTION;
 573
 574   if (This->streamSize.LowPart == libNewSize.LowPart)
 575     return S_OK;
 576
 577   /*
 578    * This will happen if we're creating a stream
 579    */
 580   if ((This->smallBlockChain == 0) && (This->bigBlockChain == 0))
 581   {
 582     if (libNewSize.LowPart < LIMIT_TO_USE_SMALL_BLOCK)
 583     {
 584       This->smallBlockChain = SmallBlockChainStream_Construct(
 585                                     This->parentStorage->ancestorStorage,
 586                                     This->ownerProperty);
 587     }
 588     else
 589     {
 590       This->bigBlockChain = BlockChainStream_Construct(
 591                                 This->parentStorage->ancestorStorage,
 592                                 NULL,
 593                                 This->ownerProperty);
 594     }
 595   }
 596
 597   /*
 598    * Read this stream's property to see if it's small blocks or big blocks
 599    */
 600   Success = StorageImpl_ReadProperty(This->parentStorage->ancestorStorage,
 601                                        This->ownerProperty,
 602                                        &curProperty);
 603   /*
 604    * Determine if we have to switch from small to big blocks or vice versa
 605    */
 606   if ( (This->smallBlockChain!=0) &&
 607        (curProperty.size.LowPart < LIMIT_TO_USE_SMALL_BLOCK) )
 608   {
 609     if (libNewSize.LowPart >= LIMIT_TO_USE_SMALL_BLOCK)
 610     {
 611       /*
 612        * Transform the small block chain into a big block chain
 613        */
 614       This->bigBlockChain = Storage32Impl_SmallBlocksToBigBlocks(
 615                                 This->parentStorage->ancestorStorage,
 616                                 &This->smallBlockChain);
 617     }
 618   }
 619
 620   if (This->smallBlockChain!=0)
 621   {
 622     Success = SmallBlockChainStream_SetSize(This->smallBlockChain, libNewSize);
 623   }
 624   else
 625   {
 626     Success = BlockChainStream_SetSize(This->bigBlockChain, libNewSize);
 627   }
 628
 629   /*
 630    * Write to the property the new information about this stream
 631    */
 632   Success = StorageImpl_ReadProperty(This->parentStorage->ancestorStorage,
 633                                        This->ownerProperty,
 634                                        &curProperty);
 635
 636   curProperty.size.HighPart = libNewSize.HighPart;
 637   curProperty.size.LowPart = libNewSize.LowPart;
 638
 639   if (Success)
 640   {
 641     StorageImpl_WriteProperty(This->parentStorage->ancestorStorage,
 642                                 This->ownerProperty,
 643                                 &curProperty);
 644   }
 645
 646   This->streamSize = libNewSize;
 647
 648   return S_OK;
 649 }
 650
 651 /***
 652  * This method is part of the IStream interface.
 653  *
 654  * It will copy the 'cb' Bytes to 'pstm' IStream.
 655  *
 656  * See the documentation of IStream for more info.
 657  */
 658 HRESULT WINAPI StgStreamImpl_CopyTo(
 659                                     IStream*      iface,
 660                                     IStream*      pstm,         /* [unique][in] */
 661                                     ULARGE_INTEGER  cb,           /* [in] */
 662                                     ULARGE_INTEGER* pcbRead,      /* [out] */
 663                                     ULARGE_INTEGER* pcbWritten)   /* [out] */
 664 {
 665   HRESULT        hr = S_OK;
 666   BYTE           tmpBuffer[128];
 667   ULONG          bytesRead, bytesWritten, copySize;
 668   ULARGE_INTEGER totalBytesRead;
 669   ULARGE_INTEGER totalBytesWritten;
 670
 671   TRACE(storage, "(%p, %p, %ld, %p, %p)\n",
 672         iface, pstm, cb.LowPart, pcbRead, pcbWritten);
 673
 674   /*
 675    * Sanity check
 676    */
 677   if ( pstm == 0 )
 678     return STG_E_INVALIDPOINTER;
 679
 680   totalBytesRead.LowPart = totalBytesRead.HighPart = 0;
 681   totalBytesWritten.LowPart = totalBytesWritten.HighPart = 0;
 682
 683   /*
 684    * use stack to store data temporarly
 685    * there is surely more performant way of doing it, for now this basic
 686    * implementation will do the job
 687    */
 688   while ( cb.LowPart > 0 )
 689   {
 690     if ( cb.LowPart >= 128 )
 691       copySize = 128;
 692     else
 693       copySize = cb.LowPart;
 694
 695     IStream_Read(iface, tmpBuffer, copySize, &bytesRead);
 696
 697     totalBytesRead.LowPart += bytesRead;
 698
 699     IStream_Write(pstm, tmpBuffer, bytesRead, &bytesWritten);
 700
 701     totalBytesWritten.LowPart += bytesWritten;
 702
 703     /*
 704      * Check that read & write operations were succesfull
 705      */
 706     if (bytesRead != bytesWritten)
 707     {
 708       hr = STG_E_MEDIUMFULL;
 709       break;
 710     }
 711
 712     if (bytesRead!=copySize)
 713       cb.LowPart = 0;
 714     else
 715       cb.LowPart -= bytesRead;
 716   }
 717
 718   /*
 719    * Update number of bytes read and written
 720    */
 721   if (pcbRead)
 722   {
 723     pcbRead->LowPart = totalBytesRead.LowPart;
 724     pcbRead->HighPart = totalBytesRead.HighPart;
 725   }
 726
 727   if (pcbWritten)
 728   {
 729     pcbWritten->LowPart = totalBytesWritten.LowPart;
 730     pcbWritten->HighPart = totalBytesWritten.HighPart;
 731   }
 732   return hr;
 733 }
 734
 735 /***
 736  * This method is part of the IStream interface.
 737  *
 738  * For streams contained in structured storages, this method
 739  * does nothing. This is what the documentation tells us.
 740  *
 741  * See the documentation of IStream for more info.
 742  */
 743 HRESULT WINAPI StgStreamImpl_Commit(
 744                   IStream*      iface,
 745                   DWORD           grfCommitFlags)  /* [in] */
 746 {
 747   return S_OK;
 748 }
 749
 750 /***
 751  * This method is part of the IStream interface.
 752  *
 753  * For streams contained in structured storages, this method
 754  * does nothing. This is what the documentation tells us.
 755  *
 756  * See the documentation of IStream for more info.
 757  */
 758 HRESULT WINAPI StgStreamImpl_Revert(
 759                   IStream* iface)
 760 {
 761   return S_OK;
 762 }
 763
 764 HRESULT WINAPI StgStreamImpl_LockRegion(
 765                                         IStream*     iface,
 766                                         ULARGE_INTEGER libOffset,   /* [in] */
 767                                         ULARGE_INTEGER cb,          /* [in] */
 768                                         DWORD          dwLockType)  /* [in] */
 769 {
 770   FIXME(storage, "not implemented!\n");
 771   return E_NOTIMPL;
 772 }
 773
 774 HRESULT WINAPI StgStreamImpl_UnlockRegion(
 775                                           IStream*     iface,
 776                                           ULARGE_INTEGER libOffset,   /* [in] */
 777                                           ULARGE_INTEGER cb,          /* [in] */
 778                                           DWORD          dwLockType)  /* [in] */
 779 {
 780   FIXME(storage, "not implemented!\n");
 781   return E_NOTIMPL;
 782 }
 783
 784 /***
 785  * This method is part of the IStream interface.
 786  *
 787  * This method returns information about the current
 788  * stream.
 789  *
 790  * See the documentation of IStream for more info.
 791  */
 792 HRESULT WINAPI StgStreamImpl_Stat(
 793                   IStream*     iface,
 794                   STATSTG*       pstatstg,     /* [out] */
 795                   DWORD          grfStatFlag)  /* [in] */
 796 {
 797   StgStreamImpl* const This=(StgStreamImpl*)iface;
 798
 799   StgProperty    curProperty;
 800   BOOL         readSucessful;
 801
 802   /*
 803    * Read the information from the property.
 804    */
 805   readSucessful = StorageImpl_ReadProperty(This->parentStorage->ancestorStorage,
 806                                              This->ownerProperty,
 807                                              &curProperty);
 808
 809   if (readSucessful)
 810   {
 811     StorageUtl_CopyPropertyToSTATSTG(pstatstg,
 812                                      &curProperty,
 813                                      grfStatFlag);
 814
 815     return S_OK;
 816   }
 817
 818   return E_FAIL;
 819 }
 820
 821 HRESULT WINAPI StgStreamImpl_Clone(
 822                                    IStream*     iface,
 823                                    IStream**    ppstm) /* [out] */
 824 {
 825   FIXME(storage, "not implemented!\n");
 826   return E_NOTIMPL;
 827 }