FCL/sf/mw/drm: comparison omadrm/drmengine/ro/src/DRMPermission.cpp

equal deleted inserted replaced

-:79d62d1d7957
+:493788a4a8a4
 // INCLUDE FILES
 #include <s32strm.h>
 #include <s32mem.h>
 #include <caf/caf.h>
-#include "DRMPermission.h"
+#include "DrmPermission.h"
-#include "DRMConstraint.h"
+#include "DrmConstraint.h"
 #include "drmlog.h"
-#include "OMA2Agent.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;
 EXPORT_C CDRMPermission* CDRMPermission::NewLC()
 {
 CDRMPermission* self = new( ELeave ) CDRMPermission();
 CleanupStack::PushL( self );
 self->ConstructL();
 return self;
 };
 // -----------------------------------------------------------------------------
 // CDRMPermission::NewL
 //
 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 ),
 iOnExpiredUrl( NULL )
 {
 iRiId.SetLength( KRiIdSize );
 iRiId.Fill( 0 );
 };
 // -----------------------------------------------------------------------------
 // Destructor
 // -----------------------------------------------------------------------------
 //
 EXPORT_C CDRMPermission::~CDRMPermission()
 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( 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
 {
 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
 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 = iPrint;
 }
 break;
 }
 return r;
 }
 // -----------------------------------------------------------------------------
 // CDRMPermission::ConstraintForIntent
 // -----------------------------------------------------------------------------
 //
 EXPORT_C CDRMConstraint* CDRMPermission::TopLevelConstraint()
 {
 if ( iAvailableRights & ERightsTopLevel )
 {
 return iTopLevel;
 }
 // -----------------------------------------------------------------------------
 // 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 );
 }
 TInt size = aBuffer.Size();
 RMemReadStream stream( (TAny*)( aBuffer.Ptr() ), size );
 CleanupClosePushL( stream );
 InternalizeL( stream );
 CleanupStack::PopAndDestroy(); // Stream
 };
 // -----------------------------------------------------------------------------
 // CDRMPermission::ExportL
 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
+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 && iAvailableRights & ERightsTopLevel )
-		{
+{
-		if( iTopLevel->Expired( aTime ) )
+if( iTopLevel->Expired( aTime ) )
-			{
+{
-			return ETrue;
+return ETrue;
-			}
+}
-		}
+}
-	if( iPlay && iAvailableRights & ERightsPlay)
+if( iPlay && iAvailableRights & ERightsPlay)
-		{
+{
-		if( !iPlay->Expired( aTime ) )
+if( !iPlay->Expired( aTime ) )
-			{
+{
-			return EFalse;
+return EFalse;
-			}
+}
-		}
+}
-	if( iDisplay && iAvailableRights & ERightsDisplay )
+if( iDisplay && iAvailableRights & ERightsDisplay )
-		{
+{
-		if( !iDisplay->Expired( aTime ) )
+if( !iDisplay->Expired( aTime ) )
-			{
+{
-			return EFalse;
+return EFalse;
-			}
+}
-		}
+}
-	if( iExecute && iAvailableRights & ERightsExecute )
+if( iExecute && iAvailableRights & ERightsExecute )
-		{
+{
-		if( !iExecute->Expired( aTime ) )
+if( !iExecute->Expired( aTime ) )
-			{
+{
-			return EFalse;
+return EFalse;
-			}
+}
-		}
+}
-	if( iPrint && iAvailableRights & ERightsPrint )
+if( iPrint && iAvailableRights & ERightsPrint )
-		{
+{
-		if( !iPrint->Expired( aTime ) )
+if( !iPrint->Expired( aTime ) )
-			{
+{
-			return EFalse;
+return EFalse;
-			}
+}
-		}
+}
-	if( iExport && iAvailableRights & ERightsExport )
+if( iExport && iAvailableRights & ERightsExport )
-		{
+{
-		if( !iExport->Expired( aTime ) )
+if( !iExport->Expired( aTime ) )
-			{
+{
-			return EFalse;
+return EFalse;
-			}
+}
-		}
+}
-	return ETrue;
+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
+// Always check that if the top level rights are present
-	// that they are valid
+// 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 ) )
+else if( iPlay && !iPlay->Valid( aTime, aIndividual, aRejection ) )
-			{
+{
-			return EFalse;
+return EFalse;
-			}
+}
-		break;
+break;
-	case ERightsDisplay:
+case ERightsDisplay:
-	    if( !iDisplay )
+if( !iDisplay )
-	    	{
+{
-	    	return EFalse;
+return EFalse;
-	    	}
+}
-		else if( iDisplay && !iDisplay->Valid( aTime, aIndividual, aRejection ) )
+else if( iDisplay && !iDisplay->Valid( aTime, aIndividual, aRejection ) )
-			{
+{
-			return EFalse;
+return EFalse;
-		    }
+}
-		break;
+break;
-	case ERightsExecute:
+case ERightsExecute:
-	    if( !iExecute )
+if( !iExecute )
-	    	{
+{
-	    	return EFalse;
+return EFalse;
-	        }
+}
-		else if( iExecute && !iExecute->Valid( aTime, aIndividual, aRejection ) )
+else if( iExecute && !iExecute->Valid( aTime, aIndividual, aRejection ) )
-			{
+{
-			return EFalse;
+return EFalse;
-			}
+}
-		break;
+break;
-	case ERightsPrint:
+case ERightsPrint:
-	    if( !iPrint )
+if( !iPrint )
-	    	{
+{
-	    	return EFalse;
+return EFalse;
-	    	}
+}
-		else if( iPrint && !iPrint->Valid( aTime, aIndividual, aRejection ) )
+else if( iPrint && !iPrint->Valid( aTime, aIndividual, aRejection ) )
-			{
+{
-			return EFalse;
+return EFalse;
-			}
+}
-		break;
+break;
-	case ERightsExport:
+case ERightsExport:
-	    if( !iExport )
+if( !iExport )
-	    	{
+{
-	    	return EFalse;
+return EFalse;
-	    	}
+}
-		else if( iExport && !iExport->Valid( aTime, aIndividual, aRejection ) )
+else if( iExport && !iExport->Valid( aTime, aIndividual, aRejection ) )
-			{
+{
-			return EFalse;
+return EFalse;
-			}
+}
-		break;
+break;
 default:
-	  	// No constraints are defined, top level doesn't work
+// No constraints are defined, top level doesn't work
-	  	// on it's own, the permission is invalid
+// on it's own, the permission is invalid
-	  	if( !iPrint && !iDisplay && !iExecute && !iPrint )
+if( !iPrint && !iDisplay && !iExecute && !iPrint )
-	  		{
+{
-	  		return EFalse;
+return EFalse;
-	  		}
+}
-			else if( iPlay && !iPlay->Valid( aTime, aIndividual, aRejection ) )
+else if( iPlay && !iPlay->Valid( aTime, aIndividual, aRejection ) )
-			{
+{
-			return EFalse;
+return EFalse;
-			}
+}
-		else if( iDisplay && !iDisplay->Valid( aTime, aIndividual, aRejection ) )
+else if( iDisplay && !iDisplay->Valid( aTime, aIndividual, aRejection ) )
-			{
+{
-			return EFalse;
+return EFalse;
-			}
+}
-			else if( iPrint && !iPrint->Valid( aTime, aIndividual, aRejection ) )
+else if( iPrint && !iPrint->Valid( aTime, aIndividual, aRejection ) )
-			{
+{
-			return EFalse;
+return EFalse;
-			}
+}
-		else if( iExecute && !iExecute->Valid( aTime, aIndividual, aRejection ) )
+else if( iExecute && !iExecute->Valid( aTime, aIndividual, aRejection ) )
-			{
+{
-			return EFalse;
+return EFalse;
-			}
+}
-		else if( iExport && !iExport->Valid( aTime, aIndividual, aRejection ) )
+else if( iExport && !iExport->Valid( aTime, aIndividual, aRejection ) )
-			{
+{
-			return EFalse;
+return EFalse;
-			}
+}
-		break;
+break;
-	}
+}
 return ETrue;
 };
 // -----------------------------------------------------------------------------
 // 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 ) );
+iTopLevel->Merge( *( aPermission.iTopLevel ) );
-	iPlay->Merge( *( aPermission.iPlay ) );
+iPlay->Merge( *( aPermission.iPlay ) );
-	iDisplay->Merge( *( aPermission.iDisplay ) );
+iDisplay->Merge( *( aPermission.iDisplay ) );
-	iExecute->Merge( *( aPermission.iExecute ) );
+iExecute->Merge( *( aPermission.iExecute ) );
-	iPrint->Merge( *( aPermission.iPrint ) );
+iPrint->Merge( *( aPermission.iPrint ) );
-	iExport->Merge( *( aPermission.iExport ) );
+iExport->Merge( *( aPermission.iExport ) );
-	iAvailableRights |= aPermission.iAvailableRights;
+iAvailableRights |= aPermission.iAvailableRights;
-	iInfoBits |= aPermission.iInfoBits;
+iInfoBits |= aPermission.iInfoBits;
-	}
+}
 // End of File

changeset 23	493788a4a8a4
parent 0	95b198f216e5