/*

* 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 "SCPHistoryPlugin.h"

#include "SCP_IDs.h"

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

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

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

// CSCPHistoryPlugin::NewL

// Two-phased contructor

// (static, may leave)

// Status : Approved

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

//

CSCPHistoryPlugin* CSCPHistoryPlugin::NewL()

    {

    Dprint ( ( _L( "CSCPHistoryPlugin::NewL()" ) ) );

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

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

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

    return self;

    }

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

// CSCPHistoryPlugin::CSCPHistoryPlugin

// Constructor

// Status : Approved

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

//

CSCPHistoryPlugin::CSCPHistoryPlugin()

    {

    Dprint ( ( _L( "CSCPHistoryPlugin::CSCPHistoryPlugin()" ) ) );

    return;

    }

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

// CSCPHistoryPlugin::ConstructL

// 2nd phase construction

// (may leave)

// Status : Approved

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

//

void CSCPHistoryPlugin::ConstructL()

    {        

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

    return;

    }

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

// CSCPHistoryPlugin::HandleEvent

// 

// 

// Status : Approved

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

//    

        {

                            break;

                        } // End of compare IF

                    } // End of For

                // kill the local

                array->Reset();

                delete array;

                } // passhistoryParamValue

            break;

            } // end of KSCPEventValidate

        // Someone has changed the Seccode and I need to include it to history

            if ( aParam.Get( KSCPParamPassword, securitycode ) != KErrNone )

                {

               	ERROR: KSCPEventPasswordChanged/KSCPParamPassword is  != KErrNone") ));

                    TRAPD( errWC, historyObject->WriteToFileL( iCfgFilenamepath, iFs ) );

						failed to write plugin configuration: %d"), errWC ));

            Dprint ( ( _L( "CSCPHistoryPlugin::KSCPEventConfigurationQuery" ) ) );

            // Get the ID from the paramObject      

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

                {

                // Nothing to do anymore

                break;

            // 1011

            if ( paramID == (RTerminalControl3rdPartySession::EPasscodeHistoryBuffer))

                {

                    }

    }

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

// CSCPHistoryPlugin::SetEventHandler

// SetEventHandler

// 

// Status : Approved

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

//    

void CSCPHistoryPlugin::SetEventHandler( MSCPPluginEventHandler* aHandler )

	{

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

	iEventHandler = aHandler;

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

	}	

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

// CSCPHistoryPlugin::~CSCPHistoryPlugin

// Destructor

// Status : Approved

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

//

CSCPHistoryPlugin::~CSCPHistoryPlugin()

    {

	Dprint( (_L("CSCPHistoryPlugin::~CSCPHistoryPlugin()") ));

	iRf.Close();   

	return;

    }

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

// CSCPHistoryPlugin::GetHistoryItemCount

// GetHistoryItemCount

// Status : Approved

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

//

TInt CSCPHistoryPlugin::GetHistoryItemCount( TInt& aHistoryCount )

    {

    Dprint ( ( _L( "CSCPHistoryPlugin::GetHistoryItemCount()" ) ) );

    // Make the ParamObject for success ack, 

    CSCPParamObject* historyObject = NULL;

    TRAPD( err, historyObject = CSCPParamObject::NewL() );

    if ( err != KErrNone )

        {

        return err;

        }

    TRAP( err, historyObject->ReadFromFileL( iCfgFilenamepath, iFs ) );

    if (  err != KErrNone  )

        {

    	// Something is wrong with the config file

    	// it is missing, caller will create new file

    	Dprint( (_L("CSCPHistoryPlugin::SetConfigFile:\

    	ERROR: Failed to ReadFromFileL: %d"), err ));

        }

    else

        {

    	historyObject->Get(KHistoryCounterParamID,aHistoryCount);

        }

	Dprint ( ( _L( "CSCPHistoryPlugin::GetHistoryItemCount aHistoryCount = %d" ), aHistoryCount ) );

    delete historyObject;

	return err;

    }

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

// CSCPHistoryPlugin::SetConfigFile

// SetConfigFile

// Status : Approved

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

//

TInt CSCPHistoryPlugin::SetConfigFile()

    {	

    Dprint ( ( _L( "CSCPHistoryPlugin::SetConfigFile()" ) ) );

	TRAPD( err, iEventHandler->GetStoragePathL( iCfgFilenamepath ) );

	if ( err != KErrNone )

	    {

		Dprint( (_L("CSCPHistoryPlugin::SetConfigFile:\

		ERROR: Failed to get storage path: %d"), err ));             

		return err;

	    }

	iCfgFilenamepath.Append( KConfigFile );

	return err;

    }

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

// CSCPHistoryPlugin::AppendSecurityCode

// AppendSecurityCode

// Status : Approved

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

//

TInt CSCPHistoryPlugin::AppendAndWriteSecurityCodeL ( TDes& aSecuritycode )

    {

    Dprint ( ( _L( "CSCPHistoryPlugin::AppendAndWriteSecurityCodeL()" ) ) );

	TInt err;

	err = KErrNone;

	TInt passhistoryParamValue;

	passhistoryParamValue = GetHistoryCountParamValue();

	Dprint ( ( _L( "CSCPHistoryPlugin::AppendAndWriteSecurityCodeL passhistoryParamValue = %d" ), passhistoryParamValue ) );

	if ( passhistoryParamValue == 0 )

	    {

	    // We must still save the currect password..

	    passhistoryParamValue = 1;

	    }

	// Make the ParamObject

	CSCPParamObject* historyObject = CSCPParamObject::NewL();

	CleanupStack::PushL( historyObject );

	// get history

	CDesCArrayFlat*  array = new (ELeave) CDesCArrayFlat(1);

	CleanupStack::PushL( array );

	err = GetHistoryArrayL( *array );

	// If for some reason err is raised, break out

	if (err != KErrNone)

	    {

		array->Reset();

		CleanupStack::PopAndDestroy( array );

		CleanupStack::PopAndDestroy( historyObject );

		return err;

	    }

	TBuf<KSCPPasscodeMaxLength> arrayItem;

  	// append the new pass to history to last index.  	

	array->AppendL( aSecuritycode );

	TInt correction;

	correction = 0;

	if ( array->Count() >=  passhistoryParamValue )

        {

        correction =  array->Count() - passhistoryParamValue;

        }    

  	// Set the historyobject

	for ( TInt i = 0 + correction; i <  array->Count(); i++ )

		{

        arrayItem =  array->MdcaPoint(i);

        historyObject->Set( KHistoryItemParamBase + i - correction, arrayItem );

        arrayItem.Zero();

		}

	// Set the historycount

	historyObject->Set(KHistoryCounterParamID, array->Count() - correction );

	// Write

	TRAP( err, historyObject->WriteToFileL( iCfgFilenamepath, iFs ) );

	if (  err != KErrNone  )

	    {

		Dprint( (_L("CSCPHistoryPlugin::AppendSecurityCode(): WARNING:\

		failed to write plugin configuration: %d"), err )); 

	    }

	// Kill the local array

	array->Reset();

	CleanupStack::PopAndDestroy( array );

	CleanupStack::PopAndDestroy( historyObject );

	return err;	

    }

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

// CSCPHistoryPlugin::GetHistoryArray

// Reads the historyconfig file and retrieves the history data

// Status : Approved

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

//

TInt CSCPHistoryPlugin::GetHistoryArrayL ( CDesCArrayFlat& array )

    {   

	Dprint( (_L("CSCPHistoryPlugin::GetHistoryArray()") ));

    TBuf<KSCPPasscodeMaxLength> arrayItem;

    TInt historyCount;

	// Make the ParamObject

	CSCPParamObject* historyObject = CSCPParamObject::NewL();

	CleanupStack::PushL( historyObject );

	TRAPD( err, historyObject->ReadFromFileL( iCfgFilenamepath, iFs ) );