mirror of
https://github.com/yuzu-emu/mbedtls.git
synced 2024-12-25 22:25:42 +00:00
441 lines
11 KiB
Plaintext
441 lines
11 KiB
Plaintext
#line 2 "suites/target_test.function"
|
|
|
|
#include "greentea-client/test_env.h"
|
|
|
|
/**
|
|
* \brief Increments pointer and asserts that it does not overflow.
|
|
*
|
|
* \param p Pointer to byte array
|
|
* \param start Pointer to start of byte array
|
|
* \param len Length of byte array
|
|
* \param step Increment size
|
|
*
|
|
*/
|
|
#define INCR_ASSERT(p, start, len, step) do \
|
|
{ \
|
|
TEST_HELPER_ASSERT( ( p ) >= ( start ) ); \
|
|
TEST_HELPER_ASSERT( sizeof( *( p ) ) == sizeof( *( start ) ) ); \
|
|
/* <= is checked to support use inside a loop where \
|
|
pointer is incremented after reading data. */ \
|
|
TEST_HELPER_ASSERT( (uint32_t)( ( ( p ) - ( start ) ) + ( step ) ) <= ( len ) );\
|
|
( p ) += ( step ); \
|
|
} \
|
|
while( 0 )
|
|
|
|
|
|
/**
|
|
* \brief 4 byte align unsigned char pointer
|
|
*
|
|
* \param p Pointer to byte array
|
|
* \param start Pointer to start of byte array
|
|
* \param len Length of byte array
|
|
*
|
|
*/
|
|
#define ALIGN_32BIT(p, start, len) do \
|
|
{ \
|
|
uint32_t align = ( - (uintptr_t)( p ) ) % 4; \
|
|
INCR_ASSERT( ( p ), ( start ), ( len ), align );\
|
|
} \
|
|
while( 0 )
|
|
|
|
|
|
/**
|
|
* \brief Verify dependencies. Dependency identifiers are
|
|
* encoded in the buffer as 8 bit unsigned integers.
|
|
*
|
|
* \param count Number of dependencies.
|
|
* \param dep_p Pointer to buffer.
|
|
*
|
|
* \return DEPENDENCY_SUPPORTED if success else DEPENDENCY_NOT_SUPPORTED.
|
|
*/
|
|
int verify_dependencies( uint8_t count, uint8_t * dep_p )
|
|
{
|
|
uint8_t i;
|
|
for ( i = 0; i < count; i++ )
|
|
{
|
|
if ( dep_check( (int)(dep_p[i]) ) != DEPENDENCY_SUPPORTED )
|
|
return( DEPENDENCY_NOT_SUPPORTED );
|
|
}
|
|
return( DEPENDENCY_SUPPORTED );
|
|
}
|
|
|
|
/**
|
|
* \brief Receives hex string on serial interface, and converts to a byte.
|
|
*
|
|
* \param none
|
|
*
|
|
* \return unsigned int8
|
|
*/
|
|
uint8_t receive_byte()
|
|
{
|
|
uint8_t byte;
|
|
uint8_t c[3];
|
|
char *endptr;
|
|
c[0] = greentea_getc();
|
|
c[1] = greentea_getc();
|
|
c[2] = '\0';
|
|
|
|
TEST_HELPER_ASSERT( unhexify( &byte, c ) != 2 );
|
|
return( byte );
|
|
}
|
|
|
|
/**
|
|
* \brief Receives unsigned integer on serial interface.
|
|
* Integers are encoded in network order, and sent as hex ascii string.
|
|
*
|
|
* \param none
|
|
*
|
|
* \return unsigned int
|
|
*/
|
|
uint32_t receive_uint32()
|
|
{
|
|
uint32_t value;
|
|
const uint8_t c_be[8] = { greentea_getc(),
|
|
greentea_getc(),
|
|
greentea_getc(),
|
|
greentea_getc(),
|
|
greentea_getc(),
|
|
greentea_getc(),
|
|
greentea_getc(),
|
|
greentea_getc()
|
|
};
|
|
const uint8_t c[9] = { c_be[6], c_be[7], c_be[4], c_be[5], c_be[2],
|
|
c_be[3], c_be[0], c_be[1], '\0' };
|
|
TEST_HELPER_ASSERT( unhexify( (uint8_t*)&value, c ) != 8 );
|
|
return( value );
|
|
}
|
|
|
|
/**
|
|
* \brief Parses out an unsigned 32 int value from the byte array.
|
|
* Integers are encoded in network order.
|
|
*
|
|
* \param p Pointer to byte array
|
|
*
|
|
* \return unsigned int
|
|
*/
|
|
uint32_t parse_uint32( uint8_t * p )
|
|
{
|
|
uint32_t value;
|
|
value = *p++ << 24;
|
|
value |= *p++ << 16;
|
|
value |= *p++ << 8;
|
|
value |= *p;
|
|
return( value );
|
|
}
|
|
|
|
|
|
/**
|
|
* \brief Receives test data on serial as greentea key,value pair:
|
|
* {{<length>;<byte array>}}
|
|
*
|
|
* \param data_len Out pointer to hold received data length.
|
|
*
|
|
* \return Byte array.
|
|
*/
|
|
uint8_t * receive_data( uint32_t * data_len )
|
|
{
|
|
uint32_t i = 0, errors = 0;
|
|
char c;
|
|
uint8_t * data = NULL;
|
|
|
|
/* Read opening braces */
|
|
i = 0;
|
|
while ( i < 2 )
|
|
{
|
|
c = greentea_getc();
|
|
/* Ignore any prevous CR LF characters */
|
|
if ( c == '\n' || c == '\r' )
|
|
continue;
|
|
i++;
|
|
if ( c != '{' )
|
|
return( NULL );
|
|
}
|
|
|
|
/* Read data length */
|
|
*data_len = receive_uint32();
|
|
data = (uint8_t *)malloc( *data_len );
|
|
TEST_HELPER_ASSERT( data != NULL );
|
|
|
|
greentea_getc(); // read ';' received after key i.e. *data_len
|
|
|
|
for( i = 0; i < *data_len; i++ )
|
|
data[i] = receive_byte();
|
|
|
|
/* Read closing braces */
|
|
for( i = 0; i < 2; i++ )
|
|
{
|
|
c = greentea_getc();
|
|
if ( c != '}' )
|
|
{
|
|
errors++;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( errors )
|
|
{
|
|
free( data );
|
|
data = NULL;
|
|
*data_len = 0;
|
|
}
|
|
|
|
return( data );
|
|
}
|
|
|
|
/**
|
|
* \brief Parse the received byte array and count the number of arguments
|
|
* to the test function passed as type hex.
|
|
*
|
|
* \param count Parameter count
|
|
* \param data Received Byte array
|
|
* \param data_len Byte array length
|
|
*
|
|
* \return count of hex params
|
|
*/
|
|
uint32_t find_hex_count( uint8_t count, uint8_t * data, uint32_t data_len )
|
|
{
|
|
uint32_t i = 0, sz = 0;
|
|
char c;
|
|
uint8_t * p = NULL;
|
|
uint32_t hex_count = 0;
|
|
|
|
p = data;
|
|
|
|
for( i = 0; i < count; i++ )
|
|
{
|
|
c = (char)*p;
|
|
INCR_ASSERT( p, data, data_len, 1 );
|
|
|
|
/* Align p to 4 bytes for int, expression, string len or hex length */
|
|
ALIGN_32BIT( p, data, data_len );
|
|
|
|
/* Network to host conversion */
|
|
sz = (int32_t)parse_uint32( p );
|
|
|
|
INCR_ASSERT( p, data, data_len, sizeof( int32_t ) );
|
|
|
|
if ( c == 'H' || c == 'S' )
|
|
{
|
|
INCR_ASSERT( p, data, data_len, sz );
|
|
hex_count += ( c == 'H' )?1:0;
|
|
}
|
|
}
|
|
|
|
return( hex_count );
|
|
}
|
|
|
|
/**
|
|
* \brief Parses received byte array for test parameters.
|
|
*
|
|
* \param count Parameter count
|
|
* \param data Received Byte array
|
|
* \param data_len Byte array length
|
|
* \param error Parsing error out variable.
|
|
*
|
|
* \return Array of parsed parameters allocated on heap.
|
|
* Note: Caller has the responsibility to delete
|
|
* the memory after use.
|
|
*/
|
|
void ** parse_parameters( uint8_t count, uint8_t * data, uint32_t data_len,
|
|
int * error )
|
|
{
|
|
uint32_t i = 0, hex_count = 0;
|
|
char c;
|
|
void ** params = NULL;
|
|
void ** cur = NULL;
|
|
uint8_t * p = NULL;
|
|
|
|
hex_count = find_hex_count(count, data, data_len);
|
|
|
|
params = (void **)malloc( sizeof( void *) * ( count + hex_count ) );
|
|
TEST_HELPER_ASSERT( params != NULL );
|
|
cur = params;
|
|
|
|
p = data;
|
|
|
|
/* Parameters */
|
|
for( i = 0; i < count; i++ )
|
|
{
|
|
c = (char)*p;
|
|
INCR_ASSERT( p, data, data_len, 1 );
|
|
|
|
/* Align p to 4 bytes for int, expression, string len or hex length */
|
|
ALIGN_32BIT( p, data, data_len );
|
|
|
|
/* Network to host conversion */
|
|
*( (int32_t *)p ) = (int32_t)parse_uint32( p );
|
|
|
|
switch( c )
|
|
{
|
|
case 'E':
|
|
{
|
|
if ( get_expression( *( (int32_t *)p ), (int32_t *)p ) )
|
|
{
|
|
*error = KEY_VALUE_MAPPING_NOT_FOUND;
|
|
goto exit;
|
|
}
|
|
} /* Intentional fall through */
|
|
case 'I':
|
|
{
|
|
*cur++ = (void *)p;
|
|
INCR_ASSERT( p, data, data_len, sizeof( int32_t ) );
|
|
}
|
|
break;
|
|
case 'H': /* Intentional fall through */
|
|
case 'S':
|
|
{
|
|
uint32_t * sz = (uint32_t *)p;
|
|
INCR_ASSERT( p, data, data_len, sizeof( int32_t ) );
|
|
*cur++ = (void *)p;
|
|
if ( c == 'H' )
|
|
*cur++ = (void *)sz;
|
|
INCR_ASSERT( p, data, data_len, ( *sz ) );
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
*error = DISPATCH_INVALID_TEST_DATA;
|
|
goto exit;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
exit:
|
|
if ( *error )
|
|
{
|
|
free( params );
|
|
params = NULL;
|
|
}
|
|
|
|
return( params );
|
|
}
|
|
|
|
/**
|
|
* \brief Sends greentea key and int value pair to host.
|
|
*
|
|
* \param key key string
|
|
* \param value integer value
|
|
*
|
|
* \return void
|
|
*/
|
|
void send_key_integer( char * key, int value )
|
|
{
|
|
char str[50];
|
|
snprintf( str, sizeof( str ), "%d", value );
|
|
greentea_send_kv( key, str );
|
|
}
|
|
|
|
/**
|
|
* \brief Sends test setup failure to the host.
|
|
*
|
|
* \param failure Test set failure
|
|
*
|
|
* \return void
|
|
*/
|
|
void send_failure( int failure )
|
|
{
|
|
send_key_integer( "F", failure );
|
|
}
|
|
|
|
/**
|
|
* \brief Sends test status to the host.
|
|
*
|
|
* \param status Test status (PASS=0/FAIL=!0)
|
|
*
|
|
* \return void
|
|
*/
|
|
void send_status( int status )
|
|
{
|
|
send_key_integer( "R", status );
|
|
}
|
|
|
|
|
|
/**
|
|
* \brief Embedded implementation of execute_tests().
|
|
* Ignores command line and received test data
|
|
* on serial.
|
|
*
|
|
* \param argc not used
|
|
* \param argv not used
|
|
*
|
|
* \return Program exit status.
|
|
*/
|
|
int execute_tests( int args, const char ** argv )
|
|
{
|
|
int ret = 0;
|
|
uint32_t data_len = 0;
|
|
uint8_t count = 0, function_id;
|
|
void ** params = NULL;
|
|
uint8_t * data = NULL, * p = NULL;
|
|
|
|
GREENTEA_SETUP( 800, "mbedtls_test" );
|
|
greentea_send_kv( "GO", " " );
|
|
|
|
while ( 1 )
|
|
{
|
|
ret = 0;
|
|
test_info.result = TEST_RESULT_SUCCESS;
|
|
data_len = 0;
|
|
|
|
data = receive_data( &data_len );
|
|
if ( data == NULL )
|
|
continue;
|
|
p = data;
|
|
|
|
do
|
|
{
|
|
/* Read dependency count */
|
|
count = *p;
|
|
TEST_HELPER_ASSERT( count < data_len );
|
|
INCR_ASSERT( p, data, data_len, sizeof( uint8_t ) );
|
|
ret = verify_dependencies( count, p );
|
|
if ( ret != DEPENDENCY_SUPPORTED )
|
|
break;
|
|
|
|
if ( count )
|
|
INCR_ASSERT( p, data, data_len, count );
|
|
|
|
/* Read function id */
|
|
function_id = *p;
|
|
INCR_ASSERT( p, data, data_len, sizeof( uint8_t ) );
|
|
if ( ( ret = check_test( function_id ) ) != DISPATCH_TEST_SUCCESS )
|
|
break;
|
|
|
|
/* Read number of parameters */
|
|
count = *p;
|
|
INCR_ASSERT( p, data, data_len, sizeof( uint8_t ) );
|
|
|
|
/* Parse parameters if present */
|
|
if ( count )
|
|
{
|
|
params = parse_parameters( count, p, data_len - ( p - data ), &ret );
|
|
if ( ret )
|
|
break;
|
|
}
|
|
|
|
ret = dispatch_test( function_id, params );
|
|
}
|
|
while ( 0 );
|
|
|
|
if ( data )
|
|
{
|
|
free( data );
|
|
data = NULL;
|
|
}
|
|
|
|
if ( params )
|
|
{
|
|
free( params );
|
|
params = NULL;
|
|
}
|
|
|
|
if ( ret )
|
|
send_failure( ret );
|
|
else
|
|
send_status( test_info.result );
|
|
}
|
|
return( 0 );
|
|
}
|
|
|