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

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

_LIT8(KCommaSpaceSep,", ");
_LIT8(KFieldSeparator, "\n");
_LIT8(KCodecSpace, " ");
_LIT8(KSemiSpaceSep," ;");

const TUint KCommaChar		= ',';
const TUint KSemiColonChar	= ';';
const TUint KEqualsChar		= '=';


CHttpServerHeaderReader* CHttpServerHeaderReader::NewL(RStringPool aStringPool)
	{
	return new (ELeave) CHttpServerHeaderReader(aStringPool);
	}

CHttpServerHeaderReader::~CHttpServerHeaderReader()
	{
	}

CHttpServerHeaderReader::CHttpServerHeaderReader(RStringPool aStringPool)
: CHttpHeaderReader(aStringPool)
	{
	}

// Helper to DoAcceptL(), DoAcceptCharsetL(), DoAcceptLanguageL() and DoAcceptEncodingL() 
// for comma-separated lists incorporating q-values..
// name : value, value; q= 2.2, value,...
void CHttpServerHeaderReader::DecodeGenericAcceptL(RHeaderField& aHeader, TInt aErrorCode) const
	{
	
	TPtrC8 rawData;
	aHeader.RawDataL(rawData);
	TInt remaining = rawData.Length();
	TPtrC8 token;
	TInt tokensFound = 0;
	while (remaining > 0)
		{
		remaining -= InetProtTextUtils::ExtractNextTokenFromList(rawData, token, KCommaChar);

		TInt pos = token.Locate(KSemiColonChar);
		if (pos < 0)
			{
			// No parameters. Just store the field value
			InetProtTextUtils::RemoveWhiteSpace(token, InetProtTextUtils::ERemoveBoth);
			SetNewFStringPartL(aHeader, tokensFound, token);
			}
		else if (pos==0)
			{
			// No valid q-value. Just store the parameter.
			User::Leave(aErrorCode);
			}
		else
			{
			// parameter value(s) exist.

			if (pos==token.Length())
				// if no field value exists. i.e. an invalid header
				User::Leave(aErrorCode);

			// store the field
			TPtrC8 fieldValue(token.Left(pos));
			TPtrC8 parameters(token.Mid(pos+1));
			InetProtTextUtils::RemoveWhiteSpace(fieldValue, InetProtTextUtils::ERemoveBoth);

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

			TPtrC8 thisParam;
			do {
				// check if there is another parameter
				pos = parameters.Locate(KSemiColonChar);
				if (pos > 0)
					{
					if (pos==token.Length())
						// if no field value exists. i.e. an invalid header
						User::Leave(aErrorCode);

					thisParam.Set(parameters.Left(pos));
					parameters.Set(parameters.Mid(pos+1));
					}
				else
					thisParam.Set(parameters);

				
				TInt pPos = thisParam.Locate(KEqualsChar);
				if (pPos <= 0 || pPos==thisParam.Length())
					// Invalid parameter, missing '=' char, or missing field value.
					User::Leave(aErrorCode);

				TPtrC8 paramField(thisParam.Left(pPos));
 				TPtrC8 paramData(thisParam.Mid(pPos + 1));

				SetNewFStringParamL(*part, paramField, paramData);

				} while (pos > 0);
			}
		++tokensFound;
		}
		
		
	}

void CHttpServerHeaderReader::DecodeAuthorizationL(RHeaderField& aHeader) const
	{
	// RFC2616, section 14.8;  RFC2617, section 
	// Authorization  = "Authorization" ":" credentials
	// credentials = auth-scheme #auth-param
	// credentials = "Basic" basic-credentials
	// basic-credentials = base64-user-pass
    // base64-user-pass  = <base64 [4] encoding of user-pass, except not limited to 76 char/line>
    // user-pass   = userid ":" password
    // userid      = *<TEXT excluding ":">
    // password    = *TEXT
	
	// Parts are encoded with no punctuation after them and parameters are comma
	// separated with the value in quotes. This means that for basic
	// authentication, part 1 must be 'Basic' and part 2 is the
	// credentials. For digest, part1 is 'Digest', and the digest
	// response is stored in parameters.

	TPtrC8 buffer;
	aHeader.RawDataL(buffer);

	TInt totalBytesConsumed = 0;
	TInt numParam = 0;
	CHeaderFieldPart* part = NULL;
	TBool done = EFalse;

	TPtrC8 token;
	TInt bytesConsumed = InetProtTextUtils::ExtractNextTokenFromList(buffer, token, KCommaSpaceSep);
	part = SetNewFStringPartL(aHeader, numParam, token);		//first assignment
	++numParam;
	
	TBool equalsPresent = (token.Locate('=') != KErrNotFound);
	if ((totalBytesConsumed == bytesConsumed) && equalsPresent)
		{
		// The first token has an equals sign in it. That
		// can't be as it has to be in an Authorization scheme
		User::Leave(KErrHttpDecodeAuthorization);
		}

	RStringF basic = iStrPool.StringF(HTTP::EBasic , RHTTPSession::GetTable());

	if (token==basic.DesC())
		{
		// Get next part and store away
		bytesConsumed = InetProtTextUtils::ExtractNextTokenFromList(buffer, token, KCommaSpaceSep);
		++numParam;
		if (bytesConsumed==0)
			{
			// Need a second value if "Basic"
			User::Leave(KErrHttpDecodeAuthorization);
			}

		// Remove surrounding quotes
		TPtrC8 val;
		if (token[0] == '"')
			{
			bytesConsumed += 
				InetProtTextUtils::ExtractQuotedStringL(token,val);
			}
		else
			{
			val.Set(token);
			}
		SetNewFStringPartL(aHeader, numParam - 1, val);	
		}
	else // Get Digest parameters. Should check if it is digest
		{
		while (!done)
			{
			TPtrC8 token;
			TInt bytesConsumed = InetProtTextUtils::ExtractNextTokenFromList(buffer, token, KCommaSpaceSep);

			done = (bytesConsumed == 0);
			if (done) 
				{
				if (numParam == 0)// if we didn't find _anything_ at all...
					User::Leave(KErrHttpDecodeAuthorization);
				}
			else if (token.Length() > 0)
				{
				totalBytesConsumed += bytesConsumed;

				if (token.Locate('=') == KErrNotFound)
					{
					// Got a new part. Add it.
					++numParam;
					part = SetNewFStringPartL(aHeader, numParam - 1, token);
					}
				else
					{
					TPtrC8 paramName;
					TPtrC8 paramVal;
					bytesConsumed += GetParamNameAndValueL(token, paramName, paramVal, KErrHttpDecodeBasicAuth);
					SetNewStringParamL(*part, paramName, paramVal);
					}
				}
			}
		}
	}

void CHttpServerHeaderReader::DecodeHostL(RHeaderField& aHeader) const
	{
	// RFC2616, section 14.23
    // Host = "Host" ":" host [ ":" port ] ; Section 3.2.2
	
	// Our convention will be that a string called HTTP::EPort will be used to
	// set a parameter holding the integer port number

	// We are looking for a hostname and optional port number, 0 or more values

	TPtrC8 rawData;
	aHeader.RawDataL(rawData);
	TInt remaining = rawData.Length();
	TPtrC8 token;
	TInt tokensFound =0;
	
	remaining -= InetProtTextUtils::ExtractNextTokenFromList(rawData, token, KFieldSeparator);

	if (remaining)
		{
		// Should not be more data
		}

	// Check for colon in our token
	TInt colonPos = token.Locate(':');
	InetProtTextUtils::RemoveWhiteSpace(token, InetProtTextUtils::ERemoveBoth);
	if (colonPos == KErrNotFound)
		{
		// Just a host name
		SetNewFStringPartL(aHeader, tokensFound, token);
		}
	else
		{
		//.. also has a port number. 

		TPtrC8 host(token.Left(colonPos));
		CHeaderFieldPart* part = SetNewFStringPartL(aHeader, tokensFound, host);

		if (colonPos==token.Length())
			// No port number supplied
			User::Leave(KErrHttpGeneralHeaderMissingHost);

		TPtrC8 port(token.Mid(colonPos + 1));
		TPtrC8 name(iStrPool.StringF(HTTP::EPort,RHTTPSession::GetTable()).DesC());
		SetNewFStringParamL(*part, name ,port);
		}
	}

void CHttpServerHeaderReader::DecodeExpectL(RHeaderField& aHeader) const
	{
	//	Expect       =  "Expect" ":" 1#expectation
	//
	//	expectation  =  "100-continue" | expectation-extension
	//	expectation-extension =  token [ "=" ( token | quoted-string )
	//	                         *expect-params ]
	//	expect-params =  ";" token [ "=" ( token | quoted-string ) ]

	TPtrC8 buffer;
	aHeader.RawDataL(buffer);

	TInt numParam = 0;

	TPtrC8 token;
	InetProtTextUtils::ExtractNextTokenFromList(buffer, token, KSemiSpaceSep);
	++numParam;
	
	SetNewFStringPartL(aHeader, 0, buffer);
	}

void CHttpServerHeaderReader::DecodeTEL(RHeaderField& aHeader) const
	{
	//	TE        = "TE" ":" #( t-codings )
	//	t-codings = "trailers" | ( transfer-extension [ accept-params ] )
	//	Examples of its use are:
	//	TE: deflate
	//	TE:
	//	TE: trailers, deflate;q=0.5
       
	DecodeGenericAcceptL(aHeader, KErrHttpDecodeTE);
	}
	
/*
 *	Methods from CHeaderReader
 */

void CHttpServerHeaderReader::DecodeHeaderL(RHeaderField& aHeader)
	{
	RStringF fieldStr = iStrPool.StringF(aHeader.Name());
	switch( fieldStr.Index(RHTTPSession::GetTable()) )
		{
	case HTTP::EAccept:
		DecodeGenericAcceptL(aHeader, KErrHttpDecodeAccept);
		break;
	case HTTP::EAcceptCharset:
		DecodeGenericAcceptL(aHeader, KErrHttpDecodeAcceptCharset);
		break;
	case HTTP::EAuthorization:
		DecodeAuthorizationL(aHeader);
		break;
	case HTTP::EAcceptLanguage:
		DecodeGenericAcceptL(aHeader, KErrHttpDecodeAcceptLanguage);
		break;
	case HTTP::EAcceptEncoding:
		DecodeGenericAcceptL(aHeader, KErrHttpDecodeAcceptEncoding);
		break;
	case HTTP::EHost:
		DecodeHostL(aHeader);
		break;
	case HTTP::EUserAgent:
		DecodeTokenListHeaderL(aHeader, KCodecSpace());
		break;
	case HTTP::EIfMatch:
		DecodeTokenListHeaderL(aHeader, KCommaSpaceSep());
		break;
	case HTTP::EIfNoneMatch:
		DecodeTokenListHeaderL(aHeader, KCommaSpaceSep());
		break;
	case HTTP::EIfModifiedSince:
		DecodeDateL(aHeader);
		break;
	case HTTP::EIfUnmodifiedSince:
		DecodeDateL(aHeader);
		break;
	case HTTP::EExpect:
		DecodeExpectL(aHeader);
		break;
	case HTTP::ETE:
		DecodeTEL(aHeader); 
		break;
	default:
		User::Leave(KErrNotSupported);
		}
	}