/*

* Copyright (c) 2004-2010 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:  ECOM plugin for receiving OMA Rights Objects

*

*/

// INCLUDE FILES

#include <txtrich.h>                    // for CRichText

#include <DRMMessageParser.h>           // for CDrmMessageParser

#include <DRMRights.h>                  // for CDRMRights

#include <ecom/implementationproxy.h>   // for TImplementationProxy

#include <push/cpushhandlerbase.h>      // for CPushHandlerBase

#include <push/pluginkiller.h>          // for CPluginKiller

#include <push/pushmessage.h>           // for CPushMessage

#include <RoapEng.h>                    // for CRoapEng

#include <RoapEngBase.h>

#include <RoapObserver.h>

#include <centralrepository.h>          // link against centralrepository.lib

#include <msvuids.h>

#include <msvids.h>

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#endif

#include <uri16.h>                          // TUriParser16

#include <data_caging_path_literals.hrh>    // KDC_MTM_RESOURCE_DIR

#include <uriutils.h>                       // UriUtils and so on

#include <RoHandler.rsg>                    // for R_QTN_DRM_MGR_INB_TITLE

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

#include "CRoHandler.h"

#include "RoMtmCli.h"                       // for CRightsObjectMtmClient

#include "RoapSyncWrapper.h"

#include "rohandlerdmgrwrapper.h"

#include "rohandlerinternalcrkeys.h"

#ifdef _DEBUG

#define DRMDEBUGLIT( a, b ) _LIT( a, b )

#define DRMDEBUG( a ) RDebug::Print( a )

#define DRMDEBUG2( a, b ) RDebug::Print( a, b )

_LIT( KRoLogDir, "DRM" );

_LIT( KRoLogFile, "RoHandler.log" );

#define LOG( a ) RFileLogger::Write( KRoLogDir(), KRoLogFile(), EFileLoggingModeAppend, a );

#define LOGHEX( ptr, len ) RFileLogger::HexDump( \

    KRoLogDir(), KRoLogFile(), EFileLoggingModeAppend, _S(""), _S(""), ptr, len );

#define LOG2( a, b ) RFileLogger::WriteFormat( \

    KRoLogDir(), KRoLogFile(), EFileLoggingModeAppend, a, b );

#else

#define DRMDEBUGLIT( a, b )

#define DRMDEBUG( a )

#define DRMDEBUG2( a, b )

#define LOG( a )

#define LOGHEX( ptr, len )

#define LOG2( a, b )

#endif

using namespace Roap;

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

const TImplementationProxy ImplementationTable[] =

    {

    IMPLEMENTATION_PROXY_ENTRY(0x101F7B93, CRoHandler::NewL)

    //{{0x101F7B93}, CRoHandler::NewL}

    };

// For reading the string value of cenrep key Inbox entry visible (for

// received RO). The size of string "false" is 5.

const TInt KBooleanStringMaxSize = 5;

// MACROS

// LOCAL CONSTANTS AND MACROS

#ifdef RD_MULTIPLE_DRIVE

_LIT( KRoHandlerTriggerFilePath, "%c:\\system\\data\\" );

#else

_LIT( KDriveZ, "z:" );

_LIT( KRoHandlerTriggerFilePath, "c:\\system\\data\\" );

#endif

_LIT( KRoHandlerResourceFile, "RoHandler.rsc" );

_LIT8( KRoapTriggerElement, "roapTrigger" );

_LIT8( KWbxmlRoapTriggerElement, "\x03\x13j" );

_LIT8( KRoapTriggerRoAcquisition, "roAcquisition" );

_LIT8( KRoapTriggerMeteringReport, "meteringReport" );

_LIT8( KRoapRoPduElement, "roResponse" );

_LIT( KFalse, "false" );

_LIT( KZero, "0" );

_LIT( KRoAcquisitionPrefix, "ROA:" );

_LIT( KTriggerPrefix, "TRI:" );

// MODULE DATA STRUCTURES

// Helper class for deleting file with given filename on cleanupstack

// Note does not own its members

// Used for cleaning up saved trigger if creating trigger related message

// inbox entry fails.

NONSHARABLE_CLASS( CFileDeleter ) : public CBase

    {

public:

    static CFileDeleter* NewLC( RFs& aFs, TFileName& aFileName )

        {

        CFileDeleter* self( new ( ELeave ) CFileDeleter( aFs, aFileName ) );

        CleanupStack::PushL( self );

        return self;

        }

    inline void SetDelete()

        {

        iDeleteFileOnDestroy = ETrue;

        }

    inline void SetNoDelete()

        {

        iDeleteFileOnDestroy = EFalse;

        }

    virtual ~CFileDeleter()

        {

        if ( iDeleteFileOnDestroy )

            {

            iFs.Delete( iFileName );

            }

        }

private:

    CFileDeleter()

        {

        }

    CFileDeleter( const CFileDeleter& )

        {

        }

    CFileDeleter( RFs& aFs, TFileName& aFileName )

        : iFs( aFs ), iFileName( aFileName )

        {

        }

    CFileDeleter& operator=( const CFileDeleter& );

    TBool iDeleteFileOnDestroy;

    RFs iFs;

    TFileName iFileName;

    };

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= 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 TDesC8& aText );

LOCAL_C void WriteL( const TDesC& aText );

LOCAL_C void WriteL( const TDesC8& aText, TInt aErr );

LOCAL_C void WriteL( const TDesC& aText, TInt aErr );

LOCAL_C void WriteCurrentTimeL();

#endif

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

// Testing stuff

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

//

#ifdef _DRM_TESTING

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

    {

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

    WriteFileL( text, aFs, KLogFile );

    }

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

    {

    RFile file;

    TInt size;

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

    CleanupClosePushL( file );

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

    User::LeaveIfError( file.Write( size, text ) );

    CleanupStack::PopAndDestroy( &file );

    }

LOCAL_C void CreateLogL()

    {

    RFs fs;

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

    CleanupClosePushL( fs );

    RFile file;

    User::LeaveIfError( file.Replace( fs, _L( "c:\\CROHandler.txt" ), EFileWrite ) );

    file.Close();

    CleanupStack::PopAndDestroy( &fs );

    }

LOCAL_C void WriteL( const TDesC& aText )

    {

    RFs fs;

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

    CleanupClosePushL( fs );

    HBufC8* text = HBufC8::NewLC( 1000 );

    TPtr8 textptr( text->Des() );

    textptr.Append( aText );

    textptr.Append( _L8( "\r\n" ) );

    WriteLogL( textptr, fs );

    CleanupStack::PopAndDestroy( text );

    CleanupStack::PopAndDestroy( &fs );

    WriteCurrentTimeL();

    }

LOCAL_C void WriteL( const TDesC8& aText )

    {

    RFs fs;

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

    CleanupClosePushL( fs );

    HBufC8* text = HBufC8::NewLC( 1000 );

    TPtr8 textptr( text->Des() );

    textptr.Append( aText );

    textptr.Append( _L8( "\r\n" ) );

    WriteLogL( textptr, fs );

    CleanupStack::PopAndDestroy( text );

    CleanupStack::PopAndDestroy( &fs );

    WriteCurrentTimeL();

    }

LOCAL_C void WriteL( const TDesC8& aText, TInt aErr )

    {

    _LIT8( KErr, ": %d" );

    HBufC8* text = HBufC8::NewLC( 1000 + 20 );

    TBuf8<20> num;

    TPtr8 textptr( text->Des() );

    textptr.Append( aText );

    num.Format( KErr(), aErr );

    textptr.Append( num );

    WriteL( textptr );

    CleanupStack::PopAndDestroy( text );

    }

LOCAL_C void WriteL( const TDesC& aText, TInt aErr )

    {

    _LIT8( KErr, ": %d" );

    HBufC8* text = HBufC8::NewLC( 1000+20 );

    TBuf8<20> num;

    TPtr8 textptr( text->Des() );

    textptr.Append( aText );

    num.Format( KErr(), aErr );

    textptr.Append( num );

    WriteL( textptr );

    CleanupStack::PopAndDestroy( text );

    }

LOCAL_C void WriteCurrentTimeL()

    {

    RFs fs;

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

    CleanupClosePushL( fs );

    HBufC8* text = HBufC8::NewLC( 100 );

    TPtr8 textptr( text->Des() );

    // Date and Time display

    TTime time;

    time.HomeTime();

    TBuf<256> dateString;

    _LIT( KDate, "%*E%*D%X%*N%*Y %1 %2 '%3" );

    time.FormatL( dateString, KDate );

    textptr.Append( _L( "\r\n\t\tData:\t" ) );

    textptr.Append( dateString );

    _LIT( KTime, "%-B%:0%J%:1%T%:2%S%:3%+B" );

    time.FormatL( dateString, KTime );

    textptr.Append( _L( "\r\n\t\tTime:\t" ) );

    textptr.Append( dateString );

    textptr.Append( _L( "\r\n" ) );

    textptr.Append( _L( "\r\n" ) );

    WriteLogL( textptr, fs );

    CleanupStack::PopAndDestroy( text );

    CleanupStack::PopAndDestroy( &fs );

    }

#endif

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

// DoResetAndDestroy

// Does RPointerArray< >->ResetAndDestroy() for the given array aPtr.

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

//

LOCAL_C void DoResetAndDestroy( TAny* aPtr )

    {

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

    delete aPtr;

    aPtr = NULL;

    }

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

// LeaveIfNullL

// Leaves with given error or with KErrArgument if aBuf is null

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

//

LOCAL_C inline void LeaveIfNullL( const TInt aRet, const HBufC8* aBuf )

    {

    if ( !aBuf )

        {

        User::LeaveIfError( aRet );

        User::Leave( KErrArgument );

        }

    }

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

// IsMeteringSupported

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

//

LOCAL_C TBool IsMeteringSupported()

    {

#ifdef RD_DRM_METERING

    return ETrue;

#else

    return EFalse;

#endif

    }

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

/*

-----------------------------------------------------------------------------

    Method: NewL

    Description: 1st phase constructor

    Return Value: new CRoHandler

    Status: Proposal

-----------------------------------------------------------------------------

*/

CRoHandler* CRoHandler::NewL

        (

        //None.

        )

    {

#ifdef _DRM_TESTING

    TRAPD( r, CreateLogL() );

    TRAP( r, WriteL( _L8( "NewL" ) ) );

#endif

    CRoHandler* self( new( ELeave ) CRoHandler() );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

#ifdef _DRM_TESTING

    TRAP( r, WriteL( _L8( "NewL-End" ) ) );

#endif

    return self;

    }

/*

-----------------------------------------------------------------------------

    Method: CRoHandler

    Description: C++ default constructor. Initialises the object

                 with zero/NULL values.

    Return Value: None.

    Status: Proposal

-----------------------------------------------------------------------------

*/

CRoHandler::CRoHandler

        (

        //None.

        )

    : CPushHandlerBase(),

    iFirstTime( ETrue ), iPushMsg( NULL ), iMsvId( NULL ),

    {

    }

/*

-----------------------------------------------------------------------------

    Method: ConstructL

    Description: Adds the AO to the Active Scheduler. Constructs iDrm object

                 then connects to drm server

    Return Value: None.

    Status: Proposal

-----------------------------------------------------------------------------

*/

void CRoHandler::ConstructL

        (

        //None.

        )

    {

#ifdef _DRM_TESTING

    TRAPD( r, WriteL( _L8( "ConstructL" ) ) );

#endif

    CRepository* repository( NULL );

    TInt err( KErrNone );

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

    // create drm

    iMessageParser = CDRMMessageParser::NewL();

    // Create wbxml trigger parser instance

    iWbxmlTriggerParser = DRM::CWbxmlRoapTriggerParser::NewL();

    // Create CMsvSession

    // new session is opened Synchronously

    iSession = CMsvSession::OpenSyncL( *this );

    iMtmReg = CClientMtmRegistry::NewL( *iSession );

    // Check if metering feature is active

    iMeteringSupported = IsMeteringSupported();

    // Check cenrep key in order to find out whether received RO

    // should be stored to inbox or not.

    TRAP( err, repository = CRepository::NewL( KCRUidRoHandler ) );

    if ( !err )

        {

        CleanupStack::PushL( repository );

        TBuf<KBooleanStringMaxSize> string;

        TInt error = repository->Get( KDRMRoHandlerInboxEntryVisible,

        string );

        // If the value of the repository key is found either "false" or

        // "0", do not store rights to an Inbox entry.

        if ( ( string.CompareF( KFalse ) == 0 ) ||

            ( string.CompareF( KZero ) == 0 ) )

        {

        iPutRightsToInbox = EFalse;

        }

    CleanupStack::PopAndDestroy( repository );

        }

#ifdef _DRM_TESTING

    TRAP( r, WriteL( _L8( "Repository->Get done" ), iPutRightsToInbox ) );

    TRAP( r, WriteL( _L8( "ConstructL-End" ) ) );

#endif

    }

/*

-----------------------------------------------------------------------------

    Method: ~CRoHandler

    Description: Calls also baseclass destructor which calls

                 REcomSession::DestroyedImplementation( iDtor_ID_Key).

    Return Value: None.

    Status: Proposal

-----------------------------------------------------------------------------

*/

CRoHandler::~CRoHandler

        (

        //None.

        )

    {

#ifdef _DRM_TESTING

    TRAPD( r, WriteL( _L8( "~CRoHandler" ) ) );

#endif

    iFs.Close();

    // Delete the necessary instance attributes

    delete iPushMsg;

    delete iMessageParser;

    delete iWbxmlTriggerParser;

    delete iParsedXmlTrigger;

    delete iMtm;

    delete iMtmReg;

    iMsvId = NULL;

    // session must be deleted last (and constructed first)

    delete iSession;