static void
on_load_unit_done (GObject *object,
GAsyncResult *res,
gpointer user_data)
{
GetServiceInfoData *data = user_data;
GError *error = NULL;
cleanup_unref_variant GVariant *result = g_dbus_proxy_call_finish (G_DBUS_PROXY(object), res, &error);
if (error)
{
end_invocation_take_gerror (data->invocation, error);
g_free (data);
return;
}
const gchar *path;
g_variant_get (result, "(&o)", &path);
if (path)
{
GDBusConnection *conn = g_dbus_proxy_get_connection (data->services->systemd);
g_dbus_connection_call (conn,
"org.freedesktop.systemd1",
path,
"org.freedesktop.DBus.Properties",
"GetAll",
g_variant_new ("(s)", ""),
G_VARIANT_TYPE ("(a{sv})"),
0,
-1,
NULL,
on_get_all_done_for_info,
data);
}
else
{
g_dbus_method_invocation_return_error (data->invocation,
COCKPIT_ERROR, COCKPIT_ERROR_FAILED,
"Heh.");
g_free (data);
}
}
/**
* mm_modem_messaging_list_sync:
* @self: A #MMModemMessaging.
* @cancellable: (allow-none): A #GCancellable or %NULL.
* @error: Return location for error or %NULL.
*
* Synchronously lists the #MMSms objects in the modem.
*
* The calling thread is blocked until a reply is received. See mm_modem_messaging_list()
* for the asynchronous version of this method.
*
* Returns: (element-type MMSms) (transfer full): A list of #MMSms objects, or #NULL if either not found or @error is set. The returned value should be freed with g_list_free_full() using g_object_unref() as #GDestroyNotify function.
*/
GList *
mm_modem_messaging_list_sync (MMModemMessaging *self,
GCancellable *cancellable,
GError **error)
{
GList *sms_objects = NULL;
gchar **sms_paths = NULL;
guint i;
g_return_val_if_fail (MM_IS_MODEM_MESSAGING (self), NULL);
sms_paths = mm_gdbus_modem_messaging_dup_messages (MM_GDBUS_MODEM_MESSAGING (self));
/* Only non-empty lists are returned */
if (!sms_paths)
return NULL;
for (i = 0; sms_paths[i]; i++) {
GObject *sms;
sms = g_initable_new (MM_TYPE_SMS,
cancellable,
error,
"g-flags", G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
"g-name", MM_DBUS_SERVICE,
"g-connection", g_dbus_proxy_get_connection (G_DBUS_PROXY (self)),
"g-object-path", sms_paths[i],
"g-interface-name", "org.freedesktop.ModemManager1.Sms",
NULL);
if (!sms) {
sms_object_list_free (sms_objects);
g_strfreev (sms_paths);
return NULL;
}
/* Keep the object */
sms_objects = g_list_prepend (sms_objects, sms);
}
g_strfreev (sms_paths);
return sms_objects;
}
static void
rate_song (GDBusProxy *mpris, gdouble song_rating)
{
GHashTable *properties;
GVariantBuilder props;
GVariant *v;
GError *error = NULL;
properties = get_playing_song_info (mpris);
if (properties == NULL) {
rb_debug ("can't set rating when not playing");
return;
}
v = g_hash_table_lookup (properties, "xesam:url");
if (v == NULL) {
rb_debug ("can't set rating, no url");
return;
}
g_variant_builder_init (&props, G_VARIANT_TYPE ("a{sv}"));
g_variant_builder_add (&props, "{sv}", "rating", g_variant_new_double (song_rating));
g_dbus_connection_call_sync (g_dbus_proxy_get_connection (mpris),
"org.gnome.Rhythmbox3",
"/org/gnome/Rhythmbox3/RhythmDB",
"org.gnome.Rhythmbox3.RhythmDB",
"SetEntryProperties",
g_variant_new ("(sa{sv})", g_variant_get_string (v, NULL), &props),
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (error != NULL) {
g_warning ("Error setting rating on %s: %s",
g_variant_get_string (v, NULL),
error->message);
g_clear_error (&error);
}
g_hash_table_destroy (properties);
}
/**
* mm_modem_voice_list_calls_sync:
* @self: A #MMModemVoice.
* @cancellable: (allow-none): A #GCancellable or %NULL.
* @error: Return location for error or %NULL.
*
* Synchronously lists the #MMCall objects in the modem.
*
* The calling thread is blocked until a reply is received. See mm_modem_voice_list_calls()
* for the asynchronous version of this method.
*
* Returns: (element-type MMCall) (transfer full): A list of #MMCall objects, or #NULL if either not found or @error is set. The returned value should be freed with g_list_free_full() using g_object_unref() as #GDestroyNotify function.
*/
GList *
mm_modem_voice_list_calls_sync (MMModemVoice *self,
GCancellable *cancellable,
GError **error)
{
GList *call_objects = NULL;
gchar **call_paths = NULL;
guint i;
g_return_val_if_fail (MM_IS_MODEM_VOICE (self), NULL);
call_paths = mm_gdbus_modem_voice_dup_calls (MM_GDBUS_MODEM_VOICE (self));
/* Only non-empty lists are returned */
if (!call_paths)
return NULL;
for (i = 0; call_paths[i]; i++) {
GObject *call;
call = g_initable_new (MM_TYPE_CALL,
cancellable,
error,
"g-flags", G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
"g-name", MM_DBUS_SERVICE,
"g-connection", g_dbus_proxy_get_connection (G_DBUS_PROXY (self)),
"g-object-path", call_paths[i],
"g-interface-name", "org.freedesktop.ModemManager1.Call",
NULL);
if (!call) {
call_object_list_free (call_objects);
g_strfreev (call_paths);
return NULL;
}
/* Keep the object */
call_objects = g_list_prepend (call_objects, call);
}
g_strfreev (call_paths);
return call_objects;
}
static void testDocumentLoadedSignal(WebViewTest* test, gconstpointer)
{
GRefPtr<GDBusProxy> proxy = adoptGRef(bus->createProxy("org.webkit.gtk.WebExtensionTest",
"/org/webkit/gtk/WebExtensionTest", "org.webkit.gtk.WebExtensionTest", test->m_mainLoop));
GDBusConnection* connection = g_dbus_proxy_get_connection(proxy.get());
guint id = g_dbus_connection_signal_subscribe(connection,
0,
"org.webkit.gtk.WebExtensionTest",
"DocumentLoaded",
"/org/webkit/gtk/WebExtensionTest",
0,
G_DBUS_SIGNAL_FLAGS_NONE,
reinterpret_cast<GDBusSignalCallback>(documentLoadedCallback),
test,
0);
g_assert(id);
test->loadHtml("<html><head><title>WebKitGTK+ Web Extensions Test</title></head><body></body></html>", 0);
g_main_loop_run(test->m_mainLoop);
g_dbus_connection_signal_unsubscribe(connection, id);
}
/**
* fcitx_input_method_set_imlist:
* @im: A #FcitxInputMethod
* @array: (element-type FcitxIMItem) (transfer none): A #FcitxIMItem List
*
* Set Fcitx all im list
**/
FCITX_EXPORT_API
void fcitx_input_method_set_imlist(FcitxInputMethod *im, GPtrArray *array) {
GVariantBuilder builder;
g_variant_builder_init(&builder, G_VARIANT_TYPE("a(sssb)"));
g_ptr_array_foreach(array, _fcitx_im_item_foreach_cb, &builder);
GVariant *value = g_variant_builder_end(&builder);
GError *error = NULL;
GVariant *result = g_dbus_connection_call_sync(
g_dbus_proxy_get_connection(G_DBUS_PROXY(im)),
g_dbus_proxy_get_name(G_DBUS_PROXY(im)), FCITX_IM_DBUS_PATH,
"org.freedesktop.DBus.Properties", "Set",
g_variant_new("(ssv)", FCITX_IM_DBUS_INTERFACE, "IMList", value),
G_VARIANT_TYPE_UNIT, G_DBUS_CALL_FLAGS_NONE, -1, /* timeout */
NULL, &error);
if (error) {
g_warning("%s", error->message);
g_error_free(error);
}
g_variant_unref(result);
}
static void steadyflow_iapp_service_proxy_set_visible (SteadyflowIAppService* self, gboolean visible, GError** error) {
GDBusMessage *_message;
GVariant *_arguments;
GVariantBuilder _arguments_builder;
GDBusMessage *_reply_message;
G_IO_ERROR;
_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "net.launchpad.steadyflow.App", "SetVisible");
g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
g_variant_builder_add_value (&_arguments_builder, g_variant_new_boolean (visible));
_arguments = g_variant_builder_end (&_arguments_builder);
g_dbus_message_set_body (_message, _arguments);
_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
g_object_unref (_message);
if (!_reply_message) {
return;
}
if (g_dbus_message_to_gerror (_reply_message, error)) {
g_object_unref (_reply_message);
return;
}
g_object_unref (_reply_message);
}
static void
prepare_print_called (GObject *source,
GAsyncResult *result,
gpointer data)
{
PortalData *portal = data;
GError *error = NULL;
const char *handle = NULL;
GVariant *ret;
ret = g_dbus_proxy_call_finish (portal->proxy, result, &error);
if (ret == NULL)
{
if (portal->op->priv->error == NULL)
portal->op->priv->error = g_error_copy (error);
g_error_free (error);
if (portal->loop)
g_main_loop_quit (portal->loop);
return;
}
else
g_variant_get (ret, "(&o)", &handle);
portal->response_signal_id =
g_dbus_connection_signal_subscribe (g_dbus_proxy_get_connection (G_DBUS_PROXY (portal->proxy)),
"org.freedesktop.portal.Desktop",
"org.freedesktop.portal.Request",
"Response",
handle,
NULL,
G_DBUS_SIGNAL_FLAGS_NO_MATCH_RULE,
prepare_print_response,
portal, NULL);
g_variant_unref (ret);
}
static void
cm_service_free (CMService *cm_service)
{
if (cm_service->proxy != NULL) {
GDBusConnection *cnx;
cnx = g_dbus_proxy_get_connection (cm_service->proxy);
if (cm_service->sig_prop_id) {
g_dbus_connection_signal_unsubscribe (cnx,
cm_service->sig_prop_id);
cm_service->sig_prop_id = 0;
}
g_object_unref (cm_service->proxy);
}
if (cm_service->cancellable != NULL) {
g_cancellable_cancel (cm_service->cancellable);
g_object_unref (cm_service->cancellable);
}
service_context_remove_creation_timeout (cm_service);
if (cm_service->context != NULL) {
g_signal_emit_by_name (cm_service->manager,
"context-unavailable",
cm_service->context);
g_object_unref (cm_service->context);
}
g_free (cm_service->iface);
g_free (cm_service->name);
g_slice_free (CMService, cm_service);
}
/**
* secret_prompt_perform:
* @self: a prompt
* @window_id: XWindow id for parent window to be transient for
* @return_type: the variant type of the prompt result
* @cancellable: optional cancellation object
* @callback: called when the operation completes
* @user_data: data to be passed to the callback
*
* Runs a prompt and performs the prompting. Returns %TRUE if the prompt
* was completed and not dismissed.
*
* If @window_id is non-zero then it is used as an XWindow id. The Secret
* Service can make its prompt transient for the window with this id. In some
* Secret Service implementations this is not possible, so the behavior
* depending on this should degrade gracefully.
*
* This method will return immediately and complete asynchronously.
*/
void
secret_prompt_perform (SecretPrompt *self,
gulong window_id,
const GVariantType *return_type,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GSimpleAsyncResult *res;
PerformClosure *closure;
const gchar *owner_name;
const gchar *object_path;
gboolean prompted;
GDBusProxy *proxy;
gchar *window;
g_return_if_fail (SECRET_IS_PROMPT (self));
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
prompted = g_atomic_int_get (&self->pv->prompted);
if (prompted) {
g_warning ("The prompt object has already had its prompt called.");
return;
}
proxy = G_DBUS_PROXY (self);
res = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
secret_prompt_perform);
closure = g_slice_new0 (PerformClosure);
closure->connection = g_object_ref (g_dbus_proxy_get_connection (proxy));
closure->call_cancellable = g_cancellable_new ();
closure->async_cancellable = cancellable ? g_object_ref (cancellable) : NULL;
closure->return_type = return_type ? g_variant_type_copy (return_type) : NULL;
g_simple_async_result_set_op_res_gpointer (res, closure, perform_closure_free);
if (window_id == 0)
window = g_strdup ("");
else
window = g_strdup_printf ("%lu", window_id);
owner_name = g_dbus_proxy_get_name_owner (proxy);
object_path = g_dbus_proxy_get_object_path (proxy);
closure->signal = g_dbus_connection_signal_subscribe (closure->connection, owner_name,
SECRET_PROMPT_INTERFACE,
SECRET_PROMPT_SIGNAL_COMPLETED,
object_path, NULL,
G_DBUS_SIGNAL_FLAGS_NONE,
on_prompt_completed,
g_object_ref (res),
g_object_unref);
closure->watch = g_bus_watch_name_on_connection (closure->connection, owner_name,
G_BUS_NAME_WATCHER_FLAGS_NONE, NULL,
on_prompt_vanished,
g_object_ref (res),
g_object_unref);
if (closure->async_cancellable) {
closure->cancelled_sig = g_cancellable_connect (closure->async_cancellable,
G_CALLBACK (on_prompt_cancelled),
res, NULL);
}
g_dbus_proxy_call (proxy, "Prompt", g_variant_new ("(s)", window),
G_DBUS_CALL_FLAGS_NO_AUTO_START, -1,
closure->call_cancellable, on_prompt_prompted, g_object_ref (res));
g_free (window);
g_object_unref (res);
}
$NetBSD: patch-calendar_libecal_e-cal.c,v 1.1 2016/01/31 07:01:55 richard Exp $ The e-calendar-factory process did not terminate automatically when the user logged out of the graphical desktop environment, and e-calendar-factory thus redundantly consumed system resources. (https://bugzilla.redhat.com/show_bug.cgi?id=1141760 and upstream https://bugzilla.gnome.org/show_bug.cgi?id=646117) --- calendar/libecal/e-cal.c.orig 2011-04-21 19:36:35.000000000 +0000 +++ calendar/libecal/e-cal.c @@ -709,7 +709,6 @@ e_cal_activate (GError **error) } connection = g_dbus_proxy_get_connection (G_DBUS_PROXY (cal_factory_proxy)); - g_dbus_connection_set_exit_on_close (connection, FALSE); cal_connection_closed_id = g_dbus_connection_signal_subscribe (connection, NULL, /* sender */ "org.freedesktop.DBus", /* interface */
gboolean
rpmostree_transaction_get_response_sync (RPMOSTreeSysroot *sysroot_proxy,
const char *transaction_address,
GCancellable *cancellable,
GError **error)
{
guint sigintid = 0;
GDBusConnection *connection;
glnx_unref_object GDBusObjectManager *object_manager = NULL;
glnx_unref_object RPMOSTreeTransaction *transaction = NULL;
TransactionProgress *tp = transaction_progress_new ();
const char *bus_name = NULL;
gint cancel_handler;
gulong signal_handler = 0;
gboolean success = FALSE;
gboolean just_started = FALSE;
connection = g_dbus_proxy_get_connection (G_DBUS_PROXY (sysroot_proxy));
if (g_dbus_connection_get_unique_name (connection) != NULL)
bus_name = BUS_NAME;
/* If we are on the message bus, setup object manager connection
* to notify if the owner changes. */
if (bus_name != NULL)
{
object_manager = rpmostree_object_manager_client_new_sync (connection,
G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE,
bus_name,
"/org/projectatomic/rpmostree1",
cancellable,
error);
if (object_manager == NULL)
goto out;
g_signal_connect (object_manager,
"notify::name-owner",
G_CALLBACK (on_owner_changed),
tp);
}
transaction = rpmostree_transaction_connect (transaction_address, cancellable, error);
if (!transaction)
goto out;
sigintid = g_unix_signal_add (SIGINT, on_sigint, cancellable);
/* setup cancel handler */
cancel_handler = g_cancellable_connect (cancellable,
G_CALLBACK (cancelled_handler),
transaction, NULL);
signal_handler = g_signal_connect (transaction, "g-signal",
G_CALLBACK (on_transaction_progress),
tp);
/* Tell the server we're ready to receive signals. */
if (!rpmostree_transaction_call_start_sync (transaction,
&just_started,
cancellable,
error))
goto out;
/* FIXME Use the 'just_started' flag to determine whether to print
* a message about reattaching to an in-progress transaction,
* like:
*
* Existing upgrade in progress, reattaching. Control-C to cancel.
*
* But that requires having a printable description of the
* operation. Maybe just add a string arg to this function?
*/
g_main_loop_run (tp->loop);
g_cancellable_disconnect (cancellable, cancel_handler);
if (!g_cancellable_set_error_if_cancelled (cancellable, error))
{
if (tp->error)
{
g_propagate_error (error, tp->error);
}
else
{
success = TRUE;
}
}
out:
if (sigintid)
g_source_remove (sigintid);
if (signal_handler)
g_signal_handler_disconnect (transaction, signal_handler);
transaction_progress_free (tp);
return success;
}
static gboolean
handle_print (XdpPrint *object,
GDBusMethodInvocation *invocation,
GUnixFDList *fd_list,
const gchar *arg_parent_window,
const gchar *arg_title,
GVariant *arg_fd,
GVariant *arg_options)
{
Request *request = request_from_invocation (invocation);
const char *app_id = xdp_app_info_get_id (request->app_info);
g_autoptr(GError) error = NULL;
g_autoptr(XdpImplRequest) impl_request = NULL;
GVariantBuilder opt_builder;
if (xdp_impl_lockdown_get_disable_printing (lockdown))
{
g_debug ("Printing disabled");
g_dbus_method_invocation_return_error (invocation,
XDG_DESKTOP_PORTAL_ERROR,
XDG_DESKTOP_PORTAL_ERROR_NOT_ALLOWED,
"Printing disabled");
return TRUE;
}
REQUEST_AUTOLOCK (request);
impl_request = xdp_impl_request_proxy_new_sync (g_dbus_proxy_get_connection (G_DBUS_PROXY (impl)),
G_DBUS_PROXY_FLAGS_NONE,
g_dbus_proxy_get_name (G_DBUS_PROXY (impl)),
request->id,
NULL, &error);
if (!impl_request)
{
g_dbus_method_invocation_return_gerror (invocation, error);
return TRUE;
}
request_set_impl_request (request, impl_request);
request_export (request, g_dbus_method_invocation_get_connection (invocation));
g_variant_builder_init (&opt_builder, G_VARIANT_TYPE_VARDICT);
xdp_filter_options (arg_options, &opt_builder,
print_options, G_N_ELEMENTS (print_options));
xdp_impl_print_call_print(impl,
request->id,
app_id,
arg_parent_window,
arg_title,
arg_fd,
g_variant_builder_end (&opt_builder),
fd_list,
NULL,
print_done,
g_object_ref (request));
xdp_print_complete_print (object, invocation, NULL, request->id);
return TRUE;
}
static gboolean
handle_open_file (XdpFileChooser *object,
GDBusMethodInvocation *invocation,
const gchar *arg_parent_window,
const gchar *arg_title,
GVariant *arg_options)
{
Request *request = request_from_invocation (invocation);
const char *app_id = request->app_id;
g_autoptr(GError) error = NULL;
g_autoptr(XdpImplRequest) impl_request = NULL;
GVariantBuilder options;
g_autoptr(GVariant) value = NULL;
REQUEST_AUTOLOCK (request);
value = g_variant_lookup_value (arg_options, "filters", NULL);
if (value != NULL)
{
if (!check_filters (value, &error))
{
g_prefix_error (&error, "invalid filters: ");
g_dbus_method_invocation_return_gerror (invocation, error);
return TRUE;
}
g_variant_unref (value);
value = NULL;
}
value = g_variant_lookup_value (arg_options, "choices", NULL);
if (value != NULL)
{
if (!check_choices (value, &error))
{
g_prefix_error (&error, "invalid choices: ");
g_dbus_method_invocation_return_gerror (invocation, error);
return TRUE;
}
g_variant_unref (value);
value = NULL;
}
g_variant_builder_init (&options, G_VARIANT_TYPE_VARDICT);
xdp_filter_options (arg_options, &options,
open_file_options, G_N_ELEMENTS (open_file_options));
impl_request = xdp_impl_request_proxy_new_sync (g_dbus_proxy_get_connection (G_DBUS_PROXY (impl)),
G_DBUS_PROXY_FLAGS_NONE,
g_dbus_proxy_get_name (G_DBUS_PROXY (impl)),
request->id,
NULL, &error);
if (!impl_request)
{
g_dbus_method_invocation_return_gerror (invocation, error);
return TRUE;
}
request_set_impl_request (request, impl_request);
request_export (request, g_dbus_method_invocation_get_connection (invocation));
xdp_impl_file_chooser_call_open_file (impl,
request->id,
app_id,
arg_parent_window,
arg_title,
g_variant_builder_end (&options),
NULL,
open_file_done,
g_object_ref (request));
xdp_file_chooser_complete_open_file (object, invocation, request->id);
return TRUE;
}
static void
identity_registered (SignonIdentity *identity,
char *object_path, GVariant *identity_data,
GError *error)
{
g_return_if_fail (SIGNON_IS_IDENTITY (identity));
SignonIdentityPrivate *priv;
priv = identity->priv;
g_return_if_fail (priv != NULL);
if (!error)
{
GDBusConnection *connection;
GDBusProxy *auth_service_proxy;
const gchar *bus_name;
GError *proxy_error = NULL;
DEBUG("%s: %s", G_STRFUNC, object_path);
/*
* TODO: as Aurel will finalize the code polishing so we will
* need to implement the refresh of the proxy to SignonIdentity
* */
g_return_if_fail (priv->proxy == NULL);
auth_service_proxy = (GDBusProxy *)priv->auth_service_proxy;
connection = g_dbus_proxy_get_connection (auth_service_proxy);
bus_name = g_dbus_proxy_get_name (auth_service_proxy);
priv->proxy =
sso_identity_proxy_new_sync (connection,
G_DBUS_PROXY_FLAGS_NONE,
bus_name,
object_path,
priv->cancellable,
&proxy_error);
if (G_UNLIKELY (proxy_error != NULL))
{
g_warning ("Failed to initialize Identity proxy: %s",
proxy_error->message);
g_clear_error (&proxy_error);
}
priv->signal_info_updated =
g_signal_connect (priv->proxy,
"info-updated",
G_CALLBACK (identity_state_changed_cb),
identity);
priv->signal_unregistered =
g_signal_connect (priv->proxy,
"unregistered",
G_CALLBACK (identity_remote_object_destroyed_cb),
identity);
if (identity_data)
{
DEBUG("%s: ", G_STRFUNC);
priv->identity_info =
signon_identity_info_new_from_variant (identity_data);
g_variant_unref (identity_data);
}
priv->updated = TRUE;
}
else
g_warning ("%s: %s", G_STRFUNC, error->message);
/*
* execute queued operations or emit errors on each of them
* */
priv->registration_state = REGISTERED;
/*
* TODO: if we will add a new state for identity: "INVALID"
* consider emission of another error, like "invalid"
* */
_signon_object_ready (identity, identity_object_quark (), error);
/*
* as the registration failed we do not
* request for new registration, but emit
* same error again and again
* */
}
static void
auth_session_get_object_path_reply (GObject *object, GAsyncResult *res,
gpointer userdata)
{
SsoAuthService *proxy = SSO_AUTH_SERVICE (object);
gchar *object_path = NULL;
GError *error = NULL;
sso_auth_service_call_get_auth_session_object_path_finish (proxy,
&object_path,
res,
&error);
SIGNON_RETURN_IF_CANCELLED (error);
g_return_if_fail (SIGNON_IS_AUTH_SESSION (userdata));
SignonAuthSession *self = SIGNON_AUTH_SESSION (userdata);
SignonAuthSessionPrivate *priv = self->priv;
g_return_if_fail (priv != NULL);
priv->registering = FALSE;
if (!g_strcmp0(object_path, "") || error)
{
if (error)
DEBUG ("Error message is %s", error->message);
else
error = g_error_new (signon_error_quark(),
SIGNON_ERROR_RUNTIME,
"Cannot create remote AuthSession object");
}
else
{
GDBusConnection *connection;
const gchar *bus_name;
GError *proxy_error = NULL;
connection = g_dbus_proxy_get_connection ((GDBusProxy *)proxy);
bus_name = g_dbus_proxy_get_name ((GDBusProxy *)proxy);
priv->proxy =
sso_auth_session_proxy_new_sync (connection,
G_DBUS_PROXY_FLAGS_NONE,
bus_name,
object_path,
priv->cancellable,
&proxy_error);
if (G_UNLIKELY (proxy_error != NULL))
{
g_warning ("Failed to initialize AuthSession proxy: %s",
proxy_error->message);
g_clear_error (&proxy_error);
}
g_dbus_proxy_set_default_timeout ((GDBusProxy *)priv->proxy,
G_MAXINT);
priv->signal_state_changed =
g_signal_connect (priv->proxy,
"state-changed",
G_CALLBACK (auth_session_state_changed_cb),
self);
priv->signal_unregistered =
g_signal_connect (priv->proxy,
"unregistered",
G_CALLBACK (auth_session_remote_object_destroyed_cb),
self);
}
DEBUG ("Object path received: %s", object_path);
_signon_object_ready (self, auth_session_object_quark (), error);
g_clear_error (&error);
}
gboolean
rpmostree_load_os_proxies (RPMOSTreeSysroot *sysroot_proxy,
gchar *opt_osname,
GCancellable *cancellable,
RPMOSTreeOS **out_os_proxy,
RPMOSTreeOSExperimental **out_osexperimental_proxy,
GError **error)
{
g_autofree char *os_object_path = NULL;
if (opt_osname == NULL)
os_object_path = rpmostree_sysroot_dup_booted (sysroot_proxy);
if (os_object_path == NULL)
{
/* Usually if opt_osname is null and the property isn't
populated that means the daemon isn't listen on the bus
make the call anyways to get the standard error.
*/
if (!opt_osname)
opt_osname = "";
if (!rpmostree_sysroot_call_get_os_sync (sysroot_proxy,
opt_osname,
&os_object_path,
cancellable,
error))
return FALSE;
}
/* owned by sysroot_proxy */
GDBusConnection *connection = g_dbus_proxy_get_connection (G_DBUS_PROXY (sysroot_proxy));
const char *bus_name;
if (g_dbus_connection_get_unique_name (connection) != NULL)
bus_name = BUS_NAME;
glnx_unref_object RPMOSTreeOS *os_proxy =
rpmostree_os_proxy_new_sync (connection,
G_DBUS_PROXY_FLAGS_NONE,
bus_name,
os_object_path,
cancellable,
error);
if (os_proxy == NULL)
return FALSE;
glnx_unref_object RPMOSTreeOSExperimental *ret_osexperimental_proxy = NULL;
if (out_osexperimental_proxy)
{
ret_osexperimental_proxy =
rpmostree_osexperimental_proxy_new_sync (connection,
G_DBUS_PROXY_FLAGS_NONE,
bus_name,
os_object_path,
cancellable,
error);
if (!ret_osexperimental_proxy)
return FALSE;
}
*out_os_proxy = g_steal_pointer (&os_proxy);
if (out_osexperimental_proxy)
*out_osexperimental_proxy = g_steal_pointer (&ret_osexperimental_proxy);
return TRUE;
}
