Switch to the new code style
Signed-off-by: Gilles Peskine <Gilles.Peskine@arm.com>
diff --git a/tests/suites/test_suite_asn1write.function b/tests/suites/test_suite_asn1write.function
index 4ed8644..ce0d0f3 100644
--- a/tests/suites/test_suite_asn1write.function
+++ b/tests/suites/test_suite_asn1write.function
@@ -4,8 +4,7 @@
#define GUARD_LEN 4
#define GUARD_VAL 0x2a
-typedef struct
-{
+typedef struct {
unsigned char *output;
unsigned char *start;
unsigned char *end;
@@ -13,41 +12,38 @@
size_t size;
} generic_write_data_t;
-int generic_write_start_step( generic_write_data_t *data )
+int generic_write_start_step(generic_write_data_t *data)
{
- mbedtls_test_set_step( data->size );
- mbedtls_free( data->output );
+ mbedtls_test_set_step(data->size);
+ mbedtls_free(data->output);
data->output = NULL;
- ASSERT_ALLOC( data->output, data->size == 0 ? 1 : data->size );
+ ASSERT_ALLOC(data->output, data->size == 0 ? 1 : data->size);
data->end = data->output + data->size;
data->p = data->end;
data->start = data->end - data->size;
- return( 1 );
+ return 1;
exit:
- return( 0 );
+ return 0;
}
-int generic_write_finish_step( generic_write_data_t *data,
- const data_t *expected, int ret )
+int generic_write_finish_step(generic_write_data_t *data,
+ const data_t *expected, int ret)
{
int ok = 0;
- if( data->size < expected->len )
- {
- TEST_EQUAL( ret, MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
- }
- else
- {
- TEST_EQUAL( ret, data->end - data->p );
- TEST_ASSERT( data->p >= data->start );
- TEST_ASSERT( data->p <= data->end );
- ASSERT_COMPARE( data->p, (size_t)( data->end - data->p ),
- expected->x, expected->len );
+ if (data->size < expected->len) {
+ TEST_EQUAL(ret, MBEDTLS_ERR_ASN1_BUF_TOO_SMALL);
+ } else {
+ TEST_EQUAL(ret, data->end - data->p);
+ TEST_ASSERT(data->p >= data->start);
+ TEST_ASSERT(data->p <= data->end);
+ ASSERT_COMPARE(data->p, (size_t) (data->end - data->p),
+ expected->x, expected->len);
}
ok = 1;
exit:
- return( ok );
+ return ok;
}
/* END_HEADER */
@@ -58,206 +54,209 @@
*/
/* BEGIN_CASE */
-void mbedtls_asn1_write_null( data_t *expected )
+void mbedtls_asn1_write_null(data_t *expected)
{
generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
int ret;
- for( data.size = 0; data.size <= expected->len + 1; data.size++ )
- {
- if( ! generic_write_start_step( &data ) )
+ for (data.size = 0; data.size <= expected->len + 1; data.size++) {
+ if (!generic_write_start_step(&data)) {
goto exit;
- ret = mbedtls_asn1_write_null( &data.p, data.start );
- if( ! generic_write_finish_step( &data, expected, ret ) )
+ }
+ ret = mbedtls_asn1_write_null(&data.p, data.start);
+ if (!generic_write_finish_step(&data, expected, ret)) {
goto exit;
+ }
/* There's no parsing function for NULL. */
}
exit:
- mbedtls_free( data.output );
+ mbedtls_free(data.output);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_asn1_write_bool( int val, data_t *expected )
+void mbedtls_asn1_write_bool(int val, data_t *expected)
{
generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
int ret;
- for( data.size = 0; data.size <= expected->len + 1; data.size++ )
- {
- if( ! generic_write_start_step( &data ) )
+ for (data.size = 0; data.size <= expected->len + 1; data.size++) {
+ if (!generic_write_start_step(&data)) {
goto exit;
- ret = mbedtls_asn1_write_bool( &data.p, data.start, val );
- if( ! generic_write_finish_step( &data, expected, ret ) )
+ }
+ ret = mbedtls_asn1_write_bool(&data.p, data.start, val);
+ if (!generic_write_finish_step(&data, expected, ret)) {
goto exit;
+ }
#if defined(MBEDTLS_ASN1_PARSE_C)
- if( ret >= 0 )
- {
+ if (ret >= 0) {
int read = 0xdeadbeef;
- TEST_EQUAL( mbedtls_asn1_get_bool( &data.p, data.end, &read ), 0 );
- TEST_EQUAL( val, read );
+ TEST_EQUAL(mbedtls_asn1_get_bool(&data.p, data.end, &read), 0);
+ TEST_EQUAL(val, read);
}
#endif /* MBEDTLS_ASN1_PARSE_C */
}
exit:
- mbedtls_free( data.output );
+ mbedtls_free(data.output);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_asn1_write_int( int val, data_t *expected )
+void mbedtls_asn1_write_int(int val, data_t *expected)
{
generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
int ret;
- for( data.size = 0; data.size <= expected->len + 1; data.size++ )
- {
- if( ! generic_write_start_step( &data ) )
+ for (data.size = 0; data.size <= expected->len + 1; data.size++) {
+ if (!generic_write_start_step(&data)) {
goto exit;
- ret = mbedtls_asn1_write_int( &data.p, data.start, val );
- if( ! generic_write_finish_step( &data, expected, ret ) )
+ }
+ ret = mbedtls_asn1_write_int(&data.p, data.start, val);
+ if (!generic_write_finish_step(&data, expected, ret)) {
goto exit;
+ }
#if defined(MBEDTLS_ASN1_PARSE_C)
- if( ret >= 0 )
- {
+ if (ret >= 0) {
int read = 0xdeadbeef;
- TEST_EQUAL( mbedtls_asn1_get_int( &data.p, data.end, &read ), 0 );
- TEST_EQUAL( val, read );
+ TEST_EQUAL(mbedtls_asn1_get_int(&data.p, data.end, &read), 0);
+ TEST_EQUAL(val, read);
}
#endif /* MBEDTLS_ASN1_PARSE_C */
}
exit:
- mbedtls_free( data.output );
+ mbedtls_free(data.output);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_asn1_write_enum( int val, data_t *expected )
+void mbedtls_asn1_write_enum(int val, data_t *expected)
{
generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
int ret;
- for( data.size = 0; data.size <= expected->len + 1; data.size++ )
- {
- if( ! generic_write_start_step( &data ) )
+ for (data.size = 0; data.size <= expected->len + 1; data.size++) {
+ if (!generic_write_start_step(&data)) {
goto exit;
- ret = mbedtls_asn1_write_enum( &data.p, data.start, val );
- if( ! generic_write_finish_step( &data, expected, ret ) )
+ }
+ ret = mbedtls_asn1_write_enum(&data.p, data.start, val);
+ if (!generic_write_finish_step(&data, expected, ret)) {
goto exit;
+ }
#if defined(MBEDTLS_ASN1_PARSE_C)
- if( ret >= 0 )
- {
+ if (ret >= 0) {
int read = 0xdeadbeef;
- TEST_EQUAL( mbedtls_asn1_get_enum( &data.p, data.end, &read ), 0 );
- TEST_EQUAL( val, read );
+ TEST_EQUAL(mbedtls_asn1_get_enum(&data.p, data.end, &read), 0);
+ TEST_EQUAL(val, read);
}
#endif /* MBEDTLS_ASN1_PARSE_C */
}
exit:
- mbedtls_free( data.output );
+ mbedtls_free(data.output);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_BIGNUM_C */
-void mbedtls_asn1_write_mpi( data_t *val, data_t *expected )
+void mbedtls_asn1_write_mpi(data_t *val, data_t *expected)
{
generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
mbedtls_mpi mpi, read;
int ret;
- mbedtls_mpi_init( &mpi );
- mbedtls_mpi_init( &read );
- TEST_ASSERT( mbedtls_mpi_read_binary( &mpi, val->x, val->len ) == 0 );
+ mbedtls_mpi_init(&mpi);
+ mbedtls_mpi_init(&read);
+ TEST_ASSERT(mbedtls_mpi_read_binary(&mpi, val->x, val->len) == 0);
- for( data.size = 0; data.size <= expected->len + 1; data.size++ )
- {
- if( ! generic_write_start_step( &data ) )
+ for (data.size = 0; data.size <= expected->len + 1; data.size++) {
+ if (!generic_write_start_step(&data)) {
goto exit;
- ret = mbedtls_asn1_write_mpi( &data.p, data.start, &mpi );
- if( ! generic_write_finish_step( &data, expected, ret ) )
+ }
+ ret = mbedtls_asn1_write_mpi(&data.p, data.start, &mpi);
+ if (!generic_write_finish_step(&data, expected, ret)) {
goto exit;
+ }
#if defined(MBEDTLS_ASN1_PARSE_C)
- if( ret >= 0 )
- {
- TEST_EQUAL( mbedtls_asn1_get_mpi( &data.p, data.end, &read ), 0 );
- TEST_EQUAL( 0, mbedtls_mpi_cmp_mpi( &mpi, &read ) );
+ if (ret >= 0) {
+ TEST_EQUAL(mbedtls_asn1_get_mpi(&data.p, data.end, &read), 0);
+ TEST_EQUAL(0, mbedtls_mpi_cmp_mpi(&mpi, &read));
}
#endif /* MBEDTLS_ASN1_PARSE_C */
/* Skip some intermediate lengths, they're boring. */
- if( expected->len > 10 && data.size == 8 )
+ if (expected->len > 10 && data.size == 8) {
data.size = expected->len - 2;
+ }
}
exit:
- mbedtls_mpi_free( &mpi );
- mbedtls_mpi_free( &read );
- mbedtls_free( data.output );
+ mbedtls_mpi_free(&mpi);
+ mbedtls_mpi_free(&read);
+ mbedtls_free(data.output);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_asn1_write_string( int tag, data_t *content, data_t *expected )
+void mbedtls_asn1_write_string(int tag, data_t *content, data_t *expected)
{
generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
int ret;
- for( data.size = 0; data.size <= expected->len + 1; data.size++ )
- {
- if( ! generic_write_start_step( &data ) )
+ for (data.size = 0; data.size <= expected->len + 1; data.size++) {
+ if (!generic_write_start_step(&data)) {
goto exit;
- switch( tag )
- {
+ }
+ switch (tag) {
case MBEDTLS_ASN1_OCTET_STRING:
ret = mbedtls_asn1_write_octet_string(
- &data.p, data.start, content->x, content->len );
+ &data.p, data.start, content->x, content->len);
break;
case MBEDTLS_ASN1_OID:
ret = mbedtls_asn1_write_oid(
&data.p, data.start,
- (const char *) content->x, content->len );
+ (const char *) content->x, content->len);
break;
case MBEDTLS_ASN1_UTF8_STRING:
ret = mbedtls_asn1_write_utf8_string(
&data.p, data.start,
- (const char *) content->x, content->len );
+ (const char *) content->x, content->len);
break;
case MBEDTLS_ASN1_PRINTABLE_STRING:
ret = mbedtls_asn1_write_printable_string(
&data.p, data.start,
- (const char *) content->x, content->len );
+ (const char *) content->x, content->len);
break;
case MBEDTLS_ASN1_IA5_STRING:
ret = mbedtls_asn1_write_ia5_string(
&data.p, data.start,
- (const char *) content->x, content->len );
+ (const char *) content->x, content->len);
break;
default:
ret = mbedtls_asn1_write_tagged_string(
&data.p, data.start, tag,
- (const char *) content->x, content->len );
+ (const char *) content->x, content->len);
}
- if( ! generic_write_finish_step( &data, expected, ret ) )
+ if (!generic_write_finish_step(&data, expected, ret)) {
goto exit;
+ }
/* There's no parsing function for octet or character strings. */
/* Skip some intermediate lengths, they're boring. */
- if( expected->len > 10 && data.size == 8 )
+ if (expected->len > 10 && data.size == 8) {
data.size = expected->len - 2;
+ }
}
exit:
- mbedtls_free( data.output );
+ mbedtls_free(data.output);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_asn1_write_algorithm_identifier( data_t *oid,
- int par_len,
- data_t *expected )
+void mbedtls_asn1_write_algorithm_identifier(data_t *oid,
+ int par_len,
+ data_t *expected)
{
generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
int ret;
@@ -265,29 +264,30 @@
unsigned char *buf_complete = NULL;
#endif /* MBEDTLS_ASN1_PARSE_C */
- for( data.size = 0; data.size <= expected->len + 1; data.size++ )
- {
- if( ! generic_write_start_step( &data ) )
+ for (data.size = 0; data.size <= expected->len + 1; data.size++) {
+ if (!generic_write_start_step(&data)) {
goto exit;
+ }
ret = mbedtls_asn1_write_algorithm_identifier(
&data.p, data.start,
- (const char *) oid->x, oid->len, par_len );
+ (const char *) oid->x, oid->len, par_len);
/* If params_len != 0, mbedtls_asn1_write_algorithm_identifier()
* assumes that the parameters are already present in the buffer
* and returns a length that accounts for this, but our test
* data omits the parameters. */
- if( ret >= 0 )
+ if (ret >= 0) {
ret -= par_len;
- if( ! generic_write_finish_step( &data, expected, ret ) )
+ }
+ if (!generic_write_finish_step(&data, expected, ret)) {
goto exit;
+ }
#if defined(MBEDTLS_ASN1_PARSE_C)
/* Only do a parse-back test if the parameters aren't too large for
* a small-heap environment. The boundary is somewhat arbitrary. */
- if( ret >= 0 && par_len <= 1234 )
- {
- mbedtls_asn1_buf alg = {0, 0, NULL};
- mbedtls_asn1_buf params = {0, 0, NULL};
+ if (ret >= 0 && par_len <= 1234) {
+ mbedtls_asn1_buf alg = { 0, 0, NULL };
+ mbedtls_asn1_buf params = { 0, 0, NULL };
/* The writing function doesn't write the parameters unless
* they're null: it only takes their length as input. But the
* parsing function requires the parameters to be present.
@@ -296,59 +296,52 @@
size_t len_complete = data_len + par_len;
unsigned char expected_params_tag;
size_t expected_params_len;
- ASSERT_ALLOC( buf_complete, len_complete );
+ ASSERT_ALLOC(buf_complete, len_complete);
unsigned char *end_complete = buf_complete + len_complete;
- memcpy( buf_complete, data.p, data_len );
- if( par_len == 0 )
- {
+ memcpy(buf_complete, data.p, data_len);
+ if (par_len == 0) {
/* mbedtls_asn1_write_algorithm_identifier() wrote a NULL */
expected_params_tag = 0x05;
expected_params_len = 0;
- }
- else if( par_len >= 2 && par_len < 2 + 128 )
- {
+ } else if (par_len >= 2 && par_len < 2 + 128) {
/* Write an OCTET STRING with a short length encoding */
expected_params_tag = buf_complete[data_len] = 0x04;
expected_params_len = par_len - 2;
buf_complete[data_len + 1] = (unsigned char) expected_params_len;
- }
- else if( par_len >= 4 + 128 && par_len < 3 + 256 * 256 )
- {
+ } else if (par_len >= 4 + 128 && par_len < 3 + 256 * 256) {
/* Write an OCTET STRING with a two-byte length encoding */
expected_params_tag = buf_complete[data_len] = 0x04;
expected_params_len = par_len - 4;
buf_complete[data_len + 1] = 0x82;
- buf_complete[data_len + 2] = (unsigned char) ( expected_params_len >> 8 );
- buf_complete[data_len + 3] = (unsigned char) ( expected_params_len );
- }
- else
- {
- TEST_ASSERT( ! "Bad test data: invalid length of ASN.1 element" );
+ buf_complete[data_len + 2] = (unsigned char) (expected_params_len >> 8);
+ buf_complete[data_len + 3] = (unsigned char) (expected_params_len);
+ } else {
+ TEST_ASSERT(!"Bad test data: invalid length of ASN.1 element");
}
unsigned char *p = buf_complete;
- TEST_EQUAL( mbedtls_asn1_get_alg( &p, end_complete,
- &alg, ¶ms ), 0 );
- TEST_EQUAL( alg.tag, MBEDTLS_ASN1_OID );
- ASSERT_COMPARE( alg.p, alg.len, oid->x, oid->len );
- TEST_EQUAL( params.tag, expected_params_tag );
- TEST_EQUAL( params.len, expected_params_len );
- mbedtls_free( buf_complete );
+ TEST_EQUAL(mbedtls_asn1_get_alg(&p, end_complete,
+ &alg, ¶ms), 0);
+ TEST_EQUAL(alg.tag, MBEDTLS_ASN1_OID);
+ ASSERT_COMPARE(alg.p, alg.len, oid->x, oid->len);
+ TEST_EQUAL(params.tag, expected_params_tag);
+ TEST_EQUAL(params.len, expected_params_len);
+ mbedtls_free(buf_complete);
buf_complete = NULL;
}
#endif /* MBEDTLS_ASN1_PARSE_C */
}
exit:
- mbedtls_free( data.output );
+ mbedtls_free(data.output);
#if defined(MBEDTLS_ASN1_PARSE_C)
- mbedtls_free( buf_complete );
+ mbedtls_free(buf_complete);
#endif /* MBEDTLS_ASN1_PARSE_C */
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_ASN1_PARSE_C */
-void mbedtls_asn1_write_len( int len, data_t * asn1, int buf_len,
- int result )
+void mbedtls_asn1_write_len(int len, data_t *asn1, int buf_len,
+ int result)
{
int ret;
unsigned char buf[150];
@@ -356,260 +349,253 @@
size_t i;
size_t read_len;
- memset( buf, GUARD_VAL, sizeof( buf ) );
+ memset(buf, GUARD_VAL, sizeof(buf));
p = buf + GUARD_LEN + buf_len;
- ret = mbedtls_asn1_write_len( &p, buf + GUARD_LEN, (size_t) len );
+ ret = mbedtls_asn1_write_len(&p, buf + GUARD_LEN, (size_t) len);
- TEST_ASSERT( ret == result );
+ TEST_ASSERT(ret == result);
/* Check for buffer overwrite on both sides */
- for( i = 0; i < GUARD_LEN; i++ )
- {
- TEST_ASSERT( buf[i] == GUARD_VAL );
- TEST_ASSERT( buf[GUARD_LEN + buf_len + i] == GUARD_VAL );
+ for (i = 0; i < GUARD_LEN; i++) {
+ TEST_ASSERT(buf[i] == GUARD_VAL);
+ TEST_ASSERT(buf[GUARD_LEN + buf_len + i] == GUARD_VAL);
}
- if( result >= 0 )
- {
- TEST_ASSERT( p + asn1->len == buf + GUARD_LEN + buf_len );
+ if (result >= 0) {
+ TEST_ASSERT(p + asn1->len == buf + GUARD_LEN + buf_len);
- TEST_ASSERT( memcmp( p, asn1->x, asn1->len ) == 0 );
+ TEST_ASSERT(memcmp(p, asn1->x, asn1->len) == 0);
/* Read back with mbedtls_asn1_get_len() to check */
- ret = mbedtls_asn1_get_len( &p, buf + GUARD_LEN + buf_len, &read_len );
+ ret = mbedtls_asn1_get_len(&p, buf + GUARD_LEN + buf_len, &read_len);
- if( len == 0 )
- {
- TEST_ASSERT( ret == 0 );
- }
- else
- {
+ if (len == 0) {
+ TEST_ASSERT(ret == 0);
+ } else {
/* Return will be MBEDTLS_ERR_ASN1_OUT_OF_DATA because the rest of
* the buffer is missing
*/
- TEST_ASSERT( ret == MBEDTLS_ERR_ASN1_OUT_OF_DATA );
+ TEST_ASSERT(ret == MBEDTLS_ERR_ASN1_OUT_OF_DATA);
}
- TEST_ASSERT( read_len == (size_t) len );
- TEST_ASSERT( p == buf + GUARD_LEN + buf_len );
+ TEST_ASSERT(read_len == (size_t) len);
+ TEST_ASSERT(p == buf + GUARD_LEN + buf_len);
}
}
/* END_CASE */
/* BEGIN_CASE */
-void test_asn1_write_bitstrings( data_t *bitstring, int bits,
- data_t *expected, int is_named )
+void test_asn1_write_bitstrings(data_t *bitstring, int bits,
+ data_t *expected, int is_named)
{
generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
int ret;
- int ( *func )( unsigned char **p, const unsigned char *start,
- const unsigned char *buf, size_t bits ) =
- ( is_named ? mbedtls_asn1_write_named_bitstring :
- mbedtls_asn1_write_bitstring );
+ int (*func)(unsigned char **p, const unsigned char *start,
+ const unsigned char *buf, size_t bits) =
+ (is_named ? mbedtls_asn1_write_named_bitstring :
+ mbedtls_asn1_write_bitstring);
#if defined(MBEDTLS_ASN1_PARSE_C)
unsigned char *masked_bitstring = NULL;
#endif /* MBEDTLS_ASN1_PARSE_C */
/* The API expects `bitstring->x` to contain `bits` bits. */
- size_t byte_length = ( bits + 7 ) / 8;
- TEST_ASSERT( bitstring->len >= byte_length );
+ size_t byte_length = (bits + 7) / 8;
+ TEST_ASSERT(bitstring->len >= byte_length);
#if defined(MBEDTLS_ASN1_PARSE_C)
- ASSERT_ALLOC( masked_bitstring, byte_length );
- if( byte_length != 0 )
- {
- memcpy( masked_bitstring, bitstring->x, byte_length );
- if( bits % 8 != 0 )
- masked_bitstring[byte_length - 1] &= ~( 0xff >> ( bits % 8 ) );
+ ASSERT_ALLOC(masked_bitstring, byte_length);
+ if (byte_length != 0) {
+ memcpy(masked_bitstring, bitstring->x, byte_length);
+ if (bits % 8 != 0) {
+ masked_bitstring[byte_length - 1] &= ~(0xff >> (bits % 8));
+ }
}
size_t value_bits = bits;
- if( is_named )
- {
+ if (is_named) {
/* In a named bit string, all trailing 0 bits are removed. */
- while( byte_length > 0 && masked_bitstring[byte_length - 1] == 0 )
+ while (byte_length > 0 && masked_bitstring[byte_length - 1] == 0) {
--byte_length;
+ }
value_bits = 8 * byte_length;
- if( byte_length > 0 )
- {
+ if (byte_length > 0) {
unsigned char last_byte = masked_bitstring[byte_length - 1];
- for( unsigned b = 1; b < 0xff && ( last_byte & b ) == 0; b <<= 1 )
+ for (unsigned b = 1; b < 0xff && (last_byte & b) == 0; b <<= 1) {
--value_bits;
+ }
}
}
#endif /* MBEDTLS_ASN1_PARSE_C */
- for( data.size = 0; data.size <= expected->len + 1; data.size++ )
- {
- if( ! generic_write_start_step( &data ) )
+ for (data.size = 0; data.size <= expected->len + 1; data.size++) {
+ if (!generic_write_start_step(&data)) {
goto exit;
- ret = ( *func )( &data.p, data.start, bitstring->x, bits );
- if( ! generic_write_finish_step( &data, expected, ret ) )
+ }
+ ret = (*func)(&data.p, data.start, bitstring->x, bits);
+ if (!generic_write_finish_step(&data, expected, ret)) {
goto exit;
+ }
#if defined(MBEDTLS_ASN1_PARSE_C)
- if( ret >= 0 )
- {
- mbedtls_asn1_bitstring read = {0, 0, NULL};
- TEST_EQUAL( mbedtls_asn1_get_bitstring( &data.p, data.end,
- &read ), 0 );
- ASSERT_COMPARE( read.p, read.len,
- masked_bitstring, byte_length );
- TEST_EQUAL( read.unused_bits, 8 * byte_length - value_bits );
+ if (ret >= 0) {
+ mbedtls_asn1_bitstring read = { 0, 0, NULL };
+ TEST_EQUAL(mbedtls_asn1_get_bitstring(&data.p, data.end,
+ &read), 0);
+ ASSERT_COMPARE(read.p, read.len,
+ masked_bitstring, byte_length);
+ TEST_EQUAL(read.unused_bits, 8 * byte_length - value_bits);
}
#endif /* MBEDTLS_ASN1_PARSE_C */
}
exit:
- mbedtls_free( data.output );
+ mbedtls_free(data.output);
#if defined(MBEDTLS_ASN1_PARSE_C)
- mbedtls_free( masked_bitstring );
+ mbedtls_free(masked_bitstring);
#endif /* MBEDTLS_ASN1_PARSE_C */
}
/* END_CASE */
/* BEGIN_CASE */
-void store_named_data_find( data_t *oid0, data_t *oid1,
- data_t *oid2, data_t *oid3,
- data_t *needle, int from, int position )
+void store_named_data_find(data_t *oid0, data_t *oid1,
+ data_t *oid2, data_t *oid3,
+ data_t *needle, int from, int position)
{
- data_t *oid[4] = {oid0, oid1, oid2, oid3};
- mbedtls_asn1_named_data nd[] ={
- { {0x06, 0, NULL}, {0, 0, NULL}, NULL, 0 },
- { {0x06, 0, NULL}, {0, 0, NULL}, NULL, 0 },
- { {0x06, 0, NULL}, {0, 0, NULL}, NULL, 0 },
- { {0x06, 0, NULL}, {0, 0, NULL}, NULL, 0 },
+ data_t *oid[4] = { oid0, oid1, oid2, oid3 };
+ mbedtls_asn1_named_data nd[] = {
+ { { 0x06, 0, NULL }, { 0, 0, NULL }, NULL, 0 },
+ { { 0x06, 0, NULL }, { 0, 0, NULL }, NULL, 0 },
+ { { 0x06, 0, NULL }, { 0, 0, NULL }, NULL, 0 },
+ { { 0x06, 0, NULL }, { 0, 0, NULL }, NULL, 0 },
};
- mbedtls_asn1_named_data *pointers[ARRAY_LENGTH( nd ) + 1];
+ mbedtls_asn1_named_data *pointers[ARRAY_LENGTH(nd) + 1];
size_t i;
mbedtls_asn1_named_data *head = NULL;
mbedtls_asn1_named_data *found = NULL;
- for( i = 0; i < ARRAY_LENGTH( nd ); i++ )
+ for (i = 0; i < ARRAY_LENGTH(nd); i++) {
pointers[i] = &nd[i];
- pointers[ARRAY_LENGTH( nd )] = NULL;
- for( i = 0; i < ARRAY_LENGTH( nd ); i++ )
- {
- ASSERT_ALLOC( nd[i].oid.p, oid[i]->len );
- memcpy( nd[i].oid.p, oid[i]->x, oid[i]->len );
+ }
+ pointers[ARRAY_LENGTH(nd)] = NULL;
+ for (i = 0; i < ARRAY_LENGTH(nd); i++) {
+ ASSERT_ALLOC(nd[i].oid.p, oid[i]->len);
+ memcpy(nd[i].oid.p, oid[i]->x, oid[i]->len);
nd[i].oid.len = oid[i]->len;
nd[i].next = pointers[i+1];
}
head = pointers[from];
- found = mbedtls_asn1_store_named_data( &head,
- (const char *) needle->x,
- needle->len,
- NULL, 0 );
+ found = mbedtls_asn1_store_named_data(&head,
+ (const char *) needle->x,
+ needle->len,
+ NULL, 0);
/* In any case, the existing list structure must be unchanged. */
- for( i = 0; i < ARRAY_LENGTH( nd ); i++ )
- TEST_ASSERT( nd[i].next == pointers[i+1] );
-
- if( position >= 0 )
- {
- /* position should have been found and modified. */
- TEST_ASSERT( head == pointers[from] );
- TEST_ASSERT( found == pointers[position] );
+ for (i = 0; i < ARRAY_LENGTH(nd); i++) {
+ TEST_ASSERT(nd[i].next == pointers[i+1]);
}
- else
- {
+
+ if (position >= 0) {
+ /* position should have been found and modified. */
+ TEST_ASSERT(head == pointers[from]);
+ TEST_ASSERT(found == pointers[position]);
+ } else {
/* A new entry should have been created. */
- TEST_ASSERT( found == head );
- TEST_ASSERT( head->next == pointers[from] );
- for( i = 0; i < ARRAY_LENGTH( nd ); i++ )
- TEST_ASSERT( found != &nd[i] );
+ TEST_ASSERT(found == head);
+ TEST_ASSERT(head->next == pointers[from]);
+ for (i = 0; i < ARRAY_LENGTH(nd); i++) {
+ TEST_ASSERT(found != &nd[i]);
+ }
}
exit:
- if( found != NULL && found == head && found != pointers[from] )
- {
- mbedtls_free( found->oid.p );
- mbedtls_free( found );
+ if (found != NULL && found == head && found != pointers[from]) {
+ mbedtls_free(found->oid.p);
+ mbedtls_free(found);
}
- for( i = 0; i < ARRAY_LENGTH( nd ); i++ )
- mbedtls_free( nd[i].oid.p );
+ for (i = 0; i < ARRAY_LENGTH(nd); i++) {
+ mbedtls_free(nd[i].oid.p);
+ }
}
/* END_CASE */
/* BEGIN_CASE */
-void store_named_data_val_found( int old_len, int new_len )
+void store_named_data_val_found(int old_len, int new_len)
{
mbedtls_asn1_named_data nd =
- { {0x06, 3, (unsigned char *) "OID"}, {0, 0, NULL}, NULL, 0 };
+ { { 0x06, 3, (unsigned char *) "OID" }, { 0, 0, NULL }, NULL, 0 };
mbedtls_asn1_named_data *head = &nd;
mbedtls_asn1_named_data *found = NULL;
unsigned char *old_val = NULL;
unsigned char *new_val = (unsigned char *) "new value";
- if( old_len != 0 )
- {
- ASSERT_ALLOC( nd.val.p, (size_t) old_len );
+ if (old_len != 0) {
+ ASSERT_ALLOC(nd.val.p, (size_t) old_len);
old_val = nd.val.p;
nd.val.len = old_len;
- memset( old_val, 'x', old_len );
+ memset(old_val, 'x', old_len);
}
- if( new_len <= 0 )
- {
- new_len = - new_len;
+ if (new_len <= 0) {
+ new_len = -new_len;
new_val = NULL;
}
- found = mbedtls_asn1_store_named_data( &head, "OID", 3,
- new_val, new_len );
- TEST_ASSERT( head == &nd );
- TEST_ASSERT( found == head );
+ found = mbedtls_asn1_store_named_data(&head, "OID", 3,
+ new_val, new_len);
+ TEST_ASSERT(head == &nd);
+ TEST_ASSERT(found == head);
- if( new_val != NULL)
- ASSERT_COMPARE( found->val.p, found->val.len,
- new_val, (size_t) new_len );
- if( new_len == 0)
- TEST_ASSERT( found->val.p == NULL );
- else if( new_len == old_len )
- TEST_ASSERT( found->val.p == old_val );
- else
- TEST_ASSERT( found->val.p != old_val );
+ if (new_val != NULL) {
+ ASSERT_COMPARE(found->val.p, found->val.len,
+ new_val, (size_t) new_len);
+ }
+ if (new_len == 0) {
+ TEST_ASSERT(found->val.p == NULL);
+ } else if (new_len == old_len) {
+ TEST_ASSERT(found->val.p == old_val);
+ } else {
+ TEST_ASSERT(found->val.p != old_val);
+ }
exit:
- mbedtls_free( nd.val.p );
+ mbedtls_free(nd.val.p);
}
/* END_CASE */
/* BEGIN_CASE */
-void store_named_data_val_new( int new_len, int set_new_val )
+void store_named_data_val_new(int new_len, int set_new_val)
{
mbedtls_asn1_named_data *head = NULL;
mbedtls_asn1_named_data *found = NULL;
const unsigned char *oid = (unsigned char *) "OID";
- size_t oid_len = strlen( (const char *) oid );
+ size_t oid_len = strlen((const char *) oid);
const unsigned char *new_val = (unsigned char *) "new value";
- if( set_new_val == 0 )
+ if (set_new_val == 0) {
new_val = NULL;
+ }
- found = mbedtls_asn1_store_named_data( &head,
- (const char *) oid, oid_len,
- new_val, (size_t) new_len );
- TEST_ASSERT( found != NULL );
- TEST_ASSERT( found == head );
- TEST_ASSERT( found->oid.p != oid );
- ASSERT_COMPARE( found->oid.p, found->oid.len, oid, oid_len );
- if( new_len == 0 )
- TEST_ASSERT( found->val.p == NULL );
- else if( new_val == NULL )
- TEST_ASSERT( found->val.p != NULL );
- else
- {
- TEST_ASSERT( found->val.p != new_val );
- ASSERT_COMPARE( found->val.p, found->val.len,
- new_val, (size_t) new_len );
+ found = mbedtls_asn1_store_named_data(&head,
+ (const char *) oid, oid_len,
+ new_val, (size_t) new_len);
+ TEST_ASSERT(found != NULL);
+ TEST_ASSERT(found == head);
+ TEST_ASSERT(found->oid.p != oid);
+ ASSERT_COMPARE(found->oid.p, found->oid.len, oid, oid_len);
+ if (new_len == 0) {
+ TEST_ASSERT(found->val.p == NULL);
+ } else if (new_val == NULL) {
+ TEST_ASSERT(found->val.p != NULL);
+ } else {
+ TEST_ASSERT(found->val.p != new_val);
+ ASSERT_COMPARE(found->val.p, found->val.len,
+ new_val, (size_t) new_len);
}
exit:
- if( found != NULL )
- {
- mbedtls_free( found->oid.p );
- mbedtls_free( found->val.p );
+ if (found != NULL) {
+ mbedtls_free(found->oid.p);
+ mbedtls_free(found->val.p);
}
- mbedtls_free( found );
+ mbedtls_free(found);
}
/* END_CASE */