void tracker_log_shutdown (void) { if (!initialized) { return; } g_message ("Stopping %s %s", g_get_application_name (), PACKAGE_VERSION); /* Reset default log handler */ g_log_set_default_handler (g_log_default_handler, NULL); if (log_handler_id) { g_log_remove_handler (G_LOG_DOMAIN, log_handler_id); log_handler_id = 0; } if (libmediaart_log_handler_id) { g_log_remove_handler ("libmediaart", libmediaart_log_handler_id); libmediaart_log_handler_id = 0; } if (use_log_files && fd != NULL) { fclose (fd); } g_mutex_clear (&mutex); initialized = FALSE; }
void wm_debug_shutdown(void) { g_log_remove_handler("lboxwm_render", rr_handler_id); g_log_remove_handler("lboxwm_toolkit", t_handler_id); g_log_remove_handler("lboxwm", lboxwm_handler_id); if(log_file) { fclose(log_file); log_file = NULL; } }
void ob_debug_shutdown(void) { g_log_remove_handler("ObRender", rr_handler_id); g_log_remove_handler("Obt", obt_handler_id); g_log_remove_handler("Openbox", ob_handler_id); g_log_remove_handler("Openbox", ob_handler_prompt_id); if (log_file) { fclose(log_file); log_file = NULL; } }
gboolean Logger::remove_log_handler(const gchar* log_domain) { auto it = handler_ids_.find(log_domain); if (handler_ids_.end() == it) return FALSE; g_log_remove_handler(log_domain, handler_ids_[log_domain]); return TRUE; }
static void VMToolsResetLogging(gboolean hard) { gLogEnabled = FALSE; g_log_set_default_handler(g_log_default_handler, NULL); CLEAR_LOG_HANDLER(gErrorData); gErrorData = NULL; if (gDomains != NULL) { guint i; for (i = 0; i < gDomains->len; i++) { LogHandler *data = g_ptr_array_index(gDomains, i); g_log_remove_handler(data->domain, data->handlerId); data->handlerId = 0; if (hard) { CLEAR_LOG_HANDLER(data); } } if (hard) { g_ptr_array_free(gDomains, TRUE); gDomains = NULL; } } if (hard) { CLEAR_LOG_HANDLER(gDefaultData); gDefaultData = NULL; } if (gLogDomain != NULL) { g_free(gLogDomain); gLogDomain = NULL; } }
PyObject * py_set_debug_log_handler(G_GNUC_UNUSED PyObject *self, PyObject *args) { PyObject *cb, *cb_data = NULL; if (!PyArg_ParseTuple(args, "O|O:py_set_debug_log_handler", &cb, &cb_data)) return NULL; if (cb == Py_None) cb = NULL; if (cb && !PyCallable_Check(cb)) { PyErr_SetString(PyExc_TypeError, "parameter must be callable"); return NULL; } Py_XDECREF(debug_cb); Py_XDECREF(debug_cb_data); debug_cb = cb; debug_cb_data = cb_data; Py_XINCREF(debug_cb); Py_XINCREF(debug_cb_data); if (debug_cb) { debug_handler_id = g_log_set_handler("librepo", G_LOG_LEVEL_DEBUG, py_debug_cb, NULL); global_logger = 1; } else if (debug_handler_id != -1) { g_log_remove_handler("librepo", debug_handler_id); } Py_RETURN_NONE; }
PHP_METHOD(midgard_connection, __destruct) { if (MGDG(midgard_memory_debug)) { php_printf("[%p] midgard_connection::__destruct()\n", getThis()); } MidgardConnection *mgd = __midgard_connection_get_ptr(getThis()); int loghandler = midgard_connection_get_loghandler(mgd); if (loghandler) { if (MGDG(midgard_memory_debug)) { php_printf("[%p] ---> g_log_remove_handler(..., %d)\n", getThis(), loghandler); } g_log_remove_handler(G_LOG_DOMAIN, loghandler); if (global_loghandler != loghandler && MGDG(midgard_memory_debug)) { php_printf("[%p] ---> (?) global_loghandler != connection's handler\n", getThis()); } // still just null it, as it is not valid anyway global_loghandler = 0; midgard_connection_set_loghandler (mgd, 0); } MGDG(connection_established) = FALSE; if (MGDG(midgard_memory_debug)) { php_printf("[%p] <= midgard_connection::__destruct()\n", getThis()); } }
static PHP_METHOD(midgard_connection, open) { RETVAL_FALSE; char *cnf_name; int cnf_name_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &cnf_name, &cnf_name_length) == FAILURE) return; MidgardConnection *mgd = __midgard_connection_get_ptr(getThis()); gboolean rv = midgard_connection_open(mgd, (const gchar *)cnf_name, NULL); if (rv) { guint loghandler = midgard_connection_get_loghandler(mgd); if (loghandler) g_log_remove_handler(G_LOG_DOMAIN, loghandler); global_loghandler = g_log_set_handler(G_LOG_DOMAIN, G_LOG_LEVEL_MASK, php_midgard_log_errors, (gpointer)mgd); midgard_connection_set_loghandler(mgd, global_loghandler); if (MGDG(midgard_memory_debug)) { php_printf("---> global_loghandler = %d\n", global_loghandler); } } RETURN_BOOL(rv); }
static void test_num_print_info (gnc_numeric n, GNCPrintAmountInfo print_info, int line) { gnc_numeric n_parsed = gnc_numeric_zero(); const char *s; gboolean ok, print_ok; auto msg = "[PrintAmountInternal()] Bad numeric from rounding: GNC_ERROR_OVERFLOW."; auto log_domain = "gnc.gui"; auto loglevel = static_cast<GLogLevelFlags>(G_LOG_LEVEL_WARNING); auto check = test_error_struct_new (log_domain, loglevel, msg); /* Throws overflows during rounding step in xaccPrintAmount when the "fraction" is high. See bug 665707. */ auto hdlr = g_log_set_handler (log_domain, loglevel, (GLogFunc)test_checked_handler, &check); s = xaccPrintAmount (n, print_info); print_ok = (s && s[0] != '\0'); if (!print_ok) return; ok = xaccParseAmount (s, print_info.monetary, &n_parsed, NULL); g_log_remove_handler (log_domain, hdlr); do_test_args (ok, "parsing failure", __FILE__, __LINE__, "num: %s, string %s (line %d)", gnc_numeric_to_string (n), s, line); ok = gnc_numeric_equal (n, n_parsed); do_test_args (ok, "not equal", __FILE__, __LINE__, "start: %s, string %s, finish: %s (line %d)", gnc_numeric_to_string (n), s, gnc_numeric_to_string (n_parsed), line); test_error_struct_free (check); }
/* Given a synthetic session, use the same logic as * QofSession::save_as to save it to a specified sql url, then load it * back and compare. */ void test_dbi_store_and_reload( const gchar* driver, QofSession* session_1, const gchar* url ) { QofSession* session_2; QofSession* session_3; gchar *msg = "[gnc_dbi_unlock()] There was no lock entry in the Lock table"; gchar *log_domain = "gnc.backend.dbi"; guint loglevel = G_LOG_LEVEL_WARNING, hdlr; TestErrorStruct check = { loglevel, log_domain, msg }; g_test_message ( "Testing %s\n", driver ); // Save the session data session_2 = qof_session_new(); hdlr = g_log_set_handler (log_domain, loglevel, (GLogFunc)test_checked_handler, &check); qof_session_begin( session_2, url, FALSE, TRUE, TRUE ); if (session_2 && qof_session_get_error(session_2) != ERR_BACKEND_NO_ERR) { g_warning("Session Error: %d, %s", qof_session_get_error(session_2), qof_session_get_error_message(session_2)); do_test( FALSE, "First DB Session Creation Failed"); return; } qof_session_swap_data( session_1, session_2 ); qof_session_save( session_2, NULL ); if (session_2 && qof_session_get_error(session_2) != ERR_BACKEND_NO_ERR) { g_warning("Session Error: %s", qof_session_get_error_message(session_2)); do_test( FALSE, "First DB Session Save Failed"); return; } // Reload the session data session_3 = qof_session_new(); qof_session_begin( session_3, url, TRUE, FALSE, FALSE ); if (session_3 && qof_session_get_error(session_3) != ERR_BACKEND_NO_ERR) { g_warning("Session Error: %s", qof_session_get_error_message(session_3)); do_test( FALSE, "Second DB Session Creation Failed"); return; } qof_session_load( session_3, NULL ); if (session_3 && qof_session_get_error(session_3) != ERR_BACKEND_NO_ERR) { g_warning("Session Error: %s", qof_session_get_error_message(session_3)); do_test( FALSE, "Second DBI Session Load Failed"); return; } // Compare with the original data compare_books( qof_session_get_book( session_2 ), qof_session_get_book( session_3 ) ); qof_session_end( session_1 ); qof_session_destroy( session_1 ); qof_session_end( session_2 ); qof_session_destroy( session_2 ); qof_session_end( session_3 ); qof_session_destroy( session_3 ); g_log_remove_handler (log_domain, hdlr); }
void ibus_unset_log_handler (void) { if (ibus_log_handler_id != 0) { g_log_remove_handler (G_LOG_DOMAIN, ibus_log_handler_id); ibus_log_handler_id = 0; } }
void msg_deinit(void) { evt_ctx_free(evt_context); evt_context = NULL; log_stderr = TRUE; if (g_log_handler_id) { g_log_remove_handler(G_LOG_DOMAIN, g_log_handler_id); g_log_handler_id = 0; } if (glib_handler_id) { g_log_remove_handler("GLib", glib_handler_id); glib_handler_id = 0; } }
//_________________________________________________________ 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 Messages::releaseLogMessages() { if ( handlerDefault ) { g_log_remove_handler(NULL, handlerDefault); handlerDefault = 0; } if ( handlerGlibmm ) { g_log_remove_handler("glibmm", handlerGlibmm); handlerGlibmm = 0; } if ( handlerAtkmm ) { g_log_remove_handler("atkmm", handlerAtkmm); handlerAtkmm = 0; } if ( handlerPangomm ) { g_log_remove_handler("pangomm", handlerPangomm); handlerPangomm = 0; } if ( handlerGdkmm ) { g_log_remove_handler("gdkmm", handlerGdkmm); handlerGdkmm = 0; } if ( handlerGtkmm ) { g_log_remove_handler("gtkmm", handlerGtkmm); handlerGtkmm = 0; } message(_("Log capture stopped.")); }
void DebugDialogImpl::releaseLogMessages() { if ( handlerDefault ) { g_log_remove_handler(NULL, handlerDefault); handlerDefault = 0; } if ( handlerGlibmm ) { g_log_remove_handler("glibmm", handlerGlibmm); handlerGlibmm = 0; } if ( handlerAtkmm ) { g_log_remove_handler("atkmm", handlerAtkmm); handlerAtkmm = 0; } if ( handlerPangomm ) { g_log_remove_handler("pangomm", handlerPangomm); handlerPangomm = 0; } if ( handlerGdkmm ) { g_log_remove_handler("gdkmm", handlerGdkmm); handlerGdkmm = 0; } if ( handlerGtkmm ) { g_log_remove_handler("gtkmm", handlerGtkmm); handlerGtkmm = 0; } message("log capture discontinued"); }
/* Object constructor */ PHP_METHOD(midgard_connection, __construct) { MidgardConnection *mgd = NULL; if (MGDG(midgard_memory_debug)) { php_printf("[%p] midgard_connection::__construct()\n", getThis()); } if (zend_parse_parameters_none() == FAILURE) return; if (MGDG(midgard_http)) { /* trying to reuse saved connection */ mgd = php_midgard_handle_lookup(&MGDG(midgard_global_holder), MGDG(all_configs) TSRMLS_CC); if (mgd == NULL) { /* @todo throw exception, instead */ php_error(E_ERROR, "Midgard handle-lookup failed (could not connect to database)"); return; } } else { mgd = midgard_connection_new(); if (mgd == NULL) { /* @todo throw exception, instead */ php_error(E_ERROR, "Failed to create underlying GObject instance"); return; } } if (global_loghandler) { if (MGDG(midgard_memory_debug)) { php_printf("---> g_log_remove_handler(..., %d)\n", global_loghandler); } g_log_remove_handler(G_LOG_DOMAIN, global_loghandler); } // midgard_connection_set_loglevel(mgd, "warning", NULL); global_loghandler = midgard_connection_get_loghandler(mgd); if (MGDG(midgard_memory_debug)) { php_printf("---> global_loghandler = %d\n", global_loghandler); } /* storing midgard_connection in object's store-structure */ MGD_PHP_SET_GOBJECT(getThis(), mgd); // explicitly enable replication (to stay compatible with mjölnir) midgard_connection_enable_replication(mgd, TRUE); if (MGDG(midgard_memory_debug)) { php_printf("[%p] <= midgard_connection::__construct()\n", getThis()); } }
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 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); }
gint display_properties_dbox(const char *filename) { GtkBuilder *builder; GtkWidget *dbox; GtkWidget *text; GError* error = NULL; gint result; guint hid; builder = gtk_builder_new(); if (!gtk_builder_add_from_file (builder, tilp_paths_build_builder("manpage.ui"), &error)) { g_warning (_("Couldn't load builder file: %s\n"), error->message); g_error_free (error); return NULL; // THIS RETURNS ! } gtk_builder_connect_signals(builder, NULL); dbox = gtk_builder_get_object(builder, "manpage_dbox"); text = gtk_builder_get_object(builder, "textview1"); txtbuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)); hid = g_log_set_handler("tifiles", G_LOG_LEVEL_INFO, new_log_handler, NULL); tifiles_file_display(filename); g_log_remove_handler("tifiles", hid); { PangoFontDescription *font_desc; GtkWidget *view = text; font_desc = pango_font_description_from_string ("Courier"); gtk_widget_modify_font (view, font_desc); pango_font_description_free (font_desc); } gtk_window_set_title(GTK_WINDOW(dbox), g_basename(filename)); gtk_widget_show(dbox); result = gtk_dialog_run(GTK_DIALOG(dbox)); switch (result) { case GTK_RESPONSE_OK: break; default: break; } gtk_widget_destroy(dbox); return 0; }
bool Logger::init() { if (installed_) { g_warning("Only one logger instance is possible, cannot create"); return false; } else { installed_ = true; i_am_the_one_ = true; } guint quiet_handler_id = g_log_set_handler("GLib-GObject", G_LOG_LEVEL_MASK, quiet_log_handler, nullptr); // handler must be installed after custom property creation handler_ids_["switcher"] = g_log_set_handler("switcher", G_LOG_LEVEL_MASK, log_handler, this); g_log_remove_handler("GLib-GObject", quiet_handler_id); install_method( "Install Log Handler", "install_log_handler", "make the logger managing the log domain", "success or fail", Method::make_arg_description("LogDomain", "log domain", "the glib log domain (e.g. shmdata, Glib or GStreamer)", nullptr), (Method::method_ptr)&install_log_handler_wrapped, G_TYPE_BOOLEAN, Method::make_arg_type_description(G_TYPE_STRING, nullptr), this); install_method( "Remove Log Handler", "remove_log_handler", "make the logger stop managing the log domain", "success or fail", Method::make_arg_description("Log Domain", "log domain", "the glib log domain (e.g. shmdata, Glib or GStreamer)", nullptr), (Method::method_ptr)&remove_log_handler_wrapped, G_TYPE_BOOLEAN, Method::make_arg_type_description(G_TYPE_STRING, nullptr), this); return true; }
void milter_manager_quit (void) { if (!initialized) return; if (the_manager) { g_object_unref(the_manager); the_manager = NULL; } _milter_manager_configuration_quit(); g_log_remove_handler("milter-manager", milter_manager_log_handler_id); milter_server_quit(); milter_client_quit(); milter_quit(); }
static gboolean test_case_destroy (TestCase *test, GError **error) { /* Failures when cleaning up the test case aren't recoverable, since we'll * pollute the subsequent test cases, so we just return the error, and * skip the rest of the cleanup. */ GHashTableIter iter; gpointer key, value; g_hash_table_iter_init (&iter, test->clients); while (g_hash_table_iter_next (&iter, &key, &value)) { if (!test_client_do (value, error, "destroy_all", NULL)) return FALSE; } if (!test_case_wait (test, error)) return FALSE; if (!test_case_assert_stacking (test, NULL, 0, error)) return FALSE; if (!test_case_check_warnings (test, error)) return FALSE; g_hash_table_iter_init (&iter, test->clients); while (g_hash_table_iter_next (&iter, &key, &value)) test_client_destroy (value); async_waiter_destroy (test->waiter); meta_display_set_alarm_filter (meta_get_display (), NULL, NULL); g_hash_table_destroy (test->clients); g_free (test); g_log_remove_handler ("mutter", test->log_handler_id); return TRUE; }
static void _midgard_connection_finalize(GObject *object) { g_assert(object != NULL); MidgardConnection *self = (MidgardConnection *) object; if (self->err != NULL) g_clear_error(&self->err); if (self->errstr != NULL) { g_free(self->errstr); self->errstr = NULL; } if (self->priv->authstack) { g_slist_free(self->priv->authstack); self->priv->authstack = NULL; } g_free ((gchar *)self->priv->cnc_str); self->priv->cnc_str = NULL; g_timer_stop(self->priv->timer); //gdouble bench = g_timer_elapsed(self->priv->timer, NULL); if (self->priv->loghandler) { /* uptime message disable for a while */ /* g_message("MidgardConnection uptime %.04f seconds", bench); */ g_log_remove_handler(G_LOG_DOMAIN, self->priv->loghandler); } g_timer_destroy(self->priv->timer); if (!self->priv->inherited) { if (self->priv->config && G_IS_OBJECT (self->priv->config)) { g_object_unref(self->priv->config); self->priv->config = NULL; } } g_free(self->priv); self->priv = NULL; }
void test_dbi_business_store_and_reload( const gchar* driver, QofSession* session_1, const gchar* url ) { QofSession* session_2; QofSession* session_3; gchar *msg = "[gnc_dbi_unlock()] There was no lock entry in the Lock table"; gchar *log_domain = "gnc.backend.dbi"; guint loglevel = G_LOG_LEVEL_WARNING, hdlr; TestErrorStruct check = { loglevel, log_domain, msg }; g_test_message ( "Testing %s\n", driver ); // Save the session data session_2 = qof_session_new(); qof_session_begin( session_2, url, FALSE, TRUE, TRUE ); qof_session_swap_data( session_1, session_2 ); qof_session_save( session_2, NULL ); // Reload the session data session_3 = qof_session_new(); qof_session_begin( session_3, url, TRUE, FALSE, FALSE ); qof_session_load( session_3, NULL ); // Compare with the original data compare_books( qof_session_get_book( session_2 ), qof_session_get_book( session_3 ) ); qof_session_end( session_1 ); qof_session_destroy( session_1 ); qof_session_end( session_2 ); qof_session_destroy( session_2 ); hdlr = g_log_set_handler (log_domain, loglevel, (GLogFunc)test_checked_handler, &check); qof_session_end( session_3 ); g_log_remove_handler (log_domain, hdlr); qof_session_destroy( session_3 ); }
/** * midgard_connection_set_loglevel: * @self: #MidgardConnection instance * @level: Loglevel string * @log_func: log handler function * * Sets log level of the given MidgardConnection. * Overwrites internal #MidgardConnection's log level defined in configuration file. * By default MidgardConnection holds loglevel which is associated with ( and duplicated * from ) #MidgardConfig. * #MidgardConfig object's log level isn't changed by this function * * This method is a shortcut which sets correctly loghandler,loglevel and GLib's log function. Default log function will be used if %NULL * is defined. Core's default function is #midgard_error_default_log. * * Available levels: error, warn, warning, info, message, debug. * warn is default loglevel, SQL queries are logged with debug level. * With info level, function names ( and classes' names ) are ( at least should be) logged in language bindings * * Returns: %TRUE if debug level is set, %FALSE otherwise */ gboolean midgard_connection_set_loglevel( MidgardConnection *self, const gchar *level, GLogFunc log_func) { g_assert(self != NULL); GLogFunc _func = log_func; if(_func == NULL) _func = midgard_error_default_log; gint loglevel = midgard_error_parse_loglevel(level); if(loglevel > -1) self->priv->loglevel = loglevel; else return FALSE; MGD_CNC_DEBUG (self) = FALSE; if (loglevel > G_LOG_LEVEL_DEBUG) MGD_CNC_DEBUG (self) = TRUE; guint loghandler = midgard_connection_get_loghandler(self); if(loghandler) g_log_remove_handler(G_LOG_DOMAIN, loghandler); loghandler = g_log_set_handler(G_LOG_DOMAIN, G_LOG_LEVEL_MASK, _func, (gpointer)self); if(loghandler == 0) return FALSE; midgard_connection_set_loghandler(self, loghandler); return TRUE; }
/* Given an already-created url (yeah, bad testing practice: Should * start fresh from a synthetic session) load and safe-save it, then * load it again into a new session and compare the two. Since * safe-save is a more-or-less atomic function call, there's no way to * be sure that it's actually doing what it's supposed to without * running this test in a debugger and stopping in the middle of the * safe-save and inspecting the database. */ void test_dbi_safe_save( const gchar* driver, const gchar* url ) { QofSession *session_1 = NULL, *session_2 = NULL; gchar *msg = "[gnc_dbi_unlock()] There was no lock entry in the Lock table"; gchar *log_domain = "gnc.backend.dbi"; guint loglevel = G_LOG_LEVEL_WARNING, hdlr; TestErrorStruct check = { loglevel, log_domain, msg }; g_test_message ( "Testing safe save %s\n", driver ); // Load the session data session_1 = qof_session_new(); qof_session_begin( session_1, url, TRUE, FALSE, FALSE ); if (session_1 && qof_session_get_error(session_1) != ERR_BACKEND_NO_ERR) { g_warning("Session Error: %d, %s", qof_session_get_error(session_1), qof_session_get_error_message(session_1)); do_test( FALSE, "DB Session Creation Failed"); goto cleanup; } qof_session_load( session_1, NULL ); /* Do a safe save */ qof_session_safe_save( session_1, NULL ); if (session_1 && qof_session_get_error(session_1) != ERR_BACKEND_NO_ERR) { g_warning("Session Error: %s", qof_session_get_error_message(session_1)); do_test( FALSE, "DB Session Safe Save Failed"); goto cleanup; } /* Destroy the session and reload it */ session_2 = qof_session_new(); qof_session_begin( session_2, url, TRUE, FALSE, FALSE ); if (session_2 && qof_session_get_error(session_2) != ERR_BACKEND_NO_ERR) { g_warning("Session Error: %d, %s", qof_session_get_error(session_2), qof_session_get_error_message(session_2)); do_test( FALSE, "DB Session re-creation Failed"); goto cleanup; } qof_session_load( session_2, NULL ); compare_books( qof_session_get_book( session_1 ), qof_session_get_book( session_2 ) ); cleanup: hdlr = g_log_set_handler (log_domain, loglevel, (GLogFunc)test_checked_handler, &check); if (session_2 != NULL) { qof_session_end( session_2 ); qof_session_destroy( session_2 ); } if (session_1 != NULL) { qof_session_end( session_1 ); qof_session_destroy( session_1 ); } g_log_remove_handler (log_domain, hdlr); return; }
gpointer cockpit_polkit_agent_register (CockpitTransport *transport, GCancellable *cancellable) { PolkitAgentListener *listener = NULL; PolkitAuthority *authority = NULL; PolkitSubject *subject = NULL; GVariant *options; GLogLevelFlags fatal; GError *error = NULL; gpointer handle = NULL; guint handler = 0; gchar *string; authority = polkit_authority_get_sync (cancellable, &error); if (authority == NULL) { g_message ("couldn't get polkit authority: %s", error->message); goto out; } subject = polkit_unix_session_new_for_process_sync (getpid (), cancellable, &error); if (subject == NULL) { /* * This can happen if there's a race between the polkit request and closing of * Cockpit. So it's not unheard of. We can complain, but not too loudly. */ g_message ("couldn't create polkit session subject: %s", error->message); goto out; } listener = g_object_new (COCKPIT_TYPE_POLKIT_AGENT, "transport", transport, NULL); options = NULL; /* * HACK: Work around polkitagent warning: * * https://bugs.freedesktop.org/show_bug.cgi?id=78193 */ fatal = g_log_set_always_fatal (0); handler = g_log_set_handler (NULL, G_LOG_LEVEL_WARNING, cockpit_null_log_handler, NULL); handle = polkit_agent_listener_register_with_options (listener, POLKIT_AGENT_REGISTER_FLAGS_NONE, subject, NULL, options, cancellable, &error); g_log_set_always_fatal (fatal); g_log_remove_handler (NULL, handler); if (error != NULL) { if ((g_error_matches (error, POLKIT_ERROR, POLKIT_ERROR_FAILED) && error->message && strstr (error->message, "already exists")) || g_error_matches (error, G_DBUS_ERROR, G_DBUS_ERROR_SERVICE_UNKNOWN)) { g_debug ("couldn't register polkit agent: %s", error->message); } else { g_dbus_error_strip_remote_error (error); g_message ("couldn't register polkit authentication agent: %s", error->message); } goto out; } string = polkit_subject_to_string (subject); g_debug ("registered polkit authentication agent for subject: %s", string); g_free (string); out: if (subject) g_object_unref (subject); if (authority) g_object_unref (authority); if (listener) g_object_unref (listener); g_clear_error (&error); return handle; }
Logger::~Logger() { if (i_am_the_one_) { for (auto& it : handler_ids_) g_log_remove_handler(it.first.c_str(), it.second); installed_ = false; } }
void debug_logger_remove_domain(DebugLogger *logger, const gchar *domain_name) { GSList *entry; gint i, num_pages; g_return_if_fail(IS_DEBUG_LOGGER(logger)); if(!domain_name) return; for(entry = logger->priv->domains; entry != NULL; entry = g_slist_next(entry)) { DomainHandler *handler = entry->data; if(strcmp( domain_name, handler->name ) == 0) { g_log_remove_handler( (handler->default_domain) ? NULL : handler->name, handler->handler_id); if(logger->ui_enabled) { num_pages = gtk_notebook_get_n_pages(logger->priv->notebook); for(i = 0; i < num_pages; ++i) { GtkWidget *current_page = gtk_notebook_get_nth_page(logger->priv->notebook, i); GtkWidget *box = gtk_notebook_get_tab_label(logger->priv->notebook, current_page); GList *list = gtk_container_get_children(GTK_CONTAINER(box)); GtkLabel *label = GTK_LABEL(list->next->data); g_list_free(list); if( strcmp(domain_name, gtk_label_get_text(label)) == 0) { gtk_notebook_remove_page(logger->priv->notebook, i); break; } } } if(handler->name) g_free(handler->name); if(handler) g_free(handler); logger->priv->domains = g_slist_remove(logger->priv->domains, handler); } } if(logger->ui_enabled) { if(gtk_notebook_get_n_pages(logger->priv->notebook) == 0) { gtk_widget_set_sensitive(logger->priv->toolbar_save, FALSE); gtk_widget_set_sensitive(logger->priv->toolbar_copy, FALSE); gtk_widget_set_sensitive(logger->priv->toolbar_select, FALSE); gtk_widget_set_sensitive(logger->priv->toolbar_clear, FALSE); } } }
gint tracker_control_general_run (void) { GError *error = NULL; GSList *pids; GSList *l; gchar *str; gpointer verbosity_type_enum_class_pointer = NULL; TrackerVerbosity set_log_verbosity_value = TRACKER_VERBOSITY_ERRORS; /* Constraints */ if (kill_option != TERM_NONE && terminate_option != TERM_NONE) { g_printerr ("%s\n", _("You can not use the --kill and --terminate arguments together")); return EXIT_FAILURE; } if ((hard_reset || soft_reset) && terminate_option != TERM_NONE) { g_printerr ("%s\n", _("You can not use the --terminate with --hard-reset or --soft-reset, --kill is implied")); return EXIT_FAILURE; } if (hard_reset && soft_reset) { g_printerr ("%s\n", _("You can not use the --hard-reset and --soft-reset arguments together")); return EXIT_FAILURE; } if (get_log_verbosity && set_log_verbosity) { g_printerr ("%s\n", _("You can not use the --get-logging and --set-logging arguments together")); return EXIT_FAILURE; } if (set_log_verbosity) { if (g_ascii_strcasecmp (set_log_verbosity, "debug") == 0) { set_log_verbosity_value = TRACKER_VERBOSITY_DEBUG; } else if (g_ascii_strcasecmp (set_log_verbosity, "detailed") == 0) { set_log_verbosity_value = TRACKER_VERBOSITY_DETAILED; } else if (g_ascii_strcasecmp (set_log_verbosity, "minimal") == 0) { set_log_verbosity_value = TRACKER_VERBOSITY_MINIMAL; } else if (g_ascii_strcasecmp (set_log_verbosity, "errors") == 0) { set_log_verbosity_value = TRACKER_VERBOSITY_ERRORS; } else { g_printerr ("%s\n", _("Invalid log verbosity, try 'debug', 'detailed', 'minimal' or 'errors'")); return EXIT_FAILURE; } } if (hard_reset || soft_reset) { /* Imply --kill */ kill_option = TERM_ALL; } if (get_log_verbosity || set_log_verbosity) { GType etype; /* Since we don't reference this enum anywhere, we do * it here to make sure it exists when we call * g_type_class_peek(). This wouldn't be necessary if * it was a param in a GObject for example. * * This does mean that we are leaking by 1 reference * here and should clean it up, but it doesn't grow so * this is acceptable. */ etype = tracker_verbosity_get_type (); verbosity_type_enum_class_pointer = g_type_class_ref (etype); } /* Unless we are stopping processes or listing processes, * don't iterate them. */ if (kill_option != TERM_NONE || terminate_option != TERM_NONE || list_processes) { guint32 own_pid; guint32 own_uid; gchar *own_pid_str; pids = get_pids (); str = g_strdup_printf (g_dngettext (NULL, "Found %d PID…", "Found %d PIDs…", g_slist_length (pids)), g_slist_length (pids)); g_print ("%s\n", str); g_free (str); /* Establish own uid/pid */ own_pid = (guint32) getpid (); own_pid_str = g_strdup_printf ("%d", own_pid); own_uid = get_uid_for_pid (own_pid_str, NULL); g_free (own_pid_str); for (l = pids; l; l = l->next) { GError *error = NULL; gchar *filename; gchar *contents = NULL; gchar **strv; guint uid; uid = get_uid_for_pid (l->data, &filename); /* Stat the file and make sure current user == file owner */ if (uid != own_uid) { continue; } /* Get contents to determine basename */ if (!g_file_get_contents (filename, &contents, NULL, &error)) { str = g_strdup_printf (_("Could not open '%s'"), filename); g_printerr ("%s, %s\n", str, error ? error->message : _("no error given")); g_free (str); g_clear_error (&error); g_free (contents); g_free (filename); continue; } strv = g_strsplit (contents, "^@", 2); if (strv && strv[0]) { gchar *basename; basename = g_path_get_basename (strv[0]); if ((g_str_has_prefix (basename, "tracker") == TRUE || g_str_has_prefix (basename, "lt-tracker") == TRUE) && g_str_has_suffix (basename, "-control") == FALSE && g_str_has_suffix (basename, "-status-icon") == FALSE) { pid_t pid; pid = atoi (l->data); str = g_strdup_printf (_("Found process ID %d for '%s'"), pid, basename); g_print ("%s\n", str); g_free (str); if (terminate_option != TERM_NONE) { if ((terminate_option == TERM_STORE && !g_str_has_suffix (basename, "tracker-store")) || (terminate_option == TERM_MINERS && !strstr (basename, "tracker-miner"))) { continue; } if (kill (pid, SIGTERM) == -1) { const gchar *errstr = g_strerror (errno); str = g_strdup_printf (_("Could not terminate process %d"), pid); g_printerr (" %s, %s\n", str, errstr ? errstr : _("no error given")); g_free (str); } else { str = g_strdup_printf (_("Terminated process %d"), pid); g_print (" %s\n", str); g_free (str); } } else if (kill_option != TERM_NONE) { if ((kill_option == TERM_STORE && !g_str_has_suffix (basename, "tracker-store")) || (kill_option == TERM_MINERS && !strstr (basename, "tracker-miner"))) { continue; } if (kill (pid, SIGKILL) == -1) { const gchar *errstr = g_strerror (errno); str = g_strdup_printf (_("Could not kill process %d"), pid); g_printerr (" %s, %s\n", str, errstr ? errstr : _("no error given")); g_free (str); } else { str = g_strdup_printf (_("Killed process %d"), pid); g_print (" %s\n", str); g_free (str); } } } g_free (basename); } g_strfreev (strv); g_free (contents); g_free (filename); } g_slist_foreach (pids, (GFunc) g_free, NULL); g_slist_free (pids); /* If we just wanted to list processes, all done */ if (list_processes && terminate_option == TERM_NONE && kill_option == TERM_NONE) { return EXIT_SUCCESS; } } if (hard_reset || soft_reset) { guint log_handler_id; #ifndef DISABLE_JOURNAL gchar *rotate_to; TrackerDBConfig *db_config; gsize chunk_size; gint chunk_size_mb; #endif /* DISABLE_JOURNAL */ /* Set log handler for library messages */ log_handler_id = g_log_set_handler (NULL, G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL, log_handler, NULL); g_log_set_default_handler (log_handler, NULL); #ifndef DISABLE_JOURNAL db_config = tracker_db_config_new (); chunk_size_mb = tracker_db_config_get_journal_chunk_size (db_config); chunk_size = (gsize) ((gsize) chunk_size_mb * (gsize) 1024 * (gsize) 1024); rotate_to = tracker_db_config_get_journal_rotate_destination (db_config); /* This call is needed to set the journal's filename */ tracker_db_journal_set_rotating ((chunk_size_mb != -1), chunk_size, rotate_to); g_free (rotate_to); g_object_unref (db_config); #endif /* DISABLE_JOURNAL */ /* Clean up (select_cache_size and update_cache_size don't matter here) */ if (!tracker_db_manager_init (TRACKER_DB_MANAGER_REMOVE_ALL, NULL, FALSE, FALSE, 100, 100, NULL, NULL, NULL, &error)) { g_message ("Error initializing database: %s", error->message); g_free (error); return EXIT_FAILURE; } #ifndef DISABLE_JOURNAL tracker_db_journal_init (NULL, FALSE, NULL); #endif /* DISABLE_JOURNAL */ tracker_db_manager_remove_all (hard_reset); tracker_db_manager_shutdown (); #ifndef DISABLE_JOURNAL tracker_db_journal_shutdown (NULL); #endif /* DISABLE_JOURNAL */ /* Unset log handler */ g_log_remove_handler (NULL, log_handler_id); } if (remove_config) { GMainLoop *main_loop; GFile *file; TrackerCrawler *crawler; const gchar *suffix = ".cfg"; const gchar *home_conf_dir; gchar *path; GSList *all, *l; crawler = tracker_crawler_new (); main_loop = g_main_loop_new (NULL, FALSE); g_signal_connect (crawler, "check-file", G_CALLBACK (crawler_check_file_cb), &suffix); g_signal_connect (crawler, "finished", G_CALLBACK (crawler_finished_cb), main_loop); /* Go through service files */ /* Check the default XDG_DATA_HOME location */ home_conf_dir = g_getenv ("XDG_CONFIG_HOME"); if (home_conf_dir && tracker_path_has_write_access_or_was_created (home_conf_dir)) { path = g_build_path (G_DIR_SEPARATOR_S, home_conf_dir, "tracker", NULL); } else { home_conf_dir = g_getenv ("HOME"); if (!home_conf_dir || !tracker_path_has_write_access_or_was_created (home_conf_dir)) { home_conf_dir = g_get_home_dir (); } path = g_build_path (G_DIR_SEPARATOR_S, home_conf_dir, ".config", "tracker", NULL); } file = g_file_new_for_path (path); g_free (path); g_print ("%s\n", _("Removing configuration files…")); tracker_crawler_start (crawler, file, FALSE); g_object_unref (file); g_main_loop_run (main_loop); g_object_unref (crawler); g_print ("%s\n", _("Resetting existing configuration…")); all = tracker_gsettings_get_all (NULL); if (!all) { return EXIT_FAILURE; } for (l = all; l; l = l->next) { ComponentGSettings *c = l->data; gchar **keys, **p; if (!c) { continue; } g_print (" %s\n", c->name); keys = g_settings_list_keys (c->settings); for (p = keys; p && *p; p++) { g_print (" %s\n", *p); g_settings_reset (c->settings, *p); } if (keys) { g_strfreev (keys); } g_settings_apply (c->settings); } tracker_gsettings_free (all); } /* Deal with logging changes AFTER the config may have been * reset, this way users can actually use --remove-config with * the --set-logging switch. */ if (get_log_verbosity) { GSList *all; gint longest = 0; all = tracker_gsettings_get_all (&longest); if (!all) { return EXIT_FAILURE; } g_print ("%s:\n", _("Components")); tracker_gsettings_print_verbosity (all, longest, TRUE); g_print ("\n"); /* Miners */ g_print ("%s (%s):\n", _("Miners"), _("Only those with config listed")); tracker_gsettings_print_verbosity (all, longest, FALSE); g_print ("\n"); tracker_gsettings_free (all); } if (set_log_verbosity) { GSList *all; gchar *str; gint longest = 0; all = tracker_gsettings_get_all (&longest); if (!all) { return EXIT_FAILURE; } str = g_strdup_printf (_("Setting log verbosity for all components to '%s'…"), set_log_verbosity); g_print ("%s\n", str); g_print ("\n"); g_free (str); tracker_gsettings_set_all (all, set_log_verbosity_value); tracker_gsettings_free (all); /* We free to make sure we get new settings and that * they're saved properly. */ all = tracker_gsettings_get_all (&longest); if (!all) { return EXIT_FAILURE; } g_print ("%s:\n", _("Components")); tracker_gsettings_print_verbosity (all, longest, TRUE); g_print ("\n"); /* Miners */ g_print ("%s (%s):\n", _("Miners"), _("Only those with config listed")); tracker_gsettings_print_verbosity (all, longest, FALSE); g_print ("\n"); tracker_gsettings_free (all); } if (verbosity_type_enum_class_pointer) { g_type_class_unref (verbosity_type_enum_class_pointer); } if (start) { TrackerMinerManager *manager; GSList *miners, *l; if (hard_reset || soft_reset) { g_print ("%s\n", _("Waiting one second before starting miners…")); /* Give a second's grace to avoid race conditions */ g_usleep (G_USEC_PER_SEC); } g_print ("%s\n", _("Starting miners…")); /* Auto-start the miners here */ manager = tracker_miner_manager_new_full (TRUE, &error); if (!manager) { g_printerr (_("Could not start miners, manager could not be created, %s"), error ? error->message : "unknown error"); g_printerr ("\n"); g_clear_error (&error); return EXIT_FAILURE; } miners = tracker_miner_manager_get_available (manager); /* Get the status of all miners, this will start all * miners not already running. */ for (l = miners; l; l = l->next) { const gchar *display_name; gdouble progress = 0.0; display_name = tracker_miner_manager_get_display_name (manager, l->data); if (!tracker_miner_manager_get_status (manager, l->data, NULL, &progress, NULL)) { g_printerr (" ✗ %s (%s)\n", display_name, _("perhaps a disabled plugin?")); } else { g_print (" ✓ %s\n", display_name); } g_free (l->data); } g_slist_free (miners); g_object_unref (manager); } if (backup) { GDBusConnection *connection; GDBusProxy *proxy; GError *error = NULL; GVariant *v; gchar *uri; uri = get_uri_from_arg (backup); g_print ("%s\n", _("Backing up database")); g_print (" %s\n", uri); connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error); if (!connection) { g_critical ("Could not connect to the D-Bus session bus, %s", error ? error->message : "no error given."); g_clear_error (&error); g_free (uri); return EXIT_FAILURE; } proxy = g_dbus_proxy_new_sync (connection, G_DBUS_PROXY_FLAGS_NONE, NULL, "org.freedesktop.Tracker1", "/org/freedesktop/Tracker1/Backup", "org.freedesktop.Tracker1.Backup", NULL, &error); if (error) { g_critical ("Could not create proxy on the D-Bus session bus, %s", error ? error->message : "no error given."); g_clear_error (&error); g_free (uri); return EXIT_FAILURE; } /* Backup/Restore can take some time */ g_dbus_proxy_set_default_timeout (proxy, G_MAXINT); v = g_dbus_proxy_call_sync (proxy, "Save", g_variant_new ("(s)", uri), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (proxy) { g_object_unref (proxy); } if (error) { g_critical ("Could not backup database, %s", error ? error->message : "no error given."); g_clear_error (&error); g_free (uri); return EXIT_FAILURE; } if (v) { g_variant_unref (v); } g_free (uri); } if (restore) { GDBusConnection *connection; GDBusProxy *proxy; GError *error = NULL; GVariant *v; gchar *uri; uri = get_uri_from_arg (restore); g_print ("%s\n", _("Restoring database from backup")); g_print (" %s\n", uri); connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error); if (!connection) { g_critical ("Could not connect to the D-Bus session bus, %s", error ? error->message : "no error given."); g_clear_error (&error); g_free (uri); return EXIT_FAILURE; } proxy = g_dbus_proxy_new_sync (connection, G_DBUS_PROXY_FLAGS_NONE, NULL, "org.freedesktop.Tracker1", "/org/freedesktop/Tracker1/Backup", "org.freedesktop.Tracker1.Backup", NULL, &error); if (error) { g_critical ("Could not create proxy on the D-Bus session bus, %s", error ? error->message : "no error given."); g_clear_error (&error); g_free (uri); return EXIT_FAILURE; } /* Backup/Restore can take some time */ g_dbus_proxy_set_default_timeout (proxy, G_MAXINT); v = g_dbus_proxy_call_sync (proxy, "Restore", g_variant_new ("(s)", uri), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (proxy) { g_object_unref (proxy); } if (error) { g_critical ("Could not restore database, %s", error ? error->message : "no error given."); g_clear_error (&error); g_free (uri); return EXIT_FAILURE; } if (v) { g_variant_unref (v); } g_free (uri); } return EXIT_SUCCESS; }