/*

* Copyright (c) 2004-2006 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 Helper Client session functionality 

*

*/

// INCLUDE FILES

#include <e32std.h>

#include <e32math.h>

#include <drmcommon.h>

#include "DRMHelperCommon.h"

#include "DRMHelperClient.h"

// LOCAL CONSTANTS AND MACROS

// Number of message slots to reserve for this client server session.

// Since we only communicate synchronously here, we never have any

// outstanding asynchronous requests.

LOCAL_C const TUint KDefaultMessageSlots = 0;

LOCAL_C const TUid KServerUid3 = {0x101F6DC5};

#ifdef __WINS__

LOCAL_C const TUint KServerMinHeapSize =  0x1000;  //  4K

LOCAL_C const TUint KServerMaxHeapSize = 0x10000;  // 64K

#endif

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

#ifdef _DRM_TESTING

LOCAL_C void WriteLogL( const TDesC8& text , RFs &aFs );

LOCAL_C void WriteFileL( const TDesC8& text , RFs &aFs , const TDesC& aName );

LOCAL_C void CreateLogL();

LOCAL_C void WriteL( const TDesC& aText );

LOCAL_C void WriteL( const TDesC8& aText );

LOCAL_C void WriteCurrentTimeL();

#endif

LOCAL_C TInt FromFileNameToUri(const TDesC16& aFileName , HBufC8*& aContentUri );

LOCAL_C TInt CheckExpiration( const TDesC8& aUri , TTime& aEndTime , TInt& aCountLeft );

LOCAL_C TInt StartServer();

LOCAL_C TInt CreateServerProcess();

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

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

// RDRMHelperClient::RDRMHelperClient

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

// might leave.

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

//

EXPORT_C RDRMHelperClient::RDRMHelperClient()

:   RSessionBase()

    {

    // No implementation required

    }

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

// RDRMHelperClient::Connect

// 

// Connect to the server session

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

//

EXPORT_C TInt RDRMHelperClient::Connect()

    {

#ifdef _DRM_TESTING

    TRAPD( err , CreateLogL() );

    if (err)

        {

        return err;

        }

    TRAP( err , WriteL(_L("Connect")) );

    if (err)

        {

        return err;

        }

    TRAP( err , WriteCurrentTimeL() );

    if (err)

        {

        return err;

        }

#endif

    TInt error = StartServer();

    if (KErrNone == error)

        {

        error = CreateSession(KDRMHelperServerName,

                              Version(),

                              KDefaultMessageSlots);

        }

    return error;

    }

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

// RDRMHelperClient::Version

// 

// return server version

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

//

EXPORT_C TVersion RDRMHelperClient::Version() const

    {

    return(TVersion(KDRMHSMajorVersionNumber,

                    KDRMHSMinorVersionNumber,

                    KDRMHSBuildVersionNumber));

    }

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

// RDRMHelperClient::SetAutomated

// 

// Register one content uri to the helper server

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

//

EXPORT_C TInt RDRMHelperClient::SetAutomated( const TDesC8& aUri , const TInt& aType ) const

    {

    TInt temp = aType;

    TPtrC8 descriptor(aUri);

    // This call waits for the server to complete the request before 

    // proceeding. 

    return SendReceive(ERegister, TIpcArgs( &descriptor, temp ) );

    }

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

// RDRMHelperClient::SetAutomated

// 

// Register one file to the helper server

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

//

EXPORT_C TInt RDRMHelperClient::SetAutomated( const TDesC16& aFileName , const TInt& aType ) const

    {

    TInt temp = aType;

    TPtrC8 descriptor( NULL , 0 );

    descriptor.Set( reinterpret_cast<const TUint8*>( aFileName.Ptr() ), aFileName.Length()*2);

    // This call waits for the server to complete the request before 

    // proceeding. 

    return SendReceive(ERegisterFile, TIpcArgs( &descriptor, temp ) );

    }

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

// RDRMHelperClient::RemoveAutomated

// 

// Register one content uri to the helper server

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

//

EXPORT_C TInt RDRMHelperClient::RemoveAutomated( const TDesC8& aUri , const TInt& aType ) const

    {

    TInt temp = aType;

    TPtrC8 descriptor(aUri);

    // This call waits for the server to complete the request before 

    // proceeding.

    return SendReceive(ERemove, TIpcArgs( &descriptor, temp ) );

    }

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

// RDRMHelperClient::RemoveAutomated

// 

// Register one file to the helper server

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

//

EXPORT_C TInt RDRMHelperClient::RemoveAutomated( const TDesC16& aFileName , const TInt& aType ) const

    {

    TInt temp = aType;

    TPtrC8 descriptor( NULL , 0 );

    descriptor.Set( reinterpret_cast<const TUint8*>( aFileName.Ptr() ), aFileName.Length()*2);

    // This call waits for the server to complete the request before 

    // proceeding. 

    return SendReceive(ERemoveFile, TIpcArgs( &descriptor ) );

    }

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

// RDRMHelperClient::IndicateIdle

// 

// Register one file to the helper server

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

//

EXPORT_C TInt RDRMHelperClient::IndicateIdle() const

    {

    return SendReceive(EIndicateIdle, TIpcArgs());

    }

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

// RDRMHelperClient::CanSetAutomated

// 

// Register one content uri to the helper server

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

//

EXPORT_C TInt RDRMHelperClient::CanSetAutomated( const TDesC8& aUri , TBool& aValue ) const

    {

    TTime endTime;

    TTime temp;

    TInt countsLeft = 0;

    TInt err = 0;

    temp.Set( KNullDate );

    endTime.Set( KNullDate );

    err = CheckExpiration( aUri , endTime , countsLeft );

    if ( endTime != temp )

        {

        aValue = ETrue;

        }

    else

        {

        aValue = EFalse;

        }

    return err;

    }

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

// RDRMHelperClient::CanSetAutomated

// 

// Register one file to the helper server

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

//

EXPORT_C TInt RDRMHelperClient::CanSetAutomated( const TDesC16& aFileName , TBool& aValue ) const

    {

    HBufC8* contentUri = NULL;

    TInt err = 0;

    err = FromFileNameToUri( aFileName , contentUri );

    if (err)

        {

        return err;

        }

    err = CanSetAutomated( contentUri->Des() , aValue );

    delete contentUri;

    return err;

    }

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

// RDRMHelperClient::IsAutomated

// 

// Register one content uri to the helper server

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

//

EXPORT_C TInt RDRMHelperClient::IsAutomated( const TDesC8& aUri , TInt& aType , TBool& aIs ) 

    {

    TPtr8 type( reinterpret_cast< TUint8* >( &aType ),

               0, 

               sizeof( TInt ) );

    TPtr8 flag( reinterpret_cast< TUint8* >( &aIs ),

               0, 

               sizeof( TInt ) );

    TPtrC8 descriptor(aUri);

    // This call waits for the server to complete the request before 

    // proceeding. 

    return SendReceive(EIsRegistered, TIpcArgs( &type, &descriptor, &flag ) );

    }

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

// RDRMHelperClient::IsAutomated

// 

// Register one file to the helper server

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

//

EXPORT_C TInt RDRMHelperClient::IsAutomated( const TDesC16& aFileName , TInt& aType , TBool& aIs ) 

    {

    TPtr8 type( reinterpret_cast< TUint8* >( &aType ),

               0, 

               sizeof( TInt ) );

    TPtr8 flag( reinterpret_cast< TUint8* >( &aIs ),

               0, 

               sizeof( TInt ) );

    TPtrC8 descriptor( NULL , 0 );

    descriptor.Set( reinterpret_cast<const TUint8*>( aFileName.Ptr() ), aFileName.Length()*2);

    // This call waits for the server to complete the request before 

    // proceeding. 

    return SendReceive(EIsRegisteredFile, TIpcArgs( &type, &descriptor, &flag ) );

    }

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

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

// StartServer

// 

// Start the helper server

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

//

LOCAL_C TInt StartServer()

    {

#ifdef _DRM_TESTING

    TRAPD( err , WriteL(_L("StartServer")) );

    if (err)

        {

        return err;

        }

    TRAP( err , WriteCurrentTimeL() );

    if (err)

        {

        return err;

        }

#endif

    TInt result = 0;

    TFindServer findHelperServer(KDRMHelperServerName);

    TFullName name;

    result = findHelperServer.Next(name);

    if (result == KErrNone)

        {

        // Server already running

        return KErrNone;

        }

    RSemaphore semaphore;       

    result = semaphore.CreateGlobal(KDRMHelperServerSemaphoreName, 0);

    if (result != KErrNone)

        {

        return  result;

        }

    result = CreateServerProcess();

    if (result != KErrNone)

        {

        semaphore.Close(); 

        return  result;

        }

    semaphore.Wait();

    semaphore.Close();       

    return  KErrNone;

    }

LOCAL_C TInt CreateServerProcess()

    {

#ifdef _DRM_TESTING

    TRAPD( err , WriteL(_L("CreateServerProcess")) );

    if (err)

        {

        return err;

        }

    TRAP( err , WriteCurrentTimeL() );

    if (err)

        {

        return err;

        }

#endif

    TInt result;

    const TUidType serverUid(KNullUid, KNullUid, KServerUid3);

#ifdef __WINS__

    RLibrary lib;

    result = lib.Load( KDRMHSServerFileName , serverUid );

    if (result != KErrNone)

        {

        return  result;

        }

#ifdef _DRM_TESTING

    TRAP( err , WriteL(_L("library is loaded")) );

    if (err)

        {

        return err;

        }

    TRAP( err , WriteCurrentTimeL() );

    if (err)

        {

        return err;

        }

#endif

    //  Get the WinsMain function

    TLibraryFunction functionWinsMain = lib.Lookup(1);

    //  Call it and cast the result to a thread function

    TThreadFunction serverThreadFunction = reinterpret_cast<TThreadFunction>(functionWinsMain());

    TName threadName(KDRMHelperServerName);

    // Append a random number to make it unique

    threadName.AppendNum(Math::Random(), EHex);

    RThread server;

    result = server.Create(threadName,   // create new server thread

                             serverThreadFunction, // thread's main function

                             KDefaultStackSize,

                             NULL,

                             &lib,

                             NULL,

                             KServerMinHeapSize,

                             KServerMaxHeapSize,

                             EOwnerProcess);

    lib.Close();    // if successful, server thread has handle to library now

    if (result != KErrNone)

        {

        return  result;

        }

#ifdef _DRM_TESTING

    TRAP( err , WriteL(_L("server thread is created")) );

    if (err)

        {

        return err;

        }

    TRAP( err , WriteCurrentTimeL() );

    if (err)

        {

        return err;

        }

#endif

    server.SetPriority(EPriorityMore);

#else

    RProcess server;

    result = server.Create( KDRMHSServerFileName, KNullDesC, serverUid);

    if (result != KErrNone)

        {

        return  result;

        }

#ifdef _DRM_TESTING

    TRAP( err , WriteL(_L("server thread is created")) );

    if (err)

        {

        return err;

        }

    TRAP( err , WriteCurrentTimeL() );

    if (err)

        {

        return err;

        }

#endif

#endif

    server.Resume();

    server.Close();

    return  KErrNone;

    }

LOCAL_C TInt FromFileNameToUri(const TDesC16& aFileName , HBufC8*& aContentUri )

    {

    DRMAuthenticated* c = NULL;

    DRMCommon::TContentProtection protection;

    HBufC8* mimeType = NULL;

    TUint dataLen = 0;

    TRAPD(err , c = DRMAuthenticated::NewL());

    if (err)

        {

        return err;

        }

    err = c->GetFileInfo(

        aFileName,

        protection,

        mimeType,

        aContentUri,

        dataLen);

    delete mimeType;

    if (err)

        {

        delete aContentUri;

        aContentUri = NULL;

        }

    return err;

    }

LOCAL_C TInt CheckExpiration( const TDesC8& aUri , TTime& aEndTime , TInt& aCountLeft )

    {

    DRMAuthenticated* c = NULL;

    CDRMRights* right = NULL;

    TRAPD( err  , c = DRMAuthenticated::NewL() );

    if (err)

        {

        return err;

        }

    err = c->GetActiveRights( aUri , 

        DRMCommon::EPlay | DRMCommon::EExecute | DRMCommon::EPrint | DRMCommon::EDisplay , 

        right );

    if (!err)

        {

        err = right->GetExpirationDetails(

            DRMCommon::EPlay | DRMCommon::EExecute | DRMCommon::EPrint | DRMCommon::EDisplay,

            aEndTime,

            aCountLeft);

        }

    delete right;

    delete c;

    return err;

    }

#ifdef _DRM_TESTING

LOCAL_C void WriteLogL( const TDesC8& text , RFs &aFs )

    {

    _LIT( KLogFile , "c:\\HSClientLog.txt" );

    WriteFileL( text , aFs , KLogFile );

    }

LOCAL_C void WriteFileL( const TDesC8& text , RFs &aFs , const TDesC& aName )

    {

    RFile file;