nimble/ll: Make public and random addresses private in ble_ll_addr

We should now only use helpers from ble_ll_addr to access public and
random addresses across all LL code.

Author: andrzej-kaczmarek

nimble/controller/include/controller/ble_ll.h

@@ -517,16 +517,6 @@ struct ble_ll_acad_channel_map_update_ind {
 /* Reset the Link Layer */
 int ble_ll_reset(void);
 
-/* 'Boolean' function returning true if address is a valid random address */
-int ble_ll_is_valid_random_addr(const uint8_t *addr);
-
-/*
- * Check if given own_addr_type is valid for current controller configuration
- * given the random address provided (when applicable)
- */
-int ble_ll_is_valid_own_addr_type(uint8_t own_addr_type,
-                                  const uint8_t *random_addr);
-
 /* Calculate maximum octets of PDU payload which can be transmitted during
  * 'usecs' on a PHY 'phy_mode'. */
 uint16_t ble_ll_pdu_max_tx_octets_get(uint32_t usecs, int phy_mode);
@@ -539,12 +529,6 @@ int ble_ll_addr_subtype(const uint8_t *addr, uint8_t addr_type);
 /* Is this address an identity address? */
 int ble_ll_addr_is_id(uint8_t *addr, uint8_t addr_type);
 
-/* Is 'addr' our device address? 'addr_type' is public (0) or random (!=0) */
-int ble_ll_is_our_devaddr(const uint8_t* addr, int addr_type);
-
-/* Get identity address 'addr_type' is public (0) or random (!=0) */
-uint8_t *ble_ll_get_our_devaddr(uint8_t addr_type);
-
 /**
  * Called to put a packet on the Link Layer transmit packet queue.
  *

nimble/controller/include/controller/ble_ll_addr.h

@@ -20,13 +20,25 @@
 #ifndef H_BLE_LL_ADDR_
 #define H_BLE_LL_ADDR_
 
+#include <stdbool.h>
+#include <stdint.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 int ble_ll_addr_init(void);
 int ble_ll_addr_public_set(const uint8_t *addr);
 
+const uint8_t *ble_ll_addr_get(uint8_t addr_type);
+const uint8_t *ble_ll_addr_public_get(void);
+const uint8_t *ble_ll_addr_random_get(void);
+int ble_ll_addr_random_set(const uint8_t *addr);
+
+bool ble_ll_addr_is_our(int addr_type, const uint8_t *addr);
+bool ble_ll_addr_is_valid_own_addr_type(uint8_t addr_type,
+                                        const uint8_t *random_addr);
+
 /* Address provider APIs - should be implemented by packages supporting
  * relevant APIs
  */

nimble/controller/include/controller/ble_ll_conn.h

@@ -483,7 +483,7 @@ void ble_ll_conn_send_connect_req_cancel(void);
 /* Signal connection created via CONNECT_IND */
 void ble_ll_conn_created_on_legacy(struct os_mbuf *rxpdu,
                                    struct ble_ll_scan_addr_data *addrd,
-                                   const uint8_t* targeta);
+                                   const uint8_t *targeta);
 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
 /* Signal connection created via AUX_CONNECT_REQ */
 void ble_ll_conn_created_on_aux(struct os_mbuf *rxpdu,

nimble/controller/src/ble_ll.c

@@ -557,93 +557,11 @@ ble_ll_addr_subtype(const uint8_t *addr, uint8_t addr_type)
     }
 }
 
-static int
-ble_ll_is_valid_addr(const uint8_t *addr)
-{
-    int i;
-
-    for (i = 0; i < BLE_DEV_ADDR_LEN; ++i) {
-        if (addr[i]) {
-            return 1;
-        }
-    }
-
-    return 0;
-}
-
-/* Checks to see that the device is a valid random address */
-int
-ble_ll_is_valid_random_addr(const uint8_t *addr)
-{
-    int i;
-    int rc;
-    uint16_t sum;
-    uint8_t addr_type;
-
-    /* Make sure all bits are neither one nor zero */
-    sum = 0;
-    for (i = 0; i < (BLE_DEV_ADDR_LEN -1); ++i) {
-        sum += addr[i];
-    }
-    sum += addr[5] & 0x3f;
-
-    if ((sum == 0) || (sum == ((5*255) + 0x3f))) {
-        return 0;
-    }
-
-    /* Get the upper two bits of the address */
-    rc = 1;
-    addr_type = addr[5] & 0xc0;
-    if (addr_type == 0xc0) {
-        /* Static random address. No other checks needed */
-    } else if (addr_type == 0x40) {
-        /* Resolvable */
-        sum = addr[3] + addr[4] + (addr[5] & 0x3f);
-        if ((sum == 0) || (sum == (255 + 255 + 0x3f))) {
-            rc = 0;
-        }
-    } else if (addr_type == 0) {
-        /* non-resolvable. Cant be equal to public */
-        if (!memcmp(g_dev_addr, addr, BLE_DEV_ADDR_LEN)) {
-            rc = 0;
-        }
-    } else {
-        /* Invalid upper two bits */
-        rc = 0;
-    }
-
-    return rc;
-}
-int
-ble_ll_is_valid_own_addr_type(uint8_t own_addr_type, const uint8_t *random_addr)
-{
-    int rc;
-
-    switch (own_addr_type) {
-    case BLE_HCI_ADV_OWN_ADDR_PUBLIC:
-#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY)
-    case BLE_HCI_ADV_OWN_ADDR_PRIV_PUB:
-#endif
-        rc = ble_ll_is_valid_addr(g_dev_addr);
-        break;
-    case BLE_HCI_ADV_OWN_ADDR_RANDOM:
-#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY)
-    case BLE_HCI_ADV_OWN_ADDR_PRIV_RAND:
-#endif
-        rc = ble_ll_is_valid_addr(random_addr);
-        break;
-    default:
-        rc = 0;
-        break;
-    }
-
-    return rc;
-}
-
+/* FIXME: remove callers */
 int
 ble_ll_set_public_addr(const uint8_t *addr)
 {
-    memcpy(g_dev_addr, addr, BLE_DEV_ADDR_LEN);
+    ble_ll_addr_public_set(addr);
 
     return BLE_ERR_SUCCESS;
 }
@@ -691,7 +609,7 @@ ble_ll_set_random_addr(const uint8_t *cmdbuf, uint8_t len, bool hci_adv_ext)
     }
 #endif
 
-    memcpy(g_random_addr, cmd->addr, BLE_DEV_ADDR_LEN);
+    ble_ll_addr_random_set(cmd->addr);
 
 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
 #if MYNEWT_VAL(BLE_LL_ROLE_BROADCASTER)
@@ -707,52 +625,6 @@ ble_ll_set_random_addr(const uint8_t *cmdbuf, uint8_t len, bool hci_adv_ext)
     return BLE_ERR_SUCCESS;
 }
 
-/**
- * Checks to see if an address is our device address (either public or
- * random)
- *
- * @param addr
- * @param addr_type
- *
- * @return int 0: not our device address. 1: is our device address
- */
-int
-ble_ll_is_our_devaddr(const uint8_t* addr, int addr_type)
-{
-    int rc;
-    uint8_t *our_addr;
-
-    if (addr_type) {
-        our_addr = g_random_addr;
-    } else {
-        our_addr = g_dev_addr;
-    }
-
-    rc = 0;
-    if (!memcmp(our_addr, addr, BLE_DEV_ADDR_LEN)) {
-        rc = 1;
-    }
-
-    return rc;
-}
-
-/**
- * Get identity address
- *
- * @param addr_type Random (1). Public(0)
- *
- * @return pointer to identity address of given type.
- */
-uint8_t*
-ble_ll_get_our_devaddr(uint8_t addr_type)
-{
-    if (addr_type) {
-        return g_random_addr;
-    }
-
-    return g_dev_addr;
-}
-
 /**
  * Wait for response timeout function
  *

nimble/controller/src/ble_ll_addr.c

@@ -22,13 +22,11 @@
 #include <controller/ble_ll.h>
 #include <controller/ble_ll_addr.h>
 
-/* FIXME: both should be static and accessible only via dedicated set/get APIs;
- *        extern declared in nimble/ble.h should be removed
- */
-uint8_t g_dev_addr[BLE_DEV_ADDR_LEN];
-uint8_t g_random_addr[BLE_DEV_ADDR_LEN];
-
-static uint8_t g_dev_addr_hci[BLE_DEV_ADDR_LEN];
+static struct {
+    uint8_t public_addr[BLE_DEV_ADDR_LEN];
+    uint8_t random_addr[BLE_DEV_ADDR_LEN];
+    uint8_t public_addr_hci[BLE_DEV_ADDR_LEN];
+} g_ble_ll_addr;
 
 static bool
 is_addr_empty(const uint8_t *addr)
@@ -39,11 +37,82 @@ is_addr_empty(const uint8_t *addr)
 int
 ble_ll_addr_public_set(const uint8_t *addr)
 {
-    memcpy(g_dev_addr_hci, addr, BLE_DEV_ADDR_LEN);
+    memcpy(g_ble_ll_addr.public_addr_hci, addr, BLE_DEV_ADDR_LEN);
 
     return 0;
 }
 
+const uint8_t *
+ble_ll_addr_get(uint8_t addr_type)
+{
+    const uint8_t *addr;
+
+    if (addr_type) {
+        addr = g_ble_ll_addr.random_addr;
+    } else {
+        addr = g_ble_ll_addr.public_addr;
+    }
+
+    return addr;
+}
+
+const uint8_t *
+ble_ll_addr_public_get(void)
+{
+    return g_ble_ll_addr.public_addr;
+}
+
+
+const uint8_t *
+ble_ll_addr_random_get(void)
+{
+    return g_ble_ll_addr.random_addr;
+}
+
+int
+ble_ll_addr_random_set(const uint8_t *addr)
+{
+    memcpy(g_ble_ll_addr.random_addr, addr, BLE_DEV_ADDR_LEN);
+
+    return 0;
+}
+
+bool
+ble_ll_addr_is_our(int addr_type, const uint8_t *addr)
+{
+    const uint8_t *our_addr;
+
+    our_addr = ble_ll_addr_get(addr_type);
+
+    return memcmp(our_addr, addr, BLE_DEV_ADDR_LEN) == 0;
+}
+
+bool
+ble_ll_addr_is_valid_own_addr_type(uint8_t addr_type,
+                                   const uint8_t *random_addr)
+{
+    const uint8_t *addr;
+
+    switch (addr_type) {
+    case BLE_HCI_ADV_OWN_ADDR_PUBLIC:
+#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY)
+    case BLE_HCI_ADV_OWN_ADDR_PRIV_PUB:
+#endif
+        addr = ble_ll_addr_public_get();
+        break;
+    case BLE_HCI_ADV_OWN_ADDR_RANDOM:
+#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY)
+    case BLE_HCI_ADV_OWN_ADDR_PRIV_RAND:
+#endif
+        addr = random_addr ? random_addr : ble_ll_addr_random_get();
+        break;
+    default:
+        return false;
+    }
+
+    return !is_addr_empty(addr);
+}
+
 int
 ble_ll_addr_init(void)
 {
@@ -55,24 +124,24 @@ ble_ll_addr_init(void)
      */
     pub_dev_addr = MYNEWT_VAL(BLE_LL_PUBLIC_DEV_ADDR);
     for (i = 0; i < BLE_DEV_ADDR_LEN; i++) {
-        g_dev_addr[i] = pub_dev_addr & 0xff;
+        g_ble_ll_addr.public_addr[i] = pub_dev_addr & 0xff;
         pub_dev_addr >>= 8;
     }
 
-    if (!is_addr_empty(g_dev_addr_hci)) {
+    if (!is_addr_empty(g_ble_ll_addr.public_addr_hci)) {
         /* Use public address set externally */
-        memcpy(g_dev_addr, g_dev_addr_hci, BLE_DEV_ADDR_LEN);
+        memcpy(g_ble_ll_addr.public_addr, g_ble_ll_addr.public_addr_hci, BLE_DEV_ADDR_LEN);
     } else {
         /* Set public address from provider API, if available */
 #if MYNEWT_API_ble_addr_provider_public
-        ble_ll_addr_provide_public(g_dev_addr);
+        ble_ll_addr_provide_public(g_ble_ll_addr.public_addr);
 #endif
     }
 
 #if MYNEWT_VAL(BLE_LL_ADDR_INIT_RANDOM)
     /* Set random address from provider API, if available */
 #if MYNEWT_API_ble_addr_provider_random
-    ble_ll_addr_provide_static(g_random_addr);
+    ble_ll_addr_provide_static(g_ble_ll_addr.random_addr);
 #endif
 #endif