Merge branch 'master' of gnunet.org:gnunet

6 files changed, 611 insertions, 368 deletions

diff --git a/src/identity/Makefile.am b/src/identity/Makefile.am
index 5c1af8e19..b4e62f595 100644
--- a/src/identity/Makefile.am
+++ b/src/identity/Makefile.am
@@ -14,7 +14,7 @@ endif
 
 if HAVE_MHD
 if HAVE_JSON
-REST_PLUGIN = libgnunet_plugin_rest_identity.la
+plugin_LTLIBRARIES = libgnunet_plugin_rest_identity.la
 endif
 endif
 
@@ -26,8 +26,7 @@ pkgcfg_DATA = \
   identity.conf
 
 lib_LTLIBRARIES = \
-  libgnunetidentity.la \
-  $(REST_PLUGIN)
+  libgnunetidentity.la
 
 
 libgnunet_plugin_rest_identity_la_SOURCES = \
diff --git a/src/identity/plugin_rest_identity.c b/src/identity/plugin_rest_identity.c
index 3bfca3121..89f590d3e 100644
--- a/src/identity/plugin_rest_identity.c
+++ b/src/identity/plugin_rest_identity.c
@@ -490,15 +490,6 @@ ego_get_all (struct GNUNET_REST_RequestHandle *con_handle,
     json_decref (json_ego);
   }
 
-  if ((size_t) 0 == json_array_size (json_root))
-  {
-    json_decref (json_root);
-    handle->response_code = MHD_HTTP_NOT_FOUND;
-    handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_NOT_FOUND);
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-
   result_str = json_dumps (json_root, 0);
   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
   resp = GNUNET_REST_create_response (result_str);
diff --git a/src/include/gnunet_peerstore_service.h b/src/include/gnunet_peerstore_service.h
index b20c1f3c7..ad80a3fa3 100644
--- a/src/include/gnunet_peerstore_service.h
+++ b/src/include/gnunet_peerstore_service.h
@@ -61,6 +61,14 @@ extern "C" {
   "transport-backchannel-monotonic-time"
 
 /**
+ * Key used to store sender's monotonic time from DV learn
+ * messages.
+ */
+#define GNUNET_PEERSTORE_TRANSPORT_DVLEARN_MONOTIME \
+  "transport-dv-learn-monotonic-time"
+
+
+/**
  * Options for storing values in PEERSTORE
  */
 enum GNUNET_PEERSTORE_StoreOption
diff --git a/src/json/json_gnsrecord.c b/src/json/json_gnsrecord.c
index 83ea367d5..cbdc0ff91 100644
--- a/src/json/json_gnsrecord.c
+++ b/src/json/json_gnsrecord.c
@@ -45,11 +45,12 @@
  */
 static int
 parse_gnsrecordobject (void *cls,
-                       json_t *root,
-                       struct GNUNET_JSON_Specification *spec)
+                       json_t *root,
+                       struct GNUNET_JSON_Specification *spec)
 {
   struct GNUNET_GNSRECORD_Data *gnsrecord_object;
   struct GNUNET_TIME_Absolute abs_expiration_time;
+  struct GNUNET_TIME_Relative rel_expiration_time;
   int unpack_state=0;
   const char *value;
   const char *expiration_time;
@@ -63,21 +64,21 @@ parse_gnsrecordobject (void *cls,
   if(!json_is_object(root))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Error json is not array nor object!\n");
+                "Error json is not array nor object!\n");
     return GNUNET_SYSERR;
   }
   //interpret single gns record
   unpack_state = json_unpack(root,
-                             "{s:s, s:s, s:s, s?:i, s:s!}",
-                             GNUNET_JSON_GNSRECORD_VALUE, &value,
-                             GNUNET_JSON_GNSRECORD_TYPE, &record_type,
-                             GNUNET_JSON_GNSRECORD_EXPIRATION_TIME, &expiration_time,
-                             GNUNET_JSON_GNSRECORD_FLAG, &flag,
-                             GNUNET_JSON_GNSRECORD_RECORD_NAME, &name);
+                             "{s:s, s:s, s:s, s?:i, s:s!}",
+                             GNUNET_JSON_GNSRECORD_VALUE, &value,
+                             GNUNET_JSON_GNSRECORD_TYPE, &record_type,
+                             GNUNET_JSON_GNSRECORD_EXPIRATION_TIME, &expiration_time,
+                             GNUNET_JSON_GNSRECORD_FLAG, &flag,
+                             GNUNET_JSON_GNSRECORD_RECORD_NAME, &name);
   if (0 != unpack_state)
   {
     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-               "Error json object has a wrong format!\n");
+               "Error json object has a wrong format!\n");
     return GNUNET_SYSERR;
   }
   gnsrecord_object = GNUNET_new (struct GNUNET_GNSRECORD_Data);
@@ -90,9 +91,9 @@ parse_gnsrecordobject (void *cls,
   }
   if (GNUNET_OK
       != GNUNET_GNSRECORD_string_to_value (gnsrecord_object->record_type,
-                                           value,
-                                           &rdata,
-                                           &rdata_size))
+                                           value,
+                                           &rdata,
+                                           &rdata_size))
   {
     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,"Value invalid for record type\n");
     GNUNET_free(gnsrecord_object);
@@ -107,25 +108,20 @@ parse_gnsrecordobject (void *cls,
     gnsrecord_object->expiration_time = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
   }
   else if (GNUNET_OK
-      == GNUNET_STRINGS_fancy_time_to_absolute (expiration_time,
-                                                &abs_expiration_time))
+           == GNUNET_STRINGS_fancy_time_to_absolute (expiration_time,
+                                                     &abs_expiration_time))
   {
     gnsrecord_object->expiration_time = abs_expiration_time.abs_value_us;
   }
-  else
+  else if (GNUNET_OK
+           == GNUNET_STRINGS_fancy_time_to_relative (expiration_time,
+                                                     &rel_expiration_time))
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Expiration time invalid\n");
-    GNUNET_free_non_null(rdata);
-    GNUNET_free(gnsrecord_object);
-    return GNUNET_SYSERR;
+    gnsrecord_object->expiration_time = rel_expiration_time.rel_value_us;
   }
-  // check if flag is a valid enum value
-  if ((GNUNET_GNSRECORD_RF_NONE != flag)
-      && (GNUNET_GNSRECORD_RF_PRIVATE != flag)
-      && (GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION != flag)
-      && (GNUNET_GNSRECORD_RF_SHADOW_RECORD) != flag)
+  else
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Flag invalid\n");
+    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Expiration time invalid\n");
     GNUNET_free_non_null(rdata);
     GNUNET_free(gnsrecord_object);
     return GNUNET_SYSERR;
diff --git a/src/namestore/plugin_rest_namestore.c b/src/namestore/plugin_rest_namestore.c
index 26a037eae..46e5a590f 100644
--- a/src/namestore/plugin_rest_namestore.c
+++ b/src/namestore/plugin_rest_namestore.c
@@ -86,7 +86,7 @@ const struct GNUNET_CONFIGURATION_Handle *cfg;
 /**
  * HTTP methods allows for this plugin
  */
-static char* allow_methods;
+static char *allow_methods;
 
 /**
  * @brief struct returned by the initialization function of the plugin
@@ -201,7 +201,7 @@ struct RequestHandle
    * Rest connection
    */
   struct GNUNET_REST_RequestHandle *rest_handle;
-  
+
   /**
    * Desired timeout for the lookup (default is no timeout).
    */
@@ -236,7 +236,6 @@ struct RequestHandle
    * Response code
    */
   int response_code;
-
 };
 
 /**
@@ -250,51 +249,49 @@ cleanup_handle (void *cls)
   struct EgoEntry *ego_entry;
   struct EgoEntry *ego_tmp;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Cleaning up\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
   if (NULL != handle->timeout_task)
   {
     GNUNET_SCHEDULER_cancel (handle->timeout_task);
     handle->timeout_task = NULL;
   }
   if (NULL != handle->record_name)
-    GNUNET_free(handle->record_name);
+    GNUNET_free (handle->record_name);
   if (NULL != handle->url)
-    GNUNET_free(handle->url);
+    GNUNET_free (handle->url);
   if (NULL != handle->emsg)
-    GNUNET_free(handle->emsg);
+    GNUNET_free (handle->emsg);
   if (NULL != handle->rd)
   {
     if (NULL != handle->rd->data)
-      GNUNET_free((void*)handle->rd->data);
-    GNUNET_free(handle->rd);
+      GNUNET_free ((void *) handle->rd->data);
+    GNUNET_free (handle->rd);
   }
   if (NULL != handle->timeout_task)
-    GNUNET_SCHEDULER_cancel(handle->timeout_task);
+    GNUNET_SCHEDULER_cancel (handle->timeout_task);
   if (NULL != handle->list_it)
-    GNUNET_NAMESTORE_zone_iteration_stop(handle->list_it);
+    GNUNET_NAMESTORE_zone_iteration_stop (handle->list_it);
   if (NULL != handle->add_qe)
-    GNUNET_NAMESTORE_cancel(handle->add_qe);
+    GNUNET_NAMESTORE_cancel (handle->add_qe);
   if (NULL != handle->identity_handle)
-    GNUNET_IDENTITY_disconnect(handle->identity_handle);
+    GNUNET_IDENTITY_disconnect (handle->identity_handle);
   if (NULL != handle->ns_handle)
   {
-    GNUNET_NAMESTORE_disconnect(handle->ns_handle);
+    GNUNET_NAMESTORE_disconnect (handle->ns_handle);
   }
 
-  for (ego_entry = handle->ego_head;
-  NULL != ego_entry;)
+  for (ego_entry = handle->ego_head; NULL != ego_entry;)
   {
     ego_tmp = ego_entry;
     ego_entry = ego_entry->next;
-    GNUNET_free(ego_tmp->identifier);
-    GNUNET_free(ego_tmp->keystring);
-    GNUNET_free(ego_tmp);
+    GNUNET_free (ego_tmp->identifier);
+    GNUNET_free (ego_tmp->keystring);
+    GNUNET_free (ego_tmp);
   }
 
-  if(NULL != handle->resp_object)
+  if (NULL != handle->resp_object)
   {
-    json_decref(handle->resp_object);
+    json_decref (handle->resp_object);
   }
 
   GNUNET_free (handle);
@@ -311,21 +308,21 @@ do_error (void *cls)
 {
   struct RequestHandle *handle = cls;
   struct MHD_Response *resp;
-  json_t *json_error = json_object();
+  json_t *json_error = json_object ();
   char *response;
 
   if (NULL == handle->emsg)
-    handle->emsg = GNUNET_strdup(GNUNET_REST_NAMESTORE_ERROR_UNKNOWN);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_ERROR_UNKNOWN);
 
-  json_object_set_new(json_error,"error", json_string(handle->emsg));
+  json_object_set_new (json_error, "error", json_string (handle->emsg));
 
   if (0 == handle->response_code)
-    handle->response_code = MHD_HTTP_OK;
+    handle->response_code = MHD_HTTP_INTERNAL_SERVER_ERROR;
   response = json_dumps (json_error, 0);
   resp = GNUNET_REST_create_response (response);
   handle->proc (handle->proc_cls, resp, handle->response_code);
-  json_decref(json_error);
-  GNUNET_free(response);
+  json_decref (json_error);
+  GNUNET_free (response);
   GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
 }
 
@@ -339,18 +336,17 @@ do_error (void *cls)
  * @param name the name of an identity (only one can be NULL)
  * @return EgoEntry or NULL if not found
  */
-struct EgoEntry*
-get_egoentry_namestore(struct RequestHandle *handle, char *name)
+struct EgoEntry *
+get_egoentry_namestore (struct RequestHandle *handle, char *name)
 {
   struct EgoEntry *ego_entry;
   if (NULL != name)
   {
-    for (ego_entry = handle->ego_head;
-        NULL != ego_entry;
-        ego_entry = ego_entry->next)
+    for (ego_entry = handle->ego_head; NULL != ego_entry;
+         ego_entry = ego_entry->next)
     {
       if (0 != strcasecmp (name, ego_entry->identifier))
-        continue;
+        continue;
       return ego_entry;
     }
   }
@@ -367,7 +363,7 @@ static void
 namestore_iteration_error (void *cls)
 {
   struct RequestHandle *handle = cls;
-  handle->emsg = GNUNET_strdup(GNUNET_REST_NAMESTORE_FAILED);
+  handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_FAILED);
   GNUNET_SCHEDULER_add_now (&do_error, handle);
   return;
 }
@@ -391,11 +387,11 @@ create_finished (void *cls, int32_t success, const char *emsg)
   {
     if (NULL != emsg)
     {
-      handle->emsg = GNUNET_strdup(emsg);
+      handle->emsg = GNUNET_strdup (emsg);
       GNUNET_SCHEDULER_add_now (&do_error, handle);
       return;
     }
-    handle->emsg = GNUNET_strdup("Error storing records");
+    handle->emsg = GNUNET_strdup ("Error storing records");
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
@@ -421,7 +417,7 @@ del_finished (void *cls, int32_t success, const char *emsg)
   if (GNUNET_NO == success)
   {
     handle->response_code = MHD_HTTP_NOT_FOUND;
-    handle->emsg = GNUNET_strdup("No record found");
+    handle->emsg = GNUNET_strdup ("No record found");
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
@@ -429,11 +425,11 @@ del_finished (void *cls, int32_t success, const char *emsg)
   {
     if (NULL != emsg)
     {
-      handle->emsg = GNUNET_strdup(emsg);
+      handle->emsg = GNUNET_strdup (emsg);
       GNUNET_SCHEDULER_add_now (&do_error, handle);
       return;
     }
-    handle->emsg = GNUNET_strdup("Deleting record failed");
+    handle->emsg = GNUNET_strdup ("Deleting record failed");
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
@@ -460,10 +456,10 @@ namestore_list_finished (void *cls)
   handle->list_it = NULL;
 
   if (NULL == handle->resp_object)
-    handle->resp_object = json_array();
+    handle->resp_object = json_array ();
 
   result_str = json_dumps (handle->resp_object, 0);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
   resp = GNUNET_REST_create_response (result_str);
   handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
   GNUNET_free_non_null (result_str);
@@ -478,26 +474,26 @@ namestore_list_finished (void *cls)
  */
 static void
 namestore_list_iteration (void *cls,
-                         const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
-                         const char *rname,
-                         unsigned int rd_len,
-                         const struct GNUNET_GNSRECORD_Data *rd)
+                          const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
+                          const char *rname,
+                          unsigned int rd_len,
+                          const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct RequestHandle *handle = cls;
   json_t *record_obj;
 
   if (NULL == handle->resp_object)
-    handle->resp_object = json_array();
+    handle->resp_object = json_array ();
 
   for (unsigned int i = 0; i < rd_len; i++)
   {
-    if ( (GNUNET_GNSRECORD_TYPE_NICK == rd[i].record_type) &&
-         (0 != strcmp (rname, GNUNET_GNS_EMPTY_LABEL_AT)) )
+    if ((GNUNET_GNSRECORD_TYPE_NICK == rd[i].record_type) &&
+        (0 != strcmp (rname, GNUNET_GNS_EMPTY_LABEL_AT)))
       continue;
 
-    record_obj = GNUNET_JSON_from_gns_record(rname,rd);
+    record_obj = GNUNET_JSON_from_gns_record (rname, &rd[i]);
 
-    if(NULL == record_obj)
+    if (NULL == record_obj)
       continue;
 
     json_array_append (handle->resp_object, record_obj);
@@ -518,32 +514,33 @@ namestore_list_iteration (void *cls,
  */
 static void
 default_ego_get (void *cls,
-                 struct GNUNET_IDENTITY_Ego *ego,
-                 void **ctx,
-                 const char *identifier)
+                 struct GNUNET_IDENTITY_Ego *ego,
+                 void **ctx,
+                 const char *identifier)
 {
   struct RequestHandle *handle = cls;
   handle->op = NULL;
 
   if (ego == NULL)
   {
-    handle->emsg = GNUNET_strdup(GNUNET_REST_NAMESTORE_NO_DEFAULT_ZONE);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_NO_DEFAULT_ZONE);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
   handle->zone_pkey = GNUNET_IDENTITY_ego_get_private_key (ego);
 
-  handle->list_it = GNUNET_NAMESTORE_zone_iteration_start (handle->ns_handle,
-                                                           handle->zone_pkey,
-                                                           &namestore_iteration_error,
-                                                           handle,
-                                                           &namestore_list_iteration,
-                                                           handle,
-                                                           &namestore_list_finished,
-                                                           handle);
+  handle->list_it =
+    GNUNET_NAMESTORE_zone_iteration_start (handle->ns_handle,
+                                           handle->zone_pkey,
+                                           &namestore_iteration_error,
+                                           handle,
+                                           &namestore_list_iteration,
+                                           handle,
+                                           &namestore_list_finished,
+                                           handle);
   if (NULL == handle->list_it)
   {
-    handle->emsg = GNUNET_strdup(GNUNET_REST_NAMESTORE_FAILED);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_FAILED);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
@@ -559,8 +556,8 @@ default_ego_get (void *cls,
  */
 void
 namestore_get (struct GNUNET_REST_RequestHandle *con_handle,
-                 const char* url,
-                 void *cls)
+               const char *url,
+               void *cls)
 {
   struct RequestHandle *handle = cls;
   struct EgoEntry *ego_entry;
@@ -569,44 +566,45 @@ namestore_get (struct GNUNET_REST_RequestHandle *con_handle,
   egoname = NULL;
   ego_entry = NULL;
 
-  //set zone to name if given
+  // set zone to name if given
   if (strlen (GNUNET_REST_API_NS_NAMESTORE) < strlen (handle->url))
   {
-    egoname = &handle->url[strlen (GNUNET_REST_API_NS_NAMESTORE)+1];
-    ego_entry = get_egoentry_namestore(handle, egoname);
+    egoname = &handle->url[strlen (GNUNET_REST_API_NS_NAMESTORE) + 1];
+    ego_entry = get_egoentry_namestore (handle, egoname);
 
     if (NULL == ego_entry)
     {
       handle->response_code = MHD_HTTP_NOT_FOUND;
-      handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_NOT_FOUND);
+      handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
       GNUNET_SCHEDULER_add_now (&do_error, handle);
       return;
     }
   }
-  if ( NULL != ego_entry )
+  if (NULL != ego_entry)
   {
-    handle->zone_pkey = GNUNET_IDENTITY_ego_get_private_key(ego_entry->ego);
+    handle->zone_pkey = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
   }
 
   if (NULL == handle->zone_pkey)
   {
     handle->op = GNUNET_IDENTITY_get (handle->identity_handle,
-                                      "namestore",
-                                      &default_ego_get,
-                                      handle);
+                                      "namestore",
+                                      &default_ego_get,
+                                      handle);
     return;
   }
-  handle->list_it = GNUNET_NAMESTORE_zone_iteration_start (handle->ns_handle,
-                                                           handle->zone_pkey,
-                                                           &namestore_iteration_error,
-                                                           handle,
-                                                           &namestore_list_iteration,
-                                                           handle,
-                                                           &namestore_list_finished,
-                                                           handle);
+  handle->list_it =
+    GNUNET_NAMESTORE_zone_iteration_start (handle->ns_handle,
+                                           handle->zone_pkey,
+                                           &namestore_iteration_error,
+                                           handle,
+                                           &namestore_list_iteration,
+                                           handle,
+                                           &namestore_list_finished,
+                                           handle);
   if (NULL == handle->list_it)
   {
-    handle->emsg = GNUNET_strdup(GNUNET_REST_NAMESTORE_FAILED);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_FAILED);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
@@ -624,31 +622,68 @@ namestore_get (struct GNUNET_REST_RequestHandle *con_handle,
  */
 static void
 default_ego_post (void *cls,
-                  struct GNUNET_IDENTITY_Ego *ego,
-                  void **ctx,
-                  const char *identifier)
+                  struct GNUNET_IDENTITY_Ego *ego,
+                  void **ctx,
+                  const char *identifier)
 {
   struct RequestHandle *handle = cls;
   handle->op = NULL;
 
   if (ego == NULL)
   {
-    handle->emsg = GNUNET_strdup(GNUNET_REST_NAMESTORE_NO_DEFAULT_ZONE);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_NO_DEFAULT_ZONE);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
   handle->zone_pkey = GNUNET_IDENTITY_ego_get_private_key (ego);
 
   handle->add_qe = GNUNET_NAMESTORE_records_store (handle->ns_handle,
-                                                   handle->zone_pkey,
-                                                   handle->record_name,
-                                                   1,
-                                                   handle->rd,
-                                                   &create_finished,
-                                                   handle);
+                                                   handle->zone_pkey,
+                                                   handle->record_name,
+                                                   1,
+                                                   handle->rd,
+                                                   &create_finished,
+                                                   handle);
+  if (NULL == handle->add_qe)
+  {
+    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_FAILED);
+    GNUNET_SCHEDULER_add_now (&do_error, handle);
+    return;
+  }
+}
+
+
+static void
+ns_lookup_error_cb (void *cls)
+{
+  struct RequestHandle *handle = cls;
+  handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_FAILED);
+  GNUNET_SCHEDULER_add_now (&do_error, handle);
+}
+
+
+static void
+ns_lookup_cb (void *cls,
+              const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+              const char *label,
+              unsigned int rd_count,
+              const struct GNUNET_GNSRECORD_Data *rd)
+{
+  struct RequestHandle *handle = cls;
+  struct GNUNET_GNSRECORD_Data rd_new[rd_count + 1];
+  for (int i = 0; i < rd_count; i++)
+    rd_new[i] = rd[i];
+  rd_new[rd_count] = *handle->rd;
+  handle->add_qe = GNUNET_NAMESTORE_records_store (handle->ns_handle,
+                                                   handle->zone_pkey,
+                                                   handle->record_name,
+                                                   rd_count + 1,
+                                                   rd_new,
+                                                   &create_finished,
+                                                   handle);
   if (NULL == handle->add_qe)
   {
-    handle->emsg = GNUNET_strdup(GNUNET_REST_NAMESTORE_FAILED);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_FAILED);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
@@ -664,8 +699,8 @@ default_ego_post (void *cls,
  */
 void
 namestore_add (struct GNUNET_REST_RequestHandle *con_handle,
-               const char* url,
-               void *cls)
+               const char *url,
+               void *cls)
 {
   struct RequestHandle *handle = cls;
   struct GNUNET_GNSRECORD_Data *gns_record;
@@ -676,50 +711,49 @@ namestore_add (struct GNUNET_REST_RequestHandle *con_handle,
   json_error_t err;
   char term_data[handle->rest_handle->data_size + 1];
 
-  struct GNUNET_JSON_Specification gnsspec[] = {
-    GNUNET_JSON_spec_gnsrecord_data(&gns_record),
-    GNUNET_JSON_spec_end ()
-  };
+  struct GNUNET_JSON_Specification gnsspec[] =
+    {GNUNET_JSON_spec_gnsrecord_data (&gns_record), GNUNET_JSON_spec_end ()};
 
   if (0 >= handle->rest_handle->data_size)
   {
-    handle->emsg = GNUNET_strdup(GNUNET_REST_NAMESTORE_NO_DATA);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_NO_DATA);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
   term_data[handle->rest_handle->data_size] = '\0';
-  GNUNET_memcpy(term_data, handle->rest_handle->data,
-                handle->rest_handle->data_size);
+  GNUNET_memcpy (term_data,
+                 handle->rest_handle->data,
+                 handle->rest_handle->data_size);
   data_js = json_loads (term_data, JSON_DECODE_ANY, &err);
   if (GNUNET_OK != GNUNET_JSON_parse (data_js, gnsspec, NULL, NULL))
   {
-    handle->emsg = GNUNET_strdup(GNUNET_REST_NAMESTORE_INVALID_DATA);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_INVALID_DATA);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
-    GNUNET_JSON_parse_free(gnsspec);
+    GNUNET_JSON_parse_free (gnsspec);
     json_decref (data_js);
     return;
   }
   handle->rd = gns_record;
 
-  name_json = json_object_get(data_js, "record_name");
-  if (!json_is_string(name_json))
+  name_json = json_object_get (data_js, "record_name");
+  if (! json_is_string (name_json))
   {
-    handle->emsg = GNUNET_strdup(GNUNET_REST_NAMESTORE_INVALID_DATA);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_INVALID_DATA);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     json_decref (data_js);
     return;
   }
-  handle->record_name = GNUNET_strdup(json_string_value(name_json));
-  if(NULL == handle->record_name)
+  handle->record_name = GNUNET_strdup (json_string_value (name_json));
+  if (NULL == handle->record_name)
   {
-    handle->emsg = GNUNET_strdup(GNUNET_REST_NAMESTORE_INVALID_DATA);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_INVALID_DATA);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     json_decref (data_js);
     return;
   }
-  if (0 >= strlen(handle->record_name))
+  if (0 >= strlen (handle->record_name))
   {
-    handle->emsg = GNUNET_strdup(GNUNET_REST_NAMESTORE_INVALID_DATA);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_INVALID_DATA);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     json_decref (data_js);
     return;
@@ -729,42 +763,42 @@ namestore_add (struct GNUNET_REST_RequestHandle *con_handle,
   egoname = NULL;
   ego_entry = NULL;
 
-  //set zone to name if given
+  // set zone to name if given
   if (strlen (GNUNET_REST_API_NS_NAMESTORE) < strlen (handle->url))
   {
-    egoname = &handle->url[strlen (GNUNET_REST_API_NS_NAMESTORE)+1];
-    ego_entry = get_egoentry_namestore(handle, egoname);
+    egoname = &handle->url[strlen (GNUNET_REST_API_NS_NAMESTORE) + 1];
+    ego_entry = get_egoentry_namestore (handle, egoname);
 
     if (NULL == ego_entry)
     {
       handle->response_code = MHD_HTTP_NOT_FOUND;
-      handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_NOT_FOUND);
+      handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
       GNUNET_SCHEDULER_add_now (&do_error, handle);
       return;
     }
   }
   if (NULL != ego_entry)
   {
-    handle->zone_pkey = GNUNET_IDENTITY_ego_get_private_key(ego_entry->ego);
+    handle->zone_pkey = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
   }
   if (NULL == handle->zone_pkey)
   {
     handle->op = GNUNET_IDENTITY_get (handle->identity_handle,
-                                      "namestore",
-                                      &default_ego_post,
-                                      handle);
+                                      "namestore",
+                                      &default_ego_post,
+                                      handle);
     return;
   }
-  handle->add_qe = GNUNET_NAMESTORE_records_store (handle->ns_handle,
-                                                   handle->zone_pkey,
-                                                   handle->record_name,
-                                                   1,
-                                                   handle->rd,
-                                                   &create_finished,
-                                                   handle);
+  handle->add_qe = GNUNET_NAMESTORE_records_lookup (handle->ns_handle,
+                                                    handle->zone_pkey,
+                                                    handle->record_name,
+                                                    &ns_lookup_error_cb,
+                                                    handle,
+                                                    &ns_lookup_cb,
+                                                    handle);
   if (NULL == handle->add_qe)
   {
-    handle->emsg = GNUNET_strdup(GNUNET_REST_NAMESTORE_FAILED);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_FAILED);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
@@ -782,16 +816,16 @@ namestore_add (struct GNUNET_REST_RequestHandle *con_handle,
  */
 static void
 default_ego_delete (void *cls,
-                    struct GNUNET_IDENTITY_Ego *ego,
-                    void **ctx,
-                    const char *identifier)
+                    struct GNUNET_IDENTITY_Ego *ego,
+                    void **ctx,
+                    const char *identifier)
 {
   struct RequestHandle *handle = cls;
   handle->op = NULL;
 
   if (ego == NULL)
   {
-    handle->emsg = GNUNET_strdup(GNUNET_REST_NAMESTORE_NO_DEFAULT_ZONE);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_NO_DEFAULT_ZONE);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
@@ -801,12 +835,12 @@ default_ego_delete (void *cls,
                                                    handle->zone_pkey,
                                                    handle->record_name,
                                                    0,
-                                                   NULL,
+                                                   NULL,
                                                    &del_finished,
                                                    handle);
   if (NULL == handle->add_qe)
   {
-    handle->emsg = GNUNET_strdup(GNUNET_REST_NAMESTORE_FAILED);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_FAILED);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
@@ -822,8 +856,8 @@ default_ego_delete (void *cls,
  */
 void
 namestore_delete (struct GNUNET_REST_RequestHandle *con_handle,
-                 const char* url,
-                 void *cls)
+                  const char *url,
+                  void *cls)
 {
   struct RequestHandle *handle = cls;
   struct GNUNET_HashCode key;
@@ -833,43 +867,42 @@ namestore_delete (struct GNUNET_REST_RequestHandle *con_handle,
   egoname = NULL;
   ego_entry = NULL;
 
-  //set zone to name if given
+  // set zone to name if given
   if (strlen (GNUNET_REST_API_NS_NAMESTORE) < strlen (handle->url))
   {
-    egoname = &handle->url[strlen (GNUNET_REST_API_NS_NAMESTORE)+1];
-    ego_entry = get_egoentry_namestore(handle, egoname);
+    egoname = &handle->url[strlen (GNUNET_REST_API_NS_NAMESTORE) + 1];
+    ego_entry = get_egoentry_namestore (handle, egoname);
 
     if (NULL == ego_entry)
     {
       handle->response_code = MHD_HTTP_NOT_FOUND;
-      handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_NOT_FOUND);
+      handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
       GNUNET_SCHEDULER_add_now (&do_error, handle);
       return;
     }
   }
-  if ( NULL != ego_entry )
+  if (NULL != ego_entry)
   {
-    handle->zone_pkey = GNUNET_IDENTITY_ego_get_private_key(ego_entry->ego);
+    handle->zone_pkey = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
   }
 
   GNUNET_CRYPTO_hash ("record_name", strlen ("record_name"), &key);
-  if ( GNUNET_NO
-      == GNUNET_CONTAINER_multihashmap_contains (con_handle->url_param_map,
-                                                 &key))
+  if (GNUNET_NO ==
+      GNUNET_CONTAINER_multihashmap_contains (con_handle->url_param_map, &key))
   {
-    handle->emsg = GNUNET_strdup(GNUNET_REST_NAMESTORE_INVALID_DATA);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_INVALID_DATA);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
-  handle->record_name = GNUNET_strdup(
-      GNUNET_CONTAINER_multihashmap_get (con_handle->url_param_map, &key));
+  handle->record_name = GNUNET_strdup (
+    GNUNET_CONTAINER_multihashmap_get (con_handle->url_param_map, &key));
 
   if (NULL == handle->zone_pkey)
   {
     handle->op = GNUNET_IDENTITY_get (handle->identity_handle,
-                                      "namestore",
-                                      &default_ego_delete,
-                                      handle);
+                                      "namestore",
+                                      &default_ego_delete,
+                                      handle);
     return;
   }
 
@@ -877,19 +910,18 @@ namestore_delete (struct GNUNET_REST_RequestHandle *con_handle,
                                                    handle->zone_pkey,
                                                    handle->record_name,
                                                    0,
-                                                   NULL,
+                                                   NULL,
                                                    &del_finished,
                                                    handle);
   if (NULL == handle->add_qe)
   {
-    handle->emsg = GNUNET_strdup(GNUNET_REST_NAMESTORE_FAILED);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_FAILED);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
 }
 
 
-
 /**
  * Respond to OPTIONS request
  *
@@ -899,17 +931,15 @@ namestore_delete (struct GNUNET_REST_RequestHandle *con_handle,
  */
 static void
 options_cont (struct GNUNET_REST_RequestHandle *con_handle,
-              const char* url,
+              const char *url,
               void *cls)
 {
   struct MHD_Response *resp;
   struct RequestHandle *handle = cls;
 
-  //independent of path return all options
+  // independent of path return all options
   resp = GNUNET_REST_create_response (NULL);
-  MHD_add_response_header (resp,
-                           "Access-Control-Allow-Methods",
-                           allow_methods);
+  MHD_add_response_header (resp, "Access-Control-Allow-Methods", allow_methods);
   handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
   GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
   return;
@@ -925,18 +955,15 @@ static void
 init_cont (struct RequestHandle *handle)
 {
   struct GNUNET_REST_RequestHandlerError err;
-  static const struct GNUNET_REST_RequestHandler handlers[] = {
-    {MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_NAMESTORE, &namestore_get},
-    {MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_NAMESTORE, &namestore_add},
-    {MHD_HTTP_METHOD_DELETE, GNUNET_REST_API_NS_NAMESTORE, &namestore_delete},
-    {MHD_HTTP_METHOD_OPTIONS, GNUNET_REST_API_NS_NAMESTORE, &options_cont},
-    GNUNET_REST_HANDLER_END
-  };
-
-  if (GNUNET_NO == GNUNET_REST_handle_request (handle->rest_handle,
-                                               handlers,
-                                               &err,
-                                               handle))
+  static const struct GNUNET_REST_RequestHandler handlers[] =
+    {{MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_NAMESTORE, &namestore_get},
+     {MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_NAMESTORE, &namestore_add},
+     {MHD_HTTP_METHOD_DELETE, GNUNET_REST_API_NS_NAMESTORE, &namestore_delete},
+     {MHD_HTTP_METHOD_OPTIONS, GNUNET_REST_API_NS_NAMESTORE, &options_cont},
+     GNUNET_REST_HANDLER_END};
+
+  if (GNUNET_NO ==
+      GNUNET_REST_handle_request (handle->rest_handle, handlers, &err, handle))
   {
     handle->response_code = err.error_code;
     GNUNET_SCHEDULER_add_now (&do_error, handle);
@@ -988,20 +1015,20 @@ id_connect_cb (void *cls,
   if ((NULL == ego) && (ID_REST_STATE_INIT == handle->state))
   {
     handle->state = ID_REST_STATE_POST_INIT;
-    init_cont(handle);
+    init_cont (handle);
     return;
   }
   if (ID_REST_STATE_INIT == handle->state)
   {
-    ego_entry = GNUNET_new(struct EgoEntry);
+    ego_entry = GNUNET_new (struct EgoEntry);
     GNUNET_IDENTITY_ego_get_public_key (ego, &pk);
     ego_entry->keystring = GNUNET_CRYPTO_ecdsa_public_key_to_string (&pk);
     ego_entry->ego = ego;
     GNUNET_asprintf (&ego_entry->identifier, "%s", name);
-    GNUNET_CONTAINER_DLL_insert_tail(handle->ego_head, handle->ego_tail,
-                                     ego_entry);
+    GNUNET_CONTAINER_DLL_insert_tail (handle->ego_head,
+                                      handle->ego_tail,
+                                      ego_entry);
   }
-
 }
 
 
@@ -1017,31 +1044,30 @@ id_connect_cb (void *cls,
  * @return GNUNET_OK if request accepted
  */
 static void
-rest_process_request(struct GNUNET_REST_RequestHandle *rest_handle,
-                              GNUNET_REST_ResultProcessor proc,
-                              void *proc_cls)
+rest_process_request (struct GNUNET_REST_RequestHandle *rest_handle,
+                      GNUNET_REST_ResultProcessor proc,
+                      void *proc_cls)
 {
   struct RequestHandle *handle = GNUNET_new (struct RequestHandle);
-  
+
   handle->response_code = 0;
   handle->timeout = GNUNET_TIME_UNIT_FOREVER_REL;
   handle->proc_cls = proc_cls;
   handle->proc = proc;
   handle->rest_handle = rest_handle;
   handle->zone_pkey = NULL;
-  
+
   handle->url = GNUNET_strdup (rest_handle->url);
-  if (handle->url[strlen (handle->url)-1] == '/')
-    handle->url[strlen (handle->url)-1] = '\0';
+  if (handle->url[strlen (handle->url) - 1] == '/')
+    handle->url[strlen (handle->url) - 1] = '\0';
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting...\n");
 
   handle->ns_handle = GNUNET_NAMESTORE_connect (cfg);
-  handle->identity_handle = GNUNET_IDENTITY_connect (cfg, &id_connect_cb, handle);
+  handle->identity_handle =
+    GNUNET_IDENTITY_connect (cfg, &id_connect_cb, handle);
   handle->timeout_task =
-    GNUNET_SCHEDULER_add_delayed (handle->timeout,
-                                  &do_error,
-                                  handle);
-  
+    GNUNET_SCHEDULER_add_delayed (handle->timeout, &do_error, handle);
+
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connected\n");
 }
 
@@ -1060,7 +1086,7 @@ libgnunet_plugin_rest_namestore_init (void *cls)
 
   cfg = cls;
   if (NULL != plugin.cfg)
-    return NULL;                /* can only initialize once! */
+    return NULL; /* can only initialize once! */
   memset (&plugin, 0, sizeof (struct Plugin));
   plugin.cfg = cfg;
   api = GNUNET_new (struct GNUNET_REST_Plugin);
@@ -1075,8 +1101,7 @@ libgnunet_plugin_rest_namestore_init (void *cls)
                    MHD_HTTP_METHOD_DELETE,
                    MHD_HTTP_METHOD_OPTIONS);
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              _("Namestore REST API initialized\n"));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _ ("Namestore REST API initialized\n"));
   return api;
 }
 
@@ -1096,8 +1121,7 @@ libgnunet_plugin_rest_namestore_done (void *cls)
 
   GNUNET_free_non_null (allow_methods);
   GNUNET_free (api);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Namestore REST plugin is finished\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Namestore REST plugin is finished\n");
   return NULL;
 }
 
diff --git a/src/transport/gnunet-service-tng.c b/src/transport/gnunet-service-tng.c
index 2f7129478..d3c3defec 100644
--- a/src/transport/gnunet-service-tng.c
+++ b/src/transport/gnunet-service-tng.c
@@ -24,15 +24,7 @@
  *
  * TODO:
  * Implement next:
- * - FIXME: handle_client_send(): pick DVH path, and box
- *   message accordingly (if applicable, see FIXMEs)
- * - proper use/initialization of timestamps in messages exchanged
- *   during DV learning
- * - persistence of monotonic time from DVInit to prevent
- *   replay attacks using DVInit messages
  * - dv hop-by-hop signature verification (at least at initiator)
- * - persistence of monotonic time obtained from other peers
- *   in PEERSTORE (by message type) -- done for backchannel, needed elsewhere?
  * - change transport-core API to provide proper flow control in both
  *   directions, allow multiple messages per peer simultaneously (tag
  *   confirmations with unique message ID), and replace quota-out with
@@ -720,6 +712,20 @@ struct TransportDVLearnMessage
   struct GNUNET_TIME_RelativeNBO non_network_delay;
 
   /**
+   * Time at the initiator when generating the signature.
+   *
+   * Note that the receiver MUST IGNORE the absolute time, and only interpret
+   * the value as a mononic time and reject "older" values than the last one
+   * observed.  This is necessary as we do not want to require synchronized
+   * clocks and may not have a bidirectional communication channel.
+   *
+   * Even with this, there is no real guarantee against replay achieved here,
+   * unless the latest timestamp is persisted.  Persistence should be
+   * provided via PEERSTORE if possible.
+   */
+  struct GNUNET_TIME_AbsoluteNBO monotonic_time;
+
+  /**
    * Signature of this hop over the path, of purpose
    * #GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR
    */
@@ -923,6 +929,41 @@ enum ClientType
 
 
 /**
+ * Which transmission options are allowable for transmission?
+ * Interpreted bit-wise!
+ */
+enum RouteMessageOptions
+{
+  /**
+   * Only confirmed, non-DV direct neighbours.
+   */
+  RMO_NONE = 0,
+
+  /**
+   * We are allowed to use DV routing for this @a hdr
+   */
+  RMO_DV_ALLOWED = 1,
+
+  /**
+   * We are allowed to use unconfirmed queues or DV routes for this message
+   */
+  RMO_UNCONFIRMED_ALLOWED = 2,
+
+  /**
+   * Reliable and unreliable, DV and non-DV are all acceptable.
+   */
+  RMO_ANYTHING_GOES = (RMO_DV_ALLOWED | RMO_UNCONFIRMED_ALLOWED),
+
+  /**
+   * If we have multiple choices, it is OK to send this message
+   * over multiple channels at the same time to improve loss tolerance.
+   * (We do at most 2 transmissions.)
+   */
+  RMO_REDUNDANT = 4
+};
+
+
+/**
  * When did we launch this DV learning activity?
  */
 struct LearnLaunchEntry
@@ -1629,6 +1670,18 @@ struct Neighbour
   struct GNUNET_SCHEDULER_Task *timeout_task;
 
   /**
+   * Handle for an operation to fetch @e last_dv_learn_monotime information from
+   * the PEERSTORE, or NULL.
+   */
+  struct GNUNET_PEERSTORE_IterateContext *get;
+
+  /**
+   * Handle to a PEERSTORE store operation to store this @e pid's @e
+   * @e last_dv_learn_monotime.  NULL if no PEERSTORE operation is pending.
+   */
+  struct GNUNET_PEERSTORE_StoreContext *sc;
+
+  /**
    * Quota at which CORE is allowed to transmit to this peer
    * (note that the value CORE should actually be told is this
    *  value plus the respective value in `struct DistanceVector`).
@@ -1643,6 +1696,12 @@ struct Neighbour
   struct GNUNET_BANDWIDTH_Value32NBO quota_out;
 
   /**
+   * Latest DVLearn monotonic time seen from this peer.  Initialized only
+   * if @e dl_monotime_available is #GNUNET_YES.
+   */
+  struct GNUNET_TIME_Absolute last_dv_learn_monotime;
+
+  /**
    * What is the earliest timeout of any message in @e pending_msg_tail?
    */
   struct GNUNET_TIME_Absolute earliest_timeout;
@@ -1652,6 +1711,12 @@ struct Neighbour
    * CORE?
    */
   int core_visible;
+
+  /**
+   * Do we have the lastest value for @e last_dv_learn_monotime from
+   * PEERSTORE yet, or are we still waiting for a reply of PEERSTORE?
+   */
+  int dv_monotime_available;
 };
 
 
@@ -2851,7 +2916,20 @@ free_neighbour (struct Neighbour *neighbour)
       free_dv_route (dv);
   }
   if (NULL != neighbour->reassembly_timeout_task)
+  {
     GNUNET_SCHEDULER_cancel (neighbour->reassembly_timeout_task);
+    neighbour->reassembly_timeout_task = NULL;
+  }
+  if (NULL != neighbour->get)
+  {
+    GNUNET_PEERSTORE_iterate_cancel (neighbour->get);
+    neighbour->get = NULL;
+  }
+  if (NULL != neighbour->sc)
+  {
+    GNUNET_PEERSTORE_store_cancel (neighbour->sc);
+    neighbour->sc = NULL;
+  }
   GNUNET_free (neighbour);
 }
 
@@ -3453,6 +3531,130 @@ check_queue_timeouts (void *cls)
 
 
 /**
+ * Create a DV Box message.
+ *
+ * @param total_hops how many hops did the message take so far
+ * @param num_hops length of the @a hops array
+ * @param origin origin of the message
+ * @param hops next peer(s) to the destination, including destination
+ * @param payload payload of the box
+ * @param payload_size number of bytes in @a payload
+ * @return boxed message (caller must #GNUNET_free() it).
+ */
+static struct TransportDVBoxMessage *
+create_dv_box (uint16_t total_hops,
+               const struct GNUNET_PeerIdentity *origin,
+               const struct GNUNET_PeerIdentity *target,
+               uint16_t num_hops,
+               const struct GNUNET_PeerIdentity *hops,
+               const void *payload,
+               uint16_t payload_size)
+{
+  struct TransportDVBoxMessage *dvb;
+  struct GNUNET_PeerIdentity *dhops;
+
+  GNUNET_assert (UINT16_MAX <
+                 sizeof (struct TransportDVBoxMessage) +
+                   sizeof (struct GNUNET_PeerIdentity) * (num_hops + 1) +
+                   payload_size);
+  dvb = GNUNET_malloc (sizeof (struct TransportDVBoxMessage) +
+                       sizeof (struct GNUNET_PeerIdentity) * (num_hops + 1) +
+                       payload_size);
+  dvb->header.size =
+    htons (sizeof (struct TransportDVBoxMessage) +
+           sizeof (struct GNUNET_PeerIdentity) * (num_hops + 1) + payload_size);
+  dvb->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DV_BOX);
+  dvb->total_hops = htons (total_hops);
+  dvb->num_hops = htons (num_hops + 1);
+  dvb->origin = *origin;
+  dhops = (struct GNUNET_PeerIdentity *) &dvb[1];
+  memcpy (dhops, hops, num_hops * sizeof (struct GNUNET_PeerIdentity));
+  dhops[num_hops] = *target;
+  memcpy (&dhops[num_hops + 1], payload, payload_size);
+  return dvb;
+}
+
+
+/**
+ * Pick @a hops_array_length random DV paths satisfying @a options
+ *
+ * @param dv data structure to pick paths from
+ * @param options constraints to satisfy
+ * @param hops_array[out] set to the result
+ * @param hops_array_length length of the @a hops_array
+ * @return number of entries set in @a hops_array
+ */
+static unsigned int
+pick_random_dv_hops (const struct DistanceVector *dv,
+                     enum RouteMessageOptions options,
+                     struct DistanceVectorHop **hops_array,
+                     unsigned int hops_array_length)
+{
+  uint64_t choices[hops_array_length];
+  uint64_t num_dv;
+  unsigned int dv_count;
+
+  /* Pick random vectors, but weighted by distance, giving more weight
+     to shorter vectors */
+  num_dv = 0;
+  dv_count = 0;
+  for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
+       pos = pos->next_dv)
+  {
+    if ((0 == (options & RMO_UNCONFIRMED_ALLOWED)) &&
+        (GNUNET_TIME_absolute_get_remaining (pos->path_valid_until)
+           .rel_value_us == 0))
+      continue; /* pos unconfirmed and confirmed required */
+    num_dv += MAX_DV_HOPS_ALLOWED - pos->distance;
+    dv_count++;
+  }
+  if (0 == dv_count)
+    return 0;
+  if (dv_count <= hops_array_length)
+  {
+    dv_count = 0;
+    for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
+         pos = pos->next_dv)
+      hops_array[dv_count++] = pos;
+    return dv_count;
+  }
+  for (unsigned int i = 0; i < hops_array_length; i++)
+  {
+    int ok = GNUNET_NO;
+    while (GNUNET_NO == ok)
+    {
+      choices[i] =
+        GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, num_dv);
+      ok = GNUNET_YES;
+      for (unsigned int j = 0; j < i; j++)
+        if (choices[i] == choices[j])
+        {
+          ok = GNUNET_NO;
+          break;
+        }
+    }
+  }
+  dv_count = 0;
+  num_dv = 0;
+  for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
+       pos = pos->next_dv)
+  {
+    uint32_t delta = MAX_DV_HOPS_ALLOWED - pos->distance;
+
+    if ((0 == (options & RMO_UNCONFIRMED_ALLOWED)) &&
+        (GNUNET_TIME_absolute_get_remaining (pos->path_valid_until)
+           .rel_value_us == 0))
+      continue; /* pos unconfirmed and confirmed required */
+    for (unsigned int i = 0; i < hops_array_length; i++)
+      if ((num_dv <= choices[i]) && (num_dv + delta > choices[i]))
+        hops_array[dv_count++] = pos;
+    num_dv += delta;
+  }
+  return dv_count;
+}
+
+
+/**
  * Client asked for transmission to a peer.  Process the request.
  *
  * @param cls the client
@@ -3471,6 +3673,7 @@ handle_client_send (void *cls, const struct OutboundMessage *obm)
   int was_empty;
   const void *payload;
   size_t payload_size;
+  struct TransportDVBoxMessage *dvb;
 
   GNUNET_assert (CT_CORE == tc->type);
   obmm = (const struct GNUNET_MessageHeader *) &obm[1];
@@ -3504,18 +3707,26 @@ handle_client_send (void *cls, const struct OutboundMessage *obm)
   }
   if (NULL == target)
   {
-    // FIXME: overall, similar logic exists already for DV boxing,
-    // re-use!
+    unsigned int res;
+    struct DistanceVectorHop *dvh;
 
-    // FIXME: dvh = pick_dv_hop (dv);
+    res = pick_random_dv_hops (dv, RMO_NONE, &dvh, 1);
+    GNUNET_assert (1 == res);
     target = dvh->next_hop;
-    // FIXME: dv box message here!
-    // FIXME: set payload & payload_size to box (and free box below!)
+    dvb = create_dv_box (0,
+                         &GST_my_identity,
+                         &obm->peer,
+                         dvh->distance,
+                         dvh->path,
+                         &obm[1],
+                         bytes_msg);
+    payload = dvb;
+    payload_size = ntohs (dvb->header.size);
   }
   else
   {
     dvh = NULL;
-    // box = NULL;
+    dvb = NULL;
     payload = &obm[1];
     payload_size = bytes_msg;
   }
@@ -3527,8 +3738,9 @@ handle_client_send (void *cls, const struct OutboundMessage *obm)
   pm->bytes_msg = payload_size;
   pm->timeout =
     GNUNET_TIME_relative_to_absolute (GNUNET_TIME_relative_ntoh (obm->timeout));
-  memcpy (&pm[1], &obm[1], payload_size);
-  // FIXME: GNUNET_free_non_null (box);
+  memcpy (&pm[1], payload, payload_size);
+  GNUNET_free_non_null (dvb);
+  dvb = NULL;
   pm->dvh = dvh;
   if (NULL != dvh)
   {
@@ -3810,41 +4022,6 @@ queue_send_msg (struct Queue *queue,
 
 
 /**
- * Which transmission options are allowable for transmission?
- * Interpreted bit-wise!
- */
-enum RouteMessageOptions
-{
-  /**
-   * Only confirmed, non-DV direct neighbours.
-   */
-  RMO_NONE = 0,
-
-  /**
-   * We are allowed to use DV routing for this @a hdr
-   */
-  RMO_DV_ALLOWED = 1,
-
-  /**
-   * We are allowed to use unconfirmed queues or DV routes for this message
-   */
-  RMO_UNCONFIRMED_ALLOWED = 2,
-
-  /**
-   * Reliable and unreliable, DV and non-DV are all acceptable.
-   */
-  RMO_ANYTHING_GOES = (RMO_DV_ALLOWED | RMO_UNCONFIRMED_ALLOWED),
-
-  /**
-   * If we have multiple choices, it is OK to send this message
-   * over multiple channels at the same time to improve loss tolerance.
-   * (We do at most 2 transmissions.)
-   */
-  RMO_REDUNDANT = 4
-};
-
-
-/**
  * Pick a queue of @a n under constraints @a options and schedule
  * transmission of @a hdr.
  *
@@ -3927,22 +4104,17 @@ forward_via_dvh (const struct DistanceVectorHop *dvh,
                  const struct GNUNET_MessageHeader *payload,
                  enum RouteMessageOptions options)
 {
-  uint16_t mlen = ntohs (payload->size);
-  char boxram[sizeof (struct TransportDVBoxMessage) +
-              (dvh->distance + 1) * sizeof (struct GNUNET_PeerIdentity) +
-              mlen] GNUNET_ALIGN;
-  struct TransportDVBoxMessage *box = (struct TransportDVBoxMessage *) boxram;
-  struct GNUNET_PeerIdentity *path = (struct GNUNET_PeerIdentity *) &box[1];
+  struct TransportDVBoxMessage *dvb;
 
-  box->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DV_BOX);
-  box->header.size = htons (sizeof (boxram));
-  box->total_hops = htons (0);
-  box->num_hops = htons (dvh->distance + 1);
-  box->origin = GST_my_identity;
-  memcpy (path, dvh->path, dvh->distance * sizeof (struct GNUNET_PeerIdentity));
-  path[dvh->distance] = dvh->dv->target;
-  memcpy (&path[dvh->distance + 1], payload, mlen);
-  route_via_neighbour (dvh->next_hop, &box->header, options);
+  dvb = create_dv_box (0,
+                       &GST_my_identity,
+                       &dvh->dv->target,
+                       dvh->distance,
+                       dvh->path,
+                       payload,
+                       ntohs (payload->size));
+  route_via_neighbour (dvh->next_hop, &dvb->header, options);
+  GNUNET_free (dvb);
 }
 
 
@@ -3960,52 +4132,15 @@ route_via_dv (const struct DistanceVector *dv,
               const struct GNUNET_MessageHeader *hdr,
               enum RouteMessageOptions options)
 {
-  struct DistanceVectorHop *h1;
-  struct DistanceVectorHop *h2;
-  uint64_t num_dv;
-  uint64_t choice1;
-  uint64_t choice2;
-
-  /* Pick random vectors, but weighted by distance, giving more weight
-     to shorter vectors */
-  num_dv = 0;
-  for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
-       pos = pos->next_dv)
-  {
-    if ((0 == (options & RMO_UNCONFIRMED_ALLOWED)) &&
-        (GNUNET_TIME_absolute_get_remaining (pos->path_valid_until)
-           .rel_value_us == 0))
-      continue; /* pos unconfirmed and confirmed required */
-    num_dv += MAX_DV_HOPS_ALLOWED - pos->distance;
-  }
-  if (0 == num_dv)
-  {
-    GNUNET_break (0);
-    return;
-  }
-  choice1 = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, num_dv);
-  choice2 = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, num_dv);
-  num_dv = 0;
-  h1 = NULL;
-  h2 = NULL;
-  for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
-       pos = pos->next_dv)
-  {
-    uint32_t delta = MAX_DV_HOPS_ALLOWED - pos->distance;
+  struct DistanceVectorHop *hops[2];
+  unsigned int res;
 
-    if ((0 == (options & RMO_UNCONFIRMED_ALLOWED)) &&
-        (GNUNET_TIME_absolute_get_remaining (pos->path_valid_until)
-           .rel_value_us == 0))
-      continue; /* pos unconfirmed and confirmed required */
-    if ((num_dv <= choice1) && (num_dv + delta > choice1))
-      h1 = pos;
-    if ((num_dv <= choice2) && (num_dv + delta > choice2))
-      h2 = pos;
-    num_dv += delta;
-  }
-  forward_via_dvh (h1, hdr, options & (~RMO_REDUNDANT));
-  if (0 == (options & RMO_REDUNDANT))
-    forward_via_dvh (h2, hdr, options & (~RMO_REDUNDANT));
+  res = pick_random_dv_hops (dv,
+                             options,
+                             hops,
+                             (0 == (options & RMO_REDUNDANT)) ? 1 : 2);
+  for (unsigned int i = 0; i < res; i++)
+    forward_via_dvh (hops[i], hdr, options & (~RMO_REDUNDANT));
 }
 
 
@@ -5912,6 +6047,7 @@ forward_dv_learn (const struct GNUNET_PeerIdentity *next_hop,
 /**
  * Check signature of type #GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR
  *
+ * @param sender_monotonic_time monotonic time of the initiator
  * @param init the signer
  * @param challenge the challenge that was signed
  * @param init_sig signature presumably by @a init
@@ -5919,6 +6055,7 @@ forward_dv_learn (const struct GNUNET_PeerIdentity *next_hop,
  */
 static int
 validate_dv_initiator_signature (
+  struct GNUNET_TIME_AbsoluteNBO sender_monotonic_time,
   const struct GNUNET_PeerIdentity *init,
   const struct ChallengeNonceP *challenge,
   const struct GNUNET_CRYPTO_EddsaSignature *init_sig)
@@ -5926,6 +6063,7 @@ validate_dv_initiator_signature (
   struct DvInitPS ip = {.purpose.purpose = htonl (
                           GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR),
                         .purpose.size = htonl (sizeof (ip)),
+                        .monotonic_time = sender_monotonic_time,
                         .challenge = *challenge};
 
   if (
@@ -6132,6 +6270,24 @@ calculate_fork_degree (unsigned int hops_taken,
 
 
 /**
+ * Function called when peerstore is done storing a DV monotonic time.
+ *
+ * @param cls a `struct Neighbour`
+ * @param success #GNUNET_YES if peerstore was successful
+ */
+static void
+neighbour_store_dvmono_cb (void *cls, int success)
+{
+  struct Neighbour *n = cls;
+
+  n->sc = NULL;
+  if (GNUNET_YES != success)
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to store other peer's monotonic time in peerstore!\n");
+}
+
+
+/**
  * Communicator gave us a DV learn message.  Process the request.
  *
  * @param cls a `struct CommunicatorMessageContext` (must call
@@ -6150,6 +6306,7 @@ handle_dv_learn (void *cls, const struct TransportDVLearnMessage *dvl)
   int do_fwd;
   int did_initiator;
   struct GNUNET_TIME_Absolute in_time;
+  struct Neighbour *n;
 
   nhops = ntohs (dvl->bidirectional); /* 0 = sender is initiator */
   bi_history = ntohs (dvl->bidirectional);
@@ -6184,15 +6341,44 @@ handle_dv_learn (void *cls, const struct TransportDVLearnMessage *dvl)
   /* continue communicator here, everything else can happen asynchronous! */
   finish_cmc_handling (cmc);
 
-  /* OPTIMIZE-FIXME: Technically, we only need to bother checking
-     the initiator signature if we send the message back to the initiator...
-   */
-  if (GNUNET_OK != validate_dv_initiator_signature (&dvl->initiator,
-                                                    &dvl->challenge,
-                                                    &dvl->init_sig))
+  n = lookup_neighbour (&dvl->initiator);
+  if (NULL != n)
   {
-    GNUNET_break_op (0);
-    return;
+    if ((n->dv_monotime_available == GNUNET_YES) &&
+        (GNUNET_TIME_absolute_ntoh (dvl->monotonic_time).abs_value_us <
+         n->last_dv_learn_monotime.abs_value_us))
+    {
+      GNUNET_STATISTICS_update (GST_stats,
+                                "# DV learn discarded due to time travel",
+                                1,
+                                GNUNET_NO);
+      return;
+    }
+    if (GNUNET_OK != validate_dv_initiator_signature (dvl->monotonic_time,
+                                                      &dvl->initiator,
+                                                      &dvl->challenge,
+                                                      &dvl->init_sig))
+    {
+      GNUNET_break_op (0);
+      return;
+    }
+    n->last_dv_learn_monotime = GNUNET_TIME_absolute_ntoh (dvl->monotonic_time);
+    if (GNUNET_YES == n->dv_monotime_available)
+    {
+      if (NULL != n->sc)
+        GNUNET_PEERSTORE_store_cancel (n->sc);
+      n->sc =
+        GNUNET_PEERSTORE_store (peerstore,
+                                "transport",
+                                &dvl->initiator,
+                                GNUNET_PEERSTORE_TRANSPORT_DVLEARN_MONOTIME,
+                                &dvl->monotonic_time,
+                                sizeof (dvl->monotonic_time),
+                                GNUNET_TIME_UNIT_FOREVER_ABS,
+                                GNUNET_PEERSTORE_STOREOPTION_REPLACE,
+                                &neighbour_store_dvmono_cb,
+                                n);
+    }
   }
   // FIXME: asynchronously (!) verify hop-by-hop signatures!
   // => if signature verification load too high, implement random drop
@@ -6418,25 +6604,16 @@ forward_dv_box (struct Neighbour *next_hop,
                 uint16_t payload_size)
 {
   struct TransportDVBoxMessage *dvb;
-  struct GNUNET_PeerIdentity *dhops;
 
-  GNUNET_assert (UINT16_MAX < sizeof (struct TransportDVBoxMessage) +
-                                sizeof (struct GNUNET_PeerIdentity) * num_hops +
-                                payload_size);
-  dvb = GNUNET_malloc (sizeof (struct TransportDVBoxMessage) +
-                       sizeof (struct GNUNET_PeerIdentity) * num_hops +
+  dvb = create_dv_box (total_hops,
+                       origin,
+                       &hops[num_hops - 1] /* == target */,
+                       num_hops - 1 /* do not count target twice */,
+                       hops,
+                       payload,
                        payload_size);
-  dvb->header.size =
-    htons (sizeof (struct TransportDVBoxMessage) +
-           sizeof (struct GNUNET_PeerIdentity) * num_hops + payload_size);
-  dvb->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DV_BOX);
-  dvb->total_hops = htons (total_hops);
-  dvb->num_hops = htons (num_hops);
-  dvb->origin = *origin;
-  dhops = (struct GNUNET_PeerIdentity *) &dvb[1];
-  memcpy (dhops, hops, num_hops * sizeof (struct GNUNET_PeerIdentity));
-  memcpy (&dhops[num_hops], payload, payload_size);
   route_message (&next_hop->pid, &dvb->header, RMO_NONE);
+  GNUNET_free (dvb);
 }
 
 
@@ -7974,10 +8151,13 @@ start_dv_learn (void *cls)
   dvl.num_hops = htons (0);
   dvl.bidirectional = htons (0);
   dvl.non_network_delay = GNUNET_TIME_relative_hton (GNUNET_TIME_UNIT_ZERO);
+  dvl.monotonic_time =
+    GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get_monotonic (GST_cfg));
   {
     struct DvInitPS dvip = {.purpose.purpose = htonl (
                               GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR),
                             .purpose.size = htonl (sizeof (dvip)),
+                            .monotonic_time = dvl.monotonic_time,
                             .challenge = lle->challenge};
 
     GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_eddsa_sign (GST_my_private_key,
@@ -8039,6 +8219,44 @@ check_validation_request_pending (void *cls,
 
 
 /**
+ * Function called with the monotonic time of a DV initiator
+ * by PEERSTORE. Updates the time.
+ *
+ * @param cls a `struct Neighbour`
+ * @param record the information found, NULL for the last call
+ * @param emsg error message
+ */
+static void
+neighbour_dv_monotime_cb (void *cls,
+                          const struct GNUNET_PEERSTORE_Record *record,
+                          const char *emsg)
+{
+  struct Neighbour *n = cls;
+  struct GNUNET_TIME_AbsoluteNBO *mtbe;
+  struct GNUNET_TIME_Absolute mt;
+
+  (void) emsg;
+  if (NULL == record)
+  {
+    /* we're done with #neighbour_dv_monotime_cb() invocations,
+       continue normal processing */
+    n->get = NULL;
+    n->dv_monotime_available = GNUNET_YES;
+    return;
+  }
+  if (sizeof (*mtbe) != record->value_size)
+  {
+    GNUNET_break (0);
+    return;
+  }
+  mtbe = record->value;
+  n->last_dv_learn_monotime =
+    GNUNET_TIME_absolute_max (n->last_dv_learn_monotime,
+                              GNUNET_TIME_absolute_ntoh (*mtbe));
+}
+
+
+/**
  * New queue became available.  Process the request.
  *
  * @param cls the client
@@ -8074,6 +8292,13 @@ handle_add_queue_message (void *cls,
                      &neighbour->pid,
                      neighbour,
                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+    neighbour->get =
+      GNUNET_PEERSTORE_iterate (peerstore,
+                                "transport",
+                                &neighbour->pid,
+                                GNUNET_PEERSTORE_TRANSPORT_DVLEARN_MONOTIME,
+                                &neighbour_dv_monotime_cb,
+                                neighbour);
   }
   addr_len = ntohs (aqm->header.size) - sizeof (*aqm);
   addr = (const char *) &aqm[1];