int bt_uuid_cmp(const bt_uuid_t *uuid1, const bt_uuid_t *uuid2)
{
bt_uuid_t u1, u2;
bt_uuid_to_uuid128(uuid1, &u1);
bt_uuid_to_uuid128(uuid2, &u2);
return bt_uuid128_cmp(&u1, &u2);
}
static struct descriptor *descriptor_create(struct gatt_db_attribute *attr,
struct characteristic *chrc)
{
struct descriptor *desc;
desc = new0(struct descriptor, 1);
desc->chrc = chrc;
desc->attr = attr;
desc->handle = gatt_db_attribute_get_handle(attr);
bt_uuid_to_uuid128(gatt_db_attribute_get_type(attr), &desc->uuid);
desc->path = g_strdup_printf("%s/desc%04x", chrc->path, desc->handle);
if (!g_dbus_register_interface(btd_get_dbus_connection(), desc->path,
GATT_DESCRIPTOR_IFACE,
descriptor_methods, NULL,
descriptor_properties,
desc, descriptor_free)) {
error("Unable to register GATT descriptor with handle 0x%04x",
desc->handle);
descriptor_free(desc);
return NULL;
}
DBG("Exported GATT characteristic descriptor: %s", desc->path);
if (uuid_cmp(&desc->uuid, GATT_CHARAC_EXT_PROPER_UUID))
chrc->ext_props_handle = desc->handle;
return desc;
}
static struct service *service_create(struct gatt_db_attribute *attr,
struct btd_gatt_client *client)
{
struct service *service;
const char *device_path = device_get_path(client->device);
bt_uuid_t uuid;
service = new0(struct service, 1);
if (!service)
return NULL;
service->chrcs = queue_new();
if (!service->chrcs) {
free(service);
return NULL;
}
service->pending_ext_props = queue_new();
if (!service->pending_ext_props) {
queue_destroy(service->chrcs, NULL);
free(service);
return NULL;
}
service->client = client;
gatt_db_attribute_get_service_data(attr, &service->start_handle,
&service->end_handle,
&service->primary,
&uuid);
bt_uuid_to_uuid128(&uuid, &service->uuid);
service->path = g_strdup_printf("%s/service%04x", device_path,
service->start_handle);
if (!g_dbus_register_interface(btd_get_dbus_connection(), service->path,
GATT_SERVICE_IFACE,
NULL, NULL,
service_properties,
service, service_free)) {
error("Unable to register GATT service with handle 0x%04x for "
"device %s",
service->start_handle,
client->devaddr);
service_free(service);
return NULL;
}
DBG("Exported GATT service: %s", service->path);
/* Set service active so we can skip discovering next time */
gatt_db_service_set_active(attr, true);
/* Mark the service as claimed since it going to be exported */
gatt_db_service_set_claimed(attr, true);
return service;
}
static struct characteristic *characteristic_create(
struct gatt_db_attribute *attr,
struct service *service)
{
struct characteristic *chrc;
bt_uuid_t uuid;
chrc = new0(struct characteristic, 1);
if (!chrc)
return NULL;
chrc->descs = queue_new();
if (!chrc->descs) {
free(chrc);
return NULL;
}
chrc->notify_clients = queue_new();
if (!chrc->notify_clients) {
queue_destroy(chrc->descs, NULL);
free(chrc);
return NULL;
}
chrc->service = service;
gatt_db_attribute_get_char_data(attr, &chrc->handle,
&chrc->value_handle,
&chrc->props, &uuid);
chrc->attr = gatt_db_get_attribute(service->client->db,
chrc->value_handle);
if (!chrc->attr) {
error("Attribute 0x%04x not found", chrc->value_handle);
characteristic_free(chrc);
return NULL;
}
bt_uuid_to_uuid128(&uuid, &chrc->uuid);
chrc->path = g_strdup_printf("%s/char%04x", service->path,
chrc->handle);
if (!g_dbus_register_interface(btd_get_dbus_connection(), chrc->path,
GATT_CHARACTERISTIC_IFACE,
characteristic_methods, NULL,
characteristic_properties,
chrc, characteristic_free)) {
error("Unable to register GATT characteristic with handle "
"0x%04x", chrc->handle);
characteristic_free(chrc);
return NULL;
}
DBG("Exported GATT characteristic: %s", chrc->path);
return chrc;
}
static void print_uuid(const bt_uuid_t *uuid)
{
char uuid_str[MAX_LEN_UUID_STR];
bt_uuid_t uuid128;
bt_uuid_to_uuid128(uuid, &uuid128);
bt_uuid_to_string(&uuid128, uuid_str, sizeof(uuid_str));
printf("%s\n", uuid_str);
}
static int uuid_to_le(const bt_uuid_t *uuid, uint8_t *dst)
{
bt_uuid_t uuid128;
if (uuid->type == BT_UUID16) {
put_le16(uuid->value.u16, dst);
return bt_uuid_len(uuid);
}
bt_uuid_to_uuid128(uuid, &uuid128);
bswap_128(&uuid128.value.u128, dst);
return bt_uuid_len(&uuid128);
}
static void cmd_services(struct client *cli, char *cmd_str)
{
char *argv[3];
int argc = 0;
if (!bt_gatt_client_is_ready(cli->gatt)) {
printf("GATT client not initialized\n");
return;
}
if (!parse_args(cmd_str, 2, argv, &argc)) {
services_usage();
return;
}
if (!argc) {
print_services(cli);
return;
}
if (argc != 2) {
services_usage();
return;
}
if (!strcmp(argv[0], "-u") || !strcmp(argv[0], "--uuid")) {
bt_uuid_t tmp, uuid;
if (bt_string_to_uuid(&tmp, argv[1]) < 0) {
printf("Invalid UUID: %s\n", argv[1]);
return;
}
bt_uuid_to_uuid128(&tmp, &uuid);
print_services_by_uuid(cli, &uuid);
} else if (!strcmp(argv[0], "-a") || !strcmp(argv[0], "--handle")) {
uint16_t handle;
char *endptr = NULL;
handle = strtol(argv[1], &endptr, 16);
if (!endptr || *endptr != '\0') {
printf("Invalid start handle: %s\n", argv[1]);
return;
}
print_services_by_handle(cli, handle);
} else
services_usage();
}
static void get_uuid128(uint8_t type, const void *val, bt_uuid_t *uuid)
{
if (type == BT_UUID16) {
bt_uuid_t uuid16;
bt_uuid16_create(&uuid16, get_le16(val));
bt_uuid_to_uuid128(&uuid16, uuid);
} else {
uint128_t u128;
/* Convert from 128-bit LE to BE */
bswap_128(val, &u128);
bt_uuid128_create(uuid, u128);
}
}
static struct gatt_included *included_from_buf(const uint8_t *buf, gsize len)
{
struct gatt_included *incl = g_new0(struct gatt_included, 1);
incl->handle = att_get_u16(&buf[0]);
incl->range.start = att_get_u16(&buf[2]);
incl->range.end = att_get_u16(&buf[4]);
if (len == 8) {
bt_uuid_t uuid128;
bt_uuid_t uuid16 = att_get_uuid16(&buf[6]);
bt_uuid_to_uuid128(&uuid16, &uuid128);
bt_uuid_to_string(&uuid128, incl->uuid, sizeof(incl->uuid));
}
return incl;
}
static void char_discovered_cb(guint8 status, const guint8 *ipdu, guint16 iplen,
gpointer user_data)
{
struct discover_char *dc = user_data;
struct att_data_list *list;
unsigned int i, err = ATT_ECODE_ATTR_NOT_FOUND;
uint16_t last = 0;
if (status) {
err = status;
goto done;
}
list = dec_read_by_type_resp(ipdu, iplen);
if (list == NULL) {
err = ATT_ECODE_IO;
goto done;
}
for (i = 0; i < list->num; i++) {
uint8_t *value = list->data[i];
struct gatt_char *chars;
bt_uuid_t uuid;
last = att_get_u16(value);
if (list->len == 7) {
bt_uuid_t uuid16 = att_get_uuid16(&value[5]);
bt_uuid_to_uuid128(&uuid16, &uuid);
} else
uuid = att_get_uuid128(&value[5]);
if (dc->uuid && bt_uuid_cmp(dc->uuid, &uuid))
continue;
chars = g_try_new0(struct gatt_char, 1);
if (!chars) {
err = ATT_ECODE_INSUFF_RESOURCES;
goto done;
}
chars->handle = last;
chars->properties = value[2];
chars->value_handle = att_get_u16(&value[3]);
bt_uuid_to_string(&uuid, chars->uuid, sizeof(chars->uuid));
dc->characteristics = g_slist_append(dc->characteristics,
chars);
}
att_data_list_free(list);
if (last != 0 && (last + 1 < dc->end)) {
bt_uuid_t uuid;
guint16 oplen;
size_t buflen;
uint8_t *buf;
buf = g_attrib_get_buffer(dc->attrib, &buflen);
bt_uuid16_create(&uuid, GATT_CHARAC_UUID);
oplen = enc_read_by_type_req(last + 1, dc->end, &uuid, buf,
buflen);
if (oplen == 0)
return;
g_attrib_send(dc->attrib, 0, buf, oplen, char_discovered_cb,
dc, NULL);
return;
}
done:
err = (dc->characteristics ? 0 : err);
dc->cb(dc->characteristics, err, dc->user_data);
discover_char_free(dc);
}
static void primary_all_cb(guint8 status, const guint8 *ipdu, guint16 iplen,
gpointer user_data)
{
struct discover_primary *dp = user_data;
struct att_data_list *list;
unsigned int i, err;
uint16_t start, end;
if (status) {
err = status == ATT_ECODE_ATTR_NOT_FOUND ? 0 : status;
goto done;
}
list = dec_read_by_grp_resp(ipdu, iplen);
if (list == NULL) {
err = ATT_ECODE_IO;
goto done;
}
for (i = 0, end = 0; i < list->num; i++) {
const uint8_t *data = list->data[i];
struct gatt_primary *primary;
bt_uuid_t uuid;
start = att_get_u16(&data[0]);
end = att_get_u16(&data[2]);
if (list->len == 6) {
bt_uuid_t uuid16 = att_get_uuid16(&data[4]);
bt_uuid_to_uuid128(&uuid16, &uuid);
} else if (list->len == 20) {
uuid = att_get_uuid128(&data[4]);
} else {
/* Skipping invalid data */
continue;
}
primary = g_try_new0(struct gatt_primary, 1);
if (!primary) {
att_data_list_free(list);
err = ATT_ECODE_INSUFF_RESOURCES;
goto done;
}
primary->range.start = start;
primary->range.end = end;
bt_uuid_to_string(&uuid, primary->uuid, sizeof(primary->uuid));
dp->primaries = g_slist_append(dp->primaries, primary);
}
att_data_list_free(list);
err = 0;
if (end != 0xffff) {
size_t buflen;
uint8_t *buf = g_attrib_get_buffer(dp->attrib, &buflen);
guint16 oplen = encode_discover_primary(end + 1, 0xffff, NULL,
buf, buflen);
g_attrib_send(dp->attrib, 0, buf, oplen, primary_all_cb,
dp, NULL);
return;
}
done:
dp->cb(dp->primaries, err, dp->user_data);
discover_primary_free(dp);
}
