1 /*

     2  * Hedgewars, a free turn based strategy game

     3  * Copyright (C) 2012 Simeon Maxein <smaxein@googlemail.com>

     4  *

     5  * This program is free software; you can redistribute it and/or

     6  * modify it under the terms of the GNU General Public License

     7  * as published by the Free Software Foundation; either version 2

     8  * of the License, or (at your option) any later version.

     9  *

    10  * This program is distributed in the hope that it will be useful,

    11  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    13  * GNU General Public License for more details.

    14  *

    15  * You should have received a copy of the GNU General Public License

    16  * along with this program; if not, write to the Free Software

    17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    18  */

    19 

    20 #include "logging.h"

    21 

    22 #include <time.h>

    23 #include <stdio.h>

    24 #include <stdarg.h>

    25 #include <stdlib.h>

    26 

    27 static int flib_loglevel = FLIB_LOGLEVEL_INFO;

    28 static FILE *flib_logfile = NULL;

    29 void (*flib_logCallback)(int level, const char *msg) = NULL;

    30 

    31 char* flib_format_ip(uint32_t numip) {

    32 	static char ip[16];

    33 	snprintf(ip, 16, "%u.%u.%u.%u", (unsigned)(numip>>24), (unsigned)((numip>>16)&0xff), (unsigned)((numip>>8)&0xff), (unsigned)(numip&0xff));

    34 	return ip;

    35 }

    36 

    37 static inline FILE *flib_log_getfile() {

    38 	if(flib_logfile==NULL) {

    39 		return stdout;

    40 	} else {

    41 		return flib_logfile;

    42 	}

    43 }

    44 

    45 static int log_time(char *buffer) {

    46     time_t timer;

    47     struct tm* tm_info;

    48 

    49     time(&timer);

    50     tm_info = localtime(&timer);

    51 

    52     return strftime(buffer, 25, "%Y-%m-%d %H:%M:%S", tm_info);

    53 }

    54 

    55 static char getPrefix(int level) {

    56 	switch(level) {

    57 	case FLIB_LOGLEVEL_ERROR: return 'E';

    58 	case FLIB_LOGLEVEL_WARNING: return 'W';

    59 	case FLIB_LOGLEVEL_INFO: return 'I';

    60 	case FLIB_LOGLEVEL_DEBUG: return 'D';

    61 	default: return '?';

    62 	}

    63 }

    64 

    65 static void _flib_vflog(const char *func, int level, const char *fmt, va_list args) {

    66 	if(level >= flib_loglevel) {

    67 		char logbuffer[1024];

    68 		logbuffer[0] = getPrefix(level);

    69 		logbuffer[1] = ' ';

    70 

    71 		int pos = 2;

    72 

    73 		int len = log_time(logbuffer+pos);

    74 		if(len>=0) {

    75 			pos += len;

    76 			if(pos>sizeof(logbuffer)-1) pos = sizeof(logbuffer)-1;

    77 		} else {

    78 			return;

    79 		}

    80 

    81 		len = snprintf(logbuffer+pos, sizeof(logbuffer)-pos, " [%-30s] ", func);

    82 		if(len>=0) {

    83 			pos += len;

    84 			if(pos>sizeof(logbuffer)-1) pos = sizeof(logbuffer)-1;

    85 		} else {

    86 			return;

    87 		}

    88 

    89 		len = vsnprintf(logbuffer+pos, sizeof(logbuffer)-pos, fmt, args);

    90 		if(len>=0) {

    91 			pos += len;

    92 			if(pos>sizeof(logbuffer)-1) pos = sizeof(logbuffer)-1;

    93 		} else {

    94 			return;

    95 		}

    96 

    97 		if(flib_logCallback != NULL) {

    98 			flib_logCallback(level, logbuffer);

    99 		} else {

   100 			FILE *logfile = flib_log_getfile();

   101 			fputs(logbuffer, logfile);

   102 			fputc('\n', logfile);

   103 			fflush(logfile);

   104 		}

   105 	}

   106 }

   107 

   108 void _flib_flog(const char *func, int level, const char *fmt, ...) {

   109 	va_list argp;

   110 	va_start(argp, fmt);

   111 	_flib_vflog(func, level, fmt, argp);

   112 	va_end(argp);

   113 }

   114 

   115 bool _flib_fassert(const char *func, int level, bool cond, const char *fmt, ...) {

   116 	if(!cond) {

   117 		va_list argp;

   118 		va_start(argp, fmt);

   119 		_flib_vflog(func, level, fmt, argp);

   120 		va_end(argp);

   121 	}

   122 	return !cond;

   123 }

   124 

   125 int flib_log_getLevel() {

   126 	return flib_loglevel;

   127 }

   128 

   129 void flib_log_setLevel(int level) {

   130 	flib_loglevel = level;

   131 }

   132 

   133 void flib_log_setFile(FILE *file) {

   134 	flib_logfile = file;

   135 	flib_logCallback = NULL;

   136 }

   137 

   138 bool flib_log_isActive(int level) {

   139 	return level >= flib_log_getLevel();

   140 }

   141 

   142 void flib_log_setCallback(void (*logCallback)(int level, const char *msg)) {

   143 	flib_logCallback = logCallback;

   144 	flib_logfile = NULL;

   145 }