common_logging.c File Reference

error handling API More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include <regex.h>

Include dependency graph for common_logging.c:

Go to the source code of this file.

Data Structures
struct	CustomLogger
	Linked list of active loggers. More...
struct	LogDef
	Represents a single logging definition. More...

Macros
#define	BULK_DELAY_THRESHOLD   (12 * 60 * 60 * 1000LL * 1000LL)
	After how many milliseconds do we always print that "message X was repeated N times"? Use 12h. More...
#define	BULK_REPEAT_THRESHOLD   1000
	After how many repetitions do we always print that "message X was repeated N times"? (even if we have not yet reached the delay threshold) More...
#define	BULK_TRACK_SIZE   256
	How many characters do we use for matching of bulk messages? More...
#define	COMP_TRACK_SIZE   32
	How many characters do we use for matching of bulk components? More...
#define	DATE_STR_SIZE   64
	How many characters can a date/time string be at most? More...
#define	ROTATION_KEEP   3
	How many log files to keep? More...
#define	PATH_MAX   4096
	Assumed maximum path length (for the log file name). More...
#define	LEN

Functions
static enum GNUNET_ErrorType	get_type (const char *log)
	Convert a textual description of a loglevel to the respective enumeration type. More...
void	GNUNET_abort_ ()
	Abort the process, generate a core dump if possible. More...
static void	resize_logdefs (void)
	Utility function - reallocates logdefs array to be twice as large. More...
static void	log_rotate (const char *new_name)
	Rotate logs, deleting the oldest log. More...
const char *	GNUNET_b2s (const void *buf, size_t buf_size)
	Convert a buffer to an 8-character string representative of the contents. More...
static enum GNUNET_GenericReturnValue	setup_log_file (const struct tm *tm)
	Setup the log file. More...
static int	add_definition (const char *lcomponent, const char *file, const char *function, int from_line, int to_line, int level, int force)
	Utility function - adds a parsed definition to logdefs array. More...
int	GNUNET_get_log_call_status (int caller_level, const char *comp, const char *file, const char *function, int line)
	Decides whether a particular logging call should or should not be allowed to be made. More...
static int	parse_definitions (const char *constname, int force)
	Utility function - parses a definition. More...
static void	parse_all_definitions ()
	Utility function - parses GNUNET_LOG and GNUNET_FORCE_LOG. More...
enum GNUNET_GenericReturnValue	GNUNET_log_setup (const char *comp, const char *loglevel, const char *logfile)
	Setup logging. More...
void	GNUNET_logger_add (GNUNET_Logger logger, void *logger_cls)
	Add a custom logger. More...
void	GNUNET_logger_remove (GNUNET_Logger logger, void *logger_cls)
	Remove a custom logger. More...
static void	output_message (enum GNUNET_ErrorType kind, const char *comp, const char *datestr, const char *msg)
	Actually output the log message. More...
static void	flush_bulk (const char *datestr)
	Flush an existing bulk report to the output. More...
void	GNUNET_log_skip (int n, int check_reset)
	Ignore the next n calls to the log function. More...
int	GNUNET_get_log_skip ()
	Get the number of log calls that are going to be skipped. More...
static void	mylog (enum GNUNET_ErrorType kind, const char *comp, const char *message, va_list va)
	Output a log message using the default mechanism. More...
void	GNUNET_log_nocheck (enum GNUNET_ErrorType kind, const char *message,...)
	Main log function. More...
void	GNUNET_log_from_nocheck (enum GNUNET_ErrorType kind, const char *comp, const char *message,...)
	Log function that specifies an alternative component. More...
const char *	GNUNET_error_type_to_string (enum GNUNET_ErrorType kind)
	Convert error type to string. More...
const char *	GNUNET_h2s (const struct GNUNET_HashCode *hc)
	Convert a hash to a string (for printing debug messages). More...
const char *	GNUNET_h2s2 (const struct GNUNET_HashCode *hc)
	Convert a hash to a string (for printing debug messages). More...
const char *	GNUNET_p2s (const struct GNUNET_CRYPTO_EddsaPublicKey *p)
	Convert a public key value to a string (for printing debug messages). More...
const char *	GNUNET_p2s2 (const struct GNUNET_CRYPTO_EddsaPublicKey *p)
	Convert a public key value to a string (for printing debug messages). More...
const char *	GNUNET_e2s (const struct GNUNET_CRYPTO_EcdhePublicKey *p)
	Convert a public key value to a string (for printing debug messages). More...
const char *	GNUNET_e2s2 (const struct GNUNET_CRYPTO_EcdhePublicKey *p)
	Convert a public key value to a string (for printing debug messages). More...
const char *	GNUNET_sh2s (const struct GNUNET_ShortHashCode *shc)
	Convert a short hash value to a string (for printing debug messages). More...
const char *	GNUNET_uuid2s (const struct GNUNET_Uuid *uuid)
	Convert a UUID to a string (for printing debug messages). More...
const char *	GNUNET_h2s_full (const struct GNUNET_HashCode *hc)
	Convert a hash to a string (for printing debug messages). More...
const char *	GNUNET_i2s (const struct GNUNET_PeerIdentity *pid)
	Convert a peer identity to a string (for printing debug messages). More...
const char *	GNUNET_i2s2 (const struct GNUNET_PeerIdentity *pid)
	Convert a peer identity to a string (for printing debug messages). More...
const char *	GNUNET_i2s_full (const struct GNUNET_PeerIdentity *pid)
	Convert a peer identity to a string (for printing debug messages). More...
const char *	GNUNET_a2s (const struct sockaddr *addr, socklen_t addrlen)
	Convert a "struct sockaddr*" (IPv4 or IPv6 address) to a string (for printing debug messages). More...
void	GNUNET_log_config_missing (enum GNUNET_ErrorType kind, const char *section, const char *option)
	Log error message about missing configuration option. More...
void	GNUNET_log_config_invalid (enum GNUNET_ErrorType kind, const char *section, const char *option, const char *required)
	Log error message about invalid configuration option value. More...
void	GNUNET_async_scope_enter (const struct GNUNET_AsyncScopeId *aid, struct GNUNET_AsyncScopeSave *old_scope)
	Set the async scope for the current thread. More...
void	GNUNET_async_scope_restore (struct GNUNET_AsyncScopeSave *old_scope)
	Clear the current thread's async scope. More...
void	GNUNET_async_scope_fresh (struct GNUNET_AsyncScopeId *aid_ret)
	Generate a fresh async scope identifier. More...
void	GNUNET_async_scope_get (struct GNUNET_AsyncScopeSave *scope_ret)
	Get the current async scope. More...
size_t	GNUNET_hex2b (const char *src, void *dst, size_t dstlen, int invert)
	Parse an ascii-encoded hexadecimal string into the buffer. More...
void	GNUNET_print_bytes (const void *buf, size_t buf_len, int fold, int in_be)
	Print a byte string in hexadecimal ascii notation. More...
void	GNUNET_util_cl_init (void)
void	__attribute__ ((constructor))
	Initializer. More...
void	GNUNET_util_cl_fini (void)
void	__attribute__ ((destructor))
	Destructor. More...

Variables
static GNUNET_THREAD_LOCAL struct GNUNET_AsyncScopeSave	current_async_scope
	Asynchronous scope of the current thread, or NULL if we have not entered an async scope yet. More...
static GNUNET_THREAD_LOCAL char last_bulk[256]	__nonstring
	The last "bulk" error message that we have been logging. More...
static GNUNET_THREAD_LOCAL enum GNUNET_ErrorType	last_bulk_kind
	Type of the last bulk message. More...
static GNUNET_THREAD_LOCAL struct GNUNET_TIME_Absolute	last_bulk_time
	Time of the last bulk error message (0 for none) More...
static GNUNET_THREAD_LOCAL unsigned int	last_bulk_repeat
	Number of times that bulk message has been repeated since. More...
static GNUNET_THREAD_LOCAL char	last_bulk_comp [32+1]
	Component when the last bulk was logged. More...
static char *	component
	Running component. More...
static char *	component_nopid
	Running component (without pid). More...
static char *	log_file_name
	Format string describing the name of the log file. More...
static enum GNUNET_ErrorType	min_level
	Minimum log level. More...
static struct CustomLogger *	loggers
	Linked list of our custom loggres. More...
static GNUNET_THREAD_LOCAL int	skip_log = 0
	Number of log calls to ignore. More...
static FILE *	GNUNET_stderr
	File descriptor to use for "stderr", or NULL for none. More...
static struct LogDef *	logdefs
	Dynamic array of logging definitions. More...
static int	logdefs_size
	Allocated size of logdefs array (in units) More...
static int	logdefs_len
	The number of units used in logdefs array. More...
static int	gnunet_log_parsed
	GNUNET_YES if GNUNET_LOG environment variable is already parsed. More...
static int	gnunet_force_log_parsed
	GNUNET_YES if GNUNET_FORCE_LOG environment variable is already parsed. More...
static int	gnunet_force_log_present
	GNUNET_YES if at least one definition with forced == 1 is available. More...

Detailed Description

error handling API

Author

Christian Grothoff

Definition in file common_logging.c.

Macro Definition Documentation

BULK_DELAY_THRESHOLD

#define BULK_DELAY_THRESHOLD   (12 * 60 * 60 * 1000LL * 1000LL)

After how many milliseconds do we always print that "message X was repeated N times"? Use 12h.

Definition at line 36 of file common_logging.c.

BULK_REPEAT_THRESHOLD

#define BULK_REPEAT_THRESHOLD   1000

After how many repetitions do we always print that "message X was repeated N times"? (even if we have not yet reached the delay threshold)

Definition at line 43 of file common_logging.c.

BULK_TRACK_SIZE

#define BULK_TRACK_SIZE   256

How many characters do we use for matching of bulk messages?

Definition at line 49 of file common_logging.c.

COMP_TRACK_SIZE

#define COMP_TRACK_SIZE   32

How many characters do we use for matching of bulk components?

Definition at line 55 of file common_logging.c.

DATE_STR_SIZE

#define DATE_STR_SIZE   64

How many characters can a date/time string be at most?

Definition at line 61 of file common_logging.c.

ROTATION_KEEP

#define ROTATION_KEEP   3

How many log files to keep?

Definition at line 66 of file common_logging.c.

PATH_MAX

#define PATH_MAX   4096

Assumed maximum path length (for the log file name).

Definition at line 72 of file common_logging.c.

LEN

#define LEN

Value:

        GNUNET_MAX ((INET6_ADDRSTRLEN + 8), \
                    (1 + sizeof(struct sockaddr_un) - sizeof(sa_family_t)))

Function Documentation

get_type()

static enum GNUNET_ErrorType get_type ( const char *  log )

static

Convert a textual description of a loglevel to the respective enumeration type.

Parameters

log	loglevel to parse

Returns

GNUNET_ERROR_TYPE_INVALID if log does not parse

Definition at line 254 of file common_logging.c.

{
  if (NULL == log)
    return GNUNET_ERROR_TYPE_UNSPECIFIED;
  if (0 == strcasecmp (log, "DEBUG"))
    return GNUNET_ERROR_TYPE_DEBUG;
  if (0 == strcasecmp (log, "INFO"))
    return GNUNET_ERROR_TYPE_INFO;
  if (0 == strcasecmp (log, "MESSAGE"))
    return GNUNET_ERROR_TYPE_MESSAGE;
  if (0 == strcasecmp (log, "WARNING"))
    return GNUNET_ERROR_TYPE_WARNING;
  if (0 == strcasecmp (log, "ERROR"))
    return GNUNET_ERROR_TYPE_ERROR;
  if (0 == strcasecmp (log, "NONE"))
    return GNUNET_ERROR_TYPE_NONE;
  return GNUNET_ERROR_TYPE_INVALID;
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_INVALID, GNUNET_ERROR_TYPE_MESSAGE, GNUNET_ERROR_TYPE_NONE, GNUNET_ERROR_TYPE_UNSPECIFIED, and GNUNET_ERROR_TYPE_WARNING.

Referenced by GNUNET_log_setup(), and parse_definitions().

Here is the caller graph for this function:

resize_logdefs()

static void resize_logdefs ( void  )

static

Utility function - reallocates logdefs array to be twice as large.

Definition at line 289 of file common_logging.c.

{
  logdefs_size = (logdefs_size + 1) * 2;
  logdefs = GNUNET_realloc (logdefs, logdefs_size * sizeof(struct LogDef));
}

References GNUNET_realloc, logdefs, and logdefs_size.

Referenced by add_definition().

Here is the caller graph for this function:

log_rotate()

static void log_rotate ( const char *  new_name )

static

Rotate logs, deleting the oldest log.

Parameters

new_name

new name to add to the rotation

Definition at line 302 of file common_logging.c.

{
  static char *rotation[ROTATION_KEEP];
  static unsigned int rotation_off;
  char *discard;
 
  if ('\0' == *new_name)
    return; /* not a real log file name */
  discard = rotation[rotation_off % ROTATION_KEEP];
  if (NULL != discard)
  {
    /* Note: can't log errors during logging (recursion!), so this
       operation MUST silently fail... */
    (void) unlink (discard);
    GNUNET_free (discard);
  }
  rotation[rotation_off % ROTATION_KEEP] = GNUNET_strdup (new_name);
  rotation_off++;
}

References GNUNET_free, GNUNET_strdup, and ROTATION_KEEP.

Referenced by setup_log_file().

Here is the caller graph for this function:

setup_log_file()

static enum GNUNET_GenericReturnValue setup_log_file ( const struct tm *  tm )

static

Setup the log file.

Parameters

tm	timestamp for which we should setup logging

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 352 of file common_logging.c.

{
  static char last_fn[PATH_MAX + 1];
  char fn[PATH_MAX + 1];
  int altlog_fd;
  int dup_return;
  FILE *altlog;
  char *leftsquare;
 
  if (NULL == log_file_name)
    return GNUNET_SYSERR;
  if (0 == strftime (fn, sizeof(fn), log_file_name, tm))
    return GNUNET_SYSERR;
  leftsquare = strrchr (fn, '[');
  if ((NULL != leftsquare) && (']' == leftsquare[1]))
  {
    char *logfile_copy = GNUNET_strdup (fn);
 
    logfile_copy[leftsquare - fn] = '\0';
    logfile_copy[leftsquare - fn + 1] = '\0';
    snprintf (fn,
              PATH_MAX,
              "%s%d%s",
              logfile_copy,
              getpid (),
              &logfile_copy[leftsquare - fn + 2]);
    GNUNET_free (logfile_copy);
  }
  if (0 == strcmp (fn, last_fn))
    return GNUNET_OK; /* no change */
  log_rotate (last_fn);
  strcpy (last_fn, fn);
  if (GNUNET_SYSERR == GNUNET_DISK_directory_create_for_file (fn))
  {
    fprintf (stderr,
             "Failed to create directory for `%s': %s\n",
             fn,
             strerror (errno));
    return GNUNET_SYSERR;
  }
  altlog_fd = open (fn,
                    O_APPEND | O_WRONLY | O_CREAT,
                    S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
 
  if (-1 != altlog_fd)
  {
    if (NULL != GNUNET_stderr)
      fclose (GNUNET_stderr);
    dup_return = dup2 (altlog_fd, 2);
    (void) close (altlog_fd);
    if (-1 != dup_return)
    {
      altlog = fdopen (2, "ab");
      if (NULL == altlog)
      {
        (void) close (2);
        altlog_fd = -1;
      }
    }
    else
    {
      altlog_fd = -1;
    }
  }
  if (-1 == altlog_fd)
  {
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", fn);
    return GNUNET_SYSERR;
  }
  GNUNET_stderr = altlog;
  return GNUNET_OK;
}

References GNUNET_DISK_directory_create_for_file(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log_strerror_file, GNUNET_OK, GNUNET_stderr, GNUNET_strdup, GNUNET_SYSERR, log_file_name, log_rotate(), and PATH_MAX.

Referenced by GNUNET_log_setup(), and mylog().

Here is the call graph for this function:

Here is the caller graph for this function:

add_definition()

static int add_definition ( const char *  lcomponent, const char *  file, const char *  function, int  from_line, int  to_line, int  level, int  force  )

static

Utility function - adds a parsed definition to logdefs array.

Parameters

component	see struct LogDef, can't be NULL
file	see struct LogDef, can't be NULL
function	see struct LogDef, can't be NULL
from_line	see struct LogDef
to_line	see struct LogDef
level	see struct LogDef, must be >= 0
force	see struct LogDef

Returns

0 on success, regex-specific error otherwise

Definition at line 439 of file common_logging.c.

{
  struct LogDef n;
  int r;
 
  if (logdefs_size == logdefs_len)
    resize_logdefs ();
  memset (&n, 0, sizeof(n));
  if (0 == strlen (lcomponent))
    lcomponent = (char *) ".*";
  r = regcomp (&n.component_regex, (const char *) lcomponent, REG_NOSUB);
  if (0 != r)
  {
    return r;
  }
  if (0 == strlen (file))
    file = (char *) ".*";
  r = regcomp (&n.file_regex, (const char *) file, REG_NOSUB);
  if (0 != r)
  {
    regfree (&n.component_regex);
    return r;
  }
  if ((NULL == function) || (0 == strlen (function)))
    function = (char *) ".*";
  r = regcomp (&n.function_regex, (const char *) function, REG_NOSUB);
  if (0 != r)
  {
    regfree (&n.component_regex);
    regfree (&n.file_regex);
    return r;
  }
  n.from_line = from_line;
  n.to_line = to_line;
  n.level = level;
  n.force = force;
  logdefs[logdefs_len++] = n;
  return 0;
}

References LogDef::component_regex, LogDef::file_regex, LogDef::force, LogDef::from_line, LogDef::function_regex, LogDef::level, logdefs, logdefs_len, logdefs_size, resize_logdefs(), and LogDef::to_line.

Referenced by parse_definitions().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_definitions()

static int parse_definitions ( const char *  constname, int  force  )

static

Utility function - parses a definition.

Definition format: component;file;function;from_line-to_line;level[/component...] All entries are mandatory, but may be empty. Empty entries for component, file and function are treated as "matches anything". Empty line entry is treated as "from 0 to INT_MAX" Line entry with only one line is treated as "this line only" Entry for level MUST NOT be empty. Entries for component, file and function that consist of a single character "*" are treated (at the moment) the same way empty entries are treated (wildcard matching is not implemented (yet?)). file entry is matched to the end of FILE. That is, it might be a base name, or a base name with leading directory names (some compilers define FILE to absolute file path).

Parameters

constname	name of the environment variable from which to get the string to be parsed
force	1 if definitions found in constname are to be forced

Returns

number of added definitions

Definition at line 570 of file common_logging.c.

{
  char *def;
  const char *tmp;
  char *comp = NULL;
  char *file = NULL;
  char *function = NULL;
  char *p;
  char *start;
  char *t;
  short state;
  int level;
  int from_line, to_line;
  int counter = 0;
  int keep_looking = 1;
 
  tmp = getenv (constname);
  if (NULL == tmp)
    return 0;
  def = GNUNET_strdup (tmp);
  from_line = 0;
  to_line = INT_MAX;
  for (p = def, state = 0, start = def; keep_looking; p++)
  {
    switch (p[0])
    {
    case ';':     /* found a field separator */
      p[0] = '\0';
      switch (state)
      {
      case 0:       /* within a component name */
        comp = start;
        break;
 
      case 1:       /* within a file name */
        file = start;
        break;
 
      case 2:       /* within a function name */
        /* after a file name there must be a function name */
        function = start;
        break;
 
      case 3:       /* within a from-to line range */
        if (strlen (start) > 0)
        {
          errno = 0;
          from_line = strtol (start, &t, 10);
          if ((0 != errno) || (from_line < 0))
          {
            GNUNET_free (def);
            return counter;
          }
          if ((t < p) && ('-' == t[0]))
          {
            errno = 0;
            start = t + 1;
            to_line = strtol (start, &t, 10);
            if ((0 != errno) || (to_line < 0) || (t != p))
            {
              GNUNET_free (def);
              return counter;
            }
          }
          else         /* one number means "match this line only" */
            to_line = from_line;
        }
        else       /* default to 0-max */
        {
          from_line = 0;
          to_line = INT_MAX;
        }
        break;
 
      default:
        fprintf (
          stderr,
          _ ("ERROR: Unable to parse log definition: Syntax error at `%s'.\n"),
          p);
        break;
      }
      start = p + 1;
      state++;
      break;
 
    case '\0':     /* found EOL */
      keep_looking = 0;
 
    /* fall through to '/' */
    case '/':     /* found a definition separator */
      switch (state)
      {
      case 4:       /* within a log level */
        p[0] = '\0';
        state = 0;
        level = get_type ((const char *) start);
        if ((GNUNET_ERROR_TYPE_INVALID == level) ||
            (GNUNET_ERROR_TYPE_UNSPECIFIED == level) ||
            (0 != add_definition (comp,
                                  file,
                                  function,
                                  from_line,
                                  to_line,
                                  level,
                                  force)))
        {
          GNUNET_free (def);
          return counter;
        }
        counter++;
        start = p + 1;
        break;
 
      default:
        fprintf (
          stderr,
          _ ("ERROR: Unable to parse log definition: Syntax error at `%s'.\n"),
          p);
        break;
      }
 
    default:
      break;
    }
  }
  GNUNET_free (def);
  return counter;
}

References _, add_definition(), LogDef::force, LogDef::from_line, get_type(), getenv(), GNUNET_ERROR_TYPE_INVALID, GNUNET_ERROR_TYPE_UNSPECIFIED, GNUNET_free, GNUNET_strdup, INT_MAX, LogDef::level, p, start, state, t, and LogDef::to_line.

Referenced by parse_all_definitions().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_all_definitions()

static void parse_all_definitions ( )

static

Utility function - parses GNUNET_LOG and GNUNET_FORCE_LOG.

Definition at line 704 of file common_logging.c.

{
  if (GNUNET_NO == gnunet_force_log_parsed)
    gnunet_force_log_present =
      parse_definitions ("GNUNET_FORCE_LOG", 1) > 0 ? GNUNET_YES : GNUNET_NO;
  gnunet_force_log_parsed = GNUNET_YES;
 
  if (GNUNET_NO == gnunet_log_parsed)
    parse_definitions ("GNUNET_LOG", 0);
  gnunet_log_parsed = GNUNET_YES;
}

References gnunet_force_log_parsed, gnunet_force_log_present, gnunet_log_parsed, GNUNET_NO, GNUNET_YES, and parse_definitions().

Referenced by GNUNET_log_setup().

Here is the call graph for this function:

Here is the caller graph for this function:

output_message()

static void output_message ( enum GNUNET_ErrorType  kind, const char *  comp, const char *  datestr, const char *  msg  )

static

Actually output the log message.

Parameters

kind	how severe was the issue
comp	component responsible
datestr	current date/time
msg	the actual message

Definition at line 820 of file common_logging.c.

{
  static int have_journald = -1;
  struct CustomLogger *pos;
  const char *optional_newline = "\n";
 
  if ((strlen (msg) > 0) &&
      ('\n' == msg[strlen (msg) - 1]))
    optional_newline = "";
 
  if (-1 == have_journald)
  {
    /* systemd after version 231 sets this environment
       variable if we are logging to journald. In this
       case, skip outputting our component name, PID
       and timestamp as journald already adds those. (#8032) */
    if (NULL != getenv ("JOURNAL_STREAM"))
      have_journald = 1;
    else
      have_journald = 0;
  }
 
  /* only use the standard logger if no custom loggers are present */
  if ((NULL != GNUNET_stderr) && (NULL == loggers))
  {
    if (kind == GNUNET_ERROR_TYPE_MESSAGE)
    {
      /* The idea here is to produce "normal" output messages
       * for end users while still having the power of the
       * logging engine for developer needs. So ideally this
       * is what it should look like when CLI tools are used
       * interactively, yet the same message shouldn't look
       * this way if the output is going to logfiles or robots
       * instead.
       */
      fprintf (GNUNET_stderr, "* %s%s", msg, optional_newline);
    }
    else if (GNUNET_YES == current_async_scope.have_scope)
    {
      static GNUNET_THREAD_LOCAL char id_buf[27];
      char *end;
 
      /* We're logging, so skip_log must be currently 0. */
      skip_log = 100;
      end = GNUNET_STRINGS_data_to_string (&current_async_scope.scope_id,
                                           sizeof(struct GNUNET_AsyncScopeId),
                                           id_buf,
                                           sizeof(id_buf) - 1);
      GNUNET_assert (NULL != end);
      *end = '\0';
      skip_log = 0;
      if (have_journald)
        fprintf (GNUNET_stderr,
                 "(%s) %s %s%s",
                 id_buf,
                 GNUNET_error_type_to_string (kind),
                 msg,
                 optional_newline);
      else
        fprintf (GNUNET_stderr,
                 "%s %s(%s) %s %s%s",
                 datestr,
                 comp,
                 id_buf,
                 GNUNET_error_type_to_string (kind),
                 msg,
                 optional_newline);
    }
    else
    {
      if (have_journald)
        fprintf (GNUNET_stderr,
                 "%s %s%s",
                 GNUNET_error_type_to_string (kind),
                 msg,
                 optional_newline);
      else
        fprintf (GNUNET_stderr,
                 "%s %s %s %s%s",
                 datestr,
                 comp,
                 GNUNET_error_type_to_string (kind),
                 msg,
                 optional_newline);
    }
    fflush (GNUNET_stderr);
  }
  pos = loggers;
  while (NULL != pos)
  {
    pos->logger (pos->logger_cls, kind, comp, datestr, msg);
    pos = pos->next;
  }
}

References current_async_scope, end, getenv(), GNUNET_assert, GNUNET_ERROR_TYPE_MESSAGE, GNUNET_error_type_to_string(), GNUNET_stderr, GNUNET_STRINGS_data_to_string(), GNUNET_THREAD_LOCAL, GNUNET_YES, GNUNET_AsyncScopeSave::have_scope, CustomLogger::logger, CustomLogger::logger_cls, loggers, msg, CustomLogger::next, GNUNET_AsyncScopeSave::scope_id, and skip_log.

Referenced by flush_bulk(), and mylog().

Here is the call graph for this function:

Here is the caller graph for this function:

flush_bulk()

static void flush_bulk ( const char *  datestr )

static

Flush an existing bulk report to the output.

Parameters

datestr

our current timestamp

Definition at line 925 of file common_logging.c.

{
  char msg[DATE_STR_SIZE + BULK_TRACK_SIZE + 256];
  int rev;
  char *last;
  const char *ft;
 
  if ((0 == last_bulk_time.abs_value_us) || (0 == last_bulk_repeat))
    return;
  rev = 0;
  last = memchr (last_bulk, '\0', BULK_TRACK_SIZE);
  if (last == NULL)
    last = &last_bulk[BULK_TRACK_SIZE - 1];
  else if (last != last_bulk)
    last--;
  if (last[0] == '\n')
  {
    rev = 1;
    last[0] = '\0';
  }
  ft =
    GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (
                                              last_bulk_time),
                                            GNUNET_YES);
  snprintf (msg,
            sizeof(msg),
            _ ("Message `%.*s' repeated %u times in the last %s\n"),
            BULK_TRACK_SIZE,
            last_bulk,
            last_bulk_repeat,
            ft);
  if (rev == 1)
    last[0] = '\n';
  output_message (last_bulk_kind, last_bulk_comp, datestr, msg);
  last_bulk_time = GNUNET_TIME_absolute_get ();
  last_bulk_repeat = 0;
}

References _, GNUNET_TIME_Absolute::abs_value_us, BULK_TRACK_SIZE, DATE_STR_SIZE, GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_duration(), GNUNET_YES, last_bulk_comp, last_bulk_kind, last_bulk_repeat, last_bulk_time, msg, and output_message().

Referenced by mylog().

Here is the call graph for this function:

Here is the caller graph for this function:

mylog()

static void mylog ( enum GNUNET_ErrorType  kind, const char *  comp, const char *  message, va_list  va  )

static

Output a log message using the default mechanism.

Parameters

kind	how severe was the issue
comp	component responsible
message	the actual message
va	arguments to the format string "message"

Definition at line 1004 of file common_logging.c.

{
  char date[DATE_STR_SIZE];
  char date2[DATE_STR_SIZE];
  struct tm *tmptr;
  size_t size;
  va_list vacp;
 
  va_copy (vacp, va);
  size = vsnprintf (NULL, 0, message, vacp) + 1;
  GNUNET_assert (0 != size);
  va_end (vacp);
  memset (date, 0, DATE_STR_SIZE);
  {
    char buf[size];
    long long offset;
 
    struct timeval timeofday;
 
    gettimeofday (&timeofday, NULL);
    offset = GNUNET_TIME_get_offset ();
    if (offset > 0)
    {
      timeofday.tv_sec += offset / 1000LL / 1000LL;
      timeofday.tv_usec += (offset % 1000000LL) * 1000000LL;
      if (timeofday.tv_usec > 1000000LL)
      {
        timeofday.tv_usec -= 1000000LL;
        timeofday.tv_sec++;
      }
    }
    else
    {
      timeofday.tv_sec += offset / 1000LL / 1000LL;
      if (timeofday.tv_usec > -(offset % 1000000LL) * 1000000LL)
      {
        timeofday.tv_usec += (offset % 1000000LL) * 1000000LL;
      }
      else
      {
        timeofday.tv_usec += 1000000LL + (offset % 1000000LL) * 1000000LL;
        timeofday.tv_sec--;
      }
    }
    tmptr = localtime (&timeofday.tv_sec);
    if (NULL == tmptr)
    {
      strcpy (date, "localtime error");
    }
    else
    {
      /* RFC 3339 timestamp, with snprintf placeholder for microseconds */
      if (0 == strftime (date2, DATE_STR_SIZE, "%Y-%m-%dT%H:%M:%S.%%06u%z",
                         tmptr))
        abort ();
      /* Fill in microseconds */
      if (0 > snprintf (date, sizeof(date), date2, timeofday.tv_usec))
        abort ();
    }
 
    vsnprintf (buf, size, message, va);
#if ! defined(GNUNET_CULL_LOGGING)
    if (NULL != tmptr)
      (void) setup_log_file (tmptr);
#endif
    if ((0 != (kind & GNUNET_ERROR_TYPE_BULK)) &&
        (0 != last_bulk_time.abs_value_us) &&
        (0 == strncmp (buf, last_bulk, sizeof(last_bulk))))
    {
      last_bulk_repeat++;
      if ((GNUNET_TIME_absolute_get_duration (last_bulk_time).rel_value_us >
           BULK_DELAY_THRESHOLD) ||
          (last_bulk_repeat > BULK_REPEAT_THRESHOLD))
        flush_bulk (date);
      return;
    }
    flush_bulk (date);
    GNUNET_strlcpy (last_bulk, buf, sizeof(last_bulk));
    last_bulk_repeat = 0;
    last_bulk_kind = kind;
    last_bulk_time = GNUNET_TIME_absolute_get ();
    GNUNET_strlcpy (last_bulk_comp, comp, sizeof(last_bulk_comp));
    output_message (kind, comp, date, buf);
  }
}

References GNUNET_TIME_Absolute::abs_value_us, BULK_DELAY_THRESHOLD, BULK_REPEAT_THRESHOLD, DATE_STR_SIZE, flush_bulk(), GNUNET_assert, GNUNET_ERROR_TYPE_BULK, GNUNET_strlcpy(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_get_offset(), last_bulk_comp, last_bulk_kind, last_bulk_repeat, last_bulk_time, output_message(), GNUNET_TIME_Relative::rel_value_us, setup_log_file(), and size.

Referenced by GNUNET_log_from_nocheck(), and GNUNET_log_nocheck().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_log_nocheck()

void GNUNET_log_nocheck	(	enum GNUNET_ErrorType	kind,
		const char *	message,
			...
	)

Main log function.

Parameters

kind	how serious is the error?
message	what is the message (format string)
...	arguments for format string

Definition at line 1102 of file common_logging.c.

{
  va_list va;
 
  va_start (va, message);
  mylog (kind, component, message, va);
  va_end (va);
}

References component, and mylog().

Here is the call graph for this function:

GNUNET_log_from_nocheck()

void GNUNET_log_from_nocheck	(	enum GNUNET_ErrorType	kind,
		const char *	comp,
		const char *	message,
			...
	)

Log function that specifies an alternative component.

This function should be used by plugins.

Parameters

kind	how serious is the error?
comp	component responsible for generating the message
message	what is the message (format string)
...	arguments for format string

Definition at line 1122 of file common_logging.c.

{
  va_list va;
  char comp_w_pid[128];
 
  if (comp == NULL)
    comp = component_nopid;
 
  va_start (va, message);
  GNUNET_snprintf (comp_w_pid, sizeof(comp_w_pid), "%s-%d", comp, getpid ());
  mylog (kind, comp_w_pid, message, va);
  va_end (va);
}

References component_nopid, GNUNET_snprintf(), and mylog().

Here is the call graph for this function:

GNUNET_util_cl_init()

void GNUNET_util_cl_init

(

void

)

__attribute__() [1/2]

void __attribute__

(

(constructor)

)

Initializer.

Definition at line 1584 of file common_logging.c.

{
  GNUNET_stderr = stderr;
}

References GNUNET_stderr.

GNUNET_util_cl_fini()

void GNUNET_util_cl_fini

(

void

)

__attribute__() [2/2]

void __attribute__

(

(destructor)

)

Destructor.

Definition at line 1597 of file common_logging.c.

{
 
}

Variable Documentation

current_async_scope

GNUNET_THREAD_LOCAL struct GNUNET_AsyncScopeSave current_async_scope

static

Asynchronous scope of the current thread, or NULL if we have not entered an async scope yet.

Definition at line 102 of file common_logging.c.

Referenced by GNUNET_async_scope_enter(), GNUNET_async_scope_get(), GNUNET_async_scope_restore(), and output_message().

__nonstring

GNUNET_THREAD_LOCAL char last_bulk [ 256 ] __nonstring

static

The last "bulk" error message that we have been logging.

Note that this message maybe truncated to the first BULK_TRACK_SIZE characters, in which case it is NOT 0-terminated!

Definition at line 109 of file common_logging.c.

last_bulk_kind

GNUNET_THREAD_LOCAL enum GNUNET_ErrorType last_bulk_kind

static

Type of the last bulk message.

Definition at line 114 of file common_logging.c.

Referenced by flush_bulk(), and mylog().

last_bulk_time

GNUNET_THREAD_LOCAL struct GNUNET_TIME_Absolute last_bulk_time

static

Time of the last bulk error message (0 for none)

Definition at line 119 of file common_logging.c.

Referenced by flush_bulk(), and mylog().

last_bulk_repeat

GNUNET_THREAD_LOCAL unsigned int last_bulk_repeat

static

Number of times that bulk message has been repeated since.

Definition at line 124 of file common_logging.c.

Referenced by flush_bulk(), and mylog().

last_bulk_comp

GNUNET_THREAD_LOCAL char last_bulk_comp[32+1]

static

Component when the last bulk was logged.

Will be 0-terminated.

Definition at line 129 of file common_logging.c.

Referenced by flush_bulk(), and mylog().

component

char* component

static

Running component.

Definition at line 134 of file common_logging.c.

Referenced by GNUNET_log_nocheck(), and GNUNET_log_setup().

component_nopid

char* component_nopid

static

Running component (without pid).

Definition at line 139 of file common_logging.c.

Referenced by GNUNET_get_log_call_status(), GNUNET_log_from_nocheck(), and GNUNET_log_setup().

log_file_name

char* log_file_name

static

Format string describing the name of the log file.

Definition at line 144 of file common_logging.c.

Referenced by GNUNET_log_setup(), and setup_log_file().

min_level

enum GNUNET_ErrorType min_level

static

Minimum log level.

Definition at line 149 of file common_logging.c.

Referenced by GNUNET_get_log_call_status(), and GNUNET_log_setup().

loggers

struct CustomLogger* loggers

static

Linked list of our custom loggres.

Definition at line 154 of file common_logging.c.

Referenced by GNUNET_logger_add(), GNUNET_logger_remove(), and output_message().

skip_log

GNUNET_THREAD_LOCAL int skip_log = 0

static

Number of log calls to ignore.

Definition at line 159 of file common_logging.c.

Referenced by GNUNET_get_log_skip(), GNUNET_log_skip(), and output_message().

GNUNET_stderr

FILE* GNUNET_stderr

static

File descriptor to use for "stderr", or NULL for none.

Definition at line 164 of file common_logging.c.

Referenced by __attribute__(), output_message(), and setup_log_file().

logdefs

struct LogDef* logdefs

static

Dynamic array of logging definitions.

Definition at line 217 of file common_logging.c.

Referenced by add_definition(), GNUNET_get_log_call_status(), and resize_logdefs().

logdefs_size

int logdefs_size

static

Allocated size of logdefs array (in units)

Definition at line 222 of file common_logging.c.

Referenced by add_definition(), and resize_logdefs().

logdefs_len

int logdefs_len

static

The number of units used in logdefs array.

Definition at line 227 of file common_logging.c.

Referenced by add_definition(), and GNUNET_get_log_call_status().

gnunet_log_parsed

int gnunet_log_parsed

static

GNUNET_YES if GNUNET_LOG environment variable is already parsed.

Definition at line 232 of file common_logging.c.

Referenced by parse_all_definitions().

gnunet_force_log_parsed

int gnunet_force_log_parsed

static

GNUNET_YES if GNUNET_FORCE_LOG environment variable is already parsed.

Definition at line 237 of file common_logging.c.

Referenced by parse_all_definitions().

gnunet_force_log_present

int gnunet_force_log_present

static

GNUNET_YES if at least one definition with forced == 1 is available.

Definition at line 242 of file common_logging.c.

Referenced by GNUNET_get_log_call_status(), and parse_all_definitions().