logging.c File Reference

Logging Dispatcher. More...

#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 "date.h"
#include "file.h"
#include "logging2.h"
#include "memory.h"
#include "message.h"
#include "queue.h"
#include "string2.h"

Include dependency graph for logging.c:

Go to the source code of this file.

Functions
static const char *	timestamp (time_t stamp)
	Create a YYYY-MM-DD HH:MM:SS timestamp.
void	log_file_close (bool verbose)
	Close the log file.
int	log_file_open (bool verbose)
	Start logging to a file.
int	log_file_set_filename (const char *file, bool verbose)
	Set the filename for the log.
int	log_file_set_level (enum LogLevel level, bool verbose)
	Set the logging level.
void	log_file_set_version (const char *version)
	Set the program's version number.
bool	log_file_running (void)
	Is the log file running?
int	log_disp_file (time_t stamp, const char *file, int line, const char *function, enum LogLevel level, const char *format,...)
	Save a log line to a file - Implements log_dispatcher_t -.
int	log_queue_add (struct LogLine *ll)
	Add a LogLine to the queue.
void	log_queue_set_max_size (int size)
	Set a upper limit for the queue length.
void	log_queue_empty (void)
	Free the contents of the queue.
void	log_queue_flush (log_dispatcher_t disp)
	Replay the log queue.
int	log_queue_save (FILE *fp)
	Save the contents of the queue to a temporary file.
int	log_disp_queue (time_t stamp, const char *file, int line, const char *function, enum LogLevel level, const char *format,...)
	Save a log line to an internal queue - Implements log_dispatcher_t -.
int	log_disp_terminal (time_t stamp, const char *file, int line, const char *function, enum LogLevel level, const char *format,...)
	Save a log line to the terminal - Implements log_dispatcher_t -.
void	log_multiline_full (enum LogLevel level, const char *str, const char *file, int line, const char *func)
	Helper to dump multiline text to the log.

Variables
const char *	LevelAbbr = "PEWM12345N"
	Abbreviations of logging level names.
log_dispatcher_t	MuttLogger = log_disp_terminal
	The log dispatcher -.
static FILE *	LogFileFP = NULL
	Log file handle.
static char *	LogFileName = NULL
	Log file name.
static int	LogFileLevel = 0
	Log file level.
static char *	LogFileVersion = NULL
	Program version.
static struct LogLineList	LogQueue = STAILQ_HEAD_INITIALIZER(LogQueue)
	In-memory list of log lines.
static int	LogQueueCount = 0
	Number of entries currently in the log queue.
static int	LogQueueMax = 0
	Maximum number of entries in the log queue.

Detailed Description

Logging Dispatcher.

Authors

• Richard Russon
• Pietro Cerutti

Copyright

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.

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, see http://www.gnu.org/licenses/.

Definition in file logging.c.

Function Documentation

timestamp()

static const char * timestamp ( time_t  stamp )

static

Create a YYYY-MM-DD HH:MM:SS timestamp.

Parameters

stamp

Unix time

Return values

ptr	Timestamp string

If stamp is 0, then the current time will be used.

Note

This function returns a pointer to a static buffer. Do not free it.

Definition at line 78 of file logging.c.

{
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

log_file_close()

void log_file_close

(

bool

verbose

)

Close the log file.

Parameters

verbose

If true, then log the event

Definition at line 99 of file logging.c.

{
  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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

log_file_open()

int log_file_open

(

bool

verbose

)

Start logging to a file.

Parameters

verbose

If true, then log the event

Return values

0	Success
-1	Error, see errno

Before opening a log file, call log_file_set_version(), log_file_set_level() and log_file_set_filename().

Definition at line 120 of file logging.c.

{
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

log_file_set_filename()

int log_file_set_filename	(	const char *	file,
		bool	verbose
	)

Set the filename for the log.

Parameters

file	Name to use
verbose	If true, then log the event

Return values

0	Success, file opened
-1	Error, see errno

Definition at line 150 of file logging.c.

{
  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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

log_file_set_level()

int log_file_set_level	(	enum LogLevel	level,
		bool	verbose
	)

Set the logging level.

Parameters

level	Logging level
verbose	If true, then log the event

Return values

0	Success
-1	Error, level is out of range

The level should be: LL_MESSAGE <= level < LL_MAX.

Definition at line 176 of file logging.c.

{
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

log_file_set_version()

void log_file_set_version

(

const char *

version

)

Set the program's version number.

Parameters

version

Version number

The string will be appended directly to 'NeoMutt', so it should begin with a hyphen.

Definition at line 221 of file logging.c.

{
  mutt_str_replace(&LogFileVersion, version);
}

Here is the call graph for this function:

Here is the caller graph for this function:

log_file_running()

bool log_file_running

(

void

)

Is the log file running?

Return values

true	The log file is running

Definition at line 230 of file logging.c.

{
  return LogFileFP;
}

Here is the caller graph for this function:

log_queue_add()

int log_queue_add

(

struct LogLine *

ll

)

Add a LogLine to the queue.

Parameters

ll	LogLine to add

Return values

num	Entries in the queue

If LogQueueMax is non-zero, the queue will be limited to this many items.

Definition at line 285 of file logging.c.

{
  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;
}

Here is the caller graph for this function:

log_queue_set_max_size()

void log_queue_set_max_size

(

int

size

)

Set a upper limit for the queue length.

Parameters

size	New maximum queue length

Note

size of 0 means unlimited

Definition at line 312 of file logging.c.

{
  if (size < 0)
    size = 0;
  LogQueueMax = size;
}

Here is the caller graph for this function:

log_queue_empty()

void log_queue_empty

(

void

)

Free the contents of the queue.

Free any log lines in the queue.

Definition at line 324 of file logging.c.

{
  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;
}

Here is the caller graph for this function:

log_queue_flush()

void log_queue_flush

(

log_dispatcher_t

disp

)

Replay the log queue.

Parameters

disp	Log dispatcher - Implements log_dispatcher_t

Pass all of the log entries in the queue to the log dispatcher provided. The queue will be emptied afterwards.

Definition at line 346 of file logging.c.

{
  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();
}

Here is the call graph for this function:

Here is the caller graph for this function:

log_queue_save()

int log_queue_save

(

FILE *

fp

)

Save the contents of the queue to a temporary file.

Parameters

fp	Open file handle

Return values

num	Lines written to the file

The queue is written to a temporary file. The format is:

• [HH:MM:SS]<LEVEL> FORMATTED-MESSAGE

Note

The caller should delete the file

Definition at line 367 of file logging.c.

{
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

log_multiline_full()

void log_multiline_full	(	enum LogLevel	level,
		const char *	str,
		const char *	file,
		int	line,
		const char *	func
	)

Helper to dump multiline text to the log.

Parameters

level	Logging level, e.g. LL_DEBUG1
str	Text to save
file	Source file
line	Source line number
func	Source function

Definition at line 502 of file logging.c.

{
  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;
    }
  }
}

Variable Documentation

LevelAbbr

const char* LevelAbbr = "PEWM12345N"

Abbreviations of logging level names.

Definition at line 46 of file logging.c.

LogFileFP

FILE* LogFileFP = NULL

static

Log file handle.

Definition at line 55 of file logging.c.

LogFileName

char* LogFileName = NULL

static

Log file name.

Definition at line 56 of file logging.c.

LogFileLevel

int LogFileLevel = 0

static

Log file level.

Definition at line 57 of file logging.c.

LogFileVersion

char* LogFileVersion = NULL

static

Program version.

Definition at line 58 of file logging.c.

LogQueue

struct LogLineList LogQueue = STAILQ_HEAD_INITIALIZER(LogQueue)

static

In-memory list of log lines.

Definition at line 63 of file logging.c.

LogQueueCount

int LogQueueCount = 0

static

Number of entries currently in the log queue.

Definition at line 65 of file logging.c.

LogQueueMax

int LogQueueMax = 0

static

Maximum number of entries in the log queue.

Definition at line 66 of file logging.c.