/*

* Copyright (c) 2007-2008 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:  Skin server's active data owner in backup/restore.

*

*/

#include <f32file.h>

#include "aknssrvactivebackupdataclient.h"

#include "AknsSrvUtils.h"

#include "AknsDebug.h"

// Maximum size of header info.

const TUint KMaxHeaderSize = 256;

// number of bytes to read from file per block

const TUint KCheckSumBlockSize = 128;

// Default size of restore/backup stream size in bytes.

const TUint KArbitraryNumber=1024;

// 8 bytes

const TUint K8Bytes = 8;

// 16 bytes

const TUint K16Bytes = 16;

// Length of extension (including preceding dot).

const TInt KExtensionLength = 4;

_LIT( KSkinRootDir,":\\resource\\skins\\" );

// ======== MEMBER FUNCTIONS ========

// Skin files are backed up in the following format.

// filename contains drive and path in addition to filename.

// <checksum><filesize><filenamelen><filename>

// ---------------------------------------------------------------------------

// Symbian constructor.

// ---------------------------------------------------------------------------

//

CAknsSrvActiveBackupDataClient* CAknsSrvActiveBackupDataClient::NewL( RFs& aFsSession )

    {

    AKNS_TRACE_DEBUG("CAknsSrvActiveBackupDataClient::NewL" );

    CAknsSrvActiveBackupDataClient* self =

        new( ELeave ) CAknsSrvActiveBackupDataClient( aFsSession );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------------------------

// Destructor

// ---------------------------------------------------------------------------

//

CAknsSrvActiveBackupDataClient::~CAknsSrvActiveBackupDataClient()

    {

    AKNS_TRACE_DEBUG("CAknsSrvActiveBackupDataClient::destructor" );

    iFileArray.Reset();

    iFileArray.Close();

    iFile.Close();

    delete iBuffer;

    }

// ---------------------------------------------------------------------------

// Prepare for backup and restore ( no actions).

// ---------------------------------------------------------------------------

//

void CAknsSrvActiveBackupDataClient::PrepareForBURL( TInt /*aBackupStateValue*/ )

    {

    AKNS_TRACE_DEBUG("CAknsSrvActiveBackupDataClient::PrepareForBURL" );

    }

// ---------------------------------------------------------------------------

// Inform that all data has been backed up or restored.

// ---------------------------------------------------------------------------

//

void CAknsSrvActiveBackupDataClient::AllSnapshotsSuppliedL()

    {

    AKNS_TRACE_DEBUG("CAknsSrvActiveBackupDataClient::AllSnapshotsSuppliedL" );

    // Finalize and cleanup.

    return;

    }

// ---------------------------------------------------------------------------

// Not supported.

// ---------------------------------------------------------------------------

//

void CAknsSrvActiveBackupDataClient::ReceiveSnapshotDataL(

    TDriveNumber /*aDrive*/, TDesC8& /*aBuffer*/, TBool /*aLastSection*/)

    {

    AKNS_TRACE_DEBUG("CAknsSrvActiveBackupDataClient::ReceiveSnapshotDataL" );

    User::Leave( KErrNotSupported );

    }

// ---------------------------------------------------------------------------

// Make a guess about data size.

// ---------------------------------------------------------------------------

//

TUint CAknsSrvActiveBackupDataClient::GetExpectedDataSize(

    TDriveNumber /*aDrive*/)

    {

    AKNS_TRACE_DEBUG("CAknsSrvActiveBackupDataClient::GetExpectedDataSize" );

    // we have no idea at this point - we even don't know what is to be

    // backed up yet

    return KArbitraryNumber;

    }

// ---------------------------------------------------------------------------

// Not supported.

// ---------------------------------------------------------------------------

//

void CAknsSrvActiveBackupDataClient::GetSnapshotDataL(

    TDriveNumber /*aDrive*/, TPtr8& /*aBuffer*/, TBool& /*aFinished*/)

    {

    AKNS_TRACE_DEBUG("CAknsSrvActiveBackupDataClient::GetSnapshotDataL" );

    User::Leave( KErrNotSupported );

    }

// ---------------------------------------------------------------------------

// Initialize for backup - collect to-be-backed-up-files.

// ---------------------------------------------------------------------------

//

void CAknsSrvActiveBackupDataClient::InitialiseGetBackupDataL(

    TDriveNumber aDrive)

    {

    AKNS_TRACE_DEBUG("CAknsSrvActiveBackupDataClient::InitialiseGetBackupDataL" );

    DoInitialiseGetBackupDataL( aDrive );

    }

// ---------------------------------------------------------------------------

// Run state machine for backup. Each file is opened and streamed to the

// BUR engine.

// ---------------------------------------------------------------------------

//

void CAknsSrvActiveBackupDataClient::GetBackupDataSectionL(

    TPtr8& aBuffer, TBool& aFinished)

    {

    AKNS_TRACE_DEBUG("CAknsSrvActiveBackupDataClient::GetBackupDataSectionL" );

    // Make sure that the buffer is empty and starts from the beginning

    aBuffer.SetLength(0);

    // don't assume they set it to false

    aFinished = EFalse;

    // any files to backup

    if( iFileArray.Count() == 0 )

        {

        // nothing to backup - just return the finished flag

        aFinished = ETrue;

        // clear the list and stop.

        iFileArray.Reset();

        AKNS_TRACE_DEBUG("CAknsSrvActiveBackupDataClient::GetBackupDataSectionL no files" );

        return;

        }

    // run the state machine

    while( ETrue )

        {

        switch( iBackupState )

            {

            // open a file for processing

            case EBackupNoFileOpen:

                {

                AKNS_TRACE_DEBUG1("CAknsSrvActiveBackupDataClient::GetBackupDataSectionL state %d", iBackupState );

                if( iFileIndex >= iFileArray.Count() )

                    {

                    // all files have been processed - send the finished flag

                    aFinished = ETrue;

                    // clear the list and stop.

                    iFileArray.Reset();

                    AKNS_TRACE_DEBUG("CAknsSrvActiveBackupDataClient::GetBackupDataSectionL all processed" );

                    return;

                    }

                // open file to send

                TInt rc=iFile.Open( iFsSession,

                                    iFileArray[iFileIndex].FullName(),

                                    ( EFileRead | EFileShareExclusive | EFileStream ) );

                if( rc != KErrNone )

                    {

                    // there's nothing we can do if we can't open the file

                    // so we just skip it

                    AKNS_TRACE_DEBUG("CAknsSrvActiveBackupDataClient::GetBackupDataSectionL skip file" );

                    ++iFileIndex;

                    break;

                    }

                iBackupState = EBackupOpenNothingSent;

                break;

                }

            // nothing sent (so far) for this file - send the header info

            case EBackupOpenNothingSent:

                {

                AKNS_TRACE_DEBUG1("CAknsSrvActiveBackupDataClient::GetBackupDataSectionL state %d", iBackupState );

                TInt fileSize;

                TInt retValue = iFile.Size( fileSize );

                if( retValue != KErrNone || fileSize == 0 )

                    {

                    // empty or unreadable - skip this file

                    iBackupState = EBackupEndOfFile;

                    AKNS_TRACE_DEBUG("CAknsSrvActiveBackupDataClient::GetBackupDataSectionL skip file2" );

                    break;

                    }

                // build the header - this is an instance member because it

                // has to persist over multiple calls to this method

                TPtr headerPtr = iBuffer->Des();

                // get the checksum - only grab last 4 bytes - enough to be satisfied that

                // the backup and restore worked ok

                TUint64 checksum = CheckSumL( iFile ) & 0xffffffff;

                // build the header - note NOT AppendFormat(); wipes out previous content.

                // <no of files><checksum><filesize><filenamelen><filename>

                headerPtr.Format(_L("%8x%8lx%8x%8x"),

                    iFileArray.Count(),

                    checksum,

                    fileSize,

                    iFileArray[iFileIndex].FullName().Length());

                headerPtr.Append( iFileArray[iFileIndex].FullName() );

                // we need it to look like an 8bit buffer

                TPtr8 headerPtr8(

                    (TUint8*)headerPtr.Ptr(),

                    headerPtr.Size(),

                    headerPtr.Size() );

                // Check how much room is left in the buffer.

                // it starts out empty when we get it from the BUE

                TInt available = aBuffer.MaxSize() - aBuffer.Size();

                // Check is there enough room for the whole header.

                TBool enoughRoom = headerPtr8.Size() < available;

                // append the header to the buffer (only till it's full)

                aBuffer.Append(

                    headerPtr8.Ptr(),

                    enoughRoom ? headerPtr8.Size() : available) ;

                // decide what needs to happen next

                // if complete then we need data, otherwise we need to put

                // the rest of the header in the next chunk

                if( enoughRoom )

                    {

                    iBackupState = EBackupOpenAllHeaderSent;

                    }

                else

                    {

                    // we need to keep track of how much of the header has

                    // been sent so that we only send the reminder on the next

                    // iteration

                    iHeaderSent = available;

                    iBackupState = EBackupOpenPartHeaderSent;

                    }

                // if the buffer's full we need to return control to the backup engine

                // Because the finishedFlag is not set, the BUE will process this

                // chunk and then ask for another

                if( aBuffer.Size() == aBuffer.MaxSize() )

                    {

                    return;

                    }

                break;

                }

            // need to send the rest of the header

            case EBackupOpenPartHeaderSent:

                {

                AKNS_TRACE_DEBUG1("CAknsSrvActiveBackupDataClient::GetBackupDataSectionL state %d", iBackupState );

                // get back the header - this is already loaded with the necessary info

                // from the previous state we were in

                TPtr headerPtr = iBuffer->Des();

                // we need it to look like an 8bit buffer

                TPtr8 headerPtr8(

                    (TUint8*)headerPtr.Ptr(),

                    headerPtr.Size(),

                    headerPtr.Size() );

                // Check how many bytes have we yet to send.

                TInt bytesRemaining = headerPtr.Size() - iHeaderSent;

                // Check how much room in the buffer.

                TInt available = aBuffer.MaxSize() - aBuffer.Size();

                // enough, if not send as much as we can

                TBool enoughRoom = bytesRemaining < available;

                aBuffer.Append(

                    headerPtr8.Ptr() + iHeaderSent,

                    enoughRoom ? bytesRemaining : available );

                if( enoughRoom )

                    {

                    iHeaderSent = 0; // ready for next header

                    iBackupState = EBackupOpenAllHeaderSent;

                    }

                else

                    {

                    iHeaderSent += available; // ready to do round again

                    // state remains as EBackupOpenPartHeaderSent

                    }

                // if the buffer's full we need to return control to the backup engine

                // Because the finishedFlag is not set, the BUE will process this

                // chunk and then ask for another

                if( aBuffer.Size() == aBuffer.MaxSize() )

                    {

                    return;

                    }

                break;

                }

            // need to send some data

            case EBackupOpenAllHeaderSent:

                {

                AKNS_TRACE_DEBUG1("CAknsSrvActiveBackupDataClient::GetBackupDataSectionL state %d", iBackupState );

                // how many bytes can we send

                TInt available = aBuffer.MaxSize() - aBuffer.Size();

                // create a buffer for this data (plus one for PtrZ)

                HBufC8* transferBuffer = HBufC8::NewLC( available + 1 );

                TPtr8 bufferToSend = transferBuffer->Des();

                // get the data

                User::LeaveIfError( iFile.Read( bufferToSend, available ) );

                // Check how much did we actually read.

                TInt bytesRead = bufferToSend.Size();

                // EOF

                if( bytesRead == 0 )

                    {

                    CleanupStack::PopAndDestroy( transferBuffer );

                    iBackupState = EBackupEndOfFile;

                    break;

                    }

                // add it to the aBuffer

                aBuffer.Append( bufferToSend.PtrZ(), bytesRead );

                // tidy up

                CleanupStack::PopAndDestroy( transferBuffer );

                // if the buffer's full we need to return control to the backup engine

                if( aBuffer.Size() == aBuffer.MaxSize() )

                    {

                    return;

                    }

                break;

                }

            // At the end of the current file.

            case EBackupEndOfFile:

                {

                AKNS_TRACE_DEBUG1("CAknsSrvActiveBackupDataClient::GetBackupDataSectionL state %d", iBackupState );

                // how many bytes can we send

                if ( aBuffer.Size() != 0 )

                    {

                    TInt available = aBuffer.MaxSize() - aBuffer.Size();

                    // pad the end of the buffer with NULL.

                    HBufC8* transferBuffer = HBufC8::NewLC( available + 1 );

                    TPtr8 bufferToSend = transferBuffer->Des();

                    bufferToSend.FillZ();

                    aBuffer.Append( bufferToSend.PtrZ(), available );

                    CleanupStack::PopAndDestroy( transferBuffer );

                    if( aBuffer.Size() != aBuffer.MaxSize() )

                        {

                        // Sanity check

                        User::Leave( KErrGeneral );

                        }

                    }

                // Close file and move on to next file.

                iFile.Close();

                ++iFileIndex;

                // Start all over again.

                iBackupState = EBackupNoFileOpen;

                break;

                }

            default:

                {

                // not reachable

                return;

                }

            }

        }

    }

// ---------------------------------------------------------------------------

// Initialize restore.

// ---------------------------------------------------------------------------

//

void CAknsSrvActiveBackupDataClient::InitialiseRestoreBaseDataL(

    TDriveNumber /*aDrive*/ )

    {

    AKNS_TRACE_DEBUG("CAknsSrvActiveBackupDataClient::InitialiseRestoreBaseDataL" );

    // this is the first state of the restore state machine

    iRestoreState = ERestoreNumberOfFiles;

    // to keep track in the state machine whether any data was actually sent

    iDataRestored = EFalse;

    iFilesRestored = 0;

    }

// ---------------------------------------------------------------------------

// Run state machine for restore. Receive stream from BUR engine and turn it

// to file(s).

// ---------------------------------------------------------------------------

//

void CAknsSrvActiveBackupDataClient::RestoreBaseDataSectionL(

    TDesC8& aBuffer, TBool aFinished )

    {

    AKNS_TRACE_DEBUG("CAknsSrvActiveBackupDataClient::RestoreBaseDataSectionL" );

    // convert the buffer - this is KMaxHeaderSize=256

    TInt bufferIndex;

    TPtr bufPtr = iBuffer->Des();

    // used to walk the buffer

    // got a new buffer - because each time this method is called, we have a

    // fresh chunk of data

    bufferIndex = 0;

    // to mark when the state machine is through

    TBool done = EFalse;

    // check whether this is an empty restore

    if( aFinished && !iDataRestored )

        {

        // we have to do this and not rely on aFinishedFlag alone, because

        // if aFinished is used, we'll process the last state of the machine

        // which does tidyup, except that if there was no data, no tidyup should

        // be done

        AKNS_TRACE_DEBUG("CAknsSrvActiveBackupDataClient::RestoreBaseDataSectionL empty restore" );

        return;

        }

    // run the machine

    do

        {

        // Check how many bytes are there available in the buffer for processing.

        TInt bytesAvailable = aBuffer.Length() - bufferIndex;

        // the reason why we are testing finishedFlag is because we must

        // make sure we re-enter the machine to do the tidyup

        if( bytesAvailable <= 0 && !aFinished )

            {

            // ran out of data in the chunk

            // so we return and wait for more data to arrive

            return;

            }

        if( aFinished &&

            iRestoreState != ERestoreComplete &&

            iRestoreState != ERestoreExpectMoreData )

            {

            // ran out of data early

            // will be ERestoreComplete if data not aligned on 128

            // will be ERestoreExpectMoreData if data aligned on 128

            User::Leave( KErrCorrupt );

            }

        // yep there was some data in the chunk if we got here

        if( bytesAvailable > 0 )

            {

            iDataRestored = ETrue;

            }

        switch( iRestoreState )

            {

            case ERestoreNumberOfFiles: // 16 bytes

                {

                TInt bytesToGet = bytesAvailable >= K16Bytes ? K16Bytes : bytesAvailable;

                TPtrC8 ptr8 = aBuffer.Mid( bufferIndex, bytesToGet );

                bufferIndex += bytesToGet;

                // convert to 16 bit

                TPtr ptr16(

                    (TUint16*) ptr8.Ptr(),

                    bytesToGet >> 1,

                    bytesToGet >> 1 );

                // stick it in the heap buffer

                bufPtr.Zero();

                bufPtr.Append( ptr16 );

                if( bufPtr.Length() == K8Bytes )

                    {

                    // If file size is now read, read file name size next.

                    iRestoreState = ERestoreExpectChecksum;

                    }

                break;

                }

            case ERestoreExpectChecksum:

                {

                // first of all, process the heap buffer to extract the checksum

                TLex lex( bufPtr );

                lex.SkipSpace();

                lex.Val( iNumberofFiles, EHex );

                AKNS_TRACE_DEBUG1("CAknsSrvActiveBackupDataClient::RestoreBaseDataSectionL state %d", iRestoreState );

                // if we have 16 bytes, get them;

                // otherwise get what we have available.

                // if not complete then we need to go around again to get the rest

                TInt bytesToGet = bytesAvailable >= K16Bytes ? K16Bytes : bytesAvailable;

                // extract the bytes

                TPtrC8 ptr8 = aBuffer.Mid( bufferIndex, bytesToGet );

                bufferIndex += bytesToGet;

                // convert to 16 bit

                TPtr ptr16(

                    (TUint16*) ptr8.Ptr(),

                    bytesToGet >> 1,

                    bytesToGet >> 1 );

                // stick it in the heap buffer

                bufPtr.Zero();

                bufPtr.Append( ptr16 );

                if( bufPtr.Length() == 8 )

                    {