diff -r 9f5ae1728557 -r db3f5fa34ec7 messagingfw/msgsrvnstore/server/src/cmsvversion1version2converter.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/messagingfw/msgsrvnstore/server/src/cmsvversion1version2converter.cpp	Wed Nov 03 22:41:46 2010 +0530
@@ -0,0 +1,2518 @@
+// 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:
+//
+
+
+/**
+ * HEADER FILES
+ */
+
+#include "cmsvversion1version2converter.h"
+#include "cmessageconvertermanager.h"
+#include "CMsvCachedStore.h"
+#include "MSVUTILS.H"
+#include "txtrich.h"
+
+
+// constants
+const TInt KArrayGranularity = 16;
+const TInt KMaxImHeaderStringLength = 1000;
+const TInt KMaxImMimeFieldLength	= 1000;
+const TInt KDesCArrayGranularity = 8;
+const TInt KMaxBufferLength = 1000;
+const TInt KDBCommitCount = 50;
+const TInt KMaxLengthOfRecipientField = 50;
+const TInt KSmcmSmsNumberMaxNumberLength = 21;
+const TInt KSmcmSmsNumberMaxNameLength = 256;							
+const TUid KUidMsvSmsEmailFieldsStream	= {0x10204C9D};
+const TUid KUidSMSHeaderStream = {0x10001834};
+const TUid KMsvEntryFileForSms={0x10003C68};
+const TUid KUidMsgFileIMailHeader	= {0x100001D8}; // mail header UID
+const TUid KUidMsgFileIMailEncodedHeader = {0x101FD0E3};
+const TUid KUidMsgFileMimeHeader	= {0x1000160F};		// 268441103 decimal
+const TInt KMaxConverterNumber = 100;
+const TInt KMaxPathConverter = 1000;
+
+//Literals
+_LIT16(KSeparator,";");
+_LIT16(KComma,",");
+_LIT16(KDetails,"");
+_LIT16(KSpace,"");
+_LIT16(KDelimiter, ";");
+
+// Sms header fields
+_LIT16(KSmsHeadearversion , "SmsHeadearversion");
+_LIT16(KSmsRecipientCount , "RecipientCount");
+_LIT16(KRecipients , "To");
+_LIT16(KSmsFlags , "SmsFlags");
+_LIT16(KTextBioMsgIdType,"BioMsgIdType");
+
+
+// global function declaration
+extern void ExternalizeL(const CDesC8Array& anArray,RWriteStream& aStream);
+extern void InternalizeL(CDesC8Array& anArray,RReadStream& aStream);
+extern void ExternalizeL(const CDesC16Array& anArray,RWriteStream& aStream);
+extern void InternalizeL(CDesC16Array& anArray,RReadStream& aStream);
+
+/**
+InternalizeL()
+
+@param anArray: A reference to an array of 16 bit descriptor arrays
+@param aStream: The read stream interface
+@retun None.
+*/
+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();
+		}
+	}
+
+/**
+InternalizeL()
+
+@param anArray: A reference to an array of 16 bit descriptor arrays
+@param aStream: The read stream interface
+@retun None.
+*/
+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();
+		}
+	}
+
+/**
+HMsvReadBuffer()
+
+@param aBuf: 8-bit non-modifiable descriptors
+@retun None.
+*/
+HMsvReadBuffer::HMsvReadBuffer(const TDesC8 &aBuf)
+	{ 
+	TUint8* ptr=(TUint8 *)aBuf.Ptr();
+	Set(ptr,ptr+aBuf.Length(),ERead);
+	}	
+	
+void HMsvReadBuffer::DoRelease()
+	{
+	delete this;
+	}
+	
+	
+//****************************************************************************************
+//              Class TImHeaderEncodingInfo Functions
+//****************************************************************************************
+
+TImHeaderEncodingInfo::TImHeaderEncodingInfo() :  
+		iType(ENoEncoding), iAddSpace(EFalse), iCharsetUid(0)
+	{
+	}
+
+
+/** 
+TImHeaderEncodingInfo()
+Copy constructor.
+
+@param aFrom: Object to copy 
+*/
+TImHeaderEncodingInfo::TImHeaderEncodingInfo(const TImHeaderEncodingInfo& aFrom) 
+	{
+	SetField( aFrom.Field() );
+	SetOffset( aFrom.Offset() );
+	SetLength( aFrom.Length() );
+	SetEncodingType( aFrom.EncodingType() );
+	SetArrayValue( aFrom.ArrayValue() );
+	SetCharsetUid(aFrom.CharsetUid());
+	SetAddSpace( aFrom.AddSpace() ); 
+	SetEncodedLength( aFrom.EncodedLength() ); 
+	}
+
+
+/** 
+InternalizeL()
+Internalises the object from the specified stream.
+
+@param aReadStream Stream to read from */
+void TImHeaderEncodingInfo::InternalizeL( RReadStream& aReadStream )
+	{
+	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());
+	}
+
+void TImHeaderEncodingInfo::SetField(const TFieldList aField)
+	{
+	iField = aField;
+	}
+	
+/** 
+Gets the field type.
+
+@return Field type 
+*/
+TImHeaderEncodingInfo::TFieldList TImHeaderEncodingInfo::Field() const
+	{
+	return iField;
+	}
+
+/** 
+Sets the field offset.
+
+@param aOffset Field offset 
+*/
+void TImHeaderEncodingInfo::SetOffset(const TInt aOffset)
+	{
+	iOffset = (TUint16)aOffset;
+	}
+
+/** 
+Gets the field offset.
+
+@return Field offset 
+*/
+TInt TImHeaderEncodingInfo::Offset() const
+	{
+	return iOffset;
+	}
+
+/** 
+Sets the field length.
+
+@param aLength Field length 
+*/
+void TImHeaderEncodingInfo::SetLength(const TInt aLength)
+	{
+	iLength = (TUint16)aLength;
+	}
+
+/** 
+Gets the field length.
+
+@return Field length 
+*/
+TInt TImHeaderEncodingInfo::Length()  const
+	{
+	return iLength;
+	}
+
+/** Sets the character set UID.
+
+@param aUid Character set UID 
+*/
+void TImHeaderEncodingInfo::SetCharsetUid(const TUint aUid)
+	{
+	iCharsetUid = aUid;
+	}
+
+/** 
+Gets the character set UID.
+@return Character set UID 
+*/
+TUint TImHeaderEncodingInfo::CharsetUid() const
+	{
+	return iCharsetUid;
+	}
+
+/** 
+Sets the encoding type (string).
+@param aChar Encoding type 
+*/
+void TImHeaderEncodingInfo::SetEncodingType(const TDesC8& aChar)
+	{
+	// If invalid, defaults to QPEncoding
+	if (aChar[0] == 'b' || aChar[0] == 'B')
+		iType = TImHeaderEncodingInfo::EBase64;
+	else if (aChar[0] == 'q' || aChar[0] == 'Q')
+		iType = TImHeaderEncodingInfo::EQP;
+	else
+		iType = TImHeaderEncodingInfo::ENoEncoding;
+	}
+
+/**
+Sets the encoding type (enumeration).
+
+@param aType Encoding type
+*/
+void TImHeaderEncodingInfo::SetEncodingType(const TEncodingType aType)
+	{
+	iType = aType;
+	}
+
+/** 
+Gets the encoding type (enumeration).
+
+@return Encoding type 
+*/
+TImHeaderEncodingInfo::TEncodingType TImHeaderEncodingInfo::EncodingType()  const
+	{
+	return iType;
+	}
+
+/** 
+Sets the array value.
+
+@param aValue Array value 
+*/
+void TImHeaderEncodingInfo::SetArrayValue(const TInt aValue)
+	{
+	iArrayValue = (TUint16)aValue;
+	}
+
+/** 
+Gets the array value.
+
+@return Array value 
+*/
+TInt TImHeaderEncodingInfo::ArrayValue()  const
+	{
+	return iArrayValue;
+	}
+
+/** 
+Sets if a space character needs adding between two adjoining encoded-words.
+
+@param atrueFalse True to add a space character 
+*/
+void TImHeaderEncodingInfo::SetAddSpace(const TBool atrueFalse)
+	{
+	iAddSpace = atrueFalse;
+	}
+
+/** 
+Tests if the add space character flag is set.
+
+@return True for added space characters 
+*/
+ TBool TImHeaderEncodingInfo::AddSpace() const
+	{
+	return iAddSpace;
+	}
+
+/** 
+Sets the encoded length.
+
+@param aLength Encoded length 
+*/
+void TImHeaderEncodingInfo::SetEncodedLength(const TInt aLength)
+	{
+	iEncodedLength = (TInt8) aLength;
+	}
+
+/** 
+Gets the encoded length.
+
+@return Encoded length 
+*/
+TInt TImHeaderEncodingInfo::EncodedLength() const
+	{
+	return iEncodedLength + (AddSpace() ? 1 : 0);
+	}
+
+
+
+//****************************************************************************************
+//              Class CMsvVersion1Version2Converter Functions
+//****************************************************************************************
+
+
+/*
+CMsvVersion1Version2Converter()
+
+@param aDBAdapter: 
+@param aMesasgeDBAdapter: 
+@retun None.
+@internalComponent
+*/
+CMsvVersion1Version2Converter::CMsvVersion1Version2Converter(CMsvDBAdapter& aDBAdapter,CMsvMessageDBAdapter& aMessageDBAdapter,TDriveNumber aDriveNum,TBool aConversionResume)
+: iDBAdapter(aDBAdapter),iMessageDBAdapter(aMessageDBAdapter)
+	{
+	iResume = aConversionResume;
+	iDrive = aDriveNum;
+	}
+
+/**
+NewL()
+
+@param aDBAdapter: 
+@param aMesasgeDBAdapter: 
+@retun None.
+@internalComponent
+*/
+CMsvVersion1Version2Converter* CMsvVersion1Version2Converter::NewL(CMsvDBAdapter& aDBAdapter,CMsvMessageDBAdapter& aMessageDBAdapter,TDriveNumber aDriveNum,TBool aConversionResume)
+	{
+	CMsvVersion1Version2Converter* self = new (ELeave) CMsvVersion1Version2Converter(aDBAdapter,aMessageDBAdapter,aDriveNum,aConversionResume);
+	CleanupStack::PushL(self);
+	
+	self->ConstructL();
+
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+/**
+~CMsvVersion1Version2Converter()
+
+@param None: 
+@retun None.
+@internalComponent
+*/
+CMsvVersion1Version2Converter::~CMsvVersion1Version2Converter()
+	{
+	iConvertedMtmArray.Close();
+
+	delete iSmsRecipientAddressFields;
+	iSmsRecipientAddressFields = NULL;
+			
+	iRecipientDetails.Close();
+	iEmailOverSmsAddress.Close();
+
+	iEmailfieldPairList.ResetAndDestroy();	
+	iEmailfieldPairList.Close();
+	iTableFieldPairList.ResetAndDestroy();
+	iTableFieldPairList.Close();
+		
+	delete iEncodingInfo;
+	iEncodingInfo = NULL;
+	
+	iServiceIdArray.Close();
+	}	
+
+/**
+ConstructL()
+
+@param None: 
+@retun None.
+@internalComponent
+*/	
+void CMsvVersion1Version2Converter::ConstructL()
+	{
+	iResumeStatus.lastId = 0;
+	iResumeStatus.mtmId.iUid = 0;
+	iResumeStatus.serviceId = 0;
+	iResumeStatus.sourceVersion = 1;
+	iResumeStatus.targetVersion = 2;
+	iResumeStatus.remainingCount = 0;
+	
+	iEncodingInfo = new (ELeave) CArrayFixFlat<TImHeaderEncodingInfo>(KArrayGranularity);
+	}
+
+/*
+GetPropertyValue()
+Gets the value of RProperty object. This value is used to check if cancel request is 
+issued for the store conversion in progress
+
+@param None
+@return: Value of the property
+@internalComponent
+*/
+TInt CMsvVersion1Version2Converter::GetPropertyValue()
+	{
+	TInt value;
+	TInt err = RProperty::Get(KMyPropertyCat,KMyPropertyName, value);
+	return value;
+	}
+
+
+/**
+ConvertMessageStoreL()
+Starts conversion of version 1 message store to version 2
+It is responsible for the conversion of sms, imap and pop messages.
+It sequentially converts the above MTM's, reading messages and inserting the same in database table
+Header tables for MTM's are created only if a service entry is found for it.
+It takes care of resuming conversion (RESTART), updation/removal of conversion status table entries,
+creation of header tables etc.
+
+@param None:
+@retun None.
+@internalComponent
+*/
+void CMsvVersion1Version2Converter::ConvertMessageStoreL()
+	{
+	// this class will take care of converting all mtms for v1 to v2
+
+	iConvertedMtmArray.AppendL(KUidMsvSmsMtm);
+	iConvertedMtmArray.AppendL(KUidMsgTypeIMAP4); // imap
+	iConvertedMtmArray.AppendL(KUidMsgTypePOP3); // pop/smtpKUidMsgTypeSMTP
+	iConvertedMtmArray.AppendL(KUidMsgTypeSMTP); // pop/smtpKUidMsgTypeSMTP
+			
+	TInt pos=0;
+	if(iResume)
+		{
+		iDBAdapter.GetConversionStatusL(iResumeStatus);
+		pos = iConvertedMtmArray.Find(iResumeStatus.mtmId);
+		
+		if (pos == KErrNotFound)// nothing found
+			{
+			pos = 0;
+			iResume = EFalse;
+			}		
+		}
+	
+	while(pos < iConvertedMtmArray.Count())
+		{
+
+		TInt mtmId = iConvertedMtmArray[pos].iUid;
+		
+		switch(mtmId)
+			{
+			case 0x1000102C: // sms
+				{
+					/*
+					1. Read TMsvIds
+					2. Construct path
+					3. Create header table for header part
+					4. Open file and Read header part and Email over sms part
+					5. Insert Header and Email Over sms part into the header table
+					6  Open file and Read body part 
+					7. Insert body part into the body table
+					8. commit the changes.	
+					*/
+				iResumeStatus.mtmId.iUid = iConvertedMtmArray[pos].iUid;
+				iDBAdapter.BeginTransactionL();
+				if(iResume)
+					{
+					// Resume conversion from the last point
+					iDBAdapter.GetRemainingServiceIdsL(iServiceIdArray);
+					iResume = EFalse;
+					}
+				else
+					{	
+					// get all serviceIds belong to sms mtm.
+					iDBAdapter.GetAllServiceIDsForMtmL(iConvertedMtmArray[pos].iUid,iServiceIdArray);
+					
+					//Lets create resume status for all the serviceids
+					iResumeStatus.mtmId.iUid = iConvertedMtmArray[pos].iUid;
+			
+					for(TInt j =0; j < iServiceIdArray.Count(); j++)
+						{
+						iResumeStatus.lastId = 0;
+						
+						iResumeStatus.serviceId = iServiceIdArray[j];
+						iResumeStatus.sourceVersion = 1;
+						iResumeStatus.targetVersion = 2;
+						iResumeStatus.remainingCount = iDBAdapter.GetMessageCountL(iServiceIdArray[j]);
+						iDBAdapter.AddConversionStatusEntryL(iResumeStatus);
+						}
+					if(iServiceIdArray.Count() !=0)
+						{
+						CreateSmsHeaderTableL();
+						iMessageDBAdapter.CreateHeaderTableL(TUid::Uid(iResumeStatus.mtmId.iUid),iTableFieldPairList,iLastErrorMessage);
+						iTableFieldPairList.ResetAndDestroy();
+						}
+					}	
+	
+				iDBAdapter.CommitTransactionL();						
+											
+				for(TInt serviceIdPosition = 0;serviceIdPosition<iServiceIdArray.Count();serviceIdPosition++)
+					{
+					/* Read and Insert Header and Body part of Sms Mesasge */
+					InternalizeSmsMessageL(iServiceIdArray[serviceIdPosition],iResumeStatus.mtmId.iUid);
+					}
+				/* remove all conversion status entries */
+				for(TInt serviceIdPosition = 0;serviceIdPosition<iServiceIdArray.Count();serviceIdPosition++)
+					{
+					iDBAdapter.RemoveConversionStatusEntriesL();							
+					}
+							
+				iServiceIdArray.Reset();	
+				pos++; // next one is imap
+				
+				// get all service ids for IMAP
+				iDBAdapter.GetAllServiceIDsForMtmL(iConvertedMtmArray[pos].iUid,iServiceIdArray);
+				}
+			   break;
+			case 0x1000102A: // imap
+				{
+				ConvertEMailImapMessagesL(pos);
+			
+				iServiceIdArray.Reset();
+				pos++; // next one is pop
+							
+				// get all service ids for POP
+				iDBAdapter.GetAllServiceIDsForMtmL(iConvertedMtmArray[pos].iUid,iServiceIdArray);
+				
+				break;// imap conversion
+				}
+			
+			case 0x10001029:  //email pop/smtp
+				{
+				ConvertEMailPopMessagesL(pos);
+				iServiceIdArray.Reset();
+				pos++;
+				// get all service ids for POP
+				iDBAdapter.GetAllServiceIDsForMtmL(iConvertedMtmArray[pos].iUid,iServiceIdArray);
+				
+				break;
+				}
+			
+			case 0x10001028:
+				{
+				ConvertEMailSmtpMessagesL(pos);
+				iServiceIdArray.Reset();
+				pos++;
+				}
+			}
+		}
+	}
+
+/**
+ConvertEMailImapMessagesL()
+Converts IMAP message headers
+
+@param None: 
+@retun None.
+@internalComponent
+*/
+void CMsvVersion1Version2Converter::ConvertEMailImapMessagesL(TInt aConvertedMtmArrayIndex)
+	{
+	if(iResume)
+		{
+		// Resume conversion from the last point
+		iDBAdapter.GetRemainingServiceIdsL(iServiceIdArray);
+							
+		iResume = EFalse;
+		}
+	else 	// new conversion request
+		{
+		if(iServiceIdArray.Count())
+			{
+			/* New request for Imap messages.
+			 iServiceIdArray array is filled with all service ids prior to this function call.
+			 This ensures we periodically update the conversion resume table and commit the open 
+			 transaction with the database*/
+			 
+			iDBAdapter.BeginTransactionL();
+			
+			//Lets create resume status for all the serviceids
+			iResumeStatus.mtmId.iUid = iConvertedMtmArray[aConvertedMtmArrayIndex].iUid;
+
+			for(TInt j =0; j < iServiceIdArray.Count(); j++)
+				{
+				iResumeStatus.lastId = 0;
+				
+				iResumeStatus.serviceId = iServiceIdArray[j];
+				iResumeStatus.sourceVersion = 1;
+				iResumeStatus.targetVersion = 2;
+				iResumeStatus.remainingCount = iDBAdapter.GetMessageCountL(iServiceIdArray[j]);
+				iDBAdapter.AddConversionStatusEntryL(iResumeStatus);
+				}
+			
+			// Create header table
+			CreateEMailHeaderTableL(iConvertedMtmArray[aConvertedMtmArrayIndex]);	
+						
+			iDBAdapter.CommitTransactionL();// done
+			}
+		}
+	iResumeStatus.mtmId.iUid = iConvertedMtmArray[aConvertedMtmArrayIndex].iUid;
+	
+	StartEMailMessageConversionL(iResumeStatus.mtmId.iUid);
+
+	// remove all conversion status entries
+	iDBAdapter.RemoveConversionStatusEntriesL();	
+	}
+
+/**
+ConvertEMailPopMessagesL()
+Converts POP message headers.
+
+@param None:
+@retun None.
+@internalComponent
+*/
+void CMsvVersion1Version2Converter::ConvertEMailPopMessagesL(TInt aConvertedMtmArrayIndex)
+	{
+	
+	iResumeStatus.mtmId.iUid = iConvertedMtmArray[aConvertedMtmArrayIndex].iUid;
+		
+	if(iResume)
+		{
+		// Resume conversion from the last point
+		iDBAdapter.GetRemainingServiceIdsL(iServiceIdArray);
+		iDBAdapter.GetConversionStatusL(iResumeStatus);
+		iResume = EFalse;
+		}
+	else
+		{
+		if(iServiceIdArray.Count())
+			{
+			/* New request for pop messages.
+			 iServiceIdArray array is filled with all service ids prior to this function call.
+			 This ensures we periodically update the conversion resume table and commit the open 
+			 transaction with the database */
+			 
+			iDBAdapter.BeginTransactionL();
+			 
+			iTableFieldPairList.ResetAndDestroy();
+	
+			// Create header table
+			CreateEMailHeaderTableL(iConvertedMtmArray[aConvertedMtmArrayIndex]);	
+						
+			//Lets create resume status for all the serviceids
+			iResumeStatus.mtmId.iUid = iConvertedMtmArray[aConvertedMtmArrayIndex].iUid;
+			
+			for(TInt j =0; j < iServiceIdArray.Count(); j++)
+				{
+				iResumeStatus.lastId = 0;
+				
+				iResumeStatus.serviceId = iServiceIdArray[j];
+				iResumeStatus.sourceVersion = 1;
+				iResumeStatus.targetVersion = 2;
+				iResumeStatus.remainingCount = iDBAdapter.GetMessageCountL(iServiceIdArray[j]);
+				iDBAdapter.AddConversionStatusEntryL(iResumeStatus);
+				}
+
+			iDBAdapter.CommitTransactionL();// done
+			}
+		}
+	StartEMailMessageConversionL(iResumeStatus.mtmId.iUid);
+	
+	// remove all conversion ststus entries
+	iDBAdapter.RemoveConversionStatusEntriesL();							
+	
+	}
+
+/**
+ConvertEMailPopMessagesL()
+Converts POP message headers.
+
+@param None:
+@retun None.
+@internalComponent
+*/
+void CMsvVersion1Version2Converter::ConvertEMailSmtpMessagesL(TInt aConvertedMtmArrayIndex)
+	{
+	
+	iResumeStatus.mtmId.iUid = iConvertedMtmArray[aConvertedMtmArrayIndex].iUid;
+		
+	if(iResume)
+		{
+		// Resume conversion from the last point
+		iDBAdapter.GetRemainingServiceIdsL(iServiceIdArray);
+		iDBAdapter.GetConversionStatusL(iResumeStatus);
+		iResume = EFalse;
+		}
+	else
+		{
+		if(iServiceIdArray.Count())
+			{
+			/* New request for smtp messages.
+			 iServiceIdArray array is filled with all service ids prior to this function call.
+			 This ensures we periodically update the conversion resume table and commit the open 
+			 transaction with the database*/
+			iDBAdapter.BeginTransactionL();	
+			iTableFieldPairList.ResetAndDestroy();
+									
+			//Lets create resume status for all the serviceids
+			iResumeStatus.mtmId.iUid = iConvertedMtmArray[aConvertedMtmArrayIndex].iUid;
+			
+			TBool messagesFound = EFalse;
+			for(TInt j =0; j < iServiceIdArray.Count(); j++)
+				{
+				iResumeStatus.lastId = 0;
+				
+				iResumeStatus.serviceId = iServiceIdArray[j];
+				iResumeStatus.sourceVersion = 1;
+				iResumeStatus.targetVersion = 2;
+				iResumeStatus.remainingCount = iDBAdapter.GetMessageCountL(iServiceIdArray[j]);
+				if(iResumeStatus.remainingCount != 0)
+					{
+					messagesFound = ETrue;
+					}
+				iDBAdapter.AddConversionStatusEntryL(iResumeStatus);
+				}
+			
+			// Create header table if only we have some messages anywhere in the message store
+			if(messagesFound)
+				{
+				CreateEMailHeaderTableL(iConvertedMtmArray[aConvertedMtmArrayIndex]);	
+				}
+
+			iDBAdapter.CommitTransactionL();// done
+			}
+		}
+	StartEMailMessageConversionL(iResumeStatus.mtmId.iUid);
+	
+	// remove all conversion ststus entries
+	iDBAdapter.RemoveConversionStatusEntriesL();							
+	
+	}
+/**
+AddFieldL()
+Appends a CFieldPair  object for common header fields to RPointerArray of CFieldPair objects
+
+@param aField: Commonly used header fields
+@retun None.
+@internalComponent
+*/
+void CMsvVersion1Version2Converter::AddFieldL(TCommonHeaderField aField)
+	{
+	CFieldPair *fieldObject = new(ELeave) CFieldPair();
+	CleanupStack::PushL(fieldObject);
+	
+	fieldObject->iFieldType = ETextField;
+	switch (aField)
+		{
+		case EFrom:
+			_LIT16(KFromText, "From");
+			fieldObject->iFieldName = KFromText().AllocL();
+			break;
+		
+		case ETo:
+			_LIT16(KToText, "To");
+			fieldObject->iFieldName = KToText().AllocL();
+			break;
+		
+		case ECC:
+			_LIT16(KCCText, "CC");
+			fieldObject->iFieldName = KCCText().AllocL();
+			break;
+		
+		case EBCC:
+			_LIT16(KBCCText, "BCC");
+			fieldObject->iFieldName = KBCCText().AllocL();
+			break;
+	
+		case ESubject:
+			_LIT16(KSubjectText, "Subject");
+			fieldObject->iFieldName = KSubjectText().AllocL();
+			break;
+		
+		default:
+			User::Leave(KErrArgument);
+		}
+		
+	iTableFieldPairList.AppendL(fieldObject);
+	CleanupStack::Pop(fieldObject);
+	}
+
+/**
+AddFieldL()
+Appends a CFieldPair  object to RPointerArray of CFieldPair objects
+
+@param aFieldName: Name of the field
+@param aFieldType: Field type
+@retun None.
+@internalComponent
+*/
+void CMsvVersion1Version2Converter::AddFieldL(HBufC* aFieldName, EFieldType aFieldType)
+	{
+	if(NULL == aFieldName)
+		{
+		User::Leave(KErrArgument);
+		}
+
+	CFieldPair *fieldObject = new(ELeave) CFieldPair();
+	CleanupStack::PushL(fieldObject);
+	
+	fieldObject->iFieldType = aFieldType;
+	fieldObject->iFieldName = aFieldName;
+	
+	iTableFieldPairList.AppendL(fieldObject);
+	CleanupStack::Pop(fieldObject);
+	}
+
+
+/**
+StartEMailMessageConversionL()
+Gets all message IDs for each service entry for the mtm that is being converted.
+It creates the path of the message, reads the message and inserts them in database.
+For Mime conversion, it checks if the message has attachments and if so than converts its mime information
+It periodically updates the conversion status entries in the database and commits the same on the main database.
+
+@param None:
+@retun None.
+@internalComponent
+*/
+void CMsvVersion1Version2Converter::StartEMailMessageConversionL(TInt32 aMtm)
+	{
+	TMsvId iD;
+	for(TInt pos = 0; pos<iServiceIdArray.Count();pos++)
+		{
+		
+		
+		iDBAdapter.BeginTransactionL();
+		
+		RArray<TMsvId> iDArray;
+		CleanupClosePushL (iDArray);
+				
+		// Get ids from the last point
+		// Note : if we are resuming than value of iResumeStatus.lastId is set to the last
+		// message id that was converted, else it is Zero.
+		iDBAdapter.GetAllMessageIdsL(iServiceIdArray[pos],iDArray,aMtm, iResumeStatus.lastId);
+		iResumeStatus.remainingCount = iDArray.Count();
+			
+		TInt i=0;
+		for (;i<iDArray.Count();i++)
+			{
+			iResumeStatus.lastId = iDArray[i];
+			iResumeStatus.remainingCount--;
+						
+			iDBAdapter.GetOwningServiceL(iDArray[i],iD);
+						
+			RBuf path;
+			CleanupClosePushL(path);
+			path.CreateL(KMaxPath);
+						
+			CreatePathL(path,iDArray[i],iD);
+					
+			//Read the message
+			TInt headerError = ReadEMailMessageHeaderL(path);
+			TInt encodeHeaderError = ReadEMailMessageEncodedHeaderL(path);
+	
+			if(headerError == KErrNone || encodeHeaderError == KErrNone)
+				{
+				iMessageDBAdapter.CreateHeaderEntryL(TUid::Uid(iResumeStatus.mtmId.iUid), iDArray[i], iEmailfieldPairList); //header
+ 				iEmailfieldPairList.ResetAndDestroy();
+				}
+			
+			path.Close();
+			path.CreateL(KMaxPathConverter);
+			// check if this has mime
+			
+			RArray<TMsvId> mimeIdArray;
+			CleanupClosePushL(mimeIdArray);
+			
+			mimeIdArray.Append(iDArray[i]);
+			iDBAdapter.GetAllMimeIdsL(iDArray[i],mimeIdArray);
+						
+			if(mimeIdArray.Count())
+				{
+				for(TInt index = 0; index < mimeIdArray.Count();index++)
+					{
+										
+					CreatePathL(path,mimeIdArray[index],iD);
+					
+					TInt error = ReadEmailMimeHeaderL(path);
+					if(!error)
+						{
+						iMessageDBAdapter.CreateHeaderEntryL(iResumeStatus.mtmId, mimeIdArray[index], iEmailfieldPairList); //header
+						iEmailfieldPairList.ResetAndDestroy();
+						}
+					path.Zero();
+					}
+				}
+			CleanupStack::PopAndDestroy(&mimeIdArray);		
+			CleanupStack::PopAndDestroy(); //path	
+
+			//check if we have a request for cancellation
+			TInt cancel = GetPropertyValue();
+			if(cancel == KErrCancel	)
+				{
+				User::Leave(KErrCancel);
+				}
+				
+			//update the conversion status
+			if(i % KDBCommitCount == 0 && i != 0)
+				{
+				iResumeStatus.lastId = iDArray[i];
+				iResumeStatus.serviceId = iServiceIdArray[pos];
+				iResumeStatus.remainingCount -= KDBCommitCount; 
+				
+				iDBAdapter.UpdateConversionStatusEntryL(iResumeStatus);
+				iDBAdapter.CommitTransactionL();
+				iDBAdapter.BeginTransactionL();
+				}
+			}
+		
+		CleanupStack::PopAndDestroy(&iDArray);
+	
+		//update status for this service id
+		iResumeStatus.lastId = 0;
+		iResumeStatus.serviceId = iServiceIdArray[pos];
+		iResumeStatus.remainingCount = 0; 
+		iDBAdapter.UpdateConversionStatusEntryL(iResumeStatus);
+		iDBAdapter.CommitTransactionL();
+		}	
+	}
+
+
+
+
+/**
+CreatePathL()
+Creates path of aessage. The path is constructed based on the message id and its owning service id.
+
+@param aMessagePath: Message path
+@param aId: Message id
+@param aOwningId: owning id.
+@retun None.
+@internalComponent
+*/
+void CMsvVersion1Version2Converter::CreatePathL(TDes& aMessagePath, TMsvId aId,TMsvId& aOwningId)
+	{
+	// Construct the mail path for this message entry
+	_LIT16(KMessageFilePath,"\\private\\1000484b\\mail2\\");
+	TBuf<KMaxPath> src;
+	TPtrC drive(TDriveUnit(iDrive).Name());
+				
+	aMessagePath.Append(drive);
+	aMessagePath.Append(KMessageFilePath);
+	
+	TBuf<KFileNameFixedWidth> dir;
+	dir.NumFixedWidth(aOwningId, EHex, KFileNameFixedWidth);
+	_LIT16(KMsvDirectoryExt, "_S\\");
+	aMessagePath.Append(dir);
+	aMessagePath.Append(KMsvDirectoryExt);
+		
+	_LIT16(KDirSep,"\\");
+	TBuf<KFileNameFixedWidth> dir1;
+	
+	dir1.NumFixedWidth(aId&0xf, EHex,1);
+	aMessagePath.Append(dir1);
+	aMessagePath.Append(KDirSep);
+	dir.NumFixedWidth(aId, EHex, KFileNameFixedWidth);	
+	aMessagePath.Append(dir);
+	}
+
+/**
+CreateEMailHeaderTableL()
+Creates structure necessary to create email header table.
+
+@param aMtmId: mtm Id of email component.
+@retun None.
+@internalComponent
+*/
+void CMsvVersion1Version2Converter::CreateEMailHeaderTableL(const TUid aMtmId)
+	{
+	CreateEMailHeaderTableStructureL();
+	iMessageDBAdapter.CreateHeaderTableL(aMtmId,iTableFieldPairList,iLastErrorMessage);
+	}
+
+/**
+CreateEMailHeaderTableStructureL()
+Creates structure necessary to create email header table.
+
+@param None:
+@retun None.
+@internalComponent
+*/
+void CMsvVersion1Version2Converter::CreateEMailHeaderTableStructureL()
+	{
+	_LIT16(KEmailHeaderVersion , "Version");
+	AddFieldL(KEmailHeaderVersion().AllocL(),EIntegerField); //0
+	
+	_LIT16(KReceiptAddress , "ReceiptAddress");
+	AddFieldL(KReceiptAddress().AllocL(),ETextField);//1
+	
+	_LIT16(KImMsgId , "ImMsgId");
+	AddFieldL(KImMsgId().AllocL(),ETextField);//2
+
+	AddFieldL(EFrom);//3
+	
+	_LIT16(KReplyTo , "ReplyTo");
+	AddFieldL(KReplyTo().AllocL(),ETextField);//4
+	
+	AddFieldL(ESubject);//5
+
+	_LIT16(KiRemoteSize , "iRemoteSize");
+	AddFieldL(KiRemoteSize().AllocL(),EIntegerField);//6
+	
+	AddFieldL(ETo);//7
+	
+	AddFieldL(ECC);//8
+				
+	AddFieldL(EBCC);//9
+
+	_LIT16(KEncodingInfo , "EncodingInfo");
+	AddFieldL(KEncodingInfo().AllocL(),ETextField);//10
+	
+	_LIT16(KResentMsgId , "ResentMsgId");
+	AddFieldL(KResentMsgId().AllocL(),ETextField);//11
+
+	_LIT16(KResentFrom , "ResentFrom");
+	AddFieldL(KResentFrom().AllocL(),ETextField);//12
+
+	_LIT16(KResentToRecipients , "ResentToRecipients");
+	AddFieldL(KResentToRecipients().AllocL(),ETextField);//13
+
+	_LIT16(KResentCcRecipients , "ResentCcRecipients");
+	AddFieldL(KResentCcRecipients().AllocL(),ETextField);//14
+	
+	_LIT16(KResentBccRecipients , "ResentBccRecipients");
+	AddFieldL(KResentBccRecipients().AllocL(),ETextField);//15
+
+	_LIT16(KInReplyTo , "InReplyTo");
+	AddFieldL(KInReplyTo().AllocL(),ETextField);//16
+
+	_LIT16(KBodyEncoding , "BodyEncoding");
+	AddFieldL(KBodyEncoding().AllocL(),EIntegerField);//17
+
+	_LIT16(KCharset , "Charset");
+	AddFieldL(KCharset().AllocL(),EIntegerField);//18
+	}
+
+/**
+EncodingInfo()
+Returns TImHeaderEncodingInfo header encoding info.
+
+@param None:
+@retun None.
+@internalComponent
+*/
+CArrayFix<TImHeaderEncodingInfo>& CMsvVersion1Version2Converter::EncodingInfo()
+	{
+	return *iEncodingInfo;
+	}
+
+/**
+ReadEMailMessageHeaderL()
+Reads an email message header from the specified path and fills 	RPointerArray of CHeaderFields
+from the header objects.
+
+@param aMessagePath: Message path.
+@retun None.
+@internalComponent
+*/
+TInt CMsvVersion1Version2Converter::ReadEMailMessageHeaderL(TDesC& aMessagePath)
+	{
+	RFs fs;
+	User::LeaveIfError(fs.Connect());
+	CleanupClosePushL(fs);	
+	
+	RFile file;
+	TInt error = file.Open(fs,aMessagePath,EFileRead);
+	
+	if(error != KErrNone)
+		{
+		CleanupStack::PopAndDestroy(&fs); //fs
+		file.Close();
+		fs.Close();
+		return EFalse;
+		}
+	
+	CleanupClosePushL(file);
+	
+	RFileReadStream in(file);
+	in.PushL();
+
+	TCheckedUid check;
+	in >> check;
+	if(check.UidType().IsValid()==EFalse) 
+		return EFalse;
+	
+	CArrayFix<TPairedTUidHBufC8>* iStreams = new(ELeave) CArrayFixFlat<TPairedTUidHBufC8>(5);
+	in >> *iStreams;; 
+
+	// check if this stream is present
+	TPairedTUidHBufC8 entry;
+	entry.iUid=KUidMsgFileIMailHeader;
+	TKeyArrayFix key(_FOFF(TPairedTUidHBufC8,iUid),ECmpTInt32);
+	
+	TInt pos;
+	TInt found = (iStreams->FindIsq(entry,key,pos));
+			
+	if(found == KErrNone)
+		{
+		
+		HBufC8 *buffer=iStreams->At(pos).iBuf;	
+		HMsvReadBuffer *buf = new (ELeave) HMsvReadBuffer(*buffer);
+		RReadStream infoHeader(buf);
+		
+		/*Lets start reading the Header Info */
+		CHeaderFields* emailHeaderFields = new (ELeave)CHeaderFields();
+		CleanupStack::PushL(emailHeaderFields);
+		emailHeaderFields->iUid = KUidMsgFileIMailHeader;
+		CleanupStack::Pop(emailHeaderFields);
+		
+		CFieldPair* emailHeaderVersionfield = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailHeaderVersionfield);
+		emailHeaderVersionfield->iFieldNumValue = infoHeader.ReadUint16L();
+		emailHeaderFields->iFieldPairList.AppendL(emailHeaderVersionfield);
+		CleanupStack::Pop(emailHeaderVersionfield);
+
+		HBufC16* receipt = HBufC::NewL( infoHeader, KMaxImHeaderStringLength );
+		CFieldPair* emailReceiptAddress = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailReceiptAddress);
+		emailReceiptAddress->iFieldTextValue = receipt;
+		emailHeaderFields->iFieldPairList.AppendL(emailReceiptAddress);
+		CleanupStack::Pop(emailReceiptAddress);
+		
+		HBufC8* msgId = HBufC8::NewL( infoHeader, KMaxImHeaderStringLength );	
+		CFieldPair* emailImMsgId = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailImMsgId);
+		emailImMsgId->iFieldTextValue = HBufC16::NewL(KMaxImHeaderStringLength);
+		emailImMsgId->iFieldTextValue->Des().Copy(msgId->Des());
+		emailHeaderFields->iFieldPairList.AppendL(emailImMsgId);
+		CleanupStack::Pop(emailImMsgId);
+		delete msgId;
+
+		HBufC16* from = HBufC::NewL( infoHeader, KMaxImHeaderStringLength );
+		CFieldPair* emailFrom = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailFrom);
+		emailFrom->iFieldTextValue = from;
+		emailHeaderFields->iFieldPairList.AppendL(emailFrom);
+		CleanupStack::Pop(emailFrom);
+
+		HBufC16* replyTo = HBufC::NewL( infoHeader, KMaxImHeaderStringLength );
+		CFieldPair* emailReplyTo = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailReplyTo);
+		emailReplyTo->iFieldTextValue = replyTo;
+		emailHeaderFields->iFieldPairList.AppendL(emailReplyTo);
+		CleanupStack::Pop(emailReplyTo);
+		
+		HBufC16* subject = HBufC::NewL( infoHeader, KMaxImHeaderStringLength );
+		CFieldPair* emailSubject = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailSubject);
+		emailSubject->iFieldTextValue = subject;
+		emailHeaderFields->iFieldPairList.AppendL(emailSubject);
+		CleanupStack::Pop(emailSubject);
+
+		CFieldPair* emailRemoteSize = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailRemoteSize);
+		emailRemoteSize->iFieldNumValue = infoHeader.ReadUint32L();
+		emailHeaderFields->iFieldPairList.AppendL(emailRemoteSize);
+		CleanupStack::Pop(emailRemoteSize);
+
+		TInt index = 0;
+		RBuf strbuf;
+		CleanupClosePushL(strbuf);
+		strbuf.CreateL(500);
+			
+		CDesCArray* to  = new (ELeave) CDesCArrayFlat( KArrayGranularity );
+		infoHeader >> *to;
+		for( index = 0;index< to->MdcaCount();index++)
+			{
+			strbuf.Append(to->MdcaPoint(index));
+			if((index + 1) != to->MdcaCount())
+				{
+				strbuf.Append(KComma);
+				}
+			else
+				{
+				strbuf.Append(KSeparator);
+				}
+			}
+			
+		delete 	to;
+		to = NULL;
+				
+		CFieldPair* emailToRecipients = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailToRecipients);
+		emailToRecipients->iFieldTextValue = strbuf.AllocL();
+		emailHeaderFields->iFieldPairList.AppendL(emailToRecipients);	
+		CleanupStack::Pop(emailToRecipients);
+		
+		strbuf.Zero();
+		
+		CDesCArray* cc  = new (ELeave)CDesCArrayFlat( KArrayGranularity );
+		infoHeader >> *cc;
+			
+		for( index = 0;index< cc->MdcaCount();index++)
+			{
+			strbuf.Append(cc->MdcaPoint(index));
+			if((index + 1) != cc->MdcaCount())
+				{
+				strbuf.Append(KComma);
+				}
+			else
+				{
+				strbuf.Append(KSeparator);
+				}
+
+			
+			
+			}
+		delete 	cc;
+		cc = NULL;
+						
+		CFieldPair* emailCcRecipients = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailCcRecipients);
+		emailCcRecipients->iFieldTextValue = strbuf.AllocL();
+		emailHeaderFields->iFieldPairList.AppendL(emailCcRecipients);	
+		CleanupStack::Pop(emailCcRecipients);
+		
+		strbuf.Zero();
+
+		CDesCArray* bcc  = new (ELeave)CDesCArrayFlat( KArrayGranularity );
+		infoHeader >> *bcc;
+			
+		for( index = 0;index< bcc->MdcaCount();index++)
+			{
+			strbuf.Append(bcc->MdcaPoint(index));
+			if((index + 1) != bcc->MdcaCount())
+				{
+				strbuf.Append(KComma);
+				}
+			else
+				{
+				strbuf.Append(KSeparator);
+				}
+
+			}
+		delete 	bcc;
+		bcc = NULL;
+					
+		CFieldPair* emailBCcRecipients = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailBCcRecipients);
+		emailBCcRecipients->iFieldTextValue = strbuf.AllocL();
+		emailHeaderFields->iFieldPairList.AppendL(emailBCcRecipients);
+		CleanupStack::Pop(emailBCcRecipients);
+		
+		strbuf.Zero();
+		
+		//Read Email encoding info
+		infoHeader >> EncodingInfo();
+		CFieldPair* emailEncodingInfo = new (ELeave)CFieldPair();
+		
+		RBuf16 encodinginfo;
+		CleanupClosePushL(encodinginfo);
+		encodinginfo.CreateL(iEncodingInfo->Count() * sizeof(TImHeaderEncodingInfo));
+		if(iEncodingInfo->Count())
+			{
+			for (index =0; index<iEncodingInfo->Count(); index++)
+				{
+				encodinginfo.AppendNum(iEncodingInfo->At(index).Field());
+				strbuf.Append(KComma);
+				encodinginfo.AppendNum(iEncodingInfo->At(index).Offset());
+				strbuf.Append(KComma);
+				encodinginfo.AppendNum(iEncodingInfo->At(index).Length());
+				strbuf.Append(KComma);
+				encodinginfo.AppendNum(iEncodingInfo->At(index).EncodingType());
+				strbuf.Append(KComma);
+				encodinginfo.AppendNum(iEncodingInfo->At(index).ArrayValue());
+				strbuf.Append(KComma);
+				encodinginfo.AppendNum(iEncodingInfo->At(index).CharsetUid());
+				strbuf.Append(KComma);
+				encodinginfo.AppendNum(iEncodingInfo->At(index).AddSpace()); 
+				strbuf.Append(KComma);
+				encodinginfo.AppendNum(iEncodingInfo->At(index).EncodedLength()); 
+				strbuf.Append(KSeparator);
+				}
+			emailEncodingInfo->iFieldTextValue = encodinginfo.AllocL();
+			}
+		else
+			{
+			emailEncodingInfo->iFieldTextValue = KNullDesC().AllocL();
+			}
+		emailHeaderFields->iFieldPairList.AppendL(emailEncodingInfo);
+
+		HBufC8* resentMsgId = HBufC8::NewL( infoHeader, KMaxImHeaderStringLength );
+		CFieldPair* emailResentMsgId = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailResentMsgId);
+		emailResentMsgId->iFieldTextValue = (HBufC16*)(resentMsgId);
+		emailHeaderFields->iFieldPairList.AppendL(emailResentMsgId);
+		CleanupStack::Pop(emailResentMsgId);
+
+		HBufC16* resentFrom = HBufC::NewL( infoHeader, KMaxImHeaderStringLength );
+		CFieldPair* emailResentFrom = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailResentFrom);
+		emailResentFrom->iFieldTextValue =(HBufC16*)(resentFrom);
+		emailHeaderFields->iFieldPairList.AppendL(emailResentFrom);
+		CleanupStack::Pop(emailResentFrom);
+		
+		CDesCArray* resentTo  = new (ELeave)CDesCArrayFlat( KArrayGranularity );
+		CDesCArray* resentCc  = new (ELeave)CDesCArrayFlat( KArrayGranularity );	
+		CDesCArray* resentBcc = new (ELeave)CDesCArrayFlat( KArrayGranularity );
+		
+		
+		CFieldPair* emailResentToRecipients= new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailResentToRecipients);
+		infoHeader >> *resentTo;
+		for(index = 0;index< resentTo->MdcaCount();index++)
+			{
+			strbuf.Append(resentTo->MdcaPoint(index));
+			if((index + 1) != resentTo->MdcaCount())
+				{
+				strbuf.Append(KComma);
+				}
+			else
+				{
+				strbuf.Append(KSeparator);
+				}
+			}
+				
+		emailResentToRecipients->iFieldTextValue = strbuf.AllocL();
+		emailHeaderFields->iFieldPairList.AppendL(emailResentToRecipients);
+		CleanupStack::Pop(emailResentToRecipients);
+		
+		delete resentTo;
+		resentTo = NULL;
+				
+		strbuf.Zero();
+
+		CFieldPair* emailResentCcRecipients= new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailResentCcRecipients);
+		infoHeader >> *resentCc;
+		for(index = 0;index< resentCc->MdcaCount();index++)
+			{
+			strbuf.Append(resentCc->MdcaPoint(index));
+			if((index + 1) != resentCc->MdcaCount())
+				{
+				strbuf.Append(KComma);
+				}
+			else
+				{
+				strbuf.Append(KSeparator);
+				}
+			}
+		emailResentCcRecipients->iFieldTextValue = strbuf.AllocL();
+		emailHeaderFields->iFieldPairList.AppendL(emailResentCcRecipients);
+		CleanupStack::Pop(emailResentCcRecipients);
+		
+		delete resentCc;
+		resentCc = NULL;
+		strbuf.Zero();
+			
+		CFieldPair* emailResentBccRecipients= new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailResentBccRecipients);
+		infoHeader >> *resentBcc;
+		for(index = 0;index< resentBcc->MdcaCount();index++)
+			{
+			strbuf.Append(resentBcc->MdcaPoint(index));
+			if((index + 1) != resentBcc->MdcaCount())
+				{
+				strbuf.Append(KComma);
+				}
+			else
+				{
+				strbuf.Append(KSeparator);
+				}
+			}
+			
+		emailResentBccRecipients->iFieldTextValue = strbuf.AllocL();
+		emailHeaderFields->iFieldPairList.AppendL(emailResentBccRecipients);
+		CleanupStack::Pop(emailResentBccRecipients);
+		
+		delete resentBcc;
+		resentBcc = NULL;
+		strbuf.Zero();
+			
+		HBufC8* inReplyTo = HBufC8::NewL( infoHeader, KMaxImHeaderStringLength );
+		CFieldPair* emailInReplyTo = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailInReplyTo);
+		emailInReplyTo->iFieldTextValue = (HBufC16*)(inReplyTo);
+		emailHeaderFields->iFieldPairList.AppendL(emailInReplyTo);
+		CleanupStack::Pop(emailInReplyTo);
+
+		TInt bodyEncoding = infoHeader.ReadUint8L();
+		CFieldPair* emailBodyEncoding = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailBodyEncoding);
+		emailBodyEncoding->iFieldNumValue = bodyEncoding;
+		emailHeaderFields->iFieldPairList.AppendL(emailBodyEncoding);
+		CleanupStack::Pop(emailBodyEncoding);
+
+		TUint headerCharset = infoHeader.ReadUint32L();
+		CFieldPair* emailCharset = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailCharset);
+		emailCharset->iFieldNumValue = headerCharset;
+		emailHeaderFields->iFieldPairList.AppendL(emailCharset);
+		CleanupStack::Pop(emailCharset);
+
+		CFieldPair* emaildetailField = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emaildetailField);
+		emaildetailField->iFieldName =  KDetails().AllocL();
+		emaildetailField->iFieldType = ETextField;
+		emaildetailField->iFieldTextValue = KSpace().AllocL();
+		emailHeaderFields->iFieldPairList.AppendL(emaildetailField);
+		CleanupStack::Pop(emaildetailField);
+
+		iEmailfieldPairList.AppendL(emailHeaderFields);
+		
+		CleanupStack::PopAndDestroy(&encodinginfo); 
+		CleanupStack::PopAndDestroy(&strbuf);
+		infoHeader.Close();
+		}
+	TInt count=iStreams->Count();
+	while(count--) 
+		{
+		delete iStreams->At(count).iBuf;
+		}
+		
+	delete iStreams;
+	iStreams=NULL;
+	CleanupStack::PopAndDestroy(3); // in , file.fs
+	
+	return KErrNone;
+	}
+
+
+
+
+
+/**
+ReadEMailMessageEncodedHeaderL()
+Reads an email message encoded header from the specified path and fills 	RPointerArray of CHeaderFields
+from these read header objects.
+
+@param aMessagePath: message path.
+@retun TInt: Error code specifying if the message was read successfully.
+@internalComponent
+*/
+TInt CMsvVersion1Version2Converter::ReadEMailMessageEncodedHeaderL(TDesC& aMessagePath)
+	{
+	RFs fs;
+	User::LeaveIfError(fs.Connect());
+	CleanupClosePushL(fs);
+			
+	RFile file;
+	TInt error = file.Open(fs,aMessagePath,EFileRead|EFileShareAny);
+	if(error != KErrNone)
+		{
+		CleanupStack::PopAndDestroy(&fs); // fs
+		file.Close();
+		fs.Close();
+		return EFalse;
+		}
+
+	CleanupClosePushL(file);
+	
+	/*Prepare the stream*/
+	CArrayFix<TPairedTUidHBufC8> *iStreams = new(ELeave) CArrayFixFlat<TPairedTUidHBufC8>(5);
+		
+	RFileReadStream in(file);
+	in.PushL();
+
+	TCheckedUid check;
+	in >> check;
+	if(check.UidType().IsValid()==EFalse) 
+		return EFalse;
+	
+	in >> *iStreams;; 
+		
+	TPairedTUidHBufC8 entry;
+	entry.iUid=KUidMsgFileIMailEncodedHeader;
+	
+	TKeyArrayFix key(_FOFF(TPairedTUidHBufC8,iUid),ECmpTInt32);
+	
+	TInt pos;
+	TInt found = (iStreams->FindIsq(entry,key,pos));		
+
+	if(found == KErrNone)
+		{
+		HBufC8 *buffer=iStreams->At(pos).iBuf;	
+		HMsvReadBuffer *buf = new (ELeave) HMsvReadBuffer(*buffer);
+		RReadStream infoencodedHeader(buf);
+		
+		TInt version = infoencodedHeader.ReadUint16L();
+		
+		HBufC8* from    = HBufC8::NewL(infoencodedHeader, KMaxImHeaderStringLength);
+		HBufC8* replyTo = HBufC8::NewL(infoencodedHeader, KMaxImHeaderStringLength);
+		HBufC8* subject = HBufC8::NewL(infoencodedHeader, KMaxImHeaderStringLength);
+
+		CDesCArray* to  = new (ELeave) CDesCArrayFlat( KArrayGranularity );		
+		CDesCArray* cc  = new (ELeave) CDesCArrayFlat( KArrayGranularity );		
+		CDesCArray* bcc  = new (ELeave) CDesCArrayFlat( KArrayGranularity );		
+		
+		infoencodedHeader >> *to;
+		infoencodedHeader >> *cc;
+		infoencodedHeader >> *bcc;
+
+		TInt decodeCharset = infoencodedHeader.ReadUint32L();
+		
+		// prepare the RBuf
+		RBuf strbuf;
+		CleanupClosePushL(strbuf);	
+		strbuf.CreateL(KMaxBufferLength);
+		strbuf.AppendNum(version);
+		
+		strbuf.Append(KSeparator);
+				
+		HBufC16* fromTextValue = HBufC16::NewL(KMaxImHeaderStringLength);
+		fromTextValue->Des().Copy(from->Des());
+		strbuf.Append(fromTextValue->Des());
+		delete from;
+		delete fromTextValue;
+		
+		strbuf.Append(KSeparator);
+		
+		HBufC16* replyTextValue = HBufC16::NewL(KMaxImHeaderStringLength);
+		replyTextValue->Des().Copy(replyTo->Des());
+		strbuf.Append(replyTextValue->Des());	
+		delete replyTo;
+		delete replyTextValue;
+			
+		strbuf.Append(KSeparator);
+		
+		HBufC16* subjectTextValue = HBufC16::NewL(KMaxImHeaderStringLength);
+		subjectTextValue->Des().Copy(subject->Des());
+		strbuf.Append(subjectTextValue->Des());
+		delete subject;
+		delete subjectTextValue;
+
+		strbuf.Append(KSeparator);
+		
+		for(TInt i = 0;i< to->MdcaCount();i++)
+			{
+			strbuf.Append(to->MdcaPoint(i));
+			if((i + 1) != (to->MdcaCount()))
+
+				{
+				strbuf.Append(KComma);
+				}
+			}
+		strbuf.Append(KSeparator);
+		delete to;
+		to = NULL;
+		
+		for(TInt i = 0;i< cc->MdcaCount();i++)
+			{
+			strbuf.Append(cc->MdcaPoint(i));
+			if((i+1) != cc->MdcaCount())
+				{
+				strbuf.Append(KComma);
+				}
+			}
+		strbuf.Append(KSeparator);
+		delete cc;
+		cc = NULL;
+				
+		
+		for(TInt i = 0;i< bcc->MdcaCount();i++)
+			{
+			strbuf.Append(bcc->MdcaPoint(i));
+			if((i + 1) != bcc->MdcaCount())
+				{
+				strbuf.Append(KComma);
+				}
+			}
+		strbuf.Append(KSeparator);
+		delete bcc;
+		bcc = NULL;
+				
+		
+		strbuf.AppendNum(decodeCharset);
+		strbuf.Append(KSeparator);
+		
+		CHeaderFields* emailEncodedHeaderFields = new (ELeave) CHeaderFields();
+		CleanupStack::PushL(emailEncodedHeaderFields);
+		emailEncodedHeaderFields->iUid = KUidMsgFileIMailEncodedHeader;
+		CleanupStack::Pop(emailEncodedHeaderFields);
+		
+		CFieldPair* emailHeaderVersionfield = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailHeaderVersionfield);
+		emailEncodedHeaderFields->iFieldPairList.AppendL(emailHeaderVersionfield);
+		CleanupStack::Pop(emailHeaderVersionfield);
+
+		CFieldPair* emailReceiptAddress = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailReceiptAddress);
+		emailReceiptAddress->iFieldTextValue = KSpace().Alloc();
+		emailEncodedHeaderFields->iFieldPairList.AppendL(emailReceiptAddress);
+		CleanupStack::Pop(emailReceiptAddress);
+		
+		CFieldPair* emailImMsgId = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailImMsgId);
+		emailImMsgId->iFieldTextValue = KSpace().AllocL();
+		emailEncodedHeaderFields->iFieldPairList.AppendL(emailImMsgId);
+		CleanupStack::Pop(emailImMsgId);
+				
+		CFieldPair* emailFrom = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailFrom);
+		emailFrom->iFieldTextValue = KSpace().AllocL();
+		emailEncodedHeaderFields->iFieldPairList.AppendL(emailFrom);
+		CleanupStack::Pop(emailFrom);
+
+		CFieldPair* emailReplyTo = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailReplyTo);
+		emailReplyTo->iFieldTextValue = KSpace().AllocL();;
+		emailEncodedHeaderFields->iFieldPairList.AppendL(emailReplyTo);
+		CleanupStack::Pop(emailReplyTo);
+		
+		CFieldPair* emailSubject = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailSubject);
+		emailSubject->iFieldTextValue = KSpace().AllocL();;
+		emailEncodedHeaderFields->iFieldPairList.AppendL(emailSubject);
+		CleanupStack::Pop(emailSubject);
+
+		CFieldPair* emailRemoteSize = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailRemoteSize);
+		emailEncodedHeaderFields->iFieldPairList.AppendL(emailRemoteSize);
+		CleanupStack::Pop(emailRemoteSize);
+
+		CFieldPair* emailToRecipients = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailToRecipients);
+		emailToRecipients->iFieldTextValue = KSpace().AllocL();
+		emailEncodedHeaderFields->iFieldPairList.AppendL(emailToRecipients);	
+		CleanupStack::Pop(emailToRecipients);
+
+		CFieldPair* emailCcRecipients = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailCcRecipients);
+		emailCcRecipients->iFieldTextValue = KSpace().AllocL();
+		emailEncodedHeaderFields->iFieldPairList.AppendL(emailCcRecipients);	
+		CleanupStack::Pop(emailCcRecipients);
+
+		CFieldPair* emailBCcRecipients = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailBCcRecipients);
+		emailBCcRecipients->iFieldTextValue = KSpace().AllocL();
+		emailEncodedHeaderFields->iFieldPairList.AppendL(emailBCcRecipients);
+		CleanupStack::Pop(emailBCcRecipients);
+		
+		//Read Email encoding info
+		CFieldPair* emailEncodingInfo = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailEncodingInfo);
+		emailEncodingInfo->iFieldTextValue = KSpace().AllocL();
+		emailEncodedHeaderFields->iFieldPairList.AppendL(emailEncodingInfo);
+		CleanupStack::Pop(emailEncodingInfo);
+		
+		CFieldPair* emailResentMsgId = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailResentMsgId);
+		emailResentMsgId->iFieldTextValue = KSpace().AllocL();;
+		emailEncodedHeaderFields->iFieldPairList.AppendL(emailResentMsgId);
+		CleanupStack::Pop(emailResentMsgId);
+
+		CFieldPair* emailResentFrom = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailResentFrom);
+		emailResentFrom->iFieldTextValue = KSpace().AllocL();
+		emailEncodedHeaderFields->iFieldPairList.AppendL(emailResentFrom);
+		CleanupStack::Pop(emailResentFrom);
+		
+		CFieldPair* emailResentToRecipients= new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailResentToRecipients);
+		emailResentToRecipients->iFieldTextValue = KSpace().AllocL();
+		emailEncodedHeaderFields->iFieldPairList.AppendL(emailResentToRecipients);
+		CleanupStack::Pop(emailResentToRecipients);
+
+		CFieldPair* emailResentCcRecipients= new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailResentCcRecipients);
+		emailResentCcRecipients->iFieldTextValue = KSpace().AllocL();
+		emailEncodedHeaderFields->iFieldPairList.AppendL(emailResentCcRecipients);
+		CleanupStack::Pop(emailResentCcRecipients);
+
+		CFieldPair* emailResentBccRecipients= new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailResentBccRecipients);
+		emailResentBccRecipients->iFieldTextValue = KSpace().AllocL();
+		emailEncodedHeaderFields->iFieldPairList.AppendL(emailResentBccRecipients);
+		CleanupStack::Pop(emailResentBccRecipients);
+
+		CFieldPair* emailInReplyTo = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailInReplyTo);
+		emailInReplyTo->iFieldTextValue = KSpace().AllocL();
+		emailEncodedHeaderFields->iFieldPairList.AppendL(emailInReplyTo);
+		CleanupStack::Pop(emailInReplyTo);
+
+		CFieldPair* emailBodyEncoding = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailBodyEncoding);
+		emailEncodedHeaderFields->iFieldPairList.AppendL(emailBodyEncoding);
+		CleanupStack::Pop(emailBodyEncoding);
+
+		CFieldPair* emailCharset = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailCharset);
+		emailEncodedHeaderFields->iFieldPairList.AppendL(emailCharset);
+		CleanupStack::Pop(emailCharset);
+
+		CFieldPair* emaildetailField = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emaildetailField);
+		emaildetailField->iFieldType = ETextField;
+		emaildetailField->iFieldTextValue = strbuf.AllocL();
+		emailEncodedHeaderFields->iFieldPairList.AppendL(emaildetailField);
+		CleanupStack::Pop(emaildetailField);
+		
+		iEmailfieldPairList.AppendL(emailEncodedHeaderFields);
+		
+		CleanupStack::PopAndDestroy(); //strbuf
+	
+		infoencodedHeader.Close();
+		}
+	TInt count=iStreams->Count();
+	while(count--) 
+		{
+		delete iStreams->At(count).iBuf;
+		}
+				
+	delete iStreams;
+	iStreams=NULL;
+	CleanupStack::PopAndDestroy(3); //fs, in, file
+	fs.Close();
+	in.Close();
+	return KErrNone;
+	}
+
+
+/**
+ReadEmailMimeHeaderL()
+Reads an email message mime header from the specified path and fills RPointerArray of CHeaderFields
+from these read header objects.
+
+@param aMessagePath: message path.
+@retun TInt: Error code specifying if the message was read successfully.
+@internalComponent
+*/
+TInt CMsvVersion1Version2Converter::ReadEmailMimeHeaderL(TDesC& aMessagePath)
+	{
+	RFs fs;
+	User::LeaveIfError(fs.Connect());
+	CleanupClosePushL(fs);
+	
+	RFile file;
+	TInt error = file.Open(fs,aMessagePath,EFileRead|EFileShareAny);
+	if(error != KErrNone) 
+		{
+		CleanupStack::PopAndDestroy(&fs); //fs
+		file.Close();
+		fs.Close();
+		return error;
+		}
+	CleanupClosePushL(file);
+	
+	CArrayFix<TPairedTUidHBufC8> *iStreams = new(ELeave) CArrayFixFlat<TPairedTUidHBufC8>(5);;
+		
+	RFileReadStream in(file);
+	in.PushL();
+
+	TCheckedUid check;
+	in >> check;
+	if(check.UidType().IsValid()==EFalse) 
+		return EFalse;
+	
+	in >> *iStreams;; 
+
+	TPairedTUidHBufC8 entry;
+	entry.iUid=KUidMsgFileMimeHeader;
+	TKeyArrayFix key(_FOFF(TPairedTUidHBufC8,iUid),ECmpTInt32);
+	
+	TInt pos;
+	TBool found = (iStreams->FindIsq(entry,key,pos));		
+
+	if(found == KErrNone)
+		{
+		HBufC8 *buffer=iStreams->At(pos).iBuf;	
+		HMsvReadBuffer *buf = new (ELeave) HMsvReadBuffer(*buffer);
+
+		RReadStream infoMimeHeader(buf);
+		
+		RBuf8 mimeStr;
+		mimeStr.Create(KMaxBufferLength);
+		CleanupClosePushL(mimeStr);
+				
+		TInt version = infoMimeHeader.ReadUint16L();
+		mimeStr.AppendNum(version);
+		mimeStr.Append(KSeparator);
+		
+		HBufC8* relativePath = HBufC8::NewL( infoMimeHeader, KMaxImMimeFieldLength );
+		mimeStr.Append(relativePath->Des());
+		mimeStr.Append(KSeparator);
+		delete relativePath;
+				
+		HBufC8* contentType = HBufC8::NewL( infoMimeHeader, KMaxImMimeFieldLength );
+		mimeStr.Append(contentType->Des());
+		mimeStr.Append(KSeparator);
+		delete contentType;
+				
+		HBufC8* contentSubType = HBufC8::NewL( infoMimeHeader, KMaxImMimeFieldLength );
+		mimeStr.Append(contentSubType->Des());
+		mimeStr.Append(KSeparator);
+		delete contentSubType;
+
+
+		TInt contentTransferEncoding =  infoMimeHeader.ReadInt8L();
+		mimeStr.AppendNum(contentTransferEncoding);
+		mimeStr.Append(KSeparator);
+		
+		HBufC8* contentDisposition = HBufC8::NewL( infoMimeHeader, KMaxImMimeFieldLength );
+		mimeStr.Append(contentDisposition->Des());
+		mimeStr.Append(KSeparator);
+		delete contentDisposition;
+		
+		HBufC8* contentDescription = HBufC8::NewL( infoMimeHeader, KMaxImMimeFieldLength );
+		mimeStr.Append(contentDescription->Des());
+		mimeStr.Append(KSeparator);
+		delete contentDescription;
+		
+		HBufC8* contentBase = HBufC8::NewL( infoMimeHeader, KMaxImMimeFieldLength );
+		mimeStr.Append(contentBase->Des());
+		mimeStr.Append(KSeparator);
+		delete contentBase;
+		
+		HBufC16* contentLocation = HBufC16::NewL( infoMimeHeader, KMaxImMimeFieldLength );
+		mimeStr.Append(contentLocation->Des());
+		mimeStr.Append(KSeparator);
+		delete contentLocation;
+		
+		HBufC8* contentID = HBufC8::NewL( infoMimeHeader, KMaxImMimeFieldLength );
+		mimeStr.Append(contentID->Des());
+		mimeStr.Append(KSeparator);
+		delete contentID;
+		
+		CDesC8Array* contentTypeParams  = new (ELeave)CDesC8ArrayFlat( KDesCArrayGranularity );
+		CDesC8Array* contentDispositionParams  = new (ELeave)CDesC8ArrayFlat( KDesCArrayGranularity );	
+		CDesC8Array* xTypeParams  = new(ELeave) CDesC8ArrayFlat(KDesCArrayGranularity);
+		
+		infoMimeHeader >> *contentTypeParams;
+		for(TInt i = 0; i<contentTypeParams->Count(); i++)
+			{
+			mimeStr.Append(contentTypeParams->MdcaPoint(i));
+			if((i + 1) != contentTypeParams->MdcaCount())
+				{
+				mimeStr.Append(KComma);
+				}
+			}
+		delete contentTypeParams;
+		contentTypeParams = NULL;
+		
+		mimeStr.Append(KSeparator);
+				
+		infoMimeHeader >> *contentDispositionParams;
+		for(TInt i = 0; i<contentDispositionParams->Count(); i++)
+			{
+			mimeStr.Append(contentDispositionParams->MdcaPoint(i));
+			if((i + 1) != contentDispositionParams->MdcaCount())
+				{
+				mimeStr.Append(KComma);
+				}
+			}
+			
+		delete contentDispositionParams;
+		contentDispositionParams = NULL;
+		
+		mimeStr.Append(KSeparator);
+		
+		infoMimeHeader >> *xTypeParams;
+		for(TInt i = 0; i<xTypeParams->Count(); i++)
+			{
+			mimeStr.Append(xTypeParams->MdcaPoint(i));
+			
+			if((i + 1) != xTypeParams->MdcaCount())
+				{
+				mimeStr.Append(KComma);
+				}
+			}
+		delete xTypeParams;
+		xTypeParams = NULL;
+		
+		mimeStr.Append(KSeparator);
+			
+		TInt mimeCharset = infoMimeHeader.ReadUint32L();
+		mimeStr.AppendNum(mimeCharset);
+		mimeStr.Append(KSeparator);
+			
+		/*Lets start reading the Header Info */
+		CHeaderFields* emailMimeHeaderFields = new (ELeave) CHeaderFields();
+		emailMimeHeaderFields->iUid = KUidMsgFileMimeHeader;
+		
+		CFieldPair* emailHeaderVersionfield = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailHeaderVersionfield);
+		emailMimeHeaderFields->iFieldPairList.AppendL(emailHeaderVersionfield);
+		CleanupStack::Pop(emailHeaderVersionfield);
+
+		CFieldPair* emailReceiptAddress = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailReceiptAddress);
+		emailReceiptAddress->iFieldTextValue = KSpace().AllocL();
+		emailMimeHeaderFields->iFieldPairList.AppendL(emailReceiptAddress);
+		CleanupStack::Pop(emailReceiptAddress);
+		
+		CFieldPair* emailImMsgId = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailImMsgId);
+		emailImMsgId->iFieldTextValue = KSpace().AllocL();
+		emailMimeHeaderFields->iFieldPairList.AppendL(emailImMsgId);
+		CleanupStack::Pop(emailImMsgId);
+		
+		CFieldPair* emailFrom = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailFrom);
+		emailFrom->iFieldTextValue = KSpace().AllocL();
+		emailMimeHeaderFields->iFieldPairList.AppendL(emailFrom);
+		CleanupStack::Pop(emailFrom);
+
+		CFieldPair* emailReplyTo = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailReplyTo);
+		emailReplyTo->iFieldTextValue = KSpace().AllocL();;
+		emailMimeHeaderFields->iFieldPairList.AppendL(emailReplyTo);
+		CleanupStack::Pop(emailReplyTo);
+		
+		CFieldPair* emailSubject = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailSubject);
+		emailSubject->iFieldTextValue = KSpace().AllocL();;
+		emailMimeHeaderFields->iFieldPairList.AppendL(emailSubject);
+		CleanupStack::Pop(emailSubject);
+
+		CFieldPair* emailRemoteSize = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailRemoteSize);
+		emailMimeHeaderFields->iFieldPairList.AppendL(emailRemoteSize);
+		CleanupStack::Pop(emailRemoteSize);
+
+		CFieldPair* emailToRecipients = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailToRecipients);
+		emailToRecipients->iFieldTextValue = KSpace().AllocL();
+		emailMimeHeaderFields->iFieldPairList.AppendL(emailToRecipients);	
+		CleanupStack::Pop(emailToRecipients);
+			
+		CFieldPair* emailCcRecipients = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailCcRecipients);
+		emailCcRecipients->iFieldTextValue = KSpace().AllocL();
+		emailMimeHeaderFields->iFieldPairList.AppendL(emailCcRecipients);	
+		CleanupStack::Pop(emailCcRecipients);
+
+		CFieldPair* emailBCcRecipients = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailBCcRecipients);
+		emailBCcRecipients->iFieldTextValue = KSpace().AllocL();
+		emailMimeHeaderFields->iFieldPairList.AppendL(emailBCcRecipients);
+		CleanupStack::Pop(emailBCcRecipients);
+		
+		//Read Email encoding info
+		CFieldPair* emailEncodingInfo = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailEncodingInfo);
+		emailEncodingInfo->iFieldTextValue = KSpace().AllocL();
+		emailMimeHeaderFields->iFieldPairList.AppendL(emailEncodingInfo);
+		CleanupStack::Pop(emailEncodingInfo);
+		
+		CFieldPair* emailResentMsgId = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailResentMsgId);
+		emailResentMsgId->iFieldTextValue = KSpace().AllocL();
+		emailMimeHeaderFields->iFieldPairList.AppendL(emailResentMsgId);
+		CleanupStack::Pop(emailResentMsgId);
+
+		CFieldPair* emailResentFrom = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailResentFrom);
+		emailResentFrom->iFieldTextValue = KSpace().AllocL();
+		emailMimeHeaderFields->iFieldPairList.AppendL(emailResentFrom);
+		CleanupStack::Pop(emailResentFrom);
+		
+		CFieldPair* emailResentToRecipients= new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailResentToRecipients);
+		emailResentToRecipients->iFieldTextValue = KSpace().AllocL();
+		emailMimeHeaderFields->iFieldPairList.AppendL(emailResentToRecipients);
+		CleanupStack::Pop(emailResentToRecipients);
+
+		CFieldPair* emailResentCcRecipients= new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailResentCcRecipients);
+		emailResentCcRecipients->iFieldTextValue = KSpace().AllocL();
+		emailMimeHeaderFields->iFieldPairList.AppendL(emailResentCcRecipients);
+		CleanupStack::Pop(emailResentCcRecipients);
+
+		CFieldPair* emailResentBccRecipients= new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailResentBccRecipients);
+		emailResentBccRecipients->iFieldTextValue = KSpace().AllocL();
+		emailMimeHeaderFields->iFieldPairList.AppendL(emailResentBccRecipients);
+		CleanupStack::Pop(emailResentBccRecipients);
+
+		CFieldPair* emailInReplyTo = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailInReplyTo);
+		emailInReplyTo->iFieldTextValue = KSpace().AllocL();
+		emailMimeHeaderFields->iFieldPairList.AppendL(emailInReplyTo);
+		CleanupStack::Pop(emailInReplyTo);
+
+		CFieldPair* emailBodyEncoding = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailBodyEncoding);
+		emailMimeHeaderFields->iFieldPairList.AppendL(emailBodyEncoding);
+		CleanupStack::Pop(emailBodyEncoding);
+
+		CFieldPair* emailCharset = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emailCharset);
+		emailMimeHeaderFields->iFieldPairList.AppendL(emailCharset);
+		CleanupStack::Pop(emailCharset);
+		// 8bit to 16bit
+		HBufC* newMimeStr = HBufC::NewL(mimeStr.Length());
+		newMimeStr->Des().Copy(mimeStr);
+		
+		CFieldPair* emaildetailField = new (ELeave)CFieldPair();
+		CleanupStack::PushL(emaildetailField);
+		emaildetailField->iFieldName = KDetails().AllocL();;
+		emaildetailField->iFieldType = ETextField;
+		emaildetailField->iFieldTextValue= newMimeStr;
+		emailMimeHeaderFields->iFieldPairList.AppendL(emaildetailField);
+		CleanupStack::Pop(emaildetailField);
+		
+		iEmailfieldPairList.AppendL(emailMimeHeaderFields);
+		
+		CleanupStack::PopAndDestroy(); //mimestr
+				
+		infoMimeHeader.Close();
+		}
+	TInt count=iStreams->Count();
+	while(count--) 
+		{
+		delete iStreams->At(count).iBuf;
+		}
+	delete iStreams;
+	iStreams=NULL;
+	CleanupStack::PopAndDestroy(3); //fs,file,in
+	
+	fs.Close();
+	in.Close();
+	
+	return KErrNone;
+	}
+
+/* start SMS conversion APIs */
+
+/**
+Read and Insert header and body part of the SMS message. 
+@param aServiceIdPosition		Service Id belong to Sms MTM.
+@return void.
+@internalComponent
+*/
+
+void CMsvVersion1Version2Converter::InternalizeSmsMessageL(TMsvId aServiceId,TUint32 aMtm)
+	{
+	RArray<TMsvId> iDArray;
+	CleanupClosePushL (iDArray);
+	TMsvId iD;
+		
+	iDBAdapter.BeginTransactionL();		
+	/* Get all TMsvIds belong to one service Id */
+	iDBAdapter.GetAllMessageIdsL(aServiceId,iDArray,aMtm, iResumeStatus.lastId);
+	iResumeStatus.remainingCount = iDArray.Count();
+	
+	for(TInt i=0;i<iDArray.Count();i++)	
+		{
+		iResumeStatus.lastId = iDArray[i];
+		iResumeStatus.remainingCount--;
+		
+		RBuf path;
+		CleanupClosePushL(path);
+		path.CreateL(KMaxPath);
+		iDBAdapter.GetOwningServiceL(iDArray[i],iD);
+		CreatePathL(path,iDArray[i],iD);
+		
+		InitializeL();
+		/* Read Sms Header part of the message */
+		TBool foundSmsHeader = ReadSmsMessageHeaderL(path);
+	
+		iEmailfieldPairList.AppendL(iSmsHeaderFields);
+		iEmailfieldPairList.AppendL(iEmailOverSmsAddressFields);
+		 
+		// Insert Sms header into DB
+		if(foundSmsHeader)
+			{
+			iMessageDBAdapter.CreateHeaderEntryL(TUid::Uid(aMtm), iDArray[i], iEmailfieldPairList);
+			}
+		
+		//update the conversion status
+		if(i % KDBCommitCount == 0 && i != 0)
+			{
+			iResumeStatus.lastId = iDArray[i];
+			iResumeStatus.serviceId = aServiceId;
+			iResumeStatus.remainingCount -= KDBCommitCount; 
+				
+			iDBAdapter.UpdateConversionStatusEntryL(iResumeStatus);
+			iDBAdapter.CommitTransactionL();
+			iDBAdapter.BeginTransactionL();
+			}
+		DeAllocateMemory(); // destroy the allocated resources  	
+		path.Close();
+		CleanupStack::PopAndDestroy(); //path
+		}
+	CleanupStack::PopAndDestroy(&iDArray);					   	
+	
+	// check if we have a request for Cancellation.
+	// if one is found than we immediately cancel without comminting to the database.
+	TInt cancel = GetPropertyValue();
+	if(cancel == KErrCancel	)
+		{
+		User::Leave(KErrCancel);
+		}
+						
+	
+	//update status for this service id
+	iResumeStatus.lastId = 0;
+	iResumeStatus.serviceId = aServiceId;
+	iResumeStatus.remainingCount = 0; 
+	iDBAdapter.UpdateConversionStatusEntryL(iResumeStatus);
+	iDBAdapter.CommitTransactionL();
+	
+	}
+
+/**
+Create SMS header table in DB. 
+@param None.
+@return void.
+@internalComponent
+*/
+void CMsvVersion1Version2Converter::CreateSmsHeaderTableL()
+	{
+	AddFieldL(KSmsHeadearversion().AllocL(),EIntegerField);
+	AddFieldL(KSmsRecipientCount().AllocL(),EIntegerField);
+	AddFieldL(KRecipients().AllocL(),ETextField);
+	AddFieldL(KSmsFlags().AllocL(),EIntegerField);
+	AddFieldL(KTextBioMsgIdType().AllocL(),EIntegerField);
+	}
+
+/**
+Internalizing CMsvRecipient fields and Sms Number fields from file store. 
+@param aStream					A ref for reading the content from file store.
+@param aDetailsOfRecipients		Recipient detailfields buffer.
+@return void.
+@internalComponent
+*/
+void CMsvVersion1Version2Converter::InternalizeSmsHeaderL(RReadStream& aStream,TDes16& aDetailsOfRecipients)
+	{
+	TInt16 version = aStream.ReadInt16L();
+	
+	// Its internalize as per CMsvRecipient::InternalizeL(aStream) 
+	TRecipientStatus aStatus = (TRecipientStatus)aStream.ReadInt32L();
+	aDetailsOfRecipients.AppendNum(aStatus);
+	aDetailsOfRecipients.Append(KComma);
+	
+	CFieldPair* smsRecipientStatus = new (ELeave)CFieldPair();
+	CleanupStack::PushL(smsRecipientStatus);
+	smsRecipientStatus->iFieldNumValue = (TInt64)aStatus;
+	iSmsRecipientAddressFields->iFieldPairList.AppendL(smsRecipientStatus);
+	CleanupStack::Pop(smsRecipientStatus);
+	
+	TInt32 aError = aStream.ReadInt32L();
+	aDetailsOfRecipients.AppendNum(aError);
+	aDetailsOfRecipients.Append(KComma);
+	CFieldPair* smsError = new (ELeave)CFieldPair();
+	CleanupStack::PushL(smsError);
+	smsError->iFieldNumValue = (TInt64)aError;
+	iSmsRecipientAddressFields->iFieldPairList.AppendL(smsError);
+	CleanupStack::Pop(smsError);
+	
+	TInt aRetries = aStream.ReadInt32L();
+	aDetailsOfRecipients.AppendNum(aRetries);
+	aDetailsOfRecipients.Append(KComma);
+	
+	CFieldPair* smsRetries = new (ELeave)CFieldPair();
+	CleanupStack::PushL(smsRetries);
+	smsRetries->iFieldNumValue = (TInt64)aRetries;
+	iSmsRecipientAddressFields->iFieldPairList.AppendL(smsRetries);
+	CleanupStack::Pop(smsRetries);
+	
+	TInt64 time; 
+	aStream >> time;
+	aDetailsOfRecipients.AppendNum(time);
+	aDetailsOfRecipients.Append(KComma);
+	
+	CFieldPair* smsTime = new (ELeave)CFieldPair();
+	CleanupStack::PushL(smsTime);
+	smsTime->iFieldNumValue = time;
+	iSmsRecipientAddressFields->iFieldPairList.AppendL(smsTime);
+	CleanupStack::Pop(smsTime);
+	// end of CMsvRecipient::Internalize(aStream)
+	
+	HBufC16* number = HBufC16::NewL(aStream, KSmcmSmsNumberMaxNumberLength);
+	CleanupStack::PushL(number);
+	aDetailsOfRecipients.Append(*number);
+	aDetailsOfRecipients.Append(KComma);
+	
+	CFieldPair* smsNumber = new (ELeave)CFieldPair();
+	CleanupStack::PushL(smsNumber);
+	smsNumber->iFieldTextValue = number;
+	CleanupStack::Pop(smsNumber);
+	iSmsRecipientAddressFields->iFieldPairList.AppendL(smsNumber);
+	
+	CleanupStack::Pop(number);
+	
+	HBufC* name = HBufC::NewL(aStream, KSmcmSmsNumberMaxNameLength);
+	CleanupStack::PushL(name);
+	aDetailsOfRecipients.Append(*name);
+	aDetailsOfRecipients.Append(KComma);
+	
+	CFieldPair* smsName = new (ELeave)CFieldPair();
+	CleanupStack::PushL(smsName);
+	smsName->iFieldName = name;
+	CleanupStack::Pop(smsName);
+	iSmsRecipientAddressFields->iFieldPairList.AppendL(smsName);
+	
+	CleanupStack::Pop(name);
+
+	TLogId logId;
+	logId = aStream.ReadInt32L();
+	aDetailsOfRecipients.AppendNum(logId);
+	aDetailsOfRecipients.Append(KComma);
+	
+	CFieldPair* smsLogId = new (ELeave)CFieldPair();
+	CleanupStack::PushL(smsLogId);
+	smsLogId->iFieldNumValue = (TInt64)logId;
+	CleanupStack::Pop(smsLogId);
+	iSmsRecipientAddressFields->iFieldPairList.AppendL(smsLogId);
+	
+	CFieldPair* smsDeliverySatus = new (ELeave)CFieldPair();
+
+	TSmsAckStatus deliveryStatus;
+	if( version >= 2 )
+		{
+		deliveryStatus = (TSmsAckStatus) aStream.ReadInt8L();
+		aDetailsOfRecipients.AppendNum(deliveryStatus);
+		aDetailsOfRecipients.Append(KDelimiter);
+		
+		smsDeliverySatus->iFieldNumValue = (TInt64)deliveryStatus;
+		iSmsRecipientAddressFields->iFieldPairList.AppendL(smsDeliverySatus);
+		}
+	else
+		{
+		deliveryStatus = ENoAckRequested;
+		aDetailsOfRecipients.AppendNum(deliveryStatus);
+		aDetailsOfRecipients.Append(KDelimiter);
+		
+		smsDeliverySatus->iFieldNumValue = (TInt64)deliveryStatus;
+		iSmsRecipientAddressFields->iFieldPairList.AppendL(smsDeliverySatus);	
+		}
+	}
+
+/**
+Internalizing the Sms header part of the message from file store. 
+@param aPath:	Path which identify the location of the file.
+@return TInt 		Return error if path or sms header is not found.
+@internalComponent
+*/
+	
+TBool CMsvVersion1Version2Converter::ReadSmsMessageHeaderL(TDes& aPath)
+	{
+	RFs fs;
+	User::LeaveIfError(fs.Connect());
+	CleanupClosePushL(fs);
+	
+	RFile file;
+	TInt error = file.Open(fs,aPath,EFileRead|EFileShareAny);
+	CleanupClosePushL(file);
+	
+	if(error !=KErrNone)
+		{
+		CleanupStack::PopAndDestroy(); //fs
+		CleanupStack::PopAndDestroy(); // file
+		return EFalse;
+		}
+
+	RFileReadStream in(file);
+	in.PushL();
+	TCheckedUid check;
+	in >> check;
+	
+	if(check.UidType().IsValid()==EFalse) 
+		{
+		return EFalse;
+		}	
+	if(check.UidType()[0]!=KMsvEntryFileForSms) 
+		{
+		return EFalse;	
+		}
+
+	iStreams = new(ELeave) CArrayFixFlat<TPairedTUidHBufC8>(5);
+	in >> *iStreams;
+	
+	TInt position = 0;
+	error = FindStream(KUidSMSHeaderStream,position);	
+	if(error == KErrNone)
+		{
+		
+		HBufC8 *buffer = iStreams->At(position).iBuf;
+		HMsvReadBuffer *buf = new (ELeave) HMsvReadBuffer(*buffer);
+		CleanupStack::PushL(buf);
+		RReadStream smsHeader(buf);
+		CleanupStack::Pop(buf);
+		
+		iSmsHeaderFields->iUid = KUidSMSHeaderStream;
+		
+		//Version
+		CFieldPair* smsHeaderVersionField = new (ELeave)CFieldPair();
+		CleanupStack::PushL(smsHeaderVersionField);
+		smsHeaderVersionField->iFieldNumValue = (TInt64)smsHeader.ReadInt16L();
+		iSmsHeaderFields->iFieldPairList.AppendL(smsHeaderVersionField);
+		CleanupStack::Pop(smsHeaderVersionField);
+		
+		//internalizing recipient count from sms header
+		TInt32 recipientCount = smsHeader.ReadInt32L();
+		CFieldPair* smsRecipientCountField = new (ELeave)CFieldPair();
+		CleanupStack::PushL(smsRecipientCountField);
+		smsRecipientCountField->iFieldNumValue = (TInt64)recipientCount;
+		iSmsHeaderFields->iFieldPairList.AppendL(smsRecipientCountField);
+		CleanupStack::Pop(smsRecipientCountField);
+		
+		iRecipientDetails.Create(KMaxLengthOfRecipientField*recipientCount);
+		
+		while(recipientCount--)
+			{
+			InternalizeSmsHeaderL(smsHeader,iRecipientDetails);
+			}
+		
+		CFieldPair* detailsOfRecipientField = new (ELeave)CFieldPair();
+		CleanupStack::PushL(detailsOfRecipientField);
+		detailsOfRecipientField->iFieldTextValue = iRecipientDetails.AllocL();
+		iSmsHeaderFields->iFieldPairList.AppendL(detailsOfRecipientField);
+		CleanupStack::Pop(detailsOfRecipientField);
+		
+		// reading sms flag
+		TUint32 iFlags = smsHeader.ReadUint32L();
+		CFieldPair* smsHeaderFlagField = new (ELeave)CFieldPair();
+		CleanupStack::PushL(smsHeaderFlagField);
+		smsHeaderFlagField->iFieldNumValue = (TInt64)iFlags;
+		iSmsHeaderFields->iFieldPairList.AppendL(smsHeaderFlagField);
+		CleanupStack::Pop(smsHeaderFlagField);
+		
+		// reading sms biomsgtype
+		TInt64 iBioMsgIdType = smsHeader.ReadInt8L();
+		CFieldPair* smsHeaderBioMsgFlagField = new (ELeave)CFieldPair();
+		CleanupStack::PushL(smsHeaderBioMsgFlagField);
+		smsHeaderBioMsgFlagField->iFieldNumValue = iBioMsgIdType;
+		iSmsHeaderFields->iFieldPairList.AppendL(smsHeaderBioMsgFlagField);
+		CleanupStack::Pop(smsHeaderBioMsgFlagField);
+		
+		CFieldPair* smsDetailField = new (ELeave)CFieldPair();
+		CleanupStack::PushL(smsDetailField);
+		smsDetailField->iFieldTextValue = KSpace().AllocL();
+		iSmsHeaderFields->iFieldPairList.AppendL(smsDetailField);
+		CleanupStack::Pop(smsDetailField);
+		
+		/* Started reading EmailOverSms part of the Message */	
+		TInt eosPosition = 0;
+		error = FindStream(KUidMsvSmsEmailFieldsStream,eosPosition);
+
+		if(error != KErrNone)
+			{	
+			FillEmptyEosBufferL();  // It meant Sms message does not have EOS fields
+			}
+		else
+			{
+			HBufC8 *eosBuffer = iStreams->At(position).iBuf;
+			CleanupStack::PushL(eosBuffer);
+			HMsvReadBuffer *eosBuf = new (ELeave) HMsvReadBuffer(*eosBuffer);
+			CleanupStack::PushL(eosBuf);
+			RReadStream smsEmailHeaderField(eosBuf);
+			
+			InternalizeEmailOverSmsHeaderL(smsEmailHeaderField);
+			
+			CleanupStack::Pop(eosBuf);
+			CleanupStack::Pop(eosBuffer);	
+			
+			smsHeader.Close();
+			smsEmailHeaderField.Close();
+			}
+		}
+		
+	TInt count=iStreams->Count();
+	while(count--) 
+		{
+		delete iStreams->At(count).iBuf;
+		}
+	delete iStreams;
+	iStreams=NULL;
+	in.Pop();
+	in.Close();
+	
+	CleanupStack::PopAndDestroy(); //file
+	file.Close();
+	CleanupStack::PopAndDestroy(); // fs
+	return ETrue;	
+	}
+
+/**
+Internalizing the EOS fields from file store. 
+@param aSmsHeaderEmailOverSmsPart		A ref for reading the content from file store.
+@return void.
+@internalComponent
+*/
+void CMsvVersion1Version2Converter::InternalizeEmailOverSmsHeaderL(RReadStream& aSmsHeaderEmailOverSmsPart)
+	{	
+	iEmailOverSmsAddress.Create(KSmcmSmsNumberMaxNumberLength*KMaxConverterNumber);
+	iEmailOverSmsAddressFields->iUid = 	KUidMsvSmsEmailFieldsStream;
+	
+	// reading EmailOverSms version
+	iEmailOverSmsAddress.AppendNum(aSmsHeaderEmailOverSmsPart.ReadInt16L());
+	iEmailOverSmsAddress.Append(KDelimiter);
+
+	TCardinality cardinality;
+	aSmsHeaderEmailOverSmsPart >> cardinality;
+	TInt count = cardinality;
+	  
+	iEmailOverSmsAddress.AppendNum(count);
+	iEmailOverSmsAddress.Append(KDelimiter);	
+
+	for( TInt i = 0; i < count; ++i )
+		{
+		HBufC* buf = HBufC::NewLC(aSmsHeaderEmailOverSmsPart, KMaxTInt);
+		iEmailOverSmsAddress.Append(*buf);
+		if(i<count-1)
+		iEmailOverSmsAddress.Append(KComma);		
+		CleanupStack::Pop(buf);
+		}
+	iEmailOverSmsAddress.Append(KDelimiter);
+		
+	// read the subject 	
+	HBufC* emailOverSmsSubject = HBufC::NewLC(aSmsHeaderEmailOverSmsPart, KMaxTInt);
+	iEmailOverSmsAddress.Append(*emailOverSmsSubject);
+	iEmailOverSmsAddress.Append(KDelimiter);
+	CleanupStack::Pop(emailOverSmsSubject);
+	
+	CFieldPair* eosAddressField = new (ELeave)CFieldPair();
+	CleanupStack::PushL(eosAddressField);
+	eosAddressField->iFieldTextValue = iEmailOverSmsAddress.AllocL();  
+	iEmailOverSmsAddressFields->iFieldPairList.AppendL(eosAddressField);
+	CleanupStack::Pop(eosAddressField);
+	
+	}
+
+/**
+Initialising the objects. 
+@param None.
+@return void.
+@internalComponent
+*/
+void CMsvVersion1Version2Converter::InitializeL()
+	{
+	iSmsHeaderFields = new (ELeave) CHeaderFields();
+	iSmsRecipientAddressFields = new (ELeave) CHeaderFields();
+	iEmailOverSmsAddressFields = new (ELeave) CHeaderFields();
+	}
+	
+/**
+Destroying the memory allocated. 
+@param None.
+@return void.
+@internalComponent
+*/
+void CMsvVersion1Version2Converter::DeAllocateMemory()
+	{
+	iEmailfieldPairList.ResetAndDestroy();	
+	if(iSmsRecipientAddressFields != NULL)
+	{
+	delete iSmsRecipientAddressFields;
+	iSmsRecipientAddressFields = NULL;	
+	}
+		
+	iRecipientDetails.Close();
+	iEmailOverSmsAddress.Close();
+	}
+	
+	
+/**
+Find the stream by passing the Uid of the stream 
+@param aUid. 				The const which identify to start position for reading.
+@param aPos. 				Starting position of the stream.
+@return TInt				returning the error if stream not found.
+@internalComponent
+*/
+TInt CMsvVersion1Version2Converter::FindStream(TUid aUid,TInt &aPos)
+	{
+	TPairedTUidHBufC8 entry;
+	entry.iUid=aUid;
+	TKeyArrayFix key(_FOFF(TPairedTUidHBufC8,iUid),ECmpTInt32);
+	return(iStreams->FindIsq(entry,key,aPos));
+	}
+
+/**
+Store the empty buffer part in emailoversms header fields
+@param None
+@return void.
+@internalComponent
+*/
+void CMsvVersion1Version2Converter::FillEmptyEosBufferL()
+	{
+	iEmailOverSmsAddressFields->iUid = 	KUidMsvSmsEmailFieldsStream;
+	
+	CFieldPair* smsdetailField = new (ELeave)CFieldPair();
+	CleanupStack::PushL(smsdetailField);
+	smsdetailField->iFieldTextValue = KSpace().AllocL();
+	iEmailOverSmsAddressFields->iFieldPairList.AppendL(smsdetailField);
+	CleanupStack::Pop(smsdetailField);	
+	}
+