/*

* Copyright (c) 2009 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

*

*/

/* TerminalControlClient.cpp

*/

#include <e32svr.h>

#include <TerminalControl3rdPartyAPI.h>

#include "TerminalControlClientServer.h"

#include "TerminalControlClient.h"

#include "debug.h"

// Standard server startup code

// 

static TInt StartServer()

	{

	RDEBUG("TerminalControlServer: Starting server...");

	const TUidType serverUid(KNullUid,KNullUid,KTerminalControlServerUid);

	// EPOC and EKA 2 is easy, we just create a new server process. Simultaneous

	// launching of two such processes should be detected when the second one

	// attempts to create the server object, failing with KErrAlreadyExists.

	RProcess server;

	//TInt r=server.Create(KHelloWorldServerImg,KNullDesC,serverUid);

	TInt r=server.Create(KTerminalControlServerImg,KNullDesC);

	if (r!=KErrNone)

		{

		RDEBUG_2("TerminalControlClient: server start failed %d",r);

		return r;

		}

	TRequestStatus stat;

	server.Rendezvous(stat);

	if (stat!=KRequestPending)

		server.Kill(0);		// abort startup

	else

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

	RDEBUG("TerminalControlClient: Started");

	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

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

	server.Close();

	return r;

	}

// This is the standard retry pattern for server connection

EXPORT_C TInt RTerminalControl::Connect()

	{

	TInt retry=2;

	for (;;)

		{

		TInt r=CreateSession(KTerminalControlServerName,TVersion(0,0,0),1);

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

			return r;

		if (--retry==0)

			return r;

		r=StartServer();

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

			return r;

		}

	}

EXPORT_C void RTerminalControl::Close()

	{

	RSessionBase::Close();  //basecall

	}

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

//

//  RTerminalControlSession subsessions

//

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

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

// RTerminalControlSession::Open

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

EXPORT_C TInt RTerminalControlSession::Open(RTerminalControl &aServer, TCertInfo &aCertification)

    {

    RDEBUG("RTerminalControlSession::Open");

    TIpcArgs args1;

    TPckg<TCertInfo> certp( aCertification );

    args1.Set(0, &certp);

	return CreateSubSession(aServer, ECreateSubSession, args1);

	}

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

// RTerminalControlSession::Close

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

EXPORT_C void RTerminalControlSession::Close()

	{

	RDEBUG("RTerminalControlSession::Close");

	RSubSessionBase::CloseSubSession(ECloseSubSession);

	}

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

// RTerminalControlSession::FileScanL

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

EXPORT_C TInt RTerminalControlSession::FileScan( const TDesC8& aStartPath /*= KTCDefaultStart*/,

                                                  TBool aRecursive /*= EFalse*/ ) 

	{

	RDEBUG("RTerminalControlSession::FileScan");

	TInt        status = KErrNone;

    TIpcArgs    args1;

    TInt        recursiveFlag = aRecursive?1:0;    

    // Set parameters

    args1.Set(0, recursiveFlag);

    args1.Set(1, &aStartPath);

    // Run file scan

	status = SendReceive( EFileScan, args1 );

    return status;

	}

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

// RTerminalControlSession::FileScanResultsL

// @param aBuffer Constructed CBufFlat to be filled with file scan results (will be resized)

// @discussion aBuffer should be pushed into cleanup stack if this method is not trapped

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

EXPORT_C TInt RTerminalControlSession::FileScanResultsL( CBufFlat* aBuffer )

    {

    RDEBUG("RTerminalControlSession::FileScanResultsL");

    User::LeaveIfError((aBuffer == NULL?KErrGeneral:KErrNone));

	TInt        status = KErrNone;

	TInt        size = 0;

	status = FileScanResultsSize(size);

	// Resize client buffer (or handle out of memory)

	aBuffer->ResizeL( size );

    //

    // If we get size, we can create object to transfer results

    //

	if ( status == KErrNone )

		{

		// We're using out own data buffer for data transfer from server

		HBufC8 *buf = HBufC8::NewLC( size );

        TPtr8 ptr(buf->Des());    	

        TIpcArgs args1;

        args1.Set(0, &ptr);

		status = SendReceive( EFileScanResults, args1 );

		if ( status == KErrNone )

			{			

            aBuffer->Write(0, ptr);

			}

		else

			{

			RDEBUG_2("TerminalControlServer: EFileScanResults failed... %d", status);

			}

		CleanupStack::PopAndDestroy( buf );

		}

	else

		{

		RDEBUG_2("TerminalControlServer: EFileScanResultsSize failed... %d", status);

		}

	return status;        

    }

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

// RTerminalControlSession::FileScanResultsSizeL

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

EXPORT_C TInt RTerminalControlSession::FileScanResultsSize( TInt &aSize )

    {

    RDEBUG("RTerminalControlSession::FileScanResultsSize");

	TInt        status = KErrNone;

	TInt        size = 0;

    TBuf8<MAX_NUMBER_OF_DIGITS_IN_10BASE_INT64> sizeBuf;

    TLex8       lex;

    //

    // Get size of file scan from the server

    //

    status = FileScanResultsSize(sizeBuf);

		if( status != KErrNone )

			{

			return status;	

			}

	lex.Assign(sizeBuf);

	status = lex.Val(size);

	aSize = size;

    return status;

    }

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

// RTerminalControlSession::FileScanResultsSize

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

EXPORT_C TInt RTerminalControlSession::FileScanResultsSize( TDes8 &aSizeBuf )

    {

    RDEBUG("RTerminalControlSession::FileScanResultsSize");

	TInt        status = KErrNone;

    TIpcArgs    args1;    

    //

    // Get size of file scan from the server

    //    

    args1.Set(0, &aSizeBuf);

    status = SendReceive( EFileScanResultsSize, args1 );

    return status;

    }

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

// RTerminalControlSession::DeleteFileL

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

EXPORT_C TInt RTerminalControlSession::DeleteFile( const TDesC8& aFileName )

    {

    RDEBUG("RTerminalControlSession::DeleteFile");

	TInt       status = KErrNone;

    TIpcArgs   args1;

    args1.Set(0, &aFileName);

    status = SendReceive( EFileDelete, args1 );

    return status;

    }

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

// RTerminalControlSession::SetAutolockPeriodL

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

EXPORT_C TInt RTerminalControlSession::SetAutolockPeriod( TInt32 aPeriod )

    {

    RDEBUG("RTerminalControlSession::SetAutolockPeriodL");

	TInt       status = KErrNone;

    TIpcArgs   args1;

    TInt       value( aPeriod );

    args1.Set(0, value);

    status = SendReceive( EDeviceLock_AutoLockPeriod_Set, args1 );

    return status;

    }

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

// RTerminalControlSession::GetAutolockPeriodL

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

EXPORT_C TInt RTerminalControlSession::GetAutolockPeriod( TInt32 &aPeriod )

    {    

    RDEBUG("RTerminalControlSession::GetAutolockPeriod");

	TInt       status = KErrNone;

    TIpcArgs   args1;

    TBuf8<MAX_NUMBER_OF_DIGITS_IN_10BASE_INT64> period;

    TLex8      lex;

    args1.Set(0, &period);

    status = SendReceive( EDeviceLock_AutoLockPeriod_Get, args1 );

    if(status == KErrNone)

        {

        lex.Assign( period );

        status = lex.Val( aPeriod );

        }

    return status;

    }

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

// RTerminalControlSession::SetMaxAutolockPeriodL

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

EXPORT_C TInt RTerminalControlSession::SetMaxAutolockPeriod( TInt32 aPeriod )

    {

    RDEBUG("RTerminalControlSession::SetMaxAutolockPeriod");

	TInt       status = KErrNone;

    TIpcArgs   args1;

    TInt       value( aPeriod );

    args1.Set(0, value);

    status = SendReceive( EDeviceLock_MaxAutoLockPeriod_Set, args1 );

    return status;

    }

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

// RTerminalControlSession::GetMaxAutolockPeriodL

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

EXPORT_C TInt RTerminalControlSession::GetMaxAutolockPeriod( TInt32 &aPeriod )

    {    

    RDEBUG("RTerminalControlSession::GetMaxAutolockPeriod");

	TInt       status = KErrNone;

    TIpcArgs   args1;

    TBuf8<MAX_NUMBER_OF_DIGITS_IN_10BASE_INT64> period; 

    TLex8 lex;

    args1.Set(0, &period);    

    status = SendReceive( EDeviceLock_MaxAutoLockPeriod_Get, args1 );

    if(status == KErrNone)

        {

        lex.Assign( period );

        status = lex.Val( aPeriod );

        }

    return status;

    }

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

// RTerminalControlSession::SetDeviceLockLevelL

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

EXPORT_C TInt RTerminalControlSession::SetDeviceLockLevel( TInt32 aLevel )

    {    

    RDEBUG("RTerminalControlSession::SetDeviceLockLevel");

	TInt       status = KErrNone;

    TIpcArgs   args1;

    TInt       value( aLevel );

    args1.Set(0, value);

    status = SendReceive( EDeviceLock_LockLevel_Set, args1 );

    return status;

    }

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

// RTerminalControlSession::GetDeviceLockLevelL

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

EXPORT_C TInt RTerminalControlSession::GetDeviceLockLevel( TInt32 &aLevel )

    {

    RDEBUG("RTerminalControlSession::GetDeviceLockLevel");

	TInt       status = KErrNone;

    TIpcArgs   args1;

    TBuf8<MAX_NUMBER_OF_DIGITS_IN_10BASE_INT64> level;

    TLex8 lex;

    args1.Set(0, &level);

    status = SendReceive( EDeviceLock_LockLevel_Get, args1 );

    if(status == KErrNone)

        {

        lex.Assign( level );

        status = lex.Val( aLevel );

        }

    return status;

    }

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

// RTerminalControlSession::SetDeviceLockCodeL

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

EXPORT_C TInt RTerminalControlSession::SetDeviceLockCode( const TDesC8 &aCode )

    {

    RDEBUG("RTerminalControlSession::SetDeviceLockCodeL");

	TInt       status = KErrNone;

    TIpcArgs   args1;

    args1.Set(0, &aCode);

    status = SendReceive( EDeviceLock_LockCode_Set, args1 );

    return status;

    }

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

// RTerminalControlSession::GetDeviceLockCodeL

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

EXPORT_C TInt RTerminalControlSession::GetDeviceLockCode( TDesC8 &/*aCode*/ )

    {

    RDEBUG("RTerminalControlSession::GetDeviceLockCode");

    return KErrNotSupported;

    }

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

// RTerminalControlSession::DeviceWipeL

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

EXPORT_C TInt RTerminalControlSession::DeviceWipe( )

    {

    RDEBUG("RTerminalControlSession::DeviceWipe");

    return SendReceive( EDeviceWipe );

    }

// --------- Enhanced features BEGIN ------------------

//#ifdef __SAP_DEVICE_LOCK_ENHANCEMENTS

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

// RTerminalControlSession::SetPasscodeMinLength

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

EXPORT_C TInt RTerminalControlSession::SetPasscodeMinLength( TInt32 aMinLength )

	{

	RDEBUG("RTerminalControlSession::SetPasscodeMinLength");

	TInt status = KErrNone;

    TIpcArgs args1;

    TInt value( aMinLength );

    args1.Set( 0, value );

    status = SendReceive( EDeviceLock_PasscodeMinLength_Set, args1 );

    return status;

	}

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

// RTerminalControlSession::GetPasscodeMinLength

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

EXPORT_C TInt RTerminalControlSession::GetPasscodeMinLength( TInt32& aMinLength )

	{

	RDEBUG("RTerminalControlSession::GetPasscodeMinLength");

	TInt status = KErrNone;

    TIpcArgs args1;

    TBuf8<MAX_NUMBER_OF_DIGITS_IN_10BASE_INT64> length;

    TLex8 lex;

    args1.Set( 0, &length );

    status = SendReceive( EDeviceLock_PasscodeMinLength_Get, args1 );

    if( status == KErrNone )

        {

        lex.Assign( length );

        status = lex.Val( aMinLength );

        }

    return status;

	}

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

// RTerminalControlSession::SetPasscodeMaxLength

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

EXPORT_C TInt RTerminalControlSession::SetPasscodeMaxLength( TInt32 aMinLength )

	{

	RDEBUG("RTerminalControlSession::SetPasscodeMaxLength");

	TInt status = KErrNone;

    TIpcArgs args1;

    TInt value( aMinLength );

    args1.Set( 0, value );

    status = SendReceive( EDeviceLock_PasscodeMaxLength_Set, args1 );

    return status;

	}

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

// RTerminalControlSession::GetPasscodeMaxLength

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

EXPORT_C TInt RTerminalControlSession::GetPasscodeMaxLength( TInt32& aMinLength )

	{

	RDEBUG("RTerminalControlSession::GetPasscodeMaxLength");

	TInt status = KErrNone;

    TIpcArgs args1;

    TBuf8<MAX_NUMBER_OF_DIGITS_IN_10BASE_INT64> length;

    TLex8 lex;

    args1.Set( 0, &length );

    status = SendReceive( EDeviceLock_PasscodeMaxLength_Get, args1 );

    if( status == KErrNone )

        {

        lex.Assign( length );

        status = lex.Val( aMinLength );

        }

    return status;

	}

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

// RTerminalControlSession::SetPasscodeRequireUpperAndLower

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

EXPORT_C TInt RTerminalControlSession::SetPasscodeRequireUpperAndLower( TBool aRequire )

	{

	RDEBUG("RTerminalControlSession::SetPasscodeRequireUpperAndLower");

	TInt status = KErrNone;

    TIpcArgs args1;

    TInt value( aRequire );

    args1.Set( 0, value );

    status = SendReceive( EDeviceLock_PasscodeRequireUpperAndLower_Set, args1 );

    return status;

	}