/*****************************************************************
**
** @(#) log.c -- The ZKT error logging module
**
** Copyright (c) June 2008, Holger Zuleger HZnet. All rights reserved.
**
** This software is open source.
**
** 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 the name of Holger Zuleger HZnet 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 THE REGENTS 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 <stdio.h>
# include <string.h>
# include <stdlib.h>
# include <ctype.h>
# include <sys/types.h>
# include <sys/stat.h>
# include <sys/time.h>
# include <time.h>
# include <assert.h>
# include <errno.h>
# include <syslog.h>
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
# include "config_zkt.h"
# include "misc.h"
# include "debug.h"
#define extern
# include "log.h"
#undef extern
/*****************************************************************
** module internal vars & declarations
*****************************************************************/
static FILE *lg_fp;
static FILE *lg_fpsave;
static int lg_minfilelevel;
static int lg_syslogging;
static int lg_minsyslevel;
static long lg_errcnt;
static const char *lg_progname;
typedef struct {
lg_lvl_t level;
const char *str;
int syslog_level;
} lg_symtbl_t;
static lg_symtbl_t symtbl[] = {
{ LG_NONE, "none", -1 },
{ LG_DEBUG, "debug", LOG_DEBUG },
{ LG_INFO, "info", LOG_INFO },
{ LG_NOTICE, "notice", LOG_NOTICE },
{ LG_WARNING, "warning", LOG_WARNING },
{ LG_ERROR, "error", LOG_ERR },
{ LG_FATAL, "fatal", LOG_CRIT },
{ LG_NONE, "user", LOG_USER },
{ LG_NONE, "daemon", LOG_DAEMON },
{ LG_NONE, "local0", LOG_LOCAL0 },
{ LG_NONE, "local1", LOG_LOCAL1 },
{ LG_NONE, "local2", LOG_LOCAL2 },
{ LG_NONE, "local3", LOG_LOCAL3 },
{ LG_NONE, "local4", LOG_LOCAL4 },
{ LG_NONE, "local5", LOG_LOCAL5 },
{ LG_NONE, "local6", LOG_LOCAL6 },
{ LG_NONE, "local7", LOG_LOCAL7 },
{ LG_NONE, NULL, -1 }
};
# define MAXFNAME (1023)
/*****************************************************************
** function definitions (for function declarations see log.h)
*****************************************************************/
/*****************************************************************
** lg_fileopen (path, name) -- open the log file
** Name is a (absolute or relative) file or directory name.
** If path is given and name is a relative path name then path
** is prepended to name.
** returns the open file pointer or NULL on error
*****************************************************************/
static FILE *lg_fileopen (const char *path, const char *name)
{
int len;
FILE *fp;
struct tm *t;
time_t sec;
char fname[MAXFNAME+1];
if ( name == NULL || *name == '\0' )
return NULL;
else if ( *name == '/' || path == NULL )
snprintf (fname, MAXFNAME, "%s", name);
else
snprintf (fname, MAXFNAME, "%s/%s", path, name);
# ifdef LOG_TEST
fprintf (stderr, "\t ==> \"%s\"", fname);
# endif
if ( is_directory (fname) )
{
len = strlen (fname);
time (&sec);
t = gmtime (&sec);
snprintf (fname+len, MAXFNAME-len, LOG_FNAMETMPL,
t->tm_year + 1900, t->tm_mon+1, t->tm_mday,
t->tm_hour, t->tm_min, t->tm_sec);
# ifdef LOG_TEST
fprintf (stderr, " isdir \"%s\"", fname);
# endif
}
# ifdef LOG_TEST
fprintf (stderr, "\n");
# endif
if ( (fp = fopen (fname, "a")) == NULL )
return NULL;
return fp;
}
/*****************************************************************
** lg_str2lvl (level_name)
*****************************************************************/
lg_lvl_t lg_str2lvl (const char *name)
{
lg_symtbl_t *p;
if ( !name )
return LG_NONE;
for ( p = symtbl; p->str; p++ )
if ( strcasecmp (name, p->str) == 0 )
return p->level;
return LG_NONE;
}
/*****************************************************************
** lg_lvl2syslog (level)
*****************************************************************/
lg_lvl_t lg_lvl2syslog (lg_lvl_t level)
{
lg_symtbl_t *p;
for ( p = symtbl; p->str; p++ )
if ( level == p->level )
return p->syslog_level;
assert ( p->str != NULL ); /* we assume not to reach this! */
return LOG_DEBUG; /* if not found, return DEBUG as default */
}
/*****************************************************************
** lg_str2syslog (facility_name)
*****************************************************************/
int lg_str2syslog (const char *facility)
{
lg_symtbl_t *p;
dbg_val1 ("lg_str2syslog (%s)\n", facility);
if ( !facility )
return LG_NONE;
for ( p = symtbl; p->str; p++ )
if ( strcasecmp (facility, p->str) == 0 )
return p->syslog_level;
return LG_NONE;
}
/*****************************************************************
** lg_lvl2str (level)
*****************************************************************/
const char *lg_lvl2str (lg_lvl_t level)
{
lg_symtbl_t *p;
if ( level < LG_DEBUG )
return "none";
for ( p = symtbl; p->str; p++ )
if ( level == p->level )
return p->str;
return "fatal";
}
/*****************************************************************
** lg_geterrcnt () -- returns the current value of the internal
** error counter
*****************************************************************/
long lg_geterrcnt ()
{
return lg_errcnt;
}
/*****************************************************************
** lg_seterrcnt () -- sets the internal error counter
** returns the current value
*****************************************************************/
long lg_seterrcnt (long value)
{
return lg_errcnt = value;
}
/*****************************************************************
** lg_reseterrcnt () -- resets the internal error counter to 0
** returns the current value
*****************************************************************/
long lg_reseterrcnt ()
{
return lg_seterrcnt (0L);
}
/*****************************************************************
** lg_open (prog, facility, syslevel, path, file, filelevel)
** -- open the log channel
** return values:
** 0 on success
** -1 on file open error
*****************************************************************/
int lg_open (const char *progname, const char *facility, const char *syslevel, const char *path, const char *file, const char *filelevel)
{
int sysfacility;
dbg_val6 ("lg_open (%s, %s, %s, %s, %s, %s)\n", progname, facility, syslevel, path, file, filelevel);
lg_minsyslevel = lg_str2lvl (syslevel);
lg_minfilelevel = lg_str2lvl (filelevel);
sysfacility = lg_str2syslog (facility);
if ( sysfacility >= 0 )
{
lg_syslogging = 1;
dbg_val2 ("lg_open: openlog (%s, LOG_NDELAY, %d)\n", progname, lg_str2syslog (facility));
openlog (progname, LOG_NDELAY, lg_str2syslog (facility));
}
if ( file && * file )
{
if ( (lg_fp = lg_fileopen (path, file)) == NULL )
return -1;
lg_progname = progname;
}
return 0;
}
/*****************************************************************
** lg_close () -- close the open filepointer for error logging
** return 0 if no error log file is currently open,
** otherwise the return code of fclose is returned.
*****************************************************************/
int lg_close ()
{
int ret = 0;
if ( lg_syslogging )
{
closelog ();
lg_syslogging = 0;
}
if ( lg_fp )
{
ret = fclose (lg_fp);
lg_fp = NULL;
}
return ret;
}
/*****************************************************************
** lg_zone_start (domain)
** -- reopen the log channel
** return values:
** 0 on success
** -1 on file open error
*****************************************************************/
int lg_zone_start (const char *dir, const char *domain)
{
char fname[255+1];
dbg_val2 ("lg_zone_start (%s, %s)\n", dir, domain);
snprintf (fname, sizeof (fname), LOG_DOMAINTMPL, domain);
if ( lg_fp )
lg_fpsave = lg_fp;
lg_fp = lg_fileopen (dir, fname);
return lg_fp != NULL;
}
/*****************************************************************
** lg_zone_end (domain)
** -- close the (reopened) log channel
** return values:
** 0 on success
** -1 on file open error
*****************************************************************/
int lg_zone_end ()
{
if ( lg_fp && lg_fpsave )
{
lg_close ();
lg_fp = lg_fpsave;
lg_fpsave = NULL;
return 1;
}
return 0;
}
/*****************************************************************
**
** lg_args (level, argc, argv[])
** log all command line arguments (up to a length of 511 chars)
** with priority level
**
*****************************************************************/
void lg_args (lg_lvl_t level, int argc, char * const argv[])
{
char cmdline[511+1];
int len;
int i;
len = 0;
for ( i = 0; i < argc && len < sizeof (cmdline); i++ )
len += snprintf (cmdline+len, sizeof (cmdline) - len, " %s", argv[i]);
#if 1
lg_mesg (level, "------------------------------------------------------------");
#else
lg_mesg (level, "");
#endif
lg_mesg (level, "running%s ", cmdline);
}
/*****************************************************************
**
** lg_mesg (level, fmt, ...)
**
** Write a given message to the error log file and counts
** all messages written with an level greater than LOG_ERR.
**
** All messages will be on one line in the logfile, so it's
** not necessary to add an '\n' to the message.
**
** To call this function before an elog_open() is called is
** useless!
**
*****************************************************************/
void lg_mesg (int priority, char *fmt, ...)
{
va_list ap;
struct timeval tv;
struct tm *t;
char format[256];
assert (fmt != NULL);
assert (priority >= LG_DEBUG && priority <= LG_FATAL);
format[0] ='\0';
dbg_val3 ("syslog = %d prio = %d >= sysmin = %d\n", lg_syslogging, priority, lg_minsyslevel);
if ( lg_syslogging && priority >= lg_minsyslevel )
{
#if defined (LOG_WITH_LEVEL) && LOG_WITH_LEVEL
snprintf (format, sizeof (format), "%s: %s", lg_lvl2str(priority), fmt);
fmt = format;
#endif
va_start(ap, fmt);
vsyslog (lg_lvl2syslog (priority), fmt, ap);
va_end(ap);
}
dbg_val3 ("filelg = %d prio = %d >= filmin = %d\n", lg_fp!=NULL, priority, lg_minfilelevel);
if ( lg_fp && priority >= lg_minfilelevel )
{
#if defined (LOG_WITH_TIMESTAMP) && LOG_WITH_TIMESTAMP
gettimeofday (&tv, NULL);
t = localtime ((time_t *) &tv.tv_sec);
fprintf (lg_fp, "%04d-%02d-%02d ",
t->tm_year+1900, t->tm_mon+1, t->tm_mday);
fprintf (lg_fp, "%02d:%02d:%02d.%03ld: ",
t->tm_hour, t->tm_min, t->tm_sec, tv.tv_usec / 1000);
#endif
#if defined (LOG_WITH_PROGNAME) && LOG_WITH_PROGNAME
if ( lg_progname )
fprintf (lg_fp, "%s: ", lg_progname);
#endif
#if defined (LOG_WITH_LEVEL) && LOG_WITH_LEVEL
if ( fmt != format ) /* level is not in fmt string */
fprintf (lg_fp, "%s: ", lg_lvl2str(priority));
#endif
va_start(ap, fmt);
vfprintf (lg_fp, fmt, ap);
va_end(ap);
fprintf (lg_fp, "\n");
}
if ( priority >= LG_ERROR )
lg_errcnt++;
}
#ifdef LOG_TEST
const char *progname;
int main (int argc, char *argv[])
{
const char *levelstr;
const char *newlevelstr;
int level;
int err;
progname = *argv;
if ( --argc )
levelstr = *++argv;
else
levelstr = "fatal";
level = lg_str2lvl (levelstr);
newlevelstr = lg_lvl2str (level+1);
dbg_val4 ("base level = %s(%d) newlevel = %s(%d)\n", levelstr, level, newlevelstr, level+1);
if ( (err = lg_open (progname,
#if 1
"user",
#else
"none",
#endif
levelstr, ".",
#if 1
"test.log",
#else
NULL,
#endif
newlevelstr)) )
fprintf (stderr, "\topen error %d\n", err);
else
{
lg_mesg (LG_DEBUG, "debug message");
lg_mesg (LG_INFO, "INFO message");
lg_mesg (LG_NOTICE, "Notice message");
lg_mesg (LG_WARNING, "Warning message");
lg_mesg (LG_ERROR, "Error message");
lg_mesg (LG_FATAL, "Fatal message ");
}
if ( (err = lg_close ()) < 0 )
fprintf (stderr, "\tclose error %d\n", err);
return 0;
}
#endif