--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omadrm/drmengine/ro/src/DRMPermission.cpp Thu Dec 17 08:52:27 2009 +0200
@@ -0,0 +1,1268 @@
+/*
+* 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 "DRMPermission.h"
+#include "DRMConstraint.h"
+#include "drmlog.h"
+#include "OMA2Agent.h"
+
+// EXTERNAL DATA STRUCTURES
+
+// EXTERNAL FUNCTION PROTOTYPES
+
+// CONSTANTS
+
+// Synchronizing marker in the beginning of the stream in order to synchronize
+// to externalized Permission object having the new structure.
+const TInt32 KSyncMark = 0xAFCE;
+
+// Old and new version number of the Permission object
+const TInt8 KVersion3_2_0 = 0;
+const TInt8 KVersion3_2_1 = 1;
+
+
+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();
+
+ return self;
+ };
+
+
+// -----------------------------------------------------------------------------
+// CDRMPermission::NewL
+// Two-phased constructor.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CDRMPermission* CDRMPermission::NewL()
+ {
+ CDRMPermission* self = NewLC();
+ CleanupStack::Pop();
+
+ return self;
+ };
+
+// -----------------------------------------------------------------------------
+// Default constructor
+// -----------------------------------------------------------------------------
+//
+CDRMPermission::CDRMPermission() :
+ iSyncMark( KSyncMark ),
+ iVersion( KVersion3_2_1 ), // Version number for differentiation in
+ // 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
+ if( !iTopLevel )
+ {
+ 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;
+ if( iParentUID )
+ {
+ dataLength = iParentUID->Length();
+ }
+ aStream.WriteInt32L( dataLength );
+
+ if( dataLength )
+ {
+ aStream.WriteL( iParentUID->Des() );
+ }
+
+ // Rights Object if of the rights delivery container
+ dataLength = 0;
+ if( iRoID )
+ {
+ dataLength = iRoID->Length();
+ }
+ aStream.WriteInt32L( dataLength );
+
+ if( dataLength )
+ {
+ aStream.WriteL( iRoID->Des() );
+ }
+
+ // Domain identifier
+ dataLength = 0;
+ if( iDomainID )
+ {
+ dataLength = iDomainID->Length();
+ }
+ aStream.WriteInt32L( dataLength );
+
+ if( dataLength )
+ {
+ aStream.WriteL( iDomainID->Des() );
+ }
+
+ // Available rights
+ aStream.WriteUint16L( iAvailableRights );
+
+ // Version number of the rights object
+ 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();
+
+ }
+ else
+ {
+
+ // 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 );
+
+ // Pop the buffer
+ CleanupStack::Pop(); // dataPart
+
+ // If an old content identifier exists delete it
+ if( iParentUID )
+ {
+ delete iParentUID;
+ iParentUID = NULL;
+ }
+
+ // assign the new content id
+ iParentUID = dataPart;
+ }
+ else
+ {
+ // If an old individual exists delete it
+ 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 );
+
+ // Pop the buffer
+ CleanupStack::Pop(); // dataPart
+
+ // If an old content identifier exists delete it
+ if( iRoID )
+ {
+ delete iRoID;
+ iRoID = NULL;
+ }
+
+ // assign the new content id
+ iRoID = dataPart;
+ }
+ else
+ {
+ // If an old individual exists delete it
+ if( iRoID )
+ {
+ delete iRoID;
+ iRoID = NULL;
+ }
+ }
+
+ // Domain identifier
+ 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 );
+
+ // Pop the buffer
+ CleanupStack::Pop(); // dataPart
+
+ // If an old content identifier exists delete it
+ if( iDomainID )
+ {
+ delete iDomainID;
+ iDomainID = NULL;
+ }
+
+ // assign the new content id
+ iDomainID = dataPart;
+ }
+ else
+ {
+ // If an old individual exists delete it
+ if( iDomainID )
+ {
+ delete iDomainID;
+ iDomainID = NULL;
+ }
+ }
+
+
+ // Available rights
+ iAvailableRights = aStream.ReadUint16L();
+
+ // Version number of the rights object
+ iRightsObjectVersion.iVersionMain = aStream.ReadUint16L();
+ iRightsObjectVersion.iVersionSub = aStream.ReadUint16L();
+
+ // Information bits
+ iInfoBits = aStream.ReadInt32L();
+
+ aStream.ReadL( iRiId );
+
+ // New structure of Permission object
+ if ( iVersion == KVersion3_2_1 )
+ {
+
+ // OnExpiredUrl
+ 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 );
+
+ // Pop the buffer
+ CleanupStack::Pop(); // dataPart
+
+ // If an old OnExpiredUrl exists delete it
+ if( iOnExpiredUrl )
+ {
+ delete iOnExpiredUrl;
+ iOnExpiredUrl = NULL;
+ }
+
+ // assign the new OnExpiredUrl
+ iOnExpiredUrl = dataPart;
+ }
+ else
+ {
+ // If an old OnExpiredUrl exists delete it
+ if( iOnExpiredUrl )
+ {
+ delete iOnExpiredUrl;
+ iOnExpiredUrl = NULL;
+ }
+ }
+
+ // For future use or development, reads the data at the end of the stream
+ 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 );
+
+ // Delete the buffer
+ CleanupStack::PopAndDestroy( dataPart );
+ }
+ }
+
+ // Permission can be considered to have the new structure after
+ // internalization.
+ if ( iVersion == KVersion3_2_0 )
+ {
+ iSyncMark = KSyncMark;
+ iVersion = KVersion3_2_1;
+ }
+
+ };
+
+// -----------------------------------------------------------------------------
+// CDRMPermission::Stateful
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CDRMPermission::Stateful() const
+ {
+ if( ( (iAvailableRights & ERightsTopLevel) && iTopLevel->Stateful() ) )
+ {
+ return ETrue;
+ }
+ else if( (iAvailableRights & ERightsPlay) && iPlay->Stateful() )
+ {
+ return ETrue;
+ }
+ else if( (iAvailableRights & ERightsDisplay) && iDisplay->Stateful() )
+ {
+ return ETrue;
+ }
+ else if( (iAvailableRights & ERightsExecute) && iExecute->Stateful() )
+ {
+ return ETrue;
+ }
+ else if( (iAvailableRights & ERightsPrint) && iPrint->Stateful() )
+ {
+ return ETrue;
+ }
+ return EFalse;
+ };
+
+// -----------------------------------------------------------------------------
+// CDRMPermission::SoftwareConstrained
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CDRMPermission::SoftwareConstrained() const
+ {
+ if ( (iAvailableRights & ERightsTopLevel) &&
+ iTopLevel->iActiveConstraints & ( EConstraintVendor | EConstraintSoftware ) )
+ {
+ return ETrue;
+ }
+ else if ( (iAvailableRights & ERightsPlay) &&
+ iPlay->iActiveConstraints & ( EConstraintVendor | EConstraintSoftware ) )
+ {
+ return ETrue;
+ }
+ else if ( (iAvailableRights & ERightsDisplay) &&
+ iDisplay->iActiveConstraints & ( EConstraintVendor | EConstraintSoftware ) )
+ {
+ return ETrue;
+ }
+ else if ( (iAvailableRights & ERightsExecute) &&
+ iExecute->iActiveConstraints & ( EConstraintVendor | EConstraintSoftware ) )
+ {
+ return ETrue;
+ }
+ else if ( (iAvailableRights & ERightsPrint) &&
+ iPrint->iActiveConstraints & ( EConstraintVendor | EConstraintSoftware ) )
+ {
+ return ETrue;
+ }
+ return EFalse;
+ };
+
+// -----------------------------------------------------------------------------
+// CDRMPermission::Child
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CDRMPermission::Child() const
+ {
+ return iParentUID ? ETrue : EFalse;
+ };
+
+// -----------------------------------------------------------------------------
+// CDRMPermission::Size
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TInt CDRMPermission::Size() const
+ {
+ TInt size = 0;
+
+ // synchronizing marker
+ size += sizeof(TInt32);
+
+ // Version number
+ size += sizeof(TInt32);
+
+ // Unique ID of the permission
+ size += sizeof(TDRMUniqueID);
+
+ // The original insertion time
+ size += sizeof(TTime);
+
+ // Top level constraint
+ size += iTopLevel->Size();
+
+ // Play constraint
+ size += iPlay->Size();
+
+ // Display constraint
+ size += iDisplay->Size();
+
+ // Execute constraint
+ size += iExecute->Size();
+
+ // Print constraint
+ size += iPrint->Size();
+
+ // Export constraint
+ size += iExport->Size();
+
+ // Export mode
+ size += sizeof(TUint8);
+
+ // Content id of the parent rights object
+ size += sizeof(TInt32);
+
+ if( iParentUID )
+ {
+ size += iParentUID->Size();
+ }
+
+ // Rights Object if of the rights delivery container
+ size += sizeof(TInt32);
+
+ if( iRoID )
+ {
+ size += iRoID->Size();
+ }
+
+ // Domain identifier
+ size += sizeof(TInt32);
+
+ if( iDomainID )
+ {
+ size += iDomainID->Size();
+ }
+
+ // Available rights
+ size += sizeof(TUint16);
+
+ // Version number of the rights object
+ size += sizeof(TUint16);
+ size += sizeof(TUint16);
+
+ // infobits
+ size += sizeof(TInt32);
+
+ // RI ID
+ size += KRiIdSize;
+
+ // OnExpiredUrl
+ size += sizeof(TInt32);
+
+ if ( iOnExpiredUrl )
+ {
+ size += iOnExpiredUrl->Size();
+ }
+
+ // For future use
+ size += sizeof(TInt32);
+
+ return size;
+
+ };
+
+// -----------------------------------------------------------------------------
+// CDRMPermission::ConstraintForIntent
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CDRMConstraint* CDRMPermission::ConstraintForIntent(
+ const ContentAccess::TIntent aIntent )
+ {
+ CDRMConstraint* r = NULL;
+
+ switch ( aIntent )
+ {
+ case ContentAccess::EPlay:
+ if ( iAvailableRights & ERightsPlay )
+ {
+ r = iPlay;
+ }
+ break;
+ case ContentAccess::EView:
+ if ( iAvailableRights & ERightsDisplay )
+ {
+ r = iDisplay;
+ }
+ break;
+ case ContentAccess::EExecute:
+ if ( iAvailableRights & ERightsExecute )
+ {
+ r = iExecute;
+ }
+ break;
+ case ContentAccess::EPrint:
+ if ( iAvailableRights & ERightsPrint )
+ {
+ r = iPrint;
+ }
+ break;
+ }
+
+ return r;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMPermission::ConstraintForIntent
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CDRMConstraint* CDRMPermission::TopLevelConstraint()
+ {
+ if ( iAvailableRights & ERightsTopLevel )
+ {
+ return iTopLevel;
+ }
+ else
+ {
+ return NULL;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMPermission::ConsumeRights
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CDRMPermission::ConsumeRights( const TIntent aIntent, const TTime& aCurrentTime )
+ {
+ //__ASSERT_DEBUG( !( aIntent == ERightsTopLevel ), User::Leave( KErrArgument ) );
+
+ CDRMConstraint* constraint( TopLevelConstraint() );
+
+ if ( constraint )
+ {
+ constraint->Consume( aCurrentTime );
+ }
+
+ constraint = ConstraintForIntent( aIntent );
+ if ( constraint )
+ {
+ constraint->Consume( aCurrentTime );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMPermission::ImportL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CDRMPermission::ImportL( const TDesC8& aBuffer )
+ {
+ TInt size = aBuffer.Size();
+ RMemReadStream stream( (TAny*)( aBuffer.Ptr() ), size );
+ CleanupClosePushL( stream );
+
+ InternalizeL( stream );
+
+ CleanupStack::PopAndDestroy(); // Stream
+ };
+
+
+// -----------------------------------------------------------------------------
+// CDRMPermission::ExportL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C HBufC8* CDRMPermission::ExportL() const
+ {
+ TInt size = Size();
+ HBufC8* data = HBufC8::NewMaxLC( size );
+
+ RMemWriteStream stream( (TAny*)( data->Ptr() ), size );
+ CleanupClosePushL( stream );
+
+ ExternalizeL( stream );
+
+ CleanupStack::PopAndDestroy(); // Stream
+ CleanupStack::Pop();
+ return data;
+ };
+
+// -----------------------------------------------------------------------------
+// CDRMPermission::DuplicateL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CDRMPermission::DuplicateL( const CDRMPermission& aPermission )
+ {
+
+ // Synchronizing marker
+ iSyncMark = aPermission.iSyncMark;
+
+ // Version number
+ iVersion = aPermission.iVersion;
+
+ // Unique ID of the permission
+ iUniqueID = aPermission.iUniqueID;
+
+ // The original insertion time
+ iOriginalInsertTime = aPermission.iOriginalInsertTime;
+
+ // Top level constraint
+ if( !iTopLevel )
+ {
+ iTopLevel = CDRMConstraint::NewL();
+ }
+ iTopLevel->DuplicateL( *(aPermission.iTopLevel ) );
+
+ // Play constraint
+ if( !iPlay )
+ {
+ iPlay = CDRMConstraint::NewL();
+ }
+ iPlay->DuplicateL( *(aPermission.iPlay ) );
+
+ // Display constraint
+ if( !iDisplay )
+ {
+ iDisplay = CDRMConstraint::NewL();
+ }
+ iDisplay->DuplicateL( *(aPermission.iDisplay ) );
+
+ // Execute constraint
+ if( !iExecute )
+ {
+ iExecute = CDRMConstraint::NewL();
+ }
+ iExecute->DuplicateL( *(aPermission.iExecute ) );
+
+ // Print constraint
+ if( !iPrint )
+ {
+ iPrint = CDRMConstraint::NewL();
+ }
+ iPrint->DuplicateL( *(aPermission.iPrint ) );
+
+ // Export constraint
+ if( !iExport )
+ {
+ iExport = CDRMConstraint::NewL();
+ }
+ iExport->DuplicateL( *(aPermission.iExport ) );
+
+ // Export mode
+ iExportMode = aPermission.iExportMode;
+
+ // Content id of the parent rights object
+ if( iParentUID )
+ {
+ delete iParentUID;
+ iParentUID = NULL;
+ }
+
+ if( aPermission.iParentUID )
+ {
+ iParentUID = aPermission.iParentUID->AllocL();
+ }
+
+ // Rights Object if of the rights delivery container
+ if( iRoID )
+ {
+ delete iRoID;
+ iRoID = NULL;
+ }
+
+ if( aPermission.iRoID )
+ {
+ iRoID = aPermission.iRoID->AllocL();
+ }
+
+ // Domain identifier
+ if( iDomainID )
+ {
+ delete iDomainID;
+ iDomainID = NULL;
+ }
+
+ if( aPermission.iDomainID )
+ {
+ iDomainID = aPermission.iDomainID->AllocL();
+ }
+ // Available rights
+ iAvailableRights = aPermission.iAvailableRights; // Bitmask
+
+ // Version number of the rights object
+ iRightsObjectVersion.iVersionMain = aPermission.iRightsObjectVersion.iVersionMain;
+ iRightsObjectVersion.iVersionSub = aPermission.iRightsObjectVersion.iVersionSub;
+
+ // info bits
+ iInfoBits = aPermission.iInfoBits;
+
+ // OnExpiredUrl
+ if ( iOnExpiredUrl )
+ {
+ delete iOnExpiredUrl;
+ iOnExpiredUrl = NULL;
+ }
+
+ if ( aPermission.iOnExpiredUrl )
+ {
+ iOnExpiredUrl = aPermission.iOnExpiredUrl->AllocL();
+ }
+
+ };
+
+
+// -----------------------------------------------------------------------------
+// CDRMPermission::Expired
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CDRMPermission::Expired( const TTime& aTime )
+ {
+ if( iTopLevel && iAvailableRights & ERightsTopLevel )
+ {
+ if( iTopLevel->Expired( aTime ) )
+ {
+ return ETrue;
+ }
+ }
+
+ if( iPlay && iAvailableRights & ERightsPlay)
+ {
+ if( !iPlay->Expired( aTime ) )
+ {
+ return EFalse;
+ }
+ }
+
+ if( iDisplay && iAvailableRights & ERightsDisplay )
+ {
+ if( !iDisplay->Expired( aTime ) )
+ {
+ return EFalse;
+ }
+ }
+
+ if( iExecute && iAvailableRights & ERightsExecute )
+ {
+ if( !iExecute->Expired( aTime ) )
+ {
+ return EFalse;
+ }
+ }
+
+ if( iPrint && iAvailableRights & ERightsPrint )
+ {
+ if( !iPrint->Expired( aTime ) )
+ {
+ return EFalse;
+ }
+ }
+
+ if( iExport && iAvailableRights & ERightsExport )
+ {
+ if( !iExport->Expired( aTime ) )
+ {
+ return EFalse;
+ }
+ }
+
+ return ETrue;
+ };
+
+
+// -----------------------------------------------------------------------------
+// CDRMPermission::Expired
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CDRMPermission::Valid( const TTime& aTime,
+ const RPointerArray<HBufC8>& aIndividual,
+ TUint32& aRejection,
+ const TRightsType aType ) const
+ {
+ // Always check that if the top level rights are present
+ // that they are valid
+ if( iTopLevel && !iTopLevel->Valid( aTime, aIndividual, aRejection ) )
+ {
+ aRejection |= aRejection;
+ return EFalse;
+ }
+
+ switch( aType )
+ {
+ case ERightsTopLevel:
+ if( !iTopLevel )
+ {
+ return EFalse;
+ }
+ break;
+ case ERightsPlay:
+ if( !iPlay )
+ {
+ return EFalse;
+ }
+ else if( iPlay && !iPlay->Valid( aTime, aIndividual, aRejection ) )
+ {
+ return EFalse;
+ }
+ break;
+ case ERightsDisplay:
+ if( !iDisplay )
+ {
+ return EFalse;
+ }
+ else if( iDisplay && !iDisplay->Valid( aTime, aIndividual, aRejection ) )
+ {
+ return EFalse;
+ }
+ break;
+ case ERightsExecute:
+ if( !iExecute )
+ {
+ return EFalse;
+ }
+ else if( iExecute && !iExecute->Valid( aTime, aIndividual, aRejection ) )
+ {
+ return EFalse;
+ }
+ break;
+ case ERightsPrint:
+ if( !iPrint )
+ {
+ return EFalse;
+ }
+ else if( iPrint && !iPrint->Valid( aTime, aIndividual, aRejection ) )
+ {
+ return EFalse;
+ }
+ break;
+ case ERightsExport:
+ if( !iExport )
+ {
+ return EFalse;
+ }
+ else if( iExport && !iExport->Valid( aTime, aIndividual, aRejection ) )
+ {
+ return EFalse;
+ }
+ break;
+ default:
+ // No constraints are defined, top level doesn't work
+ // on it's own, the permission is invalid
+ if( !iPrint && !iDisplay && !iExecute && !iPrint )
+ {
+ return EFalse;
+ }
+ else if( iPlay && !iPlay->Valid( aTime, aIndividual, aRejection ) )
+ {
+ return EFalse;
+ }
+ else if( iDisplay && !iDisplay->Valid( aTime, aIndividual, aRejection ) )
+ {
+ return EFalse;
+ }
+ else if( iPrint && !iPrint->Valid( aTime, aIndividual, aRejection ) )
+ {
+ return EFalse;
+ }
+ else if( iExecute && !iExecute->Valid( aTime, aIndividual, aRejection ) )
+ {
+ return EFalse;
+ }
+ else if( iExport && !iExport->Valid( aTime, aIndividual, aRejection ) )
+ {
+ return EFalse;
+ }
+ break;
+ }
+ return ETrue;
+ };
+
+
+
+// -----------------------------------------------------------------------------
+// CDRMPermission::ConstructL
+// 2nd phase constructor
+// -----------------------------------------------------------------------------
+//
+void CDRMPermission::ConstructL()
+ {
+ iTopLevel = CDRMConstraint::NewL();
+ iPlay = CDRMConstraint::NewL();
+ iDisplay = CDRMConstraint::NewL();
+ iExecute = CDRMConstraint::NewL();
+ iPrint = CDRMConstraint::NewL();
+ iExport = CDRMConstraint::NewL();
+
+ iRightsObjectVersion.iVersionMain = EOma1Rights;
+ iRightsObjectVersion.iVersionSub = 0;
+ };
+
+
+// -----------------------------------------------------------------------------
+// CDRMPermission::WriteInt64L
+// -----------------------------------------------------------------------------
+//
+void CDRMPermission::WriteInt64L( const TInt64& aWrite, RWriteStream& aStream ) const
+ {
+ TPtr8 output( reinterpret_cast<TUint8*>(const_cast<TInt64*>(&aWrite)),
+ sizeof(TInt64), sizeof(TInt64) );
+
+ aStream.WriteL( output, sizeof(TInt64) );
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMPermission::ReadInt64L
+// -----------------------------------------------------------------------------
+//
+void CDRMPermission::ReadInt64L( TInt64& aRead, RReadStream& aStream )
+ {
+ TPtr8 input( reinterpret_cast<TUint8*>(&aRead), 0, sizeof(TInt64) );
+
+ aStream.ReadL( input, sizeof(TInt64) );
+ };
+
+
+// -----------------------------------------------------------------------------
+// CDRMPermission::Merge
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CDRMPermission::Merge( const CDRMPermission& aPermission )
+ {
+ iTopLevel->Merge( *( aPermission.iTopLevel ) );
+ iPlay->Merge( *( aPermission.iPlay ) );
+ iDisplay->Merge( *( aPermission.iDisplay ) );
+ iExecute->Merge( *( aPermission.iExecute ) );
+ iPrint->Merge( *( aPermission.iPrint ) );
+ iExport->Merge( *( aPermission.iExport ) );
+ iAvailableRights |= aPermission.iAvailableRights;
+ iInfoBits |= aPermission.iInfoBits;
+ }
+
+// End of File