// 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 <e32base.h>

 #include <stringpool.h>

 #include <wspdecoder.h>

 // Constants

 const TUint8 KWapQuote = 0x7F;

 const TUint8 KCarryBitMask = 0x80;

 #define KTopBitMask KCarryBitMask

 const TUint8 KTop3BitSet = 0x70;

 const TUint8 KQuoteChar = '\"';

 // Panic category

 _LIT(KUriPanicCategory,"WSPDECODER");

 //***********************************************************************

 //	TWspHeaderSegmenter

 //**********************************************************************/

 /**

   NextL iterates through the buffer.  Each call returns a TWspField in the paramater.

   @param aHeader Out - a TWspField containing the header <name,value> pair.  

   @warning The TWspField::iHdrName will be opened internally.

 			It must be closed by the caller before this class is destroyed.

   @return	KErrNone if next field is returned

 			KErrNotFound at the end of the buffer - no TWspField param returned

 			KErrCorrupt if segmenting does not parse correctly

   @leave	RStringPool::OpenFStringL StringPool leave code if opening string fails.

 */

 EXPORT_C TInt TWspHeaderSegmenter::NextL(TWspField& aHeader)

 	{

 	// have we run out of buffer?

 	if (iOffset >= iBuffer.Length())

 		return KErrNotFound;

 	// Set decoder to current buffer

 	TWspPrimitiveDecoder decoder(iBuffer.Mid(iOffset));

 	TInt bufLen = 0;

 	// Get the Field Name 

 	switch(decoder.VarType())

 		{

 		case TWspPrimitiveDecoder::EString:

 			{

 			TPtrC8 name;

 			bufLen = decoder.String(name);

 			if (bufLen < KErrNone) return bufLen;

 			aHeader.iHdrName = iPool.OpenFStringL(name);

 			}

 			break;

 		case TWspPrimitiveDecoder::E7BitVal:

 			{

 			TUint8 name;

 			bufLen = decoder.Val7Bit(name);

 			if (bufLen < KErrNone) return bufLen;

 			aHeader.iHdrName = iPool.StringF(name, iStringTable);

 			}

 			break;

 		default:	// header name can't be anything else

 			return KErrCorrupt;

 		}

 	// move our pointer past header name

 	iOffset += bufLen;

 	// Get the value buffer by figuring out the type, then set the pointer to span the entire

 	// value.  Note - further parsing will happen later to pull out specific value data.

 	switch(decoder.VarType())

 		{

 		case TWspPrimitiveDecoder::ELengthVal:

 			{

 			TInt len;

 			bufLen = decoder.LengthVal(len);

 			bufLen += len;		

 			}

 			break;

 		case TWspPrimitiveDecoder::EQuotedString:

 		case TWspPrimitiveDecoder::EString:

 			{

 			TPtrC8 strBuf;

 			bufLen = decoder.String(strBuf);

 			}

 			break;

 		case TWspPrimitiveDecoder::E7BitVal:

 			bufLen = 1;

 			break;

 		default:

 			return KErrCorrupt;

 		}

 	if (bufLen < 0) 

 		return bufLen;

 	if (iOffset + bufLen > iBuffer.Length())

           return KErrCorrupt;

 	aHeader.iValBuffer.Set(iBuffer.Mid(iOffset, bufLen));

 	iOffset += bufLen;

 	return KErrNone;

 	}

  //

  // WAP-WSP 8.4.1.2

  //

 /**

 	Looks at the byte currently pointed at in this buffer and returns the type.

 	@return TWspHeaderType - the type of this data octet

 */

 EXPORT_C TWspPrimitiveDecoder::TWspHeaderType TWspPrimitiveDecoder::VarType() const

 	{

 	TWspHeaderType type = ENotSet;

 	// Check that the offset has not overflowed the buffer

 	if( iOffset >= iBuffer.Length() )

 		return type;

 	TInt octet = iBuffer[iOffset];

 	if (octet >= 0 && octet <= 31)

 		type = ELengthVal;

 	else if (octet == 34)

 		type = EQuotedString;

 	else if (octet >= 32 && octet <= 127)

 		type = EString;

 	else if (octet >= 128 && octet <= 255)

 		type = E7BitVal;

 	return type;

 	}

 /**

 	Returns length of the data following this byte.  

 	@pre iBuffer[iOffset] must be valid, VarType() == TWspHeaderType::ELengthVal

 	@post internal offset gets updated to move past this primitive 

 	@param aVal Out - the length encoded in this byte that indicates the size of the

 		  	     data that follows.

 	@return postive number indicating the number of bytes read from the buffer

 			KErrCorrupt if data is not formatted correctly.

 */

 EXPORT_C TInt TWspPrimitiveDecoder::LengthVal(TInt& aVal)

 	{

 	// have we run out of buffer?

 	if (iOffset >= iBuffer.Length())

 		return KErrCorrupt;

 	TInt bufLen = 0;

 	aVal = iBuffer[iOffset++];

 	if (aVal == 31)

 		{

 		TUint32 uintVarLen = 0;

 		bufLen = UintVar(uintVarLen);

 		if (bufLen < KErrNone) return bufLen;

 		aVal = (TInt)uintVarLen;

 		}

 	// add the 1 byte read at to get first aVal

 	++bufLen;

 	return bufLen;

 	}

 /**

    Returns a TPtrC holding the string the buffer currently points at without the NULL 

    termination. If the String type is a quoted string then the quotes are not included 

    in the returned buffer.

    @pre iBuffer[iOffset] must be valid, VarType() == TWspType::EString

    @post internal offset gets updated to move past this primitive 

    @param aString Out - the string

    @return postive number indicating the number of bytes read from the buffer

    		  KErrCorrupt if data is not formatted correctly.

 */

 EXPORT_C TInt TWspPrimitiveDecoder::String(TPtrC8& aString)

 	{

 	TWspHeaderType type = VarType();

 	if( type != EString && type != EQuotedString)

 		return KErrCorrupt;

 	TInt nullIndex = iBuffer.Mid(iOffset).Locate('\0');

 	if( nullIndex == KErrNotFound )

 		return KErrCorrupt;

 	// Set buffer to data not including the NULL terminator

 	TPtrC8 buf = iBuffer.Mid(iOffset, nullIndex);

 	// is there a WAP Quote (0x7F) or a " at the start - step over it

 	TInt bufferOffset = 0;

 	const TUint8 firstByte = iBuffer[iOffset];

 	if( firstByte == KQuoteChar || firstByte == KWapQuote )

 		++bufferOffset;

 	// Set the descriptor with the correct buffer segment

 	aString.Set(buf.Mid(bufferOffset));

 	// Step over the NULL

 	++nullIndex;

 	// update the offset

 	iOffset += nullIndex;

 	return nullIndex;

 	} 

 /**

 	Returns a token, a short int or an octet value with the top bit cleared

 	@pre iBuffer[iOffset] must be valid, VarType() == TWspHeaderType::E7BitVal

 	@post internal offset gets updated to move past this primitive 

 	@param aVal Out - the 7 bit value with top bit cleared

 	@return postive number indicating the number of bytes read from the buffer

 		    KErrCorrupt if data is not formatted correctly.

 */

 EXPORT_C TInt TWspPrimitiveDecoder::Val7Bit(TUint8& aVal)

 	{

 	// have we run out of buffer?

 	if (iOffset >= iBuffer.Length())

 		return KErrCorrupt;

 	aVal = (TUint8)(iBuffer[iOffset] & KWapQuote);

 	++iOffset;

 	// 1 byte read

 	return 1;

 	}

 /**

 	Returns an Integer - could be short or long.

 	@pre iBuffer[iOffset] must be valid, VarType() == TWspHeaderType::ELengthVal or

 		   VarType() == TWspHeaderType::E7BitVal

 	@post internal offset gets updated to move past this primitive 

 	@param aVal Out - the long int

 	@return postive number indicating the number of bytes read from the buffer

 			  KErrCorrupt if data is not formatted correctly.

 */

 EXPORT_C TInt TWspPrimitiveDecoder::Integer(TUint32& aVal)

 	{

 	// have we run out of buffer?

 	if (iOffset >= iBuffer.Length())

 		return KErrCorrupt;

 	TInt bufLen = 0;

 	// read the first byte

 	aVal = iBuffer[iOffset];

 	// short integers have the top bit set

 	if (aVal & KTopBitMask)

 		{

 		aVal &= KWapQuote;

 		++iOffset;

 		++bufLen;

 		}

 	else

 		{

 		bufLen = LongInt(aVal);

 		}

 	return bufLen;

 	}

 /**

 	Returns a long int the buffer is currently pointing at. 

 	@pre iBuffer[iOffset] must be valid, VarType() == TWspHeaderType::ELengthVal  

 	@post internal offset gets updated to move past this primitive 

 	@param aVal Out - the long int

 	@return postive number indicating the number of bytes read from the buffer

 		  KErrCorrupt if data is not formatted correctly.

 */

 EXPORT_C TInt TWspPrimitiveDecoder::LongInt(TUint32& aVal)

 	{

 	// have we run out of buffer?

 	if (iOffset >= iBuffer.Length())

 		return KErrCorrupt;

 	__ASSERT_DEBUG(aVal <= KMaxTUint, User::Panic(KUriPanicCategory, EWspDecoderLongIntOverflow));

 	// initialize

 	aVal = 0;

 	// Get num bytes encoding [len] [byte1] ... [byten]

 	// we are positioned at that location in the source descriptor

 	TUint8 numBytes = 0;

 	TInt bufLen = Val7Bit(numBytes);

 	if (bufLen < KErrNone) return bufLen;

 	// len can be up to 30 and verify we have enough buffer

 	if (numBytes > 30 || numBytes > iBuffer.Mid(iOffset).Length())

 		return KErrCorrupt;

 	// Loop over the buffer, taking each byte and shifting it in count times.  

 	for (TInt count = 0; count < numBytes ; ++count)

 		aVal = (aVal << 8) + iBuffer[iOffset++];

 	return (bufLen + numBytes);

 	}

 /**

 	Returns a TUint32 

 	@pre iBuffer[iOffset] must be valid, VarType() == TWspHeaderType::ELengthVal or

 		   VarType() == TWspHeaderType::E7BitVal 

 	@post internal offset gets updated to move past this primitive 

 	@param aVal Out - the TUint32 decoded 

 	@return postive number indicating the number of bytes read from the buffer

 		    KErrCorrupt if data is not formatted correctly.

 */

 EXPORT_C TInt TWspPrimitiveDecoder::UintVar(TUint32& aVal)

 	{

 	// have we run out of buffer?

 	if (iOffset >= iBuffer.Length())

 		return KErrCorrupt;

 	// initialize return val

 	aVal = 0;

 	// maximum length for a uintvar is 5

 	TInt lenLeft = Min(iBuffer.Mid(iOffset).Length(), 5);

 	// get the first octet

 	TUint8 byte = iBuffer[iOffset++];

 	TInt numBytes = 1;

 	--lenLeft;	

 	// Check if any of the top 3 bits, ignoring the very top 'continue' bit, are set.  

 	// Later if we see that this is a 5 byte number - we'll know it is corrupt.  

 	// Encoding uses 7 bits/number 7x5=35 and we only support a maxiumum number 

 	// of 32 bits.

 	TBool topThreeBitsSet = byte & KTop3BitSet; 

 	// copy over data from the byte into our return value (the top bit is a carry bit)

 	aVal = byte & KWapQuote;

 	// while the 'continue' bit is set and we have more data

 	while ((byte & KCarryBitMask) && (lenLeft > 0))

 		{

 		// shift our last value up

 		aVal <<= 7;

 		// get the next byte

 		byte = iBuffer[iOffset++];

 		// copy it over to the lowest byte

 		aVal |= byte & KWapQuote;

 		--lenLeft;

 		++numBytes;

 		} 

 	// last octet has continue bit set ... NOT allowed Or

 	// this was encoded wrong - can't have a number bigger than 32 bits

 	if ((byte & KCarryBitMask) || (numBytes == 5 && topThreeBitsSet))

 		return KErrCorrupt;

 	// number of bytes read

 	return numBytes;

 	}

 /**

 	Returns a formatted version string 

 	@pre iBuffer[iOffset] must be valid, VarType() == TWspHeaderType::ELengthVal  

 	@post internal offset gets updated to move past this primitive 

 	@param aPool In - an opened string pool

 	@param aVer Out - a formatted version string.  Caller must close this string.

 	@return postive number indicating the number of bytes read from the buffer

 		    KErrCorrupt if data is not formatted correctly.

 */

 EXPORT_C TInt TWspPrimitiveDecoder::VersionL(RStringPool aPool, RStringF& aVer)

 	{

 	const TInt KMaxBufLength=5;

 	TInt bufLen = 0;

 	TInt byte = iBuffer[iOffset];

 	if (!(byte & KTopBitMask))

 		{

 		TPtrC8 str;

 		bufLen = String(str);

 		if (bufLen < KErrNone) return KErrCorrupt;

 		aVer = aPool.OpenFStringL(str);

 		}

 	else

 		{

 		// Major 0-7 , Minor 0-15 [xxx][yyyy]

 		TUint8 val;

 		bufLen = Val7Bit(val);

 		if (bufLen < KErrNone) return KErrCorrupt;

 		TInt minVer =  val & 0x0F;

 		TInt majVer =  val & 0xF0;

 		majVer >>= 4;

 		if (majVer < 0 || majVer > 7)

 			return KErrCorrupt;

 		TBuf8<KMaxBufLength> buf;

 		if (minVer == 0x0F)

 			{

 			_LIT8(KVersionFormat, "%D");

 			buf.Format(KVersionFormat, majVer);

 			}

 		else

 			{

 			_LIT8(KVersionFormat, "%D.%D");

 			buf.Format(KVersionFormat, majVer, minVer);

 			}

 			aVer = aPool.OpenFStringL(buf);

 		}

 	return bufLen;

 	}

 /**

 	Returns a TDateTime offset from January 1, 1970 - WAP WSP Section 8.4.2.3 Panics if 

 	the time val is greater then the maximum allowable integer size (32 bits).

 	@pre iBuffer[iOffset] must be valid, VarType() == TWspHeaderType::ELengthVal  

 	@post internal offset gets updated to move past this primitive 

 	@param aDateTime Out - a WAP Date

 	@return postive number indicating the number of bytes read from the buffer

 			  KErrCorrupt if data is not formatted correctly.

 */

 EXPORT_C TInt TWspPrimitiveDecoder::Date(TDateTime& aDateTime)

 	{

 	TUint32 secVal;

 	TInt bufLen = LongInt(secVal);

 	__ASSERT_ALWAYS(bufLen <= KMaxTInt, User::Panic(KUriPanicCategory, EWspDecoderDateOverflow));

 	if (bufLen < KErrNone) return bufLen;

 	TDateTime dt(1970,EJanuary,0,0,0,0,0);

 	TTime time(dt);

 	TInt sec = STATIC_CAST(TInt, secVal);

 	time += TTimeIntervalSeconds(sec);

 	aDateTime = time.DateTime();

 	return bufLen;

 	}