/*

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

#include <e32std.h>

#include <ecom/implementationproxy.h>

#include <SCPParamObject.h>

#include <SCPServerInterface.h>

#include "SCP_IDs.h"

#include <bautils.h>

#include <hal.h>

#include <AknGlobalNote.h>

#include <AknGlobalConfirmationQuery.h>

// For wipe

#include <starterclient.h>

#include <sysutil.h>

#include <syslangutil.h>

#include <rfsClient.h>

#include "DMUtilClient.h"

#include "SCPTimestampPlugin.h"

#include <featmgr.h>

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#include <pathinfo.h>

#include <f32file.h>

#endif //RD_MULTIPLE_DRIVEs

// CONSTANTS

// ============================= LOCAL FUNCTIONS  =============================

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

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

// CSCPTimestampPlugin::NewL

// Two-phased contructor

// 

// Status : Approved

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

//

CSCPTimestampPlugin* CSCPTimestampPlugin::NewL()

    {

	CSCPTimestampPlugin* self = new ( ELeave ) CSCPTimestampPlugin();

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

    Dprint ( ( _L( "( 0x%x ) CSCPPatternPlugin::NewL()" ), self ) );

    return self;

    }

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

// CSCPTimestampPlugin::CSCPTimestampPlugin

// Constructor

//

// Status : Approved

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

//

CSCPTimestampPlugin::CSCPTimestampPlugin()

    : iEventHandler( NULL ),

      iConfiguration( NULL ),

      iResOpen( EFalse )

    {

    Dprint ( ( _L( "CSCPTimestampPlugin::CSCPTimestampPlugin()" ) ) );

    return;

    }

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

// CSCPTimestampPlugin::ConstructL

// 2nd phase constructor

// 

// Status : Approved

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

//

void CSCPTimestampPlugin::ConstructL()

    {   

    FeatureManager::InitializeLibL();

		if(!FeatureManager::FeatureSupported(KFeatureIdSapDeviceLockEnhancements))

		{

    	FeatureManager::UnInitializeLib();

   		User::Leave( KErrNotSupported );

  	}

   	FeatureManager::UnInitializeLib();  

    Dprint ( ( _L( "CSCPTimestampPlugin::ConstructL()" ) ) );    

    return;

    }

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

// CSCPTimestampPlugin::~CSCPTimestampPlugin

// Destructor

//

// Status : Approved

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

//

CSCPTimestampPlugin::~CSCPTimestampPlugin()

    {

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

    iResFile.Close();

    if ( iConfiguration != NULL )

        {

        delete iConfiguration;

        iConfiguration = NULL;

        }

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

    return;

    }

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

// CSCPTimestampPlugin::HandleEvent

// 

// 

// Status : Approved

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

//    

void CSCPTimestampPlugin :: HandleEventL( TInt aID, CSCPParamObject& aParam, CSCPParamObject& aOutParam )

	{

	Dprint ( ( _L( "CSCPTimestampPlugin::HandleEvent()" ) ) );		

	// Get our current functional configuration

	if ( iEventHandler->GetParameters().Get( 

	        RTerminalControl3rdPartySession::EPasscodeExpiration, iExpiration ) != KErrNone )

	    {

	    iExpiration = 0;

	    }	    

	if ( iEventHandler->GetParameters().Get( 

	        RTerminalControl3rdPartySession::EPasscodeMinChangeInterval, iMinInterval) != KErrNone )

	    {

	    iMinInterval = 0;

	    }

	if ( iEventHandler->GetParameters().Get( 

	        RTerminalControl3rdPartySession::EPasscodeMinChangeTolerance, iMinTolerance) != KErrNone )

	    {

	    iMinTolerance = 0;

	    }

	if ( iEventHandler->GetParameters().Get( 

	        RTerminalControl3rdPartySession::EPasscodeMaxAttempts, iMaxAttempts ) != KErrNone )

	    {

	    iMaxAttempts = 0;

	    }	    	    

	Dprint( ( _L( "CSCPPatternPlugin::IsChangeAllowedL(): iExpiration :%d, iExpiration :%d, iMinTolerance :%d, iMaxAttempts :%d"), iExpiration,iMinInterval,iMinTolerance,iMaxAttempts ) ); 

	Dprint( ( _L( "CSCPPatternPlugin::IsChangeAllowedL(): aID is :%d"), aID) );

	switch ( aID )

	    {	    	    

	    case ( KSCPEventPasswordChangeQuery ):

	        {

	        if ( iMinInterval > 0 )

                {   

	            // Ignore errors, the plugin will stay silent on error

	            TRAP_IGNORE( IsChangeAllowedL( aParam, aOutParam ) );

                }

	        break;

	        }

	    case ( KSCPEventConfigurationQuery ):

	        {

	        TInt paramID;	            	            

	        if ( aParam.Get( KSCPParamID, paramID ) == KErrNone ) 

	            {	                

	            ConfigurationQuery( paramID, aParam, aOutParam );

	            }

	        break;

	        }

	    case ( KSCPEventPasswordChanged ):

	        {	            

	        PasswordChanged( aParam, aOutParam );

	        break;

	        }

        case ( KSCPEventAuthenticationAttempted ):

            {

            TInt authStatus;

            if ( aParam.Get( KSCPParamStatus, authStatus ) == KErrNone ) // Ignore errors

                {

                TBool isSuccess = ( authStatus == KErrNone );

                // No return value required in any case

                AuthenticationAttempt( isSuccess, aParam, aOutParam );

                }	            

            break;

            }

        case ( KSCPEventReset ):

              {

              // Reset the configuration for this plugin.

              if ( ReadConfiguration() == KErrNone )

                {

                iConfiguration->Reset();

                WriteConfiguration();

                }

              break;

              }            

        default:

            // No implementation required, we're not interested in other events

        break;	            	            

	    }	    	    

    // The caller will own this pointer from now on   

	}

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

// CSCPTimestampPlugin::HandleEvent

// 

// 

// Status : Approved

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

//    

void CSCPTimestampPlugin::SetEventHandler( MSCPPluginEventHandler* aHandler )

	{

	Dprint( ( _L( "CSCPPatternPlugin::SetEventHandler()" ) ) ) ;

	iEventHandler = aHandler;

	iFsSession = &(iEventHandler->GetFsSession());	

	}	

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

// CSCPTimestampPlugin::IsChangeAllowed()

// 

// 

// Status : Approved

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

// 

void CSCPTimestampPlugin::IsChangeAllowedL( CSCPParamObject& aParam, CSCPParamObject& aRetParams )

    {  

    (void)aParam;

    Dprint( (_L("CSCPTimestampPlugin::IsChangeAllowedL()") ));                      

    TInt ret = KErrNone;

    if ( ReadConfiguration() != KErrNone )

        {

        Dprint( (_L("CSCPTimestampPlugin::IsChangeAllowedL() ReadConfiguration() != KErrNone RETURNING") ));

        return; // Someting wrong

        }    

    // Check if the change is within the interval

    TInt ret2 = IsAfter( KSCPIntervalStartTime, iMinInterval, KSCPTypeHours );

    if ( ret2 == KSCPIsAfter )

        {

        // Interval exceeded, change OK

        Dprint( (_L("CSCPTimestampPlugin::IsChangeAllowedL() KSCPIsAfter") ));

        ret = KErrNone;                    

        }

    else if ( ret2 == KSCPIsNotAfter )

        {

        // Change within the interval, check the tolerance

        Dprint( (_L("CSCPTimestampPlugin::IsChangeAllowedL() KSCPIsNotAfter") )); 

        TInt tolerance = 0;

        iConfiguration->Get( KSCPUsedTolerance, tolerance ); // ignore errors

        Dprint( ( _L( "CSCPPatternPlugin::IsChangeAllowedL(): tolerance get: %d"), tolerance ) );                

        Dprint( ( _L( "CSCPPatternPlugin::IsChangeAllowedL(): iMinTolerance : %d"), iMinTolerance ) );                

        if ( tolerance >= iMinTolerance )

            {

            ret = KErrSCPCodeChangeNotAllowed;

            Dprint( (_L("CSCPTimestampPlugin::IsChangeAllowedL() KErrSCPCodeChangeNotAllowed") )); 

            }

        // Used tolerance will increment in passwordChanged                

        }

    else 

        {

        // Error, new interval will start in passwordChanged.

        Dprint( (_L("CSCPTimestampPlugin::IsChangeAllowedL() Error, new interval will start in passwordChanged") )); 

        }                                                                     

    if ( ret == KErrSCPCodeChangeNotAllowed )

        {

        Dprint ( ( _L( "EDeviceLockMinChangeTolerance Failed" ) ) );

        aRetParams.AddtoFailedPolices(EDeviceLockMinChangeTolerance);

        aRetParams.Set( KSCPParamStatus, KErrSCPCodeChangeNotAllowed );

        }

    }

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

// CSCPTimestampPlugin::PasswordChanged()

// 

// 

// Status : Approved

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

//    

void CSCPTimestampPlugin::PasswordChanged( CSCPParamObject& aParam, CSCPParamObject& aRetParams )

    {

    (void)aParam;

    Dprint( (_L("CSCPTimestampPlugin::PasswordChanged()") ));                      

    TInt err = ReadConfiguration();

    if ( err == KErrNone )

        {

        // Check if immediate expiration is set

        Dprint( (_L("CSCPTimestampPlugin::PasswordChanged() : ReadConfiguration = KErrNone") ));                      

        TInt expireNow = 0;

        if ( iConfiguration->Get( KSCPExpireOnNextCall, expireNow ) == KErrNone )

            {

            iConfiguration->Unset( KSCPExpireOnNextCall );

            }                                

        TBuf<KSCPMaxInt64Length> timeBuf; 

        timeBuf.Zero();       

        // Fetch the current time and fill the buffer

        TTime curTime;

        curTime.UniversalTime();

        timeBuf.AppendNum( curTime.Int64() );

        if ( iExpiration > 0 )

            {

            // Set the last time the password was changed, for expiration

            iConfiguration->Set( KSCPLastChangeTime, timeBuf );

            }        

        Dprint( ( _L( "CSCPPatternPlugin::PasswordChanged(): iMinInterval: %d"), iMinInterval ) );

        if ( iMinInterval > 0 )

            {

            TInt ret = IsAfter( KSCPIntervalStartTime, iMinInterval, KSCPTypeHours );

            if ( ret == KSCPIsAfter )

                {                                                        

                // Interval exceeded, start a new interval from here

                Dprint( (_L("CSCPTimestampPlugin::PasswordChanged() KSCPIsAfter") ));    

                iConfiguration->Set( KSCPIntervalStartTime, timeBuf );

                iConfiguration->Set( KSCPUsedTolerance, 1 );

                }

            else if ( ret == KSCPIsNotAfter )

                {

                // Change within the interval, increment the used tolerance

                Dprint( (_L("CSCPTimestampPlugin::PasswordChanged() KSCPIsNotAfter") ));

                TInt tolerance = 0;

                iConfiguration->Get( KSCPUsedTolerance, tolerance ); //ignore errors, default to 0

                Dprint( ( _L( "CSCPPatternPlugin::PasswordChanged(): tolerance get: %d"), tolerance ) );

                tolerance++;        

                iConfiguration->Set( KSCPUsedTolerance, tolerance );                

                Dprint( ( _L( "CSCPPatternPlugin::PasswordChanged(): tolerance set: %d"), tolerance ) );                

                }                                                                

            else // error

                {

                // No time set, start a new interval from here

                Dprint( (_L("CSCPTimestampPlugin::PasswordChanged() error") ));

                iConfiguration->Set( KSCPIntervalStartTime, timeBuf );

                TInt tolerance = 0;

                iConfiguration->Get( KSCPUsedTolerance, tolerance ); //ignore errors, default to 0

                Dprint( ( _L( "CSCPPatternPlugin::PasswordChanged(): tolerance get: %d"), tolerance ) );

                tolerance++;        

                iConfiguration->Set( KSCPUsedTolerance, tolerance );

                Dprint( ( _L( "CSCPPatternPlugin::PasswordChanged(): tolerance set: %d"), tolerance ) );  

                }                       

            }        

        WriteConfiguration();

        }

        else

        {

            Dprint( (_L("CSCPTimestampPlugin::PasswordChanged() ReadConfiguration() != KErrNone") ));                      

            Dprint( ( _L( "CSCPPatternPlugin::PasswordChanged(): ReadConfiguration() = %d"), err ) );

        }

    }

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

// CSCPTimestampPlugin::AuthenticationAttempt()

// 

// 

// Status : Approved

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

//    

void CSCPTimestampPlugin :: AuthenticationAttempt( TBool aIsSuccessful, 

                                                 CSCPParamObject& aParam,

                                                 CSCPParamObject& aRetParams )

    {

    Dprint( (_L("CSCPTimestampPlugin::AuthenticationAttempt") )); 

    if ( ReadConfiguration() != KErrNone )

        {

        return;

        }

    // Check if immediate expiration is set

    TInt expireNow = 0;

    iConfiguration->Get( KSCPExpireOnNextCall, expireNow ); // ignore errors  

    Dprint( ( _L( "CSCPPatternPlugin::AuthenticationAttempt(): expireNow = %d"), expireNow ) );

    if ( ( iExpiration == 0 ) && ( iMaxAttempts == 0) && ( expireNow == 0 ) )

        {

        return; // We have no interest in this call

        }                

    if ( aIsSuccessful )

        {

        TRAP_IGNORE( SuccessfulAuthenticationL( aParam, aRetParams ) );

        }

    else

        {

        // Failed authentication attempt

        if ( iMaxAttempts > 0 )

            {

            TInt failedCount = 0;

            iConfiguration->Get( KSCPFailedAttempts, failedCount ); // ignore errors

            failedCount++;                        

            if ( failedCount == iMaxAttempts - 1 )

                {

                Dprint ( ( _L( "EDeviceLockAllowedMaxAtempts Failed" ) ) );

                aRetParams.AddtoFailedPolices(EDeviceLockAllowedMaxAtempts);

                }

            else if ( failedCount >= iMaxAttempts )

                {

                // Try to wipe the device

                TRAPD( err, WipeDeviceL( aRetParams ) );

                if ( err != KErrNone )

                    {

                    Dprint( ( _L( "CSCPPatternPlugin::\

                        AuthenticationAttempt(): Wipe FAILED :%d"), err ) );

                    }

                }

            iConfiguration->Set( KSCPFailedAttempts, failedCount );

            }

        }

    WriteConfiguration();        

    }

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

// CSCPTimestampPlugin::SuccessfulAuthentication()

// 

// 

// Status : Approved

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

//

void CSCPTimestampPlugin::SuccessfulAuthenticationL( CSCPParamObject& aParam,

                                                    CSCPParamObject& aRetParams )

    {

    Dprint( (_L("CSCPTimestampPlugin::IsAfter()..enter") ));

    // Reset the failed attempts -counter

    if ( iMaxAttempts > 0 )

        {

        iConfiguration->Set( KSCPFailedAttempts, 0 );

        }

    // Check context, if the user is already changing the password, don't force it again.

    TInt context = 0;

    aParam.Get( KSCPParamContext, context ); // ignore errors

    // Check if immediate expiration is set

    TInt expireNow = 0;

    iConfiguration->Get( KSCPExpireOnNextCall, expireNow ); // ignore errors    

    Dprint( ( _L( "CSCPPatternPlugin::SuccessfulAuthenticationL(): expireNow = %d, iExpiration =%d"), expireNow,iExpiration ) );

    // Check if the code should be changed now    

    if ( ( context != KSCPContextChangePsw ) && 

         ( ( iExpiration > 0 ) ||  ( expireNow ) ) )

        {                    

        if ( ( IsAfter( KSCPLastChangeTime, iExpiration, KSCPTypeDays ) == KSCPIsAfter ) ||

             ( expireNow ) )

            {

            Dprint ( ( _L( "EDeviceLockPasscodeExpiration Failed" ) ) );

                aRetParams.AddtoFailedPolices(EDeviceLockPasscodeExpiration);

                aRetParams.Set( KSCPParamStatus, KErrSCPInvalidCode );

            }

        }

    Dprint( (_L("CSCPTimestampPlugin::IsAfter()..exit") ));

    }

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

// CSCPTimestampPlugin::IsAfter()

// 

// 

// Status : Approved

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

//

TInt CSCPTimestampPlugin::IsAfter( TInt aConfID, TInt aInterval, TInt aIntType )

    {

    TInt ret;

    Dprint( (_L("CSCPTimestampPlugin::IsAfter()") ));

    TTime curTime;

    curTime.UniversalTime();        

    TBuf<KSCPMaxInt64Length> savedTimeBuf;

    TInt64 savedTime;

    Dprint( ( _L( "CSCPPatternPlugin::IsAfter: aConfID value is  :%d"), aConfID ) );

    ret = iConfiguration->Get( aConfID, savedTimeBuf );

    if ( ret == KErrNone )

        {    

        Dprint( (_L("CSCPTimestampPlugin::IsAfter() iConfiguration->Get == KErrNone") ));    

        TLex lex( savedTimeBuf );

        ret = lex.Val( savedTime );

        if ( ret == KErrNone )

            {

            Dprint( (_L("CSCPTimestampPlugin::IsAfter() lex.Val( savedTime ) == KErrNone") ));

            TTime configTime( savedTime );

            switch ( aIntType )