2 * Compound Storage (32 bit version)
3 * Stream implementation
5 * This file contains the implementation of the stream interface
6 * for streams contained in a compound storage.
8 * Copyright 1999 Francis Beaudet
9 * Copyright 1999 Thuy Nguyen
18 #include "debugtools.h"
19 #include "wine/obj_storage.h"
21 #include "storage32.h"
23 DEFAULT_DEBUG_CHANNEL(storage
)
27 * Virtual function table for the StgStreamImpl class.
29 static ICOM_VTABLE(IStream
) StgStreamImpl_Vtbl
=
31 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
32 StgStreamImpl_QueryInterface
,
34 StgStreamImpl_Release
,
38 StgStreamImpl_SetSize
,
42 StgStreamImpl_LockRegion
,
43 StgStreamImpl_UnlockRegion
,
48 /******************************************************************************
49 ** StgStreamImpl implementation
53 * This is the constructor for the StgStreamImpl class.
56 * parentStorage - Pointer to the storage that contains the stream to open
57 * ownerProperty - Index of the property that points to this stream.
59 StgStreamImpl
* StgStreamImpl_Construct(
60 StorageBaseImpl
* parentStorage
,
63 StgStreamImpl
* newStream
;
65 newStream
= HeapAlloc(GetProcessHeap(), 0, sizeof(StgStreamImpl
));
70 * Set-up the virtual function table and reference count.
72 newStream
->lpvtbl
= &StgStreamImpl_Vtbl
;
76 * We want to nail-down the reference to the storage in case the
77 * stream out-lives the storage in the client application.
79 newStream
->parentStorage
= parentStorage
;
80 IStorage_AddRef((IStorage
*)newStream
->parentStorage
);
82 newStream
->ownerProperty
= ownerProperty
;
85 * Start the stream at the begining.
87 newStream
->currentPosition
.HighPart
= 0;
88 newStream
->currentPosition
.LowPart
= 0;
91 * Initialize the rest of the data.
93 newStream
->streamSize
.HighPart
= 0;
94 newStream
->streamSize
.LowPart
= 0;
95 newStream
->bigBlockChain
= 0;
96 newStream
->smallBlockChain
= 0;
99 * Read the size from the property and determine if the blocks forming
100 * this stream are large or small.
102 StgStreamImpl_OpenBlockChain(newStream
);
109 * This is the destructor of the StgStreamImpl class.
111 * This method will clean-up all the resources used-up by the given StgStreamImpl
112 * class. The pointer passed-in to this function will be freed and will not
115 void StgStreamImpl_Destroy(StgStreamImpl
* This
)
117 TRACE("(%p)\n", This
);
120 * Release the reference we are holding on the parent storage.
122 IStorage_Release((IStorage
*)This
->parentStorage
);
123 This
->parentStorage
= 0;
126 * Make sure we clean-up the block chain stream objects that we were using.
128 if (This
->bigBlockChain
!= 0)
130 BlockChainStream_Destroy(This
->bigBlockChain
);
131 This
->bigBlockChain
= 0;
134 if (This
->smallBlockChain
!= 0)
136 SmallBlockChainStream_Destroy(This
->smallBlockChain
);
137 This
->smallBlockChain
= 0;
141 * Finally, free the memory used-up by the class.
143 HeapFree(GetProcessHeap(), 0, This
);
147 * This implements the IUnknown method QueryInterface for this
150 HRESULT WINAPI
StgStreamImpl_QueryInterface(
152 REFIID riid
, /* [in] */
153 void** ppvObject
) /* [iid_is][out] */
155 StgStreamImpl
* const This
=(StgStreamImpl
*)iface
;
158 * Perform a sanity check on the parameters.
164 * Initialize the return parameter.
169 * Compare the riid with the interface IDs implemented by this object.
171 if (memcmp(&IID_IUnknown
, riid
, sizeof(IID_IUnknown
)) == 0)
173 *ppvObject
= (IStream
*)This
;
175 else if (memcmp(&IID_IStream
, riid
, sizeof(IID_IStream
)) == 0)
177 *ppvObject
= (IStream
*)This
;
181 * Check that we obtained an interface.
184 return E_NOINTERFACE
;
187 * Query Interface always increases the reference count by one when it is
190 StgStreamImpl_AddRef(iface
);
196 * This implements the IUnknown method AddRef for this
199 ULONG WINAPI
StgStreamImpl_AddRef(
202 StgStreamImpl
* const This
=(StgStreamImpl
*)iface
;
210 * This implements the IUnknown method Release for this
213 ULONG WINAPI
StgStreamImpl_Release(
216 StgStreamImpl
* const This
=(StgStreamImpl
*)iface
;
225 * If the reference count goes down to 0, perform suicide.
229 StgStreamImpl_Destroy(This
);
236 * This method will open the block chain pointed by the property
237 * that describes the stream.
238 * If the stream's size is null, no chain is opened.
240 void StgStreamImpl_OpenBlockChain(
243 StgProperty curProperty
;
247 * Make sure no old object is staying behind.
249 if (This
->smallBlockChain
!= 0)
251 SmallBlockChainStream_Destroy(This
->smallBlockChain
);
252 This
->smallBlockChain
= 0;
255 if (This
->bigBlockChain
!= 0)
257 BlockChainStream_Destroy(This
->bigBlockChain
);
258 This
->bigBlockChain
= 0;
262 * Read the information from the property.
264 readSucessful
= StorageImpl_ReadProperty(This
->parentStorage
->ancestorStorage
,
270 This
->streamSize
= curProperty
.size
;
273 * This code supports only streams that are <32 bits in size.
275 assert(This
->streamSize
.HighPart
== 0);
277 if(curProperty
.startingBlock
== BLOCK_END_OF_CHAIN
)
279 assert( (This
->streamSize
.HighPart
== 0) && (This
->streamSize
.LowPart
== 0) );
283 if ( (This
->streamSize
.HighPart
== 0) &&
284 (This
->streamSize
.LowPart
< LIMIT_TO_USE_SMALL_BLOCK
) )
286 This
->smallBlockChain
= SmallBlockChainStream_Construct(
287 This
->parentStorage
->ancestorStorage
,
288 This
->ownerProperty
);
292 This
->bigBlockChain
= BlockChainStream_Construct(
293 This
->parentStorage
->ancestorStorage
,
295 This
->ownerProperty
);
302 * This method is part of the ISequentialStream interface.
304 * If reads a block of information from the stream at the current
305 * position. It then moves the current position at the end of the
308 * See the documentation of ISequentialStream for more info.
310 HRESULT WINAPI
StgStreamImpl_Read(
312 void* pv
, /* [length_is][size_is][out] */
314 ULONG
* pcbRead
) /* [out] */
316 StgStreamImpl
* const This
=(StgStreamImpl
*)iface
;
318 ULONG bytesReadBuffer
;
319 ULONG bytesToReadFromBuffer
;
321 TRACE("(%p, %p, %ld, %p)\n",
322 iface
, pv
, cb
, pcbRead
);
325 * If the caller is not interested in the nubmer of bytes read,
326 * we use another buffer to avoid "if" statements in the code.
329 pcbRead
= &bytesReadBuffer
;
332 * Using the known size of the stream, calculate the number of bytes
333 * to read from the block chain
335 bytesToReadFromBuffer
= MIN( This
->streamSize
.LowPart
- This
->currentPosition
.LowPart
, cb
);
338 * Depending on the type of chain that was opened when the stream was constructed,
339 * we delegate the work to the method that read the block chains.
341 if (This
->smallBlockChain
!=0)
343 SmallBlockChainStream_ReadAt(This
->smallBlockChain
,
344 This
->currentPosition
,
345 bytesToReadFromBuffer
,
350 else if (This
->bigBlockChain
!=0)
352 BlockChainStream_ReadAt(This
->bigBlockChain
,
353 This
->currentPosition
,
354 bytesToReadFromBuffer
,
361 * Small and big block chains are both NULL. This case will happen
362 * when a stream starts with BLOCK_END_OF_CHAIN and has size zero.
370 * We should always be able to read the proper amount of data from the
373 assert(bytesToReadFromBuffer
== *pcbRead
);
376 * Advance the pointer for the number of positions read.
378 This
->currentPosition
.LowPart
+= *pcbRead
;
381 * The function returns S_OK if the buffer was filled completely
382 * it returns S_FALSE if the end of the stream is reached before the
392 * This method is part of the ISequentialStream interface.
394 * It writes a block of information to the stream at the current
395 * position. It then moves the current position at the end of the
396 * written block. If the stream is too small to fit the block,
397 * the stream is grown to fit.
399 * See the documentation of ISequentialStream for more info.
401 HRESULT WINAPI
StgStreamImpl_Write(
403 const void* pv
, /* [size_is][in] */
405 ULONG
* pcbWritten
) /* [out] */
407 StgStreamImpl
* const This
=(StgStreamImpl
*)iface
;
409 ULARGE_INTEGER newSize
;
410 ULONG bytesWritten
= 0;
412 TRACE("(%p, %p, %ld, %p)\n",
413 iface
, pv
, cb
, pcbWritten
);
416 * If the caller is not interested in the number of bytes written,
417 * we use another buffer to avoid "if" statements in the code.
420 pcbWritten
= &bytesWritten
;
423 * Initialize the out parameter
433 newSize
.HighPart
= 0;
434 newSize
.LowPart
= This
->currentPosition
.LowPart
+ cb
;
438 * Verify if we need to grow the stream
440 if (newSize
.LowPart
> This
->streamSize
.LowPart
)
443 IStream_SetSize(iface
, newSize
);
447 * Depending on the type of chain that was opened when the stream was constructed,
448 * we delegate the work to the method that readwrites to the block chains.
450 if (This
->smallBlockChain
!=0)
452 SmallBlockChainStream_WriteAt(This
->smallBlockChain
,
453 This
->currentPosition
,
459 else if (This
->bigBlockChain
!=0)
461 BlockChainStream_WriteAt(This
->bigBlockChain
,
462 This
->currentPosition
,
471 * Advance the position pointer for the number of positions written.
473 This
->currentPosition
.LowPart
+= *pcbWritten
;
479 * This method is part of the IStream interface.
481 * It will move the current stream pointer according to the parameters
484 * See the documentation of IStream for more info.
486 HRESULT WINAPI
StgStreamImpl_Seek(
488 LARGE_INTEGER dlibMove
, /* [in] */
489 DWORD dwOrigin
, /* [in] */
490 ULARGE_INTEGER
* plibNewPosition
) /* [out] */
492 StgStreamImpl
* const This
=(StgStreamImpl
*)iface
;
494 ULARGE_INTEGER newPosition
;
496 TRACE("(%p, %ld, %ld, %p)\n",
497 iface
, dlibMove
.LowPart
, dwOrigin
, plibNewPosition
);
500 * The caller is allowed to pass in NULL as the new position return value.
501 * If it happens, we assign it to a dynamic variable to avoid special cases
504 if (plibNewPosition
== 0)
506 plibNewPosition
= &newPosition
;
510 * The file pointer is moved depending on the given "function"
515 case STREAM_SEEK_SET
:
516 plibNewPosition
->HighPart
= 0;
517 plibNewPosition
->LowPart
= 0;
519 case STREAM_SEEK_CUR
:
520 *plibNewPosition
= This
->currentPosition
;
522 case STREAM_SEEK_END
:
523 *plibNewPosition
= This
->streamSize
;
526 return STG_E_INVALIDFUNCTION
;
530 * We don't support files with offsets of 64 bits.
532 assert(dlibMove
.HighPart
== 0);
535 * Check if we end-up before the beginning of the file. That should trigger an
538 if ( (dlibMove
.LowPart
<0) && (plibNewPosition
->LowPart
< (ULONG
)(-dlibMove
.LowPart
)) )
541 * I don't know what error to send there.
547 * Move the actual file pointer
548 * If the file pointer ends-up after the end of the stream, the next Write operation will
549 * make the file larger. This is how it is documented.
551 plibNewPosition
->LowPart
+= dlibMove
.LowPart
;
552 This
->currentPosition
= *plibNewPosition
;
558 * This method is part of the IStream interface.
560 * It will change the size of a stream.
562 * TODO: Switch from small blocks to big blocks and vice versa.
564 * See the documentation of IStream for more info.
566 HRESULT WINAPI
StgStreamImpl_SetSize(
568 ULARGE_INTEGER libNewSize
) /* [in] */
570 StgStreamImpl
* const This
=(StgStreamImpl
*)iface
;
572 StgProperty curProperty
;
575 TRACE("(%p, %ld)\n", iface
, libNewSize
.LowPart
);
580 if (libNewSize
.HighPart
!= 0)
581 return STG_E_INVALIDFUNCTION
;
583 if (This
->streamSize
.LowPart
== libNewSize
.LowPart
)
587 * This will happen if we're creating a stream
589 if ((This
->smallBlockChain
== 0) && (This
->bigBlockChain
== 0))
591 if (libNewSize
.LowPart
< LIMIT_TO_USE_SMALL_BLOCK
)
593 This
->smallBlockChain
= SmallBlockChainStream_Construct(
594 This
->parentStorage
->ancestorStorage
,
595 This
->ownerProperty
);
599 This
->bigBlockChain
= BlockChainStream_Construct(
600 This
->parentStorage
->ancestorStorage
,
602 This
->ownerProperty
);
607 * Read this stream's property to see if it's small blocks or big blocks
609 Success
= StorageImpl_ReadProperty(This
->parentStorage
->ancestorStorage
,
613 * Determine if we have to switch from small to big blocks or vice versa
615 if ( (This
->smallBlockChain
!=0) &&
616 (curProperty
.size
.LowPart
< LIMIT_TO_USE_SMALL_BLOCK
) )
618 if (libNewSize
.LowPart
>= LIMIT_TO_USE_SMALL_BLOCK
)
621 * Transform the small block chain into a big block chain
623 This
->bigBlockChain
= Storage32Impl_SmallBlocksToBigBlocks(
624 This
->parentStorage
->ancestorStorage
,
625 &This
->smallBlockChain
);
629 if (This
->smallBlockChain
!=0)
631 Success
= SmallBlockChainStream_SetSize(This
->smallBlockChain
, libNewSize
);
635 Success
= BlockChainStream_SetSize(This
->bigBlockChain
, libNewSize
);
639 * Write to the property the new information about this stream
641 Success
= StorageImpl_ReadProperty(This
->parentStorage
->ancestorStorage
,
645 curProperty
.size
.HighPart
= libNewSize
.HighPart
;
646 curProperty
.size
.LowPart
= libNewSize
.LowPart
;
650 StorageImpl_WriteProperty(This
->parentStorage
->ancestorStorage
,
655 This
->streamSize
= libNewSize
;
661 * This method is part of the IStream interface.
663 * It will copy the 'cb' Bytes to 'pstm' IStream.
665 * See the documentation of IStream for more info.
667 HRESULT WINAPI
StgStreamImpl_CopyTo(
669 IStream
* pstm
, /* [unique][in] */
670 ULARGE_INTEGER cb
, /* [in] */
671 ULARGE_INTEGER
* pcbRead
, /* [out] */
672 ULARGE_INTEGER
* pcbWritten
) /* [out] */
676 ULONG bytesRead
, bytesWritten
, copySize
;
677 ULARGE_INTEGER totalBytesRead
;
678 ULARGE_INTEGER totalBytesWritten
;
680 TRACE("(%p, %p, %ld, %p, %p)\n",
681 iface
, pstm
, cb
.LowPart
, pcbRead
, pcbWritten
);
687 return STG_E_INVALIDPOINTER
;
689 totalBytesRead
.LowPart
= totalBytesRead
.HighPart
= 0;
690 totalBytesWritten
.LowPart
= totalBytesWritten
.HighPart
= 0;
693 * use stack to store data temporarly
694 * there is surely more performant way of doing it, for now this basic
695 * implementation will do the job
697 while ( cb
.LowPart
> 0 )
699 if ( cb
.LowPart
>= 128 )
702 copySize
= cb
.LowPart
;
704 IStream_Read(iface
, tmpBuffer
, copySize
, &bytesRead
);
706 totalBytesRead
.LowPart
+= bytesRead
;
708 IStream_Write(pstm
, tmpBuffer
, bytesRead
, &bytesWritten
);
710 totalBytesWritten
.LowPart
+= bytesWritten
;
713 * Check that read & write operations were succesfull
715 if (bytesRead
!= bytesWritten
)
717 hr
= STG_E_MEDIUMFULL
;
721 if (bytesRead
!=copySize
)
724 cb
.LowPart
-= bytesRead
;
728 * Update number of bytes read and written
732 pcbRead
->LowPart
= totalBytesRead
.LowPart
;
733 pcbRead
->HighPart
= totalBytesRead
.HighPart
;
738 pcbWritten
->LowPart
= totalBytesWritten
.LowPart
;
739 pcbWritten
->HighPart
= totalBytesWritten
.HighPart
;
745 * This method is part of the IStream interface.
747 * For streams contained in structured storages, this method
748 * does nothing. This is what the documentation tells us.
750 * See the documentation of IStream for more info.
752 HRESULT WINAPI
StgStreamImpl_Commit(
754 DWORD grfCommitFlags
) /* [in] */
760 * This method is part of the IStream interface.
762 * For streams contained in structured storages, this method
763 * does nothing. This is what the documentation tells us.
765 * See the documentation of IStream for more info.
767 HRESULT WINAPI
StgStreamImpl_Revert(
773 HRESULT WINAPI
StgStreamImpl_LockRegion(
775 ULARGE_INTEGER libOffset
, /* [in] */
776 ULARGE_INTEGER cb
, /* [in] */
777 DWORD dwLockType
) /* [in] */
779 FIXME("not implemented!\n");
783 HRESULT WINAPI
StgStreamImpl_UnlockRegion(
785 ULARGE_INTEGER libOffset
, /* [in] */
786 ULARGE_INTEGER cb
, /* [in] */
787 DWORD dwLockType
) /* [in] */
789 FIXME("not implemented!\n");
794 * This method is part of the IStream interface.
796 * This method returns information about the current
799 * See the documentation of IStream for more info.
801 HRESULT WINAPI
StgStreamImpl_Stat(
803 STATSTG
* pstatstg
, /* [out] */
804 DWORD grfStatFlag
) /* [in] */
806 StgStreamImpl
* const This
=(StgStreamImpl
*)iface
;
808 StgProperty curProperty
;
812 * Read the information from the property.
814 readSucessful
= StorageImpl_ReadProperty(This
->parentStorage
->ancestorStorage
,
820 StorageUtl_CopyPropertyToSTATSTG(pstatstg
,
830 HRESULT WINAPI
StgStreamImpl_Clone(
832 IStream
** ppstm
) /* [out] */
834 FIXME("not implemented!\n");