/*

* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Container store content manager implementation.

*

*/

// ========

// INCLUDES

// ========

#include <bautils.h>

#include <s32mem.h>

#include <e32math.h>

#include "ContainerStoreContentManager.h"

#include "ContainerStoreUtils.h"

#include "ContainerStoreEncryption.h"

#include "ContainerStoreDefs.h"

#include "messagestoreutils.h"

// =========

// CONSTANTS

// =========

// The heap buffer size for read operations.

const TUint KReadBufferSize = 4096;

// The heap buffer size for write operations.

const TUint KWriteBufferSize = 4096;

//cmail

// The heap buffer size for non-encrypted operations.

// must be less than or equal to KReadBufferSize and KWriteBufferSize

const TUint KNormalBlockSize = 4096;

//~cmail

// The minimum data size passed into and out of the encryption/decryption functions.  This is also

// the pad length.  This constant will be adjusted to an even multiple of the block size returned

// by the encryption functionality.

const TUint KMinimumBlockSize = 128;

#define KFILE_MODE_READ  (EFileRead | EFileShareAny)

#define KFILE_MODE_WRITE (EFileWrite | EFileShareAny)

// 82187 - Need to exclude the vommit code from the search

_LIT( KSmartForwardTag, ":::" );

_LIT( KSmartForwardTagNoAttach, "::::" );

// =============

// LOCAL CLASSES

// =============

class CBufferedReader : public CBase

    {

    public:

        static CBufferedReader* NewLC( RFile& aFile, TInt aBufferSize, TInt aBlockSize );

        virtual ~CBufferedReader();

        TPtrC8 NextBlockL();

        // NextBlockL should be called, and the data consumed, before AtEofL is called.

        TBool AtEofL();

    private:

        CBufferedReader( RFile& aFile, TInt aBlockSize );

        void ConstructL( TInt aBufferSize );

        void ReadMoreDataL();

        RFile&     iFile;

        const TInt iBlockSize;

        TInt       iBufferSize;

        TInt       iBufferPosition;

        RBuf8      iBuffer;        

    }; // end class CBufferedReader

class CBufferedWriter : public CBase

    {

    public:

        static CBufferedWriter* NewLC( RFile& aFile, TInt aBufferSize, TInt aBlockSize );

        virtual ~CBufferedWriter();

        TPtr8 NextBlockBufferL();

        void TruncateLastBlockL( TInt aTruncationAmount );

        void FlushL();

    private:

        CBufferedWriter( RFile& aFile, TInt aBlockSize );

        void ConstructL( TInt aBlocksToBuffer );

        RFile&     iFile;

        const TInt iBlockSize;

        RBuf8      iBuffer;        

    }; // end class CBufferedWriter

// ======================

// METHOD IMPLEMENTATIONS

// ======================

// ==========================================================================

// FUNCTION: NewL

// ==========================================================================

CContainerStoreContentManager* CContainerStoreContentManager::NewL( CContainerStoreUtils&      aUtils,

                                                                    CContainerStoreEncryption& aEncryption )

    {

    CContainerStoreContentManager* self = new(ELeave) CContainerStoreContentManager( aUtils, aEncryption );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    } // end NewL

// ==========================================================================

// FUNCTION: Constructor

// ==========================================================================

CContainerStoreContentManager::CContainerStoreContentManager( CContainerStoreUtils&      aUtils,

                                                              CContainerStoreEncryption& aEncryption ) :

    iUtils( aUtils ),

    iEncryption( aEncryption ),

    iFs( aUtils.FileSystem() )

    {

    __LOG_CONSTRUCT( "msg", "CContainerStoreContentManager" )

    _LIT( KFormatString, "%ST1" );    

    iTemporaryFilename.Format( KFormatString, &iUtils.PrivatePath() );

    _LIT( KEncryptDecryptTempFileFormatString, "%ST2" );    

    iEncryptDecryptTempFilename.Format( KEncryptDecryptTempFileFormatString, &iUtils.PrivatePath() );

    } // end constructor

// ==========================================================================

// FUNCTION: ConstructL

// ==========================================================================

void CContainerStoreContentManager::ConstructL()    

    {

    CleanupTemporaryFile();

    CreateContentSubdirectoriesL();

    } // end ConstructL

// ==========================================================================

// FUNCTION: Destructor

// ==========================================================================

CContainerStoreContentManager::~CContainerStoreContentManager()

    {

    __LOG_DESTRUCT

    } // end destructor

// ==========================================================================

// FUNCTION: CleanupTemporaryFile

// ==========================================================================

void CContainerStoreContentManager::WipeContentFiles( RFs& aFs )

    {

    TFileName privatePath;

    TFileName directoryNameWithWildcard;

    aFs.PrivatePath( privatePath );

    for( TInt i = 0; i < KNumberOfContentSubdirectories; i++ )

        {

        _LIT( KFormatString, "%SC%i\\*" );

        directoryNameWithWildcard.Format( KFormatString, &privatePath, i );    

        BaflUtils::DeleteFile( aFs, directoryNameWithWildcard );

        } // end for        

    }

// ==========================================================================

// FUNCTION: CleanupTemporaryFile

// ==========================================================================

void CContainerStoreContentManager::CleanupTemporaryFile()

    {

	BaflUtils::DeleteFile( iUtils.FileSystem(), iTemporaryFilename );    

    } // end CleanupTemporaryFile

// ==========================================================================

// FUNCTION: CreateContentSubdirectoriesL

// ==========================================================================

void CContainerStoreContentManager::CreateContentSubdirectoriesL()

    {

    TFileName directoryName;

    for( TInt i = 0; i < KNumberOfContentSubdirectories; i++ )

        {

        _LIT( KFormatString, "%SC%i\\" );

        directoryName.Format( KFormatString, &iUtils.PrivatePath(), i );    

        BaflUtils::EnsurePathExistsL( iUtils.FileSystem(), directoryName );

        } // end for        

    } // end CreateContentSubdirectoriesL

// ==========================================================================

// FUNCTION: UpdateBlockSizeL

// ==========================================================================

void CContainerStoreContentManager::UpdateBlockSizeL( TBool isEncrypted )

    {

    TInt actualBlockSize = 0;

    if ( isEncrypted )

        {

        actualBlockSize = iEncryption.BlockSizeL();

        if( actualBlockSize < KMinimumBlockSize )

            {

            // The minimum block size is already a multiple of the actual block size.

            iBlockSize = KMinimumBlockSize;

            }

        else

            {

            // Round up to the next multiple of the block size.

            iBlockSize = KMinimumBlockSize + actualBlockSize - (KMinimumBlockSize % actualBlockSize);

            } // end if

        }

    else

        {

        iBlockSize = KNormalBlockSize;

        }

    } // end UpdateBlockSizeL

// ==========================================================================

// FUNCTION: ContentLengthL

// ==========================================================================

TUint CContainerStoreContentManager::ContentLengthL( TContainerId aId, TBool aIsEncrypted )

    {

    TUint returnValue = 0;

	TFileName contentFilename;	

	ContentFilename( aId, contentFilename );

    // Open the content file.

	RFile file;

	TInt result = file.Open( iFs, contentFilename, KFILE_MODE_READ );

    if( result == KErrNone )

        {  

        CleanupClosePushL( file );

    	TInt fileSize;

    	User::LeaveIfError( file.Size( fileSize ) );

        if ( !aIsEncrypted )

            {

            returnValue = fileSize;

            }

        else

            {

            UpdateBlockSizeL( aIsEncrypted );

            RBuf8 encryptedBuffer;

            encryptedBuffer.CreateL( iBlockSize );

            CleanupClosePushL( encryptedBuffer );

            RBuf8 plaintextBuffer;

            plaintextBuffer.CreateL( iBlockSize );

            CleanupClosePushL( plaintextBuffer );

        	// Read the last block.

        	TInt seekPosition = fileSize - iBlockSize;

            User::LeaveIfError( file.Seek( ESeekCurrent, seekPosition ) ); 

            User::LeaveIfError( file.Read( encryptedBuffer, iBlockSize ) );

        	// Decrypt the last block.

        	iEncryption.DecryptL( encryptedBuffer, plaintextBuffer );

        	iEncryption.RemovePaddingL( plaintextBuffer );

            // The content length is the file size minus the number of pad bytes in the final block.    	    

            returnValue = fileSize - iBlockSize + plaintextBuffer.Size();

            CleanupStack::PopAndDestroy( &plaintextBuffer );        

            CleanupStack::PopAndDestroy( &encryptedBuffer );        

            }

        CleanupStack::PopAndDestroy( &file );        

        }

    // If no content file exists then treat it as content length 0.

    else if( result != KErrNotFound )

        {

        User::Leave( result );

        } // end if

    return returnValue;

    } // end ContentLengthL

// ==========================================================================

// FUNCTION: CopyContentL

// ==========================================================================

void CContainerStoreContentManager::CopyContentL( TContainerId aOldId, TContainerId aNewId )

	{

	iEncryption.CheckForAuthenticationL();

	TFileName oldContentFilename;	

	ContentFilename( aOldId, oldContentFilename );

	RFile file;

	TInt result = file.Open( iFs, oldContentFilename, KFILE_MODE_READ );

	if( result == KErrNone )

	    {

    	User::LeaveIfError( file.Size( fileSize ) );

    	iUtils.LeaveIfLowDiskSpaceL( fileSize );

    	TFileName newContentFilename;	

    	ContentFilename( aNewId, newContentFilename );

        // Just copy the content file.  No encryption/decryption is required.

        User::LeaveIfError( BaflUtils::CopyFile( iFs, oldContentFilename, newContentFilename ) );        

        iCopiedContentFiles.AppendL( aNewId );

	    }

    // It is valid not to have a content file, so don't leave in that case.

    else if( result != KErrNotFound )

        {

        User::Leave( result );        

        } // end if

	} // end CopyContentL

// ==========================================================================

// FUNCTION: EncryptAndWriteNextBlockL

// ==========================================================================

TBool CContainerStoreContentManager::EncryptAndWriteNextBlockL( CBufferedWriter& aBufferedWriter, 

                                                                const TDesC8&    aPlaintextBlock )

    {

    __LOG_ENTER_SUPPRESS( "EncryptAndWriteNextBlockL" )

    TBool lastBlock = EFalse;

    TPtr8 nextBlock = aBufferedWriter.NextBlockBufferL();    

    if( aPlaintextBlock.Length() == iBlockSize )

        {    

        iEncryption.EncryptL( aPlaintextBlock, nextBlock );

        }

    else

        {

        __LOG_WRITE_INFO( "writing last block" )

        lastBlock = ETrue;

        // Add PKCS5-stype padding to pad to the block size.

        RBuf8 paddedBuffer;

        paddedBuffer.CreateL( iBlockSize );

        CleanupClosePushL( paddedBuffer );

        paddedBuffer.Copy( aPlaintextBlock );

        iEncryption.AddPaddingL( paddedBuffer, iBlockSize );                       

        iEncryption.EncryptL( paddedBuffer, nextBlock );        

        CleanupStack::PopAndDestroy( &paddedBuffer );

        } // end if

    return lastBlock;        

    } // end EncryptAndWriteNextBlockL

// ==========================================================================

// FUNCTION: ReadNextBlockL

// ==========================================================================

TBool CContainerStoreContentManager::ReadNextBlockL( CBufferedReader& aReader,

                                                     TDes8&           aPlaintextBlock,

                                                     TBool            aIsContentEncrypted )

    {    

    TPtrC8 nextBlock = aReader.NextBlockL();

    if ( aIsContentEncrypted )

        {

        iEncryption.DecryptL( nextBlock, aPlaintextBlock );    

        }

    else

        {

        aPlaintextBlock.Copy( nextBlock );

        }

    // If this is the last block in the file then remove the pad bytes

    TBool done = aReader.AtEofL();

    if( done && aIsContentEncrypted )   

        {

        iEncryption.RemovePaddingL( aPlaintextBlock );

        } // end if

    return done;        

    } // end ReadNextBlockL

// ==========================================================================

// FUNCTION: ReplaceContentL

// ==========================================================================

void CContainerStoreContentManager::ReplaceContentL( TContainerId  aId, 

                                				     const TDesC8& aContent,

                                                     TBool         aIsContentEncrypted )

    {

    __LOG_ENTER( "ReplaceContentL" )

    if( aContent.Length() == 0 )

        {

        TRAP_IGNORE( RemoveContentL( aId ) );

        }

    else

        {                

        UpdateBlockSizeL( aIsContentEncrypted );

       	iUtils.LeaveIfLowDiskSpaceL( aContent.Length() + iBlockSize );  // worst case size

        // Open the temporary output file.

        RFile outFile;

        User::LeaveIfError( outFile.Replace( iFs, iTemporaryFilename, EFileWrite ) );

        CleanupClosePushL( outFile );

        TInt result   = KErrNone;            

        if ( aIsContentEncrypted )

            {

            CBufferedWriter* writer = CBufferedWriter::NewLC( outFile, KWriteBufferSize, iBlockSize );

            // Write content blocks to the file until there is no more content.  If the content is

            // exactly a multiple of the block size, then add one extra loop with zero length

            // content, to add the expected final pad characters.

            TInt position = 0;

            TBool done    = EFalse;    

            TInt writeLength = 0;

            while( !done && (result == KErrNone) )

                {

                writeLength = iBlockSize;

                if( writeLength > aContent.Length() - position )

                    {

                    writeLength = aContent.Length() - position;

                    } // end if

                TRAP( result, done = EncryptAndWriteNextBlockL( *writer, aContent.Mid( position, writeLength ) ) );

                position += writeLength;

                } // end while

            writer->FlushL();

            CleanupStack::PopAndDestroy( writer );

            }

        else

            {

            //The content is not encrypted, just do a simple write

            outFile.Write( aContent );

            result = outFile.Flush();

            }

        CleanupStack::PopAndDestroy( &outFile );        

        // Commit the temporary file if the result is OK.  Otherwise, clean it up.

        CommitTemporaryFileL( result, aId );

        } // end if

    __LOG_EXIT        

    } // end ReplaceContentL

// ==========================================================================

// FUNCTION: ReplaceContentL

// ==========================================================================

void CContainerStoreContentManager::ReplaceContentL( TContainerId aId, 

							                         RFile&       aContentFile,

                                                     TBool        aEncryptContent )

    {

    __LOG_ENTER( "ReplaceContentL" )

	TInt fileSize;

	User::LeaveIfError( aContentFile.Size( fileSize ) );

    TInt  result   = KErrNone;

    if( fileSize == 0 )

        {

        TRAP_IGNORE( RemoveContentL( aId ) );

        }

    else

        {                	

        UpdateBlockSizeL( aEncryptContent );

       	iUtils.LeaveIfLowDiskSpaceL( fileSize + iBlockSize );  // worst case size

        RFile outFile;

        User::LeaveIfError( outFile.Replace( iFs, iTemporaryFilename, EFileWrite ) );

        CleanupClosePushL( outFile );

        CBufferedReader* reader = CBufferedReader::NewLC( aContentFile, KReadBufferSize, iBlockSize );

        if ( aEncryptContent )

            {

            CBufferedWriter* writer = CBufferedWriter::NewLC( outFile, KWriteBufferSize, iBlockSize );

            TBool done     = EFalse;

            // Write content to the file until there is no more content.  If the content is

            // exactly a multiple of the block size, then add one extra loop with zero length

            // content, to add the expected final pad characters.