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

//

#include "TEquiv.h"

#include <uriutils.h>

#include <uriutilscommon.h>

#include "UriUtilsInternal.h"

#include <delimitedpathsegment8.h>

#include <delimitedquery8.h>

#include <escapeutils.h>

_LIT8(KParamUserFull,	";user=");

_LIT8(KParamTtlFull,	";ttl=");

_LIT8(KParamMethodFull,	";method=");

_LIT8(KParamMaddrFull,	";maddr=");

_LIT8(KParamMaddr,		"maddr");

_LIT8(KHeaderId, "call-id");

_LIT8(KHeaderIdAbbr, "i");

_LIT8(KHeaderContact, "contact");

_LIT8(KHeaderContactAbbr, "m");

_LIT8(KHeaderEncoding, "content-encoding");

_LIT8(KHeaderEncodingAbbr, "e");

_LIT8(KHeaderLength, "content-length");

_LIT8(KHeaderLengthAbbr, "l");

_LIT8(KHeaderType, "content-type");

_LIT8(KHeaderTypeAbbr, "c");

_LIT8(KHeaderFrom, "from");

_LIT8(KHeaderFromAbbr, "f");

_LIT8(KHeaderSubject, "subject");

_LIT8(KHeaderSubjectAbbr, "s");

_LIT8(KHeaderTo, "to");

_LIT8(KHeaderToAbbr, "t");

TEquiv::TEquiv(const TUriC8& aLhs, const TUriC8& aRhs)

: iLhs(aLhs), iRhs(aRhs)

	{

	}

TBool TEquiv::EquivalentL() const

	{

	if (!IsMatchSchemeL())

		return KUriUtilsErrDifferentScheme;

	if (!IsMatchUserInfoL())

		return KUriUtilsErrDifferentUserInfo;

	if (!IsMatchHostL())

		return KUriUtilsErrDifferentHost;

	if (!IsMatchPortL())

		return KUriUtilsErrDifferentPort;

	if (!IsMatchPathL())

		return KUriUtilsErrDifferentPath;

	if (!IsMatchQueryL())

		return KUriUtilsErrDifferentQuery;

	if (!IsMatchFragmentL())

		return KUriUtilsErrDifferentFragment;

	return KErrNone;

	}

TBool TEquiv::IsMatchSchemeL() const

	{

	HBufC8* lhsDes = DecodedSegmentLC(iLhs, EUriScheme);

	HBufC8* rhsDes = DecodedSegmentLC(iRhs, EUriScheme);

	TBool result = IsMatchCaseless(*lhsDes, *rhsDes);

	CleanupStack::PopAndDestroy(2);

	return result;

	}

TBool TEquiv::IsMatchUserInfoL() const

	{

	HBufC8* lhsDes = DecodedSegmentLC(iLhs, EUriUserinfo);

	HBufC8* rhsDes = DecodedSegmentLC(iRhs, EUriUserinfo);

	TBool result = IsMatchCaseSensitive(*lhsDes, *rhsDes);

	CleanupStack::PopAndDestroy(2);

	return result;

	}

TBool TEquiv::IsMatchHostL() const

	{

	HBufC8* lhsDes = DecodedSegmentLC(iLhs, EUriHost);

	HBufC8* rhsDes = DecodedSegmentLC(iRhs, EUriHost);

	TBool result = IsMatchCaseless(*lhsDes, *rhsDes);

	CleanupStack::PopAndDestroy(2);

	return result;

	}

TBool TEquiv::IsMatchPortL() const

	{

	HBufC8* lhsDes = DecodedSegmentLC(iLhs, EUriPort);

	HBufC8* rhsDes = DecodedSegmentLC(iRhs, EUriPort);

	TBool result = IsMatchCaseSensitive(*lhsDes, *rhsDes);

	CleanupStack::PopAndDestroy(2);

	return result;

	}

TBool TEquiv::IsMatchPathL() const

	{

	HBufC8* lhsDes = DecodedSegmentLC(iLhs, EUriPath);

	HBufC8* rhsDes = DecodedSegmentLC(iRhs, EUriPath);

	TBool result = IsMatchCaseSensitive(*lhsDes, *rhsDes);

	CleanupStack::PopAndDestroy(2);

	return result;

	}

TBool TEquiv::IsMatchQueryL() const

	{

	HBufC8* lhsDes = DecodedSegmentLC(iLhs, EUriQuery);

	HBufC8* rhsDes = DecodedSegmentLC(iRhs, EUriQuery);

	TBool result = IsMatchCaseSensitive(*lhsDes, *rhsDes);

	CleanupStack::PopAndDestroy(2);

	return result;

	}

TBool TEquiv::IsMatchFragmentL() const

	{

	HBufC8* lhsDes = DecodedSegmentLC(iLhs, EUriFragment);

	HBufC8* rhsDes = DecodedSegmentLC(iRhs, EUriFragment);

	TBool result = IsMatchCaseSensitive(*lhsDes, *rhsDes);

	CleanupStack::PopAndDestroy(2);

	return result;

	}

HBufC8* TEquiv::DecodedSegmentLC(const TUriC8& aUri, TUriComponent aSegmentType) const

	{

	HBufC8* decoded = EscapeUtils::EscapeDecodeL(aUri.Extract(aSegmentType));

	CleanupStack::PushL(decoded);

	return decoded;

	}

TEquivSip::TEquivSip(const TUriC8& aLhs, const TUriC8& aRhs)

: TEquiv(aLhs, aRhs)

	{

	}

void TEquivSip::RemoveLeadingZeros(TPtr8 aHost) const

	{

	for (TInt i=0; i < aHost.Length(); i++)

		{

		TBool startOfNumber = (i == 0 || aHost[i-1] < '0' || aHost[i-1] > '9');

		if (aHost[i] == '0' && startOfNumber)

			{

			// The character is a zero and is either at the start of the string

			// or the fist number in a sequence.

			aHost.Delete(i--,1);

			}

		}

	}

TBool TEquivSip::IsMatchHostL(const TDesC8& aLhs, const TDesC8& aRhs) const

	{

	UriUtils::TUriHostType lhsType = UriUtils::HostType(aLhs);

	UriUtils::TUriHostType rhsType = UriUtils::HostType(aRhs);

	if (lhsType != rhsType)

		return EFalse;

	if (lhsType != UriUtils::ETextHost)

		{

		// Host is IPv4 or IPv6

		// Create a copy of the hosts and remove any leading '0's

		HBufC8* lhsCopy = aLhs.AllocLC();

		HBufC8* rhsCopy = aRhs.AllocLC();

		RemoveLeadingZeros(lhsCopy->Des());

		RemoveLeadingZeros(rhsCopy->Des());

		TBool result = IsMatchCaseSensitive(*lhsCopy, *rhsCopy);

		CleanupStack::PopAndDestroy(2);

		return result;

		}

	return IsMatchCaseless(aLhs, aRhs);

	}

TBool TEquivSip::IsMatchHostL() const

	{

	HBufC8* lhsDes = DecodedSegmentLC(iLhs, EUriHost);

	HBufC8* rhsDes = DecodedSegmentLC(iRhs, EUriHost);

	TBool result = IsMatchHostL(*lhsDes, *rhsDes);

	CleanupStack::PopAndDestroy(2);

	return result;

	}

TBool TEquivSip::IsParamCompatibleL(const TDesC8& aLhsName, const TDesC8& aLhsValue, const TDesC8& aRhsName, const TDesC8& aRhsValue) const

	{

	// Were're just checking that if the segments have the same name part

	// that their values are the same. This method only returns false if the lhs and rhs

	// have the same name but their values are different.

	if (!IsMatchCaseless(aLhsName, aRhsName))

		{

		// Names don't match so we're OK

		return ETrue;

		}

	// The maddr parameter needs to be handled differently from the others

	// The address is checked for equivalence not just a straight string compare.

	if (IsMatchCaseless(aLhsName, KParamMaddr))

		{

			return IsMatchHostL(aLhsValue, aRhsValue);

		}

	else

		{

		if (!IsMatchCaseless(aLhsValue, aRhsValue))

			{

			// Names are the same but the values are different

			// We have a incompatible parameter

			return EFalse;

			}

		}

	return ETrue;

	}

TBool TEquivSip::IsParamListCompatibleL(const TDelimitedParserBase8& aLhsParser, const TDelimitedParserBase8& aRhsParser) const

	{

	TPtrC8 lhsName;

	TPtrC8 lhsValue;

	TPtrC8 rhsName;

	TPtrC8 rhsValue;

	TPtrC8 lhsSegment;

	TPtrC8 rhsSegment;

	// roll back to the start of the lhs segment parser

	aLhsParser.Reset();

	while( aLhsParser.GetNext(lhsSegment) == KErrNone )

		{

		// roll back to the start of the rhs segment parser

		aRhsParser.Reset();

		GetNameValuePair(lhsSegment, lhsName, lhsValue);

		while( aRhsParser.GetNext(rhsSegment) == KErrNone )

			{

			GetNameValuePair(rhsSegment, rhsName, rhsValue);

			if (!IsParamCompatibleL(lhsName, lhsValue, rhsName, rhsValue))

				return EFalse;

			}

		}

	return ETrue;

	}

TInt TEquivSip::ListLength(const TDelimitedParserBase8& aParser) const

	{

	aParser.Reset();

	TInt result = 0;

	while (!aParser.Eos())

		{

		aParser.Inc();

		++result;

		}

	aParser.Reset();

	return result;

	}

TBool TEquivSip::IsMatchPathL() const

	{

	HBufC8* lhs = DecodedSegmentLC(iLhs, EUriPath);

	HBufC8* rhs = DecodedSegmentLC(iRhs, EUriPath);

	TDelimitedPathSegmentParser8 lhsParser;

	lhsParser.Parse(*lhs);

	TDelimitedPathSegmentParser8 rhsParser;

	rhsParser.Parse(*rhs);

	// Check each parameter in the lhs parameter list with those in

	// the rhs parameter list. If at any point a parameter is incompatible

	// we'll return false.

	TBool result = ETrue;

	// Alway check the parameter list with the most parameters against the other

	// so that we don't miss any

	TInt lhsLength = ListLength(lhsParser);

	TInt rhsLength = ListLength(rhsParser);

	if (lhsLength > rhsLength)

		{

		result = IsParamListCompatibleL(lhsParser, rhsParser);

		}

	else

		{

		result = IsParamListCompatibleL(rhsParser, lhsParser);

		}

	// check that the special parameters, if present, are present in both

	if (result)

		{

		if ((lhs->Find(KParamUserFull) == KErrNotFound) != (rhs->Find(KParamUserFull) == KErrNotFound) ||

		    (lhs->Find(KParamTtlFull) == KErrNotFound) != (rhs->Find(KParamTtlFull) == KErrNotFound) ||

		    (lhs->Find(KParamMethodFull) == KErrNotFound) != (rhs->Find(KParamMethodFull) == KErrNotFound) ||

		    (lhs->Find(KParamMaddrFull) == KErrNotFound) != (rhs->Find(KParamMaddrFull) == KErrNotFound) )

			{

			result = EFalse;

			}

		}

	CleanupStack::PopAndDestroy(2);

	return result;

	}

TEquivSip::THeaderType TEquivSip::HeaderType(const TDesC8& aHeaderName) const

	{

	if (IsMatchCaseless(aHeaderName, KHeaderId) || IsMatchCaseless(aHeaderName, KHeaderIdAbbr))

		return EHeaderId;

	if (IsMatchCaseless(aHeaderName, KHeaderContact) || IsMatchCaseless(aHeaderName, KHeaderContactAbbr))

		return EHeaderContact;

	if (IsMatchCaseless(aHeaderName, KHeaderEncoding) || IsMatchCaseless(aHeaderName, KHeaderEncodingAbbr))

		return EHeaderEncoding;

	if (IsMatchCaseless(aHeaderName, KHeaderLength) || IsMatchCaseless(aHeaderName, KHeaderLengthAbbr))

		return EHeaderLength;

	if (IsMatchCaseless(aHeaderName, KHeaderType) || IsMatchCaseless(aHeaderName, KHeaderTypeAbbr))

		return EHeaderType;

	if (IsMatchCaseless(aHeaderName, KHeaderFrom) || IsMatchCaseless(aHeaderName, KHeaderFromAbbr))

		return EHeaderFrom;

	if (IsMatchCaseless(aHeaderName, KHeaderSubject) || IsMatchCaseless(aHeaderName, KHeaderSubjectAbbr))

		return EHeaderSubject;

	if (IsMatchCaseless(aHeaderName, KHeaderTo) || IsMatchCaseless(aHeaderName, KHeaderToAbbr))

		return EHeaderTo;

	return EHeaderNormal;

	}

TBool TEquivSip::IsMatchHeader(const TDesC8& aLhs, const TDesC8& aRhs) const

	{

	if (IsMatchCaseless(aLhs, aRhs))

		{

		// identical headers are always OK

		return ETrue;

		}

	// We now need to check for abbreviated headers

	TPtrC8 lhsName;

	TPtrC8 lhsValue;

	TPtrC8 rhsName;

	TPtrC8 rhsValue;

	GetNameValuePair(aLhs, lhsName, lhsValue);

	GetNameValuePair(aRhs, rhsName, rhsValue);

	if (!IsMatchCaseless(lhsValue, rhsValue))

		{

		// headers with different values can never match

		return EFalse;

		}

	// We now have only those with different header names but with the same value

	// The last check is to see if the headers are in abbreviated forms

	THeaderType lhsType = HeaderType(lhsName);

	THeaderType rhsType = HeaderType(rhsName);

	if (lhsType != EHeaderNormal && (lhsType == rhsType))

		{

		// They are both special headers of the same type

		// Everything matches

		return ETrue;

		}

	return EFalse;

	}

TBool TEquivSip::IsQueryListCompatible(const TDelimitedParserBase8& aLhsParser, const TDelimitedParserBase8& aRhsParser) const

	{

	TPtrC8 lhsSegment;

	TPtrC8 rhsSegment;

	TBool found = EFalse;

	// roll back to the start of the lhs segment parser

	aLhsParser.Reset();

	while( aLhsParser.GetNext(lhsSegment) == KErrNone )

		{

		// roll back to the start of the rhs segment parser

		aRhsParser.Reset();

		found = EFalse;

		while( aRhsParser.GetNext(rhsSegment) == KErrNone )

			{

			if (IsMatchHeader(lhsSegment, rhsSegment))

				{

				// a match has been found for this header so move to the next

				// header in the lhs list

				found = ETrue;

				break;

				}

			}

		if (!found)

			{

			// no match has been found so the headers are not equvalent

			return EFalse;

			}

		}

	return ETrue;

	}

TBool TEquivSip::IsMatchQueryL() const

	{

	HBufC8* lhs = DecodedSegmentLC(iLhs, EUriQuery);

	HBufC8* rhs = DecodedSegmentLC(iRhs, EUriQuery);

	TDelimitedQueryParser8 lhsParser;

	lhsParser.Parse(*lhs);

	TDelimitedQueryParser8 rhsParser;

	rhsParser.Parse(*rhs);

	TBool result = EFalse;

	// first check that the number of headers are the same in both lists.

	TInt lhsLength = ListLength(lhsParser);

	TInt rhsLength = ListLength(rhsParser);

	if (lhsLength == rhsLength)

		{

		// Check each parameter in the lhs parameter list with those in

		// the rhs parameter list. If at any point a parameter is incompatible

		// we'll return false.

		result = IsQueryListCompatible(lhsParser, rhsParser);

		}

	CleanupStack::PopAndDestroy(2);

	return result;

	}

TBool TEquivSip::IsMatchFragmentL() const

	{

	// We don't care about the fragment for SIP URIs

	return ETrue;

	}