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

//

// System Includes

#include <wspstringconstants.h>

#include <wspparamconstants.h>

#include <wspcontenttypes.h>

#include <wspregcontenttypes.h>

#include <wspcharactersets.h>

#include <wspstdconstants.h>

#include <wsplanguages.h>

#include <wsptypeconstants.h>

// User Includes

#include "cheaderfield.h"

#include "cwspheaderreader.h"

// Constants

const TInt KMaxNumQDigits = 5;	// Maximum number of digits for a 'Q' value

const TUint32 KRegisteredContentTypesOffset = 0x0201; // Registered content types offset

const TUint8 KTopBitMask = 0x80; // Bit-wise mask for setting top bit to 1

CWspHeaderReader::~CWspHeaderReader()

	{

	}

CWspHeaderReader* CWspHeaderReader::NewL(RStringPool aStrPool, const TStringTable& aStrTable, CWspHeaderCodec& aCodec)

	{

	return new(ELeave)CWspHeaderReader(aStrPool, aStrTable, aCodec);

	}

CWspHeaderReader* CWspHeaderReader::NewLC(RStringPool aStrPool, const TStringTable& aStrTable, CWspHeaderCodec& aCodec)

	{

	CWspHeaderReader* self = CWspHeaderReader::NewL(aStrPool, aStrTable, aCodec);

	CleanupStack::PushL(self);

	return self;

	}

CWspHeaderReader::CWspHeaderReader(RStringPool aStrPool, const TStringTable& aStrTable, CWspHeaderCodec& aCodec)

	: iStrPool(aStrPool), iStrTable(aStrTable), iCodec(aCodec)

	{

	}

void CWspHeaderReader::DecodeHeaderL(RHeaderField& aHeader)

	{

	switch( aHeader.Name().Index(iStrTable) )

		{

		case WSP::EContentType:

			DecodeContentTypeL(aHeader);

			break;

		case WSP::EDate:

		case WSP::ELastModified:

			DecodeGenericDateValueL(aHeader);

			break;

		case WSP::EContentLocation:

		case WSP::ELocation:

		case WSP::EServer:

		case WSP::EVia:

		case WSP::EXWapInitiatorURI:

		case WSP::EUpgrade:

			DecodeGenericNewStringValueL(aHeader);

			break;

		case WSP::EPragma:

			DecodePragmaL(aHeader);

			break;

		case WSP::EVary:

		case WSP::ETrailer:

			DecodeGenericFieldNameL(aHeader);

			break;

		case WSP::EWWWAuthenticate:

		case WSP::EProxyAuthenticate:

			DecodeGenericChallengeL(aHeader);

			break;

		case WSP::ESetCookie:

			DecodeSetCookieL(aHeader);

			break;

		case WSP::EEncodingVersion:

			DecodeEncodingVersionL(aHeader);

			break;

		case WSP::EAcceptRanges:

			DecodeAcceptRangesL(aHeader);

			break;

		case WSP::EContentEncoding:

			DecodeContentEncodingL(aHeader);

			break;

		case WSP::EContentLanguage:

			DecodeContentLanguageL(aHeader);

			break;

		case WSP::EContentMD5:

			DecodeContentMD5L(aHeader);

			break;

		case WSP::ERetryAfter:

			DecodeRetryAfterL(aHeader);

			break;

		case WSP::EContentRange:

		case WSP::EContentRangeDep:

			DecodeContentRangeL(aHeader);

			break;

		case WSP::EXWapApplicationId:

			DecodeXWapApplicationIdL(aHeader);

			break;

		case WSP::EPushFlag:

			DecodePushFlagL(aHeader);

			break;

		case WSP::EAllow:

			DecodeAllowL(aHeader);

			break;

		case WSP::EWarning:

			DecodeWarningL(aHeader);

			break;

		case WSP::EProfileWarning:

		case WSP::EProfileWarningDep:

			DecodeProfileWarningL(aHeader);

			break;

		default:

			User::Leave(KErrNotSupported);

			break;

		}

	}

void CWspHeaderReader::DecodeContentTypeL(RHeaderField& aHeader) const

	{

	TPtrC8 rawData;

	aHeader.RawDataL(rawData);

	CheckLengthL(rawData, 1);

	if( !(CheckNullDesPartL(aHeader, rawData, 0)) )

		{

		TWspPrimitiveDecoder wspDecoder(rawData);

		switch( wspDecoder.VarType() )

			{

			case TWspPrimitiveDecoder::E7BitVal:

				{

				TUint8 contentTypeToken = 0;

				User::LeaveIfError(wspDecoder.Val7Bit(contentTypeToken));

				RStringF contentType = iStrPool.StringF(contentTypeToken, WSPContentTypes::Table);

				SetFStringPartL(aHeader, 0, contentType);

				} break;

			case TWspPrimitiveDecoder::EString:

				{

				AddNewDecoderStringPartL(aHeader, wspDecoder);

				} break;

			case TWspPrimitiveDecoder::ELengthVal:

				{

				TInt dataLength = 0;

				TInt err = wspDecoder.LengthVal(dataLength);

				User::LeaveIfError(err);

				TInt bytesProcessed = err;

				TWspPrimitiveDecoder::TWspHeaderType type = wspDecoder.VarType();

				CHeaderFieldPart* fieldPart = NULL;

				if( type == TWspPrimitiveDecoder::E7BitVal || type == TWspPrimitiveDecoder::ELengthVal )

					{

					TUint32 contentTypeToken = 0;

					err = wspDecoder.Integer(contentTypeToken);

					User::LeaveIfError(err);

					bytesProcessed += err;

					RStringF contentTypeStr;

					if( contentTypeToken < KRegisteredContentTypesOffset )

						contentTypeStr = iStrPool.StringF(contentTypeToken, WSPContentTypes::Table);

					else

						contentTypeStr = iStrPool.StringF((contentTypeToken-KRegisteredContentTypesOffset), WSPRegContentTypes::Table);

					fieldPart = &(SetFStringPartL(aHeader, 0, contentTypeStr));

					}

				else if( type == TWspPrimitiveDecoder::EString )

					{

					TPtrC8 contentType;

					err = wspDecoder.String(contentType);

					User::LeaveIfError(err);

					bytesProcessed += err;

					fieldPart = &(SetNewFStringPartL(aHeader, 0, contentType));

					}

				else

					User::Leave(KErrCorrupt);

				// Check if paramters exist

				while( bytesProcessed < rawData.Length() )

					{

					TPtrC8 parameterBlock(rawData.Mid(bytesProcessed));

					bytesProcessed += DecodeGenericSingleParameterL(parameterBlock, *fieldPart);

					}

				} break;

			default:

				User::Leave(KErrCorrupt);

			}

		}

	}

void CWspHeaderReader::DecodePragmaL(RHeaderField& aHeader) const

	{

	TPtrC8 rawData;

	aHeader.RawDataL(rawData);

	CheckLengthL(rawData, 1);

	// Check for <Octet 128> which indicates "No-Cache" string

	if( rawData[0] == 128 )

		{

		SetFStringPartL(aHeader, 0, iStrPool.StringF(WSPStdConstants::ENoCache, WSPStdConstants::Table));

		}

	else

		{

		TWspPrimitiveDecoder wspDecoder(rawData);

		if( wspDecoder.VarType() == TWspPrimitiveDecoder::ELengthVal )

			{

			TInt dataLength = 0;

			TInt bytesProcessed = wspDecoder.LengthVal(dataLength);

			User::LeaveIfError(bytesProcessed);

			TPtrC8 rawParamBlock(rawData.Mid(bytesProcessed));

			// Check that there is only one parameter block

			if( dataLength != rawParamBlock.Length() )

				User::Leave(KErrCorrupt);

			CHeaderFieldPart& fieldPart = SetNewFStringPartL(aHeader, 0, KNullDesC8());

			bytesProcessed += DecodeGenericSingleParameterL(rawParamBlock, fieldPart);

			if( bytesProcessed != rawData.Length() )

				User::Leave(KErrCorrupt);

			}

		}

	}

void CWspHeaderReader::DecodeSetCookieL(RHeaderField& aHeader) const

	{

	TPtrC8 rawData;

	aHeader.RawDataL(rawData);

	CheckLengthL(rawData, 2);

	TWspPrimitiveDecoder wspDecoder(rawData);

	if( wspDecoder.VarType() != TWspPrimitiveDecoder::ELengthVal )

		User::Leave(KErrCorrupt);

	TInt valueLength = 0;

	TInt bytesProcessed = wspDecoder.LengthVal(valueLength);

	User::LeaveIfError(bytesProcessed);

	// Get the first part which is the cookie-version

	TInt err = 0;

	if( CheckForNullStringL(rawData, bytesProcessed, wspDecoder) )

		{

		SetNewFStringPartL(aHeader, 0, KNullDesC8());

		}

	else

		{

		RStringF version;

		err = wspDecoder.VersionL(iStrPool, version);

		User::LeaveIfError(err);

		bytesProcessed += err;

		CleanupClosePushL(version);

		SetFStringPartL(aHeader, 0, version);

		CleanupStack::PopAndDestroy(&version);

		}

	// Loop through the next two 

	// Get the second part which is the cookie-name

	// Get the third part which is the cookie-value

	CHeaderFieldPart* fieldPart = NULL;

	for(TInt ii=1; ii<3; ++ii)

		{

		TPtrC8 cookiePart(KNullDesC8());

		if( !(CheckForNullStringL(rawData, bytesProcessed, wspDecoder)) )

			{

			err = wspDecoder.String(cookiePart);

			User::LeaveIfError(err);

			bytesProcessed += err;

			}

		fieldPart = &(SetNewFStringPartL(aHeader, ii, cookiePart));

		}

	// Check if there are any parameters. if so add them to the 3rd part

	if( fieldPart != NULL ) 

		{

		while( bytesProcessed < rawData.Length() )

			{

			TPtrC8 parameterBlock(rawData.Mid(bytesProcessed));

			bytesProcessed += DecodeGenericSingleParameterL(parameterBlock, *fieldPart);

			}

		}

	}

TBool CWspHeaderReader::CheckForNullStringL(TPtrC8& aRawData, TInt& aBytesRead,

											TWspPrimitiveDecoder& aDecoder) const

	{

	// Check that the buffer is not out of range

	if( aBytesRead >= aRawData.Length() )

		User::Leave(KErrCorrupt);

	// Check if the data at the indicated position is a NULL terminator

	if( aRawData[aBytesRead] == 0 )

		{

		TUint8 value = 0;

		TInt err = aDecoder.Val7Bit(value);

		User::LeaveIfError(err);

		aBytesRead += err;

		return ETrue;

		}

	return EFalse;

	}

void CWspHeaderReader::DecodeEncodingVersionL(RHeaderField& aHeader) const

	{

	TPtrC8 rawData;

	aHeader.RawDataL(rawData);

	CheckLengthL(rawData, 1);

	TWspPrimitiveDecoder wspDecoder(rawData);

	if( !(CheckNullDesPartL(aHeader, rawData, 0)) )

		{

		// Check type and decode accordingly

		switch( wspDecoder.VarType() )

			{

			case TWspPrimitiveDecoder::ELengthVal:

				{

				TInt valLength = 0;

				TInt bytesRead = 0;

				TInt err = wspDecoder.LengthVal(valLength);

				User::LeaveIfError(err);

				bytesRead += err;

				if( wspDecoder.VarType() == TWspPrimitiveDecoder::E7BitVal )

					{

					TUint8 codePage = 0;

					err = wspDecoder.Val7Bit(codePage);

					User::LeaveIfError(err);

					bytesRead += err;

					SetNewIntegerPartL(aHeader, 0, codePage);

					if( bytesRead < rawData.Length() )

						{

						// Check for Null string first

						if( rawData[bytesRead] == 0 )

							SetNewFStringPartL(aHeader, 1, KNullDesC8());

						else

							DecodeGenericVersionL(aHeader, wspDecoder, 1);

						}

					}

				else

					User::Leave(KErrCorrupt);

				} break;

			case TWspPrimitiveDecoder::EString:

			case TWspPrimitiveDecoder::E7BitVal:

				{

				DecodeGenericVersionL(aHeader, wspDecoder, 0);

				} break;

			default:

				User::Leave(KErrCorrupt);

				break;

			}

		}

	}

void CWspHeaderReader::DecodeGenericVersionL(RHeaderField& aHeader, TWspPrimitiveDecoder& aDecoder, TInt aIndex) const

	{

	RStringF versionValue;

	CleanupClosePushL(versionValue);

	User::LeaveIfError(aDecoder.VersionL(iStrPool, versionValue));

	SetFStringPartL(aHeader, aIndex, versionValue);

	CleanupStack::PopAndDestroy(&versionValue);

	}

void CWspHeaderReader::DecodeAcceptRangesL(RHeaderField& aHeader) const

	{

	TPtrC8 rawData;

	aHeader.RawDataL(rawData);

	CheckLengthL(rawData, 1);

	TInt acceptRangeIndex = KErrNotFound;

	switch( rawData[0] )

		{

		case 128: // This is the token for 'None'

			{

			acceptRangeIndex = WSPStdConstants::ENone;

			} break;

		case 129: // This is the token for 'Bytes'

			{

			acceptRangeIndex = WSPStdConstants::EBytes;

			} break;

		default: // Must be token text

			{

			TWspPrimitiveDecoder wspDecoder(rawData);

			// Check that the data is of string type

			if( wspDecoder.VarType() == TWspPrimitiveDecoder::EString )

				{

				// Extract and add the string as a part

				AddNewDecoderStringPartL(aHeader, wspDecoder);

				}

			else

				User::Leave(KErrCorrupt);

			} break;

		}

	if(acceptRangeIndex!=KErrNotFound)

		SetFStringPartL(aHeader, 0, iStrPool.StringF(acceptRangeIndex, WSPStdConstants::Table));

	}

void CWspHeaderReader::DecodeContentEncodingL(RHeaderField& aHeader) const

	{

	TPtrC8 rawHeaderData;

	aHeader.RawDataL(rawHeaderData);

	TInt startPos = 0;

	TInt separatorPos = 0;

	TInt ii = 0;

	// Loop through all the parts separated by the header field token name

	do

		{

		TPtrC8 rawData(rawHeaderData.Mid(startPos));

		separatorPos = rawData.Locate((TUint8)(WSP::EContentEncoding + KTopBitMask));

		if(separatorPos!=KErrNotFound)

			rawData.Set(rawHeaderData.Mid(startPos, separatorPos));

		CheckLengthL(rawData, 1);

		TInt contentEncodingIndex = KErrNotFound;

		switch( rawData[0] )

			{

			case 128: // This is the token for 'GZip'

				{

				contentEncodingIndex = WSPStdConstants::EGzip;

				} break;

			case 129: // This is the token for 'Compress'

				{

				contentEncodingIndex = WSPStdConstants::ECompress;

				} break;

			case 130: // This is the token for 'Deflate'

				{

				contentEncodingIndex = WSPStdConstants::EDeflate;

				} break;

			default: // Must be token text

				{

				TWspPrimitiveDecoder wspDecoder(rawData);

				// Check that the data is of string type

				if( wspDecoder.VarType() == TWspPrimitiveDecoder::EString )

					{

					// Extract and add the string as a part

					AddNewDecoderStringPartL(aHeader, wspDecoder, ii);

					}

				else

					User::Leave(KErrCorrupt);

				} break;

			}

		if(contentEncodingIndex!=KErrNotFound)

			SetFStringPartL(aHeader, ii, iStrPool.StringF(contentEncodingIndex, WSPStdConstants::Table));

		++ii;

		startPos += (separatorPos + 1);

		} while( separatorPos != KErrNotFound );

	}

void CWspHeaderReader::DecodeContentLanguageL(RHeaderField& aHeader) const

	{

	TPtrC8 rawHeaderData;

	aHeader.RawDataL(rawHeaderData);

	TInt startPos = 0;

	TInt separatorPos = 0;

	TInt ii = 0;

	// Loop through all the parts separated by the header field name

	do

		{

		TPtrC8 rawData(rawHeaderData.Mid(startPos));

		separatorPos = rawData.Locate((TUint8)(WSP::EContentLanguage + KTopBitMask));

		if(separatorPos!=KErrNotFound)

			rawData.Set(rawHeaderData.Mid(startPos, separatorPos));

		CheckLengthL(rawData, 1);

		// First check for any language ('*') encoded as octet 128

		if( rawData[0] == 128 )

			SetFStringPartL(aHeader, ii, iStrPool.StringF(WSPLanguages::EAnyLanguage, WSPLanguages::Table));

		else

			{

			// Otherwise the language is encoded as a short int, long int or token text

			TWspPrimitiveDecoder wspDecoder(rawData);

			switch( wspDecoder.VarType() )

				{

				case TWspPrimitiveDecoder::E7BitVal: // short int

				case TWspPrimitiveDecoder::ELengthVal: // long int

					{

					TUint32 languageToken = 0;

					User::LeaveIfError(wspDecoder.Integer(languageToken));

					// Check if the language token is short or long int as long requires an offset

					if( languageToken >= 128 )

						// Language token is long int so apply the offset

						--languageToken;

					SetFStringPartL(aHeader, ii, iStrPool.StringF(languageToken, WSPLanguages::Table));

					} break;

				case TWspPrimitiveDecoder::EString: // token text

					{

					// Extract the token text and set the part

					AddNewDecoderStringPartL(aHeader, wspDecoder, ii);

					} break;

				default:

					User::Leave(KErrCorrupt);

					break;

				}

			}

		++ii;

		startPos += (separatorPos + 1);

		} while( separatorPos != KErrNotFound );

	}

void CWspHeaderReader::DecodeContentMD5L(RHeaderField& aHeader) const

	{

	TPtrC8 rawData;

	aHeader.RawDataL(rawData);

	CheckLengthL(rawData, 1);

	TWspPrimitiveDecoder wspDecoder(rawData);

	if( wspDecoder.VarType() == TWspPrimitiveDecoder::ELengthVal )

		{

		TInt length = 0;

		TInt bytesRead = wspDecoder.LengthVal(length);

		User::LeaveIfError(bytesRead);

		TPtrC8 md5Data(rawData.Mid(bytesRead));

		if( md5Data.Length() != length )

			User::Leave(KErrCorrupt);

		SetNewStringPartL(aHeader, 0, md5Data);

		}

	else

		User::Leave(KErrCorrupt);

	}

void CWspHeaderReader::DecodeRetryAfterL(RHeaderField& aHeader) const

	{

	TPtrC8 rawData;