// 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 <wspdecoder.h>
#include <wsperror.h>

// User includes
#include "wsppanic.h"

// Class signature
#include "cwspheaderutils.h"

// Constants used in this file
const TInt KDefaultSessionHeadersBufferSize		= 512;
const TInt KByteLength							= 1;

const TUint8 KNullTerminator					= 0x00;
const TUint8 KConvertToShortInt					= 0x80;

LOCAL_C void StringArrayCleanup(TAny* aStringArray);

CWspHeaderUtils* CWspHeaderUtils::NewL(CWspHeaderCodec& aCodec)
	{
	return new(ELeave) CWspHeaderUtils(aCodec);
	}

CWspHeaderUtils::CWspHeaderUtils(CWspHeaderCodec& aCodec)
	:iCodec(aCodec)
	{
	}

CWspHeaderUtils::~CWspHeaderUtils()
	{
	}

HBufC8* CWspHeaderUtils::EncodeHeadersL(RStringPool aStringPool, RHTTPHeaders aHeaders)
	{
	// Create a buffer for the encoded headers
	HBufC8* buf = HBufC8::NewL(KDefaultSessionHeadersBufferSize);
	CleanupStack::PushL(buf);

	// Encode the content-type header if it exists
	TBool hasContentType = EncodeContentTypeL(aStringPool, aHeaders, buf);

	// Go through the headers
	THTTPHdrFieldIter fields = aHeaders.Fields();
	fields.First();
	while( fields.AtEnd() == EFalse )
		{
		// Get the field value
		RStringF headerField = aStringPool.StringF(fields());

		// Was there a content-type header present? Make sure that it is not
		// appended a second time.
		TInt headerFieldValue = iCodec.EncodeFieldName(headerField);
		if( !hasContentType || headerFieldValue != WSP::EContentType )
			{
			// Encode the header field
			EncodeHeaderFieldL(aHeaders, headerField, buf);
			}
		// Next header field
		++fields;
		}
	// Cleanup...
	CleanupStack::Pop(buf);
	return buf;
	}

HBufC8* CWspHeaderUtils::EncodeNoTrailerHeadersL(RStringPool aStringPool, RHTTPHeaders aHeaders, HBufC8*& aTrailerData)
	{
	// Need an array of RStringFs for the headers in the trailers - need to put 
	// on the cleanup stack
	RArray<RStringF> trailerHeaders;
	TCleanupItem arrayCleaner = TCleanupItem(&StringArrayCleanup, (TAny*) &trailerHeaders);
	CleanupStack::PushL(arrayCleaner);

	// Need to find out what headers are in the trailers
	THTTPHdrVal trailerHeaderVal;
	TInt index =0;
	while( aHeaders.GetField(
							aStringPool.StringF(WSP::ETrailer, WSP::Table),
							index,		// Zero index -> first part
							trailerHeaderVal
							) != KErrNotFound )
		{
		__ASSERT_DEBUG( trailerHeaderVal.Type() == THTTPHdrVal::KStrFVal, Panic(KWspPanicBadTrailerHeader) );

		// Got a trailer header - append to the list
		RStringF header = trailerHeaderVal.StrF();
		User::LeaveIfError(trailerHeaders.Append(header));

		// Need to increment the reference count of this string
		header.Copy();

		// Next...
		++index;
		}
	__ASSERT_DEBUG( trailerHeaders.Count() > 0, Panic(KWspPanicNoTrailerHeaders) );

	// Create a buffer for the encoded headers
	HBufC8* bufHdrs = HBufC8::NewL(KDefaultSessionHeadersBufferSize);
	CleanupStack::PushL(bufHdrs);

	// Encode the content-type header if it exists
	TBool hasContentType = EncodeContentTypeL(aStringPool, aHeaders, bufHdrs);

	// Ok, now encode all the headers bar the ones in trailerHeaders
	// Go through the headers
	THTTPHdrFieldIter fields = aHeaders.Fields();
	fields.First();
	while( fields.AtEnd() == EFalse )
		{
		// Get the header field 
		RStringF headerField = aStringPool.StringF(fields());

		// Was there a content-type header present? Make sure that it is not
		// appended a second time, and only append if this is a trailer header.
		TInt headerFieldValue = iCodec.EncodeFieldName(headerField);
		if( !IsTrailerHeader(trailerHeaders, headerField) && 
			(!hasContentType || headerFieldValue != WSP::EContentType) )
			{
			// Encode the field
			EncodeHeaderFieldL(aHeaders, headerField, bufHdrs);
			}
		// Next header field
		++fields;
		}
	// Now, need to encode the trailer headers. Create a buffer for the trailer 
	// headers
	HBufC8* bufTrls = HBufC8::NewL(KDefaultSessionHeadersBufferSize);
	CleanupStack::PushL(bufTrls);

	TInt count = trailerHeaders.Count();
	for( TInt i=0; i < count; ++i)
		{
		// Encode the header field
		EncodeHeaderFieldL(aHeaders, trailerHeaders[i], bufTrls);
		}
	// Pass back the encoded trailer headers and other headers
	aTrailerData = bufTrls->ReAllocL(bufTrls->Des().Length());

	// Cleanup...
	CleanupStack::Pop(2, bufHdrs);
	CleanupStack::PopAndDestroy(&trailerHeaders);

	return bufHdrs;
	}

void CWspHeaderUtils::DecodeReplyHeadersL(RStringPool aStringPool, const TDesC8& aEncodedData, RHTTPHeaders& aHeaders)
	{
	// Ok, the data should have a content-type header at the start, but without
	// the header field name - straight onto the field value. The type of the 
	// first byte will give the length of the field value.
	TWspPrimitiveDecoder decoder = TWspPrimitiveDecoder(aEncodedData);

	TInt dataLength = 0;
	switch( decoder.VarType() )
		{
	case TWspPrimitiveDecoder::ELengthVal:
		{
		// The content-type header follows the BNF - 
		//
		// content-type-value = content-general-form = value-length media-type

		// The length of the data has been specified - extra it and include the
		// length of value-length
		TInt consumed = decoder.LengthVal(dataLength);
		dataLength += consumed;
		} break;
	case TWspPrimitiveDecoder::EString:
		{
		// The content-type header follows the BNF - 
		//
		// content-type-value = constrained-media = extension-media = *TEXT end-of-string
		
		// The end of the string is give by a NULL terminator
		TInt endPos = aEncodedData.Locate(KNullTerminator);
		if( endPos == KErrNotFound )
			{
			// The header data is corrupt
			User::Leave(KErrCorrupt);
			}
		dataLength = endPos + 1;
		} break;
	case TWspPrimitiveDecoder::E7BitVal:
		{
		// The content-type header follows the BNF - 
		//
		// content-type-value = constrained-media = short-integer = OCTET

		// The header data is a single byte long
		dataLength = KByteLength;
		} break;
	default:
		// The header data is corrupt
		User::Leave(KErrCorrupt);
		break;
		}
	// Set the content type field value
	TPtrC8 contentTypeValue = aEncodedData.Left(dataLength);

	// Set the raw data in the header object
	TBuf8<KByteLength> contentTypeToken;
	contentTypeToken.Append((TUint8)WSP::EContentType);
	aHeaders.SetRawFieldL(aStringPool.StringF(WSP::EContentType, WSP::Table), contentTypeValue, contentTypeToken);

	// Skip past the content-type field value
	TPtrC8 encodedData = aEncodedData.Mid(dataLength);

	// Segment the remaining data
	DecodeHeadersL(aStringPool, encodedData, aHeaders);
	}

void CWspHeaderUtils::DecodeHeadersL(RStringPool aStringPool, const TDesC8& aEncodedData, RHTTPHeaders& aHeaders)
	{
	// Use a segmentor to slice-up the data buffer
	TWspHeaderSegmenter segmentor = TWspHeaderSegmenter(aStringPool, WSP::Table, aEncodedData);

	// Slice..
	TBool done = EFalse;
	while( !done )
		{
		// Get the next field
		TWspField field;
		TInt error = segmentor.NextL(field);

		// Add the field name to the cleanup stack
		CleanupClosePushL(field.iHdrName);

		// Check for corrupt data
		if( error == KErrCorrupt )
			{
			// Data is corrupt
			User::Leave(KErrCorrupt);
			}

		// Was there a field found?
		if( error == KErrNotFound )
			{
			// No more data - stop
			done = ETrue;
			}
		else
			{
			// Set-up the field in the headers object
			TInt headerToken = field.iHdrName.Index(WSP::Table);
			if( headerToken == KErrNotFound )
				{
				// No token value so add as straight text with a NULL terminator
				HBufC8* tokenText = HBufC8::NewLC(field.iHdrName.DesC().Length() + 1);
				TPtr8 tokenTextBuffer(tokenText->Des());
				tokenTextBuffer.Append(KNullTerminator);
				aHeaders.SetRawFieldL(field.iHdrName, field.iValBuffer, *tokenText);
				CleanupStack::PopAndDestroy(tokenText);
				}
			else
				{
				// Encoded token available so use binary token as separator
				headerToken += KConvertToShortInt;
				TBuf8<KByteLength> headerTokenDes;
				headerTokenDes.Append((TUint8)headerToken);
				aHeaders.SetRawFieldL(field.iHdrName, field.iValBuffer, headerTokenDes);
				}
			}

		// Cleanup the field variable
		CleanupStack::PopAndDestroy(&field.iHdrName);

		}
	}

TBool CWspHeaderUtils::EncodeContentTypeL(RStringPool aStringPool, RHTTPHeaders aHeaders, HBufC8*& aBuf)
	{
	// Get the TPtr8 from the buffer
	TPtr8 encodedHdrs = aBuf->Des();

	// Get the content-type header, if it exists
	RStringF headerField = aStringPool.StringF(WSP::EContentType, WSP::Table);
	TPtrC8 encodedData;
	TInt foundContentType = aHeaders.GetRawField(headerField, encodedData);
	TBool hasContentType = foundContentType != KErrNotFound;

	// If the content-type header exists, append to the start of the buffer 
	// without the field name.
	if( hasContentType )
		{
		// Append the encoded field value - check for space first
		while( encodedHdrs.Length() + encodedData.Length() > encodedHdrs.MaxLength() )
			{
			aBuf = aBuf->ReAllocL(encodedHdrs.MaxLength() + KDefaultSessionHeadersBufferSize);
			encodedHdrs = aBuf->Des();
			}
		// Append the field value
		encodedHdrs.Append(encodedData);
		}
	return hasContentType;
	}

void CWspHeaderUtils::EncodeHeaderFieldL(RHTTPHeaders aHeaders, RStringF aHeaderField, HBufC8*& aBuf)
	{
	// Check to see if the header field is well-known
	TInt headerFieldValue = iCodec.EncodeFieldName(aHeaderField);

	TBool wellKnownHeader = headerFieldValue != KErrNotFound;

	// Calculate the header field length
	TInt fieldNameLength = KByteLength;
	if( !wellKnownHeader )
		{
		// The header is not well-known - need to encode the header field 
		// name as token text, which is NULL-terminated.
		fieldNameLength = aHeaderField.DesC().Length() + 1;
		}
	// Need to add the header field name and then the encoded header value.
	// First get the OTA format of the field value
	TPtrC8 encodedData;
	TInt err = aHeaders.GetRawField(aHeaderField, encodedData);

	// Was there any error encoding the header?
	if( err != KErrNone )
		{
		// Header isn't here - something has gone wrong
		User::Leave(KWspErrMissingHeader);
		}

	// Ensure there is enough space in the buffer.
	TPtr8 encodedHdrs = aBuf->Des();
	while( encodedHdrs.Length() + encodedData.Length() + fieldNameLength > encodedHdrs.MaxLength() )
		{
		aBuf = aBuf->ReAllocL(encodedHdrs.MaxLength() + KDefaultSessionHeadersBufferSize);
		encodedHdrs = aBuf->Des();
		}
	// Append the field name - check to see if well-known
	if( wellKnownHeader )
		{
		// Append as an encoded byte-value - the top bit must be set, since well-known
		// header field names are encoded as short-int ([WSP] Sect. 8.4.2.6 "Header")
		encodedHdrs.Append(headerFieldValue | KConvertToShortInt);
		}
	else
		{
		// Append as token text
		encodedHdrs.Append(aHeaderField.DesC());
		encodedHdrs.Append(KNullTerminator);
		}
	// Append the encoded field value
	encodedHdrs.Append(encodedData);
	}

TBool CWspHeaderUtils::IsTrailerHeader(RArray<RStringF> aTrailerHeaders, RStringF aHeaderField)
	{
	// Search the list of trailer headers to see if aHeaderField is in it.
	TInt index = 0;
	TInt count = aTrailerHeaders.Count();
	TBool found = EFalse;
	while( !found && index < count )
		{
		// Make the comparison
		RStringF header = aTrailerHeaders[index];
		found = header == aHeaderField;
		++index;
		}
	return found;
	}

LOCAL_C void StringArrayCleanup(TAny* aStringArray)
	{
	RArray<RStringF> array = *REINTERPRET_CAST(RArray<RStringF>*, aStringArray);

	TInt count = array.Count();
	for( TInt i = 0; i < count; ++i)
		{
		// Close the string
		array[i].Close();
		}
	array.Close();
	}