ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

[nRF5_SDK13] Changes from CR. 

- fix typso, renaming, repharse commnets.
- fix alghoritm of white/id lists setup functions in nRF5xGap class.
pull/3841/head
Andrzej Puzdrowski 2017-02-06 12:12:26 +01:00
parent 113ae4e06b
commit 3a81e23cf2
3 changed files with 74 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

90
features/FEATURE_BLE/targets/TARGET_NORDIC/TARGET_NRF5_SDK13/source/nRF5xGap.cpp
View File

@ -198,7 +198,7 @@ ble_error_t nRF5xGap::startAdvertising(const GapAdvertisingParams &params)
adv_para.p_whitelist = &whitelist; adv_para.p_whitelist = &whitelist;
#else #else
err = updateWhiteAndIdentityListInStack(nRF5xGap::avdvertising_purpose); err = updateWhiteAndIdentityListInStack(nRF5xGap::purpose_avdvertising);
if (err != BLE_ERROR_NONE) { if (err != BLE_ERROR_NONE) {
return (ble_error_t)err; return (ble_error_t)err;
@ -254,7 +254,7 @@ ble_error_t nRF5xGap::startRadioScan(const GapScanningParams &scanningParams)
scanParams.selective = scanningPolicyMode; /**< If 1, ignore unknown devices (non whitelisted). */ scanParams.selective = scanningPolicyMode; /**< If 1, ignore unknown devices (non whitelisted). */
scanParams.p_whitelist = &whitelist; /**< Pointer to whitelist, NULL if none is given. */ scanParams.p_whitelist = &whitelist; /**< Pointer to whitelist, NULL if none is given. */
#else #else
uint32_t err = updateWhiteAndIdentityListInStack(nRF5xGap::scan_connect_purpose); uint32_t err = updateWhiteAndIdentityListInStack(nRF5xGap::purpose_scan_connect);
if (err != BLE_ERROR_NONE) { if (err != BLE_ERROR_NONE) {
return (ble_error_t)err; return (ble_error_t)err;
@ -358,7 +358,7 @@ ble_error_t nRF5xGap::connect(const Address_t peerAddr,
scanParams.selective = scanningPolicyMode; /**< If 1, ignore unknown devices (non whitelisted). */ scanParams.selective = scanningPolicyMode; /**< If 1, ignore unknown devices (non whitelisted). */
scanParams.p_whitelist = &whitelist; /**< Pointer to whitelist, NULL if none is given. */ scanParams.p_whitelist = &whitelist; /**< Pointer to whitelist, NULL if none is given. */
#else #else
uint32_t err = updateWhiteAndIdentityListInStack(nRF5xGap::scan_connect_purpose); uint32_t err = updateWhiteAndIdentityListInStack(nRF5xGap::purpose_scan_connect);
if (err != BLE_ERROR_NONE) { if (err != BLE_ERROR_NONE) {
return (ble_error_t)err; return (ble_error_t)err;
@ -366,11 +366,12 @@ ble_error_t nRF5xGap::connect(const Address_t peerAddr,
scanParams.use_whitelist = (whitelistAddressesSize) ? 1 : 0; scanParams.use_whitelist = (whitelistAddressesSize) ? 1 : 0;
if (addr.addr_type == ADDR_TYPE_RANDOM_PRIVATE_RESOLVABLE || addr.addr_type == ADDR_TYPE_RANDOM_PRIVATE_NON_RESOLVABLE) { if ((addr.addr_type == BLE_GAP_ADDR_TYPE_RANDOM_PRIVATE_RESOLVABLE)
|| (addr.addr_type == BLE_GAP_ADDR_TYPE_RANDOM_PRIVATE_NON_RESOLVABLE)) {
/* If a device is using Resolvable Private Addresses Section 1.3.2.2 (Core spec v4.2 volume 6 part B), /* If a device is using Resolvable Private Addresses Section 1.3.2.2 (Core spec v4.2 volume 6 part B),
it shall also have an Identity Address that is either a Public or Random Static address type.” it shall also have an Identity Address that is either a Public or Random Static address type.”
For connecting a static address must be provided by the application to the softdevice. To establish a connection, a static address must be provided by the application to the SoftDevice.
The softdevice will resolve the address and connect to the right device if present. */ The SoftDevice resolves the address and connects to the right device if it is available. */
addr.addr_id_peer = 1; addr.addr_id_peer = 1;
addr.addr_type = BLE_GAP_ADDR_TYPE_PUBLIC; addr.addr_type = BLE_GAP_ADDR_TYPE_PUBLIC;
} else { } else {
@ -1031,35 +1032,27 @@ ble_error_t nRF5xGap::generateStackWhitelist(ble_gap_whitelist_t &whitelist)
#if (NRF_SD_BLE_API_VERSION >= 3) #if (NRF_SD_BLE_API_VERSION >= 3)
/** /**
* Fuction for preparing setting of the whitelist-feature and identiti-reseolv-feature (privacy) for SoftDevice. * Function for preparing settings of the whitelist feature and the identity-resolving feature (privacy) for the SoftDevice.
* *
* Gap::setWhitelist provide base for prepartion of this settings. * Gap::setWhitelist provides the base for preparation of these settings.
* This funtion matches resolvabele addreses (pased by Gap::setWhitelist) to IRK datas in boonds table. * This function matches resolvable addresses (passed by Gap::setWhitelist) to IRK data in bonds table.
* Therefore resovable addresses instead of being passed to the whitelist (intended to be passed to Softdevice) * Therefore resolvable addresses instead of being passed to the whitelist (intended to be passed to the Softdevice)
* are passed to the identities list (intended to be passed to Softdevice). * are passed to the identities list (intended to be passed to the Softdevice).
* *
* @param[out] gapAdrHelper Reference to the struct for storing settings. * @param[out] gapAdrHelper Reference to the struct for storing settings.
*/ */
ble_error_t nRF5xGap::getStackWhiteIdentityList(GapWhiteAndIdentityList_t &gapAdrHelper) ble_error_t nRF5xGap::getStackWhiteIdentityList(GapWhiteAndIdentityList_t &gapAdrHelper)
{ {
uint32_t peers_to_check = pm_peer_count();
pm_peer_id_t peer_id; pm_peer_id_t peer_id;
ret_code_t ret; ret_code_t ret;
pm_peer_data_bonding_t bond_data; pm_peer_data_bonding_t bond_data;
pm_peer_data_t peer_data;
uint32_t const buf_size = sizeof(bond_data);
memset(&peer_data, 0x00, sizeof(peer_data)); uint8_t irk_found[YOTTA_CFG_WHITELIST_MAX_SIZE];
peer_data.p_bonding_data = &bond_data;
memset(irk_found, 0x00, sizeof(irk_found));
uint8_t irk_fund[YOTTA_CFG_WHITELIST_MAX_SIZE];
memset(irk_fund, 0x00, sizeof(irk_fund));
gapAdrHelper.identities_cnt = 0; gapAdrHelper.identities_cnt = 0;
@ -1074,18 +1067,17 @@ ble_error_t nRF5xGap::getStackWhiteIdentityList(GapWhiteAndIdentityList_t &gapAd
* For every private resolvable address in the bond table check if * For every private resolvable address in the bond table check if
* there is maching address in th provided whitelist. * there is maching address in th provided whitelist.
*/ */
while ((peer_id != PM_PEER_ID_INVALID) && (peers_to_check--)) while (peer_id != PM_PEER_ID_INVALID)
{ {
memset(&bond_data, 0x00, sizeof(bond_data)); memset(&bond_data, 0x00, sizeof(bond_data));
// Read peer data from flash. // Read peer data from flash.
ret = pds_peer_data_read(peer_id, PM_PEER_DATA_ID_BONDING, ret = pm_peer_data_bonding_load(peer_id, &bond_data);
&peer_data, &buf_size);
if ((ret == NRF_ERROR_NOT_FOUND) || (ret == NRF_ERROR_INVALID_PARAM)) if ((ret == NRF_ERROR_NOT_FOUND) || (ret == NRF_ERROR_INVALID_PARAM))
{ {
// Peer data coulnd't be found in flash or peer ID is not valid. // Peer data could not be found in flash or peer ID is not valid.
return BLE_ERROR_UNSPECIFIED; return BLE_ERROR_UNSPECIFIED;
} }
@ -1093,7 +1085,7 @@ ble_error_t nRF5xGap::getStackWhiteIdentityList(GapWhiteAndIdentityList_t &gapAd
{ {
for (uint8_t i = 0; i < whitelistAddressesSize; ++i) for (uint8_t i = 0; i < whitelistAddressesSize; ++i)
{ {
if (!irk_fund[i]) if (!irk_found[i])
{ {
if (whitelistAddresses[i].addr_type == BLEProtocol::AddressType::RANDOM_PRIVATE_RESOLVABLE) if (whitelistAddresses[i].addr_type == BLEProtocol::AddressType::RANDOM_PRIVATE_RESOLVABLE)
{ {
@ -1102,11 +1094,10 @@ ble_error_t nRF5xGap::getStackWhiteIdentityList(GapWhiteAndIdentityList_t &gapAd
if (securityManager.matchAddressAndIrk(&whitelistAddresses[i], &bond_data.peer_ble_id.id_info)) if (securityManager.matchAddressAndIrk(&whitelistAddresses[i], &bond_data.peer_ble_id.id_info))
{ {
// Copy data to the buffer. // Copy data to the buffer.
memcpy(&gapAdrHelper.identity[i], &bond_data.peer_ble_id, sizeof(ble_gap_id_key_t)); memcpy(&gapAdrHelper.identities[i], &bond_data.peer_ble_id, sizeof(ble_gap_id_key_t));
gapAdrHelper.pp_identities[i] = &gapAdrHelper.identity[i];
gapAdrHelper.identities_cnt++; gapAdrHelper.identities_cnt++;
irk_fund[i] = 1; // don't look at this address again irk_found[i] = 1; // don't look at this address again
} }
} }
} }
@ -1117,39 +1108,52 @@ ble_error_t nRF5xGap::getStackWhiteIdentityList(GapWhiteAndIdentityList_t &gapAd
peer_id = pm_next_peer_id_get(peer_id); peer_id = pm_next_peer_id_get(peer_id);
} }
gapAdrHelper.addr_cnt = 0; gapAdrHelper.addrs_cnt = 0;
/** /**
* Bulida whitelist from the rest of addresses (explicite addressess6) * Build whitelist from the rest of addresses (explicit addresses)
*/ */
for (uint8_t i = 0; i < whitelistAddressesSize; ++i) for (uint8_t i = 0; i < whitelistAddressesSize; ++i)
{ {
if (!irk_fund[i]) if (!irk_found[i])
{ {
memcpy(&gapAdrHelper.addr[i], &bond_data.peer_ble_id.id_addr_info, sizeof(ble_gap_addr_t)); memcpy(&gapAdrHelper.addrs[i], &whitelistAddresses[i], sizeof(ble_gap_addr_t));
gapAdrHelper.pp_addr[i] = &gapAdrHelper.addr[i]; gapAdrHelper.addrs_cnt++;
gapAdrHelper.addr_cnt++;
} }
} }
return BLE_ERROR_NONE; return BLE_ERROR_NONE;
} }
ble_error_t nRF5xGap::apllyWhiteIdentityList(GapWhiteAndIdentityList_t &gapAdrHelper) ble_error_t nRF5xGap::applyWhiteIdentityList(GapWhiteAndIdentityList_t &gapAdrHelper)
{ {
uint32_t retc; uint32_t retc;
if (gapAdrHelper.identities_cnt == 0) { if (gapAdrHelper.identities_cnt == 0) {
retc = sd_ble_gap_device_identities_set(NULL, NULL, 0); retc = sd_ble_gap_device_identities_set(NULL, NULL, 0);
} else { } else {
retc = sd_ble_gap_device_identities_set(gapAdrHelper.pp_identities, NULL /* Don't use local IRKs*/,gapAdrHelper.identities_cnt); ble_gap_id_key_t * pp_identities[YOTTA_CFG_IRK_TABLE_MAX_SIZE];
for (uint32_t i = 0; i < gapAdrHelper.identities_cnt; ++i)
{
pp_identities[i] = &gapAdrHelper.identities[i];
}
retc = sd_ble_gap_device_identities_set(pp_identities, NULL /* Don't use local IRKs*/,gapAdrHelper.identities_cnt);
} }
if (retc == NRF_SUCCESS) { if (retc == NRF_SUCCESS) {
if (gapAdrHelper.addr_cnt == 0) { if (gapAdrHelper.addrs_cnt == 0) {
retc = sd_ble_gap_whitelist_set(NULL, 0); retc = sd_ble_gap_whitelist_set(NULL, 0);
} else { } else {
retc = sd_ble_gap_whitelist_set(gapAdrHelper.pp_addr, gapAdrHelper.addr_cnt); ble_gap_addr_t * pp_addrs[YOTTA_CFG_IRK_TABLE_MAX_SIZE];
for (uint32_t i = 0; i < gapAdrHelper.addrs_cnt; ++i)
{
pp_addrs[i] = &gapAdrHelper.addrs[i];
}
retc = sd_ble_gap_whitelist_set(pp_addrs, gapAdrHelper.addrs_cnt);
} }
} }
@ -1178,9 +1182,9 @@ ble_error_t nRF5xGap::updateWhiteAndIdentityListInStack(whiteAndIdentityListPurp
uint32_t err; uint32_t err;
bool provide_settings; bool provide_settings;
if (purpose == nRF5xGap::avdvertising_purpose) { if (purpose == nRF5xGap::purpose_avdvertising) {
provide_settings = (advertisingPolicyMode != Gap::ADV_POLICY_IGNORE_WHITELIST) ? true : false; provide_settings = (advertisingPolicyMode != Gap::ADV_POLICY_IGNORE_WHITELIST) ? true : false;
} else { //it must be nRF5xGap::scan_connect_purpose } else { //It must be nRF5xGap::purpose_scan_connect.
provide_settings = (scanningPolicyMode != Gap::SCAN_POLICY_IGNORE_WHITELIST) ? true : false; provide_settings = (scanningPolicyMode != Gap::SCAN_POLICY_IGNORE_WHITELIST) ? true : false;
} }
@ -1193,11 +1197,11 @@ ble_error_t nRF5xGap::updateWhiteAndIdentityListInStack(whiteAndIdentityListPurp
return (ble_error_t)err; return (ble_error_t)err;
} }
} else { } else {
whiteAndIdentityList.addr_cnt = 0; whiteAndIdentityList.addrs_cnt = 0;
whiteAndIdentityList.identities_cnt = 0; whiteAndIdentityList.identities_cnt = 0;
} }
return apllyWhiteIdentityList(whiteAndIdentityList); return applyWhiteIdentityList(whiteAndIdentityList);
} }
#endif #endif

29
features/FEATURE_BLE/targets/TARGET_NORDIC/TARGET_NRF5_SDK13/source/nRF5xGap.h
View File

@ -150,30 +150,33 @@ private:
#endif #endif
#if (NRF_SD_BLE_API_VERSION >= 3) #if (NRF_SD_BLE_API_VERSION >= 3)
/* internal type for pasing whitelist and identities list */ /* internal type for passing a whitelist and a identities list. */
typedef struct typedef struct
{ {
ble_gap_addr_t addr[YOTTA_CFG_WHITELIST_MAX_SIZE]; ble_gap_addr_t addrs[YOTTA_CFG_WHITELIST_MAX_SIZE];
ble_gap_addr_t * pp_addr[YOTTA_CFG_WHITELIST_MAX_SIZE]; uint32_t addrs_cnt;
uint32_t addr_cnt;
ble_gap_id_key_t identity[YOTTA_CFG_IRK_TABLE_MAX_SIZE]; ble_gap_id_key_t identities[YOTTA_CFG_IRK_TABLE_MAX_SIZE];
ble_gap_id_key_t * pp_identities[YOTTA_CFG_IRK_TABLE_MAX_SIZE];
uint32_t identities_cnt; uint32_t identities_cnt;
} GapWhiteAndIdentityList_t; } GapWhiteAndIdentityList_t;
/* purpouse of updation the whitelist and identities settings */ /* purpose of updating the whitelist and identities settings. */
enum whiteAndIdentityListPurpose_t enum whiteAndIdentityListPurpose_t
{ {
scan_connect_purpose = 0, purpose_scan_connect = 0,
avdvertising_purpose purpose_avdvertising
} whiteAndIdentityListPurpose; } whiteAndIdentityListPurpose;
/* Fuction for preparing setting of the whitelist-feature and identiti-reseolv-feature (privacy).*/ /* Function for preparing setting of the whitelist feature and the identity-resolving feature (privacy).*/
ble_error_t getStackWhiteIdentityList(GapWhiteAndIdentityList_t &whiteAndIdentityList); ble_error_t getStackWhiteIdentityList(GapWhiteAndIdentityList_t &whiteAndIdentityList);
/* Fuction for apllying setting of the whitelist-feature and identiti-reseolv-feature (privacy).*/
ble_error_t apllyWhiteIdentityList(GapWhiteAndIdentityList_t &whiteAndIdentityList); /* Function for applying setting of the whitelist feature and identity-resolving feature (privacy).*/
/* Fuction which incorportes 2 above f. together */ ble_error_t applyWhiteIdentityList(GapWhiteAndIdentityList_t &whiteAndIdentityList);
/* Function for introducing whitelist feature and the identity-resolving feature setting into SoftDevice.
*
* Introduced settings are comply which scanning or advertising policies.
* This function incorporates getStackWhiteIdentityList and applyWhiteIdentityList together. */
ble_error_t updateWhiteAndIdentityListInStack(whiteAndIdentityListPurpose_t purpose); ble_error_t updateWhiteAndIdentityListInStack(whiteAndIdentityListPurpose_t purpose);
#endif #endif

20
targets/TARGET_NORDIC/TARGET_NRF5_SDK13/sdk/ble/peer_manager/id_manager.h
View File

@ -284,14 +284,14 @@ bool im_address_resolve(ble_gap_addr_t const * p_addr, ble_gap_irk_t const * p_i
* 4.2 section 3.H.2.2.2. * 4.2 section 3.H.2.2.2.
* *
* @detail BLE uses a hash function to calculate the first half of a resolvable address * @detail BLE uses a hash function to calculate the first half of a resolvable address
* from the second half of the address and an irk. This function will use the ECB * from the second half of the address and an IRK. This function uses the ECB
* periferal to hash these data acording to the Bluetooth core specification. * peripheral to hash this data according to the Bluetooth core specification.
* *
* @note The ECB expect little endian input and output. * @note The ECB expects little endian input and output.
* This function expect big endian and will reverse the data as necessary. * This function expects big endian and will reverse the data as necessary.
* *
* @param[in] p_k The key used in the hash function. * @param[in] p_k The key used in the hash function.
* For address resolution this is should be the irk. * For address resolution this must be the IRK.
* The array must have a length of 16. * The array must have a length of 16.
* @param[in] p_r The rand used in the hash function. For generating a new address * @param[in] p_r The rand used in the hash function. For generating a new address
* this would be a random number. For resolving a resolvable address * this would be a random number. For resolving a resolvable address
@ -299,15 +299,15 @@ bool im_address_resolve(ble_gap_addr_t const * p_addr, ble_gap_irk_t const * p_i
* The array must have a length of 3. * The array must have a length of 3.
* @param[out] p_local_hash The result of the hash operation. For address resolution this * @param[out] p_local_hash The result of the hash operation. For address resolution this
* will match the first half of the address being resolved if and only * will match the first half of the address being resolved if and only
* if the irk used in the hash function is the same one used to generate * if the irk used in the hash function is the same one that was used to generate
* the address. * the address.
* The array must have a length of 16. * The array must have a length of 16.
* *
* @note ====IMPORTANT==== * @note ====IMPORTANT====
* This is a special modification to the original nRF5x SDK required by the mbed BLE API * This is a special modification to the original nRF5 SDK. It is required by the mbed BLE API
* to be able to generate BLE private resolvable addresses. This function is used by * to generate BLE private resolvable addresses. This function is used by
* the BLE API implementation for nRF5xSecurityManager::getAddressFromBondTable() in the * the BLE API implementation for nRF5xSecurityManager::getAddressFromBondTable() in the target's
* ble-nrf52832 yotta module. * BLE implementation.
* ================= * =================
*/ */
void ah(uint8_t const * p_k, uint8_t const * p_r, uint8_t * p_local_hash); void ah(uint8_t const * p_k, uint8_t const * p_r, uint8_t * p_local_hash);