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