uint16_t dec_read_by_type_req(const uint8_t *pdu, size_t len, uint16_t *start,
uint16_t *end, bt_uuid_t *uuid)
{
const size_t min_len = sizeof(pdu[0]) + sizeof(*start) + sizeof(*end);
if (pdu == NULL)
return 0;
if (start == NULL || end == NULL || uuid == NULL)
return 0;
if (len < min_len + 2)
return 0;
if (pdu[0] != ATT_OP_READ_BY_TYPE_REQ)
return 0;
*start = att_get_u16(&pdu[1]);
*end = att_get_u16(&pdu[3]);
if (len == min_len + 2)
*uuid = att_get_uuid16(&pdu[5]);
else
*uuid = att_get_uuid128(&pdu[5]);
return len;
}
static void resolve_included_uuid_cb(uint8_t status, const uint8_t *pdu,
uint16_t len, gpointer user_data)
{
struct included_uuid_query *query = user_data;
struct included_discovery *isd = query->isd;
struct gatt_included *incl = query->included;
unsigned int err = status;
bt_uuid_t uuid;
size_t buflen;
uint8_t *buf;
if (err)
goto done;
buf = g_attrib_get_buffer(isd->attrib, &buflen);
if (dec_read_resp(pdu, len, buf, buflen) != 16) {
err = ATT_ECODE_IO;
goto done;
}
uuid = att_get_uuid128(buf);
bt_uuid_to_string(&uuid, incl->uuid, sizeof(incl->uuid));
isd->includes = g_slist_append(isd->includes, incl);
done:
if (err)
g_free(incl);
if (isd->err == 0)
isd->err = err;
isd_unref(isd);
g_free(query);
}
static void char_desc_cb(guint8 status, const guint8 *pdu, guint16 plen,
gpointer user_data)
{
struct att_data_list *list;
guint8 format;
uint16_t handle = 0xffff;
int i;
if (status != 0) {
resp_error(err_COMM_ERR); // Todo: status
return;
}
list = dec_find_info_resp(pdu, plen, &format);
if (list == NULL) {
resp_error(err_NOT_FOUND); // Todo: what does this mean?
return;
}
resp_begin(rsp_DESCRIPTORS);
for (i = 0; i < list->num; i++) {
char uuidstr[MAX_LEN_UUID_STR];
uint8_t *value;
bt_uuid_t uuid;
value = list->data[i];
handle = att_get_u16(value);
if (format == 0x01)
uuid = att_get_uuid16(&value[2]);
else
uuid = att_get_uuid128(&value[2]);
bt_uuid_to_string(&uuid, uuidstr, MAX_LEN_UUID_STR);
send_uint(tag_HANDLE, handle);
send_str (tag_UUID, uuidstr);
}
resp_end();
att_data_list_free(list);
if (handle != 0xffff && handle < end)
gatt_discover_char_desc(attrib, handle + 1, end, char_desc_cb, NULL);
}
static void char_desc_cb(guint8 status, const guint8 *pdu, guint16 plen,
gpointer user_data)
{
struct att_data_list *list;
guint8 format;
int i;
if (status != 0) {
printf("Discover all characteristic descriptors failed: "
"%s\n", att_ecode2str(status));
goto done;
}
list = dec_find_info_resp(pdu, plen, &format);
if (list == NULL)
goto done;
printf("\n");
for (i = 0; i < list->num; i++) {
char uuidstr[MAX_LEN_UUID_STR];
uint16_t handle;
uint8_t *value;
bt_uuid_t uuid;
value = list->data[i];
handle = att_get_u16(value);
if (format == 0x01)
uuid = att_get_uuid16(&value[2]);
else
uuid = att_get_uuid128(&value[2]);
bt_uuid_to_string(&uuid, uuidstr, MAX_LEN_UUID_STR);
printf("handle: 0x%04x, uuid: %s\n", handle, uuidstr);
}
att_data_list_free(list);
done:
printf("\n%s", get_prompt());
fflush(stdout);
}
static void char_desc_cb(guint8 status, const guint8 *pdu, guint16 plen,
gpointer user_data)
{
struct att_data_list *list;
guint8 format;
uint16_t handle = 0xffff;
int i;
if (status != 0) {
rl_printf("Discover descriptors finished: %s\n",
att_ecode2str(status));
return;
}
list = dec_find_info_resp(pdu, plen, &format);
if (list == NULL)
return;
for (i = 0; i < list->num; i++) {
char uuidstr[MAX_LEN_UUID_STR];
uint8_t *value;
bt_uuid_t uuid;
value = list->data[i];
handle = att_get_u16(value);
if (format == 0x01)
uuid = att_get_uuid16(&value[2]);
else
uuid = att_get_uuid128(&value[2]);
bt_uuid_to_string(&uuid, uuidstr, MAX_LEN_UUID_STR);
rl_printf("handle: 0x%04x, uuid: %s\n", handle, uuidstr);
}
att_data_list_free(list);
if (handle != 0xffff && handle < end)
gatt_discover_char_desc(attrib, handle + 1, end, char_desc_cb,
NULL);
}
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);
}
void char_desc_cb(guint8 status, const guint8 *pdu, guint16 plen,
gpointer user_data) {
struct att_data_list *list = NULL;
guint8 format;
uint16_t handle = 0xffff;
int i;
char uuid_str[MAX_LEN_UUID_STR];
uint8_t *value;
printf_dbg("[CB] IN char_desc_cb\n");
if (status) {
cb_ret_val = BL_REQUEST_FAIL_ERROR;
sprintf(cb_ret_msg, "Characteristic descriptor "
"callback: Failure: %s\n", att_ecode2str(status));
goto exit;
}
list = dec_find_info_resp(pdu, plen, &format);
if (list == NULL) {
cb_ret_val = BL_NO_ERROR;
strcpy(cb_ret_msg, "Characteristic descriptor callback: Nothing found\n");
goto exit;
}
for (i = 0; i < list->num; i++) {
bt_uuid_t uuid;
value = list->data[i];
handle = att_get_u16(value);
if (format == 0x01)
uuid = att_get_uuid16(&value[2]);
else
uuid = att_get_uuid128(&value[2]);
bt_uuid_to_string(&uuid, uuid_str, MAX_LEN_UUID_STR);
if (strcmp(uuid_str, GATT_PRIM_SVC_UUID_STR) &&
strcmp(uuid_str, GATT_SND_SVC_UUID_STR) &&
strcmp(uuid_str, GATT_INCLUDE_UUID_STR) &&
strcmp(uuid_str, GATT_CHARAC_UUID_STR)) {
bl_desc_t *bl_desc = bl_desc_new(uuid_str, handle);
if (bl_desc == NULL) {
cb_ret_val = BL_MALLOC_ERROR;
strcpy(cb_ret_msg, "Characteristic descriptor callback: Malloc "
"error\n");
goto exit;
}
if (bl_desc_list == NULL) {
bl_desc_list = g_slist_alloc();
if (bl_desc_list == NULL) {
cb_ret_val = BL_MALLOC_ERROR;
strcpy(cb_ret_msg, "Characteristic descriptor callback: Malloc "
"error\n");
goto exit;
}
bl_desc_list->data = bl_desc;
} else {
bl_desc_list = g_slist_append(bl_desc_list, bl_desc);
}
} else {
printf_dbg("Reach end of descriptor list\n");
goto exit;
}
}
if ((handle != 0xffff) && (handle < end_handle_cb)) {
printf_dbg("[CB] OUT with asking for a new request\n");
if (gatt_discover_char_desc(attrib, handle + 1, end_handle_cb,
char_desc_cb, NULL)) {
goto next;
}
cb_ret_val = BL_SEND_REQUEST_ERROR;
strcpy(cb_ret_msg, "Unable to send request\n");
}
exit:
if (bl_desc_list) {
// Return what we got if we add something
cb_ret_val = BL_NO_ERROR;
cb_ret_pointer = bl_desc_list;
}
bl_desc_list = NULL;
g_mutex_unlock(pending_callback);
next:
if (list)
att_data_list_free(list);
printf_dbg("[CB] OUT char_desc_cb\n");
}
