Switch to the new code style
Signed-off-by: Gilles Peskine <Gilles.Peskine@arm.com>
diff --git a/library/psa_crypto_se.c b/library/psa_crypto_se.c
index 87d2634..b660393 100644
--- a/library/psa_crypto_se.c
+++ b/library/psa_crypto_se.c
@@ -48,19 +48,16 @@
/* This structure is identical to psa_drv_se_context_t declared in
* `crypto_se_driver.h`, except that some parts are writable here
* (non-const, or pointer to non-const). */
-typedef struct
-{
+typedef struct {
void *persistent_data;
size_t persistent_data_size;
uintptr_t transient_data;
} psa_drv_se_internal_context_t;
-struct psa_se_drv_table_entry_s
-{
+struct psa_se_drv_table_entry_s {
psa_key_location_t location;
const psa_drv_se_t *methods;
- union
- {
+ union {
psa_drv_se_internal_context_t internal;
psa_drv_se_context_t context;
} u;
@@ -69,46 +66,49 @@
static psa_se_drv_table_entry_t driver_table[PSA_MAX_SE_DRIVERS];
psa_se_drv_table_entry_t *psa_get_se_driver_entry(
- psa_key_lifetime_t lifetime )
+ psa_key_lifetime_t lifetime)
{
size_t i;
- psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION( lifetime );
+ psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(lifetime);
/* In the driver table, location=0 means an entry that isn't used.
* No driver has a location of 0 because it's a reserved value
* (which designates transparent keys). Make sure we never return
* a driver entry for location 0. */
- if( location == 0 )
- return( NULL );
- for( i = 0; i < PSA_MAX_SE_DRIVERS; i++ )
- {
- if( driver_table[i].location == location )
- return( &driver_table[i] );
+ if (location == 0) {
+ return NULL;
}
- return( NULL );
+ for (i = 0; i < PSA_MAX_SE_DRIVERS; i++) {
+ if (driver_table[i].location == location) {
+ return &driver_table[i];
+ }
+ }
+ return NULL;
}
const psa_drv_se_t *psa_get_se_driver_methods(
- const psa_se_drv_table_entry_t *driver )
+ const psa_se_drv_table_entry_t *driver)
{
- return( driver->methods );
+ return driver->methods;
}
psa_drv_se_context_t *psa_get_se_driver_context(
- psa_se_drv_table_entry_t *driver )
+ psa_se_drv_table_entry_t *driver)
{
- return( &driver->u.context );
+ return &driver->u.context;
}
-int psa_get_se_driver( psa_key_lifetime_t lifetime,
- const psa_drv_se_t **p_methods,
- psa_drv_se_context_t **p_drv_context)
+int psa_get_se_driver(psa_key_lifetime_t lifetime,
+ const psa_drv_se_t **p_methods,
+ psa_drv_se_context_t **p_drv_context)
{
- psa_se_drv_table_entry_t *driver = psa_get_se_driver_entry( lifetime );
- if( p_methods != NULL )
- *p_methods = ( driver ? driver->methods : NULL );
- if( p_drv_context != NULL )
- *p_drv_context = ( driver ? &driver->u.context : NULL );
- return( driver != NULL );
+ psa_se_drv_table_entry_t *driver = psa_get_se_driver_entry(lifetime);
+ if (p_methods != NULL) {
+ *p_methods = (driver ? driver->methods : NULL);
+ }
+ if (p_drv_context != NULL) {
+ *p_drv_context = (driver ? &driver->u.context : NULL);
+ }
+ return driver != NULL;
}
@@ -119,32 +119,35 @@
static psa_status_t psa_get_se_driver_its_file_uid(
const psa_se_drv_table_entry_t *driver,
- psa_storage_uid_t *uid )
+ psa_storage_uid_t *uid)
{
- if( driver->location > PSA_MAX_SE_LOCATION )
- return( PSA_ERROR_NOT_SUPPORTED );
+ if (driver->location > PSA_MAX_SE_LOCATION) {
+ return PSA_ERROR_NOT_SUPPORTED;
+ }
#if SIZE_MAX > UINT32_MAX
/* ITS file sizes are limited to 32 bits. */
- if( driver->u.internal.persistent_data_size > UINT32_MAX )
- return( PSA_ERROR_NOT_SUPPORTED );
+ if (driver->u.internal.persistent_data_size > UINT32_MAX) {
+ return PSA_ERROR_NOT_SUPPORTED;
+ }
#endif
/* See the documentation of PSA_CRYPTO_SE_DRIVER_ITS_UID_BASE. */
*uid = PSA_CRYPTO_SE_DRIVER_ITS_UID_BASE + driver->location;
- return( PSA_SUCCESS );
+ return PSA_SUCCESS;
}
psa_status_t psa_load_se_persistent_data(
- const psa_se_drv_table_entry_t *driver )
+ const psa_se_drv_table_entry_t *driver)
{
psa_status_t status;
psa_storage_uid_t uid;
size_t length;
- status = psa_get_se_driver_its_file_uid( driver, &uid );
- if( status != PSA_SUCCESS )
- return( status );
+ status = psa_get_se_driver_its_file_uid(driver, &uid);
+ if (status != PSA_SUCCESS) {
+ return status;
+ }
/* Read the amount of persistent data that the driver requests.
* If the data in storage is larger, it is truncated. If the data
@@ -153,97 +156,98 @@
/* psa_get_se_driver_its_file_uid ensures that the size_t
* persistent_data_size is in range, but compilers don't know that,
* so cast to reassure them. */
- return( psa_its_get( uid, 0,
- (uint32_t) driver->u.internal.persistent_data_size,
- driver->u.internal.persistent_data,
- &length ) );
+ return psa_its_get(uid, 0,
+ (uint32_t) driver->u.internal.persistent_data_size,
+ driver->u.internal.persistent_data,
+ &length);
}
psa_status_t psa_save_se_persistent_data(
- const psa_se_drv_table_entry_t *driver )
+ const psa_se_drv_table_entry_t *driver)
{
psa_status_t status;
psa_storage_uid_t uid;
- status = psa_get_se_driver_its_file_uid( driver, &uid );
- if( status != PSA_SUCCESS )
- return( status );
+ status = psa_get_se_driver_its_file_uid(driver, &uid);
+ if (status != PSA_SUCCESS) {
+ return status;
+ }
/* psa_get_se_driver_its_file_uid ensures that the size_t
* persistent_data_size is in range, but compilers don't know that,
* so cast to reassure them. */
- return( psa_its_set( uid,
- (uint32_t) driver->u.internal.persistent_data_size,
- driver->u.internal.persistent_data,
- 0 ) );
+ return psa_its_set(uid,
+ (uint32_t) driver->u.internal.persistent_data_size,
+ driver->u.internal.persistent_data,
+ 0);
}
-psa_status_t psa_destroy_se_persistent_data( psa_key_location_t location )
+psa_status_t psa_destroy_se_persistent_data(psa_key_location_t location)
{
psa_storage_uid_t uid;
- if( location > PSA_MAX_SE_LOCATION )
- return( PSA_ERROR_NOT_SUPPORTED );
+ if (location > PSA_MAX_SE_LOCATION) {
+ return PSA_ERROR_NOT_SUPPORTED;
+ }
uid = PSA_CRYPTO_SE_DRIVER_ITS_UID_BASE + location;
- return( psa_its_remove( uid ) );
+ return psa_its_remove(uid);
}
psa_status_t psa_find_se_slot_for_key(
const psa_key_attributes_t *attributes,
psa_key_creation_method_t method,
psa_se_drv_table_entry_t *driver,
- psa_key_slot_number_t *slot_number )
+ psa_key_slot_number_t *slot_number)
{
psa_status_t status;
psa_key_location_t key_location =
- PSA_KEY_LIFETIME_GET_LOCATION( psa_get_key_lifetime( attributes ) );
+ PSA_KEY_LIFETIME_GET_LOCATION(psa_get_key_lifetime(attributes));
/* If the location is wrong, it's a bug in the library. */
- if( driver->location != key_location )
- return( PSA_ERROR_CORRUPTION_DETECTED );
+ if (driver->location != key_location) {
+ return PSA_ERROR_CORRUPTION_DETECTED;
+ }
/* If the driver doesn't support key creation in any way, give up now. */
- if( driver->methods->key_management == NULL )
- return( PSA_ERROR_NOT_SUPPORTED );
+ if (driver->methods->key_management == NULL) {
+ return PSA_ERROR_NOT_SUPPORTED;
+ }
- if( psa_get_key_slot_number( attributes, slot_number ) == PSA_SUCCESS )
- {
+ if (psa_get_key_slot_number(attributes, slot_number) == PSA_SUCCESS) {
/* The application wants to use a specific slot. Allow it if
* the driver supports it. On a system with isolation,
* the crypto service must check that the application is
* permitted to request this slot. */
psa_drv_se_validate_slot_number_t p_validate_slot_number =
driver->methods->key_management->p_validate_slot_number;
- if( p_validate_slot_number == NULL )
- return( PSA_ERROR_NOT_SUPPORTED );
- status = p_validate_slot_number( &driver->u.context,
- driver->u.internal.persistent_data,
- attributes, method,
- *slot_number );
- }
- else if( method == PSA_KEY_CREATION_REGISTER )
- {
+ if (p_validate_slot_number == NULL) {
+ return PSA_ERROR_NOT_SUPPORTED;
+ }
+ status = p_validate_slot_number(&driver->u.context,
+ driver->u.internal.persistent_data,
+ attributes, method,
+ *slot_number);
+ } else if (method == PSA_KEY_CREATION_REGISTER) {
/* The application didn't specify a slot number. This doesn't
* make sense when registering a slot. */
- return( PSA_ERROR_INVALID_ARGUMENT );
- }
- else
- {
+ return PSA_ERROR_INVALID_ARGUMENT;
+ } else {
/* The application didn't tell us which slot to use. Let the driver
* choose. This is the normal case. */
psa_drv_se_allocate_key_t p_allocate =
driver->methods->key_management->p_allocate;
- if( p_allocate == NULL )
- return( PSA_ERROR_NOT_SUPPORTED );
- status = p_allocate( &driver->u.context,
- driver->u.internal.persistent_data,
- attributes, method,
- slot_number );
+ if (p_allocate == NULL) {
+ return PSA_ERROR_NOT_SUPPORTED;
+ }
+ status = p_allocate(&driver->u.context,
+ driver->u.internal.persistent_data,
+ attributes, method,
+ slot_number);
}
- return( status );
+ return status;
}
-psa_status_t psa_destroy_se_key( psa_se_drv_table_entry_t *driver,
- psa_key_slot_number_t slot_number )
+psa_status_t psa_destroy_se_key(psa_se_drv_table_entry_t *driver,
+ psa_key_slot_number_t slot_number)
{
psa_status_t status;
psa_status_t storage_status;
@@ -255,40 +259,42 @@
* locked in a read-only state: we can use the keys but not
* destroy them. Hence, if the driver doesn't support destroying
* keys, it's really a lack of permission. */
- if( driver->methods->key_management == NULL ||
- driver->methods->key_management->p_destroy == NULL )
- return( PSA_ERROR_NOT_PERMITTED );
+ if (driver->methods->key_management == NULL ||
+ driver->methods->key_management->p_destroy == NULL) {
+ return PSA_ERROR_NOT_PERMITTED;
+ }
status = driver->methods->key_management->p_destroy(
&driver->u.context,
driver->u.internal.persistent_data,
- slot_number );
- storage_status = psa_save_se_persistent_data( driver );
- return( status == PSA_SUCCESS ? storage_status : status );
+ slot_number);
+ storage_status = psa_save_se_persistent_data(driver);
+ return status == PSA_SUCCESS ? storage_status : status;
}
-psa_status_t psa_init_all_se_drivers( void )
+psa_status_t psa_init_all_se_drivers(void)
{
size_t i;
- for( i = 0; i < PSA_MAX_SE_DRIVERS; i++ )
- {
+ for (i = 0; i < PSA_MAX_SE_DRIVERS; i++) {
psa_se_drv_table_entry_t *driver = &driver_table[i];
- if( driver->location == 0 )
+ if (driver->location == 0) {
continue; /* skipping unused entry */
- const psa_drv_se_t *methods = psa_get_se_driver_methods( driver );
- if( methods->p_init != NULL )
- {
+ }
+ const psa_drv_se_t *methods = psa_get_se_driver_methods(driver);
+ if (methods->p_init != NULL) {
psa_status_t status = methods->p_init(
&driver->u.context,
driver->u.internal.persistent_data,
- driver->location );
- if( status != PSA_SUCCESS )
- return( status );
- status = psa_save_se_persistent_data( driver );
- if( status != PSA_SUCCESS )
- return( status );
+ driver->location);
+ if (status != PSA_SUCCESS) {
+ return status;
+ }
+ status = psa_save_se_persistent_data(driver);
+ if (status != PSA_SUCCESS) {
+ return status;
+ }
}
}
- return( PSA_SUCCESS );
+ return PSA_SUCCESS;
}
@@ -304,70 +310,74 @@
size_t i;
psa_status_t status;
- if( methods->hal_version != PSA_DRV_SE_HAL_VERSION )
- return( PSA_ERROR_NOT_SUPPORTED );
+ if (methods->hal_version != PSA_DRV_SE_HAL_VERSION) {
+ return PSA_ERROR_NOT_SUPPORTED;
+ }
/* Driver table entries are 0-initialized. 0 is not a valid driver
* location because it means a transparent key. */
#if defined(static_assert)
- static_assert( PSA_KEY_LOCATION_LOCAL_STORAGE == 0,
- "Secure element support requires 0 to mean a local key" );
+ static_assert(PSA_KEY_LOCATION_LOCAL_STORAGE == 0,
+ "Secure element support requires 0 to mean a local key");
#endif
- if( location == PSA_KEY_LOCATION_LOCAL_STORAGE )
- return( PSA_ERROR_INVALID_ARGUMENT );
- if( location > PSA_MAX_SE_LOCATION )
- return( PSA_ERROR_NOT_SUPPORTED );
+ if (location == PSA_KEY_LOCATION_LOCAL_STORAGE) {
+ return PSA_ERROR_INVALID_ARGUMENT;
+ }
+ if (location > PSA_MAX_SE_LOCATION) {
+ return PSA_ERROR_NOT_SUPPORTED;
+ }
- for( i = 0; i < PSA_MAX_SE_DRIVERS; i++ )
- {
- if( driver_table[i].location == 0 )
+ for (i = 0; i < PSA_MAX_SE_DRIVERS; i++) {
+ if (driver_table[i].location == 0) {
break;
+ }
/* Check that location isn't already in use up to the first free
* entry. Since entries are created in order and never deleted,
* there can't be a used entry after the first free entry. */
- if( driver_table[i].location == location )
- return( PSA_ERROR_ALREADY_EXISTS );
+ if (driver_table[i].location == location) {
+ return PSA_ERROR_ALREADY_EXISTS;
+ }
}
- if( i == PSA_MAX_SE_DRIVERS )
- return( PSA_ERROR_INSUFFICIENT_MEMORY );
+ if (i == PSA_MAX_SE_DRIVERS) {
+ return PSA_ERROR_INSUFFICIENT_MEMORY;
+ }
driver_table[i].location = location;
driver_table[i].methods = methods;
driver_table[i].u.internal.persistent_data_size =
methods->persistent_data_size;
- if( methods->persistent_data_size != 0 )
- {
+ if (methods->persistent_data_size != 0) {
driver_table[i].u.internal.persistent_data =
- mbedtls_calloc( 1, methods->persistent_data_size );
- if( driver_table[i].u.internal.persistent_data == NULL )
- {
+ mbedtls_calloc(1, methods->persistent_data_size);
+ if (driver_table[i].u.internal.persistent_data == NULL) {
status = PSA_ERROR_INSUFFICIENT_MEMORY;
goto error;
}
/* Load the driver's persistent data. On first use, the persistent
* data does not exist in storage, and is initialized to
* all-bits-zero by the calloc call just above. */
- status = psa_load_se_persistent_data( &driver_table[i] );
- if( status != PSA_SUCCESS && status != PSA_ERROR_DOES_NOT_EXIST )
+ status = psa_load_se_persistent_data(&driver_table[i]);
+ if (status != PSA_SUCCESS && status != PSA_ERROR_DOES_NOT_EXIST) {
goto error;
+ }
}
- return( PSA_SUCCESS );
+ return PSA_SUCCESS;
error:
- memset( &driver_table[i], 0, sizeof( driver_table[i] ) );
- return( status );
+ memset(&driver_table[i], 0, sizeof(driver_table[i]));
+ return status;
}
-void psa_unregister_all_se_drivers( void )
+void psa_unregister_all_se_drivers(void)
{
size_t i;
- for( i = 0; i < PSA_MAX_SE_DRIVERS; i++ )
- {
- if( driver_table[i].u.internal.persistent_data != NULL )
- mbedtls_free( driver_table[i].u.internal.persistent_data );
+ for (i = 0; i < PSA_MAX_SE_DRIVERS; i++) {
+ if (driver_table[i].u.internal.persistent_data != NULL) {
+ mbedtls_free(driver_table[i].u.internal.persistent_data);
+ }
}
- memset( driver_table, 0, sizeof( driver_table ) );
+ memset(driver_table, 0, sizeof(driver_table));
}