/*

* 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 <SCPTimestampPluginLang.rsg>

#include "SCP_IDs.h"

#include <bautils.h>

#include <hal.h>

#include <AknGlobalNote.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();  

	iUserInfo = CSCPUserInf::NewL();

    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;

        }

    if(iUserInfo)

        delete iUserInfo;

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

    return;

    }

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

// CSCPTimestampPlugin::HandleEvent

// 

// 

// Status : Approved

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

//    

CSCPParamObject* CSCPTimestampPlugin::HandleEvent( TInt aID, CSCPParamObject& aParam )

	{		

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

	CSCPParamObject* retParams = NULL;

	// 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;

	    }	    	    

	if ( !iResOpen )

	    {

	    // Load the resource file containing the localized texts

        TInt ret = GetResource();

        if ( ret == KErrNone )

            {

            iResOpen = ETrue;

            }

        // We'll continue without the resource if required

	    }		    

	switch ( aID )

	    {	    	    

	    case ( KSCPEventPasswordChangeQuery ):

	        {

	        if ( iMinInterval > 0 )

                {   

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

	            TRAP_IGNORE( IsChangeAllowedL( aParam, retParams ) );

                }

	        break;

	        }

	    case ( KSCPEventConfigurationQuery ):

	        {

	        TInt paramID;	            	            

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

	            {	                

	            ConfigurationQuery( paramID, aParam, retParams );

	            }

	        break;

	        }

	    case ( KSCPEventPasswordChanged ):

	        {	            

	        PasswordChanged( aParam, retParams );

	        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, retParams );

                }	            

            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   

    return retParams; 

	}

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

// 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 ( iMinTolerance > 0 && 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 )

        {

        // Code change is not allowed, send the info back to the user

        aRetParams  = CSCPParamObject::NewL();        

        aRetParams->Set( KSCPParamStatus, KErrSCPCodeChangeNotAllowed );			        			        

        aRetParams->Set( KSCPParamAction, KSCPActionShowUI );

        aRetParams->Set( KSCPParamUIMode, KSCPUINote );

        aRetParams->Set( KSCPParamNoteIcon, KSCPUINoteError );

        HBufC16* resText = NULL;

        HBufC16* formatBuf = NULL;

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

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

        if ( iMinInterval > 1 )

            {

            if ( iMinTolerance >1 )

                {

                Dprint( (_L("CSCPTimestampPlugin::IsChangeAllowedL(): iMinInterval > 1,iMinTolerance >= 1") ));                      

                resText = LoadResourceL( R_SET_SEC_CODE_CHANGE_DAY );

                }

            else

                {

                Dprint( (_L("CSCPTimestampPlugin::IsChangeAllowedL(): iMinInterval > 1,iMinTolerance !>= 1") ));                      

                resText = LoadResourceL( R_SET_SEC_CODE_CHANGE_HOURS );

                }

            }

        else

            if ( iMinTolerance > 1 )

                {

                Dprint( (_L("CSCPTimestampPlugin::IsChangeAllowedL(): iMinInterval !> 1,iMinTolerance >= 1") ));                      

                resText = LoadResourceL( R_SET_SEC_CODE_CHANGE_TIMES );

                }

            else

                {

                Dprint( (_L("CSCPTimestampPlugin::IsChangeAllowedL(): iMinInterval !> 1,iMinTolerance !>= 1") ));                      

                resText = LoadResourceL( R_SET_SEC_CODE_CHANGE_ONES );

                }         

        CleanupStack::PushL( resText );

        formatBuf = HBufC::NewL( resText->Length() + KSCPMaxMinChangeValueLen );

		TPtr16 bufDes = formatBuf->Des();

        if ( iMinInterval > 1 )

            {

            if ( iMinTolerance > 1 )

                {

                bufDes.Format( resText->Des(), iMinTolerance , iMinInterval );

                }

            else

                {

                bufDes.Format( resText->Des(), iMinInterval );

                }

            }

        else

            if ( iMinTolerance > 1 )

                {

                bufDes.Format( resText->Des(), iMinTolerance  );

                }

            else

                {

                bufDes.Format( resText->Des() );

                }  		    	

        aRetParams->Set( KSCPParamPromptText, bufDes );

        delete formatBuf;

        CleanupStack::PopAndDestroy( resText );

        }

    // No need to write configuration changes            

    }

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

// CSCPTimestampPlugin::PasswordChanged()

// 

// 

// Status : Approved

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

//    

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

    {

    (void)aParam;

    (void)aRetParams;    

    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 && iMinTolerance > 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 ) );  

                }                       

            }        

		else {

			iConfiguration->Set( KSCPIntervalStartTime, 0 );

			iConfiguration->Set( KSCPUsedTolerance, 0 );

		}

        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 )

    {

    if ( ReadConfiguration() != KErrNone )

        {

        return;

        }

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

    // Check if immediate expiration is set

    TInt expireNow = 0;

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

    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 )

            {

		    Dprint( (_L("CSCPTimestampPlugin::iMaxAttempts > 0") )); 

            TInt failedCount = 0;

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

            failedCount++;                        

            if ( failedCount == iMaxAttempts - 1 )

                {

                // Warn the user. Only one attempt left. There's no use handling the error