/*

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

#include <e32svr.h>

#include <e32math.h>

#include <gsmerror.h>

#include "SCPServer.h"

#include "SCPSession.h"

#ifdef SCP_USE_POLICY_ENGINE

#include <PolicyEngineClient.h>

#include <PolicyEngineXACML.h>

#include <RequestContext.h>

#include "DMUtilObserver.h"

#include "SCPParamDBController.h"

#endif // SCP_USE_POLICY_ENGINE

//#ifdef __SAP_DEVICE_LOCK_ENHANCEMENTS

#include "SCPPluginManager.h"

#include "SCPPluginEventHandler.h"

#include <SCPParamObject.h>

#include "SCP_IDs.h"

// For Central Repository

#include <centralrepository.h>

#include "SCPCodePrivateCRKeys.h"

#include "SCPLockCode.h"

#include <TerminalControl3rdPartyAPI.h>

//#endif // __SAP_DEVICE_LOCK_ENHANCEMENTS

#include <mmtsy_names.h>

#include "SCPDebug.h"

#include <featmgr.h>

// For Device encryption

#include <DevEncEngineConstants.h>

#include <DevEncSessionBase.h>

#include <startupdomainpskeys.h>

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

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

// PanicServer Panics the server thread

// 

// Status : Approved

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

//

GLDEF_C void PanicServer(TSCPServPanic aPanic)

	{

	_LIT( KTxtServerPanic,"SCP Server panic" );

	User::Panic( KTxtServerPanic, aPanic );

	}

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

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

// CSession2* CSCPServer::CSCPServer()

// C++ default constructor

// 

// Status : Approved

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

//

CSCPServer::CSCPServer(TInt aPriority)

	: CPolicyServer( aPriority, CSCPServerPolicy ),

	  iConfiguration( &iRfs ),

	  iALPeriodRep( NULL ),

	  iShutdownTimer( NULL ),

	  iOverrideForCleanup(EFalse) {

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

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

	}

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

// CSession2* CSCPServer::ConstructL()

// Symbian 2nd phase constructor

// 

// Status : Approved

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

//

void CSCPServer::ConstructL()

    {

    Dprint(_L("[CSCPServer]-> ConstructL() >>>"));

    TRAPD( errf, FeatureManager::InitializeLibL() );

	if( errf != KErrNone )

	{

		User::Leave(errf);

	}

    StartL( KSCPServerName );

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

    iConfiguration.Initialize();

    // Assign default config flag

    iConfiguration.iConfigFlag = KSCPConfigUnknown;

    // Assign the default codes

    iConfiguration.iSecCode.Zero();

    iConfiguration.iSecCode.Append( KSCPDefaultSecCode );

    // Assign the default codes

    iConfiguration.iCryptoCode.Zero();

    iConfiguration.iCryptoCode.Append( KSCPDefaultSecCode );

//#ifdef __SAP_DEVICE_LOCK_ENHANCEMENTS 

if(FeatureManager::FeatureSupported(KFeatureIdSapDeviceLockEnhancements))

{

    // Reset code block parameters

    iConfiguration.iFailedAttempts = 0;

    iConfiguration.iBlockedAtTime = KSCPNotBlocked;

    iPluginEventHandler = CSCPPluginEventHandler::NewL( &iRfs );

    iPluginManager = CSCPPluginManager::NewL( this );           

    // Hash the default code

    TBuf<KSCPMaxHashLength> hashBuf;

    hashBuf.Zero();

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

    TPtr codeBuf = codeHBuf->Des();

    codeBuf.Zero();

    codeBuf.Copy( KSCPDefaultEnchSecCode );

    iPluginEventHandler->HashInput( codeBuf, hashBuf );

    iConfiguration.iEnhSecCode.Zero();

    iConfiguration.iEnhSecCode.Append( hashBuf );

    CleanupStack::PopAndDestroy( codeHBuf );

}

//#endif

    // Assign the default max timeout

   	iConfiguration.iBlockedInOOS = 0;

    // Read the configuration, overwriting the default values

    TInt ret = KErrNone;

    TRAPD( err, ret = iConfiguration.ReadSetupL() );

    if ( ( err != KErrNone ) || ( ret != KErrNone ) )

        {

        Dprint( (_L("CSCPServer::ConstructL(): ERROR reading the \

            configuration file: %d"), err ));        

        }         

    else

        {

        Dprint( (_L("CSCPServer::ConstructL(): Configration read OK") ));

        }

    Dprint( (_L("CSCPServer::ConstructL(): Connecting to CenRep") ));

    iALPeriodRep = CRepository::NewL( KCRUidSecuritySettings );        

    // Check for factory settings

    CheckIfRfsPerformedL();

    Dprint(_L("[CSCPServer]-> ConstructL() <<< "));

    }

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

// CSession2* CSCPServer::NewL()

// Static constructor.

// 

// Status : Approved

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

//

CSCPServer* CSCPServer::NewL()

    {

    Dprint( (_L("--> CSCPServer::NewL()") ));

    CSCPServer *pS = new (ELeave) CSCPServer( EPriority );    

    CleanupStack::PushL( pS );

    pS->ConstructL();

    CleanupStack::Pop( pS );

    Dprint( (_L("<-- CSCPServer::NewL()") ));

    return pS;

    }

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

// CSession2* CSCPServer::~CSCPServer ()

// Destructor

// 

// Status : Approved

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

//

CSCPServer::~CSCPServer()

	{

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

    TRAPD( err, iConfiguration.WriteSetupL() );

    if ( err != KErrNone )

        {

        Dprint( (_L("CSCPServer::~CSCPServer(): ERROR writing the \

            configuration file: %d"), err ));

        }

    delete iALPeriodRep;

    iALPeriodRep = NULL;

//#ifdef __SAP_DEVICE_LOCK_ENHANCEMENTS

if(FeatureManager::FeatureSupported(KFeatureIdSapDeviceLockEnhancements))

{

    delete iPluginManager;

    iPluginManager = NULL;

    delete iPluginEventHandler;

    iPluginEventHandler = NULL;

}

FeatureManager::UnInitializeLib();

//#endif // __SAP_DEVICE_LOCK_ENHANCEMENTS 

	if ( iPhone.SubSessionHandle() )

	    {    

	    iPhone.Close();

	    }

    if ( iTelServ.Handle() )

        {        

        iTelServ.Close();                        

        }

    if ( iRfs.Handle() )

        {

        iRfs.Close();

        }    

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

	}

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

// CSession2* CSCPServer::NewSessionL (const TVersion &aVersion, const RMessage2& aMsg )

// Checks the version and creates a new session if it matches the server version.

// 

// Status : Approved

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

//

CSession2* CSCPServer::NewSessionL (const TVersion &aVersion, 

                                    const RMessage2& aMsg ) const

	{

	Dprint( (_L("--> CSCPServer::NewSessionL()") ));

	(void)aMsg;

	// Check we're the right version

	TVersion v( KSCPServMajorVersionNumber, KSCPServMinorVersionNumber, 

	            KSCPServBuildVersionNumber );

	if ( !User::QueryVersionSupported(v, aVersion) ) 

	    User::Leave( KErrNotSupported );	

	Dprint( (_L("<-- CSCPServer::NewSessionL()") ));

	return CSCPSession::NewL( (CSCPServer&)( *this ) );

	}

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

// TInt CSCPServer::ThreadFunctionStage2()

// Constructs the active scheduler and the server object, and

// runs the server.

// 

// Status : Approved

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

//

TInt CSCPServer::ThreadFunctionStage2L()

    {

    Dprint( (_L("--> CSCPServer::ThreadFunctionStage2()") ));

    // Naming the server thread after the server helps to debug panics  

    User::LeaveIfError( User::RenameThread( KSCPServerName ) );

    // Construct the active scheduler

    CActiveScheduler* activeScheduler = new (ELeave) CActiveScheduler;

    CleanupStack::PushL(activeScheduler);

    // Install active scheduler

    // We don't need to check whether an active scheduler is already installed

    // as this is a new thread, so there won't be one

    CActiveScheduler::Install( activeScheduler );

    // Construct our server    

    CSCPServer* server = CSCPServer::NewL();

    CleanupStack::PushL( server );

    RProcess::Rendezvous(KErrNone);

    // Start handling requests

    Dprint( (_L("CSCPServer: Server started") ));

    CActiveScheduler::Start();

    CleanupStack::PopAndDestroy( server );

    CleanupStack::PopAndDestroy( activeScheduler );

    Dprint( (_L("<-- CSCPServer::ThreadFunctionStage2()") ));

    return KErrNone;

    }

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

// TInt CSCPServer::ThreadFunction( TAny* )

// First-stage server entry point, creates the cleanup stack,

// and calls the actual server worker function.

// 

// Status : Approved

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

//	

TInt CSCPServer::ThreadFunction(TAny* /*aNone*/)

    {	

    Dprint( (_L("--> CSCPServer::ThreadFunction()") ));

    __UHEAP_MARK;

    CTrapCleanup* cleanupStack = CTrapCleanup::New();

    if ( !cleanupStack )

	      {

        PanicServer( ECreateTrapCleanup );

        }	

    TRAPD( err, ThreadFunctionStage2L() );

    if ( err != KErrNone )

        {

        PanicServer( ESvrStartServer );

        }

    delete cleanupStack;

    cleanupStack = NULL;

    __UHEAP_MARKEND;

    Dprint( (_L("<-- CSCPServer::ThreadFunction()") ));

    return KErrNone;

    }

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

// void CSCPServer::GetEtelHandlesL()

// Opens the handles to the Etel API, if not open, and copies

// their addresses to the given pointers, if available.

// 

// Status : Approved

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

//

void CSCPServer::GetEtelHandlesL( RTelServer** aTelServ, RMobilePhone** aPhone )

    {

    if ( !iTelServ.Handle() )

        {

        // Connect to Etel

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

        Dprint( (_L("CSCPServer::GetEtelHandlesL(): TelServ connected OK") ));

        }

	if ( !iPhone.SubSessionHandle() )

	    {

        // Load the phone module

        TInt err = iTelServ.LoadPhoneModule( KMmTsyModuleName );

        if ( err != KErrAlreadyExists )

            {

            User::LeaveIfError( err );

            }	        

        Dprint( (_L("CSCPServer::GetEtelHandlesL(): LoadPhoneModule OK") ));

        // Open the multimode TSY

        User::LeaveIfError( iPhone.Open( iTelServ, KMmTsyPhoneName ) );

        Dprint( (_L("CSCPServer::GetEtelHandlesL(): MM-Phone connected OK") ));

	    }	    

	if ( aTelServ )

	    {

	    *aTelServ = &iTelServ;

	    }

	if ( aPhone )

	    {

	    *aPhone = &iPhone;

	    }            

    }

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

// TInt CSCPServer::GetCode( TDes& aCode )

// Writes the stored ISA code to aCode

// 

// Status : Approved

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

//	

TInt CSCPServer::GetCode( TDes& aCode )

    {

    Dprint( (_L("--> CSCPServer::GetCode()") ));

    aCode.Zero();

    aCode.Copy( iConfiguration.iSecCode );

    Dprint( (_L("<-- CSCPServer::GetCode()") ));   

    return KErrNone;

    }

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

// TInt CSCPServer::StoreCode( TDes& aCode )

// Sets the stored ISA code to aCode and saves it to flash

// 

// Status : Approved

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

//	

TInt CSCPServer::StoreCode( TDes& aCode )

    {

    Dprint( (_L("--> CSCPServer::StoreCode()") ));

    TInt ret = KErrNone;

    iConfiguration.iSecCode.Zero();

    iConfiguration.iSecCode.Copy( aCode );

    // Unset the invalid configuration flag

    iConfiguration.iConfigFlag = KSCPConfigOK;

    // The code has changed, write the new value instantly to flash

    TRAPD( err, iConfiguration.WriteSetupL() );

    if ( err != KErrNone )

        {

        Dprint( (_L("CSCPServer::~CSCPServer(): ERROR writing the configuration\

            file: %d"), err ));

        ret = err;

        }           

    Dprint( (_L("<-- CSCPServer::StoreCode(): %d"), ret ));

    return ret;

    }   

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

// CSCPServer::ChangeISACodeL()

// Initializes the TSY and calls the function to change 

// the ISA-side code. Automatically uses the old code stored

// on the server.

// 

// Status : Approved

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

//

void CSCPServer::ChangeISACodeL( RMobilePhone::TMobilePassword& aNewPassword )

    {

    Dprint( (_L("--> CSCPServer::ChangeISACodeL()") ));    

    RMobilePhone::TMobilePassword oldPassword;

    TInt ret;

    // Check the given code

    if ( !IsValidISACode( aNewPassword ) )

        {

        Dprint( (_L("CSCPServer::ChangeISACodeL(): ERROR:\

            Invalid code format") ));

        User::Leave( KErrArgument );

	    }           

    // No access to the ISA side in emulator      

    GetEtelHandlesL();

    // Fetch the stored ISA password from the server    

    ret = GetCode( oldPassword );

    if ( ret != KErrNone )

        {

        Dprint( (_L("CSCPServer::ChangeISACodeL(): ERROR:\

            Failed to get stored code") ));

        User::Leave( ret );

        }           

    TRequestStatus status = KErrNone;    

#ifndef __WINS__    

    // No access to the ISA side in emulator, for WINS the call always succeeds

    RMobilePhone::TMobilePhonePasswordChangeV1 changeInfo;

    changeInfo.iOldPassword = oldPassword;

    changeInfo.iNewPassword = aNewPassword;

    RMobilePhone::TMobilePhoneSecurityCode securityCode = 

        RMobilePhone::ESecurityCodePhonePassword;

	Dprint( (_L("CSCPServer::ChangeISACodeL(): Trying to change\

	    the code, values %s, %s"), oldPassword.PtrZ(), aNewPassword.PtrZ() ));

	iPhone.ChangeSecurityCode(status, securityCode, changeInfo );

	// This is a quick call, just wait here

	User::WaitForRequest( status );