/*
* 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:       Implementation file for security manager server, session and 
 * 				  sub-session classes 
 *
*/






#include <f32file.h>
#include <e32debug.h>
#include <rtsecmgrcommondef.h>
#include "rtsecmgrserver.h"
#include "rtsecmgrsession.h"
#include "rtsecmgrsubsession.h"
#include "rtsecmgrpolicyparser.h"
#include "rtsecmgrstore.h"
#include "rtsecmgrprotectiondomain.h"
#include "rtsecmgrpolicymanager.h"
#include "rtsecmgrscriptmanager.h"
#include "rtsecmgrmsg.h"

_LIT(KUntrusted, "UnTrusted");

TInt CRTSecMgrServer::GetCapabilityInfo(TPolicyID aPolicyID,
		TExecutableID aExecID, CScript& aScript)
	{
	if ( KAnonymousScript==aExecID)
		{
		CPolicy* policy = iPolicyMgr->Policy (aPolicyID);
		if ( policy)
			{
			CProtectionDomain* domain = policy->ProtectionDomain (KUntrusted);

			if ( domain)
				{
				const CPermissionSet& permissionSet = domain->PermSet ();
				aScript.SetPermissionSet (permissionSet);
				return KErrNone;
				}
			}
		}

	return KErrNotFound;
	}

void CRTSecMgrSession::SetPolicy(const RMessage2& aMessage, TBool aIsUpdate)
	{
	if(!aMessage.HasCapability(ECapabilityWriteDeviceData , ""))
	    {
	    TPckgBuf<TInt> pkg(ErrAccessDenied);
	    aMessage.Write(EMsgArgZero , pkg);
	    return;
	    }
	RFile secPolicyFile;
	TPolicyID pID(ErrInvalidPolicyID);

	if ( KErrNone==secPolicyFile.AdoptFromClient (aMessage, EMsgArgOne,
			EMsgArgTwo))
		{
		CPolicyParser* policyParser = CPolicyParser::NewLC ();
		TInt ret(KErrNone);

		RProtectionDomains policyInfo;
		RAliasGroup aliasInfo;
		ret=policyParser->GetPolicyInfo (secPolicyFile, policyInfo, aliasInfo);

		if (KErrNone==ret)
			{
			if(aIsUpdate)
				{
				TPckgBuf<TInt> pIDPckg;
				aMessage.Read(0, pIDPckg);
				pID = pIDPckg();
				}
			else
				{
				if ( KErrNone==iSecMgrServer->ReadCounter (pID))
					{
					while (iSecMgrServer->IsValidPolicy(pID))
						{
						--pID ;
						}
					}
				else
					{
					pID = ErrServerReadConfig;
					}
				}
			TRAPD (err, iSecMgrServer->AddPolicyL (pID, policyInfo, aliasInfo));
			
			if ( KErrNone!=err)
				{
				pID = ErrSetPolicyFailed;
				}						
				
			}
		else
			{
			pID = ErrInvalidPolicyFormat;
			policyInfo.ResetAndDestroy ();
			}
		CleanupStack::PopAndDestroy (policyParser);
		}
	else
		{
		pID = ErrFileSessionNotShared;
		}

	secPolicyFile.Close();
	
	TPckgBuf<TInt> pkg(pID);
	aMessage.Write (EMsgArgZero, pkg);
	}

void CRTSecMgrSession::UpdatePolicy(const RMessage2& aMessage)
	{
	if(!aMessage.HasCapability(ECapabilityWriteDeviceData , ""))
        {
        TPckgBuf<TInt> pkg(ErrAccessDenied);
        aMessage.Write(EMsgArgZero , pkg);
        return;
        }
	TPckgBuf<TInt> pIDPckg;
	aMessage.Read (0, pIDPckg);

	TPolicyID pID(pIDPckg ());

		//Check if this ID already exists
	if ( !iSecMgrServer->IsValidPolicy(pID))
		{
		TPckgBuf<TInt> pkg(ErrUpdatePolicyFailed);
		aMessage.Write (EMsgArgZero, pkg);
		RFile secPolicyFile;
		//just to close the secPolicyFile. Else the temmporary file cannot be deleted
		secPolicyFile.AdoptFromClient (aMessage, EMsgArgOne,EMsgArgTwo);
		secPolicyFile.Close();
		return;
		}
	else
		{
		if ( IsScriptOpenWithPolicy (pID))
			{
			TPckgBuf<TInt> pkg(ErrUpdatePolicyFailed);
			aMessage.Write (EMsgArgZero, pkg);
			return;
			}
		}

	//back up the file before update (file with this policy Id)
	TInt backupResult = iSecMgrServer->BackupFile(pID);
	
	if(KErrNone == backupResult)
		{
			SetPolicy (aMessage, ETrue);
			
			aMessage.Read(0, pIDPckg);
			TInt resultSetPolicy = pIDPckg();		
			
			if(resultSetPolicy < KErrNone)
				{
					//means that the policy updation is NOT successful due to invalid policy file
					//Hence retain the previous file by restoring the temp file
					TInt restoreResult = iSecMgrServer->RestoreTempPolicy(pID);
					
					if(KErrNone != restoreResult)
					{
						// file backup not created due to errors
						TPckgBuf<TInt> pkg(ErrRestoreTempFailed);
						aMessage.Write (EMsgArgZero, pkg);
						return;
					}
				}

			//Backup file is no longer useful. 
			//Hence removing this temporary file using the method below
			TInt rmTempResult = iSecMgrServer->RemoveTempPolicy(pID);	
			if(KErrNone != rmTempResult)
			{
				//temporary file not removed
				
			}	
	}
	else
	{
		// file backup not created due to errors
		TPckgBuf<TInt> pkg(ErrBackupNotCreated);
		aMessage.Write (EMsgArgZero, pkg);
		return;
		
	}	
	
	}

void CRTSecMgrSession::UnsetPolicy(const RMessage2& aMessage)
	{
	if(!aMessage.HasCapability(ECapabilityWriteDeviceData , ""))
        {
        TPckgBuf<TInt> pkg(ErrAccessDenied);
        aMessage.Write(EMsgArgZero , pkg);
        return;
        }
	TPolicyID pID = aMessage.Int0 ();

	TInt result = ErrUnSetPolicyFailed;

	if ( !IsScriptOpenWithPolicy(pID))
		{
		result = iSecMgrServer->RemovePolicy (pID);
		}
	if( KErrNone>result )
		result = ErrUnSetPolicyFailed;
	
	TPckgBuf<TInt> retVal(result);
	aMessage.Write (EMsgArgOne, retVal);
	}

void CRTSecMgrSession::RegisterScript(const RMessage2& aMessage, TBool aIsHashed)
	{
	if( !aMessage.HasCapability(ECapabilityWriteDeviceData , ""))
        {
        TPckgBuf<TInt> pkg(ErrAccessDenied);
        aMessage.Write(EMsgArgZero , pkg);
        return;
        }
	if ( aIsHashed)
		{
		HBufC8* desData = HBufC8::NewLC (KMaxMsgLength);
		TPtr8 readPtr(desData->Des ());
		aMessage.ReadL (0, readPtr);
		CRTSecMgrRegisterScriptMsg
				* scriptMsg = CRTSecMgrRegisterScriptMsg::NewLC (*desData);

		TExecutableID scriptID = iSecMgrServer->RegisterScript (scriptMsg->PolicyID(),scriptMsg->HashValue());
		
		TPckgBuf<TInt> exeIDPkg(scriptID);
		aMessage.Write (EMsgArgOne, exeIDPkg);

		CleanupStack::PopAndDestroy (scriptMsg);
		CleanupStack::PopAndDestroy (desData);		
		}
	else
		{
		TPolicyID policyID = aMessage.Int0 ();

		TExecutableID scriptID = iSecMgrServer->RegisterScript (policyID);

		if ( KErrNone>scriptID)
			scriptID = ErrRegisterScriptFailed;

		TPckgBuf<TInt> exeIDPkg(scriptID);
		aMessage.Write (EMsgArgOne, exeIDPkg);
		}

	}

void CRTSecMgrSession::UnregisterScript(const RMessage2& aMessage)
	{
	if(!aMessage.HasCapability(ECapabilityWriteDeviceData , ""))
        {
        TPckgBuf<TInt> pkg(ErrAccessDenied);
        aMessage.Write(EMsgArgZero , pkg);
        return;
        }
	TExecutableID scriptID(aMessage.Int0 ());
	TPolicyID policyID(aMessage.Int1 ());

	TInt result = KErrNone;

	if ( !IsScriptSessionOpen(scriptID))
		{
		TRAP (result, iSecMgrServer->UnRegisterScriptL (scriptID, policyID));
		if(KErrNone>result)
				result = ErrUnRegisterScriptFailed;	
		}
	else
		{
		result = ErrUnRegisterScriptFailed;
		}

	TPckgBuf<TInt> errCode(result);
	aMessage.Write (EMsgArgTwo, errCode);
	}

void CRTSecMgrSession::GetScriptSessionL(const RMessage2& aMessage)
	{
	if(!aMessage.HasCapability(ECapabilityWriteDeviceData , ""))
        {
        User::Leave(ErrAccessDenied);
        }
	TExecutableID scriptID = (TExecutableID)aMessage.Int0();
	TPolicyID policyID = (TPolicyID)aMessage.Int1();

	CScript* script = CScript::NewLC (policyID, scriptID);

	User::LeaveIfError (iSecMgrServer->GetCapabilityInfo (*script));

	if(script->PolicyID() != policyID || !iSecMgrServer->IsValidPolicy(policyID))
	{
		User::Leave(ErrInvalidPolicyID);
	}
	
	CleanupStack::Pop (script);

	CRTSecMgrSubSession* counter = CRTSecMgrSubSession::NewL (this, script, iSecMgrServer);
	CleanupStack::PushL (counter);

	// add the CCountSubSession object to 
	// this subsession's object container
	// to gererate a unique id
	iContainer->AddL (counter);

	// Add the object to object index; this returns
	// a unique handle so that we can find the object
	// again laterit later.
	TInt handle=iSubSessionObjectIndex->AddL (counter);

	// Write the handle value back to the client.
	// NB It's not obvious but the handle value must be passed
	// back as the 4th parameter (i.e. parameter number 3 on
	// a scale of 0 to 3). 
	// The arguments that are passed across are actually
	// set up by RSubSessionBase::DoCreateSubSession().
	// If you pass your own arguments into a call
	// to RSubSessionBase::CreateSubSession(), which calls DoCreateSubSession, 
	// then only the first three are picked up - the 4th is reserved for the
	// the subsession handle.
	TPckgBuf<TInt> handlePckg(handle);
	aMessage.Write (EMsgArgThree, handlePckg);

	CleanupStack::Pop (counter);
	}

void CRTSecMgrSession::GetTrustedUnRegScriptSessionL(const RMessage2& aMessage)
	{
	if(!aMessage.HasCapability(ECapabilityWriteDeviceData , ""))
        {
        User::Leave(ErrAccessDenied);
        }
	//0th parameter - ScriptID
	//1st parameter - PolicyID	
	TExecutableID scriptID = (TExecutableID)aMessage.Int0(); //typically this is KAnonymousScript
	TPolicyID policyID = (TExecutableID)aMessage.Int1();

	CScript* script = CScript::NewLC (policyID, scriptID);

	User::LeaveIfError (iSecMgrServer->GetCapabilityInfo(policyID, scriptID, *script));

	CleanupStack::Pop (script);

	CRTSecMgrSubSession* counter = CRTSecMgrSubSession::NewL (this, script, iSecMgrServer);
	CleanupStack::PushL (counter);

	iContainer->AddL (counter);
	TInt handle=iSubSessionObjectIndex->AddL (counter);
	TPckgBuf<TInt> handlePckg(handle);
	aMessage.Write (EMsgArgThree, handlePckg);

	CleanupStack::Pop (counter);
	}

void CRTSecMgrSubSession::GetScriptFile(const RMessage2& aMessage)
	{
	RFile scriptFile;

	if ( KErrNone==scriptFile.AdoptFromClient (aMessage, EMsgArgOne,
			EMsgArgTwo))
		{
		RFileWriteStream rfws(scriptFile);
		iScript->ExternalizeL (rfws);
		rfws.Close ();
		scriptFile.Close ();
		}
	}

void CRTSecMgrSubSession::UpdatePermGrantL(const RMessage2& aMessage)
	{
	if ( !iSession->IsScriptSessionOpen(aMessage.Int0(),this))
		{
		iSecMgrServer->UpdatePermGrantL (aMessage.Int0 (), aMessage.Int1 (),
				aMessage.Int2 ());
		}
	else
		{
		TPckgBuf<TInt> pkg((TInt)ErrUpdatePermGrantFailed);
		aMessage.Write (EMsgArgZero, pkg);
		}
	}