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

const TInt KOffset = 1;				// Offset as the WspLanguages string table does not have 0x80 in it

const TInt KShortIntLimit = 128;	// A short integer can be within the range of 0-127

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

	{

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

	}

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

	{

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

	CleanupStack::PushL(self);

	return self;

	}

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

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

	{

	}

CWspHeaderWriter::~CWspHeaderWriter()

	{

	}

void CWspHeaderWriter::EncodeHeaderL(RHeaderField& aHeader)

	{

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

		{

		case WSP::EAccept:

			{

			EncodeAcceptL(aHeader);

			} break;

		case WSP::EAcceptCharsetDep:

		case WSP::EAcceptCharset:

			{

			EncodeAcceptCharsetL(aHeader);

			} break;

		case WSP::EAcceptEncodingDep:

		case WSP::EAcceptEncoding:

			{

			EncodeAcceptEncodingL(aHeader);

			} break;

		case WSP::EAcceptLanguage:

			{

			EncodeAcceptLanguageL(aHeader);

			} break;

		case WSP::EAllow:

			{

			EncodeAllowL(aHeader);

			} break;

		case WSP::EAuthorization:

			{

			EncodeAuthorizationL(aHeader);

			} break;

		case WSP::EContentEncoding:

			{

			EncodeContentEncodingL(aHeader);

			} break;

		case WSP::EContentLanguage:

			{

			EncodeContentLanguageL(aHeader);

			} break;

		case WSP::EContentLocation:

		case WSP::EFrom:

		case WSP::EProfile:

		case WSP::EReferer:

		case WSP::EUpgrade:

		case WSP::EUserAgent:

		case WSP::EVia:

			{

			GenericEncodeTextStringL(aHeader);

			} break;

		case WSP::EContentMD5:

			{

			EncodeContentMD5L(aHeader);

			} break;

		case WSP::EContentRangeDep:

		case WSP::EContentRange:

			{

			EncodeContentRangeL(aHeader);

			} break;

		case WSP::EContentType:

			{

			EncodeContentTypeL(aHeader);

			} break;

		case WSP::ECookie:

			{

			EncodeCookieL(aHeader);

			} break;

		case WSP::EDate:

		case WSP::ELastModified:

			{

			GenericEncodeDateL(aHeader);

			} break;

		case WSP::EEncodingVersion:

			{

			EncodeEncodingVersionL(aHeader);

			} break;

		case WSP::EExpect:

			{

			EncodeExpectL(aHeader);

			} break;

		case WSP::EPragma:

			{

			EncodePragmaL(aHeader);

			} break;

		case WSP::EProfileDiff:

			{

			EncodeProfileDiffL(aHeader);

			} break;

		case WSP::ERange:

			{

			EncodeRangeL(aHeader);

			} break;

		case WSP::ETE:

			{

			EncodeTEL(aHeader);

			} break;

		case WSP::ETrailer:

			{

			EncodeTrailerL(aHeader);

			} break;

		case WSP::EWarning:

			{

			EncodeWarningL(aHeader);

			} break;

		case WSP::EXWapApplicationId:

			{

			EncodeXWapApplicationIdL(aHeader);

			} break;

		default:

			User::Leave(KErrNotSupported);

			break;

		}

	}

void CWspHeaderWriter::EncodeAcceptL(RHeaderField& aHeader) const

	{

	THeaderFieldPartIter partIter = aHeader.PartsL();

	partIter.First();

	CWspHeaderEncoder* encoder = CWspHeaderEncoder::NewL();

	CleanupStack::PushL(encoder);

	TInt token = EncodeFieldName(aHeader.Name());

	TInt partCount = 0;

	TBool requireValueLength = EFalse;

	aHeader.BeginRawDataL();

	while (!partIter.AtEnd())

		{

		if (token == KErrNotFound)

			encoder->StartHeaderL(aHeader.Name().DesC());

		else

			encoder->StartHeaderL((TUint8)token);

		const CHeaderFieldPart* part = partIter();

		if (part != NULL)

			{

			++partCount;

			TInt numParam = part->NumParameters();

			if (numParam > 0)

				{

				requireValueLength = ETrue;

				encoder->StartValueLengthL();

				}

			THTTPHdrVal value = part->Value();

			if (value.Type() == THTTPHdrVal::KStrFVal)

				{

				TInt typeValue = EncodeContentTypeValue(value);

				if (typeValue < KShortIntLimit && typeValue > KErrNotFound)

					encoder->AddShortIntL((TUint8)typeValue);

				else if (typeValue == KErrNotFound)

					{

					TInt registeredValue = value.StrF().Index(WSPRegContentTypes::Table);

					if (registeredValue > KErrNotFound)

						{

						if (!requireValueLength)

							{

							encoder->StartValueLengthL();

							requireValueLength = ETrue;

							}

						const TInt KContentTypeOffset = 0x0201;	// Offset for the Registered Content Type value string table

						encoder->AddLongIntL(registeredValue + KContentTypeOffset);

						}

					else if (registeredValue == KErrNotFound)

						{

						User::LeaveIfError(CheckTextString(value.StrF()));

						encoder->AddTextStringL(value.StrF().DesC());

						}

					}

				THeaderFieldParamIter paramIter = part->Parameters();

				paramIter.First();

				while (!paramIter.AtEnd())

					{

					const CHeaderFieldParam* param = paramIter();

					if (param != NULL)

						EncodeParameterL(*param, *encoder);

					++paramIter;

					}

				if (requireValueLength)

					encoder->EndValueLengthL();

				}

			else

				User::Leave(KErrCorrupt);

			}

		HBufC8* buffer = encoder->EndHeaderL();

		CleanupStack::PushL(buffer);

		TInt startPos = 0;

		// If there is more than one header part it is necessary to append the name of the

		// header to the buffer

		if (partCount == 1)

			startPos = EncodeHeaderNameL(aHeader);

		TPtrC8 data(buffer->Mid(startPos));

		aHeader.WriteRawDataL(data);

		CleanupStack::PopAndDestroy(buffer);

		++partIter;

		}

	aHeader.CommitRawData();

	CleanupStack::PopAndDestroy(encoder);

	}

void CWspHeaderWriter::EncodeAcceptCharsetL(RHeaderField& aHeader) const

	{

	THeaderFieldPartIter partIter = aHeader.PartsL();

	partIter.First();

	aHeader.BeginRawDataL();

	CWspHeaderEncoder* encoder = CWspHeaderEncoder::NewL();

	CleanupStack::PushL(encoder);

	TInt token = EncodeFieldName(aHeader.Name());

	TInt partCount = 0;

	while (!partIter.AtEnd())

		{

		if (token == KErrNotFound)

			encoder->StartHeaderL(aHeader.Name().DesC());

		else

			encoder->StartHeaderL((TUint8)token);

		TBool requireValueLength = EFalse;

		const CHeaderFieldPart* part = partIter();

		if (part != NULL)

			{

			++partCount;

			TInt numParam = part->NumParameters();

			if (numParam > 0)

				{

				requireValueLength = ETrue;

				encoder->StartValueLengthL();

				}

			THTTPHdrVal value = part->Value();

			if (value.Type() == THTTPHdrVal::KStrFVal)

				{

				// Check for '*' (Any-charset) and that the WSP version is greater than 1.2

				if ((value.StrF().Index(WSPStdConstants::Table) == WSPStdConstants::EAny) 

					&& (iCodec.GetWspVersion() > CWspHeaderCodec::EVersion1_2))

					{

					encoder->AddTokenL(128);		// '*' is encoded as <Octet 128>

					}

				else

					{

					TInt charValue = GetCharacterSetValue(value.StrF());

					switch(charValue)

						{

						case KErrNotFound:

							{

							User::LeaveIfError(CheckTextString(value.StrF()));

							encoder->AddTextStringL(value.StrF().DesC());

							} break;

						default:

							{

							if (charValue < KShortIntLimit)

								encoder->AddShortIntL((TUint8)charValue);

							else

								{

								if (!requireValueLength)

									{

									encoder->StartValueLengthL();

									requireValueLength = ETrue;

									}

								encoder->AddLongIntL(charValue);

								}

							} break;

						}

					}

				// Check if we have any parameters

				THeaderFieldParamIter paramIter = part->Parameters();

				paramIter.First();

				while (!paramIter.AtEnd())

					{

					const CHeaderFieldParam* param = paramIter();

					THTTPHdrVal paramValue = param->Value();

					HBufC8* qValue = EncodeQValueL(paramValue.StrF());

					CleanupStack::PushL(qValue);

					if (qValue != NULL)

						encoder->AddDataL(*qValue);

					++paramIter;

					CleanupStack::PopAndDestroy(qValue);

					}

				}

			else

				User::Leave(KErrCorrupt);

			}

		// If we have a Q-value then we need to calculate the value-length

		if (requireValueLength)

			encoder->EndValueLengthL();

		HBufC8* buffer = encoder->EndHeaderL();

		CleanupStack::PushL(buffer);

		TInt startPos = 0;		

		// If there is more than one header part it is necessary to append the name of the

		// header to the buffer

		if (partCount == 1)

			startPos = EncodeHeaderNameL(aHeader);

		TPtrC8 data(buffer->Mid(startPos));

		aHeader.WriteRawDataL(data);

		CleanupStack::PopAndDestroy(buffer);

		++partIter;

		}

	aHeader.CommitRawData();

	CleanupStack::PopAndDestroy(encoder);

	}

void CWspHeaderWriter::EncodeAcceptEncodingL(RHeaderField& aHeader) const

	{

	THeaderFieldPartIter partIter = aHeader.PartsL();

	partIter.First();

	TInt partCount = 0;

	CWspHeaderEncoder* encoder = CWspHeaderEncoder::NewL();

	CleanupStack::PushL(encoder);

	TInt token = EncodeFieldName(aHeader.Name());	

	aHeader.BeginRawDataL();

	while (!partIter.AtEnd())

		{

		if (token == KErrNotFound)

			encoder->StartHeaderL(aHeader.Name().DesC());

		else

			encoder->StartHeaderL((TUint8)token);

		TBool requireValueLength = EFalse;

		const CHeaderFieldPart* part = partIter();

		if (part != NULL)

			{

			++partCount;

			TInt numParam = part->NumParameters();

			if (numParam > 0)

				{

				requireValueLength = ETrue;

				encoder->StartValueLengthL();

				}

			THTTPHdrVal value = part->Value();

			if (value.Type() == THTTPHdrVal::KStrFVal)

				{

				TInt encValue = value.StrF().Index(WSPStdConstants::Table);

				// Check for '*' (Any-encoding) and that the WSP version is greater than 1.2

				if ((encValue == WSPStdConstants::EAny) 

					&& (iCodec.GetWspVersion() > CWspHeaderCodec::EVersion1_2))

					{

					if (!requireValueLength)

						{

						encoder->StartValueLengthL();

						requireValueLength = ETrue;

						}

					encoder->AddTokenL(131);				// '*' is encoded as <Octet 131>

					}

				else

					{

					switch(encValue)

						{

						case WSPStdConstants::EGzip:		// Gzip is encoded as <Octet 128>

							{

							encoder->AddTokenL(128);

							} break;

						case WSPStdConstants::ECompress:	// Compress is encoded as <Octet 129>

							{

							encoder->AddTokenL(129);

							} break;

						case WSPStdConstants::EDeflate:		// Deflate is encoded as <Octet 130>

							{

							encoder->AddTokenL(130);

							} break;

						default:

							{

							encoder->AddTokenTextL(value.StrF().DesC());

							} break;

						}

					}

				THeaderFieldParamIter paramIter = part->Parameters();

				paramIter.First();

				while (!paramIter.AtEnd())

					{

					const CHeaderFieldParam* param = paramIter();

					THTTPHdrVal paramValue = param->Value();

					HBufC8* qValue = EncodeQValueL(paramValue.StrF());

					CleanupStack::PushL(qValue);

					if (qValue != NULL)

						encoder->AddDataL(*qValue);

					CleanupStack::PopAndDestroy(qValue);

					++paramIter;

					}

				}

			else

				User::Leave(KErrCorrupt);

			}

		if (requireValueLength)

			encoder->EndValueLengthL();

		HBufC8* buffer = encoder->EndHeaderL();

		CleanupStack::PushL(buffer);

		TInt startPos = 0;	

		// If there is more than one header part it is necessary to append the name of the

		// header to the buffer

		if (partCount == 1)

			startPos = EncodeHeaderNameL(aHeader);

		TPtrC8 data(buffer->Mid(startPos));

		aHeader.WriteRawDataL(data);

		CleanupStack::PopAndDestroy(buffer);

		++partIter;

		}

	aHeader.CommitRawData();

	CleanupStack::PopAndDestroy(encoder);

	}

void CWspHeaderWriter::EncodeAcceptLanguageL(RHeaderField& aHeader) const

	{

	THeaderFieldPartIter partIter = aHeader.PartsL();

	partIter.First();

	TInt partCount = 0;

	CWspHeaderEncoder* encoder = CWspHeaderEncoder::NewL();

	CleanupStack::PushL(encoder);

	TInt token = EncodeFieldName(aHeader.Name());

	aHeader.BeginRawDataL();

	while (!partIter.AtEnd())

		{

		if (token == KErrNotFound)

			encoder->StartHeaderL(aHeader.Name().DesC());

		else

			encoder->StartHeaderL((TUint8)token);

		TBool requireValueLength = EFalse;

		const CHeaderFieldPart* part = partIter();

		if (part != NULL)

			{

			++partCount;

			TInt numParam = part->NumParameters();

			if (numParam > 0)

				{

				requireValueLength = ETrue;

				encoder->StartValueLengthL();

				}

			THTTPHdrVal value = part->Value();

			if (value.Type() == THTTPHdrVal::KStrFVal)

				{

				TInt langValue = value.StrF().Index(WSPLanguages::Table);

				switch(langValue)

					{

					case WSPLanguages::EAnyLanguage:

						{

						encoder->AddTokenL(128);		// '*' (Any-language) is encoded as <Octet 128>

						} break;

					case KErrNotFound:

						{

						User::LeaveIfError(CheckTextString(value.StrF()));

						encoder->AddTextStringL(value.StrF().DesC());

						} break;

					default:

						{

						if (langValue < KShortIntLimit)

							encoder->AddShortIntL((TUint8)langValue);

						else

							{

							if (!requireValueLength)

								{

								encoder->StartValueLengthL();

								requireValueLength = ETrue;

								}

							encoder->AddLongIntL(langValue + KOffset);

							}

						} break;

					}

				THeaderFieldParamIter paramIter = part->Parameters();

				paramIter.First();

				while (!paramIter.AtEnd())

					{

					const CHeaderFieldParam* param = paramIter();

					THTTPHdrVal paramValue = param->Value();

					HBufC8* qValue = EncodeQValueL(paramValue.StrF());

					CleanupStack::PushL(qValue);

					if (qValue != NULL)

						encoder->AddDataL(*qValue);

					++paramIter;

					CleanupStack::PopAndDestroy(qValue);

					}

				}

			else

				User::Leave(KErrCorrupt);

			}

		if (requireValueLength)