// 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 "VJ.H"

#include "VJLOG.H"

#include <networking/in_std.h>

#include <in_sock.h>

CVJCompressor::CVJCompressor()

	{

	}

void CVJCompressor::ConstructL(CVJCompFactory* aFactory, TUint aMaxSlot, TBool aCompressConnId)

/**

Construct the CVJCompressor object.

@param aFactory Factory that created this object

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

@param aCompressConnId Whether to compress the connection number 

*/

	{

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

	iMaxVJSlots = aMaxSlot+1;

	iLastTxConn = aMaxSlot+1; // Initialize with an invalid slot number

   	iTxStates = new (ELeave) TVJCompHdr[iMaxVJSlots];

	iTxStates[0].SetNextPtr(&iTxStates[aMaxSlot]);

	iTxStates[0].SetConnectionNumber(0);

	iLastTxHdr = &iTxStates[0];

	TUint i;

	for (i=aMaxSlot; i>0; i--)

		{

		iTxStates[i].SetNextPtr(&iTxStates[i-1]);

		iTxStates[i].SetConnectionNumber(i);

		}

	iCompressConnId = aCompressConnId;

	iFactory = aFactory;

	iFactory->Open();

	}

CVJCompressor::~CVJCompressor()

	{

	delete [] iTxStates;

	if (iFactory)

	    {

		iFactory->Close();

		}

	}

ThdrIP* CVJCompressor::GetIPHeader(RMBufChain &aChain)

/**

Get the IP Header 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 IP header

*/

	{

	RMBuf* Temp = aChain.Remove();

	TUint n = aChain.Align(KInetMaxHeaderSize);

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

	aChain.Prepend(Temp);

	return IPHeader;

	}

void CVJCompressor::EncodeDelta(TUint8** aVJCompHeader, TInt16 aValue)

/**

Encodes a delta value in VJ compressed format.

@param aVJCompHeader Pointer to pointer into VJ header buffer to store encoded value;

  returns with pointer incremented one past end of value

@param aValue Value to store

*/

	{

	if ((TUint16)aValue >= 256 || aValue == 0)

		{

		*(*aVJCompHeader) = 0;

		(*aVJCompHeader)++;

		BigEndian::Put16(*aVJCompHeader, aValue);

		(*aVJCompHeader) += 2;

		}

	else

		{

		*(*aVJCompHeader) = (TUint8)aValue;

		(*aVJCompHeader)++;

		}

	}

TBool CVJCompressor::SendAsRawIP(	ThdrIP* aIPHeader, 

								    ThdrTCP* aTCPHeader )

/**

Determines if the packet must bypass VJ compression altogether.

This happens with fragmented IP packets and certain TCP flags.

@param aIPHeader First IP packet header

@param aTCPHeader TCP header

@return Whether the packet must be sent raw

*/

	{

	TBool RetCode = ETrue;

	if (!aIPHeader->NetGetFragment())

		{

		//

		//	Frame isn't fragmented, so make sure that no flags are set

		//	which would prevent us from compressing the packet.

		//

		TUint Flags = aTCPHeader->VJGetFlags();

		RetCode = (Flags & (KTcpFIN | KTcpSYN | KTcpRST | KTcpACK)) != KTcpACK;

		}

	return RetCode;

	}

TBool CVJCompressor::SuitableForVJCompression(ThdrIP* aIPHeader, 

										  ThdrTCP* aTCPHeader, 

										  TUint* aConnection,

										  ThdrIP* aRetrievedIPHdr,

										  ThdrTCP* aRetrievedTCPHdr)

/**

Sees if a packet header is stored in the VJ connection cache.

@param aIPHeader IP packet header

@param aTCPHeader TCP header

@param aConnection Returns the matching VJ connection number

@param aRetrievedIPHdr Returns the cached IP packet header

@param aRetrievedTCPHdr Returns the cached TCP packet header

@return Whether the packet matches one in the cache

*/

	{

	TBool RetCode = EFalse;

	if (GetStoredTxHeader(	aConnection, 

							aIPHeader, 

							aTCPHeader, 

							aRetrievedIPHdr, 

							aRetrievedTCPHdr))

		{

		//

		//	OK we found a stored header with the right 

		//	addresses; is the header compressible?

		//

		RetCode = IsIPCompressible(aIPHeader, aRetrievedIPHdr) &&

		          IsTCPCompressible(aTCPHeader, aRetrievedTCPHdr);

		}

	return RetCode;

	}

TBool CVJCompressor::IsIPCompressible(ThdrIP* aIPHeader, ThdrIP* aRetrievedHdr)

/**

Compares two IP headers to see if the seldom-changing fields match.

@param aIPHeader First IP packet header

@param aRetrievedHdr Second IP packet header

@return Whether the headers match

*/

	{

	TBool	RetCode = EFalse;

	//

	//	Ensure that the following match

	//			Word 0

	//					Protocol Version,

	//					Header Length,

	//					Type Of Service,

	//			Word 3	

	//					Fragment stuff

	//			Word 4

	//					Time to live,

	//					Protocol,

	//			If appropriate 

	//					IP Options 

	//

	if ((aIPHeader->Word0() == aRetrievedHdr->Word0()) &&

		(aIPHeader->Word3() == aRetrievedHdr->Word3()) &&

		(aIPHeader->Word4() == aRetrievedHdr->Word4()))

		{

		//

		//	Well those are fine now check the IP Options if there are any

		//

		const TUint Length = aIPHeader->NetGetHdrLen() - KIPMinHeaderSize;

		TUint8*	Options = aIPHeader->GetOptions();

		const TUint StoredLength = aRetrievedHdr->NetGetHdrLen() - KIPMinHeaderSize;

		TUint8*	StoredOptions = aRetrievedHdr->GetOptions();

		if (Length == StoredLength)

			{

			if (Length == 0 || !Mem::Compare(Options, Length, StoredOptions, StoredLength))

				{

				RetCode = ETrue;

				}

			}

		}

		return RetCode;

	}

TBool CVJCompressor::IsTCPCompressible(ThdrTCP* aHeader, ThdrTCP* aRetrievedHdr)

/**

Compares two TCP headers to see if the options, ECN & reserved bits match.

Everything else in the TCP header is handled specially by the

VJ compression algorithm.

@param aHeader First TCP header

@param aRetrievedHdr Second TCP header

@return Whether the headers match

*/

	{

	TBool   RetCode = EFalse;

    //

    //  Ensure that the ECN and TCP reserved bits match

    //

    if ((aHeader->VJGetReserved() == aRetrievedHdr->VJGetReserved()) &&

       ((aHeader->VJGetFlags() & KTcpECN) == (aRetrievedHdr->VJGetFlags() & KTcpECN)) &&

   	//

	//	Ensure that the header lengths match, if they do then 

	//	check that the options match

	//

	   (aHeader->NetGetHdrLen() == aRetrievedHdr->NetGetHdrLen()))

		{

		//

		//	Now compare the TCP Options 

		//

		const TUint Length = aHeader->NetGetHdrLen() - KTCPHeaderSize;

		TUint8* Options = GetTCPOpts(aHeader);

		const TUint StoredLength = aRetrievedHdr->NetGetHdrLen() - KTCPHeaderSize;

		TUint8* StoredOptions = GetTCPOpts(aRetrievedHdr);

		if (Length == StoredLength)

			{

			// This comparison will inevitably fail if a RFC 1323

			// TCP timestamp option is found, causing VJ compression to be

			// effectively disabled.

			if (StoredLength == 0 || !Mem::Compare(Options, Length, StoredOptions, StoredLength))

				{

				RetCode = ETrue;

				}

			}

		}

	return RetCode;

	}

TBool CVJCompressor::CompressUrgentPtr(TUint8** aVJPtr, TUint8* aChanges, ThdrTCP* aTCPHeader, ThdrTCP* aRetrievedTCPHdr)

/**

Compresses the TCP Urgent pointer field.

@param aVJPtr Pointer to the pointer within the VJ header to be modified;

returns pointing one past the last header location used

@param aChanges The VJ change mask to be updated

@param aTCPHeader TCP header

@param aRetrievedTCPHdr Cached TCP header from which to make a delta for aTCPHeader

@return ETrue if the field was compressed

*/

	{

	TBool   RetCode = ETrue;

	TUint   Flags = aTCPHeader->VJGetFlags();

	if (Flags & KTcpURG)

		{

		(*aChanges) |= KVjCompMaskUrgent;

		TUint16 UrgPtr = aTCPHeader->NetGetUrgPtr();

		EncodeDelta(aVJPtr, UrgPtr);

		}

	else if (aTCPHeader->NetGetUrgPtr() != aRetrievedTCPHdr->NetGetUrgPtr())

		{

		//

		//	They can change the Urgent Ptr without setting the flag but 

		//	it's not recommended, just send uncompressed frame

		//

		RetCode = EFalse;

		}

	return RetCode;

	}

TBool CVJCompressor::CompressWindow(TUint8** aVJPtr, TUint8* aChanges, ThdrTCP* aTCPHeader, ThdrTCP* aRetrievedTCPHdr)

/**

Compresses the TCP Window field.

@param aVJPtr Pointer to the pointer within the VJ header to be modified;

returns pointing one past the last header location used

@param aChanges The VJ change mask to be updated

@param aTCPHeader TCP header

@param aRetrievedTCPHdr Cached TCP header from which to make a delta for aTCPHeader

@return ETrue if the field was compressed

*/

	{

	TBool	RetCode = ETrue;

	TInt16 DeltaWindow = (TUint16)(aTCPHeader->NetGetWindow() - aRetrievedTCPHdr->NetGetWindow());

	if (DeltaWindow)

		{

		LOG(_LIT(string1,"\nWindow Delta");)

		LOG(Log::Write(string1);)

		LOG(_LIT(string2,"%d\n");)

		LOG(Log::Printf(string2,DeltaWindow);)

		*aChanges |= KVjCompMaskWindow;

		EncodeDelta(aVJPtr, DeltaWindow);

		}

	return RetCode;

	}

TBool CVJCompressor::CompressAck(TUint8** aVJPtr, TUint8* aChanges, ThdrTCP* aTCPHeader, ThdrTCP* aRetrievedTCPHdr)

/**

Compresses the TCP Acknowledgement Number field.

@param aVJPtr Pointer to the pointer within the VJ header to be modified;

returns pointing one past the last header location used

@param aChanges The VJ change mask to be updated

@param aTCPHeader TCP header

@param aRetrievedTCPHdr Cached TCP header from which to make a delta for aTCPHeader

@return ETrue if the field was compressed

*/

	{

	TBool	RetCode = ETrue;

	TInt32 DeltaAck = aTCPHeader->NetGetAckNum() - aRetrievedTCPHdr->NetGetAckNum();

	if (DeltaAck)

		{

		if (IsDeltaCompressible(DeltaAck))

			{

			EncodeDelta(aVJPtr, (TInt16)DeltaAck);

			*aChanges |= KVjCompMaskAck;

			}

		else

			{

			// Can't compress this large a difference

			RetCode = EFalse;

			}

		}

		return RetCode;

	}

TBool CVJCompressor::CompressSeq(TUint8** aVJPtr, TUint8* aChanges, ThdrTCP* aTCPHeader, ThdrTCP* aRetrievedTCPHdr)

/**

Compresses the TCP Sequence Number field.

@param aVJPtr Pointer to the pointer within the VJ header to be modified;

returns pointing one past the last header location used

@param aChanges The VJ change mask to be updated

@param aTCPHeader TCP header

@param aRetrievedTCPHdr Cached TCP header from which to make a delta for aTCPHeader

@return ETrue if the field was compressed

*/

	{

	TBool	RetCode = ETrue;

	TInt32 DeltaSeq = aTCPHeader->NetGetSeqNum() - aRetrievedTCPHdr->NetGetSeqNum();

	if (DeltaSeq)

		{

		if (IsDeltaCompressible(DeltaSeq))

			{

			EncodeDelta(aVJPtr, (TInt16)(DeltaSeq));

			*aChanges |= KVjCompMaskSeq;

			}

		else

			{

			// Can't compress this large a difference

			RetCode = EFalse;

			}

		}

	return RetCode;

	}

TBool CVJCompressor::CompressSpecialCases(TUint8** aVJPtr, 

						   TUint8* const aVJInitialDeltaPtr, 

						   TUint8* aChanges, 

						   ThdrTCP* aTCPHeader, 

						   ThdrTCP* aRetrievedTCPHdr, 

						   ThdrIP*	aIPHeader,

						   ThdrIP* aRetrievedIPHdr)

/**

Compresses special case TCP/IP packets.

See RFC 1144 sec. 3.2.3

@pre aChanges must reflect the compressed header except for the

KVjCompMaskPush and KVjCompMaskIp bits which must be clear.

@param aVJPtr Pointer to the pointer within the VJ header to be modified;

returns pointing one past the last header location used

@param aVJInitialDeltaPtr Beginning of the compressed VJ header

@param aChanges The VJ change mask to be updated

@param aTCPHeader TCP header

@param aRetrievedTCPHdr Cached TCP header from which to make a delta for aTCPHeader

@param aIPHeader IP header

@param aRetrievedIPHdr Cached IP header from which to make a delta for aIPHeader

@return ETrue if the packet can be compressed

*/

	{

	__ASSERT_DEBUG(!(*aChanges & (KVjCompMaskIp | KVjCompMaskPush)), User::Panic(_L("VJ Panic"), 0));

	TBool RetCode = ETrue;

	TUint DeltaSeq = aTCPHeader->NetGetSeqNum() - aRetrievedTCPHdr->NetGetSeqNum();

	TUint DeltaAck = aTCPHeader->NetGetAckNum() - aRetrievedTCPHdr->NetGetAckNum();

	switch (*aChanges)

		{

		case 0:

		    // No change from the last packet; this frame may be a retransmission.

		    // See RFC 1144 §4.2

			if (((aIPHeader->NetGetLength() - aIPHeader->NetGetHdrLen()) == aTCPHeader->NetGetHdrLen()) ||

			    ((aRetrievedIPHdr->NetGetLength() - aRetrievedIPHdr->NetGetHdrLen()) != aRetrievedTCPHdr->NetGetHdrLen()))

				{

				//

				//	The frame has been sent compressed and was probably missed at the other

				//	end, so send it uncompressed.

				//

				LOG(_LIT(string1,"Missed frame");)

				LOG(Log::Write(string1);)

				RetCode = EFalse;				

				}

			break;

		case KVjCompMaskSpecialD:

		case KVjCompMaskSpecialI:

			// Can't send SWU and SWAU, so send Uncompressed

			RetCode = EFalse;

			break;

		case KVjCompMaskSeq | KVjCompMaskAck:

			if (DeltaAck == DeltaSeq)

				{

				if (DeltaSeq == (aRetrievedIPHdr->NetGetLength() - aRetrievedIPHdr->NetGetHdrLen() - aRetrievedTCPHdr->NetGetHdrLen()))

					{

					// Terminal traffic

					*aChanges = KVjCompMaskSpecialI;

					*aVJPtr = aVJInitialDeltaPtr; // Reset back to just after CSum

					}

				}

			break;

		case KVjCompMaskSeq:

			if (DeltaSeq == (aRetrievedIPHdr->NetGetLength() - aRetrievedIPHdr->NetGetHdrLen() - aRetrievedTCPHdr->NetGetHdrLen()))

				{

				// Data Xfer e.g. FTP

				*aChanges = KVjCompMaskSpecialD;

				*aVJPtr = aVJInitialDeltaPtr; // Reset back to just after CSum

				}

			break;

	    default:

	        // Not a special case

	        break;

		}

	return RetCode;

	}

TBool CVJCompressor::CompressIPId(TUint8** aVJPtr, TUint8* aChanges, ThdrIP* aIPHeader, ThdrIP* aRetrievedIPHdr)

/**

Compresses the IP Packet ID field.

@param aVJPtr Pointer to the pointer within the VJ header to be modified;

returns pointing one past the last header location used

@param aChanges The VJ change mask to be updated

@param aIPHeader IP header

@param aRetrievedIPHdr Cached IP header from which to make a delta for aIPHeader

@return ETrue

*/

	{

	TInt16 DeltaIPId = (TInt16) ((TInt)aIPHeader->NetGetId() - (TInt)aRetrievedIPHdr->NetGetId());

	if (DeltaIPId != 1)

		{

		EncodeDelta(aVJPtr, DeltaIPId);

		*aChanges |= KVjCompMaskIp;

		}

	return ETrue;

	}

TBool CVJCompressor::CompressPush(TUint8* aChanges,  ThdrTCP* aTCPHeader)

/**

Compresses the TCP Push flag.

@param aChanges The VJ change mask to be updated

@param aTCPHeader TCP header

@return ETrue

*/

	{

	TUint Flags = aTCPHeader->VJGetFlags();

	if (Flags & KTcpPSH )

		{

		*aChanges |= KVjCompMaskPush;

		}

	return ETrue;

	}

TBool CVJCompressor::IsSameConnAsLast(TUint* aCompressedHdrLen, TUint aConnection)

/**

Determines whether the given VJ connection number is the same as that of the

last compressed packet sent and returns the size of the compressed header.