27 files changed, 175 insertions, 175 deletions

diff --git a/src/fs/fs.h b/src/fs/fs.h
index 059b8920d..3aa9fcc1b 100644
--- a/src/fs/fs.h
+++ b/src/fs/fs.h
@@ -55,12 +55,12 @@ struct ContentHashKey
   /**
    * Hash of the original content, used for encryption.
    */
-  GNUNET_HashCode key;
+  struct GNUNET_HashCode key;
 
   /**
    * Hash of the encrypted content, used for querying.
    */
-  GNUNET_HashCode query;
+  struct GNUNET_HashCode query;
 };
 
 
@@ -112,7 +112,7 @@ struct IndexStartMessage
   /**
    * Hash of the file that we would like to index.
    */
-  GNUNET_HashCode file_id;
+  struct GNUNET_HashCode file_id;
 
   /* this is followed by a 0-terminated
    * filename of a file with the hash
@@ -141,7 +141,7 @@ struct IndexInfoMessage
   /**
    * Hash of the indexed file.
    */
-  GNUNET_HashCode file_id;
+  struct GNUNET_HashCode file_id;
 
   /* this is followed by a 0-terminated
    * filename of a file with the hash
@@ -174,7 +174,7 @@ struct UnindexMessage
   /**
    * Hash of the file that we will unindex.
    */
-  GNUNET_HashCode file_id;
+  struct GNUNET_HashCode file_id;
 
 };
 
@@ -245,7 +245,7 @@ struct SearchMessage
    * <p>
    * If the request is for a KBLOCK, "target" must be all zeros.
    */
-  GNUNET_HashCode target;
+  struct GNUNET_HashCode target;
 
   /**
    * Hash of the keyword (aka query) for KBLOCKs; Hash of
@@ -253,7 +253,7 @@ struct SearchMessage
    * and hash of the identifier XORed with the target for
    * SBLOCKS (aka query).
    */
-  GNUNET_HashCode query;
+  struct GNUNET_HashCode query;
 
   /* this is followed by the hash codes of already-known
    * results (which should hence be excluded from what
diff --git a/src/fs/fs_api.c b/src/fs/fs_api.c
index 4265d8d51..28c887ddd 100644
--- a/src/fs/fs_api.c
+++ b/src/fs/fs_api.c
@@ -819,7 +819,7 @@ deserialize_fi_node (struct GNUNET_FS_Handle *h, const char *fn,
     if ((GNUNET_OK != GNUNET_BIO_read_int64 (rh, &ret->data.file.file_size)) ||
         (GNUNET_OK !=
          GNUNET_BIO_read (rh, "fileid", &ret->data.file.file_id,
-                          sizeof (GNUNET_HashCode))))
+                          sizeof (struct GNUNET_HashCode))))
     {
       GNUNET_break (0);
       goto cleanup;
@@ -841,7 +841,7 @@ deserialize_fi_node (struct GNUNET_FS_Handle *h, const char *fn,
     if ((GNUNET_OK != GNUNET_BIO_read_int64 (rh, &ret->data.file.file_size)) ||
         (GNUNET_OK !=
          GNUNET_BIO_read (rh, "fileid", &ret->data.file.file_id,
-                          sizeof (GNUNET_HashCode))))
+                          sizeof (struct GNUNET_HashCode))))
     {
       GNUNET_break (0);
       goto cleanup;
@@ -1198,7 +1198,7 @@ GNUNET_FS_file_information_sync_ (struct GNUNET_FS_FileInformation *fi)
     if ((GNUNET_OK != GNUNET_BIO_write_int64 (wh, fi->data.file.file_size)) ||
         (GNUNET_OK !=
          GNUNET_BIO_write (wh, &fi->data.file.file_id,
-                           sizeof (GNUNET_HashCode))))
+                           sizeof (struct GNUNET_HashCode))))
     {
       GNUNET_break (0);
       goto cleanup;
@@ -1575,7 +1575,7 @@ GNUNET_FS_unindex_sync_ (struct GNUNET_FS_UnindexContext *uc)
       (GNUNET_OK != GNUNET_BIO_write_int32 (wh, (uint32_t) uc->ksk_offset)) ||
       ((uc->state == UNINDEX_STATE_FS_NOTIFY) &&
        (GNUNET_OK !=
-        GNUNET_BIO_write (wh, &uc->file_id, sizeof (GNUNET_HashCode)))) ||
+        GNUNET_BIO_write (wh, &uc->file_id, sizeof (struct GNUNET_HashCode)))) ||
       ((uc->state == UNINDEX_STATE_ERROR) &&
        (GNUNET_OK != GNUNET_BIO_write_string (wh, uc->emsg))))
   {
@@ -1875,7 +1875,7 @@ GNUNET_FS_search_result_sync_ (struct GNUNET_FS_SearchResult *sr)
                                 sr->update_search !=
                                 NULL ? sr->update_search->serialization : NULL))
       || (GNUNET_OK != GNUNET_BIO_write_meta_data (wh, sr->meta)) ||
-      (GNUNET_OK != GNUNET_BIO_write (wh, &sr->key, sizeof (GNUNET_HashCode)))
+      (GNUNET_OK != GNUNET_BIO_write (wh, &sr->key, sizeof (struct GNUNET_HashCode)))
       || (GNUNET_OK != GNUNET_BIO_write_int32 (wh, sr->mandatory_missing)) ||
       (GNUNET_OK != GNUNET_BIO_write_int32 (wh, sr->optional_support)) ||
       (GNUNET_OK != GNUNET_BIO_write_int32 (wh, sr->availability_success)) ||
@@ -2045,7 +2045,7 @@ deserialize_unindex_file (void *cls, const char *filename)
   case UNINDEX_STATE_FS_NOTIFY:
     if (GNUNET_OK !=
         GNUNET_BIO_read (rh, "unindex-hash", &uc->file_id,
-                         sizeof (GNUNET_HashCode)))
+                         sizeof (struct GNUNET_HashCode)))
     {
       GNUNET_break (0);
       goto cleanup;
@@ -2211,7 +2211,7 @@ deserialize_search_result (void *cls, const char *filename)
           GNUNET_BIO_read_string (rh, "search-lnk", &update_srch, 16)) ||
       (GNUNET_OK != GNUNET_BIO_read_meta_data (rh, "result-meta", &sr->meta)) ||
       (GNUNET_OK !=
-       GNUNET_BIO_read (rh, "result-key", &sr->key, sizeof (GNUNET_HashCode)))
+       GNUNET_BIO_read (rh, "result-key", &sr->key, sizeof (struct GNUNET_HashCode)))
       || (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &sr->mandatory_missing)) ||
       (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &sr->optional_support)) ||
       (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &sr->availability_success)) ||
@@ -2346,7 +2346,7 @@ signal_search_resume (struct GNUNET_FS_SearchContext *sc);
  * @return GNUNET_YES (we should continue to iterate)
  */
 static int
-signal_result_resume (void *cls, const GNUNET_HashCode * key, void *value)
+signal_result_resume (void *cls, const struct GNUNET_HashCode * key, void *value)
 {
   struct GNUNET_FS_SearchContext *sc = cls;
   struct GNUNET_FS_ProgressInfo pi;
@@ -2398,7 +2398,7 @@ free_search_context (struct GNUNET_FS_SearchContext *sc);
  * @return GNUNET_YES (we should continue to iterate)
  */
 static int
-free_result (void *cls, const GNUNET_HashCode * key, void *value)
+free_result (void *cls, const struct GNUNET_HashCode * key, void *value)
 {
   struct GNUNET_FS_SearchResult *sr = value;
 
diff --git a/src/fs/fs_api.h b/src/fs/fs_api.h
index e75b75f41..7c91b5d23 100644
--- a/src/fs/fs_api.h
+++ b/src/fs/fs_api.h
@@ -205,7 +205,7 @@ struct GNUNET_FS_Uri
       /**
        * Hash of the public key for the namespace.
        */
-      GNUNET_HashCode namespace;
+      struct GNUNET_HashCode namespace;
 
       /**
        * Human-readable identifier chosen for this
@@ -333,7 +333,7 @@ struct GNUNET_FS_FileInformation
        * over the entire file (when the indexing process is started).
        * Otherwise this field is not used.
        */
-      GNUNET_HashCode file_id;
+      struct GNUNET_HashCode file_id;
 
       /**
        * Size of the file (in bytes).
@@ -568,7 +568,7 @@ struct GNUNET_FS_SearchResult
   /**
    * Key for the search result
    */
-  GNUNET_HashCode key;
+  struct GNUNET_HashCode key;
 
   /**
    * ID of the task that will clean up the probe_ctx should it not
@@ -730,7 +730,7 @@ GNUNET_FS_publish_main_ (void *cls,
  * @param file_id computed hash, NULL on error
  */
 void
-GNUNET_FS_unindex_process_hash_ (void *cls, const GNUNET_HashCode * file_id);
+GNUNET_FS_unindex_process_hash_ (void *cls, const struct GNUNET_HashCode * file_id);
 
 
 /**
@@ -1384,12 +1384,12 @@ struct GNUNET_FS_UnindexContext
   /**
    * Current key for decrypting KBLocks from 'get_key' operation.
    */
-  GNUNET_HashCode key;
+  struct GNUNET_HashCode key;
 
   /**
    * Current query of 'get_key' operation.
    */
-  GNUNET_HashCode query;
+  struct GNUNET_HashCode query;
 
   /**
    * First content UID, 0 for none.
@@ -1424,7 +1424,7 @@ struct GNUNET_FS_UnindexContext
   /**
    * Hash of the file's contents (once computed).
    */
-  GNUNET_HashCode file_id;
+  struct GNUNET_HashCode file_id;
 
   /**
    * Current operatinonal phase.
@@ -1444,12 +1444,12 @@ struct SearchRequestEntry
    * Hash of the original keyword, also known as the
    * key (for decrypting the KBlock).
    */
-  GNUNET_HashCode key;
+  struct GNUNET_HashCode key;
 
   /**
    * Hash of the public key, also known as the query.
    */
-  GNUNET_HashCode query;
+  struct GNUNET_HashCode query;
 
   /**
    * Map that contains a "struct GNUNET_FS_SearchResult" for each result that
diff --git a/src/fs/fs_download.c b/src/fs/fs_download.c
index 61178766b..fbbbc2f23 100644
--- a/src/fs/fs_download.c
+++ b/src/fs/fs_download.c
@@ -153,7 +153,7 @@ struct ProcessResultClosure
   /**
    * Hash of data.
    */
-  GNUNET_HashCode query;
+  struct GNUNET_HashCode query;
 
   /**
    * Data found in P2P network.
@@ -198,7 +198,7 @@ struct ProcessResultClosure
  * @return GNUNET_YES (we should continue to iterate); unless serious error
  */
 static int
-process_result_with_request (void *cls, const GNUNET_HashCode * key,
+process_result_with_request (void *cls, const struct GNUNET_HashCode * key,
                              void *value);
 
 
@@ -225,7 +225,7 @@ encrypt_existing_match (struct GNUNET_FS_DownloadContext *dc,
   char enc[len];
   struct GNUNET_CRYPTO_AesSessionKey sk;
   struct GNUNET_CRYPTO_AesInitializationVector iv;
-  GNUNET_HashCode query;
+  struct GNUNET_HashCode query;
 
   GNUNET_CRYPTO_hash_to_aes_key (&chk->key, &sk, &iv);
   if (-1 == GNUNET_CRYPTO_aes_encrypt (block, len, &sk, &iv, enc))
@@ -234,7 +234,7 @@ encrypt_existing_match (struct GNUNET_FS_DownloadContext *dc,
     return GNUNET_SYSERR;
   }
   GNUNET_CRYPTO_hash (enc, len, &query);
-  if (0 != memcmp (&query, &chk->query, sizeof (GNUNET_HashCode)))
+  if (0 != memcmp (&query, &chk->query, sizeof (struct GNUNET_HashCode)))
   {
     GNUNET_break_op (0);
     return GNUNET_SYSERR;
@@ -624,7 +624,7 @@ try_top_down_reconstruction (struct GNUNET_FS_DownloadContext *dc,
 {
   uint64_t off;
   char block[DBLOCK_SIZE];
-  GNUNET_HashCode key;
+  struct GNUNET_HashCode key;
   uint64_t total;
   size_t len;
   unsigned int i;
@@ -653,7 +653,7 @@ try_top_down_reconstruction (struct GNUNET_FS_DownloadContext *dc,
     return;                     /* failure */
   }
   GNUNET_CRYPTO_hash (block, len, &key);
-  if (0 != memcmp (&key, &dr->chk.key, sizeof (GNUNET_HashCode)))
+  if (0 != memcmp (&key, &dr->chk.key, sizeof (struct GNUNET_HashCode)))
     return;                     /* mismatch */
   if (GNUNET_OK !=
       encrypt_existing_match (dc, &dr->chk, dr, block, len, GNUNET_NO))
@@ -926,7 +926,7 @@ GNUNET_FS_free_download_request_ (struct DownloadRequest *dr)
  * @return GNUNET_YES (we should continue to iterate); unless serious error
  */
 static int
-process_result_with_request (void *cls, const GNUNET_HashCode * key,
+process_result_with_request (void *cls, const struct GNUNET_HashCode * key,
                              void *value)
 {
   struct ProcessResultClosure *prc = cls;
@@ -1376,7 +1376,7 @@ do_reconnect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * @return GNUNET_OK
  */
 static int
-retry_entry (void *cls, const GNUNET_HashCode * key, void *entry)
+retry_entry (void *cls, const struct GNUNET_HashCode * key, void *entry)
 {
   struct GNUNET_FS_DownloadContext *dc = cls;
   struct DownloadRequest *dr = entry;
diff --git a/src/fs/fs_namespace.c b/src/fs/fs_namespace.c
index bfd7594ef..4f58b7d5b 100644
--- a/src/fs/fs_namespace.c
+++ b/src/fs/fs_namespace.c
@@ -359,7 +359,7 @@ process_namespace (void *cls, const char *filename)
   struct ProcessNamespaceContext *pnc = cls;
   struct GNUNET_CRYPTO_RsaPrivateKey *key;
   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pk;
-  GNUNET_HashCode id;
+  struct GNUNET_HashCode id;
   const char *name;
   const char *t;
 
@@ -470,7 +470,7 @@ sb_put_cont (void *cls, int success,
              const char *msg)
 {
   struct GNUNET_FS_PublishSksContext *psc = cls;
-  GNUNET_HashCode hc;
+  struct GNUNET_HashCode hc;
 
   psc->dqe = NULL;
   if (GNUNET_OK != success)
@@ -544,9 +544,9 @@ GNUNET_FS_publish_sks (struct GNUNET_FS_Handle *h,
   struct SBlock *sb_enc;
   char *dest;
   struct GNUNET_CONTAINER_MetaData *mmeta;
-  GNUNET_HashCode key;          /* hash of thisId = key */
-  GNUNET_HashCode id;           /* hash of hc = identifier */
-  GNUNET_HashCode query;        /* id ^ nsid = DB query */
+  struct GNUNET_HashCode key;          /* hash of thisId = key */
+  struct GNUNET_HashCode id;           /* hash of hc = identifier */
+  struct GNUNET_HashCode query;        /* id ^ nsid = DB query */
 
   if (NULL == meta)
     mmeta = GNUNET_CONTAINER_meta_data_create ();
@@ -591,7 +591,7 @@ GNUNET_FS_publish_sks (struct GNUNET_FS_Handle *h,
   size = sizeof (struct SBlock) + mdsize + slen + nidlen;
   sb_enc = GNUNET_malloc (size);
   GNUNET_CRYPTO_hash (identifier, idlen, &key);
-  GNUNET_CRYPTO_hash (&key, sizeof (GNUNET_HashCode), &id);
+  GNUNET_CRYPTO_hash (&key, sizeof (struct GNUNET_HashCode), &id);
   sks_uri = GNUNET_malloc (sizeof (struct GNUNET_FS_Uri));
   sks_uri->type = sks;
   GNUNET_CRYPTO_rsa_key_get_public (namespace->key, &sb_enc->subspace);
@@ -711,7 +711,7 @@ struct ProcessUpdateClosure
  *         GNUNET_NO if not.
  */
 static int
-process_update_node (void *cls, const GNUNET_HashCode * key, void *value)
+process_update_node (void *cls, const struct GNUNET_HashCode * key, void *value)
 {
   struct ProcessUpdateClosure *pc = cls;
   struct NamespaceUpdateNode *nsn = value;
@@ -774,11 +774,11 @@ struct FindTreeClosure
  *         GNUNET_NO if not.
  */
 static int
-find_trees (void *cls, const GNUNET_HashCode * key, void *value)
+find_trees (void *cls, const struct GNUNET_HashCode * key, void *value)
 {
   struct FindTreeClosure *fc = cls;
   struct NamespaceUpdateNode *nsn = value;
-  GNUNET_HashCode hc;
+  struct GNUNET_HashCode hc;
 
   if (nsn->nug == fc->nug)
   {
@@ -838,7 +838,7 @@ GNUNET_FS_namespace_list_updateable (struct GNUNET_FS_Namespace *namespace,
 {
   unsigned int i;
   unsigned int nug;
-  GNUNET_HashCode hc;
+  struct GNUNET_HashCode hc;
   struct NamespaceUpdateNode *nsn;
   struct ProcessUpdateClosure pc;
   struct FindTreeClosure fc;
diff --git a/src/fs/fs_namespace_advertise.c b/src/fs/fs_namespace_advertise.c
index e0226ca35..c0e15541c 100644
--- a/src/fs/fs_namespace_advertise.c
+++ b/src/fs/fs_namespace_advertise.c
@@ -132,8 +132,8 @@ advertisement_cont (void *cls, int success,
 {
   struct GNUNET_FS_AdvertisementContext *ac = cls;
   const char *keyword;
-  GNUNET_HashCode key;
-  GNUNET_HashCode query;
+  struct GNUNET_HashCode key;
+  struct GNUNET_HashCode query;
   struct GNUNET_CRYPTO_AesSessionKey skey;
   struct GNUNET_CRYPTO_AesInitializationVector iv;
   struct GNUNET_CRYPTO_RsaPrivateKey *pk;
diff --git a/src/fs/fs_publish.c b/src/fs/fs_publish.c
index 31cd795b2..6f8a9d248 100644
--- a/src/fs/fs_publish.c
+++ b/src/fs/fs_publish.c
@@ -658,7 +658,7 @@ process_index_start_response (void *cls, const struct GNUNET_MessageHeader *msg)
  * @param res resulting hash, NULL on error
  */
 static void
-hash_for_index_cb (void *cls, const GNUNET_HashCode * res)
+hash_for_index_cb (void *cls, const struct GNUNET_HashCode * res)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
   struct GNUNET_FS_FileInformation *p;
diff --git a/src/fs/fs_publish_ksk.c b/src/fs/fs_publish_ksk.c
index 0b6d407ab..5511fb93d 100644
--- a/src/fs/fs_publish_ksk.c
+++ b/src/fs/fs_publish_ksk.c
@@ -172,8 +172,8 @@ publish_ksk_cont (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_FS_PublishKskContext *pkc = cls;
   const char *keyword;
-  GNUNET_HashCode key;
-  GNUNET_HashCode query;
+  struct GNUNET_HashCode key;
+  struct GNUNET_HashCode query;
   struct GNUNET_CRYPTO_AesSessionKey skey;
   struct GNUNET_CRYPTO_AesInitializationVector iv;
   struct GNUNET_CRYPTO_RsaPrivateKey *pk;
diff --git a/src/fs/fs_search.c b/src/fs/fs_search.c
index adbb85dc0..542d8f2e9 100644
--- a/src/fs/fs_search.c
+++ b/src/fs/fs_search.c
@@ -74,7 +74,7 @@ GNUNET_FS_search_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
  *         GNUNET_OK otherwise
  */
 static int
-test_result_present (void *cls, const GNUNET_HashCode * key, void *value)
+test_result_present (void *cls, const struct GNUNET_HashCode * key, void *value)
 {
   const struct GNUNET_FS_Uri *uri = cls;
   struct GNUNET_FS_SearchResult *sr = value;
@@ -162,7 +162,7 @@ struct GetResultContext
  * @return GNUNET_OK
  */
 static int
-get_result_present (void *cls, const GNUNET_HashCode * key, void *value)
+get_result_present (void *cls, const struct GNUNET_HashCode * key, void *value)
 {
   struct GetResultContext *grc = cls;
   struct GNUNET_FS_SearchResult *sr = value;
@@ -388,7 +388,7 @@ process_ksk_result (struct GNUNET_FS_SearchContext *sc,
                     const struct GNUNET_FS_Uri *uri,
                     const struct GNUNET_CONTAINER_MetaData *meta)
 {
-  GNUNET_HashCode key;
+  struct GNUNET_HashCode key;
   struct GNUNET_FS_SearchResult *sr;
   struct GetResultContext grc;
   int is_new;
@@ -477,7 +477,7 @@ process_sks_result (struct GNUNET_FS_SearchContext *sc, const char *id_update,
                     const struct GNUNET_CONTAINER_MetaData *meta)
 {
   struct GNUNET_FS_Uri uu;
-  GNUNET_HashCode key;
+  struct GNUNET_HashCode key;
   struct GNUNET_FS_SearchResult *sr;
 
   /* check if new */
@@ -533,7 +533,7 @@ decrypt_block_with_keyword (const struct GNUNET_FS_SearchContext *sc,
                             size_t edata_size,
                             char *data)
 { 
-  GNUNET_HashCode q;
+  struct GNUNET_HashCode q;
   struct GNUNET_CRYPTO_AesSessionKey skey;
   struct GNUNET_CRYPTO_AesInitializationVector iv;
   int i;
@@ -543,7 +543,7 @@ decrypt_block_with_keyword (const struct GNUNET_FS_SearchContext *sc,
                       &q);
   /* find key */
   for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
-    if (0 == memcmp (&q, &sc->requests[i].query, sizeof (GNUNET_HashCode)))
+    if (0 == memcmp (&q, &sc->requests[i].query, sizeof (struct GNUNET_HashCode)))
       break;
   if (i == sc->uri->data.ksk.keywordCount)
   {
@@ -708,7 +708,7 @@ process_sblock (struct GNUNET_FS_SearchContext *sc, const struct SBlock *sb,
   const char *uris;
   size_t off;
   char *emsg;
-  GNUNET_HashCode key;
+  struct GNUNET_HashCode key;
   char *identifier;
 
   /* decrypt */
@@ -904,7 +904,7 @@ struct MessageBuilderContext
   /**
    * Where to store the keys.
    */
-  GNUNET_HashCode *xoff;
+  struct GNUNET_HashCode *xoff;
 
   /**
    * Search context we are iterating for.
@@ -928,7 +928,7 @@ struct MessageBuilderContext
  * @return GNUNET_OK to continue iterating
  */
 static int
-build_result_set (void *cls, const GNUNET_HashCode * key, void *value)
+build_result_set (void *cls, const struct GNUNET_HashCode * key, void *value)
 {
   struct MessageBuilderContext *mbc = cls;
   struct GNUNET_FS_SearchResult *sr = value;
@@ -960,7 +960,7 @@ build_result_set (void *cls, const GNUNET_HashCode * key, void *value)
  * @return GNUNET_OK to continue iterating
  */
 static int
-find_result_set (void *cls, const GNUNET_HashCode * key, void *value)
+find_result_set (void *cls, const struct GNUNET_HashCode * key, void *value)
 {
   struct MessageBuilderContext *mbc = cls;
   struct GNUNET_FS_SearchResult *sr = value;
@@ -990,8 +990,8 @@ transmit_search_request (void *cls, size_t size, void *buf)
   size_t msize;
   struct SearchMessage *sm;
   const char *identifier;
-  GNUNET_HashCode key;
-  GNUNET_HashCode idh;
+  struct GNUNET_HashCode key;
+  struct GNUNET_HashCode idh;
   unsigned int sqms;
   uint32_t options;
 
@@ -1004,7 +1004,7 @@ transmit_search_request (void *cls, size_t size, void *buf)
   mbc.skip_cnt = sc->search_request_map_offset;
   sm = buf;
   sm->header.type = htons (GNUNET_MESSAGE_TYPE_FS_START_SEARCH);
-  mbc.xoff = (GNUNET_HashCode *) & sm[1];
+  mbc.xoff = (struct GNUNET_HashCode *) & sm[1];
   options = SEARCH_MESSAGE_OPTION_NONE;
   if (0 != (sc->options & GNUNET_FS_SEARCH_OPTION_LOOPBACK_ONLY))
     options |= SEARCH_MESSAGE_OPTION_LOOPBACK_ONLY;
@@ -1017,7 +1017,7 @@ transmit_search_request (void *cls, size_t size, void *buf)
     GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
                                            &find_result_set, &mbc);
     sqms = mbc.put_cnt;
-    mbc.put_cnt = (size - msize) / sizeof (GNUNET_HashCode);
+    mbc.put_cnt = (size - msize) / sizeof (struct GNUNET_HashCode);
     mbc.put_cnt = GNUNET_MIN (mbc.put_cnt, sqms - mbc.skip_cnt);
     if (sc->search_request_map_offset < sqms)
       GNUNET_assert (mbc.put_cnt > 0);
@@ -1025,9 +1025,9 @@ transmit_search_request (void *cls, size_t size, void *buf)
     sm->header.size = htons (msize);
     sm->type = htonl (GNUNET_BLOCK_TYPE_ANY);
     sm->anonymity_level = htonl (sc->anonymity);
-    memset (&sm->target, 0, sizeof (GNUNET_HashCode));
+    memset (&sm->target, 0, sizeof (struct GNUNET_HashCode));
     sm->query = sc->requests[sc->keyword_offset].query;
-    msize += sizeof (GNUNET_HashCode) * mbc.put_cnt;
+    msize += sizeof (struct GNUNET_HashCode) * mbc.put_cnt;
     GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
                                            &build_result_set, &mbc);
     sm->header.size = htons (msize);
@@ -1058,15 +1058,15 @@ transmit_search_request (void *cls, size_t size, void *buf)
     sm->target = sc->uri->data.sks.namespace;
     identifier = sc->uri->data.sks.identifier;
     GNUNET_CRYPTO_hash (identifier, strlen (identifier), &key);
-    GNUNET_CRYPTO_hash (&key, sizeof (GNUNET_HashCode), &idh);
+    GNUNET_CRYPTO_hash (&key, sizeof (struct GNUNET_HashCode), &idh);
     GNUNET_CRYPTO_hash_xor (&idh, &sm->target, &sm->query);
-    mbc.put_cnt = (size - msize) / sizeof (GNUNET_HashCode);
+    mbc.put_cnt = (size - msize) / sizeof (struct GNUNET_HashCode);
     sqms = GNUNET_CONTAINER_multihashmap_size (sc->master_result_map);
     mbc.put_cnt = GNUNET_MIN (mbc.put_cnt, sqms - mbc.skip_cnt);
     mbc.keyword_offset = 0;
     if (sc->search_request_map_offset < sqms)
       GNUNET_assert (mbc.put_cnt > 0);
-    msize += sizeof (GNUNET_HashCode) * mbc.put_cnt;
+    msize += sizeof (struct GNUNET_HashCode) * mbc.put_cnt;
     GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
                                            &build_result_set, &mbc);
     sm->header.size = htons (msize);
@@ -1103,9 +1103,9 @@ schedule_transmit_search_request (struct GNUNET_FS_SearchContext *sc)
   sqms =
       GNUNET_CONTAINER_multihashmap_size (sc->master_result_map) -
       sc->search_request_map_offset;
-  fit = (GNUNET_SERVER_MAX_MESSAGE_SIZE - 1 - size) / sizeof (GNUNET_HashCode);
+  fit = (GNUNET_SERVER_MAX_MESSAGE_SIZE - 1 - size) / sizeof (struct GNUNET_HashCode);
   fit = GNUNET_MIN (fit, sqms);
-  size += sizeof (GNUNET_HashCode) * fit;
+  size += sizeof (struct GNUNET_HashCode) * fit;
   GNUNET_CLIENT_notify_transmit_ready (sc->client, size,
                                        GNUNET_CONSTANTS_SERVICE_TIMEOUT,
                                        GNUNET_NO, &transmit_search_request, sc);
@@ -1220,7 +1220,7 @@ GNUNET_FS_search_start_searching_ (struct GNUNET_FS_SearchContext *sc)
 {
   unsigned int i;
   const char *keyword;
-  GNUNET_HashCode hc;
+  struct GNUNET_HashCode hc;
   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pub;
   struct GNUNET_CRYPTO_RsaPrivateKey *pk;
 
@@ -1267,7 +1267,7 @@ GNUNET_FS_search_start_searching_ (struct GNUNET_FS_SearchContext *sc)
  * @return GNUNET_OK
  */
 static int
-search_result_freeze_probes (void *cls, const GNUNET_HashCode * key,
+search_result_freeze_probes (void *cls, const struct GNUNET_HashCode * key,
                              void *value)
 {
   struct GNUNET_FS_SearchResult *sr = value;
@@ -1297,7 +1297,7 @@ search_result_freeze_probes (void *cls, const GNUNET_HashCode * key,
  * @return GNUNET_OK
  */
 static int
-search_result_resume_probes (void *cls, const GNUNET_HashCode * key,
+search_result_resume_probes (void *cls, const struct GNUNET_HashCode * key,
                              void *value)
 {
   struct GNUNET_FS_SearchResult *sr = value;
@@ -1318,7 +1318,7 @@ search_result_resume_probes (void *cls, const GNUNET_HashCode * key,
  * @return GNUNET_OK
  */
 static int
-search_result_suspend (void *cls, const GNUNET_HashCode * key, void *value)
+search_result_suspend (void *cls, const struct GNUNET_HashCode * key, void *value)
 {
   struct GNUNET_FS_SearchContext *sc = cls;
   struct GNUNET_FS_SearchResult *sr = value;
@@ -1477,7 +1477,7 @@ GNUNET_FS_search_continue (struct GNUNET_FS_SearchContext *sc)
  * @return GNUNET_OK
  */
 static int
-search_result_stop (void *cls, const GNUNET_HashCode * key, void *value)
+search_result_stop (void *cls, const struct GNUNET_HashCode * key, void *value)
 {
   struct GNUNET_FS_SearchContext *sc = cls;
   struct GNUNET_FS_SearchResult *sr = value;
@@ -1530,7 +1530,7 @@ search_result_stop (void *cls, const GNUNET_HashCode * key, void *value)
  * @return GNUNET_OK
  */
 static int
-search_result_free (void *cls, const GNUNET_HashCode * key, void *value)
+search_result_free (void *cls, const struct GNUNET_HashCode * key, void *value)
 {
   struct GNUNET_FS_SearchResult *sr = value;
 
diff --git a/src/fs/fs_sharetree.c b/src/fs/fs_sharetree.c
index c929428e1..f75571c46 100644
--- a/src/fs/fs_sharetree.c
+++ b/src/fs/fs_sharetree.c
@@ -162,7 +162,7 @@ add_to_keyword_counter (void *cls, const char *keyword, int is_mandatory)
 {
   struct GNUNET_CONTAINER_MultiHashMap *mcm = cls;
   struct KeywordCounter *cnt;
-  GNUNET_HashCode hc;
+  struct GNUNET_HashCode hc;
   size_t klen;
 
   klen = strlen (keyword) + 1;
@@ -206,7 +206,7 @@ add_to_meta_counter (void *cls, const char *plugin_name,
                      const char *data_mime_type, const char *data, size_t data_len)
 {
   struct GNUNET_CONTAINER_MultiHashMap *map = cls;
-  GNUNET_HashCode key;
+  struct GNUNET_HashCode key;
   struct MetaCounter *cnt;
 
   GNUNET_CRYPTO_hash (data, data_len, &key);
@@ -243,7 +243,7 @@ remove_high_frequency_keywords (void *cls, const char *keyword, int is_mandatory
 {
   struct TrimContext *tc = cls;
   struct KeywordCounter *counter;
-  GNUNET_HashCode hc;
+  struct GNUNET_HashCode hc;
   size_t klen;
 
   klen = strlen (keyword) + 1;
@@ -268,7 +268,7 @@ remove_high_frequency_keywords (void *cls, const char *keyword, int is_mandatory
  * @return GNUNET_YES (always)
  */
 static int
-migrate_and_drop_keywords (void *cls, const GNUNET_HashCode * key, void *value)
+migrate_and_drop_keywords (void *cls, const struct GNUNET_HashCode * key, void *value)
 {
   struct TrimContext *tc = cls;
   struct KeywordCounter *counter = value;
@@ -299,7 +299,7 @@ migrate_and_drop_keywords (void *cls, const GNUNET_HashCode * key, void *value)
  * @return GNUNET_YES (always)
  */
 static int
-migrate_and_drop_metadata (void *cls, const GNUNET_HashCode * key, void *value)
+migrate_and_drop_metadata (void *cls, const struct GNUNET_HashCode * key, void *value)
 {
   struct TrimContext *tc = cls;
   struct MetaCounter *counter = value;
diff --git a/src/fs/fs_unindex.c b/src/fs/fs_unindex.c
index 691032183..71a1b9e0b 100644
--- a/src/fs/fs_unindex.c
+++ b/src/fs/fs_unindex.c
@@ -437,7 +437,7 @@ continue_after_remove (void *cls,
  */
 static void
 process_kblock_for_unindex (void *cls,
-                            const GNUNET_HashCode * key,
+                            const struct GNUNET_HashCode * key,
                             size_t size, const void *data,
                             enum GNUNET_BLOCK_Type type,
                             uint32_t priority,
@@ -649,7 +649,7 @@ GNUNET_FS_unindex_do_remove_ (struct GNUNET_FS_UnindexContext *uc)
  * @param file_id computed hash, NULL on error
  */
 void
-GNUNET_FS_unindex_process_hash_ (void *cls, const GNUNET_HashCode * file_id)
+GNUNET_FS_unindex_process_hash_ (void *cls, const struct GNUNET_HashCode * file_id)
 {
   struct GNUNET_FS_UnindexContext *uc = cls;
 
diff --git a/src/fs/fs_uri.c b/src/fs/fs_uri.c
index 0c2d64cac..8d8479d8f 100644
--- a/src/fs/fs_uri.c
+++ b/src/fs/fs_uri.c
@@ -98,7 +98,7 @@
  * @param key wherer to store the unique key
  */
 void
-GNUNET_FS_uri_to_key (const struct GNUNET_FS_Uri *uri, GNUNET_HashCode * key)
+GNUNET_FS_uri_to_key (const struct GNUNET_FS_Uri *uri, struct GNUNET_HashCode * key)
 {
   switch (uri->type)
   {
@@ -121,7 +121,7 @@ GNUNET_FS_uri_to_key (const struct GNUNET_FS_Uri *uri, GNUNET_HashCode * key)
                         key);
     break;
   default:
-    memset (key, 0, sizeof (GNUNET_HashCode));
+    memset (key, 0, sizeof (struct GNUNET_HashCode));
     break;
   }
 }
@@ -355,7 +355,7 @@ static struct GNUNET_FS_Uri *
 uri_sks_parse (const char *s, char **emsg)
 {
   struct GNUNET_FS_Uri *ret;
-  GNUNET_HashCode namespace;
+  struct GNUNET_HashCode namespace;
   char *identifier;
   unsigned int pos;
   size_t slen;
@@ -963,7 +963,7 @@ GNUNET_FS_uri_sks_create (struct GNUNET_FS_Namespace *ns, const char *id,
  * @return an FS URI for the given namespace and identifier
  */
 struct GNUNET_FS_Uri *
-GNUNET_FS_uri_sks_create_from_nsid (GNUNET_HashCode * nsid, const char *id)
+GNUNET_FS_uri_sks_create_from_nsid (struct GNUNET_HashCode * nsid, const char *id)
 {
   struct GNUNET_FS_Uri *ns_uri;
 
@@ -1273,7 +1273,7 @@ GNUNET_FS_uri_test_equal (const struct GNUNET_FS_Uri *u1,
   case sks:
     if ((0 ==
          memcmp (&u1->data.sks.namespace, &u2->data.sks.namespace,
-                 sizeof (GNUNET_HashCode))) &&
+                 sizeof (struct GNUNET_HashCode))) &&
         (0 == strcmp (u1->data.sks.identifier, u2->data.sks.identifier)))
 
       return GNUNET_YES;
@@ -1334,7 +1334,7 @@ GNUNET_FS_uri_test_sks (const struct GNUNET_FS_Uri *uri)
  */
 int
 GNUNET_FS_uri_sks_get_namespace (const struct GNUNET_FS_Uri *uri,
-                                 GNUNET_HashCode * nsid)
+                                 struct GNUNET_HashCode * nsid)
 {
   if (!GNUNET_FS_uri_test_sks (uri))
   {
@@ -1931,7 +1931,7 @@ uri_ksk_to_string (const struct GNUNET_FS_Uri *uri)
 static char *
 uri_sks_to_string (const struct GNUNET_FS_Uri *uri)
 {
-  const GNUNET_HashCode *namespace;
+  const struct GNUNET_HashCode *namespace;
   const char *identifier;
   char *ret;
   struct GNUNET_CRYPTO_HashAsciiEncoded ns;
diff --git a/src/fs/gnunet-fs.c b/src/fs/gnunet-fs.c
index 404c64e4d..ce6284aa4 100644
--- a/src/fs/gnunet-fs.c
+++ b/src/fs/gnunet-fs.c
@@ -55,7 +55,7 @@ static int verbose;
  * @return GNUNET_OK to continue iteration
  */
 static int
-print_indexed (void *cls, const char *filename, const GNUNET_HashCode * file_id)
+print_indexed (void *cls, const char *filename, const struct GNUNET_HashCode * file_id)
 {
   if (NULL == filename)
   {
diff --git a/src/fs/gnunet-pseudonym.c b/src/fs/gnunet-pseudonym.c
index 2b1b897c2..02b71b513 100644
--- a/src/fs/gnunet-pseudonym.c
+++ b/src/fs/gnunet-pseudonym.c
@@ -95,7 +95,7 @@ progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *info)
 
 
 static void
-ns_printer (void *cls, const char *name, const GNUNET_HashCode * id)
+ns_printer (void *cls, const char *name, const struct GNUNET_HashCode * id)
 {
   struct GNUNET_CRYPTO_HashAsciiEncoded enc;
 
@@ -105,7 +105,7 @@ ns_printer (void *cls, const char *name, const GNUNET_HashCode * id)
 
 
 static int
-pseudo_printer (void *cls, const GNUNET_HashCode * pseudonym,
+pseudo_printer (void *cls, const struct GNUNET_HashCode * pseudonym,
                 const char *name, const char *unique_name,
                 const struct GNUNET_CONTAINER_MetaData *md, int rating)
 {
@@ -136,7 +136,7 @@ pseudo_printer (void *cls, const GNUNET_HashCode * pseudonym,
 static void
 post_advertising (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
 {
-  GNUNET_HashCode nsid;
+  struct GNUNET_HashCode nsid;
   char *set;
   int delta;
 
diff --git a/src/fs/gnunet-service-fs.c b/src/fs/gnunet-service-fs.c
index 94e8e6b23..aa8e8de27 100644
--- a/src/fs/gnunet-service-fs.c
+++ b/src/fs/gnunet-service-fs.c
@@ -476,7 +476,7 @@ shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * @return GNUNET_YES to continue to iterate
  */
 static int
-consider_peer_for_forwarding (void *cls, const GNUNET_HashCode * key,
+consider_peer_for_forwarding (void *cls, const struct GNUNET_HashCode * key,
                               struct GSF_PendingRequest *pr)
 {
   struct GSF_ConnectedPeer *cp = cls;
diff --git a/src/fs/gnunet-service-fs.h b/src/fs/gnunet-service-fs.h
index 0c796bf9c..70e65186d 100644
--- a/src/fs/gnunet-service-fs.h
+++ b/src/fs/gnunet-service-fs.h
@@ -119,7 +119,7 @@ struct GetMessage
   /**
    * Which of the optional hash codes are present at the end of the
    * message?  See GET_MESSAGE_BIT_xx constants.  For each bit that is
-   * set, an additional GNUNET_HashCode with the respective content
+   * set, an additional struct GNUNET_HashCode with the respective content
    * (in order of the bits) will be appended to the end of the GET
    * message.
    */
@@ -129,7 +129,7 @@ struct GetMessage
    * Hashcodes of the file(s) we're looking for.
    * Details depend on the query type.
    */
-  GNUNET_HashCode query;
+  struct GNUNET_HashCode query;
 
   /* this is followed by hash codes as specified in the "hash_bitmap";
    * after that, an optional bloomfilter (with bits set for replies
diff --git a/src/fs/gnunet-service-fs_cp.c b/src/fs/gnunet-service-fs_cp.c
index 9c229251d..e021606a9 100644
--- a/src/fs/gnunet-service-fs_cp.c
+++ b/src/fs/gnunet-service-fs_cp.c
@@ -759,7 +759,7 @@ copy_reply (void *cls, size_t buf_size, void *buf)
  */
 static void
 free_pending_request (struct PeerRequest *peerreq,
-                      const GNUNET_HashCode *query)
+                      const struct GNUNET_HashCode *query)
 {
   struct GSF_ConnectedPeer *cp = peerreq->cp;
 
@@ -786,7 +786,7 @@ free_pending_request (struct PeerRequest *peerreq,
  * @return GNUNET_YES (continue to iterate)
  */
 static int
-cancel_pending_request (void *cls, const GNUNET_HashCode * query, void *value)
+cancel_pending_request (void *cls, const struct GNUNET_HashCode * query, void *value)
 {
   struct PeerRequest *peerreq = value;
   struct GSF_PendingRequest *pr = peerreq->pr;
@@ -1129,13 +1129,13 @@ GSF_handle_p2p_query_ (const struct GNUNET_PeerIdentity *other,
   struct GSF_PendingRequestData *prd;
   struct GSF_ConnectedPeer *cp;
   struct GSF_ConnectedPeer *cps;
-  const GNUNET_HashCode *namespace;
+  const struct GNUNET_HashCode *namespace;
   const struct GNUNET_PeerIdentity *target;
   enum GSF_PendingRequestOptions options;
   uint16_t msize;
   const struct GetMessage *gm;
   unsigned int bits;
-  const GNUNET_HashCode *opt;
+  const struct GNUNET_HashCode *opt;
   uint32_t bm;
   size_t bfsize;
   uint32_t ttl_decrement;
@@ -1165,13 +1165,13 @@ GSF_handle_p2p_query_ (const struct GNUNET_PeerIdentity *other,
       bits++;
     bm >>= 1;
   }
-  if (msize < sizeof (struct GetMessage) + bits * sizeof (GNUNET_HashCode))
+  if (msize < sizeof (struct GetMessage) + bits * sizeof (struct GNUNET_HashCode))
   {
     GNUNET_break_op (0);
     return NULL;
   }
-  opt = (const GNUNET_HashCode *) &gm[1];
-  bfsize = msize - sizeof (struct GetMessage) - bits * sizeof (GNUNET_HashCode);
+  opt = (const struct GNUNET_HashCode *) &gm[1];
+  bfsize = msize - sizeof (struct GetMessage) - bits * sizeof (struct GNUNET_HashCode);
   /* bfsize must be power of 2, check! */
   if (0 != ((bfsize - 1) & bfsize))
   {
@@ -1284,7 +1284,7 @@ GSF_handle_p2p_query_ (const struct GNUNET_PeerIdentity *other,
     prd = GSF_pending_request_get_data_ (pr);
     if ((prd->type == type) &&
         ((type != GNUNET_BLOCK_TYPE_FS_SBLOCK) ||
-         (0 == memcmp (&prd->namespace, namespace, sizeof (GNUNET_HashCode)))))
+         (0 == memcmp (&prd->namespace, namespace, sizeof (struct GNUNET_HashCode)))))
     {
       if (prd->ttl.abs_value >= GNUNET_TIME_absolute_get ().abs_value + ttl)
       {
@@ -1612,7 +1612,7 @@ struct IterationContext
  * @return GNUNET_YES to continue iteration
  */
 static int
-call_iterator (void *cls, const GNUNET_HashCode * key, void *value)
+call_iterator (void *cls, const struct GNUNET_HashCode * key, void *value)
 {
   struct IterationContext *ic = cls;
   struct GSF_ConnectedPeer *cp = value;
@@ -1728,7 +1728,7 @@ GSF_block_peer_migration_ (struct GSF_ConnectedPeer *cp,
  * @return GNUNET_OK to continue iteration
  */
 static int
-flush_trust (void *cls, const GNUNET_HashCode * key, void *value)
+flush_trust (void *cls, const struct GNUNET_HashCode * key, void *value)
 {
   struct GSF_ConnectedPeer *cp = value;
   char *fn;
@@ -1829,7 +1829,7 @@ GSF_connected_peer_init_ ()
  * @return GNUNET_YES (we should continue to iterate)
  */
 static int
-clean_peer (void *cls, const GNUNET_HashCode * key, void *value)
+clean_peer (void *cls, const struct GNUNET_HashCode * key, void *value)
 {
   GSF_peer_disconnect_handler_ (NULL, (const struct GNUNET_PeerIdentity *) key);
   return GNUNET_YES;
@@ -1862,7 +1862,7 @@ GSF_connected_peer_done_ ()
  * @return GNUNET_YES (we should continue to iterate)
  */
 static int
-clean_local_client (void *cls, const GNUNET_HashCode * key, void *value)
+clean_local_client (void *cls, const struct GNUNET_HashCode * key, void *value)
 {
   const struct GSF_LocalClient *lc = cls;
   struct GSF_ConnectedPeer *cp = value;
diff --git a/src/fs/gnunet-service-fs_indexing.c b/src/fs/gnunet-service-fs_indexing.c
index e45289484..60dd1c131 100644
--- a/src/fs/gnunet-service-fs_indexing.c
+++ b/src/fs/gnunet-service-fs_indexing.c
@@ -67,7 +67,7 @@ struct IndexInfo
   /**
    * Hash of the contents of the file.
    */
-  GNUNET_HashCode file_id;
+  struct GNUNET_HashCode file_id;
 
 };
 
@@ -126,7 +126,7 @@ write_index_list ()
   while (pos != NULL)
   {
     if ((GNUNET_OK !=
-         GNUNET_BIO_write (wh, &pos->file_id, sizeof (GNUNET_HashCode))) ||
+         GNUNET_BIO_write (wh, &pos->file_id, sizeof (struct GNUNET_HashCode))) ||
         (GNUNET_OK != GNUNET_BIO_write_string (wh, pos->filename)))
       break;
     pos = pos->next;
@@ -152,7 +152,7 @@ read_index_list ()
   char *fn;
   struct IndexInfo *pos;
   char *fname;
-  GNUNET_HashCode hc;
+  struct GNUNET_HashCode hc;
   size_t slen;
   char *emsg;
 
@@ -180,7 +180,7 @@ read_index_list ()
   }
   while ((GNUNET_OK ==
           GNUNET_BIO_read (rh, "Hash of indexed file", &hc,
-                           sizeof (GNUNET_HashCode))) &&
+                           sizeof (struct GNUNET_HashCode))) &&
          (GNUNET_OK ==
           GNUNET_BIO_read_string (rh, "Name of indexed file", &fname,
                                   1024 * 16)) && (fname != NULL))
@@ -253,13 +253,13 @@ signal_index_ok (struct IndexInfo *ii)
  * @param res resulting hash, NULL on error
  */
 static void
-hash_for_index_val (void *cls, const GNUNET_HashCode * res)
+hash_for_index_val (void *cls, const struct GNUNET_HashCode * res)
 {
   struct IndexInfo *ii = cls;
 
   ii->fhc = NULL;
   if ((res == NULL) ||
-      (0 != memcmp (res, &ii->file_id, sizeof (GNUNET_HashCode))))
+      (0 != memcmp (res, &ii->file_id, sizeof (struct GNUNET_HashCode))))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                 _
@@ -431,7 +431,7 @@ GNUNET_FS_handle_unindex (void *cls, struct GNUNET_SERVER_Client *client,
   while (NULL != pos)
   {
     next = pos->next;
-    if (0 == memcmp (&pos->file_id, &um->file_id, sizeof (GNUNET_HashCode)))
+    if (0 == memcmp (&pos->file_id, &um->file_id, sizeof (struct GNUNET_HashCode)))
     {
       if (prev == NULL)
         indexed_files = next;
@@ -502,7 +502,7 @@ remove_cont (void *cls, int success,
  * @return GNUNET_OK on success
  */
 int
-GNUNET_FS_handle_on_demand_block (const GNUNET_HashCode * key, uint32_t size,
+GNUNET_FS_handle_on_demand_block (const struct GNUNET_HashCode * key, uint32_t size,
                                   const void *data, enum GNUNET_BLOCK_Type type,
                                   uint32_t priority, uint32_t anonymity,
                                   struct GNUNET_TIME_Absolute expiration,
@@ -511,10 +511,10 @@ GNUNET_FS_handle_on_demand_block (const GNUNET_HashCode * key, uint32_t size,
                                   void *cont_cls)
 {
   const struct OnDemandBlock *odb;
-  GNUNET_HashCode nkey;
+  struct GNUNET_HashCode nkey;
   struct GNUNET_CRYPTO_AesSessionKey skey;
   struct GNUNET_CRYPTO_AesInitializationVector iv;
-  GNUNET_HashCode query;
+  struct GNUNET_HashCode query;
   ssize_t nsize;
   char ndata[DBLOCK_SIZE];
   char edata[DBLOCK_SIZE];
@@ -565,7 +565,7 @@ GNUNET_FS_handle_on_demand_block (const GNUNET_HashCode * key, uint32_t size,
   GNUNET_CRYPTO_hash_to_aes_key (&nkey, &skey, &iv);
   GNUNET_CRYPTO_aes_encrypt (ndata, nsize, &skey, &iv, edata);
   GNUNET_CRYPTO_hash (edata, nsize, &query);
-  if (0 != memcmp (&query, key, sizeof (GNUNET_HashCode)))
+  if (0 != memcmp (&query, key, sizeof (struct GNUNET_HashCode)))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                 _("Indexed file `%s' changed at offset %llu\n"), fn,
diff --git a/src/fs/gnunet-service-fs_indexing.h b/src/fs/gnunet-service-fs_indexing.h
index 4295b2011..3bb0af262 100644
--- a/src/fs/gnunet-service-fs_indexing.h
+++ b/src/fs/gnunet-service-fs_indexing.h
@@ -55,7 +55,7 @@
  * @return GNUNET_OK on success
  */
 int
-GNUNET_FS_handle_on_demand_block (const GNUNET_HashCode * key, uint32_t size,
+GNUNET_FS_handle_on_demand_block (const struct GNUNET_HashCode * key, uint32_t size,
                                   const void *data, enum GNUNET_BLOCK_Type type,
                                   uint32_t priority, uint32_t anonymity,
                                   struct GNUNET_TIME_Absolute expiration,
diff --git a/src/fs/gnunet-service-fs_lc.c b/src/fs/gnunet-service-fs_lc.c
index 20d430e5a..f3b18256b 100644
--- a/src/fs/gnunet-service-fs_lc.c
+++ b/src/fs/gnunet-service-fs_lc.c
@@ -299,7 +299,7 @@ GSF_local_client_start_search_handler_ (struct GNUNET_SERVER_Client *client,
                                         *message,
                                         struct GSF_PendingRequest **prptr)
 {
-  static GNUNET_HashCode all_zeros;
+  static struct GNUNET_HashCode all_zeros;
   const struct SearchMessage *sm;
   struct GSF_LocalClient *lc;
   struct ClientRequest *cr;
@@ -311,7 +311,7 @@ GSF_local_client_start_search_handler_ (struct GNUNET_SERVER_Client *client,
 
   msize = ntohs (message->size);
   if ((msize < sizeof (struct SearchMessage)) ||
-      (0 != (msize - sizeof (struct SearchMessage)) % sizeof (GNUNET_HashCode)))
+      (0 != (msize - sizeof (struct SearchMessage)) % sizeof (struct GNUNET_HashCode)))
   {
     GNUNET_break (0);
     *prptr = NULL;
@@ -320,7 +320,7 @@ GSF_local_client_start_search_handler_ (struct GNUNET_SERVER_Client *client,
   GNUNET_STATISTICS_update (GSF_stats,
                             gettext_noop ("# client searches received"), 1,
                             GNUNET_NO);
-  sc = (msize - sizeof (struct SearchMessage)) / sizeof (GNUNET_HashCode);
+  sc = (msize - sizeof (struct SearchMessage)) / sizeof (struct GNUNET_HashCode);
   sm = (const struct SearchMessage *) message;
   type = ntohl (sm->type);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -340,7 +340,7 @@ GSF_local_client_start_search_handler_ (struct GNUNET_SERVER_Client *client,
          (SEARCH_MESSAGE_OPTION_CONTINUED was always set) and that have a
          matching query and type */
       if ((GNUNET_YES != prd->has_started) &&
-          (0 != memcmp (&prd->query, &sm->query, sizeof (GNUNET_HashCode))) &&
+          (0 != memcmp (&prd->query, &sm->query, sizeof (struct GNUNET_HashCode))) &&
           (prd->type == type))
         break;
       cr = cr->next;
@@ -350,7 +350,7 @@ GSF_local_client_start_search_handler_ (struct GNUNET_SERVER_Client *client,
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Have existing request, merging content-seen lists.\n");
-    GSF_pending_request_update_ (cr->pr, (const GNUNET_HashCode *) &sm[1], sc);
+    GSF_pending_request_update_ (cr->pr, (const struct GNUNET_HashCode *) &sm[1], sc);
     GNUNET_STATISTICS_update (GSF_stats,
                               gettext_noop
                               ("# client searches updated (merged content seen list)"),
@@ -371,7 +371,7 @@ GSF_local_client_start_search_handler_ (struct GNUNET_SERVER_Client *client,
                                           : NULL,
                                           (0 !=
                                            memcmp (&sm->target, &all_zeros,
-                                                   sizeof (GNUNET_HashCode)))
+                                                   sizeof (struct GNUNET_HashCode)))
                                           ? (const struct GNUNET_PeerIdentity *)
                                           &sm->target : NULL, NULL, 0,
                                           0 /* bf */ ,
@@ -380,7 +380,7 @@ GSF_local_client_start_search_handler_ (struct GNUNET_SERVER_Client *client,
                                           0 /* ttl */ ,
                                           0 /* sender PID */ ,
                                           0 /* origin PID */ ,
-                                          (const GNUNET_HashCode *) &sm[1], sc,
+                                          (const struct GNUNET_HashCode *) &sm[1], sc,
                                           &client_response_handler, cr);
   }
   *prptr = cr->pr;
diff --git a/src/fs/gnunet-service-fs_pe.c b/src/fs/gnunet-service-fs_pe.c
index 71b0fc091..c70f3cc84 100644
--- a/src/fs/gnunet-service-fs_pe.c
+++ b/src/fs/gnunet-service-fs_pe.c
@@ -224,7 +224,7 @@ static unsigned long long plan_count;
  * @param rp a request plan
  * @return the associated query
  */
-static const GNUNET_HashCode *
+static const struct GNUNET_HashCode *
 get_rp_key (struct GSF_RequestPlan *rp)
 {
   return &GSF_pending_request_get_data_ (rp->prl_head->pr)->query;
@@ -512,7 +512,7 @@ struct MergeContext
  *         GNUNET_NO if not (merge success)
  */
 static int
-merge_pr (void *cls, const GNUNET_HashCode * query, void *element)
+merge_pr (void *cls, const struct GNUNET_HashCode * query, void *element)
 {
   struct MergeContext *mpr = cls;
   struct GSF_RequestPlan *rp = element;
diff --git a/src/fs/gnunet-service-fs_pr.c b/src/fs/gnunet-service-fs_pr.c
index 8ca4121a5..0914ca4d2 100644
--- a/src/fs/gnunet-service-fs_pr.c
+++ b/src/fs/gnunet-service-fs_pr.c
@@ -74,7 +74,7 @@ struct GSF_PendingRequest
   /**
    * Array of hash codes of replies we've already seen.
    */
-  GNUNET_HashCode *replies_seen;
+  struct GNUNET_HashCode *replies_seen;
 
   /**
    * Bloomfilter masking replies we've already seen.
@@ -263,15 +263,15 @@ refresh_bloomfilter (struct GSF_PendingRequest *pr)
 struct GSF_PendingRequest *
 GSF_pending_request_create_ (enum GSF_PendingRequestOptions options,
                              enum GNUNET_BLOCK_Type type,
-                             const GNUNET_HashCode * query,
-                             const GNUNET_HashCode * namespace,
+                             const struct GNUNET_HashCode * query,
+                             const struct GNUNET_HashCode * namespace,
                              const struct GNUNET_PeerIdentity *target,
                              const char *bf_data, size_t bf_size,
                              uint32_t mingle, uint32_t anonymity_level,
                              uint32_t priority, int32_t ttl,
                              GNUNET_PEER_Id sender_pid,
                              GNUNET_PEER_Id origin_pid,
-                             const GNUNET_HashCode * replies_seen,
+                             const struct GNUNET_HashCode * replies_seen,
                              unsigned int replies_seen_count,
                              GSF_PendingRequestReplyHandler rh, void *rh_cls)
 {
@@ -324,9 +324,9 @@ GSF_pending_request_create_ (enum GSF_PendingRequestOptions options,
   {
     pr->replies_seen_size = replies_seen_count;
     pr->replies_seen =
-        GNUNET_malloc (sizeof (GNUNET_HashCode) * pr->replies_seen_size);
+        GNUNET_malloc (sizeof (struct GNUNET_HashCode) * pr->replies_seen_size);
     memcpy (pr->replies_seen, replies_seen,
-            replies_seen_count * sizeof (GNUNET_HashCode));
+            replies_seen_count * sizeof (struct GNUNET_HashCode));
     pr->replies_seen_count = replies_seen_count;
   }
   if (NULL != bf_data)
@@ -398,11 +398,11 @@ GSF_pending_request_is_compatible_ (struct GSF_PendingRequest *pra,
   if ((pra->public_data.type != prb->public_data.type) ||
       (0 !=
        memcmp (&pra->public_data.query, &prb->public_data.query,
-               sizeof (GNUNET_HashCode))) ||
+               sizeof (struct GNUNET_HashCode))) ||
       ((pra->public_data.type == GNUNET_BLOCK_TYPE_FS_SBLOCK) &&
        (0 !=
         memcmp (&pra->public_data.namespace, &prb->public_data.namespace,
-                sizeof (GNUNET_HashCode)))))
+                sizeof (struct GNUNET_HashCode)))))
     return GNUNET_NO;
   return GNUNET_OK;
 }
@@ -419,11 +419,11 @@ GSF_pending_request_is_compatible_ (struct GSF_PendingRequest *pra,
  */
 void
 GSF_pending_request_update_ (struct GSF_PendingRequest *pr,
-                             const GNUNET_HashCode * replies_seen,
+                             const struct GNUNET_HashCode * replies_seen,
                              unsigned int replies_seen_count)
 {
   unsigned int i;
-  GNUNET_HashCode mhash;
+  struct GNUNET_HashCode mhash;
 
   if (replies_seen_count + pr->replies_seen_count < pr->replies_seen_count)
     return;                     /* integer overflow */
@@ -434,7 +434,7 @@ GSF_pending_request_update_ (struct GSF_PendingRequest *pr,
       GNUNET_array_grow (pr->replies_seen, pr->replies_seen_size,
                          replies_seen_count + pr->replies_seen_count);
     memcpy (&pr->replies_seen[pr->replies_seen_count], replies_seen,
-            sizeof (GNUNET_HashCode) * replies_seen_count);
+            sizeof (struct GNUNET_HashCode) * replies_seen_count);
     pr->replies_seen_count += replies_seen_count;
     refresh_bloomfilter (pr);
   }
@@ -477,7 +477,7 @@ GSF_pending_request_get_message_ (struct GSF_PendingRequest *pr,
 {
   char lbuf[GNUNET_SERVER_MAX_MESSAGE_SIZE];
   struct GetMessage *gm;
-  GNUNET_HashCode *ext;
+  struct GNUNET_HashCode *ext;
   size_t msize;
   unsigned int k;
   uint32_t bm;
@@ -515,7 +515,7 @@ GSF_pending_request_get_message_ (struct GSF_PendingRequest *pr,
     k++;
   }
   bf_size = GNUNET_CONTAINER_bloomfilter_get_size (pr->bf);
-  msize = sizeof (struct GetMessage) + bf_size + k * sizeof (GNUNET_HashCode);
+  msize = sizeof (struct GetMessage) + bf_size + k * sizeof (struct GNUNET_HashCode);
   GNUNET_assert (msize < GNUNET_SERVER_MAX_MESSAGE_SIZE);
   if (buf_size < msize)
     return msize;
@@ -537,13 +537,13 @@ GSF_pending_request_get_message_ (struct GSF_PendingRequest *pr,
   gm->filter_mutator = htonl (pr->mingle);
   gm->hash_bitmap = htonl (bm);
   gm->query = pr->public_data.query;
-  ext = (GNUNET_HashCode *) & gm[1];
+  ext = (struct GNUNET_HashCode *) & gm[1];
   k = 0;
   if (!do_route)
     GNUNET_PEER_resolve (pr->sender_pid,
                          (struct GNUNET_PeerIdentity *) &ext[k++]);
   if (GNUNET_BLOCK_TYPE_FS_SBLOCK == pr->public_data.type)
-    memcpy (&ext[k++], &pr->public_data.namespace, sizeof (GNUNET_HashCode));
+    memcpy (&ext[k++], &pr->public_data.namespace, sizeof (struct GNUNET_HashCode));
   if (GNUNET_YES == pr->public_data.has_target)
     ext[k++] = pr->public_data.target.hashPubKey;
   if (pr->bf != NULL)
@@ -565,7 +565,7 @@ GSF_pending_request_get_message_ (struct GSF_PendingRequest *pr,
  * @return GNUNET_YES (we should continue to iterate)
  */
 static int
-clean_request (void *cls, const GNUNET_HashCode * key, void *value)
+clean_request (void *cls, const struct GNUNET_HashCode * key, void *value)
 {
   struct GSF_PendingRequest *pr = value;
   GSF_LocalLookupContinuation cont;
@@ -763,11 +763,11 @@ update_request_performance_data (struct ProcessReplyClosure *prq,
  * @return GNUNET_YES (we should continue to iterate)
  */
 static int
-process_reply (void *cls, const GNUNET_HashCode * key, void *value)
+process_reply (void *cls, const struct GNUNET_HashCode * key, void *value)
 {
   struct ProcessReplyClosure *prq = cls;
   struct GSF_PendingRequest *pr = value;
-  GNUNET_HashCode chash;
+  struct GNUNET_HashCode chash;
   struct GNUNET_TIME_Absolute last_transmission;
 
   if (NULL == pr->rh)
@@ -783,7 +783,7 @@ process_reply (void *cls, const GNUNET_HashCode * key, void *value)
                              &pr->public_data.namespace,
                              (prq->type ==
                               GNUNET_BLOCK_TYPE_FS_SBLOCK) ?
-                             sizeof (GNUNET_HashCode) : 0, prq->data,
+                             sizeof (struct GNUNET_HashCode) : 0, prq->data,
                              prq->size);
   switch (prq->eval)
   {
@@ -1000,7 +1000,7 @@ test_put_load_too_high (uint32_t priority)
  */
 static void
 handle_dht_reply (void *cls, struct GNUNET_TIME_Absolute exp,
-                  const GNUNET_HashCode * key,
+                  const struct GNUNET_HashCode * key,
                   const struct GNUNET_PeerIdentity *get_path,
                   unsigned int get_path_length,
                   const struct GNUNET_PeerIdentity *put_path,
@@ -1057,7 +1057,7 @@ GSF_dht_lookup_ (struct GSF_PendingRequest *pr)
   const void *xquery;
   size_t xquery_size;
   struct GNUNET_PeerIdentity pi;
-  char buf[sizeof (GNUNET_HashCode) * 2] GNUNET_ALIGN;
+  char buf[sizeof (struct GNUNET_HashCode) * 2] GNUNET_ALIGN;
 
   if (0 != pr->public_data.anonymity_level)
     return;
@@ -1071,8 +1071,8 @@ GSF_dht_lookup_ (struct GSF_PendingRequest *pr)
   if (GNUNET_BLOCK_TYPE_FS_SBLOCK == pr->public_data.type)
   {
     xquery = buf;
-    memcpy (buf, &pr->public_data.namespace, sizeof (GNUNET_HashCode));
-    xquery_size = sizeof (GNUNET_HashCode);
+    memcpy (buf, &pr->public_data.namespace, sizeof (struct GNUNET_HashCode));
+    xquery_size = sizeof (struct GNUNET_HashCode);
   }
   if (0 != (pr->public_data.options & GSF_PRO_FORWARD_ONLY))
   {
@@ -1151,7 +1151,7 @@ odc_warn_delay_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  *        maybe 0 if no unique identifier is available
  */
 static void
-process_local_reply (void *cls, const GNUNET_HashCode * key, size_t size,
+process_local_reply (void *cls, const struct GNUNET_HashCode * key, size_t size,
                      const void *data, enum GNUNET_BLOCK_Type type,
                      uint32_t priority, uint32_t anonymity,
                      struct GNUNET_TIME_Absolute expiration, uint64_t uid)
@@ -1159,7 +1159,7 @@ process_local_reply (void *cls, const GNUNET_HashCode * key, size_t size,
   struct GSF_PendingRequest *pr = cls;
   GSF_LocalLookupContinuation cont;
   struct ProcessReplyClosure prq;
-  GNUNET_HashCode query;
+  struct GNUNET_HashCode query;
   unsigned int old_rf;
 
   GNUNET_SCHEDULER_cancel (pr->warn_task);
@@ -1477,7 +1477,7 @@ GSF_handle_p2p_content_ (struct GSF_ConnectedPeer *cp,
   size_t dsize;
   enum GNUNET_BLOCK_Type type;
   struct GNUNET_TIME_Absolute expiration;
-  GNUNET_HashCode query;
+  struct GNUNET_HashCode query;
   struct ProcessReplyClosure prq;
   struct GNUNET_TIME_Relative block_time;
   double putl;
diff --git a/src/fs/gnunet-service-fs_pr.h b/src/fs/gnunet-service-fs_pr.h
index 92827f76b..ab088f88f 100644
--- a/src/fs/gnunet-service-fs_pr.h
+++ b/src/fs/gnunet-service-fs_pr.h
@@ -84,12 +84,12 @@ struct GSF_PendingRequestData
   /**
    * Primary query hash for this request.
    */
-  GNUNET_HashCode query;
+  struct GNUNET_HashCode query;
 
   /**
    * Namespace to query, only set if the type is SBLOCK.
    */
-  GNUNET_HashCode namespace;
+  struct GNUNET_HashCode namespace;
 
   /**
    * Identity of a peer hosting the content, only set if
@@ -220,15 +220,15 @@ typedef void (*GSF_PendingRequestReplyHandler) (void *cls,
 struct GSF_PendingRequest *
 GSF_pending_request_create_ (enum GSF_PendingRequestOptions options,
                              enum GNUNET_BLOCK_Type type,
-                             const GNUNET_HashCode * query,
-                             const GNUNET_HashCode * namespace,
+                             const struct GNUNET_HashCode * query,
+                             const struct GNUNET_HashCode * namespace,
                              const struct GNUNET_PeerIdentity *target,
                              const char *bf_data, size_t bf_size,
                              uint32_t mingle, uint32_t anonymity_level,
                              uint32_t priority, int32_t ttl,
                              GNUNET_PEER_Id sender_pid,
                              GNUNET_PEER_Id origin_pid,
-                             const GNUNET_HashCode * replies_seen,
+                             const struct GNUNET_HashCode * replies_seen,
                              unsigned int replies_seen_count,
                              GSF_PendingRequestReplyHandler rh, void *rh_cls);
 
@@ -243,7 +243,7 @@ GSF_pending_request_create_ (enum GSF_PendingRequestOptions options,
  */
 void
 GSF_pending_request_update_ (struct GSF_PendingRequest *pr,
-                             const GNUNET_HashCode * replies_seen,
+                             const struct GNUNET_HashCode * replies_seen,
                              unsigned int replies_seen_count);
 
 
@@ -305,7 +305,7 @@ GSF_pending_request_cancel_ (struct GSF_PendingRequest *pr, int full_cleanup);
  * @return GNUNET_YES to continue to iterate
  */
 typedef int (*GSF_PendingRequestIterator) (void *cls,
-                                           const GNUNET_HashCode * key,
+                                           const struct GNUNET_HashCode * key,
                                            struct GSF_PendingRequest * pr);
 
 
diff --git a/src/fs/gnunet-service-fs_push.c b/src/fs/gnunet-service-fs_push.c
index 22a76f332..aaf7ca8a3 100644
--- a/src/fs/gnunet-service-fs_push.c
+++ b/src/fs/gnunet-service-fs_push.c
@@ -71,7 +71,7 @@ struct MigrationReadyBlock
   /**
    * Query for the block.
    */
-  GNUNET_HashCode query;
+  struct GNUNET_HashCode query;
 
   /**
    * When does this block expire?
@@ -467,7 +467,7 @@ consider_gathering ()
  *        maybe 0 if no unique identifier is available
  */
 static void
-process_migration_content (void *cls, const GNUNET_HashCode * key, size_t size,
+process_migration_content (void *cls, const struct GNUNET_HashCode * key, size_t size,
                            const void *data, enum GNUNET_BLOCK_Type type,
                            uint32_t priority, uint32_t anonymity,
                            struct GNUNET_TIME_Absolute expiration, uint64_t uid)
diff --git a/src/fs/gnunet-service-fs_put.c b/src/fs/gnunet-service-fs_put.c
index 463acc02d..e4b13edab 100644
--- a/src/fs/gnunet-service-fs_put.c
+++ b/src/fs/gnunet-service-fs_put.c
@@ -180,7 +180,7 @@ delay_dht_put_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  *        maybe 0 if no unique identifier is available
  */
 static void
-process_dht_put_content (void *cls, const GNUNET_HashCode * key, size_t size,
+process_dht_put_content (void *cls, const struct GNUNET_HashCode * key, size_t size,
                          const void *data, enum GNUNET_BLOCK_Type type,
                          uint32_t priority, uint32_t anonymity,
                          struct GNUNET_TIME_Absolute expiration, uint64_t uid)
diff --git a/src/fs/plugin_block_fs.c b/src/fs/plugin_block_fs.c
index 9b73f2497..c43a5de5e 100644
--- a/src/fs/plugin_block_fs.c
+++ b/src/fs/plugin_block_fs.c
@@ -57,17 +57,17 @@
  */
 static enum GNUNET_BLOCK_EvaluationResult
 block_plugin_fs_evaluate (void *cls, enum GNUNET_BLOCK_Type type,
-                          const GNUNET_HashCode * query,
+                          const struct GNUNET_HashCode * query,
                           struct GNUNET_CONTAINER_BloomFilter **bf,
                           int32_t bf_mutator, const void *xquery,
                           size_t xquery_size, const void *reply_block,
                           size_t reply_block_size)
 {
   const struct SBlock *sb;
-  GNUNET_HashCode chash;
-  GNUNET_HashCode mhash;
-  const GNUNET_HashCode *nsid;
-  GNUNET_HashCode sh;
+  struct GNUNET_HashCode chash;
+  struct GNUNET_HashCode mhash;
+  const struct GNUNET_HashCode *nsid;
+  struct GNUNET_HashCode sh;
 
   switch (type)
   {
@@ -107,7 +107,7 @@ block_plugin_fs_evaluate (void *cls, enum GNUNET_BLOCK_Type type,
     }
     return GNUNET_BLOCK_EVALUATION_OK_MORE;
   case GNUNET_BLOCK_TYPE_FS_SBLOCK:
-    if (xquery_size != sizeof (GNUNET_HashCode))
+    if (xquery_size != sizeof (struct GNUNET_HashCode))
     {
       GNUNET_break_op (0);
       return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID;
@@ -124,7 +124,7 @@ block_plugin_fs_evaluate (void *cls, enum GNUNET_BLOCK_Type type,
     GNUNET_CRYPTO_hash (&sb->subspace,
                         sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
                         &sh);
-    if (0 != memcmp (nsid, &sh, sizeof (GNUNET_HashCode)))
+    if (0 != memcmp (nsid, &sh, sizeof (struct GNUNET_HashCode)))
     {
       GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING, "block-fs",
                        _
@@ -167,7 +167,7 @@ block_plugin_fs_evaluate (void *cls, enum GNUNET_BLOCK_Type type,
 static int
 block_plugin_fs_get_key (void *cls, enum GNUNET_BLOCK_Type type,
                          const void *block, size_t block_size,
-                         GNUNET_HashCode * key)
+                         struct GNUNET_HashCode * key)
 {
   const struct KBlock *kb;
   const struct SBlock *sb;
diff --git a/src/fs/test_fs_namespace.c b/src/fs/test_fs_namespace.c
index 78af1f148..e837b630f 100644
--- a/src/fs/test_fs_namespace.c
+++ b/src/fs/test_fs_namespace.c
@@ -34,7 +34,7 @@
 
 static struct PeerContext p1;
 
-static GNUNET_HashCode nsid;
+static struct GNUNET_HashCode nsid;
 
 static struct GNUNET_FS_Uri *sks_expect_uri;
 
@@ -314,7 +314,7 @@ adv_cont (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
 
 
 static void
-ns_iterator (void *cls, const char *name, const GNUNET_HashCode * id)
+ns_iterator (void *cls, const char *name, const struct GNUNET_HashCode * id)
 {
   int *ok = cls;