--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/testtoolsconn/stat/desktop/source/lib/src/crepmisc.cpp Mon Mar 08 15:04:18 2010 +0800
@@ -0,0 +1,623 @@
+/*
+* Copyright (c) 2005-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:
+*
+*/
+
+
+
+
+#include "stdafx.h"
+#include <time.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <string.h>
+#include "cReporter.h"
+
+
+/*****************************************************************************
+ * Reporter preparation
+ *
+ * Sets member strings to a known state
+ *****************************************************************************/
+
+void
+Reporter::prepare ( void )
+{
+ int i;
+
+#ifdef RPT_DEBUG_PROG
+ // set filename contents to garbage value
+ for (i=0;i<CPO_MAX_FILENAME_LEN;i++)
+ {
+ filename [ i ] = CPO_GARBAGE_CHAR;
+ }
+
+ // set program name contents to garbage value
+ for (i=0;i<RPT_MAX_PROGRAM_LEN;i++)
+ {
+ progname [ i ] = CPO_GARBAGE_CHAR;
+ }
+#endif
+
+ for (i=0;i<RPT_MAX_LIST_ENTRIES;i++)
+ {
+ messageList [ i ] = (char *)0;
+ }
+
+ fileRead = 0;
+ pCurrent = (va_list) 0;
+ prefix = 0;
+ state = 0;
+ hFile = (HANDLE) 0;
+ filename [ 0 ] = '\0';
+ progname [ 0 ] = '\0';
+}
+
+/*****************************************************************************
+ * Reporter setup
+ *
+ * Checks the output streams.
+ * Sets the prefix mask.
+ * Stores a copy of the application name.
+ * Puts a message into the logging file that the Reporter is initialised.
+ *****************************************************************************/
+
+CPO_BOOL
+Reporter::setup ( const char * appName,
+ const BITFIELD prefixMask,
+ const unsigned long ulOpenAttributes )
+{
+ // check for valid output destinations
+ if ( !( state & RPT_FILE ) &&
+ !( state & RPT_STDOUT ) &&
+ !( state & RPT_STDERR ) )
+ {
+ return ( CPO_FALSE );
+ }
+
+ // check for valid mask
+ if ( !( prefixMask & RPT_MSG_TYPE ) &&
+ !( prefixMask & RPT_APPNAME ) &&
+ !( prefixMask & RPT_DATE ) &&
+ !( prefixMask & RPT_TIME ) )
+ {
+ prefix = RPT_MSG_ONLY;
+ }
+ else
+ {
+ prefix = prefixMask;
+ }
+
+ // get the actual program name and make sure it is valid
+ extractName ( progname, appName, RPT_MAX_PROGRAM_LEN );
+ validateText ( progname, RPT_MAX_PROGRAM_LEN );
+ if ( !( *progname ) )
+ {
+ return ( CPO_FALSE );
+ }
+
+ if ( state & RPT_FILE )
+ {
+ // open output file
+ if ( !openFile ( ulOpenAttributes ) )
+ {
+ state -= RPT_FILE;
+ if ( !( state & RPT_OUTPUT_MASK ) )
+ {
+ return ( CPO_FALSE );
+ }
+ }
+ }
+
+ // set flags to show everything ok
+ state |= CPO_CONNECTED;
+ state |= CPO_ACTIVATED;
+
+ return ( CPO_TRUE );
+}
+
+/*****************************************************************************
+ * Resolve a code to a message and build it.
+ *****************************************************************************/
+
+void
+Reporter::actOnCode ( int code, char messType )
+{
+ // must be initialised and activated
+ if ( ( state & CPO_CONNECTED ) &&
+ ( state & CPO_ACTIVATED ) &&
+ code >= 0 &&
+ code < RPT_MAX_LIST_ENTRIES )
+ {
+ if ( messageList [ code ] )
+ {
+ buildMessage ( messageList [ code ], messType );
+ }
+ else
+ {
+ char tmpMsg [ 128 ];
+ (void) sprintf ( tmpMsg, "[ No message text for code %d ]", code );
+ buildMessage ( tmpMsg, messType );
+ }
+ }
+}
+
+/*****************************************************************************
+ * Generate a filename using the application name and current date.
+ *****************************************************************************/
+
+void
+Reporter::generateFilename ( char * validName, const char * appName )
+{
+ /* Construct a filename for the logging to be written to.
+ * Filename is of the format x[xxx]9988.rpt where :
+ *
+ * xxxx = up to first 4 chars of calling program's name
+ * 99 = 2 digit day of month
+ * 88 = 2 digit month of year
+ */
+
+ const int PROG_LEN = 4;
+ time_t curtime;
+ struct tm *tminfo;
+
+ // get filename from path
+ extractName ( buffer, appName, PROG_LEN );
+
+ (void) time ( &curtime );
+ tminfo = localtime ( &curtime );
+
+ (void) sprintf ( validName,
+ "%s%02d%02d.RPT",
+ buffer,
+ tminfo->tm_mday,
+ tminfo->tm_mon + 1);
+
+#ifdef RPT_DEBUG_PROG
+ (void) fprintf ( stdout, "filename [%s] generated from [%s]\n",
+ validName, appName );
+ (void) fflush ( stdout );
+#endif
+}
+
+/*****************************************************************************
+ * Extract 'length' characters of the actual filename from the path.
+ *****************************************************************************/
+
+void
+Reporter::extractName ( char * file, const char * path, const int length )
+{
+ char *ptr;
+
+ // find the last backslash
+ ptr = strrchr ( path, '\\' );
+
+ if ( !ptr )
+ {
+ strncpy ( file, path, length );
+ }
+ else
+ {
+ strncpy ( file, (++ptr), length );
+ }
+
+ *( file + length ) = '\0';
+}
+
+/****************************************************************************
+ * Open the file or print a message if we can't
+ *****************************************************************************/
+
+int
+Reporter::openFile ( unsigned long ulOpenAttributes )
+{
+#ifdef UNICODE
+ TCHAR uFilename[CPO_MAX_FILENAME_LEN + 1];
+
+ // Convert to UNICODE.
+ if (!MultiByteToWideChar(CP_ACP, // conversion type
+ 0, // flags
+ filename, // source
+ -1, // length
+ uFilename, // dest
+ CPO_MAX_FILENAME_LEN)) // length
+ {
+ return ( CPO_FALSE );
+ }
+
+ hFile = CreateFile(uFilename,
+ GENERIC_WRITE,
+ FILE_SHARE_READ | FILE_SHARE_WRITE,
+ NULL,
+ ulOpenAttributes,
+ FILE_ATTRIBUTE_NORMAL,
+ NULL);
+#else
+ hFile = CreateFile(filename,
+ GENERIC_WRITE,
+ FILE_SHARE_READ | FILE_SHARE_WRITE,
+ NULL,
+ ulOpenAttributes,
+ FILE_ATTRIBUTE_NORMAL,
+ NULL);
+#endif
+
+ if (hFile == INVALID_HANDLE_VALUE)
+ {
+// char szTemp[500] = {0};
+// sprintf(szTemp, "WARNING : [%s] could not be opened. File output disabled", filename);
+// MessageBox(NULL, szTemp, NULL, MB_OK);
+ return ( CPO_FALSE );
+ }
+
+ // move to the end if a file already exists
+ SetFilePointer(hFile, 0, 0, FILE_END);
+
+#ifdef RPT_DEBUG_PROG
+ (void) fprintf ( stdout, "file [%s] opened\n", filename );
+ (void) fflush ( stdout );
+#endif
+
+ return ( CPO_TRUE );
+}
+
+/*****************************************************************************
+ * Construct the parts of the complete message.
+ *****************************************************************************/
+
+void
+Reporter::buildMessage ( const char * message, const char messType )
+{
+ char prefixInfo [ RPT_MAX_MSG_LEN + 1 ];
+ char finalStr [ RPT_OPEN_MSG_LEN + RPT_MAX_MSG_LEN + 1 ];
+ int maxlen;
+
+ // get prefix information
+ switch ( messType )
+ {
+ case RPT_TEXT:
+ case RPT_MSG:
+ *( prefixInfo ) = '\0';
+ break;
+ case RPT_HEADER:
+ addHeaderInfo ( prefixInfo );
+ break;
+ default:
+ addLogInfo ( prefixInfo, messType );
+ break;
+ }
+
+ // parse arguments passed with message
+ (void) vsprintf ( buffer, message, pCurrent );
+
+ // get max length of output string
+ if ( messType == RPT_DEBUG || messType == RPT_MSG ||
+ messType == RPT_ERROR || messType == RPT_TEXT )
+ {
+ maxlen = RPT_OPEN_MSG_LEN - (int) strlen ( prefixInfo ) - 1;
+ }
+ else
+ {
+ maxlen = RPT_MAX_MSG_LEN - (int) strlen ( prefixInfo ) - 1;
+ }
+
+ // make sure we are dealing with a valid message of correct length
+ validateText ( buffer, maxlen );
+
+ // generate the output string
+ (void) sprintf ( finalStr,
+ "%s%s",
+ prefixInfo,
+ buffer );
+
+ if ( messType == RPT_TEXT )
+ {
+ (void) strcpy ( buffer, finalStr );
+ }
+ else
+ {
+ writeToStream ( finalStr );
+ }
+}
+
+/*****************************************************************************
+ * Validate the supplied string for zero length and unprintable chars up to
+ * length bytes.
+ *
+ * If unprintable chars are found embedded in the text, the text will be
+ * truncated at that point.
+ *
+ * If the text is longer than the specified length, it will be truncated at
+ * that length.
+ *
+ * If the text is empty or the 1st char is unprintable, the function will
+ * insert replacement 'invalid' text.
+ *****************************************************************************/
+
+void
+Reporter::validateText ( char * text, const int length )
+{
+ int len = (int) strlen ( text );
+ if ( len > length )
+ {
+ len = length;
+ }
+
+ // check for empty message or unprintable 1st char
+ if ( len && isprint ( text [ 0 ] ) )
+ {
+ // check message for unprintable characters
+ for (int i=1;i<len;i++)
+ {
+ if (text [ i ] != '\t')
+ {
+ if ( ! ( isprint ( text [ i ] ) ) )
+ {
+ break;
+ }
+ }
+ }
+
+ text [ i ] = '\0';
+ }
+ else
+ {
+ (void) strcpy ( text, "####" );
+ }
+}
+
+/*****************************************************************************
+ * Generate the prefix information to prepend to a 'write' message.
+ *
+ * NOTE: No checks are done to ensure prefix info is not too small for
+ * allocated string. If more information is prepended in the future,
+ * this will have to be implemented.
+ *****************************************************************************/
+
+void
+Reporter::addHeaderInfo ( char * prefixInfo )
+{
+ time_t curTime;
+
+ // create the time string
+ (void) time ( &curTime );
+ (void) strftime ( buffer,
+ sizeof ( buffer ),
+ "%a %b %d %Y %H:%M:%S",
+ localtime ( &curTime ) );
+
+ // append the program name
+ (void) sprintf ( prefixInfo,
+ "%s [%s] ",
+ buffer,
+ progname );
+}
+
+/*****************************************************************************
+ * Generate the prefix information to prepend to the message.
+ * If msg type is RPT_ERROR, info is generated regardless of prefix setting.
+ *
+ * NOTE: No checks are done to ensure prefix info is not too small for
+ * allocated string. If more information is prepended in the future,
+ * this will have to be implemented.
+ *****************************************************************************/
+
+void
+Reporter::addLogInfo ( char * prefixInfo, const char msgType )
+{
+ int bytesUsed = 0;
+ time_t curTime;
+ *( prefixInfo ) = '\0';
+
+ if ( prefix == RPT_MSG_ONLY)
+ {
+ return;
+ }
+
+#ifdef RPT_DEBUG_PROG
+ // fill prefix string to check for memory leaks
+ for (int i=1;i<RPT_MAX_MSG_LEN;i++)
+ {
+ *( prefixInfo + i ) = CPO_GARBAGE_CHAR;
+ }
+#endif
+
+ if ( ( prefix & RPT_MSG_TYPE ) )
+ {
+ *( prefixInfo ) = msgType;
+ *( prefixInfo + 1 ) = ' ';
+ *( prefixInfo + 2 ) = '\0';
+
+ bytesUsed += 2;
+ }
+
+ if ( ( prefix & RPT_APPNAME ) )
+ {
+ (void) sprintf ( prefixInfo + bytesUsed, "%s ", progname );
+ bytesUsed += (int) strlen ( progname ) + 1;
+ }
+
+ if ( ( prefix & RPT_DATE ) )
+ {
+ const int sublen = 5;
+
+ // create the date string
+ (void) time ( &curTime );
+ (void) strftime ( buffer,
+ sizeof ( buffer ),
+ "%d/%m",
+ localtime ( &curTime ) );
+
+ (void) sprintf ( prefixInfo + bytesUsed, "%s ", buffer );
+ bytesUsed += ( sublen + 1 );
+ }
+
+ if ( ( prefix & RPT_TIME ) )
+ {
+ const int sublen = 8;
+
+ // create the time string
+ (void) time ( &curTime );
+ (void) strftime ( buffer,
+ sizeof ( buffer ),
+ "%H:%M:%S",
+ localtime ( &curTime ) );
+
+ (void) sprintf ( prefixInfo + bytesUsed, "%s ", buffer );
+ bytesUsed += ( sublen + 1 );
+ }
+
+ // null terminate to be sure
+ *( prefixInfo + bytesUsed ) = '\0';
+}
+
+/*****************************************************************************
+ * Send text to appropriate stream(s).
+ *****************************************************************************/
+
+void
+Reporter::writeToStream ( const char * str )
+{
+#ifdef RPT_DEBUG_PROG
+ (void) fprintf ( stdout, "output [%s]\n", str );
+ (void) fflush ( stdout );
+#endif
+
+ // write output string to file
+ if ( state & RPT_FILE )
+ {
+ unsigned long lBytesWritten;
+
+ // need to seek to end of file in case other handles have written in the meantime
+ SetFilePointer(hFile, 0, NULL, FILE_END);
+
+ WriteFile(hFile, str, strlen(str), &lBytesWritten, NULL);
+ WriteFile(hFile, "\r\n", 2, &lBytesWritten, NULL);
+
+ // in case other processes are using this file to log
+ FlushFileBuffers(hFile);
+ }
+
+ // write output string to standard output
+ if ( state & RPT_STDOUT )
+ {
+ (void) fprintf ( stdout, "%s\n", str );
+ (void) fflush ( stdout );
+ }
+
+ // write output string to standard error
+ if ( state & RPT_STDERR )
+ {
+ (void) fprintf ( stderr, "%s\n", str );
+ (void) fflush ( stderr );
+ }
+}
+
+/*****************************************************************************
+ * Close the output file stream.
+ *****************************************************************************/
+
+void
+Reporter::closeFile ( void )
+{
+ CloseHandle(hFile);
+
+#ifdef RPT_DEBUG_PROG
+ (void) fprintf ( stdout, "file [%s] closed\n", filename );
+ (void) fflush ( stdout );
+#endif
+}
+
+/***************************************************************************
+ * Open the message file, then read in contents, processing a line at a
+ * time, putting the current line into global buffer string.
+ ***************************************************************************/
+
+void
+Reporter::readMessageFile ( const char * file )
+{
+ FILE * finptr;
+
+ // open initialisation file
+ if ( ( finptr = fopen ( file, "r" ) ) == NULL )
+ {
+ return;
+ }
+
+ // read each line
+ while ( ( fgets ( buffer, RPT_MAX_LINE_LEN, finptr ) ) != NULL )
+ {
+ if ( *( buffer ) != '\n' && *( buffer ) != '#' )
+ {
+ addMessage ( );
+ }
+ }
+
+ (void) fclose ( finptr );
+}
+
+/***************************************************************************
+ * Split the line of text into code and message and allocate memory in
+ * list and store it.
+ ***************************************************************************/
+
+void
+Reporter::addMessage ( void )
+{
+ char *pCode;
+ char *pText;
+ int code;
+
+ // extract the code and text
+ pCode = strtok ( buffer, ":" );
+ pText = strtok ( NULL, "\n" );
+
+ // check for legitimate values
+ if ( !pCode || !pText )
+ {
+ return;
+ }
+
+ code = atoi ( pCode );
+ if ( code > RPT_MAX_LIST_ENTRIES || messageList [ code ] )
+ {
+ return;
+ }
+
+ // jump any spaces in front of text
+ while ( *( pText ) == ' ' || *( pText ) == '\t' )
+ {
+ pText++;
+ }
+
+ // copy string
+ // messageList [ code ] = new char ( strlen ( pText ) + 1 );
+ messageList [ code ] =
+ (char *) malloc ( sizeof ( char ) * ( strlen ( pText ) + 1 ) );
+
+ (void) strcpy ( messageList [ code ], pText );
+
+#ifdef RPT_DEBUG_PROG
+// (void) fprintf ( stdout, "code [%s] text [%s] entry [%s] len %d\n",
+// pCode, pText, messageList [ code ], strlen ( pText ) );
+// (void) fflush ( stdout );
+#endif
+
+ // let object know there is at least one message entry
+ fileRead = 1;
+}
+
+/****************************************************************************/
+