/*

* 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:  Datatype implementation for Rights Constraint

*

*/

// INCLUDE FILES

#include <s32strm.h>

#include <s32mem.h>

// CONSTANTS

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

const TInt32 KSyncMark = 0xAFCE;

// Old and new version number of the Constraint object

const TInt8 KVersion3_2_0 = 0;

const TInt KSanityDataLengthLow = 0;

const TInt KSanityDataLengthHigh = 32768;

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

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

// SanitizeL

// Performs a sanity check on length parameters

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

//

LOCAL_C void SanitizeL( TInt aParam )

    {

    if( aParam < KSanityDataLengthLow || aParam > KSanityDataLengthHigh )

        {

        User::Leave(KErrArgument);

        }

    }

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

// AppendToArrayL

// Appends the strings of array aFrom to array aTo

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

//

                             const RPointerArray<HBufC8>& aFrom )

    {

    HBufC8* addData = NULL;

    for( TInt i = 0; i < aFrom.Count(); i++ )

        {

        addData = aFrom[i]->AllocLC();

        aTo.AppendL( addData );

    }

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

// CountArrayStoreSize

// Returns the size in bytes how much the array needs for storing

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

//

LOCAL_C TInt CountArrayStoreSize( const RPointerArray<HBufC8>& aArray )

    {

    TInt size = 0;

    for(TInt i = 0; i < aArray.Count(); i++ )

        {

        size += sizeof(TInt);

        size += aArray[i]->Size();

        }

    }

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

// WriteArrayToStreamL

// Write the array to the stream

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

//

LOCAL_C void WriteArrayToStreamL( RWriteStream& aStream,

                                  const RPointerArray<HBufC8>& aArray )

    {

    for(TInt i = 0; i < aArray.Count(); i++ )

        {

        aStream.WriteInt32L( aArray[i]->Size() );

        aStream.WriteL( aArray[i]->Des() );

        }

    }

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

// ReadArrayFromStringL

// Reads the array from the string

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

LOCAL_C void ReadArrayFromStringL( const TDesC8& aString,

                                   RPointerArray<HBufC8>& aArray )

    {

    RMemReadStream inRead( static_cast<const TAny*>( aString.Ptr() ), aString.Size() );

    TInt size = 0;

    HBufC8* addData = NULL;

    TPtr8 dataBuffer(NULL,0,0);

    CleanupClosePushL( inRead );

    aArray.ResetAndDestroy();

    for( TInt i = 0; i < aString.Size();)

        {

        // it means that it's an old version and the whole thing is the

        if(( aString.Size() - i) < sizeof(TInt) )

            {

            aArray.ResetAndDestroy();

            addData = aString.AllocLC();

            aArray.AppendL( addData );

            CleanupStack::Pop();

            }

        size = inRead.ReadInt32L();

        i += sizeof(TInt);

        // If the size is negative or the size left is not large enough

        // it means that it's an old version and the whole thing is the

        // string since in previous versions only one string is stored.

        if( size < 0 || size > ( aString.Size() - i ) )

            {

            aArray.ResetAndDestroy();

            addData = aString.AllocLC();

            aArray.AppendL( addData );

            CleanupStack::Pop();

            return;

            }

        // Set the read buffer:

        dataBuffer.Set(const_cast<TUint8*>(addData->Ptr()), 0, size);

        // Read the data:

        inRead.ReadL( dataBuffer );

        aArray.AppendL( addData );

        CleanupStack::Pop( addData );

        i += size;

        }

    return;

    }

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

// IsIndividualConstraintValid

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

//

                                           const RPointerArray<HBufC8>& aValidConstraints)

    {

    TInt retVal = 0;

    for( TInt i = 0; i < aConstraint.Count(); i++ )

        {

        for( TInt j = 0; j < aValidConstraints.Count(); j++ )

            {

            retVal = aConstraint[i]->Des().Compare( aValidConstraints[j]->Des() );

            if( !retVal )

                {

                return ETrue;

                }

            }

        }

    };

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

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

// CDRMConstraint::NewLC

// Two-phased constructor.

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

//

EXPORT_C CDRMConstraint* CDRMConstraint::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    };

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

// CDRMConstraint::NewL

// Two-phased constructor.

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

//

EXPORT_C CDRMConstraint* CDRMConstraint::NewL()

    {

    CDRMConstraint* self = NewLC();

    CleanupStack::Pop();

    return self;

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

// Default Constructor - First phase.

// Can be used by itself to generate an empty object

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

//

EXPORT_C CDRMConstraint::CDRMConstraint() :

    iSyncMark( KSyncMark ),

    iStartTime( Time::NullTTime() ),

    iEndTime( Time::NullTTime() ),

    iIntervalStart( Time::NullTTime() ),

    iInterval( 0 ),

    iCounter( 0 ),

    iOriginalCounter( 0 ),

    iTimedCounter( 0 ),

    iActiveConstraints( 0 ),

    iDrmMeteringInfo( NULL ),

    {

    }

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

// Destructor

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

EXPORT_C CDRMConstraint::~CDRMConstraint()

    {

    iIndividual.ResetAndDestroy();

    iIndividual.Close();

    iSystem.ResetAndDestroy();

    if( iDrmMeteringInfo )

        {

        delete iDrmMeteringInfo;

        iDrmMeteringInfo = NULL;

        }

#endif

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

// CDRMConstraint::ExternalizeL

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

//

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

    {

    // used for the buffers

    TInt32 dataLength = 0;

    // write the synchronizing marker

    aStream.WriteInt32L( iSyncMark );

    // Write the version number

    aStream.WriteInt32L( iVersion );

    // Write the start time

    WriteInt64L( iStartTime.Int64(), aStream );

    // Write the end time

    WriteInt64L( iEndTime.Int64(), aStream );

    // Write the interval start time

    aStream.WriteInt32L( iInterval.Int() );

    // Write the counter

    aStream.WriteInt32L( iCounter );

    // Write the original counter

    aStream.WriteInt32L( iOriginalCounter );

    // Write the timed counter

    aStream.WriteInt32L( iTimedCounter );

    // Write the timed interval

    aStream.WriteInt32L( iTimedInterval.Int() );

    // Write the accumulated time

    aStream.WriteInt32L( iAccumulatedTime.Int() );

    // Write the individual

    dataLength = 0;

    if ( iIndividual.Count() )

        {

        dataLength = CountArrayStoreSize( iIndividual );

        }

    aStream.WriteInt32L( dataLength );

    if ( dataLength )

        {

    // Software Vendor Id

    aStream.WriteInt32L( iVendorId.iUid );

    // Secure Id of the allowed application

    aStream.WriteInt32L( iSecureId.iUid );

    // Active constraints

    aStream.WriteUint32L( iActiveConstraints );

    // Metering info

    dataLength = 0;

    if ( iDrmMeteringInfo )

        {

        dataLength = sizeof( TTimeIntervalSeconds ) + sizeof( TUint8 );

        }

    aStream.WriteInt32L( dataLength );

    if ( dataLength )

        {

        aStream.WriteInt32L( iDrmMeteringInfo->iGraceTime.Int() );

        aStream.WriteInt8L( iDrmMeteringInfo->iAllowUseWithoutMetering );

        }

#endif

    // Write the system

    dataLength = 0;

    if ( iSystem.Count() )

        {

        dataLength = CountArrayStoreSize( iSystem );

        }

    aStream.WriteInt32L( dataLength );

    if ( dataLength )

        {

        WriteArrayToStreamL( aStream, iSystem );

        }

    // write the original timed counter

    aStream.WriteInt32L( iOriginalTimedCounter );

    // For future use

    aStream.WriteInt32L( 0 );

    };

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

// CDRMConstraint::InternalizeL

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

//

EXPORT_C void CDRMConstraint::InternalizeL( RReadStream& aStream )

    {

    TInt64 timeData = 0;

    TInt32 temp = 0;

    // used for the buffers

    TInt dataLength = 0;

    HBufC8* dataPart = NULL;

    TPtr8 dataBuffer(NULL,0,0);

    // Read the (possible) synchronizing marker.

    iSyncMark = aStream.ReadInt32L();

    if ( iSyncMark != KSyncMark )

        {

        // The structure of the externalized Permission object is the old one.

        // The first four bytes constitute half of the eight bytes of Start time.

        // in order to reconstruct the Start time (iStartTime).

        temp = aStream.ReadInt32L();

        timeData = temp;

        timeData <<= 32;

        Mem::Copy( &timeData, &iSyncMark, sizeof(TInt32) );

        iStartTime = timeData;

        timeData = 0;

        // InternalizeL.

        iVersion = KVersion3_2_0;

        }

        {

        // The structure of the externalized Permission object is the new one.

        iVersion = aStream.ReadInt32L();

        // Read the start time

        ReadInt64L( timeData, aStream );

        iStartTime = timeData;

        }

    // Read the end time

    ReadInt64L( timeData, aStream );

    iEndTime = timeData;

    // Read the interval start time

    iIntervalStart = timeData;

    iInterval = aStream.ReadInt32L();

    // Read the counter

    iCounter = aStream.ReadInt32L();

    // Read the original counter

    iOriginalCounter = aStream.ReadInt32L();

    // Read the timed counter

    iTimedCounter = aStream.ReadInt32L();

    // Read the timed interval

    iTimedInterval = aStream.ReadInt32L();

    // Read the accumulated time

    iAccumulatedTime = aStream.ReadInt32L();

    // 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 );

        // Fill the array from the string

        ReadArrayFromStringL( dataBuffer, iIndividual);

        CleanupStack::PopAndDestroy(); // dataPart

        }

    else

        {

    if ( iVersion == KVersion3_2_0 ) // Constraint has the old structure.

        {

        dataLength = aStream.ReadInt32L();

        SanitizeL( dataLength );

        if( dataLength > 0 )

            {

            // Reserve a new buffer:

            dataPart = HBufC8::NewMaxLC( dataLength );

            // Set the read buffer:

                            dataLength );

            // Read the data:

            aStream.ReadL( dataBuffer );

            CleanupStack::Pop(); // dataPart