00001 #include <polarssl/config.h>
00002
00003
00004 #include <polarssl/sha1.h>
00005 #include <polarssl/sha256.h>
00006 #include <polarssl/sha512.h>
00007
00008
00009 #if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
00010 #include "polarssl/memory.h"
00011 #endif
00012
00013 #if defined(WANT_NOT_RND_MPI)
00014 #if defined(POLARSSL_BIGNUM_C)
00015 #include "polarssl/bignum.h"
00016 #else
00017 #error "not_rnd_mpi() need bignum.c"
00018 #endif
00019 #endif
00020
00021 #ifdef _MSC_VER
00022 #include <basetsd.h>
00023 typedef UINT32 uint32_t;
00024 #else
00025 #include <inttypes.h>
00026 #endif
00027
00028 #include <assert.h>
00029 #include <stdlib.h>
00030 #include <string.h>
00031
00032
00033
00034
00035 #ifndef GET_UINT32_BE
00036 #define GET_UINT32_BE(n,b,i) \
00037 { \
00038 (n) = ( (uint32_t) (b)[(i) ] << 24 ) \
00039 | ( (uint32_t) (b)[(i) + 1] << 16 ) \
00040 | ( (uint32_t) (b)[(i) + 2] << 8 ) \
00041 | ( (uint32_t) (b)[(i) + 3] ); \
00042 }
00043 #endif
00044
00045 #ifndef PUT_UINT32_BE
00046 #define PUT_UINT32_BE(n,b,i) \
00047 { \
00048 (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
00049 (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
00050 (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
00051 (b)[(i) + 3] = (unsigned char) ( (n) ); \
00052 }
00053 #endif
00054
00055 static int unhexify(unsigned char *obuf, const char *ibuf)
00056 {
00057 unsigned char c, c2;
00058 int len = strlen(ibuf) / 2;
00059 assert(!(strlen(ibuf) %1));
00060
00061 while (*ibuf != 0)
00062 {
00063 c = *ibuf++;
00064 if( c >= '0' && c <= '9' )
00065 c -= '0';
00066 else if( c >= 'a' && c <= 'f' )
00067 c -= 'a' - 10;
00068 else if( c >= 'A' && c <= 'F' )
00069 c -= 'A' - 10;
00070 else
00071 assert( 0 );
00072
00073 c2 = *ibuf++;
00074 if( c2 >= '0' && c2 <= '9' )
00075 c2 -= '0';
00076 else if( c2 >= 'a' && c2 <= 'f' )
00077 c2 -= 'a' - 10;
00078 else if( c2 >= 'A' && c2 <= 'F' )
00079 c2 -= 'A' - 10;
00080 else
00081 assert( 0 );
00082
00083 *obuf++ = ( c << 4 ) | c2;
00084 }
00085
00086 return len;
00087 }
00088
00089 static void hexify(unsigned char *obuf, const unsigned char *ibuf, int len)
00090 {
00091 unsigned char l, h;
00092
00093 while (len != 0)
00094 {
00095 h = (*ibuf) / 16;
00096 l = (*ibuf) % 16;
00097
00098 if( h < 10 )
00099 *obuf++ = '0' + h;
00100 else
00101 *obuf++ = 'a' + h - 10;
00102
00103 if( l < 10 )
00104 *obuf++ = '0' + l;
00105 else
00106 *obuf++ = 'a' + l - 10;
00107
00108 ++ibuf;
00109 len--;
00110 }
00111 }
00112
00122 static int rnd_std_rand( void *rng_state, unsigned char *output, size_t len )
00123 {
00124 size_t i;
00125
00126 if( rng_state != NULL )
00127 rng_state = NULL;
00128
00129 for( i = 0; i < len; ++i )
00130 output[i] = rand();
00131
00132 return( 0 );
00133 }
00134
00140 static int rnd_zero_rand( void *rng_state, unsigned char *output, size_t len )
00141 {
00142 if( rng_state != NULL )
00143 rng_state = NULL;
00144
00145 memset( output, 0, len );
00146
00147 return( 0 );
00148 }
00149
00150 typedef struct
00151 {
00152 unsigned char *buf;
00153 size_t length;
00154 } rnd_buf_info;
00155
00167 static int rnd_buffer_rand( void *rng_state, unsigned char *output, size_t len )
00168 {
00169 rnd_buf_info *info = (rnd_buf_info *) rng_state;
00170 size_t use_len;
00171
00172 if( rng_state == NULL )
00173 return( rnd_std_rand( NULL, output, len ) );
00174
00175 use_len = len;
00176 if( len > info->length )
00177 use_len = info->length;
00178
00179 if( use_len )
00180 {
00181 memcpy( output, info->buf, use_len );
00182 info->buf += use_len;
00183 info->length -= use_len;
00184 }
00185
00186 if( len - use_len > 0 )
00187 return( rnd_std_rand( NULL, output + use_len, len - use_len ) );
00188
00189 return( 0 );
00190 }
00191
00199 typedef struct
00200 {
00201 uint32_t key[16];
00202 uint32_t v0, v1;
00203 } rnd_pseudo_info;
00204
00213 static int rnd_pseudo_rand( void *rng_state, unsigned char *output, size_t len )
00214 {
00215 rnd_pseudo_info *info = (rnd_pseudo_info *) rng_state;
00216 uint32_t i, *k, sum, delta=0x9E3779B9;
00217 unsigned char result[4];
00218
00219 if( rng_state == NULL )
00220 return( rnd_std_rand( NULL, output, len ) );
00221
00222 k = info->key;
00223
00224 while( len > 0 )
00225 {
00226 size_t use_len = ( len > 4 ) ? 4 : len;
00227 sum = 0;
00228
00229 for( i = 0; i < 32; i++ )
00230 {
00231 info->v0 += (((info->v1 << 4) ^ (info->v1 >> 5)) + info->v1) ^ (sum + k[sum & 3]);
00232 sum += delta;
00233 info->v1 += (((info->v0 << 4) ^ (info->v0 >> 5)) + info->v0) ^ (sum + k[(sum>>11) & 3]);
00234 }
00235
00236 PUT_UINT32_BE( info->v0, result, 0 );
00237 memcpy( output, result, use_len );
00238 len -= use_len;
00239 }
00240
00241 return( 0 );
00242 }
00243
00244 #if defined(WANT_NOT_RND_MPI)
00245
00253 #define ciL (sizeof(t_uint))
00254 #define CHARS_TO_LIMBS(i) (((i) + ciL - 1) / ciL)
00255 static int not_rnd_mpi( void *in, unsigned char *out, size_t len )
00256 {
00257 char *str = (char *) in;
00258 mpi X;
00259
00260
00261
00262
00263
00264 X.s = 1;
00265 X.p = (t_uint *) out;
00266 X.n = CHARS_TO_LIMBS( len );
00267
00268
00269
00270
00271
00272 assert( strlen( str ) / 2 == len );
00273
00274 return( mpi_read_string( &X, 16, str ) );
00275 }
00276 #endif
00277
00278
00279 #include <stdio.h>
00280 #include <string.h>
00281
00282 static int test_errors = 0;
00283
00284
00285 #define TEST_SUITE_ACTIVE
00286
00287 static int test_assert( int correct, char *test )
00288 {
00289 if( correct )
00290 return( 0 );
00291
00292 test_errors++;
00293 if( test_errors == 1 )
00294 printf( "FAILED\n" );
00295 printf( " %s\n", test );
00296
00297 return( 1 );
00298 }
00299
00300 #define TEST_ASSERT( TEST ) \
00301 do { test_assert( (TEST) ? 1 : 0, #TEST ); \
00302 if( test_errors) return; \
00303 } while (0)
00304
00305 int verify_string( char **str )
00306 {
00307 if( (*str)[0] != '"' ||
00308 (*str)[strlen( *str ) - 1] != '"' )
00309 {
00310 printf( "Expected string (with \"\") for parameter and got: %s\n", *str );
00311 return( -1 );
00312 }
00313
00314 (*str)++;
00315 (*str)[strlen( *str ) - 1] = '\0';
00316
00317 return( 0 );
00318 }
00319
00320 int verify_int( char *str, int *value )
00321 {
00322 size_t i;
00323 int minus = 0;
00324 int digits = 1;
00325 int hex = 0;
00326
00327 for( i = 0; i < strlen( str ); i++ )
00328 {
00329 if( i == 0 && str[i] == '-' )
00330 {
00331 minus = 1;
00332 continue;
00333 }
00334
00335 if( ( ( minus && i == 2 ) || ( !minus && i == 1 ) ) &&
00336 str[i - 1] == '0' && str[i] == 'x' )
00337 {
00338 hex = 1;
00339 continue;
00340 }
00341
00342 if( str[i] < '0' || str[i] > '9' )
00343 {
00344 digits = 0;
00345 break;
00346 }
00347 }
00348
00349 if( digits )
00350 {
00351 if( hex )
00352 *value = strtol( str, NULL, 16 );
00353 else
00354 *value = strtol( str, NULL, 10 );
00355
00356 return( 0 );
00357 }
00358
00359
00360
00361 printf( "Expected integer for parameter and got: %s\n", str );
00362 return( -1 );
00363 }
00364
00365 #ifdef POLARSSL_SHA1_C
00366 void test_suite_sha1_hmac( int trunc_size, char *hex_key_string, char *hex_src_string,
00367 char *hex_hash_string)
00368 {
00369 unsigned char src_str[10000];
00370 unsigned char key_str[10000];
00371 unsigned char hash_str[10000];
00372 unsigned char output[41];
00373 int key_len, src_len;
00374
00375 memset(src_str, 0x00, 10000);
00376 memset(key_str, 0x00, 10000);
00377 memset(hash_str, 0x00, 10000);
00378 memset(output, 0x00, 41);
00379
00380 key_len = unhexify( key_str, hex_key_string );
00381 src_len = unhexify( src_str, hex_src_string );
00382
00383 sha1_hmac( key_str, key_len, src_str, src_len, output );
00384 hexify( hash_str, output, 20 );
00385
00386 TEST_ASSERT( strncmp( (char *) hash_str, hex_hash_string, trunc_size * 2 ) == 0 );
00387 }
00388 #endif
00389
00390 #ifdef POLARSSL_SHA256_C
00391 void test_suite_sha224_hmac( int trunc_size, char *hex_key_string, char *hex_src_string,
00392 char *hex_hash_string)
00393 {
00394 unsigned char src_str[10000];
00395 unsigned char key_str[10000];
00396 unsigned char hash_str[10000];
00397 unsigned char output[57];
00398 int key_len, src_len;
00399
00400 memset(src_str, 0x00, 10000);
00401 memset(key_str, 0x00, 10000);
00402 memset(hash_str, 0x00, 10000);
00403 memset(output, 0x00, 57);
00404
00405 key_len = unhexify( key_str, hex_key_string );
00406 src_len = unhexify( src_str, hex_src_string );
00407
00408 sha256_hmac( key_str, key_len, src_str, src_len, output, 1 );
00409 hexify( hash_str, output, 28 );
00410
00411 TEST_ASSERT( strncmp( (char *) hash_str, hex_hash_string, trunc_size * 2 ) == 0 );
00412 }
00413 #endif
00414
00415 #ifdef POLARSSL_SHA256_C
00416 void test_suite_sha256_hmac( int trunc_size, char *hex_key_string, char *hex_src_string,
00417 char *hex_hash_string)
00418 {
00419 unsigned char src_str[10000];
00420 unsigned char key_str[10000];
00421 unsigned char hash_str[10000];
00422 unsigned char output[65];
00423 int key_len, src_len;
00424
00425 memset(src_str, 0x00, 10000);
00426 memset(key_str, 0x00, 10000);
00427 memset(hash_str, 0x00, 10000);
00428 memset(output, 0x00, 65);
00429
00430 key_len = unhexify( key_str, hex_key_string );
00431 src_len = unhexify( src_str, hex_src_string );
00432
00433 sha256_hmac( key_str, key_len, src_str, src_len, output, 0 );
00434 hexify( hash_str, output, 32 );
00435
00436 TEST_ASSERT( strncmp( (char *) hash_str, hex_hash_string, trunc_size * 2 ) == 0 );
00437 }
00438 #endif
00439
00440 #ifdef POLARSSL_SHA512_C
00441 void test_suite_sha384_hmac( int trunc_size, char *hex_key_string, char *hex_src_string,
00442 char *hex_hash_string)
00443 {
00444 unsigned char src_str[10000];
00445 unsigned char key_str[10000];
00446 unsigned char hash_str[10000];
00447 unsigned char output[97];
00448 int key_len, src_len;
00449
00450 memset(src_str, 0x00, 10000);
00451 memset(key_str, 0x00, 10000);
00452 memset(hash_str, 0x00, 10000);
00453 memset(output, 0x00, 97);
00454
00455 key_len = unhexify( key_str, hex_key_string );
00456 src_len = unhexify( src_str, hex_src_string );
00457
00458 sha512_hmac( key_str, key_len, src_str, src_len, output, 1 );
00459 hexify( hash_str, output, 48 );
00460
00461 TEST_ASSERT( strncmp( (char *) hash_str, hex_hash_string, trunc_size * 2 ) == 0 );
00462 }
00463 #endif
00464
00465 #ifdef POLARSSL_SHA512_C
00466 void test_suite_sha512_hmac( int trunc_size, char *hex_key_string, char *hex_src_string,
00467 char *hex_hash_string)
00468 {
00469 unsigned char src_str[10000];
00470 unsigned char key_str[10000];
00471 unsigned char hash_str[10000];
00472 unsigned char output[129];
00473 int key_len, src_len;
00474
00475 memset(src_str, 0x00, 10000);
00476 memset(key_str, 0x00, 10000);
00477 memset(hash_str, 0x00, 10000);
00478 memset(output, 0x00, 129);
00479
00480 key_len = unhexify( key_str, hex_key_string );
00481 src_len = unhexify( src_str, hex_src_string );
00482
00483 sha512_hmac( key_str, key_len, src_str, src_len, output, 0 );
00484 hexify( hash_str, output, 64 );
00485
00486 TEST_ASSERT( strncmp( (char *) hash_str, hex_hash_string, trunc_size * 2 ) == 0 );
00487 }
00488 #endif
00489
00490
00491
00492
00493 int dep_check( char *str )
00494 {
00495 if( str == NULL )
00496 return( 1 );
00497
00498 if( strcmp( str, "POLARSSL_SHA256_C" ) == 0 )
00499 {
00500 #if defined(POLARSSL_SHA256_C)
00501 return( 0 );
00502 #else
00503 return( 1 );
00504 #endif
00505 }
00506 if( strcmp( str, "POLARSSL_SHA1_C" ) == 0 )
00507 {
00508 #if defined(POLARSSL_SHA1_C)
00509 return( 0 );
00510 #else
00511 return( 1 );
00512 #endif
00513 }
00514 if( strcmp( str, "POLARSSL_SHA512_C" ) == 0 )
00515 {
00516 #if defined(POLARSSL_SHA512_C)
00517 return( 0 );
00518 #else
00519 return( 1 );
00520 #endif
00521 }
00522
00523
00524 return( 1 );
00525 }
00526
00527 int dispatch_test(int cnt, char *params[50])
00528 {
00529 int ret;
00530 ((void) cnt);
00531 ((void) params);
00532
00533 #if defined(TEST_SUITE_ACTIVE)
00534 if( strcmp( params[0], "sha1_hmac" ) == 0 )
00535 {
00536 #ifdef POLARSSL_SHA1_C
00537
00538 int param1;
00539 char *param2 = params[2];
00540 char *param3 = params[3];
00541 char *param4 = params[4];
00542
00543 if( cnt != 5 )
00544 {
00545 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 5 );
00546 return( 2 );
00547 }
00548
00549 if( verify_int( params[1], ¶m1 ) != 0 ) return( 2 );
00550 if( verify_string( ¶m2 ) != 0 ) return( 2 );
00551 if( verify_string( ¶m3 ) != 0 ) return( 2 );
00552 if( verify_string( ¶m4 ) != 0 ) return( 2 );
00553
00554 test_suite_sha1_hmac( param1, param2, param3, param4 );
00555 return ( 0 );
00556 #endif
00557
00558 return ( 3 );
00559 }
00560 else
00561 if( strcmp( params[0], "sha224_hmac" ) == 0 )
00562 {
00563 #ifdef POLARSSL_SHA256_C
00564
00565 int param1;
00566 char *param2 = params[2];
00567 char *param3 = params[3];
00568 char *param4 = params[4];
00569
00570 if( cnt != 5 )
00571 {
00572 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 5 );
00573 return( 2 );
00574 }
00575
00576 if( verify_int( params[1], ¶m1 ) != 0 ) return( 2 );
00577 if( verify_string( ¶m2 ) != 0 ) return( 2 );
00578 if( verify_string( ¶m3 ) != 0 ) return( 2 );
00579 if( verify_string( ¶m4 ) != 0 ) return( 2 );
00580
00581 test_suite_sha224_hmac( param1, param2, param3, param4 );
00582 return ( 0 );
00583 #endif
00584
00585 return ( 3 );
00586 }
00587 else
00588 if( strcmp( params[0], "sha256_hmac" ) == 0 )
00589 {
00590 #ifdef POLARSSL_SHA256_C
00591
00592 int param1;
00593 char *param2 = params[2];
00594 char *param3 = params[3];
00595 char *param4 = params[4];
00596
00597 if( cnt != 5 )
00598 {
00599 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 5 );
00600 return( 2 );
00601 }
00602
00603 if( verify_int( params[1], ¶m1 ) != 0 ) return( 2 );
00604 if( verify_string( ¶m2 ) != 0 ) return( 2 );
00605 if( verify_string( ¶m3 ) != 0 ) return( 2 );
00606 if( verify_string( ¶m4 ) != 0 ) return( 2 );
00607
00608 test_suite_sha256_hmac( param1, param2, param3, param4 );
00609 return ( 0 );
00610 #endif
00611
00612 return ( 3 );
00613 }
00614 else
00615 if( strcmp( params[0], "sha384_hmac" ) == 0 )
00616 {
00617 #ifdef POLARSSL_SHA512_C
00618
00619 int param1;
00620 char *param2 = params[2];
00621 char *param3 = params[3];
00622 char *param4 = params[4];
00623
00624 if( cnt != 5 )
00625 {
00626 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 5 );
00627 return( 2 );
00628 }
00629
00630 if( verify_int( params[1], ¶m1 ) != 0 ) return( 2 );
00631 if( verify_string( ¶m2 ) != 0 ) return( 2 );
00632 if( verify_string( ¶m3 ) != 0 ) return( 2 );
00633 if( verify_string( ¶m4 ) != 0 ) return( 2 );
00634
00635 test_suite_sha384_hmac( param1, param2, param3, param4 );
00636 return ( 0 );
00637 #endif
00638
00639 return ( 3 );
00640 }
00641 else
00642 if( strcmp( params[0], "sha512_hmac" ) == 0 )
00643 {
00644 #ifdef POLARSSL_SHA512_C
00645
00646 int param1;
00647 char *param2 = params[2];
00648 char *param3 = params[3];
00649 char *param4 = params[4];
00650
00651 if( cnt != 5 )
00652 {
00653 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 5 );
00654 return( 2 );
00655 }
00656
00657 if( verify_int( params[1], ¶m1 ) != 0 ) return( 2 );
00658 if( verify_string( ¶m2 ) != 0 ) return( 2 );
00659 if( verify_string( ¶m3 ) != 0 ) return( 2 );
00660 if( verify_string( ¶m4 ) != 0 ) return( 2 );
00661
00662 test_suite_sha512_hmac( param1, param2, param3, param4 );
00663 return ( 0 );
00664 #endif
00665
00666 return ( 3 );
00667 }
00668 else
00669
00670 {
00671 fprintf( stdout, "FAILED\nSkipping unknown test function '%s'\n", params[0] );
00672 fflush( stdout );
00673 return( 1 );
00674 }
00675 #else
00676 return( 3 );
00677 #endif
00678 return( ret );
00679 }
00680
00681 int get_line( FILE *f, char *buf, size_t len )
00682 {
00683 char *ret;
00684
00685 ret = fgets( buf, len, f );
00686 if( ret == NULL )
00687 return( -1 );
00688
00689 if( strlen( buf ) && buf[strlen(buf) - 1] == '\n' )
00690 buf[strlen(buf) - 1] = '\0';
00691 if( strlen( buf ) && buf[strlen(buf) - 1] == '\r' )
00692 buf[strlen(buf) - 1] = '\0';
00693
00694 return( 0 );
00695 }
00696
00697 int parse_arguments( char *buf, size_t len, char *params[50] )
00698 {
00699 int cnt = 0, i;
00700 char *cur = buf;
00701 char *p = buf, *q;
00702
00703 params[cnt++] = cur;
00704
00705 while( *p != '\0' && p < buf + len )
00706 {
00707 if( *p == '\\' )
00708 {
00709 *p++;
00710 *p++;
00711 continue;
00712 }
00713 if( *p == ':' )
00714 {
00715 if( p + 1 < buf + len )
00716 {
00717 cur = p + 1;
00718 params[cnt++] = cur;
00719 }
00720 *p = '\0';
00721 }
00722
00723 *p++;
00724 }
00725
00726
00727 for( i = 0; i < cnt; i++ )
00728 {
00729 p = params[i];
00730 q = params[i];
00731
00732 while( *p != '\0' )
00733 {
00734 if( *p == '\\' && *(p + 1) == 'n' )
00735 {
00736 p += 2;
00737 *(q++) = '\n';
00738 }
00739 else if( *p == '\\' && *(p + 1) == ':' )
00740 {
00741 p += 2;
00742 *(q++) = ':';
00743 }
00744 else if( *p == '\\' && *(p + 1) == '?' )
00745 {
00746 p += 2;
00747 *(q++) = '?';
00748 }
00749 else
00750 *(q++) = *(p++);
00751 }
00752 *q = '\0';
00753 }
00754
00755 return( cnt );
00756 }
00757
00758 int main()
00759 {
00760 int ret, i, cnt, total_errors = 0, total_tests = 0, total_skipped = 0;
00761 const char *filename = "/home/abuild/rpmbuild/BUILD/polarssl-1.3.2/tests/suites/test_suite_hmac_shax.data";
00762 FILE *file;
00763 char buf[5000];
00764 char *params[50];
00765
00766 #if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
00767 unsigned char alloc_buf[1000000];
00768 memory_buffer_alloc_init( alloc_buf, sizeof(alloc_buf) );
00769 #endif
00770
00771 file = fopen( filename, "r" );
00772 if( file == NULL )
00773 {
00774 fprintf( stderr, "Failed to open\n" );
00775 return( 1 );
00776 }
00777
00778 while( !feof( file ) )
00779 {
00780 int skip = 0;
00781
00782 if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
00783 break;
00784 fprintf( stdout, "%s%.66s", test_errors ? "\n" : "", buf );
00785 fprintf( stdout, " " );
00786 for( i = strlen( buf ) + 1; i < 67; i++ )
00787 fprintf( stdout, "." );
00788 fprintf( stdout, " " );
00789 fflush( stdout );
00790
00791 total_tests++;
00792
00793 if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
00794 break;
00795 cnt = parse_arguments( buf, strlen(buf), params );
00796
00797 if( strcmp( params[0], "depends_on" ) == 0 )
00798 {
00799 for( i = 1; i < cnt; i++ )
00800 if( dep_check( params[i] ) != 0 )
00801 skip = 1;
00802
00803 if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
00804 break;
00805 cnt = parse_arguments( buf, strlen(buf), params );
00806 }
00807
00808 if( skip == 0 )
00809 {
00810 test_errors = 0;
00811 ret = dispatch_test( cnt, params );
00812 }
00813
00814 if( skip == 1 || ret == 3 )
00815 {
00816 total_skipped++;
00817 fprintf( stdout, "----\n" );
00818 fflush( stdout );
00819 }
00820 else if( ret == 0 && test_errors == 0 )
00821 {
00822 fprintf( stdout, "PASS\n" );
00823 fflush( stdout );
00824 }
00825 else if( ret == 2 )
00826 {
00827 fprintf( stderr, "FAILED: FATAL PARSE ERROR\n" );
00828 fclose(file);
00829 exit( 2 );
00830 }
00831 else
00832 total_errors++;
00833
00834 if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
00835 break;
00836 if( strlen(buf) != 0 )
00837 {
00838 fprintf( stderr, "Should be empty %d\n", (int) strlen(buf) );
00839 return( 1 );
00840 }
00841 }
00842 fclose(file);
00843
00844 fprintf( stdout, "\n----------------------------------------------------------------------------\n\n");
00845 if( total_errors == 0 )
00846 fprintf( stdout, "PASSED" );
00847 else
00848 fprintf( stdout, "FAILED" );
00849
00850 fprintf( stdout, " (%d / %d tests (%d skipped))\n",
00851 total_tests - total_errors, total_tests, total_skipped );
00852
00853 #if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
00854 #if defined(POLARSSL_MEMORY_DEBUG)
00855 memory_buffer_alloc_status();
00856 #endif
00857 memory_buffer_alloc_free();
00858 #endif
00859
00860 return( total_errors != 0 );
00861 }
00862
00863