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
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.
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.
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
33 #define NONAMELESSUNION
34 #define NONAMELESSSTRUCT
41 #include "wine/debug.h"
43 #include "storage32.h"
45 WINE_DEFAULT_DEBUG_CHANNEL(storage
);
49 * This is the destructor of the StgStreamImpl class.
51 * This method will clean-up all the resources used-up by the given StgStreamImpl
52 * class. The pointer passed-in to this function will be freed and will not
55 static void StgStreamImpl_Destroy(StgStreamImpl
* This
)
57 TRACE("(%p)\n", This
);
60 * Release the reference we are holding on the parent storage.
61 * IStorage_Release((IStorage*)This->parentStorage);
63 * No, don't do this. Some apps call IStorage_Release without
64 * calling IStream_Release first. If we grab a reference the
65 * file is not closed, and the app fails when it tries to
66 * reopen the file (Easy-PC, for example). Just inform the
67 * storage that we have closed the stream
70 if(This
->parentStorage
) {
72 StorageBaseImpl_RemoveStream(This
->parentStorage
, This
);
76 This
->parentStorage
= 0;
79 * Make sure we clean-up the block chain stream objects that we were using.
81 if (This
->bigBlockChain
!= 0)
83 BlockChainStream_Destroy(This
->bigBlockChain
);
84 This
->bigBlockChain
= 0;
87 if (This
->smallBlockChain
!= 0)
89 SmallBlockChainStream_Destroy(This
->smallBlockChain
);
90 This
->smallBlockChain
= 0;
94 * Finally, free the memory used-up by the class.
96 HeapFree(GetProcessHeap(), 0, This
);
100 * This implements the IUnknown method QueryInterface for this
103 static HRESULT WINAPI
StgStreamImpl_QueryInterface(
105 REFIID riid
, /* [in] */
106 void** ppvObject
) /* [iid_is][out] */
108 StgStreamImpl
* const This
=(StgStreamImpl
*)iface
;
111 * Perform a sanity check on the parameters.
117 * Initialize the return parameter.
122 * Compare the riid with the interface IDs implemented by this object.
124 if (IsEqualGUID(&IID_IUnknown
, riid
)||
125 IsEqualGUID(&IID_IPersistStream
, riid
)||
126 IsEqualGUID(&IID_IStream
, riid
))
128 *ppvObject
= (IStream
*)This
;
132 * Check that we obtained an interface.
135 return E_NOINTERFACE
;
138 * Query Interface always increases the reference count by one when it is
141 IStream_AddRef(iface
);
147 * This implements the IUnknown method AddRef for this
150 static ULONG WINAPI
StgStreamImpl_AddRef(
153 StgStreamImpl
* const This
=(StgStreamImpl
*)iface
;
154 return InterlockedIncrement(&This
->ref
);
158 * This implements the IUnknown method Release for this
161 static ULONG WINAPI
StgStreamImpl_Release(
164 StgStreamImpl
* const This
=(StgStreamImpl
*)iface
;
168 ref
= InterlockedDecrement(&This
->ref
);
171 * If the reference count goes down to 0, perform suicide.
175 StgStreamImpl_Destroy(This
);
182 * This method will open the block chain pointed by the property
183 * that describes the stream.
184 * If the stream's size is null, no chain is opened.
186 static void StgStreamImpl_OpenBlockChain(
189 StgProperty curProperty
;
193 * Make sure no old object is left over.
195 if (This
->smallBlockChain
!= 0)
197 SmallBlockChainStream_Destroy(This
->smallBlockChain
);
198 This
->smallBlockChain
= 0;
201 if (This
->bigBlockChain
!= 0)
203 BlockChainStream_Destroy(This
->bigBlockChain
);
204 This
->bigBlockChain
= 0;
208 * Read the information from the property.
210 readSuccessful
= StorageImpl_ReadProperty(This
->parentStorage
->ancestorStorage
,
216 This
->streamSize
= curProperty
.size
;
219 * This code supports only streams that are <32 bits in size.
221 assert(This
->streamSize
.u
.HighPart
== 0);
223 if(curProperty
.startingBlock
== BLOCK_END_OF_CHAIN
)
225 assert( (This
->streamSize
.u
.HighPart
== 0) && (This
->streamSize
.u
.LowPart
== 0) );
229 if ( (This
->streamSize
.u
.HighPart
== 0) &&
230 (This
->streamSize
.u
.LowPart
< LIMIT_TO_USE_SMALL_BLOCK
) )
232 This
->smallBlockChain
= SmallBlockChainStream_Construct(
233 This
->parentStorage
->ancestorStorage
,
234 This
->ownerProperty
);
238 This
->bigBlockChain
= BlockChainStream_Construct(
239 This
->parentStorage
->ancestorStorage
,
241 This
->ownerProperty
);
248 * This method is part of the ISequentialStream interface.
250 * It reads a block of information from the stream at the current
251 * position. It then moves the current position at the end of the
254 * See the documentation of ISequentialStream for more info.
256 static HRESULT WINAPI
StgStreamImpl_Read(
258 void* pv
, /* [length_is][size_is][out] */
260 ULONG
* pcbRead
) /* [out] */
262 StgStreamImpl
* const This
=(StgStreamImpl
*)iface
;
264 ULONG bytesReadBuffer
;
265 ULONG bytesToReadFromBuffer
;
268 TRACE("(%p, %p, %d, %p)\n",
269 iface
, pv
, cb
, pcbRead
);
271 if (!This
->parentStorage
)
273 WARN("storage reverted\n");
274 return STG_E_REVERTED
;
278 * If the caller is not interested in the number of bytes read,
279 * we use another buffer to avoid "if" statements in the code.
282 pcbRead
= &bytesReadBuffer
;
285 * Using the known size of the stream, calculate the number of bytes
286 * to read from the block chain
288 bytesToReadFromBuffer
= min( This
->streamSize
.u
.LowPart
- This
->currentPosition
.u
.LowPart
, cb
);
291 * Depending on the type of chain that was opened when the stream was constructed,
292 * we delegate the work to the method that reads the block chains.
294 if (This
->smallBlockChain
!=0)
296 res
= SmallBlockChainStream_ReadAt(This
->smallBlockChain
,
297 This
->currentPosition
,
298 bytesToReadFromBuffer
,
303 else if (This
->bigBlockChain
!=0)
305 res
= BlockChainStream_ReadAt(This
->bigBlockChain
,
306 This
->currentPosition
,
307 bytesToReadFromBuffer
,
314 * Small and big block chains are both NULL. This case will happen
315 * when a stream starts with BLOCK_END_OF_CHAIN and has size zero.
326 * We should always be able to read the proper amount of data from the
329 assert(bytesToReadFromBuffer
== *pcbRead
);
332 * Advance the pointer for the number of positions read.
334 This
->currentPosition
.u
.LowPart
+= *pcbRead
;
338 TRACE("<-- %08x\n", res
);
343 * This method is part of the ISequentialStream interface.
345 * It writes a block of information to the stream at the current
346 * position. It then moves the current position at the end of the
347 * written block. If the stream is too small to fit the block,
348 * the stream is grown to fit.
350 * See the documentation of ISequentialStream for more info.
352 static HRESULT WINAPI
StgStreamImpl_Write(
354 const void* pv
, /* [size_is][in] */
356 ULONG
* pcbWritten
) /* [out] */
358 StgStreamImpl
* const This
=(StgStreamImpl
*)iface
;
360 ULARGE_INTEGER newSize
;
361 ULONG bytesWritten
= 0;
364 TRACE("(%p, %p, %d, %p)\n",
365 iface
, pv
, cb
, pcbWritten
);
368 * Do we have permission to write to this stream?
370 switch(STGM_ACCESS_MODE(This
->grfMode
))
376 WARN("access denied by flags: 0x%x\n", STGM_ACCESS_MODE(This
->grfMode
));
377 return STG_E_ACCESSDENIED
;
381 return STG_E_INVALIDPOINTER
;
383 if (!This
->parentStorage
)
385 WARN("storage reverted\n");
386 return STG_E_REVERTED
;
390 * If the caller is not interested in the number of bytes written,
391 * we use another buffer to avoid "if" statements in the code.
394 pcbWritten
= &bytesWritten
;
397 * Initialize the out parameter
403 TRACE("<-- S_OK, written 0\n");
408 newSize
.u
.HighPart
= 0;
409 newSize
.u
.LowPart
= This
->currentPosition
.u
.LowPart
+ cb
;
413 * Verify if we need to grow the stream
415 if (newSize
.u
.LowPart
> This
->streamSize
.u
.LowPart
)
418 res
= IStream_SetSize(iface
, newSize
);
424 * Depending on the type of chain that was opened when the stream was constructed,
425 * we delegate the work to the method that readwrites to the block chains.
427 if (This
->smallBlockChain
!=0)
429 res
= SmallBlockChainStream_WriteAt(This
->smallBlockChain
,
430 This
->currentPosition
,
436 else if (This
->bigBlockChain
!=0)
438 res
= BlockChainStream_WriteAt(This
->bigBlockChain
,
439 This
->currentPosition
,
446 /* this should never happen because the IStream_SetSize call above will
447 * make sure a big or small block chain is created */
453 * Advance the position pointer for the number of positions written.
455 This
->currentPosition
.u
.LowPart
+= *pcbWritten
;
457 TRACE("<-- S_OK, written %u\n", *pcbWritten
);
462 * This method is part of the IStream interface.
464 * It will move the current stream pointer according to the parameters
467 * See the documentation of IStream for more info.
469 static HRESULT WINAPI
StgStreamImpl_Seek(
471 LARGE_INTEGER dlibMove
, /* [in] */
472 DWORD dwOrigin
, /* [in] */
473 ULARGE_INTEGER
* plibNewPosition
) /* [out] */
475 StgStreamImpl
* const This
=(StgStreamImpl
*)iface
;
477 ULARGE_INTEGER newPosition
;
479 TRACE("(%p, %d, %d, %p)\n",
480 iface
, dlibMove
.u
.LowPart
, dwOrigin
, plibNewPosition
);
483 * fail if the stream has no parent (as does windows)
486 if (!This
->parentStorage
)
487 return STG_E_REVERTED
;
490 * The caller is allowed to pass in NULL as the new position return value.
491 * If it happens, we assign it to a dynamic variable to avoid special cases
494 if (plibNewPosition
== 0)
496 plibNewPosition
= &newPosition
;
500 * The file pointer is moved depending on the given "function"
505 case STREAM_SEEK_SET
:
506 plibNewPosition
->u
.HighPart
= 0;
507 plibNewPosition
->u
.LowPart
= 0;
509 case STREAM_SEEK_CUR
:
510 *plibNewPosition
= This
->currentPosition
;
512 case STREAM_SEEK_END
:
513 *plibNewPosition
= This
->streamSize
;
516 return STG_E_INVALIDFUNCTION
;
519 plibNewPosition
->QuadPart
= RtlLargeIntegerAdd( plibNewPosition
->QuadPart
, dlibMove
.QuadPart
);
522 * tell the caller what we calculated
524 This
->currentPosition
= *plibNewPosition
;
530 * This method is part of the IStream interface.
532 * It will change the size of a stream.
534 * TODO: Switch from small blocks to big blocks and vice versa.
536 * See the documentation of IStream for more info.
538 static HRESULT WINAPI
StgStreamImpl_SetSize(
540 ULARGE_INTEGER libNewSize
) /* [in] */
542 StgStreamImpl
* const This
=(StgStreamImpl
*)iface
;
544 StgProperty curProperty
;
547 TRACE("(%p, %d)\n", iface
, libNewSize
.u
.LowPart
);
549 if(!This
->parentStorage
)
550 return STG_E_REVERTED
;
555 if (libNewSize
.u
.HighPart
!= 0)
556 return STG_E_INVALIDFUNCTION
;
559 * Do we have permission?
561 if (!(This
->grfMode
& (STGM_WRITE
| STGM_READWRITE
)))
562 return STG_E_ACCESSDENIED
;
564 if (This
->streamSize
.u
.LowPart
== libNewSize
.u
.LowPart
)
568 * This will happen if we're creating a stream
570 if ((This
->smallBlockChain
== 0) && (This
->bigBlockChain
== 0))
572 if (libNewSize
.u
.LowPart
< LIMIT_TO_USE_SMALL_BLOCK
)
574 This
->smallBlockChain
= SmallBlockChainStream_Construct(
575 This
->parentStorage
->ancestorStorage
,
576 This
->ownerProperty
);
580 This
->bigBlockChain
= BlockChainStream_Construct(
581 This
->parentStorage
->ancestorStorage
,
583 This
->ownerProperty
);
588 * Read this stream's property to see if it's small blocks or big blocks
590 Success
= StorageImpl_ReadProperty(This
->parentStorage
->ancestorStorage
,
594 * Determine if we have to switch from small to big blocks or vice versa
596 if ( (This
->smallBlockChain
!=0) &&
597 (curProperty
.size
.u
.LowPart
< LIMIT_TO_USE_SMALL_BLOCK
) )
599 if (libNewSize
.u
.LowPart
>= LIMIT_TO_USE_SMALL_BLOCK
)
602 * Transform the small block chain into a big block chain
604 This
->bigBlockChain
= Storage32Impl_SmallBlocksToBigBlocks(
605 This
->parentStorage
->ancestorStorage
,
606 &This
->smallBlockChain
);
610 if (This
->smallBlockChain
!=0)
612 Success
= SmallBlockChainStream_SetSize(This
->smallBlockChain
, libNewSize
);
616 Success
= BlockChainStream_SetSize(This
->bigBlockChain
, libNewSize
);
620 * Write the new information about this stream to the property
622 Success
= StorageImpl_ReadProperty(This
->parentStorage
->ancestorStorage
,
626 curProperty
.size
.u
.HighPart
= libNewSize
.u
.HighPart
;
627 curProperty
.size
.u
.LowPart
= libNewSize
.u
.LowPart
;
631 StorageImpl_WriteProperty(This
->parentStorage
->ancestorStorage
,
636 This
->streamSize
= libNewSize
;
642 * This method is part of the IStream interface.
644 * It will copy the 'cb' Bytes to 'pstm' IStream.
646 * See the documentation of IStream for more info.
648 static HRESULT WINAPI
StgStreamImpl_CopyTo(
650 IStream
* pstm
, /* [unique][in] */
651 ULARGE_INTEGER cb
, /* [in] */
652 ULARGE_INTEGER
* pcbRead
, /* [out] */
653 ULARGE_INTEGER
* pcbWritten
) /* [out] */
655 StgStreamImpl
* const This
=(StgStreamImpl
*)iface
;
658 ULONG bytesRead
, bytesWritten
, copySize
;
659 ULARGE_INTEGER totalBytesRead
;
660 ULARGE_INTEGER totalBytesWritten
;
662 TRACE("(%p, %p, %d, %p, %p)\n",
663 iface
, pstm
, cb
.u
.LowPart
, pcbRead
, pcbWritten
);
669 if (!This
->parentStorage
)
670 return STG_E_REVERTED
;
673 return STG_E_INVALIDPOINTER
;
675 totalBytesRead
.u
.LowPart
= totalBytesRead
.u
.HighPart
= 0;
676 totalBytesWritten
.u
.LowPart
= totalBytesWritten
.u
.HighPart
= 0;
679 * use stack to store data temporarily
680 * there is surely a more performant way of doing it, for now this basic
681 * implementation will do the job
683 while ( cb
.u
.LowPart
> 0 )
685 if ( cb
.u
.LowPart
>= 128 )
688 copySize
= cb
.u
.LowPart
;
690 IStream_Read(iface
, tmpBuffer
, copySize
, &bytesRead
);
692 totalBytesRead
.u
.LowPart
+= bytesRead
;
694 IStream_Write(pstm
, tmpBuffer
, bytesRead
, &bytesWritten
);
696 totalBytesWritten
.u
.LowPart
+= bytesWritten
;
699 * Check that read & write operations were successful
701 if (bytesRead
!= bytesWritten
)
703 hr
= STG_E_MEDIUMFULL
;
707 if (bytesRead
!=copySize
)
710 cb
.u
.LowPart
-= bytesRead
;
714 * Update number of bytes read and written
718 pcbRead
->u
.LowPart
= totalBytesRead
.u
.LowPart
;
719 pcbRead
->u
.HighPart
= totalBytesRead
.u
.HighPart
;
724 pcbWritten
->u
.LowPart
= totalBytesWritten
.u
.LowPart
;
725 pcbWritten
->u
.HighPart
= totalBytesWritten
.u
.HighPart
;
731 * This method is part of the IStream interface.
733 * For streams contained in structured storages, this method
734 * does nothing. This is what the documentation tells us.
736 * See the documentation of IStream for more info.
738 static HRESULT WINAPI
StgStreamImpl_Commit(
740 DWORD grfCommitFlags
) /* [in] */
742 StgStreamImpl
* const This
=(StgStreamImpl
*)iface
;
744 if (!This
->parentStorage
)
745 return STG_E_REVERTED
;
751 * This method is part of the IStream interface.
753 * For streams contained in structured storages, this method
754 * does nothing. This is what the documentation tells us.
756 * See the documentation of IStream for more info.
758 static HRESULT WINAPI
StgStreamImpl_Revert(
764 static HRESULT WINAPI
StgStreamImpl_LockRegion(
766 ULARGE_INTEGER libOffset
, /* [in] */
767 ULARGE_INTEGER cb
, /* [in] */
768 DWORD dwLockType
) /* [in] */
770 StgStreamImpl
* const This
=(StgStreamImpl
*)iface
;
772 if (!This
->parentStorage
)
773 return STG_E_REVERTED
;
775 FIXME("not implemented!\n");
779 static HRESULT WINAPI
StgStreamImpl_UnlockRegion(
781 ULARGE_INTEGER libOffset
, /* [in] */
782 ULARGE_INTEGER cb
, /* [in] */
783 DWORD dwLockType
) /* [in] */
785 StgStreamImpl
* const This
=(StgStreamImpl
*)iface
;
787 if (!This
->parentStorage
)
788 return STG_E_REVERTED
;
790 FIXME("not implemented!\n");
795 * This method is part of the IStream interface.
797 * This method returns information about the current
800 * See the documentation of IStream for more info.
802 static HRESULT WINAPI
StgStreamImpl_Stat(
804 STATSTG
* pstatstg
, /* [out] */
805 DWORD grfStatFlag
) /* [in] */
807 StgStreamImpl
* const This
=(StgStreamImpl
*)iface
;
809 StgProperty curProperty
;
812 TRACE("%p %p %d\n", This
, pstatstg
, grfStatFlag
);
815 * if stream has no parent, return STG_E_REVERTED
818 if (!This
->parentStorage
)
819 return STG_E_REVERTED
;
822 * Read the information from the property.
824 readSuccessful
= StorageImpl_ReadProperty(This
->parentStorage
->ancestorStorage
,
830 StorageUtl_CopyPropertyToSTATSTG(pstatstg
,
834 pstatstg
->grfMode
= This
->grfMode
;
843 * This method is part of the IStream interface.
845 * This method returns a clone of the interface that allows for
846 * another seek pointer
848 * See the documentation of IStream for more info.
850 * I am not totally sure what I am doing here but I presume that this
851 * should be basically as simple as creating a new stream with the same
852 * parent etc and positioning its seek cursor.
854 static HRESULT WINAPI
StgStreamImpl_Clone(
856 IStream
** ppstm
) /* [out] */
858 StgStreamImpl
* const This
=(StgStreamImpl
*)iface
;
860 StgStreamImpl
* new_stream
;
861 LARGE_INTEGER seek_pos
;
863 TRACE("%p %p\n", This
, ppstm
);
869 if (!This
->parentStorage
)
870 return STG_E_REVERTED
;
873 return STG_E_INVALIDPOINTER
;
875 new_stream
= StgStreamImpl_Construct (This
->parentStorage
, This
->grfMode
, This
->ownerProperty
);
878 return STG_E_INSUFFICIENTMEMORY
; /* Currently the only reason for new_stream=0 */
880 *ppstm
= (IStream
*) new_stream
;
881 seek_pos
.QuadPart
= This
->currentPosition
.QuadPart
;
883 hres
=StgStreamImpl_Seek (*ppstm
, seek_pos
, STREAM_SEEK_SET
, NULL
);
885 assert (SUCCEEDED(hres
));
891 * Virtual function table for the StgStreamImpl class.
893 static const IStreamVtbl StgStreamImpl_Vtbl
=
895 StgStreamImpl_QueryInterface
,
896 StgStreamImpl_AddRef
,
897 StgStreamImpl_Release
,
901 StgStreamImpl_SetSize
,
902 StgStreamImpl_CopyTo
,
903 StgStreamImpl_Commit
,
904 StgStreamImpl_Revert
,
905 StgStreamImpl_LockRegion
,
906 StgStreamImpl_UnlockRegion
,
911 /******************************************************************************
912 ** StgStreamImpl implementation
916 * This is the constructor for the StgStreamImpl class.
919 * parentStorage - Pointer to the storage that contains the stream to open
920 * ownerProperty - Index of the property that points to this stream.
922 StgStreamImpl
* StgStreamImpl_Construct(
923 StorageBaseImpl
* parentStorage
,
927 StgStreamImpl
* newStream
;
929 newStream
= HeapAlloc(GetProcessHeap(), 0, sizeof(StgStreamImpl
));
934 * Set-up the virtual function table and reference count.
936 newStream
->lpVtbl
= &StgStreamImpl_Vtbl
;
939 newStream
->parentStorage
= parentStorage
;
942 * We want to nail-down the reference to the storage in case the
943 * stream out-lives the storage in the client application.
945 * -- IStorage_AddRef((IStorage*)newStream->parentStorage);
947 * No, don't do this. Some apps call IStorage_Release without
948 * calling IStream_Release first. If we grab a reference the
949 * file is not closed, and the app fails when it tries to
950 * reopen the file (Easy-PC, for example)
953 newStream
->grfMode
= grfMode
;
954 newStream
->ownerProperty
= ownerProperty
;
957 * Start the stream at the beginning.
959 newStream
->currentPosition
.u
.HighPart
= 0;
960 newStream
->currentPosition
.u
.LowPart
= 0;
963 * Initialize the rest of the data.
965 newStream
->streamSize
.u
.HighPart
= 0;
966 newStream
->streamSize
.u
.LowPart
= 0;
967 newStream
->bigBlockChain
= 0;
968 newStream
->smallBlockChain
= 0;
971 * Read the size from the property and determine if the blocks forming
972 * this stream are large or small.
974 StgStreamImpl_OpenBlockChain(newStream
);