/*
* 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: CMMCScBkupDataStrategy implementation
*
*
*/

#include "CMMCScBkupDataStrategies.h"

// User includes
#include "MMCScBkupConfig.h"
#include "MMCScBkupLogger.h"




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

// ---------------------------------------------------------------------------
// CMMCScBkupDataStrategy::CMMCScBkupDataStrategy()
// 
// C++ constructor.
// ---------------------------------------------------------------------------
CMMCScBkupDataStrategy::CMMCScBkupDataStrategy()
    {
    }


// ---------------------------------------------------------------------------
// CMMCScBkupDataStrategy::ReadStrategyLC()
// 
// Factory function
// ---------------------------------------------------------------------------
CMMCScBkupDataStrategy* CMMCScBkupDataStrategy::ReadStrategyLC(const TDesC& aName, RFs& aFsSession)
    {
    // Fetch the size
    TEntry entry;
    const TInt error = aFsSession.Entry(aName, entry);
    User::LeaveIfError(error);

    // Construct
    return CMMCScBkupDataStrategy::ReadStrategyLC(aName, aFsSession, 0, entry.iSize);
    }


// ---------------------------------------------------------------------------
// CMMCScBkupDataStrategy::ReadStrategyLC()
// 
// Factory function
// ---------------------------------------------------------------------------
CMMCScBkupDataStrategy* CMMCScBkupDataStrategy::ReadStrategyLC(const TDesC& aName, RFs& aFsSession, TInt aOffset, TInt aLength)
    {
    CMMCScBkupDataStrategy* ret = NULL;

    // First, try a normal read strategy
    TRAPD(err, ret = CMMCScBkupDataFileStrategy::NewForReadingL(aName, aFsSession));
    if  (err != KErrNone)
        {
        // Try the file section read strategy - don't trap this - if it fails
        // then this file cannot be read...
        ret = CMMCScBkupDataFileSectionReadStrategy::NewL(aName, aFsSession);
        }
    //
    if  (ret)
        {
        ret->SetOffsetAndLength(aOffset, aLength);
        }
    //
    CleanupStack::PushL( ret );
    return ret;
    }


// ---------------------------------------------------------------------------
// CMMCScBkupDataStrategy::WriteStrategyLC()
// 
// Factory function
// ---------------------------------------------------------------------------
CMMCScBkupDataStrategy* CMMCScBkupDataStrategy::WriteStrategyLC( const TDesC& aName, RFs& aFsSession, TBool aUseTempFile )
    {
    CMMCScBkupDataStrategy* ret = CMMCScBkupDataFileStrategy::NewForWritingL( aName, aFsSession, aUseTempFile );
    CleanupStack::PushL(ret);
    return ret;
    }


// ---------------------------------------------------------------------------
// CMMCScBkupDataStrategy::Write()
// 
// 
// ---------------------------------------------------------------------------
TInt CMMCScBkupDataStrategy::Write(const TDesC8& /*aSource*/)
    {
    return KErrNotSupported;
    }


// ---------------------------------------------------------------------------
// CMMCScBkupDataStrategy::Finalize()
// 
// 
// ---------------------------------------------------------------------------
TInt CMMCScBkupDataStrategy::Finalize()
    {
    return KErrNone;
    }
    

// ---------------------------------------------------------------------------
// CMMCScBkupDataStrategy::SetOffsetAndLength()
// 
// 
// ---------------------------------------------------------------------------
void CMMCScBkupDataStrategy::SetOffsetAndLength(TInt aStartOffset, TInt aLengthToRead)
    {
    iOffset = aStartOffset; 
    iLengthToRead = aLengthToRead;
    }




































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

// ---------------------------------------------------------------------------
// CMMCScBkupDataFileStrategy::CMMCScBkupDataFileStrategy()
// 
// C++ constructor.
// ---------------------------------------------------------------------------
CMMCScBkupDataFileStrategy::CMMCScBkupDataFileStrategy( RFs& aFsSession, TBool aUseTempFile )
:   iFsSession( aFsSession ), iUseTempFile( aUseTempFile )
    {
    }


// ---------------------------------------------------------------------------
// CMMCScBkupDataFileStrategy::~CMMCScBkupDataFileStrategy()
// 
// C++ destructor.
// ---------------------------------------------------------------------------
CMMCScBkupDataFileStrategy::~CMMCScBkupDataFileStrategy()
    {
    iFile.Close();
    delete iFileName;
    }


// ---------------------------------------------------------------------------
// CMMCScBkupDataFileStrategy::ConstructL()
// 
// 
// ---------------------------------------------------------------------------
void CMMCScBkupDataFileStrategy::ConstructL( const TDesC& aName, TUint aMode )
    {
    iFileName = aName.AllocL();
    
    // The previous version of this engine would attempt to use the old
    // backup & restore API to close this file. 
    //
    // With the new Symbian Secure Backup Architecture, data owners are expected
    // to release file locks on public files as soon as they receive
    // notification that a backup is beginning.
    TInt error = KErrNone;
    //
    if  ( iUseTempFile )
        {
        // Ensure path for temporary files exists on same drive where file will eventually
        // be stored. This is important, because we estimate available size on target drive
        // and so also temporary file size affects whether restore can be carried out.
        HBufC* tempPath = HBufC::NewLC( KMaxFileName );
        TPtr pTempPath( tempPath->Des() );
        pTempPath.Zero();
        if(aName.Length())
            {
            pTempPath.Append( aName[0] );
            }
        else
            {
            const TDriveUnit driveUnit( KMMCScBkupTempFileDrive );
            const TDriveName drive( driveUnit.Name() );
            pTempPath.Append( drive );
            }
        pTempPath.Append( KMMCScBkupTempDir );

        error = iFsSession.MkDirAll( pTempPath );
        if  ( ! (error == KErrNone || error == KErrAlreadyExists) )
            {
            User::LeaveIfError( error );
            }
            
        // Make a temporary file
        error = iFile.Temp( iFsSession, pTempPath, iTempFileName, aMode );
        __LOG2("CMMCScBkupDataFileStrategy::ConstructL() - Created temporary file: %S, error code: %d", &iTempFileName, error);
        
        // Clean up
        CleanupStack::PopAndDestroy( tempPath );
        }
    else
        {
        if( aMode & EFileWrite )
            {
            error = PrepareToOverwriteFile( iFsSession, *iFileName );

            if  ( error == KErrNone )
                {
                error = iFile.Create( iFsSession, *iFileName, aMode );
                __LOG2("CMMCScBkupDataFileStrategy::ConstructL() - Created file %S, error code: %d", iFileName, error);
                }
            }
        else
            {
            error = iFile.Open( iFsSession, aName, aMode );
            }
        }
    //
    User::LeaveIfError(error);
    }


// ---------------------------------------------------------------------------
// CMMCScBkupDataFileStrategy::NewForReadingL()
// 
// Factory function
// ---------------------------------------------------------------------------
CMMCScBkupDataFileStrategy* CMMCScBkupDataFileStrategy::NewForReadingL( const TDesC& aName, RFs& aFsSession )
    {
    const TUint mode = EFileRead | EFileShareReadersOnly | EFileStream;
    //
    CMMCScBkupDataFileStrategy* self = new(ELeave) CMMCScBkupDataFileStrategy( aFsSession );
    CleanupStack::PushL(self);
    self->ConstructL( aName, mode );
    CleanupStack::Pop( self );
    return self;
    }


// ---------------------------------------------------------------------------
// CMMCScBkupDataFileStrategy::NewForWritingL()
// 
// Factory function
// ---------------------------------------------------------------------------
CMMCScBkupDataFileStrategy* CMMCScBkupDataFileStrategy::NewForWritingL( const TDesC& aName, RFs& aFsSession, TBool aUseTempFile )
    {
    const TUint mode = EFileWrite | EFileStream;
    //
    CMMCScBkupDataFileStrategy* self = new(ELeave) CMMCScBkupDataFileStrategy( aFsSession, aUseTempFile );
    CleanupStack::PushL(self);
    self->ConstructL( aName, mode );
    CleanupStack::Pop( self );
    return self;
    }


// ---------------------------------------------------------------------------
// CMMCScBkupDataFileStrategy::Read()
// 
//
// ---------------------------------------------------------------------------
TInt CMMCScBkupDataFileStrategy::Read(TDes8& aSink)
    {
    TInt error = KErrNone;
    //
    aSink.Zero();
    TInt amountToRead = (LengthToRead() - Offset());
    if  (amountToRead > aSink.MaxLength())
        {
        amountToRead = aSink.MaxLength();
        }
    //
    if  (amountToRead > 0)
        {
        // Do the read
        error = iFile.Read( static_cast<TInt64>(Offset()), aSink, amountToRead );
        if  (error == KErrNone)
            {
            SetOffset( Offset() + aSink.Length() );
            }
        }
    //
    return error;
    }


// ---------------------------------------------------------------------------
// CMMCScBkupDataFileStrategy::Write()
// 
//
// ---------------------------------------------------------------------------
TInt CMMCScBkupDataFileStrategy::Write(const TDesC8& aSource)
    {
    // Offset writing not supported (no requirement)
    const TInt error = iFile.Write( aSource );
    return error;
    }


// ---------------------------------------------------------------------------
// CMMCScBkupDataFileStrategy::Finalize()
// 
// 
// ---------------------------------------------------------------------------
TInt CMMCScBkupDataFileStrategy::Finalize()
    {
    TInt error = KErrNone;
    //
    if  ( iUseTempFile )
        {
        // Prepare for over-write
        error = PrepareToOverwriteFile( iFsSession, *iFileName );
        //
        if  ( error == KErrNone )
            {
            // Finally, do the rename
            error = iFile.Rename( *iFileName );
            __LOG2("CMMCScBkupDataFileStrategy::Finalize() - Renamed temporary file as: %S, error code: %d", iFileName, error);
            }
        }

    // Whatever the situation, we close the file now
    iFile.Close();
    return error;
    }


// ---------------------------------------------------------------------------
// CMMCScBkupDataFileStrategy::PrepareToOverwriteFile()
// 
// 
// ---------------------------------------------------------------------------
TInt CMMCScBkupDataFileStrategy::PrepareToOverwriteFile( RFs& aFsSession, const TDesC& aFileName )
    {
    TInt err = KErrNone;

    // Create the full path, if not exists
    err = aFsSession.MkDirAll( aFileName );

    if( err == KErrAlreadyExists || !err )
        {
        // Reset file flags
        err = aFsSession.SetAtt( aFileName, KEntryAttNormal, !KEntryAttNormal );
        }

    if( !err )
        {
        // Delete the file
        err = aFsSession.Delete( aFileName );
        }

    if( err == KErrNotFound )
        {
        // These errors are ignored
        err = KErrNone;
        }

    return err;
    }

















































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

// ---------------------------------------------------------------------------
// CMMCScBkupDataFileSectionReadStrategy::CMMCScBkupDataFileSectionReadStrategy()
// 
// C++ constructor.
// ---------------------------------------------------------------------------
CMMCScBkupDataFileSectionReadStrategy::CMMCScBkupDataFileSectionReadStrategy(RFs& aFsSession)
:   iFsSession(aFsSession)
    {
    }


// ---------------------------------------------------------------------------
// CMMCScBkupDataFileSectionReadStrategy::~CMMCScBkupDataFileSectionReadStrategy()
// 
// 
// ---------------------------------------------------------------------------
CMMCScBkupDataFileSectionReadStrategy::~CMMCScBkupDataFileSectionReadStrategy()
    {
    delete iFileName;
    }


// ---------------------------------------------------------------------------
// CMMCScBkupDataFileSectionReadStrategy::ConstructL()
// 
// 
// ---------------------------------------------------------------------------
void CMMCScBkupDataFileSectionReadStrategy::ConstructL(const TDesC& aName)
    {
    iFileName = aName.AllocL();
    }


// ---------------------------------------------------------------------------
// CMMCScBkupDataFileSectionReadStrategy::NewL()
// 
// 
// ---------------------------------------------------------------------------
CMMCScBkupDataFileSectionReadStrategy* CMMCScBkupDataFileSectionReadStrategy::NewL(const TDesC& aName, RFs& aFsSession)
    {
    CMMCScBkupDataFileSectionReadStrategy* self = new(ELeave) CMMCScBkupDataFileSectionReadStrategy(aFsSession);
    CleanupStack::PushL(self);
    self->ConstructL(aName);
    CleanupStack::Pop(self);
    return self;
    }



// ---------------------------------------------------------------------------
// CMMCScBkupDataFileSectionReadStrategy::Read()
// 
//
// ---------------------------------------------------------------------------
TInt CMMCScBkupDataFileSectionReadStrategy::Read(TDes8& aSink)
    {
    TInt error = KErrNone;
    //
    aSink.Zero();
    TInt amountToRead = (LengthToRead() - Offset());
    if  (amountToRead > aSink.MaxLength())
        {
        amountToRead = aSink.MaxLength();
        }
    //
    if  (amountToRead > 0)
        {
        // Do the read
        error = iFsSession.ReadFileSection( *iFileName, Offset(), aSink, amountToRead );
        if  (error == KErrNone)
            {
            SetOffset( Offset() + aSink.Length() );
            }
        }
    return error;
    }