/*

* 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

*

*/

#define __INCLUDE_CAPABILITY_NAMES__

#include "TerminalControlServer.h"

// symbian

#include <e32svr.h>

#include <f32file.h>

#include <apgtask.h>

#include <apgcli.h>

#include <e32property.h>

#include <apacmdln.h>

#include <hal.h>

#include <utf.h>

// s60

#include <PSVariables.h>

#include <rfsClient.h>

#include <starterclient.h>

#include <syslangutil.h>

// tarm

#include "TerminalControlSession.h"

#include "TPtrC8I.h"

#include "TerminalControl3rdPartyAPI.h"

#include "DMUtilClient.h"

#include "debug.h"

/*

    Implementation notes:

    - CTerminalControlServer creates a CTerminalControlSession for each connection

    - CTerminalControlSession creates subsessions that have separate privileges

    - Privileges are stored in CTcTrustedSession objects (maintained by CTerminalControlSession)

    - Privileges are given by server (according to client Secure ID and received SSL certificate)

    - Server cannot be used without a subsession, client is paniced if first message is not ECreateSubSession    

*/

/******************************************************************************************

    Security policies of Terminal Control are defined here:   

*/

/**

    Ranges of policies

*/

const TInt CTerminalControlServer::iTcRanges[TC_NUMBER_OF_POLICIES] = {0, EFileScan, E3rdPartySetterGet};

/**

    Number of elements

*/

const TUint8 CTerminalControlServer::iTcElementsIndex[TC_NUMBER_OF_POLICIES] = {0, 1, 2};

/**

    Elements for each range

*/    

const CPolicyServer::TPolicyElement CTerminalControlServer::iTcElements[TC_NUMBER_OF_POLICIES] =

	    {

	    {_INIT_SECURITY_POLICY_PASS},

	    {_INIT_SECURITY_POLICY_C2(ECapabilityPowerMgmt, ECapabilityDiskAdmin)},

	    {_INIT_SECURITY_POLICY_PASS}

	    };

/**

    The policy

*/

const CPolicyServer::TPolicy CTerminalControlServer::iTcConnectionPolicy =

    {

        CPolicyServer::EAlwaysPass,

        TC_NUMBER_OF_POLICIES,

        iTcRanges,

        iTcElementsIndex,

        iTcElements

    };

/*****************************************************************************************/

_LIT8(KFormatProcessNamePrefix, "Process");

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

// Server startup code

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

static void RunServerL()

	{

	RDEBUG("TerminalControlServer.cpp RunServerL");

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

	//User::LeaveIfError(RThread().Rename(KTerminalControlServerName));   //Deprecated! Replace this with the line below as soon as possible

	User::LeaveIfError(User::RenameThread(KTerminalControlServerName)); //Correct PlatSec function, not available until week 2004_32

	// create and install the active scheduler

	CActiveScheduler* s=new(ELeave) CActiveScheduler;

	CleanupStack::PushL(s);

	CActiveScheduler::Install(s);

	// create the server (leave it on the cleanup stack)

	CTerminalControlServer::NewLC();

	// Initialisation complete, now signal the client

	RProcess::Rendezvous(KErrNone);

	// Ready to run

	RDEBUG("Policy engine server is running");

	CActiveScheduler::Start();

	// Cleanup the server and scheduler

	CleanupStack::PopAndDestroy(2);

	}

// Server process entry-point

TInt E32Main()

	{

	__UHEAP_MARK;

	RDEBUG("TerminalControlServer.cpp: E32Main");

	CTrapCleanup* cleanup=CTrapCleanup::New();

	TInt r=KErrNoMemory;

	if (cleanup)

		{

		TRAP(r,RunServerL());

		delete cleanup;

		}

	__UHEAP_MARKEND;

	return r;

	}

// RMessagePtr2::Panic() also completes the message. This is:

// (a) important for efficient cleanup within the kernel

// (b) a problem if the message is completed a second time

void PanicClient(const RMessagePtr2& aMessage,TTerminalControlPanic aPanic)

	{

	RDEBUG("TerminalControlServer.cpp PanicClient");

	_LIT(KPanic,"TerminalControlServer");

	aMessage.Panic(KPanic,aPanic);

	}

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

// CTerminalControlServer

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

CTerminalControlServer::CTerminalControlServer()

	: CPolicyServer(

	    EPriorityStandard, // Active object priority

        iTcConnectionPolicy,

	    ESharableSessions)

    , iProcessInfoArray(0)

	{

	RDEBUG("CTerminalControlServer::CTerminalControlServer");

	}

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

// CTerminalControlServer::NewLC

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

CServer2* CTerminalControlServer::NewLC()

	{    

	RDEBUG("CTerminalControlServer::NewLC");

	CTerminalControlServer* self=new(ELeave) CTerminalControlServer;

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

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

// CTerminalControlServer::~CTerminalControlServer

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

CTerminalControlServer::~CTerminalControlServer()

{

	RDEBUG("CTerminalControlServer::~CTerminalControlServer");

	if (iSCPClient.Handle())

	iSCPClient.Close();

	if (iContainerIndex)

	    {

	    delete iContainerIndex;

	    iContainerIndex = NULL;

	    }

	if (iProcessInfoArray)

	    {

	    iProcessInfoArray->Reset();

	    delete iProcessInfoArray;

	    iProcessInfoArray = NULL;

	    }

}

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

// CTerminalControlServer::ConstructL

// 2nd phase construction - ensure the timer and server objects are running

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

void CTerminalControlServer::ConstructL()

	{

	RDEBUG("CTerminalControlServer::ConstructL");

	StartL(KTerminalControlServerName);	

	iContainerIndex = CObjectConIx::NewL();

	iProcessInfoArray = new (ELeave) CArrayFix<TTcProcessInfo>((TBufRep)CBufFlat::NewL, 10);

	RDEBUG_2("CTerminalControlServer::iProcessInfoArray ALLOC %x", (TAny*)iProcessInfoArray);

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

	}

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

// CTerminalControlServer::NewSessionL

// Create a new client session. This should really check the version number.

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

CSession2* CTerminalControlServer::NewSessionL(const TVersion& aVersion,const RMessage2&) const

	{

	RDEBUG("CTerminalControlServer::NewSessionL");

	// check we're the right version

	TVersion v(KTerminalControlServerMajorVersionNumber,

	           KTerminalControlServerMinorVersionNumber,

	           KTerminalControlServerBuildVersionNumber);

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

		{

		User::Leave(KErrNotSupported);

		}

	return new (ELeave) CTerminalControlSession();

	}

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

// CTerminalControlServer::AddSession

// A new session is being created

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

void CTerminalControlServer::AddSession()

	{

	RDEBUG("CTerminalControlServer::AddSession");

	++iSessionCount;

	}

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

// CTerminalControlServer::DropSession

// A session is being destroyed

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

void CTerminalControlServer::DropSession()

	{

	RDEBUG("CTerminalControlServer::DropSession");

	iSessionCount --;

	if( iSessionCount == 0 )

	    {

	    CActiveScheduler::Stop();

	    }

	}

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

// CTerminalControlServer::NewContainerL

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

CObjectCon* CTerminalControlServer::NewContainerL()

	{

	RDEBUG("CTerminalControlServer::NewContainerL");

	return iContainerIndex->CreateL();

	}

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

// CTerminalControlServer::CustomSecurityCheckL

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

CPolicyServer::TCustomResult CTerminalControlServer::CustomSecurityCheckL(const RMessage2& /*aMsg*/, TInt& /*aAction*/, TSecurityInfo& /*aMissing*/)

	{

	RDEBUG("CTerminalControlServer::CustomSecurityCheckL");

	return EPass;

	}

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

// CTerminalControlServer::DeleteFileL

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

void CTerminalControlServer::DeleteFileL( const TDesC8 &aFileName )

    {

	RDEBUG("CTerminalControlServer::DeleteFileL");

    RFs fs;

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

    CleanupClosePushL( fs );

    HBufC *fileName = HBufC::NewLC( aFileName.Length()+1 );

    TPtr fnptr( fileName->Des() );

    fnptr.Copy(aFileName);

    TEntry entry;

    User::LeaveIfError( fs.Entry( fnptr, entry ) );

    if( entry.IsDir() )

        {

        if(fnptr.Right(1) != _L("\\"))

            {

            fnptr.Append(_L("\\"));

            }

        User::LeaveIfError(fs.RmDir( fnptr ) );

        }

    else

        {

        User::LeaveIfError(fs.Delete( fnptr ) );

        }

    CleanupStack::PopAndDestroy( fileName );

    CleanupStack::PopAndDestroy( &fs );

    }

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

// CTerminalControlServer::GetRunningProcessesL

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

CBufFlat* CTerminalControlServer::GetRunningProcessesL( )

    {

	RDEBUG("CTerminalControlServer::GetRunningProcessesL");

    TFullName    processName;

    TFindProcess findProcess;

    CBufFlat *buffer = CBufFlat::NewL(128);

    iProcessInfoArray->Reset();

    while( KErrNone == findProcess.Next( processName ) )

        {

        TTcProcessInfo info;

        RProcess process;

        if( KErrNone == process.Open( findProcess ) )

            {

            //

            // Add process information to local array

            //

            info.iProcessName = processName;

            info.iFileName    = process.FileName();

            info.iHandle      = process.Handle();

            info.iId          = process.Id();

            info.iSecureId    = process.SecureId();

            info.iProtected   = EFalse; 

            process.GetMemoryInfo( info.iMemoryInfo );

            User::IsRomAddress( info.iCodeInRom, (TAny*)(info.iMemoryInfo.iCodeBase) );

            if( !info.iCodeInRom )

            	{

            	User::IsRomAddress( info.iCodeInRom, (TAny*)(info.iMemoryInfo.iCodeBase) );

            	}

            iProcessInfoArray->AppendL( info );

            //

            // Add process also to return buffer

            //

            /*

            TInt appendPosition = buffer->Size();

            if(iProcessInfoArray->Count() >= 2)

                {

                TBuf8<sizeof(info.iProcessName)> proName;

                proName.Copy(info.iProcessName);

                buffer->InsertL(appendPosition, _L8("/"));

                buffer->InsertL(appendPosition+1, proName);

                }

            else

                {

                TBuf8<sizeof(info.iProcessName)> proName;

                proName.Copy(info.iProcessName);

                buffer->InsertL(appendPosition, proName);

                }

            }

            */

            // Enumerate names from 1

            TInt appendPosition = buffer->Size();

            TBuf8<MAX_NUMBER_OF_DIGITS_IN_10BASE_INT64> numBuf;

            TBuf8<sizeof(KFormatProcessNamePrefix)+20> nameBuf;

            numBuf.Num(iProcessInfoArray->Count());

            nameBuf.Zero();

            nameBuf.Append(KFormatProcessNamePrefix);

            nameBuf.Append(numBuf);

            if(iProcessInfoArray->Count() >= 2)

                {

                buffer->InsertL(appendPosition, _L8("/"));

                buffer->InsertL(appendPosition+1, nameBuf);

                }

            else

                {

                buffer->InsertL(appendPosition, nameBuf);

                }

            }

        }

/*

	TUint32 flags = Exec::ProcessFlags(KCurrentProcessHandle);

	if (flags & KProcessFlagSystemPermanent)

		return ESystemPermanent;

	if (flags & KProcessFlagSystemCritical)

		return ESystemCritical;

	if (flags & KThreadFlagProcessPermanent)

		return EAllThreadsCritical;

	return ENotCritical;

*/

    return buffer;

    }

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

// CTerminalControlServer::FindLocalProcessInfoL

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

CTerminalControlServer::TTcProcessInfo CTerminalControlServer::FindLocalProcessInfoL ( const TDesC8 &aProcessName )

    {

	RDEBUG("CTerminalControlServer::FindLocalProcessInfoL");

    TInt processCount = iProcessInfoArray->Count();

    if(processCount == 0)

        {

        User::Leave( KErrNotFound );

        }            

    if(aProcessName.Length() < KFormatProcessNamePrefix().Length()+1)

        {

        User::Leave(KErrNotFound);

        }

    if(aProcessName.Left( KFormatProcessNamePrefix().Length() ).Compare(KFormatProcessNamePrefix) != KErrNone)

        {

        User::Leave(KErrNotFound);

        }

    //

    // Get process index from the name

    //

    TInt  index;

    TLex8 lex;

    lex.Assign( aProcessName );

    lex.Inc( KFormatProcessNamePrefix().Length() );

    User::LeaveIfError( lex.Val(index) );

    index --;

    if(index < 0 || index >= processCount)

        {

        User::Leave( KErrNotFound );

        }

    return iProcessInfoArray->At(index);

    }

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

// CTerminalControlServer::GetProcessDataL

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

CBufFlat* CTerminalControlServer::GetProcessDataL( const TDesC8 &aProcessName, TDesC8 &aDataName )

    {

	RDEBUG("CTerminalControlServer::GetProcessDataL");

    _LIT8(KProcessDataFormat,

"\

<process-information name=\"%S\">\r\n\

\t<process-data name=\"%S\" value=\"%S\"/>\r\n\

</process-information>\r\n\

");

    TTcProcessInfo info = FindLocalProcessInfoL( aProcessName );

    CBufFlat* processData; processData = 0;

    processData = CBufFlat::NewL(128);

    CleanupStack::PushL( processData );

    // Set process data

    if(aDataName == _L8("ID"))

        {

        TBuf8<MAX_NUMBER_OF_DIGITS_IN_10BASE_INT64> numBuf;

        numBuf.Num((TUint)info.iId);

        processData->InsertL(0, numBuf);

        }

        else

    if(aDataName == _L8("FromRAM"))

        {

        TBuf8<MAX_NUMBER_OF_DIGITS_IN_10BASE_INT64> numBuf;

        numBuf.Num((TUint)!info.iCodeInRom);

        processData->InsertL(0, numBuf);

        }

        else

    if(aDataName == _L8("MemoryInfo"))

        {

        TBuf8<MAX_NUMBER_OF_DIGITS_IN_10BASE_INT64> valueBuf;

        valueBuf.Num((TUint)info.iMemoryInfo.iCodeSize+

                          info.iMemoryInfo.iConstDataSize+

                          info.iMemoryInfo.iInitialisedDataSize+

                          info.iMemoryInfo.iUninitialisedDataSize);

        TInt responseLength = KProcessDataFormat().Length() + aProcessName.Length()

                            + aDataName.Length() + valueBuf.Length();

        HBufC8* buffer = HBufC8::NewLC( responseLength );

        buffer->Des().Format( KProcessDataFormat, &aProcessName, &aDataName, &valueBuf );

        processData->InsertL(0, *buffer);

        CleanupStack::PopAndDestroy( buffer );

        }

        else

    if(aDataName == _L8("Filename"))

        {

        TBuf8<sizeof(TFileName)> fname;

        fname.Copy(info.iFileName);

        processData->InsertL(0, fname);

        }

    else