static void
got_name_owner (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
GetNameOwnerData *data = user_data;
GError *error = NULL;
GVariant *reply;
const gchar *owner;
reply = g_dbus_connection_call_finish (G_DBUS_CONNECTION (object), result, &error);
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
{
g_error_free (error);
goto out;
}
if (reply == NULL)
{
if (!g_error_matches (error, G_DBUS_ERROR, G_DBUS_ERROR_NAME_HAS_NO_OWNER))
g_warning ("bus_watch_namespace: error calling org.freedesktop.DBus.GetNameOwner: %s", error->message);
g_error_free (error);
goto out;
}
g_variant_get (reply, "(&s)", &owner);
namespace_watcher_name_appeared (data->watcher, data->name, owner);
g_variant_unref (reply);
out:
g_free (data->name);
g_slice_free (GetNameOwnerData, data);
}
static void
printer_set_enabled_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GVariant *output;
PCData *data = (PCData *) user_data;
GError *error = NULL;
output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
res,
&error);
g_object_unref (source_object);
if (output)
{
g_variant_unref (output);
}
else
{
if (error->domain != G_IO_ERROR ||
error->code != G_IO_ERROR_CANCELLED)
g_warning ("%s", error->message);
g_error_free (error);
}
data->set_enabled_finished = TRUE;
printer_configure_async_finish (data);
}
/**
* @brief Perform sending remote signals to connected clients.
* @memberof GstSwitchController
*/
static void
gst_switch_controller_emit_signal (GstSwitchController * controller,
const gchar * signame, GVariant * parameters)
{
GError *error;
gboolean res;
GList *client;
gint num;
GST_SWITCH_CONTROLLER_LOCK_CLIENTS (controller);
g_assert (parameters);
g_variant_ref_sink (parameters);
for (client = controller->clients, num = 0; client;
client = g_list_next (client)) {
error = NULL;
res = g_dbus_connection_emit_signal (G_DBUS_CONNECTION (client->data),
/*destination_bus_name */ NULL,
SWITCH_CONTROLLER_OBJECT_PATH,
SWITCH_CONTROLLER_OBJECT_NAME, signame, parameters, &error);
if (!res) {
g_assert (error != NULL);
ERROR ("emit: (%d) %s", num, error->message);
} else {
++num;
}
}
/*
INFO ("emit: %s (%d/%d)", signame, num, g_list_length (controller->uis));
*/
g_variant_unref (parameters);
GST_SWITCH_CONTROLLER_UNLOCK_CLIENTS (controller);
}
static void
install_package_names_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GVariant *output;
IMEData *data = (IMEData *) user_data;
GError *error = NULL;
output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
res,
&error);
g_object_unref (source_object);
if (output)
{
g_variant_unref (output);
}
else
{
if (error->domain != G_IO_ERROR ||
error->code != G_IO_ERROR_CANCELLED)
g_warning ("%s", error->message);
g_error_free (error);
}
install_missing_executables_cb (data);
}
static void
openoffice_missing_unoconv_ready_cb (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
PdfLoadJob *job = user_data;
GError *error = NULL;
g_dbus_connection_call_finish (G_DBUS_CONNECTION (source), res, &error);
if (error != NULL) {
GError *local_error;
/* can't install unoconv with packagekit - nothing else we can do */
g_warning ("unoconv not found, and PackageKit failed to install it with error %s",
error->message);
local_error = g_error_new_literal (G_IO_ERROR, G_IO_ERROR_NOT_FOUND,
_("LibreOffice is required to view this document"));
pdf_load_job_complete_error (job, local_error);
g_error_free (error);
return;
}
/* now that we have unoconv installed, try again refreshing the cache */
pdf_load_job_openoffice_refresh_cache (job);
}
static void
writeback_file_finished (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
WritebackFileData *data = user_data;
GError *error = NULL;
g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
res, &error);
if (error && error->code == G_DBUS_ERROR_NO_REPLY && data->retries < 5) {
/* This happens in case of exit() of the tracker-writeback binary, which
* happens on unmount of the FS event, for example */
g_debug ("Retrying write-back after unmount (timeout in 5 seconds)");
tracker_miner_fs_writeback_notify (data->fs, data->file, NULL);
data->retry_timeout = g_timeout_add_seconds (5, retry_idle, data);
data->retries++;
} else {
tracker_miner_fs_writeback_notify (data->fs, data->file, error);
writeback_file_data_free (data);
}
}
static void
on_set_static_hostname (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
GisAccountPageEnterprise *page = user_data;
GisAccountPageEnterprisePrivate *priv = gis_account_page_enterprise_get_instance_private (page);
GError *error = NULL;
GVariant *retval;
retval = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source), result, &error);
if (error != NULL) {
join_show_prompt (page, error);
g_error_free (error);
return;
}
g_variant_unref (retval);
/* Prompted for some admin credentials, try to use them to log in */
um_realm_login (priv->realm,
gtk_entry_get_text (GTK_ENTRY (priv->join_name)),
gtk_entry_get_text (GTK_ENTRY (priv->join_password)),
priv->cancellable, on_join_login, page);
}
static void
close_and_unref_connection (void *data)
{
GDBusConnection *connection = G_DBUS_CONNECTION (data);
/* TODO: watch for the need to manually call g_dbus_connection_close_sync () */
g_object_unref (connection);
}
static void uriChangedCallback(WebKitWebPage* webPage, GParamSpec* pspec, WebKitWebExtension* extension)
{
gpointer data = g_object_get_data(G_OBJECT(extension), "dbus-connection");
if (data)
emitURIChanged(G_DBUS_CONNECTION(data), webkit_web_page_get_uri(webPage));
else
delayedSignalsQueue.append(adoptPtr(new DelayedSignal(URIChangedSignal, webkit_web_page_get_uri(webPage))));
}
static void documentLoadedCallback(WebKitWebPage*, WebKitWebExtension* extension)
{
gpointer data = g_object_get_data(G_OBJECT(extension), "dbus-connection");
if (data)
emitDocumentLoaded(G_DBUS_CONNECTION(data));
else
delayedSignalsQueue.append(adoptPtr(new DelayedSignal(DocumentLoadedSignal)));
}
/**
* fu_util_update_cb:
**/
static void
fu_util_update_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
FuUtilPrivate *priv = (FuUtilPrivate *) user_data;
GDBusConnection *con = G_DBUS_CONNECTION (source_object);
priv->message = g_dbus_connection_send_message_with_reply_finish (con, res,
&priv->error);
g_main_loop_quit (priv->loop);
}
static gboolean
evd_dbus_agent_foreach_remove_reg_obj (gpointer key,
gpointer value,
gpointer user_data)
{
RegObjData *reg_obj_data = (RegObjData *) value;
GDBusConnection *conn = G_DBUS_CONNECTION (user_data);
return reg_obj_data->dbus_conn == conn;
}
static gboolean
evd_dbus_agent_foreach_remove_owned_names (gpointer key,
gpointer value,
gpointer user_data)
{
NameOwnerData *name_owner_data = (NameOwnerData *) value;
GDBusConnection *conn = G_DBUS_CONNECTION (user_data);
return name_owner_data->dbus_conn == conn;
}
static void documentLoadedCallback(WebKitWebPage*, gpointer userData)
{
bool ok = g_dbus_connection_emit_signal(G_DBUS_CONNECTION(userData),
0,
"/org/webkit/gtk/WebExtensionTest",
"org.webkit.gtk.WebExtensionTest",
"DocumentLoaded",
0,
0);
g_assert(ok);
}
static void uriChangedCallback(WebKitWebPage* webPage, GParamSpec* pspec, gpointer userData)
{
bool ok = g_dbus_connection_emit_signal(
G_DBUS_CONNECTION(userData),
0,
"/org/webkit/gtk/WebExtensionTest",
"org.webkit.gtk.WebExtensionTest",
"URIChanged",
g_variant_new("(s)", webkit_web_page_get_uri(webPage)),
0);
g_assert(ok);
}
static gboolean
evd_dbus_agent_foreach_remove_proxy (gpointer key,
gpointer value,
gpointer user_data)
{
ProxyData *proxy_data = (ProxyData *) value;
GDBusConnection *conn = G_DBUS_CONNECTION (user_data);
GDBusConnection *proxy_conn;
proxy_conn = g_dbus_proxy_get_connection (proxy_data->proxy);
return proxy_conn == conn;
}
static void
printer_add_async_scb3 (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
PpNewPrinter *printer = (PpNewPrinter *) user_data;
PpNewPrinterPrivate *priv = printer->priv;
GVariant *output;
PPDName *ppd_item = NULL;
GError *error = NULL;
output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
res,
&error);
g_object_unref (source_object);
if (output)
{
ppd_item = get_ppd_item_from_output (output);
g_variant_unref (output);
}
else
{
if (error->domain != G_IO_ERROR ||
error->code != G_IO_ERROR_CANCELLED)
g_warning ("%s", error->message);
}
if ((!error ||
error->domain != G_IO_ERROR ||
error->code != G_IO_ERROR_CANCELLED) &&
ppd_item && ppd_item->ppd_name)
{
priv->ppd_name = g_strdup (ppd_item->ppd_name);
printer_add_real_async (printer);
}
else
{
_pp_new_printer_add_async_cb (FALSE, printer);
}
if (error)
{
g_error_free (error);
}
if (ppd_item)
{
g_free (ppd_item->ppd_name);
g_free (ppd_item);
}
}
static void on_response_sap_transfer_apdu(GObject *source_object, GAsyncResult *res, gpointer user_data)
{
GError *error = NULL;
GDBusConnection *conn = NULL;
GVariant *dbus_result;
GVariantIter *iter = NULL;
GVariant *param_gv = NULL;
GVariant *inner_gv = NULL;
guchar rt_i;
int i = 0;
struct tapi_resp_data *evt_cb_data = user_data;
TelSimSapResultCode_t result = TAPI_SIM_SAP_RESULT_CODE_OK;
TelSapApduData_t r_apdu;
dbg("Func Entrance");
memset(&r_apdu, 0, sizeof(TelSapApduData_t));
conn = G_DBUS_CONNECTION (source_object);
dbus_result = g_dbus_connection_call_finish(conn, res, &error);
if (dbus_result) {
/* dbg("dbus_result type_format(%s)", g_variant_get_type_string(dbus_result));*/
g_variant_get(dbus_result, "(i@v)", &result, ¶m_gv);
inner_gv = g_variant_get_variant(param_gv);
g_variant_get(inner_gv, "ay", &iter);
while (g_variant_iter_loop(iter, "y", &rt_i)) {
r_apdu.apdu_data[i] = rt_i;
i++;
}
r_apdu.apdu_len = (int) i;
g_variant_iter_free(iter);
g_variant_unref(inner_gv);
g_variant_unref(param_gv);
/* for(i=0; i < (int)r_apdu.apdu_len; i++)
dbg("apdu[%d][0x%02x]",i, r_apdu.apdu_data[i]);*/
}
else {
result = TAPI_SIM_SAP_RESULT_CODE_DATA_NOT_AVAILABLE;
dbg( "g_dbus_conn failed. error (%s)", error->message);
g_error_free(error);
}
if (evt_cb_data->cb_fn) {
evt_cb_data->cb_fn(evt_cb_data->handle, result, (void*)&r_apdu, evt_cb_data->user_data);
}
free(evt_cb_data);
}
/**
* Emit the page created signal that is used in the UI process to finish the
* dbus proxy connection.
*/
static void emit_page_created(GDBusConnection *connection, guint64 pageid)
{
GError *error = NULL;
/* propagate the signal over dbus */
g_dbus_connection_emit_signal(G_DBUS_CONNECTION(connection), NULL,
VB_WEBEXTENSION_OBJECT_PATH, VB_WEBEXTENSION_INTERFACE,
"PageCreated", g_variant_new("(t)", pageid), &error);
if (error) {
g_warning("Failed to emit signal PageCreated: %s", error->message);
g_error_free(error);
}
}
static void
printer_add_real_async_dbus_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
PpNewPrinter *printer;
PpNewPrinterPrivate *priv;
GVariant *output;
GError *error = NULL;
output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
res,
&error);
g_object_unref (source_object);
if (output)
{
const gchar *ret_error;
g_variant_get (output, "(&s)", &ret_error);
if (ret_error[0] != '\0')
{
g_warning ("%s", ret_error);
}
g_variant_unref (output);
}
else
{
if (error->domain != G_IO_ERROR ||
error->code != G_IO_ERROR_CANCELLED)
g_warning ("%s", error->message);
}
if (!error ||
error->domain != G_IO_ERROR ||
error->code != G_IO_ERROR_CANCELLED)
{
printer = (PpNewPrinter *) user_data;
priv = printer->priv;
get_named_dest_async (priv->name,
printer_add_real_async_cb,
printer);
}
if (error)
g_error_free (error);
}
static void
get_missing_executables_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GVariant *output;
IMEData *data = (IMEData *) user_data;
GError *error = NULL;
GList *executables = NULL;
GList *item;
output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
res,
&error);
if (output)
{
GVariant *array;
g_variant_get (output, "(@as)", &array);
if (array)
{
GVariantIter *iter;
GVariant *item;
gchar *executable;
g_variant_get (array, "as", &iter);
while ((item = g_variant_iter_next_value (iter)))
{
g_variant_get (item, "s", &executable);
executables = g_list_append (executables, executable);
g_variant_unref (item);
}
g_variant_unref (array);
}
g_variant_unref (output);
}
else if (error->domain == G_DBUS_ERROR &&
(error->code == G_DBUS_ERROR_SERVICE_UNKNOWN ||
error->code == G_DBUS_ERROR_UNKNOWN_METHOD))
{
g_warning ("Install system-config-printer which provides \
DBus method \"MissingExecutables\" to find missing executables and filters.");
g_error_free (error);
}
static void
previewer_close_ready_cb (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
GError *error = NULL;
g_dbus_connection_call_finish (G_DBUS_CONNECTION (source),
res, &error);
if (error != NULL) {
DEBUG ("Unable to call Close on NautilusPreviewer: %s",
error->message);
g_error_free (error);
}
}
static void
names_listed (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
NamespaceWatcher *watcher;
GError *error = NULL;
GVariant *reply;
GVariantIter *iter;
const gchar *name;
reply = g_dbus_connection_call_finish (G_DBUS_CONNECTION (object), result, &error);
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
{
g_error_free (error);
return;
}
watcher = user_data;
if (reply == NULL)
{
g_warning ("bus_watch_namespace: error calling org.freedesktop.DBus.ListNames: %s", error->message);
g_error_free (error);
return;
}
g_variant_get (reply, "(as)", &iter);
while (g_variant_iter_next (iter, "&s", &name))
{
if (dbus_name_has_namespace (name, watcher->name_space))
{
GetNameOwnerData *data = g_slice_new (GetNameOwnerData);
data->watcher = watcher;
data->name = g_strdup (name);
g_dbus_connection_call (watcher->connection, "org.freedesktop.DBus", "/",
"org.freedesktop.DBus", "GetNameOwner",
g_variant_new ("(s)", name), G_VARIANT_TYPE ("(s)"),
G_DBUS_CALL_FLAGS_NONE, -1, watcher->cancellable,
got_name_owner, data);
}
}
g_variant_iter_free (iter);
g_variant_unref (reply);
}
static void
connection_close_cb (GObject *source_object, GAsyncResult *result, MainData *data)
{
GError *error = NULL;
/* Finish closing the connection */
g_dbus_connection_close_finish (G_DBUS_CONNECTION (source_object), result, &error);
if (error != NULL) {
g_printerr (_("Error closing D-Bus connection: %s"), error->message);
g_printerr ("\n");
g_error_free (error);
}
post_connection_closed (data);
}
static void
get_zones_reply (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
GDBusConnection *bus = G_DBUS_CONNECTION (source);
GetZonesReplyData *d = user_data;
GVariant *ret;
GError *error = NULL;
const gchar **zones;
gint idx;
gint i;
ret = g_dbus_connection_call_finish (bus, res, &error);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (d->combo),
C_("Firewall zone", "Default"));
gtk_widget_set_tooltip_text (d->combo, _("The zone defines the trust level of the connection"));
idx = 0;
if (error) {
gtk_widget_set_sensitive (d->combo, FALSE);
g_error_free (error);
}
else {
gtk_widget_set_sensitive (d->combo, TRUE);
g_variant_get (ret, "(^a&s)", &zones);
for (i = 0; zones[i]; i++) {
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (d->combo),
zones[i]);
if (g_strcmp0 (d->zone, zones[i]) == 0)
idx = i + 1;
}
if (d->zone && idx == 0) {
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (d->combo),
d->zone);
idx = i + 1;
}
g_variant_unref (ret);
}
gtk_combo_box_set_active (GTK_COMBO_BOX (d->combo), idx);
g_free (d);
}
static void
reboot_done (GObject *source, GAsyncResult *res, gpointer data)
{
GCallback reboot_failed = data;
_cleanup_variant_unref_ GVariant *ret = NULL;
_cleanup_error_free_ GError *error = NULL;
ret = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source), res, &error);
if (ret)
return;
if (error != NULL) {
g_warning ("Calling org.gnome.SessionManager.Reboot failed: %s",
error->message);
}
reboot_failed ();
}
static void
_server_connect_start_portal_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GVariant *result;
GError *error = NULL;
result = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
res,
&error);
if (result != NULL) {
g_variant_unref (result);
} else {
g_print ("portal is not running: %s\n", error->message);
g_error_free (error);
}
}
static void
select_items_ready_cb (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
GDBusConnection *connection = G_DBUS_CONNECTION (source);
NautilusApplication *self = user_data;
GError *error = NULL;
g_dbus_connection_call_finish (connection, res, &error);
if (error != NULL) {
g_warning ("Unable to select specified URIs %s\n", error->message);
g_error_free (error);
/* open default location instead */
g_application_open (G_APPLICATION (self), NULL, 0, "");
}
}
static void documentLoadedCallback(WebKitWebPage* webPage, WebKitWebExtension* extension)
{
// FIXME: Too much code just to send a message, we need convenient custom API for this.
WebKitDOMDocument* document = webkit_web_page_get_dom_document(webPage);
GRefPtr<WebKitDOMDOMWindow> window = adoptGRef(webkit_dom_document_get_default_view(document));
if (WebKitDOMWebKitNamespace* webkit = webkit_dom_dom_window_get_webkit_namespace(window.get())) {
WebKitDOMUserMessageHandlersNamespace* messageHandlers = webkit_dom_webkit_namespace_get_message_handlers(webkit);
if (WebKitDOMUserMessageHandler* handler = webkit_dom_user_message_handlers_namespace_get_handler(messageHandlers, "dom"))
webkit_dom_user_message_handler_post_message(handler, "DocumentLoaded", nullptr);
}
webkit_dom_dom_window_webkit_message_handlers_post_message(window.get(), "dom-convenience", "DocumentLoaded");
gpointer data = g_object_get_data(G_OBJECT(extension), "dbus-connection");
if (data)
emitDocumentLoaded(G_DBUS_CONNECTION(data));
else
delayedSignalsQueue.append(DelayedSignal(DocumentLoadedSignal));
}
static void
can_set_call_finished (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
Cache *cache = user_data;
GVariant *reply;
reply = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source),
result, NULL);
if (reply != NULL)
{
g_variant_get (reply, "(i)", &cache->value);
g_variant_unref (reply);
}
cache->stamp = g_get_monotonic_time ();
cache->in_progress = FALSE;
}
