/src/tinysparql/subprojects/glib-2.80.3/glib/gmessages.c

Source (jump to first uncovered line)
/* GLIB - Library of useful routines for C programming
 * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
 *
 * SPDX-License-Identifier: LGPL-2.1-or-later
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
 */

/*
 * Modified by the GLib Team and others 1997-2000.  See the AUTHORS
 * file for a list of people on the GLib Team.  See the ChangeLog
 * files for a list of changes.  These files are distributed with
 * GLib at ftp://ftp.gtk.org/pub/gtk/.
 */

/*
 * MT safe
 */

#include "config.h"

#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <signal.h>
#include <locale.h>
#include <errno.h>

#if defined(__linux__) && !defined(__BIONIC__)
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <fcntl.h>
#include <sys/uio.h>
#endif

#include "galloca.h"
#include "gbacktrace.h"
#include "gcharset.h"
#include "gconvert.h"
#include "genviron.h"
#include "glib-init.h"
#include "glib-private.h"
#include "gmain.h"
#include "gmem.h"
#include "gpattern.h"
#include "gprintfint.h"
#include "gstrfuncs.h"
#include "gstring.h"
#include "gtestutils.h"
#include "gthread.h"
#include "gthreadprivate.h"
#include "gutilsprivate.h"

#ifdef HAVE_SYSLOG_H
#include <syslog.h>
#endif

#if defined(__linux__) && !defined(__BIONIC__)
#include "gjournal-private.h"
#endif

#ifdef G_OS_UNIX
#include <unistd.h>
#endif

#ifdef G_OS_WIN32
#include <process.h>    /* For getpid() */
#include <io.h>
#  include <windows.h>

#ifndef ENABLE_VIRTUAL_TERMINAL_PROCESSING
#define ENABLE_VIRTUAL_TERMINAL_PROCESSING 0x0004
#endif

#include "gwin32.h"
#endif

/**
 * G_LOG_DOMAIN:
 *
 * Defines the log domain. See [Log Domains](#log-domains).
 *
 * Libraries should define this so that any messages
 * which they log can be differentiated from messages from other
 * libraries and application code. But be careful not to define
 * it in any public header files.
 *
 * Log domains must be unique, and it is recommended that they are the
 * application or library name, optionally followed by a hyphen and a sub-domain
 * name. For example, `bloatpad` or `bloatpad-io`.
 *
 * If undefined, it defaults to the default %NULL (or `""`) log domain; this is
 * not advisable, as it cannot be filtered against using the `G_MESSAGES_DEBUG`
 * environment variable.
 *
 * For example, GTK uses this in its `Makefile.am`:
 * |[
 * AM_CPPFLAGS = -DG_LOG_DOMAIN=\"Gtk\"
 * ]|
 *
 * Applications can choose to leave it as the default %NULL (or `""`)
 * domain. However, defining the domain offers the same advantages as
 * above.
 *

 */

/**
 * G_LOG_FATAL_MASK:
 *
 * GLib log levels that are considered fatal by default.
 *
 * This is not used if structured logging is enabled; see
 * [Using Structured Logging](logging.html#using-structured-logging).
 */

/**
 * GLogFunc:
 * @log_domain: the log domain of the message
 * @log_level: the log level of the message (including the
 *   fatal and recursion flags)
 * @message: the message to process
 * @user_data: user data, set in [func@GLib.log_set_handler]
 *
 * Specifies the prototype of log handler functions.
 *
 * The default log handler, [func@GLib.log_default_handler], automatically appends a
 * new-line character to @message when printing it. It is advised that any
 * custom log handler functions behave similarly, so that logging calls in user
 * code do not need modifying to add a new-line character to the message if the
 * log handler is changed.
 *
 * This is not used if structured logging is enabled; see
 * [Using Structured Logging](logging.html#using-structured-logging).
 */

/**
 * GLogLevelFlags:
 * @G_LOG_FLAG_RECURSION: internal flag
 * @G_LOG_FLAG_FATAL: internal flag
 * @G_LOG_LEVEL_ERROR: log level for errors, see [func@GLib.error].
 *   This level is also used for messages produced by [func@GLib.assert].
 * @G_LOG_LEVEL_CRITICAL: log level for critical warning messages, see
 *   [func@GLib.critical]. This level is also used for messages produced by
 *   [func@GLib.return_if_fail] and [func@GLib.return_val_if_fail].
 * @G_LOG_LEVEL_WARNING: log level for warnings, see [func@GLib.warning]
 * @G_LOG_LEVEL_MESSAGE: log level for messages, see [func@GLib.message]
 * @G_LOG_LEVEL_INFO: log level for informational messages, see [func@GLib.info]
 * @G_LOG_LEVEL_DEBUG: log level for debug messages, see [func@GLib.debug]
 * @G_LOG_LEVEL_MASK: a mask including all log levels
 *
 * Flags specifying the level of log messages.
 *
 * It is possible to change how GLib treats messages of the various
 * levels using [func@GLib.log_set_handler] and [func@GLib.log_set_fatal_mask].
 */

/**
 * G_LOG_LEVEL_USER_SHIFT:
 *
 * Log levels below `1<<G_LOG_LEVEL_USER_SHIFT` are used by GLib.
 * Higher bits can be used for user-defined log levels.
 */

/**
 * g_message:
 * @...: format string, followed by parameters to insert into the format string
 *   (as with `printf()`)
 *
 * A convenience function/macro to log a normal message.
 *
 * If [func@GLib.log_default_handler] is used as the log handler function, a new-line
 * character will automatically be appended to @..., and need not be entered
 * manually.
 *
 * If structured logging is enabled, this will use [func@GLib.log_structured];
 * otherwise it will use [func@GLib.log]. See
 * [Using Structured Logging](logging.html#using-structured-logging).
 */

/**
 * g_warning:
 * @...: format string, followed by parameters to insert into the format string
 *   (as with `printf()`)
 *
 * A convenience function/macro to log a warning message.
 *
 * The message should typically *not* be translated to the user’s language.
 *
 * This is not intended for end user error reporting. Use of [type@GLib.Error] is
 * preferred for that instead, as it allows calling functions to perform actions
 * conditional on the type of error.
 *
 * Warning messages are intended to be used in the event of unexpected
 * external conditions (system misconfiguration, missing files,
 * other trusted programs violating protocol, invalid contents in
 * trusted files, etc.)
 *
 * If attempting to deal with programmer errors (for example, incorrect function
 * parameters) then you should use [flags@GLib.LogLevelFlags.LEVEL_CRITICAL] instead.
 *
 * [func@GLib.warn_if_reached] and func@GLib.warn_if_fail] log at [flags@GLib.LogLevelFlags.LEVEL_WARNING].
 *
 * You can make warnings fatal at runtime by setting the `G_DEBUG`
 * environment variable (see
 * [Running GLib Applications](glib-running.html)):
 *
 * ```
 * G_DEBUG=fatal-warnings gdb ./my-program
 * ```
 *
 * Any unrelated failures can be skipped over in
 * [gdb](https://www.gnu.org/software/gdb/) using the `continue` command.
 *
 * If [func@GLib.log_default_handler] is used as the log handler function,
 * a newline character will automatically be appended to @..., and
 * need not be entered manually.
 *
 * If structured logging is enabled, this will use [func@GLib.log_structured];
 * otherwise it will use [func@GLib.log]. See
 * [Using Structured Logging](logging.html#using-structured-logging).
 */

/**
 * g_critical:
 * @...: format string, followed by parameters to insert into the format string
 *   (as with `printf()`)
 *
 * Logs a ‘critical warning’ ([flags@GLib.LogLevelFlags.LEVEL_CRITICAL]).
 *
 * Critical warnings are intended to be used in the event of an error
 * that originated in the current process (a programmer error).
 * Logging of a critical error is by definition an indication of a bug
 * somewhere in the current program (or its libraries).
 *
 * [func@GLib.return_if_fail], [func@GLib.return_val_if_fail], [func@GLib.return_if_reached] and
 * [func@GLib.return_val_if_reached] log at [flags@GLib.LogLevelFlags.LEVEL_CRITICAL].
 *
 * You can make critical warnings fatal at runtime by
 * setting the `G_DEBUG` environment variable (see
 * [Running GLib Applications](glib-running.html)):
 *
 * ```
 * G_DEBUG=fatal-warnings gdb ./my-program
 * ```
 *
 * You can also use [func@GLib.log_set_always_fatal].
 *
 * Any unrelated failures can be skipped over in
 * [gdb](https://www.gnu.org/software/gdb/) using the `continue` command.
 *
 * The message should typically *not* be translated to the
 * user’s language.
 *
 * If [func@GLib.log_default_handler] is used as the log handler function, a new-line
 * character will automatically be appended to @..., and need not be entered
 * manually.
 *
 * If structured logging is enabled, this will use [func@GLib.log_structured];
 * otherwise it will use [func@GLib.log]. See
 * [Using Structured Logging](logging.html#using-structured-logging).
 */

/**
 * g_error:
 * @...: format string, followed by parameters to insert into the format string
 *   (as with `printf()`)
 *
 * A convenience function/macro to log an error message.
 *
 * The message should typically *not* be translated to the user’s language.
 *
 * This is not intended for end user error reporting. Use of [type@GLib.Error] is
 * preferred for that instead, as it allows calling functions to perform actions
 * conditional on the type of error.
 *
 * Error messages are always fatal, resulting in a call to [func@GLib.BREAKPOINT]
 * to terminate the application. This function will
 * result in a core dump; don’t use it for errors you expect.
 * Using this function indicates a bug in your program, i.e.
 * an assertion failure.
 *
 * If [func@GLib.log_default_handler] is used as the log handler function, a new-line
 * character will automatically be appended to @..., and need not be entered
 * manually.
 *
 * If structured logging is enabled, this will use [func@GLib.log_structured];
 * otherwise it will use [func@GLib.log]. See
 * [Using Structured Logging](logging.html#using-structured-logging).
 */

/**
 * g_info:
 * @...: format string, followed by parameters to insert into the format string
 *   (as with `printf()`)
 *
 * A convenience function/macro to log an informational message.
 *
 * Seldom used.
 *
 * If [func@GLib.log_default_handler] is used as the log handler function, a new-line
 * character will automatically be appended to @..., and need not be entered
 * manually.
 *
 * Such messages are suppressed by the [func@GLib.log_default_handler] and
 * [func@GLib.log_writer_default] unless the `G_MESSAGES_DEBUG` environment variable is
 * set appropriately. If you need to set the allowed domains at runtime, use
 * [func@GLib.log_writer_default_set_debug_domains].
 *
 * If structured logging is enabled, this will use [func@GLib.log_structured];
 * otherwise it will use [func@GLib.log]. See
 * [Using Structured Logging](logging.html#using-structured-logging).
 *
 * Since: 2.40
 */

/**
 * g_debug:
 * @...: format string, followed by parameters to insert into the format string
 *   (as with `printf()`)
 *
 * A convenience function/macro to log a debug message.
 *
 * The message should typically *not* be translated to the user’s language.
 *
 * If [func@GLib.log_default_handler] is used as the log handler function, a new-line
 * character will automatically be appended to @..., and need not be entered
 * manually.
 *
 * Such messages are suppressed by the [func@GLib.log_default_handler] and
 * [func@GLib.log_writer_default] unless the `G_MESSAGES_DEBUG` environment variable is
 * set appropriately. If you need to set the allowed domains at runtime, use
 * [func@GLib.log_writer_default_set_debug_domains].
 *
 * If structured logging is enabled, this will use [func@GLib.log_structured];
 * otherwise it will use [func@GLib.log]. See
 * [Using Structured Logging](logging.html#using-structured-logging).
 *
 * Since: 2.6
 */

/* --- structures --- */
typedef struct _GLogDomain  GLogDomain;
typedef struct _GLogHandler GLogHandler;
struct _GLogDomain
{
  gchar   *log_domain;
  GLogLevelFlags fatal_mask;
  GLogHandler *handlers;
  GLogDomain  *next;
};
struct _GLogHandler
{
  guint    id;
  GLogLevelFlags log_level;
  GLogFunc   log_func;
  gpointer   data;
  GDestroyNotify destroy;
  GLogHandler *next;
};

static void g_default_print_func (const gchar *string);
static void g_default_printerr_func (const gchar *string);

/* --- variables --- */
static GMutex         g_messages_lock;
static GLogDomain    *g_log_domains = NULL;
static GPrintFunc     glib_print_func = g_default_print_func;
static GPrintFunc     glib_printerr_func = g_default_printerr_func;
static GPrivate       g_log_depth;
static GPrivate       g_log_structured_depth;
static GLogFunc       default_log_func = g_log_default_handler;
static gpointer       default_log_data = NULL;
static GTestLogFatalFunc fatal_log_func = NULL;
static gpointer          fatal_log_data;
static GLogWriterFunc log_writer_func = g_log_writer_default;
static gpointer       log_writer_user_data = NULL;
static GDestroyNotify log_writer_user_data_free = NULL;
static gboolean       g_log_debug_enabled = FALSE;  /* (atomic) */

/* --- functions --- */

static void _g_log_abort (gboolean breakpoint);
static inline const char * format_string (const char *format,
                                          va_list     args,
                                          char      **out_allocated_string)
                                          G_GNUC_PRINTF (1, 0);
static inline FILE * log_level_to_file (GLogLevelFlags log_level);

static void
_g_log_abort (gboolean breakpoint)
{
  gboolean debugger_present;

  if (g_test_subprocess ())
    {
      /* If this is a test case subprocess then it probably caused
       * this error message on purpose, so just exit() rather than
       * abort()ing, to avoid triggering any system crash-reporting
       * daemon.
       */
      _exit (1);
    }

#ifdef G_OS_WIN32
  debugger_present = IsDebuggerPresent ();
#else
  /* Assume GDB is attached. */
  debugger_present = TRUE;
#endif /* !G_OS_WIN32 */

  if (debugger_present && breakpoint)
    G_BREAKPOINT ();
  else
    g_abort ();
}

#ifdef G_OS_WIN32
static gboolean win32_keep_fatal_message = FALSE;

/* This default message will usually be overwritten. */
/* Yes, a fixed size buffer is bad. So sue me. But g_error() is never
 * called with huge strings, is it?
 */
static gchar  fatal_msg_buf[1000] = "Unspecified fatal error encountered, aborting.";

#endif

static void
write_string (FILE        *stream,
        const gchar *string)
{
  if (fputs (string, stream) == EOF)
    {
      /* Something failed, but it's not an error we can handle at glib level
       * so let's just continue without the compiler blaming us
       */
    }
}

static void
write_string_sized (FILE        *stream,
                    const gchar *string,
                    gssize       length)
{
  /* Is it nul-terminated? */
  if (length < 0)
    write_string (stream, string);
  else if (fwrite (string, 1, length, stream) < (size_t) length)
    {
      /* Something failed, but it's not an error we can handle at glib level
       * so let's just continue without the compiler blaming us
       */
    }
}

static GLogDomain*
g_log_find_domain_L (const gchar *log_domain)
{
  GLogDomain *domain;
  
  domain = g_log_domains;
  while (domain)
    {
      if (strcmp (domain->log_domain, log_domain) == 0)
  return domain;
      domain = domain->next;
    }
  return NULL;
}

static GLogDomain*
g_log_domain_new_L (const gchar *log_domain)
{
  GLogDomain *domain;

  domain = g_new (GLogDomain, 1);
  domain->log_domain = g_strdup (log_domain);
  domain->fatal_mask = G_LOG_FATAL_MASK;
  domain->handlers = NULL;
  
  domain->next = g_log_domains;
  g_log_domains = domain;
  
  return domain;
}

static void
g_log_domain_check_free_L (GLogDomain *domain)
{
  if (domain->fatal_mask == G_LOG_FATAL_MASK &&
      domain->handlers == NULL)
    {
      GLogDomain *last, *work;
      
      last = NULL;  

      work = g_log_domains;
      while (work)
  {
    if (work == domain)
      {
        if (last)
    last->next = domain->next;
        else
    g_log_domains = domain->next;
        g_free (domain->log_domain);
        g_free (domain);
        break;
      }
    last = work;
    work = last->next;
  }  
    }
}

static GLogFunc
g_log_domain_get_handler_L (GLogDomain  *domain,
          GLogLevelFlags log_level,
          gpointer  *data)
{
  if (domain && log_level)
    {
      GLogHandler *handler;
      
      handler = domain->handlers;
      while (handler)
  {
    if ((handler->log_level & log_level) == log_level)
      {
        *data = handler->data;
        return handler->log_func;
      }
    handler = handler->next;
  }
    }

  *data = default_log_data;
  return default_log_func;
}

/**
 * g_log_set_always_fatal:
 * @fatal_mask: the mask containing bits set for each level of error which is
 *   to be fatal
 *
 * Sets the message levels which are always fatal, in any log domain.
 *
 * When a message with any of these levels is logged the program terminates.
 * You can only set the levels defined by GLib to be fatal.
 * [flags@GLib.LogLevelFlags.LEVEL_ERROR] is always fatal.
 *
 * You can also make some message levels fatal at runtime by setting
 * the `G_DEBUG` environment variable (see
 * [Running GLib Applications](glib-running.html)).
 *
 * Libraries should not call this function, as it affects all messages logged
 * by a process, including those from other libraries.
 *
 * Structured log messages (using [func@GLib.log_structured] and
 * [func@GLib.log_structured_array]) are fatal only if the default log writer is used;
 * otherwise it is up to the writer function to determine which log messages
 * are fatal. See [Using Structured Logging](logging.html#using-structured-logging).
 *
 * Returns: the old fatal mask
 */
GLogLevelFlags
g_log_set_always_fatal (GLogLevelFlags fatal_mask)
{
  GLogLevelFlags old_mask;

  /* restrict the global mask to levels that are known to glib
   * since this setting applies to all domains
   */
  fatal_mask &= (1 << G_LOG_LEVEL_USER_SHIFT) - 1;
  /* force errors to be fatal */
  fatal_mask |= G_LOG_LEVEL_ERROR;
  /* remove bogus flag */
  fatal_mask &= ~G_LOG_FLAG_FATAL;

  g_mutex_lock (&g_messages_lock);
  old_mask = g_log_always_fatal;
  g_log_always_fatal = fatal_mask;
  g_mutex_unlock (&g_messages_lock);

  return old_mask;
}

/**
 * g_log_set_fatal_mask:
 * @log_domain: the log domain
 * @fatal_mask: the new fatal mask
 *
 * Sets the log levels which are fatal in the given domain.
 *
 * [flags@GLib.LogLevelFlags.LEVEL_ERROR] is always fatal.
 *
 * This has no effect on structured log messages (using [func@GLib.log_structured] or
 * [func@GLib.log_structured_array]). To change the fatal behaviour for specific log
 * messages, programs must install a custom log writer function using
 * [func@GLib.log_set_writer_func]. See
 * [Using Structured Logging](logging.html#using-structured-logging).
 *
 * This function is mostly intended to be used with
 * [flags@GLib.LogLevelFlags.LEVEL_CRITICAL].  You should typically not set
 * [flags@GLib.LogLevelFlags.LEVEL_WARNING], [flags@GLib.LogLevelFlags.LEVEL_MESSAGE], [flags@GLib.LogLevelFlags.LEVEL_INFO] or
 * [flags@GLib.LogLevelFlags.LEVEL_DEBUG] as fatal except inside of test programs.
 *
 * Returns: the old fatal mask for the log domain
 */
GLogLevelFlags
g_log_set_fatal_mask (const gchar   *log_domain,
          GLogLevelFlags fatal_mask)
{
  GLogLevelFlags old_flags;
  GLogDomain *domain;
  
  if (!log_domain)
    log_domain = "";

  /* force errors to be fatal */
  fatal_mask |= G_LOG_LEVEL_ERROR;
  /* remove bogus flag */
  fatal_mask &= ~G_LOG_FLAG_FATAL;
  
  g_mutex_lock (&g_messages_lock);

  domain = g_log_find_domain_L (log_domain);
  if (!domain)
    domain = g_log_domain_new_L (log_domain);
  old_flags = domain->fatal_mask;
  
  domain->fatal_mask = fatal_mask;
  g_log_domain_check_free_L (domain);

  g_mutex_unlock (&g_messages_lock);

  return old_flags;
}

/**
 * g_log_set_handler:
 * @log_domain: (nullable): the log domain, or `NULL` for the default `""`
 *    application domain
 * @log_levels: the log levels to apply the log handler for.
 *    To handle fatal and recursive messages as well, combine
 *    the log levels with the [flags@GLib.LogLevelFlags.FLAG_FATAL] and
 *    [flags@GLib.LogLevelFlags.FLAG_RECURSION] bit flags.
 * @log_func: the log handler function
 * @user_data: data passed to the log handler
 *
 * Sets the log handler for a domain and a set of log levels.
 *
 * To handle fatal and recursive messages the @log_levels parameter
 * must be combined with the [flags@GLib.LogLevelFlags.FLAG_FATAL] and [flags@GLib.LogLevelFlags.FLAG_RECURSION]
 * bit flags.
 *
 * Note that since the [flags@GLib.LogLevelFlags.LEVEL_ERROR] log level is always fatal, if
 * you want to set a handler for this log level you must combine it with
 * [flags@GLib.LogLevelFlags.FLAG_FATAL].
 *
 * This has no effect if structured logging is enabled; see
 * [Using Structured Logging](logging.html#using-structured-logging).
 *
 * Here is an example for adding a log handler for all warning messages
 * in the default domain:
 *
 * ```c
 * g_log_set_handler (NULL, G_LOG_LEVEL_WARNING | G_LOG_FLAG_FATAL
 *                    | G_LOG_FLAG_RECURSION, my_log_handler, NULL);
 * ```
 *
 * This example adds a log handler for all critical messages from GTK:
 *
 * ```c
 * g_log_set_handler ("Gtk", G_LOG_LEVEL_CRITICAL | G_LOG_FLAG_FATAL
 *                    | G_LOG_FLAG_RECURSION, my_log_handler, NULL);
 * ```
 *
 * This example adds a log handler for all messages from GLib:
 *
 * ```c
 * g_log_set_handler ("GLib", G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL
 *                    | G_LOG_FLAG_RECURSION, my_log_handler, NULL);
 * ```
 *
 * Returns: the id of the new handler
 */
guint
g_log_set_handler (const gchar   *log_domain,
                   GLogLevelFlags log_levels,
                   GLogFunc       log_func,
                   gpointer       user_data)
{
  return g_log_set_handler_full (log_domain, log_levels, log_func, user_data, NULL);
}

/**
 * g_log_set_handler_full: (rename-to g_log_set_handler)
 * @log_domain: (nullable): the log domain, or `NULL` for the default `""`
 *   application domain
 * @log_levels: the log levels to apply the log handler for.
 *   To handle fatal and recursive messages as well, combine
 *   the log levels with the [flags@GLib.LogLevelFlags.FLAG_FATAL] and
 *   [flags@GLib.LogLevelFlags.FLAG_RECURSION] bit flags.
 * @log_func: the log handler function
 * @user_data: data passed to the log handler
 * @destroy: destroy notify for @user_data, or `NULL`
 *
 * Like [func@GLib.log_set_handler], but takes a destroy notify for the @user_data.
 *
 * This has no effect if structured logging is enabled; see
 * [Using Structured Logging](logging.html#using-structured-logging).
 *
 * Returns: the ID of the new handler
 *
 * Since: 2.46
 */
guint
g_log_set_handler_full (const gchar    *log_domain,
                        GLogLevelFlags  log_levels,
                        GLogFunc        log_func,
                        gpointer        user_data,
                        GDestroyNotify  destroy)
{
  static guint handler_id = 0;
  GLogDomain *domain;
  GLogHandler *handler;
  
  g_return_val_if_fail ((log_levels & G_LOG_LEVEL_MASK) != 0, 0);
  g_return_val_if_fail (log_func != NULL, 0);
  
  if (!log_domain)
    log_domain = "";

  handler = g_new (GLogHandler, 1);

  g_mutex_lock (&g_messages_lock);

  domain = g_log_find_domain_L (log_domain);
  if (!domain)
    domain = g_log_domain_new_L (log_domain);
  
  handler->id = ++handler_id;
  handler->log_level = log_levels;
  handler->log_func = log_func;
  handler->data = user_data;
  handler->destroy = destroy;
  handler->next = domain->handlers;
  domain->handlers = handler;

  g_mutex_unlock (&g_messages_lock);
  
  return handler_id;
}

/**
 * g_log_set_default_handler:
 * @log_func: the log handler function
 * @user_data: data passed to the log handler
 *
 * Installs a default log handler which is used if no
 * log handler has been set for the particular log domain
 * and log level combination.
 *
 * By default, GLib uses [func@GLib.log_default_handler] as default log handler.
 *
 * This has no effect if structured logging is enabled; see
 * [Using Structured Logging](logging.html#using-structured-logging).
 *
 * Returns: the previous default log handler
 *
 * Since: 2.6
 */
GLogFunc
g_log_set_default_handler (GLogFunc log_func,
         gpointer user_data)
{
  GLogFunc old_log_func;
  
  g_mutex_lock (&g_messages_lock);
  old_log_func = default_log_func;
  default_log_func = log_func;
  default_log_data = user_data;
  g_mutex_unlock (&g_messages_lock);
  
  return old_log_func;
}

/**
 * g_test_log_set_fatal_handler:
 * @log_func: the log handler function.
 * @user_data: data passed to the log handler.
 *
 * Installs a non-error fatal log handler which can be
 * used to decide whether log messages which are counted
 * as fatal abort the program.
 *
 * The use case here is that you are running a test case
 * that depends on particular libraries or circumstances
 * and cannot prevent certain known critical or warning
 * messages. So you install a handler that compares the
 * domain and message to precisely not abort in such a case.
 *
 * Note that the handler is reset at the beginning of
 * any test case, so you have to set it inside each test
 * function which needs the special behavior.
 *
 * This handler has no effect on g_error messages.
 *
 * This handler also has no effect on structured log messages (using
 * [func@GLib.log_structured] or [func@GLib.log_structured_array]). To change the fatal
 * behaviour for specific log messages, programs must install a custom log
 * writer function using [func@GLib.log_set_writer_func].See
 * [Using Structured Logging](logging.html#using-structured-logging).
 *
 * Since: 2.22
 **/
void
g_test_log_set_fatal_handler (GTestLogFatalFunc log_func,
                              gpointer          user_data)
{
  g_mutex_lock (&g_messages_lock);
  fatal_log_func = log_func;
  fatal_log_data = user_data;
  g_mutex_unlock (&g_messages_lock);
}

/**
 * g_log_remove_handler:
 * @log_domain: the log domain
 * @handler_id: the ID of the handler, which was returned
 *   in [func@GLib.log_set_handler]
 *
 * Removes the log handler.
 *
 * This has no effect if structured logging is enabled; see
 * [Using Structured Logging](logging.html#using-structured-logging).
 */
void
g_log_remove_handler (const gchar *log_domain,
          guint    handler_id)
{
  GLogDomain *domain;
  
  g_return_if_fail (handler_id > 0);
  
  if (!log_domain)
    log_domain = "";
  
  g_mutex_lock (&g_messages_lock);
  domain = g_log_find_domain_L (log_domain);
  if (domain)
    {
      GLogHandler *work, *last;
      
      last = NULL;
      work = domain->handlers;
      while (work)
  {
    if (work->id == handler_id)
      {
        if (last)
    last->next = work->next;
        else
    domain->handlers = work->next;
        g_log_domain_check_free_L (domain); 
        g_mutex_unlock (&g_messages_lock);
              if (work->destroy)
                work->destroy (work->data);
        g_free (work);
        return;
      }
    last = work;
    work = last->next;
  }
    } 
  g_mutex_unlock (&g_messages_lock);
  g_warning ("%s: could not find handler with id '%d' for domain \"%s\"",
       G_STRLOC, handler_id, log_domain);
}

#define CHAR_IS_SAFE(wc) (!((wc < 0x20 && wc != '\t' && wc != '\n' && wc != '\r') || \
          (wc == 0x7f) || \
          (wc >= 0x80 && wc < 0xa0)))
     
static gchar*
strdup_convert (const gchar *string,
    const gchar *charset)
{
  if (!g_utf8_validate (string, -1, NULL))
    {
      GString *gstring = g_string_new ("[Invalid UTF-8] ");
      guchar *p;

      for (p = (guchar *)string; *p; p++)
  {
    if (CHAR_IS_SAFE(*p) &&
        !(*p == '\r' && *(p + 1) != '\n') &&
        *p < 0x80)
      g_string_append_c (gstring, *p);
    else
      g_string_append_printf (gstring, "\\x%02x", (guint)(guchar)*p);
  }
      
      return g_string_free (gstring, FALSE);
    }
  else
    {
      GError *err = NULL;
      
      gchar *result = g_convert_with_fallback (string, -1, charset, "UTF-8", "?", NULL, NULL, &err);
      if (result)
  return result;
      else
  {
    /* Not thread-safe, but doesn't matter if we print the warning twice
     */
    static gboolean warned = FALSE; 
    if (!warned)
      {
        warned = TRUE;
        _g_fprintf (stderr, "GLib: Cannot convert message: %s\n", err->message);
      }
    g_error_free (err);
    
    return g_strdup (string);
  }
    }
}

/* For a radix of 8 we need at most 3 output bytes for 1 input
 * byte. Additionally we might need up to 2 output bytes for the
 * readix prefix and 1 byte for the trailing NULL.
 */
#define FORMAT_UNSIGNED_BUFSIZE ((GLIB_SIZEOF_LONG * 3) + 3)

static void
format_unsigned (gchar  *buf,
     gulong  num,
     guint   radix)
{
  gulong tmp;
  gchar c;
  gint i, n;

  /* we may not call _any_ GLib functions here (or macros like g_return_if_fail()) */

  if (radix != 8 && radix != 10 && radix != 16)
    {
      *buf = '\000';
      return;
    }
  
  if (!num)
    {
      *buf++ = '0';
      *buf = '\000';
      return;
    } 
  
  if (radix == 16)
    {
      *buf++ = '0';
      *buf++ = 'x';
    }
  else if (radix == 8)
    {
      *buf++ = '0';
    }
  
  n = 0;
  tmp = num;
  while (tmp)
    {
      tmp /= radix;
      n++;
    }

  i = n;

  /* Again we can't use g_assert; actually this check should _never_ fail. */
  if (n > FORMAT_UNSIGNED_BUFSIZE - 3)
    {
      *buf = '\000';
      return;
    }

  while (num)
    {
      i--;
      c = (num % radix);
      if (c < 10)
  buf[i] = c + '0';
      else
  buf[i] = c + 'a' - 10;
      num /= radix;
    }
  
  buf[n] = '\000';
}

/* string size big enough to hold level prefix */
#define STRING_BUFFER_SIZE  (FORMAT_UNSIGNED_BUFSIZE + 32)

#define ALERT_LEVELS    (G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING)

/* these are emitted by the default log handler */
#define DEFAULT_LEVELS (G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE)
/* these are filtered by G_MESSAGES_DEBUG by the default log handler */
#define INFO_LEVELS (G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG)

static const gchar *log_level_to_color (GLogLevelFlags log_level,
                                        gboolean       use_color);
static const gchar *color_reset        (gboolean       use_color);

static gboolean gmessages_use_stderr = FALSE;

/**
 * g_log_writer_default_set_use_stderr:
 * @use_stderr: If `TRUE`, use `stderr` for log messages that would
 *  normally have appeared on `stdout`
 *
 * Configure whether the built-in log functions will output all log messages to
 * `stderr`.
 *
 * The built-in log functions are [func@GLib.log_default_handler] for the
 * old-style API, and both [func@GLib.log_writer_default] and
 * [func@GLib.log_writer_standard_streams] for the structured API.
 *
 * By default, log messages of levels [flags@GLib.LogLevelFlags.LEVEL_INFO] and
 * [flags@GLib.LogLevelFlags.LEVEL_DEBUG] are sent to `stdout`, and other log messages are
 * sent to `stderr`. This is problematic for applications that intend
 * to reserve `stdout` for structured output such as JSON or XML.
 *
 * This function sets global state. It is not thread-aware, and should be
 * called at the very start of a program, before creating any other threads
 * or creating objects that could create worker threads of their own.
 *
 * Since: 2.68
 */
void
g_log_writer_default_set_use_stderr (gboolean use_stderr)
{
  g_return_if_fail (g_thread_n_created () == 0);
  gmessages_use_stderr = use_stderr;
}

static FILE *
mklevel_prefix (gchar          level_prefix[STRING_BUFFER_SIZE],
                GLogLevelFlags log_level,
                gboolean       use_color)
{
  /* we may not call _any_ GLib functions here */

  strcpy (level_prefix, log_level_to_color (log_level, use_color));

  switch (log_level & G_LOG_LEVEL_MASK)
    {
    case G_LOG_LEVEL_ERROR:
      strcat (level_prefix, "ERROR");
      break;
    case G_LOG_LEVEL_CRITICAL:
      strcat (level_prefix, "CRITICAL");
      break;
    case G_LOG_LEVEL_WARNING:
      strcat (level_prefix, "WARNING");
      break;
    case G_LOG_LEVEL_MESSAGE:
      strcat (level_prefix, "Message");
      break;
    case G_LOG_LEVEL_INFO:
      strcat (level_prefix, "INFO");
      break;
    case G_LOG_LEVEL_DEBUG:
      strcat (level_prefix, "DEBUG");
      break;
    default:
      if (log_level)
  {
    strcat (level_prefix, "LOG-");
    format_unsigned (level_prefix + 4, log_level & G_LOG_LEVEL_MASK, 16);
  }
      else
  strcat (level_prefix, "LOG");
      break;
    }

  strcat (level_prefix, color_reset (use_color));

  if (log_level & G_LOG_FLAG_RECURSION)
    strcat (level_prefix, " (recursed)");
  if (log_level & ALERT_LEVELS)
    strcat (level_prefix, " **");

#ifdef G_OS_WIN32
  if ((log_level & G_LOG_FLAG_FATAL) != 0 && !g_test_initialized ())
    win32_keep_fatal_message = TRUE;
#endif
  return log_level_to_file (log_level);
}

typedef struct {
  gchar          *log_domain;
  GLogLevelFlags  log_level;
  gchar          *pattern;
} GTestExpectedMessage;

static GSList *expected_messages = NULL;

/**
 * g_logv:
 * @log_domain: (nullable): the log domain, or `NULL` for the default `""`
 *   application domain
 * @log_level: the log level
 * @format: the message format. See the `printf()` documentation
 * @args: the parameters to insert into the format string
 *
 * Logs an error or debugging message.
 *
 * If the log level has been set as fatal, [func@GLib.BREAKPOINT] is called
 * to terminate the program. See the documentation for [func@GLib.BREAKPOINT] for
 * details of the debugging options this provides.
 *
 * If [func@GLib.log_default_handler] is used as the log handler function, a new-line
 * character will automatically be appended to @..., and need not be entered
 * manually.
 *
 * If [structured logging is enabled](logging.html#using-structured-logging) this will
 * output via the structured log writer function (see [func@GLib.log_set_writer_func]).
 */
void
g_logv (const gchar   *log_domain,
  GLogLevelFlags log_level,
  const gchar   *format,
  va_list        args)
{
  gboolean was_fatal = (log_level & G_LOG_FLAG_FATAL) != 0;
  gboolean was_recursion = (log_level & G_LOG_FLAG_RECURSION) != 0;
  char buffer[1025], *msg_alloc = NULL;
  const char *msg;
  gint i;

  log_level &= G_LOG_LEVEL_MASK;
  if (!log_level)
    return;

  if (log_level & G_LOG_FLAG_RECURSION)
    {
      /* we use a stack buffer of fixed size, since we're likely
       * in an out-of-memory situation
       */
      gsize size G_GNUC_UNUSED;

      size = _g_vsnprintf (buffer, 1024, format, args);
      msg = buffer;
    }
  else
    {
      msg = format_string (format, args, &msg_alloc);
    }

  if (expected_messages)
    {
      GTestExpectedMessage *expected = expected_messages->data;

      if (g_strcmp0 (expected->log_domain, log_domain) == 0 &&
          ((log_level & expected->log_level) == expected->log_level) &&
          g_pattern_match_simple (expected->pattern, msg))
        {
          expected_messages = g_slist_delete_link (expected_messages,
                                                   expected_messages);
          g_free (expected->log_domain);
          g_free (expected->pattern);
          g_free (expected);
          g_free (msg_alloc);
          return;
        }
      else if ((log_level & G_LOG_LEVEL_DEBUG) != G_LOG_LEVEL_DEBUG)
        {
          gchar level_prefix[STRING_BUFFER_SIZE];
          gchar *expected_message;

          mklevel_prefix (level_prefix, expected->log_level, FALSE);
          expected_message = g_strdup_printf ("Did not see expected message %s-%s: %s",
                                              expected->log_domain ? expected->log_domain : "**",
                                              level_prefix, expected->pattern);
          g_log_default_handler (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, expected_message, NULL);
          g_free (expected_message);

          log_level |= G_LOG_FLAG_FATAL;
        }
    }

  for (i = g_bit_nth_msf (log_level, -1); i >= 0; i = g_bit_nth_msf (log_level, i))
    {
      GLogLevelFlags test_level;

      test_level = 1L << i;
      if (log_level & test_level)
  {
    GLogDomain *domain;
    GLogFunc log_func;
    GLogLevelFlags domain_fatal_mask;
    gpointer data = NULL;
          gboolean masquerade_fatal = FALSE;
          guint depth;

    if (was_fatal)
      test_level |= G_LOG_FLAG_FATAL;
    if (was_recursion)
      test_level |= G_LOG_FLAG_RECURSION;

    /* check recursion and lookup handler */
    g_mutex_lock (&g_messages_lock);
          depth = GPOINTER_TO_UINT (g_private_get (&g_log_depth));
    domain = g_log_find_domain_L (log_domain ? log_domain : "");
    if (depth)
      test_level |= G_LOG_FLAG_RECURSION;
    depth++;
    domain_fatal_mask = domain ? domain->fatal_mask : G_LOG_FATAL_MASK;
    if ((domain_fatal_mask | g_log_always_fatal) & test_level)
      test_level |= G_LOG_FLAG_FATAL;
    if (test_level & G_LOG_FLAG_RECURSION)
      log_func = _g_log_fallback_handler;
    else
      log_func = g_log_domain_get_handler_L (domain, test_level, &data);
    domain = NULL;
    g_mutex_unlock (&g_messages_lock);

    g_private_set (&g_log_depth, GUINT_TO_POINTER (depth));

          log_func (log_domain, test_level, msg, data);

          if ((test_level & G_LOG_FLAG_FATAL)
              && !(test_level & G_LOG_LEVEL_ERROR))
            {
              masquerade_fatal = fatal_log_func
                && !fatal_log_func (log_domain, test_level, msg, fatal_log_data);
            }

          if ((test_level & G_LOG_FLAG_FATAL) && !masquerade_fatal)
            {
              /* MessageBox is allowed on UWP apps only when building against
               * the debug CRT, which will set -D_DEBUG */
#if defined(G_OS_WIN32) && (defined(_DEBUG) || !defined(G_WINAPI_ONLY_APP))
              if (win32_keep_fatal_message)
                {
                  WCHAR *wide_msg;

                  wide_msg = g_utf8_to_utf16 (fatal_msg_buf, -1, NULL, NULL, NULL);

                  MessageBoxW (NULL, wide_msg, NULL,
                               MB_ICONERROR | MB_SETFOREGROUND);

                  g_free (wide_msg);
                }
#endif

              _g_log_abort (!(test_level & G_LOG_FLAG_RECURSION));
      }
    
    depth--;
    g_private_set (&g_log_depth, GUINT_TO_POINTER (depth));
  }
    }

  g_free (msg_alloc);
}

/**
 * g_log:
 * @log_domain: (nullable): the log domain, usually `G_LOG_DOMAIN`, or `NULL`
 *   for the default
 * @log_level: the log level, either from [type@GLib.LogLevelFlags]
 *   or a user-defined level
 * @format: the message format. See the `printf()` documentation
 * @...: the parameters to insert into the format string
 *
 * Logs an error or debugging message.
 *
 * If the log level has been set as fatal, [func@GLib.BREAKPOINT] is called
 * to terminate the program. See the documentation for [func@GLib.BREAKPOINT] for
 * details of the debugging options this provides.
 *
 * If [func@GLib.log_default_handler] is used as the log handler function, a new-line
 * character will automatically be appended to @..., and need not be entered
 * manually.
 *
 * If [structured logging is enabled](logging.html#using-structured-logging) this will
 * output via the structured log writer function (see [func@GLib.log_set_writer_func]).
 */
void
g_log (const gchar   *log_domain,
       GLogLevelFlags log_level,
       const gchar   *format,
       ...)
{
  va_list args;
  
  va_start (args, format);
  g_logv (log_domain, log_level, format, args);
  va_end (args);
}

/* Return value must be 1 byte long (plus nul byte).
 * Reference: http://man7.org/linux/man-pages/man3/syslog.3.html#DESCRIPTION
 */
static const gchar *
log_level_to_priority (GLogLevelFlags log_level)
{
  if (log_level & G_LOG_LEVEL_ERROR)
    return "3";
  else if (log_level & G_LOG_LEVEL_CRITICAL)
    return "4";
  else if (log_level & G_LOG_LEVEL_WARNING)
    return "4";
  else if (log_level & G_LOG_LEVEL_MESSAGE)
    return "5";
  else if (log_level & G_LOG_LEVEL_INFO)
    return "6";
  else if (log_level & G_LOG_LEVEL_DEBUG)
    return "7";

  /* Default to LOG_NOTICE for custom log levels. */
  return "5";
}

#ifdef HAVE_SYSLOG_H
static int
str_to_syslog_facility (const gchar *syslog_facility_str)
{
  int syslog_facility = LOG_USER;

  if (g_strcmp0 (syslog_facility_str, "auth") == 0)
    {
      syslog_facility = LOG_AUTH;
    }
  else if (g_strcmp0 (syslog_facility_str, "daemon") == 0)
    {
      syslog_facility = LOG_DAEMON;
    }

  return syslog_facility;
}
#endif

static inline FILE *
log_level_to_file (GLogLevelFlags log_level)
{
  if (gmessages_use_stderr)
    return stderr;

  if (log_level & (G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL |
                   G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE))
    return stderr;
  else
    return stdout;
}

static const gchar *
log_level_to_color (GLogLevelFlags log_level,
                    gboolean       use_color)
{
  /* we may not call _any_ GLib functions here */

  if (!use_color)
    return "";

  if (log_level & G_LOG_LEVEL_ERROR)
    return "\033[1;31m"; /* red */
  else if (log_level & G_LOG_LEVEL_CRITICAL)
    return "\033[1;35m"; /* magenta */
  else if (log_level & G_LOG_LEVEL_WARNING)
    return "\033[1;33m"; /* yellow */
  else if (log_level & G_LOG_LEVEL_MESSAGE)
    return "\033[1;32m"; /* green */
  else if (log_level & G_LOG_LEVEL_INFO)
    return "\033[1;32m"; /* green */
  else if (log_level & G_LOG_LEVEL_DEBUG)
    return "\033[1;32m"; /* green */

  /* No color for custom log levels. */
  return "";
}

static const gchar *
color_reset (gboolean use_color)
{
  /* we may not call _any_ GLib functions here */

  if (!use_color)
    return "";

  return "\033[0m";
}

#ifdef G_OS_WIN32

/* We might be using tty emulators such as mintty, so try to detect it, if we passed in a valid FD
 * so we need to check the name of the pipe if _isatty (fd) == 0
 */

static gboolean
win32_is_pipe_tty (int fd)
{
  gboolean result = FALSE;
  HANDLE h_fd;
  FILE_NAME_INFO *info = NULL;
  gint info_size = sizeof (FILE_NAME_INFO) + sizeof (WCHAR) * MAX_PATH;
  wchar_t *name = NULL;
  gint length;

  h_fd = (HANDLE) _get_osfhandle (fd);

  if (h_fd == INVALID_HANDLE_VALUE || GetFileType (h_fd) != FILE_TYPE_PIPE)
    goto done_query;

  /* mintty uses a pipe, in the form of \{cygwin|msys}-xxxxxxxxxxxxxxxx-ptyN-{from|to}-master */

  info = g_try_malloc (info_size);

  if (info == NULL ||
      !GetFileInformationByHandleEx (h_fd, FileNameInfo, info, info_size))
    goto done_query;

  info->FileName[info->FileNameLength / sizeof (WCHAR)] = L'\0';
  name = info->FileName;

  length = wcslen (L"\\cygwin-");
  if (wcsncmp (name, L"\\cygwin-", length))
    {
      length = wcslen (L"\\msys-");
      if (wcsncmp (name, L"\\msys-", length))
        goto done_query;
    }

  name += length;
  length = wcsspn (name, L"0123456789abcdefABCDEF");
  if (length != 16)
    goto done_query;

  name += length;
  length = wcslen (L"-pty");
  if (wcsncmp (name, L"-pty", length))
    goto done_query;

  name += length;
  length = wcsspn (name, L"0123456789");
  if (length != 1)
    goto done_query;

  name += length;
  length = wcslen (L"-to-master");
  if (wcsncmp (name, L"-to-master", length))
    {
      length = wcslen (L"-from-master");
      if (wcsncmp (name, L"-from-master", length))
        goto done_query;
    }

  result = TRUE;

done_query:
  if (info != NULL)
    g_free (info);

  return result;
}
#endif

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wformat-nonliteral"

/**
 * g_log_structured:
 * @log_domain: log domain, usually `G_LOG_DOMAIN`
 * @log_level: log level, either from [type@GLib.LogLevelFlags], or a user-defined
 *    level
 * @...: key-value pairs of structured data to add to the log entry, followed
 *    by the key `MESSAGE`, followed by a `printf()`-style message format,
 *    followed by parameters to insert in the format string
 *
 * Log a message with structured data.
 *
 * The message will be passed through to the log writer set by the application
 * using [func@GLib.log_set_writer_func]. If the message is fatal (i.e. its log level
 * is [flags@GLib.LogLevelFlags.LEVEL_ERROR]), the program will be aborted by calling
 * [func@GLib.BREAKPOINT] at the end of this function. If the log writer returns
 * [enum@GLib.LogWriterOutput.UNHANDLED] (failure), no other fallback writers will be tried.
 * See the documentation for [type@GLib.LogWriterFunc] for information on chaining
 * writers.
 *
 * The structured data is provided as key–value pairs, where keys are UTF-8
 * strings, and values are arbitrary pointers — typically pointing to UTF-8
 * strings, but that is not a requirement. To pass binary (non-nul-terminated)
 * structured data, use [func@GLib.log_structured_array]. The keys for structured data
 * should follow the [systemd journal
 * fields](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html)
 * specification. It is suggested that custom keys are namespaced according to
 * the code which sets them. For example, custom keys from GLib all have a
 * `GLIB_` prefix.
 *
 * Note that keys that expect UTF-8 strings (specifically `"MESSAGE"` and
 * `"GLIB_DOMAIN"`) must be passed as nul-terminated UTF-8 strings until GLib
 * version 2.74.1 because the default log handler did not consider the length of
 * the `GLogField`. Starting with GLib 2.74.1 this is fixed and
 * non-nul-terminated UTF-8 strings can be passed with their correct length.
 *
 * The @log_domain will be converted into a `GLIB_DOMAIN` field. @log_level will
 * be converted into a
 * [`PRIORITY`](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html#PRIORITY=)
 * field. The format string will have its placeholders substituted for the provided
 * values and be converted into a
 * [`MESSAGE`](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html#MESSAGE=)
 * field.
 *
 * Other fields you may commonly want to pass into this function:
 *
 *  * [`MESSAGE_ID`](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html#MESSAGE_ID=)
 *  * [`CODE_FILE`](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html#CODE_FILE=)
 *  * [`CODE_LINE`](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html#CODE_LINE=)
 *  * [`CODE_FUNC`](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html#CODE_FUNC=)
 *  * [`ERRNO`](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html#ERRNO=)
 *
 * Note that `CODE_FILE`, `CODE_LINE` and `CODE_FUNC` are automatically set by
 * the logging macros, [func@GLib.DEBUG_HERE], [func@GLib.message], [func@GLib.warning], [func@GLib.critical],
 * [func@GLib.error], etc, if the symbol `G_LOG_USE_STRUCTURED` is defined before including
 * `glib.h`.
 *
 * For example:
 *
 * ```c
 * g_log_structured (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
 *                   "MESSAGE_ID", "06d4df59e6c24647bfe69d2c27ef0b4e",
 *                   "MY_APPLICATION_CUSTOM_FIELD", "some debug string",
 *                   "MESSAGE", "This is a debug message about pointer %p and integer %u.",
 *                   some_pointer, some_integer);
 * ```
 *
 * Note that each `MESSAGE_ID` must be [uniquely and randomly
 * generated](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html#MESSAGE_ID=).
 * If adding a `MESSAGE_ID`, consider shipping a [message
 * catalog](https://www.freedesktop.org/wiki/Software/systemd/catalog/) with
 * your software.
 *
 * To pass a user data pointer to the log writer function which is specific to
 * this logging call, you must use [func@GLib.log_structured_array] and pass the pointer
 * as a field with `GLogField.length` set to zero, otherwise it will be
 * interpreted as a string.
 *
 * For example:
 *
 * ```c
 * const GLogField fields[] = {
 *   { "MESSAGE", "This is a debug message.", -1 },
 *   { "MESSAGE_ID", "fcfb2e1e65c3494386b74878f1abf893", -1 },
 *   { "MY_APPLICATION_CUSTOM_FIELD", "some debug string", -1 },
 *   { "MY_APPLICATION_STATE", state_object, 0 },
 * };
 * g_log_structured_array (G_LOG_LEVEL_DEBUG, fields, G_N_ELEMENTS (fields));
 * ```
 *
 * Note also that, even if no other structured fields are specified, there
 * must always be a `MESSAGE` key before the format string. The `MESSAGE`-format
 * pair has to be the last of the key-value pairs, and `MESSAGE` is the only
 * field for which `printf()`-style formatting is supported.
 *
 * The default writer function for `stdout` and `stderr` will automatically
 * append a new-line character after the message, so you should not add one
 * manually to the format string.
 *
 * Since: 2.50
 */
void
g_log_structured (const gchar    *log_domain,
                  GLogLevelFlags  log_level,
                  ...)
{
  va_list args;
  gchar buffer[1025], *message_allocated = NULL;
  const char *format;
  const gchar *message;
  gpointer p;
  gsize n_fields, i;
  GLogField stack_fields[16];
  GLogField *fields = stack_fields;
  GLogField *fields_allocated = NULL;
  GArray *array = NULL;

  va_start (args, log_level);

  /* MESSAGE and PRIORITY are a given */
  n_fields = 2;

  if (log_domain)
    n_fields++;

  for (p = va_arg (args, gchar *), i = n_fields;
       strcmp (p, "MESSAGE") != 0;
       p = va_arg (args, gchar *), i++)
    {
      GLogField field;
      const gchar *key = p;
      gconstpointer value = va_arg (args, gpointer);

      field.key = key;
      field.value = value;
      field.length = -1;

      if (i < 16)
        stack_fields[i] = field;
      else
        {
          /* Don't allow dynamic allocation, since we're likely
           * in an out-of-memory situation. For lack of a better solution,
           * just ignore further key-value pairs.
           */
          if (log_level & G_LOG_FLAG_RECURSION)
            continue;

          if (i == 16)
            {
              array = g_array_sized_new (FALSE, FALSE, sizeof (GLogField), 32);
              g_array_append_vals (array, stack_fields, 16);
            }

          g_array_append_val (array, field);
        }
    }

  n_fields = i;

  if (array)
    fields = fields_allocated = (GLogField *) g_array_free (array, FALSE);

  format = va_arg (args, gchar *);

  if (log_level & G_LOG_FLAG_RECURSION)
    {
      /* we use a stack buffer of fixed size, since we're likely
       * in an out-of-memory situation
       */
      gsize size G_GNUC_UNUSED;

      size = _g_vsnprintf (buffer, sizeof (buffer), format, args);
      message = buffer;
    }
  else
    {
      message = format_string (format, args, &message_allocated);
    }

  /* Add MESSAGE, PRIORITY and GLIB_DOMAIN. */
  fields[0].key = "MESSAGE";
  fields[0].value = message;
  fields[0].length = -1;

  fields[1].key = "PRIORITY";
  fields[1].value = log_level_to_priority (log_level);
  fields[1].length = -1;

  if (log_domain)
    {
      fields[2].key = "GLIB_DOMAIN";
      fields[2].value = log_domain;
      fields[2].length = -1;
    }

  /* Log it. */
  g_log_structured_array (log_level, fields, n_fields);

  g_free (fields_allocated);
  g_free (message_allocated);

  va_end (args);
}

/**
 * g_log_variant:
 * @log_domain: (nullable): log domain, usually `G_LOG_DOMAIN`
 * @log_level: log level, either from [type@GLib.LogLevelFlags], or a user-defined
 *    level
 * @fields: a dictionary ([type@GLib.Variant] of the type `G_VARIANT_TYPE_VARDICT`)
 * containing the key-value pairs of message data.
 *
 * Log a message with structured data, accepting the data within a [type@GLib.Variant].
 *
 * This version is especially useful for use in other languages, via introspection.
 *
 * The only mandatory item in the @fields dictionary is the `"MESSAGE"` which must
 * contain the text shown to the user.
 *
 * The values in the @fields dictionary are likely to be of type `G_VARIANT_TYPE_STRING`.
 * Array of bytes (`G_VARIANT_TYPE_BYTESTRING`) is also
 * supported. In this case the message is handled as binary and will be forwarded
 * to the log writer as such. The size of the array should not be higher than
 * `G_MAXSSIZE`. Otherwise it will be truncated to this size. For other types
 * [method@GLib.Variant.print] will be used to convert the value into a string.
 *
 * For more details on its usage and about the parameters, see [func@GLib.log_structured].
 *
 * Since: 2.50
 */
void
g_log_variant (const gchar    *log_domain,
               GLogLevelFlags  log_level,
               GVariant       *fields)
{
  GVariantIter iter;
  GVariant *value;
  gchar *key;
  GArray *fields_array;
  GLogField field;
  GSList *values_list, *print_list;

  g_return_if_fail (g_variant_is_of_type (fields, G_VARIANT_TYPE_VARDICT));

  values_list = print_list = NULL;
  fields_array = g_array_new (FALSE, FALSE, sizeof (GLogField));

  field.key = "PRIORITY";
  field.value = log_level_to_priority (log_level);
  field.length = -1;
  g_array_append_val (fields_array, field);

  if (log_domain)
    {
      field.key = "GLIB_DOMAIN";
      field.value = log_domain;
      field.length = -1;
      g_array_append_val (fields_array, field);
    }

  g_variant_iter_init (&iter, fields);
  while (g_variant_iter_next (&iter, "{&sv}", &key, &value))
    {
      gboolean defer_unref = TRUE;

      field.key = key;
      field.length = -1;

      if (g_variant_is_of_type (value, G_VARIANT_TYPE_STRING))
        {
          field.value = g_variant_get_string (value, NULL);
        }
      else if (g_variant_is_of_type (value, G_VARIANT_TYPE_BYTESTRING))
        {
          gsize s;
          field.value = g_variant_get_fixed_array (value, &s, sizeof (guchar));
          if (G_LIKELY (s <= G_MAXSSIZE))
            {
              field.length = s;
            }
          else
            {
               _g_fprintf (stderr,
                           "Byte array too large (%" G_GSIZE_FORMAT " bytes)"
                           " passed to g_log_variant(). Truncating to " G_STRINGIFY (G_MAXSSIZE)
                           " bytes.", s);
              field.length = G_MAXSSIZE;
            }
        }
      else
        {
          char *s = g_variant_print (value, FALSE);
          field.value = s;
          print_list = g_slist_prepend (print_list, s);
          defer_unref = FALSE;
        }

      g_array_append_val (fields_array, field);

      if (G_LIKELY (defer_unref))
        values_list = g_slist_prepend (values_list, value);
      else
        g_variant_unref (value);
    }

  /* Log it. */
  g_log_structured_array (log_level, (GLogField *) fields_array->data, fields_array->len);

  g_array_free (fields_array, TRUE);
  g_slist_free_full (values_list, (GDestroyNotify) g_variant_unref);
  g_slist_free_full (print_list, g_free);
}


#pragma GCC diagnostic pop

static GLogWriterOutput _g_log_writer_fallback (GLogLevelFlags   log_level,
                                                const GLogField *fields,
                                                gsize            n_fields,
                                                gpointer         user_data);

/**
 * g_log_structured_array:
 * @log_level: log level, either from [type@GLib.LogLevelFlags], or a user-defined
 *    level
 * @fields: (array length=n_fields): key–value pairs of structured data to add
 *    to the log message
 * @n_fields: number of elements in the @fields array
 *
 * Log a message with structured data.
 *
 * The message will be passed through to the log writer set by the application
 * using [func@GLib.log_set_writer_func]. If the
 * message is fatal (i.e. its log level is [flags@GLib.LogLevelFlags.LEVEL_ERROR]), the program will
 * be aborted at the end of this function.
 *
 * See [func@GLib.log_structured] for more documentation.
 *
 * This assumes that @log_level is already present in @fields (typically as the
 * `PRIORITY` field).
 *
 * Since: 2.50
 */
void
g_log_structured_array (GLogLevelFlags   log_level,
                        const GLogField *fields,
                        gsize            n_fields)
{
  GLogWriterFunc writer_func;
  gpointer writer_user_data;
  gboolean recursion;
  guint depth;

  if (n_fields == 0)
    return;

  /* Check for recursion and look up the writer function. */
  depth = GPOINTER_TO_UINT (g_private_get (&g_log_structured_depth));
  recursion = (depth > 0);

  g_mutex_lock (&g_messages_lock);

  writer_func = recursion ? _g_log_writer_fallback : log_writer_func;
  writer_user_data = log_writer_user_data;

  g_mutex_unlock (&g_messages_lock);

  /* Write the log entry. */
  g_private_set (&g_log_structured_depth, GUINT_TO_POINTER (++depth));

  g_assert (writer_func != NULL);
  writer_func (log_level, fields, n_fields, writer_user_data);

  g_private_set (&g_log_structured_depth, GUINT_TO_POINTER (--depth));

  /* Abort if the message was fatal. */
  if (log_level & G_LOG_FATAL_MASK)
    _g_log_abort (!(log_level & G_LOG_FLAG_RECURSION));
}

/* Semi-private helper function to implement the g_message() (etc.) macros
 * with support for G_GNUC_PRINTF so that @message_format can be checked
 * with -Wformat. */
void
g_log_structured_standard (const gchar    *log_domain,
                           GLogLevelFlags  log_level,
                           const gchar    *file,
                           const gchar    *line,
                           const gchar    *func,
                           const gchar    *message_format,
                           ...)
{
  GLogField fields[] =
    {
      { "PRIORITY", log_level_to_priority (log_level), -1 },
      { "CODE_FILE", file, -1 },
      { "CODE_LINE", line, -1 },
      { "CODE_FUNC", func, -1 },
      /* Filled in later: */
      { "MESSAGE", NULL, -1 },
      /* If @log_domain is %NULL, we will not pass this field: */
      { "GLIB_DOMAIN", log_domain, -1 },
    };
  gsize n_fields;
  gchar *message_allocated = NULL;
  gchar buffer[1025];
  va_list args;

  va_start (args, message_format);

  if (log_level & G_LOG_FLAG_RECURSION)
    {
      /* we use a stack buffer of fixed size, since we're likely
       * in an out-of-memory situation
       */
      gsize size G_GNUC_UNUSED;

      size = _g_vsnprintf (buffer, sizeof (buffer), message_format, args);
      fields[4].value = buffer;
    }
  else
    {
      fields[4].value = format_string (message_format, args, &message_allocated);
    }

  va_end (args);

  n_fields = G_N_ELEMENTS (fields) - ((log_domain == NULL) ? 1 : 0);
  g_log_structured_array (log_level, fields, n_fields);

  g_free (message_allocated);
}

/**
 * g_log_set_writer_func:
 * @func: log writer function, which must not be `NULL`
 * @user_data: (closure func): user data to pass to @func
 * @user_data_free: (destroy func): function to free @user_data once it’s
 *    finished with, if non-`NULL`
 *
 * Set a writer function which will be called to format and write out each log
 * message.
 *
 * Each program should set a writer function, or the default writer
 * ([func@GLib.log_writer_default]) will be used.
 *
 * Libraries **must not** call this function — only programs are allowed to
 * install a writer function, as there must be a single, central point where
 * log messages are formatted and outputted.
 *
 * There can only be one writer function. It is an error to set more than one.
 *
 * Since: 2.50
 */
void
g_log_set_writer_func (GLogWriterFunc func,
                       gpointer       user_data,
                       GDestroyNotify user_data_free)
{
  g_return_if_fail (func != NULL);

  g_mutex_lock (&g_messages_lock);

  if (log_writer_func != g_log_writer_default)
    {
      g_mutex_unlock (&g_messages_lock);
      g_error ("g_log_set_writer_func() called multiple times");
      return;
    }

  log_writer_func = func;
  log_writer_user_data = user_data;
  log_writer_user_data_free = user_data_free;

  g_mutex_unlock (&g_messages_lock);
}

/**
 * g_log_writer_supports_color:
 * @output_fd: output file descriptor to check
 *
 * Check whether the given @output_fd file descriptor supports
 * [ANSI color escape sequences](https://en.wikipedia.org/wiki/ANSI_escape_code).
 *
 * If so, they can safely be used when formatting log messages.
 *
 * Returns: `TRUE` if ANSI color escapes are supported, `FALSE` otherwise
 * Since: 2.50
 */
gboolean
g_log_writer_supports_color (gint output_fd)
{
#ifdef G_OS_WIN32
  gboolean result = FALSE;
  GWin32InvalidParameterHandler handler;
#endif

  g_return_val_if_fail (output_fd >= 0, FALSE);

  /* FIXME: This check could easily be expanded in future to be more robust
   * against different types of terminal, which still vary in their color
   * support. cmd.exe on Windows, for example, supports ANSI colors only
   * from Windows 10 onwards; bash on Windows has always supported ANSI colors.
   * The Windows 10 color support is supported on:
   * -Output in the cmd.exe, MSYS/Cygwin standard consoles.
   * -Output in the cmd.exe, MSYS/Cygwin piped to the less program.
   * but not:
   * -Output in Cygwin via mintty (https://github.com/mintty/mintty/issues/482)
   * -Color code output when output redirected to file (i.e. program 2> some.txt)
   *
   * On UNIX systems, we probably want to use the functions from terminfo to
   * work out whether colors are supported.
   *
   * Some examples:
   *  - https://github.com/chalk/supports-color/blob/9434c93918301a6b47faa01999482adfbf1b715c/index.js#L61
   *  - http://stackoverflow.com/questions/16755142/how-to-make-win32-console-recognize-ansi-vt100-escape-sequences
   *  - http://blog.mmediasys.com/2010/11/24/we-all-love-colors/
   *  - http://unix.stackexchange.com/questions/198794/where-does-the-term-environment-variable-default-get-set
   */
#ifdef G_OS_WIN32

  g_win32_push_empty_invalid_parameter_handler (&handler);

  if (g_win32_check_windows_version (10, 0, 0, G_WIN32_OS_ANY))
    {
      HANDLE h_output;
      DWORD dw_mode;

      if (_isatty (output_fd))
        {
          h_output = (HANDLE) _get_osfhandle (output_fd);

          if (!GetConsoleMode (h_output, &dw_mode))
            goto reset_invalid_param_handler;

          if (dw_mode & ENABLE_VIRTUAL_TERMINAL_PROCESSING)
            result = TRUE;

          if (!SetConsoleMode (h_output, dw_mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING))
            goto reset_invalid_param_handler;

          result = TRUE;
        }
    }

  /* FIXME: Support colored outputs for structured logs for pre-Windows 10,
   *        perhaps using WriteConsoleOutput or SetConsoleTextAttribute
   *        (bug 775468), on standard Windows consoles, such as cmd.exe
   */
  if (!result)
    result = win32_is_pipe_tty (output_fd);

reset_invalid_param_handler:
  g_win32_pop_invalid_parameter_handler (&handler);

  return result;
#else
  return isatty (output_fd);
#endif
}

#ifdef HAVE_SYSLOG_H
static gboolean syslog_opened = FALSE;
#ifndef __linux__
G_LOCK_DEFINE_STATIC (syslog_opened);
#endif
#endif

#if defined(__linux__) && !defined(__BIONIC__)
static int journal_fd = -1;

#ifndef SOCK_CLOEXEC
#define SOCK_CLOEXEC 0
#else
#define HAVE_SOCK_CLOEXEC 1
#endif

static void
open_journal (void)
{
  if ((journal_fd = socket (AF_UNIX, SOCK_DGRAM | SOCK_CLOEXEC, 0)) < 0)
    return;

#ifndef HAVE_SOCK_CLOEXEC
  if (fcntl (journal_fd, F_SETFD, FD_CLOEXEC) < 0)
    {
      close (journal_fd);
      journal_fd = -1;
    }
#endif
}
#endif

/**
 * g_log_writer_is_journald:
 * @output_fd: output file descriptor to check
 *
 * Check whether the given @output_fd file descriptor is a connection to the
 * systemd journal, or something else (like a log file or `stdout` or
 * `stderr`).
 *
 * Invalid file descriptors are accepted and return `FALSE`, which allows for
 * the following construct without needing any additional error handling:
 * ```c
 * is_journald = g_log_writer_is_journald (fileno (stderr));
 * ```
 *
 * Returns: `TRUE` if @output_fd points to the journal, `FALSE` otherwise
 * Since: 2.50
 */
gboolean
g_log_writer_is_journald (gint output_fd)
{
#if defined(__linux__) && !defined(__BIONIC__)
  return _g_fd_is_journal (output_fd);
#else
  return FALSE;
#endif
}

static void escape_string (GString *string);

/**
 * g_log_writer_format_fields:
 * @log_level: log level, either from [type@GLib.LogLevelFlags], or a user-defined
 *    level
 * @fields: (array length=n_fields): key–value pairs of structured data forming
 *    the log message
 * @n_fields: number of elements in the @fields array
 * @use_color: `TRUE` to use
 *   [ANSI color escape sequences](https://en.wikipedia.org/wiki/ANSI_escape_code)
 *   when formatting the message, `FALSE` to not
 *
 * Format a structured log message as a string suitable for outputting to the
 * terminal (or elsewhere).
 *
 * This will include the values of all fields it knows
 * how to interpret, which includes `MESSAGE` and `GLIB_DOMAIN` (see the
 * documentation for [func@GLib.log_structured]). It does not include values from
 * unknown fields.
 *
 * The returned string does **not** have a trailing new-line character. It is
 * encoded in the character set of the current locale, which is not necessarily
 * UTF-8.
 *
 * Returns: (transfer full): string containing the formatted log message, in
 *    the character set of the current locale
 * Since: 2.50
 */
gchar *
g_log_writer_format_fields (GLogLevelFlags   log_level,
                            const GLogField *fields,
                            gsize            n_fields,
                            gboolean         use_color)
{
  gsize i;
  const gchar *message = NULL;
  const gchar *log_domain = NULL;
  gssize message_length = -1;
  gssize log_domain_length = -1;
  gchar level_prefix[STRING_BUFFER_SIZE];
  GString *gstring;
  gint64 now;
  time_t now_secs;
  struct tm now_tm;
  gchar time_buf[128];

  /* Extract some common fields. */
  for (i = 0; (message == NULL || log_domain == NULL) && i < n_fields; i++)
    {
      const GLogField *field = &fields[i];

      if (g_strcmp0 (field->key, "MESSAGE") == 0)
        {
          message = field->value;
          message_length = field->length;
        }
      else if (g_strcmp0 (field->key, "GLIB_DOMAIN") == 0)
        {
          log_domain = field->value;
          log_domain_length = field->length;
        }
    }

  /* Format things. */
  mklevel_prefix (level_prefix, log_level, use_color);

  gstring = g_string_new (NULL);
  if (log_level & ALERT_LEVELS)
    g_string_append (gstring, "\n");
  if (!log_domain)
    g_string_append (gstring, "** ");

  if ((g_log_msg_prefix & (log_level & G_LOG_LEVEL_MASK)) ==
      (log_level & G_LOG_LEVEL_MASK))
    {
      const gchar *prg_name = g_get_prgname ();
      gulong pid = getpid ();

      if (prg_name == NULL)
        g_string_append_printf (gstring, "(process:%lu): ", pid);
      else
        g_string_append_printf (gstring, "(%s:%lu): ", prg_name, pid);
    }

  if (log_domain != NULL)
    {
      g_string_append_len (gstring, log_domain, log_domain_length);
      g_string_append_c (gstring, '-');
    }
  g_string_append (gstring, level_prefix);

  g_string_append (gstring, ": ");

  /* Timestamp */
  now = g_get_real_time ();
  now_secs = (time_t) (now / 1000000);
  if (_g_localtime (now_secs, &now_tm))
    strftime (time_buf, sizeof (time_buf), "%H:%M:%S", &now_tm);
  else
    strcpy (time_buf, "(error)");

  g_string_append_printf (gstring, "%s%s.%03d%s: ",
                          use_color ? "\033[34m" : "",
                          time_buf, (gint) ((now / 1000) % 1000),
                          color_reset (use_color));

  if (message == NULL)
    {
      g_string_append (gstring, "(NULL) message");
    }
  else
    {
      GString *msg;
      const gchar *charset;

      msg = g_string_new_len (message, message_length);
      escape_string (msg);

      if (g_get_console_charset (&charset))
        {
          /* charset is UTF-8 already */
          g_string_append (gstring, msg->str);
        }
      else
        {
          gchar *lstring = strdup_convert (msg->str, charset);
          g_string_append (gstring, lstring);
          g_free (lstring);
        }

      g_string_free (msg, TRUE);
    }

  return g_string_free (gstring, FALSE);
}

/**
 * g_log_writer_syslog:
 * @log_level: log level, either from [type@GLib.LogLevelFlags], or a user-defined
 *    level
 * @fields: (array length=n_fields): key–value pairs of structured data forming
 *    the log message
 * @n_fields: number of elements in the @fields array
 * @user_data: user data passed to [func@GLib.log_set_writer_func]
 *
 * Format a structured log message and send it to the syslog daemon. Only fields
 * which are understood by this function are included in the formatted string
 * which is printed.
 *
 * Log facility will be defined via the SYSLOG_FACILITY field and accepts the following
 * values: "auth", "daemon", and "user". If SYSLOG_FACILITY is not specified, LOG_USER
 * facility will be used.
 *
 * This is suitable for use as a [type@GLib.LogWriterFunc].
 *
 * If syslog is not supported, this function is still defined, but will always
 * return [enum@GLib.LogWriterOutput.UNHANDLED].
 *
 * Returns: [enum@GLib.LogWriterOutput.HANDLED] on success, [enum@GLib.LogWriterOutput.UNHANDLED] otherwise
 * Since: 2.80
 */
GLogWriterOutput
g_log_writer_syslog (GLogLevelFlags   log_level,
                     const GLogField *fields,
                     gsize            n_fields,
                     gpointer         user_data)
{
#ifdef HAVE_SYSLOG_H
  gsize i;
  const char *message = NULL;
  const char *log_domain = NULL;
  int syslog_facility = 0;
  int syslog_level;
  gssize message_length = -1;
  gssize log_domain_length = -1;
  GString *gstring;

  g_return_val_if_fail (fields != NULL, G_LOG_WRITER_UNHANDLED);
  g_return_val_if_fail (n_fields > 0, G_LOG_WRITER_UNHANDLED);

/* As not all man pages provide sufficient information about the thread safety
 * of the openlog() routine or even describe alternative routines like logopen_r()
 * intended for multi-threaded applications, use locking on non-Linux platforms till
 * the situation can be cleared. See the following links for more information:
 * FreeBSD: https://man.freebsd.org/cgi/man.cgi?query=openlog
 * NetBSD: https://man.netbsd.org/openlog.3
 * POSIX: https://pubs.opengroup.org/onlinepubs/9699919799.2008edition/functions/openlog.html#
 */
#ifndef __linux__
  G_LOCK (syslog_opened);
#endif

  if (!syslog_opened)
    {
      openlog (NULL, 0, 0);
      syslog_opened = TRUE;
    }

#ifndef __linux__
  G_UNLOCK (syslog_opened);
#endif

  for (i = 0; i < n_fields; i++)
    {
      const GLogField *field = &fields[i];

      if (g_strcmp0 (field->key, "MESSAGE") == 0)
        {
          message = field->value;
          message_length = field->length;
        }
      else if (g_strcmp0 (field->key, "GLIB_DOMAIN") == 0)
        {
          log_domain = field->value;
          log_domain_length = field->length;
        }
      else if (g_strcmp0 (field->key, "SYSLOG_FACILITY") == 0)
        {
          syslog_facility = str_to_syslog_facility (field->value);
        }
    }

  gstring = g_string_new (NULL);

  if (log_domain != NULL)
    {
      g_string_append_len (gstring, log_domain, log_domain_length);
      g_string_append (gstring, ": ");
    }

  g_string_append_len (gstring, message, message_length);

  syslog_level = atoi (log_level_to_priority (log_level));
  syslog (syslog_level | syslog_facility, "%s", gstring->str);

  g_string_free (gstring, TRUE);

  return G_LOG_WRITER_HANDLED;
#else
  return G_LOG_WRITER_UNHANDLED;
#endif /* HAVE_SYSLOG_H */
}

/* Enable support for the journal if we're on a recent enough Linux */
#if defined(__linux__) && !defined(__BIONIC__) && defined(HAVE_MKOSTEMP) && defined(O_CLOEXEC)
#define ENABLE_JOURNAL_SENDV
#endif

#ifdef ENABLE_JOURNAL_SENDV
static int
journal_sendv (struct iovec *iov,
               gsize         iovlen)
{
  int buf_fd = -1;
  struct msghdr mh;
  struct sockaddr_un sa;
  union {
    struct cmsghdr cmsghdr;
    guint8 buf[CMSG_SPACE(sizeof(int))];
  } control;
  struct cmsghdr *cmsg;
  char path[] = "/dev/shm/journal.XXXXXX";

  if (journal_fd < 0)
    open_journal ();

  if (journal_fd < 0)
    return -1;

  memset (&sa, 0, sizeof (sa));
  sa.sun_family = AF_UNIX;
  if (g_strlcpy (sa.sun_path, "/run/systemd/journal/socket", sizeof (sa.sun_path)) >= sizeof (sa.sun_path))
    return -1;

  memset (&mh, 0, sizeof (mh));
  mh.msg_name = &sa;
  mh.msg_namelen = offsetof (struct sockaddr_un, sun_path) + strlen (sa.sun_path);
  mh.msg_iov = iov;
  mh.msg_iovlen = iovlen;

retry:
  if (sendmsg (journal_fd, &mh, MSG_NOSIGNAL) >= 0)
    return 0;

  if (errno == EINTR)
    goto retry;

  if (errno != EMSGSIZE && errno != ENOBUFS)
    return -1;

  /* Message was too large, so dump to temporary file
   * and pass an FD to the journal
   */
  if ((buf_fd = mkostemp (path, O_CLOEXEC|O_RDWR)) < 0)
    return -1;

  if (unlink (path) < 0)
    {
      close (buf_fd);
      return -1;
    }

  if (writev (buf_fd, iov, iovlen) < 0)
    {
      close (buf_fd);
      return -1;
    }

  mh.msg_iov = NULL;
  mh.msg_iovlen = 0;

  memset (&control, 0, sizeof (control));
  mh.msg_control = &control;
  mh.msg_controllen = sizeof (control);

  cmsg = CMSG_FIRSTHDR (&mh);
  cmsg->cmsg_level = SOL_SOCKET;
  cmsg->cmsg_type = SCM_RIGHTS;
  cmsg->cmsg_len = CMSG_LEN (sizeof (int));
  memcpy (CMSG_DATA (cmsg), &buf_fd, sizeof (int));

  mh.msg_controllen = cmsg->cmsg_len;

retry2:
  if (sendmsg (journal_fd, &mh, MSG_NOSIGNAL) >= 0)
    return 0;

  if (errno == EINTR)
    goto retry2;

  return -1;
}
#endif /* ENABLE_JOURNAL_SENDV */

/**
 * g_log_writer_journald:
 * @log_level: log level, either from [type@GLib.LogLevelFlags], or a user-defined
 *    level
 * @fields: (array length=n_fields): key–value pairs of structured data forming
 *    the log message
 * @n_fields: number of elements in the @fields array
 * @user_data: user data passed to [func@GLib.log_set_writer_func]
 *
 * Format a structured log message and send it to the systemd journal as a set
 * of key–value pairs.
 *
 * All fields are sent to the journal, but if a field has
 * length zero (indicating program-specific data) then only its key will be
 * sent.
 *
 * This is suitable for use as a [type@GLib.LogWriterFunc].
 *
 * If GLib has been compiled without systemd support, this function is still
 * defined, but will always return [enum@GLib.LogWriterOutput.UNHANDLED].
 *
 * Returns: [enum@GLib.LogWriterOutput.HANDLED] on success, [enum@GLib.LogWriterOutput.UNHANDLED] otherwise
 * Since: 2.50
 */
GLogWriterOutput
g_log_writer_journald (GLogLevelFlags   log_level,
                       const GLogField *fields,
                       gsize            n_fields,
                       gpointer         user_data)
{
#ifdef ENABLE_JOURNAL_SENDV
  const char equals = '=';
  const char newline = '\n';
  gsize i, k;
  struct iovec *iov, *v;
  char *buf;
  gint retval;

  g_return_val_if_fail (fields != NULL, G_LOG_WRITER_UNHANDLED);
  g_return_val_if_fail (n_fields > 0, G_LOG_WRITER_UNHANDLED);

  /* According to systemd.journal-fields(7), the journal allows fields in any
   * format (including arbitrary binary), but expects text fields to be UTF-8.
   * This is great, because we require input strings to be in UTF-8, so no
   * conversion is necessary and we don’t need to care about the current
   * locale’s character set.
   */

  iov = g_alloca (sizeof (struct iovec) * 5 * n_fields);
  buf = g_alloca (32 * n_fields);

  k = 0;
  v = iov;
  for (i = 0; i < n_fields; i++)
    {
      guint64 length;
      gboolean binary;

      if (fields[i].length < 0)
        {
          length = strlen (fields[i].value);
          binary = strchr (fields[i].value, '\n') != NULL;
        }
      else
        {
          length = fields[i].length;
          binary = TRUE;
        }

      if (binary)
        {
          guint64 nstr;

          v[0].iov_base = (gpointer)fields[i].key;
          v[0].iov_len = strlen (fields[i].key);

          v[1].iov_base = (gpointer)&newline;
          v[1].iov_len = 1;

          nstr = GUINT64_TO_LE(length);
          memcpy (&buf[k], &nstr, sizeof (nstr));

          v[2].iov_base = &buf[k];
          v[2].iov_len = sizeof (nstr);
          v += 3;
          k += sizeof (nstr);
        }
      else
        {
          v[0].iov_base = (gpointer)fields[i].key;
          v[0].iov_len = strlen (fields[i].key);

          v[1].iov_base = (gpointer)&equals;
          v[1].iov_len = 1;
          v += 2;
        }

      v[0].iov_base = (gpointer)fields[i].value;
      v[0].iov_len = length;

      v[1].iov_base = (gpointer)&newline;
      v[1].iov_len = 1;
      v += 2;
    }

  retval = journal_sendv (iov, v - iov);

  return retval == 0 ? G_LOG_WRITER_HANDLED : G_LOG_WRITER_UNHANDLED;
#else
  return G_LOG_WRITER_UNHANDLED;
#endif /* ENABLE_JOURNAL_SENDV */
}

/**
 * g_log_writer_standard_streams:
 * @log_level: log level, either from [type@GLib.LogLevelFlags], or a user-defined
 *    level
 * @fields: (array length=n_fields): key–value pairs of structured data forming
 *    the log message
 * @n_fields: number of elements in the @fields array
 * @user_data: user data passed to [func@GLib.log_set_writer_func]
 *
 * Format a structured log message and print it to either `stdout` or `stderr`,
 * depending on its log level.
 *
 * [flags@GLib.LogLevelFlags.LEVEL_INFO] and [flags@GLib.LogLevelFlags.LEVEL_DEBUG] messages
 * are sent to `stdout`, or to `stderr` if requested by
 * [func@GLib.log_writer_default_set_use_stderr];
 * all other log levels are sent to `stderr`. Only fields
 * which are understood by this function are included in the formatted string
 * which is printed.
 *
 * If the output stream supports
 * [ANSI color escape sequences](https://en.wikipedia.org/wiki/ANSI_escape_code),
 * they will be used in the output.
 *
 * A trailing new-line character is added to the log message when it is printed.
 *
 * This is suitable for use as a [type@GLib.LogWriterFunc].
 *
 * Returns: [enum@GLib.LogWriterOutput.HANDLED] on success,
 *   [enum@GLib.LogWriterOutput.UNHANDLED] otherwise
 * Since: 2.50
 */
GLogWriterOutput
g_log_writer_standard_streams (GLogLevelFlags   log_level,
                               const GLogField *fields,
                               gsize            n_fields,
                               gpointer         user_data)
{
  FILE *stream;
  gchar *out = NULL;  /* in the current locale’s character set */

  g_return_val_if_fail (fields != NULL, G_LOG_WRITER_UNHANDLED);
  g_return_val_if_fail (n_fields > 0, G_LOG_WRITER_UNHANDLED);

  stream = log_level_to_file (log_level);
  if (!stream || fileno (stream) < 0)
    return G_LOG_WRITER_UNHANDLED;

  out = g_log_writer_format_fields (log_level, fields, n_fields,
                                    g_log_writer_supports_color (fileno (stream)));
  _g_fprintf (stream, "%s\n", out);
  fflush (stream);
  g_free (out);

  return G_LOG_WRITER_HANDLED;
}

/* The old g_log() API is implemented in terms of the new structured log API.
 * However, some of the checks do not line up between the two APIs: the
 * structured API only handles fatalness of messages for log levels; the old API
 * handles it per-domain as well. Consequently, we need to disable fatalness
 * handling in the structured log API when called from the old g_log() API.
 *
 * We can guarantee that g_log_default_handler() will pass GLIB_OLD_LOG_API as
 * the first field to g_log_structured_array(), if that is the case.
 */
static gboolean
log_is_old_api (const GLogField *fields,
                gsize            n_fields)
{
  return (n_fields >= 1 &&
          g_strcmp0 (fields[0].key, "GLIB_OLD_LOG_API") == 0 &&
          g_strcmp0 (fields[0].value, "1") == 0);
}

static gboolean
domain_found (const gchar *domains,
              const char  *log_domain)
{
  guint len;
  const gchar *found;

  len = strlen (log_domain);

  for (found = strstr (domains, log_domain); found;
       found = strstr (found + 1, log_domain))
    {
      if ((found == domains || found[-1] == ' ')
          && (found[len] == 0 || found[len] == ' '))
        return TRUE;
    }

  return FALSE;
}

static struct {
  GRWLock lock;
  gchar *domains;
  gboolean domains_set;
} g_log_global;

/**
 * g_log_writer_default_set_debug_domains:
 * @domains: (nullable) (transfer none): `NULL`-terminated array with domains to be printed.
 *   `NULL` or an array with no values means none. Array with a single value `"all"` means all.
 *
 * Reset the list of domains to be logged, that might be initially set by the
 * `G_MESSAGES_DEBUG` environment variable.
 *
 * This function is thread-safe.
 *
 * Since: 2.80
 */
void
g_log_writer_default_set_debug_domains (const gchar * const *domains)
{
  g_rw_lock_writer_lock (&g_log_global.lock);

  g_free (g_log_global.domains);
  g_log_global.domains = domains ?
      g_strjoinv (" ", (gchar **)domains) : NULL;

  g_log_global.domains_set = TRUE;

  g_rw_lock_writer_unlock (&g_log_global.lock);
}

/*
 * Internal version of g_log_writer_default_would_drop(), which can
 * read from either a log_domain or an array of fields. This avoids
 * having to iterate through the fields if the @log_level is sufficient
 * to make the decision.
 */
static gboolean
should_drop_message (GLogLevelFlags   log_level,
                     const char      *log_domain,
                     const GLogField *fields,
                     gsize            n_fields)
{
  /* Disable debug message output unless specified in G_MESSAGES_DEBUG. */
  if (!(log_level & DEFAULT_LEVELS) &&
      !(log_level >> G_LOG_LEVEL_USER_SHIFT) &&
      !g_log_get_debug_enabled ())
    {
      gsize i;

      g_rw_lock_reader_lock (&g_log_global.lock);

      if (G_UNLIKELY (!g_log_global.domains_set))
        {
          g_log_global.domains = g_strdup (g_getenv ("G_MESSAGES_DEBUG"));
          g_log_global.domains_set = TRUE;
        }

      if ((log_level & INFO_LEVELS) == 0 ||
          g_log_global.domains == NULL)
        {
          g_rw_lock_reader_unlock (&g_log_global.lock);
          return TRUE;
        }

      if (log_domain == NULL)
        {
          for (i = 0; i < n_fields; i++)
            {
              if (g_strcmp0 (fields[i].key, "GLIB_DOMAIN") == 0)
                {
                  log_domain = fields[i].value;
                  break;
                }
            }
        }

      if (strcmp (g_log_global.domains, "all") != 0 &&
          (log_domain == NULL || !domain_found (g_log_global.domains, log_domain)))
        {
          g_rw_lock_reader_unlock (&g_log_global.lock);
          return TRUE;
        }

      g_rw_lock_reader_unlock (&g_log_global.lock);
    }

  return FALSE;
}

/**
 * g_log_writer_default_would_drop:
 * @log_domain: (nullable): log domain
 * @log_level: log level, either from [type@GLib.LogLevelFlags], or a user-defined
 *    level
 *
 * Check whether [func@GLib.log_writer_default] and [func@GLib.log_default_handler] would
 * ignore a message with the given domain and level.
 *
 * As with [func@GLib.log_default_handler], this function drops debug and informational
 * messages unless their log domain (or `all`) is listed in the space-separated
 * `G_MESSAGES_DEBUG` environment variable, or by [func@GLib.log_writer_default_set_debug_domains].
 *
 * This can be used when implementing log writers with the same filtering
 * behaviour as the default, but a different destination or output format:
 *
 * ```c
 * if (g_log_writer_default_would_drop (log_level, log_domain))
 *   return G_LOG_WRITER_HANDLED;
 * ]|
 *
 * or to skip an expensive computation if it is only needed for a debugging
 * message, and `G_MESSAGES_DEBUG` is not set:
 *
 * ```c
 * if (!g_log_writer_default_would_drop (G_LOG_LEVEL_DEBUG, G_LOG_DOMAIN))
 *   {
 *     g_autofree gchar *result = expensive_computation (my_object);
 *
 *     g_debug ("my_object result: %s", result);
 *   }
 * ```
 *
 * Returns: `TRUE` if the log message would be dropped by GLib’s
 *   default log handlers
 * Since: 2.68
 */
gboolean
g_log_writer_default_would_drop (GLogLevelFlags  log_level,
                                 const char     *log_domain)
{
  return should_drop_message (log_level, log_domain, NULL, 0);
}

/**
 * g_log_writer_default:
 * @log_level: log level, either from [type@GLib.LogLevelFlags], or a user-defined
 *    level
 * @fields: (array length=n_fields): key–value pairs of structured data forming
 *    the log message
 * @n_fields: number of elements in the @fields array
 * @user_data: user data passed to [func@GLib.log_set_writer_func]
 *
 * Format a structured log message and output it to the default log destination
 * for the platform.
 *
 * On Linux, this is typically the systemd journal, falling
 * back to `stdout` or `stderr` if running from the terminal or if output is
 * being redirected to a file.
 *
 * Support for other platform-specific logging mechanisms may be added in
 * future. Distributors of GLib may modify this function to impose their own
 * (documented) platform-specific log writing policies.
 *
 * This is suitable for use as a [type@GLib.LogWriterFunc], and is the default writer used
 * if no other is set using [func@GLib.log_set_writer_func].
 *
 * As with [func@GLib.log_default_handler], this function drops debug and informational
 * messages unless their log domain (or `all`) is listed in the space-separated
 * `G_MESSAGES_DEBUG` environment variable, or set at runtime by [func@GLib.log_writer_default_set_debug_domains].
 *
 * [func@GLib.log_writer_default] uses the mask set by [func@GLib.log_set_always_fatal] to
 * determine which messages are fatal. When using a custom writer function instead it is
 * up to the writer function to determine which log messages are fatal.
 *
 * Returns: [enum@GLib.LogWriterOutput.HANDLED] on success,
 *   [enum@GLib.LogWriterOutput.UNHANDLED] otherwise
 * Since: 2.50
 */
GLogWriterOutput
g_log_writer_default (GLogLevelFlags   log_level,
                      const GLogField *fields,
                      gsize            n_fields,
                      gpointer         user_data)
{
  static gsize initialized = 0;
  static gboolean stderr_is_journal = FALSE;

  g_return_val_if_fail (fields != NULL, G_LOG_WRITER_UNHANDLED);
  g_return_val_if_fail (n_fields > 0, G_LOG_WRITER_UNHANDLED);

  if (should_drop_message (log_level, NULL, fields, n_fields))
    return G_LOG_WRITER_HANDLED;

  /* Mark messages as fatal if they have a level set in
   * g_log_set_always_fatal().
   */
  if ((log_level & g_log_always_fatal) && !log_is_old_api (fields, n_fields))
    log_level |= G_LOG_FLAG_FATAL;

  /* Try logging to the systemd journal as first choice. */
  if (g_once_init_enter (&initialized))
    {
      stderr_is_journal = g_log_writer_is_journald (fileno (stderr));
      g_once_init_leave (&initialized, TRUE);
    }

  if (stderr_is_journal &&
      g_log_writer_journald (log_level, fields, n_fields, user_data) ==
      G_LOG_WRITER_HANDLED)
    goto handled;

  /* FIXME: Add support for the Windows log. */

  if (g_log_writer_standard_streams (log_level, fields, n_fields, user_data) ==
      G_LOG_WRITER_HANDLED)
    goto handled;

  return G_LOG_WRITER_UNHANDLED;

handled:
  /* Abort if the message was fatal. */
  if (log_level & G_LOG_FLAG_FATAL)
    {
      /* MessageBox is allowed on UWP apps only when building against
       * the debug CRT, which will set -D_DEBUG */
#if defined(G_OS_WIN32) && (defined(_DEBUG) || !defined(G_WINAPI_ONLY_APP))
      if (!g_test_initialized ())
        {
          WCHAR *wide_msg;

          wide_msg = g_utf8_to_utf16 (fatal_msg_buf, -1, NULL, NULL, NULL);

          MessageBoxW (NULL, wide_msg, NULL, MB_ICONERROR | MB_SETFOREGROUND);

          g_free (wide_msg);
        }
#endif /* !G_OS_WIN32 */

      _g_log_abort (!(log_level & G_LOG_FLAG_RECURSION));
    }

  return G_LOG_WRITER_HANDLED;
}

static GLogWriterOutput
_g_log_writer_fallback (GLogLevelFlags   log_level,
                        const GLogField *fields,
                        gsize            n_fields,
                        gpointer         user_data)
{
  FILE *stream;
  gsize i;

  /* we cannot call _any_ GLib functions in this fallback handler,
   * which is why we skip UTF-8 conversion, etc.
   * since we either recursed or ran out of memory, we're in a pretty
   * pathologic situation anyways, what we can do is giving the
   * the process ID unconditionally however.
   */

  stream = log_level_to_file (log_level);

  for (i = 0; i < n_fields; i++)
    {
      const GLogField *field = &fields[i];

      /* Only print fields we definitely recognise, otherwise we could end up
       * printing a random non-string pointer provided by the user to be
       * interpreted by their writer function.
       */
      if (strcmp (field->key, "MESSAGE") != 0 &&
          strcmp (field->key, "MESSAGE_ID") != 0 &&
          strcmp (field->key, "PRIORITY") != 0 &&
          strcmp (field->key, "CODE_FILE") != 0 &&
          strcmp (field->key, "CODE_LINE") != 0 &&
          strcmp (field->key, "CODE_FUNC") != 0 &&
          strcmp (field->key, "ERRNO") != 0 &&
          strcmp (field->key, "SYSLOG_FACILITY") != 0 &&
          strcmp (field->key, "SYSLOG_IDENTIFIER") != 0 &&
          strcmp (field->key, "SYSLOG_PID") != 0 &&
          strcmp (field->key, "GLIB_DOMAIN") != 0)
        continue;

      write_string (stream, field->key);
      write_string (stream, "=");
      write_string_sized (stream, field->value, field->length);
    }

#ifndef G_OS_WIN32
  {
    gchar pid_string[FORMAT_UNSIGNED_BUFSIZE];

    format_unsigned (pid_string, getpid (), 10);
    write_string (stream, "_PID=");
    write_string (stream, pid_string);
  }
#endif

  return G_LOG_WRITER_HANDLED;
}

/**
 * g_log_get_debug_enabled:
 *
 * Return whether debug output from the GLib logging system is enabled.
 *
 * Note that this should not be used to conditionalise calls to [func@GLib.debug] or
 * other logging functions; it should only be used from [type@GLib.LogWriterFunc]
 * implementations.
 *
 * Note also that the value of this does not depend on `G_MESSAGES_DEBUG`, nor
 * [func@GLib.log_writer_default_set_debug_domains]; see the docs for [func@GLib.log_set_debug_enabled].
 *
 * Returns: `TRUE` if debug output is enabled, `FALSE` otherwise
 *
 * Since: 2.72
 */
gboolean
g_log_get_debug_enabled (void)
{
  return g_atomic_int_get (&g_log_debug_enabled);
}

/**
 * g_log_set_debug_enabled:
 * @enabled: `TRUE` to enable debug output, `FALSE` otherwise
 *
 * Enable or disable debug output from the GLib logging system for all domains.
 *
 * This value interacts disjunctively with `G_MESSAGES_DEBUG` and
 * [func@GLib.log_writer_default_set_debug_domains] — if any of them would allow
 * a debug message to be outputted, it will be.
 *
 * Note that this should not be used from within library code to enable debug
 * output — it is intended for external use.
 *
 * Since: 2.72
 */
void
g_log_set_debug_enabled (gboolean enabled)
{
  g_atomic_int_set (&g_log_debug_enabled, enabled);
}

/**
 * g_return_if_fail_warning: (skip)
 * @log_domain: (nullable): log domain
 * @pretty_function: function containing the assertion
 * @expression: (nullable): expression which failed
 *
 * Internal function used to print messages from the public [func@GLib.return_if_fail]
 * and [func@GLib.return_val_if_fail] macros.
 */
void
g_return_if_fail_warning (const char *log_domain,
        const char *pretty_function,
        const char *expression)
{
  g_log (log_domain,
   G_LOG_LEVEL_CRITICAL,
   "%s: assertion '%s' failed",
   pretty_function,
   expression);
}

/**
 * g_warn_message: (skip)
 * @domain: (nullable): log domain
 * @file: file containing the warning
 * @line: line number of the warning
 * @func: function containing the warning
 * @warnexpr: (nullable): expression which failed
 *
 * Internal function used to print messages from the public [func@GLib.warn_if_reached]
 * and [func@GLib.warn_if_fail] macros.
 */
void
g_warn_message (const char     *domain,
                const char     *file,
                int             line,
                const char     *func,
                const char     *warnexpr)
{
  char *s, lstr[32];
  g_snprintf (lstr, 32, "%d", line);
  if (warnexpr)
    s = g_strconcat ("(", file, ":", lstr, "):",
                     func, func[0] ? ":" : "",
                     " runtime check failed: (", warnexpr, ")", NULL);
  else
    s = g_strconcat ("(", file, ":", lstr, "):",
                     func, func[0] ? ":" : "",
                     " ", "code should not be reached", NULL);
  g_log (domain, G_LOG_LEVEL_WARNING, "%s", s);
  g_free (s);
}

void
g_assert_warning (const char *log_domain,
      const char *file,
      const int   line,
      const char *pretty_function,
      const char *expression)
{
  if (expression)
    g_log (log_domain,
     G_LOG_LEVEL_ERROR,
     "file %s: line %d (%s): assertion failed: (%s)",
     file,
     line,
     pretty_function,
     expression);
  else
    g_log (log_domain,
     G_LOG_LEVEL_ERROR,
     "file %s: line %d (%s): should not be reached",
     file,
     line,
     pretty_function);
  _g_log_abort (FALSE);
  g_abort ();
}

/**
 * g_test_expect_message:
 * @log_domain: (nullable): the log domain of the message
 * @log_level: the log level of the message
 * @pattern: a glob-style pattern (see [type@GLib.PatternSpec])
 *
 * Indicates that a message with the given @log_domain and @log_level,
 * with text matching @pattern, is expected to be logged.
 *
 * When this message is logged, it will not be printed, and the test case will
 * not abort.
 *
 * This API may only be used with the old logging API ([func@GLib.log] without
 * `G_LOG_USE_STRUCTURED` defined). It will not work with the structured logging
 * API. See [Testing for Messages](logging.html#testing-for-messages).
 *
 * Use [func@GLib.test_assert_expected_messages] to assert that all
 * previously-expected messages have been seen and suppressed.
 *
 * You can call this multiple times in a row, if multiple messages are
 * expected as a result of a single call. (The messages must appear in
 * the same order as the calls to [func@GLib.test_expect_message].)
 *
 * For example:
 *
 * ```c
 * // g_main_context_push_thread_default() should fail if the
 * // context is already owned by another thread.
 * g_test_expect_message (G_LOG_DOMAIN,
 *                        G_LOG_LEVEL_CRITICAL,
 *                        "assertion*acquired_context*failed");
 * g_main_context_push_thread_default (bad_context);
 * g_test_assert_expected_messages ();
 * ```
 *
 * Note that you cannot use this to test [func@GLib.error] messages, since
 * [func@GLib.error] intentionally never returns even if the program doesn’t
 * abort; use [func@GLib.test_trap_subprocess] in this case.
 *
 * If messages at [flags@GLib.LogLevelFlags.LEVEL_DEBUG] are emitted, but not explicitly
 * expected via [func@GLib.test_expect_message] then they will be ignored.
 *
 * Since: 2.34
 */
void
g_test_expect_message (const gchar    *log_domain,
                       GLogLevelFlags  log_level,
                       const gchar    *pattern)
{
  GTestExpectedMessage *expected;

  g_return_if_fail (log_level != 0);
  g_return_if_fail (pattern != NULL);
  g_return_if_fail (~log_level & G_LOG_LEVEL_ERROR);

  expected = g_new (GTestExpectedMessage, 1);
  expected->log_domain = g_strdup (log_domain);
  expected->log_level = log_level;
  expected->pattern = g_strdup (pattern);

  expected_messages = g_slist_append (expected_messages, expected);
}

void
g_test_assert_expected_messages_internal (const char     *domain,
                                          const char     *file,
                                          int             line,
                                          const char     *func)
{
  if (expected_messages)
    {
      GTestExpectedMessage *expected;
      gchar level_prefix[STRING_BUFFER_SIZE];
      gchar *message;

      expected = expected_messages->data;

      mklevel_prefix (level_prefix, expected->log_level, FALSE);
      message = g_strdup_printf ("Did not see expected message %s-%s: %s",
                                 expected->log_domain ? expected->log_domain : "**",
                                 level_prefix, expected->pattern);
      g_assertion_message (G_LOG_DOMAIN, file, line, func, message);
      g_free (message);
    }
}

/**
 * g_test_assert_expected_messages:
 *
 * Asserts that all messages previously indicated via
 * [func@GLib.test_expect_message] have been seen and suppressed.
 *
 * This API may only be used with the old logging API ([func@GLib.log] without
 * `G_LOG_USE_STRUCTURED` defined). It will not work with the structured logging
 * API. See [Testing for Messages](logging.html#testing-for-messages).
 *
 * If messages at [flags@GLib.LogLevelFlags.LEVEL_DEBUG] are emitted, but not explicitly
 * expected via [func@GLib.test_expect_message] then they will be ignored.
 *
 * Since: 2.34
 */

void
_g_log_fallback_handler (const gchar   *log_domain,
       GLogLevelFlags log_level,
       const gchar   *message,
       gpointer       unused_data)
{
  gchar level_prefix[STRING_BUFFER_SIZE];
#ifndef G_OS_WIN32
  gchar pid_string[FORMAT_UNSIGNED_BUFSIZE];
#endif
  FILE *stream;

  /* we cannot call _any_ GLib functions in this fallback handler,
   * which is why we skip UTF-8 conversion, etc.
   * since we either recursed or ran out of memory, we're in a pretty
   * pathologic situation anyways, what we can do is giving the
   * the process ID unconditionally however.
   */

  stream = mklevel_prefix (level_prefix, log_level, FALSE);
  if (!message)
    message = "(NULL) message";

#ifndef G_OS_WIN32
  format_unsigned (pid_string, getpid (), 10);
#endif

  if (log_domain)
    write_string (stream, "\n");
  else
    write_string (stream, "\n** ");

#ifndef G_OS_WIN32
  write_string (stream, "(process:");
  write_string (stream, pid_string);
  write_string (stream, "): ");
#endif

  if (log_domain)
    {
      write_string (stream, log_domain);
      write_string (stream, "-");
    }
  write_string (stream, level_prefix);
  write_string (stream, ": ");
  write_string (stream, message);
  write_string (stream, "\n");
}

static void
escape_string (GString *string)
{
  const char *p = string->str;
  gunichar wc;

  while (p < string->str + string->len)
    {
      gboolean safe;
      
      wc = g_utf8_get_char_validated (p, -1);
      if (wc == (gunichar)-1 || wc == (gunichar)-2)  
  {
    gchar *tmp;
    guint pos;

    pos = p - string->str;

    /* Emit invalid UTF-8 as hex escapes 
           */
    tmp = g_strdup_printf ("\\x%02x", (guint)(guchar)*p);
    g_string_erase (string, pos, 1);
    g_string_insert (string, pos, tmp);

    p = string->str + (pos + 4); /* Skip over escape sequence */

    g_free (tmp);
    continue;
  }
      if (wc == '\r')
  {
    safe = *(p + 1) == '\n';
  }
      else
  {
    safe = CHAR_IS_SAFE (wc);
  }
      
      if (!safe)
  {
    gchar *tmp;
    guint pos;

    pos = p - string->str;
    
    /* Largest char we escape is 0x0a, so we don't have to worry
     * about 8-digit \Uxxxxyyyy
     */
    tmp = g_strdup_printf ("\\u%04x", wc); 
    g_string_erase (string, pos, g_utf8_next_char (p) - p);
    g_string_insert (string, pos, tmp);
    g_free (tmp);

    p = string->str + (pos + 6); /* Skip over escape sequence */
  }
      else
  p = g_utf8_next_char (p);
    }
}

/**
 * g_log_default_handler:
 * @log_domain: (nullable): the log domain of the message, or `NULL` for the
 *   default `""` application domain
 * @log_level: the level of the message
 * @message: (nullable): the message
 * @unused_data: (nullable): data passed from [func@GLib.log] which is unused
 *
 * The default log handler set up by GLib; [func@GLib.log_set_default_handler]
 * allows to install an alternate default log handler.
 *
 * This is used if no log handler has been set for the particular log
 * domain and log level combination. It outputs the message to `stderr`
 * or `stdout` and if the log level is fatal it calls [func@GLib.BREAKPOINT]. It automatically
 * prints a new-line character after the message, so one does not need to be
 * manually included in @message.
 *
 * The behavior of this log handler can be influenced by a number of
 * environment variables:
 *
 *   - `G_MESSAGES_PREFIXED`: A `:`-separated list of log levels for which
 *     messages should be prefixed by the program name and PID of the
 *     application.
 *   - `G_MESSAGES_DEBUG`: A space-separated list of log domains for
 *     which debug and informational messages are printed. By default
 *     these messages are not printed. If you need to set the allowed
 *     domains at runtime, use [func@GLib.log_writer_default_set_debug_domains].
 *
 * `stderr` is used for levels [flags@GLib.LogLevelFlags.LEVEL_ERROR],
 * [flags@GLib.LogLevelFlags.LEVEL_CRITICAL], [flags@GLib.LogLevelFlags.LEVEL_WARNING] and
 * [flags@GLib.LogLevelFlags.LEVEL_MESSAGE]. `stdout` is used for
 * the rest, unless `stderr` was requested by
 * [func@GLib.log_writer_default_set_use_stderr].
 *
 * This has no effect if structured logging is enabled; see
 * [Using Structured Logging](logging.html#using-structured-logging).
 */
void
g_log_default_handler (const gchar   *log_domain,
           GLogLevelFlags log_level,
           const gchar   *message,
           gpointer       unused_data)
{
  GLogField fields[4];
  int n_fields = 0;

  /* we can be called externally with recursion for whatever reason */
  if (log_level & G_LOG_FLAG_RECURSION)
    {
      _g_log_fallback_handler (log_domain, log_level, message, unused_data);
      return;
    }

  fields[0].key = "GLIB_OLD_LOG_API";
  fields[0].value = "1";
  fields[0].length = -1;
  n_fields++;

  fields[1].key = "MESSAGE";
  fields[1].value = message;
  fields[1].length = -1;
  n_fields++;

  fields[2].key = "PRIORITY";
  fields[2].value = log_level_to_priority (log_level);
  fields[2].length = -1;
  n_fields++;

  if (log_domain)
    {
      fields[3].key = "GLIB_DOMAIN";
      fields[3].value = log_domain;
      fields[3].length = -1;
      n_fields++;
    }

  /* Print out via the structured log API, but drop any fatal flags since we
   * have already handled them. The fatal handling in the structured logging
   * API is more coarse-grained than in the old g_log() API, so we don't want
   * to use it here.
   */
  g_log_structured_array (log_level & ~G_LOG_FLAG_FATAL, fields, n_fields);
}

/**
 * g_set_print_handler:
 * @func: (nullable): the new print handler or `NULL` to
 *   reset to the default
 *
 * Sets the print handler to @func, or resets it to the
 * default GLib handler if `NULL`.
 *
 * Any messages passed to [func@GLib.print] will be output via
 * the new handler. The default handler outputs
 * the encoded message to `stdout`. By providing your own handler
 * you can redirect the output, to a GTK widget or a
 * log file for example.
 *
 * Since 2.76 this functions always returns a valid
 * [type@GLib.PrintFunc], and never returns `NULL`. If no custom
 * print handler was set, it will return the GLib
 * default print handler and that can be re-used to
 * decorate its output and/or to write to `stderr`
 * in all platforms. Before GLib 2.76, this was `NULL`.
 *
 * Returns: (not nullable): the old print handler
 */
GPrintFunc
g_set_print_handler (GPrintFunc func)
{
  return g_atomic_pointer_exchange (&glib_print_func,
                                    func ? func : g_default_print_func);
}

static void
print_string (FILE        *stream,
              const gchar *string)
{
  const gchar *charset;
  int ret;

  if (g_get_console_charset (&charset))
    {
      /* charset is UTF-8 already */
      ret = fputs (string, stream);
    }
  else
    {
      gchar *converted_string = strdup_convert (string, charset);

      ret = fputs (converted_string, stream);
      g_free (converted_string);
    }

  /* In case of failure we can just return early, but there's nothing else
   * we can do at this level
   */
  if (ret == EOF)
    return;

  fflush (stream);
}

G_ALWAYS_INLINE static inline const char *
format_string (const char *format,
               va_list     args,
               char      **out_allocated_string)
{
#ifdef G_ENABLE_DEBUG
  g_assert (out_allocated_string != NULL);
#endif

  /* If there is no formatting to be done, avoid an allocation */
  if (strchr (format, '%') == NULL)
    {
      *out_allocated_string = NULL;
      return format;
    }
  else
    {
      *out_allocated_string = g_strdup_vprintf (format, args);
      return *out_allocated_string;
    }
}

static void
g_default_print_func (const gchar *string)
{
  print_string (stdout, string);
}

static void
g_default_printerr_func (const gchar *string)
{
  print_string (stderr, string);
}

/**
 * g_print:
 * @format: the message format. See the `printf()` documentation
 * @...: the parameters to insert into the format string
 *
 * Outputs a formatted message via the print handler.
 *
 * The default print handler outputs the encoded message to `stdout`, without
 * appending a trailing new-line character. Typically, @format should end with
 * its own new-line character.
 *
 * This function should not be used from within libraries for debugging
 * messages, since it may be redirected by applications to special
 * purpose message windows or even files. Instead, libraries should
 * use [func@GLib.log], [func@GLib.log_structured], or the convenience macros
 * [func@GLib.message], [func@GLib.warning] and [func@GLib.error].
 */
void
g_print (const gchar *format,
         ...)
{
  va_list args;
  const gchar *string;
  gchar *free_me = NULL;
  GPrintFunc local_glib_print_func;

  g_return_if_fail (format != NULL);

  va_start (args, format);
  string = format_string (format, args, &free_me);
  va_end (args);

  local_glib_print_func = g_atomic_pointer_get (&glib_print_func);
  local_glib_print_func (string);
  g_free (free_me);
}

/**
 * g_set_printerr_handler:
 * @func: (nullable): he new error message handler or `NULL`
 *   to reset to the default
 *
 * Sets the handler for printing error messages to @func,
 * or resets it to the default GLib handler if `NULL`.
 *
 * Any messages passed to [func@GLib.printerr] will be output via
 * the new handler. The default handler outputs the encoded
 * message to `stderr`. By providing your own handler you can
 * redirect the output, to a GTK widget or a log file for
 * example.
 *
 * Since 2.76 this functions always returns a valid
 * [type@GLib.PrintFunc], and never returns `NULL`. If no custom error
 * print handler was set, it will return the GLib default
 * error print handler and that can be re-used to decorate
 * its output and/or to write to `stderr` in all platforms.
 * Before GLib 2.76, this was `NULL`.
 *
 * Returns: (not nullable): the old error message handler
 */
GPrintFunc
g_set_printerr_handler (GPrintFunc func)
{
  return g_atomic_pointer_exchange (&glib_printerr_func,
                                    func ? func : g_default_printerr_func);
}

/**
 * g_printerr:
 * @format: the message format. See the `printf()` documentation
 * @...: the parameters to insert into the format string
 *
 * Outputs a formatted message via the error message handler.
 *
 * The default handler outputs the encoded message to `stderr`, without appending
 * a trailing new-line character. Typically, @format should end with its own
 * new-line character.
 *
 * This function should not be used from within libraries.
 * Instead [func@GLib.log] or [func@GLib.log_structured] should be used, or the convenience
 * macros [func@GLib.message], [func@GLib.warning] and [func@GLib.error].
 */
void
g_printerr (const gchar *format,
            ...)
{
  va_list args;
  const char *string;
  char *free_me = NULL;
  GPrintFunc local_glib_printerr_func;

  g_return_if_fail (format != NULL);

  va_start (args, format);
  string = format_string (format, args, &free_me);
  va_end (args);

  local_glib_printerr_func = g_atomic_pointer_get (&glib_printerr_func);
  local_glib_printerr_func (string);
  g_free (free_me);
}

/**
 * g_printf_string_upper_bound:
 * @format: the format string. See the `printf()` documentation
 * @args: the parameters to be inserted into the format string
 *
 * Calculates the maximum space needed to store the output
 * of the `sprintf()` function.
 *
 * If @format or @args are invalid, `0` is returned. This could happen if, for
 * example, @format contains an `%lc` or `%ls` placeholder and @args contains a
 * wide character which cannot be represented in multibyte encoding. `0`
 * can also be returned legitimately if, for example, @format is `%s` and @args
 * is an empty string. The caller is responsible for differentiating these two
 * return cases if necessary. It is recommended to not use `%lc` or `%ls`
 * placeholders in any case, as their behaviour is locale-dependent.
 *
 * Returns: the maximum space needed to store the formatted string, or `0` on error
 */
gsize
g_printf_string_upper_bound (const gchar *format,
                             va_list      args)
{
  gchar c;
  int count = _g_vsnprintf (&c, 1, format, args);

  if (count < 0)
    return 0;

  return count + 1;
}

Coverage Report

Created: 2025-08-28 06:48