diff -r e16d72588c28 -r 8a03a285ab14 omadrm/drmengine/server/src/DRMRightsClient.cpp --- a/omadrm/drmengine/server/src/DRMRightsClient.cpp Fri Mar 12 15:43:46 2010 +0200 +++ b/omadrm/drmengine/server/src/DRMRightsClient.cpp Mon Mar 15 12:41:43 2010 +0200 @@ -21,16 +21,16 @@ #include #include "DRMRightsClient.h" #include "DRMEngineClientServer.h" -#include "DRMPermission.h" -#include "DRMAsset.h" +#include "DrmPermission.h" +#include "DrmAsset.h" #include "drmlog.h" #ifdef __DRM_FULL -#include "RDRMHelper.h" +#include "rdrmhelper.h" #endif // EXTERNAL DATA STRUCTURES -// EXTERNAL FUNCTION PROTOTYPES +// EXTERNAL FUNCTION PROTOTYPES // CONSTANTS // MACROS @@ -51,45 +51,45 @@ struct TDRMFileDeletion { TDRMFileDeletion() : iName( KNullDesC ) {}; - ~TDRMFileDeletion() + ~TDRMFileDeletion() { if ( iName.Length() ) { iFs.Delete( iName ); } - + iFs.Close(); } - + RFs iFs; TFileName iName; }; template< class T > struct RDRMArrayReset { - RDRMArrayReset( T& aItem ) : iItem( aItem ), + RDRMArrayReset( T& aItem ) : iItem( aItem ), iCleanup( ResetAndDestroy, ( TAny* )this ) {}; ~RDRMArrayReset() { }; - void PushL() + void PushL() { CleanupStack::PushL( iCleanup ); }; - - static void ResetAndDestroy( TAny* aSelf ) + + static void ResetAndDestroy( TAny* aSelf ) { - ( ( RDRMArrayReset< T >* )( aSelf ) )->iItem.ResetAndDestroy(); + ( ( RDRMArrayReset< T >* )( aSelf ) )->iItem.ResetAndDestroy(); ( ( RDRMArrayReset< T >* )( aSelf ) )->iItem.Close(); }; - - private: + + private: RDRMArrayReset(); // prohibit - + private: T& iItem; TCleanupItem iCleanup; - + }; - + // LOCAL FUNCTION PROTOTYPES // FORWARD DECLARATIONS @@ -108,7 +108,7 @@ iPtr( NULL ) { } - + // ----------------------------------------------------------------------------- // RDRMRightsClient::~RDRMRightsClient // Destructor. @@ -116,7 +116,7 @@ // EXPORT_C RDRMRightsClient::~RDRMRightsClient() { - } + } // ----------------------------------------------------------------------------- // RDRMRightsClient::Connect @@ -126,45 +126,45 @@ EXPORT_C TInt RDRMRightsClient::Connect() { TInt ret = KErrNone; - TUint8 count = 0; - - const TVersion requiredVersion( + TUint8 count = 0; + + const TVersion requiredVersion( DRMEngine::KServerMajorVersion, DRMEngine::KServerMinorVersion, DRMEngine::KServerBuildVersion ); - + FOREVER { DRMLOG( _L( "RDRMRightsClient::Connect(): Create a new session" ) ); ret = CreateSession( DRMEngine::KServerName, - requiredVersion, + requiredVersion, KMaxMessageSlots ); - + if ( ret == KErrNotFound && count < KStartupCount ) { ret = StartServer(); if ( ret ) { - break; + break; } - + ++count; } else { - break; + break; } } #ifdef __DRM_FULL - // startup code, if it starts it starts if not it will be tried again. + // startup code, if it starts it starts if not it will be tried again. RDRMHelper helper; TInt ignore = helper.Connect(); // Start HelperServer - helper.Close(); -#endif + helper.Close(); +#endif DRMLOG2( _L( "RDRMRightsClient::Connect(): Result: %d" ), ret ); - + return ret; } @@ -173,7 +173,7 @@ // Closes the connection to the server. // ----------------------------------------------------------------------------- // -EXPORT_C void RDRMRightsClient::Close() +EXPORT_C void RDRMRightsClient::Close() { DRMLOG( _L( "RDRMRightsClient::Close()" ) ); RHandleBase::Close(); @@ -182,14 +182,14 @@ EXPORT_C TInt RDRMRightsClient::StartServer() { DRMLOG( _L( "RDRMRightsClient::StartServer()" ) ); - + RSemaphore semaphore; RSemaphore semaphore2; TFindServer server( DRMEngine::KServerName ); TFullName name; RProcess process; TInt error = KErrNone; - + // "local" semaphore error = semaphore2.CreateGlobal( KRightsServerStarterSemaphore, // name 1 , // count @@ -198,7 +198,7 @@ if ( error == KErrAlreadyExists ) { error = semaphore2.OpenGlobal( KRightsServerStarterSemaphore ); - } + } // Semaphore not created or opened, don't need to close @@ -206,61 +206,61 @@ { return error; } - - // Server updated semaphore + + // Server updated semaphore error = semaphore.CreateGlobal( DRMEngine::KDRMSemaphore, // name 0 , // count EOwnerThread ); // owner - + if ( error == KErrAlreadyExists ) { error = semaphore.OpenGlobal( DRMEngine::KDRMSemaphore ); - } - + } + // Semaphore not created or opened, don't need to close if( error ) { semaphore2.Close(); return error; } - + // Wait until server has done all its things. semaphore2.Wait(); - + // Check if the server is already running. error = server.Next( name ); - + if ( !error ) { // Yep, it's already running. error = KErrNone; } - else + else { error = process.Create( KServerFileName, KNullDesC ); - + if ( !error ) { User::After( 1000 ); - + process.Resume(); process.Close(); - + // Wait here for the server process startup to complete // server will signal the global semaphore semaphore.Wait(); } } - - // Close both semaphores and signal the "local" one. - semaphore.Close(); + + // Close both semaphores and signal the "local" one. + semaphore.Close(); semaphore2.Signal(); - semaphore2.Close(); - + semaphore2.Close(); + DRMLOG2( _L( "RDRMRightsClient::StartServer(): %d" ), error ); - return error; - + return error; + } // ----------------------------------------------------------------------------- @@ -270,21 +270,21 @@ // EXPORT_C TInt RDRMRightsClient::AddRecord( const TDesC8& aCEK, // Content encryption key // The rights object which is to be added - const CDRMPermission& aRightsObject, - const TDesC8& aCID, // Content-ID + const CDRMPermission& aRightsObject, + const TDesC8& aCID, // Content-ID TDRMUniqueID& aID ) // Unique ID, out-parameter { DRMLOG( _L( "RDRMRightsClient::AddRecord" ) ); TInt error = KErrArgument; - + // Check the parameters. if ( aCEK.Length() ) { - + HBufC8* rightsData = NULL; TRAP( error, rightsData = aRightsObject.ExportL() ); TInt size = aRightsObject.Size(); - + if ( rightsData && size > 0 ) { // For C/S communications. @@ -292,21 +292,21 @@ TPtr8 uid( reinterpret_cast< TUint8* >( &aID ), 0, sizeof( TDRMUniqueID ) ); - + rightsObject.Set( const_cast< TUint8* >( rightsData->Ptr() ), size, size ); - - + + // Send the message. - error = SendReceive( DRMEngine::EAddRecord, + error = SendReceive( DRMEngine::EAddRecord, TIpcArgs( &aCID, &rightsObject, &aCEK, &uid ) ); - + delete rightsData; rightsData = NULL; } } - + DRMLOG2( _L( "RDRMRightsClient::AddRecord: %d" ), error ); return error; } @@ -325,33 +325,33 @@ TDRMUniqueID& aID ) // Unique ID, out-parameter { DRMLOG( _L( "RDRMRightsClient::AddProtectedRecord" ) ); - - TInt error = KErrNone; - TInt message = DRMEngine::EAddProtectedRecord; - HBufC8* rightsData = NULL; - TInt size = aRightsObject.Size(); - TPtr8 rightsObject( NULL, 0 ); - TPtr8 uid( reinterpret_cast< TUint8* >( &aID ), 0, - sizeof( TDRMUniqueID ) ); - TPtr8 key( NULL, 0 ); - - TRAP( error, rightsData = aRightsObject.ExportL() ); - if ( !error ) - { - rightsObject.Set( const_cast< TUint8* >( rightsData->Ptr() ), size, + + TInt error = KErrNone; + TInt message = DRMEngine::EAddProtectedRecord; + HBufC8* rightsData = NULL; + TInt size = aRightsObject.Size(); + TPtr8 rightsObject( NULL, 0 ); + TPtr8 uid( reinterpret_cast< TUint8* >( &aID ), 0, + sizeof( TDRMUniqueID ) ); + TPtr8 key( NULL, 0 ); + + TRAP( error, rightsData = aRightsObject.ExportL() ); + if ( !error ) + { + rightsObject.Set( const_cast< TUint8* >( rightsData->Ptr() ), size, size ); - - if ( aDomainRecord ) + + if ( aDomainRecord ) { message = DRMEngine::EAddDomainRecord; - } + } error = SendReceive( message, TIpcArgs( &aCID, &rightsObject, &aProtectedCek, &uid ) ); delete rightsData; rightsData = NULL; } - DRMLOG2( _L( "RDRMRightsClient::AddProtectedRecord: %d" ), error ); - return error; + DRMLOG2( _L( "RDRMRightsClient::AddProtectedRecord: %d" ), error ); + return error; } // ----------------------------------------------------------------------------- @@ -365,28 +365,28 @@ { DRMLOG( _L( "RDRMRightsClient::GetDBEntries" ) ); if( aId.Length() ) - { + { // Temporary file name from the server. TDRMFileDeletion item; - + // Make sure that the array is empty. aRightsList.ResetAndDestroy(); - + // For file operations. Destructor of TDRMFileDeletion // deletes the file & closes the session. - User::LeaveIfError( item.iFs.Connect() ); - - User::LeaveIfError( SendReceive( DRMEngine::EGetEntryList, + User::LeaveIfError( item.iFs.Connect() ); + + User::LeaveIfError( SendReceive( DRMEngine::EGetEntryList, TIpcArgs( &item.iName, &aId ) ) ); - + // Convert the file to a list. FileToListL( item.iFs, item.iName, aRightsList ); - - DRMLOG( _L( "RDRMRightsClient::GetDBEntries ok" ) ); - + + DRMLOG( _L( "RDRMRightsClient::GetDBEntries ok" ) ); + return; } - + // Invalid parameter. User::Leave( KErrArgument ); } @@ -400,7 +400,7 @@ const TDRMUniqueID& aUniqueID ) { DRMLOG( _L( "RDRMRightsClient::GetDbEntryL" ) ); - + CDRMPermission* permission = NULL; TInt size = 0; TPckg package( size ); @@ -414,12 +414,12 @@ size ); User::LeaveIfError( SendReceive( DRMEngine::EGetPreparedData, TIpcArgs( &objectPkg) ) ); - + permission = CDRMPermission::NewLC(); permission->ImportL( rightsData->Des() ); CleanupStack::Pop(); // permission CleanupStack::PopAndDestroy(); // Rights data - + DRMLOG( _L( "RDRMRightsClient::GetDbEntryL ok" ) ); return permission; } @@ -432,16 +432,16 @@ EXPORT_C TInt RDRMRightsClient::DeleteDbEntry( const TDesC8& aContentID ) { DRMLOG( _L( "RDRMRightsClient::DeleteDbEntry with CID" ) ); - + TInt error = KErrArgument; - + // Check the parameter. if ( aContentID.Length() ) { - return SendReceive( DRMEngine::EDeleteWithCID, + return SendReceive( DRMEngine::EDeleteWithCID, TIpcArgs( NULL, NULL, &aContentID ) ); } - + return error; } @@ -454,26 +454,26 @@ const TDRMUniqueID& aUniqueID ) { DRMLOG( _L( "RDRMRightsClient::DeleteDbEntry with CID & UID" ) ); - + if ( aContentID.Length() ) { // Something to do. // Put aUniqueID inside a descriptor. // Works even if its typedef is changed. - TPtrC8 uid( reinterpret_cast< TUint8* >( + TPtrC8 uid( reinterpret_cast< TUint8* >( const_cast< TDRMUniqueID* >( &aUniqueID ) ), sizeof( TDRMUniqueID ) ); - - return SendReceive( DRMEngine::EDeleteRO, + + return SendReceive( DRMEngine::EDeleteRO, TIpcArgs( &uid, NULL, NULL, &aContentID ) ); } - + return KErrArgument; } // ----------------------------------------------------------------------------- // RDRMRightsClient::ExportContentIDList -// Overloaded method: requests all content IDs to be put to a file. +// Overloaded method: requests all content IDs to be put to a file. // Assumes that the given descriptor represents a buffer large enough to // contain the file name. // ----------------------------------------------------------------------------- @@ -481,15 +481,15 @@ EXPORT_C TInt RDRMRightsClient::ExportContentIDList( TDes& aFileName ) { DRMLOG( _L( "RDRMRightsClient::ExportContentIDLis" ) ); - - return SendReceive( DRMEngine::EExportCIDs, + + return SendReceive( DRMEngine::EExportCIDs, TIpcArgs( &aFileName ) ); - + } // ----------------------------------------------------------------------------- // RDRMRightsClient::ExportContentIDList -// Overloaded method: requests all content IDs to be put to a file, +// Overloaded method: requests all content IDs to be put to a file, // and then converts the file into RPointerArray. // ----------------------------------------------------------------------------- // @@ -498,7 +498,7 @@ DRMLOG( _L( "RDRMRightsClient::ExportContentIDList to array" ) ); TFileName name; aCIDList.ResetAndDestroy(); - + TInt error = ExportContentIDList( name ); if ( !error ) { @@ -511,14 +511,14 @@ { aCIDList.ResetAndDestroy(); } - + fs.Delete( name ); fs.Close(); } } - + DRMLOG2( _L( "RDRMRightsClient::ExportContentIDList: %d" ), error ); - + return error; } @@ -540,11 +540,11 @@ SendReceive( DRMEngine::EGetKey, TIpcArgs( aIntent, const_cast(&aContentID), &aKey ), status ); - + User::WaitForRequest( status ); DRMLOG2( _L( "RDRMRightsClient::GetDecryptionKey: %d" ), status.Int() ); - + return status.Int(); } @@ -560,16 +560,16 @@ { TInt error = KErrNone; TInt size = 0; - + TPckg package( size ); TPckg package2( aRejection ); - + DRMLOG( _L( "RDRMRightsClient::CheckRights" ) ); error = SendReceive( DRMEngine::ECheckRights, TIpcArgs( aIntent, &aContentID, &package, &package2 ) ); - + DRMLOG2( _L( "RDRMRightsClient::CheckRights: %d" ), error ); - + return error; } @@ -587,10 +587,10 @@ TInt r; TInt size = 0; TPckg package( size ); - TPckg package2( aRejection ); + TPckg package2( aRejection ); CDRMPermission* permission = NULL; HBufC8* buffer = NULL; - + DRMLOG( _L( "RDRMRightsClient::GetActiveRightsL" ) ); r = SendReceive( DRMEngine::ECheckRights, TIpcArgs( aIntent, &aContentID, &package, &package2 ) ); @@ -613,7 +613,7 @@ { User::Leave( r ); } - + DRMLOG( _L( "RDRMRightsClient::GetActiveRightsL: done" ) ); return permission; } @@ -631,21 +631,21 @@ TInt count = 0; TInt error = KErrNone; - + TPtr8 ptr( reinterpret_cast< TUint8* >( &count ), - 0, + 0, sizeof( TInt ) ); - - error = SendReceive( DRMEngine::ECount, + + error = SendReceive( DRMEngine::ECount, TIpcArgs( &ptr ) ); - + if ( !error ) { error = count; } - + DRMLOG2( _L( "RDRMRightsClient::Count: %d" ), error ); - + return error; } @@ -657,11 +657,11 @@ EXPORT_C TInt RDRMRightsClient::DeleteAll() { DRMLOG( _L( "RDRMRightsClient::DeleteAll" ) ); - - TInt error = SendReceive( DRMEngine::EDeleteAll, TIpcArgs( NULL ) ); + + TInt error = SendReceive( DRMEngine::EDeleteAll, TIpcArgs( NULL ) ); DRMLOG2( _L( "RDRMRightsClient::DeleteAll: %d" ), error ); - + return error; } @@ -670,13 +670,13 @@ // Consume the right with specific intent and contentID // ----------------------------------------------------------------------------- // -EXPORT_C TInt RDRMRightsClient::Consume( const TInt aIntent, +EXPORT_C TInt RDRMRightsClient::Consume( const TInt aIntent, const TDesC8& aContentID ) { TInt error = KErrNone; DRMLOG( _L( "RDRMRightsClient::Consume" ) ); - - error = SendReceive( DRMEngine::EConsume, + + error = SendReceive( DRMEngine::EConsume, TIpcArgs( aIntent, &aContentID ) ); DRMLOG2( _L( "RDRMRightsClient::Consume: %d" ), error ); @@ -688,13 +688,13 @@ // Check if Consume is possibke // ----------------------------------------------------------------------------- // -EXPORT_C TInt RDRMRightsClient::CheckConsume( const TInt aIntent, +EXPORT_C TInt RDRMRightsClient::CheckConsume( const TInt aIntent, const TDesC8& aContentID ) { TInt error = KErrNone; DRMLOG( _L( "RDRMRightsClient::CheckConsume" ) ); - - error = SendReceive( DRMEngine::ECheckConsume, + + error = SendReceive( DRMEngine::ECheckConsume, TIpcArgs( aIntent, &aContentID ) ); DRMLOG2( _L( "RDRMRightsClient::CheckConsume: %d" ), error ); @@ -717,7 +717,7 @@ // ----------------------------------------------------------------------------- // RDRMRightsClient:: -// +// // ----------------------------------------------------------------------------- // EXPORT_C TInt RDRMRightsClient::ForwardLockURI( HBufC8*& aURI ) @@ -726,20 +726,20 @@ TBuf8< DRMEngine::KMaxOmaV1CIDLength > buf; TInt error = SendReceive( DRMEngine::EGetFLUri, TIpcArgs( &buf ) ); - + if ( error ) { aURI = NULL; return error; } - + aURI = buf.Alloc(); if ( aURI ) { return KErrNone; } - + return KErrNoMemory; } @@ -749,23 +749,23 @@ // Add domain rights object xml representation to the rdb // ----------------------------------------------------------------------------- // -EXPORT_C TInt RDRMRightsClient::AddDomainRO( const TDesC8& aRoId, +EXPORT_C TInt RDRMRightsClient::AddDomainRO( const TDesC8& aRoId, const TDesC8& aXmlData ) { DRMLOG( _L( "RDRMRightsClient::AddDomainRO" ) ); TInt error = KErrArgument; - + // Check the parameters. if ( aRoId.Length() && aXmlData.Length() ) - { + { // Send the message. - error = SendReceive( DRMEngine::EAddDomainRO, + error = SendReceive( DRMEngine::EAddDomainRO, TIpcArgs( &aRoId, &aXmlData) ); } - + DRMLOG2( _L( "RDRMRightsClient::AddDomainRO: %d" ), error ); - return error; - }; + return error; + }; // ----------------------------------------------------------------------------- // RDRMRightsClient::GetDomainROL @@ -775,37 +775,37 @@ EXPORT_C HBufC8* RDRMRightsClient::GetDomainROL( const TDesC8& aRoId ) { DRMLOG( _L( "RDRMRightsClient::GetDomainROL" ) ); - + // Check the parameter. if ( aRoId.Length() ) { TInt size = 0; TPckg package( size ); - + // Call the server. Throw an exception in case of an error. - User::LeaveIfError( - SendReceive( DRMEngine::EGetDomainRO, + User::LeaveIfError( + SendReceive( DRMEngine::EGetDomainRO, TIpcArgs( &package, &aRoId ) ) ); HBufC8* roData = HBufC8::NewMaxLC( size ); - + // Package 'object' into TPtr8. TPtr8 objectPkg( const_cast< TUint8* >( roData->Ptr() ), size, size ); - User::LeaveIfError( - SendReceive( DRMEngine::EGetPreparedData, + User::LeaveIfError( + SendReceive( DRMEngine::EGetPreparedData, TIpcArgs( &objectPkg) ) ); - CleanupStack::Pop( roData ); // roData + CleanupStack::Pop( roData ); // roData return roData; } - + User::Leave( KErrArgument ); - + // Never reached. - return NULL; - }; + return NULL; + }; // ----------------------------------------------------------------------------- // RDRMRightsClient::GetDomainROL @@ -823,7 +823,7 @@ TInt roSize; TInt offset; - + DRMLOG(_L("RDRMRightsClient::GetDomainRoForCidL")); User::LeaveIfError(SendReceive(DRMEngine::EGetDomainRoForCid, TIpcArgs(&aContentId, &pkg))); @@ -839,64 +839,64 @@ while (offset < size) { Mem::Copy( &roSize, ptr.Ptr()+offset, sizeof(TInt) ); - offset += sizeof (TInt); + offset += sizeof (TInt); ro = ptr.Mid(offset, roSize).AllocL(); aRoList.Append(ro); offset += roSize; } CleanupStack::PopAndDestroy(); } - }; + }; // ----------------------------------------------------------------------------- // RDRMRightsClient:: -// +// // ----------------------------------------------------------------------------- // EXPORT_C TInt RDRMRightsClient::Encrypt( const TDesC8& aIv, TPtr8& aData, TBool aAddPadding ) { - return SendReceive( DRMEngine::EEncrypt, + return SendReceive( DRMEngine::EEncrypt, TIpcArgs( &aIv, &aData, aAddPadding ) ); - } + } // ----------------------------------------------------------------------------- // RDRMRightsClient:: -// +// // ----------------------------------------------------------------------------- // EXPORT_C TInt RDRMRightsClient::Decrypt( const TDesC8& aIv, TPtr8& aData, TBool aRemovePadding ) { - return SendReceive( DRMEngine::EDecrypt, + return SendReceive( DRMEngine::EDecrypt, TIpcArgs( &aIv, &aData, aRemovePadding ) ); - } + } // ----------------------------------------------------------------------------- // RDRMRightsClient:: -// +// // ----------------------------------------------------------------------------- // EXPORT_C TInt RDRMRightsClient::InitializeKey( const TDesC8& aContentId ) { - return SendReceive( DRMEngine::EInitializeKey, + return SendReceive( DRMEngine::EInitializeKey, TIpcArgs( &aContentId ) ); } // ----------------------------------------------------------------------------- // RDRMRightsClient:: -// +// // ----------------------------------------------------------------------------- // EXPORT_C TInt RDRMRightsClient::InitializeGroupKey( const TDesC8& aGroupId, const TDesC8& aGroupKey, TEncryptionMethod aMethod ) { - return SendReceive( DRMEngine::EInitializeGroupKey, + return SendReceive( DRMEngine::EInitializeGroupKey, TIpcArgs( &aGroupId, &aGroupKey, aMethod ) ); - } + } // ----------------------------------------------------------------------------- // RDRMRightsClient::DeleteDomainRO @@ -906,21 +906,21 @@ EXPORT_C TInt RDRMRightsClient::DeleteDomainRO( const TDesC8& aRoId ) { DRMLOG( _L( "RDRMRightsClient::DeleteDomainRO" ) ); - + // Check the parameter. if ( aRoId.Length() ) { - return SendReceive( DRMEngine::EDeleteDomainRO, + return SendReceive( DRMEngine::EDeleteDomainRO, TIpcArgs( &aRoId ) ); } - - return KErrArgument; - }; + + return KErrArgument; + }; // ----------------------------------------------------------------------------- // RDRMRightsClient:: -// +// // ----------------------------------------------------------------------------- // EXPORT_C TInt RDRMRightsClient::IsInCache( const TDesC8& aID, @@ -930,68 +930,68 @@ DRMLOG( _L( "RDRMRightsClient::IsInCache" ) ); TPckgC< TTime > timePckg( aTime ); TPckg< TBool > inCache( aInCache ); - + return SendReceive( DRMEngine::EIsInCache, TIpcArgs( &aID, &timePckg, &inCache ) ); } - + // ----------------------------------------------------------------------------- // RDRMRightsClient:: -// +// // ----------------------------------------------------------------------------- // EXPORT_C TInt RDRMRightsClient::IsInCache( const TDesC8& aID, TBool& aInCache ) { DRMLOG( _L( "RDRMRightsClient::IsInCache" ) ); - + TPckg< TBool > inCache( aInCache ); - + return SendReceive( DRMEngine::EIsInCache, TIpcArgs( &aID, NULL, &inCache ) ); } - + // ----------------------------------------------------------------------------- // RDRMRightsClient:: -// +// // ----------------------------------------------------------------------------- // EXPORT_C TInt RDRMRightsClient::AddToCache( const TDesC8& aID, const TTime& aTime ) { DRMLOG( _L( "RDRMRightsClient::AddToCache" ) ); - + TPckgC< TTime > timePckg( aTime ); - + return SendReceive( DRMEngine::EAddToCache, TIpcArgs( &aID, &timePckg ) ); } // ----------------------------------------------------------------------------- // RDRMRightsClient:: -// +// // ----------------------------------------------------------------------------- // EXPORT_C TInt RDRMRightsClient::AddToCache( const TDesC8& aID ) { DRMLOG( _L( "RDRMRightsClient::AddToCache" ) ); - + return SendReceive( DRMEngine::EAddToCache, TIpcArgs( &aID, NULL ) ); } // ----------------------------------------------------------------------------- // RDRMRightsClient::DeleteExpiredPermissions -// +// // ----------------------------------------------------------------------------- // EXPORT_C void RDRMRightsClient::DeleteExpiredPermissions( TRequestStatus& aStatus ) { DRMLOG( _L( "RDRMRightsClient::DeleteExpiredPermissions" ) ); - + SendReceive( DRMEngine::EDeleteExpired, aStatus ); } - + // ----------------------------------------------------------------------------- // RDRMRightsClient::SetEstimatedArrival // sets the estimated RO arrival time to the given delta @@ -1004,13 +1004,13 @@ TInt error = KErrNone; TPckg< TTimeIntervalSeconds > delta( aDeltaSeconds ); - - error = SendReceive( DRMEngine::ESetEstimatedArrival, + + error = SendReceive( DRMEngine::ESetEstimatedArrival, TIpcArgs( &aContentID, &delta ) ); - - return error; + + return error; }; - + // ----------------------------------------------------------------------------- // RDRMRightsClient::GetEstimatedArrival // sets the amount of time in which the RO should arrive in @@ -1023,14 +1023,14 @@ TInt error = KErrNone; TPckg< TTimeIntervalSeconds > delta( aDeltaSeconds ); - - error = SendReceive( DRMEngine::EGetEstimatedArrival, + + error = SendReceive( DRMEngine::EGetEstimatedArrival, TIpcArgs( &aContentID, &delta ) ); - - return error; - }; - - + + return error; + }; + + // ----------------------------------------------------------------------------- // RDRMRightsClient::SetName // sets the name. @@ -1043,18 +1043,18 @@ return SendReceive( DRMEngine::ESetName, TIpcArgs( &aContentID, &aName ) ); } - + // ----------------------------------------------------------------------------- // RDRMRightsClient::GetName // Gets the name. Two-phase operation. // ----------------------------------------------------------------------------- -// +// EXPORT_C TInt RDRMRightsClient::GetName( const TDesC8& aContentID, HBufC*& aName ) { DRMLOG( _L( "RDRMRightsClient::GetName" ) ); TPckgBuf< TInt > size( 0 ); - + TInt error = SendReceive( DRMEngine::EGetName, TIpcArgs( &aContentID, &size ) ); if ( !error ) @@ -1073,10 +1073,10 @@ if ( aName ) { TPtr data( aName->Des() ); - + error = SendReceive( DRMEngine::EGetWideData, TIpcArgs( &data ) ); - + if ( error ) { delete aName; aName = NULL; @@ -1088,47 +1088,47 @@ } } } - + return error; } // ----------------------------------------------------------------------------- // RDRMRightsClient::Cancel // ----------------------------------------------------------------------------- -// +// EXPORT_C void RDRMRightsClient::Cancel() { DRMLOG( _L(" RDRMRightsClient::Cancel" ) ); SendReceive( DRMEngine::ECancel ); } - - + + // ----------------------------------------------------------------------------- // RDRMRightsClient::GetUdtData // ----------------------------------------------------------------------------- -// +// EXPORT_C TInt RDRMRightsClient::GetUdtData( TDes8& aUdtData ) { DRMLOG( _L( "RDRMRightsClient::GetUdtData" ) ); - + TInt error = SendReceive( DRMEngine::EGetUdtData, TIpcArgs( &aUdtData ) ); - - return error; - }; + + return error; + }; // ----------------------------------------------------------------------------- // RDRMRightsClient::InitializeUdt // ----------------------------------------------------------------------------- -// +// EXPORT_C TInt RDRMRightsClient::InitiateUdt( const TDesC8& aKey ) { DRMLOG( _L( "RDRMRightsClient::InitiateUdt" ) ); - + TInt error = SendReceive( DRMEngine::EInitiateUdt, - TIpcArgs( &aKey ) ); - return error; - }; + TIpcArgs( &aKey ) ); + return error; + }; // ----------------------------------------------------------------------------- // RDRMRightsClient::InitOrphanedContentIdList @@ -1138,38 +1138,38 @@ TRequestStatus& aStatus ) { DRMLOG( _L( "RDRMRightsClient::ExportOrphanedContentIdList" ) ); - - SendReceive( DRMEngine::EInitOrphanedList, + + SendReceive( DRMEngine::EInitOrphanedList, TIpcArgs( aPerformScan ), aStatus ); - - DRMLOG( _L( "RDRMRightsClient::ExportOrphanedContentIdList done" ) ); + + DRMLOG( _L( "RDRMRightsClient::ExportOrphanedContentIdList done" ) ); }; // ----------------------------------------------------------------------------- // RDRMRightsClient::ExportOrphanedContentIdList // ----------------------------------------------------------------------------- -// +// EXPORT_C TInt RDRMRightsClient::ExportOrphanedContentIdList( TDes& aFileName ) { DRMLOG( _L( "RDRMRightsClient::ExportOrphanedContentIdList" ) ); - - return SendReceive( DRMEngine::EGetOrphanedList, + + return SendReceive( DRMEngine::EGetOrphanedList, TIpcArgs( &aFileName ) ); - - }; - + + }; + // ----------------------------------------------------------------------------- // RDRMRightsClient::ExportOrphanedContentIdList // ----------------------------------------------------------------------------- -// -EXPORT_C TInt RDRMRightsClient::ExportOrphanedContentIdList( +// +EXPORT_C TInt RDRMRightsClient::ExportOrphanedContentIdList( RPointerArray& aContentIdList ) { DRMLOG( _L( "RDRMRightsClient::ExportOrphanedContentIdList to array" ) ); TFileName name; aContentIdList.ResetAndDestroy(); - + TInt error = ExportOrphanedContentIdList( name ); if ( !error ) { @@ -1182,16 +1182,16 @@ { aContentIdList.ResetAndDestroy(); } - + fs.Delete( name ); fs.Close(); } } - + DRMLOG2( _L( "RDRMRightsClient::ExportOrphanedContentIdList to array: %d" ), error ); - - return error; - }; + + return error; + }; // ----------------------------------------------------------------------------- // RDRMRightsClient::EncodeRightsIssuerField @@ -1201,28 +1201,28 @@ // - base64encode(AES IV + AES encoded original field incl. padding) // ----------------------------------------------------------------------------- // -EXPORT_C TInt RDRMRightsClient::EncodeRightsIssuerField( +EXPORT_C TInt RDRMRightsClient::EncodeRightsIssuerField( const TDesC8& aOldValue, HBufC8*& aNewValue ) { DRMLOG( _L( "RDRMRightsClient::EncodeRightsIssuerField" ) ); TInt error( KErrNone ); - + TInt size( aOldValue.Length() ); // original length size += KDCFKeySize - ( size % KDCFKeySize ); // padding size += KDCFKeySize; // IV size += ( size + 2 ) / 3 * 4; // base64 size += RMobilePhone::KPhoneSerialNumberSize; size += 3; // "flk" - + aNewValue = HBufC8::New( size ); if ( aNewValue ) { TPtr8 des( aNewValue->Des() ); - + des = aOldValue; - + error = SendReceive( DRMEngine::EEncodeRightsIssuerField, TIpcArgs( &des ) ); if ( error ) @@ -1235,25 +1235,25 @@ { error = KErrNoMemory; } - + DRMLOG2( _L( "RDRMRightsClient::EncodeRightsIssuerField> %d" ), error ); - + return error; } - -EXPORT_C TInt RDRMRightsClient::DecodeRightsIssuerField( + +EXPORT_C TInt RDRMRightsClient::DecodeRightsIssuerField( const TDesC8& aEncoded, HBufC8*& aDecoded ) { DRMLOG( _L( "DRMRightsClient::DecodeRightsIssuerField" ) ); - + TInt error( KErrNone ); - + aDecoded = HBufC8::New( aEncoded.Length() ); if ( aDecoded ) { TPtr8 des( aDecoded->Des() ); - + error = SendReceive( DRMEngine::EDecodeRightsIssuerField, TIpcArgs( &aEncoded, &des ) ); @@ -1272,15 +1272,15 @@ { error = KErrNoMemory; } - + DRMLOG2( _L( "DRMRightsClient::DecodeRightsIssuerField: error %d" ), error ); - + return error; } - + // ----------------------------------------------------------------------------- // RDRMRightsClient::SetAuthenticationSeed -// +// // ----------------------------------------------------------------------------- // EXPORT_C TInt RDRMRightsClient::SetAuthenticationSeed( const TDesC8& aContentID, @@ -1290,10 +1290,10 @@ return SendReceive( DRMEngine::ESetAuthenticationSeed, TIpcArgs( &aContentID, &aSeed ) ); } - + // ----------------------------------------------------------------------------- // RDRMRightsClient::GetAuthenticationSeed -// +// // ----------------------------------------------------------------------------- // EXPORT_C TInt RDRMRightsClient::GetAuthenticationSeed( const TDesC8& aContentID, @@ -1302,7 +1302,7 @@ DRMLOG( _L( "RDRMRightsClient::GetAuthenticationSeed" ) ); return SendReceive( DRMEngine::EGetAuthenticationSeed, TIpcArgs( &aContentID, &aSeed ) ); - } + } // ----------------------------------------------------------------------------- // RDRMRightsClient::FileToListL @@ -1315,52 +1315,52 @@ { DRMLOG( _L( "RDRMRightsClient::FileToListL" ) ); TInt error = KErrNone; - + // Temporary storage. CDRMPermission* tmpObject; - + // To access the file data. RFileReadStream fileStream; - + // How many objects there is in the file. TInt size = 0; - + // Temporary counter. TInt count = 0; - - + + // Open the file. User::LeaveIfError( fileStream.Open( aFs, aFileName, EFileRead | EFileStream ) ); CleanupClosePushL( fileStream ); - + size = fileStream.ReadInt32L(); - + while( count < size ) { // Allocate a new RO. tmpObject = CDRMPermission::NewL(); - + // Read the object. TRAP( error, tmpObject->InternalizeL( fileStream ) ); - + if ( !error ) { // Add the object into the list. error = aList.Append( tmpObject ); } - + if ( error ) { delete tmpObject; User::Leave( error ); } - - // Now tmpObject is under responsibility of aList. + + // Now tmpObject is under responsibility of aList. ++count; } - + // All done. - CleanupStack::PopAndDestroy(); // fileStream + CleanupStack::PopAndDestroy(); // fileStream } // ----------------------------------------------------------------------------- @@ -1376,10 +1376,10 @@ RFileReadStream stream; TUint16 size = 0; TPtr8 data( NULL, 0, 0 ); - + User::LeaveIfError( stream.Open( aFs, aFile, EFileRead | EFileStream ) ); CleanupClosePushL( stream ); - + size = stream.ReadUint16L(); while( size > 0 ) { @@ -1390,22 +1390,22 @@ CleanupStack::Pop(); // tmp size = stream.ReadUint16L(); } - + // All read, return. - + CleanupStack::PopAndDestroy(); // stream } // ----------------------------------------------------------------------------- // RDRMRightsClient::VerifyMacL -// Verifies the MAC. +// Verifies the MAC. // ----------------------------------------------------------------------------- -// +// EXPORT_C TInt RDRMRightsClient::VerifyMacL(const TDesC8& aSignedInfoElement, const TDesC8& aMacValue ) const { DRMLOG( _L( "RDRMRightsClient::VerifyMacL" ) ); - + TInt error = SendReceive( DRMEngine::EVerifyMac, TIpcArgs( &aSignedInfoElement, &aMacValue) ); return error; @@ -1416,19 +1416,19 @@ // RDRMRightsClient::GetSupportedIndividualsL // retrieves the supported individuals list // ----------------------------------------------------------------------------- -// +// EXPORT_C TInt RDRMRightsClient::GetSupportedIndividualsL( RPointerArray& aIndividuals) const { DRMLOG( _L( "RDRMRightsClient::GetSupportedIndividualsL" ) ); - TPckgBuf< TInt > size( 0 ); + TPckgBuf< TInt > size( 0 ); TInt error = SendReceive( DRMEngine::EGetSupportedIndividuals, TIpcArgs( &size) ); HBufC8* dataBuf = NULL; HBufC8* individual = NULL; TInt indivSize; TInt offset; - + if ( !error ) { if ( !size() ) @@ -1441,17 +1441,17 @@ if ( dataBuf ) { TPtr8 data( dataBuf->Des() ); - + error = SendReceive( DRMEngine::EGetPreparedData, TIpcArgs( &data ) ); - + if ( !error ) - { + { offset = 0; while (offset < size()) { Mem::Copy( &indivSize, data.Ptr()+offset, sizeof(TInt) ); - offset += sizeof (TInt); + offset += sizeof (TInt); individual = data.Mid(offset, indivSize).AllocLC(); aIndividuals.AppendL(individual); CleanupStack::Pop(); // individual @@ -1459,16 +1459,16 @@ } } } - CleanupStack::PopAndDestroy(); + CleanupStack::PopAndDestroy(); } - } + } return KErrNone; } - + // ----------------------------------------------------------------------------- // RDRMRightsClient::StopWatching // ----------------------------------------------------------------------------- -// +// EXPORT_C void RDRMRightsClient::StopWatching() const { SendReceive( DRMEngine::EStopWatching ); @@ -1477,7 +1477,7 @@ // ----------------------------------------------------------------------------- // RDRMRightsClient::UnwrapMacAndRek // ----------------------------------------------------------------------------- -// +// EXPORT_C TInt RDRMRightsClient::UnwrapMacAndRek( const TDesC8& aMacAndRek, TKeyTransportScheme aTransportScheme, const TDesC8& aRightsIssuerId, @@ -1486,16 +1486,16 @@ HBufC8* data = NULL; TPtr8 dataPtr( NULL, 0 ); TInt err = KErrNone; - + data = HBufC8::New( 1 + aMacAndRek.Size() ); - + if ( data ) { dataPtr.Set( data->Des() ); - dataPtr.SetLength( 1 ); + dataPtr.SetLength( 1 ); dataPtr[0] = aTransportScheme; dataPtr.Append( aMacAndRek ); - + if( aDomainId.Length() ) { err = SendReceive( DRMEngine::EUnwrapDomainMacAndRek, TIpcArgs( &dataPtr, @@ -1511,18 +1511,18 @@ delete data; data = NULL; } - else + else { err = KErrNoMemory; } - + return err; } - + // ----------------------------------------------------------------------------- // RDRMRightsClient::GetRandomDataL // ----------------------------------------------------------------------------- -// +// EXPORT_C void RDRMRightsClient::GetRandomDataL( TDes8& aRandomData ) const { if( !aRandomData.Length() ) @@ -1535,7 +1535,7 @@ // ----------------------------------------------------------------------------- // RDRMRightsClient::GetMeteringData() // ----------------------------------------------------------------------------- -// +// #ifndef RD_DRM_METERING EXPORT_C HBufC8* RDRMRightsClient::GetMeteringDataL( const TDesC8& /*aRiId*/ ) { @@ -1546,24 +1546,24 @@ { TInt error = KErrNone; HBufC8* meteringData = NULL; - + if ( aRiId.Length() ) { TInt size = 0; TPckg package( size ); - - error = SendReceive( DRMEngine::EGetMeteringData, + + error = SendReceive( DRMEngine::EGetMeteringData, TIpcArgs( &package, &aRiId ) ); - + if ( error == KErrNotFound ) { return NULL; } - + User::LeaveIfError( error ); meteringData = HBufC8::NewMaxLC( size ); - + // Package 'object' into TPtr8. TPtr8 objectPkg( const_cast< TUint8* >( meteringData->Ptr() ), size, @@ -1571,26 +1571,26 @@ User::LeaveIfError( SendReceive( DRMEngine::EGetPreparedData, TIpcArgs( &objectPkg) ) ); - + CleanupStack::Pop(); // meteringData return meteringData; } - + User::Leave( KErrArgument ); return NULL; } #endif //RD_DRM_METERING - + // ----------------------------------------------------------------------------- // RDRMRightsClient::DeleteMeteringDataL // ----------------------------------------------------------------------------- -// +// #ifndef RD_DRM_METERING EXPORT_C TInt RDRMRightsClient::DeleteMeteringDataL( const TDesC8& /*aRiId*/ ) { return KErrNotSupported; } -#else +#else EXPORT_C TInt RDRMRightsClient::DeleteMeteringDataL( const TDesC8& aRiId ) { if ( aRiId.Length() ) @@ -1604,9 +1604,9 @@ return KErrArgument; } } -#endif +#endif // ========================== OTHER EXPORTED FUNCTIONS ========================= - - -// End of File + + +// End of File