/*

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

#include <e32math.h>

#include <SCPParamObject.h>

#include <hash.h>

#include "SCPServer.h"

#include "SCPPluginEventHandler.h"

#include "SCP_IDs.h"

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

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

// void CSCPPluginEventHandler::CSCPPluginEventHandler()

// C++ default constructor

// 

// Status : Approved

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

//

CSCPPluginEventHandler::CSCPPluginEventHandler( RFs* aRfs ):

    iPluginConfiguration( NULL ),

    iRfs( aRfs )

	{

	Dprint( (_L("--> CSCPPluginEventHandler::CSCPPluginEventHandler()") ));

    // No implementation required    

	Dprint( (_L("<-- CSCPPluginEventHandler::CSCPPluginEventHandler()") ));

	}

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

// void CSCPPluginEventHandler::NewL()

// Static constructor

// 

// Status : Approved

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

//

CSCPPluginEventHandler* CSCPPluginEventHandler::NewL( RFs* aRfs )

	{

	CSCPPluginEventHandler* self = CSCPPluginEventHandler::NewLC( aRfs );

	CleanupStack::Pop( self ); 

	return self;	

	}

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

// void CSCPPluginEventHandler::NewLC()

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

// 

// Status : Approved

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

//

CSCPPluginEventHandler* CSCPPluginEventHandler::NewLC( RFs* aRfs )

	{

	CSCPPluginEventHandler* self = new (ELeave) CSCPPluginEventHandler( aRfs );

    CleanupStack::PushL( self );

    self->ConstructL();	

    return self;	

    }

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

// void CSCPPluginEventHandler::ConstructL()

// Symbian 2nd phase constructor

// 

// Status : Approved

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

//

void CSCPPluginEventHandler::ConstructL()

    {    

    // Read the configuration path            

    iConfigurationPath.Zero();

    User::LeaveIfError( iRfs->PrivatePath( iConfigurationPath ) );

    // Fetch the configuration for the plugins from disk

    iPluginConfiguration = CSCPParamObject::NewL();

    // Build the configuration file name

    TFileName cfgFileName = iConfigurationPath;                    

    cfgFileName.Append( KSCPPluginConfigFilename );

    TRAPD( err, iPluginConfiguration->ReadFromFileL( cfgFileName, iRfs ) );

    if ( ( err != KErrNotFound ) && ( err != KErrNone ) )

        {

        Dprint( (_L("CSCPPluginEventHandler::ConstructL(): WARNING:\

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

        }            

    }

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

// void CSCPPluginEventHandler::GetParameters()

// Return the stored object pointer.

// 

// Status : Approved

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

//

CSCPParamObject& CSCPPluginEventHandler::GetParameters()

    {

    return *iPluginConfiguration;

    }

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

// void CSCPPluginEventHandler::GetRfsSession()

// Return the stored RFs reference

// 

// Status : Approved

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

//

RFs& CSCPPluginEventHandler::GetFsSession()

    {

    return *iRfs;  

    }

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

// void CSCPPluginEventHandler::WritePluginConfigurationL()

// Get the param buffer from the object and write it to disk

// 

// Status : Approved

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

//

TInt CSCPPluginEventHandler::WritePluginConfigurationL()

    {   

    // Build the configuration file name

    TFileName cfgFileName;

    TInt ret = GetStoragePathL( cfgFileName );

    if ( ret != KErrNone )

        {

        Dprint( (_L("CSCPPluginEventHandler::WritePluginConfigurationL():\

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

        User::Leave( ret );

        }

    cfgFileName.Append( KSCPPluginConfigFilename );   

    TRAP( ret, iPluginConfiguration->WriteToFileL( cfgFileName, iRfs ) );

    return ret;

    }

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

// void CSCPPluginEventHandler::GetStoragePath()

// Retrieve the private path and fill it in aPath

// 

// Status : Approved

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

//

TInt CSCPPluginEventHandler::GetStoragePathL( TDes& aPath )

    {    

    aPath.Copy( iConfigurationPath );

    return KErrNone;

    }    

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

// CSCPPluginEventHandler::HashInput()

// Use the symbian Crypto API to hash the input buffer.

// 

// Status : Approved

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

//

TInt CSCPPluginEventHandler::HashInput( TDes& aInput, TDes& aOutput )

    {

    TInt ret = KErrNone;

    CMD5* hashObject = NULL;

    TRAP( ret, hashObject = CMD5::NewL() );    

#ifdef UNICODE

    TUint16* inputPtr = const_cast<TUint16*>( aInput.Ptr() ); 

    TPtrC8 inputData( reinterpret_cast<TUint8*>(inputPtr), aInput.Length()*2 );

#else // !UNICODE

    TPtrC8 inputData = aInput;

#endif

    if ( hashObject != NULL )

        {

        TPtrC8 hash = hashObject->Final( inputData );

        aOutput.Copy( hash );

        delete hashObject;

        }

    return ret;

    }

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

// CSCPPluginEventHandler::ResetConfigurationL()

// Reset the common parameter storage by resetting the ParamObject.

// 

// Status : Approved

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

//

void CSCPPluginEventHandler::ResetConfigurationL()

    {

    iPluginConfiguration->Reset();

    WritePluginConfigurationL();

    }

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

// void CSCPPluginEventHandler::~CSCPPluginEventHandler()

// Destructor

// 

// Status : Approved

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

//

CSCPPluginEventHandler::~CSCPPluginEventHandler()

	{

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

	TRAPD( err, WritePluginConfigurationL() );

    if ( err != KErrNone )

        {

        Dprint( (_L("CSCPPluginEventHandler::~CSCPPluginEventHandler():\

            WARNING: Failed to store plugin configuration: %d"), err ));        

        }	

	delete iPluginConfiguration;  

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

	}

//  End of File