code/logging_8c_source.html

 #include "config.h"
 #include <errno.h>
 #include <stdarg.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <string.h>
 #include <time.h>
 #include <unistd.h>
 #include "logging.h"
 #include "date.h"
 #include "file.h"
 #include "memory.h"
 #include "message.h"
 #include "queue.h"
 #include "string2.h"

 const char *LevelAbbr = "PEWM12345N";

 log_dispatcher_t MuttLogger = log_disp_terminal;

 FILE *LogFileFP = NULL;
 char *LogFileName = NULL;
 int LogFileLevel = 0;
 char *LogFileVersion = NULL;

 static struct LogLineList LogQueue = STAILQ_HEAD_INITIALIZER(LogQueue);

 int LogQueueCount = 0;
 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_epoch();

   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, ...)
 {
   if (!LogFileFP || (level < LL_PERROR) || (level > LogFileLevel))
     return 0;

   int ret = 0;
   int err = errno;

   if (!function)
     function = "UNKNOWN";

   ret += fprintf(LogFileFP, "[%s]<%c> %s() ", timestamp(stamp),
                  LevelAbbr[level + 3], function);

   va_list ap;
   va_start(ap, level);
   const char *fmt = va_arg(ap, const char *);
   ret += vfprintf(LogFileFP, fmt, ap);
   va_end(ap);

   if (level == LL_PERROR)
   {
     fprintf(LogFileFP, ": %s\n", strerror(err));
   }
   else if (level <= LL_MESSAGE)
   {
     fputs("\n", LogFileFP);
     ret++;
   }

   return ret;
 }

 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];
   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, ...)
 {
   char buf[1024] = { 0 };
   int err = errno;

   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)
   {
     ret += snprintf(buf + ret, sizeof(buf) - ret, ": %s", strerror(err));
     level = LL_ERROR;
   }

   struct LogLine *ll = mutt_mem_calloc(1, sizeof(*ll));
   ll->time = (stamp != 0) ? stamp : mutt_date_epoch();
   ll->file = file;
   ll->line = line;
   ll->function = function;
   ll->level = level;
   ll->message = mutt_str_dup(buf);

   log_queue_add(ll);

   return ret;
 }

 int log_disp_terminal(time_t stamp, const char *file, int line,
                       const char *function, enum LogLevel level, ...)
 {
   if ((level < LL_PERROR) || (level > LL_MESSAGE))
     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);

   log_disp_file(stamp, file, line, function, level, "%s", buf);

   FILE *fp = (level < LL_MESSAGE) ? stderr : stdout;
   int err = errno;
   int colour = 0;
   bool tty = (isatty(fileno(fp)) == 1);

   if (tty)
   {
     switch (level)
     {
       case LL_PERROR:
       case LL_ERROR:
         colour = 31;
         break;
       case LL_WARNING:
         colour = 33;
         break;
       case LL_MESSAGE:
         // colour = 36;
         break;
       case LL_DEBUG1:
       case LL_DEBUG2:
       case LL_DEBUG3:
       case LL_DEBUG4:
       case LL_DEBUG5:
       case LL_NOTIFY:
       default:
         break;
     }
   }

   if (colour > 0)
     ret += fprintf(fp, "\033[1;%dm", colour); // Escape

   fputs(buf, fp);

   if (level == LL_PERROR)
     ret += fprintf(fp, ": %s", strerror(err));

   if (colour > 0)
     ret += fprintf(fp, "\033[0m"); // Escape

   ret += fprintf(fp, "\n");

   return ret;
 }

 int log_disp_null(time_t stamp, const char *file, int line,
                   const char *function, enum LogLevel level, ...)
 {
   return 0;
 }
log_disp_null
int log_disp_null(time_t stamp, const char *file, int line, const char *function, enum LogLevel level,...)
Discard log lines - Implements log_dispatcher_t.
Definition: logging.c:506

mutt_str_equal
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:871

mutt_date_epoch
time_t mutt_date_epoch(void)
Return the number of seconds since the Unix epoch.
Definition: date.c:416

LL_DEBUG4
Log at debug level 4.
Definition: logging.h:43

LL_ERROR
Log error.
Definition: logging.h:37

log_file_close
void log_file_close(bool verbose)
Close the log file.
Definition: logging.c:98

NONULL
#define NONULL(x)
Definition: string2.h:37

mutt_mem_calloc
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:50

STAILQ_REMOVE
#define STAILQ_REMOVE(head, elm, type, field)
Definition: queue.h:399

mutt_date_localtime_format
size_t mutt_date_localtime_format(char *buf, size_t buflen, const char *format, time_t t)
Format localtime.
Definition: date.c:680

LogLine::level
enum LogLevel level
Log level, e.g. LL_DEBUG1.
Definition: logging.h:75

memory.h
Memory management wrappers.

LL_NOTIFY
Log of notifications.
Definition: logging.h:45

LevelAbbr
const char * LevelAbbr
Abbreviations of logging level names.
Definition: logging.c:45

mutt_message
#define mutt_message(...)
Definition: logging.h:83

LogLine::message
char * message
Message to be logged.
Definition: logging.h:76

LogFileFP
FILE * LogFileFP
Log file handle.
Definition: logging.c:54

LogQueue
static struct LogLineList LogQueue
In-memory list of log lines.
Definition: logging.c:62

log_disp_terminal
int log_disp_terminal(time_t stamp, const char *file, int line, const char *function, enum LogLevel level,...)
Save a log line to the terminal - Implements log_dispatcher_t.
Definition: logging.c:441

LL_PERROR
Log perror (using errno)
Definition: logging.h:36

mutt_str_dup
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:370

_
#define _(a)
Definition: message.h:28

timestamp
static const char * timestamp(time_t stamp)
Create a YYYY-MM-DD HH:MM:SS timestamp.
Definition: logging.c:77

LL_MAX
Definition: logging.h:47

STAILQ_INSERT_TAIL
#define STAILQ_INSERT_TAIL(head, elm, field)
Definition: queue.h:386

LL_MESSAGE
Log informational message.
Definition: logging.h:39

STAILQ_REMOVE_HEAD
#define STAILQ_REMOVE_HEAD(head, field)
Definition: queue.h:419

LogQueueMax
int LogQueueMax
Maximum number of entries in the log queue.
Definition: logging.c:65

log_queue_flush
void log_queue_flush(log_dispatcher_t disp)
Replay the log queue.
Definition: logging.c:348

MuttLogger
log_dispatcher_t MuttLogger
The log dispatcher.
Definition: logging.c:52

log_file_set_version
void log_file_set_version(const char *version)
Set the program&#39;s version number.
Definition: logging.c:221

file.h
File management functions.

log_file_set_filename
int log_file_set_filename(const char *file, bool verbose)
Set the filename for the log.
Definition: logging.c:149

logging.h
Logging Dispatcher.

string2.h
String manipulation functions.

LogLine::line
int line
Line number in source file.
Definition: logging.h:73

LogLevel
LogLevel
Names for the Logging Levels.
Definition: logging.h:34

LL_DEBUG2
Log at debug level 2.
Definition: logging.h:41

LogLine
A Log line.
Definition: logging.h:69

mutt_file_fclose
int mutt_file_fclose(FILE **fp)
Close a FILE handle (and NULL the pointer)
Definition: file.c:153

log_disp_file
int log_disp_file(time_t stamp, const char *file, int line, const char *function, enum LogLevel level,...)
Save a log line to a file - Implements log_dispatcher_t.
Definition: logging.c:246

queue.h

STAILQ_FOREACH_SAFE
#define STAILQ_FOREACH_SAFE(var, head, field, tvar)
Definition: queue.h:359

log_file_set_level
int log_file_set_level(enum LogLevel level, bool verbose)
Set the logging level.
Definition: logging.c:175

message.h
Message logging.

log_queue_set_max_size
void log_queue_set_max_size(int size)
Set a upper limit for the queue length.
Definition: logging.c:314

log_file_running
bool log_file_running(void)
Is the log file running?
Definition: logging.c:230

log_file_open
int log_file_open(bool verbose)
Start logging to a file.
Definition: logging.c:119

log_queue_save
int log_queue_save(FILE *fp)
Save the contents of the queue to a temporary file.
Definition: logging.c:369

log_queue_empty
void log_queue_empty(void)
Free the contents of the queue.
Definition: logging.c:326

STAILQ_FOREACH
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:349

LL_DEBUG1
Log at debug level 1.
Definition: logging.h:40

log_dispatcher_t
int(* log_dispatcher_t)(time_t stamp, const char *file, int line, const char *function, enum LogLevel level,...)
Prototype for a logging function.
Definition: logging.h:62

mutt_str_replace
char * mutt_str_replace(char **p, const char *s)
Replace one string with another.
Definition: string.c:446

FREE
#define FREE(x)
Definition: memory.h:40

STAILQ_HEAD_INITIALIZER
#define STAILQ_HEAD_INITIALIZER(head)
Definition: queue.h:321

LogLine::time
time_t time
Timestamp of the message.
Definition: logging.h:71

LogFileLevel
int LogFileLevel
Log file level.
Definition: logging.c:56

LogFileVersion
char * LogFileVersion
Program version.
Definition: logging.c:57

LL_DEBUG5
Log at debug level 5.
Definition: logging.h:44

mutt_file_fopen
FILE * mutt_file_fopen(const char *path, const char *mode)
Call fopen() safely.
Definition: file.c:588

LogQueueCount
int LogQueueCount
Number of entries currently in the log queue.
Definition: logging.c:64

log_disp_queue
int log_disp_queue(time_t stamp, const char *file, int line, const char *function, enum LogLevel level,...)
Save a log line to an internal queue - Implements log_dispatcher_t.
Definition: logging.c:400

date.h
Time and date handling routines.

LogLine::file
const char * file
Source file.
Definition: logging.h:72

log_queue_add
int log_queue_add(struct LogLine *ll)
Add a LogLine to the queue.
Definition: logging.c:287

STAILQ_FIRST
#define STAILQ_FIRST(head)
Definition: queue.h:347

LL_DEBUG3
Log at debug level 3.
Definition: logging.h:42

LL_WARNING
Log warning.
Definition: logging.h:38

LogLine::function
const char * function
C function.
Definition: logging.h:74

LogFileName
char * LogFileName
Log file name.
Definition: logging.c:55