/*

* Copyright (c) 2003 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 DRM Rights Database

*

*/

// INCLUDE FILES

#include <e32std.h>     // RPointerArray

#include <e32def.h>     // Type definitions

#include <hash.h>       // MD5 Algorithm

// #include <SysUtil.h>    // Disk space checking

#include <f32file.h>

#include <s32strm.h>

#include <s32file.h>

#include <caf/caf.h>

#include <caf/cafplatform.h>

#include <symmetric.h>  // AES128CBC

#include <DcfRep.h>

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#endif

#include "DRMCommon.h"  // DRM Error messages

#include "drmrightsdb.h"

#include "DRMRightsData.h"

#include "DRMCommonData.h"

#include "DrmPermission.h"

#include "DrmConstraint.h"

#include "DRMRightsCleaner.h"

#include "DRMRightsServer.h"

#include "DrmKeyStorage.h"

#include "utf.h" // charconv, ConvertFromUnicodeToUtf8L

#include "drmlog.h"

#include "DRMRightsServer.h"

#ifdef RD_DRM_RIGHTS_MANAGER_REMOVAL

#include "DRMClockClient.h"

#endif // RD_DRM_RIGHTS_MANAGER_REMOVAL

/*

#include "flogger.h"

_LIT( KLogDir, "drm");

_LIT( KLogName, "backup.log");

*/

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

#ifdef RD_MULTIPLE_DRIVE

// Backup Directory

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

#endif

_LIT(KJavaExtension, ".jar");

_LIT(KSISExtension, ".sis");

_LIT(KROExtension, ".ro");

_LIT(KXmlExtension, ".xml");

#ifdef RD_MULTIPLE_DRIVE

_LIT(KCIDListTempDir, "%c:\\system\\temp\\");

#else

_LIT(KCIDListTempDir, "c:\\system\\temp\\");

#endif

_LIT(KRODirName, "DomainROs\\");

_LIT(KCorruptionFlagFile, "invalid");

#ifdef __DRM_OMA2

const TInt KMaxUDTDataSize = 256;

const TInt KDeviceDataSize = 256;

const TInt KDeviceDataBlock = 128;

#else

const TInt KMaxUDTDataSize = 0;

const TInt KDeviceDataSize = 0;

const TInt KDeviceDataBlock = 0;

#endif

const TInt KUdtDataPos = 4 + KDeviceDataSize;

const TInt KEncryptionKeySize = 16;

const TInt KMaxEncryptionSize = 8192;

const TInt KMaxUpdateTime = 3000000; // consider updates to be finished within

                                     // three seconds

const TUint32 KMaxTIntVal = 2147483647; // 2^31-1

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

LOCAL_C void CleanupData( TAny* aPtr );

LOCAL_C void WriteIntToBlock( TInt aValue, TDes8& aBlock, TInt aOffset );

LOCAL_C void DeleteObject( TAny* aObject );

// FORWARD DECLARATIONS

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

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

// CleanupData

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

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

//

LOCAL_C void CleanupData( TAny* aPtr )

    {

    CDRMRightsDB* rdb = reinterpret_cast<CDRMRightsDB*>( aPtr );

    rdb->CleanUdtData();

    }

LOCAL_C void WriteIntToBlock( TInt aValue, TDes8& aBlock, TInt aOffset )

    {

    aBlock[aOffset] =     (aValue & 0xff000000) >> 24;

    aBlock[aOffset + 1] = (aValue & 0x00ff0000) >> 16;

    aBlock[aOffset + 2] = (aValue & 0x0000ff00) >> 8;

    aBlock[aOffset + 3] = (aValue & 0x000000ff);

    }

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

// DeleteObject

// Deletes the file by TFileName presented by aHandle

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

//

LOCAL_C void DeleteObject( TAny* aObject )

    {

    __ASSERT_DEBUG( aObject, User::Panic( _L( "DeleteObject" ), KErrArgument ) );

    MDrmKeyStorage* object = reinterpret_cast< MDrmKeyStorage* >( aObject );

    delete object;

    object = NULL;

    }

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

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

// CDRMRightsDB::CDRMRightsDB

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

// might leave.

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

//

CDRMRightsDB::CDRMRightsDB( RFs& aFs, CDRMRightsServer* aServer ) :

    iFileServer( aFs ),

    iImei( NULL ),

    iLastUpdate( Time::NullTTime() ),

    iRightsServer( aServer )    

    {

    };

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

// CDRMRightsDB::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CDRMRightsDB::ConstructL( const TDesC& aDatabasePath,

                               const TDesC8& aKey,

                               const TDesC& aImei )

    {

    TFileName name;

    TUint attr;

    DRMLOG( _L( "RDB starting..." ) );

    iDbPath = aDatabasePath.AllocL();

    // create an instance of the Hash algorithm class

    iHasher = CMD5::NewL();

    // store the key

    iKey = aKey.AllocL();

    // serial number

    iImei = aImei.AllocL();

    name.Copy( *iDbPath );

    name.Append( KCorruptionFlagFile );

    if ( iFileServer.Att( name, attr ) == KErrNone )

        {

        iFileServer.RmDir( name );

        iFileServer.Delete( name );

        DeleteDBL();

        }

    InitializeDatabaseL();

    };

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

// CDRMRightsDB::NewLC

// Two-phased constructor.

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

//

CDRMRightsDB* CDRMRightsDB::NewLC( RFs& aFs,

                                   const TDesC& aDatabasePath,

                                   const TDesC8& aKey,

                                   const TDesC& aImei,

                                   CDRMRightsServer* aServer )

    {

    CDRMRightsDB* self = new( ELeave ) CDRMRightsDB( aFs, aServer );

    CleanupStack::PushL( self );

    self->ConstructL( aDatabasePath, aKey, aImei );

    return self;

    };

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

// CDRMRightsDB::NewL

// Two-phased constructor.

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

//

CDRMRightsDB* CDRMRightsDB::NewL( RFs& aFs,

                                  const TDesC& aDatabaseFile,

                                  const TDesC8& aKey,

                                  const TDesC& aImei,

                                  CDRMRightsServer* aServer )

    {

    CDRMRightsDB* self = NewLC( aFs, aDatabaseFile, aKey, aImei, aServer );

    CleanupStack::Pop();

    return self;

    };

// Destructor

CDRMRightsDB::~CDRMRightsDB()

    {

    if( iHasher )

        {

        delete iHasher;

        iHasher = NULL;

        }

    if( iDbPath )

        {

        delete iDbPath;

        iDbPath = NULL;

        }

    if( iKey )

        {

        delete iKey;

        iKey = NULL;

        }

    if( iImei )

        {

        delete iImei;

        iImei = NULL;

        }

    iMemStream.Close();

    DRMLOG( _L( "RDB Closing." ) );

    };

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

// CDRMRightsDB::GetDBEntryByContentIDL

// returns the rights objects connected to aContentID

// (other items were commented in a header).

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

//

void CDRMRightsDB::GetDBEntryByContentIDL(

    const TDesC8& aContentID,

    RPointerArray<CDRMPermission>& aRightsList)

    {

    TFileName path;

    TInt error = KErrNone;

    CDRMRightsData* rights = NULL;

#ifdef RD_DRM_RIGHTS_MANAGER_REMOVAL

    TTime time;

    TBool deleteAllowed = EFalse;

    TInt timeZone = 0;

    DRMClock::ESecurityLevel securityLevel;

#endif // RD_DRM_RIGHTS_MANAGER_REMOVAL

    GetRightsFileNameL( aContentID, path);

#ifdef RD_DRM_RIGHTS_MANAGER_REMOVAL

    // Get the secure time:

    RDRMClockClient client;

    error = client.Connect();

    if( !error )

        {

        client.GetSecureTime( time, timeZone, securityLevel);

        client.Close();

        if( securityLevel == DRMClock::KInsecure )

            {

            time = Time::NullTTime();

            }

        }

    else

        {

        time = Time::NullTTime();

        }

    // Delete expired:

    TRAP_IGNORE( deleteAllowed = DeleteExpiredL( path, time, aContentID ) );

    // Check if it's possible to delete the file as well

    if( deleteAllowed )

        {

        iFileServer.Delete( path );

        }

    error = KErrNone;

#endif // RD_DRM_RIGHTS_MANAGER_REMOVAL

    TRAP( error, rights = CDRMRightsData::OpenL( path, iFileServer ) );

    if( rights )

        {

        CleanupStack::PushL( rights );

        }

    else

        {

        if( error == KErrNotFound )

            {

            User::Leave( KErrCANoRights );

            }

        User::Leave( error );

        }

    rights->FetchAllPermissionsL( aRightsList );

    CleanupStack::PopAndDestroy(); // rights

    };

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

// CDRMRightsDB::GetDBEntryByContentIDL

// returns the rights object connected to aContentID and aUniqueID

// (other items were commented in a header).

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

//

CDRMPermission* CDRMRightsDB::GetDBEntryByContentIDL(

    const TDesC8& aContentID,

    const TDRMUniqueID aUniqueID )

    {

    TFileName path;

    TInt error = KErrNone;

    CDRMRightsData* rights = NULL;

    CDRMPermission* ro = NULL;

    if( aUniqueID > KMaxTIntVal )

        {

        User::Leave( KErrArgument );

        }

    GetRightsFileNameL( aContentID, path);

    TRAP( error, rights = CDRMRightsData::OpenL( path, iFileServer ) );

    if( rights )

        {

        CleanupStack::PushL( rights );

        }

    else

        {

        if( error == KErrNotFound )

            {

            User::Leave( KErrCANoRights );

            }

        User::Leave( error );

        }

    ro = CDRMPermission::NewLC();

    rights->FetchPermissionL( *ro, aUniqueID );

    CleanupStack::Pop(); // ro

    CleanupStack::PopAndDestroy(); // rights

    return ro;

    };

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

// CDRMRightsDB::AddDBEntryL

// adds a new rights object into the database and uses the given aUniqueID if

// possible, if not it generates a new one

// (other items were commented in a header).

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

//

void CDRMRightsDB::AddDBEntryL( const TDesC8& aContentID,

                                CDRMPermission& aRightsObject,

                                const TDesC8& aEncryptionKey,

                                TDRMUniqueID& aUniqueID )

    {

    TFileName path;

    TInt error = KErrNone;

    CDRMRightsData* rights = NULL;

    TBuf8<16> nullDesc;

    TBuf<16> nullDesc2;

    HBufC8* oldKey = NULL;

    DRMLOG( _L( "CDRMRightsDB::AddDBEntryL ->" ) );

    // Indicate that the DB is updated

    iLastUpdate.HomeTime();

    // the key can either be empty or it can be 16 characters:

    if( !( aEncryptionKey.Length() == KEncryptionKeySize || aEncryptionKey.Length() == 0 ) )

        {

        User::Leave(KErrArgument);

        }

    TBuf8<16> keyStore = aEncryptionKey;

    // TBuf8<16> authStore = aAuthenticationSeed

    // Encrypt the key

    ModifyKey( keyStore );

    // Modify also the authentication seed

    // ModifyKey( authStore )

    GetRightsFileNameL( aContentID, path);

    TRAP( error, rights = CDRMRightsData::OpenL( path, iFileServer ) );

    if( rights )

        {

        CleanupStack::PushL( rights );

        // Check that the keys match, if not leave with KErrArgument

        oldKey = rights->GetKeyL();

        if ( oldKey != NULL )

            {

            CleanupStack::PushL( oldKey );

            if( oldKey->Compare(keyStore) )

                {

                User::Leave(KErrArgument);

                }

            CleanupStack::PopAndDestroy( oldKey );

            }

        }

    if( error == KErrNotFound )

        {

        // This would need the other info if it was available:

        CDRMCommonData* data = CDRMCommonData::NewL( aContentID, nullDesc, aRightsObject.iRiId, nullDesc2, nullDesc );

        rights = CDRMRightsData::NewLC( data, keyStore, path, iFileServer );

        }

    else

        {

        User::LeaveIfError( error );

        }

    // Store the RO:

    rights->StoreNewPermissionL( aRightsObject, aUniqueID );

    CleanupStack::PopAndDestroy(); // rights

    DRMLOG( _L( "CDRMRightsDB::AddDBEntryL <-" ) );

    };

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

// CDRMRightsDB::DeleteDBEntryL

// deletes the rights object connected to aContentID and aUniqueID

// (other items were commented in a header).

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

//

void CDRMRightsDB::DeleteDBEntryL( const TDesC8& aContentID,

                                   const TDRMUniqueID aUniqueID )

    {

    TFileName path;

    TInt error = KErrNone;

    CDRMRightsData* rights = NULL;

    DRMLOG( _L( "CDRMRightsDB::DeleteDBEntryL ->" ) );

    if( aUniqueID > KMaxTIntVal )

        {

        User::Leave( KErrArgument );

        }

    GetRightsFileNameL( aContentID, path);

    TRAP( error, rights = CDRMRightsData::OpenL( path, iFileServer ) );

    if( rights )

        {

        CleanupStack::PushL( rights );

        }

    else

        {

        if( error == KErrNotFound )

            {

            User::Leave( DRMCommon::ENoRights );

            }

        User::Leave( error );

        }

    // Indicate that the DB is updated

    iLastUpdate.HomeTime();

    rights->DeletePermissionL( aUniqueID );

    CleanupStack::PopAndDestroy(); // rights

    // Check if the file can be deleted:

    CheckCleanup( path );

    DRMLOG( _L( "CDRMRightsDB::DeleteDBEntryL <-" ) );

    };