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 (); }