Use spaces for indentation, not tabs.

1 files changed, 115 insertions, 115 deletions

diff --git a/lib/sha512.c b/lib/sha512.c
index becafaee84..ade9156d2c 100644
--- a/lib/sha512.c
+++ b/lib/sha512.c
@@ -36,14 +36,14 @@
 # define SWAP(n) (n)
 #else
 # define SWAP(n) \
-    u64or (u64or (u64or (u64shl (n, 56),				\
-			 u64shl (u64and (n, u64lo (0x0000ff00)), 40)),	\
-		  u64or (u64shl (u64and (n, u64lo (0x00ff0000)), 24),	\
-			 u64shl (u64and (n, u64lo (0xff000000)),  8))),	\
-	   u64or (u64or (u64and (u64shr (n,  8), u64lo (0xff000000)),	\
-			 u64and (u64shr (n, 24), u64lo (0x00ff0000))),	\
-		  u64or (u64and (u64shr (n, 40), u64lo (0x0000ff00)),	\
-			 u64shr (n, 56))))
+    u64or (u64or (u64or (u64shl (n, 56),                                \
+                         u64shl (u64and (n, u64lo (0x0000ff00)), 40)),  \
+                  u64or (u64shl (u64and (n, u64lo (0x00ff0000)), 24),   \
+                         u64shl (u64and (n, u64lo (0xff000000)),  8))), \
+           u64or (u64or (u64and (u64shr (n,  8), u64lo (0xff000000)),   \
+                         u64and (u64shr (n, 24), u64lo (0x00ff0000))),  \
+                  u64or (u64and (u64shr (n, 40), u64lo (0x0000ff00)),   \
+                         u64shr (n, 56))))
 #endif
 
 #define BLOCKSIZE 32768
@@ -146,10 +146,10 @@ sha512_conclude_ctx (struct sha512_ctx *ctx)
      Use set_uint64 rather than a simple assignment, to avoid risk of
      unaligned access.  */
   set_uint64 ((char *) &ctx->buffer[size - 2],
-	      SWAP (u64or (u64shl (ctx->total[1], 3),
-			   u64shr (ctx->total[0], 61))));
+              SWAP (u64or (u64shl (ctx->total[1], 3),
+                           u64shr (ctx->total[0], 61))));
   set_uint64 ((char *) &ctx->buffer[size - 1],
-	      SWAP (u64shl (ctx->total[0], 3)));
+              SWAP (u64shl (ctx->total[0], 3)));
 
   memcpy (&((char *) ctx->buffer)[bytes], fillbuf, (size - 2) * 8 - bytes);
 
@@ -191,43 +191,43 @@ sha512_stream (FILE *stream, void *resblock)
   while (1)
     {
       /* We read the file in blocks of BLOCKSIZE bytes.  One call of the
-	 computation function processes the whole buffer so that with the
-	 next round of the loop another block can be read.  */
+         computation function processes the whole buffer so that with the
+         next round of the loop another block can be read.  */
       size_t n;
       sum = 0;
 
       /* 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))
-		{
-		  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;
-	}
+        {
+          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 % 128 == 0
+                        BLOCKSIZE % 128 == 0
        */
       sha512_process_block (buffer, BLOCKSIZE, &ctx);
     }
@@ -262,43 +262,43 @@ sha384_stream (FILE *stream, void *resblock)
   while (1)
     {
       /* We read the file in blocks of BLOCKSIZE bytes.  One call of the
-	 computation function processes the whole buffer so that with the
-	 next round of the loop another block can be read.  */
+         computation function processes the whole buffer so that with the
+         next round of the loop another block can be read.  */
       size_t n;
       sum = 0;
 
       /* 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))
-		{
-		  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;
-	}
+        {
+          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 % 128 == 0
+                        BLOCKSIZE % 128 == 0
        */
       sha512_process_block (buffer, BLOCKSIZE, &ctx);
     }
@@ -363,15 +363,15 @@ sha512_process_bytes (const void *buffer, size_t len, struct sha512_ctx *ctx)
       ctx->buflen += add;
 
       if (ctx->buflen > 128)
-	{
-	  sha512_process_block (ctx->buffer, ctx->buflen & ~127, ctx);
+        {
+          sha512_process_block (ctx->buffer, ctx->buflen & ~127, ctx);
 
-	  ctx->buflen &= 127;
-	  /* The regions in the following copy operation cannot overlap.  */
-	  memcpy (ctx->buffer,
-		  &((char *) ctx->buffer)[(left_over + add) & ~127],
-		  ctx->buflen);
-	}
+          ctx->buflen &= 127;
+          /* The regions in the following copy operation cannot overlap.  */
+          memcpy (ctx->buffer,
+                  &((char *) ctx->buffer)[(left_over + add) & ~127],
+                  ctx->buflen);
+        }
 
       buffer = (const char *) buffer + add;
       len -= add;
@@ -384,19 +384,19 @@ sha512_process_bytes (const void *buffer, size_t len, struct sha512_ctx *ctx)
 # define alignof(type) offsetof (struct { char c; type x; }, x)
 # define UNALIGNED_P(p) (((size_t) p) % alignof (u64) != 0)
       if (UNALIGNED_P (buffer))
-	while (len > 128)
-	  {
-	    sha512_process_block (memcpy (ctx->buffer, buffer, 128), 128, ctx);
-	    buffer = (const char *) buffer + 128;
-	    len -= 128;
-	  }
+        while (len > 128)
+          {
+            sha512_process_block (memcpy (ctx->buffer, buffer, 128), 128, ctx);
+            buffer = (const char *) buffer + 128;
+            len -= 128;
+          }
       else
 #endif
-	{
-	  sha512_process_block (buffer, len & ~127, ctx);
-	  buffer = (const char *) buffer + (len & ~127);
-	  len &= 127;
-	}
+        {
+          sha512_process_block (buffer, len & ~127, ctx);
+          buffer = (const char *) buffer + (len & ~127);
+          len &= 127;
+        }
     }
 
   /* Move remaining bytes in internal buffer.  */
@@ -407,11 +407,11 @@ sha512_process_bytes (const void *buffer, size_t len, struct sha512_ctx *ctx)
       memcpy (&((char *) ctx->buffer)[left_over], buffer, len);
       left_over += len;
       if (left_over >= 128)
-	{
-	  sha512_process_block (ctx->buffer, 128, ctx);
-	  left_over -= 128;
-	  memcpy (ctx->buffer, &ctx->buffer[16], left_over);
-	}
+        {
+          sha512_process_block (ctx->buffer, 128, ctx);
+          left_over -= 128;
+          memcpy (ctx->buffer, &ctx->buffer[16], left_over);
+        }
       ctx->buflen = left_over;
     }
 }
@@ -498,22 +498,22 @@ sha512_process_block (const void *buffer, size_t len, struct sha512_ctx *ctx)
 #define SS0(x) u64xor (u64rol (x, 36), u64xor (u64rol (x, 30), u64rol (x, 25)))
 #define SS1(x) u64xor (u64rol(x, 50), u64xor (u64rol (x, 46), u64rol (x, 23)))
 
-#define M(I) (x[(I) & 15]						  \
-	      = u64plus (x[(I) & 15],					  \
-			 u64plus (S1 (x[((I) - 2) & 15]),		  \
-				  u64plus (x[((I) - 7) & 15],		  \
-					   S0 (x[((I) - 15) & 15])))))
-
-#define R(A, B, C, D, E, F, G, H, K, M)					  \
-  do									  \
-    {									  \
-      u64 t0 = u64plus (SS0 (A), F2 (A, B, C));				  \
-      u64 t1 =								  \
-	u64plus (H, u64plus (SS1 (E),					  \
-			     u64plus (F1 (E, F, G), u64plus (K, M))));	  \
-      D = u64plus (D, t1);						  \
-      H = u64plus (t0, t1);						  \
-    }									  \
+#define M(I) (x[(I) & 15]                                                 \
+              = u64plus (x[(I) & 15],                                     \
+                         u64plus (S1 (x[((I) - 2) & 15]),                 \
+                                  u64plus (x[((I) - 7) & 15],             \
+                                           S0 (x[((I) - 15) & 15])))))
+
+#define R(A, B, C, D, E, F, G, H, K, M)                                   \
+  do                                                                      \
+    {                                                                     \
+      u64 t0 = u64plus (SS0 (A), F2 (A, B, C));                           \
+      u64 t1 =                                                            \
+        u64plus (H, u64plus (SS1 (E),                                     \
+                             u64plus (F1 (E, F, G), u64plus (K, M))));    \
+      D = u64plus (D, t1);                                                \
+      H = u64plus (t0, t1);                                               \
+    }                                                                     \
   while (0)
 
   while (words < endp)
@@ -521,10 +521,10 @@ sha512_process_block (const void *buffer, size_t len, struct sha512_ctx *ctx)
       int t;
       /* FIXME: see sha1.c for a better implementation.  */
       for (t = 0; t < 16; t++)
-	{
-	  x[t] = SWAP (*words);
-	  words++;
-	}
+        {
+          x[t] = SWAP (*words);
+          words++;
+        }
 
       R( a, b, c, d, e, f, g, h, K( 0), x[ 0] );
       R( h, a, b, c, d, e, f, g, K( 1), x[ 1] );