* Time we give plugin to transmit DISCONNECT message before the
* neighbour entry self-destructs.
*/
-#define DISCONNECT_SENT_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 100)
+#define DISCONNECT_SENT_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 500)
/**
* How often must a peer violate bandwidth quotas before we start
*/
GNUNET_SCHEDULER_TaskIdentifier task;
+ /**
+ * Task to disconnect neighbour after we received a DISCONNECT message
+ */
+ GNUNET_SCHEDULER_TaskIdentifier delayed_disconnect_task;
+
/**
* At what time should we sent the next keep-alive message?
*/
int expect_latency_response;
/**
+ * When a peer wants to connect we have to reply to the 1st CONNECT message
+ * with a CONNECT_ACK message. But sometime we cannot send this message
+ * immediately since we do not have an address and then we have to remember
+ * to send this message as soon as we have an address.
+ *
* Flag to set if we still need to send a CONNECT_ACK message to the other peer
* (once we have an address to use and the peer has been allowed by our
* blacklist). Initially set to #ACK_UNDEFINED. Set to #ACK_SEND_CONNECT_ACK
- * if we need to send a CONNECT_ACK. Set to #ACK_SEND_CONNECT_ACK if we did
+ * if we need to send a CONNECT_ACK. Set to #ACK_SEND_SESSION_ACK if we did
* send a CONNECT_ACK and should go to 'S_CONNECTED' upon receiving a
* 'SESSION_ACK' (regardless of what our own state machine might say).
*/
/**
- * Context for blacklist checks and the #handle_test_blacklist_cont()
+ * Context for blacklist checks and the #try_connect_bl_check_cont()
* function. Stores information about ongoing blacklist checks.
*/
struct BlackListCheckContext
struct GNUNET_TIME_Absolute timeout)
{
n->timeout = timeout;
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Neighbour `%s' changed timeout %s\n",
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Neighbour `%s' changed timeout %s\n",
GNUNET_i2s (&n->id),
GNUNET_STRINGS_absolute_time_to_string (timeout));
neighbour_change_cb (callback_cls,
}
/**
- * Clear the primary address of a neighbour since this primary address is not
+ * Clear the primary address of a neighbour since this address is not
* valid anymore and notify monitoring about it
*
* @param n the neighbour
n->primary_address.bandwidth_out);
}
-
+/**
+ * Clear the alternative address of a neighbour since this address is not
+ * valid anymore
+ *
+ * @param n the neighbour
+ */
+static void
+unset_alternative_address (struct NeighbourMapEntry *n)
+{
+ /* Unset primary address */
+ free_address (&n->alternative_address);
+}
/**
* Free a neighbour map entry.
n->suggest_handle = NULL;
}
+ /* Cancel the disconnect task */
+ if (GNUNET_SCHEDULER_NO_TASK != n->delayed_disconnect_task)
+ {
+ GNUNET_SCHEDULER_cancel (n->delayed_disconnect_task);
+ n->delayed_disconnect_task = GNUNET_SCHEDULER_NO_TASK;
+ }
+
/* Cancel the master task */
if (GNUNET_SCHEDULER_NO_TASK != n->task)
{
{
struct SessionDisconnectMessage disconnect_msg;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Sending DISCONNECT message to peer `%4s'\n",
GNUNET_i2s (&n->id));
disconnect_msg.header.size = htons (sizeof (struct SessionDisconnectMessage));
&disconnect_msg.purpose,
&disconnect_msg.signature));
- (void) send_with_session (n,
- (const char *) &disconnect_msg, sizeof (disconnect_msg),
- UINT32_MAX, GNUNET_TIME_UNIT_FOREVER_REL,
- GNUNET_NO, &send_disconnect_cont, NULL);
+ (void) send_with_session (n, (const char *) &disconnect_msg,
+ sizeof (disconnect_msg), UINT32_MAX, GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_NO, &send_disconnect_cont, NULL );
GNUNET_STATISTICS_update (GST_stats,
gettext_noop
("# DISCONNECT messages sent"), 1,
set_state (n, GNUNET_TRANSPORT_PS_DISCONNECT);
break;
case GNUNET_TRANSPORT_PS_CONNECT_RECV_ATS:
- case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST:
/* we never ACK'ed the other peer's request, no need to send DISCONNECT */
- set_state (n, GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED);
free_neighbour (n, GNUNET_NO);
return;
case GNUNET_TRANSPORT_PS_CONNECT_RECV_ACK:
send_disconnect (n);
set_state (n, GNUNET_TRANSPORT_PS_DISCONNECT);
break;
+ case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT:
case GNUNET_TRANSPORT_PS_CONNECTED:
- 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:
/* we are currently connected, need to send disconnect and do
internal notifications and update statistics */
send_disconnect (n);
set_state (n, GNUNET_TRANSPORT_PS_DISCONNECT);
break;
case GNUNET_TRANSPORT_PS_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, GNUNET_TRANSPORT_PS_DISCONNECT);
- break;
+ /* Disconnecting while waiting for an ATS address to reconnect,
+ * cannot send DISCONNECT */
+ free_neighbour (n, GNUNET_NO);
+ return;
case GNUNET_TRANSPORT_PS_DISCONNECT:
/* already disconnected, ignore */
break;
uint32_t nonce;
GNUNET_assert ((GNUNET_TRANSPORT_PS_CONNECTED == n->state) ||
- (GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_BLACKLIST == n->state) ||
(GNUNET_TRANSPORT_PS_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 */
return;
}
- if (GNUNET_TRANSPORT_PS_CONNECT_SENT != n->state)
+ if ( (GNUNET_TRANSPORT_PS_CONNECT_SENT != n->state) &&
+ (GNUNET_TRANSPORT_PS_RECONNECT_SENT != n->state) &&
+ (GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT != n->state))
{
/* CONNECT continuation was called after neighbor changed state,
* for example due to a time out for the state or the session
GST_plugins_a2s (n->primary_address.address),
n->primary_address.session);
- /* Failed to send CONNECT message with this address */
- GNUNET_ATS_address_destroyed (GST_ats, n->primary_address.address,
- n->primary_address.session);
- GNUNET_ATS_address_destroyed (GST_ats, n->primary_address.address,
- NULL);
-
- /* Remove address and request and additional one */
- unset_primary_address (n);
-
- set_state_and_timeout (n, GNUNET_TRANSPORT_PS_INIT_ATS,
- GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
- return;
+ switch (n->state) {
+ case GNUNET_TRANSPORT_PS_CONNECT_SENT:
+ /* Remove address and request and additional one */
+ GNUNET_ATS_address_destroyed (GST_ats, n->primary_address.address,
+ n->primary_address.session);
+ GNUNET_ATS_address_destroyed (GST_ats, n->primary_address.address, NULL );
+ unset_primary_address (n);
+ set_state_and_timeout (n, GNUNET_TRANSPORT_PS_INIT_ATS,
+ GNUNET_TIME_relative_to_absolute (FAST_RECONNECT_TIMEOUT));
+ break;
+ case GNUNET_TRANSPORT_PS_RECONNECT_SENT:
+ /* Remove address and request and additional one */
+ GNUNET_ATS_address_destroyed (GST_ats, n->primary_address.address,
+ n->primary_address.session);
+ GNUNET_ATS_address_destroyed (GST_ats, n->primary_address.address, NULL );
+ unset_primary_address (n);
+ set_state_and_timeout (n, GNUNET_TRANSPORT_PS_RECONNECT_ATS,
+ GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
+ break;
+ case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT:
+ /* Remove address and request and go back to primary address */
+ GNUNET_STATISTICS_update (GST_stats, gettext_noop
+ ("# Failed attempts to switch addresses (failed to send CONNECT CONT)"), 1, GNUNET_NO);
+ GNUNET_ATS_address_destroyed (GST_ats, n->alternative_address.address,
+ n->alternative_address.session);
+ GNUNET_ATS_address_destroyed (GST_ats, n->alternative_address.address,
+ NULL );
+ unset_alternative_address (n);
+ set_state_and_timeout (n, GNUNET_TRANSPORT_PS_CONNECTED,
+ GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
+ break;
+ default:
+ GNUNET_break(0);
+ disconnect_neighbour (n);
+ break;
+ }
}
/**
struct SessionConnectMessage connect_msg;
struct NeighbourMapEntry *n;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Sending SESSION_CONNECT message to peer %s\n",
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "Sending SESSION_CONNECT message to peer `%s'\n",
GNUNET_i2s (&na->address->peer));
+
if (NULL == (papi = GST_plugins_find (na->address->transport_name)))
{
GNUNET_break (0);
GNUNET_break (0);
return;
}
- /* Hard failure to send the CONNECT message with this address:
- Destroy address and session */
+
+ switch (n->state) {
+ case GNUNET_TRANSPORT_PS_CONNECT_SENT:
+ /* Remove address and request and additional one */
+ unset_primary_address (n);
+ set_state_and_timeout (n, GNUNET_TRANSPORT_PS_INIT_ATS,
+ GNUNET_TIME_relative_to_absolute (FAST_RECONNECT_TIMEOUT));
+ /* Hard failure to send the CONNECT message with this address:
+ Destroy address and session */
+ break;
+ case GNUNET_TRANSPORT_PS_RECONNECT_SENT:
+ /* Remove address and request and additional one */
+ unset_primary_address (n);
+ set_state_and_timeout (n, GNUNET_TRANSPORT_PS_RECONNECT_ATS,
+ GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
+ break;
+ case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT:
+ GNUNET_STATISTICS_update (GST_stats, gettext_noop
+ ("# Failed attempts to switch addresses (failed to send CONNECT)"), 1, GNUNET_NO);
+ /* Remove address and request and additional one */
+ unset_alternative_address (n);
+ set_state_and_timeout (n, GNUNET_TRANSPORT_PS_CONNECTED,
+ GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
+ break;
+ default:
+ GNUNET_break (0);
+ disconnect_neighbour (n);
+ break;
+ }
GNUNET_ATS_address_destroyed (GST_ats, na->address, na->session);
GNUNET_ATS_address_destroyed (GST_ats, na->address, NULL);
-
- /* Remove address and request and additional one */
- unset_primary_address (n);
- set_state_and_timeout (n, GNUNET_TRANSPORT_PS_INIT_ATS,
- GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
- return;
}
-
GST_neighbours_notify_data_sent (&na->address->peer,
na->address,
na->session,
sizeof (struct SessionConnectMessage));
-
}
/* Remove address and request and additional one */
unset_primary_address (n);
-
+ n->ack_state = ACK_SEND_CONNECT_ACK;
set_state_and_timeout (n, GNUNET_TRANSPORT_PS_CONNECT_RECV_ATS,
GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
return;
* @param address address to use
* @param session session to use
* @param timestamp timestamp to use for the ACK message
+ * @return GNUNET_SYSERR if sending immediately failed, GNUNET_OK otherwise
*/
static void
send_connect_ack_message (const struct GNUNET_HELLO_Address *address,
struct SessionConnectMessage connect_msg;
struct NeighbourMapEntry *n;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Sending CONNECT_ACK to peer `%s'\n",
GNUNET_i2s (&address->peer));
+
if (NULL == (papi = GST_plugins_find (address->transport_name)))
{
GNUNET_break (0);
/* Remove address and request and additional one */
unset_primary_address (n);
+ n->ack_state = ACK_SEND_CONNECT_ACK;
set_state_and_timeout (n, GNUNET_TRANSPORT_PS_CONNECT_RECV_ATS,
GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
return;
/* struct NeighbourMapEntry *n = cls; */
struct QuotaNotificationRequest *qnr = value;
- GNUNET_CONTAINER_multipeermap_remove (registered_quota_notifications, key,
- qnr);
+ GNUNET_break (GNUNET_OK != GNUNET_CONTAINER_multipeermap_remove (registered_quota_notifications, key,
+ qnr));
GNUNET_free(qnr->plugin);
GNUNET_free(qnr);
return n;
}
-
-/**
- * Check if the two given addresses are the same.
- * Actually only checks if the sessions are non-NULL
- * (which they should be) and then if they are identical;
- * the actual addresses don't matter if the session
- * pointers match anyway, and we must have session pointers
- * at this time.
- *
- * @param a1 first address to compare
- * @param a2 other address to compare
- * @return #GNUNET_NO if the addresses do not match, #GNUNET_YES if they do match
- */
-static int
-address_matches (const struct NeighbourAddress *a1,
- const struct NeighbourAddress *a2)
-{
- if ( (NULL == a1->session) ||
- (NULL == a2->session) )
- {
- GNUNET_break (0);
- return 0;
- }
- return (a1->session == a2->session) ? GNUNET_YES : GNUNET_NO;
-}
-
-
/* We received a address suggestion after requesting an address in
* try_connect or after receiving a connect, switch to address
*/
case GNUNET_TRANSPORT_PS_INIT_ATS:
case GNUNET_TRANSPORT_PS_CONNECT_SENT:
case GNUNET_TRANSPORT_PS_CONNECT_RECV_ATS:
- case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST:
case GNUNET_TRANSPORT_PS_CONNECT_RECV_ACK:
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Ignoring request to try to connect to `%s', already trying!\n",
return; /* already trying */
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:
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Ignoring request to try to connect, already connected to `%s'!\n",
}
-/**
- * Function called with the result of a blacklist check.
- *
- * @param cls closure with the `struct BlackListCheckContext`
- * @param peer peer this check affects
- * @param result #GNUNET_OK if the address is allowed
- */
-static void
-handle_connect_blacklist_check_cont (void *cls,
- const struct GNUNET_PeerIdentity *peer,
- int result)
-{
- struct BlackListCheckContext *bcc = cls;
- struct NeighbourMapEntry *n;
-
- bcc->bc = NULL;
- GNUNET_CONTAINER_DLL_remove (bc_head,
- bc_tail,
- bcc);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Connection to new address of peer `%s' based on blacklist is `%s'\n",
- GNUNET_i2s (peer),
- (GNUNET_OK == result) ? "allowed" : "FORBIDDEN");
-
- if (NULL == (n = lookup_neighbour (peer)))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "No neighbor entry for peer `%s', ignoring blacklist result\n",
- GNUNET_i2s (peer));
- goto cleanup; /* nobody left to care about new address */
- }
-
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Blacklist check after CONNECT for peer `%s' in state %s/%s: %s\n",
- GNUNET_i2s (peer),
- GNUNET_TRANSPORT_ps2s (n->state),
- print_ack_state (n->ack_state),
- (GNUNET_OK == result) ? "OK" : "FAIL");
-
- if (GNUNET_OK == result)
- {
- /* Blacklist agreed on connecting to a peer with this address, notify ATS */
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Notifying ATS peer's `%s' %s address `%s' session %p\n",
- GNUNET_i2s (peer),
- (GNUNET_YES == GNUNET_HELLO_address_check_option(bcc->na.address,
- GNUNET_HELLO_ADDRESS_INFO_INBOUND)) ? "inbound" : "outbound",
- GST_plugins_a2s (bcc->na.address), bcc->na.session);
- GST_ats_add_address (bcc->na.address, bcc->na.session, NULL, 0);
- }
-
- switch (n->state)
- {
- case GNUNET_TRANSPORT_PS_NOT_CONNECTED:
- /* This should not be possible */
- GNUNET_break (0);
- free_neighbour (n, GNUNET_NO);
- break;
- case GNUNET_TRANSPORT_PS_INIT_ATS:
- /* Waiting on ATS suggestion */
- break;
- case GNUNET_TRANSPORT_PS_CONNECT_SENT:
-#if 0
- /* TODO Why should I send an connect ACK message */
- /* waiting on CONNECT_ACK, send ACK if one is pending */
-
- if ( (GNUNET_OK == result) &&
- (ACK_SEND_CONNECT_ACK == n->ack_state) )
- {
- n->ack_state = ACK_SEND_SESSION_ACK;
- send_connect_ack_message (n->primary_address.address,
- n->primary_address.session,
- n->connect_ack_timestamp);
- }
-#endif
- break;
- case GNUNET_TRANSPORT_PS_CONNECT_RECV_ATS:
- /* waiting on ATS suggestion, don't care about blacklist */
- break;
- case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST:
- if (GNUNET_YES != address_matches (&bcc->na, &n->primary_address))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Blacklist result ignored, as it is not for our primary address\n");
- break; /* result for an address we currently don't care about */
- }
- if (GNUNET_OK == result)
- {
- set_state_and_timeout (n, GNUNET_TRANSPORT_PS_CONNECT_RECV_ACK,
- GNUNET_TIME_relative_to_absolute (SETUP_CONNECTION_TIMEOUT));
- send_connect_ack_message (bcc->na.address,
- bcc->na.session,
- n->connect_ack_timestamp);
- if (ACK_SEND_CONNECT_ACK == n->ack_state)
- n->ack_state = ACK_SEND_SESSION_ACK;
- }
- else
- {
- struct GNUNET_TRANSPORT_PluginFunctions *plugin;
-
- plugin = GST_plugins_find (bcc->na.address->transport_name);
- if ( (NULL != plugin) &&
- (NULL != bcc->na.session) )
- {
- plugin->disconnect_session (plugin->cls,
- bcc->na.session);
- break;
- }
- GNUNET_break (NULL != plugin);
- free_address (&n->primary_address);
- set_state_and_timeout (n, GNUNET_TRANSPORT_PS_INIT_ATS,
- GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
- GNUNET_ATS_reset_backoff (GST_ats, peer);
- }
- break;
- case GNUNET_TRANSPORT_PS_CONNECT_RECV_ACK:
- /* waiting on SESSION_ACK, send ACK if one is pending */
- if ( (GNUNET_OK == result) &&
- (ACK_SEND_CONNECT_ACK == n->ack_state) )
- {
- /* TODO: Why should this happen? */
- /* *Debug message: */ GNUNET_break (0);
-
- n->ack_state = ACK_SEND_SESSION_ACK;
- send_connect_ack_message (n->primary_address.address,
- n->primary_address.session,
- n->connect_ack_timestamp);
- }
- break;
- case GNUNET_TRANSPORT_PS_CONNECTED:
- /* already connected, don't care about blacklist */
- break;
- case GNUNET_TRANSPORT_PS_RECONNECT_ATS:
- /* still waiting on ATS suggestion, don't care about blacklist */
- break;
- case GNUNET_TRANSPORT_PS_RECONNECT_BLACKLIST:
- if ( (GNUNET_OK == result) &&
- (ACK_SEND_CONNECT_ACK == n->ack_state) )
- {
- n->ack_state = ACK_SEND_SESSION_ACK;
- send_connect_ack_message (bcc->na.address,
- bcc->na.session,
- n->connect_ack_timestamp);
- }
- if (GNUNET_YES != address_matches (&bcc->na, &n->primary_address))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Blacklist result ignored, as it is not for our primary address\n");
- break; /* result for an address we currently don't care about */
- }
- if (GNUNET_OK == result)
- {
- set_state_and_timeout (n, GNUNET_TRANSPORT_PS_RECONNECT_SENT,
- GNUNET_TIME_relative_to_absolute (FAST_RECONNECT_TIMEOUT));
- send_session_connect (&n->primary_address);
- }
- else
- {
- set_state_and_timeout (n, GNUNET_TRANSPORT_PS_RECONNECT_ATS,
- GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
- }
- break;
- case GNUNET_TRANSPORT_PS_RECONNECT_SENT:
- /* waiting on CONNECT_ACK, don't care about blacklist */
- if ( (GNUNET_OK == result) &&
- (ACK_SEND_CONNECT_ACK == n->ack_state) )
- {
- n->ack_state = ACK_SEND_SESSION_ACK;
- send_connect_ack_message (n->primary_address.address,
- n->primary_address.session,
- n->connect_ack_timestamp);
- }
- break;
- case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_BLACKLIST:
- if (GNUNET_YES != address_matches (&bcc->na, &n->alternative_address))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Blacklist result ignored, as it is not for our primary address\n");
- break; /* result for an address we currently don't care about */
- }
- if (GNUNET_OK == result)
- {
- send_session_connect (&n->alternative_address);
- set_state (n, GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT);
- }
- else
- {
- set_state(n, GNUNET_TRANSPORT_PS_CONNECTED);
- free_address (&n->alternative_address);
- }
- break;
- case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT:
- /* waiting on CONNECT_ACK, don't care about blacklist */
- if ( (GNUNET_OK == result) &&
- (ACK_SEND_CONNECT_ACK == n->ack_state) )
- {
- n->ack_state = ACK_SEND_SESSION_ACK;
- send_connect_ack_message (n->primary_address.address,
- n->primary_address.session,
- n->connect_ack_timestamp);
- }
- break;
- case GNUNET_TRANSPORT_PS_DISCONNECT:
- /* Nothing to do here, ATS will already do what can be done */
- break;
- case GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED:
- /* should not be possible */
- GNUNET_assert (0);
- break;
- default:
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Unhandled state `%s'\n",
- GNUNET_TRANSPORT_ps2s (n->state));
- GNUNET_break (0);
- free_neighbour (n, GNUNET_NO);
- break;
- }
- cleanup:
- GNUNET_HELLO_address_free (bcc->na.address);
- GNUNET_free (bcc);
-}
-
-
-/**
- * We received a CONNECT message and want to know if connecting to a particular
- * peer via a particular address is allowed. Check it!
- *
- * @param peer identity of the peer to switch the address for
- * @param ts time at which the check was initiated
- * @param address address of the other peer, NULL if other peer
- * connected to us
- * @param session session to use (or NULL)
- */
-static void
-connect_check_blacklist (const struct GNUNET_PeerIdentity *peer,
- struct GNUNET_TIME_Absolute ts,
- const struct GNUNET_HELLO_Address *address,
- struct Session *session)
-{
- struct BlackListCheckContext *bcc;
- struct GST_BlacklistCheck *bc;
-
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Checking peer `%s' against blacklist\n",
- GNUNET_i2s (peer));
- bcc = GNUNET_new (struct BlackListCheckContext);
- bcc->na.address = GNUNET_HELLO_address_copy (address);
- bcc->na.session = session;
- bcc->na.connect_timestamp = ts;
- GNUNET_CONTAINER_DLL_insert (bc_head,
- bc_tail,
- bcc);
- if (NULL != (bc = GST_blacklist_test_allowed (peer,
- (NULL != address) ? address->transport_name : NULL,
- &handle_connect_blacklist_check_cont, bcc)))
- bcc->bc = bc;
- /* if NULL == bc, 'cont' was already called and 'bcc' already free'd, so
- we must only store 'bc' if 'bc' is non-NULL... */
-}
-
-
/**
* We received a 'SESSION_CONNECT' message from the other peer.
* Consider switching to it.
*
* @param message possibly a 'struct SessionConnectMessage' (check format)
* @param peer identity of the peer to switch the address for
- * @param address address of the other peer, NULL if other peer
- * connected to us
- * @param session session to use (or NULL)
* @return #GNUNET_OK if the message was fine, #GNUNET_SYSERR on serious error
*/
int
GST_neighbours_handle_connect (const struct GNUNET_MessageHeader *message,
- const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_HELLO_Address *address,
- struct Session *session)
+ const struct GNUNET_PeerIdentity *peer)
{
const struct SessionConnectMessage *scm;
struct NeighbourMapEntry *n;
struct GNUNET_TIME_Absolute ts;
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Received CONNECT message from peer `%s' with `%s' %p\n",
- GNUNET_i2s (peer), GST_plugins_a2s (address), session);
if (ntohs (message->size) != sizeof (struct SessionConnectMessage))
{
GNUNET_break_op (0);
set_state_and_timeout (n, GNUNET_TRANSPORT_PS_CONNECT_RECV_ATS,
GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
break;
- case GNUNET_TRANSPORT_PS_CONNECT_SENT:
case GNUNET_TRANSPORT_PS_CONNECT_RECV_ATS:
- case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST:
+ /* We already wait for an address to send an CONNECT_ACK */
+ break;
+ case GNUNET_TRANSPORT_PS_CONNECT_SENT:
case GNUNET_TRANSPORT_PS_CONNECT_RECV_ACK:
- /* It can never hurt to have an alternative address in the above cases,
- see if it is allowed */
- connect_check_blacklist (peer, ts, address, session);
+ /* Send ACK immediately */
+ n->ack_state = ACK_SEND_SESSION_ACK;
+ send_connect_ack_message (n->primary_address.address,
+ n->primary_address.session, ts);
break;
case GNUNET_TRANSPORT_PS_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 */
+ /* we are already connected and can thus send the ACK immediately */
GNUNET_assert (NULL != n->primary_address.address);
GNUNET_assert (NULL != n->primary_address.session);
- n->ack_state = ACK_UNDEFINED;
+ n->ack_state = ACK_SEND_SESSION_ACK;
send_connect_ack_message (n->primary_address.address,
- n->primary_address.session, ts);
- connect_check_blacklist (peer, ts, address, session);
+ n->primary_address.session, ts);
break;
case GNUNET_TRANSPORT_PS_RECONNECT_ATS:
- case GNUNET_TRANSPORT_PS_RECONNECT_BLACKLIST:
+ /* We wait for ATS address suggestion */
+ break;
case GNUNET_TRANSPORT_PS_RECONNECT_SENT:
- /* It can never hurt to have an alternative address in the above cases,
- see if it is allowed */
- connect_check_blacklist (peer, ts, address, session);
+ /* We received a CONNECT message while waiting for a CONNECT_ACK in fast
+ * reconnect. Send CONNECT_ACK immediately */
+ n->ack_state = ACK_SEND_SESSION_ACK;
+ send_connect_ack_message (n->primary_address.address,
+ n->primary_address.session, n->connect_ack_timestamp);
break;
- case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_BLACKLIST:
case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT:
- /* we are already connected and can thus send the ACK immediately;
+ /* 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 */
GNUNET_assert (NULL != n->primary_address.address);
GNUNET_assert (NULL != n->primary_address.session);
- n->ack_state = ACK_UNDEFINED;
+ n->ack_state = ACK_SEND_SESSION_ACK;
send_connect_ack_message (n->primary_address.address,
- n->primary_address.session, ts);
- connect_check_blacklist (peer, ts, address, session);
+ n->primary_address.session, ts);
break;
case GNUNET_TRANSPORT_PS_DISCONNECT:
- /* get rid of remains without terminating sessions, ready to re-try */
+ /* Get rid of remains without terminating sessions, ready to re-try */
free_neighbour (n, GNUNET_YES);
n = setup_neighbour (peer);
- /* Remember the CONNECT timestamp for ACK message */
+ /* Remember the CONNECT time stamp for ACK message */
n->ack_state = ACK_SEND_CONNECT_ACK;
n->connect_ack_timestamp = ts;
/* Request an address for the peer */
struct GNUNET_TRANSPORT_PluginFunctions *papi;
struct NeighbourMapEntry *n;
+ papi = GST_plugins_find (blc_ctx->address->transport_name);
+
if ( (NULL == (n = lookup_neighbour (peer))) || (result == GNUNET_NO) ||
- (NULL == (papi = GST_plugins_find (blc_ctx->address->transport_name))) )
+ (NULL == (papi)) )
{
if (NULL == n)
{
blc_ctx->session,
GNUNET_i2s (&blc_ctx->address->peer));
}
- if (NULL == (papi = GST_plugins_find (blc_ctx->address->transport_name)))
+ if (NULL == papi)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Plugin `%s' for suggested address `%s' session %p for peer `%s' is not available\n",
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Blacklist accepted to switch to suggested address `%s' session %p for peer `%s'\n",
+ "Blacklist accepted address `%s' session %p for peer `%s'\n",
GST_plugins_a2s (blc_ctx->address),
blc_ctx->session,
GNUNET_i2s (&blc_ctx->address->peer));
* set primary address and send CONNECT message*/
set_primary_address (n, blc_ctx->address, blc_ctx->session,
blc_ctx->bandwidth_in, blc_ctx->bandwidth_out, GNUNET_NO);
+ if ( (ACK_SEND_CONNECT_ACK == n->ack_state) )
+ {
+ /* Send pending CONNECT_ACK message */
+ n->ack_state = ACK_SEND_SESSION_ACK;
+ send_connect_ack_message (n->primary_address.address,
+ n->primary_address.session, n->connect_ack_timestamp);
+ }
set_state_and_timeout (n, GNUNET_TRANSPORT_PS_CONNECT_SENT,
GNUNET_TIME_relative_to_absolute (SETUP_CONNECTION_TIMEOUT));
send_session_connect (&n->primary_address);
break;
case GNUNET_TRANSPORT_PS_CONNECT_SENT:
- /* waiting on CONNECT_ACK, send ACK if one is pending */
+ /* ATS suggested a new address while waiting for an CONNECT_ACK:
+ * Switch and send new CONNECT */
+ /* ATS suggests a different address, switch again */
+ set_primary_address (n, blc_ctx->address, blc_ctx->session,
+ blc_ctx->bandwidth_in, blc_ctx->bandwidth_out, GNUNET_NO);
if (ACK_SEND_CONNECT_ACK == n->ack_state)
{
+ /* Send pending CONNECT_ACK message */
n->ack_state = ACK_SEND_SESSION_ACK;
send_connect_ack_message (n->primary_address.address,
- n->primary_address.session,
- n->connect_ack_timestamp);
+ n->primary_address.session, n->connect_ack_timestamp);
}
- /* ATS suggests a different address, switch again */
- set_primary_address (n, blc_ctx->address, blc_ctx->session,
- blc_ctx->bandwidth_in, blc_ctx->bandwidth_out, GNUNET_NO);
set_state_and_timeout (n, GNUNET_TRANSPORT_PS_CONNECT_SENT,
GNUNET_TIME_relative_to_absolute (SETUP_CONNECTION_TIMEOUT));
send_session_connect (&n->primary_address);
send_connect_ack_message (n->primary_address.address,
n->primary_address.session,
n->connect_ack_timestamp);
- if (ACK_SEND_CONNECT_ACK == n->ack_state)
+ if ( (ACK_SEND_CONNECT_ACK == n->ack_state) ||
+ (ACK_UNDEFINED == n->ack_state) )
n->ack_state = ACK_SEND_SESSION_ACK;
-
break;
- case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST:
case GNUNET_TRANSPORT_PS_CONNECT_RECV_ACK:
/* ATS asks us to switch while we were trying to connect; switch to new
address and check blacklist again */
+ if ( (ACK_SEND_CONNECT_ACK == n->ack_state) )
+ {
+ n->ack_state = ACK_SEND_SESSION_ACK;
+ send_connect_ack_message (n->primary_address.address,
+ n->primary_address.session, n->connect_ack_timestamp);
+ }
set_primary_address (n, blc_ctx->address, blc_ctx->session,
blc_ctx->bandwidth_in, blc_ctx->bandwidth_out, GNUNET_NO);
- set_state_and_timeout (n, GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST,
- GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT));
- /* REMOVE */ connect_check_blacklist (&n->id, n->connect_ack_timestamp,
- blc_ctx->address, blc_ctx->session);
+ set_state_and_timeout (n, GNUNET_TRANSPORT_PS_CONNECT_RECV_ACK,
+ GNUNET_TIME_relative_to_absolute (SETUP_CONNECTION_TIMEOUT));
break;
case GNUNET_TRANSPORT_PS_CONNECTED:
GNUNET_assert (NULL != n->primary_address.address);
}
/* 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, GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_BLACKLIST);
set_alternative_address (n, blc_ctx->address, blc_ctx->session,
blc_ctx->bandwidth_in, blc_ctx->bandwidth_out);
- /* REMOVE */ connect_check_blacklist (&n->id, GNUNET_TIME_absolute_get (),
- blc_ctx->address, blc_ctx->session);
+ set_state_and_timeout (n, GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT,
+ GNUNET_TIME_relative_to_absolute (SETUP_CONNECTION_TIMEOUT));
+ GNUNET_STATISTICS_update (GST_stats, gettext_noop
+ ("# Attempts to switch addresses"), 1, GNUNET_NO);
+ send_session_connect (&n->alternative_address);
break;
case GNUNET_TRANSPORT_PS_RECONNECT_ATS:
set_primary_address (n, blc_ctx->address, blc_ctx->session,
blc_ctx->bandwidth_in, blc_ctx->bandwidth_out, GNUNET_NO);
- set_state_and_timeout (n, GNUNET_TRANSPORT_PS_RECONNECT_BLACKLIST,
- GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT));
- /* REMOVE */ connect_check_blacklist (&n->id, n->connect_ack_timestamp,
- blc_ctx->address, blc_ctx->session);
- break;
- case GNUNET_TRANSPORT_PS_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, blc_ctx->address, blc_ctx->session,
- blc_ctx->bandwidth_in, blc_ctx->bandwidth_out, GNUNET_NO);
- set_timeout (n, GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT));
- /* REMOVE */ connect_check_blacklist (&n->id, n->connect_ack_timestamp,
- blc_ctx->address, blc_ctx->session);
+ if ( (ACK_SEND_CONNECT_ACK == n->ack_state) )
+ {
+ /* Send pending CONNECT_ACK message */
+ n->ack_state = ACK_SEND_SESSION_ACK;
+ send_connect_ack_message (n->primary_address.address,
+ n->primary_address.session, n->connect_ack_timestamp);
+ }
+ set_state_and_timeout (n, GNUNET_TRANSPORT_PS_RECONNECT_SENT,
+ GNUNET_TIME_relative_to_absolute (FAST_RECONNECT_TIMEOUT));
+ send_session_connect (&n->primary_address);
break;
case GNUNET_TRANSPORT_PS_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, blc_ctx->address, blc_ctx->session,
- blc_ctx->bandwidth_in, blc_ctx->bandwidth_out, GNUNET_NO);
- set_state_and_timeout (n, GNUNET_TRANSPORT_PS_RECONNECT_BLACKLIST,
- GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT));
- /* REMOVE */ connect_check_blacklist (&n->id, n->connect_ack_timestamp,
- blc_ctx->address, blc_ctx->session);
- break;
- case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_BLACKLIST:
- if (n->primary_address.session == blc_ctx->session)
- {
- /* ATS switches back to still-active session */
- set_state(n, GNUNET_TRANSPORT_PS_CONNECTED);
- free_address (&n->alternative_address);
- break;
- }
- /* ATS asks us to switch a life connection, update blacklist check */
+ address and send CONNECT again */
set_primary_address (n, blc_ctx->address, blc_ctx->session,
blc_ctx->bandwidth_in, blc_ctx->bandwidth_out, GNUNET_NO);
- /* REMOVE */ connect_check_blacklist (&n->id, GNUNET_TIME_absolute_get (),
- blc_ctx->address, blc_ctx->session);
+ set_state_and_timeout (n, GNUNET_TRANSPORT_PS_RECONNECT_SENT,
+ GNUNET_TIME_relative_to_absolute (FAST_RECONNECT_TIMEOUT));
+ send_session_connect (&n->primary_address);
break;
case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT:
- if (n->primary_address.session == blc_ctx->session)
+ if ( (0 == GNUNET_HELLO_address_cmp(n->primary_address.address,
+ blc_ctx->address) && n->primary_address.session == blc_ctx->session) )
{
/* ATS switches back to still-active session */
free_address (&n->alternative_address);
set_state (n, GNUNET_TRANSPORT_PS_CONNECTED);
break;
}
- /* ATS asks us to switch a life connection, update blacklist check */
- set_state (n, GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_BLACKLIST);
+ /* ATS asks us to switch a life connection, send */
set_alternative_address (n, blc_ctx->address, blc_ctx->session,
blc_ctx->bandwidth_in, blc_ctx->bandwidth_out);
- /* REMOVE */ connect_check_blacklist (&n->id, GNUNET_TIME_absolute_get (),
- blc_ctx->address, blc_ctx->session);
+ set_state_and_timeout (n, GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT,
+ GNUNET_TIME_relative_to_absolute (SETUP_CONNECTION_TIMEOUT));
+ send_session_connect (&n->alternative_address);
break;
case GNUNET_TRANSPORT_PS_DISCONNECT:
/* not going to switch addresses while disconnecting */
{
struct NeighbourMapEntry *n;
struct GST_BlacklistCheck *blc;
- struct GNUNET_TRANSPORT_PluginFunctions *papi;
struct BlacklistCheckSwitchContext *blc_ctx;
int c;
}
/* Check if plugin is available */
- if (NULL == (papi = GST_plugins_find (address->transport_name)))
+ if (NULL == (GST_plugins_find (address->transport_name)))
{
/* we don't have the plugin for this address */
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "ATS tells us to switch to %s address '%s' session %p for "
+ "ATS suggests %s address '%s' session %p for "
"peer `%s' in state %s/%s (quota in/out %u %u )\n",
GNUNET_HELLO_address_check_option (address,
GNUNET_HELLO_ADDRESS_INFO_INBOUND) ? "inbound" : "outbound",
n->task = GNUNET_SCHEDULER_NO_TASK;
delay = GNUNET_TIME_absolute_get_remaining (n->timeout);
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Master task runs for neighbour `%s' in state %s with timeout in %s\n",
GNUNET_i2s (&n->id),
GNUNET_TRANSPORT_ps2s(n->state),
GNUNET_ATS_address_destroyed (GST_ats, n->primary_address.address, NULL);
/* Remove address and request and additional one */
- GNUNET_break (0);
unset_primary_address (n);
set_state_and_timeout (n, GNUNET_TRANSPORT_PS_INIT_ATS,
GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
case GNUNET_TRANSPORT_PS_CONNECT_RECV_ATS:
if (0 == delay.rel_value_us)
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Connection to `%s' timed out waiting ATS to provide address to use for CONNECT_ACK\n",
GNUNET_i2s (&n->id));
free_neighbour (n, GNUNET_NO);
return;
}
break;
- case GNUNET_TRANSPORT_PS_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));
- free_neighbour (n, GNUNET_NO);
- return;
- }
- break;
case GNUNET_TRANSPORT_PS_CONNECT_RECV_ACK:
if (0 == delay.rel_value_us)
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Connection to `%s' timed out waiting for other peer to send SESSION_ACK\n",
GNUNET_i2s (&n->id));
disconnect_neighbour (n);
case GNUNET_TRANSPORT_PS_CONNECTED:
if (0 == delay.rel_value_us)
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Connection to `%s' timed out, missing KEEPALIVE_RESPONSEs\n",
GNUNET_i2s (&n->id));
disconnect_neighbour (n);
case GNUNET_TRANSPORT_PS_RECONNECT_ATS:
if (0 == delay.rel_value_us)
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Connection to `%s' timed out, waiting for ATS replacement address\n",
GNUNET_i2s (&n->id));
disconnect_neighbour (n);
return;
}
break;
- case GNUNET_TRANSPORT_PS_RECONNECT_BLACKLIST:
- if (0 == delay.rel_value_us)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Connection to `%s' timed out, waiting for BLACKLIST to approve replacement address\n",
- GNUNET_i2s (&n->id));
- disconnect_neighbour (n);
- return;
- }
- break;
case GNUNET_TRANSPORT_PS_RECONNECT_SENT:
if (0 == delay.rel_value_us)
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Connection to `%s' timed out, waiting for other peer to CONNECT_ACK replacement address\n",
GNUNET_i2s (&n->id));
disconnect_neighbour (n);
return;
}
break;
- case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_BLACKLIST:
- if (0 == delay.rel_value_us)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Connection to `%s' timed out, missing KEEPALIVE_RESPONSEs\n",
- GNUNET_i2s (&n->id));
- disconnect_neighbour (n);
- return;
- }
- try_transmission_to_peer (n);
- send_keepalive (n);
- break;
case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT:
if (0 == delay.rel_value_us)
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Connection to `%s' timed out, missing KEEPALIVE_RESPONSEs (after trying to CONNECT on alternative address)\n",
GNUNET_i2s (&n->id));
+ GNUNET_STATISTICS_update (GST_stats, gettext_noop
+ ("# Failed attempts to switch addresses (no response)"), 1, GNUNET_NO);
disconnect_neighbour (n);
return;
}
send_keepalive (n);
break;
case GNUNET_TRANSPORT_PS_DISCONNECT:
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Cleaning up connection to `%s' after sending DISCONNECT\n",
GNUNET_i2s (&n->id));
free_neighbour (n, GNUNET_NO);
break;
}
if ( (GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT == n->state) ||
- (GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_BLACKLIST == n->state) ||
(GNUNET_TRANSPORT_PS_CONNECTED == n->state) )
{
- /* if we are *now* in one of these three states, we're sending
+ /* if we are *now* in one of the two states, we're sending
keep alive messages, so we need to consider the keepalive
delay, not just the connection timeout */
delay = GNUNET_TIME_relative_min (GNUNET_TIME_absolute_get_remaining (n->keep_alive_time),
{
struct GNUNET_MessageHeader msg;
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Sending SESSION_ACK message to peer `%s'\n",
+ GNUNET_i2s (&n->id));
+
msg.size = htons (sizeof (struct GNUNET_MessageHeader));
msg.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_ACK);
(void) send_with_session(n,
send_session_ack_message (n);
break;
case GNUNET_TRANSPORT_PS_CONNECT_RECV_ATS:
- case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST:
case GNUNET_TRANSPORT_PS_CONNECT_RECV_ACK:
GNUNET_STATISTICS_update (GST_stats,
gettext_noop
1, GNUNET_NO);
break;
case GNUNET_TRANSPORT_PS_CONNECTED:
- /* duplicate CONNECT_ACK, let's answer by duplciate SESSION_ACK just in case */
+ /* duplicate CONNECT_ACK, let's answer by duplicate SESSION_ACK just in case */
send_session_ack_message (n);
break;
case GNUNET_TRANSPORT_PS_RECONNECT_ATS:
- case GNUNET_TRANSPORT_PS_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,
1, GNUNET_NO);
break;
case GNUNET_TRANSPORT_PS_RECONNECT_SENT:
- /* new address worked; go back to connected! */
+ /* Reconnecting with new address address worked; go back to connected! */
set_state_and_timeout (n, GNUNET_TRANSPORT_PS_CONNECTED,
GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT));
send_session_ack_message (n);
break;
- case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_BLACKLIST:
- /* duplicate CONNECT_ACK, let's answer by duplciate SESSION_ACK just in case */
- send_session_ack_message (n);
- break;
case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT:
/* new address worked; adopt it and go back to connected! */
set_state_and_timeout (n, GNUNET_TRANSPORT_PS_CONNECTED,
GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT));
GNUNET_break (GNUNET_NO == n->alternative_address.ats_active);
+ /* Notify about session... perhaps we obtained it */
GST_ats_add_address (n->alternative_address.address,
- n->alternative_address.session,
- NULL, 0);
+ n->alternative_address.session, NULL, 0);
+ /* Set primary addresses */
set_primary_address (n, n->alternative_address.address,
n->alternative_address.session, n->alternative_address.bandwidth_in,
n->alternative_address.bandwidth_out, GNUNET_YES);
+ GNUNET_STATISTICS_update (GST_stats, gettext_noop
+ ("# Successful attempts to switch addresses"), 1, GNUNET_NO);
+
free_address (&n->alternative_address);
send_session_ack_message (n);
break;
{
if (session == n->alternative_address.session)
{
- if ( (GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_BLACKLIST == n->state) ||
- (GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT == n->state) )
+ if ( (GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT == n->state) )
set_state (n, GNUNET_TRANSPORT_PS_CONNECTED);
else
- GNUNET_break (0);
- free_address (&n->alternative_address);
+ free_address (&n->alternative_address);
}
return GNUNET_NO; /* doesn't affect us further */
}
/* The session used to send the CONNECT terminated:
* this implies a connect error*/
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Could not send CONNECT message with address `%s' session %p: session terminated, requesting new address\n",
- GST_plugins_a2s (n->primary_address.address), n->primary_address.session,
+ "Failed to send CONNECT in %s with `%s' %p: session terminated\n",
+ "CONNECT_SENT",
+ GST_plugins_a2s (n->primary_address.address),
+ n->primary_address.session,
GNUNET_i2s (peer));
+
+ /* Destroy the address since it cannot be used */
GNUNET_ATS_address_destroyed (GST_ats, n->primary_address.address, NULL);
unset_primary_address (n);
set_state_and_timeout (n, GNUNET_TRANSPORT_PS_INIT_ATS,
GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
break;
case GNUNET_TRANSPORT_PS_CONNECT_RECV_ATS:
- case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST:
case GNUNET_TRANSPORT_PS_CONNECT_RECV_ACK:
/* error on inbound session; free neighbour entirely */
free_address (&n->primary_address);
free_neighbour (n, GNUNET_NO);
return GNUNET_YES;
case GNUNET_TRANSPORT_PS_CONNECTED:
+ /* Our primary connection died, try a fast reconnect */
unset_primary_address (n);
set_state_and_timeout (n, GNUNET_TRANSPORT_PS_RECONNECT_ATS,
GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
/* we don't have an address, how can it go down? */
GNUNET_break (0);
break;
- case GNUNET_TRANSPORT_PS_RECONNECT_BLACKLIST:
case GNUNET_TRANSPORT_PS_RECONNECT_SENT:
- set_state_and_timeout (n, GNUNET_TRANSPORT_PS_RECONNECT_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
- break;
- case GNUNET_TRANSPORT_PS_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, GNUNET_TRANSPORT_PS_RECONNECT_BLACKLIST, GNUNET_TIME_relative_to_absolute (FAST_RECONNECT_TIMEOUT));
- n->primary_address = n->alternative_address;
- memset (&n->alternative_address, 0, sizeof (struct NeighbourAddress));
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "Failed to send CONNECT in %s with `%s' %p: session terminated\n",
+ "RECONNECT_SENT",
+ GST_plugins_a2s (n->primary_address.address),
+ n->primary_address.session,
+ GNUNET_i2s (peer));
+
+ /* Destroy the address since it cannot be used */
+ GNUNET_ATS_address_destroyed (GST_ats, n->primary_address.address, NULL);
+ unset_primary_address (n);
+ set_state_and_timeout (n, GNUNET_TRANSPORT_PS_RECONNECT_ATS,
+ GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
break;
case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT:
/* primary went down while we were waiting for CONNECT_ACK on secondary;
secondary as primary */
+
+ /* Destroy the inbound address since it cannot be used */
+ if (GNUNET_YES
+ == GNUNET_HELLO_address_check_option (n->primary_address.address,
+ GNUNET_HELLO_ADDRESS_INFO_INBOUND))
+ GNUNET_ATS_address_destroyed (GST_ats, n->primary_address.address, NULL);
free_address (&n->primary_address);
n->primary_address = n->alternative_address;
memset (&n->alternative_address, 0, sizeof (struct NeighbourAddress));
- set_state_and_timeout (n, GNUNET_TRANSPORT_PS_RECONNECT_SENT, GNUNET_TIME_relative_to_absolute (FAST_RECONNECT_TIMEOUT));
+ set_state_and_timeout (n, GNUNET_TRANSPORT_PS_RECONNECT_ATS,
+ GNUNET_TIME_relative_to_absolute (FAST_RECONNECT_TIMEOUT));
break;
case GNUNET_TRANSPORT_PS_DISCONNECT:
free_address (&n->primary_address);
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
- /* check if we are in a plausible state for having sent
- a CONNECT_ACK. If not, return, otherwise break */
- if ( ( (GNUNET_TRANSPORT_PS_CONNECT_RECV_ACK != n->state) &&
- (GNUNET_TRANSPORT_PS_CONNECT_SENT != n->state) ) ||
- (ACK_SEND_SESSION_ACK != n->ack_state) )
+ /* Check if we are in a plausible state for having sent
+ a CONNECT_ACK. If not, return, otherwise break.
+
+ The remote peers sends a SESSION_ACK as a response for a CONNECT_ACK
+ message.
+
+ We expect a SESSION_ACK:
+ - If a remote peer has sent a CONNECT, we responded with a CONNECT_ACK and
+ now wait for the ACK to finally be connected
+ - If we sent a CONNECT_ACK to this peer before */
+
+ if ( (GNUNET_TRANSPORT_PS_CONNECT_RECV_ACK != n->state) &&
+ (ACK_SEND_SESSION_ACK != n->ack_state))
{
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Received SESSION_ACK message from peer `%s' in state %s/%s\n",
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Received unexpected SESSION_ACK message from peer `%s' in state %s/%s\n",
GNUNET_i2s (peer),
GNUNET_TRANSPORT_ps2s (n->state),
print_ack_state (n->ack_state));
+
GNUNET_STATISTICS_update (GST_stats,
gettext_noop ("# unexpected SESSION_ACK messages"), 1,
GNUNET_NO);
return GNUNET_OK;
}
- set_state_and_timeout (n, GNUNET_TRANSPORT_PS_CONNECTED, GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT));
- GNUNET_STATISTICS_set (GST_stats,
- gettext_noop ("# peers connected"),
- ++neighbours_connected,
- GNUNET_NO);
- connect_notify_cb (callback_cls, &n->id,
+
+ /* We are connected */
+ if (GNUNET_NO == GST_neighbours_test_connected(&n->id))
+ {
+ /* Notify about connection */
+ connect_notify_cb (callback_cls, &n->id,
n->primary_address.bandwidth_in,
- n->primary_address.bandwidth_out);
+ n->primary_address.bandwidth_out);\
+
+ GNUNET_STATISTICS_set (GST_stats,
+ gettext_noop ("# peers connected"),
+ ++neighbours_connected,
+ GNUNET_NO);
+ }
+
+ set_state_and_timeout (n, GNUNET_TRANSPORT_PS_CONNECTED,
+ GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT));
+
+ /* Add session to ATS since no session was given (NULL) and we may have
+ * obtained a new session */
+ GST_ats_add_address (n->primary_address.address, n->primary_address.session,
+ NULL, 0);
- GST_ats_add_address (n->primary_address.address,
- n->primary_address.session,
- NULL, 0);
+ /* Set primary address to used */
set_primary_address (n,
n->primary_address.address,
n->primary_address.session,
disconnect_neighbour (n);
}
+void delayed_disconnect (void *cls,
+ const struct GNUNET_SCHEDULER_TaskContext* tc)
+{
+ struct NeighbourMapEntry *n = cls;
+
+ n->delayed_disconnect_task = GNUNET_SCHEDULER_NO_TASK;
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "Disconnecting by request from peer %s\n",
+ GNUNET_i2s (&n->id));
+ free_neighbour (n, GNUNET_NO);
+}
+
/**
* We received a disconnect message from the given peer,
GNUNET_i2s (peer));
if (ntohs (msg->size) != sizeof (struct SessionDisconnectMessage))
{
- // GNUNET_break_op (0);
+ GNUNET_break_op (0);
GNUNET_STATISTICS_update (GST_stats,
gettext_noop
- ("# disconnect messages ignored (old format)"), 1,
+ ("# disconnect messages ignored (malformed)"), 1,
GNUNET_NO);
return;
}
GNUNET_break_op (0);
return;
}
- if (GNUNET_YES == test_connected (n))
- GNUNET_STATISTICS_update (GST_stats,
- gettext_noop
- ("# other peer asked to disconnect from us"), 1,
- GNUNET_NO);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Disconnecting by request from peer %s\n",
- GNUNET_i2s (peer));
- disconnect_neighbour (n);
+ n->delayed_disconnect_task = GNUNET_SCHEDULER_add_now (&delayed_disconnect, n);
}
{
case GNUNET_TRANSPORT_PS_CONNECTED:
case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT:
- case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_BLACKLIST:
case GNUNET_TRANSPORT_PS_RECONNECT_SENT:
case GNUNET_TRANSPORT_PS_RECONNECT_ATS:
- case GNUNET_TRANSPORT_PS_RECONNECT_BLACKLIST:
return n->latency;
case GNUNET_TRANSPORT_PS_NOT_CONNECTED:
case GNUNET_TRANSPORT_PS_INIT_ATS:
case GNUNET_TRANSPORT_PS_CONNECT_RECV_ATS:
- case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST:
case GNUNET_TRANSPORT_PS_CONNECT_RECV_ACK:
case GNUNET_TRANSPORT_PS_CONNECT_SENT:
case GNUNET_TRANSPORT_PS_DISCONNECT:
util_transmission_tk = GNUNET_SCHEDULER_NO_TASK;
}
- GNUNET_CONTAINER_multipeermap_iterate (neighbours,
- &disconnect_all_neighbours,
- NULL);
+ GNUNET_CONTAINER_multipeermap_iterate (neighbours, &disconnect_all_neighbours,
+ NULL );
GNUNET_CONTAINER_multipeermap_destroy (neighbours);
next = pending_bc_head;