package/source/zipapi/XFileStream.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: XFileStream.cxx,v $
  10  * $Revision: 1.9 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_package.hxx"
  33 #include <XFileStream.hxx>
  34 #include <EncryptionData.hxx>
  35 #include <com/sun/star/packages/zip/ZipConstants.hpp>
  36 #include <PackageConstants.hxx>
  37 #include <rtl/cipher.h>
  38 #include <ZipFile.hxx>
  39 #include <EncryptedDataHeader.hxx>
  40 #include <com/sun/star/io/XOutputStream.hpp>
  41
  42 using namespace com::sun::star::packages::zip::ZipConstants;
  43 using namespace com::sun::star::io;
  44 using namespace com::sun::star::uno;
  45 using com::sun::star::lang::IllegalArgumentException;
  46 using ::rtl::OUString;
  47
  48 XFileStream::XFileStream( ZipEntry & rEntry,
  49                            com::sun::star::uno::Reference < com::sun::star::io::XInputStream > xNewZipStream,
  50                            com::sun::star::uno::Reference < com::sun::star::io::XInputStream > xNewTempStream,
  51                            const vos::ORef < EncryptionData > &rData,
  52                            sal_Bool bNewRawStream,
  53                            sal_Bool bIsEncrypted )
  54 : maEntry ( rEntry )
  55 , mxData ( rData )
  56 , mbRawStream ( bNewRawStream )
  57 , mbFinished ( sal_False )
  58 , mxTempIn ( xNewTempStream )
  59 , mxTempSeek ( xNewTempStream, UNO_QUERY )
  60 , mxTempOut ( xNewTempStream, UNO_QUERY )
  61 , mxZipStream ( xNewZipStream )
  62 , mxZipSeek ( xNewZipStream, UNO_QUERY )
  63 , maInflater ( sal_True )
  64 , maCipher ( NULL )
  65 {
  66     mnZipCurrent = maEntry.nOffset;
  67     if (mbRawStream)
  68     {
  69         mnZipSize = maEntry.nMethod == DEFLATED ? maEntry.nCompressedSize : maEntry.nSize;
  70         mnZipEnd = maEntry.nOffset + mnZipSize;
  71     }
  72     else
  73     {
  74         mnZipSize = maEntry.nSize;
  75         mnZipEnd = maEntry.nMethod == DEFLATED ? maEntry.nOffset + maEntry.nCompressedSize : maEntry.nOffset + maEntry.nSize;
  76     }
  77
  78     if ( bIsEncrypted )
  79     {
  80         sal_Bool bHaveEncryptData = ( !rData.isEmpty() && rData->aSalt.getLength() && rData->aInitVector.getLength() && rData->nIterationCount != 0 ) ? sal_True : sal_False;
  81
  82         // if we have all the encrypted data, and want a raw stream, then prepend it to the stream, otherwise
  83         // make a cipher so we can decrypt it
  84         if ( bHaveEncryptData )
  85         {
  86             if ( !bNewRawStream )
  87                 ZipFile::StaticGetCipher ( rData, maCipher, sal_True );
  88             else
  89             {
  90                 // Put in the EncryptedDataHeader
  91                 Sequence < sal_Int8 > aEncryptedDataHeader ( n_ConstHeaderSize +
  92                                                              rData->aInitVector.getLength() +
  93                                                              rData->aSalt.getLength() +
  94                                                              rData->aDigest.getLength() );
  95                 sal_Int8 * pHeader = aEncryptedDataHeader.getArray();
  96                 ZipFile::StaticFillHeader ( rData, rEntry.nSize, pHeader );
  97                 mxTempOut->writeBytes ( aEncryptedDataHeader );
  98                 mnZipSize += mxTempSeek->getPosition();
  99                 mxTempSeek->seek ( 0 );
 100             }
 101         }
 102     }
 103 }
 104
 105 XFileStream::~XFileStream()
 106 {
 107     if ( maCipher )
 108         rtl_cipher_destroy ( maCipher );
 109 }
 110
 111 void XFileStream::fill( sal_Int64 nUntil)
 112 {
 113     sal_Int32 nRead;
 114     sal_Int64 nPosition = mxTempSeek->getPosition();
 115     mxTempSeek->seek ( mxTempSeek->getLength() );
 116     maBuffer.realloc ( n_ConstBufferSize );
 117
 118     while ( mxTempSeek->getLength() < nUntil )
 119     {
 120         if ( !mbRawStream )
 121         {
 122             while ( 0 == ( nRead = maInflater.doInflate( maBuffer ) ) )
 123             {
 124                 if ( maInflater.finished() || maInflater.needsDictionary() )
 125                 {
 126                     // some error handling ?
 127                     return;
 128                 }
 129
 130                 sal_Int64 nDiff = mnZipEnd - mnZipCurrent;
 131                 if ( nDiff > 0 )
 132                 {
 133                     mxZipSeek->seek ( mnZipCurrent );
 134                     nRead = mxZipStream->readBytes ( maCompBuffer, static_cast < sal_Int32 > ( nDiff < n_ConstBufferSize ? nDiff : n_ConstBufferSize ) );
 135                     mnZipCurrent += nRead;
 136                     // maCompBuffer now has the uncompressed data, check if we need to decrypt
 137                     // before passing to the Inflater
 138                     if ( maCipher )
 139                     {
 140                         Sequence < sal_Int8 > aCryptBuffer ( nRead );
 141                         rtlCipherError aResult = rtl_cipher_decode ( maCipher,
 142                                       maCompBuffer.getConstArray(),
 143                                       nRead,
 144                                       reinterpret_cast < sal_uInt8 * > (aCryptBuffer.getArray()),
 145                                       nRead);
 146                         OSL_ASSERT (aResult == rtl_Cipher_E_None);
 147                         maCompBuffer = aCryptBuffer; // Now it holds the decrypted data
 148
 149                     }
 150                     maInflater.setInput ( maCompBuffer );
 151                 }
 152                 else
 153                 {
 154                     // some error handling ?
 155                     return;
 156                 }
 157             }
 158         }
 159         else
 160         {
 161             sal_Int64 nDiff = mnZipEnd - mnZipCurrent;
 162             mxZipSeek->seek ( mnZipCurrent );
 163             nRead = mxZipStream->readBytes ( maBuffer, static_cast < sal_Int32 > ( nDiff < n_ConstBufferSize ? nDiff : n_ConstBufferSize ) );
 164             mnZipCurrent += nRead;
 165         }
 166         Sequence < sal_Int8 > aTmpBuffer ( maBuffer.getConstArray(), nRead );
 167         mxTempOut->writeBytes ( aTmpBuffer );
 168     }
 169     mxTempSeek->seek ( nPosition );
 170 }
 171
 172 sal_Int32 SAL_CALL XFileStream::readBytes( Sequence< sal_Int8 >& aData, sal_Int32 nBytesToRead )
 173         throw( NotConnectedException, BufferSizeExceededException, IOException, RuntimeException)
 174 {
 175     sal_Int64 nPosition = mxTempSeek->getPosition();
 176     if ( nPosition + nBytesToRead > mnZipSize )
 177         nBytesToRead = static_cast < sal_Int32 > ( mnZipSize - nPosition );
 178
 179     sal_Int64 nUntil = nBytesToRead + nPosition + n_ConstBufferSize;
 180     if (nUntil > mnZipSize )
 181         nUntil = mnZipSize;
 182     if ( nUntil > mxTempSeek->getLength() )
 183         fill ( nUntil );
 184     sal_Int32 nRead = mxTempIn->readBytes ( aData, nBytesToRead );
 185     return nRead;
 186 }
 187
 188 sal_Int32 SAL_CALL XFileStream::readSomeBytes( Sequence< sal_Int8 >& aData, sal_Int32 nMaxBytesToRead )
 189         throw( NotConnectedException, BufferSizeExceededException, IOException, RuntimeException)
 190 {
 191     return readBytes ( aData, nMaxBytesToRead );
 192 }
 193 void SAL_CALL XFileStream::skipBytes( sal_Int32 nBytesToSkip )
 194         throw( NotConnectedException, BufferSizeExceededException, IOException, RuntimeException)
 195 {
 196     seek ( mxTempSeek->getPosition() + nBytesToSkip );
 197 }
 198
 199 sal_Int32 SAL_CALL XFileStream::available(  )
 200         throw( NotConnectedException, IOException, RuntimeException)
 201 {
 202     return static_cast < sal_Int32 > ( mnZipSize - mxTempSeek->getPosition() );
 203 }
 204
 205 void SAL_CALL XFileStream::closeInput(  )
 206         throw( NotConnectedException, IOException, RuntimeException)
 207 {
 208 }
 209 void SAL_CALL XFileStream::seek( sal_Int64 location )
 210         throw( IllegalArgumentException, IOException, RuntimeException)
 211 {
 212     if ( location > mnZipSize || location < 0 )
 213         throw IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 1 );
 214     if ( location > mxTempSeek->getLength() )
 215     {
 216         sal_Int64 nUntil = location + n_ConstBufferSize > mnZipSize ? mnZipSize : location + n_ConstBufferSize;
 217         fill ( nUntil );
 218     }
 219     mxTempSeek->seek ( location );
 220 }
 221 sal_Int64 SAL_CALL XFileStream::getPosition(  )
 222         throw(IOException, RuntimeException)
 223 {
 224     return mxTempSeek->getPosition();
 225 }
 226 sal_Int64 SAL_CALL XFileStream::getLength(  )
 227         throw(IOException, RuntimeException)
 228 {
 229     return mnZipSize;
 230 }