// 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 <networking/in_std.h>

#include <in_sock.h>

#include "VJLOG.H"

#include "VJ.H"

CVJDeCompressor::CVJDeCompressor()

	{

	}

void CVJDeCompressor::ConstructL( CVJCompFactory* aFactory, TUint aMaxSlot)

/**

Construct the CVJDeCompressor object.

@param aFactory Factory that created this object

@param aMaxSlot Value of the highest VJ connection number to be received

*/

	{

	//

	// Note that aMaxSlot is the index of the maximum slot that will be accessed.

	//

	__ASSERT_DEBUG(aMaxSlot <= KMaxVjSlot, User::Panic(_L("VJ Panic"), 0));

	iNumVJSlots = aMaxSlot;

	iRxStates = new (ELeave) TVJCompHdr[aMaxSlot+1];

	iFactory = aFactory;

	iFactory->Open();

	}

CVJDeCompressor::~CVJDeCompressor()

	{

	delete []iRxStates;

	if (iFactory)

	    {

		iFactory->Close();

		}

	}

void CVJDeCompressor::CRCError()

/**

Sets the discard flag after receiving a bad frame so that future

decompressed packets don't get out of sync.

*/

	{

	LOG(_LIT(string1,"CRC Error");)

	LOG(Log::Write(string1);)

	SetFlag(KVJDiscard);

	}

void CVJDeCompressor::CopyRecvHeader(const TUint aConnection, ThdrIP* aHeader)

/**

Caches a TCP/IP Header to be used as a reference to

reconstruct future compressed headers.

@param aConnection Valid VJ connection number

@param aHeader TCP/IP header

*/

	{

	__ASSERT_DEBUG(aConnection <= iNumVJSlots, User::Panic(_L("VJ Panic"), 0));

	iRxStates[aConnection].StoreTCPIPHeader(aHeader);

	}

void CVJDeCompressor::GetStoredRxHeader(const TUint aConnection, ThdrIP* aIPHeader, ThdrTCP* aTCPHeader)

/**

Retrieves a packet header from the VJ connection cache.

@param aConnection Valid VJ connection number to retrieve

@param aIPHeader IP packet header

@param aTCPHeader TCP header

*/

	{

	__ASSERT_DEBUG(aConnection <= iNumVJSlots, User::Panic(_L("VJ Panic"), 0));

	iRxStates[aConnection].RetrieveTCPIPHeader(aIPHeader, aTCPHeader);

	}

TBool CVJDeCompressor::CheckStoredRxHeader(const TUint aConnection) const

/**

Checks if the given VJ connection number has previously been filled in.

@param aConnection Valid VJ connection number to check

@return ETrue if CopyRecvHeader() has previously been called

        on this connection number

*/

	{

	__ASSERT_DEBUG(aConnection <= iNumVJSlots, User::Panic(_L("VJ Panic"), 0));

	return iRxStates[aConnection].IsValid();

	}

TBool CVJDeCompressor::DecompVJComp(RMBufChain& aPacket)

/**

Decompresses a VJ compressed packet in place.

@param aPacket MBuf chain containing packet

@return ETrue if the frame was successfully decompressed

@see DecompVJUncomp

*/

	{

	TBool		RetCode = EFalse;

	TUint8		Connection;

	TUint16		CurrentFrameLength;

	TUint8* const InitialHeaderPtr = GetVJPtr(aPacket, &CurrentFrameLength);

	TUint8 Changes	= *InitialHeaderPtr;

	TUint Offset = 1;

	if (Changes & KVjCompMaskConn)

		{

		Connection = *(InitialHeaderPtr+Offset);

		Offset++;

		if (Connection <= iNumVJSlots && CheckStoredRxHeader(Connection))

			{

			LOG(_LIT(string1,"Clear error comp");)

			LOG(Log::Write(string1);)

			ClearFlag(KVJDiscard);

			iLastRxConn = Connection;

			}

		else

			{

			//

			//  The received connection number was invalid.

			//	Ignore all further Compressed frames until an Uncompressed frame

			//	or a frame containing an explicit connection number is received

			//

			LOG(_LIT(string1,"Invalid connection");)

			LOG(Log::Write(string1);)

			SetFlag(KVJDiscard);

			return RetCode;

			}

		}

	else

		{

		if(TestFlag(KVJDiscard))

			{

			return RetCode;

			}

		Connection = (TUint8)iLastRxConn;

		}

	TRAPD(ret, DecompressFrameL(aPacket, Connection, Changes, InitialHeaderPtr, Offset, CurrentFrameLength));

	if (ret == KErrNone)

		{

		//

		//	Under all other circumstances the frame is thrown away

		//

		RetCode = ETrue;

		}

	return RetCode;

	}

TBool CVJDeCompressor::DecompVJUncomp(RMBufChain& aPacket)

/**

Handles a VJ uncompressed packet.

Stores the packet header in the appropriate VJ connection slot.

@param aPacket MBuf chain containing packet

@return ETrue if the frame was successfully processed

@see DecompVJComp

*/

	{

	TBool	RetCode = EFalse;

	//

	//	When we get here, the first packet is some information thing,

	//	we want the IPHeader this was the easiest way I could see to do it

	//	

	//

	ThdrIP*	IPHeader = GetIPHeader(aPacket);

	if (IPHeader == NULL)

	    {

		//

		//  The packet was too short.

		//	Ignore all further Compressed frames until an Uncompressed frame

		//	or a frame containing an explicit connection number is received

		//

		LOG(_LIT(string1,"Short VJ frame received");)

		LOG(Log::Write(string1);)

		SetFlag(KVJDiscard);

		RetCode = EFalse;

		}

    else

        {

    	TUint ConnectionNumber = IPHeader->NetGetProtocol();

    	if (ConnectionNumber <= iNumVJSlots)

    		{

    		//

    		//	Set the real protocol header to TCP

    		//

    		IPHeader->NetSetProtocol(KProtocolInetTcp);

    		iLastRxConn = ConnectionNumber;

    		LOG(_LIT(string1,"Clear error uncomp");)

    		LOG(Log::Write(string1);)

    		ClearFlag(KVJDiscard);

    		//

    		//	Copy the header into one of our connection things

    		//	and zero the checksum

    		//

    		CopyRecvHeader(ConnectionNumber, IPHeader);

    		//

    		//	Receive this frame properly

    		//

    		RetCode = ETrue;

    		}

    	else

    		{

    		//

			//  The received connection number was invalid.

			//	Ignore all further Compressed frames until an Uncompressed frame

			//	or a frame containing an explicit connection number is received

    		//

    		LOG(_LIT(string1,"Invalid VJ connection received");)

    		LOG(Log::Write(string1);)

    		SetFlag(KVJDiscard);

    		RetCode = EFalse;

    		}

		}

	return RetCode;

	}

void CVJDeCompressor::DecompressFrameL(RMBufChain& aPacket, 

								TUint8 aConnection, 

								TUint8 aChanges, 

								TUint8* const aInitialHeaderPtr,

								TUint	aOffset,

								TUint16 aCurrentFrameLength)

/**

Uncompresses a VJ compressed TCP/IP header.

@param aPacket MBuf chain containing packet to be updated

@param aConnection VJ connection number

@param aChanges The VJ change mask

@param aInitialHeaderPtr Beginning of the compressed VJ header

@param aOffset Offset from start of packet to TCP checksum field

@param aCurrentFrameLength Length of the compressed packet

@leave KErrCorrupt if aPacket is corrupt

*/							   

{

	TUint8*	VJCompHeader = aInitialHeaderPtr + aOffset;

	TUint16 Checksum = BigEndian::Get16(VJCompHeader);

	VJCompHeader+=2;

	//

	//	Use the aConnection number to retrieve the TCP Header and IP Header

	//

	ThdrIP		IPHeader;

	ThdrTCP		TCPHeader;

	GetStoredRxHeader(aConnection, &IPHeader, &TCPHeader);

	TUint16 IPHeaderLength	= (TUint16)IPHeader.NetGetHdrLen();

	TUint16 TCPHeaderLength = (TUint16)TCPHeader.NetGetHdrLen();

	TUint16 PreviousDataLength = (TUint16)(IPHeader.NetGetLength() - IPHeaderLength - TCPHeaderLength);

	//

	//	Set the actual checksum

	//

	TCPHeader.VJSetChecksum(Checksum);

	//

	//	Set Push if appropriate, otherwise clear it.

	//

	DecompPushFlag(aChanges, &TCPHeader);

	//

	//	Handle the Sequence, Window, Ack, Urgent compressed elements

	//

	DecompSWAU(aChanges, &VJCompHeader, &TCPHeader, PreviousDataLength);

	//

	//	Handle the compressed IP Identification field

	//

	DecompIPId(aChanges, &VJCompHeader, &IPHeader);

	TUint16 OriginalHeaderLength = (TUint16)(VJCompHeader - aInitialHeaderPtr);

	//

	// Check if the received frame is shorter than the VJ header, and discard it if

	// so.  This condition is detected by VJCompHeader being incremented beyond the end of

	// the packet during processing.

	//

	if (OriginalHeaderLength > aCurrentFrameLength)

		{

		LOG(_LIT(string1,"Short frame discarded");)

		LOG(Log::Write(string1);)

		User::Leave(KErrCorrupt);

		}

	TUint16 CurrentDataLength = (TUint16)(aCurrentFrameLength - OriginalHeaderLength);

	IPHeaderLength	= (TUint16)IPHeader.NetGetHdrLen();

	IPHeader.NetSetLength((TUint16)(CurrentDataLength + IPHeaderLength + TCPHeaderLength));

	//

	//	Generate the IP Header Checksum.

	//

	DoIPChecksum(&IPHeader, IPHeaderLength);

	//

	//	Now the hard bit; I have reconstructed the packet, now need 

	//	to get it into the right format and receive it.

	//

	CopyInNewHeaderL(&aPacket, &IPHeader, &TCPHeader, (VJCompHeader - aInitialHeaderPtr), IPHeaderLength, TCPHeaderLength);

	//TCPHeader.Printf();

	//

	//	Store the rebuilt TCP/IP header for this aConnection

	//

	//  GetIPHeader will never return NULL here because we check the

	//  packet size above.

	//

	CopyRecvHeader(aConnection, GetIPHeader(aPacket));	  

	//

	//	Increment the length in the Info Header

	//

	RMBufPktInfo* info = RMBufPacket::PeekInfoInChain(aPacket);

	info->iLength += IPHeaderLength + TCPHeaderLength - OriginalHeaderLength;

}

// TODO: This is a funny place for this declaration

void ThdrTCP::Printf()

	{	

	TInt i;

	LOG(_LIT(string1,"TCP Header.");)

	LOG(Log::Write(string1);)

	LOG(_LIT(string2,"%02x ");)

	for (i=0;i<20;i++)

		{

		LOG(Log::Printf(string2,u.iData8[i]);)

		}

	}

ThdrIP* CVJDeCompressor::GetIPHeader(RMBufChain &aChain)

/**

Extracts the IP Header from the packet even though there is a buffer

of Info on the front.

This is used in VJ, to avoid the awful hack in the main receive path.

PRR 20-11-97

@param aChain MBuf chain containing packet

@return Pointer to packet data in chain, or NULL if the packet is too short

*/

	{

	RMBuf* Temp = aChain.Remove();

	TUint n = aChain.Align(KInetMaxHeaderSize);

	ThdrIP* IPHeader = (n<KIPMinHeaderSize) ? NULL : (ThdrIP*)aChain.First()->Ptr();

	aChain.Prepend(Temp);

	return IPHeader;

	}

void CVJDeCompressor::DoIPChecksum(ThdrIP* aIPHeader, TUint16 aIPHeaderLength)

/**

Calculate the IP checksum and store it in the given IP packet header.

See RFC 1071.

@param aIPHeader IP packet header

@param aIPHeaderLength Length of IP header in bytes (must be even)

*/

	{

	__ASSERT_DEBUG(!(aIPHeaderLength % 2), User::Panic(_L("VJ Panic"), 0));	// length must be even

	aIPHeader->VJSetChecksum(0);	// Clear the header checksum before calculating

	TUint16*	Ptr = (TUint16*)aIPHeader;

	TUint32		Checksum=0;

	TInt		i;

	for (i=aIPHeaderLength; i>0; i-=2)

		{

		Checksum += *Ptr++;

		}

	//

	//	Take care of the wrapping over 16 bits

	//  Doing it twice is sufficient for IP headers.

	//

	Checksum = (Checksum & 0xFFFF) + (Checksum >> 16);

	Checksum = (Checksum & 0xFFFF) + (Checksum >> 16);

	Checksum = ~Checksum;

	//

	// Do the endian conversion once, after the checksum is calculated

	//

	Checksum = BigEndian::Get16((TUint8*)&Checksum);

	aIPHeader->VJSetChecksum((TUint16)Checksum);

	}

TUint8* CVJDeCompressor::GetVJPtr(RMBufChain &aChain, TUint16* aCurrentFrameLength)

/**

Gets a pointer to the VJ Header even though there is a pseudo (Adam) buffer of Info on the front.

@param aChain MBuf chain containing packet

@param aCurrentFrameLength Returns the length of the packet

@return Pointer to beginning of packet data

*/

	{

	RMBuf* Temp = aChain.Remove();

	aChain.Align(KInetMaxHeaderSize);

	TUint8* IPPtr = aChain.First()->Ptr();

	*aCurrentFrameLength = (TUint16)aChain.Length();

	aChain.Prepend(Temp);

	return IPPtr;

	}

void CVJDeCompressor::CopyInNewHeaderL(RMBufChain* aPacket, ThdrIP* aIPHeader, ThdrTCP* aTCPHeader,

    TUint aCompressedHeaderLength, TUint16 aIPHeaderLength, TUint16 aTCPHeaderLength)

/**

Copy the uncompressed header into the proper location in the packet.

@param aPacket MBuf chain containing packet to be updated

@param aIPHeader IP packet header

@param aTCPHeader TCP header

@param aCompressedHeaderLength Length of VJ compression header

@param aIPHeaderLength Length of IP header

@param aTCPHeaderLength Length of TCP header

*/

	{

	TUint16 NewHeaderLength = (TUint16)(aIPHeaderLength + aTCPHeaderLength);

	//

	//  Take the Info thing off 

	//

	RMBuf* info = aPacket->Remove();

	//

	//	Now it is just possible that the frame contains no data

	//

	if ( aPacket->Length() == (TInt)aCompressedHeaderLength )

		{

		//

		//	Have finished with the compressed header

		//

		aPacket->TrimStart(aCompressedHeaderLength);

		aPacket->AllocL(NewHeaderLength);

		}

	else

		{

		//

		//	Have finished with the compressed header

		//

		aPacket->TrimStart(aCompressedHeaderLength);

		//

		//	Make way for the uncompressed header

		//

		aPacket->PrependL(NewHeaderLength);

		}

	TPtrC8 TempDescIP((TUint8*)aIPHeader, aIPHeaderLength);

	aPacket->CopyIn(TempDescIP, 0);

	TPtrC8 TempDescTCP((TUint8*)aTCPHeader, aTCPHeaderLength);

	aPacket->CopyIn(TempDescTCP, aIPHeaderLength);

	//

	//	Put the Info header back unchanged; it must be updated by the caller.

	//

	aPacket->Prepend(info);

	}

void CVJDeCompressor::DecompSWAU(const TUint aChanges, TUint8** aVJCompHeader, ThdrTCP* aTCPHeader, TUint16 aPreviousFrameLength)

/**

Decompresses the special case SWAU type packet.

@param aChanges The VJ change mask

@param aVJCompHeader Pointer to the pointer to the VJ compressed header

@param aTCPHeader TCP header to be updated

@param aPreviousFrameLength Length of cached packet for this VJ connection

*/

	{

	TUint32	SequenceNumber;

	TUint32	AckNumber;

	switch ( aChanges & KVjCompMaskSpecials )

		{

		case KVjCompMaskSpecialI: // Echoed data e.g. Telnet

			//

			//	The sequence and acknowledge numbers increment by the data 

			//	portion of the frame

			//

			SequenceNumber = aTCPHeader->NetGetSeqNum();

			aTCPHeader->NetSetSeqNum(SequenceNumber + aPreviousFrameLength);

			AckNumber = aTCPHeader->NetGetAckNum();

			aTCPHeader->NetSetAckNum(AckNumber + aPreviousFrameLength);

			break;

		case KVjCompMaskSpecialD: //Unidirectional Data e.g. ftp

			//

			//	The sequence numbers increment by the data portion of the frame.	

			//