/*
This file is part of GNUnet.
- (C) 2010,2011,2012 Christian Grothoff (and other contributing authors)
+ (C) 2010-2013 Christian Grothoff (and other contributing authors)
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
/**
* How long are we willing to wait for a response from ATS before timing out?
*/
-#define ATS_RESPONSE_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 500)
+#define ATS_RESPONSE_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 5000)
/**
* How long are we willing to wait for an ACK from the other peer before
#define SETUP_CONNECTION_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 15)
/**
- * How long are we willing to wait for a successful reconnect if
+ * How long are we willing to wait for a successful reconnect if
* an existing connection went down? Much shorter than the
* usual SETUP_CONNECTION_TIMEOUT as we do not inform the
* higher layers about the disconnect during this period.
next = GNUNET_TIME_UNIT_ZERO_ABS;
start = GNUNET_NO;
}
- if (0 == (rem = GNUNET_TIME_absolute_get_remaining(next)).rel_value)
+ if (0 == (rem = GNUNET_TIME_absolute_get_remaining(next)).rel_value_us)
{
fprintf (stderr, "Allocated in `%s' total: %5u bytes\n", __FILE__, bytes_alloced);
while (NULL != cur)
* setup a connection/session for data exchange. A 'SESSION_CONNECT'
* should be answered with a 'SESSION_CONNECT_ACK' with the same body
* to confirm. A 'SESSION_CONNECT_ACK' should then be followed with
- * a 'SESSION_ACK'. Once the 'SESSION_ACK' is received, both peers
+ * a 'SESSION_ACK'. Once the 'SESSION_ACK' is received, both peers
* should be connected.
*/
struct SessionConnectMessage
/**
* Message we send to the other peer to notify him that we intentionally
- * are disconnecting (to reduce timeouts). This is just a friendly
+ * are disconnecting (to reduce timeouts). This is just a friendly
* notification, peers must not rely on always receiving disconnect
* messages.
*/
/**
* Public key of the sender.
*/
- struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded public_key;
+ struct GNUNET_CRYPTO_EccPublicSignKey public_key;
/**
* Signature of the peer that sends us the disconnect. Only
* and set the 'send_connect_ack' to 2. If we then receive a
* 'SESSION_ACK', we go to 'S_CONNECTED' (and reset 'send_connect_ack'
* to 0).
- *
- */
+ *
+ */
enum State
{
/**
*/
S_CONNECTED_SWITCHING_BLACKLIST,
- /**
+ /**
* We have some primary connection, but ATS suggested we switch
* to some alternative; we now sent a CONNECT message for the
* alternative session to the other peer and waiting for a
* Did we tell ATS that this is our 'active' address?
*/
int ats_active;
-
+
};
struct GNUNET_TIME_Absolute keep_alive_time;
/**
- * At what time did we sent the last keep-alive message? Used
+ * At what time did we sent the last keep-alive message? Used
* to calculate round-trip time ("latency").
*/
struct GNUNET_TIME_Absolute last_keep_alive_time;
*/
struct BlackListCheckContext
{
-
+
/**
* We keep blacklist checks in a DLL.
*/
/**
* Hash map from peer identities to the respective 'struct NeighbourMapEntry'.
*/
-static struct GNUNET_CONTAINER_MultiHashMap *neighbours;
+static struct GNUNET_CONTAINER_MultiPeerMap *neighbours;
/**
* We keep blacklist checks in a DLL so that we can find
{
if (NULL == neighbours)
return NULL;
- return GNUNET_CONTAINER_multihashmap_get (neighbours, &pid->hashPubKey);
+ return GNUNET_CONTAINER_multipeermap_get (neighbours, pid);
}
static const char *
int is_active)
{
struct GNUNET_TRANSPORT_PluginFunctions *papi;
- if (NULL == (papi = GST_plugins_find (address->transport_name)))
+ if (NULL == (papi = GST_plugins_find (address->transport_name)))
{
GNUNET_break (0);
return;
/* FIXME: is this the right place to set quotas? */
GST_neighbours_set_incoming_quota (&address->peer, bandwidth_in);
send_outbound_quota (&address->peer, bandwidth_out);
- }
+ }
return;
}
free_address (na);
if (NULL == session)
- session = papi->get_session (papi->cls, address);
+ session = papi->get_session (papi->cls, address);
if (NULL == session)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Failed to obtain new session for peer `%s' and address '%s'\n",
- GNUNET_i2s (&address->peer), GST_plugins_a2s (address));
+ GNUNET_i2s (&address->peer), GST_plugins_a2s (address));
GNUNET_ATS_address_destroyed (GST_ats, address, NULL);
return;
}
least internally we need to get clean... */
if (GNUNET_YES == test_connected (n))
{
- GNUNET_STATISTICS_set (GST_stats,
- gettext_noop ("# peers connected"),
+ GNUNET_STATISTICS_set (GST_stats,
+ gettext_noop ("# peers connected"),
--neighbours_connected,
GNUNET_NO);
disconnect_notify_cb (callback_cls, &n->id);
MEMDEBUG_free_non_null (backup_primary, __LINE__);
GNUNET_assert (GNUNET_YES ==
- GNUNET_CONTAINER_multihashmap_remove (neighbours,
- &n->id.hashPubKey, n));
+ GNUNET_CONTAINER_multipeermap_remove (neighbours,
+ &n->id, n));
// FIXME-ATS-API: we might want to be more specific about
// which states we do this from in the future (ATS should
disconnect_msg.reserved = htonl (0);
disconnect_msg.purpose.size =
htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
- sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded) +
+ sizeof (struct GNUNET_CRYPTO_EccPublicSignKey) +
sizeof (struct GNUNET_TIME_AbsoluteNBO));
disconnect_msg.purpose.purpose =
htonl (GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_DISCONNECT);
disconnect_msg.timestamp =
GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get ());
- disconnect_msg.public_key = GST_my_public_key;
+ disconnect_msg.public_key = GST_my_identity.public_key;
GNUNET_assert (GNUNET_OK ==
GNUNET_CRYPTO_ecc_sign (GST_my_private_key,
&disconnect_msg.purpose,
static void
disconnect_neighbour (struct NeighbourMapEntry *n)
{
- /* depending on state, notify neighbour and/or upper layers of this peer
+ /* depending on state, notify neighbour and/or upper layers of this peer
about disconnect */
switch (n->state)
{
free_neighbour (n, GNUNET_NO);
return;
case S_CONNECT_SENT:
- send_disconnect (n);
+ send_disconnect (n);
n->state = S_DISCONNECT;
break;
case S_CONNECT_RECV_BLACKLIST_INBOUND:
return;
case S_CONNECT_RECV_ACK:
/* we DID ACK the other peer's request, must send DISCONNECT */
- send_disconnect (n);
+ send_disconnect (n);
n->state = S_DISCONNECT;
- break;
+ break;
case S_CONNECTED:
case S_RECONNECT_BLACKLIST:
case S_RECONNECT_SENT:
/* we are currently connected, need to send disconnect and do
internal notifications and update statistics */
send_disconnect (n);
- GNUNET_STATISTICS_set (GST_stats,
- gettext_noop ("# peers connected"),
+ GNUNET_STATISTICS_set (GST_stats,
+ gettext_noop ("# peers connected"),
--neighbours_connected,
GNUNET_NO);
disconnect_notify_cb (callback_cls, &n->id);
n->is_active = NULL;
if (GNUNET_SCHEDULER_NO_TASK != n->task)
GNUNET_SCHEDULER_cancel (n->task);
- n->task = GNUNET_SCHEDULER_add_now (&master_task, n);
+ n->task = GNUNET_SCHEDULER_add_now (&master_task, n);
}
if (bytes_in_send_queue < mq->message_buf_size)
{
gettext_noop
("# transmission failures for messages to other peers"),
1, GNUNET_NO);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Sending message to `%s' of type %u was a %s\n",
GNUNET_i2s (receiver),
ntohs (((struct GNUNET_MessageHeader *) mq->message_buf)->type),
GNUNET_break (0);
return;
}
- if ((0 == n->primary_address.address->address_length) &&
+ if ((0 == n->primary_address.address->address_length) &&
(NULL == n->primary_address.session))
{
/* no address, why are we here? */
if (NULL != n->is_active)
{
/* transmission already pending */
- return;
+ return;
}
/* timeout messages from the queue that are past their due date */
while (NULL != (mq = n->messages_head))
{
timeout = GNUNET_TIME_absolute_get_remaining (mq->timeout);
- if (timeout.rel_value > 0)
+ if (timeout.rel_value_us > 0)
break;
GNUNET_STATISTICS_update (GST_stats,
gettext_noop
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)
+ if (GNUNET_TIME_absolute_get_remaining (n->keep_alive_time).rel_value_us > 0)
return; /* no keepalive needed at this time */
m.size = htons (sizeof (struct GNUNET_MessageHeader));
m.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_KEEPALIVE);
n->latency = GNUNET_TIME_absolute_get_duration (n->last_keep_alive_time);
n->timeout = GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Latency for peer `%s' is %llu ms\n",
- GNUNET_i2s (&n->id), n->latency.rel_value);
+ "Latency for peer `%s' is %s\n",
+ GNUNET_i2s (&n->id),
+ GNUNET_STRINGS_relative_time_to_string (n->latency,
+ GNUNET_YES));
/* append latency */
ats.type = htonl (GNUNET_ATS_QUALITY_NET_DELAY);
- if (n->latency.rel_value > UINT32_MAX)
+ if (n->latency.rel_value_us > UINT32_MAX)
latency = UINT32_MAX;
else
- latency = n->latency.rel_value;
+ latency = n->latency.rel_value_us;
ats.value = htonl (latency);
- GST_update_ats_metrics (&n->id,
+ GST_ats_update_metrics (&n->id,
n->primary_address.address,
n->primary_address.session,
&ats, 1);
{
struct NeighbourMapEntry *n;
struct GNUNET_TIME_Relative ret;
-
+
if (NULL == neighbours)
{
*do_forward = GNUNET_NO;
}
*do_forward = GNUNET_YES;
ret = GNUNET_BANDWIDTH_tracker_get_delay (&n->in_tracker, 32 * 1024);
- if (ret.rel_value > 0)
+ if (ret.rel_value_us > 0)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Throttling read (%llu bytes excess at %u b/s), waiting %llu ms before reading more.\n",
+ "Throttling read (%llu bytes excess at %u b/s), waiting %s before reading more.\n",
(unsigned long long) n->in_tracker.
consumption_since_last_update__,
(unsigned int) n->in_tracker.available_bytes_per_s__,
- (unsigned long long) ret.rel_value);
+ GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES));
GNUNET_STATISTICS_update (GST_stats,
gettext_noop ("# ms throttling suggested"),
- (int64_t) ret.rel_value, GNUNET_NO);
+ (int64_t) ret.rel_value_us / 1000LL,
+ GNUNET_NO);
}
return ret;
}
struct GNUNET_TRANSPORT_PluginFunctions *papi;
struct SessionConnectMessage connect_msg;
- if (NULL == (papi = GST_plugins_find (na->address->transport_name)))
+ if (NULL == (papi = GST_plugins_find (na->address->transport_name)))
{
GNUNET_break (0);
return;
}
if (NULL == na->session)
- na->session = papi->get_session (papi->cls, na->address);
+ na->session = papi->get_session (papi->cls, na->address);
if (NULL == na->session)
{
GNUNET_break (0);
struct GNUNET_TRANSPORT_PluginFunctions *papi;
struct SessionConnectMessage connect_msg;
- if (NULL == (papi = GST_plugins_find (address->transport_name)))
+ if (NULL == (papi = GST_plugins_find (address->transport_name)))
{
GNUNET_break (0);
return;
}
if (NULL == session)
- session = papi->get_session (papi->cls, address);
+ session = papi->get_session (papi->cls, address);
if (NULL == session)
{
GNUNET_break (0);
struct NeighbourMapEntry *n;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Creating new neighbour entry for `%s'\n",
+ "Creating new neighbour entry for `%s'\n",
GNUNET_i2s (peer));
n = MEMDEBUG_malloc (sizeof (struct NeighbourMapEntry), __LINE__);
n->id = *peer;
MAX_BANDWIDTH_CARRY_S);
n->task = GNUNET_SCHEDULER_add_now (&master_task, n);
GNUNET_assert (GNUNET_OK ==
- GNUNET_CONTAINER_multihashmap_put (neighbours,
- &n->id.hashPubKey, n,
+ GNUNET_CONTAINER_multipeermap_put (neighbours,
+ &n->id, n,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
return n;
}
{
struct NeighbourMapEntry *n;
- if (NULL == neighbours)
+ if (NULL == neighbours)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Asked to connect to peer `%s' during shutdown\n",
GNUNET_i2s (target));
return; /* during shutdown, do nothing */
}
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Asked to connect to peer `%s'\n",
GNUNET_i2s (target));
if (0 == memcmp (target, &GST_my_identity, sizeof (struct GNUNET_PeerIdentity)))
{
/* refuse to connect to myself */
/* FIXME: can this happen? Is this not an API violation? */
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Refusing to try to connect to myself.\n");
return;
}
case S_CONNECT_RECV_ATS:
case S_CONNECT_RECV_BLACKLIST:
case S_CONNECT_RECV_ACK:
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Ignoring request to try to connect to `%s', already trying!\n",
+ 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_CONNECTED:
case S_RECONNECT_ATS:
case S_RECONNECT_BLACKLIST:
case S_RECONNECT_SENT:
case S_CONNECTED_SWITCHING_BLACKLIST:
case S_CONNECTED_SWITCHING_CONNECT_SENT:
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Ignoring request to try to connect, already connected to `%s'!\n",
+ 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:
free_neighbour (n, GNUNET_NO);
break;
case S_DISCONNECT_FINISHED:
- /* should not be possible */
- GNUNET_assert (0);
+ /* should not be possible */
+ GNUNET_assert (0);
default:
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Unhandled state `%s' \n",print_state (n->state));
GNUNET_break (0);
break;
}
}
- n = setup_neighbour (target);
- n->state = S_INIT_ATS;
+ 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);
n->primary_address.session,
n->connect_ack_timestamp);
}
- break;
+ 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,
- NULL, 0);
- }
+ GST_ats_add_address (bcc->na.address, bcc->na.session);
+
n->state = S_CONNECT_RECV_ATS;
n->timeout = GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT);
GNUNET_ATS_reset_backoff (GST_ats, peer);
send_session_connect_ack_message (bcc->na.address,
bcc->na.session,
n->connect_ack_timestamp);
- if (1 == n->send_connect_ack)
+ if (1 == n->send_connect_ack)
n->send_connect_ack = 2;
}
else
n->primary_address.session,
n->connect_ack_timestamp);
}
- break;
+ break;
case S_CONNECTED:
/* already connected, don't care about blacklist */
break;
case S_RECONNECT_ATS:
/* still waiting on ATS suggestion, don't care about blacklist */
- break;
+ break;
case S_RECONNECT_BLACKLIST:
if ( (GNUNET_OK == result) &&
(1 == n->send_connect_ack) )
n->primary_address.session,
n->connect_ack_timestamp);
}
- break;
+ break;
case S_CONNECTED_SWITCHING_BLACKLIST:
if (GNUNET_YES != address_matches (&bcc->na, &n->alternative_address))
break; /* result for an address we currently don't care about */
n->primary_address.session,
n->connect_ack_timestamp);
}
- break;
+ break;
case S_DISCONNECT:
/* Nothing to do here, ATS will already do what can be done */
break;
GNUNET_CONTAINER_DLL_insert (bc_head,
bc_tail,
bcc);
- if (NULL != (bc = GST_blacklist_test_allowed (peer,
+ if (NULL != (bc = GST_blacklist_test_allowed (peer,
address->transport_name,
&handle_test_blacklist_cont, bcc)))
- bcc->bc = bc;
+ 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... */
}
struct GNUNET_TIME_Absolute ts;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Received CONNECT message from peer `%s'\n",
+ "Received CONNECT message from peer `%s'\n",
GNUNET_i2s (peer));
if (ntohs (message->size) != sizeof (struct SessionConnectMessage))
n->connect_ack_timestamp = ts;
switch (n->state)
- {
+ {
case S_NOT_CONNECTED:
n->state = S_CONNECT_RECV_BLACKLIST_INBOUND;
/* Do a blacklist check for the new address */
case S_CONNECT_RECV_ATS:
case S_CONNECT_RECV_BLACKLIST:
case S_CONNECT_RECV_ACK:
- /* It can never hurt to have an alternative address in the above cases,
+ /* 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_RECONNECT_ATS:
case S_RECONNECT_BLACKLIST:
case S_RECONNECT_SENT:
- /* It can never hurt to have an alternative address in the above cases,
+ /* 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;
/**
* For an existing neighbour record, set the active connection to
- * use the given address.
+ * use the given address.
*
* @param peer identity of the peer to switch the address for
* @param address address of the other peer, NULL if other peer
* @param session session to use (or NULL)
* @param ats performance data
* @param ats_count number of entries in ats
- * @param bandwidth_in inbound quota to be used when connection is up
- * @param bandwidth_out outbound quota to be used when connection is up
+ * @param bandwidth_in inbound quota to be used when connection is up,
+ * 0 to disconnect from peer
+ * @param bandwidth_out outbound quota to be used when connection is up,
+ * 0 to disconnect from peer
*/
void
GST_neighbours_switch_to_address (const struct GNUNET_PeerIdentity *peer,
return;
}
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"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>",
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Failed to obtain new session for peer `%s' and address '%s'\n",
- GNUNET_i2s (&address->peer), GST_plugins_a2s (address));
+ GNUNET_i2s (&address->peer), GST_plugins_a2s (address));
GNUNET_ATS_address_destroyed (GST_ats, address, NULL);
return;
}
struct GNUNET_TIME_Relative delay;
n->task = GNUNET_SCHEDULER_NO_TASK;
- delay = GNUNET_TIME_absolute_get_remaining (n->timeout);
+ 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",
+ "Master task runs for neighbour `%s' in state %s with timeout in %s\n",
GNUNET_i2s (&n->id),
print_state(n->state),
- (unsigned long long) delay.rel_value);
+ GNUNET_STRINGS_relative_time_to_string (delay,
+ GNUNET_YES));
switch (n->state)
{
case S_NOT_CONNECTED:
free_neighbour (n, GNUNET_NO);
return;
case S_INIT_ATS:
- if (0 == delay.rel_value)
+ if (0 == delay.rel_value_us)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Connection to `%s' timed out waiting for ATS to provide address\n",
}
break;
case S_INIT_BLACKLIST:
- if (0 == delay.rel_value)
+ if (0 == delay.rel_value_us)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Connection to `%s' timed out waiting for BLACKLIST to approve address\n",
}
break;
case S_CONNECT_SENT:
- if (0 == delay.rel_value)
+ if (0 == delay.rel_value_us)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Connection to `%s' timed out waiting for other peer to send CONNECT_ACK\n",
}
break;
case S_CONNECT_RECV_BLACKLIST_INBOUND:
- if (0 == delay.rel_value)
+ 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",
}
break;
case S_CONNECT_RECV_ATS:
- if (0 == delay.rel_value)
+ 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",
}
break;
case S_CONNECT_RECV_BLACKLIST:
- if (0 == delay.rel_value)
+ 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",
}
break;
case S_CONNECT_RECV_ACK:
- if (0 == delay.rel_value)
+ if (0 == delay.rel_value_us)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Connection to `%s' timed out waiting for other peer to send SESSION_ACK\n",
}
break;
case S_CONNECTED:
- if (0 == delay.rel_value)
+ if (0 == delay.rel_value_us)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Connection to `%s' timed out, missing KEEPALIVE_RESPONSEs\n",
send_keepalive (n);
break;
case S_RECONNECT_ATS:
- if (0 == delay.rel_value)
+ if (0 == delay.rel_value_us)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Connection to `%s' timed out, waiting for ATS replacement address\n",
}
break;
case S_RECONNECT_BLACKLIST:
- if (0 == delay.rel_value)
+ 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",
}
break;
case S_RECONNECT_SENT:
- if (0 == delay.rel_value)
+ if (0 == delay.rel_value_us)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Connection to `%s' timed out, waiting for other peer to CONNECT_ACK replacement address\n",
}
break;
case S_CONNECTED_SWITCHING_BLACKLIST:
- if (0 == delay.rel_value)
+ if (0 == delay.rel_value_us)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Connection to `%s' timed out, missing KEEPALIVE_RESPONSEs\n",
send_keepalive (n);
break;
case S_CONNECTED_SWITCHING_CONNECT_SENT:
- if (0 == delay.rel_value)
+ if (0 == delay.rel_value_us)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Connection to `%s' timed out, missing KEEPALIVE_RESPONSEs (after trying to CONNECT on alternative address)\n",
default:
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Unhandled state `%s' \n",print_state (n->state));
GNUNET_break (0);
- break;
+ break;
}
if ( (S_CONNECTED_SWITCHING_CONNECT_SENT == n->state) ||
(S_CONNECTED_SWITCHING_BLACKLIST == n->state) ||
- (S_CONNECTED == 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
gettext_noop
("# unexpected CONNECT_ACK messages (not ready)"),
1, GNUNET_NO);
- break;
+ break;
case S_CONNECT_SENT:
- if (ts.abs_value != n->primary_address.connect_timestamp.abs_value)
+ if (ts.abs_value_us != n->primary_address.connect_timestamp.abs_value_us)
break; /* ACK does not match our original CONNECT message */
n->state = S_CONNECTED;
n->timeout = GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
- GNUNET_STATISTICS_set (GST_stats,
- gettext_noop ("# peers connected"),
+ GNUNET_STATISTICS_set (GST_stats,
+ gettext_noop ("# peers connected"),
++neighbours_connected,
GNUNET_NO);
connect_notify_cb (callback_cls, &n->id,
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,
- NULL, 0);
+ GST_ats_add_address (n->primary_address.address, n->primary_address.session);
set_address (&n->primary_address,
n->primary_address.address,
n->primary_address.session,
n->state = S_CONNECTED;
n->timeout = GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
GNUNET_break (GNUNET_NO == n->alternative_address.ats_active);
- GNUNET_ATS_address_add(GST_ats,
- n->alternative_address.address,
- n->alternative_address.session,
- NULL, 0);
+
+ GST_ats_add_address (n->alternative_address.address, n->alternative_address.session);
set_address (&n->primary_address,
n->alternative_address.address,
n->alternative_address.session,
GNUNET_YES);
free_address (&n->alternative_address);
send_session_ack_message (n);
- break;
+ break;
case S_DISCONNECT:
GNUNET_STATISTICS_update (GST_stats,
gettext_noop
default:
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Unhandled state `%s' \n",print_state (n->state));
GNUNET_break (0);
- break;
+ break;
}
}
n->suggest_handle = GNUNET_ATS_suggest_address (GST_ats, &n->id);
break;
case S_CONNECT_RECV_BLACKLIST_INBOUND:
- case S_CONNECT_RECV_ATS:
+ case S_CONNECT_RECV_ATS:
case S_CONNECT_RECV_BLACKLIST:
case S_CONNECT_RECV_ACK:
/* error on inbound session; free neighbour entirely */
break;
case S_CONNECTED_SWITCHING_BLACKLIST:
/* primary went down while we were checking secondary against
- blacklist, adopt secondary as primary */
+ blacklist, adopt secondary as primary */
free_address (&n->primary_address);
n->primary_address = n->alternative_address;
memset (&n->alternative_address, 0, sizeof (struct NeighbourAddress));
break;
case S_CONNECTED_SWITCHING_CONNECT_SENT:
/* primary went down while we were waiting for CONNECT_ACK on secondary;
- secondary as primary */
+ secondary as primary */
free_address (&n->primary_address);
n->primary_address = n->alternative_address;
memset (&n->alternative_address, 0, sizeof (struct NeighbourAddress));
{
struct NeighbourMapEntry *n;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Received SESSION_ACK message from peer `%s'\n",
GNUNET_i2s (peer));
if (ntohs (message->size) != sizeof (struct GNUNET_MessageHeader))
}
n->state = S_CONNECTED;
n->timeout = GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
- GNUNET_STATISTICS_set (GST_stats,
- gettext_noop ("# peers connected"),
+ GNUNET_STATISTICS_set (GST_stats,
+ gettext_noop ("# peers connected"),
++neighbours_connected,
GNUNET_NO);
connect_notify_cb (callback_cls, &n->id,
n->primary_address.bandwidth_in,
n->primary_address.bandwidth_out);
- GNUNET_ATS_address_add(GST_ats,
- n->primary_address.address,
- n->primary_address.session,
- NULL, 0);
+
+ GST_ats_add_address (n->primary_address.address, n->primary_address.session);
set_address (&n->primary_address,
n->primary_address.address,
n->primary_address.session,
sdm = (const struct SessionDisconnectMessage *) msg;
if (NULL == (n = lookup_neighbour (peer)))
return; /* gone already */
- if (GNUNET_TIME_absolute_ntoh (sdm->timestamp).abs_value <= n->connect_ack_timestamp.abs_value)
+ if (GNUNET_TIME_absolute_ntoh (sdm->timestamp).abs_value_us <= n->connect_ack_timestamp.abs_value_us)
{
GNUNET_STATISTICS_update (GST_stats,
gettext_noop
return;
}
GNUNET_CRYPTO_hash (&sdm->public_key,
- sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
+ sizeof (struct GNUNET_CRYPTO_EccPublicSignKey),
&hc);
if (0 != memcmp (peer, &hc, sizeof (struct GNUNET_PeerIdentity)))
{
}
if (ntohl (sdm->purpose.size) !=
sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
- sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded) +
+ sizeof (struct GNUNET_CRYPTO_EccPublicSignKey) +
sizeof (struct GNUNET_TIME_AbsoluteNBO))
{
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "%s message from peer `%s' has invalid size \n",
+ "DISCONNECT",
+ GNUNET_i2s (peer));
GNUNET_break_op (0);
return;
}
(GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_DISCONNECT, &sdm->purpose,
&sdm->signature, &sdm->public_key))
{
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "%s message from peer `%s' cannot be verified \n",
+ "DISCONNECT",
+ GNUNET_i2s (peer));
GNUNET_break_op (0);
return;
}
* @return GNUNET_OK (continue to iterate)
*/
static int
-neighbours_iterate (void *cls, const struct GNUNET_HashCode * key, void *value)
+neighbours_iterate (void *cls, const struct GNUNET_PeerIdentity * key, void *value)
{
struct IteratorContext *ic = cls;
struct NeighbourMapEntry *n = value;
{
struct IteratorContext ic;
- if (NULL == neighbours)
+ if (NULL == neighbours)
return; /* can happen during shutdown */
ic.cb = cb;
ic.cb_cls = cb_cls;
- GNUNET_CONTAINER_multihashmap_iterate (neighbours, &neighbours_iterate, &ic);
+ GNUNET_CONTAINER_multipeermap_iterate (neighbours, &neighbours_iterate, &ic);
}
* Obtain current latency information for the given neighbour.
*
* @param peer to get the latency for
- * @return observed latency of the address, FOREVER if the
+ * @return observed latency of the address, FOREVER if the
* the connection is not up
*/
struct GNUNET_TIME_Relative
struct NeighbourMapEntry *n;
n = lookup_neighbour (peer);
- if (NULL == n)
+ if (NULL == n)
return GNUNET_TIME_UNIT_FOREVER_REL;
switch (n->state)
{
GNUNET_break (0);
break;
}
- return GNUNET_TIME_UNIT_FOREVER_REL;
+ return GNUNET_TIME_UNIT_FOREVER_REL;
}
connect_notify_cb = connect_cb;
disconnect_notify_cb = disconnect_cb;
address_change_cb = peer_address_cb;
- neighbours = GNUNET_CONTAINER_multihashmap_create (NEIGHBOUR_TABLE_SIZE, GNUNET_NO);
+ neighbours = GNUNET_CONTAINER_multipeermap_create (NEIGHBOUR_TABLE_SIZE, GNUNET_NO);
}
* @return GNUNET_OK (continue to iterate)
*/
static int
-disconnect_all_neighbours (void *cls, const struct GNUNET_HashCode * key, void *value)
+disconnect_all_neighbours (void *cls,
+ const struct GNUNET_PeerIdentity *key,
+ void *value)
{
struct NeighbourMapEntry *n = value;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Disconnecting peer `%4s', %s\n",
GNUNET_i2s (&n->id), "SHUTDOWN_TASK");
n->state = S_DISCONNECT_FINISHED;
{
if (NULL == neighbours)
return;
- GNUNET_CONTAINER_multihashmap_iterate (neighbours,
+ GNUNET_CONTAINER_multipeermap_iterate (neighbours,
&disconnect_all_neighbours,
NULL);
- GNUNET_CONTAINER_multihashmap_destroy (neighbours);
+ GNUNET_CONTAINER_multipeermap_destroy (neighbours);
neighbours = NULL;
callback_cls = NULL;
connect_notify_cb = NULL;