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
