/*

* 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:  database implementation for WMDRM

*

*/

#include <e32std.h>

#include <systemwarninglevels.hrh>

#include "wmdrmdb.h"

#include "wmdrmfileserverclient.h"

#include "wmdrmdatastore.h"

#include "drmrightsstoringlocation.h"

#include "drmutilityinternaltypes.h"

#define _LOGGING_FILE L"wmdrmserver.txt"

#include "flogger.h"

#include "logfn.h"

#define FROM_HEX_DIGIT(x) (x >= 'a' ? x - 'a' + 10 : x - '0')

#define FROM_HEX(x,y) (FROM_HEX_DIGIT(x) * 16 + FROM_HEX_DIGIT(y))

// For secure, sync and metering stores in the case of differentiation of stores

// to system drive and internal mass drive or for all the stores in the case of 

// no differentation

_LIT( KDatabaseName, "%c:[10282F1B]hds.db" );

// For license store in the case of differentation of stores. Not used

// if no differentation is applied.                                              

_LIT( KDatabaseName2, "%c:[10282F1B]hds2.db" );

_LIT8( KDatabaseConfig, "cache_size=64; page_size=2048; encoding=UTF-8" );

_LIT( KBeginTransaction, "BEGIN TRANSACTION" );

_LIT( KCommitTransaction, "COMMIT TRANSACTION" );

_LIT( KCreateLicenseTableString, "CREATE TABLE IF NOT EXISTS license_t (hashKey BINARY NOT NULL, uniqueKey BINARY NOT NULL, data BINARY, PRIMARY KEY(hashKey, uniqueKey))" );

_LIT( KCreateSecureTableString, "CREATE TABLE IF NOT EXISTS secure_t (hashKey BINARY NOT NULL, uniqueKey BINARY NOT NULL, data BINARY, PRIMARY KEY(hashKey, uniqueKey))" );

_LIT( KCreateSyncTableString, "CREATE TABLE IF NOT EXISTS sync_t (hashKey BINARY NOT NULL, uniqueKey BINARY NOT NULL, data BINARY, PRIMARY KEY(hashKey, uniqueKey))" );

_LIT( KCreateMeteringTableString, "CREATE TABLE IF NOT EXISTS metering_t (hashKey BINARY NOT NULL, uniqueKey BINARY NOT NULL, data BINARY, PRIMARY KEY(hashKey, uniqueKey))" );

_LIT( KDeleteLicenseTableString, "DROP TABLE IF EXISTS license_t" );

_LIT( KDeleteSecureTableString, "DROP TABLE IF EXISTS secure_t" );

_LIT( KDeleteSyncTableString, "DROP TABLE IF EXISTS sync_t" );

_LIT( KDeleteMeteringTableString, "DROP TABLE IF EXISTS metering_t" );

_LIT( KSelectNRowIDsLicenseTableString, "SELECT RowID FROM license_t LIMIT %d" );

_LIT( KSelectNRowIDsSecureTableString, "SELECT RowID FROM secure_t LIMIT %d" );

_LIT( KSelectNRowIDsSyncTableString, "SELECT RowID FROM sync_t LIMIT %d" );

_LIT( KSelectNRowIDsMeteringTableString, "SELECT RowID FROM metering_t LIMIT %d" );

_LIT( KDeleteWithRowIDLicenseTableString, "DELETE FROM license_t WHERE RowID = :rowID" );

_LIT( KDeleteWithRowIDSecureTableString, "DELETE FROM secure_t WHERE RowID = :rowID" );

_LIT( KDeleteWithRowIDSyncTableString, "DELETE FROM sync_t WHERE RowID = :rowID" );

_LIT( KDeleteWithRowIDMeteringTableString, "DELETE FROM metering_t WHERE RowID = :rowID" );

_LIT( KDeleteLicenseString, "DELETE FROM license_t WHERE hashKey = :HashKey AND uniqueKey=:UniqueKey" );

_LIT( KDeleteSecureString, "DELETE FROM secure_t WHERE hashKey = :HashKey AND uniqueKey=:UniqueKey" );

_LIT( KDeleteSyncString, "DELETE FROM sync_t WHERE hashKey = :HashKey AND uniqueKey=:UniqueKey" );

_LIT( KDeleteMeteringString, "DELETE FROM metering_t WHERE hashKey = :HashKey AND uniqueKey=:UniqueKey" );

_LIT( KInsertLicenseString, "INSERT INTO license_t (hashKey, uniqueKey) VALUES (:HashKey, :UniqueKey)" );

_LIT( KInsertSecureString, "INSERT INTO secure_t (hashKey, uniqueKey) VALUES (:HashKey, :UniqueKey)" );

_LIT( KInsertSyncString, "INSERT INTO sync_t (hashKey, uniqueKey) VALUES (:HashKey, :UniqueKey)" );

_LIT( KInsertMeteringString, "INSERT INTO metering_t (hashKey, uniqueKey) VALUES (:HashKey, :UniqueKey)" );

_LIT( KUpdateLicenseDataString, "UPDATE license_t SET data=:Data WHERE hashKey = :HashKey AND uniqueKey=:UniqueKey" );

_LIT( KUpdateSecureDataString, "UPDATE secure_t SET data=:Data WHERE hashKey = :HashKey AND uniqueKey=:UniqueKey" );

_LIT( KUpdateSyncDataString, "UPDATE sync_t SET data=:Data WHERE hashKey = :HashKey AND uniqueKey=:UniqueKey" );

_LIT( KUpdateMeteringDataString, "UPDATE metering_t SET data=:Data WHERE hashKey = :HashKey AND uniqueKey=:UniqueKey" );

_LIT( KSelectLicenseString, "SELECT data FROM license_t WHERE hashKey = :HashKey AND uniqueKey=:UniqueKey" );

_LIT( KSelectSecureString, "SELECT data FROM secure_t WHERE hashKey = :HashKey AND uniqueKey=:UniqueKey" );

_LIT( KSelectSyncString, "SELECT data FROM sync_t WHERE hashKey = :HashKey AND uniqueKey=:UniqueKey" );

_LIT( KSelectMeteringString, "SELECT data FROM metering_t WHERE hashKey = :HashKey AND uniqueKey=:UniqueKey" );

_LIT( KSelectLicenseEnumeratorString, "SELECT uniqueKey FROM license_t WHERE hashKey = :HashKey" );

_LIT( KSelectSecureEnumeratorString, "SELECT uniqueKey FROM secure_t WHERE hashKey = :HashKey" );

_LIT( KSelectSyncEnumeratorString, "SELECT uniqueKey FROM sync_t WHERE hashKey = :HashKey" );

_LIT( KSelectMeteringEnumeratorString, "SELECT uniqueKey FROM metering_t WHERE hashKey = :HashKey" );

_LIT( KSelectLicenseNameSpaceEnumeratorString, "SELECT hashKey, uniqueKey FROM license_t" );

_LIT( KSelectSecureNameSpaceEnumeratorString, "SELECT hashKey, uniqueKey FROM secure_t" );

_LIT( KSelectSyncNameSpaceEnumeratorString, "SELECT hashKey, uniqueKey FROM sync_t" );

_LIT( KSelectMeteringNameSpaceEnumeratorString, "SELECT hashKey, uniqueKey FROM metering_t" );

_LIT( KHashKeyColumn, "hashkey" );

_LIT( KHashKeyParameter, ":HashKey" );

_LIT( KUniqueKeyColumn, "uniquekey" );

_LIT( KUniqueKeyParameter, ":UniqueKey" );

_LIT( KDataColumn, "data" );

_LIT( KDataParameter, ":Data" );

_LIT( KRowIDColumn, "rowID" );

_LIT( KRowIDParameter, ":rowID" );

_LIT8( KSyncStore, "syncstore" );

_LIT8( KMeteringStore, "meteringstore" );

_LIT8( KSecureStore, "securestore" );

_LIT8( KLicenseStore, "licstore" );

_LIT8( KHds, "hds" );

const TSecureId KWmDrmServerSecureId( 0x10282F1B );

const TInt KMaxTIntBufLength( 10 );

const TInt KLicenseSize( 5 * 1024 );

const TInt KSixtySeconds( 60 );

const TInt KMaxOperationsUntilCommit( 60 );

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

// CWmDrmDb::CWmDrmDb

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

//

CWmDrmDb::CWmDrmDb( CWmDrmServer* aServer ) : CTimer( EPriorityHigh ), 

    iServer( aServer ),

    iAmountOperationsWithoutCommit( 0 ),

    iSqlTransactionOngoing( EFalse ),

    iSqlTransactionOngoing2( EFalse )   

    {

    CActiveScheduler::Add( this );

    }

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

// CWmDrmDb::ConstructL

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

//

void CWmDrmDb::ConstructL()

    {

    LOGFN( "CWmDrmDb::ConstructL" );

    TDrmScheme drmScheme( EDrmSchemeWmDrm );

    TChar driveLetter;

	TChar systemDriveLetter;

    CTimer::ConstructL();

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

    // for the desired storing location of WM DRM rights.

	iWmDrmRightsConfigFound = DrmRightsStoringLocation::CheckDrmRightsStorageDriveL( 

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

    // Format the default database path on the system drive and open

    // the database. If the storing location is not configured, this database

    // will hold all the four stores, otherwise only the secure and metering

    // stores.

	if ( !iWmDrmRightsConfigFound )

		{

    	iDatabasePath.Format( KDatabaseName, (TUint)driveLetter );

    	OpenDatabaseL( iDatabasePath, iDatabase, EFalse );

    	}

    else 

        {

        // Format the database path also on the internal mass drive and 

        // open both databases. The database on the default system drive

        // includes metering and secure stores, whereas the store on the

        // configured drive includes sync and license stores.

		iDatabasePath.Format( KDatabaseName, 

		    (TUint)iServer->Fs().GetSystemDriveChar() );

        iDatabasePath2.Format( KDatabaseName2, (TUint)driveLetter );

        OpenDatabaseL( iDatabasePath, iDatabase, EFalse );

		OpenDatabaseL( iDatabasePath2, iDatabase2, ETrue );

        }               

    }

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

// CWmDrmDb::NewL

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

//

CWmDrmDb* CWmDrmDb::NewL( CWmDrmServer* aServer )

    {

    LOGFN( "CWmDrmDb::NewL" );

    CWmDrmDb* self( CWmDrmDb::NewLC( aServer ) );

    CleanupStack::Pop( self );

    return self;

    }

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

// CWmDrmDb::NewLC

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

//

CWmDrmDb* CWmDrmDb::NewLC( CWmDrmServer* aServer )

    {

    LOGFN( "CWmDrmDb::NewLC" );

    CWmDrmDb* self( new( ELeave ) CWmDrmDb( aServer ) );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CWmDrmDb::~CWmDrmDb

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

//

CWmDrmDb::~CWmDrmDb()

    {

    LOGFN( "CWmDrmDb::~CWmDrmDb" );

    TInt error( KErrNone );

    if ( IsActive() )

        {

        Cancel();

        }

    // Checks if there are prepared SQL operations that need to be 

    // committed before the object is destroyed.

    TRAP( error, CheckDatabaseCommitL( ETrue ) );

    delete iData;

    iEnumerateNamespaceStmt.Close();

    iDatabase.Close();

    if ( iWmDrmRightsConfigFound )

		{

		iDatabase2.Close();

		}

    }

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

// CWmDrmDb::RunL

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

//

void CWmDrmDb::RunL()

    {

    LOGFN( "CWmDrmDb::RunL()" );

    switch ( iStatus.Int() )

        {

        case KErrNone:

            // Normal completition

        case KErrUnderflow:

            // Time has already passed.

        case KErrAbort:

            // System time changed

            CheckDatabaseCommitL( ETrue );

            break;

        default:

            // Some other (real) error

            // Handled in RunError

            User::Leave( iStatus.Int() );

        }

    }

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

// CWmDrmDb::RunError

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

//

#if defined( _DEBUG ) || defined( _LOGGING )

TInt CWmDrmDb::RunError( TInt aError )

#else

TInt CWmDrmDb::RunError( TInt /* aError */ )

#endif

    {

    LOG2( "CWmDrmDb::RunError %d", aError );

    // Continue normally and return KErrNone.

    return KErrNone;    

    }

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

// CDRMConsume:: Activate

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

void CWmDrmDb::Activate()

    {

    LOGFN( "CWmDrmDb::Activate()" );

    // Activate one minute timer

    After( TTimeIntervalMicroSeconds32( KSixtySeconds * 1000000 ) );

    }

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

// CWmDrmDb::InitStoreL 

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

//

void CWmDrmDb::InitStoreL( 

    const TDesC8& aStore,

    TBool /*aCreateIfMissing*/ )

    {

    LOGFN( "CWmDrmDb::InitStoreL" );

    if ( aStore.CompareC( KHds ) == 0 )

        {

        if ( iWmDrmRightsConfigFound )

            {

            CreateDatabaseL( iDatabasePath, iDatabase, EFalse );

            CreateDatabaseL( iDatabasePath2, iDatabase2, ETrue );

            }

        else

            {

            CreateDatabaseL( iDatabasePath, iDatabase, EFalse );

            }

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    }

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

// CWmDrmDb::InitNameSpaceL 

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

//    

void CWmDrmDb::InitNameSpaceL( 

    const TDesC8& /*aStore*/,

    const TDesC8& aNamespace,

    TBool /*aCreateIfMissing*/ )

    {

    LOGFN( "CWmDrmDb::InitializeL" );

    TWmDrmTableType tableType( TableTypeL( aNamespace ) );

    if ( ( tableType == EWmDrmLicenseTable ) && iWmDrmRightsConfigFound )

    		{  

    		CreateTableL( tableType, iDatabase2 );

    		}

    else

    		{		

  			CreateTableL( tableType, iDatabase );

  			}

    }

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

// CWmDrmDb::RemoveStoreL 

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

//

void CWmDrmDb::RemoveStoreL( const TDesC8& aStore )

    {

    LOGFN( "CWmDrmDb::RemoveStoreL" );

    if ( aStore.CompareC( KHds ) == 0 )

        {

        // Delete databases

        iDatabase.Close();

        User::LeaveIfError( RSqlDatabase::Delete( iDatabasePath ) );

        // If WM DRM rights storing configuration is found -> delete also

        // the database on the internal mass drive.

        if ( iWmDrmRightsConfigFound )

            {

            iDatabase2.Close();

            User::LeaveIfError( RSqlDatabase::Delete( iDatabasePath2 ) );

            CreateDatabaseL( iDatabasePath, iDatabase, EFalse );

            CreateDatabaseL( iDatabasePath2, iDatabase2, ETrue );

            }

        else

            {

            CreateDatabaseL( iDatabasePath, iDatabase, EFalse );

            }

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    }

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

// CWmDrmDb::RemoveNameSpaceL 

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

//

void CWmDrmDb::RemoveNameSpaceL( 

    const TDesC8& /*aStore*/,

    const TDesC8& aNamespace )

    {

    LOGFN( "CWmDrmDb::RemoveNameSpaceL" );

    TWmDrmTableType tableType( TableTypeL( aNamespace ) );

    DeleteTableL( tableType );

    if ( ( tableType == EWmDrmLicenseTable ) && iWmDrmRightsConfigFound )

    		{  

    		CreateTableL( tableType, iDatabase2 );

    		}

    else

    		{			

  			CreateTableL( tableType, iDatabase );

  			}

    }

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

// CWmDrmDb::DeleteLicenseStoreL

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

//

void CWmDrmDb::DeleteLicenseStoreL()

    {

    LOGFN( "CWmDrmDb::DeleteLicenseStoreL" );

   	DeleteTableL( EWmDrmLicenseTable );

    DeleteTableL( EWmDrmSecureTable );

    DeleteTableL( EWmDrmSyncTable );

    if ( iWmDrmRightsConfigFound )

    		{

    		CreateTableL( EWmDrmLicenseTable, iDatabase2 );

   			}

    else

    		{

    		CreateTableL( EWmDrmLicenseTable, iDatabase );

    		}

    CreateTableL( EWmDrmSecureTable, iDatabase );

	CreateTableL( EWmDrmSyncTable, iDatabase );		

    }

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

// CWmDrmDb::CreateRecordL

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

//

void CWmDrmDb::CreateRecordL(   

    const TDesC8& /*aStore*/,

    const TDesC8& aNamespace,

    const TDesC8& aHashKey,

    const TDesC8& aUniqueKey,

    const TInt&   aSize )

    {

    LOGFN( "CWmDrmDb::CreateRecordL" );

    TPtrC statementString( NULL, 0 );

    // Check if we should begin transaction, cache operation or commit

    // cached operations 

    CheckDatabaseCommitL( EFalse );

    // First, find the table where record should be created

    TWmDrmTableType tableType( TableTypeL( aNamespace ) );

    // Update the dummy database file at this point.

    if ( iWmDrmRightsConfigFound && ( tableType == EWmDrmLicenseTable ) )

        {

        iServer->DataStore()->UpdateDummyDbFileL( aSize, ETrue );

        }

    else 

    	{

    	iServer->DataStore()->UpdateDummyDbFileL( aSize, EFalse );

    	} 	    

    // bind sql statement to database

    RSqlStatement stmt;

    CleanupClosePushL( stmt );

    //Select correct insert string

    switch ( tableType )

        {

        case EWmDrmLicenseTable:

            statementString.Set( KInsertLicenseString().Ptr(), 

                                 KInsertLicenseString().Length() );

            if ( iWmDrmRightsConfigFound )

                {

                stmt.PrepareL( iDatabase2, statementString );

                }

            else 

                {

                stmt.PrepareL( iDatabase, statementString );

                }           

            break;

        case EWmDrmSecureTable:

            statementString.Set( KInsertSecureString().Ptr(), 

                                 KInsertSecureString().Length() );

            stmt.PrepareL( iDatabase, statementString );                     

            break;

        case EWmDrmSyncTable:

            statementString.Set( KInsertSyncString().Ptr(), 

                                 KInsertSyncString().Length() );        

        	stmt.PrepareL( iDatabase, statementString );       

            break;

        case EWmDrmMeteringTable:

            statementString.Set( KInsertMeteringString().Ptr(), 

                                 KInsertMeteringString().Length() );

            stmt.PrepareL( iDatabase, statementString );                           

            break;

        default:

            User::Leave( KErrArgument );

            break;

        }

    // Get index of hash key parameter

    TInt hashKeyIndex( stmt.ParameterIndex( KHashKeyParameter ) );

    User::LeaveIfError( hashKeyIndex );

    // Replace hash key parameter

    User::LeaveIfError( stmt.BindBinary( hashKeyIndex, aHashKey ) );

    // Get index of unique key parameter

    TInt uniqueKeyIndex( stmt.ParameterIndex( KUniqueKeyParameter ) );

    User::LeaveIfError( uniqueKeyIndex );

    // Replace unique key parameter

    User::LeaveIfError( stmt.BindBinary( uniqueKeyIndex, aUniqueKey ) );

    TInt err( KErrNone );

    // Execute SQL statement

    err = stmt.Exec();

    if ( err == KSqlErrConstraint )

        {

        User::Leave( KErrAlreadyExists );

        }

    User::LeaveIfError( err );

    // Close SQL statement

    CleanupStack::PopAndDestroy( &stmt );

    // Update the dummy database file at this point.

    if ( iWmDrmRightsConfigFound && ( tableType == EWmDrmLicenseTable ) )

        {

        iServer->DataStore()->UpdateDummyDbFileL( 0, ETrue );

        }

    else 

    	{    

    	iServer->DataStore()->UpdateDummyDbFileL( 0, EFalse );

    	}

    iAmountOperationsWithoutCommit++;	

    }

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

// CWmDrmDb::ReadRecordL

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

//

void CWmDrmDb::ReadRecordL(  

    const TDesC8& /*aStore*/,

    const TDesC8& aNamespace,

    const TDesC8& aHashKey,

    const TDesC8& aUniqueKey )

    {

    LOGFN( "CWmDrmDb::ReadRecordL" );