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

Merge pull request #8591 from 0xc0170/fix_coding_style_features 

features: fix coding style
pull/8697/head
Cruz Monrreal 2018-11-09 09:40:56 -06:00 committed by GitHub
parent 44ee9a7af7 20646d3da1
commit 9d95d46d6c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
124 changed files with 1494 additions and 1385 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
.astyleignore
View File

@ -3,17 +3,22 @@ cmsis
features/cryptocell
features/mbedtls
features/lwipstack/lwip
features/lwipstack/lwip-sys
rtos/TARGET_CORTEX/rtx4
features/storage/filesystem/littlefs/littlefs/
features/storage/filesystem/fat/ChaN
features/storage/FEATURE_STORAGE
features/frameworks
features/FEATURE_BLE/targets
features/FEATURE_BLE
features/unsupported/
features/netsocket/emac-drivers
hal/storage_abstraction
FEATURE_NANOSTACK/coap-service
FEATURE_NANOSTACK/sal-stack-nanostack
TESTS/mbed_hal/trng/pithy
features/nanostack/coap-service
features/nanostack/sal-stack-nanostack
rtos/TARGET_CORTEX/rtx5
TESTS/mbed_hal/trng/pithy
targets
components/802.15.4_RF
components/wifi
tools

3
TESTS/mbed_hal/minimum_requirements/main.cpp
View File

@ -66,6 +66,7 @@ Case cases[] = {
Specification specification(greentea_test_setup, cases, greentea_test_teardown_handler);
int main() {
int main()
{
Harness::run(specification);
}

50
events/equeue/equeue_mbed.cpp
View File

@ -35,7 +35,8 @@ using namespace mbed;
// Ticker operations
#if MBED_CONF_RTOS_PRESENT
unsigned equeue_tick() {
unsigned equeue_tick()
{
return osKernelGetTickCount();
}
@ -59,12 +60,14 @@ static unsigned equeue_timer[
static unsigned equeue_ticker[
(sizeof(ALIAS_TICKER) + sizeof(unsigned) - 1) / sizeof(unsigned)];
static void equeue_tick_update() {
static void equeue_tick_update()
{
equeue_minutes += reinterpret_cast<ALIAS_TIMER *>(equeue_timer)->read_ms();
reinterpret_cast<ALIAS_TIMER *>(equeue_timer)->reset();
}
static void equeue_tick_init() {
static void equeue_tick_init()
{
MBED_STATIC_ASSERT(sizeof(equeue_timer) >= sizeof(ALIAS_TIMER),
"The equeue_timer buffer must fit the class Timer");
MBED_STATIC_ASSERT(sizeof(equeue_ticker) >= sizeof(ALIAS_TICKER),
@ -79,7 +82,8 @@ static void equeue_tick_init() {
equeue_tick_inited = true;
}
unsigned equeue_tick() {
unsigned equeue_tick()
{
if (!equeue_tick_inited) {
equeue_tick_init();
}
@ -98,14 +102,19 @@ unsigned equeue_tick() {
#endif
// Mutex operations
int equeue_mutex_create(equeue_mutex_t *m) { return 0; }
int equeue_mutex_create(equeue_mutex_t *m)
{
return 0;
}
void equeue_mutex_destroy(equeue_mutex_t *m) { }
void equeue_mutex_lock(equeue_mutex_t *m) {
void equeue_mutex_lock(equeue_mutex_t *m)
{
core_util_critical_section_enter();
}
void equeue_mutex_unlock(equeue_mutex_t *m) {
void equeue_mutex_unlock(equeue_mutex_t *m)
{
core_util_critical_section_exit();
}
@ -113,7 +122,8 @@ void equeue_mutex_unlock(equeue_mutex_t *m) {
// Semaphore operations
#ifdef MBED_CONF_RTOS_PRESENT
int equeue_sema_create(equeue_sema_t *s) {
int equeue_sema_create(equeue_sema_t *s)
{
osEventFlagsAttr_t attr;
memset(&attr, 0, sizeof(attr));
attr.cb_mem = &s->mem;
@ -123,15 +133,18 @@ int equeue_sema_create(equeue_sema_t *s) {
return !s->id ? -1 : 0;
}
void equeue_sema_destroy(equeue_sema_t *s) {
void equeue_sema_destroy(equeue_sema_t *s)
{
osEventFlagsDelete(s->id);
}
void equeue_sema_signal(equeue_sema_t *s) {
void equeue_sema_signal(equeue_sema_t *s)
{
osEventFlagsSet(s->id, 1);
}
bool equeue_sema_wait(equeue_sema_t *s, int ms) {
bool equeue_sema_wait(equeue_sema_t *s, int ms)
{
if (ms < 0) {
ms = osWaitForever;
}
@ -142,23 +155,28 @@ bool equeue_sema_wait(equeue_sema_t *s, int ms) {
#else
// Semaphore operations
int equeue_sema_create(equeue_sema_t *s) {
int equeue_sema_create(equeue_sema_t *s)
{
*s = false;
return 0;
}
void equeue_sema_destroy(equeue_sema_t *s) {
void equeue_sema_destroy(equeue_sema_t *s)
{
}
void equeue_sema_signal(equeue_sema_t *s) {
void equeue_sema_signal(equeue_sema_t *s)
{
*s = 1;
}
static void equeue_sema_timeout(equeue_sema_t *s) {
static void equeue_sema_timeout(equeue_sema_t *s)
{
*s = -1;
}
bool equeue_sema_wait(equeue_sema_t *s, int ms) {
bool equeue_sema_wait(equeue_sema_t *s, int ms)
{
int signal = 0;
ALIAS_TIMEOUT timeout;
if (ms == 0) {

3
features/cellular/framework/targets/UBLOX/AT/UBLOX_AT.h
View File

@ -20,8 +20,7 @@
#include "AT_CellularDevice.h"
namespace mbed
{
namespace mbed {
class UBLOX_AT : public AT_CellularDevice {
public:

6
features/cellular/framework/targets/UBLOX/AT/UBLOX_AT_CellularNetwork.h
View File

@ -21,11 +21,9 @@
#include "AT_CellularNetwork.h"
#include "APN_db.h"
namespace mbed
{
namespace mbed {
class UBLOX_AT_CellularNetwork : public AT_CellularNetwork
{
class UBLOX_AT_CellularNetwork : public AT_CellularNetwork {
public:
UBLOX_AT_CellularNetwork(ATHandler &atHandler);
virtual ~UBLOX_AT_CellularNetwork();

6
features/cellular/framework/targets/UBLOX/AT/UBLOX_AT_CellularPower.h
View File

@ -20,11 +20,9 @@
#include "AT_CellularPower.h"
namespace mbed
{
namespace mbed {
class UBLOX_AT_CellularPower : public AT_CellularPower
{
class UBLOX_AT_CellularPower : public AT_CellularPower {
public:
UBLOX_AT_CellularPower(ATHandler &atHandler);
virtual ~UBLOX_AT_CellularPower();

6
features/cellular/framework/targets/UBLOX/AT/UBLOX_AT_CellularStack.h
View File

@ -23,11 +23,9 @@
#include "drivers/Timer.h"
namespace mbed
{
namespace mbed {
class UBLOX_AT_CellularStack : public AT_CellularStack
{
class UBLOX_AT_CellularStack : public AT_CellularStack {
public:
UBLOX_AT_CellularStack(ATHandler &atHandler, int cid, nsapi_ip_stack_t stack_type);
virtual ~UBLOX_AT_CellularStack();

5
features/deprecated_warnings/FEATURE_LWIP/feature_lwip_is_deprecated.c
View File

@ -21,4 +21,7 @@
MBED_DEPRECATED_SINCE("5.10", "FEATURE_LWIP is deprecated. You do not need to enable it anymore in mbed_app.json")
static void feature_lwip(void) { }
void dummy_feature_lwip_is_deprecated(void) { feature_lwip(); }
void dummy_feature_lwip_is_deprecated(void)
{
feature_lwip();
}

5
features/deprecated_warnings/FEATURE_NANOSTACK/feature_nanostack_is_deprecated.c
View File

@ -21,4 +21,7 @@
MBED_DEPRECATED_SINCE("5.10", "FEATURE_NANOSTACK is deprecated. You do not need to enable it anymore in mbed_app.json")
static void feature_nanostack(void) { }
void dummy_feature_nanostack_is_deprecated(void) { feature_nanostack(); }
void dummy_feature_nanostack_is_deprecated(void)
{
feature_nanostack();
}

3
features/lorawan/LoRaRadio.h
View File

@ -184,8 +184,7 @@ typedef struct radio_events {
/**
* Interface for the radios, contains the main functions that a radio needs, and five callback functions.
*/
class LoRaRadio
{
class LoRaRadio {
public:

48
features/lorawan/lorastack/mac/LoRaMacCrypto.cpp
View File

@ -67,24 +67,29 @@ int LoRaMacCrypto::compute_mic(const uint8_t *buffer, uint16_t size,
if (NULL != cipher_info) {
ret = mbedtls_cipher_setup(aes_cmac_ctx, cipher_info);
if (0 != ret)
if (0 != ret) {
goto exit;
}
ret = mbedtls_cipher_cmac_starts(aes_cmac_ctx, key, key_length);
if (0 != ret)
if (0 != ret) {
goto exit;
}
ret = mbedtls_cipher_cmac_update(aes_cmac_ctx, mic_block_b0, sizeof(mic_block_b0));
if (0 != ret)
if (0 != ret) {
goto exit;
}
ret = mbedtls_cipher_cmac_update(aes_cmac_ctx, buffer, size & 0xFF);
if (0 != ret)
if (0 != ret) {
goto exit;
}
ret = mbedtls_cipher_cmac_finish(aes_cmac_ctx, computed_mic);
if (0 != ret)
if (0 != ret) {
goto exit;
}
*mic = (uint32_t)((uint32_t) computed_mic[3] << 24
| (uint32_t) computed_mic[2] << 16
@ -112,8 +117,9 @@ int LoRaMacCrypto::encrypt_payload(const uint8_t *buffer, uint16_t size,
mbedtls_aes_init(&aes_ctx);
ret = mbedtls_aes_setkey_enc(&aes_ctx, key, key_length);
if (0 != ret)
if (0 != ret) {
goto exit;
}
a_block[0] = 0x01;
a_block[5] = dir;
@ -133,8 +139,9 @@ int LoRaMacCrypto::encrypt_payload(const uint8_t *buffer, uint16_t size,
ctr++;
ret = mbedtls_aes_crypt_ecb(&aes_ctx, MBEDTLS_AES_ENCRYPT, a_block,
s_block);
if (0 != ret)
if (0 != ret) {
goto exit;
}
for (i = 0; i < 16; i++) {
enc_buffer[bufferIndex + i] = buffer[bufferIndex + i] ^ s_block[i];
@ -147,8 +154,9 @@ int LoRaMacCrypto::encrypt_payload(const uint8_t *buffer, uint16_t size,
a_block[15] = ((ctr) & 0xFF);
ret = mbedtls_aes_crypt_ecb(&aes_ctx, MBEDTLS_AES_ENCRYPT, a_block,
s_block);
if (0 != ret)
if (0 != ret) {
goto exit;
}
for (i = 0; i < size; i++) {
enc_buffer[bufferIndex + i] = buffer[bufferIndex + i] ^ s_block[i];
@ -181,20 +189,24 @@ int LoRaMacCrypto::compute_join_frame_mic(const uint8_t *buffer, uint16_t size,
if (NULL != cipher_info) {
ret = mbedtls_cipher_setup(aes_cmac_ctx, cipher_info);
if (0 != ret)
if (0 != ret) {
goto exit;
}
ret = mbedtls_cipher_cmac_starts(aes_cmac_ctx, key, key_length);
if (0 != ret)
if (0 != ret) {
goto exit;
}
ret = mbedtls_cipher_cmac_update(aes_cmac_ctx, buffer, size & 0xFF);
if (0 != ret)
if (0 != ret) {
goto exit;
}
ret = mbedtls_cipher_cmac_finish(aes_cmac_ctx, computed_mic);
if (0 != ret)
if (0 != ret) {
goto exit;
}
*mic = (uint32_t)((uint32_t) computed_mic[3] << 24
| (uint32_t) computed_mic[2] << 16
@ -217,13 +229,15 @@ int LoRaMacCrypto::decrypt_join_frame(const uint8_t *buffer, uint16_t size,
mbedtls_aes_init(&aes_ctx);
ret = mbedtls_aes_setkey_enc(&aes_ctx, key, key_length);
if (0 != ret)
if (0 != ret) {
goto exit;
}
ret = mbedtls_aes_crypt_ecb(&aes_ctx, MBEDTLS_AES_ENCRYPT, buffer,
dec_buffer);
if (0 != ret)
if (0 != ret) {
goto exit;
}
// Check if optional CFList is included
if (size >= 16) {
@ -247,16 +261,18 @@ int LoRaMacCrypto::compute_skeys_for_join_frame(const uint8_t *key, uint32_t key
mbedtls_aes_init(&aes_ctx);
ret = mbedtls_aes_setkey_enc(&aes_ctx, key, key_length);
if (0 != ret)
if (0 != ret) {
goto exit;
}
memset(nonce, 0, sizeof(nonce));
nonce[0] = 0x01;
memcpy(nonce + 1, app_nonce, 6);
memcpy(nonce + 7, p_dev_nonce, 2);
ret = mbedtls_aes_crypt_ecb(&aes_ctx, MBEDTLS_AES_ENCRYPT, nonce, nwk_skey);
if (0 != ret)
if (0 != ret) {
goto exit;
}
memset(nonce, 0, sizeof(nonce));
nonce[0] = 0x02;

3
features/lorawan/lorastack/mac/LoRaMacCrypto.h
View File

@ -34,8 +34,7 @@ SPDX-License-Identifier: BSD-3-Clause
#include "mbedtls/cmac.h"
class LoRaMacCrypto
{
class LoRaMacCrypto {
public:
/**
* Constructor

15
features/lorawan/lorastack/phy/LoRaPHYAU915.cpp
View File

@ -193,13 +193,16 @@ static const uint8_t datarates_AU915[] = {12, 11, 10, 9, 8, 7, 8, 0, 12, 11, 10,
*/
static const uint32_t bandwidths_AU915[] = { 125000, 125000, 125000, 125000,
125000, 125000, 500000, 0, 500000, 500000, 500000, 500000, 500000, 500000,
0, 0 };
0, 0
};
/*!
* Up/Down link data rates offset definition
*/
static const int8_t datarate_offsets_AU915[7][6] = { { DR_8, DR_8, DR_8, DR_8,
DR_8, DR_8 }, // DR_0
static const int8_t datarate_offsets_AU915[7][6] = { {
DR_8, DR_8, DR_8, DR_8,
DR_8, DR_8
}, // DR_0
{ DR_9, DR_8, DR_8, DR_8, DR_8, DR_8 }, // DR_1
{ DR_10, DR_9, DR_8, DR_8, DR_8, DR_8 }, // DR_2
{ DR_11, DR_10, DR_9, DR_8, DR_8, DR_8 }, // DR_3
@ -212,13 +215,15 @@ DR_8, DR_8 }, // DR_0
* Maximum payload with respect to the datarate index. Cannot operate with repeater.
*/
static const uint8_t max_payload_AU915[] = { 51, 51, 51, 115, 242, 242,
242, 0, 53, 129, 242, 242, 242, 242, 0, 0 };
242, 0, 53, 129, 242, 242, 242, 242, 0, 0
};
/*!
* Maximum payload with respect to the datarate index. Can operate with repeater.
*/
static const uint8_t max_payload_with_repeater_AU915[] = { 51, 51, 51, 115,
222, 222, 222, 0, 33, 109, 222, 222, 222, 222, 0, 0 };
222, 222, 222, 0, 33, 109, 222, 222, 222, 222, 0, 0
};
static const uint16_t fsb_mask[] = MBED_CONF_LORA_FSB_MASK;

6
features/lorawan/lorastack/phy/LoRaPHYCN470.cpp
View File

@ -212,8 +212,7 @@ LoRaPHYCN470::LoRaPHYCN470()
// Channels
// 125 kHz channels
for( uint8_t i = 0; i < CN470_MAX_NB_CHANNELS; i++ )
{
for (uint8_t i = 0; i < CN470_MAX_NB_CHANNELS; i++) {
channels[i].frequency = 470300000 + i * 200000;
channels[i].dr_range.value = (DR_5 << 4) | DR_0;
channels[i].band = 0;
@ -375,8 +374,7 @@ bool LoRaPHYCN470::rx_config(rx_config_params_t* config)
_radio->unlock();
if( config->rx_slot == RX_SLOT_WIN_1 )
{
if (config->rx_slot == RX_SLOT_WIN_1) {
// Apply window 1 frequency
frequency = CN470_FIRST_RX1_CHANNEL + (config->channel % 48) * CN470_STEPWIDTH_RX1_CHANNEL;
}

6
features/lorawan/lorastack/phy/LoRaPHYUS915.cpp
View File

@ -192,8 +192,7 @@ static const uint32_t bandwidths_US915[] = {125000, 125000, 125000, 125000, 5000
/*!
* Up/Down link data rates offset definition
*/
static const int8_t datarate_offsets_US915[5][4] =
{
static const int8_t datarate_offsets_US915[5][4] = {
{ DR_10, DR_9, DR_8, DR_8 }, // DR_0
{ DR_11, DR_10, DR_9, DR_8 }, // DR_1
{ DR_12, DR_11, DR_10, DR_9 }, // DR_2
@ -572,8 +571,7 @@ uint8_t LoRaPHYUS915::accept_rx_param_setup_req(rx_param_setup_req_t* params)
}
// Verify datarate offset
if (val_in_range( params->dr_offset, US915_MIN_RX1_DR_OFFSET, US915_MAX_RX1_DR_OFFSET ) == 0 )
{
if (val_in_range(params->dr_offset, US915_MIN_RX1_DR_OFFSET, US915_MAX_RX1_DR_OFFSET) == 0) {
status &= 0xFB; // Rx1DrOffset range KO
}

3
features/lorawan/system/LoRaWANTimer.h
View File

@ -26,8 +26,7 @@ SPDX-License-Identifier: BSD-3-Clause
#include "lorawan_data_structures.h"
class LoRaWANTimeHandler
{
class LoRaWANTimeHandler {
public:
LoRaWANTimeHandler();
~LoRaWANTimeHandler();

4
features/lwipstack/LWIPInterface.cpp
View File

@ -186,7 +186,7 @@ void LWIP::Interface::netif_link_irq(struct netif *netif)
if (interface->client_callback && connectedStatusPrev != interface->connected
&& interface->connected != NSAPI_STATUS_GLOBAL_UP /* advertised by netif_status_irq */
&& interface->connected != NSAPI_STATUS_DISCONNECTED) /* advertised by bring_down */ {
&& interface->connected != NSAPI_STATUS_DISCONNECTED) { /* advertised by bring_down */
interface->client_callback(NSAPI_EVENT_CONNECTION_STATUS_CHANGE, interface->connected);
}
}
@ -235,7 +235,7 @@ void LWIP::Interface::netif_status_irq(struct netif *netif)
}
if (interface->client_callback && (connectedStatusPrev != interface->connected)
&& interface->connected != NSAPI_STATUS_DISCONNECTED) /* advertised by bring_down */ {
&& interface->connected != NSAPI_STATUS_DISCONNECTED) { /* advertised by bring_down */
interface->client_callback(NSAPI_EVENT_CONNECTION_STATUS_CHANGE, interface->connected);
}
}

6
features/lwipstack/LWIPInterfaceEMAC.cpp
View File

@ -74,8 +74,7 @@ err_t LWIP::Interface::emac_igmp_mac_filter(struct netif *netif, const ip4_addr_
LWIP::Interface *mbed_if = static_cast<LWIP::Interface *>(netif->state);
switch (action) {
case NETIF_ADD_MAC_FILTER:
{
case NETIF_ADD_MAC_FILTER: {
uint32_t group23 = ntohl(group->addr) & 0x007FFFFF;
uint8_t addr[6];
addr[0] = LL_IP4_MULTICAST_ADDR_0;
@ -112,8 +111,7 @@ err_t LWIP::Interface::emac_mld_mac_filter(struct netif *netif, const ip6_addr_t
LWIP::Interface *mbed_if = static_cast<LWIP::Interface *>(netif->state);
switch (action) {
case NETIF_ADD_MAC_FILTER:
{
case NETIF_ADD_MAC_FILTER: {
uint32_t group32 = ntohl(group->addr[3]);
uint8_t addr[6];
addr[0] = LL_IP6_MULTICAST_ADDR_0;

9
features/lwipstack/LWIPStack.cpp
View File

@ -485,7 +485,8 @@ nsapi_size_or_error_t LWIP::socket_recvfrom(nsapi_socket_t handle, SocketAddress
return recv;
}
int32_t LWIP::find_multicast_member(const struct mbed_lwip_socket *s, const nsapi_ip_mreq_t *imr) {
int32_t LWIP::find_multicast_member(const struct mbed_lwip_socket *s, const nsapi_ip_mreq_t *imr)
{
uint32_t count = 0;
uint32_t index = 0;
// Set upper limit on while loop, should break out when the membership pair is found
@ -662,7 +663,8 @@ void LWIP::socket_attach(nsapi_socket_t handle, void (*callback)(void *), void *
s->data = data;
}
LWIP &LWIP::get_instance() {
LWIP &LWIP::get_instance()
{
static LWIP lwip;
return lwip;
}
@ -672,7 +674,8 @@ LWIP &LWIP::get_instance() {
#define LWIP 0x11991199
#if MBED_CONF_NSAPI_DEFAULT_STACK == LWIP
#undef LWIP
OnboardNetworkStack &OnboardNetworkStack::get_default_instance() {
OnboardNetworkStack &OnboardNetworkStack::get_default_instance()
{
return LWIP::get_instance();
}
#endif

20
features/lwipstack/LWIPStack.h
View File

@ -487,21 +487,29 @@ private:
struct mbed_lwip_socket *arena_alloc();
void arena_dealloc(struct mbed_lwip_socket *s);
static uint32_t next_registered_multicast_member(const struct mbed_lwip_socket *s, uint32_t index) {
while (!(s->multicast_memberships_registry & (0x0001 << index))) { index++; }
static uint32_t next_registered_multicast_member(const struct mbed_lwip_socket *s, uint32_t index)
{
while (!(s->multicast_memberships_registry & (0x0001 << index))) {
index++;
}
return index;
}
static uint32_t next_free_multicast_member(const struct mbed_lwip_socket *s, uint32_t index) {
while ((s->multicast_memberships_registry & (0x0001 << index))) { index++; }
static uint32_t next_free_multicast_member(const struct mbed_lwip_socket *s, uint32_t index)
{
while ((s->multicast_memberships_registry & (0x0001 << index))) {
index++;
}
return index;
}
static void set_multicast_member_registry_bit(struct mbed_lwip_socket *s, uint32_t index) {
static void set_multicast_member_registry_bit(struct mbed_lwip_socket *s, uint32_t index)
{
s->multicast_memberships_registry |= (0x0001 << index);
}
static void clear_multicast_member_registry_bit(struct mbed_lwip_socket *s, uint32_t index) {
static void clear_multicast_member_registry_bit(struct mbed_lwip_socket *s, uint32_t index)
{
s->multicast_memberships_registry &= ~(0x0001 << index);
}
static int32_t find_multicast_member(const struct mbed_lwip_socket *s, const nsapi_ip_mreq_t *imr);

3
features/lwipstack/lwip_tools.cpp
View File

@ -27,7 +27,8 @@
#include "netsocket/nsapi_types.h"
/* LWIP error remapping */
nsapi_error_t LWIP::err_remap(err_t err) {
nsapi_error_t LWIP::err_remap(err_t err)
{
switch (err) {
case ERR_OK:
case ERR_CLSD:

3
features/lwipstack/ppp_lwip.cpp
View File

@ -268,7 +268,8 @@ static void ppp_input()
return;
}
static void stream_cb() {
static void stream_cb()
{
if (my_stream && !event_queued) {
event_queued = true;
if (event_queue->call(callback(ppp_input)) == 0) {

6
features/netsocket/TLSSocket.h
View File

@ -70,12 +70,14 @@ public:
* @param stack Network stack as target for socket
* @return 0 on success, negative error code on failure
*/
virtual nsapi_error_t open(NetworkStack *stack) {
virtual nsapi_error_t open(NetworkStack *stack)
{
return tcp_socket.open(stack);
}
template <typename S>
nsapi_error_t open(S *stack) {
nsapi_error_t open(S *stack)
{
return open(nsapi_create_stack(stack));
}

26
features/netsocket/TLSSocketWrapper.cpp
View File

@ -50,7 +50,8 @@ TLSSocketWrapper::TLSSocketWrapper(Socket *transport, const char *hostname, cont
}
}
TLSSocketWrapper::~TLSSocketWrapper() {
TLSSocketWrapper::~TLSSocketWrapper()
{
if (_transport) {
close();
}
@ -139,7 +140,8 @@ nsapi_error_t TLSSocketWrapper::set_client_cert_key(const void *client_cert, siz
}
nsapi_error_t TLSSocketWrapper::do_handshake() {
nsapi_error_t TLSSocketWrapper::do_handshake()
{
nsapi_error_t _error;
const char DRBG_PERS[] = "mbed TLS client";
@ -228,7 +230,8 @@ nsapi_error_t TLSSocketWrapper::do_handshake() {
}
nsapi_error_t TLSSocketWrapper::send(const void *data, nsapi_size_t size) {
nsapi_error_t TLSSocketWrapper::send(const void *data, nsapi_size_t size)
{
int ret;
if (!_transport) {
@ -255,7 +258,8 @@ nsapi_size_or_error_t TLSSocketWrapper::sendto(const SocketAddress &, const void
return send(data, size);
}
nsapi_size_or_error_t TLSSocketWrapper::recv(void *data, nsapi_size_t size) {
nsapi_size_or_error_t TLSSocketWrapper::recv(void *data, nsapi_size_t size)
{
int ret;
if (!_transport) {
@ -287,7 +291,8 @@ nsapi_size_or_error_t TLSSocketWrapper::recvfrom(SocketAddress *address, void *d
return recv(data, size);
}
void TLSSocketWrapper::print_mbedtls_error(const char *name, int err) {
void TLSSocketWrapper::print_mbedtls_error(const char *name, int err)
{
#ifdef MBEDTLS_ERROR_C
char *buf = new char[128];
mbedtls_strerror(err, buf, 128);
@ -329,10 +334,9 @@ int TLSSocketWrapper::my_verify(void *data, mbedtls_x509_crt *crt, int depth, ui
mbedtls_x509_crt_info(buf, buf_size - 1, " ", crt);
tr_debug("%s", buf);
if (*flags == 0)
if (*flags == 0) {
tr_info("No verification issue for this certificate\n");
else
{
} else {
mbedtls_x509_crt_verify_info(buf, buf_size, " ! ", *flags);
tr_info("%s\n", buf);
}
@ -345,7 +349,8 @@ int TLSSocketWrapper::my_verify(void *data, mbedtls_x509_crt *crt, int depth, ui
#endif /* MBED_CONF_TLS_SOCKET_DEBUG_LEVEL > 0 */
int TLSSocketWrapper::ssl_recv(void *ctx, unsigned char *buf, size_t len) {
int TLSSocketWrapper::ssl_recv(void *ctx, unsigned char *buf, size_t len)
{
int recv;
TLSSocketWrapper *my = static_cast<TLSSocketWrapper *>(ctx);
@ -365,7 +370,8 @@ int TLSSocketWrapper::ssl_recv(void *ctx, unsigned char *buf, size_t len) {
return recv;
}
int TLSSocketWrapper::ssl_send(void *ctx, const unsigned char *buf, size_t len) {
int TLSSocketWrapper::ssl_send(void *ctx, const unsigned char *buf, size_t len)
{
int size = -1;
TLSSocketWrapper *my = static_cast<TLSSocketWrapper *>(ctx);

7
features/netsocket/cellular/generic_modem_driver/PPPCellularInterface.cpp
View File

@ -159,7 +159,9 @@ static nsapi_error_t do_sim_pin_check(ATCmdParser *at, const char *pin)
success = at->send("AT+CLCK=\"SC\",0,\"%s\"", pin) && at->recv("OK");
}
if (success) return NSAPI_ERROR_OK;
if (success) {
return NSAPI_ERROR_OK;
}
return NSAPI_ERROR_AUTH_FAILURE;
}
@ -444,7 +446,8 @@ nsapi_error_t PPPCellularInterface::initialize_sim_card()
return nsapi_error;
}
void PPPCellularInterface::set_sim_pin(const char *pin) {
void PPPCellularInterface::set_sim_pin(const char *pin)
{
/* overwrite the default pin by user provided pin */
_pin = pin;
}

3
features/netsocket/cellular/generic_modem_driver/TESTS/unit_tests/default/main.cpp
View File

@ -229,7 +229,8 @@ Case cases[] = { Case("UDP echo test", test_udp_echo),
Case("TCP async echo test", test_tcp_echo_async),
#endif
Case("Connect with credentials", test_connect_credentials),
Case("Connect with preset credentials", test_connect_preset_credentials) };
Case("Connect with preset credentials", test_connect_preset_credentials)
};
Specification specification(test_setup, cases);

9
features/storage/TESTS/blockdevice/heap_block_device/main.cpp
View File

@ -45,7 +45,8 @@ const struct {
// Simple test that read/writes random set of blocks
void test_read_write() {
void test_read_write()
{
uint8_t *dummy = new (std::nothrow) uint8_t[TEST_BLOCK_DEVICE_SIZE];
TEST_SKIP_UNLESS_MESSAGE(dummy, "Not enough memory for test");
delete[] dummy;
@ -155,7 +156,8 @@ end:
// Test setup
utest::v1::status_t test_setup(const size_t number_of_cases) {
utest::v1::status_t test_setup(const size_t number_of_cases)
{
GREENTEA_SETUP(30, "default_auto");
return verbose_test_setup_handler(number_of_cases);
}
@ -166,6 +168,7 @@ Case cases[] = {
Specification specification(test_setup, cases);
int main() {
int main()
{
return !Harness::run(specification);
}

6
features/storage/TESTS/blockdevice/mbr_block_device/main.cpp
View File

@ -232,7 +232,8 @@ end:
// Test setup
utest::v1::status_t test_setup(const size_t number_of_cases) {
utest::v1::status_t test_setup(const size_t number_of_cases)
{
GREENTEA_SETUP(10, "default_auto");
return verbose_test_setup_handler(number_of_cases);
}
@ -245,6 +246,7 @@ Case cases[] = {
Specification specification(test_setup, cases);
int main() {
int main()
{
return !Harness::run(specification);
}

15
features/storage/TESTS/blockdevice/util_block_device/main.cpp
View File

@ -36,7 +36,8 @@ using namespace utest::v1;
// Simple test which read/writes blocks on a sliced block device
void test_slicing() {
void test_slicing()
{
uint8_t *dummy = new (std::nothrow) uint8_t[BLOCK_COUNT * BLOCK_SIZE];
TEST_SKIP_UNLESS_MESSAGE(dummy, "Not enough memory for test");
delete[] dummy;
@ -141,7 +142,8 @@ end:
}
// Simple test which read/writes blocks on a chain of block devices
void test_chaining() {
void test_chaining()
{
uint8_t *dummy = new (std::nothrow) uint8_t[BLOCK_COUNT * BLOCK_SIZE];
TEST_SKIP_UNLESS_MESSAGE(dummy, "Not enough memory for test");
delete[] dummy;
@ -211,7 +213,8 @@ end:
}
// Simple test which read/writes blocks on a chain of block devices
void test_profiling() {
void test_profiling()
{
uint8_t *dummy = new (std::nothrow) uint8_t[BLOCK_COUNT * BLOCK_SIZE];
TEST_SKIP_UNLESS_MESSAGE(dummy, "Not enough memory for test");
delete[] dummy;
@ -287,7 +290,8 @@ end:
// Test setup
utest::v1::status_t test_setup(const size_t number_of_cases) {
utest::v1::status_t test_setup(const size_t number_of_cases)
{
GREENTEA_SETUP(10, "default_auto");
return verbose_test_setup_handler(number_of_cases);
}
@ -300,6 +304,7 @@ Case cases[] = {
Specification specification(test_setup, cases);
int main() {
int main()
{
return !Harness::run(specification);
}

15
features/storage/TESTS/filesystem/fat_filesystem/main.cpp
View File

@ -35,7 +35,8 @@ HeapBlockDevice bd(128*BLOCK_SIZE, BLOCK_SIZE);
// Test formatting
void test_format() {
void test_format()
{
int err = FATFileSystem::format(&bd);
TEST_ASSERT_EQUAL(0, err);
}
@ -43,7 +44,8 @@ void test_format() {
// Simple test for reading/writing files
template <ssize_t TEST_SIZE>
void test_read_write() {
void test_read_write()
{
FATFileSystem fs("fat");
int err = fs.mount(&bd);
@ -86,7 +88,8 @@ void test_read_write() {
// Simple test for iterating dir entries
void test_read_dir() {
void test_read_dir()
{
FATFileSystem fs("fat");
int err = fs.mount(&bd);
@ -147,7 +150,8 @@ void test_read_dir() {
// Test setup
utest::v1::status_t test_setup(const size_t number_of_cases) {
utest::v1::status_t test_setup(const size_t number_of_cases)
{
GREENTEA_SETUP(10, "default_auto");
return verbose_test_setup_handler(number_of_cases);
}
@ -161,6 +165,7 @@ Case cases[] = {
Specification specification(test_setup, cases);
int main() {
int main()
{
return !Harness::run(specification);
}

15
features/storage/TESTS/filesystem/multipart_fat_filesystem/main.cpp
View File

@ -37,7 +37,8 @@ HeapBlockDevice bd(BLOCK_COUNT*BLOCK_SIZE, BLOCK_SIZE);
// Test formatting and partitioning
void test_format() {
void test_format()
{
// Create two partitions splitting device in ~half
int err = MBRBlockDevice::partition(&bd, 1, 0x83, 0, (BLOCK_COUNT / 2) * BLOCK_SIZE);
TEST_ASSERT_EQUAL(0, err);
@ -72,7 +73,8 @@ void test_format() {
// Simple multipartition test for reading/writing files
template <ssize_t TEST_SIZE>
void test_read_write() {
void test_read_write()
{
// Load both partitions
MBRBlockDevice part1(&bd, 1);
int err = part1.init();
@ -163,7 +165,8 @@ void test_read_write() {
TEST_ASSERT_EQUAL(0, err);
}
void test_single_mbr() {
void test_single_mbr()
{
int err = bd.init();
TEST_ASSERT_EQUAL(0, err);
@ -205,7 +208,8 @@ void test_single_mbr() {
// Test setup
utest::v1::status_t test_setup(const size_t number_of_cases) {
utest::v1::status_t test_setup(const size_t number_of_cases)
{
GREENTEA_SETUP(10, "default_auto");
return verbose_test_setup_handler(number_of_cases);
}
@ -219,6 +223,7 @@ Case cases[] = {
Specification specification(test_setup, cases);
int main() {
int main()
{
return !Harness::run(specification);
}

3
features/storage/blockdevice/BlockDevice.h
View File

@ -40,8 +40,7 @@ typedef uint64_t bd_size_t;
/** A hardware device capable of writing and reading blocks
*/
class BlockDevice
{
class BlockDevice {
public:
/** Return the default block device

3
features/storage/blockdevice/ExhaustibleBlockDevice.h
View File

@ -31,8 +31,7 @@
* after a configurable number of cycles.
*
*/
class ExhaustibleBlockDevice : public BlockDevice
{
class ExhaustibleBlockDevice : public BlockDevice {
public:
/** Lifetime of the block device
*

3
features/storage/blockdevice/HeapBlockDevice.h
View File

@ -50,8 +50,7 @@
* }
* @endcode
*/
class HeapBlockDevice : public BlockDevice
{
class HeapBlockDevice : public BlockDevice {
public:
/** Lifetime of the memory block device

3
features/storage/blockdevice/MBRBlockDevice.h
View File

@ -87,8 +87,7 @@ enum {
* - At most 4 partitions are supported
* - Extended partitions are currently not supported and will error during init
*/
class MBRBlockDevice : public BlockDevice
{
class MBRBlockDevice : public BlockDevice {
public:
/** Format the MBR to contain the following partition
*

3
features/storage/blockdevice/ObservingBlockDevice.h
View File

@ -27,8 +27,7 @@
#include "platform/Callback.h"
class ObservingBlockDevice : public BlockDevice
{
class ObservingBlockDevice : public BlockDevice {
public:
/** Lifetime of the block device

3
features/storage/blockdevice/ProfilingBlockDevice.h
View File

@ -43,8 +43,7 @@
* printf("erase count: %lld\n", profiler.get_erase_count());
* @endcode
*/
class ProfilingBlockDevice : public BlockDevice
{
class ProfilingBlockDevice : public BlockDevice {
public:
/** Lifetime of the memory block device
*

3
features/storage/blockdevice/ReadOnlyBlockDevice.h
View File

@ -26,8 +26,7 @@
#include "PlatformMutex.h"
class ReadOnlyBlockDevice : public BlockDevice
{
class ReadOnlyBlockDevice : public BlockDevice {
public:
/** Lifetime of the block device

3
features/storage/blockdevice/SlicingBlockDevice.h
View File

@ -45,8 +45,7 @@
* SlicingBlockDevice slice3(&mem, 16*512, -16*512);
* @endcode
*/
class SlicingBlockDevice : public BlockDevice
{
class SlicingBlockDevice : public BlockDevice {
public:
/** Lifetime of the memory block device
*

6
features/storage/filesystem/FileSystem.cpp
View File

@ -139,7 +139,8 @@ size_t FileSystem::dir_size(fs_dir_t dir)
template <typename F>
class Managed : public F {
public:
virtual int close() {
virtual int close()
{
int err = F::close();
delete this;
return err;
@ -159,7 +160,8 @@ int FileSystem::open(FileHandle **file, const char *path, int flags)
return 0;
}
int FileSystem::open(DirHandle **dir, const char *path) {
int FileSystem::open(DirHandle **dir, const char *path)
{
Dir *d = new Managed<Dir>;
int err = d->open(this, path);
if (err) {

3
features/storage/filesystem/fat/FATFileSystem.cpp
View File

@ -280,7 +280,8 @@ DRESULT disk_ioctl(BYTE pdrv, BYTE cmd, void *buff)
// Filesystem implementation (See FATFilySystem.h)
FATFileSystem::FATFileSystem(const char *name, BlockDevice *bd)
: FileSystem(name), _id(-1) {
: FileSystem(name), _id(-1)
{
if (bd) {
mount(bd);
}

78
features/storage/filesystem/littlefs/LittleFileSystem.cpp
View File

@ -33,17 +33,28 @@ extern "C" void lfs_crc(uint32_t *crc, const void *buffer, size_t size)
static int lfs_toerror(int err)
{
switch (err) {
case LFS_ERR_OK: return 0;
case LFS_ERR_IO: return -EIO;
case LFS_ERR_NOENT: return -ENOENT;
case LFS_ERR_EXIST: return -EEXIST;
case LFS_ERR_NOTDIR: return -ENOTDIR;
case LFS_ERR_ISDIR: return -EISDIR;
case LFS_ERR_INVAL: return -EINVAL;
case LFS_ERR_NOSPC: return -ENOSPC;
case LFS_ERR_NOMEM: return -ENOMEM;
case LFS_ERR_CORRUPT: return -EILSEQ;
default: return err;
case LFS_ERR_OK:
return 0;
case LFS_ERR_IO:
return -EIO;
case LFS_ERR_NOENT:
return -ENOENT;
case LFS_ERR_EXIST:
return -EEXIST;
case LFS_ERR_NOTDIR:
return -ENOTDIR;
case LFS_ERR_ISDIR:
return -EISDIR;
case LFS_ERR_INVAL:
return -EINVAL;
case LFS_ERR_NOSPC:
return -ENOSPC;
case LFS_ERR_NOMEM:
return -ENOMEM;
case LFS_ERR_CORRUPT:
return -EILSEQ;
default:
return err;
}
}
@ -62,10 +73,14 @@ static int lfs_fromflags(int flags)
static int lfs_fromwhence(int whence)
{
switch (whence) {
case SEEK_SET: return LFS_SEEK_SET;
case SEEK_CUR: return LFS_SEEK_CUR;
case SEEK_END: return LFS_SEEK_END;
default: return whence;
case SEEK_SET:
return LFS_SEEK_SET;
case SEEK_CUR:
return LFS_SEEK_CUR;
case SEEK_END:
return LFS_SEEK_END;
default:
return whence;
}
}
@ -73,31 +88,39 @@ static int lfs_tomode(int type)
{
int mode = S_IRWXU | S_IRWXG | S_IRWXO;
switch (type) {
case LFS_TYPE_DIR: return mode | S_IFDIR;
case LFS_TYPE_REG: return mode | S_IFREG;
default: return 0;
case LFS_TYPE_DIR:
return mode | S_IFDIR;
case LFS_TYPE_REG:
return mode | S_IFREG;
default:
return 0;
}
}
static int lfs_totype(int type)
{
switch (type) {
case LFS_TYPE_DIR: return DT_DIR;
case LFS_TYPE_REG: return DT_REG;
default: return DT_UNKNOWN;
case LFS_TYPE_DIR:
return DT_DIR;
case LFS_TYPE_REG:
return DT_REG;
default:
return DT_UNKNOWN;
}
}
////// Block device operations //////
static int lfs_bd_read(const struct lfs_config *c, lfs_block_t block,
lfs_off_t off, void *buffer, lfs_size_t size) {
lfs_off_t off, void *buffer, lfs_size_t size)
{
BlockDevice *bd = (BlockDevice *)c->context;
return bd->read(buffer, (bd_addr_t)block * c->block_size + off, size);
}
static int lfs_bd_prog(const struct lfs_config *c, lfs_block_t block,
lfs_off_t off, const void *buffer, lfs_size_t size) {
lfs_off_t off, const void *buffer, lfs_size_t size)
{
BlockDevice *bd = (BlockDevice *)c->context;
return bd->program(buffer, (bd_addr_t)block * c->block_size + off, size);
}
@ -125,13 +148,15 @@ LittleFileSystem::LittleFileSystem(const char *name, BlockDevice *bd,
, _read_size(read_size)
, _prog_size(prog_size)
, _block_size(block_size)
, _lookahead(lookahead) {
, _lookahead(lookahead)
{
if (bd) {
mount(bd);
}
}
LittleFileSystem::~LittleFileSystem() {
LittleFileSystem::~LittleFileSystem()
{
// nop if unmounted
unmount();
}
@ -212,7 +237,8 @@ int LittleFileSystem::unmount()
int LittleFileSystem::format(BlockDevice *bd,
lfs_size_t read_size, lfs_size_t prog_size,
lfs_size_t block_size, lfs_size_t lookahead) {
lfs_size_t block_size, lfs_size_t lookahead)
{
LFS_INFO("format(%p, %ld, %ld, %ld, %ld)",
bd, read_size, prog_size, block_size, lookahead);
int err = bd->init();

3
features/storage/nvstore/TESTS/nvstore/functionality/main.cpp
View File

@ -666,7 +666,8 @@ clean:
utest::v1::status_t greentea_failure_handler(const Case *const source, const failure_t reason) {
utest::v1::status_t greentea_failure_handler(const Case *const source, const failure_t reason)
{
greentea_case_failure_abort_handler(source, reason);
return STATUS_CONTINUE;
}

9
features/storage/nvstore/source/nvstore.cpp
View File

@ -38,8 +38,7 @@ static const uint16_t master_record_key = 0xFFE;
static const uint16_t no_key = 0xFFF;
static const uint16_t last_reserved_key = master_record_key;
typedef struct
{
typedef struct {
uint16_t key_and_flags;
uint16_t size_and_owner;
uint32_t crc;
@ -88,10 +87,12 @@ static const uint8_t blank_flash_val = 0xFF;
#endif
NVStore::nvstore_area_data_t NVStore::initial_area_params[] = {{NVSTORE_AREA_1_ADDRESS, NVSTORE_AREA_1_SIZE},
{NVSTORE_AREA_2_ADDRESS, NVSTORE_AREA_2_SIZE}};
{NVSTORE_AREA_2_ADDRESS, NVSTORE_AREA_2_SIZE}
};
#else
NVStore::nvstore_area_data_t NVStore::initial_area_params[] = {{0, 0},
{0, 0}};
{0, 0}
};
#endif
typedef enum {

15
rtos/TARGET_CORTEX/TOOLCHAIN_ARM_STD/mbed_boot_arm_std.c
View File

@ -113,7 +113,8 @@ static osThreadId_t os_libspace_id[OS_THREAD_LIBSPACE_NUM] \
__attribute__((section(".bss.os.libspace")));
// Check if Kernel has been started
static uint32_t os_kernel_is_active (void) {
static uint32_t os_kernel_is_active(void)
{
static uint8_t os_kernel_active = 0U;
if (os_kernel_active == 0U) {
@ -125,7 +126,8 @@ static uint32_t os_kernel_is_active (void) {
}
// Provide libspace for current thread
void *__user_perthread_libspace (void) {
void *__user_perthread_libspace(void)
{
osThreadId_t id;
uint32_t n;
@ -218,21 +220,24 @@ __USED int _mutex_initialize(mutex *m)
}
/* Acquire mutex */
__USED void _mutex_acquire(mutex *m) {
__USED void _mutex_acquire(mutex *m)
{
if (os_kernel_is_active() != 0U) {
(void)osMutexAcquire(*m, osWaitForever);
}
}
/* Release mutex */
__USED void _mutex_release(mutex *m) {
__USED void _mutex_release(mutex *m)
{
if (os_kernel_is_active() != 0U) {
(void)osMutexRelease(*m);
}
}
/* Free mutex */
__USED void _mutex_free(mutex *m) {
__USED void _mutex_free(mutex *m)
{
mutex *slot = NULL;
core_util_critical_section_enter();
for (int i = 0; i < OS_MUTEX_STATIC_NUM; i++) {

3
rtos/TARGET_CORTEX/TOOLCHAIN_GCC_ARM/mbed_boot_gcc_arm.c
View File

@ -86,7 +86,8 @@ void mbed_toolchain_init()
}
extern int __real_main(void);
int __wrap_main(void) {
int __wrap_main(void)
{
/* For backwards compatibility */
return __real_main();
}