/* * Copyright (c) 2013 Nordic Semiconductor ASA * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, * are permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright notice, this list * of conditions and the following disclaimer. * * 2. Redistributions in binary form, except as embedded into a Nordic Semiconductor ASA * integrated circuit in a product or a software update for such product, must reproduce * the above copyright notice, this list of conditions and the following disclaimer in * the documentation and/or other materials provided with the distribution. * * 3. Neither the name of Nordic Semiconductor ASA nor the names of its contributors may be * used to endorse or promote products derived from this software without specific prior * written permission. * * 4. This software, with or without modification, must only be used with a * Nordic Semiconductor ASA integrated circuit. * * 5. Any software provided in binary or object form under this license must not be reverse * engineered, decompiled, modified and/or disassembled. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * */ #include "device_manager.h" #include "app_trace.h" #include "pstorage.h" #include "nrf_ble_hci.h" #include "app_error.h" #if defined ( __CC_ARM ) #ifndef __ALIGN #define __ALIGN(x) __align(x) /**< Forced aligment keyword for ARM Compiler */ #endif #elif defined ( __ICCARM__ ) #ifndef __ALIGN #define __ALIGN(x) /**< Forced aligment keyword for IAR Compiler */ #endif #elif defined ( __GNUC__ ) #ifndef __ALIGN #define __ALIGN(x) __attribute__((aligned(x))) /**< Forced aligment keyword for GNU Compiler */ #endif #endif #define INVALID_ADDR_TYPE 0xFF /**< Identifier for an invalid address type. */ #define EDIV_INIT_VAL 0xFFFF /**< Initial value for diversifier. */ /** * @defgroup device_manager_app_states Connection Manager Application States * @{ */ #define STATE_CONTROL_PROCEDURE_IN_PROGRESS 0x01 /**< State where a security procedure is ongoing. */ #define STATE_QUEUED_CONTROL_REQUEST 0x02 /**< State where it is known if there is any queued security request or not. */ /** @} */ /** * @defgroup device_manager_conn_inst_states Connection Manager Connection Instances States. * @{ */ #define STATE_IDLE 0x01 /**< State where connection instance is free. */ #define STATE_CONNECTED 0x02 /**< State where connection is successfully established. */ #define STATE_PAIRING 0x04 /**< State where pairing procedure is in progress. This state is used for pairing and bonding, as pairing is needed for both. */ #define STATE_BONDED 0x08 /**< State where device is bonded. */ #define STATE_DISCONNECTING 0x10 /**< State where disconnection is in progress, application will be notified first, but no further active procedures on the link. */ #define STATE_PAIRING_PENDING 0x20 /**< State where pairing request is pending on the link. */ #define STATE_BOND_INFO_UPDATE 0x40 /**< State where information has been updated, update the flash. */ #define STATE_LINK_ENCRYPTED 0x80 /**< State where link is encrypted. */ /** @} */ /** * @defgroup device_manager_peer_id_defines Peer Identification Information Defines. * * @brief These defines are used to know which of the peer identification is applicable for a peer. * * @details These defines are used for peer identification. Here, bit map is used because it is * possible that the application has both IRK and address for identification. * @{ */ #define UNASSIGNED 0xFF /**< Peer instance is unassigned/unused. */ #define IRK_ENTRY 0x01 /**< Peer instance has IRK as identification information. */ #define ADDR_ENTRY 0x02 /**< Peer instance has address as identification information. */ #define SERVICE_CONTEXT_ENTRY 0x04 /**< Peer instance has service context set. */ #define APP_CONTEXT_ENTRY 0x08 /**< Peer instance has an application context set. */ /** @} */ /**@brief Device store state identifiers. */ typedef enum { STORE_ALL_CONTEXT, /**< Store all context. */ FIRST_BOND_STORE, /**< Store bond. */ UPDATE_PEER_ADDR /**< Update peer address. */ } device_store_state_t; /** * @defgroup device_manager_context_offsets Context Offsets * @{ * * @brief Context offsets each of the context information in persistent memory. * * @details Below is a layout showing how each how the context information is stored in persistent * memory. * * All Device context is stored in the flash as follows: * +---------+---------+---------+------------------+----------------+--------------------+ * | Block / Device ID + Layout of stored information in storage block | * +---------+---------+---------+------------------+----------------+--------------------+ * | Block 0 | Device 0| Peer Id | Bond Information | Service Context| Application Context| * +---------+---------+---------+------------------+----------------+--------------------+ * | Block 1 | Device 1| Peer Id | Bond Information | Service Context| Application Context| * +---------+---------+---------+------------------+----------------+--------------------+ * | ... | .... | * +---------+---------+---------+------------------+----------------+--------------------+ * | Block N | Device N| Peer Id | Bond Information | Service Context| Application Context| * +---------+---------+---------+------------------+----------------+--------------------+ * * The following defines are used to get offset of each of the components within a block. */ #define PEER_ID_STORAGE_OFFSET 0 /**< Offset at which peer id is stored in the block. */ #define BOND_STORAGE_OFFSET PEER_ID_SIZE /**< Offset at which bond information is stored in the block. */ #define SERVICE_STORAGE_OFFSET (BOND_STORAGE_OFFSET + BOND_SIZE) /**< Offset at which service context is stored in the block. */ #define APP_CONTEXT_STORAGE_OFFSET (SERVICE_STORAGE_OFFSET + SERVICE_CONTEXT_SIZE) /**< Offset at which application context is stored in the block. */ /** @} */ /** * @defgroup device_manager_context_size Context size. * @{ * * @brief This group defines the size of each of the context information. */ #define PEER_ID_SIZE (sizeof(peer_id_t)) /**< Size of peer identification information. */ #define BOND_SIZE (sizeof(bond_context_t)) /**< Size of bond information. */ #define DEVICE_CONTEXT_SIZE (PEER_ID_SIZE + BOND_SIZE) /**< Size of Device context, include peer identification and bond information. */ #define GATTS_SERVICE_CONTEXT_SIZE (sizeof(dm_gatts_context_t)) /**< Size of GATTS service context. */ #define GATTC_SERVICE_CONTEXT_SIZE (sizeof(dm_gatt_client_context_t)) /**< Size of GATTC service context. */ #define SERVICE_CONTEXT_SIZE (GATTS_SERVICE_CONTEXT_SIZE + GATTC_SERVICE_CONTEXT_SIZE) /**< Combined size of GATTS and GATTC service contexts. */ #define APP_CONTEXT_MIN_SIZE 4 /**< Minimum size for application context data. */ #if (DEVICE_MANAGER_APP_CONTEXT_SIZE != 0) #define APP_CONTEXT_SIZE (sizeof(uint32_t) + DEVICE_MANAGER_APP_CONTEXT_SIZE) /**< Size of application context including length field. */ #else //DEVICE_MANAGER_APP_CONTEXT_SIZE #define APP_CONTEXT_SIZE 0 /**< Size of application context. */ #endif // DEVICE_MANAGER_APP_CONTEXT_SIZE #define ALL_CONTEXT_SIZE (DEVICE_CONTEXT_SIZE + SERVICE_CONTEXT_SIZE + APP_CONTEXT_SIZE) /**< Size of all contexts. */ /** @} */ /** * @defgroup device_manager_log Module's Log Macros * * @details Macros used for creating module logs which can be useful in understanding handling * of events or actions on API requests. These are intended for debugging purposes and * can be disabled by defining the DM_DISABLE_LOGS. * * @note That if ENABLE_DEBUG_LOG_SUPPORT is disabled, having DM_DISABLE_LOGS has no effect. * @{ */ #define nDM_DISABLE_LOGS /**< Enable this macro to disable any logs from this module. */ #ifndef DM_DISABLE_LOGS #define DM_LOG app_trace_log /**< Used for logging details. */ #define DM_ERR app_trace_log /**< Used for logging errors in the module. */ #define DM_TRC app_trace_log /**< Used for getting trace of execution in the module. */ #define DM_DUMP app_trace_dump /**< Used for dumping octet information to get details of bond information etc. */ #else //DM_DISABLE_LOGS #define DM_DUMP(...) /**< Disables dumping of octet streams. */ #define DM_LOG(...) /**< Disables detailed logs. */ #define DM_ERR(...) /**< Disables error logs. */ #define DM_TRC(...) /**< Disables traces. */ #endif //DM_DISABLE_LOGS /** @} */ /** * @defgroup device_manager_mutex_lock_unlock Module's Mutex Lock/Unlock Macros. * * @details Macros used to lock and unlock modules. Currently the SDK does not use mutexes but * framework is provided in case need arises to use an alternative architecture. * @{ */ #define DM_MUTEX_LOCK() SDK_MUTEX_LOCK(m_dm_mutex) /**< Lock module using mutex. */ #define DM_MUTEX_UNLOCK() SDK_MUTEX_UNLOCK(m_dm_mutex) /**< Unlock module using mutex. */ /** @} */ /** * @defgroup device_manager_misc_defines Miscellaneous defines used across the module. * @{ */ #define DM_GATT_ATTR_SIZE 6 /**< Size of each GATT attribute to be stored persistently. */ #define DM_GATT_SERVER_ATTR_MAX_SIZE ((DM_GATT_ATTR_SIZE * DM_GATT_CCCD_COUNT) + 2) /**< Maximum size of GATT attributes to be stored.*/ #define DM_SERVICE_CONTEXT_COUNT (DM_PROTOCOL_CNTXT_ALL + 1) /**< Maximum number of service contexts. */ #define DM_EVT_DEVICE_CONTEXT_BASE 0x20 /**< Base for device context base. */ #define DM_EVT_SERVICE_CONTEXT_BASE 0x30 /**< Base for service context base. */ #define DM_EVT_APP_CONTEXT_BASE 0x40 /**< Base for application context base. */ #define DM_LOAD_OPERATION_ID 0x01 /**< Load operation identifier. */ #define DM_STORE_OPERATION_ID 0x02 /**< Store operation identifier. */ #define DM_CLEAR_OPERATION_ID 0x03 /**< Clear operation identifier. */ /** @} */ #define DM_GATTS_INVALID_SIZE 0xFFFFFFFF /**< Identifer for GATTS invalid size. */ /** * @defgroup api_param_check API Parameters check macros. * * @details Macros for verifying parameters passed to the module in the APIs. These macros * could be mapped to nothing in the final version of the code in order to save execution * time and program size. * @{ */ //#define DM_DISABLE_API_PARAM_CHECK /**< Macro to disable API parameters check. */ #undef NULL_PARAM_CHECK #undef VERIFY_MODULE_INITIALIZED #undef VERIFY_MODULE_INITIALIZED_VOID #undef VERIFY_APP_REGISTERED #undef VERIFY_APP_REGISTERED_VOID #undef VERIFY_CONNECTION_INSTANCE #undef VERIFY_DEVICE_INSTANCE #ifndef DM_DISABLE_API_PARAM_CHECK /**@brief Macro for verifying NULL parameters are not passed to API. * * @param[in] PARAM Parameter checked for NULL. * * @retval (NRF_ERROR_NULL | DEVICE_MANAGER_ERR_BASE) when @ref PARAM is NULL. */ #define NULL_PARAM_CHECK(PARAM) \ if ((PARAM) == NULL) \ { \ return (NRF_ERROR_NULL | DEVICE_MANAGER_ERR_BASE); \ } /**@} */ /**@brief Macro for verifying module's initialization status. * * @retval (NRF_ERROR_INVALID_STATE | DEVICE_MANAGER_ERR_BASE) when module is not initialized. */ #define VERIFY_MODULE_INITIALIZED() \ do \ { \ if (!m_module_initialized) \ { \ return (NRF_ERROR_INVALID_STATE | DEVICE_MANAGER_ERR_BASE); \ } \ } while (0) /**@brief Macro for verifying module's initialization status. Returns in case it is not initialized. */ #define VERIFY_MODULE_INITIALIZED_VOID() \ do \ { \ if (!m_module_initialized) \ { \ return; \ } \ } while (0) /**@brief Macro for verifying that the application is registered. * * @param[in] X Application instance identifier. * * @retval (NRF_ERROR_INVALID_STATE | DEVICE_MANAGER_ERR_BASE) when module API is called without * registering an application with the module. */ #define VERIFY_APP_REGISTERED(X) \ do \ { \ if (((X) >= DEVICE_MANAGER_MAX_APPLICATIONS) || \ (m_application_table[(X)].ntf_cb == NULL)) \ { \ return (NRF_ERROR_INVALID_STATE | DEVICE_MANAGER_ERR_BASE); \ } \ } while (0) /**@brief Macro for verifying that the application is registered. Returns in case it is not * registered. * * @param[in] X Application instance identifier. */ #define VERIFY_APP_REGISTERED_VOID(X) \ do \ { \ if (((X) >= DEVICE_MANAGER_MAX_APPLICATIONS) || \ (m_application_table[(X)].ntf_cb == NULL)) \ { \ return; \ } \ } while (0) /**@brief Macro for verifying connection instance is allocated. * * @param[in] X Connection instance identifier. * * @retval (NRF_ERROR_INVALID_ADDR | DEVICE_MANAGER_ERR_BASE) when connection instance is not * allocated. */ #define VERIFY_CONNECTION_INSTANCE(X) \ do \ { \ if (((X) >= DEVICE_MANAGER_MAX_CONNECTIONS) || \ (m_connection_table[(X)].state == STATE_IDLE)) \ { \ return (NRF_ERROR_INVALID_ADDR | DEVICE_MANAGER_ERR_BASE); \ } \ } while (0) /**@brief Macro for verifying if device instance is allocated. * * @param[in] X Device instance identifier. * * @retval (NRF_ERROR_INVALID_ADDR | DEVICE_MANAGER_ERR_BASE) when device instance is not allocated. */ #define VERIFY_DEVICE_INSTANCE(X) \ do \ { \ if (((X) >= DEVICE_MANAGER_MAX_BONDS) || \ (m_peer_table[(X)].id_bitmap == UNASSIGNED)) \ { \ return (NRF_ERROR_INVALID_ADDR | DEVICE_MANAGER_ERR_BASE); \ } \ } while (0) /**@brief Macro for verifying if device is bonded and thus can store data persistantly. * * @param[in] X Connection instance identifier. * * @retval (NRF_ERROR_INVALID_STATE | DEVICE_MANAGER_ERR_BASE) when device is not bonded. */ #define VERIFY_DEVICE_BOND(X) \ do \ { \ if ((m_connection_table[(X)].state & STATE_BONDED) != STATE_BONDED)\ { \ return (NRF_ERROR_INVALID_STATE | DEVICE_MANAGER_ERR_BASE); \ } \ } while (0) #else #define NULL_PARAM_CHECK(X) #define VERIFY_MODULE_INITIALIZED() #define VERIFY_MODULE_INITIALIZED_VOID() #define VERIFY_APP_REGISTERED(X) #define VERIFY_APP_REGISTERED_VOID(X) #define VERIFY_CONNECTION_INSTANCE(X) #define VERIFY_DEVICE_INSTANCE(X) #endif //DM_DISABLE_API_PARAM_CHECK /** @} */ #define INVALID_CONTEXT_LEN 0xFFFFFFFF /**< Identifier for invalid context length. */ /**@brief Macro for checking that application context size is greater that minimal size. * * @param[in] X Size of application context. * * @retval (NRF_ERROR_INVALID_PARAM) when size is smaller than minimun required size. */ #define SIZE_CHECK_APP_CONTEXT(X) \ if ((X) < (APP_CONTEXT_MIN_SIZE)) \ { \ return NRF_ERROR_INVALID_PARAM; \ } /** * @defgroup dm_data_types Module's internal data types. * * @brief This section describes a module's internal data structures. * @{ */ /**@brief Peer identification information. */ typedef struct { ble_gap_id_key_t peer_id; /**< IRK and/or address of peer. */ uint16_t ediv; /**< Peer's encrypted diversifier. */ uint8_t id_bitmap; /**< Contains information if above field is valid. */ } peer_id_t; STATIC_ASSERT(sizeof(peer_id_t) % 4 == 0); /**< Check to ensure Peer identification information is a multiple of 4. */ /**@brief Portion of bonding information exchanged by a device during bond creation that needs to * be stored persistently. * * @note An entry is not made in this table unless device is bonded. */ typedef struct { ble_gap_enc_key_t peer_enc_key; /**< Local LTK info, central IRK and address */ } bond_context_t; STATIC_ASSERT(sizeof(bond_context_t) % 4 == 0); /**< Check to ensure bond information is a multiple of 4. */ /**@brief GATT Server Attributes size and data. */ typedef struct { uint32_t flags; /**< Flags identifying the stored attributes. */ uint32_t size; /**< Size of stored attributes. */ uint8_t attributes[DM_GATT_SERVER_ATTR_MAX_SIZE]; /**< Array to hold the server attributes. */ } dm_gatts_context_t; STATIC_ASSERT(sizeof(dm_gatts_context_t) % 4 == 0); /**< Check to ensure GATT Server Attributes size and data information is a multiple of 4. */ /**@brief GATT Client context information. Placeholder for now. */ typedef struct { void * p_dummy; /**< Placeholder, currently unused. */ } dm_gatt_client_context_t; STATIC_ASSERT(sizeof(dm_gatt_client_context_t) % 4 == 0); /**< Check to ensure GATT Client context information is a multiple of 4. */ STATIC_ASSERT((DEVICE_MANAGER_APP_CONTEXT_SIZE % 4) == 0); /**< Check to ensure device manager application context information is a multiple of 4. */ /**@brief Connection instance definition. Maintains information with respect to an active peer. */ typedef struct { ble_gap_addr_t peer_addr; /**< Peer identification information. This information is retained as long as the connection session exists, once disconnected, for non-bonded devices this information is not stored persistently. */ uint16_t conn_handle; /**< Connection handle for the device. */ uint8_t state; /**< Link state. */ uint8_t bonded_dev_id; /**< In case the device is bonded, this points to the corresponding bonded device. This index can be used to index service and bond context as well. */ } connection_instance_t; /**@brief Application instance definition. Maintains information with respect to a registered * application. */ typedef struct { dm_event_cb_t ntf_cb; /**< Callback registered with the application. */ ble_gap_sec_params_t sec_param; /**< Local security parameters registered by the application. */ uint8_t state; /**< Application state. Currently this is used only for knowing if any security procedure is in progress and/or a security procedure is pending to be requested. */ uint8_t service; /**< Service registered by the application. */ } application_instance_t; /**@brief Function for performing necessary action of storing each of the service context as * registered by the application. * * @param[in] p_block_handle Storage block identifier. * @param[in] p_handle Device handle identifying device that is stored. * * @retval Operation result code. */ typedef ret_code_t (* service_context_access_t)(pstorage_handle_t const * p_block_handle, dm_handle_t const * p_handle); /**@brief Function for performing necessary action of applying the context information. * * @param[in] p_handle Device handle identifying device that is stored. * * @retval Operation result code. */ typedef ret_code_t (* service_context_apply_t)(dm_handle_t * p_handle); /**@brief Function for performing necessary functions of storing or updating. * * @param[in] p_dest Destination address where data is stored persistently. * @param[in] p_src Source address containing data to be stored. * @param[in] size Size of data to be stored expressed in bytes. Must be word aligned. * @param[in] offset Offset in bytes to be applied when writing to the block. * * @retval Operation result code. */ typedef uint32_t (* storage_operation)(pstorage_handle_t * p_dest, uint8_t * p_src, pstorage_size_t size, pstorage_size_t offset); /** @} */ /** * @defgroup dm_tables Module's internal tables. * * @brief This section describes the module's internal tables and the static global variables * needed for its functionality. * @{ */ #if (DEVICE_MANAGER_APP_CONTEXT_SIZE != 0) static uint8_t * m_app_context_table[DEVICE_MANAGER_MAX_BONDS]; /**< Table to remember application contexts of bonded devices. */ #endif //DEVICE_MANAGER_APP_CONTEXT_SIZE __ALIGN(sizeof(uint32_t)) static peer_id_t m_peer_table[DEVICE_MANAGER_MAX_BONDS] ; /**< Table to maintain bonded devices' identification information, an instance is allocated in the table when a device is bonded and freed when bond information is deleted. */ __ALIGN(sizeof(uint32_t)) static bond_context_t m_bond_table[DEVICE_MANAGER_MAX_CONNECTIONS]; /**< Table to maintain bond information for active peers. */ static dm_gatts_context_t m_gatts_table[DEVICE_MANAGER_MAX_CONNECTIONS]; /**< Table for service information for active connection instances. */ static connection_instance_t m_connection_table[DEVICE_MANAGER_MAX_CONNECTIONS]; /**< Table to maintain active peer information. An instance is allocated in the table when a new connection is established and freed on disconnection. */ static application_instance_t m_application_table[DEVICE_MANAGER_MAX_APPLICATIONS]; /**< Table to maintain application instances. */ static pstorage_handle_t m_storage_handle; /**< Persistent storage handle for blocks requested by the module. */ static uint32_t m_peer_addr_update; /**< 32-bit bitmap to remember peer device address update. */ static ble_gap_id_key_t m_local_id_info; /**< ID information of central in case resolvable address is used. */ static bool m_module_initialized = false; /**< State indicating if module is initialized or not. */ static uint8_t m_irk_index_table[DEVICE_MANAGER_MAX_BONDS]; /**< List maintaining IRK index list. */ SDK_MUTEX_DEFINE(m_dm_mutex) /**< Mutex variable. Currently unused, this declaration does not occupy any space in RAM. */ /** @} */ static __INLINE ret_code_t no_service_context_store(pstorage_handle_t const * p_block_handle, dm_handle_t const * p_handle); static __INLINE ret_code_t gatts_context_store(pstorage_handle_t const * p_block_handle, dm_handle_t const * p_handle); static __INLINE ret_code_t gattc_context_store(pstorage_handle_t const * p_block_handle, dm_handle_t const * p_handle); static __INLINE ret_code_t gattsc_context_store(pstorage_handle_t const * p_block_handle, dm_handle_t const * p_handle); static __INLINE ret_code_t no_service_context_load(pstorage_handle_t const * p_block_handle, dm_handle_t const * p_handle); static __INLINE ret_code_t gatts_context_load(pstorage_handle_t const * p_block_handle, dm_handle_t const * p_handle); static __INLINE ret_code_t gattc_context_load(pstorage_handle_t const * p_block_handle, dm_handle_t const * p_handle); static __INLINE ret_code_t gattsc_context_load(pstorage_handle_t const * p_block_handle, dm_handle_t const * p_handle); static __INLINE ret_code_t no_service_context_apply(dm_handle_t * p_handle); static __INLINE ret_code_t gatts_context_apply(dm_handle_t * p_handle); static __INLINE ret_code_t gattc_context_apply(dm_handle_t * p_handle); static __INLINE ret_code_t gattsc_context_apply(dm_handle_t * p_handle); /**< Array of function pointers based on the types of service registered. */ const service_context_access_t m_service_context_store[DM_SERVICE_CONTEXT_COUNT] = { no_service_context_store, /**< Dummy function, when there is no service context registered. */ gatts_context_store, /**< GATT Server context store function. */ gattc_context_store, /**< GATT Client context store function. */ gattsc_context_store /**< GATT Server & Client context store function. */ }; /**< Array of function pointers based on the types of service registered. */ const service_context_access_t m_service_context_load[DM_SERVICE_CONTEXT_COUNT] = { no_service_context_load, /**< Dummy function, when there is no service context registered. */ gatts_context_load, /**< GATT Server context load function. */ gattc_context_load, /**< GATT Client context load function. */ gattsc_context_load /**< GATT Server & Client context load function. */ }; /**< Array of function pointers based on the types of service registered. */ const service_context_apply_t m_service_context_apply[DM_SERVICE_CONTEXT_COUNT] = { no_service_context_apply, /**< Dummy function, when there is no service context registered. */ gatts_context_apply, /**< GATT Server context apply function. */ gattc_context_apply, /**< GATT Client context apply function. */ gattsc_context_apply /**< GATT Server & Client context apply function. */ }; const uint32_t m_context_init_len = 0xFFFFFFFF; /**< Constant used to update the initial value for context in the flash. */ /**@brief Function for setting update status for the device identified by 'index'. * * @param[in] index Device identifier. */ static __INLINE void update_status_bit_set(uint32_t index) { m_peer_addr_update |= (BIT_0 << index); } /**@brief Function for resetting update status for device identified by 'index'. * * @param[in] index Device identifier. */ static __INLINE void update_status_bit_reset(uint32_t index) { m_peer_addr_update &= (~((uint32_t)BIT_0 << index)); } /**@brief Function for providing update status for the device identified by 'index'. * * @param[in] index Device identifier. * * @retval true if the bit is set, false otherwise. */ static __INLINE bool update_status_bit_is_set(uint32_t index) { return ((m_peer_addr_update & (BIT_0 << index)) ? true : false); } /**@brief Function for initialiasing the application instance identified by 'index'. * * @param[in] index Device identifier. */ static __INLINE void application_instance_init(uint32_t index) { DM_TRC("[DM]: Initializing Application Instance 0x%08X.\r\n", index); m_application_table[index].ntf_cb = NULL; m_application_table[index].state = 0x00; m_application_table[index].service = 0x00; } /**@brief Function for initialiasing the connection instance identified by 'index'. * * @param[in] index Device identifier. */ static __INLINE void connection_instance_init(uint32_t index) { DM_TRC("[DM]: Initializing Connection Instance 0x%08X.\r\n", index); m_connection_table[index].state = STATE_IDLE; m_connection_table[index].conn_handle = BLE_CONN_HANDLE_INVALID; m_connection_table[index].bonded_dev_id = DM_INVALID_ID; memset(&m_connection_table[index].peer_addr, 0, sizeof (ble_gap_addr_t)); } /**@brief Function for initialiasing the peer device instance identified by 'index'. * * @param[in] index Device identifier. */ static __INLINE void peer_instance_init(uint32_t index) { DM_TRC("[DM]: Initializing Peer Instance 0x%08X.\r\n", index); memset(m_peer_table[index].peer_id.id_addr_info.addr, 0, BLE_GAP_ADDR_LEN); memset(m_peer_table[index].peer_id.id_info.irk, 0, BLE_GAP_SEC_KEY_LEN); //Initialize the address type to invalid. m_peer_table[index].peer_id.id_addr_info.addr_type = INVALID_ADDR_TYPE; //Initialize the identification bit map to unassigned. m_peer_table[index].id_bitmap = UNASSIGNED; // Initialize diversifier. m_peer_table[index].ediv = EDIV_INIT_VAL; //Reset the status bit. update_status_bit_reset(index); #if (DEVICE_MANAGER_APP_CONTEXT_SIZE != 0) //Initialize the application context for bond device. m_app_context_table[index] = NULL; #endif //DEVICE_MANAGER_APP_CONTEXT_SIZE } /**@brief Function for searching connection instance matching the connection handle and the state * requested. * * @details Connection handle and state information is used to get a connection instance, it * is possible to ignore the connection handle by using BLE_CONN_HANDLE_INVALID. * * @param[in] conn_handle Connection handle. * @param[in] state Connection instance state. * @param[out] p_instance Connection instance. * * @retval NRF_SUCCESS Operation success. * @retval NRF_ERROR_INVALID_STATE Operation failure. Invalid state * @retval NRF_ERROR_NOT_FOUND Operation failure. Not found */ static ret_code_t connection_instance_find(uint16_t conn_handle, uint8_t state, uint32_t * p_instance) { ret_code_t err_code; uint32_t index; err_code = NRF_ERROR_INVALID_STATE; for (index = 0; index < DEVICE_MANAGER_MAX_CONNECTIONS; index++) { //Search only based on the state. if (state & m_connection_table[index].state) { //Ignore the connection handle. if ((conn_handle == BLE_CONN_HANDLE_INVALID) || (conn_handle == m_connection_table[index].conn_handle)) { //Search for matching connection handle. (*p_instance) = index; err_code = NRF_SUCCESS; break; } else { err_code = NRF_ERROR_NOT_FOUND; } } } return err_code; } /**@brief Function for allocating device instance for a bonded device. * * @param[out] p_device_index Device index. * @param[in] p_addr Peer identification information. * * @retval NRF_SUCCESS Operation success. * @retval DM_DEVICE_CONTEXT_FULL Operation failure. */ static __INLINE ret_code_t device_instance_allocate(uint8_t * p_device_index, ble_gap_addr_t const * p_addr) { ret_code_t err_code; uint32_t index; err_code = DM_DEVICE_CONTEXT_FULL; for (index = 0; index < DEVICE_MANAGER_MAX_BONDS; index++) { DM_TRC("[DM]:[DI 0x%02X]: Device type 0x%02X.\r\n", index, m_peer_table[index].peer_id.id_addr_info.addr_type); DM_TRC("[DM]: Device Addr 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X.\r\n", m_peer_table[index].peer_id.id_addr_info.addr[0], m_peer_table[index].peer_id.id_addr_info.addr[1], m_peer_table[index].peer_id.id_addr_info.addr[2], m_peer_table[index].peer_id.id_addr_info.addr[3], m_peer_table[index].peer_id.id_addr_info.addr[4], m_peer_table[index].peer_id.id_addr_info.addr[5]); if (m_peer_table[index].id_bitmap == UNASSIGNED) { if (p_addr->addr_type != BLE_GAP_ADDR_TYPE_RANDOM_PRIVATE_RESOLVABLE) { m_peer_table[index].id_bitmap &= (~ADDR_ENTRY); m_peer_table[index].peer_id.id_addr_info = (*p_addr); } else { m_peer_table[index].id_bitmap &= (~IRK_ENTRY); } (*p_device_index) = index; err_code = NRF_SUCCESS; DM_LOG("[DM]: Allocated device instance 0x%02X\r\n", index); break; } } return err_code; } /**@brief Function for freeing a device instance allocated for bonded device. * * @param[in] device_index Device index. * * @retval NRF_SUCCESS On success, else an error code indicating reason for failure. */ static __INLINE ret_code_t device_instance_free(uint32_t device_index) { ret_code_t err_code; pstorage_handle_t block_handle; //Get the block handle. err_code = pstorage_block_identifier_get(&m_storage_handle, device_index, &block_handle); if (err_code == NRF_SUCCESS) { DM_TRC("[DM]:[DI 0x%02X]: Freeing Instance.\r\n", device_index); //Request clearing of the block. err_code = pstorage_clear(&block_handle, ALL_CONTEXT_SIZE); if (err_code == NRF_SUCCESS) { peer_instance_init(device_index); } } return err_code; } /**@brief Function for searching for the device in the bonded device list. * * @param[in] p_addr Peer identification information. * @param[out] p_device_index Device index. * * @retval NRF_SUCCESS Operation success. * @retval NRF_ERROR_NOT_FOUND Operation failure. */ static ret_code_t device_instance_find(ble_gap_addr_t const * p_addr, uint32_t * p_device_index, uint16_t ediv) { ret_code_t err_code; uint32_t index; err_code = NRF_ERROR_NOT_FOUND; if (NULL != p_addr) { DM_TRC("[DM]: Searching for device 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X.\r\n", p_addr->addr[0], p_addr->addr[1], p_addr->addr[2], p_addr->addr[3], p_addr->addr[4], p_addr->addr[5]); } for (index = 0; index < DEVICE_MANAGER_MAX_BONDS; index++) { DM_TRC("[DM]:[DI 0x%02X]: Device type 0x%02X.\r\n", index, m_peer_table[index].peer_id.id_addr_info.addr_type); DM_TRC("[DM]: Device Addr 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X.\r\n", m_peer_table[index].peer_id.id_addr_info.addr[0], m_peer_table[index].peer_id.id_addr_info.addr[1], m_peer_table[index].peer_id.id_addr_info.addr[2], m_peer_table[index].peer_id.id_addr_info.addr[3], m_peer_table[index].peer_id.id_addr_info.addr[4], m_peer_table[index].peer_id.id_addr_info.addr[5]); if (((NULL == p_addr) && (ediv == m_peer_table[index].ediv)) || ((NULL != p_addr) && (memcmp(&m_peer_table[index].peer_id.id_addr_info, p_addr, sizeof(ble_gap_addr_t)) == 0))) { DM_LOG("[DM]: Found device at instance 0x%02X\r\n", index); (*p_device_index) = index; err_code = NRF_SUCCESS; break; } } return err_code; } /**@brief Function for notifying connection manager event to the application. * * @param[in] p_handle Device handle identifying device. * @param[in] p_event Connection manager event details. * @param[in] event_result Event result code. */ static __INLINE void app_evt_notify(dm_handle_t const * const p_handle, dm_event_t const * const p_event, uint32_t event_result) { dm_event_cb_t app_cb = m_application_table[0].ntf_cb; DM_MUTEX_UNLOCK(); DM_TRC("[DM]: Notifying application of event 0x%02X\r\n", p_event->event_id); //No need to do any kind of return value processing thus can be supressed. UNUSED_VARIABLE(app_cb(p_handle, p_event, event_result)); DM_MUTEX_LOCK(); } /**@brief Function for allocating instance. * * @details The instance identifier is provided in the 'p_instance' parameter if the routine * succeeds. * * @param[out] p_instance Connection instance. * * @retval NRF_SUCCESS Operation success. * @retval NRF_ERROR_NO_MEM Operation failure. No memory. */ static __INLINE uint32_t connection_instance_allocate(uint32_t * p_instance) { uint32_t err_code; DM_TRC("[DM]: Request to allocation connection instance\r\n"); err_code = connection_instance_find(BLE_CONN_HANDLE_INVALID, STATE_IDLE, p_instance); if (err_code == NRF_SUCCESS) { DM_LOG("[DM]:[%02X]: Connection Instance Allocated.\r\n", (*p_instance)); m_connection_table[*p_instance].state = STATE_CONNECTED; } else { DM_LOG("[DM]: No free connection instances available\r\n"); err_code = NRF_ERROR_NO_MEM; } return err_code; } /**@brief Function for freeing instance. Instance identifier is provided in the parameter * 'p_instance' in case the routine succeeds. * * @param[in] p_instance Connection instance. */ static __INLINE void connection_instance_free(uint32_t const * p_instance) { DM_TRC("[DM]:[CI 0x%02X]: Freeing connection instance\r\n", (*p_instance)); if (m_connection_table[*p_instance].state != STATE_IDLE) { DM_LOG("[DM]:[%02X]: Freed connection instance.\r\n", (*p_instance)); connection_instance_init(*p_instance); } } /**@brief Function for storage operation dummy handler. * * @param[in] p_dest Destination address where data is to be stored persistently. * @param[in] p_src Source address containing data to be stored. API assumes this to be resident * memory and no intermediate copy of data is made by the API. * @param[in] size Size of data to be stored expressed in bytes. Should be word aligned. * @param[in] offset Offset in bytes to be applied when writing to the block. * For example, if within a block of 100 bytes, application wishes to * write 20 bytes at offset of 12, then this field should be set to 12. * Should be word aligned. * * @retval NRF_SUCCESS Operation success. */ static uint32_t storage_operation_dummy_handler(pstorage_handle_t * p_dest, uint8_t * p_src, pstorage_size_t size, pstorage_size_t offset) { return NRF_SUCCESS; } /**@brief Function for saving the device context persistently. * * @param[in] p_handle Device handle identifying device. * @param[in] state Device store state. */ static __INLINE void device_context_store(dm_handle_t const * p_handle, device_store_state_t state) { pstorage_handle_t block_handle; storage_operation store_fn; ret_code_t err_code; DM_LOG("[DM]: --> device_context_store\r\n"); err_code = pstorage_block_identifier_get(&m_storage_handle, p_handle->device_id, &block_handle); if (err_code == NRF_SUCCESS) { if ((STATE_BOND_INFO_UPDATE == (m_connection_table[p_handle->connection_id].state & STATE_BOND_INFO_UPDATE)) || (state == UPDATE_PEER_ADDR)) { DM_LOG("[DM]:[DI %02X]:[CI %02X]: -> Updating bonding information.\r\n", p_handle->device_id, p_handle->connection_id); store_fn = pstorage_update; } else if (state == FIRST_BOND_STORE) { DM_LOG("[DM]:[DI %02X]:[CI %02X]: -> Storing bonding information.\r\n", p_handle->device_id, p_handle->connection_id); store_fn = pstorage_store; } else { DM_LOG("[DM]:[DI %02X]:[CI %02X]: -> No update in bonding information.\r\n", p_handle->device_id, p_handle->connection_id); //No operation needed. store_fn = storage_operation_dummy_handler; } //Store the peer id. err_code = store_fn(&block_handle, (uint8_t *)&m_peer_table[p_handle->device_id], PEER_ID_SIZE, PEER_ID_STORAGE_OFFSET); if ((err_code == NRF_SUCCESS) && (state != UPDATE_PEER_ADDR)) { m_connection_table[p_handle->connection_id].state &= (~STATE_BOND_INFO_UPDATE); //Store the bond information. err_code = store_fn(&block_handle, (uint8_t *)&m_bond_table[p_handle->connection_id], BOND_SIZE, BOND_STORAGE_OFFSET); if (err_code != NRF_SUCCESS) { DM_ERR("[DM]:[0x%02X]:Failed to store bond information, reason 0x%08X\r\n", p_handle->device_id, err_code); } } if (state != UPDATE_PEER_ADDR) { //Store the service information err_code = m_service_context_store[m_application_table[p_handle->appl_id].service] ( &block_handle, p_handle ); if (err_code != NRF_SUCCESS) { //Notify application of an error event. DM_ERR("[DM]: Failed to store service context, reason %08X\r\n", err_code); } } } if (err_code != NRF_SUCCESS) { //Notify application of an error event. DM_ERR("[DM]: Failed to store device context, reason %08X\r\n", err_code); } } /**@brief Function for storing when there is no service registered. * * @param[in] p_block_handle Storage block identifier. * @param[in] p_handle Device handle identifying device that is loaded. * * @retval NRF_SUCCESS */ static __INLINE ret_code_t no_service_context_store(pstorage_handle_t const * p_block_handle, dm_handle_t const * p_handle) { DM_LOG("[DM]: --> no_service_context_store\r\n"); return NRF_SUCCESS; } /**@brief Function for storing GATT Server context. * * @param[in] p_block_handle Storage block identifier. * @param[in] p_handle Device handle identifying device that is stored. * * @retval NRF_SUCCESS Operation success. */ static __INLINE ret_code_t gatts_context_store(pstorage_handle_t const * p_block_handle, dm_handle_t const * p_handle) { storage_operation store_fn; uint32_t attr_flags = BLE_GATTS_SYS_ATTR_FLAG_SYS_SRVCS | BLE_GATTS_SYS_ATTR_FLAG_USR_SRVCS; uint16_t attr_len = DM_GATT_SERVER_ATTR_MAX_SIZE; uint8_t sys_data[DM_GATT_SERVER_ATTR_MAX_SIZE]; DM_LOG("[DM]: --> gatts_context_store\r\n"); uint32_t err_code = sd_ble_gatts_sys_attr_get( m_connection_table[p_handle->connection_id].conn_handle, sys_data, &attr_len, attr_flags); if (err_code == NRF_SUCCESS) { if (memcmp(m_gatts_table[p_handle->connection_id].attributes, sys_data, attr_len) == 0) { //No store operation is needed. DM_LOG("[DM]:[0x%02X]: No change in GATTS Context information.\r\n", p_handle->device_id); if ((m_connection_table[p_handle->connection_id].state & STATE_CONNECTED) != STATE_CONNECTED) { DM_LOG("[DM]:[0x%02X]: Resetting GATTS for active instance.\r\n", p_handle->connection_id); //Reset GATTS information for the current context. memset(&m_gatts_table[p_handle->connection_id], 0, sizeof(dm_gatts_context_t)); } } else { if (m_gatts_table[p_handle->connection_id].size != 0) { //There is data already stored in persistent memory, therefore an update is needed. DM_LOG("[DM]:[0x%02X]: Updating stored service context\r\n", p_handle->device_id); store_fn = pstorage_update; } else { //Fresh write, a store is needed. DM_LOG("[DM]:[0x%02X]: Storing service context\r\n", p_handle->device_id); store_fn = pstorage_store; } m_gatts_table[p_handle->connection_id].flags = attr_flags; m_gatts_table[p_handle->connection_id].size = attr_len; memcpy(m_gatts_table[p_handle->connection_id].attributes, sys_data, attr_len); DM_DUMP((uint8_t *)&m_gatts_table[p_handle->connection_id], sizeof(dm_gatts_context_t)); DM_LOG("[DM]:[0x%02X]: GATTS Data size 0x%08X\r\n", p_handle->device_id, m_gatts_table[p_handle->connection_id].size); //Store GATTS information. err_code = store_fn((pstorage_handle_t *)p_block_handle, (uint8_t *)&m_gatts_table[p_handle->connection_id], GATTS_SERVICE_CONTEXT_SIZE, SERVICE_STORAGE_OFFSET); if (err_code != NRF_SUCCESS) { DM_ERR("[DM]:[0x%02X]:Failed to store service context, reason 0x%08X\r\n", p_handle->device_id, err_code); } else { DM_LOG("[DM]: Service context successfully stored.\r\n"); } } } return NRF_SUCCESS; } /**@brief Function for storing GATT Client context. * * @param[in] p_block_handle Storage block identifier. * @param[in] p_handle Device handle identifying device that is stored. * * @retval NRF_SUCCESS Operation success. */ static __INLINE ret_code_t gattc_context_store(pstorage_handle_t const * p_block_handle, dm_handle_t const * p_handle) { DM_LOG("[DM]: --> gattc_context_store\r\n"); return NRF_SUCCESS; } /**@brief Function for storing GATT Server & Client context. * * @param[in] p_block_handle Storage block identifier. * @param[in] p_handle Device handle identifying device that is stored. * * @retval NRF_SUCCESS On success, else an error code indicating reason for failure. */ static __INLINE ret_code_t gattsc_context_store(pstorage_handle_t const * p_block_handle, dm_handle_t const * p_handle) { DM_LOG("[DM]: --> gattsc_context_store\r\n"); ret_code_t err_code = gatts_context_store(p_block_handle, p_handle); if (NRF_SUCCESS == err_code) { err_code = gattc_context_store(p_block_handle, p_handle); } return err_code; } /**@brief Function for loading when there is no service registered. * * @param[in] p_block_handle Storage block identifier. * @param[in] p_handle Device handle identifying device that is loaded. * * @retval NRF_SUCCESS */ static __INLINE ret_code_t no_service_context_load(pstorage_handle_t const * p_block_handle, dm_handle_t const * p_handle) { DM_LOG("[DM]: --> no_service_context_load\r\n"); return NRF_SUCCESS; } /**@brief Function for loading GATT Server context. * * @param[in] p_block_handle Storage block identifier. * @param[in] p_handle Device handle identifying device that is loaded. * * @retval NRF_SUCCESS On success, else an error code indicating reason for failure. */ static __INLINE ret_code_t gatts_context_load(pstorage_handle_t const * p_block_handle, dm_handle_t const * p_handle) { DM_LOG("[DM]:[CI 0x%02X]:[DI 0x%02X]: --> gatts_context_load\r\n", p_handle->connection_id, p_handle->device_id); ret_code_t err_code = pstorage_load((uint8_t *)&m_gatts_table[p_handle->connection_id], (pstorage_handle_t *)p_block_handle, GATTS_SERVICE_CONTEXT_SIZE, SERVICE_STORAGE_OFFSET); if (err_code == NRF_SUCCESS) { DM_LOG("[DM]:[%02X]:[Block ID 0x%08X]: Service context loaded, size 0x%08X\r\n", p_handle->connection_id, p_block_handle->block_id, m_gatts_table[p_handle->connection_id].size); DM_DUMP((uint8_t *)&m_gatts_table[p_handle->connection_id], sizeof(dm_gatts_context_t)); if (m_gatts_table[p_handle->connection_id].size == DM_GATTS_INVALID_SIZE) { m_gatts_table[p_handle->connection_id].size = 0; } } else { DM_ERR("[DM]:[%02X]: Failed to load Service context, reason %08X\r\n", p_handle->connection_id, err_code); } return err_code; } /**@brief Function for loading GATT Client context. * * @param[in] p_block_handle Storage block identifier. * @param[in] p_handle Device handle identifying device that is loaded. * * @retval NRF_SUCCESS */ static __INLINE ret_code_t gattc_context_load(pstorage_handle_t const * p_block_handle, dm_handle_t const * p_handle) { DM_LOG("[DM]: --> gattc_context_load\r\n"); return NRF_SUCCESS; } /**@brief Function for loading GATT Server & Client context. * * @param[in] p_block_handle Storage block identifier. * @param[in] p_handle Device handle identifying device that is loaded. * * @retval NRF_SUCCESS On success, else an error code indicating reason for failure. */ static __INLINE ret_code_t gattsc_context_load(pstorage_handle_t const * p_block_handle, dm_handle_t const * p_handle) { DM_LOG("[DM]: --> gattsc_context_load\r\n"); ret_code_t err_code = gatts_context_load(p_block_handle, p_handle); if (NRF_SUCCESS == err_code) { err_code = gattc_context_load(p_block_handle, p_handle); } return err_code; } /**@brief Function for applying when there is no service registered. * * @param[in] p_handle Device handle identifying device that is applied. * * @retval NRF_SUCCESS */ static __INLINE ret_code_t no_service_context_apply(dm_handle_t * p_handle) { DM_LOG("[DM]: --> no_service_context_apply\r\n"); DM_LOG("[DM]:[CI 0x%02X]: No Service context\r\n", p_handle->connection_id); return NRF_SUCCESS; } /**@brief Function for applying GATT Server context. * * @param[in] p_handle Device handle identifying device that is applied. * * @retval NRF_SUCCESS On success. * @retval DM_SERVICE_CONTEXT_NOT_APPLIED On failure. */ static __INLINE ret_code_t gatts_context_apply(dm_handle_t * p_handle) { uint32_t err_code; uint8_t * p_gatts_context = NULL; uint16_t context_len = 0; uint32_t context_flags = 0; DM_LOG("[DM]: --> gatts_context_apply\r\n"); DM_LOG("[DM]:[CI 0x%02X]: State 0x%02X, Size 0x%08X\r\n", p_handle->connection_id, m_connection_table[p_handle->connection_id].state, m_gatts_table[p_handle->connection_id].size); if ((m_gatts_table[p_handle->connection_id].size != 0) && ( ((m_connection_table[p_handle->connection_id].state & STATE_LINK_ENCRYPTED) == STATE_LINK_ENCRYPTED) && ((m_connection_table[p_handle->connection_id].state & STATE_BOND_INFO_UPDATE) != STATE_BOND_INFO_UPDATE) ) ) { DM_LOG("[DM]: Setting stored context.\r\n"); p_gatts_context = &m_gatts_table[p_handle->connection_id].attributes[0]; context_len = m_gatts_table[p_handle->connection_id].size; context_flags = m_gatts_table[p_handle->connection_id].flags; } err_code = sd_ble_gatts_sys_attr_set(m_connection_table[p_handle->connection_id].conn_handle, p_gatts_context, context_len, context_flags); if (err_code == NRF_ERROR_INVALID_DATA) { // Indication that the ATT table has changed. Restore the system attributes to system // services only and send a service changed indication if possible. context_flags = BLE_GATTS_SYS_ATTR_FLAG_SYS_SRVCS; err_code = sd_ble_gatts_sys_attr_set(m_connection_table[p_handle->connection_id].conn_handle, p_gatts_context, context_len, context_flags); } if (err_code != NRF_SUCCESS) { DM_LOG("[DM]: Failed to set system attributes, reason 0x%08X.\r\n", err_code); err_code = DM_SERVICE_CONTEXT_NOT_APPLIED; } if (context_flags == BLE_GATTS_SYS_ATTR_FLAG_SYS_SRVCS) { err_code = sd_ble_gatts_service_changed(m_connection_table[p_handle->connection_id].conn_handle, 0x000C, 0xFFFF); if (err_code != NRF_SUCCESS) { DM_LOG("[DM]: Failed to send Service Changed indication, reason 0x%08X.\r\n", err_code); if ((err_code != BLE_ERROR_INVALID_CONN_HANDLE) && (err_code != NRF_ERROR_INVALID_STATE) && (err_code != BLE_ERROR_NO_TX_PACKETS) && (err_code != NRF_ERROR_BUSY)) { // Those errors can be expected when sending trying to send Service Changed // Indication if the CCCD is not set to indicate. Thus set the returning error // code to success. err_code = NRF_SUCCESS; } else { err_code = DM_SERVICE_CONTEXT_NOT_APPLIED; } } } return err_code; } /**@brief Function for applying GATT Client context. * * @param[in] p_handle Device handle identifying device that is applied. * * @retval NRF_SUCCESS On success. */ static __INLINE ret_code_t gattc_context_apply(dm_handle_t * p_handle) { DM_LOG("[DM]: --> gattc_context_apply\r\n"); return NRF_SUCCESS; } /**@brief Function for applying GATT Server & Client context. * * @param[in] p_handle Device handle identifying device that is applied. * * @retval NRF_SUCCESS On success, else an error code indicating reason for failure. */ static __INLINE ret_code_t gattsc_context_apply(dm_handle_t * p_handle) { uint32_t err_code; DM_LOG("[DM]: --> gattsc_context_apply\r\n"); err_code = gatts_context_apply(p_handle); if (err_code == NRF_SUCCESS) { err_code = gattc_context_apply(p_handle); } return err_code; } /**@brief Function for pstorage module callback. * * @param[in] p_handle Identifies module and block for which callback is received. * @param[in] op_code Identifies the operation for which the event is notified. * @param[in] result Identifies the result of flash access operation. * NRF_SUCCESS implies, operation succeeded. * @param[in] p_data Identifies the application data pointer. In case of store operation, this * points to the resident source of application memory that application can now * free or reuse. In case of clear, this is NULL as no application pointer is * needed for this operation. * @param[in] data_len Length of data provided by the application for the operation. */ static void dm_pstorage_cb_handler(pstorage_handle_t * p_handle, uint8_t op_code, uint32_t result, uint8_t * p_data, uint32_t data_len) { VERIFY_APP_REGISTERED_VOID(0); if (data_len > ALL_CONTEXT_SIZE) { //Clearing of all bonds at initialization, no event is generated. return; } DM_MUTEX_LOCK(); dm_event_t dm_event; dm_handle_t dm_handle; dm_context_t context_data; pstorage_handle_t block_handle; uint32_t index_count; uint32_t err_code; bool app_notify = true; err_code = dm_handle_initialize(&dm_handle); APP_ERROR_CHECK(err_code); dm_handle.appl_id = 0; dm_event.event_id = 0x00; //Construct the event which it is related to. //Initialize context data information and length. context_data.p_data = p_data; context_data.len = data_len; for (uint32_t index = 0; index < DEVICE_MANAGER_MAX_BONDS; index++) { err_code = pstorage_block_identifier_get(&m_storage_handle, index, &block_handle); if ((err_code == NRF_SUCCESS) && ( (memcmp(p_handle, &block_handle, sizeof(pstorage_handle_t)) == 0) ) ) { dm_handle.device_id = index; break; } } if (dm_handle.device_id != DM_INVALID_ID) { if (op_code == PSTORAGE_CLEAR_OP_CODE) { if (data_len == ALL_CONTEXT_SIZE) { dm_event.event_id = DM_EVT_DEVICE_CONTEXT_BASE; } else { dm_event.event_id = DM_EVT_APP_CONTEXT_BASE; } } else { //Update or store operation. //Context is identified based on the pointer value. Device context, application context //and service context all have their own value range. index_count = ((uint32_t)(p_data - (uint8_t *)m_peer_table)) / PEER_ID_SIZE; if (index_count < DEVICE_MANAGER_MAX_BONDS) { dm_event.event_param.p_device_context = &context_data; //Only the peer identification is stored, not bond information. Hence do not notify //the application yet, unless the store operation resulted in a failure. if ((result == NRF_SUCCESS) && ( (update_status_bit_is_set(dm_handle.device_id) == false) ) ) { app_notify = false; } else { //Reset update status since update is complete. update_status_bit_reset(dm_handle.device_id); //Notify application of error in storing the context. dm_event.event_id = DM_EVT_DEVICE_CONTEXT_BASE; } } else { index_count = ((uint32_t)(p_data - (uint8_t *)m_bond_table)) / BOND_SIZE; if (index_count < DEVICE_MANAGER_MAX_CONNECTIONS) { DM_LOG("[DM]:[0x%02X]:[0x%02X]: Bond context Event\r\n", dm_handle.device_id, dm_handle.connection_id); dm_event.event_param.p_device_context = &context_data; dm_event.event_id = DM_EVT_DEVICE_CONTEXT_BASE; dm_handle.connection_id = index_count; ble_gap_sec_keyset_t keys_exchanged; keys_exchanged.keys_peer.p_enc_key = NULL; keys_exchanged.keys_peer.p_id_key = &m_local_id_info; keys_exchanged.keys_own.p_enc_key = &m_bond_table[index_count].peer_enc_key; keys_exchanged.keys_own.p_id_key = &m_peer_table[dm_handle.device_id].peer_id; //Context information updated to provide the keys. context_data.p_data = (uint8_t *)&keys_exchanged; context_data.len = sizeof(ble_gap_sec_keyset_t); } else { index_count = ((uint32_t)(p_data - (uint8_t *)m_gatts_table)) / GATTS_SERVICE_CONTEXT_SIZE; if (index_count < DEVICE_MANAGER_MAX_CONNECTIONS) { DM_LOG("[DM]:[0x%02X]:[0x%02X]: Service context Event\r\n", dm_handle.device_id, dm_handle.connection_id); //Notify application. dm_event.event_id = DM_EVT_SERVICE_CONTEXT_BASE; dm_handle.connection_id = index_count; dm_handle.service_id = DM_PROTOCOL_CNTXT_GATT_SRVR_ID; //Reset the service context now that it was successfully written to the //application and the link is disconnected. if ((m_connection_table[index_count].state & STATE_CONNECTED) != STATE_CONNECTED) { DM_LOG("[DM]:[0x%02X]:[0x%02X]: Resetting bond information for " "active instance.\r\n", dm_handle.device_id, dm_handle.connection_id); memset(&m_gatts_table[dm_handle.connection_id], 0, sizeof(dm_gatts_context_t)); } } else { DM_LOG("[DM]:[0x%02X]:[0x%02X]: App context Event\r\n", dm_handle.device_id, dm_handle.connection_id); app_notify = false; dm_event.event_id = DM_EVT_APP_CONTEXT_BASE; #if (DEVICE_MANAGER_APP_CONTEXT_SIZE != 0) if (p_data == (uint8_t *)(&m_context_init_len)) { //Context data is deleted. //This is a workaround to get the right event as on delete operation //update operation is used instead of clear. op_code = PSTORAGE_CLEAR_OP_CODE; app_notify = true; } else if (m_app_context_table[dm_handle.device_id] == p_data) { app_notify = true; dm_event.event_param.p_app_context = &context_data; //Verify if the device is connected, if yes set connection instance. for (uint32_t index = 0; index < DEVICE_MANAGER_MAX_CONNECTIONS; index++) { if (dm_handle.device_id == m_connection_table[index].bonded_dev_id) { dm_handle.connection_id = index; break; } } } else { //No implementation needed. } #endif //DEVICE_MANAGER_APP_CONTEXT_SIZE } } } } if (app_notify == true) { if (op_code == PSTORAGE_CLEAR_OP_CODE) { dm_event.event_id |= DM_CLEAR_OPERATION_ID; } else if (op_code == PSTORAGE_LOAD_OP_CODE) { dm_event.event_id |= DM_LOAD_OPERATION_ID; } else { dm_event.event_id |= DM_STORE_OPERATION_ID; } dm_event.event_param.p_app_context = &context_data; app_evt_notify(&dm_handle, &dm_event, result); } } DM_MUTEX_UNLOCK(); } ret_code_t dm_init(dm_init_param_t const * const p_init_param) { pstorage_module_param_t param; pstorage_handle_t block_handle; ret_code_t err_code; uint32_t index; DM_LOG("[DM]: >> dm_init.\r\n"); NULL_PARAM_CHECK(p_init_param); SDK_MUTEX_INIT(m_dm_mutex); DM_MUTEX_LOCK(); for (index = 0; index < DEVICE_MANAGER_MAX_APPLICATIONS; index++) { application_instance_init(index); } for (index = 0; index < DEVICE_MANAGER_MAX_CONNECTIONS; index++) { connection_instance_init(index); } memset(m_gatts_table, 0, sizeof(m_gatts_table)); //Initialization of all device instances. for (index = 0; index < DEVICE_MANAGER_MAX_BONDS; index++) { peer_instance_init(index); m_irk_index_table[index] = DM_INVALID_ID; } //All context with respect to a particular device is stored contiguously. param.block_size = ALL_CONTEXT_SIZE; param.block_count = DEVICE_MANAGER_MAX_BONDS; param.cb = dm_pstorage_cb_handler; err_code = pstorage_register(¶m, &m_storage_handle); if (err_code == NRF_SUCCESS) { m_module_initialized = true; if (p_init_param->clear_persistent_data == false) { DM_LOG("[DM]: Storage handle 0x%08X.\r\n", m_storage_handle.block_id); //Copy bonded peer device address and IRK to RAM table. //Bonded devices are stored in range (0,DEVICE_MANAGER_MAX_BONDS-1). The remaining //range is for active connections that may or may not be bonded. for (index = 0; index < DEVICE_MANAGER_MAX_BONDS; index++) { err_code = pstorage_block_identifier_get(&m_storage_handle, index, &block_handle); //Issue read request if you successfully get the block identifier. if (err_code == NRF_SUCCESS) { DM_TRC("[DM]:[0x%02X]: Block handle 0x%08X.\r\n", index, block_handle.block_id); err_code = pstorage_load((uint8_t *)&m_peer_table[index], &block_handle, sizeof(peer_id_t), 0); if (err_code != NRF_SUCCESS) { // In case a peer device could not be loaded successfully, rest of the // initialization procedure are skipped and an error is sent to the // application. DM_ERR( "[DM]: Failed to load peer device %08X from storage, reason %08X.\r\n", index, err_code); m_module_initialized = false; break; } else { DM_TRC("[DM]:[DI 0x%02X]: Device type 0x%02X.\r\n", index, m_peer_table[index].peer_id.id_addr_info.addr_type); DM_TRC("[DM]: Device Addr 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X.\r\n", m_peer_table[index].peer_id.id_addr_info.addr[0], m_peer_table[index].peer_id.id_addr_info.addr[1], m_peer_table[index].peer_id.id_addr_info.addr[2], m_peer_table[index].peer_id.id_addr_info.addr[3], m_peer_table[index].peer_id.id_addr_info.addr[4], m_peer_table[index].peer_id.id_addr_info.addr[5]); } } else { //In case a peer device could not be loaded successfully, rest of the //initialization procedure are skipped and an error is sent to the application. DM_LOG("[DM]: Failed to get block handle for instance %08X, reason %08X.\r\n", index, err_code); m_module_initialized = false; break; } } } else { err_code = pstorage_clear(&m_storage_handle, (param.block_size * param.block_count)); DM_ERR("[DM]: Successfully requested clear of persistent data.\r\n"); } } else { DM_ERR("[DM]: Failed to register with storage module, reason 0x%08X.\r\n", err_code); } DM_MUTEX_UNLOCK(); DM_TRC("[DM]: << dm_init.\r\n"); return err_code; } ret_code_t dm_register(dm_application_instance_t * p_appl_instance, dm_application_param_t const * p_appl_param) { VERIFY_MODULE_INITIALIZED(); NULL_PARAM_CHECK(p_appl_instance); NULL_PARAM_CHECK(p_appl_param); NULL_PARAM_CHECK(p_appl_param->evt_handler); DM_MUTEX_LOCK(); DM_LOG("[DM]: >> dm_register.\r\n"); uint32_t err_code; //Verify if an application instance is available. Currently only one instance is supported. if (m_application_table[0].ntf_cb == NULL) { DM_LOG("[DM]: Application Instance allocated.\r\n"); //Mark instance as allocated. m_application_table[0].ntf_cb = p_appl_param->evt_handler; m_application_table[0].sec_param = p_appl_param->sec_param; m_application_table[0].service = p_appl_param->service_type; m_application_table[0].sec_param.kdist_peer.enc = 0; m_application_table[0].sec_param.kdist_peer.id = 1; m_application_table[0].sec_param.kdist_peer.sign = 0; m_application_table[0].sec_param.kdist_own.enc = 1; m_application_table[0].sec_param.kdist_own.id = 1; m_application_table[0].sec_param.kdist_own.sign = 0; //Populate application's instance variable with the assigned allocation instance. *p_appl_instance = 0; err_code = NRF_SUCCESS; } else { err_code = (NRF_ERROR_NO_MEM | DEVICE_MANAGER_ERR_BASE); } DM_MUTEX_UNLOCK(); DM_TRC("[DM]: << dm_register.\r\n"); return err_code; } ret_code_t dm_security_setup_req(dm_handle_t * p_handle) { VERIFY_MODULE_INITIALIZED(); NULL_PARAM_CHECK(p_handle); VERIFY_APP_REGISTERED(p_handle->appl_id); VERIFY_CONNECTION_INSTANCE(p_handle->connection_id); DM_MUTEX_LOCK(); DM_LOG("[DM]: >> dm_security_setup_req\r\n"); uint32_t err_code = (NRF_ERROR_INVALID_STATE | DEVICE_MANAGER_ERR_BASE); if ((m_connection_table[p_handle->connection_id].state & STATE_CONNECTED) == STATE_CONNECTED) { err_code = sd_ble_gap_authenticate(m_connection_table[p_handle->connection_id].conn_handle, &m_application_table[0].sec_param); } DM_TRC("[DM]: << dm_security_setup_req, 0x%08X\r\n", err_code); DM_MUTEX_UNLOCK(); return err_code; } ret_code_t dm_security_status_req(dm_handle_t const * p_handle, dm_security_status_t * p_status) { VERIFY_MODULE_INITIALIZED(); NULL_PARAM_CHECK(p_handle); NULL_PARAM_CHECK(p_status); VERIFY_APP_REGISTERED(p_handle->appl_id); VERIFY_CONNECTION_INSTANCE(p_handle->connection_id); DM_MUTEX_LOCK(); DM_LOG("[DM]: >> dm_security_status_req\r\n"); if ((m_connection_table[p_handle->connection_id].state & STATE_PAIRING) || (m_connection_table[p_handle->connection_id].state & STATE_PAIRING_PENDING)) { (*p_status) = ENCRYPTION_IN_PROGRESS; } else if (m_connection_table[p_handle->connection_id].state & STATE_LINK_ENCRYPTED) { (*p_status) = ENCRYPTED; } else { (*p_status) = NOT_ENCRYPTED; } DM_TRC("[DM]: << dm_security_status_req\r\n"); DM_MUTEX_UNLOCK(); return NRF_SUCCESS; } ret_code_t dm_whitelist_create(dm_application_instance_t const * p_handle, ble_gap_whitelist_t * p_whitelist) { VERIFY_MODULE_INITIALIZED(); NULL_PARAM_CHECK(p_handle); NULL_PARAM_CHECK(p_whitelist); NULL_PARAM_CHECK(p_whitelist->pp_addrs); NULL_PARAM_CHECK(p_whitelist->pp_irks); VERIFY_APP_REGISTERED(*p_handle); DM_MUTEX_LOCK(); DM_LOG("[DM]: >> dm_whitelist_create\r\n"); uint32_t addr_count = 0; uint32_t irk_count = 0; bool connected = false; for (uint32_t index = 0; index < DEVICE_MANAGER_MAX_BONDS; index++) { connected = false; for (uint32_t c_index = 0; c_index < DEVICE_MANAGER_MAX_CONNECTIONS; c_index++) { if ((index == m_connection_table[c_index].bonded_dev_id) && ((m_connection_table[c_index].state & STATE_CONNECTED) == STATE_CONNECTED)) { connected = true; break; } } if (connected == false) { if ((irk_count < p_whitelist->irk_count) && ((m_peer_table[index].id_bitmap & IRK_ENTRY) == 0)) { p_whitelist->pp_irks[irk_count] = &m_peer_table[index].peer_id.id_info; m_irk_index_table[irk_count] = index; irk_count++; } if ((addr_count < p_whitelist->addr_count) && (m_peer_table[index].id_bitmap & ADDR_ENTRY) == 0) { p_whitelist->pp_addrs[addr_count] = &m_peer_table[index].peer_id.id_addr_info; addr_count++; } } } p_whitelist->addr_count = addr_count; p_whitelist->irk_count = irk_count; DM_LOG("[DM]: Created whitelist, number of IRK = 0x%02X, number of addr = 0x%02X\r\n", irk_count, addr_count); DM_TRC("[DM]: << dm_whitelist_create\r\n"); DM_MUTEX_UNLOCK(); return NRF_SUCCESS; } ret_code_t dm_device_add(dm_handle_t * p_handle, dm_device_context_t const * p_context) { return (API_NOT_IMPLEMENTED | DEVICE_MANAGER_ERR_BASE); } ret_code_t dm_device_delete(dm_handle_t const * p_handle) { VERIFY_MODULE_INITIALIZED(); NULL_PARAM_CHECK(p_handle); VERIFY_APP_REGISTERED(p_handle->appl_id); VERIFY_DEVICE_INSTANCE(p_handle->device_id); DM_MUTEX_LOCK(); DM_TRC("[DM]: >> dm_device_delete\r\n"); uint32_t err_code = device_instance_free(p_handle->device_id); DM_TRC("[DM]: << dm_device_delete\r\n"); DM_MUTEX_UNLOCK(); return err_code; } ret_code_t dm_device_delete_all(dm_application_instance_t const * p_handle) { VERIFY_MODULE_INITIALIZED(); NULL_PARAM_CHECK(p_handle); VERIFY_APP_REGISTERED((*p_handle)); DM_MUTEX_LOCK(); uint32_t err_code = NRF_SUCCESS; DM_TRC("[DM]: >> dm_device_delete_all\r\n"); for (uint32_t index = 0; index < DEVICE_MANAGER_MAX_BONDS; index++) { if (m_peer_table[index].id_bitmap != UNASSIGNED) { err_code = device_instance_free(index); } } DM_TRC("[DM]: << dm_device_delete_all\r\n"); DM_MUTEX_UNLOCK(); return err_code; } ret_code_t dm_service_context_set(dm_handle_t const * p_handle, dm_service_context_t const * p_context) { VERIFY_MODULE_INITIALIZED(); NULL_PARAM_CHECK(p_handle); NULL_PARAM_CHECK(p_context); VERIFY_APP_REGISTERED(p_handle->appl_id); VERIFY_CONNECTION_INSTANCE(p_handle->connection_id); VERIFY_DEVICE_INSTANCE(p_handle->device_id); DM_MUTEX_LOCK(); DM_TRC("[DM]: >> dm_service_context_set\r\n"); if ((p_context->context_data.p_data != NULL) && ( (p_context->context_data.len != 0) && (p_context->context_data.len < DM_GATT_SERVER_ATTR_MAX_SIZE) ) ) { if (p_context->service_type == DM_PROTOCOL_CNTXT_GATT_SRVR_ID) { memcpy(m_gatts_table[p_handle->connection_id].attributes, p_context->context_data.p_data, p_context->context_data.len); } } pstorage_handle_t block_handle; uint32_t err_code = pstorage_block_identifier_get(&m_storage_handle, p_handle->device_id, &block_handle); err_code = m_service_context_store[p_context->service_type](&block_handle, p_handle); DM_TRC("[DM]: << dm_service_context_set\r\n"); DM_MUTEX_UNLOCK(); return err_code; } ret_code_t dm_service_context_get(dm_handle_t const * p_handle, dm_service_context_t * p_context) { VERIFY_MODULE_INITIALIZED(); NULL_PARAM_CHECK(p_handle); NULL_PARAM_CHECK(p_context); VERIFY_APP_REGISTERED(p_handle->appl_id); VERIFY_DEVICE_INSTANCE(p_handle->device_id); if ((m_connection_table[p_handle->connection_id].state & STATE_CONNECTED) != STATE_CONNECTED) { DM_TRC("[DM]: Device must be connected to get context. \r\n"); return (FEATURE_NOT_ENABLED | DEVICE_MANAGER_ERR_BASE); } DM_MUTEX_LOCK(); DM_TRC("[DM]: >> dm_service_context_get\r\n"); if (p_context->service_type == DM_PROTOCOL_CNTXT_GATT_SRVR_ID) { p_context->context_data.p_data = m_gatts_table[p_handle->connection_id].attributes; p_context->context_data.len = m_gatts_table[p_handle->connection_id].size; } pstorage_handle_t block_handle; uint32_t err_code = pstorage_block_identifier_get(&m_storage_handle, p_handle->device_id, &block_handle); err_code = m_service_context_load[p_context->service_type](&block_handle, p_handle); if (p_context->service_type == DM_PROTOCOL_CNTXT_GATT_SRVR_ID) { p_context->context_data.p_data = m_gatts_table[p_handle->connection_id].attributes; p_context->context_data.len = m_gatts_table[p_handle->connection_id].size; } DM_TRC("[DM]: << dm_service_context_get\r\n"); DM_MUTEX_UNLOCK(); return err_code; } ret_code_t dm_service_context_delete(dm_handle_t const * p_handle) { VERIFY_MODULE_INITIALIZED(); NULL_PARAM_CHECK(p_handle); VERIFY_APP_REGISTERED(p_handle->appl_id); VERIFY_DEVICE_INSTANCE(p_handle->device_id); DM_LOG("[DM]: Context delete is not supported yet.\r\n"); return (API_NOT_IMPLEMENTED | DEVICE_MANAGER_ERR_BASE); } ret_code_t dm_application_context_set(dm_handle_t const * p_handle, dm_application_context_t const * p_context) { #if (DEVICE_MANAGER_APP_CONTEXT_SIZE != 0) VERIFY_MODULE_INITIALIZED(); NULL_PARAM_CHECK(p_handle); NULL_PARAM_CHECK(p_context); NULL_PARAM_CHECK(p_context->p_data); VERIFY_APP_REGISTERED(p_handle->appl_id); VERIFY_DEVICE_INSTANCE(p_handle->device_id); VERIFY_DEVICE_BOND(p_handle->connection_id); SIZE_CHECK_APP_CONTEXT(p_context->len); DM_MUTEX_LOCK(); DM_TRC("[DM]: >> dm_application_context_set\r\n"); uint32_t err_code; uint32_t context_len; pstorage_handle_t block_handle; storage_operation store_fn = pstorage_store; err_code = pstorage_block_identifier_get(&m_storage_handle, p_handle->device_id, &block_handle); if (err_code == NRF_SUCCESS) { err_code = pstorage_load((uint8_t *)&context_len, &block_handle, sizeof(uint32_t), APP_CONTEXT_STORAGE_OFFSET); if ((err_code == NRF_SUCCESS) && (context_len != INVALID_CONTEXT_LEN)) { //Data already exists. Need an update. store_fn = pstorage_update; DM_LOG("[DM]:[DI 0x%02X]: Updating existing application context, existing len 0x%08X, " "new length 0x%08X.\r\n", p_handle->device_id, context_len, p_context->len); } else { DM_LOG("[DM]: Storing application context.\r\n"); } //Store/update context length. err_code = store_fn(&block_handle, (uint8_t *)(&p_context->len), sizeof(uint32_t), APP_CONTEXT_STORAGE_OFFSET); if (err_code == NRF_SUCCESS) { //Update context data is used for application context as flash is never //cleared if a delete of application context is called. err_code = pstorage_update(&block_handle, p_context->p_data, DEVICE_MANAGER_APP_CONTEXT_SIZE, (APP_CONTEXT_STORAGE_OFFSET + sizeof(uint32_t))); if (err_code == NRF_SUCCESS) { m_app_context_table[p_handle->device_id] = p_context->p_data; } } } DM_TRC("[DM]: << dm_application_context_set\r\n"); DM_MUTEX_UNLOCK(); return err_code; #else //DEVICE_MANAGER_APP_CONTEXT_SIZE return (FEATURE_NOT_ENABLED | DEVICE_MANAGER_ERR_BASE); #endif //DEVICE_MANAGER_APP_CONTEXT_SIZE } ret_code_t dm_application_context_get(dm_handle_t const * p_handle, dm_application_context_t * p_context) { #if (DEVICE_MANAGER_APP_CONTEXT_SIZE != 0) VERIFY_MODULE_INITIALIZED(); NULL_PARAM_CHECK(p_handle); NULL_PARAM_CHECK(p_context); VERIFY_APP_REGISTERED(p_handle->appl_id); VERIFY_DEVICE_INSTANCE(p_handle->device_id); DM_MUTEX_LOCK(); DM_TRC("[DM]: >> dm_application_context_get\r\n"); uint32_t context_len; uint32_t err_code; pstorage_handle_t block_handle; //Check if the context exists. if (NULL == p_context->p_data) { p_context->p_data = m_app_context_table[p_handle->device_id]; } else { m_app_context_table[p_handle->device_id] = p_context->p_data; } err_code = pstorage_block_identifier_get(&m_storage_handle, p_handle->device_id, &block_handle); if (err_code == NRF_SUCCESS) { err_code = pstorage_load((uint8_t *)&context_len, &block_handle, sizeof(uint32_t), APP_CONTEXT_STORAGE_OFFSET); if ((err_code == NRF_SUCCESS) && (context_len != INVALID_CONTEXT_LEN)) { err_code = pstorage_load(p_context->p_data, &block_handle, DEVICE_MANAGER_APP_CONTEXT_SIZE, (APP_CONTEXT_STORAGE_OFFSET + sizeof(uint32_t))); if (err_code == NRF_SUCCESS) { p_context->len = context_len; } } else { err_code = DM_NO_APP_CONTEXT; } } DM_TRC("[DM]: << dm_application_context_get\r\n"); DM_MUTEX_UNLOCK(); return err_code; #else //DEVICE_MANAGER_APP_CONTEXT_SIZE return (FEATURE_NOT_ENABLED | DEVICE_MANAGER_ERR_BASE); #endif //DEVICE_MANAGER_APP_CONTEXT_SIZE } ret_code_t dm_application_context_delete(const dm_handle_t * p_handle) { #if (DEVICE_MANAGER_APP_CONTEXT_SIZE != 0) VERIFY_MODULE_INITIALIZED(); NULL_PARAM_CHECK(p_handle); VERIFY_APP_REGISTERED(p_handle->appl_id); VERIFY_DEVICE_INSTANCE(p_handle->device_id); DM_MUTEX_LOCK(); DM_TRC("[DM]: >> dm_application_context_delete\r\n"); uint32_t err_code; uint32_t context_len; pstorage_handle_t block_handle; err_code = pstorage_block_identifier_get(&m_storage_handle, p_handle->device_id, &block_handle); if (err_code == NRF_SUCCESS) { err_code = pstorage_load((uint8_t *)&context_len, &block_handle, sizeof(uint32_t), APP_CONTEXT_STORAGE_OFFSET); if (context_len != m_context_init_len) { err_code = pstorage_update(&block_handle, (uint8_t *)&m_context_init_len, sizeof(uint32_t), APP_CONTEXT_STORAGE_OFFSET); if (err_code != NRF_SUCCESS) { DM_ERR("[DM]: Failed to delete application context, reason 0x%08X\r\n", err_code); } else { m_app_context_table[p_handle->device_id] = NULL; } } } DM_TRC("[DM]: << dm_application_context_delete\r\n"); DM_MUTEX_UNLOCK(); return err_code; #else //DEVICE_MANAGER_APP_CONTEXT_SIZE return (FEATURE_NOT_ENABLED | DEVICE_MANAGER_ERR_BASE); #endif //DEVICE_MANAGER_APP_CONTEXT_SIZE } ret_code_t dm_application_instance_set(dm_application_instance_t const * p_appl_instance, dm_handle_t * p_handle) { VERIFY_MODULE_INITIALIZED(); NULL_PARAM_CHECK(p_handle); NULL_PARAM_CHECK(p_appl_instance); VERIFY_APP_REGISTERED((*p_appl_instance)); p_handle->appl_id = (*p_appl_instance); return NRF_SUCCESS; } uint32_t dm_handle_initialize(dm_handle_t * p_handle) { NULL_PARAM_CHECK(p_handle); p_handle->appl_id = DM_INVALID_ID; p_handle->connection_id = DM_INVALID_ID; p_handle->device_id = DM_INVALID_ID; p_handle->service_id = DM_INVALID_ID; return NRF_SUCCESS; } ret_code_t dm_peer_addr_set(dm_handle_t const * p_handle, ble_gap_addr_t const * p_addr) { VERIFY_MODULE_INITIALIZED(); NULL_PARAM_CHECK(p_handle); NULL_PARAM_CHECK(p_addr); VERIFY_APP_REGISTERED(p_handle->appl_id); VERIFY_DEVICE_INSTANCE(p_handle->device_id); DM_MUTEX_LOCK(); DM_TRC("[DM]: >> dm_peer_addr_set\r\n"); ret_code_t err_code; if ((p_handle->connection_id == DM_INVALID_ID) && (p_addr->addr_type != BLE_GAP_ADDR_TYPE_RANDOM_PRIVATE_RESOLVABLE)) { m_peer_table[p_handle->device_id].peer_id.id_addr_info = (*p_addr); update_status_bit_set(p_handle->device_id); device_context_store(p_handle, UPDATE_PEER_ADDR); err_code = NRF_SUCCESS; } else { err_code = (NRF_ERROR_INVALID_PARAM | DEVICE_MANAGER_ERR_BASE); } DM_TRC("[DM]: << dm_peer_addr_set\r\n"); DM_MUTEX_UNLOCK(); return err_code; } ret_code_t dm_peer_addr_get(dm_handle_t const * p_handle, ble_gap_addr_t * p_addr) { VERIFY_MODULE_INITIALIZED(); NULL_PARAM_CHECK(p_handle); NULL_PARAM_CHECK(p_addr); VERIFY_APP_REGISTERED(p_handle->appl_id); DM_MUTEX_LOCK(); DM_TRC("[DM]: >> dm_peer_addr_get\r\n"); ret_code_t err_code; err_code = (NRF_ERROR_NOT_FOUND | DEVICE_MANAGER_ERR_BASE); if (p_handle->device_id == DM_INVALID_ID) { if ((p_handle->connection_id != DM_INVALID_ID) && ((m_connection_table[p_handle->connection_id].state & STATE_CONNECTED) == STATE_CONNECTED)) { DM_TRC("[DM]:[CI 0x%02X]: Address get for non bonded active connection.\r\n", p_handle->connection_id); (*p_addr) = m_connection_table[p_handle->connection_id].peer_addr; err_code = NRF_SUCCESS; } } else { if ((m_peer_table[p_handle->device_id].id_bitmap & ADDR_ENTRY) == 0) { DM_TRC("[DM]:[DI 0x%02X]: Address get for bonded device.\r\n", p_handle->device_id); (*p_addr) = m_peer_table[p_handle->device_id].peer_id.id_addr_info; err_code = NRF_SUCCESS; } } DM_TRC("[DM]: << dm_peer_addr_get\r\n"); DM_MUTEX_UNLOCK(); return err_code; } ret_code_t dm_distributed_keys_get(dm_handle_t const * p_handle, dm_sec_keyset_t * p_key_dist) { VERIFY_MODULE_INITIALIZED(); NULL_PARAM_CHECK(p_handle); NULL_PARAM_CHECK(p_key_dist); VERIFY_APP_REGISTERED(p_handle->appl_id); VERIFY_DEVICE_INSTANCE(p_handle->device_id); DM_MUTEX_LOCK(); DM_TRC("[DM]: >> dm_distributed_keys_get\r\n"); ret_code_t err_code; ble_gap_enc_key_t peer_enc_key; pstorage_handle_t block_handle; err_code = NRF_ERROR_NOT_FOUND; p_key_dist->keys_central.enc_key.p_enc_key = NULL; p_key_dist->keys_central.p_id_key = (dm_id_key_t *)&m_peer_table[p_handle->device_id].peer_id; p_key_dist->keys_central.p_sign_key = NULL; p_key_dist->keys_periph.p_id_key = (dm_id_key_t *)&m_local_id_info; p_key_dist->keys_periph.p_sign_key = NULL; p_key_dist->keys_periph.enc_key.p_enc_key = (dm_enc_key_t *)&peer_enc_key; if ((m_peer_table[p_handle->device_id].id_bitmap & IRK_ENTRY) == 0) { // p_key_dist->keys_periph.p_id_key->id_addr_info.addr_type = INVALID_ADDR_TYPE; } err_code = pstorage_block_identifier_get(&m_storage_handle, p_handle->device_id, &block_handle); if (err_code == NRF_SUCCESS) { err_code = pstorage_load((uint8_t *)&peer_enc_key, &block_handle, BOND_SIZE, BOND_STORAGE_OFFSET); if (err_code == NRF_SUCCESS) { p_key_dist->keys_central.enc_key.p_enc_key = NULL; p_key_dist->keys_central.p_id_key = (dm_id_key_t *)&m_peer_table[p_handle->device_id].peer_id; p_key_dist->keys_central.p_sign_key = NULL; p_key_dist->keys_periph.p_id_key = (dm_id_key_t *)&m_local_id_info; p_key_dist->keys_periph.p_sign_key = NULL; p_key_dist->keys_periph.enc_key.p_enc_key = (dm_enc_key_t *)&peer_enc_key; } } DM_TRC("[DM]: << dm_distributed_keys_get\r\n"); DM_MUTEX_UNLOCK(); return err_code; } /**@brief Function for loading bond information for a connection instance. */ void bond_data_load(dm_handle_t * p_handle) { pstorage_handle_t block_handle; uint32_t err_code = pstorage_block_identifier_get(&m_storage_handle, p_handle->device_id, &block_handle); if (err_code == NRF_SUCCESS) { DM_LOG( "[DM]:[%02X]:[Block ID 0x%08X]:Loading bond information at %p, size 0x%08X, offset 0x%08X.\r\n", p_handle->connection_id, block_handle.block_id, &m_bond_table[p_handle->connection_id], BOND_SIZE, BOND_STORAGE_OFFSET); err_code = pstorage_load((uint8_t *)&m_bond_table[p_handle->connection_id], &block_handle, BOND_SIZE, BOND_STORAGE_OFFSET); if (err_code != NRF_SUCCESS) { DM_ERR("[DM]:[%02X]: Failed to load Bond information, reason %08X\r\n", p_handle->connection_id, err_code); } DM_LOG( "[DM]:[%02X]:Loading service context at %p, size 0x%08X, offset 0x%08X.\r\n", p_handle->connection_id, &m_gatts_table[p_handle->connection_id], sizeof(dm_gatts_context_t), SERVICE_STORAGE_OFFSET); err_code = m_service_context_load[m_application_table[0].service]( &block_handle, p_handle); if (err_code != NRF_SUCCESS) { DM_ERR( "[DM]:[%02X]: Failed to load service information, reason %08X\r\n", p_handle->connection_id, err_code); } } else { DM_ERR("[DM]:[%02X]: Failed to get block identifier for " "device %08X, reason %08X.\r\n", p_handle->connection_id, p_handle->device_id, err_code); } } void dm_ble_evt_handler(ble_evt_t * p_ble_evt) { uint32_t err_code; uint32_t index; uint32_t device_index = DM_INVALID_ID; bool notify_app = false; dm_handle_t handle; dm_event_t event; uint32_t event_result; ble_gap_enc_info_t * p_enc_info = NULL; VERIFY_MODULE_INITIALIZED_VOID(); VERIFY_APP_REGISTERED_VOID(0); DM_MUTEX_LOCK(); err_code = dm_handle_initialize(&handle); APP_ERROR_CHECK(err_code); event_result = NRF_SUCCESS; err_code = NRF_SUCCESS; event.event_param.p_gap_param = &p_ble_evt->evt.gap_evt; event.event_paramlen = sizeof(ble_gap_evt_t); handle.device_id = DM_INVALID_ID; handle.appl_id = 0; index = 0x00; if (p_ble_evt->header.evt_id != BLE_GAP_EVT_CONNECTED) { err_code = connection_instance_find(p_ble_evt->evt.gap_evt.conn_handle, STATE_CONNECTED, &index); if (err_code == NRF_SUCCESS) { handle.device_id = m_connection_table[index].bonded_dev_id; handle.connection_id = index; } } switch (p_ble_evt->header.evt_id) { case BLE_GAP_EVT_CONNECTED: //Allocate connection instance for a new connection. err_code = connection_instance_allocate(&index); //Connection instance is successfully allocated. if (err_code == NRF_SUCCESS) { //Application notification related information. notify_app = true; event.event_id = DM_EVT_CONNECTION; handle.connection_id = index; m_connection_table[index].conn_handle = p_ble_evt->evt.gap_evt.conn_handle; m_connection_table[index].state = STATE_CONNECTED; m_connection_table[index].peer_addr = p_ble_evt->evt.gap_evt.params.connected.peer_addr; if (p_ble_evt->evt.gap_evt.params.connected.irk_match == 1) { if (m_irk_index_table[p_ble_evt->evt.gap_evt.params.connected.irk_match_idx] != DM_INVALID_ID) { device_index = m_irk_index_table[p_ble_evt->evt.gap_evt.params.connected.irk_match_idx]; err_code = NRF_SUCCESS; } } else { //Use the device address to check if the device exists in the bonded device list. err_code = device_instance_find(&p_ble_evt->evt.gap_evt.params.connected.peer_addr, &device_index, EDIV_INIT_VAL); } if (err_code == NRF_SUCCESS) { m_connection_table[index].bonded_dev_id = device_index; m_connection_table[index].state |= STATE_BONDED; handle.device_id = device_index; bond_data_load(&handle); } } break; case BLE_GAP_EVT_DISCONNECTED: //Disconnection could be peer or self initiated hence disconnecting and connecting //both states are permitted, however, connection handle must be known. DM_LOG("[DM]: Disconnect Reason 0x%04X\r\n", p_ble_evt->evt.gap_evt.params.disconnected.reason); m_connection_table[index].state &= (~STATE_CONNECTED); if ((m_connection_table[index].state & STATE_BONDED) == STATE_BONDED) { if ((m_connection_table[index].state & STATE_LINK_ENCRYPTED) == STATE_LINK_ENCRYPTED) { //Write bond information persistently. device_context_store(&handle, STORE_ALL_CONTEXT); } } else { //Free any allocated instances for devices that is not bonded. if (handle.device_id != DM_INVALID_ID) { peer_instance_init(handle.device_id); handle.device_id = DM_INVALID_ID; } } m_connection_table[index].state = STATE_DISCONNECTING; notify_app = true; event.event_id = DM_EVT_DISCONNECTION; break; case BLE_GAP_EVT_SEC_INFO_REQUEST: DM_LOG("[DM]: >> BLE_GAP_EVT_SEC_INFO_REQUEST\r\n"); //If the device is already bonded, respond with existing info, else NULL. if (m_connection_table[index].bonded_dev_id == DM_INVALID_ID) { //Find device based on div. err_code = device_instance_find(NULL,&device_index, p_ble_evt->evt.gap_evt.params.sec_info_request.master_id.ediv); if (err_code == NRF_SUCCESS) { //Load needed bonding information. m_connection_table[index].bonded_dev_id = device_index; m_connection_table[index].state |= STATE_BONDED; handle.device_id = device_index; bond_data_load(&handle); } } if (m_connection_table[index].bonded_dev_id != DM_INVALID_ID) { p_enc_info = &m_bond_table[index].peer_enc_key.enc_info; DM_DUMP((uint8_t *)p_enc_info, sizeof(ble_gap_enc_info_t)); } err_code = sd_ble_gap_sec_info_reply(p_ble_evt->evt.gap_evt.conn_handle, p_enc_info, &m_peer_table[index].peer_id.id_info, NULL); if (err_code != NRF_SUCCESS) { DM_ERR("[DM]:[CI %02X]:[DI %02X]: Security information response failed, reason " "0x%08X\r\n", index, m_connection_table[index].bonded_dev_id, err_code); } break; case BLE_GAP_EVT_SEC_PARAMS_REQUEST: DM_LOG("[DM]: >> BLE_GAP_EVT_SEC_PARAMS_REQUEST\r\n"); event.event_id = DM_EVT_SECURITY_SETUP; m_connection_table[index].state |= STATE_PAIRING; notify_app = true; if (m_connection_table[index].bonded_dev_id == DM_INVALID_ID) { //Assign a peer index as a new bond or update existing bonds. err_code = device_instance_allocate((uint8_t *)&device_index, &m_connection_table[index].peer_addr); //Allocation successful. if (err_code == NRF_SUCCESS) { DM_LOG("[DM]:[CI 0x%02X]:[DI 0x%02X]: Bonded!\r\n",index, device_index); handle.device_id = device_index; m_connection_table[index].bonded_dev_id = device_index; } else { DM_LOG("[DM]: Security parameter request failed, reason 0x%08X.\r\n", err_code); event_result = err_code; notify_app = true; } ble_gap_sec_keyset_t keys_exchanged; DM_LOG("[DM]: 0x%02X, 0x%02X, 0x%02X, 0x%02X\r\n", p_ble_evt->evt.gap_evt.params.sec_params_request.peer_params.kdist_peer.enc, p_ble_evt->evt.gap_evt.params.sec_params_request.peer_params.kdist_own.id, p_ble_evt->evt.gap_evt.params.sec_params_request.peer_params.kdist_peer.sign, p_ble_evt->evt.gap_evt.params.sec_params_request.peer_params.bond); keys_exchanged.keys_peer.p_enc_key = NULL; keys_exchanged.keys_peer.p_id_key = &m_peer_table[m_connection_table[index].bonded_dev_id].peer_id; keys_exchanged.keys_peer.p_sign_key = NULL; keys_exchanged.keys_peer.p_pk = NULL; keys_exchanged.keys_own.p_enc_key = &m_bond_table[index].peer_enc_key; keys_exchanged.keys_own.p_id_key = NULL; keys_exchanged.keys_own.p_sign_key = NULL; keys_exchanged.keys_own.p_pk = NULL; err_code = sd_ble_gap_sec_params_reply(p_ble_evt->evt.gap_evt.conn_handle, BLE_GAP_SEC_STATUS_SUCCESS, &m_application_table[0].sec_param, &keys_exchanged); if (err_code != NRF_SUCCESS) { DM_LOG("[DM]: Security parameter reply request failed, reason 0x%08X.\r\n", err_code); event_result = err_code; notify_app = false; } } else { //Bond/key refresh. DM_LOG("[DM]: !!! Bond/key refresh !!!\r\n"); //Set the update flag for bond data. m_connection_table[index].state |= STATE_BOND_INFO_UPDATE; event.event_id = DM_EVT_SECURITY_SETUP_REFRESH; err_code = sd_ble_gap_sec_params_reply(p_ble_evt->evt.gap_evt.conn_handle, BLE_GAP_SEC_STATUS_PAIRING_NOT_SUPP, NULL, NULL); if (err_code != NRF_SUCCESS) { DM_LOG("[DM]: Security parameter reply request failed, reason 0x%08X.\r\n", err_code); event_result = err_code; notify_app = false; } } break; case BLE_GAP_EVT_AUTH_STATUS: { DM_LOG("[DM]: >> BLE_GAP_EVT_AUTH_STATUS, status %08X\r\n", p_ble_evt->evt.gap_evt.params.auth_status.auth_status); m_application_table[0].state &= (~STATE_CONTROL_PROCEDURE_IN_PROGRESS); m_connection_table[index].state &= (~STATE_PAIRING); event.event_id = DM_EVT_SECURITY_SETUP_COMPLETE; notify_app = true; if (p_ble_evt->evt.gap_evt.params.auth_status.auth_status != BLE_GAP_SEC_STATUS_SUCCESS) { // In case of key refresh attempt, since this behavior is now rejected, we don't do anything here if ((m_connection_table[index].state & STATE_BOND_INFO_UPDATE) != STATE_BOND_INFO_UPDATE) { // Free the allocation as bonding failed. ret_code_t result = device_instance_free(m_connection_table[index].bonded_dev_id); (void) result; event_result = p_ble_evt->evt.gap_evt.params.auth_status.auth_status; } } else { DM_DUMP((uint8_t *)&p_ble_evt->evt.gap_evt.params.auth_status, sizeof(ble_gap_evt_auth_status_t)); DM_DUMP((uint8_t *)&m_bond_table[index], sizeof(bond_context_t)); if (p_ble_evt->evt.gap_evt.params.auth_status.bonded == 1) { if (handle.device_id != DM_INVALID_ID) { m_connection_table[index].state |= STATE_BONDED; //IRK and/or public address is shared, update it. if (p_ble_evt->evt.gap_evt.params.auth_status.kdist_peer.id == 1) { m_peer_table[handle.device_id].id_bitmap &= (~IRK_ENTRY); } if (m_connection_table[index].bonded_dev_id != DM_INVALID_ID) { DM_LOG("[DM]:[CI 0x%02X]:[DI 0x%02X]: Bonded!\r\n", index, handle.device_id); if (m_connection_table[index].peer_addr.addr_type != BLE_GAP_ADDR_TYPE_RANDOM_PRIVATE_RESOLVABLE) { m_peer_table[handle.device_id].peer_id.id_addr_info = m_connection_table[index].peer_addr; m_peer_table[handle.device_id].id_bitmap &= (~ADDR_ENTRY); DM_DUMP((uint8_t *)&m_peer_table[handle.device_id].peer_id.id_addr_info, sizeof(m_peer_table[handle.device_id].peer_id.id_addr_info)); } else { // Here we must fetch the keys from the keyset distributed. m_peer_table[handle.device_id].ediv = m_bond_table[index].peer_enc_key.master_id.ediv; m_peer_table[handle.device_id].id_bitmap &= (~IRK_ENTRY); } device_context_store(&handle, FIRST_BOND_STORE); } } } else { //Pairing request, no need to touch the bonding info. } } break; } case BLE_GAP_EVT_CONN_SEC_UPDATE: DM_LOG("[DM]: >> BLE_GAP_EVT_CONN_SEC_UPDATE, Mode 0x%02X, Level 0x%02X\r\n", p_ble_evt->evt.gap_evt.params.conn_sec_update.conn_sec.sec_mode.sm, p_ble_evt->evt.gap_evt.params.conn_sec_update.conn_sec.sec_mode.lv); if ((p_ble_evt->evt.gap_evt.params.conn_sec_update.conn_sec.sec_mode.lv == 1) && (p_ble_evt->evt.gap_evt.params.conn_sec_update.conn_sec.sec_mode.sm == 1) && ((m_connection_table[index].state & STATE_BONDED) == STATE_BONDED)) { //Lost bond case, generate a security refresh event! memset(m_gatts_table[index].attributes, 0, DM_GATT_SERVER_ATTR_MAX_SIZE); event.event_id = DM_EVT_SECURITY_SETUP_REFRESH; m_connection_table[index].state |= STATE_PAIRING_PENDING; m_connection_table[index].state |= STATE_BOND_INFO_UPDATE; m_application_table[0].state |= STATE_QUEUED_CONTROL_REQUEST; } else { m_connection_table[index].state |= STATE_LINK_ENCRYPTED; event.event_id = DM_EVT_LINK_SECURED; //Apply service context. err_code = m_service_context_apply[m_application_table[0].service](&handle); if (err_code != NRF_SUCCESS) { DM_ERR("[DM]:[CI 0x%02X]:[DI 0x%02X]: Failed to apply service context\r\n", handle.connection_id, handle.device_id); event_result = DM_SERVICE_CONTEXT_NOT_APPLIED; } } event_result = NRF_SUCCESS; notify_app = true; break; case BLE_GATTS_EVT_SYS_ATTR_MISSING: DM_LOG("[DM]: >> BLE_GATTS_EVT_SYS_ATTR_MISSING\r\n"); //Apply service context. event_result = m_service_context_apply[m_application_table[0].service](&handle); break; case BLE_GAP_EVT_SEC_REQUEST: DM_LOG("[DM]: >> BLE_GAP_EVT_SEC_REQUEST\r\n"); //Verify if the device is already bonded, and if it is bonded, initiate encryption. //If the device is not bonded, an instance needs to be allocated in order to initiate //bonding. The application have to initiate the procedure, the module will not do this //automatically. event.event_id = DM_EVT_SECURITY_SETUP; notify_app = true; break; default: break; } if (notify_app) { app_evt_notify(&handle, &event, event_result); //Freeing the instance after the event is notified so the application can get the context. if (event.event_id == DM_EVT_DISCONNECTION) { //Free the instance. connection_instance_free(&index); } } UNUSED_VARIABLE(err_code); DM_MUTEX_UNLOCK(); } ret_code_t dm_handle_get(uint16_t conn_handle, dm_handle_t * p_handle) { ret_code_t err_code; uint32_t index; NULL_PARAM_CHECK(p_handle); VERIFY_APP_REGISTERED(p_handle->appl_id); p_handle->device_id = DM_INVALID_ID; err_code = NRF_ERROR_NOT_FOUND; for (index = 0; index < DEVICE_MANAGER_MAX_CONNECTIONS; index++) { //Search for matching connection handle. if (conn_handle == m_connection_table[index].conn_handle) { p_handle->connection_id = index; p_handle->device_id = m_connection_table[index].bonded_dev_id; err_code = NRF_SUCCESS; break; } } return err_code; }