/*

* Copyright (c) 2002-2009 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 CAF Agent Data class

*

*/

// INCLUDE FILES

#include <caf/caf.h>

#include <caf/cafplatform.h>

#include <caf/bitset.h>

#include <caf/attribute.h>

#include <e32test.h>

#include "DRMCommon.h"

#include "Oma2AgentData.h"

#include "Oma2AgentAttributes.h"

#include "Oma1Dcf.h"

#include "oma2dcf.h"

#include "symmetric.h"

#include "DRMRightsClient.h"

#include "DRMProtectedRoParser.h"

#include "DcfCache.h"

#include "cleanupresetanddestroy.h"

using namespace ContentAccess;

//TRACE macros

#ifdef _DEBUG

#include <e32debug.h> // RDebug

#define TRACE( x ) RDebug::Print( _L( x ) )

#define TRACE2( x, y ) RDebug::Print( _L( x ), y )

#define TRACE3( x, y, z ) RDebug::Print( _L( x ), y, z )

#else

#define TRACE( x )

#define TRACE2( x, y )

#define TRACE3( x, y, z )

#endif

// CONSTANTS

_LIT8(KMimeAudio, "audio");

_LIT8(KMimeImage, "image");

// LOCAL FUNCTION PROTOTYPES

LOCAL_C TInt MapContentShareMode( TContentShareMode aMode );

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

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

// MapContentShareMode

// Maps the CAF specific file share mode to the RFs/RFile sharing mode

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

//

LOCAL_C TInt MapContentShareMode( TContentShareMode aMode )

    {

    TInt r = EFileRead | EFileShareAny;

    switch ( aMode )

        {

        case EContentShareReadOnly:

            r = EFileRead | EFileShareReadersOnly;

            break;

        case EContentShareReadWrite:

            r = EFileRead | EFileShareReadersOrWriters;

            break;

        case EContentShareExclusive:

            r = EFileRead | EFileShareExclusive;

            break;

        }

    return r;

    }

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

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

// COma2AgentData::COma2AgentData

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

// might leave.

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

//

COma2AgentData::COma2AgentData() :

    iDcf( NULL ),

    iDataPosition( 0 ),

    iRightsStatus( KErrNone ),

    iVirtualPath( KNullDesC ),

    iCache( NULL ),

    iGroupKeyUsed( EFalse ),

    iLastFileSize( 0 )

    {

    }

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

// COma2AgentData::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void COma2AgentData::ConstructL(

    const TVirtualPathPtr& aVirtualPath,

    TContentShareMode aShareMode )

    {

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

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

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

    User::LeaveIfError( iFile.Open( iFs, aVirtualPath.URI(),

        MapContentShareMode( aShareMode ) ) );

    iDcf = CDcfCommon::NewL( iFile );

    iVirtualPath = aVirtualPath;

    User::LeaveIfError( iDcf->OpenPart( iVirtualPath.UniqueId() ) );

    InitializeL();

    }

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

//

void COma2AgentData::ConstructL(

    RFile& aFile,

    const TDesC& aUniqueId )

    {

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

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

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

    User::LeaveIfError( iFile.Duplicate( aFile ) );

    iDcf = CDcfCommon::NewL( iFile );

    User::LeaveIfError( iDcf->OpenPart( aUniqueId ) );

    InitializeL();

    iUniqueId = aUniqueId.AllocL();

    }

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

// COma2AgentData::InitializeL

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

//

void COma2AgentData::InitializeL()

    {

    TInt r = KErrNone;

    TBuf8<KDCFKeySize * 2> blocks;

    CDrmProtectedRoParser* parser;

    TInt pos;

    COma2Dcf* dcf2 = NULL;

    TInt i;

    TBool reinit = EFalse;

    TInt error = KErrNone;

    if ( iDcf->iVersion == EOma2Dcf )

        {

        dcf2 = static_cast<COma2Dcf*> ( iDcf );

        // Encrypted images are not supported, but plain ones are:

        if ( dcf2->iMimeType->Left( KMimeImage().Length() ).CompareF(

            KMimeImage ) == 0 && iDcf->iEncryptionMethod != EMethodNULL )

            {

            User::Leave( KErrNotSupported );

            }

        }

    // Set the session key for this file

    if ( iDcf->iEncryptionMethod == EMethodAES_128_CBC )

        {

        // Check if we can use the group key first

        if ( dcf2 && dcf2->iGroupId )

            {

            r = iRdb.InitializeGroupKey( *dcf2->iGroupId, *dcf2->iGroupKey,

                dcf2->iGkEncryptionMethod );

            if ( r == KErrNone )

                {

                iGroupKeyUsed = ETrue;

                }

            }

        else

            {

            r = iRdb.InitializeKey( *iDcf->iContentID );

            }

        // If the DCF contains a domain RO, try to save and use it

        if ( dcf2 && dcf2->iRightsObjects.Count() )

            {

            error = r;

            __UHEAP_MARK;

            for ( i = 0; i < dcf2->iRightsObjects.Count(); i++ )

                {

                RPointerArray<CDRMRights> rights;

                CleanupResetAndDestroyPushL( rights );

                parser = CDrmProtectedRoParser::NewL();

                CleanupStack::PushL( parser );

                // NOTE:

                // This is trapped for a reason, the file opening must not fail

                // even if the parsing of the embedded rights object fails

                // for some reason it is possible that the rights are already

                // put into the database and the leave occurs because of this,

                // also it's possible that there are existing rights

                // that work with the given content.

                TRAP( r, parser->ParseAndStoreL( *dcf2->iRightsObjects[i],

                    rights) );

                CleanupStack::PopAndDestroy( parser );

                CleanupStack::PopAndDestroy( &rights );

                if ( r == KErrNone && !reinit )

                    {

                    reinit = ETrue;

                    }

                }

            __UHEAP_MARKEND;

            if ( reinit && !iGroupKeyUsed )

                {

                r = iRdb.InitializeKey( *iDcf->iContentID );

                }

            else

                {

                r = error;

                }

            }

        if ( r != KErrCANoRights && r != KErrCANoPermission &&

            r != KErrCAPendingRights && r != KErrNone )

            {

            User::Leave( r );

            }

        iRightsStatus = r;

        }

    else if ( iDcf->iEncryptionMethod != EMethodNULL )

        {

        User::Leave( KErrNotSupported );

        }

    iCache = CDcfCache::NewL( iRdb, iFile, *iDcf, 0, 0 );

    if ( iDcf->iPadding == -1 && iRightsStatus == KErrNone )

        {

        pos = iDcf->iOffset + iDcf->iDataLength - 2 * KDCFKeySize;

        iFile.Seek( ESeekStart, pos );

        iFile.Read( blocks );

        iDcf->iPadding = iRdb.CalculatePadding( blocks );

        if ( iDcf->iPadding >= 0 )

            {

            iDcf->iPlainTextLength -= iDcf->iPadding;

            iDcf->iPlainTextLengthValid = ETrue;

            }

        }

    User::LeaveIfError( iFile.Size( iLastFileSize ) );

    }

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

// COma2AgentData::NewL

// Two-phased constructor.

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

//

COma2AgentData* COma2AgentData::NewL(

    const TVirtualPathPtr& aVirtualPath,

    TContentShareMode aShareMode )

    {

    COma2AgentData* self = NewLC( aVirtualPath, aShareMode );

    CleanupStack::Pop( self );

    return self;

    }

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

// COma2AgentData::NewLC

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

//

COma2AgentData* COma2AgentData::NewLC(

    const TVirtualPathPtr& aVirtualPath,

    TContentShareMode aShareMode )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL( aVirtualPath, aShareMode );

    return self;

    }

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

// COma2AgentData::NewL

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

//

COma2AgentData* COma2AgentData::NewL(

    RFile& aFile,

    const TDesC& aUniqueId )

    {

    COma2AgentData* self = COma2AgentData::NewLC( aFile, aUniqueId );

    CleanupStack::Pop( self );

    return self;

    }

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

// COma2AgentData::NewLC

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

//

COma2AgentData* COma2AgentData::NewLC(

    RFile& aFile,

    const TDesC& aUniqueId )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL( aFile, aUniqueId );

    return self;

    }

// Destructor

COma2AgentData::~COma2AgentData()

    {

    iRdb.Close();

    iFile.Close();

    iFs.Close();

    delete iDcf;

    delete iCache;

    delete iUniqueId;

    }

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

// COma2AgentData::DataSizeL

// Re-create the DCF because it's size may have changed.

// for progressive download etc.

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

//

void COma2AgentData::DataSizeL( TInt &aSize )

    {

    TInt fileSize = 0;

    TInt seekPos = 0;

    User::LeaveIfError( iFile.Size( fileSize ) );

    if ( iDcf )

        {

        // if the size of the file has changed update info:

        if ( fileSize != iLastFileSize )

            {

            // Delete the old dcf

            delete iDcf;

            iDcf = NULL;

            // seek the file to the beginning

            iFile.Seek( ESeekStart, seekPos );

            // Create new dcf as the size may have changed

            iDcf = CDcfCommon::NewL( iFile );

            // open the content part

            if ( iUniqueId )

                {

                User::LeaveIfError( iDcf->OpenPart( iUniqueId->Des() ) );

                }

            else

                {

                User::LeaveIfError( iDcf->OpenPart( iVirtualPath.UniqueId() ) );

                }

            // re-initialize the dcf, this updates the iLastFileSize

            InitializeL();

            }

        aSize = iDcf->iPlainTextLength;

        }

    else

        {

        User::Leave( KErrNotReady );

        }

    }

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

// COma2AgentData::EvaluateIntent

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

//

TInt COma2AgentData::EvaluateIntent( TIntent aIntent )

    {

    TInt r = KErrNone;

    // Check for a mismatch in the MIME type and the intent

    if ( ( iDcf->iMimeType->Left(

            KMimeAudio().Length() ).CompareF( KMimeAudio ) == 0 &&

            ( aIntent == EView || aIntent == EPrint || aIntent == EExecute ) )

        ||

        ( iDcf->iMimeType->Left(

            KMimeImage().Length() ).CompareF( KMimeImage ) == 0 &&

            ( aIntent == EPlay || aIntent == EExecute ) ) )

        {

        r = KErrArgument;

        }

    else if ( iDcf->iEncryptionMethod )

        {

        if ( iGroupKeyUsed )

            {

            r = iRdb.CheckConsume( aIntent,

                *( static_cast<COma2Dcf*> ( iDcf )->iGroupId ) );

            }

        else

            {

            r = iRdb.CheckConsume( aIntent, *iDcf->iContentID );

            }

        }

    return r;

    }

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

// COma2AgentData::ExecuteIntent

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

//

TInt COma2AgentData::ExecuteIntent( TIntent aIntent )

    {

    TInt r = KErrNone;

    TBuf8<KDCFKeySize> key;

    // Check for a mismatch in the MIME type and the intent

    if ( ( iDcf->iMimeType->Left(

            KMimeAudio().Length() ).CompareF( KMimeAudio ) == 0 &&

            ( aIntent == EView || aIntent == EPrint || aIntent == EExecute ) )

        ||

        ( iDcf->iMimeType->Left(

            KMimeImage().Length() ).CompareF( KMimeImage ) == 0 &&

            ( aIntent == EPlay || aIntent == EExecute ) ) )

        {

        r = KErrArgument;

        }

    else if ( iDcf->iEncryptionMethod )

        {

        // If the MIME type allows it, do the consumption

        if ( iGroupKeyUsed )

            {

            r = iRdb.Consume( aIntent,

                *( static_cast<COma2Dcf*> ( iDcf )->iGroupId ) );

            }

        else

            {

            r = iRdb.Consume( aIntent, *iDcf->iContentID );

            }

        // If the consumption succeeded, try to get the decryption key.

        // This is possible at this time because the permission is now known on

        // the server side, and the server can return the key if the

        // security level allows it. The decision is made based on the

        // used permission and the caller identity.

        if ( r == KErrNone && iRdb.GetDecryptionKey( aIntent,

            *iDcf->iContentID, key ) == KErrNone && key.Length()

            == KDCFKeySize )

            {

            iCache->SetKey( key );

            }

        }

    return r;

    }

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

// COma2AgentData::Read

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

//

TInt COma2AgentData::Read( TDes8& aDes )

    {

    return Read( aDes, aDes.MaxLength() );

    }

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

// COma2AgentData::Read

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

//

TInt COma2AgentData::Read(

    TDes8& aDes,

    TInt aLength )

    {

    return iCache->Read( iDataPosition, aDes, aLength );

    }

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

// COma2AgentData::Read

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

//

void COma2AgentData::Read(

    TDes8& aDes,

    TRequestStatus& aStatus )

    {

    TRequestStatus* status = &aStatus;

    User::RequestComplete( status, Read( aDes, aDes.MaxLength() ) );

    }

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

// COma2AgentData::Read

// asynchronous read

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

//

void COma2AgentData::Read(

    TDes8& aDes,

    TInt aLength,

    TRequestStatus& aStatus )

    {

    TRequestStatus* status = &aStatus;

    User::RequestComplete( status, Read( aDes, aLength ) );

    }

#ifdef ASYNC_READ

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

// COma2AgentData::Read

// asynchronous read (not really asynchronous)

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

//

TInt COma2AgentData::Read(

    TInt aPos,

    TDes8& aDes,

    TInt aLength,

    TRequestStatus& aStatus )

    {

    return iCache->Read( aPos, aDes, aLength, aStatus );

    }

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

// COma2AgentData::ReadCancel

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

//

void COma2AgentData::ReadCancel( TRequestStatus& aStatus )

    {

    TRACE("+ COma2AgentData::ReadCancel");

    iCache->ReadCancel( aStatus );

    TRACE("- COma2AgentData::ReadCancel");

    }

#endif

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

// COma2AgentData::Seek

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

//

TInt COma2AgentData::Seek( TSeek aMode, TInt& aPos )

    {

    TInt r = KErrNone;

    switch ( aMode )

        {

        case ESeekStart:

            break;

        case ESeekEnd:

            aPos = iDcf->iPlainTextLength + aPos;