/*

 * Copyright (c) 2005-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: 

 *

 */

 /**

 @test

 @internalComponent

 This contains CT_FileData

 */

 //	User includes

 #include "T_FileData.h"

 /*@{*/

 ///	Parameters

 _LIT(KFile,								"file");

 _LIT(KUParamPath,						"path");

 _LIT(KUParamName,						"name");

 _LIT(KRFsName,							"RFs");

 _LIT(KFileMode,							"file_mode");

 _LIT(KUParamExpectedString,				"expected_string");

 _LIT(KUParamAsync,						"async");

 _LIT(KUParamBufferLength,				"buffer_length");

 _LIT(KUParamLength,						"length");

 _LIT(KUParamStartPos,					"start_pos");

 _LIT(KUParamEndPos,						"end_pos");

 _LIT(KUParamUsage,						"usage");

 _LIT(KUParamPos,						"position");

 _LIT(KSeek, 							"seek");

 _LIT(KUParamCancelAll,					"cancel_all");

 _LIT(KUParamData, 						"datawrite");

 _LIT(KUParamSize, 						"size");

 _LIT(KUParamExpectedSize,				"expected_size");

 _LIT(KUParamCompareValue,				"compare_value");

 _LIT(KUParamSetAttMask,					"set_att_mask");

 _LIT(KUParamClearAttMask, 				"clear_att_mask");

 _LIT(KUParamDate, 						"date");

 _LIT(KFileObjectName,					"file_object_name");

 _LIT(KUParamOwnerType,					"owner_type");

 _LIT(KUParamComparePath,				"compare_path");

 // OwnerType

 _LIT(KEOwnerProcess, 					"EOwnerProcess");

 _LIT(KEOwnerThread, 					"EOwnerThread");

 // Block Usage

 _LIT(KEBlockMapUsagePaging, 			"EBlockMapUsagePaging");

 _LIT(KETestDebug, 						"ETestDebug");

 // FileMode

 _LIT(KEFileShareExclusive,	 			"EFileShareExclusive");

 _LIT(KEFileShareReadersOnly,	 		"EFileShareReadersOnly");

 _LIT(KEFileShareAny,	 				"EFileShareAny");

 _LIT(KEFileShareReadersOrWriters,	 	"EFileShareReadersOrWriters");

 _LIT(KEFileStream,	 					"EFileStream");

 _LIT(KEFileStreamText,					"EFileStreamText");

 _LIT(KEFileRead,	 					"EFileRead");

 _LIT(KEFileWrite,						"EFileWrite");

 _LIT(KEFileReadAsyncAll,	 			"EFileReadAsyncAll");

 // Seek

 _LIT(KESeekStart,						"ESeekStart");

 _LIT(KESeekCurrent,						"ESeekCurrent");

 _LIT(KESeekEnd,							"ESeekEnd");

 ///	Commands

 _LIT(KCmdNew,							"new");

 _LIT(KCmdClose,							"Close");

 _LIT(KCmdDestructor,					"~");

 _LIT(KCmdBlockMap,						"BlockMap");

 _LIT(KCmdOpen,							"Open");

 _LIT(KCmdCreate,						"Create");

 _LIT(KCmdWrite,							"Write");

 _LIT(KCmdReplace, 						"Replace");

 _LIT(KCmdRead,							"Read");

 _LIT(KCmdFlush,							"Flush");

 _LIT(KCmdTemp,							"Temp");

 _LIT(KCmdRename,						"Rename");

 _LIT(KCmdSeek,							"Seek");

 _LIT(KCmdReadCancel,					"ReadCancel");

 _LIT(KCmdLock,							"Lock");

 _LIT(KCmdUnLock,						"UnLock");

 _LIT(KCmdSize, 							"Size");

 _LIT(KCmdSetSize, 						"SetSize");

 _LIT(KCmdAtt,							"Att");

 _LIT(KCmdSetAtt,						"SetAtt");

 _LIT(KCmdModified, 						"Modified");

 _LIT(KCmdSetModified,					"SetModified");

 _LIT(KCmdSet,							"Set");

 _LIT(KCmdChangeMode, 					"ChangeMode");

 _LIT(KCmdDrive,							"Drive");

 _LIT(KCmdDuplicate, 					"Duplicate");

 _LIT(KCmdName,							"Name");

 _LIT(KCmdFullName,						"FullName");

 //Attributes

 _LIT(KDEntryAttNormal,  				"KEntryAttNormal");

 _LIT(KDEntryAttReadOnly, 				"KEntryAttReadOnly");

 _LIT(KDEntryAttArchive,					"KEntryAttArchive");

 _LIT(KDEntryAttHidden,					"KEntryAttHidden");

 _LIT(KDEntryAttSystem,					"KEntryAttSystem");

 _LIT(KDEntryAttVolume,					"KEntryAttVolume");

 _LIT(KDEntryAttDir,						"KEntryAttDir");

 _LIT(KDEntryAttXIP,						"KEntryAttXIP");

 _LIT(KDEntryAttRemote,					"KEntryAttRemote");

 //constants

 const TInt KDefaultDescSize = 64;

 /*@}*/

 CT_FileData* CT_FileData::NewL()

 /**

  * Two phase constructor

  */

 	{

 	CT_FileData* ret = new (ELeave) CT_FileData();

 	CleanupStack::PushL(ret);

 	ret->ConstructL();

 	CleanupStack::Pop(ret);

 	return ret;

 	}

 CT_FileData::CT_FileData()

 /**

  * Protected constructor. First phase construction

  */

 :	iFile(NULL)

 	{

 	}

 void CT_FileData::ConstructL()

 /**

  * Protected constructor. Second phase construction

  */

 	{

 	iFileOpened = EFalse;

 	}

 CT_FileData::~CT_FileData()

 /**

  * Destructor.

  */

 	{

 	DoCleanup();

 	}

 void CT_FileData::DoCleanup()

 /**

  * Contains cleanup implementation

  */

 	{

 	//Deleting RFile.

 	if(iFile != NULL)

 		{

 		INFO_PRINTF1(_L("Deleting current RFile"));

 		delete iFile;

 		iFile = NULL;

 		}

 	iReadCallbackArray.Close();

 	iWriteCallbackArray.Close();

 	iFlushCallbackArray.Close();

 	}

 TAny* CT_FileData::GetObject()

 /**

  * Return a pointer to the object that the data wraps

  *

  * @return pointer to the object that the data wraps

  */

 	{

 	return iFile;

 	}

 TBool CT_FileData::DoCommandL(const TTEFFunction& aCommand, const TTEFSectionName& aSection, const TInt aAsyncErrorIndex)

 /**

  * Process a command read from the ini file

  *

  * @param aCommand	the command to process

  * @param aSection		the entry in the ini file requiring the command to be processed

  * @param aAsyncErrorIndex the index of asynchronous command error code belongs to.

  *

  * @return ETrue if the command is processed

  */

 	{

 	TBool retVal = ETrue;

 	if (aCommand == KCmdNew)

 		{

 		DoCmdNewL();

 		}

 	else if (aCommand == KCmdDestructor)

 		{

 		DoCmdDestructor();

 		}

 	else if (aCommand == KCmdOpen)

 		{

 		DoCmdOpenL(aSection);

 		}

 	else if (aCommand == KCmdWrite)

 		{

 		DoCmdWriteL(aSection, aAsyncErrorIndex);

 		}

 	else if (aCommand == KCmdClose)

 		{

 		DoCmdClose();

 		}

 	else if (aCommand == KCmdCreate)

 		{

 		DoCmdCreateL(aSection);

 		}

 	else if (aCommand == KCmdReplace)

 		{

 		DoCmdReplaceL(aSection);

 		}

 	else if (aCommand == KCmdRead)

 		{

 		DoCmdReadL(aSection, aAsyncErrorIndex);

 		}	

 	else if (aCommand == KCmdFlush)

 		{

 		DoCmdFlushL(aSection, aAsyncErrorIndex);

 		}

 	else if (aCommand == KCmdTemp)

 		{

 		DoCmdTempL(aSection);

 		}	

 	else if (aCommand == KCmdRename)

 		{

 		DoCmdRenameL(aSection);

 		}

 	else if (aCommand == KCmdSeek)

 		{

 		DoCmdSeekL(aSection);

 		}

 	else if (aCommand == KCmdReadCancel)

 		{

 		DoCmdReadCancelL(aSection);

 		}	

 	else if (aCommand == KCmdLock)

 		{

 		DoCmdLockL(aSection);

 		}

 	else if (aCommand == KCmdUnLock)

 		{

 		DoCmdUnLockL(aSection);

 		}

 	else if (aCommand == KCmdSize)

 		{

 		DoCmdSizeL(aSection);

 		}		

 	else if (aCommand == KCmdSetSize)

 		{

 		DoCmdSetSizeL(aSection);

 		}

 	else if (aCommand == KCmdAtt)

 		{

 		DoCmdAttL(aSection);

 		}		

 	else if (aCommand == KCmdSetAtt)

 		{

 		DoCmdSetAttL(aSection);

 		}		

 	else if (aCommand == KCmdModified)

 		{

 		DoCmdModifiedL(aSection);

 		}

 	else if (aCommand == KCmdSetModified)

 		{

 		DoCmdSetModifiedL(aSection);

 		}

 	else if (aCommand == KCmdSet)

 		{

 		DoCmdSetL(aSection);

 		}

 	else if (aCommand == KCmdChangeMode)

 		{

 		DoCmdChangeModeL(aSection);

 		}

 	else if (aCommand == KCmdDrive)

 		{

 		DoCmdDriveL(aSection);

 		}

 	else if (aCommand == KCmdName)

 		{

 		DoCmdNameL(aSection);

 		}

 	else if (aCommand == KCmdDuplicate)

 		{

 		DoCmdDuplicateL(aSection);

 		}

 	else if (aCommand == KCmdFullName)

 		{

 		DoCmdFullName(aSection);

 		}

 	else if (aCommand == KCmdBlockMap)

 		{

 		DoCmdBlockMap(aSection);

 		}

 	else

 		{

 		retVal = EFalse;

 		}

 	return retVal;

 	}

 void CT_FileData::DoCmdNewL()

 /** Creates new RFile class instance */

 	{

 	//Deletes previous RFile class instance if it was already created.

 	DoCleanup();

 	INFO_PRINTF1(_L("Create new RFile class instance"));

 	// do create

 	TRAPD(err, iFile = new (ELeave) RFile());

 	if ( err!=KErrNone )

 		{

 		ERR_PRINTF2(_L("Error returned by New()%d"), err);

 		SetError(err);

 		}

 	}

 void CT_FileData::DoCmdDestructor()

 /** Destroy RFile the object */

 	{

 	DoCleanup();

 	}

 void CT_FileData::DoCmdOpenL(const TDesC& aSection)

 /**	Opens files */

 	{

 	RFs*	rfsObject=NULL;

 	TPtrC	rfsObjectName;

 	TBool	dataOk=GET_MANDATORY_STRING_PARAMETER(KRFsName(), aSection, rfsObjectName);

 	if ( dataOk )

 		{

 		rfsObject=(RFs*)GetDataObjectL(rfsObjectName);

 		}

 	TPtrC	filePath;

 	if ( !GET_MANDATORY_STRING_PARAMETER(KFile(), aSection, filePath) )

 		{

 		dataOk=EFalse;

 		}

 	TUint	fileMode = 0;

 	if ( !GetFileModeL(KFileMode, aSection, fileMode) )

 		{

 		ERR_PRINTF2(_L("Open() error reading parameter. %S"), &KFileMode());

 		SetBlockResult(EFail);

 		dataOk=EFalse;

 		}

 	if ( dataOk )

 		{

 		if (rfsObject)

 			{

 			TInt	err = iFile->Open(*rfsObject, filePath, fileMode);

 			if ( err!=KErrNone )

 				{

 				ERR_PRINTF2(_L("Open() failed with Error:%d"), err);

 				SetError(err);

 				}

 			else

 				{

 				iFileOpened = true;

 				}

 			}

 		else

 			{

 			ERR_PRINTF1(_L("RFs object is NULL"));

 			SetBlockResult(EFail);

 			}

 		}

 	}

 void CT_FileData::DoCmdClose()

 /** Close file	 */

 	{

 	INFO_PRINTF1(_L("Closing RFile"));

 	iFile->Close();

 	}

 void CT_FileData::DoCmdCreateL(const TDesC& aSection)

 /** create a new file */

 	{

 	RFs*	rfsObject=NULL;

 	TPtrC	rfsObjectName;

 	TBool	dataOk = ETrue;

 	if ( GET_MANDATORY_STRING_PARAMETER(KRFsName, aSection, rfsObjectName) )

 		{

 		rfsObject=(RFs*)GetDataObjectL(rfsObjectName);

 		}

 	else

 		{

 		dataOk = EFalse;

 		}

 	//	Gets name of file from ini file.

 	TPtrC	name;

 	if ( !GET_MANDATORY_STRING_PARAMETER(KUParamName(), aSection, name) )

 		{

 		dataOk = EFalse;

 		}

 	TUint	fileMode = 0;

 	if ( !GetFileModeL(KFileMode, aSection, fileMode) )

 		{

 		ERR_PRINTF2(_L("Create() error reading parameter. %S"), &KFileMode());

 		SetBlockResult(EFail);

 		dataOk = EFalse;

 		}

 	if ( dataOk )

 		{

 		//	Creates and opens a new file for writing.

 		if (rfsObject)

 			{

 			TInt	err = iFile->Create(*rfsObject, name, fileMode);

 			if ( err!=KErrNone )

 				{

 				ERR_PRINTF2(_L("Create(), error create() = %d"), err);

 				SetError(err);

 				}

 			}

 		else

 			{

 			ERR_PRINTF1(_L("RFs object is NULL"));

 			SetBlockResult(EFail);

 			}

 		}

 	}

 void CT_FileData::DoCmdReplaceL(const TDesC& aSection)

 /** replace a existing file or create new */

 	{

 	TPtrC rfsObjectName;

 	RFs* rfsObject = NULL;

 	TBool	dataOk = ETrue;

 	if ( GET_MANDATORY_STRING_PARAMETER(KRFsName, aSection, rfsObjectName) )

 		{

 		rfsObject=(RFs*)GetDataObjectL(rfsObjectName);

 		}

 	//	Gets name of file from ini file.

 	TPtrC path;

 	if (!GET_MANDATORY_STRING_PARAMETER(KFile(), aSection, path))

 		{

 		dataOk = EFalse;

 		}

 	TUint fileMode = 0;

 	if(!GetFileModeL(KFileMode, aSection, fileMode))

 		{

 		ERR_PRINTF2(_L("Replace() error reading parameter. %S"), &KFileMode());

 		SetBlockResult(EFail);

 		dataOk = EFalse;

 		}

 	//	Creates and opens a new file for writing.

 	if ( dataOk )

 		{

 		//	Creates and opens a new file for writing.

 		if (rfsObject)

 			{

 			TInt	err = iFile->Replace(*rfsObject, path, fileMode);

 			if ( err!=KErrNone )

 				{

 				ERR_PRINTF2(_L("Replace() failed with error = %d"), err);

 				SetError(err);

 				}

 			else

 				{

 				iFileOpened = ETrue;

 				INFO_PRINTF2(_L("File: %S is replaced successfuly"), &path);				

 				}

 			}

 		else

 			{

 			ERR_PRINTF1(_L("RFs object is NULL"));

 			SetBlockResult(EFail);

 			}

 		}

 	}	

 void CT_FileData::DoCmdReadL(const TDesC& aSection, const TInt aAsyncErrorIndex)

 /** wrapper for read commands */

 	{

 	TBool async = EFalse;

 		if(GET_OPTIONAL_BOOL_PARAMETER(KUParamAsync, aSection, async))

 			{

 			if (async)

 				{

 				DoAsynchronousReadsL(aSection, aAsyncErrorIndex);	

 				}

 			else

 				{

 				DoSynchronousReadsL(aSection);

 				}

 			}

 		else

 			{

 			DoSynchronousReadsL(aSection);

 			}

 	}

 TBool CT_FileData::GetFileModeL(const TDesC& aParameterName, const TDesC& aSection, TUint& aFileMode)

 /** process the filemode from ini  */

 	{

 	TBool ret = ETrue;

 	TPtrC aModeStr;

 	if(GET_OPTIONAL_STRING_PARAMETER(aParameterName, aSection, aModeStr))

 		{

 		//break the file mode string to array of file modes

 		//in case there's more than one filemode		

 		RPointerArray<HBufC> fileModes = SplitL(aModeStr, "|");		

 		for ( int i = 0 ; i < fileModes.Count() ; i++ )

 			{

 			if (*fileModes[i] == KEFileShareExclusive)

 				{

 				aFileMode = aFileMode | EFileShareExclusive ;

 				}

 			else if (*fileModes[i] ==  KEFileShareReadersOnly)

 				{

 				aFileMode = aFileMode | EFileShareReadersOnly;

 				}

 			else if (*fileModes[i] ==  KEFileShareAny)

 				{

 				aFileMode = aFileMode | EFileShareAny;

 				}		

 			else if (*fileModes[i] ==  KEFileShareReadersOrWriters)

 				{

 				aFileMode = aFileMode | EFileShareReadersOrWriters;

 				}					

 			else if (*fileModes[i] ==  KEFileStream)

 				{

 				aFileMode = aFileMode | EFileStream;

 				}					

 			else if (*fileModes[i] ==  KEFileStreamText)

 				{

 				aFileMode = aFileMode | EFileStreamText;

 				}					

 			else if (*fileModes[i] ==  KEFileRead)

 				{

 				aFileMode = aFileMode | EFileRead;

 				}					

 			else if (*fileModes[i] ==  KEFileWrite)

 				{

 				aFileMode = aFileMode | EFileWrite;

 				}

 			else if (*fileModes[i] ==  KEFileReadAsyncAll)

 				{

 				aFileMode = aFileMode | EFileReadAsyncAll;

 				}

 			else

 				{

 				aFileMode = EFileShareAny;

 				ret = EFalse;

 				}

 			}

 		for (int j=0 ; j<fileModes.Count() ; j++)

 			{

 			HBufC* temp = fileModes[j];

 			delete temp;

 			temp = NULL;

 			}

 		fileModes.Close();

 		}

 	else

 		{

 		ret = EFalse;

 		}

 	return ret;

 	}

 void CT_FileData::DoSynchronousReadsL(const TDesC& aSection)

 /** process all synchronous reads */

 	{	

 	TInt length;

 	TInt pos;

 	HBufC8* filedata = NULL;	

 	TInt bufferLength;

 //get optional buffer length from ini file	

 	if (GET_OPTIONAL_INT_PARAMETER(KUParamBufferLength, aSection, bufferLength))

 		{

 		filedata = HBufC8::NewLC(bufferLength);

 		}

 	else

 		{

 		filedata = HBufC8::NewLC(KDefaultDescSize);

 		}

 	TPtr8 filedataPtr = filedata->Des();

 	TInt err = 0;

 //devide which read to call, by switching between parameters fetched from ini file.	

 	if(GET_OPTIONAL_INT_PARAMETER(KUParamLength, aSection, length))

 		{

 		if(GET_OPTIONAL_INT_PARAMETER(KUParamPos, aSection, pos))

 			{

 			INFO_PRINTF1(_L("calling RFile::Read(TInt& aPos, TDes8 &aData, TInt aLen)"));

 			err = iFile->Read(pos, filedataPtr, length);

 			HandleExpectedString(filedataPtr, aSection);

 			}

 		else

 			{

 			INFO_PRINTF1(_L("calling RFile::Read(TDes8 &aData, TInt aLen)"));

 			err = iFile->Read(filedataPtr, length);

 			HandleExpectedString(filedataPtr, aSection);

 			}

 		}

 	else

 		{

 		if(GET_OPTIONAL_INT_PARAMETER(KUParamPos, aSection, pos))

 			{

 			INFO_PRINTF1(_L("calling RFile::Read(TInt& aPos, TDes8 &aData)"));

 			err = iFile->Read(pos, filedataPtr);

 			HandleExpectedString(filedataPtr, aSection);

 			}

 		else

 			{

 			INFO_PRINTF1(_L("calling RFile::Read(TDes8 &aData)"));

 			err = iFile->Read(filedataPtr);

 			HandleExpectedString(filedataPtr, aSection);

 			}

 		}

 	TBuf<KDefaultDescSize> filedata16;

 	filedata16.Copy(filedataPtr);

 	INFO_PRINTF2(_L("read \"%S\" from file"), &filedata16);		

 //did the read complete with error code?		

 	if (err != KErrNone)

 		{

 		ERR_PRINTF2(_L("error executing synchronous read %d"), err);

 		SetError(err);

 		}

 	CleanupStack::PopAndDestroy(1);		

 	}

 void CT_FileData::DoAsynchronousReadsL(const TDesC& aSection, const TInt aAsyncErrorIndex)

 /**process all asynchronous reads */

 	{

 	TInt length;

 	TInt pos;

 	CT_FileActiveCallback* active = CT_FileActiveCallback::NewL(*this);

 	iReadCallbackArray.Append(active);

 	TInt bufferLength;

 	//Get the buffer length, and create the buffer for activeCallback object

 	if (GET_OPTIONAL_INT_PARAMETER(KUParamBufferLength, aSection, bufferLength))

 		{

 		active->CreateFileDataBufferL(bufferLength);

 		}

 	else

 		{

 		active->CreateFileDataBufferL(KDefaultDescSize);

 		}	

 	TPtr8 fileDataPtr = active->iFileData->Des();

 	//decide which read to call	

 	if(GET_OPTIONAL_INT_PARAMETER(KUParamLength, aSection, length))

 		{

 		if(GET_OPTIONAL_INT_PARAMETER(KUParamPos, aSection, pos))

 			{

 			INFO_PRINTF1(_L("calling RFile::Read(TInt& aPos, TDes8 &aData, TInt aLen, TRequestiStatus aiStatus)"));

 			iFile->Read(pos, fileDataPtr, length,active->iStatus);

 			}

 		else

 			{

 			INFO_PRINTF1(_L("calling RFile::Read(TDes8 &aData, TInt aLen, TRequestiStatus aiStatus)"));

 			iFile->Read(fileDataPtr, length, active->iStatus);

 			}

 		}

 	else

 		{

 		if(GET_OPTIONAL_INT_PARAMETER(KUParamPos, aSection, pos))

 			{

 			INFO_PRINTF1(_L("calling RFile::Read(TInt& aPos, TDes8 &aData, TRequestiStatus aiStatus)"));

 			iFile->Read(pos, fileDataPtr, active->iStatus);

 			}

 		else

 			{

 			INFO_PRINTF1(_L("calling RFile::Read(TDesC &aData, TRequestiStatus aiStatus)"));

 			iFile->Read(fileDataPtr, active->iStatus);

 			}

 		}

 	//acitvate callback object

 	active->SetSection(aSection);

 	active->Activate(aAsyncErrorIndex);

 	IncOutstanding();

 	}

 void CT_FileData::HandleExpectedString(const TDesC& aReadedData, const TDesC& aSection)

 /** compare the expected string with readed string, takes 16-bit parameter*/

 	{

 	TPtrC expectedString;

 	if(GET_OPTIONAL_STRING_PARAMETER(KUParamExpectedString, aSection, expectedString))

 		{

 		if (aReadedData == expectedString)

 			{

 			INFO_PRINTF1(_L("expected string matches with the data read"));			

 			}

 		else

 			{

 			ERR_PRINTF1(_L("expected string does not match with the data read"));

 			SetBlockResult(EFail);

 			}

 		}

 	}

 void CT_FileData::HandleExpectedString(const TDesC8& aReadedData, const TDesC& aSection)

 /** compare the expected string with readed string, takes 16-bit parameter */

 	{

 	TBuf<KDefaultDescSize> readedData16;

 	readedData16.Copy(aReadedData);

 	TPtrC expectedString;

 	if(GET_OPTIONAL_STRING_PARAMETER(KUParamExpectedString, aSection, expectedString))

 		{

 		if (readedData16 == expectedString)

 			{

 			INFO_PRINTF1(_L("expected string matches with the data read"));			

 			}

 		else

 			{

 			ERR_PRINTF1(_L("expected string does not match with the data read"));

 			SetBlockResult(EFail);

 			}

 		}

 	}		

 void CT_FileData::DoCmdFlushL(const TDesC& aSection, const TInt aAsyncErrorIndex)

 /** flush all the internal buffers to file */

 	{

 	TBool async = false;

 	TInt err = 0;

 	//get the parameter from ini, to decide which version of RFile::Flush to call

 	GET_OPTIONAL_BOOL_PARAMETER(KUParamAsync, aSection, async);

 	if (async == true)

 		{		

 		CActiveCallback* active = CActiveCallback::NewL(*this);

 		iFlushCallbackArray.Append( active );

 		iFile->Flush(active->iStatus);

 		active->Activate(aAsyncErrorIndex);

 		IncOutstanding();

 		}

 	else

 		{

 		err = iFile->Flush();

 		if (err != KErrNone)

 			{

 			ERR_PRINTF2(_L("Flush() failed with error code. %d"), err);

 			SetError(err);

 			}

 		else

 			{

 			INFO_PRINTF1(_L("Succesfully flushed the file"));

 			}

 		}	

 	}	

 void CT_FileData::DoCmdTempL(const TDesC& aSection)

 /* create temporary file */

 	{

 	TPtrC rfsObjectName;

 	RFs* rfsObject = NULL;

 	TBool	dataOk=GET_MANDATORY_STRING_PARAMETER(KRFsName, aSection, rfsObjectName);

 	if ( dataOk )

 		{

 		rfsObject=(RFs*)GetDataObjectL(rfsObjectName);

 		}

 	//	Gets name of file from ini file.

 	TPtrC path;

 	if (!GET_MANDATORY_STRING_PARAMETER(KUParamPath(), aSection, path))

 		{

 		dataOk=EFalse;

 		}

 	TUint fileMode = 0;

 	if(!GetFileModeL(KFileMode, aSection, fileMode))

 		{

 		ERR_PRINTF2(_L("Temp() error reading parameter. %S"), &KFileMode());

 		SetBlockResult(EFail);

 		dataOk=EFalse;

 		}

 	//	Creates Temporary file.

 	TFileName fileName;

 	if ( dataOk )

 		{

 		if (rfsObject)

 			{

 			TInt	err = iFile->Temp(*rfsObject, path, fileName,fileMode);

 			INFO_PRINTF2(_L("File: %S is created"), &fileName);			

 			if ( err!=KErrNone )

 				{

 				ERR_PRINTF2(_L("Temp() failed with error = %d"), err);

 				SetError(err);

 				}

 			else

 				{

 				iFileOpened = ETrue;				

 				}				

 			}

 		else

 			{

 			ERR_PRINTF1(_L("RFs object is NULL"));

 			SetBlockResult(EFail);

 			}

 		}	

 	}	

 void CT_FileData::DoCmdRenameL(const TDesC& aSection)

 /** rename the file */

 	{

 	TPtrC newName;

 	//get the name from ini and rename the file.

 	if(GET_MANDATORY_STRING_PARAMETER(KUParamName(), aSection, newName))

 		{	

 		TInt err = iFile->Rename(newName);

 		if (err != KErrNone)

 			{

 			ERR_PRINTF2(_L("Rename() failed with error code %d"), err);

 			SetError(err);

 			}

 		}

 	}	

 void CT_FileData::DoCmdSeekL(const TDesC& aSection)

 /** set the file cursor to specified location in file */

 	{

 	TSeek seek = ESeekStart;

 	TBool dataOk = EFalse;

 	TInt pos;

 	//convert the mode string from ini to TSeek

 	if(ConvertToSeek(KSeek, aSection,seek))

 		{

 		dataOk = GET_MANDATORY_INT_PARAMETER(KUParamPos(), aSection, pos);		

 		}	

 	if(dataOk)

 		{

 		TInt err = iFile->Seek(seek, pos);

 		if(err != KErrNone)	

 			{

 			ERR_PRINTF2(_L("Seek(), error seeking() = %d"), err);

 			SetError(err);

 			}

 		else

 			{

 			INFO_PRINTF1(_L("Succesfully seeked the file"));

 			}

 		}

 	}	

 TBool CT_FileData::ConvertToSeek(const TDesC& aParameterName, const TDesC& aSection, TSeek& aSeek)

 /** convert a seek mode string from ini to TSeek */

 	{

 	TBool ret = ETrue;

 	TPtrC aModeStr;

 	if(GET_MANDATORY_STRING_PARAMETER(aParameterName, aSection, aModeStr))

 		{

 		if (aModeStr == KESeekStart)

 			{

 			aSeek = ESeekStart;

 			}

 		else if (aModeStr == KESeekCurrent)

 			{

 			aSeek = ESeekCurrent;

 			}

 		else if (aModeStr == KESeekEnd)

 			{

 			aSeek = ESeekEnd;

 			}

 		else

 			{

 			ret = EFalse;

 			}

 		}

 	else

 		{

 		ret = EFalse;

 		}

 	return ret;

 	}	

 void CT_FileData::DoCmdReadCancelL(const TDesC& aSection)

 /** wrapper for readcancels */

 	{

 	TBool cancelAll;

 	//decide which ReadCancel to call

 	if(GET_OPTIONAL_BOOL_PARAMETER(KUParamCancelAll, aSection, cancelAll))

 		{

 		if (cancelAll == true)

 			{

 			ReadCancelAll();

 			}

 		else

 			{

 			ReadCancel();

 			}

 		}

 	else

 		{

 		ReadCancel();

 		}

 	}	

 void CT_FileData::ReadCancel()

 /** will cancel the last active request by default */

 	{

 	iFile->ReadCancel(iReadCallbackArray[iReadCallbackArray.Count()-1]->iStatus);

 	}

 void CT_FileData::ReadCancelAll()

 /** cancel all outstanding read requests */

 	{

 	iFile->ReadCancel();

 	}

 // the write implementation

 void CT_FileData::DoCmdWriteL(const TDesC& aSection, const TInt aAsyncErrorIndex)

 /** wrapper for write commands */

 	{

 	TBool async = EFalse;

 	//decide which write to call

 	GET_OPTIONAL_BOOL_PARAMETER(KUParamAsync, aSection, async);

 	if (async == true)

 		{

 		DoAsynchronousWritesL(aSection, aAsyncErrorIndex);	

 		}

 	else

 		{

 		DoSynchronousWritesL(aSection);

 		}

 	}

 void CT_FileData::DoAsynchronousWritesL(const TDesC& aSection, const TInt aAsyncErrorIndex)

 /** call asynchronous writes */

 	{

 	HBufC8* dataWrite8;

 	TInt bufferLength;

 	//Get the buffer length, and create the buffer for activeCallback object

 	if (GET_OPTIONAL_INT_PARAMETER(KUParamBufferLength, aSection, bufferLength))

 		{

 		dataWrite8 = HBufC8::NewLC(bufferLength);

 		}

 	else

 		{

 		dataWrite8 = HBufC8::NewLC(KDefaultDescSize);

 		}	

 	TPtr8 data8Ptr = dataWrite8->Des();

 	TPtrC data;

 	// Get the data to write

 	if(GET_MANDATORY_STRING_PARAMETER(KUParamData(), aSection, data))

 		{

 		//convert it to 8-bit

 		data8Ptr.Copy(data);

 		CActiveCallback* active = CActiveCallback::NewL(*this);

 		iWriteCallbackArray.Append( active );

 		TInt length;

 		TInt pos;	

 		//now, decide which read to call

 		if(GET_OPTIONAL_INT_PARAMETER(KUParamLength, aSection, length))

 			{

 			if(GET_OPTIONAL_INT_PARAMETER(KUParamPos, aSection, pos))

 				{

 				INFO_PRINTF1(_L("calling RFile::Write(TInt& aPos, TDesC8 &aData, TInt aLen, TRequestStatus &aStatus)"));

 				iFile->Write(pos, *dataWrite8, length, active->iStatus);

 				}

 			else

 				{

 				INFO_PRINTF1(_L("calling RFile::Write(TDesC8 &aData, TInt aLen, , TRequestStatus &aStatus)"));

 				iFile->Write(*dataWrite8, length, active->iStatus);

 				}

 			}

 		else

 			{

 			if(GET_OPTIONAL_INT_PARAMETER(KUParamPos, aSection, pos))

 				{

 				INFO_PRINTF1(_L("calling RFile::Write(TInt& aPos, TDesC8 &aData, TRequestStatus &aStatus)"));

 				iFile->Write(pos, *dataWrite8, active->iStatus);

 				}

 			else

 				{

 				INFO_PRINTF1(_L("calling RFile::Write(TDesC8 &aData, TRequestStatus &aStatus)"));

 				iFile->Write(*dataWrite8, active->iStatus);

 				}

 			}

 		active->Activate(aAsyncErrorIndex);

 		IncOutstanding();

 		}

 	CleanupStack::PopAndDestroy();	

 	}

 void CT_FileData::DoSynchronousWritesL(const TDesC& aSection)

 /** cakk synchronous writes */

 	{

 	HBufC8* dataWrite8;

 	TInt bufferLength;

 	//Get the buffer length, and create the buffer for activeCallback object

 	if (GET_OPTIONAL_INT_PARAMETER(KUParamBufferLength, aSection, bufferLength))

 		{

 		dataWrite8 = HBufC8::NewLC(bufferLength);

 		}

 	else

 		{

 		dataWrite8 = HBufC8::NewLC(KDefaultDescSize);

 		}	

 	TPtr8 data8Ptr = dataWrite8->Des();

 	TInt err = 0;

 	TPtrC data;	

 	// get the data

 	if (GET_MANDATORY_STRING_PARAMETER(KUParamData(), aSection, data))

 		{

 		//convert it to 8-bit		

 		data8Ptr.Copy(data);

 		TInt length;

 		TInt pos;

 		//will decide which write to call 

 		if(GET_OPTIONAL_INT_PARAMETER(KUParamLength, aSection, length))

 			{

 			if(GET_OPTIONAL_INT_PARAMETER(KUParamPos, aSection, pos))

 				{

 				INFO_PRINTF1(_L("calling RFile::Write(TInt& aPos, TDesC8 &aData, TInt aLen)"));

 				err = iFile->Write(pos, *dataWrite8, length);

 				}

 			else

 				{

 				INFO_PRINTF1(_L("calling RFile::Write(TDesC8 &aData, TInt aLen)"));

 				err = iFile->Write(*dataWrite8, length);

 				}

 			}

 		else

 			{

 			if(GET_OPTIONAL_INT_PARAMETER(KUParamPos, aSection, pos))

 				{

 				INFO_PRINTF1(_L("calling RFile::Write(TInt& aPos, TDesC8 &aData)"));

 				err = iFile->Write(pos, *dataWrite8);

 				}

 			else

 				{

 				INFO_PRINTF1(_L("calling RFile::Write(TDesC8 &aData)"));

 				err = iFile->Write(*dataWrite8);

 				}

 			}

 		if (err == KErrNone)

 			{

 			INFO_PRINTF2(_L("written \"%S\" to file"), &data);

 			}

 		else

 			{

 			ERR_PRINTF2(_L("Error executing synchronous write %d"), err);

 			SetError(err);

 			}

 		}

 	CleanupStack::PopAndDestroy();	

 	}	

 void CT_FileData::DoCmdLockL(const TDesC& aSection)

 /** lock a region in file */

 	{

 	TInt pos=0;

 	TBool dataOk = ETrue;

 	//get the position

 	if(!GET_MANDATORY_INT_PARAMETER(KUParamPos(), aSection, pos))

 		{

 		dataOk = EFalse;

 		}

 	TInt length=0;	

 	// get the length

 	if(!GET_MANDATORY_INT_PARAMETER(KUParamLength(), aSection, length))

 		{

 		dataOk = EFalse;

 		}

 	//Lock!!

 	if (dataOk)

 		{

 		TInt err = iFile->Lock(pos, length);

 		if(err!=KErrNone)

 			{

 			ERR_PRINTF2(_L("Lock() error locking file. %d"), err);

 			SetError(err);	

 			}	

 		}

 	}	

 void CT_FileData::DoCmdUnLockL(const TDesC& aSection)

 /** unlock a region that has been previously locked */

 	{

 	TBool dataOk = ETrue;

 	TInt pos=0;

 	//get the position

 	if(!GET_MANDATORY_INT_PARAMETER(KUParamPos(), aSection, pos))

 		{

 		dataOk = EFalse;

 		}

 	TInt length=0;

 	// get the length

 	if(!GET_MANDATORY_INT_PARAMETER(KUParamLength(), aSection, length))

 		{

 		dataOk = EFalse;

 		}

 	//call UnLock

 	if (dataOk)

 		{

 		TInt err = iFile->UnLock(pos, length);

 		if(err!=KErrNone)

 			{

 			ERR_PRINTF2(_L("UnLock() error unlocking file. %d"), err);

 			SetError(err);	

 			}

 		else

 			{

 			INFO_PRINTF1(_L("Succesfully unlocked the file"));

 			}

 		}

 	}	

 void CT_FileData::DoCmdSizeL(const TDesC& aSection)

 /** get file size */

 	{

 	TInt expectedSize =  0;

 	TInt size = 0;

 	TInt err = iFile->Size(size);

 	INFO_PRINTF2(_L("The Size of the file is %d bytes"), size);	

 	if (err != KErrNone)

 		{

 		ERR_PRINTF2(_L("Size() error getting file size. %d"), err);

 		SetError(err);

 		}

 	else

 		{

 		//get expected size from ini

 		if(GET_OPTIONAL_INT_PARAMETER(KUParamExpectedSize(), aSection, expectedSize))		

 			{

 			if(expectedSize != size)

 				{

 				ERR_PRINTF3(_L("The file size does not match the expected size %d != %d"), size, expectedSize)				

 				SetBlockResult(EFail);

 				}

 			}

 		}

 	}

 void CT_FileData::DoCmdSetSizeL(const TDesC& aSection)

 /** set file size */

 	{

 	TInt size=0;

 	if(GET_MANDATORY_INT_PARAMETER(KUParamSize(), aSection, size))

 		{

 		TInt err = iFile->SetSize(size);

 		if (err != KErrNone)

 			{

 			ERR_PRINTF2(_L("SetSize() error setting file size. %d"), err);

 			SetError(err);	

 			}

 		else

 			{

 			INFO_PRINTF2(_L("The Size of the fail is set to %d bytes"), size);	

 			}			

 		}

 	}	

 void CT_FileData::DoCmdAttL(const TDesC& aSection)

 /** get file attributes */

 	{

 	TUint attValue = 0;

 	TInt err = iFile->Att(attValue);

 	PrintFileAttributes(attValue);

 	if (err != KErrNone)

 		{

 		ERR_PRINTF2(_L("Att() getting attributes. %d"), err);

 		SetError(err);	

 		}

 	else

 		{

 		TUint bitmask = 0x000000FF;

 		//lets filter out symbian specific bits

 		attValue = attValue & bitmask;

 		TUint attCompare = 0;

 		//compare the expected att value with the file attributes

 		if (ConvertToAttributeL(KUParamCompareValue, aSection, attCompare))

 			{

 			if (attCompare == attValue)

 				{

 				INFO_PRINTF1(_L("attributes match"));

 				}

 			else

 				{

 				ERR_PRINTF1(_L("Attributes does not match"));

 				SetBlockResult(EFail);

 				}

 			}

 		}

 	}

 void CT_FileData::DoCmdSetAttL(const TDesC& aSection)

 /** set file attributes */

 	{

 	TUint setAttMask = 0;

 	TBool dataOk = ETrue;

 	//get the attribute mask to set

 	if(!ConvertToAttributeL(KUParamSetAttMask, aSection, setAttMask))

 		{

 		ERR_PRINTF2(_L("SetATt() error reading parameter. %S"), &KUParamSetAttMask());

 		SetBlockResult(EFail);	

 		dataOk = EFalse;

 		}

 	TUint clearAttMask = 0;

 	//get the attribute mask to clear

 	if(!ConvertToAttributeL(KUParamClearAttMask, aSection, clearAttMask))

 		{

 		ERR_PRINTF2(_L("SetAtt() error reading parameter. %S"), &KUParamClearAttMask());

 		SetBlockResult(EFail);	

 		dataOk = EFalse;

 		}

 	// all ok? let's call SetAtt		

 	if (dataOk)

 		{

 		TInt err = iFile->SetAtt(setAttMask, clearAttMask);

 		if (err != KErrNone)

 			{

 			ERR_PRINTF2(_L("SetAtt() failed with, err: %d"), err);

 			SetError(err);	

 			}

 		else

 			{

 			INFO_PRINTF1(_L("The attribute value has been set"));	

 			}	

 		}

 	}	

 TBool CT_FileData::ConvertToAttributeL(const TDesC& aParameterName, const TDesC& aSection, TUint& aAttribute)

 /** convert attribute string from ini to file attribute bitmask */

 	{

 	TBool ret = ETrue;

 	TPtrC aModeStr;

 	if(GET_OPTIONAL_STRING_PARAMETER(aParameterName, aSection, aModeStr))

 		{

 		//break the file mode string to array of file modes

 		//in case there's more than one filemode		

 		RPointerArray<HBufC> fileModes = SplitL(aModeStr, "|");		

 		for ( int i = 0 ; i < fileModes.Count() ; i++ )

 			{

 			if (aModeStr == KDEntryAttNormal)

 				{

 				aAttribute = aAttribute | KEntryAttNormal;

 				}

 			else if (aModeStr == KDEntryAttReadOnly)

 				{

 				aAttribute = aAttribute | KEntryAttReadOnly;

 				}

 			else if (aModeStr == KDEntryAttArchive)

 				{

 				aAttribute = aAttribute | KEntryAttArchive;

 				}

 			else if (aModeStr == KDEntryAttHidden)

 				{

 				aAttribute = aAttribute | KEntryAttHidden;

 				}

 			else if (aModeStr == KDEntryAttSystem)

 				{

 				aAttribute = aAttribute | KEntryAttSystem;

 				}

 			else if (aModeStr == KDEntryAttVolume)

 				{

 				aAttribute = aAttribute | KEntryAttVolume;

 				}

 			else if (aModeStr == KDEntryAttDir)

 				{

 				aAttribute = aAttribute | KEntryAttDir;

 				}

 			else if (aModeStr == KDEntryAttXIP)

 				{

 				aAttribute = aAttribute | KEntryAttXIP;

 				}

 			else if (aModeStr == KDEntryAttRemote)

 				{

 				aAttribute = aAttribute | KEntryAttRemote;

 				}

 			else

 				{

 				ret = EFalse;

 				}

 			}

 		for (int j=0 ; j<fileModes.Count() ; j++)

 			{

 			HBufC* temp = fileModes[j];

 			delete temp;

 			temp = NULL;

 			}

 		fileModes.Close();

 		}

 	else

 		{

 		ret = EFalse;

 		}

 	return ret;

 	}	

 void CT_FileData::DoCmdModifiedL(const TDesC& aSection)

 /** get file modification date */

 	{

 	TTime time;

 	TInt err = iFile->Modified(time);

 	_LIT(KDateString,"%E%D%X%N%Y %1 %2 %3");	

 	TBuf<KDefaultDescSize> dateString;

 	//format the time to string	

 	TRAPD(err2, time.FormatL(dateString, KDateString));

 	if(err2 != KErrNone)

 		{

 		ERR_PRINTF2(_L("Modified() error formating date string err: %d"), err);

 		}

 	INFO_PRINTF2(_L("Modified() returned: %S"), &dateString);

 	if (err != KErrNone)

 		{

 		ERR_PRINTF2(_L("Modified() failed with, err: %d"), err);

 		SetError(err);	

 		}

 	else

 		{

 		//compare the file modification date with the date readed from inin

 		TPtrC compValue;

 		if (GET_OPTIONAL_STRING_PARAMETER(KUParamCompareValue, aSection, compValue))

 			{

 			TTime compTime;

 			err = compTime.Set(compValue);

 			if ( err != KErrNone )

 				{

 				ERR_PRINTF1(_L("invalid compare value"));

 				}

 			else

 				{

 				if (compTime == time)

 					{

 					INFO_PRINTF1(_L("The dates match"));

 					}

 				else

 					{

 					ERR_PRINTF1(_L("The values do not match"));

 					SetBlockResult(EFail);

 					}

 				}

 			}		

 		}		

 	}

 void CT_FileData::DoCmdSetModifiedL(const TDesC& aSection)

 /** set file modification date */

 	{

 	TPtrC dateDesc;

 	TBool dataOk = ETrue;

 	TTime time;

 	TInt err = KErrNone;

 	if(!GET_MANDATORY_STRING_PARAMETER(KUParamDate(), aSection, dateDesc))

 		{

 		dataOk = EFalse;

 		}

 	else

 		{

 		err = time.Set(dateDesc);

 		}

 	if (err != KErrNone)

 		{

 		ERR_PRINTF2(_L("time.Set() failed with error code %d"), err);

 		SetBlockResult(EFail);

 		dataOk = EFalse;

 		}

 	if (dataOk)

 		{

 		err = iFile->SetModified(time);

 		if (err != KErrNone)

 			{

 			ERR_PRINTF2(_L("SetModified() failed with error code %d"), err);

 			SetError(err);			

 			}		

 		}

 	}

 void CT_FileData::DoCmdSetL(const TDesC& aSection)

 /** set file attributes and modification time */

 	{

 	TPtrC dateDesc;

 	TBool dataOk = ETrue;

 	TInt err = KErrNone;

 	TTime time;

 	//get and process the date string

 	if(!GET_MANDATORY_STRING_PARAMETER(KUParamDate(), aSection, dateDesc))

 		{

 		dataOk = EFalse;

 		}

 	else

 		{

 		err = time.Set(dateDesc);

 		}		

 	TUint setAttMask = 0;

 	// get the attribute masks	

 	if(!ConvertToAttributeL(KUParamSetAttMask, aSection,setAttMask))

 		{

 		dataOk = EFalse;

 		}	

 	TUint clearAttMask = 0;	

 	if(!ConvertToAttributeL(KUParamClearAttMask, aSection, clearAttMask))

 		{

 		dataOk = EFalse;

 		}			

 	// if all Ok then proceed with Set	

 	if (dataOk)

 		{

 		err = iFile->Set(time, setAttMask, clearAttMask);

 		if ( err != KErrNone)

 			{

 			ERR_PRINTF2(_L("Set() failed with error code %d"), err);

 			SetError(err);

 			}		

 		}

 	}

 void CT_FileData::DoCmdChangeModeL(const TDesC& aSection)

 /** Change the file mode */

 	{

 	TUint fileMode = 0;

 	if(!GetFileModeL(KFileMode, aSection, fileMode))

 		{

 		ERR_PRINTF2(_L("Set() error reading parameter. %S"), &KFileMode());

 		SetBlockResult(EFail);	

 		}

 	else

 		{

 		TInt err = iFile->ChangeMode((TFileMode)fileMode);

 		if ( err != KErrNone )

 			{

 			ERR_PRINTF2(_L("ChangeMode() failed with error code %d"), err);

 			SetError(err);

 			}	

 		}

 	}	

 void CT_FileData::DoCmdDriveL(const TDesC& aSection)

 /** Get the drive info, in which the file is stored */

 	{

 	TDriveInfo driveInfo;

 	TInt driveNumber;

 	int err = iFile->Drive(driveNumber, driveInfo);

 	INFO_PRINTF2(_L("TDriveInfo.iType    =%d"), driveInfo.iType);

 	INFO_PRINTF2(_L("TDriveInfo.iBattery =%d"), driveInfo.iBattery);

 	INFO_PRINTF2(_L("TDriveInfo.iDriveAtt=0x%X"), driveInfo.iDriveAtt);

 	INFO_PRINTF2(_L("Drivenumber 		 =%d"), driveNumber);	

 	if (err != KErrNone)

 		{

 		ERR_PRINTF2(_L("Drive() failed with error code %d"), err);

 		SetError(err);

 		}

 	else

 		{

 		TInt compDriveNumber;

 		if ( GET_OPTIONAL_INT_PARAMETER(KUParamCompareValue, aSection, compDriveNumber))

 			{

 				if ( compDriveNumber == driveNumber )

 					{

 					INFO_PRINTF3(_L("drivenumbers match %d == %d "), compDriveNumber, driveNumber);

 					}

 				else 

 					{

 					ERR_PRINTF3(_L("drivenumbers do not match %d != %d"), compDriveNumber, driveNumber);

 					SetBlockResult(EFail);

 					}

 			}		

 		}

 	}	

 void CT_FileData::DoCmdDuplicateL(const TDesC& aSection)

 /** Duplicate the file */

 	{

 	TPtrC rFileObjectName;

 	TBool dataOk = GET_MANDATORY_STRING_PARAMETER(KFileObjectName, aSection, rFileObjectName);

 	// get the RFile handle to duplicate	

 	RFile* rFileObject = NULL;

 	if (dataOk)

 		{

 		rFileObject=(RFile*)GetDataObjectL(rFileObjectName);

 		if(rFileObject == NULL)

 			{

 			ERR_PRINTF2(_L("Duplicate() error getting object. %S"), KFileObjectName);

 			SetBlockResult(EFail);	

 			dataOk = EFalse;

 			}

 		}

 	// if handle ok then procees with duplication	

 	if (dataOk)

 		{

 		TOwnerType ownerType;

 		TInt err = KErrNone;	

 		// determine the owner type to pass to duplicate

 		if (ConvertToOwnerType(KUParamOwnerType, aSection, ownerType) && dataOk)

 			{

 			err = iFile->Duplicate(*rFileObject, ownerType);

 			}

 		else

 			{

 			err = iFile->Duplicate(*rFileObject);

 			}

 		if (err != KErrNone)

 			{

 			ERR_PRINTF2(_L("Duplicate() error duplicating %d"), err);

 			SetError(err);

 			}

 		else

 			{	

 			//lets mark the file to be opened

 			iFileOpened = ETrue;		

 			}

 		}

 	}	

 TBool CT_FileData::ConvertToOwnerType(const TDesC& aParameterName, const TDesC& aSection, TOwnerType& aResult)

 /** convert the ownerType string from ini to EOwnerType */

 	{

 	TBool ret = ETrue;

 	TPtrC ownerTypeString;

 	if(GET_OPTIONAL_STRING_PARAMETER(aParameterName, aSection, ownerTypeString))

 		{

 		if (ownerTypeString == KEOwnerProcess )

 			{

 			aResult = EOwnerProcess;

 			}

 		else if (ownerTypeString == KEOwnerThread)

 			{

 			aResult = EOwnerThread;

 			}

 		else

 			{

 			ret = EFalse;

 			}

 		}

 	else

 		{

 		ret = EFalse;

 		}

 	return ret;

 	}	

 void CT_FileData::DoCmdFullName(const TDesC& aSection)

 /** get the file fullname */

 	{

 	TBuf<128> name;

 	TInt err = iFile->FullName(name);

 	INFO_PRINTF2(_L("FullName() returned  %S"), &name);		

 	if(err != KErrNone)

 		{

 		ERR_PRINTF2(_L("FullName() error, returned. %d"), err);

 		SetError(err);	

 		}

 	else

 		{

 		TPtrC path;	

 		if(GET_OPTIONAL_STRING_PARAMETER(KUParamComparePath, aSection, path))

 			{

 			if (path == name)

 				{

 				INFO_PRINTF1(_L("the paths match"));	

 				}

 			else

 				{

 				ERR_PRINTF1(_L("the paths do not match"));

 				SetBlockResult(EFail);

 				}

 			}				

 		}

 	}	

 void CT_FileData::DoCmdNameL(const TDesC& aSection)

 /** get the file name */

 	{

 	TBuf<KDefaultDescSize> name;

 	TInt err = iFile->Name(name);

 	INFO_PRINTF2(_L("Name() returned  %S"), &name);	

 	if(err != KErrNone)

 		{

 		ERR_PRINTF2(_L("Name() error, returned. %d"), err);

 		SetError(err);	

 		}

 	else	

 		{

 		TPtrC compValue;	

 		if (GET_OPTIONAL_STRING_PARAMETER(KUParamCompareValue, aSection, compValue))

 			{

 			if (compValue == name)

 				{

 				INFO_PRINTF3(_L("The names match %S == %S"), &name, &compValue);

 				}

 			else

 				{

 				ERR_PRINTF3(_L("The names do not match %S == %S"), &name, &compValue);			

 				SetBlockResult(EFail);

 				}

 			}		

 		}

 	}	

 TBool CT_FileData::ConvertToBlockMapUsage(const TDesC& aParameterName, const TDesC& aSection, TBlockMapUsage& aResult)

 	{

 	TBool ret = ETrue;

 	TPtrC blockmapeUsageString;

 	if(GET_OPTIONAL_STRING_PARAMETER(aParameterName, aSection, blockmapeUsageString))

 		{

 		if (blockmapeUsageString == KEBlockMapUsagePaging )

 			{

 			aResult = EBlockMapUsagePaging;

 			}

 		else if (blockmapeUsageString == KETestDebug)

 			{

 			aResult = ETestDebug;

 			}

 		else

 			{

 			ret = EFalse;

 			}

 		}

 	else

 		{

 		ret = EFalse;

 		}

 	return ret;

 	}	

 void CT_FileData::DoCmdBlockMap(const TDesC& aSection)

 	{

 	TInt64 startPos = 0;

 	GET_OPTIONAL_INT64_PARAMETER(KUParamStartPos, aSection, startPos);

 	SBlockMapInfo blockMapInfo;

 	TInt err = KErrNone;

 	TInt64 endPos = -1;

 	if (GET_OPTIONAL_INT64_PARAMETER(KUParamEndPos, aSection, endPos))

 		{

 		TBlockMapUsage usage;

 		if (ConvertToBlockMapUsage(KUParamUsage, aSection, usage))

 			{

 			err = iFile->BlockMap(blockMapInfo, startPos, endPos, usage);

 			}

 		else

 			{

 			err = iFile->BlockMap(blockMapInfo, startPos, endPos);

 			}

 		}

 	else

 		{

 		TBlockMapUsage usage;

 		if (ConvertToBlockMapUsage(KUParamUsage, aSection, usage))

 			{

 			err = iFile->BlockMap(blockMapInfo, startPos, usage);

 			}

 		else

 			{		

 			err = iFile->BlockMap(blockMapInfo, startPos);

 			}

 		}

 	if (KErrNone != err)

 		{

 		ERR_PRINTF2(_L("BlockMap Returned an error %d"), err);

 		SetError(err);

 		}

 	if (KErrNone == err || KErrCompletion == err)

 		{

 		INFO_PRINTF2(_L("Returned start position %d"), startPos);

 		INFO_PRINTF2(_L("Local drive number %d"), blockMapInfo.iLocalDriveNumber);

 		INFO_PRINTF2(_L("Block start address %d"), blockMapInfo.iStartBlockAddress);

 		INFO_PRINTF2(_L("Block start offset %u"), blockMapInfo.iBlockStartOffset);

 		INFO_PRINTF2(_L("Block graduality %u"), blockMapInfo.iBlockGranularity);	

 		}

 	}

 //function that adds the buffer to the end of the array

 void CT_FileData::ToArrayL(RPointerArray<HBufC>& aArray, HBufC*& aBuffer)

 	{

 	HBufC* arrayElement = HBufC::NewL(aBuffer->Length());

 	TPtr arrayElementPtr = arrayElement->Des();

 	arrayElementPtr.Copy(*aBuffer);

 	arrayElementPtr.TrimAll();

 	aArray.Append(arrayElement);

 	arrayElement = NULL;

 	}

 // helper function to split filemodes or attributes to array

 RPointerArray<HBufC> CT_FileData::SplitL(const TDesC& aInput, const char* aToken)

 	{

 	RPointerArray<HBufC> fileModeArray;

 	HBufC*  buffer = HBufC::NewL(aInput.Length());

 	TPtr bufferPtr = buffer->Des();

 	for (int i=0;i<aInput.Length();i++)

 		{

 		if (aInput[i] == *aToken)

 			{

 			ToArrayL(fileModeArray, buffer);

 			delete buffer;	

 			buffer = NULL;

 			buffer = HBufC::NewL( aInput.Length() - i);	

 			bufferPtr = buffer->Des();

 			}

 		else

 			{

 			bufferPtr.Append(aInput[i]);

 			}

 		}

 	ToArrayL(fileModeArray, buffer);		

 	delete buffer;

 	buffer = NULL;		

 	return fileModeArray;

 	}

 void CT_FileData::DoCancel(CActive* aActive, TInt aIndex)

 	{

 	TBool	foundActiveObject = EFalse;

 	TInt	index=0;

 	TInt	count=0;

 	count=iReadCallbackArray.Count();

 	for( index=0; (index<count) && (!foundActiveObject); ++index )

  		{

  		if( aActive == iReadCallbackArray[index] )

 			{

 			INFO_PRINTF1(_L("DoCancel iReadCallbackArray called"));

 			foundActiveObject = ETrue;

 			iReadCallbackArray.Remove(index);

 	 		}

 		}

 	count=iWriteCallbackArray.Count();

 	for( index=0; (index<count) && (!foundActiveObject); ++index )

  		{

  		if( aActive == iWriteCallbackArray[index] )

 			{

 			INFO_PRINTF1(_L("DoCancel iWriteCallbackArray called"));

 			foundActiveObject = ETrue;

 			iWriteCallbackArray.Remove(index);

 	 		}

 		}

 	// See if it is in iFlushCallbackArray

 	count=iFlushCallbackArray.Count();

 	for( index=0; (index<count) && (!foundActiveObject); ++index )

  		{

  		if( aActive == iFlushCallbackArray[index] )

 			{

 			INFO_PRINTF1(_L("DoCancel iFlushCallbackArray called"));

 			foundActiveObject = ETrue;

 			iFlushCallbackArray.Remove(index);

 	 		}

 		}

  	if( foundActiveObject )

  		{

 		TInt	err = aActive->iStatus.Int();

 		if( err != KErrNone )

 			{

 			ERR_PRINTF2(_L("DoCancel Error %d"), err);

 			SetAsyncError( aIndex, err );

 			}

 		// Reset the outstanding request state

 		DecOutstanding();

 		delete aActive;

 		}

 	else

 		{

  		ERR_PRINTF1(_L("Stray DoCancel signal"));

  		SetBlockResult(EFail);

 		}

 	}

 void CT_FileData::RunL(CActive* aActive, TInt aIndex)

 	{

 	TBool	foundActiveObject = EFalse;

 	TInt	index=0;

 	TInt	count=0;

 	count=iReadCallbackArray.Count();

 	for( index=0; (index<count) && (!foundActiveObject); ++index )

  		{

  		if( aActive == iReadCallbackArray[index] )

 			{

 			foundActiveObject = ETrue;

 			TInt	err = aActive->iStatus.Int();

 			TBuf<KDefaultDescSize> info;

 			info.Copy(iReadCallbackArray[index]->iFileData->Des());

 			INFO_PRINTF2(_L("readed \"%S\" from file"), &info);

 			HandleExpectedString(iReadCallbackArray[index]->iFileData->Des(), *iReadCallbackArray[index]->iSection);

 			if( err != KErrNone )

 				{

 				ERR_PRINTF2(_L("Async Read error %d"), err);

 				SetAsyncError( aIndex, err );

 				}

 			else

 				{

 				INFO_PRINTF1(_L("Succesfully completed Async Read"));

 				}

 			iReadCallbackArray.Remove(index);	

 			delete aActive;

 	 		}

 		}

 	count=iWriteCallbackArray.Count();

 	for( index=0; (index<count) && (!foundActiveObject); ++index )

  		{

  		if( aActive == iWriteCallbackArray[index] )

 			{

 			foundActiveObject = ETrue;

 			TInt	err = aActive->iStatus.Int();

 			if( err != KErrNone )

 				{

 				ERR_PRINTF2(_L("Async Write Error %d"), err);

 				SetAsyncError( aIndex, err );

 				}				

 			else

 				{

 				INFO_PRINTF1(_L("Succesfully completed Async Write"));

 				}

 			iWriteCallbackArray.Remove(index);				

 			delete aActive;			

 	 		}

 		}	

 	count=iFlushCallbackArray.Count();

 	for( index=0; (index<count) && (!foundActiveObject); ++index )

  		{

  		if( aActive == iFlushCallbackArray[index] )

 			{

 			foundActiveObject = ETrue;

 			TInt	err = aActive->iStatus.Int();

 			if( err != KErrNone )

 				{

 				ERR_PRINTF2(_L("Async Flush Error %d"), err);

 				SetAsyncError( aIndex, err );

 				}				

 			iFlushCallbackArray.Remove(index);				

 			delete aActive;			

 	 		}

 		}				

 	DecOutstanding();

 	}

 void CT_FileData::PrintFileAttributes(TUint aAttValue)

 /** Prints file attributes */

 	{

 	if ((aAttValue & KEntryAttNormal) == KEntryAttNormal)

 		{

 		INFO_PRINTF1(_L("KEntryAttNormal"));

 		}

 	if ((aAttValue & KEntryAttReadOnly) == KEntryAttReadOnly)

 		{

 		INFO_PRINTF1(_L("KEntryAttReadOnly"));

 		}

 	if ((aAttValue & KEntryAttHidden) == KEntryAttHidden)

 		{

 		INFO_PRINTF1(_L("KEntryAttHidden"));

 		}

 	if ((aAttValue & KEntryAttSystem) == KEntryAttSystem)

 		{

 		INFO_PRINTF1(_L("KEntryAttSystem"));

 		}

 	if ((aAttValue & KEntryAttVolume) == KEntryAttVolume)

 		{

 		INFO_PRINTF1(_L("KEntryAttVolume"));

 		}

 	if ((aAttValue & KEntryAttDir) == KEntryAttDir)

 		{

 		INFO_PRINTF1(_L("KEntryAttDir"));

 		}

 	if ((aAttValue & KEntryAttArchive) == KEntryAttArchive)

 		{

 		INFO_PRINTF1(_L("KEntryAttArchive"));

 		}

 	if ((aAttValue & KEntryAttXIP) == KEntryAttXIP)

 		{

 		INFO_PRINTF1(_L("KEntryAttXIP"));

 		}

 	if ((aAttValue & KEntryAttRemote) == KEntryAttRemote)

 		{

 		INFO_PRINTF1(_L("KEntryAttRemote"));

 		}	

 	}