static void device_free(struct audio_device *dev)
{
struct dev_priv *priv = dev->priv;
if (dev->conn)
dbus_connection_unref(dev->conn);
btd_device_unref(dev->btd_dev);
if (priv) {
if (priv->auths)
audio_device_cancel_authorization(dev, NULL, NULL);
if (priv->control_timer)
g_source_remove(priv->control_timer);
if (priv->avdtp_timer)
g_source_remove(priv->avdtp_timer);
if (priv->headset_timer)
g_source_remove(priv->headset_timer);
if (priv->dc_req)
dbus_message_unref(priv->dc_req);
if (priv->conn_req)
dbus_message_unref(priv->conn_req);
if (priv->dc_id)
device_remove_disconnect_watch(dev->btd_dev,
priv->dc_id);
g_free(priv);
}
g_free(dev->path);
g_free(dev);
}
static void input_device_free(struct input_device *idev)
{
if (idev->dc_id)
device_remove_disconnect_watch(idev->device, idev->dc_id);
btd_service_unref(idev->service);
btd_device_unref(idev->device);
g_free(idev->name);
g_free(idev->path);
if (idev->ctrl_watch > 0)
g_source_remove(idev->ctrl_watch);
if (idev->intr_watch > 0)
g_source_remove(idev->intr_watch);
if (idev->sec_watch > 0)
g_source_remove(idev->sec_watch);
if (idev->intr_io)
g_io_channel_unref(idev->intr_io);
if (idev->ctrl_io)
g_io_channel_unref(idev->ctrl_io);
if (idev->req) {
g_free(idev->req->rd_data);
g_free(idev->req);
}
if (idev->reconnect_timer > 0)
g_source_remove(idev->reconnect_timer);
g_free(idev);
}
static void gas_free(struct gas *gas)
{
gatt_db_unref(gas->db);
bt_gatt_client_unref(gas->client);
btd_device_unref(gas->device);
g_free(gas);
}
static void peer_free(struct network_peer *peer)
{
g_slist_free_full(peer->connections, connection_free);
btd_device_unref(peer->device);
g_free(peer->path);
g_free(peer);
}
static void input_device_free(struct input_device *idev)
{
bt_uhid_unref(idev->uhid);
btd_service_unref(idev->service);
btd_device_unref(idev->device);
g_free(idev->path);
if (idev->ctrl_watch > 0)
g_source_remove(idev->ctrl_watch);
if (idev->intr_watch > 0)
g_source_remove(idev->intr_watch);
if (idev->sec_watch > 0)
g_source_remove(idev->sec_watch);
if (idev->intr_io)
g_io_channel_unref(idev->intr_io);
if (idev->ctrl_io)
g_io_channel_unref(idev->ctrl_io);
if (idev->req) {
g_free(idev->req->rd_data);
g_free(idev->req);
}
if (idev->reconnect_timer > 0)
g_source_remove(idev->reconnect_timer);
if (idev->report_req_timer > 0)
g_source_remove(idev->report_req_timer);
g_free(idev);
}
static void device_free(struct audio_device *dev)
{
struct dev_priv *priv = dev->priv;
if (dev->conn)
dbus_connection_unref(dev->conn);
btd_device_unref(dev->btd_dev);
if (priv) {
if (priv->control_timer)
g_source_remove(priv->control_timer);
if (priv->avdtp_timer)
g_source_remove(priv->avdtp_timer);
if (priv->headset_timer)
g_source_remove(priv->headset_timer);
if (priv->dc_req)
dbus_message_unref(priv->dc_req);
if (priv->conn_req)
dbus_message_unref(priv->conn_req);
g_free(priv);
}
g_free(dev->path);
g_free(dev);
}
static void peer_free(struct network_peer *peer)
{
g_slist_foreach(peer->connections, (GFunc) connection_free, NULL);
g_slist_free(peer->connections);
btd_device_unref(peer->device);
g_free(peer->path);
g_free(peer);
}
static void gatt_service_free(struct gatt_service *gatt)
{
g_slist_free_full(gatt->watchers, watcher_free);
g_slist_free_full(gatt->chars, characteristic_free);
g_slist_free(gatt->offline_chars);
g_free(gatt->path);
btd_device_unref(gatt->dev);
dbus_connection_unref(gatt->conn);
g_free(gatt);
}
static void input_device_free(struct input_device *idev)
{
if (idev->dc_id)
device_remove_disconnect_watch(idev->device, idev->dc_id);
dbus_connection_unref(idev->conn);
btd_device_unref(idev->device);
g_free(idev->name);
g_free(idev->path);
g_free(idev);
}
static void monitor_destroy(gpointer user_data)
{
struct monitor *monitor = user_data;
btd_device_unref(monitor->device);
g_free(monitor->linklosslevel);
g_free(monitor->immediatelevel);
g_free(monitor->signallevel);
g_free(monitor);
monitors = g_slist_remove(monitors, monitor);
}
static void scan_param_remove(struct btd_service *service)
{
struct scan *scan = btd_service_get_user_data(service);
if (scan->attrib != NULL && scan->refresh_cb_id > 0)
g_attrib_unregister(scan->attrib, scan->refresh_cb_id);
btd_device_remove_attio_callback(scan->device, scan->attioid);
btd_device_unref(scan->device);
g_attrib_unref(scan->attrib);
g_free(scan);
}
static void devstate_cleanup_cb(gpointer user_data)
{
struct alert_adapter *aa = user_data;
DBG("Device disconnected, reinitializing state");
aa->en_new_alerts = 0;
aa->en_unread_alerts = 0;
btd_device_remove_attio_callback(aa->device, aa->id);
btd_device_unref(aa->device);
aa->device = NULL;
aa->id = 0;
}
static void unregister_reporter_device(gpointer data, gpointer user_data)
{
struct btd_device *device = data;
struct reporter_adapter *radapter = user_data;
const char *path = device_get_path(device);
DBG("unregister on device %s", path);
g_dbus_unregister_interface(btd_get_dbus_connection(), path,
PROXIMITY_REPORTER_INTERFACE);
radapter->devices = g_slist_remove(radapter->devices, device);
btd_device_unref(device);
}
static void hog_device_free(void *data)
{
struct hog_device *dev = data;
queue_remove(devices, dev);
if (queue_isempty(devices)) {
queue_destroy(devices, NULL);
devices = NULL;
}
btd_device_remove_attio_callback(dev->device, dev->attioid);
btd_device_unref(dev->device);
bt_hog_unref(dev->hog);
free(dev);
}
static void deviceinfo_free(gpointer user_data)
{
struct deviceinfo *d = user_data;
if (d->attioid > 0)
btd_device_remove_attio_callback(d->dev, d->attioid);
if (d->attrib != NULL)
g_attrib_unref(d->attrib);
g_slist_free_full(d->chars, g_free);
btd_device_unref(d->dev);
g_free(d->svc_range);
g_free(d);
}
static void deviceinfo_driver_remove(struct btd_service *service)
{
struct deviceinfo *d = btd_service_get_user_data(service);
if (d->attioid > 0)
btd_device_remove_attio_callback(d->dev, d->attioid);
if (d->attrib != NULL)
g_attrib_unref(d->attrib);
g_slist_free_full(d->chars, g_free);
btd_device_unref(d->dev);
g_free(d->svc_range);
g_free(d);
}
static void destroy_heartrate(gpointer user_data)
{
struct heartrate *hr = user_data;
if (hr->attioid > 0)
btd_device_remove_attio_callback(hr->dev, hr->attioid);
if (hr->attrib != NULL) {
g_attrib_unregister(hr->attrib, hr->attionotid);
g_attrib_unref(hr->attrib);
}
btd_device_unref(hr->dev);
g_free(hr->svc_range);
g_free(hr);
}
static void link_loss_purge_attio_cb(struct connected_device *condev)
{
struct link_loss_adapter *la;
if (!condev)
return;
la = condev->adapter;
if (condev->callback_id && condev->device)
btd_device_remove_attio_callback(condev->device, condev->callback_id);
if (condev->device)
btd_device_unref(condev->device);
la->connected_devices = g_slist_remove(la->connected_devices, condev);
g_free(condev);
}
static void destroy_thermometer(gpointer user_data)
{
struct thermometer *t = user_data;
if (t->attioid > 0)
btd_device_remove_attio_callback(t->dev, t->attioid);
if (t->attrib != NULL) {
g_attrib_unregister(t->attrib, t->attio_measurement_id);
g_attrib_unregister(t->attrib, t->attio_intermediate_id);
g_attrib_unregister(t->attrib, t->attio_interval_id);
g_attrib_unref(t->attrib);
}
btd_device_unref(t->dev);
g_free(t->svc_range);
g_free(t);
}
static void destroy_csc(gpointer user_data)
{
struct csc *csc = user_data;
if (csc->attioid > 0)
btd_device_remove_attio_callback(csc->dev, csc->attioid);
if (csc->attrib != NULL) {
g_attrib_unregister(csc->attrib, csc->attio_measurement_id);
g_attrib_unregister(csc->attrib, csc->attio_controlpoint_id);
g_attrib_unref(csc->attrib);
}
btd_device_unref(csc->dev);
g_free(csc->svc_range);
g_free(csc->locations);
g_free(csc);
}
static void attio_connected_cb(GAttrib *attrib, gpointer user_data)
{
struct notify_callback *cb = user_data;
struct notify_data *nd = cb->notify_data;
enum notify_type type = nd->type;
struct alert_adapter *al_adapter = nd->al_adapter;
size_t len;
uint8_t *pdu = g_attrib_get_buffer(attrib, &len);
switch (type) {
case NOTIFY_RINGER_SETTING:
len = enc_notification(al_adapter->hnd_value[type],
&ringer_setting, sizeof(ringer_setting),
pdu, len);
break;
case NOTIFY_ALERT_STATUS:
len = enc_notification(al_adapter->hnd_value[type],
&alert_status, sizeof(alert_status),
pdu, len);
break;
case NOTIFY_NEW_ALERT:
case NOTIFY_UNREAD_ALERT:
len = enc_notification(al_adapter->hnd_value[type],
nd->value, nd->len, pdu, len);
break;
default:
DBG("Unknown type, could not send notification");
goto end;
}
DBG("Send notification for handle: 0x%04x, ccc: 0x%04x",
al_adapter->hnd_value[type],
al_adapter->hnd_ccc[type]);
g_attrib_send(attrib, 0, pdu, len, NULL, NULL, NULL);
end:
btd_device_remove_attio_callback(cb->device, cb->id);
btd_device_unref(cb->device);
g_free(cb->notify_data->value);
g_free(cb->notify_data);
g_free(cb);
}
static void imm_alert_remove_condev(struct connected_device *condev)
{
struct imm_alert_adapter *ia;
if (!condev)
return;
ia = condev->adapter;
if (condev->callback_id && condev->device)
btd_device_remove_attio_callback(condev->device,
condev->callback_id);
if (condev->device)
btd_device_unref(condev->device);
ia->connected_devices = g_slist_remove(ia->connected_devices, condev);
g_free(condev);
}
static void device_free(struct audio_device *dev)
{
struct dev_priv *priv = dev->priv;
if (priv) {
if (priv->control_timer)
g_source_remove(priv->control_timer);
if (priv->avdtp_timer)
g_source_remove(priv->avdtp_timer);
if (priv->dc_id)
device_remove_disconnect_watch(dev->btd_dev,
priv->dc_id);
g_free(priv);
}
btd_device_unref(dev->btd_dev);
g_free(dev);
}
static void avctp_disconnected(struct avctp *session)
{
struct avctp_server *server;
if (!session)
return;
if (session->browsing)
avctp_channel_destroy(session->browsing);
if (session->control)
avctp_channel_destroy(session->control);
if (session->auth_id != 0) {
btd_cancel_authorization(session->auth_id);
session->auth_id = 0;
}
if (session->key != NULL) {
if (session->key->timer > 0)
g_source_remove(session->key->timer);
g_free(session->key);
}
if (session->uinput >= 0) {
char address[18];
ba2str(device_get_address(session->device), address);
DBG("AVCTP: closing uinput for %s", address);
ioctl(session->uinput, UI_DEV_DESTROY);
close(session->uinput);
session->uinput = -1;
}
server = session->server;
server->sessions = g_slist_remove(server->sessions, session);
btd_device_unref(session->device);
g_free(session);
}
static void monitor_destroy(gpointer user_data)
{
struct monitor *monitor = user_data;
if (monitor->immediateto)
g_source_remove(monitor->immediateto);
if (monitor->attioid)
btd_device_remove_attio_callback(monitor->device,
monitor->attioid);
if (monitor->attrib)
g_attrib_unref(monitor->attrib);
dbus_connection_unref(monitor->conn);
btd_device_unref(monitor->device);
g_free(monitor->linkloss);
g_free(monitor->immediate);
g_free(monitor->txpower);
g_free(monitor->linklosslevel);
g_free(monitor->immediatelevel);
g_free(monitor->signallevel);
g_free(monitor);
}
static void ext_io_destroy(gpointer p)
{
struct ext_io *ext_io = p;
struct ext_profile *ext = ext_io->ext;
if (ext_io->io_id > 0)
g_source_remove(ext_io->io_id);
if (ext_io->io) {
g_io_channel_shutdown(ext_io->io, FALSE, NULL);
g_io_channel_unref(ext_io->io);
}
if (ext_io->auth_id != 0)
btd_cancel_authorization(ext_io->auth_id);
if (ext_io->new_conn) {
dbus_pending_call_cancel(ext_io->new_conn);
dbus_pending_call_unref(ext_io->new_conn);
ext_cancel(ext);
}
if (ext_io->resolving)
bt_cancel_discovery(adapter_get_address(ext_io->adapter),
device_get_address(ext_io->device));
if (ext_io->rec_handle)
remove_record_from_server(ext_io->rec_handle);
if (ext_io->adapter)
btd_adapter_unref(ext_io->adapter);
if (ext_io->device)
btd_device_unref(ext_io->device);
g_free(ext_io);
}
