dnxLogging.c

Go to the documentation of this file.

/*--------------------------------------------------------------------------

   Copyright (c) 2006-2007, Intellectual Reserve, Inc. All rights reserved.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License version 2 as
   published by the Free Software Foundation.

   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

  --------------------------------------------------------------------------*/

#if HAVE_CONFIG_H
# include <config.h>
#endif

#include "dnxLogging.h"
#include "dnxError.h"
#include "dnxTransport.h"
#include "dnxDebug.h"

#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <time.h>
#include <errno.h>
#include <assert.h>
#include <unistd.h>
#include <syslog.h>

#ifndef LOCALSTATEDIR
# define LOCALSTATEDIR     "/var"
#endif

#define LOGDIR             LOCALSTATEDIR "/log"

#ifndef DEF_LOG_FILE
# define DEF_LOG_FILE      LOGDIR "/dnx.log"
#endif

#ifndef DEF_DEBUG_FILE
# define DEF_DEBUG_FILE    LOGDIR "/dnx.debug.log"
#endif

#ifndef DEF_DEBUG_LEVEL
# define DEF_DEBUG_LEVEL   0
#endif

#define MAX_LOG_LINE       4096
#define SYSLOG_IDENT       "DNX"             

static char SLTAG[] = "syslog:";             
static int defDebugLevel = DEF_DEBUG_LEVEL;  

static int s_syslogLog = 0;                  
static int s_syslogDebug = 0;                
static int s_syslogAudit = 0;                
static int * s_debugLevel = &defDebugLevel;  
static char s_logFileName[FILENAME_MAX + 1] = DEF_LOG_FILE;
static char s_dbgFileName[FILENAME_MAX + 1] = DEF_DEBUG_FILE;
static char s_audFileName[FILENAME_MAX + 1] = "";

/*--------------------------------------------------------------------------
                              IMPLEMENTATION
  --------------------------------------------------------------------------*/

static int decodeSyslogFlags(const char * flagstr, int defaultSev)
{
   static struct { const char * str; int value; } sevflags[] = 
   {
      // severities (posix only)
      { "LOG_EMERG",    LOG_EMERG   },
      { "LOG_ALERT",    LOG_ALERT   },
      { "LOG_CRIT",     LOG_CRIT    },
      { "LOG_ERR",      LOG_ERR     },
      { "LOG_WARNING",  LOG_WARNING },
      { "LOG_NOTICE",   LOG_NOTICE  },
      { "LOG_INFO",     LOG_INFO    },
      { "LOG_DEBUG",    LOG_DEBUG   },
   };
   static struct { const char * str; int value; } facflags[] = 
   {
      // facilities (posix only)
      { "LOG_USER",     LOG_USER    },
      { "LOG_LOCAL0",   LOG_LOCAL0  },
      { "LOG_LOCAL1",   LOG_LOCAL1  },
      { "LOG_LOCAL2",   LOG_LOCAL2  },
      { "LOG_LOCAL3",   LOG_LOCAL3  },
      { "LOG_LOCAL4",   LOG_LOCAL4  },
      { "LOG_LOCAL5",   LOG_LOCAL5  },
      { "LOG_LOCAL6",   LOG_LOCAL6  },
      { "LOG_LOCAL7",   LOG_LOCAL7  },
   };
   char flagcpy[128];
   char * cp = flagcpy; // current word pointer
   char * ep;           // string end pointer
   int sevFound = 0, facFound = 0;
   int severity, facility;

   // make a working copy
   strncpy(flagcpy, flagstr, sizeof(flagcpy) - 1);
   flagcpy[sizeof(flagcpy) - 1] = 0;
   ep = cp + strlen(cp);

   // parse requested flag values
   while (cp < ep)
   {
      char * np;  // next word pointer
      char * tp;  // temp pointer
      int i;

      // remove leading whitespace (if any)
      while (isspace(*cp)) cp++;

      // terminate and find start of next
      if ((tp = np = strchr(cp, '|')) == 0)
         tp = np = ep;
      *np++ = 0;

      // remove trailing whitespace
      while (tp > --cp && isspace(*tp)) *tp = 0;

      // compare severity strings - ignore unknowns - last one wins
      for (i = 0; i < sizeof(sevflags) / sizeof(*sevflags); i++)
         if (strcmp(sevflags[i].str, cp) == 0)
         {
            severity = sevflags[i].value;
            sevFound = 1;
         }
            
      // compare facility strings - ignore unknowns - last one wins
      for (i = 0; i < sizeof(facflags) / sizeof(*facflags); i++)
         if (strcmp(facflags[i].str, cp) == 0)
         {
            facility = facflags[i].value;
            facFound = 1;
         }

      // move to next word
      cp = np;
   }
   if (!sevFound) severity = defaultSev;
   if (!facFound) facility = LOG_USER;
   return severity | facility;
}

//----------------------------------------------------------------------------

static FILE * openFile(const char * filename, int * pstd)
{
   int std = 1;
   FILE * fp = stdout;

   // check first for standard file handle references
   if (*filename && strcmp(filename, "STDOUT") != 0)
   {
      if (strcmp(filename, "STDERR") == 0)
         fp = stderr;
      else
      {
         // try 1000 times to open the file (in case it's shared)
         int i = 0;
         do fp = fopen(filename, "a+"); while (!fp && ++i < 1000);
         std = 0;
      }
   }
   *pstd = std;
   return fp;
}

//----------------------------------------------------------------------------

static void dnx_vsyslog(int pri, const char * fmt, va_list ap)
{
#ifdef _BSD_SOURCE
   vsyslog(pri, fmt, ap);
#else
   {
      char buf[MAX_LOG_LINE];
      vsnprintf(buf, sizeof(buf), fmt, ap);
      syslog(pri, "%s", buf);
   }
#endif
}

//----------------------------------------------------------------------------

static int vlogger(FILE * fp, char * fmt, va_list ap)
{
   if (!isatty(fileno(fp)))
   {
      // "Sun Sep 16 01:03:52 1973\n\0"
      //  01234567890123456789012345
      char clock_buf[26];
      struct timespec tspec;
      clock_gettime(CLOCK_REALTIME, &tspec); 
      ctime_r(&tspec.tv_sec, clock_buf);
      if (fprintf(fp, "[%.*s.%-3ld%.*s] ", 
            19, clock_buf, 
            tspec.tv_nsec / (1000L * 1000L), // convert to milliseconds
            5, clock_buf + 19) < 0)
         return errno;
   }
   if (vfprintf(fp, fmt, ap) < 0)
      return errno;
   if (fputc('\n', fp) == EOF)
      return errno;
   if (fflush(fp) == EOF)
      return errno;
   return 0;
}

/*--------------------------------------------------------------------------
                                 INTERFACE
  --------------------------------------------------------------------------*/

void dnxLog(char * fmt, ... )
{
   va_list ap;
   assert(fmt);

   if (*s_logFileName)
   {
      if (s_syslogLog)
      {
         va_start(ap, fmt);
         dnx_vsyslog(s_syslogLog, fmt, ap);
         va_end(ap);
      }
      else
      {
         FILE * fp;
         int stdhandle;
         if ((fp = openFile(s_logFileName, &stdhandle)) != 0)
         {
            va_start(ap, fmt);
            vlogger(fp, fmt, ap);
            va_end(ap);

            if (!stdhandle)
               fclose(fp);
         }
      }
   }
}

//----------------------------------------------------------------------------

void dnxDebug(int level, char * fmt, ... )
{
   va_list ap;
   assert(fmt);

   if (*s_dbgFileName && level <= *s_debugLevel)
   {
      if (s_syslogDebug)
      {
         va_start(ap, fmt);
         dnx_vsyslog(s_syslogDebug, fmt, ap);
         va_end(ap);
      }
      else
      {
         FILE * fp;
         int stdhandle;
         if ((fp = openFile(s_dbgFileName, &stdhandle)) != 0)
         {
            va_start(ap, fmt);
            vlogger(fp, fmt, ap);
            va_end(ap);

            if (!stdhandle)
               fclose(fp);
         }
      }
   }
}

//----------------------------------------------------------------------------

int dnxAudit(char * fmt, ... )
{
   int ret = 0;
   va_list ap;
   assert(fmt);

   if (*s_audFileName)
   {
      if (s_syslogAudit)
      {
         va_start(ap, fmt);
         dnx_vsyslog(s_syslogAudit, fmt, ap);
         va_end(ap);
      }
      else
      {
         FILE * fp;
         int stdhandle;
         if ((fp = openFile(s_audFileName, &stdhandle)) != 0)
         {
            va_start(ap, fmt);
            ret = vlogger(fp, fmt, ap);
            va_end(ap);

            if (!stdhandle)
               fclose(fp);
         }
      }
   }
   return ret;
}

//----------------------------------------------------------------------------

void dnxLogInit(char * logFile, char * debugFile, char * auditFile,
      int * debugLevel)
{
   if (logFile)
   {
      if (strncasecmp(logFile, SLTAG, sizeof SLTAG - 1) == 0)
         s_syslogLog = decodeSyslogFlags(logFile 
               + sizeof SLTAG - 1, LOG_INFO);
      else
      {
         strncpy(s_logFileName, logFile, sizeof(s_logFileName) - 1);
         s_logFileName[sizeof(s_logFileName) - 1] = 0;
      }
   }
   if (debugFile)
   {
      if (strncasecmp(debugFile, SLTAG, sizeof SLTAG - 1) == 0)
         s_syslogDebug = decodeSyslogFlags(debugFile 
               + sizeof SLTAG - 1, LOG_DEBUG);
      else
      {
         strncpy(s_dbgFileName, debugFile, sizeof(s_dbgFileName) - 1);
         s_dbgFileName[sizeof(s_dbgFileName) - 1] = 0;
      }
   }
   if (auditFile)
   {
      if (strncasecmp(auditFile, SLTAG, sizeof SLTAG - 1) == 0)
         s_syslogDebug = decodeSyslogFlags(auditFile 
               + sizeof SLTAG - 1, LOG_NOTICE);
      else
      {
         strncpy(s_audFileName, auditFile, sizeof(s_audFileName) - 1);
         s_audFileName[sizeof(s_audFileName) - 1] = 0;
      }
   }
   s_debugLevel = debugLevel;

   // see if syslog is required before opening - we don't want to change
   //    the syslog attributes for the Nagios process (for example).
   if (s_syslogLog || s_syslogDebug || s_syslogAudit)
      openlog(SYSLOG_IDENT, 0, 0);
}

/*--------------------------------------------------------------------------*/