openstack/liberasurecode
Code Issues Proposed changes

Use spaces for code indent, instead of tabs

Browse Source 
Some files use tabs instead of spaces for indent. Even some other
files use both of tabs and spaces which is quite confusing.

This updates all *.c files and *.h files to use spaces consistently.
Note that indent width is still inconsistent (2 vs 4), which may be
fixed later.

Change-Id: I7c0b2629785bfbaf3d0a06d8d81aa29c00168083
This commit is contained in:
Takashi Kajinami 2024-01-27 12:54:00 +09:00
parent ee1d5548b4
commit ca2caab1ad
4 changed files with 313 additions and 316 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
include/erasurecode/md5.h
View File

@ -32,10 +32,10 @@
typedef unsigned int MD5_u32plus; typedef unsigned int MD5_u32plus;
typedef struct { typedef struct {
MD5_u32plus lo, hi; MD5_u32plus lo, hi;
MD5_u32plus a, b, c, d; MD5_u32plus a, b, c, d;
unsigned char buffer[64]; unsigned char buffer[64];
MD5_u32plus block[16]; MD5_u32plus block[16];
} MD5_CTX; } MD5_CTX;
extern void MD5_Init(MD5_CTX *ctx); extern void MD5_Init(MD5_CTX *ctx);

276
src/builtin/xor_codes/xor_hd_code.c
View File

@ -254,149 +254,149 @@ int xor_hd_fragments_needed(xor_code_t *code_desc, int *fragments_to_reconstruct
pattern = get_failure_pattern(code_desc, missing_idxs); pattern = get_failure_pattern(code_desc, missing_idxs);
switch(pattern) { switch(pattern) {
case FAIL_PATTERN_0D_0P: case FAIL_PATTERN_0D_0P:
break; break;
case FAIL_PATTERN_1D_0P: case FAIL_PATTERN_1D_0P:
{ {
int *missing_data = get_missing_data(code_desc, missing_idxs); int *missing_data = get_missing_data(code_desc, missing_idxs);
ret = fragments_needed_one_data(code_desc, missing_data, NULL, &data_bm, &parity_bm); ret = fragments_needed_one_data(code_desc, missing_data, NULL, &data_bm, &parity_bm);
free(missing_data); free(missing_data);
break; break;
} }
case FAIL_PATTERN_2D_0P: case FAIL_PATTERN_2D_0P:
{ {
int *missing_data = get_missing_data(code_desc, missing_idxs); int *missing_data = get_missing_data(code_desc, missing_idxs);
ret = fragments_needed_two_data(code_desc, missing_data, NULL, &data_bm, &parity_bm); ret = fragments_needed_two_data(code_desc, missing_data, NULL, &data_bm, &parity_bm);
free(missing_data); free(missing_data);
break; break;
} }
case FAIL_PATTERN_3D_0P: case FAIL_PATTERN_3D_0P:
{ {
int *missing_data = get_missing_data(code_desc, missing_idxs); int *missing_data = get_missing_data(code_desc, missing_idxs);
ret = fragments_needed_three_data(code_desc, missing_data, NULL, &data_bm, &parity_bm); ret = fragments_needed_three_data(code_desc, missing_data, NULL, &data_bm, &parity_bm);
free(missing_data); free(missing_data);
break; break;
} }
case FAIL_PATTERN_1D_1P: case FAIL_PATTERN_1D_1P:
{ {
int *missing_data = get_missing_data(code_desc, missing_idxs); int *missing_data = get_missing_data(code_desc, missing_idxs);
int *missing_parity = get_missing_parity(code_desc, missing_idxs); int *missing_parity = get_missing_parity(code_desc, missing_idxs);
unsigned int missing_data_bm = missing_elements_bm(code_desc, missing_data, data_bit_lookup); unsigned int missing_data_bm = missing_elements_bm(code_desc, missing_data, data_bit_lookup);
ret = fragments_needed_one_data(code_desc, missing_data, missing_parity, &data_bm, &parity_bm); ret = fragments_needed_one_data(code_desc, missing_data, missing_parity, &data_bm, &parity_bm);
// OR all parities // OR all parities
i=0; i=0;
while (missing_parity[i] > -1) { while (missing_parity[i] > -1) {
data_bm |= code_desc->parity_bms[missing_parity[i]-code_desc->k]; data_bm |= code_desc->parity_bms[missing_parity[i]-code_desc->k];
data_bm &= ~(missing_data_bm); data_bm &= ~(missing_data_bm);
i++; i++;
} }
free(missing_parity); free(missing_parity);
free(missing_data); free(missing_data);
break; break;
} }
case FAIL_PATTERN_1D_2P: case FAIL_PATTERN_1D_2P:
{ {
int *missing_data = get_missing_data(code_desc, missing_idxs); int *missing_data = get_missing_data(code_desc, missing_idxs);
int *missing_parity = get_missing_parity(code_desc, missing_idxs); int *missing_parity = get_missing_parity(code_desc, missing_idxs);
int missing_data_bm = missing_elements_bm(code_desc, missing_data, data_bit_lookup); int missing_data_bm = missing_elements_bm(code_desc, missing_data, data_bit_lookup);
ret = fragments_needed_one_data(code_desc, missing_data, missing_parity, &data_bm, &parity_bm); ret = fragments_needed_one_data(code_desc, missing_data, missing_parity, &data_bm, &parity_bm);
// OR all parities // OR all parities
i=0; i=0;
while (missing_parity[i] > -1) { while (missing_parity[i] > -1) {
data_bm |= code_desc->parity_bms[missing_parity[i]-code_desc->k]; data_bm |= code_desc->parity_bms[missing_parity[i]-code_desc->k];
data_bm &= ~(missing_data_bm); data_bm &= ~(missing_data_bm);
i++; i++;
} }
free(missing_parity); free(missing_parity);
free(missing_data); free(missing_data);
break; break;
} }
case FAIL_PATTERN_2D_1P: case FAIL_PATTERN_2D_1P:
{ {
int *missing_data = get_missing_data(code_desc, missing_idxs); int *missing_data = get_missing_data(code_desc, missing_idxs);
int *missing_parity = get_missing_parity(code_desc, missing_idxs); int *missing_parity = get_missing_parity(code_desc, missing_idxs);
unsigned int missing_data_bm = missing_elements_bm(code_desc, missing_data, data_bit_lookup); unsigned int missing_data_bm = missing_elements_bm(code_desc, missing_data, data_bit_lookup);
ret = fragments_needed_two_data(code_desc, missing_data, missing_parity, &data_bm, &parity_bm); ret = fragments_needed_two_data(code_desc, missing_data, missing_parity, &data_bm, &parity_bm);
// OR all parities // OR all parities
i=0; i=0;
while (missing_parity[i] > -1) { while (missing_parity[i] > -1) {
data_bm |= code_desc->parity_bms[missing_parity[i]-code_desc->k]; data_bm |= code_desc->parity_bms[missing_parity[i]-code_desc->k];
data_bm &= ~(missing_data_bm); data_bm &= ~(missing_data_bm);
i++; i++;
} }
free(missing_parity); free(missing_parity);
free(missing_data); free(missing_data);
break; break;
} }
case FAIL_PATTERN_0D_1P: case FAIL_PATTERN_0D_1P:
{ {
int *missing_parity = get_missing_parity(code_desc, missing_idxs); int *missing_parity = get_missing_parity(code_desc, missing_idxs);
// OR all of the parities // OR all of the parities
i=0; i=0;
while (missing_parity[i] > -1) { while (missing_parity[i] > -1) {
data_bm |= code_desc->parity_bms[missing_parity[i]-code_desc->k]; data_bm |= code_desc->parity_bms[missing_parity[i]-code_desc->k];
i++; i++;
} }
free(missing_parity); free(missing_parity);
ret = 0; ret = 0;
break; break;
} }
case FAIL_PATTERN_0D_2P: case FAIL_PATTERN_0D_2P:
{ {
int *missing_parity = get_missing_parity(code_desc, missing_idxs); int *missing_parity = get_missing_parity(code_desc, missing_idxs);
// OR all of the parities // OR all of the parities
i=0; i=0;
while (missing_parity[i] > -1) { while (missing_parity[i] > -1) {
data_bm |= code_desc->parity_bms[missing_parity[i]-code_desc->k]; data_bm |= code_desc->parity_bms[missing_parity[i]-code_desc->k];
i++; i++;
} }
free(missing_parity); free(missing_parity);
ret = 0; ret = 0;
break; break;
} }
case FAIL_PATTERN_0D_3P: case FAIL_PATTERN_0D_3P:
{ {
int *missing_parity = get_missing_parity(code_desc, missing_idxs); int *missing_parity = get_missing_parity(code_desc, missing_idxs);
// OR all of the parities // OR all of the parities
i=0; i=0;
while (missing_parity[i] > -1) { while (missing_parity[i] > -1) {
data_bm |= code_desc->parity_bms[missing_parity[i]-code_desc->k]; data_bm |= code_desc->parity_bms[missing_parity[i]-code_desc->k];
i++; i++;
} }
free(missing_parity); free(missing_parity);
ret = 0; ret = 0;
break; break;
} }
case FAIL_PATTERN_GE_HD: case FAIL_PATTERN_GE_HD:
default: default:
break; break;
} }
} }
if (ret >= 0) { if (ret >= 0) {
i=0; i=0;
j=0; j=0;
while (data_bm) { while (data_bm) {
if (data_bm & 1) { if (data_bm & 1) {
fragments_needed[j] = i; fragments_needed[j] = i;
j++; j++;
} }
i++; i++;
data_bm >>= 1; data_bm >>= 1;
} }
i=0; i=0;
while (parity_bm) { while (parity_bm) {
if (parity_bm & 1) { if (parity_bm & 1) {
fragments_needed[j] = i + code_desc->k; fragments_needed[j] = i + code_desc->k;
j++; j++;
} }
i++; i++;
parity_bm >>= 1; parity_bm >>= 1;
} }
fragments_needed[j] = -1; fragments_needed[j] = -1;
} }
out: out:

2
src/erasurecode_helpers.c
View File

@ -201,7 +201,7 @@ int get_aligned_data_size(ec_backend_t instance, int data_len)
} }
aligned_size = ((data_len + alignment_multiple - 1) / alignment_multiple) aligned_size = ((data_len + alignment_multiple - 1) / alignment_multiple)
* alignment_multiple; * alignment_multiple;
return aligned_size; return aligned_size;
} }

343
src/utils/chksum/md5.c
View File

@ -48,18 +48,18 @@
* architectures that lack an AND-NOT instruction, just like in Colin Plumb's * architectures that lack an AND-NOT instruction, just like in Colin Plumb's
* implementation. * implementation.
*/ */
#define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z)))) #define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))
#define G(x, y, z) ((y) ^ ((z) & ((x) ^ (y)))) #define G(x, y, z) ((y) ^ ((z) & ((x) ^ (y))))
#define H(x, y, z) ((x) ^ (y) ^ (z)) #define H(x, y, z) ((x) ^ (y) ^ (z))
#define I(x, y, z) ((y) ^ ((x) | ~(z))) #define I(x, y, z) ((y) ^ ((x) | ~(z)))
/* /*
* The MD5 transformation for all four rounds. * The MD5 transformation for all four rounds.
*/ */
#define STEP(f, a, b, c, d, x, t, s) \ #define STEP(f, a, b, c, d, x, t, s) \
(a) += f((b), (c), (d)) + (x) + (t); \ (a) += f((b), (c), (d)) + (x) + (t); \
(a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \ (a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \
(a) += (b); (a) += (b);
/* /*
* SET reads 4 input bytes in little-endian byte order and stores them * SET reads 4 input bytes in little-endian byte order and stores them
@ -70,19 +70,16 @@
* doesn't work. * doesn't work.
*/ */
#if defined(__i386__) || defined(__x86_64__) || defined(__vax__) #if defined(__i386__) || defined(__x86_64__) || defined(__vax__)
#define SET(n) \ #define SET(n) (*(MD5_u32plus *)&ptr[(n) * 4])
(*(MD5_u32plus *)&ptr[(n) * 4]) #define GET(n) SET(n)
#define GET(n) \
SET(n)
#else #else
#define SET(n) \ #define SET(n) \
(ctx->block[(n)] = \ (ctx->block[(n)] = \
(MD5_u32plus)ptr[(n) * 4] | \ (MD5_u32plus)ptr[(n) * 4] | \
((MD5_u32plus)ptr[(n) * 4 + 1] << 8) | \ ((MD5_u32plus)ptr[(n) * 4 + 1] << 8) | \
((MD5_u32plus)ptr[(n) * 4 + 2] << 16) | \ ((MD5_u32plus)ptr[(n) * 4 + 2] << 16) | \
((MD5_u32plus)ptr[(n) * 4 + 3] << 24)) ((MD5_u32plus)ptr[(n) * 4 + 3] << 24))
#define GET(n) \ #define GET(n) (ctx->block[(n)])
(ctx->block[(n)])
#endif #endif
/* /*
@ -91,205 +88,205 @@
*/ */
static void *body(MD5_CTX *ctx, void *data, unsigned long size) static void *body(MD5_CTX *ctx, void *data, unsigned long size)
{ {
unsigned char *ptr; unsigned char *ptr;
MD5_u32plus a, b, c, d; MD5_u32plus a, b, c, d;
MD5_u32plus saved_a, saved_b, saved_c, saved_d; MD5_u32plus saved_a, saved_b, saved_c, saved_d;
ptr = data; ptr = data;
a = ctx->a; a = ctx->a;
b = ctx->b; b = ctx->b;
c = ctx->c; c = ctx->c;
d = ctx->d; d = ctx->d;
do { do {
saved_a = a; saved_a = a;
saved_b = b; saved_b = b;
saved_c = c; saved_c = c;
saved_d = d; saved_d = d;
/* Round 1 */ /* Round 1 */
STEP(F, a, b, c, d, SET(0), 0xd76aa478, 7) STEP(F, a, b, c, d, SET(0), 0xd76aa478, 7)
STEP(F, d, a, b, c, SET(1), 0xe8c7b756, 12) STEP(F, d, a, b, c, SET(1), 0xe8c7b756, 12)
STEP(F, c, d, a, b, SET(2), 0x242070db, 17) STEP(F, c, d, a, b, SET(2), 0x242070db, 17)
STEP(F, b, c, d, a, SET(3), 0xc1bdceee, 22) STEP(F, b, c, d, a, SET(3), 0xc1bdceee, 22)
STEP(F, a, b, c, d, SET(4), 0xf57c0faf, 7) STEP(F, a, b, c, d, SET(4), 0xf57c0faf, 7)
STEP(F, d, a, b, c, SET(5), 0x4787c62a, 12) STEP(F, d, a, b, c, SET(5), 0x4787c62a, 12)
STEP(F, c, d, a, b, SET(6), 0xa8304613, 17) STEP(F, c, d, a, b, SET(6), 0xa8304613, 17)
STEP(F, b, c, d, a, SET(7), 0xfd469501, 22) STEP(F, b, c, d, a, SET(7), 0xfd469501, 22)
STEP(F, a, b, c, d, SET(8), 0x698098d8, 7) STEP(F, a, b, c, d, SET(8), 0x698098d8, 7)
STEP(F, d, a, b, c, SET(9), 0x8b44f7af, 12) STEP(F, d, a, b, c, SET(9), 0x8b44f7af, 12)
STEP(F, c, d, a, b, SET(10), 0xffff5bb1, 17) STEP(F, c, d, a, b, SET(10), 0xffff5bb1, 17)
STEP(F, b, c, d, a, SET(11), 0x895cd7be, 22) STEP(F, b, c, d, a, SET(11), 0x895cd7be, 22)
STEP(F, a, b, c, d, SET(12), 0x6b901122, 7) STEP(F, a, b, c, d, SET(12), 0x6b901122, 7)
STEP(F, d, a, b, c, SET(13), 0xfd987193, 12) STEP(F, d, a, b, c, SET(13), 0xfd987193, 12)
STEP(F, c, d, a, b, SET(14), 0xa679438e, 17) STEP(F, c, d, a, b, SET(14), 0xa679438e, 17)
STEP(F, b, c, d, a, SET(15), 0x49b40821, 22) STEP(F, b, c, d, a, SET(15), 0x49b40821, 22)
/* Round 2 */ /* Round 2 */
STEP(G, a, b, c, d, GET(1), 0xf61e2562, 5) STEP(G, a, b, c, d, GET(1), 0xf61e2562, 5)
STEP(G, d, a, b, c, GET(6), 0xc040b340, 9) STEP(G, d, a, b, c, GET(6), 0xc040b340, 9)
STEP(G, c, d, a, b, GET(11), 0x265e5a51, 14) STEP(G, c, d, a, b, GET(11), 0x265e5a51, 14)
STEP(G, b, c, d, a, GET(0), 0xe9b6c7aa, 20) STEP(G, b, c, d, a, GET(0), 0xe9b6c7aa, 20)
STEP(G, a, b, c, d, GET(5), 0xd62f105d, 5) STEP(G, a, b, c, d, GET(5), 0xd62f105d, 5)
STEP(G, d, a, b, c, GET(10), 0x02441453, 9) STEP(G, d, a, b, c, GET(10), 0x02441453, 9)
STEP(G, c, d, a, b, GET(15), 0xd8a1e681, 14) STEP(G, c, d, a, b, GET(15), 0xd8a1e681, 14)
STEP(G, b, c, d, a, GET(4), 0xe7d3fbc8, 20) STEP(G, b, c, d, a, GET(4), 0xe7d3fbc8, 20)
STEP(G, a, b, c, d, GET(9), 0x21e1cde6, 5) STEP(G, a, b, c, d, GET(9), 0x21e1cde6, 5)
STEP(G, d, a, b, c, GET(14), 0xc33707d6, 9) STEP(G, d, a, b, c, GET(14), 0xc33707d6, 9)
STEP(G, c, d, a, b, GET(3), 0xf4d50d87, 14) STEP(G, c, d, a, b, GET(3), 0xf4d50d87, 14)
STEP(G, b, c, d, a, GET(8), 0x455a14ed, 20) STEP(G, b, c, d, a, GET(8), 0x455a14ed, 20)
STEP(G, a, b, c, d, GET(13), 0xa9e3e905, 5) STEP(G, a, b, c, d, GET(13), 0xa9e3e905, 5)
STEP(G, d, a, b, c, GET(2), 0xfcefa3f8, 9) STEP(G, d, a, b, c, GET(2), 0xfcefa3f8, 9)
STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14) STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14)
STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20) STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20)
/* Round 3 */ /* Round 3 */
STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4) STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4)
STEP(H, d, a, b, c, GET(8), 0x8771f681, 11) STEP(H, d, a, b, c, GET(8), 0x8771f681, 11)
STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16) STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16)
STEP(H, b, c, d, a, GET(14), 0xfde5380c, 23) STEP(H, b, c, d, a, GET(14), 0xfde5380c, 23)
STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4) STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4)
STEP(H, d, a, b, c, GET(4), 0x4bdecfa9, 11) STEP(H, d, a, b, c, GET(4), 0x4bdecfa9, 11)
STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16) STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16)
STEP(H, b, c, d, a, GET(10), 0xbebfbc70, 23) STEP(H, b, c, d, a, GET(10), 0xbebfbc70, 23)
STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4) STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4)
STEP(H, d, a, b, c, GET(0), 0xeaa127fa, 11) STEP(H, d, a, b, c, GET(0), 0xeaa127fa, 11)
STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16) STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16)
STEP(H, b, c, d, a, GET(6), 0x04881d05, 23) STEP(H, b, c, d, a, GET(6), 0x04881d05, 23)
STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4) STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4)
STEP(H, d, a, b, c, GET(12), 0xe6db99e5, 11) STEP(H, d, a, b, c, GET(12), 0xe6db99e5, 11)
STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16) STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16)
STEP(H, b, c, d, a, GET(2), 0xc4ac5665, 23) STEP(H, b, c, d, a, GET(2), 0xc4ac5665, 23)
/* Round 4 */ /* Round 4 */
STEP(I, a, b, c, d, GET(0), 0xf4292244, 6) STEP(I, a, b, c, d, GET(0), 0xf4292244, 6)
STEP(I, d, a, b, c, GET(7), 0x432aff97, 10) STEP(I, d, a, b, c, GET(7), 0x432aff97, 10)
STEP(I, c, d, a, b, GET(14), 0xab9423a7, 15) STEP(I, c, d, a, b, GET(14), 0xab9423a7, 15)
STEP(I, b, c, d, a, GET(5), 0xfc93a039, 21) STEP(I, b, c, d, a, GET(5), 0xfc93a039, 21)
STEP(I, a, b, c, d, GET(12), 0x655b59c3, 6) STEP(I, a, b, c, d, GET(12), 0x655b59c3, 6)
STEP(I, d, a, b, c, GET(3), 0x8f0ccc92, 10) STEP(I, d, a, b, c, GET(3), 0x8f0ccc92, 10)
STEP(I, c, d, a, b, GET(10), 0xffeff47d, 15) STEP(I, c, d, a, b, GET(10), 0xffeff47d, 15)
STEP(I, b, c, d, a, GET(1), 0x85845dd1, 21) STEP(I, b, c, d, a, GET(1), 0x85845dd1, 21)
STEP(I, a, b, c, d, GET(8), 0x6fa87e4f, 6) STEP(I, a, b, c, d, GET(8), 0x6fa87e4f, 6)
STEP(I, d, a, b, c, GET(15), 0xfe2ce6e0, 10) STEP(I, d, a, b, c, GET(15), 0xfe2ce6e0, 10)
STEP(I, c, d, a, b, GET(6), 0xa3014314, 15) STEP(I, c, d, a, b, GET(6), 0xa3014314, 15)
STEP(I, b, c, d, a, GET(13), 0x4e0811a1, 21) STEP(I, b, c, d, a, GET(13), 0x4e0811a1, 21)
STEP(I, a, b, c, d, GET(4), 0xf7537e82, 6) STEP(I, a, b, c, d, GET(4), 0xf7537e82, 6)
STEP(I, d, a, b, c, GET(11), 0xbd3af235, 10) STEP(I, d, a, b, c, GET(11), 0xbd3af235, 10)
STEP(I, c, d, a, b, GET(2), 0x2ad7d2bb, 15) STEP(I, c, d, a, b, GET(2), 0x2ad7d2bb, 15)
STEP(I, b, c, d, a, GET(9), 0xeb86d391, 21) STEP(I, b, c, d, a, GET(9), 0xeb86d391, 21)
a += saved_a; a += saved_a;
b += saved_b; b += saved_b;
c += saved_c; c += saved_c;
d += saved_d; d += saved_d;
ptr += 64; ptr += 64;
} while (size -= 64); } while (size -= 64);
ctx->a = a; ctx->a = a;
ctx->b = b; ctx->b = b;
ctx->c = c; ctx->c = c;
ctx->d = d; ctx->d = d;
return ptr; return ptr;
} }
void MD5_Init(MD5_CTX *ctx) void MD5_Init(MD5_CTX *ctx)
{ {
ctx->a = 0x67452301; ctx->a = 0x67452301;
ctx->b = 0xefcdab89; ctx->b = 0xefcdab89;
ctx->c = 0x98badcfe; ctx->c = 0x98badcfe;
ctx->d = 0x10325476; ctx->d = 0x10325476;
ctx->lo = 0; ctx->lo = 0;
ctx->hi = 0; ctx->hi = 0;
} }
void MD5_Update(MD5_CTX *ctx, void *data, unsigned long size) void MD5_Update(MD5_CTX *ctx, void *data, unsigned long size)
{ {
MD5_u32plus saved_lo; MD5_u32plus saved_lo;
unsigned long used, free; unsigned long used, free;
saved_lo = ctx->lo; saved_lo = ctx->lo;
if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo) if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo)
ctx->hi++; ctx->hi++;
ctx->hi += size >> 29; ctx->hi += size >> 29;
used = saved_lo & 0x3f; used = saved_lo & 0x3f;
if (used) { if (used) {
free = 64 - used; free = 64 - used;
if (size < free) { if (size < free) {
memcpy(&ctx->buffer[used], data, size); memcpy(&ctx->buffer[used], data, size);
return; return;
} }
memcpy(&ctx->buffer[used], data, free); memcpy(&ctx->buffer[used], data, free);
data = (unsigned char *)data + free; data = (unsigned char *)data + free;
size -= free; size -= free;
body(ctx, ctx->buffer, 64); body(ctx, ctx->buffer, 64);
} }
if (size >= 64) { if (size >= 64) {
data = body(ctx, data, size & ~(unsigned long)0x3f); data = body(ctx, data, size & ~(unsigned long)0x3f);
size &= 0x3f; size &= 0x3f;
} }
memcpy(ctx->buffer, data, size); memcpy(ctx->buffer, data, size);
} }
void MD5_Final(unsigned char *result, MD5_CTX *ctx) void MD5_Final(unsigned char *result, MD5_CTX *ctx)
{ {
unsigned long used, free; unsigned long used, free;
used = ctx->lo & 0x3f; used = ctx->lo & 0x3f;
ctx->buffer[used++] = 0x80; ctx->buffer[used++] = 0x80;
free = 64 - used; free = 64 - used;
if (free < 8) { if (free < 8) {
memset(&ctx->buffer[used], 0, free); memset(&ctx->buffer[used], 0, free);
body(ctx, ctx->buffer, 64); body(ctx, ctx->buffer, 64);
used = 0; used = 0;
free = 64; free = 64;
} }
memset(&ctx->buffer[used], 0, free - 8); memset(&ctx->buffer[used], 0, free - 8);
ctx->lo <<= 3; ctx->lo <<= 3;
ctx->buffer[56] = ctx->lo; ctx->buffer[56] = ctx->lo;
ctx->buffer[57] = ctx->lo >> 8; ctx->buffer[57] = ctx->lo >> 8;
ctx->buffer[58] = ctx->lo >> 16; ctx->buffer[58] = ctx->lo >> 16;
ctx->buffer[59] = ctx->lo >> 24; ctx->buffer[59] = ctx->lo >> 24;
ctx->buffer[60] = ctx->hi; ctx->buffer[60] = ctx->hi;
ctx->buffer[61] = ctx->hi >> 8; ctx->buffer[61] = ctx->hi >> 8;
ctx->buffer[62] = ctx->hi >> 16; ctx->buffer[62] = ctx->hi >> 16;
ctx->buffer[63] = ctx->hi >> 24; ctx->buffer[63] = ctx->hi >> 24;
body(ctx, ctx->buffer, 64); body(ctx, ctx->buffer, 64);
result[0] = ctx->a; result[0] = ctx->a;
result[1] = ctx->a >> 8; result[1] = ctx->a >> 8;
result[2] = ctx->a >> 16; result[2] = ctx->a >> 16;
result[3] = ctx->a >> 24; result[3] = ctx->a >> 24;
result[4] = ctx->b; result[4] = ctx->b;
result[5] = ctx->b >> 8; result[5] = ctx->b >> 8;
result[6] = ctx->b >> 16; result[6] = ctx->b >> 16;
result[7] = ctx->b >> 24; result[7] = ctx->b >> 24;
result[8] = ctx->c; result[8] = ctx->c;
result[9] = ctx->c >> 8; result[9] = ctx->c >> 8;
result[10] = ctx->c >> 16; result[10] = ctx->c >> 16;
result[11] = ctx->c >> 24; result[11] = ctx->c >> 24;
result[12] = ctx->d; result[12] = ctx->d;
result[13] = ctx->d >> 8; result[13] = ctx->d >> 8;
result[14] = ctx->d >> 16; result[14] = ctx->d >> 16;
result[15] = ctx->d >> 24; result[15] = ctx->d >> 24;
memset(ctx, 0, sizeof(*ctx)); memset(ctx, 0, sizeof(*ctx));
} }
#endif #endif