-more fixes to namestore

9 files changed, 176 insertions, 113 deletions

diff --git a/src/namestore/gnunet-service-namestore.c b/src/namestore/gnunet-service-namestore.c
index b8714f08d..a03f70d2a 100644
--- a/src/namestore/gnunet-service-namestore.c
+++ b/src/namestore/gnunet-service-namestore.c
@@ -24,8 +24,8 @@
  * @author Matthias Wachs
  */
 #include "platform.h"
-#include "gnunet_getopt_lib.h"
-#include "gnunet_service_lib.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_dnsparser_lib.h"
 #include "gnunet_namestore_service.h"
 #include "gnunet_namestore_plugin.h"
 #include "gnunet_signatures.h"
@@ -553,6 +553,7 @@ handle_lookup_name_it (void *cls,
   struct GNUNET_NAMESTORE_CryptoContainer *cc;
   struct GNUNET_CRYPTO_RsaSignature *signature_new;
   struct GNUNET_TIME_Absolute e;
+  struct GNUNET_TIME_Relative re;
   struct GNUNET_CRYPTO_ShortHashCode zone_key_hash;
   struct GNUNET_HashCode long_hash;
   char *rd_tmp;
@@ -563,79 +564,139 @@ handle_lookup_name_it (void *cls,
   int copied_elements;
   int contains_signature;
   int authoritative;
-  int c;
+  int rd_modified;
+  unsigned int c;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Found %u records under name `%s'\n",
+              rd_count,
+              name);
+  authoritative = GNUNET_NO;
+  signature_new = NULL;
+  cc = NULL;
+  if (NULL != zone_key) 
+  {
+    GNUNET_CRYPTO_short_hash (zone_key, 
+                              sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), 
+                              &zone_key_hash);
+    GNUNET_CRYPTO_short_hash_double (&zone_key_hash, &long_hash);
+    if (NULL != (cc = GNUNET_CONTAINER_multihashmap_get (zonekeys, &long_hash)))   
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Am authoritative for zone `%s'\n",
+                  GNUNET_short_h2s (&zone_key_hash));
+      authoritative = GNUNET_YES;    
+    }
+  }
 
-  name_len = (NULL == name) ? 0 : strlen(name) + 1;
   copied_elements = 0;
+  rd_modified = GNUNET_NO;
   rd_selected = NULL;
   /* count records to copy */
-  if (0 != lnc->record_type)
+  for (c = 0; c < rd_count; c++)
+  {
+    if ( (GNUNET_YES == authoritative) &&
+         (GNUNET_YES ==
+          GNUNET_NAMESTORE_is_expired (&rd[c]) ) )
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Skipping expired record\n");
+      continue; 
+    }
+    if ( (GNUNET_NAMESTORE_TYPE_ANY == lnc->record_type) || 
+         (rd[c].record_type == lnc->record_type) )
+      copied_elements++; /* found matching record */
+    else
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+                  "Skipping non-mtaching record\n");
+      rd_modified = GNUNET_YES;
+    }
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+              "Found %u records with type %u for name `%s' in zone `%s'\n",
+              copied_elements, 
+              lnc->record_type, 
+              lnc->name, 
+              GNUNET_short_h2s(lnc->zone));
+  if (copied_elements > 0)
   {
-    /* special record type needed */
+    rd_selected = GNUNET_malloc (copied_elements * sizeof (struct GNUNET_NAMESTORE_RecordData));
+    copied_elements = 0;
     for (c = 0; c < rd_count; c++)
-      if (rd[c].record_type == lnc->record_type)
-        copied_elements++; /* found matching record */
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                "Found %u records with type %u for name `%s' in zone `%s'\n",
-                copied_elements, 
-                lnc->record_type, 
-                lnc->name, 
-                GNUNET_short_h2s(lnc->zone));
-    if (copied_elements > 0)
     {
-      rd_selected = GNUNET_malloc (copied_elements * sizeof (struct GNUNET_NAMESTORE_RecordData));
-      copied_elements = 0;
-      for (c = 0; c < rd_count; c++)
+      if ( (GNUNET_YES == authoritative) &&
+           (GNUNET_YES ==
+            GNUNET_NAMESTORE_is_expired (&rd[c])) )
+        continue;
+      if ( (GNUNET_NAMESTORE_TYPE_ANY == lnc->record_type) || 
+           (rd[c].record_type == lnc->record_type) )
       {
-        if (rd[c].record_type == lnc->record_type)
+        if (0 != (rd[c].flags & GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION))
         {
-          /* found matching record */
-          rd_selected[copied_elements] = rd[c]; /* shallow copy! */
-          copied_elements++;
+          GNUNET_break (GNUNET_YES == authoritative);
+          rd_modified = GNUNET_YES;
+          re.rel_value = rd[c].expiration_time;
+          e = GNUNET_TIME_relative_to_absolute (re);
         }
+        else
+        {
+          e.abs_value = rd[c].expiration_time;
+        }
+        /* found matching record, copy and convert flags to public format */
+        rd_selected[copied_elements] = rd[c]; /* shallow copy! */
+        rd_selected[copied_elements].expiration_time = e.abs_value;
+        if (0 != (rd_selected[copied_elements].flags &
+                  (GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION | GNUNET_NAMESTORE_RF_AUTHORITY)))
+        {
+          rd_selected[copied_elements].flags &= ~ (GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION | 
+                                  GNUNET_NAMESTORE_RF_AUTHORITY);
+          rd_modified = GNUNET_YES;
+        }
+        copied_elements++;
+      }
+      else
+      {
+        rd_modified = GNUNET_YES;
       }
     }
   }
   else
-  {
-    copied_elements = rd_count;
-    rd_selected = (struct GNUNET_NAMESTORE_RecordData *) rd;
-  }
-  // FIXME: need to adjust 'rd' from relative to absolute times!
+    rd_selected = NULL;
+
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-              "Found %u records for name `%s' in zone `%s'\n",
+              "Found %u matching records for name `%s' in zone `%s'\n",
               copied_elements,
               lnc->name, 
               GNUNET_short_h2s (lnc->zone));
-
-  if ((copied_elements == rd_count) && (NULL != signature))
-    contains_signature = GNUNET_YES; /* returning all records, so include signature */
-  else
-    contains_signature = GNUNET_NO; /* returning not all records, so do not include signature */
-
-  authoritative = GNUNET_NO;
-  signature_new = NULL;
-  if ((NULL != zone_key) && (copied_elements == rd_count))
+  contains_signature = GNUNET_NO;
+  if (copied_elements > 0)
   {
-    GNUNET_CRYPTO_short_hash (zone_key, 
-                              sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), 
-                              &zone_key_hash);
-    GNUNET_CRYPTO_short_hash_double (&zone_key_hash, &long_hash);
-    if (NULL != (cc = GNUNET_CONTAINER_multihashmap_get(zonekeys, &long_hash)))
+    if (GNUNET_YES == authoritative)
     {
+      GNUNET_assert (NULL != cc);
       e = get_block_expiration_time (rd_count, rd);
-      signature_new = GNUNET_NAMESTORE_create_signature (cc->privkey, e, name, rd, rd_count);
+      signature_new = GNUNET_NAMESTORE_create_signature (cc->privkey, e, name, rd_selected, copied_elements);
       GNUNET_assert (NULL != signature_new);
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
                   "Creating signature for name `%s' with %u records in zone `%s'\n",
                   name, 
                   copied_elements,
                   GNUNET_short_h2s(&zone_key_hash));
-      authoritative = GNUNET_YES;
+    }
+    else
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Not authoritative, records modified is %d, have sig is %d\n",
+                  rd_modified,
+                  NULL != signature);
+      if ((GNUNET_NO == rd_modified) && (NULL != signature))
+        contains_signature = GNUNET_YES; /* returning all records, so include signature */
     }
   }
 
   rd_ser_len = GNUNET_NAMESTORE_records_get_size (copied_elements, rd_selected);
+  name_len = (NULL == name) ? 0 : strlen(name) + 1;
   r_size = sizeof (struct LookupNameResponseMessage) +
            sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) +
            name_len +
@@ -656,13 +717,12 @@ handle_lookup_name_it (void *cls,
   memcpy (name_tmp, name, name_len);
   rd_tmp = &name_tmp[name_len];
   GNUNET_NAMESTORE_records_serialize (copied_elements, rd_selected, rd_ser_len, rd_tmp);
-
   if (rd_selected != rd)
     GNUNET_free_non_null (rd_selected);
-
   if (NULL != zone_key)
     lnr_msg->public_key = *zone_key;
-  if (GNUNET_YES == authoritative)
+  if ( (GNUNET_YES == authoritative) &&
+       (copied_elements > 0) )
   {
     /* use new created signature */
     lnr_msg->contains_sig = htons (GNUNET_YES);
@@ -957,35 +1017,31 @@ handle_create_record_it (void *cls,
   update = GNUNET_NO;
   for (c = 0; c < rd_count; c++)
   {
-    if (crc->rd->record_type != rd[c].record_type)
+    if ( (crc->rd->record_type != rd[c].record_type) ||
+         ((crc->rd->flags & GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION) 
+          != (rd[c].flags & GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION)) )
       continue; /* no match */
     if ( (GNUNET_NAMESTORE_TYPE_PKEY == crc->rd->record_type) ||
-         (GNUNET_NAMESTORE_TYPE_PSEU == crc->rd->record_type) )
+         (GNUNET_NAMESTORE_TYPE_PSEU == crc->rd->record_type) ||
+         (GNUNET_DNSPARSER_TYPE_CNAME == crc->rd->record_type) )
     {
-      /* Update unique PKEY or PSEU */
-      /* FIXME: should we do this test here? Is this not something
-         that should be handled closer to the UI? If not, what 
-         about othrer 'unique' record types like CNAME? */
+      /* Update unique PKEY, PSEU or CNAME record; for these
+         record types, only one can be active at any time */
       exist = c;
       if ( (crc->rd->data_size != rd[c].data_size) ||
            (0 != memcmp (crc->rd->data, rd[c].data, rd[c].data_size)) ||
-           (crc->rd->expiration_time != rd[c].expiration_time) ||
-           ((crc->rd->flags & GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION) 
-            != (rd[c].flags & GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION)) )
+           (crc->rd->expiration_time != rd[c].expiration_time) )
         update = GNUNET_YES;
       break;
     }
     if ( (crc->rd->data_size == rd[c].data_size) &&
          (0 == memcmp (crc->rd->data, rd[c].data, rd[c].data_size)))
     {
-      /* FIXME: again, do we need to handle this special case here? */
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
                   "Found matching existing record for `%s'; only updating expiration date!\n",
                   crc->name);
       exist = c;
-      if ( (crc->rd->expiration_time != rd[c].expiration_time) &&
-           ((crc->rd->flags & GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION) 
-            == (rd[c].flags & GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION) ) )
+      if (crc->rd->expiration_time != rd[c].expiration_time) 
         update = GNUNET_YES;
       break;
     }
@@ -1682,7 +1738,7 @@ zone_iteraterate_proc (void *cls,
   {
     // FIXME: new expiration flags need additional special treatment here!
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Record %i has flags: 0x%x must have 0x%x \n",
+                "Record %i has flags: 0x%x must have 0x%x\n",
                 c, rd[c].flags, 
                 proc->zi->must_have_flags);
     include = GNUNET_YES;
@@ -1719,43 +1775,39 @@ zone_iteraterate_proc (void *cls,
               "Included %u of %u records\n", 
               rd_count_filtered, rd_count);
 
-  /* compute / obtain signature */
-  GNUNET_CRYPTO_short_hash (zone_key, 
-                            sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
-                            &zone_hash);
-  GNUNET_CRYPTO_short_hash_double (&zone_hash, &long_hash);
-  if (NULL != (cc = GNUNET_CONTAINER_multihashmap_get(zonekeys, &long_hash)))
-  {
-    expire = get_block_expiration_time (rd_count_filtered, rd_filtered);
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Creating signature for `%s' in zone `%s' with %u records and expiration %llu\n",
-                name, GNUNET_short_h2s(&zone_hash), 
-                rd_count_filtered,
-                (unsigned long long) expire.abs_value);
-    new_signature = GNUNET_NAMESTORE_create_signature (cc->privkey, expire, name, 
-                                                       rd_filtered, rd_count_filtered);
-    GNUNET_assert (NULL != signature);
-    signature = new_signature;
-  }
-  else if (rd_count_filtered == rd_count)
+  signature = NULL;    
+  if (rd_count_filtered > 0)
   {
-    if (NULL != signature)
+    /* compute / obtain signature */
+    GNUNET_CRYPTO_short_hash (zone_key, 
+                              sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                              &zone_hash);
+    GNUNET_CRYPTO_short_hash_double (&zone_hash, &long_hash);
+    if (NULL != (cc = GNUNET_CONTAINER_multihashmap_get(zonekeys, &long_hash)))
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                  "Using provided signature for `%s' in zone `%s' with %u records and expiration %llu\n",
-                  name, GNUNET_short_h2s (&zone_hash), rd_count_filtered, 
+      expire = get_block_expiration_time (rd_count_filtered, rd_filtered);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Creating signature for `%s' in zone `%s' with %u records and expiration %llu\n",
+                  name, GNUNET_short_h2s(&zone_hash), 
+                  rd_count_filtered,
                   (unsigned long long) expire.abs_value);
-      return;
-    }    
-  }
-  else
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                "No signature provided for `%s'\n",
-                name);
-    signature = NULL;
+      new_signature = GNUNET_NAMESTORE_create_signature (cc->privkey, expire, name, 
+                                                         rd_filtered, rd_count_filtered);
+      GNUNET_assert (NULL != new_signature);
+      signature = new_signature;
+    }
+    else if (rd_count_filtered == rd_count)
+    {
+      if (NULL != signature)
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+                      "Using provided signature for `%s' in zone `%s' with %u records and expiration %llu\n",
+                      name, GNUNET_short_h2s (&zone_hash), rd_count_filtered, 
+                      (unsigned long long) expire.abs_value);
+          return;
+        }    
+    }
   }
-
   if (GNUNET_YES == proc->zi->has_zone)
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
                 "Sending name `%s' for iteration over zone `%s'\n",
diff --git a/src/namestore/namestore_common.c b/src/namestore/namestore_common.c
index 5698236c5..8a2e15e2a 100644
--- a/src/namestore/namestore_common.c
+++ b/src/namestore/namestore_common.c
@@ -614,6 +614,22 @@ GNUNET_NAMESTORE_number_to_typename (uint32_t type)
   return name_map[i].name;  
 }
 
+/**
+ * Test if a given record is expired.
+ * 
+ * @return GNUNET_YES if the record is expired,
+ *         GNUNET_NO if not
+ */
+int
+GNUNET_NAMESTORE_is_expired (const struct GNUNET_NAMESTORE_RecordData *rd)
+{
+  struct GNUNET_TIME_Absolute at;
+
+  if (0 != (rd->flags & GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION))
+    return GNUNET_NO;
+  at.abs_value = rd->expiration_time;
+  return (0 == GNUNET_TIME_absolute_get_remaining (at).rel_value) ? GNUNET_YES : GNUNET_NO;
+}
 
 
 /* end of namestore_common.c */
diff --git a/src/namestore/test_namestore_api_create.c b/src/namestore/test_namestore_api_create.c
index 9c794b235..b04e236ba 100644
--- a/src/namestore/test_namestore_api_create.c
+++ b/src/namestore/test_namestore_api_create.c
@@ -152,13 +152,13 @@ name_lookup_second_proc (void *cls,
       }
     }
 
-    if (GNUNET_OK != GNUNET_NAMESTORE_verify_signature(zone_key, expire, n, rd_count, rd, signature))
+    if (GNUNET_OK != GNUNET_NAMESTORE_verify_signature (zone_key, expire, n, rd_count, rd, signature))
     {
       GNUNET_break (0);
       failed = GNUNET_YES;
     }
 
-    if (GNUNET_OK != GNUNET_NAMESTORE_verify_signature(&pubkey, expire, n, rd_count, rd, signature))
+    if (GNUNET_OK != GNUNET_NAMESTORE_verify_signature (&pubkey, expire, n, rd_count, rd, signature))
     {
       GNUNET_break (0);
       failed = GNUNET_YES;
@@ -167,7 +167,8 @@ name_lookup_second_proc (void *cls,
     struct GNUNET_NAMESTORE_RecordData rd_new[2];
     rd_new[0] = *s_first_record;
     rd_new[1] = *s_second_record;
-    s_signature_updated = GNUNET_NAMESTORE_create_signature(privkey, expire, s_name, rd_new, 2);
+    rd_new[1].flags = 0; /* unset GNUNET_NAMESTORE_RF_AUTHORITY */
+    s_signature_updated = GNUNET_NAMESTORE_create_signature (privkey, expire, s_name, rd_new, 2);
 
     if (0 != memcmp (s_signature_updated, signature, sizeof (struct GNUNET_CRYPTO_RsaSignature)))
     {
@@ -330,7 +331,7 @@ create_record (unsigned int count)
   rd = GNUNET_malloc (count * sizeof (struct GNUNET_NAMESTORE_RecordData));
   for (c = 0; c < count; c++)
   {
-    rd[c].expiration_time = GNUNET_TIME_absolute_get().abs_value;
+    rd[c].expiration_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_HOURS).abs_value;
     rd[c].record_type = TEST_RECORD_TYPE;
     rd[c].data_size = TEST_RECORD_DATALEN;
     rd[c].data = GNUNET_malloc(TEST_RECORD_DATALEN);
diff --git a/src/namestore/test_namestore_api_lookup.c b/src/namestore/test_namestore_api_lookup.c
index 702fb2db1..9ed2c83c1 100644
--- a/src/namestore/test_namestore_api_lookup.c
+++ b/src/namestore/test_namestore_api_lookup.c
@@ -28,8 +28,6 @@
 #include "namestore.h"
 #include "gnunet_signatures.h"
 
-#define VERBOSE GNUNET_NO
-
 #define RECORDS 5
 
 #define TEST_RECORD_TYPE 1234
@@ -120,6 +118,7 @@ name_lookup_proc (void *cls,
     {
       GNUNET_break (0);
     }
+    GNUNET_assert (NULL != signature);
     if (0 != memcmp (signature, s_signature, sizeof (struct GNUNET_CRYPTO_RsaSignature)))
     {
       GNUNET_break (0);
@@ -184,7 +183,7 @@ create_record (unsigned int count)
   rd = GNUNET_malloc (count * sizeof (struct GNUNET_NAMESTORE_RecordData));
   for (c = 0; c < count; c++)
   {
-    rd[c].expiration_time = GNUNET_TIME_absolute_get().abs_value;
+    rd[c].expiration_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_HOURS).abs_value;
     rd[c].record_type = TEST_RECORD_TYPE;
     rd[c].data_size = TEST_RECORD_DATALEN;
     rd[c].data = GNUNET_malloc(TEST_RECORD_DATALEN);
diff --git a/src/namestore/test_namestore_api_lookup_specific_type.c b/src/namestore/test_namestore_api_lookup_specific_type.c
index 26f037b00..fbbf009cd 100644
--- a/src/namestore/test_namestore_api_lookup_specific_type.c
+++ b/src/namestore/test_namestore_api_lookup_specific_type.c
@@ -140,11 +140,6 @@ name_lookup_existing_record_type (void *cls,
     GNUNET_break(0);
     failed = GNUNET_YES;
   }
-  if (NULL != signature)
-  {
-    GNUNET_break(0);
-    failed = GNUNET_YES;
-  }
   if (failed == GNUNET_YES)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Namestore returned invalid response\n");
@@ -254,13 +249,13 @@ create_record (unsigned int count)
   rd = GNUNET_malloc (count * sizeof (struct GNUNET_NAMESTORE_RecordData));
   for (c = 0; c < count-1; c++)
   {
-    rd[c].expiration_time = 0;
+    rd[c].expiration_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_HOURS).abs_value;
     rd[c].record_type = 1;
     rd[c].data_size = TEST_RECORD_DATALEN;
     rd[c].data = GNUNET_malloc(TEST_RECORD_DATALEN);
     memset ((char *) rd[c].data, TEST_RECORD_DATA, TEST_RECORD_DATALEN);
   }
-  rd[c].expiration_time = GNUNET_TIME_absolute_get().abs_value;
+  rd[c].expiration_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_HOURS).abs_value;
   rd[c].record_type = TEST_RECORD_LOOKUP_TYPE_EXISTING;
   rd[c].data_size = TEST_RECORD_DATALEN;
   rd[c].data = GNUNET_malloc(TEST_RECORD_DATALEN);
diff --git a/src/namestore/test_namestore_api_remove.c b/src/namestore/test_namestore_api_remove.c
index 0ee4e44f7..639ebb3cf 100644
--- a/src/namestore/test_namestore_api_remove.c
+++ b/src/namestore/test_namestore_api_remove.c
@@ -220,14 +220,14 @@ create_record (unsigned int count)
   struct GNUNET_NAMESTORE_RecordData * rd;
 
   rd = GNUNET_malloc (count * sizeof (struct GNUNET_NAMESTORE_RecordData));
-  rd[0].expiration_time = GNUNET_TIME_absolute_get().abs_value;
+  rd[0].expiration_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_HOURS).abs_value;
   rd[0].record_type = 0;
   rd[0].data_size = TEST_REMOVE_RECORD_DATALEN;
   rd[0].data = GNUNET_malloc(TEST_REMOVE_RECORD_DATALEN);
   memset ((char *) rd[0].data, TEST_RECORD_DATA, TEST_RECORD_DATALEN);
   for (c = 1; c < count; c++)
   {
-    rd[c].expiration_time = 0;
+    rd[c].expiration_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_HOURS).abs_value;
     rd[c].record_type = TEST_RECORD_TYPE;
     rd[c].data_size = TEST_RECORD_DATALEN;
     rd[c].data = GNUNET_malloc(TEST_RECORD_DATALEN);
diff --git a/src/namestore/test_namestore_api_zone_iteration.c b/src/namestore/test_namestore_api_zone_iteration.c
index 1d5f013cb..78b390cc6 100644
--- a/src/namestore/test_namestore_api_zone_iteration.c
+++ b/src/namestore/test_namestore_api_zone_iteration.c
@@ -353,7 +353,7 @@ create_record (unsigned int count)
   rd = GNUNET_malloc (count * sizeof (struct GNUNET_NAMESTORE_RecordData));
   for (c = 0; c < count; c++)
   {
-    rd[c].expiration_time = GNUNET_TIME_absolute_get().abs_value;
+    rd[c].expiration_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_HOURS).abs_value;
     rd[c].record_type = 1111;
     rd[c].data_size = 50;
     rd[c].data = GNUNET_malloc(50);
diff --git a/src/namestore/test_namestore_api_zone_iteration_specific_zone.c b/src/namestore/test_namestore_api_zone_iteration_specific_zone.c
index 429636e4b..3ee452b69 100644
--- a/src/namestore/test_namestore_api_zone_iteration_specific_zone.c
+++ b/src/namestore/test_namestore_api_zone_iteration_specific_zone.c
@@ -312,7 +312,7 @@ create_record (unsigned int count)
   rd = GNUNET_malloc (count * sizeof (struct GNUNET_NAMESTORE_RecordData));
   for (c = 0; c < count; c++)
   {
-    rd[c].expiration_time = GNUNET_TIME_absolute_get().abs_value;
+    rd[c].expiration_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_HOURS).abs_value;
     rd[c].record_type = 1111;
     rd[c].data_size = 50;
     rd[c].data = GNUNET_malloc(50);
diff --git a/src/namestore/test_namestore_api_zone_iteration_stop.c b/src/namestore/test_namestore_api_zone_iteration_stop.c
index 4974875d1..3b2da0f19 100644
--- a/src/namestore/test_namestore_api_zone_iteration_stop.c
+++ b/src/namestore/test_namestore_api_zone_iteration_stop.c
@@ -361,7 +361,7 @@ create_record (unsigned int count)
   rd = GNUNET_malloc (count * sizeof (struct GNUNET_NAMESTORE_RecordData));
   for (c = 0; c < count; c++)
   {
-    rd[c].expiration_time = GNUNET_TIME_absolute_get().abs_value;
+    rd[c].expiration_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_HOURS).abs_value;
     rd[c].record_type = 1111;
     rd[c].data_size = 50;
     rd[c].data = GNUNET_malloc(50);