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