13 files changed, 144 insertions, 144 deletions

diff --git a/src/util/common_logging.c b/src/util/common_logging.c
index 2c0fd57a8..82878a02a 100644
--- a/src/util/common_logging.c
+++ b/src/util/common_logging.c
@@ -903,7 +903,7 @@ GNUNET_error_type_to_string (enum GNUNET_ErrorType kind)
  * @return string form; will be overwritten by next call to GNUNET_h2s.
  */
 const char *
-GNUNET_h2s (const GNUNET_HashCode * hc)
+GNUNET_h2s (const struct GNUNET_HashCode * hc)
 {
   static struct GNUNET_CRYPTO_HashAsciiEncoded ret;
 
@@ -921,7 +921,7 @@ GNUNET_h2s (const GNUNET_HashCode * hc)
  * @return string form; will be overwritten by next call to GNUNET_h2s_full.
  */
 const char *
-GNUNET_h2s_full (const GNUNET_HashCode * hc)
+GNUNET_h2s_full (const struct GNUNET_HashCode * hc)
 {
   static struct GNUNET_CRYPTO_HashAsciiEncoded ret;
 
diff --git a/src/util/container_bloomfilter.c b/src/util/container_bloomfilter.c
index 8c226f67d..8d0852fc9 100644
--- a/src/util/container_bloomfilter.c
+++ b/src/util/container_bloomfilter.c
@@ -340,9 +340,9 @@ typedef int (*BitIterator) (void *cls,
  */
 static void
 iterateBits (const struct GNUNET_CONTAINER_BloomFilter *bf,
-             BitIterator callback, void *arg, const GNUNET_HashCode * key)
+             BitIterator callback, void *arg, const struct GNUNET_HashCode * key)
 {
-  GNUNET_HashCode tmp[2];
+  struct GNUNET_HashCode tmp[2];
   int bitCount;
   unsigned int round;
   unsigned int slot = 0;
@@ -354,7 +354,7 @@ iterateBits (const struct GNUNET_CONTAINER_BloomFilter *bf,
   GNUNET_assert (bf->bitArraySize * 8LL > bf->bitArraySize);
   while (bitCount > 0)
   {
-    while (slot < (sizeof (GNUNET_HashCode) / sizeof (uint32_t)))
+    while (slot < (sizeof (struct GNUNET_HashCode) / sizeof (uint32_t)))
     {
       if (GNUNET_YES !=
           callback (arg, bf,
@@ -368,7 +368,7 @@ iterateBits (const struct GNUNET_CONTAINER_BloomFilter *bf,
     }
     if (bitCount > 0)
     {
-      GNUNET_CRYPTO_hash (&tmp[round & 1], sizeof (GNUNET_HashCode),
+      GNUNET_CRYPTO_hash (&tmp[round & 1], sizeof (struct GNUNET_HashCode),
                           &tmp[(round + 1) & 1]);
       round++;
       slot = 0;
@@ -696,7 +696,7 @@ GNUNET_CONTAINER_bloomfilter_clear (struct GNUNET_CONTAINER_BloomFilter *bf)
  */
 int
 GNUNET_CONTAINER_bloomfilter_test (const struct GNUNET_CONTAINER_BloomFilter
-                                   *bf, const GNUNET_HashCode * e)
+                                   *bf, const struct GNUNET_HashCode * e)
 {
   int res;
 
@@ -716,7 +716,7 @@ GNUNET_CONTAINER_bloomfilter_test (const struct GNUNET_CONTAINER_BloomFilter
  */
 void
 GNUNET_CONTAINER_bloomfilter_add (struct GNUNET_CONTAINER_BloomFilter *bf,
-                                  const GNUNET_HashCode * e)
+                                  const struct GNUNET_HashCode * e)
 {
   if (NULL == bf)
     return;
@@ -801,7 +801,7 @@ GNUNET_CONTAINER_bloomfilter_or2 (struct GNUNET_CONTAINER_BloomFilter *bf,
  */
 void
 GNUNET_CONTAINER_bloomfilter_remove (struct GNUNET_CONTAINER_BloomFilter *bf,
-                                     const GNUNET_HashCode * e)
+                                     const struct GNUNET_HashCode * e)
 {
   if (NULL == bf)
     return;
@@ -827,7 +827,7 @@ GNUNET_CONTAINER_bloomfilter_resize (struct GNUNET_CONTAINER_BloomFilter *bf,
                                      void *iterator_cls, size_t size,
                                      unsigned int k)
 {
-  GNUNET_HashCode hc;
+  struct GNUNET_HashCode hc;
   unsigned int i;
 
   GNUNET_free (bf->bitArray);
diff --git a/src/util/container_multihashmap.c b/src/util/container_multihashmap.c
index 7e53a6440..ada98251c 100644
--- a/src/util/container_multihashmap.c
+++ b/src/util/container_multihashmap.c
@@ -39,7 +39,7 @@ struct MapEntry
   /**
    * Key for the entry.
    */
-  GNUNET_HashCode key;
+  struct GNUNET_HashCode key;
 
   /**
    * Value of the entry.
@@ -130,7 +130,7 @@ GNUNET_CONTAINER_multihashmap_destroy (struct GNUNET_CONTAINER_MultiHashMap
  */
 static unsigned int
 idx_of (const struct GNUNET_CONTAINER_MultiHashMap *m,
-        const GNUNET_HashCode * key)
+        const struct GNUNET_HashCode * key)
 {
   GNUNET_assert (m != NULL);
   return (*(unsigned int *) key) % m->map_length;
@@ -163,14 +163,14 @@ GNUNET_CONTAINER_multihashmap_size (const struct GNUNET_CONTAINER_MultiHashMap
  */
 void *
 GNUNET_CONTAINER_multihashmap_get (const struct GNUNET_CONTAINER_MultiHashMap
-                                   *map, const GNUNET_HashCode * key)
+                                   *map, const struct GNUNET_HashCode * key)
 {
   struct MapEntry *e;
 
   e = map->map[idx_of (map, key)];
   while (e != NULL)
   {
-    if (0 == memcmp (key, &e->key, sizeof (GNUNET_HashCode)))
+    if (0 == memcmp (key, &e->key, sizeof (struct GNUNET_HashCode)))
       return e->value;
     e = e->next;
   }
@@ -197,7 +197,7 @@ GNUNET_CONTAINER_multihashmap_iterate (const struct
   unsigned int i;
   struct MapEntry *e;
   struct MapEntry *n;
-  GNUNET_HashCode kc;
+  struct GNUNET_HashCode kc;
 
   count = 0;
   GNUNET_assert (map != NULL);
@@ -233,7 +233,7 @@ GNUNET_CONTAINER_multihashmap_iterate (const struct
  */
 int
 GNUNET_CONTAINER_multihashmap_remove (struct GNUNET_CONTAINER_MultiHashMap *map,
-                                      const GNUNET_HashCode * key, void *value)
+                                      const struct GNUNET_HashCode * key, void *value)
 {
   struct MapEntry *e;
   struct MapEntry *p;
@@ -244,7 +244,7 @@ GNUNET_CONTAINER_multihashmap_remove (struct GNUNET_CONTAINER_MultiHashMap *map,
   e = map->map[i];
   while (e != NULL)
   {
-    if ((0 == memcmp (key, &e->key, sizeof (GNUNET_HashCode))) &&
+    if ((0 == memcmp (key, &e->key, sizeof (struct GNUNET_HashCode))) &&
         (value == e->value))
     {
       if (p == NULL)
@@ -272,7 +272,7 @@ GNUNET_CONTAINER_multihashmap_remove (struct GNUNET_CONTAINER_MultiHashMap *map,
  */
 int
 GNUNET_CONTAINER_multihashmap_remove_all (struct GNUNET_CONTAINER_MultiHashMap
-                                          *map, const GNUNET_HashCode * key)
+                                          *map, const struct GNUNET_HashCode * key)
 {
   struct MapEntry *e;
   struct MapEntry *p;
@@ -285,7 +285,7 @@ GNUNET_CONTAINER_multihashmap_remove_all (struct GNUNET_CONTAINER_MultiHashMap
   e = map->map[i];
   while (e != NULL)
   {
-    if (0 == memcmp (key, &e->key, sizeof (GNUNET_HashCode)))
+    if (0 == memcmp (key, &e->key, sizeof (struct GNUNET_HashCode)))
     {
       if (p == NULL)
         map->map[i] = e->next;
@@ -321,14 +321,14 @@ GNUNET_CONTAINER_multihashmap_remove_all (struct GNUNET_CONTAINER_MultiHashMap
 int
 GNUNET_CONTAINER_multihashmap_contains (const struct
                                         GNUNET_CONTAINER_MultiHashMap *map,
-                                        const GNUNET_HashCode * key)
+                                        const struct GNUNET_HashCode * key)
 {
   struct MapEntry *e;
 
   e = map->map[idx_of (map, key)];
   while (e != NULL)
   {
-    if (0 == memcmp (key, &e->key, sizeof (GNUNET_HashCode)))
+    if (0 == memcmp (key, &e->key, sizeof (struct GNUNET_HashCode)))
       return GNUNET_YES;
     e = e->next;
   }
@@ -349,7 +349,7 @@ GNUNET_CONTAINER_multihashmap_contains (const struct
 int
 GNUNET_CONTAINER_multihashmap_contains_value (const struct
                                               GNUNET_CONTAINER_MultiHashMap
-                                              *map, const GNUNET_HashCode * key,
+                                              *map, const struct GNUNET_HashCode * key,
                                               const void *value)
 {
   struct MapEntry *e;
@@ -357,7 +357,7 @@ GNUNET_CONTAINER_multihashmap_contains_value (const struct
   e = map->map[idx_of (map, key)];
   while (e != NULL)
   {
-    if ((0 == memcmp (key, &e->key, sizeof (GNUNET_HashCode))) &&
+    if ((0 == memcmp (key, &e->key, sizeof (struct GNUNET_HashCode))) &&
         (e->value == value))
       return GNUNET_YES;
     e = e->next;
@@ -416,7 +416,7 @@ grow (struct GNUNET_CONTAINER_MultiHashMap *map)
  */
 int
 GNUNET_CONTAINER_multihashmap_put (struct GNUNET_CONTAINER_MultiHashMap *map,
-                                   const GNUNET_HashCode * key, void *value,
+                                   const struct GNUNET_HashCode * key, void *value,
                                    enum GNUNET_CONTAINER_MultiHashMapOption opt)
 {
   struct MapEntry *e;
@@ -429,7 +429,7 @@ GNUNET_CONTAINER_multihashmap_put (struct GNUNET_CONTAINER_MultiHashMap *map,
     e = map->map[i];
     while (e != NULL)
     {
-      if (0 == memcmp (key, &e->key, sizeof (GNUNET_HashCode)))
+      if (0 == memcmp (key, &e->key, sizeof (struct GNUNET_HashCode)))
       {
         if (opt == GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)
           return GNUNET_SYSERR;
@@ -467,7 +467,7 @@ GNUNET_CONTAINER_multihashmap_put (struct GNUNET_CONTAINER_MultiHashMap *map,
 int
 GNUNET_CONTAINER_multihashmap_get_multiple (const struct
                                             GNUNET_CONTAINER_MultiHashMap *map,
-                                            const GNUNET_HashCode * key,
+                                            const struct GNUNET_HashCode * key,
                                             GNUNET_CONTAINER_HashMapIterator it,
                                             void *it_cls)
 {
@@ -480,7 +480,7 @@ GNUNET_CONTAINER_multihashmap_get_multiple (const struct
   while (NULL != (e = n))
   {
     n = e->next;
-    if (0 != memcmp (key, &e->key, sizeof (GNUNET_HashCode)))
+    if (0 != memcmp (key, &e->key, sizeof (struct GNUNET_HashCode)))
       continue;
     if ((it != NULL) && (GNUNET_OK != it (it_cls, key, e->value)))
       return GNUNET_SYSERR;
diff --git a/src/util/crypto_hash.c b/src/util/crypto_hash.c
index 4d957c00e..04225b3dc 100644
--- a/src/util/crypto_hash.c
+++ b/src/util/crypto_hash.c
@@ -49,7 +49,7 @@
  * @param ret pointer to where to write the hashcode
  */
 void
-GNUNET_CRYPTO_hash (const void *block, size_t size, GNUNET_HashCode * ret)
+GNUNET_CRYPTO_hash (const void *block, size_t size, struct GNUNET_HashCode * ret)
 {
   gcry_md_hash_buffer (GCRY_MD_SHA512, ret, block, size);
 }
@@ -140,7 +140,7 @@ struct GNUNET_CRYPTO_FileHashContext
  */
 static void
 file_hash_finish (struct GNUNET_CRYPTO_FileHashContext *fhc,
-                  const GNUNET_HashCode * res)
+                  const struct GNUNET_HashCode * res)
 {
   fhc->callback (fhc->callback_cls, res);
   GNUNET_free (fhc->filename);
@@ -161,7 +161,7 @@ static void
 file_hash_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_CRYPTO_FileHashContext *fhc = cls;
-  GNUNET_HashCode *res;
+  struct GNUNET_HashCode *res;
   size_t delta;
 
   fhc->task = GNUNET_SCHEDULER_NO_TASK;
@@ -179,7 +179,7 @@ file_hash_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   fhc->offset += delta;
   if (fhc->offset == fhc->fsize)
   {
-    res = (GNUNET_HashCode *) gcry_md_read (fhc->md, GCRY_MD_SHA512);
+    res = (struct GNUNET_HashCode *) gcry_md_read (fhc->md, GCRY_MD_SHA512);
     file_hash_finish (fhc, res);
     return;
   }
@@ -272,7 +272,7 @@ GNUNET_CRYPTO_hash_file_cancel (struct GNUNET_CRYPTO_FileHashContext *fhc)
  *  safely cast to char*, a '\\0' termination is set).
  */
 void
-GNUNET_CRYPTO_hash_to_enc (const GNUNET_HashCode * block,
+GNUNET_CRYPTO_hash_to_enc (const struct GNUNET_HashCode * block,
                            struct GNUNET_CRYPTO_HashAsciiEncoded *result)
 {
   char *np;
@@ -296,7 +296,7 @@ GNUNET_CRYPTO_hash_to_enc (const GNUNET_HashCode * block,
  */
 int
 GNUNET_CRYPTO_hash_from_string2 (const char *enc, size_t enclen,
-                                GNUNET_HashCode * result)
+                                struct GNUNET_HashCode * result)
 {
   char upper_enc[enclen];
   char* up_ptr = upper_enc;
@@ -321,8 +321,8 @@ GNUNET_CRYPTO_hash_from_string2 (const char *enc, size_t enclen,
  *  hashcode proximity.
  */
 unsigned int
-GNUNET_CRYPTO_hash_distance_u32 (const GNUNET_HashCode * a,
-                                 const GNUNET_HashCode * b)
+GNUNET_CRYPTO_hash_distance_u32 (const struct GNUNET_HashCode * a,
+                                 const struct GNUNET_HashCode * b)
 {
   unsigned int x1 = (a->bits[1] - b->bits[1]) >> 16;
   unsigned int x2 = (b->bits[1] - a->bits[1]) >> 16;
@@ -339,11 +339,11 @@ GNUNET_CRYPTO_hash_distance_u32 (const GNUNET_HashCode * a,
  */
 void
 GNUNET_CRYPTO_hash_create_random (enum GNUNET_CRYPTO_Quality mode,
-                                  GNUNET_HashCode * result)
+                                  struct GNUNET_HashCode * result)
 {
   int i;
 
-  for (i = (sizeof (GNUNET_HashCode) / sizeof (uint32_t)) - 1; i >= 0; i--)
+  for (i = (sizeof (struct GNUNET_HashCode) / sizeof (uint32_t)) - 1; i >= 0; i--)
     result->bits[i] = GNUNET_CRYPTO_random_u32 (mode, UINT32_MAX);
 }
 
@@ -356,13 +356,13 @@ GNUNET_CRYPTO_hash_create_random (enum GNUNET_CRYPTO_Quality mode,
  * @param result set to b - a
  */
 void
-GNUNET_CRYPTO_hash_difference (const GNUNET_HashCode * a,
-                               const GNUNET_HashCode * b,
-                               GNUNET_HashCode * result)
+GNUNET_CRYPTO_hash_difference (const struct GNUNET_HashCode * a,
+                               const struct GNUNET_HashCode * b,
+                               struct GNUNET_HashCode * result)
 {
   int i;
 
-  for (i = (sizeof (GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0; i--)
+  for (i = (sizeof (struct GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0; i--)
     result->bits[i] = b->bits[i] - a->bits[i];
 }
 
@@ -375,12 +375,12 @@ GNUNET_CRYPTO_hash_difference (const GNUNET_HashCode * a,
  * @param result set to a + delta
  */
 void
-GNUNET_CRYPTO_hash_sum (const GNUNET_HashCode * a,
-                        const GNUNET_HashCode * delta, GNUNET_HashCode * result)
+GNUNET_CRYPTO_hash_sum (const struct GNUNET_HashCode * a,
+                        const struct GNUNET_HashCode * delta, struct GNUNET_HashCode * result)
 {
   int i;
 
-  for (i = (sizeof (GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0; i--)
+  for (i = (sizeof (struct GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0; i--)
     result->bits[i] = delta->bits[i] + a->bits[i];
 }
 
@@ -393,12 +393,12 @@ GNUNET_CRYPTO_hash_sum (const GNUNET_HashCode * a,
  * @param result set to a ^ b
  */
 void
-GNUNET_CRYPTO_hash_xor (const GNUNET_HashCode * a, const GNUNET_HashCode * b,
-                        GNUNET_HashCode * result)
+GNUNET_CRYPTO_hash_xor (const struct GNUNET_HashCode * a, const struct GNUNET_HashCode * b,
+                        struct GNUNET_HashCode * result)
 {
   int i;
 
-  for (i = (sizeof (GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0; i--)
+  for (i = (sizeof (struct GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0; i--)
     result->bits[i] = a->bits[i] ^ b->bits[i];
 }
 
@@ -411,11 +411,11 @@ GNUNET_CRYPTO_hash_xor (const GNUNET_HashCode * a, const GNUNET_HashCode * b,
  * @param iv set to a valid initialization vector
  */
 void
-GNUNET_CRYPTO_hash_to_aes_key (const GNUNET_HashCode * hc,
+GNUNET_CRYPTO_hash_to_aes_key (const struct GNUNET_HashCode * hc,
                                struct GNUNET_CRYPTO_AesSessionKey *skey,
                                struct GNUNET_CRYPTO_AesInitializationVector *iv)
 {
-  GNUNET_assert (sizeof (GNUNET_HashCode) >=
+  GNUNET_assert (sizeof (struct GNUNET_HashCode) >=
                  GNUNET_CRYPTO_AES_KEY_LENGTH +
                  sizeof (struct GNUNET_CRYPTO_AesInitializationVector));
   memcpy (skey, hc, GNUNET_CRYPTO_AES_KEY_LENGTH);
@@ -433,16 +433,16 @@ GNUNET_CRYPTO_hash_to_aes_key (const GNUNET_HashCode * hc,
  * @return Bit \a bit from hashcode \a code, -1 for invalid index
  */
 int
-GNUNET_CRYPTO_hash_get_bit (const GNUNET_HashCode * code, unsigned int bit)
+GNUNET_CRYPTO_hash_get_bit (const struct GNUNET_HashCode * code, unsigned int bit)
 {
-  GNUNET_assert (bit < 8 * sizeof (GNUNET_HashCode));
+  GNUNET_assert (bit < 8 * sizeof (struct GNUNET_HashCode));
   return (((unsigned char *) code)[bit >> 3] & (1 << (bit & 7))) > 0;
 }
 
 
 /**
  * Determine how many low order bits match in two
- * GNUNET_HashCodes.  i.e. - 010011 and 011111 share
+ * struct GNUNET_HashCodes.  i.e. - 010011 and 011111 share
  * the first two lowest order bits, and therefore the
  * return value is two (NOT XOR distance, nor how many
  * bits match absolutely!).
@@ -453,16 +453,16 @@ GNUNET_CRYPTO_hash_get_bit (const GNUNET_HashCode * code, unsigned int bit)
  * @return the number of bits that match
  */
 unsigned int
-GNUNET_CRYPTO_hash_matching_bits (const GNUNET_HashCode * first,
-                                  const GNUNET_HashCode * second)
+GNUNET_CRYPTO_hash_matching_bits (const struct GNUNET_HashCode * first,
+                                  const struct GNUNET_HashCode * second)
 {
   unsigned int i;
 
-  for (i = 0; i < sizeof (GNUNET_HashCode) * 8; i++)
+  for (i = 0; i < sizeof (struct GNUNET_HashCode) * 8; i++)
     if (GNUNET_CRYPTO_hash_get_bit (first, i) !=
         GNUNET_CRYPTO_hash_get_bit (second, i))
       return i;
-  return sizeof (GNUNET_HashCode) * 8;
+  return sizeof (struct GNUNET_HashCode) * 8;
 }
 
 
@@ -475,7 +475,7 @@ GNUNET_CRYPTO_hash_matching_bits (const GNUNET_HashCode * first,
  * @return 1 if h1 > h2, -1 if h1 < h2 and 0 if h1 == h2.
  */
 int
-GNUNET_CRYPTO_hash_cmp (const GNUNET_HashCode * h1, const GNUNET_HashCode * h2)
+GNUNET_CRYPTO_hash_cmp (const struct GNUNET_HashCode * h1, const struct GNUNET_HashCode * h2)
 {
   unsigned int *i1;
   unsigned int *i2;
@@ -483,7 +483,7 @@ GNUNET_CRYPTO_hash_cmp (const GNUNET_HashCode * h1, const GNUNET_HashCode * h2)
 
   i1 = (unsigned int *) h1;
   i2 = (unsigned int *) h2;
-  for (i = (sizeof (GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0; i--)
+  for (i = (sizeof (struct GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0; i--)
   {
     if (i1[i] > i2[i])
       return 1;
@@ -504,15 +504,15 @@ GNUNET_CRYPTO_hash_cmp (const GNUNET_HashCode * h1, const GNUNET_HashCode * h2)
  * @return -1 if h1 is closer, 1 if h2 is closer and 0 if h1==h2.
  */
 int
-GNUNET_CRYPTO_hash_xorcmp (const GNUNET_HashCode * h1,
-                           const GNUNET_HashCode * h2,
-                           const GNUNET_HashCode * target)
+GNUNET_CRYPTO_hash_xorcmp (const struct GNUNET_HashCode * h1,
+                           const struct GNUNET_HashCode * h2,
+                           const struct GNUNET_HashCode * target)
 {
   int i;
   unsigned int d1;
   unsigned int d2;
 
-  for (i = sizeof (GNUNET_HashCode) / sizeof (unsigned int) - 1; i >= 0; i--)
+  for (i = sizeof (struct GNUNET_HashCode) / sizeof (unsigned int) - 1; i >= 0; i--)
   {
     d1 = ((unsigned int *) h1)[i] ^ ((unsigned int *) target)[i];
     d2 = ((unsigned int *) h2)[i] ^ ((unsigned int *) target)[i];
@@ -576,7 +576,7 @@ GNUNET_CRYPTO_hmac_derive_key_v (struct GNUNET_CRYPTO_AuthKey *key,
 void
 GNUNET_CRYPTO_hmac (const struct GNUNET_CRYPTO_AuthKey *key,
                     const void *plaintext, size_t plaintext_len,
-                    GNUNET_HashCode * hmac)
+                    struct GNUNET_HashCode * hmac)
 {
   gcry_md_hd_t md;
   const unsigned char *mc;
diff --git a/src/util/crypto_ksk.c b/src/util/crypto_ksk.c
index 274457b61..0c091099e 100644
--- a/src/util/crypto_ksk.c
+++ b/src/util/crypto_ksk.c
@@ -70,11 +70,11 @@ struct GNUNET_CRYPTO_RsaPrivateKey
 
 
 static void
-mpz_randomize (gcry_mpi_t n, unsigned int nbits, GNUNET_HashCode * rnd)
+mpz_randomize (gcry_mpi_t n, unsigned int nbits, struct GNUNET_HashCode * rnd)
 {
-  GNUNET_HashCode hc;
-  GNUNET_HashCode tmp;
-  int bits_per_hc = sizeof (GNUNET_HashCode) * 8;
+  struct GNUNET_HashCode hc;
+  struct GNUNET_HashCode tmp;
+  int bits_per_hc = sizeof (struct GNUNET_HashCode) * 8;
   int cnt;
   int i;
 
@@ -88,8 +88,8 @@ mpz_randomize (gcry_mpi_t n, unsigned int nbits, GNUNET_HashCode * rnd)
     int j;
 
     if (i > 0)
-      GNUNET_CRYPTO_hash (&hc, sizeof (GNUNET_HashCode), &tmp);
-    for (j = 0; j < sizeof (GNUNET_HashCode) / sizeof (uint32_t); j++)
+      GNUNET_CRYPTO_hash (&hc, sizeof (struct GNUNET_HashCode), &tmp);
+    for (j = 0; j < sizeof (struct GNUNET_HashCode) / sizeof (uint32_t); j++)
     {
 #if HAVE_GCRY_MPI_LSHIFT
       gcry_mpi_lshift (n, n, sizeof (uint32_t) * 8);
@@ -101,7 +101,7 @@ mpz_randomize (gcry_mpi_t n, unsigned int nbits, GNUNET_HashCode * rnd)
     }
     hc = tmp;
   }
-  GNUNET_CRYPTO_hash (&hc, sizeof (GNUNET_HashCode), rnd);
+  GNUNET_CRYPTO_hash (&hc, sizeof (struct GNUNET_HashCode), rnd);
   i = gcry_mpi_get_nbits (n);
   while (i > nbits)
     gcry_mpi_clear_bit (n, --i);
@@ -137,7 +137,7 @@ mpz_tdiv_q_2exp (gcry_mpi_t q, gcry_mpi_t n, unsigned int b)
  * Return true if n is probably a prime
  */
 static int
-is_prime (gcry_mpi_t n, int steps, GNUNET_HashCode * hc)
+is_prime (gcry_mpi_t n, int steps, struct GNUNET_HashCode * hc)
 {
   gcry_mpi_t x;
   gcry_mpi_t y;
@@ -218,7 +218,7 @@ adjust (unsigned char *buf, size_t size, size_t target)
 
 
 static void
-gen_prime (gcry_mpi_t * ptest, unsigned int nbits, GNUNET_HashCode * hc)
+gen_prime (gcry_mpi_t * ptest, unsigned int nbits, struct GNUNET_HashCode * hc)
 {
   /* Note: 2 is not included because it can be tested more easily by
    * looking at bit 0. The last entry in this list is marked by a zero */
@@ -400,7 +400,7 @@ gen_prime (gcry_mpi_t * ptest, unsigned int nbits, GNUNET_HashCode * hc)
  */
 static void
 generate_kblock_key (KBlock_secret_key *sk, unsigned int nbits,
-                     GNUNET_HashCode * hc)
+                     struct GNUNET_HashCode * hc)
 {
   gcry_mpi_t t1, t2;
   gcry_mpi_t phi;               /* helper: (p-1)(q-1) */
@@ -490,10 +490,10 @@ GNUNET_NETWORK_STRUCT_END
  * given HashCode as input to the PRNG.
  */
 static struct KskRsaPrivateKeyBinaryEncoded *
-makeKblockKeyInternal (const GNUNET_HashCode * hc)
+makeKblockKeyInternal (const struct GNUNET_HashCode * hc)
 {
   KBlock_secret_key sk;
-  GNUNET_HashCode hx;
+  struct GNUNET_HashCode hx;
   unsigned char *pbu[6];
   gcry_mpi_t *pkv[6];
   size_t sizes[6];
@@ -564,7 +564,7 @@ struct KBlockKeyCacheLine
   /**
    * Hash from which the key was generated.
    */
-  GNUNET_HashCode hc;
+  struct GNUNET_HashCode hc;
 
   /**
    * The encoded key.
@@ -594,13 +594,13 @@ static unsigned int cacheSize;
  * @return corresponding private key; must not be freed!
  */
 struct GNUNET_CRYPTO_RsaPrivateKey *
-GNUNET_CRYPTO_rsa_key_create_from_hash (const GNUNET_HashCode * hc)
+GNUNET_CRYPTO_rsa_key_create_from_hash (const struct GNUNET_HashCode * hc)
 {
   struct KBlockKeyCacheLine *line;
   unsigned int i;
 
   for (i = 0; i < cacheSize; i++)  
-    if (0 == memcmp (hc, &cache[i]->hc, sizeof (GNUNET_HashCode)))
+    if (0 == memcmp (hc, &cache[i]->hc, sizeof (struct GNUNET_HashCode)))
       return GNUNET_CRYPTO_rsa_decode_key ((const char*) cache[i]->pke,
                                            ntohs (cache[i]->pke->len));  
   line = GNUNET_malloc (sizeof (struct KBlockKeyCacheLine));
diff --git a/src/util/crypto_rsa.c b/src/util/crypto_rsa.c
index 0106f43be..bbd73083d 100644
--- a/src/util/crypto_rsa.c
+++ b/src/util/crypto_rsa.c
@@ -838,7 +838,7 @@ GNUNET_CRYPTO_rsa_encrypt (const void *block, size_t size,
   size_t isize;
   size_t erroff;
 
-  GNUNET_assert (size <= sizeof (GNUNET_HashCode));
+  GNUNET_assert (size <= sizeof (struct GNUNET_HashCode));
   pubkey = public2PrivateKey (publicKey);
   if (pubkey == NULL)
     return GNUNET_SYSERR;
@@ -936,7 +936,7 @@ GNUNET_CRYPTO_rsa_sign (const struct GNUNET_CRYPTO_RsaPrivateKey *key,
   gcry_sexp_t data;
   size_t ssize;
   gcry_mpi_t rval;
-  GNUNET_HashCode hc;
+  struct GNUNET_HashCode hc;
   char *buff;
   int bufSize;
 
@@ -949,7 +949,7 @@ GNUNET_CRYPTO_rsa_sign (const struct GNUNET_CRYPTO_RsaPrivateKey *key,
           [bufSize -
            strlen
            ("0123456789012345678901234567890123456789012345678901234567890123))")
-           - 1], &hc, sizeof (GNUNET_HashCode));
+           - 1], &hc, sizeof (struct GNUNET_HashCode));
   GNUNET_assert (0 == gcry_sexp_new (&data, buff, bufSize, 0));
   GNUNET_free (buff);
   GNUNET_assert (0 == gcry_pk_sign (&result, data, key->sexp));
@@ -988,7 +988,7 @@ GNUNET_CRYPTO_rsa_verify (uint32_t purpose,
   size_t size;
   gcry_mpi_t val;
   struct GNUNET_CRYPTO_RsaPrivateKey *hostkey;
-  GNUNET_HashCode hc;
+  struct GNUNET_HashCode hc;
   char *buff;
   int bufSize;
   size_t erroff;
@@ -1012,7 +1012,7 @@ GNUNET_CRYPTO_rsa_verify (uint32_t purpose,
           [strlen (FORMATSTRING) -
            strlen
            ("0123456789012345678901234567890123456789012345678901234567890123))")],
-          &hc, sizeof (GNUNET_HashCode));
+          &hc, sizeof (struct GNUNET_HashCode));
   GNUNET_assert (0 == gcry_sexp_new (&data, buff, bufSize, 0));
   GNUNET_free (buff);
   hostkey = public2PrivateKey (publicKey);
diff --git a/src/util/perf_crypto_hash.c b/src/util/perf_crypto_hash.c
index d883776b4..d1f4c9dc1 100644
--- a/src/util/perf_crypto_hash.c
+++ b/src/util/perf_crypto_hash.c
@@ -32,9 +32,9 @@
 static void
 perfHash ()
 {
-  GNUNET_HashCode hc1;
-  GNUNET_HashCode hc2;
-  GNUNET_HashCode hc3;
+  struct GNUNET_HashCode hc1;
+  struct GNUNET_HashCode hc2;
+  struct GNUNET_HashCode hc3;
   int i;
   char *buf;
 
@@ -43,8 +43,8 @@ perfHash ()
   GNUNET_CRYPTO_hash ("foo", 3, &hc1);
   for (i = 0; i < 1024; i++)
   {
-    GNUNET_CRYPTO_hash (&hc1, sizeof (GNUNET_HashCode), &hc2);
-    GNUNET_CRYPTO_hash (&hc2, sizeof (GNUNET_HashCode), &hc1);
+    GNUNET_CRYPTO_hash (&hc1, sizeof (struct GNUNET_HashCode), &hc2);
+    GNUNET_CRYPTO_hash (&hc2, sizeof (struct GNUNET_HashCode), &hc1);
     GNUNET_CRYPTO_hash (buf, 1024 * 64, &hc3);
   }
   GNUNET_free (buf);
diff --git a/src/util/pseudonym.c b/src/util/pseudonym.c
index 016573845..c3964f296 100644
--- a/src/util/pseudonym.c
+++ b/src/util/pseudonym.c
@@ -88,7 +88,7 @@ static struct DiscoveryCallback *head;
  * @param rating rating of pseudonym
  */
 static void
-internal_notify (const GNUNET_HashCode * id,
+internal_notify (const struct GNUNET_HashCode * id,
                  const struct GNUNET_CONTAINER_MetaData *md, int rating)
 {
   struct DiscoveryCallback *pos;
@@ -169,7 +169,7 @@ GNUNET_PSEUDONYM_discovery_callback_unregister (GNUNET_PSEUDONYM_Iterator
  */
 static char *
 get_data_filename (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                   const char *prefix, const GNUNET_HashCode * psid)
+                   const char *prefix, const struct GNUNET_HashCode * psid)
 {
   struct GNUNET_CRYPTO_HashAsciiEncoded enc;
 
@@ -192,7 +192,7 @@ get_data_filename (const struct GNUNET_CONFIGURATION_Handle *cfg,
  */
 static void
 write_pseudonym_info (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                      const GNUNET_HashCode * nsid,
+                      const struct GNUNET_HashCode * nsid,
                       const struct GNUNET_CONTAINER_MetaData *meta,
                       int32_t ranking, const char *ns_name)
 {
@@ -238,7 +238,7 @@ write_pseudonym_info (const struct GNUNET_CONFIGURATION_Handle *cfg,
  */
 static int
 read_info (const struct GNUNET_CONFIGURATION_Handle *cfg,
-           const GNUNET_HashCode * nsid,
+           const struct GNUNET_HashCode * nsid,
            struct GNUNET_CONTAINER_MetaData **meta, int32_t * ranking,
            char **ns_name)
 {
@@ -303,9 +303,9 @@ read_info (const struct GNUNET_CONFIGURATION_Handle *cfg,
  */
 char *
 GNUNET_PSEUDONYM_name_uniquify (const struct GNUNET_CONFIGURATION_Handle *cfg,
-    const GNUNET_HashCode * nsid, const char *name, unsigned int *suffix)
+    const struct GNUNET_HashCode * nsid, const char *name, unsigned int *suffix)
 {
-  GNUNET_HashCode nh;
+  struct GNUNET_HashCode nh;
   uint64_t len;
   char *fn;
   struct GNUNET_DISK_FileHandle *fh;
@@ -328,23 +328,23 @@ GNUNET_PSEUDONYM_name_uniquify (const struct GNUNET_CONFIGURATION_Handle *cfg,
                               GNUNET_DISK_PERM_USER_WRITE);
   i = 0;
   idx = -1;
-  while ((len >= sizeof (GNUNET_HashCode)) &&
-         (sizeof (GNUNET_HashCode) ==
-          GNUNET_DISK_file_read (fh, &nh, sizeof (GNUNET_HashCode))))
+  while ((len >= sizeof (struct GNUNET_HashCode)) &&
+         (sizeof (struct GNUNET_HashCode) ==
+          GNUNET_DISK_file_read (fh, &nh, sizeof (struct GNUNET_HashCode))))
   {
-    if (0 == memcmp (&nh, nsid, sizeof (GNUNET_HashCode)))
+    if (0 == memcmp (&nh, nsid, sizeof (struct GNUNET_HashCode)))
     {
       idx = i;
       break;
     }
     i++;
-    len -= sizeof (GNUNET_HashCode);
+    len -= sizeof (struct GNUNET_HashCode);
   }
   if (idx == -1)
   {
     idx = i;
-    if (sizeof (GNUNET_HashCode) !=
-        GNUNET_DISK_file_write (fh, nsid, sizeof (GNUNET_HashCode)))
+    if (sizeof (struct GNUNET_HashCode) !=
+        GNUNET_DISK_file_write (fh, nsid, sizeof (struct GNUNET_HashCode)))
       LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "write", fn);
   }
   GNUNET_DISK_file_close (fh);
@@ -376,7 +376,7 @@ GNUNET_PSEUDONYM_name_uniquify (const struct GNUNET_CONFIGURATION_Handle *cfg,
  */
 int
 GNUNET_PSEUDONYM_get_info (const struct GNUNET_CONFIGURATION_Handle *cfg,
-    const GNUNET_HashCode * nsid, struct GNUNET_CONTAINER_MetaData **ret_meta,
+    const struct GNUNET_HashCode * nsid, struct GNUNET_CONTAINER_MetaData **ret_meta,
     int32_t *ret_rank, char **ret_name, int *name_is_a_dup)
 {
   struct GNUNET_CONTAINER_MetaData *meta;
@@ -450,13 +450,13 @@ GNUNET_PSEUDONYM_get_info (const struct GNUNET_CONFIGURATION_Handle *cfg,
  */
 int
 GNUNET_PSEUDONYM_name_to_id (const struct GNUNET_CONFIGURATION_Handle *cfg,
-    const char *ns_uname, GNUNET_HashCode * nsid)
+    const char *ns_uname, struct GNUNET_HashCode * nsid)
 {
   size_t slen;
   uint64_t len;
   unsigned int idx;
   char *name;
-  GNUNET_HashCode nh;
+  struct GNUNET_HashCode nh;
   char *fn;
   struct GNUNET_DISK_FileHandle *fh;
 
@@ -476,7 +476,7 @@ GNUNET_PSEUDONYM_name_to_id (const struct GNUNET_CONFIGURATION_Handle *cfg,
 
   if ((GNUNET_OK != GNUNET_DISK_file_test (fn) ||
        (GNUNET_OK != GNUNET_DISK_file_size (fn, &len, GNUNET_YES, GNUNET_YES))) ||
-      ((idx + 1) * sizeof (GNUNET_HashCode) > len))
+      ((idx + 1) * sizeof (struct GNUNET_HashCode) > len))
   {
     GNUNET_free (fn);
     return GNUNET_SYSERR;
@@ -487,10 +487,10 @@ GNUNET_PSEUDONYM_name_to_id (const struct GNUNET_CONFIGURATION_Handle *cfg,
                               GNUNET_DISK_PERM_USER_READ |
                               GNUNET_DISK_PERM_USER_WRITE);
   GNUNET_free (fn);
-  GNUNET_DISK_file_seek (fh, idx * sizeof (GNUNET_HashCode),
+  GNUNET_DISK_file_seek (fh, idx * sizeof (struct GNUNET_HashCode),
                          GNUNET_DISK_SEEK_SET);
-  if (sizeof (GNUNET_HashCode) !=
-      GNUNET_DISK_file_read (fh, nsid, sizeof (GNUNET_HashCode)))
+  if (sizeof (struct GNUNET_HashCode) !=
+      GNUNET_DISK_file_read (fh, nsid, sizeof (struct GNUNET_HashCode)))
   {
     GNUNET_DISK_file_close (fh);
     return GNUNET_SYSERR;
@@ -535,7 +535,7 @@ list_pseudonym_helper (void *cls, const char *fullname)
 {
   struct ListPseudonymClosure *c = cls;
   int ret;
-  GNUNET_HashCode id;
+  struct GNUNET_HashCode id;
   int32_t rating;
   struct GNUNET_CONTAINER_MetaData *meta;
   const char *fn;
@@ -612,7 +612,7 @@ GNUNET_PSEUDONYM_list_all (const struct GNUNET_CONFIGURATION_Handle *cfg,
  */
 int
 GNUNET_PSEUDONYM_rank (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                       const GNUNET_HashCode * nsid, int delta)
+                       const struct GNUNET_HashCode * nsid, int delta)
 {
   struct GNUNET_CONTAINER_MetaData *meta;
   int ret;
@@ -648,7 +648,7 @@ GNUNET_PSEUDONYM_rank (const struct GNUNET_CONFIGURATION_Handle *cfg,
  */
 int
 GNUNET_PSEUDONYM_set_info (const struct GNUNET_CONFIGURATION_Handle *cfg,
-    const GNUNET_HashCode * nsid, const char *name,
+    const struct GNUNET_HashCode * nsid, const char *name,
     const struct GNUNET_CONTAINER_MetaData *md, int rank)
 {
   GNUNET_assert (cfg != NULL);
@@ -670,7 +670,7 @@ GNUNET_PSEUDONYM_set_info (const struct GNUNET_CONFIGURATION_Handle *cfg,
  */
 void
 GNUNET_PSEUDONYM_add (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                      const GNUNET_HashCode * id,
+                      const struct GNUNET_HashCode * id,
                       const struct GNUNET_CONTAINER_MetaData *meta)
 {
   char *name;
diff --git a/src/util/test_container_bloomfilter.c b/src/util/test_container_bloomfilter.c
index f881bb367..f9743bdca 100644
--- a/src/util/test_container_bloomfilter.c
+++ b/src/util/test_container_bloomfilter.c
@@ -36,16 +36,16 @@
  * Generate a random hashcode.
  */
 static void
-nextHC (GNUNET_HashCode * hc)
+nextHC (struct GNUNET_HashCode * hc)
 {
   GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, hc);
 }
 
 static int
-add_iterator (void *cls, GNUNET_HashCode * next)
+add_iterator (void *cls, struct GNUNET_HashCode * next)
 {
   int *ret = cls;
-  GNUNET_HashCode pos;
+  struct GNUNET_HashCode pos;
 
   if (0 == (*ret)--)
     return GNUNET_NO;
@@ -59,7 +59,7 @@ main (int argc, char *argv[])
 {
   struct GNUNET_CONTAINER_BloomFilter *bf;
   struct GNUNET_CONTAINER_BloomFilter *bfi;
-  GNUNET_HashCode tmp;
+  struct GNUNET_HashCode tmp;
   int i;
   int ok1;
   int ok2;
diff --git a/src/util/test_container_multihashmap.c b/src/util/test_container_multihashmap.c
index ba621c17e..befd0ce46 100644
--- a/src/util/test_container_multihashmap.c
+++ b/src/util/test_container_multihashmap.c
@@ -35,8 +35,8 @@ static int
 testMap (int i)
 {
   struct GNUNET_CONTAINER_MultiHashMap *m;
-  GNUNET_HashCode k1;
-  GNUNET_HashCode k2;
+  struct GNUNET_HashCode k1;
+  struct GNUNET_HashCode k2;
   const char *ret;
   int j;
 
diff --git a/src/util/test_crypto_hash.c b/src/util/test_crypto_hash.c
index bc0411482..a8ef39a38 100644
--- a/src/util/test_crypto_hash.c
+++ b/src/util/test_crypto_hash.c
@@ -35,18 +35,18 @@ static char block[65536];
 static int
 test (int number)
 {
-  GNUNET_HashCode h1;
-  GNUNET_HashCode h2;
+  struct GNUNET_HashCode h1;
+  struct GNUNET_HashCode h2;
   struct GNUNET_CRYPTO_HashAsciiEncoded enc;
 
-  memset (&h1, number, sizeof (GNUNET_HashCode));
+  memset (&h1, number, sizeof (struct GNUNET_HashCode));
   GNUNET_CRYPTO_hash_to_enc (&h1, &enc);
   if (GNUNET_OK != GNUNET_CRYPTO_hash_from_string ((char *) &enc, &h2))
   {
     printf ("enc2hash failed!\n");
     return 1;
   }
-  if (0 != memcmp (&h1, &h2, sizeof (GNUNET_HashCode)))
+  if (0 != memcmp (&h1, &h2, sizeof (struct GNUNET_HashCode)))
     return 1;
   return 0;
 }
@@ -67,10 +67,10 @@ testArithmetic ()
 {
   static struct GNUNET_CRYPTO_AesSessionKey zskey;
   static struct GNUNET_CRYPTO_AesInitializationVector ziv;
-  GNUNET_HashCode h1;
-  GNUNET_HashCode h2;
-  GNUNET_HashCode d;
-  GNUNET_HashCode s;
+  struct GNUNET_HashCode h1;
+  struct GNUNET_HashCode h2;
+  struct GNUNET_HashCode d;
+  struct GNUNET_HashCode s;
   struct GNUNET_CRYPTO_AesSessionKey skey;
   struct GNUNET_CRYPTO_AesInitializationVector iv;
 
@@ -107,10 +107,10 @@ testArithmetic ()
 }
 
 static void
-finished_task (void *cls, const GNUNET_HashCode * res)
+finished_task (void *cls, const struct GNUNET_HashCode * res)
 {
   int *ret = cls;
-  GNUNET_HashCode want;
+  struct GNUNET_HashCode want;
 
   GNUNET_CRYPTO_hash (block, sizeof (block), &want);
   if (0 != memcmp (res, &want, sizeof (want)))
diff --git a/src/util/test_crypto_ksk.c b/src/util/test_crypto_ksk.c
index 58c459547..f0e4337ef 100644
--- a/src/util/test_crypto_ksk.c
+++ b/src/util/test_crypto_ksk.c
@@ -40,7 +40,7 @@ testCorrectKey ()
 {
   const char *want =
       "010601000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000b73c215f7a5e6b09bec55713c901786c09324a150980e014bdb0d04426934929c3b4971a9711af5455536cd6eeb8bfa004ee904972a737455f53c752987d8c82b755bc02882b44950c4acdc1672ba74c3b94d81a4c1ea3d74e7700ae5594c3a4f3c559e4bff2df6844fac302e4b66175e14dc8bad3ce44281d2fec1a1abef06301010000";
-  GNUNET_HashCode in;
+  struct GNUNET_HashCode in;
   struct GNUNET_CRYPTO_RsaPrivateKey *hostkey;
   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
   int i;
@@ -79,7 +79,7 @@ testCorrectKey ()
 static int
 testMultiKey (const char *word)
 {
-  GNUNET_HashCode in;
+  struct GNUNET_HashCode in;
   struct GNUNET_CRYPTO_RsaPrivateKey *hostkey;
   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey1;
@@ -228,7 +228,7 @@ int
 main (int argc, char *argv[])
 {
   int failureCount = 0;
-  GNUNET_HashCode in;
+  struct GNUNET_HashCode in;
   struct GNUNET_CRYPTO_RsaPrivateKey *hostkey;
 
   GNUNET_log_setup ("test-crypto-ksk", "WARNING", NULL);
diff --git a/src/util/test_pseudonym.c b/src/util/test_pseudonym.c
index 4ce8b3853..f0233771a 100644
--- a/src/util/test_pseudonym.c
+++ b/src/util/test_pseudonym.c
@@ -35,16 +35,16 @@
 
 static struct GNUNET_CONTAINER_MetaData *meta;
 
-static GNUNET_HashCode id1;
+static struct GNUNET_HashCode id1;
 
 static int
-iter (void *cls, const GNUNET_HashCode * pseudonym,
+iter (void *cls, const struct GNUNET_HashCode * pseudonym,
       const char *name, const char *unique_name,
       const struct GNUNET_CONTAINER_MetaData *md, int rating)
 {
   int *ok = cls;
 
-  if ((0 == memcmp (pseudonym, &id1, sizeof (GNUNET_HashCode))) &&
+  if ((0 == memcmp (pseudonym, &id1, sizeof (struct GNUNET_HashCode))) &&
       (!GNUNET_CONTAINER_meta_data_test_equal (md, meta)))
   {
     *ok = GNUNET_NO;
@@ -54,7 +54,7 @@ iter (void *cls, const GNUNET_HashCode * pseudonym,
 }
 
 static int
-noti_callback (void *cls, const GNUNET_HashCode * pseudonym,
+noti_callback (void *cls, const struct GNUNET_HashCode * pseudonym,
                const char *name, const char *unique_name,
                const struct GNUNET_CONTAINER_MetaData *md, int rating)
 {
@@ -65,7 +65,7 @@ noti_callback (void *cls, const GNUNET_HashCode * pseudonym,
 }
 
 static int
-fake_noti_callback (void *cls, const GNUNET_HashCode * pseudonym,
+fake_noti_callback (void *cls, const struct GNUNET_HashCode * pseudonym,
                     const char *name, const char *unique_name,
                     const struct GNUNET_CONTAINER_MetaData *md, int rating)
 {
@@ -76,7 +76,7 @@ fake_noti_callback (void *cls, const GNUNET_HashCode * pseudonym,
 }
 
 static int
-false_callback (void *cls, const GNUNET_HashCode * pseudonym,
+false_callback (void *cls, const struct GNUNET_HashCode * pseudonym,
                 const char *name, const char *unique_name,
                 const struct GNUNET_CONTAINER_MetaData *md, int rating)
 {
@@ -87,11 +87,11 @@ int
 main (int argc, char *argv[])
 {
   int ok;
-  GNUNET_HashCode rid1;
-  GNUNET_HashCode id2;
-  GNUNET_HashCode rid2;
-  GNUNET_HashCode fid;
-  GNUNET_HashCode id3;
+  struct GNUNET_HashCode rid1;
+  struct GNUNET_HashCode id2;
+  struct GNUNET_HashCode rid2;
+  struct GNUNET_HashCode fid;
+  struct GNUNET_HashCode id3;
 
   int old;
   int newVal;
@@ -174,8 +174,8 @@ main (int argc, char *argv[])
   CHECK (GNUNET_SYSERR == GNUNET_PSEUDONYM_name_to_id (cfg, name1, &rid1));
   CHECK (GNUNET_OK == GNUNET_PSEUDONYM_name_to_id (cfg, name2_unique, &rid2));
   CHECK (GNUNET_OK == GNUNET_PSEUDONYM_name_to_id (cfg, name1_unique, &rid1));
-  CHECK (0 == memcmp (&id1, &rid1, sizeof (GNUNET_HashCode)));
-  CHECK (0 == memcmp (&id2, &rid2, sizeof (GNUNET_HashCode)));
+  CHECK (0 == memcmp (&id1, &rid1, sizeof (struct GNUNET_HashCode)));
+  CHECK (0 == memcmp (&id2, &rid2, sizeof (struct GNUNET_HashCode)));
 
   GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &fid);
   GNUNET_log_skip (1, GNUNET_NO);