void FcitxNotificationItemDestroy(void* arg)
{
FcitxNotificationItem* notificationitem = (FcitxNotificationItem*) arg;
if (notificationitem->conn) {
dbus_connection_unregister_object_path(notificationitem->conn, NOTIFICATION_ITEM_DEFAULT_OBJ);
dbus_connection_unregister_object_path(notificationitem->conn, "/MenuBar");
}
free(notificationitem);
}
static void profile_done(pa_bluetooth_backend *b, pa_bluetooth_profile_t profile) {
pa_assert(b);
switch (profile) {
case PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT:
dbus_connection_unregister_object_path(pa_dbus_connection_get(b->connection), HSP_AG_PROFILE);
break;
case PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY:
dbus_connection_unregister_object_path(pa_dbus_connection_get(b->connection), HSP_HS_PROFILE);
break;
default:
pa_assert_not_reached();
break;
}
}
/*!
* \brief Carry out all actions to finalise the D-Bus connection.
*/
void
pcb_dbus_finish (void)
{
DBusError err;
// Initialise the error variable
dbus_error_init (&err);
// TODO: Could emit a "goodbye" signal here?
dbus_connection_flush (pcb_dbus_conn);
dbus_connection_unregister_object_path (pcb_dbus_conn,
PCB_DBUS_OBJECT_PATH);
dbus_bus_release_name (pcb_dbus_conn, PCB_DBUS_CANONICAL_NAME, &err);
dbus_error_free (&err);
pcb_dbus_connection_finish_with_mainloop (pcb_dbus_conn);
dbus_connection_close (pcb_dbus_conn);
dbus_connection_unref (pcb_dbus_conn);
// Call DBus shutdown. This doesn't work with shared connections,
// only private ones (like we took out earlier).
// If any future module / plugin to PCB wants to use DBus too,
// we must remove this call. DBus will get shut-down when the app exits.
dbus_shutdown ();
}
void DBus_InterpCleanup(Tcl_Interp *interp, DBusConnection *conn, char *path)
{
char **entries, **entry, *newpath, *pathentry;
Tcl_DBusHandlerData *data;
dbus_connection_get_object_path_data(conn, path, (void **)&data);
if (data != NULL) {
if (DBus_HandlerCleanup(interp, data)) {
dbus_connection_unregister_object_path(conn, path);
ckfree((char *)data);
}
}
dbus_connection_list_registered(conn, path, &entries);
if (*entries != NULL) {
newpath = ckalloc(strlen(path) + 256);
strcpy(newpath, path);
pathentry = newpath + strlen(path) - 1;
if (*pathentry++ != '/') *pathentry++ = '/';
for (entry = entries; *entry != NULL; entry++) {
strncpy(pathentry, *entry, 255);
/* Get a list of descendents from the child */
DBus_InterpCleanup(interp, conn, newpath);
}
ckfree(newpath);
}
/* Release the entries array */
dbus_free_string_array(entries);
}
static void
cleanup_singleton (gpointer unused)
{
g_return_if_fail (dbus_conn);
if (object_registered)
dbus_connection_unregister_object_path (dbus_conn, GNOME_KEYRING_DAEMON_PATH);
object_registered = FALSE;
}
static int ldbus_connection_unregister_object_path(lua_State *L) {
DBusConnection *connection = check_DBusConnection(L, 1);
const char *path = luaL_checkstring(L, 2);
if (!dbus_connection_unregister_object_path(connection, path)) {
return luaL_error(L, LDBUS_NO_MEMORY);
}
lua_pushboolean(L, 1);
return 1;
}
/**
* wpas_dbus_ctrl_iface_deinit - Deinitialize dbus ctrl interface for
* wpa_supplicant
* @iface: Pointer to dbus private data from wpas_dbus_init()
*
* Deinitialize the dbus control interface that was initialized with
* wpas_dbus_ctrl_iface_init().
*/
void wpas_dbus_ctrl_iface_deinit(struct wpas_dbus_priv *iface)
{
if (!iface->dbus_new_initialized)
return;
wpa_printf(MSG_DEBUG, "dbus: Unregister D-Bus object '%s'",
WPAS_DBUS_NEW_PATH);
dbus_connection_unregister_object_path(iface->con,
WPAS_DBUS_NEW_PATH);
}
void FcitxNotificationItemDestroy(void* arg)
{
FcitxNotificationItem* notificationitem = (FcitxNotificationItem*) arg;
if (notificationitem->conn) {
dbus_connection_unregister_object_path(notificationitem->conn, NOTIFICATION_ITEM_DEFAULT_OBJ);
dbus_connection_unregister_object_path(notificationitem->conn, "/MenuBar");
dbus_connection_remove_filter(notificationitem->conn, FcitxNotificationItemDBusFilter, notificationitem);
dbus_bus_remove_match(notificationitem->conn,
"type='signal',"
"interface='" DBUS_INTERFACE_DBUS "',"
"path='" DBUS_PATH_DBUS "',"
"member='NameOwnerChanged',"
"arg0='" NOTIFICATION_WATCHER_DBUS_ADDR "'",
NULL);
}
free(notificationitem);
}
void FcitxXkbDBusDestroy(void* arg)
{
FcitxXkbDBus* xkbdbus = arg;
if (xkbdbus->watcherId) {
FcitxDBusUnwatchName(xkbdbus->owner, xkbdbus->watcherId);
}
if (xkbdbus->conn) {
dbus_connection_unregister_object_path(xkbdbus->conn, FCITX_XKB_PATH);
}
if (xkbdbus->privconn) {
dbus_connection_unregister_object_path(xkbdbus->privconn, FCITX_XKB_PATH);
}
FcitxIsoCodesFree(xkbdbus->isocodes);
free(xkbdbus);
}
static void mafw_proxy_renderer_dispose (GObject *obj)
{
MafwProxyRenderer *renderer_obj = MAFW_PROXY_RENDERER(obj);
if (connection)
{
dbus_connection_unregister_object_path(connection,
proxy_extension_return_path(renderer_obj));
dbus_connection_unref(connection);
}
}
void avahi_dbus_async_host_name_resolver_free(AsyncHostNameResolverInfo *i) {
assert(i);
if (i->host_name_resolver)
avahi_s_host_name_resolver_free(i->host_name_resolver);
dbus_connection_unregister_object_path(server->bus, i->path);
AVAHI_LLIST_REMOVE(AsyncHostNameResolverInfo, async_host_name_resolvers, i->client->async_host_name_resolvers, i);
i->client->n_objects--;
assert(i->client->n_objects >= 0);
avahi_free(i);
}
static jboolean tearDownNativeDataNative(JNIEnv *env, jobject object) {
LOGV(__FUNCTION__);
#ifdef HAVE_BLUETOOTH
native_data_t *nat =
(native_data_t *)env->GetIntField(object, field_mNativeData);
if (nat != NULL) {
const char *device_agent_path =
"/android/bluetooth/remote_device_agent";
dbus_connection_unregister_object_path (nat->conn, device_agent_path);
}
#endif /*HAVE_BLUETOOTH*/
return JNI_TRUE;
}
static void mafw_proxy_playlist_finalize(GObject *object)
{
MafwProxyPlaylist* playlist = MAFW_PROXY_PLAYLIST(object);
MafwProxyPlaylistPrivate *priv;
priv = MAFW_PROXY_PLAYLIST_GET_PRIVATE(playlist);
dbus_connection_unregister_object_path(priv->connection,
priv->obj_path);
dbus_connection_unref(priv->connection);
g_free(priv->obj_path);
}
void cras_dbus_control_stop()
{
if (!dbus_control.conn)
return;
dbus_connection_unregister_object_path(dbus_control.conn,
CRAS_ROOT_OBJECT_PATH);
dbus_connection_unref(dbus_control.conn);
dbus_control.conn = NULL;
cras_observer_remove(dbus_control.observer);
dbus_control.observer = NULL;
}
static void
wsnamesFini (CompPlugin *p)
{
freeDisplayPrivateIndex (displayPrivateIndex);
bananaUnloadPlugin (bananaIndex);
if (core.dbusConnection != NULL)
{
dbus_connection_unregister_object_path (core.dbusConnection,
"/org/fusilli/wsnames");
}
}
void avahi_dbus_entry_group_free(EntryGroupInfo *i) {
assert(i);
if (i->entry_group)
avahi_s_entry_group_free(i->entry_group);
dbus_connection_unregister_object_path(server->bus, i->path);
avahi_free(i->path);
AVAHI_LLIST_REMOVE(EntryGroupInfo, entry_groups, i->client->entry_groups, i);
i->client->n_objects--;
assert(i->client->n_objects >= 0);
avahi_free(i);
}
void avahi_dbus_domain_browser_free(DomainBrowserInfo *i) {
assert(i);
if (i->domain_browser)
avahi_s_domain_browser_free(i->domain_browser);
dbus_connection_unregister_object_path(server->bus, i->path);
avahi_free(i->path);
AVAHI_LLIST_REMOVE(DomainBrowserInfo, domain_browsers, i->client->domain_browsers, i);
i->client->n_objects--;
assert(i->client->n_objects >= 0);
avahi_free(i);
}
void avahi_dbus_service_type_browser_free(ServiceTypeBrowserInfo *i) {
assert(i);
if (i->service_type_browser)
avahi_s_service_type_browser_free(i->service_type_browser);
dbus_connection_unregister_object_path(server->bus, i->path);
avahi_free(i->path);
AVAHI_LLIST_REMOVE(ServiceTypeBrowserInfo, service_type_browsers, i->client->service_type_browsers, i);
i->client->n_objects--;
assert(i->client->n_objects >= 0);
avahi_free(i);
}
void pcb_dbus_finish( void )
{
DBusError err;
dbus_error_init( err.name );
dbus_connection_flush( &pcb_dbus_conn );
dbus_connection_unregister_object_path( &pcb_dbus_conn, "/org/seul/geda/pcb" );
dbus_bus_release_name( &pcb_dbus_conn, "org.seul.geda.pcb", err.name );
dbus_error_free( err.name );
pcb_dbus_connection_finish_with_mainloop( &pcb_dbus_conn );
dbus_connection_close( &pcb_dbus_conn );
dbus_connection_unref( &pcb_dbus_conn );
dbus_shutdown( );
return;
}
static void mafw_proxy_source_dispose (GObject *obj)
{
MafwProxySource *source_obj = MAFW_PROXY_SOURCE(obj);
if (connection)
{
dbus_connection_unregister_object_path(connection,
proxy_extension_return_path(source_obj));
dbus_connection_unref(connection);
}
if (source_obj->priv->browse_requests)
g_hash_table_destroy(source_obj->priv->browse_requests);
}
void pa_dbusobj_server_lookup_free(pa_dbusobj_server_lookup *sl) {
pa_assert(sl);
if (sl->path_registered) {
pa_assert(sl->conn);
if (!dbus_connection_unregister_object_path(pa_dbus_connection_get(sl->conn), OBJECT_PATH))
pa_log_debug("dbus_connection_unregister_object_path() failed for " OBJECT_PATH ".");
}
if (sl->conn)
pa_dbus_connection_unref(sl->conn);
pa_xfree(sl);
}
void
pre_disconnect_hook(void)
{
DBusError error;
dbus_error_init(&error);
dbus_connection_unregister_object_path(connection_data->connection,
connection_data->busobject);
dbus_bus_remove_match(connection_data->connection, MATCH_RULE,
&error);
dbus_bus_release_name(connection_data->connection,
connection_data->busname, &error);
dbus_error_free(&error);
}
void
gconf_database_dbus_teardown (GConfDatabase *db)
{
DBusConnection *conn;
conn = gconfd_dbus_get_connection ();
dbus_connection_unregister_object_path (conn, db->object_path);
dbus_connection_remove_filter (conn,
(DBusHandleMessageFunction)database_filter_func,
db);
g_free (db->object_path);
db->object_path = NULL;
}
void avahi_dbus_record_browser_free(RecordBrowserInfo *i) {
assert(i);
if (i->record_browser)
avahi_s_record_browser_free(i->record_browser);
if (i->path) {
dbus_connection_unregister_object_path(server->bus, i->path);
avahi_free(i->path);
}
AVAHI_LLIST_REMOVE(RecordBrowserInfo, record_browsers, i->client->record_browsers, i);
assert(i->client->n_objects >= 1);
i->client->n_objects--;
avahi_free(i);
}
static void cleanupNative(JNIEnv* env, jobject object) {
#ifdef HAVE_BLUETOOTH
LOGV("%s", __FUNCTION__);
native_data_t *nat =
(native_data_t *)env->GetIntField(object, field_mNativeData);
if (nat) {
if (!dbus_connection_unregister_object_path (nat->conn, GATT_CLIENT_WATCHER_PATH)) {
LOGE("%s: Can't unregister object path %s for GATT Client watcher!",
__FUNCTION__, GATT_CLIENT_WATCHER_PATH);
}
dbus_connection_close(nat->conn);
env->DeleteGlobalRef(nat->me);
free(nat);
nat = NULL;
}
#endif
}
static void
server_handle_shutdown (DBusConnection *connection, DBusMessage *message)
{
DBusMessage *reply;
if (gconfd_dbus_check_in_shutdown (connection, message))
return;
gconf_log(GCL_DEBUG, _("Shutdown request received"));
reply = dbus_message_new_method_return (message);
dbus_connection_send (connection, reply, NULL);
dbus_message_unref (reply);
dbus_connection_unregister_object_path (connection, server_path);
gconfd_main_quit();
}
static void object_path_unref(DBusConnection *connection, const char *path)
{
struct generic_data *data = NULL;
LOG("object_path_unref");
if (dbus_connection_get_object_path_data(connection, path,
(void *) &data) == FALSE)
return;
if (data == NULL)
return;
data->refcount--;
if (data->refcount > 0)
return;
dbus_connection_unregister_object_path(data->conn, data->path);
}
gboolean
ibus_connection_unregister_object_path (IBusConnection *connection, const gchar *path)
{
g_assert (IBUS_IS_CONNECTION (connection));
g_assert (path != NULL);
IBusConnectionPrivate *priv;
priv = IBUS_CONNECTION_GET_PRIVATE (connection);
gboolean retval;
retval = dbus_connection_unregister_object_path (priv->connection, path);
if (!retval) {
g_warning ("Out of memory!");
return FALSE;
}
return TRUE;
}
/**
* wrapper_unexport:
* @comp: the extension to unexport.
*
* De-registers the given component from D-Bus, frees data structures for
* which it's responsible.
*/
static void wrapper_unexport(gpointer comp)
{
DBusError err;
GList *node;
ExportedComponent *ecomp;
ecomp = NULL;
for (node = Exports; node; node = node->next) {
ecomp = (ExportedComponent *)node->data;
if (ecomp->comp == comp)
break;
}
if (!ecomp)
return;
dbus_connection_unregister_object_path(Session_bus, ecomp->object_path);
dbus_error_init(&err);
switch (dbus_bus_release_name(Session_bus, ecomp->service_name, &err)){
case DBUS_RELEASE_NAME_REPLY_NOT_OWNER:
case DBUS_RELEASE_NAME_REPLY_NON_EXISTENT:
g_warning("dbus_bus_release_name() failed, either "
"'%s' is non-existent, or we are not the owners",
ecomp->service_name);
break;
default:
if (dbus_error_is_set(&err)) {
g_warning("dbus_bus_release_name() an error was set: "
"%s", err.message);
dbus_error_free(&err);
}
}
disconnect_sighandlers(ecomp);
g_free(ecomp->service_name);
g_free(ecomp->object_path);
ecomp->object_path = NULL;
g_free(ecomp->name);
g_free(ecomp->uuid);
g_free(ecomp);
Exports = g_list_delete_link(Exports, node);
extension_deregister(comp);
}
/**
* wpa_dbus_unregister_object_per_iface - Unregisters DBus object
* @ctrl_iface: Pointer to dbus private data
* @path: DBus path to object which will be unregistered
* Returns: Zero on success and -1 on failure
*
* Unregisters DBus object given by its path
*/
int wpa_dbus_unregister_object_per_iface(
struct wpas_dbus_priv *ctrl_iface, const char *path)
{
DBusConnection *con = ctrl_iface->con;
struct wpa_dbus_object_desc *obj_desc = NULL;
dbus_connection_get_object_path_data(con, path, (void **) &obj_desc);
if (!obj_desc) {
wpa_printf(MSG_ERROR, "dbus: %s: Could not obtain object's "
"private data: %s", __func__, path);
} else {
eloop_cancel_timeout(flush_object_timeout_handler, con,
obj_desc);
}
if (!dbus_connection_unregister_object_path(con, path))
return -1;
return 0;
}
