--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/traceservices/commsdebugutility/SCLI/comsdbgcli.cpp Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,1310 @@
+// 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
+ * @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.
+ * "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 TDesC8> 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 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);
+ }
+
+
+
+
+
+
+//
+// Removed 16-bit static writes
+//
+
+EXPORT_C void RFileLogger::Write(const TDesC& aSubsystem, const TDesC& aComponent, TFileLoggingMode /*aMode*/, const TDesC16& aText)
+/**
+ * Static write. Write 16-bit aText to the log file if it is a valid file.
+ * @internalTechnology
+ * @removed With the advent of a single log file for all clients, this function has been replaced by an equivalent without the aMode parameter.
+ @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.
+ */
+ {
+ // the convert also truncates if necessary
+ TNameTag narrowComponent;
+ CnvUtfConverter::ConvertFromUnicodeToUtf8(narrowComponent,aComponent);
+ TNameTag narrowSubsystem;
+ CnvUtfConverter::ConvertFromUnicodeToUtf8(narrowSubsystem,aSubsystem);
+
+ Write(narrowSubsystem, narrowComponent, aText);
+ }
+
+EXPORT_C void RFileLogger::WriteFormat(const TDesC& aSubsystem, const TDesC& aComponent, TFileLoggingMode aMode, TRefByValue<const TDesC16> aFmt,...)
+/**
+ * Static write. Write the formatted 16-bit string aFmt to the log file.
+ * @internalTechnology
+ * @removed With the advent of a single log file for all clients, this function has been replaced by an equivalent without the aMode parameter.
+ @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 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.
+ */
+ {
+ // Just to remove the warning otherwise this does nothing
+ if (aMode == EFileLoggingModeUnknown) { }
+ //coverity[var_decl]
+ VA_LIST list;
+ VA_START(list,aFmt);
+
+ // the convert also truncates if necessary
+ TNameTag narrowComponent;
+ CnvUtfConverter::ConvertFromUnicodeToUtf8(narrowComponent,aComponent);
+ TNameTag narrowSubsystem;
+ CnvUtfConverter::ConvertFromUnicodeToUtf8(narrowSubsystem,aSubsystem);
+ //coverity[uninit_use_in_call]
+ DoStaticWriteFormat(narrowSubsystem, narrowComponent,aFmt,list);
+ }
+
+EXPORT_C void RFileLogger::WriteFormat(const TDesC& aSubsystem, const TDesC& aComponent, TFileLoggingMode /*aMode*/, TRefByValue<const TDesC16> aFmt, VA_LIST& aList)
+/**
+ * Static write. Write the formatted 16-bit string aFmt to the log file.
+ * @internalTechnology
+ * @removed With the advent of a single log file for all clients, this function has been replaced by an equivalent without the aMode parameter.
+ @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 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.
+ */
+ {
+ // the convert also truncates if necessary
+ TNameTag narrowComponent;
+ CnvUtfConverter::ConvertFromUnicodeToUtf8(narrowComponent,aComponent);
+ TNameTag narrowSubsystem;
+ CnvUtfConverter::ConvertFromUnicodeToUtf8(narrowSubsystem,aSubsystem);
+
+ DoStaticWriteFormat(narrowSubsystem, narrowComponent,aFmt,aList);
+ }
+
+//
+// Removed 8-bit static writes
+//
+
+EXPORT_C void RFileLogger::Write(const TDesC& aSubsystem, const TDesC& aComponent, TFileLoggingMode /*aMode*/, const TDesC8& aText)
+/**
+ * Static write. Write 8-bit aText to the log file.
+ * @internalTechnology
+ * @removed With the advent of a single log file for all clients, this function has been replaced by an equivalent without the aMode parameter.
+ @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 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.
+ */
+ {
+ // the convert also truncates if necessary
+ TNameTag narrowComponent;
+ CnvUtfConverter::ConvertFromUnicodeToUtf8(narrowComponent,aComponent);
+ TNameTag narrowSubsystem;
+ CnvUtfConverter::ConvertFromUnicodeToUtf8(narrowSubsystem,aSubsystem);
+
+ Write(narrowSubsystem, narrowComponent, aText);
+ }
+
+EXPORT_C void RFileLogger::WriteFormat(const TDesC& aSubsystem, const TDesC& aComponent, TFileLoggingMode aMode, TRefByValue<const TDesC8> aFmt,...)
+/**
+ * Static write. Write the formatted 8-bit string aFmt to the log file.
+ * @internalTechnology
+ * @removed With the advent of a single log file for all clients, this function has been replaced by an equivalent without the aMode parameter.
+ @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 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.
+ * "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.
+ */
+
+ {
+ // Just to remove the warning otherwise this does nothing
+ if (aMode == EFileLoggingModeUnknown) { }
+ //coverity[var_decl]
+ VA_LIST list;
+ VA_START(list,aFmt);
+
+ // the convert also truncates if necessary
+ TNameTag narrowComponent;
+ CnvUtfConverter::ConvertFromUnicodeToUtf8(narrowComponent,aComponent);
+ TNameTag narrowSubsystem;
+ CnvUtfConverter::ConvertFromUnicodeToUtf8(narrowSubsystem,aSubsystem);
+ //coverity[uninit_use_in_call]
+ DoStaticWriteFormat(narrowSubsystem, narrowComponent, aFmt, list);
+ }
+
+EXPORT_C void RFileLogger::WriteFormat(const TDesC& aSubsystem, const TDesC& aComponent, TFileLoggingMode /*aMode*/, TRefByValue<const TDesC8> aFmt, VA_LIST& aList)
+/**
+ * Static write. Write the formatted 16-bit string aFmt to the log file.
+ * @internalTechnology
+ * @removed With the advent of a single log file for all clients, this function has been replaced by an equivalent without the aMode parameter.
+ @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 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.
+ * "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.
+ */
+ {
+ // the convert also truncates if necessary
+ TNameTag narrowComponent;
+ CnvUtfConverter::ConvertFromUnicodeToUtf8(narrowComponent,aComponent);
+ TNameTag narrowSubsystem;
+ CnvUtfConverter::ConvertFromUnicodeToUtf8(narrowSubsystem,aSubsystem);
+
+ DoStaticWriteFormat(narrowSubsystem, narrowComponent,aFmt,aList);
+ }
+
+//
+// Hex Dumps
+//
+
+EXPORT_C void RFileLogger::HexDump(const TText* aHeader, const TText* aMargin, const TUint8* aPtr, TInt aLen)
+/**
+ * Dump arbitrary data to the log file as a standard hex dump.
+ * @internalTechnology
+ * @pre The session with the server must be active, otherwise this no action is taken.
+ The client requesting to log must be listed in the flogger "ini" file
+ as an enabled logging client, otherwise no logging will occur.
+ * @param aHeader Specify a zero-terminated string to be printed before the first hex line. Leave as null or an empty string for no header.
+ * @param aMargin Specify a zero-terminated string to be printed before each subsequent line. Leave as null or an empty string for no Margin.
+ * @param aPtr pointer to the data being dumped.
+ * @param aLen the number of bytes to dump
+ * @post Each line is preceded in the log file by the two client tags and the client thread ID.
+ * @note Example of aHeader/aMargin. If "aHeader" is set to "Fn Output:" and "aMargin" is set to " ", then output would look
+ * like (for a print of the alphabet):
+ * TLOG Example 20 FnOutput:0000 : 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f 70 abcdefghijklmnop
+ * TLOG Example 20 0010 : 71 72 73 74 75 76 77 78 79 7a qrstuvwxyz
+ *
+ */
+ {
+ if (IsLogging())
+ {
+ DoHexDump(aHeader,aMargin,aPtr,aLen);
+ }
+
+
+ }
+
+
+
+EXPORT_C void RFileLogger::HexDump(const TDesC8& aData, const TDesC8& aHeader)
+/**
+ * Dump arbitrary data to the log file as a standard hex dump.
+ * @internalTechnology
+ * @pre The session with the server must be active, otherwise this no action is taken.
+ The client requesting to log must be listed in the flogger "ini" file
+ as an enabled logging client, otherwise no logging will occur.
+ * @param aData the data being dumped.
+ * @param aHeader Specify a string to be printed before the first hex line. If not supplied, no header or margin is written.
+ * If supplied, then subsequent lines are indented to the length of aHeader.
+ * @post Each line is preceded in the log file by the two client tags and the client thread ID.
+ * @note Example of aHeader. If "aHeader" is set to "Fn Output:" then output would look
+ * like (for a print of the alphabet):
+ * TLOG Example 20 FnOutput:0000 : 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f 70 abcdefghijklmnop
+ * TLOG Example 20 0010 : 71 72 73 74 75 76 77 78 79 7a qrstuvwxyz
+ *
+ */
+ {
+ if (IsLogging())
+ {
+ DoHexDump(aData,aHeader,TPtrC8(NULL,0));
+ }
+
+
+ }
+
+
+
+
+
+
+EXPORT_C void RFileLogger::HexDump(const TDesC8& aSubsystem, const TDesC8& aComponent, const TDesC8& aData, const TDesC8& aHeader)
+/**
+ * Static Write. Dump arbitrary data to the log file as a standard hex dump.
+ * @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 aData the data being dumped.
+ * @param aHeader Specify a string to be printed before the first hex line. If not supplied, no header or Margin is written.
+ * @param aMargin Specify a string to be printed before each subsequent line. If not supplied, a string of spaces equal to the length of aHeader is used.
+ * @post Each line 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.
+ * Example of aHeader/aMargin. If "aHeader" is set to "Fn Output:" and "aMargin" is set to " ", then output would look
+ * like (for a print of the alphabet):
+ * TLOG Example 20 FnOutput:0000 : 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f 70 abcdefghijklmnop
+ * TLOG Example 20 0010 : 71 72 73 74 75 76 77 78 79 7a qrstuvwxyz
+ *
+ */
+ {
+ RFileLogger logger;
+ TInt ret=logger.Connect();
+ if (ret==KErrNone)
+ {
+ ret = logger.SetLogTags(aSubsystem,aComponent);
+ if (((ret == KErrNone) && logger.iLoggerBody) && logger.iLoggerBody->iLoggingOnPckg())
+ {
+ logger.DoHexDump(aData,aHeader,TPtrC8(NULL,0));
+ }
+ logger.Close();
+ }
+ }
+
+
+
+
+
+EXPORT_C void RFileLogger::HexDump(const TDesC& aSubsystem, const TDesC& aComponent, TFileLoggingMode /*aMode*/, const TText* aHeader, const TText* aMargin, const TUint8* aPtr, TInt aLen)
+/**
+ * Static Write. Dump arbitrary data to the log file as a standard hex dump.
+ * @internalTechnology
+ * @removed With the advent of a single log file for all clients, this function has been replaced by an equivalent without the aMode parameter.
+ @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 aHeader Specify a zero-terminated string to be printed before the first hex line. Leave as null or an empty string for no header.
+ * @param aMargin Specify a zero-terminated string to be printed before each subsequent line. Leave as null or an empty string for no Margin.
+ * @param aPtr pointer to the data being dumped.
+ * @param aLen the number of bytes to dump
+ * @post Each line 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.
+ * Example of aHeader/aMargin. If "aHeader" is set to "Fn Output:" and "aMargin" is set to " ", then output would look
+ * like (for a print of the alphabet):
+ * TLOG Example 20 FnOutput:0000 : 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f 70 abcdefghijklmnop
+ * TLOG Example 20 0010 : 71 72 73 74 75 76 77 78 79 7a qrstuvwxyz
+ *
+ */
+ {
+ // the convert also truncates if necessary
+ TNameTag narrowComponent;
+ CnvUtfConverter::ConvertFromUnicodeToUtf8(narrowComponent,aComponent);
+ TNameTag narrowSubsystem;
+ CnvUtfConverter::ConvertFromUnicodeToUtf8(narrowSubsystem,aSubsystem);
+
+ RFileLogger logger;
+ TInt ret=logger.Connect();
+ if (ret==KErrNone)
+ {
+ ret = logger.SetLogTags(narrowSubsystem,narrowComponent);
+ if (((ret == KErrNone) && logger.iLoggerBody) && logger.iLoggerBody->iLoggingOnPckg())
+ {
+ logger.DoHexDump(aHeader,aMargin,aPtr,aLen);
+ }
+ logger.Close();
+ }
+
+ }
+
+
+EXPORT_C TInt RFileLogger::Handle() const
+// Returns handle of session, or Null if no session.
+ {
+ if (iLoggerBody)
+ {
+ return iLoggerBody->Handle();
+ }
+ else
+ {
+ return 0;
+ }
+ }
+
+EXPORT_C TInt RFileLogger::Share()
+ {
+ if (iLoggerBody)
+ {
+ return iLoggerBody->ShareAuto();
+ }
+ return KErrSessionClosed;
+ }
+
+
+//
+// Debug tools to check for memory leaks
+//
+
+EXPORT_C void RFileLogger::__DbgShutDownServer()
+/**
+ * Debugging Tool. Ask the flogger server to shutdown. Only valid in DEBUG builds.
+ * @internalTechnology
+ */
+ {
+#ifdef _DEBUG
+ if (iLoggerBody)
+ (void)iLoggerBody->DoSendReceive(EShutDownServer);
+#endif
+ }
+
+EXPORT_C void RFileLogger::__DbgSetHeapFailure(TInt aFailAfter)
+/**
+ * Debugging Tool. Ask the flogger server to set its heap failure. Only valid in DEBUG builds.
+ * @internalTechnology
+ * @param aFailAfter The number of successful memory allocations which will occur before
+ * a memory allocation is failed by the memory manager.
+ */
+ {
+#ifdef _DEBUG
+ if (iLoggerBody)
+ {
+ (void)iLoggerBody->DoSendReceive(ESetHeapFailure, TIpcArgs(aFailAfter));
+ }
+#else
+ (void)aFailAfter;
+#endif
+ }
+
+//
+// Private functions
+//
+
+TInt RFileLogger::DoConnect()
+/**
+ * Connect to the flogger server
+ * @return TInt indicating success code (KErrNone) or an error code.
+ * @note: creates 1 slot: no asynchronous IPC so never need more than 1 reserved message slot.
+ @internalComponent
+ */
+ {
+ __ASSERT_ALWAYS(iLoggerBody,User::Panic(KFloggerPanic, EInternalConsistencyFault));
+ return iLoggerBody->DoCreateSession(KFLoggerServerName,Version(),KNumberMessageSlots);
+ }
+
+TInt RFileLogger::DoSetLogTags(const TDesC8& aSubsystem, const TDesC8& aComponent)
+/**
+ * Set the two tag strings that all further writes by this client will use to
+ * identify it in the log file.
+ * @param aSubsystem Specifies the tag1 name that goes into the log file
+ * @param aComponent specifies the tag2 name that goes into the log file
+ * @return TInt indicating success code (KErrNone), or (KErrNotFound) if
+ the connection is not valid, or an error code from SendReceive.
+ * @note If an error occurs, the client connection will be silently closed to protect
+ * the client.
+ */
+ {
+ TInt err(KErrNone);
+ if (iLoggerBody) //check that the connection was set up correctly
+ {
+ err = iLoggerBody->DoSendReceive(ESetLogTag, TIpcArgs(&aSubsystem, &aComponent, &(iLoggerBody->iLoggingOnPckg)));
+ if (err !=KErrNone )
+ { //Something went wrong. We need to protect the client because error can be ignored.
+ Close();
+ }
+ }
+ else
+ {
+ err = KErrNotFound;
+ }
+ return err;
+ }
+
+void RFileLogger::DoWrite(const TDesC8& aBuf)
+/**
+ * Send to the flogger server the pre-formatted write string.
+ * @internalTechnology
+ * @pre session is already open.
+ * @param aBuf 8-bit text to be written. It must not exceed KLogBufferSize.
+ */
+ {
+ __ASSERT_ALWAYS(iLoggerBody,User::Panic(KFloggerPanic, EInternalConsistencyFault));
+ (void)iLoggerBody->DoSendReceive(EWriteToLog,TIpcArgs(&aBuf, aBuf.Length()));
+ }
+
+void RFileLogger::DoWriteFormat(TRefByValue<const TDesC16> aFmt, VA_LIST& aList)
+/**
+ * Trim and convert format string before sending to the flogger server.
+ * @pre session is already open.
+ * @param aFmt c-style formatted text to be written.
+ * @param aList any variables required by the format.
+ * @post The final string is truncated to KLogBufferSize and converted to 8-bit.
+ */
+ {
+ TBuf16<KLogBufferSize> wideBuf;
+ __ASSERT_ALWAYS(iLoggerBody,User::Panic(KFloggerPanic, EInternalConsistencyFault));
+ wideBuf.AppendFormatList(aFmt, aList, &(iLoggerBody->iFlogOverflow16));
+ TBuf8<KLogBufferSize> narrowBuf;
+ CnvUtfConverter::ConvertFromUnicodeToUtf8(narrowBuf,wideBuf);
+ DoWrite(narrowBuf);
+ }
+
+void RFileLogger::DoWriteFormat(TRefByValue<const TDesC8> aFmt, VA_LIST& aList)
+/**
+ * Trim format string before sending to the flogger server.
+ * @pre session is already open.
+ * @param aFmt c-style formatted text to be written.
+ * @param aList any variables required by the format.
+ * @post The final string is truncated to KLogBufferSize.
+ */
+ {
+ TBuf8<KLogBufferSize> buf;
+ __ASSERT_ALWAYS(iLoggerBody,User::Panic(KFloggerPanic, EInternalConsistencyFault));
+ buf.AppendFormatList(aFmt,aList, &(iLoggerBody->iFlogOverflow8));
+ DoWrite(buf);
+ }
+
+void RFileLogger::DoSendStaticWrite(const TDesC8& aSubsystem, const TDesC8& aComponent, const TDesC8& aText)
+/**
+ * Send to the flogger server the pre-formatted write string.
+ * @pre session is already open.
+ * aText is not longer than KLogBufferSize
+ * @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 write
+ * @post The text is only written if the tag1+tag2 combination is listed as an enabled client
+ * in the flogger "ini" file, otherwise no action is taken.
+ * The text is preceded in the log file by the two client tags and the client thread ID.
+ */
+ {
+ __ASSERT_ALWAYS(iLoggerBody,User::Panic(KFloggerPanic, EInternalConsistencyFault));
+ (void)iLoggerBody->DoSendReceive(EStaticWriteToLog,TIpcArgs(&aSubsystem, &aComponent, &aText, aText.Length())); // ignore error
+ }
+
+void RFileLogger::DoStaticWrite(const TDesC8& aSubsystem, const TDesC8& aComponent, const TDesC8& aText)
+/**
+ * Send to the flogger server the pre-formatted write string.
+ * @pre session is already open.
+ * aText is not longer than KLogBufferSize
+ * @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 write
+ * @post The text is only written if the tag1+tag2 combination is listed as an enabled client
+ * in the flogger "ini" file, otherwise no action is taken.
+ * The text is preceded in the log file by the two client tags and the client thread ID.
+ */
+ {
+ RFileLogger logger;
+ TInt ret=logger.Connect();
+ if (ret==KErrNone)
+ {
+ TPtrC8 textValid;
+ textValid.Set(aText.Left(KLogBufferSize));
+
+ logger.DoSendStaticWrite(aSubsystem, aComponent, textValid);
+ }
+
+ logger.Close();
+ }
+
+
+
+void RFileLogger::DoStaticWriteFormat(const TDesC8& aSubsystem, const TDesC8& aComponent, TRefByValue<const TDesC> aFmt, VA_LIST& aList)
+/**
+ * Send to the flogger server a format write string.
+ * @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 formatted text to be written.
+ * @param aList any variables required by the format.
+ * @post The text is only written if the tag1+tag2 combination is listed as an enabled client
+ * in the flogger "ini" file, otherwise no action is taken.
+ * If necessary, the final string is truncated to KLogBufferSize.
+ * The final string is converted to an 8-bit string.
+ * The text is preceded in the log file by the two client tags and the client thread ID.
+ */
+ {
+ TFlogOverflow16 objFlogBody16;
+ TBuf<KLogBufferSize> wideBuf;
+ TBuf8<KLogBufferSize> narrowBuf;
+
+ wideBuf.AppendFormatList(aFmt, aList, &objFlogBody16);
+ CnvUtfConverter::ConvertFromUnicodeToUtf8(narrowBuf,wideBuf);
+
+ DoStaticWrite(aSubsystem, aComponent, narrowBuf);
+ }
+
+void RFileLogger::DoStaticWriteFormat(const TDesC8& aSubsystem, const TDesC8& aComponent, TRefByValue<const TDesC8> aFmt, VA_LIST& aList)
+/**
+ * Send to the flogger server a format write string.
+ * @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 formatted text to be written.
+ * @param aList any variables required by the format.
+ * @post The text is only written if the tag1+tag2 combination is listed as an enabled client
+ * in the flogger "ini" file, otherwise no action is taken.
+ * If necessary, the final string is truncated to KLogBufferSize.
+ * The text is preceded in the log file by the two client tags and the client thread ID.
+ */ {
+ TFlogOverflow8 objFlogBody8;
+ TBuf8<KLogBufferSize> buf;
+ buf.AppendFormatList(aFmt, aList, &objFlogBody8);
+
+ DoStaticWrite(aSubsystem, aComponent, buf);
+ }
+
+void RFileLogger::DoHexDump(const TText* aHeader, const TText* aMargin, const TUint8* aPtr, TInt aLen)
+/**
+ * Static Write. Dump arbitrary data to the log file as a standard hex dump.
+ * @pre session is already open.
+ * @param aHeader Specify a zero-terminated string to be printed before the first hex line. Leave as null or an empty string for no header.
+ * @param aMargin Specify a zero-terminated string to be printed before each subsequent line. Leave as null or an empty string for no Margin.
+ * @param aPtr pointer to the data being dumped.
+ * @param aLen the number of bytes to dump
+ * @post The text is only written if the tag1+tag2 combination is listed as an enabled client
+ * in the flogger "ini" file, otherwise no action is taken.
+ * Each line is preceded in the log file by the two client tags and the client thread ID.
+ * The data is written in lines of 16 characters.
+ * @note Example of aHeader/aMargin. If "aHeader" is set to "Fn Output:" and "aMargin" is set to " ", then output would look
+ * like (for a print of the alphabet):
+ * TLOG Example 20 FnOutput:0000 : 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f 70 abcdefghijklmnop
+ * TLOG Example 20 0010 : 71 72 73 74 75 76 77 78 79 7a qrstuvwxyz
+ *
+ */
+ {
+ // this delightful art-deco code lifted straight from old flogger
+ if (aPtr==NULL) // nothing to do
+ {
+ return;
+ }
+
+ TBuf<KMaxHexDumpWidth> buf;
+ TBuf8<KMaxHexDumpWidth> temp;
+
+
+ TInt i=0;
+ const TText* p=aHeader;
+ while (aLen>0)
+ {
+ if (p==NULL)
+ {
+ p=BLANK; // if NULL set p to a blank string
+ }
+ TInt n=(aLen>KHexDumpWidth ? KHexDumpWidth : aLen);
+ __ASSERT_ALWAYS(iLoggerBody,User::Panic(KFloggerPanic, EInternalConsistencyFault));
+ buf.AppendFormat(KFirstFormatString,&(iLoggerBody->iFlogOverflow16),p,i);
+ TInt j;
+ for (j=0; j<n; j++)
+ {
+ buf.AppendFormat(KSecondFormatString,aPtr[i+j]);
+ }
+ while (j++<KHexDumpWidth)
+ {
+ buf.Append(KThreeSpaces);
+ }
+ buf.Append(KTwoSpaces);
+ for (j=0; j<n; j++)
+ {
+ buf.AppendFormat(KThirdFormatString,(aPtr[i+j]<KLowestPrintableCharacter || aPtr[i+j]>KHighestPrintableCharacter) ? KFullStopChar : aPtr[i+j]);
+ }
+
+ CnvUtfConverter::ConvertFromUnicodeToUtf8(temp,buf);
+ DoWrite(temp);
+
+ buf.SetLength(0);
+ temp.SetLength(0);
+ aLen-=n;
+ i+=n;
+ p=aMargin;
+ }
+ }
+
+
+
+void RFileLogger::DoHexDump(const TDesC8& aData, const TDesC8& aHeader, const TDesC8& aMargin)
+/**
+ * Static Write. Dump arbitrary data to the log file as a standard hex dump.
+ * @see RFileLogger::HexDump(const TDesC8& aData, const TDesC8& aHeader = 0)
+ * @param aMargin - supply a margin - if left null, then a margin of spaces of equal length to "aHeader"
+ * is used.
+ * @pre session is already open.
+ */
+ {
+ HBufC8* marginStr = NULL;
+ TBuf8<KMaxHexDumpWidth> buf;
+ TInt aRemainingLen = aData.Length();
+ TInt aHeaderLen = aHeader.Length();
+
+ __ASSERT_ALWAYS(iLoggerBody,User::Panic(KFloggerPanic, EInternalConsistencyFault));
+
+ if (aData.Length()==0) // nothing to do
+ {
+ return;
+ }
+
+
+ if (aHeaderLen > 0)
+ {
+
+ if (aMargin.Length() == 0)
+ {
+ marginStr = HBufC8::New(aHeader.Length());
+ if (marginStr == NULL)
+ {
+ return; // abort if No memory
+ }
+ TPtr8 marginStrPtr(marginStr->Des());
+ marginStrPtr.AppendFill(' ',aHeader.Length());
+ }
+ else
+ {
+ marginStr = aMargin.Alloc();
+ }
+ }
+
+
+
+ TUint blockStartPos = 0;
+ while (aRemainingLen>0)
+ {
+ TInt blockLength = (aRemainingLen>KHexDumpWidth ? KHexDumpWidth : aRemainingLen);
+
+ // write the header/margin and print in hex which bytes we are about to write
+ if (blockStartPos == 0)
+ {
+ if (aHeaderLen > 0)
+ {
+ buf.Append(aHeader);
+ }
+ buf.AppendFormat(KFirstFormatString8,&(iLoggerBody->iFlogOverflow8), blockStartPos);
+ }
+ else
+ {
+ if (marginStr)
+ {
+ buf.Append(*marginStr);
+ }
+ buf.AppendFormat(KFirstFormatString8,&(iLoggerBody->iFlogOverflow8),blockStartPos);
+ }
+
+ TInt bytePos;
+ // write the bytes as hex
+ for (bytePos = 0; bytePos < blockLength; bytePos++)
+ {
+ buf.AppendFormat(KSecondFormatString8,aData[blockStartPos + bytePos]);
+ }
+ while (bytePos++ < KHexDumpWidth)
+ {
+ buf.Append(KThreeSpaces8);
+ }
+ buf.Append(KTwoSpaces8);
+ // print the bytes as characters, or full stops if outside printable range
+ for (bytePos = 0; bytePos < blockLength; bytePos++)
+ {
+ buf.AppendFormat(KThirdFormatString8,(aData[blockStartPos + bytePos] < KLowestPrintableCharacter || aData[blockStartPos + bytePos] > KHighestPrintableCharacter) ? KFullStopChar8 : aData[blockStartPos + bytePos]);
+ }
+
+ DoWrite(buf);
+
+ buf.SetLength(0);
+ aRemainingLen -= blockLength;
+ blockStartPos += blockLength;
+ }
+ delete marginStr;
+ }
+
+
+
+EXPORT_C void ClientRunStubOrdinal1()
+/**
+ * @removed This function has been removed because the flogsvrl dll contains the equivalent function
+@internalComponent
+ */
+ {User::Panic(KFloggerPanic, KErrNotSupported);}
+