// Copyright (c) 2002-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 "chttpgeneralheaderwriter.h"

#include <http/rhttpsession.h>
#include <httpstringconstants.h>
#include <httperr.h>

#include "CHeaderField.h"

_LIT8(KSemiSpaceSep,"; ");

CHttpGeneralHeaderWriter* CHttpGeneralHeaderWriter::NewL(RStringPool aStringPool)
/** 
	Factory constructor.
	@internalComponent
	@param		aStringPool	The current string pool.
	@return		A pointer to a fully initialised object.
	@leave		KErrNoMemory	Not enough memory to create object.
*/
	{
	return new(ELeave)CHttpGeneralHeaderWriter(aStringPool);
	}

CHttpGeneralHeaderWriter::~CHttpGeneralHeaderWriter()
/**
	Destructor
	@internalComponent
*/
	{
	}

CHttpGeneralHeaderWriter::CHttpGeneralHeaderWriter(RStringPool aStringPool)
: CHttpHeaderWriter(aStringPool)
/**
	Constructor
	@internalComponent
	@param		aStringPool	The current string pool.
*/
	{
	}

void CHttpGeneralHeaderWriter::EncodeCacheControlL(RHeaderField& aHeader) const
/**
	Encodes a Cache-Control header. RFC 2616 section 14.9 - 

		Cache-Control			=	"Cache-Control" ":" 1#cache-directive
		cache-directive			=	cache-request-directive 
								|	cache-response-directive
		cache-request-directive	=	"no-cache" 
								|	"no-store" 
								|	"max-age" "=" delta-seconds
								|	"max-stale" [ "=" delta-seconds ] 
								|	"min-fresh" "=" delta-seconds 
								|	"no-transform" 
								|	"only-if-cached" 
								|	cache-extension

		cache-response-directive=	"public" 
								|	"private" [ "=" <"> 1#field-name <"> ] 
								|	"no-cache" [ "=" <"> 1#field-name <"> ]
								|	"no-store" 
								|	"no-transform"
								|	"must-revalidate"
								|	"proxy-revalidate"
								|	"max-age" "=" delta-seconds
								|	"s-maxage" "=" delta-seconds
								|	cache-extension

		cache-extension			=	token [ "=" ( token | quoted-string ) ]

	The cache-control header value is a comma separated list of values with at
	least one value.
	@internalComponent
	@param		aHeader	The cache-control header field to encode.
	@leave		CHttpWriter::DoTokenCsvListHeaderL
	@todo		Is there any point in this? Why not call DoTokenCsvListHeaderL()
				directly
*/
	{
	DoTokenCsvListHeaderL(aHeader, KErrHttpEncodeCacheControl);
	}

void CHttpGeneralHeaderWriter::EncodeConnectionL(RHeaderField& aHeader) const
/**
	Decodes the Connection header. RFC2616 section 14.10 - 

		Connection = "Connection" ":" 1#(connection-token)
		connection-token  = token
	The connection header value is a comma separated list of values with at least
	one value.
	@internalComponent
	@param		aHeader	The connection header field to encode.
	@leave		CHttpWriter::DoTokenCsvListHeaderL
	@todo		Is there any point in this? Why not call DoTokenCsvListHeaderL()
				directly
*/
	{
	DoTokenCsvListHeaderL(aHeader, KErrHttpEncodeConnection);
	}

void CHttpGeneralHeaderWriter::EncodeDateL(RHeaderField& aHeader) const
/**
	Encodes the date header. RFC2616 section 14.18 - 

		Date		=	"Date" ":" HTTP-Date

	The HTTP-Date format has a few formats. E.g. Date: Tue, 15 Nov 1994 08:12:31 GMT
	@internalComponent
	@param		aHeader	The date header field to encode.
	@leave		CHttpWriter::EncodeGenericDateL
	@todo		Is there any point in this? Why not call EncodeGenericDateL()
				directly
*/
	{
	EncodeGenericDateL(aHeader, KErrHttpEncodeDate);
	}

void CHttpGeneralHeaderWriter::EncodeTransferEncodingL(RHeaderField& aHeader) const
/**
	Encodes the transfer-encoding header. RFC2616 section 14.41 -

		Transfer-Encoding       =	"Transfer-Encoding" ":" 1#transfer-coding
		transfer-coding         =	"chunked" | transfer-extension
		transfer-extension      =	token *( ";" parameter )
		parameter               =	attribute "=" value
		attribute               =	token
		value                   =	token | quoted-string

	The transfer-encoding header is a comma separated list of values with at 
	least one value.
	@internalComponent
	@param		aHeader	The transfer-encoding header field to encode.
	@leave		CHttpWriter::DoTokenCsvListHeaderL
	@todo		Is there any point in this? Why not call DoTokenCsvListHeaderL()
				directly
*/
	{
	DoTokenCsvListHeaderL(aHeader, KErrHttpEncodeTransferEncoding);
	}

void CHttpGeneralHeaderWriter::EncodeContentTypeL(RHeaderField& aHeader) const
/**
	Encodes the content-type header. RFC2616 section 14.17

		Content-Type			=	"Content-Type" ":" media-type
		media-type				=	type "/" subtype *( ";" parameter )
		type					=	token
		subtype					=	token
		parameter				=	attribute '=' value
		attribute               =	token
		value                   =	token | quoted-string
	
	The content-type header has a single media-type value. The atttribute 
	is normally the 'charset'. E.g. Content-Type: text/html; charset=ISO-8859-4
	@internalComponent
	@param		aHeader	The content-type header field to encode.
	@leave		RHeaderField::BeginRawDataL
	@leave		RHeaderField::WriteRawDataL
	@leave		CHttpWriter::WriteRawStrFPartL
	@leave		KErrHttpEncodeContentType	There are no value tokens, the
											parameter was empty or the parameter
											was not a string type value.
*/
	{
  __START_PERFORMANCE_LOGGER();
	// Check part 1
	THeaderFieldPartIter iter = aHeader.PartsL();
	iter.First();
	if( iter.AtEnd() )
		{
		// The header value is empty!
		User::Leave(KErrHttpEncodeContentType);
		}
	aHeader.BeginRawDataL();
	const CHeaderFieldPart* part = WriteRawStrFPartL(aHeader, iter, KErrHttpEncodeContentType);

	// Check for parameters...
	THeaderFieldParamIter iter2 = part->Parameters();
	iter2.First();
	while( !iter2.AtEnd() )
		{
		// Got a parameter - write a semicolon separator
		aHeader.WriteRawDataL(KSemiSpaceSep);
		const CHeaderFieldParam* param = iter2();
		if( !param )
			{
			// Empty parameter!
			User::Leave(KErrHttpEncodeContentType);
			}
		// Anticipate only string parameter values
		THTTPHdrVal paramVal = param->Value();
		if( paramVal.Type() != THTTPHdrVal::KStrFVal )
			{
			// Was not a string value...
			User::Leave(KErrHttpEncodeContentType);
			}
		RStringF paramName = iStringPool.StringF(param->Name());
		aHeader.WriteRawDataL(paramName.DesC());
		aHeader.WriteRawDataL('=');
		aHeader.WriteRawDataL(paramVal.StrF().DesC());
		
		// Move onto the next parameter, writing a separator as necessary
		++iter2;
		}
	// All done!
	aHeader.CommitRawData();
	__END_PERFORMANCE_LOGGER(_L(",CHttpGeneralHeaderWriter::EncodeContentTypeL()"));
	}

void CHttpGeneralHeaderWriter::EncodeContentLengthL(RHeaderField& aHeader) const
/**
	Encodes the content-length header. RFC2616 section 14.13 - 

		Content-Length    = "Content-Length" ":" 1*DIGIT

	The content-length value is a number with at least one digit.
	@internalComponent
	@param		aHeader	The content-length header field to encode.
	@leave		CHttpWriter::EncodeGenericNumberHeaderL
	@todo		Is there any point in this? Why not call EncodeGenericNumberHeaderL()
				directly. 
*/
	{
	EncodeGenericNumberHeaderL(aHeader, KErrHttpEncodeContentLength);
	}

/*
 *	Methods from CHeaderWriter
 */

void CHttpGeneralHeaderWriter::EncodeHeaderL(RHeaderField& aHeader)
/**
	Encodes the header field value. 
	@internalComponent
	@param		aHeader		The header field to be encoded.
	@leave		CHttpGeneralHeaderWriter::EncodeCacheControlL
	@leave		CHttpGeneralHeaderWriter::EncodeConnectionL
	@leave		CHttpGeneralHeaderWriter::EncodeDateL
	@leave		CHttpGeneralHeaderWriter::EncodeTransferEncodingL
	@leave		CHttpGeneralHeaderWriter::EncodeContentLengthL
	@leave		CHttpWriter::DoTokenCsvListHeaderL
	@leave		KErrNotSupported	The writer was asked to encode a header that
									is does not support.
*/
	{
	RStringF fieldStr = iStringPool.StringF(aHeader.Name());
	switch( fieldStr.Index(iStringTable) )
		{
	case HTTP::ECacheControl:
		{
		EncodeCacheControlL(aHeader);
		} break;
	case HTTP::EConnection:
		{
		EncodeConnectionL(aHeader);
		} break;
	case HTTP::EDate:
		{
		EncodeDateL(aHeader);
		} break;
	case HTTP::EPragma:
		{
		// RFC2616 section 14.32 - 
		//
		//		Pragma				=	"Pragma" ":" 1#pragma-directive
		//		pragma-directive	=	"no-cache"	|	extension-pragma
		//		extension-pragma	=	token [ "=" ( token ! quoted-string ) ]
		//
		// The pragma header value is a comma separated list of values with at 
		// least one value.
		DoTokenCsvListHeaderL(aHeader, KErrHttpEncodePragma);
		} break;
	case HTTP::ETransferEncoding:
		{
		EncodeTransferEncodingL(aHeader);
		} break;
	case HTTP::EContentEncoding:
		{
		DoTokenCsvListHeaderL(aHeader, KErrHttpEncodeContentEncoding);
		} break;
	case HTTP::EContentLanguage:
		{
		// RFC2616 section 14.12 - 
		// 
		//		Content-Language	=	"Content-Language" ":" 1#language-tag
		// 
		// The content-language header value is a comma separated list of values
		// with at least one value.
		DoTokenCsvListHeaderL(aHeader, KErrHttpEncodeContentLanguage);
		} break;
	case HTTP::EUpgrade:
		{
		DoTokenCsvListHeaderL(aHeader, KErrHttpEncodeUpgrade);
		} break;
	case HTTP::EContentLength:
		{
		EncodeContentLengthL(aHeader);
		} break;
	case HTTP::EContentLocation:
		{
		DoTokenCsvListHeaderL(aHeader, KErrHttpEncodeContentLocation);
		} break;
	case HTTP::EContentMD5:
		{
		DoTokenCsvListHeaderL(aHeader, KErrHttpEncodeContentMD5);
		} break;
	case HTTP::EContentType:
		{
		EncodeContentTypeL(aHeader);
		} break;
	case HTTP::EExpires:
	case HTTP::ELastModified:
		{
		EncodeDateL(aHeader);
		}break;
	default:
		User::Leave(KErrNotSupported);
		break;
		}
	}