na->session = NULL;
}
-/* Change the status of the neighbour */
+/**
+ * Set net state for this neighbour and notify monitoring
+ *
+ * @param n the respective neighbour
+ * @param s the new state
+ */
static void
set_state (struct NeighbourMapEntry *n, enum GNUNET_TRANSPORT_PeerState s)
{
n->state = s;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Neighbour `%s' changed state to %s\n",
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Neighbour `%s' changed state to %s\n",
GNUNET_i2s (&n->id),
GNUNET_TRANSPORT_p2s(s));
neighbour_change_cb (callback_cls,
}
+/**
+ * Set net state and state timeout for this neighbour and notify monitoring
+ *
+ * @param n the respective neighbour
+ * @param s the new state
+ * @param timeout the new timeout
+ */
static void
set_state_and_timeout (struct NeighbourMapEntry *n,
enum GNUNET_TRANSPORT_PeerState s,
{
n->state = s;
n->timeout = timeout;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Neighbour `%s' changed state to %s with timeout %s\n",
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Neighbour `%s' changed state to %s with timeout %s\n",
GNUNET_i2s (&n->id),
GNUNET_TRANSPORT_p2s(s),
GNUNET_STRINGS_absolute_time_to_string (timeout));
n->primary_address.bandwidth_out);
}
+
+/**
+ * Set new state timeout for this neighbour and notify monitoring
+ *
+ * @param n the respective neighbour
+ * @param timeout the new timeout
+ */
static void
set_timeout (struct NeighbourMapEntry *n,
struct GNUNET_TIME_Absolute timeout)
{
n->timeout = timeout;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Neighbour `%s' changed timeout %s\n",
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Neighbour `%s' changed timeout %s\n",
GNUNET_i2s (&n->id),
GNUNET_STRINGS_absolute_time_to_string (timeout));
neighbour_change_cb (callback_cls,
const struct GNUNET_HELLO_Address *address,
struct Session *session,
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
- struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
- int is_active)
+ struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out)
{
struct GNUNET_TRANSPORT_PluginFunctions *papi;
if (NULL == (papi = GST_plugins_find (address->transport_name)))
{
n->alternative_address.bandwidth_in = bandwidth_in;
n->alternative_address.bandwidth_out = bandwidth_out;
- if (is_active != n->alternative_address.ats_active)
- {
- n->alternative_address.ats_active = is_active;
- GNUNET_ATS_address_in_use (GST_ats, n->alternative_address.address,
- n->alternative_address.session, is_active);
- GST_validation_set_address_use (n->alternative_address.address,
- n->alternative_address.session, is_active);
- }
- if (GNUNET_YES == is_active)
- {
- GST_neighbours_set_incoming_quota (&address->peer, bandwidth_in);
- send_outbound_quota (&address->peer, bandwidth_out);
- }
return;
}
free_address (&n->alternative_address);
return;
}
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Neighbour `%s' switched to address %s\n",
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Neighbour `%s' configured alternative address %s\n",
GNUNET_i2s (&n->id),
GST_plugins_a2s(address));
n->alternative_address.bandwidth_in = bandwidth_in;
n->alternative_address.bandwidth_out = bandwidth_out;
n->alternative_address.session = session;
- n->alternative_address.ats_active = is_active;
+ n->alternative_address.ats_active = GNUNET_NO;
n->alternative_address.keep_alive_nonce = 0;
- if (GNUNET_YES == is_active)
- {
- /* Telling ATS about new session */
- GNUNET_ATS_address_in_use (GST_ats, n->alternative_address.address, n->alternative_address.session, GNUNET_YES);
- GST_validation_set_address_use (n->alternative_address.address, n->alternative_address.session, GNUNET_YES);
- GST_neighbours_set_incoming_quota (&address->peer, bandwidth_in);
- send_outbound_quota (&address->peer, bandwidth_out);
- }
}
send_outbound_quota (&address->peer, bandwidth_out);
}
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Neighbour `%s' switched to address %s\n",
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Neighbour `%s' switched to address %s\n",
GNUNET_i2s (&n->id),
GST_plugins_a2s(address));
n->primary_address.bandwidth_out);
}
+/**
+ * Clear the primary address of a neighbour since this primary address is not
+ * valid anymore and notify monitoring about it
+ *
+ * @param n the neighbour
+ */
+static void
+unset_primary_address (struct NeighbourMapEntry *n)
+{
+
+}
+
/**
* Free a neighbour map entry.
GNUNET_NO);
disconnect_notify_cb (callback_cls, &n->id);
}
- set_state (n, S_DISCONNECT_FINISHED);
+ set_state (n, GNUNET_TRANSPORT_DISCONNECT_FINISHED);
if (NULL != n->primary_address.address)
{
n = lookup_neighbour (target);
if (NULL == n)
return; /* already gone */
- if (S_DISCONNECT != n->state)
+ if (GNUNET_TRANSPORT_DISCONNECT != n->state)
return; /* have created a fresh entry since */
if (GNUNET_SCHEDULER_NO_TASK != n->task)
GNUNET_SCHEDULER_cancel (n->task);
about disconnect */
switch (n->state)
{
- case S_NOT_CONNECTED:
- case S_INIT_ATS:
- case S_INIT_BLACKLIST:
+ case GNUNET_TRANSPORT_NOT_CONNECTED:
+ case GNUNET_TRANSPORT_INIT_ATS:
+ case GNUNET_TRANSPORT_INIT_BLACKLIST:
/* other peer is completely unaware of us, no need to send DISCONNECT */
- set_state (n, S_DISCONNECT_FINISHED);
+ set_state (n, GNUNET_TRANSPORT_DISCONNECT_FINISHED);
free_neighbour (n, GNUNET_NO);
return;
- case S_CONNECT_SENT:
+ case GNUNET_TRANSPORT_CONNECT_SENT:
send_disconnect (n);
- set_state (n, S_DISCONNECT);
+ set_state (n, GNUNET_TRANSPORT_DISCONNECT);
break;
- case S_CONNECT_RECV_BLACKLIST_INBOUND:
- case S_CONNECT_RECV_ATS:
- case S_CONNECT_RECV_BLACKLIST:
+ case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST_INBOUND:
+ case GNUNET_TRANSPORT_CONNECT_RECV_ATS:
+ case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST:
/* we never ACK'ed the other peer's request, no need to send DISCONNECT */
- set_state (n, S_DISCONNECT_FINISHED);
+ set_state (n, GNUNET_TRANSPORT_DISCONNECT_FINISHED);
free_neighbour (n, GNUNET_NO);
return;
- case S_CONNECT_RECV_ACK:
+ case GNUNET_TRANSPORT_CONNECT_RECV_ACK:
/* we DID ACK the other peer's request, must send DISCONNECT */
send_disconnect (n);
- set_state (n, S_DISCONNECT);
+ set_state (n, GNUNET_TRANSPORT_DISCONNECT);
break;
- case S_CONNECTED:
- case S_RECONNECT_BLACKLIST:
- case S_RECONNECT_SENT:
- case S_CONNECTED_SWITCHING_BLACKLIST:
- case S_CONNECTED_SWITCHING_CONNECT_SENT:
+ case GNUNET_TRANSPORT_CONNECTED:
+ case GNUNET_TRANSPORT_RECONNECT_BLACKLIST:
+ case GNUNET_TRANSPORT_RECONNECT_SENT:
+ case GNUNET_TRANSPORT_CONNECTED_SWITCHING_BLACKLIST:
+ case GNUNET_TRANSPORT_CONNECTED_SWITCHING_CONNECT_SENT:
/* we are currently connected, need to send disconnect and do
internal notifications and update statistics */
send_disconnect (n);
--neighbours_connected,
GNUNET_NO);
disconnect_notify_cb (callback_cls, &n->id);
- set_state (n, S_DISCONNECT);
+ set_state (n, GNUNET_TRANSPORT_DISCONNECT);
break;
- case S_RECONNECT_ATS:
+ case GNUNET_TRANSPORT_RECONNECT_ATS:
/* ATS address request timeout, disconnect without sending disconnect message */
GNUNET_STATISTICS_set (GST_stats,
gettext_noop ("# peers connected"),
--neighbours_connected,
GNUNET_NO);
disconnect_notify_cb (callback_cls, &n->id);
- set_state (n, S_DISCONNECT);
+ set_state (n, GNUNET_TRANSPORT_DISCONNECT);
break;
- case S_DISCONNECT:
+ case GNUNET_TRANSPORT_DISCONNECT:
/* already disconnected, ignore */
break;
- case S_DISCONNECT_FINISHED:
+ case GNUNET_TRANSPORT_DISCONNECT_FINISHED:
/* already cleaned up, how did we get here!? */
GNUNET_assert (0);
break;
struct GNUNET_TIME_Relative timeout;
uint32_t nonce;
- GNUNET_assert ((S_CONNECTED == n->state) ||
- (S_CONNECTED_SWITCHING_BLACKLIST == n->state) ||
- (S_CONNECTED_SWITCHING_CONNECT_SENT));
+ GNUNET_assert ((GNUNET_TRANSPORT_CONNECTED == n->state) ||
+ (GNUNET_TRANSPORT_CONNECTED_SWITCHING_BLACKLIST == n->state) ||
+ (GNUNET_TRANSPORT_CONNECTED_SWITCHING_CONNECT_SENT));
if (GNUNET_TIME_absolute_get_remaining (n->keep_alive_time).rel_value_us > 0)
return; /* no keepalive needed at this time */
1, GNUNET_NO);
return;
}
- if ( (S_CONNECTED != n->state) ||
+ if ( (GNUNET_TRANSPORT_CONNECTED != n->state) ||
(GNUNET_YES != n->expect_latency_response) )
{
GNUNET_STATISTICS_update (GST_stats,
GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT,
MAX_BANDWIDTH_CARRY_S);
n->task = GNUNET_SCHEDULER_add_now (&master_task, n);
- set_state_and_timeout (n, S_NOT_CONNECTED, GNUNET_TIME_UNIT_FOREVER_ABS);
+ set_state_and_timeout (n, GNUNET_TRANSPORT_NOT_CONNECTED, GNUNET_TIME_UNIT_FOREVER_ABS);
GNUNET_assert (GNUNET_OK ==
GNUNET_CONTAINER_multipeermap_put (neighbours,
&n->id, n,
}
+static void
+address_suggest_cont (void *cls,
+ const struct GNUNET_PeerIdentity *peer,
+ const struct GNUNET_HELLO_Address *address, struct Session *session,
+ struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
+ struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
+ const struct GNUNET_ATS_Information *ats, uint32_t ats_count)
+{
+
+}
+
+
/**
* Try to create a connection to the given target (eventually).
*
{
switch (n->state)
{
- case S_NOT_CONNECTED:
+ case GNUNET_TRANSPORT_NOT_CONNECTED:
/* this should not be possible */
GNUNET_break (0);
free_neighbour (n, GNUNET_NO);
break;
- case S_INIT_ATS:
- case S_INIT_BLACKLIST:
- case S_CONNECT_SENT:
- case S_CONNECT_RECV_BLACKLIST_INBOUND:
- case S_CONNECT_RECV_ATS:
- case S_CONNECT_RECV_BLACKLIST:
- case S_CONNECT_RECV_ACK:
+ case GNUNET_TRANSPORT_INIT_ATS:
+ case GNUNET_TRANSPORT_INIT_BLACKLIST:
+ case GNUNET_TRANSPORT_CONNECT_SENT:
+ case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST_INBOUND:
+ case GNUNET_TRANSPORT_CONNECT_RECV_ATS:
+ case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST:
+ case GNUNET_TRANSPORT_CONNECT_RECV_ACK:
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Ignoring request to try to connect to `%s', already trying!\n",
GNUNET_i2s (target));
return; /* already trying */
- case S_CONNECTED:
- case S_RECONNECT_ATS:
- case S_RECONNECT_BLACKLIST:
- case S_RECONNECT_SENT:
- case S_CONNECTED_SWITCHING_BLACKLIST:
- case S_CONNECTED_SWITCHING_CONNECT_SENT:
+ case GNUNET_TRANSPORT_CONNECTED:
+ case GNUNET_TRANSPORT_RECONNECT_ATS:
+ case GNUNET_TRANSPORT_RECONNECT_BLACKLIST:
+ case GNUNET_TRANSPORT_RECONNECT_SENT:
+ case GNUNET_TRANSPORT_CONNECTED_SWITCHING_BLACKLIST:
+ case GNUNET_TRANSPORT_CONNECTED_SWITCHING_CONNECT_SENT:
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Ignoring request to try to connect, already connected to `%s'!\n",
GNUNET_i2s (target));
return; /* already connected */
- case S_DISCONNECT:
+ case GNUNET_TRANSPORT_DISCONNECT:
/* get rid of remains, ready to re-try immediately */
free_neighbour (n, GNUNET_NO);
break;
- case S_DISCONNECT_FINISHED:
+ case GNUNET_TRANSPORT_DISCONNECT_FINISHED:
/* should not be possible */
GNUNET_assert (0);
default:
}
}
n = setup_neighbour (target);
- set_state_and_timeout (n, S_INIT_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
+ set_state_and_timeout (n, GNUNET_TRANSPORT_INIT_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
GNUNET_ATS_reset_backoff (GST_ats, target);
- n->suggest_handle = GNUNET_ATS_suggest_address (GST_ats, target);
+ n->suggest_handle = GNUNET_ATS_suggest_address (GST_ats, target, &address_suggest_cont, n);
}
n->send_connect_ack);
switch (n->state)
{
- case S_NOT_CONNECTED:
+ case GNUNET_TRANSPORT_NOT_CONNECTED:
/* this should not be possible */
GNUNET_break (0);
free_neighbour (n, GNUNET_NO);
break;
- case S_INIT_ATS:
+ case GNUNET_TRANSPORT_INIT_ATS:
/* waiting on ATS suggestion; still, pass address to ATS as a
possibility */
break;
- case S_INIT_BLACKLIST:
+ case GNUNET_TRANSPORT_INIT_BLACKLIST:
/* check if the address the blacklist was fine with matches
ATS suggestion, if so, we can move on! */
if ( (GNUNET_OK == result) &&
}
if (GNUNET_OK == result)
{
- set_state_and_timeout (n, S_CONNECT_SENT, GNUNET_TIME_relative_to_absolute (SETUP_CONNECTION_TIMEOUT));
+ set_state_and_timeout (n, GNUNET_TRANSPORT_CONNECT_SENT, GNUNET_TIME_relative_to_absolute (SETUP_CONNECTION_TIMEOUT));
send_session_connect (&n->primary_address);
}
else
{
free_address (&n->primary_address);
- set_state_and_timeout (n, S_INIT_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
+ set_state_and_timeout (n, GNUNET_TRANSPORT_INIT_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
}
break;
- case S_CONNECT_SENT:
+ case GNUNET_TRANSPORT_CONNECT_SENT:
/* waiting on CONNECT_ACK, send ACK if one is pending */
if ( (GNUNET_OK == result) &&
(1 == n->send_connect_ack) )
n->connect_ack_timestamp);
}
break;
- case S_CONNECT_RECV_BLACKLIST_INBOUND:
- set_state_and_timeout (n, S_CONNECT_RECV_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
+ case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST_INBOUND:
+ set_state_and_timeout (n, GNUNET_TRANSPORT_CONNECT_RECV_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
GNUNET_ATS_reset_backoff (GST_ats, peer);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Suggesting address for peer %s to ATS\n",
GNUNET_i2s (peer));
- n->suggest_handle = GNUNET_ATS_suggest_address (GST_ats, peer);
+ n->suggest_handle = GNUNET_ATS_suggest_address (GST_ats, peer, &address_suggest_cont, n);
break;
- case S_CONNECT_RECV_ATS:
+ case GNUNET_TRANSPORT_CONNECT_RECV_ATS:
/* waiting on ATS suggestion, don't care about blacklist */
break;
- case S_CONNECT_RECV_BLACKLIST:
+ case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST:
if (GNUNET_YES != address_matches (&bcc->na, &n->primary_address))
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
}
if (GNUNET_OK == result)
{
- set_state_and_timeout (n, S_CONNECT_RECV_ACK, GNUNET_TIME_relative_to_absolute (SETUP_CONNECTION_TIMEOUT));
+ set_state_and_timeout (n, GNUNET_TRANSPORT_CONNECT_RECV_ACK, GNUNET_TIME_relative_to_absolute (SETUP_CONNECTION_TIMEOUT));
send_session_connect_ack_message (bcc->na.address,
bcc->na.session,
n->connect_ack_timestamp);
}
GNUNET_break (NULL != plugin);
free_address (&n->primary_address);
- set_state_and_timeout (n, S_INIT_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
+ set_state_and_timeout (n, GNUNET_TRANSPORT_INIT_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
GNUNET_ATS_reset_backoff (GST_ats, peer);
}
break;
- case S_CONNECT_RECV_ACK:
+ case GNUNET_TRANSPORT_CONNECT_RECV_ACK:
/* waiting on SESSION_ACK, send ACK if one is pending */
if ( (GNUNET_OK == result) &&
(1 == n->send_connect_ack) )
n->connect_ack_timestamp);
}
break;
- case S_CONNECTED:
+ case GNUNET_TRANSPORT_CONNECTED:
/* already connected, don't care about blacklist */
break;
- case S_RECONNECT_ATS:
+ case GNUNET_TRANSPORT_RECONNECT_ATS:
/* still waiting on ATS suggestion, don't care about blacklist */
break;
- case S_RECONNECT_BLACKLIST:
+ case GNUNET_TRANSPORT_RECONNECT_BLACKLIST:
if ( (GNUNET_OK == result) &&
(1 == n->send_connect_ack) )
{
}
if (GNUNET_OK == result)
{
- set_state_and_timeout (n, S_RECONNECT_SENT, GNUNET_TIME_relative_to_absolute (FAST_RECONNECT_TIMEOUT));
+ set_state_and_timeout (n, GNUNET_TRANSPORT_RECONNECT_SENT, GNUNET_TIME_relative_to_absolute (FAST_RECONNECT_TIMEOUT));
send_session_connect (&n->primary_address);
}
else
{
- set_state_and_timeout (n, S_RECONNECT_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
+ set_state_and_timeout (n, GNUNET_TRANSPORT_RECONNECT_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
}
break;
- case S_RECONNECT_SENT:
+ case GNUNET_TRANSPORT_RECONNECT_SENT:
/* waiting on CONNECT_ACK, don't care about blacklist */
if ( (GNUNET_OK == result) &&
(1 == n->send_connect_ack) )
n->connect_ack_timestamp);
}
break;
- case S_CONNECTED_SWITCHING_BLACKLIST:
+ case GNUNET_TRANSPORT_CONNECTED_SWITCHING_BLACKLIST:
if (GNUNET_YES != address_matches (&bcc->na, &n->alternative_address))
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
if (GNUNET_OK == result)
{
send_session_connect (&n->alternative_address);
- set_state (n, S_CONNECTED_SWITCHING_CONNECT_SENT);
+ set_state (n, GNUNET_TRANSPORT_CONNECTED_SWITCHING_CONNECT_SENT);
}
else
{
- set_state(n, S_CONNECTED);
+ set_state(n, GNUNET_TRANSPORT_CONNECTED);
free_address (&n->alternative_address);
}
break;
- case S_CONNECTED_SWITCHING_CONNECT_SENT:
+ case GNUNET_TRANSPORT_CONNECTED_SWITCHING_CONNECT_SENT:
/* waiting on CONNECT_ACK, don't care about blacklist */
if ( (GNUNET_OK == result) &&
(1 == n->send_connect_ack) )
n->connect_ack_timestamp);
}
break;
- case S_DISCONNECT:
+ case GNUNET_TRANSPORT_DISCONNECT:
/* Nothing to do here, ATS will already do what can be done */
break;
- case S_DISCONNECT_FINISHED:
+ case GNUNET_TRANSPORT_DISCONNECT_FINISHED:
/* should not be possible */
GNUNET_assert (0);
break;
n->send_connect_ack);
switch (n->state)
{
- case S_NOT_CONNECTED:
+ case GNUNET_TRANSPORT_NOT_CONNECTED:
/* Do a blacklist check for the new address */
- set_state (n, S_CONNECT_RECV_BLACKLIST_INBOUND);
+ set_state (n, GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST_INBOUND);
check_blacklist (peer, ts, address, session);
break;
- case S_INIT_ATS:
+ case GNUNET_TRANSPORT_INIT_ATS:
/* CONNECT message takes priority over us asking ATS for address */
- set_state (n, S_CONNECT_RECV_BLACKLIST_INBOUND);
+ set_state (n, GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST_INBOUND);
/* fallthrough */
- case S_INIT_BLACKLIST:
- case S_CONNECT_SENT:
- case S_CONNECT_RECV_BLACKLIST_INBOUND:
- case S_CONNECT_RECV_ATS:
- case S_CONNECT_RECV_BLACKLIST:
- case S_CONNECT_RECV_ACK:
+ case GNUNET_TRANSPORT_INIT_BLACKLIST:
+ case GNUNET_TRANSPORT_CONNECT_SENT:
+ case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST_INBOUND:
+ case GNUNET_TRANSPORT_CONNECT_RECV_ATS:
+ case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST:
+ case GNUNET_TRANSPORT_CONNECT_RECV_ACK:
/* It can never hurt to have an alternative address in the above cases,
see if it is allowed */
check_blacklist (peer, ts, address, session);
break;
- case S_CONNECTED:
+ case GNUNET_TRANSPORT_CONNECTED:
/* we are already connected and can thus send the ACK immediately;
still, it can never hurt to have an alternative address, so also
tell ATS about it */
n->primary_address.session, ts);
check_blacklist (peer, ts, address, session);
break;
- case S_RECONNECT_ATS:
- case S_RECONNECT_BLACKLIST:
- case S_RECONNECT_SENT:
+ case GNUNET_TRANSPORT_RECONNECT_ATS:
+ case GNUNET_TRANSPORT_RECONNECT_BLACKLIST:
+ case GNUNET_TRANSPORT_RECONNECT_SENT:
/* It can never hurt to have an alternative address in the above cases,
see if it is allowed */
check_blacklist (peer, ts, address, session);
break;
- case S_CONNECTED_SWITCHING_BLACKLIST:
- case S_CONNECTED_SWITCHING_CONNECT_SENT:
+ case GNUNET_TRANSPORT_CONNECTED_SWITCHING_BLACKLIST:
+ case GNUNET_TRANSPORT_CONNECTED_SWITCHING_CONNECT_SENT:
/* we are already connected and can thus send the ACK immediately;
still, it can never hurt to have an alternative address, so also
tell ATS about it */
n->primary_address.session, ts);
check_blacklist (peer, ts, address, session);
break;
- case S_DISCONNECT:
+ case GNUNET_TRANSPORT_DISCONNECT:
/* get rid of remains without terminating sessions, ready to re-try */
free_neighbour (n, GNUNET_YES);
n = setup_neighbour (peer);
- set_state (n, S_CONNECT_RECV_ATS);
+ set_state (n, GNUNET_TRANSPORT_CONNECT_RECV_ATS);
GNUNET_ATS_reset_backoff (GST_ats, peer);
- n->suggest_handle = GNUNET_ATS_suggest_address (GST_ats, peer);
break;
- case S_DISCONNECT_FINISHED:
+ case GNUNET_TRANSPORT_DISCONNECT_FINISHED:
/* should not be possible */
GNUNET_assert (0);
break;
}
switch (n->state)
{
- case S_NOT_CONNECTED:
+ case GNUNET_TRANSPORT_NOT_CONNECTED:
GNUNET_break (0);
free_neighbour (n, GNUNET_NO);
return;
- case S_INIT_ATS:
+ case GNUNET_TRANSPORT_INIT_ATS:
set_primary_address (n, address, session, bandwidth_in, bandwidth_out, GNUNET_NO);
- set_state_and_timeout (n, S_INIT_BLACKLIST, GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT));
+ set_state_and_timeout (n, GNUNET_TRANSPORT_INIT_BLACKLIST, GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT));
check_blacklist (&n->id,
n->connect_ack_timestamp,
address, session);
break;
- case S_INIT_BLACKLIST:
+ case GNUNET_TRANSPORT_INIT_BLACKLIST:
/* ATS suggests a different address, switch again */
set_primary_address (n,
address, session, bandwidth_in, bandwidth_out, GNUNET_NO);
n->connect_ack_timestamp,
address, session);
break;
- case S_CONNECT_SENT:
+ case GNUNET_TRANSPORT_CONNECT_SENT:
/* ATS suggests a different address, switch again */
set_primary_address (n, address, session, bandwidth_in, bandwidth_out, GNUNET_NO);
- set_state_and_timeout (n, S_INIT_BLACKLIST, GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT));
+ set_state_and_timeout (n, GNUNET_TRANSPORT_INIT_BLACKLIST, GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT));
check_blacklist (&n->id,
n->connect_ack_timestamp,
address, session);
break;
- case S_CONNECT_RECV_ATS:
+ case GNUNET_TRANSPORT_CONNECT_RECV_ATS:
set_primary_address (n,
address, session, bandwidth_in, bandwidth_out, GNUNET_NO);
- set_state_and_timeout (n, S_CONNECT_RECV_BLACKLIST, GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT));
+ set_state_and_timeout (n, GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST, GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT));
check_blacklist (&n->id,
n->connect_ack_timestamp,
address, session);
break;
- case S_CONNECT_RECV_BLACKLIST_INBOUND:
+ case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST_INBOUND:
set_timeout (n, GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT));
- neighbour_change_cb (callback_cls, &n->id, n->primary_address.address,
- n->state, n->timeout, bandwidth_in, bandwidth_out);
check_blacklist (&n->id,
n->connect_ack_timestamp,
address, session);
break;
- case S_CONNECT_RECV_BLACKLIST:
- case S_CONNECT_RECV_ACK:
+ case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST:
+ case GNUNET_TRANSPORT_CONNECT_RECV_ACK:
/* ATS asks us to switch while we were trying to connect; switch to new
address and check blacklist again */
set_primary_address (n,
address, session, bandwidth_in, bandwidth_out, GNUNET_NO);
- set_state_and_timeout (n, S_CONNECT_RECV_BLACKLIST, GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT));
- neighbour_change_cb (callback_cls, &n->id, n->primary_address.address,
- n->state, n->timeout, bandwidth_in, bandwidth_out);
+ set_state_and_timeout (n, GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST, GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT));
check_blacklist (&n->id,
n->connect_ack_timestamp,
address, session);
break;
- case S_CONNECTED:
+ case GNUNET_TRANSPORT_CONNECTED:
GNUNET_assert (NULL != n->primary_address.address);
GNUNET_assert (NULL != n->primary_address.session);
if (n->primary_address.session == session)
/* not an address change, just a quota change */
set_primary_address (n,
address, session, bandwidth_in, bandwidth_out, GNUNET_YES);
- neighbour_change_cb (callback_cls, &n->id, n->primary_address.address,
- n->state, n->timeout, bandwidth_in, bandwidth_out);
break;
}
/* ATS asks us to switch a life connection; see if we can get
a CONNECT_ACK on it before we actually do this! */
- set_state (n, S_CONNECTED_SWITCHING_BLACKLIST);
- set_alternative_address (n,
- address, session, bandwidth_in, bandwidth_out, GNUNET_NO);
- neighbour_change_cb (callback_cls, &n->id, n->primary_address.address,
- n->state, n->timeout, bandwidth_in, bandwidth_out);
+ set_state (n, GNUNET_TRANSPORT_CONNECTED_SWITCHING_BLACKLIST);
+ set_alternative_address (n, address, session, bandwidth_in, bandwidth_out);
check_blacklist (&n->id,
GNUNET_TIME_absolute_get (),
address, session);
break;
- case S_RECONNECT_ATS:
+ case GNUNET_TRANSPORT_RECONNECT_ATS:
set_primary_address (n,
address, session, bandwidth_in, bandwidth_out, GNUNET_NO);
- set_state_and_timeout (n, S_RECONNECT_BLACKLIST, GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT));
- neighbour_change_cb (callback_cls, &n->id, n->primary_address.address,
- n->state, n->timeout, bandwidth_in, bandwidth_out);
+ set_state_and_timeout (n, GNUNET_TRANSPORT_RECONNECT_BLACKLIST, GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT));
check_blacklist (&n->id,
n->connect_ack_timestamp,
address, session);
break;
- case S_RECONNECT_BLACKLIST:
+ case GNUNET_TRANSPORT_RECONNECT_BLACKLIST:
/* ATS asks us to switch while we were trying to reconnect; switch to new
address and check blacklist again */
set_primary_address (n,
address, session, bandwidth_in, bandwidth_out, GNUNET_NO);
set_timeout (n, GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT));
- neighbour_change_cb (callback_cls, &n->id, n->primary_address.address,
- n->state, n->timeout, bandwidth_in, bandwidth_out);
check_blacklist (&n->id,
n->connect_ack_timestamp,
address, session);
break;
- case S_RECONNECT_SENT:
+ case GNUNET_TRANSPORT_RECONNECT_SENT:
/* ATS asks us to switch while we were trying to reconnect; switch to new
address and check blacklist again */
set_primary_address (n,
address, session, bandwidth_in, bandwidth_out, GNUNET_NO);
- set_state_and_timeout (n, S_RECONNECT_BLACKLIST, GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT));
- neighbour_change_cb (callback_cls, &n->id, n->primary_address.address,
- n->state, n->timeout, bandwidth_in, bandwidth_out);
+ set_state_and_timeout (n, GNUNET_TRANSPORT_RECONNECT_BLACKLIST, GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT));
check_blacklist (&n->id,
n->connect_ack_timestamp,
address, session);
break;
- case S_CONNECTED_SWITCHING_BLACKLIST:
+ case GNUNET_TRANSPORT_CONNECTED_SWITCHING_BLACKLIST:
if (n->primary_address.session == session)
{
/* ATS switches back to still-active session */
- set_state(n, S_CONNECTED);
+ set_state(n, GNUNET_TRANSPORT_CONNECTED);
free_address (&n->alternative_address);
break;
}
/* ATS asks us to switch a life connection, update blacklist check */
set_primary_address (n,
address, session, bandwidth_in, bandwidth_out, GNUNET_NO);
- neighbour_change_cb (callback_cls, &n->id, n->primary_address.address,
- n->state, n->timeout, bandwidth_in, bandwidth_out);
check_blacklist (&n->id,
GNUNET_TIME_absolute_get (),
address, session);
break;
- case S_CONNECTED_SWITCHING_CONNECT_SENT:
+ case GNUNET_TRANSPORT_CONNECTED_SWITCHING_CONNECT_SENT:
if (n->primary_address.session == session)
{
/* ATS switches back to still-active session */
free_address (&n->alternative_address);
- set_state (n, S_CONNECTED);
+ set_state (n, GNUNET_TRANSPORT_CONNECTED);
break;
}
/* ATS asks us to switch a life connection, update blacklist check */
- set_state (n, S_CONNECTED_SWITCHING_BLACKLIST);
- set_alternative_address (n,
- address, session, bandwidth_in, bandwidth_out, GNUNET_NO);
- neighbour_change_cb (callback_cls, &n->id, n->primary_address.address,
- n->state, n->timeout, bandwidth_in, bandwidth_out);
+ set_state (n, GNUNET_TRANSPORT_CONNECTED_SWITCHING_BLACKLIST);
+ set_alternative_address (n, address, session, bandwidth_in, bandwidth_out);
check_blacklist (&n->id,
GNUNET_TIME_absolute_get (),
address, session);
break;
- case S_DISCONNECT:
+ case GNUNET_TRANSPORT_DISCONNECT:
/* not going to switch addresses while disconnecting */
return;
- case S_DISCONNECT_FINISHED:
+ case GNUNET_TRANSPORT_DISCONNECT_FINISHED:
GNUNET_assert (0);
break;
default:
GNUNET_YES));
switch (n->state)
{
- case S_NOT_CONNECTED:
+ case GNUNET_TRANSPORT_NOT_CONNECTED:
/* invalid state for master task, clean up */
GNUNET_break (0);
- set_state (n, S_DISCONNECT_FINISHED);
+ set_state (n, GNUNET_TRANSPORT_DISCONNECT_FINISHED);
free_neighbour (n, GNUNET_NO);
return;
- case S_INIT_ATS:
+ case GNUNET_TRANSPORT_INIT_ATS:
if (0 == delay.rel_value_us)
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Connection to `%s' timed out waiting for ATS to provide address\n",
GNUNET_i2s (&n->id));
- set_state (n, S_DISCONNECT_FINISHED);
+ set_state (n, GNUNET_TRANSPORT_DISCONNECT_FINISHED);
free_neighbour (n, GNUNET_NO);
return;
}
break;
- case S_INIT_BLACKLIST:
+ case GNUNET_TRANSPORT_INIT_BLACKLIST:
if (0 == delay.rel_value_us)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Connection to `%s' timed out waiting for BLACKLIST to approve address\n",
GNUNET_i2s (&n->id));
- set_state (n, S_DISCONNECT_FINISHED);
+ set_state (n, GNUNET_TRANSPORT_DISCONNECT_FINISHED);
free_neighbour (n, GNUNET_NO);
return;
}
break;
- case S_CONNECT_SENT:
+ case GNUNET_TRANSPORT_CONNECT_SENT:
if (0 == delay.rel_value_us)
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
return;
}
break;
- case S_CONNECT_RECV_BLACKLIST_INBOUND:
+ case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST_INBOUND:
if (0 == delay.rel_value_us)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Connection to `%s' timed out waiting BLACKLIST to approve address to use for received CONNECT\n",
GNUNET_i2s (&n->id));
- set_state (n, S_DISCONNECT_FINISHED);
+ set_state (n, GNUNET_TRANSPORT_DISCONNECT_FINISHED);
free_neighbour (n, GNUNET_NO);
return;
}
break;
- case S_CONNECT_RECV_ATS:
+ case GNUNET_TRANSPORT_CONNECT_RECV_ATS:
if (0 == delay.rel_value_us)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Connection to `%s' timed out waiting ATS to provide address to use for CONNECT_ACK\n",
GNUNET_i2s (&n->id));
- set_state (n, S_DISCONNECT_FINISHED);
+ set_state (n, GNUNET_TRANSPORT_DISCONNECT_FINISHED);
free_neighbour (n, GNUNET_NO);
return;
}
break;
- case S_CONNECT_RECV_BLACKLIST:
+ case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST:
if (0 == delay.rel_value_us)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Connection to `%s' timed out waiting BLACKLIST to approve address to use for CONNECT_ACK\n",
GNUNET_i2s (&n->id));
- set_state (n, S_DISCONNECT_FINISHED);
+ set_state (n, GNUNET_TRANSPORT_DISCONNECT_FINISHED);
free_neighbour (n, GNUNET_NO);
return;
}
break;
- case S_CONNECT_RECV_ACK:
+ case GNUNET_TRANSPORT_CONNECT_RECV_ACK:
if (0 == delay.rel_value_us)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
return;
}
break;
- case S_CONNECTED:
+ case GNUNET_TRANSPORT_CONNECTED:
if (0 == delay.rel_value_us)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
try_transmission_to_peer (n);
send_keepalive (n);
break;
- case S_RECONNECT_ATS:
+ case GNUNET_TRANSPORT_RECONNECT_ATS:
if (0 == delay.rel_value_us)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
return;
}
break;
- case S_RECONNECT_BLACKLIST:
+ case GNUNET_TRANSPORT_RECONNECT_BLACKLIST:
if (0 == delay.rel_value_us)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
return;
}
break;
- case S_RECONNECT_SENT:
+ case GNUNET_TRANSPORT_RECONNECT_SENT:
if (0 == delay.rel_value_us)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
return;
}
break;
- case S_CONNECTED_SWITCHING_BLACKLIST:
+ case GNUNET_TRANSPORT_CONNECTED_SWITCHING_BLACKLIST:
if (0 == delay.rel_value_us)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
try_transmission_to_peer (n);
send_keepalive (n);
break;
- case S_CONNECTED_SWITCHING_CONNECT_SENT:
+ case GNUNET_TRANSPORT_CONNECTED_SWITCHING_CONNECT_SENT:
if (0 == delay.rel_value_us)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
try_transmission_to_peer (n);
send_keepalive (n);
break;
- case S_DISCONNECT:
+ case GNUNET_TRANSPORT_DISCONNECT:
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Cleaning up connection to `%s' after sending DISCONNECT\n",
GNUNET_i2s (&n->id));
free_neighbour (n, GNUNET_NO);
return;
- case S_DISCONNECT_FINISHED:
+ case GNUNET_TRANSPORT_DISCONNECT_FINISHED:
/* how did we get here!? */
GNUNET_assert (0);
break;
GNUNET_break (0);
break;
}
- if ( (S_CONNECTED_SWITCHING_CONNECT_SENT == n->state) ||
- (S_CONNECTED_SWITCHING_BLACKLIST == n->state) ||
- (S_CONNECTED == n->state) )
+ if ( (GNUNET_TRANSPORT_CONNECTED_SWITCHING_CONNECT_SENT == n->state) ||
+ (GNUNET_TRANSPORT_CONNECTED_SWITCHING_BLACKLIST == n->state) ||
+ (GNUNET_TRANSPORT_CONNECTED == n->state) )
{
/* if we are *now* in one of these three states, we're sending
keep alive messages, so we need to consider the keepalive
ts = GNUNET_TIME_absolute_ntoh (scm->timestamp);
switch (n->state)
{
- case S_NOT_CONNECTED:
+ case GNUNET_TRANSPORT_NOT_CONNECTED:
GNUNET_break (0);
free_neighbour (n, GNUNET_NO);
return GNUNET_SYSERR;
- case S_INIT_ATS:
- case S_INIT_BLACKLIST:
+ case GNUNET_TRANSPORT_INIT_ATS:
+ case GNUNET_TRANSPORT_INIT_BLACKLIST:
GNUNET_STATISTICS_update (GST_stats,
gettext_noop
("# unexpected CONNECT_ACK messages (not ready)"),
1, GNUNET_NO);
break;
- case S_CONNECT_SENT:
+ case GNUNET_TRANSPORT_CONNECT_SENT:
if (ts.abs_value_us != n->primary_address.connect_timestamp.abs_value_us)
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"CONNECT_ACK ignored as the timestamp does not match our CONNECT request\n");
return GNUNET_OK;
}
- set_state_and_timeout (n, S_CONNECTED, GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT));
+ set_state_and_timeout (n, GNUNET_TRANSPORT_CONNECTED, GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT));
GNUNET_STATISTICS_set (GST_stats,
gettext_noop ("# peers connected"),
++neighbours_connected,
GNUNET_YES);
send_session_ack_message (n);
break;
- case S_CONNECT_RECV_BLACKLIST_INBOUND:
- case S_CONNECT_RECV_ATS:
- case S_CONNECT_RECV_BLACKLIST:
- case S_CONNECT_RECV_ACK:
+ case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST_INBOUND:
+ case GNUNET_TRANSPORT_CONNECT_RECV_ATS:
+ case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST:
+ case GNUNET_TRANSPORT_CONNECT_RECV_ACK:
GNUNET_STATISTICS_update (GST_stats,
gettext_noop
("# unexpected CONNECT_ACK messages (not ready)"),
1, GNUNET_NO);
break;
- case S_CONNECTED:
+ case GNUNET_TRANSPORT_CONNECTED:
/* duplicate CONNECT_ACK, let's answer by duplciate SESSION_ACK just in case */
send_session_ack_message (n);
break;
- case S_RECONNECT_ATS:
- case S_RECONNECT_BLACKLIST:
+ case GNUNET_TRANSPORT_RECONNECT_ATS:
+ case GNUNET_TRANSPORT_RECONNECT_BLACKLIST:
/* we didn't expect any CONNECT_ACK, as we are waiting for ATS
to give us a new address... */
GNUNET_STATISTICS_update (GST_stats,
("# unexpected CONNECT_ACK messages (waiting on ATS)"),
1, GNUNET_NO);
break;
- case S_RECONNECT_SENT:
+ case GNUNET_TRANSPORT_RECONNECT_SENT:
/* new address worked; go back to connected! */
- set_state (n, S_CONNECTED);
+ set_state (n, GNUNET_TRANSPORT_CONNECTED);
send_session_ack_message (n);
break;
- case S_CONNECTED_SWITCHING_BLACKLIST:
+ case GNUNET_TRANSPORT_CONNECTED_SWITCHING_BLACKLIST:
/* duplicate CONNECT_ACK, let's answer by duplciate SESSION_ACK just in case */
send_session_ack_message (n);
break;
- case S_CONNECTED_SWITCHING_CONNECT_SENT:
+ case GNUNET_TRANSPORT_CONNECTED_SWITCHING_CONNECT_SENT:
/* new address worked; adopt it and go back to connected! */
- set_state_and_timeout (n, S_CONNECTED, GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT));
+ set_state_and_timeout (n, GNUNET_TRANSPORT_CONNECTED, GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT));
GNUNET_break (GNUNET_NO == n->alternative_address.ats_active);
GST_ats_add_address (n->alternative_address.address,
n->alternative_address.session,
NULL, 0);
- set_alternative_address (n,
- n->alternative_address.address,
- n->alternative_address.session,
- n->alternative_address.bandwidth_in,
- n->alternative_address.bandwidth_out,
- GNUNET_YES);
+ set_primary_address (n, n->alternative_address.address,
+ n->alternative_address.session, n->alternative_address.bandwidth_in,
+ n->alternative_address.bandwidth_out, GNUNET_YES);
+
free_address (&n->alternative_address);
send_session_ack_message (n);
break;
- case S_DISCONNECT:
+ case GNUNET_TRANSPORT_DISCONNECT:
GNUNET_STATISTICS_update (GST_stats,
gettext_noop
("# unexpected CONNECT_ACK messages (disconnecting)"),
1, GNUNET_NO);
return GNUNET_SYSERR;
- case S_DISCONNECT_FINISHED:
+ case GNUNET_TRANSPORT_DISCONNECT_FINISHED:
GNUNET_assert (0);
break;
default:
{
if (session == n->alternative_address.session)
{
- if ( (S_CONNECTED_SWITCHING_BLACKLIST == n->state) ||
- (S_CONNECTED_SWITCHING_CONNECT_SENT == n->state) )
- set_state (n, S_CONNECTED);
+ if ( (GNUNET_TRANSPORT_CONNECTED_SWITCHING_BLACKLIST == n->state) ||
+ (GNUNET_TRANSPORT_CONNECTED_SWITCHING_CONNECT_SENT == n->state) )
+ set_state (n, GNUNET_TRANSPORT_CONNECTED);
else
GNUNET_break (0);
free_address (&n->alternative_address);
n->expect_latency_response = GNUNET_NO;
switch (n->state)
{
- case S_NOT_CONNECTED:
+ case GNUNET_TRANSPORT_NOT_CONNECTED:
GNUNET_break (0);
free_neighbour (n, GNUNET_NO);
return GNUNET_YES;
- case S_INIT_ATS:
+ case GNUNET_TRANSPORT_INIT_ATS:
GNUNET_break (0);
free_neighbour (n, GNUNET_NO);
return GNUNET_YES;
- case S_INIT_BLACKLIST:
- case S_CONNECT_SENT:
+ case GNUNET_TRANSPORT_INIT_BLACKLIST:
+ case GNUNET_TRANSPORT_CONNECT_SENT:
free_address (&n->primary_address);
- set_state_and_timeout (n, S_INIT_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
+ set_state_and_timeout (n, GNUNET_TRANSPORT_INIT_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
break;
- case S_CONNECT_RECV_BLACKLIST_INBOUND:
- case S_CONNECT_RECV_ATS:
- case S_CONNECT_RECV_BLACKLIST:
- case S_CONNECT_RECV_ACK:
+ case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST_INBOUND:
+ case GNUNET_TRANSPORT_CONNECT_RECV_ATS:
+ case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST:
+ case GNUNET_TRANSPORT_CONNECT_RECV_ACK:
/* error on inbound session; free neighbour entirely */
free_address (&n->primary_address);
free_neighbour (n, GNUNET_NO);
return GNUNET_YES;
- case S_CONNECTED:
- set_state_and_timeout (n, S_INIT_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
+ case GNUNET_TRANSPORT_CONNECTED:
+ set_state_and_timeout (n, GNUNET_TRANSPORT_INIT_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
free_address (&n->primary_address);
break;
- case S_RECONNECT_ATS:
+ case GNUNET_TRANSPORT_RECONNECT_ATS:
/* we don't have an address, how can it go down? */
GNUNET_break (0);
break;
- case S_RECONNECT_BLACKLIST:
- case S_RECONNECT_SENT:
- set_state_and_timeout (n, S_RECONNECT_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
+ case GNUNET_TRANSPORT_RECONNECT_BLACKLIST:
+ case GNUNET_TRANSPORT_RECONNECT_SENT:
+ set_state_and_timeout (n, GNUNET_TRANSPORT_RECONNECT_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
break;
- case S_CONNECTED_SWITCHING_BLACKLIST:
+ case GNUNET_TRANSPORT_CONNECTED_SWITCHING_BLACKLIST:
/* primary went down while we were checking secondary against
blacklist, adopt secondary as primary */
free_address (&n->primary_address);
- set_state_and_timeout (n, S_RECONNECT_BLACKLIST, GNUNET_TIME_relative_to_absolute (FAST_RECONNECT_TIMEOUT));
+ set_state_and_timeout (n, GNUNET_TRANSPORT_RECONNECT_BLACKLIST, GNUNET_TIME_relative_to_absolute (FAST_RECONNECT_TIMEOUT));
n->primary_address = n->alternative_address;
memset (&n->alternative_address, 0, sizeof (struct NeighbourAddress));
break;
- case S_CONNECTED_SWITCHING_CONNECT_SENT:
+ case GNUNET_TRANSPORT_CONNECTED_SWITCHING_CONNECT_SENT:
/* primary went down while we were waiting for CONNECT_ACK on secondary;
secondary as primary */
free_address (&n->primary_address);
n->primary_address = n->alternative_address;
memset (&n->alternative_address, 0, sizeof (struct NeighbourAddress));
- set_state_and_timeout (n, S_RECONNECT_SENT, GNUNET_TIME_relative_to_absolute (FAST_RECONNECT_TIMEOUT));
+ set_state_and_timeout (n, GNUNET_TRANSPORT_RECONNECT_SENT, GNUNET_TIME_relative_to_absolute (FAST_RECONNECT_TIMEOUT));
break;
- case S_DISCONNECT:
+ case GNUNET_TRANSPORT_DISCONNECT:
free_address (&n->primary_address);
break;
- case S_DISCONNECT_FINISHED:
+ case GNUNET_TRANSPORT_DISCONNECT_FINISHED:
/* neighbour was freed and plugins told to terminate session */
return GNUNET_NO;
break;
}
/* check if we are in a plausible state for having sent
a CONNECT_ACK. If not, return, otherwise break */
- if ( ( (S_CONNECT_RECV_ACK != n->state) &&
- (S_CONNECT_SENT != n->state) ) ||
+ if ( ( (GNUNET_TRANSPORT_CONNECT_RECV_ACK != n->state) &&
+ (GNUNET_TRANSPORT_CONNECT_SENT != n->state) ) ||
(2 != n->send_connect_ack) )
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
GNUNET_NO);
return GNUNET_OK;
}
- set_state_and_timeout (n, S_CONNECTED, GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT));
+ set_state_and_timeout (n, GNUNET_TRANSPORT_CONNECTED, GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT));
GNUNET_STATISTICS_set (GST_stats,
gettext_noop ("# peers connected"),
++neighbours_connected,
return GNUNET_TIME_UNIT_FOREVER_REL;
switch (n->state)
{
- case S_CONNECTED:
- case S_CONNECTED_SWITCHING_CONNECT_SENT:
- case S_CONNECTED_SWITCHING_BLACKLIST:
- case S_RECONNECT_SENT:
- case S_RECONNECT_ATS:
- case S_RECONNECT_BLACKLIST:
+ case GNUNET_TRANSPORT_CONNECTED:
+ case GNUNET_TRANSPORT_CONNECTED_SWITCHING_CONNECT_SENT:
+ case GNUNET_TRANSPORT_CONNECTED_SWITCHING_BLACKLIST:
+ case GNUNET_TRANSPORT_RECONNECT_SENT:
+ case GNUNET_TRANSPORT_RECONNECT_ATS:
+ case GNUNET_TRANSPORT_RECONNECT_BLACKLIST:
return n->latency;
- case S_NOT_CONNECTED:
- case S_INIT_BLACKLIST:
- case S_INIT_ATS:
- case S_CONNECT_RECV_BLACKLIST_INBOUND:
- case S_CONNECT_RECV_ATS:
- case S_CONNECT_RECV_BLACKLIST:
- case S_CONNECT_RECV_ACK:
- case S_CONNECT_SENT:
- case S_DISCONNECT:
- case S_DISCONNECT_FINISHED:
+ case GNUNET_TRANSPORT_NOT_CONNECTED:
+ case GNUNET_TRANSPORT_INIT_BLACKLIST:
+ case GNUNET_TRANSPORT_INIT_ATS:
+ case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST_INBOUND:
+ case GNUNET_TRANSPORT_CONNECT_RECV_ATS:
+ case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST:
+ case GNUNET_TRANSPORT_CONNECT_RECV_ACK:
+ case GNUNET_TRANSPORT_CONNECT_SENT:
+ case GNUNET_TRANSPORT_DISCONNECT:
+ case GNUNET_TRANSPORT_DISCONNECT_FINISHED:
return GNUNET_TIME_UNIT_FOREVER_REL;
default:
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Disconnecting peer `%4s', %s\n",
GNUNET_i2s (&n->id), "SHUTDOWN_TASK");
- set_state (n, S_DISCONNECT_FINISHED);
+ set_state (n, GNUNET_TRANSPORT_DISCONNECT_FINISHED);
free_neighbour (n, GNUNET_NO);
return GNUNET_OK;
}