/*

* Copyright (c) 2004 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:

*

*/

// INCLUDE FILES

#include <e32std.h>

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#endif

#include "RoapStorageServer.h"

#include "DRMContextDB.h"

#include "RoapLog.h"

#include "drmroapclientserver.h"

#include "drmcommonclientserver.h"

#include "DrmKeyStorage.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

const TUint8 KMaxStartTries = 5;

const TInt KWaitingTime = 1000000; // 10 secs

_LIT( KRoapStorageThread, "RoapStorageServer" );

#ifdef RD_MULTIPLE_DRIVE

_LIT( KRIContextFileName, "%c:\\private\\101F51F2\\ricontexts.dat" );

_LIT( KDomainContextFileName, "%c:\\private\\101F51F2\\domaincontexts.dat" );

// File names and paths for importing keys

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

_LIT( KInputFilePattern, "%c:\\private\\101F51F2\\import\\SigningCert*" );

_LIT( KDeviceKeyFileName, "%c:\\private\\101F51F2\\import\\DevicePrivateKey.der" );

_LIT( KDeviceCertFileName, "%c:\\private\\101F51F2\\import\\DeviceCert.der" );

#else

// File names and paths for importing keys

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

_LIT( KInputFilePattern, "c:\\private\\101F51F2\\import\\SigningCert*" );

_LIT( KDeviceKeyFileName, "c:\\private\\101F51F2\\import\\DevicePrivateKey.der" );

_LIT( KDeviceCertFileName, "c:\\private\\101F51F2\\import\\DeviceCert.der" );

#endif

// MODULE DATA STRUCTURES

using Roap::KServerMajorVersion;

using Roap::KServerMinorVersion;

using Roap::KServerBuildVersion;

// LOCAL FUNCTION PROTOTYPES

LOCAL_C TInt StartRoapServer( RSemaphore& aClientSem );

// FORWARD DECLARATIONS

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

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

// Function StartRoapServer().

// 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.

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

LOCAL_C TInt StartRoapServer( RSemaphore& aClientSem )

    {

    TInt error = KErrNone;

    CRoapStorageServer* server = NULL;

    TUint8 count = 0;

    do

        {

        ++count;

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

        if ( error )

           {

           User::After( TTimeIntervalMicroSeconds32(KWaitingTime) );

           }

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

    if( error )

        {

        return error;

        }

    // Release the semaphore...

    aClientSem.Signal();

    aClientSem.Close();

    // Start waiting for connections

    CActiveScheduler::Start();

    // Delete CRoapStorageServer

    delete server;

    return KErrNone;

    }

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

// Function ReadFileL().

// Read a file into a buffer

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

LOCAL_C void ReadFileL( RFs& aFs, HBufC8*& aContent, const TDesC& aName )

    {

    TInt size = 0;

    RFile file;

    User::LeaveIfError( file.Open( aFs, aName, EFileRead ) );

    CleanupClosePushL( file );

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

    aContent = HBufC8::NewLC( size );

    TPtr8 ptr( aContent->Des() );

    User::LeaveIfError( file.Read( ptr, size) );

    CleanupStack::Pop(); // aContent

    CleanupStack::PopAndDestroy(); // file

    }

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

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

// CRoapStorageServer::NewLC

// Two-phased constructor.

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

//

CRoapStorageServer* CRoapStorageServer::NewL()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

CRoapStorageServer::~CRoapStorageServer()

    {

    iRFs.Close();

    delete iRoapStorage;

    }

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

// CRoapStorageServer::RunErrorL

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

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

//

TInt CRoapStorageServer::RunError( TInt aError )

    {

    // Inform the client.

    Message().Complete( aError );

    // Restart the scheduler.

    ReStart();

    // Error handled.

    return KErrNone;

    }

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

// CRoapStorageServer::NewSessionL

// Called when a client requires a new instance.

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

CSession2* CRoapStorageServer::NewSessionL(

    const TVersion& aVersion,

    const RMessage2& /*aMessage*/) const

    {

    RThread client;

    // Check that the versions are compatible.

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

                                                  KServerMinorVersion,

                                                  KServerBuildVersion ),

                                        aVersion ) )

        {

        // Sorry, no can do.

        User::Leave( KErrNotSupported );

        }

    return CRoapStorageSession::NewL();

    }

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

// CRoapStorageServer::CRoapStorageServer

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

// might leave.

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

//

CRoapStorageServer::CRoapStorageServer() :

    CServer2( EPriorityStandard ),

    iRoapStorage( NULL )

    {

    // Nothing

    }

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

// CRoapStorageServer::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CRoapStorageServer::ConstructL()

    {

    TInt err = KErrNone;

    User::RenameThread( KRoapStorageThread );

    StartL( Roap::KServerName );

    User::LeaveIfError(iRFs.Connect());

#ifndef RD_MULTIPLE_DRIVE

    iRoapStorage = CDRMContextDB::NewL( KRIContextFile(),

                                        KDomainContextFile(),

                                        iRFs );

#else //RD_MULTIPLE_DRIVE

    TInt driveNumber( -1 );

    TChar driveLetter;

    DriveInfo::GetDefaultDrive( DriveInfo::EDefaultSystem, driveNumber );

    iRFs.DriveToChar( driveNumber, driveLetter );

    TFileName riContextFile;

    riContextFile.Format( KRIContextFileName, (TUint)driveLetter );

    TFileName domainContextFile;

    domainContextFile.Format( KDomainContextFileName, (TUint)driveLetter );

    iRoapStorage = CDRMContextDB::NewL( riContextFile,

                                        domainContextFile,

                                        iRFs );

#endif

    TRAP( err, ImportKeysL() );

    }

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

// CRoapStorageServer::ContextDB

// Return the internal ROAP storage object

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

//

CDRMContextDB* CRoapStorageServer::ContextDB()

    {

    return iRoapStorage;

    }

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

// CRoapStorageServer::ImportKeys

// Import keys which are stored in the import directory into the private

// directory. Only one key pair plus assocated certificates can be imported

// at a time. The file names are DevicePrivateKey.der, DeviceCert.der and

// SigningCertXX.der.

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

//

void CRoapStorageServer::ImportKeysL()

    {

    MDrmKeyStorage* storage = NULL;

    HBufC8* privateKey = NULL;

    HBufC8* cert = NULL;

    RArray<TPtrC8> certChain;

    RPointerArray<HBufC8> buffers;

    TFileName fileName;

    RFile file;

    TInt i;

    CDir* dir = NULL;

    TInt err = KErrNone;

    __UHEAP_MARK;

    LOG( _L( "CRoapStorageServer::ImportKeysL" ) );

    CleanupClosePushL( buffers );

    CleanupClosePushL( certChain );

#ifndef RD_MULTIPLE_DRIVE

    ReadFileL( iRFs, privateKey, KDeviceKeyFileName );

#else //RD_MULTIPLE_DRIVE

    TFileName tempPath;

    TFileName tempPath2;

    TInt driveNumber( -1 );

    TChar driveLetter;

    DriveInfo::GetDefaultDrive( DriveInfo::EDefaultSystem, driveNumber );

    iRFs.DriveToChar( driveNumber, driveLetter );

    tempPath.Format( KDeviceKeyFileName, (TUint)driveLetter );

    ReadFileL( iRFs, privateKey, tempPath );

#endif

    CleanupStack::PushL( privateKey );

#ifndef RD_MULTIPLE_DRIVE

    ReadFileL( iRFs, cert, KDeviceCertFileName );

#else //RD_MULTIPLE_DRIVE

    tempPath2.Format( KDeviceCertFileName, (TUint)driveLetter );

    ReadFileL( iRFs, cert, tempPath2 );

#endif

    CleanupStack::PushL( cert );

    buffers.AppendL( cert );

#ifndef RD_MULTIPLE_DRIVE

    iRFs.Delete( KDeviceKeyFileName );

    iRFs.Delete( KDeviceCertFileName );

#else //RD_MULTIPLE_DRIVE

    iRFs.Delete( tempPath );

    iRFs.Delete( tempPath2 );

#endif

#ifndef RD_MULTIPLE_DRIVE

    User::LeaveIfError( iRFs.GetDir( KInputFilePattern, KEntryAttNormal,

        ESortByName, dir ) );

#else //RD_MULTIPLE_DRIVE

    tempPath.Format( KInputFilePattern, (TUint)driveLetter );

    User::LeaveIfError( iRFs.GetDir( tempPath, KEntryAttNormal,

        ESortByName, dir ) );

#endif

    CleanupStack::PushL( dir );

    for ( i = 0; i < dir->Count(); i++ )

        {

#ifndef RD_MULTIPLE_DRIVE

        fileName.Copy( KImportDir );

#else //RD_MULTIPLE_DRIVE

        tempPath.Format( KImportDir, (TUint)driveLetter );

        fileName.Copy( tempPath );

#endif

        fileName.Append( (*dir)[i].iName );

        ReadFileL( iRFs, cert, fileName );

        CleanupStack::PushL( cert );

        buffers.AppendL( cert );

        iRFs.Delete( fileName );

        }

    for ( i = 0; i < buffers.Count(); i++ )

        {

        certChain.AppendL( *( buffers[i] ) );

        }

    storage = DrmKeyStorageNewL();

    TRAP( err, storage->ImportDataL( *privateKey, certChain ) );

    delete storage;

    CleanupStack::PopAndDestroy( i + 1 ); // certs & dir

    CleanupStack::PopAndDestroy( 3 ); // privateKey, certChain, buffers

    LOG( _L( "CRoapStorageServer::ImportKeysL done" ) );

    __UHEAP_MARKEND;

    }

// ========================== OTHER EXPORTED FUNCTIONS =========================

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

// Function StartupRoapStorage().

// This function starts the actual Roap Storage

// the cleanup stack and active scheduler.

// Returns: TInt: Symbian OS error code.

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

//

TInt StartupRoapStorage( TAny* )

    {

    TInt error = KErrNone;

    CTrapCleanup* trap = CTrapCleanup::New();

    __ASSERT_ALWAYS( trap, User::Invariant() );

    CActiveScheduler* scheduler = new CActiveScheduler();

    __ASSERT_ALWAYS( scheduler, User::Invariant() );

    CActiveScheduler::Install( scheduler );

    RSemaphore clientSem;

    __ASSERT_ALWAYS( clientSem.OpenGlobal( KDRMEngCommonSemaphore ) == 0, User::Invariant() );

    error = StartRoapServer( clientSem );

    if ( error ) {

        // Server creation failed. Release the semaphore.

        // In case of successful startup, CRoapStorageServer

        // releases the semaphore.

        clientSem.Signal();

        clientSem.Close();

        }

    delete scheduler;

    scheduler = NULL;

    delete trap;

    trap = NULL;

    // __ASSERT_ALWAYS( !error, User::Invariant() );

    return KErrNone;

    }

//  End of File