/*

* Copyright (c) 2003 - 2007 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:  DRM3 Engine manages all DRM related database operations.

*

*/

// INCLUDE FILES

#include <e32std.h>

#include <e32test.h>

#include <etelmm.h>

#include <DRMTypes.h>

#include <starterclient.h>

#include <featmgr.h>

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#endif

#include "DRMRightsServer.h"

#include "drmrightsdb.h"

#include "DRMDbSession.h"

#include "DRMEngineClientServer.h"

#include "drmlog.h"

#include "DRMNotifier.h"

#include "DrmKeyStorage.h"

#include "DRMNotifierServer.h"

#include "RoapStorageServer.h"

#include "drmnotifierclientserver.h"

#include "drmroapclientserver.h"

#include "DRMXOma.h"

#include "DRMBackupObserver.h"

#include "DRMBackup.h"

#include "flogger.h"

#include "DrmRightsParser.h"

#include "DRMRights.h"

#include "DRMHelperCommon.h"

#include  "wmdrmclientwrapper.h"

#ifdef __DRM_CLOCK

#include "DRMClockServer.h"

#include "drmclockclientserver.h"

#endif

#include <utf.h>

#include <DRMIndividualConstraintExtension.h>

/*

_LIT( KLogDir, "drm");

_LIT( KLogName, "backup.log");

*/

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

LOCAL_C const TUint KMaxHeapsize = 0x7A120;

_LIT8( KImsiId,"IMSI:");

// MACROS

#ifdef _DRM_TESTING

_LIT( KDateTimeFormat, "%F%Y%M%D%H%T%S%C" );

#endif

// LOCAL CONSTANTS AND MACROS

const TUint8 KMaxStartTries = 30;

const TInt KWaitingTime = 2000000; // 2 sec

_LIT( KRightsServerThread, "RightsServer" );

#ifdef RD_MULTIPLE_DRIVE

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

_LIT( KIndividualConstraintExtensionDll, "%c:\\sys\\bin\\DRMIndividualConstraintExtension.dll" );

_LIT( KRightsDir, "%c:\\private\\101F51F2\\rdb\\" );

_LIT( KTimedReplayCacheFile, "%c:\\private\\101F51F2\\timererc.dat" );

_LIT( KPlainReplayCacheFile, "%c:\\private\\101F51F2\\plainrc.dat" );

#ifdef RD_DRM_METERING

_LIT( KMeteringDataBaseFile, "%c:\\private\\101F51F2\\meterdb.dat" );

#endif

#define USE_RO_IMPORT

#ifdef USE_RO_IMPORT

_LIT( KInternalImportDir, "%c:\\private\\101F51F2\\import\\" );

_LIT( KUserDiskImportDir, "%c:\\import\\" ); // usually embedded MMC

_LIT( KUserRemovableDiskImportDir, "%c:\\import\\" ); // usually external MMC

_LIT( KDrSuffix, ".dr" );

#endif

#else

_LIT( KRightsDir, "c:\\private\\101F51F2\\rdb\\" );

_LIT( KTimedReplayCacheFile, "c:\\private\\101F51F2\\timererc.dat" );

_LIT( KPlainReplayCacheFile, "c:\\private\\101F51F2\\plainrc.dat" );

#ifdef RD_DRM_METERING

_LIT( KMeteringDataBaseFile, "c:\\private\\101F51F2\\meterdb.dat" );

#endif

#define USE_RO_IMPORT

#ifdef USE_RO_IMPORT

_LIT( KInternalImportDir, "c:\\private\\101F51F2\\import\\" );

_LIT( KUserDiskImportDir, "e:\\import\\" );

_LIT( KDrSuffix, ".dr" );

#endif

#endif

_LIT(KWmDrmClientWrapperName, "wmdrmclientwrapper.dll");

// MODULE DATA STRUCTURES

NONSHARABLE_STRUCT( TUnloadModule )

    {

    RTelServer* iServer;

    const TDesC* iName;

    };

// LOCAL FUNCTION PROTOTYPES

LOCAL_C TInt Startup( void );

LOCAL_C void SignalClient();

LOCAL_C TInt StartDBServer( void );

#else

#define DRM_USE_SERIALNUMBER_URI

#include <mmtsy_names.h>

#endif

#ifdef DRM_USE_SERIALNUMBER_URI

LOCAL_C void DoUnloadPhoneModule( TAny* aAny );

#endif

// #define USE_RO_IMPORT

// FORWARD DECLARATIONS

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

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

// Function Startup().

// This function starts the actual DRM Rights server after initializing

// the cleanup stack and active scheduler.

// Returns: TInt: Symbian OS error code.

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

//

LOCAL_C TInt Startup( void )

    {

    TInt error = KErrNone;

    CTrapCleanup* trap = CTrapCleanup::New();

    CActiveScheduler* scheduler = new CActiveScheduler();

    if ( trap && scheduler )

        {

        CActiveScheduler::Install( scheduler );

        error = StartDBServer();

        }

    else

        {

        error = KErrNoMemory;

        }

    delete scheduler;

    scheduler = NULL;

    delete trap;

    trap = NULL;

    if ( error )

        {

        // Something went wrong. Release the client (if any).

        SignalClient();

        if ( error == KErrAlreadyExists )

            {

            error = KErrNone;

            }

        }

    return error;

    }

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

// Function SignalClient().

// Signal the waiting client (one of them if any exists).

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

//

void SignalClient( void )

    {

    RSemaphore semaphore;

    if ( !semaphore.OpenGlobal( DRMEngine::KDRMSemaphore ) )

        {

        semaphore.Signal();

        semaphore.Close();

        }

    }

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

// Function StartDBServer().

// This function starts the actual server under TRAP harness and starts

// waiting for connections. This function returns only if there has been

// errors during server startup or the server is stopped for some reason.

//

// Returns: TInt: Symbian OS error code.

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

TInt StartDBServer( void )

    {

    TInt error = KErrNone;

    CDRMRightsServer* server = NULL;

    TUint8 count = 0;

    do

        {

        DRMLOG2( _L( "RightsServer.exe: StartDBServer: %d" ), error );

        ++count;

        TRAP( error, ( server = CDRMRightsServer::NewL() ) );

        if ( error )

            {

            User::After( TTimeIntervalMicroSeconds32(KWaitingTime) );

            }

        } while( error && ( count <= KMaxStartTries ) );

    if( error )

        {

        DRMLOG2( _L( "RightsServer.exe: CDRMRightsServer::NewL failed: %d " ), error );

        // Failed

        return error;

        }

    // Release the semaphore if necessary.

    SignalClient();

    // Start waiting for connections

    CActiveScheduler::Start();

    // Dying...

    // Delete CDRMRigntsServer

    DRMLOG( _L( "RightsServer.exe: DB server dying..." ) );

    delete server;

    return KErrNone;

    }

#ifdef DRM_USE_SERIALNUMBER_URI

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

// Function DoUnloadPhoneModule

// Unload phone module

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

//

void DoUnloadPhoneModule( TAny* aAny )

    {

    __ASSERT_DEBUG( aAny, User::Invariant() );

    TUnloadModule* module = ( TUnloadModule* ) aAny;

    module->iServer->UnloadPhoneModule( *( module->iName ) );

    }

#endif

#ifdef USE_RO_IMPORT

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

// PointerArrayResetDestroyAndClose

// Template method used to push RPointerArrays to the cleanup stack. Takes

// care of deleting all pointers in the array.

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

//

template<class S>

void PointerArrayResetDestroyAndClose(TAny* aPtr)

    {

    (reinterpret_cast<RPointerArray<S>*>(aPtr))->ResetAndDestroy();

    (reinterpret_cast<RPointerArray<S>*>(aPtr))->Close();

    }

#endif

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

// CUsageUrl:

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

// CUsageUrl::CUsageUrl

// Storage class default constructor

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

//

CUsageUrl::CUsageUrl()

    {

    }

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

// CUsageUrl::~CUsageUrl

// Storage class destructor

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

//

CUsageUrl::~CUsageUrl()

    {

    delete iUrl;    

    }

// CDRMRightsServer:

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

// CDRMRightsServer::NewLC

// Two-phased constructor.

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

//

CDRMRightsServer* CDRMRightsServer::NewL()

    {

    CDRMRightsServer* self = new( ELeave ) CDRMRightsServer();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

CDRMRightsServer::~CDRMRightsServer()

    {

    DRMLOG( _L( "CDRMRightsServer::~" ) );

    delete iIMEI; iIMEI = NULL;

    delete iIMSI; iIMSI = NULL;

    delete iDb; iDb = NULL;

    iClock.Close();

    iCache.Close();

    iMeteringDb.Close();

    iFs.Close();

    iActiveCountConstraints.ResetAndDestroy();

    iActiveCountConstraints.Close();

    delete iBackupObserver;

    delete iBackupHandler;

    delete iActiveBackupClient;

    delete iDbWatcher;

#if 0

    // Close and delete the shared data client

    if( iSharedDataClient )

        {

        iSharedDataClient->Close();

        delete iSharedDataClient;

        iSharedDataClient = NULL;

        }

#endif

    if( iNotifier )

        {

        delete iNotifier; iNotifier = NULL;

        }

    iActiveUrls.ResetAndDestroy();

    //An empty semaphore

    RSemaphore semaphore;

    }

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

// CDRMRightsServer::GetSecureTime

// Fetch the time from (secure) source.

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

//

TBool CDRMRightsServer::GetSecureTime( TTime& aTime ) const

    {

    DRMClock::ESecurityLevel secLevel = DRMClock::KInsecure;

    TInt timezone( 0 );

    iClock.GetSecureTime( aTime, timezone, secLevel );

    if( secLevel == DRMClock::KSecure )

        {

        DRMLOG( _L( "CDRMRightsServer::GetSecureTime: Time is secure\r\n" ) );

        return ETrue;

        }

    DRMLOG( _L( "CDRMRightsServer::GetSecureTime: Time is not secure\r\n" ) );

    return EFalse;

    }

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

// CDRMRightsServer::Notifier

// Return a handle to DRM Notifier.

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

//

CDRMNotifier& CDRMRightsServer::Notifier()

    {

    return *iNotifier;

    }

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

// CDRMRightsServer::Notifier

// Return a handle to DRM Notifier.

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

//

CDRMRightsDB& CDRMRightsServer::Database()

    {

    return *iDb;

    }

RFs& CDRMRightsServer::FileServerSession()

    {

    return iFs;

    }

RDRMReplayCache& CDRMRightsServer::ReplayCache()

    {

    return iCache;

    }

RDrmMeteringDb& CDRMRightsServer::MeteringDatabase()

    {

    return iMeteringDb;

    }

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

// CDRMRightsServer::HandleNotifyL

// Forward the event to the database.

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

//

void CDRMRightsServer::HandleNotifyL(const TUid /*aUid*/,

                                     const TDesC& /*aKey*/,

                                     const TDesC& /*aValue*/)

    {

    /* XXX Backup via Publish/Subscribe

    __ASSERT_DEBUG( iDb, User::Invariant() );

    TInt value = -1;

    TLex16 parser( aValue );

    if ( aUid == KSDUidSystem )

        {

        // Check if it's a backup / restore status event

        if( !aKey.Compare( KBackupRestoreStatus ) )

            {

            User::LeaveIfError( parser.Val( value ) );

            if( value == 3 ) // Complete

                {

                iDb->MergeDBL();

                }

            }

        // Check if it's a drm backup restore status event

        else if ( aUid == KSDUidSystem )

            {

            if( !aKey.Compare( KDRMBackupRestoreStatus ) )

                {

                User::LeaveIfError( parser.Val( value ) );

                if( value == 1 ) // PrepareForBackup

                    {

                    TRAPD( error, iDb->BackupDBL( KNullDesC,

                                                  KNullDesC8 ) );

                    // Notify that it's done

                    User::LeaveIfError( iSharedDataClient->AssignToTemporaryFile(

                                        KSDUidSystem ) );

                    User::LeaveIfError( iSharedDataClient->SetInt(

                                        KDRMBackupRestoreStatus, 0 ) );

                    iSharedDataClient->Flush();

                    }

                }

            }

        }

    */

    }

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

// CDRMRightsServer::RunErrorL

// From CActive. Complete the request and restart the scheduler.

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

//

TInt CDRMRightsServer::RunError( TInt aError )

    {

    DRMLOG2( _L( "CDRMRightsServer::RunError: %d" ), aError );

    // Inform the client.

    if ( !Message().IsNull() )

        {

        Message().Complete( aError );

        }

    // Restart the scheduler.

    ReStart();

    // Error handled.

    return KErrNone;

    }

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

// CDRMRightsServer::NewSessionL

// Called when a client requires a new instance.

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

CSession2* CDRMRightsServer::NewSessionL( const TVersion& aVersion,

                                          const RMessage2& /*aMessage*/ ) const

    {

    DRMLOG( _L( "CDRMRightsServer::NewSessionL" ) );

    if ( ! User::QueryVersionSupported( TVersion( DRMEngine::KServerMajorVersion,

        DRMEngine::KServerMinorVersion,