// Copyright (c) 2007-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:

// This file provides the implementation of the NetUps Utility Functions.

// Most / all of thes methods seem destinated to migrate into the netupsstate.cpp file.

// @internalAll

// @prototype

// 

//

#include "e32cmn.h"

#include <comms-infras/ss_activities.h>

#include "netupsaction.h"

#include "netupsassert.h"

#include "netupstypes.h"			// defines TNetUpsDecision

#include "netupsstatemachine.h"		// defines the NetUps State Machine

#include "netupsdatabaseentry.h"

#include "netupsprocessentry.h"

#include "netupsthreadentry.h"

#include "netupsprocessmonitor.h"

#include "netupsthreadmonitor.h"

#include "netupssubsession.h"

#include "netupspolicycheckrequestqueue.h"

#include "netupsstatedef.h"

#include <comms-infras/commsdebugutility.h> 		// defines the comms debug logging utility

using namespace ESock;

namespace NetUps

{

__FLOG_STMT(_LIT8(KNetUpsSubsys, 	"esock");)   

__FLOG_STMT(_LIT8(KNetUpsComponent, "NetUps");) /*esockloader*/

	namespace NetUpsFunctions 

	{

	void HandleUPSRequestL(CState& aState, TThreadKey& aThreadKey, const TPolicyCheckRequestData& aPolicyCheckRequestData, TRequestId aRequestId)

	// Process Life Time Non Session

	// Network Life Time Non Session 

	// CNullState

		{

		__FLOG_STATIC7(KNetUpsSubsys, KNetUpsComponent, _L("::HandleUPSRequestL(), processId = %d, threadId = %d, serviceId  = %d, platSecCheckResult  = %d, NodeId  = %08x, originator  = %08x, requestId = %d"),

					 aPolicyCheckRequestData.iProcessId.Id(),

					 aPolicyCheckRequestData.iThreadId.Id(),		aPolicyCheckRequestData.iServiceId,

					 aPolicyCheckRequestData.iPlatSecCheckResult, 	&aPolicyCheckRequestData.iCommsId.Node(),

					 &(aPolicyCheckRequestData.iPolicyCheckRequestOriginator), aRequestId); 

		aThreadKey.iThreadEntry.AddCommsIdL(aPolicyCheckRequestData.iCommsId);

		TRAPD(err, aThreadKey.iThreadEntry.RequestQueue().SendRequestL(aPolicyCheckRequestData, aRequestId));

		if (err != KErrNone)

			{

			// 1st back out the CommsId which we have just added, provided there are no

			// connections currently associated with it.

			aThreadKey.iThreadEntry.RemoveCommsId(aPolicyCheckRequestData.iCommsId);

			// 2nd, leave with original error, presumably KErrNoMemory

			User::Leave(err);

			}

		aState.PerformStateTransition(EPolicyCheckRequest, aThreadKey.iProcessEntry);

		}

	void HandleUpsRequestCompletion_ProcessLifeTimeNonSessionL(CState& aState, TCommsIdKey& aCommsIdKey, MPolicyCheckRequestOriginator& aPolicyCheckRequestOriginator, TNetUpsDecision aNetUpsDecision)

		{ // Tested

		// process life time, non session

		__FLOG_STATIC5(KNetUpsSubsys, KNetUpsComponent,_L("::HandleUpsRequestCompletion_ProcessLifeTimeNonSessionL(), processId = %d, threadId = %d, nodeId = %08x, aPolicyCheckRequestOriginator = %08x, netUpsDecision = %d"),

					 	aCommsIdKey.iProcessEntry.ProcessId().Id(),

					 	aCommsIdKey.iThreadEntry.ThreadId().Id(),

					 	&aCommsIdKey.iCommsId.Node(),

					 	&aPolicyCheckRequestOriginator,

					 	aNetUpsDecision );

		switch(aNetUpsDecision) 

			{			

			case ENo:

				//  if request fails, remove the record of the commsid (cosmetic).

				aCommsIdKey.iThreadEntry.RemoveCommsId(aCommsIdKey.iCommsId);

				// intended fall through

			case EYes:

				{

				__ASSERT_DEBUG((aCommsIdKey.iThreadEntry.ThreadMonitor() != NULL), User::Panic(KNetUpsPanic, KPanicNullPointer_NetUpsAction));					

				if (aCommsIdKey.iThreadEntry.ThreadMonitor()->IsActive() == EFalse)

					{

					aCommsIdKey.iThreadEntry.ThreadMonitor()->Start();						

					}

				TInt rc = aPolicyCheckRequestOriginator.ProcessPolicyCheckResponse(aNetUpsDecision, aCommsIdKey.iCommsId);

				__FLOG_STATIC1(KNetUpsSubsys, KNetUpsComponent,_L("::HandleUpsRequestCompletion_ProcessLifeTimeNonSessionL(), error = %d"), rc);

				break;	

				}

			case ESessionYes:

			case ESessionNo:

				{

				HandleUpsRequestCompletion_EnteringProcessSessionLifeTimeL(aState, aCommsIdKey, aPolicyCheckRequestOriginator, aNetUpsDecision);

				break;

				}

			default:

				{

				HandleUPSErrorOnCompletion_ProcessLifeTimeNonSessionL(aCommsIdKey, aPolicyCheckRequestOriginator, KErrCorrupt);

				break;

				}

			}

		}

	void HandleUPSErrorOnCompletion_ProcessLifeTimeNonSessionL(TCommsIdKey& aCommsIdKey, MPolicyCheckRequestOriginator& aPolicyCheckRequestOriginator, TInt aError)

		{

		__FLOG_STATIC5(KNetUpsSubsys, KNetUpsComponent,_L("::HandleUpsRequestCompletion_EnteringProcessSessionLifeTimeL(), processId = %d, threadId = %d, nodeId = %08x, aPolicyCheckRequestOriginator = %08x, netUpsDecision = %d"),

					 	aCommsIdKey.iProcessEntry.ProcessId().Id(),

					 	aCommsIdKey.iThreadEntry.ThreadId().Id(),

					 	&aCommsIdKey.iCommsId.Node(),

					 	&aPolicyCheckRequestOriginator,

					 	aError ); 

		// Remove the entry on 1st time failure	

		aCommsIdKey.iThreadEntry.RemoveCommsId(aCommsIdKey.iCommsId);

		TInt rc = aPolicyCheckRequestOriginator.ProcessPolicyCheckResponse(aError, aCommsIdKey.iCommsId);			

		__FLOG_STATIC2(KNetUpsSubsys, KNetUpsComponent,_L("::HandleUPSErrorOnCompletion_ProcessLifeTimeNonSessionL(), error = %d, rc = %d"), aError, rc );

		}

	void HandleUpsRequestCompletion_NetworkLifeTimeNonSessionL(CState& aState, TCommsIdKey& aCommsIdKey, MPolicyCheckRequestOriginator& aPolicyCheckRequestOriginator, TNetUpsDecision aNetUpsDecision)

		{ // Tested

		__FLOG_STATIC5(KNetUpsSubsys, KNetUpsComponent,_L("::HandleUpsRequestCompletion_NetworkLifeTimeNonSessionL(), processId = %d, threadId = %d, nodeId = %08x, aPolicyCheckRequestOriginator = %08x, netUpsDecision = %d"),

					 	aCommsIdKey.iProcessEntry.ProcessId().Id(),

					 	aCommsIdKey.iThreadEntry.ThreadId().Id(),

					 	&aCommsIdKey.iCommsId.Node(),

					 	&aPolicyCheckRequestOriginator,

					 	aNetUpsDecision ); 

		// network life time, non session		

		switch(aNetUpsDecision) 

			{			

			case EYes:

				{

				aCommsIdKey.iThreadEntry.IncrementConnectionCount(aCommsIdKey.iCommsId);

				__ASSERT_DEBUG((aCommsIdKey.iThreadEntry.ThreadMonitor() != NULL), User::Panic(KNetUpsPanic, KPanicNullPointer_NetUpsAction1));					

				if (aCommsIdKey.iThreadEntry.ThreadMonitor()->IsActive() == EFalse)

					{

					aCommsIdKey.iThreadEntry.ThreadMonitor()->Start();

					}

				TInt rc = aPolicyCheckRequestOriginator.ProcessPolicyCheckResponse(aNetUpsDecision, aCommsIdKey.iCommsId);

				__FLOG_STATIC1(KNetUpsSubsys, KNetUpsComponent,_L("::HandleUpsRequestCompletion_NetworkLifeTimeNonSessionL(), error = %d"), rc );

				break;

				}

			case ENo:

				{

				//  if request fails, remove the record of the commsid

				aCommsIdKey.iThreadEntry.RemoveCommsId(aCommsIdKey.iCommsId);		

				__ASSERT_DEBUG((aCommsIdKey.iThreadEntry.ThreadMonitor() != NULL), User::Panic(KNetUpsPanic, KPanicNullPointer_NetUpsAction2));					

				if (aCommsIdKey.iThreadEntry.ThreadMonitor()->IsActive() == EFalse)

					{

					aCommsIdKey.iThreadEntry.ThreadMonitor()->Start();

					}

				TInt rc = aPolicyCheckRequestOriginator.ProcessPolicyCheckResponse(aNetUpsDecision, aCommsIdKey.iCommsId);

				__FLOG_STATIC1(KNetUpsSubsys, KNetUpsComponent,_L("::HandleUpsRequestCompletion_NetworkLifeTimeNonSessionL(), error = %d"), rc );

				break;	

				}

			case ESessionYes:

			case ESessionNo:

				{

				HandleUpsRequestCompletion_EnteringNetworkSessionLifeTimeL(aState, aCommsIdKey, aPolicyCheckRequestOriginator, aNetUpsDecision);

				break;

				}

			default:

				{

				HandleUPSErrorOnCompletion_NetworkLifeTimeNonSessionL(aCommsIdKey, aPolicyCheckRequestOriginator, KErrCorrupt);

				break;

				}

			}

		}

	void HandleUPSErrorOnCompletion_NetworkLifeTimeNonSessionL(TCommsIdKey& aCommsIdKey, MPolicyCheckRequestOriginator& aPolicyCheckRequestOriginator, TInt aError)

		{

		__FLOG_STATIC5(KNetUpsSubsys, KNetUpsComponent,_L("::HandleUpsRequestCompletion_EnteringNetworkLifeTimeL(), processId = %d, threadId = %d, commsId = %08x, aPolicyCheckRequestOriginator = %08x, netUpsDecision = %d"),

					 	aCommsIdKey.iProcessEntry.ProcessId().Id(),

					 	aCommsIdKey.iThreadEntry.ThreadId().Id(),

					 	&aCommsIdKey.iCommsId.Node(),

					 	&aPolicyCheckRequestOriginator,

					 	aError ); 

		// Remove the entry on 1st time failure

		aCommsIdKey.iThreadEntry.RemoveCommsId(aCommsIdKey.iCommsId);

		TInt rc =  aPolicyCheckRequestOriginator.ProcessPolicyCheckResponse(aError, aCommsIdKey.iCommsId);			

		__FLOG_STATIC2(KNetUpsSubsys, KNetUpsComponent,_L("::HandleUPSErrorOnCompletion_NetworkLifeTimeNonSessionL(), error = %d, rc = %d"), aError, rc );

		}

	void HandleUpsRequestCompletion_EnteringProcessSessionLifeTimeL(CState& aState, TCommsIdKey& aCommsIdKey, MPolicyCheckRequestOriginator& aPolicyCheckRequestOriginator, TNetUpsDecision aNetUpsDecision)

		{ // Tested

		// process life time, entering session mode

		__FLOG_STATIC5(KNetUpsSubsys, KNetUpsComponent,_L("::HandleUpsRequestCompletion_EnteringProcessSessionLifeTimeL(), processId = %d, threadId = %d, commsId = %d, aPolicyCheckRequestOriginator = %08x, netUpsDecision = %d"),

					 	aCommsIdKey.iProcessEntry.ProcessId().Id(),

					 	aCommsIdKey.iThreadEntry.ThreadId().Id(),

					 	&aCommsIdKey.iCommsId.Node(),

					 	&aPolicyCheckRequestOriginator,

					 	aNetUpsDecision ); 

		if (CNetUpsImpl::MapInternalStateToSessionMode(aState.State()) == CNetUpsImpl::ESessionMode)

			{

			// if already in session mode, reply with session decision

			CNetUpsImpl::DetermineUpsDecision(aState.State(), aNetUpsDecision);					

			}

		else	

			{

			// otherwise not yet in session mode, so use the ups decision which has just returned.

			TEvent event;		

			aNetUpsDecision == ESessionYes ? event = EResponseSessionYes : event = EResponseSessionNo;	

			aState.PerformStateTransition(event, aCommsIdKey.iProcessEntry);

			}

		TInt rc = aPolicyCheckRequestOriginator.ProcessPolicyCheckResponse(aNetUpsDecision, aCommsIdKey.iCommsId);								

		__FLOG_STATIC1(KNetUpsSubsys, KNetUpsComponent,_L("::HandleUpsRequestCompletion_EnteringProcessSessionLifeTimeL(), error = %d"), rc );

		CleanUpThreadEntries_ProcessLifeTime(aCommsIdKey);

		if ((aCommsIdKey.iProcessEntry.ThreadEntry()).Count() == 0)

			{

			StartProcessMonitor(aCommsIdKey);

			// if thread entry count = 0, must be ready to move from Transit_Session_Yes to Session_Yes

			aState.PerformStateTransition(ETransitionForward, aCommsIdKey.iProcessEntry);

			}

		}		

	void HandleUPSErrorOnCompletion_EnteringProcessSessionLifeTimeL(CState& aState, TCommsIdKey& aCommsIdKey, MPolicyCheckRequestOriginator& aPolicyCheckRequestOriginator, TInt /*aError*/)

		{				

		// Covers the case that we are already in session life time, but outstanding UPS requests are completing

		// Simply check if ready to transition to process life time.

		// 	Determine the response to be given for all subsessions associated with this session.

		TNetUpsDecision netUpsDecision;

		CNetUpsImpl::DetermineUpsDecision(aState.State(), netUpsDecision);					

		TInt rc = aPolicyCheckRequestOriginator.ProcessPolicyCheckResponse(netUpsDecision, aCommsIdKey.iCommsId);								

		__FLOG_STATIC1(KNetUpsSubsys, KNetUpsComponent,_L("::HandleUPSErrorOnCompletion_EnteringProcessSessionLifeTimeL(), error = %d"), rc );

		CleanUpThreadEntries_ProcessLifeTime(aCommsIdKey);

		if ((aCommsIdKey.iProcessEntry.ThreadEntry()).Count() == 0)

			{

			StartProcessMonitor(aCommsIdKey);

			// if thread entry count = 0, must be ready to move from Transit_Session_Yes to Session_Yes

			aState.PerformStateTransition(ETransitionForward, aCommsIdKey.iProcessEntry);

			}

		}	

	void CleanUpThreadEntries_ProcessLifeTime(TThreadKey& aThreadKey)

		{ // Tested

		__FLOG_STATIC2(KNetUpsSubsys, KNetUpsComponent, _L("::CleanUpThreadEntries_ProcessLifeTime() processId = %d, threadId = %d"),

				 		aThreadKey.iProcessEntry.ProcessId().Id(), aThreadKey.iThreadEntry.ThreadId().Id() ); 

		// 1st detach this subsession so it can be deleted inside CSubSession::RunL() 

		// which is the top of this calling stack.

		__ASSERT_DEBUG((aThreadKey.iThreadEntry.SubSession() != NULL), User::Panic(KNetUpsPanic, KPanicInvalidLogic));

		aThreadKey.iThreadEntry.SubSession()->SetReadyForDeletion();

		aThreadKey.iThreadEntry.SetSubSession(NULL);			

		// now clean up everything other than the current entry on the queue, 

		// which is currently being processed and will be deleted by the subsession.

		TNetUpsDecision netUpsDecision;

		aThreadKey.iProcessEntry.UpsStateMachine().NetUpsImpl().DetermineUpsDecision(aThreadKey.iProcessEntry.NetUpsState(), netUpsDecision);

		ReplyOutStandingRequests(aThreadKey, netUpsDecision);

		// Code to bottom is used in method below, consider cloning

		TInt count = aThreadKey.iProcessEntry.ThreadEntry().Count();

		for (TInt i = count - 1; i >= 0; --i)

			{

			TBool readyToDelete = ETrue;

			CThreadEntry* threadEntry = aThreadKey.iProcessEntry.ThreadEntry()[i];

			if (threadEntry->ThreadMonitor() != NULL)

				{

				// Note: An active object remains active until immediately before its RunL is executed.

				if (aThreadKey.iProcessEntry.ThreadEntry()[i]->ThreadMonitor()->IsActive() != EFalse)

					{

					threadEntry->ThreadMonitor()->Cancel();

					}

				delete threadEntry->ThreadMonitor();

				threadEntry->SetThreadMonitor(NULL);

				}

			if (threadEntry->SubSession() != NULL)

				{

				if (threadEntry->SubSession()->IsActive() == EFalse)

					{

					delete threadEntry->SubSession();

					threadEntry->SetSubSession(NULL);

					}

				else

					{

					readyToDelete = EFalse;

					TThreadKey threadKey(aThreadKey.iDatabaseEntry, aThreadKey.iProcessEntry, *threadEntry);

					ReplyOutStandingRequests(threadKey, netUpsDecision);

					}				

				}

			if (readyToDelete)

				{		

				delete threadEntry;

				aThreadKey.iProcessEntry.ThreadEntry().Remove(i);						

				}									

			}

		}

	void HandleUpsRequestCompletion_EnteringNetworkSessionLifeTimeL(CState& aState, TCommsIdKey& aCommsIdKey, MPolicyCheckRequestOriginator& aPolicyCheckRequestOriginator, TNetUpsDecision aNetUpsDecision)

		{ // Tested

		// network life time, non session mode

		__FLOG_STATIC5(KNetUpsSubsys, KNetUpsComponent,_L("::HandleUpsRequestCompletion_EnteringNetworkSessionLifeTimeL(), processId = %d, threadId = %d, commsId = %d, aPolicyCheckRequestOriginator = %08x, netUpsDecision = %d"),

					 	aCommsIdKey.iProcessEntry.ProcessId().Id(),

					 	aCommsIdKey.iThreadEntry.ThreadId().Id(),

					 	&aCommsIdKey.iCommsId.Node(),

					 	&aPolicyCheckRequestOriginator,

					 	aNetUpsDecision ); 

		if (CNetUpsImpl::MapInternalStateToSessionMode(aState.State()) == CNetUpsImpl::ESessionMode)

			{

			// if already in session mode, reply with session decision

			CNetUpsImpl::DetermineUpsDecision(aState.State(), aNetUpsDecision);		

			}

		if (aNetUpsDecision == ESessionYes)

			{

			aCommsIdKey.iThreadEntry.IncrementConnectionCount(aCommsIdKey.iCommsId);

			}		

		TInt rc = aPolicyCheckRequestOriginator.ProcessPolicyCheckResponse(aNetUpsDecision, aCommsIdKey.iCommsId);					

		__FLOG_STATIC1(KNetUpsSubsys, KNetUpsComponent,_L("::HandleUpsRequestCompletion_EnteringNetworkSessionLifeTimeL(), error = %d"), rc );

		CleanUpThreadEntries_NetworkLifeTime(aState, aCommsIdKey, aNetUpsDecision);

		}			

	void HandleUPSErrorOnCompletion_EnteringNetworkSessionLifeTimeL(CState& aState, TCommsIdKey& aCommsIdKey, MPolicyCheckRequestOriginator& aPolicyCheckRequestOriginator, TInt aError)

		{

		// network life time, non session mode

#ifndef _DEBUG

		(void) aError;

#endif

		__FLOG_STATIC5(KNetUpsSubsys, KNetUpsComponent,_L("::CleanUpThreadEntries_NetworkLifeTime(), processId = %d, threadId = %d, commsId = %d, aPolicyCheckRequestOriginator = %08x, netUpsDecision = %d"),

					 	aCommsIdKey.iProcessEntry.ProcessId().Id(),

					 	aCommsIdKey.iThreadEntry.ThreadId().Id(),

					 	&aCommsIdKey.iCommsId.Node(),

					 	&aPolicyCheckRequestOriginator,

					 	aError ); 

		// 	Determine the response to be given for all subsessions associated with this session.

		TNetUpsDecision netUpsDecision = ENo;

		CNetUpsImpl::DetermineUpsDecision(aState.State(), netUpsDecision);					

		TInt rc = aPolicyCheckRequestOriginator.ProcessPolicyCheckResponse(netUpsDecision, aCommsIdKey.iCommsId);								

		__FLOG_STATIC1(KNetUpsSubsys, KNetUpsComponent,_L("::HandleUPSErrorOnCompletion_EnteringNetworkSessionLifeTimeL(), error = %d"), rc );

		CleanUpThreadEntries_NetworkLifeTime(aState, aCommsIdKey, netUpsDecision);					

		}

	void CleanUpThreadEntries_NetworkLifeTime(CState& aState, TCommsIdKey& aCommsIdKey, TNetUpsDecision aNetUpsDecision)

		{ // Tested

		// 1st detach this subsession so it can be deleted inside CSubSession::RunL() 

		// which is the top of this calling stack.

		__FLOG_STATIC4(KNetUpsSubsys, KNetUpsComponent,_L("::CleanUpThreadEntries_NetworkLifeTime(), processId = %d, threadId = %d, commsId = %d, netUpsDecision = %d"),

				 aCommsIdKey.iProcessEntry.ProcessId().Id(),

				 aCommsIdKey.iThreadEntry.ThreadId().Id(),

				 &aCommsIdKey.iCommsId.Node(),

				 aNetUpsDecision ); 

		__ASSERT_DEBUG((aCommsIdKey.iThreadEntry.SubSession() != NULL), User::Panic(KNetUpsPanic, KPanicInvalidLogic));

		aCommsIdKey.iThreadEntry.SubSession()->SetReadyForDeletion();

		aCommsIdKey.iThreadEntry.SetSubSession(NULL);			

		ReplyOutStandingRequests(aCommsIdKey, aNetUpsDecision);

		TBool allActiveObjectsCompleted = ETrue;

		TInt count = aCommsIdKey.iProcessEntry.ThreadEntry().Count();

		for (TInt i = 0; i < count; i++)

			{

			CThreadEntry* threadEntry = aCommsIdKey.iProcessEntry.ThreadEntry()[i];

			if (threadEntry->ThreadMonitor() != NULL)

				{

				// Note: An active object remains active until immediately before its RunL is executed.				

				if (threadEntry->ThreadMonitor()->IsActive() != EFalse)

					{

					threadEntry->ThreadMonitor()->Cancel();

					}

				delete threadEntry->ThreadMonitor();

				threadEntry->SetThreadMonitor(NULL);

				}

			if (threadEntry->SubSession() != NULL)

				{

				// Note: An active object remains active until immediately before its RunL is executed.				

				if (threadEntry->SubSession()->IsActive() == EFalse)

					{

					delete threadEntry->SubSession();

					threadEntry->SetSubSession(NULL);

					}

				else

					{

					allActiveObjectsCompleted = EFalse;

					TThreadKey threadKey(aCommsIdKey.iDatabaseEntry, aCommsIdKey.iProcessEntry, *threadEntry);

					ReplyOutStandingRequests(threadKey, aNetUpsDecision);

					}	

				}

			}

		__ASSERT_DEBUG(((aNetUpsDecision == ESessionYes) || (aNetUpsDecision == ESessionNo)), User::Panic(KNetUpsPanic, KPanicInvalidLogic));

		if (aNetUpsDecision == ESessionYes)

			{				

			PerformTransitionFromNetworkLifeTimeNonSession(aState, EResponseSessionYes, aCommsIdKey, allActiveObjectsCompleted);			

			}

		else if (aNetUpsDecision == ESessionNo)

			{

			TInt count = aCommsIdKey.iProcessEntry.ThreadEntry().Count();

			TBool allCountsZero = ETrue;

			for (TInt i = 0; i < count; i++)

				{

				if ( (aCommsIdKey.iProcessEntry.ThreadEntry())[i]->ConnectionCount() != 0 )

					{

					allCountsZero = EFalse;

					break;

					}

				}

			if (allCountsZero)

				{

				PerformTransitionFromNetworkLifeTimeNonSession(aState, EResponseSessionNo_WithoutConnections, aCommsIdKey, allActiveObjectsCompleted);			

				}	

			else

				{

				PerformTransitionFromNetworkLifeTimeNonSession(aState, EResponseSessionNo_WithConnections, aCommsIdKey, allActiveObjectsCompleted);			

				}			

			}

		}

	void HandleProcessTermination(TProcessKey& aProcessKey)

		{ // Not Tested

		// Needed for process life time - session Yes / session No

		__FLOG_STATIC1(KNetUpsSubsys, KNetUpsComponent, _L("::HandleProcessTermination() processId = %d"), aProcessKey.iProcessEntry.ProcessId().Id()); 

		TBool retainProcessMonitor = ETrue;

		DeleteProcessEntry(aProcessKey, retainProcessMonitor);

		}

	void HandleThreadTermination_DeleteThreadEntry(TThreadKey& aThreadKey)

		{ // Tested

		// Could add reason for thread termination, but end result is the same.

		// Handles the following states:

		// Process Life Time Non Session - No Movement

		// Network Life Time Non Session - No Movement		

		// The thread monitors should be cancelled before entry into any other state.

		TNetUpsState state = aThreadKey.iProcessEntry.NetUpsState();

		__ASSERT_DEBUG(((state == EProcLife_NonSession) || (state == ENetLife_NonSession)), User::Panic(KNetUpsPanic, KPanicInvalidLogic));

		__FLOG_STATIC2(KNetUpsSubsys, KNetUpsComponent, _L("::HandleThreadTermination_DeleteThreadEntry() processId = %d, threadId = %d"),

				 		aThreadKey.iProcessEntry.ProcessId().Id(), aThreadKey.iThreadEntry.ThreadId().Id() ); 

		CThreadEntry& threadEntry = aThreadKey.iThreadEntry;

		threadEntry.SetThreadMonitor(NULL); // Set the thread monitor to NULL, as  currently called

											// from threadMonitor RunL, which deletes itself at end of RunL.

		if (aThreadKey.iThreadEntry.SubSession() != NULL) 

			{

			// cancel all requests and reply back with KErrDied to the originator.

			threadEntry.RequestQueue().CancelAllRequests(KErrDied);

			DeleteThreadEntry(aThreadKey);						

			if (aThreadKey.iProcessEntry.ThreadEntry().Count() == 0)		

				{

				DeleteProcessEntry(aThreadKey);

				}				

			}

		}

	void IncrementConnectionCountL(TCommsIdKey&)

		{

		__FLOG_STATIC0(KNetUpsSubsys, KNetUpsComponent, _L("::IncrementConnectionCountL"));

		User::Panic(KNetUpsPanic, KPanicMethodNotSupported);

		}				

	void DecrementConnectionCount_NetworkLifeTime_SessionL(TCommsIdKey& aCommsIdKey)

		{ // Tested

		// Network Lifetime - Session No - MCPR Count

		// Network Lifetime - Session Yes

		// Remove the comms id 1st

		//  

		__FLOG_STATIC3(KNetUpsSubsys, KNetUpsComponent, _L("::DecrementConnectionCount_NetworkLifeTime_SessionL(), processId = %d, threadId = %d, commsId = %d, aError = %d"),

					 aCommsIdKey.iProcessEntry.ProcessId().Id(),

					 aCommsIdKey.iThreadEntry.ThreadId().Id(),

					 &aCommsIdKey.iCommsId.Node()); 

		TNetUpsState state = aCommsIdKey.iProcessEntry.NetUpsState();

		__ASSERT_DEBUG(((state == ENetLife_Transit_SessionYes) 					||

						(state == ENetLife_SessionYes) 							||

						(state == ENetLife_SessionNo_Transit_WithConnections) 	||

						(state == ENetLife_SessionNo_WithConnections)),

						User::Panic(KNetUpsPanic, KPanicInvalidLogic));

		DecrementConnectionCount_NetworkLifeTime_NonSessionL(aCommsIdKey);

		if (aCommsIdKey.iProcessEntry.ThreadEntry().Count() == 0)

			{

			TProcessKey processKey(aCommsIdKey.iDatabaseEntry, aCommsIdKey.iProcessEntry);

			DeleteProcessEntry(processKey);				

			}			

		}				

	void DecrementConnectionCount_NetworkLifeTime_NonSessionL(TCommsIdKey& aCommsIdKey)

		{ // Tested

		__FLOG_STATIC3(KNetUpsSubsys, KNetUpsComponent, _L("::DecrementConnectionCount_NetworkLifeTime_NonSessionL(), processId = %d, threadId = %d, commsId = %d, aError = %d"),

					 aCommsIdKey.iProcessEntry.ProcessId().Id(),

					 aCommsIdKey.iThreadEntry.ThreadId().Id(),

					 &aCommsIdKey.iCommsId.Node());