You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mynewt.apache.org by cc...@apache.org on 2017/02/01 22:12:36 UTC
[3/8] incubator-mynewt-core git commit: nimble/host: Add generic type
for BD address
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/net/nimble/host/src/ble_sm_sc.c
----------------------------------------------------------------------
diff --git a/net/nimble/host/src/ble_sm_sc.c b/net/nimble/host/src/ble_sm_sc.c
index 971d2fb..f78b049 100644
--- a/net/nimble/host/src/ble_sm_sc.c
+++ b/net/nimble/host/src/ble_sm_sc.c
@@ -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;
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/net/nimble/host/src/ble_store.c
----------------------------------------------------------------------
diff --git a/net/nimble/host/src/ble_store.c b/net/nimble/host/src/ble_store.c
index d042722..e70a5bd 100644
--- a/net/nimble/host/src/ble_store.c
+++ b/net/nimble/host/src/ble_store.c
@@ -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;
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/net/nimble/host/store/ram/src/ble_store_ram.c
----------------------------------------------------------------------
diff --git a/net/nimble/host/store/ram/src/ble_store_ram.c b/net/nimble/host/store/ram/src/ble_store_ram.c
index 65a76cc..4e018a9 100644
--- a/net/nimble/host/store/ram/src/ble_store_ram.c
+++ b/net/nimble/host/store/ram/src/ble_store_ram.c
@@ -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;
}
}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/net/nimble/host/test/src/ble_gap_test.c
----------------------------------------------------------------------
diff --git a/net/nimble/host/test/src/ble_gap_test.c b/net/nimble/host/test/src/ble_gap_test.c
index 38536ea..0a047d6 100644
--- a/net/nimble/host/test/src/ble_gap_test.c
+++ b/net/nimble/host/test/src/ble_gap_test.c
@@ -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,
¶m_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, ¶ms,
+ rc = ble_gap_disc(BLE_ADDR_PUBLIC, 0, ¶ms,
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(¶ms, 0, sizeof params);
params.limited = limited;
- rc = ble_hs_test_util_disc(BLE_ADDR_TYPE_PUBLIC, 0, ¶ms,
+ rc = ble_hs_test_util_disc(BLE_OWN_ADDR_PUBLIC, 0, ¶ms,
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, ¶ms,
+ rc = ble_hs_test_util_connect(BLE_OWN_ADDR_PUBLIC,
+ &peer_addr, 0, ¶ms,
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(¶ms, 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, ¶ms, ble_gap_test_util_disc_cb,
NULL, -1, 0);
@@ -2690,7 +2680,7 @@ ble_gap_test_util_disc_timeout(int32_t duration_ms)
memset(¶ms, 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, ¶ms, ble_gap_test_util_disc_cb,
NULL, -1, 0);
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/net/nimble/host/test/src/ble_gatts_notify_test.c
----------------------------------------------------------------------
diff --git a/net/nimble/host/test/src/ble_gatts_notify_test.c b/net/nimble/host/test/src/ble_gatts_notify_test.c
index 995520b..357d250 100644
--- a/net/nimble/host/test/src/ble_gatts_notify_test.c
+++ b/net/nimble/host/test/src/ble_gatts_notify_test.c
@@ -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;
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/net/nimble/host/test/src/ble_hs_adv_test.c
----------------------------------------------------------------------
diff --git a/net/nimble/host/test/src/ble_hs_adv_test.c b/net/nimble/host/test/src/ble_hs_adv_test.c
index 526fa74..2f92260 100644
--- a/net/nimble/host/test/src/ble_hs_adv_test.c
+++ b/net/nimble/host/test/src/ble_hs_adv_test.c
@@ -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);
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/net/nimble/host/test/src/ble_hs_conn_test.c
----------------------------------------------------------------------
diff --git a/net/nimble/host/test/src/ble_hs_conn_test.c b/net/nimble/host/test/src/ble_hs_conn_test.c
index 5563dde..93e2f14 100644
--- a/net/nimble/host/test/src/ble_hs_conn_test.c
+++ b/net/nimble/host/test/src/ble_hs_conn_test.c
@@ -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);
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/net/nimble/host/test/src/ble_hs_test_util.c
----------------------------------------------------------------------
diff --git a/net/nimble/host/test/src/ble_hs_test_util.c b/net/nimble/host/test/src/ble_hs_test_util.c
index 2e8ecbc..687920e 100644
--- a/net/nimble/host/test/src/ble_hs_test_util.c
+++ b/net/nimble/host/test/src/ble_hs_test_util.c
@@ -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) {
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/net/nimble/host/test/src/ble_hs_test_util.h
----------------------------------------------------------------------
diff --git a/net/nimble/host/test/src/ble_hs_test_util.h b/net/nimble/host/test/src/ble_hs_test_util.h
index 041bb4d..57de72f 100644
--- a/net/nimble/host/test/src/ble_hs_test_util.h
+++ b/net/nimble/host/test/src/ble_hs_test_util.h
@@ -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,
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/net/nimble/host/test/src/ble_os_test.c
----------------------------------------------------------------------
diff --git a/net/nimble/host/test/src/ble_os_test.c b/net/nimble/host/test/src/ble_os_test.c
index 7830242..4dda7e7 100644
--- a/net/nimble/host/test/src/ble_os_test.c
+++ b/net/nimble/host/test/src/ble_os_test.c
@@ -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);
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/net/nimble/host/test/src/ble_sm_lgcy_test.c
----------------------------------------------------------------------
diff --git a/net/nimble/host/test/src/ble_sm_lgcy_test.c b/net/nimble/host/test/src/ble_sm_lgcy_test.c
index 5ca2d7b..52c5761 100644
--- a/net/nimble/host/test/src/ble_sm_lgcy_test.c
+++ b/net/nimble/host/test/src/ble_sm_lgcy_test.c
@@ -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,
},
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/net/nimble/host/test/src/ble_sm_sc_test.c
----------------------------------------------------------------------
diff --git a/net/nimble/host/test/src/ble_sm_sc_test.c b/net/nimble/host/test/src/ble_sm_sc_test.c
index d75f2ee..21fc4c7 100644
--- a/net/nimble/host/test/src/ble_sm_sc_test.c
+++ b/net/nimble/host/test/src/ble_sm_sc_test.c
@@ -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,
},
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/net/nimble/host/test/src/ble_sm_test_util.c
----------------------------------------------------------------------
diff --git a/net/nimble/host/test/src/ble_sm_test_util.c b/net/nimble/host/test/src/ble_sm_test_util.c
index 682de2b..8dff6fb 100644
--- a/net/nimble/host/test/src/ble_sm_test_util.c
+++ b/net/nimble/host/test/src/ble_sm_test_util.c
@@ -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);
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/net/nimble/include/nimble/ble.h
----------------------------------------------------------------------
diff --git a/net/nimble/include/nimble/ble.h b/net/nimble/include/nimble/ble.h
index c6c38ca..b514131 100644
--- a/net/nimble/include/nimble/ble.h
+++ b/net/nimble/include/nimble/ble.h
@@ -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