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

/**
 @file
 @internalComponent 
*/

#if !defined(__VJ_H__)
#define __VJ_H__

#include <networking/in_tcp.h>
#include <networking/vjif.h>

const TUint8 KVJDiscard			= 1;

// Limits on the number of slots that can be handled by the VJ code
// in terms of the enumerated slot number.
// The VJ code may work with KMinVjSlot=0, but 2 is safer without more testing.
const TUint8 KMinVjSlot			= 2;
const TUint8 KDesiredVjSlot		= 15;
const TUint8 KMaxVjSlot			= 255;

const TUint8 KVjCompSlotId		= 1;
const TUint8 KVjCompMaskConn	= 0x40;
const TUint8 KVjCompMaskIp		= 0x20;
const TUint8 KVjCompMaskPush	= 0x10;
const TUint8 KVjCompMaskSeq		= 0x08;
const TUint8 KVjCompMaskAck		= 0x04;
const TUint8 KVjCompMaskWindow	= 0x02;
const TUint8 KVjCompMaskUrgent	= 0x01;
const TUint8 KVjCompMaskSpecialD = KVjCompMaskSeq 
								| KVjCompMaskAck 
								| KVjCompMaskWindow 
								| KVjCompMaskUrgent;
const TUint8 KVjCompMaskSpecials = KVjCompMaskSpecialD;
const TUint8 KVjCompMaskSpecialI = KVjCompMaskSeq 
								| KVjCompMaskWindow 
								| KVjCompMaskUrgent;


const TUint32 KUidVJCompDll		=  0x10000ba8;
const TUint32 KUidUnicodeVJCompDll		=  0x10003d43;

// moved from ncpip.h
const TUint KPppIdIp = 0x0021;
const TUint KPppIdVjCompTcp = 0x002d;
const TUint KPppIdVjUncompTcp = 0x002f;
//

class TVJCompHdr
/**
Van Jacobson compressed TCP/IP header container class.
Implements a linked list.
@internalComponent
*/
	{
public:
	TVJCompHdr();
	void			StoreTCPIPHeader(ThdrIP * aHeader);
	void			RetrieveTCPIPHeader(ThdrIP* aIPHeader, ThdrTCP* aTCPHeader);
	inline void		SetNextPtr(TVJCompHdr * aNextPtr);
	inline TVJCompHdr*		NextPtr() const;
	inline void		SetConnectionNumber(TUint aConnection);
	inline TUint	ConnectionNumber() const;
	inline TBool	IsValid() const;
private:
	inline void		MarkValid();

private:
    /** Pointer to the next object in the linked list */
	TVJCompHdr*		iNextPtr;
	
	/** Flag for iConnectionId indicating this object contains valid data */
	enum {KVJValidFlag = 0x80000000};
	
	/** VJ connection number */
	TUint			iConnectionId;
	
	/** IP header */
	ThdrIP			iIPHeader;
	
	/** TCP header */
	ThdrTCP			iTCPHeader;
	};

#include <networking/vj.inl>

NONSHARABLE_CLASS(CVJDeCompressor) : public CVJDeCompressorIf
/**
Van Jacobson TCP/IP header decompressor (RFC 1144)
@internalComponent
*/
	{
public:
	~CVJDeCompressor();
	//IMPORT_C static CVJDeCompressor* NewL(TUint aSlots);
	TBool	DecompVJUncomp(RMBufChain& aPacket);
	TBool	DecompVJComp(RMBufChain& aPacket);
	void	CRCError();
	void	ConstructL( CVJCompFactory* aFactory, TUint aSlots );
	CVJDeCompressor();
private:
	inline	void	SetFlag( const TUint aFlag);
	inline	void	ClearFlag( const TUint aFlag);
	inline	TBool	TestFlag( const TUint aFlag);
	void	DecompSWAU(const TUint aChanges, TUint8** aVJCompHeader, ThdrTCP* aTCPHeader, TUint16 aPreviousFrameLength);
	void	DecompPushFlag(const TUint aChanges, ThdrTCP* aHeader);
	void	DecompIPId(const TUint aChanges, TUint8** aVJCompHeader, ThdrIP* aIPHeader );
	TUint16	DecodeDelta( TUint8 ** aVJCompHeader );
	void	EncodeDelta(TUint8** aVJCompHeader, TUint16 aValue);
	void	DecompUrgent(TUint8** aVJCompHeader, ThdrTCP* aTCPHeader, TUint aChanges);
	void	DecompWindow(TUint8** aVJCompHeader, ThdrTCP* aTCPHeader);
	void	DecompAck(TUint8** aVJCompHeader, ThdrTCP* aTCPHeader);
	void	DecompSeq(TUint8** aVJCompHeader, ThdrTCP* aTCPHeader);
	TUint8*	GetVJPtr(RMBufChain &aChain, TUint16* aCurrentFrameLength);
	void	DecompressFrameL(RMBufChain& aPacket, TUint8 aConnection, TUint8 aChanges, TUint8* const aInitialHeaderPtr, TUint Offset, TUint16 aCurrentFrameLength);
	void	CopyInNewHeaderL(RMBufChain* aPacket, ThdrIP * aIPHeader, ThdrTCP * aTCPHeader, TUint aCompressedHeaderLength, TUint16 aIPHeaderLength, TUint16 aTCPHeaderLength);
	ThdrIP*	GetIPHeader(RMBufChain &aChain);
	void	DoIPChecksum(ThdrIP* aIPHeader, TUint16 aIPHeaderLength);
	void	CopyRecvHeader(const TUint aConnectionNumber, ThdrIP * aHeader);
	void	GetStoredRxHeader(const TUint aConnectionNumber, ThdrIP * aIPHeader, ThdrTCP * aTCPHeader);
	TBool	CheckStoredRxHeader(const TUint aConnection) const;
	
private:
    /** Index of the highest-numbered VJ connection */
	TUint		iNumVJSlots;
	
	/** VJ connection number of the last valid packet received */
	TUint		iLastRxConn;
	
	/** Set to KVJDiscard while discarding received packets due to lost synchronization */
	TUint		iFlags;

    /** Pointer to start of array of VJ connections */
	TVJCompHdr* iRxStates;
	};

#include <networking/vjdecomp.inl>

NONSHARABLE_CLASS(CVJCompressor) : public CVJCompressorIf
/**
Van Jacobson TCP/IP header compressor (RFC 1144)
@internalComponent
*/
	{
public:

	~CVJCompressor();
	//IMPORT_C static CVJCompressor* NewL( TUint aSlots, TBool aCompressConnId );
	TInt	VJCompressFrame(RMBufChain& aPacket);
	void	ConstructL(CVJCompFactory* aFactory, TUint aMaxSlot, TBool aCompressConnId);
	CVJCompressor();

private:
	void	EncodeDelta(TUint8** aVJCompHeader, TInt16 aValue);
	inline TBool	IsDeltaCompressible(TUint32 aDelta) const;
	ThdrIP*	GetIPHeader(RMBufChain &aChain);
	TBool	SuitableForVJCompression(ThdrIP* aIPHeader, ThdrTCP* aTCPHeader, TUint* aConnection, ThdrIP* aRetrievedIPHdr, ThdrTCP* aRetrievedTCPHdr);
	TBool	CompressFrame(	RMBufChain& aPacket, 
							ThdrIP* aIPHeader, 
							ThdrTCP* aTCPHeader, 
							TUint aConnection,
							ThdrIP* aRetrievedIPHdr,
							ThdrTCP* aRetrievedTCPHdr);
	TBool	SendAsRawIP(ThdrIP* aIPHeader, ThdrTCP* aTCPHeader);
	TBool	IsIPCompressible( ThdrIP* aIPHeader, ThdrIP* aRetrievedIPHdr);
	TBool	IsTCPCompressible( ThdrTCP* aTCPHeader, ThdrTCP* aRetrievedTCPHdr);
	TBool	CompressUrgentPtr(TUint8** aVJPtr, TUint8* aChanges, ThdrTCP* aTCPHeader, ThdrTCP* aRetrievedTCPHdr);
	TBool	CompressWindow(TUint8** aVJPtr, TUint8* aChanges, ThdrTCP* aTCPHeader, ThdrTCP* aRetrievedTCPHdr);
	TBool	CompressAck(TUint8** aVJPtr, TUint8* aChanges, ThdrTCP* aTCPHeader, ThdrTCP* aRetrievedTCPHdr);
	TBool	CompressSeq(TUint8** aVJPtr, TUint8* aChanges, ThdrTCP* aTCPHeader, ThdrTCP* aRetrievedTCPHdr);
	TBool	CompressIPId(TUint8** aVJPtr, TUint8* aChanges, ThdrIP* aIPHeader, ThdrIP* aRetrievedIPHdr);
	TBool	CompressPush(TUint8* aChanges,  ThdrTCP* aTCPHeader);
	TBool	IsSameConnAsLast(TUint* aCompressedHdrLen, TUint aConnection);
	void	SetFirstFewBytes(TUint8* aChanges, TBool aNewConnection, TUint8** aVJHeader, ThdrTCP* aTCPHeader, TUint aConnection);
	void	CopyInNewTxHeader(RMBufChain& aPacket, TUint8* aCompressedHdr, TUint aOldHeaderLength, TUint aNewHeaderLength);
	void	DecrementPacketLen( RMBufChain& aPacket, TUint SizeDecrease );
	TBool	CompressSpecialCases(	TUint8** aVJPtr, 
									TUint8* const aVJInitialDeltaPtr, 
									TUint8* aChanges, 
									ThdrTCP* aTCPHeader, 
									ThdrTCP* aRetrievedTCPHdr, 
									ThdrIP* aIPHeader,
									ThdrIP* aRetrievedIPHdr);
	void	ConvertFrameToUncompVJ(ThdrIP* aIPHeader, TUint aConnection);
	inline TUint8* GetTCPOpts(ThdrTCP* aTCPHeader) const;
	void	CopyTxHeader( ThdrIP* aIPHeader, TUint aConnection);
	TBool	GetStoredTxHeader(	TUint* aConnection, 
								ThdrIP * aIPHeader, 
								ThdrTCP* aTCPHeader, 
								ThdrIP* aRetrievedIPHdr, 
								ThdrTCP* aRetrievedTCPHdr);
	TBool	IPAddressesMatch(ThdrIP* aIPHeader,ThdrIP* aNotherIPHdr);	
	TBool	TCPPortsMatch(ThdrTCP* aHeader, ThdrTCP* aNotherHdr );
	
private:
    /** Maximum number of VJ connections */
	TUint		iMaxVJSlots;
	
	/** Whether VJ was configured to compress the connection number */
	TBool		iCompressConnId;
	
	/** Connection number of the last packet compressed */
	TUint		iLastTxConn;
	
    /** Pointer to the last element in the LRU circular list */
	TVJCompHdr*	iLastTxHdr;

    /** Pointer to start of array of VJ connections */
	TVJCompHdr*	iTxStates;
	};

#include <networking/vjcomp.inl>

NONSHARABLE_CLASS(CVJFactory) : public CVJCompFactory
/**
Factory base for creating a concrete instance of a
compressor or decompressor object
@internalTechnology
*/
	{
public:
	CVJFactory();
	void InstallL();
	CVJCompressorIf* NewVJCompressorL( TInt aMaxVJSlots, TInt aCompressConnId);
	CVJDeCompressorIf* NewVJDeCompressorL(TInt aMaxVJSlots);
	};

extern "C"
	{
/**
Generates and returns a CVJFactory object.
This is the polymorphic DLL entry point.

@return New CVJFactory object
@internalTechnology
*/
	IMPORT_C CVJCompFactory* NewVJCompFactoryL(void);
	}

#endif // __VJ_H__