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

// tunnelnif.cpp

//

//

#include <es_mbuf.h>

//#include <flogger.h>

#include <agenterrors.h>

//#include "TunnelNifVar.h"

#include "tunnelFlow.h"

#include "tunnelBinders.h"

#include "tunnelProvision.h"

#include <comms-infras/linkmessages.h>

#include <comms-infras/ss_metaconnprov.h>					// for SAccessPointConfig

#include <comms-infras/commsdebugutility.h>

#include <elements/nm_messages_base.h>

#include <elements/nm_messages_child.h>

using namespace Messages;

using namespace MeshMachine;

using namespace ESock;

/*

 * This sections defines a whole load of constants etc... not very exciting

 */

#if defined (_DEBUG)

	#define LOG(a) a

#else

	#define LOG(a)

#endif

_LIT8(KDescIp6, "ip6");

_LIT8(KDescIp, "ip");

// Note: The "tunnel" logging string has been repeated here but should be unified throughout

// the Tunnel CFProtocol.  The main logging relies on 16-bit RFileLogger calls whereas the

// CFNode logging requires an 8-bit string.  An attempt to make everything 8-bit resulted

// in undefined RFileLogger symbols.

#ifdef SYMBIAN_TRACE_ENABLE

_LIT8(KTunnel, "tunnel");

#endif

/*

 * The Link class

 */

CTunnelFlow::CTunnelFlow(CSubConnectionFlowFactoryBase& aFactory, const TNodeId& aSubConnId, CProtocolIntfBase* aProtocolIntf)

	: CSubConnectionFlowBase(aFactory, aSubConnId, aProtocolIntf)

/**

Constructor.

@param aFactory Reference to the factory which created this object.

@param aSubConnId Id of SubConnection Provider - for sending messages to it.

@param aProtocolIntf Protocol Interface corresponding to the Flow.

*/

    {

    LOG_NODE_CREATE(KTunnel, CTunnelFlow);

    }

CTunnelFlow::~CTunnelFlow()

    {

    LOG_NODE_DESTROY(KTunnel, CTunnelFlow);

    }

TInt CTunnelFlow::Notification(TTunnelAgentMessage::TTunnelSetAddress& aMessage)

    {

	if (iNifIf4)

		{

		return iNifIf4->Notification(aMessage);

		}

	if (iNifIf6)

		{

		return iNifIf6->Notification(aMessage);

		}

	return KErrNotSupported;

	}

// =====================================================================================

// CSubConnectionFlowBase

// =====================================================================================

MFlowBinderControl* CTunnelFlow::DoGetBinderControlL()

	{

	return this;

	}

// =====================================================================================

// MFlowBinderControl methods

// =====================================================================================

MLowerControl* CTunnelFlow::GetControlL(const TDesC8& aProtocol)

	{

	if (aProtocol.CompareF(KDescIp6) == 0)

		{

		if ( iNifIf6 )

			{

			CTunnelNcpLog::Printf(_L("CTunnelFlow:\tGetControlL already bound to %S"), &aProtocol);

			User::Leave(KErrInUse);

			return NULL;

			}

		iNifIf6 = CTunnelNcp6::ConstructL(*this);

		return iNifIf6;

        }

	else if (aProtocol.CompareF(KDescIp) == 0)

	    {

		if ( iNifIf4 )

            {

            CTunnelNcpLog::Printf(_L("CTunnelFlow:\tGetControlL already bound to %S"), &aProtocol);

			User::Leave(KErrInUse);

            return NULL;

            }

        iNifIf4 = CTunnelNcp4::ConstructL(*this);

		return iNifIf4;

        }

	Panic(ETunnelPanic_BadBind);

	return NULL;

	}

MLowerDataSender* CTunnelFlow::BindL(const TDesC8& aProtocol, MUpperDataReceiver* aReceiver, MUpperControl* aControl)

/**

 * Binds upper CFProtocol to this CFProtocol

 *

 * @param aUpperReceiver A pointer to Upper layer Receive class

 * @param aUpperControl A pointer to Upper layer control class

 */

	{

	MLowerDataSender* lowerDataSender = NULL;

	if (aProtocol.CompareF(KDescIp6) == 0)

		{

		ASSERT(iNifIf6);

		lowerDataSender = iNifIf6->Bind(aReceiver, aControl);

        }

	else if (aProtocol.CompareF(KDescIp) == 0)

		{

		ASSERT(iNifIf4);

		lowerDataSender = iNifIf4->Bind(aReceiver, aControl);

		}

	else

		{

		// GetControlL() should already have been called.

		Panic(ETunnelPanic_BadBind);

		}

	if (lowerDataSender)

    	{

    	iSubConnectionProvider.PostMessage(Id(), TCFControlProvider::TActive().CRef());

    	}

	return lowerDataSender;

	}

void CTunnelFlow::Unbind(MUpperDataReceiver* aUpperReceiver, MUpperControl* aUpperControl)

    {

	if (iNifIf4 && iNifIf4->MatchesUpperControl(aUpperControl))

		{

		iNifIf4->Unbind(aUpperReceiver, aUpperControl);

		delete iNifIf4;

		iNifIf4 = NULL;

		}

	else

	if (iNifIf6 && iNifIf6->MatchesUpperControl(aUpperControl))

		{

		iNifIf6->Unbind(aUpperReceiver, aUpperControl);

		delete iNifIf6;

		iNifIf6 = NULL;

		}

	else

		{

		Panic(ETunnelPanic_BadUnbind);

		}

	MaybePostDataClientIdle();

    }

CSubConnectionFlowBase* CTunnelFlow::Flow()

/**

Return the Flow corresponding to the MFlowBinderControl

*/

	{

	return this;

	}

// =====================================================================================

// Messages::ANode

// =====================================================================================

void CTunnelFlow::ReceivedL(const TRuntimeCtxId& aSender, const TNodeId& aRecipient, TSignatureBase& aMessage)

    {

    CSubConnectionFlowBase::ReceivedL(aSender, aRecipient, aMessage);

	if (aMessage.IsMessage<TEBase::TError>())

		{

		}

	else if (TEChild::ERealmId == aMessage.MessageId().Realm())

		{

		switch (aMessage.MessageId().MessageId())

			{

		case TEChild::TDestroy::EId :

			Destroy();

			break;

		default:

//TODO - logging

			ASSERT(EFalse);

			}

		}

	else if (TCFDataClient::ERealmId == aMessage.MessageId().Realm())

		{

		switch (aMessage.MessageId().MessageId())

			{

		case TCFDataClient::TStart::EId :

			StartFlowL();

			break;

		case TCFDataClient::TStop::EId :

			StopFlow(static_cast<TCFDataClient::TStop&>(aMessage).iValue);

			break;

		case TCFDataClient::TBindTo::EId:

            {

			TCFDataClient::TBindTo& bindToReq = message_cast<TCFDataClient::TBindTo>(aMessage);

			if (!bindToReq.iNodeId.IsNull())

				{

				User::Leave(KErrNotSupported);

				}

			RClientInterface::OpenPostMessageClose(Id(), aSender, TCFDataClient::TBindToComplete().CRef());

            }

			break;

		case TCFDataClient::TProvisionConfig::EId:

			ProvisionConfig(static_cast<TCFDataClient::TProvisionConfig&>(aMessage).iConfig);

			break;

		default:

//TODO - logging

			ASSERT(EFalse);

			}

		}

   	else if (TTunnelAgentMessage::ERealmId == aMessage.MessageId().Realm())

		{

		switch (aMessage.MessageId().MessageId())

			{

		case TTunnelAgentMessage::TTunnelSetAddress::EId:

			{

			Notification(static_cast<TTunnelAgentMessage::TTunnelSetAddress&>(aMessage));

			break;

			}

		default:

			Panic(ETunnelPanic_UnexpectedMessage);

			}

		}

	else	// realm is not TCFMessage or TTunnelAgentMessage

		{

		Panic(ETunnelPanic_UnexpectedMessage);

		}

    }

// =====================================================================================

//

// Methods for handling incoming SCPR messages

//

void CTunnelFlow::StartFlowL()

    {

    // NOTE: according to the NAF docs the sequence should really be StartSending(), then LinkLayerUp() then Progress()

    // for DNS to work.  However, this tunnel NIF doesn't support DNS.

    //

	CTunnelNcpLog::Write(_L("CTunnelFlow:\tStartFlow()"));

	// Process any errors that may have occurred during processing of the ProvisionConfig message earlier.

	// ProvisionConfig has no response, so error the StartFlow here.

	User::LeaveIfError(iSavedError);

	PostDataClientStartedMessage();

	if (iNifIf4)

		{

		iNifIf4->StartSending();

		}

	if (iNifIf6)

		{

		iNifIf6->StartSending();

		}

	iMMState = EStarted;

    }

void CTunnelFlow::StopFlow(TInt aError)

    {

    CTunnelNcpLog::Printf(_L("CTunnelFlow:\tStop(aError %d)"), aError);

    PostFlowDownMessage(aError);

    }

void CTunnelFlow::MaybePostDataClientIdle()

    {

	if (iNifIf4 == NULL && iNifIf4 == NULL)

		{

   		iSubConnectionProvider.RNodeInterface::PostMessage(Id(), TCFControlProvider::TIdle().CRef());

		}

    }

/*

Provisioning description for Tunnel CFProtocol Flow:

- on receipt of the TProvisionConfig message, the provisioning information contained within

  the AccessPointConfig array is validated:

	- TTunnelProvision must be present.  It is added by the Tunnel MCPr and populated from CommsDat.  A pointer to it

	  is stored in iProvisionInfo. If missing, TError(TCFDataClient::TStart, KErrCorrupt) message is signalled back

  	  to the SCPr on the next StartFlow message (ProvisionConfig has no response message).

*/

void CTunnelFlow::ProvisionConfig(const ESock::RMetaExtensionContainerC& aConfigData)

/**

Handle ProvisionConfig message from SCPR.

*/

	{

	iSavedError = KErrNone;

	CTunnelNcpLog::Printf(_L("CTunnelFlow:\tProvisionConfig message received"));

	AccessPointConfig().Close();

	AccessPointConfig().Open(aConfigData);

    const TTunnelProvision* provision = static_cast<const TTunnelProvision*>(AccessPointConfig().FindExtension(

    		STypeId::CreateSTypeId(TTunnelProvision::EUid, TTunnelProvision::ETypeId)));

    if (provision == NULL)

        {

        CTunnelNcpLog::Printf(_L("CTunnelFlow:\tProcessProvisionConfigL() - no Tunnel configuration"));

		iSavedError = KErrCorrupt;

        }

	ASSERT(iProvisionInfo == NULL);

	iProvisionInfo = &provision->iInfo;

	ASSERT(iProvisionInfo);

	}

void CTunnelFlow::Destroy()

/**

Handle Destroy message from SCPR.

*/

	{

	ASSERT(iNifIf4 == NULL);		// must not still be bound from above before being destroyed

	ASSERT(iNifIf6 == NULL);

	DeleteThisFlow();

	}

//

// Utility functions

//

void CTunnelFlow::PostProgressMessage(TInt aStage, TInt aError)

	{

	iSubConnectionProvider.RNodeInterface::PostMessage(Id(), TCFMessage::TStateChange(Elements::TStateChange(aStage, aError)).CRef());

	}

void Panic(TTunnelPanic aPanic)

	{

	_LIT(KTunnelPanicTag, "Tunnel");

	User::Panic(KTunnelPanicTag, aPanic);

	}