/*

* Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:       Defines runtime security manager script session class

 *

*/

#include <aknlistquerydialog.h>

#include <AknQueryDialog.h>

#include <aknmessagequerycontrol.h>

#include <aknmessagequerydialog.h> 

#include <badesca.h>

#include <bautils.h>

#include <coemain.h>

#include <data_caging_path_literals.hrh>

#include <eikenv.h>

#include <eikfrlb.h>

#include <eikfrlbd.h>

#include <pathinfo.h> 

#include <StringLoader.h>

#include <rtsecmanager.h>

#include <rtsecmgrscriptsession.h>

#include <rtsecmgrscript.h>

#include "rtsecmgrclient.h"

#include "rtsecmgrdef.h"

#define FIRST_RESOURCE_ID(x) ((x)+2);

//security manager resource file literal

_LIT(KSecMgrResourceFile, "RTSecManager.RSC");

//constant for descriptor array granularity

const TInt KDescArrayInit = 6;

const TInt KMaxBuf=255;

//typedef of selection index array

typedef RArray<TInt> RSelIdxArray;

//static resource IDs for capability text display in default prompt

static const TInt CAPABILITY_RESOURCEID[KCapabilitySize] =

	{

	0, //ECapabilityTCB (0) 

	R_RTSECMGR_COMMDD, //ECapabilityCommDD (1)

	R_RTSECMGR_POWERMGMT, //ECapabilityPowerMgmt (2)

	R_RTSECMGR_MMEDIADD, //ECapabilityMultimediaDD (3)

	R_RTSECMGR_READDEVICEDATA, //ECapabilityReadDeviceData (4)

	R_RTSECMGR_WRITEDEVICEDATA, //ECapabilityWriteDeviceData (5)

	R_RTSECMGR_DRM, //ECapabilityDRM (6)

	R_RTSECMGR_TRUSTEDUI, //ECapabilityTrustedUI (7)

	R_RTSECMGR_PROTSERV, //ECapabilityProtServ (8)

	R_RTSECMGR_DISKADMIN, //ECapabilityDiskAdmin (9)

	R_RTSECMGR_NWCONTROL, //ECapabilityNetworkControl (10)

	R_RTSECMGR_ALLFILES, //ECapabilityAllFiles (11)

	R_RTSECMGR_SWEVENT, //ECapabilitySwEvent (12)

	R_RTSECMGR_NWSERVICES, //ECapabilityNetworkServices (13)

	R_RTSECMGR_LOCALSERVICES, //ECapabilityLocalServices (14)

	R_RTSECMGR_READUSERDATA, //ECapabilityReadUserData (15)

	R_RTSECMGR_WRITEUSERDATA, //ECapabilityWriteUserData (16)

	R_RTSECMGR_LOCATION, //ECapabilityLocation (17)

	R_RTSECMGR_SURRDD, //ECapabilitySurroundingsDD (18)

	R_RTSECMGR_USERENV	//ECapabilityUserEnvironment (19)					

		};

static const TInt MOREINFO_CAP_RESOURCEID[KCapabilitySize] = 

	{

	0, //ECapabilityTCB (0) 

	R_RTSECMGR_MORE_INFO_COMMDD, //ECapabilityCommDD (1)

	R_RTSECMGR_POWERMGMT, //ECapabilityPowerMgmt (2)

	R_RTSECMGR_MORE_INFO_MMEDIADD, //ECapabilityMultimediaDD (3)

	R_RTSECMGR_MORE_INFO_READDEVICEDATA, //ECapabilityReadDeviceData (4)

	R_RTSECMGR_MORE_INFO_WRITEDEVICEDATA, //ECapabilityWriteDeviceData (5)

	0, //ECapabilityDRM (6)

	0, //ECapabilityTrustedUI (7)

	0, //ECapabilityProtServ (8)

	0, //ECapabilityDiskAdmin (9)

	R_RTSECMGR_MORE_INFO_NWCONTROL, //ECapabilityNetworkControl (10)

	0, //ECapabilityAllFiles (11)

	R_RTSECMGR_MORE_INFO_SWEVENT, //ECapabilitySwEvent (12)

	R_RTSECMGR_MORE_INFO_NWSERVICES, //ECapabilityNetworkServices (13)

	R_RTSECMGR_MORE_INFO_LOCALSERVICES, //ECapabilityLocalServices (14)

	R_RTSECMGR_MORE_INFO_READ_USERDATA, //ECapabilityReadUserData

	R_RTSECMGR_MORE_INFO_WRITE_USERDATA,//ECapabilityWriteUserData

	R_RTSECMGR_MORE_INFO_LOCATION,//ECapabilityLocation

	R_RTSECMGR_MORE_INFO_SURRDD, //ECapabilitySurroundingsDD

	R_RTSECMGR_MORE_INFO_USERENV //ECapabilityUserEnvironment

	};

struct TCallbackParam

{

	CRTSecMgrScriptSession* iRTSecMgrScriptSession;

	CPromptData *iPromptData;	

};

/**

 * Proxy delegate class for runtime security manager client-side

 * sub-session handle.

 * 

 * @lib rtsecmgrclient.lib

 */

class CRTSecMgrSubSessionProxy : public CBase

	{

public:

	static CRTSecMgrSubSessionProxy* NewL()

		{

		CRTSecMgrSubSessionProxy* self = CRTSecMgrSubSessionProxy::NewLC ();

		CleanupStack::Pop (self);

		return self;

		}

	static CRTSecMgrSubSessionProxy* NewLC()

		{

		CRTSecMgrSubSessionProxy* self = new (ELeave) CRTSecMgrSubSessionProxy();

		CleanupStack::PushL (self);

		self->ConstructL ();

		return self;

		}

	virtual ~CRTSecMgrSubSessionProxy()

		{

		iSubSession.Close ();

		}

	inline RSecMgrSubSession& SubSession()

		{

		return iSubSession;

		}

	RSecMgrSubSession* operator ->()

	{

	return &iSubSession;

	}

private:

	inline CRTSecMgrSubSessionProxy()

		{

		}

	void ConstructL()

		{

		}

	RSecMgrSubSession iSubSession;

	};

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

// Defintiion of default private constructor

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

//

CRTSecMgrScriptSession::CRTSecMgrScriptSession(MSecMgrPromptHandler* aPromptHdlr) :

				iPromptHdlr(aPromptHdlr), iUIPromptOption(RTPROMPTUI_DEFAULT), isCustomPrompt(EFalse)

	{

	iSessionData = NULL;

	}

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

// Defintiion of second-phase constructor

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

//

CRTSecMgrScriptSession* CRTSecMgrScriptSession::NewL(

		MSecMgrPromptHandler* aPromptHdlr)

	{

	CRTSecMgrScriptSession* self = CRTSecMgrScriptSession::NewLC (aPromptHdlr);

	CleanupStack::Pop (self);

	return self;

	}

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

// Defintiion of second-phase constructor

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

//

CRTSecMgrScriptSession* CRTSecMgrScriptSession::NewLC(

		MSecMgrPromptHandler* aPromptHdlr)

	{

	CRTSecMgrScriptSession* self = new (ELeave) CRTSecMgrScriptSession(aPromptHdlr);

	CleanupStack::PushL (self);

	self->ConstructL ();

	return self;

	}

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

// Defintiion of second-phase constructor

// This method instantiates client side sub-session proxy instance.

// In addition, this method loads the security manager resource

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

//

void CRTSecMgrScriptSession::ConstructL()

	{

	iCoeEnv = CCoeEnv::Static ();

	if ( !iCoeEnv && !iPromptHdlr)

		User::Leave (KErrNotSupported);

	iSubSessionProxy = CRTSecMgrSubSessionProxy::NewL ();

	if ( !iPromptHdlr)

	    {

	    iPromptHdlr = this; //default prompt handler	

	    isCustomPrompt = ETrue ;

	    }

	_permanentInfo = new(ELeave) TPermanentInfo;			

	_sessionData.sessionInfo = new(ELeave) TSessionInfo;

	_sessionData.sessionInfo->AllowedCaps = KDefaultNullBit;

    _sessionData.sessionInfo->DeniedCaps = KDefaultNullBit;

    _sessionData.sessionInfo->AllowedProviders.Reset();

    _sessionData.sessionInfo->DeniedProviders.Reset();

    _permanentInfo->iAllowedBits = KDefaultNullBit;

    _permanentInfo->iDeniedBits = KDefaultNullBit;

    _permanentInfo->iAllowedProviders.Reset();

    _permanentInfo->iDeniedProviders.Reset();

    iResourceOffsetArray.Reset();

	}

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

//Method to add the resource files to CONE environment.

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

void CRTSecMgrScriptSession::AddResourceFiles()

    {

        if(iCoeEnv)

        {            

        CDesCArray* diskList = new (ELeave) CDesCArrayFlat(KDescArrayInit);

        CleanupStack::PushL (diskList);

        BaflUtils::GetDiskListL (iCoeEnv->FsSession (), *diskList);

        for (TInt idx(0); idx<diskList->Count ();++idx)

            {

            TInt intDrive;

            TChar ch = ((*diskList)[idx])[0];

            RFs::CharToDrive (ch, intDrive);

            TDriveUnit curDrive(intDrive);

            TFileName resFile(curDrive.Name ());

            resFile.Append (KDC_APP_RESOURCE_DIR);

            resFile.Append (KSecMgrResourceFile);

            BaflUtils::NearestLanguageFile (iCoeEnv->FsSession (), resFile);

            if ( BaflUtils::FileExists (iCoeEnv->FsSession (), resFile))

                {

                TRAPD (err, iResourceOffsetArray.Append(iCoeEnv->AddResourceFileL (resFile)));

                User::LeaveIfError (err);

                break;

                }

            }

        CleanupStack::PopAndDestroy (diskList);

        }        

    }

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

//Method to add provider resource files into the CONE environment

//Returns the first resource identifier which has the prompt string

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

TInt CRTSecMgrScriptSession::AddProviderResourceFile(TFileName aResourceFileName)

    {

    RResourceFile resFile;

    TInt resID(KErrNone);

    if(iCoeEnv)

        {            

        CDesCArray* diskList = new (ELeave) CDesCArrayFlat(KDescArrayInit);

        CleanupStack::PushL (diskList);

        BaflUtils::GetDiskListL (iCoeEnv->FsSession (), *diskList);

        for (TInt idx(0); idx<diskList->Count ();++idx)

            {

            TInt intDrive;

            TChar ch = ((*diskList)[idx])[0];

            RFs::CharToDrive (ch, intDrive);

            TDriveUnit curDrive(intDrive);

            TFileName resFileName(curDrive.Name ());

            resFileName.Append (KDC_APP_RESOURCE_DIR);

            resFileName.Append (aResourceFileName);

            BaflUtils::NearestLanguageFile (iCoeEnv->FsSession (), resFileName);

            if ( BaflUtils::FileExists (iCoeEnv->FsSession (), resFileName))

                {

                TRAPD(err,resFile.OpenL(iCoeEnv->FsSession(),resFileName));

                if(err == KErrNone)

                    {

                    resFile.ConfirmSignatureL(0);

                    resID = FIRST_RESOURCE_ID(resFile.Offset());

                    resFile.Close();

                    iResourceOffsetArray.Append(iCoeEnv->AddResourceFileL (resFileName));

                    break;

                    }

                }

            }

        CleanupStack::PopAndDestroy(diskList);

        }

    return resID;

    }

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

//Close the resource files previously added 

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

void CRTSecMgrScriptSession::CloseResourceFiles()

    {

    if (iCoeEnv)

        {

        for(TInt i(0); i < iResourceOffsetArray.Count(); i++)

            iCoeEnv->DeleteResourceFile (iResourceOffsetArray[i]);

        iResourceOffsetArray.Reset();

        }

    }

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

// Destructor

// Closes script sub-session handle

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

//

EXPORT_C CRTSecMgrScriptSession::~CRTSecMgrScriptSession()

	{

	_permanentInfo->iAllowedProviders.Close();

	_permanentInfo->iDeniedProviders.Close();

	_sessionData.sessionInfo->AllowedProviders.Close();

	_sessionData.sessionInfo->DeniedProviders.Close();

	delete _permanentInfo;

	delete _sessionData.sessionInfo;

	if(iSessionData)

	    {

	    delete iSessionData;

	    iSessionData = NULL;

	    }

	Close ();

	}

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

// Opens script session, in turn opening client-side sub-session handle

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

//

TInt CRTSecMgrScriptSession::Open(const RSessionBase& aParentSession,

		TPolicyID aPolicyID, TExecutableID aExecID)

	{

	if (iScript)

		{

		delete iScript;

		iScript = NULL;

		}

	iScript = CScript::NewL (aPolicyID, aExecID);

	TInt ret((*iSubSessionProxy)->Open (aParentSession, *iScript, aPolicyID));

	if ( KErrNone==ret)

	    {

        _permanentInfo->iAllowedBits = iScript->PermGranted ();

        _permanentInfo->iDeniedBits = iScript->PermDenied ();

        iScript->PermGranted(_permanentInfo->iAllowedProviders);

        iScript->PermDenied(_permanentInfo->iDeniedProviders);		    

	    }

	return ret;

	}

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

// Opens script session, in turn opening client-side sub-session handle

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

//

TInt CRTSecMgrScriptSession::Open(const RSessionBase& aParentSession,

		TPolicyID aPolicyID, TExecutableID aExecID, const TDesC& aHashValue)

	{

	if (iScript)

		{

		delete iScript;

		iScript = NULL;

		}

	iScript = CScript::NewL (aPolicyID, aExecID);

	TInt ret((*iSubSessionProxy)->Open (aParentSession, *iScript, aPolicyID, aHashValue));

	if ( KErrNone==ret)

		{

        _permanentInfo->iAllowedBits = iScript->PermGranted ();

        _permanentInfo->iDeniedBits = iScript->PermDenied ();

        iScript->PermGranted(_permanentInfo->iAllowedProviders);

        iScript->PermDenied(_permanentInfo->iDeniedProviders);            

		}

	return ret;

	}

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

// Opens script session, in turn opening client-side sub-session handle

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

//

TInt CRTSecMgrScriptSession::Open(const RSessionBase& aParentSession,

		TPolicyID aPolicyID, TExecutableID aExecID, const CTrustInfo& aTrustInfo)

	{

	if (iScript)

		{

		delete iScript;

		iScript = NULL;

		}

	iScript = CScript::NewL (aPolicyID, aExecID);

	TInt ret((*iSubSessionProxy)->Open (aParentSession, *iScript, aPolicyID, aTrustInfo));

	if ( KErrNone==ret)

		{		

        _permanentInfo->iAllowedBits = iScript->PermGranted ();

        _permanentInfo->iDeniedBits = iScript->PermDenied ();    

        iScript->PermGranted(_permanentInfo->iAllowedProviders);

        iScript->PermDenied(_permanentInfo->iDeniedProviders);            

		}

	return ret;

	}

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

// Performs access permission check, returns unmatched capabilities if any

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

//

EXPORT_C TInt CRTSecMgrScriptSession::IsAllowed(const RCapabilityArray& aCapabilitiesToCheck,RCapabilityArray& aUnMatchedCapabilities)

	{

	RPromptDataList promptDataList;

	TCapabilityBitSet unMatchedCapBits(KDefaultNullBit);

	TInt ret(IsAllowed(aCapabilitiesToCheck,promptDataList,unMatchedCapBits));

	promptDataList.ResetAndDestroy();

	if(KDefaultNullBit!=unMatchedCapBits)

	BuildCapsL(unMatchedCapBits,aUnMatchedCapabilities);

	return ret;

	}

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

// Performs access permission check

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

//

EXPORT_C TInt CRTSecMgrScriptSession::IsAllowed(const RCapabilityArray& aCapabilitiesToCheck)

 	{

 	RPromptDataList promptDataList;

	TCapabilityBitSet unMatchedCapBits(KDefaultNullBit);

	TInt ret(IsAllowed(aCapabilitiesToCheck,promptDataList,unMatchedCapBits));

	promptDataList.ResetAndDestroy();

	return ret;

	}

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

// Private implementation to perform access perform access check.

// This function is the real task master

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

//

TInt CRTSecMgrScriptSession::IsAllowed(

		const RCapabilityArray& aCapabilitiesToCheck,

		RPromptDataList& aPromptDataList, TCapabilityBitSet& aUnMatchedCaps)

	{

	if ( aCapabilitiesToCheck.Count ()<=0)

		{

		return EAccessOk; //if no capabilities are required, safely return

		}

	if ( aCapabilitiesToCheck.Find(ECapabilityTCB) != KErrNotFound)

		return EAccessNok;

	aPromptDataList.Reset ();

	TCapabilityBitSet capToCheck(KDefaultNullBit);

	TCapabilityBitSet finalCaps(KDefaultNullBit);

	for (TInt i(0); i!=aCapabilitiesToCheck.Count (); ++i)

		AddCapability (capToCheck, aCapabilitiesToCheck[i]);

	capToCheck &= ~(iScript->PermissionSet().UnconditionalCaps());

	/* Check if a;ready denied. No point in going forward */

	if(capToCheck & _sessionData.sessionInfo->DeniedCaps || capToCheck & _permanentInfo->iDeniedBits)

	        return EAccessNok;

	TCapabilityBitSet allowedCaps(KDefaultNullBit);

	allowedCaps |= _sessionData.sessionInfo->AllowedCaps; //for session allowed

	allowedCaps &= ~_permanentInfo->iDeniedBits;

	allowedCaps |= _permanentInfo->iAllowedBits; //for permanently allowed

	//In case if all the capabilities required by the service provider

	//are allowed without prompting

	TCapabilityBitSet original_capToCheck = capToCheck;

	capToCheck &= allowedCaps;

	if(original_capToCheck == capToCheck)

		return EAccessOk;

	capToCheck ^= original_capToCheck ;

	TBool isPermGrantModified(EFalse);

	RPermissions perms = iScript->PermissionSet().Permissions ();

	for (TInt i(0); (i!=perms.Count ())&& capToCheck ;++i)

		{

		CPermission* perm = CPermission::NewLC(*perms[i]);

		TCapabilityBitSet tempCapToCheck(KDefaultNullBit);

		RCapabilityArray capabilities;

		perm->Capabilitilites (capabilities);

		for (TInt capsIdx(0); capsIdx!=capabilities.Count();++capsIdx)

			{

			TCapability cap(capabilities[capsIdx]);

			tempCapToCheck |= LOWBIT << cap;

			}

		capToCheck &= tempCapToCheck;

		if ( capToCheck )

			{

			if ( capToCheck & _permanentInfo->iDeniedBits) //check if permanently disabled

				{

				allowedCaps &= ~tempCapToCheck; //just in case...

				_sessionData.sessionInfo->DeniedCaps &= ~tempCapToCheck; //just in case...

				}

			else

				if ( capToCheck & _sessionData.sessionInfo->DeniedCaps) //not necessary to do this check...

					{

					allowedCaps &= ~tempCapToCheck; //just in case...	

					}

				else