/*

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

#include <e32math.h>

#include <e32uid.h>

#include "SCPClient.h"

#include "SCPParamObject.h"

#include "SCP_IDs.h"

#include <centralrepository.h>

#include "SCPLockCode.h"

//#ifdef __SAP_DEVICE_LOCK_ENHANCEMENTS

#include <TerminalControl3rdPartyAPI.h>

#include <SCPServerInterface.h>

#include <secui.hrh>

//#endif // DEVICE_LOCK_ENHANCEMENTS

#include <featmgr.h>

#include "SCPDebug.h"

#include <e32property.h>

/*#ifdef _DEBUG

#define __SCP_DEBUG

#endif // _DEBUG

// Define this so the precompiler in CW 3.1 won't complain about token pasting,

// the warnings are not valid

#pragma warn_illtokenpasting off

#ifdef __SCP_DEBUG

#define Dprint(a) RDebug::Print##a

#else

#define Dprint(a)

#endif // _DEBUG*/

static const TUint KDefaultMessageSlots = 3;

static const TInt KSCPConnectRetries( 2 );

// Uid for the application; this should match the mmp file

const TUid KServerUid3 = {0x10207836};

#ifdef __WINS__

static const TUint KServerMinHeapSize =  0x1000;  //  4K

static const TUint KServerMaxHeapSize = 0x10000;  // 64K

#endif

static TInt StartServer();

static TInt CreateServerProcess();

// LOCAL FUNCTION PROTOTYPES

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

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

// StartServer() Server starter check

// Determines if the server is running, if not, calls the starter function

// Returns: TInt: Operation status, a standard error code

//

// Status : Approved

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

//

static TInt StartServer()

    {

    Dprint( (_L("--> SCPClient::StartServer()") ));        

    TInt result;

    TFindServer findSCPServer( KSCPServerName );

    TFullName name;

    result = findSCPServer.Next( name );

    if ( result != KErrNone )

        {

        // The server is not running, try to create the server process

        result = CreateServerProcess();

        } 

    Dprint( (_L("<-- SCPClient::StartServer(): Exit code: %d"), result ));

    return result;

    }

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

// CreateServerProcess() Server starter function

// Starts the SCP server

// Returns: TInt: Operation status, a standard error code

//

// Status : Approved

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

//

static TInt CreateServerProcess()

    {

    Dprint( (_L("--> SCPClient::CreateServerProcess()") ));

    TInt result;

    const TUidType serverUid( KNullUid, KNullUid, KServerUid3 );

    RProcess server;

    _LIT( KEmpty, "");   

    result = server.Create( KSCPServerFileName, KEmpty );

    if ( result != KErrNone )

        {

        Dprint( (_L("<-- SCPClient::CreateServerProcess(), process creation error!") ));

        return result;

        }

    TRequestStatus stat;

    server.Rendezvous(stat);

    if ( stat != KRequestPending )

        {

        server.Kill(0);    // abort startup

        }    

    else

        {

        server.Resume(); // logon OK - start the server

        }

    User::WaitForRequest(stat); // wait for start or death

    // we can't use the 'exit reason' if the server panicked as this

    // is the panic 'reason' and may be '0' which cannot be distinguished

    // from KErrNone

    result = ( server.ExitType() == EExitPanic ) ? KErrGeneral : stat.Int();

    server.Close();

    Dprint( (_L("<-- SCPClient::CreateServerProcess(): %d"), result ));

    return result;

    }

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

// C++ default constructor can NOT contain any code, that

// might leave.

//

EXPORT_C RSCPClient::RSCPClient()

:   RSessionBase()

    {

    // No implementation required

    }

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

// TInt RSCPClient::Connect()

// Creates a new session, and starts the server, if required.

// 

// Status : Approved

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

//

EXPORT_C TInt RSCPClient::Connect()

    {

    Dprint( (_L("--> RSCPClient::Connect()") ));

    // Use a mutex-object so that two processes cannot start the server at the same time

    RMutex startMutex;

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

	if( errf != KErrNone )

		{

		return errf;

		}

		if(FeatureManager::FeatureSupported(KFeatureIdSapDeviceLockEnhancements))

		{

			isFlagEnabled = ETrue;

		}

		else

		{

			isFlagEnabled = EFalse;

		}

		FeatureManager::UnInitializeLib();

    TInt mRet = startMutex.OpenGlobal( KSCPServerName );

    if ( mRet == KErrNotFound )

        {

        mRet = startMutex.CreateGlobal( KSCPServerName );

        }

    if ( mRet != KErrNone )

        {        

        return mRet;

        }

    // Acquire the mutex

    startMutex.Wait();

    TInt retry = KSCPConnectRetries;

    TInt r;

    for (;;)

        {        

        r = CreateSession( KSCPServerName, Version(), KDefaultMessageSlots );

        if ( ( r != KErrNotFound ) && ( r != KErrServerTerminated  ) )

            {

            break;

            }

        if ( --retry == 0 )

            {

            break;

            }

        r = StartServer();

        if ( ( r != KErrNone ) && ( r != KErrAlreadyExists ) )

            {

            break;   

            }

        }

    Dprint( (_L("<-- RSCPClient::Connect(), exiting: %d"), r ));

    // Release the mutex

    startMutex.Signal();

    startMutex.Close();

    return r;

    }

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

// TVersion RSCPClient::Version()

// Constructs a TVersion object containing the defined version

// numbers, and returns it

// 

// Status : Approved

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

//

EXPORT_C TVersion RSCPClient::Version() const

    {

    Dprint( (_L("<--> RSCPClient::Version()") ));

    return( TVersion( KSCPServMajorVersionNumber,

                      KSCPServMinorVersionNumber,

                      KSCPServBuildVersionNumber ) );

    }

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

// TInt RSCPClient::GetCode( TSCPSecCode& aCode )

// Requests the stored ISA code.

// 

// Status : Approved

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

//

EXPORT_C TInt RSCPClient::GetCode( TSCPSecCode& aCode )

    {

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

    TInt ret = SendReceive(ESCPServGetCode, TIpcArgs( &aCode ) );

    Dprint( (_L("<-- RSCPClient::GetCode(): %d"), ret ));

    return ret;

    }

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

// TInt RSCPClient::StoreCode( TSCPSecCode& aCode )

// Propagates the store code -request to the server along

// with the buffer parameter.

// 

// Status : Approved

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

//

EXPORT_C TInt RSCPClient::StoreCode( TSCPSecCode& aCode )

    {

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

    TInt ret = SendReceive(ESCPServSetCode, TIpcArgs( &aCode ) );

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

    return ret;

    }   

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

// TInt RSCPClient::ChangeCode( TDes& aNewCode )

// Propagates the change code -request to the server, along with

// the code parameter.

// 

// Status : Approved

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

//

EXPORT_C TInt RSCPClient::ChangeCode( TDes& aNewCode )

    {

    Dprint( (_L("--> RSCPClient::ChangeCode()") ));

    TInt ret = SendReceive(ESCPServChangeCode, TIpcArgs( &aNewCode ) );

    Dprint( (_L("<-- RSCPClient::ChangeCode(): %d"), ret ));  

    return ret;

    }   

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

// TInt RSCPClient::SetPhoneLock()

// Propagates the lock/unlock phone -request to the server

// 

// Status : Approved

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

//

EXPORT_C TInt RSCPClient::SetPhoneLock( TBool aLocked )

    {

    Dprint( (_L("--> RSCPClient::SetPhoneLock( %d)"), aLocked ));

    TInt ret = SendReceive(ESCPServSetPhoneLock, TIpcArgs( aLocked ) );

    Dprint( (_L("<-- RSCPClient::SetPhoneLock(): %d"), ret ));

    return ret;

    }   

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

// TBool RSCPClient::QueryAdminCmd( TSCPAdminCommand aCommand )

// Packs the command parameter into a buffer, and propagates

// the call to the server, the response is received in the

// same buffer.

// 

// Status : Approved

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

//

EXPORT_C TBool RSCPClient::QueryAdminCmd( TSCPAdminCommand aCommand )

    {

    Dprint( (_L("--> RSCPClient::QueryAdminCmd()") ));

    TInt status = 0;

    TPckg<TInt> retPackage(status);

    TInt ret = SendReceive( ESCPServQueryAdminCmd, TIpcArgs( aCommand, &retPackage ) );

    Dprint( (_L("<-- RSCPClient::QueryAdminCmd(): %d"), retPackage() ));

    return static_cast<TBool>( status );

    }   

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

// TInt RSCPClient::GetLockState( TBool& aState )

// Package the parameter, and send it to the server.

// 

// Status : Approved

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

//

EXPORT_C TInt RSCPClient::GetLockState( TBool& aState )

    {

    Dprint( (_L("--> RSCPClient::GetLockState()") )); 

    TPckg<TBool> retPackage(aState);

    TInt ret = SendReceive( ESCPServGetLockState, TIpcArgs( &retPackage ) );

    Dprint( (_L("<-- RSCPClient::GetLockState(): %d"), retPackage() ));

    return ret;            

    }

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

// TInt RSCPClient::GetParamValue( TInt aParamID, TDes& aValue )

// The server contains all the logic for the parameters, just 

// propagate the call.

// 

// Status : Approved

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

//

EXPORT_C TInt RSCPClient::GetParamValue( TInt aParamID, TDes& aValue )

    {

    Dprint( (_L("--> RSCPClient::GetParamValue()") ));  

    TInt ret = SendReceive( ESCPServGetParam, TIpcArgs( aParamID, &aValue ) );

    Dprint( (_L("<-- RSCPClient::GetParamValue(): %d"), ret));

    return ret;            

    }

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

// TInt RSCPClient::SetParamValue( TInt aParamID, TDes& aValue )

// The server contains all the logic for the parameters, just 

// propagate the call.

// 

// Status : Approved

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

//

EXPORT_C TInt RSCPClient::SetParamValue( TInt aParamID, TDes& aValue )

    {

    Dprint( (_L("--> RSCPClient::SetParamValue()") ));  

    TInt ret = SendReceive( ESCPServSetParam, TIpcArgs( aParamID, &aValue ) );

    Dprint( (_L("<-- RSCPClient::SetParamValue(): %d"), ret ));

    return ret;            

    }    

// *********** Device lock new features ************* -->>

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

// RSCPClient::CheckConfiguration()

// Ask the server if the configuration is OK

// 

// Status : Approved

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

//

EXPORT_C TInt RSCPClient::CheckConfiguration( TInt aMode )

    {

    Dprint( (_L("--> RSCPClient::CheckConfiguration()") ));

    TInt status = 0;

    TPckg<TInt> retPackage(status);    

    TInt ret = SendReceive(ESCPServCheckConfig, TIpcArgs( aMode, &retPackage ) );

    if ( ret == KErrNone )

        {

        ret = status;

        if ( status == KErrNone )

            {

            Dprint( (_L("RSCPClient::CheckConfiguration(): Configuration OK") ));

            }

        else if ( status == KErrAccessDenied )

            {

            if ( aMode == KSCPInitial )

                {

                Dprint( (_L("RSCPClient::CheckConfiguration(): Initial check failed") ));

                }

            else

                {

                Dprint( (_L("RSCPClient::CheckConfiguration(): WARNING:\

                   Configuration Out of sync") ));

                }            

            }

        }                

    Dprint( (_L("<-- RSCPClient::CheckConfiguration(): %d"), status ));

    return ret;

    }

EXPORT_C TInt RSCPClient :: PerformCleanupL(RArray<TUid>& aAppIDs) {

    TInt lCount = aAppIDs.Count();

    if(lCount < 1) {

        return KErrNone; 

    }

    HBufC8* lBuff = HBufC8 :: NewLC(lCount * sizeof(TInt32));

    TPtr8 lBufPtr = lBuff->Des();

    RDesWriteStream lWriteStream(lBufPtr);

    CleanupClosePushL(lWriteStream);

    for(TInt i=0; i < lCount; i++) {

        Dprint((_L("[RSCPClient]-> Marking %d for cleanup"), aAppIDs[i].iUid ));

        lWriteStream.WriteInt32L(aAppIDs[i].iUid);

    }

    lWriteStream.CommitL();

    TInt lStatus = SendReceive(ESCPApplicationUninstalled, TIpcArgs(ESCPApplicationUninstalled, &lBuff->Des()));

    CleanupStack :: PopAndDestroy(2); // lBuff, lWriteStream

    return lStatus;

}

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

// The server contains all the logic for the parameters, just

// propagate the call.

//

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

//

EXPORT_C TInt RSCPClient :: SetParamValue(TInt aParamID, TDes& aValue, TUint32 aCallerSID) {

    Dprint((_L("RSCPClient::SetParamValue() >>>")));

    TPckgBuf<TUint32> lCallerID(aCallerSID);

    TInt ret = SendReceive(ESCPServSetParam, TIpcArgs(aParamID, &aValue, &lCallerID));

    Dprint((_L("RSCPClient::SetParamValue(): %d <<<"), ret));

    return ret;

}

EXPORT_C TInt RSCPClient::GetPolicies(RArray<TInt>& aDeviceLockPolicies) {

    Dprint(_L("[RSCPClient]-> GetPolicies >>>"));

    HBufC8* lBuff = NULL;

    TInt lStatus = KErrNone;

    TRAP(lStatus, lBuff = HBufC8 :: NewL((EDevicelockTotalPolicies - 1)  * sizeof(TInt)));

    if (lStatus == KErrNone) {

        lStatus = SendReceive(ESCPServGetParam, TIpcArgs(-1, &lBuff->Des()));

        if (lStatus == KErrNone) {

            // Copy data from lBuff to aDeviceLockPolicies

            TPtr8 bufPtr = lBuff->Des();

            if (bufPtr.Length() > 0) {

                RDesReadStream lBufReadStream(bufPtr);

                Dprint(_L("[RSCPClient]-> Get from server complete, returning service request..."));

                for (TInt i = 0; i < 17; i++) {

                    TInt32 lParamValue = 0;

                    TRAP(lStatus, lParamValue = lBufReadStream.ReadInt32L());

                    if (lStatus != KErrNone) {

                        break;

                    }

                    aDeviceLockPolicies.Append(lParamValue);

                }

                lBufReadStream.Close();