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

 // Implements the Flogger server side data writing

 // 

 //

 /**

  @file

  @internalComponent

 */

 #include "comsdbgwriter.h"

 #include "comsdbgmessages.h"

 const TInt KHeapBufSize = 50000;   // Maximum that the file buffer can grow to limit its impact somewhat

 // RDebug will truncate strings longer than the limit below

 const TInt KRDebugLimit = 0x100;

 // source strings, lengths and offsets

 _LIT8(KLogStartedString, "#Logging started on dd/mm/yyyy. Output version 2\r\n");	///< Format specifier for the very first line written. The output version is printed so tools processing the log output can determine the expected format of the output.

 _LIT8(KDateChangedString,"#      Date is now: dd/mm/yyyy.\r\n");	///< Format specifier for subsequent date changes

 const TInt KLogStartedStringLength = 50;

 const TInt KLogStartedDayOffset = 20;

 const TInt KLogStartedMonthOffset = 23;

 const TInt KLogStartedYearOffset = 26;

 _LIT8(KUnableToLog, "#Logs lost since log file couldn't be written to");

 _LIT8(KClearLogString, "#Clear Log called by ");

 const TInt KClearLogStringLength = 21;

 _LIT8(KEolCharacters, "\r\n");

 const TInt KEolCharactersLength = 2;

 _LIT8(KLogPathTree,"\\");	

 _LIT8(KLogFileExt,".");

 //Below const is... log string + 2 tags + 8 for the thread id + 3 tabs + EOL characters.

 const TInt KMaxFinalLogStringLength = KLogBufferSize+2*KMaxTagLength+8+3+KEolCharactersLength;

 _LIT8(KBadMediaString, "#Bad media setting in ini file.\r\n");

 _LIT8(KUnableToUpdateMedia, "#Unable to update logging media. Err code: %d\r\n");

 _LIT8(KUnableToLoadSerialDevices, "#Unable to load the LDD or PDD required for serial. Err code: %d\r\n");

 _LIT8(KUnableToOpenSerial, "#Unable to open the serial port. Err code: %d\r\n");

 _LIT8(KUnableToSetSerialConfig, "#Could not set serial port configuration after opening port. Err code: %d\r\n");

 // source characters

 _LIT8(KTabCharacter, "\t");

 _LIT8(KTypeIdentifierAscii, "a");

 _LIT8(KTypeIdentifierBinary, "b");

 // serial specs

 const TBps KFloggerSerialRate = EBps115200;

 const TInt KSerialRetryCount = 50;

 const TInt KSerialTimeoutInMicroSecs = 100000;

 // serial ports

 const TInt KSerialPort1 = 0;

 #if defined (__WINS__)

 const TInt KSerialPort2OnEmulator = 1;

 #else

 const TInt KSerialPort2OnTarget = 2;

 #endif

 #if defined (__WINS__)

 #define PDD_NAME _L("ECDRV.PDD")

 #define LDD_NAME _L("ECOMM.LDD")

 #else

 #define PDD_NAME _L("EUART1")

 #define LDD_NAME _L("ECOMM")

 #endif

 // log file specs

 _LIT(KLogFileName, "log.txt");

 _LIT(KLogDefaultFilePath, "C:\\logs\\");

 const TUint KZeroDate = 0;  ///< The day to count forward from when determining date roll.

 const TUint KSecondsToWriteTimestampOnNoActivity = 5;

 #if defined (__WINS__)

 const TInt Win32DisplayStringLengthMax = 1024; 

 #endif

 CLogManager* CLogManager::NewL(MLogArrayAccess& aArrayAccess)

 	{

 	CLogManager* self = new(ELeave) CLogManager(aArrayAccess);

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	}

 CLogManager::CLogManager(MLogArrayAccess& aArrayAccess)

 : iArrayAccess(aArrayAccess), iTimeString(KTimeFormat)

 {}

 CLogManager::~CLogManager()

 	{

 	delete iLogger;

 	}

 void CLogManager::ConstructL()

 /*

  * Set the initial media to file and write there until the server has told us

  * which media is in the ini file.

  * Write the log started and date message. 

  */

 	{

 	iLogger = CFileWriter::NewL();	//File writer by default

 	iCurrentMediaSetting = KFileMedia;

 	iLoggingEnabled = EFalse;

 	}

 TInt CLogManager::ThreadEntryPoint(TAny* aPtr)

 	{

 	MLogArrayAccess* arrayAccess = static_cast<MLogArrayAccess*> (aPtr);

 	CTrapCleanup* cleanupStack = CTrapCleanup::New();

 	if (cleanupStack==NULL)

 		{

 		return KErrNoMemory;

 		}

 	TRAPD(err, CLogManager::DoRunThreadL(*arrayAccess));

 	delete cleanupStack;

 	return err;

 	}

 void CLogManager::DoRunThreadL(MLogArrayAccess& aArrayAccess)

 	{

 	CLogManager* self = CLogManager::NewL(aArrayAccess);

 	self->DoStart();

 	delete self;

 	}

 void CLogManager::DoStart()

 /**

  * Second/consumer/slave/draining/dequeuer thread main loop.

  * @note Continuously takes the log queue top message and processes it. Blocks on the "Get" if no messages.

  * @note Completes when a shutdown message is processed from the queue. This message sets "iShutDown".

  */

 	{

 	CLogMessageBase * message = NULL;

 	TInt ret = KErrNone;

 	RThread::Rendezvous(ret);

 	FOREVER

 		{

 		iArrayAccess.GetFirstMessageAndTakeOwnership(message);

 		__ASSERT_ALWAYS(message, User::Panic(KFloggerServerPanic, ENullMessageInArray));

 		message->Invoke(*this);

 		delete message;

         // GetFirstMessage waits on the request semaphore, so to balance these each 

 		// time a message is processed we must then signal the completion semaphore

 		// when in synchronous mode

 		iArrayAccess.SignalCompletionSemaphore();

 		if (iShutDown)

 			{

 			break;

 			}

 		}

 	}

 void CLogManager::WriteDateIntoLog(TBool firstTime)

 /**

  * Write the date straight to the log output

  * @param firstTime If ETrue then write a "log started" otherwise write a "date change" msg

  */

 	{

 	if (!iLoggingEnabled) 

 	   {

 	   return;

 	   }

 	//Put a date stamp for when we've started logging

 	//Can't use TTime::FormatL since it gives unicode and we want narrow.

 	TTime time;

 	TBuf8<KLogStartedStringLength> logDateString;

 	time.HomeTime();

 	TDateTime dateTime(time.DateTime());

 	if (firstTime)

 		{

 		logDateString.Copy(KLogStartedString);

 		}

 	else

 		{

 		logDateString.Copy(KDateChangedString);

 		}

 	TBuf8<2> holdingBuf;

 	holdingBuf.NumFixedWidth(dateTime.Day()+1, EDecimal, 2);

 	logDateString.Replace(KLogStartedDayOffset,2,holdingBuf);

 	holdingBuf.NumFixedWidth(dateTime.Month()+1, EDecimal, 2);

 	logDateString.Replace(KLogStartedMonthOffset,2,holdingBuf);

 	TBuf8<4> holdingBuf2;

 	holdingBuf2.NumFixedWidth(dateTime.Year(), EDecimal, 4);

 	logDateString.Replace(KLogStartedYearOffset,4,holdingBuf2);

 	iLogger->LogString(logDateString);

 	}

 void CLogManager::ClearLog(const TFullName& aName)

 	{

 	if (!iLoggingEnabled) 

 	   {

 	   return;

 	   }

 	TRAP_IGNORE(iLogger->ClearLogL());	//if there is an error there is nothing we can do.

 	TBuf8<KMaxFullName+KClearLogStringLength+KEolCharactersLength> buf(KClearLogString);

 	buf.Append(aName);

 	buf.Append(KEolCharacters);

 	iLogger->LogString(buf);

 	WriteDateIntoLog(ETrue);

 	iTicksSinceLastLog=0;

 	}

 void CLogManager::SetTimeL(const TTime& aTime)

 	{

 	if (!iLoggingEnabled) 

 	   {

 	   return;

 	   }

 	//check whether date has rolled and write it to log if necessary

 	TTime currentMicrosecs;

 	TTimeIntervalDays newDate;

 	currentMicrosecs.HomeTime();

 	TTime zeroDate = TTime(TInt64(KZeroDate));

 	newDate = currentMicrosecs.DaysFrom(zeroDate);

 	if (newDate > iCurrentDate)

 		{

 		WriteDateIntoLog(EFalse);

 		iCurrentDate = newDate;

 		}

 	//Print the time to the log

 	//Have to do this stuff manually since TTime only provides Unicode formating

 	//which is not what we want.

 	// We format this each second regardless of whether it is used so that it is ready for use

 	// if a client logs since in normal use it would be rare for flogger not to log something each second.

 	TDateTime dateTime(aTime.DateTime());

 	TBuf8<2> holdingBuf;

 	holdingBuf.NumFixedWidth(dateTime.Hour(), EDecimal, 2);

 	iTimeString.Replace(KHourOffset,2,holdingBuf);

 	holdingBuf.NumFixedWidth(dateTime.Minute(), EDecimal, 2);

 	iTimeString.Replace(KMinuteOffset,2,holdingBuf);

 	holdingBuf.NumFixedWidth(dateTime.Second(), EDecimal, 2);

 	iTimeString.Replace(KSecondOffset,2,holdingBuf);

 	if (iTicksSinceLastLog++ < KSecondsToWriteTimestampOnNoActivity)

 		{

 		iLogger->LogString(iTimeString);

 		iLogger->FlushLogL();

 		}

 	}

 void CLogManager::LogString(const TDesC8& aLogString, const TDesC8& aSubSystem, const TDesC8& aComponent, const TThreadId& aThreadId)

 	{

 	if (!iLoggingEnabled) 

 	   {

 	   return;

 	   }

 	if (iTicksSinceLastLog > KSecondsToWriteTimestampOnNoActivity)

 		{

 		iLogger->LogString(iTimeString);

 		}

 	iTicksSinceLastLog=0;

 	TBuf8<KMaxFinalLogStringLength> buf;

 	buf.Append(aSubSystem);

 	buf.Append(KTabCharacter);

 	buf.Append(aComponent);

 	buf.Append(KTabCharacter);

 	buf.Append(KTypeIdentifierAscii);

 	buf.Append(KTabCharacter);

 	buf.AppendNum(aThreadId, EHex);

 	buf.Append(KTabCharacter);

 	buf.Append(aLogString);

 	// check whether last two bytes of string are eol chars, since some lines have cr/lf, some don't

 	TPtr8 ptr(&buf[buf.Length()-2], 2, 2);

 	if (ptr.Compare(KEolCharacters)!=0)

 		{

 		buf.Append(KEolCharacters);

 		}

 	iLogger->LogString(buf);

 	}

 void CLogManager::LogBinaryDump(const TDesC8& aBinaryString, const TDesC8& aSubSystem, const TDesC8& aComponent)

 	{

 	iLogger->LogBinaryDump(aBinaryString, aSubSystem, aComponent);

 	}

 void CLogManager::LogComment(const TDesC8& aComment)

 	{

 	if (iTicksSinceLastLog > KSecondsToWriteTimestampOnNoActivity)

 		{

 		iLogger->LogString(iTimeString);

 		}

 	iTicksSinceLastLog=0;

 	iLogger->LogString(aComment);

 	}

 void CLogManager::MediaUpdate(const TDesC8& aMediaSetting, const TBool aForceFlush, const TDesC8& aLogPathSetting)

 	{

 	TRAPD(err, DoMediaUpdateL(aMediaSetting,aForceFlush, aLogPathSetting));

 	if (err!=KErrNone)

 		{

 		TBuf8<KMaxFinalLogStringLength> buf;

 		buf.Format(KUnableToUpdateMedia,err);

 		iLogger->LogString(buf);

 		}

 	}

 void CLogManager::DoMediaUpdateL(const TDesC8& aMediaSetting,const TBool aForceFlush, const TDesC8& aLogPathSetting)

 	{

 	//We should NEVER have no media selected, media is set on construction

 	//and there should always be something set up.

 	__ASSERT_ALWAYS(iLogger, User::Panic(KFloggerServerPanic, ENoLoggingMediaSetUp));

 	if (aMediaSetting.Length() == 0)

 		{

 		return;

 		}

 	// if the ini file has been opened, the media setting will be either the default

 	// or some other string so we can allow logging. If we are only opening media now, output extra info.

 	TTime currentMicrosecs;

 	currentMicrosecs.HomeTime();

 	iCurrentDate = currentMicrosecs.DaysFrom(TTime(TInt64(KZeroDate)));

 	if (!iLoggingEnabled)

 		{

 		iLoggingEnabled = ETrue;

 		WriteDateIntoLog(ETrue);

 		}

 	//Media update is a best effort, if it fails we keep

 	//logging to the old media

 	//If bad media in ini file, carry on with old media and post message in log

 	if (aMediaSetting.CompareF(iCurrentMediaSetting)==0 && aLogPathSetting.CompareF(iLogPath) == 0)

 		{

 		//Media hasn't changed, so update flush status only

 		// ForceFlushing as far as media is concerned only applies to file since 

 		// serial has no such buffer which needs flushing.

 		iLogger->SetForceFlush(aForceFlush);

 		return;

 		}

 	if (!aMediaSetting.CompareF(KFileMedia))

 		{

 		CLoggerMediaBase* media = CFileWriter::NewL();

 		delete iLogger;

 		iLogger = media;

 		// ForceFlushing only applies to file since serial has no such buffer

 		iLogger->SetForceFlush(aForceFlush);

 		if(aLogPathSetting.Length() != 0)

 			{

 			(static_cast<CFileWriter*>(iLogger))->SetLogPath(aLogPathSetting);

 			WriteDateIntoLog(ETrue);

 			}

 		}

 	else if (!aMediaSetting.CompareF(KSerial1Media))

 		{

 		// lots of things can go wrong when constructing the serial, so

 		// we set it up in stages, and log here if an error

 		// If we get an error in NewL - just let generic error given by

 		// SetMedia cover it

 		//CLoggerMediaBase* media = CSerialWriter::NewL();

 		CSerialWriter* serial = CSerialWriter::NewL();

 		TInt res = serial->LoadDevices();

 		if (res != KErrNone)

 			{

 			TBuf8<KMaxFinalLogStringLength> buf;

 			buf.Format(KUnableToLoadSerialDevices,res);

 			iLogger->LogString(buf);

 			delete serial;

 			User::Leave(res);

 			}

 		res = serial->OpenPort(KSerialPort1);

 		if (res != KErrNone)

 			{

 			TBuf8<KMaxFinalLogStringLength> buf;

 			buf.Format(KUnableToOpenSerial,res);

 			iLogger->LogString(buf);

 			delete serial;

 			User::Leave(res);

 			}

 		res = serial->SetPortConfig();

 		if (res != KErrNone)

 			{

 			TBuf8<KMaxFinalLogStringLength> buf;

 			buf.Format(KUnableToSetSerialConfig,res);

 			iLogger->LogString(buf);

 			delete serial;

 			User::Leave(res);

 			}

 		CLoggerMediaBase* media = serial;

 		delete iLogger;

 		iLogger = media;

 		WriteDateIntoLog(ETrue);

 		}

 	else if (!aMediaSetting.CompareF(KSerial2Media))

 		{

 		// lots of things can go wrong when constructing the serial, so

 		// we set it up in stages, and log here if an error.

 		// If we get an error in NewL - just let generic error given by

 		// SetMedia cover it

 		CSerialWriter* serial = CSerialWriter::NewL();

 		TInt res = serial->LoadDevices();

 		if (res != KErrNone)

 			{

 			TBuf8<KMaxFinalLogStringLength> buf;

 			buf.Format(KUnableToLoadSerialDevices,res);

 			iLogger->LogString(buf);

 			delete serial;

 			User::Leave(res);

 			}

 		#if defined (__WINS__)

 		res = serial->OpenPort(KSerialPort2OnEmulator);

 		#else

 		res = serial->OpenPort(KSerialPort2OnTarget);

 		#endif

 		if (res != KErrNone)

 			{

 			TBuf8<KMaxFinalLogStringLength> buf;

 			buf.Format(KUnableToOpenSerial,res);

 			iLogger->LogString(buf);

 			delete serial;

 			User::Leave(res);

 			}

 		res = serial->SetPortConfig();

 		if (res != KErrNone)

 			{

 			TBuf8<KMaxFinalLogStringLength> buf;

 			buf.Format(KUnableToSetSerialConfig,res);

 			iLogger->LogString(buf);

 			delete serial;

 			User::Leave(res);

 			}

 		CLoggerMediaBase* media = serial;

 		delete iLogger;

 		iLogger = media;

 		WriteDateIntoLog(ETrue);

 		}

 	else if (!aMediaSetting.CompareF(KRDebugMedia))

 		{

 		CLoggerMediaBase* media = CRDebugWriter::NewL();;

 		delete iLogger;

 		iLogger = media;

 		WriteDateIntoLog(ETrue);

 		}

 	else if (!aMediaSetting.CompareF(KOSTv2Media))

 		{

 		CLoggerMediaBase* media = COstv2Writer::NewL();;

 		delete iLogger;

 		iLogger = media;

 		WriteDateIntoLog(ETrue);

 		}

 	else	//Bad setting in the media file, leave media as is and return.

 		{

 		iLogger->LogString(KBadMediaString);

 		return;	

 		}

 	iCurrentMediaSetting = aMediaSetting;

 	iLogPath = aLogPathSetting;

 	}

 void CLogManager::ShutDown()

 	{

 	iShutDown = ETrue;

 	}

 //////////////////////////////////////////////////////////////////////////////

 void CFileWriter::LogString(const TDesC8& aString)

 	{

 	TPtr8 ptr(iHBuf->Des());

 	if (ptr.Length()+aString.Length() <=KHeapBufSize)

 		{

 		ptr.Append(aString);

 		}

 	else

 		{

 		TRAPD(err, DoFlushBufferToFileL());

 		if (err==KErrNone)

 			{

 			ptr.Zero();

 			ptr.Append(aString);

 			}

 		else

 			{

 			ptr.Zero();

 			ptr.Append(KUnableToLog);

 			ptr.Append(aString);

 			}

 		}

 	if (iForceBufferFlushAlways)

 		{

 		TRAPD(err, DoFlushBufferToFileL());

 		ptr.Zero();

 		if (err!=KErrNone)

 			{

 			ptr.Append(KUnableToLog);

 			}

 		}

 	}

 void CFileWriter::LogBinaryDump(const TDesC8& aBinaryString, const TDesC8& aSubSystem, const TDesC8& aComponent)

 	{

 	TRAPD(err, DoLogBinaryDumpL(aBinaryString, aSubSystem, aComponent));

 	if (err!=KErrNone)

 		{

 		LogString(KUnableToLog);

 		}

 	}

 void CFileWriter::DoLogBinaryDumpL(const TDesC8& aBinaryString, const TDesC8& aSubSystem, const TDesC8& aComponent)

 /**

  * Place a chunk of raw binary into the log file

  * @post Opens the output file, flushes the write buffer and then places some tags before writing

  *   the binary data.

  */

 	{

 	RFile logFile;

 	TInt err = logFile.Open(iFs, iLogFileName, EFileWrite|EFileShareAny);

 	if(err == KErrPathNotFound)

 		{

 		TName filePath;

 		filePath.Copy(iLogPath);

 		User::LeaveIfError(iFs.MkDirAll(filePath));

 		}

 	if(err == KErrNotFound || err == KErrPathNotFound)

 		{

 		err = logFile.Create(iFs, iLogFileName, EFileWrite|EFileShareAny);

 		}

 	User::LeaveIfError(err);

 	CleanupClosePushL(logFile);

 	TInt filePos = 0;

 	User::LeaveIfError(logFile.Seek(ESeekEnd,filePos));

 	User::LeaveIfError(logFile.Write(*iHBuf));

 	TPtr8 ptr(iHBuf->Des());

 	ptr.Zero();

 	TUint32 length = static_cast<TUint32>(aBinaryString.Length());

 	TBuf8<sizeof(TUint32)> lengthString(4);

 	lengthString[0] = static_cast<TUint8>((length & 0x000000ff) >> 0);

 	lengthString[1] = static_cast<TUint8>((length & 0x0000ff00) >> 8);

 	lengthString[2] = static_cast<TUint8>((length & 0x00ff0000) >> 16);

 	lengthString[3] = static_cast<TUint8>((length & 0xff000000) >> 24);

 	User::LeaveIfError(logFile.Write(aSubSystem));

 	User::LeaveIfError(logFile.Write(KTabCharacter));

 	User::LeaveIfError(logFile.Write(aComponent));

 	User::LeaveIfError(logFile.Write(KTabCharacter));

 	User::LeaveIfError(logFile.Write(KTypeIdentifierBinary));

 	User::LeaveIfError(logFile.Write(KTabCharacter));

 	User::LeaveIfError(logFile.Write(lengthString));

 	User::LeaveIfError(logFile.Write(KTabCharacter));

 	User::LeaveIfError(logFile.Write(aBinaryString));

 	User::LeaveIfError(logFile.Write(KEolCharacters));

 	CleanupStack::PopAndDestroy();	//logFile

 	//LogString(KEolCharacters);

 	}

 void CFileWriter::ClearLogL()

 	{

 	User::LeaveIfError(iFs.Delete(iLogFileName));

 	RFile logFile;

 	User::LeaveIfError(logFile.Create(iFs, iLogFileName, EFileWrite|EFileShareAny));

 	logFile.Close();

 	TPtr8 ptr(iHBuf->Des());

 	ptr.Zero();

 	}

 void CFileWriter::DoFlushBufferToFileL()

 	{

 	//Check that the log file exists, if not create a blank one.

 	RFile logFile;

 	TBool writePathErrorCode = KErrNone;

 	TInt err = logFile.Open(iFs, iLogFileName, EFileWrite|EFileShareAny);

 	if (err==KErrPathNotFound)

 		{

 		TName filePath;

 		filePath.Copy(iLogPath);

 		User::LeaveIfError(iFs.MkDirAll(filePath));

 		}

 	else if (err == KErrBadName || err == KErrNotReady)

 		{

 		writePathErrorCode = err;			

 		// duff pathspec in ini file

 		TName filePath;

 		filePath.Copy(KLogDefaultFilePath);

 		err = iFs.MkDirAll(filePath);

 		iLogFileName.Copy(KLogDefaultFilePath);

 		iLogFileName.Append(KLogFileName);			

 		if (err == KErrAlreadyExists)

 			{

 			err = logFile.Open(iFs, iLogFileName, EFileWrite|EFileShareAny);

 			}

 		}

 	if (err==KErrNotFound||err==KErrPathNotFound||err==KErrBadName||err == KErrNotReady)

 		{

 		err = logFile.Create(iFs, iLogFileName, EFileWrite|EFileShareAny);

 		}

 	User::LeaveIfError(err);

 	CleanupClosePushL(logFile);

 	TInt filePos = 0;

 	User::LeaveIfError(logFile.Seek(ESeekEnd,filePos));

 	if (writePathErrorCode != KErrNone)

 		{

 		TBuf8<KMaxFinalLogStringLength> tmpBuf;

 		tmpBuf.Format(KUnableToUpdateMedia,writePathErrorCode);

 		User::LeaveIfError(logFile.Write(tmpBuf));

 		}

 	if (iHBuf)

 		{

 		User::LeaveIfError(logFile.Write(*iHBuf));

 		}

 	CleanupStack::PopAndDestroy();	//logFile

 	}

 void CFileWriter::FlushLogL()

 	{

 	DoFlushBufferToFileL();

 	if (iHBuf)

 		{

 		TPtr8 ptr(iHBuf->Des());

 		ptr.Zero();

 		}

 	}

 void CFileWriter::SetForceFlush(TBool aOn)

 	{

 	iForceBufferFlushAlways = aOn;

 	}

 void CFileWriter::SetLogPath(const TDesC8& aLogPathSetting)

 	{

 	iLogPath.Copy(aLogPathSetting);

 	//the path may be reconfigured, so check for '\' 

 	//as its assumed to be at the end already

 	TPtr8 iTempStr = iLogPath.RightTPtr(1);	//get last

 	TPtr8 iTempExt = iLogPath.RightTPtr(4);	//get last 4

 	if( iTempStr == KLogPathTree)

 		{

 			//ends with '\', so ok to copy

 			iLogFileName.Copy(iLogPath);

 			iLogFileName.Append(KLogFileName);

 		}	

 	else if(iTempExt.Find(KLogFileExt)==KErrNotFound)

 		{

 			//no file extension already set, so its just path

 			iLogPath.Append(KLogPathTree);

 			iLogFileName.Copy(iLogPath);

 			iLogFileName.Append(KLogFileName);

 		}

 	else

 		{

 			//already has all we need

 			iLogFileName.Copy(iLogPath);

 		}

 	}

 CFileWriter* CFileWriter::NewL()

 	{

 	CFileWriter* self = new(ELeave) CFileWriter;

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	}

 void CFileWriter::ConstructL()

 	{

 	User::LeaveIfError(iFs.Connect());

 	//Create our buffer for logging into, at zero length but specify a maximum.

 	iHBuf = HBufC8::NewL(KHeapBufSize);

 	iForceBufferFlushAlways = EFalse;

 	iLogPath.Copy(KLogDefaultFilePath);

 	iLogFileName.Copy(iLogPath);

 	iLogFileName.Append(KLogFileName);

 	}

 CFileWriter::~CFileWriter()

 	{

 	// Don't attempt flushing when it's an OOM leave from NewL()

 	if (iHBuf)

 		{

 		TRAP_IGNORE(CFileWriter::FlushLogL());	//Ignore error. Nothing we can do now.

 		delete iHBuf;

 		}

 	iFs.Close();

 	}

 ///////////////////////////////////////////////////////////////////////

 CSerialWriter* CSerialWriter::NewL()

 	{

 	CSerialWriter* self = new(ELeave) CSerialWriter;

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	}

 void CSerialWriter::ConstructL()

 	{

 	User::LeaveIfError(iTimeoutTimer.CreateLocal());

 	}

 TInt CSerialWriter::LoadDevices()

 	{

 	// load the device drivers

 	TInt result = User::LoadPhysicalDevice(PDD_NAME);

 	if ((result != KErrNone) && (result != KErrAlreadyExists))

 		{

 		 return result;

 		}

 	result = User::LoadLogicalDevice(LDD_NAME);

 	if ((result != KErrNone) && (result != KErrAlreadyExists))

 		{

 		return result;

 		}

 	return KErrNone;

 	}

 TInt CSerialWriter::OpenPort(TInt aPort)

 	{

 	return iSerialPort.Open(aPort);

 	}

 TInt CSerialWriter::SetPortConfig()

 	{

 	TCommConfig tComConfig;

 	TCommConfigV01 &tComConfigV = tComConfig();

 	iSerialPort.Config(tComConfig);

 	tComConfigV.iRate=KFloggerSerialRate;

 	tComConfigV.iDataBits=EData8;

 	tComConfigV.iStopBits=EStop1;

 	tComConfigV.iParity=EParityNone;

 	tComConfigV.iHandshake=0;

 	tComConfigV.iFifo = EFifoEnable;

 	return iSerialPort.SetConfig(tComConfig);

 	}

 CSerialWriter::~CSerialWriter()

 	{

 	iTimeoutTimer.Close();

 	iSerialPort.Close();

 	}

 void CSerialWriter::ClearLogL()

 /**

  * @note: Nothing to do for serial

  */

 	{}

 void CSerialWriter::FlushLogL()

 /**

  * @note: Nothing to do for serial

  */

 	{}

 void CSerialWriter::SetForceFlush(TBool)

 /**

  * @note: Nothing to do for serial.

  */

 	{

 	}

 void CSerialWriter::LogString(const TDesC8& aString)

 	{

 	//iInvalidcounter is used to dump packets if we fail to get a write through before the

 	//timer expires. It stops us getting backed up too much if there's a problem.

 	if (iInvalidCounter==0)

 		{

 		TRequestStatus writeStatus(KRequestPending);

 		TRequestStatus timeoutStatus(KRequestPending);

 		iSerialPort.Write(writeStatus, aString, aString.Length());

 		iTimeoutTimer.After(timeoutStatus, 

 			TTimeIntervalMicroSeconds32(KSerialTimeoutInMicroSecs));

 		User::WaitForRequest(writeStatus, timeoutStatus);

 		if (writeStatus==KRequestPending)

 			{//OK, still not completed, better cancel send.

 			iSerialPort.WriteCancel();

 			iInvalidCounter=KSerialRetryCount;

 			}

 		else

 			{

 			iTimeoutTimer.Cancel();

 			}

 		User::WaitForAnyRequest();

 		}

 	else

 		--iInvalidCounter;

 	}

 void CSerialWriter::LogBinaryDump(const TDesC8& aBinaryString, const TDesC8& aSubSystem, const TDesC8& aComponent)

 	{

 	TUint32 length = static_cast<TUint32>(aBinaryString.Length());

 	TBuf8<sizeof(TUint32)> lengthString(4);

 	lengthString[0] = static_cast<TUint8>((length & 0x000000ff) >> 0);

 	lengthString[1] = static_cast<TUint8>((length & 0x0000ff00) >> 8);

 	lengthString[2] = static_cast<TUint8>((length & 0x00ff0000) >> 16);

 	lengthString[3] = static_cast<TUint8>((length & 0xff000000) >> 24);

 	LogString(aSubSystem);

 	LogString(KTabCharacter);

 	LogString(aComponent);

 	LogString(KTabCharacter);

 	LogString(KTypeIdentifierBinary);

 	LogString(KTabCharacter);

 	LogString(lengthString);

 	LogString(KTabCharacter);

 	LogString(aBinaryString);

 	LogString(KEolCharacters);

 	}

 ///////////////////////////////////////////////////////////////////////////////////////////////////

 //Don't strictly need a NewL. Doing it for consistency.

 CRDebugWriter* CRDebugWriter::NewL()

 	{

 	return new(ELeave) CRDebugWriter;

 	}

 CRDebugWriter::~CRDebugWriter()

 	{

 	}

 void CRDebugWriter::ClearLogL()

 /**

  * @note: Nothing to do for RDebug

  */

 	{}

 void CRDebugWriter::FlushLogL()

 /**

  * @note: Nothing to do for RDebug

  */

 	{}

 void CRDebugWriter::SetForceFlush(TBool)

 /**

  * @note: Nothing to do for RDebug.

  */

 	{

 	}

 void CRDebugWriter::LogString(const TDesC8& aString)

 	{

 	//RDebug truncates strings longer than a certain size

 	//To work around this we chop our string into palatable chunks

 	//and log those individually

 	const TUint8 *p = aString.Ptr();

 	TInt bytesSent(0);

 	TInt totalToSend = aString.Length();

 	TInt length(0);

 	do

 		{

 		bytesSent += KRDebugLimit;

 		if (bytesSent < totalToSend)

 			{

 			length = KRDebugLimit;

 			}

 		else

 			{

 			length = totalToSend - bytesSent + KRDebugLimit;

 			}

 		TPtrC8 ptr(p,length);

 		RDebug::RawPrint(ptr);		

 		p += KRDebugLimit;

 		}

 	while(bytesSent < totalToSend);

 	}

 void CRDebugWriter::LogBinaryDump(const TDesC8& aBinaryString, const TDesC8& aSubSystem, const TDesC8& aComponent)

 	{

 	TUint32 length = static_cast<TUint32>(aBinaryString.Length());

 	TBuf8<sizeof(TUint32)> lengthString(4);

 	lengthString[0] = static_cast<TUint8>((length & 0x000000ff) >> 0);

 	lengthString[1] = static_cast<TUint8>((length & 0x0000ff00) >> 8);

 	lengthString[2] = static_cast<TUint8>((length & 0x00ff0000) >> 16);

 	lengthString[3] = static_cast<TUint8>((length & 0xff000000) >> 24);

 	RDebug::RawPrint(aSubSystem);

 	RDebug::RawPrint(KTabCharacter);

 	RDebug::RawPrint(aComponent);

 	RDebug::RawPrint(KTabCharacter);

 	RDebug::RawPrint(KTypeIdentifierBinary);

 	RDebug::RawPrint(KTabCharacter);

 	RDebug::RawPrint(lengthString);

 	RDebug::RawPrint(KTabCharacter);

 	LogString(aBinaryString);	

 	RDebug::RawPrint(KEolCharacters);

 	}

 ///////////////////////////////////////////////////////////////////////

 #if defined (__WINS__)

 #include <emulator.h>

 CDebugPortProtocol* CDebugPortProtocol::NewL()

 	{

 	CDebugPortProtocol* protocol = new(ELeave) CDebugPortProtocol;

 	CleanupStack::PushL(protocol);

 	protocol->ConstructL();

 	CleanupStack::Pop(protocol);

 	return protocol;

 	}

 void CDebugPortProtocol::ConstructL()

 	{

 	iDebugWriter = CDebugPortWriter::NewL();

 	}

 CDebugPortProtocol::~CDebugPortProtocol()

 	{

 	delete iDebugWriter;

 	}

 void CDebugPortProtocol::ClearLog(const TFullName& /*aName*/)

 	{

 	}

 void CDebugPortProtocol::SetTimeL(const TTime& /*aTime*/)

 	{

 	}

 void CDebugPortProtocol::LogString(const TDesC8& aLogString, const TDesC8& aSubSystem, const TDesC8& aComponent, const TThreadId& aThreadId)

 	{

 	TBuf8<KMaxFinalLogStringLength> buf;

 	buf.Append(aSubSystem);

 	buf.Append(KTabCharacter);

 	buf.Append(aComponent);

 	buf.Append(KTabCharacter);

 	buf.Append(KTypeIdentifierAscii);

 	buf.Append(KTabCharacter);

 	buf.AppendNum(aThreadId, EHex);

 	buf.Append(KTabCharacter);

 	buf.Append(aLogString);

 	// check whether last two bytes of string are eol chars, since some lines have cr/lf, some don't

 	TPtr8 ptr(&buf[buf.Length()-2], 2, 2);

 	if (ptr.Compare(KEolCharacters) !=0 )

 		{

 		buf.Append(KEolCharacters);

 		}

 	iDebugWriter->LogString(buf);

 	}

 void CDebugPortProtocol::LogBinaryDump(const TDesC8& aBinaryString, const TDesC8& aSubSystem, const TDesC8& aComponent)

 	{

 	iDebugWriter->LogBinaryDump(aBinaryString, aSubSystem, aComponent);

 	}

 void CDebugPortProtocol::LogComment(const TDesC8& aComment)

 	{

 	iDebugWriter->LogString(aComment);

 	}

 void CDebugPortProtocol::MediaUpdate(const TDesC8& /*aMediaSetting*/, const TBool /*aForceFlushOn*/, const TDesC8& /*aLogPathSetting*/)

 	{

 	}

 void CDebugPortProtocol::ShutDown()

 	{

 	}

 ///////////////////////////////////////////////////////////////////////////////////////////////////////

 CDebugPortWriter* CDebugPortWriter::NewL()

 	{

 	return new(ELeave) CDebugPortWriter;

 	}

 void CDebugPortWriter::LogString(const TDesC8& aString)

 	{

 	char str[Win32DisplayStringLengthMax];

 	int len = Min(sizeof(str) - 1, aString.Length());

 	Mem::Copy(str, aString.Ptr(), len);

 	str[len] = '\0';

 	Emulator::Lock();

 	::OutputDebugStringA(str);

 	Emulator::Unlock();

 	}

 void CDebugPortWriter::ClearLogL()

 	{

 	}

 void CDebugPortWriter::FlushLogL()

 	{

 	}

 void CDebugPortWriter::LogBinaryDump(const TDesC8& /*aBinaryString*/, const TDesC8& /*aSubSystem*/, const TDesC8& /*aComponent*/)

 	{

 	}

 void CDebugPortWriter::SetForceFlush(const TBool /*aOn*/)

 	{

 	}

 #endif  //(__WINS__)