-consistently use struct GNUNET_HashCode

8 files changed, 72 insertions, 72 deletions

diff --git a/src/datacache/datacache.c b/src/datacache/datacache.c
index b440af1b2..9087ae0dd 100644
--- a/src/datacache/datacache.c
+++ b/src/datacache/datacache.c
@@ -103,7 +103,7 @@ struct GNUNET_DATACACHE_Handle
  * @param size number of bytes that were made available
  */
 static void
-env_delete_notify (void *cls, const GNUNET_HashCode * key, size_t size)
+env_delete_notify (void *cls, const struct GNUNET_HashCode * key, size_t size)
 {
   struct GNUNET_DATACACHE_Handle *h = cls;
 
@@ -233,7 +233,7 @@ GNUNET_DATACACHE_destroy (struct GNUNET_DATACACHE_Handle *h)
  */
 int
 GNUNET_DATACACHE_put (struct GNUNET_DATACACHE_Handle *h,
-                      const GNUNET_HashCode * key, size_t size,
+                      const struct GNUNET_HashCode * key, size_t size,
                       const char *data, enum GNUNET_BLOCK_Type type,
                       struct GNUNET_TIME_Absolute discard_time)
 {
@@ -270,7 +270,7 @@ GNUNET_DATACACHE_put (struct GNUNET_DATACACHE_Handle *h,
  */
 unsigned int
 GNUNET_DATACACHE_get (struct GNUNET_DATACACHE_Handle *h,
-                      const GNUNET_HashCode * key, enum GNUNET_BLOCK_Type type,
+                      const struct GNUNET_HashCode * key, enum GNUNET_BLOCK_Type type,
                       GNUNET_DATACACHE_Iterator iter, void *iter_cls)
 {
   GNUNET_STATISTICS_update (h->stats, gettext_noop ("# requests received"), 1,
diff --git a/src/datacache/perf_datacache.c b/src/datacache/perf_datacache.c
index 94cd7a58e..fd3891116 100644
--- a/src/datacache/perf_datacache.c
+++ b/src/datacache/perf_datacache.c
@@ -45,10 +45,10 @@ static const char *plugin_name;
 
 static int
 checkIt (void *cls, struct GNUNET_TIME_Absolute exp,
-         const GNUNET_HashCode * key, size_t size, const char *data,
+         const struct GNUNET_HashCode * key, size_t size, const char *data,
          enum GNUNET_BLOCK_Type type)
 {
-  if ((size == sizeof (GNUNET_HashCode)) && (0 == memcmp (data, cls, size)))
+  if ((size == sizeof (struct GNUNET_HashCode)) && (0 == memcmp (data, cls, size)))
     found++;
   return GNUNET_OK;
 }
@@ -59,8 +59,8 @@ run (void *cls, char *const *args, const char *cfgfile,
      const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct GNUNET_DATACACHE_Handle *h;
-  GNUNET_HashCode k;
-  GNUNET_HashCode n;
+  struct GNUNET_HashCode k;
+  struct GNUNET_HashCode n;
   struct GNUNET_TIME_Absolute exp;
   struct GNUNET_TIME_Absolute start;
   unsigned int i;
@@ -76,14 +76,14 @@ run (void *cls, char *const *args, const char *cfgfile,
   }
   exp = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_HOURS);
   start = GNUNET_TIME_absolute_get ();
-  memset (&k, 0, sizeof (GNUNET_HashCode));
+  memset (&k, 0, sizeof (struct GNUNET_HashCode));
   for (i = 0; i < ITERATIONS; i++)
   {
     if (0 == i % (ITERATIONS / 80))
       FPRINTF (stderr, "%s",  ".");
-    GNUNET_CRYPTO_hash (&k, sizeof (GNUNET_HashCode), &n);
+    GNUNET_CRYPTO_hash (&k, sizeof (struct GNUNET_HashCode), &n);
     ASSERT (GNUNET_OK ==
-            GNUNET_DATACACHE_put (h, &k, sizeof (GNUNET_HashCode),
+            GNUNET_DATACACHE_put (h, &k, sizeof (struct GNUNET_HashCode),
                                   (const char *) &n, 1 + i % 16, exp));
     k = n;
   }
@@ -96,12 +96,12 @@ run (void *cls, char *const *args, const char *cfgfile,
           GNUNET_TIME_absolute_get_duration (start).rel_value / ITERATIONS,
           "ms/item");
   start = GNUNET_TIME_absolute_get ();
-  memset (&k, 0, sizeof (GNUNET_HashCode));
+  memset (&k, 0, sizeof (struct GNUNET_HashCode));
   for (i = 0; i < ITERATIONS; i++)
   {
     if (0 == i % (ITERATIONS / 80))
       FPRINTF (stderr, "%s",  ".");
-    GNUNET_CRYPTO_hash (&k, sizeof (GNUNET_HashCode), &n);
+    GNUNET_CRYPTO_hash (&k, sizeof (struct GNUNET_HashCode), &n);
     GNUNET_DATACACHE_get (h, &k, 1 + i % 16, &checkIt, &n);
     k = n;
   }
diff --git a/src/datacache/plugin_datacache_mysql.c b/src/datacache/plugin_datacache_mysql.c
index 810342908..1457eddfb 100644
--- a/src/datacache/plugin_datacache_mysql.c
+++ b/src/datacache/plugin_datacache_mysql.c
@@ -87,7 +87,7 @@
 /**
  * Estimate of the per-entry overhead (including indices).
  */
-#define OVERHEAD ((4*2+4*2+8*2+8*2+sizeof(GNUNET_HashCode)*5+8))
+#define OVERHEAD ((4*2+4*2+8*2+8*2+sizeof(struct GNUNET_HashCode)*5+8))
 
 /**
  * Die with an error message that indicates
@@ -190,7 +190,7 @@ itable (struct Plugin *plugin)
  * @return 0 on error, number of bytes used otherwise
  */
 static size_t
-mysql_plugin_put (void *cls, const GNUNET_HashCode * key, size_t size,
+mysql_plugin_put (void *cls, const struct GNUNET_HashCode * key, size_t size,
                   const char *data, enum GNUNET_BLOCK_Type type,
                   struct GNUNET_TIME_Absolute discard_time)
 {
@@ -202,7 +202,7 @@ mysql_plugin_put (void *cls, const GNUNET_HashCode * key, size_t size,
   unsigned long long v_now;
   unsigned long long v_discard_time;
   unsigned int v_type;
-  GNUNET_HashCode vhash;
+  struct GNUNET_HashCode vhash;
   int ret;
 
   if (size > GNUNET_SERVER_MAX_MESSAGE_SIZE)
@@ -211,8 +211,8 @@ mysql_plugin_put (void *cls, const GNUNET_HashCode * key, size_t size,
   now = GNUNET_TIME_absolute_get ();
 
   /* first try UPDATE */
-  h_length = sizeof (GNUNET_HashCode);
-  k_length = sizeof (GNUNET_HashCode);
+  h_length = sizeof (struct GNUNET_HashCode);
+  k_length = sizeof (struct GNUNET_HashCode);
   v_length = size;
   v_type = type;
   v_now = (unsigned long long) now.abs_value;
@@ -221,15 +221,15 @@ mysql_plugin_put (void *cls, const GNUNET_HashCode * key, size_t size,
       GNUNET_MYSQL_statement_run_prepared (plugin->mc, plugin->update_value, NULL,
                               MYSQL_TYPE_LONGLONG, &v_now, GNUNET_YES,
                               MYSQL_TYPE_LONGLONG, &v_discard_time, GNUNET_YES,
-                              MYSQL_TYPE_BLOB, key, sizeof (GNUNET_HashCode),
+                              MYSQL_TYPE_BLOB, key, sizeof (struct GNUNET_HashCode),
                               &k_length, MYSQL_TYPE_BLOB, &vhash,
-                              sizeof (GNUNET_HashCode), &h_length,
+                              sizeof (struct GNUNET_HashCode), &h_length,
                               MYSQL_TYPE_LONG, &v_type, GNUNET_YES, -1))
     return GNUNET_OK;
 
   /* now try INSERT */
-  h_length = sizeof (GNUNET_HashCode);
-  k_length = sizeof (GNUNET_HashCode);
+  h_length = sizeof (struct GNUNET_HashCode);
+  k_length = sizeof (struct GNUNET_HashCode);
   v_length = size;
   if (GNUNET_OK !=
       (ret =
@@ -237,9 +237,9 @@ mysql_plugin_put (void *cls, const GNUNET_HashCode * key, size_t size,
                                MYSQL_TYPE_LONG, &type, GNUNET_YES,
                                MYSQL_TYPE_LONGLONG, &v_now, GNUNET_YES,
                                MYSQL_TYPE_LONGLONG, &v_discard_time, GNUNET_YES,
-                               MYSQL_TYPE_BLOB, key, sizeof (GNUNET_HashCode),
+                               MYSQL_TYPE_BLOB, key, sizeof (struct GNUNET_HashCode),
                                &k_length, MYSQL_TYPE_BLOB, &vhash,
-                               sizeof (GNUNET_HashCode), &h_length,
+                               sizeof (struct GNUNET_HashCode), &h_length,
                                MYSQL_TYPE_BLOB, data, (unsigned long) size,
                                &v_length, -1)))
   {
@@ -270,7 +270,7 @@ return_ok (void *cls, unsigned int num_values, MYSQL_BIND * values)
  * @return the number of results found
  */
 static unsigned int
-mysql_plugin_get (void *cls, const GNUNET_HashCode * key,
+mysql_plugin_get (void *cls, const struct GNUNET_HashCode * key,
                   enum GNUNET_BLOCK_Type type, GNUNET_DATACACHE_Iterator iter,
                   void *iter_cls)
 {
@@ -290,7 +290,7 @@ mysql_plugin_get (void *cls, const GNUNET_HashCode * key,
   char buffer[GNUNET_SERVER_MAX_MESSAGE_SIZE];
 
   now = GNUNET_TIME_absolute_get ();
-  h_length = sizeof (GNUNET_HashCode);
+  h_length = sizeof (struct GNUNET_HashCode);
   v_length = sizeof (buffer);
   total = -1;
   memset (rbind, 0, sizeof (rbind));
@@ -303,7 +303,7 @@ mysql_plugin_get (void *cls, const GNUNET_HashCode * key,
        (ret =
         GNUNET_MYSQL_statement_run_prepared_select (plugin->mc, plugin->count_value, 1, rbind,
                                        return_ok, NULL, MYSQL_TYPE_BLOB, key,
-                                       sizeof (GNUNET_HashCode), &h_length,
+                                       sizeof (struct GNUNET_HashCode), &h_length,
                                        MYSQL_TYPE_LONG, &v_type, GNUNET_YES,
                                        MYSQL_TYPE_LONGLONG, &v_now, GNUNET_YES,
                                        -1))) || (-1 == total))
@@ -332,7 +332,7 @@ mysql_plugin_get (void *cls, const GNUNET_HashCode * key,
         (ret =
          GNUNET_MYSQL_statement_run_prepared_select (plugin->mc, plugin->select_value, 2, rbind,
                                         return_ok, NULL, MYSQL_TYPE_BLOB, key,
-                                        sizeof (GNUNET_HashCode), &h_length,
+                                        sizeof (struct GNUNET_HashCode), &h_length,
                                         MYSQL_TYPE_LONG, &v_type, GNUNET_YES,
                                         MYSQL_TYPE_LONGLONG, &v_now, GNUNET_YES,
                                         MYSQL_TYPE_LONG, &off, GNUNET_YES, -1)))
@@ -364,24 +364,24 @@ mysql_plugin_del (void *cls)
 
   MYSQL_BIND rbind[5];
   unsigned int v_type;
-  GNUNET_HashCode v_key;
-  GNUNET_HashCode vhash;
+  struct GNUNET_HashCode v_key;
+  struct GNUNET_HashCode vhash;
   unsigned long k_length;
   unsigned long h_length;
   unsigned long v_length;
   int ret;
   char buffer[GNUNET_SERVER_MAX_MESSAGE_SIZE];
 
-  k_length = sizeof (GNUNET_HashCode);
-  h_length = sizeof (GNUNET_HashCode);
+  k_length = sizeof (struct GNUNET_HashCode);
+  h_length = sizeof (struct GNUNET_HashCode);
   v_length = sizeof (buffer);
   memset (rbind, 0, sizeof (rbind));
   rbind[0].buffer_type = MYSQL_TYPE_BLOB;
-  rbind[0].buffer_length = sizeof (GNUNET_HashCode);
+  rbind[0].buffer_length = sizeof (struct GNUNET_HashCode);
   rbind[0].length = &k_length;
   rbind[0].buffer = &v_key;
   rbind[1].buffer_type = MYSQL_TYPE_BLOB;
-  rbind[1].buffer_length = sizeof (GNUNET_HashCode);
+  rbind[1].buffer_length = sizeof (struct GNUNET_HashCode);
   rbind[1].length = &h_length;
   rbind[1].buffer = &vhash;
   rbind[2].buffer_type = MYSQL_TYPE_LONG;
@@ -399,9 +399,9 @@ mysql_plugin_del (void *cls)
        (ret =
         GNUNET_MYSQL_statement_run_prepared (plugin->mc, plugin->delete_value, NULL,
                                 MYSQL_TYPE_BLOB, &v_key,
-                                sizeof (GNUNET_HashCode), &k_length,
+                                sizeof (struct GNUNET_HashCode), &k_length,
                                 MYSQL_TYPE_BLOB, &vhash,
-                                sizeof (GNUNET_HashCode), &h_length,
+                                sizeof (struct GNUNET_HashCode), &h_length,
                                 MYSQL_TYPE_LONG, &v_type, GNUNET_YES,
                                 MYSQL_TYPE_BLOB, buffer,
                                 (unsigned long) sizeof (buffer), &v_length,
diff --git a/src/datacache/plugin_datacache_postgres.c b/src/datacache/plugin_datacache_postgres.c
index b40f1fd04..e9157742c 100644
--- a/src/datacache/plugin_datacache_postgres.c
+++ b/src/datacache/plugin_datacache_postgres.c
@@ -34,7 +34,7 @@
 /**
  * Per-entry overhead estimate
  */
-#define OVERHEAD (sizeof(GNUNET_HashCode) + 24)
+#define OVERHEAD (sizeof(struct GNUNET_HashCode) + 24)
 
 /**
  * Context for all functions in this plugin.
@@ -160,7 +160,7 @@ init_connection (struct Plugin *plugin)
  * @return 0 on error, number of bytes used otherwise
  */
 static size_t
-postgres_plugin_put (void *cls, const GNUNET_HashCode * key, size_t size,
+postgres_plugin_put (void *cls, const struct GNUNET_HashCode * key, size_t size,
                      const char *data, enum GNUNET_BLOCK_Type type,
                      struct GNUNET_TIME_Absolute discard_time)
 {
@@ -178,7 +178,7 @@ postgres_plugin_put (void *cls, const GNUNET_HashCode * key, size_t size,
   int paramLengths[] = {
     sizeof (btype),
     sizeof (bexpi),
-    sizeof (GNUNET_HashCode),
+    sizeof (struct GNUNET_HashCode),
     size
   };
   const int paramFormats[] = { 1, 1, 1, 1 };
@@ -206,7 +206,7 @@ postgres_plugin_put (void *cls, const GNUNET_HashCode * key, size_t size,
  * @return the number of results found
  */
 static unsigned int
-postgres_plugin_get (void *cls, const GNUNET_HashCode * key,
+postgres_plugin_get (void *cls, const struct GNUNET_HashCode * key,
                      enum GNUNET_BLOCK_Type type,
                      GNUNET_DATACACHE_Iterator iter, void *iter_cls)
 {
@@ -218,7 +218,7 @@ postgres_plugin_get (void *cls, const GNUNET_HashCode * key,
     (const char *) &btype,
   };
   int paramLengths[] = {
-    sizeof (GNUNET_HashCode),
+    sizeof (struct GNUNET_HashCode),
     sizeof (btype),
   };
   const int paramFormats[] = { 1, 1 };
@@ -298,7 +298,7 @@ postgres_plugin_del (void *cls)
   struct Plugin *plugin = cls;
   uint32_t size;
   uint32_t oid;
-  GNUNET_HashCode key;
+  struct GNUNET_HashCode key;
   PGresult *res;
 
   res = PQexecPrepared (plugin->dbh, "getm", 0, NULL, NULL, NULL, 1);
@@ -319,7 +319,7 @@ postgres_plugin_del (void *cls)
   }
   if ((3 != PQnfields (res)) || (sizeof (size) != PQfsize (res, 0)) ||
       (sizeof (oid) != PQfsize (res, 1)) ||
-      (sizeof (GNUNET_HashCode) != PQgetlength (res, 0, 2)))
+      (sizeof (struct GNUNET_HashCode) != PQgetlength (res, 0, 2)))
   {
     GNUNET_break (0);
     PQclear (res);
@@ -327,7 +327,7 @@ postgres_plugin_del (void *cls)
   }
   size = ntohl (*(uint32_t *) PQgetvalue (res, 0, 0));
   oid = ntohl (*(uint32_t *) PQgetvalue (res, 0, 1));
-  memcpy (&key, PQgetvalue (res, 0, 2), sizeof (GNUNET_HashCode));
+  memcpy (&key, PQgetvalue (res, 0, 2), sizeof (struct GNUNET_HashCode));
   PQclear (res);
   if (GNUNET_OK != GNUNET_POSTGRES_delete_by_rowid (plugin->dbh, "delrow", oid))
     return GNUNET_SYSERR;
diff --git a/src/datacache/plugin_datacache_sqlite.c b/src/datacache/plugin_datacache_sqlite.c
index db27de3e2..26792e1fb 100644
--- a/src/datacache/plugin_datacache_sqlite.c
+++ b/src/datacache/plugin_datacache_sqlite.c
@@ -37,7 +37,7 @@
  * How much overhead do we assume per entry in the
  * datacache?
  */
-#define OVERHEAD (sizeof(GNUNET_HashCode) + 32)
+#define OVERHEAD (sizeof(struct GNUNET_HashCode) + 32)
 
 /**
  * Context for all functions in this plugin.
@@ -98,7 +98,7 @@ sq_prepare (sqlite3 * dbh, const char *zSql,    /* SQL statement, UTF-8 encoded
  * @return 0 on error, number of bytes used otherwise
  */
 static size_t
-sqlite_plugin_put (void *cls, const GNUNET_HashCode * key, size_t size,
+sqlite_plugin_put (void *cls, const struct GNUNET_HashCode * key, size_t size,
                    const char *data, enum GNUNET_BLOCK_Type type,
                    struct GNUNET_TIME_Absolute discard_time)
 {
@@ -126,7 +126,7 @@ sqlite_plugin_put (void *cls, const GNUNET_HashCode * key, size_t size,
   if ((SQLITE_OK != sqlite3_bind_int (stmt, 1, type)) ||
       (SQLITE_OK != sqlite3_bind_int64 (stmt, 2, dval)) ||
       (SQLITE_OK !=
-       sqlite3_bind_blob (stmt, 3, key, sizeof (GNUNET_HashCode),
+       sqlite3_bind_blob (stmt, 3, key, sizeof (struct GNUNET_HashCode),
                           SQLITE_TRANSIENT)) ||
       (SQLITE_OK != sqlite3_bind_blob (stmt, 4, data, size, SQLITE_TRANSIENT)))
   {
@@ -161,7 +161,7 @@ sqlite_plugin_put (void *cls, const GNUNET_HashCode * key, size_t size,
  * @return the number of results found
  */
 static unsigned int
-sqlite_plugin_get (void *cls, const GNUNET_HashCode * key,
+sqlite_plugin_get (void *cls, const struct GNUNET_HashCode * key,
                    enum GNUNET_BLOCK_Type type, GNUNET_DATACACHE_Iterator iter,
                    void *iter_cls)
 {
@@ -192,7 +192,7 @@ sqlite_plugin_get (void *cls, const GNUNET_HashCode * key,
   ntime = (int64_t) now.abs_value;
   GNUNET_assert (ntime >= 0);
   if ((SQLITE_OK !=
-       sqlite3_bind_blob (stmt, 1, key, sizeof (GNUNET_HashCode),
+       sqlite3_bind_blob (stmt, 1, key, sizeof (struct GNUNET_HashCode),
                           SQLITE_TRANSIENT)) ||
       (SQLITE_OK != sqlite3_bind_int (stmt, 2, type)) ||
       (SQLITE_OK != sqlite3_bind_int64 (stmt, 3, now.abs_value)))
@@ -239,7 +239,7 @@ sqlite_plugin_get (void *cls, const GNUNET_HashCode * key,
       return cnt;
     }
     if ((SQLITE_OK !=
-         sqlite3_bind_blob (stmt, 1, key, sizeof (GNUNET_HashCode),
+         sqlite3_bind_blob (stmt, 1, key, sizeof (struct GNUNET_HashCode),
                             SQLITE_TRANSIENT)) ||
         (SQLITE_OK != sqlite3_bind_int (stmt, 2, type)) ||
         (SQLITE_OK != sqlite3_bind_int64 (stmt, 3, now.abs_value)))
@@ -287,7 +287,7 @@ sqlite_plugin_del (void *cls)
   unsigned int dsize;
   sqlite3_stmt *stmt;
   sqlite3_stmt *dstmt;
-  GNUNET_HashCode hc;
+  struct GNUNET_HashCode hc;
 
   LOG (GNUNET_ERROR_TYPE_DEBUG, "Processing `%s'\n", "DEL");
   stmt = NULL;
@@ -311,8 +311,8 @@ sqlite_plugin_del (void *cls)
     return GNUNET_SYSERR;
   }
   rowid = sqlite3_column_int64 (stmt, 0);
-  GNUNET_assert (sqlite3_column_bytes (stmt, 1) == sizeof (GNUNET_HashCode));
-  memcpy (&hc, sqlite3_column_blob (stmt, 1), sizeof (GNUNET_HashCode));
+  GNUNET_assert (sqlite3_column_bytes (stmt, 1) == sizeof (struct GNUNET_HashCode));
+  memcpy (&hc, sqlite3_column_blob (stmt, 1), sizeof (struct GNUNET_HashCode));
   dsize = sqlite3_column_bytes (stmt, 2);
   if (SQLITE_OK != sqlite3_finalize (stmt))
     LOG_SQLITE (plugin->dbh, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
diff --git a/src/datacache/plugin_datacache_template.c b/src/datacache/plugin_datacache_template.c
index 2d3f160e4..6c4395982 100644
--- a/src/datacache/plugin_datacache_template.c
+++ b/src/datacache/plugin_datacache_template.c
@@ -52,7 +52,7 @@ struct Plugin
  * @return 0 on error, number of bytes used otherwise
  */
 static size_t
-template_plugin_put (void *cls, const GNUNET_HashCode * key, size_t size,
+template_plugin_put (void *cls, const struct GNUNET_HashCode * key, size_t size,
                      const char *data, enum GNUNET_BLOCK_Type type,
                      struct GNUNET_TIME_Absolute discard_time)
 {
@@ -73,7 +73,7 @@ template_plugin_put (void *cls, const GNUNET_HashCode * key, size_t size,
  * @return the number of results found
  */
 static unsigned int
-template_plugin_get (void *cls, const GNUNET_HashCode * key,
+template_plugin_get (void *cls, const struct GNUNET_HashCode * key,
                      enum GNUNET_BLOCK_Type type,
                      GNUNET_DATACACHE_Iterator iter, void *iter_cls)
 {
diff --git a/src/datacache/test_datacache.c b/src/datacache/test_datacache.c
index c818daaa8..1d8cd3295 100644
--- a/src/datacache/test_datacache.c
+++ b/src/datacache/test_datacache.c
@@ -39,10 +39,10 @@ static const char *plugin_name;
 
 static int
 checkIt (void *cls, struct GNUNET_TIME_Absolute exp,
-         const GNUNET_HashCode * key, size_t size, const char *data,
+         const struct GNUNET_HashCode * key, size_t size, const char *data,
          enum GNUNET_BLOCK_Type type)
 {
-  if (size != sizeof (GNUNET_HashCode))
+  if (size != sizeof (struct GNUNET_HashCode))
   {
     GNUNET_break (0);
     ok = 2;
@@ -61,8 +61,8 @@ run (void *cls, char *const *args, const char *cfgfile,
      const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct GNUNET_DATACACHE_Handle *h;
-  GNUNET_HashCode k;
-  GNUNET_HashCode n;
+  struct GNUNET_HashCode k;
+  struct GNUNET_HashCode n;
   struct GNUNET_TIME_Absolute exp;
   unsigned int i;
 
@@ -77,27 +77,27 @@ run (void *cls, char *const *args, const char *cfgfile,
   }
   exp = GNUNET_TIME_absolute_get ();
   exp.abs_value += 5 * 60 * 1000;
-  memset (&k, 0, sizeof (GNUNET_HashCode));
+  memset (&k, 0, sizeof (struct GNUNET_HashCode));
   for (i = 0; i < 100; i++)
   {
-    GNUNET_CRYPTO_hash (&k, sizeof (GNUNET_HashCode), &n);
+    GNUNET_CRYPTO_hash (&k, sizeof (struct GNUNET_HashCode), &n);
     ASSERT (GNUNET_OK ==
-            GNUNET_DATACACHE_put (h, &k, sizeof (GNUNET_HashCode),
+            GNUNET_DATACACHE_put (h, &k, sizeof (struct GNUNET_HashCode),
                                   (const char *) &n, 1 + i % 16, exp));
     k = n;
   }
-  memset (&k, 0, sizeof (GNUNET_HashCode));
+  memset (&k, 0, sizeof (struct GNUNET_HashCode));
   for (i = 0; i < 100; i++)
   {
-    GNUNET_CRYPTO_hash (&k, sizeof (GNUNET_HashCode), &n);
+    GNUNET_CRYPTO_hash (&k, sizeof (struct GNUNET_HashCode), &n);
     ASSERT (1 == GNUNET_DATACACHE_get (h, &k, 1 + i % 16, &checkIt, &n));
     k = n;
   }
 
-  memset (&k, 42, sizeof (GNUNET_HashCode));
-  GNUNET_CRYPTO_hash (&k, sizeof (GNUNET_HashCode), &n);
+  memset (&k, 42, sizeof (struct GNUNET_HashCode));
+  GNUNET_CRYPTO_hash (&k, sizeof (struct GNUNET_HashCode), &n);
   ASSERT (GNUNET_OK ==
-          GNUNET_DATACACHE_put (h, &k, sizeof (GNUNET_HashCode),
+          GNUNET_DATACACHE_put (h, &k, sizeof (struct GNUNET_HashCode),
                                 (const char *) &n, 792,
                                 GNUNET_TIME_UNIT_FOREVER_ABS));
   ASSERT (0 != GNUNET_DATACACHE_get (h, &k, 792, &checkIt, &n));
diff --git a/src/datacache/test_datacache_quota.c b/src/datacache/test_datacache_quota.c
index 5325b398f..1f252c14a 100644
--- a/src/datacache/test_datacache_quota.c
+++ b/src/datacache/test_datacache_quota.c
@@ -47,8 +47,8 @@ run (void *cls, char *const *args, const char *cfgfile,
      const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct GNUNET_DATACACHE_Handle *h;
-  GNUNET_HashCode k;
-  GNUNET_HashCode n;
+  struct GNUNET_HashCode k;
+  struct GNUNET_HashCode n;
   unsigned int i;
   unsigned int j;
   char buf[3200];
@@ -64,11 +64,11 @@ run (void *cls, char *const *args, const char *cfgfile,
   }
   exp = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_HOURS);
   memset (buf, 1, sizeof (buf));
-  memset (&k, 0, sizeof (GNUNET_HashCode));
+  memset (&k, 0, sizeof (struct GNUNET_HashCode));
   for (i = 0; i < 10; i++)
   {
     FPRINTF (stderr, "%s",  ".");
-    GNUNET_CRYPTO_hash (&k, sizeof (GNUNET_HashCode), &n);
+    GNUNET_CRYPTO_hash (&k, sizeof (struct GNUNET_HashCode), &n);
     for (j = i; j < sizeof (buf); j += 10)
     {
       exp.abs_value++;
@@ -79,11 +79,11 @@ run (void *cls, char *const *args, const char *cfgfile,
     k = n;
   }
   FPRINTF (stderr, "%s",  "\n");
-  memset (&k, 0, sizeof (GNUNET_HashCode));
+  memset (&k, 0, sizeof (struct GNUNET_HashCode));
   for (i = 0; i < 10; i++)
   {
     FPRINTF (stderr, "%s",  ".");
-    GNUNET_CRYPTO_hash (&k, sizeof (GNUNET_HashCode), &n);
+    GNUNET_CRYPTO_hash (&k, sizeof (struct GNUNET_HashCode), &n);
     if (i < 2)
       ASSERT (0 == GNUNET_DATACACHE_get (h, &k, 1 + i, NULL, NULL));
     if (i == 9)