rtsecuritymanager/rtsecuritymanagerserver/src/rtsecmgrclientapi.cpp
changeset 0 99ef825efeca
child 10 a7062f7f0b79
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/rtsecuritymanager/rtsecuritymanagerserver/src/rtsecmgrclientapi.cpp	Mon Mar 30 12:51:20 2009 +0300
@@ -0,0 +1,402 @@
+/*
+* 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);
+		}
+	}