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

BLE: cleanup generic sources

pull/13475/head
Vincent Coubard 2020-08-24 11:20:46 +01:00
parent 57b5f711e5
commit bc259c561d
12 changed files with 231 additions and 243 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
connectivity/FEATURE_BLE/source/Gap.cpp
View File

@ -285,14 +285,6 @@ ble_error_t Gap::cancelConnect()
} }
ble_error_t Gap::cancelConnect(
peer_address_type_t peerAddressType,
const address_t &peerAddress
)
{
return impl->cancelConnect(peerAddressType, peerAddress);
}
#endif // BLE_ROLE_CENTRAL #endif // BLE_ROLE_CENTRAL
#if BLE_FEATURE_CONNECTABLE #if BLE_FEATURE_CONNECTABLE

75
connectivity/FEATURE_BLE/source/generic/GapImpl.cpp
View File

@ -17,21 +17,20 @@
*/ */
#include <algorithm> #include <algorithm>
#include <stdint.h> #include <cstdint>
#include "GapImpl.h"
#include "ble/Gap.h"
#include "source/BLEInstanceBase.h"
#include "ble/Gap.h" #include "ble/Gap.h"
#include "ble/SecurityManager.h" #include "ble/SecurityManager.h"
#include "source/BLEInstanceBase.h"
#include "source/generic/GapImpl.h"
#include "source/pal/PalGap.h" #include "source/pal/PalGap.h"
#include "source/pal/GapEvents.h" #include "source/pal/GapEvents.h"
#include "source/pal/GapTypes.h" #include "source/pal/GapTypes.h"
#include "source/pal/PalGenericAccessService.h" #include "source/pal/PalGenericAccessService.h"
#include "source/pal/PalEventQueue.h" #include "source/pal/PalEventQueue.h"
#include "source/pal/PalGap.h"
#include "drivers/Timeout.h"
using namespace std::chrono; using namespace std::chrono;
@ -44,21 +43,21 @@ namespace impl {
namespace { namespace {
// Constants // Constants
static const uint16_t scan_interval_min = 0x0004; const uint16_t scan_interval_min = 0x0004;
static const uint16_t scan_interval_max = 0x4000; const uint16_t scan_interval_max = 0x4000;
static const uint16_t connection_interval_min = 0x0006; const uint16_t connection_interval_min = 0x0006;
static const uint16_t connection_interval_max = 0x0C80; const uint16_t connection_interval_max = 0x0C80;
static const uint16_t slave_latency_min = 0x0000; const uint16_t slave_latency_min = 0x0000;
static const uint16_t slave_latency_max = 0x01F3; const uint16_t slave_latency_max = 0x01F3;
static const uint16_t advertising_interval_min = 0x0020; const uint16_t advertising_interval_min = 0x0020;
static const uint16_t advertising_interval_max = 0x4000; const uint16_t advertising_interval_max = 0x4000;
static const uint16_t supervision_timeout_min = 0x000A; const uint16_t supervision_timeout_min = 0x000A;
static const uint16_t supervision_timeout_max = 0x0C80; const uint16_t supervision_timeout_max = 0x0C80;
static const mbed_error_status_t mixed_scan_api_error = const mbed_error_status_t mixed_scan_api_error =
MBED_MAKE_ERROR(MBED_MODULE_BLE, MBED_ERROR_CODE_BLE_USE_INCOMPATIBLE_API); MBED_MAKE_ERROR(MBED_MODULE_BLE, MBED_ERROR_CODE_BLE_USE_INCOMPATIBLE_API);
static const mbed_error_status_t illegal_state_error = const mbed_error_status_t illegal_state_error =
MBED_MAKE_ERROR(MBED_MODULE_BLE, MBED_ERROR_CODE_BLE_ILLEGAL_STATE); MBED_MAKE_ERROR(MBED_MODULE_BLE, MBED_ERROR_CODE_BLE_ILLEGAL_STATE);
/* /*
@ -82,13 +81,13 @@ static bool is_in_range(T value, T lower_bound, T higher_bound)
* timeout to be equal to 0xFFFF. When it is the case that value can be * timeout to be equal to 0xFFFF. When it is the case that value can be
* interpreted as "non specific". * interpreted as "non specific".
*/ */
static bool is_preferred_connection_params_valid(const Gap::PreferredConnectionParams_t *params) bool is_preferred_connection_params_valid(const Gap::PreferredConnectionParams_t *params)
{ {
if (params == nullptr) { if (params == nullptr) {
return false; return false;
} }
if (is_in_range(params->slaveLatency, slave_latency_min, slave_latency_max) == false) { if (!is_in_range(params->slaveLatency, slave_latency_min, slave_latency_max) == false) {
return false; return false;
} }
@ -132,7 +131,7 @@ static bool is_preferred_connection_params_valid(const Gap::PreferredConnectionP
/** /**
* Check if random bytes of an address are valid. * Check if random bytes of an address are valid.
*/ */
static bool is_prand_valid(const uint8_t *bytes, size_t len) bool is_prand_valid(const uint8_t *bytes, size_t len)
{ {
// at least one bit of the random part of the static address shall be // at least one bit of the random part of the static address shall be
// equal to 0 and at least one bit of the random part of the static // equal to 0 and at least one bit of the random part of the static
@ -163,7 +162,7 @@ static bool is_prand_valid(const uint8_t *bytes, size_t len)
* or not. * or not.
* Return true if it is the case and false otherwise. * Return true if it is the case and false otherwise.
*/ */
static bool is_prand_48_bits_valid(const address_t &address) bool is_prand_48_bits_valid(const address_t &address)
{ {
return is_prand_valid(address.data(), 6); return is_prand_valid(address.data(), 6);
} }
@ -173,7 +172,7 @@ static bool is_prand_48_bits_valid(const address_t &address)
* or not. * or not.
* Return true if it is the case and false otherwise. * Return true if it is the case and false otherwise.
*/ */
static bool is_prand_24_bits_valid(const address_t &address) bool is_prand_24_bits_valid(const address_t &address)
{ {
return is_prand_valid(address.data() + 3, 3); return is_prand_valid(address.data() + 3, 3);
} }
@ -181,7 +180,7 @@ static bool is_prand_24_bits_valid(const address_t &address)
/* /*
* Return true if address is a random static address. * Return true if address is a random static address.
*/ */
static bool is_random_static_address(const address_t &address) bool is_random_static_address(const address_t &address)
{ {
// top two msb bits shall be equal to 0b11. // top two msb bits shall be equal to 0b11.
if ((address[5] & 0xC0) != 0xC0) { if ((address[5] & 0xC0) != 0xC0) {
@ -194,7 +193,7 @@ static bool is_random_static_address(const address_t &address)
/* /*
* Return true if address is a random private non resolvable address. * Return true if address is a random private non resolvable address.
*/ */
static bool is_random_private_non_resolvable_address( bool is_random_private_non_resolvable_address(
const address_t &address const address_t &address
) )
{ {
@ -209,7 +208,7 @@ static bool is_random_private_non_resolvable_address(
/* /*
* Return true if address is a random private resolvable address. * Return true if address is a random private resolvable address.
*/ */
static bool is_random_private_resolvable_address( bool is_random_private_resolvable_address(
const address_t &address const address_t &address
) )
{ {
@ -224,7 +223,7 @@ static bool is_random_private_resolvable_address(
/* /*
* Return true if the address is a random address. * Return true if the address is a random address.
*/ */
static bool is_random_address(const address_t &address) bool is_random_address(const address_t &address)
{ {
return is_random_private_resolvable_address(address) || return is_random_private_resolvable_address(address) ||
is_random_private_non_resolvable_address(address) || is_random_private_non_resolvable_address(address) ||
@ -234,7 +233,7 @@ static bool is_random_address(const address_t &address)
/* /*
* Return true if the whitelist in input is valid or false otherwise. * Return true if the whitelist in input is valid or false otherwise.
*/ */
static bool is_whitelist_valid(const ::ble::whitelist_t &whitelist) bool is_whitelist_valid(const ::ble::whitelist_t &whitelist)
{ {
if (whitelist.size > whitelist.capacity) { if (whitelist.size > whitelist.capacity) {
return false; return false;
@ -266,7 +265,7 @@ static bool is_whitelist_valid(const ::ble::whitelist_t &whitelist)
/* /*
* Return true if device is present in the whitelist. * Return true if device is present in the whitelist.
*/ */
static bool is_in_whitelist( bool is_in_whitelist(
const whitelist_t::entry_t &device, const whitelist_t &whitelist const whitelist_t::entry_t &device, const whitelist_t &whitelist
) )
{ {
@ -283,7 +282,7 @@ static bool is_in_whitelist(
/* /*
* Convert a peer_address_type_t into a whitelist_address_type_t. * Convert a peer_address_type_t into a whitelist_address_type_t.
*/ */
static whitelist_address_type_t to_whitelist_address_type( whitelist_address_type_t to_whitelist_address_type(
peer_address_type_t address_type peer_address_type_t address_type
) )
{ {
@ -354,9 +353,7 @@ Gap::Gap(
} }
Gap::~Gap() Gap::~Gap() = default;
{
}
bool Gap::isFeatureSupported(controller_supported_features_t feature) bool Gap::isFeatureSupported(controller_supported_features_t feature)
@ -907,7 +904,7 @@ ble_error_t Gap::getCentralPrivacyConfiguration(
} }
ble_error_t Gap::reset(void) ble_error_t Gap::reset()
{ {
/* Notify that the instance is about to shut down */ /* Notify that the instance is about to shut down */
// shutdownCallChain.call(this); // shutdownCallChain.call(this);
@ -973,6 +970,16 @@ ble_error_t Gap::reset(void)
return BLE_ERROR_NONE; return BLE_ERROR_NONE;
} }
void Gap::onShutdown(const GapShutdownCallback_t &callback)
{
shutdownCallChain.add(callback);
}
Gap::GapShutdownCallbackChain_t &Gap::onShutdown()
{
return shutdownCallChain;
}
void Gap::on_scan_timeout() void Gap::on_scan_timeout()
{ {

35
connectivity/FEATURE_BLE/source/generic/GapImpl.h
View File

@ -312,7 +312,7 @@ public:
#if BLE_FEATURE_WHITELIST #if BLE_FEATURE_WHITELIST
uint8_t getMaxWhitelistSize(void) const; uint8_t getMaxWhitelistSize() const;
ble_error_t getWhitelist(whitelist_t &whitelist) const; ble_error_t getWhitelist(whitelist_t &whitelist) const;
@ -326,17 +326,14 @@ public:
); );
static ble_error_t getRandomAddressType( static ble_error_t getRandomAddressType(
const ble::address_t address, ble::address_t address,
ble::random_address_type_t *addressType ble::random_address_type_t *addressType
); );
ble_error_t reset(void); ble_error_t reset();
void onShutdown(const GapShutdownCallback_t &callback); void onShutdown(const GapShutdownCallback_t &callback);
template<typename T>
void onShutdown(T *objPtr, void (T::*memberPtr)(const Gap *));
GapShutdownCallbackChain_t &onShutdown(); GapShutdownCallbackChain_t &onShutdown();
#if !defined(DOXYGEN_ONLY) #if !defined(DOXYGEN_ONLY)
@ -432,20 +429,20 @@ private:
connection_handle_t connection_handle, connection_handle_t connection_handle,
phy_t tx_phy, phy_t tx_phy,
phy_t rx_phy phy_t rx_phy
); ) override;
void on_data_length_change( void on_data_length_change(
connection_handle_t connection_handle, connection_handle_t connection_handle,
uint16_t tx_size, uint16_t tx_size,
uint16_t rx_size uint16_t rx_size
); ) override;
void on_phy_update_complete( void on_phy_update_complete(
hci_error_code_t hci_status, hci_error_code_t hci_status,
connection_handle_t connection_handle, connection_handle_t connection_handle,
phy_t tx_phy, phy_t tx_phy,
phy_t rx_phy phy_t rx_phy
); ) override;
void on_enhanced_connection_complete( void on_enhanced_connection_complete(
hci_error_code_t status, hci_error_code_t status,
@ -459,7 +456,7 @@ private:
uint16_t connection_latency, uint16_t connection_latency,
uint16_t supervision_timeout, uint16_t supervision_timeout,
clock_accuracy_t master_clock_accuracy clock_accuracy_t master_clock_accuracy
); ) override;
void on_extended_advertising_report( void on_extended_advertising_report(
advertising_event_t event_type, advertising_event_t event_type,
@ -475,7 +472,7 @@ private:
const ble::address_t &direct_address, const ble::address_t &direct_address,
uint8_t data_length, uint8_t data_length,
const uint8_t *data const uint8_t *data
); ) override;
void on_periodic_advertising_sync_established( void on_periodic_advertising_sync_established(
hci_error_code_t error, hci_error_code_t error,
@ -486,7 +483,7 @@ private:
phy_t advertiser_phy, phy_t advertiser_phy,
uint16_t periodic_advertising_interval, uint16_t periodic_advertising_interval,
clock_accuracy_t clock_accuracy clock_accuracy_t clock_accuracy
); ) override;
void on_periodic_advertising_report( void on_periodic_advertising_report(
sync_handle_t sync_handle, sync_handle_t sync_handle,
@ -495,22 +492,22 @@ private:
advertising_data_status_t data_status, advertising_data_status_t data_status,
uint8_t data_length, uint8_t data_length,
const uint8_t *data const uint8_t *data
); ) override;
void on_periodic_advertising_sync_loss(sync_handle_t sync_handle); void on_periodic_advertising_sync_loss(sync_handle_t sync_handle) override;
void on_advertising_set_terminated( void on_advertising_set_terminated(
hci_error_code_t status, hci_error_code_t status,
advertising_handle_t advertising_handle, advertising_handle_t advertising_handle,
connection_handle_t connection_handle, connection_handle_t connection_handle,
uint8_t number_of_completed_extended_advertising_events uint8_t number_of_completed_extended_advertising_events
); ) override;
void on_scan_request_received( void on_scan_request_received(
advertising_handle_t advertising_handle, advertising_handle_t advertising_handle,
connection_peer_address_type_t scanner_address_type, connection_peer_address_type_t scanner_address_type,
const ble::address_t &address const ble::address_t &address
); ) override;
void on_connection_update_complete( void on_connection_update_complete(
hci_error_code_t status, hci_error_code_t status,
@ -518,7 +515,7 @@ private:
uint16_t connection_interval, uint16_t connection_interval,
uint16_t connection_latency, uint16_t connection_latency,
uint16_t supervision_timeout uint16_t supervision_timeout
); ) override;
void on_remote_connection_parameter( void on_remote_connection_parameter(
connection_handle_t connection_handle, connection_handle_t connection_handle,
@ -526,9 +523,9 @@ private:
uint16_t connection_interval_max, uint16_t connection_interval_max,
uint16_t connection_latency, uint16_t connection_latency,
uint16_t supervision_timeout uint16_t supervision_timeout
); ) override;
void on_scan_timeout(); void on_scan_timeout() override;
void process_legacy_scan_timeout(); void process_legacy_scan_timeout();

89
connectivity/FEATURE_BLE/source/generic/GattClientImpl.cpp
View File

@ -20,17 +20,17 @@
#if BLE_FEATURE_GATT_CLIENT #if BLE_FEATURE_GATT_CLIENT
#include <stdio.h> #include <cstdlib>
#include <stdlib.h> #include <algorithm>
#include "GattClientImpl.h" #include "ble/SecurityManager.h"
#include "source/pal/AttServerMessage.h"
#include "ble/gatt/DiscoveredService.h" #include "ble/gatt/DiscoveredService.h"
#include "ble/gatt/DiscoveredCharacteristic.h" #include "ble/gatt/DiscoveredCharacteristic.h"
#include "ble/common/blecommon.h" #include "ble/common/blecommon.h"
#include "source/generic/GattClientImpl.h"
#include "source/pal/AttServerMessage.h"
#include "source/BLEInstanceBase.h" #include "source/BLEInstanceBase.h"
#include "ble/SecurityManager.h"
#include <algorithm>
using ble::AttServerMessage; using ble::AttServerMessage;
using ble::AttReadResponse; using ble::AttReadResponse;
@ -86,9 +86,7 @@ struct GattClient::ProcedureControlBlock {
{ {
} }
virtual ~ProcedureControlBlock() virtual ~ProcedureControlBlock() = default;
{
}
/* /*
* Entry point of the control block stack machine. * Entry point of the control block stack machine.
@ -115,7 +113,7 @@ struct GattClient::ProcedureControlBlock {
* Procedure control block for the discovery process. * Procedure control block for the discovery process.
*/ */
struct GattClient::DiscoveryControlBlock : public ProcedureControlBlock { struct GattClient::DiscoveryControlBlock final : public ProcedureControlBlock {
using ProcedureControlBlock::connection_handle; using ProcedureControlBlock::connection_handle;
DiscoveryControlBlock( DiscoveryControlBlock(
@ -134,7 +132,7 @@ struct GattClient::DiscoveryControlBlock : public ProcedureControlBlock {
{ {
} }
virtual ~DiscoveryControlBlock() ~DiscoveryControlBlock() final
{ {
while (services_discovered) { while (services_discovered) {
service_t *tmp = services_discovered->next; service_t *tmp = services_discovered->next;
@ -143,17 +141,17 @@ struct GattClient::DiscoveryControlBlock : public ProcedureControlBlock {
} }
} }
virtual void handle_timeout_error(GattClient *client) void handle_timeout_error(GattClient *client) final
{ {
terminate(client); terminate(client);
} }
virtual void abort(GattClient *client) void abort(GattClient *client) final
{ {
terminate(client); terminate(client);
} }
virtual void handle(GattClient *client, const AttServerMessage &message) void handle(GattClient *client, const AttServerMessage &message) final
{ {
// if end of discovery has been requested, ends it immediately // if end of discovery has been requested, ends it immediately
if (done) { if (done) {
@ -178,7 +176,7 @@ struct GattClient::DiscoveryControlBlock : public ProcedureControlBlock {
); );
break; break;
case AttributeOpcode::ERROR_RESPONSE: { case AttributeOpcode::ERROR_RESPONSE: {
const AttErrorResponse &error = static_cast<const AttErrorResponse &>(message); const auto &error = static_cast<const AttErrorResponse &>(message);
if (error.error_code != AttErrorResponse::ATTRIBUTE_NOT_FOUND) { if (error.error_code != AttErrorResponse::ATTRIBUTE_NOT_FOUND) {
terminate(client); terminate(client);
return; return;
@ -222,7 +220,7 @@ struct GattClient::DiscoveryControlBlock : public ProcedureControlBlock {
discovered_service.setup(uuid, start_handle, end_handle); discovered_service.setup(uuid, start_handle, end_handle);
service_callback(&discovered_service); service_callback(&discovered_service);
} else { } else {
service_t *discovered_service = new(std::nothrow) service_t( auto *discovered_service = new(std::nothrow) service_t(
start_handle, end_handle, uuid start_handle, end_handle, uuid
); );
@ -475,7 +473,7 @@ struct GattClient::DiscoveryControlBlock : public ProcedureControlBlock {
}; };
struct GattClient::ReadControlBlock : public ProcedureControlBlock { struct GattClient::ReadControlBlock final : public ProcedureControlBlock {
using ProcedureControlBlock::connection_handle; using ProcedureControlBlock::connection_handle;
ReadControlBlock( ReadControlBlock(
@ -486,14 +484,14 @@ struct GattClient::ReadControlBlock : public ProcedureControlBlock {
{ {
} }
virtual ~ReadControlBlock() ~ReadControlBlock() final
{ {
if (data != nullptr) { if (data != nullptr) {
free(data); free(data);
} }
} }
virtual void handle_timeout_error(GattClient *client) void handle_timeout_error(GattClient *client) final
{ {
GattReadCallbackParams response = { GattReadCallbackParams response = {
connection_handle, connection_handle,
@ -506,7 +504,7 @@ struct GattClient::ReadControlBlock : public ProcedureControlBlock {
terminate(client, response); terminate(client, response);
} }
virtual void abort(GattClient *client) void abort(GattClient *client) final
{ {
GattReadCallbackParams response = { GattReadCallbackParams response = {
connection_handle, connection_handle,
@ -526,7 +524,7 @@ struct GattClient::ReadControlBlock : public ProcedureControlBlock {
delete this; delete this;
} }
virtual void handle(GattClient *client, const AttServerMessage &message) void handle(GattClient *client, const AttServerMessage &message) final
{ {
switch (message.opcode) { switch (message.opcode) {
case AttributeOpcode::ERROR_RESPONSE: case AttributeOpcode::ERROR_RESPONSE:
@ -679,7 +677,7 @@ struct GattClient::ReadControlBlock : public ProcedureControlBlock {
* Control block for the write process * Control block for the write process
*/ */
struct GattClient::WriteControlBlock : public ProcedureControlBlock { struct GattClient::WriteControlBlock final : public ProcedureControlBlock {
using ProcedureControlBlock::connection_handle; using ProcedureControlBlock::connection_handle;
WriteControlBlock( WriteControlBlock(
@ -693,12 +691,12 @@ struct GattClient::WriteControlBlock : public ProcedureControlBlock {
{ {
} }
virtual ~WriteControlBlock() ~WriteControlBlock() final
{ {
free(data); free(data);
} }
virtual void handle_timeout_error(GattClient* client) void handle_timeout_error(GattClient *client) final
{ {
GattWriteCallbackParams response = { GattWriteCallbackParams response = {
connection_handle, connection_handle,
@ -710,7 +708,7 @@ struct GattClient::WriteControlBlock : public ProcedureControlBlock {
terminate(client, response); terminate(client, response);
} }
virtual void abort(GattClient *client) void abort(GattClient *client) final
{ {
GattWriteCallbackParams response = { GattWriteCallbackParams response = {
connection_handle, connection_handle,
@ -729,7 +727,7 @@ struct GattClient::WriteControlBlock : public ProcedureControlBlock {
delete this; delete this;
} }
virtual void handle(GattClient* client, const AttServerMessage& message) void handle(GattClient *client, const AttServerMessage &message) final
{ {
switch(message.opcode) { switch(message.opcode) {
case AttributeOpcode::ERROR_RESPONSE: case AttributeOpcode::ERROR_RESPONSE:
@ -814,7 +812,7 @@ struct GattClient::WriteControlBlock : public ProcedureControlBlock {
connection_handle, connection_handle,
attribute_handle, attribute_handle,
GattWriteCallbackParams::OP_WRITE_REQ, GattWriteCallbackParams::OP_WRITE_REQ,
status, static_cast<uint16_t>(status),
error_code error_code
}; };
@ -849,20 +847,12 @@ struct GattClient::WriteControlBlock : public ProcedureControlBlock {
switch (error.error_code) { switch (error.error_code) {
case AttErrorResponse::INVALID_HANDLE: case AttErrorResponse::INVALID_HANDLE:
status = BLE_ERROR_INVALID_PARAM;
break;
case AttErrorResponse::INVALID_ATTRIBUTE_VALUE_LENGTH: case AttErrorResponse::INVALID_ATTRIBUTE_VALUE_LENGTH:
status = BLE_ERROR_INVALID_PARAM; status = BLE_ERROR_INVALID_PARAM;
break; break;
case AttErrorResponse::INSUFFICIENT_AUTHORIZATION: case AttErrorResponse::INSUFFICIENT_AUTHORIZATION:
status = BLE_ERROR_INVALID_STATE;
break;
case AttErrorResponse::INSUFFICIENT_AUTHENTICATION: case AttErrorResponse::INSUFFICIENT_AUTHENTICATION:
status = BLE_ERROR_INVALID_STATE;
break;
case AttErrorResponse::INSUFFICIENT_ENCRYPTION_KEY_SIZE: case AttErrorResponse::INSUFFICIENT_ENCRYPTION_KEY_SIZE:
status = BLE_ERROR_INVALID_STATE;
break;
case AttErrorResponse::INSUFFICIENT_ENCRYPTION: case AttErrorResponse::INSUFFICIENT_ENCRYPTION:
status = BLE_ERROR_INVALID_STATE; status = BLE_ERROR_INVALID_STATE;
break; break;
@ -902,7 +892,7 @@ struct GattClient::WriteControlBlock : public ProcedureControlBlock {
* Control block for the descriptor discovery process * Control block for the descriptor discovery process
*/ */
struct GattClient::DescriptorDiscoveryControlBlock : public ProcedureControlBlock { struct GattClient::DescriptorDiscoveryControlBlock final : public ProcedureControlBlock {
using ProcedureControlBlock::connection_handle; using ProcedureControlBlock::connection_handle;
DescriptorDiscoveryControlBlock( DescriptorDiscoveryControlBlock(
@ -918,9 +908,7 @@ struct GattClient::DescriptorDiscoveryControlBlock : public ProcedureControlBloc
{ {
} }
virtual ~DescriptorDiscoveryControlBlock() ~DescriptorDiscoveryControlBlock() final = default;
{
}
ble_error_t start(GattClient *client) ble_error_t start(GattClient *client)
{ {
@ -933,17 +921,17 @@ struct GattClient::DescriptorDiscoveryControlBlock : public ProcedureControlBloc
); );
} }
virtual void handle_timeout_error(GattClient *client) void handle_timeout_error(GattClient *client) final
{ {
terminate(client, BLE_ERROR_UNSPECIFIED); terminate(client, BLE_ERROR_UNSPECIFIED);
} }
virtual void abort(GattClient *client) void abort(GattClient *client) final
{ {
terminate(client, BLE_ERROR_INVALID_STATE); terminate(client, BLE_ERROR_INVALID_STATE);
} }
virtual void handle(GattClient *client, const AttServerMessage &message) void handle(GattClient *client, const AttServerMessage &message) final
{ {
if (done) { if (done) {
terminate(client, BLE_ERROR_NONE); terminate(client, BLE_ERROR_NONE);
@ -1061,7 +1049,7 @@ ble_error_t GattClient::launchServiceDiscovery(
return BLE_ERROR_NONE; return BLE_ERROR_NONE;
} }
DiscoveryControlBlock *discovery_pcb = new(std::nothrow) DiscoveryControlBlock( auto *discovery_pcb = new(std::nothrow) DiscoveryControlBlock(
connection_handle, connection_handle,
service_callback, service_callback,
characteristic_callback, characteristic_callback,
@ -1154,7 +1142,7 @@ ble_error_t GattClient::read(
return BLE_ERROR_INVALID_STATE; return BLE_ERROR_INVALID_STATE;
} }
ReadControlBlock *read_pcb = new(std::nothrow) ReadControlBlock( auto *read_pcb = new(std::nothrow) ReadControlBlock(
connection_handle, connection_handle,
attribute_handle, attribute_handle,
offset offset
@ -1253,7 +1241,7 @@ ble_error_t GattClient::write(
memcpy(data, value, length); memcpy(data, value, length);
} }
WriteControlBlock *write_pcb = new(std::nothrow) WriteControlBlock( auto *write_pcb = new(std::nothrow) WriteControlBlock(
connection_handle, connection_handle,
attribute_handle, attribute_handle,
data, data,
@ -1325,7 +1313,7 @@ ble_error_t GattClient::discoverCharacteristicDescriptors(
return BLE_ERROR_NONE; return BLE_ERROR_NONE;
} }
DescriptorDiscoveryControlBlock *discovery_pcb = auto *discovery_pcb =
new(std::nothrow) DescriptorDiscoveryControlBlock( new(std::nothrow) DescriptorDiscoveryControlBlock(
characteristic, characteristic,
discoveryCallback, discoveryCallback,
@ -1375,8 +1363,7 @@ void GattClient::terminateCharacteristicDescriptorDiscovery(
while (pcb) { while (pcb) {
if (pcb->type == DESCRIPTOR_DISCOVERY_PROCEDURE) { if (pcb->type == DESCRIPTOR_DISCOVERY_PROCEDURE) {
DescriptorDiscoveryControlBlock *dpcb = auto *dpcb = static_cast<DescriptorDiscoveryControlBlock *>(pcb);
static_cast<DescriptorDiscoveryControlBlock *>(pcb);
if (dpcb->characteristic == characteristic) { if (dpcb->characteristic == characteristic) {
dpcb->done = true; dpcb->done = true;
return; return;
@ -1397,7 +1384,7 @@ ble_error_t GattClient::negotiateAttMtu(
} }
ble_error_t GattClient::reset(void) ble_error_t GattClient::reset()
{ {
/* Notify that the instance is about to shut down. */ /* Notify that the instance is about to shut down. */
shutdownCallChain.call(client); shutdownCallChain.call(client);
@ -1523,7 +1510,7 @@ void GattClient::on_server_event(connection_handle_t connection, const AttServer
switch (message.opcode) { switch (message.opcode) {
case AttributeOpcode::HANDLE_VALUE_NOTIFICATION: { case AttributeOpcode::HANDLE_VALUE_NOTIFICATION: {
const AttHandleValueNotification &notification = const auto &notification =
static_cast<const AttHandleValueNotification &>(message); static_cast<const AttHandleValueNotification &>(message);
callbacks_params.handle = notification.attribute_handle; callbacks_params.handle = notification.attribute_handle;
callbacks_params.type = BLE_HVX_NOTIFICATION; callbacks_params.type = BLE_HVX_NOTIFICATION;
@ -1532,7 +1519,7 @@ void GattClient::on_server_event(connection_handle_t connection, const AttServer
} break; } break;
case AttributeOpcode::HANDLE_VALUE_INDICATION: { case AttributeOpcode::HANDLE_VALUE_INDICATION: {
const AttHandleValueIndication &indication = const auto &indication =
static_cast<const AttHandleValueIndication &>(message); static_cast<const AttHandleValueIndication &>(message);
callbacks_params.handle = indication.attribute_handle; callbacks_params.handle = indication.attribute_handle;
callbacks_params.type = BLE_HVX_INDICATION; callbacks_params.type = BLE_HVX_INDICATION;

15
connectivity/FEATURE_BLE/source/generic/GattClientImpl.h
View File

@ -61,8 +61,8 @@ public:
ble_error_t launchServiceDiscovery( ble_error_t launchServiceDiscovery(
ble::connection_handle_t connectionHandle, ble::connection_handle_t connectionHandle,
ServiceDiscovery::ServiceCallback_t sc = NULL, ServiceDiscovery::ServiceCallback_t sc = nullptr,
ServiceDiscovery::CharacteristicCallback_t cc = NULL, ServiceDiscovery::CharacteristicCallback_t cc = nullptr,
const UUID &matchingServiceUUID = UUID::ShortUUIDBytes_t(BLE_UUID_UNKNOWN), const UUID &matchingServiceUUID = UUID::ShortUUIDBytes_t(BLE_UUID_UNKNOWN),
const UUID &matchingCharacteristicUUIDIn = UUID::ShortUUIDBytes_t(BLE_UUID_UNKNOWN) const UUID &matchingCharacteristicUUIDIn = UUID::ShortUUIDBytes_t(BLE_UUID_UNKNOWN)
); );
@ -140,9 +140,6 @@ public:
void onShutdown(const GattClientShutdownCallback_t &callback); void onShutdown(const GattClientShutdownCallback_t &callback);
template<typename T>
void onShutdown(T *objPtr, void (T::*memberPtr)(const GattClient *));
GattClientShutdownCallbackChain_t &onShutdown(); GattClientShutdownCallbackChain_t &onShutdown();
HVXCallbackChain_t &onHVX(); HVXCallbackChain_t &onHVX();
@ -178,7 +175,7 @@ private:
void on_att_mtu_change( void on_att_mtu_change(
ble::connection_handle_t connection_handle, ble::connection_handle_t connection_handle,
uint16_t att_mtu_size uint16_t att_mtu_size
); ) override;
/** /**
* @see PalGattClient::EventHandler::on_write_command_sent * @see PalGattClient::EventHandler::on_write_command_sent
@ -187,7 +184,7 @@ private:
ble::connection_handle_t connection_handle, ble::connection_handle_t connection_handle,
ble::attribute_handle_t attribute_handle, ble::attribute_handle_t attribute_handle,
uint8_t status uint8_t status
); ) override;
private: private:
struct ProcedureControlBlock; struct ProcedureControlBlock;
@ -260,9 +257,7 @@ private:
*/ */
GattClient(PalGattClient &pal_client); GattClient(PalGattClient &pal_client);
~GattClient() ~GattClient() = default;
{
}
void setInterface(ble::GattClient *client_interface) void setInterface(ble::GattClient *client_interface)
{ {

4
connectivity/FEATURE_BLE/source/generic/GattServerImpl.cpp
View File

@ -18,7 +18,7 @@
#include "ble/common/BLERoles.h" #include "ble/common/BLERoles.h"
#include <algorithm> #include <algorithm>
#include "GattServerImpl.h" #include "source/generic/GattServerImpl.h"
#include "source/BLEInstanceBase.h" #include "source/BLEInstanceBase.h"
#include "wsf_types.h" #include "wsf_types.h"
#include "att_api.h" #include "att_api.h"
@ -1285,7 +1285,7 @@ void GattServer::add_generic_attribute_service()
void *GattServer::alloc_block(size_t block_size) void *GattServer::alloc_block(size_t block_size)
{ {
alloc_block_t *block = (alloc_block_t *) malloc(sizeof(alloc_block_t) + block_size); auto *block = (alloc_block_t *) malloc(sizeof(alloc_block_t) + block_size);
if (block == nullptr) { if (block == nullptr) {
return nullptr; return nullptr;
} }

26
connectivity/FEATURE_BLE/source/generic/GattServerImpl.h
View File

@ -19,25 +19,29 @@
#ifndef MBED_CORDIO_GATT_SERVER_H__ #ifndef MBED_CORDIO_GATT_SERVER_H__
#define MBED_CORDIO_GATT_SERVER_H__ #define MBED_CORDIO_GATT_SERVER_H__
#include "ble/common/CallChainOfFunctionPointersWithContext.h"
#include <cstddef>
#include "wsf_types.h"
#include "att_api.h"
#include "ble/GattServer.h"
#include "ble/Gap.h"
#include "ble/SecurityManager.h"
#include "ble/gatt/GattService.h" #include "ble/gatt/GattService.h"
#include "ble/gatt/GattAttribute.h" #include "ble/gatt/GattAttribute.h"
#include "GattServerEvents.h" #include "ble/gatt/GattCallbackParamTypes.h"
#include "ble/gatt/GattCallbackParamTypes.h" #include "ble/gatt/GattCallbackParamTypes.h"
#include <stddef.h> #include "ble/common/CallChainOfFunctionPointersWithContext.h"
#include <ble/GattServer.h>
#include "ble/common/blecommon.h" #include "ble/common/blecommon.h"
#include "ble/Gap.h"
#include "wsf_types.h"
#include "att_api.h"
#include "SecurityManager.h"
#include "ble/gatt/GattCallbackParamTypes.h"
#include "source/pal/PalSigningMonitor.h"
#include "source/BLEInstanceBase.h" #include "source/BLEInstanceBase.h"
#include "source/generic/GattServerEvents.h"
#include "source/pal/PalSigningMonitor.h"
namespace ble { namespace ble {

66
connectivity/FEATURE_BLE/source/generic/MemorySecurityDb.h
View File

@ -27,7 +27,7 @@ namespace ble {
class MemorySecurityDb : public SecurityDb { class MemorySecurityDb : public SecurityDb {
private: private:
struct entry_t { struct entry_t {
entry_t() { }; entry_t() = default;
SecurityDistributionFlags_t flags; SecurityDistributionFlags_t flags;
SecurityEntryKeys_t local_keys; SecurityEntryKeys_t local_keys;
SecurityEntryKeys_t peer_keys; SecurityEntryKeys_t peer_keys;
@ -42,21 +42,21 @@ private:
public: public:
MemorySecurityDb() : SecurityDb() { } MemorySecurityDb() : SecurityDb() { }
virtual ~MemorySecurityDb() { } ~MemorySecurityDb() override = default;
virtual SecurityDistributionFlags_t* get_distribution_flags( SecurityDistributionFlags_t* get_distribution_flags(
entry_handle_t db_handle entry_handle_t db_handle
) { ) override {
return reinterpret_cast<SecurityDistributionFlags_t*>(db_handle); return reinterpret_cast<SecurityDistributionFlags_t*>(db_handle);
} }
/* local keys */ /* local keys */
/* set */ /* set */
virtual void set_entry_local_ltk( void set_entry_local_ltk(
entry_handle_t db_handle, entry_handle_t db_handle,
const ltk_t &ltk const ltk_t &ltk
) { ) override {
entry_t *entry = as_entry(db_handle); entry_t *entry = as_entry(db_handle);
if (entry) { if (entry) {
entry->flags.ltk_sent = true; entry->flags.ltk_sent = true;
@ -64,11 +64,11 @@ public:
} }
} }
virtual void set_entry_local_ediv_rand( void set_entry_local_ediv_rand(
entry_handle_t db_handle, entry_handle_t db_handle,
const ediv_t &ediv, const ediv_t &ediv,
const rand_t &rand const rand_t &rand
) { ) override {
entry_t *entry = as_entry(db_handle); entry_t *entry = as_entry(db_handle);
if (entry) { if (entry) {
entry->local_keys.ediv = ediv; entry->local_keys.ediv = ediv;
@ -80,10 +80,10 @@ public:
/* set */ /* set */
virtual void set_entry_peer_ltk( void set_entry_peer_ltk(
entry_handle_t db_handle, entry_handle_t db_handle,
const ltk_t &ltk const ltk_t &ltk
) { ) override {
entry_t *entry = as_entry(db_handle); entry_t *entry = as_entry(db_handle);
if (entry) { if (entry) {
entry->peer_keys.ltk = ltk; entry->peer_keys.ltk = ltk;
@ -91,11 +91,11 @@ public:
} }
} }
virtual void set_entry_peer_ediv_rand( void set_entry_peer_ediv_rand(
entry_handle_t db_handle, entry_handle_t db_handle,
const ediv_t &ediv, const ediv_t &ediv,
const rand_t &rand const rand_t &rand
) { ) override {
entry_t *entry = as_entry(db_handle); entry_t *entry = as_entry(db_handle);
if (entry) { if (entry) {
entry->peer_keys.ediv = ediv; entry->peer_keys.ediv = ediv;
@ -103,10 +103,10 @@ public:
} }
} }
virtual void set_entry_peer_irk( void set_entry_peer_irk(
entry_handle_t db_handle, entry_handle_t db_handle,
const irk_t &irk const irk_t &irk
) { ) override {
entry_t *entry = as_entry(db_handle); entry_t *entry = as_entry(db_handle);
if (entry) { if (entry) {
entry->peer_identity.irk = irk; entry->peer_identity.irk = irk;
@ -114,11 +114,11 @@ public:
} }
} }
virtual void set_entry_peer_bdaddr( void set_entry_peer_bdaddr(
entry_handle_t db_handle, entry_handle_t db_handle,
bool address_is_public, bool address_is_public,
const address_t &peer_address const address_t &peer_address
) { ) override {
entry_t *entry = as_entry(db_handle); entry_t *entry = as_entry(db_handle);
if (entry) { if (entry) {
entry->peer_identity.identity_address = peer_address; entry->peer_identity.identity_address = peer_address;
@ -126,10 +126,10 @@ public:
} }
} }
virtual void set_entry_peer_csrk( void set_entry_peer_csrk(
entry_handle_t db_handle, entry_handle_t db_handle,
const csrk_t &csrk const csrk_t &csrk
) { ) override {
entry_t *entry = as_entry(db_handle); entry_t *entry = as_entry(db_handle);
if (entry) { if (entry) {
entry->flags.csrk_stored = true; entry->flags.csrk_stored = true;
@ -137,10 +137,10 @@ public:
} }
} }
virtual void set_entry_peer_sign_counter( void set_entry_peer_sign_counter(
entry_handle_t db_handle, entry_handle_t db_handle,
sign_count_t sign_counter sign_count_t sign_counter
) { ) override {
entry_t *entry = as_entry(db_handle); entry_t *entry = as_entry(db_handle);
if (entry) { if (entry) {
entry->peer_signing.counter = sign_counter; entry->peer_signing.counter = sign_counter;
@ -148,40 +148,40 @@ public:
} }
private: private:
virtual uint8_t get_entry_count() { uint8_t get_entry_count() override {
return BLE_SECURITY_DATABASE_MAX_ENTRIES; return BLE_SECURITY_DATABASE_MAX_ENTRIES;
} }
virtual SecurityDistributionFlags_t* get_entry_handle_by_index(uint8_t index) { SecurityDistributionFlags_t* get_entry_handle_by_index(uint8_t index) override {
if (index < BLE_SECURITY_DATABASE_MAX_ENTRIES) { if (index < BLE_SECURITY_DATABASE_MAX_ENTRIES) {
return &_entries[index].flags; return &_entries[index].flags;
} else { } else {
return NULL; return nullptr;
} }
} }
virtual void reset_entry(entry_handle_t db_entry) { void reset_entry(entry_handle_t db_entry) override{
entry_t *entry = reinterpret_cast<entry_t*>(db_entry); auto *entry = reinterpret_cast<entry_t*>(db_entry);
*entry = entry_t(); *entry = entry_t();
} }
virtual SecurityEntryIdentity_t* read_in_entry_peer_identity(entry_handle_t db_entry) { SecurityEntryIdentity_t* read_in_entry_peer_identity(entry_handle_t db_entry) override {
entry_t *entry = reinterpret_cast<entry_t*>(db_entry); auto *entry = reinterpret_cast<entry_t*>(db_entry);
return &entry->peer_identity; return &entry->peer_identity;
}; };
virtual SecurityEntryKeys_t* read_in_entry_peer_keys(entry_handle_t db_entry) { SecurityEntryKeys_t* read_in_entry_peer_keys(entry_handle_t db_entry) override {
entry_t *entry = reinterpret_cast<entry_t*>(db_entry); auto *entry = reinterpret_cast<entry_t*>(db_entry);
return &entry->peer_keys; return &entry->peer_keys;
}; };
virtual SecurityEntryKeys_t* read_in_entry_local_keys(entry_handle_t db_entry) { SecurityEntryKeys_t* read_in_entry_local_keys(entry_handle_t db_entry) override {
entry_t *entry = reinterpret_cast<entry_t*>(db_entry); auto *entry = reinterpret_cast<entry_t*>(db_entry);
return &entry->local_keys; return &entry->local_keys;
}; };
virtual SecurityEntrySigning_t* read_in_entry_peer_signing(entry_handle_t db_entry) { SecurityEntrySigning_t* read_in_entry_peer_signing(entry_handle_t db_entry) override {
entry_t *entry = reinterpret_cast<entry_t*>(db_entry); auto *entry = reinterpret_cast<entry_t*>(db_entry);
return &entry->peer_signing; return &entry->peer_signing;
}; };

10
connectivity/FEATURE_BLE/source/generic/SecurityDb.h
View File

@ -19,7 +19,7 @@
#ifndef GENERIC_SECURITY_MANAGER_DB_H__ #ifndef GENERIC_SECURITY_MANAGER_DB_H__
#define GENERIC_SECURITY_MANAGER_DB_H__ #define GENERIC_SECURITY_MANAGER_DB_H__
#include <stdlib.h> #include <cstdlib>
#include "platform/Callback.h" #include "platform/Callback.h"
#include "ble/common/BLETypes.h" #include "ble/common/BLETypes.h"
@ -127,7 +127,7 @@ public:
WhitelistDbCb_t; WhitelistDbCb_t;
SecurityDb() : _local_sign_counter(0) { }; SecurityDb() : _local_sign_counter(0) { };
virtual ~SecurityDb() { }; virtual ~SecurityDb() = default;
/** /**
* Return immediately security flags associated to a db entry. * Return immediately security flags associated to a db entry.
@ -486,7 +486,7 @@ public:
return flags; return flags;
} }
return NULL; return nullptr;
} }
/** /**
@ -535,7 +535,7 @@ public:
} }
} }
return NULL; return nullptr;
} }
/** /**
@ -704,7 +704,7 @@ private:
*/ */
virtual SecurityDistributionFlags_t* get_free_entry_flags() { virtual SecurityDistributionFlags_t* get_free_entry_flags() {
/* get a free one if available */ /* get a free one if available */
SecurityDistributionFlags_t* match = NULL; SecurityDistributionFlags_t* match = nullptr;
for (size_t i = 0; i < get_entry_count(); i++) { for (size_t i = 0; i < get_entry_count(); i++) {
entry_handle_t db_handle = get_entry_handle_by_index(i); entry_handle_t db_handle = get_entry_handle_by_index(i);
SecurityDistributionFlags_t* flags = get_distribution_flags(db_handle); SecurityDistributionFlags_t* flags = get_distribution_flags(db_handle);

57
connectivity/FEATURE_BLE/source/generic/SecurityManagerImpl.cpp
View File

@ -18,11 +18,12 @@
#include "ble/common/BLERoles.h" #include "ble/common/BLERoles.h"
#include "SecurityManagerImpl.h"
#include "source/pal/PalSecurityManager.h" #include "source/pal/PalSecurityManager.h"
#include "MemorySecurityDb.h"
#include "FileSecurityDb.h" #include "source/generic/SecurityManagerImpl.h"
#include "KVStoreSecurityDb.h" #include "source/generic/MemorySecurityDb.h"
#include "source/generic/FileSecurityDb.h"
#include "source/generic/KVStoreSecurityDb.h"
using ble::advertising_peer_address_type_t; using ble::advertising_peer_address_type_t;
using ble::AuthenticationMask; using ble::AuthenticationMask;
@ -33,27 +34,27 @@ namespace ble {
namespace impl { namespace impl {
namespace { namespace {
static constexpr auto SECURITY_MODE_ENCRYPTION_OPEN_LINK = constexpr auto SECURITY_MODE_ENCRYPTION_OPEN_LINK =
ble::SecurityManager::SECURITY_MODE_ENCRYPTION_OPEN_LINK; ble::SecurityManager::SECURITY_MODE_ENCRYPTION_OPEN_LINK;
static constexpr auto SECURITY_MODE_ENCRYPTION_NO_MITM = constexpr auto SECURITY_MODE_ENCRYPTION_NO_MITM =
ble::SecurityManager::SECURITY_MODE_ENCRYPTION_NO_MITM; ble::SecurityManager::SECURITY_MODE_ENCRYPTION_NO_MITM;
static constexpr auto SECURITY_MODE_ENCRYPTION_WITH_MITM = constexpr auto SECURITY_MODE_ENCRYPTION_WITH_MITM =
ble::SecurityManager::SECURITY_MODE_ENCRYPTION_WITH_MITM; ble::SecurityManager::SECURITY_MODE_ENCRYPTION_WITH_MITM;
static constexpr auto SECURITY_MODE_SIGNED_NO_MITM = constexpr auto SECURITY_MODE_SIGNED_NO_MITM =
ble::SecurityManager::SECURITY_MODE_SIGNED_NO_MITM; ble::SecurityManager::SECURITY_MODE_SIGNED_NO_MITM;
static constexpr auto SECURITY_MODE_SIGNED_WITH_MITM = constexpr auto SECURITY_MODE_SIGNED_WITH_MITM =
ble::SecurityManager::SECURITY_MODE_SIGNED_WITH_MITM; ble::SecurityManager::SECURITY_MODE_SIGNED_WITH_MITM;
using SecurityCompletionStatus_t = ble::SecurityManager::SecurityCompletionStatus_t; using SecurityCompletionStatus_t = ble::SecurityManager::SecurityCompletionStatus_t;
static constexpr auto SEC_STATUS_TIMEOUT = constexpr auto SEC_STATUS_TIMEOUT =
ble::SecurityManager::SEC_STATUS_TIMEOUT; ble::SecurityManager::SEC_STATUS_TIMEOUT;
static constexpr auto SEC_STATUS_SUCCESS = constexpr auto SEC_STATUS_SUCCESS =
ble::SecurityManager::SEC_STATUS_SUCCESS; ble::SecurityManager::SEC_STATUS_SUCCESS;
} }
@ -153,8 +154,8 @@ ble_error_t SecurityManager::setDatabaseFilepath(
if (!_db) return BLE_ERROR_INITIALIZATION_INCOMPLETE; if (!_db) return BLE_ERROR_INITIALIZATION_INCOMPLETE;
/* operation only allowed with no connections active */ /* operation only allowed with no connections active */
for (size_t i = 0; i < MAX_CONTROL_BLOCKS; i++) { for (auto & _control_block : _control_blocks) {
if (_control_blocks[i].connected) { if (_control_block.connected) {
return BLE_ERROR_OPERATION_NOT_PERMITTED; return BLE_ERROR_OPERATION_NOT_PERMITTED;
} }
} }
@ -982,7 +983,7 @@ ble_error_t SecurityManager::init_resolving_list()
/* match the resolving list to the currently stored set of IRKs */ /* match the resolving list to the currently stored set of IRKs */
uint8_t resolving_list_capacity = _pal.read_resolving_list_capacity(); uint8_t resolving_list_capacity = _pal.read_resolving_list_capacity();
SecurityEntryIdentity_t* identity_list_p = auto* identity_list_p =
new (std::nothrow) SecurityEntryIdentity_t[resolving_list_capacity]; new (std::nothrow) SecurityEntryIdentity_t[resolving_list_capacity];
if (identity_list_p) { if (identity_list_p) {
@ -1921,7 +1922,7 @@ void SecurityManager::on_ltk_request(
SecurityManager::ControlBlock_t::ControlBlock_t() : SecurityManager::ControlBlock_t::ControlBlock_t() :
connection(0), connection(0),
db_entry(0), db_entry(nullptr),
local_address(), local_address(),
connected(false), connected(false),
authenticated(false), authenticated(false),
@ -1959,9 +1960,9 @@ typename SecurityManager::ControlBlock_t*
SecurityManager::acquire_control_block(connection_handle_t connection) SecurityManager::acquire_control_block(connection_handle_t connection)
{ {
/* grab the first disconnected slot*/ /* grab the first disconnected slot*/
for (size_t i = 0; i < MAX_CONTROL_BLOCKS; i++) { for (auto & control_block : _control_blocks) {
if (!_control_blocks[i].connected) { if (!control_block.connected) {
ControlBlock_t* cb = &_control_blocks[i]; ControlBlock_t* cb = &control_block;
cb->connected = true; cb->connected = true;
cb->connection = connection; cb->connection = connection;
return cb; return cb;
@ -1977,11 +1978,11 @@ SecurityManager::get_control_block(
connection_handle_t connection connection_handle_t connection
) )
{ {
for (size_t i = 0; i < MAX_CONTROL_BLOCKS; i++) { for (auto & cb : _control_blocks) {
if (!_control_blocks[i].connected) { if (!cb.connected) {
continue; continue;
} else if (connection == _control_blocks[i].connection) { } else if (connection == cb.connection) {
return &_control_blocks[i]; return &cb;
} }
} }
return nullptr; return nullptr;
@ -1994,8 +1995,8 @@ SecurityManager::get_control_block(
) )
{ {
MBED_ASSERT(_db); MBED_ASSERT(_db);
for (size_t i = 0; i < MAX_CONTROL_BLOCKS; i++) { for (auto & control_block : _control_blocks) {
ControlBlock_t *cb = &_control_blocks[i]; ControlBlock_t *cb = &control_block;
if (cb->connected) { if (cb->connected) {
SecurityDistributionFlags_t* flags = _db->get_distribution_flags(cb->db_entry); SecurityDistributionFlags_t* flags = _db->get_distribution_flags(cb->db_entry);
if (flags && (flags->peer_address == peer_address)) { if (flags && (flags->peer_address == peer_address)) {
@ -2012,11 +2013,11 @@ SecurityManager::get_control_block(
SecurityDb::entry_handle_t db_entry SecurityDb::entry_handle_t db_entry
) )
{ {
for (size_t i = 0; i < MAX_CONTROL_BLOCKS; i++) { for (auto & cb : _control_blocks) {
if (!_control_blocks[i].connected) { if (!cb.connected) {
continue; continue;
} else if (db_entry == _control_blocks[i].db_entry) { } else if (db_entry == cb.db_entry) {
return &_control_blocks[i]; return &cb;
} }
} }
return nullptr; return nullptr;

88
connectivity/FEATURE_BLE/source/generic/SecurityManagerImpl.h
View File

@ -19,21 +19,25 @@
#ifndef IMPL_SECURITY_MANAGER_H_ #ifndef IMPL_SECURITY_MANAGER_H_
#define IMPL_SECURITY_MANAGER_H_ #define IMPL_SECURITY_MANAGER_H_
#include <stdint.h> #include <cstdint>
#include "ble/common/CallChainOfFunctionPointersWithContext.h"
#include "platform/Callback.h" #include "platform/Callback.h"
#include "ble/Gap.h"
#include "ble/SecurityManager.h"
#include "ble/common/CallChainOfFunctionPointersWithContext.h"
#include "ble/common/BLETypes.h" #include "ble/common/BLETypes.h"
#include "ble/common/blecommon.h" #include "ble/common/blecommon.h"
#include "ble/Gap.h" #include "ble/common/BLETypes.h"
#include "source/pal/GapTypes.h" #include "source/pal/GapTypes.h"
#include "ble/common/BLETypes.h"
#include "SecurityDb.h"
#include "source/pal/PalConnectionMonitor.h" #include "source/pal/PalConnectionMonitor.h"
#include "source/pal/PalSigningMonitor.h" #include "source/pal/PalSigningMonitor.h"
#include "source/pal/PalSecurityManager.h" #include "source/pal/PalSecurityManager.h"
#include "ble/SecurityManager.h"
#include "source/generic/SecurityDb.h"
namespace ble { namespace ble {
class PalGenericAccessService; class PalGenericAccessService;
@ -70,12 +74,12 @@ public:
bool enableBonding = true, bool enableBonding = true,
bool requireMITM = true, bool requireMITM = true,
SecurityIOCapabilities_t iocaps = IO_CAPS_NONE, SecurityIOCapabilities_t iocaps = IO_CAPS_NONE,
const Passkey_t passkey = NULL, const Passkey_t passkey = nullptr,
bool signing = true, bool signing = true,
const char *dbFilepath = NULL const char *dbFilepath = nullptr
); );
ble_error_t setDatabaseFilepath(const char *dbFilepath = NULL); ble_error_t setDatabaseFilepath(const char *dbFilepath = nullptr);
ble_error_t reset(ble::SecurityManager* sm); ble_error_t reset(ble::SecurityManager* sm);
@ -85,7 +89,7 @@ public:
// List management // List management
// //
ble_error_t purgeAllBondingState(void); ble_error_t purgeAllBondingState();
ble_error_t generateWhitelistFromBondTable(::ble::whitelist_t *whitelist) const; ble_error_t generateWhitelistFromBondTable(::ble::whitelist_t *whitelist) const;
@ -246,26 +250,26 @@ private:
AuthenticationMask authentication, AuthenticationMask authentication,
KeyDistribution initiator_dist, KeyDistribution initiator_dist,
KeyDistribution responder_dist KeyDistribution responder_dist
); ) override;
/** @copydoc PalSecurityManager::on_pairing_error /** @copydoc PalSecurityManager::on_pairing_error
*/ */
void on_pairing_error( void on_pairing_error(
connection_handle_t connection, connection_handle_t connection,
pairing_failure_t error pairing_failure_t error
); ) override;
/** @copydoc PalSecurityManager::on_pairing_timed_out /** @copydoc PalSecurityManager::on_pairing_timed_out
*/ */
void on_pairing_timed_out( void on_pairing_timed_out(
connection_handle_t connection connection_handle_t connection
); ) override;
/** @copydoc PalSecurityManager::on_pairing_completed /** @copydoc PalSecurityManager::on_pairing_completed
*/ */
void on_pairing_completed( void on_pairing_completed(
connection_handle_t connection connection_handle_t connection
); ) override;
//////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////
// Security // Security
@ -275,31 +279,31 @@ private:
*/ */
void on_valid_mic_timeout( void on_valid_mic_timeout(
connection_handle_t connection connection_handle_t connection
); ) override;
/** @copydoc PalSecurityManager::on_signed_write_received /** @copydoc PalSecurityManager::on_signed_write_received
*/ */
void on_signed_write_received( void on_signed_write_received(
connection_handle_t connection, connection_handle_t connection,
uint32_t sign_coutner uint32_t sign_coutner
); ) override;
/** @copydoc PalSecurityManager::on_signed_write_verification_failure /** @copydoc PalSecurityManager::on_signed_write_verification_failure
*/ */
void on_signed_write_verification_failure( void on_signed_write_verification_failure(
connection_handle_t connection connection_handle_t connection
); ) override;
/** @copydoc PalSecurityManager::on_signed_write /** @copydoc PalSecurityManager::on_signed_write
*/ */
void on_signed_write(); void on_signed_write() override;
/** @copydoc PalSecurityManager::on_slave_security_request /** @copydoc PalSecurityManager::on_slave_security_request
*/ */
void on_slave_security_request( void on_slave_security_request(
connection_handle_t connection, connection_handle_t connection,
AuthenticationMask authentication AuthenticationMask authentication
); ) override;
//////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////
// Encryption // Encryption
@ -310,13 +314,13 @@ private:
void on_link_encryption_result( void on_link_encryption_result(
connection_handle_t connection, connection_handle_t connection,
link_encryption_t result link_encryption_t result
); ) override;
/** @copydoc PalSecurityManager::on_link_encryption_request_timed_out /** @copydoc PalSecurityManager::on_link_encryption_request_timed_out
*/ */
void on_link_encryption_request_timed_out( void on_link_encryption_request_timed_out(
connection_handle_t connection connection_handle_t connection
); ) override;
//////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////
// MITM // MITM
@ -327,45 +331,45 @@ private:
void on_passkey_display( void on_passkey_display(
connection_handle_t connection, connection_handle_t connection,
passkey_num_t passkey passkey_num_t passkey
); ) override;
/** @copydoc PalSecurityManager::on_keypress_notification /** @copydoc PalSecurityManager::on_keypress_notification
*/ */
void on_keypress_notification( void on_keypress_notification(
connection_handle_t connection, connection_handle_t connection,
ble::Keypress_t keypress ble::Keypress_t keypress
); ) override;
/** @copydoc PalSecurityManager::on_passkey_request /** @copydoc PalSecurityManager::on_passkey_request
*/ */
void on_passkey_request( void on_passkey_request(
connection_handle_t connection connection_handle_t connection
); ) override;
/** @copydoc PalSecurityManager::on_confirmation_request /** @copydoc PalSecurityManager::on_confirmation_request
*/ */
void on_confirmation_request( void on_confirmation_request(
connection_handle_t connection connection_handle_t connection
); ) override;
/** @copydoc PalSecurityManager::on_secure_connections_oob_request /** @copydoc PalSecurityManager::on_secure_connections_oob_request
*/ */
void on_secure_connections_oob_request( void on_secure_connections_oob_request(
connection_handle_t connection connection_handle_t connection
); ) override;
/** @copydoc PalSecurityManager::on_legacy_pairing_oob_request /** @copydoc PalSecurityManager::on_legacy_pairing_oob_request
*/ */
void on_legacy_pairing_oob_request( void on_legacy_pairing_oob_request(
connection_handle_t connection connection_handle_t connection
); ) override;
/** @copydoc PalSecurityManager::on_secure_connections_oob_generated /** @copydoc PalSecurityManager::on_secure_connections_oob_generated
*/ */
void on_secure_connections_oob_generated( void on_secure_connections_oob_generated(
const oob_lesc_value_t &random, const oob_lesc_value_t &random,
const oob_confirm_t &confirm const oob_confirm_t &confirm
); ) override;
//////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////
// Keys // Keys
@ -376,14 +380,14 @@ private:
void on_secure_connections_ltk_generated( void on_secure_connections_ltk_generated(
connection_handle_t connection, connection_handle_t connection,
const ltk_t &ltk const ltk_t &ltk
); ) override;
/** @copydoc PalSecurityManager::on_keys_distributed_ltk /** @copydoc PalSecurityManager::on_keys_distributed_ltk
*/ */
void on_keys_distributed_ltk( void on_keys_distributed_ltk(
connection_handle_t connection, connection_handle_t connection,
const ltk_t &ltk const ltk_t &ltk
); ) override;
/** @copydoc PalSecurityManager::on_keys_distributed_ediv_rand /** @copydoc PalSecurityManager::on_keys_distributed_ediv_rand
*/ */
@ -391,14 +395,14 @@ private:
connection_handle_t connection, connection_handle_t connection,
const ediv_t &ediv, const ediv_t &ediv,
const rand_t &rand const rand_t &rand
); ) override;
/** @copydoc PalSecurityManager::on_keys_distributed_local_ltk /** @copydoc PalSecurityManager::on_keys_distributed_local_ltk
*/ */
void on_keys_distributed_local_ltk( void on_keys_distributed_local_ltk(
connection_handle_t connection, connection_handle_t connection,
const ltk_t &ltk const ltk_t &ltk
); ) override;
/** @copydoc PalSecurityManager::on_keys_distributed_local_ediv_rand /** @copydoc PalSecurityManager::on_keys_distributed_local_ediv_rand
*/ */
@ -406,14 +410,14 @@ private:
connection_handle_t connection, connection_handle_t connection,
const ediv_t &ediv, const ediv_t &ediv,
const rand_t &rand const rand_t &rand
); ) override;
/** @copydoc PalSecurityManager::on_keys_distributed_irk /** @copydoc PalSecurityManager::on_keys_distributed_irk
*/ */
void on_keys_distributed_irk( void on_keys_distributed_irk(
connection_handle_t connection, connection_handle_t connection,
const irk_t &irk const irk_t &irk
); ) override;
/** @copydoc PalSecurityManager::on_keys_distributed_bdaddr /** @copydoc PalSecurityManager::on_keys_distributed_bdaddr
*/ */
@ -421,14 +425,14 @@ private:
connection_handle_t connection, connection_handle_t connection,
advertising_peer_address_type_t peer_address_type, advertising_peer_address_type_t peer_address_type,
const address_t &peer_identity_address const address_t &peer_identity_address
); ) override;
/** @copydoc PalSecurityManager::on_keys_distributed_csrk /** @copydoc PalSecurityManager::on_keys_distributed_csrk
*/ */
void on_keys_distributed_csrk( void on_keys_distributed_csrk(
connection_handle_t connection, connection_handle_t connection,
const csrk_t &csrk const csrk_t &csrk
); ) override;
/** @copydoc PalSecurityManager::on_ltk_requeston_ltk_request /** @copydoc PalSecurityManager::on_ltk_requeston_ltk_request
*/ */
@ -436,13 +440,13 @@ private:
connection_handle_t connection, connection_handle_t connection,
const ediv_t &ediv, const ediv_t &ediv,
const rand_t &rand const rand_t &rand
); ) override;
/** @copydoc PalSecurityManager::on_ltk_requeston_ltk_request /** @copydoc PalSecurityManager::on_ltk_requeston_ltk_request
*/ */
void on_ltk_request( void on_ltk_request(
connection_handle_t connection connection_handle_t connection
); ) override;
/* end implements PalSecurityManager::EventHandler */ /* end implements PalSecurityManager::EventHandler */
@ -460,7 +464,7 @@ private:
_pal(palImpl), _pal(palImpl),
_connection_monitor(connMonitorImpl), _connection_monitor(connMonitorImpl),
_signing_monitor(signingMonitorImpl), _signing_monitor(signingMonitorImpl),
_db(NULL), _db(nullptr),
_default_authentication(0), _default_authentication(0),
_default_key_distribution(KeyDistribution::KEY_DISTRIBUTION_ALL), _default_key_distribution(KeyDistribution::KEY_DISTRIBUTION_ALL),
_pairing_authorisation_required(false), _pairing_authorisation_required(false),
@ -487,7 +491,7 @@ private:
private: private:
ble_error_t init_database(const char *db_path = NULL); ble_error_t init_database(const char *db_path = nullptr);
ble_error_t init_resolving_list(); ble_error_t init_resolving_list();
@ -544,12 +548,12 @@ private:
address_t peer_address, address_t peer_address,
own_address_type_t local_address_type, own_address_type_t local_address_type,
address_t local_address address_t local_address
); ) override;
void on_disconnected( void on_disconnected(
connection_handle_t connection, connection_handle_t connection,
disconnection_reason_t reason disconnection_reason_t reason
); ) override;
void on_security_entry_retrieved( void on_security_entry_retrieved(
SecurityDb::entry_handle_t entry, SecurityDb::entry_handle_t entry,

1
connectivity/FEATURE_BLE/source/pal/PalSecurityManager.h
View File

@ -22,6 +22,7 @@
#include "platform/Callback.h" #include "platform/Callback.h"
#include "platform/NonCopyable.h" #include "platform/NonCopyable.h"
#include "ble/common/blecommon.h"
#include "ble/common/BLETypes.h" #include "ble/common/BLETypes.h"
#include "GapTypes.h" #include "GapTypes.h"