mirrors-yuzu-emu/mbedtls
1
0
Fork 0
mirror of https://github.com/yuzu-emu/mbedtls synced 2024-11-24 13:48:10 +00:00
Code Issues Projects Releases Packages Wiki Activity
mbedtls/tests/suites/embedded_test.function
Azim Khan d59391afcd Add support for sending hex parameters
2018-08-06 11:40:57 +01:00

410 lines
10 KiB
Text
Raw Blame History

#line 2 "embedded_test.function"
#include "greentea-client/test_env_c.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 \
{ \
assert( p >= start ); \
assert( sizeof( *p ) == sizeof( *start ) ); \
/* <= is checked to support use inside a loop where \
pointer is incremented after reading data. */ \
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 unsigned integer on serial interface.
* Integers are encoded in network order.
*
* \param none
*
* \return unsigned int
*/
uint32_t receive_uint32()
{
uint32_t value;
value = (uint8_t)greentea_getc() << 24;
value |= (uint8_t)greentea_getc() << 16;
value |= (uint8_t)greentea_getc() << 8;
value |= (uint8_t)greentea_getc();
return( (uint32_t)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 );
assert( data != NULL );
greentea_getc(); // read ';' received after key i.e. *data_len
for( i = 0; i < *data_len; i++ )
data[i] = greentea_getc();
/* 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 Parses received byte array and finds number of hex parameters.
*
* \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 ) );
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( 180, "mbedtls_test" );
greentea_send_kv( "GO", " " );
while ( 1 )
{
ret = 0;
test_info.failed = 0;
data_len = 0;
data = receive_data( &data_len );
if ( data == NULL )
continue;
p = data;
do
{
/* Read dependency count */
count = *p;
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 ) );
/* 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.failed );
}
return( 0 );
}
Reference in a new issue View git blame Copy permalink