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

#include <http/rhttpsession.h>

#include <httpstringconstants.h>

#include <httperr.h>

#include <inetprottextutils.h>

_LIT8(KCommaSpaceSep,", ");

_LIT8(KCommaNewline, ",\n");

_LIT8(KEqualQuote, "=\"");

CHttpGeneralHeaderReader* CHttpGeneralHeaderReader::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) CHttpGeneralHeaderReader(aStringPool);

	}

CHttpGeneralHeaderReader::~CHttpGeneralHeaderReader()

/**

	Destructor

	@internalComponent

*/	{

	}

CHttpGeneralHeaderReader::CHttpGeneralHeaderReader(RStringPool aStringPool)

: CHttpHeaderReader(aStringPool)

/**

	Constructor

	@internalComponent

	@param		aStringPool	The current string pool.

*/

	{

	}

void CHttpGeneralHeaderReader::DecodeCacheControlL(RHeaderField& aHeader) const

/**

	Decodes 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 decode.

	@leave		CHttpReader::DecodeGenericL

	@todo		Is there any point in this? Why not call DecodeGenericL() straight away

*/

	{

	TPtrC8 rawData;

	aHeader.RawDataL(rawData);

	TInt remaining = rawData.Length();

	TPtrC8 token;

	TInt tokensFound =0;

	RStringF maxAge = iStrPool.StringF(HTTP::EMaxAge, iStringTable);

	RStringF maxStale = iStrPool.StringF(HTTP::EMaxStale, iStringTable);

	RStringF minFresh = iStrPool.StringF(HTTP::EMinFresh, iStringTable);

	RStringF smaxAge = iStrPool.StringF(HTTP::ESMaxAge, iStringTable);

	while(remaining > 0)

	    {

		remaining -= InetProtTextUtils::ExtractNextTokenFromList(rawData, token, KCommaNewline());

		if(token.Locate('=') == KErrNotFound)

		   {

		  SetNewFStringPartL(aHeader, tokensFound, token);    

		   }

		else

		   {

		   CHeaderFieldPart*  part = SetNewFStringPartL(aHeader, tokensFound, KNullDesC8());

		   TPtrC8 paramName;

		   InetProtTextUtils::ExtractNextTokenFromList(token, paramName, '=');

		   if ( (paramName.Compare(maxAge.DesC()) == 0) ||

		   (paramName.Compare(maxStale.DesC()) == 0) ||

		   (paramName.Compare(minFresh.DesC()) == 0)||

		   (paramName.Compare(smaxAge.DesC()) == 0) )

		       { 

		       SetNewIntegerParamL(*part, paramName, token); 

		       }

		   else

		       {

		       SetNewFStringParamL(*part, paramName, token); 

		       } 

	       	   }

	 ++tokensFound; 

	    }

	}

void CHttpGeneralHeaderReader::DecodeConnectionL(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 decode.

	@leave		CHttpReader::DecodeGenericL

	@todo		Is there any point in this? Why not call DecodeGenericL() straight away

*/

	{

	DecodeGenericL(aHeader, KCommaNewline);

	}

void CHttpGeneralHeaderReader::DecodeTransferEncodingL(RHeaderField& aHeader) const

/**

	Decodes 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 decode.

	@leave		RHeaderField::RawDataL

	@leave		CHttpReader::SetNewFStringPartL

	@leave		CHttpReader::SetNewFStringParamL

	@leave		KErrHttpDecodeTransferEncoding	There was a transfer-extension

												with no token before the 

												parameter.

*/

	{

	TPtrC8 rawData;

	aHeader.RawDataL(rawData);

	TInt remaining = rawData.Length();

	TInt xfrCodingsFound = 0;

	// Iterate over the token list

	while( remaining > 0 )

		{

		// locate a token and set the new header part at the appropriate position.

		// Note - the token delimiter may be a '\n' or a ','

		TPtrC8 xfrCoding;

		remaining -= InetProtTextUtils::ExtractNextTokenFromList(rawData, xfrCoding, KCommaNewline);

		// Search for ';' separator to determine if there is a parameter within 

		// this transfer-coding. Don't bother check for 'chunked' per se, just 

		// treat it as equivalent to a transfer-extension which means we would

		// erroneously store parameters passed with 'chunked' (which the RFC doesn't allow)

		TInt pos = xfrCoding.Locate(';');

		if( pos == 0 )

			{

			// No transfer extension before the parameter pair!

			User::Leave(KErrHttpDecodeTransferEncoding);

			}

		if( pos == KErrNotFound )

			{

			// A transfer encoding with no parameter. Trim surrounding whitespace.

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

			// Create and set the new header part at position zero

			SetNewFStringPartL(aHeader, xfrCodingsFound, xfrCoding);

			}

		else

			{

			// Found the ';' separator - presumably a parameter/value pair.

			TPtrC8 xfrExtn;

			xfrExtn.Set(xfrCoding.Left(pos));

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

			// Set the transfer extension as a new header part

			CHeaderFieldPart* part = SetNewFStringPartL(aHeader, xfrCodingsFound, xfrExtn);

			// Get the param. Advance over the separator to the attrib-value pair.

			xfrCoding.Set(xfrCoding.Mid(pos + 1));

			// Search for '=' separator. If not found, then the param/value pair

			// is badly formed - ignore for the sake of robustness.

			pos = xfrCoding.Locate(TChar('='));

			if( pos > 0 ) // shortest parameter name, 1 char

				{

				TPtrC8 parameter;

				parameter.Set(xfrCoding.Left(pos));

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

				TPtrC8 paramValue;

				paramValue.Set(xfrCoding.Mid(pos + 1));

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

				// set the parameter of the header part

				SetNewFStringParamL(*part, parameter, paramValue);

				}

			}

		++xfrCodingsFound;

		}

	}

void CHttpGeneralHeaderReader::DecodeContentTypeL(RHeaderField& aHeader) const

/**

	Decodes 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 decode.

	@leave		RHeaderField::RawDataL

	@leave		CHttpReader::SetNewFStringPartL

	@leave		CHttpReader::SetNewFStringParamL

	@leave		KErrHttpDecodeContentType	There was a transfer-extension with 

											no token before the parameter.

*/

	{

	TPtrC8 rawData;

	aHeader.RawDataL(rawData);

	TInt remaining = rawData.Length();

	// Search for '\n' separator. In the case when a duplicate header has been received,

	// only use the first instance of the valid data.

	TInt newLinePos = rawData.Locate('\n');

	if (newLinePos != KErrNotFound)

		{

		rawData.Set(rawData.Left(newLinePos));

		}

	// Search for ';' separator

	TInt pos = rawData.Locate(TChar(';'));

	if( pos == 0 )

		{

		// No media type!

		User::Leave(KErrHttpDecodeContentType);

		}

	if( pos == KErrNotFound )

		{

		// Media type only - no parameter. Trim surrounding whitespace.

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

		// create and set the new header part at position zero

		SetNewFStringPartL(aHeader, 0, rawData);

		}

	else

		{

		// found the separator; there is presumably a parameter/value pair

		TPtrC8 mediaType;

		mediaType.Set(rawData.Left(pos));

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

		// set the media type as a new header part

		CHeaderFieldPart* part = SetNewFStringPartL(aHeader, 0, mediaType); // part 0, i.e. the first (and only) part

		// get the param

		remaining -= pos;

		if (remaining <= 0)

			User::Leave(KErrHttpDecodeContentType);

		rawData.Set(rawData.Mid(pos + 1)); // move rawData onto the string after the ; char

		TPtrC8 token;

		while (remaining > 0)

			{

			remaining -= InetProtTextUtils::ExtractNextTokenFromList(rawData, token, ';');

			if (!token.Length())

				{

				// no more tokens.

				break;

				}

			SetParamNameAndValueL(*part, token, ETrue);

			}

		}

	}

void CHttpGeneralHeaderReader::DecodeContentDispositionL(RHeaderField& aHeader) const

/**

	Decodes the content-dispostion header. RFC2183 section 2

		disposition				:=	"Content-Disposition" ":" 

									disposition-type

									*(";" disposition-parm)

		disposition-type		:=	"inline"

									/ "attachment"

									/ extension-token 

									; values are not case-sensitive

		disposition-param		:=	filename-parm

                       				/ creation-date-parm

                       				/ modification-date-parm

                       				/ read-date-parm

                       				/ size-parm

                       				/ parameter

		filename-parm 			:= 	"filename" "=" value

     	creation-date-parm 		:= 	"creation-date" "=" quoted-date-time

     	modification-date-parm 	:= 	"modification-date" "=" quoted-date-time

     	read-date-parm 			:= 	"read-date" "=" quoted-date-time

     	size-parm 				:= 	"size" "=" 1*DIGIT

     	quoted-date-time 		:= 	quoted-string

                      				; contents MUST be an RFC 822 `date-time'

                      				; numeric timezones (+HHMM or -HHMM) MUST be used

	@internalComponent

	@param		aHeader	The content-disposition header field to decode.

	@leave		RHeaderField::RawDataL

	@leave		CHttpReader::SetNewFStringPartL

	@leave		CHttpReader::SetNewFStringParamL

	@leave		KErrHttpDecodeContentDisposition	There was a transfer-extension with 

											no token before the parameter.

*/

	{

	TPtrC8 rawData;

	aHeader.RawDataL(rawData);

	TInt remaining = rawData.Length();

	// Search for '\n' separator. In the case when a duplicate header has been received,

	// only use the first instance of the valid data.

	TInt newLinePos = rawData.Locate('\n');

	if (newLinePos != KErrNotFound)

		{

		rawData.Set(rawData.Left(newLinePos));

		}

	// Search for ';' separator

	TInt pos = rawData.Locate(TChar(';'));

	if( pos == 0 )

		{

		// No disposition type!

		User::Leave(KErrHttpDecodeContentDisposition);

		}

	if( pos == KErrNotFound )

		{

		// Disposition type only - no parameter. Trim surrounding whitespace.

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

		// create and set the new header part at position zero

		SetNewFStringPartL(aHeader, 0, rawData);

		}

	else

		{

		// found the separator; there is presumably a parameter/value pair

		TPtrC8 mediaType;

		mediaType.Set(rawData.Left(pos));

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

		// set the disposition type as a new header part

		CHeaderFieldPart* part = SetNewFStringPartL(aHeader, 0, mediaType); // part 0, i.e. the first (and only) part

		// get the param

		remaining -= pos;

		if (remaining <= 0)

			{

			User::Leave(KErrHttpDecodeContentDisposition); 

			}

		rawData.Set(rawData.Mid(pos + 1)); // move rawData onto the string after the ; char

		while (remaining > 0)

			{

				if ( rawData.Find(KEqualQuote) != KErrNotFound )

				{			     			     

				TPtrC8 rawDataBuf;

				rawDataBuf.Set(rawData);

				TPtrC8 param;		

				InetProtTextUtils::ExtractNextTokenFromList(rawDataBuf, param, '=');

				TPtrC8 paramVal;					  

				if(rawDataBuf.Locate('"') == 0)

				{				   					 

					// Go past the first '"' after the '='

					rawDataBuf.Set(rawDataBuf.Mid(rawDataBuf.Locate('"')+1));

					if ( rawDataBuf.Length() > 0)  

					{

						InetProtTextUtils::ExtractNextTokenFromList(rawDataBuf, paramVal, '"');

					rawData.Set(rawDataBuf);

					if (rawData.Locate(';') != KErrNotFound)

					{

					// Go past the ';' character.

					rawData.Set(rawData.Mid(1));

					}

					SetNewFStringParamL(*part, param, paramVal);

					}

					else

					{

					// No value for the param, so set an empty param.

					SetNewFStringParamL(*part, param, KNullDesC8());	

					}

				}

				else

				{

					InetProtTextUtils::ExtractNextTokenFromList(rawDataBuf, paramVal, ';');

					rawData.Set(rawDataBuf);

					SetNewFStringParamL(*part, param, paramVal);			    

				}

				}

				else

				{

					TPtrC8 token;

					remaining -= InetProtTextUtils::ExtractNextTokenFromList(rawData, token,';' );				

					if (!token.Length())

					{

					// no more tokens.

					break;

					}

					SetParamNameAndValueL(*part, token, ETrue);

				}

			}			

		}

	}

/*

 *	Methods from CHeaderReader

 */

void CHttpGeneralHeaderReader::DecodeHeaderL(RHeaderField& aHeader)

/** 

	Decodes the raw header field value.

	@internalComponent

	@param		aHeader		The header field to decode.

	@leave		CHttpGeneralHeaderReader::DecodeCacheControlL

	@leave		CHttpGeneralHeaderReader::DecodeConnectionL

	@leave		CHttpGeneralHeaderReader::DecodeContentTypeL

	@leave		CHttpReader::DecodeDateL

	@leave		CHttpReader::DecodeGenericL

	@leave		CHttpReader::DecodeGenericNumberL

	@leave		KErrNotSupported	The reader was asked to decode a header that

									is does not support.

*/

	{

	RStringF fieldStr = iStrPool.StringF(aHeader.Name());

	switch( fieldStr.Index(iStringTable) )

		{

	case HTTP::ECacheControl:

		{

		DecodeCacheControlL(aHeader);

		} break;

	case HTTP::EConnection:

		{

		DecodeConnectionL(aHeader);

		} break;

	case HTTP::EDate:

	case HTTP::EExpires:

		{

		DecodeDateL(aHeader);

		} break;

	case HTTP::EPragma:

	case HTTP::EContentLanguage:

	case HTTP::EContentLocation: 	// Only expect one value

	case HTTP::EContentMD5: 		// Only expect one value

	case HTTP::EUpgrade:

		{

		DecodeGenericL(aHeader, KCommaNewline());

		} break;

	case HTTP::ETransferEncoding:

		{

		DecodeTransferEncodingL(aHeader);

		} break;

	case HTTP::EContentEncoding:

		{

		DecodeTokenListHeaderL(aHeader, KCommaSpaceSep());

		} break;

	case HTTP::EContentLength:

		{

		DecodeGenericNumberL(aHeader);

		} break;

	case HTTP::EContentType:

		{

		DecodeContentTypeL(aHeader);

		} break;

	case HTTP::EContentDisposition:

		{

		DecodeContentDispositionL(aHeader);	

		} break;

	default:

		User::Leave(KErrNotSupported);