/*

* Copyright (c) 2003-2008 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:  This class handles all client requests.

*

*/

// INCLUDE FILES

#include <s32file.h>

#include <f32file.h>

#include <symmetric.h>

#include <rijndael.h>

#include <caf/caf.h>

#include <x509keys.h>

#include <asn1dec.h>

#include <DcfRep.h>

#include <e32math.h>

#include <utf.h>

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

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#endif

#include "Oma2Agent.h"

#include "DrmPermission.h"

#include "DRMDbSession.h"

#include "DRMEngineClientServer.h"

#include "DRMRightsServer.h"

#include "RoapStorageClient.h"

#include "OmaCrypto.h"

#include "CmlaCrypto.h"

#include "DrmKeyStorage.h"

#include "drmrightsdb.h"

#include "drmparentstorage.h"

#include "DRMDomainContext.h"

#include "DRMRIContext.h"

#include "drmenginetypedefs.h"

#include "DRMXOma.h"

#include "DRMNotifier.h"

#include "DRMEventAddRemove.h"

#include "DRMEventModify.h"

#include "DRMRightsCleaner.h"

#include "DRMActiveOperation.h"

#include "drmconsume.h"

#include "drmlog.h"

#include "DRMPointerArray.h"

#include "Base64.h"

#ifdef RD_DRM_METERING

#include "drmmeteringdbdata.h"

#endif

// NAMESPACES

using namespace DRMEngine;

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

#define REPLAYCACHE reinterpret_cast< CDRMRightsServer* >\

    (const_cast<CServer2*>(Server()))->ReplayCache()

#define DRMDB ( ( CDRMRightsServer* )( Server() ) )->Database()

#ifdef RD_DRM_METERING

#define METERINGDB reinterpret_cast< CDRMRightsServer* >\

    (const_cast<CServer2*>(Server()))->MeteringDatabase()

#endif

#define RFSSESSION ( ( CDRMRightsServer* )( Server() ) )->FileServerSession()

#define DRMNOTIFIER ( ( CDRMRightsServer* )( Server() ) )->Notifier()

#define XOMAHEADER ( ( CDRMRightsServer* )( Server() ) )->XOmaHeaders()

#define IMEI ( ( CDRMRightsServer* )( Server() ) )->GetIMEIL()

#define IMSI ( ( CDRMRightsServer* )( Server() ) )->GetIMSIL()

#define SERVER reinterpret_cast< CDRMRightsServer* >\

    (const_cast<CServer2*>(Server()))

#define IPCREAD0L( a ) aMessage.ReadL( 0, a )

#define IPCREAD1L( a ) aMessage.ReadL( 1, a )

#define IPCREAD2L( a ) aMessage.ReadL( 2, a )

#define IPCREAD3L( a ) aMessage.ReadL( 3, a )

#define IPCWRITE0L( a ) aMessage.WriteL( 0, a )

#define IPCWRITE1L( a ) aMessage.WriteL( 1, a )

#define IPCWRITE2L( a ) aMessage.WriteL( 2, a )

#define IPCWRITE3L( a ) aMessage.WriteL( 3, a )

#define IPCGETDESLEN0 aMessage.GetDesLength( 0 )

#define IPCGETDESLEN1 aMessage.GetDesLength( 1 )

#define IPCGETDESLEN2 aMessage.GetDesLength( 2 )

#define IPCGETDESLEN3 aMessage.GetDesLength( 3 )

#define IPCGETDESMAXLEN0 aMessage.GetDesMaxLength( 0 )

#define IPCGETDESMAXLEN1 aMessage.GetDesMaxLength( 1 )

#define IPCGETDESMAXLEN2 aMessage.GetDesMaxLength( 2 )

#define IPCGETDESMAXLEN3 aMessage.GetDesMaxLength( 3 )

// LOCAL CONSTANTS AND MACROS

#ifdef RD_MULTIPLE_DRIVE

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

_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

#else

_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

#endif

const TInt KMicrosecondsToSecond = 1000000;

_LIT8( KFLPrefix, "flk" );

_LIT8( KFLLongPrefix, "flk:flk" );

_LIT8( KFLSuffix, "@localhost" );

// These need to be updated if the DRM Filter / Oma1DcfCreator URI's change

// IMPORTANT IMPORTANT IMPORTANT

_LIT8( KDCMUri, "ldf:31415926535@localhost");

_LIT8( KLDFUri, "flk:flkS60_3_0_Hutchinson_2005");

_LIT8(KTimeStamp, "timeStamp");

#ifdef RD_DRM_METERING

_LIT8(KMeteringDelimiter, ":");

_LIT8(KCRLF, "\r\n" );

#endif

LOCAL_C const TUint8 KFLPrefixLength = 3;

const TUint32 KTrustedShutdownClient = 0x10205CB5;

const TUint32 KAppInstSrv = 0x101F875A;

const TInt KSanityDataLengthLow = 0;

const TInt KSanityDataLengthHigh = 32768;

// MODULE DATA STRUCTURES

NONSHARABLE_STRUCT( TDeleteFile )

    {

    RFs* iFs;

    TFileName* iFileName;

    };

// ============================ auto_handde helper class =======================

//Auto handle for easening handle release on exceptional exit situations

template<class T> class auto_handle

    {

public:

    auto_handle() {}

    auto_handle(T aHandle) : iHandle( aHandle ) {}

    auto_handle( auto_handle<T>& aHandle) : iHandle( aHandle.release() ) {}

    ~auto_handle() { iHandle.Close(); }

    const T& operator()() const { return iHandle; }

    T& operator()() { return iHandle; }

    T get() const { return iHandle; }

    T release() { T temp = iHandle; iHandle = 0; return temp; }

private:

    T iHandle;

    };

// DATA TYPES

// LOCAL FUNCTION PROTOTYPES

LOCAL_C void DeleteFile( TAny* aHandle );

LOCAL_C void DeleteObject( TAny* aObject );

LOCAL_C TTime EndTime( const TTime& aTime1, const TTime& aTime2 );

// FORWARD DECLARATIONS

LOCAL_C void ModifyRightsObjectByTimeL( CDRMPermission* aRights,

                                        TTimeIntervalMicroSeconds& aChange,

                                        TBool aModifyInsertionTime );

LOCAL_C void ModifyTimesInListL( CDRMPermissionList* aList,

                                 TTimeIntervalMicroSeconds& aChange,

                                 TBool aModifyInsertionTime );

LOCAL_C void ModifyConstraintByTime( CDRMConstraint* aConstraint,

                                     TTimeIntervalMicroSeconds& aChange );

LOCAL_C TPtrC8 ExtractElement( const TDesC8& aRights, const TDesC8& aElement,

                               TInt& aOffset );

LOCAL_C TTime Iso8601ToTime( TDesC8& aTimeString );

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

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

// SanitizeL

// Performs a sanity check on length parameters

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

//

LOCAL_C void SanitizeL( TInt aParam )

    {

    if( aParam <= KSanityDataLengthLow || aParam > KSanityDataLengthHigh )

        {

        User::Leave(KErrArgument);

        }

    }

LOCAL_C void ModifyTimesInListL( CDRMPermissionList* aList,

    TTimeIntervalMicroSeconds& aChange,

    TBool aModifyInsertionTime )

    {

    TInt i = 0;

    // Go through the whole list and run the modification for all objects

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

        {

        // Call modification for each rights object in the list

        ModifyRightsObjectByTimeL( (*aList)[i], aChange, aModifyInsertionTime );

        }

    };

LOCAL_C void ModifyRightsObjectByTimeL( CDRMPermission* aRights,

    TTimeIntervalMicroSeconds& aChange,

    TBool aModifyInsertionTime )

    {

    // If original insertion time exists and we want to change it, change it

    if ( aModifyInsertionTime && aRights->iOriginalInsertTime != Time::NullTTime() )

        {

        aRights->iOriginalInsertTime += aChange;

        }

    if ( aRights->iAvailableRights & ERightsTopLevel )

        {

        ModifyConstraintByTime( aRights->iTopLevel, aChange );

        }

    // If play rights are available, check if they need to be changed

    if ( aRights->iAvailableRights & ERightsPlay )

        {

        ModifyConstraintByTime( aRights->iPlay, aChange );

        }

    // If display rights are available, check if they need to be changed

    if ( aRights->iAvailableRights & ERightsDisplay )

        {

        ModifyConstraintByTime( aRights->iDisplay, aChange );

        }

    // If execute rights are available, check if they need to be changed

    if ( aRights->iAvailableRights & ERightsExecute )

        {

        ModifyConstraintByTime( aRights->iExecute, aChange );

        }

    // If print rights are available, check if they need to be changed

    if ( aRights->iAvailableRights & ERightsPrint )

        {

        ModifyConstraintByTime( aRights->iPrint, aChange );

        }

    };

LOCAL_C void ModifyConstraintByTime(

    CDRMConstraint* aConstraint,

    TTimeIntervalMicroSeconds& aChange )

    {

    // if start time exists, modify it

    if ( aConstraint->iActiveConstraints & EConstraintStartTime )

        {

        aConstraint->iStartTime += aChange;

        }

    // if end time exists, modify it

    if ( aConstraint->iActiveConstraints & EConstraintEndTime )

        {

        aConstraint->iEndTime += aChange;

        }

    // if activated interval exists, modify it

    if ( aConstraint->iActiveConstraints & EConstraintInterval &&

         aConstraint->iIntervalStart != Time::NullTTime() )

        {

        aConstraint->iIntervalStart += aChange;

        }

    };

LOCAL_C TPtrC8 ExtractElement( const TDesC8& aRights,

                               const TDesC8& aElement,

                               TInt& aOffset )

    {

    DRMLOG( _L("CDRMDbSession::ExtractElement") );

    TPtrC8 temp( KNullDesC8 );

    TInt startPos = ( 0 );

    TInt endPos = ( 0 );

    TInt ret( 0 );

    TInt startLength ( 0 );

    auto_handle< RBuf8 > tagToBeFound;

    // Must be nonleaving since this function is nonleaving

    ret = tagToBeFound().Create( aElement.Length() + 3 ); // max "</" aElement ">"

    if ( ret != KErrNone )

        {

        aOffset = -1;

        return KNullDesC8();

        }

    // First we try to find the start tag (as localname)

    tagToBeFound().SetLength( 0 );

    tagToBeFound().AppendFormat( _L8( "<%S" ), &aElement );

    temp.Set( aRights.Mid( aOffset ) );

    startPos = temp.Find( tagToBeFound() );

    startLength = tagToBeFound().Length();

    startPos += aOffset;

    temp.Set( aRights.Mid( startPos + startLength ) );

    // Now find the end of the start tag

    tagToBeFound().SetLength( 0 );

    tagToBeFound().Append( _L8( ">" ) ); // '>' as last

    // Define the starting point of the data after the start tag

    // and skip the '>' mark.

    startPos = startPos + startLength + temp.Find( tagToBeFound() ) + 1;

    temp.Set( aRights.Mid( startPos ) );

    // Finally find the start of the end tag

    tagToBeFound().SetLength( 0 );

    tagToBeFound().AppendFormat( _L8( "</%S" ), &aElement );

    endPos = startPos + temp.Find(tagToBeFound() );

    if ( endPos < startPos )

        {

        aOffset = -1;

        return KNullDesC8();

        }

    temp.Set( aRights.Mid(startPos, endPos - startPos) );

    aOffset = endPos;

    DRMLOG2( _L( "Calculated length %d" ), endPos - startPos);

    DRMLOG( _L( "Extracted element" ) );

    //auto_handle closes and frees allocated resources

    return temp;

    };

LOCAL_C TTime Iso8601ToTime( TDesC8& aTimeString )

    {

    DRMLOG( _L("CDRMDbSession::Iso8601ToTime") );

    TLex8 lex;

    TInt year = 0;

    TInt month = 0;

    TInt day = 0;

    TInt hour = 0;

    TInt minute = 0;

    TInt second = 0;

    TTime r = Time::NullTTime();

    TLocale l;

    TTimeIntervalSeconds offset(l.UniversalTimeOffset());

    if (aTimeString.Length() > 0)

        {

        lex = aTimeString;

        lex.Val(year);

        lex.Inc();

        lex.Val(month);

        lex.Inc();

        lex.Val(day);

        lex.Inc();

        lex.Val(hour);

        lex.Inc();

        lex.Val(minute);

        lex.Inc();

        lex.Val(second);

        r = TTime(TDateTime(year, static_cast<TMonth>(month - 1), day - 1,

                hour, minute, second, 0));

        if (lex.Get() != 'Z')

            {

            r += offset;

            }

        }

    return r;

    }

#ifdef RD_DRM_METERING

LOCAL_C HBufC8* CreateMeteringDataL( CDRMPointerArray<CDrmMeteringDbData>* meteringArray )

    {

    // Calculate buffer size of cipher data

    TInt size( sizeof( KCRLF ) );

    HBufC8* cipherData = NULL;

    TPtr8 ptr( NULL, 0 );

    _LIT8( KElementStart, "<rawMeteringReportData>");

    _LIT8( KElementEnd, "</rawMeteringReportData>");

    size = KElementStart().Size() + KElementEnd().Size();

    for( TUint i(0); i < meteringArray->Count(); i++ )

        {

        size += sizeof( ( *meteringArray)[i]->iContentId );

        if ( (*meteringArray)[i]->iParentUid &&

             (*meteringArray)[i]->iParentUid->Size() )

            {

            size += (*meteringArray)[i]->iParentUid->Size() + 1;

            }

        switch( (*meteringArray)[i]->iPermission )

            {

            case EPlay:

                size += 4;

                break;

            case EView:

            case EExecute:

                size += 7;

                break;

            case EPrint:

                size+= 5;

                break;

            default:

                break; // Not a valid permission

            }

        size += (*meteringArray)[i]->iContentId->Size();

        size += sizeof( (*meteringArray)[i]->iAccumulatedTime.Int() / 60 );

        size += sizeof( (*meteringArray)[i]->iAccumulatedTime.Int() % 60 );

        if( ( ( *meteringArray)[i]->iAccumulatedTime.Int() % 60 ) < 10 )

            {

            size++; //for precending zero for seconds..

            }

        size += sizeof( ( *meteringArray)[i]->iCount );

        size += 4 * sizeof( KMeteringDelimiter ); // ":" -delimiter

        size += sizeof( KCRLF );

        }

    cipherData = HBufC8::NewLC( size );

    ptr.Set( cipherData->Des() );

    ptr.Append( KElementStart );

    for( TUint i(0); i < meteringArray->Count(); i++ )

        {

        ptr.Append( KCRLF );

        if ( (*meteringArray)[i]->iParentUid &&

             (*meteringArray)[i]->iParentUid->Size() )

            {

            ptr.Append( *(*meteringArray)[i]->iParentUid );

            ptr.Append( _L(";") );

            }

        ptr.Append( *(*meteringArray)[i]->iContentId );

        ptr.Append( KMeteringDelimiter );

        switch( (*meteringArray)[i]->iPermission )

            {

            case EPlay:

                ptr.Append( _L("play") );

                break;

            case EView:

                ptr.Append( _L("display") );

                break;

            case EExecute:

                ptr.Append( _L("execute") );

                break;

            case EPrint:

                ptr.Append( _L("print") );

                break;

            default:

                break; // Not a valid permission

            }          // export not supported

        ptr.Append( KMeteringDelimiter );

        ptr.AppendNum( (*meteringArray)[i]->iCount );

        ptr.Append( KMeteringDelimiter );

        ptr.AppendNum( (*meteringArray)[i]->iAccumulatedTime.Int() / 60 );

        ptr.Append( KMeteringDelimiter );

        if( ( ( *meteringArray)[i]->iAccumulatedTime.Int() % 60 ) < 10 )

            {

            ptr.AppendNum( 0 ); //precending zero for seconds..

            }

        ptr.AppendNum( (*meteringArray)[i]->iAccumulatedTime.Int() % 60 );

        }

    ptr.Append( KCRLF );

    ptr.Append( KElementEnd );

    CleanupStack::Pop( cipherData );

    return cipherData;

    }

#endif

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

// DeleteFile

// Deletes the file by TFileName presented by aHandle

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

//

void DeleteFile( TAny* aHandle )

    {

    __ASSERT_DEBUG( aHandle, User::Panic( _L( "DeleteFile" ), KErrArgument ) );

    TDeleteFile* handle = reinterpret_cast< TDeleteFile* >( aHandle );

    handle->iFs->Delete( *( handle->iFileName ) );

    }

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

// DeleteObject

// Deletes the file by TFileName presented by aHandle

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

//

void DeleteObject( TAny* aObject )

    {

    __ASSERT_DEBUG( aObject, User::Panic( _L( "DeleteObject" ), KErrArgument ) );

    MDrmKeyStorage* object = reinterpret_cast< MDrmKeyStorage* >( aObject );

    delete object;

    object = NULL;

    }