MCL/sf/mw/drm: comparison omadrm/drmengine/server/src/drmrightsdb.cpp

equal deleted inserted replaced

-:04da681812a9
+:457cd4423b8c
 #include <e32std.h>     // RPointerArray
 #include <e32def.h>     // Type definitions
 #include <hash.h>       // MD5 Algorithm
 // #include <SysUtil.h>    // Disk space checking
+#include <featmgr.h>    // Feature Manager
 #include <f32file.h>
 #include <s32strm.h>
 #include <s32file.h>
 #include <caf/caf.h>
 #include <caf/cafplatform.h>
 // MACROS
 // LOCAL CONSTANTS AND MACROS
 #ifdef RD_MULTIPLE_DRIVE
 // Backup Directory
+#ifdef __DRM_OMA2
 _LIT( KBackupDir, "%c:\\private\\101F51F2\\backup\\" );
+#endif
 #endif
 _LIT(KJavaExtension, ".jar");
 _LIT(KSISExtension, ".sis");
 _LIT(KRODirName, "DomainROs\\");
 _LIT(KCorruptionFlagFile, "invalid");
 #ifdef __DRM_OMA2
-const TInt KMaxUDTDataSize = 256;
-const TInt KDeviceDataSize = 256;
 const TInt KDeviceDataBlock = 128;
-#else
-const TInt KMaxUDTDataSize = 0;
-const TInt KDeviceDataSize = 0;
-const TInt KDeviceDataBlock = 0;
 #endif
-const TInt KUdtDataPos = 4 + KDeviceDataSize;
 const TInt KEncryptionKeySize = 16;
 const TInt KMaxEncryptionSize = 8192;
 const TInt KMaxUpdateTime = 3000000; // consider updates to be finished within
 const TUint32 KMaxTIntVal = 2147483647; // 2^31-1
 // MODULE DATA STRUCTURES
 // LOCAL FUNCTION PROTOTYPES
+#ifdef __DRM_OMA2
 LOCAL_C void CleanupData( TAny* aPtr );
 LOCAL_C void WriteIntToBlock( TInt aValue, TDes8& aBlock, TInt aOffset );
+#endif
 LOCAL_C void DeleteObject( TAny* aObject );
 // FORWARD DECLARATIONS
 // ============================= LOCAL FUNCTIONS ===============================
 // -----------------------------------------------------------------------------
 // CleanupData
 // Used to catch errors and delete the file if it's needed
 // -----------------------------------------------------------------------------
 //
+#ifdef __DRM_OMA2
 LOCAL_C void CleanupData( TAny* aPtr )
 {
 CDRMRightsDB* rdb = reinterpret_cast<CDRMRightsDB*>( aPtr );
 rdb->CleanUdtData();
 aBlock[aOffset] =     (aValue & 0xff000000) >> 24;
 aBlock[aOffset + 1] = (aValue & 0x00ff0000) >> 16;
 aBlock[aOffset + 2] = (aValue & 0x0000ff00) >> 8;
 aBlock[aOffset + 3] = (aValue & 0x000000ff);
 }
+#endif
 // ----------------------------------------------------------------------------
 // DeleteObject
 // Deletes the file by TFileName presented by aHandle
 // ----------------------------------------------------------------------------
 //
 iFileServer.Delete( name );
 DeleteDBL();
 }
 InitializeDatabaseL();
+FeatureManager::InitializeLibL();
 };
 // -----------------------------------------------------------------------------
 // CDRMRightsDB::NewLC
 // Two-phased constructor.
 delete iImei;
 iImei = NULL;
 }
 iMemStream.Close();
+FeatureManager::UnInitializeLib();
 DRMLOG( _L( "RDB Closing." ) );
 };
 // -----------------------------------------------------------------------------
 //
 HBufC8* CDRMRightsDB::GetUdtDataLC()
 {
 #ifdef __DRM_OMA2
+if ( ! ( FeatureManager::FeatureSupported( KFeatureIdFfOmadrm2Support ) ) )
+{
+User::Leave( KErrNotSupported );
+}
+const TInt KMaxUDTDataSize( 256 );
+const TInt KDeviceDataSize( 256 );
+const TInt KUdtDataPos = 4 + KDeviceDataSize;
 HBufC8* udtData = HBufC8::NewMaxLC( KMaxUDTDataSize );
 TFileName backupFile;
 RFile input;
 TInt pos = KUdtDataPos;
 TPtr8 inRead( udtData->Des() );
 #else
 void CDRMRightsDB::InitiateUdtL( const TDesC8& )
 #endif // __DRM_OMA2
 {
 #ifdef __DRM_OMA2
+if ( ! ( FeatureManager::FeatureSupported( KFeatureIdFfOmadrm2Support ) ) )
+{
+User::Leave( KErrNotSupported );
+}
 TFileName backupFile;
 RFile input;
 HBufC8* keyData = NULL;
 MDrmKeyStorage* storage = DrmKeyStorageNewL();
 // first write the first 4 bytes empty, in the end the size is written there
 stream.WriteInt32L( fileSize );
 #ifdef __DRM_OMA2
-AddUDTDataL( stream );
+if ( FeatureManager::FeatureSupported ( KFeatureIdFfOmadrm2Support ) )
+{
+AddUDTDataL( stream );
+}
 #endif
 encIV.SetLength(KEncryptionKeySize);
 // fill the iv with rnd data and write it to stream:
 MDrmKeyStorage* storage = DrmKeyStorageNewL();
 // The file will be opened and closed in CDRMBackup
 // -----------------------------------------------------------------------------
 //
 void CDRMRightsDB::RestoreContentFromFileL( RFile& aBackupFile,
 const TDesC8& aEncryptionKey,
 const TInt aMode )
 {
 // RFileLogger::Write(KLogDir, KLogName, EFileLoggingModeAppend, _L8("RestoreContentFromFileL\n\r"));
 TInt8 continueMarker = 1;
 TBuf8<16> key;
 TBuf8<16> encryptionKey;
 TInt permissions = 0;
+// Default values when OMA2 DRM is not supported
+TInt maxUDTDataSize( 0 );
+TInt deviceDataSize( 0 );
+TInt udtDataPos( 4 + deviceDataSize );
 CDRMPermission* permission = CDRMPermission::NewLC();
 CDRMCommonData *commonData = NULL;
 CDRMPointerArray<CDRMPermission> *permissionArray = CDRMPointerArray<CDRMPermission>::NewLC();
 permissionArray->SetAutoCleanup( ETrue );
 TDRMUniqueID uniqueID = 0;
 RFile fileHandle;
 TInt readPos = 0;
 TInt size = 0;
 TInt dataLeft = 0;
 TPtr8 keyData(NULL,0,0);
+#ifdef __DRM_OMA2
+if ( FeatureManager::FeatureSupported( KFeatureIdFfOmadrm2Support ) )
+{
+		maxUDTDataSize = 256;
+		deviceDataSize = 256;
+		udtDataPos = 4 + deviceDataSize;
+		}
+#endif
 // maintain knowledge about stateful rights not being restored
 TBool stateful = EFalse;
 DRMLOG( _L( "CDRMRightsDB::RestoreContentFromFileL ->" ) );
 // Indicate that the DB is updated
 iLastUpdate.HomeTime();
 encIV.SetLength( KEncryptionKeySize );
 // Check that the decryption works, if it doesn't then the
 // key is faulty
 User::LeaveIfError( aBackupFile.Size( readPos ) );
-if( readPos < KUdtDataPos+KMaxUDTDataSize+(KEncryptionKeySize*2) )
+if( readPos < udtDataPos+maxUDTDataSize+(KEncryptionKeySize*2) )
 {
 // RFileLogger::Write(KLogDir, KLogName, EFileLoggingModeAppend, _L8("RestoreContentFromFileL : corrupt\n\r"));
 User::Leave(KErrCorrupt);
 }
 readPos -= KEncryptionKeySize*2;
 // Now we are ready to go through the file
 //-----------------------------------------------------------------------
 // Duplicate file handle
-readPos = KUdtDataPos+KMaxUDTDataSize;
+readPos = udtDataPos+maxUDTDataSize;
 User::LeaveIfError( fileHandle.Seek( ESeekStart, readPos ) );
 iMemStream.Close();
 ReadDataL( fileHandle, encIV, readData, dataBuffer,
 dataLeft, size, ETrue, encryptionKey );
 {
 keyExists = ETrue;
 counter = KEncryptionKeySize;
 }
 }
 // Encrypt the key
 if( keyExists )
 {
 ModifyKey( key );
 if( !rights )
 {
 User::Leave( KErrGeneral );
 }
 if( insertPerm == -1 ) // Add everything no checks needed
 {
 for( TInt count = 0; count < permissions; count++ )
 {
 if( dataLeft < 4 )
 User::LeaveIfError(error);
 }
 }
 for( TInt count = 0; count < permissions; count++ )
 {
 if( dataLeft < 4 )
 {
 size = 4;
 // to enable UDT
 if( stateful )
 {
 User::Leave( KErrPermissionDenied );
 }
 };
 // -----------------------------------------------------------------------------
 #else
 void CDRMRightsDB::AddUDTDataL( RWriteStream& )
 #endif // __DRM_OMA2
 {
 #ifdef __DRM_OMA2
+if ( ! ( FeatureManager::FeatureSupported( KFeatureIdFfOmadrm2Support ) ) )
+{
+User::Leave( KErrNotSupported );
+}
+const TInt KMaxUDTDataSize( 256 );
 TBuf8<MDrmKeyStorage::KRdbSerialNumberLength> serialNumber;
 TBuf8<KMaxUDTDataSize> buffer;
 TUint8* ptr = const_cast<TUint8*>(buffer.Ptr());
 HBufC8* result = NULL;
 TPtr8 udtData( ptr+KDeviceDataBlock, KDeviceDataBlock, KDeviceDataBlock );
 // test function
 void CDRMRightsDB::CreateDummyUDTFileL()
 {
 #ifdef __DRM_OMA2
+if ( ! ( FeatureManager::FeatureSupported( KFeatureIdFfOmadrm2Support ) ) )
+{
+User::Leave( KErrNotSupported );
+}
 TFileName backupFile;
 RFile input;
 TInt fileSize = 4 + 256 + 256;
 backupFile.Copy( _L("c:\\") );
 // -----------------------------------------------------------------------------
 //
 void CDRMRightsDB::CleanUdtData()
 {
 #ifdef __DRM_OMA2
+if ( ! ( FeatureManager::FeatureSupported( KFeatureIdFfOmadrm2Support ) ) )
+{
+return;
+}
 TFileName backupFile;
 #ifndef RD_MULTIPLE_DRIVE
 backupFile.Copy( KBackupDirectory );

branch	RCL_3
changeset 16	457cd4423b8c
parent 12	8a03a285ab14
child 22	ad2863178d17