// Copyright (c) 2004-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:

 // in_chk.h - IPv6/IPv4 checksum module

 // Raw Internet Checksum computation from RMBufChain.

 //

 /**

  @file in_chk.h

  @publishedAll

  @released

 */

 #ifndef __IN_CHK_H__

 #define __IN_CHK_H__

 #include "in_pkt.h"

 class RMBufChain;

 class RMBufPktInfo;

 /** Checksum calculation.

 @publishedAll

 @released

 */

 class TChecksum {

 public:

         // TChecksum can be initialized with an old inverted checksum

         TChecksum(TUint16 aSum = ~0) : iSum((TUint16)~aSum) {}

 	inline void Init(TUint16 aSum = ~0);

 	inline TUint32 Sum();

         inline TUint32 Sum32();

         inline void Fold();

         inline void Reverse();

         // Complex Add methods

         IMPORT_C void Add(RMBufChain &aPacket, TInt aOffset);

         IMPORT_C void Add(RMBufChain &aPacket, const RMBufPktInfo *aInfo, TInt aOffset);

         // Inline Add methods

         inline void Add(const TUint16 *aPtr, TInt aLength);

         inline void AddHi(TUint8 aByte);

         inline void AddLo(TUint8 aByte);

         inline void Add(TUint16 aHalfWord);

         inline void Add(TUint32 aWord);

         inline void AddH(TUint16 aHalfWord);

         inline void AddH(TUint32 aWord);

         // Static methods

         static inline TUint32 Fold(TUint32 aSum);

         static inline TUint16 ComplementedFold(TUint32 aSum);

         IMPORT_C static TUint32 Calculate(const TUint16 *aPtr, TInt aLength);

 private:

 	TUint32	iSum;   // 32-bit sum in network byte order

 };

 /**

 // TInet6Checksum Template.

 //

 //		This template class provides utilitlies to compute and check

 //		IPv6 Upper Layer Checksums

 //		These are not merged with the TInet6Packet class, because that

 //		class is intended (and is used) for all headers, not just upper

 //		layers.

 //

 //	The template parameter (Header class) must

 //		- have Checksum() method

 //		- have SetChecksum() method

 //		- the checkum in header must be aligned to 16 bit word

 //

 // @publishedAll

 // @released

 */

 template <class T>

 class TInet6Checksum : public TInet6Packet<T>

 	{

 public:

 	TInet6Checksum() {}

 	TInet6Checksum(RMBufChain &aPacket) : TInet6Packet<T>(aPacket) {}

 	TInet6Checksum(RMBufChain &aPacket, TInt aOffset) : TInet6Packet<T>(aPacket, aOffset) {}

 	void ComputeChecksum(RMBufChain &aPacket, const RMBufPktInfo *aInfo, TInt aOffset = 0);

 	TBool VerifyChecksum(RMBufChain &aPacket, const RMBufPktInfo *aInfo, TInt aOffset = 0);

 	void ComputeChecksum();

 	TBool VerifyChecksum();

 	};

 //

 // Inline methods for TChecksum

 //

 inline void TChecksum::Init(TUint16 aSum)

 {

         iSum = ~aSum & 0xffff;

 }

 inline void TChecksum::Add(const TUint16 *aPtr, TInt aLength)

 {

 	iSum += Calculate(aPtr, aLength);

 }

 inline void TChecksum::AddHi(TUint8 aByte)

 {

         iSum += (aByte << 8);

 }

 inline void TChecksum::AddLo(TUint8 aByte)

 {

         iSum += aByte;

 }

 // Add halfword in network byte order

 inline void TChecksum::Add(TUint16 aHalfWord)

 {

         iSum += aHalfWord;

 }

 // Add word in network byte order

 inline void TChecksum::Add(TUint32 aWord)

 {

 	iSum += aWord >> 16;

         iSum += aWord & 0xffff;

 }

 // Add halfword in host byte order

 inline void TChecksum::AddH(TUint16 aHalfWord)

 {

 		__DEBUG_ONLY (const TInt one = 1;)

 		ASSERT(*(TUint8*)&one); //check that we are little-endian

 		iSum += ((aHalfWord << 8) | (aHalfWord >> 8)) & 0xffff;

 }

 // Add word in host byte order

 inline void TChecksum::AddH(TUint32 aWord)

 {

 		__DEBUG_ONLY (const TInt one = 1;)

 		ASSERT(*(TUint8*)&one); //check that we are little-endian

         iSum += (aWord >> 24);          // add octet  3

         iSum += (aWord >> 8) & 0xffff,  // add octets 2-1

         iSum += (aWord << 8) & 0xff00;  // add octet  0

 }

 // Fold 32-bit sum into 16 bits

 inline void TChecksum::Fold()

 {

         iSum = Fold(iSum);

 }

 // Return 16-bit inverted checksum

 inline TUint32 TChecksum::Sum()

 {

         return Fold(iSum) ^ 0xffff;

 }

 // Return 32-bit intermediate sum

 inline TUint32 TChecksum::Sum32()

 {

         return iSum;

 }

 // Reverse checksum direction. Can be used to back out partial sums.

 inline void TChecksum::Reverse()

 {

         iSum = Sum();

 }

 inline TUint32 TChecksum::Fold(TUint32 aSum)

 {

 	aSum = (aSum >> 16) + (aSum & 0xffff);  // Max: 0x0001fffe

 	aSum += (aSum >> 16);                   // Max: 0x0001ffff

         return aSum & 0xffff;                   // Truncate to 16 bits

 }

 inline TUint16 TChecksum::ComplementedFold(TUint32 aSum)

 {

         return (TUint16)~Fold(aSum);

 }

 template <class T>

 void TInet6Checksum<T>::ComputeChecksum(RMBufChain &aPacket, const RMBufPktInfo *aInfo, TInt aOffset)

 	{

         TChecksum sum;

 	this->iHdr->SetChecksum(0);

         sum.Add(aPacket, aInfo, aOffset);

 	this->iHdr->SetChecksum(sum.Sum());

 	}

 template <class T>

 TBool TInet6Checksum<T>::VerifyChecksum(RMBufChain &aPacket, const RMBufPktInfo *aInfo, TInt aOffset)

 	{

         TChecksum sum;

         sum.Add(aPacket, aInfo, aOffset);

         return !sum.Sum();

 	}

 //

 // The following are mainly for the IPv4 Header checksum

 //

 template <class T>

 void TInet6Checksum<T>::ComputeChecksum()

 	{

         TChecksum sum;

 	this->iHdr->SetChecksum(0);

         sum.Add((TUint16 *)(this->iHdr), this->iHdr->HeaderLength());

 	this->iHdr->SetChecksum(sum.Sum());

 	}

 template <class T>

 TBool TInet6Checksum<T>::VerifyChecksum()

 	{

         TChecksum sum;

         sum.Add((TUint16*)(this->iHdr), this->iHdr->HeaderLength());

         return !sum.Sum();

 	}

 #endif