// Copyright (c) 1998-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:

// MIUTHDR.CPP

//

#include "MIUTHDR.H"

#include <msvstd.h>

#include <msvstore.h>	// CMsvStore

#include "MIUT_ERR.H"

#include "MIUTCONV.H"

#include <imcvcodc.h>

#include "cimencodedheader.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS  

#include "timrfc822datefield.h"

#include "cimconvertheader.h"

#include "miut_errconsts.h"

#endif

#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)

_LIT16(KComma, ",");

_LIT16(KDelimiter, ";");

#endif

const TInt KArrayGranularity = 16;

GLDEF_C TPtrC8 LimitStringSize(const TPtrC8& aString, TInt aMaxSize)

	{

	if (aString.Length() < aMaxSize)

		return aString;

	else

		return aString.Left(aMaxSize);

	}

GLDEF_C TPtrC16 LimitStringSize(const TPtrC16& aString, TInt aMaxSize)

	{

	if (aString.Length() < aMaxSize)

		return aString;

	else

		return aString.Left(aMaxSize);

	}

/**

// Ex/Internalize functions are not used at the moment, but have been left here since it is 

// very likely they will be needed in future. They are commented out to keep arm5 happy.

//----------------------------------------------------------------------------------------

LOCAL_C void ExternalizeL(const CArrayFix<TImHeaderEncodingInfo>& anArray,

								RWriteStream& aStream)

//----------------------------------------------------------------------------------------

	{

	TInt count;

	count=anArray.Count();

	aStream << TCardinality(count);		// compressed value

	for (TInt ii=count-1 ; ii>=0 ; --ii)

		{

		TImHeaderEncodingInfo info(anArray[ii]);

		info.ExternalizeL(aStream);

		}

	}

//----------------------------------------------------------------------------------------

LOCAL_C void InternalizeL(CArrayFix<TImHeaderEncodingInfo>& anArray, RReadStream& aStream)

//----------------------------------------------------------------------------------------

	{

	TCardinality card;

	aStream >> card;

	TInt count=card;

	anArray.Reset();

	for (TInt ii=0; ii<count ; ++ii)

		{

		TImHeaderEncodingInfo info;

		info.InternalizeL(aStream);

		anArray.InsertL(0,info);

		}

	}

*/	

#if defined (_UNICODE)

void ExternalizeL(const CDesC16Array& anArray,RWriteStream& aStream)

	{

	// Used in CImHeader and CImEncodedHeader

	TInt count=anArray.Count();

	aStream << TCardinality(count);		// compressed value

	for (TInt ii=0;ii<count;++ii)

		aStream << LimitStringSize(anArray[ii], KMaxImHeaderStringLength);

	}

void InternalizeL(CDesC16Array& anArray,RReadStream& aStream)

	{

	TCardinality card;

	aStream >> card;

	TInt count=card;

	anArray.Reset();

	for (TInt ii=0;ii<count;++ii)

		{

		HBufC16* buf=HBufC16::NewLC(aStream,KMaxImHeaderStringLength);

		anArray.CArrayFixBase::InsertL(ii,&buf);

		CleanupStack::Pop();

		}

	}

#endif

void ExternalizeL(const CDesC8Array& anArray,RWriteStream& aStream)

	{

	// Used in CImHeader , CImMimeHeader & CImMimePartData

	TInt count=anArray.Count();

	aStream << TCardinality(count);		// compressed value

	for (TInt ii=0;ii<count;++ii)

		aStream << LimitStringSize(anArray[ii], KMaxImHeaderStringLength);

	}

void InternalizeL(CDesC8Array& anArray,RReadStream& aStream)

	{

	TCardinality card;

	aStream >> card;

	TInt count=card;

	anArray.Reset();

	for (TInt ii=0;ii<count;++ii)

		{

		HBufC8* buf=HBufC8::NewLC(aStream,KMaxImHeaderStringLength);

		anArray.CArrayFixBase::InsertL(ii,&buf);

		CleanupStack::Pop();

		}

	}

//****************************************************************************************

//              Class TImHeaderEncodingInfo Functions

//****************************************************************************************

//----------------------------------------------------------------------------------------

EXPORT_C TImHeaderEncodingInfo::TImHeaderEncodingInfo() :  

		iType(ENoEncoding), iAddSpace(EFalse), iCharsetUid(KUidMsvCharsetNone)

//----------------------------------------------------------------------------------------

/** Default constructor. */

	{

	}

//----------------------------------------------------------------------------------------

EXPORT_C TImHeaderEncodingInfo::TImHeaderEncodingInfo(const TImHeaderEncodingInfo& aFrom) 

//----------------------------------------------------------------------------------------

/** Copy constructor.

@param aFrom Object to copy */

	{

	SetField( aFrom.Field() );

	SetOffset( aFrom.Offset() );

	SetLength( aFrom.Length() );

	SetEncodingType( aFrom.EncodingType() );

	SetArrayValue( aFrom.ArrayValue() );

	SetCharsetUid(aFrom.CharsetUid());

	SetAddSpace( aFrom.AddSpace() ); 

	SetEncodedLength( aFrom.EncodedLength() ); 

	}

//----------------------------------------------------------------------------------------

EXPORT_C void TImHeaderEncodingInfo::ExternalizeL( RWriteStream& aWriteStream ) const

//----------------------------------------------------------------------------------------

/** Externalises the object to the specified stream.

@param aWriteStream Stream to write to */

	{

	aWriteStream.WriteUint16L( Field() );

	aWriteStream.WriteUint16L( Offset() );

	aWriteStream.WriteUint16L( Length() );

	aWriteStream.WriteUint16L( EncodingType() );

	aWriteStream.WriteUint16L( ArrayValue() );

	aWriteStream.WriteUint32L( CharsetUid() );

	aWriteStream.WriteUint16L( AddSpace() );

	aWriteStream.WriteUint8L( EncodedLength() );

	}

//----------------------------------------------------------------------------------------

EXPORT_C void TImHeaderEncodingInfo::InternalizeL( RReadStream& aReadStream )

//----------------------------------------------------------------------------------------

/** Internalises the object from the specified stream.

@param aReadStream Stream to read from */

	{

	SetField( (TFieldList) aReadStream.ReadUint16L());

	SetOffset( aReadStream.ReadUint16L());

	SetLength( aReadStream.ReadUint16L());

	SetEncodingType( (TEncodingType) aReadStream.ReadUint16L());

	SetArrayValue( aReadStream.ReadUint16L());

	SetCharsetUid( aReadStream.ReadUint32L());

	SetAddSpace( aReadStream.ReadUint16L());

	SetEncodedLength( aReadStream.ReadUint8L());

	}

//****************************************************************************************

//              Class  CImHeader  Functions

//****************************************************************************************

CImHeader::CImHeader()

	{

	}

EXPORT_C CImHeader* CImHeader::NewLC()

/** Allocates and creates a new CImHeader object, leaving the object on the cleanup 

stack.

@return New CImHeader object */

	{

	// standard two-phase construction stuff...

	CImHeader* self = new (ELeave) CImHeader;

	CleanupStack::PushL( self );

	self->ConstructL();

	return self;

	}

void CImHeader::ConstructL()

	{

	iTo  = new (ELeave)CDesCArrayFlat( KArrayGranularity );

	iCc  = new (ELeave)CDesCArrayFlat( KArrayGranularity );	

	iBcc = new (ELeave)CDesCArrayFlat( KArrayGranularity );

	iEncodingInfo = new (ELeave) CArrayFixFlat<TImHeaderEncodingInfo>(KArrayGranularity);

	iResentTo  = new (ELeave)CDesCArrayFlat( KArrayGranularity );

	iResentCc  = new (ELeave)CDesCArrayFlat( KArrayGranularity );	

	iResentBcc = new (ELeave)CDesCArrayFlat( KArrayGranularity );

	iEncodedHeader = NULL;

	Reset();

	}

EXPORT_C CImHeader::~CImHeader()

/** Destructor. */

	{

	Reset();

	delete iTo;

	delete iCc;

	delete iBcc;

	delete iEncodingInfo;

	delete iResentTo;

	delete iResentCc;

	delete iResentBcc;

	delete iEncodedHeader;

	}

EXPORT_C void CImHeader::Reset()

/** Resets all header field values. */

	{

	iVersion = KImHeaderVersion;

	delete iFrom;

	iFrom = NULL;

	delete iSubject;

	iSubject = NULL;

	delete iImMsgId;

	iImMsgId = NULL;

	delete iReplyTo;

	iReplyTo = NULL;

	delete iReceipt;

	iReceipt = NULL;

	if (iTo)

		iTo->Reset();

	if (iCc)

		iCc->Reset();

	if (iBcc)

		iBcc->Reset();

	if (iEncodingInfo)

		iEncodingInfo->Reset();

	delete iResentFrom;

	iResentFrom=NULL;

	delete iResentMsgId;

	iResentMsgId=NULL;

	delete iInReplyTo;

	iInReplyTo=NULL;

	if (iResentTo)

		iResentTo->Reset();

	if (iResentCc)

		iResentCc->Reset();

	if (iResentBcc)

		iResentBcc->Reset();

	iBodyEncoding = EMsgOutboxMIME;

if (iEncodedHeader)

		iEncodedHeader->Reset();

	}

EXPORT_C const TPtrC CImHeader::Subject() const

/** Gets the "Subject" header field.

@return Field value */

	{

	return iSubject ? TPtrC(*iSubject) : TPtrC();

	}

EXPORT_C const TPtrC8 CImHeader::ImMsgId() const

/** Gets the "MessageId" header field.

@return Field value */

	{

	return iImMsgId ? TPtrC8(*iImMsgId) : TPtrC8();

	}

EXPORT_C const TPtrC CImHeader::From() const

/** Gets the "From" header field. 

This consists of an address and (possibly) an alias.

@return Field value */

	{

	return iFrom ? TPtrC(*iFrom) : TPtrC();

	}

EXPORT_C const TPtrC CImHeader::ReceiptAddress() const

/** Gets the "Receipt" header field. 

@return Field value */

	{

	return iReceipt ? TPtrC(*iReceipt) : TPtrC();

	}

EXPORT_C const TPtrC CImHeader::ReplyTo() const

/** Gets the "ReplyTo" header field. 

@return Field value */

	{

	return iReplyTo ? TPtrC(*iReplyTo) : TPtrC();

	}

EXPORT_C TUint CImHeader::Charset() const

/** Gets the character set to use when sending the message header.

If set, this overrides the default system character set for sending

the header. 

Character set and encoding options can also be set on a per header field

basis using TImHeaderEncodingInfo objects. See EncodingInfo().

@return Identifier for the character set. Character sets idenitifiers

are defined by the character conversion API in charconv.h. 

@see SetCharset()

@see EncodingInfo()

*/

	{

	return i822HeaderCharset;

	}

EXPORT_C void CImHeader::SetSubjectL( const TDesC8& aSubject )

/** Sets the "Subject" header field. 

@param aSubject Field value */

	{

#if defined (_UNICODE)

	HBufC* newSubject = HBufC::NewL(aSubject.Length());

	newSubject->Des().Copy(aSubject);

# else

	HBufC* newSubject = aSubject.Alloc();

#endif

	delete iSubject;

	iSubject = newSubject;

	}

EXPORT_C void CImHeader::SetImMsgIdL( const TDesC8& aImMsgId )

/** Sets the "MessageId" header field.

@param aImMsgId Field value

*/

	{

	HBufC8* newImMsgId = aImMsgId.Alloc();

	delete iImMsgId;

	iImMsgId = newImMsgId;

	}

EXPORT_C void CImHeader::SetFromL( const TDesC8& aFrom )

/** Sets the "From" header field. 

@param aFrom Field value */

	{

#if defined (_UNICODE)

	HBufC* newFrom = HBufC::NewL(aFrom.Length());

	newFrom->Des().Copy(aFrom);

# else

	HBufC* newFrom = aFrom.Alloc();

#endif

	delete iFrom;

	iFrom = newFrom;

	}

EXPORT_C void CImHeader::SetReplyToL( const TDesC8& aReplyTo )

/** Sets the "ReplyTo" header field. 

@param aReplyTo Field value */

	{

#if defined (_UNICODE)

	HBufC* newReplyTo = HBufC::NewL(aReplyTo.Length());

	newReplyTo->Des().Copy(aReplyTo);

# else

	HBufC* newReplyTo = aReplyTo.Alloc();

#endif

	delete iReplyTo;

	iReplyTo = newReplyTo;

	}

EXPORT_C void CImHeader::SetReceiptAddressL( const TDesC8& aReceipt )

/** Sets the "Receipt" header field. 

@param Field value

*/

	{

#if defined (_UNICODE)

	HBufC* newReceipt = HBufC::NewL(aReceipt.Length());

	newReceipt->Des().Copy(aReceipt);

# else

	HBufC* newReceipt = aReceipt.Alloc();

#endif

	delete iReceipt;

	iReceipt = newReceipt;

	}

EXPORT_C void CImHeader::ExternalizeL( RMsvWriteStream& aWriteStream ) const

/** Externalises the settings to a specified stream.

@param aWriteStream Stream to write to */

	{

	aWriteStream.WriteUint16L(Version());	// This MUST be the 1st item written into the stream

	aWriteStream << LimitStringSize(ReceiptAddress(), KMaxImHeaderStringLength);

	aWriteStream << LimitStringSize(ImMsgId(), KMaxImHeaderStringLength);

	aWriteStream << LimitStringSize(From(), KMaxImHeaderStringLength);

	aWriteStream << LimitStringSize(ReplyTo(), KMaxImHeaderStringLength);

	aWriteStream << LimitStringSize(Subject(), KMaxImHeaderStringLength);

	aWriteStream.WriteUint32L( iRemoteSize );

	aWriteStream << ToRecipients();

	aWriteStream << CcRecipients();

	aWriteStream << BccRecipients();

	aWriteStream << EncodingInfo();

	aWriteStream << LimitStringSize(ResentMsgId(), KMaxImHeaderStringLength);

	aWriteStream << LimitStringSize(ResentFrom(), KMaxImHeaderStringLength);

	aWriteStream << ResentToRecipients();

	aWriteStream << ResentCcRecipients();

	aWriteStream << ResentBccRecipients();

	aWriteStream << LimitStringSize(InReplyTo(), KMaxImHeaderStringLength);

	aWriteStream.WriteInt8L(BodyEncoding());

	aWriteStream.WriteUint32L(Charset());

	}

EXPORT_C void CImHeader::InternalizeL( RMsvReadStream& aReadStream )

/** Internalises the settings from a specified stream.

@param aReadStream Stream to read from */

	{

	Reset();

	iVersion = aReadStream.ReadUint16L();

	__ASSERT_DEBUG (iVersion == KImHeaderVersion, gPanic(EMiutBadStreamVersion));

	iReceipt = HBufC::NewL( aReadStream, KMaxImHeaderStringLength );

	iImMsgId = HBufC8::NewL( aReadStream, KMaxImHeaderStringLength );

	iFrom = HBufC::NewL( aReadStream, KMaxImHeaderStringLength );

	iReplyTo = HBufC::NewL( aReadStream, KMaxImHeaderStringLength );

	iSubject = HBufC::NewL( aReadStream, KMaxImHeaderStringLength );

	iRemoteSize=aReadStream.ReadUint32L();

	aReadStream >> ToRecipients();

	aReadStream >> CcRecipients();

	aReadStream >> BccRecipients();

	aReadStream >> EncodingInfo();

	iResentMsgId = HBufC8::NewL( aReadStream, KMaxImHeaderStringLength );

	iResentFrom = HBufC::NewL( aReadStream, KMaxImHeaderStringLength );

	aReadStream >> ResentToRecipients();

	aReadStream >> ResentCcRecipients();

	aReadStream >> ResentBccRecipients();

	iInReplyTo = HBufC8::NewL( aReadStream, KMaxImHeaderStringLength );

	iBodyEncoding = (TMsgOutboxBodyEncoding)aReadStream.ReadInt8L();

	i822HeaderCharset = aReadStream.ReadUint32L();

	}

EXPORT_C TInt CImHeader::DataSize()

/** Gets the combined length of all the field values stored. 

@return Combined length */

	{

	TInt headerSize = 2; // CRLF at end of header

	// speed-up by getting 'this' as a local variable...

	const CImHeader* self=this;

	headerSize+=self->From().Length();

	headerSize+=self->ReplyTo().Length();

	headerSize+=self->Subject().Length();

	headerSize+=self->ReceiptAddress().Length();

	headerSize+=sizeof(TTime);

	headerSize+=self->ImMsgId().Length();

	headerSize+=sizeof(TUid);				// size of Charset

// not added headerSize+=sizeof(TUint16); // iVersion

	TInt ii;

	CDesCArray& toArray = *self->iTo; 

	for ( ii = 0; ii < toArray.Count(); ii++)

		{

		headerSize+=toArray[ii].Length();

		}

	CDesCArray& ccArray = *self->iCc;

	for ( ii = 0; ii < ccArray.Count(); ii++)