src/common/eventlog.c

/*
 * Copyright (C) 1999  Rob Crittenden (rcrit@greyoak.com)
 * Copyright (C) 1999,2000  Ross Combs (rocombs@cs.nmsu.edu)
 *
 * 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 "common/setup_before.h"
#include <stdio.h>
#ifdef HAVE_STDDEF_H
# include <stddef.h>
#else
# ifndef NULL
#  define NULL ((void *)0)
# endif
#endif
#include <errno.h>
#include "compat/strerror.h"
#ifdef HAVE_STRING_H
# include <string.h>
#else
# ifdef HAVE_STRINGS_H
#  include <strings.h>
# endif
#endif
#include "compat/strcasecmp.h"
#include "compat/vargs.h"
#ifdef TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
#else
# ifdef HAVE_SYS_TIME_H
#  include <sys/time.h>
# else
#  include <time.h>
# endif
#endif
#include "compat/strftime.h"
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#include "common/eventlog.h"
#include "common/hexdump.h"
#include "common/setup_after.h"

#ifdef WIN32_GUI
# include "win32/winmain.h"
#endif

static FILE *           eventstrm=NULL;
static t_eventlog_level currlevel=eventlog_level_debug|
                                  eventlog_level_info|
                                  eventlog_level_warn|
                                  eventlog_level_error|
                                  eventlog_level_fatal;
/* FIXME: maybe this should be default for win32 */
static int eventlog_debugmode=0;

extern void eventlog_set_debugmode(int debugmode)
{
    eventlog_debugmode = debugmode;
}

extern void eventlog_set(FILE * fp)
{
    eventstrm = fp;
}

extern FILE * eventlog_get(void)
{
  return eventstrm;
}

extern int eventlog_close(void)
{
   fclose(eventstrm);
   return 0;
}

extern int eventlog_open(char const * filename)
{
    FILE * temp;
    
    if (!filename)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL filename");
        return -1;
    }
    
    if (!(temp = fopen(filename,"a")))
    {
        eventlog(eventlog_level_error,__FUNCTION__,"could not open file \"%s\" for appending (fopen: %s)",filename,pstrerror(errno));
        return -1;
    }
    
    if (eventstrm && eventstrm!=stderr) /* close old one */
        if (fclose(eventstrm)<0)
        {
            eventstrm = temp;
            eventlog(eventlog_level_error,__FUNCTION__,"could not close previous logfile after writing (fclose: %s)",pstrerror(errno));
            return 0;
        }
    eventstrm = temp;
    
    return 0;
}


extern void eventlog_clear_level(void)
{
    currlevel = eventlog_level_none;
}


extern int eventlog_add_level(char const * levelname)
{
    if (!levelname)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL levelname");
        return -1;
    }
    
    if (strcasecmp(levelname,"trace")==0)
    {
        currlevel |= eventlog_level_trace;
        return 0;
    }
    if (strcasecmp(levelname,"debug")==0)
    {
        currlevel |= eventlog_level_debug;
        return 0;
    }
    if (strcasecmp(levelname,"info")==0)
    {
        currlevel |= eventlog_level_info;
        return 0;
    }
    if (strcasecmp(levelname,"warn")==0)
    {
        currlevel |= eventlog_level_warn;
        return 0;
    }
    if (strcasecmp(levelname,"error")==0)
    {
        currlevel |= eventlog_level_error;
        return 0;
    }
    if (strcasecmp(levelname,"fatal")==0)
    {
        currlevel |= eventlog_level_fatal;
        return 0;
    }
    
    eventlog(eventlog_level_error,__FUNCTION__,"got bad levelname \"%s\"",levelname);
    return -1;
}


extern int eventlog_del_level(char const * levelname)
{
    if (!levelname)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL levelname");
        return -1;
    }
    
    if (strcasecmp(levelname,"trace")==0)
    {
        currlevel &= ~eventlog_level_trace;
        return 0;
    }
    if (strcasecmp(levelname,"debug")==0)
    {
        currlevel &= ~eventlog_level_debug;
        return 0;
    }
    if (strcasecmp(levelname,"info")==0)
    {
        currlevel &= ~eventlog_level_info;
        return 0;
    }
    if (strcasecmp(levelname,"warn")==0)
    {
        currlevel &= ~eventlog_level_warn;
        return 0;
    }
    if (strcasecmp(levelname,"error")==0)
    {
        currlevel &= ~eventlog_level_error;
        return 0;
    }
    if (strcasecmp(levelname,"fatal")==0)
    {
        currlevel &= ~eventlog_level_fatal;
        return 0;
    }
    
    
    eventlog(eventlog_level_error,__FUNCTION__,"got bad levelname \"%s\"",levelname);
    return -1;
}

extern char const * eventlog_get_levelname_str(t_eventlog_level level)
{
  switch (level)
  {
  case eventlog_level_trace:
    return "trace";
  case eventlog_level_debug:
    return "debug";
  case eventlog_level_info:
    return "info ";
  case eventlog_level_warn:
    return "warn ";
  case eventlog_level_error:
    return "error";
  case eventlog_level_fatal:
    return "fatal";
  default:
    return "unknown";
  } 
}

extern void eventlog_hexdump_data(void const * data, unsigned int len)
{
    unsigned int i;
    char dst[100];
    unsigned char * datac;

    if (!data) {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL data");
        return;
    }

    for (i = 0, datac = (char*)data; i < len; i += 16, datac += 16)
    {
        hexdump_string(datac, (len - i < 16) ? (len - i) : 16, dst, i);
        fprintf(eventstrm,"%s\n",dst);
#ifdef WIN32_GUI
        gui_lprintf(eventlog_level_info,"%s\n",dst);
#endif
       if (eventlog_debugmode)
       {
         printf("%s\n",dst);
       }

    }
    if (eventlog_debugmode) fflush(stdout);
    fflush(eventstrm);
}

#ifdef DEBUGMODSTRINGS
extern void eventlog_real(t_eventlog_level level, char const * module, char const * fmt, ...)
#else
extern void eventlog(t_eventlog_level level, char const * module, char const * fmt, ...)
#endif
{
    va_list     args;
    char        time_string[EVENT_TIME_MAXLEN];
    struct tm * tmnow;
    time_t      now;
    
    if (!(level&currlevel))
        return;
    if (!eventstrm)
        return;
    
    /* get the time before parsing args */
    time(&now);
    if (!(tmnow = localtime(&now)))
        strcpy(time_string,"?");
    else
        strftime(time_string,EVENT_TIME_MAXLEN,EVENT_TIME_FORMAT,tmnow);
    
    if (!module)
    {
        fprintf(eventstrm,"%s [error] eventlog: got NULL module\n",time_string);
#ifdef WIN32_GUI
        gui_lprintf(eventlog_level_error,"%s [error] eventlog: got NULL module\n",time_string);
#endif
        fflush(eventstrm);
        return;
    }

    if (!fmt)
    {
        fprintf(eventstrm,"%s [error] eventlog: got NULL fmt\n",time_string);
#ifdef WIN32_GUI
        gui_lprintf(eventlog_level_error,"%s [error] eventlog: got NULL fmt\n",time_string);
#endif
        fflush(eventstrm);
        return;
    }
    
    fprintf(eventstrm,"%s [%s] %s: ",time_string,eventlog_get_levelname_str(level),module);
#ifdef WIN32_GUI
    gui_lprintf(level,"%s [%s] %s: ",time_string,eventlog_get_levelname_str(level),module);
#endif

    VA_START(args,fmt);

#ifdef HAVE_VPRINTF
    vfprintf(eventstrm,fmt,args);
#ifdef WIN32_GUI
    gui_lvprintf(level,fmt,args);
#endif
#else
# if HAVE__DOPRNT
    _doprnt(fmt,args,eventstrm);
# else
    fprintf(eventstrm,"sorry, vfprintf() and _doprnt() are not available on this system");
# endif
#endif
    va_end(args);
    fprintf(eventstrm,"\n");
#ifdef WIN32_GUI
    gui_lprintf(level,"\n");
#endif

    if (eventlog_debugmode) {
        printf("%s [%s] %s: ",time_string,eventlog_get_levelname_str(level),module);
        va_start(args,fmt);
#ifdef HAVE_VPRINTF
        vprintf(fmt,args);
#else
# if HAVE__DOPRNT
        _doprnt(fmt,args,stdout);
# else
        printf("sorry, vfprintf() and _doprnt() are not available on this system");
# endif
#endif
        va_end(args);
        printf("\n");
        fflush(stdout);
    }
    fflush(eventstrm);
}


extern void eventlog_step(char const * filename, t_eventlog_level level, char const * module, char const * fmt, ...)
{
    va_list args;
    char        time_string[EVENT_TIME_MAXLEN];
    struct tm * tmnow;
    time_t      now;
    FILE *      fp;
    
    if (!(level&currlevel))
        return;
    if (!eventstrm)
        return;
    
    if (!(fp = fopen(filename, "a")))
        return;
    
    /* get the time before parsing args */
    time(&now);
    if (!(tmnow = localtime(&now)))
        strcpy(time_string,"?");
    else
        strftime(time_string,EVENT_TIME_MAXLEN,EVENT_TIME_FORMAT,tmnow);
    
    if (!module)
    {
        fprintf(fp,"%s [error] eventlog_step: got NULL module\n",time_string);
        fclose(fp);
        return;
    }
    if (!fmt)
    {
        fprintf(fp,"%s [error] eventlog_step: got NULL fmt\n",time_string);
        fclose(fp);
        return;
    }
    
    fprintf(fp,"%s [%s] %s: ",time_string,eventlog_get_levelname_str(level),module);
    va_start(args,fmt);
#ifdef HAVE_VPRINTF
    vfprintf(fp,fmt,args);
#else
# if HAVE__DOPRNT
    _doprnt(fmt,args,fp);
# else
    fprintf(fp,"sorry, vfprintf() and _doprnt() are not available on this system");
# endif
#endif
    va_end(args);
    fprintf(fp,"\n");
    fclose(fp);
}
1	sysadm	1.1	/*
2			* Copyright (C) 1999 Rob Crittenden (rcrit@greyoak.com)
3			* Copyright (C) 1999,2000 Ross Combs (rocombs@cs.nmsu.edu)
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18			*/
19			#include "common/setup_before.h"
20			#include <stdio.h>
21			#ifdef HAVE_STDDEF_H
22			# include <stddef.h>
23			#else
24			# ifndef NULL
25			# define NULL ((void *)0)
26			# endif
27			#endif
28			#include <errno.h>
29			#include "compat/strerror.h"
30			#ifdef HAVE_STRING_H
31			# include <string.h>
32			#else
33			# ifdef HAVE_STRINGS_H
34			# include <strings.h>
35			# endif
36			#endif
37			#include "compat/strcasecmp.h"
38			#include "compat/vargs.h"
39			#ifdef TIME_WITH_SYS_TIME
40			# include <sys/time.h>
41			# include <time.h>
42			#else
43			# ifdef HAVE_SYS_TIME_H
44			# include <sys/time.h>
45			# else
46			# include <time.h>
47			# endif
48			#endif
49			#include "compat/strftime.h"
50			#ifdef HAVE_UNISTD_H
51			# include <unistd.h>
52			#endif
53			#include "common/eventlog.h"
54			#include "common/hexdump.h"
55			#include "common/setup_after.h"
56
57			#ifdef WIN32_GUI
58			# include "win32/winmain.h"
59			#endif
60
61			static FILE * eventstrm=NULL;
62			static t_eventlog_level currlevel=eventlog_level_debug\|
63			eventlog_level_info\|
64			eventlog_level_warn\|
65			eventlog_level_error\|
66			eventlog_level_fatal;
67			/* FIXME: maybe this should be default for win32 */
68			static int eventlog_debugmode=0;
69
70			extern void eventlog_set_debugmode(int debugmode)
71			{
72			eventlog_debugmode = debugmode;
73			}
74
75			extern void eventlog_set(FILE * fp)
76			{
77			eventstrm = fp;
78			}
79
80			extern FILE * eventlog_get(void)
81			{
82			return eventstrm;
83			}
84
85			extern int eventlog_close(void)
86			{
87			fclose(eventstrm);
88			return 0;
89			}
90
91			extern int eventlog_open(char const * filename)
92			{
93			FILE * temp;
94
95			if (!filename)
96			{
97			eventlog(eventlog_level_error,__FUNCTION__,"got NULL filename");
98			return -1;
99			}
100
101			if (!(temp = fopen(filename,"a")))
102			{
103			eventlog(eventlog_level_error,__FUNCTION__,"could not open file \"%s\" for appending (fopen: %s)",filename,pstrerror(errno));
104			return -1;
105			}
106
107			if (eventstrm && eventstrm!=stderr) /* close old one */
108			if (fclose(eventstrm)<0)
109			{
110			eventstrm = temp;
111			eventlog(eventlog_level_error,__FUNCTION__,"could not close previous logfile after writing (fclose: %s)",pstrerror(errno));
112			return 0;
113			}
114			eventstrm = temp;
115
116			return 0;
117			}
118
119
120			extern void eventlog_clear_level(void)
121			{
122			currlevel = eventlog_level_none;
123			}
124
125
126			extern int eventlog_add_level(char const * levelname)
127			{
128			if (!levelname)
129			{
130			eventlog(eventlog_level_error,__FUNCTION__,"got NULL levelname");
131			return -1;
132			}
133
134			if (strcasecmp(levelname,"trace")==0)
135			{
136			currlevel \|= eventlog_level_trace;
137			return 0;
138			}
139			if (strcasecmp(levelname,"debug")==0)
140			{
141			currlevel \|= eventlog_level_debug;
142			return 0;
143			}
144			if (strcasecmp(levelname,"info")==0)
145			{
146			currlevel \|= eventlog_level_info;
147			return 0;
148			}
149			if (strcasecmp(levelname,"warn")==0)
150			{
151			currlevel \|= eventlog_level_warn;
152			return 0;
153			}
154			if (strcasecmp(levelname,"error")==0)
155			{
156			currlevel \|= eventlog_level_error;
157			return 0;
158			}
159			if (strcasecmp(levelname,"fatal")==0)
160			{
161			currlevel \|= eventlog_level_fatal;
162			return 0;
163			}
164
165			eventlog(eventlog_level_error,__FUNCTION__,"got bad levelname \"%s\"",levelname);
166			return -1;
167			}
168
169
170			extern int eventlog_del_level(char const * levelname)
171			{
172			if (!levelname)
173			{
174			eventlog(eventlog_level_error,__FUNCTION__,"got NULL levelname");
175			return -1;
176			}
177
178			if (strcasecmp(levelname,"trace")==0)
179			{
180			currlevel &= ~eventlog_level_trace;
181			return 0;
182			}
183			if (strcasecmp(levelname,"debug")==0)
184			{
185			currlevel &= ~eventlog_level_debug;
186			return 0;
187			}
188			if (strcasecmp(levelname,"info")==0)
189			{
190			currlevel &= ~eventlog_level_info;
191			return 0;
192			}
193			if (strcasecmp(levelname,"warn")==0)
194			{
195			currlevel &= ~eventlog_level_warn;
196			return 0;
197			}
198			if (strcasecmp(levelname,"error")==0)
199			{
200			currlevel &= ~eventlog_level_error;
201			return 0;
202			}
203			if (strcasecmp(levelname,"fatal")==0)
204			{
205			currlevel &= ~eventlog_level_fatal;
206			return 0;
207			}
208
209
210			eventlog(eventlog_level_error,__FUNCTION__,"got bad levelname \"%s\"",levelname);
211			return -1;
212			}
213
214			extern char const * eventlog_get_levelname_str(t_eventlog_level level)
215			{
216			switch (level)
217			{
218			case eventlog_level_trace:
219			return "trace";
220			case eventlog_level_debug:
221			return "debug";
222			case eventlog_level_info:
223			return "info ";
224			case eventlog_level_warn:
225			return "warn ";
226			case eventlog_level_error:
227			return "error";
228			case eventlog_level_fatal:
229			return "fatal";
230			default:
231			return "unknown";
232			}
233			}
234
235			extern void eventlog_hexdump_data(void const * data, unsigned int len)
236			{
237			unsigned int i;
238			char dst[100];
239			unsigned char * datac;
240
241			if (!data) {
242			eventlog(eventlog_level_error, __FUNCTION__, "got NULL data");
243			return;
244			}
245
246			for (i = 0, datac = (char*)data; i < len; i += 16, datac += 16)
247			{
248			hexdump_string(datac, (len - i < 16) ? (len - i) : 16, dst, i);
249			fprintf(eventstrm,"%s\n",dst);
250			#ifdef WIN32_GUI
251			gui_lprintf(eventlog_level_info,"%s\n",dst);
252			#endif
253			if (eventlog_debugmode)
254			{
255			printf("%s\n",dst);
256			}
257
258			}
259			if (eventlog_debugmode) fflush(stdout);
260			fflush(eventstrm);
261			}
262
263			#ifdef DEBUGMODSTRINGS
264			extern void eventlog_real(t_eventlog_level level, char const * module, char const * fmt, ...)
265			#else
266			extern void eventlog(t_eventlog_level level, char const * module, char const * fmt, ...)
267			#endif
268			{
269			va_list args;
270			char time_string[EVENT_TIME_MAXLEN];
271			struct tm * tmnow;
272			time_t now;
273
274			if (!(level&currlevel))
275			return;
276			if (!eventstrm)
277			return;
278
279			/* get the time before parsing args */
280			time(&now);
281			if (!(tmnow = localtime(&now)))
282			strcpy(time_string,"?");
283			else
284			strftime(time_string,EVENT_TIME_MAXLEN,EVENT_TIME_FORMAT,tmnow);
285
286			if (!module)
287			{
288			fprintf(eventstrm,"%s [error] eventlog: got NULL module\n",time_string);
289			#ifdef WIN32_GUI
290			gui_lprintf(eventlog_level_error,"%s [error] eventlog: got NULL module\n",time_string);
291			#endif
292			fflush(eventstrm);
293			return;
294			}
295
296			if (!fmt)
297			{
298			fprintf(eventstrm,"%s [error] eventlog: got NULL fmt\n",time_string);
299			#ifdef WIN32_GUI
300			gui_lprintf(eventlog_level_error,"%s [error] eventlog: got NULL fmt\n",time_string);
301			#endif
302			fflush(eventstrm);
303			return;
304			}
305
306			fprintf(eventstrm,"%s [%s] %s: ",time_string,eventlog_get_levelname_str(level),module);
307			#ifdef WIN32_GUI
308			gui_lprintf(level,"%s [%s] %s: ",time_string,eventlog_get_levelname_str(level),module);
309			#endif
310
311			VA_START(args,fmt);
312
313			#ifdef HAVE_VPRINTF
314			vfprintf(eventstrm,fmt,args);
315			#ifdef WIN32_GUI
316			gui_lvprintf(level,fmt,args);
317			#endif
318			#else
319			# if HAVE__DOPRNT
320			_doprnt(fmt,args,eventstrm);
321			# else
322			fprintf(eventstrm,"sorry, vfprintf() and _doprnt() are not available on this system");
323			# endif
324			#endif
325			va_end(args);
326			fprintf(eventstrm,"\n");
327			#ifdef WIN32_GUI
328			gui_lprintf(level,"\n");
329			#endif
330
331			if (eventlog_debugmode) {
332			printf("%s [%s] %s: ",time_string,eventlog_get_levelname_str(level),module);
333			va_start(args,fmt);
334			#ifdef HAVE_VPRINTF
335			vprintf(fmt,args);
336			#else
337			# if HAVE__DOPRNT
338			_doprnt(fmt,args,stdout);
339			# else
340			printf("sorry, vfprintf() and _doprnt() are not available on this system");
341			# endif
342			#endif
343			va_end(args);
344			printf("\n");
345			fflush(stdout);
346			}
347			fflush(eventstrm);
348			}
349
350
351			extern void eventlog_step(char const * filename, t_eventlog_level level, char const * module, char const * fmt, ...)
352			{
353			va_list args;
354			char time_string[EVENT_TIME_MAXLEN];
355			struct tm * tmnow;
356			time_t now;
357			FILE * fp;
358
359			if (!(level&currlevel))
360			return;
361			if (!eventstrm)
362			return;
363
364			if (!(fp = fopen(filename, "a")))
365			return;
366
367			/* get the time before parsing args */
368			time(&now);
369			if (!(tmnow = localtime(&now)))
370			strcpy(time_string,"?");
371			else
372			strftime(time_string,EVENT_TIME_MAXLEN,EVENT_TIME_FORMAT,tmnow);
373
374			if (!module)
375			{
376			fprintf(fp,"%s [error] eventlog_step: got NULL module\n",time_string);
377			fclose(fp);
378			return;
379			}
380			if (!fmt)
381			{
382			fprintf(fp,"%s [error] eventlog_step: got NULL fmt\n",time_string);
383			fclose(fp);
384			return;
385			}
386
387			fprintf(fp,"%s [%s] %s: ",time_string,eventlog_get_levelname_str(level),module);
388			va_start(args,fmt);
389			#ifdef HAVE_VPRINTF
390			vfprintf(fp,fmt,args);
391			#else
392			# if HAVE__DOPRNT
393			_doprnt(fmt,args,fp);
394			# else
395			fprintf(fp,"sorry, vfprintf() and _doprnt() are not available on this system");
396			# endif
397			#endif
398			va_end(args);
399			fprintf(fp,"\n");
400			fclose(fp);
401			}
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1