static void tapi_exit(void)
{
DBG("");
seel_io_driver_unregister(&tizen_io_driver);
seel_cert_driver_unregister(&tizen_cert_driver);
if (modem_hash != NULL) {
g_hash_table_destroy(modem_hash);
modem_hash = NULL;
}
if (cert_hash != NULL) {
g_hash_table_destroy(cert_hash);
cert_hash = NULL;
}
g_dbus_remove_watch(connection, watch);
g_dbus_remove_watch(connection, sim_watch);
dbus_connection_unref(connection);
}
static void agent_destroy(gpointer data)
{
struct connman_agent *agent = data;
DBG("agent %s req %p", agent->owner, agent->pending);
if (agent->watch > 0) {
g_dbus_remove_watch(connection, agent->watch);
agent->watch = 0;
}
agent_unref(agent);
}
static void serial_port_free(void *data)
{
struct serial_port *port = data;
struct serial_device *device = port->device;
if (device && port->listener_id > 0)
g_dbus_remove_watch(device->conn, port->listener_id);
port_release(port);
g_free(port->uuid);
g_free(port);
}
static void agent_disconnect(DBusConnection *conn, void *user_data)
{
struct connman_agent *agent = user_data;
DBG("agent %s disconnected", agent->owner);
if (agent->watch > 0) {
g_dbus_remove_watch(conn, agent->watch);
agent->watch = 0;
}
g_hash_table_remove(agent_hash, agent->owner);
}
static void ril_remove(struct ofono_modem *modem)
{
struct ril_data *ril = ofono_modem_get_data(modem);
DBG("modem: %p ril: %p", modem, ril);
ofono_modem_set_data(modem, NULL);
if (!ril)
return;
if (ril->timer_id > 0)
g_source_remove(ril->timer_id);
g_ril_unref(ril->modem);
g_free(ril);
g_dbus_remove_watch(connection, mce_daemon_watch);
if (signal_watch > 0)
g_dbus_remove_watch(connection, signal_watch);
}
static void watcher_exit_cb(DBusConnection *conn, void *user_data)
{
struct watcher *watcher = user_data;
struct heartrate_adapter *hradapter = watcher->hradapter;
DBG("heartrate watcher [%s] disconnected", watcher->path);
hradapter->watchers = g_slist_remove(hradapter->watchers, watcher);
g_dbus_remove_watch(conn, watcher->id);
if (g_slist_length(hradapter->watchers) == 0)
g_slist_foreach(hradapter->devices, disable_measurement, 0);
}
static int session_disconnect(struct connman_session *session)
{
DBG("session %p, %s", session, session->owner);
if (session->notify_watch > 0)
g_dbus_remove_watch(connection, session->notify_watch);
g_dbus_unregister_interface(connection, session->session_path,
CONNMAN_SESSION_INTERFACE);
g_hash_table_remove(session_hash, session->session_path);
return 0;
}
int connman_agent_unregister(const char *sender, const char *path)
{
DBG("sender %s path %s", sender, path);
if (agent_path == NULL)
return -ESRCH;
if (agent_watch > 0)
g_dbus_remove_watch(connection, agent_watch);
agent_free();
return 0;
}
static void lockdown_remove(struct ofono_modem *modem)
{
DBusConnection *conn = ofono_dbus_get_connection();
if (modem->lock_watch) {
g_dbus_remove_watch(conn, modem->lock_watch);
modem->lock_watch = 0;
}
g_free(modem->lock_owner);
modem->lock_owner = NULL;
modem->lockdown = FALSE;
}
static void agent_destroy(gpointer data)
{
struct agent *agent = data;
DBG("agent %s", agent->owner);
if (agent->watch > 0) {
g_dbus_remove_watch(btd_get_dbus_connection(), agent->watch);
agent->watch = 0;
agent_release(agent);
}
agent_unref(agent);
}
static void ndef_agent_free(gpointer data)
{
struct near_ndef_agent *agent = data;
DBG("");
if (!agent || agent->watch == 0)
return;
g_dbus_remove_watch(connection, agent->watch);
g_free(agent->sender);
g_free(agent->path);
}
static void agent_free(void)
{
if (agent_watch > 0)
g_dbus_remove_watch(connection, agent_watch);
agent_watch = 0;
g_free(agent_sender);
agent_sender = NULL;
g_free(agent_path);
agent_path = NULL;
connman_agent_cancel(NULL);
}
void __connman_agent_cleanup(void)
{
DBG("");
if (connection == NULL)
return;
if (agent_watch > 0)
g_dbus_remove_watch(connection, agent_watch);
release_all_agents();
dbus_connection_unref(connection);
connection = NULL;
}
static void agent_disconnect(DBusConnection *conn, void *user_data)
{
struct agent *agent = user_data;
DBG("Agent %s disconnected", agent->owner);
if (agent->watch > 0) {
g_dbus_remove_watch(conn, agent->watch);
agent->watch = 0;
}
remove_default_agent(agent);
g_hash_table_remove(agent_list, agent->owner);
}
static DBusMessage *port_connect(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
struct serial_device *device = user_data;
struct serial_port *port;
const char *pattern;
int err;
if (dbus_message_has_member(msg, "ConnectFD") && DBUS_TYPE_UNIX_FD < 0)
return btd_error_not_supported(msg);
if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &pattern,
DBUS_TYPE_INVALID) == FALSE)
return NULL;
port = find_port(device->ports, pattern);
if (!port) {
char *endptr = NULL;
int channel;
channel = strtol(pattern, &endptr, 10);
if ((endptr && *endptr != '\0') || channel < 1 || channel > 30)
return btd_error_does_not_exist(msg);
port = create_port(device, NULL, channel);
}
if (port->listener_id)
return btd_error_failed(msg, "Port already in use");
port->listener_id = g_dbus_add_disconnect_watch(conn,
dbus_message_get_sender(msg),
port_owner_exited, port,
NULL);
port->msg = dbus_message_ref(msg);
err = connect_port(port);
if (err < 0) {
error("%s", strerror(-err));
g_dbus_remove_watch(conn, port->listener_id);
port->listener_id = 0;
return btd_error_failed(msg, strerror(-err));
}
return NULL;
}
static void media_endpoint_destroy(struct media_endpoint *endpoint)
{
DBG("sender=%s path=%s", endpoint->sender, endpoint->path);
media_endpoint_cancel_all(endpoint);
g_slist_free_full(endpoint->transports,
(GDestroyNotify) media_transport_destroy);
g_dbus_remove_watch(btd_get_dbus_connection(), endpoint->watch);
g_free(endpoint->capabilities);
g_free(endpoint->sender);
g_free(endpoint->path);
g_free(endpoint->uuid);
g_free(endpoint);
}
static void path_unregister(void *data)
{
struct service_adapter *serv_adapter = data;
GSList *l, *next = NULL;
for (l = serv_adapter->records; l != NULL; l = next) {
struct record_data *user_record = l->data;
next = l->next;
g_dbus_remove_watch(connection, user_record->listener_id);
exit_callback(connection, user_record);
}
g_free(serv_adapter);
}
void agent_free(struct agent *agent)
{
if (!agent)
return;
if (agent->remove_cb)
agent->remove_cb(agent, agent->remove_cb_data);
if (agent->request) {
DBusError err;
agent_pincode_cb pincode_cb;
agent_passkey_cb passkey_cb;
agent_cb cb;
dbus_error_init(&err);
dbus_set_error_const(&err, "org.bluez.Error.Failed", "Canceled");
switch (agent->request->type) {
case AGENT_REQUEST_PINCODE:
pincode_cb = agent->request->cb;
pincode_cb(agent, &err, NULL, agent->request->user_data);
break;
case AGENT_REQUEST_PASSKEY:
passkey_cb = agent->request->cb;
passkey_cb(agent, &err, 0, agent->request->user_data);
break;
default:
cb = agent->request->cb;
cb(agent, &err, agent->request->user_data);
}
dbus_error_free(&err);
agent_cancel(agent);
}
if (!agent->exited) {
g_dbus_remove_watch(btd_get_dbus_connection(),
agent->listener_id);
agent_release(agent);
}
g_free(agent->name);
g_free(agent->path);
g_free(agent);
}
static void session_free(struct obc_session *session)
{
GSList *l = session->pending_calls;
DBG("%p", session);
while (l) {
struct pending_req *req = l->data;
l = l->next;
session->pending_calls = g_slist_remove(session->pending_calls, req);
pending_req_finalize(req);
}
if (session->agent) {
obc_agent_release(session->agent);
obc_agent_free(session->agent);
}
if (session->watch)
g_dbus_remove_watch(session->conn, session->watch);
if (session->obex != NULL)
gw_obex_close(session->obex);
if (session->io != NULL) {
g_io_channel_shutdown(session->io, TRUE, NULL);
g_io_channel_unref(session->io);
}
if (session->path)
session_unregistered(session);
if (session->conn)
dbus_connection_unref(session->conn);
if (session->conn_system)
dbus_connection_unref(session->conn_system);
sessions = g_slist_remove(sessions, session);
g_free(session->adapter);
g_free(session->callback);
g_free(session->path);
g_free(session->owner);
g_free(session);
}
int port_remove_listener(const char *owner, const char *dev)
{
struct rfcomm_node *node;
node = find_node_by_name(connected_nodes, dev);
if (!node)
return -ENOENT;
if (strcmp(node->owner, owner) != 0)
return -EPERM;
g_dbus_remove_watch(node->conn, node->listener_id);
connected_nodes = g_slist_remove(connected_nodes, node);
rfcomm_node_free(node);
return 0;
}
void gnss_agent_free(struct gnss_agent *agent)
{
DBusConnection *conn = ofono_dbus_get_connection();
if (agent->disconnect_watch) {
gnss_agent_send_release(agent);
g_dbus_remove_watch(conn, agent->disconnect_watch);
agent->disconnect_watch = 0;
}
if (agent->removed_cb)
agent->removed_cb(agent->removed_data);
g_free(agent->path);
g_free(agent->bus);
g_free(agent);
}
static gboolean rfcomm_disconnect_cb(GIOChannel *io,
GIOCondition cond, struct rfcomm_node *node)
{
debug("RFCOMM node %s was disconnected", node->device);
g_dbus_remove_watch(node->conn, node->listener_id);
g_dbus_emit_signal(node->conn, SERIAL_MANAGER_PATH,
SERIAL_MANAGER_INTERFACE, "ServiceDisconnected" ,
DBUS_TYPE_STRING, &node->device,
DBUS_TYPE_INVALID);
connected_nodes = g_slist_remove(connected_nodes, node);
rfcomm_node_free(node);
return FALSE;
}
static void supplicant_destroy(void)
{
if (g_slist_length(driver_list) > 0)
return;
_DBG_SUPPLICANT("connection %p", connection);
if (watch > 0)
g_dbus_remove_watch(connection, watch);
dbus_bus_remove_match(connection, supplicant_rule, NULL);
dbus_connection_flush(connection);
dbus_connection_remove_filter(connection, supplicant_filter, NULL);
dbus_connection_unref(connection);
connection = NULL;
}
static void agent_free(struct session_data *session)
{
struct agent_data *agent = session->agent;
if (agent->watch)
g_dbus_remove_watch(session->conn, agent->watch);
if (agent->pending) {
dbus_pending_call_cancel(agent->pending->call);
free_pending(agent->pending);
}
session->agent = NULL;
g_free(agent->name);
g_free(agent->path);
g_free(agent);
}
static void free_session(struct connman_session *session)
{
if (session == NULL)
return;
if (session->notify_watch > 0)
g_dbus_remove_watch(connection, session->notify_watch);
destroy_policy_config(session);
g_slist_free(session->info->config.allowed_bearers);
g_free(session->owner);
g_free(session->session_path);
g_free(session->notify_path);
g_free(session->info);
g_free(session->info_last);
g_free(session);
}
int obc_session_set_owner(struct obc_session *session, const char *name,
GDBusWatchFunction func)
{
if (session == NULL)
return -EINVAL;
if (session->watch)
g_dbus_remove_watch(session->conn, session->watch);
session->watch = g_dbus_add_disconnect_watch(session->conn, name, func,
session, NULL);
if (session->watch == 0)
return -EINVAL;
session->owner = g_strdup(name);
return 0;
}
static void server_free(void *data)
{
struct network_server *ns = data;
if (!ns)
return;
server_remove_sessions(ns);
if (ns->record_id)
adapter_service_remove(ns->na->adapter, ns->record_id);
g_dbus_remove_watch(btd_get_dbus_connection(), ns->watch_id);
g_free(ns->name);
g_free(ns->bridge);
g_free(ns);
}
static void release_counter(gpointer key, gpointer value, gpointer user_data)
{
struct connman_counter *counter = value;
DBusMessage *message;
DBG("owner %s path %s", counter->owner, counter->path);
if (counter->watch > 0)
g_dbus_remove_watch(connection, counter->watch);
message = dbus_message_new_method_call(counter->owner, counter->path,
CONNMAN_COUNTER_INTERFACE, "Release");
if (!message)
return;
dbus_message_set_no_reply(message, TRUE);
g_dbus_send_message(connection, message);
}
static void handover_agent_free(gpointer data)
{
struct near_handover_agent *agent = data;
if (!agent)
return;
g_free(agent->sender);
agent->sender = NULL;
g_free(agent->path);
agent->path = NULL;
if (agent->watch == 0)
return;
g_dbus_remove_watch(connection, agent->watch);
agent->watch = 0;
}
static void remove_private_network(gpointer user_data)
{
struct connman_private_network *pn = user_data;
disable_nat(default_interface);
connman_rtnl_remove_watch(pn->iface_watch);
if (pn->watch > 0) {
g_dbus_remove_watch(connection, pn->watch);
pn->watch = 0;
}
close(pn->fd);
g_free(pn->interface);
g_free(pn->owner);
g_free(pn->path);
g_free(pn);
}
