/*

* Copyright (c) 2000 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

*

*/

// INCLUDE FILES

#include <e32debug.h>

#include <e32math.h>

#include <e32cmn.h>

#include    <e32property.h>

#include    <PSVariables.h>   // Property values

#include 	<coreapplicationuisdomainpskeys.h>

#include "SCPServer.h"

#include "SCPSession.h"

#include "SCPLockSettingEventHandler.h"

#include "SCPLockNotificationEventHandler.h"

// For Central Repository

#include <centralrepository.h>

#include "SCPCodePrivateCRKeys.h"

#include "SCPLockCode.h"

#ifdef SCP_SMS_LOCK_AVAILABLE

#include <RemoteLockSettings.h>

#endif // SCP_SMS_LOCK_AVAILABLE

//#ifdef __SAP_DEVICE_LOCK_ENHANCEMENTS

#include <SCPParamObject.h>

//#endif // __SAP_DEVICE_LOCK_ENHANCEMENTS

#include <featmgr.h>

#include "SCPDebug.h"

#include <TerminalControl3rdPartyAPI.h>

#include <TerminalControl3rdPartyParamsPlugin.h>

#include <utf.h>

#include <PolicyEngineXACML.h>

// ================= MEMBER FUNCTIONS =======================

// C++ default constructor can NOT contain any code, that

// might leave.

//

CSCPSession::CSCPSession( CSCPServer& aServer )

	: CSession2(),

	iServer( aServer ),

	iLockCommandState( ESCPLockCmdStateIdle ),

	iUnlockMessageSent( EFalse ),

	iLockOperationTimer( NULL ),

	iPendingCallStatus( NULL ),

	iALParamValue(NULL)

	{

	}

// Symbian 2nd phase constructor can leave.

void CSCPSession::ConstructL()

    {

    User::LeaveIfError( iPE.Connect() );

    User::LeaveIfError( iPR.Open( iPE ) );

    iServer.SessionOpened();

    }

// Static constructor.

CSCPSession* CSCPSession::NewL( CSCPServer& aServer )

	{

	CSCPSession* self = CSCPSession::NewLC( aServer );

	CleanupStack::Pop( self );

	return self;	

	}

// Static constructor, leaves object pointer to the cleanup stack.

CSCPSession* CSCPSession::NewLC( CSCPServer& aServer )

    {

    CSCPSession* self = new(ELeave) CSCPSession( aServer );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor

CSCPSession::~CSCPSession()

    {

    Dprint( (_L("--> CSCPSession::~CSCPSession()")) );

    delete iLockOperationTimer;

    iLockOperationTimer = NULL;

    delete iNotificationHandler; 

    iNotificationHandler = NULL;   

    delete iSettingHandler;    

    iSettingHandler = NULL;

    iPendingCallStatus = NULL;

    iServer.SessionClosed();

    if(iALParamValue) {

		delete iALParamValue;		

    }

    iPR.Close();

	iPE.Close();    

    Dprint( (_L("<-- CSCPSession::~CSCPSession()")) );   

    }

// ---------------------------------------------------------

// TBool CSCPSession::IsOperationInProgress( TSCPAdminCommand aCommand )

// Checks from the state variable, if the given command is actually in progress

// 

// Status : Approved

// ---------------------------------------------------------

//

TBool CSCPSession::IsOperationInProgress( TSCPAdminCommand aCommand )

    {    

    Dprint( (_L("--> CSCPSession::IsOperationInProgress( %d )"), aCommand ));

    TBool ret = EFalse;

    if ( aCommand == ESCPCommandLockPhone )

        {

        if (    ( iLockCommandState == ESCPLockCmdStateInProgress )

            ||  ( iLockCommandState == ESCPLockCmdStateInProgressAcknowledged )

           )

            {

            ret = ETrue; 

            }

        }

    if ( aCommand == ESCPCommandUnlockPhone )

        {

        if ( iUnlockMessageSent )

            {

            ret = ETrue;

            }

        }

    Dprint( (_L("<-- CSCPSession::IsOperationInProgress(): %d"), ret ));

    return ret;

    }

// ---------------------------------------------------------

// TBool CSCPSession::AcknowledgeOperation( TSCPAdminCommand aCommand )

// Set the state variable accordingly, if it was set in a waiting state

// and return the status value respectively.

// 

// Status : Approved

// ---------------------------------------------------------

//

TBool CSCPSession::AcknowledgeOperation( TSCPAdminCommand aCommand )

    {

    Dprint( (_L("--> CSCPSession::AcknowledgeOperation( %d )"), aCommand ));

    // The return parameter, set this if the ack was awaited

    TBool ret = EFalse;

    if ( aCommand == ESCPCommandLockPhone )        

        {

        switch ( iLockCommandState )

            {

            case ( ESCPLockCmdStateInProgress ):

                {                                                      

                // Acknowledgement received, now just wait for the actual 

                // call to finish

                Dprint( (_L("CSCPSession::AcknowledgeOperation( %d ): \

                    Lock-op acknowledged"), aCommand ));

                iLockCommandState = ESCPLockCmdStateInProgressAcknowledged;

                iNotificationHandler->AckReceived();

                ret = ETrue;

                break;

                }

            case ( ESCPLockCmdStateFinishedAckPending ):                

                {

                // OK, the operation is completed

                Dprint( (_L("CSCPSession::AcknowledgeOperation( %d ): \

                    Lock-op acknowledged"), aCommand ));

                iLockCommandState = ESCPLockCmdStateIdle;

                iUnlockMessageSent = EFalse;                    

                Dprint( (_L("CSCPSession::AcknowledgeOperation( %d ): \

                    Completing wait"), aCommand ));

                User::RequestComplete( iPendingCallStatus, KErrNone );

                iPendingCallStatus = NULL;

                ret = ETrue;                    

                break;

                }                

            case ( ESCPLockCmdStateIdle ): 

            // Flow through, nothing here

            case ( ESCPLockCmdStateInProgressAcknowledged ):

            // Flow through, nothing here  

            default:

            // No action          

            break;                

            }

        }

    if ( aCommand == ESCPCommandUnlockPhone )

        {

        if ( iUnlockMessageSent )

            {

            Dprint( (_L("CSCPSession::AcknowledgeOperation( %d ): \

                Completing Unlock-event"), aCommand ));

            ret = ETrue;

            // Complete the call

            iUnlockMessageSent = EFalse;            

            User::RequestComplete( iPendingCallStatus, KErrNone );

            iPendingCallStatus = NULL;

            }

        }        

    Dprint( (_L("<-- CSCPSession::AcknowledgeOperation(): %d"), ret ));    

    return ret;

    }        

// ---------------------------------------------------------

// void CSCPSession::HandleGetCodeMessageL( const RMessage2 &aMessage )

// Gets the stored code from the server and returns it to the

// client thread.

// 

// Status : Approved

// ---------------------------------------------------------

//

void CSCPSession::HandleGetCodeMessageL( const RMessage2 &aMessage )

    {    

    Dprint( (_L("--> CSCPSession::HandleGetCodeMessageL()") ));

    TSCPSecCode code;

    code.Zero();

    if ( iServer.GetCode( code ) != KErrNone )

        {

        User::Leave( KErrGeneral );

        }   

    aMessage.WriteL( 0, code );    

    Dprint( (_L("<-- CSCPSession::HandleGetCodeMessageL()") ));  

    }

// ---------------------------------------------------------

// void CSCPSession::HandleSetCodeMessageL( const RMessage2 &aMessage )

// Reads the code from the client buffer, and sends it to the server.

// 

// Status : Approved

// ---------------------------------------------------------

//

void CSCPSession::HandleSetCodeMessageL( const RMessage2 &aMessage )

    {

    Dprint( (_L("--> CSCPSession::HandleSetCodeMessageL()") ));

    RMobilePhone::TMobilePassword code;

    aMessage.ReadL( 0, code );    

    TSCPSecCode curCode;

    iServer.GetCode( curCode );

    if ( curCode.Compare( code ) == 0 )

        {

        TInt retErrorNone = KErrNone;

        // The codes are already the same.

        User::Leave( retErrorNone );

        }

#ifndef __WINS__    

    // No access to the ISA side in emulator

    // Check the given code, leave on error

    iServer.CheckISACodeL( code );

#endif //  __WINS__

    TInt ret = iServer.StoreCode( code ); 

    if ( ret != KErrNone )

        {

        User::Leave( ret );

        }

    Dprint( (_L("<-- CSCPSession::HandleSetCodeMessageL()") ));

    }

//#ifndef __SAP_DEVICE_LOCK_ENHANCEMENTS 

// ---------------------------------------------------------

// void CSCPSession::HandleChangeCodeMessageL( const RMessage2 &aMessage )

// Fetches the stored code from the server, reads the new code

// from the client side, and calls the method to change the code.

// 

// Status : Approved

// ---------------------------------------------------------

//

void CSCPSession::HandleChangeCodeMessageL( const RMessage2 &aMessage )

    {

    if(!FeatureManager::FeatureSupported(KFeatureIdSapDeviceLockEnhancements))

    {

    Dprint( (_L("--> CSCPSession::HandleChangeCodeMessageL()") ));                

    RMobilePhone::TMobilePassword newPassword;

    aMessage.ReadL( 0, newPassword );    

	// Possible leave will result in an error status for the client

	iServer.ChangeISACodeL( newPassword );

	Dprint( (_L("<-- CSCPSession::HandleChangeCodeMessageL()") ));	

	}	

	else

/*

#else // __SAP_DEVICE_LOCK_ENHANCEMENTS active

// ---------------------------------------------------------

// void CSCPSession::HandleChangeCodeMessageL( const RMessage2 &aMessage )

// Send the code in slot 0 to the server for storage. 

//

// 

// Status : Approved

// ---------------------------------------------------------

//

void CSCPSession::HandleChangeCodeMessageL( const RMessage2 &aMessage )

*/

    {

    Dprint( (_L("--> CSCPSession::HandleChangeCodeMessageL()") ));

    (void)aMessage;

    HBufC* codeHBuf = HBufC::NewLC( KSCPMaxEnhCodeLen + 1 );

    TPtr codeBuf = codeHBuf->Des();

    aMessage.ReadL( 0, codeBuf );

    if ( !iServer.IsValidEnhCode( codeBuf ) )

        {

        Dprint( (_L("CSCPSession::HandleChangeCodeMessageL(): ERROR:\

            Invalid code format") ));

        CleanupStack::PopAndDestroy( codeHBuf );

        User::Leave( KErrArgument );

        }

    iServer.StoreEnhCode( codeBuf );

    CleanupStack::PopAndDestroy( codeHBuf );

	Dprint( (_L("<-- CSCPSession::HandleChangeCodeMessageL()") ));	

	}

    }

//#endif // __SAP_DEVICE_LOCK_ENHANCEMENTS

// ---------------------------------------------------------

// void CSCPSession::HandleSetLockStateMessageL( const RMessage2 &aMessage )

// Sets the DOS lock setting to enabled/disabled, 

// and activates or deactivates Autolock via SetDOSLockSetting.

// 

// Status : Approved

// ---------------------------------------------------------

//

void CSCPSession::HandleSetLockStateMessageL( const RMessage2 &aMessage )

    {

    Dprint( (_L("--> CSCPSession::HandleSetLockStateMessageL()") ));

    TInt lockState = aMessage.Int0();

    Dprint( (_L("CSCPSession::HandleSetLockStateMessageL(), lock command: %d"),

        lockState ));

    SetDOSLockSettingL( lockState, ETrue, aMessage );

    Dprint( (_L("<-- CSCPSession::HandleSetLockStateMessageL()") ));

    }

// ---------------------------------------------------------

// void CSCPSession::SetDOSLockSettingL( TBool aLocked, const RMessage2 &aMessage )

// Checks whether a lock operation is already in progress, if not, 

// starts the operation by creating the two active objects responsible for handling

// the call, and sets the state variable accordingly.

// 

// Status : Approved

// ---------------------------------------------------------

void CSCPSession::SetDOSLockSettingL( TBool aLocked, 

                                      TBool aAutolock,

                                      const RMessage2 &aMessage )

    {

    // Only one lock/unlock phone command can be in progress at a time

    if (    ( IsOperationInProgress( ESCPCommandLockPhone ) )

            || ( IsOperationInProgress( ESCPCommandUnlockPhone ) )

            || ( iServer.IsOperationInProgress( ESCPCommandLockPhone ) )

            || ( iServer.IsOperationInProgress( ESCPCommandUnlockPhone ) )

       )

        {

        User::Leave( KErrInUse );

        }

    // Fetch the stored password from the server

    TSCPSecCode storedCode;

    if ( iServer.GetCode( storedCode ) != KErrNone )

        {

        Dprint( (_L("CSCPSession::HandleLockPhoneMessageL():\

            FAILED to get stored code!") ));

        User::Leave( KErrGeneral );

        }

    // Create a timer object for this call

    iLockOperationTimer = CSCPTimer::NewL( KSCPLockOperationTimeout, NULL, this );

    // Set the state parameter for this session, a lock command is now in progress

    iLockCommandState = ESCPLockCmdStateInProgress;

#ifndef __WINS__ // The notification handler is not used in emulator

    // Don't create the notification handler if it won't be used 

    // (because DOS lock won't be disabled)

    if ( ( aLocked ) || ( ( !IsSMSLockActiveL() ) && ( !IsAutolockActive() ) ) )

        {

        iNotificationHandler = CSCPLockNotificationEventHandler::NewL( &iServer, this );

        }

#endif // WINS

    iSettingHandler = CSCPLockSettingEventHandler::NewL( 

        aMessage, this, aLocked, aAutolock, &iServer );

    iSettingHandler->StartL();

    }

// ---------------------------------------------------------

// void CSCPSession::HandleQueryMessageL( const RMessage2 &aMessage )

// Checks if the given operation is in progress, and acknowledges the

// message. The return value is computed based on the calls, if either

// is true, so is the return value.

// 

// Status : Approved

// ---------------------------------------------------------

//

void CSCPSession::HandleQueryMessageL( const RMessage2 &aMessage )

    {

    Dprint( (_L("--> CSCPSession::HandleQueryMessageL()") ));

    #ifdef SCP_ENFORCE_SECURITY

    // Check the process permissions for this call

    switch ( (TSCPAdminCommand)aMessage.Int0() )

        {

        case ( ESCPCommandLockPhone ):

            {

            // Only Security Observer allowed

            if ( aMessage.SecureId() != KAknNfySrvUid /*KSCPServerSIDSecurityObserver*/ )

                {

                Dprint( (_L("CSCPSession::HandleQueryMessageL():\

                    ERROR: Permission denied") ));

                User::Leave( KErrPermissionDenied );

                }

            break;

            }

        case ( ESCPCommandUnlockPhone ):

            {

            // Only Autolock allowed

            if ( aMessage.SecureId() != KSCPServerSIDAutolock )

                {

                Dprint( (_L("CSCPSession::HandleSetParamMessageL():\

                    ERROR: Permission denied") ));

                User::Leave( KErrPermissionDenied );

                }

            break;

            }

        default: 

            {                        

            Dprint( (_L("CSCPSession::HandleQueryMessageL():DEFAULT:\

                Permission denied") ));

            User::Leave( KErrPermissionDenied );

            }

        break;        

        }

    #endif

    // Check from the server, if another session has initiated a lock operation

    // Also if an acknowledgement was awaited for this operation, the return

    // value should be true

    TSCPAdminCommand commandQueried = (TSCPAdminCommand)aMessage.Int0();

    TBool ret1 = iServer.IsOperationInProgress( commandQueried );

    TBool ret2 = iServer.AcknowledgementReceived( commandQueried );

    TBool ret = ret1 || ret2;

    // Return the reply        

    TInt retWrap = (TInt)ret;

    TPckg<TInt> retPackage(retWrap);

    aMessage.WriteL(1, retPackage );

    Dprint( (_L("<-- CSCPSession::HandleQueryMessageL()") ));

    }