ret_code_t pm_peers_delete(void)
{
VERIFY_MODULE_INITIALIZED();
m_deleting_all = true;
pm_peer_id_t current_peer_id = pdb_next_peer_id_get(PM_PEER_ID_INVALID);
if (current_peer_id == PM_PEER_ID_INVALID)
{
// No peers bonded.
m_deleting_all = false;
pm_evt_t pm_delete_all_evt;
memset(&pm_delete_all_evt, 0, sizeof(pm_evt_t));
pm_delete_all_evt.evt_id = PM_EVT_PEERS_DELETE_SUCCEEDED;
pm_delete_all_evt.peer_id = PM_PEER_ID_INVALID;
pm_delete_all_evt.conn_handle = BLE_CONN_HANDLE_INVALID;
evt_send(&pm_delete_all_evt);
}
while (current_peer_id != PM_PEER_ID_INVALID)
{
ret_code_t err_code = pm_peer_delete(current_peer_id);
if (err_code != NRF_SUCCESS)
{
return NRF_ERROR_INTERNAL;
}
current_peer_id = pdb_next_peer_id_get(current_peer_id);
}
return NRF_SUCCESS;
}
void pm_peer_delete_all(void)
{
pm_peer_id_t current_peer_id = PM_PEER_ID_INVALID;
while (pdb_next_peer_id_get(PM_PEER_ID_INVALID) != PM_PEER_ID_INVALID)
{
current_peer_id = pdb_next_peer_id_get(current_peer_id);
pm_peer_delete(current_peer_id);
}
}
void im_evt_handler(im_evt_t const * p_evt)
{
pm_evt_t pm_evt;
switch (p_evt->evt_id)
{
case IM_EVT_DUPLICATE_ID:
// Delete the duplicate data to free space and avoid finding old data when scanning in the future
pm_peer_delete(p_evt->params.duplicate_id.peer_id_2);
break;
case IM_EVT_BONDED_PEER_CONNECTED:
ble_conn_state_user_flag_set(p_evt->conn_handle, m_pm.bonding_flag_id, true);
memset(&pm_evt, 0, sizeof(pm_evt_t));
pm_evt.conn_handle = p_evt->conn_handle;
pm_evt.peer_id = im_peer_id_get_by_conn_handle(p_evt->conn_handle);
pm_evt.evt_id = PM_EVT_BONDED_PEER_CONNECTED;
evt_send(&pm_evt);
break;
}
}
/**@brief Function for handling the Application's BLE Stack events.
*
* @param[in] p_ble_evt Bluetooth stack event.
*/
static void on_ble_evt(ble_evt_t * p_ble_evt)
{
uint32_t err_code = NRF_SUCCESS; //lint -save -e438 // Last value assigned to variable 'err_code' not used
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_DISCONNECTED:
{
NRF_LOG_PRINTF("[APP]: %s: BLE_GAP_EVT_DISCONNECTED\r\n", __func__);
m_conn_handle = BLE_CONN_HANDLE_INVALID;
/*check if the last connected peer had not used MITM, if so, delete its bond information*/
if (peer_to_be_deleted != PM_PEER_ID_INVALID)
{
ret_code_t ret_val = pm_peer_delete(peer_to_be_deleted);
APP_ERROR_CHECK(ret_val);
APP_LOG("Collector's bond deleted\r\n");
peer_to_be_deleted = PM_PEER_ID_INVALID;
}
// advertising_init(); // TODO: Check if this is correct, shouldn't be needed
nrf_gpio_pin_clear(LED_1);
}break;//BLE_GAP_EVT_DISCONNECTED
case BLE_GAP_EVT_CONNECTED:
{
NRF_LOG_PRINTF("[APP]: %s: BLE_GAP_EVT_CONNECTED\r\n", __func__);
peer_to_be_deleted = PM_PEER_ID_INVALID;
m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
// Start Security Request timer.
err_code = app_timer_start(m_sec_req_timer_id, SECURITY_REQUEST_DELAY, NULL);
APP_ERROR_CHECK(err_code);
}break;//BLE_GAP_EVT_CONNECTED
case BLE_GATTS_EVT_TIMEOUT:
NRF_LOG_PRINTF("[APP]: %s: BLE_GATTS_EVT_TIMEOUT\r\n", __func__);
// Disconnect on GATT Server timeout events.
err_code = sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
APP_ERROR_CHECK(err_code);
break;//BLE_GATTS_EVT_TIMEOUT
case BLE_GAP_EVT_SEC_PARAMS_REQUEST:
NRF_LOG_DEBUG("BLE_GAP_EVT_SEC_PARAMS_REQUEST\r\n");
break;//BLE_GAP_EVT_SEC_PARAMS_REQUEST
case BLE_GAP_EVT_PASSKEY_DISPLAY:
{
NRF_LOG_PRINTF("[APP]: %s: BLE_GAP_EVT_PASSKEY_DISPLAY\r\n", __func__);
char passkey[PASSKEY_LENGTH+1];
memcpy(passkey,p_ble_evt->evt.gap_evt.params.passkey_display.passkey,PASSKEY_LENGTH);
passkey[PASSKEY_LENGTH] = 0;
// Don't send delayed Security Request if security procedure is already in progress.
err_code = app_timer_stop(m_sec_req_timer_id);
APP_ERROR_CHECK(err_code);
NRF_LOG_PRINTF("Passkey: %s\r\n",passkey);
}break;//BLE_GAP_EVT_PASSKEY_DISPLAY
case BLE_EVT_USER_MEM_REQUEST:
NRF_LOG_PRINTF("[APP]: %s: BLE_EVT_USER_MEM_REQUEST\r\n", __func__);
err_code = sd_ble_user_mem_reply(m_conn_handle, NULL);
APP_ERROR_CHECK(err_code);
break;//BLE_EVT_USER_MEM_REQUEST
case BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST:
{
NRF_LOG_PRINTF("[APP]: %s: BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST\r\n", __func__);
ble_gatts_rw_authorize_reply_params_t auth_reply;
if(p_ble_evt->evt.gatts_evt.params.authorize_request.type
!= BLE_GATTS_AUTHORIZE_TYPE_INVALID)
{
if ((p_ble_evt->evt.gatts_evt.params.authorize_request.request.write.op
== BLE_GATTS_OP_PREP_WRITE_REQ)
|| (p_ble_evt->evt.gatts_evt.params.authorize_request.request.write.op
== BLE_GATTS_OP_EXEC_WRITE_REQ_NOW)
|| (p_ble_evt->evt.gatts_evt.params.authorize_request.request.write.op
== BLE_GATTS_OP_EXEC_WRITE_REQ_CANCEL))
{
if (p_ble_evt->evt.gatts_evt.params.authorize_request.type
== BLE_GATTS_AUTHORIZE_TYPE_WRITE)
{
auth_reply.type = BLE_GATTS_AUTHORIZE_TYPE_WRITE;
}
else
{
auth_reply.type = BLE_GATTS_AUTHORIZE_TYPE_READ;
}
auth_reply.params.write.gatt_status = APP_FEATURE_NOT_SUPPORTED;
err_code = sd_ble_gatts_rw_authorize_reply(m_conn_handle,&auth_reply);
APP_ERROR_CHECK(err_code);
}
}
}break;//BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST
default:
// No implementation needed.
break;
}
}
