/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_package.hxx"

#include <com/sun/star/packages/zip/ZipConstants.hpp>
#include <com/sun/star/packages/zip/ZipIOException.hpp>
#include <com/sun/star/xml/crypto/CipherID.hpp>

#include <XUnbufferedStream.hxx>
#include <EncryptionData.hxx>
#include <PackageConstants.hxx>
#include <ZipFile.hxx>
#include <EncryptedDataHeader.hxx>
#include <algorithm>
#include <string.h>

#include <osl/mutex.hxx>

#if 0
// for debugging purposes here
#include <com/sun/star/ucb/XSimpleFileAccess.hpp>
#include <comphelper/processfactory.hxx>
using namespace ::com::sun::star;
#endif

using namespace ::com::sun::star;
using namespace com::sun::star::packages::zip::ZipConstants;
using namespace com::sun::star::io;
using namespace com::sun::star::uno;
using com::sun::star::lang::IllegalArgumentException;
using com::sun::star::packages::zip::ZipIOException;
using ::rtl::OUString;

XUnbufferedStream::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 )
: maMutexHolder( aMutexHolder.Is() ? aMutexHolder : SotMutexHolderRef( new SotMutexHolder ) )
, mxZipStream ( xNewZipStream )
, mxZipSeek ( xNewZipStream, UNO_QUERY )
, maEntry ( rEntry )
, mxData ( rData )
, mnBlockSize( 1 )
, maInflater ( sal_True )
, mbRawStream ( nStreamMode == UNBUFF_STREAM_RAW || nStreamMode == UNBUFF_STREAM_WRAPPEDRAW )
, mbWrappedRaw ( nStreamMode == UNBUFF_STREAM_WRAPPEDRAW )
, mbFinished ( sal_False )
, mnHeaderToRead ( 0 )
, mnZipCurrent ( 0 )
, mnZipEnd ( 0 )
, mnZipSize ( 0 )
, mnMyCurrent ( 0 )
, mbCheckCRC( !bRecoveryMode )
{
	mnZipCurrent = maEntry.nOffset;
	if ( mbRawStream )
	{
		mnZipSize = maEntry.nMethod == DEFLATED ? maEntry.nCompressedSize : maEntry.nSize;
		mnZipEnd = maEntry.nOffset + mnZipSize;
	}
	else
	{
		mnZipSize = maEntry.nSize;
		mnZipEnd = maEntry.nMethod == DEFLATED ? maEntry.nOffset + maEntry.nCompressedSize : maEntry.nOffset + maEntry.nSize;
	}
	sal_Bool bHaveEncryptData = ( rData.is() && rData->m_aSalt.getLength() && rData->m_aInitVector.getLength() && rData->m_nIterationCount != 0 ) ? sal_True : sal_False;
	sal_Bool bMustDecrypt = ( nStreamMode == UNBUFF_STREAM_DATA && bHaveEncryptData && bIsEncrypted ) ? sal_True : sal_False;
	
	if ( bMustDecrypt )
    {
		m_xCipherContext = ZipFile::StaticGetCipher( xFactory, rData, false );
        mnBlockSize = ( rData->m_nEncAlg == xml::crypto::CipherID::AES_CBC_W3C_PADDING ? 16 : 1 );
    }

	if ( bHaveEncryptData && mbWrappedRaw && bIsEncrypted )
	{
		// if we have the data needed to decrypt it, but didn't want it decrypted (or
		// we couldn't decrypt it due to wrong password), then we prepend this
		// data to the stream

		// Make a buffer big enough to hold both the header and the data itself
		maHeader.realloc  ( n_ConstHeaderSize +
							rData->m_aInitVector.getLength() + 
							rData->m_aSalt.getLength() + 
							rData->m_aDigest.getLength() +
							aMediaType.getLength() * sizeof( sal_Unicode ) );
		sal_Int8 * pHeader = maHeader.getArray();
		ZipFile::StaticFillHeader( rData, rEntry.nSize, aMediaType, pHeader );
		mnHeaderToRead = static_cast < sal_Int16 > ( maHeader.getLength() );
	}
}

// allows to read package raw stream
XUnbufferedStream::XUnbufferedStream(
                    const uno::Reference< lang::XMultiServiceFactory >& /*xFactory*/,
                    const Reference < XInputStream >& xRawStream,
					const ::rtl::Reference< EncryptionData >& rData )
: maMutexHolder( new SotMutexHolder )
, mxZipStream ( xRawStream )
, mxZipSeek ( xRawStream, UNO_QUERY )
, mxData ( rData )
, mnBlockSize( 1 )
, maInflater ( sal_True )
, mbRawStream ( sal_False )
, mbWrappedRaw ( sal_False )
, mbFinished ( sal_False )
, mnHeaderToRead ( 0 )
, mnZipCurrent ( 0 )
, mnZipEnd ( 0 )
, mnZipSize ( 0 )
, mnMyCurrent ( 0 )
, mbCheckCRC( sal_False )
{
	// for this scenario maEntry is not set !!!
	OSL_ENSURE( mxZipSeek.is(), "The stream must be seekable!\n" );

	// skip raw header, it must be already parsed to rData
	mnZipCurrent = n_ConstHeaderSize + rData->m_aInitVector.getLength() + 
							rData->m_aSalt.getLength() + rData->m_aDigest.getLength();

	try {
		if ( mxZipSeek.is() )
			mnZipSize = mxZipSeek->getLength();
	} catch( Exception& )
	{
		// in case of problem the size will stay set to 0
	}
	
	mnZipEnd = mnZipCurrent + mnZipSize;

    // the raw data will not be decrypted, no need for the cipher
    // m_xCipherContext = ZipFile::StaticGetCipher( xFactory, rData, false );
}

XUnbufferedStream::~XUnbufferedStream() 
{
}

sal_Int32 SAL_CALL XUnbufferedStream::readBytes( Sequence< sal_Int8 >& aData, sal_Int32 nBytesToRead ) 
		throw( NotConnectedException, BufferSizeExceededException, IOException, RuntimeException)
{
    ::osl::MutexGuard aGuard( maMutexHolder->GetMutex() );

	sal_Int32 nRequestedBytes = nBytesToRead;
	OSL_ENSURE( !mnHeaderToRead || mbWrappedRaw, "Only encrypted raw stream can be provided with header!" );
	if ( mnMyCurrent + nRequestedBytes > mnZipSize + maHeader.getLength() )
		nRequestedBytes = static_cast < sal_Int32 > ( mnZipSize + maHeader.getLength() - mnMyCurrent );

	sal_Int32 nRead = 0, nLastRead = 0, nTotal = 0;
	aData.realloc ( nRequestedBytes );
	if ( nRequestedBytes ) 
	{
		if ( mbRawStream )
		{
			sal_Int64 nDiff = mnZipEnd - mnZipCurrent;

			if ( mbWrappedRaw && mnHeaderToRead )
			{
				sal_Int16 nHeadRead = static_cast< sal_Int16 >(( nRequestedBytes > mnHeaderToRead ?
                                                                                 mnHeaderToRead : nRequestedBytes ));
				rtl_copyMemory ( aData.getArray(), maHeader.getConstArray() + maHeader.getLength() - mnHeaderToRead, nHeadRead );
				mnHeaderToRead = mnHeaderToRead - nHeadRead;

				if ( nHeadRead < nRequestedBytes )
				{
					sal_Int32 nToRead = nRequestedBytes - nHeadRead;
					nToRead = ( nDiff < nToRead ) ? sal::static_int_cast< sal_Int32 >( nDiff ) : nToRead;

					Sequence< sal_Int8 > aPureData( nToRead );
					mxZipSeek->seek ( mnZipCurrent );
					nRead = mxZipStream->readBytes ( aPureData, nToRead );
					mnZipCurrent += nRead;

					aPureData.realloc( nRead );
					if ( mbCheckCRC )
						maCRC.update( aPureData );

					aData.realloc( nHeadRead + nRead );

					sal_Int8* pPureBuffer = aPureData.getArray();
					sal_Int8* pBuffer = aData.getArray();
					for ( sal_Int32 nInd = 0; nInd < nRead; nInd++ )
						pBuffer[ nHeadRead + nInd ] = pPureBuffer[ nInd ];
				}

				nRead += nHeadRead;
			}
			else
			{
				mxZipSeek->seek ( mnZipCurrent );

				nRead = mxZipStream->readBytes ( 
										aData, 
										static_cast < sal_Int32 > ( nDiff < nRequestedBytes ? nDiff : nRequestedBytes ) );

				mnZipCurrent += nRead;

				aData.realloc( nRead );
				if ( mbWrappedRaw && mbCheckCRC )
					maCRC.update( aData );
			}
		}
		else
		{
			while ( 0 == ( nLastRead = maInflater.doInflateSegment( aData, nRead, aData.getLength() - nRead ) ) || 
				  ( nRead + nLastRead != nRequestedBytes && mnZipCurrent < mnZipEnd ) )
			{
				nRead += nLastRead;

				if ( nRead > nRequestedBytes )
					throw RuntimeException( 
						OUString( RTL_CONSTASCII_USTRINGPARAM( "Should not be possible to read more then requested!" ) ),
						Reference< XInterface >() );
					
				if ( maInflater.finished() || maInflater.getLastInflateError() )
					throw ZipIOException( OUString( RTL_CONSTASCII_USTRINGPARAM( "The stream seems to be broken!" ) ),
										Reference< XInterface >() );

				if ( maInflater.needsDictionary() )
					throw ZipIOException( OUString( RTL_CONSTASCII_USTRINGPARAM( "Dictionaries are not supported!" ) ),
										Reference< XInterface >() );

                sal_Int32 nDiff = static_cast< sal_Int32 >( mnZipEnd - mnZipCurrent );
                if ( nDiff > 0 )
                {
                    mxZipSeek->seek ( mnZipCurrent );

                    sal_Int32 nToRead = std::max( nRequestedBytes, static_cast< sal_Int32 >( 8192 ) );
                    if ( mnBlockSize > 1 )
                        nToRead = nToRead + mnBlockSize - nToRead % mnBlockSize;
                    nToRead = std::min( nDiff, nToRead );

                    sal_Int32 nZipRead = mxZipStream->readBytes( maCompBuffer, nToRead );
                    if ( nZipRead < nToRead )
                        throw ZipIOException( OUString( RTL_CONSTASCII_USTRINGPARAM( "No expected data!" ) ),
                                            Reference< XInterface >() );

                    mnZipCurrent += nZipRead;
                    // maCompBuffer now has the data, check if we need to decrypt
                    // before passing to the Inflater
                    if ( m_xCipherContext.is() )
                    {
                        if ( mbCheckCRC )
                            maCRC.update( maCompBuffer );

                        maCompBuffer = m_xCipherContext->convertWithCipherContext( maCompBuffer );
                        if ( mnZipCurrent == mnZipEnd )
                        {
                            uno::Sequence< sal_Int8 > aSuffix = m_xCipherContext->finalizeCipherContextAndDispose();
                            if ( aSuffix.getLength() )
                            {
                                sal_Int32 nOldLen = maCompBuffer.getLength();
                                maCompBuffer.realloc( nOldLen + aSuffix.getLength() );
                                rtl_copyMemory( maCompBuffer.getArray() + nOldLen, aSuffix.getConstArray(), aSuffix.getLength() );
                            }
                        }
                    }
                    maInflater.setInput ( maCompBuffer );
				}
				else
				{
					throw ZipIOException( OUString( RTL_CONSTASCII_USTRINGPARAM( "The stream seems to be broken!" ) ),
										Reference< XInterface >() );
				}
			}
		}

		mnMyCurrent += nRead + nLastRead;
		nTotal = nRead + nLastRead;
		if ( nTotal < nRequestedBytes)
			aData.realloc ( nTotal );

		if ( mbCheckCRC && ( !mbRawStream || mbWrappedRaw ) )
		{
			if ( !m_xCipherContext.is() && !mbWrappedRaw )
				maCRC.update( aData );

#if 0
			// for debugging purposes here
			if ( mbWrappedRaw )
			{
				if ( 0 )
				{
					uno::Reference< lang::XMultiServiceFactory > xFactory = comphelper::getProcessServiceFactory();
					uno::Reference< ucb::XSimpleFileAccess > xAccess( xFactory->createInstance( ::rtl::OUString::createFromAscii( "com.sun.star.ucb.SimpleFileAccess" ) ), uno::UNO_QUERY );
					uno::Reference< io::XOutputStream > xOut = xAccess->openFileWrite( ::rtl::OUString::createFromAscii( "file:///d:/777/Encrypted/picture" ) );
					xOut->writeBytes( aData );
					xOut->closeOutput();
				}
			}
#endif
			
			if ( mnZipSize + maHeader.getLength() == mnMyCurrent && maCRC.getValue() != maEntry.nCrc )
				throw ZipIOException( OUString( RTL_CONSTASCII_USTRINGPARAM( "The stream seems to be broken!" ) ),
									Reference< XInterface >() );
		}
	}
	
	return nTotal;
}

sal_Int32 SAL_CALL XUnbufferedStream::readSomeBytes( Sequence< sal_Int8 >& aData, sal_Int32 nMaxBytesToRead ) 
		throw( NotConnectedException, BufferSizeExceededException, IOException, RuntimeException)
{
	return readBytes ( aData, nMaxBytesToRead );
}
void SAL_CALL XUnbufferedStream::skipBytes( sal_Int32 nBytesToSkip ) 
		throw( NotConnectedException, BufferSizeExceededException, IOException, RuntimeException)
{
	if ( nBytesToSkip )
	{
		Sequence < sal_Int8 > aSequence ( nBytesToSkip );
		readBytes ( aSequence, nBytesToSkip );
	}
}

sal_Int32 SAL_CALL XUnbufferedStream::available(  ) 
		throw( NotConnectedException, IOException, RuntimeException)
{
	return static_cast < sal_Int32 > ( mnZipSize - mnMyCurrent );
}

void SAL_CALL XUnbufferedStream::closeInput(  ) 
		throw( NotConnectedException, IOException, RuntimeException)
{
}
/*
void SAL_CALL XUnbufferedStream::seek( sal_Int64 location ) 
		throw( IllegalArgumentException, IOException, RuntimeException)
{
}
sal_Int64 SAL_CALL XUnbufferedStream::getPosition(  ) 
		throw(IOException, RuntimeException)
{
	return mnMyCurrent;
}
sal_Int64 SAL_CALL XUnbufferedStream::getLength(  ) 
		throw(IOException, RuntimeException)
{
	return mnZipSize;
}
*/