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

// Purpose:		Definition of CUrl class - Url processor based on RFC2396.

// CUrl encapsulates a url and provides access to its components. On creation, the contents of 

// the url is in unescaped mode - excluded characters (as defined by RFC2396) have not been coded into their 

// escape triples. Two NewL() functions are provided. The first takes any descriptor and encapsulates it into

// the CUrl object, and leaves if the the url begins with a ':' (EWapErrCorruptUrl) or if the scheme is 

// 

//

//				corrupted (EWapErrCorruptScheme). The second NewL() creates a url with a file scheme (file://) from a 

//				TParseBase argument, and will leave if the url is invalid (EWapErrCorruptUrl). Two static functions have 

//				been provided that each take a descriptor argument which is then escape encoded/decoded.

//

//				NOTE - maintainer needs detailed knowledge of url parsing (RFC2396)

//

// System includes

//

#include <Utf.h>

// CUrl class signature

//

#include "urlbase.h"

// Static data used in this class

//

const TInt KCUrlInvalidCharPos		= -1;

const TInt KUrlConversionBufferSize = 50;

//	Constants 

_LIT(KHexDigit, "0123456789ABCDEF");

_LIT(KUnwiseData, "{}|\\^[]\'");

_LIT(KDelimsData, "<>#%\"");

_LIT(KReservedData, ";/?:@&=+$,");

_LIT(KReservedDataForPath, ";?@&=+$,");

//	Delimiters and scheme identifiers for urls

_LIT(KUrlPathDelimiter,"/");		

_LIT(KUrlFileSchemeSignature,"file://"); 

_LIT(KUrlLoc,"//");

_LIT(KUrlColon,":");

_LIT(KUrlQMark,"?");

_LIT(KUrlHash,"#");

// Implementation of CUrl

//

EXPORT_C CUrl* CUrl::NewL(const TDesC& aUrl)

//

//	Static factory c'tor.

	{

	CUrl* url = new(ELeave) CUrl();

	CleanupStack::PushL(url);

	url->ConstructL(aUrl);

	CleanupStack::Pop();

	return url;

	}

EXPORT_C CUrl* CUrl::NewL(const TParseBase& aFileName)

//

//	Static factory c'tor. Used for creating CUrl object for a file on local file system

	{

	CUrl* url = new(ELeave) CUrl();

	CleanupStack::PushL(url);

	url->ConstructL(aFileName);

	CleanupStack::Pop();

	return url;	

	}

CUrl::CUrl()

//

//	Default c'tor

	{

	}

EXPORT_C CUrl::~CUrl()

//

//	D'tor

	{

	delete iUrlDes;

	}

void CUrl::ConstructL(const TDesC& aUrl)

//

//	Non-trivial c'tor - can be used for all general urls

	{

	// Stripe any leading whitespace

	TPtrC url = aUrl;

	while( url.Locate(' ') == 0 )

		{

		// Remove the leading whitespace -> set pointer to second character

		url.Set(url.Mid(1));

		}

	iUrlDes = url.AllocL();

	// Check to see if there's ':' at start of aUrl

	TInt colonPos = aUrl.Locate(':');

	if (colonPos == 0)

		User::Leave(EWapErrCorruptUrl);

	TPtrC scheme(Component(EUrlScheme));

	CheckSchemeValidL(scheme);

	}

void CUrl::CheckSchemeValidL(const TDesC& aScheme) const

	{ // Check the scheme, leave if corrupt

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

		{

		TChar c = aScheme[i];

		TBool ok =  (c>='a' &&  c<='z') || (c>='A'  && c <='Z');

		if (!ok && i > 0)

			ok = (c>='0' && c<='9') || c == '+' || c == '-' || c == '.';

		if (!ok)

			User::Leave(EWapErrCorruptScheme);

		}

	}

void CUrl::ConstructL(const TParseBase& aFileName)

//

//	Non-trivial c'tor - used to create Urls for local file space only. NO scheme in aFileName

	{

	if( aFileName.IsWild() ) 

		User::Leave(EWapErrCorruptUrl);

	// Convert Unicode file name into UTF8 format

	HBufC8* utf8 = ConvertFromUnicodeToUtf8L(aFileName.FullName());

	CleanupStack::PushL(utf8);

	// Convert to 16-bit format

	HBufC* escapedFullPath = HBufC::NewLC(utf8->Length());

	escapedFullPath->Des().Copy(*utf8);

	// Need to escape encode all the components - start with filename, then path and last the drive

	TPtr fullPath = escapedFullPath->Des();

	if ( fullPath.Compare(KNullDesC) )

		{

		// Convert '\' to '/' then escape encode with EUrlPath - this doesn't encode '/' and ':'

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

			{

			if (fullPath[i] == KPathDelimiter)

				fullPath[i] = '/';

			}

		escapedFullPath = EscapeEncodeL(fullPath, EUrlPath);

		CleanupStack::PopAndDestroy();	// escapedFullPath (old version)

		CleanupStack::PushL(escapedFullPath);	// new version

		// Replace ':' with '|'

		fullPath.Set(escapedFullPath->Des());

		TInt colonPos = fullPath.Locate(KDriveDelimiter);

		if( colonPos != KErrNotFound )

			fullPath[colonPos] = '|';

		}

	// Form the url

	TInt size = KUrlFileSchemeSignature().Length() + KUrlPathDelimiter().Length() + fullPath.Length();

	iUrlDes = HBufC::NewL(size);

	iUrlDes->Des().Append(KUrlFileSchemeSignature());

	iUrlDes->Des().Append(KUrlPathDelimiter());

	iUrlDes->Des().Append(fullPath);

	CleanupStack::PopAndDestroy(2);	// escapedFullPath, utf8

	}

EXPORT_C CUrl* CUrl::ResolveL(CUrl& aBaseUrl, CUrl& aRelativeUrl)

//

//	Based on the relative parsing algorithm in RFC2396

	{

	//	Return copy of aRelativeUrl if aBaseUrl is empty

	if (aBaseUrl.UrlDes().Compare(KNullDesC)==0)

		return aRelativeUrl.AllocL();

	TPtrC relativeUrl(aRelativeUrl.UrlDes());

	TPtrC relPath(aRelativeUrl.Component(EUrlPath));

	TPtrC relAuth(aRelativeUrl.Component(EUrlAuthority));

	TPtrC relScheme(aRelativeUrl.Component(EUrlScheme));

	TPtrC relQuery(aRelativeUrl.Component(EUrlQuery));

	TPtrC relFragment(aRelativeUrl.Component(EUrlFragment));

	if (relScheme.Length() > 0)

		{

		// LOOPHOLE in RFC 1630 if schemes match then remove the scheme from the relative url

		if (aBaseUrl.UrlDes().FindF(relScheme) == 0)

			relativeUrl.Set(relativeUrl.Mid(relScheme.Length() + 1)); // remove the ':' as well

		else // the relative url is absolute

			return NewL(relativeUrl);

		}

	TBool useBaseAuth = ETrue;

	TBool useRelQuery = ETrue;

	TPtrC basePath(aBaseUrl.Component(EUrlPath));

	HBufC* resolvedPath = NULL;

	if (relPath.Compare(KNullDesC)==0 && relAuth.Compare(KNullDesC)==0 

		&& relScheme.Compare(KNullDesC)==0 && relQuery.Compare(KNullDesC)==0) // relative URL could just be a fragment

		{

		// Use current document url (assume that it is aBaseUrl), including query, then add relative URL fragment

		useRelQuery = EFalse;

		resolvedPath = basePath.AllocLC();

		}

	else if (relativeUrl.Find(KUrlLoc) == 0) // relative url is a network path

		{

		// Set resolved path to be the relative path

		useBaseAuth = EFalse;

		resolvedPath = relPath.AllocLC();

		}	

	else if (relPath.Locate('/') == 0) // relative url is an absolute path

		{

		resolvedPath = relPath.AllocLC();

		}

	else 

		{

		//	Do path resolution, merge the base path and relative path

		if (relPath.Length() != 0)

			// if the relative path is a query or fragment then shouldn't strip the document from the basePath

			{

			TInt endBasePath = basePath.LocateReverse('/');

			if (endBasePath != KErrNotFound)

				basePath.Set(basePath.Left(endBasePath + 1)); // keep the '/' 

			else

				basePath.Set(_L("/"));	//	Create path of just '/'

			}

		//	Resolve relative path against base path

		resolvedPath = HBufC::NewLC(relPath.Length() + basePath.Length());

		TRelativePaths relativePaths(basePath, relPath, resolvedPath->Des());

		relativePaths.ResolveRelativePaths();

		}

	// put the url together

	TPtrC baseScheme(aBaseUrl.Component(EUrlScheme));

	TPtrC baseAuth(aBaseUrl.Component(EUrlAuthority));

	TPtrC baseQuery(aBaseUrl.Component(EUrlQuery));

	HBufC* resolvedUrl = HBufC::NewLC(aBaseUrl.UrlDes().Length()  

										 + relativeUrl.Length()

										 + KUrlColon().Length() 

										 + KUrlLoc().Length()

										 + KUrlQMark().Length()

										 + KUrlHash().Length()

										 + 1); // this will be long enough - extra 1 just in case basePath was empty

	TPtr resolvedBuf = resolvedUrl->Des();

	if (baseScheme.Length() > 0)

		{

		resolvedBuf.Append(baseScheme);

		resolvedBuf.Append(KUrlColon);

		}

	resolvedBuf.Append(KUrlLoc);	

	if (useBaseAuth && baseAuth.Length() >0)

		{

		resolvedBuf.Append(baseAuth);

		}

	else if (relAuth.Length() > 0)

		{

		resolvedBuf.Append(relAuth);

		}

	resolvedBuf.Append(*resolvedPath);

	if (useRelQuery && relQuery.Length() >0)

		{

		resolvedBuf.Append(KUrlQMark);

		resolvedBuf.Append(relQuery);

		}

	else if (!useRelQuery && baseQuery.Length() >0)

		{

		resolvedBuf.Append(KUrlQMark);

		resolvedBuf.Append(baseQuery);

		}

	if (relFragment.Length() >0)

		{

		resolvedBuf.Append(KUrlHash);

		resolvedBuf.Append(relFragment);

		}

	CUrl * url = CUrl::NewL(*resolvedUrl);

	CleanupStack::PopAndDestroy(2); // resolvedUrl, resolvedPath

	return url;

	}

void CUrl::Panic(TPanicCode aPanicCode) const

	{

	_LIT(KWapCUrl,"Wap - CUrl");

	User::Panic(KWapCUrl, aPanicCode);

	}

void CUrl::Part(TComponent aComponent, const TDesC& aUrl, TInt& aStartPos, TInt& aEndPos) const

//

// Takes a descriptor as a url and parses it for the start and end positions of a particular component. 

// KCUrlInvalidCharPos is used to indicate that component is not in url.

// 

// Based on RFC2396

	{

	aStartPos = aEndPos = KCUrlInvalidCharPos;

	TPtrC url = aUrl;

	// search for first of ':' | '/' | '?' | '#'

	TInt stripped =0;

	TInt colonPos = aUrl.Locate(':');

	__ASSERT_ALWAYS(colonPos != 0,Panic(EInvalidUrl));		// if ':' is first character then it is invalid

	TInt hashPos = aUrl.Locate('#');

	TInt slashPos = aUrl.Locate('/');

	TInt queryPos = aUrl.Locate('?');

	colonPos = colonPos == KErrNotFound ? KMaxTInt : colonPos;

	hashPos = hashPos == KErrNotFound ? KMaxTInt : hashPos;

	slashPos = slashPos == KErrNotFound ? KMaxTInt : slashPos;

	queryPos = queryPos == KErrNotFound ? KMaxTInt : queryPos;

	// if ':' is before others then there is a scheme so extract it

	if (colonPos < hashPos && colonPos < slashPos && colonPos < queryPos)

		{

		if (aComponent == EUrlScheme)

			{

			aStartPos = stripped;

			aEndPos = colonPos -1;

			return;

			}

		if (url.Length() == colonPos + 1) // reached the end of the url

			return;	

		url.Set(url.Mid(colonPos+1));

		stripped += colonPos+1;

		hashPos -= colonPos+1;

		slashPos -= colonPos+1;

		queryPos -= colonPos+1;

		}

	// if first 2 characters are '//' then a host exists, 

	if (url.Find(KUrlLoc) == 0)

		{

		TInt urlLocLength = KUrlLoc().Length();

		if (url.Length() == urlLocLength) // reached the end of the url

			return;

		// extract '//' and rescan for '/'

		url.Set(url.Mid(urlLocLength));

		stripped += urlLocLength;

		hashPos -= urlLocLength;

		queryPos -= urlLocLength;

		slashPos = url.Locate('/');

		slashPos = slashPos == KErrNotFound ? KMaxTInt : slashPos;

		// host is ended by first of '#' | '?' | '/' | end of url

		TInt hostEndCharPos = slashPos;

		hostEndCharPos = hashPos < hostEndCharPos ? hashPos : hostEndCharPos;

		hostEndCharPos = queryPos < hostEndCharPos ? queryPos : hostEndCharPos;

		hostEndCharPos = url.Length() < hostEndCharPos ? url.Length() : hostEndCharPos;

		if (aComponent == EUrlAuthority)

			{

			aStartPos = stripped;

			aEndPos = hostEndCharPos+stripped-1;

			return;

			}

		if (aComponent == EUrlLocation ||

			aComponent == EUrlUsername ||

			aComponent == EUrlPassword)

			{

			aStartPos = stripped;

			aEndPos = hostEndCharPos+stripped-1;

			// We need part of the authority. Extract it

			PartOfAuthority(aComponent, aUrl, aStartPos, aEndPos);

			return;

			}

		//	Have we reached the end of the url

		if (url.Length() == hostEndCharPos)

			return; 

		// extract host	

		url.Set(url.Mid(hostEndCharPos));

		stripped += hostEndCharPos;

		slashPos -= hostEndCharPos;

		hashPos -= hostEndCharPos;

		queryPos -= hostEndCharPos;		

		}

	//	If first character is '/' | this is the start of a relative url | there is no authority then path exists

	//	as long as it isn't just a query or fragment

	if ((slashPos == 0 || stripped == 0 || stripped == colonPos +1 ) && hashPos != 0 && queryPos !=0)

		{ 

		TInt pathEndCharPos = queryPos;

		pathEndCharPos = hashPos < pathEndCharPos ? hashPos : pathEndCharPos;

		pathEndCharPos = url.Length() < pathEndCharPos ? url.Length() : pathEndCharPos;

		if (aComponent == EUrlPath)

			{

			aStartPos = stripped;

			aEndPos = pathEndCharPos+stripped-1;

			return;

			}

		if (url.Length() == pathEndCharPos) // reached the end of the url

			return;

		//	extractPath

		url.Set(url.Mid(pathEndCharPos));

		stripped += pathEndCharPos ;

		queryPos -= pathEndCharPos ;

		hashPos -= pathEndCharPos ;

		}

	// if first is '?' then query exists

	if (queryPos == 0) 	

		{

		// extract ?, query is ended by '#' | end of url

		if (url.Length() == 1)	// reached the end of the url

			return;

		url.Set(url.Mid(1));

		stripped += 1;

		hashPos -= 1;

		// extract query

		TInt queryEndCharPos = hashPos;

		queryEndCharPos = url.Length() < queryEndCharPos ? url.Length() : queryEndCharPos;

		if (aComponent == EUrlQuery)

			{

			aStartPos = stripped;

			aEndPos = queryEndCharPos+stripped-1;

			return;

			}

		if (url.Length() == queryEndCharPos) // reached the end of the url

			return;

		url.Set(url.Mid(queryEndCharPos));

		stripped += queryEndCharPos;

		hashPos -= queryEndCharPos;

		}

	if (hashPos == 0)

		{

		if (url.Length() == 1)	// reached the end of the url

			return;

		// extract hash

		url.Set(url.Mid(1));

		stripped += 1;

		// fragment left

		if (aComponent == EUrlFragment)

			{

			aStartPos = stripped;

			aEndPos = stripped + url.Length() -1;

			return;

			}

		}

	__ASSERT_DEBUG(	aStartPos == aEndPos && aEndPos == KCUrlInvalidCharPos, Panic(EInvalidUrl));

	}

void CUrl::PartOfAuthority(TComponent aComponent, const TDesC& aUrl, TInt& aStartPos, TInt& aEndPos) const

	{

	if (aEndPos < aStartPos)

		{

		// We don't have what the user asked for

		aStartPos = KCUrlInvalidCharPos;

		aEndPos = KCUrlInvalidCharPos;

		return;

		}

	TPtrC authority = aUrl.Mid(aStartPos, aEndPos - aStartPos);

	TInt endPos = aEndPos - aStartPos;

	TInt colonPos = authority.Locate(':');

	TInt atPos = authority.Locate('@');

	if (atPos == KErrNotFound)

		{

		// There isn't a username or password.

		if (aComponent != EUrlLocation)

			{

			// We don't have what the user asked for

			aStartPos = KCUrlInvalidCharPos;

			aEndPos = KCUrlInvalidCharPos;

			}

		// Else all we've got is the location, so we can return

		// without doing anything

		return;

		}

	// We have an @.

	if (aComponent == EUrlLocation)

		{

		if (atPos != endPos - 1)

			{

			// We have a location of non-zero length

			aStartPos += atPos + 1;

			return;

			}

		else

			{

			aStartPos = KCUrlInvalidCharPos;

			aEndPos = KCUrlInvalidCharPos;			

			}

		}

	else

		{

		// Either username or password

		if (aComponent == EUrlUsername)

			{

			if (colonPos == KErrNotFound || colonPos > atPos)

				{

				// No password

				aEndPos = aStartPos + atPos - 1;

				return;

				}

			else

				{

				aEndPos = aStartPos + colonPos - 1;

				return;

				}

			}

		else

			{

			// They want the password

			if (colonPos == KErrNotFound || colonPos > atPos)

				{

				// There isn't a password

				aStartPos = KCUrlInvalidCharPos;

				aEndPos = KCUrlInvalidCharPos;

				}

			else

				{