void
msg_init(gboolean interactive)
{
if (evt_context)
return;
if (!interactive)
{
g_log_handler_id = g_log_set_handler(G_LOG_DOMAIN, 0xff, msg_log_func, NULL);
glib_handler_id = g_log_set_handler("GLib", 0xff, msg_log_func, NULL);
}
else
{
log_stderr = TRUE;
skip_timestamp_on_stderr = TRUE;
}
evt_context = evt_ctx_init("syslog-ng", EVT_FAC_SYSLOG);
}
void
gkr_debug_message (GkrDebugFlags flag,
const gchar *format,
...)
{
static gsize initialized_flags = 0;
const gchar *messages_env;
const gchar *debug_env;
va_list args;
if (g_once_init_enter (&initialized_flags)) {
messages_env = g_getenv ("G_MESSAGES_DEBUG");
debug_env = g_getenv ("GKR_DEBUG");
#ifdef GKR_DEBUG
if (debug_env == NULL)
debug_env = G_STRINGIFY (GKR_DEBUG);
#endif
/*
* If the caller is selectively asking for certain debug
* messages with the GKR_DEBUG environment variable, then
* we install our own output handler and only print those
* messages. This happens irrespective of G_MESSAGES_DEBUG
*/
if (messages_env == NULL && debug_env != NULL)
g_log_set_handler (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
on_gkr_log_debug, NULL);
/*
* If the caller is using G_MESSAGES_DEBUG then we enable
* all our debug messages, and let Glib filter which ones
* to display.
*/
if (messages_env != NULL && debug_env == NULL)
debug_env = "all";
gkr_debug_set_flags (debug_env);
#ifdef FOR_WHEN_ALL_ELSE_FAILS
openlog ("libgnome-keyring", LOG_NDELAY | LOG_PID, LOG_AUTHPRIV);
gkr_debug_set_flags ("all");
#endif
g_once_init_leave (&initialized_flags, 1);
}
if (flag & current_flags) {
va_start (args, format);
g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, format, args);
va_end (args);
}
#ifdef FOR_WHEN_ALL_ELSE_FAILS
va_start (args, format);
vsyslog (LOG_ERR, format, args);
va_end (args);
#endif
}
int
main (int argc, char *argv[])
{
guint owner_id;
g_autoptr(GError) error = NULL;
GDBusConnection *session_bus;
GOptionContext *context;
setlocale (LC_ALL, "");
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
/* Avoid even loading gvfs to avoid accidental confusion */
g_setenv ("GIO_USE_VFS", "local", TRUE);
gtk_init (&argc, &argv);
context = g_option_context_new ("- file chooser portal");
g_option_context_add_main_entries (context, entries, NULL);
if (!g_option_context_parse (context, &argc, &argv, &error))
{
g_printerr ("option parsing failed: %s\n", error->message);
return 1;
}
if (opt_verbose)
g_log_set_handler (NULL, G_LOG_LEVEL_DEBUG, message_handler, NULL);
g_set_prgname (argv[0]);
loop = g_main_loop_new (NULL, FALSE);
outstanding_handles = g_hash_table_new (g_str_hash, g_str_equal);
session_bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
if (session_bus == NULL)
{
g_printerr ("No session bus: %s\n", error->message);
return 2;
}
owner_id = g_bus_own_name (G_BUS_TYPE_SESSION,
"org.freedesktop.impl.portal.desktop.gtk",
G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT | (opt_replace ? G_BUS_NAME_OWNER_FLAGS_REPLACE : 0),
on_bus_acquired,
on_name_acquired,
on_name_lost,
NULL,
NULL);
g_main_loop_run (loop);
g_bus_unown_name (owner_id);
return 0;
}
static void
logging_setup (void)
{
openlog (G_LOG_DOMAIN, LOG_CONS, LOG_DAEMON);
g_log_set_handler (G_LOG_DOMAIN,
G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION,
log_handler,
NULL);
}
/**
* pk_debug_add_log_domain:
*/
void
pk_debug_add_log_domain (const gchar *log_domain)
{
if (_verbose) {
g_log_set_fatal_mask (log_domain, G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL);
g_log_set_handler (log_domain,
G_LOG_LEVEL_ERROR |
G_LOG_LEVEL_CRITICAL |
G_LOG_LEVEL_DEBUG |
G_LOG_LEVEL_WARNING,
pk_debug_handler_cb, NULL);
} else {
/* hide all debugging */
g_log_set_handler (log_domain,
G_LOG_LEVEL_DEBUG | G_LOG_LEVEL_WARNING,
pk_debug_ignore_cb, NULL);
}
}
int
main (int argc, char *argv[])
{
gboolean ret;
gboolean debug_mode = FALSE;
GOptionContext *ctx;
GError *err = NULL;
GOptionEntry options[] = {
{"debug-mode", 'd', 0, G_OPTION_ARG_NONE, &debug_mode, "debug mode", NULL},
{NULL}
};
gtk_init (&argc, &argv);
ctx = g_option_context_new (" -codecanalyzer options");
g_option_context_add_main_entries (ctx, options, NULL);
if (!g_option_context_parse (ctx, &argc, &argv, &err)) {
if (err)
g_printerr ("Failed to initialize: %s\n", err->message);
else
g_printerr ("Failed to initialize, Unknown error\n");
exit (1);
}
g_option_context_free (ctx);
if (debug_mode) {
g_log_set_handler (G_LOG_DOMAIN, G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL,
g_log_default_handler, NULL);
g_setenv ("G_MESSAGES_DEBUG", "all", TRUE);
g_debug ("Codecanalyzer is in DEBUG_MODE..");
}
xmlKeepBlanksDefault (0);
ret = analyzer_ui_init ();
if (!ret) {
g_error ("Failed to activate the gtk+-3.x backend \n");
goto done;
}
ret = analyzer_create_dirs ();
if (!ret) {
g_error ("Failed to create the necessary dir names \n");
goto done;
}
gtk_builder_connect_signals (ui->builder, NULL);
gtk_widget_show_all (ui->main_window);
gtk_main ();
done:
g_printf ("Closing Codecanalyzer....\n");
return 0;
}
int main(void)
{
stringleton_init ();
g_log_set_handler (NULL, G_LOG_LEVEL_DEBUG, debug_null, NULL);
run_suite (dmapd_test_parse_plugin_option_suite());
run_suite (dmapd_test_daap_record_suite());
exit (EXIT_SUCCESS);
}
static void set_g_logging (int debug)
{
void (*handler) (const gchar *, GLogLevelFlags,
const gchar *, gpointer);
GLogLevelFlags flags = G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING |
G_LOG_LEVEL_DEBUG;
if (debug) {
handler = stderr_output_handler;
} else {
handler = dummy_output_handler;
}
g_log_set_handler("Gtk", flags, (GLogFunc) handler, NULL);
g_log_set_handler("Gdk", flags, (GLogFunc) handler, NULL);
g_log_set_handler("GLib", flags, (GLogFunc) handler, NULL);
g_log_set_handler("Pango", flags, (GLogFunc) handler, NULL);
g_log_set_handler("GtkSourceView", flags, (GLogFunc) handler, NULL);
}
int main (int argc, char *argv[])
{
/* Initialize GTK+ */
g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING, (GLogFunc) gtk_false, NULL);
gtk_init (&argc, &argv);
g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING, g_log_default_handler, NULL);
for( int i = 0; i < argc; ++i ) {
aux::a2w w(argv[i]);
_argv.push_back(sciter::string(w.c_str(),w.length()));
}
auto message_pump = []() -> int {
gtk_main ();
return 0;
};
return uimain(message_pump);
}
int
main (int argc,
char **argv)
{
guint owner_id;
GMainLoop *loop;
GOptionContext *context;
g_autoptr(GError) error = NULL;
setlocale (LC_ALL, "");
g_setenv ("GIO_USE_VFS", "local", TRUE);
g_set_prgname (argv[0]);
flatpak_migrate_from_xdg_app ();
g_set_printerr_handler (printerr_handler);
context = g_option_context_new ("- permission store");
g_option_context_add_main_entries (context, entries, NULL);
if (!g_option_context_parse (context, &argc, &argv, &error))
{
g_printerr ("Option parsing failed: %s", error->message);
return 1;
}
if (opt_version)
{
g_print ("%s\n", PACKAGE_STRING);
exit (EXIT_SUCCESS);
}
if (opt_verbose)
g_log_set_handler (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, message_handler, NULL);
g_set_prgname (argv[0]);
owner_id = g_bus_own_name (G_BUS_TYPE_SESSION,
"org.freedesktop.impl.portal.PermissionStore",
G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT | (opt_replace ? G_BUS_NAME_OWNER_FLAGS_REPLACE : 0),
on_bus_acquired,
on_name_acquired,
on_name_lost,
NULL,
NULL);
loop = g_main_loop_new (NULL, FALSE);
g_main_loop_run (loop);
g_bus_unown_name (owner_id);
return 0;
}
void wm_debug_startup(void)
{
struct t_paths *p = t_paths_new();
gchar *dir = g_build_filename(t_paths_cache_home(p), "lboxwm", NULL);
if(!t_paths_mkdir_path(dir, 0777))
g_message(_("Unable to make directory '%s': %s"), dir, g_strerror(errno));
else {
gchar *name = g_build_filename(t_paths_cache_home(p), "lboxwm", "lboxwm.log", NULL);
unlink(name);
log_file = fopen(name, "w");
g_free(name);
} rr_handler_id =
g_log_set_handler("lboxwm_render", G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION, log_handler, NULL);
t_handler_id =
g_log_set_handler("lboxwm_toolkit", G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION, log_handler, NULL);
lboxwm_handler_id =
g_log_set_handler("lboxwm", G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION, log_handler, NULL);
t_paths_unref(p);
g_free(dir);
}
//_________________________________________________________
LogHandler::~LogHandler( void )
{
if( _gtkLogId > 0 )
{
g_log_remove_handler( "Gtk", _gtkLogId );
g_log_set_handler( "Gtk", G_LOG_LEVEL_WARNING, g_log_default_handler, 0L );
}
if( _glibLogId > 0 )
{
g_log_remove_handler( "GLib-GObject", _glibLogId );
g_log_set_handler( "GLib-GObject", G_LOG_LEVEL_CRITICAL, g_log_default_handler, 0L );
}
}
void
InstallGdkErrorHandler()
{
g_log_set_handler("Gdk",
(GLogLevelFlags)(G_LOG_LEVEL_ERROR | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION),
GdkErrorHandler,
nullptr);
if (PR_GetEnv("MOZ_X_SYNC")) {
XSynchronize(GDK_DISPLAY_XDISPLAY(gdk_display_get_default()), True);
}
}
int main (int argc, char *argv[])
{
GCompletion *cmp;
GList *items;
gchar *prefix;
#ifdef __SYMBIAN32__
g_log_set_handler (NULL, G_LOG_FLAG_FATAL| G_LOG_FLAG_RECURSION | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG, &mrtLogHandler, NULL);
g_set_print_handler(mrtPrintHandler);
#endif /*__SYMBIAN32__*/
cmp = g_completion_new (NULL);
items = NULL;
items = g_list_append (items, "a\302\243");
items = g_list_append (items, "a\302\244");
items = g_list_append (items, "bb");
items = g_list_append (items, "bc");
g_completion_add_items (cmp, items);
items = g_completion_complete (cmp, "a", &prefix);
g_assert (!strcmp ("a\302", prefix));
g_assert (g_list_length (items) == 2);
g_free (prefix);
items = g_completion_complete_utf8 (cmp, "a", &prefix);
g_assert (!strcmp ("a", prefix));
g_assert (g_list_length (items) == 2);
g_free (prefix);
items = g_completion_complete (cmp, "b", &prefix);
g_assert (!strcmp ("b", prefix));
g_assert (g_list_length (items) == 2);
g_free (prefix);
items = g_completion_complete_utf8 (cmp, "b", &prefix);
g_assert (!strcmp ("b", prefix));
g_assert (g_list_length (items) == 2);
g_free (prefix);
items = g_completion_complete (cmp, "a", NULL);
g_assert (g_list_length (items) == 2);
items = g_completion_complete_utf8 (cmp, "a", NULL);
g_assert (g_list_length (items) == 2);
g_completion_free (cmp);
#if __SYMBIAN32__
testResultXml("completion-test");
#endif /* EMULATOR */
return 0;
}
int
main (int argc, char *argv[])
{
guint owner_id;
g_autoptr(GError) error = NULL;
GDBusConnection *session_bus;
GOptionContext *context;
setlocale (LC_ALL, "");
/* Avoid even loading gvfs to avoid accidental confusion */
g_setenv ("GIO_USE_VFS", "local", TRUE);
g_set_printerr_handler (printerr_handler);
context = g_option_context_new ("- desktop portal");
g_option_context_add_main_entries (context, entries, NULL);
if (!g_option_context_parse (context, &argc, &argv, &error))
{
g_printerr ("Option parsing failed: %s", error->message);
return 1;
}
if (opt_verbose)
g_log_set_handler (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, message_handler, NULL);
g_set_prgname (argv[0]);
load_installed_portals ();
loop = g_main_loop_new (NULL, FALSE);
session_bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
if (session_bus == NULL)
{
g_printerr ("No session bus: %s", error->message);
return 2;
}
owner_id = g_bus_own_name (G_BUS_TYPE_SESSION,
"org.freedesktop.portal.Desktop",
G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT | (opt_replace ? G_BUS_NAME_OWNER_FLAGS_REPLACE : 0),
on_bus_acquired,
on_name_acquired,
on_name_lost,
NULL,
NULL);
g_main_loop_run (loop);
g_bus_unown_name (owner_id);
return 0;
}
int
main (int argc, char **argv)
{
GIOChannel *gio;
GMainLoop *ml;
gchar *path;
gchar *tmp;
xmmsc_connection_t *conn;
xmmsc_result_t *res;
xmonitor_t *mon;
gint fd;
conn = xmmsc_init ("xmms-medialib-updater");
path = getenv ("XMMS_PATH");
if (!xmmsc_connect (conn, path)) {
ERR ("Could not connect to xmms2d %s", xmmsc_get_last_error (conn));
return EXIT_FAILURE;
}
ml = g_main_loop_new (NULL, FALSE);
xmmsc_mainloop_gmain_init (conn);
xmmsc_disconnect_callback_set (conn, quit, ml);
mon = g_new0 (xmonitor_t, 1);
fd = monitor_init (mon);
mon->conn = conn;
if (fd == -1) {
ERR ("Couldn't initalize monitor");
return EXIT_FAILURE;
}
tmp = getenv("XMMS_DEBUG");
if (!tmp) {
g_log_set_handler (NULL, G_LOG_LEVEL_MESSAGE | G_LOG_FLAG_RECURSION,
message_handler, NULL);
}
gio = g_io_channel_unix_new (fd);
g_io_add_watch (gio, G_IO_IN, s_callback, mon);
res = xmmsc_configval_register (conn, "mlibupdater.watch_dirs", "");
xmmsc_result_notifier_set (res, handle_configval, mon);
xmmsc_result_unref (res);
res = xmmsc_broadcast_configval_changed (conn);
xmmsc_result_notifier_set (res, handle_config_changed, mon);
xmmsc_result_unref (res);
g_main_loop_run (ml);
return EXIT_SUCCESS;
}
void
peas_debug_init (void)
{
if (g_getenv ("PEAS_DEBUG") == NULL)
{
g_log_set_handler (G_LOG_DOMAIN,
G_LOG_LEVEL_DEBUG,
debug_log_handler,
NULL);
}
}
static void
gst_gl_window_init (GstGLWindow * window)
{
window->priv = GST_GL_WINDOW_GET_PRIVATE (window);
if (g_getenv ("GST_GL_WINDOW_DEBUG") != NULL)
_gst_gl_window_debug = TRUE;
g_log_set_handler ("GstGLWindow", G_LOG_LEVEL_DEBUG,
gst_gl_window_log_handler, NULL);
}
gint
main (gint argc,
gchar *argv[])
{
g_autoptr(GDBusConnection) connection = NULL;
g_autoptr(IpcGitService) service = NULL;
g_autoptr(GOutputStream) stdout_stream = NULL;
g_autoptr(GInputStream) stdin_stream = NULL;
g_autoptr(GIOStream) stream = NULL;
g_autoptr(GMainLoop) main_loop = NULL;
g_autoptr(GError) error = NULL;
g_set_prgname ("gnome-builder-git");
g_set_application_name ("gnome-builder-git");
prctl (PR_SET_PDEATHSIG, SIGTERM);
signal (SIGPIPE, SIG_IGN);
ggit_init ();
g_log_set_handler (NULL, G_LOG_LEVEL_MASK, log_func, NULL);
if (!g_unix_set_fd_nonblocking (STDIN_FILENO, TRUE, &error) ||
!g_unix_set_fd_nonblocking (STDOUT_FILENO, TRUE, &error))
goto error;
main_loop = g_main_loop_new (NULL, FALSE);
stdin_stream = g_unix_input_stream_new (STDIN_FILENO, FALSE);
stdout_stream = g_unix_output_stream_new (STDOUT_FILENO, FALSE);
stream = g_simple_io_stream_new (stdin_stream, stdout_stream);
if (!(connection = create_connection (stream, main_loop, &error)))
goto error;
service = ipc_git_service_impl_new ();
if (!g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (service),
connection,
"/org/gnome/Builder/Git",
&error))
goto error;
g_dbus_connection_start_message_processing (connection);
g_main_loop_run (main_loop);
return EXIT_SUCCESS;
error:
if (error != NULL)
g_printerr ("%s\n", error->message);
return EXIT_FAILURE;
}
void
logging_init(void)
{
g_log_set_handler(VCD_LOG_DOMAIN,
VCD_LOG_LEVEL_VERBOSE
| VCD_LOG_LEVEL_ERROR
| VCD_LOG_LEVEL_WARNING
| VCD_LOG_LEVEL_INFO,
vcd_log_handler,
NULL);
}
void
rra_log_initialize(void)
{
log_handler = g_log_set_handler(G_LOG_DOMAIN,
RRA_LOG_LEVEL_TRACE
| G_LOG_LEVEL_DEBUG
| G_LOG_LEVEL_INFO
| G_LOG_LEVEL_MESSAGE
| G_LOG_LEVEL_WARNING,
rra_glog_handler,
NULL);
}
int main(int argc, char** argv)
{
gtk_test_init(&argc, &argv, NULL);
g_test_add_func("/blacklist/active", test_set_blacklist_active);
g_test_add_func("/blacklist/empty", test_empty_blacklist);
/* mute standard debug output from plugin */
g_log_set_handler("dynlist", G_LOG_LEVEL_DEBUG, redirect_log, NULL);
return g_test_run();
}
void
galeon_debug_init (void)
{
#ifndef DISABLE_LOGGING
galeon_log_modules = g_getenv ("GALEON_LOG_MODULES");
g_log_set_handler (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, log_module, NULL);
#endif
#ifndef DISABLE_PROFILING
galeon_profile_modules = g_getenv ("GALEON_PROFILE_MODULES");
#endif
}
int
main (int argc,
char *argv[])
{
GThread *threads[N_THREADS];
int i;
void *p;
#ifdef __SYMBIAN32__
g_log_set_handler (NULL, G_LOG_FLAG_FATAL| G_LOG_FLAG_RECURSION | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG, &mrtLogHandler, NULL);
g_set_print_handler(mrtPrintHandler);
#endif /*__SYMBIAN32__*/
/* test simple initializer */
initializer1();
initializer1();
/* test pointer initializer */
/*void */p = initializer2();
g_assert (p == &dummy_value);
p = initializer2();
g_assert (p == &dummy_value);
/* setup threads */
g_thread_init (NULL);
tmutex = g_mutex_new ();
tcond = g_cond_new ();
/* start multiple threads for initializer3() */
g_mutex_lock (tmutex);
for (i = 0; i < N_THREADS; i++)
threads[i] = g_thread_create (tmain_call_initializer3, 0, FALSE, NULL);
g_mutex_unlock (tmutex);
/* concurrently call initializer3() */
g_cond_broadcast (tcond);
/* loop until all threads passed the call to initializer3() */
while (g_atomic_int_get (&thread_call_count) < i)
{
if (rand() % 2)
g_thread_yield(); /* concurrent shuffling for single core */
else
g_usleep (1000); /* concurrent shuffling for multi core */
g_cond_broadcast (tcond);
}
/* call multiple (unoptimized) initializers from multiple threads */
g_mutex_lock (tmutex);
g_atomic_int_set (&thread_call_count, 0);
for (i = 0; i < N_THREADS; i++)
g_thread_create (stress_concurrent_initializers, 0, FALSE, NULL);
g_mutex_unlock (tmutex);
while (g_atomic_int_get (&thread_call_count) < 256 * 4 * N_THREADS)
g_usleep (50 * 1000); /* wait for all 5 threads to complete */
#if __SYMBIAN32__
testResultXml("onceinit");
#endif /* EMULATOR */
return 0;
}
void Messages::captureLogMessages()
{
/*
This might likely need more code, to capture Gtkmm
and Glibmm warnings, or maybe just simply grab stdout/stderr
*/
GLogLevelFlags flags = (GLogLevelFlags) (G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL |
G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE |
G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG);
if ( !handlerDefault ) {
handlerDefault = g_log_set_handler(NULL, flags,
dialogLoggingCallback, (gpointer)this);
}
if ( !handlerGlibmm ) {
handlerGlibmm = g_log_set_handler("glibmm", flags,
dialogLoggingCallback, (gpointer)this);
}
if ( !handlerAtkmm ) {
handlerAtkmm = g_log_set_handler("atkmm", flags,
dialogLoggingCallback, (gpointer)this);
}
if ( !handlerPangomm ) {
handlerPangomm = g_log_set_handler("pangomm", flags,
dialogLoggingCallback, (gpointer)this);
}
if ( !handlerGdkmm ) {
handlerGdkmm = g_log_set_handler("gdkmm", flags,
dialogLoggingCallback, (gpointer)this);
}
if ( !handlerGtkmm ) {
handlerGtkmm = g_log_set_handler("gtkmm", flags,
dialogLoggingCallback, (gpointer)this);
}
message(_("Log capture started."));
}
void
cockpit_polkit_agent_unregister (gpointer handle)
{
guint handler = 0;
/* Everything is shutting down at this point, prevent polkit from complaining */
handler = g_log_set_handler (NULL, G_LOG_LEVEL_WARNING, cockpit_null_log_handler, NULL);
if (handle)
polkit_agent_listener_unregister (handle);
g_log_remove_handler (NULL, handler);
}
void
nm_logging_setup (gboolean become_daemon)
{
if (become_daemon)
openlog (G_LOG_DOMAIN, 0, LOG_DAEMON);
else
openlog (G_LOG_DOMAIN, LOG_CONS | LOG_PERROR, LOG_USER);
g_log_set_handler (G_LOG_DOMAIN,
G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION,
nm_log_handler,
NULL);
}
void
ibus_set_log_handler (gboolean verbose)
{
if (ibus_log_handler_id != 0) {
g_log_remove_handler (G_LOG_DOMAIN, ibus_log_handler_id);
}
ibus_log_handler_is_verbose = verbose;
ibus_log_handler_id = g_log_set_handler (G_LOG_DOMAIN,
G_LOG_LEVEL_MASK,
ibus_log_handler,
NULL);
}
void set_console_log_handler(void)
{
GLogLevelFlags log_flags;
/* Arrange that if we have no console window, and a GLib message logging
routine is called to log a message, we pop up a console window.
We do that by inserting our own handler for all messages logged
to the default domain; that handler pops up a console if necessary,
and then calls the default handler. */
/* We might want to have component specific log levels later ... */
log_flags = (GLogLevelFlags)
(G_LOG_LEVEL_ERROR|
G_LOG_LEVEL_CRITICAL|
G_LOG_LEVEL_WARNING|
G_LOG_LEVEL_MESSAGE|
G_LOG_LEVEL_INFO|
G_LOG_LEVEL_DEBUG|
G_LOG_FLAG_FATAL|
G_LOG_FLAG_RECURSION);
g_log_set_handler(NULL,
log_flags,
console_log_handler, NULL /* user_data */);
g_log_set_handler(LOG_DOMAIN_MAIN,
log_flags,
console_log_handler, NULL /* user_data */);
#ifdef HAVE_LIBPCAP
g_log_set_handler(LOG_DOMAIN_CAPTURE,
log_flags,
console_log_handler, NULL /* user_data */);
g_log_set_handler(LOG_DOMAIN_CAPTURE_CHILD,
log_flags,
console_log_handler, NULL /* user_data */);
#endif
}
/* initialize GNet testing */
static void
gnet_check_init (int *argc, char **argv[])
{
gnet_init ();
/* GST_DEBUG_CATEGORY_INIT (check_debug, "check", 0, "check regression tests"); */
if (g_getenv ("GNET_TEST_DEBUG"))
_gnet_check_debug = TRUE;
if (g_getenv ("SOCKS_SERVER")) {
GInetAddr *ia;
ia = gnet_socks_get_server ();
if (ia) {
gchar *name;
name = gnet_inetaddr_get_canonical_name (ia);
g_print ("\nUsing SOCKS %u proxy: %s\n", gnet_socks_get_version(), name);
g_free (name);
gnet_inetaddr_unref (ia);
gnet_socks_set_enabled (TRUE);
}
}
g_log_set_handler (NULL, G_LOG_LEVEL_MESSAGE, gnet_check_log_message_func,
NULL);
g_log_set_handler (NULL, G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING,
gnet_check_log_critical_func, NULL);
g_log_set_handler ("GNet", G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING,
gnet_check_log_critical_func, NULL);
g_log_set_handler ("GLib", G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING,
gnet_check_log_critical_func, NULL);
g_log_set_handler ("GLib-GObject", G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING,
gnet_check_log_critical_func, NULL);
check_cond = g_cond_new ();
check_mutex = g_mutex_new ();
}
