/*

* 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:  Client side class implementation

*

*/

// INCLUDE FILES

#include <s32file.h>

#include <etelmm.h>

#include <featmgr.h>

#include "DRMRightsClient.h"

#include "DRMEngineClientServer.h"

#include "DrmPermission.h"

#include "DrmAsset.h"

#include "drmlog.h"

#ifdef __DRM_FULL

#include "rdrmhelper.h"

#endif

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

_LIT( KServerFileName, "rightsserver.exe" );

_LIT( KRightsServerStarterSemaphore, "RightsServerStarterSemaphore" );

// Maximum number of message slots that we use

LOCAL_C const TInt KMaxMessageSlots = 4;

// Try start the server only once. If it doesn't work, it doesn't work.

LOCAL_C const TUint8 KStartupCount = 1;

// MODULE DATA STRUCTURES

struct TDRMFileDeletion

    {

    TDRMFileDeletion() : iName( KNullDesC ) {};

    ~TDRMFileDeletion()

        {

        if ( iName.Length() )

            {

            iFs.Delete( iName );

            }

        iFs.Close();

        }

    RFs iFs;

    TFileName iName;

    };

template< class T > struct RDRMArrayReset

    {

    RDRMArrayReset( T& aItem ) : iItem( aItem ),

                                 iCleanup( ResetAndDestroy, ( TAny* )this ) {};

    ~RDRMArrayReset() { };

    void PushL()

        {

        CleanupStack::PushL( iCleanup );

        };

    static void ResetAndDestroy( TAny* aSelf )

        {

        ( ( RDRMArrayReset< T >* )( aSelf ) )->iItem.ResetAndDestroy();

        ( ( RDRMArrayReset< T >* )( aSelf ) )->iItem.Close();

        };

    private:

        RDRMArrayReset(); // prohibit

    private:

        T& iItem;

        TCleanupItem iCleanup;

    };

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

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

// RDRMRightsClient::RDRMRightsClient

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

// might leave.

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

//

EXPORT_C RDRMRightsClient::RDRMRightsClient() :

    iPtr( NULL )

    {

    }

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

// RDRMRightsClient::~RDRMRightsClient

// Destructor.

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

//

EXPORT_C RDRMRightsClient::~RDRMRightsClient()

    {

    }

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

// RDRMRightsClient::Connect

// Opens connection to the server.

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

//

EXPORT_C TInt RDRMRightsClient::Connect()

    {

    TInt ret = KErrNone;

    TUint8 count = 0;

    const TVersion requiredVersion(

        DRMEngine::KServerMajorVersion,

        DRMEngine::KServerMinorVersion,

        DRMEngine::KServerBuildVersion );

    FOREVER

        {

        DRMLOG( _L( "RDRMRightsClient::Connect(): Create a new session" ) );

        ret = CreateSession( DRMEngine::KServerName,

                             requiredVersion,

                             KMaxMessageSlots );

        if ( ret == KErrNotFound && count < KStartupCount )

            {

            ret = StartServer();

            if ( ret )

                {

                break;

                }

            ++count;

            }

        else

            {

            break;

            }

        }

#ifdef __DRM_FULL

    TRAP( ret, FeatureManager::InitializeLibL() );

    if ( !ret && FeatureManager::FeatureSupported( KFeatureIdFfOmadrm1FullSupport ) )

        {

        // startup code, if it starts it starts if not it will be tried again.        

        RDRMHelper helper;

        TInt ignore = helper.Connect(); // Start HelperServer

        helper.Close();

        }

    if ( !ret )

        {

        FeatureManager::UnInitializeLib();

        }

#endif        

    DRMLOG2( _L( "RDRMRightsClient::Connect(): Result: %d" ), ret );

    return ret;

    }

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

// RDRMRightsClient::Close

// Closes the connection to the server.

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

//

EXPORT_C void RDRMRightsClient::Close()

    {

    DRMLOG( _L( "RDRMRightsClient::Close()" ) );

    RHandleBase::Close();

    }

EXPORT_C TInt RDRMRightsClient::StartServer()

    {

    DRMLOG( _L( "RDRMRightsClient::StartServer()" ) );

    RSemaphore semaphore;

    RSemaphore semaphore2;

    TFindServer server( DRMEngine::KServerName );

    TFullName name;

    RProcess process;

    TInt error = KErrNone;

    // "local" semaphore

     error = semaphore2.CreateGlobal( KRightsServerStarterSemaphore,   // name

                                    1 ,              // count

                                    EOwnerThread );  // owner

    if ( error == KErrAlreadyExists )

        {

        error = semaphore2.OpenGlobal( KRightsServerStarterSemaphore );

        }

    // Semaphore not created or opened, don't need to close

    if( error )

        {

        return error;

        }

    // Server updated semaphore

    error = semaphore.CreateGlobal( DRMEngine::KDRMSemaphore,   // name

                                    0 ,              // count

                                    EOwnerThread );  // owner

    if ( error == KErrAlreadyExists )

        {

        error = semaphore.OpenGlobal( DRMEngine::KDRMSemaphore );

        }

    // Semaphore not created or opened, don't need to close

    if( error )

        {

        semaphore2.Close();

        return error;

        }

    // Wait until server has done all its things.

    semaphore2.Wait();

    // Check if the server is already running.

    error = server.Next( name );

    if ( !error )

        {

        // Yep, it's already running.

        error = KErrNone;

        }

    else

        {

        error = process.Create( KServerFileName,

                                KNullDesC );

        if ( !error )

            {

            User::After( 1000 );

            process.Resume();

            process.Close();

            // Wait here for the server process startup to complete

            // server will signal the global semaphore

            semaphore.Wait();

            }

        }

    // Close both semaphores and signal the "local" one.

    semaphore.Close();

    semaphore2.Signal();

    semaphore2.Close();

    DRMLOG2( _L( "RDRMRightsClient::StartServer(): %d" ), error );

    return error;

    }

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

// RDRMRightsClient::AddRecord

// Add a new entry to the rights database.

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

//

EXPORT_C TInt RDRMRightsClient::AddRecord( const TDesC8& aCEK, // Content encryption key

                                  // The rights object which is to be added

                                  const CDRMPermission& aRightsObject,

                                  const TDesC8& aCID, // Content-ID

                                  TDRMUniqueID& aID ) // Unique ID, out-parameter

    {

    DRMLOG( _L( "RDRMRightsClient::AddRecord" ) );

    TInt error = KErrArgument;

    // Check the parameters.

    if ( aCEK.Length() )

        {

        HBufC8* rightsData = NULL;

        TRAP( error, rightsData = aRightsObject.ExportL() );

        TInt size = aRightsObject.Size();

        if ( rightsData && size > 0 )

            {

            // For C/S communications.

            TPtr8 rightsObject( NULL, 0 );

            TPtr8 uid( reinterpret_cast< TUint8* >( &aID ),

                       0,

                       sizeof( TDRMUniqueID ) );

            rightsObject.Set( const_cast< TUint8* >( rightsData->Ptr() ),

                              size,

                              size );

            // Send the message.

            error = SendReceive( DRMEngine::EAddRecord,

                             TIpcArgs( &aCID, &rightsObject, &aCEK, &uid ) );

            delete rightsData;

            rightsData = NULL;

            }

        }

    DRMLOG2( _L( "RDRMRightsClient::AddRecord: %d" ), error );

    return error;

    }

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

// RDRMRightsClient::AddProtectedRecord

// Add a protected entry to the rights database.

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

//

EXPORT_C TInt RDRMRightsClient::AddProtectedRecord(

    const TDesC8& aProtectedCek,

    TBool aDomainRecord,

    const CDRMPermission& aRightsObject,

    const TDesC8& aCID,

    TDRMUniqueID& aID ) // Unique ID, out-parameter

    {

    DRMLOG( _L( "RDRMRightsClient::AddProtectedRecord" ) );

    TInt error = KErrNone;

    TInt message = DRMEngine::EAddProtectedRecord;

    HBufC8* rightsData = NULL;

    TInt size = aRightsObject.Size();

    TPtr8 rightsObject( NULL, 0 );

    TPtr8 uid( reinterpret_cast< TUint8* >( &aID ), 0,

        sizeof( TDRMUniqueID ) );

    TPtr8 key( NULL, 0 );

    TRAP( error, rightsData = aRightsObject.ExportL() );

    if ( !error )

        {

        rightsObject.Set( const_cast< TUint8* >( rightsData->Ptr() ), size,

            size );

        if ( aDomainRecord )

            {

            message = DRMEngine::EAddDomainRecord;

            }

        error = SendReceive( message, TIpcArgs( &aCID, &rightsObject, &aProtectedCek, &uid ) );

        delete rightsData;

        rightsData = NULL;

        }

    DRMLOG2( _L( "RDRMRightsClient::AddProtectedRecord: %d" ), error );

    return error;

    }

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

// RDRMRightsClient::GetDBEntriesL

// Get a file name from the server. The file contains the rights objects,

// which are then converted to RPointerArray.

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

//

EXPORT_C void RDRMRightsClient::GetDBEntriesL( const TDesC8& aId,

                                      RPointerArray< CDRMPermission >& aRightsList )

    {

    DRMLOG( _L( "RDRMRightsClient::GetDBEntries" ) );

    if( aId.Length() )

        {

        // Temporary file name from the server.

        TDRMFileDeletion item;

        // Make sure that the array is empty.

        aRightsList.ResetAndDestroy();

        // For file operations. Destructor of TDRMFileDeletion

        // deletes the file & closes the session.

        User::LeaveIfError( item.iFs.Connect() );

        User::LeaveIfError( SendReceive( DRMEngine::EGetEntryList,

                                         TIpcArgs( &item.iName, &aId ) ) );

        // Convert the file to a list.

        FileToListL( item.iFs, item.iName, aRightsList );

        DRMLOG( _L( "RDRMRightsClient::GetDBEntries ok" ) );

        return;

        }

    // Invalid parameter.

    User::Leave( KErrArgument );

    }

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

// RDRMRightsClient::GetDbEntryL

// Get a single RO from the server.

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

//

EXPORT_C CDRMPermission* RDRMRightsClient::GetDbEntryL( const TDesC8& aContentID,

                                                 const TDRMUniqueID& aUniqueID )

    {

    DRMLOG( _L( "RDRMRightsClient::GetDbEntryL" ) );

    CDRMPermission* permission = NULL;

    TInt size = 0;

    TPckg<TInt> package( size );

    TPtrC8 uid( reinterpret_cast< TUint8* >( const_cast< TDRMUniqueID* >(

        &aUniqueID ) ), sizeof( TDRMUniqueID ) );

    User::LeaveIfError( SendReceive( DRMEngine::EGetDbEntry,

        TIpcArgs( &package, NULL, &uid, &aContentID ) ) );

    HBufC8* rightsData = HBufC8::NewMaxLC( size );

    TPtr8 objectPkg( const_cast< TUint8* >( rightsData->Ptr() ), size,

        size );

    User::LeaveIfError( SendReceive( DRMEngine::EGetPreparedData,

        TIpcArgs( &objectPkg) ) );

    permission = CDRMPermission::NewLC();

    permission->ImportL( rightsData->Des() );

    CleanupStack::Pop(); // permission

    CleanupStack::PopAndDestroy(); // Rights data

    DRMLOG( _L( "RDRMRightsClient::GetDbEntryL ok" ) );

    return permission;

    }

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

// RDRMRightsClient::DeleteDbEntry

// Deletes all rights objects associated with the given UID.

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

//

EXPORT_C TInt RDRMRightsClient::DeleteDbEntry( const TDesC8& aContentID )

    {

    DRMLOG( _L( "RDRMRightsClient::DeleteDbEntry with CID" ) );

    TInt error = KErrArgument;

    // Check the parameter.

    if ( aContentID.Length() )

        {

        return SendReceive( DRMEngine::EDeleteWithCID,

                            TIpcArgs( NULL, NULL, &aContentID ) );

        }

    return error;

    }

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

// RDRMRightsClient::DeleteDbEntry

// Delete a single rights object identified by given parameters.

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

//

EXPORT_C TInt RDRMRightsClient::DeleteDbEntry( const TDesC8& aContentID,

                                               const TDRMUniqueID& aUniqueID )

    {

    DRMLOG( _L( "RDRMRightsClient::DeleteDbEntry with CID & UID" ) );

    if ( aContentID.Length() )

        {

        // Something to do.

        // Put aUniqueID inside a descriptor.

        // Works even if its typedef is changed.

        TPtrC8 uid( reinterpret_cast< TUint8* >(

                        const_cast< TDRMUniqueID* >( &aUniqueID ) ),

                    sizeof( TDRMUniqueID ) );

        return SendReceive( DRMEngine::EDeleteRO,

                            TIpcArgs( &uid, NULL, NULL, &aContentID ) );

        }

    return KErrArgument;

    }

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

// RDRMRightsClient::ExportContentIDList

// Overloaded method: requests all content IDs to be put to a file.

// Assumes that the given descriptor represents a buffer large enough to

// contain the file name.

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

//

EXPORT_C TInt RDRMRightsClient::ExportContentIDList( TDes& aFileName )

    {

    DRMLOG( _L( "RDRMRightsClient::ExportContentIDLis" ) );

    return SendReceive( DRMEngine::EExportCIDs,

                        TIpcArgs( &aFileName ) );

    }

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

// RDRMRightsClient::ExportContentIDList

// Overloaded method: requests all content IDs to be put to a file,

// and then converts the file into RPointerArray.

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

//

EXPORT_C TInt RDRMRightsClient::ExportContentIDList( RPointerArray< HBufC8 >& aCIDList )