mutt_logging.c

Go to the documentation of this file.

#include "config.h"
#include <errno.h>
#include <limits.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "mutt/mutt.h"
#include "config/lib.h"
#include "curs_lib.h"
#include "globals.h"
#include "mutt_curses.h"
#include "mutt_window.h"
#include "muttlib.h"
#include "options.h"

size_t LastError = 0; 

short C_DebugLevel = 0;   
char *C_DebugFile = NULL; 
char *CurrentFile = NULL; 
const int NumOfLogs = 5;  
#define S_TO_MS 1000L

static void error_pause(void)
{
  const size_t elapsed = mutt_date_epoch_ms() - LastError;
  const size_t sleep = C_SleepTime * S_TO_MS;
  if ((LastError == 0) || (elapsed >= sleep))
    return;

  mutt_refresh();
  mutt_date_sleep_ms(sleep - elapsed);
}

static const char *rotate_logs(const char *file, int count)
{
  if (!file)
    return NULL;

  char old_file[PATH_MAX];
  char new_file[PATH_MAX];

  /* rotate the old debug logs */
  for (count -= 2; count >= 0; count--)
  {
    snprintf(old_file, sizeof(old_file), "%s%d", file, count);
    snprintf(new_file, sizeof(new_file), "%s%d", file, count + 1);

    mutt_expand_path(old_file, sizeof(old_file));
    mutt_expand_path(new_file, sizeof(new_file));
    rename(old_file, new_file);
  }

  return mutt_str_strdup(old_file);
}

void mutt_clear_error(void)
{
  /* Make sure the error message has had time to be read */
  if (OptMsgErr)
    error_pause();

  ErrorBufMessage = false;
  if (!OptNoCurses)
    mutt_window_clearline(MuttMessageWindow, 0);
}

int log_disp_curses(time_t stamp, const char *file, int line,
                    const char *function, int level, ...)
{
  if (level > C_DebugLevel)
    return 0;

  char buf[1024];

  va_list ap;
  va_start(ap, level);
  const char *fmt = va_arg(ap, const char *);
  int ret = vsnprintf(buf, sizeof(buf), fmt, ap);
  va_end(ap);

  if (level == LL_PERROR)
  {
    char *buf2 = buf + ret;
    int len = sizeof(buf) - ret;
    char *p = strerror(errno);
    if (!p)
      p = _("unknown error");

    ret += snprintf(buf2, len, ": %s (errno = %d)", p, errno);
  }

  const bool dupe = (strcmp(buf, ErrorBuf) == 0);
  if (!dupe)
  {
    /* Only log unique messages */
    log_disp_file(stamp, file, line, function, level, "%s", buf);
    if (stamp == 0)
      log_disp_queue(stamp, file, line, function, level, "%s", buf);
  }

  /* Don't display debugging message on screen */
  if (level > LL_MESSAGE)
    return 0;

  /* Only pause if this is a message following an error */
  if ((level > LL_ERROR) && OptMsgErr && !dupe)
    error_pause();

  mutt_simple_format(ErrorBuf, sizeof(ErrorBuf), 0, MuttMessageWindow->cols,
                     JUSTIFY_LEFT, 0, buf, sizeof(buf), false);
  ErrorBufMessage = true;

  if (!OptKeepQuiet)
  {
    if (level == LL_ERROR)
      BEEP();
    SET_COLOR((level == LL_ERROR) ? MT_COLOR_ERROR : MT_COLOR_MESSAGE);
    mutt_window_mvaddstr(MuttMessageWindow, 0, 0, ErrorBuf);
    NORMAL_COLOR;
    mutt_window_clrtoeol(MuttMessageWindow);
    mutt_refresh();
  }

  if ((level <= LL_ERROR) && !dupe)
  {
    OptMsgErr = true;
    LastError = mutt_date_epoch_ms();
  }
  else
  {
    OptMsgErr = false;
    LastError = 0;
  }

  return ret;
}

void mutt_log_prep(void)
{
  char ver[64];
  snprintf(ver, sizeof(ver), "-%s%s", PACKAGE_VERSION, GitVer);
  log_file_set_version(ver);
}

void mutt_log_stop(void)
{
  log_file_close(false);
  FREE(&CurrentFile);
}

int mutt_log_set_file(const char *file, bool verbose)
{
  if (mutt_str_strcmp(CurrentFile, C_DebugFile) != 0)
  {
    const char *name = rotate_logs(C_DebugFile, NumOfLogs);
    if (!name)
      return -1;

    log_file_set_filename(name, false);
    FREE(&name);
    mutt_str_replace(&CurrentFile, C_DebugFile);
  }

  cs_str_string_set(Config, "debug_file", file, NULL);

  return 0;
}

int mutt_log_set_level(int level, bool verbose)
{
  if (!CurrentFile)
    mutt_log_set_file(C_DebugFile, false);

  if (log_file_set_level(level, verbose) != 0)
    return -1;

  cs_str_native_set(Config, "debug_level", level, NULL);
  return 0;
}

int mutt_log_start(void)
{
  if (C_DebugLevel < 1)
    return 0;

  if (log_file_running())
    return 0;

  mutt_log_set_file(C_DebugFile, false);

  /* This will trigger the file creation */
  if (log_file_set_level(C_DebugLevel, true) < 0)
    return -1;

  return 0;
}

int level_validator(const struct ConfigSet *cs, const struct ConfigDef *cdef,
                    intptr_t value, struct Buffer *err)
{
  if ((value < 0) || (value >= LL_MAX))
  {
    mutt_buffer_printf(err, _("Invalid value for option %s: %ld"), cdef->name, value);
    return CSR_ERR_INVALID;
  }

  return CSR_SUCCESS;
}

int mutt_log_observer(struct NotifyCallback *nc)
{
  if (!nc)
    return -1;

  struct EventConfig *ec = (struct EventConfig *) nc->event;

  if (mutt_str_strcmp(ec->name, "debug_file") == 0)
    mutt_log_set_file(C_DebugFile, true);
  else if (mutt_str_strcmp(ec->name, "debug_level") == 0)
    mutt_log_set_level(C_DebugLevel, true);

  return 0;
}