FCL/sf/mw/drm: comparison wmdrm/wmdrmengine/wmdrmserver/server/src/wmdrmsession.cpp

equal deleted inserted replaced

-:b09186059647
+:c938d010410d
 /*
-* Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2007-2010 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".
 // CWmDrmSession::CWmDrmSession
 // Constructor
 //---------------------------------------------------------------------------
 //
 CWmDrmSession::CWmDrmSession()
-	{
+{
-	}
+}
 //---------------------------------------------------------------------------
 // CWmDrmSession::~CWmDrmSession
 // Destructor
 //---------------------------------------------------------------------------
 //
 CWmDrmSession::~CWmDrmSession()
-	{
+{
-	LOGFN( "CWmDrmSession::~CWmDrmSession" );
+LOGFN( "CWmDrmSession::~CWmDrmSession" );
 //Server().Cache()->FlushL();
-	delete iEnumerator;
+delete iEnumerator;
-	iEnumerator = NULL;
+iEnumerator = NULL;
 delete iSlot;
-	iSlot = NULL;
+iSlot = NULL;
-	}
+}
 //---------------------------------------------------------------------------
 // CWmDrmSession::InitStoreL
 //---------------------------------------------------------------------------
 //
 TInt CWmDrmSession::InitStoreL( const RMessage2& aMessage )
 {
 TInt r = KErrNone;
 TBuf8<KMaxWmDrmStoreNameSize> store;
 LOGFNR( "CWmDrmSession::InitStoreL", r );
 if ( aMessage.GetDesLength( 0 ) > KMaxWmDrmStoreNameSize || aMessage.GetDesLength( 0 ) <= 0 )
 {
 User::Leave( KErrArgument );
 }
 }
 //---------------------------------------------------------------------------
 // CWmDrmSession::RemoveStoreL
 //---------------------------------------------------------------------------
 //
 TInt CWmDrmSession::RemoveStoreL( const RMessage2& aMessage )
 {
 TInt r = KErrNone;
 TBuf8<KMaxWmDrmStoreNameSize> store;
 LOGFNR( "CWmDrmSession::RemoveStoreL", r );
 if ( aMessage.GetDesLength( 0 ) > KMaxWmDrmStoreNameSize || aMessage.GetDesLength( 0 ) <= 0  )
 {
 User::Leave( KErrArgument );
 }
 }
 //---------------------------------------------------------------------------
 // CWmDrmSession::InitNamespaceL
 //---------------------------------------------------------------------------
 //
 TInt CWmDrmSession::InitNamespaceL( const RMessage2& aMessage )
 {
 TInt r = KErrNone;
 TBuf8<KMaxWmDrmStoreNameSize> store;
 TBuf8<KMaxWmDrmNamespaceNameSize> nameSpace;
 LOGFNR( "CWmDrmSession::InitNamespaceL", r );
 // :KLUDGE: Note: store length of zero is allowed
 if ( aMessage.GetDesLengthL( 0 ) > KMaxWmDrmStoreNameSize ||
 aMessage.GetDesLengthL( 1 ) > KMaxWmDrmNamespaceNameSize ||
 aMessage.GetDesLength( 1 ) <= 0 )
 }
 //---------------------------------------------------------------------------
 // CWmDrmSession::RemoveNamespaceL
 //---------------------------------------------------------------------------
 //
 TInt CWmDrmSession::RemoveNamespaceL( const RMessage2& aMessage )
 {
 TInt r = KErrNone;
 TBuf8<KMaxWmDrmStoreNameSize> store;
 TBuf8<KMaxWmDrmNamespaceNameSize> nameSpace;
 LOGFNR( "CWmDrmSession::RemoveNamespaceL", r );
 // :KLUDGE: Note: store length of zero is allowed
 if ( aMessage.GetDesLengthL( 0 ) > KMaxWmDrmStoreNameSize ||
 aMessage.GetDesLengthL( 1 ) > KMaxWmDrmNamespaceNameSize ||
 aMessage.GetDesLength( 1 ) <= 0 )
 }
 //---------------------------------------------------------------------------
 // CWmDrmSession::SlotOpenL
 //---------------------------------------------------------------------------
 //
 TInt CWmDrmSession::SlotOpenL( const RMessage2& aMessage )
 {
 TInt r = KErrNone;
 RBuf8 messageBuffer;
-	TInt size;
+TInt size;
 LOGFNR( "CWmDrmSession::SlotOpenL", r );
 if ( aMessage.GetDesLength( 0 ) > KMaxSlotNameSize || aMessage.GetDesLength( 0 ) <= 0 )
 {
 User::Leave( KErrArgument );
 }
 }
 //---------------------------------------------------------------------------
 // CWmDrmSession::SlotCreateL
 //---------------------------------------------------------------------------
 //
 TInt CWmDrmSession::SlotCreateL( const RMessage2& aMessage )
 {
 TInt r = KErrNone;
 RBuf8 messageBuffer;
-	TInt size;
+TInt size;
 LOGFNR( "CWmDrmSession::SlotCreateL", r );
 if ( aMessage.GetDesLength( 0 ) > KMaxSlotNameSize || aMessage.GetDesLength( 0 ) <= 0  )
 {
 User::Leave( KErrArgument );
 }
 if ( iSlot != NULL )
 {
 delete iSlot;
 iSlot = NULL;
 }
 iSlot = CSlot::NewL( &Server(), messageBuffer );
 iSlot->CreateL( size );
 CleanupStack::PopAndDestroy( &messageBuffer );
 return r;
 }
 //---------------------------------------------------------------------------
 // CWmDrmSession::SlotSeekL
 //---------------------------------------------------------------------------
 //
 TInt CWmDrmSession::SlotSeekL( const RMessage2& aMessage )
 {
 TInt r = KErrNone;
 TSeek whence = ESeekStart;
 TInt pos = aMessage.Int0();
 TInt size;
 LOGFNR( "CWmDrmSession::SlotSeekL", r );
 if ( iSlot == NULL )
 {
 User::Leave( KErrNotReady );
 }
 }
 //---------------------------------------------------------------------------
 // CWmDrmSession::SlotReadL
 //---------------------------------------------------------------------------
 //
 TInt CWmDrmSession::SlotReadL( const RMessage2& aMessage )
 {
 TInt r = KErrNone;
 RBuf8 buf;
 TInt amountRead = 0;
 LOGFNR( "CWmDrmSession::SlotReadL", r );
 if ( iSlot == NULL )
 {
 User::Leave( KErrNotReady );
 }
 }
 //---------------------------------------------------------------------------
 // CWmDrmSession::SlotWriteL
 //---------------------------------------------------------------------------
 //
 TInt CWmDrmSession::SlotWriteL( const RMessage2& aMessage )
 {
 TInt r = KErrNone;
 RBuf8 buf;
 LOGFNR( "CWmDrmSession::SlotWriteL", r );
 if ( iSlot == NULL )
 {
 User::Leave( KErrNotReady );
 }
 aMessage.ReadL( 0, buf );
 r = iSlot->WriteL( buf );
 CleanupStack::PopAndDestroy( &buf );
 return r;
 }
 TInt CWmDrmSession::SlotResizeL( const RMessage2& aMessage )
 {
 TInt r = KErrNone;
 LOGFNR( "CWmDrmSession::SlotResizeL", r );
 if ( iSlot == NULL )
 {
 User::Leave( KErrNotReady );
 }
 }
 //---------------------------------------------------------------------------
 // CWmDrmSession::SlotDeleteL
 //---------------------------------------------------------------------------
 //
 TInt CWmDrmSession::SlotDeleteL( const RMessage2& aMessage )
 {
 TInt r = KErrNone;
 RBuf8 messageBuffer;
 LOGFNR( "CWmDrmSession::SlotDeleteL", r );
 if ( aMessage.GetDesLength( 0 ) > KMaxSlotNameSize )
 {
 User::Leave( KErrArgument );
 }
 }
 //---------------------------------------------------------------------------
 // CWmDrmSession::SlotCloseL
 //---------------------------------------------------------------------------
 //
 TInt CWmDrmSession::SlotCloseL( const RMessage2& /*aMessage*/ )
 {
 TInt r = KErrNone;
 LOGFNR( "CWmDrmSession::SlotCloseL", r );
 if ( iSlot == NULL )
 {
 User::Leave( KErrNotReady );
 }
 }
 //---------------------------------------------------------------------------
 // CWmDrmSession::EnumerateStartL
 //---------------------------------------------------------------------------
 //
 TInt CWmDrmSession::EnumerateStartL( const RMessage2& aMessage )
 {
 TInt r = KErrNone;
 RBuf8 messageBuffer;
 LOGFNR( "CWmDrmSession::EnumerateStartL", r );
 if ( aMessage.GetDesLength( 0 ) > KMaxSlotNameSize || aMessage.GetDesLength( 0 ) <= 0  )
 {
 User::Leave( KErrArgument );
 }
 }
 //---------------------------------------------------------------------------
 // CWmDrmSession::EnumerateReloadL
 //---------------------------------------------------------------------------
 //
 TInt CWmDrmSession::EnumerateReloadL( const RMessage2& aMessage )
 {
 TInt r = KErrNone;
 TBuf8<KWmDrmIdSize> hash;
 TBuf8<KWmDrmIdSize> id;
 LOGFNR( "CWmDrmSession::EnumerateReloadL", r );
 if ( iEnumerator == NULL )
 {
 User::Leave( KErrNotReady );
 }
 }
 //---------------------------------------------------------------------------
 // CWmDrmSession::EnumerateNextL
 //---------------------------------------------------------------------------
 //
 TInt CWmDrmSession::EnumerateNextL( const RMessage2& aMessage )
 {
 TInt r = KErrNone;
 TBuf8<KWmDrmIdSize> hash;
 TBuf8<KWmDrmIdSize> id;
 LOGFNR( "CWmDrmSession::EnumerateNextL", r );
 if ( iEnumerator == NULL )
 {
 User::Leave( KErrNotReady );
 }
 }
 //---------------------------------------------------------------------------
 // CWmDrmSession::EnumerateDeleteL
 //---------------------------------------------------------------------------
 //
 TInt CWmDrmSession::EnumerateDeleteL ( const RMessage2& /*aMessage*/ )
 {
 TInt r = KErrNone;
 LOGFNR( "CWmDrmSession::EnumerateDeleteL", r );
 if ( iEnumerator == NULL )
 {
 User::Leave( KErrNotReady );
 }
 //---------------------------------------------------------------------------
 //
 TInt CWmDrmSession::EnumerateEndL ( const RMessage2& /*aMessage*/ )
 {
 TInt r = KErrNone;
 LOGFNR( "CWmDrmSession::EnumerateEndL", r );
 if ( iEnumerator == NULL )
 {
 User::Leave( KErrNotReady );
 }
 //---------------------------------------------------------------------------
 //
 TInt CWmDrmSession::EmptyCacheL( const RMessage2& aMessage )
 {
 TInt r = KErrNone;
 LOGFNR( "CWmDrmSession::EmptyCacheL", r );
 TRAP_IGNORE( EnumerateEndL( aMessage ) );
 TRAP_IGNORE( SlotCloseL( aMessage ) );
 Server().ResetCacheL();
 return r;
 }
 //---------------------------------------------------------------------------
 // CWmDrmSession::LogStats
 //---------------------------------------------------------------------------
 //
 TInt CWmDrmSession::LogStats( const RMessage2& /*aMessage*/ )
 {
 TInt r = KErrNone;
 #ifdef _LOGGING
 TInt cells;
 TInt amount;
 TInt i;
 TInt j;
 _LIT( KStatsDir, "wmdrm" );
 _LIT( KStatsFile, "wmdrmserver.txt" );
 LOGFNR( "CWmDrmSession::LogStatsL", r );
 cells = User::AllocSize( amount );
 RFileLogger::Write( KStatsDir, KStatsFile, EFileLoggingModeAppend, _L( "Statistics:" ) );
 RFileLogger::WriteFormat( KStatsDir, KStatsFile, EFileLoggingModeAppend,
 _L( "Memory: %d cells, %d bytes allocated" ), cells, amount );
 RFileLogger::Write( KStatsDir, KStatsFile, EFileLoggingModeAppend,
 *Server().EnumeratorCache()->iEnumeratorCache[i]->iEntries[j] );
 }
 }
 #endif
 return r;
 }
 //---------------------------------------------------------------------------
 // CWmDrmSession::TimeValid
 //---------------------------------------------------------------------------
 //
 TInt CWmDrmSession::TimeValid( const RMessage2& /*aMessage*/ )
 {
 TInt r = KErrNone;
 LOGFNR( "CWmDrmSession::TimeValid", r );
 r = Server().Clock()->TimeIsGood();
 return r;
 }
 //---------------------------------------------------------------------------
 // CWmDrmSession::SetTimeAsValidL
 //---------------------------------------------------------------------------
 //
 void CWmDrmSession::SetTimeAsValidL( const RMessage2& aMessage )
 {
 LOGFN( "CWmDrmSession::TimeValid" );
 Server().Clock()->SetTimeAsGoodL( aMessage.Int0() == 0 ? EFalse : ETrue );
 }
 //---------------------------------------------------------------------------
 // CWmDrmSession::DeleteRightsL
 //---------------------------------------------------------------------------
 //
 TInt CWmDrmSession::DeleteRightsL( const RMessage2& /*aMessage*/ )
 {
 TInt r = KErrNone;
 TBool wmDrmRightsConfigFound( EFalse );
 TChar driveLetter;
 TDrmScheme drmScheme( EDrmSchemeWmDrm );
 LOGFNR( "CWmDrmSession::DeleteRightsL", r );
 // Close EVERYTHING down, clear cache etc, so that we have nothing going on
 // When we start to delete stuff
 Server().ResetCacheL();
 wmDrmRightsConfigFound = DrmRightsStoringLocation::CheckDrmRightsStorageDriveL(
-	  		Server().Fs(), drmScheme, driveLetter );
+Server().Fs(), drmScheme, driveLetter );
 // If WM DRM rights storage configuration is found, update both databases
 if ( wmDrmRightsConfigFound )
 {
-	Server().DataStore()->UpdateDummyDbFileL(
+Server().DataStore()->UpdateDummyDbFileL(
-	    Server().DataStore()->DummyDBSizeL( ETrue ), ETrue );
+Server().DataStore()->DummyDBSizeL( ETrue ), ETrue );
-	}
+}
 Server().DataStore()->UpdateDummyDbFileL(
 Server().DataStore()->DummyDBSizeL( EFalse ), EFalse );
 // Delete license store
 Server().Db()->DeleteLicenseStoreL();
 // If WM DRM rights storage configuration is found, update both databases
 if ( wmDrmRightsConfigFound )
-	{
+{
-	Server().DataStore()->UpdateDummyDbFileL( 0, ETrue );
+Server().DataStore()->UpdateDummyDbFileL( 0, ETrue );
-	}
+}
 Server().DataStore()->UpdateDummyDbFileL( 0, EFalse );
 return r;
 }
 //---------------------------------------------------------------------------
 // CWmDrmSession::StoreStateL
 //---------------------------------------------------------------------------
 //
 void CWmDrmSession::StoreStateL( const RMessage2& aMessage )
 {
 TWmDrmStoreState state;
 LOGFN( "CWmDrmSession::StoreStateL" );
 state = Server().DataStore()->DataStoreStateL();
 aMessage.WriteL( 0, TPckg<TWmDrmStoreState>( state ) );
 }
 {
 TTime time = Time::NullTTime();
 TBool validity = EFalse;
 TPckg<TTime> timePckg(time);
 TPckg<TBool> validityPckg(validity);
 LOGFN( "CWmDrmSession::GetTimeL" );
 // Get the time from the clock
 Server().Clock()->GetTimeL( time, validity );
 aMessage.WriteL(0, timePckg);
 aMessage.WriteL(1, validityPckg);
 }
 //---------------------------------------------------------------------------
 // CWmDrmSession::CommitDataL
 //---------------------------------------------------------------------------
 //
-void CWmDrmSession::CommitDataL( const RMessage2& aMessage )
+void CWmDrmSession::CommitDataL( const RMessage2& /*aMessage*/ )
 {
 LOGFN( "CWmDrmSession::CommitDataL" );
 // Force a commit on the database
 Server().Db()->CheckDatabaseCommitL( ETrue );
 }
 //---------------------------------------------------------------------------
 // CWmDrmSession::ServiceL
 //---------------------------------------------------------------------------
 //
 void CWmDrmSession::ServiceL( const RMessage2& aMessage )
-	{
+{
-	TInt r = KErrNone;
+TInt r = KErrNone;
-	TInt trap = KErrNone;
+TInt trap = KErrNone;
-	_LIT_SECURITY_POLICY_C1(drmCheck, ECapabilityDRM);
+_LIT_SECURITY_POLICY_C1(drmCheck, ECapabilityDRM);
 RThread client;
-	LOGFNR( "CWmDrmSession::ServiceL", r );
+LOGFNR( "CWmDrmSession::ServiceL", r );
 #ifdef _LOGGING
 TInt c;
 TInt s;
 c = User::AllocSize(s);
 LOG3( "Memory: %d cells, %d bytes allocated", c, s );
 case EStoreState:
 TRAP( trap, StoreStateL( aMessage ) );
 break;
 case EGetTime:
 TRAP( trap, GetTimeL( aMessage ) );
 break;
 case ECommitData:
 TRAP( trap, CommitDataL( aMessage ) );
 break;
 default:
 r = KErrArgument;
 break;
 }
 if ( trap != KErrNone )
 }
 }
 client.Close();
 LOG2( "** ServiceL error: %d", r );
 aMessage.Complete( r );
-	}
+}
 //---------------------------------------------------------------------------
 // CWmDrmSession::ServiceError
 //---------------------------------------------------------------------------
 //
 void CWmDrmSession::ServiceError( const RMessage2& aMessage, TInt aError )
-	{
+{
-	LOGFN( "CWmDrmSession::ServiceError" );
+LOGFN( "CWmDrmSession::ServiceError" );
-	LOG2( "** Error: %d", aError );
+LOG2( "** Error: %d", aError );
-	CSession2::ServiceError( aMessage, aError );
+CSession2::ServiceError( aMessage, aError );
-	}
+}
 //---------------------------------------------------------------------------
 // CWmDrmSession::Server
 //---------------------------------------------------------------------------
 //
 CWmDrmServer& CWmDrmSession::Server()
-	{
+{
-	return *static_cast<CWmDrmServer*>( const_cast<CServer2*>( CSession2::Server() ) );
+return *static_cast<CWmDrmServer*>( const_cast<CServer2*>( CSession2::Server() ) );
-	}
+}

changeset 87	c938d010410d
parent 47	5ed7931150e9