// Copyright (c) 2001-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 <uriutils.h>

 #include <uriutilscommon.h>

 #include "UriUtilsInternal.h"

 #include <escapeutils.h>

 _LIT8(KDot, ".");

 _LIT8(KDotDot, "..");

 _LIT8(KDotSlash, "./");

 _LIT8(KDotDotSlash, "../");

 _LIT8(KSlash, "/");	

 _LIT8(KSlashDot, "/.");

 _LIT8(KSlashDotDot, "/..");

 _LIT8(KSlashDotSlash, "/./");

 _LIT8(KSlashDotDotSlash, "/../");

 _LIT(KHexDigit, "0123456789ABCDEF");

 _LIT(KUnreserved, "-.~_");

 #ifdef _DEBUG

 _LIT(KNormalisationUriPanicCategory, "URI-NORMALIZATION");

 #endif

 const TInt KEscapeIndicator					= '%';

 const TInt KEscapeTripleLength				= 3;

 const TInt KEscDelimiterPos					= 0;

 const TInt KMostSignificantNibblePos		= 1;

 const TInt KLeastSignificantNibblePos		= 2;

 const TInt KSubstringLength					= 3;

 const TInt KUpdateLength					= 2;

 const TInt KAttachLength					= 1;

 const TInt KDotLength						= 1;

 const TInt KDotDotLength					= 2;

 const TInt KDotDotSlashLength				= 3;

 const TInt KSlashDotDotSlashLength			= 4;

 //

 //

 // Implementation of UriUtils

 //

 //

 /**

 	Converts a 16-bit format uri into its internet form. Any Unicode characters 

 	are converted into Utf8 representation and then any excluded characters are 

 	escape encoded.  Reserved characters specified in RFC2396 will not be escape 

 	encoded however, these include ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" | "$" | ",". 

 	For example http://localhost will not be encoded to http%3A%2F%2Flocalhost.

 	@since			6.0

 	@deprecated	 Deprecated in 9.1

 	@leave			KUriUtilsCannotConvert. When the input data cannot be converted.

 	@leave			KUriUtilsErr16BitChar. When the input data has a 16-Bit character to be escape encoded.

 	@param			aUri	The 16-bit format uri.

 	@return			A pointer to a newly created 8-bit uri.

  */

 EXPORT_C CUri8* UriUtils::ConvertToInternetFormL(const TUriC16& aUri)

 	{

 	// Need to convert to utf8

 	HBufC8* utf8Buf = EscapeUtils::ConvertFromUnicodeToUtf8L(aUri.UriDes());

 	CleanupStack::PushL(utf8Buf);

 	// Ok need to parse for the uri without the fragment

 	TUriParser8 parser;

 	parser.Parse(*utf8Buf);

 	TPtrC8 uriNoFragment;

 	parser.UriWithoutFragment(uriNoFragment);

 	// Now escape encode the uri without the fragment

 	HBufC8* escapedBuf = EscapeUtils::EscapeEncodeL(uriNoFragment, EscapeUtils::EEscapeNormal);

 	CleanupStack::PushL(escapedBuf);

 	// Now escape encode the fragment if there is one...

 	HBufC8* escapedFragmentBuf = NULL;

 	if( parser.IsPresent(EUriFragment) )

 		{

 		escapedFragmentBuf = EscapeUtils::EscapeEncodeL(parser.Extract(EUriFragment), EscapeUtils::EEscapeNormal);

 		CleanupStack::PushL(escapedFragmentBuf);

 		}

 	// Parse and then create the CUri8 object

 	parser.Parse(*escapedBuf);

 	CUri8* netForm = CUri8::NewL(parser);

 	// Set the fragment if there was one...

 	if( escapedFragmentBuf != NULL )

 		{

 		CleanupStack::PushL(netForm);

 		netForm->SetComponentL(*escapedFragmentBuf, EUriFragment);

 		CleanupStack::Pop(netForm);

 		CleanupStack::PopAndDestroy(escapedFragmentBuf);

 		}

 	// Cleanup and return

 	CleanupStack::PopAndDestroy(2, utf8Buf);	// utf8Buf, escapedBuf

 	return netForm;

 	}

 /**

 	Converts an 8-bit format uri its into display form. Any escape tripes are decoded and 

 	sets of Utf8 format characters are converted into Unicode.

 	@since			6.0

 	@deprecated	 Deprecated in 9.1	

 	@leave			KUriUtilsCannotConvert. When the input data cannot be converted.

 	@param			aUri	The 8-bit format uri.

 	@return			A pointer to a newly created 16-bit uri.

  */

 EXPORT_C CUri16* UriUtils::ConvertToDisplayFormL(const TUriC8& aUri)

 	{

 	// Need decode escape triples

 	HBufC8* unescapedBuf = EscapeUtils::EscapeDecodeL(aUri.UriDes());

 	CleanupStack::PushL(unescapedBuf);

 	// Now need to convert utf8 to unicode

 	HBufC16* utf8Buf = EscapeUtils::ConvertToUnicodeFromUtf8L(*unescapedBuf);

 	CleanupStack::PushL(utf8Buf);

 	// Parse and then create the CUri16 object

 	TUriParser16 parser;

 	parser.Parse(*utf8Buf);

 	CUri16* displayForm = CUri16::NewL(parser);

 	// Cleanup and return

 	CleanupStack::PopAndDestroy(2, unescapedBuf);	// unescapedBuf, utf8Buf

 	return displayForm;

 	}

 /** 

 	Create a new CUri8 object from a Unicode descriptor.

 	@param aUri a Unicode string containing the URI to parse.

 	@return the new CUri8 object

 	@leave EUriUtilsParserErrInvalidUri  if the descriptor is an invalid URI.

  */

 EXPORT_C CUri8* UriUtils::CreateUriL(const TDesC& aUri) 

 	{

 	// convert to UTF8

 	HBufC8* unsafe8 = EscapeUtils::ConvertFromUnicodeToUtf8L(aUri);

      	CleanupStack::PushL(unsafe8);

 	// escape encode only those characters that cannot be in a URI. assume all %hh are %encoded already

 	HBufC8* uri8desc = EscapeUtils::ReEscapeEncodeL(*unsafe8);

 	CleanupStack::PopAndDestroy(unsafe8);

      	CleanupStack::PushL(uri8desc);

 	TUriParser8 parser;

 	// parse the descriptor into a URI, Leave if it cannot be parsed

 	User::LeaveIfError( parser.Parse(*uri8desc) );

 	CUri8* uri8 = CUri8::NewL(parser);

 	CleanupStack::PopAndDestroy(uri8desc);

 	return uri8;

 	}

 /** 

 	Create a new CAuthority8 object from a Unicode descriptor.

 	@param aAuthority a Unicode string containing the Authority to parse.

 	@return the new CAuthority8 object

 	@leave EUriUtilsParserErrInvalidUri  if the descriptor is an invalid Authority.

  */

 EXPORT_C CAuthority8* UriUtils::CreateAuthorityL(const TDesC& aAuthority) 

 	{

 	// convert to UTF8

 	HBufC8* unsafe8 = EscapeUtils::ConvertFromUnicodeToUtf8L(aAuthority);

      	CleanupStack::PushL(unsafe8);

 	// escape encode only those characters that cannot be in the authority. assume all %s are %encoded already

 	HBufC8* authority8desc = EscapeUtils::ReEscapeEncodeL(*unsafe8);

 	CleanupStack::PopAndDestroy(unsafe8);

      	CleanupStack::PushL(authority8desc);

 	TAuthorityParser8 parser;

 	// parse the descriptor into the authority, Leave if it cannot be parsed

 	User::LeaveIfError( parser.Parse(*authority8desc) );

 	CAuthority8* authority8 = CAuthority8::NewL(parser);

 	CleanupStack::PopAndDestroy(authority8desc);

 	return authority8;

 	}

 /**

 	Checks a descriptor for excluded (invalid) characters. Excluded characters include all 

 	control characters (values 0x00 to 0x1F and greater than 0x7F), space (0x20), delimiter 

 	characters ('<', '>', '#', '%',	'"') and unwise characters ('{', '}', '|', '\', '^', '[', ']', '`').

 	@since			6.0

 	@param			aData	The descriptor to be checked.

 	@return			A boolean value of ETrue if the descriptor contains invalid

 	characters, otherwise EFalse.

  */

 EXPORT_C TBool UriUtils::HasInvalidChars(const TDesC8& aData)

 	{

 	return CheckForExcludedChars(aData);

 	}

 /**

 	Checks a descriptor for excluded (invalid) characters. Excluded characters include all 

 	control characters (values 0x00 to 0x1F and	greater than 0x7F), space (0x20), delimiter 

 	characters ('<', '>', '#', '%','"') and unwise characters ('{', '}', '|', '\', '^', '[', ']', '`').

 	@since			6.0

 	@param			aData	The descriptor to be checked.

 	@return			A boolean value of ETrue if the descriptor contains invalid

 	characters, otherwise EFalse.

  */

 EXPORT_C TBool UriUtils::HasInvalidChars(const TDesC16& aData)

 	{

 	return CheckForExcludedChars(aData);

 	}

 /**

 	Checks the supplied host for an IPv4, IPv6 or text format host

 	@since			7.0

 	@param			aHost	The descriptor containing the host to check

 	@return			A TUriHostType enum of either EIPv6, EIPv4, EText or EUnknown

  */

 EXPORT_C UriUtils::TUriHostType UriUtils::HostType(const TDesC8& aHost)

 	{

 	return CheckHostType(aHost);

 	}

 /**

 	Checks the supplied host for an IPv4, IPv6 or text format host

 	@since			7.0

 	@param			aHost	The descriptor containing the host to check

 	@return			A TUriHostType enum of either EIPv6, EIPv4, EText or EUnknown

  */

 EXPORT_C UriUtils::TUriHostType UriUtils::HostType(const TDesC16& aHost)

 	{

 	return CheckHostType(aHost);

 	}

 //

 //

 // Implementation of component internal functions

 //

 //

 /**

 	@internalComponent

 	Checks whether the given scheme is a network scheme or not

 	@param aScheme The descriptor with the scheme.

 	@return A boolean value of EFalse if the scheme is SIP.	For all other schemes returns ETrue.

  */

 TBool IsNetworkScheme(const TDesC8& aScheme)

 	{

 	TUriSchemeType scheme = SchemeType(aScheme);

 	if (scheme == ESchemeTypeSip)

 		{

 		return EFalse;

 		}

 	return ETrue;

 	}

 /**

 	@internalComponent

 	Checks whether the given scheme is a network scheme or not

 	@param aScheme The descriptor with the scheme.

 	@return A boolean value of EFalse if the scheme is SIP.	For all other schemes returns ETrue.

  */

 TBool IsNetworkScheme(const TDesC16& aScheme)

 	{

 	TUriSchemeType scheme = SchemeType(aScheme);

 	if (scheme == ESchemeTypeSip)

 		{

 		return EFalse;

 		}

 	return ETrue;

 	}

 /**

 	@internalComponent

 	Returns the type of the URIs scheme

 	@param			aScheme	The descriptor with the scheme.

 	@return			The scheme type

  */

 TUriSchemeType SchemeType(const TDesC8& aScheme)

 	{

 	// Compares the scheme with both sip and sips

 	if (aScheme.CompareF(KSipScheme8()) == 0 || aScheme.CompareF(KSipsScheme8()) == 0)

 		{

 		// there's a match so this is a sip scheme

 		return ESchemeTypeSip;

 		}

 	//Compares the scheme with tel 

 	else if (aScheme.CompareF(KTelScheme8()) == 0) 

 		{

 		return ESchemeTypeTel;

 		} 

 	return ESchemeTypeUnknown;

 	}

 /**

 	@internalComponent

 	Returns the type of the URIs scheme

 	@param			aScheme	The descriptor with the scheme.

 	@return			The scheme type

  */

 TUriSchemeType SchemeType(const TDesC16& aScheme)

 	{

 	// Compares the scheme with both sip and sips

 	if (aScheme.CompareF(KSipScheme()) == 0 || aScheme.CompareF(KSipsScheme()) == 0)

 		{

 		// there's a match so this is a sip scheme

 		return ESchemeTypeSip;

 		}

 	return ESchemeTypeUnknown;

 	}

 /**

 	@internalComponent

 	Checks that a text host is in a valid form

 	@param			aHost	The descriptor containing the host to check

 	@return			ETrue if the host is valid otherwise EFalse

  */

 TBool IsTextHostValid(const TDesC8& aHost)

 	{

 	return CheckValidTextHost(aHost);

 	}

 /**

 	@internalComponent

 	Checks that a text host is in a valid form

 	@param			aHost	The descriptor containing the host to check

 	@return			ETrue if the host is valid otherwise EFalse

  */

 TBool IsTextHostValid(const TDesC16& aHost)

 	{

 	return CheckValidTextHost(aHost);

 	}

 /**

 	@internalComponent

 	Parses a segment of the form name=value and returns the name and value parts

 	@param			aSegment	the name-value segemnt to parse

 	@param			aName		the name part that is returned

 	@param			aValue		the value part that is returned

  */

 void GetNameValuePair(const TDesC8& aSegment, TPtrC8& aName, TPtrC8& aValue)

 	{

 	TPtrC8 value;

 	TInt sepPos = aSegment.Locate(KEqualsSeparator);

 	if (sepPos != KErrNotFound)

 		{

 		aName.Set(aSegment.Left(sepPos));

 		value.Set(aSegment.Mid(sepPos+1));

 		}

 	else

 		{

 		aName.Set(aSegment);

 		}

 	aValue.Set(value);

 	}

 //

 //

 // Implementation of LOCAL functions

 //

 //

 /**

 	Checks the descriptor for any excluded characters. These are characters that 

 	should have been escaped encoded or ocnverted to Utf8 from Unicode.

 	@since			6.0

 	@param			aData	The descriptor to be checked.

 	@return		A boolean value of ETrue if the descriptor contains excluded

 				characters, EFalse if it does not.

  */

 template<class TDesCType>

 LOCAL_C TBool CheckForExcludedChars(const TDesCType& aData)

 	{

 	// Run through the descriptor

 	TBool valid = ETrue;

 	const TInt length = aData.Length();

 	TInt i=0;

 	while( valid && i<length )

 		{

 		TInt notUsed;

 		// See if the character is an excluded one, or is part of an escape triple...

 		if( EscapeUtils::IsExcludedChar(aData[i]) && !EscapeUtils::IsEscapeTriple(aData.Mid(i), notUsed) )

 			{

 			valid = EFalse;

 			}

 		else

 			{

 			++i;

 			}

 		}

 	return !valid;

 	}

 /**

 	Checks the supplied host for an IPv4, IPv6 or text format host

 	@since			7.0

 	@param			aHost	The descriptor containing the host to check

 	@return			A TUriHostType enum of either EIPv6, EIPv4, EText or EUnknown

  */

 template<class TDesCType>

 LOCAL_C UriUtils::TUriHostType CheckHostType(const TDesCType& aHost)

 	{

 	UriUtils::TUriHostType hostType;

 	TInt dotCount=0;

 	TBool colonPresent=EFalse;

 	TBool numeric=ETrue;

 	TInt len = aHost.Length();

 	for (TInt ii=0; ii < len && !colonPresent; ++ii)

 		{

 		TChar ch(aHost[ii]);

 		// host contains a character that is not '0'..'9' or '.'

 		if ((ch < 48 || ch > 57) && ch != 46)

 			numeric=EFalse;

 		// need to check that IPv4 address has the 3 dots

 		if (ch == 46)

 			++dotCount;

 		else

 			if (ch == 58)

 				colonPresent=ETrue;

 		}

 	if (colonPresent) // if theres a colon, it has to be an IPv6 address

 		hostType = UriUtils::EIPv6Host;

 	else

 		if (numeric  && (dotCount==3)) // if its numeric only, and has three seperators...

 			hostType = UriUtils::EIPv4Host;

 		else

 			hostType = UriUtils::ETextHost;

 	return hostType;

 	}

 /**

 	@internalComponent

 	Checks that a text host is in a valid form

 	@param			aHost	The descriptor containing the host to check

 	@return			ETrue if the host is valid otherwise EFalse

  */

 template<class TDesCType>

 LOCAL_C TBool CheckValidTextHost(const TDesCType& aHost)

 	{

 	TInt len = aHost.Length();

 	if (len == 0)

 		return EFalse;

 	// host name can't start with a dot or dash

 	TChar firstChar(aHost[0]);

 	if (firstChar == '-' || firstChar == '.')

 		return EFalse;

 	TChar prev = '\0';

 	TInt ii;

 	for (ii=0; ii < len; ii++)

 		{

 		TChar ch(aHost[ii]);

 		// Valid characters are a-z, 0-9, '-' and '.'

 		if ((ch < 'A' || ch > 'Z') && (ch < 'a' || ch > 'z') && (ch < '0' || ch > '9') && ch != '-' && ch != '.')

 			{

 			return EFalse;

 			}

 		// dot is the section separator. Check the previous section is not empty

 		if (ch == '.' && prev == '.')

 			{

 			// can't have an empty section

 			return EFalse;

 			}

 			prev = ch;

 		}

 	// host name can't end with a dot or dash

 	if (prev == '-' || prev == '.')

 		return EFalse;

 	return ETrue;

 	}

 /**

 	Supports Syntax-Based Normalization as specifed in section 6.2.2 of RFC3986.

 	returns a new CUri8 object containing a normalised URI from a parsed URI object.

 	@param aUri	A reference to a parsed uri object.

 	@return A pointer to a CUri8 object containing normalised URI.

 	@leave KErrNoMemory

 	@internalAll

  */

 EXPORT_C CUri8* UriUtils:: NormaliseUriL(const TUriC8& aUri)	

 	{

 	CUri8* normalisedUri = CUri8::NewLC(aUri);

 	PercentEncodeL(normalisedUri); 

 	CaseNormaliseL(normalisedUri);

 	RemoveDotSegmentsL(normalisedUri);

 	CleanupStack::Pop(normalisedUri);

 	return normalisedUri;

 	}

 /**

 	Performs Case Normalization for CUri8 object as specified 

 	in section 6.2.2.1 of RFC3986.

 	@param aNormalisedUri It is an in-out parameter. aNormalisedUri is a pointer 

 	to CUri8 object with an uri needs to be case normalised and returns with 

 	case normalised.

 	@leave KErrNoMemory

  */

 void CaseNormaliseL(CUri8* aNormalisedUri )	

 	{

 	//Case normalise the scheme

 	DoCaseNormaliseL(aNormalisedUri, EUriScheme);	

 	//Case normalise the Userinfo

 	DoCaseNormaliseL(aNormalisedUri, EUriUserinfo);	

 	//Case normalise the Host

 	DoCaseNormaliseL(aNormalisedUri, EUriHost);	

 	//Case normalise the Port

 	DoCaseNormaliseL(aNormalisedUri, EUriPort);	

 	//Case normalise the Path

 	DoCaseNormaliseL(aNormalisedUri, EUriPath);	

 	//Case normalise the Query

 	DoCaseNormaliseL(aNormalisedUri, EUriQuery);	

 	//Case normalise the Fragment

 	DoCaseNormaliseL(aNormalisedUri, EUriFragment);	

 	}

 /**

 	Performs Case Normalization for specified sub component of URI.

 	@param aNormalisedUri It is an in-out parameter. aNormalisedUri is a pointer 

 	to CUri8 object with an uri needs to be case normalised and returns with 

 	case normalised for specified sub component.

 	@param aComponent Enumeration of TUriComponent.

 	@leave KErrNoMemory

 */

 void DoCaseNormaliseL(CUri8* aNormalisedUri, TUriComponent aComponent)

 	{

 	const TUriC8& uri(aNormalisedUri->Uri());

 	if(!uri.IsPresent(aComponent) )

 		{

 		return;

 		}

 	//extracts subcomponent of uri which needs to be case-normalised

 	HBufC8* heapBuf = uri.Extract(aComponent).AllocLC(); 	

 	TPtr8 normalisedComponent(heapBuf->Des());

 	TBool normalised = EFalse;

 	if(aComponent == EUriScheme || aComponent == EUriHost )

 		{

 		//change this component to lower case

 		normalisedComponent.LowerCase();

 		normalised = ETrue;

 		}

 	TInt len =  normalisedComponent.Length();

 	TBuf8<KSubstringLength> subString;

 	//case normalise the component

 	for (TInt pos = 0; pos < len; pos++)

 		{

 		if (normalisedComponent[pos] == KEscapeIndicator )

 			{

 			__ASSERT_DEBUG( ((len-pos) >= KSubstringLength), User::Panic(KNormalisationUriPanicCategory, KUriUtilsErrBadEscapeTriple) );

 			TPtrC8 componentBuf(normalisedComponent.Mid(pos,KSubstringLength));

 			if (ValidateAndConvertPercentEncodedTriple(componentBuf,subString))

 				{

 				normalisedComponent.Replace(pos,KSubstringLength,subString);

 				pos += KUpdateLength;

 				normalised = ETrue;

 				subString.Zero();

 				}

 			}

 		}

 	//updating the uri with normalised string

 	if( normalised )

 		{

 		if(aComponent<EUriMaxComponents && aComponent >=EUriScheme)

 		   {

 		   aNormalisedUri->SetComponentL(normalisedComponent, aComponent);

 		   }

 		else

 		   {

 			User::Leave(KErrArgument);	

 		   }

 		}

 	CleanupStack::PopAndDestroy(heapBuf);

 	}

 /**

 	Validates and Converts the valid Percent encoded triplets to Uppercase for specified 

 	sub component of URI. For eg: Converts %3a to %3A

 	@param aData A reference to a string to be validated and converted to upper case.

 	@param aCaseNormalizedData A reference to a descriptor that is converted to 

 	uppercase that is to be returned.

 	@return returns a bool whether it is a valid Percent encoded triplet

 */

 TBool ValidateAndConvertPercentEncodedTriple(TDesC8& aData , TDes8& aCaseNormalizedData )	

 	{

 	// See if the descriptor is actually long enough and

 	// Check that the three characters form an escape triple - first char is '%'

 	if( aData.Length() < KEscapeTripleLength || aData[KEscDelimiterPos] != KEscapeIndicator )

 		{

 		return EFalse;//do nothing

 		}

 	// Check that next two characters are valid

 	TInt mostSignificantDigitValue = KHexDigit().LocateF(aData[KMostSignificantNibblePos] );

 	TInt leastSignificantDigitValue = KHexDigit().LocateF(aData[KLeastSignificantNibblePos] );

 	if( mostSignificantDigitValue== KErrNotFound || leastSignificantDigitValue == KErrNotFound )

 		{

 		// Either of the characters were not a valid hex character

 		return EFalse;

 		}

 	aCaseNormalizedData.Zero();

 	aCaseNormalizedData.Append(KEscapeIndicator); 

 	//Coverts most significant hex character to uppercase

 	(mostSignificantDigitValue >= 0 && mostSignificantDigitValue <= 0xF) ? 

 		aCaseNormalizedData.Append(KHexDigit().Mid(mostSignificantDigitValue,1)) :

 		aCaseNormalizedData.Append(KHexDigit().Mid(mostSignificantDigitValue,1));

 	//Coverts least significant hex character to uppercase

 	(leastSignificantDigitValue >= 0 && leastSignificantDigitValue <= 0xF) ? 

 		aCaseNormalizedData.Append(KHexDigit().Mid(leastSignificantDigitValue,1)) :

 		aCaseNormalizedData.Append(aData[KLeastSignificantNibblePos]);

 	return ETrue;

 	}

 /**

 	Performs Percent-Encoding Normalization for CUri8 object as specifed in 

 	section 6.2.2.2 of RFC3986.

 	@param aNormalisedUri It is an in-out parameter. aNormalisedUri is a pointer to 

 	CUri8 object with an uri needs to be Percent-Encoded and returns with Percent-Encode 

 	normalised form.

 	@leave KErrNoMemory

  */

 void  PercentEncodeL(CUri8* aNormalisedUri)

 	{

 	//PercentEncode the scheme

 	DoPercentEncodeL(aNormalisedUri, EUriScheme);	

 	//PercentEncode the Userinfo

 	DoPercentEncodeL(aNormalisedUri, EUriUserinfo);	

 	//PercentEncode the Host

 	DoPercentEncodeL(aNormalisedUri, EUriHost);	

 	//PercentEncode the Port

 	DoPercentEncodeL(aNormalisedUri, EUriPort);	

 	//PercentEncode the Path

 	DoPercentEncodeL(aNormalisedUri, EUriPath);	

 	//PercentEncode the Query

 	DoPercentEncodeL(aNormalisedUri, EUriQuery);	

 	//PercentEncode the Fragment

 	DoPercentEncodeL(aNormalisedUri, EUriFragment);	

 	}

 /**

 	Performs Percent-Encoding for specified sub component of URI.

 	@param aNormalisedUri It is an in-out parameter. aNormalisedUri is a pointer to 

 	CUri8 object with an uri needs to be Percent-Encoded and returns with Percent-Encoded 

 	for specified sub component.

 	@param aComponent Enumeration of TUriComponent.

 	@leave KErrNoMemory

 */

 void DoPercentEncodeL(CUri8* aNormalisedUri, TUriComponent aComponent)

 	{

 	const TUriC8& uri(aNormalisedUri->Uri());

 	if(!uri.IsPresent(aComponent))

 		{

 		return;

 		}

 	HBufC8* heapBuf = uri.Extract(aComponent).AllocLC();

 	TPtr8 percentNormalisedComponent(heapBuf->Des());

 	TBool normalised = EFalse;

 	TInt len = percentNormalisedComponent.Length();	

 	for (TInt pos = 0; pos < len; pos++)

 		{

 		TInt hex;

 		// check for and decode '%' encoded characters

 		if (percentNormalisedComponent[pos] == KEscapeIndicator && EscapeUtils::IsEscapeTriple(percentNormalisedComponent.Mid(pos, KSubstringLength), hex))

 			{

 			TChar replacedChar(hex);

 			if( KUnreserved().LocateF(hex) != KErrNotFound || replacedChar.IsAlphaDigit() )

 				{

 				TBuf8<KAttachLength> subString;

 				subString.Append(replacedChar);

 				percentNormalisedComponent.Replace(pos, KSubstringLength, subString);

 				normalised = ETrue;

 				len = percentNormalisedComponent.Length();

 				}

 			}

 		}

 	if( normalised )

 		{

 		if(aComponent<EUriMaxComponents && aComponent >=EUriScheme)

 		   {

 		    aNormalisedUri->SetComponentL(percentNormalisedComponent, aComponent);

 		   }

 		else

 		   {

 			User::Leave(KErrArgument);	

 		   }

 		}

 	CleanupStack::PopAndDestroy(heapBuf); 	

 	}

 /**

 	Performs Path Segment Normalization for CUri8 object as specifed in 

 	section 6.2.2.3 of RFC3986.

 	@param aNormalisedUri It is an in-out parameter. aNormalisedUri is a pointer to 

 	CUri8 object with uri needs to be Path Segment normalised and returns with 

 	Path Segment normalised form.

 	@leave KErrNoMemory

  */

 void  RemoveDotSegmentsL(CUri8* aNormalisedUri)

 	{

 	const TUriC8& uri( aNormalisedUri->Uri() );

 	if(uri.IsPresent(EUriPath))

 		{

 		HBufC8* dotSegmentsPath = uri.Extract(EUriPath).AllocLC();

 		RemoveExtraneousDotSegmentsL(dotSegmentsPath);

 		aNormalisedUri->SetComponentL(*dotSegmentsPath, EUriPath);	

 		CleanupStack::PopAndDestroy(dotSegmentsPath);	

 		}

 	}

 /**

 	Performs Remove_dot_segments algorithm as specifed in section 5.2.4 of RFC3986.

 	@param aUriInputPath It is an in-out parameter. aUriInputPath is a pointer to the 

 	path descriptor to be normalised for extraneous dot_segments and returns with 

 	normalised dot_segments.

 	@leave KErrNoMemory

 */

 void RemoveExtraneousDotSegmentsL(HBufC8* aUriInputPath)

 	{

 	TPtr8 uriPathBuf(aUriInputPath->Des());

 	TInt length = uriPathBuf.Length();	

 	HBufC8* path = HBufC8::NewLC(length);

 	TPtr8 transitionalBuf(path->Des());

 	while(length > 0)	

 		{

 		//step a of section 5.2.4 of RFC 3986

 		if(length >= KDotDotSlashLength && 

 			KDotDotSlash().Compare(uriPathBuf.Mid(0, KDotDotSlashLength)) == 0 )

 			{

 			uriPathBuf.Delete(0,KDotDotSlashLength);

 			}

 		//step a of section 5.2.4 of RFC 3986

 		else if(length >= KDotDotLength && 

 				KDotSlash().Compare(uriPathBuf.Mid(0, KDotDotLength)) == 0)

 			{

 			uriPathBuf.Delete(0,KDotDotLength);	

 			}

 		//step b of section 5.2.4 of RFC 3986

 		else if(length >= KDotDotSlashLength && 

 				KSlashDotSlash().Compare(uriPathBuf.Mid(0, KDotDotSlashLength)) == 0)

 			{

 			uriPathBuf.Replace(0, KDotDotSlashLength, KSlash);

 			}

 		//step c of section 5.2.4 of RFC 3986

 		else if(length >= KSlashDotDotSlashLength && 

 				KSlashDotDotSlash().Compare(uriPathBuf.Mid(0, KSlashDotDotSlashLength)) == 0)

 			{

 			updateStrings(uriPathBuf, transitionalBuf, KSlashDotDotSlashLength);

 			}

 		//step c of section 5.2.4 of RFC 3986 --complete path segment

 		else if(length == KDotDotSlashLength && 

 				KSlashDotDot().Compare(uriPathBuf.Mid(0, KDotDotSlashLength)) == 0)

 			{

 			updateStrings(uriPathBuf, transitionalBuf, KDotDotSlashLength);

 			}

 		//step b of section 5.2.4 of RFC 3986--complete path segment

 		else if(length == KDotDotLength && 

 				KSlashDot().Compare(uriPathBuf.Mid(0, KDotDotLength)) == 0)

 			{

 			uriPathBuf.Replace(0, KDotDotLength, KSlash);

 			}

 		//step d of section 5.2.4 of RFC 3986

 		else if(length == KDotDotLength && 

 				KDotDot().Compare(uriPathBuf.Mid(0)) == 0)

 			{

 			uriPathBuf.Delete(0,KDotDotLength);	

 			}

 		//step d of section 5.2.4 of RFC 3986

 		else if(length == KDotLength && 

 				KDot().Compare(uriPathBuf.Mid(0)) == 0)

 			{

 			uriPathBuf.Delete(0,KDotLength);	

 			}

 		//step e of section 5.2.4 of RFC 3986

 		else 

 			{

 			//get the first path segment including initial / (if any)from uriPathBuf

 			// till next slash (but not including next slash)..append it to the output Buf	

 			TInt substrLength;

 			TInt nextSlashPos = uriPathBuf.Find(KSlash);

 			if(nextSlashPos == 0 && length > KDotLength)

 				//replace with locate next

 				{

 				nextSlashPos = uriPathBuf.Mid(1).Find(KSlash);

 				if(nextSlashPos != KErrNotFound)

 					{

 					++nextSlashPos;

 					}

 				}

 			if(length == KDotLength)

 				//only '/' is exist

 				{

 				substrLength = length;	

 				}

 			else

 				{

 				substrLength = nextSlashPos == KErrNotFound ? length : nextSlashPos ;	

 				}

 			transitionalBuf.Append(uriPathBuf.Mid(0,substrLength));

 			uriPathBuf.Delete(0,substrLength);	

 			}

 		length = uriPathBuf.Length();

 		}

 	uriPathBuf.Copy(transitionalBuf);

 	CleanupStack::PopAndDestroy(path);

 	}

 /**

 	Updates the strings specified in step c of section 5.2.4 of RFC 3986

 	@param aInputBuf A reference to the inputBuf needs to be modified 

 	@param aOutPutBuf A reference to the outPutBuf needs to be modified

 	@param aLength length of the string to be replaced.

  */

 void  updateStrings(TPtr8& aInputBuf, TPtr8& aOutPutBuf, TInt aLength)

 	{

 	aInputBuf.Replace(0,aLength,KSlash);

 	//In outPutBuf to remove the last segment starting with / (if exist)

 	//eg: /abc/def/fgh --> /abc/def

 	TInt outputBufLength = aOutPutBuf.Length();

 	TInt pos = aOutPutBuf.LocateReverse('/');	

 	//remove the last segment including '/'

 	pos != KErrNotFound ? aOutPutBuf.Delete( pos, outputBufLength - pos ) : aOutPutBuf.Delete( 0,outputBufLength );

 	}