www.pudn.com > rDUNclientBeta1.zip > Debug.cpp

//Debug.cpp - Generic debug information output engine 
//Copyright (C) Robert Merrison 2001  
 
//This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License  
//as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. 
//This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied  
//warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. 
//You should have received a copy of the GNU General Public License along with this program; if not, write to the  
//Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
 
 
#include  
 
#include "Debug.h" 
#include "timer.h" 
 
/*Constructor: Initialises a few things*/ 
debug_engine::debug_engine( ) 
{ 
	is_inited	= false; //Not initialized yet 
	write_file	= false; //Don't output to a file by default 
	level		= DBLEVEL_MED; //Set default debug level to medium 
	debug_file	= NULL;	 
	bytes_written	= 0; 
	file_size_limit	= 0; //Turn file size limit off by default 
	timer		= NULL; 
	log_time	= false; 
 
	memset( filename, 0, sizeof( filename ) ); 
} 
 
/*Destructor: Do nothing*/ 
debug_engine::~debug_engine( ) 
{ 
} 
 
/*Initialization: Init stuff*/ 
bool debug_engine::init( short debug_level, char *debug_filename, time_engine* timer_engine ) 
{	 
		//Make sure the debug level is valid 
	if( debug_level != DBLEVEL_LOW && debug_level != DBLEVEL_MED && debug_level != DBLEVEL_HIGH){ 
		return false; 
	}	 
		//Check if a filename is specfied and if so, activate file writing 
	if( debug_filename != NULL ){ 
		write_file	= true; 
	} 
	else{ 
		write_file = false; 
	} 
	timer	= timer_engine; 
		//Enable time outputting if a timer engine is specified 
	if( timer_engine != NULL ){ 
		log_time	= true; 
	} 
	else{ 
		log_time	= false; 
	} 
		//If file writing is activated, open the file for writing 
	if( write_file ){ 
		if( !open_debug_file( debug_filename ) ){ 
			write_file = false;	//Disable file writing if there was an error 
		} 
	} 
		//Set the debug level 
	level		= debug_level; 
		//Initialization is complete 
	is_inited	= true; 
	log_message( MSG_NOTICE, "Debug engine started"); 
 
	return is_inited; 
} 
 
/*Open debug file: Opens the debug file (if used) for writing*/ 
bool debug_engine::open_debug_file( char *debug_filename ) 
{	 
		//Open the file and check for errors 
	debug_file = fopen( debug_filename, "w" ); 
	if( !debug_file ){ 
		return false; 
	} 
    bytes_written	= 0; 
	strcpy( filename, debug_filename ); 
	return true; 
} 
 
/*Kill: Clears everything up when we are done*/ 
bool debug_engine::kill( ) 
{	 
	if( is_inited == false ){ 
		return true; 
	} 
	log_message( MSG_NOTICE, "Debug engine killed" ); 
 
		//Close the debug logging file if it exists 
	if( debug_file ){ 
		fclose( debug_file ); 
	} 
		//No longer initialized 
	is_inited	= false; 
 
 
	return true; 
} 
 
/*Log Message: Logs an error/status message to the screen/log file*/ 
bool debug_engine::log_message( short msg_type, char* message, ... ) 
{ 
		//Check the logging engine has been initialized 
	if( !is_inited ) { 
		return false; 
	} 
 
	if( timer != NULL ){ 
		log_time	= true; 
	} 
	else{ 
		log_time	= false; 
	}	 
		//Now read in any paramters that may have been passed 
	va_list	parameters; 
	char	debug_string[256]; 
	memset( debug_string, 0, sizeof( debug_string ) ); 
	va_start( parameters, message ); 
	vsprintf( debug_string, message, parameters ); 
	va_end( parameters ); 
		//Add the time/date information if needed 
	char	string_to_output[1024]; 
	memset	(string_to_output, 0, sizeof( string_to_output )); 
	if( log_time == true ){ 
		tm	time	= timer->get_current_time(); 
		sprintf( string_to_output, "[%i/%i/%i %i:%i] %s", time.tm_mday, time.tm_mon+1, time.tm_year+1900,  
			time.tm_hour, time.tm_min+1, debug_string ); 
	} 
	else 
	{ 
		sprintf( string_to_output, "%s", debug_string ); 
	} 
	bool output_string	= must_log( msg_type ); 
 
	if( output_string ){ 
		printf( "%s\n", string_to_output ); 
		if( write_file ){	 
			bytes_written += (int)(strlen( string_to_output) + 1);	//Just make sure we haven't gone over the file size 
			check_file_size();	 
			fprintf( debug_file, "%s\n", string_to_output ); 
			fflush( debug_file ); 
		} 
	} 
	 
	return true; 
} 
 
/*Check Logging: Checks the logging level and type of message and detemines if it should be logged*/ 
bool debug_engine::must_log( short msg_type ) 
{ 
		//Always log critical errors and notices 
	if( msg_type == MSG_NOTICE || msg_type == MSG_CRITICAL ){	  
		return true; 
	} 
 
		//Check the message type against the logging level and return accordingly 
	switch( msg_type ){ 
		case MSG_STATUS:{ 
			if( level == DBLEVEL_HIGH ){ 
				return true; 
			} 
			else{ 
				return false; 
			} 
		} 
		case MSG_ERROR:{ 
			if( level == DBLEVEL_MED || level == DBLEVEL_HIGH ){ 
				return true; 
			} 
			else{ 
				return false; 
			} 
		} 
	} 
 
	return false; 
} 
 
/*Check file size: Checks that logging hasn't gone over the allowable file size, and if it has,  
	restarts the log file*/ 
void debug_engine::check_file_size() 
{ 
		//Check if the filesize limit is enabled or not 
	if( file_size_limit == 0 ){ 
		return; 
	} 
		//Check if we have hit the limit, and if so close the file and then re-open it to clear it 
	if( bytes_written > file_size_limit ){ 
		if( debug_file ){ 
			printf( "Remaking log file\n" ); 
			fclose( debug_file ); 
			open_debug_file( filename ); 
		} 
	} 
 
	return; 
}