/* GLIB - Library of useful routines for C programming

 * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald

 *

 * 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

 */

/**

 * SECTION:messages

 * @Title: Message Output and Debugging Functions

 * @Short_description: functions to output messages and help debug applications

 *

 * These functions provide support for outputting messages.

 *

 * The g_return family of macros (g_return_if_fail(),

 * g_return_val_if_fail(), g_return_if_reached(),

 * g_return_val_if_reached()) should only be used for programming

 * errors, a typical use case is checking for invalid parameters at

 * the beginning of a public function. They should not be used if

 * you just mean "if (error) return", they should only be used if

 * you mean "if (bug in program) return". The program behavior is

 * generally considered undefined after one of these checks fails.

 * They are not intended for normal control flow, only to give a

 * perhaps-helpful warning before giving up.

 *

 * Structured logging output is supported using g_log_structured(). This differs

 * from the traditional g_log() API in that log messages are handled as a

 * collection of key–value pairs representing individual pieces of information,

 * rather than as a single string containing all the information in an arbitrary

 * format.

 *

 * The convenience macros g_info(), g_message(), g_debug(), g_warning() and g_error()

 * will use the traditional g_log() API unless you define the symbol

 * %G_LOG_USE_STRUCTURED before including `glib.h`. But note that even messages

 * logged through the traditional g_log() API are ultimatively passed to

 * g_log_structured(), so that all log messages end up in same destination.

 * If %G_LOG_USE_STRUCTURED is defined, g_test_expect_message() will become

 * ineffective for the wrapper macros g_warning() and friends (see

 * [Testing for Messages][testing-for-messages]).

 *

 * The support for structured logging was motivated by the following needs (some

 * of which were supported previously; others weren’t):

 *  * Support for multiple logging levels.

 *  * Structured log support with the ability to add `MESSAGE_ID`s (see

 *    g_log_structured()).

 *  * Moving the responsibility for filtering log messages from the program to

 *    the log viewer — instead of libraries and programs installing log handlers

 *    (with g_log_set_handler()) which filter messages before output, all log

 *    messages are outputted, and the log viewer program (such as `journalctl`)

 *    must filter them. This is based on the idea that bugs are sometimes hard

 *    to reproduce, so it is better to log everything possible and then use

 *    tools to analyse the logs than it is to not be able to reproduce a bug to

 *    get additional log data. Code which uses logging in performance-critical

 *    sections should compile out the g_log_structured() calls in

 *    release builds, and compile them in in debugging builds.

 *  * A single writer function which handles all log messages in a process, from

 *    all libraries and program code; rather than multiple log handlers with

 *    poorly defined interactions between them. This allows a program to easily

 *    change its logging policy by changing the writer function, for example to

 *    log to an additional location or to change what logging output fallbacks

 *    are used. The log writer functions provided by GLib are exposed publicly

 *    so they can be used from programs’ log writers. This allows log writer

 *    policy and implementation to be kept separate.

 *  * If a library wants to add standard information to all of its log messages

 *    (such as library state) or to redact private data (such as passwords or

 *    network credentials), it should use a wrapper function around its

 *    g_log_structured() calls or implement that in the single log writer

 *    function.

 *  * If a program wants to pass context data from a g_log_structured() call to

 *    its log writer function so that, for example, it can use the correct

 *    server connection to submit logs to, that user data can be passed as a

 *    zero-length #GLogField to g_log_structured_array().

 *  * Color output needed to be supported on the terminal, to make reading

 *    through logs easier.

 *

 * ## Using Structured Logging ## {#using-structured-logging}

 *

 * To use structured logging (rather than the old-style logging), either use

 * the g_log_structured() and g_log_structured_array() functions; or define

 * `G_LOG_USE_STRUCTURED` before including any GLib header, and use the

 * g_message(), g_debug(), g_error() (etc.) macros.

 *

 * You do not need to define `G_LOG_USE_STRUCTURED` to use g_log_structured(),

 * but it is a good idea to avoid confusion.

 *

 * ## Log Domains ## {#log-domains}

 *

 * Log domains may be used to broadly split up the origins of log messages.

 * Typically, there are one or a few log domains per application or library.

 * %G_LOG_DOMAIN should be used to define the default log domain for the current

 * compilation unit — it is typically defined at the top of a source file, or in

 * the preprocessor flags for a group of source 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`.

 *

 * ## Debug Message Output ## {#debug-message-output}

 *

 * The default log functions (g_log_default_handler() for the old-style API and

 * g_log_writer_default() for the structured API) both drop debug and

 * informational messages by default, unless the log domains of those messages

 * are listed in the `G_MESSAGES_DEBUG` environment variable (or it is set to

 * `all`).

 *

 * It is recommended that custom log writer functions re-use the

 * `G_MESSAGES_DEBUG` environment variable, rather than inventing a custom one,

 * so that developers can re-use the same debugging techniques and tools across

 * projects.

 *

 * ## Testing for Messages ## {#testing-for-messages}

 *

 * With the old g_log() API, g_test_expect_message() and

 * g_test_assert_expected_messages() could be used in simple cases to check

 * whether some code under test had emitted a given log message. These

 * functions have been deprecated with the structured logging API, for several

 * reasons:

 *  * They relied on an internal queue which was too inflexible for many use

 *    cases, where messages might be emitted in several orders, some

 *    messages might not be emitted deterministically, or messages might be

 *    emitted by unrelated log domains.

 *  * They do not support structured log fields.

 *  * Examining the log output of code is a bad approach to testing it, and

 *    while it might be necessary for legacy code which uses g_log(), it should

 *    be avoided for new code using g_log_structured().

 *

 * They will continue to work as before if g_log() is in use (and

 * %G_LOG_USE_STRUCTURED is not defined). They will do nothing if used with the

 * structured logging API.

 *

 * Examining the log output of code is discouraged: libraries should not emit to

 * `stderr` during defined behaviour, and hence this should not be tested. If

 * the log emissions of a library during undefined behaviour need to be tested,

 * they should be limited to asserting that the library aborts and prints a

 * suitable error message before aborting. This should be done with

 * g_test_trap_assert_stderr().

 *

 * If it is really necessary to test the structured log messages emitted by a

 * particular piece of code – and the code cannot be restructured to be more

 * suitable to more conventional unit testing – you should write a custom log

 * writer function (see g_log_set_writer_func()) which appends all log messages

 * to a queue. When you want to check the log messages, examine and clear the

 * queue, ignoring irrelevant log messages (for example, from log domains other

 * than the one under test).

 */

#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 "glib-init.h"

#include "galloca.h"

#include "gbacktrace.h"

#include "gcharset.h"

#include "gconvert.h"

#include "genviron.h"

#include "gmain.h"

#include "gmem.h"

#include "gprintfint.h"

#include "gtestutils.h"

#include "gthread.h"

#include "gstrfuncs.h"

#include "gstring.h"

#include "gpattern.h"

#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

/* XXX: Remove once XP support really dropped */

#if _WIN32_WINNT < 0x0600

typedef enum _FILE_INFO_BY_HANDLE_CLASS

{

  FileBasicInfo                   = 0,

  FileStandardInfo                = 1,

  FileNameInfo                    = 2,

  FileRenameInfo                  = 3,

  FileDispositionInfo             = 4,

  FileAllocationInfo              = 5,

  FileEndOfFileInfo               = 6,

  FileStreamInfo                  = 7,

  FileCompressionInfo             = 8,

  FileAttributeTagInfo            = 9,

  FileIdBothDirectoryInfo         = 10,

  FileIdBothDirectoryRestartInfo  = 11,

  FileIoPriorityHintInfo          = 12,

  FileRemoteProtocolInfo          = 13,

  FileFullDirectoryInfo           = 14,

  FileFullDirectoryRestartInfo    = 15,

  FileStorageInfo                 = 16,

  FileAlignmentInfo               = 17,

  FileIdInfo                      = 18,

  FileIdExtdDirectoryInfo         = 19,

  FileIdExtdDirectoryRestartInfo  = 20,

  MaximumFileInfoByHandlesClass

} FILE_INFO_BY_HANDLE_CLASS;

typedef struct _FILE_NAME_INFO

{

  DWORD FileNameLength;

  WCHAR FileName[1];

} FILE_NAME_INFO;

typedef BOOL (WINAPI fGetFileInformationByHandleEx) (HANDLE,

                                                     FILE_INFO_BY_HANDLE_CLASS,

                                                     LPVOID,

                                                     DWORD);

#endif

#if defined (_MSC_VER) && (_MSC_VER >=1400)

/* This is ugly, but we need it for isatty() in case we have bad fd's,

 * otherwise Windows will abort() the program on msvcrt80.dll and later

 */

#include <crtdbg.h>

_GLIB_EXTERN void

myInvalidParameterHandler(const wchar_t *expression,

                          const wchar_t *function,

                          const wchar_t *file,

                          unsigned int   line,

                          uintptr_t      pReserved)

{

}

#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][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 g_log_set_handler()

 *

 * Specifies the prototype of log handler functions.

 *

 * The default log handler, g_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][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 g_error().

 *     This level is also used for messages produced by g_assert().

 * @G_LOG_LEVEL_CRITICAL: log level for critical warning messages, see

 *     g_critical().

 *     This level is also used for messages produced by g_return_if_fail()

 *     and g_return_val_if_fail().

 * @G_LOG_LEVEL_WARNING: log level for warnings, see g_warning()

 * @G_LOG_LEVEL_MESSAGE: log level for messages, see g_message()

 * @G_LOG_LEVEL_INFO: log level for informational messages, see g_info()

 * @G_LOG_LEVEL_DEBUG: log level for debug messages, see g_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 g_log_set_handler() and g_log_set_fatal_mask().

 */

/**

 * G_LOG_LEVEL_USER_SHIFT:

 *

 * Log levels below 1<

 * 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 g_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 g_log_structured();

 * otherwise it will use g_log(). See

 * [Using Structured Logging][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 #GError is

 * preferred for that instead, as it allows calling functions to perform actions

 * conditional on the type of error.

 *

 * 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 g_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 g_log_structured();

 * otherwise it will use g_log(). See

 * [Using Structured Logging][using-structured-logging].

 */

/**

 * g_critical:

 * @...: format string, followed by parameters to insert

 *     into the format string (as with printf())

 *

 * Logs a "critical warning" (#G_LOG_LEVEL_CRITICAL).

 * It's more or less application-defined what constitutes

 * a critical vs. a regular warning. You could call

 * g_log_set_always_fatal() to make critical warnings exit

 * the program, then use g_critical() for fatal errors, for

 * example.

 *

 * You can also 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

 * ]|

 *

 * 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 g_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 g_log_structured();

 * otherwise it will use g_log(). See

 * [Using Structured Logging][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 #GError 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

 * abort() 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 g_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 g_log_structured();

 * otherwise it will use g_log(). See

 * [Using Structured Logging][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 g_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 g_log_default_handler() and

 * g_log_writer_default() unless the `G_MESSAGES_DEBUG` environment variable is

 * set appropriately.

 *

 * If structured logging is enabled, this will use g_log_structured();

 * otherwise it will use g_log(). See

 * [Using Structured Logging][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 g_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 g_log_default_handler() and

 * g_log_writer_default() unless the `G_MESSAGES_DEBUG` environment variable is

 * set appropriately.

 *

 * If structured logging is enabled, this will use g_log_structured();

 * otherwise it will use g_log(). See

 * [Using Structured Logging][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;

};

/* --- variables --- */

static GMutex         g_messages_lock;

static GLogDomain    *g_log_domains = NULL;

static GPrintFunc     glib_print_func = NULL;

static GPrintFunc     glib_printerr_func = NULL;

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;

/* --- functions --- */

static void _g_log_abort (gboolean breakpoint);

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.";

static gchar *fatal_msg_ptr = fatal_msg_buf;

#undef write

static inline int

dowrite (int          fd,

	 const void  *buf,

	 unsigned int len)

{

  if (win32_keep_fatal_message)

    {

      memcpy (fatal_msg_ptr, buf, len);

      fatal_msg_ptr += len;

      *fatal_msg_ptr = 0;

      return len;

    }

  write (fd, buf, len);

  return len;

}

#define write(fd, buf, len) dowrite(fd, buf, len)

#endif

static void

write_string (FILE        *stream,

	      const gchar *string)

{

  fputs (string, stream);

}

static void

write_string_sized (FILE        *stream,

                    const gchar *string,

                    gssize       length)

{

  /* Is it nul-terminated? */

  if (length < 0)

    write_string (stream, string);

  else

    fwrite (string, 1, length, stream);

}

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.

 * %G_LOG_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 g_log_structured() and

 * g_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][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.

 * %G_LOG_LEVEL_ERROR is always fatal.

 *

 * This has no effect on structured log messages (using g_log_structured() or

 * g_log_structured_array()). To change the fatal behaviour for specific log

 * messages, programs must install a custom log writer function using

 * g_log_set_writer_func(). See

 * [Using Structured Logging][using-structured-logging].

 *

 * 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 #G_LOG_FLAG_FATAL and

 *     #G_LOG_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 #G_LOG_FLAG_FATAL and #G_LOG_FLAG_RECURSION

 * bit flags.

 *

 * Note that since the #G_LOG_LEVEL_ERROR log level is always fatal, if

 * you want to set a handler for this log level you must combine it with

 * #G_LOG_FLAG_FATAL.

 *

 * This has no effect if structured logging is enabled; see

 * [Using Structured Logging][using-structured-logging].

 *

 * Here is an example for adding a log handler for all warning messages

 * in the default domain:

 * |[ 

 * 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+:

 * |[ 

 * 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:

 * |[ 

 * 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 #G_LOG_FLAG_FATAL and

 *     #G_LOG_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 g_log_set_handler(), but takes a destroy notify for the @user_data.

 *

 * This has no effect if structured logging is enabled; see