diff --git a/python-libmount.changes b/python-libmount.changes index 41cc10d..891331f 100644 --- a/python-libmount.changes +++ b/python-libmount.changes @@ -1,3 +1,9 @@ +------------------------------------------------------------------- +Tue Jan 16 16:26:48 UTC 2018 - normand@linux.vnet.ibm.com + +- Add util_linux_bigendian.patch solve two failing tests on ppc64 + (sha1, uuid/oids) + ------------------------------------------------------------------- Fri Jan 12 13:49:36 CET 2018 - sbrabec@suse.com diff --git a/python-libmount.spec b/python-libmount.spec index 0054cb7..b356bb5 100644 --- a/python-libmount.spec +++ b/python-libmount.spec @@ -73,7 +73,7 @@ Name: python-libmount %endif Summary: %main_summary License: GPL-2.0+ -Group: %main_group +Group: %group_pl BuildRequires: audit-devel BuildRequires: bc BuildRequires: binutils-devel @@ -164,6 +164,9 @@ Patch1: util-linux-lsmem-memory-zone-1.patch Patch2: util-linux-lsmem-memory-zone-2.patch # PATCH-FEATURE-UPSTREAM util-linux-lsmem-memory-zone-3.patch bsc1065471 FATE324252 sbrabec@suse.com -- lsmem: Add support for zone awareness. Patch3: util-linux-lsmem-memory-zone-3.patch +# Add four commits from upstream to pass tests on ppc64 +Patch4: util_linux_bigendian.patch + BuildRoot: %{_tmppath}/%{name}-%{version}-build # %if %build_util_linux @@ -387,6 +390,7 @@ SMP systems. %if %build_util_linux %package -n python-libmount Summary: %summary_pl +License: GPL-2.0+ Group: %group_pl %description -n python-libmount @@ -403,6 +407,7 @@ library. %patch1 -p1 %patch2 -p1 %patch3 -p1 +%patch4 -p1 # # setctsid cp -p %{S:22} %{S:23} . diff --git a/util-linux-systemd.changes b/util-linux-systemd.changes index 41cc10d..891331f 100644 --- a/util-linux-systemd.changes +++ b/util-linux-systemd.changes @@ -1,3 +1,9 @@ +------------------------------------------------------------------- +Tue Jan 16 16:26:48 UTC 2018 - normand@linux.vnet.ibm.com + +- Add util_linux_bigendian.patch solve two failing tests on ppc64 + (sha1, uuid/oids) + ------------------------------------------------------------------- Fri Jan 12 13:49:36 CET 2018 - sbrabec@suse.com diff --git a/util-linux-systemd.spec b/util-linux-systemd.spec index b85327d..fd87b69 100644 --- a/util-linux-systemd.spec +++ b/util-linux-systemd.spec @@ -164,6 +164,9 @@ Patch1: util-linux-lsmem-memory-zone-1.patch Patch2: util-linux-lsmem-memory-zone-2.patch # PATCH-FEATURE-UPSTREAM util-linux-lsmem-memory-zone-3.patch bsc1065471 FATE324252 sbrabec@suse.com -- lsmem: Add support for zone awareness. Patch3: util-linux-lsmem-memory-zone-3.patch +# Add four commits from upstream to pass tests on ppc64 +Patch4: util_linux_bigendian.patch + BuildRoot: %{_tmppath}/%{name}-%{version}-build # %if %build_util_linux @@ -403,6 +406,7 @@ library. %patch1 -p1 %patch2 -p1 %patch3 -p1 +%patch4 -p1 # # setctsid cp -p %{S:22} %{S:23} . diff --git a/util-linux.changes b/util-linux.changes index 41cc10d..891331f 100644 --- a/util-linux.changes +++ b/util-linux.changes @@ -1,3 +1,9 @@ +------------------------------------------------------------------- +Tue Jan 16 16:26:48 UTC 2018 - normand@linux.vnet.ibm.com + +- Add util_linux_bigendian.patch solve two failing tests on ppc64 + (sha1, uuid/oids) + ------------------------------------------------------------------- Fri Jan 12 13:49:36 CET 2018 - sbrabec@suse.com diff --git a/util-linux.spec b/util-linux.spec index 1c2727a..c59f968 100644 --- a/util-linux.spec +++ b/util-linux.spec @@ -164,6 +164,9 @@ Patch1: util-linux-lsmem-memory-zone-1.patch Patch2: util-linux-lsmem-memory-zone-2.patch # PATCH-FEATURE-UPSTREAM util-linux-lsmem-memory-zone-3.patch bsc1065471 FATE324252 sbrabec@suse.com -- lsmem: Add support for zone awareness. Patch3: util-linux-lsmem-memory-zone-3.patch +# Add four commits from upstream to pass tests on ppc64 +Patch4: util_linux_bigendian.patch + BuildRoot: %{_tmppath}/%{name}-%{version}-build # %if %build_util_linux @@ -403,6 +406,7 @@ library. %patch1 -p1 %patch2 -p1 %patch3 -p1 +%patch4 -p1 # # setctsid cp -p %{S:22} %{S:23} . diff --git a/util_linux_bigendian.patch b/util_linux_bigendian.patch new file mode 100644 index 0000000..4de91ec --- /dev/null +++ b/util_linux_bigendian.patch @@ -0,0 +1,663 @@ +commit 3bd55be742aec60a93ebcdebc325b49737cd6642 +Author: Karel Zak +Date: Tue Dec 12 11:29:02 2017 +0100 + + lib/sha1: use ul_/UL_prefix for symbols + + Unfortunately, the symbols are visible in statically compiled libuuid + and the names are too generic. + + Addresses: https://github.com/karelzak/util-linux/issues/548 + Signed-off-by: Karel Zak + +commit b4db227582f1d0a14c7b63de8d57e6052b753d57 +Author: Karel Zak +Date: Tue Dec 12 11:38:17 2017 +0100 + + test_sha1: update helper + + Signed-off-by: Karel Zak + +commit 3ae2cb49d9a8c20de1892c691b7cc86f4deb280c +Author: Karel Zak +Date: Tue Dec 12 11:42:28 2017 +0100 + + lib/sha1: fix indention + + * indent -linux -psl -blf lib/sha1.c + * manually fix comments + + Signed-off-by: Karel Zak + +commit 4ff4b1106e8c6a71cce59ca40a2019342a92d47d +Author: Karel Zak +Date: Tue Jan 2 11:08:03 2018 +0100 + + lib/sha1: use proper WORDS_BIGENDIAN macro + + The original code uses BYTE_ORDER, but we use WORDS_BIGENDIAN in + utl-linux. + + Reported-by: Andreas Schwab + Signed-off-by: Karel Zak + +--- + include/sha1.h | 47 +---- + lib/sha1.c | 426 ++++++++++++++++++++-------------------------- + libuuid/src/gen_uuid.c | 12 - + tests/helpers/test_sha1.c | 12 - + 4 files changed, 219 insertions(+), 278 deletions(-) + +Index: util-linux-2.31/include/sha1.h +=================================================================== +--- util-linux-2.31.orig/include/sha1.h ++++ util-linux-2.31/include/sha1.h +@@ -1,5 +1,5 @@ +-#ifndef SHA1_H +-#define SHA1_H ++#ifndef UTIL_LINUX_SHA1_H ++#define UTIL_LINUX_SHA1_H + + /* + SHA-1 in C +@@ -9,38 +9,19 @@ + + #include "stdint.h" + +-#define SHA1LENGTH 20 ++#define UL_SHA1LENGTH 20 + + typedef struct + { +- uint32_t state[5]; +- uint32_t count[2]; +- unsigned char buffer[64]; +-} SHA1_CTX; +- +-void SHA1Transform( +- uint32_t state[5], +- const unsigned char buffer[64] +- ); +- +-void SHA1Init( +- SHA1_CTX * context +- ); +- +-void SHA1Update( +- SHA1_CTX * context, +- const unsigned char *data, +- uint32_t len +- ); +- +-void SHA1Final( +- unsigned char digest[SHA1LENGTH], +- SHA1_CTX * context +- ); +- +-void SHA1( +- char *hash_out, +- const char *str, +- unsigned len); ++ uint32_t state[5]; ++ uint32_t count[2]; ++ unsigned char buffer[64]; ++} UL_SHA1_CTX; ++ ++void ul_SHA1Transform(uint32_t state[5], const unsigned char buffer[64]); ++void ul_SHA1Init(UL_SHA1_CTX *context); ++void ul_SHA1Update(UL_SHA1_CTX *context, const unsigned char *data, uint32_t len); ++void ul_SHA1Final(unsigned char digest[UL_SHA1LENGTH], UL_SHA1_CTX *context); ++void ul_SHA1(char *hash_out, const char *str, unsigned len); + +-#endif /* SHA1_H */ ++#endif /* UTIL_LINUX_SHA1_H */ +Index: util-linux-2.31/lib/sha1.c +=================================================================== +--- util-linux-2.31.orig/lib/sha1.c ++++ util-linux-2.31/lib/sha1.c +@@ -1,43 +1,31 @@ + /* +-SHA-1 in C +-By Steve Reid +-100% Public Domain +- +-Test Vectors (from FIPS PUB 180-1) +-"abc" +- A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D +-"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" +- 84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1 +-A million repetitions of "a" +- 34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F +-*/ ++ * SHA-1 in C by Steve Reid ++ * 100% Public Domain ++ * ++ * Test Vectors (from FIPS PUB 180-1) ++ * 1) "abc": A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D ++ * 2) "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq": 84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1 ++ * 3) A million repetitions of "a": 34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F ++ */ + +-/* #define LITTLE_ENDIAN * This should be #define'd already, if true. */ +-/* #define SHA1HANDSOFF * Copies data before messing with it. */ +- +-#define SHA1HANDSOFF ++#define UL_SHA1HANDSOFF + + #include + #include +- +-/* for uint32_t */ + #include + + #include "sha1.h" + +- + #define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) + + /* blk0() and blk() perform the initial expand. */ +-/* I got the idea of expanding during the round function from SSLeay */ +-#if BYTE_ORDER == LITTLE_ENDIAN +-#define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \ +- |(rol(block->l[i],8)&0x00FF00FF)) +-#elif BYTE_ORDER == BIG_ENDIAN +-#define blk0(i) block->l[i] ++#ifdef WORDS_BIGENDIAN ++# define blk0(i) block->l[i] + #else +-#error "Endianness not defined!" ++# define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \ ++ |(rol(block->l[i],8)&0x00FF00FF)) + #endif ++ + #define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \ + ^block->l[(i+2)&15]^block->l[i&15],1)) + +@@ -48,249 +36,221 @@ A million repetitions of "a" + #define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30); + #define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30); + +- + /* Hash a single 512-bit block. This is the core of the algorithm. */ + +-void SHA1Transform( +- uint32_t state[5], +- const unsigned char buffer[64] +-) ++void ul_SHA1Transform(uint32_t state[5], const unsigned char buffer[64]) + { +- uint32_t a, b, c, d, e; ++ uint32_t a, b, c, d, e; + +- typedef union +- { +- unsigned char c[64]; +- uint32_t l[16]; +- } CHAR64LONG16; ++ typedef union { ++ unsigned char c[64]; ++ uint32_t l[16]; ++ } CHAR64LONG16; + +-#ifdef SHA1HANDSOFF +- CHAR64LONG16 block[1]; /* use array to appear as a pointer */ ++#ifdef UL_SHA1HANDSOFF ++ CHAR64LONG16 block[1]; /* use array to appear as a pointer */ + +- memcpy(block, buffer, 64); ++ memcpy(block, buffer, 64); + #else +- /* The following had better never be used because it causes the +- * pointer-to-const buffer to be cast into a pointer to non-const. +- * And the result is written through. I threw a "const" in, hoping +- * this will cause a diagnostic. +- */ +- CHAR64LONG16 *block = (const CHAR64LONG16 *) buffer; ++ /* The following had better never be used because it causes the ++ * pointer-to-const buffer to be cast into a pointer to non-const. ++ * And the result is written through. I threw a "const" in, hoping ++ * this will cause a diagnostic. ++ */ ++ CHAR64LONG16 *block = (const CHAR64LONG16 *)buffer; + #endif +- /* Copy context->state[] to working vars */ +- a = state[0]; +- b = state[1]; +- c = state[2]; +- d = state[3]; +- e = state[4]; +- /* 4 rounds of 20 operations each. Loop unrolled. */ +- R0(a, b, c, d, e, 0); +- R0(e, a, b, c, d, 1); +- R0(d, e, a, b, c, 2); +- R0(c, d, e, a, b, 3); +- R0(b, c, d, e, a, 4); +- R0(a, b, c, d, e, 5); +- R0(e, a, b, c, d, 6); +- R0(d, e, a, b, c, 7); +- R0(c, d, e, a, b, 8); +- R0(b, c, d, e, a, 9); +- R0(a, b, c, d, e, 10); +- R0(e, a, b, c, d, 11); +- R0(d, e, a, b, c, 12); +- R0(c, d, e, a, b, 13); +- R0(b, c, d, e, a, 14); +- R0(a, b, c, d, e, 15); +- R1(e, a, b, c, d, 16); +- R1(d, e, a, b, c, 17); +- R1(c, d, e, a, b, 18); +- R1(b, c, d, e, a, 19); +- R2(a, b, c, d, e, 20); +- R2(e, a, b, c, d, 21); +- R2(d, e, a, b, c, 22); +- R2(c, d, e, a, b, 23); +- R2(b, c, d, e, a, 24); +- R2(a, b, c, d, e, 25); +- R2(e, a, b, c, d, 26); +- R2(d, e, a, b, c, 27); +- R2(c, d, e, a, b, 28); +- R2(b, c, d, e, a, 29); +- R2(a, b, c, d, e, 30); +- R2(e, a, b, c, d, 31); +- R2(d, e, a, b, c, 32); +- R2(c, d, e, a, b, 33); +- R2(b, c, d, e, a, 34); +- R2(a, b, c, d, e, 35); +- R2(e, a, b, c, d, 36); +- R2(d, e, a, b, c, 37); +- R2(c, d, e, a, b, 38); +- R2(b, c, d, e, a, 39); +- R3(a, b, c, d, e, 40); +- R3(e, a, b, c, d, 41); +- R3(d, e, a, b, c, 42); +- R3(c, d, e, a, b, 43); +- R3(b, c, d, e, a, 44); +- R3(a, b, c, d, e, 45); +- R3(e, a, b, c, d, 46); +- R3(d, e, a, b, c, 47); +- R3(c, d, e, a, b, 48); +- R3(b, c, d, e, a, 49); +- R3(a, b, c, d, e, 50); +- R3(e, a, b, c, d, 51); +- R3(d, e, a, b, c, 52); +- R3(c, d, e, a, b, 53); +- R3(b, c, d, e, a, 54); +- R3(a, b, c, d, e, 55); +- R3(e, a, b, c, d, 56); +- R3(d, e, a, b, c, 57); +- R3(c, d, e, a, b, 58); +- R3(b, c, d, e, a, 59); +- R4(a, b, c, d, e, 60); +- R4(e, a, b, c, d, 61); +- R4(d, e, a, b, c, 62); +- R4(c, d, e, a, b, 63); +- R4(b, c, d, e, a, 64); +- R4(a, b, c, d, e, 65); +- R4(e, a, b, c, d, 66); +- R4(d, e, a, b, c, 67); +- R4(c, d, e, a, b, 68); +- R4(b, c, d, e, a, 69); +- R4(a, b, c, d, e, 70); +- R4(e, a, b, c, d, 71); +- R4(d, e, a, b, c, 72); +- R4(c, d, e, a, b, 73); +- R4(b, c, d, e, a, 74); +- R4(a, b, c, d, e, 75); +- R4(e, a, b, c, d, 76); +- R4(d, e, a, b, c, 77); +- R4(c, d, e, a, b, 78); +- R4(b, c, d, e, a, 79); +- /* Add the working vars back into context.state[] */ +- state[0] += a; +- state[1] += b; +- state[2] += c; +- state[3] += d; +- state[4] += e; +- /* Wipe variables */ +- a = b = c = d = e = 0; +-#ifdef SHA1HANDSOFF +- memset(block, '\0', sizeof(block)); ++ /* Copy context->state[] to working vars */ ++ a = state[0]; ++ b = state[1]; ++ c = state[2]; ++ d = state[3]; ++ e = state[4]; ++ /* 4 rounds of 20 operations each. Loop unrolled. */ ++ R0(a, b, c, d, e, 0); ++ R0(e, a, b, c, d, 1); ++ R0(d, e, a, b, c, 2); ++ R0(c, d, e, a, b, 3); ++ R0(b, c, d, e, a, 4); ++ R0(a, b, c, d, e, 5); ++ R0(e, a, b, c, d, 6); ++ R0(d, e, a, b, c, 7); ++ R0(c, d, e, a, b, 8); ++ R0(b, c, d, e, a, 9); ++ R0(a, b, c, d, e, 10); ++ R0(e, a, b, c, d, 11); ++ R0(d, e, a, b, c, 12); ++ R0(c, d, e, a, b, 13); ++ R0(b, c, d, e, a, 14); ++ R0(a, b, c, d, e, 15); ++ R1(e, a, b, c, d, 16); ++ R1(d, e, a, b, c, 17); ++ R1(c, d, e, a, b, 18); ++ R1(b, c, d, e, a, 19); ++ R2(a, b, c, d, e, 20); ++ R2(e, a, b, c, d, 21); ++ R2(d, e, a, b, c, 22); ++ R2(c, d, e, a, b, 23); ++ R2(b, c, d, e, a, 24); ++ R2(a, b, c, d, e, 25); ++ R2(e, a, b, c, d, 26); ++ R2(d, e, a, b, c, 27); ++ R2(c, d, e, a, b, 28); ++ R2(b, c, d, e, a, 29); ++ R2(a, b, c, d, e, 30); ++ R2(e, a, b, c, d, 31); ++ R2(d, e, a, b, c, 32); ++ R2(c, d, e, a, b, 33); ++ R2(b, c, d, e, a, 34); ++ R2(a, b, c, d, e, 35); ++ R2(e, a, b, c, d, 36); ++ R2(d, e, a, b, c, 37); ++ R2(c, d, e, a, b, 38); ++ R2(b, c, d, e, a, 39); ++ R3(a, b, c, d, e, 40); ++ R3(e, a, b, c, d, 41); ++ R3(d, e, a, b, c, 42); ++ R3(c, d, e, a, b, 43); ++ R3(b, c, d, e, a, 44); ++ R3(a, b, c, d, e, 45); ++ R3(e, a, b, c, d, 46); ++ R3(d, e, a, b, c, 47); ++ R3(c, d, e, a, b, 48); ++ R3(b, c, d, e, a, 49); ++ R3(a, b, c, d, e, 50); ++ R3(e, a, b, c, d, 51); ++ R3(d, e, a, b, c, 52); ++ R3(c, d, e, a, b, 53); ++ R3(b, c, d, e, a, 54); ++ R3(a, b, c, d, e, 55); ++ R3(e, a, b, c, d, 56); ++ R3(d, e, a, b, c, 57); ++ R3(c, d, e, a, b, 58); ++ R3(b, c, d, e, a, 59); ++ R4(a, b, c, d, e, 60); ++ R4(e, a, b, c, d, 61); ++ R4(d, e, a, b, c, 62); ++ R4(c, d, e, a, b, 63); ++ R4(b, c, d, e, a, 64); ++ R4(a, b, c, d, e, 65); ++ R4(e, a, b, c, d, 66); ++ R4(d, e, a, b, c, 67); ++ R4(c, d, e, a, b, 68); ++ R4(b, c, d, e, a, 69); ++ R4(a, b, c, d, e, 70); ++ R4(e, a, b, c, d, 71); ++ R4(d, e, a, b, c, 72); ++ R4(c, d, e, a, b, 73); ++ R4(b, c, d, e, a, 74); ++ R4(a, b, c, d, e, 75); ++ R4(e, a, b, c, d, 76); ++ R4(d, e, a, b, c, 77); ++ R4(c, d, e, a, b, 78); ++ R4(b, c, d, e, a, 79); ++ /* Add the working vars back into context.state[] */ ++ state[0] += a; ++ state[1] += b; ++ state[2] += c; ++ state[3] += d; ++ state[4] += e; ++ /* Wipe variables */ ++ a = b = c = d = e = 0; ++#ifdef UL_SHA1HANDSOFF ++ memset(block, '\0', sizeof(block)); + #endif + } + +- + /* SHA1Init - Initialize new context */ + +-void SHA1Init( +- SHA1_CTX * context +-) ++void ul_SHA1Init(UL_SHA1_CTX *context) + { +- /* SHA1 initialization constants */ +- context->state[0] = 0x67452301; +- context->state[1] = 0xEFCDAB89; +- context->state[2] = 0x98BADCFE; +- context->state[3] = 0x10325476; +- context->state[4] = 0xC3D2E1F0; +- context->count[0] = context->count[1] = 0; ++ /* SHA1 initialization constants */ ++ context->state[0] = 0x67452301; ++ context->state[1] = 0xEFCDAB89; ++ context->state[2] = 0x98BADCFE; ++ context->state[3] = 0x10325476; ++ context->state[4] = 0xC3D2E1F0; ++ context->count[0] = context->count[1] = 0; + } + +- + /* Run your data through this. */ + +-void SHA1Update( +- SHA1_CTX * context, +- const unsigned char *data, +- uint32_t len +-) ++void ul_SHA1Update(UL_SHA1_CTX *context, const unsigned char *data, uint32_t len) + { +- uint32_t i; ++ uint32_t i; + +- uint32_t j; ++ uint32_t j; + +- j = context->count[0]; +- if ((context->count[0] += len << 3) < j) +- context->count[1]++; +- context->count[1] += (len >> 29); +- j = (j >> 3) & 63; +- if ((j + len) > 63) +- { +- memcpy(&context->buffer[j], data, (i = 64 - j)); +- SHA1Transform(context->state, context->buffer); +- for (; i + 63 < len; i += 64) +- { +- SHA1Transform(context->state, &data[i]); +- } +- j = 0; +- } +- else +- i = 0; +- memcpy(&context->buffer[j], &data[i], len - i); ++ j = context->count[0]; ++ if ((context->count[0] += len << 3) < j) ++ context->count[1]++; ++ context->count[1] += (len >> 29); ++ j = (j >> 3) & 63; ++ if ((j + len) > 63) { ++ memcpy(&context->buffer[j], data, (i = 64 - j)); ++ ul_SHA1Transform(context->state, context->buffer); ++ for (; i + 63 < len; i += 64) { ++ ul_SHA1Transform(context->state, &data[i]); ++ } ++ j = 0; ++ } else ++ i = 0; ++ memcpy(&context->buffer[j], &data[i], len - i); + } + +- + /* Add padding and return the message digest. */ + +-void SHA1Final( +- unsigned char digest[20], +- SHA1_CTX * context +-) ++void ul_SHA1Final(unsigned char digest[20], UL_SHA1_CTX *context) + { +- unsigned i; ++ unsigned i; + +- unsigned char finalcount[8]; ++ unsigned char finalcount[8]; + +- unsigned char c; ++ unsigned char c; + +-#if 0 /* untested "improvement" by DHR */ +- /* Convert context->count to a sequence of bytes +- * in finalcount. Second element first, but +- * big-endian order within element. +- * But we do it all backwards. +- */ +- unsigned char *fcp = &finalcount[8]; ++#if 0 /* untested "improvement" by DHR */ ++ /* Convert context->count to a sequence of bytes ++ * in finalcount. Second element first, but ++ * big-endian order within element. ++ * But we do it all backwards. ++ */ ++ unsigned char *fcp = &finalcount[8]; + +- for (i = 0; i < 2; i++) +- { +- uint32_t t = context->count[i]; ++ for (i = 0; i < 2; i++) { ++ uint32_t t = context->count[i]; + +- int j; ++ int j; + +- for (j = 0; j < 4; t >>= 8, j++) +- *--fcp = (unsigned char) t} ++ for (j = 0; j < 4; t >>= 8, j++) ++ *--fcp = (unsigned char)t} + #else +- for (i = 0; i < 8; i++) +- { +- finalcount[i] = (unsigned char) ((context->count[(i >= 4 ? 0 : 1)] >> ((3 - (i & 3)) * 8)) & 255); /* Endian independent */ +- } ++ for (i = 0; i < 8; i++) { ++ finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)] >> ((3 - (i & 3)) * 8)) & 255); /* Endian independent */ ++ } + #endif +- c = 0200; +- SHA1Update(context, &c, 1); +- while ((context->count[0] & 504) != 448) +- { +- c = 0000; +- SHA1Update(context, &c, 1); +- } +- SHA1Update(context, finalcount, 8); /* Should cause a SHA1Transform() */ +- for (i = 0; i < 20; i++) +- { +- digest[i] = (unsigned char) +- ((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255); +- } +- /* Wipe variables */ +- memset(context, '\0', sizeof(*context)); +- memset(&finalcount, '\0', sizeof(finalcount)); ++ c = 0200; ++ ul_SHA1Update(context, &c, 1); ++ while ((context->count[0] & 504) != 448) { ++ c = 0000; ++ ul_SHA1Update(context, &c, 1); ++ } ++ ul_SHA1Update(context, finalcount, 8); /* Should cause a SHA1Transform() */ ++ for (i = 0; i < 20; i++) { ++ digest[i] = (unsigned char) ++ ((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255); ++ } ++ /* Wipe variables */ ++ memset(context, '\0', sizeof(*context)); ++ memset(&finalcount, '\0', sizeof(finalcount)); + } + +-void SHA1( +- char *hash_out, +- const char *str, +- unsigned len) ++void ul_SHA1(char *hash_out, const char *str, unsigned len) + { +- SHA1_CTX ctx; +- unsigned int ii; ++ UL_SHA1_CTX ctx; ++ unsigned int ii; + +- SHA1Init(&ctx); +- for (ii=0; ii