// 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 client side

// 

//

/**

 @file

 @internalTechnology

*/

#include <f32file.h>

#include <comms-infras/commsdebugutility.h>

#include "comsdbgstd.h"

#include <e32def.h>

#include <utf.h>

#define BLANK	_S("")

const TInt KHexDumpWidth=16;			///< Number of bytes written per line when formatting as hex.

const TInt KNumberMessageSlots=1;       ///< Number of message slots on flogger client.no asynchronous IPC so never need more than 1 slot

const TInt KLowestPrintableCharacter = 32; ///< In Hex output, replace chars below space with a dot.

const TInt KHighestPrintableCharacter = 126; ///< In Hex output, replace chars above 7-bits with a dot.

_LIT(KFirstFormatString,"%s%04x : ");   ///< Format string used in Hexdump to format first part: header and byte numbers.

_LIT(KSecondFormatString,"%02x ");      ///< Format string used in Hexdump to format mid part: each of the 16 bytes as hex

_LIT(KThirdFormatString,"%c");          ///< Format string used in Hexdump to format the last part: each of the 16 bytes as characters

_LIT(KThreeSpaces,"   ");               ///< Format string used in Hexdump to define padding between first and mid parts

_LIT(KTwoSpaces," ");                   ///< Format string used in Hexdump to define padding between hex and char bytes.

_LIT8(KFirstFormatString8,"%04x : ");   ///< Format string used in Hexdump to format first part: header and byte numbers.

_LIT8(KSecondFormatString8,"%02x ");      ///< Format string used in Hexdump to format mid part: each of the 16 bytes as hex

_LIT8(KThirdFormatString8,"%c");          ///< Format string used in Hexdump to format the last part: each of the 16 bytes as characters

_LIT8(KThreeSpaces8,"   ");               ///< Format string used in Hexdump to define padding between first and mid parts

_LIT8(KTwoSpaces8," ");                   ///< Format string used in Hexdump to define padding between hex and char bytes.

//

// RFileLogger class definition

//

EXPORT_C RFileLogger::RFileLogger() : iLoggerBody(NULL)

/**

 * Create a new flogger client interface object with an empty body.

 * @internalTechnology 

 */

	{}

EXPORT_C RFileLogger::~RFileLogger()

/**

 * Destructor

 * @internalTechnology 

 */

	{}

EXPORT_C TVersion RFileLogger::Version() const

/**

 * Return the client side version number

 * @internalTechnology 

 * @return TVersion 3-part version number: major, minor, build.

 */

	{

	return(TVersion(KFLogSrvMajorVersionNumber,KFLogSrvMinorVersionNumber,KFLogSrvBuildVersionNumber));

	}

EXPORT_C TInt RFileLogger::Connect()

/**

 Connect to the flogger server - default number of message slots = 1

 @internalTechnology 

 @return TInt indicating success code (KErrNone), KErrNoMemory if failed to allocate log body

         or an error from RSessionBase::CreateSession.

         KErrAlreadyExists if Connect has already been called.

 */

	{

	if (iLoggerBody)

		{

		return KErrAlreadyExists;

		}

	iLoggerBody = new RFileLoggerBody;

	if (iLoggerBody)

		{

		TInt ret=DoConnect();

		if (ret==KErrNotFound)

			{

			ret=FLogger::Start();

			if (ret==KErrNone || ret==KErrAlreadyExists)

				ret=DoConnect();

			}

		if (ret != KErrNone)

			{

			// we had a problem (perhaps no memory) so kill loggerbody again

			delete iLoggerBody;

			iLoggerBody = NULL;

			}

		return ret;

		} 

	else

		{

		//OOM, so return KErrNoMemory so that OOM tests know this

		return KErrNoMemory;

		}

	}

EXPORT_C void RFileLogger::Close()

/**

 * Close a client side session with the flogger server.

 * @internalTechnology 

 * @post The client session is closed and the body of the class is deleted.

 *       Further calls to the Write functions will fail silently until a new session is opened.

 */

	{

	if (iLoggerBody)

		{

		iLoggerBody->Close();

		delete iLoggerBody;

		}

	iLoggerBody = NULL;

	}

EXPORT_C void RFileLogger::SetDateAndTime(TBool /*aUseDate*/,TBool /*aUseTime*/)

/**

 * Does nothing.

 * @internalTechnology 

 * @removed    This function no longer needed since now logging to one file and

 *             date/time comes from system.

 */

	{}

EXPORT_C TInt RFileLogger::SetLogTags(const TDesC8& aSubsystem, const TDesC8& aComponent)

/**

 * Set the two tag strings that all further writes by this client will use to

 * idenitfy it in the log file.

 * @internalTechnology 

 * @param aSubsystem	Specifies the tag1 name that goes into the log file

 * @param aComponent	specifies the tag2 name that goes into the log file

 * @post  The client session is updated so that all future calls use this tag set.

 *        Tags are truncated to KMaxTagLength.

 * @return TInt indicating success code (KErrNone) or an error code.

 * @note If an error occurs, the client connection will be silently closed to protect

 *       the client.

 */

	{

	TPtrC8 validSubsystem;

	TPtrC8 validComponent;

	validSubsystem.Set(aSubsystem.Left(KMaxTagLength));

	validComponent.Set(aComponent.Left(KMaxTagLength));

	return DoSetLogTags(validSubsystem, validComponent);

	}

EXPORT_C void RFileLogger::CreateLog(const TDesC& aSubsystem, const TDesC& aComponent, TFileLoggingMode /*aMode*/)

/**

 * Sets the log tags.

 * @internalTechnology 

 * @removed             Not fully supported since flogger only uses one log file. Use SetLogTags instead.

 * @param aSubsystem	Specifies the tag1 name that goes into the log file

 * @param aComponent	specifies the tag2 name that goes into the log file

 * @param aMode         not used

 * @note	            This function is partially supported and is equivalent to calling SetLogTags.

 * @see SetLogTags

 */

	{

	TNameTag narrowComponent;

	CnvUtfConverter::ConvertFromUnicodeToUtf8(narrowComponent,aComponent);

	TNameTag narrowSubsystem;

	CnvUtfConverter::ConvertFromUnicodeToUtf8(narrowSubsystem,aSubsystem);

	(void)DoSetLogTags(narrowSubsystem,narrowComponent);

	}

EXPORT_C void RFileLogger::CloseLog()

/**

 * Close a client side session with the flogger server.

 * @internalTechnology 

 * @deprecated   With the advent of a single log file for all clients, closing the log file is no longer necessary. Use Close to close the session.

 * @see          Close

 */

	{

	Close();

	}

EXPORT_C TBool RFileLogger::LogValid() const

/**

 * Always returns ETrue.

 * @internalTechnology 

 * @removed  With the advent of a single log file for all clients, checking for log validity is no longer necessary.

 * @return   ETrue always.

 */

	{

	return ETrue;

	}

EXPORT_C TInt RFileLogger::LastError() const

/**

 * Always returns KErrNone

 * @internalTechnology 

 * @removed  Flogger no longer retains internal errors.

 * @return   KErrNone always.

 */

	{

	return KErrNone;

	}

EXPORT_C TInt RFileLogger::ClearLog()

/**

 * Request that the server empty the log file.

 * @internalTechnology 

 * @pre  The client requesting the log be cleared must be listed in the flogger "ini" file

 *       as an enabled logging client. This prevents unwanted clients clearing the log.

 *       The session with the server must be active, otherwise this will fail silently.

 * @post A message is added to the server write queue that indicates to clear the log.

 *       Once the message reaches the head of the queue flogger will empty the log file

 *       and begin filling it again.

 * @return TInt indicating success code (KErrNone) or an error code.

 */

	{

	if (IsLogging())

		{

		__ASSERT_ALWAYS(iLoggerBody,User::Panic(KFloggerPanic, EInternalConsistencyFault));

		return iLoggerBody->DoSendReceive(EClearLog, TIpcArgs());

		}

	else

		{

		return KErrNone;

		}

	}

//

// 16-bit non-static writes

//

EXPORT_C void RFileLogger::Write(const TDesC16& aText)

/**

 * Write 16-bit aText to the log file.

 * @internalTechnology 

 * @pre  The client requesting to log must be listed in the flogger "ini" file

 *       as an enabled logging client, otherwise no logging will occur.

 *       The session with the server must be active, otherwise this will fail silently.

 * @param aText Text to write

 * @post The 16-bit text is converted to 8-bit text before writing, and is truncated to KLogBufferSize

 *       if necessary.

 *       The text is preceded in the log file by the two client tags and the client thread ID.

 @note There is no need to supply CR, LF. If these are supplied it may cause the log output to be incorrect.

 */

	{

	if (!IsLogging())

		{

		return;

		}

	TPtrC16 textValid;

	textValid.Set(aText.Left(KLogBufferSize));

	TBuf8<KLogBufferSize> buf;

	CnvUtfConverter::ConvertFromUnicodeToUtf8(buf,textValid);

	DoWrite(buf);

	}

EXPORT_C void RFileLogger::WriteFormat(TRefByValue<const TDesC16> aFmt,...)

/**

 * Write the formatted 16-bit string aFmt to the log file

 * @internalTechnology 

 * @pre  The client requesting to log must be listed in the flogger "ini" file

 *       as an enabled logging client, otherwise no logging will occur.

 *       The session with the server must be active, otherwise this will fail silently.

 * @param aFmt c-style format descriptor, followed by any variables required by the format.

 * @post The 16-bit text is converted to 8-bit text before writing, and is truncated to KLogBufferSize

 *       if necessary.

 *       The text is preceded in the log file by the two client tags and the client thread ID.

 */

	{

	if (!IsLogging())

		{

		return;

		}

  //coverity[var_decl]

	VA_LIST list;

	VA_START(list,aFmt);

	//coverity[uninit_use_in_call]

	DoWriteFormat(aFmt,list);

	}

EXPORT_C void RFileLogger::WriteFormat(TRefByValue<const TDesC16> aFmt, VA_LIST& aList)

/**

 * Write the formatted 16-bit string aFmt to the log file.

 * @internalTechnology 

 * @pre  The client requesting to log must be listed in the flogger "ini" file

 *       as an enabled logging client, otherwise no logging will occur.

 *       The session with the server must be active, otherwise this will fail silently.

 * @param aFmt c-style format descriptor

 * @param aList any variables required by the format.

 * @post The 16-bit text is converted to 8-bit text before writing, and is truncated to KLogBufferSize

 *       if necessary.

 *       The text is preceded in the log file by the two client tags and the client thread ID.

 */

	{

	if (IsLogging())

		{

		DoWriteFormat(aFmt,aList);

		}

	}

//

// 8-bit non-static writes

//

EXPORT_C void RFileLogger::Write(const TDesC8& aText)

/**

 * Write 8-bit aText to the log file.

 * @internalTechnology 

 * @pre  The client requesting to log must be listed in the flogger "ini" file

 *       as an enabled logging client, otherwise no logging will occur.

 *       The session with the server must be active, otherwise this will fail silently.

 * @param aText  Text to log.

 * @post The text is truncated to KLogBufferSize if necessary.

 *       The text is preceded in the log file by the two client tags and the client thread ID.

 */

	{

	TPtrC8 textValid;

	textValid.Set(aText.Left(KLogBufferSize));

	if (IsLogging())

		{

		DoWrite(textValid);

		}

	}

EXPORT_C void RFileLogger::WriteFormat(TRefByValue<const TDesC8> aFmt,...)

/**

 * Write the formatted 8-bit string aFmt to the log file.

 * @internalTechnology 

 * @pre  The client requesting to log must be listed in the flogger "ini" file

 *       as an enabled logging client, otherwise no logging will occur.

 *       The session with the server must be active, otherwise this will fail silently.

 * @param aFmt c-style format descriptor, followed by any variables required by the format.

 * @post The text is truncated to KLogBufferSize if necessary.

 *       The text is preceded in the log file by the two client tags and the client thread ID.

 */

	{

	if (!IsLogging())

		{

		return;

		}

  //coverity[var_decl]		

	VA_LIST list;

	VA_START(list,aFmt);

	//coverity[uninit_use_in_call]  

	DoWriteFormat(aFmt,list);

	}

EXPORT_C void RFileLogger::WriteFormat(TRefByValue<const TDesC8> aFmt, VA_LIST& aList)

/**

 * Write the formatted 8-bit string aFmt to the log file if it is a valid file.

 * @internalTechnology 

 * @pre  The client requesting to log must be listed in the flogger "ini" file

 *       as an enabled logging client, otherwise no logging will occur.

 *       The session with the server must be active, otherwise this will fail silently.

 * @param aFmt c-style format descriptor

 * @param aList any variables required by the format.

 * @post The text is truncated to KLogBufferSize if necessary.

 *       The text is preceded in the log file by the two client tags and the client thread ID.

 */

	{

	if (IsLogging())

		{

		DoWriteFormat(aFmt,aList);

		}

	}

EXPORT_C void RFileLogger::WriteBinary(const TDesC8& aData)

/**

 * Dump arbitrary data to the log file in a binary format.

 * @internalTechnology 

 * @pre  The client requesting to log must be listed in the flogger "ini" file

 *       as an enabled logging client, otherwise no logging will occur.

 *       The session with the server must be active, otherwise this will fail silently.

 * @param aData Descriptor of the data to be dumped

 * @post The 8-bit binary dump is preceded in the log file by the two client tags

 *

 * @note Unlike all other write API's, no thread ID is written with this API.

 */

	{

	if (IsLogging())

		{

		__ASSERT_ALWAYS(iLoggerBody,User::Panic(KFloggerPanic, EInternalConsistencyFault));

		(void)iLoggerBody->DoSendReceive(EWriteBinary, TIpcArgs(&aData, aData.Length()));

		}

	}

//

// 16-bit static writes

//

EXPORT_C void RFileLogger::Write(const TDesC8& aSubsystem, const TDesC8& aComponent, const TDesC16& aText)

/**

 * Static write. Write 16-bit aText to the log file if it is a valid file.

 * @internalTechnology 

   @pre The client requesting to log must be listed in the flogger "ini" file

         as an enabled logging client, otherwise no logging will occur.

 * @param aSubsystem Specifies the tag1 name that goes into the log file

 * @param aComponent specifies the tag2 name that goes into the log file

 * @param aMode not used

 * @param aText Text to write

 * @post The text is converted to 8-bit text before writing, and truncated to KLogBufferSize if necessary.

 *       The text is preceded in the log file by the two client tags and the client thread ID.

 *       "aSubsystem" and "aComponent" are each truncated to KMaxTagLength.

 * @note This function has poor performance since it performs a full connection and disconnection to the flogger server.

 */

	{

	// truncate tags

	TPtrC8 validSubsystem;

	TPtrC8 validComponent;

	validSubsystem.Set(aSubsystem.Left(KMaxTagLength));

	validComponent.Set(aComponent.Left(KMaxTagLength));

	TBuf8<KLogBufferSize> buf;

	CnvUtfConverter::ConvertFromUnicodeToUtf8(buf,aText);

	DoStaticWrite(validSubsystem, validComponent, buf);

	}

EXPORT_C void RFileLogger::WriteFormat(const TDesC8& aSubsystem, const TDesC8& aComponent, const TRefByValue<const TDesC16> aFmt,...)

/**

 * Static write. Write the formatted 16-bit string aFmt to the log file.

 * @internalTechnology 

   @pre The client requesting to log must be listed in the flogger "ini" file

        as an enabled logging client, otherwise no logging will occur.

 * @param aSubsystem Specifies the tag1 name that goes into the log file

 * @param aComponent specifies the tag2 name that goes into the log file

 * @param aFmt c-style format descriptor, followed by any variables required by the format.

 * @post The text is converted to 8-bit text before writing, and truncated to KLogBufferSize if necessary.

 *       The text is preceded in the log file by the two client tags and the client thread ID.

 *       "aSubsystem" and "aComponent" are each truncated to KMaxTagLength.

 * @note This function has poor performance since it performs a full connection and disconnection to the flogger server.

 */

	{

	//coverity[var_decl]

	VA_LIST list;

	VA_START(list,aFmt);

	// truncate tags

	TPtrC8 validSubsystem;

	TPtrC8 validComponent;

	validSubsystem.Set(aSubsystem.Left(KMaxTagLength));

	validComponent.Set(aComponent.Left(KMaxTagLength));

	//coverity[uninit_use_in_call]

	DoStaticWriteFormat(validSubsystem,validComponent,aFmt,list);

	}

EXPORT_C void RFileLogger::WriteFormat(const TDesC8& aSubsystem, const TDesC8& aComponent, const TRefByValue<const TDesC16> aFmt, VA_LIST& aList)

/**

 * Static write. Write the formatted 16-bit string aFmt to the log file.

 * @internalTechnology 

   @pre The client requesting to log must be listed in the flogger "ini" file

        as an enabled logging client, otherwise no logging will occur.

 * @param aSubsystem Specifies the tag1 name that goes into the log file

 * @param aComponent specifies the tag2 name that goes into the log file

 * @param aFmt c-style format descriptor

 * @param aList any variables required by the format.

 * @post The text is converted to 8-bit text before writing, and truncated to KLogBufferSize if necessary.

 *       The text is preceded in the log file by the two client tags and the client thread ID.

 *       "aSubsystem" and "aComponent" are each truncated to KMaxTagLength.

 * @note This function has poor performance since it performs a full connection and disconnection to the flogger server.

 */

	{

	// truncate tags

	TPtrC8 validSubsystem;

	TPtrC8 validComponent;

	validSubsystem.Set(aSubsystem.Left(KMaxTagLength));

	validComponent.Set(aComponent.Left(KMaxTagLength));

	DoStaticWriteFormat(validSubsystem,validComponent,aFmt,aList);

	}

//

// 8-bit static writes

//

EXPORT_C void RFileLogger::Write(const TDesC8& aSubsystem, const TDesC8& aComponent, const TDesC8& aText)

/**

 * Static write. Write 8-bit aText to the log file.

 * @internalTechnology 

   @pre The client requesting to log must be listed in the flogger "ini" file

        as an enabled logging client, otherwise no logging will occur.

 * @param aSubsystem Specifies the tag1 name that goes into the log file

 * @param aComponent specifies the tag2 name that goes into the log file

 * @param aText  Text to log.

 * @post The text is truncated to KLogBufferSize if necessary.

 *       The text is preceded in the log file by the two client tags and the client thread ID.

 *       "aSubsystem" and "aComponent" are each truncated to KMaxTagLength.

 * @note This function has poor performance since it performs a full connection and disconnection to the flogger server.

 */

	{

	// truncate tags

	TPtrC8 validSubsystem;

	TPtrC8 validComponent;

	validSubsystem.Set(aSubsystem.Left(KMaxTagLength));

	validComponent.Set(aComponent.Left(KMaxTagLength));

	DoStaticWrite(validSubsystem,validComponent, aText);

	}

EXPORT_C void RFileLogger::WriteFormat(const TDesC8& aSubsystem, const TDesC8& aComponent, const TRefByValue<const TDesC8> aFmt,...)

/**

 * Static write. Write the formatted 8-bit string aFmt to the log file.

 * @internalTechnology 

   @pre The client requesting to log must be listed in the flogger "ini" file

        as an enabled logging client, otherwise no logging will occur.

 * @param aSubsystem Specifies the tag1 name that goes into the log file

 * @param aComponent specifies the tag2 name that goes into the log file