void avrcp_unregister(const bdaddr_t *src)
{
struct avctp_server *server;
server = find_server(servers, src);
if (!server)
return;
servers = g_slist_remove(servers, server);
#ifndef ANDROID
remove_record_from_server(server->ct_record_id);
#endif
remove_record_from_server(server->tg_record_id);
g_io_channel_shutdown(server->io, TRUE, NULL);
g_io_channel_unref(server->io);
g_free(server);
if (servers)
return;
dbus_connection_unref(connection);
connection = NULL;
}
static DBusMessage *update_record(DBusConnection *conn, DBusMessage *msg,
struct service_adapter *serv_adapter,
dbus_uint32_t handle, sdp_record_t *sdp_record)
{
bdaddr_t src;
int err;
if (remove_record_from_server(handle) < 0) {
sdp_record_free(sdp_record);
return btd_error_not_available(msg);
}
if (serv_adapter->adapter)
adapter_get_address(serv_adapter->adapter, &src);
else
bacpy(&src, BDADDR_ANY);
sdp_record->handle = handle;
err = add_record_to_server(&src, sdp_record);
if (err < 0) {
sdp_record_free(sdp_record);
error("Failed to update the service record");
return btd_error_failed(msg, strerror(-err));
}
return dbus_message_new_method_return(msg);
}
gboolean hdp_update_sdp_record(struct hdp_adapter *adapter, GSList *app_list)
{
sdp_record_t *sdp_record;
bdaddr_t addr;
if (adapter->sdp_handler)
remove_record_from_server(adapter->sdp_handler);
if (!app_list) {
adapter->sdp_handler = 0;
return TRUE;
}
sdp_record = sdp_record_alloc();
if (!sdp_record)
return FALSE;
if (adapter->sdp_handler)
sdp_record->handle = adapter->sdp_handler;
else
sdp_record->handle = 0xffffffff; /* Set automatically */
if (is_app_role(app_list, HDP_SINK))
set_sdp_services_uuid(sdp_record, HDP_SINK);
if (is_app_role(app_list, HDP_SOURCE))
set_sdp_services_uuid(sdp_record, HDP_SOURCE);
if (!register_service_protocols(adapter, sdp_record))
goto fail;
if (!register_service_profiles(sdp_record))
goto fail;
if (!register_service_additional_protocols(adapter, sdp_record))
goto fail;
sdp_set_info_attr(sdp_record, HDP_SERVICE_NAME, HDP_SERVICE_PROVIDER,
HDP_SERVICE_DSC);
if (!register_service_sup_features(app_list, sdp_record))
goto fail;
if (!register_data_exchange_spec(sdp_record))
goto fail;
register_mcap_features(sdp_record);
if (sdp_set_record_state(sdp_record, adapter->record_state++))
goto fail;
adapter_get_address(adapter->btd_adapter, &addr);
if (add_record_to_server(&addr, sdp_record) < 0)
goto fail;
adapter->sdp_handler = sdp_record->handle;
return TRUE;
fail:
if (sdp_record)
sdp_record_free(sdp_record);
return FALSE;
}
void avrcp_exit(void)
{
if (!avctp_server)
return;
g_io_channel_close(avctp_server);
g_io_channel_unref(avctp_server);
avctp_server = NULL;
#ifndef ANDROID
remove_record_from_server(ct_record_id);
ct_record_id = 0;
#endif
remove_record_from_server(tg_record_id);
tg_record_id = 0;
dbus_connection_unref(connection);
connection = NULL;
}
void a2dp_exit()
{
g_slist_foreach(sinks, (GFunc) a2dp_unregister_sep, NULL);
g_slist_free(sinks);
sinks = NULL;
g_slist_foreach(sources, (GFunc) a2dp_unregister_sep, NULL);
g_slist_free(sources);
sources = NULL;
if (source_record_id) {
remove_record_from_server(source_record_id);
source_record_id = 0;
}
if (sink_record_id) {
remove_record_from_server(sink_record_id);
sink_record_id = 0;
}
dbus_connection_unref(connection);
}
static void server_disconnect(DBusConnection *conn, void *user_data)
{
struct network_server *ns = user_data;
ns->watch_id = 0;
if (ns->record_id) {
remove_record_from_server(ns->record_id);
ns->record_id = 0;
}
g_free(ns->bridge);
ns->bridge = NULL;
}
static void headset_server_remove(struct btd_adapter *adapter)
{
struct audio_adapter *adp;
const gchar *path = adapter_get_path(adapter);
DBG("path %s", path);
adp = find_adapter(adapters, adapter);
if (!adp)
return;
if (adp->hsp_ag_record_id) {
remove_record_from_server(adp->hsp_ag_record_id);
adp->hsp_ag_record_id = 0;
}
if (adp->hsp_ag_server) {
g_io_channel_shutdown(adp->hsp_ag_server, TRUE, NULL);
g_io_channel_unref(adp->hsp_ag_server);
adp->hsp_ag_server = NULL;
}
if (adp->hfp_ag_record_id) {
remove_record_from_server(adp->hfp_ag_record_id);
adp->hfp_ag_record_id = 0;
}
if (adp->hfp_ag_server) {
g_io_channel_shutdown(adp->hfp_ag_server, TRUE, NULL);
g_io_channel_unref(adp->hfp_ag_server);
adp->hfp_ag_server = NULL;
}
btd_adapter_unregister_powered_callback(adapter, state_changed);
audio_adapter_unref(adp);
}
static void server_free(struct network_server *ns)
{
if (!ns)
return;
/* FIXME: Missing release/free all bnepX interfaces */
if (ns->record_id)
remove_record_from_server(ns->record_id);
g_free(ns->iface);
g_free(ns->name);
g_free(ns->bridge);
g_slist_free_full(ns->sessions, session_free);
g_free(ns);
}
static void server_remove(struct sap_server *server)
{
if (!server)
return;
sap_server_remove_conn(server);
remove_record_from_server(server->record_id);
if (server->listen_io) {
g_io_channel_shutdown(server->listen_io, TRUE, NULL);
g_io_channel_unref(server->listen_io);
server->listen_io = NULL;
}
g_free(server->path);
g_free(server);
}
static void disable_proxy(struct serial_proxy *prx)
{
if (prx->rfcomm) {
g_io_channel_shutdown(prx->rfcomm, TRUE, NULL);
g_io_channel_unref(prx->rfcomm);
prx->rfcomm = NULL;
}
if (prx->local) {
g_io_channel_shutdown(prx->local, TRUE, NULL);
g_io_channel_unref(prx->local);
prx->local = NULL;
}
remove_record_from_server(prx->record_id);
prx->record_id = 0;
g_io_channel_unref(prx->io);
prx->io = NULL;
}
static DBusMessage *update_record(DBusMessage *msg,
struct service_adapter *serv_adapter,
dbus_uint32_t handle, sdp_record_t *sdp_record)
{
int err;
if (remove_record_from_server(handle) < 0) {
sdp_record_free(sdp_record);
return btd_error_not_available(msg);
}
sdp_record->handle = handle;
err = add_record_to_server(get_address(serv_adapter), sdp_record);
if (err < 0) {
sdp_record_free(sdp_record);
error("Failed to update the service record");
return btd_error_failed(msg, strerror(-err));
}
return dbus_message_new_method_return(msg);
}
int sap_server_unregister(const char *path)
{
if (!server)
return -EINVAL;
remove_record_from_server(server->record_id);
if (server->conn)
sap_conn_remove(server->conn);
if (server->listen_io) {
g_io_channel_shutdown(server->listen_io, TRUE, NULL);
g_io_channel_unref(server->listen_io);
server->listen_io = NULL;
}
g_dbus_unregister_interface(connection, path, SAP_SERVER_INTERFACE);
sap_exit();
return 0;
}
static void gateway_server_remove(struct btd_adapter *adapter)
{
struct audio_adapter *adp;
const gchar *path = adapter_get_path(adapter);
DBG("path %s", path);
adp = find_adapter(adapters, adapter);
if (!adp)
return;
if (adp->hfp_hs_record_id) {
remove_record_from_server(adp->hfp_hs_record_id);
adp->hfp_hs_record_id = 0;
}
if (adp->hfp_hs_server) {
g_io_channel_unref(adp->hfp_hs_server);
adp->hfp_hs_server = NULL;
}
audio_adapter_unref(adp);
}
static void exit_callback(DBusConnection *conn, void *user_data)
{
struct record_data *user_record = user_data;
struct service_adapter *serv_adapter = user_record->serv_adapter;
struct pending_auth *auth;
DBG("remove record");
serv_adapter->records = g_slist_remove(serv_adapter->records,
user_record);
auth = find_pending_by_sender(serv_adapter, user_record->sender);
if (auth) {
serv_adapter->pending_list = g_slist_remove(serv_adapter->pending_list,
auth);
g_free(auth);
}
remove_record_from_server(user_record->handle);
g_free(user_record->sender);
g_free(user_record);
}
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);
}
static void pnat_remove(struct btd_adapter *adapter)
{
struct dun_server *server;
GSList *match;
bdaddr_t src;
adapter_get_address(adapter, &src);
match = g_slist_find_custom(servers, &src, server_cmp);
if (match == NULL)
return;
server = match->data;
servers = g_slist_delete_link(servers, match);
disconnect(server);
remove_record_from_server(server->record_handle);
close(server->rfcomm_ctl);
g_io_channel_shutdown(server->server, TRUE, NULL);
g_io_channel_unref(server->server);
g_free(server);
}
int sap_server_register(const char *path, bdaddr_t *src)
{
sdp_record_t *record = NULL;
GError *gerr = NULL;
GIOChannel *io;
if (sap_init() < 0) {
error("Sap driver initialization failed.");
return -1;
}
server = g_try_new0(struct sap_server, 1);
if (!server) {
sap_exit();
return -ENOMEM;
}
server->path = g_strdup(path);
record = create_sap_record(SAP_SERVER_CHANNEL);
if (!record) {
error("Creating SAP SDP record failed.");
goto sdp_err;
}
if (add_record_to_server(src, record) < 0) {
error("Adding SAP SDP record to the SDP server failed.");
sdp_record_free(record);
goto sdp_err;
}
server->record_id = record->handle;
io = bt_io_listen(BT_IO_RFCOMM, NULL, connect_confirm_cb, server,
NULL, &gerr,
BT_IO_OPT_SOURCE_BDADDR, src,
BT_IO_OPT_CHANNEL, SAP_SERVER_CHANNEL,
BT_IO_OPT_SEC_LEVEL, BT_IO_SEC_HIGH,
BT_IO_OPT_MASTER, TRUE,
BT_IO_OPT_INVALID);
if (!io) {
error("Can't listen at channel %d.", SAP_SERVER_CHANNEL);
g_error_free(gerr);
goto server_err;
}
DBG("Listen socket 0x%02x", g_io_channel_unix_get_fd(io));
server->listen_io = io;
server->conn = NULL;
if (!g_dbus_register_interface(connection, path, SAP_SERVER_INTERFACE,
server_methods, server_signals, NULL,
server, destroy_sap_interface)) {
error("D-Bus failed to register %s interface",
SAP_SERVER_INTERFACE);
goto server_err;
}
return 0;
server_err:
remove_record_from_server(server->record_id);
sdp_err:
server_free(server);
sap_exit();
return -1;
}
gboolean mcap_update_sdp_record(struct mcap_adapter *adapter, GSList *app_list)
{ DBG("");
DBG("1");
sdp_record_t *sdp_record;
bdaddr_t addr;
if (adapter->sdp_handler)
remove_record_from_server(adapter->sdp_handler);
if (!app_list) {
adapter->sdp_handler = 0;
return TRUE;
}
DBG("3");
sdp_record = sdp_record_alloc();
if (!sdp_record)
return FALSE;
if (adapter->sdp_handler)
sdp_record->handle = adapter->sdp_handler;
else
sdp_record->handle = 0xffffffff;
DBG("4");
if (is_app_role(app_list, MCAP_SINK))
set_sdp_services_uuid(sdp_record, MCAP_SINK);
if (is_app_role(app_list, MCAP_SOURCE))
set_sdp_services_uuid(sdp_record, MCAP_SOURCE);
DBG("52");
if (!register_service_protocols(adapter, sdp_record))
DBG("eq");
if (!register_service_profiles(sdp_record))
DBG("e2");
if (!register_service_additional_protocols(adapter, sdp_record))
DBG("e3");
DBG("5");
sdp_set_info_attr(sdp_record, MCAP_SERVICE_NAME, MCAP_SERVICE_PROVIDER,
MCAP_SERVICE_DSC);
if (!register_service_sup_features(app_list, sdp_record))
DBG("e4");
if (!register_data_exchange_spec(sdp_record))
DBG("45");
DBG("6");
register_mcap_features(sdp_record);
if (sdp_set_record_state(sdp_record, adapter->record_state++))
DBG("5");
adapter_get_address(adapter->btd_adapter, &addr);
DBG("8");
if (add_record_to_server(&addr, sdp_record) < 0)
DBG("5");
DBG("7");
adapter->sdp_handler = sdp_record->handle;
return TRUE;
fail:
if (sdp_record)
sdp_record_free(sdp_record);
return TRUE;
}
int avrcp_register(DBusConnection *conn, const bdaddr_t *src, GKeyFile *config)
{
sdp_record_t *record;
gboolean tmp, master = TRUE;
GError *err = NULL;
struct avctp_server *server;
if (config) {
tmp = g_key_file_get_boolean(config, "General",
"Master", &err);
if (err) {
DBG("audio.conf: %s", err->message);
g_error_free(err);
} else
master = tmp;
err = NULL;
input_device_name = g_key_file_get_string(config,
"AVRCP", "InputDeviceName", &err);
if (err) {
DBG("audio.conf: %s", err->message);
input_device_name = NULL;
g_error_free(err);
}
}
server = g_new0(struct avctp_server, 1);
if (!server)
return -ENOMEM;
if (!connection)
connection = dbus_connection_ref(conn);
record = avrcp_tg_record();
if (!record) {
error("Unable to allocate new service record");
g_free(server);
return -1;
}
if (add_record_to_server(src, record) < 0) {
error("Unable to register AVRCP target service record");
g_free(server);
sdp_record_free(record);
return -1;
}
server->tg_record_id = record->handle;
#ifndef ANDROID
record = avrcp_ct_record();
if (!record) {
error("Unable to allocate new service record");
g_free(server);
return -1;
}
if (add_record_to_server(src, record) < 0) {
error("Unable to register AVRCP controller service record");
sdp_record_free(record);
g_free(server);
return -1;
}
server->ct_record_id = record->handle;
#endif
server->io = avctp_server_socket(src, master);
if (!server->io) {
#ifndef ANDROID
remove_record_from_server(server->ct_record_id);
#endif
remove_record_from_server(server->tg_record_id);
g_free(server);
return -1;
}
bacpy(&server->src, src);
servers = g_slist_append(servers, server);
return 0;
}
