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

//

#include "PPPLCP.H"

#include "PPPBASE.H"

#include "PPPLOG.H"

#include "ncpip.h"

#include "PPPCCP.H" // for KPppIdCcp

#include <es_ini.h>

//

// PPP State machine

//

MPppFsm::MPppFsm(CPppLcp* aPppLcp, TPppPhase aPhase, TUint aPppId)

	: MPppRecvr(aPppLcp, aPhase, aPppId),	

	// Values may be initialized via  .ini file, but unless specified otherwise:

	iTerminateRequestEnabled(ETrue), // RFC-compliant termination phase (TerminateRequest) is enabled

	iTerminateAckEnabled(ETrue),     // RFC-compliant termination phase (TerminateAck) is enabled

	iFsmTerminationCauseError(KErrNone),

	iMaxTerminateRequest(KPppFsmTerminateRequestRetries),      // Wait after Sending TerminateRequest

	iTerminateRequestTimeout(KPppFsmTerminateRequestTimeout),  // Wait for TerminateAck after sending TerminateRequest	

	iTerminateAckTimeout(KPppFsmTerminateAckTimeout),           // Wait after sending TerminateAck

	iFsmTermination(EFalse),

	iNoEvidenceOfPeer(EFalse),

	iWaitTimeNoIncrease(EFalse)

	{

	}

MPppFsm::~MPppFsm()

	{

	TimerDelete();

	if (!iRequestList.IsEmpty())

		iRequestList.Free();

	}

void MPppFsm::FsmConstructL()

/**

Construct the state machine object

*/

	{

	ReadIniFileL();

	// Dump the configuration resulting from the .ini file:

	LOG(iPppLcp->iLogger->Printf(_L("%s FSM: TerminateRequestEnabled[%d], MaxTerminateRequest[%d], TerminateRequestTimeout[%d]"),\

		__iFsmName,	

		iTerminateRequestEnabled,

		iMaxTerminateRequest,

		iTerminateRequestTimeout);)

	LOG(iPppLcp->iLogger->Printf(_L("%s FSM: TerminateAckEnabled[%d], TerminateAckTimeout[%d]"),\

		__iFsmName,

		iTerminateAckEnabled,

		iTerminateAckTimeout);)

	TimerConstructL(KPppFsmTimerPriority);

	}

void MPppFsm::TerminateLink()

/**

Tear down the protocol, regardless of the state of the FSM.

*/

	{

	// Support for Termination Phase.

	// This is not according to the RFC, but it is done to avoid 

	// any regressions in the existing PPP.	

	switch(iState) 

		{		

		case EPppFsmStopping: // We have received TerminateRequest, sent TerminateAck and

							  // are waiting for one timeout to expire.

			break;	// Stay in EPppFsmStopping state            

		default: 

			SendInitialTerminateRequest();

			SetState(EPppFsmClosing);

		}			

	}

//

// Open/Close calls from higher level protocols

//

TInt MPppFsm::FsmOpen()

/**

Begin the state machine and protocol.

Called by the derived class during initialization.

@return KErrNone if successful, otherwise one of the system-wide error codes

*/

	{

	LOG( iPppLcp->iLogger->Printf(_L("%s FSM Open Request"), __iFsmName); )

	TInt err = KErrNone;

	InitMaxFailure();

	switch (iState)

		{

	case EPppFsmInitial:

		err = FsmLayerStarted();

		SetState(EPppFsmStarting);

		break;

	case EPppFsmStarting:

		break;

	case EPppFsmClosed:

		err = FsmLayerStarted();

		SendInitialConfigRequest();

		SetState(EPppFsmReqSent);

		break;

	case EPppFsmStopped:

	case EPppFsmClosing:

	case EPppFsmStopping:

	case EPppFsmOpened:

		// Check that we *really* want to do this!

		LowerLayerDown();

		LowerLayerUp();

		break;

	case EPppFsmReqSent:

	case EPppFsmAckRecvd:

	case EPppFsmAckSent:

		break;

		}

	iPppAbortCode = KErrNone;

	return err;

	}

void MPppFsm::FsmClose(TInt aReason)

/**

Close the state machine and protocol.

Called by the derived class on closing.

@param aReason Reason for closing

*/

	{

	LOG( iPppLcp->iLogger->Printf(_L("%s FSM Close Request, error[%d]"), __iFsmName, aReason); )

	switch (iState)

		{

	case EPppFsmInitial:

	case EPppFsmClosed:

	case EPppFsmClosing:

		break;

	case EPppFsmStarting:

		FsmLayerFinished();

		SetState(EPppFsmInitial);

		break;

	case EPppFsmStopped:

		SetState(EPppFsmClosed);

		break;

	case EPppFsmStopping:

		SetState(EPppFsmClosing);

		break;

	case EPppFsmOpened:

		FsmLayerDown(aReason);

		// continue into next statement

	case EPppFsmReqSent:

	case EPppFsmAckRecvd:

	case EPppFsmAckSent:

		SendInitialTerminateRequest();

		SetState(EPppFsmClosing);

		break;

		}

	}

void MPppFsm::FsmAbort(TInt aReason)

/**

Abort the protocol.

@param aReason Reason for aborting

*/

// 29.11.00.  Changed slightly so that this does the same as RXJ- 

// in the PPP RFC for all states.

	{

	LOG( iPppLcp->iLogger->Printf(_L("%s FSM Abort Request, error[%d]"), __iFsmName, aReason); )

	switch (iState)

		{

	case EPppFsmInitial:

	case EPppFsmStarting:

		// bad event

		break;

	case EPppFsmClosed:

	case EPppFsmStopped:

		FsmLayerFinished();

		break;

	case EPppFsmClosing:

		FsmLayerFinished();

		SetState(EPppFsmClosed);

		break;

	case EPppFsmStopping:

		FsmLayerFinished();

		SetState(EPppFsmStopped);

		break;

	case EPppFsmOpened:

		FsmLayerDown();

		SendInitialTerminateRequest();

		SetState(EPppFsmStopping);

		break;

	case EPppFsmReqSent:

	case EPppFsmAckRecvd:

	case EPppFsmAckSent:

		FsmLayerFinished(aReason);

		SetState(EPppFsmStopped);

		break;

		}

	iPppAbortCode = aReason;

	}

//

// Upcall from Timer

//

EXPORT_C void MPppFsm::TimerComplete(TInt /*aStatus*/)

/**

Called by MTimer on timer expiry.

@param aStatus Aynchronous request completion status (ignored)

*/

	{

	LOG( iPppLcp->iLogger->Printf(_L("%s FSM Timer Expired %d "), __iFsmName, iRestartCount); )

	switch (iState)

		{

	case EPppFsmInitial:

	case EPppFsmStarting:

	case EPppFsmClosed:

	case EPppFsmStopped:

	case EPppFsmOpened:

		// Bad Event

		return;

	default:

		break;

		}

	if (iRestartCount>0)

		{

		switch (iState)

			{

		case EPppFsmClosing:

		case EPppFsmStopping:

			SendTerminateRequest();

			break;

		case EPppFsmReqSent:

		case EPppFsmAckRecvd:

		case EPppFsmAckSent:

			//PG RFC 1661 4.6 double timeout period

			// Allow for configuration of non-doubling of timeout period (initially for

			// conformance testing) - default behaviour is for doubling to occur.

			if (!iWaitTimeNoIncrease && iWaitTime*2 < KPppFsmRequestMaxTimeout)

				{

				iWaitTime = iWaitTime * 2;

				}

			SendConfigRequest();

			if(iState == EPppFsmAckRecvd)

				SetState(EPppFsmReqSent);

			break;

		default:

			break;

			}

		}

	else		

		{		

 		switch(iState)

  			{

  			case EPppFsmClosing: // We sent out TerminateRequests, no TerminateAcks received.

 				FsmLayerFinished(iFsmTerminationCauseError); // Authoritative Close of the Link --> KErrCancel

  				break;

  			case EPppFsmStopping: // We've sent TerminateAck and waited one restart period

  				FsmLayerFinished(iFsmTerminationCauseError); // Peer initiated disconnection.

  				break;

  			default:

  				// Don't abort if we're configured to persist.

  				if(!iPersist)

  					{

  					iFsmTermination = ETrue; // Used later to bring down the FSM as opposed to restarting it.

  					FsmLayerFinished(KErrTimedOut);

  					}

  				else

 					{

 					LOG( iPppLcp->iLogger->Printf(_L("%s FSM going idle"), __iFsmName); )

 					}

  				break;

  			}

		switch (iState)

			{

		case EPppFsmClosing:

			SetState(EPppFsmClosed);

			break;

		case EPppFsmStopping:

		case EPppFsmReqSent:

		case EPppFsmAckRecvd:

		case EPppFsmAckSent:

			SetState(EPppFsmStopped);

			break;

		case EPppFsmInitial:

		case EPppFsmStarting:

		case EPppFsmClosed:

		case EPppFsmStopped:

		case EPppFsmOpened:

		default:

			break;

			}

		}

	}

//

// Upcalls from Recvr

//

EXPORT_C void MPppFsm::LowerLayerUp()

/**

Called when the lower layer protocol has come up.

*/

	{

	LOG( iPppLcp->iLogger->Printf(_L("%s FSM Up Event"), __iFsmName); )

	switch (iState)

		{

	case EPppFsmInitial:

		SetState(EPppFsmOpened);

		break;

	case EPppFsmStarting:

		SendInitialConfigRequest();

		SetState(EPppFsmReqSent);

		break;

	case EPppFsmClosed:

	case EPppFsmStopped:

	case EPppFsmClosing:

	case EPppFsmStopping:

	case EPppFsmReqSent:

	case EPppFsmAckRecvd:

	case EPppFsmAckSent:

	case EPppFsmOpened:

		// Bad Event

		break;

		}

	}

EXPORT_C void MPppFsm::LowerLayerDown(TInt aStatus)

/**

Signals the Down event.

Called when the lower layer protocol has gone down.

This means that our layer can no longer receive or transmit anything.

In case of LCP, this means that the physical link is closed (e.g. Peer dropped DTR)

If we are LCP, this may mean that PPP is finished, because the link is no longer available.

@param aStatus Error code indicating the reason the layer is going down

*/

	{

	LOG( iPppLcp->iLogger->Printf(_L("%s FSM Down Event, error[%d]"), __iFsmName, aStatus); )

	switch (iState)

		{

	case EPppFsmInitial:

		// Bad Event

		break;

	case EPppFsmStarting:

		FsmLayerDown(aStatus);

		break;

	case EPppFsmClosed:

		SetState(EPppFsmInitial);

		break;

	case EPppFsmClosing: // We are waiting for Terminate Ack (or TerminateRequest retransmission)

		SetState(EPppFsmInitial);

		break;

	case EPppFsmStopped:

		if(!iFsmTermination) // We are not terminating, so we restart the FSM.

			{

			FsmLayerStarted();

			SetState(EPppFsmStarting);

			return; // The alternative is calling FsmTerminationPhaseComplete from every case.	

			}

		// If we are terminating, we terminate the FSM and notify Nifman that the NIF is finished.				

		SetState(EPppFsmStarting);

		break;

	case EPppFsmStopping: // We are waiting 1 restart period after transmitting Terminate Ack 

		SetState(EPppFsmStarting);

		break;

	case EPppFsmReqSent:

	case EPppFsmAckRecvd:

	case EPppFsmAckSent:

		FsmLayerDown(aStatus);

		SetState(EPppFsmStarting);

		break;

	case EPppFsmOpened:

		FsmLayerDown(aStatus);

		SetState(EPppFsmStarting);

		break;

		}

	// This call is critical to make sure PPP reports its demise correctly. Otherwise, Nifman remains unaware, and 

	// ESock / Nifman / PPP hangs.	

	FsmTerminationPhaseComplete(); // ASSUMPTION: LCP signals to Nifman. Others do nothing.	

	// Note: early return from EPppFsmStopped.

	}

EXPORT_C void MPppFsm::FrameError()

/**

Called when a bad frame is received.

No action is currently taken.

@see RecvFrame() is called instead when a good frame is received

*/

	{

	return;

	}

EXPORT_C void MPppFsm::KillProtocol()

/**

Called when the lower level protocol is killed.

*/

	{

	//

	// This came to light as a result of the CCP work

	// This happens if a protocol is told to shut down,

	// I'm not sure how to handle it?? Do we just Stop it???

	//

	return;

	}

EXPORT_C TBool MPppFsm::RecvFrame(RMBufChain& aPacket)

/**

Receives and processes a PPP frame.

Called by CPppLcp.

@see FrameError() is called instead when a bad frame is received

@param aPacket MBuf chain containing packet

@return EFalse

*/

	{

	RMBufPacket pkt;

	pkt.Assign(aPacket);

	pkt.Unpack();

	RMBufPktInfo* info = pkt.Info();

	TUint8 op;

	TUint8 id;

	TInt len;

	// Extract and drop LCP header

	pkt.Align(4);

	TUint8* ptr = pkt.First()->Ptr();

	op = *ptr++;

	id = *ptr++;

	len = BigEndian::Get16(ptr);

	// Check packet length is OK

	if (info->iLength<len || info->iLength<4 )

		{

		// Too short!

		pkt.Free();

		return EFalse;

		}

	else if (info->iLength > len)

		pkt.TrimEnd(len);

	// Received a potentially valid packet; probably we have a meaningful relationship with peer

	iNoEvidenceOfPeer = EFalse;	

	// If op is unknown

	switch (op)

		{

	case KPppLcpConfigAck:

	case KPppLcpConfigNak:

	case KPppLcpConfigReject:

		// Filter out bad acks

		if (iState>=EPppFsmReqSent && id!=iRequestId)

			break;

		else

			iRequestId |= KPppRequestIdAnswered;

		// fall through ...

	case KPppLcpConfigRequest:

		// Option negotiation ops

		// Split the MBuf chain in separate options

		//if(len<=4)

		if(len<4)

			break;

		//

		// Hmmm sometimes we receive a Config request of Length 4

		// i.e. no options Send a Config ACK

		// 

		if ( (len == 4) && (op == KPppLcpConfigRequest))

			{

			 if (ProcessEmptyConfigReq())

				{

				if (iPppId == KPppIdCcp)

					{

					// For empty CCP Config Requests send a Protocol Reject,

					// otherwise we can end up continually exchanging empty

					// Config Requests and Config ACK's.  KPppIdLcp is passed to

					// CPppHdlcLink::Send() via FsmRejectPacket() to ensure

					// transmission of an *LCP* Protocol Reject of CCP rather than

					// a *CCP* Protocol Reject of CCP (subtle difference).

					pkt.Pack();

					FsmRejectPacket(pkt, KPppLcpProtocolReject, KPppIdLcp);

					}

				else

					{

					// Send an acknowledgement

					ptr = pkt.First()->Ptr();

					*ptr = KPppLcpConfigAck;

					pkt.Pack();

					SendFrame(pkt);

					}

				}

			 else

				{

				break;

				}

			}

		else if (len == 4 && (op != KPppLcpConfigAck && iPppLcp->QueryExternalIPConfiguration()))

			{

			// With Mobile IP, there is the possibility of having no options to negotiate, in which