// 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 "RawIPFlow.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;

using namespace ESock;

#ifdef __FLOG_ACTIVE

//These variables are used only if flog is active.

_LIT8(KTcpDumpFirstTag,"TcpDump");

static const TUint16 KTcpDumpLinkType = 12;

#endif

CRawIPFlow::CRawIPFlow(CSubConnectionFlowFactoryBase& aFactory, const TNodeId& aSubConnId, CProtocolIntfBase* aProtocolIntf, CBttLogger* aTheLogger)

/**

 * Constructor.

 *

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

 * @param aTheLogger The logging object, ownership is passed to this object

 */

	: CSubConnectionFlowBase(aFactory, aSubConnId, aProtocolIntf),

	  iTheLogger(aTheLogger),

	  iInitError(KErrNone),

	  iStarted(EFalse),

	  iStopping(EFalse)

	{

	LOG_NODE_CREATE(KNifSubDir, CRawIPFlow);

	}

void CRawIPFlow::ConstructL()

/**

 * Second-phase constructor. Creates the Etel

 * control engine

 *

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

 */

	{

	_LOG_L1C2(_L8("CRawIPFlow %08x:\tConstructL()"), this);

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

	iBcaController = CBcaIoController::NewL(*this, iTheLogger);

	}

CRawIPFlow::~CRawIPFlow()

/**

 * Destructor. Cancels and deletes all owned active objects.

 */

	{

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

	delete iBcaController;

	// This class also deletes the logging object

	delete iTheLogger;

	ASSERT(iBinder == NULL);

	delete iBinderControl;	

	LOG_NODE_DESTROY(KNifSubDir, CRawIPFlow);

	// Cleanup when stop was not called - harmless as it null's the pointer

	__PACKETLOG_DELETE;

	}

void CRawIPFlow::StartFlowL()

/**

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

 * complete, LinkLayerUp() will be called.

 *

 * Called in response to corresponding SCPR message.

 *

 * @return Allways KErrNone

 */

	{

	ASSERT(iStarting==EFalse);

	iStarting = ETrue;

	_LOG_L1C2(_L8("CRawIPFlow %08x:\tStartFlowL()"), this);

	// 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(MControllerObserver::EStart, KErrNone);

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

#ifdef __FLOG_ACTIVE

	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(iProvision->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);

	TRAPD(err,__PACKETLOG_NEWL(KTcpDumpFirstTag, logFileName, CPacketLogger::ETcpDump, KTcpDumpLinkType));

	if (err)

		{

		_LOG_L1C1(_L8("Trapped leave from __PACKETLOG_NEWL"));

		}

	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);

	_LOG_L1C1(logText);

#endif

	}

void CRawIPFlow::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.

 */

	{

	_LOG_L1C2(_L8("CRawIPFlow %08x:\tLinkLayerUp()"), this);

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

	iBinder->StartSending();

	iStarted = ETrue;

	iStarting = EFalse;

	}

void CRawIPFlow::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

 */

	{

	_LOG_L1C3(_L8("CRawIPFlow %08x:\tLinkLayerDown(aError %d)"), this, aError);

	__PACKETLOG_DELETE;

	if (iStopping)

		{

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

		}

    else if (iStarting)

		{

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

		}

	else

		{

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

		}

    iStarted = EFalse;

    iStarting = EFalse;

    iStopping = EFalse;

	}

void CRawIPFlow::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

 */

	{

	_LOG_L1C3(_L8("CRawIPFlow %08x:\tStopFlow(aError %d)"), this, aError);

	__PACKETLOG_DELETE;

	iStopping = ETrue;

	ShutDown(MControllerObserver::EInitialised, aError);

	}

							   TUint16 /*aType*/)

/**

 * Sends a packet, via the BCA controller. This method is protocol-agnostic,

 * and is called by the IPv4 and IPv6 binder to actually send packets.

 *

 * @param aPdu The packet to send

 */

	{

	}

void CRawIPFlow::Process(RMBufChain& aPdu, TUint16 aProtocolCode)

/**

 * Handles incoming packets which have been passed up from the BCA controller.

 * If the IPv4 binder wants to process the packet, it hands it on; otherwise,

 * the packet is binned.

 *

 * @param aPdu The incoming packet

 */

	{

	_LOG_L1C3(_L8("CRawIPFlow %08x:\tProcess() [aPdu length=%d]"),

		this, aPdu.Length() - aPdu.First()->Length());

	// If the packet has zero or negative length, bin it.

	if ((aPdu.Length() - aPdu.First()->Length()) <= 0)

		{

		_LOG_L1C1(_L8("Dumped packet: illegal length"));

		aPdu.Free();

		return;

		}

	// See if the protocol interface wants the packet.

	if (iBinder && iBinder->WantsProtocol(aProtocolCode))

		{

		__PACKETLOG_WRITE_PACKET(aPdu, 0);

		iBinder->Process(aPdu);

		}

	else

		{

		// The protocol didn't want the packet, so bin it.

		_LOG_L1C2(_L8("Packet was not processed: freeing (protocol code: %X)"),

			aProtocolCode);

		if (iBinder == NULL)

			{

			_LOG_L1C2(_L8("CRawIPFlow %08x:\tProcess(): NOTE: Binder not present"), this);

			}

		aPdu.Free();

		}

	}

void CRawIPFlow::ResumeSending()

/**

 * Notifies the protocol interface that it can resume sending packets.

 */

	{

	_LOG_L1C2(_L8("CRawIPFlow %08x:\tResumeSending()"), this);

	if (iBinder)

		{

		iBinder->StartSending();

		}

	else

		{

		_LOG_L1C2(_L8("CRawIPFlow %08x:\tResumeSending(): NOTE: Binder not present"), this);

		}

	}

void CRawIPFlow::InitialiseL(TInitialisationState aState, TInt aError)

/**

 * 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

 */

	{

	_LOG_L1C4(_L8("CRawIPFlow %08x:\tInitialiseL(aState %d, aError %d)"),

		this, aState, aError);		

	if (aError != KErrNone)

		{

		_LOG_L2C2(_L8("  *** FAILED to initialise NIF *** Error =%d"),aError);

		// Initialise shutdown sequence

		switch (aState)

		{

		case MControllerObserver::EBcaController:

			ShutDown(MControllerObserver::EInitialised, aError);

			break;

		default:

			_LOG_L2C3(_L8("ERROR CRawIPFlow: Unknown state:%d in NIF: %S"), aState, &KNifName);

			User::Leave(KErrUnknown);

			break;

			}

		return;

		}

	switch (aState)

		{

	case MControllerObserver::EStart:

		{

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

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

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

		_LOG_L1C2(_L8("Port details %S"), &iProvision->GetPortName());

		iBcaController->SetPort(iProvision->GetPortName());

		_LOG_L1C3(_L8("bcaName details %S,%S"),&iProvision->GetBCAStack(), &iProvision->GetBCAName());

		iBcaController->SetBcaStackAndName(iProvision->GetBCAStack(), iProvision->GetBCAName());

		_LOG_L1C2(_L8("IAP ID details %u"), iProvision->GetIAPid());

		iBcaController->SetIapId(iProvision->GetIAPid());

		UpdateContextState(RPacketContext::EStatusActive, KErrNone);

		iBcaController->StartL();

		}

		break;

	case MControllerObserver::EBcaController:

		_LOG_L1C1(_L8("  ***** NIF INITIALISED *****"));

		LinkLayerUp();

		break;

	default:

		_LOG_L2C3(_L8("ERROR CRawIPFlow: Unknown state:%d in NIF: %S"), aState, &KNifName);

		User::Leave(KErrUnknown);

		break;

		}

	}

void CRawIPFlow::ShutDown(TInitialisationState aState, 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)

 */

	{

	_LOG_L1C4(_L8("CRawIPFlow %08x:\tShutDown(aState %d, aError %d)"),

		this, aState, aError);	

	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;

		}

	switch (aState)

		{

	case MControllerObserver::EInitialised:

		iBcaController->Stop(aError);

		break;

	case MControllerObserver::EBcaController:

		LinkLayerDown(iInitError);

		break;

	default:

		_LOG_L2C1(_L8("ERROR CRawIPFlow: Unknown Shutdown step"));

		_BTT_PANIC(KNifName,KNifUnknownShutDownState);

		break;

		}

	}

CBinderBase* CRawIPFlow::GetBinder()

/**

 * Returns a pointer to the Binder class

 *

 * @return a pointer to a CBinderBase derived class

 */

	{

	return iBinder;

	}

CBcaIoController* CRawIPFlow::GetBcaController()

/**

 * Returns a pointer to the CBcaIoController class

 *

 * @return a pointer to CBcaIoController

 */

	{

	return iBcaController;

	}

void CRawIPFlow::UpdateContextState(

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

/**

 * Updates the state of the iContextState variable

 *

 * @param aState The new state

 * @param aError A possible error

 */

	{

	_LOG_L1C3(_L8("CRawIPFlow %08x:\tUpdateContextState(aState %d)"), this, aState);

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

//

MFlowBinderControl* CRawIPFlow::DoGetBinderControlL()

	{

	return iBinderControl;

	}

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

//

// MFlowBinderControl methods

//

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

	{

#ifdef __BTT_LOGGING__

	//TBuf8<256> debugBuffer;

	//debugBuffer.Copy(aProtocol);

	_LOG_L1C3(_L8("CRawIPFlow %08x:\tGetControlL(aProtocol %S)"), this, &aProtocol);

#endif

	// IPv4 and ICMP Protocols

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

		{

		if (!iBinder)

			{

			iBinder = new (ELeave) CIPv4Binder(*this, iTheLogger);

#ifdef RAWIP_HEADER_APPENDED_TO_PACKETS

 			iBcaController->SetType(KIp4FrameType);

#endif // RAWIP_HEADER_APPENDED_TO_PACKETS

			}

		else

			{

			_LOG_L1C2(_L8("CRawIPFlow %08x:\tGetControlL(): IPv4 binder already exists"), this);

			}

		}

	// IPv6 Protocol

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

		{

		if (!iBinder)

			{

			iBinder = new (ELeave) CIPv6Binder(*this, iTheLogger);

#ifdef RAWIP_HEADER_APPENDED_TO_PACKETS

 			iBcaController->SetType(KIp6FrameType);

#endif // RAWIP_HEADER_APPENDED_TO_PACKETS

			}

		else

			{

			_LOG_L1C2(_L8("CRawIPFlow %08x:\tGetControlL(): IPv6 binder already exists"), this);

			}

		}		

	else

		{

		User::Leave(KErrNotSupported);

		}

    return iBinder;

	}

MLowerDataSender* CRawIPFlow::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

 */

	{

#ifndef _DEBUG

	(void) aProtocol;

#endif

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

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

	ASSERT(iBinder);

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

	return iBinder->Bind(aReceiver, aControl);

	}

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

    {

    _LOG_L1C2(_L8("CRawIPFlow %08x:\tUnbind()"), this);

	if (iBinder)

	    {

        iBinder->Unbind(aUpperReceiver, aUpperControl);

        delete iBinder;