From f1734054fa3fbc40d16d57d867dbee7a3adbd23a Mon Sep 17 00:00:00 2001 From: David Horstmann Date: Mon, 20 Nov 2023 17:15:32 +0000 Subject: [PATCH] Rename "input_copy" -> "local_input" This helps to prevent confusion as it avoids overloading the word "copy" as both an action and an object. Signed-off-by: David Horstmann --- library/psa_crypto.c | 32 ++++++------ library/psa_crypto_core.h | 20 +++---- .../suites/test_suite_psa_crypto_memory.data | 20 +++---- .../test_suite_psa_crypto_memory.function | 52 +++++++++---------- 4 files changed, 62 insertions(+), 62 deletions(-) diff --git a/library/psa_crypto.c b/library/psa_crypto.c index bad55b1c65..b51b3b9398 100644 --- a/library/psa_crypto.c +++ b/library/psa_crypto.c @@ -8496,30 +8496,30 @@ psa_status_t psa_crypto_copy_output(const uint8_t *output_copy, size_t output_co return PSA_SUCCESS; } -psa_status_t psa_crypto_input_copy_alloc(const uint8_t *input, size_t input_len, - psa_crypto_input_copy_t *input_copy) +psa_status_t psa_crypto_local_input_alloc(const uint8_t *input, size_t input_len, + psa_crypto_local_input_t *local_input) { psa_status_t status; - input_copy->buffer = NULL; - input_copy->length = 0; + local_input->buffer = NULL; + local_input->length = 0; if (input_len == 0) { return PSA_SUCCESS; } - input_copy->buffer = mbedtls_calloc(input_len, 1); - if (input_copy->buffer == NULL) { + local_input->buffer = mbedtls_calloc(input_len, 1); + if (local_input->buffer == NULL) { /* Since we dealt with the zero-length case above, we know that * a NULL return value means a failure of allocation. */ return PSA_ERROR_INSUFFICIENT_MEMORY; } - /* From now on, we must free input_copy->buffer on error. */ + /* From now on, we must free local_input->buffer on error. */ - input_copy->length = input_len; + local_input->length = input_len; status = psa_crypto_copy_input(input, input_len, - input_copy->buffer, input_copy->length); + local_input->buffer, local_input->length); if (status != PSA_SUCCESS) { goto error; } @@ -8527,17 +8527,17 @@ psa_status_t psa_crypto_input_copy_alloc(const uint8_t *input, size_t input_len, return PSA_SUCCESS; error: - mbedtls_free(input_copy->buffer); - input_copy->buffer = NULL; - input_copy->length = 0; + mbedtls_free(local_input->buffer); + local_input->buffer = NULL; + local_input->length = 0; return status; } -void psa_crypto_input_copy_free(psa_crypto_input_copy_t *input_copy) +void psa_crypto_local_input_free(psa_crypto_local_input_t *local_input) { - mbedtls_free(input_copy->buffer); - input_copy->buffer = NULL; - input_copy->length = 0; + mbedtls_free(local_input->buffer); + local_input->buffer = NULL; + local_input->length = 0; } psa_status_t psa_crypto_output_copy_alloc(uint8_t *output, size_t output_len, diff --git a/library/psa_crypto_core.h b/library/psa_crypto_core.h index 21d4bf3786..ea34aab747 100644 --- a/library/psa_crypto_core.h +++ b/library/psa_crypto_core.h @@ -854,34 +854,34 @@ psa_status_t mbedtls_psa_verify_hash_complete( psa_status_t mbedtls_psa_verify_hash_abort( mbedtls_psa_verify_hash_interruptible_operation_t *operation); -typedef struct psa_crypto_input_copy_s { +typedef struct psa_crypto_local_input_s { uint8_t *buffer; size_t length; -} psa_crypto_input_copy_t; +} psa_crypto_local_input_t; -#define PSA_CRYPTO_INPUT_COPY_INIT { NULL, 0 } +#define PSA_CRYPTO_LOCAL_INPUT_INIT { NULL, 0 } /** Allocate a local copy of an input buffer. * * \param[in] input Pointer to input buffer. * \param[in] input_len Length of the input buffer. - * \param[out] input_copy Pointer to a psa_crypto_input_copy_t struct to - * populate with the input copy. + * \param[out] local_input Pointer to a psa_crypto_local_input_t struct to + * populate with the local input copy. * \return #PSA_SUCCESS, if the buffer was successfully * copied. * \return #PSA_ERROR_INSUFFICIENT_MEMORY, if a copy of * the buffer cannot be allocated. */ -psa_status_t psa_crypto_input_copy_alloc(const uint8_t *input, size_t input_len, - psa_crypto_input_copy_t *input_copy); +psa_status_t psa_crypto_local_input_alloc(const uint8_t *input, size_t input_len, + psa_crypto_local_input_t *local_input); /** Free a local copy of an input buffer. * - * \param[in] input_copy Pointer to a psa_crypto_input_copy_t struct + * \param[in] local_input Pointer to a psa_crypto_local_input_t struct * populated by a previous call to - * psa_crypto_input_copy_alloc(). + * psa_crypto_local_input_alloc(). */ -void psa_crypto_input_copy_free(psa_crypto_input_copy_t *input_copy); +void psa_crypto_local_input_free(psa_crypto_local_input_t *local_input); typedef struct psa_crypto_output_copy_s { uint8_t *original; diff --git a/tests/suites/test_suite_psa_crypto_memory.data b/tests/suites/test_suite_psa_crypto_memory.data index 94fb407f9b..d758bda0d4 100644 --- a/tests/suites/test_suite_psa_crypto_memory.data +++ b/tests/suites/test_suite_psa_crypto_memory.data @@ -28,20 +28,20 @@ copy_output:0:10:PSA_SUCCESS PSA output buffer copy: zero-length both buffers copy_output:0:0:PSA_SUCCESS -PSA crypto input copy alloc -input_copy_alloc:200:PSA_SUCCESS +PSA crypto local input alloc +local_input_alloc:200:PSA_SUCCESS -PSA crypto input copy alloc, NULL buffer -input_copy_alloc:0:PSA_SUCCESS +PSA crypto local input alloc, NULL buffer +local_input_alloc:0:PSA_SUCCESS -PSA crypto input copy free -input_copy_free:200 +PSA crypto local input free +local_input_free:200 -PSA crypto input copy free, NULL buffer -input_copy_free:0 +PSA crypto local input free, NULL buffer +local_input_free:0 -PSA crypto input copy round-trip -input_copy_round_trip +PSA crypto local input round-trip +local_input_round_trip PSA crypto output copy alloc output_copy_alloc:200:PSA_SUCCESS diff --git a/tests/suites/test_suite_psa_crypto_memory.function b/tests/suites/test_suite_psa_crypto_memory.function index 8421604e9d..3d606bbb66 100644 --- a/tests/suites/test_suite_psa_crypto_memory.function +++ b/tests/suites/test_suite_psa_crypto_memory.function @@ -79,73 +79,73 @@ exit: /* END_CASE */ /* BEGIN_CASE */ -void input_copy_alloc(int input_len, psa_status_t exp_status) +void local_input_alloc(int input_len, psa_status_t exp_status) { uint8_t *input = NULL; - psa_crypto_input_copy_t input_copy; + psa_crypto_local_input_t local_input; psa_status_t status; - input_copy.buffer = NULL; + local_input.buffer = NULL; TEST_CALLOC(input, input_len); fill_buffer_pattern(input, input_len); - status = psa_crypto_input_copy_alloc(input, input_len, &input_copy); + status = psa_crypto_local_input_alloc(input, input_len, &local_input); TEST_EQUAL(status, exp_status); if (exp_status == PSA_SUCCESS) { if (input_len != 0) { - TEST_ASSERT(input_copy.buffer != input); + TEST_ASSERT(local_input.buffer != input); } TEST_MEMORY_COMPARE(input, input_len, - input_copy.buffer, input_copy.length); + local_input.buffer, local_input.length); } exit: - mbedtls_free(input_copy.buffer); + mbedtls_free(local_input.buffer); mbedtls_free(input); } /* END_CASE */ /* BEGIN_CASE */ -void input_copy_free(int input_len) +void local_input_free(int input_len) { - psa_crypto_input_copy_t input_copy; + psa_crypto_local_input_t local_input; - input_copy.buffer = NULL; - input_copy.length = input_len; - TEST_CALLOC(input_copy.buffer, input_copy.length); + local_input.buffer = NULL; + local_input.length = input_len; + TEST_CALLOC(local_input.buffer, local_input.length); - psa_crypto_input_copy_free(&input_copy); + psa_crypto_local_input_free(&local_input); - TEST_ASSERT(input_copy.buffer == NULL); - TEST_EQUAL(input_copy.length, 0); + TEST_ASSERT(local_input.buffer == NULL); + TEST_EQUAL(local_input.length, 0); exit: - mbedtls_free(input_copy.buffer); - input_copy.buffer = NULL; - input_copy.length = 0; + mbedtls_free(local_input.buffer); + local_input.buffer = NULL; + local_input.length = 0; } /* END_CASE */ /* BEGIN_CASE */ -void input_copy_round_trip() +void local_input_round_trip() { - psa_crypto_input_copy_t input_copy; + psa_crypto_local_input_t local_input; uint8_t input[200]; psa_status_t status; fill_buffer_pattern(input, sizeof(input)); - status = psa_crypto_input_copy_alloc(input, sizeof(input), &input_copy); + status = psa_crypto_local_input_alloc(input, sizeof(input), &local_input); TEST_EQUAL(status, PSA_SUCCESS); - TEST_MEMORY_COMPARE(input_copy.buffer, input_copy.length, + TEST_MEMORY_COMPARE(local_input.buffer, local_input.length, input, sizeof(input)); - TEST_ASSERT(input_copy.buffer != input); + TEST_ASSERT(local_input.buffer != input); - psa_crypto_input_copy_free(&input_copy); - TEST_ASSERT(input_copy.buffer == NULL); - TEST_EQUAL(input_copy.length, 0); + psa_crypto_local_input_free(&local_input); + TEST_ASSERT(local_input.buffer == NULL); + TEST_EQUAL(local_input.length, 0); } /* END_CASE */