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

// SS_CONN.CPP

// 

//

#include "ss_connselect.h"

#include <comms-infras/ss_log.h>

#include "SS_conn.H"

#include <comms-infras/esock_params_internal.h>

#include <comms-infras/ss_nodemessages_selector.h>

#include <elements/nm_messages_base.h>

#include <elements/nm_messages_peer.h>

#include <comms-infras/ss_nodemessages_dataclient.h>

#include <comms-infras/ss_nodemessages_factory.h>

#include <comms-infras/ss_nodemessages_internal.h>

#ifdef _DEBUG

// Panic category for "absolutely impossible!" vanilla ASSERT()-type panics from this module

// (if it could happen through user error then you should give it an explicit, documented, category + code)

_LIT(KSpecAssert_ESockSSockscnslc, "ESockSSockscnslc");

#endif

using namespace ESock;

using namespace Messages;

using namespace MeshMachine;

//

//CSelectionRequest

CSelectionRequest* CSelectionRequest::NewL(const TRuntimeCtxId& aRequestingClient, const TNodeId& aTierManagerId)

	{

	CSelectionRequest* self = new (ELeave) CSelectionRequest(aRequestingClient,aTierManagerId);

	NM_LOG_START_BLOCK(KESockMetaConnectionTag(), _L8("CSelectionRequest::NewL"));

	NM_LOG((KESockMetaConnectionTag(), _L8("[this=0x%08x]"), self));

	NM_LOG_ADDRESS_EXT(KESockMetaConnectionTag(), aRequestingClient, _L8("Client:"));

	NM_LOG_ADDRESS_EXT(KESockMetaConnectionTag(), aTierManagerId, _L8("TierMgr:"));

	NM_LOG_END_BLOCK(KESockMetaConnectionTag(), KNullDesC8());

	return self;

	}

CSelectionRequest::CSelectionRequest(const TRuntimeCtxId& aRequestingClient, const TNodeId& aTierManagerId)

:	Messages::ASimpleNodeIdBase(),

	TIfStaticFetcherNearestInHierarchy(this),

	iTierManagerId(aTierManagerId),

	iSelectionStatus(EIdle),

	iPlatsecApiExt(NULL)

	{

	LOG_NODE_CREATE(KESockMetaConnectionTag, CSelectionRequest);

	iRequestingNode.Open(address_cast<TNodeId>(aRequestingClient));

	iRequest.Open(iRequestingNode, aRequestingClient);

	}

CSelectionRequest::~CSelectionRequest()

	{

	if (iPlatsecApiExt != NULL)

		delete iPlatsecApiExt;

	iRequestingNode.Close();

	//Properly handled CSR should either complete the request or be cancelled before being destroyed.

	//If the requesting client wants to cancel its request with this CSR, it sends a cancel message.

	//The cancel message is processed (all active requests are being cancelled) and when all complete

	//with error (or select complete) messages, then the error is being send to the requesting client.

	//The requesting client must wait for this error (confirmation to its cancel message) and then

	//it can destroy this CSR, not earlier.

	//This is why we must make sure that iActiveRequests is empty.

	//If this ASSERT fires in your case, make sure that the requesting client obeys the above mentioned

	//protocol.

	__ASSERT_DEBUG(iActiveRequests.Count()==0, User::Panic(KSpecAssert_ESockSSockscnslc, 1));

	iActiveRequests.Close();

	//The client decided to destroy us.

	//Regardless if we received or didn't receive TSelect, iTopMcprId must be empty now.

	__ASSERT_DEBUG(iTopMcprId.IsNull(), User::Panic(KSpecAssert_ESockSSockscnslc, 2));

	LOG_NODE_DESTROY(KESockMetaConnectionTag, CSelectionRequest);

	}

//The entry point to the selector. It may be replaced by the mesh machine in the future.

void CSelectionRequest::ReceivedL(const TRuntimeCtxId& aSender, const TNodeId& /*aRecipient*/, TSignatureBase& aCFMessage)

    {

	if (TEBase::ERealmId == aCFMessage.MessageId().Realm())

		{

		switch (aCFMessage.MessageId().MessageId())

			{

		case TEBase::TCancel::EId :

			__ASSERT_DEBUG(iRequestingNode == aSender, User::Panic(KSpecAssert_ESockSSockscnslc, 3));

			Cancel();

			break;

		case TEBase::TError::EId:

			{

			TEBase::TError& error = message_cast<TEBase::TError>(aCFMessage);

			if (iSelectionStatus==ERequestingCommsBinder)

			    {

			    CommsBinderRequestError(aSender,error);

			    }

			else if(error.iMsgId == TCFDataClient::TBindToComplete::Id())

			    {

			    if (KErrNone==iOriginalError)

			        {

			        iOriginalError = error.iValue;

			        }

	            // Send TCFServiceProvider::TBindToComplete to complete BinderRequest

	            __ASSERT_DEBUG(!iTopMcprId.IsNull(), User::Panic(KSpecAssert_ESockSSockscnslc, 43)); //iTopMcprId must be selected by now!

	            RNodeInterface::OpenPostMessageClose(Id(), iTopMcprId, TCFServiceProvider::TBindToComplete(error.iValue).CRef());

			    }

			else

			    {

				if (error.iMsgId == TCFSelector::TSimpleSelect::Id()

					|| error.iMsgId == TCFSelector::TSelect::Id())

					{

					//TSelect may be used by CConnection or the TopMcpr

					//In both cases the control client must leave on an error.

					TInt idx = FindActiveRequest(aSender);

					if (idx != KErrNotFound && !(iActiveRequests[idx].Flags() & TClientType::ELeaving))

						{

						RNodeInterface::OpenPostMessageClose(Id(), aSender, TEChild::TLeft().CRef());

						iActiveRequests[idx].SetFlags(TClientType::ELeaving);

	                    if (aSender == iTopMcprId)

	                        {

	                        iTopMcprId.SetNull();

	                        }						

						}

					}

				SelectionError(aSender, error.iValue);

				}

			}

			break;

		default:

//TODO - logging

			NM_LOG_START_BLOCK(KESockMetaConnectionTag(), _L8("CSelectionRequest:ReceivedL"));

			NM_LOG((KESockMetaConnectionTag(), _L8("[this=0x%08x] ERROR: KErrNotSupported "), this));

			NM_LOG_MESSAGE(KESockMetaConnectionTag(), aCFMessage);

			NM_LOG_END_BLOCK(KESockMetaConnectionTag(), KNullDesC8());

	    		__ASSERT_DEBUG(iRequestingNode==aSender, User::Panic(KSpecAssert_ESockSSockscnslc, 4));

			__ASSERT_DEBUG(EFalse, User::Panic(KSpecAssert_ESockSSockscnslc, 5)); //For debug configurations

			User::Leave(KErrNotSupported); //For release configurations

			}

		}

	else if ( aCFMessage.IsMessage<TEChild::TDestroy>() )

		{

		__ASSERT_DEBUG(iRequestingNode==aSender, User::Panic(KSpecAssert_ESockSSockscnslc, 6));

		InitialiseDestroy();

		}

	else if (TEPeer::ERealmId == aCFMessage.MessageId().Realm())

		{

		switch (aCFMessage.MessageId().MessageId())

			{

		case TEPeer::TLeaveComplete::EId:

			__ASSERT_DEBUG(aSender==iTopMcprId || iTopMcprId.IsNull(), User::Panic(KSpecAssert_ESockSSockscnslc, 7));

			iTopMcprId.SetNull();

			delete this;

			break;

		default:

//TODO - logging

			NM_LOG_START_BLOCK(KESockMetaConnectionTag(), _L8("CSelectionRequest:ReceivedL"));

			NM_LOG((KESockMetaConnectionTag(), _L8("[this=0x%08x] ERROR: KErrNotSupported "), this));

			NM_LOG_MESSAGE(KESockMetaConnectionTag(), aCFMessage);

			NM_LOG_END_BLOCK(KESockMetaConnectionTag(), KNullDesC8());

			__ASSERT_DEBUG(EFalse, User::Panic(KSpecAssert_ESockSSockscnslc, 8)); //For debug configurations

			User::Leave(KErrNotSupported); //For release configurations

			}

		}

	else if (TCFSelector::ERealmId == aCFMessage.MessageId().Realm())

		{

		switch (aCFMessage.MessageId().MessageId())

			{

    	case TCFSelector::TSelect::EId:

    		__ASSERT_DEBUG(aSender == iRequestingNode.RecipientId(), User::Panic(KSpecAssert_ESockSSockscnslc, 9));

    		SelectConnPrefList(message_cast<const TCFSelector::TSelect>(aCFMessage).iConnPrefList);

    		break;

		case TCFSelector::TSimpleSelect::EId:

			__ASSERT_DEBUG(iRequestingNode == aSender, User::Panic(KSpecAssert_ESockSSockscnslc, 10));

			iRequest.Open(iRequestingNode, aSender);

			Select(message_cast<const TCFSelector::TSimpleSelect>(aCFMessage).iSelectionPrefs);

			break;

		case TCFSelector::TSelectComplete::EId:

			{

			TCFSelector::TSelectComplete& msg = message_cast<TCFSelector::TSelectComplete>(aCFMessage);

			SelectComplete(address_cast<TNodeId>(aSender), msg.iNodeId, msg.iProviderInfo);

			}

			break;

		default:

//TODO - logging

			NM_LOG_START_BLOCK(KESockMetaConnectionTag(), _L8("CSelectionRequest:ReceivedL"));

			NM_LOG((KESockMetaConnectionTag(), _L8("[this=0x%08x] ERROR: KErrNotSupported "), this));

			NM_LOG_MESSAGE(KESockMetaConnectionTag(), aCFMessage);

			NM_LOG_END_BLOCK(KESockMetaConnectionTag(), KNullDesC8());

			__ASSERT_DEBUG(EFalse, User::Panic(KSpecAssert_ESockSSockscnslc, 11)); //For debug configurations

			User::Leave(KErrNotSupported); //For release configurations

			}

		}

	else if ( aCFMessage.IsMessage<TCFServiceProvider::TCommsBinderResponse>() )

		{

		CommsBinderResponse(message_cast<TCFServiceProvider::TCommsBinderResponse>(aCFMessage));

		}

	else if ( aCFMessage.IsMessage<TCFDataClient::TBindToComplete>() )

		{

		__ASSERT_DEBUG(iRequestingNode==aSender, User::Panic(KSpecAssert_ESockSSockscnslc, 12));

		__ASSERT_DEBUG(iSelectionStatus==ERequestingCommsBinder || iSelectionStatus==EIdle, User::Panic(KSpecAssert_ESockSSockscnslc, 13));

		__ASSERT_DEBUG(!iTopMcprId.IsNull(), User::Panic(KSpecAssert_ESockSSockscnslc, 14)); //iTopMcprId must be selected by now!

		// Notify the service provider to complete binding activity (TCFServiceProvider::TCommsBinderRequest)

		RNodeInterface::OpenPostMessageClose(Id(), iTopMcprId, TCFServiceProvider::TBindToComplete().CRef());

		}

	else if ( aCFMessage.IsMessage<TCFMessage::TStateChange>() )

		{

		if (!iDestroying)

			{

			// When destroying prevent the status change being posted to

			// the Implicit Flow Request which may already have been deleted.

			iRequestingNode.PostMessage(Id(), aCFMessage);

			}

		}

	else if ( aCFMessage.IsMessage<TCFMessage::TProvisionConnectionInfo>() )

		{

		__ASSERT_DEBUG(iRequestingNode == aSender, User::Panic(KSpecAssert_ESockSSockscnslc, 15));

		Provision(message_cast<const TCFMessage::TProvisionConnectionInfo>(aCFMessage).iPtr);

		}

	else if ( aCFMessage.IsMessage<TCFPeer::TJoinComplete>() )

		{

		JoinComplete(address_cast<TNodeId>(aSender), message_cast<TCFPeer::TJoinComplete>(aCFMessage));

		}

	else

		{

//TODO - logging

		NM_LOG_START_BLOCK(KESockMetaConnectionTag(), _L8("CSelectionRequest:ReceivedL"));

		NM_LOG((KESockMetaConnectionTag(), _L8("[this=0x%08x] ERROR: KErrNotSupported "), this));

		NM_LOG_MESSAGE(KESockMetaConnectionTag(), aCFMessage);

		NM_LOG_END_BLOCK(KESockMetaConnectionTag(), KNullDesC8());

		__ASSERT_DEBUG(EFalse, User::Panic(KSpecAssert_ESockSSockscnslc, 16)); //For debug configurations

		User::Leave(KErrNotSupported); //For release configurations

		}

	}

void CSelectionRequest::InitialiseDestroy()

	{

	__ASSERT_DEBUG(!iDestroying, User::Panic(KSpecAssert_ESockSSockscnslc, 17));

	iDestroying = ETrue;

    if (iActiveRequests.Count()!=0)

    	{

      /*

      Unfortunatelly today the parent of 'this' (CConnection or CFlowRequest) doesn't handle ownership

      with 'this' very well and it may (in cancelation scenarios it will) bail out right after posting TDestroy

      to 'this'. This is not good because the TSelect protocol carries data owned by the parent (selection preferences)

      and MCPRs may attempt to access them after the owner/parent has gone away. We're making it illegal for the

      parent to post TDestroy before all requests are completed. Consequently before posting TDestroy the parent 

      must make sure the selection is complete by awaiting response to the TSelect protocol. If it wants to

      terminate selection it _must_ send TCancel (and await responses) before posting TDestroy.

      */

        __ASSERT_DEBUG(EFalse, User::Panic(KSpecAssert_ESockSSockscnslc, 44)); 

    	return;

    	}

	//We have never joined the top mcpr, clear it now

	if (!iJoined)

		{

		iTopMcprId.SetNull();

		}

	//We are ready but we have to leave the iTopMcprId first

	if (!iTopMcprId.IsNull())

    	{

    	RNodeInterface::OpenPostMessageClose(Id(), iTopMcprId, TEPeer::TLeaveRequest().CRef());

		return;

    	}

   	//We are ready to be deleted

   	delete this;

   	return;

	}

//Selection requests start here.

void CSelectionRequest::Select(const TSelectionPrefs& aSelectionPreferences)

	{

    NM_LOG_START_BLOCK(KESockMetaConnectionTag(), _L8("CSelectionRequest::Select"));

	NM_LOG_ADDRESS_EXT(KESockMetaConnectionTag(), iRequestingNode.RecipientId(), _L8("Client:"));

	NM_LOG((KESockMetaConnectionTag(), _L8("[this=0x%08x]"), this));

    NM_LOG_STMT(TUint selectionScope = aSelectionPreferences.Scope());

	NM_LOG((KESockMetaConnectionTag(), _L8("%s"), (selectionScope & TSelectionPrefs::EExplicitConnection)?_S8("EExplicitConnection"):_S8("SelectTopProviderOnly")));

	LOG( ESockLog::Printf(KESockMetaConnectionTag, _L8("CSelectionRequest %08x:\tSelect: %s."), this, (selectionScope&TSelectionPrefs::ESelectFromExisting)?_S8("ESelectFromExisting"):_S8("SelectAndCreate")));

	LOG( ESockLog::Printf(KESockMetaConnectionTag, _L8("CSelectionRequest %08x:\tSelect: %s."), this, (selectionScope&TSelectionPrefs::ERequestCommsBinder)?_S8("ERequestCommsBinder"):_S8("DoNotRequestCommsBinder")));

    NM_LOG_END_BLOCK(KESockMetaConnectionTag(), KNullDesC8());

	//The requesting client may only request selection once.

	//If this assert fires in your case, please make sure the requesting client obeys the protocol.

	__ASSERT_DEBUG(iSelectionStatus==EIdle, User::Panic(KSpecAssert_ESockSSockscnslc, 18));

	__ASSERT_DEBUG(iTopMcprId.IsNull(), User::Panic(KSpecAssert_ESockSSockscnslc, 19));

	iSelectionStatus = ESelecting;

	iSelectionPreferences.Copy(aSelectionPreferences);

	__ASSERT_DEBUG(iActiveRequests.Count()==0, User::Panic(KSpecAssert_ESockSSockscnslc, 20));

	if (KErrNone==iActiveRequests.Append(RNodeInterface()))

		{

		RNodeInterface& tierManager = iActiveRequests[0];

		tierManager.Open(iTierManagerId);

		tierManager.PostMessage(Id(), TCFPeer::TJoinRequest(Id(), TClientType(TCFClientType::ECtrl)).CRef());

		}

	else

		{

		//We have an OOM condition here. Since we have just started serving this request,

		//we must report this error to the requesting client (see SelectError()).

		SelectionError(Id(), KErrNoMemory);

		}

	}

void CSelectionRequest::SelectConnPrefList(const RConnPrefList& aConnPrefList)

	{

	//The requesting client may only request selection once.

	//If this assert fires in your case, please make sure the requesting client obeys the protocol.

	__ASSERT_DEBUG(iSelectionStatus == EIdle, User::Panic(KSpecAssert_ESockSSockscnslc, 21));

	__ASSERT_DEBUG(iTopMcprId == TNodeId::NullId(), User::Panic(KSpecAssert_ESockSSockscnslc, 22));

	iSelectionStatus = ESelecting;

	iConnPrefList = aConnPrefList;

	ESock::RConnPrefList::TIter<TConnCSRPref> iterCSR = iConnPrefList.getIter<TConnCSRPref>();

	//There should be one and only one CSR pref

	__ASSERT_DEBUG(iterCSR[0] != NULL || iterCSR[1] == NULL , User::Panic(KSpecAssert_ESockSSockscnslc, 23));

	TConnCSRPref* pref = iterCSR[0];

	iSelectionPreferences.SetScope(pref->Scope());

	iSelectionPreferences.SetFlags(pref->Flags());

	iSelectionPreferences.SetSubSessionUniqueId(pref->Scope());

	__ASSERT_DEBUG(iActiveRequests.Count()==0, User::Panic(KSpecAssert_ESockSSockscnslc, 24));

	if (KErrNone==iActiveRequests.Append(RNodeInterface()))

		{

		RNodeInterface& tierManager = iActiveRequests[iActiveRequests.Count()-1];

		tierManager.Open(iTierManagerId);

		tierManager.PostMessage(

			Id(),

			TCFPeer::TJoinRequest(Id(), TClientType(TCFClientType::ECtrl)).CRef()

			);

		}

	else

		{

		//We have an OOM condition here. Since we have just started serving this request,

		//we must report this error to the requesting client (see SelectError()).

		SelectionError(Id(), KErrNoMemory);

		}

	}

void CSelectionRequest::Provision(const Meta::SMetaData* aProvisionConfig)

	{

/*	if (!aProvisionConfig->IsTypeOf(STypeId::CreateSTypeId(CConnectionInfo::EUid, CConnectionInfo::ETypeId)))

	return;*/

	iProvision = aProvisionConfig;

	}

void CSelectionRequest::Cancel()

	{

	NM_LOG_START_BLOCK(KESockMetaConnectionTag(), _L8("CSelectionRequest::Cancel"));

	NM_LOG((KESockMetaConnectionTag, _L8("[this=0x%08x]"), this));

	NM_LOG_ADDRESS_EXT(KESockMetaConnectionTag(), iRequestingNode.RecipientId(), _L8("Client:"));

	NM_LOG_END_BLOCK(KESockMetaConnectionTag(), KNullDesC8());

	//Is the requesting client trying to cancel its request again?

	__ASSERT_DEBUG(iSelectionStatus!=ECancelling, User::Panic(KSpecAssert_ESockSSockscnslc, 25));

	if (iSelectionStatus!=EIdle)

		{

		iSelectionStatus = ECancelling;

		iOriginalError = KErrCancel;

		TEBase::TCancel cancel;

		for (TInt i = iActiveRequests.Count()-1; i >= 0; i--)

			{

			//Send cancel and wait for error messages before destructing this object.

			iActiveRequests[i].PostMessage(Id(), cancel);

			}

		//We have not completed the original request yet, do not send

		//an error message to the requesting client from here.

		//When the last error (or select complete) message has been returned

		//from the last MCpr we have cancelled, then we send our cancel's

		//confirmation from SelectionFinished().

		}

	}

void CSelectionRequest::JoinComplete(const TNodeId& aSender, TCFPeer::TJoinComplete& /*aCFMessage*/)

	{

	if (KErrNone==iOriginalError)

		{

		if (iTopMcprId.IsNull())

			{

			__ASSERT_DEBUG(iActiveRequests[0].RecipientId()==aSender && iTierManagerId==aSender, User::Panic(KSpecAssert_ESockSSockscnslc, 26)); //It has surely been sent by the tier manager.

			if(iConnPrefList.Count() < 1)

				{

				iActiveRequests[0].PostMessage(Id(), TCFSelector::TSimpleSelect(iSelectionPreferences).CRef());

				}

			else

				{

				iActiveRequests[0].PostMessage(Id(), TCFSelector::TSelect(iConnPrefList).CRef());

				}

			}

		else

			{

			if (aSender==iTopMcprId)

				{

				iJoined = ETrue;

				TUint selectionScope = iSelectionPreferences.Scope();

				if (!(selectionScope & TSelectionPrefs::EExplicitConnection))

					{

					return;

					}

				}

			if(iConnPrefList.Count() < 1)

				{

				RNodeInterface::OpenPostMessageClose(Id(), aSender, TCFSelector::TSimpleSelect(iSelectionPreferences).CRef());

				}

			else

				{

				RNodeInterface::OpenPostMessageClose(

					Id(),

					aSender,

					TCFSelector::TSelect(iConnPrefList).CRef()

					);

				}

			}

		}

	else

		{

		TInt idx = FindActiveRequest(aSender);

		if (idx != KErrNotFound && !(iActiveRequests[idx].Flags() & TClientType::ELeaving))

			{

			RNodeInterface::OpenPostMessageClose(Id(), aSender, TEChild::TLeft().CRef());

			iActiveRequests[idx].SetFlags(TClientType::ELeaving);

			}

		ProviderSelectionFinished(aSender);

		if (iActiveRequests.Count()==0)

			{ //The active list is empty which means that we have finished serving the selection request.

			SelectionFinished();

			}

		}

	}

void CSelectionRequest::CommsBinderResponse(const TCFServiceProvider::TCommsBinderResponse& aMsg)

	{

	iRequest.ReplyTo(Id(), TCFDataClient::TBindTo(aMsg.iNodeId).CRef());

	iSelectionStatus = EIdle;

	}

//This fn is called when a provider has been successfuly selected.

void CSelectionRequest::SelectComplete(const TNodeId& aSenderId, const TNodeId& aMcprId, const TProviderInfo& aMcprInfo)

	{

	NM_LOG_START_BLOCK(KESockMetaConnectionTag(), _L8("CSelectionRequest::SelectComplete"));

	NM_LOG((KESockMetaConnectionTag(), _L8("[this=0x%08x]"), this));

	NM_LOG_ADDRESS(KESockMetaConnectionTag(), aSenderId);

	NM_LOG_ADDRESS(KESockMetaConnectionTag(), aMcprId);

	NM_LOG_END_BLOCK(KESockMetaConnectionTag(), KNullDesC8());

	__ASSERT_DEBUG(!aSenderId.IsNull(), User::Panic(KSpecAssert_ESockSSockscnslc, 27)); //The sender must exist and be in the active list

	//The sender must be in the active list (or it is the tier manager)

	__ASSERT_DEBUG(KErrNotFound!=FindActiveRequest(aSenderId), User::Panic(KSpecAssert_ESockSSockscnslc, 28));

	if (aMcprId.IsNull())

		{ //Last SelectComplete from aSenderId. Remove from the active list.

		ProviderSelectionFinished(aSenderId);

		}

	else

		{

		HandleProviderSelection(aMcprId);

		}

	if (iTopMcprId.IsNull())

		{

		//Top provider has been selected (it must not be null since we have received SelectComplete and not Error).

    	NM_LOG_ADDRESS_EXT(KESockMetaConnectionTag, aMcprId, _L8("Top provider selected: "));

		//We should have never reveive SelectComplete(NULL) as the only select complete.

		//If even one provider cannot be selected we should have received an error message!

		__ASSERT_DEBUG(!aMcprId.IsNull(), User::Panic(KSpecAssert_ESockSSockscnslc, 30));

		__ASSERT_DEBUG(iActiveRequests[0].RecipientId()==aSenderId, User::Panic(KSpecAssert_ESockSSockscnslc, 29)); //It has surely been sent by the tier manager.

		iTopMcprId = aMcprId;

		iTopMcprInfo = aMcprInfo;

		}

	else if (iActiveRequests.Count()==0)

		{ //The active list is empty which means that we have finished serving the selection request.

		SelectionFinished();

		}

	}

//This fn is called when we receive or generate an error during selection.

void CSelectionRequest::SelectionError(const TRuntimeCtxId& aSenderId, TInt aError)

	{

	//Remember the error because for legacy selection we need to use it

	if (KErrNone==iOriginalError)

		{

		iOriginalError = aError;

		}

	NM_LOG_START_BLOCK(KESockMetaConnectionTag(), _L8("CSelectionRequest::SelectionError"));

	NM_LOG((KESockMetaConnectionTag(), _L8("[this=0x%08x] [aError=%d]"), this, aError));

	NM_LOG_ADDRESS_EXT(KESockMetaConnectionTag(), iRequestingNode.RecipientId(), _L8("Client:"));

	NM_LOG_END_BLOCK(KESockMetaConnectionTag(), KNullDesC8());

	__ASSERT_DEBUG(!aSenderId.IsNull(), User::Panic(KSpecAssert_ESockSSockscnslc, 31)); //The sender must exist and be in the active list

	__ASSERT_DEBUG(iSelectionStatus!=ERequestingCommsBinder, User::Panic(KSpecAssert_ESockSSockscnslc, 32));