/*

* Copyright (c) 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:  WMDRM data store implementation

*

*/

#include <ezlib.h>

#include <e32math.h>

#include <symmetric.h>

#include <bacntf.h>

#include <centralrepository.h> 

#include "wmdrmdatastore.h"

#include "wmdrmprivatecrkeys.h"

#include "wmdrmkeystorage.h"

#include "slotdatacache.h"

#include "wmdrmdb.h"

#include "drmrightsstoringlocation.h"

#include "drmutilityinternaltypes.h"

#define _LOGGING_FILE L"wmdrmserver.txt"

#include "flogger.h"

#include "logfn.h"

const TInt KMegaByte( 1024 * 1024 );

const TInt KTwoHundredMegaBytes ( 200 * 1024 * 1024 );

const TInt KMaxSpaceRatio( 85 );

const TInt KMaxSpaceRatio2( 20 );

const TInt KMaxTInt64BufLength( 20 );

const TInt KDummyDbInitialSize( 0 );

#if defined(FF_PLATFORM_SIMULATOR) || defined(__WINSCW__)

_LIT8( KDummyKey, "0123456789012345" );

#endif

CWmDrmDataStore* CWmDrmDataStore::NewL( CWmDrmServer* aServer )

    {

    LOGFN( "CWmDrmDataStore::NewL" );

    CWmDrmDataStore* self = new ( ELeave ) CWmDrmDataStore( aServer );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

CWmDrmDataStore::CWmDrmDataStore( CWmDrmServer* aServer ) 

    : iServer( aServer ), iMinFreeSpace2( 0 )

    {

    LOGFN( "CWmDrmDataStore::CWmDrmDataStore" );

    }

void CWmDrmDataStore::ConstructL()

    {

    TDrmScheme drmScheme( EDrmSchemeWmDrm );

    TFileName tempFile, tempFile2;

    TChar driveLetter;

    LOGFN( "CWmDrmDataStore::ConstructL" );

    // Check which drive is configured in the Central Repository Key

    // for the desired storing location of WM DRM rights (license store).

	iWmDrmRightsConfigFound = DrmRightsStoringLocation::CheckDrmRightsStorageDriveL(

	    iServer->Fs(), drmScheme, driveLetter );

    // If the storing location is configured to other drive than the default 

	// system drive, prepare utility files for that drive, too.

    if ( iWmDrmRightsConfigFound )

        {

        PrepareInfoFilesL( ETrue, driveLetter, iDummyDb2 );

        }

    // Prepare the utility files for the default system drive

    PrepareInfoFilesL( EFalse, (TUint)iServer->Fs().GetSystemDriveChar(), 

        iDummyDb );

    }

CWmDrmDataStore::~CWmDrmDataStore()

    {

    LOGFN( "CWmDrmDataStore::~CWmDrmDataStore" );

    iDummyDb.Close();

    // Close the database on the configured drive

    if ( iWmDrmRightsConfigFound )

        {

        iDummyDb2.Close();

        }

    }

void CWmDrmDataStore::ReadInitialFreeSpaceL( const TDesC& aFileName,

    TBool& aConfiguredDrive )

    {

    RFile file;

    TBuf8<KMaxTInt64BufLength + 2 * KAESKeyLength> encryptedData;

    TBuf8<KMaxTInt64BufLength + 2 * KAESKeyLength> decryptedData;

    TBuf8<KAESKeyLength> key;

    TBuf8<KAESKeyLength> iv;

    CBufferedDecryptor* decryptor = NULL;

    CModeCBCDecryptor* cbcDecryptor = NULL;

    CAESDecryptor* aesDecryptor = NULL;

    CPaddingPKCS7* padding = NULL;

    TInt size = 0;

    LOGFN( "CWmDrmDataStore::ReadInitialFreeSpaceL" );

    User::LeaveIfError( file.Open( iServer->Fs(), aFileName, EFileRead ) );

    CleanupClosePushL( file );

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

	if( size != ( 2 * KAESKeyLength ) )

	    {

	    User::Leave(KErrCorrupt);

	    }

    User::LeaveIfError( file.Read( iv ) );

	User::LeaveIfError( file.Read( encryptedData ) );

#if defined(FF_PLATFORM_SIMULATOR) || defined(__WINSCW__)

	key.Copy( KDummyKey );

#else

	iServer->Cache()->iKeyStorage->GetDeviceSpecificKeyL( key );

#endif

	aesDecryptor = CAESDecryptor::NewL( key );

    CleanupStack::PushL( aesDecryptor );

    cbcDecryptor = CModeCBCDecryptor::NewL( aesDecryptor, iv );

    CleanupStack::Pop( aesDecryptor );

    CleanupStack::PushL( cbcDecryptor );

    padding = CPaddingPKCS7::NewL( KAESKeyLength );

    CleanupStack::PushL( padding );

    decryptor = CBufferedDecryptor::NewL( cbcDecryptor, padding );

    CleanupStack::Pop( 2, cbcDecryptor ); //padding, cbcDecryptor

    CleanupStack::PushL( decryptor );

	decryptor->ProcessFinalL( encryptedData, decryptedData );

	CleanupStack::PopAndDestroy( 2, &file ); //decryptor, file

	TLex8 lex( decryptedData );

	if ( aConfiguredDrive )

	    {

	    User::LeaveIfError( lex.Val( iInitialFreeSpace2 ) );

	    }

	else 

	    {

	    User::LeaveIfError( lex.Val( iInitialFreeSpace ) );

	    }    

    }

void CWmDrmDataStore::WriteInitialFreeSpaceL( const TDesC& aFileName,

    TBool& aConfiguredDrive )

    {

    RFile file;

    TBuf8<KMaxTInt64BufLength + 2 * KAESKeyLength> encryptedData;

    TBuf8<KMaxTInt64BufLength + 2 * KAESKeyLength> decryptedData;

    TBuf8<KAESKeyLength> key;

    TBuf8<KAESKeyLength> iv;

    CBufferedEncryptor* encryptor = NULL;

    CModeCBCEncryptor* cbcEncryptor = NULL;

    CAESEncryptor* aesEncryptor = NULL;

    CPaddingPKCS7* padding = NULL;

    LOGFN( "CWmDrmDataStore::WriteInitialFreeSpaceL" );

    User::LeaveIfError( file.Create( iServer->Fs(), aFileName, EFileWrite ) );

    CleanupClosePushL( file );

    if ( aConfiguredDrive )

        {

        iInitialFreeSpace2 = iServer->FreeSpaceL( aConfiguredDrive );

        }

    else

        {

        iInitialFreeSpace = iServer->FreeSpaceL( aConfiguredDrive );

        }    

    iv.SetLength( KAESKeyLength );

    TRandom::RandomL( iv );

#if defined(FF_PLATFORM_SIMULATOR) || defined(__WINSCW__)

    key.Copy( KDummyKey );

#else

    iServer->Cache()->iKeyStorage->GetDeviceSpecificKeyL( key );

#endif

    aesEncryptor = CAESEncryptor::NewL( key );

    CleanupStack::PushL( aesEncryptor );

    cbcEncryptor = CModeCBCEncryptor::NewL( aesEncryptor, iv );

    CleanupStack::Pop( aesEncryptor );

    CleanupStack::PushL( cbcEncryptor );

    padding = CPaddingPKCS7::NewL( KAESKeyLength );

    CleanupStack::PushL( padding );

    encryptor = CBufferedEncryptor::NewL( cbcEncryptor, padding );

    CleanupStack::Pop( 2, cbcEncryptor ); //padding, cbcEncryptor

    CleanupStack::PushL( encryptor );

    if ( aConfiguredDrive )

        {

        decryptedData.AppendNum( iInitialFreeSpace2 );

        }

    else

        {

        decryptedData.AppendNum( iInitialFreeSpace );

        }    

    encryptor->ProcessFinalL( decryptedData, encryptedData );

    User::LeaveIfError( file.Write( iv ) );

    User::LeaveIfError( file.Write( encryptedData ) );

    CleanupStack::PopAndDestroy( 2, &file ); //encryptor, file

    }

TWmDrmStoreState CWmDrmDataStore::DataStoreStateL()

    {

    TWmDrmStoreState state;

    TInt64 freeSpace( 0 );

    TInt64 freeSpace2( 0 );

    TInt dataStoreSize( 0 );

    TInt dummyDbSize( 0 );

    TInt ratio( 0 );

    TInt ratio2( 0 );

    TBool internalMassDriveNotFull( ETrue );

    LOGFN( "CWmDrmDataStore::DataStoreStateL" );

    freeSpace = iServer->FreeSpaceL( EFalse );

    if ( iWmDrmRightsConfigFound )

        {

        // Check free space from the configured drive, too.

        freeSpace2 = iServer->FreeSpaceL( ETrue );

        if ( freeSpace2 < iMinFreeSpace2 ) 

            {

            internalMassDriveNotFull = EFalse;

            }

        dummyDbSize = DummyDBSizeL( ETrue );

        dataStoreSize = DataStoreSizeL( ETrue );

        ratio2 = dataStoreSize * 100 / iInitialFreeSpace2;

        freeSpace2 += dummyDbSize;

#ifdef _LOGGING        

        TBuf<KMaxTInt64BufLength> free2;

        LOG1( "CWmDrmDataStore::DataStoreStateL: Free space (2): ");

        free2.AppendNumUC( freeSpace2, EDecimal );

        LOG( free2 );

        TBuf<KMaxTInt64BufLength> free2Min;

        LOG1( "CWmDrmDataStore::DataStoreStateL: Minimum free space (2): ");

        free2Min.AppendNumUC( iMinFreeSpace2, EDecimal );

        LOG( free2Min );

#endif             

        }

    // Check the system drive storage space next.   

    dummyDbSize = DummyDBSizeL( EFalse );

    dataStoreSize = DataStoreSizeL( EFalse );

    ratio = dataStoreSize * 100 / iInitialFreeSpace;

    freeSpace += dummyDbSize;

#ifdef _LOGGING        

    TBuf<KMaxTInt64BufLength> free;

    LOG1( "CWmDrmDataStore::DataStoreStateL: Free space: ");

    free.AppendNumUC( freeSpace, EDecimal );

    LOG( free );

    TBuf<KMaxTInt64BufLength> freeMin;

    LOG1( "CWmDrmDataStore::DataStoreStateL: Minimum free space: ");

    freeMin.AppendNumUC( iMinFreeSpace, EDecimal );

    LOG( freeMin );

#endif      

    // Select the state of the storage space.      

    if ( ( freeSpace > iMinFreeSpace ) && internalMassDriveNotFull ) 

        {

        LOG1( "CWmDrmDataStore::DataStoreStateL: Store space Ok" );

        state = EStoreSpaceOK;

        }

    else

        {

        // The configured drive is running out of space. The system drive 

        // may also be running out of storage space, but calculate

        // the ratio of database size to initial free drive space and the

        // state of the drive storage space from the configured drive because

        // it is likely to fill up faster since the media files may be synced to it. 

        if ( !internalMassDriveNotFull )

            {

            LOG2( "Ratio (2): %d", ratio2 );

            if ( ratio2 <= iMaxSpaceRatio2 )

                {

                LOG1( "CWmDrmDataStore::DataStoreStateL: Store space low (2)" );

                state = EStoreSpaceLow;

                }

            else

                {

                LOG1( "CWmDrmDataStore::DataStoreStateL: Store space full (2)" );

                state = EStoreSpaceFull;

                }

            }

        else

            // Only the system drive is running out of storage space. 

            {

            LOG2( "Ratio: %d", ratio );

            if ( ratio <= iMaxSpaceRatio )

                {

                LOG1( "CWmDrmDataStore::DataStoreStateL Store space low" );

                state = EStoreSpaceLow;

                }

            else

                {

                LOG1( "CWmDrmDataStore::DataStoreStateL Store space full" );

                state = EStoreSpaceFull;

                }

            }    

        }

    LOG2( "DataStoreState: %d", state );

    return state;

    }

void CWmDrmDataStore::InitializeDummyDbFileL( const TDesC& aFileName,

    RFile& aDummyDb, TBool& aConfiguredDrive )

    {

    TInt r( KErrNone );

    LOGFN( "CWmDrmDataStore::InitializeDummyDbFileL" );

    r = aDummyDb.Create( iServer->Fs(), aFileName, EFileWrite );

    if ( r == KErrAlreadyExists )

        {

        User::LeaveIfError( 

            aDummyDb.Open( iServer->Fs(), aFileName, EFileWrite ) );

        }

    else if( !r )

        {

        TInt dataStoreSize( DataStoreSizeL( aConfiguredDrive ) );

        if ( aConfiguredDrive )

            {

            if ( dataStoreSize <= iDummyDbInitialSize2 )

                {

                User::LeaveIfError( 

                    aDummyDb.SetSize( iDummyDbInitialSize2 - dataStoreSize ) );

                }

            else

                {

                User::LeaveIfError( aDummyDb.SetSize( 0 ) );

                }

            }

        else 

            {

            if ( dataStoreSize <= iDummyDbInitialSize )

                {

                User::LeaveIfError( 

                    aDummyDb.SetSize( iDummyDbInitialSize - dataStoreSize ) );

                }

            else

                {

                User::LeaveIfError( aDummyDb.SetSize( 0 ) );

                }

            } 

        }

    else

        {

        User::Leave( r );

        }

    }

void CWmDrmDataStore::UpdateDummyDbFileL( TInt aSize, TBool aConfiguredDrive )

    {

    LOGFN( "CWmDrmDataStore::UpdateDummyDbFileL" );

    LOG2( "aSize: %d", aSize );

    if ( aSize > 0 )

        {

        TInt dummyDbSize( DummyDBSizeL( aConfiguredDrive ) );

        LOG2( "dummyDbSize: %d", dummyDbSize );

        if ( aSize <= dummyDbSize )

            {

            if ( aConfiguredDrive ) 

                {

            	User::LeaveIfError( iDummyDb2.SetSize( dummyDbSize - aSize ) );

            	}

            else

            	{	

            	User::LeaveIfError( iDummyDb.SetSize( dummyDbSize - aSize ) );

            	}

           	} 		

        else

            {

            if ( aConfiguredDrive )

            	{

            	User::LeaveIfError( iDummyDb2.SetSize( 0 ) );

            	}

            else 

            	{

            	User::LeaveIfError( iDummyDb.SetSize( 0 ) );	

          		}

          	}		

        }

    else

        {

        TInt dataStoreSize( DataStoreSizeL( aConfiguredDrive ) );

        LOG2( "dataStoreSize: %d", dataStoreSize );

        if ( aConfiguredDrive )

            {

            if ( dataStoreSize <= iDummyDbInitialSize2 )

                {

                User::LeaveIfError( 

                    iDummyDb2.SetSize( iDummyDbInitialSize2 - dataStoreSize ) );

            	}

            else 

            	{

            	User::LeaveIfError( iDummyDb2.SetSize( 0 ) );

            	}

            }

        else 

            {

            if ( dataStoreSize <= iDummyDbInitialSize )

                {

                User::LeaveIfError( 

                    iDummyDb.SetSize( iDummyDbInitialSize - dataStoreSize ) );

            	}

            else 

            	{

            	User::LeaveIfError( iDummyDb.SetSize( 0 ) );

            	}

            }

        } 

    }

TInt CWmDrmDataStore::DataStoreSizeL( TBool aConfiguredDrive )

    {

    TInt dataStoreSize( iServer->Db()->DataBaseSize( aConfiguredDrive ) );

    User::LeaveIfError( dataStoreSize );

    return dataStoreSize;

    }

TInt CWmDrmDataStore::DummyDBSizeL( TBool aConfiguredDrive )

    {

    TInt dummyDbSize( 0 );

    if ( aConfiguredDrive )

        {

        User::LeaveIfError( iDummyDb2.Size( dummyDbSize ) );

        }

    else

        {

        User::LeaveIfError( iDummyDb.Size( dummyDbSize ) );

        }    

    return dummyDbSize;

    }

void CWmDrmDataStore::PrepareInfoFilesL( TBool aConfiguredDrive, 

    TChar aDriveLetter, RFile& aDummyDb )

    {

    LOGFN( "CWmDrmDataStore::PrepareInfoFilesL" );

    CRepository* repository( NULL );

    TInt r( KErrNone );

    TFileName dummyDbFile; 

    TFileName initialFreeSpaceFile;

    initialFreeSpaceFile.Format( KPrivateDir, (TUint)aDriveLetter );

    iServer->Fs().MkDirAll( initialFreeSpaceFile );

    initialFreeSpaceFile.Format( KInitialFreeSpaceFile, (TUint)aDriveLetter );

    dummyDbFile.Format( KDummyDbFile, (TUint)aDriveLetter );

    TRAP( r, WriteInitialFreeSpaceL( initialFreeSpaceFile, 

        aConfiguredDrive ) );

    if ( r )

        {

        r = KErrNone;

        // catch the read error

        TRAP( r, ReadInitialFreeSpaceL( initialFreeSpaceFile, 

            aConfiguredDrive ) );

        // if an error occurs, this means that we are unable to read the info, 

        // thus we need to delete the file and run write again.

        // hopefully this being a temporary error, but if we fail again we fail

        // until next ConstructL

        if( r != KErrNone )

            {

            // delete the file:

            iServer->Fs().Delete( initialFreeSpaceFile );

            // Calc & Write the new info

            WriteInitialFreeSpaceL( initialFreeSpaceFile, aConfiguredDrive );

            }

        }

    if ( aConfiguredDrive )

        {

#ifdef _LOGGING        

        TBuf<KMaxTInt64BufLength> freeSpace2;

        LOG1( "CWmDrmDataStore::DataStoreStateL: Initial free space (2): ");

        freeSpace2.AppendNumUC( iInitialFreeSpace2, EDecimal );

        LOG( freeSpace2 );

#endif          

        if ( iInitialFreeSpace2 <= 0 )

            {

            User::Leave( KErrNotReady );

            }

        }

    else 

        {

#ifdef _LOGGING        

        TBuf<KMaxTInt64BufLength> freeSpace;

        LOG1( "CWmDrmDataStore::DataStoreStateL: Initial free space: ");

        freeSpace.AppendNumUC( iInitialFreeSpace, EDecimal );

        LOG( freeSpace );

#endif          

        if ( iInitialFreeSpace <= 0 )

            {

            User::Leave( KErrNotReady );

            }

        }

    //LOG1( "CWmDrmDataStore::PrepareInfoFilesL Check Cenrep" );

    TRAP( r, repository = CRepository::NewL( KCRUidWMDRM ) );

    if ( repository )

        {

        TInt rate( 0 );

        // Check the cenrep key parameters either for the default system drive

        // or for the internal mass drive depending whether the WMDRM rights