[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[freetype2-demos] master d8db386: [ftlint] Render and calculate MD5 chec
|
From: |
Werner Lemberg |
|
Subject: |
[freetype2-demos] master d8db386: [ftlint] Render and calculate MD5 checksum. |
|
Date: |
Sun, 13 Jun 2021 00:01:31 -0400 (EDT) |
branch: master
commit d8db386cc85bb5043a8b9d528e0082936a45f300
Author: Sarthak Bhardwaj <1sarthakbhardwaj@gmail.com>
Commit: Alexei Podtelezhnikov <apodtele@gmail.com>
[ftlint] Render and calculate MD5 checksum.
* src/ftlint.c (main): Handle the load flags and the render mode from
the command line.
(Checksum): Calculate MD5 sum.
* src/md5.c, src/md5.h: MD5 source code.
* Makefile, messon.build: Update the build systems.
Co-authored-by: Sarthak Bhardwaj <1sarthakbhardwaj@gmail.com>
Co-authored-by: Anurag Thakur <devanuragthakur@gmail.com>
---
ChangeLog | 11 +++
Makefile | 2 +
meson.build | 2 +
src/ftlint.c | 129 ++++++++++++++++++++++----
src/md5.c | 291 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
src/md5.h | 45 +++++++++
6 files changed, 460 insertions(+), 20 deletions(-)
diff --git a/ChangeLog b/ChangeLog
index 2c865d8..3159acd 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,14 @@
+2021-06-13 Sarthak Bhardwaj <1sarthakbhardwaj@gmail.com>
+ Anurag Thakur <devanuragthakur@gmail.com>
+
+ [ftlint] Render and calculate MD5 checksum.
+
+ * src/ftlint.c (main): Handle the load flags and the render mode from
+ the command line.
+ (Checksum): Calculate MD5 sum.
+ * src/md5.c, src/md5.h: MD5 source code.
+ * Makefile, messon.build: Update the build systems.
+
2021-06-06 Anuj Verma <anujv@iitbhilai.ac.in>
[ftsdf] Synchronize with the change made in the `sdf` renderer.
diff --git a/Makefile b/Makefile
index bb7ac85..ece0aa8 100644
--- a/Makefile
+++ b/Makefile
@@ -345,10 +345,12 @@ else
$(OBJ_DIR_2)/common.$(SO): $(SRC_DIR)/common.c
$(OBJ_DIR_2)/strbuf.$(SO): $(SRC_DIR)/strbuf.c
$(OBJ_DIR_2)/output.$(SO): $(SRC_DIR)/output.c
+ $(OBJ_DIR_2)/md5.$(SO): $(SRC_DIR)/md5.c
$(OBJ_DIR_2)/mlgetopt.$(SO): $(SRC_DIR)/mlgetopt.c
COMMON_OBJ := $(OBJ_DIR_2)/common.$(SO) \
$(OBJ_DIR_2)/strbuf.$(SO) \
$(OBJ_DIR_2)/output.$(SO) \
+ $(OBJ_DIR_2)/md5.$(SO) \
$(OBJ_DIR_2)/mlgetopt.$(SO)
$(OBJ_DIR_2)/ftcommon.$(SO): $(SRC_DIR)/ftcommon.c $(SRC_DIR)/ftcommon.h
diff --git a/meson.build b/meson.build
index c316429..ae4d6df 100644
--- a/meson.build
+++ b/meson.build
@@ -41,6 +41,8 @@ common_files = files([
'src/common.h',
'src/strbuf.c',
'src/strbuf.h',
+ 'src/md5.c',
+ 'src/md5.h',
])
# Use `mlgetopt.h` on non-Unix platforms.
diff --git a/src/ftlint.c b/src/ftlint.c
index a6c1d03..9944f5d 100644
--- a/src/ftlint.c
+++ b/src/ftlint.c
@@ -6,7 +6,7 @@
/* D. Turner, R.Wilhelm, and W. Lemberg */
/* */
/* ftlint: a simple font tester. This program tries to load all the */
-/* glyphs of a given font. */
+/* glyphs of a given font, render them, and calculate MD5. */
/* */
/* NOTE: This is just a test program that is used to show off and */
/* debug the current engine. */
@@ -14,20 +14,30 @@
/****************************************************************************/
#include <ft2build.h>
-#include FT_FREETYPE_H
+#include <freetype/freetype.h>
+#include <freetype/ftbitmap.h>
+
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include "md5.h"
-#define xxTEST_PSNAMES
+#ifdef UNIX
+#include <unistd.h>
+#else
+#include "mlgetopt.h"
+#endif
- static FT_Error error;
+#define xxTEST_PSNAMES
- static FT_Library library;
- static FT_Face face;
+ static FT_Error error;
+ static FT_Library library;
+ static FT_Face face;
+ static FT_Render_Mode render_mode = FT_RENDER_MODE_NORMAL;
+ static FT_Int32 load_flags = FT_LOAD_DEFAULT;
static unsigned int num_glyphs;
static int ptsize;
@@ -41,8 +51,11 @@
printf( "ftlint: simple font tester -- part of the FreeType project\n" );
printf( "----------------------------------------------------------\n" );
printf( "\n" );
- printf( "Usage: %s ppem fontname[.ttf|.ttc] [fontname2..]\n", name );
+ printf( "Usage: %s [options] ppem fontname[.ttf|.ttc] [fontname2..]\n",
+ name );
printf( "\n" );
+ printf( " -f L Use hex number L as load flags (see `FT_LOAD_XXX').\n" );
+ printf( " -r N Set render mode to N\n" );
exit( 1 );
}
@@ -55,6 +68,43 @@
exit(1);
}
+ static void
+ Checksum( FT_GlyphSlot glyph )
+ {
+ FT_Bitmap bitmap;
+ FT_Error err;
+ FT_Bitmap_Init( &bitmap );
+
+
+ printf( "#%u ", glyph->glyph_index );
+
+ err = FT_Bitmap_Convert( library, &glyph->bitmap, &bitmap, 1 );
+ if ( !err )
+ {
+ MD5_CTX ctx;
+ unsigned char md5[16];
+ int i;
+ int rows = (int)bitmap.rows;
+ int pitch = bitmap.pitch;
+
+ MD5_Init( &ctx );
+ if ( bitmap.buffer )
+ MD5_Update( &ctx, bitmap.buffer,
+ (unsigned long)rows * (unsigned long)pitch );
+ MD5_Final( md5, &ctx );
+
+ for ( i = 0; i < 16; i++ )
+ {
+ printf( "%02X", md5[i] );
+ }
+ printf( "\n" );
+ }
+ else
+ printf("Error generating checksums\n");
+
+ FT_Bitmap_Done( library, &bitmap );
+ }
+
int
main( int argc,
@@ -65,6 +115,7 @@
char filename[1024];
char* execname;
char* fname;
+ int opt;
execname = argv[0];
@@ -72,22 +123,56 @@
if ( argc < 3 )
Usage( execname );
- if ( sscanf( argv[1], "%d", &ptsize ) != 1 )
+ while ( ( opt = getopt( argc, argv, "f:r:") ) != -1)
+ {
+
+ switch ( opt )
+ {
+
+ case 'f':
+ load_flags = strtol( optarg, NULL, 16 );
+ break;
+
+ case 'r':
+ {
+ int rm = atoi( optarg );
+
+
+ if ( rm < 0 || rm >= FT_RENDER_MODE_MAX )
+ render_mode = FT_RENDER_MODE_NORMAL;
+ else
+ render_mode = (FT_Render_Mode)rm;
+ }
+ break;
+
+ default:
+ Usage( execname );
+ break;
+ }
+ }
+
+ argc -= optind;
+ argv += optind;
+
+
+ if( sscanf( argv[0], "%d", &ptsize) != 1)
Usage( execname );
error = FT_Init_FreeType( &library );
- if (error) Panic( "Could not create library object" );
+ if ( error )
+ Panic( "Could not create library object" );
+
/* Now check all files */
- for ( file_index = 2; file_index < argc; file_index++ )
+ for ( file_index = 1; file_index < argc; file_index++ )
{
fname = argv[file_index];
/* try to open the file with no extra extension first */
error = FT_New_Face( library, fname, 0, &face );
- if (!error)
+ if ( !error )
{
- printf( "%s: ", fname );
+ printf( "%s: \n", fname );
goto Success;
}
@@ -132,7 +217,7 @@
else
i--;
- printf( "%s: ", fname );
+ printf( "%s: \n", fname );
/* Load face */
error = FT_New_Face( library, filename, 0, &face );
@@ -158,29 +243,33 @@
#endif
error = FT_Set_Char_Size( face, ptsize << 6, ptsize << 6, 72, 72 );
- if (error) Panic( "Could not set character size" );
+ if ( error )
+ Panic( "Could not set character size" );
Fail = 0;
{
for ( id = 0; id < num_glyphs; id++ )
{
- error = FT_Load_Glyph( face, id, FT_LOAD_DEFAULT );
- if (error)
+ error = FT_Load_Glyph( face, id, load_flags );
+ if ( error )
{
if ( Fail < 10 )
printf( "glyph %4u: 0x%04x\n" , id, error );
Fail++;
+ continue;
}
+
+ FT_Render_Glyph( face->glyph, render_mode );
+ Checksum( face->glyph );
}
}
if ( Fail == 0 )
printf( "OK.\n" );
+ else if ( Fail == 1 )
+ printf( "1 fail.\n" );
else
- if ( Fail == 1 )
- printf( "1 fail.\n" );
- else
- printf( "%d fails.\n", Fail );
+ printf( "%d fails.\n", Fail );
FT_Done_Face( face );
}
diff --git a/src/md5.c b/src/md5.c
new file mode 100644
index 0000000..b235e17
--- /dev/null
+++ b/src/md5.c
@@ -0,0 +1,291 @@
+/*
+ * This is an OpenSSL-compatible implementation of the RSA Data Security, Inc.
+ * MD5 Message-Digest Algorithm (RFC 1321).
+ *
+ * Homepage:
+ *
http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5
+ *
+ * Author:
+ * Alexander Peslyak, better known as Solar Designer <solar at openwall.com>
+ *
+ * This software was written by Alexander Peslyak in 2001. No copyright is
+ * claimed, and the software is hereby placed in the public domain.
+ * In case this attempt to disclaim copyright and place the software in the
+ * public domain is deemed null and void, then the software is
+ * Copyright (c) 2001 Alexander Peslyak and it is hereby released to the
+ * general public under the following terms:
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted.
+ *
+ * There's ABSOLUTELY NO WARRANTY, express or implied.
+ *
+ * (This is a heavily cut-down "BSD license".)
+ *
+ * This differs from Colin Plumb's older public domain implementation in that
+ * no exactly 32-bit integer data type is required (any 32-bit or wider
+ * unsigned integer data type will do), there's no compile-time endianness
+ * configuration, and the function prototypes match OpenSSL's. No code from
+ * Colin Plumb's implementation has been reused; this comment merely compares
+ * the properties of the two independent implementations.
+ *
+ * The primary goals of this implementation are portability and ease of use.
+ * It is meant to be fast, but not as fast as possible. Some known
+ * optimizations are not included to reduce source code size and avoid
+ * compile-time configuration.
+ */
+
+#ifndef HAVE_OPENSSL
+
+#include <string.h>
+
+#include "md5.h"
+
+/*
+ * The basic MD5 functions.
+ *
+ * F and G are optimized compared to their RFC 1321 definitions for
+ * architectures that lack an AND-NOT instruction, just like in Colin Plumb's
+ * implementation.
+ */
+#define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))
+#define G(x, y, z) ((y) ^ ((z) & ((x) ^ (y))))
+#define H(x, y, z) (((x) ^ (y)) ^ (z))
+#define H2(x, y, z) ((x) ^ ((y) ^ (z)))
+#define I(x, y, z) ((y) ^ ((x) | ~(z)))
+
+/*
+ * The MD5 transformation for all four rounds.
+ */
+#define STEP(f, a, b, c, d, x, t, s) \
+ (a) += f((b), (c), (d)) + (x) + (t); \
+ (a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \
+ (a) += (b);
+
+/*
+ * SET reads 4 input bytes in little-endian byte order and stores them in a
+ * properly aligned word in host byte order.
+ *
+ * The check for little-endian architectures that tolerate unaligned memory
+ * accesses is just an optimization. Nothing will break if it fails to detect
+ * a suitable architecture.
+ *
+ * Unfortunately, this optimization may be a C strict aliasing rules violation
+ * if the caller's data buffer has effective type that cannot be aliased by
+ * MD5_u32plus. In practice, this problem may occur if these MD5 routines are
+ * inlined into a calling function, or with future and dangerously advanced
+ * link-time optimizations. For the time being, keeping these MD5 routines in
+ * their own translation unit avoids the problem.
+ */
+#if defined(__i386__) || defined(__x86_64__) || defined(__vax__)
+#define SET(n) \
+ (*(MD5_u32plus *)&ptr[(n) * 4])
+#define GET(n) \
+ SET(n)
+#else
+#define SET(n) \
+ (ctx->block[(n)] = \
+ (MD5_u32plus)ptr[(n) * 4] | \
+ ((MD5_u32plus)ptr[(n) * 4 + 1] << 8) | \
+ ((MD5_u32plus)ptr[(n) * 4 + 2] << 16) | \
+ ((MD5_u32plus)ptr[(n) * 4 + 3] << 24))
+#define GET(n) \
+ (ctx->block[(n)])
+#endif
+
+/*
+ * This processes one or more 64-byte data blocks, but does NOT update the bit
+ * counters. There are no alignment requirements.
+ */
+static const void *body(MD5_CTX *ctx, const void *data, unsigned long size)
+{
+ const unsigned char *ptr;
+ MD5_u32plus a, b, c, d;
+ MD5_u32plus saved_a, saved_b, saved_c, saved_d;
+
+ ptr = (const unsigned char *)data;
+
+ a = ctx->a;
+ b = ctx->b;
+ c = ctx->c;
+ d = ctx->d;
+
+ do {
+ saved_a = a;
+ saved_b = b;
+ saved_c = c;
+ saved_d = d;
+
+/* Round 1 */
+ STEP(F, a, b, c, d, SET(0), 0xd76aa478, 7)
+ STEP(F, d, a, b, c, SET(1), 0xe8c7b756, 12)
+ STEP(F, c, d, a, b, SET(2), 0x242070db, 17)
+ STEP(F, b, c, d, a, SET(3), 0xc1bdceee, 22)
+ STEP(F, a, b, c, d, SET(4), 0xf57c0faf, 7)
+ STEP(F, d, a, b, c, SET(5), 0x4787c62a, 12)
+ STEP(F, c, d, a, b, SET(6), 0xa8304613, 17)
+ STEP(F, b, c, d, a, SET(7), 0xfd469501, 22)
+ STEP(F, a, b, c, d, SET(8), 0x698098d8, 7)
+ STEP(F, d, a, b, c, SET(9), 0x8b44f7af, 12)
+ STEP(F, c, d, a, b, SET(10), 0xffff5bb1, 17)
+ STEP(F, b, c, d, a, SET(11), 0x895cd7be, 22)
+ STEP(F, a, b, c, d, SET(12), 0x6b901122, 7)
+ STEP(F, d, a, b, c, SET(13), 0xfd987193, 12)
+ STEP(F, c, d, a, b, SET(14), 0xa679438e, 17)
+ STEP(F, b, c, d, a, SET(15), 0x49b40821, 22)
+
+/* Round 2 */
+ STEP(G, a, b, c, d, GET(1), 0xf61e2562, 5)
+ STEP(G, d, a, b, c, GET(6), 0xc040b340, 9)
+ STEP(G, c, d, a, b, GET(11), 0x265e5a51, 14)
+ STEP(G, b, c, d, a, GET(0), 0xe9b6c7aa, 20)
+ STEP(G, a, b, c, d, GET(5), 0xd62f105d, 5)
+ STEP(G, d, a, b, c, GET(10), 0x02441453, 9)
+ STEP(G, c, d, a, b, GET(15), 0xd8a1e681, 14)
+ STEP(G, b, c, d, a, GET(4), 0xe7d3fbc8, 20)
+ STEP(G, a, b, c, d, GET(9), 0x21e1cde6, 5)
+ STEP(G, d, a, b, c, GET(14), 0xc33707d6, 9)
+ STEP(G, c, d, a, b, GET(3), 0xf4d50d87, 14)
+ STEP(G, b, c, d, a, GET(8), 0x455a14ed, 20)
+ STEP(G, a, b, c, d, GET(13), 0xa9e3e905, 5)
+ STEP(G, d, a, b, c, GET(2), 0xfcefa3f8, 9)
+ STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14)
+ STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20)
+
+/* Round 3 */
+ STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4)
+ STEP(H2, d, a, b, c, GET(8), 0x8771f681, 11)
+ STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16)
+ STEP(H2, b, c, d, a, GET(14), 0xfde5380c, 23)
+ STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4)
+ STEP(H2, d, a, b, c, GET(4), 0x4bdecfa9, 11)
+ STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16)
+ STEP(H2, b, c, d, a, GET(10), 0xbebfbc70, 23)
+ STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4)
+ STEP(H2, d, a, b, c, GET(0), 0xeaa127fa, 11)
+ STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16)
+ STEP(H2, b, c, d, a, GET(6), 0x04881d05, 23)
+ STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4)
+ STEP(H2, d, a, b, c, GET(12), 0xe6db99e5, 11)
+ STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16)
+ STEP(H2, b, c, d, a, GET(2), 0xc4ac5665, 23)
+
+/* Round 4 */
+ STEP(I, a, b, c, d, GET(0), 0xf4292244, 6)
+ STEP(I, d, a, b, c, GET(7), 0x432aff97, 10)
+ STEP(I, c, d, a, b, GET(14), 0xab9423a7, 15)
+ STEP(I, b, c, d, a, GET(5), 0xfc93a039, 21)
+ STEP(I, a, b, c, d, GET(12), 0x655b59c3, 6)
+ STEP(I, d, a, b, c, GET(3), 0x8f0ccc92, 10)
+ STEP(I, c, d, a, b, GET(10), 0xffeff47d, 15)
+ STEP(I, b, c, d, a, GET(1), 0x85845dd1, 21)
+ STEP(I, a, b, c, d, GET(8), 0x6fa87e4f, 6)
+ STEP(I, d, a, b, c, GET(15), 0xfe2ce6e0, 10)
+ STEP(I, c, d, a, b, GET(6), 0xa3014314, 15)
+ STEP(I, b, c, d, a, GET(13), 0x4e0811a1, 21)
+ STEP(I, a, b, c, d, GET(4), 0xf7537e82, 6)
+ STEP(I, d, a, b, c, GET(11), 0xbd3af235, 10)
+ STEP(I, c, d, a, b, GET(2), 0x2ad7d2bb, 15)
+ STEP(I, b, c, d, a, GET(9), 0xeb86d391, 21)
+
+ a += saved_a;
+ b += saved_b;
+ c += saved_c;
+ d += saved_d;
+
+ ptr += 64;
+ } while (size -= 64);
+
+ ctx->a = a;
+ ctx->b = b;
+ ctx->c = c;
+ ctx->d = d;
+
+ return ptr;
+}
+
+void MD5_Init(MD5_CTX *ctx)
+{
+ ctx->a = 0x67452301;
+ ctx->b = 0xefcdab89;
+ ctx->c = 0x98badcfe;
+ ctx->d = 0x10325476;
+
+ ctx->lo = 0;
+ ctx->hi = 0;
+}
+
+void MD5_Update(MD5_CTX *ctx, const void *data, unsigned long size)
+{
+ MD5_u32plus saved_lo;
+ unsigned long used, available;
+
+ saved_lo = ctx->lo;
+ if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo)
+ ctx->hi++;
+ ctx->hi += size >> 29;
+
+ used = saved_lo & 0x3f;
+
+ if (used) {
+ available = 64 - used;
+
+ if (size < available) {
+ memcpy(&ctx->buffer[used], data, size);
+ return;
+ }
+
+ memcpy(&ctx->buffer[used], data, available);
+ data = (const unsigned char *)data + available;
+ size -= available;
+ body(ctx, ctx->buffer, 64);
+ }
+
+ if (size >= 64) {
+ data = body(ctx, data, size & ~(unsigned long)0x3f);
+ size &= 0x3f;
+ }
+
+ memcpy(ctx->buffer, data, size);
+}
+
+#define OUT(dst, src) \
+ (dst)[0] = (unsigned char)(src); \
+ (dst)[1] = (unsigned char)((src) >> 8); \
+ (dst)[2] = (unsigned char)((src) >> 16); \
+ (dst)[3] = (unsigned char)((src) >> 24);
+
+void MD5_Final(unsigned char *result, MD5_CTX *ctx)
+{
+ unsigned long used, available;
+
+ used = ctx->lo & 0x3f;
+
+ ctx->buffer[used++] = 0x80;
+
+ available = 64 - used;
+
+ if (available < 8) {
+ memset(&ctx->buffer[used], 0, available);
+ body(ctx, ctx->buffer, 64);
+ used = 0;
+ available = 64;
+ }
+
+ memset(&ctx->buffer[used], 0, available - 8);
+
+ ctx->lo <<= 3;
+ OUT(&ctx->buffer[56], ctx->lo)
+ OUT(&ctx->buffer[60], ctx->hi)
+
+ body(ctx, ctx->buffer, 64);
+
+ OUT(&result[0], ctx->a)
+ OUT(&result[4], ctx->b)
+ OUT(&result[8], ctx->c)
+ OUT(&result[12], ctx->d)
+
+ memset(ctx, 0, sizeof(*ctx));
+}
+
+#endif
diff --git a/src/md5.h b/src/md5.h
new file mode 100644
index 0000000..2da44bf
--- /dev/null
+++ b/src/md5.h
@@ -0,0 +1,45 @@
+/*
+ * This is an OpenSSL-compatible implementation of the RSA Data Security, Inc.
+ * MD5 Message-Digest Algorithm (RFC 1321).
+ *
+ * Homepage:
+ *
http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5
+ *
+ * Author:
+ * Alexander Peslyak, better known as Solar Designer <solar at openwall.com>
+ *
+ * This software was written by Alexander Peslyak in 2001. No copyright is
+ * claimed, and the software is hereby placed in the public domain.
+ * In case this attempt to disclaim copyright and place the software in the
+ * public domain is deemed null and void, then the software is
+ * Copyright (c) 2001 Alexander Peslyak and it is hereby released to the
+ * general public under the following terms:
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted.
+ *
+ * There's ABSOLUTELY NO WARRANTY, express or implied.
+ *
+ * See md5.c for more information.
+ */
+
+#ifdef HAVE_OPENSSL
+#include <openssl/md5.h>
+#elif !defined(_MD5_H)
+#define _MD5_H
+
+/* Any 32-bit or wider unsigned integer data type will do */
+typedef unsigned int MD5_u32plus;
+
+typedef struct {
+ MD5_u32plus lo, hi;
+ MD5_u32plus a, b, c, d;
+ unsigned char buffer[64];
+ MD5_u32plus block[16];
+} MD5_CTX;
+
+extern void MD5_Init(MD5_CTX *ctx);
+extern void MD5_Update(MD5_CTX *ctx, const void *data, unsigned long size);
+extern void MD5_Final(unsigned char *result, MD5_CTX *ctx);
+
+#endif
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [freetype2-demos] master d8db386: [ftlint] Render and calculate MD5 checksum.,
Werner Lemberg <=