00001
00030 #include "polarssl/config.h"
00031
00032 #if defined(POLARSSL_MD_C)
00033
00034 #include "polarssl/md_wrap.h"
00035
00036 #if defined(POLARSSL_MD2_C)
00037 #include "polarssl/md2.h"
00038 #endif
00039
00040 #if defined(POLARSSL_MD4_C)
00041 #include "polarssl/md4.h"
00042 #endif
00043
00044 #if defined(POLARSSL_MD5_C)
00045 #include "polarssl/md5.h"
00046 #endif
00047
00048 #if defined(POLARSSL_SHA1_C)
00049 #include "polarssl/sha1.h"
00050 #endif
00051
00052 #if defined(POLARSSL_SHA256_C)
00053 #include "polarssl/sha256.h"
00054 #endif
00055
00056 #if defined(POLARSSL_SHA512_C)
00057 #include "polarssl/sha512.h"
00058 #endif
00059
00060 #if defined(POLARSSL_MEMORY_C)
00061 #include "polarssl/memory.h"
00062 #else
00063 #define polarssl_malloc malloc
00064 #define polarssl_free free
00065 #endif
00066
00067 #include <stdlib.h>
00068
00069 #if defined(POLARSSL_MD2_C)
00070
00071 static void md2_starts_wrap( void *ctx )
00072 {
00073 md2_starts( (md2_context *) ctx );
00074 }
00075
00076 static void md2_update_wrap( void *ctx, const unsigned char *input, size_t ilen )
00077 {
00078 md2_update( (md2_context *) ctx, input, ilen );
00079 }
00080
00081 static void md2_finish_wrap( void *ctx, unsigned char *output )
00082 {
00083 md2_finish( (md2_context *) ctx, output );
00084 }
00085
00086 static int md2_file_wrap( const char *path, unsigned char *output )
00087 {
00088 #if defined(POLARSSL_FS_IO)
00089 return md2_file( path, output );
00090 #else
00091 ((void) path);
00092 ((void) output);
00093 return POLARSSL_ERR_MD_FEATURE_UNAVAILABLE;
00094 #endif
00095 }
00096
00097 static void md2_hmac_starts_wrap( void *ctx, const unsigned char *key, size_t keylen )
00098 {
00099 md2_hmac_starts( (md2_context *) ctx, key, keylen );
00100 }
00101
00102 static void md2_hmac_update_wrap( void *ctx, const unsigned char *input, size_t ilen )
00103 {
00104 md2_hmac_update( (md2_context *) ctx, input, ilen );
00105 }
00106
00107 static void md2_hmac_finish_wrap( void *ctx, unsigned char *output )
00108 {
00109 md2_hmac_finish( (md2_context *) ctx, output );
00110 }
00111
00112 static void md2_hmac_reset_wrap( void *ctx )
00113 {
00114 md2_hmac_reset( (md2_context *) ctx );
00115 }
00116
00117 static void * md2_ctx_alloc( void )
00118 {
00119 return polarssl_malloc( sizeof( md2_context ) );
00120 }
00121
00122 static void md2_ctx_free( void *ctx )
00123 {
00124 polarssl_free( ctx );
00125 }
00126
00127 static void md2_process_wrap( void *ctx, const unsigned char *data )
00128 {
00129 ((void) data);
00130
00131 md2_process( (md2_context *) ctx );
00132 }
00133
00134 const md_info_t md2_info = {
00135 POLARSSL_MD_MD2,
00136 "MD2",
00137 16,
00138 md2_starts_wrap,
00139 md2_update_wrap,
00140 md2_finish_wrap,
00141 md2,
00142 md2_file_wrap,
00143 md2_hmac_starts_wrap,
00144 md2_hmac_update_wrap,
00145 md2_hmac_finish_wrap,
00146 md2_hmac_reset_wrap,
00147 md2_hmac,
00148 md2_ctx_alloc,
00149 md2_ctx_free,
00150 md2_process_wrap,
00151 };
00152
00153 #endif
00154
00155 #if defined(POLARSSL_MD4_C)
00156
00157 static void md4_starts_wrap( void *ctx )
00158 {
00159 md4_starts( (md4_context *) ctx );
00160 }
00161
00162 static void md4_update_wrap( void *ctx, const unsigned char *input, size_t ilen )
00163 {
00164 md4_update( (md4_context *) ctx, input, ilen );
00165 }
00166
00167 static void md4_finish_wrap( void *ctx, unsigned char *output )
00168 {
00169 md4_finish( (md4_context *) ctx, output );
00170 }
00171
00172 static int md4_file_wrap( const char *path, unsigned char *output )
00173 {
00174 #if defined(POLARSSL_FS_IO)
00175 return md4_file( path, output );
00176 #else
00177 ((void) path);
00178 ((void) output);
00179 return POLARSSL_ERR_MD_FEATURE_UNAVAILABLE;
00180 #endif
00181 }
00182
00183 static void md4_hmac_starts_wrap( void *ctx, const unsigned char *key, size_t keylen )
00184 {
00185 md4_hmac_starts( (md4_context *) ctx, key, keylen );
00186 }
00187
00188 static void md4_hmac_update_wrap( void *ctx, const unsigned char *input, size_t ilen )
00189 {
00190 md4_hmac_update( (md4_context *) ctx, input, ilen );
00191 }
00192
00193 static void md4_hmac_finish_wrap( void *ctx, unsigned char *output )
00194 {
00195 md4_hmac_finish( (md4_context *) ctx, output );
00196 }
00197
00198 static void md4_hmac_reset_wrap( void *ctx )
00199 {
00200 md4_hmac_reset( (md4_context *) ctx );
00201 }
00202
00203 static void *md4_ctx_alloc( void )
00204 {
00205 return polarssl_malloc( sizeof( md4_context ) );
00206 }
00207
00208 static void md4_ctx_free( void *ctx )
00209 {
00210 polarssl_free( ctx );
00211 }
00212
00213 static void md4_process_wrap( void *ctx, const unsigned char *data )
00214 {
00215 md4_process( (md4_context *) ctx, data );
00216 }
00217
00218 const md_info_t md4_info = {
00219 POLARSSL_MD_MD4,
00220 "MD4",
00221 16,
00222 md4_starts_wrap,
00223 md4_update_wrap,
00224 md4_finish_wrap,
00225 md4,
00226 md4_file_wrap,
00227 md4_hmac_starts_wrap,
00228 md4_hmac_update_wrap,
00229 md4_hmac_finish_wrap,
00230 md4_hmac_reset_wrap,
00231 md4_hmac,
00232 md4_ctx_alloc,
00233 md4_ctx_free,
00234 md4_process_wrap,
00235 };
00236
00237 #endif
00238
00239 #if defined(POLARSSL_MD5_C)
00240
00241 static void md5_starts_wrap( void *ctx )
00242 {
00243 md5_starts( (md5_context *) ctx );
00244 }
00245
00246 static void md5_update_wrap( void *ctx, const unsigned char *input, size_t ilen )
00247 {
00248 md5_update( (md5_context *) ctx, input, ilen );
00249 }
00250
00251 static void md5_finish_wrap( void *ctx, unsigned char *output )
00252 {
00253 md5_finish( (md5_context *) ctx, output );
00254 }
00255
00256 static int md5_file_wrap( const char *path, unsigned char *output )
00257 {
00258 #if defined(POLARSSL_FS_IO)
00259 return md5_file( path, output );
00260 #else
00261 ((void) path);
00262 ((void) output);
00263 return POLARSSL_ERR_MD_FEATURE_UNAVAILABLE;
00264 #endif
00265 }
00266
00267 static void md5_hmac_starts_wrap( void *ctx, const unsigned char *key, size_t keylen )
00268 {
00269 md5_hmac_starts( (md5_context *) ctx, key, keylen );
00270 }
00271
00272 static void md5_hmac_update_wrap( void *ctx, const unsigned char *input, size_t ilen )
00273 {
00274 md5_hmac_update( (md5_context *) ctx, input, ilen );
00275 }
00276
00277 static void md5_hmac_finish_wrap( void *ctx, unsigned char *output )
00278 {
00279 md5_hmac_finish( (md5_context *) ctx, output );
00280 }
00281
00282 static void md5_hmac_reset_wrap( void *ctx )
00283 {
00284 md5_hmac_reset( (md5_context *) ctx );
00285 }
00286
00287 static void * md5_ctx_alloc( void )
00288 {
00289 return polarssl_malloc( sizeof( md5_context ) );
00290 }
00291
00292 static void md5_ctx_free( void *ctx )
00293 {
00294 polarssl_free( ctx );
00295 }
00296
00297 static void md5_process_wrap( void *ctx, const unsigned char *data )
00298 {
00299 md5_process( (md5_context *) ctx, data );
00300 }
00301
00302 const md_info_t md5_info = {
00303 POLARSSL_MD_MD5,
00304 "MD5",
00305 16,
00306 md5_starts_wrap,
00307 md5_update_wrap,
00308 md5_finish_wrap,
00309 md5,
00310 md5_file_wrap,
00311 md5_hmac_starts_wrap,
00312 md5_hmac_update_wrap,
00313 md5_hmac_finish_wrap,
00314 md5_hmac_reset_wrap,
00315 md5_hmac,
00316 md5_ctx_alloc,
00317 md5_ctx_free,
00318 md5_process_wrap,
00319 };
00320
00321 #endif
00322
00323 #if defined(POLARSSL_SHA1_C)
00324
00325 static void sha1_starts_wrap( void *ctx )
00326 {
00327 sha1_starts( (sha1_context *) ctx );
00328 }
00329
00330 static void sha1_update_wrap( void *ctx, const unsigned char *input, size_t ilen )
00331 {
00332 sha1_update( (sha1_context *) ctx, input, ilen );
00333 }
00334
00335 static void sha1_finish_wrap( void *ctx, unsigned char *output )
00336 {
00337 sha1_finish( (sha1_context *) ctx, output );
00338 }
00339
00340 static int sha1_file_wrap( const char *path, unsigned char *output )
00341 {
00342 #if defined(POLARSSL_FS_IO)
00343 return sha1_file( path, output );
00344 #else
00345 ((void) path);
00346 ((void) output);
00347 return POLARSSL_ERR_MD_FEATURE_UNAVAILABLE;
00348 #endif
00349 }
00350
00351 static void sha1_hmac_starts_wrap( void *ctx, const unsigned char *key, size_t keylen )
00352 {
00353 sha1_hmac_starts( (sha1_context *) ctx, key, keylen );
00354 }
00355
00356 static void sha1_hmac_update_wrap( void *ctx, const unsigned char *input, size_t ilen )
00357 {
00358 sha1_hmac_update( (sha1_context *) ctx, input, ilen );
00359 }
00360
00361 static void sha1_hmac_finish_wrap( void *ctx, unsigned char *output )
00362 {
00363 sha1_hmac_finish( (sha1_context *) ctx, output );
00364 }
00365
00366 static void sha1_hmac_reset_wrap( void *ctx )
00367 {
00368 sha1_hmac_reset( (sha1_context *) ctx );
00369 }
00370
00371 static void * sha1_ctx_alloc( void )
00372 {
00373 return polarssl_malloc( sizeof( sha1_context ) );
00374 }
00375
00376 static void sha1_ctx_free( void *ctx )
00377 {
00378 polarssl_free( ctx );
00379 }
00380
00381 static void sha1_process_wrap( void *ctx, const unsigned char *data )
00382 {
00383 sha1_process( (sha1_context *) ctx, data );
00384 }
00385
00386 const md_info_t sha1_info = {
00387 POLARSSL_MD_SHA1,
00388 "SHA1",
00389 20,
00390 sha1_starts_wrap,
00391 sha1_update_wrap,
00392 sha1_finish_wrap,
00393 sha1,
00394 sha1_file_wrap,
00395 sha1_hmac_starts_wrap,
00396 sha1_hmac_update_wrap,
00397 sha1_hmac_finish_wrap,
00398 sha1_hmac_reset_wrap,
00399 sha1_hmac,
00400 sha1_ctx_alloc,
00401 sha1_ctx_free,
00402 sha1_process_wrap,
00403 };
00404
00405 #endif
00406
00407
00408
00409
00410 #if defined(POLARSSL_SHA256_C)
00411
00412 static void sha224_starts_wrap( void *ctx )
00413 {
00414 sha256_starts( (sha256_context *) ctx, 1 );
00415 }
00416
00417 static void sha224_update_wrap( void *ctx, const unsigned char *input, size_t ilen )
00418 {
00419 sha256_update( (sha256_context *) ctx, input, ilen );
00420 }
00421
00422 static void sha224_finish_wrap( void *ctx, unsigned char *output )
00423 {
00424 sha256_finish( (sha256_context *) ctx, output );
00425 }
00426
00427 static void sha224_wrap( const unsigned char *input, size_t ilen,
00428 unsigned char *output )
00429 {
00430 sha256( input, ilen, output, 1 );
00431 }
00432
00433 static int sha224_file_wrap( const char *path, unsigned char *output )
00434 {
00435 #if defined(POLARSSL_FS_IO)
00436 return sha256_file( path, output, 1 );
00437 #else
00438 ((void) path);
00439 ((void) output);
00440 return POLARSSL_ERR_MD_FEATURE_UNAVAILABLE;
00441 #endif
00442 }
00443
00444 static void sha224_hmac_starts_wrap( void *ctx, const unsigned char *key, size_t keylen )
00445 {
00446 sha256_hmac_starts( (sha256_context *) ctx, key, keylen, 1 );
00447 }
00448
00449 static void sha224_hmac_update_wrap( void *ctx, const unsigned char *input, size_t ilen )
00450 {
00451 sha256_hmac_update( (sha256_context *) ctx, input, ilen );
00452 }
00453
00454 static void sha224_hmac_finish_wrap( void *ctx, unsigned char *output )
00455 {
00456 sha256_hmac_finish( (sha256_context *) ctx, output );
00457 }
00458
00459 static void sha224_hmac_reset_wrap( void *ctx )
00460 {
00461 sha256_hmac_reset( (sha256_context *) ctx );
00462 }
00463
00464 static void sha224_hmac_wrap( const unsigned char *key, size_t keylen,
00465 const unsigned char *input, size_t ilen,
00466 unsigned char *output )
00467 {
00468 sha256_hmac( key, keylen, input, ilen, output, 1 );
00469 }
00470
00471 static void * sha224_ctx_alloc( void )
00472 {
00473 return polarssl_malloc( sizeof( sha256_context ) );
00474 }
00475
00476 static void sha224_ctx_free( void *ctx )
00477 {
00478 polarssl_free( ctx );
00479 }
00480
00481 static void sha224_process_wrap( void *ctx, const unsigned char *data )
00482 {
00483 sha256_process( (sha256_context *) ctx, data );
00484 }
00485
00486 const md_info_t sha224_info = {
00487 POLARSSL_MD_SHA224,
00488 "SHA224",
00489 28,
00490 sha224_starts_wrap,
00491 sha224_update_wrap,
00492 sha224_finish_wrap,
00493 sha224_wrap,
00494 sha224_file_wrap,
00495 sha224_hmac_starts_wrap,
00496 sha224_hmac_update_wrap,
00497 sha224_hmac_finish_wrap,
00498 sha224_hmac_reset_wrap,
00499 sha224_hmac_wrap,
00500 sha224_ctx_alloc,
00501 sha224_ctx_free,
00502 sha224_process_wrap,
00503 };
00504
00505 static void sha256_starts_wrap( void *ctx )
00506 {
00507 sha256_starts( (sha256_context *) ctx, 0 );
00508 }
00509
00510 static void sha256_update_wrap( void *ctx, const unsigned char *input, size_t ilen )
00511 {
00512 sha256_update( (sha256_context *) ctx, input, ilen );
00513 }
00514
00515 static void sha256_finish_wrap( void *ctx, unsigned char *output )
00516 {
00517 sha256_finish( (sha256_context *) ctx, output );
00518 }
00519
00520 static void sha256_wrap( const unsigned char *input, size_t ilen,
00521 unsigned char *output )
00522 {
00523 sha256( input, ilen, output, 0 );
00524 }
00525
00526 static int sha256_file_wrap( const char *path, unsigned char *output )
00527 {
00528 #if defined(POLARSSL_FS_IO)
00529 return sha256_file( path, output, 0 );
00530 #else
00531 ((void) path);
00532 ((void) output);
00533 return POLARSSL_ERR_MD_FEATURE_UNAVAILABLE;
00534 #endif
00535 }
00536
00537 static void sha256_hmac_starts_wrap( void *ctx, const unsigned char *key, size_t keylen )
00538 {
00539 sha256_hmac_starts( (sha256_context *) ctx, key, keylen, 0 );
00540 }
00541
00542 static void sha256_hmac_update_wrap( void *ctx, const unsigned char *input, size_t ilen )
00543 {
00544 sha256_hmac_update( (sha256_context *) ctx, input, ilen );
00545 }
00546
00547 static void sha256_hmac_finish_wrap( void *ctx, unsigned char *output )
00548 {
00549 sha256_hmac_finish( (sha256_context *) ctx, output );
00550 }
00551
00552 static void sha256_hmac_reset_wrap( void *ctx )
00553 {
00554 sha256_hmac_reset( (sha256_context *) ctx );
00555 }
00556
00557 static void sha256_hmac_wrap( const unsigned char *key, size_t keylen,
00558 const unsigned char *input, size_t ilen,
00559 unsigned char *output )
00560 {
00561 sha256_hmac( key, keylen, input, ilen, output, 0 );
00562 }
00563
00564 static void * sha256_ctx_alloc( void )
00565 {
00566 return polarssl_malloc( sizeof( sha256_context ) );
00567 }
00568
00569 static void sha256_ctx_free( void *ctx )
00570 {
00571 polarssl_free( ctx );
00572 }
00573
00574 static void sha256_process_wrap( void *ctx, const unsigned char *data )
00575 {
00576 sha256_process( (sha256_context *) ctx, data );
00577 }
00578
00579 const md_info_t sha256_info = {
00580 POLARSSL_MD_SHA256,
00581 "SHA256",
00582 32,
00583 sha256_starts_wrap,
00584 sha256_update_wrap,
00585 sha256_finish_wrap,
00586 sha256_wrap,
00587 sha256_file_wrap,
00588 sha256_hmac_starts_wrap,
00589 sha256_hmac_update_wrap,
00590 sha256_hmac_finish_wrap,
00591 sha256_hmac_reset_wrap,
00592 sha256_hmac_wrap,
00593 sha256_ctx_alloc,
00594 sha256_ctx_free,
00595 sha256_process_wrap,
00596 };
00597
00598 #endif
00599
00600 #if defined(POLARSSL_SHA512_C)
00601
00602 static void sha384_starts_wrap( void *ctx )
00603 {
00604 sha512_starts( (sha512_context *) ctx, 1 );
00605 }
00606
00607 static void sha384_update_wrap( void *ctx, const unsigned char *input, size_t ilen )
00608 {
00609 sha512_update( (sha512_context *) ctx, input, ilen );
00610 }
00611
00612 static void sha384_finish_wrap( void *ctx, unsigned char *output )
00613 {
00614 sha512_finish( (sha512_context *) ctx, output );
00615 }
00616
00617 static void sha384_wrap( const unsigned char *input, size_t ilen,
00618 unsigned char *output )
00619 {
00620 sha512( input, ilen, output, 1 );
00621 }
00622
00623 static int sha384_file_wrap( const char *path, unsigned char *output )
00624 {
00625 #if defined(POLARSSL_FS_IO)
00626 return sha512_file( path, output, 1 );
00627 #else
00628 ((void) path);
00629 ((void) output);
00630 return POLARSSL_ERR_MD_FEATURE_UNAVAILABLE;
00631 #endif
00632 }
00633
00634 static void sha384_hmac_starts_wrap( void *ctx, const unsigned char *key, size_t keylen )
00635 {
00636 sha512_hmac_starts( (sha512_context *) ctx, key, keylen, 1 );
00637 }
00638
00639 static void sha384_hmac_update_wrap( void *ctx, const unsigned char *input, size_t ilen )
00640 {
00641 sha512_hmac_update( (sha512_context *) ctx, input, ilen );
00642 }
00643
00644 static void sha384_hmac_finish_wrap( void *ctx, unsigned char *output )
00645 {
00646 sha512_hmac_finish( (sha512_context *) ctx, output );
00647 }
00648
00649 static void sha384_hmac_reset_wrap( void *ctx )
00650 {
00651 sha512_hmac_reset( (sha512_context *) ctx );
00652 }
00653
00654 static void sha384_hmac_wrap( const unsigned char *key, size_t keylen,
00655 const unsigned char *input, size_t ilen,
00656 unsigned char *output )
00657 {
00658 sha512_hmac( key, keylen, input, ilen, output, 1 );
00659 }
00660
00661 static void * sha384_ctx_alloc( void )
00662 {
00663 return polarssl_malloc( sizeof( sha512_context ) );
00664 }
00665
00666 static void sha384_ctx_free( void *ctx )
00667 {
00668 polarssl_free( ctx );
00669 }
00670
00671 static void sha384_process_wrap( void *ctx, const unsigned char *data )
00672 {
00673 sha512_process( (sha512_context *) ctx, data );
00674 }
00675
00676 const md_info_t sha384_info = {
00677 POLARSSL_MD_SHA384,
00678 "SHA384",
00679 48,
00680 sha384_starts_wrap,
00681 sha384_update_wrap,
00682 sha384_finish_wrap,
00683 sha384_wrap,
00684 sha384_file_wrap,
00685 sha384_hmac_starts_wrap,
00686 sha384_hmac_update_wrap,
00687 sha384_hmac_finish_wrap,
00688 sha384_hmac_reset_wrap,
00689 sha384_hmac_wrap,
00690 sha384_ctx_alloc,
00691 sha384_ctx_free,
00692 sha384_process_wrap,
00693 };
00694
00695 static void sha512_starts_wrap( void *ctx )
00696 {
00697 sha512_starts( (sha512_context *) ctx, 0 );
00698 }
00699
00700 static void sha512_update_wrap( void *ctx, const unsigned char *input, size_t ilen )
00701 {
00702 sha512_update( (sha512_context *) ctx, input, ilen );
00703 }
00704
00705 static void sha512_finish_wrap( void *ctx, unsigned char *output )
00706 {
00707 sha512_finish( (sha512_context *) ctx, output );
00708 }
00709
00710 static void sha512_wrap( const unsigned char *input, size_t ilen,
00711 unsigned char *output )
00712 {
00713 sha512( input, ilen, output, 0 );
00714 }
00715
00716 static int sha512_file_wrap( const char *path, unsigned char *output )
00717 {
00718 #if defined(POLARSSL_FS_IO)
00719 return sha512_file( path, output, 0 );
00720 #else
00721 ((void) path);
00722 ((void) output);
00723 return POLARSSL_ERR_MD_FEATURE_UNAVAILABLE;
00724 #endif
00725 }
00726
00727 static void sha512_hmac_starts_wrap( void *ctx, const unsigned char *key, size_t keylen )
00728 {
00729 sha512_hmac_starts( (sha512_context *) ctx, key, keylen, 0 );
00730 }
00731
00732 static void sha512_hmac_update_wrap( void *ctx, const unsigned char *input, size_t ilen )
00733 {
00734 sha512_hmac_update( (sha512_context *) ctx, input, ilen );
00735 }
00736
00737 static void sha512_hmac_finish_wrap( void *ctx, unsigned char *output )
00738 {
00739 sha512_hmac_finish( (sha512_context *) ctx, output );
00740 }
00741
00742 static void sha512_hmac_reset_wrap( void *ctx )
00743 {
00744 sha512_hmac_reset( (sha512_context *) ctx );
00745 }
00746
00747 static void sha512_hmac_wrap( const unsigned char *key, size_t keylen,
00748 const unsigned char *input, size_t ilen,
00749 unsigned char *output )
00750 {
00751 sha512_hmac( key, keylen, input, ilen, output, 0 );
00752 }
00753
00754 static void * sha512_ctx_alloc( void )
00755 {
00756 return polarssl_malloc( sizeof( sha512_context ) );
00757 }
00758
00759 static void sha512_ctx_free( void *ctx )
00760 {
00761 polarssl_free( ctx );
00762 }
00763
00764 static void sha512_process_wrap( void *ctx, const unsigned char *data )
00765 {
00766 sha512_process( (sha512_context *) ctx, data );
00767 }
00768
00769 const md_info_t sha512_info = {
00770 POLARSSL_MD_SHA512,
00771 "SHA512",
00772 64,
00773 sha512_starts_wrap,
00774 sha512_update_wrap,
00775 sha512_finish_wrap,
00776 sha512_wrap,
00777 sha512_file_wrap,
00778 sha512_hmac_starts_wrap,
00779 sha512_hmac_update_wrap,
00780 sha512_hmac_finish_wrap,
00781 sha512_hmac_reset_wrap,
00782 sha512_hmac_wrap,
00783 sha512_ctx_alloc,
00784 sha512_ctx_free,
00785 sha512_process_wrap,
00786 };
00787
00788 #endif
00789
00790 #endif