// 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 "inetprottextutils.h"

#include "inetprottextutilslocal.h"

#include <uriutilscommon.h>

// Panic category

//

#ifdef _DEBUG

	_LIT(KTextUtilsPanicCategory, "IPTXTUTL"); 

#endif

const TUint KZeroChar		= '0';

const TUint KAChar			= 'A';

const TUint	KQuote			= '"';

const TUint KMinusSign		= '-';

const TInt KMaxTIntDecimalDigits = 11; // KMaxTInt  => "-2147483648" 

const TInt KMaxTIntDividedByTen = KMaxTInt/10;

#define KHorizTab 0x09

#define KSpace 0x20

#define KZero 0x30

#define KNine 0x39

#define KDecimal 0x2E

const TInt KMaxNumberSize	= 32;	// includes '-' sign

/**

	Removes any contiguous whitespace at the extremes of the data, as specified

	by aMode. Whitespace is defined by the functions TChar::IsSpace() - white

	space includes spaces, tabs, and separators (e.g. new line).

	@param			aData	A descriptor pointer with the data.

	@param			aMode	The specified removal mode.

	@return			The number of consumed whitespace characters. If the data is

	empty or the data is all whitespace the error code KUriUtilsErrEmptyData is

	returned.

*/

EXPORT_C TInt InetProtTextUtils::RemoveWhiteSpace(TPtrC8& aData, TRemoveMode aMode)

	{

	TInt consumed = DoRemoveWhiteSpace(aData, aMode);

	if( consumed == KUriUtilsErrEmptyData )

		{

		// Either empty data or all whitespace

		aData.Set(KNullDesC8());

		}

	return consumed;

	}

/**

	Removes any contiguous whitespace at the extremes of the data, as specified

	by aMode. Whitespace is defined by the functions TChar::IsSpace() - white

	space includes spaces, tabs, and separators (e.g. new line).

	@param			aData	A descriptor pointer with the data.

	@param			aMode	The specified removal mode.

	@return			The number of consumed whitespace characters. If the data is

	empty or the data is all whitespace the error code KUriUtilsErrEmptyData is

	returned.

*/

EXPORT_C TInt InetProtTextUtils::RemoveWhiteSpace(TPtrC16& aData, TRemoveMode aMode)

	{

	TInt consumed = DoRemoveWhiteSpace(aData, aMode);

	if( consumed == KUriUtilsErrEmptyData )

		{

		// Either empty data or all whitespace

		aData.Set(KNullDesC16());

		}

	return consumed;

	}

/**

	Converts an integer value into its decimal character representation.

	@param			aInt		An integer value.	

	@param			aBuffer		An output argument of a pointer to a data buffer

	that will contain the character representation of the integer value.

*/

EXPORT_C void InetProtTextUtils::ConvertIntToDescriptorL(TInt aInt, HBufC8*& aBuffer)

	{

	DoConvertIntToDescriptorL(aInt, aBuffer, EDecimal);

	}

/**

	Converts an integer value into its decimal character representation.

	@param			aInt		An integer value.	

	@param			aBuffer		An output argument of a pointer to a data buffer

	that will contain the character representation of the integer value.

*/

EXPORT_C void InetProtTextUtils::ConvertIntToDescriptorL(TInt aInt, HBufC16*& aBuffer)

	{

	DoConvertIntToDescriptorL(aInt, aBuffer, EDecimal);

	}

/**

	Converts the character representation of an integer into its numeric value.

	Preceeding whitespace is ignored and the integer is delimited by either the

	end of the data, whitespace or any other character other than 0 to 9.

	@param			aData	A descriptor pointer with the data.

	@param			aInt	An output argument in which the numeric value of the

	data is placed.

	@return			The number of consumed characters that contributed to the 

					integer value, including any whitespace before the integer. 

					If the data is empty the error code KUriUtilsErrEmptyData 

					is returned. If there are no digits at the beginning of the

					data the error code KUriUtilsErrNoIntergerInData is returned.

*/

EXPORT_C TInt InetProtTextUtils::ConvertDescriptorToInt(const TDesC8& aData, TInt& aInt)

	{

	// Do conversion and return number of consumed characters

	return DoConvertDescriptorToInt(TPtrC8(aData), aInt, EDecimal);

	}

/**

	Converts the character representation of an integer into its numeric value.

	Preceeding whitespace is ignored and the integer is delimited by either the

	end of the data, whitespace or any other character other than 0 to 9.

	@param			aData	A descriptor pointer with the data.

	@param			aInt	An output argument in which the numeric value of the

	data is placed.

	@return			The number of consumed characters that contributed to the 

					integer value, including any whitespace before the integer.

					If the data is empty the error code KUriUtilsErrEmptyData is

					returned. If there are no digits at the beginning of the data

					the error code KUriUtilsErrNoIntergerInData is returned.

*/

EXPORT_C TInt InetProtTextUtils::ConvertDescriptorToInt(const TDesC16& aData, TInt& aInt)

	{

	// Do conversion and return number of consumed characters

	return DoConvertDescriptorToInt(TPtrC16(aData), aInt, EDecimal);

	}

/**

	@internalComponent

	Converts an integer to its hex representation.

	@param		aHex	The integer value to convert.

	@param		aBuffer	An output argument that is set to the buffer containing 

						the hex representation of aValue.

	@panic		EInvariantFalse	The integer value was too big.

*/

EXPORT_C void InetProtTextUtils::ConvertHexToDescriptorL(TInt aHex, HBufC8*& aBuffer)

	{

	DoConvertIntToDescriptorL(aHex, aBuffer, EHex);

	}

/**

	@internalComponent

	Converts an integer to its hex representation.

	@param		aHex	The integer value to convert.

	@param		aBuffer	An output argument that is set to the buffer containing 

						the hex representation of aValue.

	@panic		EInvariantFalse	The integer value was too big.

*/

EXPORT_C void InetProtTextUtils::ConvertHexToDescriptorL(TInt aHex, HBufC16*& aBuffer)

	{

	DoConvertIntToDescriptorL(aHex, aBuffer, EHex);

	}

/**

	@internalComponent

	Descriptor to hex convertor. Searches the descriptor buffer for a hex number

	representation at the start of the buffer. The hex number is deemed to have 

	ended when the first non-hex character is found. The numeric value of the 

	hex number is returned along with the number characters consumed in obtaining

	the number. The amount of leading whitespace is included in the number of 

	characters consumed.

	@param		aData	The descriptor buffer to be parsed.

	@param		aHex	An output argument set to the numeric value of the 

						parsed hex number.

	@return		The number of characters consumed in parsing the hex number. If 

				the descriptor was empty then KUriUtilsErrEmptyData is returned.

				If no hex number was parsed then KUriUtilsErrNoIntergerInData is

				returned.

*/

EXPORT_C TInt InetProtTextUtils::ConvertDescriptorToHex(const TDesC8& aData, TInt& aHex)

	{

	// Do conversion, returning the number of consumed characters

	return DoConvertDescriptorToInt(TPtrC8(aData), aHex, EHex);

	}

/**

	@internalComponent

	Descriptor to hex convertor. Searches the descriptor buffer for a hex number

	representation at the start of the buffer. The hex number is deemed to have 

	ended when the first non-hex character is found. The numeric value of the 

	hex number is returned along with the number characters consumed in obtaining

	the number. The amount of leading whitespace is included in the number of 

	characters consumed.

	@param		aData	The descriptor buffer to be parsed.

	@param		aHex	An output argument set to the numeric value of the 

						parsed hex number.

	@return		The number of characters consumed in parsing the hex number. If 

				the descriptor was empty then KUriUtilsErrEmptyData is returned.

				If no hex number was parsed then KUriUtilsErrNoIntergerInData is

				returned.

*/

EXPORT_C TInt InetProtTextUtils::ConvertDescriptorToHex(const TDesC16& aData, TInt& aHex)

	{

	// Do conversion, returning the number of consumed characters

	return DoConvertDescriptorToInt(TPtrC16(aData), aHex, EHex);

	}

/** 

	Extract a token from the head of the supplied buffer, which is assumed to be

	a token-list. The tokens are separated by the specified character. Any white

	space surrounding the token is stripped out.  The number of characters 

	consumed from the buffer are returned. The buffer is updated to not include

	the extracted token including the separator.

	@param			aBuffer		The buffer containing the token-list.

	@param			aToken		An output argument containing the extracted token.

	@param			aSeparator	The separator character.

	@return			The number of characters consumed from the buffer.

*/

EXPORT_C TInt InetProtTextUtils::ExtractNextTokenFromList(TPtrC8& aBuffer, TPtrC8& aToken, TChar aSeparator)

	{

	return DoExtractNextTokenFromList(aBuffer, aToken, aSeparator);

	}

/** 

	Extract a token from the head of the supplied buffer, which is assumed to be

	a token-list. The tokens are separated by the specified character. Any white

	space surrounding the token is stripped out.  The number of characters 

	consumed from the buffer are returned. The buffer is updated to not include

	the extracted token including the separator.

	@param			aBuffer		The buffer containing the token-list.

	@param			aToken		An output argument containing the extracted token.

	@param			aSeparator	The separator character.

	@return			The number of characters consumed from the buffer.

*/

EXPORT_C TInt InetProtTextUtils::ExtractNextTokenFromList(TPtrC16& aBuffer, TPtrC16& aToken, TChar aSeparator)

	{

	return DoExtractNextTokenFromList(aBuffer, aToken, aSeparator);

	}

/** 

	Extract a token from the head of the supplied buffer, which is assumed to be

	a token-list. The tokens are separated by one of the specified characters. 

	Any white space surrounding the token is stripped out.  The number of 

	characters consumed from the buffer are returned. The buffer is updated to 

	not include the extracted token including the separator.

	@param			aBuffer		The buffer containing the token-list.

	@param			aToken		An output argument containing the extracted token.

	@param			aSeparators	The list of separator characters.

	@return			The number of characters consumed from the buffer.

*/

EXPORT_C TInt InetProtTextUtils::ExtractNextTokenFromList(TPtrC8& aBuffer, TPtrC8& aToken, const TDesC8& aSeparators)

	{

	TPtrC8 separators = aSeparators;

	return DoExtractNextTokenFromList(aBuffer, aToken, separators);

	}

/** 

	Extract a token from the head of the supplied buffer, which is assumed to be

	a token-list. The tokens are separated by one of the specified characters. 

	Any white space surrounding the token is stripped out.  The number of 

	characters consumed from the buffer are returned. The buffer is updated to 

	not include the extracted token including the separator.

	@param			aBuffer		The buffer containing the token-list.

	@param			aToken		An output argument containing the extracted token.

	@param			aSeparators	The list of separator characters.

	@return			The number of characters consumed from the buffer.

*/

EXPORT_C TInt InetProtTextUtils::ExtractNextTokenFromList(TPtrC16& aBuffer, TPtrC16& aToken, const TDesC16& aSeparators)

	{

	TPtrC16 separators = aSeparators;

	return DoExtractNextTokenFromList(aBuffer, aToken, separators);

	}

/**	

	Extract a quoted string value from the head of the supplied buffer. Anything

	outside the quotes is discarded and the quotes themselves are not included 

	in the returned string.

	@param			aBuffer			The buffer containing the quoted.

	@param			aQuotedString	An output argument containing the extracted

									string.

	@return			The number of characters consumed from the buffer.

*/

EXPORT_C TInt InetProtTextUtils::ExtractQuotedStringL(TPtrC8& aBuffer, TPtrC8& aQuotedString)

	{

	return DoExtractQuotedStringL(aBuffer, aQuotedString);

	}

/**	

	Extract a quoted string value from the head of the supplied buffer. Anything

	outside the quotes is discarded and the quotes themselves are not included 

	in the returned string.

	@param			aBuffer			The buffer containing the quoted.

	@param			aQuotedString	An output argument containing the extracted

									string.

	@return			The number of characters consumed from the buffer.

*/

EXPORT_C TInt InetProtTextUtils::ExtractQuotedStringL(TPtrC16& aBuffer, TPtrC16& aQuotedString)

	{

	return DoExtractQuotedStringL(aBuffer, aQuotedString);

	}

/**	

	@internalTechnology

	Extract an integer value from the head of the supplied buffer.

	@param			aBuffer	The buffer containing the integer value.

	@param			aIntVal	An output argument in which extracted integer value

							is placed.

	@param			aAllowNonWsTerminator	If set to true whitespace is considered as the 

									terminator, if set to false a non-decimal charecter

									is considered as terminator.

	@return			The number of characters in aBuffer after the integer.

	@leave			KUriUtilsErrMalformedInteger if the value in aBuffer is not an integer 

					(ie, contains non-decimal characters, or is too big to fit in a TInt)

*/

EXPORT_C TInt InetProtTextUtils::ExtractIntegerValueL(TPtrC8& aBuffer, TInt& aIntVal, TBool aAllowNonWsTerminator)

	{

	// Anticipate an empty token by default

	TPtrC8 data(aBuffer);

	// Trim out any whitespace to the left the integer and check there's something left!

	InetProtTextUtils::RemoveWhiteSpace(data, InetProtTextUtils::ERemoveLeft);

	const TInt len = data.Length();

	TInt retVal = aBuffer.Length() -  len; // the amount of WS consumed

	if (len == 0)

		{

		// No integer was found - the supplied buffer was all WS!

		aIntVal = 0;

		retVal = aBuffer.Length();

		aBuffer.Set(data);

		}

	else

		{

		// Got some data to work with... find out how many digits are present. Assume that the integer

		// required is a contiguous set of decimal digits followed by WS or the end of the buffer

		TInt numDigits = 0;

		TChar ch = KZero; // default most significant digit to zero without affecting the result

		TBool done = EFalse;

		while (!done)

			{

			// check for the end of the integer. This depends on what is allowed to terminate it.

			if (aAllowNonWsTerminator)

				{

				done = (numDigits == data.Length());

				if (!done)

					{

					ch = data[numDigits];

					done = ((ch < KZero) || (ch > KNine));

					}

				}

			else

				{

				done = (numDigits == data.Length());

				if (!done)

					{

					ch = data[numDigits];

					done = ((ch == KSpace) || (ch == KHorizTab) || (ch == KDecimal));

					}

				}

			// Check that we're getting digits

			if (!done)

				{

				if ((ch < KZero) || (ch > KNine)) // digits 0-9

					User::Leave(KUriUtilsErrMalformedInteger);

				++numDigits;

				}

			}

		// Make sure there's no overflow (trivial check)

		if(numDigits>KMaxTIntDecimalDigits)

			User::Leave(KUriUtilsErrMalformedInteger);

		// Now work back, building up the integer

		aIntVal = 0;

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

			{

			// double check no overflow (

			if(aIntVal>KMaxTIntDividedByTen   ||  //works except for 2147483648 and ...49)

				( (aIntVal == KMaxTIntDividedByTen)  && (data[pos] >= (KNine-1)) ) // covers those two cases

				)  

				User::Leave(KUriUtilsErrMalformedInteger);

			aIntVal = (data[pos] - KZero) + (aIntVal * 10); // decimal, innit?

			}

		// work out how much this has consumed

		retVal += numDigits;

		// Finally ensure the buffer has had the correct amount of data consumed

		if (len == aBuffer.Length())

			aBuffer.Set(KNullDesC8()); // there was nothing to the right of the integer

		else

			aBuffer.Set(aBuffer.Mid(retVal));

		}

	return retVal;

	}

/*

 *	Local methods

 */

/**

	@internalComponent

	Does the whitespace removal. Checks the mode and then calls the appropriate

	functions.

	@warning		Will panic will KUriUtilsErrBadTExtRemoveMode if aMode not valid.

	@param			aData	A descriptor pointer with the data.

	@param			aMode	The specified removal mode.

	@return			The number of consumed whitespace characters. If the data is

					empty or the data is all whitespace the error code 

					KUriUtilsErrEmptyData is returned.

*/

template<class TPtrCType>

TInt DoRemoveWhiteSpace(TPtrCType& aData, InetProtTextUtils::TRemoveMode aMode)

	{

	TInt consumed = 0;

	switch( aMode )

		{

	case InetProtTextUtils::ERemoveLeft:

		{

		consumed = FindWhiteSpaceLeft(aData);

		if( consumed > 0 )

			{

			// Found some whitespace

			aData.Set(aData.Mid(consumed));

			}

		} break;

	case InetProtTextUtils::ERemoveRight:

		{

		consumed = FindWhiteSpaceRight(aData);

		if( consumed > 0 )

			{

			// Found some whitespace

			aData.Set(aData.Left(aData.Length() - consumed));

			}

		} break;

	case InetProtTextUtils::ERemoveBoth:

		{

		// Remove from left first...

		consumed = FindWhiteSpaceLeft(aData);

 		if( consumed != KUriUtilsErrEmptyData )

			{

			// Found some whitespace - set the pointer then remove from right

			aData.Set(aData.Mid(consumed));

			TInt consumedRight = FindWhiteSpaceRight(aData);

			// To get this far descriptor is non-empty and not all whitespace - no check

			aData.Set(aData.Left(aData.Length() - consumedRight));

			consumed += consumedRight;

			}

		} break;

	default:

		__ASSERT_DEBUG(EFalse, User::Panic(KTextUtilsPanicCategory, KUriUtilsErrBadTextRemoveMode));

		}

	return consumed;

	}

/**

	@internalComponent

	Finds the number of contiguous whitespace characters at the 

	beginning of the data.

	@param			aData	A descriptor pointer with the data.

	@return			The number of consumed whitespace characters. If the data is

					empty or the data is all whitespace the error code 

					KTextUtilsErrEmptyData is returned.

 */

template<class TPtrCType>

TInt FindWhiteSpaceLeft(const TPtrCType& aData)

	{

	const TInt length = aData.Length();

	if( length == 0 )

		return KUriUtilsErrEmptyData;

	TInt i = 0;

	TBool done = EFalse;

	while( !done && i < length )

		{

		TChar current = aData[i];

		done  = !current.IsSpace();

		if( !done )

			++i;

		}

	if( i == length )

		return KUriUtilsErrEmptyData;

	return i;

	}

/**

	@internalComponent

	Finds the number of contiguous whitespace characters at the end of the data.

	@param			aData	A descriptor pointer with the data.

	@return			The number of consumed whitespace characters. If the data is

					empty or the data is all whitespace the error code 

					KTextUtilsErrEmptyData is returned.

*/

template<class TPtrCType>

TInt FindWhiteSpaceRight(const TPtrCType& aData)

	{

	const TInt length = aData.Length();

	if( length == 0 )

		return KUriUtilsErrEmptyData;

	TInt i = 0;

	TBool done = EFalse;

	while( !done && i < length )

		{

		TChar current = aData[(length-1) - i];

		done  = !current.IsSpace();

		if( !done )

			++i;

		}

	if( i == length )

		return KUriUtilsErrEmptyData;

	return i;

	}

/** 

	Extracts next token from the buffer.

	@param			aBuffer		The buffer containing the token-list.

	@param			aToken		An output argument containing the extracted token.

	@param			aSeparator	The separator character.

	@return			The number of characters consumed from the buffer.

*/

template<class TPtrCType>

TInt DoExtractNextTokenFromList(TPtrCType& aBuffer, TPtrCType& aToken, TChar aSeparator)

	{

	// Anticipate an empty token by default.

	TInt consumed = 0;

	// Search for the separator

	const TInt pos = aBuffer.Locate(aSeparator);

	// If the separator was found, take chars upto it. Otherwise use the whole

	// remaining buffer - implies the last token in the list.

	if( pos == KErrNotFound )

		{

		// Last token - take the whole lot

		aToken.Set(aBuffer);

		consumed = aBuffer.Length();

		}

	else

		{

		// Take upto the separator position for the token, and move the buffer 

		// past the token.

		aToken.Set(aBuffer.Left(pos));

		consumed = pos + 1;	// include the separator

		}

	// Set the buffer to move past the extracted token.

	aBuffer.Set(aBuffer.Mid(consumed));

	// Trim out any whitespace surrounding the token, and return how many charas

	// were consumed.

	InetProtTextUtils::RemoveWhiteSpace(aToken, InetProtTextUtils::ERemoveBoth);

	return consumed;

	}

/** 

	Extracts next token from the buffer.

	@param			aBuffer		The buffer containing the token-list.

	@param			aToken		An output argument containing the extracted token.

	@param			aSeparator	The separator.

	@return			The number of characters consumed from the buffer.

*/

template<class TPtrCType>

TInt DoExtractNextTokenFromList(TPtrCType& aBuffer, TPtrCType& aToken, const TPtrCType& aSeparator)

	{

	// Finds the next token in the list, where all the characters in

	// the separator array are considered to be separators.

	// Anticipate an empty token by default.

	TInt consumed = 0;

	// Search for separator...

	const TInt length = aBuffer.Length();

	TInt pos = 0;

	TBool found = EFalse;

	while( !found && pos < length )

		{

		// If we find a quoted string, skip over it (and any token

		// separators within it)

		if( aBuffer[pos] == KQuote )

			{

			for( ++pos; pos < length && aBuffer[pos] != KQuote; ++pos )

				{}

			if (pos == length)

				break; // end of string reached

			}

		if( aSeparator.Locate(aBuffer[pos]) != KErrNotFound )

			found = ETrue;

		else

			++pos;

		}

	// If the separator was found, take chars upto it. Otherwise use the whole

	// remaining buffer - implies the last token in the list.

	if( found )

		{

		// Take upto the separator position for the token, and move the buffer 

		// past the token.

		aToken.Set(aBuffer.Left(pos));

		consumed = pos + 1;

		}

	else

		{

		// Last token - take the whole lot

		aToken.Set(aBuffer);

		consumed = aBuffer.Length();

		}

	// Set the buffer to move past the extracted token.

	aBuffer.Set(aBuffer.Mid(consumed));

	// Trim out any whitespace surrounding the token, and return how

	// many characters were extracted.

	InetProtTextUtils::RemoveWhiteSpace(aToken, InetProtTextUtils::ERemoveBoth);

	return consumed;

	}

/**	

	Extract a quoted string value from the buffer. 

	@param			aBuffer			The buffer containing the quoted.

	@param			aQuotedString	An output argument containing the extracted

									string.

	@return			The number of characters consumed from the buffer.

*/

template<class TPtrCType>

TInt DoExtractQuotedStringL(TPtrCType& aBuffer, TPtrCType& aQuotedString)

	{

	// Find the opening "

	TInt quotePos1 = aBuffer.Locate(KQuote);

	if( quotePos1 == KErrNotFound )

		User::Leave(KUriUtilsErrDecodeMalformedQuotedString);

	// Find the closing "

	TPtrCType temp = aBuffer.Mid(quotePos1 + 1);	// ignore the "

	TInt quotePos2 = temp.LocateReverse(KQuote);

	if( quotePos2 == KErrNotFound )

		User::Leave(KUriUtilsErrDecodeMalformedQuotedString);

	// return what's between them and consume the right number of characters from the buffer

	aQuotedString.Set(temp.Left(quotePos2));

	TInt consumed = quotePos1 + quotePos2 + 2; // +2 is to consume the quotes themselves

	aBuffer.Set(aBuffer.Mid(consumed));

	return consumed;

	}

/**

	Converts an integer value into its decimal character representation.

	@param			aInt		An integer value.	

	@param			aBuffer		An output argument of a pointer to a data buffer

	that will contain the character representation of the integer value.

	@param			aRadix		enum value.	

*/

template<class HBufCType>

void DoConvertIntToDescriptorL(TInt aInt, HBufCType*& aBuffer, TRadix aRadix)

	{

	// Create the buffer - max possible size for binary number is 32

	TBuf8<KMaxNumberSize> buf;

	buf.SetMax();

	// Is the number -ve?

	TUint value = aInt;

	TBool negative = EFalse;

	if( aInt < 0 )

		{

		negative = ETrue;

		value = -aInt;

		}

	// Now form the number...

	TInt index = KMaxNumberSize;

	do	

		{

		// Update the index

		--index;

		__ASSERT_DEBUG( index > 0, User::Invariant() );

		// Find the value of the least significant digit

		TUint q = value/aRadix;

		TUint c = value - (q*aRadix);

		// Convert digit to character and insert into the buffer.

		( c > 9 ) ? c += (KAChar-10) : c += KZeroChar;

		buf[index] = STATIC_CAST(TUint8, c);

		// Update the value left to convert.

		value = q;

		} while( value > 0 );

	// Add the '-' sign if number was negative

	if( negative )

		buf[--index] = KMinusSign;

	// Create the output buffer...

	TPtrC8 number = buf.Mid(index);

	aBuffer = HBufCType::NewL(number.Length());

	aBuffer->Des().Copy(number);

	}

/**

	Converts the character representation of an integer into its numeric value.

	Preceeding whitespace is ignored and the integer is delimited by either the

	end of the data, whitespace or any other character other than 0 to 9.

	@param			aData	A descriptor pointer with the data.

	@param			aInt	An output argument in which the numeric value of the

	data is placed.

	@param			aRadix		enum value.	

	@return			The number of consumed characters that contributed to the 

					integer value, including any whitespace before the integer. 

					If the data is empty the error code KUriUtilsErrEmptyData 

					is returned. If there are no digits at the beginning of the

					data the error code KUriUtilsErrNoIntergerInData is returned.

*/

template<class TPtrCType>

TInt DoConvertDescriptorToInt(const TPtrCType& aData, TInt& aInt, TRadix aRadix)

	{

	// Remove any whitespace before the digits

	TPtrCType data = aData;

	TInt consumed = InetProtTextUtils::RemoveWhiteSpace(data, InetProtTextUtils::ERemoveLeft);

	// Ensure that there are some digits to convert

	TInt length = data.Length();

	if( length == 0 )

		{

		return KUriUtilsErrEmptyData;

		}

	// Search for digits and calculate value - stop when non-digit found

	TInt value = 0;

	TBool done = EFalse;

	TBool negative=EFalse;

	if(data[0]==KMinusSign)

	   {

		negative=ETrue;

	   }	

	TInt i=0;

	// Length is verifying as user input may be just only '-' sign.

	if( negative && length > 1 )

		{

		i = 1;	

		}

	while( !done )

		{

		// Get the current char and see if it is a digit

		TChar c = data[i];

		if( c.IsHexDigit() )

			{

			// Need to convert char to its numeric value

			TInt digit = c - KZeroChar;

			// Was the char in the A-F range?

			if( digit > 9 )

				digit = c.GetUpperCase() - (KAChar - 10);

			if( digit > aRadix )

				{

				// The character is too large for the radix - end of data.

				done = ETrue;

				}

			else

				{

				// Update running total

				value *= aRadix;

				value += digit;

				}

			}

		else

			{

			// Non-digit found - we're done!

			done = ETrue;

			}

		// Check for end of data

		done = done || !(++i < length);

		}

	// Set up outputs

	if( i == 0 )

		{

		// No digits found in data - do not set aInt

		return KUriUtilsErrNoIntegerInData;

		}

	// Set the value of the interger

	if( negative )

		aInt = -value;

	else

		aInt = value;

	// Return consumed characters

	return i + consumed;

	}