/*
|
* Licensed to the Apache Software Foundation (ASF) under one
|
* or more contributor license agreements. See the NOTICE file
|
* distributed with this work for additional information
|
* regarding copyright ownership. The ASF licenses this file
|
* to you under the Apache License, Version 2.0 (the
|
* "License"); you may not use this file except in compliance
|
* with the License. You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing,
|
* software distributed under the License is distributed on an
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
* KIND, either express or implied. See the License for the
|
* specific language governing permissions and limitations
|
* under the License.
|
*/
|
|
#include <stddef.h>
|
#include <errno.h>
|
#include <string.h>
|
#include "testutil/testutil.h"
|
#include "nimble/hci_common.h"
|
#include "ble_hs_test.h"
|
#include "host/ble_uuid.h"
|
#include "ble_hs_test_util.h"
|
|
static uint8_t *ble_att_svr_test_attr_r_1;
|
static uint16_t ble_att_svr_test_attr_r_1_len;
|
static uint8_t *ble_att_svr_test_attr_r_2;
|
static uint16_t ble_att_svr_test_attr_r_2_len;
|
|
static uint8_t ble_att_svr_test_attr_w_1[1024];
|
static uint16_t ble_att_svr_test_attr_w_1_len;
|
static uint8_t ble_att_svr_test_attr_w_2[1024];
|
static uint16_t ble_att_svr_test_attr_w_2_len;
|
|
static uint16_t ble_att_svr_test_n_conn_handle;
|
static uint16_t ble_att_svr_test_n_attr_handle;
|
static uint8_t ble_att_svr_test_attr_n[1024];
|
static uint16_t ble_att_svr_test_attr_n_len;
|
|
static void
|
ble_att_svr_test_assert_mbufs_freed(void)
|
{
|
/* When checking for mbuf leaks, ensure no stale prep entries. */
|
static const struct ble_hs_test_util_mbuf_params mbuf_params = {
|
.prev_tx = 1,
|
.rx_queue = 1,
|
.prep_list = 0,
|
};
|
|
ble_hs_test_util_assert_mbufs_freed(&mbuf_params);
|
}
|
|
static int
|
ble_att_svr_test_misc_gap_cb(struct ble_gap_event *event, void *arg)
|
{
|
int rc;
|
|
switch (event->type) {
|
case BLE_GAP_EVENT_NOTIFY_RX:
|
ble_att_svr_test_n_conn_handle = event->notify_rx.conn_handle;
|
ble_att_svr_test_n_attr_handle = event->notify_rx.attr_handle;
|
TEST_ASSERT_FATAL(OS_MBUF_PKTLEN(event->notify_rx.om) <=
|
sizeof ble_att_svr_test_attr_n);
|
ble_att_svr_test_attr_n_len = OS_MBUF_PKTLEN(event->notify_rx.om);
|
rc = os_mbuf_copydata(event->notify_rx.om, 0,
|
ble_att_svr_test_attr_n_len,
|
ble_att_svr_test_attr_n);
|
TEST_ASSERT_FATAL(rc == 0);
|
break;
|
|
default:
|
break;
|
}
|
|
return 0;
|
}
|
|
/**
|
* @return The handle of the new test connection.
|
*/
|
static uint16_t
|
ble_att_svr_test_misc_init(uint16_t mtu)
|
{
|
struct ble_l2cap_chan *chan;
|
struct ble_hs_conn *conn;
|
int rc;
|
|
ble_hs_test_util_init();
|
|
ble_hs_test_util_create_conn(2, ((uint8_t[]){2,3,4,5,6,7,8,9}),
|
ble_att_svr_test_misc_gap_cb, NULL);
|
|
ble_hs_lock();
|
|
rc = ble_hs_misc_conn_chan_find(2, BLE_L2CAP_CID_ATT, &conn, &chan);
|
TEST_ASSERT_FATAL(rc == 0);
|
|
if (mtu != 0) {
|
chan->my_mtu = mtu;
|
chan->peer_mtu = mtu;
|
chan->flags |= BLE_L2CAP_CHAN_F_TXED_MTU;
|
}
|
|
ble_hs_unlock();
|
|
ble_att_svr_test_attr_r_1_len = 0;
|
ble_att_svr_test_attr_r_2_len = 0;
|
ble_att_svr_test_attr_w_1_len = 0;
|
|
return 2;
|
}
|
|
static int
|
ble_att_svr_test_misc_attr_fn_r_1(uint16_t conn_handle, uint16_t attr_handle,
|
uint8_t op, uint16_t offset,
|
struct os_mbuf **om, void *arg)
|
{
|
int rc;
|
|
switch (op) {
|
case BLE_ATT_ACCESS_OP_READ:
|
if (offset > ble_att_svr_test_attr_r_1_len) {
|
return BLE_ATT_ERR_INVALID_OFFSET;
|
}
|
|
rc = os_mbuf_append(*om, ble_att_svr_test_attr_r_1 + offset,
|
ble_att_svr_test_attr_r_1_len - offset);
|
TEST_ASSERT_FATAL(rc == 0);
|
return 0;
|
|
default:
|
return BLE_ATT_ERR_UNLIKELY;
|
}
|
}
|
|
static int
|
ble_att_svr_test_misc_attr_fn_r_2(uint16_t conn_handle, uint16_t attr_handle,
|
uint8_t op, uint16_t offset,
|
struct os_mbuf **om, void *arg)
|
{
|
int rc;
|
|
switch (op) {
|
case BLE_ATT_ACCESS_OP_READ:
|
if (offset > ble_att_svr_test_attr_r_2_len) {
|
return BLE_ATT_ERR_INVALID_OFFSET;
|
}
|
|
rc = os_mbuf_append(*om, ble_att_svr_test_attr_r_2 + offset,
|
ble_att_svr_test_attr_r_2_len - offset);
|
TEST_ASSERT_FATAL(rc == 0);
|
return 0;
|
|
default:
|
return BLE_ATT_ERR_UNLIKELY;
|
}
|
}
|
|
static int
|
ble_att_svr_test_misc_attr_fn_r_err(uint16_t conn_handle, uint16_t attr_handle,
|
uint8_t op, uint16_t offset,
|
struct os_mbuf **om, void *arg)
|
{
|
int rc;
|
|
rc = os_mbuf_append(*om, (uint8_t[4]){1,2,3,4}, 4);
|
TEST_ASSERT_FATAL(rc == 0);
|
|
return BLE_ATT_ERR_UNLIKELY;
|
}
|
|
#define BLE_ATT_SVR_TEST_LAST_SVC 11
|
#define BLE_ATT_SVR_TEST_LAST_ATTR 24
|
|
static int
|
ble_att_svr_test_misc_attr_fn_r_group(uint16_t conn_handle,
|
uint16_t attr_handle,
|
uint8_t op,
|
uint16_t offset,
|
struct os_mbuf **om,
|
void *arg)
|
{
|
uint8_t *src;
|
int rc;
|
|
/* Service 0x1122 from 1 to 5 */
|
/* Service 0x2233 from 6 to 10 */
|
/* Service 010203...0f from 11 to 24 */
|
|
static uint8_t vals[25][16] = {
|
[1] = { 0x22, 0x11 },
|
[2] = { 0x01, 0x11 },
|
[3] = { 0x02, 0x11 },
|
[4] = { 0x03, 0x11 },
|
[5] = { 0x04, 0x11 },
|
[6] = { 0x33, 0x22 },
|
[7] = { 0x01, 0x22 },
|
[8] = { 0x02, 0x22 },
|
[9] = { 0x03, 0x22 },
|
[10] = { 0x04, 0x22 },
|
[11] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16 },
|
[12] = { 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 },
|
[13] = { 0xdd, 0xdd },
|
[14] = { 0x55, 0x55 },
|
[15] = { 0xdd, 0xdd },
|
[16] = { 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2 },
|
[17] = { 0xdd, 0xdd },
|
[18] = { 0x66, 0x66 },
|
[19] = { 0xdd, 0xdd },
|
[20] = { 0x77, 0x77 },
|
[21] = { 0xdd, 0xdd },
|
[22] = { 0x88, 0x88 },
|
[23] = { 0xdd, 0xdd },
|
[24] = { 0x99, 0x99 },
|
};
|
|
static uint8_t zeros[14];
|
|
if (op != BLE_ATT_ACCESS_OP_READ) {
|
return -1;
|
}
|
|
TEST_ASSERT_FATAL(attr_handle >= 1 &&
|
attr_handle <= BLE_ATT_SVR_TEST_LAST_ATTR);
|
|
src = &vals[attr_handle][0];
|
if (memcmp(src + 2, zeros, 14) == 0) {
|
rc = os_mbuf_append(*om, src, 2);
|
} else {
|
rc = os_mbuf_append(*om, src, 16);
|
}
|
if (rc != 0) {
|
return BLE_ATT_ERR_INSUFFICIENT_RES;
|
}
|
|
return 0;
|
}
|
|
static void
|
ble_att_svr_test_misc_register_uuid(const ble_uuid_t *uuid, uint8_t flags,
|
uint16_t expected_handle,
|
ble_att_svr_access_fn *fn)
|
{
|
uint16_t handle;
|
int rc;
|
|
rc = ble_att_svr_register(uuid, flags, 0, &handle, fn, NULL);
|
TEST_ASSERT_FATAL(rc == 0);
|
TEST_ASSERT_FATAL(handle == expected_handle);
|
}
|
|
static void
|
ble_att_svr_test_misc_register_group_attrs(void)
|
{
|
/* Service 0x1122 from 1 to 5 */
|
/* Service 0x2233 from 6 to 10 */
|
/* Service 010203...0f from 11 to 24 */
|
|
static const ble_uuid16_t uuid_svc =
|
BLE_UUID16_INIT(BLE_ATT_UUID_PRIMARY_SERVICE);
|
static const ble_uuid16_t uuid_inc =
|
BLE_UUID16_INIT(BLE_ATT_UUID_INCLUDE);
|
static const ble_uuid16_t uuid_chr =
|
BLE_UUID16_INIT(BLE_ATT_UUID_CHARACTERISTIC);
|
static ble_uuid16_t uuids[24];
|
|
int i;
|
|
/* Service 0x1122 from 1 to 5 */
|
ble_att_svr_test_misc_register_uuid(&uuid_svc.u, HA_FLAG_PERM_RW, 1,
|
ble_att_svr_test_misc_attr_fn_r_group);
|
for (i = 2; i <= 5; i++) {
|
if ((i - 2) % 2 == 0) {
|
ble_att_svr_test_misc_register_uuid(&uuid_chr.u, HA_FLAG_PERM_RW, i,
|
ble_att_svr_test_misc_attr_fn_r_group);
|
} else {
|
uuids[i] = *BLE_UUID16(BLE_UUID16_DECLARE(i));
|
ble_att_svr_test_misc_register_uuid(&uuids[i].u, HA_FLAG_PERM_RW, i,
|
ble_att_svr_test_misc_attr_fn_r_group);
|
}
|
}
|
|
/* Service 0x2233 from 6 to 10 */
|
ble_att_svr_test_misc_register_uuid(&uuid_svc.u, HA_FLAG_PERM_RW, 6,
|
ble_att_svr_test_misc_attr_fn_r_group);
|
for (i = 7; i <= 10; i++) {
|
ble_att_svr_test_misc_register_uuid(&uuid_inc.u, HA_FLAG_PERM_RW, i,
|
ble_att_svr_test_misc_attr_fn_r_group);
|
}
|
|
/* Service 010203...0f from 11 to 24 */
|
ble_att_svr_test_misc_register_uuid(&uuid_svc.u, HA_FLAG_PERM_RW, 11,
|
ble_att_svr_test_misc_attr_fn_r_group);
|
for (i = 12; i <= 24; i++) {
|
if ((i - 12) % 2 == 0) {
|
ble_att_svr_test_misc_register_uuid(&uuid_chr.u, HA_FLAG_PERM_RW, i,
|
ble_att_svr_test_misc_attr_fn_r_group);
|
} else {
|
uuids[i] = *BLE_UUID16(BLE_UUID16_DECLARE(i));
|
ble_att_svr_test_misc_register_uuid(&uuids[i].u, HA_FLAG_PERM_RW, i,
|
ble_att_svr_test_misc_attr_fn_r_group);
|
}
|
}
|
}
|
|
static int
|
ble_att_svr_test_misc_attr_fn_rw_1(uint16_t conn_handle, uint16_t attr_handle,
|
uint8_t op, uint16_t offset,
|
struct os_mbuf **om, void *arg)
|
{
|
int rc;
|
|
switch (op) {
|
case BLE_ATT_ACCESS_OP_READ:
|
if (offset > ble_att_svr_test_attr_w_1_len) {
|
return BLE_ATT_ERR_INVALID_OFFSET;
|
}
|
|
rc = os_mbuf_append(*om, ble_att_svr_test_attr_w_1 + offset,
|
ble_att_svr_test_attr_w_1_len - offset);
|
TEST_ASSERT_FATAL(rc == 0);
|
return 0;
|
|
case BLE_ATT_ACCESS_OP_WRITE:
|
rc = os_mbuf_copydata(*om, 0, OS_MBUF_PKTLEN(*om),
|
ble_att_svr_test_attr_w_1);
|
TEST_ASSERT_FATAL(rc == 0);
|
ble_att_svr_test_attr_w_1_len = OS_MBUF_PKTLEN(*om);
|
return 0;
|
|
default:
|
return BLE_ATT_ERR_UNLIKELY;
|
}
|
}
|
|
static int
|
ble_att_svr_test_misc_attr_fn_w_1(uint16_t conn_handle, uint16_t attr_handle,
|
uint8_t op, uint16_t offset,
|
struct os_mbuf **om, void *arg)
|
{
|
int rc;
|
|
switch (op) {
|
case BLE_ATT_ACCESS_OP_WRITE:
|
rc = os_mbuf_copydata(*om, 0, OS_MBUF_PKTLEN(*om),
|
ble_att_svr_test_attr_w_1);
|
TEST_ASSERT_FATAL(rc == 0);
|
ble_att_svr_test_attr_w_1_len = OS_MBUF_PKTLEN(*om);
|
return 0;
|
|
default:
|
return BLE_ATT_ERR_UNLIKELY;
|
}
|
}
|
|
static int
|
ble_att_svr_test_misc_attr_fn_w_2(uint16_t conn_handle, uint16_t attr_handle,
|
uint8_t op, uint16_t offset,
|
struct os_mbuf **om, void *arg)
|
{
|
int rc;
|
|
switch (op) {
|
case BLE_ATT_ACCESS_OP_WRITE:
|
rc = os_mbuf_copydata(*om, 0, OS_MBUF_PKTLEN(*om),
|
ble_att_svr_test_attr_w_2);
|
TEST_ASSERT_FATAL(rc == 0);
|
ble_att_svr_test_attr_w_2_len = OS_MBUF_PKTLEN(*om);
|
return 0;
|
|
default:
|
return BLE_ATT_ERR_UNLIKELY;
|
}
|
}
|
|
static int
|
ble_att_svr_test_misc_attr_fn_w_fail(uint16_t conn_handle,
|
uint16_t attr_handle,
|
uint8_t op, uint16_t offset,
|
struct os_mbuf **om, void *arg)
|
{
|
return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
|
}
|
|
static void
|
ble_att_svr_test_misc_verify_w_1(void *data, int data_len)
|
{
|
TEST_ASSERT(ble_att_svr_test_attr_w_1_len == data_len);
|
TEST_ASSERT(memcmp(ble_att_svr_test_attr_w_1, data, data_len) == 0);
|
}
|
|
static void
|
ble_att_svr_test_misc_verify_w_2(void *data, int data_len)
|
{
|
TEST_ASSERT(ble_att_svr_test_attr_w_2_len == data_len);
|
TEST_ASSERT(memcmp(ble_att_svr_test_attr_w_2, data, data_len) == 0);
|
}
|
|
static void
|
ble_att_svr_test_misc_rx_read_mult_req(uint16_t conn_handle,
|
uint16_t *handles, int num_handles,
|
int success)
|
{
|
int rc;
|
|
rc = ble_hs_test_util_rx_att_read_mult_req(conn_handle, handles,
|
num_handles);
|
if (success) {
|
TEST_ASSERT(rc == 0);
|
} else {
|
TEST_ASSERT(rc != 0);
|
}
|
}
|
|
static void
|
ble_att_svr_test_misc_verify_tx_read_mult_rsp(
|
uint16_t conn_handle, struct ble_hs_test_util_flat_attr *attrs,
|
int num_attrs)
|
{
|
struct ble_l2cap_chan *chan;
|
struct os_mbuf *om;
|
uint16_t attr_len;
|
uint16_t mtu;
|
uint8_t u8;
|
int rc;
|
int off;
|
int i;
|
|
om = ble_hs_test_util_prev_tx_dequeue();
|
|
rc = os_mbuf_copydata(om, 0, 1, &u8);
|
TEST_ASSERT(rc == 0);
|
TEST_ASSERT(u8 == BLE_ATT_OP_READ_MULT_RSP);
|
|
ble_hs_lock();
|
|
rc = ble_hs_misc_conn_chan_find(conn_handle, BLE_L2CAP_CID_ATT,
|
NULL, &chan);
|
TEST_ASSERT_FATAL(rc == 0);
|
mtu = ble_att_chan_mtu(chan);
|
|
ble_hs_unlock();
|
|
off = 1;
|
for (i = 0; i < num_attrs; i++) {
|
attr_len = min(attrs[i].value_len, mtu - off);
|
|
rc = os_mbuf_cmpf(om, off, attrs[i].value, attr_len);
|
TEST_ASSERT(rc == 0);
|
|
off += attr_len;
|
}
|
|
TEST_ASSERT(OS_MBUF_PKTLEN(om) == off);
|
}
|
|
static void
|
ble_att_svr_test_misc_verify_all_read_mult(
|
uint16_t conn_handle, struct ble_hs_test_util_flat_attr *attrs,
|
int num_attrs)
|
{
|
uint16_t handles[256];
|
int i;
|
|
TEST_ASSERT_FATAL(num_attrs <= sizeof handles / sizeof handles[0]);
|
|
for (i = 0; i < num_attrs; i++) {
|
handles[i] = attrs[i].handle;
|
}
|
|
ble_att_svr_test_misc_rx_read_mult_req(conn_handle, handles, num_attrs, 1);
|
ble_att_svr_test_misc_verify_tx_read_mult_rsp(conn_handle,
|
attrs, num_attrs);
|
}
|
|
static void
|
ble_att_svr_test_misc_verify_tx_mtu_rsp(uint16_t conn_handle)
|
{
|
struct ble_l2cap_chan *chan;
|
struct ble_hs_conn *conn;
|
uint16_t my_mtu;
|
int rc;
|
|
ble_hs_lock();
|
|
rc = ble_att_conn_chan_find(conn_handle, &conn, &chan);
|
assert(rc == 0);
|
my_mtu = chan->my_mtu;
|
|
ble_hs_unlock();
|
|
ble_hs_test_util_verify_tx_mtu_cmd(0, my_mtu);
|
}
|
|
struct ble_att_svr_test_type_value_entry {
|
uint16_t first; /* 0 on last entry */
|
uint16_t last;
|
};
|
|
static void
|
ble_att_svr_test_misc_verify_tx_find_type_value_rsp(
|
struct ble_att_svr_test_type_value_entry *entries)
|
{
|
struct ble_att_svr_test_type_value_entry *entry;
|
struct os_mbuf *om;
|
uint16_t u16;
|
uint8_t op;
|
int off;
|
int rc;
|
|
off = 0;
|
|
om = ble_hs_test_util_prev_tx_dequeue_pullup();
|
|
rc = os_mbuf_copydata(om, off, 1, &op);
|
TEST_ASSERT(rc == 0);
|
off += 1;
|
|
TEST_ASSERT(op == BLE_ATT_OP_FIND_TYPE_VALUE_RSP);
|
|
for (entry = entries; entry->first != 0; entry++) {
|
rc = os_mbuf_copydata(om, off, 2, &u16);
|
TEST_ASSERT(rc == 0);
|
put_le16(&u16, u16);
|
TEST_ASSERT(u16 == entry->first);
|
off += 2;
|
|
rc = os_mbuf_copydata(om, off, 2, &u16);
|
TEST_ASSERT(rc == 0);
|
put_le16(&u16, u16);
|
TEST_ASSERT(u16 == entry->last);
|
off += 2;
|
}
|
|
/* Ensure there is no extra data in the response. */
|
TEST_ASSERT(off == OS_MBUF_PKTHDR(om)->omp_len);
|
}
|
|
/** Returns the number of entries successfully verified. */
|
|
struct ble_att_svr_test_type_entry {
|
uint16_t handle; /* 0 on last entry */
|
void *value;
|
int value_len;
|
};
|
|
/** Returns the number of entries successfully verified. */
|
static void
|
ble_att_svr_test_misc_verify_tx_read_type_rsp(
|
struct ble_att_svr_test_type_entry *entries)
|
{
|
struct ble_att_svr_test_type_entry *entry;
|
struct ble_att_read_type_rsp rsp;
|
struct os_mbuf *om;
|
uint16_t handle;
|
uint8_t buf[512];
|
int off;
|
int rc;
|
|
om = ble_hs_test_util_prev_tx_dequeue_pullup();
|
TEST_ASSERT(om);
|
|
ble_att_read_type_rsp_parse(om->om_data, om->om_len, &rsp);
|
|
off = BLE_ATT_READ_TYPE_RSP_BASE_SZ;
|
for (entry = entries; entry->handle != 0; entry++) {
|
TEST_ASSERT_FATAL(rsp.batp_length ==
|
BLE_ATT_READ_TYPE_ADATA_BASE_SZ + entry->value_len);
|
|
rc = os_mbuf_copydata(om, off, 2, &handle);
|
TEST_ASSERT(rc == 0);
|
handle = get_le16(&handle);
|
TEST_ASSERT(handle == entry->handle);
|
off += 2;
|
|
rc = os_mbuf_copydata(om, off, entry->value_len, buf);
|
TEST_ASSERT(rc == 0);
|
TEST_ASSERT(memcmp(entry->value, buf, entry->value_len) == 0);
|
off += entry->value_len;
|
}
|
|
/* Ensure there is no extra data in the response. */
|
TEST_ASSERT(off == OS_MBUF_PKTLEN(om));
|
}
|
|
static void
|
ble_att_svr_test_misc_verify_tx_prep_write_rsp(uint16_t attr_handle,
|
uint16_t offset,
|
void *data, int data_len)
|
{
|
struct ble_att_prep_write_cmd rsp;
|
struct os_mbuf *om;
|
uint8_t buf[1024];
|
int rc;
|
|
om = ble_hs_test_util_prev_tx_dequeue();
|
|
rc = os_mbuf_copydata(om, 0, OS_MBUF_PKTLEN(om), buf);
|
TEST_ASSERT_FATAL(rc == 0);
|
|
ble_att_prep_write_rsp_parse(buf, sizeof buf, &rsp);
|
|
TEST_ASSERT(rsp.bapc_handle == attr_handle);
|
TEST_ASSERT(rsp.bapc_offset == offset);
|
TEST_ASSERT(memcmp(buf + BLE_ATT_PREP_WRITE_CMD_BASE_SZ, data,
|
data_len) == 0);
|
|
TEST_ASSERT(OS_MBUF_PKTLEN(om) ==
|
BLE_ATT_PREP_WRITE_CMD_BASE_SZ + data_len);
|
}
|
|
static void
|
ble_att_svr_test_misc_verify_tx_exec_write_rsp(void)
|
{
|
struct os_mbuf *om;
|
|
om = ble_hs_test_util_prev_tx_dequeue_pullup();
|
TEST_ASSERT(om);
|
|
ble_att_exec_write_rsp_parse(om->om_data, om->om_len);
|
}
|
|
static void
|
ble_att_svr_test_misc_mtu_exchange(uint16_t my_mtu, uint16_t peer_sent,
|
uint16_t peer_actual, uint16_t chan_mtu)
|
{
|
struct ble_att_mtu_cmd req;
|
struct ble_l2cap_chan *chan;
|
struct ble_hs_conn *conn;
|
uint16_t conn_handle;
|
uint8_t buf[BLE_ATT_MTU_CMD_SZ];
|
int rc;
|
|
conn_handle = ble_att_svr_test_misc_init(my_mtu);
|
|
req.bamc_mtu = peer_sent;
|
ble_att_mtu_req_write(buf, sizeof buf, &req);
|
|
rc = ble_hs_test_util_l2cap_rx_payload_flat(conn_handle, BLE_L2CAP_CID_ATT,
|
buf, sizeof buf);
|
TEST_ASSERT(rc == 0);
|
|
ble_att_svr_test_misc_verify_tx_mtu_rsp(conn_handle);
|
|
ble_hs_lock();
|
rc = ble_hs_misc_conn_chan_find(conn_handle, BLE_L2CAP_CID_ATT,
|
&conn, &chan);
|
TEST_ASSERT_FATAL(rc == 0);
|
TEST_ASSERT(chan->peer_mtu == peer_actual);
|
TEST_ASSERT(ble_att_chan_mtu(chan) == chan_mtu);
|
ble_hs_unlock();
|
|
}
|
|
static void
|
ble_att_svr_test_misc_prep_write(uint16_t conn_handle, uint16_t attr_handle,
|
uint16_t offset, void *data,
|
int data_len, uint8_t error_code)
|
{
|
int rc;
|
|
rc = ble_hs_test_util_rx_att_prep_write_req(conn_handle, attr_handle,
|
offset, data, data_len);
|
if (error_code == 0) {
|
TEST_ASSERT(rc == 0);
|
ble_att_svr_test_misc_verify_tx_prep_write_rsp(attr_handle, offset,
|
data, data_len);
|
} else {
|
TEST_ASSERT(rc != 0);
|
ble_hs_test_util_verify_tx_err_rsp(BLE_ATT_OP_PREP_WRITE_REQ,
|
attr_handle, error_code);
|
}
|
}
|
|
static void
|
ble_att_svr_test_misc_exec_write(uint16_t conn_handle, uint8_t flags,
|
uint8_t error_code, uint16_t error_handle)
|
{
|
int rc;
|
|
rc = ble_hs_test_util_rx_att_exec_write_req(conn_handle, flags);
|
if (error_code == 0) {
|
TEST_ASSERT(rc == 0);
|
ble_att_svr_test_misc_verify_tx_exec_write_rsp();
|
} else {
|
TEST_ASSERT(rc != 0);
|
ble_hs_test_util_verify_tx_err_rsp(BLE_ATT_OP_EXEC_WRITE_REQ,
|
error_handle, error_code);
|
}
|
}
|
|
static void
|
ble_att_svr_test_misc_rx_notify(uint16_t conn_handle, uint16_t attr_handle,
|
void *attr_val, int attr_len, int good)
|
{
|
struct ble_att_notify_req req;
|
uint8_t buf[1024];
|
int off;
|
int rc;
|
|
req.banq_handle = attr_handle;
|
ble_att_notify_req_write(buf, sizeof buf, &req);
|
off = BLE_ATT_NOTIFY_REQ_BASE_SZ;
|
|
memcpy(buf + off, attr_val, attr_len);
|
off += attr_len;
|
|
rc = ble_hs_test_util_l2cap_rx_payload_flat(conn_handle, BLE_L2CAP_CID_ATT,
|
buf, off);
|
if (good) {
|
TEST_ASSERT(rc == 0);
|
} else {
|
TEST_ASSERT(rc == BLE_HS_EBADDATA);
|
}
|
}
|
|
static void
|
ble_att_svr_test_misc_verify_notify(uint16_t conn_handle, uint16_t attr_handle,
|
void *attr_val, int attr_len, int good)
|
{
|
ble_att_svr_test_n_conn_handle = 0xffff;
|
ble_att_svr_test_n_attr_handle = 0;
|
ble_att_svr_test_attr_n_len = 0;
|
|
ble_att_svr_test_misc_rx_notify(conn_handle, attr_handle, attr_val,
|
attr_len, good);
|
|
if (good) {
|
TEST_ASSERT(ble_att_svr_test_n_conn_handle == conn_handle);
|
TEST_ASSERT(ble_att_svr_test_n_attr_handle == attr_handle);
|
TEST_ASSERT(ble_att_svr_test_attr_n_len == attr_len);
|
TEST_ASSERT(memcmp(ble_att_svr_test_attr_n, attr_val, attr_len) == 0);
|
} else {
|
TEST_ASSERT(ble_att_svr_test_n_conn_handle == 0xffff);
|
TEST_ASSERT(ble_att_svr_test_n_attr_handle == 0);
|
TEST_ASSERT(ble_att_svr_test_attr_n_len == 0);
|
}
|
}
|
|
static void
|
ble_att_svr_test_misc_verify_tx_indicate_rsp(void)
|
{
|
struct os_mbuf *om;
|
|
om = ble_hs_test_util_prev_tx_dequeue_pullup();
|
TEST_ASSERT(om);
|
|
ble_att_indicate_rsp_parse(om->om_data, om->om_len);
|
}
|
|
static void
|
ble_att_svr_test_misc_rx_indicate(uint16_t conn_handle, uint16_t attr_handle,
|
void *attr_val, int attr_len, int good)
|
{
|
int rc;
|
|
rc = ble_hs_test_util_rx_att_indicate_req(conn_handle, attr_handle,
|
attr_val, attr_len);
|
if (good) {
|
TEST_ASSERT(rc == 0);
|
} else {
|
TEST_ASSERT(rc == BLE_HS_EBADDATA);
|
}
|
}
|
|
static void
|
ble_att_svr_test_misc_verify_indicate(uint16_t conn_handle,
|
uint16_t attr_handle,
|
void *attr_val, int attr_len, int good)
|
{
|
ble_att_svr_test_n_conn_handle = 0xffff;
|
ble_att_svr_test_n_attr_handle = 0;
|
ble_att_svr_test_attr_n_len = 0;
|
|
ble_att_svr_test_misc_rx_indicate(conn_handle, attr_handle, attr_val,
|
attr_len, good);
|
|
if (good) {
|
TEST_ASSERT(ble_att_svr_test_n_conn_handle == conn_handle);
|
TEST_ASSERT(ble_att_svr_test_n_attr_handle == attr_handle);
|
TEST_ASSERT(ble_att_svr_test_attr_n_len == attr_len);
|
TEST_ASSERT(memcmp(ble_att_svr_test_attr_n, attr_val, attr_len) == 0);
|
ble_att_svr_test_misc_verify_tx_indicate_rsp();
|
} else {
|
TEST_ASSERT(ble_att_svr_test_n_conn_handle == 0xffff);
|
TEST_ASSERT(ble_att_svr_test_n_attr_handle == 0);
|
TEST_ASSERT(ble_att_svr_test_attr_n_len == 0);
|
TEST_ASSERT(ble_hs_test_util_prev_tx_queue_sz() == 0);
|
}
|
}
|
|
TEST_CASE_SELF(ble_att_svr_test_mtu)
|
{
|
/*** MTU too low; should pretend peer sent default value instead. */
|
ble_att_svr_test_misc_mtu_exchange(BLE_ATT_MTU_DFLT, 5,
|
BLE_ATT_MTU_DFLT, BLE_ATT_MTU_DFLT);
|
|
/*** MTUs equal. */
|
ble_att_svr_test_misc_mtu_exchange(50, 50, 50, 50);
|
|
/*** Peer's higher than mine. */
|
ble_att_svr_test_misc_mtu_exchange(50, 100, 100, 50);
|
|
/*** Mine higher than peer's. */
|
ble_att_svr_test_misc_mtu_exchange(100, 50, 50, 50);
|
|
ble_att_svr_test_assert_mbufs_freed();
|
}
|
|
TEST_CASE_SELF(ble_att_svr_test_read)
|
{
|
struct ble_hs_conn *conn;
|
struct os_mbuf *om;
|
uint16_t attr_handle;
|
uint16_t conn_handle;
|
const ble_uuid_t *uuid_sec = BLE_UUID128_DECLARE( \
|
1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
|
const ble_uuid_t *uuid_bad = BLE_UUID128_DECLARE( \
|
2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
|
const ble_uuid_t *uuid = BLE_UUID128_DECLARE( \
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, );
|
int rc;
|
|
conn_handle = ble_att_svr_test_misc_init(0);
|
|
/*** Nonexistent attribute. */
|
attr_handle = 0;
|
rc = ble_hs_test_util_rx_att_read_req(conn_handle, attr_handle);
|
TEST_ASSERT(rc != 0);
|
ble_hs_test_util_verify_tx_err_rsp(BLE_ATT_OP_READ_REQ, 0,
|
BLE_ATT_ERR_INVALID_HANDLE);
|
|
/*** Application error. */
|
rc = ble_att_svr_register(uuid_bad, HA_FLAG_PERM_RW, 0, &attr_handle,
|
ble_att_svr_test_misc_attr_fn_r_err, NULL);
|
TEST_ASSERT(rc == 0);
|
|
rc = ble_hs_test_util_rx_att_read_req(conn_handle, attr_handle);
|
TEST_ASSERT(rc == BLE_HS_EAPP);
|
ble_hs_test_util_verify_tx_err_rsp(BLE_ATT_OP_READ_REQ, attr_handle,
|
BLE_ATT_ERR_UNLIKELY);
|
|
/*** Successful read. */
|
ble_att_svr_test_attr_r_1 = (uint8_t[]){0,1,2,3,4,5,6,7};
|
ble_att_svr_test_attr_r_1_len = 8;
|
rc = ble_att_svr_register(uuid, HA_FLAG_PERM_RW, 0, &attr_handle,
|
ble_att_svr_test_misc_attr_fn_r_1, NULL);
|
TEST_ASSERT(rc == 0);
|
|
rc = ble_hs_test_util_rx_att_read_req(conn_handle, attr_handle);
|
TEST_ASSERT(rc == 0);
|
ble_hs_test_util_verify_tx_read_rsp(
|
ble_att_svr_test_attr_r_1, ble_att_svr_test_attr_r_1_len);
|
|
/*** Partial read. */
|
ble_att_svr_test_attr_r_1 =
|
(uint8_t[]){0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,
|
22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39};
|
ble_att_svr_test_attr_r_1_len = 40;
|
|
rc = ble_hs_test_util_rx_att_read_req(conn_handle, attr_handle);
|
TEST_ASSERT(rc == 0);
|
ble_hs_test_util_verify_tx_read_rsp(ble_att_svr_test_attr_r_1,
|
BLE_ATT_MTU_DFLT - 1);
|
|
/*** Read requires encryption. */
|
/* Insufficient authentication. */
|
rc = ble_att_svr_register(uuid_sec, BLE_ATT_F_READ | BLE_ATT_F_READ_ENC, 0,
|
&attr_handle,
|
ble_att_svr_test_misc_attr_fn_r_1, NULL);
|
TEST_ASSERT(rc == 0);
|
|
rc = ble_hs_test_util_rx_att_read_req(conn_handle, attr_handle);
|
TEST_ASSERT(rc == BLE_HS_ATT_ERR(BLE_ATT_ERR_INSUFFICIENT_AUTHEN));
|
ble_hs_test_util_verify_tx_err_rsp(BLE_ATT_OP_READ_REQ, attr_handle,
|
BLE_ATT_ERR_INSUFFICIENT_AUTHEN);
|
|
/* Security check bypassed for local reads. */
|
rc = ble_att_svr_read_local(attr_handle, &om);
|
TEST_ASSERT_FATAL(rc == 0);
|
TEST_ASSERT(OS_MBUF_PKTLEN(om) == ble_att_svr_test_attr_r_1_len);
|
TEST_ASSERT(os_mbuf_cmpf(om, 0, ble_att_svr_test_attr_r_1,
|
ble_att_svr_test_attr_r_1_len) == 0);
|
rc = os_mbuf_free_chain(om);
|
TEST_ASSERT_FATAL(rc == 0);
|
|
/* Ensure no response got sent. */
|
TEST_ASSERT(ble_hs_test_util_prev_tx_dequeue() == NULL);
|
|
/* Encrypt link; success. */
|
ble_hs_lock();
|
conn = ble_hs_conn_find(conn_handle);
|
conn->bhc_sec_state.encrypted = 1;
|
ble_hs_unlock();
|
|
rc = ble_hs_test_util_rx_att_read_req(conn_handle, attr_handle);
|
TEST_ASSERT(rc == 0);
|
ble_hs_test_util_verify_tx_read_rsp(ble_att_svr_test_attr_r_1,
|
BLE_ATT_MTU_DFLT - 1);
|
|
ble_att_svr_test_assert_mbufs_freed();
|
}
|
|
TEST_CASE_SELF(ble_att_svr_test_read_blob)
|
{
|
uint16_t attr_handle;
|
uint16_t conn_handle;
|
const ble_uuid_t *uuid = BLE_UUID128_DECLARE( \
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
|
int rc;
|
|
conn_handle = ble_att_svr_test_misc_init(0);
|
|
/*** Nonexistent attribute. */
|
rc = ble_hs_test_util_rx_att_read_blob_req(conn_handle, 0, 0);
|
TEST_ASSERT(rc != 0);
|
ble_hs_test_util_verify_tx_err_rsp(BLE_ATT_OP_READ_BLOB_REQ, 0,
|
BLE_ATT_ERR_INVALID_HANDLE);
|
|
/*** Successful partial read. */
|
ble_att_svr_test_attr_r_1 =
|
(uint8_t[]){0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,
|
22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39};
|
ble_att_svr_test_attr_r_1_len = 40;
|
rc = ble_att_svr_register(uuid, HA_FLAG_PERM_RW, 0, &attr_handle,
|
ble_att_svr_test_misc_attr_fn_r_1, NULL);
|
TEST_ASSERT(rc == 0);
|
|
rc = ble_hs_test_util_rx_att_read_blob_req(conn_handle, attr_handle, 0);
|
TEST_ASSERT(rc == 0);
|
ble_hs_test_util_verify_tx_read_blob_rsp(ble_att_svr_test_attr_r_1,
|
BLE_ATT_MTU_DFLT - 1);
|
|
/*** Read remainder of attribute. */
|
rc = ble_hs_test_util_rx_att_read_blob_req(conn_handle, attr_handle,
|
BLE_ATT_MTU_DFLT - 1);
|
TEST_ASSERT(rc == 0);
|
ble_hs_test_util_verify_tx_read_blob_rsp(
|
ble_att_svr_test_attr_r_1 + BLE_ATT_MTU_DFLT - 1,
|
40 - (BLE_ATT_MTU_DFLT - 1));
|
|
/*** Zero-length read. */
|
rc = ble_hs_test_util_rx_att_read_blob_req(conn_handle, attr_handle,
|
ble_att_svr_test_attr_r_1_len);
|
TEST_ASSERT(rc == 0);
|
ble_hs_test_util_verify_tx_read_blob_rsp(ble_att_svr_test_attr_r_1,
|
0);
|
|
ble_att_svr_test_assert_mbufs_freed();
|
}
|
|
TEST_CASE_SELF(ble_att_svr_test_read_mult)
|
{
|
uint16_t conn_handle;
|
int rc;
|
|
conn_handle = ble_att_svr_test_misc_init(0);
|
|
struct ble_hs_test_util_flat_attr attrs[2] = {
|
{
|
.handle = 0,
|
.offset = 0,
|
.value = { 1, 2, 3, 4 },
|
.value_len = 4,
|
},
|
{
|
.handle = 0,
|
.offset = 0,
|
.value = { 2, 3, 4, 5, 6 },
|
.value_len = 5,
|
},
|
};
|
|
ble_att_svr_test_attr_r_1 = attrs[0].value;
|
ble_att_svr_test_attr_r_1_len = attrs[0].value_len;
|
ble_att_svr_test_attr_r_2 = attrs[1].value;
|
ble_att_svr_test_attr_r_2_len = attrs[1].value_len;
|
|
rc = ble_att_svr_register(BLE_UUID16_DECLARE(0x1111), HA_FLAG_PERM_RW, 0,
|
&attrs[0].handle,
|
ble_att_svr_test_misc_attr_fn_r_1, NULL);
|
TEST_ASSERT(rc == 0);
|
|
rc = ble_att_svr_register(BLE_UUID16_DECLARE(0x2222), HA_FLAG_PERM_RW, 0,
|
&attrs[1].handle,
|
ble_att_svr_test_misc_attr_fn_r_2, NULL);
|
TEST_ASSERT(rc == 0);
|
|
/*** Single nonexistent attribute. */
|
ble_att_svr_test_misc_rx_read_mult_req(
|
conn_handle, ((uint16_t[]){ 100 }), 1, 0);
|
ble_hs_test_util_verify_tx_err_rsp(BLE_ATT_OP_READ_MULT_REQ,
|
100, BLE_ATT_ERR_INVALID_HANDLE);
|
|
/*** Single attribute. */
|
ble_att_svr_test_misc_verify_all_read_mult(conn_handle, &attrs[0], 1);
|
|
/*** Two attributes. */
|
ble_att_svr_test_misc_verify_all_read_mult(conn_handle, attrs, 2);
|
|
/*** Reverse order. */
|
ble_att_svr_test_misc_verify_all_read_mult(conn_handle, attrs, 2);
|
|
/*** Second attribute nonexistent; verify only error txed. */
|
ble_att_svr_test_misc_rx_read_mult_req(
|
conn_handle, ((uint16_t[]){ attrs[0].handle, 100 }), 2, 0);
|
ble_hs_test_util_verify_tx_err_rsp(BLE_ATT_OP_READ_MULT_REQ,
|
100, BLE_ATT_ERR_INVALID_HANDLE);
|
|
/*** Response too long; verify only MTU bytes sent. */
|
attrs[0].value_len = 20;
|
memcpy(attrs[0].value,
|
((uint8_t[]){0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19}),
|
attrs[0].value_len);
|
ble_att_svr_test_attr_r_1_len = attrs[0].value_len;
|
|
attrs[1].value_len = 20;
|
memcpy(attrs[1].value,
|
((uint8_t[]){
|
22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39
|
}),
|
attrs[1].value_len);
|
ble_att_svr_test_attr_r_2_len = attrs[1].value_len;
|
|
ble_att_svr_test_misc_verify_all_read_mult(conn_handle, attrs, 2);
|
|
ble_att_svr_test_assert_mbufs_freed();
|
}
|
|
TEST_CASE_SELF(ble_att_svr_test_write)
|
{
|
struct ble_hs_conn *conn;
|
uint16_t conn_handle;
|
uint16_t attr_handle;
|
const ble_uuid_t *uuid_sec = BLE_UUID128_DECLARE( \
|
2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
|
const ble_uuid_t *uuid_rw = BLE_UUID128_DECLARE( \
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
|
const ble_uuid_t *uuid_r = BLE_UUID128_DECLARE( \
|
1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
|
int rc;
|
|
static const uint8_t attr_val[8] = { 0, 1, 2, 3, 4, 5, 6, 7 };
|
|
conn_handle = ble_att_svr_test_misc_init(0);
|
|
/*** Nonexistent attribute. */
|
rc = ble_hs_test_util_rx_att_write_req(conn_handle, 0,
|
attr_val, sizeof attr_val);
|
TEST_ASSERT(rc != 0);
|
ble_hs_test_util_verify_tx_err_rsp(
|
BLE_ATT_OP_WRITE_REQ, 0, BLE_ATT_ERR_INVALID_HANDLE);
|
|
/*** Write not permitted if non-local. */
|
/* Non-local write (fail). */
|
rc = ble_att_svr_register(uuid_r, BLE_ATT_F_READ, 0, &attr_handle,
|
ble_att_svr_test_misc_attr_fn_w_1, NULL);
|
TEST_ASSERT(rc == 0);
|
|
rc = ble_hs_test_util_rx_att_write_req(conn_handle, attr_handle,
|
attr_val, sizeof attr_val);
|
TEST_ASSERT(rc == BLE_HS_EREJECT);
|
ble_hs_test_util_verify_tx_err_rsp(BLE_ATT_OP_WRITE_REQ,
|
attr_handle,
|
BLE_ATT_ERR_WRITE_NOT_PERMITTED);
|
|
/* Local write (success). */
|
rc = ble_hs_test_util_write_local_flat(attr_handle,
|
attr_val, sizeof attr_val);
|
TEST_ASSERT(rc == 0);
|
|
/* Ensure no response got sent. */
|
TEST_ASSERT(ble_hs_test_util_prev_tx_dequeue() == NULL);
|
|
/*** Successful write. */
|
rc = ble_att_svr_register(uuid_rw, HA_FLAG_PERM_RW, 0, &attr_handle,
|
ble_att_svr_test_misc_attr_fn_w_1, NULL);
|
TEST_ASSERT(rc == 0);
|
|
rc = ble_hs_test_util_rx_att_write_req(conn_handle, attr_handle,
|
attr_val, sizeof attr_val);
|
TEST_ASSERT(rc == 0);
|
ble_hs_test_util_verify_tx_write_rsp();
|
|
/*** Write requires encryption. */
|
/* Insufficient authentication. */
|
rc = ble_att_svr_register(uuid_sec, BLE_ATT_F_WRITE | BLE_ATT_F_WRITE_ENC,
|
0, &attr_handle,
|
ble_att_svr_test_misc_attr_fn_w_1, NULL);
|
TEST_ASSERT(rc == 0);
|
|
rc = ble_hs_test_util_rx_att_write_req(conn_handle, attr_handle,
|
attr_val, sizeof attr_val);
|
TEST_ASSERT(rc == BLE_HS_ATT_ERR(BLE_ATT_ERR_INSUFFICIENT_AUTHEN));
|
ble_hs_test_util_verify_tx_err_rsp(BLE_ATT_OP_WRITE_REQ,
|
attr_handle,
|
BLE_ATT_ERR_INSUFFICIENT_AUTHEN);
|
|
/* Security check bypassed for local writes. */
|
rc = ble_hs_test_util_write_local_flat(attr_handle,
|
attr_val, sizeof attr_val);
|
TEST_ASSERT(rc == 0);
|
|
/* Ensure no response got sent. */
|
TEST_ASSERT(ble_hs_test_util_prev_tx_dequeue() == NULL);
|
|
/* Encrypt link; success. */
|
ble_hs_lock();
|
conn = ble_hs_conn_find(conn_handle);
|
conn->bhc_sec_state.encrypted = 1;
|
ble_hs_unlock();
|
|
rc = ble_hs_test_util_rx_att_write_req(conn_handle, attr_handle,
|
attr_val, sizeof attr_val);
|
TEST_ASSERT(rc == 0);
|
ble_hs_test_util_verify_tx_write_rsp();
|
|
ble_att_svr_test_assert_mbufs_freed();
|
}
|
|
TEST_CASE_SELF(ble_att_svr_test_find_info)
|
{
|
uint16_t conn_handle;
|
uint16_t handle1;
|
uint16_t handle2;
|
uint16_t handle3;
|
const ble_uuid_t *uuid1 =
|
BLE_UUID128_DECLARE(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ,11, 12, 13, 14, 15);
|
const ble_uuid_t *uuid2 =
|
BLE_UUID128_DECLARE(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
|
const ble_uuid_t *uuid3 = BLE_UUID16_DECLARE(0x000f);
|
int rc;
|
|
conn_handle = ble_att_svr_test_misc_init(128);
|
|
/*** Start handle of 0. */
|
rc = ble_hs_test_util_rx_att_find_info_req(conn_handle, 0, 0);
|
TEST_ASSERT(rc != 0);
|
ble_hs_test_util_verify_tx_err_rsp(
|
BLE_ATT_OP_FIND_INFO_REQ, 0, BLE_ATT_ERR_INVALID_HANDLE);
|
|
/*** Start handle > end handle. */
|
rc = ble_hs_test_util_rx_att_find_info_req(conn_handle, 101, 100);
|
TEST_ASSERT(rc != 0);
|
ble_hs_test_util_verify_tx_err_rsp(
|
BLE_ATT_OP_FIND_INFO_REQ, 101, BLE_ATT_ERR_INVALID_HANDLE);
|
|
/*** No attributes. */
|
rc = ble_hs_test_util_rx_att_find_info_req(conn_handle, 200, 300);
|
TEST_ASSERT(rc != 0);
|
ble_hs_test_util_verify_tx_err_rsp(
|
BLE_ATT_OP_FIND_INFO_REQ, 200, BLE_ATT_ERR_ATTR_NOT_FOUND);
|
|
/*** Range too late. */
|
rc = ble_att_svr_register(uuid1, HA_FLAG_PERM_RW, 0, &handle1,
|
ble_att_svr_test_misc_attr_fn_r_1, NULL);
|
TEST_ASSERT(rc == 0);
|
|
rc = ble_hs_test_util_rx_att_find_info_req(conn_handle, 200, 300);
|
TEST_ASSERT(rc != 0);
|
ble_hs_test_util_verify_tx_err_rsp(
|
BLE_ATT_OP_FIND_INFO_REQ, 200, BLE_ATT_ERR_ATTR_NOT_FOUND);
|
|
/*** One 128-bit entry. */
|
rc = ble_hs_test_util_rx_att_find_info_req(conn_handle, handle1, handle1);
|
TEST_ASSERT(rc == 0);
|
ble_hs_test_util_verify_tx_find_info_rsp(
|
((struct ble_hs_test_util_att_info_entry[]) { {
|
.handle = handle1,
|
.uuid = BLE_UUID128_DECLARE(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15),
|
}, {
|
.handle = 0,
|
} }));
|
|
/*** Two 128-bit entries. */
|
rc = ble_att_svr_register(uuid2, HA_FLAG_PERM_RW, 0, &handle2,
|
ble_att_svr_test_misc_attr_fn_r_1, NULL);
|
TEST_ASSERT(rc == 0);
|
|
rc = ble_hs_test_util_rx_att_find_info_req(conn_handle, handle1, handle2);
|
TEST_ASSERT(rc == 0);
|
ble_hs_test_util_verify_tx_find_info_rsp(
|
((struct ble_hs_test_util_att_info_entry[]) { {
|
.handle = handle1,
|
.uuid = BLE_UUID128_DECLARE(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15),
|
}, {
|
.handle = handle2,
|
.uuid = BLE_UUID128_DECLARE(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16),
|
}, {
|
.handle = 0,
|
} }));
|
|
/*** Two 128-bit entries; 16-bit entry doesn't get sent. */
|
rc = ble_att_svr_register(uuid3, HA_FLAG_PERM_RW, 0, &handle3,
|
ble_att_svr_test_misc_attr_fn_r_1, NULL);
|
TEST_ASSERT(rc == 0);
|
|
rc = ble_hs_test_util_rx_att_find_info_req(conn_handle, handle1, handle3);
|
TEST_ASSERT(rc == 0);
|
ble_hs_test_util_verify_tx_find_info_rsp(
|
((struct ble_hs_test_util_att_info_entry[]) { {
|
.handle = handle1,
|
.uuid = BLE_UUID128_DECLARE(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15),
|
}, {
|
.handle = handle2,
|
.uuid = BLE_UUID128_DECLARE(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16),
|
}, {
|
.handle = 0,
|
} }));
|
|
/*** Remaining 16-bit entry requested. */
|
rc = ble_hs_test_util_rx_att_find_info_req(conn_handle, handle3, handle3);
|
TEST_ASSERT(rc == 0);
|
ble_hs_test_util_verify_tx_find_info_rsp(
|
((struct ble_hs_test_util_att_info_entry[]) { {
|
.handle = handle3,
|
.uuid = BLE_UUID16_DECLARE(0x000f),
|
}, {
|
.handle = 0,
|
} }));
|
|
ble_att_svr_test_assert_mbufs_freed();
|
}
|
|
TEST_CASE_SELF(ble_att_svr_test_find_type_value)
|
{
|
uint16_t conn_handle;
|
uint16_t handle1;
|
uint16_t handle2;
|
uint16_t handle3;
|
uint16_t handle4;
|
uint16_t handle5;
|
uint16_t handle_desc;
|
const ble_uuid_t *uuid1 = BLE_UUID16_DECLARE(0x2800);
|
const ble_uuid_t *uuid2 = BLE_UUID16_DECLARE(0x2803);
|
const ble_uuid_t *uuid3 =
|
BLE_UUID128_DECLARE(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
|
int rc;
|
|
conn_handle = ble_att_svr_test_misc_init(128);
|
|
ble_att_svr_test_attr_r_1 = (uint8_t[]){0x99, 0x99};
|
ble_att_svr_test_attr_r_1_len = 2;
|
|
/*** Start handle of 0. */
|
rc = ble_hs_test_util_rx_att_find_type_value_req(
|
conn_handle, 0, 0, 0x2800, ble_att_svr_test_attr_r_1,
|
ble_att_svr_test_attr_r_1_len);
|
TEST_ASSERT(rc != 0);
|
ble_hs_test_util_verify_tx_err_rsp(
|
BLE_ATT_OP_FIND_TYPE_VALUE_REQ, 0,
|
BLE_ATT_ERR_INVALID_HANDLE);
|
|
/*** Start handle > end handle. */
|
rc = ble_hs_test_util_rx_att_find_type_value_req(
|
conn_handle, 101, 100, 0x2800, ble_att_svr_test_attr_r_1,
|
ble_att_svr_test_attr_r_1_len);
|
TEST_ASSERT(rc != 0);
|
ble_hs_test_util_verify_tx_err_rsp(
|
BLE_ATT_OP_FIND_TYPE_VALUE_REQ, 101,
|
BLE_ATT_ERR_INVALID_HANDLE);
|
|
/*** No attributes. */
|
rc = ble_hs_test_util_rx_att_find_type_value_req(
|
conn_handle, 200, 300, 0x2800, ble_att_svr_test_attr_r_1,
|
ble_att_svr_test_attr_r_1_len);
|
TEST_ASSERT(rc != 0);
|
ble_hs_test_util_verify_tx_err_rsp(
|
BLE_ATT_OP_FIND_TYPE_VALUE_REQ, 200,
|
BLE_ATT_ERR_ATTR_NOT_FOUND);
|
|
/*** Range too late. */
|
rc = ble_att_svr_register(uuid1, HA_FLAG_PERM_RW, 0, &handle1,
|
ble_att_svr_test_misc_attr_fn_r_1, NULL);
|
TEST_ASSERT(rc == 0);
|
|
rc = ble_hs_test_util_rx_att_find_type_value_req(
|
conn_handle, 200, 300, 0x2800, ble_att_svr_test_attr_r_1,
|
ble_att_svr_test_attr_r_1_len);
|
TEST_ASSERT(rc != 0);
|
ble_hs_test_util_verify_tx_err_rsp(
|
BLE_ATT_OP_FIND_TYPE_VALUE_REQ, 200,
|
BLE_ATT_ERR_ATTR_NOT_FOUND);
|
|
/*** One entry, one attribute. */
|
rc = ble_hs_test_util_rx_att_find_type_value_req(
|
conn_handle, handle1, handle1, 0x2800, ble_att_svr_test_attr_r_1,
|
ble_att_svr_test_attr_r_1_len);
|
TEST_ASSERT(rc == 0);
|
ble_att_svr_test_misc_verify_tx_find_type_value_rsp(
|
((struct ble_att_svr_test_type_value_entry[]) { {
|
.first = handle1,
|
.last = handle1,
|
}, {
|
.first = 0,
|
} }));
|
|
/*** One entry, two attributes. */
|
rc = ble_att_svr_register(uuid2, HA_FLAG_PERM_RW, 0, &handle2,
|
ble_att_svr_test_misc_attr_fn_r_1, NULL);
|
TEST_ASSERT(rc == 0);
|
|
rc = ble_hs_test_util_rx_att_find_type_value_req(
|
conn_handle, handle1, handle2, 0x2800, ble_att_svr_test_attr_r_1,
|
ble_att_svr_test_attr_r_1_len);
|
TEST_ASSERT(rc == 0);
|
ble_att_svr_test_misc_verify_tx_find_type_value_rsp(
|
((struct ble_att_svr_test_type_value_entry[]) { {
|
.first = handle1,
|
.last = handle2,
|
}, {
|
.first = 0,
|
} }));
|
|
/*** Entry 1: four attributes; entry 2 (invalid value): one attribute;
|
* entry 3: one attribute; Check that invalid value is not returned. */
|
ble_att_svr_test_attr_r_2 = (uint8_t[]){0x00, 0x00};
|
ble_att_svr_test_attr_r_2_len = 2;
|
|
rc = ble_att_svr_register(uuid3, HA_FLAG_PERM_RW, 0, &handle_desc,
|
ble_att_svr_test_misc_attr_fn_r_2, NULL);
|
TEST_ASSERT(rc == 0);
|
|
rc = ble_att_svr_register(uuid2, HA_FLAG_PERM_RW, 0, &handle3,
|
ble_att_svr_test_misc_attr_fn_r_2, NULL);
|
TEST_ASSERT(rc == 0);
|
|
rc = ble_att_svr_register(uuid1, HA_FLAG_PERM_RW, 0, &handle4,
|
ble_att_svr_test_misc_attr_fn_r_2, NULL);
|
TEST_ASSERT(rc == 0);
|
|
rc = ble_att_svr_register(uuid1, HA_FLAG_PERM_RW, 0, &handle5,
|
ble_att_svr_test_misc_attr_fn_r_1, NULL);
|
TEST_ASSERT(rc == 0);
|
|
rc = ble_hs_test_util_rx_att_find_type_value_req(
|
conn_handle, 0x0001, 0xffff, 0x2800, ble_att_svr_test_attr_r_1,
|
ble_att_svr_test_attr_r_1_len);
|
TEST_ASSERT(rc == 0);
|
ble_att_svr_test_misc_verify_tx_find_type_value_rsp(
|
((struct ble_att_svr_test_type_value_entry[]) { {
|
.first = handle1,
|
.last = handle3,
|
}, {
|
.first = handle5,
|
.last = handle5,
|
}, {
|
.first = 0,
|
} }));
|
|
/*** As above, check proper range is returned with smaller search range */
|
rc = ble_hs_test_util_rx_att_find_type_value_req(
|
conn_handle, 0x0001, 0x0001, 0x2800, ble_att_svr_test_attr_r_1,
|
ble_att_svr_test_attr_r_1_len);
|
TEST_ASSERT(rc == 0);
|
ble_att_svr_test_misc_verify_tx_find_type_value_rsp(
|
((struct ble_att_svr_test_type_value_entry[]) { {
|
.first = handle1,
|
.last = handle3,
|
}, {
|
.first = 0,
|
} }));
|
|
/*** As above, check grouping by Characteristic UUID */
|
rc = ble_hs_test_util_rx_att_find_type_value_req(
|
conn_handle, handle1, handle3, 0x2803, ble_att_svr_test_attr_r_1,
|
ble_att_svr_test_attr_r_1_len);
|
TEST_ASSERT(rc == 0);
|
ble_att_svr_test_misc_verify_tx_find_type_value_rsp(
|
((struct ble_att_svr_test_type_value_entry[]) { {
|
.first = handle2,
|
.last = handle_desc,
|
}, {
|
.first = 0,
|
} }));
|
|
ble_att_svr_test_assert_mbufs_freed();
|
}
|
|
static void
|
ble_att_svr_test_misc_read_type(uint16_t mtu)
|
{
|
uint16_t conn_handle;
|
int rc;
|
|
conn_handle = ble_att_svr_test_misc_init(mtu);
|
|
/*** Start handle of 0. */
|
rc = ble_hs_test_util_rx_att_read_type_req16(conn_handle, 0, 0,
|
BLE_ATT_UUID_PRIMARY_SERVICE);
|
TEST_ASSERT(rc != 0);
|
ble_hs_test_util_verify_tx_err_rsp(
|
BLE_ATT_OP_READ_TYPE_REQ, 0,
|
BLE_ATT_ERR_INVALID_HANDLE);
|
|
/*** Start handle > end handle. */
|
rc = ble_hs_test_util_rx_att_read_type_req16(conn_handle, 101, 100,
|
BLE_ATT_UUID_PRIMARY_SERVICE);
|
TEST_ASSERT(rc != 0);
|
ble_hs_test_util_verify_tx_err_rsp(
|
BLE_ATT_OP_READ_TYPE_REQ, 101,
|
BLE_ATT_ERR_INVALID_HANDLE);
|
|
/*** No attributes. */
|
rc = ble_hs_test_util_rx_att_read_type_req16(conn_handle, 1, 0xffff,
|
BLE_ATT_UUID_PRIMARY_SERVICE);
|
TEST_ASSERT(rc != 0);
|
ble_hs_test_util_verify_tx_err_rsp(
|
BLE_ATT_OP_READ_TYPE_REQ, 1,
|
BLE_ATT_ERR_ATTR_NOT_FOUND);
|
|
/*** Range too late. */
|
ble_att_svr_test_misc_register_group_attrs();
|
rc = ble_hs_test_util_rx_att_read_type_req16(conn_handle, 200, 300,
|
BLE_ATT_UUID_PRIMARY_SERVICE);
|
TEST_ASSERT(rc != 0);
|
ble_hs_test_util_verify_tx_err_rsp(
|
BLE_ATT_OP_READ_TYPE_REQ, 200,
|
BLE_ATT_ERR_ATTR_NOT_FOUND);
|
|
/*** One characteristic from one service. */
|
rc = ble_hs_test_util_rx_att_read_type_req16(conn_handle, 1, 2,
|
BLE_ATT_UUID_CHARACTERISTIC);
|
TEST_ASSERT(rc == 0);
|
ble_att_svr_test_misc_verify_tx_read_type_rsp(
|
((struct ble_att_svr_test_type_entry[]) { {
|
.handle = 2,
|
.value = (uint8_t[]){ 0x01, 0x11 },
|
.value_len = 2,
|
}, {
|
.handle = 0,
|
} }));
|
|
/*** Both characteristics from one service. */
|
rc = ble_hs_test_util_rx_att_read_type_req16(conn_handle, 1, 10,
|
BLE_ATT_UUID_CHARACTERISTIC);
|
TEST_ASSERT(rc == 0);
|
ble_att_svr_test_misc_verify_tx_read_type_rsp(
|
((struct ble_att_svr_test_type_entry[]) { {
|
.handle = 2,
|
.value = (uint8_t[]){ 0x01, 0x11 },
|
.value_len = 2,
|
}, {
|
.handle = 4,
|
.value = (uint8_t[]){ 0x03, 0x11 },
|
.value_len = 2,
|
}, {
|
.handle = 0,
|
} }));
|
|
/*** Ensure 16-bit and 128-bit values are retrieved separately. */
|
rc = ble_hs_test_util_rx_att_read_type_req16(conn_handle, 11, 0xffff,
|
BLE_ATT_UUID_CHARACTERISTIC);
|
TEST_ASSERT(rc == 0);
|
ble_att_svr_test_misc_verify_tx_read_type_rsp(
|
((struct ble_att_svr_test_type_entry[]) { {
|
.handle = 12,
|
.value = (uint8_t[]){ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 },
|
.value_len = 16,
|
}, {
|
.handle = 0,
|
} }));
|
|
rc = ble_hs_test_util_rx_att_read_type_req16(conn_handle, 13, 0xffff,
|
BLE_ATT_UUID_CHARACTERISTIC);
|
TEST_ASSERT(rc == 0);
|
ble_att_svr_test_misc_verify_tx_read_type_rsp(
|
((struct ble_att_svr_test_type_entry[]) { {
|
.handle = 14,
|
.value = (uint8_t[]){ 0x55, 0x55 },
|
.value_len = 2,
|
}, {
|
.handle = 0,
|
} }));
|
|
rc = ble_hs_test_util_rx_att_read_type_req16(conn_handle, 15, 0xffff,
|
BLE_ATT_UUID_CHARACTERISTIC);
|
TEST_ASSERT(rc == 0);
|
ble_att_svr_test_misc_verify_tx_read_type_rsp(
|
((struct ble_att_svr_test_type_entry[]) { {
|
.handle = 16,
|
.value = (uint8_t[]){ 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2 },
|
.value_len = 16,
|
}, {
|
.handle = 0,
|
} }));
|
|
/*** Read until the end of the attribute list. */
|
rc = ble_hs_test_util_rx_att_read_type_req16(conn_handle, 17, 0xffff,
|
BLE_ATT_UUID_CHARACTERISTIC);
|
TEST_ASSERT(rc == 0);
|
ble_att_svr_test_misc_verify_tx_read_type_rsp(
|
((struct ble_att_svr_test_type_entry[]) { {
|
.handle = 18,
|
.value = (uint8_t[]){ 0x66, 0x66 },
|
.value_len = 2,
|
}, {
|
.handle = 20,
|
.value = (uint8_t[]){ 0x77, 0x77 },
|
.value_len = 2,
|
}, {
|
.handle = 22,
|
.value = (uint8_t[]){ 0x88, 0x88 },
|
.value_len = 2,
|
}, {
|
.handle = 24,
|
.value = (uint8_t[]){ 0x99, 0x99 },
|
.value_len = 2,
|
}, {
|
.handle = 0,
|
} }));
|
|
ble_att_svr_test_assert_mbufs_freed();
|
}
|
|
TEST_CASE_SELF(ble_att_svr_test_read_type)
|
{
|
ble_att_svr_test_misc_read_type(0);
|
ble_att_svr_test_misc_read_type(128);
|
|
ble_att_svr_test_assert_mbufs_freed();
|
}
|
|
TEST_CASE_SELF(ble_att_svr_test_read_group_type)
|
{
|
uint16_t conn_handle;
|
int rc;
|
|
conn_handle = ble_att_svr_test_misc_init(128);
|
|
/*** Start handle of 0. */
|
rc = ble_hs_test_util_rx_att_read_group_type_req16(
|
conn_handle, 0, 0, BLE_ATT_UUID_PRIMARY_SERVICE);
|
TEST_ASSERT(rc != 0);
|
ble_hs_test_util_verify_tx_err_rsp(
|
BLE_ATT_OP_READ_GROUP_TYPE_REQ, 0,
|
BLE_ATT_ERR_INVALID_HANDLE);
|
|
/*** Start handle > end handle. */
|
rc = ble_hs_test_util_rx_att_read_group_type_req16(
|
conn_handle, 101, 100, BLE_ATT_UUID_PRIMARY_SERVICE);
|
TEST_ASSERT(rc != 0);
|
ble_hs_test_util_verify_tx_err_rsp(
|
BLE_ATT_OP_READ_GROUP_TYPE_REQ, 101,
|
BLE_ATT_ERR_INVALID_HANDLE);
|
|
/*** Invalid group UUID (0x1234). */
|
rc = ble_hs_test_util_rx_att_read_group_type_req16(
|
conn_handle, 110, 150, 0x1234);
|
TEST_ASSERT(rc != 0);
|
ble_hs_test_util_verify_tx_err_rsp(
|
BLE_ATT_OP_READ_GROUP_TYPE_REQ, 110,
|
BLE_ATT_ERR_UNSUPPORTED_GROUP);
|
|
/*** No attributes. */
|
rc = ble_hs_test_util_rx_att_read_group_type_req16(
|
conn_handle, 1, 0xffff, BLE_ATT_UUID_PRIMARY_SERVICE);
|
TEST_ASSERT(rc != 0);
|
ble_hs_test_util_verify_tx_err_rsp(
|
BLE_ATT_OP_READ_GROUP_TYPE_REQ, 1,
|
BLE_ATT_ERR_ATTR_NOT_FOUND);
|
|
/*** Range too late. */
|
ble_att_svr_test_misc_register_group_attrs();
|
|
rc = ble_hs_test_util_rx_att_read_group_type_req16(
|
conn_handle, 200, 300, BLE_ATT_UUID_PRIMARY_SERVICE);
|
TEST_ASSERT(rc != 0);
|
ble_hs_test_util_verify_tx_err_rsp(
|
BLE_ATT_OP_READ_GROUP_TYPE_REQ, 200,
|
BLE_ATT_ERR_ATTR_NOT_FOUND);
|
|
/*** One 16-bit UUID service. */
|
rc = ble_hs_test_util_rx_att_read_group_type_req16(
|
conn_handle, 1, 5, BLE_ATT_UUID_PRIMARY_SERVICE);
|
TEST_ASSERT(rc == 0);
|
ble_hs_test_util_verify_tx_read_group_type_rsp(
|
((struct ble_hs_test_util_att_group_type_entry[]) { {
|
.start_handle = 1,
|
.end_handle = 5,
|
.uuid = BLE_UUID16_DECLARE(0x1122),
|
}, {
|
.start_handle = 0,
|
} }));
|
|
/*** Two 16-bit UUID services. */
|
rc = ble_hs_test_util_rx_att_read_group_type_req16(
|
conn_handle, 1, 10, BLE_ATT_UUID_PRIMARY_SERVICE);
|
TEST_ASSERT(rc == 0);
|
ble_hs_test_util_verify_tx_read_group_type_rsp(
|
((struct ble_hs_test_util_att_group_type_entry[]) { {
|
.start_handle = 1,
|
.end_handle = 5,
|
.uuid = BLE_UUID16_DECLARE(0x1122),
|
}, {
|
.start_handle = 6,
|
.end_handle = 10,
|
.uuid = BLE_UUID16_DECLARE(0x2233),
|
}, {
|
.start_handle = 0,
|
} }));
|
|
/*** Two 16-bit UUID services; ensure 128-bit service not returned. */
|
rc = ble_hs_test_util_rx_att_read_group_type_req16(
|
conn_handle, 1, 100, BLE_ATT_UUID_PRIMARY_SERVICE);
|
TEST_ASSERT(rc == 0);
|
ble_hs_test_util_verify_tx_read_group_type_rsp(
|
((struct ble_hs_test_util_att_group_type_entry[]) { {
|
.start_handle = 1,
|
.end_handle = 5,
|
.uuid = BLE_UUID16_DECLARE(0x1122),
|
}, {
|
.start_handle = 6,
|
.end_handle = 10,
|
.uuid = BLE_UUID16_DECLARE(0x2233),
|
}, {
|
.start_handle = 0,
|
} }));
|
|
/*** One 128-bit service. */
|
rc = ble_hs_test_util_rx_att_read_group_type_req16(
|
conn_handle, 11, 100, BLE_ATT_UUID_PRIMARY_SERVICE);
|
TEST_ASSERT(rc == 0);
|
ble_hs_test_util_verify_tx_read_group_type_rsp(
|
((struct ble_hs_test_util_att_group_type_entry[]) { {
|
.start_handle = 11,
|
.end_handle = 0xffff,
|
.uuid = BLE_UUID128_DECLARE(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16),
|
}, {
|
.start_handle = 0,
|
} }));
|
|
ble_att_svr_test_assert_mbufs_freed();
|
}
|
|
TEST_CASE_SELF(ble_att_svr_test_prep_write)
|
{
|
struct ble_hs_conn *conn;
|
uint16_t conn_handle;
|
int i;
|
|
static uint8_t data[1024];
|
|
conn_handle = ble_att_svr_test_misc_init(205);
|
|
/* Initialize some attribute data. */
|
for (i = 0; i < sizeof data; i++) {
|
data[i] = i;
|
}
|
|
/* Register two writable attributes. */
|
ble_att_svr_test_misc_register_uuid(BLE_UUID16_DECLARE(0x1234),
|
HA_FLAG_PERM_RW, 1,
|
ble_att_svr_test_misc_attr_fn_w_1);
|
ble_att_svr_test_misc_register_uuid(BLE_UUID16_DECLARE(0x8989),
|
HA_FLAG_PERM_RW, 2,
|
ble_att_svr_test_misc_attr_fn_w_2);
|
|
/* 3: not writable. */
|
ble_att_svr_test_misc_register_uuid(BLE_UUID16_DECLARE(0xabab),
|
BLE_ATT_F_READ, 3,
|
ble_att_svr_test_misc_attr_fn_r_1);
|
/* 4: Encryption required. */
|
ble_att_svr_test_misc_register_uuid(
|
BLE_UUID16_DECLARE(0xabac), BLE_ATT_F_WRITE | BLE_ATT_F_WRITE_ENC, 4,
|
ble_att_svr_test_misc_attr_fn_w_1);
|
|
/* 5: Encryption+authentication required. */
|
ble_att_svr_test_misc_register_uuid(
|
BLE_UUID16_DECLARE(0xabad),
|
BLE_ATT_F_WRITE | BLE_ATT_F_WRITE_ENC | BLE_ATT_F_WRITE_AUTHEN,
|
5, ble_att_svr_test_misc_attr_fn_w_1);
|
|
/* 6: Write callback always fails. */
|
ble_att_svr_test_misc_register_uuid(
|
BLE_UUID16_DECLARE(0xabae), BLE_ATT_F_WRITE, 6,
|
ble_att_svr_test_misc_attr_fn_w_fail);
|
|
/*** Empty write succeeds. */
|
ble_att_svr_test_misc_exec_write(conn_handle, BLE_ATT_EXEC_WRITE_F_EXECUTE,
|
0, 0);
|
|
/*** Empty cancel succeeds. */
|
ble_att_svr_test_misc_exec_write(conn_handle, 0, 0, 0);
|
|
/*** Failure for prep write to nonexistent attribute. */
|
ble_att_svr_test_misc_prep_write(conn_handle, 53525, 0, data, 10,
|
BLE_ATT_ERR_INVALID_HANDLE);
|
|
/*** Failure due to write-not-permitted. */
|
ble_att_svr_test_misc_prep_write(conn_handle, 3, 0, data, 35,
|
BLE_ATT_ERR_WRITE_NOT_PERMITTED);
|
|
/*** Failure due to insufficient authentication (encryption required). */
|
ble_att_svr_test_misc_prep_write(conn_handle, 4, 0, data, 1,
|
BLE_ATT_ERR_INSUFFICIENT_AUTHEN);
|
|
/*** Encrypt connection; ensure previous prep write now succeeds. */
|
ble_hs_lock();
|
conn = ble_hs_conn_find(2);
|
TEST_ASSERT_FATAL(conn != NULL);
|
conn->bhc_sec_state.encrypted = 1;
|
ble_hs_unlock();
|
|
ble_att_svr_test_misc_prep_write(conn_handle, 4, 0, data, 1, 0);
|
ble_att_svr_test_misc_exec_write(conn_handle, 0, 0, 0);
|
|
/*** Failure due to insufficient authentication (not authenticated). */
|
ble_att_svr_test_misc_prep_write(conn_handle, 5, 0, data, 35,
|
BLE_ATT_ERR_INSUFFICIENT_AUTHEN);
|
|
/*** Failure for write starting at nonzero offset. */
|
ble_att_svr_test_misc_prep_write(conn_handle, 1, 1, data, 10, 0);
|
ble_att_svr_test_misc_exec_write(conn_handle, BLE_ATT_EXEC_WRITE_F_EXECUTE,
|
BLE_ATT_ERR_INVALID_OFFSET, 1);
|
ble_att_svr_test_misc_verify_w_1(NULL, 0);
|
|
/*** Success for clear starting at nonzero offset. */
|
ble_att_svr_test_misc_prep_write(conn_handle, 1, 1, data, 10, 0);
|
ble_att_svr_test_misc_exec_write(conn_handle, 0, 0, 0);
|
ble_att_svr_test_misc_verify_w_1(NULL, 0);
|
|
/*** Failure for write with gap. */
|
ble_att_svr_test_misc_prep_write(conn_handle, 1, 0, data, 10, 0);
|
ble_att_svr_test_misc_prep_write(conn_handle, 1, 11, data, 10, 0);
|
ble_att_svr_test_misc_exec_write(conn_handle, BLE_ATT_EXEC_WRITE_F_EXECUTE,
|
BLE_ATT_ERR_INVALID_OFFSET, 1);
|
ble_att_svr_test_misc_verify_w_1(NULL, 0);
|
|
/*** Success for clear with gap. */
|
ble_att_svr_test_misc_prep_write(conn_handle, 1, 0, data, 10, 0);
|
ble_att_svr_test_misc_prep_write(conn_handle, 1, 11, data, 10, 0);
|
ble_att_svr_test_misc_exec_write(conn_handle, 0, 0, 0);
|
ble_att_svr_test_misc_verify_w_1(NULL, 0);
|
|
/*** Failure for overlong write. */
|
ble_att_svr_test_misc_prep_write(conn_handle, 1, 0, data, 200, 0);
|
ble_att_svr_test_misc_prep_write(conn_handle, 1, 200, data + 200, 200, 0);
|
ble_att_svr_test_misc_prep_write(conn_handle, 1, 400, data + 400, 200, 0);
|
ble_att_svr_test_misc_exec_write(conn_handle, BLE_ATT_EXEC_WRITE_F_EXECUTE,
|
BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN, 1);
|
ble_att_svr_test_misc_verify_w_1(NULL, 0);
|
|
/*** Successful two part write. */
|
ble_att_svr_test_misc_prep_write(conn_handle, 1, 0, data, 20, 0);
|
ble_att_svr_test_misc_prep_write(conn_handle, 1, 20, data + 20, 20, 0);
|
ble_att_svr_test_misc_exec_write(conn_handle, BLE_ATT_EXEC_WRITE_F_EXECUTE,
|
0, 0);
|
ble_att_svr_test_misc_verify_w_1(data, 40);
|
|
/*** Successful three part write. */
|
ble_att_svr_test_misc_prep_write(conn_handle, 1, 0, data, 35, 0);
|
ble_att_svr_test_misc_prep_write(conn_handle, 1, 35, data + 35, 43, 0);
|
ble_att_svr_test_misc_prep_write(conn_handle, 1, 78, data + 78, 1, 0);
|
ble_att_svr_test_misc_exec_write(conn_handle, BLE_ATT_EXEC_WRITE_F_EXECUTE,
|
0, 0);
|
ble_att_svr_test_misc_verify_w_1(data, 79);
|
|
/*** Successful two part write to two attributes. */
|
ble_att_svr_test_misc_prep_write(conn_handle, 1, 0, data, 7, 0);
|
ble_att_svr_test_misc_prep_write(conn_handle, 1, 7, data + 7, 10, 0);
|
ble_att_svr_test_misc_prep_write(conn_handle, 2, 0, data, 20, 0);
|
ble_att_svr_test_misc_prep_write(conn_handle, 2, 20, data + 20, 10, 0);
|
ble_att_svr_test_misc_exec_write(conn_handle, BLE_ATT_EXEC_WRITE_F_EXECUTE,
|
0, 0);
|
ble_att_svr_test_misc_verify_w_1(data, 17);
|
ble_att_svr_test_misc_verify_w_2(data, 30);
|
|
/*** Fail write to second attribute; ensure first write doesn't occur. */
|
ble_att_svr_test_misc_prep_write(conn_handle, 1, 0, data, 5, 0);
|
ble_att_svr_test_misc_prep_write(conn_handle, 1, 5, data + 5, 2, 0);
|
ble_att_svr_test_misc_prep_write(conn_handle, 2, 0, data, 11, 0);
|
ble_att_svr_test_misc_prep_write(conn_handle, 2, 12, data + 11, 19, 0);
|
ble_att_svr_test_misc_exec_write(conn_handle, BLE_ATT_EXEC_WRITE_F_EXECUTE,
|
BLE_ATT_ERR_INVALID_OFFSET, 2);
|
ble_att_svr_test_misc_verify_w_1(data, 17);
|
ble_att_svr_test_misc_verify_w_2(data, 30);
|
|
/*** Successful out of order write to two attributes. */
|
ble_att_svr_test_misc_prep_write(conn_handle, 1, 0, data, 9, 0);
|
ble_att_svr_test_misc_prep_write(conn_handle, 2, 0, data, 18, 0);
|
ble_att_svr_test_misc_prep_write(conn_handle, 1, 9, data + 9, 3, 0);
|
ble_att_svr_test_misc_prep_write(conn_handle, 2, 18, data + 18, 43, 0);
|
ble_att_svr_test_misc_exec_write(conn_handle, BLE_ATT_EXEC_WRITE_F_EXECUTE,
|
0, 0);
|
ble_att_svr_test_misc_verify_w_1(data, 12);
|
ble_att_svr_test_misc_verify_w_2(data, 61);
|
|
/*** Fail due to attribute callback error. */
|
ble_att_svr_test_misc_prep_write(conn_handle, 6, 0, data, 35, 0);
|
ble_att_svr_test_misc_prep_write(conn_handle, 6, 35, data + 35, 43, 0);
|
ble_att_svr_test_misc_prep_write(conn_handle, 6, 78, data + 78, 1, 0);
|
ble_att_svr_test_misc_exec_write(conn_handle, BLE_ATT_EXEC_WRITE_F_EXECUTE,
|
BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN, 6);
|
|
ble_att_svr_test_assert_mbufs_freed();
|
}
|
|
TEST_CASE_SELF(ble_att_svr_test_notify)
|
{
|
uint16_t conn_handle;
|
|
conn_handle = ble_att_svr_test_misc_init(0);
|
|
/*** Successful notifies; verify callback is executed. */
|
/* 3-length attribute. */
|
ble_att_svr_test_misc_verify_notify(conn_handle, 10,
|
(uint8_t[]) { 1, 2, 3 }, 3, 1);
|
/* 1-length attribute. */
|
ble_att_svr_test_misc_verify_notify(conn_handle, 1,
|
(uint8_t[]) { 0xff }, 1, 1);
|
/* 0-length attribute. */
|
ble_att_svr_test_misc_verify_notify(conn_handle, 43, NULL, 0, 1);
|
|
/*** Bad notifies; verify callback is not executed. */
|
/* Attribute handle of 0. */
|
ble_att_svr_test_misc_verify_notify(conn_handle, 0,
|
(uint8_t[]) { 1, 2, 3 }, 3, 0);
|
|
ble_att_svr_test_assert_mbufs_freed();
|
}
|
|
TEST_CASE_SELF(ble_att_svr_test_prep_write_tmo)
|
{
|
int32_t ticks_from_now;
|
uint16_t conn_handle;
|
int rc;
|
int i;
|
|
static uint8_t data[1024];
|
|
conn_handle = ble_att_svr_test_misc_init(205);
|
|
/* Initialize some attribute data. */
|
for (i = 0; i < sizeof data; i++) {
|
data[i] = i;
|
}
|
|
/* Register a writable attribute. */
|
ble_att_svr_test_misc_register_uuid(BLE_UUID16_DECLARE(0x1234),
|
HA_FLAG_PERM_RW, 1,
|
ble_att_svr_test_misc_attr_fn_w_1);
|
|
/* Ensure timer is not set. */
|
ticks_from_now = ble_hs_conn_timer();
|
TEST_ASSERT_FATAL(ticks_from_now == BLE_HS_FOREVER);
|
|
/* Receive a prepare write request. */
|
ble_att_svr_test_misc_prep_write(conn_handle, 1, 0, data, 7, 0);
|
|
/* Ensure timer will expire in 30 seconds. */
|
ticks_from_now = ble_hs_conn_timer();
|
TEST_ASSERT(ticks_from_now == BLE_HS_ATT_SVR_QUEUED_WRITE_TMO);
|
|
/* Almost let the timer expire. */
|
os_time_advance(BLE_HS_ATT_SVR_QUEUED_WRITE_TMO - 1);
|
ticks_from_now = ble_hs_conn_timer();
|
TEST_ASSERT(ticks_from_now == 1);
|
|
/* Receive a second prepare write request. */
|
ble_att_svr_test_misc_prep_write(conn_handle, 1, 7, data + 7, 10, 0);
|
|
/* Ensure timer got reset. */
|
ticks_from_now = ble_hs_conn_timer();
|
TEST_ASSERT(ticks_from_now == BLE_HS_ATT_SVR_QUEUED_WRITE_TMO);
|
|
/* Allow the timer to expire. */
|
ble_hs_test_util_hci_ack_set_disconnect(0);
|
os_time_advance(BLE_HS_ATT_SVR_QUEUED_WRITE_TMO);
|
ticks_from_now = ble_hs_conn_timer();
|
TEST_ASSERT(ticks_from_now == BLE_HS_FOREVER);
|
|
/* Ensure connection was terminated. */
|
ble_hs_test_util_hci_verify_tx_disconnect(2, BLE_ERR_REM_USER_CONN_TERM);
|
|
/* Free connection. This is needed so that the prep write mbufs get
|
* freed and no mbuf leak gets reported.
|
*/
|
rc = ble_hs_atomic_conn_delete(conn_handle);
|
TEST_ASSERT_FATAL(rc == 0);
|
|
ble_att_svr_test_assert_mbufs_freed();
|
}
|
|
TEST_CASE_SELF(ble_att_svr_test_indicate)
|
{
|
uint16_t conn_handle;
|
|
conn_handle = ble_att_svr_test_misc_init(0);
|
|
/*** Successful indicates; verify callback is executed. */
|
/* 3-length attribute. */
|
ble_att_svr_test_misc_verify_indicate(conn_handle, 10,
|
(uint8_t[]) { 1, 2, 3 }, 3, 1);
|
/* 1-length attribute. */
|
ble_att_svr_test_misc_verify_indicate(conn_handle, 1,
|
(uint8_t[]) { 0xff }, 1, 1);
|
/* 0-length attribute. */
|
ble_att_svr_test_misc_verify_indicate(conn_handle, 43, NULL, 0, 1);
|
|
/*** Bad indicates; verify callback is not executed. */
|
/* Attribute handle of 0. */
|
ble_att_svr_test_misc_verify_indicate(conn_handle, 0,
|
(uint8_t[]) { 1, 2, 3 }, 3, 0);
|
|
ble_att_svr_test_assert_mbufs_freed();
|
}
|
|
TEST_CASE_SELF(ble_att_svr_test_oom)
|
{
|
struct os_mbuf *oms;
|
uint16_t conn_handle;
|
int rc;
|
|
conn_handle = ble_att_svr_test_misc_init(0);
|
|
/* Register an attribute (primary service) for incoming read commands. */
|
ble_att_svr_test_misc_register_uuid(
|
BLE_UUID16_DECLARE(BLE_ATT_UUID_PRIMARY_SERVICE),
|
HA_FLAG_PERM_RW, 1, ble_att_svr_test_misc_attr_fn_rw_1);
|
ble_att_svr_test_attr_w_1_len = 2;
|
ble_att_svr_test_attr_w_1[0] = 0x12;
|
ble_att_svr_test_attr_w_1[1] = 0x34;
|
|
/* Exhaust the msys pool. Leave one mbuf for the forthcoming request. */
|
oms = ble_hs_test_util_mbuf_alloc_all_but(1);
|
|
/*** MTU; always respond affirmatively, even when no mbufs. */
|
|
/* Receive a request. */
|
rc = ble_hs_test_util_rx_att_mtu_cmd(conn_handle, 1, 100);
|
TEST_ASSERT_FATAL(rc == 0);
|
|
/* Ensure we were able to send a real response. */
|
ble_att_svr_test_misc_verify_tx_mtu_rsp(conn_handle);
|
|
/*** Find information; always respond affirmatively, even when no mbufs. */
|
ble_hs_test_util_prev_tx_dequeue();
|
|
/* Receive a request. */
|
rc = ble_hs_test_util_rx_att_find_info_req(conn_handle, 1, 100);
|
TEST_ASSERT_FATAL(rc == 0);
|
|
/* Ensure we were able to send a real response. */
|
ble_hs_test_util_verify_tx_find_info_rsp(
|
(struct ble_hs_test_util_att_info_entry[]) {
|
{ .handle = 1, .uuid = BLE_UUID16_DECLARE(BLE_ATT_UUID_PRIMARY_SERVICE) },
|
{ 0 },
|
});
|
|
/*** Find by type value. */
|
ble_hs_test_util_prev_tx_dequeue();
|
|
/* Receive a request. */
|
rc = ble_hs_test_util_rx_att_find_type_value_req(
|
conn_handle, 1, 100, 0x0001, ((uint8_t[2]){0x99, 0x99}), 2);
|
TEST_ASSERT_FATAL(rc == BLE_HS_ENOMEM);
|
|
/* Ensure we were able to send an error response. */
|
ble_hs_test_util_verify_tx_err_rsp(BLE_ATT_OP_FIND_TYPE_VALUE_REQ, 1,
|
BLE_ATT_ERR_INSUFFICIENT_RES);
|
|
/*** Read by type; always respond affirmatively, even when no mbufs. */
|
ble_hs_test_util_prev_tx_dequeue();
|
|
/* Receive a request. */
|
rc = ble_hs_test_util_rx_att_read_type_req16(conn_handle, 100, 0xffff,
|
BLE_ATT_UUID_PRIMARY_SERVICE);
|
TEST_ASSERT_FATAL(rc == BLE_HS_ENOENT);
|
|
/* Ensure we were able to send a non-OOM error response. */
|
ble_hs_test_util_verify_tx_err_rsp(BLE_ATT_OP_READ_TYPE_REQ, 100,
|
BLE_ATT_ERR_ATTR_NOT_FOUND);
|
|
/*** Read; always respond affirmatively, even when no mbufs. */
|
ble_hs_test_util_prev_tx_dequeue();
|
|
/* Receive a request. */
|
rc = ble_hs_test_util_rx_att_read_req(conn_handle, 1);
|
TEST_ASSERT_FATAL(rc == 0);
|
|
/* Ensure we were able to send a real response. */
|
ble_hs_test_util_verify_tx_read_rsp(ble_att_svr_test_attr_w_1,
|
ble_att_svr_test_attr_w_1_len);
|
|
/*** Read blob; always respond affirmatively, even when no mbufs. */
|
ble_hs_test_util_prev_tx_dequeue();
|
|
/* Receive a request. */
|
rc = ble_hs_test_util_rx_att_read_blob_req(conn_handle, 1, 0);
|
TEST_ASSERT_FATAL(rc == 0);
|
|
/* Ensure we were able to send a real response. */
|
ble_hs_test_util_verify_tx_read_blob_rsp(ble_att_svr_test_attr_w_1,
|
ble_att_svr_test_attr_w_1_len);
|
|
/*** Read multiple. */
|
ble_hs_test_util_prev_tx_dequeue();
|
|
/* Receive a request. */
|
rc = ble_hs_test_util_rx_att_read_mult_req(conn_handle,
|
((uint16_t[2]){0x0001, 0x0002}),
|
2);
|
TEST_ASSERT_FATAL(rc == BLE_HS_ENOMEM);
|
|
/* Ensure we were able to send an error response. */
|
ble_hs_test_util_verify_tx_err_rsp(BLE_ATT_OP_READ_MULT_REQ, 0,
|
BLE_ATT_ERR_INSUFFICIENT_RES);
|
|
/***
|
* Read by group type; always respond affirmatively, even when no
|
* mbufs.
|
*/
|
ble_hs_test_util_prev_tx_dequeue();
|
|
/* Receive a request. */
|
rc = ble_hs_test_util_rx_att_read_group_type_req16(
|
conn_handle, 11, 100, BLE_ATT_UUID_PRIMARY_SERVICE);
|
TEST_ASSERT_FATAL(rc == BLE_HS_ENOENT);
|
|
/* Ensure we were able to send a non-OOM error response. */
|
ble_hs_test_util_verify_tx_err_rsp(BLE_ATT_OP_READ_GROUP_TYPE_REQ, 11,
|
BLE_ATT_ERR_ATTR_NOT_FOUND);
|
|
/*** Write. */
|
ble_hs_test_util_prev_tx_dequeue();
|
|
/* Receive a request. */
|
rc = ble_hs_test_util_rx_att_write_req(conn_handle, 1,
|
((uint8_t[1]){1}), 1);
|
TEST_ASSERT_FATAL(rc == BLE_HS_ENOMEM);
|
|
/* Ensure we were able to send an error response. */
|
ble_hs_test_util_verify_tx_err_rsp(BLE_ATT_OP_WRITE_REQ, 1,
|
BLE_ATT_ERR_INSUFFICIENT_RES);
|
|
/*** Write command; no response. */
|
ble_hs_test_util_prev_tx_dequeue();
|
|
/* Receive a request. */
|
rc = ble_hs_test_util_rx_att_write_cmd(conn_handle, 1,
|
((uint8_t[1]){1}), 1);
|
TEST_ASSERT_FATAL(rc == 0);
|
|
/* Ensure no response sent. */
|
TEST_ASSERT(ble_hs_test_util_prev_tx_dequeue() == NULL);
|
|
/*** Prepare write. */
|
ble_hs_test_util_prev_tx_dequeue();
|
|
/* Receive a request. */
|
rc = ble_hs_test_util_rx_att_prep_write_req(conn_handle, 1, 0,
|
((uint8_t[1]){1}), 1);
|
TEST_ASSERT_FATAL(rc == BLE_HS_ENOMEM);
|
|
/* Ensure we were able to send an error response. */
|
ble_hs_test_util_verify_tx_err_rsp(BLE_ATT_OP_PREP_WRITE_REQ, 1,
|
BLE_ATT_ERR_INSUFFICIENT_RES);
|
|
/*** Notify; no response. */
|
ble_hs_test_util_prev_tx_dequeue();
|
|
/* Receive a request. */
|
rc = ble_hs_test_util_rx_att_notify_req(conn_handle, 1,
|
((uint8_t[1]){1}), 1);
|
TEST_ASSERT_FATAL(rc == 0);
|
|
/* Ensure no response sent. */
|
TEST_ASSERT(ble_hs_test_util_prev_tx_dequeue() == NULL);
|
|
/*** Indicate. */
|
ble_hs_test_util_prev_tx_dequeue();
|
|
/* Receive a request. */
|
rc = ble_hs_test_util_rx_att_indicate_req(conn_handle, 1,
|
((uint8_t[1]){1}), 1);
|
TEST_ASSERT_FATAL(rc == BLE_HS_ENOMEM);
|
|
/* Ensure we were able to send a real response. */
|
ble_hs_test_util_verify_tx_err_rsp(BLE_ATT_OP_INDICATE_REQ, 1,
|
BLE_ATT_ERR_INSUFFICIENT_RES);
|
|
rc = os_mbuf_free_chain(oms);
|
TEST_ASSERT_FATAL(rc == 0);
|
|
ble_att_svr_test_assert_mbufs_freed();
|
}
|
|
TEST_CASE_SELF(ble_att_svr_test_unsupported_req)
|
{
|
uint16_t conn_handle;
|
int rc;
|
uint8_t buf[] = {0x3f, 0x00, 0x00, 0x01, 0x02, 0x03};
|
|
conn_handle = ble_att_svr_test_misc_init(0);
|
|
/* Put handle into buf */
|
(*(uint16_t *)&buf[1]) = htole16(conn_handle);
|
rc = ble_hs_test_util_l2cap_rx_payload_flat(conn_handle, BLE_L2CAP_CID_ATT,
|
buf, sizeof buf);
|
TEST_ASSERT(rc != 0);
|
ble_hs_test_util_verify_tx_err_rsp(0x3f, 0,
|
BLE_ATT_ERR_REQ_NOT_SUPPORTED);
|
|
/* Check for no response when unknown command is sent */
|
buf[0] = 0x4f;
|
rc = ble_hs_test_util_l2cap_rx_payload_flat(conn_handle, BLE_L2CAP_CID_ATT,
|
buf, sizeof buf);
|
TEST_ASSERT(rc != 0);
|
|
/* Ensure no response sent. */
|
TEST_ASSERT(ble_hs_test_util_prev_tx_dequeue() == NULL);
|
|
ble_att_svr_test_assert_mbufs_freed();
|
}
|
|
TEST_SUITE(ble_att_svr_suite)
|
{
|
ble_att_svr_test_mtu();
|
ble_att_svr_test_read();
|
ble_att_svr_test_read_blob();
|
ble_att_svr_test_read_mult();
|
ble_att_svr_test_write();
|
ble_att_svr_test_find_info();
|
ble_att_svr_test_find_type_value();
|
ble_att_svr_test_read_type();
|
ble_att_svr_test_read_group_type();
|
ble_att_svr_test_prep_write();
|
ble_att_svr_test_prep_write_tmo();
|
ble_att_svr_test_notify();
|
ble_att_svr_test_indicate();
|
ble_att_svr_test_oom();
|
ble_att_svr_test_unsupported_req();
|
}
|
