sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
46c52132c4
nuttx/wireless/bluetooth/bt_att.c
Alin Jerpelea e36d93f600 wireless: bluetooth: nxstyle fixes 
various nxstyle fixes to fix the CI complains.

Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com>
2020-04-23 19:44:08 +08:00

1942 lines
49 KiB
C
Raw Blame History

/****************************************************************************
* wireless/bluetooth/bt_att.c
* Attribute protocol handling.
*
* Copyright (C) 2018 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* Ported from the Intel/Zephyr arduino101_firmware_source-v1.tar package
* where the code was released with a compatible 3-clause BSD license:
*
* Copyright (c) 2016, Intel Corporation
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS
* ; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <stdbool.h>
#include <string.h>
#include <errno.h>
#include <debug.h>
#include <nuttx/net/bluetooth.h>
#include <nuttx/wireless/bluetooth/bt_hci.h>
#include <nuttx/wireless/bluetooth/bt_core.h>
#include <nuttx/wireless/bluetooth/bt_uuid.h>
#include <nuttx/wireless/bluetooth/bt_gatt.h>
#include "bt_hcicore.h"
#include "bt_conn.h"
#include "bt_l2cap.h"
#include "bt_att.h"
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#if !defined(CONFIG_BLUETOOTH_DEBUG_ATT)
# undef wlinfo
# define wlinfo(fmt, ...)
#endif
#define BT_GATT_PERM_READ_MASK (BT_GATT_PERM_READ | \
BT_GATT_PERM_READ_ENCRYPT | \
BT_GATT_PERM_READ_AUTHEN | \
BT_GATT_PERM_AUTHOR)
#define BT_GATT_PERM_WRITE_MASK (BT_GATT_PERM_WRITE | \
BT_GATT_PERM_WRITE_ENCRYPT | \
BT_GATT_PERM_WRITE_AUTHEN | \
BT_GATT_PERM_AUTHOR)
#define BT_GATT_PERM_ENCRYPT_MASK (BT_GATT_PERM_READ_ENCRYPT | \
BT_GATT_PERM_WRITE_ENCRYPT)
#define BT_GATT_PERM_AUTHEN_MASK (BT_GATT_PERM_READ_AUTHEN | \
BT_GATT_PERM_WRITE_AUTHEN)
#define BT_ATT_OP_CMD_MASK (BT_ATT_OP_WRITE_CMD & \
BT_ATT_OP_SIGNED_WRITE_CMD)
/****************************************************************************
* Private Types
****************************************************************************/
/* ATT request context */
struct bt_att_req_s
{
bt_att_func_t func;
FAR void *user_data;
bt_att_destroy_t destroy;
uint8_t op;
};
/* ATT channel specific context */
struct bt_att_s
{
/* The connection this context is associated with */
FAR struct bt_conn_s *conn;
uint16_t mtu;
struct bt_att_req_s req;
/* TODO: Allow more than one pending request */
};
struct find_info_data_s
{
FAR struct bt_conn_s *conn;
FAR struct bt_buf_s *buf;
FAR struct bt_att_find_info_rsp_s *rsp;
union
{
FAR struct bt_att_info_16_s *info16;
FAR struct bt_att_info_128_s *info128;
} u;
};
struct find_type_data_s
{
FAR struct bt_conn_s *conn;
FAR struct bt_buf_s *buf;
FAR struct bt_att_handle_group_s *group;
FAR const void *value;
uint8_t value_len;
};
struct read_type_data_s
{
FAR struct bt_conn_s *conn;
FAR struct bt_uuid_s *uuid;
FAR struct bt_buf_s *buf;
FAR struct bt_att_read_type_rsp_s *rsp;
FAR struct bt_att_data_s *item;
};
struct read_data_s
{
FAR struct bt_conn_s *conn;
uint16_t offset;
FAR struct bt_buf_s *buf;
FAR struct bt_att_read_rsp_s *rsp;
uint8_t err;
};
struct read_group_data_s
{
FAR struct bt_conn_s *conn;
FAR struct bt_uuid_s *uuid;
FAR struct bt_buf_s *buf;
FAR struct bt_att_read_group_rsp_s *rsp;
FAR struct bt_att_group_data_s *group;
};
struct write_data_s
{
FAR struct bt_conn_s *conn;
FAR struct bt_buf_s *buf;
uint8_t op;
FAR const void *value;
uint8_t len;
uint16_t offset;
uint8_t err;
};
struct flush_data_s
{
FAR struct bt_conn_s *conn;
FAR struct bt_buf_s *buf;
uint8_t flags;
uint8_t err;
};
struct handler_info_s
{
uint8_t op;
CODE uint8_t(*func)(FAR struct bt_conn_s *conn, FAR struct bt_buf_s *buf);
uint8_t expect_len;
};
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
static void att_req_destroy(FAR struct bt_att_req_s *req);
static void send_err_rsp(struct bt_conn_s *conn, uint8_t req,
uint16_t handle, uint8_t err);
static uint8_t att_mtu_req(struct bt_conn_s *conn, struct bt_buf_s *data);
static uint8_t att_handle_rsp(struct bt_conn_s *conn, void *pdu,
uint16_t len, uint8_t err);
static uint8_t att_mtu_rsp(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *buf);
static bool range_is_valid(uint16_t start, uint16_t end,
FAR uint16_t *err);
static uint8_t find_info_cb(FAR const struct bt_gatt_attr_s *attr,
FAR void *user_data);
static uint8_t att_find_info_rsp(FAR struct bt_conn_s *conn,
uint16_t start_handle, uint16_t end_handle);
static uint8_t att_find_info_req(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *data);
static uint8_t find_type_cb(FAR const struct bt_gatt_attr_s *attr,
FAR void *user_data);
static uint8_t att_find_type_rsp(FAR struct bt_conn_s *conn,
FAR uint16_t start_handle, uint16_t end_handle,
FAR const void *value, uint8_t value_len);
static uint8_t att_find_type_req(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *data);
static bool uuid_create(FAR struct bt_uuid_s *uuid,
FAR struct bt_buf_s *data);
static uint8_t read_type_cb(FAR const struct bt_gatt_attr_s *attr,
FAR void *user_data);
static uint8_t att_read_type_rsp(FAR struct bt_conn_s *conn,
FAR struct bt_uuid_s *uuid, uint16_t start_handle,
uint16_t end_handle);
static uint8_t att_read_type_req(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *data);
static uint8_t err_to_att(int err);
static uint8_t check_perm(FAR struct bt_conn_s *conn,
FAR const struct bt_gatt_attr_s *attr, uint8_t mask);
static uint8_t read_cb(FAR const struct bt_gatt_attr_s *attr,
FAR void *user_data);
static uint8_t att_read_rsp(FAR struct bt_conn_s *conn, uint8_t op,
uint8_t rsp, uint16_t handle, uint16_t offset);
static uint8_t att_read_req(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *data);
static uint8_t att_read_blob_req(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *data);
static uint8_t att_read_mult_req(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *buf);
static uint8_t read_group_cb(FAR const struct bt_gatt_attr_s *attr,
FAR void *user_data);
static uint8_t att_read_group_rsp(FAR struct bt_conn_s *conn,
FAR struct bt_uuid_s *uuid, uint16_t start_handle,
uint16_t end_handle);
static uint8_t att_read_group_req(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *data);
static uint8_t write_cb(FAR const struct bt_gatt_attr_s *attr,
FAR void *user_data);
static uint8_t att_write_rsp(FAR struct bt_conn_s *conn, uint8_t op,
uint8_t rsp, uint16_t handle, uint16_t offset,
FAR const void *value, uint8_t len);
static uint8_t att_write_req(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *data);
static uint8_t att_prepare_write_req(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *data);
static uint8_t flush_cb(FAR const struct bt_gatt_attr_s *attr,
FAR void *user_data);
static uint8_t att_exec_write_rsp(FAR struct bt_conn_s *conn,
uint8_t flags);
static uint8_t att_exec_write_req(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *data);
static uint8_t att_write_cmd(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *data);
static uint8_t att_signed_write_cmd(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *data);
static uint8_t att_error_rsp(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *data);
static uint8_t att_handle_find_info_rsp(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *buf);
static uint8_t att_handle_find_type_rsp(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *buf);
static uint8_t att_handle_read_type_rsp(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *buf);
static uint8_t att_handle_read_rsp(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *buf);
static uint8_t att_handle_read_blob_rsp(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *buf);
static uint8_t att_handle_read_mult_rsp(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *buf);
static uint8_t att_handle_write_rsp(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *buf);
static void bt_att_receive(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *buf, FAR void *context, uint16_t cid);
static void bt_att_connected(FAR struct bt_conn_s *conn, FAR void *context,
uint16_t cid);
static void bt_att_disconnected(FAR struct bt_conn_s *conn,
FAR void *context, uint16_t cid);
/****************************************************************************
* Private Data
****************************************************************************/
static struct bt_att_s g_bt_att_pool[CONFIG_BLUETOOTH_MAX_CONN];
static const struct bt_uuid_s g_primary_uuid =
{
BT_UUID_16,
{
BT_UUID_GATT_PRIMARY
}
};
static const struct bt_uuid_s g_secondary_uuid =
{
BT_UUID_16,
{
BT_UUID_GATT_SECONDARY
},
};
static const struct handler_info_s g_handlers[] =
{
{
BT_ATT_OP_ERROR_RSP,
att_error_rsp,
sizeof(struct bt_att_error_rsp_s)
},
{
BT_ATT_OP_MTU_REQ,
att_mtu_req,
sizeof(struct bt_att_exchange_mtu_req_s)
},
{
BT_ATT_OP_MTU_RSP,
att_mtu_rsp,
sizeof(struct bt_att_exchange_mtu_rsp_s)
},
{
BT_ATT_OP_FIND_INFO_REQ,
att_find_info_req,
sizeof(struct bt_att_find_info_req_s)
},
{
BT_ATT_OP_FIND_INFO_RSP,
att_handle_find_info_rsp,
sizeof(struct bt_att_find_info_rsp_s)
},
{
BT_ATT_OP_FIND_TYPE_REQ,
att_find_type_req,
sizeof(struct bt_att_find_type_req_s)
},
{
BT_ATT_OP_FIND_TYPE_RSP,
att_handle_find_type_rsp,
sizeof(struct bt_att_find_type_rsp_s)
},
{
BT_ATT_OP_READ_TYPE_REQ,
att_read_type_req,
sizeof(struct bt_att_read_type_req_s)
},
{
BT_ATT_OP_READ_TYPE_RSP,
att_handle_read_type_rsp,
sizeof(struct bt_att_read_type_rsp_s)
},
{
BT_ATT_OP_READ_REQ,
att_read_req,
sizeof(struct bt_att_read_req_s)
},
{
BT_ATT_OP_READ_RSP,
att_handle_read_rsp,
sizeof(struct bt_att_read_rsp_s)
},
{
BT_ATT_OP_READ_BLOB_REQ,
att_read_blob_req,
sizeof(struct bt_att_read_blob_req_s)
},
{
BT_ATT_OP_READ_BLOB_RSP,
att_handle_read_blob_rsp,
sizeof(struct bt_att_read_blob_rsp_s)
},
{
BT_ATT_OP_READ_MULT_REQ,
att_read_mult_req,
BT_ATT_READ_MULT_MIN_LEN_REQ
},
{
BT_ATT_OP_READ_MULT_RSP,
att_handle_read_mult_rsp,
sizeof(struct bt_att_read_mult_rsp_s)
},
{
BT_ATT_OP_READ_GROUP_REQ,
att_read_group_req,
sizeof(struct bt_att_read_group_req_s)
},
{
BT_ATT_OP_WRITE_REQ,
att_write_req,
sizeof(struct bt_att_write_req_s)
},
{
BT_ATT_OP_WRITE_RSP,
att_handle_write_rsp,
0
},
{
BT_ATT_OP_PREPARE_WRITE_REQ,
att_prepare_write_req,
sizeof(struct bt_att_prepare_write_req_s)
},
{
BT_ATT_OP_EXEC_WRITE_REQ,
att_exec_write_req,
sizeof(struct bt_att_exec_write_req_s)
},
{
BT_ATT_OP_WRITE_CMD,
att_write_cmd,
sizeof(struct bt_att_write_cmd_s)
},
{
BT_ATT_OP_SIGNED_WRITE_CMD,
att_signed_write_cmd,
sizeof(struct bt_att_write_cmd_s) + sizeof(struct bt_att_signature_s)
}
};
#define NHANDLERS (sizeof(g_handlers) / sizeof(struct handler_info_s))
/****************************************************************************
* Private Functions
****************************************************************************/
static void att_req_destroy(FAR struct bt_att_req_s *req)
{
if (req->destroy)
{
req->destroy(req->user_data);
}
memset(req, 0, sizeof(*req));
}
static void send_err_rsp(struct bt_conn_s *conn,
uint8_t req,
uint16_t handle,
uint8_t err)
{
struct bt_att_error_rsp_s *rsp;
struct bt_buf_s *buf;
/* Ignore opcode 0x00 */
if (!req)
{
return;
}
buf = bt_att_create_pdu(conn, BT_ATT_OP_ERROR_RSP, sizeof(*rsp));
if (!buf)
{
return;
}
rsp = bt_buf_extend(buf, sizeof(*rsp));
rsp->request = req;
rsp->handle = BT_HOST2LE16(handle);
rsp->error = err;
bt_l2cap_send(conn, BT_L2CAP_CID_ATT, buf);
}
static uint8_t att_mtu_req(struct bt_conn_s *conn, struct bt_buf_s *data)
{
FAR struct bt_att_s *att = conn->att;
struct bt_att_exchange_mtu_req_s *req;
struct bt_att_exchange_mtu_rsp_s *rsp;
struct bt_buf_s *buf;
uint16_t maxmtu;
uint16_t mtu;
req = (void *)data->data;
mtu = BT_LE162HOST(req->mtu);
wlinfo("Client MTU %u\n", mtu);
if (mtu > BT_ATT_MAX_LE_MTU || mtu < BT_ATT_DEFAULT_LE_MTU)
{
return BT_ATT_ERR_INVALID_PDU;
}
buf = bt_att_create_pdu(conn, BT_ATT_OP_MTU_RSP, sizeof(*rsp));
if (!buf)
{
return BT_ATT_ERR_UNLIKELY;
}
/* Select MTU based on the amount of room we have in bt_buf_s including one
* extra byte for ATT header.
*/
maxmtu = bt_buf_tailroom(buf) + 1;
if (mtu > maxmtu)
{
mtu = maxmtu;
}
wlinfo("Server MTU %u\n", mtu);
att->mtu = mtu;
rsp = bt_buf_extend(buf, sizeof(*rsp));
rsp->mtu = BT_HOST2LE16(mtu);
bt_l2cap_send(conn, BT_L2CAP_CID_ATT, buf);
return 0;
}
static uint8_t att_handle_rsp(struct bt_conn_s *conn,
void *pdu,
uint16_t len,
uint8_t err)
{
FAR struct bt_att_s *att = conn->att;
struct bt_att_req_s req;
if (!att->req.func)
{
return 0;
}
/* Reset request before callback so another request can be queued */
memcpy(&req, &att->req, sizeof(req));
att->req.func = NULL;
req.func(conn, err, pdu, len, req.user_data);
att_req_destroy(&req);
return 0;
}
static uint8_t att_mtu_rsp(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *buf)
{
FAR struct bt_att_s *att = conn->att;
FAR struct bt_att_exchange_mtu_rsp_s *rsp;
uint16_t maxmtu;
uint16_t mtu;
if (!att)
{
return 0;
}
rsp = (void *)buf->data;
mtu = BT_LE162HOST(rsp->mtu);
wlinfo("Server MTU %u\n", mtu);
/* Check if MTU is within allowed range */
if (mtu > BT_ATT_MAX_LE_MTU || mtu < BT_ATT_DEFAULT_LE_MTU)
{
return att_handle_rsp(conn, NULL, 0, BT_ATT_ERR_INVALID_PDU);
}
/* Clip MTU based on the maximum amount of data bt_buf_s can hold excluding
* L2CAP, ACL and driver headers.
*/
maxmtu = BLUETOOTH_MAX_FRAMELEN - (sizeof(struct bt_l2cap_hdr_s) +
sizeof(struct bt_hci_acl_hdr_s) +
g_btdev.btdev->head_reserve);
if (mtu > maxmtu)
{
mtu = maxmtu;
}
att->mtu = mtu;
return att_handle_rsp(conn, rsp, buf->len, 0);
}
static bool range_is_valid(uint16_t start, uint16_t end, FAR uint16_t *err)
{
/* Handle 0 is invalid */
if (!start || !end)
{
if (err)
{
*err = 0;
}
return false;
}
/* Check if range is valid */
if (start > end)
{
if (err)
{
*err = start;
}
return false;
}
return true;
}
static uint8_t find_info_cb(FAR const struct bt_gatt_attr_s *attr,
FAR void *user_data)
{
FAR struct find_info_data_s *data = user_data;
FAR struct bt_att_s *att = data->conn->att;
wlinfo("handle 0x%04x\n", attr->handle);
/* Initialize rsp at first entry */
if (!data->rsp)
{
data->rsp = bt_buf_extend(data->buf, sizeof(*data->rsp));
data->rsp->format = (attr->uuid->type == BT_UUID_16) ?
BT_ATT_INFO_16 : BT_ATT_INFO_128;
}
switch (data->rsp->format)
{
case BT_ATT_INFO_16:
if (attr->uuid->type != BT_UUID_16)
{
return BT_GATT_ITER_STOP;
}
/* Fast forward to next item position */
data->u.info16 = bt_buf_extend(data->buf,
sizeof(*data->u.info16));
data->u.info16->handle = BT_HOST2LE16(attr->handle);
data->u.info16->uuid = BT_HOST2LE16(attr->uuid->u.u16);
return att->mtu - data->buf->len > sizeof(*data->u.info16) ?
BT_GATT_ITER_CONTINUE : BT_GATT_ITER_STOP;
case BT_ATT_INFO_128:
if (attr->uuid->type != BT_UUID_128)
{
return BT_GATT_ITER_STOP;
}
/* Fast forward to next item position */
data->u.info128 = bt_buf_extend(data->buf,
sizeof(*data->u.info128));
data->u.info128->handle = BT_HOST2LE16(attr->handle);
memcpy(data->u.info128->uuid,
attr->uuid->u.u128,
sizeof(data->u.info128->uuid));
return att->mtu - data->buf->len > sizeof(*data->u.info128) ?
BT_GATT_ITER_CONTINUE : BT_GATT_ITER_STOP;
}
return BT_GATT_ITER_STOP;
}
static uint8_t att_find_info_rsp(FAR struct bt_conn_s *conn,
uint16_t start_handle,
uint16_t end_handle)
{
struct find_info_data_s data;
memset(&data, 0, sizeof(data));
data.buf = bt_att_create_pdu(conn, BT_ATT_OP_FIND_INFO_RSP, 0);
if (!data.buf)
{
return BT_ATT_ERR_UNLIKELY;
}
data.conn = conn;
bt_gatt_foreach_attr(start_handle, end_handle, find_info_cb, &data);
if (!data.rsp)
{
bt_buf_release(data.buf);
/* Respond since handle is set */
send_err_rsp(conn, BT_ATT_OP_FIND_INFO_REQ, start_handle,
BT_ATT_ERR_ATTRIBUTE_NOT_FOUND);
return 0;
}
bt_l2cap_send(conn, BT_L2CAP_CID_ATT, data.buf);
return 0;
}
static uint8_t att_find_info_req(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *data)
{
FAR struct bt_att_find_info_req_s *req;
uint16_t start_handle;
uint16_t end_handle;
uint16_t err_handle;
req = (void *)data->data;
start_handle = BT_LE162HOST(req->start_handle);
end_handle = BT_LE162HOST(req->end_handle);
wlinfo("start_handle 0x%04x end_handle 0x%04x\n",
start_handle, end_handle);
if (!range_is_valid(start_handle, end_handle, &err_handle))
{
send_err_rsp(conn, BT_ATT_OP_FIND_INFO_REQ, err_handle,
BT_ATT_ERR_INVALID_HANDLE);
return 0;
}
return att_find_info_rsp(conn, start_handle, end_handle);
}
static uint8_t find_type_cb(FAR const struct bt_gatt_attr_s *attr,
FAR void *user_data)
{
FAR struct find_type_data_s *data = user_data;
FAR struct bt_att_s *att = data->conn->att;
uint8_t uuid[16];
int read;
/* Skip if not a primary service */
if (bt_uuid_cmp(attr->uuid, &g_primary_uuid))
{
if (data->group && attr->handle > data->group->end_handle)
{
data->group->end_handle = BT_HOST2LE16(attr->handle);
}
return BT_GATT_ITER_CONTINUE;
}
wlinfo("handle 0x%04x\n", attr->handle);
/* Stop if there is no space left */
if (att->mtu - data->buf->len < sizeof(*data->group))
{
return BT_GATT_ITER_STOP;
}
/* Read attribute value and store in the buffer */
read = attr->read(data->conn, attr, uuid, sizeof(uuid), 0);
if (read < 0)
{
/* TODO: Return an error if this fails */
return BT_GATT_ITER_STOP;
}
/* Check if data matches */
if (read != data->value_len || memcmp(data->value, uuid, read))
{
/* If a group exists stop otherwise continue */
return data->group ? BT_GATT_ITER_STOP : BT_GATT_ITER_CONTINUE;
}
/* Fast forward to next item position */
data->group = bt_buf_extend(data->buf, sizeof(*data->group));
data->group->start_handle = BT_HOST2LE16(attr->handle);
data->group->end_handle = BT_HOST2LE16(attr->handle);
/* Continue to find the end_handle */
return BT_GATT_ITER_CONTINUE;
}
static uint8_t att_find_type_rsp(FAR struct bt_conn_s *conn,
FAR uint16_t start_handle,
uint16_t end_handle,
FAR const void *value,
uint8_t value_len)
{
struct find_type_data_s data;
memset(&data, 0, sizeof(data));
data.buf = bt_att_create_pdu(conn, BT_ATT_OP_FIND_TYPE_RSP, 0);
if (!data.buf)
{
return BT_ATT_ERR_UNLIKELY;
}
data.conn = conn;
data.value = value;
data.value_len = value_len;
bt_gatt_foreach_attr(start_handle, end_handle, find_type_cb, &data);
if (!data.group)
{
bt_buf_release(data.buf);
/* Respond since handle is set */
send_err_rsp(conn, BT_ATT_OP_FIND_TYPE_REQ, start_handle,
BT_ATT_ERR_ATTRIBUTE_NOT_FOUND);
return 0;
}
bt_l2cap_send(conn, BT_L2CAP_CID_ATT, data.buf);
return 0;
}
static uint8_t att_find_type_req(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *data)
{
FAR struct bt_att_find_type_req_s *req;
FAR uint8_t *value;
uint16_t start_handle;
uint16_t end_handle;
uint16_t err_handle;
uint16_t type;
req = (FAR void *)data->data;
start_handle = BT_LE162HOST(req->start_handle);
end_handle = BT_LE162HOST(req->end_handle);
type = BT_LE162HOST(req->type);
value = bt_buf_consume(data, sizeof(*req));
wlinfo("start_handle 0x%04x end_handle 0x%04x type %u\n", start_handle,
end_handle, type);
if (!range_is_valid(start_handle, end_handle, &err_handle))
{
send_err_rsp(conn, BT_ATT_OP_FIND_TYPE_REQ, err_handle,
BT_ATT_ERR_INVALID_HANDLE);
return 0;
}
/* The Attribute Protocol Find By Type Value Request shall be used with the
* Attribute Type parameter set to the UUID for «Primary Service» and the
* Attribute Value set to the 16-bit Bluetooth UUID or 128-bit UUID for the
* specific primary service.
*/
if (type != BT_UUID_GATT_PRIMARY)
{
send_err_rsp(conn, BT_ATT_OP_FIND_TYPE_REQ, start_handle,
BT_ATT_ERR_ATTRIBUTE_NOT_FOUND);
return 0;
}
return att_find_type_rsp(conn, start_handle, end_handle, value, data->len);
}
static bool uuid_create(FAR struct bt_uuid_s *uuid,
FAR struct bt_buf_s *data)
{
if (data->len > sizeof(uuid->u.u128))
{
return false;
}
switch (data->len)
{
case 2:
uuid->type = BT_UUID_16;
uuid->u.u16 = bt_buf_get_le16(data);
return true;
case 16:
uuid->type = BT_UUID_128;
memcpy(uuid->u.u128, data->data, data->len);
return true;
}
return false;
}
static uint8_t read_type_cb(FAR const struct bt_gatt_attr_s *attr,
FAR void *user_data)
{
FAR struct read_type_data_s *data = user_data;
FAR struct bt_att_s *att = data->conn->att;
int read;
/* Skip if doesn't match */
if (bt_uuid_cmp(attr->uuid, data->uuid))
{
return BT_GATT_ITER_CONTINUE;
}
wlinfo("handle 0x%04x\n", attr->handle);
/* Fast forward to next item position */
data->item = bt_buf_extend(data->buf, sizeof(*data->item));
data->item->handle = BT_HOST2LE16(attr->handle);
/* Read attribute value and store in the buffer */
read = attr->read(data->conn, attr, data->buf->data + data->buf->len,
att->mtu - data->buf->len, 0);
if (read < 0)
{
/* TODO: Handle read errors */
return BT_GATT_ITER_STOP;
}
if (!data->rsp->len)
{
/* Set len to be the first item found */
data->rsp->len = read + sizeof(*data->item);
}
else if (data->rsp->len != read + sizeof(*data->item))
{
/* All items should have the same size */
data->buf->len -= sizeof(*data->item);
return BT_GATT_ITER_STOP;
}
bt_buf_extend(data->buf, read);
/* Return true only if there are still space for more items */
return att->mtu - data->buf->len > data->rsp->len ?
BT_GATT_ITER_CONTINUE : BT_GATT_ITER_STOP;
}
static uint8_t att_read_type_rsp(FAR struct bt_conn_s *conn,
FAR struct bt_uuid_s *uuid,
uint16_t start_handle,
uint16_t end_handle)
{
struct read_type_data_s data;
memset(&data, 0, sizeof(data));
data.buf = bt_att_create_pdu(conn, BT_ATT_OP_READ_TYPE_RSP,
sizeof(*data.rsp));
if (!data.buf)
{
return BT_ATT_ERR_UNLIKELY;
}
data.conn = conn;
data.uuid = uuid;
data.rsp = bt_buf_extend(data.buf, sizeof(*data.rsp));
data.rsp->len = 0;
bt_gatt_foreach_attr(start_handle, end_handle, read_type_cb, &data);
if (!data.rsp->len)
{
bt_buf_release(data.buf);
/* Response here since handle is set */
send_err_rsp(conn, BT_ATT_OP_READ_TYPE_REQ, start_handle,
BT_ATT_ERR_ATTRIBUTE_NOT_FOUND);
return 0;
}
bt_l2cap_send(conn, BT_L2CAP_CID_ATT, data.buf);
return 0;
}
static uint8_t att_read_type_req(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *data)
{
FAR struct bt_att_read_type_req_s *req;
struct bt_uuid_s uuid;
uint16_t start_handle;
uint16_t end_handle;
uint16_t err_handle;
/* Type can only be UUID16 or UUID128 */
if (data->len != sizeof(*req) + sizeof(uuid.u.u16) &&
data->len != sizeof(*req) + sizeof(uuid.u.u128))
{
return BT_ATT_ERR_INVALID_PDU;
}
req = (FAR void *)data->data;
start_handle = BT_LE162HOST(req->start_handle);
end_handle = BT_LE162HOST(req->end_handle);
bt_buf_consume(data, sizeof(*req));
if (!uuid_create(&uuid, data))
{
return BT_ATT_ERR_UNLIKELY;
}
wlinfo("start_handle 0x%04x end_handle 0x%04x type %u\n",
start_handle, end_handle, uuid.u.u16);
if (!range_is_valid(start_handle, end_handle, &err_handle))
{
send_err_rsp(conn, BT_ATT_OP_READ_TYPE_REQ, err_handle,
BT_ATT_ERR_INVALID_HANDLE);
return 0;
}
return att_read_type_rsp(conn, &uuid, start_handle, end_handle);
}
static uint8_t err_to_att(int err)
{
wlinfo("%d", err);
switch (err)
{
case -EINVAL:
return BT_ATT_ERR_INVALID_OFFSET;
case -EFBIG:
return BT_ATT_ERR_INVALID_ATTRIBUTE_LEN;
default:
return BT_ATT_ERR_UNLIKELY;
}
}
static uint8_t check_perm(FAR struct bt_conn_s *conn,
FAR const struct bt_gatt_attr_s *attr,
uint8_t mask)
{
if ((mask & BT_GATT_PERM_READ) && !(attr->perm & BT_GATT_PERM_READ))
{
return BT_ATT_ERR_READ_NOT_PERMITTED;
}
if ((mask & BT_GATT_PERM_WRITE) && !(attr->perm & BT_GATT_PERM_WRITE))
{
return BT_ATT_ERR_READ_NOT_PERMITTED;
}
mask &= attr->perm;
if (mask & BT_GATT_PERM_AUTHEN_MASK)
{
/* TODO: Check conn authentication */
return BT_ATT_ERR_AUTHENTICATION;
}
if ((mask & BT_GATT_PERM_ENCRYPT_MASK) && !conn->encrypt)
{
return BT_ATT_ERR_INSUFFICIENT_ENCRYPTION;
}
if (mask & BT_GATT_PERM_AUTHOR)
{
return BT_ATT_ERR_AUTHORIZATION;
}
return 0;
}
static uint8_t read_cb(FAR const struct bt_gatt_attr_s *attr,
FAR void *user_data)
{
FAR struct read_data_s *data = user_data;
FAR struct bt_att_s *att = data->conn->att;
int read;
wlinfo("handle 0x%04x\n", attr->handle);
data->rsp = bt_buf_extend(data->buf, sizeof(*data->rsp));
if (!attr->read)
{
data->err = BT_ATT_ERR_READ_NOT_PERMITTED;
return BT_GATT_ITER_STOP;
}
/* Check attribute permissions */
data->err = check_perm(data->conn, attr, BT_GATT_PERM_READ_MASK);
if (data->err)
{
return BT_GATT_ITER_STOP;
}
/* Read attribute value and store in the buffer */
read = attr->read(data->conn, attr, data->buf->data + data->buf->len,
att->mtu - data->buf->len, data->offset);
if (read < 0)
{
data->err = err_to_att(read);
return BT_GATT_ITER_STOP;
}
bt_buf_extend(data->buf, read);
return BT_GATT_ITER_CONTINUE;
}
static uint8_t att_read_rsp(FAR struct bt_conn_s *conn, uint8_t op,
uint8_t rsp, uint16_t handle, uint16_t offset)
{
struct read_data_s data;
if (!handle)
{
return BT_ATT_ERR_INVALID_HANDLE;
}
memset(&data, 0, sizeof(data));
data.buf = bt_att_create_pdu(conn, rsp, 0);
if (!data.buf)
{
return BT_ATT_ERR_UNLIKELY;
}
data.conn = conn;
data.offset = offset;
bt_gatt_foreach_attr(handle, handle, read_cb, &data);
/* In case of error discard data and respond with an error */
if (data.err)
{
bt_buf_release(data.buf);
/* Respond here since handle is set */
send_err_rsp(conn, op, handle, data.err);
return 0;
}
bt_l2cap_send(conn, BT_L2CAP_CID_ATT, data.buf);
return 0;
}
static uint8_t att_read_req(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *data)
{
FAR struct bt_att_read_req_s *req;
uint16_t handle;
req = (void *)data->data;
handle = BT_LE162HOST(req->handle);
wlinfo("handle 0x%04x\n", handle);
return att_read_rsp(conn,
BT_ATT_OP_READ_REQ,
BT_ATT_OP_READ_RSP,
handle,
0);
}
static uint8_t att_read_blob_req(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *data)
{
FAR struct bt_att_read_blob_req_s *req;
uint16_t handle;
uint16_t offset;
req = (FAR void *)data->data;
handle = BT_LE162HOST(req->handle);
offset = BT_LE162HOST(req->offset);
wlinfo("handle 0x%04x offset %u\n", handle, offset);
return att_read_rsp(conn, BT_ATT_OP_READ_BLOB_REQ,
BT_ATT_OP_READ_BLOB_RSP, handle, offset);
}
static uint8_t att_read_mult_req(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *buf)
{
struct read_data_s data;
uint16_t handle;
memset(&data, 0, sizeof(data));
data.buf = bt_att_create_pdu(conn, BT_ATT_OP_READ_MULT_RSP, 0);
if (!data.buf)
{
return BT_ATT_ERR_UNLIKELY;
}
data.conn = conn;
while (buf->len >= sizeof(uint16_t))
{
handle = bt_buf_get_le16(buf);
wlinfo("handle 0x%04x \n", handle);
bt_gatt_foreach_attr(handle, handle, read_cb, &data);
/* Stop reading in case of error */
if (data.err)
{
bt_buf_release(data.buf);
/* Respond here since handle is set */
send_err_rsp(conn, BT_ATT_OP_READ_MULT_REQ, handle, data.err);
return 0;
}
}
bt_l2cap_send(conn, BT_L2CAP_CID_ATT, data.buf);
return 0;
}
static uint8_t read_group_cb(FAR const struct bt_gatt_attr_s *attr,
FAR void *user_data)
{
FAR struct read_group_data_s *data = user_data;
FAR struct bt_att_s *att = data->conn->att;
int read;
/* If UUID don't match update group end_handle */
if (bt_uuid_cmp(attr->uuid, data->uuid))
{
if (data->group && attr->handle > data->group->end_handle)
{
data->group->end_handle = BT_HOST2LE16(attr->handle);
}
return BT_GATT_ITER_CONTINUE;
}
wlinfo("handle 0x%04x\n", attr->handle);
/* Stop if there is no space left */
if (data->rsp->len && att->mtu - data->buf->len < data->rsp->len)
{
return BT_GATT_ITER_STOP;
}
/* Fast forward to next group position */
data->group = bt_buf_extend(data->buf, sizeof(*data->group));
/* Initialize group handle range */
data->group->start_handle = BT_HOST2LE16(attr->handle);
data->group->end_handle = BT_HOST2LE16(attr->handle);
/* Read attribute value and store in the buffer */
read = attr->read(data->conn, attr, data->buf->data + data->buf->len,
att->mtu - data->buf->len, 0);
if (read < 0)
{
/* TODO: Handle read errors */
return BT_GATT_ITER_STOP;
}
if (!data->rsp->len)
{
/* Set len to be the first group found */
data->rsp->len = read + sizeof(*data->group);
}
else if (data->rsp->len != read + sizeof(*data->group))
{
/* All groups entries should have the same size */
data->buf->len -= sizeof(*data->group);
return false;
}
bt_buf_extend(data->buf, read);
/* Continue to find the end handle */
return BT_GATT_ITER_CONTINUE;
}
static uint8_t att_read_group_rsp(FAR struct bt_conn_s *conn,
FAR struct bt_uuid_s *uuid,
uint16_t start_handle,
uint16_t end_handle)
{
struct read_group_data_s data;
memset(&data, 0, sizeof(data));
data.buf = bt_att_create_pdu(conn, BT_ATT_OP_READ_GROUP_RSP,
sizeof(*data.rsp));
if (!data.buf)
{
return BT_ATT_ERR_UNLIKELY;
}
data.conn = conn;
data.uuid = uuid;
data.rsp = bt_buf_extend(data.buf, sizeof(*data.rsp));
data.rsp->len = 0;
bt_gatt_foreach_attr(start_handle, end_handle, read_group_cb, &data);
if (!data.rsp->len)
{
bt_buf_release(data.buf);
/* Respond here since handle is set */
send_err_rsp(conn, BT_ATT_OP_READ_GROUP_REQ, start_handle,
BT_ATT_ERR_ATTRIBUTE_NOT_FOUND);
return 0;
}
bt_l2cap_send(conn, BT_L2CAP_CID_ATT, data.buf);
return 0;
}
static uint8_t att_read_group_req(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *data)
{
FAR struct bt_att_read_group_req_s *req;
struct bt_uuid_s uuid;
uint16_t start_handle;
uint16_t end_handle;
uint16_t err_handle;
/* Type can only be UUID16 or UUID128 */
if (data->len != sizeof(*req) + sizeof(uuid.u.u16) &&
data->len != sizeof(*req) + sizeof(uuid.u.u128))
{
return BT_ATT_ERR_INVALID_PDU;
}
req = (FAR void *)data->data;
start_handle = BT_LE162HOST(req->start_handle);
end_handle = BT_LE162HOST(req->end_handle);
bt_buf_consume(data, sizeof(*req));
if (!uuid_create(&uuid, data))
{
return BT_ATT_ERR_UNLIKELY;
}
wlinfo("start_handle 0x%04x end_handle 0x%04x type %u\n",
start_handle, end_handle, uuid.u.u16);
if (!range_is_valid(start_handle, end_handle, &err_handle))
{
send_err_rsp(conn, BT_ATT_OP_READ_GROUP_REQ, err_handle,
BT_ATT_ERR_INVALID_HANDLE);
return 0;
}
/* Core v4.2, Vol 3, sec 2.5.3 Attribute Grouping: Not all of the grouping
* attributes can be used in the ATT Read By Group Type Request. The
* «Primary Service» and «Secondary Service» grouping types may be used
* in the Read By Group Type Request. The «Characteristic» grouping type
* shall not be used in the ATT Read By Group Type Request.
*/
if (bt_uuid_cmp(&uuid, &g_primary_uuid) &&
bt_uuid_cmp(&uuid, &g_secondary_uuid))
{
send_err_rsp(conn, BT_ATT_OP_READ_GROUP_REQ, start_handle,
BT_ATT_ERR_UNSUPPORTED_GROUP_TYPE);
return 0;
}
return att_read_group_rsp(conn, &uuid, start_handle, end_handle);
}
static uint8_t write_cb(FAR const struct bt_gatt_attr_s *attr,
FAR void *user_data)
{
FAR struct write_data_s *data = user_data;
int write;
wlinfo("handle 0x%04x\n", attr->handle);
/* Check for write support and flush support in case of prepare */
if (!attr->write ||
(data->op == BT_ATT_OP_PREPARE_WRITE_REQ && !attr->flush))
{
data->err = BT_ATT_ERR_WRITE_NOT_PERMITTED;
return BT_GATT_ITER_STOP;
}
/* Check attribute permissions */
data->err = check_perm(data->conn, attr, BT_GATT_PERM_WRITE_MASK);
if (data->err)
{
return BT_GATT_ITER_STOP;
}
/* Read attribute value and store in the buffer */
write = attr->write(data->conn,
attr,
data->value,
data->len,
data->offset);
if (write < 0 || write != data->len)
{
data->err = err_to_att(write);
return BT_GATT_ITER_STOP;
}
/* Flush in case of regular write operation */
if (attr->flush && data->op != BT_ATT_OP_PREPARE_WRITE_REQ)
{
write = attr->flush(data->conn, attr, BT_GATT_FLUSH_SYNC);
if (write < 0)
{
data->err = err_to_att(write);
return BT_GATT_ITER_STOP;
}
}
data->err = 0;
return BT_GATT_ITER_CONTINUE;
}
static uint8_t att_write_rsp(FAR struct bt_conn_s *conn, uint8_t op,
uint8_t rsp, uint16_t handle,
uint16_t offset, FAR const void *value,
uint8_t len)
{
struct write_data_s data;
if (!handle)
{
return BT_ATT_ERR_INVALID_HANDLE;
}
memset(&data, 0, sizeof(data));
/* Only allocate buf if required to respond */
if (rsp)
{
data.buf = bt_att_create_pdu(conn, rsp, 0);
if (!data.buf)
{
return BT_ATT_ERR_UNLIKELY;
}
}
data.conn = conn;
data.op = op;
data.offset = offset;
data.value = value;
data.len = len;
data.err = BT_ATT_ERR_INVALID_HANDLE;
bt_gatt_foreach_attr(handle, handle, write_cb, &data);
/* In case of error discard data and respond with an error */
if (data.err)
{
if (rsp)
{
bt_buf_release(data.buf);
/* Respond here since handle is set */
send_err_rsp(conn, op, handle, data.err);
}
return 0;
}
if (data.buf)
{
/* Add prepare write response */
if (rsp == BT_ATT_OP_PREPARE_WRITE_RSP)
{
FAR struct bt_att_prepare_write_rsp_s *wrrsp;
wrrsp = bt_buf_extend(data.buf, sizeof(*wrrsp));
wrrsp->handle = BT_HOST2LE16(handle);
wrrsp->offset = BT_HOST2LE16(offset);
bt_buf_extend(data.buf, len);
memcpy(wrrsp->value, value, len);
}
bt_l2cap_send(conn, BT_L2CAP_CID_ATT, data.buf);
}
return 0;
}
static uint8_t att_write_req(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *data)
{
FAR struct bt_att_write_req_s *req;
uint16_t handle;
req = (FAR void *)data->data;
handle = BT_LE162HOST(req->handle);
bt_buf_consume(data, sizeof(*req));
wlinfo("handle 0x%04x\n", handle);
return att_write_rsp(conn, BT_ATT_OP_WRITE_REQ, BT_ATT_OP_WRITE_RSP,
handle, 0, data->data, data->len);
}
static uint8_t att_prepare_write_req(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *data)
{
FAR struct bt_att_prepare_write_req_s *req;
uint16_t handle;
uint16_t offset;
req = (FAR void *)data->data;
handle = BT_LE162HOST(req->handle);
offset = BT_LE162HOST(req->offset);
bt_buf_consume(data, sizeof(*req));
wlinfo("handle 0x%04x offset %u\n", handle, offset);
return att_write_rsp(conn, BT_ATT_OP_PREPARE_WRITE_REQ,
BT_ATT_OP_PREPARE_WRITE_RSP, handle, offset,
data->data, data->len);
}
typedef CODE uint8_t
(*bt_gatt_attr_func_t)(FAR const struct bt_gatt_attr_s *attr,
FAR void *user_data);
static uint8_t flush_cb(FAR const struct bt_gatt_attr_s *attr,
FAR void *user_data)
{
FAR struct flush_data_s *data = user_data;
int err;
/* If attribute cannot be flushed continue to next */
if (!attr->flush)
{
return BT_GATT_ITER_CONTINUE;
}
wlinfo("handle 0x%04x flags 0x%02x\n", attr->handle, data->flags);
/* Flush attribute any data cached to be written */
err = attr->flush(data->conn, attr, data->flags);
if (err < 0)
{
data->err = err_to_att(err);
return BT_GATT_ITER_STOP;
}
data->err = 0;
return BT_GATT_ITER_CONTINUE;
}
static uint8_t att_exec_write_rsp(FAR struct bt_conn_s *conn, uint8_t flags)
{
struct flush_data_s data;
memset(&data, 0, sizeof(data));
data.buf = bt_att_create_pdu(conn, BT_ATT_OP_EXEC_WRITE_RSP, 0);
if (!data.buf)
{
return BT_ATT_ERR_UNLIKELY;
}
data.conn = conn;
data.flags = flags;
/* Apply to the whole database */
bt_gatt_foreach_attr(0x0000, 0xffff, flush_cb, &data);
/* In case of error discard data */
if (data.err)
{
bt_buf_release(data.buf);
return data.err;
}
bt_l2cap_send(conn, BT_L2CAP_CID_ATT, data.buf);
return 0;
}
static uint8_t att_exec_write_req(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *data)
{
FAR struct bt_att_exec_write_req_s *req;
req = (FAR void *)data->data;
wlinfo("flags 0x%02x\n", req->flags);
return att_exec_write_rsp(conn, req->flags);
}
static uint8_t att_write_cmd(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *data)
{
FAR struct bt_att_write_cmd_s *req;
uint16_t handle;
if (data->len < sizeof(*req))
{
/* Commands don't have any response */
return 0;
}
req = (FAR void *)data->data;
handle = BT_LE162HOST(req->handle);
wlinfo("handle 0x%04x\n", handle);
return att_write_rsp(conn, 0, 0, handle, 0, data->data, data->len);
}
static uint8_t att_signed_write_cmd(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *data)
{
FAR struct bt_att_signed_write_cmd_s *req;
uint16_t handle;
req = (FAR void *)data->data;
handle = BT_LE162HOST(req->handle);
bt_buf_consume(data, sizeof(*req));
wlinfo("handle 0x%04x\n", handle);
/* TODO: Validate signature */
return att_write_rsp(conn, 0, 0, handle, 0, data->data,
data->len - sizeof(struct bt_att_signature_s));
}
static uint8_t att_error_rsp(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *data)
{
FAR struct bt_att_s *att = conn->att;
FAR struct bt_att_error_rsp_s *rsp;
uint8_t err;
rsp = (FAR void *)data->data;
wlinfo("request 0x%02x handle 0x%04x error 0x%02x\n",
rsp->request, BT_LE162HOST(rsp->handle), rsp->error);
/* Match request with response */
err = rsp->request == att->req.op ? rsp->error : BT_ATT_ERR_UNLIKELY;
return att_handle_rsp(conn, NULL, 0, err);
}
static uint8_t att_handle_find_info_rsp(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *buf)
{
wlinfo("\n");
return att_handle_rsp(conn, buf->data, buf->len, 0);
}
static uint8_t att_handle_find_type_rsp(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *buf)
{
wlinfo("\n");
return att_handle_rsp(conn, buf->data, buf->len, 0);
}
static uint8_t att_handle_read_type_rsp(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *buf)
{
wlinfo("\n");
return att_handle_rsp(conn, buf->data, buf->len, 0);
}
static uint8_t att_handle_read_rsp(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *buf)
{
wlinfo("\n");
return att_handle_rsp(conn, buf->data, buf->len, 0);
}
static uint8_t att_handle_read_blob_rsp(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *buf)
{
wlinfo("\n");
return att_handle_rsp(conn, buf->data, buf->len, 0);
}
static uint8_t att_handle_read_mult_rsp(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *buf)
{
wlinfo("\n");
return att_handle_rsp(conn, buf->data, buf->len, 0);
}
static uint8_t att_handle_write_rsp(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *buf)
{
wlinfo("\n");
return att_handle_rsp(conn, buf->data, buf->len, 0);
}
static void bt_att_receive(FAR struct bt_conn_s *conn,
FAR struct bt_buf_s *buf, FAR void *context,
uint16_t cid)
{
FAR struct bt_att_hdr_s *hdr = (FAR void *)buf->data;
uint8_t err = BT_ATT_ERR_NOT_SUPPORTED;
size_t i;
DEBUGASSERT(conn->att);
if (buf->len < sizeof(*hdr))
{
wlerr("ERROR: Too small ATT PDU received\n");
goto done;
}
wlinfo("Received ATT code 0x%02x len %u\n", hdr->code, buf->len);
bt_buf_consume(buf, sizeof(*hdr));
for (i = 0; i < NHANDLERS; i++)
{
if (hdr->code != g_handlers[i].op)
{
continue;
}
if (buf->len < g_handlers[i].expect_len)
{
wlerr("ERROR: Invalid len %u for code 0x%02x\n",
buf->len, hdr->code);
err = BT_ATT_ERR_INVALID_PDU;
break;
}
err = g_handlers[i].func(conn, buf);
break;
}
/* Commands don't have response */
if ((hdr->code & BT_ATT_OP_CMD_MASK))
{
goto done;
}
if (err)
{
wlinfo("ATT error 0x%02x", err);
send_err_rsp(conn, hdr->code, 0, err);
}
done:
bt_buf_release(buf);
}
static void bt_att_connected(FAR struct bt_conn_s *conn, FAR void *context,
uint16_t cid)
{
int i;
wlinfo("conn %p handle %u\n", conn, conn->handle);
for (i = 0; i < CONFIG_BLUETOOTH_MAX_CONN; i++)
{
FAR struct bt_att_s *att = &g_bt_att_pool[i];
if (!att->conn)
{
att->conn = conn;
conn->att = att;
att->mtu = BT_ATT_DEFAULT_LE_MTU;
bt_gatt_connected(conn);
return;
}
}
wlerr("ERROR: No available ATT context for conn %p\n", conn);
}
static void bt_att_disconnected(FAR struct bt_conn_s *conn,
FAR void *context, uint16_t cid)
{
FAR struct bt_att_s *att = conn->att;
if (!att)
{
return;
}
wlinfo("conn %p handle %u\n", conn, conn->handle);
conn->att = NULL;
memset(att, 0, sizeof(*att));
bt_gatt_disconnected(conn);
}
/****************************************************************************
* Public Functions
****************************************************************************/
void bt_att_initialize(void)
{
static struct bt_l2cap_chan_s chan =
{
.cid = BT_L2CAP_CID_ATT,
.receive = bt_att_receive,
.connected = bt_att_connected,
.disconnected = bt_att_disconnected,
};
bt_l2cap_chan_register(&chan);
}
FAR struct bt_buf_s *bt_att_create_pdu(FAR struct bt_conn_s *conn,
uint8_t op,
size_t len)
{
FAR struct bt_att_hdr_s *hdr;
FAR struct bt_buf_s *buf;
FAR FAR struct bt_att_s *att = conn->att;
if (len + sizeof(op) > att->mtu)
{
wlwarn("ATT MTU exceeded, max %u, wanted %u\n", att->mtu, len);
return NULL;
}
buf = bt_l2cap_create_pdu(conn);
if (!buf)
{
return NULL;
}
hdr = bt_buf_extend(buf, sizeof(*hdr));
hdr->code = op;
return buf;
}
int bt_att_send(FAR struct bt_conn_s *conn, FAR struct bt_buf_s *buf,
bt_att_func_t func, FAR void *user_data,
bt_att_destroy_t destroy)
{
FAR struct bt_att_s *att;
if (!conn)
{
return -EINVAL;
}
att = conn->att;
if (!att)
{
return -ENOTCONN;
}
if (func)
{
FAR struct bt_att_hdr_s *hdr;
/* Check if there is a request pending */
if (att->req.func)
{
/* TODO: Allow more than one pending request */
return -EBUSY;
}
hdr = (void *)buf->data;
att->req.op = hdr->code;
att->req.func = func;
att->req.user_data = user_data;
att->req.destroy = destroy;
}
bt_l2cap_send(conn, BT_L2CAP_CID_ATT, buf);
return 0;
}
void bt_att_cancel(FAR struct bt_conn_s *conn)
{
FAR struct bt_att_s *att;
if (!conn)
{
return;
}
att = conn->att;
if (!att)
{
return;
}
att_req_destroy(&att->req);
}
Reference in New Issue View Git Blame Copy Permalink