1*a3872823SAndrew Rist /**************************************************************
2cdf0e10cSrcweir *
3*a3872823SAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
4*a3872823SAndrew Rist * or more contributor license agreements. See the NOTICE file
5*a3872823SAndrew Rist * distributed with this work for additional information
6*a3872823SAndrew Rist * regarding copyright ownership. The ASF licenses this file
7*a3872823SAndrew Rist * to you under the Apache License, Version 2.0 (the
8*a3872823SAndrew Rist * "License"); you may not use this file except in compliance
9*a3872823SAndrew Rist * with the License. You may obtain a copy of the License at
10*a3872823SAndrew Rist *
11*a3872823SAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
12*a3872823SAndrew Rist *
13*a3872823SAndrew Rist * Unless required by applicable law or agreed to in writing,
14*a3872823SAndrew Rist * software distributed under the License is distributed on an
15*a3872823SAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*a3872823SAndrew Rist * KIND, either express or implied. See the License for the
17*a3872823SAndrew Rist * specific language governing permissions and limitations
18*a3872823SAndrew Rist * under the License.
19*a3872823SAndrew Rist *
20*a3872823SAndrew Rist *************************************************************/
21*a3872823SAndrew Rist
22*a3872823SAndrew Rist
23cdf0e10cSrcweir
24cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove
25cdf0e10cSrcweir #include "precompiled_package.hxx"
26cdf0e10cSrcweir
27cdf0e10cSrcweir #include <com/sun/star/packages/zip/ZipConstants.hpp>
28cdf0e10cSrcweir #include <com/sun/star/packages/zip/ZipIOException.hpp>
29cdf0e10cSrcweir #include <com/sun/star/xml/crypto/CipherID.hpp>
30cdf0e10cSrcweir
31cdf0e10cSrcweir #include <XUnbufferedStream.hxx>
32cdf0e10cSrcweir #include <EncryptionData.hxx>
33cdf0e10cSrcweir #include <PackageConstants.hxx>
34cdf0e10cSrcweir #include <ZipFile.hxx>
35cdf0e10cSrcweir #include <EncryptedDataHeader.hxx>
36cdf0e10cSrcweir #include <algorithm>
37cdf0e10cSrcweir #include <string.h>
38cdf0e10cSrcweir
39cdf0e10cSrcweir #include <osl/mutex.hxx>
40cdf0e10cSrcweir
41cdf0e10cSrcweir #if 0
42cdf0e10cSrcweir // for debugging purposes here
43cdf0e10cSrcweir #include <com/sun/star/ucb/XSimpleFileAccess.hpp>
44cdf0e10cSrcweir #include <comphelper/processfactory.hxx>
45cdf0e10cSrcweir using namespace ::com::sun::star;
46cdf0e10cSrcweir #endif
47cdf0e10cSrcweir
48cdf0e10cSrcweir using namespace ::com::sun::star;
49cdf0e10cSrcweir using namespace com::sun::star::packages::zip::ZipConstants;
50cdf0e10cSrcweir using namespace com::sun::star::io;
51cdf0e10cSrcweir using namespace com::sun::star::uno;
52cdf0e10cSrcweir using com::sun::star::lang::IllegalArgumentException;
53cdf0e10cSrcweir using com::sun::star::packages::zip::ZipIOException;
54cdf0e10cSrcweir using ::rtl::OUString;
55cdf0e10cSrcweir
XUnbufferedStream(const uno::Reference<lang::XMultiServiceFactory> & xFactory,SotMutexHolderRef aMutexHolder,ZipEntry & rEntry,Reference<XInputStream> xNewZipStream,const::rtl::Reference<EncryptionData> & rData,sal_Int8 nStreamMode,sal_Bool bIsEncrypted,const::rtl::OUString & aMediaType,sal_Bool bRecoveryMode)56cdf0e10cSrcweir XUnbufferedStream::XUnbufferedStream(
57cdf0e10cSrcweir const uno::Reference< lang::XMultiServiceFactory >& xFactory,
58cdf0e10cSrcweir SotMutexHolderRef aMutexHolder,
59cdf0e10cSrcweir ZipEntry & rEntry,
60cdf0e10cSrcweir Reference < XInputStream > xNewZipStream,
61cdf0e10cSrcweir const ::rtl::Reference< EncryptionData >& rData,
62cdf0e10cSrcweir sal_Int8 nStreamMode,
63cdf0e10cSrcweir sal_Bool bIsEncrypted,
64cdf0e10cSrcweir const ::rtl::OUString& aMediaType,
65cdf0e10cSrcweir sal_Bool bRecoveryMode )
66cdf0e10cSrcweir : maMutexHolder( aMutexHolder.Is() ? aMutexHolder : SotMutexHolderRef( new SotMutexHolder ) )
67cdf0e10cSrcweir , mxZipStream ( xNewZipStream )
68cdf0e10cSrcweir , mxZipSeek ( xNewZipStream, UNO_QUERY )
69cdf0e10cSrcweir , maEntry ( rEntry )
70cdf0e10cSrcweir , mxData ( rData )
71cdf0e10cSrcweir , mnBlockSize( 1 )
72cdf0e10cSrcweir , maInflater ( sal_True )
73cdf0e10cSrcweir , mbRawStream ( nStreamMode == UNBUFF_STREAM_RAW || nStreamMode == UNBUFF_STREAM_WRAPPEDRAW )
74cdf0e10cSrcweir , mbWrappedRaw ( nStreamMode == UNBUFF_STREAM_WRAPPEDRAW )
75cdf0e10cSrcweir , mbFinished ( sal_False )
76cdf0e10cSrcweir , mnHeaderToRead ( 0 )
77cdf0e10cSrcweir , mnZipCurrent ( 0 )
78cdf0e10cSrcweir , mnZipEnd ( 0 )
79cdf0e10cSrcweir , mnZipSize ( 0 )
80cdf0e10cSrcweir , mnMyCurrent ( 0 )
81cdf0e10cSrcweir , mbCheckCRC( !bRecoveryMode )
82cdf0e10cSrcweir {
83cdf0e10cSrcweir mnZipCurrent = maEntry.nOffset;
84cdf0e10cSrcweir if ( mbRawStream )
85cdf0e10cSrcweir {
86cdf0e10cSrcweir mnZipSize = maEntry.nMethod == DEFLATED ? maEntry.nCompressedSize : maEntry.nSize;
87cdf0e10cSrcweir mnZipEnd = maEntry.nOffset + mnZipSize;
88cdf0e10cSrcweir }
89cdf0e10cSrcweir else
90cdf0e10cSrcweir {
91cdf0e10cSrcweir mnZipSize = maEntry.nSize;
92cdf0e10cSrcweir mnZipEnd = maEntry.nMethod == DEFLATED ? maEntry.nOffset + maEntry.nCompressedSize : maEntry.nOffset + maEntry.nSize;
93cdf0e10cSrcweir }
94cdf0e10cSrcweir sal_Bool bHaveEncryptData = ( rData.is() && rData->m_aSalt.getLength() && rData->m_aInitVector.getLength() && rData->m_nIterationCount != 0 ) ? sal_True : sal_False;
95cdf0e10cSrcweir sal_Bool bMustDecrypt = ( nStreamMode == UNBUFF_STREAM_DATA && bHaveEncryptData && bIsEncrypted ) ? sal_True : sal_False;
96cdf0e10cSrcweir
97cdf0e10cSrcweir if ( bMustDecrypt )
98cdf0e10cSrcweir {
99cdf0e10cSrcweir m_xCipherContext = ZipFile::StaticGetCipher( xFactory, rData, false );
100cdf0e10cSrcweir mnBlockSize = ( rData->m_nEncAlg == xml::crypto::CipherID::AES_CBC_W3C_PADDING ? 16 : 1 );
101cdf0e10cSrcweir }
102cdf0e10cSrcweir
103cdf0e10cSrcweir if ( bHaveEncryptData && mbWrappedRaw && bIsEncrypted )
104cdf0e10cSrcweir {
105cdf0e10cSrcweir // if we have the data needed to decrypt it, but didn't want it decrypted (or
106cdf0e10cSrcweir // we couldn't decrypt it due to wrong password), then we prepend this
107cdf0e10cSrcweir // data to the stream
108cdf0e10cSrcweir
109cdf0e10cSrcweir // Make a buffer big enough to hold both the header and the data itself
110cdf0e10cSrcweir maHeader.realloc ( n_ConstHeaderSize +
111cdf0e10cSrcweir rData->m_aInitVector.getLength() +
112cdf0e10cSrcweir rData->m_aSalt.getLength() +
113cdf0e10cSrcweir rData->m_aDigest.getLength() +
114cdf0e10cSrcweir aMediaType.getLength() * sizeof( sal_Unicode ) );
115cdf0e10cSrcweir sal_Int8 * pHeader = maHeader.getArray();
116cdf0e10cSrcweir ZipFile::StaticFillHeader( rData, rEntry.nSize, aMediaType, pHeader );
117cdf0e10cSrcweir mnHeaderToRead = static_cast < sal_Int16 > ( maHeader.getLength() );
118cdf0e10cSrcweir }
119cdf0e10cSrcweir }
120cdf0e10cSrcweir
121cdf0e10cSrcweir // allows to read package raw stream
XUnbufferedStream(const uno::Reference<lang::XMultiServiceFactory> &,const Reference<XInputStream> & xRawStream,const::rtl::Reference<EncryptionData> & rData)122cdf0e10cSrcweir XUnbufferedStream::XUnbufferedStream(
123cdf0e10cSrcweir const uno::Reference< lang::XMultiServiceFactory >& /*xFactory*/,
124cdf0e10cSrcweir const Reference < XInputStream >& xRawStream,
125cdf0e10cSrcweir const ::rtl::Reference< EncryptionData >& rData )
126cdf0e10cSrcweir : maMutexHolder( new SotMutexHolder )
127cdf0e10cSrcweir , mxZipStream ( xRawStream )
128cdf0e10cSrcweir , mxZipSeek ( xRawStream, UNO_QUERY )
129cdf0e10cSrcweir , mxData ( rData )
130cdf0e10cSrcweir , mnBlockSize( 1 )
131cdf0e10cSrcweir , maInflater ( sal_True )
132cdf0e10cSrcweir , mbRawStream ( sal_False )
133cdf0e10cSrcweir , mbWrappedRaw ( sal_False )
134cdf0e10cSrcweir , mbFinished ( sal_False )
135cdf0e10cSrcweir , mnHeaderToRead ( 0 )
136cdf0e10cSrcweir , mnZipCurrent ( 0 )
137cdf0e10cSrcweir , mnZipEnd ( 0 )
138cdf0e10cSrcweir , mnZipSize ( 0 )
139cdf0e10cSrcweir , mnMyCurrent ( 0 )
140cdf0e10cSrcweir , mbCheckCRC( sal_False )
141cdf0e10cSrcweir {
142cdf0e10cSrcweir // for this scenario maEntry is not set !!!
143cdf0e10cSrcweir OSL_ENSURE( mxZipSeek.is(), "The stream must be seekable!\n" );
144cdf0e10cSrcweir
145cdf0e10cSrcweir // skip raw header, it must be already parsed to rData
146cdf0e10cSrcweir mnZipCurrent = n_ConstHeaderSize + rData->m_aInitVector.getLength() +
147cdf0e10cSrcweir rData->m_aSalt.getLength() + rData->m_aDigest.getLength();
148cdf0e10cSrcweir
149cdf0e10cSrcweir try {
150cdf0e10cSrcweir if ( mxZipSeek.is() )
151cdf0e10cSrcweir mnZipSize = mxZipSeek->getLength();
152cdf0e10cSrcweir } catch( Exception& )
153cdf0e10cSrcweir {
154cdf0e10cSrcweir // in case of problem the size will stay set to 0
155cdf0e10cSrcweir }
156cdf0e10cSrcweir
157cdf0e10cSrcweir mnZipEnd = mnZipCurrent + mnZipSize;
158cdf0e10cSrcweir
159cdf0e10cSrcweir // the raw data will not be decrypted, no need for the cipher
160cdf0e10cSrcweir // m_xCipherContext = ZipFile::StaticGetCipher( xFactory, rData, false );
161cdf0e10cSrcweir }
162cdf0e10cSrcweir
~XUnbufferedStream()163cdf0e10cSrcweir XUnbufferedStream::~XUnbufferedStream()
164cdf0e10cSrcweir {
165cdf0e10cSrcweir }
166cdf0e10cSrcweir
readBytes(Sequence<sal_Int8> & aData,sal_Int32 nBytesToRead)167cdf0e10cSrcweir sal_Int32 SAL_CALL XUnbufferedStream::readBytes( Sequence< sal_Int8 >& aData, sal_Int32 nBytesToRead )
168cdf0e10cSrcweir throw( NotConnectedException, BufferSizeExceededException, IOException, RuntimeException)
169cdf0e10cSrcweir {
170cdf0e10cSrcweir ::osl::MutexGuard aGuard( maMutexHolder->GetMutex() );
171cdf0e10cSrcweir
172cdf0e10cSrcweir sal_Int32 nRequestedBytes = nBytesToRead;
173cdf0e10cSrcweir OSL_ENSURE( !mnHeaderToRead || mbWrappedRaw, "Only encrypted raw stream can be provided with header!" );
174cdf0e10cSrcweir if ( mnMyCurrent + nRequestedBytes > mnZipSize + maHeader.getLength() )
175cdf0e10cSrcweir nRequestedBytes = static_cast < sal_Int32 > ( mnZipSize + maHeader.getLength() - mnMyCurrent );
176cdf0e10cSrcweir
177cdf0e10cSrcweir sal_Int32 nRead = 0, nLastRead = 0, nTotal = 0;
178cdf0e10cSrcweir aData.realloc ( nRequestedBytes );
179cdf0e10cSrcweir if ( nRequestedBytes )
180cdf0e10cSrcweir {
181cdf0e10cSrcweir if ( mbRawStream )
182cdf0e10cSrcweir {
183cdf0e10cSrcweir sal_Int64 nDiff = mnZipEnd - mnZipCurrent;
184cdf0e10cSrcweir
185cdf0e10cSrcweir if ( mbWrappedRaw && mnHeaderToRead )
186cdf0e10cSrcweir {
187cdf0e10cSrcweir sal_Int16 nHeadRead = static_cast< sal_Int16 >(( nRequestedBytes > mnHeaderToRead ?
188cdf0e10cSrcweir mnHeaderToRead : nRequestedBytes ));
189cdf0e10cSrcweir rtl_copyMemory ( aData.getArray(), maHeader.getConstArray() + maHeader.getLength() - mnHeaderToRead, nHeadRead );
190cdf0e10cSrcweir mnHeaderToRead = mnHeaderToRead - nHeadRead;
191cdf0e10cSrcweir
192cdf0e10cSrcweir if ( nHeadRead < nRequestedBytes )
193cdf0e10cSrcweir {
194cdf0e10cSrcweir sal_Int32 nToRead = nRequestedBytes - nHeadRead;
195cdf0e10cSrcweir nToRead = ( nDiff < nToRead ) ? sal::static_int_cast< sal_Int32 >( nDiff ) : nToRead;
196cdf0e10cSrcweir
197cdf0e10cSrcweir Sequence< sal_Int8 > aPureData( nToRead );
198cdf0e10cSrcweir mxZipSeek->seek ( mnZipCurrent );
199cdf0e10cSrcweir nRead = mxZipStream->readBytes ( aPureData, nToRead );
200cdf0e10cSrcweir mnZipCurrent += nRead;
201cdf0e10cSrcweir
202cdf0e10cSrcweir aPureData.realloc( nRead );
203cdf0e10cSrcweir if ( mbCheckCRC )
204cdf0e10cSrcweir maCRC.update( aPureData );
205cdf0e10cSrcweir
206cdf0e10cSrcweir aData.realloc( nHeadRead + nRead );
207cdf0e10cSrcweir
208cdf0e10cSrcweir sal_Int8* pPureBuffer = aPureData.getArray();
209cdf0e10cSrcweir sal_Int8* pBuffer = aData.getArray();
210cdf0e10cSrcweir for ( sal_Int32 nInd = 0; nInd < nRead; nInd++ )
211cdf0e10cSrcweir pBuffer[ nHeadRead + nInd ] = pPureBuffer[ nInd ];
212cdf0e10cSrcweir }
213cdf0e10cSrcweir
214cdf0e10cSrcweir nRead += nHeadRead;
215cdf0e10cSrcweir }
216cdf0e10cSrcweir else
217cdf0e10cSrcweir {
218cdf0e10cSrcweir mxZipSeek->seek ( mnZipCurrent );
219cdf0e10cSrcweir
220cdf0e10cSrcweir nRead = mxZipStream->readBytes (
221cdf0e10cSrcweir aData,
222cdf0e10cSrcweir static_cast < sal_Int32 > ( nDiff < nRequestedBytes ? nDiff : nRequestedBytes ) );
223cdf0e10cSrcweir
224cdf0e10cSrcweir mnZipCurrent += nRead;
225cdf0e10cSrcweir
226cdf0e10cSrcweir aData.realloc( nRead );
227cdf0e10cSrcweir if ( mbWrappedRaw && mbCheckCRC )
228cdf0e10cSrcweir maCRC.update( aData );
229cdf0e10cSrcweir }
230cdf0e10cSrcweir }
231cdf0e10cSrcweir else
232cdf0e10cSrcweir {
233cdf0e10cSrcweir while ( 0 == ( nLastRead = maInflater.doInflateSegment( aData, nRead, aData.getLength() - nRead ) ) ||
234cdf0e10cSrcweir ( nRead + nLastRead != nRequestedBytes && mnZipCurrent < mnZipEnd ) )
235cdf0e10cSrcweir {
236cdf0e10cSrcweir nRead += nLastRead;
237cdf0e10cSrcweir
238cdf0e10cSrcweir if ( nRead > nRequestedBytes )
239cdf0e10cSrcweir throw RuntimeException(
240cdf0e10cSrcweir OUString( RTL_CONSTASCII_USTRINGPARAM( "Should not be possible to read more then requested!" ) ),
241cdf0e10cSrcweir Reference< XInterface >() );
242cdf0e10cSrcweir
243cdf0e10cSrcweir if ( maInflater.finished() || maInflater.getLastInflateError() )
244cdf0e10cSrcweir throw ZipIOException( OUString( RTL_CONSTASCII_USTRINGPARAM( "The stream seems to be broken!" ) ),
245cdf0e10cSrcweir Reference< XInterface >() );
246cdf0e10cSrcweir
247cdf0e10cSrcweir if ( maInflater.needsDictionary() )
248cdf0e10cSrcweir throw ZipIOException( OUString( RTL_CONSTASCII_USTRINGPARAM( "Dictionaries are not supported!" ) ),
249cdf0e10cSrcweir Reference< XInterface >() );
250cdf0e10cSrcweir
251cdf0e10cSrcweir sal_Int32 nDiff = static_cast< sal_Int32 >( mnZipEnd - mnZipCurrent );
252cdf0e10cSrcweir if ( nDiff > 0 )
253cdf0e10cSrcweir {
254cdf0e10cSrcweir mxZipSeek->seek ( mnZipCurrent );
255cdf0e10cSrcweir
256cdf0e10cSrcweir sal_Int32 nToRead = std::max( nRequestedBytes, static_cast< sal_Int32 >( 8192 ) );
257cdf0e10cSrcweir if ( mnBlockSize > 1 )
258cdf0e10cSrcweir nToRead = nToRead + mnBlockSize - nToRead % mnBlockSize;
259cdf0e10cSrcweir nToRead = std::min( nDiff, nToRead );
260cdf0e10cSrcweir
261cdf0e10cSrcweir sal_Int32 nZipRead = mxZipStream->readBytes( maCompBuffer, nToRead );
262cdf0e10cSrcweir if ( nZipRead < nToRead )
263cdf0e10cSrcweir throw ZipIOException( OUString( RTL_CONSTASCII_USTRINGPARAM( "No expected data!" ) ),
264cdf0e10cSrcweir Reference< XInterface >() );
265cdf0e10cSrcweir
266cdf0e10cSrcweir mnZipCurrent += nZipRead;
267cdf0e10cSrcweir // maCompBuffer now has the data, check if we need to decrypt
268cdf0e10cSrcweir // before passing to the Inflater
269cdf0e10cSrcweir if ( m_xCipherContext.is() )
270cdf0e10cSrcweir {
271cdf0e10cSrcweir if ( mbCheckCRC )
272cdf0e10cSrcweir maCRC.update( maCompBuffer );
273cdf0e10cSrcweir
274cdf0e10cSrcweir maCompBuffer = m_xCipherContext->convertWithCipherContext( maCompBuffer );
275cdf0e10cSrcweir if ( mnZipCurrent == mnZipEnd )
276cdf0e10cSrcweir {
277cdf0e10cSrcweir uno::Sequence< sal_Int8 > aSuffix = m_xCipherContext->finalizeCipherContextAndDispose();
278cdf0e10cSrcweir if ( aSuffix.getLength() )
279cdf0e10cSrcweir {
280cdf0e10cSrcweir sal_Int32 nOldLen = maCompBuffer.getLength();
281cdf0e10cSrcweir maCompBuffer.realloc( nOldLen + aSuffix.getLength() );
282cdf0e10cSrcweir rtl_copyMemory( maCompBuffer.getArray() + nOldLen, aSuffix.getConstArray(), aSuffix.getLength() );
283cdf0e10cSrcweir }
284cdf0e10cSrcweir }
285cdf0e10cSrcweir }
286cdf0e10cSrcweir maInflater.setInput ( maCompBuffer );
287cdf0e10cSrcweir }
288cdf0e10cSrcweir else
289cdf0e10cSrcweir {
290cdf0e10cSrcweir throw ZipIOException( OUString( RTL_CONSTASCII_USTRINGPARAM( "The stream seems to be broken!" ) ),
291cdf0e10cSrcweir Reference< XInterface >() );
292cdf0e10cSrcweir }
293cdf0e10cSrcweir }
294cdf0e10cSrcweir }
295cdf0e10cSrcweir
296cdf0e10cSrcweir mnMyCurrent += nRead + nLastRead;
297cdf0e10cSrcweir nTotal = nRead + nLastRead;
298cdf0e10cSrcweir if ( nTotal < nRequestedBytes)
299cdf0e10cSrcweir aData.realloc ( nTotal );
300cdf0e10cSrcweir
301cdf0e10cSrcweir if ( mbCheckCRC && ( !mbRawStream || mbWrappedRaw ) )
302cdf0e10cSrcweir {
303cdf0e10cSrcweir if ( !m_xCipherContext.is() && !mbWrappedRaw )
304cdf0e10cSrcweir maCRC.update( aData );
305cdf0e10cSrcweir
306cdf0e10cSrcweir #if 0
307cdf0e10cSrcweir // for debugging purposes here
308cdf0e10cSrcweir if ( mbWrappedRaw )
309cdf0e10cSrcweir {
310cdf0e10cSrcweir if ( 0 )
311cdf0e10cSrcweir {
312cdf0e10cSrcweir uno::Reference< lang::XMultiServiceFactory > xFactory = comphelper::getProcessServiceFactory();
313cdf0e10cSrcweir uno::Reference< ucb::XSimpleFileAccess > xAccess( xFactory->createInstance( ::rtl::OUString::createFromAscii( "com.sun.star.ucb.SimpleFileAccess" ) ), uno::UNO_QUERY );
314cdf0e10cSrcweir uno::Reference< io::XOutputStream > xOut = xAccess->openFileWrite( ::rtl::OUString::createFromAscii( "file:///d:/777/Encrypted/picture" ) );
315cdf0e10cSrcweir xOut->writeBytes( aData );
316cdf0e10cSrcweir xOut->closeOutput();
317cdf0e10cSrcweir }
318cdf0e10cSrcweir }
319cdf0e10cSrcweir #endif
320cdf0e10cSrcweir
321cdf0e10cSrcweir if ( mnZipSize + maHeader.getLength() == mnMyCurrent && maCRC.getValue() != maEntry.nCrc )
322cdf0e10cSrcweir throw ZipIOException( OUString( RTL_CONSTASCII_USTRINGPARAM( "The stream seems to be broken!" ) ),
323cdf0e10cSrcweir Reference< XInterface >() );
324cdf0e10cSrcweir }
325cdf0e10cSrcweir }
326cdf0e10cSrcweir
327cdf0e10cSrcweir return nTotal;
328cdf0e10cSrcweir }
329cdf0e10cSrcweir
readSomeBytes(Sequence<sal_Int8> & aData,sal_Int32 nMaxBytesToRead)330cdf0e10cSrcweir sal_Int32 SAL_CALL XUnbufferedStream::readSomeBytes( Sequence< sal_Int8 >& aData, sal_Int32 nMaxBytesToRead )
331cdf0e10cSrcweir throw( NotConnectedException, BufferSizeExceededException, IOException, RuntimeException)
332cdf0e10cSrcweir {
333cdf0e10cSrcweir return readBytes ( aData, nMaxBytesToRead );
334cdf0e10cSrcweir }
skipBytes(sal_Int32 nBytesToSkip)335cdf0e10cSrcweir void SAL_CALL XUnbufferedStream::skipBytes( sal_Int32 nBytesToSkip )
336cdf0e10cSrcweir throw( NotConnectedException, BufferSizeExceededException, IOException, RuntimeException)
337cdf0e10cSrcweir {
338cdf0e10cSrcweir if ( nBytesToSkip )
339cdf0e10cSrcweir {
340cdf0e10cSrcweir Sequence < sal_Int8 > aSequence ( nBytesToSkip );
341cdf0e10cSrcweir readBytes ( aSequence, nBytesToSkip );
342cdf0e10cSrcweir }
343cdf0e10cSrcweir }
344cdf0e10cSrcweir
available()345cdf0e10cSrcweir sal_Int32 SAL_CALL XUnbufferedStream::available( )
346cdf0e10cSrcweir throw( NotConnectedException, IOException, RuntimeException)
347cdf0e10cSrcweir {
348cdf0e10cSrcweir return static_cast < sal_Int32 > ( mnZipSize - mnMyCurrent );
349cdf0e10cSrcweir }
350cdf0e10cSrcweir
closeInput()351cdf0e10cSrcweir void SAL_CALL XUnbufferedStream::closeInput( )
352cdf0e10cSrcweir throw( NotConnectedException, IOException, RuntimeException)
353cdf0e10cSrcweir {
354cdf0e10cSrcweir }
355cdf0e10cSrcweir /*
356cdf0e10cSrcweir void SAL_CALL XUnbufferedStream::seek( sal_Int64 location )
357cdf0e10cSrcweir throw( IllegalArgumentException, IOException, RuntimeException)
358cdf0e10cSrcweir {
359cdf0e10cSrcweir }
360cdf0e10cSrcweir sal_Int64 SAL_CALL XUnbufferedStream::getPosition( )
361cdf0e10cSrcweir throw(IOException, RuntimeException)
362cdf0e10cSrcweir {
363cdf0e10cSrcweir return mnMyCurrent;
364cdf0e10cSrcweir }
365cdf0e10cSrcweir sal_Int64 SAL_CALL XUnbufferedStream::getLength( )
366cdf0e10cSrcweir throw(IOException, RuntimeException)
367cdf0e10cSrcweir {
368cdf0e10cSrcweir return mnZipSize;
369cdf0e10cSrcweir }
370cdf0e10cSrcweir */
371