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

// This module contains the code for the dummy PPP Nif class which communicates with the upper PPP Nif

// via PPP "proxy"

// 

//

#include <comms-infras/nifif.h>

#include <nifvar.h>

#include <nifutl.h>

#include <es_mbuf.h>

#include <comms-infras/commsdebugutility.h>

#include <connectprog.h>

#include <in_chk.h>

#include <commsdattypeinfov1_1.h>

//New ppp progress states file

#include "PppProg.h"

#include "dummypppnif.h"

#include "DummyPPPNifVar.h"

const TInt KLoWatMark = 2;

const TInt KHiWatMark = 6;

// Internal flag bits used  

const TUint KDummyPPPSendBusy = 0x00001000;

const TUint KDummyPPPApplyPending = 0x00010000;

//only for generating the logs

_LIT(KCodeTextString,"	%s [0x%02x]");

_LIT(KCodeTextWithoutSpacesString,"	%s [0x%02x]");

_LIT(KIdentifierLengthString,"	Id = 0x%02x, Len = %d");

_LIT(KLengthString,"	Length = %d");

_LIT(KLengthString2,"	    Length = 0x%02x");

_LIT(KTCPLengthString,"	    Length = %d, Hdr len = %d");

_LIT(KUDPLengthPortString,"	    Length = %d, Src port = %d, Dst port = %d");

_LIT(KBytesRemainingString,"        %d byte%s remaining");

_LIT(KLcpCodeString,"	Code = %s [0x%02x]");

_LIT(KCodeString,"	Code = 0x%02x");

_LIT(KCodeString2,"	Code = 0x%04x");

_LIT(KProtocolString,"	Protocol = 0x%04x");

_LIT(KNumberString,"	Number = 0x%08x");

_LIT(KSecondsString,"	Seconds = %d");

_LIT(KSizeString,"	    Size = %d");

_LIT(KMapString,"	    Map = 0x%08x");

_LIT(KProtocolTextString,"	    Protocol = %s [0x%04x]");

_LIT(KLcpOptFcsTypeString,"	    Types =%s%s%s");

_LIT(KMaximumBytesString,"	    Maximum bytes = %d");

_LIT(KUserNameString,"	Username = \"%S\"");

_LIT(KPasswordString,"	Password = \"%S\"");

_LIT(KMessageString,"	Message = \"%S\"");

_LIT(KDelayString,"	    Delay=%d\n");

_LIT(KNameString,"	Name = \"%S\"");

_LIT(KChangeMaskString,"	Change Mask = 0x%x: ");

_LIT(KChecksumString,"	Checksum = 0x%x");

_LIT(KChecksumString3,"	    Chksum = 0x%04x (0x%04x) !!!");

_LIT(KConnectionString,"	    Connection = 0x%x");

_LIT(KHdrLengthString,"	Length = %d, Hdr len = %d");

_LIT(KIDFragmentString,"	Id = 0x%04x, Fragment = %d %s%s%s");

_LIT(KSrcDstAddrString,"	Src = %d.%d.%d.%d, Dst = %d.%d.%d.%d");

_LIT(KIpv6SrcAddress,"    Src = %x:%x:%x:%x:%x:%x:%x:%x");

_LIT(KIpv6DstAddress,"    Dst = %x:%x:%x:%x:%x:%x:%x:%x");

_LIT(KIpv6Class,"    Class = %d");

_LIT(KIpv6FlowLabel,"    FlowLabel = %d");

_LIT(KIpv6PayloadLen,"    Payload = %d words");

_LIT(KIpv6NextHeadType,"    Next Header type is [%d]");

_LIT(KIpv6HopLimit,"    Hop Limit is %d");

_LIT(KIpv6UnknownHeadType,"    Unknown next header: [%d]");

_LIT(KConnectionNoString,"	Connection number [0x%02x]");

_LIT(KRemoteAddrString,"	    Remote Address = %d.%d.%d.%d");

_LIT(KOurAddrString,"	    Our Address = %d.%d.%d.%d");

_LIT(KMaxSlotString,"	      Max Slot Id = %d");

_LIT(KCompSlotString,"	      Comp Slot Id = %d");

_LIT(KAddrString,"	    Address = %d.%d.%d.%d");

_LIT(KPortString,"	    Src port = %d, Dst port = %d");

_LIT(KWindowUrgentString,"	    Window = %d, Urgent = %d");

_LIT(KSeqAckString,"	    Seq = 0x%08x, Ack = 0x%08x");

_LIT(KFlagsString,"	    Flags = %s%s%s%s%s%s");

#define EIGHT_SPACE_MARGIN			_S("        ")

#define FOURTEEN_SPACE_MARGIN		_S("              ")

/*

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

 */

#ifdef __FLOG_ACTIVE

_LIT8(KDummyPppLogFolder	,"dummypppnif");

_LIT8(KDummyPppLogFile, "dummypppnif.txt");

#endif // #ifdef __FLOG_ACTIVE

_LIT(KEndOfLine, "\n");

/*

 * The Link class

 */

CDummyPPPLink::CDummyPPPLink(CNifIfFactory& aFactory)

	: CNifIfLink(aFactory)

	{

	CDummyNifLog::Printf(_L("Dummy PPP Link Created\r\n"));

	}

CDummyPPPLink::~CDummyPPPLink()

	{

	CDummyNifLog::Printf(_L("Dummy PPP Link Destroyed\r\n"));

	TimerDelete();

	iNifIf->End();

	iNifIf->CloseLog();

	}

void CDummyPPPLink::OpenL()

//

// Start connect establishment

//

	{

	switch (iState)

		{

	case EDummyPPPLinkConnecting:

	case EDummyPPPLinkOpen:

		return;

	case EDummyPPPLinkClosed:

		iState = EDummyPPPLinkConnecting;

		break;

	default:

		return;

		}

	CDummyNifLog::Printf(_L("Dummy PPP LinkOpen\r\n"));

	}

void CDummyPPPLink::LinkDown(TInt /*aStatus*/)

//

// Link down - drop out of packet mode

// and notify reason

//

	{

	CDummyNifLog::Printf(_L("Dummy PPP LinkDown\r\n"));

	iState = EDummyPPPLinkClosed;

	}

TInt CDummyPPPLink::Send(RMBufChain& aPdu, TAny* aSource)

	{

	CDummyNifLog::Printf(_L("Dummy PPP LinkSend\r\n"));

	return iNifIf->Send(aPdu, aSource);

	}

TInt CDummyPPPIf::Send(RMBufChain& aPacket, TAny* )

{

	//To send over serial port to NTRAS

	//return Send(aPacket, iDummyPPPId);

	CDummyNifLog::Write(_L("DummyPPP::RecvdfromPPP\n"));

	CDummyNifLog::Printf(_L("Dummy PPP Send\r\n"));

	logUser->Dump(aPacket, KDummyPPPRecvChannel);

	//Added to send to PPP interface directly

	if(!ProcessPPPPacket(aPacket))

	{

		if(SwitchIPHeaders(*ptrTransPktPPP))

		{

			SendtoPPP(*ptrTransPktPPP);

		}

	}

	return iSendFlowOn;

}

TInt CDummyPPPIf::SwitchIPHeaders(RMBufChain& aPacket)

{

	CDummyNifLog::Printf(_L("DummyPPP::SwitchIPHeaders\r\n"));

	TInt iResult = 0;

	// this received data has already been looped back...

	// get the ip header from the RMBufChain

	TInet6HeaderIP4* ip4 = (TInet6HeaderIP4*) aPacket.First()->Next()->Ptr();

	// get the udp header as well - assume only udp traffic here

	TInet6HeaderUDP* udp = (TInet6HeaderUDP*) ip4->EndPtr();

	TUint dstPort = udp->DstPort();

	if(KDummyPppNifCmdPort == dstPort)

	{	

		// let's use the first payload byte as the command byte

		if(*(udp->EndPtr())== KForceDisconnect)

		{

			CDummyNifLog::Printf(_L("DummyPPP::Sending LinkLayerDown signal\r\n"));

			// do some action

			iNotify->IfProgress(KLinkLayerClosed, KErrCommsLineFail);

			iNotify->LinkLayerDown(KErrCommsLineFail, MNifIfNotify::EDisconnect);

		}

	}

	else

	{

		// update the headers (addresses, checksums etc) to UpdateHeaders(ip4, udp);

		// swap over the destination and source addresses

		TUint32 tempSrc,tempDest;

		tempSrc = ip4->SrcAddr();

		tempDest = ip4->DstAddr();

		ip4->SetSrcAddr(tempDest);

		ip4->SetDstAddr(tempSrc);

		TUint tempChksum;

		tempChksum = ip4->Checksum();

		// we've changed the ip hdr so need to recalculate the ip hdr checksum

		ip4->SetChecksum(0); 

		tempChksum = TChecksum::Calculate((TUint16*)ip4, ip4->HeaderLength());

		tempChksum = TChecksum::ComplementedFold(tempChksum);

		ip4->SetChecksum(tempChksum);

		//ip4->SetChecksum(TChecksum::ComplementedFold(TChecksum::Calculate((TUint16*)ip4, ip4->HeaderLength())));

		// also want to set the udp checksum to zero cos it will be wrong now that we have 

		// changed the ip hdr - just set to zero and it is ignored

		udp->SetChecksum(0);

		iResult = 1;

	}

	return iResult;

}

void CDummyPPPIf::SendtoPPP(RMBufChain& aPacket)

{

	CDummyNifLog::Printf(_L("Dummy PPP SendtoPPP\r\n"));

	iSendNumBufs += aPacket.NumBufs();

	iLink->iSendQ.Append(aPacket);

	switch (iLink->iState)

		{

	case EDummyPPPLinkConnecting:

		aPacket.Free();

		break;

	case EDummyPPPLinkOpen:

		if (iSendFlowOn && iSendNumBufs>=iSendHiWat)

			{

			iSendFlowOn = EFalse;

			CDummyNifLog::Printf(_L("DummyPPP::SendtoPPP() Flow off, iSendNumBufs %d"), iSendNumBufs);

			}

		else if (!(iFlags & KDummyPPPSendBusy))

			DoSendtoPPP();

		break;

	case EDummyPPPLinkClosed:

		{

		TRAPD(err, iLink->OpenL());

		aPacket.Free();

		}

		break;

	default:

		aPacket.Free();

		break;

		}

	iSendCallBack->CallBack();

}

TInt CDummyPPPIf::SendCallBack(TAny* aCProtocol)

	{

	((CDummyPPPIf*)aCProtocol)->DoSendtoPPP();

	return 0;

	}

void CDummyPPPIf::DoSendtoPPP()

{

	if (iFlags & KDummyPPPSendBusy)

		return;

    if (ipktRecvPPP.IsEmpty())

	{

   		RMBufPacket pkt;

		if (!iLink->iSendQ.Remove(pkt))

		{

			iSendNumBufs=0; // Must be so

			return;

		}

		CDummyNifLog::Write(_L("DummyPPP::DoSendtoPPP()\n"));

		logUser->Dump(pkt, KDummyPPPSendChannel);

		// Get next packet from send queue

		do

			{

			iFlags |= KDummyPPPSendBusy;

			iSendNumBufs -= pkt.NumBufs();

			iProtocol->Process(pkt, (CProtocolBase*)this);

			// the following Free() may not actually do anything if the packet has already been freed.

			pkt.Free();

			if (!iSendFlowOn && iSendNumBufs<iSendLoWat)

				{

				CDummyNifLog::Printf(_L("DummyPPP::DoSendtoPPP(): Flow on, iSendNumBufs %d"), iSendNumBufs);

				iSendFlowOn = ETrue;

				//for CppLcp's LinkFlowOn()

				iProtocol->StartSending(iProtocol);

				}

			} while (iLink->iSendQ.Remove(pkt));

		iFlags &= ~KDummyPPPSendBusy;

	}

}

TInt CDummyPPPIf::ProcessPPPPacket(RMBufChain& aPacket)

/**

 * Processes all packets received from PPP

 *

 * @param RMBufChain& aPacket

 * @returns nonzero if completed task

 * @returns 0 if need to send it to PPP

 */

{

	// Check if Handle ConfigRequest, ConfigAck, ConfigNak 

	//not responding to ConfigReject

	CDummyNifLog::Printf(_L("Dummy PPP ProcessPPPPacket\r\n"));

    TUint result = 0;

	result = DecodePacket(aPacket);

	if(result == 1) 

	{	if(iCodeRec == KPppLcpConfigReject)

		{

			//Panic as DpppLink does not respond to protocol reject

		}

		else

		{

			if(((iCodeRec == KPppLcpConfigAck)

				||(iCodeRec == KPppLcpConfigNak)

				||(iCodeRec == KPppLcpConfigRequest))

				&&(iDummyPPPState<EDummyPPPFsmOpened))

			{

				ProcessConfig();

			}

			else

			{

				ProcessPAPandIPCP();

			}

		}

		ipktRecvPPP.Free();

	}

    if(result == 0)

	{

		//Added to initialize the SendPPP index	

		ipktRecvPPP.Pack();

		ptrTransPktPPP = &ipktRecvPPP;

		SetupSendPPP();

	}

	return result;

}

TInt CDummyPPPIf::DecodePacket(RMBufChain& aPacket)

/**

 * Decodes RMBufChain received from PPP

 *

 * @param RMBufChain& aPacket

 * @returns 1 if need processing further

 * @returns 0 if need to send it to PPP

 * @returns 2 if packet is discarded

 */

{

	TInt result = 0;

	// N.B. ipktRecvPPP must be freed at the end of the previous receive / send sequence.

	// Freeing it here merely covers for a defect where it is not freed as expected.

	// Doubly freeing RMBufChain does not result in error. 

	ipktRecvPPP.Free();

	// If ipktRecvPPP not Freed, Assign Panics.

	ipktRecvPPP.Assign(aPacket);

	ipktRecvPPP.Unpack();

	RMBufPktInfo* info = ipktRecvPPP.Info();

	CDummyNifLog::Printf(_L("Dummy PPP DecodePacket\r\n"));

	// Extract and drop LCP header

	ipktRecvPPP.Align(4);

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

	iCodeRec = *ptr++;

	iIdRec = *ptr++;

	iLenRec = BigEndian::Get16(ptr);

	// Check packet length is OK

	if (info->iLength<iLenRec || info->iLength<4 || info->iLength!=iLenRec)

	{

		// Too short!

		ipktRecvPPP.Free();

		return result;

	}

	else 

	{

		if (info->iLength>iLenRec)

			ipktRecvPPP.TrimEnd(iLenRec);

	}

	if(iCodeRec == KPppLcpConfigReject)

	{

		//not responding to protocol reject

		return result;

	}

	// If op is unknown

	switch (iCodeRec)

		{

	case KPppLcpConfigAck:

	case KPppLcpConfigNak:

		// Filter out bad acks

		if (iDummyPPPState>=EDummyPPPFsmReqSent && iIdRec!=iDummyPPPRequestId)

			break;

		else

			iDummyPPPRequestId |= KPppRequestIdAnswered;

		// fall through ...

	case KPppLcpConfigRequest:

		// Option negotiation ops

		// Split the MBuf chain in separate options

		//if(len<=4)

		if(iLenRec<4)

			break;

		//

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

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

		// 

		if ( (iLenRec == 4) && (iCodeRec == KPppLcpConfigRequest))

			{

			result = 1;

			break;

			}

		if (iLenRec == 4)

			{

			break;

			}

		else

			{

			ipktRecvPPP.TrimStart(4);

			//ProcessConfig(op, id, len-4, pkt);

			result = 1;

			break;

			}

	case KPppLcpTerminateAck:

		//To be opened only in case if Dummy PPPNif sends Terminate Request so blocked

		// Filter out bad acks

		//if ((iDummyPPPState==EPppFsmClosing || iDummyPPPState==EPppFsmStopping) && id!=iTerminateId)

		//	break;

		//else

		//	iTerminateId |= KPppRequestIdAnswered;

		// fall through ...

	case KPppLcpTerminateRequest:

		if(iLenRec<4)

			break;

		ipktRecvPPP.TrimStart(4);

		ProcessTerminate();

		result = 2;

		break;

	default:

		break;

	}

	//pkt.Free();

	if(iDummyPPPState==EDummyPPPFsmIPOpen)

		result = 0;

	return result;

	}

void CDummyPPPIf::ProcessConfig()

	{	

	// Split the recvd packet into separate options

	// placing each option in a queue where it can be

	// easily parsed and manipulated in the upcall handlers.

	RPppOptionList rcvlist;	// Recvd list of options

	RPppOptionList acklist;	// List of Ack'd options - only valid of the following are empty

	RPppOptionList naklist;	// List of Nak'd options - only valid of the following is empty

	RPppOptionList rejlist;	// List of Rejected options

	CDummyNifLog::Printf(_L("Dummy PPP ProcessConfig\r\n"));

	enum TDummyPPPResult { ENop, EAck, ENak, ERej };

	TDummyPPPResult reply = ENop;

    TRAPD(err, rcvlist.SetL(ipktRecvPPP));

	if (err!=KErrNone)

		return;

	if (iCodeRec == KPppLcpConfigRequest)

		{

		// About to drop out of opened state to need to reset things

		// BEFORE the new request is processed.

		if (iDummyPPPState == EDummyPPPFsmOpened)

			{

			TRAPD(err, InitialiseConfigRequestL());

			if (err != KErrNone)

				{

				CDummyNifLog::Printf(_L("Dummy PPP InitialiseConfigRequestL failed\r\n"));

				return;

				}

			}

		// Check options, and split into list of OK, Bad and Unknown

		// Note - the naklist options will have been updated to

		// contain acceptable values.

		if (iCodeRec==KPppLcpConfigRequest)

			CheckRecvConfigRequest(rcvlist, acklist, naklist, rejlist);

		if (!rejlist.IsEmpty())

			{

			reply = ERej;

			naklist.Free();

			acklist.Free();

			}

		else if (!naklist.IsEmpty())

			{

			reply = ENak;

			acklist.Free();

			}

		else if (!acklist.IsEmpty())

			{

			reply = EAck;