gcc4 fixes

1 files changed, 2 insertions, 2 deletions

diff --git a/pwmanager/libcrypt/cipher/serpent.c b/pwmanager/libcrypt/cipher/serpent.c
index d606d9f..fb5df20 100644
--- a/pwmanager/libcrypt/cipher/serpent.c
+++ b/pwmanager/libcrypt/cipher/serpent.c
@@ -548,271 +548,271 @@ typedef struct serpent_context
     SBOX (which, block, block_tmp, 0);               \
     BLOCK_XOR (block_tmp, subkeys[round]);           \
     round++;                                         \
   }
 
 /* Apply an inverse Serpent round to BLOCK, using the SBOX number
    WHICH and the subkeys contained in SUBKEYS.  Use BLOCK_TMP as
    temporary storage.  This macro increments `round'.  */
 #define ROUND_INVERSE(which, subkey, block, block_tmp) \
   {                                                    \
     LINEAR_TRANSFORMATION_INVERSE (block);             \
     SBOX_INVERSE (which, block, block_tmp, 0);         \
     BLOCK_XOR (block_tmp, subkey[round]);              \
     round--;                                           \
     BLOCK_COPY (block, block_tmp);                     \
   }
 
 /* Apply the first Serpent round to BLOCK, using the SBOX number WHICH
    and the subkeys contained in SUBKEYS.  Use BLOCK_TMP as temporary
    storage.  The result will be stored in BLOCK_TMP.  This macro
    increments `round'.  */
 #define ROUND_FIRST_INVERSE(which, subkeys, block, block_tmp) \
   {                                                           \
     BLOCK_XOR (block, subkeys[round]);                        \
     round--;                                                  \
     SBOX_INVERSE (which, block, block_tmp, 0);                \
     BLOCK_XOR (block_tmp, subkeys[round]);                    \
     round--;                                                  \
   }
 
 /* Convert the user provided key KEY of KEY_LENGTH bytes into the
    internally used format.  */
 static void
 serpent_key_prepare (const byte_t *key, unsigned int key_length,
                      serpent_key_t key_prepared)
 {
   int i;
 
   /* Copy key.  */
   for (i = 0; i < key_length / 4; i++)
     {
 #ifdef WORDS_BIGENDIAN
       key_prepared[i] = byte_swap_32 (((u32_t *) key)[i]);
 #else
       key_prepared[i] = ((u32_t *) key)[i];
 #endif
     }
 
   if (i < 8)
     {
       /* Key must be padded according to the Serpent
          specification.  */
       key_prepared[i] = 0x00000001;
 
       for (i++; i < 8; i++)
         key_prepared[i] = 0;
     }
 }
 
 /* Derive the 33 subkeys from KEY and store them in SUBKEYS.  */
 static void
 serpent_subkeys_generate (serpent_key_t key, serpent_subkeys_t subkeys)
 {
           u32_t w_real[140];    /* The `prekey'.  */
   u32_t k[132];
   u32_t *w = &w_real[8];
   int i, j;
 
   /* Initialize with key values.  */
   for (i = 0; i < 8; i++)
     w[i - 8] = key[i];
 
   /* Expand to intermediate key using the affine recurrence.  */
   for (i = 0; i < 132; i++)
     w[i] = rol (w[i - 8] ^ w[i - 5] ^ w[i - 3] ^ w[i - 1] ^ PHI ^ i, 11);
 
   /* Calculate subkeys via S-Boxes, in bitslice mode.  */
   SBOX (3, w, k,   0);
   SBOX (2, w, k,   4);
   SBOX (1, w, k,   8);
   SBOX (0, w, k,  12);
   SBOX (7, w, k,  16);
   SBOX (6, w, k,  20);
   SBOX (5, w, k,  24);
   SBOX (4, w, k,  28);
   SBOX (3, w, k,  32);
   SBOX (2, w, k,  36);
   SBOX (1, w, k,  40);
   SBOX (0, w, k,  44);
   SBOX (7, w, k,  48);
   SBOX (6, w, k,  52);
   SBOX (5, w, k,  56);
   SBOX (4, w, k,  60);
   SBOX (3, w, k,  64);
   SBOX (2, w, k,  68);
   SBOX (1, w, k,  72);
   SBOX (0, w, k,  76);
   SBOX (7, w, k,  80);
   SBOX (6, w, k,  84);
   SBOX (5, w, k,  88);
   SBOX (4, w, k,  92);
   SBOX (3, w, k,  96);
   SBOX (2, w, k, 100);
   SBOX (1, w, k, 104);
   SBOX (0, w, k, 108);
   SBOX (7, w, k, 112);
   SBOX (6, w, k, 116);
   SBOX (5, w, k, 120);
   SBOX (4, w, k, 124);
   SBOX (3, w, k, 128);
 
   /* Renumber subkeys.  */
   for (i = 0; i < ROUNDS + 1; i++)
     for (j = 0; j < 4; j++)
       subkeys[i][j] = k[4 * i + j];
 }
 
 /* Initialize CONTEXT with the key KEY of KEY_LENGTH bits.  */
 static void
 serpent_setkey_internal (serpent_context_t *context,
                          const byte_t *key, unsigned int key_length)
 {
   serpent_key_t key_prepared;
 
   serpent_key_prepare (key, key_length, key_prepared);
   serpent_subkeys_generate (key_prepared, context->keys);
   _gcry_burn_stack (272 * sizeof (u32_t));
 }
-
+ static const char *serpent_test (void);
 /* Initialize CTX with the key KEY of KEY_LENGTH bytes.  */
 static gcry_err_code_t
 serpent_setkey (void *ctx,
                 const byte_t *key, unsigned int key_length)
 {
   serpent_context_t *context = ctx;
   static const char *serpent_test_ret;
   static int serpent_init_done;
   gcry_err_code_t ret = GPG_ERR_NO_ERROR;
   
   if (! serpent_init_done)
     {
       /* Execute a self-test the first time, Serpent is used.  */
-      static const char *serpent_test (void);
+     
       
       serpent_test_ret = serpent_test ();
       if (serpent_test_ret)
         log_error ("Serpent test failure: %s\n", serpent_test_ret);
       serpent_init_done = 1;
     }
 
   if (serpent_test_ret)
     ret = GPG_ERR_SELFTEST_FAILED;
   else
     {
       serpent_setkey_internal (context, key, key_length);
       _gcry_burn_stack (sizeof (serpent_key_t));
     }
 
   return ret;
 }
 
 static void
 serpent_encrypt_internal (serpent_context_t *context,
                           const serpent_block_t input, serpent_block_t output)
 {
   serpent_block_t b, b_next;
   int round = 0;
 
 #ifdef WORDS_BIGENDIAN
   b[0] = byte_swap_32 (input[0]);
   b[1] = byte_swap_32 (input[1]);
   b[2] = byte_swap_32 (input[2]);
   b[3] = byte_swap_32 (input[3]);
 #else
   b[0] = input[0];
   b[1] = input[1];
   b[2] = input[2];
   b[3] = input[3];
 #endif
 
   ROUND (0, context->keys, b, b_next);
   ROUND (1, context->keys, b, b_next);
   ROUND (2, context->keys, b, b_next);
   ROUND (3, context->keys, b, b_next);
   ROUND (4, context->keys, b, b_next);
   ROUND (5, context->keys, b, b_next);
   ROUND (6, context->keys, b, b_next);
   ROUND (7, context->keys, b, b_next);
   ROUND (0, context->keys, b, b_next);
   ROUND (1, context->keys, b, b_next);
   ROUND (2, context->keys, b, b_next);
   ROUND (3, context->keys, b, b_next);
   ROUND (4, context->keys, b, b_next);
   ROUND (5, context->keys, b, b_next);
   ROUND (6, context->keys, b, b_next);
   ROUND (7, context->keys, b, b_next);
   ROUND (0, context->keys, b, b_next);
   ROUND (1, context->keys, b, b_next);
   ROUND (2, context->keys, b, b_next);
   ROUND (3, context->keys, b, b_next);
   ROUND (4, context->keys, b, b_next);
   ROUND (5, context->keys, b, b_next);
   ROUND (6, context->keys, b, b_next);
   ROUND (7, context->keys, b, b_next);
   ROUND (0, context->keys, b, b_next);
   ROUND (1, context->keys, b, b_next);
   ROUND (2, context->keys, b, b_next);
   ROUND (3, context->keys, b, b_next);
   ROUND (4, context->keys, b, b_next);
   ROUND (5, context->keys, b, b_next);
   ROUND (6, context->keys, b, b_next);
 
   ROUND_LAST (7, context->keys, b, b_next);
 
 #ifdef WORDS_BIGENDIAN
   output[0] = byte_swap_32 (b_next[0]);
   output[1] = byte_swap_32 (b_next[1]);
   output[2] = byte_swap_32 (b_next[2]);
   output[3] = byte_swap_32 (b_next[3]);
 #else
   output[0] = b_next[0];
   output[1] = b_next[1];
   output[2] = b_next[2];
   output[3] = b_next[3];
 #endif
 }
 
 static void
 serpent_decrypt_internal (serpent_context_t *context,
                           const serpent_block_t input, serpent_block_t output)
 {
   serpent_block_t b, b_next;
   int round = ROUNDS;
 
 #ifdef WORDS_BIGENDIAN
   b_next[0] = byte_swap_32 (input[0]);
   b_next[1] = byte_swap_32 (input[1]);
   b_next[2] = byte_swap_32 (input[2]);
   b_next[3] = byte_swap_32 (input[3]);
 #else
   b_next[0] = input[0];
   b_next[1] = input[1];
   b_next[2] = input[2];
   b_next[3] = input[3];
 #endif
 
   ROUND_FIRST_INVERSE (7, context->keys, b_next, b);
 
   ROUND_INVERSE (6, context->keys, b, b_next);
   ROUND_INVERSE (5, context->keys, b, b_next);
   ROUND_INVERSE (4, context->keys, b, b_next);
   ROUND_INVERSE (3, context->keys, b, b_next);
   ROUND_INVERSE (2, context->keys, b, b_next);
   ROUND_INVERSE (1, context->keys, b, b_next);
   ROUND_INVERSE (0, context->keys, b, b_next);
   ROUND_INVERSE (7, context->keys, b, b_next);
   ROUND_INVERSE (6, context->keys, b, b_next);
   ROUND_INVERSE (5, context->keys, b, b_next);
   ROUND_INVERSE (4, context->keys, b, b_next);
   ROUND_INVERSE (3, context->keys, b, b_next);
   ROUND_INVERSE (2, context->keys, b, b_next);
   ROUND_INVERSE (1, context->keys, b, b_next);
   ROUND_INVERSE (0, context->keys, b, b_next);
   ROUND_INVERSE (7, context->keys, b, b_next);
   ROUND_INVERSE (6, context->keys, b, b_next);
   ROUND_INVERSE (5, context->keys, b, b_next);
   ROUND_INVERSE (4, context->keys, b, b_next);
   ROUND_INVERSE (3, context->keys, b, b_next);
   ROUND_INVERSE (2, context->keys, b, b_next);
   ROUND_INVERSE (1, context->keys, b, b_next);
   ROUND_INVERSE (0, context->keys, b, b_next);