Exemple #1
0
static void
tracker_controller_dbus_stop (TrackerController *controller)
{
	TrackerControllerPrivate *priv;

	priv = controller->priv;

	if (priv->registration_id != 0) {
		g_dbus_connection_unregister_object (priv->d_connection,
		                                     priv->registration_id);
	}

	if (priv->bus_name_id != 0) {
		g_bus_unown_name (priv->bus_name_id);
	}

	if (priv->introspection_data) {
		g_dbus_node_info_unref (priv->introspection_data);
	}

	if (priv->d_connection) {
		g_object_unref (priv->d_connection);
	}

	if (priv->connection) {
		g_object_unref (priv->connection);
	}
}
Exemple #2
0
/**
 * cd_sensor_finalize:
 **/
static void
cd_sensor_finalize (GObject *object)
{
	CdSensor *sensor = CD_SENSOR (object);
	CdSensorPrivate *priv = sensor->priv;

	if (priv->registration_id > 0) {
		g_debug ("CdSensor: Unregister interface %i on %s",
			  priv->registration_id,
			  priv->object_path);
		g_dbus_connection_unregister_object (priv->connection,
						     priv->registration_id);
	}
	if (priv->watcher_id != 0)
		g_bus_unwatch_name (priv->watcher_id);
	g_free (priv->model);
	g_free (priv->vendor);
	g_free (priv->serial);
	g_free (priv->id);
	g_free (priv->object_path);
	g_hash_table_unref (priv->options);
	g_hash_table_unref (priv->metadata);
#ifdef HAVE_GUSB
	g_object_unref (priv->usb_ctx);
	g_object_unref (priv->device_list);
#endif
#ifdef HAVE_GUDEV
	if (priv->device != NULL)
		g_object_unref (priv->device);
#endif

	G_OBJECT_CLASS (cd_sensor_parent_class)->finalize (object);
}
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:
  ;
}
Exemple #4
0
static void
impl_deactivate(PeasActivatable *activatable)
{
	XmrMprisPlugin *plugin;

	plugin = XMR_MPRIS_PLUGIN(activatable);

	g_signal_handlers_disconnect_by_func(plugin->window,
					track_changed, plugin);

	g_signal_handlers_disconnect_by_func(plugin->player,
				player_tick, plugin);

	g_signal_handlers_disconnect_by_func(plugin->player,
			player_state_changed, plugin);

	if (plugin->root_id != 0)
	{
		g_dbus_connection_unregister_object(plugin->connection, plugin->root_id);
		plugin->root_id = 0;
	}
	if (plugin->player_id != 0)
	{
		g_dbus_connection_unregister_object(plugin->connection, plugin->player_id);
		plugin->player_id = 0;
	}
	if (plugin->name_own_id > 0) {
		g_bus_unown_name(plugin->name_own_id);
		plugin->name_own_id = 0;
	}
	if (plugin->connection != NULL)
	{
		g_object_unref(plugin->connection);
		plugin->connection = NULL;
	}

	if (plugin->current_song)
	{
		song_info_free(plugin->current_song);
		plugin->current_song = NULL;
	}

	g_object_unref(plugin->window);
	g_object_unref(plugin->player);
}
void AbstractDBusInterface::unregisterObject()
{
	if(regId)
	{
		DebugOut()<<__FUNCTION__<<endl;
		g_dbus_connection_unregister_object(mConnection, regId);
	}

	regId=0;
}
static void tts_cleanup(wrtc_t *wrtc)
{
    if (wrtc->gtts != 0) {
        g_dbus_connection_unregister_object(wrtc->gdbus, wrtc->gtts);
        wrtc->gtts = 0;
    }

    if (wrtc->intr != NULL) {
        g_dbus_node_info_unref(wrtc->intr);
        wrtc->intr = NULL;
    }
}
static void prv_connector_unpublish_object(dleyna_connector_id_t connection,
					   guint object_id)
{
	DLEYNA_LOG_DEBUG("Enter, object_id = %u", object_id);

	g_dbus_connection_unregister_object((GDBusConnection *)connection,
					    object_id);

	(void) g_hash_table_remove(g_context.objects, &object_id);

	DLEYNA_LOG_DEBUG("Exit");
}
Exemple #8
0
void
ev_application_shutdown (EvApplication *application)
{
	if (application->uri) {
#ifdef ENABLE_DBUS
		ev_application_unregister_uri (application,
					       application->uri);
#endif
		g_free (application->uri);
		application->uri = NULL;
	}

	ev_application_accel_map_save (application);

	g_object_unref (application->scr_saver);
	application->scr_saver = NULL;

#ifdef ENABLE_DBUS
	if (application->keys) {
		g_object_unref (application->keys);
		application->keys = NULL;
	}
        if (application->registration_id != 0) {
                g_dbus_connection_unregister_object (application->connection,
                                                     application->registration_id);
                application->registration_id = 0;
        }
        if (application->connection != NULL) {
                g_object_unref (application->connection);
                application->connection = NULL;
        }
	if (introspection_data) {
		g_dbus_node_info_ref (introspection_data);
		introspection_data = NULL;
	}
#endif /* ENABLE_DBUS */

        g_free (application->dot_dir);
        application->dot_dir = NULL;
        g_free (application->data_dir);
        application->data_dir = NULL;
	g_free (application->filechooser_open_uri);
        application->filechooser_open_uri = NULL;
	g_free (application->filechooser_save_uri);
	application->filechooser_save_uri = NULL;

	g_object_unref (application);
        instance = NULL;

	gtk_main_quit ();
}
Exemple #9
0
void mpris_base_unregister(mpris *inst)
{
	gulong *current_sig_id = inst->base_sig_id_list;

	while(current_sig_id && *current_sig_id > 0)
	{
		g_signal_handler_disconnect(	inst->gmpv_ctx->gui,
						*current_sig_id );

		current_sig_id++;
	}

	g_dbus_connection_unregister_object(	inst->session_bus_conn,
						inst->base_reg_id );

	g_hash_table_remove_all(inst->base_prop_table);
	g_hash_table_unref(inst->base_prop_table);
	g_free(inst->base_sig_id_list);
}
Exemple #10
0
static void
finalize(GObject* object)
{
  ZathuraDbus* dbus = ZATHURA_DBUS(object);
  private_t* priv   = GET_PRIVATE(dbus);

  if (priv->connection != NULL && priv->registration_id > 0) {
    g_dbus_connection_unregister_object(priv->connection, priv->registration_id);
  }

  if (priv->owner_id > 0) {
    g_bus_unown_name(priv->owner_id);
  }

  if (priv->introspection_data != NULL) {
    g_dbus_node_info_unref(priv->introspection_data);
  }

  G_OBJECT_CLASS(zathura_dbus_parent_class)->finalize(object);
}
Exemple #11
0
static void
evd_dbus_agent_free_reg_obj_data (gpointer data)
{
  ObjectData *obj_data;
  RegObjData *reg_obj_data = (RegObjData *) data;

  obj_data = reg_obj_data->obj_data;

  g_dbus_connection_unregister_object (reg_obj_data->dbus_conn,
                                       reg_obj_data->reg_id);

  g_hash_table_remove (obj_data->reg_objs, &reg_obj_data->reg_str_id);

  g_free (reg_obj_data->obj_path);
  g_dbus_interface_info_unref (reg_obj_data->iface_info);
  g_object_unref (reg_obj_data->dbus_conn);
  g_hash_table_destroy (reg_obj_data->invocations);

  g_slice_free (RegObjData, reg_obj_data);
}
Exemple #12
0
static void gtlm_nfc_dispose(GObject *object)
{
    GTlmNfc* self = GTLM_NFC (object);

    if (self->system_bus) {
        GError* error = NULL;
        GVariant* agent_register_response = g_dbus_connection_call_sync (self->system_bus,
                                         "org.neard",
                                         "/org/neard",
                                         "org.neard.AgentManager",
                                        "UnregisterNDEFAgent",
                                        g_variant_new("(os)",
                                                      "/org/tlmnfc/agent",
                                                      "application/gtlm-nfc"),
                                        NULL,
                                        G_DBUS_CALL_FLAGS_NONE,
                                        -1,
                                        NULL,
                                        &error);
        if (agent_register_response == NULL) {
            g_debug ("Error unregistering an agent with neard: %s", error->message);
            g_error_free (error);
        }
        g_variant_unref(agent_register_response);
    }
    if (self->agent_registration_id > 0)
        if (g_dbus_connection_unregister_object(self->system_bus, self->agent_registration_id) == FALSE)
            g_debug("Error unregistering agent object");


    if (self->neard_manager) {
        g_object_unref(self->neard_manager);
        self->neard_manager = NULL;
    }
    if (self->system_bus) {
        g_object_unref(self->system_bus);
        self->system_bus = NULL;
    }
    
    G_OBJECT_CLASS (gtlm_nfc_parent_class)->dispose (object);
}
void AbstractDBusInterface::unregisterObject()
{
	g_dbus_connection_unregister_object(mConnection, regId);
}
Exemple #14
0
/**
 * g_dbus_connection_unexport_menu_model:
 * @connection: a #GDBusConnection
 * @export_id: the ID from g_dbus_connection_export_menu_model()
 *
 * Reverses the effect of a previous call to
 * g_dbus_connection_export_menu_model().
 *
 * It is an error to call this function with an ID that wasn't returned
 * from g_dbus_connection_export_menu_model() or to call it with the
 * same ID more than once.
 *
 * Since: 2.32
 */
void
g_dbus_connection_unexport_menu_model (GDBusConnection *connection,
                                       guint            export_id)
{
  g_dbus_connection_unregister_object (connection, export_id);
}
Exemple #15
0
void unregister_agent_callbacks(GError **error)
{
    if (_bt_agent_registration_id)
        g_dbus_connection_unregister_object(g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, error), _bt_agent_registration_id);
}
AutomotiveManager::~AutomotiveManager()
{
	g_dbus_connection_unregister_object(mConnection, regId);
}
Exemple #17
0
int
main (int argc, char *argv[])
{
	GOptionContext *opt_ctx = NULL;
	GError *error = NULL;
	NMConnectionList *list = NULL;
	guint owner_id = 0, registration_id = 0;
	GDBusConnection *bus = NULL;
	gs_free char *type = NULL, *uuid = NULL, *import = NULL;
	gboolean create = FALSE, show = FALSE;
	int ret = 1;

	GOptionEntry entries[] = {
		{ ARG_TYPE,   't', 0, G_OPTION_ARG_STRING, &type,   "Type of connection to show or create", NM_SETTING_WIRED_SETTING_NAME },
		{ ARG_CREATE, 'c', 0, G_OPTION_ARG_NONE,   &create, "Create a new connection", NULL },
		{ ARG_SHOW,   's', 0, G_OPTION_ARG_NONE,   &show,   "Show a given connection type page", NULL },
		{ "edit",     'e', 0, G_OPTION_ARG_STRING, &uuid,   "Edit an existing connection with a given UUID", "UUID" },
		{ ARG_IMPORT, 'i', 0, G_OPTION_ARG_STRING, &import, "Import a VPN connection from given file", NULL },

		/* This is not passed over D-Bus. */
		{ "keep-above", 0, G_OPTION_FLAG_HIDDEN, G_OPTION_ARG_NONE, &nm_ce_keep_above, NULL, NULL },
		{ NULL }
	};

	bindtextdomain (GETTEXT_PACKAGE, NMALOCALEDIR);
	bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
	gtk_init (&argc, &argv);
	textdomain (GETTEXT_PACKAGE);

	opt_ctx = g_option_context_new (NULL);
	g_option_context_set_summary (opt_ctx, "Allows users to view and edit network connection settings");
	g_option_context_add_main_entries (opt_ctx, entries, NULL);
	if (!g_option_context_parse (opt_ctx, &argc, &argv, &error)) {
		g_printerr ("Failed to parse options: %s\n", error->message);
		goto out;
	}

	/* Just one page for both CDMA & GSM, handle that here */
	if (g_strcmp0 (type, NM_SETTING_CDMA_SETTING_NAME) == 0) {
		g_free (type);
		type = g_strdup (NM_SETTING_GSM_SETTING_NAME);
	}

	bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
	if (bus) {
		/* Check for an existing instance on the bus, and if there
		 * is one, send the arguments to it and exit instead of opening
		 * a second instance of the connection editor.
		 */
		if (try_existing_instance (bus, type, create, show, uuid, import)) {
			/* success */
			ret = 0;
			goto out;
		}
	}

	loop = g_main_loop_new (NULL, FALSE);

	list = nm_connection_list_new ();
	if (!list) {
		g_warning ("Failed to initialize the UI, exiting...");
		goto out;
	}
	g_signal_connect_swapped (list, "done", G_CALLBACK (g_main_loop_quit), loop);

	owner_id = start_service (bus, list, &registration_id);

	/* Figure out what page or editor window we'll show initially */
	if (handle_arguments (list, type, create, show, uuid, import, (create || show || uuid || import)))
		nm_connection_list_present (list);

	g_unix_signal_add (SIGTERM, signal_handler, GINT_TO_POINTER (SIGTERM));
	g_unix_signal_add (SIGINT, signal_handler, GINT_TO_POINTER (SIGINT));

	g_main_loop_run (loop);
	ret = 0;

out:
	if (owner_id)
		g_bus_unown_name (owner_id);
	if (registration_id)
		g_dbus_connection_unregister_object (bus, registration_id);
	if (introspection_data)
		g_dbus_node_info_unref (introspection_data);
	g_clear_error (&error);
	if (opt_ctx)
		g_option_context_free (opt_ctx);
	g_clear_object (&list);
	g_clear_object (&bus);
	return ret;
}
Exemple #18
0
static void
handle_method_call (GDBusConnection       *connection,
                    const gchar           *sender,
                    const gchar           *object_path,
                    const gchar           *interface_name,
                    const gchar           *method_name,
                    GVariant              *parameters,
                    GDBusMethodInvocation *invocation,
                    gpointer               user_data)
{
	if (g_strcmp0 (method_name, "RegisterMe") == 0)
	{
		GError *error;
		gchar *nickname;
		gint registration_id;
		gint i;
		gchar *client_object;
		gchar *response;
		gboolean unregistered;
		gboolean unique_username;
		GUser user;

		g_variant_get (parameters, "(&s)", &nickname);
		client_object = g_strdup_printf ("%s/%s", OBJECT_PATH,nickname);
		error = NULL;
		unique_username = TRUE;

		for (i = 0 ; i < users->len; i++)
		{
			user = g_array_index (users, GUser, i);
			if (g_strcmp0(user.nickname, nickname) == 0)
			{
				unique_username = FALSE;
				break;
			}
		}

		if (unique_username == FALSE)
		{
			g_print ("%s already registered, not registering the new one!\n",nickname);
			response = g_strdup (&REGISTRATION_RESPONSE_NOT_OK);
			g_dbus_method_invocation_return_value (invocation,
													 g_variant_new ("(s)", response));
			g_free (response);
			return;
		}

		unregistered = g_dbus_connection_unregister_object(connection,temp_registration_id);

		if (unregistered == FALSE)
		{
			g_printerr ("Error unregistering the temp object!\n");
		}

		registration_id = g_dbus_connection_register_object (connection,
																client_object,
																introspection_data->interfaces[0],
																&interface_vtable,
																NULL,
																NULL,
																&error);
		if (registration_id <= 0)
		{
			g_print ("%s not registered!\n",nickname);
			response = g_strdup (&REGISTRATION_RESPONSE_NOT_OK);
			g_dbus_method_invocation_return_value (invocation,
													 g_variant_new ("(s)", response));
		    g_free (response);
		}
		else if (error == NULL)
		{
			gint iter;

			user.registration_id = registration_id;
			i = 0;
			for (; i < MAX_CHAR; i++)
			{
				user.nickname[i] = nickname[i];
				if (nickname[i] == 0)
					break;
			}
			user.connection = connection;
			g_print ("%s joined the chat.\n",user.nickname);

			g_array_append_val(users, user);

			for (iter = 0; iter < users->len ; iter++)
			{
				user = g_array_index (users, GUser, iter);
				if (g_strcmp0(nickname,user.nickname) == 0)
					continue;
				object_path = g_strdup_printf("%s/%s", OBJECT_PATH, &user.nickname);
				g_dbus_connection_emit_signal(user.connection,
												NULL,
												object_path,
												INTERFACE_PATH,
												"joined_chat",
												g_variant_new ("(s)",
																nickname),
												&error);

			}

			response = g_strdup (&REGISTRATION_RESPONSE_OK);
			g_dbus_method_invocation_return_value (invocation,
													 g_variant_new ("(s)", response));
			g_free (response);
		}
	}
	else if (g_strcmp0 (method_name, "SendMessage") == 0)
	{
		gchar *nick;
		gchar *content;
		gchar *object_path;
		gint iter;
		GError *error;
		GUser user;

		g_variant_get (parameters, "(&s&s)", &nick, &content);
		error = NULL;

		g_print ("%s: %s\n", nick, content);

		for (iter = 0; iter < users->len ; iter++)
		{
			user = g_array_index (users, GUser, iter);
			if (g_strcmp0(nick,user.nickname) == 0)
				continue;
			object_path = g_strdup_printf("%s/%s", OBJECT_PATH, &user.nickname);
			g_dbus_connection_emit_signal(user.connection,
											NULL,
											object_path,
											INTERFACE_PATH,
											"message",
											g_variant_new ("(ss)",
															nick,
															content),
											&error);

		}

	}
	else if (g_strcmp0 (method_name, "ListUsers") == 0)
	{
		gchar *list;
		GError *error;
		gchar *nickname;
		GUser user;
		gint iter;

		list = get_users_list();
		error = NULL;

		g_variant_get (parameters, "(&s)", &nickname);
		object_path = g_strdup_printf ("%s/%s", OBJECT_PATH,nickname);
		for (iter = 0; iter < users->len; iter++)
		{
			user = g_array_index (users, GUser, iter);
			if (g_strcmp0(nickname,user.nickname) == 0)
			{
				g_dbus_connection_emit_signal(user.connection,
												NULL,
												object_path,
												INTERFACE_PATH,
												"users_list",
												g_variant_new ("(s)",
																list),
												&error);
				break;
			}
		}

	}
	else if (g_strcmp0 (method_name, "QuitChat") == 0)
	{
		gchar *list;
		GError *error;
		gchar *nickname;
		GUser user;
		gint iter;
		gint position;
		gboolean unregistered;

		position = 0;
		list = get_users_list();
		error = NULL;
		g_variant_get (parameters, "(&s)", &nickname);

		for (iter = 0; iter < users->len; iter++)
		{
			user = g_array_index (users, GUser, iter);
			if (g_strcmp0(nickname,user.nickname) == 0)
			{
				// Save position for later
				position = iter;

				// Unregister object on dbus
				unregistered = g_dbus_connection_unregister_object(connection, user.registration_id);
				if (unregistered == FALSE)
				{
					g_printerr ("Error unregistering the object!\n");
				}

				// Unref the connection
				g_object_unref (user.connection);
			}
			else
			{
				object_path = g_strdup_printf ("%s/%s", OBJECT_PATH,&user.nickname);
				g_dbus_connection_emit_signal(user.connection,
												NULL,
												object_path,
												INTERFACE_PATH,
												"left_chat",
												g_variant_new ("(s)",
																nickname),
												&error);
			}
		}
		// Remove the user from users list
		g_array_remove_index(users,position);

		g_print ("%s left the chat!\n", nickname);
	}
	else
	{
		 g_printerr ("Unknown method!\n");
	}
}