498 lines
16 KiB
C
498 lines
16 KiB
C
|
/**
|
||
|
|
* Copyright (c) 2015 - 2020, 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 form under this license must not be reverse
|
||
|
|
* engineered, decompiled, modified and/or disassembled.
|
||
|
|
*
|
||
|
|
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
|
||
|
|
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||
|
|
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||
|
|
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA 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 "ble_conn_state.h"
|
||
|
|
#include <stdbool.h>
|
||
|
|
#include <stdint.h>
|
||
|
|
#include <string.h>
|
||
|
|
#include "ble.h"
|
||
|
|
#include "nrf_atflags.h"
|
||
|
|
#include "app_error.h"
|
||
|
|
#include "nrf_sdh_ble.h"
|
||
|
|
#include "app_util_platform.h"
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
#define DEFAULT_FLAG_COLLECTION_COUNT 6 /**< The number of flags kept for each connection, excluding user flags. */
|
||
|
|
#define TOTAL_FLAG_COLLECTION_COUNT (DEFAULT_FLAG_COLLECTION_COUNT \
|
||
|
|
+ BLE_CONN_STATE_USER_FLAG_COUNT) /**< The number of flags kept for each connection, including user flags. */
|
||
|
|
|
||
|
|
/**@brief Structure containing all the flag collections maintained by the Connection State module.
|
||
|
|
*/
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
nrf_atflags_t valid_flags; /**< Flags indicating which connection handles are valid. */
|
||
|
|
nrf_atflags_t connected_flags; /**< Flags indicating which connections are connected, since disconnected connection handles will not immediately be invalidated. */
|
||
|
|
nrf_atflags_t central_flags; /**< Flags indicating in which connections the local device is the central. */
|
||
|
|
nrf_atflags_t encrypted_flags; /**< Flags indicating which connections are encrypted. */
|
||
|
|
nrf_atflags_t mitm_protected_flags; /**< Flags indicating which connections have encryption with protection from man-in-the-middle attacks. */
|
||
|
|
nrf_atflags_t lesc_flags; /**< Flags indicating which connections have bonded using LE Secure Connections (LESC). */
|
||
|
|
nrf_atflags_t user_flags[BLE_CONN_STATE_USER_FLAG_COUNT]; /**< Flags that can be reserved by the user. The flags will be cleared when a connection is invalidated, otherwise, the user is wholly responsible for the flag states. */
|
||
|
|
} ble_conn_state_flag_collections_t;
|
||
|
|
|
||
|
|
|
||
|
|
ANON_UNIONS_ENABLE;
|
||
|
|
|
||
|
|
/**@brief Structure containing the internal state of the Connection State module.
|
||
|
|
*/
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
nrf_atflags_t acquired_flags; /**< Bitmap for keeping track of which user flags have been acquired. */
|
||
|
|
union
|
||
|
|
{
|
||
|
|
ble_conn_state_flag_collections_t flags; /**< Flag collections kept by the Connection State module. */
|
||
|
|
nrf_atflags_t flag_array[TOTAL_FLAG_COLLECTION_COUNT]; /**< Flag collections as array to allow iterating over all flag collections. */
|
||
|
|
};
|
||
|
|
} ble_conn_state_t;
|
||
|
|
|
||
|
|
ANON_UNIONS_DISABLE;
|
||
|
|
|
||
|
|
|
||
|
|
static ble_conn_state_t m_bcs = {0}; /**< Instantiation of the internal state. */
|
||
|
|
|
||
|
|
|
||
|
|
/**@brief Function for resetting all internal memory to the values it had at initialization.
|
||
|
|
*/
|
||
|
|
void bcs_internal_state_reset(void)
|
||
|
|
{
|
||
|
|
memset( &m_bcs, 0, sizeof(ble_conn_state_t) );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
ble_conn_state_conn_handle_list_t conn_handle_list_get(nrf_atflags_t flags)
|
||
|
|
{
|
||
|
|
ble_conn_state_conn_handle_list_t conn_handle_list;
|
||
|
|
conn_handle_list.len = 0;
|
||
|
|
|
||
|
|
if (flags != 0)
|
||
|
|
{
|
||
|
|
for (uint32_t i = 0; i < BLE_CONN_STATE_MAX_CONNECTIONS; i++)
|
||
|
|
{
|
||
|
|
if (nrf_atflags_get(&flags, i))
|
||
|
|
{
|
||
|
|
conn_handle_list.conn_handles[conn_handle_list.len++] = i;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return conn_handle_list;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
uint32_t active_flag_count(nrf_atflags_t flags)
|
||
|
|
{
|
||
|
|
uint32_t set_flag_count = 0;
|
||
|
|
|
||
|
|
for (uint32_t i = 0; i < BLE_CONN_STATE_MAX_CONNECTIONS; i++)
|
||
|
|
{
|
||
|
|
if (nrf_atflags_get(&flags, i))
|
||
|
|
{
|
||
|
|
set_flag_count += 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return set_flag_count;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**@brief Function for activating a connection record.
|
||
|
|
*
|
||
|
|
* @param p_record The record to activate.
|
||
|
|
* @param conn_handle The connection handle to copy into the record.
|
||
|
|
* @param role The role of the connection.
|
||
|
|
*
|
||
|
|
* @return whether the record was activated successfully.
|
||
|
|
*/
|
||
|
|
static bool record_activate(uint16_t conn_handle)
|
||
|
|
{
|
||
|
|
if (conn_handle >= BLE_CONN_STATE_MAX_CONNECTIONS)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
nrf_atflags_set(&m_bcs.flags.connected_flags, conn_handle);
|
||
|
|
nrf_atflags_set(&m_bcs.flags.valid_flags, conn_handle);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**@brief Function for marking a connection record as invalid and resetting the values.
|
||
|
|
*
|
||
|
|
* @param p_record The record to invalidate.
|
||
|
|
*/
|
||
|
|
static void record_invalidate(uint16_t conn_handle)
|
||
|
|
{
|
||
|
|
for (uint32_t i = 0; i < TOTAL_FLAG_COLLECTION_COUNT; i++)
|
||
|
|
{
|
||
|
|
nrf_atflags_clear(&m_bcs.flag_array[i], conn_handle);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**@brief Function for marking a connection as disconnected. See @ref BLE_CONN_STATUS_DISCONNECTED.
|
||
|
|
*
|
||
|
|
* @param p_record The record of the connection to set as disconnected.
|
||
|
|
*/
|
||
|
|
static void record_set_disconnected(uint16_t conn_handle)
|
||
|
|
{
|
||
|
|
nrf_atflags_clear(&m_bcs.flags.connected_flags, conn_handle);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**@brief Function for invalidating records with a @ref BLE_CONN_STATUS_DISCONNECTED
|
||
|
|
* connection status
|
||
|
|
*/
|
||
|
|
static void record_purge_disconnected()
|
||
|
|
{
|
||
|
|
nrf_atflags_t disconnected_flags = ~m_bcs.flags.connected_flags;
|
||
|
|
ble_conn_state_conn_handle_list_t disconnected_list;
|
||
|
|
|
||
|
|
UNUSED_RETURN_VALUE(nrf_atomic_u32_and(&disconnected_flags, m_bcs.flags.valid_flags));
|
||
|
|
disconnected_list = conn_handle_list_get(disconnected_flags);
|
||
|
|
|
||
|
|
for (uint32_t i = 0; i < disconnected_list.len; i++)
|
||
|
|
{
|
||
|
|
record_invalidate(disconnected_list.conn_handles[i]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**@brief Function for checking if a user flag has been acquired.
|
||
|
|
*
|
||
|
|
* @param[in] flag_id Which flag to check.
|
||
|
|
*
|
||
|
|
* @return Whether the flag has been acquired.
|
||
|
|
*/
|
||
|
|
static bool user_flag_is_acquired(ble_conn_state_user_flag_id_t flag_id)
|
||
|
|
{
|
||
|
|
return nrf_atflags_get(&m_bcs.acquired_flags, flag_id);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void ble_conn_state_init(void)
|
||
|
|
{
|
||
|
|
bcs_internal_state_reset();
|
||
|
|
}
|
||
|
|
|
||
|
|
static void flag_toggle(nrf_atflags_t * p_flags, uint16_t conn_handle, bool value)
|
||
|
|
{
|
||
|
|
if (value)
|
||
|
|
{
|
||
|
|
nrf_atflags_set(p_flags, conn_handle);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
nrf_atflags_clear(p_flags, conn_handle);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Function for handling BLE events.
|
||
|
|
*
|
||
|
|
* @param[in] p_ble_evt Event received from the BLE stack.
|
||
|
|
* @param[in] p_context Context.
|
||
|
|
*/
|
||
|
|
static void ble_evt_handler(ble_evt_t const * p_ble_evt, void * p_context)
|
||
|
|
{
|
||
|
|
uint16_t conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
|
||
|
|
switch (p_ble_evt->header.evt_id)
|
||
|
|
{
|
||
|
|
case BLE_GAP_EVT_CONNECTED:
|
||
|
|
record_purge_disconnected();
|
||
|
|
|
||
|
|
if ( !record_activate(conn_handle) )
|
||
|
|
{
|
||
|
|
// No more records available. Should not happen.
|
||
|
|
APP_ERROR_HANDLER(NRF_ERROR_NO_MEM);
|
||
|
|
}
|
||
|
|
#ifdef BLE_GAP_ROLE_CENTRAL
|
||
|
|
else if ((p_ble_evt->evt.gap_evt.params.connected.role == BLE_GAP_ROLE_CENTRAL))
|
||
|
|
{
|
||
|
|
// Central
|
||
|
|
nrf_atflags_set(&m_bcs.flags.central_flags, conn_handle);
|
||
|
|
}
|
||
|
|
#endif // BLE_GAP_ROLE_CENTRAL
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// No implementation required.
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
|
||
|
|
case BLE_GAP_EVT_DISCONNECTED:
|
||
|
|
record_set_disconnected(conn_handle);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case BLE_GAP_EVT_CONN_SEC_UPDATE:
|
||
|
|
{
|
||
|
|
uint8_t sec_lv = p_ble_evt->evt.gap_evt.params.conn_sec_update.conn_sec.sec_mode.lv;
|
||
|
|
// Set/unset flags based on security level.
|
||
|
|
flag_toggle(&m_bcs.flags.lesc_flags, conn_handle, sec_lv >= 4);
|
||
|
|
flag_toggle(&m_bcs.flags.mitm_protected_flags, conn_handle, sec_lv >= 3);
|
||
|
|
flag_toggle(&m_bcs.flags.encrypted_flags, conn_handle, sec_lv >= 2);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
case BLE_GAP_EVT_AUTH_STATUS:
|
||
|
|
if (p_ble_evt->evt.gap_evt.params.auth_status.auth_status == BLE_GAP_SEC_STATUS_SUCCESS)
|
||
|
|
{
|
||
|
|
bool lesc = p_ble_evt->evt.gap_evt.params.auth_status.lesc;
|
||
|
|
flag_toggle(&m_bcs.flags.lesc_flags, conn_handle, lesc);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
NRF_SDH_BLE_OBSERVER(m_ble_evt_observer, BLE_CONN_STATE_BLE_OBSERVER_PRIO, ble_evt_handler, NULL);
|
||
|
|
|
||
|
|
|
||
|
|
bool ble_conn_state_valid(uint16_t conn_handle)
|
||
|
|
{
|
||
|
|
if (conn_handle >= BLE_CONN_STATE_MAX_CONNECTIONS)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return nrf_atflags_get(&m_bcs.flags.valid_flags, conn_handle);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
uint8_t ble_conn_state_role(uint16_t conn_handle)
|
||
|
|
{
|
||
|
|
uint8_t role = BLE_GAP_ROLE_INVALID;
|
||
|
|
|
||
|
|
if (ble_conn_state_valid(conn_handle))
|
||
|
|
{
|
||
|
|
#if defined (BLE_GAP_ROLE_PERIPH) && defined (BLE_GAP_ROLE_CENTRAL)
|
||
|
|
bool central = nrf_atflags_get(&m_bcs.flags.central_flags, conn_handle);
|
||
|
|
role = central ? BLE_GAP_ROLE_CENTRAL : BLE_GAP_ROLE_PERIPH;
|
||
|
|
#elif defined (BLE_GAP_ROLE_CENTRAL)
|
||
|
|
role = BLE_GAP_ROLE_CENTRAL;
|
||
|
|
#else
|
||
|
|
role = BLE_GAP_ROLE_PERIPH;
|
||
|
|
#endif // defined (BLE_GAP_ROLE_PERIPH) && defined (BLE_GAP_ROLE_CENTRAL)
|
||
|
|
}
|
||
|
|
|
||
|
|
return role;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
ble_conn_state_status_t ble_conn_state_status(uint16_t conn_handle)
|
||
|
|
{
|
||
|
|
ble_conn_state_status_t conn_status = BLE_CONN_STATUS_INVALID;
|
||
|
|
|
||
|
|
if (ble_conn_state_valid(conn_handle))
|
||
|
|
{
|
||
|
|
bool connected = nrf_atflags_get(&m_bcs.flags.connected_flags, conn_handle);
|
||
|
|
conn_status = connected ? BLE_CONN_STATUS_CONNECTED : BLE_CONN_STATUS_DISCONNECTED;
|
||
|
|
}
|
||
|
|
|
||
|
|
return conn_status;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
bool ble_conn_state_encrypted(uint16_t conn_handle)
|
||
|
|
{
|
||
|
|
if (ble_conn_state_valid(conn_handle))
|
||
|
|
{
|
||
|
|
return nrf_atflags_get(&m_bcs.flags.encrypted_flags, conn_handle);
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
bool ble_conn_state_mitm_protected(uint16_t conn_handle)
|
||
|
|
{
|
||
|
|
if (ble_conn_state_valid(conn_handle))
|
||
|
|
{
|
||
|
|
return nrf_atflags_get(&m_bcs.flags.mitm_protected_flags, conn_handle);
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool ble_conn_state_lesc(uint16_t conn_handle)
|
||
|
|
{
|
||
|
|
if (ble_conn_state_valid(conn_handle))
|
||
|
|
{
|
||
|
|
return nrf_atflags_get(&m_bcs.flags.lesc_flags, conn_handle);
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
uint32_t ble_conn_state_conn_count(void)
|
||
|
|
{
|
||
|
|
return active_flag_count(m_bcs.flags.connected_flags);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
uint32_t ble_conn_state_central_conn_count(void)
|
||
|
|
{
|
||
|
|
nrf_atflags_t central_conn_flags = m_bcs.flags.central_flags;
|
||
|
|
UNUSED_RETURN_VALUE(nrf_atomic_u32_and(¢ral_conn_flags, m_bcs.flags.connected_flags));
|
||
|
|
|
||
|
|
return active_flag_count(central_conn_flags);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
uint32_t ble_conn_state_peripheral_conn_count(void)
|
||
|
|
{
|
||
|
|
nrf_atflags_t peripheral_conn_flags = ~m_bcs.flags.central_flags;
|
||
|
|
UNUSED_RETURN_VALUE(nrf_atomic_u32_and(&peripheral_conn_flags, m_bcs.flags.connected_flags));
|
||
|
|
|
||
|
|
return active_flag_count(peripheral_conn_flags);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
ble_conn_state_conn_handle_list_t ble_conn_state_conn_handles(void)
|
||
|
|
{
|
||
|
|
return conn_handle_list_get(m_bcs.flags.valid_flags);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
ble_conn_state_conn_handle_list_t ble_conn_state_central_handles(void)
|
||
|
|
{
|
||
|
|
nrf_atflags_t central_conn_flags = m_bcs.flags.central_flags;
|
||
|
|
UNUSED_RETURN_VALUE(nrf_atomic_u32_and(¢ral_conn_flags, m_bcs.flags.connected_flags));
|
||
|
|
|
||
|
|
return conn_handle_list_get(central_conn_flags);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
ble_conn_state_conn_handle_list_t ble_conn_state_periph_handles(void)
|
||
|
|
{
|
||
|
|
nrf_atflags_t peripheral_conn_flags = ~m_bcs.flags.central_flags;
|
||
|
|
UNUSED_RETURN_VALUE(nrf_atomic_u32_and(&peripheral_conn_flags, m_bcs.flags.connected_flags));
|
||
|
|
|
||
|
|
return conn_handle_list_get(peripheral_conn_flags);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
uint16_t ble_conn_state_conn_idx(uint16_t conn_handle)
|
||
|
|
{
|
||
|
|
if (ble_conn_state_valid(conn_handle))
|
||
|
|
{
|
||
|
|
return conn_handle;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
return BLE_CONN_STATE_MAX_CONNECTIONS;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
ble_conn_state_user_flag_id_t ble_conn_state_user_flag_acquire(void)
|
||
|
|
{
|
||
|
|
uint32_t acquired_flag = nrf_atflags_find_and_set_flag(&m_bcs.acquired_flags,
|
||
|
|
BLE_CONN_STATE_USER_FLAG_COUNT);
|
||
|
|
|
||
|
|
if (acquired_flag == BLE_CONN_STATE_USER_FLAG_COUNT)
|
||
|
|
{
|
||
|
|
return BLE_CONN_STATE_USER_FLAG_INVALID;
|
||
|
|
}
|
||
|
|
return (ble_conn_state_user_flag_id_t)acquired_flag;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
bool ble_conn_state_user_flag_get(uint16_t conn_handle, ble_conn_state_user_flag_id_t flag_id)
|
||
|
|
{
|
||
|
|
if (user_flag_is_acquired(flag_id) && ble_conn_state_valid(conn_handle))
|
||
|
|
{
|
||
|
|
return nrf_atflags_get(&m_bcs.flags.user_flags[flag_id], conn_handle);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void ble_conn_state_user_flag_set(uint16_t conn_handle,
|
||
|
|
ble_conn_state_user_flag_id_t flag_id,
|
||
|
|
bool value)
|
||
|
|
{
|
||
|
|
if (user_flag_is_acquired(flag_id) && ble_conn_state_valid(conn_handle))
|
||
|
|
{
|
||
|
|
flag_toggle(&m_bcs.flags.user_flags[flag_id], conn_handle, value);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
static uint32_t for_each_set_flag(nrf_atflags_t flags,
|
||
|
|
ble_conn_state_user_function_t user_function,
|
||
|
|
void * p_context)
|
||
|
|
{
|
||
|
|
if (user_function == NULL)
|
||
|
|
{
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
uint32_t call_count = 0;
|
||
|
|
|
||
|
|
if (flags != 0)
|
||
|
|
{
|
||
|
|
for (uint32_t i = 0; i < BLE_CONN_STATE_MAX_CONNECTIONS; i++)
|
||
|
|
{
|
||
|
|
if (nrf_atflags_get(&flags, i))
|
||
|
|
{
|
||
|
|
user_function(i, p_context);
|
||
|
|
call_count += 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return call_count;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
uint32_t ble_conn_state_for_each_connected(ble_conn_state_user_function_t user_function,
|
||
|
|
void * p_context)
|
||
|
|
{
|
||
|
|
return for_each_set_flag(m_bcs.flags.connected_flags, user_function, p_context);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
uint32_t ble_conn_state_for_each_set_user_flag(ble_conn_state_user_flag_id_t flag_id,
|
||
|
|
ble_conn_state_user_function_t user_function,
|
||
|
|
void * p_context)
|
||
|
|
{
|
||
|
|
if (!user_flag_is_acquired(flag_id))
|
||
|
|
{
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
return for_each_set_flag(m_bcs.flags.user_flags[flag_id], user_function, p_context);
|
||
|
|
}
|