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

// Name          : SIPMessageUtility.cpp

// Part of       : TransactionUser

// Version       : SIP/5.0

//

#include <in_sock.h>

#include <e32math.h>

#include <utf.h>

#include "SipAssert.h"

#include "siprequest.h"

#include "sipresponse.h"

#include "sipuri.h"

#include "uricontainer.h"

#include "sipviaheader.h"

#include "sipfromheader.h"

#include "siptoheader.h"

#include "sipaddress.h"

#include "siphostport.h"

#include "sipcseqheader.h"

#include "sipstrings.h"

#include "sipstrconsts.h"

#include "SIPMessageUtility.h"

#include "CUserAgent.h"

const TInt KMaxBitsReturned = 6;

const TInt KBitsInByte = 8;

//Length of CSIPMessageUtility::iCounter as characters in hex representation

const TInt KCounterLength = 8;

// -----------------------------------------------------------------------------

// CSIPMessageUtility::CSIPMessageUtility

// -----------------------------------------------------------------------------

//

CSIPMessageUtility::CSIPMessageUtility()

	{	

	TUint ticks = User::TickCount();

	TTime now;

	now.UniversalTime();

	TInt64 us = now.Int64();

	iSeed = static_cast<TInt64>(ticks) + us;

	iCounter = I64LOW(us) - ticks;

	}

// -----------------------------------------------------------------------------

// CSIPMessageUtility::~CSIPMessageUtility

// -----------------------------------------------------------------------------

//

CSIPMessageUtility::~CSIPMessageUtility()

	{

	}

// -----------------------------------------------------------------------------

// CSIPMessageUtility::CompareTInetAddr

// aAddr2 always has port filled.

// -----------------------------------------------------------------------------

//

TBool CSIPMessageUtility::CompareTInetAddr(const TInetAddr& aAddr,

										   RStringF aTransportProtocol,

                                           const TInetAddr& aAddr2)

	{

    return aAddr.Match(aAddr2) &&

    	   (SIPPort(aAddr, aTransportProtocol) == aAddr2.Port());

	}

// -----------------------------------------------------------------------------

// CSIPMessageUtility::SIPPort

// -----------------------------------------------------------------------------

//

TUint CSIPMessageUtility::SIPPort(const TInetAddr& aAddr,

								  RStringF aTransportProtocol)

	{

	const TUint KDefaultSipPort 	  = 5060;

	const TUint KDefaultSipPortForTLS = 5061;

    if (aAddr.Port() == 0)

        {

        if (aTransportProtocol == SIPStrings::StringF(SipStrConsts::ETLS))

        	{

        	return KDefaultSipPortForTLS;

        	}

        return KDefaultSipPort;

        }

    return aAddr.Port();

	}

// -----------------------------------------------------------------------------

// CSIPMessageUtility::ConvertUtf8LC

// -----------------------------------------------------------------------------

//

HBufC* CSIPMessageUtility::ConvertUtf8LC(const TDesC8& aUtf8)

	{

	HBufC* unicode = HBufC::NewLC(aUtf8.Size());

	TPtr ptr = unicode->Des();

	User::LeaveIfError(CnvUtfConverter::ConvertToUnicodeFromUtf8(ptr, aUtf8));

    return unicode;

	}

// -----------------------------------------------------------------------------

// CSIPMessageUtility::AddRandomStringL

// -----------------------------------------------------------------------------

//

void CSIPMessageUtility::AddRandomStringL(TDes8& aBuf,

										  TInt aLength,

										  TBool aCaseSensitive,

										  CSIPMessage* aMsg,

										  TTransactionId aTransactionId,

										  const CUserAgent* aUserAgent)

	{

    __SIP_ASSERT_LEAVE(aLength <= aBuf.MaxLength() - aBuf.Length(),

		               KErrOverflow);

	HBufC8* data = BuildInputDataL(aLength, aMsg, aTransactionId, aUserAgent);

    //2^KMaxBitsReturned (64) valid chars that can be put to descriptor

	_LIT8(KCharStore,

          "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_");

	TInt amountOfBits = KMaxBitsReturned;

	if (!aCaseSensitive)

		{

		//The capital letters are not used

		amountOfBits--;

		}

	TUint counter = 0;

	for (TInt i = 0; i < aLength; i++)

		{

		aBuf.Append(KCharStore()[CSIPMessageUtility::GetNextBits(

            		*data, amountOfBits, counter) %	KCharStore().Length()]);

		}

	delete data;

	}

// -----------------------------------------------------------------------------

// CSIPMessageUtility::BuildInputDataL

// Use the best source of randomness first, and add pseudorandom numbers until

// there is enough data.

// -----------------------------------------------------------------------------

//

HBufC8* CSIPMessageUtility::BuildInputDataL(TUint aLength,

											CSIPMessage* aMsg,

											TTransactionId aTransactionId,

											const CUserAgent* aUserAgent)

	{

	//Extra bytes at end to have enough data for getting aLength amount of

	//KMaxBitsReturned bit sequences.

	const TInt KExtra = 4;

	HBufC8* buf =

		HBufC8::NewLC(((aLength * KMaxBitsReturned) / KBitsInByte) + KExtra);

	TPtr8 ptr = buf->Des();

	//First two bytes are filled later. Terminate string with a zero.

	const TUint8 reserveString[] = {1, 1, 0};

	ptr = reserveString;

	//Increment the counter every time the input data is created so even if To,

	//From etc. headers are same, output differs.

	iCounter++;

    AddCheckSumOfSipMessageL(aMsg, ptr);

    AddCheckSumOfTaIdL(aTransactionId, ptr);

	AddSystemInfo(ptr);

	if (aUserAgent && FitsInBuf(ptr, sizeof(TUint16)))

		{

		//UserAgent's current state

        ComputeChecksum(ptr, aUserAgent, sizeof(*aUserAgent));

		}

	TInt random = 0;

	while (FitsInBuf(ptr, sizeof(random)))

		{

		random = Math::Rand(iSeed);

		ptr.Append(reinterpret_cast<const TUint8*>(&random), sizeof(random));

        }

    //Write buf's checksum to the two reserved bytes.

	TUint16 cs = 0;

	Mem::Crc(cs, ptr.Ptr(), buf->Length());

	ptr[0] = static_cast<TUint8>((cs & 0xff00) >> KBitsInByte);

	ptr[1] = static_cast<TUint8>(cs & 0xff);

	CleanupStack::Pop(buf);

	return buf;

	}

// -----------------------------------------------------------------------------

// CSIPMessageUtility::GetNextBits

// -----------------------------------------------------------------------------

//

TUint8

CSIPMessageUtility::GetNextBits(const TDesC8& aBuf, TInt aBits, TUint& aCounter)

	{

	if (aBuf.Length() == 0)

		{

		return 0;

		}

	//Amount of aBits long bit sequences in aBuf

	TUint sixBitItems = aBuf.Length() * KBitsInByte / aBits;

	if (aCounter >= sixBitItems)

		{

		aCounter = 0;

		}

	//The position in aBuf, of the byte containing the first bit of the aBits

	//long bit sequence. Zero means the first byte.

	TInt startByte = aCounter * aBits / KBitsInByte;

	TUint16 result = static_cast<TUint16>(aBuf[startByte] << KBitsInByte);

	if (++startByte >= aBuf.Length())

		{

		startByte = 0;

		}

	result = static_cast<TUint16>(result | aBuf[startByte]);

	//The position of the first bit of the aBits long bit sequence, within the

	//byte. Zero means the first bit.

	TUint offsetInsideByte = (aCounter * aBits) % KBitsInByte;

	//Remove excess bits from the result

	result = static_cast<TUint16>(result << offsetInsideByte);	

	result >>= ((2 * KBitsInByte) - aBits);

    __ASSERT_DEBUG(result < (1 << aBits),

        		   User::Panic(_L("CSIPMsgUtil:GetNextBits"), KErrOverflow));

    aCounter++;

    return static_cast<TUint8>(result);

	}

// -----------------------------------------------------------------------------

// CSIPMessageUtility::FitsInBuf

// -----------------------------------------------------------------------------

//

TBool CSIPMessageUtility::FitsInBuf(const TDes8& aBuf, TInt aSize)

	{	

	return (aBuf.Size() <= aBuf.MaxSize() - aSize);

	}

// -----------------------------------------------------------------------------

// CSIPMessageUtility::AddCheckSumOfSipMessageL

// -----------------------------------------------------------------------------

//

void CSIPMessageUtility::AddCheckSumOfSipMessageL(CSIPMessage* aMsg,

                                                  TDes8& aBuf)

    {

    if (aMsg)

        {

        if (aMsg->HasHeader(SIPStrings::StringF(SipStrConsts::EToHeader)))

		    {

		    AddCheckSumOfFromToHeaderL(*aMsg->To(), aBuf);

		    }

	    if (aMsg->HasHeader(SIPStrings::StringF(SipStrConsts::EFromHeader)))

		    {

		    AddCheckSumOfFromToHeaderL(*aMsg->From(), aBuf);

		    }

	    AddCheckSumOfCSeq(*aMsg, aBuf);

	    AddCheckSumOfRequestLineL(*aMsg, aBuf);

        }

    }

// -----------------------------------------------------------------------------

// CSIPMessageUtility::AddCheckSumOfFromToHeaderL

// -----------------------------------------------------------------------------

//

void

CSIPMessageUtility::AddCheckSumOfFromToHeaderL(CSIPFromToHeaderBase& aHeader,

                                               TDes8& aBuf)

	{

	if (FitsInBuf(aBuf, sizeof(TUint16)))

		{

		HBufC8* toBuf = aHeader.SIPAddress().ToTextLC();

		HBufC8* buf = HBufC8::NewLC(KCounterLength + toBuf->Length());

		TPtr8 ptr = buf->Des();

		//Add iCounter at the beginning, to get a greater effect on output

		ptr.AppendFormat(_L8("%x"), iCounter);

		ptr.Append(*toBuf);

        ComputeChecksum(aBuf, buf, buf->Length());

        CleanupStack::PopAndDestroy(buf);

		CleanupStack::PopAndDestroy(toBuf);

		}

	}

// -----------------------------------------------------------------------------

// CSIPMessageUtility::AddCheckSumOfCSeq

// -----------------------------------------------------------------------------

//

void CSIPMessageUtility::AddCheckSumOfCSeq(CSIPMessage& aMsg, TDes8& aBuf)

	{

	if (aMsg.HasHeader(SIPStrings::StringF(SipStrConsts::ECSeqHeader)) &&

		FitsInBuf(aBuf, sizeof(TUint16)))

		{

		TUint cseq = aMsg.CSeq()->Seq();

        ComputeChecksum(aBuf, &cseq, sizeof(cseq));

		}

	}

// -----------------------------------------------------------------------------

// CSIPMessageUtility::AddCheckSumOfClock

// -----------------------------------------------------------------------------

//

void CSIPMessageUtility::AddCheckSumOfClock(TDes8& aBuf) const

	{

	if (FitsInBuf(aBuf, sizeof(TUint16)))

		{

		TTime now;

		now.UniversalTime();

		TInt64 timeAsInt = now.Int64();

		TBuf8<20> timeBuf;

		//Add iCounter before timeAsInt. If this function is called very often,

		//timeAsInt can be same as in the previous call.

		timeBuf.Append(reinterpret_cast<const TUint8*>(&iCounter),

					   sizeof(iCounter));

		timeBuf.Append(reinterpret_cast<const TUint8*>(&timeAsInt),

					   sizeof(timeAsInt));

        ComputeChecksum(aBuf, &timeBuf, timeBuf.Length());

		if (FitsInBuf(aBuf, sizeof(TUint16)))

			{

			timeBuf.Zero();

			timeBuf.Append(reinterpret_cast<const TUint8*>(&iCounter),

						   sizeof(iCounter));

			TUint ticks = User::TickCount();

			timeBuf.Append(reinterpret_cast<const TUint8*>(&ticks),

						   sizeof(ticks));

            ComputeChecksum(aBuf, &timeBuf, timeBuf.Length());

            }

		}

	}

// -----------------------------------------------------------------------------

// CSIPMessageUtility::AddCheckSumOfTaIdL

// Add counter first, so it has greater effect on output.

// -----------------------------------------------------------------------------

//

void CSIPMessageUtility::AddCheckSumOfTaIdL(TTransactionId aTransactionId,

											TDes8& aBuf)

	{

	if (aTransactionId != KEmptyTransactionId &&

		FitsInBuf(aBuf, sizeof(TUint16)))

		{

		const TInt KTransactionIdLengthInHex = 8;

		HBufC8* buf = HBufC8::NewLC(KCounterLength + KTransactionIdLengthInHex);

		TPtr8 ptr = buf->Des();

		ptr.AppendFormat(_L8("%x%x"), iCounter, aTransactionId);

        ComputeChecksum(aBuf, buf, buf->Length());

        CleanupStack::PopAndDestroy(buf);

		}

	}

// -----------------------------------------------------------------------------

// CSIPMessageUtility::AddCheckSumOfRequestLineL

// -----------------------------------------------------------------------------

//

void CSIPMessageUtility::AddCheckSumOfRequestLineL(CSIPMessage& aMsg,

                                                   TDes8& aBuf)

	{

	if (aMsg.IsRequest() && FitsInBuf(aBuf, sizeof(TUint16)))

		{

		CSIPRequest& req = static_cast<CSIPRequest&>(aMsg);	

		if (req.RequestURI())

			{

			HBufC8* uriBuf = req.RequestURI()->ToTextL();

			CleanupStack::PushL(uriBuf);

			HBufC8* buf =

                HBufC8::NewLC(uriBuf->Length() + req.Method().DesC().Length());

			TPtr8 ptr = buf->Des();

			ptr.Append(*uriBuf);

			ptr.Append(req.Method().DesC());

            ComputeChecksum(aBuf, buf, buf->Length());

			CleanupStack::PopAndDestroy(buf);

			CleanupStack::PopAndDestroy(uriBuf);

			}

		}

	}

// -----------------------------------------------------------------------------

// CSIPMessageUtility::AddSystemInfo

// -----------------------------------------------------------------------------

//

void CSIPMessageUtility::AddSystemInfo(TDes8& aBuf) const

	{

	AddCheckSumOfClock(aBuf);

	if (FitsInBuf(aBuf, sizeof(TUint16)))

		{

		TInt largest = 0;

		TInt total = User::Available(largest);		

		TInt value = (largest + total - User::CountAllocCells()) + iCounter;

        ComputeChecksum(aBuf, &value, sizeof(value));

		}

	if (FitsInBuf(aBuf, sizeof(TUint8)))	

		{

		TTimeIntervalSeconds inactivity = User::InactivityTime();

		if (inactivity.Int() > 0)

			{

			TUint8 byteVal = static_cast<TUint8>(inactivity.Int() & 0xff);

			aBuf.Append(&byteVal, sizeof(byteVal));

			}

		}

	}

// -----------------------------------------------------------------------------

// CSIPMessageUtility::ComputeChecksum

// -----------------------------------------------------------------------------

//

void

CSIPMessageUtility::ComputeChecksum(TDes8& aBuf, const TAny* aPtr, TInt aLength)

    {

    __SIP_ASSERT_RETURN(aPtr != NULL, KErrArgument);

    TUint16 cs = 0;

	Mem::Crc(cs, aPtr, aLength);

	aBuf.Append(reinterpret_cast<const TUint8*>(&cs), sizeof(cs));

    }

// -----------------------------------------------------------------------------

// CSIPMessageUtility::MessageMethod

// -----------------------------------------------------------------------------

//

RStringF CSIPMessageUtility::MessageMethod(CSIPMessage& aMsg)

	{

	if (aMsg.IsRequest())

		{

		return static_cast<const CSIPRequest&>(aMsg).Method();

		}

    __ASSERT_DEBUG(aMsg.CSeq() != NULL,

        		   User::Panic(_L("CSIPMsgUtil:MsgMethod"), KErrArgument));

    return aMsg.CSeq()->Method();

	}

// -----------------------------------------------------------------------------

// CSIPMessageUtility::TransactionType

// -----------------------------------------------------------------------------

//

CTransactionBase::TTransactionType

CSIPMessageUtility::TransactionType(CSIPMessage& aMsg, TBool aIncomingMsg)

	{

	__ASSERT_ALWAYS(

		aMsg.HasHeader(SIPStrings::StringF(SipStrConsts::ECSeqHeader)),

		User::Panic(_L("MsgUt:TType CSeq"), KErrArgument));

	RStringF cseqMethod = aMsg.CSeq()->Method();

	if (cseqMethod == SIPStrings::StringF(SipStrConsts::EInvite) ||

        cseqMethod == SIPStrings::StringF(SipStrConsts::EAck))

		{

		if (aMsg.IsRequest() ^ aIncomingMsg)

			{

			//Outgoing request or incoming response

			return CTransactionBase::KClientInviteTransaction;

			}

		return CTransactionBase::KServerInviteTransaction;

		}

	if (aMsg.IsRequest() ^ aIncomingMsg)

		{

		return CTransactionBase::KClientTransaction;

		}

	return CTransactionBase::KServerTransaction;

	}

// -----------------------------------------------------------------------------

// CSIPMessageUtility::HasViaMagicCookie

// -----------------------------------------------------------------------------

//

TBool CSIPMessageUtility::HasViaMagicCookie(CSIPMessage& aMsg)

	{

    CSIPViaHeader* topVia = TopVia(aMsg);

    RStringF branch = SIPStrings::StringF(SipStrConsts::EBranch);

	return topVia &&

		   topVia->HasParam(branch) &&

           topVia->ParamValue(branch).DesC().Left(

               BranchMagicCookie().Length()).Compare(BranchMagicCookie()) == 0;

	}

// -----------------------------------------------------------------------------

// CSIPMessageUtility::CheckTransport

// -----------------------------------------------------------------------------

//

TBool CSIPMessageUtility::CheckTransport(RStringF aTransport)

    {

    return aTransport == SIPStrings::StringF(SipStrConsts::EUDP) ||

    	   aTransport == SIPStrings::StringF(SipStrConsts::ETCP) ||

    	   aTransport == SIPStrings::StringF(SipStrConsts::ETLS);

    }