espressif/esp-nimble
1
0
Fork 0
mirror of https://github.com/espressif/esp-nimble.git synced 2026-07-28 21:57:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

nimble/host: Add generic type for BD address

Browse Source 
This patch introduces ble_addr_t (with additional helpers/symbols) type
to pass complete device address via API instead of separate type and
address value.

Note that it only makes sure public APIs use new type. Both apps and
host internals may still use type/addr combination in many places, but
this can be changed later without affecting backwards compatibility.

X-Original-Commit: 6d0e7fb8aef7f767949b767478c88df0ce0f7cdb
This commit is contained in:
Andrzej Kaczmarek
2017-02-01 22:24:57 +01:00
parent 844550400b
commit 35c71a4dcd
30 changed files with 510 additions and 599 deletions
Download Patch File Download Diff File Expand all files Collapse all files
nimble/controller/src/ble_ll_adv.c
+4 -4
View File
@@ -1127,9 +1127,9 @@ ble_ll_adv_rx_req(uint8_t pdu_type, struct os_mbuf *rxpdu)
/* Get the peer address type */
if (rxbuf[0] & BLE_ADV_PDU_HDR_TXADD_MASK) {
txadd = BLE_ADDR_TYPE_RANDOM;
txadd = BLE_ADDR_RANDOM;
} else {
txadd = BLE_ADDR_TYPE_PUBLIC;
txadd = BLE_ADDR_PUBLIC;
}
ble_hdr = BLE_MBUF_HDR_PTR(rxpdu);
@@ -1218,9 +1218,9 @@ ble_ll_adv_conn_req_rxd(uint8_t *rxbuf, struct ble_mbuf_hdr *hdr,
valid = 1;
if (rxbuf[0] & BLE_ADV_PDU_HDR_TXADD_MASK) {
addr_type = BLE_ADDR_TYPE_RANDOM;
addr_type = BLE_ADDR_RANDOM;
} else {
addr_type = BLE_ADDR_TYPE_PUBLIC;
addr_type = BLE_ADDR_PUBLIC;
}
/*
nimble/controller/src/ble_ll_scan.c
+2 -2
View File
@@ -945,9 +945,9 @@ ble_ll_scan_rx_isr_end(struct os_mbuf *rxpdu, uint8_t crcok)
pdu_type = rxbuf[0] & BLE_ADV_PDU_HDR_TYPE_MASK;
peer = rxbuf + BLE_LL_PDU_HDR_LEN;
if (rxbuf[0] & BLE_ADV_PDU_HDR_TXADD_MASK) {
addr_type = BLE_ADDR_TYPE_RANDOM;
addr_type = BLE_ADDR_RANDOM;
} else {
addr_type = BLE_ADDR_TYPE_PUBLIC;
addr_type = BLE_ADDR_PUBLIC;
}
peer_addr_type = addr_type;
nimble/drivers/nrf52/src/ble_hw.c
+2 -2
View File
@@ -90,7 +90,7 @@ ble_hw_whitelist_add(uint8_t *addr, uint8_t addr_type)
if ((mask & g_ble_hw_whitelist_mask) == 0) {
NRF_RADIO->DAB[i] = get_le32(addr);
NRF_RADIO->DAP[i] = get_le16(addr + 4);
if (addr_type == BLE_ADDR_TYPE_RANDOM) {
if (addr_type == BLE_ADDR_RANDOM) {
NRF_RADIO->DACNF |= (mask << 8);
}
g_ble_hw_whitelist_mask |= mask;
@@ -128,7 +128,7 @@ ble_hw_whitelist_rmv(uint8_t *addr, uint8_t addr_type)
if (mask & g_ble_hw_whitelist_mask) {
if ((dab == NRF_RADIO->DAB[i]) && (dap == NRF_RADIO->DAP[i])) {
cfg_addr = txadd & mask;
if (addr_type == BLE_ADDR_TYPE_RANDOM) {
if (addr_type == BLE_ADDR_RANDOM) {
if (cfg_addr != 0) {
break;
}
nimble/host/include/host/ble_gap.h
+12 -28
View File
@@ -91,9 +91,6 @@ struct hci_conn_update;
#define BLE_GAP_INITIAL_CONN_MIN_CE_LEN 0x0010
#define BLE_GAP_INITIAL_CONN_MAX_CE_LEN 0x0300
#define BLE_GAP_ADDR_TYPE_WL 0xff
#define BLE_GAP_ADDR_TYPE_NONE 0xfe
#define BLE_GAP_ROLE_MASTER 0
#define BLE_GAP_ROLE_SLAVE 1
@@ -166,18 +163,14 @@ struct ble_gap_adv_params {
struct ble_gap_conn_desc {
struct ble_gap_sec_state sec_state;
uint8_t peer_ota_addr[6];
uint8_t peer_id_addr[6];
uint8_t our_id_addr[6];
uint8_t our_ota_addr[6];
ble_addr_t our_id_addr;
ble_addr_t peer_id_addr;
ble_addr_t our_ota_addr;
ble_addr_t peer_ota_addr;
uint16_t conn_handle;
uint16_t conn_itvl;
uint16_t conn_latency;
uint16_t supervision_timeout;
uint8_t peer_ota_addr_type;
uint8_t peer_id_addr_type;
uint8_t our_id_addr_type;
uint8_t our_ota_addr_type;
uint8_t role;
uint8_t master_clock_accuracy;
};
@@ -219,18 +212,16 @@ struct ble_gap_passkey_params {
struct ble_gap_disc_desc {
/*** Common fields. */
uint8_t event_type;
uint8_t addr_type;
uint8_t length_data;
ble_addr_t addr;
int8_t rssi;
uint8_t addr[6];
uint8_t *data;
/***
* LE direct advertising report fields; direct_addr_type is
* BLE_GAP_ADDR_TYPE_NONE if direct address fields are not present.
* LE direct advertising report fields; direct_addr is BLE_ADDR_ANY if
* direct address fields are not present.
*/
uint8_t direct_addr_type;
uint8_t direct_addr[6];
ble_addr_t direct_addr;
};
/**
@@ -526,17 +517,12 @@ typedef int ble_gap_event_fn(struct ble_gap_event *event, void *arg);
#define BLE_GAP_DISC_MODE_LTD 1
#define BLE_GAP_DISC_MODE_GEN 2
struct ble_gap_white_entry {
uint8_t addr_type;
uint8_t addr[6];
};
int ble_gap_conn_find(uint16_t handle, struct ble_gap_conn_desc *out_desc);
int ble_gap_set_event_cb(uint16_t conn_handle,
ble_gap_event_fn *cb, void *cb_arg);
int ble_gap_adv_start(uint8_t own_addr_type, uint8_t peer_addr_type,
const uint8_t *peer_addr, int32_t duration_ms,
int ble_gap_adv_start(uint8_t own_addr_type, const ble_addr_t *direct_addr,
int32_t duration_ms,
const struct ble_gap_adv_params *adv_params,
ble_gap_event_fn *cb, void *cb_arg);
int ble_gap_adv_stop(void);
@@ -550,16 +536,14 @@ int ble_gap_disc(uint8_t own_addr_type, int32_t duration_ms,
ble_gap_event_fn *cb, void *cb_arg);
int ble_gap_disc_cancel(void);
int ble_gap_disc_active(void);
int ble_gap_connect(uint8_t own_addr_type,
uint8_t peer_addr_type, const uint8_t *peer_addr,
int ble_gap_connect(uint8_t own_addr_type, const ble_addr_t *peer_addr,
int32_t duration_ms,
const struct ble_gap_conn_params *params,
ble_gap_event_fn *cb, void *cb_arg);
int ble_gap_conn_cancel(void);
int ble_gap_conn_active(void);
int ble_gap_terminate(uint16_t conn_handle, uint8_t hci_reason);
int ble_gap_wl_set(const struct ble_gap_white_entry *white_list,
uint8_t white_list_count);
int ble_gap_wl_set(const ble_addr_t *addr, uint8_t white_list_count);
int ble_gap_update_params(uint16_t conn_handle,
const struct ble_gap_upd_params *params);
int ble_gap_dbg_update_active(uint16_t conn_handle);
nimble/host/include/host/ble_hs_id.h
+2 -1
View File
@@ -21,12 +21,13 @@
#define H_BLE_HS_ID_
#include <inttypes.h>
#include "nimble/ble.h"
#ifdef __cplusplus
extern "C" {
#endif
int ble_hs_id_gen_rnd(int nrpa, uint8_t *out_addr);
int ble_hs_id_gen_rnd(int nrpa, ble_addr_t *out_addr);
int ble_hs_id_set_rnd(const uint8_t *rnd_addr);
int ble_hs_id_copy_addr(uint8_t id_addr_type, uint8_t *out_id_addr,
int *out_is_nrpa);
nimble/host/include/host/ble_store.h
+8 -15
View File
@@ -21,6 +21,7 @@
#define H_BLE_STORE_
#include <inttypes.h>
#include "nimble/ble.h"
#ifdef __cplusplus
extern "C" {
@@ -30,7 +31,7 @@ extern "C" {
#define BLE_STORE_OBJ_TYPE_PEER_SEC 2
#define BLE_STORE_OBJ_TYPE_CCCD 3
#define BLE_STORE_ADDR_TYPE_NONE 0xff
//#define BLE_STORE_ADDR_TYPE_NONE 0xff
/**
* Used as a key for lookups of security material. This struct corresponds to
@@ -41,14 +42,9 @@ extern "C" {
struct ble_store_key_sec {
/**
* Key by peer identity address;
* Valid peer_addr_type values;
* o BLE_ADDR_TYPE_PUBLIC
* o BLE_ADDR_TYPE_RANDOM
* o BLE_STORE_ADDR_TYPE_NONE
* peer_addr_type=BLE_STORE_ADDR_TYPE_NONE means don't key off peer.
* peer_addr=BLE_ADDR_NONE means don't key off peer.
*/
uint8_t peer_addr[6];
uint8_t peer_addr_type;
ble_addr_t peer_addr;
/** Key by ediv; ediv_rand_present=0 means don't key off ediv. */
uint16_t ediv;
@@ -69,8 +65,7 @@ struct ble_store_key_sec {
* o BLE_STORE_OBJ_TYPE_PEER_SEC
*/
struct ble_store_value_sec {
uint8_t peer_addr[6];
uint8_t peer_addr_type;
ble_addr_t peer_addr;
uint8_t key_size;
uint16_t ediv;
@@ -95,10 +90,9 @@ struct ble_store_value_sec {
struct ble_store_key_cccd {
/**
* Key by peer identity address;
* peer_addr_type=BLE_STORE_ADDR_TYPE_NONE means don't key off peer.
* peer_addr=BLE_ADDR_NONE means don't key off peer.
*/
uint8_t peer_addr[6];
uint8_t peer_addr_type;
ble_addr_t peer_addr;
/**
* Key by characteristic value handle;
@@ -115,8 +109,7 @@ struct ble_store_key_cccd {
* This struct corresponds to the BLE_STORE_OBJ_TYPE_CCCD store object type.
*/
struct ble_store_value_cccd {
uint8_t peer_addr[6];
uint8_t peer_addr_type;
ble_addr_t peer_addr;
uint16_t chr_val_handle;
uint16_t flags;
unsigned value_changed:1;
nimble/host/src/ble_att_svr.c
+1 -2
View File
@@ -282,8 +282,7 @@ ble_att_svr_check_perms(uint16_t conn_handle, int is_read,
ble_hs_conn_addrs(conn, &addrs);
memset(&key_sec, 0, sizeof key_sec);
key_sec.peer_addr_type = addrs.peer_id_addr_type;
memcpy(key_sec.peer_addr, addrs.peer_id_addr, 6);
key_sec.peer_addr = addrs.peer_id_addr;
}
ble_hs_unlock();
nimble/host/src/ble_gap.c
+75 -109
View File
@@ -235,15 +235,12 @@ ble_gap_log_duration(int32_t duration_ms)
}
static void
ble_gap_log_conn(uint8_t own_addr_type,
uint8_t peer_addr_type, const uint8_t *peer_addr,
ble_gap_log_conn(uint8_t own_addr_type, const ble_addr_t *peer_addr,
const struct ble_gap_conn_params *params)
{
BLE_HS_LOG(INFO, "peer_addr_type=%d peer_addr=", peer_addr_type);
if (peer_addr == NULL) {
BLE_HS_LOG(INFO, "N/A");
} else {
BLE_HS_LOG_ADDR(INFO, peer_addr);
if (peer_addr != NULL) {
BLE_HS_LOG(INFO, "peer_addr_type=%d peer_addr=", peer_addr->type);
BLE_HS_LOG_ADDR(INFO, peer_addr->val);
}
BLE_HS_LOG(INFO, " scan_itvl=%d scan_window=%d itvl_min=%d itvl_max=%d "
@@ -278,34 +275,27 @@ ble_gap_log_update(uint16_t conn_handle,
}
static void
ble_gap_log_wl(const struct ble_gap_white_entry *white_list,
uint8_t white_list_count)
ble_gap_log_wl(const ble_addr_t *addr, uint8_t white_list_count)
{
const struct ble_gap_white_entry *entry;
int i;
BLE_HS_LOG(INFO, "count=%d ", white_list_count);
for (i = 0; i < white_list_count; i++) {
entry = white_list + i;
BLE_HS_LOG(INFO, "entry-%d={addr_type=%d addr=", i, entry->addr_type);
BLE_HS_LOG_ADDR(INFO, entry->addr);
for (i = 0; i < white_list_count; i++, addr++) {
BLE_HS_LOG(INFO, "entry-%d={addr_type=%d addr=", i, addr->type);
BLE_HS_LOG_ADDR(INFO, addr->val);
BLE_HS_LOG(INFO, "} ");
}
}
static void
ble_gap_log_adv(uint8_t own_addr_type, uint8_t peer_addr_type,
const uint8_t *peer_addr,
ble_gap_log_adv(uint8_t own_addr_type, const ble_addr_t *direct_addr,
const struct ble_gap_adv_params *adv_params)
{
BLE_HS_LOG(INFO, "disc_mode=%d peer_addr_type=%d peer_addr=",
ble_gap_slave.disc_mode, peer_addr_type);
if(peer_addr) {
BLE_HS_LOG_ADDR(INFO, peer_addr);
} else {
BLE_HS_LOG(INFO, "none");
BLE_HS_LOG(INFO, "disc_mode=%d", ble_gap_slave.disc_mode);
if (direct_addr) {
BLE_HS_LOG(INFO, " direct_addr_type=%d direct_addr=", direct_addr->type);
BLE_HS_LOG_ADDR(INFO, direct_addr->val);
}
BLE_HS_LOG(INFO, " adv_channel_map=%d own_addr_type=%d "
"adv_filter_policy=%d adv_itvl_min=%d adv_itvl_max=%d "
@@ -330,14 +320,10 @@ ble_gap_fill_conn_desc(struct ble_hs_conn *conn,
ble_hs_conn_addrs(conn, &addrs);
desc->our_ota_addr_type = addrs.our_ota_addr_type;
memcpy(desc->our_ota_addr, addrs.our_ota_addr, 6);
desc->our_id_addr_type = addrs.our_id_addr_type;
memcpy(desc->our_id_addr, addrs.our_id_addr, 6);
desc->peer_ota_addr_type = addrs.peer_ota_addr_type;
memcpy(desc->peer_ota_addr, addrs.peer_ota_addr, 6);
desc->peer_id_addr_type = addrs.peer_id_addr_type;
memcpy(desc->peer_id_addr, addrs.peer_id_addr, 6);
desc->our_id_addr = addrs.our_id_addr;
desc->peer_id_addr = addrs.peer_id_addr;
desc->our_ota_addr = addrs.our_ota_addr;
desc->peer_ota_addr = addrs.peer_ota_addr;
desc->conn_handle = conn->bhc_handle;
desc->conn_itvl = conn->bhc_itvl;
@@ -1169,12 +1155,6 @@ ble_gap_rx_conn_complete(struct hci_le_conn_complete *evt)
BLE_HS_DBG_ASSERT(conn != NULL);
conn->bhc_handle = evt->connection_handle;
memcpy(conn->bhc_peer_addr, evt->peer_addr, sizeof conn->bhc_peer_addr);
conn->bhc_peer_addr_type = evt->peer_addr_type;
memcpy(conn->bhc_our_rpa_addr, evt->local_rpa,
sizeof conn->bhc_our_rpa_addr);
memcpy(conn->bhc_peer_rpa_addr, evt->peer_rpa,
sizeof conn->bhc_peer_rpa_addr);
conn->bhc_itvl = evt->conn_itvl;
conn->bhc_latency = evt->conn_latency;
conn->bhc_supervision_timeout = evt->supervision_timeout;
@@ -1192,8 +1172,14 @@ ble_gap_rx_conn_complete(struct hci_le_conn_complete *evt)
ble_gap_slave_reset_state();
}
memcpy(conn->bhc_our_rpa_addr, evt->local_rpa, 6);
memcpy(conn->bhc_peer_rpa_addr, evt->peer_rpa, 6);
conn->bhc_peer_addr.type = evt->peer_addr_type;
memcpy(conn->bhc_peer_addr.val, evt->peer_addr, 6);
conn->bhc_our_rpa_addr.type = BLE_ADDR_RANDOM;
memcpy(conn->bhc_our_rpa_addr.val, evt->local_rpa, 6);
conn->bhc_peer_rpa_addr.type = BLE_ADDR_RANDOM;
memcpy(conn->bhc_peer_rpa_addr.val, evt->peer_rpa, 6);
ble_hs_lock();
@@ -1412,13 +1398,13 @@ ble_gap_wl_busy(void)
}
static int
ble_gap_wl_tx_add(const struct ble_gap_white_entry *entry)
ble_gap_wl_tx_add(const ble_addr_t *addr)
{
uint8_t buf[BLE_HCI_CMD_HDR_LEN + BLE_HCI_CHG_WHITE_LIST_LEN];
int rc;
rc = ble_hs_hci_cmd_build_le_add_to_whitelist(
entry->addr, entry->addr_type, buf, sizeof buf);
addr->val, addr->type, buf, sizeof buf);
if (rc != 0) {
return rc;
}
@@ -1449,14 +1435,13 @@ ble_gap_wl_tx_clear(void)
/**
* Overwrites the controller's white list with the specified contents.
*
* @param white_list The entries to write to the white list.
* @param addr The entries to write to the white list.
* @param white_list_count The number of entries in the white list.
*
* @return 0 on success; nonzero on failure.
*/
int
ble_gap_wl_set(const struct ble_gap_white_entry *white_list,
uint8_t white_list_count)
ble_gap_wl_set(const ble_addr_t *addr, uint8_t white_list_count)
{
#if !MYNEWT_VAL(BLE_WHITELIST)
return BLE_HS_ENOTSUP;
@@ -1475,8 +1460,8 @@ ble_gap_wl_set(const struct ble_gap_white_entry *white_list,
}
for (i = 0; i < white_list_count; i++) {
if (white_list[i].addr_type != BLE_ADDR_TYPE_PUBLIC &&
white_list[i].addr_type != BLE_ADDR_TYPE_RANDOM) {
if (addr[i].type != BLE_ADDR_PUBLIC &&
addr[i].type != BLE_ADDR_RANDOM) {
rc = BLE_HS_EINVAL;
goto done;
@@ -1489,7 +1474,7 @@ ble_gap_wl_set(const struct ble_gap_white_entry *white_list,
}
BLE_HS_LOG(INFO, "GAP procedure initiated: set whitelist; ");
ble_gap_log_wl(white_list, white_list_count);
ble_gap_log_wl(addr, white_list_count);
BLE_HS_LOG(INFO, "\n");
rc = ble_gap_wl_tx_clear();
@@ -1498,7 +1483,7 @@ ble_gap_wl_set(const struct ble_gap_white_entry *white_list,
}
for (i = 0; i < white_list_count; i++) {
rc = ble_gap_wl_tx_add(white_list + i);
rc = ble_gap_wl_tx_add(addr + i);
if (rc != 0) {
goto done;
}
@@ -1642,8 +1627,7 @@ ble_gap_adv_dflt_itvls(uint8_t conn_mode,
}
static int
ble_gap_adv_params_tx(uint8_t own_addr_type,
uint8_t peer_addr_type, const uint8_t *peer_addr,
ble_gap_adv_params_tx(uint8_t own_addr_type, const ble_addr_t *peer_addr,
const struct ble_gap_adv_params *adv_params)
{
@@ -1652,12 +1636,12 @@ ble_gap_adv_params_tx(uint8_t own_addr_type,
int rc;
if (peer_addr == NULL) {
peer_addr = ble_hs_misc_null_addr;
peer_addr = BLE_ADDR_ANY;
}
hci_adv_params.own_addr_type = own_addr_type;
hci_adv_params.peer_addr_type = peer_addr_type;
memcpy(hci_adv_params.peer_addr, peer_addr,
hci_adv_params.peer_addr_type = peer_addr->type;
memcpy(hci_adv_params.peer_addr, peer_addr->val,
sizeof hci_adv_params.peer_addr);
/* Fill optional fields if application did not specify them. */
@@ -1694,8 +1678,7 @@ ble_gap_adv_params_tx(uint8_t own_addr_type,
}
static int
ble_gap_adv_validate(uint8_t own_addr_type, uint8_t peer_addr_type,
const uint8_t *peer_addr,
ble_gap_adv_validate(uint8_t own_addr_type, const ble_addr_t *peer_addr,
const struct ble_gap_adv_params *adv_params)
{
if (adv_params == NULL) {
@@ -1737,10 +1720,10 @@ ble_gap_adv_validate(uint8_t own_addr_type, uint8_t peer_addr_type,
break;
case BLE_GAP_CONN_MODE_DIR:
if (peer_addr_type != BLE_ADDR_TYPE_PUBLIC &&
peer_addr_type != BLE_ADDR_TYPE_RANDOM &&
peer_addr_type != BLE_ADDR_TYPE_RPA_PUB_DEFAULT &&
peer_addr_type != BLE_ADDR_TYPE_RPA_RND_DEFAULT) {
if (peer_addr->type != BLE_ADDR_PUBLIC &&
peer_addr->type != BLE_ADDR_RANDOM &&
peer_addr->type != BLE_ADDR_PUBLIC_ID &&
peer_addr->type != BLE_ADDR_RANDOM_ID) {
return BLE_HS_EINVAL;
}
@@ -1768,18 +1751,12 @@ ble_gap_adv_validate(uint8_t own_addr_type, uint8_t peer_addr_type,
*
* @param own_addr_type The type of address the stack should use for
* itself. Valid values are:
* o BLE_ADDR_TYPE_PUBLIC
* o BLE_ADDR_TYPE_RANDOM
* o BLE_ADDR_TYPE_RPA_PUB_DEFAULT
* o BLE_ADDR_TYPE_RPA_RND_DEFAULT
* @param peer_addr_type Address type of the peer's identity address.
* Valid values are:
* o BLE_ADDR_TYPE_PUBLIC
* o BLE_ADDR_TYPE_RANDOM
* This parameter is ignored unless directed
* advertising is being used.
* @param peer_addr The peer's six-byte identity address.
* This parameter is ignored unless directed
* o BLE_OWN_ADDR_PUBLIC
* o BLE_OWN_ADDR_RANDOM
* o BLE_OWN_ADDR_RPA_PUBLIC_DEFAULT
* o BLE_OWN_ADDR_RPA_RANDOM_DEFAULT
* @param direct_addr The peer's address for directed advertising.
* This parameter shall be non-NULL if directed
* advertising is being used.
* @param duration_ms The duration of the advertisement procedure.
* On expiration, the procedure ends and a
@@ -1800,8 +1777,8 @@ ble_gap_adv_validate(uint8_t own_addr_type, uint8_t peer_addr_type,
* @return 0 on success; nonzero on failure.
*/
int
ble_gap_adv_start(uint8_t own_addr_type, uint8_t peer_addr_type,
const uint8_t *peer_addr, int32_t duration_ms,
ble_gap_adv_start(uint8_t own_addr_type, const ble_addr_t *direct_addr,
int32_t duration_ms,
const struct ble_gap_adv_params *adv_params,
ble_gap_event_fn *cb, void *cb_arg)
{
@@ -1816,8 +1793,7 @@ ble_gap_adv_start(uint8_t own_addr_type, uint8_t peer_addr_type,
ble_hs_lock();
rc = ble_gap_adv_validate(own_addr_type, peer_addr_type, peer_addr,
adv_params);
rc = ble_gap_adv_validate(own_addr_type, direct_addr, adv_params);
if (rc != 0) {
goto done;
}
@@ -1837,7 +1813,7 @@ ble_gap_adv_start(uint8_t own_addr_type, uint8_t peer_addr_type,
}
BLE_HS_LOG(INFO, "GAP procedure initiated: advertise; ");
ble_gap_log_adv(own_addr_type, peer_addr_type, peer_addr, adv_params);
ble_gap_log_adv(own_addr_type, direct_addr, adv_params);
BLE_HS_LOG(INFO, "\n");
ble_gap_slave.cb = cb;
@@ -1846,8 +1822,7 @@ ble_gap_adv_start(uint8_t own_addr_type, uint8_t peer_addr_type,
ble_gap_slave.disc_mode = adv_params->disc_mode;
ble_gap_slave.our_addr_type = own_addr_type;
rc = ble_gap_adv_params_tx(own_addr_type, peer_addr_type, peer_addr,
adv_params);
rc = ble_gap_adv_params_tx(own_addr_type, direct_addr, adv_params);
if (rc != 0) {
goto done;
}
@@ -2301,8 +2276,7 @@ ble_gap_disc_active(void)
*****************************************************************************/
static int
ble_gap_conn_create_tx(uint8_t own_addr_type,
uint8_t peer_addr_type, const uint8_t *peer_addr,
ble_gap_conn_create_tx(uint8_t own_addr_type, const ble_addr_t *peer_addr,
const struct ble_gap_conn_params *params)
{
uint8_t buf[BLE_HCI_CMD_HDR_LEN + BLE_HCI_CREATE_CONN_LEN];
@@ -2312,7 +2286,7 @@ ble_gap_conn_create_tx(uint8_t own_addr_type,
hcc.scan_itvl = params->scan_itvl;
hcc.scan_window = params->scan_window;
if (peer_addr_type == BLE_GAP_ADDR_TYPE_WL) {
if (peer_addr == NULL) {
/* Application wants to connect to any device in the white list. The
* peer address type and peer address fields are ignored by the
* controller; fill them with dummy values.
@@ -2322,8 +2296,8 @@ ble_gap_conn_create_tx(uint8_t own_addr_type,
memset(hcc.peer_addr, 0, sizeof hcc.peer_addr);
} else {
hcc.filter_policy = BLE_HCI_CONN_FILT_NO_WL;
hcc.peer_addr_type = peer_addr_type;
memcpy(hcc.peer_addr, peer_addr, sizeof hcc.peer_addr);
hcc.peer_addr_type = peer_addr->type;
memcpy(hcc.peer_addr, peer_addr->val, sizeof hcc.peer_addr);
}
hcc.own_addr_type = own_addr_type;
@@ -2352,19 +2326,13 @@ ble_gap_conn_create_tx(uint8_t own_addr_type,
*
* @param own_addr_type The type of address the stack should use for
* itself during connection establishment.
* o BLE_ADDR_TYPE_PUBLIC
* o BLE_ADDR_TYPE_RANDOM
* o BLE_ADDR_TYPE_RPA_PUB_DEFAULT
* o BLE_ADDR_TYPE_RPA_RND_DEFAULT
* @param peer_addr_type The peer's address type. One of:
* o BLE_HCI_CONN_PEER_ADDR_PUBLIC
* o BLE_HCI_CONN_PEER_ADDR_RANDOM
* o BLE_HCI_CONN_PEER_ADDR_PUBLIC_IDENT
* o BLE_HCI_CONN_PEER_ADDR_RANDOM_IDENT
* o BLE_GAP_ADDR_TYPE_WL
* @param peer_addr The identity address of the peer to connect to.
* This parameter is ignored when the white
* list is used.
* o BLE_OWN_ADDR_PUBLIC
* o BLE_OWN_ADDR_RANDOM
* o BLE_OWN_ADDR_RPA_PUBLIC_DEFAULT
* o BLE_OWN_ADDR_RPA_RANDOM_DEFAULT
* @param peer_addr The address of the peer to connect to.
* If this parameter is NULL, the white list
* is used.
* @param duration_ms The duration of the discovery procedure.
* On expiration, the procedure ends and a
* BLE_GAP_EVENT_DISC_COMPLETE event is
@@ -2390,8 +2358,7 @@ ble_gap_conn_create_tx(uint8_t own_addr_type,
* Other nonzero on error.
*/
int
ble_gap_connect(uint8_t own_addr_type,
uint8_t peer_addr_type, const uint8_t *peer_addr,
ble_gap_connect(uint8_t own_addr_type, const ble_addr_t *peer_addr,
int32_t duration_ms,
const struct ble_gap_conn_params *conn_params,
ble_gap_event_fn *cb, void *cb_arg)
@@ -2422,11 +2389,11 @@ ble_gap_connect(uint8_t own_addr_type,
goto done;
}
if (peer_addr_type != BLE_HCI_CONN_PEER_ADDR_PUBLIC &&
peer_addr_type != BLE_HCI_CONN_PEER_ADDR_RANDOM &&
peer_addr_type != BLE_HCI_CONN_PEER_ADDR_PUB_ID &&
peer_addr_type != BLE_HCI_CONN_PEER_ADDR_RAND_ID &&
peer_addr_type != BLE_GAP_ADDR_TYPE_WL) {
if (peer_addr &&
peer_addr->type != BLE_ADDR_PUBLIC &&
peer_addr->type != BLE_ADDR_RANDOM &&
peer_addr->type != BLE_ADDR_PUBLIC_ID &&
peer_addr->type != BLE_ADDR_RANDOM_ID) {
rc = BLE_HS_EINVAL;
goto done;
@@ -2450,7 +2417,7 @@ ble_gap_connect(uint8_t own_addr_type,
}
/* Verify peer not already connected. */
if (ble_hs_conn_find_by_addr(peer_addr_type, peer_addr) != NULL) {
if (ble_hs_conn_find_by_addr(peer_addr) != NULL) {
rc = BLE_HS_EDONE;
goto done;
}
@@ -2463,17 +2430,17 @@ ble_gap_connect(uint8_t own_addr_type,
}
BLE_HS_LOG(INFO, "GAP procedure initiated: connect; ");
ble_gap_log_conn(own_addr_type, peer_addr_type, peer_addr, conn_params);
ble_gap_log_conn(own_addr_type, peer_addr, conn_params);
BLE_HS_LOG(INFO, "\n");
ble_gap_master.cb = cb;
ble_gap_master.cb_arg = cb_arg;
ble_gap_master.conn.using_wl = peer_addr_type == BLE_GAP_ADDR_TYPE_WL;
ble_gap_master.conn.using_wl = peer_addr == NULL;
ble_gap_master.conn.our_addr_type = own_addr_type;
ble_gap_master.op = BLE_GAP_OP_M_CONN;
rc = ble_gap_conn_create_tx(own_addr_type, peer_addr_type, peer_addr,
rc = ble_gap_conn_create_tx(own_addr_type, peer_addr,
conn_params);
if (rc != 0) {
ble_gap_master_reset_state();
@@ -3014,8 +2981,7 @@ ble_gap_security_initiate(uint16_t conn_handle)
ble_hs_conn_addrs(conn, &addrs);
memset(&key_sec, 0, sizeof key_sec);
key_sec.peer_addr_type = addrs.peer_id_addr_type;
memcpy(key_sec.peer_addr, addrs.peer_id_addr, 6);
key_sec.peer_addr = addrs.peer_id_addr;
}
ble_hs_unlock();
nimble/host/src/ble_gatts.c
+6 -10
View File
@@ -689,8 +689,7 @@ ble_gatts_clt_cfg_access_locked(struct ble_hs_conn *conn, uint16_t attr_handle,
/* Successful writes get persisted for bonded connections. */
if (conn->bhc_sec_state.bonded) {
out_cccd->peer_addr_type = conn->bhc_peer_addr_type;
memcpy(out_cccd->peer_addr, conn->bhc_peer_addr, 6);
out_cccd->peer_addr = conn->bhc_peer_addr;
out_cccd->chr_val_handle = chr_val_handle;
out_cccd->flags = clt_cfg->flags;
out_cccd->value_changed = 0;
@@ -1407,8 +1406,7 @@ ble_gatts_rx_indicate_ack(uint16_t conn_handle, uint16_t chr_val_handle)
persist = conn->bhc_sec_state.bonded &&
!(clt_cfg->flags & BLE_GATTS_CLT_CFG_F_MODIFIED);
if (persist) {
cccd_value.peer_addr_type = conn->bhc_peer_addr_type;
memcpy(cccd_value.peer_addr, conn->bhc_peer_addr, 6);
cccd_value.peer_addr = conn->bhc_peer_addr;
cccd_value.chr_val_handle = chr_val_handle;
cccd_value.flags = clt_cfg->flags;
cccd_value.value_changed = 0;
@@ -1488,8 +1486,8 @@ ble_gatts_chr_updated(uint16_t chr_val_handle)
/*** Persist updated flag for unconnected and not-yet-bonded devices. */
/* Retrieve each record corresponding to the modified characteristic. */
cccd_key.peer_addr_type = BLE_STORE_ADDR_TYPE_NONE,
cccd_key.chr_val_handle = chr_val_handle,
cccd_key.peer_addr = *BLE_ADDR_ANY;
cccd_key.chr_val_handle = chr_val_handle;
cccd_key.idx = 0;
while (1) {
@@ -1501,8 +1499,7 @@ ble_gatts_chr_updated(uint16_t chr_val_handle)
/* Determine if this record needs to be rewritten. */
ble_hs_lock();
conn = ble_hs_conn_find_by_addr(cccd_value.peer_addr_type,
cccd_value.peer_addr);
conn = ble_hs_conn_find_by_addr(&cccd_key.peer_addr);
if (conn == NULL) {
/* Device isn't connected; persist the changed flag so that an
@@ -1646,8 +1643,7 @@ ble_gatts_bonding_restored(uint16_t conn_handle)
BLE_HS_DBG_ASSERT(conn != NULL);
BLE_HS_DBG_ASSERT(conn->bhc_sec_state.bonded);
cccd_key.peer_addr_type = conn->bhc_peer_addr_type;
memcpy(cccd_key.peer_addr, conn->bhc_peer_addr, 6);
cccd_key.peer_addr = conn->bhc_peer_addr;
cccd_key.chr_val_handle = 0;
cccd_key.idx = 0;
nimble/host/src/ble_hs_conn.c
+16 -23
View File
@@ -258,7 +258,7 @@ ble_hs_conn_find_assert(uint16_t conn_handle)
}
struct ble_hs_conn *
ble_hs_conn_find_by_addr(uint8_t addr_type, const uint8_t *addr)
ble_hs_conn_find_by_addr(const ble_addr_t *addr)
{
#if !NIMBLE_BLE_CONNECT
return NULL;
@@ -269,9 +269,7 @@ ble_hs_conn_find_by_addr(uint8_t addr_type, const uint8_t *addr)
BLE_HS_DBG_ASSERT(ble_hs_locked_by_cur_task());
SLIST_FOREACH(conn, &ble_hs_conns, bhc_next) {
if (conn->bhc_peer_addr_type == addr_type &&
memcmp(conn->bhc_peer_addr, addr, 6) == 0) {
if (ble_addr_cmp(&conn->bhc_peer_addr, addr) == 0) {
return conn;
}
}
@@ -330,43 +328,38 @@ void
ble_hs_conn_addrs(const struct ble_hs_conn *conn,
struct ble_hs_conn_addrs *addrs)
{
const uint8_t *our_id_addr_val;
int rc;
/* Determine our address information. */
addrs->our_id_addr_type =
addrs->our_id_addr.type =
ble_hs_misc_addr_type_to_id(conn->bhc_our_addr_type);
rc = ble_hs_id_addr(addrs->our_id_addr_type, &addrs->our_id_addr, NULL);
rc = ble_hs_id_addr(addrs->our_id_addr.type, &our_id_addr_val, NULL);
assert(rc == 0);
if (memcmp(conn->bhc_our_rpa_addr, ble_hs_conn_null_addr, 6) == 0) {
addrs->our_ota_addr_type = addrs->our_id_addr_type;
memcpy(addrs->our_id_addr.val, our_id_addr_val, 6);
if (memcmp(conn->bhc_our_rpa_addr.val, ble_hs_conn_null_addr, 6) == 0) {
addrs->our_ota_addr = addrs->our_id_addr;
} else {
addrs->our_ota_addr_type = BLE_ADDR_TYPE_RANDOM;
addrs->our_ota_addr = conn->bhc_our_rpa_addr;
}
/* Determine peer address information. */
addrs->peer_ota_addr_type = conn->bhc_peer_addr_type;
addrs->peer_id_addr = conn->bhc_peer_addr;
switch (conn->bhc_peer_addr_type) {
case BLE_ADDR_TYPE_PUBLIC:
addrs->peer_id_addr_type = BLE_ADDR_TYPE_PUBLIC;
addrs->peer_ota_addr = conn->bhc_peer_addr;
addrs->peer_ota_addr = conn->bhc_peer_addr;
switch (conn->bhc_peer_addr.type) {
case BLE_ADDR_PUBLIC:
case BLE_ADDR_RANDOM:
break;
case BLE_ADDR_TYPE_RANDOM:
addrs->peer_id_addr_type = BLE_ADDR_TYPE_RANDOM;
addrs->peer_ota_addr = conn->bhc_peer_addr;
break;
case BLE_ADDR_TYPE_RPA_PUB_DEFAULT:
addrs->peer_id_addr_type = BLE_ADDR_TYPE_PUBLIC;
case BLE_ADDR_PUBLIC_ID:
addrs->peer_id_addr.type = BLE_ADDR_PUBLIC;
addrs->peer_ota_addr = conn->bhc_peer_rpa_addr;
break;
case BLE_ADDR_TYPE_RPA_RND_DEFAULT:
addrs->peer_id_addr_type = BLE_ADDR_TYPE_RANDOM;
case BLE_ADDR_RANDOM_ID:
addrs->peer_id_addr.type = BLE_ADDR_RANDOM;
addrs->peer_ota_addr = conn->bhc_peer_rpa_addr;
break;
nimble/host/src/ble_hs_conn_priv.h
+8 -14
View File
@@ -40,11 +40,10 @@ typedef uint8_t ble_hs_conn_flags_t;
struct ble_hs_conn {
SLIST_ENTRY(ble_hs_conn) bhc_next;
uint16_t bhc_handle;
uint8_t bhc_peer_addr_type;
uint8_t bhc_our_addr_type;
uint8_t bhc_peer_addr[6];
uint8_t bhc_our_rpa_addr[6];
uint8_t bhc_peer_rpa_addr[6];
ble_addr_t bhc_peer_addr;
ble_addr_t bhc_our_rpa_addr;
ble_addr_t bhc_peer_rpa_addr;
uint16_t bhc_itvl;
uint16_t bhc_latency;
@@ -68,14 +67,10 @@ struct ble_hs_conn {
};
struct ble_hs_conn_addrs {
uint8_t our_ota_addr_type;
uint8_t our_id_addr_type;
uint8_t peer_ota_addr_type;
uint8_t peer_id_addr_type;
const uint8_t *our_ota_addr;
const uint8_t *our_id_addr;
const uint8_t *peer_ota_addr;
const uint8_t *peer_id_addr;
ble_addr_t our_id_addr;
ble_addr_t peer_id_addr;
ble_addr_t our_ota_addr;
ble_addr_t peer_ota_addr;
};
int ble_hs_conn_can_alloc(void);
@@ -85,8 +80,7 @@ void ble_hs_conn_insert(struct ble_hs_conn *conn);
void ble_hs_conn_remove(struct ble_hs_conn *conn);
struct ble_hs_conn *ble_hs_conn_find(uint16_t conn_handle);
struct ble_hs_conn *ble_hs_conn_find_assert(uint16_t conn_handle);
struct ble_hs_conn *ble_hs_conn_find_by_addr(uint8_t addr_type,
const uint8_t *addr);
struct ble_hs_conn *ble_hs_conn_find_by_addr(const ble_addr_t *addr);
struct ble_hs_conn *ble_hs_conn_find_by_idx(int idx);
int ble_hs_conn_exists(uint16_t conn_handle);
struct ble_hs_conn *ble_hs_conn_first(void);
nimble/host/src/ble_hs_hci_cmd.c
+5 -5
View File
@@ -162,7 +162,7 @@ static int
ble_hs_hci_cmd_body_le_whitelist_chg(const uint8_t *addr, uint8_t addr_type,
uint8_t *dst)
{
if (addr_type > BLE_ADDR_TYPE_RANDOM) {
if (addr_type > BLE_ADDR_RANDOM) {
return BLE_ERR_INV_HCI_CMD_PARMS;
}
@@ -1094,7 +1094,7 @@ ble_hs_hci_cmd_body_add_to_resolv_list(uint8_t addr_type, const uint8_t *addr,
const uint8_t *local_irk,
uint8_t *dst)
{
if (addr_type > BLE_ADDR_TYPE_RANDOM) {
if (addr_type > BLE_ADDR_RANDOM) {
return BLE_ERR_INV_HCI_CMD_PARMS;
}
@@ -1140,7 +1140,7 @@ ble_hs_hci_cmd_body_remove_from_resolv_list(uint8_t addr_type,
const uint8_t *addr,
uint8_t *dst)
{
if (addr_type > BLE_ADDR_TYPE_RANDOM) {
if (addr_type > BLE_ADDR_RANDOM) {
return BLE_ERR_INV_HCI_CMD_PARMS;
}
@@ -1199,7 +1199,7 @@ ble_hs_hci_cmd_body_read_peer_resolv_addr(uint8_t peer_identity_addr_type,
const uint8_t *peer_identity_addr,
uint8_t *dst)
{
if (peer_identity_addr_type > BLE_ADDR_TYPE_RANDOM) {
if (peer_identity_addr_type > BLE_ADDR_RANDOM) {
return BLE_ERR_INV_HCI_CMD_PARMS;
}
@@ -1238,7 +1238,7 @@ ble_hs_hci_cmd_body_read_lcl_resolv_addr(
const uint8_t *local_identity_addr,
uint8_t *dst)
{
if (local_identity_addr_type > BLE_ADDR_TYPE_RANDOM) {
if (local_identity_addr_type > BLE_ADDR_RANDOM) {
return BLE_ERR_INV_HCI_CMD_PARMS;
}
nimble/host/src/ble_hs_hci_evt.c
+7 -9
View File
@@ -377,9 +377,7 @@ ble_hs_hci_evt_le_adv_rpt(uint8_t subevent, uint8_t *data, int len)
return rc;
}
/* Direct address fields not present in a standard advertising report. */
desc.direct_addr_type = BLE_GAP_ADDR_TYPE_NONE;
memset(desc.direct_addr, 0, sizeof desc.direct_addr);
desc.direct_addr = *BLE_ADDR_ANY;
data_off = 0;
for (i = 0; i < num_reports; i++) {
@@ -390,11 +388,11 @@ ble_hs_hci_evt_le_adv_rpt(uint8_t subevent, uint8_t *data, int len)
suboff++;
off = 2 + suboff * num_reports + i;
desc.addr_type = data[off];
desc.addr.type = data[off];
suboff++;
off = 2 + suboff * num_reports + i * 6;
memcpy(desc.addr, data + off, 6);
memcpy(desc.addr.val, data + off, 6);
suboff += 6;
off = 2 + suboff * num_reports + i;
@@ -444,19 +442,19 @@ ble_hs_hci_evt_le_dir_adv_rpt(uint8_t subevent, uint8_t *data, int len)
suboff++;
off = 2 + suboff * num_reports + i;
desc.addr_type = data[off];
desc.addr.type = data[off];
suboff++;
off = 2 + suboff * num_reports + i * 6;
memcpy(desc.addr, data + off, 6);
memcpy(desc.addr.val, data + off, 6);
suboff += 6;
off = 2 + suboff * num_reports + i;
desc.direct_addr_type = data[off];
desc.direct_addr.type = data[off];
suboff++;
off = 2 + suboff * num_reports + i * 6;
memcpy(desc.direct_addr, data + off, 6);
memcpy(desc.direct_addr.val, data + off, 6);
suboff += 6;
off = 2 + suboff * num_reports + i;
nimble/host/src/ble_hs_id.c
+16 -14
View File
@@ -46,19 +46,21 @@ ble_hs_id_set_pub(const uint8_t *pub_addr)
* @return 0 on success; nonzero on failure.
*/
int
ble_hs_id_gen_rnd(int nrpa, uint8_t *out_addr)
ble_hs_id_gen_rnd(int nrpa, ble_addr_t *out_addr)
{
int rc;
rc = ble_hs_hci_util_rand(out_addr, 6);
out_addr->type = BLE_ADDR_RANDOM;
rc = ble_hs_hci_util_rand(out_addr->val, 6);
if (rc != 0) {
return rc;
}
if (nrpa) {
out_addr[5] &= ~0xc0;
out_addr->val[5] &= ~0xc0;
} else {
out_addr[5] |= 0xc0;
out_addr->val[5] |= 0xc0;
}
return 0;
@@ -112,8 +114,8 @@ done:
*
* @param id_addr_type The type of identity address to retrieve.
* Valid values are:
* o BLE_ADDR_TYPE_PUBLIC
* o BLE_ADDR_TYPE_RANDOM
* o BLE_ADDR_PUBLIC
* o BLE_ADDR_RANDOM
* @param out_id_addr On success, this is reseated to point to the
* retrieved 6-byte identity address.
* @param out_is_nrpa On success, the pointed-to value indicates
@@ -137,12 +139,12 @@ ble_hs_id_addr(uint8_t id_addr_type, const uint8_t **out_id_addr,
BLE_HS_DBG_ASSERT(ble_hs_locked_by_cur_task());
switch (id_addr_type) {
case BLE_ADDR_TYPE_PUBLIC:
case BLE_ADDR_PUBLIC:
id_addr = ble_hs_id_pub;
nrpa = 0;
break;
case BLE_ADDR_TYPE_RANDOM:
case BLE_ADDR_RANDOM:
id_addr = ble_hs_id_rnd;
nrpa = (ble_hs_id_rnd[5] & 0xc0) == 0;
break;
@@ -172,8 +174,8 @@ ble_hs_id_addr(uint8_t id_addr_type, const uint8_t **out_id_addr,
*
* @param id_addr_type The type of identity address to retrieve.
* Valid values are:
* o BLE_ADDR_TYPE_PUBLIC
* o BLE_ADDR_TYPE_RANDOM
* o BLE_ADDR_PUBLIC
* o BLE_ADDR_RANDOM
* @param out_id_addr On success, the requested identity address is
* copied into this buffer. The buffer must
* be at least six bytes in size.
@@ -215,16 +217,16 @@ ble_hs_id_use_addr(uint8_t addr_type)
int rc;
switch (addr_type) {
case BLE_ADDR_TYPE_PUBLIC:
case BLE_ADDR_TYPE_RANDOM:
case BLE_OWN_ADDR_PUBLIC:
case BLE_OWN_ADDR_RANDOM:
rc = ble_hs_id_addr(addr_type, NULL, NULL);
if (rc != 0) {
return rc;
}
break;
case BLE_ADDR_TYPE_RPA_PUB_DEFAULT:
case BLE_ADDR_TYPE_RPA_RND_DEFAULT:
case BLE_OWN_ADDR_RPA_PUBLIC_DEFAULT:
case BLE_OWN_ADDR_RPA_RANDOM_DEFAULT:
id_addr_type = ble_hs_misc_addr_type_to_id(addr_type);
rc = ble_hs_id_addr(id_addr_type, NULL, &nrpa);
if (rc != 0) {
nimble/host/src/ble_hs_misc.c
+7 -7
View File
@@ -81,16 +81,16 @@ uint8_t
ble_hs_misc_addr_type_to_id(uint8_t addr_type)
{
switch (addr_type) {
case BLE_ADDR_TYPE_PUBLIC:
case BLE_ADDR_TYPE_RPA_PUB_DEFAULT:
return BLE_ADDR_TYPE_PUBLIC;
case BLE_ADDR_PUBLIC:
case BLE_ADDR_PUBLIC_ID:
return BLE_ADDR_PUBLIC;
case BLE_ADDR_TYPE_RANDOM:
case BLE_ADDR_TYPE_RPA_RND_DEFAULT:
return BLE_ADDR_TYPE_RANDOM;
case BLE_ADDR_RANDOM:
case BLE_ADDR_RANDOM_ID:
return BLE_ADDR_RANDOM;
default:
BLE_HS_DBG_ASSERT(0);
return BLE_ADDR_TYPE_PUBLIC;
return BLE_ADDR_PUBLIC;
}
}
nimble/host/src/ble_sm.c
+26 -28
View File
@@ -446,8 +446,8 @@ ble_sm_fill_store_value(uint8_t peer_addr_type, uint8_t *peer_addr,
{
memset(value_sec, 0, sizeof *value_sec);
value_sec->peer_addr_type = peer_addr_type;
memcpy(value_sec->peer_addr, peer_addr, sizeof value_sec->peer_addr);
value_sec->peer_addr.type = peer_addr_type;
memcpy(value_sec->peer_addr.val, peer_addr, sizeof value_sec->peer_addr);
if (keys->ediv_rand_valid && keys->ltk_valid) {
value_sec->key_size = keys->key_size;
@@ -484,17 +484,17 @@ ble_sm_ia_ra(struct ble_sm_proc *proc,
ble_hs_conn_addrs(conn, &addrs);
if (proc->flags & BLE_SM_PROC_F_INITIATOR) {
*out_iat = addrs.our_ota_addr_type;
memcpy(out_ia, addrs.our_ota_addr, 6);
*out_iat = addrs.our_ota_addr.type;
memcpy(out_ia, addrs.our_ota_addr.val, 6);
*out_rat = addrs.peer_ota_addr_type;
memcpy(out_ra, addrs.peer_ota_addr, 6);
*out_rat = addrs.peer_ota_addr.type;
memcpy(out_ra, addrs.peer_ota_addr.val, 6);
} else {
*out_iat = addrs.peer_ota_addr_type;
memcpy(out_ia, addrs.peer_ota_addr, 6);
*out_iat = addrs.peer_ota_addr.type;
memcpy(out_ia, addrs.peer_ota_addr.val, 6);
*out_rat = addrs.our_ota_addr_type;
memcpy(out_ra, addrs.our_ota_addr, 6);
*out_rat = addrs.our_ota_addr.type;
memcpy(out_ra, addrs.our_ota_addr.val, 6);
}
}
@@ -503,8 +503,7 @@ ble_sm_persist_keys(struct ble_sm_proc *proc)
{
struct ble_store_value_sec value_sec;
struct ble_hs_conn *conn;
uint8_t peer_addr[6];
uint8_t peer_addr_type;
ble_addr_t peer_addr;
int authenticated;
ble_hs_lock();
@@ -514,22 +513,22 @@ ble_sm_persist_keys(struct ble_sm_proc *proc)
/* If we got an identity address, use that for key storage. */
if (proc->peer_keys.addr_valid) {
peer_addr_type = proc->peer_keys.addr_type;
memcpy(peer_addr, proc->peer_keys.addr, sizeof peer_addr);
peer_addr.type = proc->peer_keys.addr_type;
memcpy(peer_addr.val, proc->peer_keys.addr, sizeof peer_addr);
} else {
peer_addr_type = ble_hs_misc_addr_type_to_id(conn->bhc_peer_addr_type);
memcpy(peer_addr, conn->bhc_peer_addr, sizeof peer_addr);
peer_addr = conn->bhc_peer_addr;
peer_addr.type = ble_hs_misc_addr_type_to_id(conn->bhc_peer_addr.type);
}
ble_hs_unlock();
authenticated = proc->flags & BLE_SM_PROC_F_AUTHENTICATED;
ble_sm_fill_store_value(peer_addr_type, peer_addr, authenticated,
ble_sm_fill_store_value(peer_addr.type, peer_addr.val, authenticated,
&proc->our_keys, &value_sec);
ble_store_write_our_sec(&value_sec);
ble_sm_fill_store_value(peer_addr_type, peer_addr, authenticated,
ble_sm_fill_store_value(peer_addr.type, peer_addr.val, authenticated,
&proc->peer_keys, &value_sec);
ble_store_write_peer_sec(&value_sec);
}
@@ -1031,8 +1030,8 @@ ble_sm_retrieve_ltk(struct hci_le_lt_key_req *evt, uint8_t peer_addr_type,
/* Tell applicaiton to look up LTK by peer address and ediv/rand pair. */
memset(&key_sec, 0, sizeof key_sec);
key_sec.peer_addr_type = peer_addr_type;
memcpy(key_sec.peer_addr, peer_addr, 6);
key_sec.peer_addr.type = peer_addr_type;
memcpy(key_sec.peer_addr.val, peer_addr, 6);
key_sec.ediv = evt->encrypted_diversifier;
key_sec.rand_num = evt->random_number;
key_sec.ediv_rand_present = 1;
@@ -1204,7 +1203,7 @@ ble_sm_ltk_req_rx(struct hci_le_lt_key_req *evt)
if (restore) {
conn = ble_hs_conn_find_assert(evt->connection_handle);
ble_hs_conn_addrs(conn, &addrs);
memcpy(peer_id_addr, addrs.peer_id_addr, 6);
memcpy(peer_id_addr, addrs.peer_id_addr.val, 6);
}
ble_hs_unlock();
@@ -1215,7 +1214,7 @@ ble_sm_ltk_req_rx(struct hci_le_lt_key_req *evt)
if (res.app_status == 0) {
if (restore) {
store_rc = ble_sm_retrieve_ltk(evt, addrs.peer_id_addr_type,
store_rc = ble_sm_retrieve_ltk(evt, addrs.peer_id_addr.type,
peer_id_addr, &value_sec);
if (store_rc == 0) {
/* Send the key to the controller. */
@@ -1666,8 +1665,7 @@ ble_sm_sec_req_rx(uint16_t conn_handle, struct os_mbuf **om,
*/
ble_hs_conn_addrs(conn, &addrs);
memset(&key_sec, 0, sizeof key_sec);
key_sec.peer_addr_type = addrs.peer_id_addr_type;
memcpy(key_sec.peer_addr, addrs.peer_id_addr, 6);
key_sec.peer_addr = addrs.peer_id_addr;;
}
ble_hs_unlock();
@@ -1825,8 +1823,8 @@ ble_sm_key_exch_exec(struct ble_sm_proc *proc, struct ble_sm_result *res,
conn = ble_hs_conn_find_assert(proc->conn_handle);
ble_hs_conn_addrs(conn, &addrs);
addr_info->addr_type = addrs.our_id_addr_type;
memcpy(addr_info->bd_addr, addrs.our_id_addr, 6);
addr_info->addr_type = addrs.our_id_addr.type;
memcpy(addr_info->bd_addr, addrs.our_id_addr.val, 6);
proc->our_keys.addr_valid = 1;
memcpy(proc->our_keys.irk, irk, 16);
@@ -2277,8 +2275,8 @@ ble_sm_unbond(uint8_t peer_id_addr_type, const uint8_t *peer_id_addr)
int rc;
memset(&key_sec, 0, sizeof key_sec);
key_sec.peer_addr_type = peer_id_addr_type;
memcpy(key_sec.peer_addr, peer_id_addr, sizeof key_sec.peer_addr);
key_sec.peer_addr.type = peer_id_addr_type;
memcpy(key_sec.peer_addr.val, peer_id_addr, sizeof key_sec.peer_addr);
our_rc = ble_store_delete_our_sec(&key_sec);
peer_rc = ble_store_delete_peer_sec(&key_sec);
nimble/host/src/ble_sm_sc.c
+15 -30
View File
@@ -609,11 +609,8 @@ ble_sm_sc_public_key_rx(uint16_t conn_handle, struct os_mbuf **om,
}
static void
ble_sm_sc_dhkey_addrs(struct ble_sm_proc *proc,
uint8_t *out_our_id_addr_type,
const uint8_t **out_our_ota_addr,
uint8_t *out_peer_id_addr_type,
const uint8_t **out_peer_ota_addr)
ble_sm_sc_dhkey_addrs(struct ble_sm_proc *proc, ble_addr_t *our_addr,
ble_addr_t *peer_addr)
{
struct ble_hs_conn_addrs addrs;
struct ble_hs_conn *conn;
@@ -621,10 +618,9 @@ ble_sm_sc_dhkey_addrs(struct ble_sm_proc *proc,
conn = ble_hs_conn_find_assert(proc->conn_handle);
ble_hs_conn_addrs(conn, &addrs);
*out_our_id_addr_type = addrs.our_ota_addr_type;
*out_our_ota_addr = addrs.our_ota_addr;
*out_peer_id_addr_type = addrs.peer_ota_addr_type;
*out_peer_ota_addr = addrs.peer_ota_addr;
*our_addr = addrs.our_ota_addr;
*peer_addr = addrs.peer_ota_addr;
}
void
@@ -632,10 +628,8 @@ ble_sm_sc_dhkey_check_exec(struct ble_sm_proc *proc, struct ble_sm_result *res,
void *arg)
{
struct ble_sm_dhkey_check *cmd;
const uint8_t *our_ota_addr;
const uint8_t *peer_ota_addr;
uint8_t peer_id_addr_type;
uint8_t our_id_addr_type;
ble_addr_t our_addr;
ble_addr_t peer_addr;
struct os_mbuf *txom;
uint8_t *iocap;
int rc;
@@ -652,9 +646,7 @@ ble_sm_sc_dhkey_check_exec(struct ble_sm_proc *proc, struct ble_sm_result *res,
iocap = &pair_rsp->io_cap;
}
ble_sm_sc_dhkey_addrs(proc,
&our_id_addr_type, &our_ota_addr,
&peer_id_addr_type, &peer_ota_addr);
ble_sm_sc_dhkey_addrs(proc, &our_addr, &peer_addr);
cmd = ble_sm_cmd_get(BLE_SM_OP_PAIR_DHKEY_CHECK, sizeof(*cmd), &txom);
if (!cmd) {
@@ -664,9 +656,8 @@ ble_sm_sc_dhkey_check_exec(struct ble_sm_proc *proc, struct ble_sm_result *res,
rc = ble_sm_alg_f6(proc->mackey, ble_sm_our_pair_rand(proc),
ble_sm_peer_pair_rand(proc), proc->tk, iocap,
our_id_addr_type, our_ota_addr,
peer_id_addr_type, peer_ota_addr,
cmd->value);
our_addr.type, our_addr.val, peer_addr.type,
peer_addr.val, cmd->value);
if (rc != 0) {
os_mbuf_free_chain(txom);
goto err;
@@ -695,10 +686,8 @@ ble_sm_dhkey_check_process(struct ble_sm_proc *proc,
struct ble_sm_result *res)
{
uint8_t exp_value[16];
const uint8_t *peer_ota_addr;
const uint8_t *our_ota_addr;
uint8_t peer_id_addr_type;
uint8_t our_id_addr_type;
ble_addr_t our_addr;
ble_addr_t peer_addr;
uint8_t *iocap;
uint8_t ioact;
@@ -714,11 +703,7 @@ ble_sm_dhkey_check_process(struct ble_sm_proc *proc,
iocap = &pair_req->io_cap;
}
ble_sm_sc_dhkey_addrs(proc,
&our_id_addr_type,
&our_ota_addr,
&peer_id_addr_type,
&peer_ota_addr);
ble_sm_sc_dhkey_addrs(proc, &our_addr, &peer_addr);
BLE_HS_LOG(DEBUG, "tk=");
ble_hs_log_flat_buf(proc->tk, 16);
BLE_HS_LOG(DEBUG, "\n");
@@ -727,8 +712,8 @@ ble_sm_dhkey_check_process(struct ble_sm_proc *proc,
ble_sm_peer_pair_rand(proc),
ble_sm_our_pair_rand(proc),
proc->tk, iocap,
peer_id_addr_type, peer_ota_addr,
our_id_addr_type, our_ota_addr,
peer_addr.type, peer_addr.val,
our_addr.type, our_addr.val,
exp_value);
if (res->app_status != 0) {
res->sm_err = BLE_SM_ERR_UNSPECIFIED;
nimble/host/src/ble_store.c
+14 -17
View File
@@ -73,9 +73,9 @@ ble_store_read_our_sec(struct ble_store_key_sec *key_sec,
union ble_store_key *store_key;
int rc;
BLE_HS_DBG_ASSERT(key_sec->peer_addr_type == BLE_ADDR_TYPE_PUBLIC ||
key_sec->peer_addr_type == BLE_ADDR_TYPE_RANDOM ||
key_sec->peer_addr_type == BLE_STORE_ADDR_TYPE_NONE);
BLE_HS_DBG_ASSERT(key_sec->peer_addr.type == BLE_ADDR_PUBLIC ||
key_sec->peer_addr.type == BLE_ADDR_RANDOM ||
ble_addr_cmp(&key_sec->peer_addr, BLE_ADDR_ANY) == 0);
store_key = (void *)key_sec;
store_value = (void *)value_sec;
@@ -89,8 +89,8 @@ ble_store_persist_sec(int obj_type, struct ble_store_value_sec *value_sec)
union ble_store_value *store_value;
int rc;
BLE_HS_DBG_ASSERT(value_sec->peer_addr_type == BLE_ADDR_TYPE_PUBLIC ||
value_sec->peer_addr_type == BLE_ADDR_TYPE_RANDOM);
BLE_HS_DBG_ASSERT(value_sec->peer_addr.type == BLE_ADDR_PUBLIC ||
value_sec->peer_addr.type == BLE_ADDR_RANDOM);
BLE_HS_DBG_ASSERT(value_sec->ltk_present ||
value_sec->irk_present ||
value_sec->csrk_present);
@@ -139,9 +139,8 @@ ble_store_read_peer_sec(struct ble_store_key_sec *key_sec,
union ble_store_key *store_key;
int rc;
BLE_HS_DBG_ASSERT(key_sec->peer_addr_type == BLE_ADDR_TYPE_PUBLIC ||
key_sec->peer_addr_type == BLE_ADDR_TYPE_RANDOM ||
key_sec->peer_addr_type == BLE_STORE_ADDR_TYPE_NONE);
BLE_HS_DBG_ASSERT(key_sec->peer_addr.type == BLE_ADDR_PUBLIC ||
key_sec->peer_addr.type == BLE_ADDR_RANDOM);
store_key = (void *)key_sec;
store_value = (void *)value_sec;
@@ -164,13 +163,13 @@ ble_store_write_peer_sec(struct ble_store_value_sec *value_sec)
return rc;
}
if (value_sec->peer_addr_type != BLE_STORE_ADDR_TYPE_NONE &&
if (ble_addr_cmp(&value_sec->peer_addr, BLE_ADDR_ANY) &&
value_sec->irk_present) {
/* Write the peer IRK to the controller keycache
* There is not much to do here if it fails */
rc = ble_hs_pvcy_add_entry(value_sec->peer_addr,
value_sec->peer_addr_type,
rc = ble_hs_pvcy_add_entry(value_sec->peer_addr.val,
value_sec->peer_addr.type,
value_sec->irk);
if (rc != 0) {
return rc;
@@ -220,8 +219,7 @@ void
ble_store_key_from_value_cccd(struct ble_store_key_cccd *out_key,
struct ble_store_value_cccd *value)
{
out_key->peer_addr_type = value->peer_addr_type;
memcpy(out_key->peer_addr, value->peer_addr, 6);
out_key->peer_addr = value->peer_addr;
out_key->chr_val_handle = value->chr_val_handle;
out_key->idx = 0;
}
@@ -230,8 +228,7 @@ void
ble_store_key_from_value_sec(struct ble_store_key_sec *out_key,
struct ble_store_value_sec *value)
{
out_key->peer_addr_type = value->peer_addr_type;
memcpy(out_key->peer_addr, value->peer_addr, sizeof out_key->peer_addr);
out_key->peer_addr = value->peer_addr;
out_key->ediv = value->ediv;
out_key->rand_num = value->rand_num;
@@ -253,11 +250,11 @@ void ble_store_iterate(int obj_type,
switch(obj_type) {
case BLE_STORE_OBJ_TYPE_PEER_SEC:
case BLE_STORE_OBJ_TYPE_OUR_SEC:
key.sec.peer_addr_type = BLE_STORE_ADDR_TYPE_NONE;
key.sec.peer_addr = *BLE_ADDR_ANY;
pidx = &key.sec.idx;
break;
case BLE_STORE_OBJ_TYPE_CCCD:
key.cccd.peer_addr_type = BLE_STORE_ADDR_TYPE_NONE;
key.cccd.peer_addr = *BLE_ADDR_ANY;
pidx = &key.cccd.idx;
default:
return;
nimble/host/store/ram/src/ble_store_ram.c
+7 -16
View File
@@ -74,10 +74,10 @@ ble_store_ram_print_value_sec(struct ble_store_value_sec *sec)
static void
ble_store_ram_print_key_sec(struct ble_store_key_sec *key_sec)
{
if (key_sec->peer_addr_type != BLE_STORE_ADDR_TYPE_NONE) {
if (ble_addr_cmp(&key_sec->peer_addr, BLE_ADDR_ANY)) {
BLE_HS_LOG(DEBUG, "peer_addr_type=%d peer_addr=",
key_sec->peer_addr_type);
ble_hs_log_flat_buf(key_sec->peer_addr, 6);
key_sec->peer_addr.type);
ble_hs_log_flat_buf(key_sec->peer_addr.val, 6);
BLE_HS_LOG(DEBUG, " ");
}
if (key_sec->ediv_rand_present) {
@@ -100,13 +100,8 @@ ble_store_ram_find_sec(struct ble_store_key_sec *key_sec,
for (i = 0; i < num_value_secs; i++) {
cur = value_secs + i;
if (key_sec->peer_addr_type != BLE_STORE_ADDR_TYPE_NONE) {
if (cur->peer_addr_type != key_sec->peer_addr_type) {
continue;
}
if (memcmp(cur->peer_addr, key_sec->peer_addr,
sizeof cur->peer_addr) != 0) {
if (ble_addr_cmp(&key_sec->peer_addr, BLE_ADDR_ANY)) {
if (ble_addr_cmp(&cur->peer_addr, &key_sec->peer_addr)) {
continue;
}
}
@@ -304,12 +299,8 @@ ble_store_ram_find_cccd(struct ble_store_key_cccd *key)
for (i = 0; i < ble_store_ram_num_cccds; i++) {
cccd = ble_store_ram_cccds + i;
if (key->peer_addr_type != BLE_STORE_ADDR_TYPE_NONE) {
if (cccd->peer_addr_type != key->peer_addr_type) {
continue;
}
if (memcmp(cccd->peer_addr, key->peer_addr, 6) != 0) {
if (ble_addr_cmp(&key->peer_addr, BLE_ADDR_ANY)) {
if (ble_addr_cmp(&cccd->peer_addr, &key->peer_addr)) {
continue;
}
}
nimble/host/test/src/ble_gap_test.c
+158 -168
View File
@@ -150,7 +150,7 @@ ble_gap_test_util_verify_tx_clear_wl(void)
}
static void
ble_gap_test_util_verify_tx_add_wl(struct ble_gap_white_entry *entry)
ble_gap_test_util_verify_tx_add_wl(ble_addr_t *addr)
{
uint8_t param_len;
uint8_t *param;
@@ -160,9 +160,9 @@ ble_gap_test_util_verify_tx_add_wl(struct ble_gap_white_entry *entry)
BLE_HCI_OCF_LE_ADD_WHITE_LIST,
&param_len);
TEST_ASSERT(param_len == 7);
TEST_ASSERT(param[0] == entry->addr_type);
TEST_ASSERT(param[0] == addr->type);
for (i = 0; i < 6; i++) {
TEST_ASSERT(param[1 + i] == entry->addr[i]);
TEST_ASSERT(param[1 + i] == addr->val[i]);
}
}
@@ -391,8 +391,7 @@ ble_gap_test_util_rx_param_req(struct ble_gap_upd_params *params, int pos,
*****************************************************************************/
static void
ble_gap_test_util_wl_set(struct ble_gap_white_entry *white_list,
int white_list_count, int cmd_fail_idx,
ble_gap_test_util_wl_set(ble_addr_t *addrs, int addrs_count, int cmd_fail_idx,
uint8_t fail_status)
{
int cmd_idx;
@@ -402,7 +401,7 @@ ble_gap_test_util_wl_set(struct ble_gap_white_entry *white_list,
ble_gap_test_util_init();
cmd_idx = 0;
rc = ble_hs_test_util_wl_set(white_list, white_list_count, cmd_fail_idx,
rc = ble_hs_test_util_wl_set(addrs, addrs_count, cmd_fail_idx,
fail_status);
TEST_ASSERT(rc == BLE_HS_HCI_ERR(fail_status));
@@ -414,8 +413,8 @@ ble_gap_test_util_wl_set(struct ble_gap_white_entry *white_list,
cmd_idx++;
/* Verify tx of add white list commands. */
for (i = 0; i < white_list_count; i++) {
ble_gap_test_util_verify_tx_add_wl(white_list + i);
for (i = 0; i < addrs_count; i++) {
ble_gap_test_util_verify_tx_add_wl(addrs + i);
if (cmd_idx >= cmd_fail_idx) {
return;
}
@@ -435,21 +434,20 @@ TEST_CASE(ble_gap_test_case_wl_bad_args)
/*** Invalid address type. */
rc = ble_hs_test_util_wl_set(
((struct ble_gap_white_entry[]) { {
((ble_addr_t[]) { {
5, { 1, 2, 3, 4, 5, 6 }
}, }),
1, 0, 0);
TEST_ASSERT(rc == BLE_HS_EINVAL);
/*** White-list-using connection in progress. */
rc = ble_hs_test_util_connect(BLE_ADDR_TYPE_PUBLIC,
BLE_GAP_ADDR_TYPE_WL, NULL, 0, NULL,
rc = ble_hs_test_util_connect(BLE_ADDR_PUBLIC, NULL, 0, NULL,
ble_gap_test_util_connect_cb, NULL, 0);
TEST_ASSERT(rc == 0);
rc = ble_hs_test_util_wl_set(
((struct ble_gap_white_entry[]) { {
BLE_ADDR_TYPE_PUBLIC, { 1, 2, 3, 4, 5, 6 }
((ble_addr_t[]) { {
BLE_ADDR_PUBLIC, { 1, 2, 3, 4, 5, 6 }
}, }),
1, 0, 0);
TEST_ASSERT(rc == BLE_HS_EBUSY);
@@ -459,31 +457,31 @@ TEST_CASE(ble_gap_test_case_wl_ctlr_fail)
{
int i;
struct ble_gap_white_entry white_list[] = {
{ BLE_ADDR_TYPE_PUBLIC, { 1, 2, 3, 4, 5, 6 } },
{ BLE_ADDR_TYPE_PUBLIC, { 2, 3, 4, 5, 6, 7 } },
{ BLE_ADDR_TYPE_PUBLIC, { 3, 4, 5, 6, 7, 8 } },
{ BLE_ADDR_TYPE_PUBLIC, { 4, 5, 6, 7, 8, 9 } },
ble_addr_t addrs[] = {
{ BLE_ADDR_PUBLIC, { 1, 2, 3, 4, 5, 6 } },
{ BLE_ADDR_PUBLIC, { 2, 3, 4, 5, 6, 7 } },
{ BLE_ADDR_PUBLIC, { 3, 4, 5, 6, 7, 8 } },
{ BLE_ADDR_PUBLIC, { 4, 5, 6, 7, 8, 9 } },
};
int white_list_count = sizeof white_list / sizeof white_list[0];
int addrs_count = sizeof addrs / sizeof addrs[0];
for (i = 0; i < 5; i++) {
ble_gap_test_util_wl_set(white_list, white_list_count, i,
ble_gap_test_util_wl_set(addrs, addrs_count, i,
BLE_ERR_UNSPECIFIED);
}
}
TEST_CASE(ble_gap_test_case_wl_good)
{
struct ble_gap_white_entry white_list[] = {
{ BLE_ADDR_TYPE_PUBLIC, { 1, 2, 3, 4, 5, 6 } },
{ BLE_ADDR_TYPE_PUBLIC, { 2, 3, 4, 5, 6, 7 } },
{ BLE_ADDR_TYPE_PUBLIC, { 3, 4, 5, 6, 7, 8 } },
{ BLE_ADDR_TYPE_PUBLIC, { 4, 5, 6, 7, 8, 9 } },
ble_addr_t addrs[] = {
{ BLE_ADDR_PUBLIC, { 1, 2, 3, 4, 5, 6 } },
{ BLE_ADDR_PUBLIC, { 2, 3, 4, 5, 6, 7 } },
{ BLE_ADDR_PUBLIC, { 3, 4, 5, 6, 7, 8 } },
{ BLE_ADDR_PUBLIC, { 4, 5, 6, 7, 8, 9 } },
};
int white_list_count = sizeof white_list / sizeof white_list[0];
int addrs_count = sizeof addrs / sizeof addrs[0];
ble_gap_test_util_wl_set(white_list, white_list_count, 0, 0);
ble_gap_test_util_wl_set(addrs, addrs_count, 0, 0);
}
TEST_SUITE(ble_gap_test_suite_wl)
@@ -564,7 +562,7 @@ TEST_CASE(ble_gap_test_case_disc_bad_args)
/*** Invalid filter policy. */
params.filter_policy = 6;
rc = ble_gap_disc(BLE_ADDR_TYPE_PUBLIC, 0, &params,
rc = ble_gap_disc(BLE_ADDR_PUBLIC, 0, &params,
ble_gap_test_util_disc_cb, NULL);
TEST_ASSERT(rc == BLE_HS_EINVAL);
}
@@ -580,10 +578,9 @@ TEST_CASE(ble_gap_test_case_disc_good)
struct ble_gap_disc_desc desc = {
.event_type = BLE_HCI_ADV_TYPE_ADV_IND,
.addr_type = BLE_ADDR_TYPE_PUBLIC,
.addr = { BLE_ADDR_PUBLIC, { 1, 2, 3, 4, 5, 6 } },
.length_data = 0,
.rssi = 0,
.addr = { 1, 2, 3, 4, 5, 6 },
.data = adv_data,
};
struct ble_gap_disc_params disc_params = {
@@ -602,7 +599,7 @@ TEST_CASE(ble_gap_test_case_disc_good)
TEST_ASSERT_FATAL(rc == 0);
for (own_addr_type = 0;
own_addr_type <= BLE_ADDR_TYPE_RPA_RND_DEFAULT;
own_addr_type <= BLE_OWN_ADDR_RPA_RANDOM_DEFAULT;
own_addr_type++)
for (passive = 0; passive <= 1; passive++)
for (limited = 0; limited <= 1; limited++) {
@@ -614,11 +611,11 @@ TEST_CASE(ble_gap_test_case_disc_good)
TEST_ASSERT(ble_gap_test_disc_event_type == BLE_GAP_EVENT_DISC);
TEST_ASSERT(ble_gap_test_disc_desc.event_type ==
BLE_HCI_ADV_TYPE_ADV_IND);
TEST_ASSERT(ble_gap_test_disc_desc.addr_type ==
BLE_ADDR_TYPE_PUBLIC);
TEST_ASSERT(ble_gap_test_disc_desc.addr.type ==
BLE_ADDR_PUBLIC);
TEST_ASSERT(ble_gap_test_disc_desc.length_data == 3);
TEST_ASSERT(ble_gap_test_disc_desc.rssi == 0);
TEST_ASSERT(memcmp(ble_gap_test_disc_desc.addr, desc.addr, 6) == 0);
TEST_ASSERT(memcmp(ble_gap_test_disc_desc.addr.val, desc.addr.val, 6) == 0);
TEST_ASSERT(ble_gap_test_disc_arg == NULL);
}
@@ -629,10 +626,9 @@ TEST_CASE(ble_gap_test_case_disc_ltd_mismatch)
int rc;
struct ble_gap_disc_desc desc = {
.event_type = BLE_HCI_ADV_TYPE_ADV_IND,
.addr_type = BLE_ADDR_TYPE_PUBLIC,
.length_data = 3,
.rssi = 0,
.addr = { 1, 2, 3, 4, 5, 6 },
.addr = { BLE_ADDR_PUBLIC, { 1, 2, 3, 4, 5, 6 } },
.data = (uint8_t[BLE_HS_ADV_MAX_SZ]){
2,
BLE_HS_ADV_TYPE_FLAGS,
@@ -648,7 +644,7 @@ TEST_CASE(ble_gap_test_case_disc_ltd_mismatch)
.filter_duplicates = 0,
};
rc = ble_gap_test_util_disc(BLE_ADDR_TYPE_PUBLIC, &disc_params, &desc,
rc = ble_gap_test_util_disc(BLE_OWN_ADDR_PUBLIC, &disc_params, &desc,
-1, 0);
TEST_ASSERT(rc == 0);
TEST_ASSERT(ble_gap_master_in_progress());
@@ -662,7 +658,7 @@ TEST_CASE(ble_gap_test_case_disc_ltd_mismatch)
desc.data[2] = BLE_HS_ADV_F_DISC_LTD;
disc_params.limited = 0;
rc = ble_gap_test_util_disc(BLE_ADDR_TYPE_PUBLIC, &disc_params, &desc,
rc = ble_gap_test_util_disc(BLE_OWN_ADDR_PUBLIC, &disc_params, &desc,
-1, 0);
TEST_ASSERT(rc == 0);
TEST_ASSERT(ble_gap_master_in_progress());
@@ -682,10 +678,9 @@ TEST_CASE(ble_gap_test_case_disc_hci_fail)
struct ble_gap_disc_desc desc = {
.event_type = BLE_HCI_ADV_TYPE_ADV_IND,
.addr_type = BLE_ADDR_TYPE_PUBLIC,
.length_data = 0,
.rssi = 0,
.addr = { 1, 2, 3, 4, 5, 6 },
.addr = { BLE_ADDR_PUBLIC, { 1, 2, 3, 4, 5, 6 } },
.data = NULL,
};
struct ble_gap_disc_params disc_params = {
@@ -701,7 +696,7 @@ TEST_CASE(ble_gap_test_case_disc_hci_fail)
disc_params.limited = limited;
for (fail_idx = 0; fail_idx < 2; fail_idx++) {
rc = ble_gap_test_util_disc(BLE_ADDR_TYPE_PUBLIC, &disc_params,
rc = ble_gap_test_util_disc(BLE_OWN_ADDR_PUBLIC, &disc_params,
&desc, fail_idx, BLE_ERR_UNSUPPORTED);
TEST_ASSERT(rc == BLE_HS_HCI_ERR(BLE_ERR_UNSUPPORTED));
TEST_ASSERT(!ble_gap_master_in_progress());
@@ -722,7 +717,7 @@ ble_gap_test_util_disc_dflts_once(int limited)
memset(&params, 0, sizeof params);
params.limited = limited;
rc = ble_hs_test_util_disc(BLE_ADDR_TYPE_PUBLIC, 0, &params,
rc = ble_hs_test_util_disc(BLE_OWN_ADDR_PUBLIC, 0, &params,
ble_gap_test_util_disc_cb, NULL, -1, 0);
TEST_ASSERT_FATAL(rc == 0);
@@ -734,7 +729,7 @@ ble_gap_test_util_disc_dflts_once(int limited)
exp_window = BLE_GAP_SCAN_FAST_WINDOW;
}
ble_gap_test_util_verify_tx_set_scan_params(
BLE_ADDR_TYPE_PUBLIC,
BLE_ADDR_PUBLIC,
BLE_HCI_SCAN_TYPE_ACTIVE,
exp_itvl,
exp_window,
@@ -757,13 +752,13 @@ TEST_CASE(ble_gap_test_case_disc_already)
ble_gap_test_util_init();
/* Start a discovery procedure. */
rc = ble_hs_test_util_disc(BLE_ADDR_TYPE_PUBLIC, BLE_HS_FOREVER,
rc = ble_hs_test_util_disc(BLE_OWN_ADDR_PUBLIC, BLE_HS_FOREVER,
&disc_params, ble_gap_test_util_disc_cb,
NULL, -1, 0);
TEST_ASSERT_FATAL(rc == 0);
/* Ensure host indicates BLE_HS_EALREADY if we try to discover. */
rc = ble_gap_disc(BLE_ADDR_TYPE_PUBLIC, BLE_HS_FOREVER, &disc_params,
rc = ble_gap_disc(BLE_ADDR_PUBLIC, BLE_HS_FOREVER, &disc_params,
ble_gap_test_util_disc_cb, NULL);
TEST_ASSERT(rc == BLE_HS_EALREADY);
}
@@ -771,19 +766,18 @@ TEST_CASE(ble_gap_test_case_disc_already)
TEST_CASE(ble_gap_test_case_disc_busy)
{
static const struct ble_gap_disc_params disc_params = { 0 };
static const uint8_t peer_addr[6] = { 1, 2, 3, 4, 5, 6 };
static const ble_addr_t peer_addr = { BLE_ADDR_PUBLIC, { 1, 2, 3, 4, 5, 6 }};
int rc;
ble_gap_test_util_init();
/* Start a connect procedure. */
rc = ble_hs_test_util_connect(BLE_ADDR_TYPE_PUBLIC, BLE_ADDR_TYPE_PUBLIC,
peer_addr, 0, NULL,
rc = ble_hs_test_util_connect(BLE_OWN_ADDR_PUBLIC, &peer_addr, 0, NULL,
ble_gap_test_util_connect_cb, NULL, 0);
TEST_ASSERT_FATAL(rc == 0);
/* Ensure host indicates BLE_HS_EBUSY if we try to discover. */
rc = ble_gap_disc(BLE_ADDR_TYPE_PUBLIC, BLE_HS_FOREVER, &disc_params,
rc = ble_gap_disc(BLE_ADDR_PUBLIC, BLE_HS_FOREVER, &disc_params,
ble_gap_test_util_disc_cb, NULL);
TEST_ASSERT(rc == BLE_HS_EBUSY);
}
@@ -811,7 +805,7 @@ TEST_CASE(ble_gap_test_case_conn_gen_good)
struct ble_gap_conn_params params;
int rc;
uint8_t peer_addr[6] = { 1, 2, 3, 4, 5, 6 };
ble_addr_t peer_addr = { BLE_ADDR_PUBLIC, { 1, 2, 3, 4, 5, 6 }};
ble_gap_test_util_init();
@@ -827,8 +821,8 @@ TEST_CASE(ble_gap_test_case_conn_gen_good)
params.min_ce_len = 3;
params.max_ce_len = 4;
rc = ble_hs_test_util_connect(BLE_ADDR_TYPE_PUBLIC,
BLE_ADDR_TYPE_PUBLIC, peer_addr, 0, &params,
rc = ble_hs_test_util_connect(BLE_OWN_ADDR_PUBLIC,
&peer_addr, 0, &params,
ble_gap_test_util_connect_cb, NULL, 0);
TEST_ASSERT(rc == 0);
@@ -844,7 +838,7 @@ TEST_CASE(ble_gap_test_case_conn_gen_good)
evt.status = BLE_ERR_SUCCESS;
evt.connection_handle = 2;
evt.role = BLE_HCI_LE_CONN_COMPLETE_ROLE_MASTER;
memcpy(evt.peer_addr, peer_addr, 6);
memcpy(evt.peer_addr, peer_addr.val, 6);
rc = ble_gap_rx_conn_complete(&evt);
TEST_ASSERT(rc == 0);
@@ -852,8 +846,8 @@ TEST_CASE(ble_gap_test_case_conn_gen_good)
TEST_ASSERT(ble_gap_test_event.type == BLE_GAP_EVENT_CONNECT);
TEST_ASSERT(ble_gap_test_conn_desc.conn_handle == 2);
TEST_ASSERT(memcmp(ble_gap_test_conn_desc.peer_id_addr,
peer_addr, 6) == 0);
TEST_ASSERT(memcmp(ble_gap_test_conn_desc.peer_id_addr.val,
peer_addr.val, 6) == 0);
TEST_ASSERT(ble_hs_atomic_conn_flags(2, NULL) == 0);
}
@@ -867,36 +861,35 @@ TEST_CASE(ble_gap_test_case_conn_gen_bad_args)
TEST_ASSERT(!ble_gap_master_in_progress());
/*** Invalid address type. */
rc = ble_gap_connect(BLE_ADDR_TYPE_PUBLIC, 5,
((uint8_t[]){ 1, 2, 3, 4, 5, 6 }), 0, NULL,
rc = ble_gap_connect(BLE_OWN_ADDR_PUBLIC,
&((ble_addr_t) { 5, { 1, 2, 3, 4, 5, 6 }}), 0, NULL,
ble_gap_test_util_connect_cb, NULL);
TEST_ASSERT(rc == BLE_HS_EINVAL);
TEST_ASSERT(!ble_gap_master_in_progress());
/*** Connection already in progress. */
rc = ble_hs_test_util_connect(BLE_ADDR_TYPE_PUBLIC,
BLE_ADDR_TYPE_PUBLIC,
((uint8_t[]){ 1, 2, 3, 4, 5, 6 }), 0,
NULL, ble_gap_test_util_connect_cb,
rc = ble_hs_test_util_connect(BLE_OWN_ADDR_PUBLIC,
&((ble_addr_t) { BLE_ADDR_PUBLIC, { 1, 2, 3, 4, 5, 6 }}),
0, NULL, ble_gap_test_util_connect_cb,
NULL, 0);
TEST_ASSERT(rc == 0);
TEST_ASSERT(ble_gap_master_in_progress());
rc = ble_gap_connect(BLE_ADDR_TYPE_PUBLIC, BLE_ADDR_TYPE_PUBLIC,
((uint8_t[]){ 1, 2, 3, 4, 5, 6 }), 0, NULL,
ble_gap_test_util_connect_cb, NULL);
rc = ble_gap_connect(BLE_OWN_ADDR_PUBLIC,
&((ble_addr_t) { BLE_ADDR_PUBLIC, { 1, 2, 3, 4, 5, 6 }}),
0, NULL, ble_gap_test_util_connect_cb, NULL);
TEST_ASSERT(rc == BLE_HS_EALREADY);
}
TEST_CASE(ble_gap_test_case_conn_gen_dflt_params)
{
static const uint8_t peer_addr[6] = { 2, 3, 8, 6, 6, 1 };
static const ble_addr_t peer_addr = { BLE_ADDR_PUBLIC, { 2, 3, 8, 6, 6, 1 }};
int rc;
ble_gap_test_util_init();
rc = ble_hs_test_util_connect(BLE_ADDR_TYPE_PUBLIC,
BLE_ADDR_TYPE_PUBLIC, peer_addr, 0, NULL,
rc = ble_hs_test_util_connect(BLE_OWN_ADDR_PUBLIC,
&peer_addr, 0, NULL,
ble_gap_test_util_connect_cb, NULL, 0);
TEST_ASSERT(rc == 0);
}
@@ -904,42 +897,39 @@ TEST_CASE(ble_gap_test_case_conn_gen_dflt_params)
TEST_CASE(ble_gap_test_case_conn_gen_already)
{
static const struct ble_gap_conn_params conn_params = { 0 };
static const uint8_t peer_addr[6] = { 1, 2, 3, 4, 5, 6 };
static const ble_addr_t peer_addr = { BLE_ADDR_PUBLIC, { 1, 2, 3, 4, 5, 6 }};
int rc;
ble_gap_test_util_init();
/* Start a connect procedure. */
rc = ble_hs_test_util_connect(BLE_ADDR_TYPE_PUBLIC, BLE_ADDR_TYPE_PUBLIC,
peer_addr, 0, NULL,
rc = ble_hs_test_util_connect(BLE_OWN_ADDR_PUBLIC, &peer_addr, 0, NULL,
ble_gap_test_util_connect_cb, NULL, 0);
TEST_ASSERT_FATAL(rc == 0);
/* Ensure host indicates BLE_HS_EALREADY if we try to connect. */
rc = ble_gap_connect(BLE_ADDR_TYPE_PUBLIC, BLE_ADDR_TYPE_PUBLIC,
peer_addr, BLE_HS_FOREVER, &conn_params,
ble_gap_test_util_connect_cb, NULL);
rc = ble_gap_connect(BLE_OWN_ADDR_PUBLIC, &peer_addr, BLE_HS_FOREVER,
&conn_params, ble_gap_test_util_connect_cb, NULL);
TEST_ASSERT(rc == BLE_HS_EALREADY);
}
TEST_CASE(ble_gap_test_case_conn_gen_done)
{
static const struct ble_gap_conn_params conn_params = { 0 };
static const uint8_t peer_addr[6] = { 1, 2, 3, 4, 5, 6 };
static const ble_addr_t peer_addr = { BLE_ADDR_PUBLIC, { 1, 2, 3, 4, 5, 6 }};
int rc;
ble_gap_test_util_init();
/* Successfully connect to the peer. */
ble_hs_test_util_create_conn(2, peer_addr, ble_gap_test_util_connect_cb,
ble_hs_test_util_create_conn(2, peer_addr.val, ble_gap_test_util_connect_cb,
NULL);
/* Ensure host indicates BLE_HS_EDONE if we try to connect to the same
* peer.
*/
rc = ble_gap_connect(BLE_ADDR_TYPE_PUBLIC, BLE_ADDR_TYPE_PUBLIC,
peer_addr, BLE_HS_FOREVER, &conn_params,
ble_gap_test_util_connect_cb, NULL);
rc = ble_gap_connect(BLE_OWN_ADDR_PUBLIC, &peer_addr, BLE_HS_FOREVER,
&conn_params, ble_gap_test_util_connect_cb, NULL);
TEST_ASSERT(rc == BLE_HS_EDONE);
}
@@ -947,21 +937,20 @@ TEST_CASE(ble_gap_test_case_conn_gen_busy)
{
static const struct ble_gap_disc_params disc_params = { 0 };
static const struct ble_gap_conn_params conn_params = { 0 };
static const uint8_t peer_addr[6] = { 1, 2, 3, 4, 5, 6 };
static const ble_addr_t peer_addr = { BLE_ADDR_PUBLIC, { 1, 2, 3, 4, 5, 6 }};
int rc;
ble_gap_test_util_init();
/* Start a discovery procedure. */
rc = ble_hs_test_util_disc(BLE_ADDR_TYPE_PUBLIC, BLE_HS_FOREVER,
rc = ble_hs_test_util_disc(BLE_ADDR_PUBLIC, BLE_HS_FOREVER,
&disc_params, ble_gap_test_util_disc_cb,
NULL, -1, 0);
TEST_ASSERT_FATAL(rc == 0);
/* Ensure host indicates BLE_HS_EBUSY if we try to connect. */
rc = ble_gap_connect(BLE_ADDR_TYPE_PUBLIC, BLE_ADDR_TYPE_PUBLIC,
peer_addr, BLE_HS_FOREVER, &conn_params,
ble_gap_test_util_connect_cb, NULL);
rc = ble_gap_connect(BLE_ADDR_PUBLIC, &peer_addr, BLE_HS_FOREVER,
&conn_params, ble_gap_test_util_connect_cb, NULL);
TEST_ASSERT(rc == BLE_HS_EBUSY);
}
@@ -1012,13 +1001,15 @@ ble_gap_test_util_conn_cancel(uint8_t hci_status)
static void
ble_gap_test_util_conn_and_cancel(uint8_t *peer_addr, uint8_t hci_status)
{
ble_addr_t addr = { BLE_ADDR_PUBLIC };
int rc;
ble_gap_test_util_init();
memcpy(addr.val, peer_addr, 6);
/* Begin creating a connection. */
rc = ble_hs_test_util_connect(BLE_ADDR_TYPE_PUBLIC,
BLE_ADDR_TYPE_PUBLIC, peer_addr, 0, NULL,
rc = ble_hs_test_util_connect(BLE_ADDR_PUBLIC, &addr, 0, NULL,
ble_gap_test_util_connect_cb, NULL, 0);
TEST_ASSERT(rc == 0);
TEST_ASSERT(ble_gap_master_in_progress());
@@ -1078,7 +1069,7 @@ TEST_CASE(ble_gap_test_case_conn_cancel_ctlr_fail)
TEST_ASSERT(ble_gap_test_event.type == BLE_GAP_EVENT_CONNECT);
TEST_ASSERT(ble_gap_test_conn_desc.conn_handle == 2);
TEST_ASSERT(memcmp(ble_gap_test_conn_desc.peer_id_addr,
TEST_ASSERT(memcmp(ble_gap_test_conn_desc.peer_id_addr.val,
peer_addr, 6) == 0);
TEST_ASSERT(ble_hs_atomic_conn_flags(2, NULL) == 0);
@@ -1152,9 +1143,9 @@ TEST_CASE(ble_gap_test_case_conn_terminate_good)
TEST_ASSERT(ble_gap_test_conn_status ==
BLE_HS_HCI_ERR(BLE_ERR_CONN_TERM_LOCAL));
TEST_ASSERT(ble_gap_test_conn_desc.conn_handle == 2);
TEST_ASSERT(ble_gap_test_conn_desc.peer_id_addr_type ==
BLE_ADDR_TYPE_PUBLIC);
TEST_ASSERT(memcmp(ble_gap_test_conn_desc.peer_id_addr,
TEST_ASSERT(ble_gap_test_conn_desc.peer_id_addr.type ==
BLE_ADDR_PUBLIC);
TEST_ASSERT(memcmp(ble_gap_test_conn_desc.peer_id_addr.val,
peer_addr, 6) == 0);
TEST_ASSERT(ble_gap_test_conn_arg == NULL);
@@ -1193,9 +1184,9 @@ TEST_CASE(ble_gap_test_case_conn_terminate_ctlr_fail)
TEST_ASSERT(ble_gap_test_conn_status ==
BLE_HS_HCI_ERR(BLE_ERR_UNSUPPORTED));
TEST_ASSERT(ble_gap_test_conn_desc.conn_handle == 2);
TEST_ASSERT(ble_gap_test_conn_desc.peer_id_addr_type ==
BLE_ADDR_TYPE_PUBLIC);
TEST_ASSERT(memcmp(ble_gap_test_conn_desc.peer_id_addr,
TEST_ASSERT(ble_gap_test_conn_desc.peer_id_addr.type ==
BLE_ADDR_PUBLIC);
TEST_ASSERT(memcmp(ble_gap_test_conn_desc.peer_id_addr.val,
peer_addr, 6) == 0);
TEST_ASSERT(ble_gap_test_conn_arg == NULL);
@@ -1240,30 +1231,30 @@ TEST_CASE(ble_gap_test_case_conn_find)
ble_gap_test_util_init();
ble_hs_test_util_create_rpa_conn(8,
BLE_ADDR_TYPE_PUBLIC,
BLE_ADDR_PUBLIC,
((uint8_t[6]){0,0,0,0,0,0}),
BLE_ADDR_TYPE_PUBLIC,
BLE_ADDR_PUBLIC,
((uint8_t[6]){2,3,4,5,6,7}),
((uint8_t[6]){0,0,0,0,0,0}),
ble_gap_test_util_connect_cb,
NULL);
rc = ble_hs_id_copy_addr(BLE_ADDR_TYPE_PUBLIC, pub_addr, NULL);
rc = ble_hs_id_copy_addr(BLE_ADDR_PUBLIC, pub_addr, NULL);
TEST_ASSERT_FATAL(rc == 0);
rc = ble_gap_conn_find(8, &desc);
TEST_ASSERT_FATAL(rc == 0);
TEST_ASSERT(desc.conn_handle == 8);
TEST_ASSERT(desc.our_id_addr_type == BLE_ADDR_TYPE_PUBLIC);
TEST_ASSERT(desc.our_ota_addr_type == BLE_ADDR_TYPE_PUBLIC);
TEST_ASSERT(desc.peer_ota_addr_type == BLE_ADDR_TYPE_PUBLIC);
TEST_ASSERT(desc.our_id_addr.type == BLE_ADDR_PUBLIC);
TEST_ASSERT(desc.our_ota_addr.type == BLE_ADDR_PUBLIC);
TEST_ASSERT(desc.peer_ota_addr.type == BLE_ADDR_PUBLIC);
TEST_ASSERT(desc.role == BLE_GAP_ROLE_MASTER);
TEST_ASSERT(memcmp(desc.our_ota_addr, pub_addr, 6) == 0);
TEST_ASSERT(memcmp(desc.our_id_addr, pub_addr, 6) == 0);
TEST_ASSERT(memcmp(desc.peer_ota_addr,
TEST_ASSERT(memcmp(desc.our_ota_addr.val, pub_addr, 6) == 0);
TEST_ASSERT(memcmp(desc.our_id_addr.val, pub_addr, 6) == 0);
TEST_ASSERT(memcmp(desc.peer_ota_addr.val,
((uint8_t[6]){2,3,4,5,6,7}), 6) == 0);
TEST_ASSERT(memcmp(desc.peer_id_addr,
TEST_ASSERT(memcmp(desc.peer_id_addr.val,
((uint8_t[6]){2,3,4,5,6,7}), 6) == 0);
TEST_ASSERT(desc.conn_itvl == BLE_GAP_INITIAL_CONN_ITVL_MAX);
TEST_ASSERT(desc.conn_latency == BLE_GAP_INITIAL_CONN_LATENCY);
@@ -1288,9 +1279,9 @@ TEST_CASE(ble_gap_test_case_conn_find)
ble_gap_test_util_init();
ble_hs_test_util_create_rpa_conn(54,
BLE_ADDR_TYPE_RPA_PUB_DEFAULT,
BLE_OWN_ADDR_RPA_PUBLIC_DEFAULT,
((uint8_t[6]){0x40,1,2,3,4,5}),
BLE_ADDR_TYPE_RPA_RND_DEFAULT,
BLE_OWN_ADDR_RPA_RANDOM_DEFAULT,
((uint8_t[6]){3,4,5,6,7,8}),
((uint8_t[6]){0x50,1,2,3,4,5}),
ble_gap_test_util_connect_cb,
@@ -1299,16 +1290,16 @@ TEST_CASE(ble_gap_test_case_conn_find)
rc = ble_gap_conn_find(54, &desc);
TEST_ASSERT_FATAL(rc == 0);
TEST_ASSERT(desc.conn_handle == 54);
TEST_ASSERT(desc.our_id_addr_type == BLE_ADDR_TYPE_PUBLIC);
TEST_ASSERT(desc.our_ota_addr_type == BLE_ADDR_TYPE_RANDOM);
TEST_ASSERT(desc.peer_ota_addr_type == BLE_ADDR_TYPE_RPA_RND_DEFAULT);
TEST_ASSERT(desc.our_id_addr.type == BLE_ADDR_PUBLIC);
TEST_ASSERT(desc.our_ota_addr.type == BLE_ADDR_RANDOM);
TEST_ASSERT(desc.peer_ota_addr.type == BLE_ADDR_RANDOM);
TEST_ASSERT(desc.role == BLE_GAP_ROLE_MASTER);
TEST_ASSERT(memcmp(desc.our_ota_addr,
TEST_ASSERT(memcmp(desc.our_ota_addr.val,
((uint8_t[6]){0x40,1,2,3,4,5}), 6) == 0);
TEST_ASSERT(memcmp(desc.our_id_addr, pub_addr, 6) == 0);
TEST_ASSERT(memcmp(desc.peer_ota_addr,
TEST_ASSERT(memcmp(desc.our_id_addr.val, pub_addr, 6) == 0);
TEST_ASSERT(memcmp(desc.peer_ota_addr.val,
((uint8_t[6]){0x50,1,2,3,4,5}), 6) == 0);
TEST_ASSERT(memcmp(desc.peer_id_addr,
TEST_ASSERT(memcmp(desc.peer_id_addr.val,
((uint8_t[6]){3,4,5,6,7,8}), 6) == 0);
TEST_ASSERT(desc.conn_itvl == BLE_GAP_INITIAL_CONN_ITVL_MAX);
TEST_ASSERT(desc.conn_latency == BLE_GAP_INITIAL_CONN_LATENCY);
@@ -1342,8 +1333,8 @@ TEST_SUITE(ble_gap_test_suite_conn_find)
*****************************************************************************/
static void
ble_gap_test_util_adv(uint8_t own_addr_type, uint8_t peer_addr_type,
const uint8_t *peer_addr, uint8_t conn_mode,
ble_gap_test_util_adv(uint8_t own_addr_type,
const ble_addr_t *peer_addr, uint8_t conn_mode,
uint8_t disc_mode, int connect_status,
int cmd_fail_idx, uint8_t fail_status)
{
@@ -1383,7 +1374,7 @@ ble_gap_test_util_adv(uint8_t own_addr_type, uint8_t peer_addr_type,
}
if (fail_status == 0 || cmd_fail_idx >= cmd_idx) {
rc = ble_hs_test_util_adv_start(own_addr_type, peer_addr_type,
rc = ble_hs_test_util_adv_start(own_addr_type,
peer_addr, &adv_params, BLE_HS_FOREVER,
ble_gap_test_util_connect_cb, NULL,
cmd_fail_idx - cmd_idx, fail_status);
@@ -1416,7 +1407,7 @@ ble_gap_test_util_adv(uint8_t own_addr_type, uint8_t peer_addr_type,
evt.status = connect_status;
evt.connection_handle = 2;
evt.role = BLE_HCI_LE_CONN_COMPLETE_ROLE_SLAVE;
memcpy(evt.peer_addr, peer_addr, 6);
memcpy(evt.peer_addr, peer_addr->val, 6);
rc = ble_gap_rx_conn_complete(&evt);
TEST_ASSERT(rc == 0);
@@ -1434,7 +1425,8 @@ ble_gap_test_util_adv(uint8_t own_addr_type, uint8_t peer_addr_type,
TEST_CASE(ble_gap_test_case_adv_bad_args)
{
struct ble_gap_adv_params adv_params;
uint8_t peer_addr[6] = { 1, 2, 3, 4, 5, 6 };
ble_addr_t peer_addr = { BLE_ADDR_PUBLIC, { 1, 2, 3, 4, 5, 6 }};
ble_addr_t peer_addr_inv = { 12, { 1, 2, 3, 4, 5, 6 }};
int rc;
ble_gap_test_util_init();
@@ -1444,8 +1436,8 @@ TEST_CASE(ble_gap_test_case_adv_bad_args)
/*** Invalid discoverable mode. */
adv_params = ble_hs_test_util_adv_params;
adv_params.disc_mode = 43;
rc = ble_hs_test_util_adv_start(BLE_ADDR_TYPE_PUBLIC, BLE_ADDR_TYPE_PUBLIC,
peer_addr, &adv_params, BLE_HS_FOREVER,
rc = ble_hs_test_util_adv_start(BLE_OWN_ADDR_PUBLIC,
&peer_addr, &adv_params, BLE_HS_FOREVER,
ble_gap_test_util_connect_cb, NULL, 0, 0);
TEST_ASSERT(rc == BLE_HS_EINVAL);
TEST_ASSERT(!ble_gap_adv_active());
@@ -1453,8 +1445,8 @@ TEST_CASE(ble_gap_test_case_adv_bad_args)
/*** Invalid connectable mode. */
adv_params = ble_hs_test_util_adv_params;
adv_params.conn_mode = 27;
rc = ble_hs_test_util_adv_start(BLE_ADDR_TYPE_PUBLIC, BLE_ADDR_TYPE_PUBLIC,
peer_addr, &adv_params, BLE_HS_FOREVER,
rc = ble_hs_test_util_adv_start(BLE_OWN_ADDR_PUBLIC,
&peer_addr, &adv_params, BLE_HS_FOREVER,
ble_gap_test_util_connect_cb, NULL, 0, 0);
TEST_ASSERT(rc == BLE_HS_EINVAL);
TEST_ASSERT(!ble_gap_adv_active());
@@ -1462,22 +1454,22 @@ TEST_CASE(ble_gap_test_case_adv_bad_args)
/*** Invalid peer address type with directed advertisable mode. */
adv_params = ble_hs_test_util_adv_params;
adv_params.conn_mode = BLE_GAP_CONN_MODE_DIR;
rc = ble_hs_test_util_adv_start(BLE_ADDR_TYPE_PUBLIC, 12,
peer_addr, &adv_params, BLE_HS_FOREVER,
rc = ble_hs_test_util_adv_start(BLE_OWN_ADDR_PUBLIC,
&peer_addr_inv, &adv_params, BLE_HS_FOREVER,
ble_gap_test_util_connect_cb, NULL, 0, 0);
TEST_ASSERT(rc == BLE_HS_EINVAL);
TEST_ASSERT(!ble_gap_adv_active());
/*** Advertising already in progress. */
adv_params = ble_hs_test_util_adv_params;
rc = ble_hs_test_util_adv_start(BLE_ADDR_TYPE_PUBLIC, BLE_ADDR_TYPE_PUBLIC,
peer_addr, &adv_params, BLE_HS_FOREVER,
rc = ble_hs_test_util_adv_start(BLE_OWN_ADDR_PUBLIC,
&peer_addr, &adv_params, BLE_HS_FOREVER,
ble_gap_test_util_connect_cb, NULL, 0, 0);
TEST_ASSERT(rc == 0);
TEST_ASSERT(ble_gap_adv_active());
rc = ble_hs_test_util_adv_start(BLE_ADDR_TYPE_PUBLIC, BLE_ADDR_TYPE_PUBLIC,
peer_addr, &adv_params, BLE_HS_FOREVER,
rc = ble_hs_test_util_adv_start(BLE_OWN_ADDR_PUBLIC,
&peer_addr, &adv_params, BLE_HS_FOREVER,
ble_gap_test_util_connect_cb, NULL, 0, 0);
TEST_ASSERT(rc == BLE_HS_EALREADY);
TEST_ASSERT(ble_gap_adv_active());
@@ -1485,8 +1477,7 @@ TEST_CASE(ble_gap_test_case_adv_bad_args)
static void
ble_gap_test_util_adv_verify_dflt_params(uint8_t own_addr_type,
uint8_t peer_addr_type,
const uint8_t *peer_addr,
const ble_addr_t *peer_addr,
uint8_t conn_mode,
uint8_t disc_mode)
{
@@ -1511,8 +1502,8 @@ ble_gap_test_util_adv_verify_dflt_params(uint8_t own_addr_type,
adv_params.filter_policy = 0;
adv_params.high_duty_cycle = 0;
rc = ble_hs_test_util_adv_start(BLE_ADDR_TYPE_PUBLIC, BLE_ADDR_TYPE_PUBLIC,
peer_addr, &adv_params, BLE_HS_FOREVER,
rc = ble_hs_test_util_adv_start(BLE_OWN_ADDR_PUBLIC, peer_addr,
&adv_params, BLE_HS_FOREVER,
ble_gap_test_util_connect_cb, NULL, 0, 0);
TEST_ASSERT_FATAL(rc == 0);
@@ -1555,7 +1546,7 @@ ble_gap_test_util_adv_verify_dflt_params(uint8_t own_addr_type,
TEST_CASE(ble_gap_test_case_adv_dflt_params)
{
uint8_t peer_addr[6] = { 1, 2, 3, 4, 5, 6 };
ble_addr_t peer_addr = { BLE_ADDR_PUBLIC, { 1, 2, 3, 4, 5, 6 }};
int d;
int c;
@@ -1563,29 +1554,29 @@ TEST_CASE(ble_gap_test_case_adv_dflt_params)
for (c = BLE_GAP_CONN_MODE_NON; c < BLE_GAP_CONN_MODE_MAX; c++) {
for (d = BLE_GAP_DISC_MODE_NON; d < BLE_GAP_DISC_MODE_MAX; d++) {
ble_gap_test_util_adv_verify_dflt_params(
BLE_ADDR_TYPE_PUBLIC, BLE_ADDR_TYPE_PUBLIC, peer_addr, c, d);
BLE_OWN_ADDR_PUBLIC, &peer_addr, c, d);
}
}
}
TEST_CASE(ble_gap_test_case_adv_good)
{
uint8_t peer_addr[6] = { 1, 2, 3, 4, 5, 6 };
ble_addr_t peer_addr = { BLE_ADDR_PUBLIC, { 1, 2, 3, 4, 5, 6 }};
int d;
int c;
for (c = BLE_GAP_CONN_MODE_NON; c < BLE_GAP_CONN_MODE_MAX; c++) {
for (d = BLE_GAP_DISC_MODE_NON; d < BLE_GAP_DISC_MODE_MAX; d++) {
ble_gap_test_util_adv(BLE_ADDR_TYPE_PUBLIC, BLE_ADDR_TYPE_PUBLIC,
peer_addr, c, d, BLE_ERR_SUCCESS, -1, 0);
ble_gap_test_util_adv(BLE_OWN_ADDR_PUBLIC,
&peer_addr, c, d, BLE_ERR_SUCCESS, -1, 0);
if (c != BLE_GAP_CONN_MODE_NON) {
TEST_ASSERT(!ble_gap_adv_active());
TEST_ASSERT(ble_gap_test_event.type == BLE_GAP_EVENT_CONNECT);
TEST_ASSERT(ble_gap_test_conn_status == 0);
TEST_ASSERT(ble_gap_test_conn_desc.conn_handle == 2);
TEST_ASSERT(memcmp(ble_gap_test_conn_desc.peer_id_addr,
peer_addr, 6) == 0);
TEST_ASSERT(memcmp(ble_gap_test_conn_desc.peer_id_addr.val,
peer_addr.val, 6) == 0);
TEST_ASSERT(ble_gap_test_conn_arg == NULL);
}
}
@@ -1594,14 +1585,14 @@ TEST_CASE(ble_gap_test_case_adv_good)
TEST_CASE(ble_gap_test_case_adv_ctlr_fail)
{
uint8_t peer_addr[6] = { 1, 2, 3, 4, 5, 6 };
ble_addr_t peer_addr = { BLE_ADDR_PUBLIC, { 1, 2, 3, 4, 5, 6 }};
int d;
int c;
for (c = BLE_GAP_CONN_MODE_NON + 1; c < BLE_GAP_CONN_MODE_MAX; c++) {
for (d = BLE_GAP_DISC_MODE_NON; d < BLE_GAP_DISC_MODE_MAX; d++) {
ble_gap_test_util_adv(BLE_ADDR_TYPE_PUBLIC, BLE_ADDR_TYPE_PUBLIC,
peer_addr, c, d, BLE_ERR_DIR_ADV_TMO, -1, 0);
ble_gap_test_util_adv(BLE_OWN_ADDR_PUBLIC,
&peer_addr, c, d, BLE_ERR_DIR_ADV_TMO, -1, 0);
TEST_ASSERT(!ble_gap_adv_active());
TEST_ASSERT(ble_gap_test_event.type == BLE_GAP_EVENT_ADV_COMPLETE);
@@ -1614,7 +1605,7 @@ TEST_CASE(ble_gap_test_case_adv_ctlr_fail)
TEST_CASE(ble_gap_test_case_adv_hci_fail)
{
uint8_t peer_addr[6] = { 1, 2, 3, 4, 5, 6 };
ble_addr_t peer_addr = { BLE_ADDR_PUBLIC, { 1, 2, 3, 4, 5, 6 }};
int fail_idx;
int d;
int c;
@@ -1622,8 +1613,8 @@ TEST_CASE(ble_gap_test_case_adv_hci_fail)
for (c = BLE_GAP_CONN_MODE_NON; c < BLE_GAP_CONN_MODE_MAX; c++) {
for (d = BLE_GAP_DISC_MODE_NON; d < BLE_GAP_DISC_MODE_MAX; d++) {
for (fail_idx = 0; fail_idx < 4; fail_idx++) {
ble_gap_test_util_adv(BLE_ADDR_TYPE_PUBLIC,
BLE_ADDR_TYPE_PUBLIC, peer_addr,
ble_gap_test_util_adv(BLE_OWN_ADDR_PUBLIC,
&peer_addr,
c, d, 0, fail_idx, BLE_ERR_UNSUPPORTED);
TEST_ASSERT(!ble_gap_adv_active());
@@ -1649,7 +1640,7 @@ TEST_SUITE(ble_gap_test_suite_adv)
*****************************************************************************/
static void
ble_gap_test_util_stop_adv(uint8_t peer_addr_type, const uint8_t *peer_addr,
ble_gap_test_util_stop_adv(const ble_addr_t *peer_addr,
uint8_t conn_mode, uint8_t disc_mode,
int cmd_fail_idx, uint8_t fail_status)
{
@@ -1659,7 +1650,7 @@ ble_gap_test_util_stop_adv(uint8_t peer_addr_type, const uint8_t *peer_addr,
ble_gap_test_util_init();
/* Start advertising; don't rx a successful connection event. */
ble_gap_test_util_adv(BLE_ADDR_TYPE_PUBLIC, peer_addr_type, peer_addr,
ble_gap_test_util_adv(BLE_OWN_ADDR_PUBLIC, peer_addr,
conn_mode, disc_mode, -1, -1, 0);
TEST_ASSERT(ble_gap_adv_active());
@@ -1676,14 +1667,13 @@ ble_gap_test_util_stop_adv(uint8_t peer_addr_type, const uint8_t *peer_addr,
TEST_CASE(ble_gap_test_case_stop_adv_good)
{
uint8_t peer_addr[6] = { 1, 2, 3, 4, 5, 6 };
ble_addr_t peer_addr = { BLE_ADDR_PUBLIC, { 1, 2, 3, 4, 5, 6 }};
int d;
int c;
for (c = BLE_GAP_CONN_MODE_NON; c < BLE_GAP_CONN_MODE_MAX; c++) {
for (d = BLE_GAP_DISC_MODE_NON; d < BLE_GAP_DISC_MODE_MAX; d++) {
ble_gap_test_util_stop_adv(BLE_ADDR_TYPE_PUBLIC, peer_addr, c, d,
-1, 0);
ble_gap_test_util_stop_adv(&peer_addr, c, d, -1, 0);
TEST_ASSERT(!ble_gap_adv_active());
TEST_ASSERT(ble_gap_test_event.type == 0xff);
TEST_ASSERT(ble_gap_test_conn_status == -1);
@@ -1695,13 +1685,13 @@ TEST_CASE(ble_gap_test_case_stop_adv_good)
TEST_CASE(ble_gap_test_case_stop_adv_hci_fail)
{
uint8_t peer_addr[6] = { 1, 2, 3, 4, 5, 6 };
ble_addr_t peer_addr = { BLE_ADDR_PUBLIC, { 1, 2, 3, 4, 5, 6 }};
int d;
int c;
for (c = BLE_GAP_CONN_MODE_NON; c < BLE_GAP_CONN_MODE_MAX; c++) {
for (d = BLE_GAP_DISC_MODE_NON; d < BLE_GAP_DISC_MODE_MAX; d++) {
ble_gap_test_util_stop_adv(BLE_ADDR_TYPE_PUBLIC, peer_addr, c, d,
ble_gap_test_util_stop_adv(&peer_addr, c, d,
0, BLE_ERR_UNSUPPORTED);
TEST_ASSERT(ble_gap_adv_active());
TEST_ASSERT(ble_gap_test_event.type == 0xff);
@@ -1774,7 +1764,7 @@ ble_gap_test_util_update_no_l2cap(struct ble_gap_upd_params *params,
TEST_ASSERT(ble_gap_test_conn_status == BLE_HS_HCI_ERR(event_status));
if (event_status == 0) {
TEST_ASSERT(ble_gap_test_conn_desc.conn_handle == 2);
TEST_ASSERT(memcmp(ble_gap_test_conn_desc.peer_id_addr,
TEST_ASSERT(memcmp(ble_gap_test_conn_desc.peer_id_addr.val,
peer_addr, 6) == 0);
TEST_ASSERT(ble_gap_test_conn_desc.conn_itvl == params->itvl_max);
TEST_ASSERT(ble_gap_test_conn_desc.conn_latency ==
@@ -1867,7 +1857,7 @@ ble_gap_test_util_update_l2cap(struct ble_gap_upd_params *params,
}
TEST_ASSERT(ble_gap_test_conn_desc.conn_handle == 2);
TEST_ASSERT(memcmp(ble_gap_test_conn_desc.peer_id_addr,
TEST_ASSERT(memcmp(ble_gap_test_conn_desc.peer_id_addr.val,
peer_addr, 6) == 0);
}
@@ -1931,7 +1921,7 @@ ble_gap_test_util_update_no_l2cap_tmo(struct ble_gap_upd_params *params,
TEST_ASSERT(ble_gap_test_event.type == BLE_GAP_EVENT_CONN_UPDATE);
TEST_ASSERT(ble_gap_test_conn_status == BLE_HS_ETIMEOUT);
TEST_ASSERT(ble_gap_test_conn_desc.conn_handle == 2);
TEST_ASSERT(memcmp(ble_gap_test_conn_desc.peer_id_addr,
TEST_ASSERT(memcmp(ble_gap_test_conn_desc.peer_id_addr.val,
peer_addr, 6) == 0);
}
@@ -2023,7 +2013,7 @@ ble_gap_test_util_update_l2cap_tmo(struct ble_gap_upd_params *params,
TEST_ASSERT(ble_gap_test_event.type == BLE_GAP_EVENT_CONN_UPDATE);
TEST_ASSERT(ble_gap_test_conn_status == BLE_HS_ETIMEOUT);
TEST_ASSERT(ble_gap_test_conn_desc.conn_handle == 2);
TEST_ASSERT(memcmp(ble_gap_test_conn_desc.peer_id_addr,
TEST_ASSERT(memcmp(ble_gap_test_conn_desc.peer_id_addr.val,
peer_addr, 6) == 0);
}
@@ -2048,7 +2038,7 @@ ble_gap_test_util_update_peer(uint8_t status,
TEST_ASSERT(ble_gap_test_event.type == BLE_GAP_EVENT_CONN_UPDATE);
TEST_ASSERT(ble_gap_test_conn_status == BLE_HS_HCI_ERR(status));
TEST_ASSERT(ble_gap_test_conn_desc.conn_handle == 2);
TEST_ASSERT(memcmp(ble_gap_test_conn_desc.peer_id_addr,
TEST_ASSERT(memcmp(ble_gap_test_conn_desc.peer_id_addr.val,
peer_addr, 6) == 0);
if (status == 0) {
@@ -2105,7 +2095,7 @@ ble_gap_test_util_update_req_pos(struct ble_gap_upd_params *peer_params,
TEST_ASSERT(ble_gap_test_event.type == BLE_GAP_EVENT_CONN_UPDATE);
TEST_ASSERT(ble_gap_test_conn_status == 0);
TEST_ASSERT(ble_gap_test_conn_desc.conn_handle == 2);
TEST_ASSERT(memcmp(ble_gap_test_conn_desc.peer_id_addr,
TEST_ASSERT(memcmp(ble_gap_test_conn_desc.peer_id_addr.val,
peer_addr, 6) == 0);
TEST_ASSERT(ble_gap_test_conn_desc.conn_itvl == self_params->itvl_max);
TEST_ASSERT(ble_gap_test_conn_desc.conn_latency == self_params->latency);
@@ -2118,7 +2108,7 @@ hci_fail:
TEST_ASSERT(ble_gap_test_event.type == BLE_GAP_EVENT_CONN_UPDATE);
TEST_ASSERT(ble_gap_test_conn_status == BLE_HS_HCI_ERR(hci_status));
TEST_ASSERT(ble_gap_test_conn_desc.conn_handle == 2);
TEST_ASSERT(memcmp(ble_gap_test_conn_desc.peer_id_addr,
TEST_ASSERT(memcmp(ble_gap_test_conn_desc.peer_id_addr.val,
peer_addr, 6) == 0);
TEST_ASSERT(ble_gap_test_conn_desc.conn_itvl ==
BLE_GAP_INITIAL_CONN_ITVL_MAX);
@@ -2168,7 +2158,7 @@ hci_fail:
TEST_ASSERT(ble_gap_test_event.type == BLE_GAP_EVENT_CONN_UPDATE);
TEST_ASSERT(ble_gap_test_conn_status == BLE_HS_HCI_ERR(hci_status));
TEST_ASSERT(ble_gap_test_conn_desc.conn_handle == 2);
TEST_ASSERT(memcmp(ble_gap_test_conn_desc.peer_id_addr,
TEST_ASSERT(memcmp(ble_gap_test_conn_desc.peer_id_addr.val,
peer_addr, 6) == 0);
TEST_ASSERT(ble_gap_test_conn_desc.conn_itvl ==
BLE_GAP_INITIAL_CONN_ITVL_MAX);
@@ -2244,7 +2234,7 @@ ble_gap_test_util_update_req_concurrent(
TEST_ASSERT(ble_gap_test_event.type == BLE_GAP_EVENT_CONN_UPDATE);
TEST_ASSERT(ble_gap_test_conn_status == 0);
TEST_ASSERT(ble_gap_test_conn_desc.conn_handle == 2);
TEST_ASSERT(memcmp(ble_gap_test_conn_desc.peer_id_addr,
TEST_ASSERT(memcmp(ble_gap_test_conn_desc.peer_id_addr.val,
peer_addr, 6) == 0);
TEST_ASSERT(ble_gap_test_conn_desc.conn_itvl == self_params->itvl_max);
TEST_ASSERT(ble_gap_test_conn_desc.conn_latency == self_params->latency);
@@ -2257,7 +2247,7 @@ hci_fail:
TEST_ASSERT(ble_gap_test_event.type == BLE_GAP_EVENT_CONN_UPDATE);
TEST_ASSERT(ble_gap_test_conn_status == BLE_HS_HCI_ERR(fail_status));
TEST_ASSERT(ble_gap_test_conn_desc.conn_handle == 2);
TEST_ASSERT(memcmp(ble_gap_test_conn_desc.peer_id_addr,
TEST_ASSERT(memcmp(ble_gap_test_conn_desc.peer_id_addr.val,
peer_addr, 6) == 0);
TEST_ASSERT(ble_gap_test_conn_desc.conn_itvl ==
BLE_GAP_INITIAL_CONN_ITVL_MAX);
@@ -2577,9 +2567,9 @@ ble_gap_test_util_conn_forever(void)
int32_t ticks_from_now;
/* Initiate a connect procedure with no timeout. */
ble_hs_test_util_connect(BLE_ADDR_TYPE_PUBLIC,
BLE_ADDR_TYPE_PUBLIC,
((uint8_t[]){ 1, 2, 3, 4, 5, 6 }), BLE_HS_FOREVER,
ble_hs_test_util_connect(BLE_OWN_ADDR_PUBLIC,
&((ble_addr_t) { BLE_ADDR_PUBLIC, { 1, 2, 3, 4, 5, 6 }}),
BLE_HS_FOREVER,
NULL, ble_gap_test_util_connect_cb,
NULL, 0);
@@ -2605,9 +2595,9 @@ ble_gap_test_util_conn_timeout(int32_t duration_ms)
TEST_ASSERT_FATAL(duration_ms != BLE_HS_FOREVER);
/* Initiate a connect procedure with the specified timeout. */
ble_hs_test_util_connect(BLE_ADDR_TYPE_PUBLIC,
BLE_ADDR_TYPE_PUBLIC,
((uint8_t[]){ 1, 2, 3, 4, 5, 6 }), duration_ms,
ble_hs_test_util_connect(BLE_OWN_ADDR_PUBLIC,
&((ble_addr_t) { BLE_ADDR_PUBLIC, { 1, 2, 3, 4, 5, 6 }}),
duration_ms,
NULL, ble_gap_test_util_connect_cb,
NULL, 0);
@@ -2663,7 +2653,7 @@ ble_gap_test_util_disc_forever(void)
memset(&params, 0, sizeof params);
/* Initiate a discovery procedure with no timeout. */
ble_hs_test_util_disc(BLE_ADDR_TYPE_PUBLIC,
ble_hs_test_util_disc(BLE_ADDR_PUBLIC,
BLE_HS_FOREVER, &params, ble_gap_test_util_disc_cb,
NULL, -1, 0);
@@ -2690,7 +2680,7 @@ ble_gap_test_util_disc_timeout(int32_t duration_ms)
memset(&params, 0, sizeof params);
/* Initiate a discovery procedure with the specified timeout. */
ble_hs_test_util_disc(BLE_ADDR_TYPE_PUBLIC,
ble_hs_test_util_disc(BLE_ADDR_PUBLIC,
duration_ms, &params, ble_gap_test_util_disc_cb,
NULL, -1, 0);
nimble/host/test/src/ble_gatts_notify_test.c
+1 -1
View File
@@ -921,7 +921,7 @@ TEST_CASE(ble_gatts_notify_test_bonded_i_no_ack)
ble_gatts_notify_test_chr_1_len);
/* Verify 'updated' state is still persisted. */
key_cccd.peer_addr_type = BLE_STORE_ADDR_TYPE_NONE;
key_cccd.peer_addr = *BLE_ADDR_ANY;
key_cccd.chr_val_handle = ble_gatts_notify_test_chr_1_def_handle + 1;
key_cccd.idx = 0;
nimble/host/test/src/ble_hs_adv_test.c
+2 -2
View File
@@ -158,7 +158,7 @@ ble_hs_adv_test_misc_tx_and_verify_data(
ble_hs_adv_test_misc_verify_tx_rsp_data(test_rsp_fields);
}
rc = ble_hs_test_util_adv_start(BLE_ADDR_TYPE_PUBLIC, 0, NULL, &adv_params,
rc = ble_hs_test_util_adv_start(BLE_OWN_ADDR_PUBLIC, NULL, &adv_params,
BLE_HS_FOREVER, NULL, NULL, 0, 0);
TEST_ASSERT_FATAL(rc == 0);
@@ -169,7 +169,7 @@ ble_hs_adv_test_misc_tx_and_verify_data(
rc = ble_hs_test_util_adv_stop(0);
TEST_ASSERT_FATAL(rc == 0);
rc = ble_hs_test_util_adv_start(BLE_ADDR_TYPE_PUBLIC, 0, NULL, &adv_params,
rc = ble_hs_test_util_adv_start(BLE_OWN_ADDR_PUBLIC, NULL, &adv_params,
BLE_HS_FOREVER, NULL, NULL, 0, 0);
TEST_ASSERT_FATAL(rc == 0);
nimble/host/test/src/ble_hs_conn_test.c
+15 -17
View File
@@ -43,7 +43,7 @@ TEST_CASE(ble_hs_conn_test_direct_connect_success)
struct hci_le_conn_complete evt;
struct ble_l2cap_chan *chan;
struct ble_hs_conn *conn;
uint8_t addr[6] = { 1, 2, 3, 4, 5, 6 };
ble_addr_t addr = { BLE_ADDR_PUBLIC, { 1, 2, 3, 4, 5, 6 }};
int rc;
ble_hs_test_util_init();
@@ -53,9 +53,8 @@ TEST_CASE(ble_hs_conn_test_direct_connect_success)
TEST_ASSERT(!ble_hs_conn_test_util_any());
/* Initiate connection. */
rc = ble_hs_test_util_connect(BLE_ADDR_TYPE_PUBLIC,
BLE_ADDR_TYPE_PUBLIC,
addr, 0, NULL, NULL, NULL, 0);
rc = ble_hs_test_util_connect(BLE_OWN_ADDR_PUBLIC,
&addr, 0, NULL, NULL, NULL, 0);
TEST_ASSERT(rc == 0);
TEST_ASSERT(ble_gap_master_in_progress());
@@ -66,7 +65,7 @@ TEST_CASE(ble_hs_conn_test_direct_connect_success)
evt.status = BLE_ERR_SUCCESS;
evt.connection_handle = 2;
evt.role = BLE_HCI_LE_CONN_COMPLETE_ROLE_MASTER;
memcpy(evt.peer_addr, addr, 6);
memcpy(evt.peer_addr, addr.val, 6);
rc = ble_gap_rx_conn_complete(&evt);
TEST_ASSERT(rc == 0);
TEST_ASSERT(!ble_gap_master_in_progress());
@@ -76,7 +75,7 @@ TEST_CASE(ble_hs_conn_test_direct_connect_success)
conn = ble_hs_conn_first();
TEST_ASSERT_FATAL(conn != NULL);
TEST_ASSERT(conn->bhc_handle == 2);
TEST_ASSERT(memcmp(conn->bhc_peer_addr, addr, 6) == 0);
TEST_ASSERT(memcmp(conn->bhc_peer_addr.val, addr.val, 6) == 0);
chan = ble_hs_conn_chan_find(conn, BLE_L2CAP_CID_ATT);
TEST_ASSERT_FATAL(chan != NULL);
@@ -93,7 +92,7 @@ TEST_CASE(ble_hs_conn_test_direct_connectable_success)
struct ble_gap_adv_params adv_params;
struct ble_l2cap_chan *chan;
struct ble_hs_conn *conn;
uint8_t addr[6] = { 1, 2, 3, 4, 5, 6 };
ble_addr_t addr = { BLE_ADDR_PUBLIC, { 1, 2, 3, 4, 5, 6 }};
int rc;
ble_hs_test_util_init();
@@ -106,8 +105,8 @@ TEST_CASE(ble_hs_conn_test_direct_connectable_success)
/* Initiate advertising. */
adv_params = ble_hs_test_util_adv_params;
adv_params.conn_mode = BLE_GAP_CONN_MODE_DIR;
rc = ble_hs_test_util_adv_start(BLE_ADDR_TYPE_PUBLIC, BLE_ADDR_TYPE_PUBLIC,
addr, &adv_params, BLE_HS_FOREVER,
rc = ble_hs_test_util_adv_start(BLE_OWN_ADDR_PUBLIC,
&addr, &adv_params, BLE_HS_FOREVER,
NULL, NULL, 0, 0);
TEST_ASSERT(rc == 0);
@@ -120,7 +119,7 @@ TEST_CASE(ble_hs_conn_test_direct_connectable_success)
evt.status = BLE_ERR_SUCCESS;
evt.connection_handle = 2;
evt.role = BLE_HCI_LE_CONN_COMPLETE_ROLE_SLAVE;
memcpy(evt.peer_addr, addr, 6);
memcpy(evt.peer_addr, addr.val, 6);
rc = ble_gap_rx_conn_complete(&evt);
TEST_ASSERT(rc == 0);
TEST_ASSERT(!ble_gap_master_in_progress());
@@ -131,7 +130,7 @@ TEST_CASE(ble_hs_conn_test_direct_connectable_success)
conn = ble_hs_conn_first();
TEST_ASSERT_FATAL(conn != NULL);
TEST_ASSERT(conn->bhc_handle == 2);
TEST_ASSERT(memcmp(conn->bhc_peer_addr, addr, 6) == 0);
TEST_ASSERT(memcmp(conn->bhc_peer_addr.val, addr.val, 6) == 0);
chan = ble_hs_conn_chan_find(conn, BLE_L2CAP_CID_ATT);
TEST_ASSERT_FATAL(chan != NULL);
@@ -149,7 +148,7 @@ TEST_CASE(ble_hs_conn_test_undirect_connectable_success)
struct ble_gap_adv_params adv_params;
struct ble_l2cap_chan *chan;
struct ble_hs_conn *conn;
uint8_t addr[6] = { 1, 2, 3, 4, 5, 6 };
ble_addr_t addr = { BLE_ADDR_PUBLIC, { 1, 2, 3, 4, 5, 6 }};
int rc;
ble_hs_test_util_init();
@@ -167,9 +166,8 @@ TEST_CASE(ble_hs_conn_test_undirect_connectable_success)
adv_params = ble_hs_test_util_adv_params;
adv_params.conn_mode = BLE_GAP_CONN_MODE_UND;
rc = ble_hs_test_util_adv_start(BLE_ADDR_TYPE_PUBLIC,
BLE_ADDR_TYPE_PUBLIC,
addr, &adv_params,
rc = ble_hs_test_util_adv_start(BLE_OWN_ADDR_PUBLIC,
&addr, &adv_params,
BLE_HS_FOREVER,
NULL, NULL, 0, 0);
TEST_ASSERT(rc == 0);
@@ -183,7 +181,7 @@ TEST_CASE(ble_hs_conn_test_undirect_connectable_success)
evt.status = BLE_ERR_SUCCESS;
evt.connection_handle = 2;
evt.role = BLE_HCI_LE_CONN_COMPLETE_ROLE_SLAVE;
memcpy(evt.peer_addr, addr, 6);
memcpy(evt.peer_addr, addr.val, 6);
rc = ble_gap_rx_conn_complete(&evt);
TEST_ASSERT(rc == 0);
TEST_ASSERT(!ble_gap_master_in_progress());
@@ -194,7 +192,7 @@ TEST_CASE(ble_hs_conn_test_undirect_connectable_success)
conn = ble_hs_conn_first();
TEST_ASSERT_FATAL(conn != NULL);
TEST_ASSERT(conn->bhc_handle == 2);
TEST_ASSERT(memcmp(conn->bhc_peer_addr, addr, 6) == 0);
TEST_ASSERT(memcmp(conn->bhc_peer_addr.val, addr.val, 6) == 0);
chan = ble_hs_conn_chan_find(conn, BLE_L2CAP_CID_ATT);
TEST_ASSERT_FATAL(chan != NULL);
nimble/host/test/src/ble_hs_test_util.c
+30 -28
View File
@@ -372,11 +372,15 @@ ble_hs_test_util_create_rpa_conn(uint16_t handle, uint8_t own_addr_type,
const uint8_t *peer_rpa,
ble_gap_event_fn *cb, void *cb_arg)
{
ble_addr_t addr;
struct hci_le_conn_complete evt;
int rc;
ble_hs_test_util_connect(own_addr_type, peer_addr_type,
peer_id_addr, 0, NULL, cb, cb_arg, 0);
addr.type = peer_addr_type;
memcpy(addr.val, peer_id_addr, 6);
ble_hs_test_util_connect(own_addr_type, &addr,
0, NULL, cb, cb_arg, 0);
memset(&evt, 0, sizeof evt);
evt.subevent_code = BLE_HCI_LE_SUBEV_CONN_COMPLETE;
@@ -403,8 +407,8 @@ ble_hs_test_util_create_conn(uint16_t handle, const uint8_t *peer_id_addr,
{
static uint8_t null_addr[6];
ble_hs_test_util_create_rpa_conn(handle, BLE_ADDR_TYPE_PUBLIC, null_addr,
BLE_ADDR_TYPE_PUBLIC, peer_id_addr,
ble_hs_test_util_create_rpa_conn(handle, BLE_ADDR_PUBLIC, null_addr,
BLE_ADDR_PUBLIC, peer_id_addr,
null_addr, cb, cb_arg);
}
@@ -423,20 +427,20 @@ ble_hs_test_util_conn_params_dflt(struct ble_gap_conn_params *conn_params)
static void
ble_hs_test_util_hcc_from_conn_params(
struct hci_create_conn *hcc, uint8_t own_addr_type, uint8_t peer_addr_type,
const uint8_t *peer_addr, const struct ble_gap_conn_params *conn_params)
struct hci_create_conn *hcc, uint8_t own_addr_type,
const ble_addr_t *peer_addr, const struct ble_gap_conn_params *conn_params)
{
hcc->scan_itvl = conn_params->scan_itvl;
hcc->scan_window = conn_params->scan_window;
if (peer_addr_type == BLE_GAP_ADDR_TYPE_WL) {
if (peer_addr == NULL) {
hcc->filter_policy = BLE_HCI_CONN_FILT_USE_WL;
hcc->peer_addr_type = 0;
memset(hcc->peer_addr, 0, 6);
} else {
hcc->filter_policy = BLE_HCI_CONN_FILT_NO_WL;
hcc->peer_addr_type = peer_addr_type;
memcpy(hcc->peer_addr, peer_addr, 6);
hcc->peer_addr_type = peer_addr->type;
memcpy(hcc->peer_addr, peer_addr->val, 6);
}
hcc->own_addr_type = own_addr_type;
hcc->conn_itvl_min = conn_params->itvl_min;
@@ -488,8 +492,8 @@ ble_hs_test_util_verify_tx_create_conn(const struct hci_create_conn *exp)
}
int
ble_hs_test_util_connect(uint8_t own_addr_type, uint8_t peer_addr_type,
const uint8_t *peer_addr, int32_t duration_ms,
ble_hs_test_util_connect(uint8_t own_addr_type, const ble_addr_t *peer_addr,
int32_t duration_ms,
const struct ble_gap_conn_params *params,
ble_gap_event_fn *cb, void *cb_arg,
uint8_t ack_status)
@@ -509,8 +513,8 @@ ble_hs_test_util_connect(uint8_t own_addr_type, uint8_t peer_addr_type,
BLE_HCI_OCF_LE_CREATE_CONN),
ack_status);
rc = ble_gap_connect(own_addr_type, peer_addr_type, peer_addr, duration_ms,
params, cb, cb_arg);
rc = ble_gap_connect(own_addr_type, peer_addr, duration_ms, params, cb,
cb_arg);
TEST_ASSERT(rc == BLE_HS_HCI_ERR(ack_status));
@@ -519,8 +523,8 @@ ble_hs_test_util_connect(uint8_t own_addr_type, uint8_t peer_addr_type,
params = &dflt_params;
}
ble_hs_test_util_hcc_from_conn_params(&hcc, own_addr_type,
peer_addr_type, peer_addr, params);
ble_hs_test_util_hcc_from_conn_params(&hcc, own_addr_type, peer_addr,
params);
ble_hs_test_util_verify_tx_create_conn(&hcc);
return rc;
@@ -624,8 +628,8 @@ ble_hs_test_util_disc(uint8_t own_addr_type, int32_t duration_ms,
* enabled and does not send SET_RPA_TMO every time. For test purpose
* let's track privacy state in here.
*/
if ((own_addr_type == BLE_ADDR_TYPE_RPA_PUB_DEFAULT ||
own_addr_type == BLE_ADDR_TYPE_RPA_RND_DEFAULT) && !privacy_enabled) {
if ((own_addr_type == BLE_OWN_ADDR_RPA_PUBLIC_DEFAULT ||
own_addr_type == BLE_OWN_ADDR_RPA_RANDOM_DEFAULT) && !privacy_enabled) {
privacy_enabled = true;
ble_hs_test_util_set_ack_seq(((struct ble_hs_test_util_phony_ack[]) {
{
@@ -771,8 +775,7 @@ ble_hs_test_util_adv_rsp_set_fields(const struct ble_hs_adv_fields *adv_fields,
}
int
ble_hs_test_util_adv_start(uint8_t own_addr_type,
uint8_t peer_addr_type, const uint8_t *peer_addr,
ble_hs_test_util_adv_start(uint8_t own_addr_type, const ble_addr_t *peer_addr,
const struct ble_gap_adv_params *adv_params,
int32_t duration_ms,
ble_gap_event_fn *cb, void *cb_arg,
@@ -800,7 +803,7 @@ ble_hs_test_util_adv_start(uint8_t own_addr_type,
ble_hs_test_util_set_ack_seq(acks);
rc = ble_gap_adv_start(own_addr_type, peer_addr_type, peer_addr,
rc = ble_gap_adv_start(own_addr_type, peer_addr,
duration_ms, adv_params, cb, cb_arg);
return rc;
@@ -820,8 +823,7 @@ ble_hs_test_util_adv_stop(uint8_t hci_status)
}
int
ble_hs_test_util_wl_set(struct ble_gap_white_entry *white_list,
uint8_t white_list_count,
ble_hs_test_util_wl_set(ble_addr_t *addrs, uint8_t addrs_count,
int fail_idx, uint8_t fail_status)
{
struct ble_hs_test_util_phony_ack acks[64];
@@ -829,7 +831,7 @@ ble_hs_test_util_wl_set(struct ble_gap_white_entry *white_list,
int rc;
int i;
TEST_ASSERT_FATAL(white_list_count < 63);
TEST_ASSERT_FATAL(addrs_count < 63);
cmd_idx = 0;
acks[cmd_idx] = (struct ble_hs_test_util_phony_ack) {
@@ -838,7 +840,7 @@ ble_hs_test_util_wl_set(struct ble_gap_white_entry *white_list,
};
cmd_idx++;
for (i = 0; i < white_list_count; i++) {
for (i = 0; i < addrs_count; i++) {
acks[cmd_idx] = (struct ble_hs_test_util_phony_ack) {
BLE_HS_TEST_UTIL_LE_OPCODE(BLE_HCI_OCF_LE_ADD_WHITE_LIST),
ble_hs_test_util_exp_hci_status(cmd_idx, fail_idx, fail_status),
@@ -849,7 +851,7 @@ ble_hs_test_util_wl_set(struct ble_gap_white_entry *white_list,
memset(acks + cmd_idx, 0, sizeof acks[cmd_idx]);
ble_hs_test_util_set_ack_seq(acks);
rc = ble_gap_wl_set(white_list, white_list_count);
rc = ble_gap_wl_set(addrs, addrs_count);
return rc;
}
@@ -2101,7 +2103,7 @@ ble_hs_test_util_num_cccds(void)
struct ble_store_key_cccd key = { };
int rc;
key.peer_addr_type = BLE_STORE_ADDR_TYPE_NONE;
key.peer_addr = *BLE_ADDR_ANY;
for (key.idx = 0; ; key.idx++) {
rc = ble_store_read_cccd(&key, &val);
switch (rc) {
@@ -2124,7 +2126,7 @@ ble_hs_test_util_num_our_secs(void)
struct ble_store_key_sec key = { };
int rc;
key.peer_addr_type = BLE_STORE_ADDR_TYPE_NONE;
key.peer_addr = *BLE_ADDR_ANY;
for (key.idx = 0; ; key.idx++) {
rc = ble_store_read_our_sec(&key, &val);
switch (rc) {
@@ -2147,7 +2149,7 @@ ble_hs_test_util_num_peer_secs(void)
struct ble_store_key_sec key = { };
int rc;
key.peer_addr_type = BLE_STORE_ADDR_TYPE_NONE;
key.peer_addr = *BLE_ADDR_ANY;
for (key.idx = 0; ; key.idx++) {
rc = ble_store_read_peer_sec(&key, &val);
switch (rc) {
nimble/host/test/src/ble_hs_test_util.h
+3 -6
View File
@@ -99,8 +99,7 @@ void ble_hs_test_util_create_rpa_conn(uint16_t handle, uint8_t own_addr_type,
void ble_hs_test_util_create_conn(uint16_t handle, const uint8_t *addr,
ble_gap_event_fn *cb, void *cb_arg);
int ble_hs_test_util_connect(uint8_t own_addr_type,
uint8_t peer_addr_type,
const uint8_t *peer_addr,
const ble_addr_t *peer_addr,
int32_t duration_ms,
const struct ble_gap_conn_params *params,
ble_gap_event_fn *cb,
@@ -128,15 +127,13 @@ int ble_hs_test_util_adv_rsp_set_fields(
const struct ble_hs_adv_fields *adv_fields,
int cmd_fail_idx, uint8_t hci_status);
int ble_hs_test_util_adv_start(uint8_t own_addr_type,
uint8_t peer_addr_type,
const uint8_t *peer_addr,
const ble_addr_t *peer_addr,
const struct ble_gap_adv_params *adv_params,
int32_t duration_ms,
ble_gap_event_fn *cb, void *cb_arg,
int fail_idx, uint8_t fail_status);
int ble_hs_test_util_adv_stop(uint8_t hci_status);
int ble_hs_test_util_wl_set(struct ble_gap_white_entry *white_list,
uint8_t white_list_count,
int ble_hs_test_util_wl_set(ble_addr_t *addrs, uint8_t addrs_count,
int fail_idx, uint8_t fail_status);
int ble_hs_test_util_conn_update(uint16_t conn_handle,
struct ble_gap_upd_params *params,
nimble/host/test/src/ble_os_test.c
+14 -15
View File
@@ -113,8 +113,8 @@ ble_gap_direct_connect_test_connect_cb(struct ble_gap_event *event, void *arg)
rc = ble_gap_conn_find(event->connect.conn_handle, &desc);
TEST_ASSERT_FATAL(rc == 0);
TEST_ASSERT(desc.peer_id_addr_type == BLE_ADDR_TYPE_PUBLIC);
TEST_ASSERT(memcmp(desc.peer_id_addr, ble_os_test_peer_addr, 6) == 0);
TEST_ASSERT(desc.peer_id_addr.type == BLE_ADDR_PUBLIC);
TEST_ASSERT(memcmp(desc.peer_id_addr.val, ble_os_test_peer_addr, 6) == 0);
return 0;
}
@@ -123,7 +123,7 @@ static void
ble_gap_direct_connect_test_task_handler(void *arg)
{
struct hci_le_conn_complete evt;
uint8_t addr[6] = { 1, 2, 3, 4, 5, 6 };
ble_addr_t addr = { BLE_ADDR_PUBLIC, { 1, 2, 3, 4, 5, 6 }};
int cb_called;
int rc;
@@ -138,8 +138,7 @@ ble_gap_direct_connect_test_task_handler(void *arg)
TEST_ASSERT(!ble_os_test_misc_conn_exists(BLE_HS_CONN_HANDLE_NONE));
/* Initiate a direct connection. */
ble_hs_test_util_connect(BLE_ADDR_TYPE_PUBLIC, BLE_ADDR_TYPE_PUBLIC,
addr, 0, NULL,
ble_hs_test_util_connect(BLE_OWN_ADDR_PUBLIC, &addr, 0, NULL,
ble_gap_direct_connect_test_connect_cb,
&cb_called, 0);
TEST_ASSERT(!ble_os_test_misc_conn_exists(BLE_HS_CONN_HANDLE_NONE));
@@ -150,7 +149,7 @@ ble_gap_direct_connect_test_task_handler(void *arg)
evt.subevent_code = BLE_HCI_LE_SUBEV_CONN_COMPLETE;
evt.status = BLE_ERR_SUCCESS;
evt.connection_handle = 2;
memcpy(evt.peer_addr, addr, 6);
memcpy(evt.peer_addr, addr.val, 6);
rc = ble_gap_rx_conn_complete(&evt);
TEST_ASSERT(rc == 0);
@@ -214,7 +213,7 @@ ble_os_disc_test_task_handler(void *arg)
/* Initiate the general discovery procedure with a 300 ms timeout. */
memset(&disc_params, 0, sizeof disc_params);
rc = ble_hs_test_util_disc(BLE_ADDR_TYPE_PUBLIC, 300, &disc_params,
rc = ble_hs_test_util_disc(BLE_ADDR_PUBLIC, 300, &disc_params,
ble_os_disc_test_cb,
&cb_called, 0, 0);
TEST_ASSERT(rc == 0);
@@ -281,8 +280,8 @@ ble_gap_terminate_test_task_handler(void *arg)
{
struct hci_disconn_complete disconn_evt;
struct hci_le_conn_complete conn_evt;
uint8_t addr1[6] = { 1, 2, 3, 4, 5, 6 };
uint8_t addr2[6] = { 2, 3, 4, 5, 6, 7 };
ble_addr_t addr1 = { BLE_ADDR_PUBLIC, { 1, 2, 3, 4, 5, 6 }};
ble_addr_t addr2 = { BLE_ADDR_PUBLIC, { 2, 3, 4, 5, 6, 7 }};
int disconn_handle;
int rc;
@@ -303,25 +302,25 @@ ble_gap_terminate_test_task_handler(void *arg)
TEST_ASSERT(!ble_gap_master_in_progress());
/* Create two direct connections. */
ble_hs_test_util_connect(BLE_ADDR_TYPE_PUBLIC, BLE_ADDR_TYPE_PUBLIC,
addr1, 0, NULL, ble_gap_terminate_cb,
ble_hs_test_util_connect(BLE_OWN_ADDR_PUBLIC,
&addr1, 0, NULL, ble_gap_terminate_cb,
&disconn_handle, 0);
memset(&conn_evt, 0, sizeof conn_evt);
conn_evt.subevent_code = BLE_HCI_LE_SUBEV_CONN_COMPLETE;
conn_evt.status = BLE_ERR_SUCCESS;
conn_evt.connection_handle = 1;
memcpy(conn_evt.peer_addr, addr1, 6);
memcpy(conn_evt.peer_addr, addr1.val, 6);
rc = ble_gap_rx_conn_complete(&conn_evt);
TEST_ASSERT(rc == 0);
ble_hs_test_util_connect(BLE_ADDR_TYPE_PUBLIC, BLE_ADDR_TYPE_PUBLIC,
addr2, 0, NULL, ble_gap_terminate_cb,
ble_hs_test_util_connect(BLE_OWN_ADDR_PUBLIC,
&addr2, 0, NULL, ble_gap_terminate_cb,
&disconn_handle, 0);
memset(&conn_evt, 0, sizeof conn_evt);
conn_evt.subevent_code = BLE_HCI_LE_SUBEV_CONN_COMPLETE;
conn_evt.status = BLE_ERR_SUCCESS;
conn_evt.connection_handle = 2;
memcpy(conn_evt.peer_addr, addr2, 6);
memcpy(conn_evt.peer_addr, addr2.val, 6);
rc = ble_gap_rx_conn_complete(&conn_evt);
TEST_ASSERT(rc == 0);
nimble/host/test/src/ble_sm_lgcy_test.c
+2 -2
View File
@@ -319,7 +319,7 @@ TEST_CASE(ble_sm_lgcy_us_jw_iio3_rio3_b1_iat0_rat1_ik7_rk5)
.init_id_addr = {
0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a,
},
.resp_addr_type = BLE_ADDR_TYPE_RANDOM,
.resp_addr_type = BLE_ADDR_RANDOM,
.resp_id_addr = {
0x11, 0x22, 0x11, 0x22, 0x11, 0xcc,
},
@@ -442,7 +442,7 @@ TEST_CASE(ble_sm_lgcy_us_pk_iio4_rio2_b1_iat0_rat1_ik7_rk5)
.init_id_addr = {
0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a,
},
.resp_addr_type = BLE_ADDR_TYPE_RANDOM,
.resp_addr_type = BLE_ADDR_RANDOM,
.resp_id_addr = {
0x11, 0x22, 0x11, 0x22, 0x11, 0xcc,
},
nimble/host/test/src/ble_sm_sc_test.c
+12 -12
View File
@@ -3039,14 +3039,14 @@ TEST_CASE(ble_sm_sc_peer_jw_iio3_rio3_b1_iat2_rat2_ik7_rk7)
struct ble_sm_test_params params;
params = (struct ble_sm_test_params) {
.init_addr_type = BLE_ADDR_TYPE_RPA_PUB_DEFAULT,
.init_addr_type = BLE_OWN_ADDR_RPA_PUBLIC_DEFAULT,
.init_id_addr = {
0x06, 0x05, 0x04, 0x03, 0x02, 0x01,
},
.init_rpa = {
0xd0, 0x8e, 0xf7, 0x42, 0x8c, 0x69,
},
.resp_addr_type = BLE_ADDR_TYPE_RPA_PUB_DEFAULT,
.resp_addr_type = BLE_ADDR_PUBLIC_ID,
.resp_id_addr = {
0x0c, 0x0b, 0x0a, 0x09, 0x08, 0x07,
},
@@ -3201,14 +3201,14 @@ TEST_CASE(ble_sm_sc_peer_nc_iio1_rio1_b1_iat2_rat2_ik3_rk3)
struct ble_sm_test_params params;
params = (struct ble_sm_test_params) {
.init_addr_type = BLE_ADDR_TYPE_RPA_PUB_DEFAULT,
.init_addr_type = BLE_OWN_ADDR_RPA_PUBLIC_DEFAULT,
.init_id_addr = {
0x06, 0x05, 0x04, 0x03, 0x02, 0x01,
},
.init_rpa = {
0xc5, 0xf3, 0x5d, 0x83, 0xcd, 0x4a,
},
.resp_addr_type = BLE_ADDR_TYPE_RPA_PUB_DEFAULT,
.resp_addr_type = BLE_ADDR_PUBLIC_ID,
.resp_id_addr = {
0x0c, 0x0b, 0x0a, 0x09, 0x08, 0x07,
},
@@ -3353,14 +3353,14 @@ TEST_CASE(ble_sm_sc_peer_pk_iio2_rio0_b1_iat2_rat2_ik7_rk3)
struct ble_sm_test_params params;
params = (struct ble_sm_test_params) {
.init_addr_type = BLE_ADDR_TYPE_RPA_PUB_DEFAULT,
.init_addr_type = BLE_OWN_ADDR_RPA_PUBLIC_DEFAULT,
.init_id_addr = {
0x06, 0x05, 0x04, 0x03, 0x02, 0x01,
},
.init_rpa = {
0x6e, 0x56, 0x09, 0xef, 0x1e, 0x76,
},
.resp_addr_type = BLE_ADDR_TYPE_RPA_PUB_DEFAULT,
.resp_addr_type = BLE_ADDR_PUBLIC_ID,
.resp_id_addr = {
0x0c, 0x0b, 0x0a, 0x09, 0x08, 0x07,
},
@@ -3972,14 +3972,14 @@ TEST_CASE(ble_sm_sc_us_jw_iio3_rio3_b1_iat2_rat2_ik3_rk3)
struct ble_sm_test_params params;
params = (struct ble_sm_test_params) {
.init_addr_type = BLE_ADDR_TYPE_RPA_PUB_DEFAULT,
.init_addr_type = BLE_OWN_ADDR_RPA_PUBLIC_DEFAULT,
.init_id_addr = {
0x06, 0x05, 0x04, 0x03, 0x02, 0x01,
},
.init_rpa = {
0x46, 0x85, 0x37, 0x90, 0x86, 0x58,
},
.resp_addr_type = BLE_ADDR_TYPE_RPA_PUB_DEFAULT,
.resp_addr_type = BLE_ADDR_PUBLIC_ID,
.resp_id_addr = {
0x0c, 0x0b, 0x0a, 0x09, 0x08, 0x07,
},
@@ -4122,14 +4122,14 @@ TEST_CASE(ble_sm_sc_us_nc_iio1_rio1_b1_iat2_rat2_ik3_rk3)
struct ble_sm_test_params params;
params = (struct ble_sm_test_params) {
.init_addr_type = BLE_ADDR_TYPE_RPA_PUB_DEFAULT,
.init_addr_type = BLE_OWN_ADDR_RPA_PUBLIC_DEFAULT,
.init_id_addr = {
0x06, 0x05, 0x04, 0x03, 0x02, 0x01,
},
.init_rpa = {
0xc5, 0xf3, 0x5d, 0x83, 0xcd, 0x4a,
},
.resp_addr_type = BLE_ADDR_TYPE_RPA_PUB_DEFAULT,
.resp_addr_type = BLE_ADDR_PUBLIC_ID,
.resp_id_addr = {
0x0c, 0x0b, 0x0a, 0x09, 0x08, 0x07,
},
@@ -4274,14 +4274,14 @@ TEST_CASE(ble_sm_sc_us_pk_iio2_rio0_b1_iat2_rat2_ik7_rk3)
struct ble_sm_test_params params;
params = (struct ble_sm_test_params) {
.init_addr_type = BLE_ADDR_TYPE_RPA_PUB_DEFAULT,
.init_addr_type = BLE_OWN_ADDR_RPA_PUBLIC_DEFAULT,
.init_id_addr = {
0x06, 0x05, 0x04, 0x03, 0x02, 0x01,
},
.init_rpa = {
0x6e, 0x56, 0x09, 0xef, 0x1e, 0x76,
},
.resp_addr_type = BLE_ADDR_TYPE_RPA_PUB_DEFAULT,
.resp_addr_type = BLE_ADDR_PUBLIC_ID,
.resp_id_addr = {
0x0c, 0x0b, 0x0a, 0x09, 0x08, 0x07,
},
nimble/host/test/src/ble_sm_test_util.c
+6 -6
View File
@@ -1384,7 +1384,7 @@ ble_sm_test_util_verify_persist(struct ble_sm_test_params *params,
params->pair_rsp.authreq & BLE_SM_PAIR_AUTHREQ_BOND;
memset(&key_sec, 0, sizeof key_sec);
key_sec.peer_addr_type = BLE_STORE_ADDR_TYPE_NONE;
key_sec.peer_addr = *BLE_ADDR_ANY;
rc = ble_store_read_peer_sec(&key_sec, &value_sec);
if (!bonding) {
@@ -1400,8 +1400,8 @@ ble_sm_test_util_verify_persist(struct ble_sm_test_params *params,
csrk_expected =
!!(peer_entity.key_dist & BLE_SM_PAIR_KEY_DIST_SIGN);
TEST_ASSERT(value_sec.peer_addr_type == peer_entity.id_addr_type);
TEST_ASSERT(memcmp(value_sec.peer_addr, peer_entity.id_addr, 6) == 0);
TEST_ASSERT(value_sec.peer_addr.type == peer_entity.id_addr_type);
TEST_ASSERT(memcmp(value_sec.peer_addr.val, peer_entity.id_addr, 6) == 0);
TEST_ASSERT(value_sec.ediv == peer_entity.ediv);
TEST_ASSERT(value_sec.rand_num == peer_entity.rand_num);
TEST_ASSERT(value_sec.authenticated == params->authenticated);
@@ -1435,8 +1435,8 @@ ble_sm_test_util_verify_persist(struct ble_sm_test_params *params,
csrk_expected =
!!(our_entity.key_dist & BLE_SM_PAIR_KEY_DIST_SIGN);
TEST_ASSERT(value_sec.peer_addr_type == peer_entity.id_addr_type);
TEST_ASSERT(memcmp(value_sec.peer_addr, peer_entity.id_addr, 6) == 0);
TEST_ASSERT(value_sec.peer_addr.type == peer_entity.id_addr_type);
TEST_ASSERT(memcmp(value_sec.peer_addr.val, peer_entity.id_addr, 6) == 0);
TEST_ASSERT(value_sec.ediv == our_entity.ediv);
TEST_ASSERT(value_sec.rand_num == our_entity.rand_num);
TEST_ASSERT(value_sec.authenticated == params->authenticated);
@@ -1515,7 +1515,7 @@ ble_sm_test_util_peer_bonding_good(int send_enc_req,
/* Ensure the LTK request event got sent to the application. */
TEST_ASSERT(ble_sm_test_store_obj_type == BLE_STORE_OBJ_TYPE_OUR_SEC);
TEST_ASSERT(ble_sm_test_store_key.sec.peer_addr_type ==
TEST_ASSERT(ble_sm_test_store_key.sec.peer_addr.type ==
ble_hs_misc_addr_type_to_id(peer_addr_type));
TEST_ASSERT(ble_sm_test_store_key.sec.ediv_rand_present);
TEST_ASSERT(ble_sm_test_store_key.sec.ediv == ediv);
nimble/include/nimble/ble.h
+34 -6
View File
@@ -21,6 +21,8 @@
#define H_BLE_
#include <inttypes.h>
#include <string.h>
#ifdef __cplusplus
extern "C" {
#endif
@@ -195,18 +197,44 @@ enum ble_error_codes
BLE_ERR_MAX = 255
};
/* Address types */
#define BLE_ADDR_TYPE_PUBLIC (0)
#define BLE_ADDR_TYPE_RANDOM (1)
#define BLE_ADDR_TYPE_RPA_PUB_DEFAULT (2)
#define BLE_ADDR_TYPE_RPA_RND_DEFAULT (3)
int ble_err_from_os(int os_err);
/* HW error codes */
#define BLE_HW_ERR_DO_NOT_USE (0) /* XXX: reserve this one for now */
#define BLE_HW_ERR_HCI_SYNC_LOSS (1)
/* Own Bluetooth Device address type */
#define BLE_OWN_ADDR_PUBLIC (0x00)
#define BLE_OWN_ADDR_RANDOM (0x01)
#define BLE_OWN_ADDR_RPA_PUBLIC_DEFAULT (0x02)
#define BLE_OWN_ADDR_RPA_RANDOM_DEFAULT (0x03)
/* Bluetooth Device address type */
#define BLE_ADDR_PUBLIC (0x00)
#define BLE_ADDR_RANDOM (0x01)
#define BLE_ADDR_PUBLIC_ID (0x02)
#define BLE_ADDR_RANDOM_ID (0x03)
#define BLE_ADDR_ANY (&(ble_addr_t) { 0, {0, 0, 0, 0, 0, 0} })
#define BLE_ADDR_IS_RPA(addr) (((addr)->type == BLE_ADDR_RANDOM) && \
((addr)->val[5] & 0xc0) == 0x40)
#define BLE_ADDR_IS_NRPA(addr) (((addr)->type == BLE_ADDR_RANDOM) && \
(((addr)->val[5] & 0xc0) == 0x00)
#define BLE_ADDR_IS_STATIC(addr) (((addr)->type == BLE_ADDR_RANDOM) && \
(((addr)->val[5] & 0xc0) == 0xc0)
typedef struct {
uint8_t type;
uint8_t val[6];
} ble_addr_t;
static inline int ble_addr_cmp(const ble_addr_t *a, const ble_addr_t *b)
{
return memcmp(a, b, sizeof(*a));
}
#ifdef __cplusplus
}
#endif