/*

* Copyright (c) 2006-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:  Contained libc logger class implementation.

 *

*/

// INCLUDE FILES

#include <f32file.h>

#ifdef SYMBIAN_FILE_LOGGER

#include <flogger.h>

#endif

#include "libloggerhandler.h"

// CONSTANTS

#define LOG_MESSAGE_TYPE_INFO "INFO"

#define LOG_MESSAGE_TYPE_MINOR "MINOR"

#define LOG_MESSAGE_TYPE_MAJOR "MAJOR"

#define LOG_MESSAGE_TYPE_CRITICAL "CRITICAL"

#define MAX_LOG_STR_LEN 512 /* Overall size of any logging string size, including timestamp and others */

#define MAX_DATE_TIME_LEN 32

#define DUMP_STR_LENGTH 16

#ifdef SYMBIAN_FILE_LOGGER

_LIT(KLogFileLocation,"libc"); // c:\logs\libc

#else

_LIT(KLogFileLocation,"c:\\logs\\libc\\");

_LIT8(KDumpSpace,"                   %04x ");

#endif

const char KMsgType[4][16] =

	{

		LOG_MESSAGE_TYPE_INFO,

		LOG_MESSAGE_TYPE_MINOR,

		LOG_MESSAGE_TYPE_MAJOR,

		LOG_MESSAGE_TYPE_CRITICAL

	};

// ============================ LOCAL FUNCTIONS ===============================

// strlen is implemented over here, just to remove the dependancy from libc/estdlib

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

// _lstrlen

// find the string length.

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

//

LOCAL_C TInt _lstrlen(const char *str)

    {

	const char *s;

	for (s = str; *s; ++s)

	    {

	    }

	return(s - str);

    }

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

// BitPosition

// Find the bit position within the number

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

//

LOCAL_C TInt BitPosition(TInt aNumber)

    {

    TInt pos = 0;

    while(!(aNumber & 1))

        {

        aNumber = (aNumber >> 1);

        pos++;

        }

    // only first 4 bits are used.

    if ( pos < 0 || pos >= 4)

        {

        // crosses the boundary.

        pos = 0;

        }

    return pos;

    }

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

// CLibLogger::GetLogFilename

// Get the log file name.

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

//

void CLibLogger::GetLogFilename(TDes& aFileName)

{

	_LIT(KFileNameFormat, "Mrt_%S.txt");

    RProcess currentProcess;

    TName processName = currentProcess.Name();

#ifdef SYMBIAN_FILE_LOGGER

    aFileName.Format(KFileNameFormat, &processName);

#else

    aFileName.Copy(KLogFileLocation);

    aFileName.AppendFormat(KFileNameFormat, &processName);

#endif

    currentProcess.Close();

}

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

// CLibLogger::WriteMessage

// Write message to the log file

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

//

TInt CLibLogger::WriteMessage(const TDesC8& aMessage)

{

	TFileName logFileName;

	GetLogFilename(logFileName);

	TInt err = KErrNone;

#ifdef SYMBIAN_FILE_LOGGER

    RFileLogger::Write(KLogFileLocation, logFileName, EFileLoggingModeAppend, aMessage);

#else

	RFs fsSession; /* file server */

	RFile iFile;

	err = CLibLogger::CreateFileSession(fsSession, iFile);

	if(KErrNone != err)

	{

		/* Error : Unable to initialize the file session */

		return err;

	}

	/* write the buffer to the file */

	err = iFile.Write(aMessage);

	if(KErrNone != err)

	{

		/* Error : Unable to initialize the file session */

		iFile.Close();

		fsSession.Close();

		return err;

	}

	/* flush the buffer */

	iFile.Flush(); /* commit the write. */

	/* close the session and resources */

	iFile.Close();

	fsSession.Close();

#endif

    return err;

}

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

// CLibLogger::LogMessage

// Logging the internal messages.

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

//

int CLibLogger::LogMessage(TLibTraceMessageType aLogMessageType,

							char *aFileName,

							int aLine,

							char *aFormat,

							VA_LIST& aMarkerList)

{

	/* checking for error inputs */

	if(NULL == aFormat)

	{

		/* Error : Check the input parameter. */

		return -1;

	}

	/* trying to fetch the local time */

	TBuf8<MAX_LOG_STR_LEN> lBuf;

	lBuf.FillZ();

	lBuf.SetLength(0);

#ifdef SYMBIAN_FILE_LOGGER

	/* formulate the time stamp with log type */

	_LIT8(KFormat, "(%s : %d) [%s] - ");

	lBuf.Format(KFormat,

		aFileName,

		aLine,

		KMsgType[BitPosition(aLogMessageType)]

		);

#else

	TTime lCurTime;

	lCurTime.HomeTime();

	TDateTime lTimeStamp = lCurTime.DateTime();

	/* formulate the time stamp with log type */

	_LIT8(KFormat, "%2d/%2d/%d-%2d:%2d:%2d.%3d - (%s : %d) [%s] - ");

	lBuf.Format(KFormat,

		lTimeStamp.Day(),

		(int)(lTimeStamp.Month() + 1),

		lTimeStamp.Year(),

		lTimeStamp.Hour(),

		lTimeStamp.Minute(),

		lTimeStamp.Second(),

		(int)((lTimeStamp.MicroSecond())/1000),

		aFileName,

		aLine,

		KMsgType[BitPosition(aLogMessageType)]

		);

#endif // SYMBIAN_FILE_LOGGER

	TPtrC8 lPtr((TUint8*)aFormat, _lstrlen(aFormat));

	lBuf.AppendFormatList(lPtr, aMarkerList);

	/* new line */

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

	lBuf.Append(KNewLine);

    WriteMessage(lBuf);

	return lBuf.Length();

}

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

// CLibLogger::LogMessage

// Logging the internal messages.

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

//

int CLibLogger::LogMessage(char *aFileName, int aLine)

{

	/* trying to fetch the local time */

	TBuf8<MAX_LOG_STR_LEN> lBuf;

	lBuf.FillZ();

	lBuf.SetLength(0);

#ifdef SYMBIAN_FILE_LOGGER

	/* formulate the time stamp with log type */

	_LIT8(KFormat, "(%s : %d) ");

	lBuf.Format(KFormat,

		aFileName,

		aLine);

#else

	TTime lCurTime;

	lCurTime.HomeTime();

	TDateTime lTimeStamp = lCurTime.DateTime();

	/* formulate the time stamp with log type */

	_LIT8(KFormat, "%2d/%2d/%d-%2d:%2d:%2d.%3d - (%s : %d) ");

	lBuf.Format(KFormat,

		lTimeStamp.Day(),

		(int)(lTimeStamp.Month() + 1),

		lTimeStamp.Year(),

		lTimeStamp.Hour(),

		lTimeStamp.Minute(),

		lTimeStamp.Second(),

		(int)((lTimeStamp.MicroSecond())/1000),

		aFileName,

		aLine);

#endif // SYMBIAN_FILE_LOGGER

    WriteMessage(lBuf);

	return lBuf.Length();

}

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

// CLibLogger::LogMessage

// Logging the internal messages.

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

//

int CLibLogger::LogMessage(TLibTraceMessageType aLogMessageType,

							char *aFormat, 

							VA_LIST& aMarkerList)

{

	/* checking for error inputs */

	if(NULL == aFormat)

	{

		/* Error : Check the input parameter. */

		return -1;

	}

	/* trying to fetch the local time */

	TBuf8<MAX_LOG_STR_LEN> lBuf;

	lBuf.FillZ();

	lBuf.SetLength(0);

	/* formulate the time stamp with log type */

	_LIT8(KFormat, "[%s] - ");

	lBuf.Format(KFormat, 

		KMsgType[BitPosition(aLogMessageType)]

		);

	TPtrC8 lPtr((TUint8*)aFormat, _lstrlen(aFormat));

	lBuf.AppendFormatList(lPtr, aMarkerList);

	/* new line */

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

	lBuf.Append(KNewLine);

    WriteMessage(lBuf);

	return lBuf.Length();

}

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

// CLibLogger::DumpFormatMessage

// Dump the internal message in hex format.

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

//

int CLibLogger::DumpFormatMessage(TLibTraceMessageType aLogMessageType,

                            char *aFileName,

							int aLine,

							char *aMessage,

							char *aFormat,

							VA_LIST& aMarkerList)

{

	if(NULL == aFormat)

	{

		/* Error : Check your input value. */

		return 0;

	}

	TBuf8<MAX_LOG_STR_LEN> lBuf;

	lBuf.FillZ();

	lBuf.SetLength(0);

	TPtrC8 lPtr((TUint8*)aFormat, _lstrlen(aFormat));

	lBuf.AppendFormatList(lPtr, aMarkerList);

	return DumpMessage(aLogMessageType, aFileName, aLine, aMessage, (char *)lBuf.PtrZ(), lBuf.Length());

}

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

// CLibLogger::DumpMessage

// Dump the internal message in hex format.

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

//

int CLibLogger::DumpMessage(TLibTraceMessageType aLogMessageType,

                            char *aFileName,

							int aLine,

							char *aMessage,

							char *aStr,

							int aStrLen)

{

	int istrLen = (aStrLen == -1) ? _lstrlen(aStr) : aStrLen;

	if((NULL == aStr)

		|| (istrLen <= 0))

	{

		/* Error : Check your input value. */

		return 0;

	}

	/* log the timestamp */

	return LibTracer(aLogMessageType, aFileName, aLine, aMessage) + DumpMessage(aStr, istrLen);

}

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

// CLibLogger::DumpFormatMessage

// Dump the internal message in hex format.

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

//

int CLibLogger::DumpFormatMessage(TLibTraceMessageType aLogMessageType,

							char *aMessage,

							char *aFormat,

							VA_LIST& aMarkerList)

{

	if(NULL == aFormat)

	{

		/* Error : Check your input value. */

		return 0;

	}

	/* trying to fetch the local time */

	TBuf8<MAX_LOG_STR_LEN> lBuf;

	lBuf.FillZ();

	lBuf.SetLength(0);

	/* formulate the time stamp with log type */

	_LIT8(KFormat, "[%s] - %s");

	lBuf.Format(KFormat,

		KMsgType[BitPosition(aLogMessageType)], aMessage);

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

	lBuf.Append(KNewLine);

    WriteMessage(lBuf);

    int len = lBuf.Length();

	lBuf.FillZ();

	lBuf.SetLength(0);

	TPtrC8 lPtr((TUint8*)aFormat, _lstrlen(aFormat));

	lBuf.AppendFormatList(lPtr, aMarkerList);

	return len + DumpMessage((char *)lBuf.PtrZ(), lBuf.Length());

}

#ifdef SYMBIAN_FILE_LOGGER

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

// CLibLogger::DumpMessage

// Dump the internal message in hex format.

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

//

int CLibLogger::DumpMessage(char *aStr, int aStrLen)

{

	/* check the inputs */

	if((NULL == aStr)

		|| (aStrLen <= 0))

	{

		/* Error : Check your input value. */

		return 0;

	}

	/* Input parameter is okey */

	TFileName logFileName;

	GetLogFilename(logFileName);

    RFileLogger::HexDump(KLogFileLocation, logFileName, EFileLoggingModeAppend, NULL, NULL, (TUint8*)aStr, aStrLen);

    return aStrLen;

}

#else

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

// CLibLogger::CreateFileSession

// Create a file session for the logger.

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

//

int CLibLogger::CreateFileSession(RFs &aFsSession, RFile &aFile)

{

	int lErr;

	/* register with the file service session. */

	lErr = aFsSession.Connect();

	if(lErr != KErrNone)

	{

		/* Error : unable to create a session with file server */

		return lErr;

	}

	/* Success : application is connected with the file server */

	TFileName logFileName;

	GetLogFilename(logFileName);

	aFsSession.MkDirAll(logFileName);

	CDir* fileList;

	CDir* dirList;

	//coverity[alloc_fn]

	lErr = aFsSession.GetDir(logFileName,KEntryAttNormal,

		ESortByName,fileList,dirList);

	if(lErr != KErrNone)

	{

		/* Error : unable to retrieve the directory list */

		aFsSession.Close(); /* close the session with file server */

		return lErr;

	}

	if(0 >= fileList->Count())

	{

		/* File doesn't exist. create a new file. */

		lErr = aFile.Replace(aFsSession,

								logFileName,

								EFileWrite|EFileStreamText);

		if(lErr != KErrNone)

		{

			/* Error : unable to create the new file. */

			delete fileList;

			delete dirList;

			aFsSession.Close(); /* close the session with file server */

			return lErr;

		}

	}

	else

	{

		/* Shared access for reading and writing. */

		lErr = aFile.Open(aFsSession,

								logFileName,

								EFileWrite | EFileStreamText);

		if(lErr != KErrNone)

		{

			/* Error : unable to open the file. */

			delete fileList;

			delete dirList;

			aFsSession.Close(); /* close the session with file server */

			return lErr;

		}

		int pos = 0; /* since we have pass the 2nd parameter as reference. */

		lErr = aFile.Seek(ESeekEnd, pos);

		if(lErr != KErrNone)

		{

			/* Error : unable to move the file pointer. */

			//coverity[leave_without_push]

			aFile.Close(); /* close the file */

			//coverity[leave_without_push]

			aFsSession.Close(); /* close the session with file server */

			delete fileList;

			delete dirList;

			return lErr;

		}

	}

	/* delete the resources */

	delete fileList;

	delete dirList;

	return lErr;

}

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

// CLibLogger::DumpMessage

// Dump the internal message in hex format.

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

//

int CLibLogger::DumpMessage(char *aStr, int aStrLen)

{

	/* check the inputs */

	if((NULL == aStr)

		|| (aStrLen <= 0))

	{

		/* Error : Check your input value. */

		return 0;

	}

	/* Input parameter is okey */

	/* local variables */

	int counter = 0;

	/* store the input string to a local pointer */

	TPtrC8 istrMesg((TUint8* )aStr, aStrLen);

	/* local log buffer */

	TBuf8<MAX_LOG_STR_LEN> lstrLogMesgString;

	TBuf8<MAX_LOG_STR_LEN> ptempStr;

	/* few literals */

	_LIT8(KSpace, " ");

	_LIT8(KDblSpace, "   ");

	_LIT8(KFormat, "%2x "); /* hex format */

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

	RFs fsSession; /* file server */

	RFile file;

	int lErr = CLibLogger::CreateFileSession(fsSession, file);

	if(KErrNone != lErr)

	{

		/* Error : Unable to initialize the file session */

		return lErr;

	}

	// since these method can be called in from thread context and

	// thread may not call this method within TRAPD

    //CleanupClosePushL(fsSession);

    //CleanupClosePushL(file);

	for(counter = 0; counter < aStrLen; counter++)

	{

		if((counter != 0) && ((counter % DUMP_STR_LENGTH) == 0))

		{

			/* sring reaches with the multiple to 16 (DUMP_STR_LENGTH) */

			lstrLogMesgString.UpperCase();

			lstrLogMesgString.Append(KSpace);

			/* append 16 (DUMP_STR_LENGTH) characters */

			lstrLogMesgString.Append(istrMesg.Mid(((counter / DUMP_STR_LENGTH) - 1) * DUMP_STR_LENGTH, DUMP_STR_LENGTH));

			/* dump the buffer */

			ptempStr.Format(KDumpSpace, counter - DUMP_STR_LENGTH);

			lstrLogMesgString.Insert(0, ptempStr);

            file.Write(lstrLogMesgString);

            file.Write(KNewLine);

            file.Flush();

			/* free the buffer, set the length to zero */

			lstrLogMesgString.FillZ();

			lstrLogMesgString.SetLength(0);

		} /* end of if */

		ptempStr.Format(KFormat,(int)istrMesg[counter]);

		lstrLogMesgString.Append(ptempStr);

	} /*  end of for */

	if(0 < lstrLogMesgString.Length())

	{

		/* few character remains */

		/* it's not multiple of 16 (DUMP_STR_LENGTH) */

		/* adjust the dump and the character portion */

		if (aStrLen % DUMP_STR_LENGTH != 0)

		{

    		for(int lliCounter = 0; lliCounter < DUMP_STR_LENGTH - (aStrLen % DUMP_STR_LENGTH); lliCounter++)

    		{

    			lstrLogMesgString.Append(KDblSpace); /* filling the blanks */

    		} /* end of for */

        }

		lstrLogMesgString.UpperCase();

		/* fill the string */

		lstrLogMesgString.Append(KSpace);

		/* append the string */

		if (aStrLen % DUMP_STR_LENGTH != 0)

		{

		    lstrLogMesgString.Append(istrMesg.Mid(((counter / DUMP_STR_LENGTH)) * DUMP_STR_LENGTH, (aStrLen - ((counter / DUMP_STR_LENGTH)) * DUMP_STR_LENGTH)));

		}

		else

		{

		    lstrLogMesgString.Append(istrMesg.Mid(((counter / DUMP_STR_LENGTH) - 1) * DUMP_STR_LENGTH, (aStrLen - ((counter / DUMP_STR_LENGTH) -1) * DUMP_STR_LENGTH)));

		}

		ptempStr.Format(KDumpSpace, ((aStrLen / DUMP_STR_LENGTH) * DUMP_STR_LENGTH));

		lstrLogMesgString.Insert(0, ptempStr);

        file.Write(lstrLogMesgString);

        file.Write(KNewLine);

        file.Flush();

	} /* end of if */

	//CleanupStack::PopAndDestroy(2); // file, fsFession

	file.Close();

	fsSession.Close();

	return aStrLen; /* return the total dump message length */

}

#endif // SYMBIAN_FILE_LOGGER

#ifndef EKA2

GLDEF_C TInt E32Dll(TDllReason aReason)

	{

	switch (aReason)

		{

	default:

		break;

		}

	return KErrNone;

	}

#endif

// End of file