/**
* How often do we send KEEPALIVE messages to each of our neighbours and measure
* the latency with this neighbour?
- * (idle timeout is 5 minutes or 300 seconds, so with 30s interval we
- * send 10 keepalives in each interval, so 10 messages would need to be
+ * (idle timeout is 5 minutes or 300 seconds, so with 100s interval we
+ * send 3 keepalives in each interval, so 3 messages would need to be
* lost in a row for a disconnect).
*/
-#define KEEPALIVE_FREQUENCY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
+#define KEEPALIVE_FREQUENCY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 100)
/**
* How long are we willing to wait for a response from ATS before timing out?
* Free a neighbour map entry.
*
* @param n entry to free
+ * @param keep_sessions GNUNET_NO to tell plugin to terminate sessions,
+ * GNUNET_YES to keep all sessions
*/
static void
-free_neighbour (struct NeighbourMapEntry *n)
+free_neighbour (struct NeighbourMapEntry *n, int keep_sessions)
{
struct MessageQueue *mq;
struct GNUNET_TRANSPORT_PluginFunctions *papi;
API gives us not even the means to selectively kill only one of
them! Killing all sessions like this seems to be very, very
wrong. */
- if ( (NULL != n->primary_address.address) &&
- (NULL != (papi = GST_plugins_find (n->primary_address.address->transport_name))) )
+ if ((GNUNET_NO == keep_sessions) &&
+ (NULL != n->primary_address.address) &&
+ (NULL != (papi = GST_plugins_find (n->primary_address.address->transport_name))))
papi->disconnect (papi->cls, &n->id);
n->state = S_DISCONNECT_FINISHED;
if (S_DISCONNECT != n->state)
return; /* have created a fresh entry since */
n->state = S_DISCONNECT;
- GNUNET_SCHEDULER_cancel (n->task);
+ if (GNUNET_SCHEDULER_NO_TASK != n->task)
+ GNUNET_SCHEDULER_cancel (n->task);
n->task = GNUNET_SCHEDULER_add_now (&master_task, n);
}
case S_INIT_BLACKLIST:
/* other peer is completely unaware of us, no need to send DISCONNECT */
n->state = S_DISCONNECT_FINISHED;
- free_neighbour (n);
+ free_neighbour (n, GNUNET_NO);
return;
case S_CONNECT_SENT:
send_disconnect (n);
case S_CONNECT_RECV_BLACKLIST:
/* we never ACK'ed the other peer's request, no need to send DISCONNECT */
n->state = S_DISCONNECT_FINISHED;
- free_neighbour (n);
+ free_neighbour (n, GNUNET_NO);
return;
case S_CONNECT_RECV_ACK:
/* we DID ACK the other peer's request, must send DISCONNECT */
struct MessageQueue *mq = cls;
struct NeighbourMapEntry *n;
- n = lookup_neighbour (receiver);
- if (NULL == n)
- {
- GNUNET_break (0);
- return;
- }
-
+ if (NULL == (n = lookup_neighbour (receiver)))
+ return; /* disconnect or other error while transmitting, can happen */
if (n->is_active == mq)
{
/* this is still "our" neighbour, remove us from its queue
and allow it to send the next message now */
n->is_active = NULL;
- GNUNET_SCHEDULER_cancel (n->task);
+ if (GNUNET_SCHEDULER_NO_TASK != n->task)
+ GNUNET_SCHEDULER_cancel (n->task);
n->task = GNUNET_SCHEDULER_add_now (&master_task, n);
}
GNUNET_assert (bytes_in_send_queue >= mq->message_buf_size);
if ( (NULL != n->is_active) ||
( (NULL == n->primary_address.session) && (NULL == n->primary_address.address)) )
return;
- GNUNET_SCHEDULER_cancel (n->task);
+ if (GNUNET_SCHEDULER_NO_TASK != n->task)
+ GNUNET_SCHEDULER_cancel (n->task);
n->task = GNUNET_SCHEDULER_add_now (&master_task, n);
}
case S_NOT_CONNECTED:
/* this should not be possible */
GNUNET_break (0);
- free_neighbour (n);
+ free_neighbour (n, GNUNET_NO);
break;
case S_INIT_ATS:
case S_INIT_BLACKLIST:
return; /* already connected */
case S_DISCONNECT:
/* get rid of remains, ready to re-try immediately */
- free_neighbour (n);
+ free_neighbour (n, GNUNET_NO);
break;
case S_DISCONNECT_FINISHED:
/* should not be possible */
default:
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Unhandled state `%s' \n",print_state (n->state));
GNUNET_break (0);
- free_neighbour (n);
+ free_neighbour (n, GNUNET_NO);
break;
}
}
n = setup_neighbour (target);
n->state = S_INIT_ATS;
n->timeout = GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT);
+
+ GNUNET_ATS_reset_backoff (GST_ats, target);
GNUNET_ATS_suggest_address (GST_ats, target);
}
case S_NOT_CONNECTED:
/* this should not be possible */
GNUNET_break (0);
- free_neighbour (n);
+ free_neighbour (n, GNUNET_NO);
break;
case S_INIT_ATS:
/* still waiting on ATS suggestion */
n->state = S_INIT_ATS;
n->timeout = GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT);
// FIXME: do we need to ask ATS again for suggestions?
+ GNUNET_ATS_reset_backoff (GST_ats, peer);
GNUNET_ATS_suggest_address (GST_ats, &n->id);
}
break;
default:
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Unhandled state `%s' \n",print_state (n->state));
GNUNET_break (0);
- free_neighbour (n);
+ free_neighbour (n, GNUNET_NO);
break;
}
cleanup:
case S_NOT_CONNECTED:
n->state = S_CONNECT_RECV_ATS;
n->timeout = GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT);
+ GNUNET_ATS_reset_backoff (GST_ats, peer);
GNUNET_ATS_suggest_address (GST_ats, peer);
check_blacklist (peer, ts, address, session, ats, ats_count);
break;
check_blacklist (peer, ts, address, session, ats, ats_count);
break;
case S_DISCONNECT:
- /* get rid of remains, ready to re-try */
- free_neighbour (n);
+ /* get rid of remains without terminating sessions, ready to re-try */
+ free_neighbour (n, GNUNET_YES);
n = setup_neighbour (peer);
n->state = S_CONNECT_RECV_ATS;
+ GNUNET_ATS_reset_backoff (GST_ats, peer);
GNUNET_ATS_suggest_address (GST_ats, peer);
- check_blacklist (peer, ts, address, session, ats, ats_count);
break;
case S_DISCONNECT_FINISHED:
/* should not be possible */
default:
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Unhandled state `%s' \n",print_state (n->state));
GNUNET_break (0);
- free_neighbour (n);
+ free_neighbour (n, GNUNET_NO);
break;
}
}
{
case S_NOT_CONNECTED:
GNUNET_break (0);
- free_neighbour (n);
+ free_neighbour (n, GNUNET_NO);
return;
case S_INIT_ATS:
set_address (&n->primary_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_address (&n->alternative_address,
- address, session, bandwidth_in, bandwidth_out, GNUNET_YES);
+ address, session, bandwidth_in, bandwidth_out, GNUNET_NO);
n->state = S_CONNECTED_SWITCHING_BLACKLIST;
check_blacklist (&n->id,
GNUNET_TIME_absolute_get (),
}
/* ATS asks us to switch a life connection, update blacklist check */
set_address (&n->alternative_address,
- address, session, bandwidth_in, bandwidth_out, GNUNET_YES);
+ address, session, bandwidth_in, bandwidth_out, GNUNET_NO);
check_blacklist (&n->id,
GNUNET_TIME_absolute_get (),
address, session, ats, ats_count);
}
/* ATS asks us to switch a life connection, update blacklist check */
set_address (&n->alternative_address,
- address, session, bandwidth_in, bandwidth_out, GNUNET_YES);
+ address, session, bandwidth_in, bandwidth_out, GNUNET_NO);
n->state = S_CONNECTED_SWITCHING_BLACKLIST;
check_blacklist (&n->id,
GNUNET_TIME_absolute_get (),
/* invalid state for master task, clean up */
GNUNET_break (0);
n->state = S_DISCONNECT_FINISHED;
- free_neighbour (n);
+ free_neighbour (n, GNUNET_NO);
return;
case S_INIT_ATS:
if (0 == delay.rel_value)
"Connection to `%s' timed out waiting for ATS to provide address\n",
GNUNET_i2s (&n->id));
n->state = S_DISCONNECT_FINISHED;
- free_neighbour (n);
+ free_neighbour (n, GNUNET_NO);
return;
}
break;
"Connection to `%s' timed out waiting for BLACKLIST to approve address\n",
GNUNET_i2s (&n->id));
n->state = S_DISCONNECT_FINISHED;
- free_neighbour (n);
+ free_neighbour (n, GNUNET_NO);
return;
}
break;
"Connection to `%s' timed out waiting ATS to provide address to use for CONNECT_ACK\n",
GNUNET_i2s (&n->id));
n->state = S_DISCONNECT_FINISHED;
- free_neighbour (n);
+ free_neighbour (n, GNUNET_NO);
return;
}
break;
"Connection to `%s' timed out waiting BLACKLIST to approve address to use for CONNECT_ACK\n",
GNUNET_i2s (&n->id));
n->state = S_DISCONNECT_FINISHED;
- free_neighbour (n);
+ free_neighbour (n, GNUNET_NO);
return;
}
break;
"Cleaning up connection to `%s' after sending DISCONNECT\n",
GNUNET_i2s (&n->id));
n->state = S_DISCONNECT_FINISHED;
- free_neighbour (n);
+ free_neighbour (n, GNUNET_NO);
return;
case S_DISCONNECT_FINISHED:
/* how did we get here!? */
}
delay = GNUNET_TIME_relative_min (GNUNET_TIME_absolute_get_remaining (n->keep_alive_time),
delay);
- GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == n->task);
- n->task = GNUNET_SCHEDULER_add_delayed (delay,
- &master_task,
- n);
+ if (GNUNET_SCHEDULER_NO_TASK == n->task)
+ n->task = GNUNET_SCHEDULER_add_delayed (delay,
+ &master_task,
+ n);
}
{
case S_NOT_CONNECTED:
GNUNET_break (0);
- free_neighbour (n);
+ free_neighbour (n, GNUNET_NO);
return;
case S_INIT_ATS:
case S_INIT_BLACKLIST:
/* new address worked; adopt it and go back to connected! */
n->state = S_CONNECTED;
n->timeout = GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
- GNUNET_assert (GNUNET_NO == n->alternative_address.ats_active);
+ GNUNET_break (GNUNET_NO == n->alternative_address.ats_active);
set_address (&n->primary_address,
n->alternative_address.address,
n->alternative_address.session,
{
case S_NOT_CONNECTED:
GNUNET_break (0);
- free_neighbour (n);
+ free_neighbour (n, GNUNET_NO);
return;
case S_INIT_ATS:
GNUNET_break (0);
- free_neighbour (n);
+ free_neighbour (n, GNUNET_NO);
return;
case S_INIT_BLACKLIST:
case S_CONNECT_SENT:
case S_CONNECT_RECV_ACK:
/* error on inbound session; free neighbour entirely */
free_address (&n->primary_address);
- free_neighbour (n);
+ free_neighbour (n, GNUNET_NO);
return;
case S_CONNECTED:
free_address (&n->primary_address);
"Disconnecting peer `%4s', %s\n",
GNUNET_i2s (&n->id), "SHUTDOWN_TASK");
n->state = S_DISCONNECT_FINISHED;
- free_neighbour (n);
+ free_neighbour (n, GNUNET_NO);
return GNUNET_OK;
}
projects / oweals / gnunet.git / blobdiff