void
synce_device_dbus_uninit(SynceDevice *self)
{
SynceDevicePrivate *priv = SYNCE_DEVICE_GET_PRIVATE (self);
g_return_if_fail(priv->inited && !(priv->dispose_has_run));
#if !USE_GDBUS
GError *error = NULL;
DBusGConnection *system_bus = NULL;
#endif
g_message ("%s: unregistering object path '%s'", G_STRFUNC, priv->obj_path);
#if USE_GDBUS
g_dbus_interface_skeleton_unexport(G_DBUS_INTERFACE_SKELETON(priv->interface));
g_object_unref(priv->interface);
priv->interface = NULL;
#else
system_bus = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error);
if (system_bus == NULL) {
g_critical("Failed to connect to system bus: %s", error->message);
g_error_free(error);
return;
}
dbus_g_connection_unregister_g_object(system_bus, G_OBJECT(self));
dbus_g_connection_unref(system_bus);
#endif
return;
}
static void
skeleton_destroy_func (gpointer user_data)
{
GDBusInterfaceSkeleton *skeleton = user_data;
g_dbus_interface_skeleton_unexport (skeleton);
g_object_unref (skeleton);
}
static void
synce_device_dispose (GObject *obj)
{
SynceDevice *self = SYNCE_DEVICE (obj);
SynceDevicePrivate *priv = SYNCE_DEVICE_GET_PRIVATE (self);
if (priv->dispose_has_run)
return;
priv->dispose_has_run = TRUE;
#if USE_GDBUS
if (priv->interface) {
g_dbus_interface_skeleton_unexport(G_DBUS_INTERFACE_SKELETON(priv->interface));
g_object_unref(priv->interface);
}
#endif
g_io_stream_close(G_IO_STREAM(priv->conn), NULL, NULL);
g_object_unref(priv->conn);
#if HAVE_GUDEV
g_object_unref(priv->gudev_client);
#endif
g_hash_table_destroy (priv->requests);
if (G_OBJECT_CLASS (synce_device_parent_class)->dispose)
G_OBJECT_CLASS (synce_device_parent_class)->dispose (obj);
}
static void
registration_data_unexport_interface (RegistrationData *data,
GDBusInterfaceSkeleton *interface_skeleton)
{
GDBusInterfaceInfo *info;
GDBusInterfaceSkeleton *iface;
info = g_dbus_interface_skeleton_get_info (interface_skeleton);
iface = g_hash_table_lookup (data->map_iface_name_to_iface, info->name);
g_assert (iface != NULL);
if (data->manager->priv->connection != NULL)
g_dbus_interface_skeleton_unexport (iface);
g_warn_if_fail (g_hash_table_remove (data->map_iface_name_to_iface, info->name));
/* if we are already exported, then... */
if (data->exported)
{
const gchar *interfaces[2];
/* emit InterfacesRemoved on the ObjectManager object */
interfaces[0] = info->name;
interfaces[1] = NULL;
g_dbus_object_manager_server_emit_interfaces_removed (data->manager, data, interfaces);
}
}
static void
unexport_all (GDBusObjectManagerServer *manager, gboolean only_manager)
{
GHashTableIter iter;
RegistrationData *data;
GHashTableIter iface_iter;
GDBusInterfaceSkeleton *iface;
g_return_if_fail (manager->priv->connection != NULL);
g_warn_if_fail (manager->priv->manager_reg_id > 0);
if (manager->priv->manager_reg_id > 0)
{
g_warn_if_fail (g_dbus_connection_unregister_object (manager->priv->connection,
manager->priv->manager_reg_id));
manager->priv->manager_reg_id = 0;
}
if (only_manager)
goto out;
g_hash_table_iter_init (&iter, manager->priv->map_object_path_to_data);
while (g_hash_table_iter_next (&iter, NULL, (gpointer) &data))
{
g_hash_table_iter_init (&iface_iter, data->map_iface_name_to_iface);
while (g_hash_table_iter_next (&iface_iter, NULL, (gpointer) &iface))
{
g_warn_if_fail (g_dbus_interface_skeleton_get_connection (iface) != NULL);
g_dbus_interface_skeleton_unexport (iface);
}
}
out:
;
}
static void
la_handler_service_finalize (GObject *object)
{
LAHandlerService *service = LA_HANDLER_SERVICE (object);
/* release the interface skeleton */
g_dbus_interface_skeleton_unexport (G_DBUS_INTERFACE_SKELETON (service->interface));
/* release the NSM consumer service object, if there is one */
if (service->nsm_consumer != NULL)
g_object_unref (service->nsm_consumer);
/* release the interface skeleton */
g_signal_handlers_disconnect_matched (service->interface,
G_SIGNAL_MATCH_DATA,
0, 0, NULL, NULL, service);
g_object_unref (service->interface);
/* release the job manager skeleton */
g_object_unref (service->job_manager);
/* release the D-Bus connection object */
if (service->connection != NULL)
g_object_unref (service->connection);
/* release the shutdown clients */
g_hash_table_unref (service->units_to_clients);
g_hash_table_unref (service->clients_to_units);
(*G_OBJECT_CLASS (la_handler_service_parent_class)->finalize) (object);
}
static void
set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
MMBaseManagerPrivate *priv = MM_BASE_MANAGER (object)->priv;
switch (prop_id) {
case PROP_CONNECTION: {
gboolean had_connection = FALSE;
if (priv->connection) {
had_connection = TRUE;
g_object_unref (priv->connection);
}
priv->connection = g_value_dup_object (value);
/* Propagate connection loss to subobjects */
if (had_connection && !priv->connection) {
if (priv->object_manager) {
mm_dbg ("Stopping connection in object manager server");
g_dbus_object_manager_server_set_connection (priv->object_manager, NULL);
}
if (priv->test_skeleton &&
g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (priv->test_skeleton))) {
mm_dbg ("Stopping connection in test skeleton");
g_dbus_interface_skeleton_unexport (G_DBUS_INTERFACE_SKELETON (priv->test_skeleton));
}
}
break;
}
case PROP_AUTO_SCAN:
priv->auto_scan = g_value_get_boolean (value);
break;
case PROP_ENABLE_TEST:
priv->enable_test = g_value_get_boolean (value);
break;
case PROP_PLUGIN_DIR:
g_free (priv->plugin_dir);
priv->plugin_dir = g_value_dup_string (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
_dbus_clear (SettingsPluginIfcfg *self)
{
SettingsPluginIfcfgPrivate *priv = SETTINGS_PLUGIN_IFCFG_GET_PRIVATE (self);
nm_clear_g_signal_handler (priv->dbus.connection, &priv->dbus.signal_id);
nm_clear_g_cancellable (&priv->dbus.cancellable);
if (priv->dbus.interface) {
g_dbus_interface_skeleton_unexport (priv->dbus.interface);
nm_exported_object_skeleton_release (priv->dbus.interface);
priv->dbus.interface = NULL;
}
g_clear_object (&priv->dbus.connection);
}
static void
nemo_dbus_manager_dispose (GObject *object)
{
NemoDBusManager *self = (NemoDBusManager *) object;
if (self->file_operations) {
g_dbus_interface_skeleton_unexport (G_DBUS_INTERFACE_SKELETON (self->file_operations));
g_object_unref (self->file_operations);
self->file_operations = NULL;
}
if (self->object_manager) {
g_object_unref (self->object_manager);
self->object_manager = NULL;
}
G_OBJECT_CLASS (nemo_dbus_manager_parent_class)->dispose (object);
}
static void
nautilus_freedesktop_dbus_dispose (GObject *object)
{
NautilusFreedesktopDBus *fdb = (NautilusFreedesktopDBus *) object;
if (fdb->owner_id != 0) {
g_bus_unown_name (fdb->owner_id);
fdb->owner_id = 0;
}
if (fdb->skeleton != NULL) {
g_dbus_interface_skeleton_unexport (G_DBUS_INTERFACE_SKELETON (fdb->skeleton));
g_object_unref (fdb->skeleton);
fdb->skeleton = NULL;
}
g_clear_object (&fdb->object_manager);
G_OBJECT_CLASS (nautilus_freedesktop_dbus_parent_class)->dispose (object);
}
static void
registration_data_free (RegistrationData *data)
{
GHashTableIter iter;
GDBusInterfaceSkeleton *iface;
data->exported = FALSE;
g_hash_table_iter_init (&iter, data->map_iface_name_to_iface);
while (g_hash_table_iter_next (&iter, NULL, (gpointer) &iface))
{
if (data->manager->priv->connection != NULL)
g_dbus_interface_skeleton_unexport (iface);
}
g_signal_handlers_disconnect_by_func (data->object, G_CALLBACK (on_interface_added), data);
g_signal_handlers_disconnect_by_func (data->object, G_CALLBACK (on_interface_removed), data);
g_object_unref (data->object);
g_hash_table_destroy (data->map_iface_name_to_iface);
g_free (data);
}
static void
dispose (GObject *object)
{
NMSstpPluginPrivate *priv = NM_SSTP_PLUGIN_GET_PRIVATE (object);
GDBusInterfaceSkeleton *skeleton = NULL;
if (priv->dbus_skeleton)
skeleton = G_DBUS_INTERFACE_SKELETON (priv->dbus_skeleton);
if (skeleton) {
if (g_dbus_interface_skeleton_get_object_path (skeleton))
g_dbus_interface_skeleton_unexport (skeleton);
g_signal_handlers_disconnect_by_func (skeleton, handle_need_secrets, object);
g_signal_handlers_disconnect_by_func (skeleton, handle_set_state, object);
g_signal_handlers_disconnect_by_func (skeleton, handle_set_ip4_config, object);
}
if (priv->connection)
g_object_unref (priv->connection);
G_OBJECT_CLASS (nm_sstp_plugin_parent_class)->dispose (object);
}
int
main (int argc, char *argv[])
{
GMainLoop *loop;
GDBusConnection *conn;
gboolean replace;
gboolean show_version;
GError *error;
guint name_owner_id;
GBusNameOwnerFlags flags;
GOptionContext *context;
const GOptionEntry options[] = {
{ "replace", 'r', 0, G_OPTION_ARG_NONE, &replace, N_("Replace old daemon."), NULL },
{ "version", 0, 0, G_OPTION_ARG_NONE, &show_version, N_("Show program version."), NULL},
{ NULL }
};
setlocale (LC_ALL, "");
bindtextdomain (GETTEXT_PACKAGE, GVFS_LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
g_set_application_name (_("GVFS Metadata Daemon"));
context = g_option_context_new ("");
g_option_context_set_summary (context, _("Metadata daemon for GVFS"));
g_option_context_add_main_entries (context, options, GETTEXT_PACKAGE);
replace = FALSE;
show_version = FALSE;
name_owner_id = 0;
error = NULL;
if (!g_option_context_parse (context, &argc, &argv, &error))
{
/* Translators: the first %s is the application name, */
/* the second %s is the error message */
g_printerr (_("%s: %s"), g_get_application_name(), error->message);
g_printerr ("\n");
g_printerr (_("Try \"%s --help\" for more information."),
g_get_prgname ());
g_printerr ("\n");
g_error_free (error);
g_option_context_free (context);
return 1;
}
g_option_context_free (context);
if (show_version)
{
g_print(PACKAGE_STRING "\n");
return 0;
}
error = NULL;
conn = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
if (!conn)
{
g_printerr ("Failed to connect to the D-BUS daemon: %s (%s, %d)\n",
error->message, g_quark_to_string (error->domain), error->code);
g_error_free (error);
return 1;
}
tree_infos = g_hash_table_new_full (g_str_hash,
g_str_equal,
NULL,
(GDestroyNotify)tree_info_free);
loop = g_main_loop_new (NULL, FALSE);
g_dbus_connection_set_exit_on_close (conn, FALSE);
g_signal_connect (conn, "closed", G_CALLBACK (on_connection_closed), loop);
flags = G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT;
if (replace)
flags |= G_BUS_NAME_OWNER_FLAGS_REPLACE;
skeleton = gvfs_metadata_skeleton_new ();
g_signal_connect (skeleton, "handle-set", G_CALLBACK (handle_set), skeleton);
g_signal_connect (skeleton, "handle-remove", G_CALLBACK (handle_remove), skeleton);
g_signal_connect (skeleton, "handle-move", G_CALLBACK (handle_move), skeleton);
g_signal_connect (skeleton, "handle-get-tree-from-device", G_CALLBACK (handle_get_tree_from_device), skeleton);
error = NULL;
if (!g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (skeleton), conn,
G_VFS_DBUS_METADATA_PATH, &error))
{
g_printerr ("Error exporting metadata daemon: %s (%s, %d)\n",
error->message, g_quark_to_string (error->domain), error->code);
g_error_free (error);
g_object_unref (conn);
g_main_loop_unref (loop);
return 1;
}
name_owner_id = g_bus_own_name_on_connection (conn,
G_VFS_DBUS_METADATA_NAME,
flags,
NULL,
on_name_lost,
loop,
NULL);
g_main_loop_run (loop);
if (skeleton)
g_dbus_interface_skeleton_unexport (G_DBUS_INTERFACE_SKELETON (skeleton));
if (name_owner_id != 0)
g_bus_unown_name (name_owner_id);
if (conn)
g_object_unref (conn);
if (loop != NULL)
g_main_loop_unref (loop);
return 0;
}
