/*

* Copyright (c) 2007 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:  Part of the Implementation of the DRM Rights Database

*

*/

// INCLUDE FILES

#include <s32strm.h>

#include <s32mem.h>

#include <caf/caf.h>

#include "drmlog.h"

// EXTERNAL DATA STRUCTURES

// CONSTANTS

// Synchronizing marker in the beginning of the stream in order to synchronize

const TInt32 KSyncMark = 0xAFCE;

// Old and new version number of the Permission object

const TInt8 KVersion3_2_0 = 0;

const TInt KSanityDataLengthLow = 0;

const TInt KSanityDataLengthHigh = 32768;

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

// SanitizeL

// Performs a sanity check on length parameters

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

//

LOCAL_C void SanitizeL( TInt aParam )

    {

    if( aParam < KSanityDataLengthLow || aParam > KSanityDataLengthHigh )

        {

        User::Leave(KErrArgument);

        }

    }

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

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

// CDRMPermission::NewLC

// Two-phased constructor.

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

//

EXPORT_C CDRMPermission* CDRMPermission::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    };

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

// CDRMPermission::NewL

// Two-phased constructor.

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

//

EXPORT_C CDRMPermission* CDRMPermission::NewL()

    {

    CDRMPermission* self = NewLC();

    CleanupStack::Pop();

    return self;

    };

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

// Default constructor

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

//

CDRMPermission::CDRMPermission() :

    iSyncMark( KSyncMark ),

                               // InternalizeL.

    iUniqueID( 0 ),

    iOriginalInsertTime( Time::NullTTime() ),

    iTopLevel( NULL ),

    iPlay( NULL ),

    iDisplay( NULL ),

    iExecute(NULL ),

    iPrint( NULL ),

    iExportMode( ECopy ),

    iParentUID( NULL ),

    iRoID( NULL ),

    iDomainID( NULL ),

    iAvailableRights( 0 ),

    iInfoBits( 0 ),

    iOnExpiredUrl( NULL )

    {

    iRiId.SetLength( KRiIdSize );

    iRiId.Fill( 0 );

    };

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

// Destructor

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

//

EXPORT_C CDRMPermission::~CDRMPermission()

    {

    if( iTopLevel )

        {

        delete iTopLevel;

        iTopLevel = NULL;

        }

    if( iPlay )

        {

        delete iPlay;

        iPlay = NULL;

        }

    if( iDisplay )

        {

        delete iDisplay;

        iDisplay = NULL;

        }

    if( iExecute )

        {

        delete iExecute;

        iExecute = NULL;

        }

    if( iExport )

        {

        delete iExport;

        iExport = NULL;

        }

    if( iPrint )

        {

        delete iPrint;

        iPrint = NULL;

        }

    if( iParentUID )

        {

        delete iParentUID;

        iParentUID = NULL;

        }

    if( iRoID )

        {

        delete iRoID;

        iRoID = NULL;

        }

    if( iDomainID )

        {

        delete iDomainID;

        iDomainID = NULL;

        }

    if( iOnExpiredUrl )

        {

        delete iOnExpiredUrl;

        iOnExpiredUrl = NULL;

        }

    };

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

// CDRMPermission::ExternalizeL

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

//

EXPORT_C void CDRMPermission::ExternalizeL( RWriteStream& aStream ) const

    {

    // used for the buffers

    TInt dataLength = 0;

    // Used for mode

    TUint8 exportMode = 0;

    // Write the synchronizing marker

    aStream.WriteInt32L( iSyncMark );

    // Write the version number

    aStream.WriteInt32L( iVersion );

    // Unique ID of the permission

    aStream.WriteUint32L( iUniqueID );

    // The original insertion time

    WriteInt64L( iOriginalInsertTime.Int64(), aStream );

    // Top level constraint

        {

        User::Leave( KErrNotReady );

        }

    iTopLevel->ExternalizeL( aStream );

    // Play constraint

    if( !iPlay )

        {

        User::Leave( KErrNotReady );

        }

    iPlay->ExternalizeL( aStream );

    // Display constraint

    if( !iDisplay )

        {

        User::Leave( KErrNotReady );

        }

    iDisplay->ExternalizeL( aStream );

    // Execute constraint

    if( !iExecute )

        {

        User::Leave( KErrNotReady );

        }

    iExecute->ExternalizeL( aStream );

    // Print constraint

    if( !iPrint )

        {

        User::Leave( KErrNotReady );

        }

    iPrint->ExternalizeL( aStream );

    // Export constraint

    if( !iExport )

        {

        User::Leave( KErrNotReady );

        }

    iExport->ExternalizeL( aStream );

    // Export mode

    exportMode = iExportMode;

    aStream.WriteUint8L( exportMode );

    // Content id of the parent rights object

    dataLength = 0;

        {

        dataLength = iParentUID->Length();

        }

    aStream.WriteInt32L( dataLength );

    if( dataLength )

        {

    // Rights Object if of the rights delivery container

    if( iRoID )

        {

        dataLength = iRoID->Length();

        }

    aStream.WriteInt32L( dataLength );

    if( dataLength )

        {

        }

    // Domain identifier

    if( iDomainID )

        {

        dataLength = iDomainID->Length();

        }

    aStream.WriteInt32L( dataLength );

    if( dataLength )

        {

    aStream.WriteUint16L( iAvailableRights );

    aStream.WriteUint16L( iRightsObjectVersion.iVersionMain );

    aStream.WriteUint16L( iRightsObjectVersion.iVersionSub );

    // Info bits

    aStream.WriteInt32L( iInfoBits );

    aStream.WriteL( iRiId );

    // OnExpiredUrl

    dataLength = 0;

    if ( iOnExpiredUrl )

        {

        dataLength = iOnExpiredUrl->Length();

        }

    aStream.WriteInt32L( dataLength );

    if ( dataLength )

        {

        aStream.WriteL( iOnExpiredUrl->Des() );

        }

    // For future use

    aStream.WriteInt32L( 0 );

    };

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

// CDRMPermission::InternalizeL

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

//

EXPORT_C void CDRMPermission::InternalizeL( RReadStream& aStream )

    TInt64 timeData = 0;

    // used for the buffers

    TInt dataLength = 0;

    TPtr8 dataBuffer(NULL,0,0);

    HBufC8* dataPart = NULL;

    // (Possible) synchronizing marker

    iSyncMark = aStream.ReadInt32L();

    if ( iSyncMark == KSyncMark )

        {

        // The internalized Permission object has the new structure if the

        // synchronizing marker is found in the beginning of the stream. In that

        // case read version number and Unique ID.

        iVersion = aStream.ReadInt32L();

        // Unique ID of the permission

        iUniqueID = aStream.ReadUint32L();

        }

        {

        // The internalized Permission object has the old structure. The

        // stream information that was read to iSyncMark is actually the

        // Unique ID.

        iUniqueID = (TDRMUniqueID)iSyncMark;

        iVersion = KVersion3_2_0; // Old version, needed for differentation

        }

    // The original insertion time

    ReadInt64L( timeData, aStream );

    iOriginalInsertTime = timeData;

    // Top level constraint

    if( !iTopLevel )

        {

        iTopLevel = CDRMConstraint::NewL();

        }

    iTopLevel->InternalizeL( aStream );

    // Play constraint

    if( !iPlay )

        {

        iPlay = CDRMConstraint::NewL();

        }

    iPlay->InternalizeL( aStream );

    // Display constraint

    if( !iDisplay )

        {

        iDisplay = CDRMConstraint::NewL();

        }

    iDisplay->InternalizeL( aStream );

    // Execute constraint

    if( !iExecute )

        {

        iExecute = CDRMConstraint::NewL();

        }

    iExecute->InternalizeL( aStream );

    // Print constraint

    if( !iPrint)

        {

        iPrint = CDRMConstraint::NewL();

        }

    iPrint->InternalizeL( aStream );

    // Export constraint

    iExport->InternalizeL( aStream );

    // Export mode

    iExportMode = static_cast<TExportMode>(aStream.ReadUint8L());

    // Content id of the parent rights object

    dataLength = aStream.ReadInt32L();

    SanitizeL( dataLength );

    if( dataLength > 0 )

        {

        // Reserve a new buffer:

        dataPart = HBufC8::NewMaxLC( dataLength );

        // Set the read buffer:

        dataBuffer.Set(const_cast<TUint8*>(dataPart->Ptr()), 0, dataLength);

        // Read the data:

        aStream.ReadL( dataBuffer );

        CleanupStack::Pop(); // dataPart

        if( iParentUID )

            {

            delete iParentUID;

            iParentUID = NULL;

            }

        // assign the new content id

        }

    else

        {

        if( iParentUID )

            {

            delete iParentUID;

            iParentUID = NULL;

    // Rights Object if of the rights delivery container

    // Read the individual

    dataLength = aStream.ReadInt32L();

    SanitizeL( dataLength );

    if( dataLength > 0 )

        {

        // Reserve a new buffer:

        dataPart = HBufC8::NewMaxLC( dataLength );

        // Set the read buffer:

        dataBuffer.Set(const_cast<TUint8*>(dataPart->Ptr()), 0, dataLength);

        // Read the data:

        aStream.ReadL( dataBuffer );

        CleanupStack::Pop(); // dataPart

        if( iRoID )

            {

            delete iRoID;

            iRoID = NULL;

            }

        // assign the new content id

        }

    else

        {

        if( iRoID )

            {

            delete iRoID;

            iRoID = NULL;