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

// Irlan connection control engine 

// 

//

/**

 @file

*/

#include <nifman.h>

#include <nifvar.h>

#include <nifutl.h>

#include <es_mbuf.h>

#include <in_pkt.h>

#include <ir_sock.h>

#include "PKTDRV.H"

#include "ETHINTER.H"

#include "IRLAN.H"

#include "IRLANUTL.H"

#include "INTSOCK.H"

#include "IRLANBUF.H"

#include "IRLANDAT.H"

#include "irlantimer.h"

#include <nifmbuf.h>

//#define __TRACEWIN__

#ifdef __TRACEWIN__

  #include <log.h>

#else

  #define LOG(a)

#endif

/**

Create a new CIrlanControlEngine object.

@param aPktDrv A pointer to CIrlanPktDrv object.

@return A pointer to CIrlanControlEngine object.

*/

CIrlanControlEngine *CIrlanControlEngine::NewL(CIrlanPktDrv* aPktDrv)

{

#ifdef __TRACEWIN__

	LOG(Log::Printf(_L("IRLAN	CIrlanControlEngine::NewL\r\n")));

#endif

	CIrlanControlEngine *cc=new (ELeave) CIrlanControlEngine;

	CleanupStack::PushL(cc);

	cc->ConstructL(aPktDrv);

	CActiveScheduler::Add(cc);

	CleanupStack::Pop();

	return cc;

}

/**

Think this should be a deferred deletion here especially

if IrLAN is already connected.

Destructor.

*/

CIrlanControlEngine::~CIrlanControlEngine()

{

	LOG(Log::Printf(_L("IRLAN	~CIrlanControlEngine\r\n")));

	CIrlanParameter *par;

	TDblQueIter<CIrlanParameter> i(iIrlanParameterList);

	while (par=i++,par!=NULL)

		{

		par->iLink.Deque();

		delete par;

		}

	iDataSendQ.Free();

	if (iTimers)

		iTimers->StopIrlanControlEngineTimer();

	delete iTimers;

	if (iSender)

		{

		iSender->Cancel();

		delete iSender;

		}

	if (iReceiver)

		{

		iReceiver->Cancel();

		delete iReceiver;

		}

	delete iHostResolver;   // do close on this too?

	delete iNetDatabase;	// do close on this too?

	if (iDataSock)

		iDataSock->Close();

	if (iControlSock)

		iControlSock->Close();

	delete iRecvBuffer;

	CActive::Cancel();

}

/**

Default constructor

*/

CIrlanControlEngine::CIrlanControlEngine()

	:CActive(EIrlanControlPriority)

	,iRecvBufPtr(NULL,0)

{

}

/**

The CIrlanControlEngine::ConstructL performs all the memory allocating initialisations.

@param aNotify A pointer to CIrlanPktDrv object.

*/

void CIrlanControlEngine::ConstructL(CIrlanPktDrv* aNotify)

{

#ifdef __TRACEWIN__

	LOG(Log::Printf(_L("IRLAN	CIrlanControlEngine::ConstructL\r\n")));

#endif

	iRecvBufLength=KIrlanBufSize;

	iTimers=CIrlanControlEngineTimers::NewL(this);

	iRecvBuffer=HBufC8::NewMaxL(iRecvBufLength);

	TPtr8 temp=iRecvBuffer->Des();

	iRecvBufPtr.Set(temp);

	iNotify=aNotify;

    iIrlanParameterList.SetOffset(_FOFF(CIrlanParameter,iLink));

}

/**

Handles Errors.

*/

void CIrlanControlEngine::HandleErrorL()

{

#ifdef __TRACEWIN__

	LOG(Log::Printf(_L("IRLAN	Error in CIrlanControlEngine::RunL\r\n")));

#endif

   	switch (iState)

		{

	case E_Idle:

	case E_Query:

	case E_Conn:

		PassiveIdleTransitionL();

		iState=E_PassiveIdle;

		iDiscoveredDevice=0;

		break;

	case E_Data:

		{

		iState=E_Idle;

		iDiscoveredDevice=0;

		TPtr8 dest(&iHWAddr[0],6,6);

		dest.FillZ(6);

		// Tear down the link stuff.

		delete iSender;

		iSender=0;

		delete iReceiver;

		iReceiver=0;

		break;

		}

	default:

		break;

		}

}

/**

Irlan state machine - on hitting this RunL, either iStatus is KErrNone in which case

we have completed OK and can try the next stage or it isn't in which case we must

handle the error appropriately.  The state machine is only rearmed if the phase action

produces some error.  Otherwise, it is left up to the IrDA PRT to call back via the

socket/hostresolver/netDB notifer and for the request to be completed that way.

*/

void CIrlanControlEngine::RunL()

{

#ifdef __TRACEWIN__

	PrintState();

#endif

	RMBufChain pkt;

	TInt ret=KErrNone;

	if (iStatus!=KErrNone)

		{

		HandleErrorL();

		return;

		}

	switch (iState)

		{

	case E_Idle:

		if (iDiscoveredDevice)

			{// An IrDA discovery has been successfully completed.

//			iHostResolver.Close();

			TRAP(ret,QueryRemoteIASL());

			User::LeaveIfError(ret);

			iState=E_Query;

			break;

			}

		ret=AttemptingDiscoveryL();

		// a KErrNone here indicates we're doing a discovery...

		// any other error will be picked up as a PassiveIdleTransition

		break;

	case E_PassiveIdle:

		// the remote side has successfully connected to us

		// now we wait on receipt of remote command frames

		QueueWaitForControlCommand();

		iState=E_Info;

		break;

	case E_Query:

		// A query on remote device's IAS has successfully completed.

  		iOpenRetries=0;

  		ret=ConnectToProviderL();

  		iState=E_Conn;

  		break;

	case E_Conn:

		// Completed OK - send the GetInfoCmd

		ret=GetInfoCmd();

		iState=E_Info;

		break;

	case E_Info:

		// Need to parse response from this query if it comes.

		switch (iAccessType)

			{

		case EAccessPoint:

			if (iAwaitingResponse)

				{

				ParseInfoReply();

				ret=GetMediaCmd();

				iState=E_Media;

				break;

				}

			QueueWaitForControlResponse();

			break;

		case EPeerToPeer:

			if (iAwaitingCommand)

				{

				ParseControlCommand();  // also sends the reply

				break;

				}

			QueueWaitForControlCommand();

			break;

		case EHosted:

			break;

			}

		break;

	case E_Media:

		if (iAwaitingResponse)

			{

			ret=ParseMediaReply();

			User::LeaveIfError(ret);

			ret=OpenDataCmd();

			iState=E_Open;

			break;

			}

		QueueWaitForControlResponse();

		break;

	case E_Open:

		if (iAwaitingResponse)

			{

			ParseOpenDataReply();

			// WE'RE ONLY SUPPORTING ACCESS MODE IRLAN AT PRESENT

			__ASSERT_DEBUG(iAccessType==EAccessPoint,IrlanUtil::Fault(EIrlanInvalidIrlanMode));

			ret=GetDirectedFilterConfigCmd();

			iState=E_FilterConfig;

			break;

			}

		QueueWaitForControlResponse();

		break;

	case E_FilterConfig:

		// This is an extra state I've added to handle filter config stuff

		if (iAwaitingResponse)

			{

			ParseDirectedFilterConfigReply();

			ret=SetDirectedFilterOperationCmd();

			iState=E_FilterOperation;

			break;

			}

		QueueWaitForControlResponse();

		break;

	case E_FilterOperation:

		// This is an extra state I've added to handle filter operation stuff

		if (iAwaitingResponse)

			{

			ParseDirectedFilterOperationReply();

			ret=SetBroadcastFilterOperationCmd();

			iState=E_FilterBroadcast;

			break;

			}

		QueueWaitForControlResponse();

		break;

	case E_FilterBroadcast:

		// This is an extra state I've added to handle broadcast filter stuff

		if (iAwaitingResponse)

			{

			ParseBroadcastFilterOperationReply();

			ConnectToDataChannelL();

			break;

			}

		QueueWaitForControlResponse();

		break;

	case E_Wait:

		// Only needed if acting as a provd.

		break;

	case E_Arb:

		// Only needed if acting as a provd.

		break;

	case E_Data:

		// Once we're here, we can send/receive ethernet packets as data over IrLAN.

		iSender=CIrlanSender::NewL(this,iDataSock);

		iReceiver=CIrlanReceiver::NewL(this,iDataSock);

 		iReceiver->QueueRead();

		if (iDataSendQ.Remove(pkt))

			{

			iSender->QueueSend(pkt);

			pkt.Free();

			}

        iNotify->LinkLayerUp(); //bring up the tcpip stack ect.

		return;

	case E_Close:

		break;

	case E_Sync:

		break;

	default:

		IrlanUtil::Panic(EIrlanErrorState);

		break;

		}

	if (ret!=KErrNone)

	  	ActivateStateMachine(ret);

}

/**

Process the packet received from the LinkLayer.

*/

void CIrlanControlEngine::ProcessReceivedPacketL()

{

	RMBufPacket pkt;

	pkt.CreateL(iRecvBufPtr,0);

	pkt.Pack();

	iNotify->Process(pkt);	// We had a read queued and that has completed

}

/**

Starts up the state machine in E_Idle state - will lead to a discovery attempt.

*/

void CIrlanControlEngine::StartL()

{

	TInt ret;

	iHostResolver=CInternalHostResolver::NewL();

	if ((ret=iHostResolver->OpenL(_L("IrTinyTP"),this))!=KErrNone)

		{

		LOG(Log::Printf(_L("IRLAN	CInternalHostResolver::OpenL failed with err=%d\r\n"),ret));

		User::Leave(ret);

		}

	iState=E_Idle;

	iProtocol=iHostResolver->iProtocol;

	ActivateStateMachine();

}

/**

cancellation of an outstanding request.

*/

void CIrlanControlEngine::DoCancel()

{

	switch (iState)

		{

	case E_Data:

		iSender->DoCancel();

		iReceiver->DoCancel();

		break;

	default:

		break;

		}

}

/** 

Protocol inspects return

It blocks sending if it receives a return <= 0

This value should be propogated up through the stack

@internalComponent

*/

const TInt KStopSending		= 0;

/**

Protocol inspects return to indicate Keep sending the data.

@internalComponent

*/

const TInt KContinueSending	= 1;

/**

Sender Class is generic and does not want to know about RMBuf's

Copy to a Heap Buffer and Free the packet. EtherII MAC layer comments

Say we should free the packet buffer

RMBuf could contain a chain so get into a contiguous buffer

@param aPdu		A reference to the packet to be sent (really an RMBufPkt)

@param aSource  A pointer to the source protocol.

@return 0 Tells the higher layer to stop sending the data.

		1 Tells higher layer that it can continue sending more data.

*/

TInt CIrlanControlEngine::Send(RMBufChain& aPdu, TAny*)

{

	if (iState!=E_Data)

		{// Not ready to send the packet.

		aPdu.Free();

		return KStopSending;

		}

	// Need to stick the packet in a queue and kick the sender...

	iDataSendQ.Append(aPdu);

	iSender->KickSender();

	return KContinueSending;

}

/**

This kicks off the state machine active object.  Completion in RunL..

@param aStat The active object Request complete status.

*/

void CIrlanControlEngine::ActivateStateMachine(TInt aStat)

{

	TRequestStatus *pS=&iStatus;

	User::RequestComplete(pS,aStat);

	SetActive();

}

//*************************** NOTIFIERS **********************************

/**

Upcall from SAP - more data arrived

Indicates that new data is available on a service access point

*/

void CIrlanControlEngine::NewData(TUint /*aCount*/)

{

}

/**

Upcall from SAP - flow control on

Indicates that new buffer space is available on a service 

*/

void CIrlanControlEngine::CanSend()

{

	if (iState==E_Data)

		{

#ifdef __TRACEWIN__

	LOG(Log::Printf(_L("IRLAN	CanSend received from SAP\r\n")));

#endif

		// if there's any data in the queue, force send it!

		if (!iDataSendQ.IsEmpty())

			iSender->KickSender();

		return;

		}

}

/**

This returns the hardware address pulled out of response to

IrLAN FILTER_OPERATION/DYNAMIC request.

@return NULL Failure.

		(NULL Terminated Binary String) The Hardware Address of the interface. LAN Device 

		Specific

@note this will not contain the correct MAC address until IRLAN recives a control frame.

*/

TUint8* CIrlanControlEngine::GetInterfaceAddress()

{

	return &iHWAddr[0];

}

/**

Upcall from SAP.  Notify layer above

Indicates that a connection attempt has completed successfully

*/

void CIrlanControlEngine::ConnectComplete()

{

#ifdef __TRACEWIN__

	LOG(Log::Printf(_L("IRLAN	Control channel connect complete 1\r\n")));

#endif

	ActivateStateMachine();

}

#pragma warning (disable:4100)

/**

Upcall from SAP.  Notify layer above

Indicates that a connection attempt has completed successfully

@param aConnectData Connect data (if supported)  

*/

void CIrlanControlEngine::ConnectComplete(const TDesC8& /*aConnectData*/)

{

	PrintState();

	TInt ret=KErrNone;

	switch (iState)

		{

	case E_Conn:

		// Successful completion of control channel connect.

#ifdef __TRACEWIN__

	LOG(Log::Printf(_L("IRLAN	Control channel connect complete 2 data len=%d\r\n"),aConnectData.Length()));

#endif

		break;

	case E_FilterBroadcast:

		// Successful completion of data channel connect.

#ifdef __TRACEWIN__

	LOG(Log::Printf(_L("IRLAN	Control channel connect complete 2 data len=%d\r\n"),aConnectData.Length()));

#endif

	    iState=E_Data;			// READY TO TRY AND SEND/RECEIVE PACKETS!

		break;

	default:

		ret=KErrNotSupported;

		break;

		}

	ActivateStateMachine(ret);

}

#pragma warning (default:4100)

/**

Upcall from SAP.  Notify layer above

Indicates that a connection attempt has completed successfully

@param aSSP The new SSP for passive opens 

*/

void CIrlanControlEngine::ConnectComplete(CServProviderBase& aSSP)

{

#ifdef __TRACEWIN__

	LOG(Log::Printf(_L("IRLAN	Control channel connect complete 3 - not supported!!\r\n")));

#endif

	iAcceptControlSock=CInternalSocket::NewL(&aSSP,this);

	ActivateStateMachine();

}

/**

Upcall from SAP.  Notify layer above

Indicates that a connection attempt has completed successfully

@param aSSP The new SSP for passive opens