---

logger.c

Go to the documentation of this file.

/***************************************************************************
                                  logger.c
                             -------------------
    begin                : Sat Nov 3 2001
    copyright            : (C) 2001-2002 by Christian Hönig & Gunter Ohrner
    email                : pdepp@CustomCDROM.de
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/

#include "common.h"

#include <assert.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <time.h>

#include "logger.h"

#include "buffer.h"
#include "conftable.h"
#include "fileplist.h"
#include "loggerlist.h"
#include "misc.h"
#include "xmalloc.h"


/**************************************************************************
 *                                                                        *
 *   functions/macros to retrieve information about log message sources   *
 *                                                                        *
 **************************************************************************/

// 0 is message source description, 1 is msg source conftable key

#define lgGetSrcDescText(src) (((src) <= LOG_SRC_LAST) ? (log_src_info_tab[src][0]) : "unknown source")

#define lgGetSrcConfKey(src) (((src) <= LOG_SRC_LAST) ? (log_src_info_tab[src][1]) : "U")

#define lgGetSrcDescMaxLen() (lgGetSrcMaxLen(0))

#define lgGetSrcKeyMaxLen() (lgGetSrcMaxLen(1))

size_t lgGetSrcMaxLen(int which)
{
  int src;
  size_t maxlen = 0;

  assert(which == 0 || which == 1);

  for(src = 0; src <= LOG_SRC_LAST; ++src)
    maxlen = MAX2(maxlen, strlen(log_src_info_tab[src][which]));

  return MAX2(maxlen, strlen(LOG_SRC_PLACEHOLDER_ALL));
}


#define lgGetLvlConfKey(lvl) (((lvl) <= LOG_LVL_LAST) ? log_lvl_info_tab[lvl] : "u")

size_t lgGetLvlKeyMaxLen()
{
  int lvl;
  size_t maxlen = 0;

  for(lvl = 0; lvl <= LOG_LVL_LAST; ++lvl)
    maxlen = MAX2(maxlen, strlen(log_lvl_info_tab[lvl]));

  return MAX2(maxlen, strlen(LOG_LVL_PLACEHOLDER_ALL));
}


/**************************************************************************
 *                                                                        *
 *           functions for dealing with a single logging stream           *
 *                                                                        *
 **************************************************************************/
/*
  each logging stream is associated with exactly ONE log message source
  and ONE severity level.
 */

struct Logger
{
FILE* lg_ostream;
  int manage_stream;
  char *format;
  size_t format_len;
};

int logClose(Logger this) {
  int result = 0;
  // can I close lg_stream?
  if (this->manage_stream && this->lg_ostream != NULL) {
    result = fclose(this->lg_ostream);
    // invalidate the lg_ostream var
    if (result == 0) this->lg_ostream = NULL;
  }
  return result;
}

Logger logInitStream_int(FILE * log_stream, const char* format, int manage_stream)
{
  Logger this = (Logger) pd_malloc(sizeof(struct Logger));
  this->lg_ostream = log_stream;
  this->format_len = strlen(format);
  this->format = (char*) pd_malloc(this->format_len + 1);
  strcpy(this->format, format);

  if (log_stream != NULL)
    this->manage_stream = manage_stream;
  
  // always succeed
  return this;
}

// opens a new logfile. returns 0 on success
Logger logInit(const char* file_name, const char* format)
{
  FILE* new_stream;
  if (file_name == NULL) file_name = CONFENTRY_KEY_STDLOGFILE;

  if (!strcmp(file_name, LOG_NULL_STREAM))
    new_stream = NULL;
  else
  {
    new_stream = fopen(file_name, "a");
    if (!new_stream) return NULL;
  }

  return logInitStream_int(new_stream, format, true);
}

// sets the current logging stream to use the given stream log_stream
Logger logInitStream(FILE * log_stream, const char* format)
{
  return logInitStream_int(log_stream, format, false);
}

// logs a string into the current logfile with an additional error description
int logMessagev(Logger this,
                const unsigned int origin, __attribute__((unused)) const unsigned int severity,
                const int errno_val, const char *const log_text_format, va_list daten)
{
  const int errno_orig = errno;
  const time_t tmptime = time(NULL);
  struct tm* now = localtime(&tmptime);
  size_t idx;
  
  if (this->lg_ostream == NULL/* && severity != CRITICAL*/) return -1;
  
  for (idx = 0; idx < this->format_len; ++idx)
  {
    char cur_char = *(this->format+idx);
    if (cur_char == MP)
    {
      //check the following char
      switch(*(this->format+idx+1))
      {
      case(MP_YEAR): // year
        fprintf(this->lg_ostream, "%d", now->tm_year+1900);
        break;
      case(MP_MONTH): // month
        fprintf(this->lg_ostream, "%02d", now->tm_mon+1);
        break;
      case(MP_DAY): // day
        fprintf(this->lg_ostream, "%02d", now->tm_mday);
        break;
      case(MP_WDAY): // day of week short
        fputs(day_of_week[now->tm_wday][WD_SHORT], this->lg_ostream);
        break;
      case(MP_WDAYL): // day of week long
        fputs(day_of_week[now->tm_wday][WD_LONG], this->lg_ostream);
        break;
      case(MP_HOUR): // hour
        fprintf(this->lg_ostream, "%02d", now->tm_hour);
        break;
      case(MP_MIN): // minute
        fprintf(this->lg_ostream, "%02d", now->tm_min);
        break;
      case(MP_SEC): // second
        fprintf(this->lg_ostream, "%02d", now->tm_sec);
        break;
      case(MP_SRC): // source
        fputs(lgGetSrcDescText(origin), this->lg_ostream);
        break;
      case(MP_LOG): // logcontent
        vfprintf(this->lg_ostream, log_text_format, daten);
        if (errno_val != 0) fprintf(this->lg_ostream, ": %s", strerror(errno_val));
        break;
      default:
        //we swallow the MP, but keep the following char
        //(remember: a MP without \ is invalid!)
        --idx;
      }
      //jump over this one (%A = 2 chars)
      ++idx;
    }
    // find a sonderzeichen?
    // remember: a single '\\' (backslash) is ignored  !!!
    else if (cur_char == '\\')
    {
      switch (*(this->format+idx+1))
      {
      case('n'):  //newline char
        putc('\n', this->lg_ostream);
        break;
      case('t'):  //tab
        putc('\t', this->lg_ostream);
        break;
      case('\\'): // backslash
        putc('\\', this->lg_ostream);
        break;
      case(MP):
        putc(MP, this->lg_ostream);
        break;
      default:
        //a single backslash is written into the data nirvana ;)
        
        // this is not very clean, but i avoid writing everywhere the ++idx
        // here it is not allowed to add one;
        --idx;
      }
      ++idx;
    } 
    else // no special char
      putc(cur_char, this->lg_ostream);
  }

  fflush(this->lg_ostream);
  
  // restore errno value, just in case
  errno = errno_orig;
  return 0;
}

// terminates a Logger object
int logTerminate(Logger this)
{
  logClose(this);
  pd_free(this->format);
  pd_free(this);
  return 0;
}

/**************************************************************************
 *                                                                        *
 *           functions for managing a bunch of logging streams            *
 *                                                                        *
 **************************************************************************/

LoggerList loggers[LOG_SRC_LAST+1][LOG_LVL_LAST+1];
FilepList log_streams;

// adds a logger to the [src][lvl]-matrix
inline int addLogger2List(Logger lgr, int src, int lvl, const char* origin_flags);
// quick and dirty: converts an int to a str
inline char* int2str(int i);

int logfilesInit()
{
  const size_t log_file_name_key_len = MAX2(                      // -%s, +NNN
                                        strlen(CONFENTRY_KEY_LOGFILE)-2+3+1,
                                        strlen(CONFENTRY_KEY_STDLOGFILE)+1
                                       );
  char* log_file_name_key = (char*) pd_malloc(log_file_name_key_len);
  const char* log_file_name;
  int lvl, cnt, src, at_least_one_added = false;

  size_t lvl_key_max = lgGetLvlKeyMaxLen(), src_key_max = lgGetSrcKeyMaxLen();

  // *** size calculations for format string template keys ***
  // generic format template key for all loggers if not specified explicitely
                                                           // -%s, +\0
  size_t std_format_key_len = strlen(CONFENTRY_KEY_LOGFORMAT) - 2 + 1;
  // std format template key for a given logger
                                      // "NNN.src\0"
  size_t log_format_key_id_len = 3 + 1 + src_key_max + 1;
  size_t log_format_key_len = std_format_key_len + log_format_key_id_len;
  // std format template key for a given msg source in a given logger
  size_t src_format_key_id_len = log_format_key_id_len + lvl_key_max + 1;
                                              // -%s, +"NNN.s\0"
  size_t src_format_key_len = log_format_key_len + 1 + lvl_key_max;
  // format template key for a given msg source and severity level in a given lgr
                                                    // -%s, +"NNN.s.l\0"
  size_t src_lvl_format_key_id_len = src_format_key_id_len;
  size_t src_lvl_format_key_len = src_format_key_len;

  // key to get the global log format template
  char* std_format_key = (char*) pd_malloc(std_format_key_len);

  // id (middle part) of log_format_key     "NNN.src\0"
  char* log_format_key_id = (char*) pd_malloc(log_format_key_id_len);
  // key to get a log-specific format template
  char* log_format_key = (char*) pd_malloc(log_format_key_len);

  // if (middle part) of src_format_key       "NNN.src.lvl\0"
  char* src_format_key_id = (char*) pd_malloc(src_format_key_id_len);
  // key to get format for a single mesg. source in a specific logger
  char* src_format_key = (char*) pd_malloc(src_format_key_len);

  // if (middle part) of src_lvl_format_key      "NNN.src.lvl\0"
  char* src_lvl_format_key_id = (char*) pd_malloc(src_lvl_format_key_id_len);
  // key to get the format key for a single msg. src. at a given severity level in one logger
  char* src_lvl_format_key = (char*) pd_malloc(src_lvl_format_key_len);

  // *** size calculations for origin flag keys ***
  // generic origin flag key for all loggers if not specified explicitely
                                                                   // -%s, +\0"
  size_t std_origin_flags_key_len = strlen(CONFENTRY_KEY_LOGORIGINFLAGS) - 2 + 1;
  // std origin flags key for a given logger
                                                                     // -%s, +"NNN\0"
  size_t log_origin_flags_key_len = strlen(CONFENTRY_KEY_LOGORIGINFLAGS) - 2 + 3 + 1;

  char* std_origin_flags_key = (char*) pd_malloc(std_origin_flags_key_len);
  char* log_origin_flags_key = (char*) pd_malloc(log_origin_flags_key_len);

  const char * std_origin_flags, * std_format;

  log_streams = filepListInit();

  // format standard origin flags and format keys and read the values
  sprintf(std_origin_flags_key, CONFENTRY_KEY_LOGORIGINFLAGS, "");
  std_origin_flags = getEntryDefl(std_origin_flags_key, STD_CONFENTRY_VAL_LOGORIGINFLAGS);

  sprintf(std_format_key, CONFENTRY_KEY_LOGFORMAT, "");
  std_format = getEntryDefl(std_format_key, STD_CONFENTRY_VAL_LOGFORMAT);

  // init the logListists
  for (src = 0; src <= LOG_SRC_LAST; ++src)
    for(lvl = 0; lvl <= LOG_LVL_LAST; ++lvl)
    {
      loggers[src][lvl] = logListInit();
      if (lvl >= CRITICAL) // log any critical error to stderr
      {
        Logger std_err_log = logInitStream(stderr, LOG_PANIC_FORMAT);
#ifndef NDEBUG
        if (!
#endif
            addLogger2List(std_err_log, src, lvl,
                           LOG_LVL_PLACEHOLDER_ALL LOG_SRC_PLACEHOLDER_ALL)
#ifndef NDEBUG
            )
          abort()
#endif
            ;
      }
    }

  // add the standard-logfile first
  // use an invalid cnt value so the default values will be used for origin_flags
  // and format
  cnt = -1;
  snprintf(log_file_name_key, log_file_name_key_len, CONFENTRY_KEY_STDLOGFILE);

  while((log_file_name = getEntry(log_file_name_key)) != NULL && cnt < 1000)
  {
    const char * log_origin_flags, * log_format;
    int added = false;

    // open the logfile
    FILE* log_stream = fopen(log_file_name, "a");
    if (log_stream == NULL)
      fprintf(stderr,
              "could not open logfile \"%s\": %s\n",
              log_file_name, strerror(errno));
    else
    {
      // generate conftable key for the logfile specific format template string
      // look for "logN.A.format"
      sprintf(log_format_key_id, "%d.%s", cnt, LOG_SRC_PLACEHOLDER_ALL);
      sprintf(log_format_key, CONFENTRY_KEY_LOGFORMAT, log_format_key_id);
      // Read the logfile specific format template string. If none is given use the
      // global default defined in the log file.
      log_format = getEntry(log_format_key);

      if (log_format == NULL)
      {
        // no logN.A.format found...
        // look for logN.format
        sprintf(log_format_key_id, "%d", cnt);
        sprintf(log_format_key, CONFENTRY_KEY_LOGFORMAT, log_format_key_id);
        // Read the logfile specific format template string. If none is given use the
        // global default defined in the log file.
        log_format = getEntryDefl(log_format_key, std_format);
      }

      // generate the logfile specifig msg origin flag string
      snprintf(log_origin_flags_key, log_origin_flags_key_len,
               CONFENTRY_KEY_LOGORIGINFLAGS, int2str(cnt));
      log_origin_flags = getEntryDefl(log_origin_flags_key, std_origin_flags);

      // loop over all msg sources of this logger
      for (src = 0; src <= LOG_SRC_LAST; ++src)
      {
        const char * src_format;

        // lookup format templates given explicitely for this msg source with
        // this logger
        sprintf(src_format_key_id, "%s.%s.%s", int2str(cnt), lgGetSrcConfKey(src), LOG_LVL_PLACEHOLDER_ALL);
        sprintf(src_format_key, CONFENTRY_KEY_LOGFORMAT, src_format_key_id);

        // inherit log_format if no specific is given
        src_format = getEntry(src_format_key);

        if (src_format == NULL)
        {
          // lookup format templates given explicitely for this msg source with
          //   this logger
          sprintf(src_format_key_id, "%s.%s", int2str(cnt), lgGetSrcConfKey(src));
          sprintf(src_format_key, CONFENTRY_KEY_LOGFORMAT, src_format_key_id);

          // inherit   log_format if no specific is given
          src_format = getEntryDefl(src_format_key, log_format);
        }

        // loop over all severity levels for a specific msg source of the current logger
        for (lvl = 0; lvl <= LOG_LVL_LAST; ++lvl)
        {
          const char* src_lvl_format;

          // look up format informations given explicitely for
          // this msg source / level pair, overriding any more generic
          // format description
          sprintf(src_lvl_format_key_id, "%s.%s.%s", 
                  int2str(cnt), lgGetSrcConfKey(src), lgGetLvlConfKey(lvl));
          sprintf(src_lvl_format_key, CONFENTRY_KEY_LOGFORMAT, src_lvl_format_key_id);

          // inherit the src_format if no specific is given
          src_lvl_format = getEntry(src_lvl_format_key);
          if (src_lvl_format == NULL)
          {
            sprintf(src_lvl_format_key_id, "%s.%s.%s", 
                    int2str(cnt), LOG_SRC_PLACEHOLDER_ALL, lgGetLvlConfKey(lvl));
            sprintf(src_lvl_format_key, CONFENTRY_KEY_LOGFORMAT, src_lvl_format_key_id);
            src_lvl_format = getEntryDefl(src_lvl_format_key, src_format);
          }

          if (strcmp(src_lvl_format, LOG_NULL_FORMAT) != 0)
          {
            Logger lgr;
            lgr = logInitStream(log_stream, src_lvl_format);

            if (addLogger2List(lgr, src, lvl, log_origin_flags))
              added = true;
            else
            logTerminate(lgr);
          }
        } // end "for (lvl="
      } // end "for (src="

      if (!added)
        fclose(log_stream);
      else
      {
        at_least_one_added = true;
        filepListAppend(log_streams, log_stream);
      }
    } // endif FILE == NULL

    // continue with the next logfile defined in the configuration file
    snprintf(log_file_name_key, log_file_name_key_len,
             CONFENTRY_KEY_LOGFILE, int2str(++cnt));
  }

  // no logfile could be created, use panic logging stream for everything (stderr)
  if (!at_least_one_added)
  {
    for (src = 0; src <= LOG_SRC_LAST; ++src)
      // everything which is critical is logged to stderr anyway
      for (lvl = INFO; lvl < CRITICAL; ++lvl)
      {
        Logger panic_log = logInitStream(stderr, LOG_PANIC_FORMAT);
#ifndef NDEBUG
        if (!
#endif
            addLogger2List(panic_log, src, lvl,
                            LOG_SRC_PLACEHOLDER_ALL LOG_LVL_PLACEHOLDER_ALL)
#ifndef NDEBUG
            )
          abort()
#endif
            ;
      }
    /* This message get's output during logging
       subsystem-preinitialisation as well so we should better be quiet...
       logger(LOGGER, WARNING,
           "No logfiles have been configured or could be opened,\n"
           "falling back to stderr for outputting all messages!"); */
  }

  pd_free(log_file_name_key);
  pd_free(std_format_key);
  pd_free(log_format_key);
  pd_free(log_format_key_id);
  pd_free(src_format_key);
  pd_free(src_format_key_id);
  pd_free(src_lvl_format_key);
  pd_free(src_lvl_format_key_id);
  pd_free(std_origin_flags_key);
  pd_free(log_origin_flags_key);

  return 0;
}

// close all log files and shut down the logging subsystem
int logfilesTerminate()
{
  int src, lvl;
  for (src = 0; src <= LOG_SRC_LAST ; ++src)
    for (lvl = 0; lvl <= LOG_LVL_LAST; ++lvl)
    {
      logListFirst(loggers[src][lvl]);
      while(!logListIsTail(loggers[src][lvl]))
      {
        logTerminate(logListGetPayload(loggers[src][lvl]));
        logListDelete(loggers[src][lvl]);
      }
      logListTerminate(loggers[src][lvl]);
    }

  filepListFirst(log_streams);
  while(!filepListIsTail(log_streams))
  {
    fclose(filepListGetPayload(log_streams));
    filepListDelete(log_streams);
  }
  filepListTerminate(log_streams);

  return 0;
}

// logs an error message
int logerr(const unsigned int origin, const unsigned int severity, const int errno_val,
           const char *const log_text_format, ...)
{
  va_list args;
  int res = 0;
  LoggerList cur_list = loggers[origin][severity];

  logListFirst(cur_list);
  while(!logListIsTail(cur_list))
  {
    va_start(args, log_text_format);
    if ( logMessagev(logListGetPayload(cur_list),
                     origin, severity, errno_val, log_text_format, args) == -1 ) res = -1;
    va_end(args);
    logListNext(cur_list);
  }
  return res;
}

// logs a string into the current logfile
int logger(const unsigned int origin, const unsigned int severity,
           const char *const log_text_format, ...)
{
  va_list args;
  int res = 0;
  LoggerList cur_list = loggers[origin][severity];

  logListFirst(cur_list);
  while(!logListIsTail(cur_list))
  {
    va_start(args, log_text_format);
    if ( logMessagev(logListGetPayload(cur_list),
                     origin, severity, 0, log_text_format, args) == -1 ) res = -1;
    va_end(args);
    logListNext(cur_list);
  }
  return res;
}

inline int addLogger2List(Logger lgr, int src, int lvl, const char* origin_flags)
{
  assert(src >= 0 && src <= LOG_SRC_LAST && lvl >= 0 && lvl <= LOG_LVL_LAST);

  // This looks fairly complex but is extremely simple in fact:
  // If the src conf key is contained in the current origin_flags string
  //   or the placeholder for all msg sources is included 
  // and the lvl conf key is contained in the current origin_flags string
  //   or the placeholder for all severity levels is included 
  // then add this logger to the matrix
  if ((strstr(origin_flags, lgGetSrcConfKey(src))
          || strstr(origin_flags, LOG_SRC_PLACEHOLDER_ALL))
      && (strstr(origin_flags, lgGetLvlConfKey(lvl))
          || (strstr(origin_flags, LOG_LVL_PLACEHOLDER_ALL) && lvl != DEBUG)))
  {
    logListAppend(loggers[src][lvl], lgr);
    return true;
  }
  return false;
}

inline char* int2str(int i)
{
  char tmp_buf[4];

  ssize_t res = snprintf(tmp_buf, 4, "%d", i);

  return (res == -1 || res >= 4) ? "" : tmp_buf;
}

---