/* Functions to compute MD2 message digest of files or memory blocks.
according to the definition of MD2 in RFC 1319 from April 1992.
- Copyright (C) 1995,1996,1997,1999,2000,2001,2002,2003,2005,2006
- Free Software Foundation, Inc.
+ Copyright (C) 1995-1997, 1999-2003, 2005-2006, 2008-2011 Free Software
+ Foundation, Inc.
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
#include "md2.h"
+#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
# include "unlocked-io.h"
#endif
-#define BLOCKSIZE 4096
+#define BLOCKSIZE 32768
#if BLOCKSIZE % 64 != 0
# error "invalid BLOCKSIZE"
#endif
}
/* Put result from CTX in first 16 bytes following RESBUF. The result
- must be in little endian byte order.
-
- IMPORTANT: On some systems it is required that RESBUF is correctly
- aligned for a 32 bits value. */
+ must be in little endian byte order. */
void *
md2_read_ctx (const struct md2_ctx *ctx, void *resbuf)
{
}
/* Process the remaining bytes in the internal buffer and the usual
- prolog according to the standard and write the result to RESBUF.
-
- IMPORTANT: On some systems it is required that RESBUF is correctly
- aligned for a 32 bits value. */
+ prolog according to the standard and write the result to RESBUF. */
void *
md2_finish_ctx (struct md2_ctx *ctx, void *resbuf)
{
md2_stream (FILE *stream, void *resblock)
{
struct md2_ctx ctx;
- char buffer[BLOCKSIZE + 72];
size_t sum;
+ char *buffer = malloc (BLOCKSIZE + 72);
+ if (!buffer)
+ return 1;
+
/* Initialize the computation context. */
md2_init_ctx (&ctx);
/* Read block. Take care for partial reads. */
while (1)
- {
- n = fread (buffer + sum, 1, BLOCKSIZE - sum, stream);
-
- sum += n;
-
- if (sum == BLOCKSIZE)
- break;
-
- if (n == 0)
- {
- /* Check for the error flag IFF N == 0, so that we don't
- exit the loop after a partial read due to e.g., EAGAIN
- or EWOULDBLOCK. */
- if (ferror (stream))
- return 1;
- goto process_partial_block;
- }
-
- /* We've read at least one byte, so ignore errors. But always
- check for EOF, since feof may be true even though N > 0.
- Otherwise, we could end up calling fread after EOF. */
- if (feof (stream))
- goto process_partial_block;
- }
+ {
+ n = fread (buffer + sum, 1, BLOCKSIZE - sum, stream);
+
+ sum += n;
+
+ if (sum == BLOCKSIZE)
+ break;
+
+ if (n == 0)
+ {
+ /* Check for the error flag IFF N == 0, so that we don't
+ exit the loop after a partial read due to e.g., EAGAIN
+ or EWOULDBLOCK. */
+ if (ferror (stream))
+ {
+ free (buffer);
+ return 1;
+ }
+ goto process_partial_block;
+ }
+
+ /* We've read at least one byte, so ignore errors. But always
+ check for EOF, since feof may be true even though N > 0.
+ Otherwise, we could end up calling fread after EOF. */
+ if (feof (stream))
+ goto process_partial_block;
+ }
/* Process buffer with BLOCKSIZE bytes. Note that
BLOCKSIZE % 64 == 0
/* Construct result in desired memory. */
md2_finish_ctx (&ctx, resblock);
+ free (buffer);
return 0;
}
/* is 16 bytes full? */
if (ctx->curlen == 16)
- {
- md2_compress (ctx);
- md2_update_chksum (ctx);
- ctx->curlen = 0;
- }
+ {
+ md2_compress (ctx);
+ md2_update_chksum (ctx);
+ ctx->curlen = 0;
+ }
}
}
for (j = 0; j < 18; j++)
{
for (k = 0; k < 48; k++)
- {
- t = (ctx->X[k] ^= PI_SUBST[(int) (t & 255)]);
- }
+ {
+ t = (ctx->X[k] ^= PI_SUBST[(int) (t & 255)]);
+ }
t = (t + (unsigned char) j) & 255;
}
}