blob: 013472170a5a4113abd5f8c02d9ebfea8c4e050d [file] [log] [blame]
/*
*
* BlueZ - Bluetooth protocol stack for Linux
*
* Copyright (C) 2014 Google Inc.
*
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "src/shared/att.h"
#include "lib/bluetooth.h"
#include "lib/uuid.h"
#include "src/shared/gatt-helpers.h"
#include "src/shared/util.h"
#include "src/shared/queue.h"
#include "src/shared/gatt-db.h"
#include "src/shared/gatt-client.h"
#include <assert.h>
#include <limits.h>
#include <sys/uio.h>
#ifndef MAX
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#endif
#ifndef MIN
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#endif
#define UUID_BYTES (BT_GATT_UUID_SIZE * sizeof(uint8_t))
#define GATT_SVC_UUID 0x1801
#define SVC_CHNGD_UUID 0x2a05
struct bt_gatt_client {
struct bt_att *att;
int ref_count;
struct bt_gatt_client *parent;
struct queue *clones;
bt_gatt_client_callback_t ready_callback;
bt_gatt_client_destroy_func_t ready_destroy;
void *ready_data;
bt_gatt_client_service_changed_callback_t svc_chngd_callback;
bt_gatt_client_destroy_func_t svc_chngd_destroy;
void *svc_chngd_data;
bt_gatt_client_debug_func_t debug_callback;
bt_gatt_client_destroy_func_t debug_destroy;
void *debug_data;
struct gatt_db *db;
bool in_init;
bool ready;
/*
* Queue of long write requests. An error during "prepare write"
* requests can result in a cancel through "execute write". To prevent
* cancelation of prepared writes to the wrong attribute and multiple
* requests to the same attribute that may result in a corrupted final
* value, we avoid interleaving prepared writes.
*/
struct queue *long_write_queue;
bool in_long_write;
unsigned int reliable_write_session_id;
/* List of registered disconnect/notification/indication callbacks */
struct queue *notify_list;
struct queue *notify_chrcs;
int next_reg_id;
unsigned int disc_id, notify_id, ind_id;
/*
* Handles of the GATT Service and the Service Changed characteristic
* value handle. These will have the value 0 if they are not present on
* the remote peripheral.
*/
unsigned int svc_chngd_ind_id;
bool svc_chngd_registered;
struct queue *svc_chngd_queue; /* Queued service changed events */
bool in_svc_chngd;
/*
* List of pending read/write operations. For operations that span
* across multiple PDUs, this list provides a mapping from an operation
* id to an ATT request id.
*/
struct queue *pending_requests;
unsigned int next_request_id;
struct bt_gatt_request *discovery_req;
unsigned int mtu_req_id;
};
struct request {
struct bt_gatt_client *client;
bool long_write;
bool prep_write;
bool removed;
int ref_count;
unsigned int id;
unsigned int att_id;
void *data;
void (*destroy)(void *);
};
static struct request *request_ref(struct request *req)
{
__sync_fetch_and_add(&req->ref_count, 1);
return req;
}
static struct request *request_create(struct bt_gatt_client *client)
{
struct request *req;
req = new0(struct request, 1);
if (client->next_request_id < 1)
client->next_request_id = 1;
queue_push_tail(client->pending_requests, req);
req->client = client;
req->id = client->next_request_id++;
return request_ref(req);
}
static void request_unref(void *data)
{
struct request *req = data;
if (__sync_sub_and_fetch(&req->ref_count, 1))
return;
if (req->destroy)
req->destroy(req->data);
if (!req->removed)
queue_remove(req->client->pending_requests, req);
free(req);
}
struct notify_chrc {
uint16_t value_handle;
uint16_t ccc_handle;
uint16_t properties;
int notify_count; /* Reference count of registered notify callbacks */
/* Pending calls to register_notify are queued here so that they can be
* processed after a write that modifies the CCC descriptor.
*/
struct queue *reg_notify_queue;
unsigned int ccc_write_id;
};
struct notify_data {
struct bt_gatt_client *client;
unsigned int id;
unsigned int att_id;
int ref_count;
struct notify_chrc *chrc;
bt_gatt_client_register_callback_t callback;
bt_gatt_client_notify_callback_t notify;
void *user_data;
bt_gatt_client_destroy_func_t destroy;
};
static struct notify_data *notify_data_ref(struct notify_data *notify_data)
{
__sync_fetch_and_add(&notify_data->ref_count, 1);
return notify_data;
}
static void notify_data_unref(void *data)
{
struct notify_data *notify_data = data;
if (__sync_sub_and_fetch(&notify_data->ref_count, 1))
return;
if (notify_data->destroy)
notify_data->destroy(notify_data->user_data);
free(notify_data);
}
static void find_ccc(struct gatt_db_attribute *attr, void *user_data)
{
struct gatt_db_attribute **ccc_ptr = user_data;
bt_uuid_t uuid;
if (*ccc_ptr)
return;
bt_uuid16_create(&uuid, GATT_CLIENT_CHARAC_CFG_UUID);
if (bt_uuid_cmp(&uuid, gatt_db_attribute_get_type(attr)))
return;
*ccc_ptr = attr;
}
static struct notify_chrc *notify_chrc_create(struct bt_gatt_client *client,
uint16_t value_handle)
{
struct gatt_db_attribute *attr, *ccc;
struct notify_chrc *chrc;
bt_uuid_t uuid;
uint8_t properties;
/* Check that chrc_value_handle belongs to a known characteristic */
attr = gatt_db_get_attribute(client->db, value_handle - 1);
if (!attr)
return NULL;
bt_uuid16_create(&uuid, GATT_CHARAC_UUID);
if (bt_uuid_cmp(&uuid, gatt_db_attribute_get_type(attr)))
return NULL;
if (!gatt_db_attribute_get_char_data(attr, NULL, NULL, &properties,
NULL, NULL))
return NULL;
chrc = new0(struct notify_chrc, 1);
chrc->reg_notify_queue = queue_new();
if (!chrc->reg_notify_queue) {
free(chrc);
return NULL;
}
/*
* Find the CCC characteristic. Some characteristics that allow
* notifications may not have a CCC descriptor. We treat these as
* automatically successful.
*/
ccc = NULL;
gatt_db_service_foreach_desc(attr, find_ccc, &ccc);
if (ccc)
chrc->ccc_handle = gatt_db_attribute_get_handle(ccc);
chrc->value_handle = value_handle;
chrc->properties = properties;
queue_push_tail(client->notify_chrcs, chrc);
return chrc;
}
static void notify_chrc_free(void *data)
{
struct notify_chrc *chrc = data;
queue_destroy(chrc->reg_notify_queue, notify_data_unref);
free(chrc);
}
static bool match_notify_data_id(const void *a, const void *b)
{
const struct notify_data *notify_data = a;
unsigned int id = PTR_TO_UINT(b);
return notify_data->id == id;
}
struct handle_range {
uint16_t start;
uint16_t end;
};
static void notify_data_cleanup(void *data)
{
struct notify_data *notify_data = data;
if (notify_data->att_id)
bt_att_cancel(notify_data->client->att, notify_data->att_id);
notify_data_unref(notify_data);
}
struct discovery_op;
typedef void (*discovery_op_complete_func_t)(struct discovery_op *op,
bool success,
uint8_t att_ecode);
typedef void (*discovery_op_fail_func_t)(struct discovery_op *op);
struct discovery_op {
struct bt_gatt_client *client;
struct queue *pending_svcs;
struct queue *pending_chrcs;
struct queue *svcs;
struct queue *ext_prop_desc;
struct gatt_db_attribute *cur_svc;
bool success;
uint16_t start;
uint16_t end;
uint16_t last;
int ref_count;
discovery_op_complete_func_t complete_func;
discovery_op_fail_func_t failure_func;
};
static void discovery_op_free(struct discovery_op *op)
{
queue_destroy(op->pending_svcs, NULL);
queue_destroy(op->pending_chrcs, free);
queue_destroy(op->svcs, NULL);
queue_destroy(op->ext_prop_desc, NULL);
free(op);
}
static void discovery_op_complete(struct discovery_op *op, bool success,
uint8_t err)
{
/* Reset remaining range */
if (op->last != UINT16_MAX)
gatt_db_clear_range(op->client->db, op->last + 1, UINT16_MAX);
op->success = success;
op->complete_func(op, success, err);
}
static struct discovery_op *discovery_op_create(struct bt_gatt_client *client,
uint16_t start, uint16_t end,
discovery_op_complete_func_t complete_func,
discovery_op_fail_func_t failure_func)
{
struct discovery_op *op;
op = new0(struct discovery_op, 1);
op->pending_svcs = queue_new();
op->pending_chrcs = queue_new();
op->svcs = queue_new();
op->ext_prop_desc = queue_new();
op->client = client;
op->complete_func = complete_func;
op->failure_func = failure_func;
op->start = start;
op->end = end;
op->last = gatt_db_isempty(client->db) ? 0 : UINT16_MAX;
return op;
}
static struct discovery_op *discovery_op_ref(struct discovery_op *op)
{
__sync_fetch_and_add(&op->ref_count, 1);
return op;
}
static void discovery_op_unref(void *data)
{
struct discovery_op *op = data;
if (__sync_sub_and_fetch(&op->ref_count, 1))
return;
if (!op->success && op->failure_func)
op->failure_func(op);
discovery_op_free(op);
}
static void discovery_req_clear(struct bt_gatt_client *client)
{
if (!client->discovery_req)
return;
bt_gatt_request_unref(client->discovery_req);
client->discovery_req = NULL;
}
static void discover_chrcs_cb(bool success, uint8_t att_ecode,
struct bt_gatt_result *result,
void *user_data);
static void discover_incl_cb(bool success, uint8_t att_ecode,
struct bt_gatt_result *result, void *user_data)
{
struct discovery_op *op = user_data;
struct bt_gatt_client *client = op->client;
struct bt_gatt_iter iter;
struct gatt_db_attribute *attr, *tmp;
uint16_t handle, start, end;
uint128_t u128;
bt_uuid_t uuid;
char uuid_str[MAX_LEN_UUID_STR];
unsigned int includes_count, i;
discovery_req_clear(client);
if (!success) {
if (att_ecode == BT_ATT_ERROR_ATTRIBUTE_NOT_FOUND)
goto next;
goto failed;
}
/* Get the currently processed service */
attr = op->cur_svc;
if (!attr)
goto failed;
if (!result || !bt_gatt_iter_init(&iter, result))
goto failed;
includes_count = bt_gatt_result_included_count(result);
if (includes_count == 0)
goto failed;
util_debug(client->debug_callback, client->debug_data,
"Included services found: %u",
includes_count);
for (i = 0; i < includes_count; i++) {
if (!bt_gatt_iter_next_included_service(&iter, &handle, &start,
&end, u128.data))
break;
bt_uuid128_create(&uuid, u128);
/* Log debug message */
bt_uuid_to_string(&uuid, uuid_str, sizeof(uuid_str));
util_debug(client->debug_callback, client->debug_data,
"handle: 0x%04x, start: 0x%04x, end: 0x%04x,"
"uuid: %s", handle, start, end, uuid_str);
tmp = gatt_db_get_attribute(client->db, start);
if (!tmp)
goto failed;
tmp = gatt_db_service_add_included(attr, tmp);
if (!tmp)
goto failed;
/*
* GATT requires that all include definitions precede
* characteristic declarations. Based on the order we're adding
* these entries, the correct handle must be assigned to the new
* attribute.
*/
if (gatt_db_attribute_get_handle(tmp) != handle)
goto failed;
}
next:
/* Move on to the next service */
attr = queue_pop_head(op->pending_svcs);
if (!attr) {
/*
* We have processed all include definitions. Move on to
* characteristics.
*/
attr = queue_pop_head(op->svcs);
if (!attr)
goto failed;
if (!gatt_db_attribute_get_service_handles(attr, &start, &end))
goto failed;
op->cur_svc = attr;
client->discovery_req = bt_gatt_discover_characteristics(
client->att,
start, end,
discover_chrcs_cb,
discovery_op_ref(op),
discovery_op_unref);
if (client->discovery_req)
return;
util_debug(client->debug_callback, client->debug_data,
"Failed to start characteristic discovery");
discovery_op_unref(op);
goto failed;
}
queue_push_tail(op->svcs, attr);
op->cur_svc = attr;
if (!gatt_db_attribute_get_service_handles(attr, &start, &end))
goto failed;
if (start == end)
goto next;
client->discovery_req = bt_gatt_discover_included_services(client->att,
start, end,
discover_incl_cb,
discovery_op_ref(op),
discovery_op_unref);
if (client->discovery_req)
return;
util_debug(client->debug_callback, client->debug_data,
"Failed to start included discovery");
discovery_op_unref(op);
failed:
discovery_op_complete(op, false, att_ecode);
}
struct chrc {
uint16_t start_handle;
uint16_t end_handle;
uint16_t value_handle;
uint8_t properties;
bt_uuid_t uuid;
};
static void discover_descs_cb(bool success, uint8_t att_ecode,
struct bt_gatt_result *result,
void *user_data);
static bool discover_descs(struct discovery_op *op, bool *discovering)
{
struct bt_gatt_client *client = op->client;
struct gatt_db_attribute *attr;
struct chrc *chrc_data;
uint16_t desc_start;
*discovering = false;
while ((chrc_data = queue_pop_head(op->pending_chrcs))) {
attr = gatt_db_service_insert_characteristic(op->cur_svc,
chrc_data->value_handle,
&chrc_data->uuid, 0,
chrc_data->properties,
NULL, NULL, NULL);
if (!attr) {
util_debug(client->debug_callback, client->debug_data,
"Failed to insert characteristic at 0x%04x",
chrc_data->value_handle);
goto failed;
}
if (gatt_db_attribute_get_handle(attr) !=
chrc_data->value_handle)
goto failed;
/*
* check for descriptors presence, before initializing the
* desc_handle and avoid integer overflow during desc_handle
* intialization.
*/
if (chrc_data->value_handle >= chrc_data->end_handle) {
free(chrc_data);
continue;
}
desc_start = chrc_data->value_handle + 1;
client->discovery_req = bt_gatt_discover_descriptors(
client->att, desc_start,
chrc_data->end_handle,
discover_descs_cb,
discovery_op_ref(op),
discovery_op_unref);
if (client->discovery_req) {
*discovering = true;
goto done;
}
util_debug(client->debug_callback, client->debug_data,
"Failed to start descriptor discovery");
discovery_op_unref(op);
goto failed;
}
done:
free(chrc_data);
return true;
failed:
free(chrc_data);
return false;
}
static void ext_prop_write_cb(struct gatt_db_attribute *attrib,
int err, void *user_data)
{
struct bt_gatt_client *client = user_data;
util_debug(client->debug_callback, client->debug_data,
"Value set status: %d", err);
}
static void ext_prop_read_cb(bool success, uint8_t att_ecode,
const uint8_t *value, uint16_t length,
void *user_data);
static bool read_ext_prop_desc(struct discovery_op *op)
{
struct bt_gatt_client *client = op->client;
uint16_t handle;
struct gatt_db_attribute *attr;
attr = queue_peek_head(op->ext_prop_desc);
if (!attr)
return false;
handle = gatt_db_attribute_get_handle(attr);
if (!bt_gatt_client_read_value(client, handle, ext_prop_read_cb,
discovery_op_ref(op),
discovery_op_unref))
return false;
return true;
}
static void ext_prop_read_cb(bool success, uint8_t att_ecode,
const uint8_t *value, uint16_t length,
void *user_data)
{
struct discovery_op *op = user_data;
struct bt_gatt_client *client = op->client;
bool discovering;
struct gatt_db_attribute *desc_attr = NULL;
struct gatt_db_attribute *next_srv;
uint16_t start, end;
util_debug(client->debug_callback, client->debug_data,
"Ext. prop value: 0x%04x", (uint16_t)value[0]);
desc_attr = queue_pop_head(op->ext_prop_desc);
if (!desc_attr)
goto failed;
if (!gatt_db_attribute_write(desc_attr, 0, value, length, 0, NULL,
ext_prop_write_cb, client))
goto failed;
/* Any other descriptor to read? */
if (read_ext_prop_desc(op))
return;
/* Continue with discovery */
do {
if (!discover_descs(op, &discovering))
goto failed;
if (discovering)
return;
/* Done with the current service */
gatt_db_service_set_active(op->cur_svc, true);
next_srv = queue_pop_head(op->svcs);
if (!next_srv)
goto done;
if (!gatt_db_attribute_get_service_handles(next_srv, &start,
&end))
goto failed;
} while (start == end);
/* Move on to the next service */
op->cur_svc = next_srv;
client->discovery_req = bt_gatt_discover_characteristics(client->att,
start, end,
discover_chrcs_cb,
discovery_op_ref(op),
discovery_op_unref);
if (client->discovery_req)
return;
util_debug(client->debug_callback, client->debug_data,
"Failed to start characteristic discovery");
discovery_op_unref(op);
failed:
success = false;
done:
discovery_op_complete(op, success, att_ecode);
}
static void discover_descs_cb(bool success, uint8_t att_ecode,
struct bt_gatt_result *result,
void *user_data)
{
struct discovery_op *op = user_data;
struct bt_gatt_client *client = op->client;
struct bt_gatt_iter iter;
struct gatt_db_attribute *attr;
uint16_t handle, start, end;
uint128_t u128;
bt_uuid_t uuid;
char uuid_str[MAX_LEN_UUID_STR];
unsigned int desc_count;
bool discovering;
bt_uuid_t ext_prop_uuid;
discovery_req_clear(client);
if (!success) {
if (att_ecode == BT_ATT_ERROR_ATTRIBUTE_NOT_FOUND) {
success = true;
goto next;
}
goto done;
}
if (!result || !bt_gatt_iter_init(&iter, result))
goto failed;
desc_count = bt_gatt_result_descriptor_count(result);
if (desc_count == 0)
goto failed;
util_debug(client->debug_callback, client->debug_data,
"Descriptors found: %u", desc_count);
bt_uuid16_create(&ext_prop_uuid, GATT_CHARAC_EXT_PROPER_UUID);
while (bt_gatt_iter_next_descriptor(&iter, &handle, u128.data)) {
bt_uuid128_create(&uuid, u128);
/* Log debug message */
bt_uuid_to_string(&uuid, uuid_str, sizeof(uuid_str));
util_debug(client->debug_callback, client->debug_data,
"handle: 0x%04x, uuid: %s",
handle, uuid_str);
attr = gatt_db_service_insert_descriptor(op->cur_svc, handle,
&uuid, 0, NULL, NULL,
NULL);
if (!attr)
goto failed;
if (gatt_db_attribute_get_handle(attr) != handle)
goto failed;
if (!bt_uuid_cmp(&ext_prop_uuid, &uuid))
queue_push_tail(op->ext_prop_desc, attr);
}
/* If we got extended prop descriptor, lets read it right away */
if (read_ext_prop_desc(op))
return;
next:
if (!discover_descs(op, &discovering))
goto failed;
if (discovering)
return;
/* Done with the current service */
gatt_db_service_set_active(op->cur_svc, true);
attr = queue_pop_head(op->svcs);
if (!attr)
goto done;
if (!gatt_db_attribute_get_service_handles(attr, &start, &end))
goto failed;
if (start == end)
goto next;
/* Move on to the next service */
op->cur_svc = attr;
client->discovery_req = bt_gatt_discover_characteristics(client->att,
start, end,
discover_chrcs_cb,
discovery_op_ref(op),
discovery_op_unref);
if (client->discovery_req)
return;
util_debug(client->debug_callback, client->debug_data,
"Failed to start characteristic discovery");
discovery_op_unref(op);
failed:
success = false;
done:
discovery_op_complete(op, success, att_ecode);
}
static void discover_chrcs_cb(bool success, uint8_t att_ecode,
struct bt_gatt_result *result,
void *user_data)
{
struct discovery_op *op = user_data;
struct bt_gatt_client *client = op->client;
struct bt_gatt_iter iter;
struct gatt_db_attribute *attr;
struct chrc *chrc_data;
uint16_t start, end, value;
uint8_t properties;
uint128_t u128;
bt_uuid_t uuid;
char uuid_str[MAX_LEN_UUID_STR];
unsigned int chrc_count;
bool discovering;
discovery_req_clear(client);
if (!success) {
if (att_ecode == BT_ATT_ERROR_ATTRIBUTE_NOT_FOUND) {
success = true;
goto next;
}
goto done;
}
if (!op->cur_svc || !result || !bt_gatt_iter_init(&iter, result))
goto failed;
chrc_count = bt_gatt_result_characteristic_count(result);
util_debug(client->debug_callback, client->debug_data,
"Characteristics found: %u", chrc_count);
if (chrc_count == 0)
goto failed;
while (bt_gatt_iter_next_characteristic(&iter, &start, &end, &value,
&properties, u128.data)) {
bt_uuid128_create(&uuid, u128);
/* Log debug message */
bt_uuid_to_string(&uuid, uuid_str, sizeof(uuid_str));
util_debug(client->debug_callback, client->debug_data,
"start: 0x%04x, end: 0x%04x, value: 0x%04x, "
"props: 0x%02x, uuid: %s",
start, end, value, properties, uuid_str);
chrc_data = new0(struct chrc, 1);
chrc_data->start_handle = start;
chrc_data->end_handle = end;
chrc_data->value_handle = value;
chrc_data->properties = properties;
chrc_data->uuid = uuid;
queue_push_tail(op->pending_chrcs, chrc_data);
}
/*
* Sequentially discover descriptors for each characteristic and insert
* the characteristics into the database as we proceed.
*/
if (!discover_descs(op, &discovering))
goto failed;
if (discovering)
return;
next:
/* Done with the current service */
gatt_db_service_set_active(op->cur_svc, true);
attr = queue_pop_head(op->svcs);
if (!attr)
goto done;
if (!gatt_db_attribute_get_service_handles(attr, &start, &end))
goto failed;
if (start == end)
goto next;
/* Move on to the next service */
op->cur_svc = attr;
client->discovery_req = bt_gatt_discover_characteristics(client->att,
start, end,
discover_chrcs_cb,
discovery_op_ref(op),
discovery_op_unref);
if (client->discovery_req)
return;
util_debug(client->debug_callback, client->debug_data,
"Failed to start characteristic discovery");
discovery_op_unref(op);
failed:
success = false;
done:
discovery_op_complete(op, success, att_ecode);
}
static void discover_secondary_cb(bool success, uint8_t att_ecode,
struct bt_gatt_result *result,
void *user_data)
{
struct discovery_op *op = user_data;
struct bt_gatt_client *client = op->client;
struct bt_gatt_iter iter;
struct gatt_db_attribute *attr;
uint16_t start, end;
uint128_t u128;
bt_uuid_t uuid;
char uuid_str[MAX_LEN_UUID_STR];
discovery_req_clear(client);
if (!success) {
util_debug(client->debug_callback, client->debug_data,
"Secondary service discovery failed."
" ATT ECODE: 0x%02x", att_ecode);
switch (att_ecode) {
case BT_ATT_ERROR_ATTRIBUTE_NOT_FOUND:
case BT_ATT_ERROR_UNSUPPORTED_GROUP_TYPE:
goto next;
default:
goto done;
}
}
if (!result || !bt_gatt_iter_init(&iter, result)) {
success = false;
goto done;
}
util_debug(client->debug_callback, client->debug_data,
"Secondary services found: %u",
bt_gatt_result_service_count(result));
while (bt_gatt_iter_next_service(&iter, &start, &end, u128.data)) {
bt_uuid128_create(&uuid, u128);
/* Log debug message */
bt_uuid_to_string(&uuid, uuid_str, sizeof(uuid_str));
util_debug(client->debug_callback, client->debug_data,
"start: 0x%04x, end: 0x%04x, uuid: %s",
start, end, uuid_str);
/* Store the service */
attr = gatt_db_insert_service(client->db, start, &uuid, false,
end - start + 1);
if (!attr) {
gatt_db_clear_range(client->db, start, end);
attr = gatt_db_insert_service(client->db, start, &uuid,
false, end - start + 1);
if (!attr) {
util_debug(client->debug_callback,
client->debug_data,
"Failed to store service");
success = false;
goto done;
}
/* Database has changed adjust last handle */
op->last = end;
}
/* Skip if service already active */
if (!gatt_db_service_get_active(attr))
queue_push_tail(op->pending_svcs, attr);
/* Update last handle */
if (end > op->last)
op->last = end;
}
next:
/* Sequentially discover included services */
attr = queue_pop_head(op->pending_svcs);
/* Complete with success if queue is empty */
if (!attr) {
success = true;
goto done;
}
/*
* Store the service in the svcs queue to be reused during
* characteristics discovery later.
*/
queue_push_tail(op->svcs, attr);
op->cur_svc = attr;
if (!gatt_db_attribute_get_service_handles(attr, &start, &end)) {
success = false;
goto done;
}
client->discovery_req = bt_gatt_discover_included_services(client->att,
start, end,
discover_incl_cb,
discovery_op_ref(op),
discovery_op_unref);
if (client->discovery_req)
return;
util_debug(client->debug_callback, client->debug_data,
"Failed to start included services discovery");
discovery_op_unref(op);
success = false;
done:
discovery_op_complete(op, success, att_ecode);
}
static void discover_primary_cb(bool success, uint8_t att_ecode,
struct bt_gatt_result *result,
void *user_data)
{
struct discovery_op *op = user_data;
struct bt_gatt_client *client = op->client;
struct bt_gatt_iter iter;
struct gatt_db_attribute *attr;
uint16_t start, end;
uint128_t u128;
bt_uuid_t uuid;
char uuid_str[MAX_LEN_UUID_STR];
discovery_req_clear(client);
if (!success) {
util_debug(client->debug_callback, client->debug_data,
"Primary service discovery failed."
" ATT ECODE: 0x%02x", att_ecode);
/* Reset error in case of not found */
switch (att_ecode) {
case BT_ATT_ERROR_ATTRIBUTE_NOT_FOUND:
success = true;
att_ecode = 0;
goto secondary;
default:
goto done;
}
}
if (!result || !bt_gatt_iter_init(&iter, result)) {
success = false;
goto done;
}
util_debug(client->debug_callback, client->debug_data,
"Primary services found: %u",
bt_gatt_result_service_count(result));
while (bt_gatt_iter_next_service(&iter, &start, &end, u128.data)) {
bt_uuid128_create(&uuid, u128);
/* Log debug message. */
bt_uuid_to_string(&uuid, uuid_str, sizeof(uuid_str));
util_debug(client->debug_callback, client->debug_data,
"start: 0x%04x, end: 0x%04x, uuid: %s",
start, end, uuid_str);
attr = gatt_db_insert_service(client->db, start, &uuid, true,
end - start + 1);
if (!attr) {
gatt_db_clear_range(client->db, start, end);
attr = gatt_db_insert_service(client->db, start, &uuid,
true, end - start + 1);
if (!attr) {
util_debug(client->debug_callback,
client->debug_data,
"Failed to store service");
success = false;
goto done;
}
/* Database has changed adjust last handle */
op->last = end;
}
/* Skip if service already active */
if (!gatt_db_service_get_active(attr))
queue_push_tail(op->pending_svcs, attr);
/* Update last handle */
if (end > op->last)
op->last = end;
}
secondary:
/*
* Version 4.2 [Vol 1, Part A] page 101:
* A secondary service is a service that provides auxiliary
* functionality of a device and is referenced from at least one
* primary service on the device.
*/
if (queue_isempty(op->pending_svcs))
goto done;
/* Discover secondary services */
client->discovery_req = bt_gatt_discover_secondary_services(client->att,
NULL, op->start, op->end,
discover_secondary_cb,
discovery_op_ref(op),
discovery_op_unref);
if (client->discovery_req)
return;
util_debug(client->debug_callback, client->debug_data,
"Failed to start secondary service discovery");
discovery_op_unref(op);
success = false;
done:
discovery_op_complete(op, success, att_ecode);
}
static void notify_client_ready(struct bt_gatt_client *client, bool success,
uint8_t att_ecode)
{
const struct queue_entry *entry;
if (!client->ready_callback || client->ready)
return;
bt_gatt_client_ref(client);
client->ready = success;
client->ready_callback(success, att_ecode, client->ready_data);
/* Notify clones */
for (entry = queue_get_entries(client->clones); entry;
entry = entry->next) {
struct bt_gatt_client *clone = entry->data;
notify_client_ready(clone, success, att_ecode);
}
bt_gatt_client_unref(client);
}
static void exchange_mtu_cb(bool success, uint8_t att_ecode, void *user_data)
{
struct discovery_op *op = user_data;
struct bt_gatt_client *client = op->client;
op->success = success;
client->mtu_req_id = 0;
if (!success) {
util_debug(client->debug_callback, client->debug_data,
"MTU Exchange failed. ATT ECODE: 0x%02x",
att_ecode);
/*
* BLUETOOTH SPECIFICATION Version 4.2 [Vol 3, Part G] page 546
* If the Error Response is sent by the server with the Error
* Code set to RequestNot Supported , the Attribute Opcode is
* not supported and the default MTU shall be used.
*/
if (att_ecode == BT_ATT_ERROR_REQUEST_NOT_SUPPORTED)
goto discover;
client->in_init = false;
notify_client_ready(client, success, att_ecode);
return;
}
util_debug(client->debug_callback, client->debug_data,
"MTU exchange complete, with MTU: %u",
bt_att_get_mtu(client->att));
discover:
client->discovery_req = bt_gatt_discover_all_primary_services(
client->att, NULL,
discover_primary_cb,
discovery_op_ref(op),
discovery_op_unref);
if (client->discovery_req)
return;
util_debug(client->debug_callback, client->debug_data,
"Failed to initiate primary service discovery");
client->in_init = false;
notify_client_ready(client, false, att_ecode);
discovery_op_unref(op);
}
struct service_changed_op {
struct bt_gatt_client *client;
uint16_t start_handle;
uint16_t end_handle;
};
static void process_service_changed(struct bt_gatt_client *client,
uint16_t start_handle,
uint16_t end_handle);
static void service_changed_cb(uint16_t value_handle, const uint8_t *value,
uint16_t length, void *user_data);
static void complete_notify_request(void *data)
{
struct notify_data *notify_data = data;
notify_data->att_id = 0;
notify_data->callback(0, notify_data->user_data);
}
static bool notify_data_write_ccc(struct notify_data *notify_data, bool enable,
bt_att_response_func_t callback)
{
uint8_t pdu[4];
unsigned int att_id;
assert(notify_data->chrc->ccc_handle);
memset(pdu, 0, sizeof(pdu));
put_le16(notify_data->chrc->ccc_handle, pdu);
if (enable) {
/* Try to enable notifications and/or indications based on
* whatever the characteristic supports.
*/
if (notify_data->chrc->properties & BT_GATT_CHRC_PROP_NOTIFY)
pdu[2] = 0x01;
if (notify_data->chrc->properties & BT_GATT_CHRC_PROP_INDICATE)
pdu[2] |= 0x02;
if (!pdu[2])
return false;
}
att_id = bt_att_send(notify_data->client->att, BT_ATT_OP_WRITE_REQ,
pdu, sizeof(pdu), callback,
notify_data_ref(notify_data),
notify_data_unref);
notify_data->chrc->ccc_write_id = notify_data->att_id = att_id;
return !!att_id;
}
static uint8_t process_error(const void *pdu, uint16_t length)
{
const struct bt_att_pdu_error_rsp *error_pdu;
if (!pdu || length != sizeof(struct bt_att_pdu_error_rsp))
return 0;
error_pdu = pdu;
return error_pdu->ecode;
}
static void enable_ccc_callback(uint8_t opcode, const void *pdu,
uint16_t length, void *user_data)
{
struct notify_data *notify_data = user_data;
uint16_t att_ecode;
assert(notify_data->chrc->ccc_write_id);
notify_data->chrc->ccc_write_id = 0;
if (opcode == BT_ATT_OP_ERROR_RSP) {
att_ecode = process_error(pdu, length);
/* Failed to enable. Complete the current request and move on to
* the next one in the queue. If there was an error sending the
* write request, then just move on to the next queued entry.
*/
queue_remove(notify_data->client->notify_list, notify_data);
notify_data->callback(att_ecode, notify_data->user_data);
while ((notify_data = queue_pop_head(
notify_data->chrc->reg_notify_queue))) {
if (notify_data_write_ccc(notify_data, true,
enable_ccc_callback))
return;
}
return;
}
/* Success! Report success for all remaining requests. */
bt_gatt_client_ref(notify_data->client);
complete_notify_request(notify_data);
queue_remove_all(notify_data->chrc->reg_notify_queue, NULL, NULL,
complete_notify_request);
bt_gatt_client_unref(notify_data->client);
}
static bool match_notify_chrc_value_handle(const void *a, const void *b)
{
const struct notify_chrc *chrc = a;
uint16_t value_handle = PTR_TO_UINT(b);
return chrc->value_handle == value_handle;
}
static unsigned int register_notify(struct bt_gatt_client *client,
uint16_t handle,
bt_gatt_client_register_callback_t callback,
bt_gatt_client_notify_callback_t notify,
void *user_data,
bt_gatt_client_destroy_func_t destroy)
{
struct notify_data *notify_data;
struct notify_chrc *chrc = NULL;
/* Check if a characteristic ref count has been started already */
chrc = queue_find(client->notify_chrcs, match_notify_chrc_value_handle,
UINT_TO_PTR(handle));
if (!chrc) {
/*
* Create an entry if the characteristic is known and has a CCC
* descriptor.
*/
chrc = notify_chrc_create(client, handle);
if (!chrc)
return 0;
}
/* Fail if we've hit the maximum allowed notify sessions */
if (chrc->notify_count == INT_MAX)
return 0;
notify_data = new0(struct notify_data, 1);
notify_data->client = client;
notify_data->ref_count = 1;
notify_data->chrc = chrc;
notify_data->callback = callback;
notify_data->notify = notify;
notify_data->user_data = user_data;
notify_data->destroy = destroy;
/* Add the handler to the bt_gatt_client's general list */
queue_push_tail(client->notify_list, notify_data);
/* Assign an ID to the handler. */
if (client->next_reg_id < 1)
client->next_reg_id = 1;
notify_data->id = client->next_reg_id++;
/* Increment the per-characteristic ref count of notify handlers */
__sync_fetch_and_add(&notify_data->chrc->notify_count, 1);
/*
* If a write to the CCC descriptor is in progress, then queue this
* request.
*/
if (chrc->ccc_write_id) {
queue_push_tail(chrc->reg_notify_queue, notify_data);
return notify_data->id;
}
/*
* If the ref count > 1, then notifications are already enabled.
*/
if (chrc->notify_count > 1 || !chrc->ccc_handle) {
complete_notify_request(notify_data);
return notify_data->id;
}
/* Write to the CCC descriptor */
if (!notify_data_write_ccc(notify_data, true, enable_ccc_callback)) {
queue_remove(client->notify_list, notify_data);
free(notify_data);
return 0;
}
return notify_data->id;
}
static void get_first_attribute(struct gatt_db_attribute *attrib,
void *user_data)
{
struct gatt_db_attribute **stored = user_data;
if (*stored)
return;
*stored = attrib;
}
static void service_changed_register_cb(uint16_t att_ecode, void *user_data)
{
bool success;
struct bt_gatt_client *client = user_data;
if (att_ecode) {
util_debug(client->debug_callback, client->debug_data,
"Failed to register handler for \"Service Changed\"");
success = false;
client->svc_chngd_ind_id = 0;
goto done;
}
client->svc_chngd_registered = true;
success = true;
util_debug(client->debug_callback, client->debug_data,
"Registered handler for \"Service Changed\": %u",
client->svc_chngd_ind_id);
done:
notify_client_ready(client, success, att_ecode);
}
static bool register_service_changed(struct bt_gatt_client *client)
{
bt_uuid_t uuid;
struct gatt_db_attribute *attr = NULL;
bt_uuid16_create(&uuid, SVC_CHNGD_UUID);
if (client->svc_chngd_ind_id)
return true;
gatt_db_find_by_type(client->db, 0x0001, 0xffff, &uuid,
get_first_attribute, &attr);
if (!attr)
return true;
/*
* Register an indication handler for the "Service Changed"
* characteristic and report ready only if the handler is registered
* successfully.
*/
client->svc_chngd_ind_id = register_notify(client,
gatt_db_attribute_get_handle(attr),
service_changed_register_cb,
service_changed_cb,
client, NULL);
return client->svc_chngd_ind_id ? true : false;
}
static void service_changed_complete(struct discovery_op *op, bool success,
uint8_t att_ecode)
{
struct bt_gatt_client *client = op->client;
struct service_changed_op *next_sc_op;
uint16_t start_handle = op->start;
uint16_t end_handle = op->end;
const struct queue_entry *entry;
client->in_svc_chngd = false;
if (!success && att_ecode != BT_ATT_ERROR_ATTRIBUTE_NOT_FOUND) {
util_debug(client->debug_callback, client->debug_data,
"Failed to discover services within changed range - "
"error: 0x%02x", att_ecode);
gatt_db_clear_range(client->db, start_handle, end_handle);
}
/* Notify the upper layer of changed services */
if (client->svc_chngd_callback)
client->svc_chngd_callback(start_handle, end_handle,
client->svc_chngd_data);
/* Notify clones */
for (entry = queue_get_entries(client->clones); entry;
entry = entry->next) {
struct bt_gatt_client *clone = entry->data;
if (clone->svc_chngd_callback)
clone->svc_chngd_callback(start_handle, end_handle,
clone->svc_chngd_data);
}
/* Process any queued events */
next_sc_op = queue_pop_head(client->svc_chngd_queue);
if (next_sc_op) {
process_service_changed(client, next_sc_op->start_handle,
next_sc_op->end_handle);
free(next_sc_op);
return;
}
if (register_service_changed(client))
return;
util_debug(client->debug_callback, client->debug_data,
"Failed to re-register handler for \"Service Changed\"");
}
static void service_changed_failure(struct discovery_op *op)
{
struct bt_gatt_client *client = op->client;
gatt_db_clear_range(client->db, op->start, op->end);
}
static void process_service_changed(struct bt_gatt_client *client,
uint16_t start_handle,
uint16_t end_handle)
{
struct discovery_op *op;
op = discovery_op_create(client, start_handle, end_handle,
service_changed_complete,
service_changed_failure);
if (!op)
goto fail;
client->discovery_req = bt_gatt_discover_primary_services(client->att,
NULL, start_handle, end_handle,
discover_primary_cb,
discovery_op_ref(op),
discovery_op_unref);
if (client->discovery_req) {
client->in_svc_chngd = true;
return;
}
discovery_op_free(op);
fail:
util_debug(client->debug_callback, client->debug_data,
"Failed to initiate service discovery"
" after Service Changed");
}
static void service_changed_cb(uint16_t value_handle, const uint8_t *value,
uint16_t length, void *user_data)
{
struct bt_gatt_client *client = user_data;
struct service_changed_op *op;
uint16_t start, end;
if (length != 4)
return;
start = get_le16(value);
end = get_le16(value + 2);
if (start > end) {
util_debug(client->debug_callback, client->debug_data,
"Service Changed received with invalid handles");
return;
}
util_debug(client->debug_callback, client->debug_data,
"Service Changed received - start: 0x%04x end: 0x%04x",
start, end);
if (!client->in_svc_chngd) {
process_service_changed(client, start, end);
return;
}
op = new0(struct service_changed_op, 1);
op->start_handle = start;
op->end_handle = end;
queue_push_tail(client->svc_chngd_queue, op);
}
static void init_complete(struct discovery_op *op, bool success,
uint8_t att_ecode)
{
struct bt_gatt_client *client = op->client;
client->in_init = false;
if (!success)
goto fail;
if (register_service_changed(client))
goto done;
util_debug(client->debug_callback, client->debug_data,
"Failed to register handler for \"Service Changed\"");
success = false;
fail:
util_debug(client->debug_callback, client->debug_data,
"Failed to initialize gatt-client");
op->success = false;
done:
notify_client_ready(client, success, att_ecode);
}
static bool gatt_client_init(struct bt_gatt_client *client, uint16_t mtu)
{
struct discovery_op *op;
if (client->in_init || client->ready)
return false;
op = discovery_op_create(client, 0x0001, 0xffff, init_complete, NULL);
if (!op)
return false;
/*
* BLUETOOTH SPECIFICATION Version 4.2 [Vol 3, Part G] page 546:
*
* 4.3.1 Exchange MTU
*
* This sub-procedure shall not be used on a BR/EDR physical link since
* the MTU size is negotiated using L2CAP channel configuration
* procedures.
*/
if (bt_att_get_link_type(client->att) == BT_ATT_LINK_BREDR)
goto discover;
/* Check if MTU needs to be send */
mtu = MAX(BT_ATT_DEFAULT_LE_MTU, mtu);
if (mtu == BT_ATT_DEFAULT_LE_MTU)
goto discover;
/* Configure the MTU */
client->mtu_req_id = bt_gatt_exchange_mtu(client->att, mtu,
exchange_mtu_cb,
discovery_op_ref(op),
discovery_op_unref);
if (!client->mtu_req_id) {
discovery_op_free(op);
return false;
}
client->in_init = true;
return true;
discover:
client->discovery_req = bt_gatt_discover_all_primary_services(
client->att, NULL,
discover_primary_cb,
discovery_op_ref(op),
discovery_op_unref);
if (!client->discovery_req) {
discovery_op_free(op);
return false;
}
client->in_init = true;
return true;
}
struct pdu_data {
const void *pdu;
uint16_t length;
};
static void disable_ccc_callback(uint8_t opcode, const void *pdu,
uint16_t length, void *user_data)
{
struct notify_data *notify_data = user_data;
struct notify_data *next_data;
assert(notify_data->chrc->ccc_write_id);
notify_data->chrc->ccc_write_id = 0;
/* This is a best effort procedure, so ignore errors and process any
* queued requests.
*/
while (1) {
next_data = queue_pop_head(notify_data->chrc->reg_notify_queue);
if (!next_data || notify_data_write_ccc(notify_data, true,
enable_ccc_callback))
return;
}
}
static void complete_unregister_notify(void *data)
{
struct notify_data *notify_data = data;
/*
* If a procedure to enable the CCC is still pending, then cancel it and
* return.
*/
if (notify_data->att_id) {
bt_att_cancel(notify_data->client->att, notify_data->att_id);
notify_data->att_id = 0;
goto done;
}
if (__sync_sub_and_fetch(&notify_data->chrc->notify_count, 1) ||
!notify_data->chrc->ccc_handle)
goto done;
notify_data_write_ccc(notify_data, false, disable_ccc_callback);
done:
notify_data_unref(notify_data);
}
static void notify_handler(void *data, void *user_data)
{
struct notify_data *notify_data = data;
struct pdu_data *pdu_data = user_data;
uint16_t value_handle;
const uint8_t *value = NULL;
value_handle = get_le16(pdu_data->pdu);
if (notify_data->chrc->value_handle != value_handle)
return;
if (pdu_data->length > 2)
value = pdu_data->pdu + 2;
/*
* Even if the notify data has a pending ATT request to write to the
* CCC, there is really no reason not to notify the handlers.
*/
if (notify_data->notify)
notify_data->notify(value_handle, value, pdu_data->length - 2,
notify_data->user_data);
}
static void notify_cb(uint8_t opcode, const void *pdu, uint16_t length,
void *user_data)
{
struct bt_gatt_client *client = user_data;
struct pdu_data pdu_data;
bt_gatt_client_ref(client);
memset(&pdu_data, 0, sizeof(pdu_data));
pdu_data.pdu = pdu;
pdu_data.length = length;
queue_foreach(client->notify_list, notify_handler, &pdu_data);
if (opcode == BT_ATT_OP_HANDLE_VAL_IND && !client->parent)
bt_att_send(client->att, BT_ATT_OP_HANDLE_VAL_CONF, NULL, 0,
NULL, NULL, NULL);
bt_gatt_client_unref(client);
}
static void bt_gatt_client_free(struct bt_gatt_client *client)
{
bt_gatt_client_cancel_all(client);
queue_destroy(client->notify_list, notify_data_cleanup);
if (client->ready_destroy)
client->ready_destroy(client->ready_data);
if (client->debug_destroy)
client->debug_destroy(client->debug_data);
if (client->att) {
bt_att_unregister_disconnect(client->att, client->disc_id);
bt_att_unregister(client->att, client->notify_id);
bt_att_unregister(client->att, client->ind_id);
bt_att_unref(client->att);
}
gatt_db_unref(client->db);
queue_destroy(client->clones, NULL);
queue_destroy(client->svc_chngd_queue, free);
queue_destroy(client->long_write_queue, request_unref);
queue_destroy(client->notify_chrcs, notify_chrc_free);
queue_destroy(client->pending_requests, request_unref);
if (client->parent) {
queue_remove(client->parent->clones, client);
bt_gatt_client_unref(client->parent);
}
free(client);
}
static void att_disconnect_cb(int err, void *user_data)
{
struct bt_gatt_client *client = user_data;
bool in_init = client->in_init;
client->disc_id = 0;
bt_att_unref(client->att);
client->att = NULL;
client->in_init = false;
client->ready = false;
if (in_init)
notify_client_ready(client, false, 0);
}
static struct bt_gatt_client *gatt_client_new(struct gatt_db *db,
struct bt_att *att)
{
struct bt_gatt_client *client;
client = new0(struct bt_gatt_client, 1);
client->disc_id = bt_att_register_disconnect(att, att_disconnect_cb,
client, NULL);
if (!client->disc_id)
goto fail;
client->clones = queue_new();
client->long_write_queue = queue_new();
client->svc_chngd_queue = queue_new();
client->notify_list = queue_new();
client->notify_chrcs = queue_new();
client->pending_requests = queue_new();
client->notify_id = bt_att_register(att, BT_ATT_OP_HANDLE_VAL_NOT,
notify_cb, client, NULL);
if (!client->notify_id)
goto fail;
client->ind_id = bt_att_register(att, BT_ATT_OP_HANDLE_VAL_IND,
notify_cb, client, NULL);
if (!client->ind_id)
goto fail;
client->att = bt_att_ref(att);
client->db = gatt_db_ref(db);
return client;
fail:
bt_gatt_client_free(client);
return NULL;
}
struct bt_gatt_client *bt_gatt_client_new(struct gatt_db *db,
struct bt_att *att,
uint16_t mtu)
{
struct bt_gatt_client *client;
if (!att || !db)
return NULL;
client = gatt_client_new(db, att);
if (!client)
return NULL;
if (!gatt_client_init(client, mtu)) {
bt_gatt_client_free(client);
return NULL;
}
return bt_gatt_client_ref(client);
}
struct bt_gatt_client *bt_gatt_client_clone(struct bt_gatt_client *client)
{
struct bt_gatt_client *clone;
if (!client)
return NULL;
clone = gatt_client_new(client->db, client->att);
if (!clone)
return NULL;
queue_push_tail(client->clones, clone);
/*
* Reference the parent since the clones depend on it to propagate
* service changed and ready callbacks.
*/
clone->parent = bt_gatt_client_ref(client);
clone->ready = client->ready;
return bt_gatt_client_ref(clone);
}
struct bt_gatt_client *bt_gatt_client_ref(struct bt_gatt_client *client)
{
if (!client)
return NULL;
__sync_fetch_and_add(&client->ref_count, 1);
return client;
}
void bt_gatt_client_unref(struct bt_gatt_client *client)
{
if (!client)
return;
if (__sync_sub_and_fetch(&client->ref_count, 1))
return;
bt_gatt_client_free(client);
}
bool bt_gatt_client_is_ready(struct bt_gatt_client *client)
{
return (client && client->ready);
}
bool bt_gatt_client_set_ready_handler(struct bt_gatt_client *client,
bt_gatt_client_callback_t callback,
void *user_data,
bt_gatt_client_destroy_func_t destroy)
{
if (!client)
return false;
if (client->ready_destroy)
client->ready_destroy(client->ready_data);
client->ready_callback = callback;
client->ready_destroy = destroy;
client->ready_data = user_data;
return true;
}
bool bt_gatt_client_set_service_changed(struct bt_gatt_client *client,
bt_gatt_client_service_changed_callback_t callback,
void *user_data,
bt_gatt_client_destroy_func_t destroy)
{
if (!client)
return false;
if (client->svc_chngd_destroy)
client->svc_chngd_destroy(client->svc_chngd_data);
client->svc_chngd_callback = callback;
client->svc_chngd_destroy = destroy;
client->svc_chngd_data = user_data;
return true;
}
bool bt_gatt_client_set_debug(struct bt_gatt_client *client,
bt_gatt_client_debug_func_t callback,
void *user_data,
bt_gatt_client_destroy_func_t destroy) {
if (!client)
return false;
if (client->debug_destroy)
client->debug_destroy(client->debug_data);
client->debug_callback = callback;
client->debug_destroy = destroy;
client->debug_data = user_data;
return true;
}
uint16_t bt_gatt_client_get_mtu(struct bt_gatt_client *client)
{
if (!client || !client->att)
return 0;
return bt_att_get_mtu(client->att);
}
struct gatt_db *bt_gatt_client_get_db(struct bt_gatt_client *client)
{
if (!client || !client->db)
return NULL;
return client->db;
}
static bool match_req_id(const void *a, const void *b)
{
const struct request *req = a;
unsigned int id = PTR_TO_UINT(b);
return req->id == id;
}
static void cancel_long_write_cb(uint8_t opcode, const void *pdu, uint16_t len,
void *user_data)
{
struct bt_gatt_client *client = user_data;
if (queue_isempty(client->long_write_queue))
client->in_long_write = false;
}
static bool cancel_long_write_req(struct bt_gatt_client *client,
struct request *req)
{
uint8_t pdu = 0x00;
/*
* att_id == 0 means that request has been queued and no prepare write
* has been sent so far.Let's just remove if from the queue.
* Otherwise execute write needs to be send.
*/
if (!req->att_id)
return queue_remove(client->long_write_queue, req);
return !!bt_att_send(client->att, BT_ATT_OP_EXEC_WRITE_REQ, &pdu,
sizeof(pdu),
cancel_long_write_cb,
client, NULL);
}
static void cancel_prep_write_cb(uint8_t opcode, const void *pdu, uint16_t len,
void *user_data)
{
struct request *req = user_data;
struct bt_gatt_client *client = req->client;
client->reliable_write_session_id = 0;
}
static bool cancel_prep_write_session(struct bt_gatt_client *client,
struct request *req)
{
uint8_t pdu = 0x00;
return !!bt_att_send(client->att, BT_ATT_OP_EXEC_WRITE_REQ, &pdu,
sizeof(pdu),
cancel_prep_write_cb,
req, request_unref);
}
static bool cancel_request(struct request *req)
{
req->removed = true;
if (req->long_write)
return cancel_long_write_req(req->client, req);
if (req->prep_write)
return cancel_prep_write_session(req->client, req);
return bt_att_cancel(req->client->att, req->att_id);
}
bool bt_gatt_client_cancel(struct bt_gatt_client *client, unsigned int id)
{
struct request *req;
if (!client || !id || !client->att)
return false;
req = queue_remove_if(client->pending_requests, match_req_id,
UINT_TO_PTR(id));
if (!req)
return false;
return cancel_request(req);
}
bool bt_gatt_client_cancel_all(struct bt_gatt_client *client)
{
if (!client || !client->att)
return false;
queue_remove_all(client->pending_requests, NULL, NULL,
(queue_destroy_func_t) cancel_request);
if (client->discovery_req) {
bt_gatt_request_cancel(client->discovery_req);
bt_gatt_request_unref(client->discovery_req);
client->discovery_req = NULL;
}
if (client->mtu_req_id)
bt_att_cancel(client->att, client->mtu_req_id);
return true;
}
struct read_op {
bt_gatt_client_read_callback_t callback;
void *user_data;
bt_gatt_client_destroy_func_t destroy;
};
static void destroy_read_op(void *data)
{
struct read_op *op = data;
if (op->destroy)
op->destroy(op->user_data);
free(op);
}
static void read_cb(uint8_t opcode, const void *pdu, uint16_t length,
void *user_data)
{
struct request *req = user_data;
struct read_op *op = req->data;
bool success;
uint8_t att_ecode = 0;
const uint8_t *value = NULL;
uint16_t value_len = 0;
if (opcode == BT_ATT_OP_ERROR_RSP) {
success = false;
att_ecode = process_error(pdu, length);
goto done;
}
if (opcode != BT_ATT_OP_READ_RSP || (!pdu && length)) {
success = false;
goto done;
}
success = true;
value_len = length;
if (value_len)
value = pdu;
done:
if (op->callback)
op->callback(success, att_ecode, value, length, op->user_data);
}
unsigned int bt_gatt_client_read_value(struct bt_gatt_client *client,
uint16_t value_handle,
bt_gatt_client_read_callback_t callback,
void *user_data,
bt_gatt_client_destroy_func_t destroy)
{
struct request *req;
struct read_op *op;
uint8_t pdu[2];
if (!client)
return 0;
op = new0(struct read_op, 1);
req = request_create(client);
if (!req) {
free(op);
return 0;
}
op->callback = callback;
op->user_data = user_data;
op->destroy = destroy;
req->data = op;
req->destroy = destroy_read_op;
put_le16(value_handle, pdu);
req->att_id = bt_att_send(client->att, BT_ATT_OP_READ_REQ,
pdu, sizeof(pdu),
read_cb, req,
request_unref);
if (!req->att_id) {
op->destroy = NULL;
request_unref(req);
return 0;
}
return req->id;
}
static void read_multiple_cb(uint8_t opcode, const void *pdu, uint16_t length,
void *user_data)
{
struct request *req = user_data;
struct read_op *op = req->data;
uint8_t att_ecode;
bool success;
if (opcode != BT_ATT_OP_READ_MULT_RSP || (!pdu && length)) {
success = false;
if (opcode == BT_ATT_OP_ERROR_RSP)
att_ecode = process_error(pdu, length);
else
att_ecode = 0;
pdu = NULL;
length = 0;
} else {
success = true;
att_ecode = 0;
}
if (op->callback)
op->callback(success, att_ecode, pdu, length, op->user_data);
}
unsigned int bt_gatt_client_read_multiple(struct bt_gatt_client *client,
uint16_t *handles, uint8_t num_handles,
bt_gatt_client_read_callback_t callback,
void *user_data,
bt_gatt_client_destroy_func_t destroy)
{
uint8_t pdu[num_handles * 2];
struct request *req;
struct read_op *op;
int i;
if (!client)
return 0;
if (num_handles < 2)
return 0;
if (num_handles * 2 > bt_att_get_mtu(client->att) - 1)
return 0;
op = new0(struct read_op, 1);
req = request_create(client);
if (!req) {
free(op);
return 0;
}
op->callback = callback;
op->user_data = user_data;
op->destroy = destroy;
req->data = op;
req->destroy = destroy_read_op;
for (i = 0; i < num_handles; i++)
put_le16(handles[i], pdu + (2 * i));
req->att_id = bt_att_send(client->att, BT_ATT_OP_READ_MULT_REQ,
pdu, sizeof(pdu),
read_multiple_cb, req,
request_unref);
if (!req->att_id) {
op->destroy = NULL;
request_unref(req);
return 0;
}
return req->id;
}
struct read_long_op {
struct bt_gatt_client *client;
int ref_count;
uint16_t value_handle;
uint16_t offset;
struct iovec iov;
bt_gatt_client_read_callback_t callback;
void *user_data;
bt_gatt_client_destroy_func_t destroy;
};
static void destroy_read_long_op(void *data)
{
struct read_long_op *op = data;
if (op->destroy)
op->destroy(op->user_data);
free(op->iov.iov_base);
free(op);
}
static bool append_chunk(struct read_long_op *op, const uint8_t *data,
uint16_t len)
{
void *buf;
/* Truncate if the data would exceed maximum length */
if (op->offset + len > BT_ATT_MAX_VALUE_LEN)
len = BT_ATT_MAX_VALUE_LEN - op->offset;
buf = realloc(op->iov.iov_base, op->iov.iov_len + len);
if (!buf)
return false;
op->iov.iov_base = buf;
memcpy(op->iov.iov_base + op->iov.iov_len, data, len);
op->iov.iov_len += len;
op->offset += len;
return true;
}
static void read_long_cb(uint8_t opcode, const void *pdu,
uint16_t length, void *user_data)
{
struct request *req = user_data;
struct read_long_op *op = req->data;
bool success;
uint8_t att_ecode = 0;
if (opcode == BT_ATT_OP_ERROR_RSP) {
success = false;
att_ecode = process_error(pdu, length);
goto done;
}
if ((!op->offset && opcode != BT_ATT_OP_READ_RSP)
|| (op->offset && opcode != BT_ATT_OP_READ_BLOB_RSP)
|| (!pdu && length)) {
success = false;
goto done;
}
if (!length)
goto success;
if (!append_chunk(op, pdu, length)) {
success = false;
goto done;
}
if (op->offset >= BT_ATT_MAX_VALUE_LEN)
goto success;
if (length >= bt_att_get_mtu(op->client->att) - 1) {
uint8_t pdu[4];
put_le16(op->value_handle, pdu);
put_le16(op->offset, pdu + 2);
req->att_id = bt_att_send(op->client->att,
BT_ATT_OP_READ_BLOB_REQ,
pdu, sizeof(pdu),
read_long_cb,
request_ref(req),
request_unref);
if (req->att_id)
return;
request_unref(req);
success = false;
goto done;
}
success:
success = true;
done:
if (op->callback)
op->callback(success, att_ecode, op->iov.iov_base,
op->iov.iov_len, op->user_data);
}
unsigned int bt_gatt_client_read_long_value(struct bt_gatt_client *client,
uint16_t value_handle, uint16_t offset,
bt_gatt_client_read_callback_t callback,
void *user_data,
bt_gatt_client_destroy_func_t destroy)
{
struct request *req;
struct read_long_op *op;
uint8_t att_op;
uint8_t pdu[4];
uint16_t pdu_len;
if (!client)
return 0;
op = new0(struct read_long_op, 1);
req = request_create(client);
if (!req) {
free(op);
return 0;
}
op->client = client;
op->value_handle = value_handle;
op->offset = offset;
op->callback = callback;
op->user_data = user_data;
op->destroy = destroy;
req->data = op;
req->destroy = destroy_read_long_op;
put_le16(value_handle, pdu);
pdu_len = sizeof(value_handle);
/*
* Core v4.2, part F, section 1.3.4.4.5:
* If the attribute value has a fixed length that is less than or equal
* to (ATT_MTU - 3) octets in length, then an Error Response can be sent
* with the error code Ā«Attribute Not LongĀ».
*
* To remove need for caller to handle "Attribute Not Long" error when
* reading characteristics with short values, use Read Request for
* reading first part of characteristics value instead of Read Blob
* Request. Both are allowed in this case.
*/
if (op->offset) {
att_op = BT_ATT_OP_READ_BLOB_REQ;
pdu_len += sizeof(op->offset);
put_le16(op->offset, pdu + 2);
} else {
att_op = BT_ATT_OP_READ_REQ;
}
req->att_id = bt_att_send(client->att, att_op, pdu, pdu_len,
read_long_cb, req, request_unref);
if (!req->att_id) {
op->destroy = NULL;
request_unref(req);
return 0;
}
return req->id;
}
unsigned int bt_gatt_client_write_without_response(
struct bt_gatt_client *client,
uint16_t value_handle,
bool signed_write,
const uint8_t *value, uint16_t length) {
uint8_t pdu[2 + length];
struct request *req;
int security;
uint8_t op;
if (!client)
return 0;
req = request_create(client);
if (!req)
return 0;
/* Only use signed write if unencrypted */
if (signed_write) {
security = bt_att_get_security(client->att);
op = security > BT_SECURITY_LOW ? BT_ATT_OP_WRITE_CMD :
BT_ATT_OP_SIGNED_WRITE_CMD;
} else
op = BT_ATT_OP_WRITE_CMD;
put_le16(value_handle, pdu);
memcpy(pdu + 2, value, length);
req->att_id = bt_att_send(client->att, op, pdu, sizeof(pdu), NULL, req,
request_unref);
if (!req->att_id) {
request_unref(req);
return 0;
}
return req->id;
}
struct write_op {
struct bt_gatt_client *client;
bt_gatt_client_callback_t callback;
void *user_data;
bt_gatt_destroy_func_t destroy;
};
static void destroy_write_op(void *data)
{
struct write_op *op = data;
if (op->destroy)
op->destroy(op->user_data);
free(op);
}
static void write_cb(uint8_t opcode, const void *pdu, uint16_t length,
void *user_data)
{
struct request *req = user_data;
struct write_op *op = req->data;
bool success = true;
uint8_t att_ecode = 0;
if (opcode == BT_ATT_OP_ERROR_RSP) {
success = false;
att_ecode = process_error(pdu, length);
goto done;
}
if (opcode != BT_ATT_OP_WRITE_RSP || pdu || length)
success = false;
done:
if (op->callback)
op->callback(success, att_ecode, op->user_data);
}
unsigned int bt_gatt_client_write_value(struct bt_gatt_client *client,
uint16_t value_handle,
const uint8_t *value, uint16_t length,
bt_gatt_client_callback_t callback,
void *user_data,
bt_gatt_client_destroy_func_t destroy)
{
struct request *req;
struct write_op *op;
uint8_t pdu[2 + length];
if (!client)
return 0;
op = new0(struct write_op, 1);
req = request_create(client);
if (!req) {
free(op);
return 0;
}
op->callback = callback;
op->user_data = user_data;
op->destroy = destroy;
req->data = op;
req->destroy = destroy_write_op;
put_le16(value_handle, pdu);
memcpy(pdu + 2, value, length);
req->att_id = bt_att_send(client->att, BT_ATT_OP_WRITE_REQ,
pdu, sizeof(pdu),
write_cb, req,
request_unref);
if (!req->att_id) {
op->destroy = NULL;
request_unref(req);
return 0;
}
return req->id;
}
struct long_write_op {
struct bt_gatt_client *client;
bool reliable;
bool success;
uint8_t att_ecode;
bool reliable_error;
uint16_t value_handle;
uint8_t *value;
uint16_t length;
uint16_t offset;
uint16_t index;
uint16_t cur_length;
bt_gatt_client_write_long_callback_t callback;
void *user_data;
bt_gatt_client_destroy_func_t destroy;
};
static void long_write_op_free(void *data)
{
struct long_write_op *op = data;
if (op->destroy)
op->destroy(op->user_data);
free(op->value);
free(op);
}
static void prepare_write_cb(uint8_t opcode, const void *pdu, uint16_t length,
void *user_data);
static void complete_write_long_op(struct request *req, bool success,
uint8_t att_ecode, bool reliable_error);
static void handle_next_prep_write(struct request *req)
{
struct long_write_op *op = req->data;
bool success = true;
uint8_t *pdu;
pdu = malloc(op->cur_length + 4);
if (!pdu) {
success = false;
goto done;
}
put_le16(op->value_handle, pdu);
put_le16(op->offset + op->index, pdu + 2);
memcpy(pdu + 4, op->value + op->index, op->cur_length);
req->att_id = bt_att_send(op->client->att, BT_ATT_OP_PREP_WRITE_REQ,
pdu, op->cur_length + 4,
prepare_write_cb,
request_ref(req),
request_unref);
if (!req->att_id) {
request_unref(req);
success = false;
}
free(pdu);
/* If so far successful, then the operation should continue.
* Otherwise, there was an error and the procedure should be
* completed.
*/
if (success)
return;
done:
complete_write_long_op(req, success, 0, false);
}
static void start_next_long_write(struct bt_gatt_client *client)
{
struct request *req;
if (queue_isempty(client->long_write_queue)) {
client->in_long_write = false;
return;
}
req = queue_pop_head(client->long_write_queue);
if (!req)
return;
handle_next_prep_write(req);
/*
* send_next_prep_write adds an extra ref. Unref here to clean up if
* necessary, since we also added a ref before pushing to the queue.
*/
request_unref(req);
}
static void execute_write_cb(uint8_t opcode, const void *pdu, uint16_t length,
void *user_data)
{
struct request *req = user_data;
struct long_write_op *op = req->data;
bool success = op->success;
uint8_t att_ecode = op->att_ecode;
if (opcode == BT_ATT_OP_ERROR_RSP) {
success = false;
att_ecode = process_error(pdu, length);
} else if (opcode != BT_ATT_OP_EXEC_WRITE_RSP || pdu || length)
success = false;
bt_gatt_client_ref(op->client);
if (op->callback)
op->callback(success, op->reliable_error, att_ecode,
op->user_data);
start_next_long_write(op->client);
bt_gatt_client_unref(op->client);
}
static void complete_write_long_op(struct request *req, bool success,
uint8_t att_ecode, bool reliable_error)
{
struct long_write_op *op = req->data;
uint8_t pdu;
op->success = success;
op->att_ecode = att_ecode;
op->reliable_error = reliable_error;
if (success)
pdu = 0x01; /* Write */
else
pdu = 0x00; /* Cancel */
req->att_id = bt_att_send(op->client->att, BT_ATT_OP_EXEC_WRITE_REQ,
&pdu, sizeof(pdu),
execute_write_cb,
request_ref(req),
request_unref);
if (req->att_id)
return;
request_unref(req);
success = false;
bt_gatt_client_ref(op->client);
if (op->callback)
op->callback(success, reliable_error, att_ecode, op->user_data);
start_next_long_write(op->client);
bt_gatt_client_unref(op->client);
}
static void prepare_write_cb(uint8_t opcode, const void *pdu, uint16_t length,
void *user_data)
{
struct request *req = user_data;
struct long_write_op *op = req->data;
bool success = true;
bool reliable_error = false;
uint8_t att_ecode = 0;
uint16_t next_index;
if (opcode == BT_ATT_OP_ERROR_RSP) {
success = false;
att_ecode = process_error(pdu, length);
goto done;
}
if (opcode != BT_ATT_OP_PREP_WRITE_RSP) {
success = false;
goto done;
}
if (op->reliable) {
if (!pdu || length != (op->cur_length + 4)) {
success = false;
reliable_error = true;
goto done;
}
if (get_le16(pdu) != op->value_handle ||
get_le16(pdu + 2) != (op->offset + op->index)) {
success = false;
reliable_error = true;
goto done;
}
if (memcmp(pdu + 4, op->value + op->index, op->cur_length)) {
success = false;
reliable_error = true;
goto done;
}
}
next_index = op->index + op->cur_length;
if (next_index == op->length) {
/* All bytes written */
goto done;
}
/* If the last written length was greater than or equal to what can fit
* inside a PDU, then there is more data to send.
*/
if (op->cur_length >= bt_att_get_mtu(op->client->att) - 5) {
op->index = next_index;
op->cur_length = MIN(op->length - op->index,
bt_att_get_mtu(op->client->att) - 5);
handle_next_prep_write(req);
return;
}
done:
complete_write_long_op(req, success, att_ecode, reliable_error);
}
unsigned int bt_gatt_client_write_long_value(struct bt_gatt_client *client,
bool reliable,
uint16_t value_handle, uint16_t offset,
const uint8_t *value, uint16_t length,
bt_gatt_client_write_long_callback_t callback,
void *user_data,
bt_gatt_client_destroy_func_t destroy)
{
struct request *req;
struct long_write_op *op;
uint8_t *pdu;
if (!client)
return 0;
if ((size_t)(length + offset) > UINT16_MAX)
return 0;
/* Don't allow writing a 0-length value using this procedure. The
* upper-layer should use bt_gatt_write_value for that instead.
*/
if (!length || !value)
return 0;
op = new0(struct long_write_op, 1);
op->value = malloc(length);
if (!op->value) {
free(op);
return 0;
}
req = request_create(client);
if (!req) {
free(op->value);
free(op);
return 0;
}
memcpy(op->value, value, length);
op->client = client;
op->reliable = reliable;
op->value_handle = value_handle;
op->length = length;
op->offset = offset;
op->cur_length = MIN(length, bt_att_get_mtu(client->att) - 5);
op->callback = callback;
op->user_data = user_data;
op->destroy = destroy;
req->data = op;
req->destroy = long_write_op_free;
req->long_write = true;
if (client->in_long_write || client->reliable_write_session_id > 0) {
queue_push_tail(client->long_write_queue, req);
return req->id;
}
pdu = malloc(op->cur_length + 4);
if (!pdu) {
free(op->value);
free(op);
return 0;
}
put_le16(value_handle, pdu);
put_le16(offset, pdu + 2);
memcpy(pdu + 4, op->value, op->cur_length);
req->att_id = bt_att_send(client->att, BT_ATT_OP_PREP_WRITE_REQ,
pdu, op->cur_length + 4,
prepare_write_cb, req,
request_unref);
free(pdu);
if (!req->att_id) {
op->destroy = NULL;
request_unref(req);
return 0;
}
client->in_long_write = true;