Restoring authorship annotation for Nikita Slyusarev <nslus@yandex-team.com>. Commit 1 of 2.

1 files changed, 49 insertions, 49 deletions

diff --git a/contrib/libs/curl/lib/md4.c b/contrib/libs/curl/lib/md4.c
index d3355ad929..fedbf4e882 100644
--- a/contrib/libs/curl/lib/md4.c
+++ b/contrib/libs/curl/lib/md4.c
@@ -262,14 +262,14 @@ static void MD4_Final(unsigned char *result, MD4_CTX *ctx)
  * 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.
- */
-
-
+ */ 
+ 
+ 
 #include <string.h>
-
+ 
 /* Any 32-bit or wider unsigned integer data type will do */
 typedef unsigned int MD4_u32plus;
-
+ 
 struct md4_ctx {
   MD4_u32plus lo, hi;
   MD4_u32plus a, b, c, d;
@@ -277,28 +277,28 @@ struct md4_ctx {
   MD4_u32plus block[16];
 };
 typedef struct md4_ctx MD4_CTX;
-
+ 
 static void MD4_Init(MD4_CTX *ctx);
 static void MD4_Update(MD4_CTX *ctx, const void *data, unsigned long size);
 static void MD4_Final(unsigned char *result, MD4_CTX *ctx);
-
+ 
 /*
  * The basic MD4 functions.
  *
  * F and G are optimized compared to their RFC 1320 definitions, with the
  * optimization for F borrowed from Colin Plumb's MD5 implementation.
- */
+ */ 
 #define F(x, y, z)                      ((z) ^ ((x) & ((y) ^ (z))))
 #define G(x, y, z)                      (((x) & ((y) | (z))) | ((y) & (z)))
 #define H(x, y, z)                      ((x) ^ (y) ^ (z))
-
+ 
 /*
  * The MD4 transformation for all three rounds.
- */
+ */ 
 #define STEP(f, a, b, c, d, x, s) \
         (a) += f((b), (c), (d)) + (x); \
         (a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s))));
-
+ 
 /*
  * SET reads 4 input bytes in little-endian byte order and stores them
  * in a properly aligned word in host byte order.
@@ -322,23 +322,23 @@ static void MD4_Final(unsigned char *result, MD4_CTX *ctx);
 #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(MD4_CTX *ctx, const void *data, unsigned long size)
-{
+{ 
   const unsigned char *ptr;
   MD4_u32plus a, b, c, d;
-
+ 
   ptr = (const unsigned char *)data;
-
+ 
   a = ctx->a;
   b = ctx->b;
   c = ctx->c;
   d = ctx->d;
-
+ 
   do {
     MD4_u32plus saved_a, saved_b, saved_c, saved_d;
 
@@ -346,7 +346,7 @@ static const void *body(MD4_CTX *ctx, const void *data, unsigned long size)
     saved_b = b;
     saved_c = c;
     saved_d = d;
-
+ 
 /* Round 1 */
     STEP(F, a, b, c, d, SET(0), 3)
     STEP(F, d, a, b, c, SET(1), 7)
@@ -364,7 +364,7 @@ static const void *body(MD4_CTX *ctx, const void *data, unsigned long size)
     STEP(F, d, a, b, c, SET(13), 7)
     STEP(F, c, d, a, b, SET(14), 11)
     STEP(F, b, c, d, a, SET(15), 19)
-
+ 
 /* Round 2 */
     STEP(G, a, b, c, d, GET(0) + 0x5a827999, 3)
     STEP(G, d, a, b, c, GET(4) + 0x5a827999, 5)
@@ -382,7 +382,7 @@ static const void *body(MD4_CTX *ctx, const void *data, unsigned long size)
     STEP(G, d, a, b, c, GET(7) + 0x5a827999, 5)
     STEP(G, c, d, a, b, GET(11) + 0x5a827999, 9)
     STEP(G, b, c, d, a, GET(15) + 0x5a827999, 13)
-
+ 
 /* Round 3 */
     STEP(H, a, b, c, d, GET(0) + 0x6ed9eba1, 3)
     STEP(H, d, a, b, c, GET(8) + 0x6ed9eba1, 9)
@@ -400,73 +400,73 @@ static const void *body(MD4_CTX *ctx, const void *data, unsigned long size)
     STEP(H, d, a, b, c, GET(11) + 0x6ed9eba1, 9)
     STEP(H, c, d, a, b, GET(7) + 0x6ed9eba1, 11)
     STEP(H, b, c, d, a, GET(15) + 0x6ed9eba1, 15)
-
+ 
     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;
-}
-
+} 
+ 
 static void MD4_Init(MD4_CTX *ctx)
-{
+{ 
   ctx->a = 0x67452301;
   ctx->b = 0xefcdab89;
   ctx->c = 0x98badcfe;
   ctx->d = 0x10325476;
-
+ 
   ctx->lo = 0;
   ctx->hi = 0;
-}
-
+} 
+ 
 static void MD4_Update(MD4_CTX *ctx, const void *data, unsigned long size)
-{
+{ 
   MD4_u32plus saved_lo;
   unsigned long used;
-
+ 
   saved_lo = ctx->lo;
   ctx->lo = (saved_lo + size) & 0x1fffffff;
   if(ctx->lo < saved_lo)
     ctx->hi++;
   ctx->hi += (MD4_u32plus)size >> 29;
-
+ 
   used = saved_lo & 0x3f;
-
+ 
   if(used) {
     unsigned long 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);
-}
-
+} 
+ 
 static void MD4_Final(unsigned char *result, MD4_CTX *ctx)
-{
+{ 
   unsigned long used, available;
-
+ 
   used = ctx->lo & 0x3f;
 
   ctx->buffer[used++] = 0x80;
@@ -478,10 +478,10 @@ static void MD4_Final(unsigned char *result, MD4_CTX *ctx)
     body(ctx, ctx->buffer, 64);
     used = 0;
     available = 64;
-  }
-
+  } 
+ 
   memset(&ctx->buffer[used], 0, available - 8);
-
+ 
   ctx->lo <<= 3;
   ctx->buffer[56] = curlx_ultouc((ctx->lo)&0xff);
   ctx->buffer[57] = curlx_ultouc((ctx->lo >> 8)&0xff);
@@ -512,18 +512,18 @@ static void MD4_Final(unsigned char *result, MD4_CTX *ctx)
   result[15] = curlx_ultouc(ctx->d >> 24);
 
   memset(ctx, 0, sizeof(*ctx));
-}
-
+} 
+ 
 #endif /* CRYPTO LIBS */
 
 void Curl_md4it(unsigned char *output, const unsigned char *input,
                 const size_t len)
-{
-  MD4_CTX ctx;
+{ 
+  MD4_CTX ctx; 
 
   MD4_Init(&ctx);
   MD4_Update(&ctx, input, curlx_uztoui(len));
   MD4_Final(output, &ctx);
-}
+} 
 
 #endif /* CURL_DISABLE_CRYPTO_AUTH */