/*

* 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 <e32svr.h>

#include <f32file.h>

#include <apgtask.h>

#include <rfsClient.h>

#include <TerminalControl3rdPartyAPI.h>

#include "TerminalControlSession.h"

#include "PlatformSecurityPolicies.h"

#include "TcTrustedSession.h"

//Device encryption utility

#include <DevEncEngineConstants.h>

#include <DevEncSessionBase.h>

//Feature manager

#include <featmgr.h>

//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<CTerminalControlServer*>(const_cast<CServer2*>(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<MAX_NUMBER_OF_DIGITS_IN_10BASE_INT64> 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();