// Copyright (c) 2006-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_NODEINTERFACES.CPP

*/

#include <comms-infras/ss_log.h>

#include <comms-infras/ss_dispatchers.h>

#include <comms-infras/ss_nodemessages.h>

#include <comms-infras/ss_api_ext.h>

#include <elements/interfacetable.h>

#include <elements/metatype.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_ESockSSocksndntr, "ESockSSocksndntr");

#endif

using namespace ESock;

using namespace Messages;

using namespace MeshMachine;

EXPORT_C void TCFItfExt::ForwardMessageL(const TRuntimeCtxId& aSender,

                                         TSignalBase& aMessage,

                                         Messages::ANode& aNode,

                                         const TClientType& aClientType,

                                         const TClientType& aClientTypeExclude)

	{

	NetInterfaces::TInterfaceControl* ic = NULL;

    ic = aNode.FetchNodeInterfaceControlL(AMMNodeBase::KInterfaceId);

    MeshMachine::AMMNodeBase* nodeBase = reinterpret_cast<MeshMachine::AMMNodeBase*>(ic->FetchInterfaceL(AMMNodeBase::KInterfaceId));

    RNodeInterface* recp;

    if(aClientType.Type() == TCFClientType::ECtrl)

    	{

		recp = nodeBase->GetFirstClient<TDefaultClientMatchPolicy>(TClientType(TCFClientType::EServProvider),aClientTypeExclude);

    	}

    else

		{

		recp = nodeBase->GetFirstClient<TDefaultClientMatchPolicy>(TClientType(TCFClientType::ECtrlProvider),aClientTypeExclude);

		}

    if(recp)

    	{

    	recp->PostMessage(aSender, aMessage);

    	}

	else

		{

		User::Leave(KErrNotFound);

		}

	}

EXPORT_C TAny* TCFItfExt::FetchInterfaceL(Messages::ANode& aNode, TInt aInterface)

	{

	NetInterfaces::TInterfaceControl* ic = NULL;

	ic = aNode.FetchNodeInterfaceControlL(aInterface);

	return ic->FetchInterfaceL(aInterface);

	}

EXPORT_C TAny* TCFItfExt::FetchInterfaceOrForwardMsgL(const TRuntimeCtxId& aSender,

                                                      TSignalBase& aMessage,

                                                      Messages::ANode& aNode,

                                                      TInt aInterface,

                                                      const TClientType& aClientType,

                                                      const TClientType& aClientTypeExclude)

    {

	TAny* itf = NULL;

	TRAPD(ret, itf = FetchInterfaceL(aNode, aInterface));

	switch(ret)

		{

	case KErrNone:

		return itf;

	case KErrInterfaceNotSupported:

		ForwardMessageL(aSender, aMessage, aNode, aClientType, aClientTypeExclude);

		break;

	default:

        __ASSERT_DEBUG(EFalse, User::Panic(KSpecAssert_ESockSSocksndntr, 1)); //unreachable

        User::Leave(ret);

        break;

		}

	//Never gets here

	return NULL;

    }

EXPORT_C NetInterfaces::TInterfaceControl* TCFItfExt::FetchInterfaceControlOrForwardMsgL(const TRuntimeCtxId& aSender,

                                                                                         TSignalBase& aMessage,

                                                                                         Messages::ANode& aNode,

																			 			 TInt aInterface,

								  		   		  							  			 const TClientType& aClientType,

								  		   		  							  			 const TClientType& aClientTypeExclude)

	{

	NetInterfaces::TInterfaceControl* ic = NULL;

	TRAPD(ret, ic = aNode.FetchNodeInterfaceControlL(aInterface));

	switch(ret)

		{

	case KErrNone:

		return ic;

	case KErrInterfaceNotSupported:

		ForwardMessageL(aSender, aMessage, aNode, aClientType, aClientTypeExclude);

		break;

	default:

        User::Leave(ret);

        __ASSERT_DEBUG(EFalse, User::Panic(KSpecAssert_ESockSSocksndntr, 2)); //unreachable

        break;

		}

	//Never gets here

	return NULL;

	}

EXPORT_C void TCFSigRMessage2Ext::Error(const TRuntimeCtxId& /*aSender*/, const TRuntimeCtxId& /*aRecipient*/, TInt aError)

    {

	LOG( ESockLog::Printf(KESockDCMsgs, _L8( "TCFSigRMessage2Ext:\tError(): completing message (%08X) with %d" ),

			iMessage.Handle(), aError) );

    if ( !iMessage.IsNull() )

        {

        iMessage.Complete(aError);

        }

    }

EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TCFSigRMessage2Ext, 0, 0 ) //has to be derived from

	REGISTER_ATTRIBUTE( TCFSigRMessage2Ext, iMessage, TMeta<RMessage2> )

END_ATTRIBUTE_TABLE_BASE(TSignalBase, 0)