Greenbone Vulnerability Management Libraries  10.0.0
logging.c File Reference

Implementation of logging methods. More...

#include "logging.h"
#include <errno.h>
#include <libgen.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>
#include <time.h>
#include <unistd.h>
Include dependency graph for logging.c:

Go to the source code of this file.

Data Structures

struct  gvm_logging_t
 Logging stores the parameters loaded from a log configuration. More...
 

Macros

#define SYSLOG_NAMES
 

Functions

gchar * get_time (gchar *time_fmt)
 Returns time as specified in time_fmt strftime format. More...
 
static gint level_int_from_string (const gchar *level)
 Return the integer corresponding to a log level string. More...
 
static gint facility_int_from_string (const gchar *facility)
 Return the integer corresponding to a syslog facility string. More...
 
GSList * load_log_configuration (gchar *config_file)
 Loads parameters from a config file into a linked list. More...
 
void free_log_configuration (GSList *log_domain_list)
 Frees all resources loaded by the config loader. More...
 
void gvm_log_silent (const char *log_domain, GLogLevelFlags log_level, const char *message, gpointer gvm_log_config_list)
 Returns immediately. More...
 
static void gvm_log_lock_init (void)
 Initialize logger_mutex mutex if it was not done before. More...
 
static void gvm_log_lock (void)
 Try to lock logger_mutex. More...
 
static void gvm_log_unlock (void)
 Unlock logger_mutex. More...
 
void gvm_log_func (const char *log_domain, GLogLevelFlags log_level, const char *message, gpointer gvm_log_config_list)
 Creates the formatted string and outputs it to the log destination. More...
 
void log_func_for_gnutls (int level, const char *message)
 This function logs debug messages from gnutls. More...
 
void setup_log_handlers (GSList *gvm_log_config_list)
 Sets up routing of logdomains to log handlers. More...
 

Variables

static GMutex * logger_mutex = NULL
 

Detailed Description

Implementation of logging methods.

This file contains all methods needed for logging. To enable logging, methods in this file are called.

The module reuses glib datatypes and api for memory management and logging.

Definition in file logging.c.

Macro Definition Documentation

◆ SYSLOG_NAMES

#define SYSLOG_NAMES

Definition at line 37 of file logging.c.

Function Documentation

◆ facility_int_from_string()

static gint facility_int_from_string ( const gchar *  facility)
static

Return the integer corresponding to a syslog facility string.

Parameters
facilityFacility name.
Returns
Facility integer if facility matches a facility name, else LOG_LOCAL0.

Definition at line 129 of file logging.c.

130 {
131  if (facility && strlen (facility) > 0)
132  {
133  int i = 0;
134  while (facilitynames[i].c_name != NULL)
135  {
136  if (g_ascii_strcasecmp (facility, facilitynames[i].c_name) == 0)
137  return facilitynames[i].c_val;
138  i++;
139  }
140  }
141  return LOG_LOCAL0;
142 }

Referenced by gvm_log_func().

Here is the caller graph for this function:

◆ free_log_configuration()

void free_log_configuration ( GSList *  log_domain_list)

Frees all resources loaded by the config loader.

Parameters
log_domain_listHead of the link list.

Definition at line 283 of file logging.c.

284 {
285  GSList *log_domain_list_tmp;
286 
287  /* Free the struct fields then the struct and then go the next
288  * item in the link list.
289  */
290 
291  /* Go to the head of the list. */
292  log_domain_list_tmp = log_domain_list;
293  while (log_domain_list_tmp != NULL)
294  {
295  gvm_logging_t *log_domain_entry;
296 
297  /* Get the list data which is an gvm_logging_t struct. */
298  log_domain_entry = log_domain_list_tmp->data;
299 
300  /* Free the struct contents. */
301  g_free (log_domain_entry->log_domain);
302  g_free (log_domain_entry->prepend_string);
303  g_free (log_domain_entry->prepend_time_format);
304  g_free (log_domain_entry->log_file);
305  g_free (log_domain_entry->default_level);
306  g_free (log_domain_entry->syslog_ident);
307  g_free (log_domain_entry->prepend_separator);
308 
309  /* Drop the reference to the GIOChannel. */
310  if (log_domain_entry->log_channel)
311  g_io_channel_unref (log_domain_entry->log_channel);
312 
313  /* Free the struct. */
314  g_free (log_domain_entry);
315 
316  /* Go to the next item. */
317  log_domain_list_tmp = g_slist_next (log_domain_list_tmp);
318  }
319  /* Free the link list. */
320  g_slist_free (log_domain_list);
321 }
gchar * prepend_time_format
If prependstring has t, format for strftime.
Definition: logging.c:52
gchar * prepend_string
Prepend this string before every message.
Definition: logging.c:51
Logging stores the parameters loaded from a log configuration.
Definition: logging.c:48
GIOChannel * log_channel
Gio Channel - FD holder for logfile.
Definition: logging.c:55
gchar * log_domain
Affected logdomain e.g libnasl.
Definition: logging.c:50
gchar * log_file
Where to log to.
Definition: logging.c:53
gchar * syslog_ident
Syslog ident to use for syslog logging.
Definition: logging.c:57
gchar * prepend_separator
Definition: logging.c:58
GLogLevelFlags * default_level
What severity level to use as default.
Definition: logging.c:54

References gvm_logging_t::default_level, gvm_logging_t::log_channel, gvm_logging_t::log_domain, gvm_logging_t::log_file, gvm_logging_t::prepend_separator, gvm_logging_t::prepend_string, gvm_logging_t::prepend_time_format, and gvm_logging_t::syslog_ident.

◆ get_time()

gchar* get_time ( gchar *  time_fmt)

Returns time as specified in time_fmt strftime format.

Parameters
time_fmtptr to the string format to use. The strftime man page documents the conversion specification. An example time_fmt string is "%Y-%m-%d %H:%M:%S".
Returns
NULL in case the format string is NULL. A ptr to a string that contains the formatted date time value. This value must be freed using glib's g_free.

Definition at line 74 of file logging.c.

75 {
76  time_t now;
77  struct tm *ts;
78  gchar buf[80];
79 
80  /* Get the current time. */
81  now = time (NULL);
82 
83  /* Format and print the time, "ddd yyyy-mm-dd hh:mm:ss zzz." */
84  ts = localtime (&now);
85  strftime (buf, sizeof (buf), time_fmt, ts);
86 
87  return g_strdup_printf ("%s", buf);
88 }

Referenced by gvm_log_func().

Here is the caller graph for this function:

◆ gvm_log_func()

void gvm_log_func ( const char *  log_domain,
GLogLevelFlags  log_level,
const char *  message,
gpointer  gvm_log_config_list 
)

Creates the formatted string and outputs it to the log destination.

Parameters
log_domainA string containing the message's log domain.
log_levelFlags defining the message's log level.
messageA string containing the log message.
gvm_log_config_listA pointer to the configuration linked list.

Definition at line 384 of file logging.c.

386 {
387  gchar *prepend;
388  gchar *prepend_buf;
389  gchar *prepend_tmp;
390  gchar *prepend_tmp1;
391  gchar *tmp;
392  gchar *tmpstr;
393  int messagelen;
394 
395  /* For link list operations. */
396  GSList *log_domain_list_tmp;
397  gvm_logging_t *log_domain_entry = NULL;
398 
399  /* Channel to log through. */
400  GIOChannel *channel;
401  GError *error = NULL;
402 
403  /* The default parameters to be used. The group '*' will override
404  * these defaults if it's found.
405  */
406  gchar *prepend_format = "%t %s %p - ";
407  gchar *time_format = "%Y-%m-%d %Hh%M.%S %Z";
408  gchar *log_separator = ":";
409  gchar *log_file = "-";
410  GLogLevelFlags default_level = G_LOG_LEVEL_DEBUG;
411  channel = NULL;
412  gchar *syslog_facility = "local0";
413  gchar *syslog_ident = NULL;
414 
415  /* Initialize logger lock if not done. */
417 
418  /* Let's load the default configuration file directives from the
419  * linked list. Scanning the link list twice is inefficient but
420  * leaves the source cleaner.
421  */
422  if (gvm_log_config_list != NULL && log_domain != NULL)
423  {
424  /* Go to the head of the list. */
425  log_domain_list_tmp = (GSList *) gvm_log_config_list;
426 
427  while (log_domain_list_tmp != NULL)
428  {
429  gvm_logging_t *entry;
430 
431  entry = log_domain_list_tmp->data;
432 
433  /* Override defaults if the current linklist group name is '*'. */
434  if (g_ascii_strcasecmp (entry->log_domain, "*") == 0)
435  {
436  /* Get the list data for later use. */
437  log_domain_entry = entry;
438 
439  /* Override defaults if the group items are not null. */
440  if (log_domain_entry->prepend_string)
441  prepend_format = log_domain_entry->prepend_string;
442  if (log_domain_entry->prepend_time_format)
443  time_format = log_domain_entry->prepend_time_format;
444  if (log_domain_entry->log_file)
445  log_file = log_domain_entry->log_file;
446  if (log_domain_entry->default_level)
447  default_level = *log_domain_entry->default_level;
448  if (log_domain_entry->log_channel)
449  channel = log_domain_entry->log_channel;
450  if (log_domain_entry->syslog_facility)
451  syslog_facility = log_domain_entry->syslog_facility;
452  if (log_domain_entry->prepend_separator)
453  log_separator = log_domain_entry->prepend_separator;
454  break;
455  }
456 
457  /* Go to the next item. */
458  log_domain_list_tmp = g_slist_next (log_domain_list_tmp);
459  }
460  }
461 
462  /* Let's load the configuration file directives if a linked list item for
463  * the log domain group exists.
464  */
465  if (gvm_log_config_list != NULL && log_domain != NULL)
466  {
467  /* Go to the head of the list. */
468  log_domain_list_tmp = (GSList *) gvm_log_config_list;
469 
470  while (log_domain_list_tmp != NULL)
471  {
472  gvm_logging_t *entry;
473 
474  entry = log_domain_list_tmp->data;
475 
476  /* Search for the log domain in the link list. */
477  if (g_ascii_strcasecmp (entry->log_domain, log_domain) == 0)
478  {
479  /* Get the list data which is an gvm_logging_t struct. */
480  log_domain_entry = entry;
481 
482  /* Get the struct contents. */
483  prepend_format = log_domain_entry->prepend_string;
484  time_format = log_domain_entry->prepend_time_format;
485  log_file = log_domain_entry->log_file;
486  if (log_domain_entry->default_level)
487  default_level = *log_domain_entry->default_level;
488  channel = log_domain_entry->log_channel;
489  syslog_facility = log_domain_entry->syslog_facility;
490  syslog_ident = log_domain_entry->syslog_ident;
491  if (log_domain_entry->prepend_separator)
492  log_separator = log_domain_entry->prepend_separator;
493  break;
494  }
495 
496  /* Go to the next item. */
497  log_domain_list_tmp = g_slist_next (log_domain_list_tmp);
498  }
499  }
500 
501  /* If the current log entry is less severe than the specified log level,
502  * let's exit.
503  */
504  if (default_level < log_level)
505  return;
506 
507  /* Prepend buf is a newly allocated empty string. Makes life easier. */
508  prepend_buf = g_strdup ("");
509 
510  /* Make the tmp pointer (for iteration) point to the format string. */
511  tmp = prepend_format;
512 
513  while (*tmp != '\0')
514  {
515  /* If the current char is a % and the next one is a p, get the pid. */
516  if ((*tmp == '%') && (*(tmp + 1) == 'p'))
517  {
518  /* Use g_strdup, a new string returned. Store it in a tmp var until
519  * we free the old one. */
520  prepend_tmp = g_strdup_printf ("%s%d", prepend_buf, (int) getpid ());
521  /* Free the old string. */
522  g_free (prepend_buf);
523  /* Point the buf ptr to the new string. */
524  prepend_buf = prepend_tmp;
525  /* Skip over the two chars we've processed '%p'. */
526  tmp += 2;
527  }
528  else if ((*tmp == '%') && (*(tmp + 1) == 't'))
529  {
530  /* Get time returns a newly allocated string.
531  * Store it in a tmp var.
532  */
533  prepend_tmp1 = get_time (time_format);
534  /* Use g_strdup. New string returned. Store it in a tmp var until
535  * we free the old one.
536  */
537  prepend_tmp = g_strdup_printf ("%s%s", prepend_buf, prepend_tmp1);
538  /* Free the time tmp var. */
539  g_free (prepend_tmp1);
540  /* Free the old string. */
541  g_free (prepend_buf);
542  /* Point the buf ptr to the new string. */
543  prepend_buf = prepend_tmp;
544  /* Skip over the two chars we've processed '%t.' */
545  tmp += 2;
546  }
547  else if ((*tmp == '%') && (*(tmp + 1) == 's'))
548  {
549  /* Use g_strdup. New string returned. Store it in a tmp var until
550  * we free the old one.
551  */
552  prepend_tmp = g_strdup_printf ("%s%s", prepend_buf, log_separator);
553  /* Free the old string. */
554  g_free (prepend_buf);
555  /* Point the buf ptr to the new string. */
556  prepend_buf = prepend_tmp;
557  /* Skip over the two chars we've processed '%s.' */
558  tmp += 2;
559  }
560  else
561  {
562  /* Jump to the next character. */
563  tmp++;
564  }
565  }
566 
567  /* Step through all possible messages prefixing them with an appropriate
568  * tag.
569  */
570  switch (log_level)
571  {
572  case G_LOG_FLAG_RECURSION:
573  prepend = g_strdup_printf ("RECURSION%s%s", log_separator, prepend_buf);
574  break;
575 
576  case G_LOG_FLAG_FATAL:
577  prepend = g_strdup_printf ("FATAL%s%s", log_separator, prepend_buf);
578  break;
579 
580  case G_LOG_LEVEL_ERROR:
581  prepend = g_strdup_printf ("ERROR%s%s", log_separator, prepend_buf);
582  break;
583 
584  case G_LOG_LEVEL_CRITICAL:
585  prepend = g_strdup_printf ("CRITICAL%s%s", log_separator, prepend_buf);
586  break;
587 
588  case G_LOG_LEVEL_WARNING:
589  prepend = g_strdup_printf ("WARNING%s%s", log_separator, prepend_buf);
590  break;
591 
592  case G_LOG_LEVEL_MESSAGE:
593  prepend = g_strdup_printf ("MESSAGE%s%s", log_separator, prepend_buf);
594  break;
595 
596  case G_LOG_LEVEL_INFO:
597  prepend = g_strdup_printf (" INFO%s%s", log_separator, prepend_buf);
598  break;
599 
600  case G_LOG_LEVEL_DEBUG:
601  prepend = g_strdup_printf (" DEBUG%s%s", log_separator, prepend_buf);
602  break;
603 
604  default:
605  prepend = g_strdup_printf ("UNKNOWN%s%s", log_separator, prepend_buf);
606  break;
607  }
608 
609  /* If the current log entry is more severe than the specified log
610  * level, print out the message. In case MESSAGE already ends in a
611  * LF and there is not only the LF, remove the LF to avoid empty
612  * lines in the log.
613  */
614  messagelen = message ? strlen (message) : 0;
615  if (messagelen > 1 && message[messagelen - 1] == '\n')
616  messagelen--;
617  tmpstr = g_strdup_printf ("%s%s%s%s %.*s\n", log_domain ? log_domain : "",
618  log_separator, prepend, log_separator, messagelen,
619  message);
620  g_free (prepend);
621 
622  gvm_log_lock ();
623  /* Output everything to stderr if logfile is "-". */
624  if (g_ascii_strcasecmp (log_file, "-") == 0)
625  {
626  fprintf (stderr, "%s", tmpstr);
627  fflush (stderr);
628  }
629  /* Output everything to syslog if logfile is "syslog" */
630  else if (g_ascii_strcasecmp (log_file, "syslog") == 0)
631  {
632  int facility = facility_int_from_string (syslog_facility);
633  int syslog_level = LOG_INFO;
634 
635  openlog (syslog_ident, LOG_CONS | LOG_PID | LOG_NDELAY, facility);
636 
637  switch (log_level)
638  {
639  case G_LOG_FLAG_FATAL:
640  syslog_level = LOG_ALERT;
641  break;
642  case G_LOG_LEVEL_ERROR:
643  syslog_level = LOG_ERR;
644  break;
645  case G_LOG_LEVEL_CRITICAL:
646  syslog_level = LOG_CRIT;
647  break;
648  case G_LOG_LEVEL_WARNING:
649  syslog_level = LOG_WARNING;
650  break;
651  case G_LOG_LEVEL_MESSAGE:
652  syslog_level = LOG_NOTICE;
653  break;
654  case G_LOG_LEVEL_INFO:
655  syslog_level = LOG_INFO;
656  break;
657  case G_LOG_LEVEL_DEBUG:
658  syslog_level = LOG_DEBUG;
659  break;
660  default:
661  syslog_level = LOG_INFO;
662  break;
663  }
664 
665  syslog (syslog_level, "%s", message);
666 
667  closelog ();
668  }
669  else
670  {
671  /* Open a channel and store it in the struct or
672  * retrieve and use an already existing channel.
673  */
674  if (channel == NULL)
675  {
676  channel = g_io_channel_new_file (log_file, "a", &error);
677  if (!channel)
678  {
679  gchar *log = g_strdup (log_file);
680  gchar *dir = dirname (log);
681 
682  /* Check error. In case of the directory does not exist, it will
683  * be handle below. In other case a message is printed to the
684  * stderr since the channel is still not created/accessible.
685  */
686  if (error->code != G_FILE_ERROR_NOENT)
687  fprintf (stderr, "Can not open '%s' logfile: %s\n", log_file,
688  error->message);
689  g_error_free (error);
690 
691  /* Ensure directory exists. */
692  if (g_mkdir_with_parents (dir, 0755)) /* "rwxr-xr-x" */
693  {
694  g_warning ("Failed to create log file directory %s: %s", dir,
695  strerror (errno));
696  g_free (log);
697  g_free (tmpstr);
698  g_free (prepend_buf);
699  return;
700  }
701  g_free (log);
702 
703  /* Try again. */
704  error = NULL;
705  channel = g_io_channel_new_file (log_file, "a", &error);
706  if (!channel)
707  {
708  g_error ("Can not open '%s' logfile: %s", log_file,
709  error->message);
710  }
711  }
712 
713  /* Store it in the struct for later use. */
714  if (log_domain_entry != NULL)
715  log_domain_entry->log_channel = channel;
716  }
717  g_io_channel_write_chars (channel, (const gchar *) tmpstr, -1, NULL,
718  &error);
719  g_io_channel_flush (channel, NULL);
720  }
721  gvm_log_unlock ();
722  g_free (tmpstr);
723  g_free (prepend_buf);
724 }
gchar * prepend_time_format
If prependstring has t, format for strftime.
Definition: logging.c:52
static void gvm_log_unlock(void)
Unlock logger_mutex.
Definition: logging.c:370
gchar * prepend_string
Prepend this string before every message.
Definition: logging.c:51
gchar * syslog_facility
Syslog facility to use for syslog logging.
Definition: logging.c:56
Logging stores the parameters loaded from a log configuration.
Definition: logging.c:48
GIOChannel * log_channel
Gio Channel - FD holder for logfile.
Definition: logging.c:55
gchar * log_domain
Affected logdomain e.g libnasl.
Definition: logging.c:50
static gint facility_int_from_string(const gchar *facility)
Return the integer corresponding to a syslog facility string.
Definition: logging.c:129
static void gvm_log_lock_init(void)
Initialize logger_mutex mutex if it was not done before.
Definition: logging.c:348
gchar * log_file
Where to log to.
Definition: logging.c:53
gchar * syslog_ident
Syslog ident to use for syslog logging.
Definition: logging.c:57
gchar * prepend_separator
Definition: logging.c:58
GLogLevelFlags * default_level
What severity level to use as default.
Definition: logging.c:54
static void gvm_log_lock(void)
Try to lock logger_mutex.
Definition: logging.c:361
gchar * get_time(gchar *time_fmt)
Returns time as specified in time_fmt strftime format.
Definition: logging.c:74

References gvm_logging_t::default_level, facility_int_from_string(), get_time(), gvm_log_lock(), gvm_log_lock_init(), gvm_log_unlock(), gvm_logging_t::log_channel, gvm_logging_t::log_domain, gvm_logging_t::log_file, gvm_logging_t::prepend_separator, gvm_logging_t::prepend_string, gvm_logging_t::prepend_time_format, gvm_logging_t::syslog_facility, and gvm_logging_t::syslog_ident.

Referenced by setup_log_handlers().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ gvm_log_lock()

static void gvm_log_lock ( void  )
static

Try to lock logger_mutex.

Definition at line 361 of file logging.c.

362 {
363  g_mutex_lock (logger_mutex);
364 }
static GMutex * logger_mutex
Definition: logging.c:342

References logger_mutex.

Referenced by gvm_log_func().

Here is the caller graph for this function:

◆ gvm_log_lock_init()

static void gvm_log_lock_init ( void  )
static

Initialize logger_mutex mutex if it was not done before.

Definition at line 348 of file logging.c.

349 {
350  if (logger_mutex == NULL)
351  {
352  logger_mutex = g_malloc (sizeof (*logger_mutex));
353  g_mutex_init (logger_mutex);
354  }
355 }
static GMutex * logger_mutex
Definition: logging.c:342

References logger_mutex.

Referenced by gvm_log_func().

Here is the caller graph for this function:

◆ gvm_log_silent()

void gvm_log_silent ( const char *  log_domain,
GLogLevelFlags  log_level,
const char *  message,
gpointer  gvm_log_config_list 
)

Returns immediately.

Parameters
log_domainA string containing the message's log domain.
log_levelFlags defining the message's log level.
messageA string containing the log message.
gvm_log_config_listA pointer to the configuration linked list.

Definition at line 332 of file logging.c.

334 {
335  (void) log_domain;
336  (void) log_level;
337  (void) message;
338  (void) gvm_log_config_list;
339  return;
340 }

◆ gvm_log_unlock()

static void gvm_log_unlock ( void  )
static

Unlock logger_mutex.

Definition at line 370 of file logging.c.

371 {
372  g_mutex_unlock (logger_mutex);
373 }
static GMutex * logger_mutex
Definition: logging.c:342

References logger_mutex.

Referenced by gvm_log_func().

Here is the caller graph for this function:

◆ level_int_from_string()

static gint level_int_from_string ( const gchar *  level)
static

Return the integer corresponding to a log level string.

Parameters
levelLevel name or integer.
Returns
Log level integer if level matches a level name, else 0.

Definition at line 98 of file logging.c.

99 {
100  if (level && strlen (level) > 0)
101  {
102  if (level[0] >= '0' && level[0] <= '9')
103  return atoi (level);
104  if (strcasecmp (level, "critical") == 0)
105  return G_LOG_LEVEL_CRITICAL;
106  if (strcasecmp (level, "debug") == 0)
107  return G_LOG_LEVEL_DEBUG;
108  if (strcasecmp (level, "error") == 0)
109  return G_LOG_LEVEL_ERROR;
110  if (strcasecmp (level, "info") == 0)
111  return G_LOG_LEVEL_INFO;
112  if (strcasecmp (level, "message") == 0)
113  return G_LOG_LEVEL_MESSAGE;
114  if (strcasecmp (level, "warning") == 0)
115  return G_LOG_LEVEL_WARNING;
116  }
117  return 0;
118 }

Referenced by load_log_configuration().

Here is the caller graph for this function:

◆ load_log_configuration()

GSList* load_log_configuration ( gchar *  config_file)

Loads parameters from a config file into a linked list.

Parameters
config_fileA string containing the path to the configuration file to load.
Returns
NULL in case the config file could not be loaded or an error occurred otherwise, a singly linked list of parameter groups is returned.

Definition at line 155 of file logging.c.

156 {
157  GKeyFile *key_file;
158  GKeyFileFlags flags;
159  GError *error = NULL;
160  /* key_file *_has_* functions requires this. */
161 
162  // FIXME: If a g_* function that takes error fails, then free error.
163 
164  /* Groups found in the conf file. */
165  gchar **groups;
166  /* Temp variable to iterate over groups. */
167  gchar **group;
168 
169  /* The link list for the structure above and it's tmp helper */
170  GSList *log_domain_list = NULL;
171 
172  /* Create a new GKeyFile object and a bitwise list of flags. */
173  key_file = g_key_file_new ();
174  flags = G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS;
175 
176  /* Load the GKeyFile from conf or return. */
177  if (!g_key_file_load_from_file (key_file, config_file, flags, &error))
178  {
179  g_error ("%s: %s", config_file, error->message);
180  }
181 
182  /* Get all the groups available. */
183  groups = g_key_file_get_groups (key_file, NULL);
184 
185  /* Point to the group head. */
186  group = groups;
187  /* Iterate till we get to the end of the array. */
188  while (*group != NULL)
189  {
190  /* Structure to hold per group settings. */
191  gvm_logging_t *log_domain_entry;
192  /* Create the struct. */
193  log_domain_entry = g_malloc (sizeof (gvm_logging_t));
194  /* Set the logdomain. */
195  log_domain_entry->log_domain = g_strdup (*group);
196  /* Initialize everything else to NULL. */
197  log_domain_entry->prepend_string = NULL;
198  log_domain_entry->prepend_time_format = NULL;
199  log_domain_entry->log_file = NULL;
200  log_domain_entry->default_level = NULL;
201  log_domain_entry->log_channel = NULL;
202  log_domain_entry->syslog_facility = NULL;
203  log_domain_entry->syslog_ident = NULL;
204  log_domain_entry->prepend_separator = NULL;
205 
206  /* Look for the prepend string. */
207  if (g_key_file_has_key (key_file, *group, "prepend", &error))
208  {
209  log_domain_entry->prepend_string =
210  g_key_file_get_value (key_file, *group, "prepend", &error);
211  }
212 
213  /* Look for the log_separator string. */
214  if (g_key_file_has_key (key_file, *group, "separator", &error))
215  {
216  log_domain_entry->prepend_separator =
217  g_key_file_get_value (key_file, *group, "separator", &error);
218  }
219 
220  /* Look for the prepend time format string. */
221  if (g_key_file_has_key (key_file, *group, "prepend_time_format", &error))
222  {
223  log_domain_entry->prepend_time_format = g_key_file_get_value (
224  key_file, *group, "prepend_time_format", &error);
225  }
226 
227  /* Look for the log file string. */
228  if (g_key_file_has_key (key_file, *group, "file", &error))
229  {
230  log_domain_entry->log_file =
231  g_key_file_get_value (key_file, *group, "file", &error);
232  }
233 
234  /* Look for the prepend log level string. */
235  if (g_key_file_has_key (key_file, *group, "level", &error))
236  {
237  gchar *level;
238 
239  level = g_key_file_get_value (key_file, *group, "level", &error);
240  level = g_strchug (level);
241  log_domain_entry->default_level = g_malloc (sizeof (gint));
242  *log_domain_entry->default_level = level_int_from_string (level);
243  g_free (level);
244  }
245 
246  /* Look for the syslog_facility string. */
247  if (g_key_file_has_key (key_file, *group, "syslog_facility", &error))
248  {
249  log_domain_entry->syslog_facility =
250  g_key_file_get_value (key_file, *group, "syslog_facility", &error);
251  }
252  else
253  log_domain_entry->syslog_facility = "local0";
254 
255  /* Look for the syslog_ident string. */
256  if (g_key_file_has_key (key_file, *group, "syslog_ident", &error))
257  {
258  log_domain_entry->syslog_ident =
259  g_key_file_get_value (key_file, *group, "syslog_ident", &error);
260  }
261  else
262  log_domain_entry->syslog_ident = g_strdup (*group);
263 
264  /* Attach the struct to the list. */
265  log_domain_list = g_slist_prepend (log_domain_list, log_domain_entry);
266  group++;
267  }
268  /* Free the groups array. */
269  g_strfreev (groups);
270 
271  /* Free the key file. */
272  g_key_file_free (key_file);
273 
274  return log_domain_list;
275 }
gchar * prepend_time_format
If prependstring has t, format for strftime.
Definition: logging.c:52
gchar * prepend_string
Prepend this string before every message.
Definition: logging.c:51
gchar * syslog_facility
Syslog facility to use for syslog logging.
Definition: logging.c:56
Logging stores the parameters loaded from a log configuration.
Definition: logging.c:48
GIOChannel * log_channel
Gio Channel - FD holder for logfile.
Definition: logging.c:55
gchar * log_domain
Affected logdomain e.g libnasl.
Definition: logging.c:50
gchar * log_file
Where to log to.
Definition: logging.c:53
gchar * syslog_ident
Syslog ident to use for syslog logging.
Definition: logging.c:57
gchar * prepend_separator
Definition: logging.c:58
GLogLevelFlags * default_level
What severity level to use as default.
Definition: logging.c:54
static gint level_int_from_string(const gchar *level)
Return the integer corresponding to a log level string.
Definition: logging.c:98

References gvm_logging_t::default_level, level_int_from_string(), gvm_logging_t::log_channel, gvm_logging_t::log_domain, gvm_logging_t::log_file, gvm_logging_t::prepend_separator, gvm_logging_t::prepend_string, gvm_logging_t::prepend_time_format, gvm_logging_t::syslog_facility, and gvm_logging_t::syslog_ident.

Here is the call graph for this function:

◆ log_func_for_gnutls()

void log_func_for_gnutls ( int  level,
const char *  message 
)

This function logs debug messages from gnutls.

Parameters
levelGnuTLS log level (integer from 0 to 99 according to GnuTLS documentation.
messageGnuTLS log message.

To enable GNUTLS debug messages, the environment variable OPENVAS_GNUTLS_DEBUG is to be set to the desired log level as described in the GNUTLS manual.

Definition at line 738 of file logging.c.

739 {
740  g_log ("x gnutls", G_LOG_LEVEL_INFO, "tls(%d): %s", level, message);
741 }

◆ setup_log_handlers()

void setup_log_handlers ( GSList *  gvm_log_config_list)

Sets up routing of logdomains to log handlers.

Iterates over the link list and adds the groups to the handler.

Parameters
gvm_log_config_listA pointer to the configuration linked list.

Definition at line 751 of file logging.c.

752 {
753  GSList *log_domain_list_tmp;
754  if (gvm_log_config_list != NULL)
755  {
756  /* Go to the head of the list. */
757  log_domain_list_tmp = (GSList *) gvm_log_config_list;
758 
759  while (log_domain_list_tmp != NULL)
760  {
761  gvm_logging_t *log_domain_entry;
762 
763  /* Get the list data which is an gvm_logging_t struct. */
764  log_domain_entry = log_domain_list_tmp->data;
765 
766  GLogFunc logfunc =
767 #if 0
768  (!strcmp (log_domain_entry, "syslog")) ? gvm_syslog_func :
769 #endif
770  gvm_log_func;
771 
772  if (g_ascii_strcasecmp (log_domain_entry->log_domain, "*"))
773  {
774  g_log_set_handler (
775  log_domain_entry->log_domain,
776  (GLogLevelFlags) (G_LOG_LEVEL_DEBUG | G_LOG_LEVEL_INFO
777  | G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_WARNING
778  | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_ERROR
779  | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION),
780  (GLogFunc) logfunc, gvm_log_config_list);
781  }
782  else
783  {
784  g_log_set_default_handler ((GLogFunc) logfunc,
785  gvm_log_config_list);
786  }
787 
788  /* Go to the next item. */
789  log_domain_list_tmp = g_slist_next (log_domain_list_tmp);
790  }
791  }
792  g_log_set_handler (
793  "",
794  (GLogLevelFlags) (G_LOG_LEVEL_DEBUG | G_LOG_LEVEL_INFO | G_LOG_LEVEL_MESSAGE
795  | G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL
796  | G_LOG_LEVEL_ERROR | G_LOG_FLAG_FATAL
797  | G_LOG_FLAG_RECURSION),
798  (GLogFunc) gvm_log_func, gvm_log_config_list);
799 }
Logging stores the parameters loaded from a log configuration.
Definition: logging.c:48
gchar * log_domain
Affected logdomain e.g libnasl.
Definition: logging.c:50
void gvm_log_func(const char *log_domain, GLogLevelFlags log_level, const char *message, gpointer gvm_log_config_list)
Creates the formatted string and outputs it to the log destination.
Definition: logging.c:384

References gvm_log_func(), and gvm_logging_t::log_domain.

Here is the call graph for this function:

Variable Documentation

◆ logger_mutex

GMutex* logger_mutex = NULL
static

Definition at line 342 of file logging.c.

Referenced by gvm_log_lock(), gvm_log_lock_init(), and gvm_log_unlock().