#include "transport.h"
+
/**
* Size of the neighbour hash map.
*/
/**
* 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?
* Possible state of a neighbour. Initially, we are S_NOT_CONNECTED.
*
* Then, there are two main paths. If we receive a CONNECT message, we
- * first run a check against the blacklist and ask ATS for a
- * suggestion. (S_CONNECT_RECV_ATS). If the blacklist comes back
- * positive, we give the address to ATS. If ATS makes a suggestion,
- * we ALSO give that suggestion to the blacklist
+ * first run a check against the blacklist (S_CONNECT_RECV_BLACKLIST_INBOUND).
+ * If this check is successful, we give the inbound address to ATS.
+ * After the check we ask ATS for a suggestion (S_CONNECT_RECV_ATS).
+ * If ATS makes a suggestion, we ALSO give that suggestion to the blacklist
* (S_CONNECT_RECV_BLACKLIST). Once the blacklist approves the
* address we got from ATS, we send our CONNECT_ACK and go to
* S_CONNECT_RECV_ACK. If we receive a SESSION_ACK, we go to
*/
S_CONNECT_SENT,
+ /**
+ * Received a CONNECT, do a blacklist check for inbound address
+ */
+ S_CONNECT_RECV_BLACKLIST_INBOUND,
+
/**
* Received a CONNECT, asking ATS about address suggestions.
*/
S_DISCONNECT,
/**
- * We're finished with the disconnect; clean up state now!
+ * We're finished with the disconnect; and are cleaning up the state
+ * now! We put the struct into this state when we are really in the
+ * task that calls 'free' on it and are about to remove the record
+ * from the map. We should never find a 'struct NeighbourMapEntry'
+ * in this state in the map. Accessing a 'struct NeighbourMapEntry'
+ * in this state virtually always means using memory that has been
+ * freed (the exception being the cleanup code in 'free_neighbour').
*/
S_DISCONNECT_FINISHED
};
/**
* Function to call when we connected to a neighbour.
*/
-static GNUNET_TRANSPORT_NotifyConnect connect_notify_cb;
+static NotifyConnect connect_notify_cb;
/**
* Function to call when we disconnected from a neighbour.
{
case S_NOT_CONNECTED:
return "S_NOT_CONNECTED";
- break;
case S_INIT_ATS:
return "S_INIT_ATS";
- break;
case S_INIT_BLACKLIST:
return "S_INIT_BLACKLIST";
- break;
case S_CONNECT_SENT:
return "S_CONNECT_SENT";
- break;
+ case S_CONNECT_RECV_BLACKLIST_INBOUND:
+ return "S_CONNECT_RECV_BLACKLIST_INBOUND";
case S_CONNECT_RECV_ATS:
return "S_CONNECT_RECV_ATS";
- break;
case S_CONNECT_RECV_BLACKLIST:
return "S_CONNECT_RECV_BLACKLIST";
- break;
case S_CONNECT_RECV_ACK:
return "S_CONNECT_RECV_ACK";
- break;
case S_CONNECTED:
return "S_CONNECTED";
- break;
case S_RECONNECT_ATS:
return "S_RECONNECT_ATS";
- break;
case S_RECONNECT_BLACKLIST:
return "S_RECONNECT_BLACKLIST";
- break;
case S_RECONNECT_SENT:
return "S_RECONNECT_SENT";
- break;
case S_CONNECTED_SWITCHING_BLACKLIST:
return "S_CONNECTED_SWITCHING_BLACKLIST";
- break;
case S_CONNECTED_SWITCHING_CONNECT_SENT:
return "S_CONNECTED_SWITCHING_CONNECT_SENT";
- break;
case S_DISCONNECT:
return "S_DISCONNECT";
- break;
case S_DISCONNECT_FINISHED:
return "S_DISCONNECT_FINISHED";
- break;
default:
- return "UNDEFINED";
GNUNET_break (0);
- break;
+ return "UNDEFINED";
}
- GNUNET_break (0);
return "UNDEFINED";
}
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:
GST_validation_set_address_use (na->address, na->session, GNUNET_NO, __LINE__);
GNUNET_ATS_address_in_use (GST_ats, na->address, na->session, GNUNET_NO);
}
+
na->ats_active = GNUNET_NO;
if (NULL != na->address)
{
if (GNUNET_YES == is_active)
{
/* Telling ATS about new session */
- GNUNET_ATS_address_update (GST_ats, na->address, na->session, NULL, 0);
GNUNET_ATS_address_in_use (GST_ats, na->address, na->session, GNUNET_YES);
GST_validation_set_address_use (na->address, na->session, GNUNET_YES, __LINE__);
* 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;
+ struct GNUNET_HELLO_Address *backup_primary;
n->is_active = NULL; /* always free'd by its own continuation! */
{
GNUNET_CONTAINER_DLL_remove (n->messages_head, n->messages_tail, mq);
if (NULL != mq->cont)
- mq->cont (mq->cont_cls, GNUNET_SYSERR);
+ mq->cont (mq->cont_cls, GNUNET_SYSERR, mq->message_buf_size, 0);
GNUNET_free (mq);
}
/* It is too late to send other peer disconnect notifications, but at
disconnect_notify_cb (callback_cls, &n->id);
}
+ n->state = S_DISCONNECT_FINISHED;
+
+ if (NULL != n->primary_address.address)
+ backup_primary = GNUNET_HELLO_address_copy(n->primary_address.address);
+ else
+ backup_primary = NULL;
+
+ /* free addresses and mark as unused */
+ free_address (&n->primary_address);
+ free_address (&n->alternative_address);
+
/* FIXME-PLUGIN-API: This does not seem to guarantee that all
transport sessions eventually get killed due to inactivity; they
MUST have their own timeout logic (but at least TCP doesn't have
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))) )
+
+ /* cut transport-level connection */
+ if ((GNUNET_NO == keep_sessions) &&
+ (NULL != backup_primary) &&
+ (NULL != (papi = GST_plugins_find (backup_primary->transport_name))))
papi->disconnect (papi->cls, &n->id);
- n->state = S_DISCONNECT_FINISHED;
+ GNUNET_free_non_null (backup_primary);
GNUNET_assert (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap_remove (neighbours,
&n->id.hashPubKey, n));
- /* cut transport-level connection */
- free_address (&n->primary_address);
- free_address (&n->alternative_address);
-
// FIXME-ATS-API: we might want to be more specific about
// which states we do this from in the future (ATS should
// have given us a 'suggest_address' handle, and if we have
GNUNET_free (n);
}
-
/**
* Transmit a message using the current session of the given
* neighbour.
struct GNUNET_TRANSPORT_PluginFunctions *papi;
GNUNET_assert (n->primary_address.session != NULL);
- if ( ( (NULL == (papi = GST_plugins_find (n->primary_address.address->transport_name))) ||
+ if ( ((NULL == (papi = GST_plugins_find (n->primary_address.address->transport_name)) ||
(-1 == papi->send (papi->cls,
n->primary_address.session,
msgbuf, msgbuf_size,
priority,
timeout,
- cont, cont_cls))) &&
- (NULL != cont) )
- cont (cont_cls, &n->id, GNUNET_SYSERR);
+ cont, cont_cls)))) &&
+ (NULL != cont))
+ cont (cont_cls, &n->id, GNUNET_SYSERR, msgbuf_size, 0);
GNUNET_break (NULL != papi);
}
* @param cls NULL
* @param target identity of the neighbour that was disconnected
* @param result GNUNET_OK if the disconnect got out successfully
+ * @param payload bytes payload
+ * @param physical bytes physical
*/
static void
send_disconnect_cont (void *cls, const struct GNUNET_PeerIdentity *target,
- int result)
+ int result, size_t payload, size_t physical)
{
struct NeighbourMapEntry *n;
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);
n->state = S_DISCONNECT;
- break;
+ break;
+ case S_CONNECT_RECV_BLACKLIST_INBOUND:
case S_CONNECT_RECV_ATS:
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 */
* @param cls the 'struct MessageQueue' of the message
* @param receiver intended receiver
* @param success whether it worked or not
+ * @param size_payload bytes payload sent
+ * @param physical bytes sent on wire
*/
static void
transmit_send_continuation (void *cls,
const struct GNUNET_PeerIdentity *receiver,
- int success)
+ int success, size_t size_payload, size_t physical)
{
struct MessageQueue *mq = cls;
struct NeighbourMapEntry *n;
- n = lookup_neighbour (receiver);
- if (NULL == n)
+ if (NULL == (n = lookup_neighbour (receiver)))
{
- GNUNET_break (0);
- return;
+ GNUNET_free (mq);
+ 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 (bytes_in_send_queue < mq->message_buf_size)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "bytes_in_send_queue `%u' mq->message_buf_size %u\n",
+ bytes_in_send_queue, mq->message_buf_size );
+ GNUNET_break (0);
+ }
+
+
+ GNUNET_break (size_payload == mq->message_buf_size);
bytes_in_send_queue -= mq->message_buf_size;
GNUNET_STATISTICS_set (GST_stats,
gettext_noop
ntohs (((struct GNUNET_MessageHeader *) mq->message_buf)->type),
(success == GNUNET_OK) ? "success" : "FAILURE");
if (NULL != mq->cont)
- mq->cont (mq->cont_cls, success);
+ mq->cont (mq->cont_cls, success, size_payload, physical);
GNUNET_free (mq);
}
1, GNUNET_NO);
GNUNET_CONTAINER_DLL_remove (n->messages_head, n->messages_tail, mq);
n->is_active = mq;
- transmit_send_continuation (mq, &n->id, GNUNET_SYSERR); /* timeout */
+ transmit_send_continuation (mq, &n->id, GNUNET_SYSERR, mq->message_buf_size, 0); /* timeout */
}
if (NULL == mq)
return; /* no more messages */
/**
* Send keepalive message to the neighbour. Must only be called
- * if we are on 'connected' state. Will internally determine
- * if a keepalive is truly needed (so can always be called).
+ * if we are on 'connected' state or while trying to switch addresses.
+ * Will internally determine if a keepalive is truly needed (so can
+ * always be called).
*
* @param n neighbour that went idle and needs a keepalive
*/
{
struct GNUNET_MessageHeader m;
- GNUNET_assert (S_CONNECTED == n->state);
+ GNUNET_assert ((S_CONNECTED == n->state) ||
+ (S_CONNECTED_SWITCHING_BLACKLIST == n->state) ||
+ (S_CONNECTED_SWITCHING_CONNECT_SENT));
if (GNUNET_TIME_absolute_get_remaining (n->keep_alive_time).rel_value > 0)
return; /* no keepalive needed at this time */
m.size = htons (sizeof (struct GNUNET_MessageHeader));
{
GNUNET_break (0);
if (NULL != cont)
- cont (cont_cls, GNUNET_SYSERR);
+ cont (cont_cls, GNUNET_SYSERR, msg_size, 0);
return;
}
if (GNUNET_YES != test_connected (n))
{
GNUNET_break (0);
if (NULL != cont)
- cont (cont_cls, GNUNET_SYSERR);
+ cont (cont_cls, GNUNET_SYSERR, msg_size, 0);
return;
}
bytes_in_send_queue += msg_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);
}
{
struct GNUNET_TRANSPORT_PluginFunctions *papi;
struct SessionConnectMessage connect_msg;
-
+
if (NULL == (papi = GST_plugins_find (na->address->transport_name)))
{
GNUNET_break (0);
UINT_MAX,
GNUNET_TIME_UNIT_FOREVER_REL,
NULL, NULL);
+
}
{
struct GNUNET_TRANSPORT_PluginFunctions *papi;
struct SessionConnectMessage connect_msg;
-
+
if (NULL == (papi = GST_plugins_find (address->transport_name)))
{
GNUNET_break (0);
UINT_MAX,
GNUNET_TIME_UNIT_FOREVER_REL,
NULL, NULL);
+
}
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:
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:
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);
}
"Connection to new address of peer `%s' based on blacklist is `%s'\n",
GNUNET_i2s (peer),
(GNUNET_OK == result) ? "allowed" : "FORBIDDEN");
- if (GNUNET_OK == result)
- {
- /* valid new address, let ATS know! */
- GNUNET_ATS_address_update (GST_ats,
- bcc->na.address,
- bcc->na.session,
- bcc->ats, bcc->ats_count);
- }
if (NULL == (n = lookup_neighbour (peer)))
goto cleanup; /* nobody left to care about new address */
switch (n->state)
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 */
}
else
{
+ // FIXME: should also possibly destroy session with plugin!?
GNUNET_ATS_address_destroyed (GST_ats,
bcc->na.address,
NULL);
+ free_address (&n->primary_address);
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?
n->connect_ack_timestamp);
}
break;
+ case S_CONNECT_RECV_BLACKLIST_INBOUND:
+ if (GNUNET_OK == result)
+ {
+ /* valid new address, let ATS know! */
+ GNUNET_ATS_address_add (GST_ats,
+ bcc->na.address,
+ bcc->na.session,
+ bcc->ats, bcc->ats_count);
+ }
+ 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);
+ break;
case S_CONNECT_RECV_ATS:
/* still waiting on ATS suggestion, don't care about blacklist */
- break;
+ break;
case S_CONNECT_RECV_BLACKLIST:
if (GNUNET_YES != address_matches (&bcc->na, &n->primary_address))
break; /* result for an address we currently don't care about */
}
else
{
+ // FIXME: should also possibly destroy session with plugin!?
GNUNET_ATS_address_destroyed (GST_ats,
bcc->na.address,
NULL);
+ free_address (&n->primary_address);
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:
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Received CONNECT message from peer `%s'\n",
GNUNET_i2s (peer));
+
if (ntohs (message->size) != sizeof (struct SessionConnectMessage))
{
GNUNET_break_op (0);
n = setup_neighbour (peer);
n->send_connect_ack = 1;
n->connect_ack_timestamp = ts;
+
switch (n->state)
{
case S_NOT_CONNECTED:
- n->state = S_CONNECT_RECV_ATS;
- n->timeout = GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT);
- GNUNET_ATS_suggest_address (GST_ats, peer);
+ n->state = S_CONNECT_RECV_BLACKLIST_INBOUND;
+ /* Do a blacklist check for the new address */
check_blacklist (peer, ts, address, session, ats, ats_count);
break;
case S_INIT_ATS:
+ /* CONNECT message takes priority over us asking ATS for address */
+ n->state = S_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:
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;
}
}
{
GNUNET_break (0);
if (strlen (address->transport_name) > 0)
- GNUNET_ATS_address_destroyed (GST_ats, address, session);
+ GNUNET_ATS_address_destroyed (GST_ats, address, NULL);
return;
}
+
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "ATS tells us to switch to address '%s' session %p for "
+ "peer `%s' in state %s (quota in/out %u %u )\n",
+ (address->address_length != 0) ? GST_plugins_a2s (address): "<inbound>",
+ session,
+ GNUNET_i2s (peer),
+ print_state (n->state),
+ ntohl (bandwidth_in.value__),
+ ntohl (bandwidth_out.value__));
+
if (NULL == session)
+ {
session = papi->get_session (papi->cls, address);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Obtained new session for peer `%s' and address '%s': %p\n",
+ GNUNET_i2s (&address->peer), GST_plugins_a2s (address), session);
+ }
if (NULL == session)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
GNUNET_ATS_address_destroyed (GST_ats, address, NULL);
return;
}
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "ATS tells us to switch to address '%s' for peer `%s'\n",
- (address->address_length != 0) ? GST_plugins_a2s (address): "<inbound>",
- GNUNET_i2s (peer));
switch (n->state)
{
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,
n->connect_ack_timestamp,
address, session, ats, ats_count);
break;
+ case S_CONNECT_RECV_BLACKLIST_INBOUND:
+ n->timeout = GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT);
+ check_blacklist (&n->id,
+ n->connect_ack_timestamp,
+ address, session, ats, ats_count);
+ break;
case S_CONNECT_RECV_BLACKLIST:
+ case S_CONNECT_RECV_ACK:
/* ATS asks us to switch while we were trying to connect; switch to new
address and check blacklist again */
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 (),
n->task = GNUNET_SCHEDULER_NO_TASK;
delay = GNUNET_TIME_absolute_get_remaining (n->timeout);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Master task runs for neighbour `%s' in state %s with timeout in %llu ms\n",
+ GNUNET_i2s (&n->id),
+ print_state(n->state),
+ (unsigned long long) delay.rel_value);
switch (n->state)
{
case S_NOT_CONNECTED:
/* 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;
return;
}
break;
+ case S_CONNECT_RECV_BLACKLIST_INBOUND:
+ if (0 == delay.rel_value)
+ {
+ 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));
+ n->state = S_DISCONNECT_FINISHED;
+ free_neighbour (n, GNUNET_NO);
+ return;
+ }
+ break;
case S_CONNECT_RECV_ATS:
if (0 == delay.rel_value)
{
"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;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"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!? */
GNUNET_break (0);
break;
}
- 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 ( (S_CONNECTED_SWITCHING_CONNECT_SENT == n->state) ||
+ (S_CONNECTED_SWITCHING_BLACKLIST == n->state) ||
+ (S_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
+ delay, not just the connection timeout */
+ delay = GNUNET_TIME_relative_min (GNUNET_TIME_absolute_get_remaining (n->keep_alive_time),
+ delay);
+ }
+ if (GNUNET_SCHEDULER_NO_TASK == n->task)
+ n->task = GNUNET_SCHEDULER_add_delayed (delay,
+ &master_task,
+ n);
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Received CONNECT_ACK message from peer `%s'\n",
GNUNET_i2s (peer));
+
if (ntohs (message->size) != sizeof (struct SessionConnectMessage))
{
GNUNET_break_op (0);
{
case S_NOT_CONNECTED:
GNUNET_break (0);
- free_neighbour (n);
+ free_neighbour (n, GNUNET_NO);
return;
case S_INIT_ATS:
case S_INIT_BLACKLIST:
gettext_noop ("# peers connected"),
++neighbours_connected,
GNUNET_NO);
- connect_notify_cb (callback_cls, &n->id, ats, ats_count);
+ connect_notify_cb (callback_cls, &n->id, ats, ats_count,
+ n->primary_address.bandwidth_in,
+ n->primary_address.bandwidth_out);
+ /* Tell ATS that the outbound session we created to send CONNECT was successfull */
+ GNUNET_ATS_address_add (GST_ats,
+ n->primary_address.address,
+ n->primary_address.session,
+ ats, ats_count);
set_address (&n->primary_address,
n->primary_address.address,
n->primary_address.session,
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:
/* 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);
+ GNUNET_ATS_address_add(GST_ats,
+ n->alternative_address.address,
+ n->alternative_address.session,
+ ats, ats_count);
set_address (&n->primary_address,
n->alternative_address.address,
n->alternative_address.session,
*
* @param peer identity of the peer where the session died
* @param session session that is gone
+ * @return GNUNET_YES if this was a session used, GNUNET_NO if
+ * this session was not in use
*/
-void
+int
GST_neighbours_session_terminated (const struct GNUNET_PeerIdentity *peer,
struct Session *session)
{
}
}
if (NULL == (n = lookup_neighbour (peer)))
- return; /* can't affect us */
+ return GNUNET_NO; /* can't affect us */
if (session != n->primary_address.session)
{
if (session == n->alternative_address.session)
else
GNUNET_break (0);
}
- return; /* doesn't affect us further */
+ return GNUNET_NO; /* doesn't affect us further */
}
n->expect_latency_response = GNUNET_NO;
-
switch (n->state)
{
case S_NOT_CONNECTED:
GNUNET_break (0);
- free_neighbour (n);
- return;
+ free_neighbour (n, GNUNET_NO);
+ return GNUNET_YES;
case S_INIT_ATS:
GNUNET_break (0);
- free_neighbour (n);
- return;
+ free_neighbour (n, GNUNET_NO);
+ return GNUNET_YES;
case S_INIT_BLACKLIST:
case S_CONNECT_SENT:
free_address (&n->primary_address);
// FIXME: need to ask ATS for suggestions again?
GNUNET_ATS_suggest_address (GST_ats, &n->id);
break;
+ case S_CONNECT_RECV_BLACKLIST_INBOUND:
case S_CONNECT_RECV_ATS:
case S_CONNECT_RECV_BLACKLIST:
case S_CONNECT_RECV_ACK:
/* error on inbound session; free neighbour entirely */
free_address (&n->primary_address);
- free_neighbour (n);
- return;
+ free_neighbour (n, GNUNET_NO);
+ return GNUNET_YES;
case S_CONNECTED:
free_address (&n->primary_address);
n->state = S_RECONNECT_ATS;
break;
case S_DISCONNECT_FINISHED:
/* neighbour was freed and plugins told to terminate session */
+ return GNUNET_NO;
break;
default:
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Unhandled state `%s' \n",print_state (n->state));
if (GNUNET_SCHEDULER_NO_TASK != n->task)
GNUNET_SCHEDULER_cancel (n->task);
n->task = GNUNET_SCHEDULER_add_now (&master_task, n);
+ return GNUNET_YES;
}
gettext_noop ("# peers connected"),
++neighbours_connected,
GNUNET_NO);
- connect_notify_cb (callback_cls, &n->id, ats, ats_count);
+ connect_notify_cb (callback_cls, &n->id, ats, ats_count,
+ n->primary_address.bandwidth_in,
+ n->primary_address.bandwidth_out);
+ GNUNET_ATS_address_add(GST_ats,
+ n->primary_address.address,
+ n->primary_address.session,
+ ats, ats_count);
set_address (&n->primary_address,
n->primary_address.address,
n->primary_address.session,
{
struct NeighbourMapEntry *n;
const struct SessionDisconnectMessage *sdm;
- GNUNET_HashCode hc;
+ struct GNUNET_HashCode hc;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Received DISCONNECT message from peer `%s'\n",
* @return GNUNET_OK (continue to iterate)
*/
static int
-neighbours_iterate (void *cls, const GNUNET_HashCode * key, void *value)
+neighbours_iterate (void *cls, const struct GNUNET_HashCode * key, void *value)
{
struct IteratorContext *ic = cls;
struct NeighbourMapEntry *n = value;
if (GNUNET_YES == test_connected (n))
- ic->cb (ic->cb_cls, &n->id, NULL, 0, n->primary_address.address);
+ {
+ struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in;
+ struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out;
+
+ if (NULL != n->primary_address.address)
+ {
+ bandwidth_in = n->primary_address.bandwidth_in;
+ bandwidth_out = n->primary_address.bandwidth_out;
+ }
+ else
+ {
+ bandwidth_in = GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT;
+ bandwidth_out = GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT;
+ }
+
+ ic->cb (ic->cb_cls, &n->id, NULL, 0,
+ n->primary_address.address,
+ bandwidth_in, bandwidth_out);
+ }
return GNUNET_OK;
}
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:
return n->latency;
case S_NOT_CONNECTED:
case S_INIT_BLACKLIST:
case S_INIT_ATS:
- 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 S_CONNECT_SENT:
case S_DISCONNECT:
case S_DISCONNECT_FINISHED:
return GNUNET_TIME_UNIT_FOREVER_REL;
*/
void
GST_neighbours_start (void *cls,
- GNUNET_TRANSPORT_NotifyConnect connect_cb,
+ NotifyConnect connect_cb,
GNUNET_TRANSPORT_NotifyDisconnect disconnect_cb,
GNUNET_TRANSPORT_PeerIterateCallback peer_address_cb)
{
connect_notify_cb = connect_cb;
disconnect_notify_cb = disconnect_cb;
address_change_cb = peer_address_cb;
- neighbours = GNUNET_CONTAINER_multihashmap_create (NEIGHBOUR_TABLE_SIZE);
+ neighbours = GNUNET_CONTAINER_multihashmap_create (NEIGHBOUR_TABLE_SIZE, GNUNET_NO);
}
* @return GNUNET_OK (continue to iterate)
*/
static int
-disconnect_all_neighbours (void *cls, const GNUNET_HashCode * key, void *value)
+disconnect_all_neighbours (void *cls, const struct GNUNET_HashCode * key, void *value)
{
struct NeighbourMapEntry *n = value;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Disconnecting peer `%4s', %s\n",
GNUNET_i2s (&n->id), "SHUTDOWN_TASK");
- free_neighbour (n);
+ n->state = S_DISCONNECT_FINISHED;
+ free_neighbour (n, GNUNET_NO);
return GNUNET_OK;
}
projects / oweals / gnunet.git / blobdiff