/*
* Copyright (c) 2004 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 "TrkFramingLayer.h"

#ifdef __USE_NEW_DEBUG_API__
#include "trkdispatchlayer2.h"
#else
#include "TrkDispatchLayer.h"
#endif

#include "serframe.h"

_LIT8(kPPP_FLAG, "~");
_LIT8(kPPP_ESCAPE, "}");


//
//
// CTrkFramingLayer implementation
//
//

//
// CTrkFramingLayer constructor
//
CTrkFramingLayer::CTrkFramingLayer(CTrkCommPort* aPort)
	: iPort(aPort),
	  iFramingState(CTrkFramingLayer::eWaiting),
	  iEscape(0),
	  iFCS(0),
	  iSequenceId(0),
	  iOutSequenceId(1)
{
	// check the target endianness
	TUint32	test;
	TUint8 *byte_alias = (TUint8 *)&test;
	
	// Write a specific 4-byte sequence and then read it as
	// a 32-bit word.  Big-endian systems yield one value and
	// little-endian systems yield another.
	
	byte_alias[ 0 ] = 0x12;
	byte_alias[ 1 ] = 0x34;
	byte_alias[ 2 ] = 0x56;
	byte_alias[ 3 ] = 0x78;
	
	if (test == 0x12345678)
		iIsBigEndian = ETrue;
	else
		iIsBigEndian = EFalse;
}

//
// CTrkFramingLayer destructor
//
CTrkFramingLayer::~CTrkFramingLayer()
{
	if (iPort)
	{
		iPort->ClosePort();
		SafeDelete(iPort);
	}
	
	SafeDelete(iLastReply);
}

//
// CTrkFramingLayer::Listen
//
// Start listening for incoming messages from the host debugger
//
void CTrkFramingLayer::Listen(CTrkDispatchLayer *aDispatchLayer)
{
	// Start listening asynchronously for incoming messages
	iDispatchLayer = aDispatchLayer;
	
	iPort->Listen(this);
}

//
// CTrkFramingLayer::StopListening
//
// Stop listening for incoming messages from the host debugger
//
void CTrkFramingLayer::StopListening()
{
	iDispatchLayer = 0;
	iPort->StopListening();
}

//
// CTrkFramingLayer::HandleByte
//
// Handle a single incoming byte with a state machine 
//
void CTrkFramingLayer::HandleByte(TUint8 aByte)
{
	// discard existing escape if needed
	if (iFramingState != eInFrame)
		iEscape = EFalse;

	// handle state machine
	switch (iFramingState)
	{
		case eWaiting:
		{
			// Start of a new packet
			if (PPP_FLAG == aByte)
			{
				iFCS = PPPINITFCS;
				iFramingState = eFound;	// next state
			}
			break;
		}
			
		case eFound:
		{
			if (PPP_FLAG == aByte)  // discard multiple flags
				break;
	
			iFramingState = eInFrame;

			// fall through to eInFrame, receive first char
		}
					
		case eInFrame:
		{
			if (PPP_FLAG == aByte)
			{
				if (iEscape)
				{
					// [..., escape, flag] is bad frame; drop it
					// send a NAK with the error.
					RespondErr(kDSReplyNAK, kDSReplyEscapeError);
					
					// clear the buffer
					DiscardFrame();
				}
				else
				{
					// normal case, good packet
					if (ProcessFrame())
					{
						iDispatchLayer->HandleMsg(iBuffer);
					}
						
					// now start all over again
					DiscardFrame();
				}
				break;
			}
			else if (iEscape)
			{
				aByte ^= PPP_TRANS;		// change character to new code
				iEscape = EFalse;		// no longer escaped character
			}
			else if (PPP_ESCAPE == aByte)
			{
				iEscape = ETrue;		// next character is escaped
				break;
			}

			// make sure our buffer is not full
			if (iBuffer.Length() == iBuffer.MaxLength())
			{
				// overflow.  send out a NAK immediately.  go into an overflow state
				// which will wait for the end of the packet.
				RespondErr(kDSReplyNAK, kDSReplyOverflow);

				iFramingState = eFrameOverflow;
				break;
			}
							
			// append byte to buffer and compute running FCS (checksum)
			iBuffer.Append(aByte);

			iFCS = PPPFCS(iFCS, aByte);
			break;
		}
		
		case eFrameOverflow:
		{
			// overflow occurred.  throw away all characters and wait for a flag
			if (PPP_FLAG == aByte)
			{
				DiscardFrame();
			}
			break;
		}
			
		default:
		{
			User::Panic(_L("Invalid Framing State"), __LINE__);
			break;
		}
	}
}

//
// CTrkFramingLayer::RespondOkL
//
// Send an ACK to the host debugger
//
void CTrkFramingLayer::RespondOkL(const TDesC8& aMsg)
{
	// compose the standard ACK message
	TBuf8<3> reply;
	reply.Zero();
	
	reply.Append(kDSReplyACK);
	reply.Append(iSequenceId);
	reply.Append(kDSReplyNoError);

	// now append the rest of the response if necessary
	HBufC8 *ack = HBufC8::NewLC(aMsg.Length() + 3);
	ack->Des().Copy(aMsg.Ptr(), aMsg.Length());

	TPtr8 ptr(ack->Des());
	ptr.Insert(0, reply);

	// send it out
	TUint ackTries = 3;
	TInt leaveCode = KErrGeneral;
	
	do
	{
		TRAP(leaveCode, SendMsgL(*ack));
		ackTries--;
	} while ((leaveCode != KErrNone) && ackTries > 0);
	
	// now increment the sequence id
	IncrementSequenceId();

	// save this in case we need to resend it
	SafeDelete(iLastReply);
	iLastReply = ack->Des().AllocL();
	
	CleanupStack::PopAndDestroy(ack);
}

//
// CTrkFramingLayer::RespondErr
//
// Send an NAK to the host debugger
//
void CTrkFramingLayer::RespondErr(TUint8 aType, TUint8 aErr)
{
	// compose the standard NAK message
	TBuf8<3> ack;
	TUint ackTries = 3;
	TInt leaveCode = KErrGeneral;
	
	ack.Zero();
	ack.Append(aType);	
	ack.Append(iSequenceId);
	ack.Append(aErr);

	// send it out
	do
	{
		TRAP(leaveCode, SendMsgL(ack));
		ackTries--;
	} while ((leaveCode != KErrNone) && ackTries > 0);

	if (kDSReplySequenceMissing != aErr)
	{
		// now increment the sequence id
		IncrementSequenceId();
	}
	
	// save this in case we need to resend it
	SafeDelete(iLastReply);
	iLastReply = ack.Alloc();
	
	if (!iLastReply)
		User::Panic(_L("Failed to allocate reply buffer"), __LINE__);
}

//
// CTrkFramingLayer::InformEventL
//
// Queue up an event on the target
//
void CTrkFramingLayer::InformEventL(const TDesC8& aMsg)
{
	// compose the message
	TBuf8<1> id;
	id.Zero();
	id.Append(iOutSequenceId);
	IncrementOutSequenceId();

	HBufC8 *msg = HBufC8::NewLC(aMsg.Length() + 1);
	msg->Des().Copy(aMsg.Ptr(), aMsg.Length());

	TPtr8 ptr(msg->Des());
	ptr.Insert(1, id);

	// now send it out
	TUint ackTries = 3;
	TInt leaveCode = KErrGeneral;

	do
	{
		TRAP(leaveCode, SendMsgL(*msg));
		ackTries--;
	} while ((leaveCode != KErrNone) && ackTries > 0);

	CleanupStack::PopAndDestroy(msg);
	
	if (leaveCode != KErrNone)
		User::Leave(leaveCode);
}

//
// CTrkFramingLayer::SendRawMsgL
//
// Frames a message and sends it back to the host debugger
//
void CTrkFramingLayer::SendRawMsgL(const TDesC8& aMsg)
{
	iPort->SendDataL(aMsg);
}


//
// CTrkFramingLayer::SendMsgL
//
// Frames a message and sends it back to the host debugger
//
void CTrkFramingLayer::SendMsgL(const TDesC8& aMsg)
{
	FCSType fcs;
	FCSType acc;

	// allocate room for this message with ample space for escape sequences and framing
	HBufC8 *msg = HBufC8::NewLC(aMsg.Length() + 100);

	TPtr8 ptr(msg->Des());

	// walk through buffer, computing frame check sequence
	// (checksum).
	
	fcs = PPPINITFCS;
	
	for (TInt i=0; i<aMsg.Length(); i++)
		fcs = PPPFCS(fcs, aMsg[i]);

	fcs = fcs ^ PPPCOMPFCS;		// finish by complementing
	
	// send bytes out the comm channel:
	//	[0x7E (frame flag)] [...data...] [FCS:8 or FCS:16 or FCS:32] [0x7E (frame flag)]
	 
	// FLAG
	ptr.Append(kPPP_FLAG);
					
	// DATA
	TBuf8<1> byte;
	
	for (TInt i=0; i<aMsg.Length(); i++)
	{
		byte.Zero();
		byte.Append(aMsg[i]);
		
		// escape if necessary
		if (byte[0] == PPP_FLAG || byte[0] == PPP_ESCAPE)
		{
			ptr.Append(kPPP_ESCAPE);
			byte[0] ^= PPP_TRANS;
		}
		
		ptr.Append(byte);
	}
	
	// FCS always goes out in little endian (LSB, ... , MSB) order	
	acc = fcs;		// accumulator
	
	TInt fcsSize = sizeof(FCSType);
	
	for (TInt i=0; i<fcsSize; i++)
	{
		byte.Zero();
		byte.Append(acc & 0xFF);

		acc >>= 8;

		// escape if necessary
		if (byte[0] == PPP_FLAG || byte[0] == PPP_ESCAPE)
		{
			ptr.Append(kPPP_ESCAPE);
			byte[0] ^= PPP_TRANS;
		}
		
		ptr.Append(byte);
	}
	
	// FLAG	
	ptr.Append(kPPP_FLAG);
	
	iPort->SendDataL(*msg);
	
	CleanupStack::PopAndDestroy(msg);
}

//
// CTrkFramingLayer::DiscardFrame
//
// Trash the existing message and reset the state machine 
//
void CTrkFramingLayer::DiscardFrame()
{
	iBuffer.Zero();
	iFramingState = eWaiting;
}

//
// CTrkFramingLayer::ProcessFrame
//
// Checks a complete message for correct format
//
TBool CTrkFramingLayer::ProcessFrame()
{
	// the buffer contains data in the following form:
	//		[data] [FCS8]
	//	or:
	//		[data] [FCS16]
	//	or:
	//		[data] [FCS32]
	//	
	//	where data is arbitrary length and FCSxx is 1, 2 or 4 bytes

	TInt minSize = 2 + sizeof(FCSType);
	
	if (iBuffer.Length() < minSize)
	{
		// data received is too short
		RespondErr(kDSReplyNAK, kDSReplyPacketSizeError);
		DiscardFrame();
		return EFalse;
	}
	
	// check for FCS
	if (PPPGOODFCS != iFCS)
	{
		// bad checksum (FCS)		
		RespondErr(kDSReplyNAK, kDSReplyBadFCS);
		DiscardFrame();
		return EFalse;
	}
	
	// make sure the sequence id is correct, then increment
	if (iBuffer[TRK_MSG_SID_INDEX] == 0)
	{
		// special case - resets both sequence ids
		iSequenceId = 0;
		iOutSequenceId = 1;		
	}
	else
	{
		// see which id we're dealing with
		if ((iBuffer[0] != kDSReplyACK) && (iBuffer[0] != kDSReplyNAK))
		{
			// a command from the host 
			if (iBuffer[TRK_MSG_SID_INDEX] == iSequenceId)
			{
				// got the expected sequence id - do nothing
			}
			else if (iBuffer[TRK_MSG_SID_INDEX] == (iSequenceId - 1))
			{
				// we need to resend the last reply
				TUint ackTries = 3;
				TInt leaveCode = KErrGeneral;

				do
				{
					TRAP(leaveCode, SendMsgL(*iLastReply));
					ackTries--;
				} while ((leaveCode != KErrNone) && ackTries > 0);

				return EFalse;
			}
			else
			{
				// bad sequence id
				RespondErr(kDSReplyNAK, kDSReplySequenceMissing);
				DiscardFrame();
				return EFalse;
			}
		}
	}

	// trim back packet, eliminating FCS
	iBuffer.Delete(iBuffer.Length()-1, 1);

	// remove sequence id
	iBuffer.Delete(1, 1);
	
	return ETrue;
}