/*

* Copyright (c) 2005 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:  Implementation of the Active Backup in DRM

*

*/

// INCLUDE FILES

#include <s32mem.h>

#include <sysutil.h>

#ifdef RD_MULTIPLE_DRIVE

#endif

#include "DRMBackup.h"

#include "RoapStorageClient.h"

/*

#include "flogger.h"

_LIT( KLogDir, "drm");

_LIT( KLogName, "backup.log");

*/

// EXTERNAL DATA STRUCTURES

// CONSTANTS

const TInt KDoBackup        =   0x00000001;

const TInt KRightsFileOpen  =   0x00000002;

const TInt KContextFileOpen =   0x00000004;

const TInt KRightsSizeRead  =   0x00000008;

const TInt KContextSizeRead =   0x00000010;

// MACROS

// LOCAL CONSTANTS AND MACROS

#ifdef RD_MULTIPLE_DRIVE

// Backup Directory

_LIT( KBackupDir, "%c:\\private\\101F51F2\\backup\\" );

#endif

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

LOCAL_C void CleanupData( TAny* aPtr );

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

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

// CleanupData

// Used to catch errors and delete the file if it's needed

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

//

LOCAL_C void CleanupData( TAny* aPtr )

    {

    CDRMBackup* backup = reinterpret_cast<CDRMBackup*>( aPtr );

    backup->PerformCleanup();

    }

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

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

// CDRMBackup::CDRMBackup

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

                        RFs& aFileServer ) :

    iDRMRightsDB( aRightsDatabase ),

    iRightsFileSize( 0 ),

    iContextFileSize( 0 ),

    iPosition( 0 ),

    iReadData( 0 ),

    iStatus( 0 )

    };

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

// CDRMBackup::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CDRMBackup::ConstructL()

    {

    TInt error = KErrNone;

#ifndef RD_MULTIPLE_DRIVE

    // Create the backup directory if needed

    error = iFileServer.MkDirAll( KBackupDirectory );

#else //RD_MULTIPLE_DRIVE

    TInt driveNumber( -1 );

    TChar driveLetter;

    DriveInfo::GetDefaultDrive( DriveInfo::EDefaultSystem, driveNumber );

    // Create the backup directory if needed

    error = iFileServer.MkDirAll( backupDir );

#endif

    if( error != KErrAlreadyExists )

        {

        User::LeaveIfError( error );

        }

#ifndef RD_MULTIPLE_DRIVE

    iRightsFileName.Copy( KBackupDirectory );

#else //RD_MULTIPLE_DRIVE

    iRightsFileName.Copy( backupDir );

#endif

    iRightsFileName.Append( KRightsDbBackupFile );

    };

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

// CDRMBackup::NewLC

// Two-phased constructor

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

//

                               RFs& aFileServer )

    {

                                               aFileServer );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    };

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

// CDRMBackup::NewL

// Two-phased constructor

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

//

                              RFs& aFileServer )

    {

                              aFileServer );

    CleanupStack::Pop();

    return self;

    };

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

// CDRMBackup::~CDRMBackup

// Destructor

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

CDRMBackup::~CDRMBackup()

    {

    };

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

// CDRMBackup::AllSnapshotsSuppliedL

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

void CDRMBackup::AllSnapshotsSuppliedL()

    {

    return;

    };

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

// CDRMBackup::ReceiveSnapshotDataL

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

                                      TBool /* aLastSection */)

    {

    User::Leave( KErrNotSupported );

    };

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

// CDRMBackup::GetExpectedDataSize

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

TUint CDRMBackup::GetExpectedDataSize(TDriveNumber /* aDrive */)

    {

    return 0;

    };

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

// CDRMBackup::GetSnapshotDataL

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

                                  TBool& /* aFinished */)

    {

    User::Leave( KErrNotSupported );

    };

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

// CDRMBackup::InitialiseGetBackupDataL

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

void CDRMBackup::InitialiseGetBackupDataL(TDriveNumber aDrive)

    {

    // Clean up existing data:

    PerformCleanup();

#ifndef RD_MULTIPLE_DRIVE

    // Only do a backup when backing up drive C

    if( aDrive == EDriveC )

#else //RD_MULTIPLE_DRIVE

    TInt driveNumber( -1 );

    DriveInfo::GetDefaultDrive( DriveInfo::EDefaultSystem, driveNumber );

    if( aDrive == driveNumber )

#endif

        {

        iStatus |= KDoBackup;

        }

    else

        {

        iStatus &= ~KDoBackup;

        return;

        }

    TCleanupItem resetAndDestroy( CleanupData, reinterpret_cast<TAny*>(this) );

    CleanupStack::PushL( resetAndDestroy );

    // This function needs to write the two files required to be backed up.

    // create the rights database backup file

    CreateRightsBackupFileL();

    // create the context database backup file

    CreateContextBackupFileL();

    // If everything went properly, pop

    CleanupStack::Pop();

    };

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

// CDRMBackup::GetBackupDataSectionL

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

void CDRMBackup::GetBackupDataSectionL(TPtr8& aBuffer, TBool& aFinished)

    {

    TInt seekAmount = 0;

    // if we are not supposed to do anything, just return

    if( !(iStatus & KDoBackup ) )

        {

        aFinished = ETrue;

        return;

        }

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

    aBuffer.SetLength(0);

    TCleanupItem resetAndDestroy( CleanupData, reinterpret_cast<TAny*>(this) );

    CleanupStack::PushL( resetAndDestroy );

    if( iPosition < iRightsFileSize )

        iRightsBackupFile.Seek( ESeekStart,iPosition );

        // Read data

        User::LeaveIfError( iRightsBackupFile.Read( aBuffer ) );

        iPosition += aBuffer.Length();

        if( iPosition == iRightsFileSize )

            {

            aFinished = ETrue;

            }

        else

        }

    else if( iPosition < iRightsFileSize + iContextFileSize )

        // Find the right position

        iContextBackupFile.Seek( ESeekStart, seekAmount );

        // Read data

        User::LeaveIfError( iContextBackupFile.Read( aBuffer ) );

        iPosition += aBuffer.Length();

        if( iPosition-iRightsFileSize == iContextFileSize )

            {

            aFinished = ETrue;

            }

        else

            }

        }

    else

        {

        User::Leave( KErrGeneral );

        }

    if( aFinished )

        {

        }

    else

        {

    };

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

// CDRMBackup::InitialiseRestoreBaseDataL

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

void CDRMBackup::InitialiseRestoreBaseDataL(TDriveNumber aDrive)

    {

    // Clean up existing data:

    PerformCleanup();

#ifndef RD_MULTIPLE_DRIVE

    // Only do a restore when restoring drive C

    if( aDrive == EDriveC )

#else //RD_MULTIPLE_DRIVE

    TInt driveNumber( -1 );

    DriveInfo::GetDefaultDrive( DriveInfo::EDefaultSystem, driveNumber );

    // Only do a restore when restoring drive C

    if( aDrive == driveNumber )

#endif

        {

        iStatus |= KDoBackup;

        }

    else

        {

        iStatus &= ~KDoBackup;

        }

    };

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

// CDRMBackup::RestoreBaseDataSectionL

// Create the files where the restore is performed from

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

void CDRMBackup::RestoreBaseDataSectionL(TDesC8& aBuffer, TBool aFinished)

    {

    TInt seekAmount = 0;

    Roap::RRoapStorageClient client;

    TFileName tempFileName;

    TPtrC8 buffer( aBuffer );

    if( !(iStatus & KDoBackup ) )

        {

        return;

        }

    TCleanupItem resetAndDestroy( CleanupData, reinterpret_cast<TAny*>(this) );

    // Read the size of the first file, even if it comes in one byte chunks

    if( iPosition == 0 && iReadData < 4 && !( iStatus & KRightsSizeRead ) )

        {

        if( iReadData + buffer.Length() >= 4 )

            {

            Mem::Copy( const_cast<TUint8*>( iSizeBuffer.Ptr() ) + iReadData,

                       buffer.Ptr(), 4-iReadData );

            RMemReadStream stream( iSizeBuffer.Ptr(), 4 );

            CleanupClosePushL( stream );

            iRightsFileSize = stream.ReadInt32L();

            CleanupStack::PopAndDestroy();

            // Remove the 'used' data from the beginning of the data block

            buffer.Set( buffer.Mid( 4-iReadData ) );

            iStatus |= KRightsSizeRead;

            iReadData = 0;

            }

        else

            {

            if( aFinished )

                {

                CleanupStack::PopAndDestroy();

                return;

            // copy the data to the temp buffer

            Mem::Copy( const_cast<TUint8*>( iSizeBuffer.Ptr() ) + iReadData,

                       buffer.Ptr(), buffer.Length() );

            iReadData += buffer.Length();

            }

        }

    if( iPosition == iRightsFileSize && iReadData < 4 && !(iStatus & KContextSizeRead) )

        {

        if( iReadData + buffer.Length() >= 4 )

            {

            Mem::Copy( const_cast<TUint8*>( iSizeBuffer.Ptr() ) + iReadData,

                       buffer.Ptr(), 4-iReadData );

            RMemReadStream stream( iSizeBuffer.Ptr(), 4 );

            CleanupClosePushL( stream );

            iContextFileSize = stream.ReadInt32L();

            CleanupStack::PopAndDestroy();

            // Remove the 'used' data from the beginning of the data block

            buffer.Set( buffer.Mid( 4-iReadData ) );

            iStatus |= KContextSizeRead;

            iReadData = 0;

            }

        else

            {

            if( aFinished )

                {

                CleanupStack::PopAndDestroy();

                return;

            // copy the data to the temp buffer

            Mem::Copy( const_cast<TUint8*>( iSizeBuffer.Ptr()) + iReadData,

                       buffer.Ptr(), buffer.Length() );

            iReadData += buffer.Length();

        }

    // Restore the two files:

    // RFileLogger::Write(KLogDir, KLogName, EFileLoggingModeAppend, _L8("RestoreBaseDataSectionL : before restore\n\r"));

    if( iPosition < iRightsFileSize )

        {

        // RFileLogger::Write(KLogDir, KLogName, EFileLoggingModeAppend, _L8("RestoreBaseDataSectionL : restore starts\n\r"));

        if( !( iStatus & KRightsFileOpen ) )

            {

            User::LeaveIfError( iRightsBackupFile.Replace( iFileServer,

                                                           iRightsFileName,