/*

* Copyright (c) 2002 - 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:  Implementation of class representeting discrete OMA2 DCF

*

*/

// INCLUDE FILES

#include <e32const.h> // KMaxTUint32

#include <e32cmn.h> // Max, Min

#include <e32base.h>

#include <f32file.h>

#include <utf.h>

#include <featmgr.h>

#include <caf/caf.h>

#include <caf/cafplatform.h>

#include "Oma2Agent.h"

#include "oma2dcf.h"

#include "Oma2DcfPartInfo.h"

// LOCAL CONSTANTS AND MACROS

#define M4CC( a ) ( ( a[ 0 ] << 24 ) + ( a[ 1 ] << 16 ) + ( a[ 2 ] << 8 ) + a[ 3 ] )

const TUint32 KDiscreteMediaHeaders( M4CC( "odhe" ) );

const TUint32 KContainer( M4CC( "odrm" ) );

const TUint32 KContentObject( M4CC( "odda" ) );

const TUint32 KCommonHeaders( M4CC( "ohdr" ) );

const TUint32 KMutableInfo( M4CC( "mdri" ) );

const TUint32 KTransactionTracking( M4CC( "odtt" ) );

const TUint32 KRightsObject( M4CC( "odrb" ) );

const TUint32 KGroupId( M4CC( "grpi" ) );

const TUint32 KUserData( M4CC( "udta" ) );

// supported user data boxes

_LIT8( KTitle, "titl" );

_LIT8( KDescription, "dscp" );

_LIT8( KCopyright, "cprt" );

_LIT8( KAuthor, "auth" );

_LIT8( KIconUri, "icnu" );

_LIT8( KInfoURL, "infu" );

_LIT8( KPerformer, "perf" );

_LIT8( KGenre, "gnre" );

_LIT8( KRating, "rtng" );

_LIT8( KClassification, "clsf" );

_LIT8( KKeyword, "kywd" );

_LIT8( KLocationInformation, "loci" );

_LIT8( KAlbum, "albm" );

_LIT8( KRecordingYear, "yrrc" );

_LIT8( KCoverUri, "cvru" );

_LIT8( KLyricsURL, "lrcu" );

_LIT8( KMdri, "mdri" );

_LIT8( KOdtt, "odtt" );

_LIT8( KOdrb, "odrb" );

// textual headers

_LIT8( KSilentHeader, "Silent" );

_LIT8( KPreviewHeader, "Preview" );

_LIT8( KContentURLHeader, "ContentURL" );

_LIT8( KContentVersionHeader, "ContentVersion" );

_LIT8( KContentLocationHeader, "Content-Location" );

// supported custom textual headers

_LIT8( KIconUriHeader, "IconURI" );

_LIT8( KTitleHeader, "Title" );

_LIT8( KDescriptionHeader, "Description" );

_LIT8( KAuthorHeader, "Author" );

_LIT8( KCopyrightHeader, "Copyright" );

_LIT8( KInfoURLHeader, "InfoURL" );

// textual headers, methods

_LIT8( KSilentMethodOnDemand, "on-demand" );

_LIT8( KSilentMethodInAdvance, "in-advance" );

_LIT8( KPreviewMethodInstant, "instant" );

_LIT8( KPreviewMethodPreviewRights, "preview-rights" );

_LIT8( KEmptyTransactionId, "0000000000000000" );

_LIT8( KTerminator, "\0" );

_LIT8( KSeparator, ":" );

_LIT8( KParamSeparator, ";" );

const TInt KBrandingSize( 20 );

const TInt KMaxBoxHeaderSize( 16 );

const TInt KLengthBoxSize( 4 );

const TInt KLengthBoxType( 4 );

const TInt KLengthBoxSize64( 8 );

const TInt KLengthVersion( 1 );

const TInt KLengthFlags( 3 );

const TInt KLengthEncMethod( 1 );

const TInt KLengthPadType( 1 );

const TInt KLengthPlainTextSize( 8 );

const TInt KLengthDataLengthSize( 8 );

const TInt KLengthContentIdSize( 2 );

const TInt KLengthRiUrlSize( 2 );

const TInt KLengthTextHeadersSize( 2 );

const TInt KLengthTerminator( 1 );

// Smallest possible ISO based media box size

// See ISO/IEC 14496-12 and DRM-DCF-CLI-12 in OMA-TS-DRM-DCF-V2_1

const TUint32 KMinBoxSize( KLengthBoxSize + KLengthBoxType );

// Largest supported ISO based media box size

const TUint32 KMaxBoxSize( KMaxTUint32 );

const TUint KUserDataBoxMask( 0x000001 );

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

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

// ReadUint32FromBlock

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

//

LOCAL_C TUint32 ReadUint32FromBlock( const TDesC8& aBlock, TInt aOffset )

    {

    return ( aBlock[ aOffset ] << 24 ) +

        ( aBlock[ aOffset + 1 ] << 16 ) +

        ( aBlock[ aOffset + 2 ] << 8 ) +

        aBlock[ aOffset + 3 ];

    }

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

// ReadUint16FromBlock

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

//

LOCAL_C TUint16 ReadUint16FromBlock( const TDesC8& aBlock, TInt aOffset )

    {

    return ( ( aBlock[ aOffset ] << 8 ) + aBlock[ aOffset + 1 ] );

    }

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

// WriteIntToBlock

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

//

LOCAL_C void WriteIntToBlock( TInt aValue, TDes8& aBlock, TInt aOffset )

    {

    aBlock.SetLength( 4 );

    aBlock[ aOffset ] =     ( aValue & 0xff000000 ) >> 24;

    aBlock[ aOffset + 1 ] = ( aValue & 0x00ff0000 ) >> 16;

    aBlock[ aOffset + 2 ] = ( aValue & 0x0000ff00 ) >> 8;

    aBlock[ aOffset + 3 ] = ( aValue & 0x000000ff );

    }

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

// ValidateBoxSizeL

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

//

LOCAL_C void ValidateBoxSizeL(

    const TUint32 aSize,

    const TUint32 aMinSize = KMinBoxSize,

    const TUint32 aMaxSize = KMaxBoxSize )

    {

    TUint32 minSize( Max( aMinSize, KMinBoxSize) );

    TUint32 maxSize( Min( aMaxSize, KMaxBoxSize ) );

    if ( aSize < minSize )

        {

        User::Leave( KErrArgument );

        }

    if ( aSize > maxSize )

        {

        User::Leave( KErrArgument );

        }

    }

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

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

// COma2Dcf::COma2Dcf

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

// might leave.

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

//

COma2Dcf::COma2Dcf():

    iEncrytionPadding( EPaddingNone ),

    iSilentRefresh( ENoSilentRefresh ),

    iPreview( ENoPreview ),

    iPreviewParameter( NULL ),

    iSilentParameter( NULL ),

    iTextualHeaders( NULL ),

    iContentUrl( NULL ),

    iContentVersion( NULL ),

    iContentLocation( NULL ),

    iTransactionTracking( NULL ),

    iUserData( NULL ),

    iAuthor( NULL ),

    iCopyRight( NULL ),

    iInfoUri( NULL ),

    iGroupId( NULL ),

    iGroupKey( NULL ),

    iGkEncryptionMethod( EMethodNULL ),

    iMutablePart( NULL ),

    iPerformer( NULL ),

    iGenre( NULL ),

    iRatingInfo( NULL ),

    iClassificationInfo( NULL ),

    iKeyword( NULL ),

    iLocInfoName( NULL ),

    iLocInfoAstronomicalBody( NULL ),

    iLocInfoAdditionalNotes( NULL ),

    iAlbumTitle( NULL ),

    iCoverUri( NULL ),

    iLyricsURL( NULL ),

    iRecordingYear( 0 ),

    iAlbumTrack( 0 )

    {

    }

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

// COma2Dcf::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void COma2Dcf::ConstructL(

    const RFile& aFile,

    TInt aPart )

    {

    CDcfCommon::ConstructL( aFile );

    ReadPartsL();

    User::LeaveIfError( OpenPart( aPart ) );

    }

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

// COma2Dcf::NewL

// Two-phased constructor.

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

//

EXPORT_C COma2Dcf* COma2Dcf::NewL(

    const RFile& aFile,

    TInt aPart )

    {

    COma2Dcf* self( new ( ELeave ) COma2Dcf );

    CleanupStack::PushL( self );

    self->ConstructL( aFile, aPart );

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

EXPORT_C COma2Dcf::~COma2Dcf()

    {

    delete iPreviewParameter;

    delete iSilentParameter;

    delete iTextualHeaders;

    delete iContentUrl;

    delete iContentVersion;

    delete iContentLocation;

    delete iTransactionTracking;

    delete iUserData;

    delete iAuthor;

    delete iCopyRight;

    delete iInfoUri;

    delete iGroupId;

    delete iGroupKey;

    delete iPerformer;

    delete iGenre;

    delete iRatingInfo;

    delete iClassificationInfo;

    delete iKeyword;

    delete iLocInfoName;

    delete iLocInfoAstronomicalBody;

    delete iLocInfoAdditionalNotes;

    delete iAlbumTitle;

    delete iCoverUri;

    delete iLyricsURL;

    delete iMutablePart;

    iRightsObjects.ResetAndDestroy();

    iRightsObjects.Close();

    iParts.ResetAndDestroy();

    iParts.Close();

    }

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

// COma2Dcf::IsValidDcf

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

//

EXPORT_C TBool COma2Dcf::IsValidDcf(

    const TDesC8& aDcfFragment )

    {

    TBool r( EFalse );

    TInt err( KErrNone );

    if ( aDcfFragment.Length() >= KBrandingSize &&

        aDcfFragment.Left( KBrandingSize ).Compare( KOma2DcfBranding ) == 0 )

        {

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

        if ( !err && FeatureManager::FeatureSupported( KFeatureIdFfOmadrm2Support ) )

            {

            r = ETrue;

            }

        if ( !err )

            {

            FeatureManager::UnInitializeLib();

            }

        }

    return r;

    }

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

// COma2Dcf::ReadPartsL

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

//

void COma2Dcf::ReadPartsL( void )

    {

    TBuf8<KBrandingSize> buffer;

    TInt size;

    TUint32 type;

    TInt offset;

    TInt headerSize;

    COma2DcfPartInfo* part;

    User::LeaveIfError( iFile.Read( 0, buffer, KBrandingSize ) );

    if ( !IsValidDcf( buffer ) )

        {

        User::Leave( KErrArgument );

        }

    iVersion = ReadUint32FromBlock( buffer, 12 );

    offset = KBrandingSize;

    iParts.Reset();

    do

        {

        ReadBoxSizeAndTypeL( offset, size, type, headerSize );

        if ( headerSize > 0 )

            {

            part = COma2DcfPartInfo::NewL();

            part->iType = type;

            part->iSize = size;

            part->iOffset = offset;

            CleanupStack::PushL( part );

            if ( type == KContainer )

                {

                ReadPartInfoL( part, offset );

                iParts.Append( part );

                CleanupStack::Pop( part );

                }

            else if ( type == KMutableInfo )

                {

                iMutablePart = part;

                CleanupStack::Pop( part );

                ReadMutableInfoL( offset, size );

                }

            else

                {

                CleanupStack::PopAndDestroy( part );

                }

            }

        offset += size;

        }

    while ( offset < iLength && headerSize > 0 );

    delete iContentID;

    iContentID = NULL;

    delete iMimeType;

    iMimeType = NULL;

    if ( iParts.Count() == 0 ||

        iParts[ 0 ]->iContentId == NULL ||

        iParts[ 0 ]->iMimeType == NULL )

        {

        User::LeaveIfError( KErrArgument );

        }

    iContentID = iParts[ 0 ]->iContentId->AllocL();

    iMimeType = iParts[ 0 ]->iMimeType->AllocL();

    }

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

// COma2Dcf::CheckUniqueId

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

//

TInt COma2Dcf::CheckUniqueId( const TDesC& aUniqueId )

    {

    TInt r( CDcfCommon::CheckUniqueId( aUniqueId ) );

    if ( r == KErrNotFound )

        {

        HBufC8* id( NULL );

        TRAPD( err,

            id = CnvUtfConverter::ConvertFromUnicodeToUtf8L( aUniqueId ) );

        if ( err == KErrNone )

            {

            r = KErrNotFound;

            for ( TInt i( 0 );

                i < iParts.Count() && r == KErrNotFound;

                i++ )

                {

                if ( !id->Compare( *iParts[ i ]->iContentId ) )

                    {

                    r = i;

                    }

                }

            delete id;

            }

        else

            {

            r = err;

            }

        }

    return r;

    }

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

// COma2Dcf::OpenPart

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

//

TInt COma2Dcf::OpenPart(

    const TDesC& aUniqueId )

    {

    return OpenPart( CheckUniqueId( aUniqueId ) );

    }

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

// COma2Dcf::OpenPart

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

//

TInt COma2Dcf::OpenPart(

    TInt aPart )

    {

    TInt r( KErrNone );

    TInt size( 0 );

    if ( aPart >= 0 && aPart < iParts.Count() )

        {

        TRAP( r, ReadContainerL( iParts[ aPart ]->iOffset, size ) );

        }

    else

        {

        r = KErrNotFound;

        }

    return r;

    }

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

// COma2Dcf::GetPartIdsL

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

//

void COma2Dcf::GetPartIdsL( RPointerArray<HBufC8>& aPartList )

    {

    aPartList.ResetAndDestroy();

    for ( TInt i( 0 ); i < iParts.Count(); i++ )

        {

        aPartList.Append( iParts[ i ]->iContentId->AllocL() );

        }

    }

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

// COma2Dcf::ReadContainerL

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

//

void COma2Dcf::ReadContainerL(

    TInt aOffset,

    TInt& aSize )

    {

    TUint32 type( 0 );

    TInt size( 0 );

    ReadBoxSizeAndTypeL( aOffset, aSize, type, size );

    VerifyTypeL( type, KContainer );

    aOffset += size + KLengthVersion + KLengthFlags;

    ReadDiscreteMediaHeaderL( aOffset, size );

    aOffset += size;

    ReadContentObjectL( aOffset, size );

    }

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

// COma2Dcf::ReadDiscreteMediaHeaderL

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

//

void COma2Dcf::ReadDiscreteMediaHeaderL(

    TInt aOffset,

    TInt& aSize )

    {

    TBuf8<1> valBuf;

    TBuf8<4> udtaBuf;

    TInt size( 0 );

    TUint32 type( 0 );

    TUint8 length( 0 );

    TPtr8 ptr( 0, 0 );

    TBuf8< KLengthVersion + KLengthFlags > buffer;

    TUint32 version_and_flags( 0 );

    ReadBoxSizeAndTypeL( aOffset, aSize, type, size );

    VerifyTypeL( type, KDiscreteMediaHeaders );

    // read flags and version

    aOffset += size;

    User::LeaveIfError( iFile.Read( aOffset, buffer ) );

    version_and_flags = ReadUint32FromBlock( buffer, 0 );

    aOffset += KLengthVersion + KLengthFlags;

    // read ContentType

    delete iMimeType;

    iMimeType = NULL;

    // input validation

    if ( aOffset < 0 )

        {

        // RFile::Read will panic if offset is negative

        User::Leave( KErrArgument );

        }

    User::LeaveIfError( iFile.Read( aOffset, valBuf, 1 ) );

    length = valBuf[ 0 ];

    aOffset += 1;

    iMimeType = HBufC8::NewMax( length );

    User::LeaveIfNull( iMimeType );

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

    User::LeaveIfError( iFile.Read( ptr, length ) );