printing validation information with cli

2 files changed, 268 insertions, 86 deletions

diff --git a/src/transport/gnunet-transport.c b/src/transport/gnunet-transport.c
index c8408b757..8311c1d72 100644
--- a/src/transport/gnunet-transport.c
+++ b/src/transport/gnunet-transport.c
@@ -316,13 +316,13 @@ shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   }
 }
 
-static struct ResolutionContext *rc_head;
-static struct ResolutionContext *rc_tail;
+static struct PeerResolutionContext *rc_head;
+static struct PeerResolutionContext *rc_tail;
 
-struct ResolutionContext
+struct PeerResolutionContext
 {
-  struct ResolutionContext *next;
-  struct ResolutionContext *prev;
+  struct PeerResolutionContext *next;
+  struct PeerResolutionContext *prev;
   struct GNUNET_PeerIdentity id;
   struct GNUNET_HELLO_Address *addrcp;
   struct GNUNET_TRANSPORT_AddressToStringContext *asc;
@@ -332,11 +332,32 @@ struct ResolutionContext
   int printed;
 };
 
+static struct ValidationResolutionContext *vc_head;
+static struct ValidationResolutionContext *vc_tail;
+
+struct ValidationResolutionContext
+{
+  struct ValidationResolutionContext *next;
+  struct ValidationResolutionContext *prev;
+
+  struct GNUNET_PeerIdentity id;
+  struct GNUNET_HELLO_Address *addrcp;
+  struct GNUNET_TIME_Absolute last_validation;
+  struct GNUNET_TIME_Absolute valid_until;
+  struct GNUNET_TIME_Absolute next_validation;
+  enum GNUNET_TRANSPORT_ValidationState state;
+
+  struct GNUNET_TRANSPORT_AddressToStringContext *asc;
+
+  char *transport;
+  int printed;
+};
+
 static void
 operation_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  struct ResolutionContext *cur;
-  struct ResolutionContext *next;
+  struct PeerResolutionContext *cur;
+  struct PeerResolutionContext *next;
   op_timeout = GNUNET_SCHEDULER_NO_TASK;
   if ((try_connect) || (benchmark_send) || (benchmark_receive))
   {
@@ -442,6 +463,126 @@ fail_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   display_test_result (tstc, GNUNET_NO);
 }
 
+
+static void
+resolve_validation_address (const struct GNUNET_PeerIdentity *id,
+    const struct GNUNET_HELLO_Address *address, int numeric,
+    struct GNUNET_TIME_Absolute last_validation,
+    struct GNUNET_TIME_Absolute valid_until,
+    struct GNUNET_TIME_Absolute next_validation,
+    enum GNUNET_TRANSPORT_ValidationState state);
+
+static void
+process_validation_string (void *cls, const char *address)
+{
+  struct ValidationResolutionContext *vc = cls;
+  char *s_valid;
+  char *s_last;
+  char *s_next;
+
+  if (address != NULL )
+  {
+    if (GNUNET_TIME_UNIT_ZERO_ABS.abs_value_us == vc->valid_until.abs_value_us)
+      s_valid = GNUNET_strdup("never");
+    else
+      s_valid = GNUNET_strdup(GNUNET_STRINGS_absolute_time_to_string (vc->valid_until));
+
+    if (GNUNET_TIME_UNIT_ZERO_ABS.abs_value_us == vc->last_validation.abs_value_us)
+      s_last = GNUNET_strdup("never");
+    else
+      s_last = GNUNET_strdup(GNUNET_STRINGS_absolute_time_to_string (vc->last_validation));
+
+    if (GNUNET_TIME_UNIT_ZERO_ABS.abs_value_us == vc->next_validation.abs_value_us)
+      s_next = GNUNET_strdup("never");
+    else
+      s_next = GNUNET_strdup(GNUNET_STRINGS_absolute_time_to_string (vc->next_validation));
+
+    FPRINTF (stdout,
+        _("Peer `%s' %s `%s'\n\t%s%s\n\t%s%s\n\t%s%s\n"),
+        GNUNET_i2s (&vc->id), address, GNUNET_TRANSPORT_vs2s (vc->state),
+        "Valid until    : ", s_valid,
+        "Last validation: ",s_last,
+        "Next validation: ", s_next);
+    GNUNET_free (s_valid);
+    GNUNET_free (s_last);
+    GNUNET_free (s_next);
+    vc->printed = GNUNET_YES;
+  }
+  else
+  {
+    /* done */
+    GNUNET_assert(address_resolutions > 0);
+    address_resolutions--;
+    if (GNUNET_NO == vc->printed)
+    {
+      if (numeric == GNUNET_NO)
+      {
+        /* Failed to resolve address, try numeric lookup */
+        resolve_validation_address (&vc->id, vc->addrcp, GNUNET_NO,
+           vc->last_validation, vc->valid_until, vc->next_validation,
+           vc->state);
+      }
+      else
+      {
+        FPRINTF (stdout, _("Peer `%s' %s `%s' \n"),
+            GNUNET_i2s (&vc->id), "<unable to resolve address>",
+            GNUNET_TRANSPORT_vs2s (vc->state));
+      }
+    }
+    GNUNET_free (vc->transport);
+    GNUNET_free (vc->addrcp);
+    GNUNET_CONTAINER_DLL_remove(vc_head, vc_tail, vc);
+    GNUNET_free(vc);
+    if ((0 == address_resolutions) && (iterate_validation))
+    {
+      if (GNUNET_SCHEDULER_NO_TASK != end)
+      {
+        GNUNET_SCHEDULER_cancel (end);
+        end = GNUNET_SCHEDULER_NO_TASK;
+      }
+      if (GNUNET_SCHEDULER_NO_TASK != op_timeout)
+      {
+        GNUNET_SCHEDULER_cancel (op_timeout);
+        op_timeout = GNUNET_SCHEDULER_NO_TASK;
+      }
+      ret = 0;
+      end = GNUNET_SCHEDULER_add_now (&shutdown_task, NULL );
+    }
+  }
+}
+
+
+
+static void
+resolve_validation_address (const struct GNUNET_PeerIdentity *id,
+    const struct GNUNET_HELLO_Address *address, int numeric,
+    struct GNUNET_TIME_Absolute last_validation,
+    struct GNUNET_TIME_Absolute valid_until,
+    struct GNUNET_TIME_Absolute next_validation,
+    enum GNUNET_TRANSPORT_ValidationState state)
+{
+  struct ValidationResolutionContext *vc;
+
+  vc = GNUNET_new (struct ValidationResolutionContext);
+  GNUNET_assert(NULL != vc);
+  GNUNET_CONTAINER_DLL_insert(vc_head, vc_tail, vc);
+  address_resolutions++;
+
+  vc->id = (*id);
+  vc->transport = GNUNET_strdup(address->transport_name);
+  vc->addrcp = GNUNET_HELLO_address_copy (address);
+  vc->printed = GNUNET_NO;
+  vc->state = state;
+  vc->last_validation = last_validation;
+  vc->valid_until = valid_until;
+  vc->next_validation = next_validation;
+
+  /* Resolve address to string */
+  vc->asc = GNUNET_TRANSPORT_address_to_string (cfg, address, numeric,
+      RESOLUTION_TIMEOUT, &process_validation_string, vc);
+}
+
+
 void process_validation_cb (void *cls,
     const struct GNUNET_PeerIdentity *peer,
     const struct GNUNET_HELLO_Address *address,
@@ -450,7 +591,27 @@ void process_validation_cb (void *cls,
     struct GNUNET_TIME_Absolute next_validation,
     enum GNUNET_TRANSPORT_ValidationState state)
 {
-  GNUNET_break (0);
+  if ((NULL == peer) && (NULL == address))
+  {
+    /* done */
+    vic = NULL;
+    if (GNUNET_SCHEDULER_NO_TASK != end)
+      GNUNET_SCHEDULER_cancel (end);
+    end = GNUNET_SCHEDULER_add_now (&shutdown_task, NULL );
+    return;
+  }
+  if ((NULL == peer) || (NULL == address))
+  {
+    /* invalid response */
+    vic = NULL;
+    if (GNUNET_SCHEDULER_NO_TASK != end)
+      GNUNET_SCHEDULER_cancel (end);
+    end = GNUNET_SCHEDULER_add_now (&shutdown_task, NULL );
+    return;
+  }
+  resolve_validation_address (peer, address,
+     numeric, last_validation,
+     valid_until, next_validation, state);
 }
 
 /**
@@ -701,7 +862,7 @@ notify_receive (void *cls, const struct GNUNET_PeerIdentity *peer,
 }
 
 static void
-resolve_address (const struct GNUNET_PeerIdentity *id,
+resolve_peer_address (const struct GNUNET_PeerIdentity *id,
     const struct GNUNET_HELLO_Address *address, int numeric,
     enum GNUNET_TRANSPORT_PeerState state,
     struct GNUNET_TIME_Absolute state_timeout);
@@ -729,9 +890,9 @@ print_info (const struct GNUNET_PeerIdentity *id, const char *transport,
 }
 
 static void
-process_string (void *cls, const char *address)
+process_peer_string (void *cls, const char *address)
 {
-  struct ResolutionContext *rc = cls;
+  struct PeerResolutionContext *rc = cls;
 
   if (address != NULL )
   {
@@ -748,7 +909,7 @@ process_string (void *cls, const char *address)
       if (numeric == GNUNET_NO)
       {
         /* Failed to resolve address, try numeric lookup */
-        resolve_address (&rc->id, rc->addrcp, GNUNET_YES,
+        resolve_peer_address (&rc->id, rc->addrcp, GNUNET_YES,
             rc->state, rc->state_timeout);
       }
       else
@@ -780,14 +941,14 @@ process_string (void *cls, const char *address)
 }
 
 static void
-resolve_address (const struct GNUNET_PeerIdentity *id,
+resolve_peer_address (const struct GNUNET_PeerIdentity *id,
     const struct GNUNET_HELLO_Address *address, int numeric,
     enum GNUNET_TRANSPORT_PeerState state,
     struct GNUNET_TIME_Absolute state_timeout)
 {
-  struct ResolutionContext *rc;
+  struct PeerResolutionContext *rc;
 
-  rc = GNUNET_new (struct ResolutionContext);
+  rc = GNUNET_new (struct PeerResolutionContext);
   GNUNET_assert(NULL != rc);
   GNUNET_CONTAINER_DLL_insert(rc_head, rc_tail, rc);
   address_resolutions++;
@@ -800,7 +961,7 @@ resolve_address (const struct GNUNET_PeerIdentity *id,
   rc->state_timeout = state_timeout;
   /* Resolve address to string */
   rc->asc = GNUNET_TRANSPORT_address_to_string (cfg, address, numeric,
-      RESOLUTION_TIMEOUT, &process_string, rc);
+      RESOLUTION_TIMEOUT, &process_peer_string, rc);
 }
 
 /**
@@ -843,7 +1004,7 @@ process_peer_iteration_cb (void *cls, const struct GNUNET_PeerIdentity *peer,
       GNUNET_i2s (peer), address->transport_name);
 
   if (NULL != address)
-    resolve_address (peer, address, numeric, state, state_timeout);
+    resolve_peer_address (peer, address, numeric, state, state_timeout);
   else
     print_info (peer, NULL, NULL, state, state_timeout);
 }
@@ -915,7 +1076,7 @@ process_peer_monitoring_cb (void *cls, const struct GNUNET_PeerIdentity *peer,
   m->state_timeout = state_timeout;
 
   if (NULL != address)
-    resolve_address (peer, m->address, numeric, m->state, m->state_timeout);
+    resolve_peer_address (peer, m->address, numeric, m->state, m->state_timeout);
   else
     print_info (peer, NULL, NULL, m->state, m->state_timeout);
 }
diff --git a/src/transport/transport_api_monitoring.c b/src/transport/transport_api_monitoring.c
index 9820151d5..9d74eb114 100644
--- a/src/transport/transport_api_monitoring.c
+++ b/src/transport/transport_api_monitoring.c
@@ -348,7 +348,7 @@ do_connect (void *cls,
  * @param pal_ctx our context
  */
 static void
-reconnect (struct GNUNET_TRANSPORT_PeerMonitoringContext *pal_ctx)
+reconnect_peer_ctx (struct GNUNET_TRANSPORT_PeerMonitoringContext *pal_ctx)
 {
   GNUNET_assert (GNUNET_NO == pal_ctx->one_shot);
   GNUNET_CLIENT_disconnect (pal_ctx->client);
@@ -360,6 +360,23 @@ reconnect (struct GNUNET_TRANSPORT_PeerMonitoringContext *pal_ctx)
 }
 
 /**
+ * Cut the existing connection and reconnect.
+ *
+ * @param pal_ctx our context
+ */
+static void
+reconnect_val_ctx (struct GNUNET_TRANSPORT_ValidationMonitoringContext *val_ctx)
+{
+  GNUNET_assert (GNUNET_NO == val_ctx->one_shot);
+  GNUNET_CLIENT_disconnect (val_ctx->client);
+  val_ctx->client = NULL;
+  val_ctx->backoff = GNUNET_TIME_STD_BACKOFF (val_ctx->backoff);
+  val_ctx->reconnect_task = GNUNET_SCHEDULER_add_delayed (val_ctx->backoff,
+                                                          &do_connect,
+                                                          val_ctx);
+}
+
+/**
  * Function called with responses from the service.
  *
  * @param cls our 'struct GNUNET_TRANSPORT_PeerMonitoringContext*'
@@ -370,7 +387,14 @@ static void
 val_response_processor (void *cls, const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_TRANSPORT_ValidationMonitoringContext *val_ctx = cls;
-  GNUNET_break (0);
+  struct ValidationIterateResponseMessage *vr_msg;
+  struct GNUNET_HELLO_Address *address;
+  const char *addr;
+  const char *transport_name;
+  size_t size;
+  size_t tlen;
+  size_t alen;
+
   if (msg == NULL)
   {
     GNUNET_break (0);
@@ -380,93 +404,87 @@ val_response_processor (void *cls, const struct GNUNET_MessageHeader *msg)
       val_ctx->cb (val_ctx->cb_cls, NULL, NULL,
           GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_TIME_UNIT_ZERO_ABS,
           GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_TRANSPORT_VS_TIMEOUT);
-      GNUNET_TRANSPORT_monitor_peers_cancel (val_ctx);
+      GNUNET_TRANSPORT_monitor_validation_entries_cancel (val_ctx);
     }
     else
     {
-      reconnect (val_ctx);
+      reconnect_val_ctx (val_ctx);
     }
     return;
   }
-
-  /* expect more replies */
-  GNUNET_CLIENT_receive (val_ctx->client, &val_response_processor,
-      val_ctx, GNUNET_TIME_absolute_get_remaining (val_ctx->timeout));
-
-  return;
-
-  struct ValidationIterateResponseMessage *vir_msg;
-  struct GNUNET_HELLO_Address *address;
-  const char *addr;
-  const char *transport_name;
-  uint16_t size;
-  size_t alen;
-  size_t tlen;
-#if 0
-
   size = ntohs (msg->size);
   GNUNET_break (ntohs (msg->type) ==
-      GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_RESPONSE);
+      GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_VALIDATION_RESPONSE);
   if (size == sizeof (struct GNUNET_MessageHeader))
   {
     /* Done! */
-    if (pal_ctx->one_shot)
+    if (val_ctx->one_shot)
     {
-      pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL,
-          GNUNET_TRANSPORT_PS_NOT_CONNECTED, GNUNET_TIME_UNIT_ZERO_ABS);
-      GNUNET_TRANSPORT_monitor_peers_cancel (pal_ctx);
+      val_ctx->cb (val_ctx->cb_cls, NULL, NULL,
+          GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_TIME_UNIT_ZERO_ABS,
+          GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_TRANSPORT_VS_NONE);
+      GNUNET_TRANSPORT_monitor_validation_entries_cancel (val_ctx);
     }
     else
     {
-      reconnect (pal_ctx);
+      reconnect_val_ctx (val_ctx);
     }
     return;
   }
 
-  if ((size < sizeof (struct PeerIterateResponseMessage)) ||
-      (ntohs (msg->type) !=
-          GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_RESPONSE))
+  if ((size < sizeof (struct ValidationIterateResponseMessage)) ||
+      (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_VALIDATION_RESPONSE))
   {
     GNUNET_break (0);
-    if (pal_ctx->one_shot)
+    if (val_ctx->one_shot)
     {
-      pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL,
-          GNUNET_TRANSPORT_PS_NOT_CONNECTED, GNUNET_TIME_UNIT_ZERO_ABS);
-      GNUNET_TRANSPORT_monitor_peers_cancel (pal_ctx);
+      val_ctx->cb (val_ctx->cb_cls, NULL, NULL,
+          GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_TIME_UNIT_ZERO_ABS,
+          GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_TRANSPORT_VS_NONE);
+      GNUNET_TRANSPORT_monitor_validation_entries_cancel (val_ctx);
     }
     else
     {
-      reconnect (pal_ctx);
+      reconnect_val_ctx (val_ctx);
     }
     return;
   }
 
-  pir_msg = (struct PeerIterateResponseMessage *) msg;
-  tlen = ntohl (pir_msg->pluginlen);
-  alen = ntohl (pir_msg->addrlen);
+  vr_msg = (struct ValidationIterateResponseMessage *) msg;
+  tlen = ntohl (vr_msg->pluginlen);
+  alen = ntohl (vr_msg->addrlen);
 
-  if (size != sizeof (struct PeerIterateResponseMessage) + tlen + alen)
+  if (size != sizeof (struct ValidationIterateResponseMessage) + tlen + alen)
   {
     GNUNET_break (0);
-    if (pal_ctx->one_shot)
+    if (val_ctx->one_shot)
     {
-      pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL,
-          GNUNET_TRANSPORT_PS_NOT_CONNECTED, GNUNET_TIME_UNIT_ZERO_ABS);
-      GNUNET_TRANSPORT_monitor_peers_cancel (pal_ctx);
+      val_ctx->cb (val_ctx->cb_cls, NULL, NULL,
+          GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_TIME_UNIT_ZERO_ABS,
+          GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_TRANSPORT_VS_NONE);
+      GNUNET_TRANSPORT_monitor_validation_entries_cancel (val_ctx);
     }
     else
     {
-      reconnect (pal_ctx);
+      reconnect_val_ctx (val_ctx);
     }
     return;
   }
-
   if ( (0 == tlen) && (0 == alen) )
   {
-    /* No address available */
-    pal_ctx->cb (pal_ctx->cb_cls, &pir_msg->peer, NULL,
-        ntohl(pir_msg->state),
-        GNUNET_TIME_absolute_ntoh (pir_msg->state_timeout));
+    GNUNET_break (0);
+    if (val_ctx->one_shot)
+    {
+      val_ctx->cb (val_ctx->cb_cls, NULL, NULL,
+          GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_TIME_UNIT_ZERO_ABS,
+          GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_TRANSPORT_VS_NONE);
+      GNUNET_TRANSPORT_monitor_validation_entries_cancel (val_ctx);
+    }
+    else
+    {
+      reconnect_val_ctx (val_ctx);
+    }
+    return;
   }
   else
   {
@@ -475,36 +493,40 @@ val_response_processor (void *cls, const struct GNUNET_MessageHeader *msg)
       GNUNET_break (0); /* This must not happen: address without plugin */
       return;
     }
-    addr = (const char *) &pir_msg[1];
+    addr = (const char *) &vr_msg[1];
     transport_name = &addr[alen];
 
     if (transport_name[tlen - 1] != '\0')
     {
       /* Corrupt plugin name */
       GNUNET_break (0);
-      if (pal_ctx->one_shot)
+      if (val_ctx->one_shot)
       {
-        pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL,
-            GNUNET_TRANSPORT_PS_NOT_CONNECTED, GNUNET_TIME_UNIT_ZERO_ABS);
-        GNUNET_TRANSPORT_monitor_peers_cancel (pal_ctx);
+        val_ctx->cb (val_ctx->cb_cls, NULL, NULL,
+            GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_TIME_UNIT_ZERO_ABS,
+            GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_TRANSPORT_VS_NONE);
+        GNUNET_TRANSPORT_monitor_validation_entries_cancel (val_ctx);
       }
       else
       {
-        reconnect (pal_ctx);
+        reconnect_val_ctx (val_ctx);
       }
       return;
     }
 
     /* notify client */
-    address = GNUNET_HELLO_address_allocate (&pir_msg->peer,
-        transport_name, addr, alen, ntohl(pir_msg->local_address_info));
-    pal_ctx->cb (pal_ctx->cb_cls, &pir_msg->peer, address,
-        ntohl(pir_msg->state),
-        GNUNET_TIME_absolute_ntoh (pir_msg->state_timeout));
+    address = GNUNET_HELLO_address_allocate (&vr_msg->peer,
+        transport_name, addr, alen, ntohl(vr_msg->local_address_info));
+    val_ctx->cb (val_ctx->cb_cls, &vr_msg->peer, address,
+        GNUNET_TIME_absolute_ntoh(vr_msg->last_validation),
+        GNUNET_TIME_absolute_ntoh(vr_msg->valid_until),
+        GNUNET_TIME_absolute_ntoh(vr_msg->next_validation),
+        ntohl(vr_msg->state));
     GNUNET_HELLO_address_free (address);
   }
-#endif
-
+  /* expect more replies */
+  GNUNET_CLIENT_receive (val_ctx->client, &val_response_processor,
+      val_ctx, GNUNET_TIME_absolute_get_remaining (val_ctx->timeout));
 }
 
 
@@ -538,7 +560,7 @@ peer_response_processor (void *cls, const struct GNUNET_MessageHeader *msg)
     }
     else
     {
-      reconnect (pal_ctx);
+      reconnect_peer_ctx (pal_ctx);
     }
     return;
   }
@@ -556,14 +578,13 @@ peer_response_processor (void *cls, const struct GNUNET_MessageHeader *msg)
     }
     else
     {
-      reconnect (pal_ctx);
+      reconnect_peer_ctx (pal_ctx);
     }
     return;
   }
 
   if ((size < sizeof (struct PeerIterateResponseMessage)) ||
-      (ntohs (msg->type) !=
-          GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_RESPONSE))
+      (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_RESPONSE))
   {
     GNUNET_break (0);
     if (pal_ctx->one_shot)
@@ -574,7 +595,7 @@ peer_response_processor (void *cls, const struct GNUNET_MessageHeader *msg)
     }
     else
     {
-      reconnect (pal_ctx);
+      reconnect_peer_ctx (pal_ctx);
     }
     return;
   }
@@ -594,7 +615,7 @@ peer_response_processor (void *cls, const struct GNUNET_MessageHeader *msg)
     }
     else
     {
-      reconnect (pal_ctx);
+      reconnect_peer_ctx (pal_ctx);
     }
     return;
   }
@@ -628,7 +649,7 @@ peer_response_processor (void *cls, const struct GNUNET_MessageHeader *msg)
       }
       else
       {
-        reconnect (pal_ctx);
+        reconnect_peer_ctx (pal_ctx);
       }
       return;
     }