nochanges
Dependents: BLE_Acceleration_Statejudging
Fork of nRF51822 by
Diff: nordic/ble/ble_bondmngr.cpp
- Revision:
- 0:eff01767de02
- Child:
- 32:84dea0924a63
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/nordic/ble/ble_bondmngr.cpp Wed Mar 26 14:38:17 2014 +0000 @@ -0,0 +1,1594 @@ +/* Copyright (c) 2012 Nordic Semiconductor. All Rights Reserved. + * + * The information contained herein is property of Nordic Semiconductor ASA. + * Terms and conditions of usage are described in detail in NORDIC + * SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT. + * + * Licensees are granted free, non-transferable use of the information. NO + * WARRANTY of ANY KIND is provided. This heading must NOT be removed from + * the file. + * + */ + +#include "ble_bondmngr.h" +#include <stdlib.h> +#include <stdint.h> +#include <string.h> +#include "nordic_common.h" +#include "nrf_error.h" +#include "ble_gap.h" +#include "ble_srv_common.h" +#include "app_util.h" +#include "nrf_assert.h" +//#include "nrf.h" +#include "nrf51_bitfields.h" +#include "crc16.h" +#include "pstorage.h" +#include "ble_bondmngr_cfg.h" + +#define CCCD_SIZE 6 /**< Number of bytes needed for storing the state of one CCCD. */ +#define CRC_SIZE 2 /**< Size of CRC in sys_attribute data. */ +#define SYS_ATTR_BUFFER_MAX_LEN (((BLE_BONDMNGR_CCCD_COUNT + 1) * CCCD_SIZE) + CRC_SIZE) /**< Size of sys_attribute data. */ +#define MAX_NUM_CENTRAL_WHITE_LIST MIN(BLE_BONDMNGR_MAX_BONDED_CENTRALS, 8) /**< Maximum number of whitelisted centrals supported.*/ +#define MAX_BONDS_IN_FLASH 10 /**< Maximum number of bonds that can be stored in flash. */ +#define BOND_MANAGER_DATA_SIGNATURE 0x53240000 + +/**@defgroup ble_bond_mngr_sec_access Bond Manager Security Status Access Macros + * @brief The following group of macros abstract access to Security Status with a peer. + * @{ + */ + +#define SEC_STATUS_INIT_VAL 0x00 /**< Initialization value for security status flags. */ +#define ENC_STATUS_SET_VAL 0x01 /**< Bitmask for encryption status. */ +#define BOND_IN_PROGRESS_SET_VAL 0x02 /**< Bitmask for 'bonding in progress'. */ + + +/**@brief Macro for setting the Encryption Status for current link. + * + * @details Macro for setting the Encryption Status for current link. + */ +#define ENCRYPTION_STATUS_SET() \ + do \ + { \ + m_sec_con_status |= ENC_STATUS_SET_VAL; \ + } while (0) + +/**@brief Macro for getting the Encryption Status for current link. + * + * @details Macro for getting the Encryption Status for current link. + */ +#define ENCRYPTION_STATUS_GET() \ + (((m_sec_con_status & ENC_STATUS_SET_VAL) == 0) ? false : true) + +/**@brief Macro for resetting the Encryption Status for current link. + * + * @details Macro for resetting the Encryption Status for current link. + */ +#define ENCRYPTION_STATUS_RESET() \ + do \ + { \ + m_sec_con_status &= (~ENC_STATUS_SET_VAL); \ + } while (0) + + +/**@brief Macro for resetting the Bonding In Progress status for current link. + * + * @details Macro for resetting the Bonding In Progress status for current link. + */ +#define BONDING_IN_PROGRESS_STATUS_SET() \ + do \ + { \ + m_sec_con_status |= BOND_IN_PROGRESS_SET_VAL; \ + } while (0) + +/**@brief Macro for setting the Bonding In Progress status for current link. + * + * @details Macro for setting the Bonding In Progress status for current link. + */ +#define BONDING_IN_PROGRESS_STATUS_GET() \ + (((m_sec_con_status & BOND_IN_PROGRESS_SET_VAL) == 0) ? false: true) + +/**@brief Macro for resetting the Bonding In Progress status for current link. + * + * @details Macro for resetting the Bonding In Progress status for current link. + */ +#define BONDING_IN_PROGRESS_STATUS_RESET() \ + do \ + { \ + m_sec_con_status &= (~BOND_IN_PROGRESS_SET_VAL); \ + } while (0) + +/**@brief Macro for resetting all security status flags for current link. + * + * @details Macro for resetting all security status flags for current link. + */ +#define SECURITY_STATUS_RESET() \ + do \ + { \ + m_sec_con_status = SEC_STATUS_INIT_VAL; \ + } while (0) + +/** @} */ + +/**@brief Verify module's initialization status. + * + * @details Verify module's initialization status. Returns NRF_INVALID_STATE in case a module API + * is called without initializing the module. + */ +#define VERIFY_MODULE_INITIALIZED() \ + do \ + { \ + if (!m_is_bondmngr_initialized) \ + { \ + return NRF_ERROR_INVALID_STATE; \ + } \ + } while(0) + + +/**@brief This structure contains the Bonding Information for one central. + */ +typedef struct +{ + int32_t central_handle; /**< Central's handle (NOTE: Size is 32 bits just to make struct size dividable by 4). */ + ble_gap_evt_auth_status_t auth_status; /**< Central authentication data. */ + ble_gap_evt_sec_info_request_t central_id_info; /**< Central identification info. */ + ble_gap_addr_t central_addr; /**< Central's address. */ +} central_bond_t; + +STATIC_ASSERT(sizeof(central_bond_t) % 4 == 0); + +/**@brief This structure contains the System Attributes information related to one central. + */ +typedef struct +{ + int32_t central_handle; /**< Central's handle (NOTE: Size is 32 bits just to make struct size dividable by 4). */ + uint8_t sys_attr[SYS_ATTR_BUFFER_MAX_LEN]; /**< Central sys_attribute data. */ + uint32_t sys_attr_size; /**< Central sys_attribute data's size (NOTE: Size is 32 bits just to make struct size dividable by 4). */ +} central_sys_attr_t; + +STATIC_ASSERT(sizeof(central_sys_attr_t) % 4 == 0); + +/**@brief This structure contains the Bonding Information and System Attributes related to one + * central. + */ +typedef struct +{ + central_bond_t bond; /**< Bonding information. */ + central_sys_attr_t sys_attr; /**< System attribute information. */ +} central_t; + +/**@brief This structure contains the whitelisted addresses. + */ +typedef struct +{ + int8_t central_handle; /**< Central's handle. */ + ble_gap_addr_t * p_addr; /**< Pointer to the central's address if BLE_GAP_ADDR_TYPE_PUBLIC. */ +} whitelist_addr_t; + +/**@brief This structure contains the whitelisted IRKs. + */ +typedef struct +{ + int8_t central_handle; /**< Central's handle. */ + ble_gap_irk_t * p_irk; /**< Pointer to the central's irk if available. */ +} whitelist_irk_t; + +static bool m_is_bondmngr_initialized = false; /**< Flag for checking if module has been initialized. */ +static ble_bondmngr_init_t m_bondmngr_config; /**< Configuration as specified by the application. */ +static uint16_t m_conn_handle; /**< Current connection handle. */ +static central_t m_central; /**< Current central data. */ +static central_t m_centrals_db[BLE_BONDMNGR_MAX_BONDED_CENTRALS]; /**< Pointer to start of bonded centrals database. */ +static uint8_t m_centrals_in_db_count; /**< Number of bonded centrals. */ +static whitelist_addr_t m_whitelist_addr[MAX_NUM_CENTRAL_WHITE_LIST]; /**< List of central's addresses for the whitelist. */ +static whitelist_irk_t m_whitelist_irk[MAX_NUM_CENTRAL_WHITE_LIST]; /**< List of central's IRKs for the whitelist. */ +static uint8_t m_addr_count; /**< Number of addresses in the whitelist. */ +static uint8_t m_irk_count; /**< Number of IRKs in the whitelist. */ +static uint16_t m_crc_bond_info; /**< Combined CRC for all Bonding Information currently stored in flash. */ +static uint16_t m_crc_sys_attr; /**< Combined CRC for all System Attributes currently stored in flash. */ +static pstorage_handle_t mp_flash_bond_info; /**< Pointer to flash location to write next Bonding Information. */ +static pstorage_handle_t mp_flash_sys_attr; /**< Pointer to flash location to write next System Attribute information. */ +static uint8_t m_bond_info_in_flash_count; /**< Number of Bonding Information currently stored in flash. */ +static uint8_t m_sys_attr_in_flash_count; /**< Number of System Attributes currently stored in flash. */ +static uint8_t m_sec_con_status; /**< Variable to denote security status.*/ +static bool m_bond_loaded; /**< Variable to indicate if the bonding information of the currently connected central is available in the RAM.*/ +static bool m_sys_attr_loaded; /**< Variable to indicate if the system attribute information of the currently connected central is loaded from the database and set in the S110 SoftDevice.*/ +static uint32_t m_bond_crc_array[BLE_BONDMNGR_MAX_BONDED_CENTRALS]; +static uint32_t m_sys_crc_array[BLE_BONDMNGR_MAX_BONDED_CENTRALS]; + +/**@brief Function for extracting the CRC from an encoded 32 bit number that typical resides in + * the flash memory + * + * @param[in] header Header containing CRC and magic number. + * @param[out] p_crc Extracted CRC. + * + * @retval NRF_SUCCESS CRC successfully extracted. + * @retval NRF_ERROR_NOT_FOUND Flash seems to be empty. + * @retval NRF_ERROR_INVALID_DATA Header does not contain the magic number. + */ +static uint32_t crc_extract(uint32_t header, uint16_t * p_crc) +{ + if ((header & 0xFFFF0000U) == BOND_MANAGER_DATA_SIGNATURE) + { + *p_crc = (uint16_t)(header & 0x0000FFFFU); + + return NRF_SUCCESS; + } + else if (header == 0xFFFFFFFFU) + { + return NRF_ERROR_NOT_FOUND; + } + else + { + return NRF_ERROR_INVALID_DATA; + } +} + + +/**@brief Function for storing the Bonding Information of the specified central to the flash. + * + * @param[in] p_bond Bonding information to be stored. + * + * @return NRF_SUCCESS on success, an error_code otherwise. + */ +static uint32_t bond_info_store(central_bond_t * p_bond) +{ + uint32_t err_code; + pstorage_handle_t dest_block; + + // Check if flash is full + if (m_bond_info_in_flash_count >= MAX_BONDS_IN_FLASH) + { + return NRF_ERROR_NO_MEM; + } + + // Check if this is the first bond to be stored + if (m_bond_info_in_flash_count == 0) + { + // Initialize CRC + m_crc_bond_info = crc16_compute(NULL, 0, NULL); + } + + // Get block pointer from base + err_code = pstorage_block_identifier_get(&mp_flash_bond_info,m_bond_info_in_flash_count,&dest_block); + if (err_code != NRF_SUCCESS) + { + return err_code; + } + + // Write Bonding Information + err_code = pstorage_store(&dest_block, + (uint8_t *)p_bond, + sizeof(central_bond_t), + sizeof(uint32_t)); + + if (err_code != NRF_SUCCESS) + { + return err_code; + } + m_crc_bond_info = crc16_compute((uint8_t *)p_bond, + sizeof(central_bond_t), + &m_crc_bond_info); + + // Write header + m_bond_crc_array[m_bond_info_in_flash_count] = (BOND_MANAGER_DATA_SIGNATURE | m_crc_bond_info); + + err_code = pstorage_store (&dest_block, (uint8_t *)&m_bond_crc_array[m_bond_info_in_flash_count],sizeof(uint32_t),0); + if (err_code != NRF_SUCCESS) + { + return err_code; + } + + m_bond_info_in_flash_count++; + return NRF_SUCCESS; +} + + +/**@brief Function for storing the System Attributes related to a specified central in flash. + * + * @param[in] p_sys_attr System Attributes to be stored. + * + * @return NRF_SUCCESS on success, an error_code otherwise. + */ +static uint32_t sys_attr_store(central_sys_attr_t * p_sys_attr) +{ + uint32_t err_code; + pstorage_handle_t dest_block; + + // Check if flash is full. + if (m_sys_attr_in_flash_count >= MAX_BONDS_IN_FLASH) + { + return NRF_ERROR_NO_MEM; + } + + // Check if this is the first time any System Attributes is stored. + if (m_sys_attr_in_flash_count == 0) + { + // Initialize CRC + m_crc_sys_attr = crc16_compute(NULL, 0, NULL); + } + + + // Get block pointer from base + err_code = pstorage_block_identifier_get(&mp_flash_sys_attr,m_sys_attr_in_flash_count,&dest_block); + if (err_code != NRF_SUCCESS) + { + return err_code; + } + + // Write System Attributes in flash. + err_code = pstorage_store(&dest_block, + (uint8_t *)p_sys_attr, + sizeof(central_sys_attr_t), + sizeof(uint32_t)); + + if (err_code != NRF_SUCCESS) + { + return err_code; + } + m_crc_sys_attr = crc16_compute((uint8_t *)p_sys_attr, + sizeof(central_sys_attr_t), + &m_crc_sys_attr); + + // Write header. + m_sys_crc_array[m_sys_attr_in_flash_count] = (BOND_MANAGER_DATA_SIGNATURE | m_crc_sys_attr); + + err_code = pstorage_store (&dest_block, + (uint8_t *)&m_sys_crc_array[m_sys_attr_in_flash_count], + sizeof(uint32_t), + 0); + if (err_code != NRF_SUCCESS) + { + return err_code; + } + + m_sys_attr_in_flash_count++; + + + return NRF_SUCCESS; +} + + +/**@brief Function for loading the Bonding Information of one central from flash. + * + * @param[out] p_bond Loaded Bonding Information. + * + * @return NRF_SUCCESS on success, otherwise an error code. + */ +static uint32_t bonding_info_load_from_flash(central_bond_t * p_bond) +{ + pstorage_handle_t source_block; + uint32_t err_code; + uint32_t crc; + uint16_t crc_header; + + // Check if this is the first bond to be loaded, in which case the + // m_bond_info_in_flash_count variable would have the intial value 0. + if (m_bond_info_in_flash_count == 0) + { + // Initialize CRC. + m_crc_bond_info = crc16_compute(NULL, 0, NULL); + } + + // Get block pointer from base + err_code = pstorage_block_identifier_get(&mp_flash_bond_info, + m_bond_info_in_flash_count, + &source_block); + if (err_code != NRF_SUCCESS) + { + return err_code; + } + + err_code = pstorage_load((uint8_t *)&crc, &source_block, sizeof(uint32_t), 0); + if (err_code != NRF_SUCCESS) + { + return err_code; + } + + // Extract CRC from header. + err_code = crc_extract(crc, &crc_header); + if (err_code != NRF_SUCCESS) + { + return err_code; + } + + // Load central. + err_code = pstorage_load((uint8_t *)p_bond, + &source_block, + sizeof(central_bond_t), + sizeof(uint32_t)); + if (err_code != NRF_SUCCESS) + { + return err_code; + } + + // Check CRC. + m_crc_bond_info = crc16_compute((uint8_t *)p_bond, + sizeof(central_bond_t), + &m_crc_bond_info); + if (m_crc_bond_info == crc_header) + { + m_bond_info_in_flash_count++; + return NRF_SUCCESS; + } + else + { + return NRF_ERROR_INVALID_DATA; + } +} + + + +/**@brief Function for loading the System Attributes related to one central from flash. + * + * @param[out] p_sys_attr Loaded System Attributes. + * + * @return NRF_SUCCESS on success, otherwise an error code. + */ +static uint32_t sys_attr_load_from_flash(central_sys_attr_t * p_sys_attr) +{ + pstorage_handle_t source_block; + uint32_t err_code; + uint32_t crc; + uint16_t crc_header; + + // Check if this is the first time System Attributes is loaded from flash, in which case the + // m_sys_attr_in_flash_count variable would have the initial value 0. + if (m_sys_attr_in_flash_count == 0) + { + // Initialize CRC. + m_crc_sys_attr = crc16_compute(NULL, 0, NULL); + } + + // Get block pointer from base + err_code = pstorage_block_identifier_get(&mp_flash_sys_attr, + m_sys_attr_in_flash_count, + &source_block); + if (err_code != NRF_SUCCESS) + { + return err_code; + } + + err_code = pstorage_load((uint8_t *)&crc, &source_block, sizeof(uint32_t), 0); + if (err_code != NRF_SUCCESS) + { + return err_code; + } + + // Extract CRC from header. + err_code = crc_extract(crc, &crc_header); + if (err_code != NRF_SUCCESS) + { + return err_code; + } + + err_code = pstorage_load((uint8_t *)p_sys_attr, + &source_block, + sizeof(central_sys_attr_t), + sizeof(uint32_t)); + if (err_code != NRF_SUCCESS) + { + return err_code; + } + + // Check CRC. + m_crc_sys_attr = crc16_compute((uint8_t *)p_sys_attr, + sizeof(central_sys_attr_t), + &m_crc_sys_attr); + + if (m_crc_sys_attr == crc_header) + { + m_sys_attr_in_flash_count++; + return NRF_SUCCESS; + } + else + { + return NRF_ERROR_INVALID_DATA; + } +} + + +/**@brief Function for erasing the flash pages that contain Bonding Information and System + * Attributes. + * + * @return NRF_SUCCESS on success, otherwise an error code. + */ +static uint32_t flash_pages_erase(void) +{ + uint32_t err_code; + + err_code = pstorage_clear(&mp_flash_bond_info, MAX_BONDS_IN_FLASH); + + if (err_code == NRF_SUCCESS) + { + err_code = pstorage_clear(&mp_flash_sys_attr, MAX_BONDS_IN_FLASH); + } + + return err_code; +} + + +/**@brief Function for checking if Bonding Information in RAM is different from that in + * flash. + * + * @return TRUE if Bonding Information in flash and RAM are different, FALSE otherwise. + */ +static bool bond_info_changed(void) +{ + int i; + uint16_t crc = crc16_compute(NULL, 0, NULL); + + // Compute CRC for all bonds in database. + for (i = 0; i < m_centrals_in_db_count; i++) + { + crc = crc16_compute((uint8_t *)&m_centrals_db[i].bond, + sizeof(central_bond_t), + &crc); + } + + // Compare the computed CRS to CRC stored in flash. + return (crc != m_crc_bond_info); +} + + +/**@brief Function for checking if System Attributes in RAM is different from that in flash. + * + * @return TRUE if System Attributes in flash and RAM are different, FALSE otherwise. + */ +static bool sys_attr_changed(void) +{ + int i; + uint16_t crc = crc16_compute(NULL, 0, NULL); + + // Compute CRC for all System Attributes in database. + for (i = 0; i < m_centrals_in_db_count; i++) + { + crc = crc16_compute((uint8_t *)&m_centrals_db[i].sys_attr, + sizeof(central_sys_attr_t), + &crc); + } + + // Compare the CRC of System Attributes in flash with that of the System Attributes in memory. + return (crc != m_crc_sys_attr); +} + + +/**@brief Function for setting the System Attributes for specified central to the SoftDevice, or + * clearing the System Attributes if central is a previously unknown. + * + * @param[in] p_central Central for which the System Attributes is to be set. + * + * @return NRF_SUCCESS on success, otherwise an error code. + */ +static uint32_t central_sys_attr_set(central_t * p_central) +{ + uint8_t * p_sys_attr; + + if (m_central.sys_attr.sys_attr_size != 0) + { + if (m_central.sys_attr.sys_attr_size > SYS_ATTR_BUFFER_MAX_LEN) + { + return NRF_ERROR_INTERNAL; + } + + p_sys_attr = m_central.sys_attr.sys_attr; + } + else + { + p_sys_attr = NULL; + } + + return sd_ble_gatts_sys_attr_set(m_conn_handle, p_sys_attr, m_central.sys_attr.sys_attr_size); +} + + +/**@brief Function for updating the whitelist data structures. + */ +static void update_whitelist(void) +{ + int i; + + for (i = 0, m_addr_count = 0, m_irk_count = 0; i < m_centrals_in_db_count; i++) + { + central_bond_t * p_bond = &m_centrals_db[i].bond; + + if (p_bond->auth_status.central_kex.irk) + { + m_whitelist_irk[m_irk_count].central_handle = p_bond->central_handle; + m_whitelist_irk[m_irk_count].p_irk = &(p_bond->auth_status.central_keys.irk); + + m_irk_count++; + } + + if (p_bond->central_addr.addr_type != BLE_GAP_ADDR_TYPE_RANDOM_PRIVATE_RESOLVABLE) + { + m_whitelist_addr[m_addr_count].central_handle = p_bond->central_handle; + m_whitelist_addr[m_addr_count].p_addr = &(p_bond->central_addr); + + m_addr_count++; + } + } +} + + +/**@brief Function for handling the authentication status event related to a new central. + * + * @details This function adds the new central to the database and stores the central's Bonding + * Information to flash. It also notifies the application when the new bond is created, + * and sets the System Attributes to prepare the stack for connection with the new + * central. + * + * @param[in] p_auth_status New authentication status. + * + * @return NRF_SUCCESS on success, otherwise an error code. + */ +static uint32_t on_auth_status_from_new_central(ble_gap_evt_auth_status_t * p_auth_status) +{ + uint32_t err_code; + + if (m_centrals_in_db_count >= BLE_BONDMNGR_MAX_BONDED_CENTRALS) + { + return NRF_ERROR_NO_MEM; + } + + // Update central. + m_central.bond.auth_status = *p_auth_status; + m_central.bond.central_id_info.div = p_auth_status->periph_keys.enc_info.div; + m_central.sys_attr.sys_attr_size = 0; + + // Add new central to database. + m_central.bond.central_handle = m_centrals_in_db_count; + m_centrals_db[m_centrals_in_db_count++] = m_central; + + update_whitelist(); + + m_bond_loaded = true; + + // Clear System Attributes. + err_code = sd_ble_gatts_sys_attr_set(m_conn_handle, NULL, 0); + if (err_code != NRF_SUCCESS) + { + return err_code; + } + + // Write new central's Bonding Information to flash. + err_code = bond_info_store(&m_central.bond); + if ((err_code == NRF_ERROR_NO_MEM) && (m_bondmngr_config.evt_handler != NULL)) + { + ble_bondmngr_evt_t evt; + + evt.evt_type = BLE_BONDMNGR_EVT_BOND_FLASH_FULL; + evt.central_handle = m_central.bond.central_handle; + evt.central_id = m_central.bond.central_id_info.div; + + m_bondmngr_config.evt_handler(&evt); + } + else if (err_code != NRF_SUCCESS) + { + return err_code; + } + + // Pass the event to application. + if (m_bondmngr_config.evt_handler != NULL) + { + ble_bondmngr_evt_t evt; + + evt.evt_type = BLE_BONDMNGR_EVT_NEW_BOND; + evt.central_handle = m_central.bond.central_handle; + evt.central_id = m_central.bond.central_id_info.div; + + m_bondmngr_config.evt_handler(&evt); + } + + return NRF_SUCCESS; +} + + +/**@brief Function for updating the current central's entry in the database. + */ +static uint32_t central_update(void) +{ + uint32_t err_code; + int32_t central_handle = m_central.bond.central_handle; + + if ((central_handle >= 0) && (central_handle < m_centrals_in_db_count)) + { + // Update the database based on whether the bond and system attributes have + // been loaded or not to avoid overwriting information that was not used in the + // connection session. + if (m_bond_loaded) + { + m_centrals_db[central_handle].bond = m_central.bond; + } + + if (m_sys_attr_loaded) + { + m_centrals_db[central_handle].sys_attr = m_central.sys_attr; + } + + update_whitelist(); + + err_code = NRF_SUCCESS; + } + else + { + err_code = NRF_ERROR_INTERNAL; + } + + return err_code; +} + + +/**@brief Function for searching for the central in the database of known centrals. + * + * @details If the central is found, the variable m_central will be populated with all the + * information (Bonding Information and System Attributes) related to that central. + * + * @param[in] central_id Central Identifier. + * @return NRF_SUCCESS on success, otherwise an error code. + */ +static uint32_t central_find_in_db(uint16_t central_id) +{ + int i; + + for (i = 0; i < m_centrals_in_db_count; i++) + { + if (central_id == m_centrals_db[i].bond.central_id_info.div) + { + m_central = m_centrals_db[i]; + return NRF_SUCCESS; + } + } + + return NRF_ERROR_NOT_FOUND; +} + + +/**@brief Function for loading all Bonding Information and System Attributes from flash. + * + * @return NRF_SUCCESS on success, otherwise an error code. + */ +static uint32_t load_all_from_flash(void) +{ + uint32_t err_code; + int i; + + m_centrals_in_db_count = 0; + + while (m_centrals_in_db_count < BLE_BONDMNGR_MAX_BONDED_CENTRALS) + { + central_bond_t central_bond_info; + int central_handle; + + // Load Bonding Information. + err_code = bonding_info_load_from_flash(¢ral_bond_info); + if (err_code == NRF_ERROR_NOT_FOUND) + { + // No more bonds in flash. + break; + } + else if (err_code != NRF_SUCCESS) + { + return err_code; + } + + central_handle = central_bond_info.central_handle; + if (central_handle > m_centrals_in_db_count) + { + // Central handle value(s) missing in flash. This should never happen. + return NRF_ERROR_INVALID_DATA; + } + else + { + // Add/update Bonding Information in central array. + m_centrals_db[central_handle].bond = central_bond_info; + if (central_handle == m_centrals_in_db_count) + { + // New central handle, clear System Attributes. + m_centrals_db[central_handle].sys_attr.sys_attr_size = 0; + m_centrals_db[central_handle].sys_attr.central_handle = INVALID_CENTRAL_HANDLE; + m_centrals_in_db_count++; + } + else + { + // Entry was updated, do nothing. + } + } + } + + // Load System Attributes for all previously known centrals. + for (i = 0; i < m_centrals_in_db_count; i++) + { + central_sys_attr_t central_sys_attr; + + // Load System Attributes. + err_code = sys_attr_load_from_flash(¢ral_sys_attr); + if (err_code == NRF_ERROR_NOT_FOUND) + { + // No more System Attributes in flash. + break; + } + else if (err_code != NRF_SUCCESS) + { + return err_code; + } + + if (central_sys_attr.central_handle > m_centrals_in_db_count) + { + // Central handle value(s) missing in flash. This should never happen. + return NRF_ERROR_INVALID_DATA; + } + else + { + // Add/update Bonding Information in central array. + m_centrals_db[central_sys_attr.central_handle].sys_attr = central_sys_attr; + } + } + + // Initialize the remaining empty bond entries in the memory. + for (i = m_centrals_in_db_count; i < BLE_BONDMNGR_MAX_BONDED_CENTRALS; i++) + { + m_centrals_db[i].bond.central_handle = INVALID_CENTRAL_HANDLE; + m_centrals_db[i].sys_attr.sys_attr_size = 0; + m_centrals_db[i].sys_attr.central_handle = INVALID_CENTRAL_HANDLE; + } + + // Update whitelist data structures. + update_whitelist(); + + return NRF_SUCCESS; +} + + +/**@brief Function for handling the connected event received from the BLE stack. + * + * @param[in] p_ble_evt Event received from the BLE stack. + */ +static void on_connect(ble_evt_t * p_ble_evt) +{ + m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle; + + m_central.bond.central_handle = INVALID_CENTRAL_HANDLE; + m_central.bond.central_addr = p_ble_evt->evt.gap_evt.params.connected.peer_addr; + m_central.sys_attr.sys_attr_size = 0; + + if (p_ble_evt->evt.gap_evt.params.connected.irk_match) + { + uint8_t irk_idx = p_ble_evt->evt.gap_evt.params.connected.irk_match_idx; + + if ((irk_idx >= MAX_NUM_CENTRAL_WHITE_LIST) || + (m_whitelist_irk[irk_idx].central_handle >= BLE_BONDMNGR_MAX_BONDED_CENTRALS)) + { + m_bondmngr_config.error_handler(NRF_ERROR_INTERNAL); + } + else + { + m_central = m_centrals_db[m_whitelist_irk[irk_idx].central_handle]; + } + } + else + { + int i; + + for (i = 0; i < m_addr_count; i++) + { + ble_gap_addr_t * p_cur_addr = m_whitelist_addr[i].p_addr; + + if (memcmp(p_cur_addr->addr, m_central.bond.central_addr.addr, BLE_GAP_ADDR_LEN) == 0) + { + m_central = m_centrals_db[m_whitelist_addr[i].central_handle]; + break; + } + } + } + + if (m_central.bond.central_handle != INVALID_CENTRAL_HANDLE) + { + // Reset bond and system attributes loaded variables. + m_bond_loaded = false; + m_sys_attr_loaded = false; + + // Do not set the system attributes of the central on connection. + if (m_bondmngr_config.evt_handler != NULL) + { + ble_bondmngr_evt_t evt; + + evt.evt_type = BLE_BONDMNGR_EVT_CONN_TO_BONDED_CENTRAL; + evt.central_handle = m_central.bond.central_handle; + evt.central_id = m_central.bond.central_id_info.div; + + m_bondmngr_config.evt_handler(&evt); + } + } +} + + +/**@brief Function for handling the 'System Attributes Missing' event received from the + * SoftDevice. + * + * @param[in] p_ble_evt Event received from the BLE stack. + */ +static void on_sys_attr_missing(ble_evt_t * p_ble_evt) +{ + uint32_t err_code; + + if ( + (m_central.bond.central_handle == INVALID_CENTRAL_HANDLE) || + !ENCRYPTION_STATUS_GET() || + BONDING_IN_PROGRESS_STATUS_GET() + ) + { + err_code = sd_ble_gatts_sys_attr_set(m_conn_handle, NULL, 0); + } + else + { + // Current central is valid, use its data. Set the corresponding sys_attr. + err_code = central_sys_attr_set(&m_central); + if (err_code == NRF_SUCCESS) + { + // Set System Attributes loaded status variable. + m_sys_attr_loaded = true; + } + } + + if (err_code != NRF_SUCCESS) + { + m_bondmngr_config.error_handler(err_code); + } +} + + +/**@brief Function for handling the new authentication status event, received from the + * SoftDevice, related to an already bonded central. + * + * @details This function also writes the updated Bonding Information to flash and notifies the + * application. + * + * @param[in] p_auth_status Updated authentication status. + */ +static void auth_status_update(ble_gap_evt_auth_status_t * p_auth_status) +{ + uint32_t err_code; + + // Authentication status changed, update Bonding Information. + m_central.bond.auth_status = *p_auth_status; + m_central.bond.central_id_info.div = p_auth_status->periph_keys.enc_info.div; + + memset(&(m_centrals_db[m_central.bond.central_handle]), 0, sizeof(central_t)); + m_centrals_db[m_central.bond.central_handle] = m_central; + + // Write updated Bonding Information to flash. + err_code = bond_info_store(&m_central.bond); + if ((err_code == NRF_ERROR_NO_MEM) && (m_bondmngr_config.evt_handler != NULL)) + { + ble_bondmngr_evt_t evt; + + evt.evt_type = BLE_BONDMNGR_EVT_BOND_FLASH_FULL; + evt.central_handle = m_central.bond.central_handle; + evt.central_id = m_central.bond.central_id_info.div; + + m_bondmngr_config.evt_handler(&evt); + } + else if (err_code != NRF_SUCCESS) + { + m_bondmngr_config.error_handler(err_code); + } + + // Pass the event to the application. + if (m_bondmngr_config.evt_handler != NULL) + { + ble_bondmngr_evt_t evt; + + evt.evt_type = BLE_BONDMNGR_EVT_AUTH_STATUS_UPDATED; + evt.central_handle = m_central.bond.central_handle; + evt.central_id = m_central.bond.central_id_info.div; + + m_bondmngr_config.evt_handler(&evt); + } +} + + +/**@brief Function for handling the Authentication Status event received from the BLE stack. + * + * @param[in] p_ble_evt Event received from the BLE stack. + */ +static void on_auth_status(ble_gap_evt_auth_status_t * p_auth_status) +{ + if (p_auth_status->auth_status != BLE_GAP_SEC_STATUS_SUCCESS) + { + return; + } + + // Verify if its pairing and not bonding + if (!ENCRYPTION_STATUS_GET()) + { + return; + } + + if (m_central.bond.central_handle == INVALID_CENTRAL_HANDLE) + { + uint32_t err_code = central_find_in_db(p_auth_status->periph_keys.enc_info.div); + + if (err_code == NRF_SUCCESS) + { + // Possible DIV Collision indicate error to application, + // not storing the new LTK + err_code = NRF_ERROR_FORBIDDEN; + } + else + { + // Add the new device to data base + err_code = on_auth_status_from_new_central(p_auth_status); + } + + if (err_code != NRF_SUCCESS) + { + m_bondmngr_config.error_handler(err_code); + } + } + else + { + m_bond_loaded = true; + + // Receiving a auth status again when already in have existing information! + auth_status_update(p_auth_status); + } +} + + +/**@brief Function for handling the Security Info Request event received from the BLE stack. + * + * @param[in] p_ble_evt Event received from the BLE stack. + */ +static void on_sec_info_request(ble_evt_t * p_ble_evt) +{ + uint32_t err_code; + + err_code = central_find_in_db(p_ble_evt->evt.gap_evt.params.sec_info_request.div); + if (err_code == NRF_SUCCESS) + { + // Bond information has been found and loaded for security procedures. Reflect this in the + // status variable + m_bond_loaded = true; + + // Central found in the list of bonded central. Use the encryption info for this central. + err_code = sd_ble_gap_sec_info_reply(m_conn_handle, + &m_central.bond.auth_status.periph_keys.enc_info, + NULL); + if (err_code != NRF_SUCCESS) + { + m_bondmngr_config.error_handler(err_code); + } + + // Do not set the sys_attr yet, should be set only when sec_update is successful. + } + else if (err_code == NRF_ERROR_NOT_FOUND) + { + m_central.bond.central_id_info = p_ble_evt->evt.gap_evt.params.sec_info_request; + + // New central. + err_code = sd_ble_gap_sec_info_reply(m_conn_handle, NULL, NULL); + if (err_code != NRF_SUCCESS) + { + m_bondmngr_config.error_handler(err_code); + } + + // Initialize the sys_attr. + err_code = sd_ble_gatts_sys_attr_set(m_conn_handle, NULL, 0); + } + + if (err_code != NRF_SUCCESS) + { + m_bondmngr_config.error_handler(err_code); + } +} + + +/**@brief Function for handling the Connection Security Update event received from the BLE + * stack. + * + * @param[in] p_ble_evt Event received from the BLE stack. + */ +static void on_sec_update(ble_gap_evt_conn_sec_update_t * p_sec_update) +{ + uint8_t security_mode = p_sec_update->conn_sec.sec_mode.sm; + uint8_t security_level = p_sec_update->conn_sec.sec_mode.lv; + + if (((security_mode == 1) && (security_level > 1)) || + ((security_mode == 2) && (security_level != 0))) + { + ENCRYPTION_STATUS_SET(); + + uint32_t err_code = central_sys_attr_set(&m_central); + + if (err_code != NRF_SUCCESS) + { + m_bondmngr_config.error_handler(err_code); + } + else + { + m_sys_attr_loaded = true; + } + + if (m_bondmngr_config.evt_handler != NULL) + { + ble_bondmngr_evt_t evt; + + evt.evt_type = BLE_BONDMNGR_EVT_ENCRYPTED; + evt.central_handle = m_central.bond.central_handle; + evt.central_id = m_central.bond.central_id_info.div; + + m_bondmngr_config.evt_handler(&evt); + } + } +} + + +/**@brief Function for handling the Connection Security Parameters Request event received from + * the BLE stack. + * + * @param[in] p_ble_evt Event received from the BLE stack. + */ +static void on_sec_param_request(ble_gap_evt_sec_params_request_t * p_sec_update) +{ + if (p_sec_update->peer_params.bond) + { + BONDING_IN_PROGRESS_STATUS_SET(); + + if (m_central.bond.central_handle != INVALID_CENTRAL_HANDLE) + { + // Bonding request received from a bonded central, make all system attributes null + m_central.sys_attr.sys_attr_size = 0; + memset(m_central.sys_attr.sys_attr, 0, SYS_ATTR_BUFFER_MAX_LEN); + } + } +} + + +void ble_bondmngr_on_ble_evt(ble_evt_t * p_ble_evt) +{ + if (!m_is_bondmngr_initialized) + { + m_bondmngr_config.error_handler(NRF_ERROR_INVALID_STATE); + } + + switch (p_ble_evt->header.evt_id) + { + case BLE_GAP_EVT_CONNECTED: + on_connect(p_ble_evt); + break; + + // NOTE: All actions to be taken on the Disconnected event are performed in + // ble_bondmngr_bonded_centrals_store(). This function must be called from the + // Disconnected handler of the application before advertising is restarted (to make + // sure the flash blocks are cleared while the radio is inactive). + case BLE_GAP_EVT_DISCONNECTED: + SECURITY_STATUS_RESET(); + break; + + case BLE_GATTS_EVT_SYS_ATTR_MISSING: + on_sys_attr_missing(p_ble_evt); + break; + + case BLE_GAP_EVT_AUTH_STATUS: + on_auth_status(&p_ble_evt->evt.gap_evt.params.auth_status); + break; + + case BLE_GAP_EVT_SEC_INFO_REQUEST: + on_sec_info_request(p_ble_evt); + break; + + case BLE_GAP_EVT_SEC_PARAMS_REQUEST: + on_sec_param_request(&p_ble_evt->evt.gap_evt.params.sec_params_request); + break; + + case BLE_GAP_EVT_CONN_SEC_UPDATE: + on_sec_update(&p_ble_evt->evt.gap_evt.params.conn_sec_update); + break; + + default: + // No implementation needed. + break; + } +} + + +uint32_t ble_bondmngr_bonded_centrals_store(void) +{ + uint32_t err_code; + int i; + + VERIFY_MODULE_INITIALIZED(); + + if (m_central.bond.central_handle != INVALID_CENTRAL_HANDLE) + { + // Fetch System Attributes from stack. + uint16_t sys_attr_size = SYS_ATTR_BUFFER_MAX_LEN; + + err_code = sd_ble_gatts_sys_attr_get(m_conn_handle, + m_central.sys_attr.sys_attr, + &sys_attr_size); + if (err_code != NRF_SUCCESS) + { + return err_code; + } + + m_central.sys_attr.central_handle = m_central.bond.central_handle; + m_central.sys_attr.sys_attr_size = (uint16_t)sys_attr_size; + + // Update the current central. + err_code = central_update(); + if (err_code != NRF_SUCCESS) + { + return err_code; + } + } + + // Save Bonding Information if changed. + if (bond_info_changed()) + { + // Erase flash page. + err_code = pstorage_clear(&mp_flash_bond_info,MAX_BONDS_IN_FLASH); + if (err_code != NRF_SUCCESS) + { + return err_code; + } + + // Store bond information for all centrals. + m_bond_info_in_flash_count = 0; + for (i = 0; i < m_centrals_in_db_count; i++) + { + err_code = bond_info_store(&m_centrals_db[i].bond); + if (err_code != NRF_SUCCESS) + { + return err_code; + } + } + } + + // Save System Attributes, if changed. + if (sys_attr_changed()) + { + // Erase flash page. + err_code = pstorage_clear(&mp_flash_sys_attr, MAX_BONDS_IN_FLASH); + if (err_code != NRF_SUCCESS) + { + return err_code; + } + + // Store System Attributes for all centrals. + m_sys_attr_in_flash_count = 0; + for (i = 0; i < m_centrals_in_db_count; i++) + { + err_code = sys_attr_store(&m_centrals_db[i].sys_attr); + if (err_code != NRF_SUCCESS) + { + return err_code; + } + } + } + + m_conn_handle = BLE_CONN_HANDLE_INVALID; + m_central.bond.central_handle = INVALID_CENTRAL_HANDLE; + m_central.sys_attr.central_handle = INVALID_CENTRAL_HANDLE; + m_central.sys_attr.sys_attr_size = 0; + m_bond_loaded = false; + m_sys_attr_loaded = false; + + return NRF_SUCCESS; +} + + +uint32_t ble_bondmngr_sys_attr_store(void) +{ + uint32_t err_code; + + if (m_central.sys_attr.sys_attr_size == 0) + { + // Connected to new central. So the flash block for System Attributes for this + // central is empty. Hence no erase is needed. + + uint16_t sys_attr_size = SYS_ATTR_BUFFER_MAX_LEN; + + // Fetch System Attributes from stack. + err_code = sd_ble_gatts_sys_attr_get(m_conn_handle, + m_central.sys_attr.sys_attr, + &sys_attr_size); + + if (err_code != NRF_SUCCESS) + { + return err_code; + } + + m_central.sys_attr.central_handle = m_central.bond.central_handle; + m_central.sys_attr.sys_attr_size = (uint16_t)sys_attr_size; + + // Copy the System Attributes to database. + m_centrals_db[m_central.bond.central_handle].sys_attr = m_central.sys_attr; + + // Write new central's System Attributes to flash. + return (sys_attr_store(&m_central.sys_attr)); + } + else + { + // Will not write to flash because System Attributes of an old central would already be + // in flash and so this operation needs a flash erase operation. + return NRF_ERROR_INVALID_STATE; + } +} + + +uint32_t ble_bondmngr_bonded_centrals_delete(void) +{ + VERIFY_MODULE_INITIALIZED(); + + m_centrals_in_db_count = 0; + m_bond_info_in_flash_count = 0; + m_sys_attr_in_flash_count = 0; + + return flash_pages_erase(); +} + + +uint32_t ble_bondmngr_central_addr_get(int8_t central_handle, ble_gap_addr_t * p_central_addr) +{ + if ( + (central_handle == INVALID_CENTRAL_HANDLE) || + (central_handle >= m_centrals_in_db_count) || + (p_central_addr == NULL) || + ( + m_centrals_db[central_handle].bond.central_addr.addr_type + == + BLE_GAP_ADDR_TYPE_RANDOM_PRIVATE_RESOLVABLE + ) + ) + { + return NRF_ERROR_INVALID_PARAM; + } + + *p_central_addr = m_centrals_db[central_handle].bond.central_addr; + return NRF_SUCCESS; +} + + +uint32_t ble_bondmngr_whitelist_get(ble_gap_whitelist_t * p_whitelist) +{ + static ble_gap_addr_t * s_addr[MAX_NUM_CENTRAL_WHITE_LIST]; + static ble_gap_irk_t * s_irk[MAX_NUM_CENTRAL_WHITE_LIST]; + + int i; + + for (i = 0; i < m_irk_count; i++) + { + s_irk[i] = m_whitelist_irk[i].p_irk; + } + for (i = 0; i < m_addr_count; i++) + { + s_addr[i] = m_whitelist_addr[i].p_addr; + } + + p_whitelist->addr_count = m_addr_count; + p_whitelist->pp_addrs = (m_addr_count != 0) ? s_addr : NULL; + p_whitelist->irk_count = m_irk_count; + p_whitelist->pp_irks = (m_irk_count != 0) ? s_irk : NULL; + + return NRF_SUCCESS; +} + + +static void bm_pstorage_cb_handler(pstorage_handle_t * handle, + uint8_t op_code, + uint32_t result, + uint8_t * p_data, + uint32_t data_len) +{ + if (result != NRF_SUCCESS) + { + m_bondmngr_config.error_handler(result); + } +} + + +uint32_t ble_bondmngr_init(ble_bondmngr_init_t * p_init) +{ + pstorage_module_param_t param; + uint32_t err_code; + + if (p_init->error_handler == NULL) + { + return NRF_ERROR_INVALID_PARAM; + } + + if (BLE_BONDMNGR_MAX_BONDED_CENTRALS > MAX_BONDS_IN_FLASH) + { + return NRF_ERROR_DATA_SIZE; + } + + param.block_size = sizeof (central_bond_t) + sizeof (uint32_t); + param.block_count = MAX_BONDS_IN_FLASH; + param.cb = bm_pstorage_cb_handler; + + // Blocks are requested twice, once for bond information and once for system attributes. + // The number of blocks requested has to be the maximum number of bonded devices that + // need to be supported. However, the size of blocks can be different if the sizes of + // system attributes and bonds are not too close. + err_code = pstorage_register(¶m, &mp_flash_bond_info); + if (err_code != NRF_SUCCESS) + { + return err_code; + } + + param.block_size = sizeof(central_sys_attr_t) + sizeof(uint32_t); + + err_code = pstorage_register(¶m, &mp_flash_sys_attr); + if (err_code != NRF_SUCCESS) + { + return err_code; + } + + m_bondmngr_config = *p_init; + + memset(&m_central, 0, sizeof(central_t)); + + m_central.bond.central_handle = INVALID_CENTRAL_HANDLE; + m_conn_handle = BLE_CONN_HANDLE_INVALID; + m_centrals_in_db_count = 0; + m_bond_info_in_flash_count = 0; + m_sys_attr_in_flash_count = 0; + + SECURITY_STATUS_RESET(); + + // Erase all stored centrals if specified. + if (m_bondmngr_config.bonds_delete) + { + err_code = flash_pages_erase(); + if (err_code != NRF_SUCCESS) + { + return err_code; + } + + m_centrals_in_db_count = 0; + int i; + for (i = m_centrals_in_db_count; i < BLE_BONDMNGR_MAX_BONDED_CENTRALS; i++) + { + m_centrals_db[i].bond.central_handle = INVALID_CENTRAL_HANDLE; + m_centrals_db[i].sys_attr.sys_attr_size = 0; + m_centrals_db[i].sys_attr.central_handle = INVALID_CENTRAL_HANDLE; + } + } + else + { + // Load bond manager data from flash. + err_code = load_all_from_flash(); + if (err_code != NRF_SUCCESS) + { + return err_code; + } + } + + m_is_bondmngr_initialized = true; + + return NRF_SUCCESS; +} + + +uint32_t ble_bondmngr_central_ids_get(uint16_t * p_central_ids, uint16_t * p_length) +{ + VERIFY_MODULE_INITIALIZED(); + int i; + if (p_length == NULL) + { + return NRF_ERROR_NULL; + } + + if (*p_length < m_centrals_in_db_count) + { + // Length of the input array is not enough to fit all known central identifiers. + return NRF_ERROR_DATA_SIZE; + } + + *p_length = m_centrals_in_db_count; + if (p_central_ids == NULL) + { + // Only the length field was required to be filled. + return NRF_SUCCESS; + } + + for (i = 0; i < m_centrals_in_db_count; i++) + { + p_central_ids[i] = m_centrals_db[i].bond.central_id_info.div; + } + + return NRF_SUCCESS; +} + + +uint32_t ble_bondmngr_bonded_central_delete(uint16_t central_id) +{ + VERIFY_MODULE_INITIALIZED(); + + int8_t central_handle_to_be_deleted = INVALID_CENTRAL_HANDLE; + uint8_t i; + + // Search for the handle of the central. + for (i = 0; i < m_centrals_in_db_count; i++) + { + if (m_centrals_db[i].bond.central_id_info.div == central_id) + { + central_handle_to_be_deleted = i; + break; + } + } + + if (central_handle_to_be_deleted == INVALID_CENTRAL_HANDLE) + { + // Central ID not found. + return NRF_ERROR_NOT_FOUND; + } + + // Delete the central in RAM. + for (i = central_handle_to_be_deleted; i < (m_centrals_in_db_count - 1); i++) + { + // Overwrite the current central entry with the next one. + m_centrals_db[i] = m_centrals_db[i + 1]; + + // Decrement the value of handle. + m_centrals_db[i].bond.central_handle--; + if (INVALID_CENTRAL_HANDLE != m_centrals_db[i].sys_attr.central_handle) + { + m_centrals_db[i].sys_attr.central_handle--; + } + } + + // Clear the last database entry. + memset(&(m_centrals_db[m_centrals_in_db_count - 1]), 0, sizeof(central_t)); + + m_centrals_in_db_count--; + + uint32_t err_code; + + // Reinitialize the pointers to the memory where bonding info and System Attributes are stored + // in flash. + // Refresh the data in the flash memory (both Bonding Information and System Attributes). + // Erase and rewrite bonding info and System Attributes. + + err_code = flash_pages_erase(); + if (err_code != NRF_SUCCESS) + { + return err_code; + } + + m_bond_info_in_flash_count = 0; + m_sys_attr_in_flash_count = 0; + + for (i = 0; i < m_centrals_in_db_count; i++) + { + err_code = bond_info_store(&(m_centrals_db[i].bond)); + if (err_code != NRF_SUCCESS) + { + return err_code; + } + } + + for (i = 0; i < m_centrals_in_db_count; i++) + { + err_code = sys_attr_store(&(m_centrals_db[i].sys_attr)); + if (err_code != NRF_SUCCESS) + { + return err_code; + } + } + + update_whitelist(); + + return NRF_SUCCESS; +} + + +uint32_t ble_bondmngr_is_link_encrypted (bool * status) +{ + VERIFY_MODULE_INITIALIZED(); + + (*status) = ENCRYPTION_STATUS_GET(); + + return NRF_SUCCESS; +}