int avctp_register(struct btd_adapter *adapter, gboolean master)
{
struct avctp_server *server;
const bdaddr_t *src = adapter_get_address(adapter);
server = g_new0(struct avctp_server, 1);
server->control_io = avctp_server_socket(src, master, L2CAP_MODE_BASIC,
AVCTP_CONTROL_PSM);
if (!server->control_io) {
g_free(server);
return -1;
}
server->browsing_io = avctp_server_socket(src, master, L2CAP_MODE_ERTM,
AVCTP_BROWSING_PSM);
if (!server->browsing_io) {
if (server->control_io) {
g_io_channel_shutdown(server->control_io, TRUE, NULL);
g_io_channel_unref(server->control_io);
server->control_io = NULL;
}
g_free(server);
return -1;
}
server->adapter = btd_adapter_ref(adapter);
servers = g_slist_append(servers, server);
return 0;
}
static int gatt_example_adapter_probe(struct btd_adapter *adapter)
{
uint16_t manuf1_range[2] = {0, 0}, manuf2_range[2] = {0, 0};
uint16_t vendor_range[2] = {0, 0};
struct gatt_example_adapter *gadapter;
gadapter = g_new0(struct gatt_example_adapter, 1);
gadapter->adapter = btd_adapter_ref(adapter);
if (!register_battery_service(adapter)) {
DBG("Battery service could not be registered");
gatt_example_adapter_free(gadapter);
return -EIO;
}
register_manuf1_service(gadapter, manuf1_range);
register_manuf2_service(gadapter, manuf2_range);
register_termometer_service(gadapter, manuf1_range, manuf2_range);
register_vendor_service(gadapter, vendor_range);
register_weight_service(gadapter, vendor_range);
adapters = g_slist_append(adapters, gadapter);
return 0;
}
static struct network_adapter *create_adapter(struct btd_adapter *adapter)
{
struct network_adapter *na;
GError *err = NULL;
bdaddr_t src;
na = g_new0(struct network_adapter, 1);
na->adapter = btd_adapter_ref(adapter);
adapter_get_address(adapter, &src);
na->io = bt_io_listen(BT_IO_L2CAP, NULL, confirm_event, na,
NULL, &err,
BT_IO_OPT_SOURCE_BDADDR, &src,
BT_IO_OPT_PSM, BNEP_PSM,
BT_IO_OPT_OMTU, BNEP_MTU,
BT_IO_OPT_IMTU, BNEP_MTU,
BT_IO_OPT_SEC_LEVEL,
security ? BT_IO_SEC_MEDIUM : BT_IO_SEC_LOW,
BT_IO_OPT_INVALID);
if (!na->io) {
error("%s", err->message);
g_error_free(err);
adapter_free(na);
return NULL;
}
return na;
}
int proxy_register(DBusConnection *conn, struct btd_adapter *btd_adapter)
{
struct serial_adapter *adapter;
const char *path;
adapter = find_adapter(adapters, btd_adapter);
if (adapter)
return -EINVAL;
adapter = g_new0(struct serial_adapter, 1);
adapter->conn = dbus_connection_ref(conn);
adapter->btd_adapter = btd_adapter_ref(btd_adapter);
path = adapter_get_path(btd_adapter);
if (!g_dbus_register_interface(conn, path,
SERIAL_MANAGER_INTERFACE,
manager_methods, manager_signals, NULL,
adapter, manager_path_unregister)) {
error("Failed to register %s interface to %s",
SERIAL_MANAGER_INTERFACE, path);
return -1;
}
register_stored(adapter);
adapters = g_slist_append(adapters, adapter);
debug("Registered interface %s on path %s",
SERIAL_MANAGER_INTERFACE, path);
return 0;
}
static int register_interface(const char *path, struct btd_adapter *adapter)
{
struct service_adapter *serv_adapter;
DBG("path %s", path);
serv_adapter = g_try_new0(struct service_adapter, 1);
if (serv_adapter == NULL)
return -ENOMEM;
if (adapter != NULL)
serv_adapter->adapter = btd_adapter_ref(adapter);
serv_adapter->pending_list = NULL;
if (g_dbus_register_interface(btd_get_dbus_connection(),
path, SERVICE_INTERFACE,
service_methods, NULL, NULL, serv_adapter,
path_unregister) == FALSE) {
error("D-Bus failed to register %s interface",
SERVICE_INTERFACE);
g_free(serv_adapter);
return -EIO;
}
DBG("Registered interface %s on path %s", SERVICE_INTERFACE, path);
if (serv_adapter->adapter == NULL)
serv_adapter_any = serv_adapter;
return 0;
}
static struct audio_adapter *audio_adapter_create(struct btd_adapter *adapter)
{
struct audio_adapter *adp;
adp = g_new0(struct audio_adapter, 1);
adp->btd_adapter = btd_adapter_ref(adapter);
return audio_adapter_ref(adp);
}
static int hid_server_probe(struct btd_profile *p, struct btd_adapter *adapter)
{
int ret;
ret = server_start(adapter_get_address(adapter));
if (ret < 0)
return ret;
adapters = g_slist_append(adapters, btd_adapter_ref(adapter));
return 0;
}
static int alert_server_probe(struct btd_profile *p,
struct btd_adapter *adapter)
{
struct alert_adapter *al_adapter;
al_adapter = g_new0(struct alert_adapter, 1);
al_adapter->adapter = btd_adapter_ref(adapter);
alert_adapters = g_slist_append(alert_adapters, al_adapter);
register_phone_alert_service(al_adapter);
register_alert_notif_service(al_adapter);
return 0;
}
static int hid_server_probe(struct btd_adapter *adapter)
{
bdaddr_t src;
int ret;
adapter_get_address(adapter, &src);
ret = server_start(&src);
if (ret < 0)
return ret;
adapters = g_slist_append(adapters, btd_adapter_ref(adapter));
return 0;
}
struct btd_adapter *btd_manager_register_adapter(int id, gboolean up)
{
struct btd_adapter *adapter;
const char *path;
adapter = manager_find_adapter_by_id(id);
if (adapter) {
error("Unable to register adapter: hci%d already exist", id);
return NULL;
}
adapter = adapter_create(connection, id);
if (!adapter)
return NULL;
adapters = g_slist_append(adapters, adapter);
if (!adapter_init(adapter, up)) {
adapters = g_slist_remove(adapters, adapter);
btd_adapter_unref(adapter);
return NULL;
}
path = adapter_get_path(adapter);
g_dbus_emit_signal(connection, "/",
MANAGER_INTERFACE, "AdapterAdded",
DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID);
manager_update_adapters();
btd_stop_exit_timer();
if (default_adapter_id < 0)
manager_set_default_adapter(id);
if (main_opts.did_source)
btd_adapter_set_did(adapter, main_opts.did_vendor,
main_opts.did_product,
main_opts.did_version,
main_opts.did_source);
DBG("Adapter %s registered", path);
return btd_adapter_ref(adapter);
}
static int ext_start_servers(struct ext_profile *ext,
struct btd_adapter *adapter)
{
struct ext_io *server;
BtIOConfirm confirm;
BtIOConnect connect;
GError *err = NULL;
uint16_t handle;
GIOChannel *io;
handle = ext_register_record(ext, adapter_get_address(adapter));
if (ext->authorize) {
confirm = ext_confirm;
connect = NULL;
} else {
confirm = NULL;
connect = ext_direct_connect;
}
if (ext->psm) {
server = g_new0(struct ext_io, 1);
server->ext = ext;
server->rec_handle = handle;
io = bt_io_listen(connect, confirm, server, NULL, &err,
BT_IO_OPT_SOURCE_BDADDR,
adapter_get_address(adapter),
BT_IO_OPT_PSM, ext->psm,
BT_IO_OPT_SEC_LEVEL, ext->sec_level,
BT_IO_OPT_INVALID);
if (err != NULL) {
error("L2CAP server failed for %s: %s",
ext->name, err->message);
g_free(server);
g_clear_error(&err);
} else {
server->io = io;
server->proto = BTPROTO_L2CAP;
server->adapter = btd_adapter_ref(adapter);
ext->servers = g_slist_append(ext->servers, server);
DBG("%s listening on PSM %u", ext->name, ext->psm);
}
}
int media_register(struct btd_adapter *btd_adapter)
{
struct media_adapter *adapter;
adapter = g_new0(struct media_adapter, 1);
adapter->btd_adapter = btd_adapter_ref(btd_adapter);
if (!g_dbus_register_interface(btd_get_dbus_connection(),
adapter_get_path(btd_adapter),
MEDIA_INTERFACE,
media_methods, NULL, NULL,
adapter, path_free)) {
error("D-Bus failed to register %s path",
adapter_get_path(btd_adapter));
path_free(adapter);
return -1;
}
adapters = g_slist_append(adapters, adapter);
return 0;
}
int sap_server_register(struct btd_adapter *adapter)
{
sdp_record_t *record = NULL;
GError *gerr = NULL;
GIOChannel *io;
struct sap_server *server;
if (sap_init() < 0) {
error("Sap driver initialization failed.");
return -1;
}
record = create_sap_record(SAP_SERVER_CHANNEL);
if (!record) {
error("Creating SAP SDP record failed.");
goto sdp_err;
}
if (adapter_service_add(adapter, record) < 0) {
error("Adding SAP SDP record to the SDP server failed.");
sdp_record_free(record);
goto sdp_err;
}
server = g_new0(struct sap_server, 1);
server->adapter = btd_adapter_ref(adapter);
server->record_id = record->handle;
io = bt_io_listen(NULL, connect_confirm_cb, server,
NULL, &gerr,
BT_IO_OPT_SOURCE_BDADDR,
btd_adapter_get_address(adapter),
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;
}
server->listen_io = io;
if (!g_dbus_register_interface(btd_get_dbus_connection(),
adapter_get_path(server->adapter),
SAP_SERVER_INTERFACE,
server_methods, NULL,
server_properties, server,
destroy_sap_interface)) {
error("D-Bus failed to register %s interface",
SAP_SERVER_INTERFACE);
goto server_err;
}
DBG("server %p, listen socket 0x%02x", server,
g_io_channel_unix_get_fd(io));
return 0;
server_err:
server_remove(server);
sdp_err:
sap_exit();
return -1;
}
