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:37 UTC
[4/8] incubator-mynewt-core git commit: nimble/host: Add generic type
for BD address
nimble/host: Add generic type for BD address
This patch introduces ble_addr_t (with additional helpers/symbols) type
to pass complete device address via API instead of separate type and
address value.
Note that it only makes sure public APIs use new type. Both apps and
host internals may still use type/addr combination in many places, but
this can be changed later without affecting backwards compatibility.
Project: http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/commit/6d0e7fb8
Tree: http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/tree/6d0e7fb8
Diff: http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/diff/6d0e7fb8
Branch: refs/heads/develop
Commit: 6d0e7fb8aef7f767949b767478c88df0ce0f7cdb
Parents: 0b59cb3
Author: Andrzej Kaczmarek <an...@codecoup.pl>
Authored: Tue Jan 31 15:04:18 2017 +0100
Committer: Andrzej Kaczmarek <an...@codecoup.pl>
Committed: Wed Feb 1 22:24:57 2017 +0100
----------------------------------------------------------------------
apps/blecent/src/main.c | 9 +-
apps/blecent/src/misc.c | 10 +-
apps/bleprph/src/bleprph.h | 1 +
apps/bleprph/src/main.c | 18 +-
apps/bleprph_oic/src/main.c | 18 +-
apps/bletiny/src/bletiny.h | 12 +-
apps/bletiny/src/cmd.c | 231 ++++++-------
apps/bletiny/src/main.c | 29 +-
apps/bletiny/src/misc.c | 16 +-
apps/bleuart/src/main.c | 2 +-
hw/drivers/nimble/nrf52/src/ble_hw.c | 4 +-
net/nimble/controller/src/ble_ll_adv.c | 8 +-
net/nimble/controller/src/ble_ll_scan.c | 4 +-
net/nimble/host/include/host/ble_gap.h | 40 +--
net/nimble/host/include/host/ble_hs_id.h | 3 +-
net/nimble/host/include/host/ble_store.h | 23 +-
net/nimble/host/src/ble_att_svr.c | 3 +-
net/nimble/host/src/ble_gap.c | 184 +++++------
net/nimble/host/src/ble_gatts.c | 16 +-
net/nimble/host/src/ble_hs_conn.c | 39 +--
net/nimble/host/src/ble_hs_conn_priv.h | 22 +-
net/nimble/host/src/ble_hs_hci_cmd.c | 10 +-
net/nimble/host/src/ble_hs_hci_evt.c | 16 +-
net/nimble/host/src/ble_hs_id.c | 30 +-
net/nimble/host/src/ble_hs_misc.c | 14 +-
net/nimble/host/src/ble_sm.c | 54 ++-
net/nimble/host/src/ble_sm_sc.c | 45 +--
net/nimble/host/src/ble_store.c | 31 +-
net/nimble/host/store/ram/src/ble_store_ram.c | 23 +-
net/nimble/host/test/src/ble_gap_test.c | 326 +++++++++----------
.../host/test/src/ble_gatts_notify_test.c | 2 +-
net/nimble/host/test/src/ble_hs_adv_test.c | 4 +-
net/nimble/host/test/src/ble_hs_conn_test.c | 32 +-
net/nimble/host/test/src/ble_hs_test_util.c | 58 ++--
net/nimble/host/test/src/ble_hs_test_util.h | 9 +-
net/nimble/host/test/src/ble_os_test.c | 29 +-
net/nimble/host/test/src/ble_sm_lgcy_test.c | 4 +-
net/nimble/host/test/src/ble_sm_sc_test.c | 24 +-
net/nimble/host/test/src/ble_sm_test_util.c | 12 +-
net/nimble/include/nimble/ble.h | 40 ++-
40 files changed, 666 insertions(+), 789 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/apps/blecent/src/main.c
----------------------------------------------------------------------
diff --git a/apps/blecent/src/main.c b/apps/blecent/src/main.c
index 28fadf8..18f7045 100755
--- a/apps/blecent/src/main.c
+++ b/apps/blecent/src/main.c
@@ -243,7 +243,7 @@ blecent_scan(void)
disc_params.filter_policy = 0;
disc_params.limited = 0;
- 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,
blecent_gap_event, NULL);
if (rc != 0) {
BLECENT_LOG(ERROR, "Error initiating GAP discovery procedure; rc=%d\n",
@@ -312,11 +312,12 @@ blecent_connect_if_interesting(const struct ble_gap_disc_desc *disc)
/* Try to connect the the advertiser. Allow 30 seconds (30000 ms) for
* timeout.
*/
- rc = ble_gap_connect(BLE_ADDR_TYPE_PUBLIC, disc->addr_type, disc->addr,
- 30000, NULL, blecent_gap_event, NULL);
+ rc = ble_gap_connect(BLE_ADDR_PUBLIC, &disc->addr, 30000, NULL,
+ blecent_gap_event, NULL);
if (rc != 0) {
BLECENT_LOG(ERROR, "Error: Failed to connect to device; addr_type=%d "
- "addr=%s\n", disc->addr_type, addr_str(disc->addr));
+ "addr=%s\n", disc->addr.type,
+ addr_str(disc->addr.val));
return;
}
}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/apps/blecent/src/misc.c
----------------------------------------------------------------------
diff --git a/apps/blecent/src/misc.c b/apps/blecent/src/misc.c
index 11360e5..eb4af0c 100644
--- a/apps/blecent/src/misc.c
+++ b/apps/blecent/src/misc.c
@@ -82,14 +82,14 @@ void
print_conn_desc(const struct ble_gap_conn_desc *desc)
{
BLECENT_LOG(DEBUG, "handle=%d our_ota_addr_type=%d our_ota_addr=%s ",
- desc->conn_handle, desc->our_ota_addr_type,
- addr_str(desc->our_ota_addr));
+ desc->conn_handle, desc->our_ota_addr.type,
+ addr_str(desc->our_ota_addr.val));
BLECENT_LOG(DEBUG, "our_id_addr_type=%d our_id_addr=%s ",
- desc->our_id_addr_type, addr_str(desc->our_id_addr));
+ desc->our_id_addr.type, addr_str(desc->our_id_addr.val));
BLECENT_LOG(DEBUG, "peer_ota_addr_type=%d peer_ota_addr=%s ",
- desc->peer_ota_addr_type, addr_str(desc->peer_ota_addr));
+ desc->peer_ota_addr.type, addr_str(desc->peer_ota_addr.val));
BLECENT_LOG(DEBUG, "peer_id_addr_type=%d peer_id_addr=%s ",
- desc->peer_id_addr_type, addr_str(desc->peer_id_addr));
+ desc->peer_id_addr.type, addr_str(desc->peer_id_addr.val));
BLECENT_LOG(DEBUG, "conn_itvl=%d conn_latency=%d supervision_timeout=%d "
"encrypted=%d authenticated=%d bonded=%d",
desc->conn_itvl, desc->conn_latency,
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/apps/bleprph/src/bleprph.h
----------------------------------------------------------------------
diff --git a/apps/bleprph/src/bleprph.h b/apps/bleprph/src/bleprph.h
index 2e3f024..afcbb72 100644
--- a/apps/bleprph/src/bleprph.h
+++ b/apps/bleprph/src/bleprph.h
@@ -21,6 +21,7 @@
#define H_BLEPRPH_
#include "log/log.h"
+#include "nimble/ble.h"
#ifdef __cplusplus
extern "C" {
#endif
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/apps/bleprph/src/main.c
----------------------------------------------------------------------
diff --git a/apps/bleprph/src/main.c b/apps/bleprph/src/main.c
index 62da56a..3bdbbcd 100755
--- a/apps/bleprph/src/main.c
+++ b/apps/bleprph/src/main.c
@@ -51,17 +51,17 @@ static void
bleprph_print_conn_desc(struct ble_gap_conn_desc *desc)
{
BLEPRPH_LOG(INFO, "handle=%d our_ota_addr_type=%d our_ota_addr=",
- desc->conn_handle, desc->our_ota_addr_type);
- print_addr(desc->our_ota_addr);
+ desc->conn_handle, desc->our_ota_addr.type);
+ print_addr(desc->our_ota_addr.val);
BLEPRPH_LOG(INFO, " our_id_addr_type=%d our_id_addr=",
- desc->our_id_addr_type);
- print_addr(desc->our_id_addr);
+ desc->our_id_addr.type);
+ print_addr(desc->our_id_addr.val);
BLEPRPH_LOG(INFO, " peer_ota_addr_type=%d peer_ota_addr=",
- desc->peer_ota_addr_type);
- print_addr(desc->peer_ota_addr);
+ desc->peer_ota_addr.type);
+ print_addr(desc->peer_ota_addr.val);
BLEPRPH_LOG(INFO, " peer_id_addr_type=%d peer_id_addr=",
- desc->peer_id_addr_type);
- print_addr(desc->peer_id_addr);
+ desc->peer_id_addr.type);
+ print_addr(desc->peer_id_addr.val);
BLEPRPH_LOG(INFO, " conn_itvl=%d conn_latency=%d supervision_timeout=%d "
"encrypted=%d authenticated=%d bonded=%d\n",
desc->conn_itvl, desc->conn_latency,
@@ -129,7 +129,7 @@ bleprph_advertise(void)
memset(&adv_params, 0, sizeof adv_params);
adv_params.conn_mode = BLE_GAP_CONN_MODE_UND;
adv_params.disc_mode = BLE_GAP_DISC_MODE_GEN;
- rc = ble_gap_adv_start(BLE_ADDR_TYPE_PUBLIC, 0, NULL, BLE_HS_FOREVER,
+ rc = ble_gap_adv_start(BLE_OWN_ADDR_PUBLIC, NULL, BLE_HS_FOREVER,
&adv_params, bleprph_gap_event, NULL);
if (rc != 0) {
BLEPRPH_LOG(ERROR, "error enabling advertisement; rc=%d\n", rc);
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/apps/bleprph_oic/src/main.c
----------------------------------------------------------------------
diff --git a/apps/bleprph_oic/src/main.c b/apps/bleprph_oic/src/main.c
index e25f182..8a01a14 100755
--- a/apps/bleprph_oic/src/main.c
+++ b/apps/bleprph_oic/src/main.c
@@ -55,17 +55,17 @@ static void
bleprph_print_conn_desc(struct ble_gap_conn_desc *desc)
{
BLEPRPH_LOG(INFO, "handle=%d our_ota_addr_type=%d our_ota_addr=",
- desc->conn_handle, desc->our_ota_addr_type);
- print_addr(desc->our_ota_addr);
+ desc->conn_handle, desc->our_ota_addr.type);
+ print_addr(desc->our_ota_addr.val);
BLEPRPH_LOG(INFO, " our_id_addr_type=%d our_id_addr=",
- desc->our_id_addr_type);
- print_addr(desc->our_id_addr);
+ desc->our_id_addr.type);
+ print_addr(desc->our_id_addr.val);
BLEPRPH_LOG(INFO, " peer_ota_addr_type=%d peer_ota_addr=",
- desc->peer_ota_addr_type);
- print_addr(desc->peer_ota_addr);
+ desc->peer_ota_addr.type);
+ print_addr(desc->peer_ota_addr.val);
BLEPRPH_LOG(INFO, " peer_id_addr_type=%d peer_id_addr=",
- desc->peer_id_addr_type);
- print_addr(desc->peer_id_addr);
+ desc->peer_id_addr.type);
+ print_addr(desc->peer_id_addr.val);
BLEPRPH_LOG(INFO, " conn_itvl=%d conn_latency=%d supervision_timeout=%d "
"encrypted=%d authenticated=%d bonded=%d\n",
desc->conn_itvl, desc->conn_latency,
@@ -133,7 +133,7 @@ bleprph_advertise(void)
memset(&adv_params, 0, sizeof adv_params);
adv_params.conn_mode = BLE_GAP_CONN_MODE_UND;
adv_params.disc_mode = BLE_GAP_DISC_MODE_GEN;
- rc = ble_gap_adv_start(BLE_ADDR_TYPE_PUBLIC, 0, NULL, BLE_HS_FOREVER,
+ rc = ble_gap_adv_start(BLE_ADDR_PUBLIC, NULL, BLE_HS_FOREVER,
&adv_params, bleprph_gap_event, NULL);
if (rc != 0) {
BLEPRPH_LOG(ERROR, "error enabling advertisement; rc=%d\n", rc);
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/apps/bletiny/src/bletiny.h
----------------------------------------------------------------------
diff --git a/apps/bletiny/src/bletiny.h b/apps/bletiny/src/bletiny.h
index 8cf6832..2ab696a 100644
--- a/apps/bletiny/src/bletiny.h
+++ b/apps/bletiny/src/bletiny.h
@@ -21,6 +21,7 @@
#define H_BLETINY_PRIV_
#include <inttypes.h>
+#include "nimble/ble.h"
#include "nimble/nimble_opt.h"
#include "log/log.h"
#include "os/queue.h"
@@ -153,17 +154,16 @@ int bletiny_write_long(uint16_t conn_handle, uint16_t attr_handle,
uint16_t offset, struct os_mbuf *om);
int bletiny_write_reliable(uint16_t conn_handle,
struct ble_gatt_attr *attrs, int num_attrs);
-int bletiny_adv_start(uint8_t own_addr_type, uint8_t peer_addr_type,
- const uint8_t *peer_addr, int32_t duration_ms,
+int bletiny_adv_start(uint8_t own_addr_type, const ble_addr_t *direct_addr,
+ int32_t duration_ms,
const struct ble_gap_adv_params *params);
int bletiny_adv_stop(void);
-int bletiny_conn_initiate(uint8_t own_addr_type, uint8_t peer_addr_type,
- uint8_t *peer_addr, int32_t duration_ms,
+int bletiny_conn_initiate(uint8_t own_addr_type, const ble_addr_t *peer_addr,
+ int32_t duration_ms,
struct ble_gap_conn_params *params);
int bletiny_conn_cancel(void);
int bletiny_term_conn(uint16_t conn_handle, uint8_t reason);
-int bletiny_wl_set(struct ble_gap_white_entry *white_list,
- int white_list_count);
+int bletiny_wl_set(ble_addr_t *addrs, int addrs_count);
int bletiny_scan(uint8_t own_addr_type, int32_t duration_ms,
const struct ble_gap_disc_params *disc_params);
int bletiny_scan_cancel(void);
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/apps/bletiny/src/cmd.c
----------------------------------------------------------------------
diff --git a/apps/bletiny/src/cmd.c b/apps/bletiny/src/cmd.c
index 3019bb3..c5f4a55 100644
--- a/apps/bletiny/src/cmd.c
+++ b/apps/bletiny/src/cmd.c
@@ -47,6 +47,28 @@ static struct shell_cmd cmd_b = {
static bssnz_t uint8_t cmd_buf[CMD_BUF_SZ];
+static struct kv_pair cmd_own_addr_types[] = {
+ { "public", BLE_OWN_ADDR_PUBLIC },
+ { "random", BLE_OWN_ADDR_RANDOM },
+ { "rpa_pub", BLE_OWN_ADDR_RPA_PUBLIC_DEFAULT },
+ { "rpa_rnd", BLE_OWN_ADDR_RPA_RANDOM_DEFAULT },
+ { NULL }
+};
+
+static struct kv_pair cmd_peer_addr_types[] = {
+ { "public", BLE_ADDR_PUBLIC },
+ { "random", BLE_ADDR_RANDOM },
+ { "public_id", BLE_ADDR_PUBLIC_ID },
+ { "random_id", BLE_ADDR_RANDOM_ID },
+ { NULL }
+};
+
+static struct kv_pair cmd_addr_type[] = {
+ { "public", BLE_ADDR_PUBLIC },
+ { "random", BLE_ADDR_RANDOM },
+ { NULL }
+};
+
/*****************************************************************************
* $misc *
*****************************************************************************/
@@ -244,14 +266,6 @@ static struct kv_pair cmd_adv_disc_modes[] = {
{ NULL }
};
-static struct kv_pair cmd_adv_addr_types[] = {
- { "public", BLE_ADDR_TYPE_PUBLIC },
- { "random", BLE_ADDR_TYPE_RANDOM },
- { "rpa_pub", BLE_ADDR_TYPE_RPA_PUB_DEFAULT },
- { "rpa_rnd", BLE_ADDR_TYPE_RPA_RND_DEFAULT },
- { NULL }
-};
-
static struct kv_pair cmd_adv_filt_types[] = {
{ "none", BLE_HCI_ADV_FILT_NONE },
{ "scan", BLE_HCI_ADV_FILT_SCAN },
@@ -399,11 +413,10 @@ bletiny_adv_help(void)
console_printf("Available adv params: \n");
help_cmd_kv_dflt("conn", cmd_adv_conn_modes, BLE_GAP_CONN_MODE_UND);
help_cmd_kv_dflt("disc", cmd_adv_disc_modes, BLE_GAP_DISC_MODE_GEN);
- help_cmd_kv_dflt("peer_addr_type", cmd_adv_addr_types,
- BLE_ADDR_TYPE_PUBLIC);
+ help_cmd_kv_dflt("peer_addr_type", cmd_peer_addr_types, BLE_ADDR_PUBLIC);
help_cmd_byte_stream_exact_length("peer_addr", 6);
- help_cmd_kv_dflt("own_addr_type", cmd_adv_addr_types,
- BLE_ADDR_TYPE_PUBLIC);
+ help_cmd_kv_dflt("own_addr_type", cmd_own_addr_types,
+ BLE_OWN_ADDR_PUBLIC);
help_cmd_long_bounds_dflt("chan_map", 0, 0xff, 0);
help_cmd_kv_dflt("filt", cmd_adv_filt_types, BLE_HCI_ADV_FILT_NONE);
help_cmd_long_bounds_dflt("itvl_min", 0, UINT16_MAX, 0);
@@ -417,9 +430,9 @@ cmd_adv(int argc, char **argv)
{
struct ble_gap_adv_params params;
int32_t duration_ms;
- uint8_t peer_addr_type;
+ ble_addr_t peer_addr;
+ ble_addr_t *peer_addr_param = &peer_addr;
uint8_t own_addr_type;
- uint8_t peer_addr[8];
int rc;
if (argc > 1 && strcmp(argv[1], "help") == 0) {
@@ -453,18 +466,18 @@ cmd_adv(int argc, char **argv)
return rc;
}
- peer_addr_type = parse_arg_kv_default(
- "peer_addr_type", cmd_adv_addr_types, BLE_ADDR_TYPE_PUBLIC, &rc);
+ peer_addr.type = parse_arg_kv_default(
+ "peer_addr_type", cmd_peer_addr_types, BLE_ADDR_PUBLIC, &rc);
if (rc != 0) {
console_printf("invalid 'peer_addr_type' parameter\n");
- help_cmd_kv_dflt("peer_addr_type", cmd_adv_addr_types,
- BLE_ADDR_TYPE_PUBLIC);
+ help_cmd_kv_dflt("peer_addr_type", cmd_peer_addr_types,
+ BLE_ADDR_PUBLIC);
return rc;
}
- rc = parse_arg_mac("peer_addr", peer_addr);
+ rc = parse_arg_mac("peer_addr", peer_addr.val);
if (rc == ENOENT) {
- memset(peer_addr, 0, sizeof peer_addr);
+ peer_addr_param = NULL;
} else if (rc != 0) {
console_printf("invalid 'peer_addr' parameter\n");
help_cmd_byte_stream_exact_length("peer_addr", 6);
@@ -472,11 +485,11 @@ cmd_adv(int argc, char **argv)
}
own_addr_type = parse_arg_kv_default(
- "own_addr_type", cmd_adv_addr_types, BLE_ADDR_TYPE_PUBLIC, &rc);
+ "own_addr_type", cmd_own_addr_types, BLE_OWN_ADDR_PUBLIC, &rc);
if (rc != 0) {
console_printf("invalid 'own_addr_type' parameter\n");
- help_cmd_kv_dflt("own_addr_type", cmd_adv_addr_types,
- BLE_ADDR_TYPE_PUBLIC);
+ help_cmd_kv_dflt("own_addr_type", cmd_own_addr_types,
+ BLE_OWN_ADDR_PUBLIC);
return rc;
}
@@ -527,8 +540,8 @@ cmd_adv(int argc, char **argv)
return rc;
}
- rc = bletiny_adv_start(own_addr_type, peer_addr_type, peer_addr,
- duration_ms, ¶ms);
+ rc = bletiny_adv_start(own_addr_type, peer_addr_param, duration_ms,
+ ¶ms);
if (rc != 0) {
console_printf("advertise fail: %d\n", rc);
return rc;
@@ -541,23 +554,6 @@ cmd_adv(int argc, char **argv)
* $connect *
*****************************************************************************/
-static struct kv_pair cmd_conn_peer_addr_types[] = {
- { "public", BLE_HCI_CONN_PEER_ADDR_PUBLIC },
- { "random", BLE_HCI_CONN_PEER_ADDR_RANDOM },
- { "rpa_pub", BLE_HCI_CONN_PEER_ADDR_PUBLIC_IDENT },
- { "rpa_rnd", BLE_HCI_CONN_PEER_ADDR_RANDOM_IDENT },
- { "wl", BLE_GAP_ADDR_TYPE_WL },
- { NULL }
-};
-
-static struct kv_pair cmd_conn_own_addr_types[] = {
- { "public", BLE_ADDR_TYPE_PUBLIC },
- { "random", BLE_ADDR_TYPE_RANDOM },
- { "rpa_pub", BLE_ADDR_TYPE_RPA_PUB_DEFAULT },
- { "rpa_rnd", BLE_ADDR_TYPE_RPA_RND_DEFAULT },
- { NULL }
-};
-
static void
bletiny_conn_help(void)
{
@@ -565,11 +561,10 @@ bletiny_conn_help(void)
console_printf("\thelp\n");
console_printf("\tcancel\n");
console_printf("Available conn params: \n");
- help_cmd_kv_dflt("peer_addr_type", cmd_conn_peer_addr_types,
- BLE_ADDR_TYPE_PUBLIC);
+ help_cmd_kv_dflt("peer_addr_type", cmd_peer_addr_types, BLE_ADDR_PUBLIC);
help_cmd_byte_stream_exact_length("peer_addr", 6);
- help_cmd_kv_dflt("own_addr_type", cmd_conn_own_addr_types,
- BLE_ADDR_TYPE_PUBLIC);
+ help_cmd_kv_dflt("own_addr_type", cmd_own_addr_types,
+ BLE_OWN_ADDR_PUBLIC);
help_cmd_uint16_dflt("scan_itvl", 0x0010);
help_cmd_uint16_dflt("scan_window", 0x0010);
help_cmd_uint16_dflt("itvl_min", BLE_GAP_INITIAL_CONN_ITVL_MIN);
@@ -586,8 +581,8 @@ cmd_conn(int argc, char **argv)
{
struct ble_gap_conn_params params;
int32_t duration_ms;
- uint8_t peer_addr[6];
- int peer_addr_type;
+ ble_addr_t peer_addr;
+ ble_addr_t *peer_addr_param = &peer_addr;
int own_addr_type;
int rc;
@@ -606,39 +601,36 @@ cmd_conn(int argc, char **argv)
return 0;
}
- peer_addr_type = parse_arg_kv_default("peer_addr_type",
- cmd_conn_peer_addr_types,
- BLE_ADDR_TYPE_PUBLIC, &rc);
+ peer_addr.type = parse_arg_kv_default("peer_addr_type", cmd_peer_addr_types,
+ BLE_ADDR_PUBLIC, &rc);
if (rc != 0) {
console_printf("invalid 'peer_addr_type' parameter\n");
- help_cmd_kv_dflt("peer_addr_type", cmd_conn_peer_addr_types,
- BLE_ADDR_TYPE_PUBLIC);
+ help_cmd_kv_dflt("peer_addr_type", cmd_peer_addr_types,
+ BLE_ADDR_PUBLIC);
return rc;
}
- if (peer_addr_type != BLE_GAP_ADDR_TYPE_WL) {
- rc = parse_arg_mac("peer_addr", peer_addr);
- if (rc == ENOENT) {
- /* Allow "addr" for backwards compatibility. */
- rc = parse_arg_mac("addr", peer_addr);
- }
+ rc = parse_arg_mac("peer_addr", peer_addr.val);
+ if (rc == ENOENT) {
+ /* Allow "addr" for backwards compatibility. */
+ rc = parse_arg_mac("addr", peer_addr.val);
+ }
- if (rc != 0) {
- console_printf("invalid 'peer_addr' parameter\n");
- help_cmd_byte_stream_exact_length("peer_addr", 6);
- return rc;
- }
- } else {
- memset(peer_addr, 0, sizeof peer_addr);
+ if (rc == ENOENT) {
+ /* With no "peer_addr" specified we'll use white list */
+ peer_addr_param = NULL;
+ } else if (rc != 0) {
+ console_printf("invalid 'peer_addr' parameter\n");
+ help_cmd_byte_stream_exact_length("peer_addr", 6);
+ return rc;
}
- own_addr_type = parse_arg_kv_default("own_addr_type",
- cmd_conn_own_addr_types,
- BLE_ADDR_TYPE_PUBLIC, &rc);
+ own_addr_type = parse_arg_kv_default("own_addr_type", cmd_own_addr_types,
+ BLE_OWN_ADDR_PUBLIC, &rc);
if (rc != 0) {
console_printf("invalid 'own_addr_type' parameter\n");
- help_cmd_kv_dflt("own_addr_type", cmd_conn_own_addr_types,
- BLE_ADDR_TYPE_PUBLIC);
+ help_cmd_kv_dflt("own_addr_type", cmd_own_addr_types,
+ BLE_OWN_ADDR_PUBLIC);
return rc;
}
@@ -707,8 +699,8 @@ cmd_conn(int argc, char **argv)
return rc;
}
- rc = bletiny_conn_initiate(own_addr_type, peer_addr_type, peer_addr,
- duration_ms, ¶ms);
+ rc = bletiny_conn_initiate(own_addr_type, peer_addr_param, duration_ms,
+ ¶ms);
if (rc != 0) {
return rc;
}
@@ -1434,14 +1426,6 @@ static struct kv_pair cmd_scan_filt_policies[] = {
{ NULL }
};
-static struct kv_pair cmd_scan_addr_types[] = {
- { "public", BLE_ADDR_TYPE_PUBLIC },
- { "random", BLE_ADDR_TYPE_RANDOM },
- { "rpa_pub", BLE_ADDR_TYPE_RPA_PUB_DEFAULT },
- { "rpa_rnd", BLE_ADDR_TYPE_RPA_RND_DEFAULT },
- { NULL }
-};
-
static void
bletiny_scan_help(void)
{
@@ -1457,8 +1441,8 @@ bletiny_scan_help(void)
help_cmd_kv_dflt("filt", cmd_scan_filt_policies,
BLE_HCI_SCAN_FILT_NO_WL);
help_cmd_uint16_dflt("nodups", 0);
- help_cmd_kv_dflt("own_addr_type", cmd_scan_addr_types,
- BLE_ADDR_TYPE_PUBLIC);
+ help_cmd_kv_dflt("own_addr_type", cmd_own_addr_types,
+ BLE_OWN_ADDR_PUBLIC);
}
static int
@@ -1536,12 +1520,12 @@ cmd_scan(int argc, char **argv)
return rc;
}
- own_addr_type = parse_arg_kv_default("own_addr_type", cmd_scan_addr_types,
- BLE_ADDR_TYPE_PUBLIC, &rc);
+ own_addr_type = parse_arg_kv_default("own_addr_type", cmd_own_addr_types,
+ BLE_OWN_ADDR_PUBLIC, &rc);
if (rc != 0) {
console_printf("invalid 'own_addr_type' parameter\n");
- help_cmd_kv_dflt("own_addr_type", cmd_scan_addr_types,
- BLE_ADDR_TYPE_PUBLIC);
+ help_cmd_kv_dflt("own_addr_type", cmd_own_addr_types,
+ BLE_OWN_ADDR_PUBLIC);
return rc;
}
@@ -1565,7 +1549,7 @@ cmd_show_addr(int argc, char **argv)
int rc;
console_printf("public_id_addr=");
- rc = ble_hs_id_copy_addr(BLE_ADDR_TYPE_PUBLIC, id_addr, NULL);
+ rc = ble_hs_id_copy_addr(BLE_ADDR_PUBLIC, id_addr, NULL);
if (rc == 0) {
print_addr(id_addr);
} else {
@@ -1573,7 +1557,7 @@ cmd_show_addr(int argc, char **argv)
}
console_printf(" random_id_addr=");
- rc = ble_hs_id_copy_addr(BLE_ADDR_TYPE_RANDOM, id_addr, NULL);
+ rc = ble_hs_id_copy_addr(BLE_ADDR_RANDOM, id_addr, NULL);
if (rc == 0) {
print_addr(id_addr);
} else {
@@ -2278,8 +2262,8 @@ cmd_set_sm_data(void)
}
static struct kv_pair cmd_set_addr_types[] = {
- { "public", BLE_ADDR_TYPE_PUBLIC },
- { "random", BLE_ADDR_TYPE_RANDOM },
+ { "public", BLE_ADDR_PUBLIC },
+ { "random", BLE_ADDR_RANDOM },
{ NULL }
};
@@ -2287,7 +2271,7 @@ static void
bletiny_set_addr_help(void)
{
console_printf("Available set addr params: \n");
- help_cmd_kv_dflt("addr_type", cmd_set_addr_types, BLE_ADDR_TYPE_PUBLIC);
+ help_cmd_kv_dflt("addr_type", cmd_set_addr_types, BLE_ADDR_PUBLIC);
help_cmd_byte_stream_exact_length("addr", 6);
}
@@ -2299,10 +2283,10 @@ cmd_set_addr(void)
int rc;
addr_type = parse_arg_kv_default("addr_type", cmd_set_addr_types,
- BLE_ADDR_TYPE_PUBLIC, &rc);
+ BLE_ADDR_PUBLIC, &rc);
if (rc != 0) {
console_printf("invalid 'addr_type' parameter\n");
- help_cmd_kv_dflt("addr_type", cmd_set_addr_types, BLE_ADDR_TYPE_PUBLIC);
+ help_cmd_kv_dflt("addr_type", cmd_set_addr_types, BLE_ADDR_PUBLIC);
return rc;
}
@@ -2314,7 +2298,7 @@ cmd_set_addr(void)
}
switch (addr_type) {
- case BLE_ADDR_TYPE_PUBLIC:
+ case BLE_ADDR_PUBLIC:
/* We shouldn't be writing to the controller's address (g_dev_addr).
* There is no standard way to set the local public address, so this is
* our only option at the moment.
@@ -2323,7 +2307,7 @@ cmd_set_addr(void)
ble_hs_id_set_pub(g_dev_addr);
break;
- case BLE_ADDR_TYPE_RANDOM:
+ case BLE_ADDR_RANDOM:
rc = ble_hs_id_set_rnd(addr);
if (rc != 0) {
return rc;
@@ -2563,12 +2547,6 @@ cmd_update(int argc, char **argv)
* $white list *
*****************************************************************************/
-static struct kv_pair cmd_wl_addr_types[] = {
- { "public", BLE_HCI_CONN_PEER_ADDR_PUBLIC },
- { "random", BLE_HCI_CONN_PEER_ADDR_RANDOM },
- { NULL }
-};
-
#define CMD_WL_MAX_SZ 8
static void
@@ -2579,16 +2557,14 @@ bletiny_wl_help(void)
console_printf("Available wl params: \n");
console_printf("\tlist of:\n");
help_cmd_byte_stream_exact_length("addr", 6);
- help_cmd_kv("addr_type", cmd_wl_addr_types);
+ help_cmd_kv("addr_type", cmd_addr_type);
}
static int
cmd_wl(int argc, char **argv)
{
- static struct ble_gap_white_entry white_list[CMD_WL_MAX_SZ];
- uint8_t addr_type;
- uint8_t addr[6];
- int wl_cnt;
+ static ble_addr_t addrs[CMD_WL_MAX_SZ];
+ int addrs_cnt;
int rc;
if (argc > 1 && strcmp(argv[1], "help") == 0) {
@@ -2596,13 +2572,13 @@ cmd_wl(int argc, char **argv)
return 0;
}
- wl_cnt = 0;
+ addrs_cnt = 0;
while (1) {
- if (wl_cnt >= CMD_WL_MAX_SZ) {
+ if (addrs_cnt >= CMD_WL_MAX_SZ) {
return EINVAL;
}
- rc = parse_arg_mac("addr", addr);
+ rc = parse_arg_mac("addr", addrs[addrs_cnt].val);
if (rc == ENOENT) {
break;
} else if (rc != 0) {
@@ -2611,23 +2587,21 @@ cmd_wl(int argc, char **argv)
return rc;
}
- addr_type = parse_arg_kv("addr_type", cmd_wl_addr_types, &rc);
+ addrs[addrs_cnt].type = parse_arg_kv("addr_type", cmd_addr_type, &rc);
if (rc != 0) {
console_printf("invalid 'addr' parameter\n");
- help_cmd_kv("addr_type", cmd_wl_addr_types);
+ help_cmd_kv("addr_type", cmd_addr_type);
return rc;
}
- memcpy(white_list[wl_cnt].addr, addr, 6);
- white_list[wl_cnt].addr_type = addr_type;
- wl_cnt++;
+ addrs_cnt++;
}
- if (wl_cnt == 0) {
+ if (addrs_cnt == 0) {
return EINVAL;
}
- bletiny_wl_set(white_list, wl_cnt);
+ bletiny_wl_set(addrs, addrs_cnt);
return 0;
}
@@ -2792,18 +2766,12 @@ static struct kv_pair cmd_keystore_entry_type[] = {
{ NULL }
};
-static struct kv_pair cmd_keystore_addr_type[] = {
- { "public", BLE_ADDR_TYPE_PUBLIC },
- { "random", BLE_ADDR_TYPE_RANDOM },
- { NULL }
-};
-
static void
bletiny_keystore_parse_keydata_help(void)
{
console_printf("Available keystore parse keydata params: \n");
help_cmd_kv("type", cmd_keystore_entry_type);
- help_cmd_kv("addr_type", cmd_keystore_addr_type);
+ help_cmd_kv("addr_type", cmd_addr_type);
help_cmd_byte_stream_exact_length("addr", 6);
help_cmd_uint16("ediv");
help_cmd_uint64("rand");
@@ -2826,14 +2794,14 @@ cmd_keystore_parse_keydata(int argc, char **argv, union ble_store_key *out,
switch (*obj_type) {
case BLE_STORE_OBJ_TYPE_PEER_SEC:
case BLE_STORE_OBJ_TYPE_OUR_SEC:
- rc = parse_arg_kv("addr_type", cmd_keystore_addr_type, &rc);
+ out->sec.peer_addr.type = parse_arg_kv("addr_type", cmd_addr_type, &rc);
if (rc != 0) {
console_printf("invalid 'addr_type' parameter\n");
- help_cmd_kv("addr_type", cmd_keystore_addr_type);
+ help_cmd_kv("addr_type", cmd_addr_type);
return rc;
}
- rc = parse_arg_mac("addr", out->sec.peer_addr);
+ rc = parse_arg_mac("addr", out->sec.peer_addr.val);
if (rc != 0) {
console_printf("invalid 'addr' parameter\n");
help_cmd_byte_stream_exact_length("addr", 6);
@@ -2912,8 +2880,7 @@ cmd_keystore_parse_valuedata(int argc, char **argv,
help_cmd_byte_stream_exact_length("csrk", 16);
return rc;
}
- out->sec.peer_addr_type = key->sec.peer_addr_type;
- memcpy(out->sec.peer_addr, key->sec.peer_addr, 6);
+ out->sec.peer_addr = key->sec.peer_addr;
out->sec.ediv = key->sec.ediv;
out->sec.rand_num = key->sec.rand_num;
break;
@@ -3013,12 +2980,12 @@ cmd_keystore_iterator(int obj_type,
case BLE_STORE_OBJ_TYPE_PEER_SEC:
case BLE_STORE_OBJ_TYPE_OUR_SEC:
console_printf("Key: ");
- if (val->sec.peer_addr_type == BLE_STORE_ADDR_TYPE_NONE) {
+ if (ble_addr_cmp(&val->sec.peer_addr, BLE_ADDR_ANY) == 0) {
console_printf("ediv=%u ", val->sec.ediv);
console_printf("ediv=%llu ", val->sec.rand_num);
} else {
- console_printf("addr_type=%u ", val->sec.peer_addr_type);
- print_addr(val->sec.peer_addr);
+ console_printf("addr_type=%u ", val->sec.peer_addr.type);
+ print_addr(val->sec.peer_addr.val);
}
console_printf("\n");
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/apps/bletiny/src/main.c
----------------------------------------------------------------------
diff --git a/apps/bletiny/src/main.c b/apps/bletiny/src/main.c
index 5f76bcf..4e69f40 100755
--- a/apps/bletiny/src/main.c
+++ b/apps/bletiny/src/main.c
@@ -908,8 +908,8 @@ bletiny_gap_event(struct ble_gap_event *event, void *arg)
case BLE_GAP_EVENT_DISC:
console_printf("received advertisement; event_type=%d rssi=%d "
"addr_type=%d addr=", event->disc.event_type,
- event->disc.rssi, event->disc.addr_type);
- print_addr(event->disc.addr);
+ event->disc.rssi, event->disc.addr.type);
+ print_addr(event->disc.addr.val);
/*
* There is no adv data to print in case of connectable
@@ -1295,26 +1295,24 @@ bletiny_adv_stop(void)
}
int
-bletiny_adv_start(uint8_t own_addr_type, uint8_t peer_addr_type,
- const uint8_t *peer_addr, int32_t duration_ms,
- const struct ble_gap_adv_params *params)
+bletiny_adv_start(uint8_t own_addr_type, const ble_addr_t *direct_addr,
+ int32_t duration_ms, const struct ble_gap_adv_params *params)
{
int rc;
- rc = ble_gap_adv_start(own_addr_type, peer_addr_type, peer_addr,
- duration_ms, params, bletiny_gap_event, NULL);
+ rc = ble_gap_adv_start(own_addr_type, direct_addr, duration_ms, params,
+ bletiny_gap_event, NULL);
return rc;
}
int
-bletiny_conn_initiate(uint8_t own_addr_type, uint8_t peer_addr_type,
- uint8_t *peer_addr, int32_t duration_ms,
- struct ble_gap_conn_params *params)
+bletiny_conn_initiate(uint8_t own_addr_type, const ble_addr_t *peer_addr,
+ int32_t duration_ms, struct ble_gap_conn_params *params)
{
int rc;
- rc = ble_gap_connect(own_addr_type, peer_addr_type, peer_addr, duration_ms,
- params, bletiny_gap_event, NULL);
+ rc = ble_gap_connect(own_addr_type, peer_addr, duration_ms, params,
+ bletiny_gap_event, NULL);
return rc;
}
@@ -1338,11 +1336,11 @@ bletiny_term_conn(uint16_t conn_handle, uint8_t reason)
}
int
-bletiny_wl_set(struct ble_gap_white_entry *white_list, int white_list_count)
+bletiny_wl_set(ble_addr_t *addrs, int addrs_count)
{
int rc;
- rc = ble_gap_wl_set(white_list, white_list_count);
+ rc = ble_gap_wl_set(addrs, addrs_count);
return rc;
}
@@ -1461,8 +1459,7 @@ bletiny_sec_restart(uint16_t conn_handle,
}
memset(&key_sec, 0, sizeof key_sec);
- key_sec.peer_addr_type = desc.peer_id_addr_type;
- memcpy(key_sec.peer_addr, desc.peer_id_addr, 6);
+ key_sec.peer_addr = desc.peer_id_addr;
rc = ble_hs_atomic_conn_flags(conn_handle, &conn_flags);
if (rc != 0) {
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/apps/bletiny/src/misc.c
----------------------------------------------------------------------
diff --git a/apps/bletiny/src/misc.c b/apps/bletiny/src/misc.c
index e8ed345..d39016b 100644
--- a/apps/bletiny/src/misc.c
+++ b/apps/bletiny/src/misc.c
@@ -102,17 +102,17 @@ void
print_conn_desc(const struct ble_gap_conn_desc *desc)
{
console_printf("handle=%d our_ota_addr_type=%d our_ota_addr=",
- desc->conn_handle, desc->our_ota_addr_type);
- print_addr(desc->our_ota_addr);
+ desc->conn_handle, desc->our_ota_addr.type);
+ print_addr(desc->our_ota_addr.val);
console_printf(" our_id_addr_type=%d our_id_addr=",
- desc->our_id_addr_type);
- print_addr(desc->our_id_addr);
+ desc->our_id_addr.type);
+ print_addr(desc->our_id_addr.val);
console_printf(" peer_ota_addr_type=%d peer_ota_addr=",
- desc->peer_ota_addr_type);
- print_addr(desc->peer_ota_addr);
+ desc->peer_ota_addr.type);
+ print_addr(desc->peer_ota_addr.val);
console_printf(" peer_id_addr_type=%d peer_id_addr=",
- desc->peer_id_addr_type);
- print_addr(desc->peer_id_addr);
+ desc->peer_id_addr.type);
+ print_addr(desc->peer_id_addr.val);
console_printf(" conn_itvl=%d conn_latency=%d supervision_timeout=%d "
"encrypted=%d authenticated=%d bonded=%d\n",
desc->conn_itvl, desc->conn_latency,
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/apps/bleuart/src/main.c
----------------------------------------------------------------------
diff --git a/apps/bleuart/src/main.c b/apps/bleuart/src/main.c
index 1a9e4dc..6da390d 100755
--- a/apps/bleuart/src/main.c
+++ b/apps/bleuart/src/main.c
@@ -112,7 +112,7 @@ bleuart_advertise(void)
memset(&adv_params, 0, sizeof adv_params);
adv_params.conn_mode = BLE_GAP_CONN_MODE_UND;
adv_params.disc_mode = BLE_GAP_DISC_MODE_GEN;
- rc = ble_gap_adv_start(BLE_ADDR_TYPE_PUBLIC, 0, NULL, BLE_HS_FOREVER,
+ rc = ble_gap_adv_start(BLE_ADDR_PUBLIC, NULL, BLE_HS_FOREVER,
&adv_params, bleuart_gap_event, NULL);
if (rc != 0) {
return;
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/hw/drivers/nimble/nrf52/src/ble_hw.c
----------------------------------------------------------------------
diff --git a/hw/drivers/nimble/nrf52/src/ble_hw.c b/hw/drivers/nimble/nrf52/src/ble_hw.c
index 0962285..ad5af49 100644
--- a/hw/drivers/nimble/nrf52/src/ble_hw.c
+++ b/hw/drivers/nimble/nrf52/src/ble_hw.c
@@ -90,7 +90,7 @@ ble_hw_whitelist_add(uint8_t *addr, uint8_t addr_type)
if ((mask & g_ble_hw_whitelist_mask) == 0) {
NRF_RADIO->DAB[i] = get_le32(addr);
NRF_RADIO->DAP[i] = get_le16(addr + 4);
- if (addr_type == BLE_ADDR_TYPE_RANDOM) {
+ if (addr_type == BLE_ADDR_RANDOM) {
NRF_RADIO->DACNF |= (mask << 8);
}
g_ble_hw_whitelist_mask |= mask;
@@ -128,7 +128,7 @@ ble_hw_whitelist_rmv(uint8_t *addr, uint8_t addr_type)
if (mask & g_ble_hw_whitelist_mask) {
if ((dab == NRF_RADIO->DAB[i]) && (dap == NRF_RADIO->DAP[i])) {
cfg_addr = txadd & mask;
- if (addr_type == BLE_ADDR_TYPE_RANDOM) {
+ if (addr_type == BLE_ADDR_RANDOM) {
if (cfg_addr != 0) {
break;
}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/net/nimble/controller/src/ble_ll_adv.c
----------------------------------------------------------------------
diff --git a/net/nimble/controller/src/ble_ll_adv.c b/net/nimble/controller/src/ble_ll_adv.c
index bf62810..077ca5a 100644
--- a/net/nimble/controller/src/ble_ll_adv.c
+++ b/net/nimble/controller/src/ble_ll_adv.c
@@ -1127,9 +1127,9 @@ ble_ll_adv_rx_req(uint8_t pdu_type, struct os_mbuf *rxpdu)
/* Get the peer address type */
if (rxbuf[0] & BLE_ADV_PDU_HDR_TXADD_MASK) {
- txadd = BLE_ADDR_TYPE_RANDOM;
+ txadd = BLE_ADDR_RANDOM;
} else {
- txadd = BLE_ADDR_TYPE_PUBLIC;
+ txadd = BLE_ADDR_PUBLIC;
}
ble_hdr = BLE_MBUF_HDR_PTR(rxpdu);
@@ -1218,9 +1218,9 @@ ble_ll_adv_conn_req_rxd(uint8_t *rxbuf, struct ble_mbuf_hdr *hdr,
valid = 1;
if (rxbuf[0] & BLE_ADV_PDU_HDR_TXADD_MASK) {
- addr_type = BLE_ADDR_TYPE_RANDOM;
+ addr_type = BLE_ADDR_RANDOM;
} else {
- addr_type = BLE_ADDR_TYPE_PUBLIC;
+ addr_type = BLE_ADDR_PUBLIC;
}
/*
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/net/nimble/controller/src/ble_ll_scan.c
----------------------------------------------------------------------
diff --git a/net/nimble/controller/src/ble_ll_scan.c b/net/nimble/controller/src/ble_ll_scan.c
index be06030..f732753 100644
--- a/net/nimble/controller/src/ble_ll_scan.c
+++ b/net/nimble/controller/src/ble_ll_scan.c
@@ -945,9 +945,9 @@ ble_ll_scan_rx_isr_end(struct os_mbuf *rxpdu, uint8_t crcok)
pdu_type = rxbuf[0] & BLE_ADV_PDU_HDR_TYPE_MASK;
peer = rxbuf + BLE_LL_PDU_HDR_LEN;
if (rxbuf[0] & BLE_ADV_PDU_HDR_TXADD_MASK) {
- addr_type = BLE_ADDR_TYPE_RANDOM;
+ addr_type = BLE_ADDR_RANDOM;
} else {
- addr_type = BLE_ADDR_TYPE_PUBLIC;
+ addr_type = BLE_ADDR_PUBLIC;
}
peer_addr_type = addr_type;
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/net/nimble/host/include/host/ble_gap.h
----------------------------------------------------------------------
diff --git a/net/nimble/host/include/host/ble_gap.h b/net/nimble/host/include/host/ble_gap.h
index fa84d3b..6a4cee2 100644
--- a/net/nimble/host/include/host/ble_gap.h
+++ b/net/nimble/host/include/host/ble_gap.h
@@ -91,9 +91,6 @@ struct hci_conn_update;
#define BLE_GAP_INITIAL_CONN_MIN_CE_LEN 0x0010
#define BLE_GAP_INITIAL_CONN_MAX_CE_LEN 0x0300
-#define BLE_GAP_ADDR_TYPE_WL 0xff
-#define BLE_GAP_ADDR_TYPE_NONE 0xfe
-
#define BLE_GAP_ROLE_MASTER 0
#define BLE_GAP_ROLE_SLAVE 1
@@ -166,18 +163,14 @@ struct ble_gap_adv_params {
struct ble_gap_conn_desc {
struct ble_gap_sec_state sec_state;
- uint8_t peer_ota_addr[6];
- uint8_t peer_id_addr[6];
- uint8_t our_id_addr[6];
- uint8_t our_ota_addr[6];
+ ble_addr_t our_id_addr;
+ ble_addr_t peer_id_addr;
+ ble_addr_t our_ota_addr;
+ ble_addr_t peer_ota_addr;
uint16_t conn_handle;
uint16_t conn_itvl;
uint16_t conn_latency;
uint16_t supervision_timeout;
- uint8_t peer_ota_addr_type;
- uint8_t peer_id_addr_type;
- uint8_t our_id_addr_type;
- uint8_t our_ota_addr_type;
uint8_t role;
uint8_t master_clock_accuracy;
};
@@ -219,18 +212,16 @@ struct ble_gap_passkey_params {
struct ble_gap_disc_desc {
/*** Common fields. */
uint8_t event_type;
- uint8_t addr_type;
uint8_t length_data;
+ ble_addr_t addr;
int8_t rssi;
- uint8_t addr[6];
uint8_t *data;
/***
- * LE direct advertising report fields; direct_addr_type is
- * BLE_GAP_ADDR_TYPE_NONE if direct address fields are not present.
+ * LE direct advertising report fields; direct_addr is BLE_ADDR_ANY if
+ * direct address fields are not present.
*/
- uint8_t direct_addr_type;
- uint8_t direct_addr[6];
+ ble_addr_t direct_addr;
};
/**
@@ -526,17 +517,12 @@ typedef int ble_gap_event_fn(struct ble_gap_event *event, void *arg);
#define BLE_GAP_DISC_MODE_LTD 1
#define BLE_GAP_DISC_MODE_GEN 2
-struct ble_gap_white_entry {
- uint8_t addr_type;
- uint8_t addr[6];
-};
-
int ble_gap_conn_find(uint16_t handle, struct ble_gap_conn_desc *out_desc);
int ble_gap_set_event_cb(uint16_t conn_handle,
ble_gap_event_fn *cb, void *cb_arg);
-int ble_gap_adv_start(uint8_t own_addr_type, uint8_t peer_addr_type,
- const uint8_t *peer_addr, int32_t duration_ms,
+int ble_gap_adv_start(uint8_t own_addr_type, const ble_addr_t *direct_addr,
+ int32_t duration_ms,
const struct ble_gap_adv_params *adv_params,
ble_gap_event_fn *cb, void *cb_arg);
int ble_gap_adv_stop(void);
@@ -550,16 +536,14 @@ int ble_gap_disc(uint8_t own_addr_type, int32_t duration_ms,
ble_gap_event_fn *cb, void *cb_arg);
int ble_gap_disc_cancel(void);
int ble_gap_disc_active(void);
-int ble_gap_connect(uint8_t own_addr_type,
- uint8_t peer_addr_type, const uint8_t *peer_addr,
+int ble_gap_connect(uint8_t own_addr_type, const ble_addr_t *peer_addr,
int32_t duration_ms,
const struct ble_gap_conn_params *params,
ble_gap_event_fn *cb, void *cb_arg);
int ble_gap_conn_cancel(void);
int ble_gap_conn_active(void);
int ble_gap_terminate(uint16_t conn_handle, uint8_t hci_reason);
-int ble_gap_wl_set(const struct ble_gap_white_entry *white_list,
- uint8_t white_list_count);
+int ble_gap_wl_set(const ble_addr_t *addr, uint8_t white_list_count);
int ble_gap_update_params(uint16_t conn_handle,
const struct ble_gap_upd_params *params);
int ble_gap_dbg_update_active(uint16_t conn_handle);
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/net/nimble/host/include/host/ble_hs_id.h
----------------------------------------------------------------------
diff --git a/net/nimble/host/include/host/ble_hs_id.h b/net/nimble/host/include/host/ble_hs_id.h
index 3867f5d..8674840 100644
--- a/net/nimble/host/include/host/ble_hs_id.h
+++ b/net/nimble/host/include/host/ble_hs_id.h
@@ -21,12 +21,13 @@
#define H_BLE_HS_ID_
#include <inttypes.h>
+#include "nimble/ble.h"
#ifdef __cplusplus
extern "C" {
#endif
-int ble_hs_id_gen_rnd(int nrpa, uint8_t *out_addr);
+int ble_hs_id_gen_rnd(int nrpa, ble_addr_t *out_addr);
int ble_hs_id_set_rnd(const uint8_t *rnd_addr);
int ble_hs_id_copy_addr(uint8_t id_addr_type, uint8_t *out_id_addr,
int *out_is_nrpa);
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/net/nimble/host/include/host/ble_store.h
----------------------------------------------------------------------
diff --git a/net/nimble/host/include/host/ble_store.h b/net/nimble/host/include/host/ble_store.h
index 71d8709..f0d4300 100644
--- a/net/nimble/host/include/host/ble_store.h
+++ b/net/nimble/host/include/host/ble_store.h
@@ -21,6 +21,7 @@
#define H_BLE_STORE_
#include <inttypes.h>
+#include "nimble/ble.h"
#ifdef __cplusplus
extern "C" {
@@ -30,7 +31,7 @@ extern "C" {
#define BLE_STORE_OBJ_TYPE_PEER_SEC 2
#define BLE_STORE_OBJ_TYPE_CCCD 3
-#define BLE_STORE_ADDR_TYPE_NONE 0xff
+//#define BLE_STORE_ADDR_TYPE_NONE 0xff
/**
* Used as a key for lookups of security material. This struct corresponds to
@@ -41,14 +42,9 @@ extern "C" {
struct ble_store_key_sec {
/**
* Key by peer identity address;
- * Valid peer_addr_type values;
- * o BLE_ADDR_TYPE_PUBLIC
- * o BLE_ADDR_TYPE_RANDOM
- * o BLE_STORE_ADDR_TYPE_NONE
- * peer_addr_type=BLE_STORE_ADDR_TYPE_NONE means don't key off peer.
+ * peer_addr=BLE_ADDR_NONE means don't key off peer.
*/
- uint8_t peer_addr[6];
- uint8_t peer_addr_type;
+ ble_addr_t peer_addr;
/** Key by ediv; ediv_rand_present=0 means don't key off ediv. */
uint16_t ediv;
@@ -69,8 +65,7 @@ struct ble_store_key_sec {
* o BLE_STORE_OBJ_TYPE_PEER_SEC
*/
struct ble_store_value_sec {
- uint8_t peer_addr[6];
- uint8_t peer_addr_type;
+ ble_addr_t peer_addr;
uint8_t key_size;
uint16_t ediv;
@@ -95,10 +90,9 @@ struct ble_store_value_sec {
struct ble_store_key_cccd {
/**
* Key by peer identity address;
- * peer_addr_type=BLE_STORE_ADDR_TYPE_NONE means don't key off peer.
+ * peer_addr=BLE_ADDR_NONE means don't key off peer.
*/
- uint8_t peer_addr[6];
- uint8_t peer_addr_type;
+ ble_addr_t peer_addr;
/**
* Key by characteristic value handle;
@@ -115,8 +109,7 @@ struct ble_store_key_cccd {
* This struct corresponds to the BLE_STORE_OBJ_TYPE_CCCD store object type.
*/
struct ble_store_value_cccd {
- uint8_t peer_addr[6];
- uint8_t peer_addr_type;
+ ble_addr_t peer_addr;
uint16_t chr_val_handle;
uint16_t flags;
unsigned value_changed:1;
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/net/nimble/host/src/ble_att_svr.c
----------------------------------------------------------------------
diff --git a/net/nimble/host/src/ble_att_svr.c b/net/nimble/host/src/ble_att_svr.c
index c2097e1..df1a30d 100644
--- a/net/nimble/host/src/ble_att_svr.c
+++ b/net/nimble/host/src/ble_att_svr.c
@@ -282,8 +282,7 @@ ble_att_svr_check_perms(uint16_t conn_handle, int is_read,
ble_hs_conn_addrs(conn, &addrs);
memset(&key_sec, 0, sizeof key_sec);
- key_sec.peer_addr_type = addrs.peer_id_addr_type;
- memcpy(key_sec.peer_addr, addrs.peer_id_addr, 6);
+ key_sec.peer_addr = addrs.peer_id_addr;
}
ble_hs_unlock();
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/net/nimble/host/src/ble_gap.c
----------------------------------------------------------------------
diff --git a/net/nimble/host/src/ble_gap.c b/net/nimble/host/src/ble_gap.c
index 3b9892c..be9865e 100644
--- a/net/nimble/host/src/ble_gap.c
+++ b/net/nimble/host/src/ble_gap.c
@@ -235,15 +235,12 @@ ble_gap_log_duration(int32_t duration_ms)
}
static void
-ble_gap_log_conn(uint8_t own_addr_type,
- uint8_t peer_addr_type, const uint8_t *peer_addr,
+ble_gap_log_conn(uint8_t own_addr_type, const ble_addr_t *peer_addr,
const struct ble_gap_conn_params *params)
{
- BLE_HS_LOG(INFO, "peer_addr_type=%d peer_addr=", peer_addr_type);
- if (peer_addr == NULL) {
- BLE_HS_LOG(INFO, "N/A");
- } else {
- BLE_HS_LOG_ADDR(INFO, peer_addr);
+ if (peer_addr != NULL) {
+ BLE_HS_LOG(INFO, "peer_addr_type=%d peer_addr=", peer_addr->type);
+ BLE_HS_LOG_ADDR(INFO, peer_addr->val);
}
BLE_HS_LOG(INFO, " scan_itvl=%d scan_window=%d itvl_min=%d itvl_max=%d "
@@ -278,34 +275,27 @@ ble_gap_log_update(uint16_t conn_handle,
}
static void
-ble_gap_log_wl(const struct ble_gap_white_entry *white_list,
- uint8_t white_list_count)
+ble_gap_log_wl(const ble_addr_t *addr, uint8_t white_list_count)
{
- const struct ble_gap_white_entry *entry;
int i;
BLE_HS_LOG(INFO, "count=%d ", white_list_count);
- for (i = 0; i < white_list_count; i++) {
- entry = white_list + i;
-
- BLE_HS_LOG(INFO, "entry-%d={addr_type=%d addr=", i, entry->addr_type);
- BLE_HS_LOG_ADDR(INFO, entry->addr);
+ for (i = 0; i < white_list_count; i++, addr++) {
+ BLE_HS_LOG(INFO, "entry-%d={addr_type=%d addr=", i, addr->type);
+ BLE_HS_LOG_ADDR(INFO, addr->val);
BLE_HS_LOG(INFO, "} ");
}
}
static void
-ble_gap_log_adv(uint8_t own_addr_type, uint8_t peer_addr_type,
- const uint8_t *peer_addr,
+ble_gap_log_adv(uint8_t own_addr_type, const ble_addr_t *direct_addr,
const struct ble_gap_adv_params *adv_params)
{
- BLE_HS_LOG(INFO, "disc_mode=%d peer_addr_type=%d peer_addr=",
- ble_gap_slave.disc_mode, peer_addr_type);
- if(peer_addr) {
- BLE_HS_LOG_ADDR(INFO, peer_addr);
- } else {
- BLE_HS_LOG(INFO, "none");
+ BLE_HS_LOG(INFO, "disc_mode=%d", ble_gap_slave.disc_mode);
+ if (direct_addr) {
+ BLE_HS_LOG(INFO, " direct_addr_type=%d direct_addr=", direct_addr->type);
+ BLE_HS_LOG_ADDR(INFO, direct_addr->val);
}
BLE_HS_LOG(INFO, " adv_channel_map=%d own_addr_type=%d "
"adv_filter_policy=%d adv_itvl_min=%d adv_itvl_max=%d "
@@ -330,14 +320,10 @@ ble_gap_fill_conn_desc(struct ble_hs_conn *conn,
ble_hs_conn_addrs(conn, &addrs);
- desc->our_ota_addr_type = addrs.our_ota_addr_type;
- memcpy(desc->our_ota_addr, addrs.our_ota_addr, 6);
- desc->our_id_addr_type = addrs.our_id_addr_type;
- memcpy(desc->our_id_addr, addrs.our_id_addr, 6);
- desc->peer_ota_addr_type = addrs.peer_ota_addr_type;
- memcpy(desc->peer_ota_addr, addrs.peer_ota_addr, 6);
- desc->peer_id_addr_type = addrs.peer_id_addr_type;
- memcpy(desc->peer_id_addr, addrs.peer_id_addr, 6);
+ desc->our_id_addr = addrs.our_id_addr;
+ desc->peer_id_addr = addrs.peer_id_addr;
+ desc->our_ota_addr = addrs.our_ota_addr;
+ desc->peer_ota_addr = addrs.peer_ota_addr;
desc->conn_handle = conn->bhc_handle;
desc->conn_itvl = conn->bhc_itvl;
@@ -1169,12 +1155,6 @@ ble_gap_rx_conn_complete(struct hci_le_conn_complete *evt)
BLE_HS_DBG_ASSERT(conn != NULL);
conn->bhc_handle = evt->connection_handle;
- memcpy(conn->bhc_peer_addr, evt->peer_addr, sizeof conn->bhc_peer_addr);
- conn->bhc_peer_addr_type = evt->peer_addr_type;
- memcpy(conn->bhc_our_rpa_addr, evt->local_rpa,
- sizeof conn->bhc_our_rpa_addr);
- memcpy(conn->bhc_peer_rpa_addr, evt->peer_rpa,
- sizeof conn->bhc_peer_rpa_addr);
conn->bhc_itvl = evt->conn_itvl;
conn->bhc_latency = evt->conn_latency;
conn->bhc_supervision_timeout = evt->supervision_timeout;
@@ -1192,8 +1172,14 @@ ble_gap_rx_conn_complete(struct hci_le_conn_complete *evt)
ble_gap_slave_reset_state();
}
- memcpy(conn->bhc_our_rpa_addr, evt->local_rpa, 6);
- memcpy(conn->bhc_peer_rpa_addr, evt->peer_rpa, 6);
+ conn->bhc_peer_addr.type = evt->peer_addr_type;
+ memcpy(conn->bhc_peer_addr.val, evt->peer_addr, 6);
+
+ conn->bhc_our_rpa_addr.type = BLE_ADDR_RANDOM;
+ memcpy(conn->bhc_our_rpa_addr.val, evt->local_rpa, 6);
+
+ conn->bhc_peer_rpa_addr.type = BLE_ADDR_RANDOM;
+ memcpy(conn->bhc_peer_rpa_addr.val, evt->peer_rpa, 6);
ble_hs_lock();
@@ -1412,13 +1398,13 @@ ble_gap_wl_busy(void)
}
static int
-ble_gap_wl_tx_add(const struct ble_gap_white_entry *entry)
+ble_gap_wl_tx_add(const ble_addr_t *addr)
{
uint8_t buf[BLE_HCI_CMD_HDR_LEN + BLE_HCI_CHG_WHITE_LIST_LEN];
int rc;
rc = ble_hs_hci_cmd_build_le_add_to_whitelist(
- entry->addr, entry->addr_type, buf, sizeof buf);
+ addr->val, addr->type, buf, sizeof buf);
if (rc != 0) {
return rc;
}
@@ -1449,14 +1435,13 @@ ble_gap_wl_tx_clear(void)
/**
* Overwrites the controller's white list with the specified contents.
*
- * @param white_list The entries to write to the white list.
+ * @param addr The entries to write to the white list.
* @param white_list_count The number of entries in the white list.
*
* @return 0 on success; nonzero on failure.
*/
int
-ble_gap_wl_set(const struct ble_gap_white_entry *white_list,
- uint8_t white_list_count)
+ble_gap_wl_set(const ble_addr_t *addr, uint8_t white_list_count)
{
#if !MYNEWT_VAL(BLE_WHITELIST)
return BLE_HS_ENOTSUP;
@@ -1475,8 +1460,8 @@ ble_gap_wl_set(const struct ble_gap_white_entry *white_list,
}
for (i = 0; i < white_list_count; i++) {
- if (white_list[i].addr_type != BLE_ADDR_TYPE_PUBLIC &&
- white_list[i].addr_type != BLE_ADDR_TYPE_RANDOM) {
+ if (addr[i].type != BLE_ADDR_PUBLIC &&
+ addr[i].type != BLE_ADDR_RANDOM) {
rc = BLE_HS_EINVAL;
goto done;
@@ -1489,7 +1474,7 @@ ble_gap_wl_set(const struct ble_gap_white_entry *white_list,
}
BLE_HS_LOG(INFO, "GAP procedure initiated: set whitelist; ");
- ble_gap_log_wl(white_list, white_list_count);
+ ble_gap_log_wl(addr, white_list_count);
BLE_HS_LOG(INFO, "\n");
rc = ble_gap_wl_tx_clear();
@@ -1498,7 +1483,7 @@ ble_gap_wl_set(const struct ble_gap_white_entry *white_list,
}
for (i = 0; i < white_list_count; i++) {
- rc = ble_gap_wl_tx_add(white_list + i);
+ rc = ble_gap_wl_tx_add(addr + i);
if (rc != 0) {
goto done;
}
@@ -1642,8 +1627,7 @@ ble_gap_adv_dflt_itvls(uint8_t conn_mode,
}
static int
-ble_gap_adv_params_tx(uint8_t own_addr_type,
- uint8_t peer_addr_type, const uint8_t *peer_addr,
+ble_gap_adv_params_tx(uint8_t own_addr_type, const ble_addr_t *peer_addr,
const struct ble_gap_adv_params *adv_params)
{
@@ -1652,12 +1636,12 @@ ble_gap_adv_params_tx(uint8_t own_addr_type,
int rc;
if (peer_addr == NULL) {
- peer_addr = ble_hs_misc_null_addr;
+ peer_addr = BLE_ADDR_ANY;
}
hci_adv_params.own_addr_type = own_addr_type;
- hci_adv_params.peer_addr_type = peer_addr_type;
- memcpy(hci_adv_params.peer_addr, peer_addr,
+ hci_adv_params.peer_addr_type = peer_addr->type;
+ memcpy(hci_adv_params.peer_addr, peer_addr->val,
sizeof hci_adv_params.peer_addr);
/* Fill optional fields if application did not specify them. */
@@ -1694,8 +1678,7 @@ ble_gap_adv_params_tx(uint8_t own_addr_type,
}
static int
-ble_gap_adv_validate(uint8_t own_addr_type, uint8_t peer_addr_type,
- const uint8_t *peer_addr,
+ble_gap_adv_validate(uint8_t own_addr_type, const ble_addr_t *peer_addr,
const struct ble_gap_adv_params *adv_params)
{
if (adv_params == NULL) {
@@ -1737,10 +1720,10 @@ ble_gap_adv_validate(uint8_t own_addr_type, uint8_t peer_addr_type,
break;
case BLE_GAP_CONN_MODE_DIR:
- if (peer_addr_type != BLE_ADDR_TYPE_PUBLIC &&
- peer_addr_type != BLE_ADDR_TYPE_RANDOM &&
- peer_addr_type != BLE_ADDR_TYPE_RPA_PUB_DEFAULT &&
- peer_addr_type != BLE_ADDR_TYPE_RPA_RND_DEFAULT) {
+ if (peer_addr->type != BLE_ADDR_PUBLIC &&
+ peer_addr->type != BLE_ADDR_RANDOM &&
+ peer_addr->type != BLE_ADDR_PUBLIC_ID &&
+ peer_addr->type != BLE_ADDR_RANDOM_ID) {
return BLE_HS_EINVAL;
}
@@ -1768,18 +1751,12 @@ ble_gap_adv_validate(uint8_t own_addr_type, uint8_t peer_addr_type,
*
* @param own_addr_type The type of address the stack should use for
* itself. Valid values are:
- * o BLE_ADDR_TYPE_PUBLIC
- * o BLE_ADDR_TYPE_RANDOM
- * o BLE_ADDR_TYPE_RPA_PUB_DEFAULT
- * o BLE_ADDR_TYPE_RPA_RND_DEFAULT
- * @param peer_addr_type Address type of the peer's identity address.
- * Valid values are:
- * o BLE_ADDR_TYPE_PUBLIC
- * o BLE_ADDR_TYPE_RANDOM
- * This parameter is ignored unless directed
- * advertising is being used.
- * @param peer_addr The peer's six-byte identity address.
- * This parameter is ignored unless directed
+ * o BLE_OWN_ADDR_PUBLIC
+ * o BLE_OWN_ADDR_RANDOM
+ * o BLE_OWN_ADDR_RPA_PUBLIC_DEFAULT
+ * o BLE_OWN_ADDR_RPA_RANDOM_DEFAULT
+ * @param direct_addr The peer's address for directed advertising.
+ * This parameter shall be non-NULL if directed
* advertising is being used.
* @param duration_ms The duration of the advertisement procedure.
* On expiration, the procedure ends and a
@@ -1800,8 +1777,8 @@ ble_gap_adv_validate(uint8_t own_addr_type, uint8_t peer_addr_type,
* @return 0 on success; nonzero on failure.
*/
int
-ble_gap_adv_start(uint8_t own_addr_type, uint8_t peer_addr_type,
- const uint8_t *peer_addr, int32_t duration_ms,
+ble_gap_adv_start(uint8_t own_addr_type, const ble_addr_t *direct_addr,
+ int32_t duration_ms,
const struct ble_gap_adv_params *adv_params,
ble_gap_event_fn *cb, void *cb_arg)
{
@@ -1816,8 +1793,7 @@ ble_gap_adv_start(uint8_t own_addr_type, uint8_t peer_addr_type,
ble_hs_lock();
- rc = ble_gap_adv_validate(own_addr_type, peer_addr_type, peer_addr,
- adv_params);
+ rc = ble_gap_adv_validate(own_addr_type, direct_addr, adv_params);
if (rc != 0) {
goto done;
}
@@ -1837,7 +1813,7 @@ ble_gap_adv_start(uint8_t own_addr_type, uint8_t peer_addr_type,
}
BLE_HS_LOG(INFO, "GAP procedure initiated: advertise; ");
- ble_gap_log_adv(own_addr_type, peer_addr_type, peer_addr, adv_params);
+ ble_gap_log_adv(own_addr_type, direct_addr, adv_params);
BLE_HS_LOG(INFO, "\n");
ble_gap_slave.cb = cb;
@@ -1846,8 +1822,7 @@ ble_gap_adv_start(uint8_t own_addr_type, uint8_t peer_addr_type,
ble_gap_slave.disc_mode = adv_params->disc_mode;
ble_gap_slave.our_addr_type = own_addr_type;
- rc = ble_gap_adv_params_tx(own_addr_type, peer_addr_type, peer_addr,
- adv_params);
+ rc = ble_gap_adv_params_tx(own_addr_type, direct_addr, adv_params);
if (rc != 0) {
goto done;
}
@@ -2301,8 +2276,7 @@ ble_gap_disc_active(void)
*****************************************************************************/
static int
-ble_gap_conn_create_tx(uint8_t own_addr_type,
- uint8_t peer_addr_type, const uint8_t *peer_addr,
+ble_gap_conn_create_tx(uint8_t own_addr_type, const ble_addr_t *peer_addr,
const struct ble_gap_conn_params *params)
{
uint8_t buf[BLE_HCI_CMD_HDR_LEN + BLE_HCI_CREATE_CONN_LEN];
@@ -2312,7 +2286,7 @@ ble_gap_conn_create_tx(uint8_t own_addr_type,
hcc.scan_itvl = params->scan_itvl;
hcc.scan_window = params->scan_window;
- if (peer_addr_type == BLE_GAP_ADDR_TYPE_WL) {
+ if (peer_addr == NULL) {
/* Application wants to connect to any device in the white list. The
* peer address type and peer address fields are ignored by the
* controller; fill them with dummy values.
@@ -2322,8 +2296,8 @@ ble_gap_conn_create_tx(uint8_t own_addr_type,
memset(hcc.peer_addr, 0, sizeof hcc.peer_addr);
} else {
hcc.filter_policy = BLE_HCI_CONN_FILT_NO_WL;
- hcc.peer_addr_type = peer_addr_type;
- memcpy(hcc.peer_addr, peer_addr, sizeof hcc.peer_addr);
+ hcc.peer_addr_type = peer_addr->type;
+ memcpy(hcc.peer_addr, peer_addr->val, sizeof hcc.peer_addr);
}
hcc.own_addr_type = own_addr_type;
@@ -2352,19 +2326,13 @@ ble_gap_conn_create_tx(uint8_t own_addr_type,
*
* @param own_addr_type The type of address the stack should use for
* itself during connection establishment.
- * o BLE_ADDR_TYPE_PUBLIC
- * o BLE_ADDR_TYPE_RANDOM
- * o BLE_ADDR_TYPE_RPA_PUB_DEFAULT
- * o BLE_ADDR_TYPE_RPA_RND_DEFAULT
- * @param peer_addr_type The peer's address type. One of:
- * o BLE_HCI_CONN_PEER_ADDR_PUBLIC
- * o BLE_HCI_CONN_PEER_ADDR_RANDOM
- * o BLE_HCI_CONN_PEER_ADDR_PUBLIC_IDENT
- * o BLE_HCI_CONN_PEER_ADDR_RANDOM_IDENT
- * o BLE_GAP_ADDR_TYPE_WL
- * @param peer_addr The identity address of the peer to connect to.
- * This parameter is ignored when the white
- * list is used.
+ * o BLE_OWN_ADDR_PUBLIC
+ * o BLE_OWN_ADDR_RANDOM
+ * o BLE_OWN_ADDR_RPA_PUBLIC_DEFAULT
+ * o BLE_OWN_ADDR_RPA_RANDOM_DEFAULT
+ * @param peer_addr The address of the peer to connect to.
+ * If this parameter is NULL, the white list
+ * is used.
* @param duration_ms The duration of the discovery procedure.
* On expiration, the procedure ends and a
* BLE_GAP_EVENT_DISC_COMPLETE event is
@@ -2390,8 +2358,7 @@ ble_gap_conn_create_tx(uint8_t own_addr_type,
* Other nonzero on error.
*/
int
-ble_gap_connect(uint8_t own_addr_type,
- uint8_t peer_addr_type, const uint8_t *peer_addr,
+ble_gap_connect(uint8_t own_addr_type, const ble_addr_t *peer_addr,
int32_t duration_ms,
const struct ble_gap_conn_params *conn_params,
ble_gap_event_fn *cb, void *cb_arg)
@@ -2422,11 +2389,11 @@ ble_gap_connect(uint8_t own_addr_type,
goto done;
}
- if (peer_addr_type != BLE_HCI_CONN_PEER_ADDR_PUBLIC &&
- peer_addr_type != BLE_HCI_CONN_PEER_ADDR_RANDOM &&
- peer_addr_type != BLE_HCI_CONN_PEER_ADDR_PUB_ID &&
- peer_addr_type != BLE_HCI_CONN_PEER_ADDR_RAND_ID &&
- peer_addr_type != BLE_GAP_ADDR_TYPE_WL) {
+ if (peer_addr &&
+ peer_addr->type != BLE_ADDR_PUBLIC &&
+ peer_addr->type != BLE_ADDR_RANDOM &&
+ peer_addr->type != BLE_ADDR_PUBLIC_ID &&
+ peer_addr->type != BLE_ADDR_RANDOM_ID) {
rc = BLE_HS_EINVAL;
goto done;
@@ -2450,7 +2417,7 @@ ble_gap_connect(uint8_t own_addr_type,
}
/* Verify peer not already connected. */
- if (ble_hs_conn_find_by_addr(peer_addr_type, peer_addr) != NULL) {
+ if (ble_hs_conn_find_by_addr(peer_addr) != NULL) {
rc = BLE_HS_EDONE;
goto done;
}
@@ -2463,17 +2430,17 @@ ble_gap_connect(uint8_t own_addr_type,
}
BLE_HS_LOG(INFO, "GAP procedure initiated: connect; ");
- ble_gap_log_conn(own_addr_type, peer_addr_type, peer_addr, conn_params);
+ ble_gap_log_conn(own_addr_type, peer_addr, conn_params);
BLE_HS_LOG(INFO, "\n");
ble_gap_master.cb = cb;
ble_gap_master.cb_arg = cb_arg;
- ble_gap_master.conn.using_wl = peer_addr_type == BLE_GAP_ADDR_TYPE_WL;
+ ble_gap_master.conn.using_wl = peer_addr == NULL;
ble_gap_master.conn.our_addr_type = own_addr_type;
ble_gap_master.op = BLE_GAP_OP_M_CONN;
- rc = ble_gap_conn_create_tx(own_addr_type, peer_addr_type, peer_addr,
+ rc = ble_gap_conn_create_tx(own_addr_type, peer_addr,
conn_params);
if (rc != 0) {
ble_gap_master_reset_state();
@@ -3014,8 +2981,7 @@ ble_gap_security_initiate(uint16_t conn_handle)
ble_hs_conn_addrs(conn, &addrs);
memset(&key_sec, 0, sizeof key_sec);
- key_sec.peer_addr_type = addrs.peer_id_addr_type;
- memcpy(key_sec.peer_addr, addrs.peer_id_addr, 6);
+ key_sec.peer_addr = addrs.peer_id_addr;
}
ble_hs_unlock();
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/net/nimble/host/src/ble_gatts.c
----------------------------------------------------------------------
diff --git a/net/nimble/host/src/ble_gatts.c b/net/nimble/host/src/ble_gatts.c
index 39bf350..eaf4fcc 100644
--- a/net/nimble/host/src/ble_gatts.c
+++ b/net/nimble/host/src/ble_gatts.c
@@ -689,8 +689,7 @@ ble_gatts_clt_cfg_access_locked(struct ble_hs_conn *conn, uint16_t attr_handle,
/* Successful writes get persisted for bonded connections. */
if (conn->bhc_sec_state.bonded) {
- out_cccd->peer_addr_type = conn->bhc_peer_addr_type;
- memcpy(out_cccd->peer_addr, conn->bhc_peer_addr, 6);
+ out_cccd->peer_addr = conn->bhc_peer_addr;
out_cccd->chr_val_handle = chr_val_handle;
out_cccd->flags = clt_cfg->flags;
out_cccd->value_changed = 0;
@@ -1407,8 +1406,7 @@ ble_gatts_rx_indicate_ack(uint16_t conn_handle, uint16_t chr_val_handle)
persist = conn->bhc_sec_state.bonded &&
!(clt_cfg->flags & BLE_GATTS_CLT_CFG_F_MODIFIED);
if (persist) {
- cccd_value.peer_addr_type = conn->bhc_peer_addr_type;
- memcpy(cccd_value.peer_addr, conn->bhc_peer_addr, 6);
+ cccd_value.peer_addr = conn->bhc_peer_addr;
cccd_value.chr_val_handle = chr_val_handle;
cccd_value.flags = clt_cfg->flags;
cccd_value.value_changed = 0;
@@ -1488,8 +1486,8 @@ ble_gatts_chr_updated(uint16_t chr_val_handle)
/*** Persist updated flag for unconnected and not-yet-bonded devices. */
/* Retrieve each record corresponding to the modified characteristic. */
- cccd_key.peer_addr_type = BLE_STORE_ADDR_TYPE_NONE,
- cccd_key.chr_val_handle = chr_val_handle,
+ cccd_key.peer_addr = *BLE_ADDR_ANY;
+ cccd_key.chr_val_handle = chr_val_handle;
cccd_key.idx = 0;
while (1) {
@@ -1501,8 +1499,7 @@ ble_gatts_chr_updated(uint16_t chr_val_handle)
/* Determine if this record needs to be rewritten. */
ble_hs_lock();
- conn = ble_hs_conn_find_by_addr(cccd_value.peer_addr_type,
- cccd_value.peer_addr);
+ conn = ble_hs_conn_find_by_addr(&cccd_key.peer_addr);
if (conn == NULL) {
/* Device isn't connected; persist the changed flag so that an
@@ -1646,8 +1643,7 @@ ble_gatts_bonding_restored(uint16_t conn_handle)
BLE_HS_DBG_ASSERT(conn != NULL);
BLE_HS_DBG_ASSERT(conn->bhc_sec_state.bonded);
- cccd_key.peer_addr_type = conn->bhc_peer_addr_type;
- memcpy(cccd_key.peer_addr, conn->bhc_peer_addr, 6);
+ cccd_key.peer_addr = conn->bhc_peer_addr;
cccd_key.chr_val_handle = 0;
cccd_key.idx = 0;
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/net/nimble/host/src/ble_hs_conn.c
----------------------------------------------------------------------
diff --git a/net/nimble/host/src/ble_hs_conn.c b/net/nimble/host/src/ble_hs_conn.c
index 8207c28..d5dc17d 100644
--- a/net/nimble/host/src/ble_hs_conn.c
+++ b/net/nimble/host/src/ble_hs_conn.c
@@ -258,7 +258,7 @@ ble_hs_conn_find_assert(uint16_t conn_handle)
}
struct ble_hs_conn *
-ble_hs_conn_find_by_addr(uint8_t addr_type, const uint8_t *addr)
+ble_hs_conn_find_by_addr(const ble_addr_t *addr)
{
#if !NIMBLE_BLE_CONNECT
return NULL;
@@ -269,9 +269,7 @@ ble_hs_conn_find_by_addr(uint8_t addr_type, const uint8_t *addr)
BLE_HS_DBG_ASSERT(ble_hs_locked_by_cur_task());
SLIST_FOREACH(conn, &ble_hs_conns, bhc_next) {
- if (conn->bhc_peer_addr_type == addr_type &&
- memcmp(conn->bhc_peer_addr, addr, 6) == 0) {
-
+ if (ble_addr_cmp(&conn->bhc_peer_addr, addr) == 0) {
return conn;
}
}
@@ -330,43 +328,38 @@ void
ble_hs_conn_addrs(const struct ble_hs_conn *conn,
struct ble_hs_conn_addrs *addrs)
{
+ const uint8_t *our_id_addr_val;
int rc;
/* Determine our address information. */
- addrs->our_id_addr_type =
+ addrs->our_id_addr.type =
ble_hs_misc_addr_type_to_id(conn->bhc_our_addr_type);
- rc = ble_hs_id_addr(addrs->our_id_addr_type, &addrs->our_id_addr, NULL);
+ rc = ble_hs_id_addr(addrs->our_id_addr.type, &our_id_addr_val, NULL);
assert(rc == 0);
- if (memcmp(conn->bhc_our_rpa_addr, ble_hs_conn_null_addr, 6) == 0) {
- addrs->our_ota_addr_type = addrs->our_id_addr_type;
+ memcpy(addrs->our_id_addr.val, our_id_addr_val, 6);
+
+ if (memcmp(conn->bhc_our_rpa_addr.val, ble_hs_conn_null_addr, 6) == 0) {
addrs->our_ota_addr = addrs->our_id_addr;
} else {
- addrs->our_ota_addr_type = BLE_ADDR_TYPE_RANDOM;
addrs->our_ota_addr = conn->bhc_our_rpa_addr;
}
/* Determine peer address information. */
- addrs->peer_ota_addr_type = conn->bhc_peer_addr_type;
addrs->peer_id_addr = conn->bhc_peer_addr;
- switch (conn->bhc_peer_addr_type) {
- case BLE_ADDR_TYPE_PUBLIC:
- addrs->peer_id_addr_type = BLE_ADDR_TYPE_PUBLIC;
- addrs->peer_ota_addr = conn->bhc_peer_addr;
- break;
-
- case BLE_ADDR_TYPE_RANDOM:
- addrs->peer_id_addr_type = BLE_ADDR_TYPE_RANDOM;
- addrs->peer_ota_addr = conn->bhc_peer_addr;
+ addrs->peer_ota_addr = conn->bhc_peer_addr;
+ switch (conn->bhc_peer_addr.type) {
+ case BLE_ADDR_PUBLIC:
+ case BLE_ADDR_RANDOM:
break;
- case BLE_ADDR_TYPE_RPA_PUB_DEFAULT:
- addrs->peer_id_addr_type = BLE_ADDR_TYPE_PUBLIC;
+ case BLE_ADDR_PUBLIC_ID:
+ addrs->peer_id_addr.type = BLE_ADDR_PUBLIC;
addrs->peer_ota_addr = conn->bhc_peer_rpa_addr;
break;
- case BLE_ADDR_TYPE_RPA_RND_DEFAULT:
- addrs->peer_id_addr_type = BLE_ADDR_TYPE_RANDOM;
+ case BLE_ADDR_RANDOM_ID:
+ addrs->peer_id_addr.type = BLE_ADDR_RANDOM;
addrs->peer_ota_addr = conn->bhc_peer_rpa_addr;
break;
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/net/nimble/host/src/ble_hs_conn_priv.h
----------------------------------------------------------------------
diff --git a/net/nimble/host/src/ble_hs_conn_priv.h b/net/nimble/host/src/ble_hs_conn_priv.h
index 1a96b3c..904aa3c 100644
--- a/net/nimble/host/src/ble_hs_conn_priv.h
+++ b/net/nimble/host/src/ble_hs_conn_priv.h
@@ -40,11 +40,10 @@ typedef uint8_t ble_hs_conn_flags_t;
struct ble_hs_conn {
SLIST_ENTRY(ble_hs_conn) bhc_next;
uint16_t bhc_handle;
- uint8_t bhc_peer_addr_type;
uint8_t bhc_our_addr_type;
- uint8_t bhc_peer_addr[6];
- uint8_t bhc_our_rpa_addr[6];
- uint8_t bhc_peer_rpa_addr[6];
+ ble_addr_t bhc_peer_addr;
+ ble_addr_t bhc_our_rpa_addr;
+ ble_addr_t bhc_peer_rpa_addr;
uint16_t bhc_itvl;
uint16_t bhc_latency;
@@ -68,14 +67,10 @@ struct ble_hs_conn {
};
struct ble_hs_conn_addrs {
- uint8_t our_ota_addr_type;
- uint8_t our_id_addr_type;
- uint8_t peer_ota_addr_type;
- uint8_t peer_id_addr_type;
- const uint8_t *our_ota_addr;
- const uint8_t *our_id_addr;
- const uint8_t *peer_ota_addr;
- const uint8_t *peer_id_addr;
+ ble_addr_t our_id_addr;
+ ble_addr_t peer_id_addr;
+ ble_addr_t our_ota_addr;
+ ble_addr_t peer_ota_addr;
};
int ble_hs_conn_can_alloc(void);
@@ -85,8 +80,7 @@ void ble_hs_conn_insert(struct ble_hs_conn *conn);
void ble_hs_conn_remove(struct ble_hs_conn *conn);
struct ble_hs_conn *ble_hs_conn_find(uint16_t conn_handle);
struct ble_hs_conn *ble_hs_conn_find_assert(uint16_t conn_handle);
-struct ble_hs_conn *ble_hs_conn_find_by_addr(uint8_t addr_type,
- const uint8_t *addr);
+struct ble_hs_conn *ble_hs_conn_find_by_addr(const ble_addr_t *addr);
struct ble_hs_conn *ble_hs_conn_find_by_idx(int idx);
int ble_hs_conn_exists(uint16_t conn_handle);
struct ble_hs_conn *ble_hs_conn_first(void);
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/net/nimble/host/src/ble_hs_hci_cmd.c
----------------------------------------------------------------------
diff --git a/net/nimble/host/src/ble_hs_hci_cmd.c b/net/nimble/host/src/ble_hs_hci_cmd.c
index d20baf9..bbef1a0 100644
--- a/net/nimble/host/src/ble_hs_hci_cmd.c
+++ b/net/nimble/host/src/ble_hs_hci_cmd.c
@@ -162,7 +162,7 @@ static int
ble_hs_hci_cmd_body_le_whitelist_chg(const uint8_t *addr, uint8_t addr_type,
uint8_t *dst)
{
- if (addr_type > BLE_ADDR_TYPE_RANDOM) {
+ if (addr_type > BLE_ADDR_RANDOM) {
return BLE_ERR_INV_HCI_CMD_PARMS;
}
@@ -1094,7 +1094,7 @@ ble_hs_hci_cmd_body_add_to_resolv_list(uint8_t addr_type, const uint8_t *addr,
const uint8_t *local_irk,
uint8_t *dst)
{
- if (addr_type > BLE_ADDR_TYPE_RANDOM) {
+ if (addr_type > BLE_ADDR_RANDOM) {
return BLE_ERR_INV_HCI_CMD_PARMS;
}
@@ -1140,7 +1140,7 @@ ble_hs_hci_cmd_body_remove_from_resolv_list(uint8_t addr_type,
const uint8_t *addr,
uint8_t *dst)
{
- if (addr_type > BLE_ADDR_TYPE_RANDOM) {
+ if (addr_type > BLE_ADDR_RANDOM) {
return BLE_ERR_INV_HCI_CMD_PARMS;
}
@@ -1199,7 +1199,7 @@ ble_hs_hci_cmd_body_read_peer_resolv_addr(uint8_t peer_identity_addr_type,
const uint8_t *peer_identity_addr,
uint8_t *dst)
{
- if (peer_identity_addr_type > BLE_ADDR_TYPE_RANDOM) {
+ if (peer_identity_addr_type > BLE_ADDR_RANDOM) {
return BLE_ERR_INV_HCI_CMD_PARMS;
}
@@ -1238,7 +1238,7 @@ ble_hs_hci_cmd_body_read_lcl_resolv_addr(
const uint8_t *local_identity_addr,
uint8_t *dst)
{
- if (local_identity_addr_type > BLE_ADDR_TYPE_RANDOM) {
+ if (local_identity_addr_type > BLE_ADDR_RANDOM) {
return BLE_ERR_INV_HCI_CMD_PARMS;
}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/net/nimble/host/src/ble_hs_hci_evt.c
----------------------------------------------------------------------
diff --git a/net/nimble/host/src/ble_hs_hci_evt.c b/net/nimble/host/src/ble_hs_hci_evt.c
index d622950..a2d7a52 100644
--- a/net/nimble/host/src/ble_hs_hci_evt.c
+++ b/net/nimble/host/src/ble_hs_hci_evt.c
@@ -377,9 +377,7 @@ ble_hs_hci_evt_le_adv_rpt(uint8_t subevent, uint8_t *data, int len)
return rc;
}
- /* Direct address fields not present in a standard advertising report. */
- desc.direct_addr_type = BLE_GAP_ADDR_TYPE_NONE;
- memset(desc.direct_addr, 0, sizeof desc.direct_addr);
+ desc.direct_addr = *BLE_ADDR_ANY;
data_off = 0;
for (i = 0; i < num_reports; i++) {
@@ -390,11 +388,11 @@ ble_hs_hci_evt_le_adv_rpt(uint8_t subevent, uint8_t *data, int len)
suboff++;
off = 2 + suboff * num_reports + i;
- desc.addr_type = data[off];
+ desc.addr.type = data[off];
suboff++;
off = 2 + suboff * num_reports + i * 6;
- memcpy(desc.addr, data + off, 6);
+ memcpy(desc.addr.val, data + off, 6);
suboff += 6;
off = 2 + suboff * num_reports + i;
@@ -444,19 +442,19 @@ ble_hs_hci_evt_le_dir_adv_rpt(uint8_t subevent, uint8_t *data, int len)
suboff++;
off = 2 + suboff * num_reports + i;
- desc.addr_type = data[off];
+ desc.addr.type = data[off];
suboff++;
off = 2 + suboff * num_reports + i * 6;
- memcpy(desc.addr, data + off, 6);
+ memcpy(desc.addr.val, data + off, 6);
suboff += 6;
off = 2 + suboff * num_reports + i;
- desc.direct_addr_type = data[off];
+ desc.direct_addr.type = data[off];
suboff++;
off = 2 + suboff * num_reports + i * 6;
- memcpy(desc.direct_addr, data + off, 6);
+ memcpy(desc.direct_addr.val, data + off, 6);
suboff += 6;
off = 2 + suboff * num_reports + i;
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/net/nimble/host/src/ble_hs_id.c
----------------------------------------------------------------------
diff --git a/net/nimble/host/src/ble_hs_id.c b/net/nimble/host/src/ble_hs_id.c
index d338f04..5c3fae0 100644
--- a/net/nimble/host/src/ble_hs_id.c
+++ b/net/nimble/host/src/ble_hs_id.c
@@ -46,19 +46,21 @@ ble_hs_id_set_pub(const uint8_t *pub_addr)
* @return 0 on success; nonzero on failure.
*/
int
-ble_hs_id_gen_rnd(int nrpa, uint8_t *out_addr)
+ble_hs_id_gen_rnd(int nrpa, ble_addr_t *out_addr)
{
int rc;
- rc = ble_hs_hci_util_rand(out_addr, 6);
+ out_addr->type = BLE_ADDR_RANDOM;
+
+ rc = ble_hs_hci_util_rand(out_addr->val, 6);
if (rc != 0) {
return rc;
}
if (nrpa) {
- out_addr[5] &= ~0xc0;
+ out_addr->val[5] &= ~0xc0;
} else {
- out_addr[5] |= 0xc0;
+ out_addr->val[5] |= 0xc0;
}
return 0;
@@ -112,8 +114,8 @@ done:
*
* @param id_addr_type The type of identity address to retrieve.
* Valid values are:
- * o BLE_ADDR_TYPE_PUBLIC
- * o BLE_ADDR_TYPE_RANDOM
+ * o BLE_ADDR_PUBLIC
+ * o BLE_ADDR_RANDOM
* @param out_id_addr On success, this is reseated to point to the
* retrieved 6-byte identity address.
* @param out_is_nrpa On success, the pointed-to value indicates
@@ -137,12 +139,12 @@ ble_hs_id_addr(uint8_t id_addr_type, const uint8_t **out_id_addr,
BLE_HS_DBG_ASSERT(ble_hs_locked_by_cur_task());
switch (id_addr_type) {
- case BLE_ADDR_TYPE_PUBLIC:
+ case BLE_ADDR_PUBLIC:
id_addr = ble_hs_id_pub;
nrpa = 0;
break;
- case BLE_ADDR_TYPE_RANDOM:
+ case BLE_ADDR_RANDOM:
id_addr = ble_hs_id_rnd;
nrpa = (ble_hs_id_rnd[5] & 0xc0) == 0;
break;
@@ -172,8 +174,8 @@ ble_hs_id_addr(uint8_t id_addr_type, const uint8_t **out_id_addr,
*
* @param id_addr_type The type of identity address to retrieve.
* Valid values are:
- * o BLE_ADDR_TYPE_PUBLIC
- * o BLE_ADDR_TYPE_RANDOM
+ * o BLE_ADDR_PUBLIC
+ * o BLE_ADDR_RANDOM
* @param out_id_addr On success, the requested identity address is
* copied into this buffer. The buffer must
* be at least six bytes in size.
@@ -215,16 +217,16 @@ ble_hs_id_use_addr(uint8_t addr_type)
int rc;
switch (addr_type) {
- case BLE_ADDR_TYPE_PUBLIC:
- case BLE_ADDR_TYPE_RANDOM:
+ case BLE_OWN_ADDR_PUBLIC:
+ case BLE_OWN_ADDR_RANDOM:
rc = ble_hs_id_addr(addr_type, NULL, NULL);
if (rc != 0) {
return rc;
}
break;
- case BLE_ADDR_TYPE_RPA_PUB_DEFAULT:
- case BLE_ADDR_TYPE_RPA_RND_DEFAULT:
+ case BLE_OWN_ADDR_RPA_PUBLIC_DEFAULT:
+ case BLE_OWN_ADDR_RPA_RANDOM_DEFAULT:
id_addr_type = ble_hs_misc_addr_type_to_id(addr_type);
rc = ble_hs_id_addr(id_addr_type, NULL, &nrpa);
if (rc != 0) {
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/net/nimble/host/src/ble_hs_misc.c
----------------------------------------------------------------------
diff --git a/net/nimble/host/src/ble_hs_misc.c b/net/nimble/host/src/ble_hs_misc.c
index 7827ba8..1c85c51 100644
--- a/net/nimble/host/src/ble_hs_misc.c
+++ b/net/nimble/host/src/ble_hs_misc.c
@@ -81,16 +81,16 @@ uint8_t
ble_hs_misc_addr_type_to_id(uint8_t addr_type)
{
switch (addr_type) {
- case BLE_ADDR_TYPE_PUBLIC:
- case BLE_ADDR_TYPE_RPA_PUB_DEFAULT:
- return BLE_ADDR_TYPE_PUBLIC;
+ case BLE_ADDR_PUBLIC:
+ case BLE_ADDR_PUBLIC_ID:
+ return BLE_ADDR_PUBLIC;
- case BLE_ADDR_TYPE_RANDOM:
- case BLE_ADDR_TYPE_RPA_RND_DEFAULT:
- return BLE_ADDR_TYPE_RANDOM;
+ case BLE_ADDR_RANDOM:
+ case BLE_ADDR_RANDOM_ID:
+ return BLE_ADDR_RANDOM;
default:
BLE_HS_DBG_ASSERT(0);
- return BLE_ADDR_TYPE_PUBLIC;
+ return BLE_ADDR_PUBLIC;
}
}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/6d0e7fb8/net/nimble/host/src/ble_sm.c
----------------------------------------------------------------------
diff --git a/net/nimble/host/src/ble_sm.c b/net/nimble/host/src/ble_sm.c
index 3e05f7c..c19c80b 100644
--- a/net/nimble/host/src/ble_sm.c
+++ b/net/nimble/host/src/ble_sm.c
@@ -446,8 +446,8 @@ ble_sm_fill_store_value(uint8_t peer_addr_type, uint8_t *peer_addr,
{
memset(value_sec, 0, sizeof *value_sec);
- value_sec->peer_addr_type = peer_addr_type;
- memcpy(value_sec->peer_addr, peer_addr, sizeof value_sec->peer_addr);
+ value_sec->peer_addr.type = peer_addr_type;
+ memcpy(value_sec->peer_addr.val, peer_addr, sizeof value_sec->peer_addr);
if (keys->ediv_rand_valid && keys->ltk_valid) {
value_sec->key_size = keys->key_size;
@@ -484,17 +484,17 @@ ble_sm_ia_ra(struct ble_sm_proc *proc,
ble_hs_conn_addrs(conn, &addrs);
if (proc->flags & BLE_SM_PROC_F_INITIATOR) {
- *out_iat = addrs.our_ota_addr_type;
- memcpy(out_ia, addrs.our_ota_addr, 6);
+ *out_iat = addrs.our_ota_addr.type;
+ memcpy(out_ia, addrs.our_ota_addr.val, 6);
- *out_rat = addrs.peer_ota_addr_type;
- memcpy(out_ra, addrs.peer_ota_addr, 6);
+ *out_rat = addrs.peer_ota_addr.type;
+ memcpy(out_ra, addrs.peer_ota_addr.val, 6);
} else {
- *out_iat = addrs.peer_ota_addr_type;
- memcpy(out_ia, addrs.peer_ota_addr, 6);
+ *out_iat = addrs.peer_ota_addr.type;
+ memcpy(out_ia, addrs.peer_ota_addr.val, 6);
- *out_rat = addrs.our_ota_addr_type;
- memcpy(out_ra, addrs.our_ota_addr, 6);
+ *out_rat = addrs.our_ota_addr.type;
+ memcpy(out_ra, addrs.our_ota_addr.val, 6);
}
}
@@ -503,8 +503,7 @@ ble_sm_persist_keys(struct ble_sm_proc *proc)
{
struct ble_store_value_sec value_sec;
struct ble_hs_conn *conn;
- uint8_t peer_addr[6];
- uint8_t peer_addr_type;
+ ble_addr_t peer_addr;
int authenticated;
ble_hs_lock();
@@ -514,22 +513,22 @@ ble_sm_persist_keys(struct ble_sm_proc *proc)
/* If we got an identity address, use that for key storage. */
if (proc->peer_keys.addr_valid) {
- peer_addr_type = proc->peer_keys.addr_type;
- memcpy(peer_addr, proc->peer_keys.addr, sizeof peer_addr);
+ peer_addr.type = proc->peer_keys.addr_type;
+ memcpy(peer_addr.val, proc->peer_keys.addr, sizeof peer_addr);
} else {
- peer_addr_type = ble_hs_misc_addr_type_to_id(conn->bhc_peer_addr_type);
- memcpy(peer_addr, conn->bhc_peer_addr, sizeof peer_addr);
+ peer_addr = conn->bhc_peer_addr;
+ peer_addr.type = ble_hs_misc_addr_type_to_id(conn->bhc_peer_addr.type);
}
ble_hs_unlock();
authenticated = proc->flags & BLE_SM_PROC_F_AUTHENTICATED;
- ble_sm_fill_store_value(peer_addr_type, peer_addr, authenticated,
+ ble_sm_fill_store_value(peer_addr.type, peer_addr.val, authenticated,
&proc->our_keys, &value_sec);
ble_store_write_our_sec(&value_sec);
- ble_sm_fill_store_value(peer_addr_type, peer_addr, authenticated,
+ ble_sm_fill_store_value(peer_addr.type, peer_addr.val, authenticated,
&proc->peer_keys, &value_sec);
ble_store_write_peer_sec(&value_sec);
}
@@ -1031,8 +1030,8 @@ ble_sm_retrieve_ltk(struct hci_le_lt_key_req *evt, uint8_t peer_addr_type,
/* Tell applicaiton to look up LTK by peer address and ediv/rand pair. */
memset(&key_sec, 0, sizeof key_sec);
- key_sec.peer_addr_type = peer_addr_type;
- memcpy(key_sec.peer_addr, peer_addr, 6);
+ key_sec.peer_addr.type = peer_addr_type;
+ memcpy(key_sec.peer_addr.val, peer_addr, 6);
key_sec.ediv = evt->encrypted_diversifier;
key_sec.rand_num = evt->random_number;
key_sec.ediv_rand_present = 1;
@@ -1204,7 +1203,7 @@ ble_sm_ltk_req_rx(struct hci_le_lt_key_req *evt)
if (restore) {
conn = ble_hs_conn_find_assert(evt->connection_handle);
ble_hs_conn_addrs(conn, &addrs);
- memcpy(peer_id_addr, addrs.peer_id_addr, 6);
+ memcpy(peer_id_addr, addrs.peer_id_addr.val, 6);
}
ble_hs_unlock();
@@ -1215,7 +1214,7 @@ ble_sm_ltk_req_rx(struct hci_le_lt_key_req *evt)
if (res.app_status == 0) {
if (restore) {
- store_rc = ble_sm_retrieve_ltk(evt, addrs.peer_id_addr_type,
+ store_rc = ble_sm_retrieve_ltk(evt, addrs.peer_id_addr.type,
peer_id_addr, &value_sec);
if (store_rc == 0) {
/* Send the key to the controller. */
@@ -1666,8 +1665,7 @@ ble_sm_sec_req_rx(uint16_t conn_handle, struct os_mbuf **om,
*/
ble_hs_conn_addrs(conn, &addrs);
memset(&key_sec, 0, sizeof key_sec);
- key_sec.peer_addr_type = addrs.peer_id_addr_type;
- memcpy(key_sec.peer_addr, addrs.peer_id_addr, 6);
+ key_sec.peer_addr = addrs.peer_id_addr;;
}
ble_hs_unlock();
@@ -1825,8 +1823,8 @@ ble_sm_key_exch_exec(struct ble_sm_proc *proc, struct ble_sm_result *res,
conn = ble_hs_conn_find_assert(proc->conn_handle);
ble_hs_conn_addrs(conn, &addrs);
- addr_info->addr_type = addrs.our_id_addr_type;
- memcpy(addr_info->bd_addr, addrs.our_id_addr, 6);
+ addr_info->addr_type = addrs.our_id_addr.type;
+ memcpy(addr_info->bd_addr, addrs.our_id_addr.val, 6);
proc->our_keys.addr_valid = 1;
memcpy(proc->our_keys.irk, irk, 16);
@@ -2277,8 +2275,8 @@ ble_sm_unbond(uint8_t peer_id_addr_type, const uint8_t *peer_id_addr)
int rc;
memset(&key_sec, 0, sizeof key_sec);
- key_sec.peer_addr_type = peer_id_addr_type;
- memcpy(key_sec.peer_addr, peer_id_addr, sizeof key_sec.peer_addr);
+ key_sec.peer_addr.type = peer_id_addr_type;
+ memcpy(key_sec.peer_addr.val, peer_id_addr, sizeof key_sec.peer_addr);
our_rc = ble_store_delete_our_sec(&key_sec);
peer_rc = ble_store_delete_peer_sec(&key_sec);