{
case GNUNET_TRANSPORT_PS_NOT_CONNECTED:
case GNUNET_TRANSPORT_PS_INIT_ATS:
- case GNUNET_TRANSPORT_PS_INIT_BLACKLIST:
case GNUNET_TRANSPORT_PS_CONNECT_SENT:
- case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST_INBOUND:
case GNUNET_TRANSPORT_PS_CONNECT_RECV_ATS:
- case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST:
case GNUNET_TRANSPORT_PS_CONNECT_RECV_ACK:
return GNUNET_NO;
case GNUNET_TRANSPORT_PS_CONNECTED:
case GNUNET_TRANSPORT_PS_RECONNECT_ATS:
- case GNUNET_TRANSPORT_PS_RECONNECT_BLACKLIST:
case GNUNET_TRANSPORT_PS_RECONNECT_SENT:
- case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_BLACKLIST:
case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT:
return GNUNET_YES;
case GNUNET_TRANSPORT_PS_DISCONNECT:
return "S_NOT_CONNECTED";
case GNUNET_TRANSPORT_PS_INIT_ATS:
return "S_INIT_ATS";
- case GNUNET_TRANSPORT_PS_INIT_BLACKLIST:
- return "S_INIT_BLACKLIST";
case GNUNET_TRANSPORT_PS_CONNECT_SENT:
return "S_CONNECT_SENT";
- case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST_INBOUND:
- return "S_CONNECT_RECV_BLACKLIST_INBOUND";
case GNUNET_TRANSPORT_PS_CONNECT_RECV_ATS:
return "S_CONNECT_RECV_ATS";
- case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST:
- return "S_CONNECT_RECV_BLACKLIST";
case GNUNET_TRANSPORT_PS_CONNECT_RECV_ACK:
return "S_CONNECT_RECV_ACK";
case GNUNET_TRANSPORT_PS_CONNECTED:
return "S_CONNECTED";
case GNUNET_TRANSPORT_PS_RECONNECT_ATS:
return "S_RECONNECT_ATS";
- case GNUNET_TRANSPORT_PS_RECONNECT_BLACKLIST:
- return "S_RECONNECT_BLACKLIST";
case GNUNET_TRANSPORT_PS_RECONNECT_SENT:
return "S_RECONNECT_SENT";
- case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_BLACKLIST:
- return "S_CONNECTED_SWITCHING_BLACKLIST";
case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT:
return "S_CONNECTED_SWITCHING_CONNECT_SENT";
case GNUNET_TRANSPORT_PS_DISCONNECT:
{
switch (state)
{
+ case GNUNET_TRANSPORT_VS_NONE:
+ return "NONE";
case GNUNET_TRANSPORT_VS_NEW:
return "NEW";
case GNUNET_TRANSPORT_VS_REMOVE:
/**
* Send our subscription request to the service.
*
- * @param pal_ctx our context
+ * @param val_ctx our context
*/
static void
send_val_mon_request (struct GNUNET_TRANSPORT_ValidationMonitoringContext *val_ctx)
{
struct ValidationMonitorMessage msg;
- msg.header.size = htons (sizeof (struct PeerMonitorMessage));
+ msg.header.size = htons (sizeof (struct ValidationMonitorMessage));
msg.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_VALIDATION_REQUEST);
msg.one_shot = htonl (val_ctx->one_shot);
msg.peer = val_ctx->peer;
val_ctx));
}
-
/**
* Task run to re-establish the connection.
*
* @param tc scheduler context, unused
*/
static void
-do_connect (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_peer_connect (void *cls,
+ const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GNUNET_TRANSPORT_PeerMonitoringContext *pal_ctx = 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);
pal_ctx->client = NULL;
+ pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL,
+ GNUNET_TRANSPORT_PS_NOT_CONNECTED,
+ GNUNET_TIME_UNIT_ZERO_ABS);
pal_ctx->backoff = GNUNET_TIME_STD_BACKOFF (pal_ctx->backoff);
pal_ctx->reconnect_task = GNUNET_SCHEDULER_add_delayed (pal_ctx->backoff,
- &do_connect,
+ &do_peer_connect,
pal_ctx);
}
+
+/**
+ * Task run to re-establish the connection.
+ *
+ * @param cls our 'struct GNUNET_TRANSPORT_PeerAddressLookupContext*'
+ * @param tc scheduler context, unused
+ */
+static void
+do_val_connect (void *cls,
+ const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+ struct GNUNET_TRANSPORT_ValidationMonitoringContext *val_ctx = cls;
+
+ val_ctx->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
+ val_ctx->client = GNUNET_CLIENT_connect ("transport", val_ctx->cfg);
+ GNUNET_assert (NULL != val_ctx->client);
+ send_val_mon_request (val_ctx);
+}
+
+/**
+ * Cut the existing connection and reconnect.
+ *
+ * @param val_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;
+ /* notify clients about (re)connect */
+ 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);
+ val_ctx->backoff = GNUNET_TIME_STD_BACKOFF (val_ctx->backoff);
+ val_ctx->reconnect_task = GNUNET_SCHEDULER_add_delayed (val_ctx->backoff,
+ &do_val_connect,
+ val_ctx);
+}
+
+
/**
* Function called with responses from the service.
*
- * @param cls our 'struct GNUNET_TRANSPORT_PeerMonitoringContext*'
+ * @param cls our `struct GNUNET_TRANSPORT_PeerMonitoringContext *`
* @param msg NULL on timeout or error, otherwise presumably a
* message with the human-readable address
*/
static void
-val_response_processor (void *cls, const struct GNUNET_MessageHeader *msg)
+val_response_processor (void *cls,
+ const struct GNUNET_MessageHeader *msg)
{
struct GNUNET_TRANSPORT_ValidationMonitoringContext *val_ctx = cls;
- GNUNET_break (0);
- if (msg == NULL)
+ 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 (NULL == msg)
{
- GNUNET_break (0);
if (val_ctx->one_shot)
{
/* Disconnect */
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
{
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));
}
/**
* Function called with responses from the service.
*
- * @param cls our 'struct GNUNET_TRANSPORT_PeerMonitoringContext*'
+ * @param cls our `struct GNUNET_TRANSPORT_PeerMonitoringContext *`
* @param msg NULL on timeout or error, otherwise presumably a
* message with the human-readable address
*/
static void
-peer_response_processor (void *cls, const struct GNUNET_MessageHeader *msg)
+peer_response_processor (void *cls,
+ const struct GNUNET_MessageHeader *msg)
{
struct GNUNET_TRANSPORT_PeerMonitoringContext *pal_ctx = cls;
struct PeerIterateResponseMessage *pir_msg;
uint16_t size;
size_t alen;
size_t tlen;
- GNUNET_break (0);
- if (msg == NULL)
+
+ if (NULL == msg)
{
if (pal_ctx->one_shot)
{
}
else
{
- reconnect (pal_ctx);
+ reconnect_peer_ctx (pal_ctx);
}
return;
}
/* Done! */
if (pal_ctx->one_shot)
{
+ /* iteration finished */
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);
}
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)
{
+ /* iteration finished (with error) */
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);
}
else
{
- reconnect (pal_ctx);
+ reconnect_peer_ctx (pal_ctx);
}
return;
}
}
else
{
- reconnect (pal_ctx);
+ reconnect_peer_ctx (pal_ctx);
}
return;
}
}
else
{
- reconnect (pal_ctx);
+ reconnect_peer_ctx (pal_ctx);
}
return;
}
* @param cfg configuration to use
* @param peer a specific peer identity to obtain information for,
* NULL for all peers
- * @param one_shot GNUNET_YES to return the current state and then end (with NULL+NULL),
- * GNUNET_NO to monitor peers continuously
+ * @param one_shot #GNUNET_YES to return the current state and then end (with NULL+NULL),
+ * #GNUNET_NO to monitor peers continuously
* @param timeout how long is the lookup allowed to take at most
* @param peer_callback function to call with the results
- * @param peer_callback_cls closure for peer_address_callback
+ * @param peer_callback_cls closure for @a peer_address_callback
*/
struct GNUNET_TRANSPORT_PeerMonitoringContext *
GNUNET_TRANSPORT_monitor_peers (const struct GNUNET_CONFIGURATION_Handle *cfg,
- const struct GNUNET_PeerIdentity *peer,
- int one_shot,
- struct GNUNET_TIME_Relative timeout,
- GNUNET_TRANSPORT_PeerIterateCallback peer_callback,
- void *peer_callback_cls)
+ const struct GNUNET_PeerIdentity *peer,
+ int one_shot,
+ struct GNUNET_TIME_Relative timeout,
+ GNUNET_TRANSPORT_PeerIterateCallback peer_callback,
+ void *peer_callback_cls)
{
struct GNUNET_TRANSPORT_PeerMonitoringContext *pal_ctx;
struct GNUNET_CLIENT_Connection *client;