/*

* 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"

//security manager resource file literal

_LIT(KSecMgrResourceFile, "RTSecManager.RSC");

//constant for descriptor array granularity

const TInt KDescArrayInit = 6;

const TInt KMaxBuf=256;

//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) :

	iPermBits(KDefaultNullBit), iDeniedBits(KDefaultNullBit),

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

	{

	_sessionInfo.AllowedCaps = KDefaultNullBit;

	_sessionInfo.DeniedCaps = KDefaultNullBit;

}

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

// 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 ;

	    }

	}

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, iResourceOffset = iCoeEnv->AddResourceFileL (resFile));

                User::LeaveIfError (err);

                break;

                }

            }

        CleanupStack::PopAndDestroy (diskList);

        }        

    }

void CRTSecMgrScriptSession::CloseResourceFiles()

    {

    if ( iResourceOffset && iCoeEnv)

            iCoeEnv->DeleteResourceFile (iResourceOffset);

	iResourceOffset = 0;

    }

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

// Destructor

// Closes script sub-session handle

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

//

EXPORT_C CRTSecMgrScriptSession::~CRTSecMgrScriptSession()

	{

	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)

		{

		iPermBits = iScript->PermGranted ();

		iDeniedBits = iScript->PermDenied ();

		}

	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)

		{

		iPermBits = iScript->PermGranted ();

		iDeniedBits = iScript->PermDenied ();

		}

	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)

		{

		iPermBits = iScript->PermGranted ();

		iDeniedBits = iScript->PermDenied ();

		}

	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 & _sessionInfo.DeniedCaps || capToCheck & iDeniedBits)

	        return EAccessNok;

	TCapabilityBitSet allowedCaps(KDefaultNullBit);

	allowedCaps |= _sessionInfo.AllowedCaps; //for session allowed

	allowedCaps &= ~iDeniedBits;

	allowedCaps |= iPermBits; //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 & iDeniedBits) //check if permanently disabled

				{

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

				_sessionInfo.DeniedCaps &= ~tempCapToCheck; //just in case...

				}

			else

				if ( capToCheck & _sessionInfo.DeniedCaps) //not necessary to do this check...

					{

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

					}

				else

					if ((capToCheck & allowedCaps) != capToCheck) //check if it's already allowed

						{

						//capToCheck &= allowedCaps;

						TCapabilityBitSet temp = capToCheck;

						temp &= allowedCaps;

						temp ^= capToCheck;

						capToCheck = temp;

						if ( (perm->Condition() & RTUserPrompt_OneShot) ||(perm->Condition() & RTUserPrompt_Session) ||((perm->Condition() & RTUserPrompt_Permanent) &&

								(iScript->ScriptID()!=KAnonymousScript)))

							{

							if ( !(_sessionInfo.AllowedCaps & capToCheck))

								{

								//check if it's denied for this session

								if ( !(_sessionInfo.DeniedCaps & capToCheck))

									{

									CPromptData* promptData = CPromptData::NewL();//should write NewL Function

									promptData->SetPermissions(*perm);

									promptData->SetUserSelection(perm->Default ()) ;

									aPromptDataList.Append (promptData);

									}

								}

							else

								{

								allowedCaps |= tempCapToCheck; //enable in allowed

								}

							}

						}

			}

		capToCheck ^= original_capToCheck;

		capabilities.Close ();

		CleanupStack::PopAndDestroy(perm);

		}//for loop

	if ( aPromptDataList.Count ()>0)

		{

		//TInt ret = EPromptOk;

		TInt ret = iPromptHdlr->Prompt (aPromptDataList , iScript->ScriptID());

		//Iterate over promptDataList and check the user selection

			RCapabilityArray capArray;

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

				{

				CPermission *perm = (aPromptDataList[i])->iPermission;

				perm->Capabilitilites(capArray);

				TCapabilityBitSet tempCapToCheck(KDefaultEnableBit);

				TCapabilityBitSet userSelectedCaps = 0;

				for(TInt idx(0); idx != capArray.Count(); idx++)

					userSelectedCaps |= tempCapToCheck <<capArray[idx];	

				capArray.Close();

				HandleGrantChosen (aPromptDataList[i], userSelectedCaps, allowedCaps, isPermGrantModified);

				finalCaps |= allowedCaps ;

				}

		if ( EPromptOk!=ret)

			{

			return EAccessNok;

			}

		if ( (iScript->ScriptID()!=KAnonymousScript)&&(isPermGrantModified))

			UpdatePermGrant ();//commit perm grant change 

		finalCaps |= iPermBits ;

		if((finalCaps & NetworkServices_CAP) && isCustomPrompt)

		    PromptCostL() ;

		finalCaps |= _sessionInfo.AllowedCaps ;

		if ( KErrNone == ((finalCaps & original_capToCheck) ^ original_capToCheck))

			return EAccessOk;

		else

			{

			aUnMatchedCaps = (finalCaps & original_capToCheck) ^ original_capToCheck;

			return EAccessNok;

			}

		}

	else

		{

		return EAccessNok;

		}

	}

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