static struct network_peer *create_peer(struct btd_device *device)
{
struct network_peer *peer;
const char *path;
peer = g_new0(struct network_peer, 1);
peer->device = btd_device_ref(device);
path = device_get_path(device);
if (g_dbus_register_interface(btd_get_dbus_connection(), path,
NETWORK_PEER_INTERFACE,
connection_methods,
NULL, connection_properties,
peer, path_unregister) == FALSE) {
error("D-Bus failed to register %s interface",
NETWORK_PEER_INTERFACE);
peer_free(peer);
return NULL;
}
DBG("Registered interface %s on path %s",
NETWORK_PEER_INTERFACE, path);
return peer;
}
static struct input_device *input_device_new(DBusConnection *conn,
struct btd_device *device, const char *path,
const bdaddr_t *src, const bdaddr_t *dst,
const uint32_t handle)
{
struct input_device *idev;
char name[249], src_addr[18], dst_addr[18];
idev = g_new0(struct input_device, 1);
bacpy(&idev->src, src);
bacpy(&idev->dst, dst);
idev->device = btd_device_ref(device);
idev->path = g_strdup(path);
idev->conn = dbus_connection_ref(conn);
idev->handle = handle;
ba2str(src, src_addr);
ba2str(dst, dst_addr);
if (read_device_name(src_addr, dst_addr, name) == 0)
idev->name = g_strdup(name);
if (g_dbus_register_interface(conn, idev->path, INPUT_DEVICE_INTERFACE,
device_methods, device_signals, NULL,
idev, device_unregister) == FALSE) {
error("Failed to register interface %s on path %s",
INPUT_DEVICE_INTERFACE, path);
input_device_free(idev);
return NULL;
}
debug("Registered interface %s on path %s",
INPUT_DEVICE_INTERFACE, idev->path);
return idev;
}
static struct monitor *register_monitor(struct btd_device *device)
{
const char *path = device_get_path(device);
struct monitor *monitor;
char *level;
monitor = find_monitor(device);
if (monitor != NULL)
return monitor;
level = read_proximity_config(device, "LinkLossAlertLevel");
monitor = g_new0(struct monitor, 1);
monitor->device = btd_device_ref(device);
monitor->linklosslevel = (level ? : g_strdup("high"));
monitor->signallevel = g_strdup("unknown");
monitor->immediatelevel = g_strdup("none");
monitors = g_slist_append(monitors, monitor);
if (g_dbus_register_interface(btd_get_dbus_connection(), path,
PROXIMITY_INTERFACE,
NULL, NULL, monitor_device_properties,
monitor, monitor_destroy) == FALSE) {
error("D-Bus failed to register %s interface",
PROXIMITY_INTERFACE);
monitor_destroy(monitor);
return NULL;
}
DBG("Registered interface %s on path %s", PROXIMITY_INTERFACE, path);
return monitor;
}
static struct network_peer *create_peer(struct btd_device *device,
const char *path, bdaddr_t *src,
bdaddr_t *dst)
{
struct network_peer *peer;
peer = g_new0(struct network_peer, 1);
peer->device = btd_device_ref(device);
peer->path = g_strdup(path);
bacpy(&peer->src, src);
bacpy(&peer->dst, dst);
if (g_dbus_register_interface(connection, path,
NETWORK_PEER_INTERFACE,
connection_methods,
connection_signals, NULL,
peer, path_unregister) == FALSE) {
error("D-Bus failed to register %s interface",
NETWORK_PEER_INTERFACE);
peer_free(peer);
return NULL;
}
DBG("Registered interface %s on path %s",
NETWORK_PEER_INTERFACE, path);
return peer;
}
static int gap_driver_probe(struct btd_service *service)
{
struct btd_device *device = btd_service_get_device(service);
struct gas *gas;
GSList *l;
char addr[18];
ba2str(device_get_address(device), addr);
DBG("GAP profile probe (%s)", addr);
/* Ignore, if we were probed for this device already */
l = g_slist_find_custom(devices, device, cmp_device);
if (l) {
error("Profile probed twice for the same device!");
return -1;
}
gas = g_new0(struct gas, 1);
if (!gas)
return -1;
gas->device = btd_device_ref(device);
devices = g_slist_append(devices, gas);
return 0;
}
static void register_devstate_cleanup_cb(struct alert_adapter *aa,
struct btd_device *device)
{
if (!aa->device) {
aa->device = btd_device_ref(device);
aa->id = btd_device_add_attio_callback(aa->device, NULL,
devstate_cleanup_cb, aa);
}
}
static void register_reporter_device(struct btd_device *device,
struct reporter_adapter *radapter)
{
const char *path = device_get_path(device);
DBG("register on device %s", path);
g_dbus_register_interface(radapter->conn, path,
PROXIMITY_REPORTER_INTERFACE,
reporter_methods, reporter_signals,
NULL, device, NULL);
btd_device_ref(device);
radapter->devices = g_slist_prepend(radapter->devices, device);
}
static void register_reporter_device(struct btd_device *device,
struct reporter_adapter *radapter)
{
const char *path = device_get_path(device);
DBG("register on device %s", path);
g_dbus_register_interface(btd_get_dbus_connection(), path,
PROXIMITY_REPORTER_INTERFACE,
NULL, NULL, reporter_device_properties,
device, NULL);
btd_device_ref(device);
radapter->devices = g_slist_prepend(radapter->devices, device);
}
struct audio_device *audio_device_register(DBusConnection *conn,
struct btd_device *device,
const char *path, const bdaddr_t *src,
const bdaddr_t *dst)
{
struct audio_device *dev;
if (!conn || !path)
return NULL;
dev = g_new0(struct audio_device, 1);
dev->btd_dev = btd_device_ref(device);
dev->path = g_strdup(path);
bacpy(&dev->dst, dst);
bacpy(&dev->src, src);
dev->conn = dbus_connection_ref(conn);
dev->priv = g_new0(struct dev_priv, 1);
dev->priv->state = AUDIO_STATE_DISCONNECTED;
if (!g_dbus_register_interface(dev->conn, dev->path,
AUDIO_INTERFACE,
dev_methods, dev_signals, NULL,
dev, NULL)) {
error("Unable to register %s on %s", AUDIO_INTERFACE,
dev->path);
device_free(dev);
return NULL;
}
DBG("Registered interface %s on path %s", AUDIO_INTERFACE,
dev->path);
if (sink_callback_id == 0)
sink_callback_id = sink_add_state_cb(device_sink_cb, NULL);
if (avdtp_callback_id == 0)
avdtp_callback_id = avdtp_add_state_cb(device_avdtp_cb, NULL);
if (avctp_callback_id == 0)
avctp_callback_id = avctp_add_state_cb(device_avctp_cb, NULL);
if (headset_callback_id == 0)
headset_callback_id = headset_add_state_cb(device_headset_cb,
NULL);
dev->uinput = -1;
return dev;
}
static void filter_devices_notify(struct btd_device *device, void *user_data)
{
struct notify_data *notify_data = user_data;
struct alert_adapter *al_adapter = notify_data->al_adapter;
enum notify_type type = notify_data->type;
struct notify_callback *cb;
if (!is_notifiable_device(device, al_adapter->hnd_ccc[type]))
return;
cb = g_new0(struct notify_callback, 1);
cb->notify_data = notify_data;
cb->device = btd_device_ref(device);
cb->id = btd_device_add_attio_callback(device,
attio_connected_cb, NULL, cb);
}
int deviceinfo_register(struct btd_device *device, struct gatt_primary *prim)
{
struct deviceinfo *d;
d = g_new0(struct deviceinfo, 1);
d->dev = btd_device_ref(device);
d->svc_range = g_new0(struct att_range, 1);
d->svc_range->start = prim->range.start;
d->svc_range->end = prim->range.end;
servers = g_slist_prepend(servers, d);
d->attioid = btd_device_add_attio_callback(device, attio_connected_cb,
attio_disconnected_cb, d);
return 0;
}
static int scan_register(struct btd_service *service, struct gatt_primary *prim)
{
struct btd_device *device = btd_service_get_device(service);
struct scan *scan;
scan = g_new0(struct scan, 1);
scan->device = btd_device_ref(device);
scan->range = prim->range;
scan->attioid = btd_device_add_attio_callback(device,
attio_connected_cb,
attio_disconnected_cb,
scan);
btd_service_set_user_data(service, scan);
return 0;
}
static int csc_device_probe(struct btd_service *service)
{
struct btd_device *device = btd_service_get_device(service);
struct btd_adapter *adapter;
struct csc_adapter *cadapter;
struct csc *csc;
struct gatt_primary *prim;
prim = btd_device_get_primary(device, CYCLING_SC_UUID);
if (prim == NULL)
return -EINVAL;
adapter = device_get_adapter(device);
cadapter = find_csc_adapter(adapter);
if (cadapter == NULL)
return -1;
csc = g_new0(struct csc, 1);
csc->dev = btd_device_ref(device);
csc->cadapter = cadapter;
if (!g_dbus_register_interface(btd_get_dbus_connection(),
device_get_path(device),
CYCLINGSPEED_INTERFACE,
cyclingspeed_device_methods,
NULL,
cyclingspeed_device_properties,
csc, destroy_csc)) {
error("D-Bus failed to register %s interface",
CYCLINGSPEED_INTERFACE);
destroy_csc(csc);
return -EIO;
}
csc->svc_range = g_new0(struct att_range, 1);
csc->svc_range->start = prim->range.start;
csc->svc_range->end = prim->range.end;
cadapter->devices = g_slist_prepend(cadapter->devices, csc);
csc->attioid = btd_device_add_attio_callback(device, attio_connected_cb,
attio_disconnected_cb, csc);
return 0;
}
static int deviceinfo_register(struct btd_service *service,
struct gatt_primary *prim)
{
struct btd_device *device = btd_service_get_device(service);
struct deviceinfo *d;
d = g_new0(struct deviceinfo, 1);
d->dev = btd_device_ref(device);
d->svc_range = g_new0(struct att_range, 1);
d->svc_range->start = prim->range.start;
d->svc_range->end = prim->range.end;
btd_service_set_user_data(service, d);
d->attioid = btd_device_add_attio_callback(device, attio_connected_cb,
attio_disconnected_cb, d);
return 0;
}
static int heartrate_device_register(struct btd_device *device,
struct gatt_primary *prim)
{
struct btd_adapter *adapter;
struct heartrate_adapter *hradapter;
struct heartrate *hr;
adapter = device_get_adapter(device);
hradapter = find_heartrate_adapter(adapter);
if (hradapter == NULL)
return -1;
hr = g_new0(struct heartrate, 1);
hr->dev = btd_device_ref(device);
hr->hradapter = hradapter;
if (!g_dbus_register_interface(btd_get_dbus_connection(),
device_get_path(device),
HEART_RATE_INTERFACE,
heartrate_device_methods,
NULL,
heartrate_device_properties,
hr, destroy_heartrate)) {
error("D-Bus failed to register %s interface",
HEART_RATE_INTERFACE);
destroy_heartrate(hr);
return -EIO;
}
hr->svc_range = g_new0(struct att_range, 1);
hr->svc_range->start = prim->range.start;
hr->svc_range->end = prim->range.end;
hradapter->devices = g_slist_prepend(hradapter->devices, hr);
hr->attioid = btd_device_add_attio_callback(device, attio_connected_cb,
attio_disconnected_cb, hr);
return 0;
}
int monitor_register(DBusConnection *conn, struct btd_device *device,
struct att_primary *linkloss, struct att_primary *txpower,
struct att_primary *immediate, struct enabled *enabled)
{
const char *path = device_get_path(device);
struct monitor *monitor;
bdaddr_t sba, dba;
char *level;
adapter_get_address(device_get_adapter(device), &sba);
device_get_address(device, &dba);
level = read_proximity_config(&sba, &dba, "LinkLossAlertLevel");
monitor = g_new0(struct monitor, 1);
monitor->device = btd_device_ref(device);
monitor->conn = dbus_connection_ref(conn);
monitor->linklosslevel = (level ? : g_strdup("high"));
monitor->signallevel = g_strdup("unknown");
monitor->immediatelevel = g_strdup("none");
if (g_dbus_register_interface(conn, path,
PROXIMITY_INTERFACE,
monitor_methods, monitor_signals,
NULL, monitor, monitor_destroy) == FALSE) {
error("D-Bus failed to register %s interface",
PROXIMITY_INTERFACE);
monitor_destroy(monitor);
return -1;
}
DBG("Registered interface %s on path %s", PROXIMITY_INTERFACE, path);
if (linkloss && enabled->linkloss) {
monitor->linkloss = g_new0(struct att_range, 1);
monitor->linkloss->start = linkloss->start;
monitor->linkloss->end = linkloss->end;
monitor->enabled.linkloss = TRUE;
}
struct audio_device *audio_device_register(struct btd_device *device)
{
struct audio_device *dev;
DBG("%s", device_get_path(device));
dev = g_new0(struct audio_device, 1);
dev->btd_dev = btd_device_ref(device);
dev->priv = g_new0(struct dev_priv, 1);
dev->priv->state = AUDIO_STATE_DISCONNECTED;
if (sink_callback_id == 0)
sink_callback_id = sink_add_state_cb(device_sink_cb, NULL);
if (avdtp_callback_id == 0)
avdtp_callback_id = avdtp_add_state_cb(device_avdtp_cb, NULL);
if (avctp_callback_id == 0)
avctp_callback_id = avctp_add_state_cb(device_avctp_cb, NULL);
return dev;
}
static struct hog_device *hog_device_new(struct btd_device *device,
struct gatt_primary *prim)
{
struct hog_device *dev;
char name[248];
uint16_t vendor, product, version;
if (device_name_known(device))
device_get_name(device, name, sizeof(name));
else
strcpy(name, "bluez-hog-device");
vendor = btd_device_get_vendor(device);
product = btd_device_get_product(device);
version = btd_device_get_version(device);
DBG("name=%s vendor=0x%X, product=0x%X, version=0x%X", name, vendor,
product, version);
dev = new0(struct hog_device, 1);
dev->device = btd_device_ref(device);
dev->hog = bt_hog_new_default(name, vendor, product, version, prim);
/*
* TODO: Remove attio callback and use .accept once using
* bt_gatt_client.
*/
dev->attioid = btd_device_add_attio_callback(device,
attio_connected_cb,
attio_disconnected_cb,
dev);
if (!devices)
devices = queue_new();
queue_push_tail(devices, dev);
return dev;
}
static struct input_device *input_device_new(DBusConnection *conn,
struct btd_device *device, const char *path,
const uint32_t handle, gboolean disable_sdp)
{
struct btd_adapter *adapter = device_get_adapter(device);
struct input_device *idev;
char name[249], src_addr[18], dst_addr[18];
DBG("path %s", path);
idev = g_new0(struct input_device, 1);
adapter_get_address(adapter, &idev->src);
device_get_address(device, &idev->dst, NULL);
idev->device = btd_device_ref(device);
idev->path = g_strdup(path);
idev->conn = dbus_connection_ref(conn);
idev->handle = handle;
idev->disable_sdp = disable_sdp;
ba2str(&idev->src, src_addr);
ba2str(&idev->dst, dst_addr);
if (read_device_name(src_addr, dst_addr, name) == 0)
idev->name = g_strdup(name);
if (g_dbus_register_interface(conn, idev->path, INPUT_DEVICE_INTERFACE,
device_methods, device_signals, NULL,
idev, device_unregister) == FALSE) {
error("Failed to register interface %s on path %s",
INPUT_DEVICE_INTERFACE, path);
input_device_free(idev);
return NULL;
}
DBG("Registered interface %s on path %s",
INPUT_DEVICE_INTERFACE, idev->path);
return idev;
}
static struct btd_device *get_notifiable_device(struct btd_adapter *adapter,
char *key, char *value,
uint16_t ccc)
{
struct btd_device *device;
char addr[18];
uint16_t hnd, val;
uint8_t bdaddr_type;
sscanf(key, "%17s#%hhu#%04hX", addr, &bdaddr_type, &hnd);
if (hnd != ccc)
return NULL;
val = strtol(value, NULL, 16);
if (!(val & 0x0001))
return NULL;
device = adapter_find_device(adapter, addr);
if (device == NULL)
return NULL;
return btd_device_ref(device);
}
static struct avctp *avctp_get_internal(struct btd_device *device)
{
struct avctp_server *server;
struct avctp *session;
server = find_server(servers, device_get_adapter(device));
if (server == NULL)
return NULL;
session = find_session(server->sessions, device);
if (session)
return session;
session = g_new0(struct avctp, 1);
session->server = server;
session->device = btd_device_ref(device);
session->state = AVCTP_STATE_DISCONNECTED;
session->uinput = -1;
server->sessions = g_slist_append(server->sessions, session);
return session;
}
static uint8_t link_loss_alert_lvl_write(struct attribute *a,
gpointer user_data, struct btd_device *device)
{
uint8_t value;
struct link_loss_adapter *adapter = user_data;
GSList *l = NULL;
struct connected_device *condev = NULL;
if (device) {
l = g_slist_find_custom(adapter->connected_devices, device,
lldevice_cmp);
if (l)
condev = l->data;
}
if (a->len == 0) {
DBG("Illegal alert level len");
goto set_error;
}
value = a->data[0];
if (value != NO_ALERT && value != MILD_ALERT && value != HIGH_ALERT) {
DBG("Illegal alert value");
goto set_error;
}
/* Register a disconnect cb if the alert level is non-zero */
if (value != NO_ALERT && device && !condev) {
condev = g_new0(struct connected_device, 1);
condev->device = btd_device_ref(device);
condev->adapter = adapter;
condev->callback_id = btd_device_add_attio_callback(device,
NULL, link_loss_disc_cb, condev);
adapter->connected_devices = g_slist_append(
adapter->connected_devices, condev);
} else if (value == NO_ALERT && condev) {
static int gap_probe(struct btd_service *service)
{
struct btd_device *device = btd_service_get_device(service);
struct gas *gas = btd_service_get_user_data(service);
char addr[18];
ba2str(device_get_address(device), addr);
DBG("GAP profile probe (%s)", addr);
/* Ignore, if we were probed for this device already */
if (gas) {
error("Profile probed twice for the same device!");
return -1;
}
gas = g_new0(struct gas, 1);
if (!gas)
return -1;
gas->device = btd_device_ref(device);
btd_service_set_user_data(service, gas);
return 0;
}
