// Copyright (c) 2008-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 <upnp/tupnptable.h>
#include <inetprottextutils.h>
#include <upnp/upnpconstants.h>

#include "cupnpheaderreader.h"


_LIT8(KSemiSpaceSep," ;");
const TUint KOpenAngleBracket		= '<';
const TUint KCloseAngleBracket		= '>';
const TUint KCommaChar		= ',';
const TUint KSemiColonChar	= ';';
const TUint KEqualsChar		= '=';


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

CUPnPHeaderReader::~CUPnPHeaderReader()
	{
	// do nothing.
	}

void CUPnPHeaderReader::DecodeHeaderL(RHeaderField& aHeader)
	{
	RStringF fieldStr = iStringPool.StringF(aHeader.Name());
	switch( fieldStr.Index(TUPnPTable::Table()) )
		{
		case UPnP::ENTS:
		case UPnP::ENT:
		case UPnP::EST:
		case UPnP::EUSN:
		case UPnP::ESoapAction:
		case UPnP::ESID:
			DecodeGenericUpnpHeadersL(aHeader);	
			break;
		case UPnP::ETimeout:
			DecodeTimeoutHeaderL(aHeader);
			break;
		case UPnP::EExt:
			DecodeExtL(aHeader);
			break;
		case UPnP::EMX:
		case UPnP::ESEQ:
			DecodeGenericNumberL(aHeader);
			break;
		case UPnP::EMAN:
			DecodeManL(aHeader);
			break;
		case UPnP::ECallback:
			DecodeCallbackL(aHeader);
			break;
		default:
			User::Leave(KErrNotSupported);
		}	
	}

CUPnPHeaderReader::CUPnPHeaderReader(RStringPool aStringPool)
:iStringPool(aStringPool)
	{
	// do nothing.
	}

CHeaderFieldPart* CUPnPHeaderReader::SetNewPartL(RHeaderField& aHeader, TInt aPartIndex, THTTPHdrVal& aPartVal) const
	{
	CHeaderFieldPart* part = CHeaderFieldPart::NewL(aPartVal);
	CleanupStack::PushL(part);
	aHeader.SetPartL(part, aPartIndex);
	CleanupStack::Pop(part);
	return part;
	}

CHeaderFieldPart* CUPnPHeaderReader::SetNewFStringPartL(RHeaderField& aHeader, TInt aPartIndex, TPtrC8 aValue) const
	{
	RStringF partStr = iStringPool.OpenFStringL(aValue);
	CleanupClosePushL(partStr);
	THTTPHdrVal partVal(partStr);
	CHeaderFieldPart* part = SetNewPartL(aHeader, aPartIndex, partVal);
	CleanupStack::PopAndDestroy(&partStr);
	return part;
	}

CHeaderFieldPart* CUPnPHeaderReader::SetNewIntegerPartL(RHeaderField& aHeader, TInt aPartIndex, TInt aValue) const
	{
	THTTPHdrVal partVal(aValue);
	CHeaderFieldPart* part = SetNewPartL(aHeader, aPartIndex, partVal);
	return part;
	}

void CUPnPHeaderReader::DecodeGenericNumberL(RHeaderField& aHeader) const
	{
	TPtrC8 buffer;
	aHeader.RawDataL(buffer);
	TInt number = KErrNotFound;
	
	TInt decimalPos = buffer.Locate('.');
	if(decimalPos == 0)
		{
		// first character is decimal. So, set the value as zero.
		SetNewIntegerPartL(aHeader, 0, 0);
		}
	else
	   	{
		// Search for '\n' separator. In the case when a duplicate header has been received,
		// only use the fist instance of the valid data.
		TInt newLinePos = buffer.Locate('\n');
		if (newLinePos != KErrNotFound)
			{
			buffer.Set(buffer.Left(newLinePos));
			}
		
		TInt value = KErrNotFound;
		TInt ret = InetProtTextUtils::ConvertDescriptorToInt(buffer, value);
		if ( ret > KErrNone ) 
			{
			// Extract an integer.  Do not permit terminators other than WS or EOL.
			InetProtTextUtils::ExtractIntegerValueL(buffer, number, EFalse);	
			}
		SetNewIntegerPartL(aHeader, 0, number); // part 0, i.e. the first (and only) part
	   	}
	}

CHeaderFieldParam* CUPnPHeaderReader::SetNewFStringParamL(CHeaderFieldPart& aHeaderPart, TPtrC8 aParamName, TPtrC8 aParamValue) const
	{
	RStringF paramNameStr = iStringPool.OpenFStringL(aParamName);
	CleanupClosePushL(paramNameStr);
	RStringF paramValStr = iStringPool.OpenFStringL(aParamValue);
	CleanupClosePushL(paramValStr);
	THTTPHdrVal paramVal(paramValStr);
	CHeaderFieldParam* param = CHeaderFieldParam::NewL(paramNameStr, paramVal);
	CleanupStack::PushL(param);
	aHeaderPart.AddParamL(param);
	CleanupStack::Pop(param);
	CleanupStack::PopAndDestroy(2, &paramNameStr); // and paramValStr
	return param;
	}

void CUPnPHeaderReader::DecodeExtL(RHeaderField& aHeader) const
	{
	TPtrC8 nullPtr(KNullDesC8);
	SetNewFStringPartL(aHeader, 0, nullPtr);	
	}

void CUPnPHeaderReader::DecodeGenericUpnpHeadersL(RHeaderField& aHeader) const
	{
	TPtrC8 buffer;
	aHeader.RawDataL(buffer);
	
	// Search for '\n' separator. In the case when a duplicate header has been received,
	// only use the fist instance of the valid data.
	TInt newLinePos = buffer.Locate('\n');
	if (newLinePos != KErrNotFound)
		{
		buffer.Set(buffer.Left(newLinePos));
		}

	TPtrC8 token;
	InetProtTextUtils::ExtractNextTokenFromList(buffer, token, KSemiSpaceSep);
	SetNewFStringPartL(aHeader, 0, token); // part 0, i.e. the first (and only) part
	}

void CUPnPHeaderReader::DecodeTimeoutHeaderL(RHeaderField& aHeader) const
	{
	TPtrC8 buffer;
	aHeader.RawDataL(buffer);
	
	// Search for '\n' separator. In the case when a duplicate header has been received,
	// only use the fist instance of the valid data.
	TInt newLinePos = buffer.Locate('\n');
	if (newLinePos != KErrNotFound)
		{
		buffer.Set(buffer.Left(newLinePos));
		}
		
	RStringF infinite = iStringPool.StringF(UPnP::EInfinite, TUPnPTable::Table());
	if(buffer.Compare(infinite.DesC()) == 0)
		{
		SetNewIntegerPartL(aHeader, 0, -(KMaxTInt));	
		}
	
	else
		{
		TPtrC8 token;
		InetProtTextUtils::ExtractNextTokenFromList(buffer, token, KSemiSpaceSep);
		TInt consumed = token.Locate('-');
		token.Set(token.Mid(consumed+1));
		TInt intVal;
		InetProtTextUtils::ConvertDescriptorToInt(token, intVal);
		SetNewIntegerPartL(aHeader, 0, intVal); // part 0, i.e. the first (and only) part
		}
	}

void CUPnPHeaderReader::DecodeCallbackL(RHeaderField& aHeader) const
	{
	//Callback: <token1><token2><token3>...<tokenN>
	
	TPtrC8 rawData;
	aHeader.RawDataL(rawData);
	TInt remaining = rawData.Length();
	TPtrC8 token;
	TInt tokensFound = 0;
	TInt consumed;
	while (remaining)
		{
		// Locate and remove the '<' character from the token
		consumed = rawData.Locate(KOpenAngleBracket);
		if(consumed == KErrNotFound)
			{
			// No more tokens.
			break;	
			}
		// '<' character has now been removed.
		rawData.Set(rawData.Mid(consumed+1));
		// Now extract the value before '>' character. 
		// This will be the actual value of the token.
		remaining -= InetProtTextUtils::ExtractNextTokenFromList(rawData, token, KCloseAngleBracket);

		// No parameters. Just store the field value
		InetProtTextUtils::RemoveWhiteSpace(token, InetProtTextUtils::ERemoveBoth);
		SetNewFStringPartL(aHeader, tokensFound, token);
		++tokensFound;
		}
	}

void CUPnPHeaderReader::DecodeManL(RHeaderField& aHeader) 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 ns-value. Just store the parameter.
			User::Leave(KErrUPnPDecodeMAN);
			}
		else
			{
			// parameter value(s) exist.

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

			// 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(KErrUPnPDecodeMAN);

					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(KErrUPnPDecodeMAN);

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

				SetNewFStringParamL(*part, paramField, paramData);

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