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

//

/**

@file

ss_mcprnodeinterfaces.cpp

*/

#include <comms-infras/ss_mcprnodemessages.h>

#include <comms-infras/metatype.h>

#include <ss_glob.h>

#include <comms-infras/ss_log.h>

#include <comms-infras/ss_thread.h>

#include <comms-infras/metatypevariablelen.h>

#include <comms-infras/ss_mmnode.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <es_enum_internal.h>

#endif

#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_ESockSSocksmcprn, "ESockSSocksmcprn");

#endif

using namespace ESock;

using namespace Elements;

using namespace Messages;

using namespace MeshMachine;

const TInt KESockInternalMetaPlaneMessagesImplementationUid = 0x1028300E;

enum EMessageTypeId //message signatures only (NOT messages) messages are declared under class TCFMessage

	{

	ESafeMessageCarrierBase				=0,

	ESafeMessageCarrierEast				=1,

	ESafeMessageCarrierWest				=2

	};

//

//TConnProviderInfoPref

EXPORT_C TConnProviderInfoPref::TConnProviderInfoPref(const TConnProviderInfo& aProviderInfo)

:	TConnPref(EConnPrefProviderInfo)

	{

	TConnProviderInfo* prefPtr = reinterpret_cast<TConnProviderInfo*>(UserPtr());

	*prefPtr = aProviderInfo; //Binary copy

	}

EXPORT_C const TConnProviderInfo& TConnProviderInfoPref::Info() const

/**

@publishedPartner

@return stored SNAP value

@released since v9.1

*/

	{

	return *(reinterpret_cast<TConnProviderInfo*>(UserPtr()));

	}

//

//TSelectionPrefs

EXPORT_START_ATTRIBUTE_TABLE_AND_FN(TSelectionPrefs, TSelectionPrefs::EUid, TSelectionPrefs::ETypeId)

    REGISTER_ATTRIBUTE(TSelectionPrefs, iPrefs, TMeta<TConnPref>)

    REGISTER_ATTRIBUTE(TSelectionPrefs, iU.iSelectionParams, TMetaNumber)

	REGISTER_ATTRIBUTE(TSelectionPrefs, iSubSessionUniqueId, TMetaNumber)

END_ATTRIBUTE_TABLE()

EXPORT_C TSelectionPrefs::TSelectionPrefs()

	{

    iU.iS.iScope = ENone;

    iU.iS.iFlags = 0;

	}

EXPORT_C TSelectionPrefs::TSelectionPrefs(TSelectionScope aSelectionScope)

	{

    iU.iS.iScope = aSelectionScope;

    iU.iS.iFlags = 0;

	}

EXPORT_C TSelectionPrefs::TSelectionPrefs(const TConnPref& aPref)

	{

	SetPrefs(aPref);

	}

//

//TOverridenSelectionPrefsExt

EXPORT_START_ATTRIBUTE_TABLE_AND_FN(TOverridenSelectionPrefsExt, TOverridenSelectionPrefsExt::EUid, TOverridenSelectionPrefsExt::ETypeId)

	//No attributes as this is only for type id

END_ATTRIBUTE_TABLE()

EXPORT_C TOverridenSelectionPrefsExt::TOverridenSelectionPrefsExt(TUid aTierId, const TSelectionPrefs& aPrefs)

:	iPrefs(aPrefs),

	iTierId(aTierId)

	{

	}

//

//TDeferredSelectionPrefsExt

EXPORT_START_ATTRIBUTE_TABLE_AND_FN(TDeferredSelectionPrefsExt, TDeferredSelectionPrefsExt::EUid, TDeferredSelectionPrefsExt::ETypeId)

	//No attributes as this is only for type id

END_ATTRIBUTE_TABLE()

EXPORT_C TDeferredSelectionPrefsExt::TDeferredSelectionPrefsExt(TUid aTierId, const TConnPref& aPrefs)

:	iPrefs(aPrefs),

	iTierId(aTierId)

	{

	}

//

//TPromptingSelectionPrefsExt

EXPORT_START_ATTRIBUTE_TABLE_AND_FN(TPromptingSelectionPrefsExt, TPromptingSelectionPrefsExt::EUid, TPromptingSelectionPrefsExt::ETypeId)

	//No attributes as this is only for type id

END_ATTRIBUTE_TABLE()

EXPORT_C TPromptingSelectionPrefsExt::TPromptingSelectionPrefsExt(TUid aTierId, const TConnPref& aPrefs)

    : iPrefs(aPrefs), iTierId(aTierId), iPromptingInProgress(ETrue)

	{

	}

EXPORT_C Meta::SMetaData* RConnPrefList::TIterBase::AtIndex(const Meta::STypeId& aType, TInt aIndex)

	{

	TInt ind = 0;

	TInt count = 0;

	while(ind < iConnPrefList.Count())

		{

		if (iConnPrefList[ind]->IsTypeOf(aType))

			{

			if(count == aIndex)

				{

				iMasterIndex = ind;

				return static_cast<Meta::SMetaData*>(iConnPrefList[ind]);

				}

			count++;

			}

		ind++;

		}

	return NULL;

	}

//

//RConnPrefList

EXPORT_C RConnPrefList::RConnPrefList()

	{

	iObject = NULL;

	}

EXPORT_C void RConnPrefList::Open(RConnPrefList& aObject)

	{

	iObject = aObject.iObject;

	}

TInt RConnPrefList::Open(TConnPrefList* aObject)

	{

	if(aObject == NULL)

		{

		return KErrNotFound;

		}

	else

		{

		iObject = aObject;

		return KErrNone;

		}

	}

EXPORT_C void RConnPrefList::Close()

	{

	iObject = NULL;

	}

EXPORT_C void RConnPrefList::AppendL(SMetaDataECom* aFamily)

	{

	if(iObject == NULL)

		{

		User::Leave(KErrNotReady);

		}

	else if(aFamily == NULL)

		{

		User::Leave(KErrArgument);

		}

	iObject->AppendL(aFamily);

	}

EXPORT_C SMetaData* RConnPrefList::operator[](TInt aIndex)

	{

	if(iObject == NULL )

		{

		return NULL;

		}

	return (*iObject)[aIndex];

	}

EXPORT_C void RConnPrefList::Remove(TInt aIndex)

	{

	if(iObject == NULL)

		{

		return;

		}

	iObject->Remove(aIndex);

	}

EXPORT_C TInt RConnPrefList::Count()

	{

	if(iObject != NULL)

		{

		return iObject->Count();

		}

	else

		{

		return 0;

		}

	}

//

//TSafeMessageCarrierBase - Safe CF Message carriers

//It is not a purposes of these carriers to secure the comunication channel between two non-peer nodes.

//Sending of such message does not quarantee the node will be there to receive it

//There is a specialisation of the request carrier "locking" the requesting node which makes sure

//that the response will always be deliverd.

TSafeMessageCarrierBase::TSafeMessageCarrierBase(const Messages::TSignatureBase& aMessage)

:	Messages::TSignatureBase(aMessage.MessageId())

	{

	__ASSERT_DEBUG(KMaxCarriedMessageSize>=aMessage.Length(), User::Panic(KSpecAssert_ESockSSocksmcprn, 1)); //TODO: Add panic code & description!!!

	VERIFY(aMessage.Store(iMessageBuf)==KErrNone); //Guaranteed to succeed now - compile assert is quarding it from the template

	}

void TSafeMessageCarrierBase::DispatchCarriedMessageL(const TRuntimeCtxId& aSender, const TNodeId& aNodeId)

    {

	TBuf8<__Align8(TSignalBase::KMaxInlineMessageSize + TSignalBase::KMaxUnstoredOverhead)> msgBuf;

	Meta::CMetaDataVirtualCtorInPlace* vctr = TlsGlobals::Get().VirtualCtor();

	TPtrC8 ptr(iMessageBuf);

	iMessage = static_cast<Messages::TSignatureBase*>(vctr->New(ptr, msgBuf));

   	User::LeaveIfError(iMessage? KErrNone : KErrNotFound);

#ifdef SYMBIAN_TRACE_ENABLE

    _LIT8(KESockMeshMachine, "cftransport");

    NM_LOG_START_BLOCK(KESockMeshMachine, _L8("TransportReceiver::DispatchMessage"));

    NM_LOG_ADDRESS(KESockMeshMachine, aSender);

    NM_LOG_ADDRESS(KESockMeshMachine, aNodeId);

    NM_LOG_MESSAGE(KESockMeshMachine, *iMessage);

    NM_LOG_END_BLOCK(KESockMeshMachine, _L8("TransportReceiver::DispatchMessage"));

#endif

	iMessage->DispatchL(aSender, aNodeId);

   	}

EXPORT_C void TSafeMessageCarrierBase::Error(const TRuntimeCtxId& aSender, const TRuntimeCtxId& aRecipient, TInt aError)

	{

	NM_LOG_START_BLOCK(KESockMeshMachine, _L8("TSafeMessageCarrierBase:Error"));

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

    NM_LOG_ADDRESS_EXT(KESockMeshMachine, aSender, _L8("Originator: "));

    NM_LOG_ADDRESS_EXT(KESockMeshMachine, aRecipient, _L8("Recipient: "));

    NM_LOG((KESockMeshMachine, _L8("[MessageId=0x%08x:0x%08x] "), MessageId().Realm(), MessageId().MessageId()));

    NM_LOG_END_BLOCK(KESockMeshMachine, _L8("TSafeMessageCarrierBase:Error"));

    if (!aSender.IsNull())

        {

        TEBase::TError errMsg(

#if defined(__GCCXML__)

        	static_cast<Messages::TNodeSignal::TMessageId>(MessageId()), 

#else

        	MessageId(),

#endif

        	aError

        	);

        TCFSafeMessage::TResponseCarrierWest<TEBase::TError> responseCarrierMsg(errMsg, aSender);

        RClientInterface::OpenPostMessageClose(aRecipient, aSender, responseCarrierMsg);

        }

	}

EXPORT_START_ATTRIBUTE_TABLE_AND_FN(TSafeMessageCarrierBase, KESockInternalMetaPlaneMessagesImplementationUid, ESafeMessageCarrierBase)

	REGISTER_ATTRIBUTE(TSafeMessageCarrierBase, iMessageBuf, TMeta<TBuf8<KMaxCarriedMessageSize> >) //TODO find variable len meta type

END_ATTRIBUTE_TABLE_BASE(TSignatureBase, ESignatureBase)

/*

//Used to lock the requesting node until the response has been received

class ARequestingNodeLockingClient : Messages::ASimpleNodeIdBase

	{

public:

	void LockRequestingNodeL(const MeshMachine::AMMNodeBase& aRequestingNode)

		{

		//ARequestingNodeLockingClient can currently only work on MeshMachine::AMMNodeBase nodes!!!

   		MeshMachine::AMMNodeBase* nodeBase = reinterpret_cast<MeshMachine::AMMNodeBase*>(aRequestingNode.FetchNodeInterfaceL(AMMNodeBase::KInterfaceId));

		nodeBase.AddClientL((*this)(),RNodeInterface::ECtrl);

		}

	static void Cleanup(TAny* aThis)

		{

		ARequestingNodeLockingClient* self = static_cast<ARequestingNodeLockingClient*>(aThis);

		MeshMachine::AMMNodeBase* nodeBase = reinterpret_cast<MeshMachine::AMMNodeBase*>(self->iLockedNode.FetchNodeInterfaceL(AMMNodeBase::KInterfaceId));

		nodeBase.RemoveClient((*this)());

		delete self;

		}

	virtual TInt ReceivedL(Messages::TSignatureBase& aCFMessage)

		{

		if (aCFMessage.iSender == iLockedNode())

			{

			return;

			}

		//Noone else knows about this node!!!!

		__ASSERT_DEBUG(aCFMessage.iSender == iRespondingNode, User::Panic(KSpecAssert_ESockSSocksmcprn, 2));

		CleanupStack::PushL(TCleanupItem(Cleanup,this));

		TInt error = iLockedNode->ReceivedL(aCFMessage);

		CleanupStack::PopAndDestroy();

		return error;

		}

private:

	TNodeId iRespondingNode;

	MeshMachine::AMMNodeBase& iLockedNode;

	};

EXPORT_C void TSafeMessageCarrierEastBase::LockRequestingNodeAndPostL(const MeshMachine::AMMNodeBase& aRequestingNode)

   	{

   	__ASSERT_DEBUG(iMessage, User::Panic(KSpecAssert_ESockSSocksmcprn, 3)); //The local message

	__ASSERT_DEBUG(KMaxCarriedMessageSize>=aMessage.Length(), User::Panic(KSpecAssert_ESockSSocksmcprn, 4)); //TODO: Add panic code & description!!!

	iMessageBuf.FillZ();

	iMessage->

	VERIFY(aMessage.Store(iMessageBuf)==KErrNone); //Guaranteed to succeed now - compile assert is quarding it from the template

   	ARequestingNodeLockingClient* lock = new (ELeave) ARequestingNodeLockingClient;

   	CleanupStack::PushL(lock);

   	lock->LockRequestingNodeL(aRequestingNode);

   	CleanupStack::Pop(lock);

   	}

*/

EXPORT_C TSafeRequestCarrierEast::TSafeRequestCarrierEast(const Messages::TSignatureBase& aMessage)

:	TSafeMessageCarrierBase(aMessage)

   	{

   	}

EXPORT_C void TSafeRequestCarrierEast::DispatchL(const TRuntimeCtxId& aSender, const TRuntimeCtxId& aRecipient)

    {

    const TNodeId& nodeId = address_cast<const TNodeId>(aRecipient);  //This message type operates on nodes

    AMMNodeBase* nodeBase = reinterpret_cast<AMMNodeBase*>(nodeId.Node().FetchNodeInterfaceL(AMMNodeBase::KInterfaceId)); //Will result in Error() when not found

   	if (static_cast<ACFMMNodeIdBase*>(nodeBase)->ControlProvider()==0)

   		{

   		DispatchCarriedMessageL(aSender, nodeId);

   		}

   	else

   		{

   		nodeBase->PostToClients<TDefaultClientMatchPolicy>(aSender, *this, TClientType(TCFClientType::ECtrlProvider), TClientType(0, TClientType::ELeaving));

   		}

   	}

DEFINE_MVIP_CTR(TSafeRequestCarrierEast)

EXPORT_START_ATTRIBUTE_TABLE_AND_FN(TSafeRequestCarrierEast, KESockInternalMetaPlaneMessagesImplementationUid, ESafeMessageCarrierEast)

END_ATTRIBUTE_TABLE_BASE(TSafeMessageCarrierBase, ESafeMessageCarrierBase)

EXPORT_C TSafeResponseCarrierWest::TSafeResponseCarrierWest(const Messages::TSignatureBase& aMessage, const TRuntimeCtxId& aRecipient)

:	TSafeMessageCarrierBase(aMessage),

   	iRecipient(address_cast<TNodeId>(aRecipient)) //Must be a node!

   	{

   	}

EXPORT_C void TSafeResponseCarrierWest::DispatchL(const TRuntimeCtxId& aSender, const TRuntimeCtxId& aRecipient)

    {

    const TNodeId& nodeId = address_cast<const TNodeId>(aRecipient);  //This message type operates on nodes

	if (nodeId==iRecipient)

		{

		DispatchCarriedMessageL(aSender, nodeId);

		}

	else

		{

    	MeshMachine::AMMNodeBase* nodeBase = NULL;

    	TRAP_IGNORE(nodeBase = reinterpret_cast<MeshMachine::AMMNodeBase*>(nodeId.Node().FetchNodeInterfaceL(AMMNodeBase::KInterfaceId)));

    	if (nodeBase)

    		{

    		//If the interface is not found, ignore

			nodeBase->PostToClients<TDefaultClientMatchPolicy>(aSender, *this, TClientType(TCFClientType::EData), TClientType(0, TClientType::ELeaving));

			}

		}

   	}

DEFINE_MVIP_CTR(TSafeResponseCarrierWest)

EXPORT_START_ATTRIBUTE_TABLE_AND_FN(TSafeResponseCarrierWest, KESockInternalMetaPlaneMessagesImplementationUid, ESafeMessageCarrierWest)

	REGISTER_ATTRIBUTE(TSafeResponseCarrierWest, iRecipient, TMeta<TNodeId>)

END_ATTRIBUTE_TABLE_BASE(TSafeMessageCarrierBase, ESafeMessageCarrierBase)

const TImplementationProxy SignatureImplementationTable[] =

	{

	//NOTE: Entries must be sorted for the binary search to work efficiently!

	MVIP_CTR_ENTRY(ESafeMessageCarrierEast,TSafeRequestCarrierEast),

	MVIP_CTR_ENTRY(ESafeMessageCarrierWest,TSafeResponseCarrierWest),

	};

void TCFSafeMessage::RegisterL()

	{

	TlsGlobals::Get().RegisterInterfaceL(TUid::Uid(KESockInternalMetaPlaneMessagesImplementationUid), sizeof(SignatureImplementationTable) / sizeof(SignatureImplementationTable[0]), SignatureImplementationTable);

	}

void TCFSafeMessage::DeRegister()

	{

	TlsGlobals::Get().DeregisterInterface(TUid::Uid(KESockInternalMetaPlaneMessagesImplementationUid));

	}