diff -r 000000000000 -r 4e1aa6a622a0 sysstatemgmt/systemstatemgr/sus/src/susadaptionserver.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/sysstatemgmt/systemstatemgr/sus/src/susadaptionserver.cpp	Tue Feb 02 00:53:00 2010 +0200
@@ -0,0 +1,788 @@
+// Copyright (c) 2008-2009 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:
+//
+
+#include "susadaptionserver.h"
+#include "susadaptionsession.h"
+#include "susadaptionclisrv.h"
+#include "suspanic.h"
+#include "ssmdebug.h"
+
+
+// ------------------- Policy Server Security Setup ----------------------
+
+const TUint  KRangeCount = 8; 
+const TInt   KRanges[KRangeCount] = // add the required ranges here
+	{ 
+	0,
+	ERequestCoopSysStateChange,     //State Adaptation Range
+	EGetSimOwned,					//Sim Adaptation Range
+	EValidateRtc,					//Rtc Adaptation Range
+	ESecurityStateChange,			//Misc Adaptation Range
+	EActivateRfForEmergencyCall,	//Emergency Call Adaptation Range
+	ESetAsPriorityClient,           //Setting Priority Client 
+	EEndOfSusAdaptionOpCodes		//Dummy
+	};
+	
+/**
+ Maps to index in the array KPolicyElements
+ */
+const TInt KCapabilitiesForRequest1 = 0;
+const TInt KCapabilitiesForRequest2 = 1;
+const TInt KSecurityCheckForRequest3 = 2;
+
+/**
+ Specifies the appropriate action to take for each range in KRanges. 
+ The n:th element of KElementsIndex specifies the appropriate action to take for the n:th range in KRanges.
+ */	
+const TUint8 KElementsIndex[KRangeCount] = 
+	{
+	CPolicyServer::ENotSupported,
+	CPolicyServer::ECustomCheck, 
+	KCapabilitiesForRequest1,
+	CPolicyServer::ECustomCheck, 
+	CPolicyServer::ECustomCheck, 
+	KCapabilitiesForRequest2,
+	KSecurityCheckForRequest3,
+	CPolicyServer::ENotSupported
+	};
+
+//ESetAsPriorityClient request is allowed only for priotity clients(Telephony). Inorder to prevent the access
+//client request will be policed using C32 SID
+#define KC32SecureId 0x10003D33
+
+/**
+ Array containing the different security checks performed by this server 
+ */
+const CPolicyServer::TPolicyElement KPolicyElements[] = 
+	{ 
+	{_INIT_SECURITY_POLICY_C1(ECapabilityReadDeviceData), CPolicyServer::EFailClient}, //lint !e778 suppress Constant expression evaluates to 0 in operation '+'
+	{_INIT_SECURITY_POLICY_C2(ECapabilityPowerMgmt, ECapabilityWriteDeviceData), CPolicyServer::EFailClient},
+	{_INIT_SECURITY_POLICY_S0(KC32SecureId), CPolicyServer::EFailClient}
+	};
+
+/**
+ Setup a security policy.
+ */
+const CPolicyServer::TPolicy KSusAdaptionServerPolicy =
+	{
+	CPolicyServer::EAlwaysPass, //specifies all connect attempts should pass
+	KRangeCount,
+	KRanges,
+	KElementsIndex, 	
+	KPolicyElements 	
+	};
+
+// ------------------- AdaptionServer Implementation ----------------------
+
+/**
+ */
+ 
+#define KSsmSecureId 0x2000D75B
+#define KAlarmServerSecureId 0x101F5027
+#define KSusSecureId 0x2000D766
+
+
+CPolicyServer::TCustomResult CSsmAdaptationServer::CustomSecurityCheckL(const RMessage2& aMsg, TInt& /*aAction*/, TSecurityInfo& /*aMissing*/)
+	{
+	CPolicyServer::TCustomResult customResult;
+	switch(aMsg.Function())
+		{
+		case ERequestCoopSysStateChange:/*State Adaptation OpCodes*/
+		case ERequestCoopSysSelfTest:
+		case ERequestCoopSysPerformRestartActions:
+		case ERequestCoopSysPerformShutdownActions:
+		case ERequestCoopSysPerformRfsActions:
+		case ERequestCoopSysCancel:
+		case ESecurityStateChange:/*Misc Adaptation OpCodes*/
+		case EGetGlobalStartupMode:
+		case EPrepareSimLanguages:
+		case EMiscCancel:
+		case EGetHiddenReset:
+		case EGetSimLanguagesArray:
+			{
+			if(aMsg.SecureId() == KSsmSecureId)
+				{
+				customResult = EPass;					
+				}
+			else
+				{
+				customResult = EFail;				
+				}
+			break;
+			}
+		case EGetLastCoopSysEvent:
+		case ENotifyCoopSysEvent:
+		case ENotifyCoopSysCancel:
+			{
+			if(aMsg.SecureId() == KSusSecureId)
+				{
+				customResult = EPass;					
+				}
+			else
+				{
+				customResult = EFail;					
+				}
+			break;
+			}			
+		case EValidateRtc:/*Rtc Adaptation OpCodes*/
+		case ERtcCancel:
+			{
+			// On licensee devices processes other than the alarm server need to check the validity of the RTC,
+			// so they should be allowed to validate the Rtc and to cancel the validate rtc request.
+			customResult = EPass;
+			break;
+			}
+		case ESetWakeupAlarm:
+		case EUnsetWakeupAlarm:
+			{
+			if(aMsg.SecureId() == KAlarmServerSecureId)
+				{
+				customResult = EPass;					
+				}
+			else
+				{
+				customResult = EFail;				
+				}
+			break;
+			}
+		default:
+			{
+			customResult = EFail;
+			break;
+			}
+		}
+		
+	return customResult;
+	}
+ 
+ 
+CSsmAdaptationServer::CSsmAdaptationServer( ): CPolicyServer(EPriorityStandard, KSusAdaptionServerPolicy)
+,iPriorityClientSession(NULL)
+	{
+	}
+
+/**
+ */
+CSsmAdaptationServer::~CSsmAdaptationServer( )
+	{
+	const TInt ignore = User::SetCritical (User::ENotCritical );
+
+	// Observers must be deleted before their corresponding adaptation
+	delete iStateAdaptationObservers;
+	iStateAdaptationObservers = NULL;
+	delete iStateAdaptation;
+	iStateAdaptation = NULL;
+	
+	// Observers must be deleted before their corresponding adaptation
+	delete iSimAdaptationObservers;
+	iSimAdaptationObservers = NULL;
+	delete iSimAdaptation;
+	iSimAdaptation = NULL;
+	
+	delete iEmergencyCallRfAdaptation;
+	iEmergencyCallRfAdaptation = NULL;
+	delete iMiscAdaptation;
+	iMiscAdaptation = NULL;
+	delete iRtcAdaptation;
+	iRtcAdaptation = NULL;
+	
+	//Delete iSusAdaptationPluginLoader after deleting all the adaptations as it will close
+	//all the loaded libraries.
+	delete iSusAdaptationPluginLoader;
+	} //lint !e529 suppress Symbol 'ignore' not subsequently referenced
+
+/**
+ */
+CSsmAdaptationServer* CSsmAdaptationServer::NewLC( )
+	{
+	CSsmAdaptationServer* server = new(ELeave) CSsmAdaptationServer();
+	CleanupStack::PushL (server );
+	server->ConstructL ( );
+	return server;
+	}
+
+/**
+ */
+void CSsmAdaptationServer::ConstructL( )
+	{
+
+	__ASSERT_ALWAYS( KErrNone == User::SetCritical(User::ESystemCritical),
+			User::Panic(KPanicSsmSus, EAdaptionServerError1));
+
+	__ASSERT_ALWAYS( KErrNone == User::RenameThread(KSusAdaptionServerName),
+			User::Panic(KPanicSsmSus, EAdaptionServerError2));
+
+	iSusAdaptationPluginLoader = CSusAdaptationPluginLoader::NewL();
+	TInt err = Start(KSusAdaptionServerName);
+#ifdef  TESTSUSADAPTATIONPLUGINLOAD_OOM
+	if (err != KErrNone && err != KErrAlreadyExists)
+		{
+		User::Leave(err);
+		}
+#else
+	User::LeaveIfError(err);
+#endif
+	}
+
+/**
+ */
+CSession2* CSsmAdaptationServer::NewSessionL(const TVersion& aVersion, const RMessage2& /*aMessage*/) const
+	{
+	// Check we're the right version
+	TVersion v(KSsmAdaptationMajorVersionNumber, KSsmAdaptationMinorVersionNumber,
+			KSsmAdaptationBuildVersionNumber);
+	if ( !User::QueryVersionSupported(v,aVersion) )
+		{
+		User::Leave (KErrNotSupported );
+		}
+
+	// version supported, go ahead
+	return CSsmAdaptationSession::NewL ( );
+	}
+void CSsmAdaptationServer::DoRequestCoopSysStateChangeL(const RMessage2& aMessage)
+	{
+	if( iStateAdaptation == NULL )
+	    {
+	    LoadStateAdaptationL();
+	    }
+	iStateAdaptation->DoRequestCoopSysStateChangeL(aMessage);
+	}
+void CSsmAdaptationServer::DoRequestCoopSysSelfTestL(const RMessage2& aMessage)
+	{
+    if( iStateAdaptation == NULL )
+        {
+        LoadStateAdaptationL();
+        }
+
+	iStateAdaptation->DoRequestCoopSysSelfTestL(aMessage);
+	}
+
+void CSsmAdaptationServer::DoRequestCoopSysPerformRestartActionsL(const RMessage2& aMessage)
+	{
+    if( iStateAdaptation == NULL )
+        {
+        LoadStateAdaptationL();
+        }
+
+	iStateAdaptation->DoRequestCoopSysPerformRestartActionsL(aMessage);
+	}
+
+void CSsmAdaptationServer::DoRequestCoopSysPerformShutdownActionsL(const RMessage2& aMessage)
+	{
+    if( iStateAdaptation == NULL )
+        {
+        LoadStateAdaptationL();
+        }
+
+	iStateAdaptation->DoRequestCoopSysPerformShutdownActionsL(aMessage);
+	}
+
+void CSsmAdaptationServer::DoRequestCoopSysPerformRfsActionsL(const RMessage2& aMessage)
+	{
+    if( iStateAdaptation == NULL )
+        {
+        LoadStateAdaptationL();
+        }
+
+	iStateAdaptation->DoRequestCoopSysPerformRfsActionsL(aMessage);
+	}
+
+void CSsmAdaptationServer::DoRequestCoopSysCancelL(const RMessage2& aMessage)
+	{
+    if( iStateAdaptation == NULL )
+        {
+        LoadStateAdaptationL();
+        }
+
+	iStateAdaptation->DoRequestCancel(aMessage);
+	}
+void CSsmAdaptationServer::DoNotifyCoopSysEventL(const RMessage2& aMessage)
+	{
+	if( iStateAdaptationObservers == NULL )
+	    {
+	    LoadStateAdaptationObserversL();
+	    }
+	iStateAdaptationObservers->DoNotifyCoopSysEventL(aMessage) ;
+	}
+void CSsmAdaptationServer::DoNotifyCoopSysEventCancelL(const RMessage2& aMessage)
+	{
+    if( iStateAdaptationObservers == NULL )
+        {
+        LoadStateAdaptationObserversL();
+        }
+	iStateAdaptationObservers->DoNotifyCoopSysEventCancelL(aMessage);
+	}
+void CSsmAdaptationServer::DoGetLastCoopSysEventL(const RMessage2& aMessage)
+	{
+    if( iStateAdaptationObservers == NULL )
+        {
+        LoadStateAdaptationObserversL();
+        }
+	iStateAdaptationObservers->DoGetLastCoopSysEvent(aMessage);
+	}
+
+//SIM ADAPTATION RELATED
+
+void CSsmAdaptationServer::DoGetSimOwnedL(const RMessage2& aMessage)
+	{
+	if( iSimAdaptation == NULL )
+	    {
+	    LoadSimAdaptationL();	    
+	    }
+
+	iSimAdaptation->DoGetSimOwnedL(aMessage);
+	}
+void CSsmAdaptationServer::DoGetSimCancelL(const RMessage2& aMessage)
+	{
+    if( iSimAdaptation == NULL )
+        {
+        LoadSimAdaptationL();       
+        }
+
+	iSimAdaptation->DoGetSimCancel(aMessage);
+	}
+void CSsmAdaptationServer::DoNotifySimEventL(const RMessage2& aMessage)
+	{
+	if( iSimAdaptationObservers == NULL )
+	    {
+	    LoadSimAdaptationObserversL();	    
+	    }
+
+	iSimAdaptationObservers->DoNotifySimEventL(aMessage);
+	}
+void CSsmAdaptationServer::DoNotifySimCancelL(const RMessage2& aMessage)
+	{
+    if( iSimAdaptationObservers == NULL )
+        {
+        LoadSimAdaptationObserversL();      
+        }
+
+	iSimAdaptationObservers->DoNotifySimEventCancelL(aMessage);
+	}
+void CSsmAdaptationServer::DoGetLastSimEventL(const RMessage2& aMessage)
+	{
+    if( iSimAdaptationObservers == NULL )
+        {
+        LoadSimAdaptationObserversL();      
+        }
+
+	iSimAdaptationObservers->DoGetLastSimEvent(aMessage);
+	}
+// RTC ADAPTATION RELATED
+
+void CSsmAdaptationServer::DoValidateRtcL(const RMessage2& aMessage)
+	{
+   if( iRtcAdaptation == NULL )
+       {
+       LoadRtcAdaptationL();       
+       }
+
+	iRtcAdaptation->DoValidateRtcL(aMessage);
+	}
+void CSsmAdaptationServer::DoSetWakeupAlarmL(const RMessage2& aMessage)
+	{
+	if( iRtcAdaptation == NULL )
+	    {
+	    LoadRtcAdaptationL();	    
+	    }
+
+	iRtcAdaptation->DoSetWakeupAlarmL(aMessage);
+	}
+void CSsmAdaptationServer::DoUnsetWakeupAlarmL(const RMessage2& aMessage)
+	{
+    if( iRtcAdaptation == NULL )
+        {
+        LoadRtcAdaptationL();
+        }
+	iRtcAdaptation->DoUnsetWakeupAlarmL(aMessage);
+	}
+void CSsmAdaptationServer::DoRtcCancelL(const RMessage2& aMessage)
+	{
+    if( iRtcAdaptation == NULL )
+        {
+        LoadRtcAdaptationL();
+        }
+	iRtcAdaptation->DoRtcCancelL(aMessage);
+	}
+
+//MISC ADAPTATION RELATED
+void CSsmAdaptationServer::DoSecurityStateChangeL(const RMessage2& aMessage)
+	{
+	if( iMiscAdaptation == NULL )
+	    {
+	    LoadMiscAdaptationL();    
+	    }
+	
+	iMiscAdaptation->DoSecurityStateChangeL(aMessage);
+	}
+void CSsmAdaptationServer::DoGetGlobalStartupModeL(const RMessage2& aMessage)
+	{
+    if( iMiscAdaptation == NULL )
+        {
+        LoadMiscAdaptationL();    
+        }
+
+	iMiscAdaptation->DoGetGlobalStartupModeL(aMessage);
+	}
+void CSsmAdaptationServer::DoPrepareSimLanguagesL(const RMessage2& aMessage)
+	{
+    if( iMiscAdaptation == NULL )
+        {
+        LoadMiscAdaptationL();    
+        }
+
+	iMiscAdaptation->DoPrepareSimLanguagesL(aMessage);
+	}
+
+void CSsmAdaptationServer::DoGetSimLanguagesArrayL(const RMessage2& aMessage)
+	{
+	if( iMiscAdaptation == NULL )
+        {
+		LoadMiscAdaptationL();
+		}
+	iMiscAdaptation->DoGetSimLanguagesArrayL(aMessage);
+
+	}
+
+void CSsmAdaptationServer::DoMiscAdaptationCancelL(const RMessage2& aMessage)
+	{
+    if( iMiscAdaptation == NULL )
+        {
+        LoadMiscAdaptationL();    
+        }
+
+	iMiscAdaptation->DoMiscAdaptationCancelL(aMessage);
+	}
+
+void CSsmAdaptationServer::DoMiscAdaptationHiddenResetL(const RMessage2& aMessage)
+	{
+    if( iMiscAdaptation == NULL )
+        {
+        LoadMiscAdaptationL();    
+        }
+
+	iMiscAdaptation->DoMiscAdaptationHiddenResetL(aMessage);
+	}
+
+//EMERGENCY CALL RF ADAPTATION RELATED 
+void CSsmAdaptationServer::DoActivateRfForEmergencyCallL(const RMessage2& aMessage)
+	{
+	if( iEmergencyCallRfAdaptation == NULL )
+	    {
+	    LoadEmergencyCallRfAdaptationL();    
+	    }
+	
+	iEmergencyCallRfAdaptation->DoActivateRfForEmergencyCallL(aMessage);
+	}
+void CSsmAdaptationServer::DoDeactivateRfForEmergencyCallL(const RMessage2& aMessage)
+	{
+    if( iEmergencyCallRfAdaptation == NULL )
+        {
+        LoadEmergencyCallRfAdaptationL();    
+        }
+
+	iEmergencyCallRfAdaptation->DoDeactivateRfForEmergencyCallL(aMessage);
+	}
+void CSsmAdaptationServer::DoEmergencyCallRfCancelL(const RMessage2& aMessage)
+	{
+    if( iEmergencyCallRfAdaptation == NULL )
+        {
+        LoadEmergencyCallRfAdaptationL();    
+        }
+
+	iEmergencyCallRfAdaptation->DoEmergencyCallRfAdaptationCancelL(aMessage);
+	}
+
+
+	
+	
+void CSsmAdaptationServer::LoadStateAdaptationL()
+	{
+	MStateAdaptation *stateAdaptationPlugin = iSusAdaptationPluginLoader->CreateStateAdaptationL();
+    CleanupReleasePushL(*stateAdaptationPlugin);
+    //From here stateAdaptationPlugin object will be owned by iStateAdaptation
+    iStateAdaptation = CStateAdaptationRequests::NewL(*stateAdaptationPlugin);
+    CleanupStack::Pop(stateAdaptationPlugin);
+	}
+
+void CSsmAdaptationServer::LoadStateAdaptationObserversL()
+	{
+	if( iStateAdaptation == NULL )
+	    {
+	    // Load the State adaptation to use it's adaptation plugin
+	    LoadStateAdaptationL();
+	    }
+	iStateAdaptationObservers = CStateAdaptationObservers::NewL(iStateAdaptation->Adaptation());
+	}
+
+void CSsmAdaptationServer::LoadSimAdaptationL()
+	{
+	MSimAdaptation *simAdaptation = iSusAdaptationPluginLoader->CreateSimAdaptationL();
+    CleanupReleasePushL(*simAdaptation);
+    //From here simAdaptation plugin object will be owned by iSimAdaptation
+    iSimAdaptation = CSimAdaptationRequests::NewL(*simAdaptation);
+    CleanupStack::Pop(simAdaptation);
+	}
+void CSsmAdaptationServer::LoadSimAdaptationObserversL()
+	{
+    if( iSimAdaptation == NULL )
+        {
+        // Load the SIM adaptation to use it's adaptation plugin
+        LoadSimAdaptationL();
+        }
+    iSimAdaptationObservers = CSimAdaptationObservers::NewL(iSimAdaptation->Adaptation());
+	}
+void CSsmAdaptationServer::LoadRtcAdaptationL()
+	{
+	MRtcAdaptation *rtcAdaptationPlugin = iSusAdaptationPluginLoader->CreateRtcAdaptationL();
+    CleanupReleasePushL(*rtcAdaptationPlugin);
+    //From here rtcAdaptationPlugin object object will be owned by iRtcAdaptation
+    iRtcAdaptation = CRtcAdaptation::NewL(*rtcAdaptationPlugin);
+    CleanupStack::Pop(rtcAdaptationPlugin);
+	}
+void CSsmAdaptationServer::LoadMiscAdaptationL()
+	{
+	MMiscAdaptation *miscAdaptationPlugin = iSusAdaptationPluginLoader->CreateMiscAdaptationL();
+    CleanupReleasePushL(*miscAdaptationPlugin);
+    //From here miscAdaptationPlugin object will be owned by iMiscAdaptation
+    iMiscAdaptation = CMiscAdaptation::NewL(*miscAdaptationPlugin);
+    CleanupStack::Pop(miscAdaptationPlugin);
+	}
+void CSsmAdaptationServer::LoadEmergencyCallRfAdaptationL()
+	{
+	MEmergencyCallRfAdaptation *emergencyCallRfAdaptationPlugin = iSusAdaptationPluginLoader->CreateEmergencyCallRfAdaptationL();
+    CleanupReleasePushL(*emergencyCallRfAdaptationPlugin);
+    //From here emergencyCallRfAdaptationPlugin object will be owned by iEmergencyCallRfAdaptation
+    iEmergencyCallRfAdaptation = CEmergencyCallRfAdaptation::NewL(*emergencyCallRfAdaptationPlugin);    
+    CleanupStack::Pop(emergencyCallRfAdaptationPlugin);
+    //Reserve memory for performing Emergency call during OOM condition
+    iEmergencyCallRfAdaptation->ReserveMemoryL();    
+	}
+
+#ifdef _DEBUG
+void CSsmAdaptationServer::UnloadAdaptationsAndObservers()
+{
+	delete iStateAdaptation;
+	iStateAdaptation = NULL;
+	delete iStateAdaptationObservers;
+	iStateAdaptationObservers = NULL;
+	delete iSimAdaptation;
+	iSimAdaptation = NULL;
+	delete iSimAdaptationObservers;
+	iSimAdaptationObservers = NULL;
+	delete iEmergencyCallRfAdaptation;
+	iEmergencyCallRfAdaptation = NULL;
+	delete iMiscAdaptation;
+	iMiscAdaptation = NULL;
+	delete iRtcAdaptation;
+	iRtcAdaptation = NULL;
+}
+#endif
+
+/**
+ * Sets the calling client as a priority client. This also loads the emergency client dll,
+ * if it is not already loaded.
+ */
+TInt CSsmAdaptationServer::SetAsPriorityClientL(CSsmAdaptationSession* aSession)
+    {
+    if(iPriorityClientSession == NULL )
+        {
+        if(iEmergencyCallRfAdaptation == NULL)
+            {
+            LoadEmergencyCallRfAdaptationL();
+            }
+        iPriorityClientSession = aSession;
+        iEmergencyCallRfAdaptation->SetPriorityClientSession(iPriorityClientSession);
+        return KErrNone;
+        }
+    return KErrAlreadyExists;
+    }
+
+/*
+ * Remove priority Client
+ */
+void CSsmAdaptationServer::RemovePriorityClient(CSsmAdaptationSession* aSession)
+    {
+    if(aSession == iPriorityClientSession)
+        {
+        iPriorityClientSession = NULL; 
+        iEmergencyCallRfAdaptation->RemovePriorityClientSession();
+        } 
+    }
+
+//RMessage2 related functionality
+//C Class
+
+void CAdaptationMessage::ReadL(TInt aParamNumber,TPtr8 aParam)
+	{
+	iMessage.ReadL(aParamNumber,aParam);			
+	}
+
+TInt CAdaptationMessage::GetDesLength(TInt aParam)
+	{
+	return iMessage.GetDesLength(aParam);
+	}
+
+TInt CAdaptationMessage::Function() const
+	{
+	return iMessage.Function();	
+	}
+
+CSession2 *CAdaptationMessage::Session() const
+	{
+	return iMessage.Session();
+	}
+
+TInt CAdaptationMessage::Int0() const
+	{
+	return iMessage.Int0();
+	}
+
+void CAdaptationMessage::WriteL(TInt aParam, const TDesC8 &aDes)
+	{
+	iMessage.WriteL(aParam,aDes);
+	}
+
+CAdaptationMessage::CAdaptationMessage(const RMessage2 &aMessage): CBase(),iMessage(aMessage)
+,iMessageAvailable(ETrue),iUsingReservedHeap(EFalse)
+	{
+	}
+ 
+void CAdaptationMessage::Complete(TInt aReason)
+	{
+	iMessage.Complete(aReason);  	
+	}
+
+
+void RSsmAdaptationRequestQueue::NotifyAndRemoveAll()
+	{
+	TInt index,count = iQueue.Count();
+	
+	for(index =0;index < count ;index++)
+		{
+		iQueue[index]->Complete(KErrServerTerminated);
+		delete iQueue[index];
+		iQueue[index] = NULL;
+		}
+	iQueue.Reset();		
+	}
+
+void RSsmAdaptationRequestQueue::NotifyAndRemoveAll(RHeap *aReservedHeap)
+    {
+    TInt index,count = iQueue.Count();
+    
+    for(index =0;index < count ;index++)
+        {
+        iQueue[index]->Complete(KErrServerTerminated);
+        if(iQueue[index]->iUsingReservedHeap)
+            {
+            aReservedHeap->Free(iQueue[index]);
+            }
+        else
+            {
+            delete iQueue[index];
+            }
+        iQueue[index] = NULL;
+        }
+    iQueue.Reset();     
+    }
+
+void RSsmAdaptationRequestQueue::Close()
+	{
+	iQueue.Close();
+	}
+TBool RSsmAdaptationRequestQueue::IsEmpty()
+	{
+	if(iQueue.Count() == 0)
+		{
+		return ETrue;	
+		}
+	else
+		{
+		return EFalse;	
+		}
+	}
+void RSsmAdaptationRequestQueue::RemoveFromQueueAndComplete(const RMessage2 &aMessage)
+	{
+
+	CAdaptationMessage *messageToBeDeleted;
+	
+	// iQueue.Count() is recalculated each time as the object is removed from the 
+	// array(which reduces the number of object pointers in the array
+	for(TInt index = 0; index < iQueue.Count(); index++ )
+		{
+		if(aMessage.Session() == iQueue[index]->Session())
+			{
+			messageToBeDeleted = iQueue[index];
+			DEBUGPRINT2A("RSsmAdaptationRequestQueue cancelling request with function id: %d", messageToBeDeleted->Function());
+			iQueue.Remove(index);
+			messageToBeDeleted->Complete(KErrCancel);
+			delete messageToBeDeleted;
+			index--;				
+			}
+		}
+	
+	}
+
+void RSsmAdaptationRequestQueue::RemoveFromQueueAndComplete(const RMessage2 &aMessage, RHeap *aReservedHeap )
+    {
+
+    CAdaptationMessage *messageToBeDeleted;
+    
+    // iQueue.Count() is recalculated each time as the object is removed from the 
+    // array(which reduces the number of object pointers in the array
+    for(TInt index = 0; index < iQueue.Count(); ++index )
+        {
+        if(aMessage.Session() == iQueue[index]->Session())
+            {
+            messageToBeDeleted = iQueue[index];
+            DEBUGPRINT2A("RSsmAdaptationRequestQueue(aMessage,ReservedHeap)called to cancel the request with function id: %d", messageToBeDeleted->Function());
+            iQueue.Remove(index);
+            messageToBeDeleted->Complete(KErrCancel);
+            if(messageToBeDeleted->iUsingReservedHeap)
+                {
+                aReservedHeap->Free(messageToBeDeleted);
+                }
+            else
+                {
+                delete messageToBeDeleted;
+                }
+            --index;
+            }
+        }
+    }
+void RSsmAdaptationRequestQueue::Dequeue(CAdaptationMessage *&aCurrentMessage)
+	{
+	aCurrentMessage = iQueue[0];
+	iQueue.Remove(0);
+	}
+TInt RSsmAdaptationRequestQueue::Queue(CAdaptationMessage *aPendingRequest)
+	{
+	return iQueue.Append(aPendingRequest);
+	} 
+
+TInt RSsmAdaptationRequestQueue::Reserve(TInt aReserverCount)
+    {
+    return(iQueue.Reserve(aReserverCount));
+    }
+
+/**
+ * Method to get number of object pointers in the Queue
+ */
+TInt RSsmAdaptationRequestQueue::Count()
+    {
+    return iQueue.Count();
+    } 
+