common_logging.c File Reference

error handling API More...

#include "platform.h"
#include "gnunet_crypto_lib.h"
#include "gnunet_disk_lib.h"
#include "gnunet_strings_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 GNUNET_GE_KIND. More...
void	GNUNET_abort_ ()
	Abort the process, generate a core dump if possible. More...
static void	resize_logdefs ()
	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...
static int	setup_log_file (const struct tm *tm)
	Setup the log file. More...
static int	add_definition (const char *component, 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...
int	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...
void	__attribute__ ((constructor))
	Initializer. More...
void	__attribute__ ((destructor))
	Destructor. More...

Variables
static __thread 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 37 of file common_logging.c.

Referenced by mylog().

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 44 of file common_logging.c.

Referenced by mylog().

BULK_TRACK_SIZE

#define BULK_TRACK_SIZE   256

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

Definition at line 50 of file common_logging.c.

Referenced by flush_bulk().

COMP_TRACK_SIZE

#define COMP_TRACK_SIZE   32

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

Definition at line 56 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 62 of file common_logging.c.

Referenced by flush_bulk(), and mylog().

ROTATION_KEEP

#define ROTATION_KEEP   3

How many log files to keep?

Definition at line 67 of file common_logging.c.

Referenced by log_rotate().

PATH_MAX

#define PATH_MAX   4096

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

Definition at line 73 of file common_logging.c.

Referenced by setup_log_file().

LEN

#define LEN

Value:

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

Referenced by GNUNET_a2s().

Function Documentation

get_type()

static enum GNUNET_ErrorType get_type ( const char *  log )

static

Convert a textual description of a loglevel to the respective GNUNET_GE_KIND.

Parameters

log	loglevel to parse

Returns

GNUNET_GE_INVALID if log does not parse

Definition at line 253 of file common_logging.c.

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().

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

Here is the caller graph for this function:

resize_logdefs()

static void resize_logdefs ( )

static

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

Definition at line 288 of file common_logging.c.

References GNUNET_realloc, and logdefs_size.

Referenced by add_definition().

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

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.

References GNUNET_free, GNUNET_strdup, and ROTATION_KEEP.

Referenced by setup_log_file().

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

Here is the caller graph for this function:

setup_log_file()

static int 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 330 of file common_logging.c.

References fn, 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().

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

Here is the call graph for this function:

Here is the caller graph for this function:

add_definition()

static int add_definition ( const char *  component, 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 418 of file common_logging.c.

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

Referenced by parse_definitions().

{
  struct LogDef n;
  int r;

  if (logdefs_size == logdefs_len)
    resize_logdefs();
  memset(&n, 0, sizeof(n));
  if (0 == strlen(component))
    component = (char *)".*";
  r = regcomp(&n.component_regex, (const char *)component, 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_get_log_call_status()

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.

Used internally by GNUNET_log*()

Parameters

caller_level	loglevel the caller wants to use
comp	component name the caller uses (NULL means that global component name is used)
file	file name containing the logging call, usually FILE
function	function which tries to make a logging call, usually FUNCTION
line	line at which the call is made, usually LINE

Returns

0 to disallow the call, 1 to allow it

Definition at line 479 of file common_logging.c.

References component_nopid, LogDef::component_regex, LogDef::file_regex, LogDef::force, LogDef::from_line, LogDef::function_regex, GNUNET_ERROR_TYPE_MESSAGE, gnunet_force_log_present, GNUNET_NO, LogDef::level, logdefs_len, min_level, and LogDef::to_line.

Referenced by GCC_debug(), GCCH_debug(), GCT_debug(), and get_nick_record().

{
  struct LogDef *ld;
  int i;
  int force_only;

  if (NULL == comp)
    /* Use default component */
    comp = component_nopid;

  /* We have no definitions to override globally configured log level,
   * so just use it right away.
   */
  if ((min_level >= 0) && (GNUNET_NO == gnunet_force_log_present))
    return caller_level <= min_level;

  /* Only look for forced definitions? */
  force_only = min_level >= 0;
  for (i = 0; i < logdefs_len; i++)
    {
      ld = &logdefs[i];
      if (((!force_only) || ld->force) &&
          (line >= ld->from_line && line <= ld->to_line) &&
          (0 == regexec(&ld->component_regex, comp, 0, NULL, 0)) &&
          (0 == regexec(&ld->file_regex, file, 0, NULL, 0)) &&
          (0 == regexec(&ld->function_regex, function, 0, NULL, 0)))
        {
          /* We're finished */
          return caller_level <= ld->level;
        }
    }
  /* No matches - use global level, if defined */
  if (min_level >= 0)
    return caller_level <= min_level;
  /* All programs/services previously defaulted to WARNING.
   * Now *we* default to WARNING, and THEY default to NULL.
   * Or rather we default to MESSAGE, since things aren't always bad.
   */
  return caller_level <= GNUNET_ERROR_TYPE_MESSAGE;
}

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 549 of file common_logging.c.

References _, add_definition(), 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().

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

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 683 of file common_logging.c.

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

Referenced by GNUNET_log_setup().

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

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 805 of file common_logging.c.

References current_async_scope, end, 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, CustomLogger::next, GNUNET_AsyncScopeSave::scope_id, and skip_log.

Referenced by flush_bulk(), and mylog().

{
  struct CustomLogger *pos;

  /* 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", msg);
        }
      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;
          fprintf(GNUNET_stderr,
                  "%s %s(%s) %s %s",
                  datestr,
                  comp,
                  id_buf,
                  GNUNET_error_type_to_string(kind),
                  msg);
        }
      else
        {
          fprintf(GNUNET_stderr,
                  "%s %s %s %s",
                  datestr,
                  comp,
                  GNUNET_error_type_to_string(kind),
                  msg);
        }
      fflush(GNUNET_stderr);
    }
  pos = loggers;
  while (NULL != pos)
    {
      pos->logger(pos->logger_cls, kind, comp, datestr, msg);
      pos = pos->next;
    }
}

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 875 of file common_logging.c.

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().

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

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 960 of file common_logging.c.

References GNUNET_TIME_Absolute::abs_value_us, buf, 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().

{
  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;
        timeofday.tv_usec += (offset % 1000LL) * 1000LL;
        if (timeofday.tv_usec > 1000000LL)
          {
            timeofday.tv_usec -= 1000000LL;
            timeofday.tv_sec++;
          }
      }
    else
      {
        timeofday.tv_sec += offset / 1000LL;
        if (timeofday.tv_usec > -(offset % 1000LL) * 1000LL)
          {
            timeofday.tv_usec += (offset % 1000LL) * 1000LL;
          }
        else
          {
            timeofday.tv_usec += 1000000LL + (offset % 1000LL) * 1000LL;
            timeofday.tv_sec--;
          }
      }
    tmptr = localtime(&timeofday.tv_sec);
    if (NULL == tmptr)
      {
        strcpy(date, "localtime error");
      }
    else
      {
        if (0 == strftime(date2, DATE_STR_SIZE, "%b %d %H:%M:%S-%%06u", tmptr))
          abort();
        if (0 > snprintf(date, sizeof(date), date2, timeofday.tv_usec))
          abort();
      }

    vsnprintf(buf, size, message, va);
#if !(defined(GNUNET_CULL_LOGGING) || TALER_WALLET_ONLY)
    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);
  }
}

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 1055 of file common_logging.c.

References component, and mylog().

{
  va_list va;

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

Here is the call graph for this function:

GNUNET_async_scope_enter()

void GNUNET_async_scope_enter	(	const struct GNUNET_AsyncScopeId *	aid,
		struct GNUNET_AsyncScopeSave *	old_scope
	)

Set the async scope for the current thread.

Parameters

aid	the async scope identifier
old_scope[out]	location to save the old scope

Definition at line 1496 of file common_logging.c.

References current_async_scope, GNUNET_YES, GNUNET_AsyncScopeSave::have_scope, and GNUNET_AsyncScopeSave::scope_id.

Referenced by GNUNET_SCHEDULER_begin_async_scope(), and GNUNET_SCHEDULER_do_work().

{
  *old_scope = current_async_scope;
  current_async_scope.have_scope = GNUNET_YES;
  current_async_scope.scope_id = *aid;
}

Here is the caller graph for this function:

GNUNET_async_scope_restore()

void GNUNET_async_scope_restore

(

struct GNUNET_AsyncScopeSave *

old_scope

)

Clear the current thread's async scope.

Parameters

old_scope

scope to restore

Definition at line 1511 of file common_logging.c.

References current_async_scope.

Referenced by GNUNET_SCHEDULER_do_work().

{
  current_async_scope = *old_scope;
}

Here is the caller graph for this function:

GNUNET_async_scope_fresh()

void GNUNET_async_scope_fresh

(

struct GNUNET_AsyncScopeId *

aid_ret

)

Generate a fresh async scope identifier.

Parameters

[out]

aid_ret

pointer to where the result is stored

Definition at line 1523 of file common_logging.c.

References GNUNET_CRYPTO_QUALITY_WEAK, and GNUNET_CRYPTO_random_block().

{
  GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_WEAK,
                             aid_ret,
                             sizeof(struct GNUNET_AsyncScopeId));
}

Here is the call graph for this function:

GNUNET_async_scope_get()

void GNUNET_async_scope_get

(

struct GNUNET_AsyncScopeSave *

scope_ret

)

Get the current async scope.

Parameters

[out]

scope_ret

pointer to where the result is stored

Definition at line 1537 of file common_logging.c.

References current_async_scope.

Referenced by add_without_sets(), GNUNET_CURL_job_add2(), GNUNET_SCHEDULER_add_at_with_priority(), GNUNET_SCHEDULER_add_select(), GNUNET_SCHEDULER_add_shutdown(), and GNUNET_SCHEDULER_do_work().

{
  *scope_ret = current_async_scope;
}

Here is the caller graph for this function:

__attribute__() [1/2]

void __attribute__

(

(constructor)

)

Initializer.

Definition at line 1546 of file common_logging.c.

References GNUNET_stderr.

{
  GNUNET_stderr = stderr;
}

__attribute__() [2/2]

void __attribute__

(

(destructor)

)

Destructor.

Definition at line 1555 of file common_logging.c.

{

}

Variable Documentation

current_async_scope

__thread 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 216 of file common_logging.c.

logdefs_size

int logdefs_size

static

Allocated size of logdefs array (in units)

Definition at line 221 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 226 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 231 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 236 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 241 of file common_logging.c.

Referenced by GNUNET_get_log_call_status(), and parse_all_definitions().