diff -r 000000000000 -r b497e44ab2fc terminalsecurity/server/src/TerminalControlSession.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/terminalsecurity/server/src/TerminalControlSession.cpp Thu Dec 17 09:07:52 2009 +0200 @@ -0,0 +1,1470 @@ +/* +* Copyright (c) 2009 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: Implementation of terminalsecurity components +* +*/ +// TerminalControlSession.cpp +// +//#define __INCLUDE_CAPABILITY_NAMES__ + +#include +#include +#include + +#include + +#include +#include "TerminalControlSession.h" +#include "PlatformSecurityPolicies.h" +#include "TcTrustedSession.h" +//Device encryption utility +#include +#include +//Feature manager +#include +//For debugging purpose +#include "debug.h" + + +// ---------------------------------------------------------------------------------------- +// CTerminalControlSession::CTerminalControlSession +// ---------------------------------------------------------------------------------------- +CTerminalControlSession::CTerminalControlSession() +: iContainer(0), iTrustedSessions(0) + { + RDEBUG("CTerminalControlSession::CTerminalControlSession"); + + } + +// ---------------------------------------------------------------------------------------- +// CTerminalControlSession::Server +// ---------------------------------------------------------------------------------------- +CTerminalControlServer& CTerminalControlSession::Server() + { + RDEBUG("CTerminalControlSession::Server"); + + return *static_cast(const_cast(CSession2::Server())); + } + +// ---------------------------------------------------------------------------------------- +// CTerminalControlSession::CreateL +// 2nd phase construct for sessions - called by the CServer framework +// ---------------------------------------------------------------------------------------- +void CTerminalControlSession::CreateL() + { + RDEBUG("CTerminalControlSession::CreateL"); + + iTrustedSessions = CObjectIx::NewL(); + iContainer = Server().NewContainerL(); + Server().AddSession(); + } + +// ---------------------------------------------------------------------------------------- +// CTerminalControlSession::~CTerminalControlSession +// ---------------------------------------------------------------------------------------- +CTerminalControlSession::~CTerminalControlSession() + { + RDEBUG("CTerminalControlSession::~CTerminalControlSession"); + + delete iTrustedSessions; + Server().DropSession(); + } + +// ---------------------------------------------------------------------------------------- +// CTerminalControlSession::ServiceL +// ---------------------------------------------------------------------------------------- +void CTerminalControlSession::ServiceL(const RMessage2& aMessage) + { + RDEBUG("CTerminalControlSession::ServiceL"); + + TRAPD(err,DispatchMessageL(aMessage)); + aMessage.Complete(err); + } + +// ---------------------------------------------------------------------------------------- +// CTerminalControlSession::DispatchMessageL +// ---------------------------------------------------------------------------------------- +void CTerminalControlSession::DispatchMessageL(const RMessage2& aMessage) + { + RDEBUG_2("CTerminalControlServer::DispatchMessageL; %d", aMessage.Function() ); + + HBufC8* results = 0; + HBufC8* paramCopy = 0; + HBufC8* paramCopy2 = 0; + TBuf8 sizeBuf; + TInt value; + + // + // Create new sub session + // + switch(aMessage.Function()) + { + case ECreateSubSession: + NewTrustedSessionL( aMessage ); + return; + }; + + // + // Get access level from the sub session information + // Note: this is where connections without a valid subsession are terminated + // + CTcTrustedSession* session = TrustedSessionFromHandle( aMessage ); + if(session == NULL) + { + // NOTE: This leave happens after client is paniced + RDEBUG("CTerminalControlSession::DispatchMessageL() - SESSION NOT TRUSTED - ABORT!"); + User::Leave( KErrAccessDenied ); + } + + TInt accessLevel = session->AccessLevel(); + TBool hasAllFilesCap = aMessage.HasCapability(ECapabilityAllFiles); + TBool hasDiskAdminCap = aMessage.HasCapability(ECapabilityDiskAdmin); + + // + // Disconnecting + // + switch(aMessage.Function()) + { + case ECloseSubSession: + if(session->iWipeRequested) + { + DeleteTrustedSession( aMessage ); + Server().WipeDeviceL(); + } + else if(session->iRebootRequested) + { + DeleteTrustedSession( aMessage ); + Server().RebootDeviceL(); + } + else + { + DeleteTrustedSession( aMessage ); + } + return; + }; + + if((accessLevel == CTcTrustedSession::EAccessLevelNone) && (!hasAllFilesCap)) + { + RDEBUG("CTerminalControlSession::DispatchMessageL() - SESSION HAS NO ACCESS LEVEL - ABORT!"); + User::Leave( KErrAccessDenied ); + } + // + // Message handlers for third party messages + // + if((((accessLevel & CTcTrustedSession::EAccessLevelApplication) != 0 )&& (hasDiskAdminCap))||(hasAllFilesCap)) + { + switch(aMessage.Function()) + { + case E3rdPartySetterGet: + GetDeviceLockParameterL( aMessage ); + break; + + case E3rdPartySetterGetSize: + GetDeviceLockParameterSizeL( aMessage ); + break; + + case E3rdPartySetterSet: + SetDeviceLockParameterL( aMessage ); + break; + } + } + + // + // Message handlers for DM adapter + // + if((accessLevel & CTcTrustedSession::EAccessLevelDMAdapter) != 0) + { + switch(aMessage.Function()) + { + //------------------------------------------------------------------------- + case EFileScan: + // Read startup folder + paramCopy = CopyParameterL( aMessage, 1 ); + CleanupStack::PushL( paramCopy ); + session->FileScanL( *paramCopy, (aMessage.Int0() == 1) ); + CleanupStack::PopAndDestroy( paramCopy ); + break; + + //------------------------------------------------------------------------- + case EFileScanResults: + results = session->FileScanResultsL(); + + if( results != NULL) + { + CleanupStack::PushL( results ); + + TInt size1 = aMessage.GetDesMaxLength(0); + TInt size2 = results->Size(); + + if(size1 >= size2) + { + aMessage.WriteL(0, *results); + } + else + { + User::Leave( KErrArgument ); + } + + CleanupStack::PopAndDestroy( results ); + } + else + { + User::Leave(KErrGeneral); + } + break; + + //------------------------------------------------------------------------- + case EFileScanResultsSize: + results = session->FileScanResultsL(); + + if( results != NULL ) + { + sizeBuf.Num( results->Size() ); + delete results; + } + else + { + sizeBuf.Num(0); + } + + if(aMessage.GetDesMaxLength(0) >= sizeBuf.Length()) + { + aMessage.WriteL(0, sizeBuf); + } + else + { + User::Leave( KErrArgument ); + } + break; + + //------------------------------------------------------------------------- + case EFileDelete: + paramCopy = CopyParameterL( aMessage, 0 ); + CleanupStack::PushL( paramCopy ); + Server().DeleteFileL( *paramCopy ); + CleanupStack::PopAndDestroy( paramCopy ); + break; + + //------------------------------------------------------------------------- + case EDeviceLock_AutoLockPeriod_Set: + value = aMessage.Int0(); + Server().SetLockTimeoutL( value ); + break; + + //------------------------------------------------------------------------- + case EDeviceLock_AutoLockPeriod_Get: + sizeBuf.Num( Server().GetLockTimeoutL() ); + if(aMessage.GetDesMaxLength(0) >= sizeBuf.Length()) + { + aMessage.WriteL(0, sizeBuf); + } + else + { + User::Leave( KErrArgument ); + } + break; + + //------------------------------------------------------------------------- + case EDeviceLock_MaxAutoLockPeriod_Set: + value = aMessage.Int0(); + Server().SetLockMaxTimeoutL( value ); + break; + + //------------------------------------------------------------------------- + case EDeviceLock_MaxAutoLockPeriod_Get: + sizeBuf.Num( Server().GetLockMaxTimeoutL() ); + if(aMessage.GetDesMaxLength(0) >= sizeBuf.Length()) + { + aMessage.WriteL(0, sizeBuf); + } + else + { + User::Leave( KErrArgument ); + } + break; + + //------------------------------------------------------------------------- + case EDeviceLock_LockLevel_Set: + value = aMessage.Int0(); + Server().SetLockLevelL( value ); + break; + + //------------------------------------------------------------------------- + case EDeviceLock_LockLevel_Get: + { + sizeBuf.Num( Server().GetLockLevelL() ); + if(aMessage.GetDesMaxLength(0) >= sizeBuf.Length()) + { + aMessage.WriteL(0, sizeBuf); + } + else + { + User::Leave( KErrArgument ); + } + } + break; + + //------------------------------------------------------------------------- + case EDeviceLock_LockCode_Set: + paramCopy = CopyParameterL( aMessage, 0 ); + CleanupStack::PushL( paramCopy ); + Server().SetLockCodeL( *paramCopy ); + CleanupStack::PopAndDestroy( paramCopy ); + break; + + //------------------------------------------------------------------------- + case EDeviceLock_LockCode_Get: + { + RDEBUG("CTerminalControlSession::DispatchMessageL() - GetLockCode not supported - ABORT!"); + User::Leave( KErrNotSupported ); + } + break; + + //------------------------------------------------------------------------- + case EDeviceWipe: + // Schedule wipe to when client has been disconnected + session->iWipeRequested = ETrue; + break; + + + +// ----- enhanced features BEGIN ---------------- +//#ifdef __SAP_DEVICE_LOCK_ENHANCEMENTS + + case EDeviceLock_PasscodeMinLength_Set: + { + value = aMessage.Int0(); + Server().SetPasscodeMinLengthL( value ); + } + break; + + case EDeviceLock_PasscodeMinLength_Get: + { + sizeBuf.Num( Server().GetPasscodeMinLengthL() ); + if( aMessage.GetDesMaxLength( 0 ) >= sizeBuf.Length() ) + { + aMessage.WriteL( 0, sizeBuf ); + } + else + { + RDEBUG("Invalid descriptor buffer length!"); + User::Leave( KErrArgument ); + } + } + break; + + case EDeviceLock_PasscodeMaxLength_Set: + { + value = aMessage.Int0(); + Server().SetPasscodeMaxLengthL( value ); + } + break; + + case EDeviceLock_PasscodeMaxLength_Get: + { + sizeBuf.Num( Server().GetPasscodeMaxLengthL() ); + if( aMessage.GetDesMaxLength( 0 ) >= sizeBuf.Length() ) + { + aMessage.WriteL( 0, sizeBuf ); + } + else + { + RDEBUG("Invalid descriptor buffer length!"); + User::Leave( KErrArgument ); + } + } + break; + + case EDeviceLock_PasscodeRequireUpperAndLower_Set: + { + value = aMessage.Int0(); + Server().SetPasscodeRequireUpperAndLowerL( value ); + } + break; + + case EDeviceLock_PasscodeRequireUpperAndLower_Get: + { + sizeBuf.Num( Server().GetPasscodeRequireUpperAndLowerL() ); + if( aMessage.GetDesMaxLength( 0 ) >= sizeBuf.Length() ) + { + aMessage.WriteL( 0, sizeBuf ); + } + else + { + RDEBUG("Invalid descriptor buffer length!"); + User::Leave( KErrArgument ); + } + } + break; + + case EDeviceLock_PasscodeRequireCharsAndNumbers_Set: + { + value = aMessage.Int0(); + Server().SetPasscodeRequireCharsAndNumbersL( value ); + } + break; + + case EDeviceLock_PasscodeRequireCharsAndNumbers_Get: + { + sizeBuf.Num( Server().GetPasscodeRequireCharsAndNumbersL() ); + if( aMessage.GetDesMaxLength( 0 ) >= sizeBuf.Length() ) + { + aMessage.WriteL( 0, sizeBuf ); + } + else + { + RDEBUG("Invalid descriptor buffer length!"); + User::Leave( KErrArgument ); + } + } + break; + + case EDeviceLock_PasscodeMaxRepeatedCharacters_Set: + { + value = aMessage.Int0(); + Server().SetPasscodeMaxRepeatedCharactersL( value ); + } + break; + + case EDeviceLock_PasscodeMaxRepeatedCharacters_Get: + { + sizeBuf.Num( Server().GetPasscodeMaxRepeatedCharactersL() ); + if( aMessage.GetDesMaxLength( 0 ) >= sizeBuf.Length() ) + { + aMessage.WriteL( 0, sizeBuf ); + } + else + { + RDEBUG("Invalid descriptor buffer length!"); + User::Leave( KErrArgument ); + } + } + break; + + case EDeviceLock_PasscodeHistoryBuffer_Set: + { + value = aMessage.Int0(); + Server().SetPasscodeHistoryBufferL( value ); + } + break; + + case EDeviceLock_PasscodeHistoryBuffer_Get: + { + sizeBuf.Num( Server().GetPasscodeHistoryBufferL() ); + if( aMessage.GetDesMaxLength( 0 ) >= sizeBuf.Length() ) + { + aMessage.WriteL( 0, sizeBuf ); + } + else + { + RDEBUG("Invalid descriptor buffer length!"); + User::Leave( KErrArgument ); + } + } + break; + + case EDeviceLock_PasscodeExpiration_Set: + { + value = aMessage.Int0(); + Server().SetPasscodeExpirationL( value ); + } + break; + + case EDeviceLock_PasscodeExpiration_Get: + { + sizeBuf.Num( Server().GetPasscodeExpirationL() ); + if( aMessage.GetDesMaxLength( 0 ) >= sizeBuf.Length() ) + { + aMessage.WriteL( 0, sizeBuf ); + } + else + { + RDEBUG("Invalid descriptor buffer length!"); + User::Leave( KErrArgument ); + } + } + break; + + case EDeviceLock_PasscodeMinChangeTolerance_Set: + { + value = aMessage.Int0(); + Server().SetPasscodeMinChangeToleranceL( value ); + } + break; + + case EDeviceLock_PasscodeMinChangeTolerance_Get: + { + sizeBuf.Num( Server().GetPasscodeMinChangeToleranceL() ); + if( aMessage.GetDesMaxLength( 0 ) >= sizeBuf.Length() ) + { + aMessage.WriteL( 0, sizeBuf ); + } + else + { + RDEBUG("Invalid descriptor buffer length!"); + User::Leave( KErrArgument ); + } + } + break; + + case EDeviceLock_PasscodeMinChangeInterval_Set: + { + value = aMessage.Int0(); + Server().SetPasscodeMinChangeIntervalL( value ); + } + break; + + case EDeviceLock_PasscodeMinChangeInterval_Get: + { + sizeBuf.Num( Server().GetPasscodeMinChangeIntervalL() ); + if( aMessage.GetDesMaxLength( 0 ) >= sizeBuf.Length() ) + { + aMessage.WriteL( 0, sizeBuf ); + } + else + { + RDEBUG("Invalid descriptor buffer length!"); + User::Leave( KErrArgument ); + } + } + break; + + case EDeviceLock_PasscodeCheckSpecificStrings_Set: + { + value = aMessage.Int0(); + Server().SetPasscodeCheckSpecificStringsL( value ); + } + break; + + case EDeviceLock_PasscodeCheckSpecificStrings_Get: + { + sizeBuf.Num( Server().GetPasscodeCheckSpecificStringsL() ); + if( aMessage.GetDesMaxLength( 0 ) >= sizeBuf.Length() ) + { + aMessage.WriteL( 0, sizeBuf ); + } + else + { + RDEBUG("Invalid descriptor buffer length!"); + User::Leave( KErrArgument ); + } + } + break; + + case EDeviceLock_PasscodeDisallowSpecific: + { + paramCopy = CopyParameterL( aMessage, 0 ); + CleanupStack::PushL( paramCopy ); + Server().DisallowSpecificPasscodesL( *paramCopy ); + CleanupStack::PopAndDestroy( paramCopy ); + paramCopy = NULL; + } + break; + + case EDeviceLock_PasscodeAllowSpecific: + { + paramCopy = CopyParameterL( aMessage, 0 ); + CleanupStack::PushL( paramCopy ); + Server().AllowSpecificPasscodesL( *paramCopy ); + CleanupStack::PopAndDestroy( paramCopy ); + paramCopy = NULL; + } + break; + + case EDeviceLock_PasscodeClearSpecificStrings: + { + Server().ClearSpecificPasscodeStringsL(); + } + break; + + case EDeviceLock_PasscodeMaxAttempts_Set: + { + value = aMessage.Int0(); + Server().SetPasscodeMaxAttemptsL( value ); + } + break; + + case EDeviceLock_PasscodeMaxAttempts_Get: + { + sizeBuf.Num( Server().GetPasscodeMaxAttemptsL() ); + if( aMessage.GetDesMaxLength( 0 ) >= sizeBuf.Length() ) + { + aMessage.WriteL( 0, sizeBuf ); + } + else + { + RDEBUG("Invalid descriptor buffer length!"); + User::Leave( KErrArgument ); + } + } + break; + + case EDeviceLock_PasscodeConsecutiveNumbers_Set: + { + value = aMessage.Int0(); + Server().SetConsecutiveNumbersL( value ); + } + break; + + case EDeviceLock_PasscodeConsecutiveNumbers_Get: + { + sizeBuf.Num( Server().GetConsecutiveNumbersL() ); + if( aMessage.GetDesMaxLength( 0 ) >= sizeBuf.Length() ) + { + aMessage.WriteL( 0, sizeBuf ); + } + else + { + RDEBUG("Invalid descriptor buffer length!"); + User::Leave( KErrArgument ); + } + } + break; + + case EDeviceLock_PasscodeMinSpecialCharacters_Set: + { + value = aMessage.Int0(); + Server().SetPasscodeMinSpecialCharactersL( value ); + } + break; + + case EDeviceLock_PasscodeMinSpecialCharacters_Get: + { + sizeBuf.Num( Server().GetPasscodeMinSpecialCharactersL() ); + if( aMessage.GetDesMaxLength( 0 ) >= sizeBuf.Length() ) + { + aMessage.WriteL( 0, sizeBuf ); + } + else + { + RDEBUG("Invalid descriptor buffer length!"); + User::Leave( KErrArgument ); + } + } + break; + + case EDeviceLock_PasscodeDisallowSimple_Set: + { + value = aMessage.Int0(); + Server().SetDisallowSimpleL( value ); + } + break; + case EDeviceLock_PasscodeDisallowSimple_Get: + { + sizeBuf.Num( Server().GetDisallowSimpleL() ); + if( aMessage.GetDesMaxLength( 0 ) >= sizeBuf.Length() ) + { + aMessage.WriteL( 0, sizeBuf ); + } + else + { + RDEBUG("Invalid descriptor buffer length!"); + User::Leave( KErrArgument ); + } + } + break; + +// ----- enhanced features END ---------------- +//#endif + + + + + //------------------------------------------------------------------------- + case EProcesses: + { + /*if( session->iProcessList == NULL ) + { + // Note: This should not happen since process list size may vary + // Process list is updated when size is queried + delete session->iProcessList; session->iProcessList = 0; + session->iProcessList = Server().GetRunningProcessesL(); + }*/ + + if( session->iProcessList != NULL ) + { + TInt size1 = aMessage.GetDesMaxLength(0); + TInt size2 = session->iProcessList->Size(); + if(size1 >= size2) + { + aMessage.WriteL(0, session->iProcessList->Ptr(0)); + } + else + { + + User::Leave(KErrGeneral); + } + } + else + { + RDEBUG("Process list is NULL"); + User::Leave(KErrGeneral); + } + } + break; + + //------------------------------------------------------------------------- + case EProcessesSize: + { + // NOTE: Processes are listed only in this function + // Process list size may change in each listing + delete session->iProcessList; session->iProcessList = 0; + session->iProcessList = Server().GetRunningProcessesL(); + + // Get size in buffer + if( session->iProcessList != NULL ) + { + sizeBuf.Num( session->iProcessList->Size() ); + } + else + { + sizeBuf.Num(0); + } + + // Return size + if(aMessage.GetDesMaxLength(0) >= sizeBuf.Length()) + { + aMessage.WriteL(0, sizeBuf); + } + else + { + RDEBUG("Invalid descriptor buffer length!"); + User::Leave( KErrArgument ); + } + } + break; + + //------------------------------------------------------------------------- + case EProcessData: + paramCopy = CopyParameterL( aMessage, 0 ); + CleanupStack::PushL( paramCopy ); + paramCopy2 = CopyParameterL( aMessage, 1 ); + CleanupStack::PushL( paramCopy2 ); + + if( session->iProcessList == NULL ) + { + // Note: Process list may have changed since last listing... + // If there is a previous list, we don't want to update it. + delete session->iProcessList; session->iProcessList = 0; + session->iProcessList = Server().GetRunningProcessesL(); + } + + delete session->iProcessData; session->iProcessData = 0; + session->iProcessData = Server().GetProcessDataL(*paramCopy, *paramCopy2); + + if( session->iProcessData != NULL ) + { + TInt size1 = aMessage.GetDesMaxLength(2); + TInt size2 = session->iProcessData->Size(); + if(size1 >= size2) + { + aMessage.WriteL(2, session->iProcessData->Ptr(0)); + } + else + { + RDEBUG("Invalid descriptor buffer length!"); + User::Leave( KErrArgument ); + } + } + else + { + RDEBUG("process data is NULL"); + User::Leave(KErrGeneral); + } + + CleanupStack::PopAndDestroy( paramCopy2 ); + CleanupStack::PopAndDestroy( paramCopy ); + break; + + //------------------------------------------------------------------------- + case EReboot: + // Schedule reboot to when client has been disconnected + value = aMessage.Int0(); + if( value == 0 ) + { + session->iRebootRequested = EFalse; + } + else + { + session->iRebootRequested = ETrue; + } + break; + + //------------------------------------------------------------------------- + case ELocalOperation_Start: + paramCopy = CopyParameterL( aMessage, 0 ); + value = aMessage.Int1(); + CleanupStack::PushL( paramCopy ); + if(value == 1) + { + Server().StartProcessByUidL( *paramCopy ); + } + else + { + Server().StartProcessByFullNameL( *paramCopy ); + } + CleanupStack::PopAndDestroy( paramCopy ); + break; + + //------------------------------------------------------------------------- + case ELocalOperation_Stop: + paramCopy = CopyParameterL( aMessage, 0 ); + value = aMessage.Int1(); + CleanupStack::PushL( paramCopy ); + if(value == 1) + { + Server().StopProcessByUidL( *paramCopy ); + } + else + { + Server().StopProcessByFullNameL( *paramCopy ); + } + CleanupStack::PopAndDestroy( paramCopy ); + break; + + default: + { + RDEBUG("CTerminalControlSession::DispatchMessageL() - DM Adapter - ERROR - KErrNotSupported"); + User::Leave( KErrNotSupported ); + } + break; + + } + } + } + +// ---------------------------------------------------------------------------------------- +// CTerminalControlSession::NewTrustedSessionL +// Create a new counter; pass back its handle via the message +// ---------------------------------------------------------------------------------------- +void CTerminalControlSession::NewTrustedSessionL( const RMessage2& aMessage) + { + RDEBUG("CTerminalControlSession::NewTrustedSessionL"); + + TInt param0Size = aMessage.GetDesLength(0); + TInt certSize = sizeof(TCertInfo); + TBool hasCert = ( param0Size == certSize ); + + TCertInfo cert; + TPckg certp( cert ); + certp.FillZ(); + + if( hasCert ) + { + RDEBUG("CTerminalControlSession::NewTrustedSessionL Session has a certificate"); + aMessage.Read(0, certp); + } + else + { + RDEBUG("CTerminalControlSession::NewTrustedSessionL Warning: Session does not have a certificate"); + } + + // + // Add new CTcTrustedSession object into container and object index + // + TSecureId secureID = aMessage.SecureId(); + + CTcTrustedSession* trustedSession = 0; + + if( hasCert ) + { + trustedSession = CTcTrustedSession::NewL( secureID, cert ); + } + else + { + trustedSession = CTcTrustedSession::NewL( secureID ); + } + + if(trustedSession == 0) + { + PanicClient( aMessage, EBadDescriptor); + } + else + { + iContainer->AddL( trustedSession ); + TInt handle = iTrustedSessions->AddL( trustedSession ); + + // Send handle to client + TPckg handlePckg( handle ); + TInt checkValue = handlePckg(); + TRAPD( r, aMessage.WriteL(3, handlePckg)) + + RDEBUG_2("CTerminalControlSession::NewTrustedSessionL: %d", handle ); + + if ( r != KErrNone) + { + iTrustedSessions->Remove(handle); + PanicClient( aMessage, EBadDescriptor); + return; + } + + iSubsessionCount++; + } + } + +// ---------------------------------------------------------------------------------------- +// CTerminalControlSession::TrustedSessionFromHandle +// ---------------------------------------------------------------------------------------- +CTcTrustedSession* CTerminalControlSession::TrustedSessionFromHandle( const RMessage2& aMessage) + { + RDEBUG_2("CTerminalControlSession::TrustedSessionFromHandle: %d", aMessage.Int3() ); + + CTcTrustedSession* trustedSession = (CTcTrustedSession*)iTrustedSessions->At(aMessage.Int3()); + if (trustedSession == NULL) + PanicClient( aMessage, EBadSubsessionHandle); + return trustedSession; + } + +// ---------------------------------------------------------------------------------------- +// CTerminalControlSession::DeleteTrustedSession +// ---------------------------------------------------------------------------------------- +void CTerminalControlSession::DeleteTrustedSession( const RMessage2& aMessage) + { + RDEBUG_2("CTerminalControlSession::DeleteTrustedSession: %d", aMessage.Int3() ); + + + CTcTrustedSession* trustedSession = (CTcTrustedSession*)iTrustedSessions->At(aMessage.Int3()); + + //if (trustedSession == NULL) + // PanicClient( aMessage, EBadSubsessionHandle); + + iTrustedSessions->Remove(aMessage.Int3()); + + // delete trustedSession is not needed + + iSubsessionCount--; + } + +// ---------------------------------------------------------------------------------------- +// CTerminalControlSession::ServiceError +// Handle an error from CHelloWorldSession::ServiceL() +// ---------------------------------------------------------------------------------------- +void CTerminalControlSession::ServiceError(const RMessage2& aMessage,TInt aError) + { + RDEBUG_2("TerminalControlServer: CTerminalControlSession::ServiceError %d", aError); + + CSession2::ServiceError(aMessage,aError); + } + +// ---------------------------------------------------------------------------------------- +// CTerminalControlSession::SetDeviceLockParameterL +// ---------------------------------------------------------------------------------------- +TInt CTerminalControlSession::SetDeviceLockParameterL(const RMessage2 &aMessage) + { + RDEBUG_2("CTerminalControlSession::SetDeviceLockParameterL: %d", aMessage.Int0()); + + TInt status = KErrNone; + TInt type = aMessage.Int0(); + HBufC8* data = CopyParameterL(aMessage, 1); + TPtr8 ptr (data->Des()); + TInt value = 0; + TLex8 lex; + + CleanupStack::PushL( data ); + + //Check if the device memory is encrypted or not. + TBool encryptionEnabled = IsDeviceMemoryEncrypted(); + + switch(type) + { + case RTerminalControl3rdPartySession::ETimeout: + lex.Assign( *data ); + User::LeaveIfError( lex.Val( value ) ); + if ( 0 == value ) + { + if ( encryptionEnabled ) + { + //If drive memory is encrypted, do not set the value + User::Leave( KErrPermissionDenied ); + } + } + Server().SetLockTimeoutL( value ); + break; + + case RTerminalControl3rdPartySession::EMaxTimeout: + RDEBUG_2("Value of max timeout is %d", value); + lex.Assign( *data ); + User::LeaveIfError( lex.Val( value ) ); + + if ( encryptionEnabled ) + { + RDEBUG("Memory is encrypted"); + if ((0 == value) || value > KMaxAutolockPeriod) + { + RDEBUG_2("Denying setting of max auto lock as value is %d", value); + User::Leave( KErrPermissionDenied ); + } + } + else + { + RDEBUG("Memory is decrypted"); + } + Server().SetLockMaxTimeoutL( value ); + break; + + case RTerminalControl3rdPartySession::EPasscode: + Server().SetLockCodeL( *data ); + break; + + case RTerminalControl3rdPartySession::EPasscodePolicy: + lex.Assign( *data ); + User::LeaveIfError( lex.Val( value ) ); + Server().SetPasscodePolicyL( value ); + break; + + case RTerminalControl3rdPartySession::ELock: + lex.Assign( *data ); + User::LeaveIfError( lex.Val( value ) ); + RDEBUG_2("RTerminalControl3rdPartySession::ELock: %d", value ); + Server().SetLockLevelL( value ); + break; + + case RTerminalControl3rdPartySession::EDeviceWipe: + if(data->Des() != _L8("0")) + { + Server().WipeDeviceL(); + } + break; + +// ----- enhanced features BEGIN ---------------- +//#ifdef __SAP_DEVICE_LOCK_ENHANCEMENTS + + case RTerminalControl3rdPartySession::EPasscodeMinLength: + { + lex.Assign( *data ); + User::LeaveIfError( lex.Val( value ) ); + Server().SetPasscodeMinLengthL( value ); + } + break; + + case RTerminalControl3rdPartySession::EPasscodeMaxLength: + { + lex.Assign( *data ); + User::LeaveIfError( lex.Val( value ) ); + Server().SetPasscodeMaxLengthL( value ); + } + break; + + case RTerminalControl3rdPartySession::EPasscodeRequireUpperAndLower: + { + lex.Assign( *data ); + User::LeaveIfError( lex.Val( value ) ); + Server().SetPasscodeRequireUpperAndLowerL( value ); + } + break; + + case RTerminalControl3rdPartySession::EPasscodeRequireCharsAndNumbers: + { + lex.Assign( *data ); + User::LeaveIfError( lex.Val( value ) ); + Server().SetPasscodeRequireCharsAndNumbersL( value ); + } + break; + + case RTerminalControl3rdPartySession::EPasscodeMaxRepeatedCharacters: + { + lex.Assign( *data ); + User::LeaveIfError( lex.Val( value ) ); + Server().SetPasscodeMaxRepeatedCharactersL( value ); + } + break; + + case RTerminalControl3rdPartySession::EPasscodeHistoryBuffer: + { + lex.Assign( *data ); + User::LeaveIfError( lex.Val( value ) ); + Server().SetPasscodeHistoryBufferL( value ); + } + break; + + case RTerminalControl3rdPartySession::EPasscodeExpiration: + { + lex.Assign( *data ); + User::LeaveIfError( lex.Val( value ) ); + Server().SetPasscodeExpirationL( value ); + } + break; + + case RTerminalControl3rdPartySession::EPasscodeMinChangeTolerance: + { + lex.Assign( *data ); + User::LeaveIfError( lex.Val( value ) ); + Server().SetPasscodeMinChangeToleranceL( value ); + } + break; + + case RTerminalControl3rdPartySession::EPasscodeMinChangeInterval: + { + lex.Assign( *data ); + User::LeaveIfError( lex.Val( value ) ); + Server().SetPasscodeMinChangeIntervalL( value ); + } + break; + + case RTerminalControl3rdPartySession::EPasscodeCheckSpecificStrings: + { + lex.Assign( *data ); + User::LeaveIfError( lex.Val( value ) ); + Server().SetPasscodeCheckSpecificStringsL( value ); + } + break; + + case RTerminalControl3rdPartySession::EPasscodeDisallowSpecific: + { + Server().DisallowSpecificPasscodesL( *data ); + } + break; + + case RTerminalControl3rdPartySession::EPasscodeAllowSpecific: + { + Server().AllowSpecificPasscodesL( *data ); + } + break; + + case RTerminalControl3rdPartySession::EPasscodeClearSpecificStrings: + { + Server().ClearSpecificPasscodeStringsL(); + } + break; + + case RTerminalControl3rdPartySession::EPasscodeMaxAttempts: + { + lex.Assign( *data ); + User::LeaveIfError( lex.Val( value ) ); + Server().SetPasscodeMaxAttemptsL( value ); + } + break; + + case RTerminalControl3rdPartySession::EPasscodeConsecutiveNumbers: + { + lex.Assign( *data ); + User::LeaveIfError( lex.Val( value ) ); + Server().SetConsecutiveNumbersL( value ); + } + break; + + case RTerminalControl3rdPartySession::EPasscodeMinSpecialCharacters: + { + lex.Assign( *data ); + User::LeaveIfError( lex.Val( value ) ); + Server().SetPasscodeMinSpecialCharactersL( value ); + } + break; + case RTerminalControl3rdPartySession::EPasscodeDisallowSimple: + { + lex.Assign( *data ); + User::LeaveIfError( lex.Val( value ) ); + Server().SetDisallowSimpleL( value ); + } + break; + +//#endif +// ----- enhanced features END ---------------- + + default: + { + RDEBUG("CTerminalControlSession::SetDeviceLockParameterL() - 3rd party - ERROR - KErrNotSupported"); + User::Leave( KErrNotSupported ); + } + break; + + } + + CleanupStack::PopAndDestroy( data ); + + return status; + } + +// ---------------------------------------------------------------------------------------- +// CTerminalControlSession::GetDeviceLockParameterSizeL +// ---------------------------------------------------------------------------------------- +TInt CTerminalControlSession::GetDeviceLockParameterSizeL(const RMessage2 &aMessage) + { + RDEBUG_2("CTerminalControlSession::GetDeviceLockParameterSizeL: %d", aMessage.Int0() ); + + TBuf8 sizeBuf; + TBuf8 sizeBuf2; + TInt type = aMessage.Int0(); + + GetDeviceLockParameterL( sizeBuf, type ); + sizeBuf2.Num(sizeBuf.Length()); + + if(aMessage.GetDesMaxLength(1) >= sizeBuf2.Length()) + { + aMessage.WriteL(1, sizeBuf2); + } + else + { + User::Leave(KErrGeneral); + } + + return KErrNone; + } + +// ---------------------------------------------------------------------------------------- +// CTerminalControlSession::GetDeviceLockParameterL +// ---------------------------------------------------------------------------------------- +TInt CTerminalControlSession::GetDeviceLockParameterL(const RMessage2 &aMessage) + { + RDEBUG_2("CTerminalControlSession::GetDeviceLockParameterL: %d", aMessage.Int0() ); + + TBuf8 sizeBuf; + TInt status = KErrNone; + TInt type = aMessage.Int0(); + + GetDeviceLockParameterL( sizeBuf, type ); + + if(aMessage.GetDesMaxLength(1) >= sizeBuf.Length()) + { + aMessage.WriteL(1, sizeBuf); + } + else + { + User::Leave(KErrGeneral); + } + + return status; + } + +// ---------------------------------------------------------------------------------------- +// CTerminalControlSession::GetDeviceLockParameterL +// ---------------------------------------------------------------------------------------- +void CTerminalControlSession::GetDeviceLockParameterL(TBuf8 &sizeBuf, TInt aType) + { + RDEBUG_2("CTerminalControlSession::GetDeviceLockParameterL2: %d", aType ); + + switch(aType) + { + case RTerminalControl3rdPartySession::ETimeout: + sizeBuf.Num( Server().GetLockTimeoutL() ); + break; + + case RTerminalControl3rdPartySession::EMaxTimeout: + sizeBuf.Num( Server().GetLockMaxTimeoutL() ); + break; + + case RTerminalControl3rdPartySession::EPasscode: + User::Leave( KErrNotSupported ); + break; + + case RTerminalControl3rdPartySession::EPasscodePolicy: + sizeBuf.Num( Server().GetPasscodePolicyL() ); + break; + + case RTerminalControl3rdPartySession::ELock: + User::Leave( KErrNotSupported ); + break; + +// ----- enhanced features BEGIN ---------------- +//#ifdef __SAP_DEVICE_LOCK_ENHANCEMENTS + + case RTerminalControl3rdPartySession::EPasscodeMinLength: + { + sizeBuf.Num( Server().GetPasscodeMinLengthL() ); + } + break; + + case RTerminalControl3rdPartySession::EPasscodeMaxLength: + { + sizeBuf.Num( Server().GetPasscodeMaxLengthL() ); + } + break; + + case RTerminalControl3rdPartySession::EPasscodeRequireUpperAndLower: + { + sizeBuf.Num( Server().GetPasscodeRequireUpperAndLowerL() ); + } + break; + + case RTerminalControl3rdPartySession::EPasscodeRequireCharsAndNumbers: + { + sizeBuf.Num( Server().GetPasscodeRequireCharsAndNumbersL() ); + } + break; + + case RTerminalControl3rdPartySession::EPasscodeMaxRepeatedCharacters: + { + sizeBuf.Num( Server().GetPasscodeMaxRepeatedCharactersL() ); + } + break; + + case RTerminalControl3rdPartySession::EPasscodeHistoryBuffer: + { + sizeBuf.Num( Server().GetPasscodeHistoryBufferL() ); + } + break; + + case RTerminalControl3rdPartySession::EPasscodeExpiration: + { + sizeBuf.Num( Server().GetPasscodeExpirationL() ); + } + break; + + case RTerminalControl3rdPartySession::EPasscodeMinChangeTolerance: + { + sizeBuf.Num( Server().GetPasscodeMinChangeToleranceL() ); + } + break; + + case RTerminalControl3rdPartySession::EPasscodeMinChangeInterval: + { + sizeBuf.Num( Server().GetPasscodeMinChangeIntervalL() ); + } + break; + + case RTerminalControl3rdPartySession::EPasscodeCheckSpecificStrings: + { + sizeBuf.Num( Server().GetPasscodeCheckSpecificStringsL() ); + } + break; + + case RTerminalControl3rdPartySession::EPasscodeDisallowSpecific: + { + // this is set only value, can not get + User::Leave( KErrNotSupported ); + } + break; + + case RTerminalControl3rdPartySession::EPasscodeAllowSpecific: + { + // this is set only value, can not get + User::Leave( KErrNotSupported ); + } + break; + + case RTerminalControl3rdPartySession::EPasscodeClearSpecificStrings: + { + // this is set only value, can not get + User::Leave( KErrNotSupported ); + } + break; + + case RTerminalControl3rdPartySession::EPasscodeMaxAttempts: + { + sizeBuf.Num( Server().GetPasscodeMaxAttemptsL() ); + } + break; + + case RTerminalControl3rdPartySession::EPasscodeConsecutiveNumbers: + { + sizeBuf.Num( Server().GetConsecutiveNumbersL() ); + } + break; + + case RTerminalControl3rdPartySession::EPasscodeMinSpecialCharacters: + { + sizeBuf.Num( Server().GetPasscodeMinSpecialCharactersL() ); + } + break; + + case RTerminalControl3rdPartySession::EPasscodeDisallowSimple: + { + sizeBuf.Num( Server().GetDisallowSimpleL() ); + } + break; + +//#endif +// ----- enhanced features END ---------------- + + case RTerminalControl3rdPartySession::EDeviceWipe: + default: + { + RDEBUG("CTerminalControlSession::GetDeviceLockParameterL() - 3rd party - ERROR - KErrNotSupported"); + User::Leave( KErrNotSupported ); + } + break; + + } + } + +// ---------------------------------------------------------------------------------------- +// CTerminalControlSession::CopyParameterL +// ---------------------------------------------------------------------------------------- +HBufC8* CTerminalControlSession::CopyParameterL( const RMessage2 &aMsg, TInt aIndex ) + { + RDEBUG("CTerminalControlSession::CopyParameterL"); + + TInt length = aMsg.GetDesLengthL( aIndex ); + + HBufC8* buffer = HBufC8::NewL( length ); + TPtr8 ptr( buffer->Des() ); + aMsg.ReadL( aIndex, ptr ); + + return buffer; + } + +// --------------------------------------------------------- +// CTerminalControlSession::IsDeviceMemoryEncrypted +// Checks if phone memory is encrypted or not. +// --------------------------------------------------------- +TBool CTerminalControlSession::IsDeviceMemoryEncrypted() + { + RDEBUG("CTerminalControlSession::IsDeviceMemoryEncrypted >>"); + + TBool ret(EFalse); + + //First check if the feature is supported on device + TRAPD(ferr, FeatureManager::InitializeLibL()); + if (ferr != KErrNone) + { + RDEBUG_2("feature mgr initialization error, %d", ferr); + return EFalse; + } + ret = FeatureManager::FeatureSupported( KFeatureIdFfDeviceEncryptionFeature); + FeatureManager::UnInitializeLib(); + + //If feature is supported, check if any drive is encrypted. + if (ret) + { + CDevEncSession* devEncSession = new CDevEncSession( EDriveC ); + + if (!devEncSession) + { + RDEBUG("Can't instantiate device encryption session.."); + return EFalse; + } + + TInt err = devEncSession->Connect(); + if (KErrNone == err) + { + //Session with device encryption is established. Check if any drive is encrypted + TInt encStatus (KErrNone); + TInt err = devEncSession->DiskStatus( encStatus ); + RDEBUG_3("err = %d, encstatus = %d", err, encStatus); + if ( KErrNone == err && encStatus != EDecrypted ) + { + RDEBUG("Memory is encrypted"); + ret = ETrue; + } + else + { + RDEBUG("Memory is not encrypted"); + ret = EFalse; + } + } + else + { + RDEBUG_2("Error %d while establishing connection with device encryption engine", err); + ret = EFalse; + } + + delete devEncSession; devEncSession = NULL; + } + + RDEBUG_2("CTerminalControlSession::IsDeviceMemoryEncrypted, ret = %d <<", ret); + return ret; + } + +// ---------------------------------------------------------------------------------------- +// End of file