diff -r 000000000000 -r 08ec8eefde2f traceservices/commsdebugutility/SCLI/comsdbgcli.cpp --- /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 +#include +#include "comsdbgstd.h" +#include + +#include + +#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 buf; + CnvUtfConverter::ConvertFromUnicodeToUtf8(buf,textValid); + DoWrite(buf); + } + +EXPORT_C void RFileLogger::WriteFormat(TRefByValue 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 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 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 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 buf; + CnvUtfConverter::ConvertFromUnicodeToUtf8(buf,aText); + + DoStaticWrite(validSubsystem, validComponent, buf); + } + +EXPORT_C void RFileLogger::WriteFormat(const TDesC8& aSubsystem, const TDesC8& aComponent, const TRefByValue 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 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 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 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 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 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 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 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 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 wideBuf; + __ASSERT_ALWAYS(iLoggerBody,User::Panic(KFloggerPanic, EInternalConsistencyFault)); + wideBuf.AppendFormatList(aFmt, aList, &(iLoggerBody->iFlogOverflow16)); + TBuf8 narrowBuf; + CnvUtfConverter::ConvertFromUnicodeToUtf8(narrowBuf,wideBuf); + DoWrite(narrowBuf); + } + +void RFileLogger::DoWriteFormat(TRefByValue 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 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 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 wideBuf; + TBuf8 narrowBuf; + + wideBuf.AppendFormatList(aFmt, aList, &objFlogBody16); + CnvUtfConverter::ConvertFromUnicodeToUtf8(narrowBuf,wideBuf); + + DoStaticWrite(aSubsystem, aComponent, narrowBuf); + } + +void RFileLogger::DoStaticWriteFormat(const TDesC8& aSubsystem, const TDesC8& aComponent, TRefByValue 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 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 buf; + TBuf8 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; jKHighestPrintableCharacter) ? 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 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);} +