/////////////////////////////////////////////////////////////////////////// // // Copyright (c) 2000-2003 Intel Corporation // All rights reserved. // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: // // * Redistributions of source code must retain the above copyright notice, // this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above copyright notice, // this list of conditions and the following disclaimer in the documentation // and/or other materials provided with the distribution. // * Neither name of Intel Corporation nor the names of its contributors // may be used to endorse or promote products derived from this software // without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL OR // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY // OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // /////////////////////////////////////////////////////////////////////////// #include "config.h" #include "upnpdebug.h" #include #include #include "ithread.h" #include "upnp.h" #include #include //Mutex to synchronize all the log file opeartions in the debug mode static ithread_mutex_t GlobalDebugMutex; // Global log level static Upnp_LogLevel g_log_level = UPNP_DEFAULT_LOG_LEVEL; //File handle for the error log file static FILE *ErrFileHnd = NULL; //File handle for the information log file static FILE *InfoFileHnd = NULL; //Name of the error file static const char *errFileName = "IUpnpErrFile.txt"; //Name of the info file static const char *infoFileName = "IUpnpInfoFile.txt"; /*************************************************************************** * Function : UpnpSetLogFileNames * * Parameters: * IN const char* ErrFileName: name of the error file * IN const char *InfoFileName: name of the information file * IN int size: Size of the buffer * IN int starLength: This parameter provides the width of the banner * * Description: * This functions takes the buffer and writes the buffer in the file as * per the requested banner * Returns: void ***************************************************************************/ void UpnpSetLogFileNames ( IN const char *ErrFileName, IN const char *InfoFileName ) { if( ErrFileName ) { errFileName = ErrFileName; } if( InfoFileName ) { infoFileName = InfoFileName; } } /*************************************************************************** * Function : UpnpInitLog * * Parameters: void * * Description: * This functions initializes the log files * * Returns: int * -1 : If fails * UPNP_E_SUCCESS : if success ***************************************************************************/ int UpnpInitLog() { ithread_mutex_init( &GlobalDebugMutex, NULL ); if( DEBUG_TARGET == 1 ) { if( ( ErrFileHnd = fopen( errFileName, "a" ) ) == NULL ) return -1; if( ( InfoFileHnd = fopen( infoFileName, "a" ) ) == NULL ) return -1; } return UPNP_E_SUCCESS; } /*************************************************************************** * Function : UpnpSetLogLevel * * Parameters: Upnp_LogLevel log_level * * Description: * This functions set the log level (see {\tt Upnp_LogLevel} * Returns: void ***************************************************************************/ void UpnpSetLogLevel (Upnp_LogLevel log_level) { g_log_level = log_level; } /*************************************************************************** * Function : UpnpCloseLog * * Parameters: void * * Description: * This functions closes the log files * Returns: void ***************************************************************************/ void UpnpCloseLog() { if( DEBUG_TARGET == 1 ) { fflush( ErrFileHnd ); fflush( InfoFileHnd ); fclose( ErrFileHnd ); fclose( InfoFileHnd ); } ithread_mutex_destroy( &GlobalDebugMutex ); } /*************************************************************************** * Function : DebugAtThisLevel * * Parameters: * IN Upnp_LogLevel DLevel: The level of the debug logging. It will decide * whether debug statement will go to standard output, * or any of the log files. * IN Dbg_Module Module: debug will go in the name of this module * * Description: * This functions returns true if debug output should be done in this * module. * * Returns: int ***************************************************************************/ #ifdef DEBUG int DebugAtThisLevel( IN Upnp_LogLevel DLevel, IN Dbg_Module Module) { int ret = g_log_level >= DLevel; ret &= DEBUG_ALL || (Module == SSDP && DEBUG_SSDP ) || (Module == SOAP && DEBUG_SOAP ) || (Module == GENA && DEBUG_GENA ) || (Module == TPOOL && DEBUG_TPOOL) || (Module == MSERV && DEBUG_MSERV) || (Module == DOM && DEBUG_DOM ) || (Module == HTTP && DEBUG_HTTP ); return ret; } #endif /*************************************************************************** * Function : UpnpPrintf * * Parameters: * IN Upnp_LogLevel DLevel: The level of the debug logging. It will decide * whether debug statement will go to standard output, * or any of the log files. * IN Dbg_Module Module: debug will go in the name of this module * IN char *DbgFileName: Name of the file from where debug statement is * coming * IN int DbgLineNo : Line number of the file from where debug statement * is coming * IN char * FmtStr, ...: Variable number of arguments that will go * in the debug statement * * Description: * This functions prints the debug statement either on the startdard * output or log file along with the information from where this debug * statement is coming * Returns: void ***************************************************************************/ #ifdef DEBUG void UpnpPrintf( IN Upnp_LogLevel DLevel, IN Dbg_Module Module, IN const char *DbgFileName, IN int DbgLineNo, IN const char *FmtStr, ... ) { va_list ArgList; if (!DebugAtThisLevel(DLevel, Module)) { return; } ithread_mutex_lock(&GlobalDebugMutex); va_start(ArgList, FmtStr); if (!DEBUG_TARGET) { if( DbgFileName ) { UpnpDisplayFileAndLine(stdout, DbgFileName, DbgLineNo); } vfprintf(stdout, FmtStr, ArgList); fflush(stdout); } else if (DLevel == 0) { if (DbgFileName) { UpnpDisplayFileAndLine(ErrFileHnd, DbgFileName, DbgLineNo); } vfprintf(ErrFileHnd, FmtStr, ArgList); fflush(ErrFileHnd); } else { if (DbgFileName) { UpnpDisplayFileAndLine(InfoFileHnd, DbgFileName, DbgLineNo); } vfprintf(InfoFileHnd, FmtStr, ArgList); fflush(InfoFileHnd); } va_end(ArgList); ithread_mutex_unlock(&GlobalDebugMutex); } #endif /*************************************************************************** * Function : UpnpGetDebugFile * * Parameters: * IN Upnp_LogLevel DLevel: The level of the debug logging. It will decide * whether debug statement will go to standard output, * or any of the log files. * IN Dbg_Module Module: debug will go in the name of this module * * Description: * This function checks if the module is turned on for debug * and returns the file descriptor corresponding to the debug level * Returns: FILE * * NULL : if the module is turn off for debug * else returns the right file descriptor ***************************************************************************/ #ifdef DEBUG FILE *GetDebugFile( Upnp_LogLevel DLevel, Dbg_Module Module ) { FILE *ret; if (!DebugAtThisLevel(DLevel, Module)) { ret = NULL; } if (!DEBUG_TARGET) { ret = stdout; } else if (DLevel == 0) { ret = ErrFileHnd; } else { ret = InfoFileHnd; } return ret; } #endif /*************************************************************************** * Function : UpnpDisplayFileAndLine * * Parameters: * IN FILE *fd: File descriptor where line number and file name will be * written * IN char *DbgFileName: Name of the file * IN int DbgLineNo : Line number of the file * * Description: * This function writes the file name and file number from where * debug statement is coming to the log file * Returns: void ***************************************************************************/ #ifdef DEBUG void UpnpDisplayFileAndLine( IN FILE * fd, IN const char *DbgFileName, IN int DbgLineNo) { int starlength = 66; const char *lines[2]; char FileAndLine[500]; lines[0] = "DEBUG"; if (DbgFileName) { sprintf(FileAndLine, "FILE: %s, LINE: %d", DbgFileName, DbgLineNo); lines[1] = FileAndLine; } UpnpDisplayBanner(fd, lines, 2, starlength); fflush(fd); } #endif /*************************************************************************** * Function : UpnpDisplayBanner * * Parameters: * IN FILE *fd: file descriptor where the banner will be written * IN char **lines: The buffer that will be written * IN int size: Size of the buffer * IN int starLength: This parameter provides the width of the banner * * Description: * This functions takes the buffer and writes the buffer in the file as * per the requested banner * Returns: void ***************************************************************************/ #ifdef DEBUG void UpnpDisplayBanner( IN FILE * fd, IN const char **lines, IN size_t size, IN int starLength) { int leftMarginLength = starLength / 2 + 1; int rightMarginLength = starLength / 2 + 1; int i = 0; int LineSize = 0; int starLengthMinus2 = starLength - 2; char *leftMargin = ( char * )malloc( leftMarginLength ); char *rightMargin = ( char * )malloc( rightMarginLength ); char *stars = ( char * )malloc( starLength + 1 ); char *currentLine = ( char * )malloc( starLength + 1 ); const char *line = NULL; memset( stars, '*', starLength ); stars[starLength] = 0; memset( leftMargin, 0, leftMarginLength ); memset( rightMargin, 0, rightMarginLength ); fprintf( fd, "\n%s\n", stars ); for( i = 0; i < size; i++ ) { LineSize = strlen( lines[i] ); line = lines[i]; while( LineSize > starLengthMinus2 ) { memcpy( currentLine, line, starLengthMinus2 ); currentLine[starLengthMinus2] = 0; fprintf( fd, "*%s*\n", currentLine ); LineSize -= starLengthMinus2; line += starLengthMinus2; } leftMarginLength = (starLengthMinus2 - LineSize)/2; if( LineSize % 2 == 0 ) { rightMarginLength = leftMarginLength; } else { rightMarginLength = leftMarginLength + 1; } memset( leftMargin, ' ', leftMarginLength ); memset( rightMargin, ' ', rightMarginLength ); leftMargin[leftMarginLength] = 0; rightMargin[rightMarginLength] = 0; fprintf( fd, "*%s%s%s*\n", leftMargin, line, rightMargin ); } fprintf( fd, "%s\n\n", stars ); free( currentLine ); free( stars ); free( rightMargin ); free( leftMargin ); } #endif