logging.c

Go to the documentation of this file.

 
#include "config.h"
#include <errno.h>
#include <stdarg.h> // IWYU pragma: keep
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include "date.h"
#include "file.h"
#include "logging2.h"
#include "memory.h"
#include "message.h"
#include "queue.h"
#include "string2.h"
 
const char *LevelAbbr = "PEWM12345N"; 
 
log_dispatcher_t MuttLogger = log_disp_terminal;
 
static FILE *LogFileFP = NULL;      
static char *LogFileName = NULL;    
static int LogFileLevel = 0;        
static char *LogFileVersion = NULL; 
 
static struct LogLineList LogQueue = STAILQ_HEAD_INITIALIZER(LogQueue);
 
static int LogQueueCount = 0; 
static int LogQueueMax = 0;   
 
static const char *timestamp(time_t stamp)
{
  static char buf[23] = { 0 };
  static time_t last = 0;
 
  if (stamp == 0)
    stamp = mutt_date_now();
 
  if (stamp != last)
  {
    mutt_date_localtime_format(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", stamp);
    last = stamp;
  }
 
  return buf;
}
 
void log_file_close(bool verbose)
{
  if (!LogFileFP)
    return;
 
  fprintf(LogFileFP, "[%s] Closing log.\n", timestamp(0));
  fprintf(LogFileFP, "# vim: syntax=neomuttlog\n");
  mutt_file_fclose(&LogFileFP);
  if (verbose)
    mutt_message(_("Closed log file: %s"), LogFileName);
}
 
int log_file_open(bool verbose)
{
  if (!LogFileName)
    return -1;
 
  if (LogFileFP)
    log_file_close(false);
 
  if (LogFileLevel < LL_DEBUG1)
    return -1;
 
  LogFileFP = mutt_file_fopen(LogFileName, "a+");
  if (!LogFileFP)
    return -1;
  setvbuf(LogFileFP, NULL, _IOLBF, 0);
 
  fprintf(LogFileFP, "[%s] NeoMutt%s debugging at level %d\n", timestamp(0),
          NONULL(LogFileVersion), LogFileLevel);
  if (verbose)
    mutt_message(_("Debugging at level %d to file '%s'"), LogFileLevel, LogFileName);
  return 0;
}
 
int log_file_set_filename(const char *file, bool verbose)
{
  if (!file)
    return -1;
 
  /* also handles both being NULL */
  if (mutt_str_equal(LogFileName, file))
    return 0;
 
  mutt_str_replace(&LogFileName, file);
 
  if (!LogFileName)
    log_file_close(verbose);
 
  return log_file_open(verbose);
}
 
int log_file_set_level(enum LogLevel level, bool verbose)
{
  if ((level < LL_MESSAGE) || (level >= LL_MAX))
    return -1;
 
  if (level == LogFileLevel)
    return 0;
 
  LogFileLevel = level;
 
  if (level == LL_MESSAGE)
  {
    log_file_close(verbose);
  }
  else if (LogFileFP)
  {
    if (verbose)
      mutt_message(_("Logging at level %d to file '%s'"), LogFileLevel, LogFileName);
    fprintf(LogFileFP, "[%s] NeoMutt%s debugging at level %d\n", timestamp(0),
            NONULL(LogFileVersion), LogFileLevel);
  }
  else
  {
    log_file_open(verbose);
  }
 
  if (LogFileLevel >= LL_DEBUG5)
  {
    fprintf(LogFileFP, "\n"
                       "WARNING:\n"
                       "    Logging at this level can reveal personal information.\n"
                       "    Review the log carefully before posting in bug reports.\n"
                       "\n");
  }
 
  return 0;
}
 
void log_file_set_version(const char *version)
{
  mutt_str_replace(&LogFileVersion, version);
}
 
bool log_file_running(void)
{
  return LogFileFP;
}
 
int log_disp_file(time_t stamp, const char *file, int line, const char *function,
                  enum LogLevel level, const char *format, ...)
{
  if (!LogFileFP || (level < LL_PERROR) || (level > LogFileLevel))
    return 0;
 
  int rc = 0;
  int err = errno;
 
  if (!function)
    function = "UNKNOWN";
 
  rc += fprintf(LogFileFP, "[%s]<%c> %s() ", timestamp(stamp), LevelAbbr[level + 3], function);
 
  va_list ap;
  va_start(ap, format);
  rc += vfprintf(LogFileFP, format, ap);
  va_end(ap);
 
  if (level == LL_PERROR)
  {
    fprintf(LogFileFP, ": %s\n", strerror(err));
  }
  else if (level <= LL_MESSAGE)
  {
    fputs("\n", LogFileFP);
    rc++;
  }
 
  return rc;
}
 
int log_queue_add(struct LogLine *ll)
{
  if (!ll)
    return -1;
 
  STAILQ_INSERT_TAIL(&LogQueue, ll, entries);
 
  if ((LogQueueMax > 0) && (LogQueueCount >= LogQueueMax))
  {
    ll = STAILQ_FIRST(&LogQueue);
    STAILQ_REMOVE_HEAD(&LogQueue, entries);
    FREE(&ll->message);
    FREE(&ll);
  }
  else
  {
    LogQueueCount++;
  }
  return LogQueueCount;
}
 
void log_queue_set_max_size(int size)
{
  if (size < 0)
    size = 0;
  LogQueueMax = size;
}
 
void log_queue_empty(void)
{
  struct LogLine *ll = NULL;
  struct LogLine *tmp = NULL;
 
  STAILQ_FOREACH_SAFE(ll, &LogQueue, entries, tmp)
  {
    STAILQ_REMOVE(&LogQueue, ll, LogLine, entries);
    FREE(&ll->message);
    FREE(&ll);
  }
 
  LogQueueCount = 0;
}
 
void log_queue_flush(log_dispatcher_t disp)
{
  struct LogLine *ll = NULL;
  STAILQ_FOREACH(ll, &LogQueue, entries)
  {
    disp(ll->time, ll->file, ll->line, ll->function, ll->level, "%s", ll->message);
  }
 
  log_queue_empty();
}
 
int log_queue_save(FILE *fp)
{
  if (!fp)
    return 0;
 
  char buf[32] = { 0 };
  int count = 0;
  struct LogLine *ll = NULL;
  STAILQ_FOREACH(ll, &LogQueue, entries)
  {
    mutt_date_localtime_format(buf, sizeof(buf), "%H:%M:%S", ll->time);
    fprintf(fp, "[%s]<%c> %s", buf, LevelAbbr[ll->level + 3], ll->message);
    if (ll->level <= LL_MESSAGE)
      fputs("\n", fp);
    count++;
  }
 
  return count;
}
 
int log_disp_queue(time_t stamp, const char *file, int line, const char *function,
                   enum LogLevel level, const char *format, ...)
{
  char buf[LOG_LINE_MAX_LEN] = { 0 };
  int err = errno;
 
  va_list ap;
  va_start(ap, format);
  int rc = vsnprintf(buf, sizeof(buf), format, ap);
  va_end(ap);
 
  if (level == LL_PERROR)
  {
    if ((rc >= 0) && (rc < sizeof(buf)))
      rc += snprintf(buf + rc, sizeof(buf) - rc, ": %s", strerror(err));
    level = LL_ERROR;
  }
 
  struct LogLine *ll = mutt_mem_calloc(1, sizeof(*ll));
  ll->time = (stamp != 0) ? stamp : mutt_date_now();
  ll->file = file;
  ll->line = line;
  ll->function = function;
  ll->level = level;
  ll->message = mutt_str_dup(buf);
 
  log_queue_add(ll);
 
  return rc;
}
 
int log_disp_terminal(time_t stamp, const char *file, int line, const char *function,
                      enum LogLevel level, const char *format, ...)
{
  char buf[LOG_LINE_MAX_LEN] = { 0 };
 
  va_list ap;
  va_start(ap, format);
  int rc = vsnprintf(buf, sizeof(buf), format, ap);
  va_end(ap);
 
  log_disp_file(stamp, file, line, function, level, "%s", buf);
 
  if ((level < LL_PERROR) || (level > LL_MESSAGE))
    return 0;
 
  FILE *fp = (level < LL_MESSAGE) ? stderr : stdout;
  int err = errno;
  int color = 0;
  bool tty = (isatty(fileno(fp)) == 1);
 
  if (tty)
  {
    switch (level)
    {
      case LL_PERROR:
      case LL_ERROR:
        color = 31;
        break;
      case LL_WARNING:
        color = 33;
        break;
      case LL_MESSAGE:
      default:
        break;
    }
  }
 
  if (color > 0)
    rc += fprintf(fp, "\033[1;%dm", color); // Escape
 
  fputs(buf, fp);
 
  if (level == LL_PERROR)
    rc += fprintf(fp, ": %s", strerror(err));
 
  if (color > 0)
    rc += fprintf(fp, "\033[0m"); // Escape
 
  rc += fprintf(fp, "\n");
 
  return rc;
}
 
void log_multiline_full(enum LogLevel level, const char *str, const char *file,
                        int line, const char *func)
{
  while (str && (str[0] != '\0'))
  {
    const char *end = strchr(str, '\n');
    if (end)
    {
      int len = end - str;
      MuttLogger(0, file, line, func, level, "%.*s\n", len, str);
      str = end + 1;
    }
    else
    {
      MuttLogger(0, file, line, func, level, "%s\n", str);
      break;
    }
  }
}