/*
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
*/
#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_us)
+ {
+ 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_EccPublicKey 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;
};
*/
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
* Address that is being checked.
*/
struct NeighbourAddress na;
-
- /**
- * ATS information about the address.
- */
- struct GNUNET_ATS_Information *ats;
/**
* Handle to the ongoing blacklist check.
*/
struct GST_BlacklistCheck *bc;
-
- /**
- * Size of the 'ats' array.
- */
- uint32_t ats_count;
-
};
GNUNET_break (0);
return "UNDEFINED";
}
- 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);
{
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... */
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;
(NULL != (papi = GST_plugins_find (backup_primary->transport_name))))
papi->disconnect (papi->cls, &n->id);
- GNUNET_free_non_null (backup_primary);
+ MEMDEBUG_free_non_null (backup_primary, __LINE__);
GNUNET_assert (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap_remove (neighbours,
// 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__);
}
/**
timeout,
cont, cont_cls)))) &&
(NULL != cont))
- cont (cont_cls, &n->id, GNUNET_SYSERR);
+ 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_EccPublicKey) +
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__);
}
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
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 */
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);
* plus calculated latency) to ATS.
*
* @param neighbour neighbour to keep alive
- * @param ats performance data
- * @param ats_count number of entries in ats
*/
void
-GST_neighbours_keepalive_response (const struct GNUNET_PeerIdentity *neighbour,
- const struct GNUNET_ATS_Information *ats,
- uint32_t ats_count)
+GST_neighbours_keepalive_response (const struct GNUNET_PeerIdentity *neighbour)
{
struct NeighbourMapEntry *n;
uint32_t latency;
- struct GNUNET_ATS_Information ats_new[ats_count + 1];
+ struct GNUNET_ATS_Information ats;
if (NULL == (n = lookup_neighbour (neighbour)))
{
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,
- "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_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Latency for peer `%s' is %s\n",
+ GNUNET_i2s (&n->id),
+ GNUNET_STRINGS_relative_time_to_string (n->latency,
+ GNUNET_YES));
/* append latency */
- ats_new[ats_count].type = htonl (GNUNET_ATS_QUALITY_NET_DELAY);
- if (n->latency.rel_value > UINT32_MAX)
+ ats.type = htonl (GNUNET_ATS_QUALITY_NET_DELAY);
+ if (n->latency.rel_value_us > UINT32_MAX)
latency = UINT32_MAX;
else
- latency = n->latency.rel_value;
- ats_new[ats_count].value = htonl (latency);
- GNUNET_ATS_address_update (GST_ats,
- n->primary_address.address,
- n->primary_address.session, ats_new,
- ats_count + 1);
+ latency = n->latency.rel_value_us;
+ ats.value = htonl (latency);
+ GST_ats_update_metrics (&n->id,
+ n->primary_address.address,
+ n->primary_address.session,
+ &ats, 1);
}
}
*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;
}
{
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);
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;
struct NeighbourMapEntry *n;
if (NULL == neighbours)
- return; /* during shutdown, do nothing */
+ {
+ 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,
"Asked to connect to peer `%s'\n",
GNUNET_i2s (target));
- if (0 ==
- memcmp (target, &GST_my_identity, sizeof (struct GNUNET_PeerIdentity)))
+ 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? */
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:
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);
- }
+ 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);
- 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__);
}
* @param address address of the other peer, NULL if other peer
* connected to us
* @param session session to use (or NULL)
- * @param ats performance data
- * @param ats_count number of entries in ats (excluding 0-termination)
*/
static void
check_blacklist (const struct GNUNET_PeerIdentity *peer,
struct GNUNET_TIME_Absolute ts,
const struct GNUNET_HELLO_Address *address,
- struct Session *session,
- const struct GNUNET_ATS_Information *ats,
- uint32_t ats_count)
+ struct Session *session)
{
struct BlackListCheckContext *bcc;
struct GST_BlacklistCheck *bc;
bcc =
- GNUNET_malloc (sizeof (struct BlackListCheckContext) +
- sizeof (struct GNUNET_ATS_Information) * ats_count);
- bcc->ats_count = ats_count;
+ MEMDEBUG_malloc (sizeof (struct BlackListCheckContext), __LINE__);
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];
- memcpy (bcc->ats, ats, sizeof (struct GNUNET_ATS_Information) * ats_count);
GNUNET_CONTAINER_DLL_insert (bc_head,
bc_tail,
bcc);
* @param address address of the other peer, NULL if other peer
* connected to us
* @param session session to use (or NULL)
- * @param ats performance data
- * @param ats_count number of entries in ats (excluding 0-termination)
*/
void
GST_neighbours_handle_connect (const struct GNUNET_MessageHeader *message,
const struct GNUNET_PeerIdentity *peer,
const struct GNUNET_HELLO_Address *address,
- struct Session *session,
- const struct GNUNET_ATS_Information *ats,
- uint32_t ats_count)
+ struct Session *session)
{
const struct SessionConnectMessage *scm;
struct NeighbourMapEntry *n;
case S_NOT_CONNECTED:
n->state = S_CONNECT_RECV_BLACKLIST_INBOUND;
/* Do a blacklist check for the new address */
- check_blacklist (peer, ts, address, session, ats, ats_count);
+ check_blacklist (peer, ts, address, session);
break;
case S_INIT_ATS:
/* CONNECT message takes priority over us asking ATS for address */
case S_CONNECT_RECV_ACK:
/* It can never hurt to have an alternative address in the above cases,
see if it is allowed */
- check_blacklist (peer, ts, address, session, ats, ats_count);
+ check_blacklist (peer, ts, address, session);
break;
case S_CONNECTED:
/* we are already connected and can thus send the ACK immediately;
n->send_connect_ack = 0;
send_session_connect_ack_message (n->primary_address.address,
n->primary_address.session, ts);
- check_blacklist (peer, ts, address, session, ats, ats_count);
+ 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,
see if it is allowed */
- check_blacklist (peer, ts, address, session, ats, ats_count);
+ check_blacklist (peer, ts, address, session);
break;
case S_CONNECTED_SWITCHING_BLACKLIST:
case S_CONNECTED_SWITCHING_CONNECT_SENT:
n->send_connect_ack = 0;
send_session_connect_ack_message (n->primary_address.address,
n->primary_address.session, ts);
- check_blacklist (peer, ts, address, session, ats, ats_count);
+ check_blacklist (peer, ts, address, session);
break;
case S_DISCONNECT:
/* get rid of remains without terminating sessions, ready to re-try */
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;
}
n->timeout = GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT);
check_blacklist (&n->id,
n->connect_ack_timestamp,
- address, session, ats, ats_count);
+ address, session);
break;
case S_INIT_BLACKLIST:
/* ATS suggests a different address, switch again */
n->timeout = GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT);
check_blacklist (&n->id,
n->connect_ack_timestamp,
- address, session, ats, ats_count);
+ address, session);
break;
case S_CONNECT_SENT:
/* ATS suggests a different address, switch again */
n->timeout = GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT);
check_blacklist (&n->id,
n->connect_ack_timestamp,
- address, session, ats, ats_count);
+ address, session);
break;
case S_CONNECT_RECV_ATS:
set_address (&n->primary_address,
n->timeout = GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT);
check_blacklist (&n->id,
n->connect_ack_timestamp,
- address, session, ats, ats_count);
+ address, session);
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);
+ address, session);
break;
case S_CONNECT_RECV_BLACKLIST:
case S_CONNECT_RECV_ACK:
n->timeout = GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT);
check_blacklist (&n->id,
n->connect_ack_timestamp,
- address, session, ats, ats_count);
+ address, session);
break;
case S_CONNECTED:
GNUNET_assert (NULL != n->primary_address.address);
n->state = S_CONNECTED_SWITCHING_BLACKLIST;
check_blacklist (&n->id,
GNUNET_TIME_absolute_get (),
- address, session, ats, ats_count);
+ address, session);
break;
case S_RECONNECT_ATS:
set_address (&n->primary_address,
n->timeout = GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT);
check_blacklist (&n->id,
n->connect_ack_timestamp,
- address, session, ats, ats_count);
+ address, session);
break;
case S_RECONNECT_BLACKLIST:
/* ATS asks us to switch while we were trying to reconnect; switch to new
n->timeout = GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT);
check_blacklist (&n->id,
n->connect_ack_timestamp,
- address, session, ats, ats_count);
+ address, session);
break;
case S_RECONNECT_SENT:
/* ATS asks us to switch while we were trying to reconnect; switch to new
n->timeout = GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT);
check_blacklist (&n->id,
n->connect_ack_timestamp,
- address, session, ats, ats_count);
+ address, session);
break;
case S_CONNECTED_SWITCHING_BLACKLIST:
if (n->primary_address.session == session)
address, session, bandwidth_in, bandwidth_out, GNUNET_NO);
check_blacklist (&n->id,
GNUNET_TIME_absolute_get (),
- address, session, ats, ats_count);
+ address, session);
break;
case S_CONNECTED_SWITCHING_CONNECT_SENT:
if (n->primary_address.session == session)
n->state = S_CONNECTED_SWITCHING_BLACKLIST;
check_blacklist (&n->id,
GNUNET_TIME_absolute_get (),
- address, session, ats, ats_count);
+ address, session);
break;
case S_DISCONNECT:
/* not going to switch addresses while disconnecting */
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",
+ "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",
* @param address address of the other peer, NULL if other peer
* connected to us
* @param session session to use (or NULL)
- * @param ats performance data
- * @param ats_count number of entries in ats
*/
void
GST_neighbours_handle_connect_ack (const struct GNUNET_MessageHeader *message,
const struct GNUNET_PeerIdentity *peer,
const struct GNUNET_HELLO_Address *address,
- struct Session *session,
- const struct GNUNET_ATS_Information *ats,
- uint32_t ats_count)
+ struct Session *session)
{
const struct SessionConnectMessage *scm;
struct GNUNET_TIME_Absolute ts;
1, GNUNET_NO);
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);
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,
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);
+ 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,
- ats, ats_count);
+
+ 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,
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)))
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:
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
* @param address address of the other peer, NULL if other peer
* connected to us
* @param session session to use (or NULL)
- * @param ats performance data
- * @param ats_count number of entries in ats
*/
void
GST_neighbours_handle_session_ack (const struct GNUNET_MessageHeader *message,
const struct GNUNET_PeerIdentity *peer,
const struct GNUNET_HELLO_Address *address,
- struct Session *session,
- const struct GNUNET_ATS_Information *ats,
- uint32_t ats_count)
+ struct Session *session)
{
struct NeighbourMapEntry *n;
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,
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);
+
+ 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_RsaPublicKeyBinaryEncoded),
+ sizeof (struct GNUNET_CRYPTO_EccPublicKey),
&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_EccPublicKey) +
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;
}
if (GNUNET_OK !=
- GNUNET_CRYPTO_rsa_verify
+ GNUNET_CRYPTO_ecc_verify
(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;
}
bandwidth_out = GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT;
}
- ic->cb (ic->cb_cls, &n->id, NULL, 0,
+ ic->cb (ic->cb_cls, &n->id,
n->primary_address.address,
bandwidth_in, bandwidth_out);
}
* @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,
- 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;