// 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:

// Implements the CRawIPFlow class, which provides a central point for the NIF

// to communicate with NifMan and the BCA controllers. This class creates an interface

// to the IPv4 protocol when it is required.

// 

//

/**

 @file

*/

#include <f32file.h>

#include <nifman.h>

#include <nifmbuf.h>

#include <in_iface.h>

#include <nifvar.h>

#include "IPv4Binder.h"

#include "IPv6Binder.h"

#include "RawIP2Flow.h"

#include "BcaController.h"

#include <comms-infras/linkprovision.h>

#include <comms-infras/linkmessages.h>

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

#include <elements/nm_messages_base.h>

#include <elements/nm_messages_child.h>

#include <comms-infras/ss_nodemessages_flow.h>

using namespace Messages;

using namespace MeshMachine;

/**

 * Constructor.

 *

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

 * @param aSubConnId Reference to the node id for sub connection.

 * @param aProtocolIntf pointer to the CProtocolIntfBase

 */

	: CSubConnectionFlowBase(aFactory, aSubConnId, aProtocolIntf),

	  iInitError(KErrNone),

	  iStarted(EFalse),

	  iStopping(EFalse)

	{

	LOG_NODE_CREATE(KNifSubDir, CRawIP2Flow);

	}

void CRawIP2Flow::ConstructL()

/**

 * Second-phase constructor. Creates the Etel

 * control engine

 *

 * @param aName The name of the NIF (unused)

 */

	{

    iBinderControl = new (ELeave) TBinderControlProxy(*this);

	}

CRawIP2Flow::~CRawIP2Flow()

/**

 * Destructor. Cancels and deletes all owned active objects.

 */

	{

	// Note that we don't delete iBinder because it's not owned by us.

	delete iBcaController;

	ASSERT(iBinder == NULL);

	delete iBinderControl;	

	LOG_NODE_DESTROY(KNifSubDir, CRawIP2Flow);

	}

void CRawIP2Flow::StartFlowL()

/**

 * Starts the Flow up. This process involves connecting to the BCA.  

 *

 * Called in response to corresponding SCPR message.

 *

 * @return Allways KErrNone

 */

	{

	ASSERT(iStarting==EFalse);

	iStarting = ETrue;

	// If there were any errors during earlier processing of the ProvisionConfig message

	// then send an Error message in response to the StartFlow (because ProvisionConfig

	// does not have a response code).

	if (iProvisionError != KErrNone)

		{

		User::Leave(iProvisionError);

		}

	// Retrieve Agent provisioned information only available at StartFlow time

	DynamicProvisionConfigL();

	InitialiseL();

	// associate the binder object with the lowersender

	iBinder->SetSender(&(iBcaController->Bca()->GetSender()));

	//the name calculation should be done only if logging is enabled

	const TUint KModemNameLen = KCommsDbSvrMaxColumnNameLength + 10;  // need enough for ppp-XXX.txt - e.g. ppp-comm-1.txt, ppp-btcomm-10.txt etc

	TBuf8<KModemNameLen> modemName;

	_LIT8(KDoubleColon, "::");

	modemName.Copy(iBCAProvisionConfig->GetPortName());

	const TInt pos = modemName.FindC((const TDesC8&)KDoubleColon);

	if(pos != KErrNotFound)

		{

		modemName.Delete(pos, 2);

		}

	//append time stamp

	const TUint KTimeStampLen = 8;

	TBuf8<KTimeStampLen> logFileName;

	_LIT8(KTimeFormat, "%08X");

	TUint32 counter = User::FastCounter();

	logFileName.Format(KTimeFormat, counter);

	const TUint KLogTextLen = KModemNameLen+KTimeStampLen+30;

	TBuf8<KLogTextLen> logText;

	_LIT8(KLogTimeText, "TcpDump log file time stamp:");

	_LIT8(KLogModemText, " for modem:");

	logText.Append(KLogTimeText);

	logText.Append(logFileName);

	logText.Append(KLogModemText);

	logText.Append(modemName);

#endif

	}

void CRawIP2Flow::LinkLayerUp()

/**

 * This function is called when initialisation is complete and the Flow is

 * ready to send/receive data. It notifies NifMan and the IP interface that it's

 * ready to go.

 */

	{

	iLastRequestOriginator.ReplyTo(Id(), ESock::TCFDataClient::TStarted().CRef());

	iStarted = ETrue;

	iStarting = EFalse;

	}

void CRawIP2Flow::LinkLayerDown(TInt aError)

/**

 * This function is called when the context has been deactivated and the NIF

 * is ready to be deleted, or if there is an error on startup. Its job is to

 * notify NifMan that the link has gone down, so it can delete the NIF.

 *

 * @param aError An error code to propagate to NifMan

 */

	{

	if (iStopping)

		{

		iLastRequestOriginator.ReplyTo(Id(), ESock::TCFDataClient::TStopped(aError).CRef());

		}

    else if (iStarting)

		{

		iSubConnectionProvider.PostMessage(Id(), TEBase::TError(ESock::TCFServiceProvider::TStart::Id(), aError).CRef());

		}

	else    

		{

		iSubConnectionProvider.PostMessage(Id(), ESock::TCFControlProvider::TDataClientGoneDown(aError, MNifIfNotify::EDisconnect).CRef());

		}

    iStarted = EFalse;

    iStarting = EFalse;

    iStopping = EFalse;

	}

void CRawIP2Flow::StopFlow(TInt aError)

/**

 * This function is called by NifMan to bring down the link. It starts

 * the asynchronous context deactivation process; LinkLayerDown() will be

 * called when the context has been deactivated.

 *

 * @param aError A code specifying why the link is to be brought down

 * @param aAction The action to take: disconnect or reconnect

 */

	{

	iStopping = ETrue;

	ShutDown(aError);

	}

void CRawIP2Flow::InitialiseL()

/**

 * This method controls the initialisation sequence of the different modules

 * in the Flow. When a module completes all the initialisation tasks it will

 * call again this method with the new state. If an error occurs then the

 * ShutDown() method will be called.

 *

 * @param aState The current initialisation step

 * @param aError A possible error

 */

	{

	// Update local state from TSY information originally from Agent.

	GetBinder()->UpdateContextConfigL(*iAgentProvision->iGprsConfig);

	GetBinder()->UpdateConnectionSpeed(iAgentProvision->iConnectionSpeed);

	UpdateContextState(RPacketContext::EStatusActive, KErrNone);

	iBcaController->StartLoadL(iBCAProvisionConfig,iBinder,iBinder);

	}

void CRawIP2Flow::ShutDown(TInt aError)

/**

 * This method controls the shutdown sequence of the different modules

 * in the Flow. When a module completes all the shutdown tasks it will

 * call again this method with the new state.

 *

 * @param aState The current state

 * @param aError A possible error (only during initialisation)

 */

	{

	if (aError != KErrNone)

		{

		// Flow is shutting down due to an error.

		// The error code must be stored in order to call linklayer down

		// passing that value

		iInitError = aError;

		}

	iBcaController->Stop(aError);

	LinkLayerDown(iInitError);

	}

CBinderBase* CRawIP2Flow::GetBinder()

/**

 * Returns a pointer to the Binder class

 *

 * @return a pointer to a CBinderBase derived class

 */

	{

	return iBinder;

	}

CBcaController* CRawIP2Flow::GetBcaController()

/**

 * Returns a pointer to the CBcaIoController class

 *

 * @return a pointer to CBcaIoController

 */

	{

	return iBcaController;

	}

void CRawIP2Flow::UpdateContextState(

	RPacketContext::TContextStatus aState, TInt /*aError*/)

/**

 * Updates the state of the iContextState variable

 *

 * @param aState The new state

 * @param aError A possible error

 */

	{

	// Note that we do not need to close the Flow down if there's been an

	// error, as the context state machine will do this for us.

	iContextStatus = aState;

	}

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

//

// CSubConnectionFlowBase

//

ESock::MFlowBinderControl* CRawIP2Flow::DoGetBinderControlL()

	{

	return iBinderControl;

	}

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

//

// MFlowBinderControl methods

//

ESock::MLowerControl* CRawIP2Flow::GetControlL(const TDesC8& aProtocol)

	{

	// IPv4 and ICMP Protocols

	if (aProtocol.CompareF(KDescIp()) == 0 || aProtocol.CompareF(KDescIcmp()) == 0)

		{

		if (!iBinder)

			{

#ifdef RAWIP_HEADER_APPENDED_TO_PACKETS			

 			iBinder->SetType(KIp4FrameType);

#endif // RAWIP_HEADER_APPENDED_TO_PACKETS			

			}

		else

			{

			}

		}

	// IPv6 Protocol

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

		{

		if (!iBinder)

			{

#ifdef RAWIP_HEADER_APPENDED_TO_PACKETS			

 			iBinder->SetType(KIp6FrameType);

#endif // RAWIP_HEADER_APPENDED_TO_PACKETS						

			}

		else

			{

			}

		}		

	else

		{

		User::Leave(KErrNotSupported);

		}

    return iBinder;

	}

ESock::MLowerDataSender* CRawIP2Flow::BindL(const TDesC8& aProtocol, ESock::MUpperDataReceiver* aReceiver, ESock::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

 */

	{

#ifndef _DEBUG

	(void) aProtocol;

#endif

	ASSERT (aProtocol.CompareF(KDescIp()) == 0 || aProtocol.CompareF(KDescIcmp()) == 0

			|| aProtocol.CompareF(KDescIp6()) == 0);

	ASSERT(iBinder);

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

	return iBinder->Bind(aReceiver, aControl);

	}

void CRawIP2Flow::Unbind(ESock::MUpperDataReceiver* aUpperReceiver, ESock::MUpperControl* aUpperControl)

    {

	ASSERT(iBinder);

	iBinder->Unbind(aUpperReceiver, aUpperControl);

    delete iBinder;

    iBinder = NULL;

    SendDataClientIdleIfNoClients();

    }

void CRawIP2Flow::SendDataClientIdleIfNoClients()

    {

    if (iBinder == NULL)

        {

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

        }

    }

ESock::CSubConnectionFlowBase* CRawIP2Flow::Flow()

/**

Return the Flow corresponding to the MFlowBinderControl

*/

	{

	return this;

	}

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

//

// MCFNode

//

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

    {

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

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

		{

		SubConnectionError(static_cast<TEBase::TError&>(aMessage).iValue);

		}

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

		{

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

			{

		case TEChild::TDestroy::EId :

			Destroy();

			break;

		default:

//TODO - logging

			ASSERT(EFalse);

			}

		}

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

		{

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

			{

		case ESock::TCFDataClient::TStart::EId :

			StartFlowL();

			break;

		case ESock::TCFDataClient::TStop::EId :

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

			break;

		case ESock::TCFDataClient::TProvisionConfig::EId:

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

			break;

		case ESock::TCFDataClient::TBindTo::EId:

            {

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

			if (!bindToReq.iNodeId.IsNull())

				{

				User::Leave(KErrNotSupported);

				}

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

            }

			break;

		default:

//TODO - logging

			ASSERT(EFalse);

			}

		}

	else if (ESock::TCFFlow::ERealmId == aMessage.MessageId().Realm())

		{

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

			{

		case ESock::TCFFlow::TBlock::EId :

			iBlocked = ETrue;

			break;

		case ESock::TCFFlow::TUnBlock::EId :

			iBlocked = EFalse;

			if (iBinder)

				{

				iBinder->StartSending();

				}

			break;

		case ESock::TCFFlow::TRejoin::EId:

			{

			ESock::TCFFlow::TRejoin& rejoinMsg = message_cast<ESock::TCFFlow::TRejoin>(aMessage);

			ESock::TDefaultFlowFactoryQuery query(rejoinMsg.iNodeId);

			CRawIP2Flow* otherFlow = static_cast<CRawIP2Flow*>(Factory().Find(query));

			ASSERT(otherFlow);

			//This rather ugly looking snipped of code implements

			//the scenario whereat the network tears down the default

			//scpr and the default scpr selects a new default amongst

			//the non-default and subsequently performs a transparant

			//swap - i.e.: the upper layer perceives this as a

			//non-default going down. Since the datapath is pre-bound

			//to the flow representing the default, the datapath needs

			//to perform a transparent swap too, so that the upper layer

			//doesn't notice anything. It does that by swapping the

			//flows below the binders.

			CBinderBase* localBinder = iBinder;

			TBinderControlProxy* localBinderControl = iBinderControl;

			iBinder = otherFlow->iBinder;

			otherFlow->iBinder->ChangeFlow(*this);

			localBinder->ChangeFlow(*otherFlow);

			otherFlow->iBinder = localBinder;

			iBinderControl = otherFlow->iBinderControl;

			otherFlow->iBinderControl = localBinderControl;

			otherFlow->iBinderControl->iFlow = otherFlow;

			iBinderControl->iFlow = this;

			iSubConnectionProvider.Close();

			iSubConnectionProvider.Open(address_cast<TNodeId>(rejoinMsg.iNodeId));

			}

			break;

		default:

//TODO - logging

			ASSERT(EFalse);

			}

		}

	else	// not a recognised realm or message

		{

		ASSERT(EFalse);

		}

    }

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

//