#include "transport.h"
+
/**
* Size of the neighbour hash map.
*/
*/
#define BLACKLIST_RESPONSE_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 500)
+#define DEBUG_MALLOC GNUNET_NO
+
+#if DEBUG_MALLOC
+
+struct Allocator
+{
+ struct Allocator *prev;
+ struct Allocator *next;
+
+ unsigned int bytes_alloced;
+ unsigned int max_alloced;
+ unsigned int diff;
+ unsigned int line;
+
+ struct GNUNET_TIME_Absolute max_alloced_when;
+ struct GNUNET_TIME_Absolute last_alloced_when;
+
+};
+
+struct Allocator *aehead;
+struct Allocator *aetail;
+
+struct Allocation
+{
+ struct Allocation *prev;
+ struct Allocation *next;
+
+ struct Allocator *alloc;
+ unsigned int bytes_alloced;
+ void *p;
+ unsigned int line;
+};
+
+struct Allocation *ahead;
+struct Allocation *atail;
+
+static int bytes_alloced;
+
+static struct Allocator *
+find_allocator (int line)
+{
+ struct Allocator *cur = aehead;
+ while (NULL != cur)
+ {
+ if (line == cur->line)
+ return cur;
+ cur = cur->next;
+ }
+ return cur;
+}
+
+static void
+print_allocators ()
+{
+ static int start = GNUNET_YES;
+ static struct GNUNET_TIME_Absolute next;
+ static struct GNUNET_TIME_Relative rem;
+ struct Allocator *cur = aehead;
+ if (start)
+ {
+ next = GNUNET_TIME_UNIT_ZERO_ABS;
+ start = GNUNET_NO;
+ }
+ if (0 == (rem = GNUNET_TIME_absolute_get_remaining(next)).rel_value)
+ {
+ fprintf (stderr, "Allocated in `%s' total: %5u bytes\n", __FILE__, bytes_alloced);
+ while (NULL != cur)
+ {
+ char *last_alloc = GNUNET_strdup (GNUNET_STRINGS_absolute_time_to_string(cur->max_alloced_when));
+ fprintf (stderr, "Allocated from line %4u :%5u bytes (diff %5i bytes, max alloc: %5u @ %s, last alloc %s)\n",
+ cur->line, cur->bytes_alloced, cur->diff, cur->max_alloced,
+ last_alloc,
+ GNUNET_STRINGS_absolute_time_to_string(cur->last_alloced_when));
+ GNUNET_free (last_alloc);
+ cur->diff = 0;
+ cur = cur->next;
+ }
+ fprintf (stderr, "\n");
+ next = GNUNET_TIME_absolute_add(GNUNET_TIME_absolute_get(), GNUNET_TIME_UNIT_SECONDS);
+ }
+}
+
+#endif
+
+static void
+MEMDEBUG_add_alloc (void *p, size_t size, int line)
+{
+#if DEBUG_MALLOC
+ struct Allocation *alloc = GNUNET_malloc (sizeof (struct Allocation));
+ struct Allocator *allocator = find_allocator(line);
+ if (NULL == allocator)
+ {
+ allocator = GNUNET_malloc (sizeof (struct Allocator));
+ allocator->line = line;
+ GNUNET_CONTAINER_DLL_insert (aehead, aetail, allocator);
+ }
+ alloc->alloc = allocator;
+ alloc->p = p;
+ alloc->line = line;
+ alloc->bytes_alloced = size;
+ allocator->bytes_alloced += size;
+ allocator->last_alloced_when = GNUNET_TIME_absolute_get();
+ if (allocator->bytes_alloced >= allocator->max_alloced)
+ {
+ allocator->max_alloced = allocator->bytes_alloced;
+ allocator->max_alloced_when = allocator->last_alloced_when;
+ }
+ allocator->diff += size;
+ GNUNET_CONTAINER_DLL_insert (ahead, atail, alloc);
+ print_allocators ();
+ bytes_alloced += size;
+#endif
+}
+
+
+static void *
+MEMDEBUG_malloc (size_t size, int line)
+{
+ void * ret;
+
+ ret = GNUNET_malloc (size);
+#if DEBUG_MALLOC
+ if (NULL != ret)
+ MEMDEBUG_add_alloc (ret, size, line);
+#endif
+ return ret;
+
+}
+
+static void
+MEMDEBUG_free (void * alloc, int line)
+{
+#if DEBUG_MALLOC
+ struct Allocation *cur;
+ struct Allocator *allocator;
+ cur = ahead;
+ while (NULL != cur)
+ {
+ if (alloc == cur->p)
+ break;
+ cur = cur->next;
+ }
+ if (NULL == cur)
+ {
+ fprintf (stderr, "Unmonitored free from line %4u\n", line);
+ GNUNET_break (0);
+ return;
+ }
+ allocator = cur->alloc;
+ if (NULL == allocator)
+ {
+ GNUNET_break (0);
+ }
+ GNUNET_CONTAINER_DLL_remove (ahead, atail, cur);
+ allocator->bytes_alloced -= cur->bytes_alloced;
+ allocator->diff -= cur->bytes_alloced;
+ GNUNET_assert (allocator->bytes_alloced >= 0);
+ bytes_alloced -= cur->bytes_alloced;
+ GNUNET_assert (bytes_alloced >= 0);
+ GNUNET_free (cur);
+#endif
+ GNUNET_free (alloc);
+}
+
+static void
+MEMDEBUG_free_non_null (void * alloc, int line)
+{
+ if (alloc != NULL)
+ MEMDEBUG_free (alloc, line);
+}
+
GNUNET_NETWORK_STRUCT_BEGIN
* Purpose of the signature. Extends over the timestamp.
* Purpose should be GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DISCONNECT.
*/
- struct GNUNET_CRYPTO_RsaSignaturePurpose purpose;
+ struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
/**
* Absolute time at the sender. Only the most recent connect
/**
* Public key of the sender.
*/
- struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded public_key;
+ struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded public_key;
/**
* Signature of the peer that sends us the disconnect. Only
* valid if the timestamp is AFTER the timestamp from the
* corresponding 'CONNECT' message.
*/
- struct GNUNET_CRYPTO_RsaSignature signature;
+ struct GNUNET_CRYPTO_EccSignature signature;
};
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
};
*/
struct GNUNET_TIME_Absolute connect_ack_timestamp;
+ /**
+ * ATS address suggest handle
+ */
+ struct GNUNET_ATS_SuggestHandle *suggest_handle;
+
/**
* Time where we should cut the connection (timeout) if we don't
* make progress in the state machine (or get a KEEPALIVE_RESPONSE
/**
* 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";
- break;
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";
}
/**
{
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);
+ address_change_cb (NULL, &na->address->peer, NULL);
}
+
na->ats_active = GNUNET_NO;
if (NULL != na->address)
{
- GNUNET_HELLO_address_free (na->address);
+ MEMDEBUG_free (na->address, __LINE__);
+ //GNUNET_HELLO_address_free (na->address);
na->address = NULL;
}
na->session = NULL;
int is_active)
{
struct GNUNET_TRANSPORT_PluginFunctions *papi;
-
if (NULL == (papi = GST_plugins_find (address->transport_name)))
{
GNUNET_break (0);
na->ats_active = is_active;
GNUNET_ATS_address_in_use (GST_ats, na->address, na->session, is_active);
GST_validation_set_address_use (na->address, na->session, is_active, __LINE__);
+ if (is_active)
+ address_change_cb (NULL, &address->peer, address);
}
if (GNUNET_YES == is_active)
{
return;
}
na->address = GNUNET_HELLO_address_copy (address);
+ MEMDEBUG_add_alloc (na->address, GNUNET_HELLO_address_get_size (na->address), __LINE__);
na->bandwidth_in = bandwidth_in;
na->bandwidth_out = bandwidth_out;
na->session = session;
/* Telling ATS about new session */
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__);
-
+ address_change_cb (NULL, &address->peer, address);
/* 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);
{
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);
- GNUNET_free (mq);
+ mq->cont (mq->cont_cls, GNUNET_SYSERR, mq->message_buf_size, 0);
+ MEMDEBUG_free (mq, __LINE__);
}
/* It is too late to send other peer disconnect notifications, but at
least internally we need to get clean... */
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);
+ MEMDEBUG_add_alloc (backup_primary, GNUNET_HELLO_address_get_size(backup_primary), __LINE__);
+ }
+ 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. */
+
+ /* cut transport-level connection */
if ((GNUNET_NO == keep_sessions) &&
- (NULL != n->primary_address.address) &&
- (NULL != (papi = GST_plugins_find (n->primary_address.address->transport_name))))
+ (NULL != backup_primary) &&
+ (NULL != (papi = GST_plugins_find (backup_primary->transport_name))))
papi->disconnect (papi->cls, &n->id);
- n->state = S_DISCONNECT_FINISHED;
+ MEMDEBUG_free_non_null (backup_primary, __LINE__);
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
// such a handle, we should cancel the operation here!
- GNUNET_ATS_suggest_address_cancel (GST_ats, &n->id);
+ if (NULL != n->suggest_handle)
+ {
+ GNUNET_ATS_suggest_address_cancel (GST_ats, &n->id);
+ n->suggest_handle = NULL;
+ }
if (GNUNET_SCHEDULER_NO_TASK != n->task)
{
n->task = GNUNET_SCHEDULER_NO_TASK;
}
/* free rest of memory */
- GNUNET_free (n);
+ MEMDEBUG_free (n, __LINE__);
}
-
/**
* 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;
htons (GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_DISCONNECT);
disconnect_msg.reserved = htonl (0);
disconnect_msg.purpose.size =
- htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
- sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) +
+ htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
+ sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded) +
sizeof (struct GNUNET_TIME_AbsoluteNBO));
disconnect_msg.purpose.purpose =
htonl (GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_DISCONNECT);
GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get ());
disconnect_msg.public_key = GST_my_public_key;
GNUNET_assert (GNUNET_OK ==
- GNUNET_CRYPTO_rsa_sign (GST_my_private_key,
+ GNUNET_CRYPTO_ecc_sign (GST_my_private_key,
&disconnect_msg.purpose,
&disconnect_msg.signature));
* @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;
if (NULL == (n = lookup_neighbour (receiver)))
{
- GNUNET_free (mq);
+ MEMDEBUG_free (mq, __LINE__);
return; /* disconnect or other error while transmitting, can happen */
}
if (n->is_active == mq)
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_ERROR,
+ "Bytes_in_send_queue `%u', Message_size %u, result: %s, payload %u, on wire %u\n",
+ bytes_in_send_queue, mq->message_buf_size,
+ (GNUNET_OK == success) ? "OK" : "FAIL",
+ size_payload, physical);
+ 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);
- GNUNET_free (mq);
+ mq->cont (mq->cont_cls, success, size_payload, physical);
+ MEMDEBUG_free (mq, __LINE__);
}
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));
n->expect_latency_response = GNUNET_NO;
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,
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Latency for peer `%s' is %llu ms\n",
GNUNET_i2s (&n->id), n->latency.rel_value);
memcpy (ats_new, ats, sizeof (struct GNUNET_ATS_Information) * ats_count);
{
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;
gettext_noop
("# bytes in message queue for other peers"),
bytes_in_send_queue, GNUNET_NO);
- mq = GNUNET_malloc (sizeof (struct MessageQueue) + msg_size);
+ mq = MEMDEBUG_malloc (sizeof (struct MessageQueue) + msg_size, __LINE__);
mq->cont = cont;
mq->cont_cls = cont_cls;
memcpy (&mq[1], msg, msg_size);
{
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);
+
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Creating new neighbour entry for `%s'\n",
GNUNET_i2s (peer));
- n = GNUNET_malloc (sizeof (struct NeighbourMapEntry));
+ n = MEMDEBUG_malloc (sizeof (struct NeighbourMapEntry), __LINE__);
n->id = *peer;
n->state = S_NOT_CONNECTED;
n->latency = GNUNET_TIME_UNIT_FOREVER_REL;
n->timeout = GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT);
GNUNET_ATS_reset_backoff (GST_ats, target);
- GNUNET_ATS_suggest_address (GST_ats, target);
+ n->suggest_handle = GNUNET_ATS_suggest_address (GST_ats, target);
}
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_suggest_address (GST_ats, &n->id);
+ n->suggest_handle = GNUNET_ATS_suggest_address (GST_ats, &n->id);
}
break;
case S_CONNECT_SENT:
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);
+ n->suggest_handle = GNUNET_ATS_suggest_address (GST_ats, peer);
break;
case S_CONNECT_RECV_ATS:
/* still waiting on ATS suggestion, don't care about blacklist */
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);
+ n->suggest_handle = GNUNET_ATS_suggest_address (GST_ats, &n->id);
}
break;
case S_CONNECT_RECV_ACK:
n->state = S_RECONNECT_ATS;
n->timeout = GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT);
// FIXME: do we need to ask ATS again for suggestions?
- GNUNET_ATS_suggest_address (GST_ats, &n->id);
+ n->suggest_handle = GNUNET_ATS_suggest_address (GST_ats, &n->id);
}
break;
case S_RECONNECT_SENT:
break;
}
cleanup:
- GNUNET_HELLO_address_free (bcc->na.address);
+ MEMDEBUG_free (bcc->na.address, __LINE__);
+ //GNUNET_HELLO_address_free (bcc->na.address);
GNUNET_CONTAINER_DLL_remove (bc_head,
bc_tail,
bcc);
- GNUNET_free (bcc);
+ MEMDEBUG_free (bcc, __LINE__);
}
struct GST_BlacklistCheck *bc;
bcc =
- GNUNET_malloc (sizeof (struct BlackListCheckContext) +
- sizeof (struct GNUNET_ATS_Information) * ats_count);
+ MEMDEBUG_malloc (sizeof (struct BlackListCheckContext) +
+ sizeof (struct GNUNET_ATS_Information) * ats_count, __LINE__);
bcc->ats_count = ats_count;
bcc->na.address = GNUNET_HELLO_address_copy (address);
+ MEMDEBUG_add_alloc (bcc->na.address, GNUNET_HELLO_address_get_size (address), __LINE__);
bcc->na.session = session;
bcc->na.connect_timestamp = ts;
bcc->ats = (struct GNUNET_ATS_Information *) &bcc[1];
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:
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:
n = setup_neighbour (peer);
n->state = S_CONNECT_RECV_ATS;
GNUNET_ATS_reset_backoff (GST_ats, peer);
- GNUNET_ATS_suggest_address (GST_ats, peer);
+ n->suggest_handle = GNUNET_ATS_suggest_address (GST_ats, peer);
break;
case S_DISCONNECT_FINISHED:
/* should not be possible */
if (NULL == (papi = GST_plugins_find (address->transport_name)))
{
/* we don't have the plugin for this address */
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "2348 : `%s' \n", address->transport_name);
GNUNET_ATS_address_destroyed (GST_ats, address, NULL);
return;
}
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:
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 %d with timeout in %llu ms\n",
+ "Master task runs for neighbour `%s' in state %s with timeout in %llu ms\n",
GNUNET_i2s (&n->id),
- n->state,
+ print_state(n->state),
(unsigned long long) delay.rel_value);
switch (n->state)
{
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, GNUNET_NO);
return;
case S_DISCONNECT_FINISHED:
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);
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);
+ 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,
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,
+ 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 (bcc->na.session == session)
{
GST_blacklist_test_cancel (bcc->bc);
- GNUNET_HELLO_address_free (bcc->na.address);
+ MEMDEBUG_free (bcc->na.address, __LINE__);
+ //GNUNET_HELLO_address_free (bcc->na.address);
GNUNET_CONTAINER_DLL_remove (bc_head,
bc_tail,
bcc);
- GNUNET_free (bcc);
+ MEMDEBUG_free (bcc, __LINE__);
}
}
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;
case S_NOT_CONNECTED:
GNUNET_break (0);
free_neighbour (n, GNUNET_NO);
- return;
+ return GNUNET_YES;
case S_INIT_ATS:
GNUNET_break (0);
free_neighbour (n, GNUNET_NO);
- return;
+ return GNUNET_YES;
case S_INIT_BLACKLIST:
case S_CONNECT_SENT:
free_address (&n->primary_address);
n->state = S_INIT_ATS;
n->timeout = GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT);
// FIXME: need to ask ATS for suggestions again?
- GNUNET_ATS_suggest_address (GST_ats, &n->id);
+ n->suggest_handle = GNUNET_ATS_suggest_address (GST_ats, &n->id);
break;
case S_CONNECT_RECV_BLACKLIST_INBOUND:
case S_CONNECT_RECV_ATS:
/* error on inbound session; free neighbour entirely */
free_address (&n->primary_address);
free_neighbour (n, GNUNET_NO);
- return;
+ return GNUNET_YES;
case S_CONNECTED:
free_address (&n->primary_address);
n->state = S_RECONNECT_ATS;
n->timeout = GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT);
/* FIXME: is this ATS call needed? */
- GNUNET_ATS_suggest_address (GST_ats, &n->id);
+ n->suggest_handle = GNUNET_ATS_suggest_address (GST_ats, &n->id);
break;
case S_RECONNECT_ATS:
/* we don't have an address, how can it go down? */
n->state = S_RECONNECT_ATS;
n->timeout = GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT);
// FIXME: need to ask ATS for suggestions again?
- GNUNET_ATS_suggest_address (GST_ats, &n->id);
+ n->suggest_handle = GNUNET_ATS_suggest_address (GST_ats, &n->id);
break;
case S_CONNECTED_SWITCHING_BLACKLIST:
/* primary went down while we were checking secondary against
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,
return;
}
GNUNET_CRYPTO_hash (&sdm->public_key,
- sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+ sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
&hc);
if (0 != memcmp (peer, &hc, sizeof (struct GNUNET_PeerIdentity)))
{
return;
}
if (ntohl (sdm->purpose.size) !=
- sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
- sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) +
+ sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
+ sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded) +
sizeof (struct GNUNET_TIME_AbsoluteNBO))
{
GNUNET_break_op (0);
return;
}
if (GNUNET_OK !=
- GNUNET_CRYPTO_rsa_verify
+ GNUNET_CRYPTO_ecc_verify
(GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_DISCONNECT, &sdm->purpose,
&sdm->signature, &sdm->public_key))
{
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_RECV_BLACKLIST_INBOUND:
- case S_CONNECT_SENT:
+ 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;
* @param disconnect_cb function to call if we disconnect from a peer
* @param peer_address_cb function to call if we change an active address
* of a neighbour
+ * @param max_fds maximum number of fds to use
*/
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)
+ GNUNET_TRANSPORT_PeerIterateCallback peer_address_cb,
+ unsigned int max_fds)
{
callback_cls = cls;
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);
}