*/
#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);
-}
-
+/**
+ * Interval to send utilization data
+ */
+#define UTIL_TRANSMISSION_INTERVAL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
GNUNET_NETWORK_STRUCT_BEGIN
/**
* Public key of the sender.
*/
- struct GNUNET_CRYPTO_EccPublicSignKey public_key;
+ struct GNUNET_CRYPTO_EddsaPublicKey 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_EccSignature signature;
+ struct GNUNET_CRYPTO_EddsaSignature signature;
};
*/
int send_connect_ack;
+ /**
+ * Tracking utilization of outbound bandwidth
+ */
+ uint32_t util_payload_bytes_sent;
+
+ /**
+ * Tracking utilization of inbound bandwidth
+ */
+ uint32_t util_payload_bytes_recv;
+
+ /**
+ * Tracking utilization of outbound bandwidth
+ */
+ uint32_t util_total_bytes_sent;
+
+ /**
+ * Tracking utilization of inbound bandwidth
+ */
+ uint32_t util_total_bytes_recv;
+
+
+
+
+ /**
+ * Date of last utilization transmission
+ */
+ struct GNUNET_TIME_Absolute last_util_transmission;
};
*/
static unsigned long long bytes_in_send_queue;
+/**
+ * Task transmitting utilization data
+ */
+static GNUNET_SCHEDULER_TaskIdentifier util_transmission_tk;
+
/**
* Lookup a neighbour entry in the neighbours hash map.
na->ats_active = GNUNET_NO;
if (NULL != na->address)
{
- MEMDEBUG_free (na->address, __LINE__);
- //GNUNET_HELLO_address_free (na->address);
+ GNUNET_HELLO_address_free (na->address);
na->address = NULL;
}
na->session = NULL;
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;
GNUNET_CONTAINER_DLL_remove (n->messages_head, n->messages_tail, mq);
if (NULL != mq->cont)
mq->cont (mq->cont_cls, GNUNET_SYSERR, mq->message_buf_size, 0);
- MEMDEBUG_free (mq, __LINE__);
+ GNUNET_free (mq);
}
/* It is too late to send other peer disconnect notifications, but at
least internally we need to get clean... */
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);
- MEMDEBUG_free_non_null (backup_primary, __LINE__);
+ GNUNET_free_non_null (backup_primary);
GNUNET_assert (GNUNET_YES ==
GNUNET_CONTAINER_multipeermap_remove (neighbours,
n->task = GNUNET_SCHEDULER_NO_TASK;
}
/* free rest of memory */
- MEMDEBUG_free (n, __LINE__);
+ GNUNET_free (n);
}
/**
disconnect_msg.reserved = htonl (0);
disconnect_msg.purpose.size =
htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
- sizeof (struct GNUNET_CRYPTO_EccPublicSignKey) +
+ sizeof (struct GNUNET_CRYPTO_EddsaPublicKey) +
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_identity.public_key;
GNUNET_assert (GNUNET_OK ==
- GNUNET_CRYPTO_ecc_sign (GST_my_private_key,
+ GNUNET_CRYPTO_eddsa_sign (GST_my_private_key,
&disconnect_msg.purpose,
&disconnect_msg.signature));
if (NULL == (n = lookup_neighbour (receiver)))
{
- MEMDEBUG_free (mq, __LINE__);
+ GNUNET_free (mq);
return; /* disconnect or other error while transmitting, can happen */
}
if (n->is_active == mq)
(success == GNUNET_OK) ? "success" : "FAILURE");
if (NULL != mq->cont)
mq->cont (mq->cont_cls, success, size_payload, physical);
- MEMDEBUG_free (mq, __LINE__);
+ GNUNET_free (mq);
}
gettext_noop
("# bytes in message queue for other peers"),
bytes_in_send_queue, GNUNET_NO);
- mq = MEMDEBUG_malloc (sizeof (struct MessageQueue) + msg_size, __LINE__);
+ mq = GNUNET_malloc (sizeof (struct MessageQueue) + msg_size);
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 = MEMDEBUG_malloc (sizeof (struct NeighbourMapEntry), __LINE__);
+ n = GNUNET_malloc (sizeof (struct NeighbourMapEntry));
n->id = *peer;
n->state = S_NOT_CONNECTED;
n->latency = GNUNET_TIME_UNIT_FOREVER_REL;
+ n->last_util_transmission = GNUNET_TIME_absolute_get();
+ n->util_payload_bytes_recv = 0;
+ n->util_payload_bytes_sent = 0;
+ n->util_total_bytes_recv = 0;
+ n->util_total_bytes_sent = 0;
GNUNET_BANDWIDTH_tracker_init (&n->in_tracker,
GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT,
MAX_BANDWIDTH_CARRY_S);
break;
}
cleanup:
- MEMDEBUG_free (bcc->na.address, __LINE__);
- //GNUNET_HELLO_address_free (bcc->na.address);
+ GNUNET_HELLO_address_free (bcc->na.address);
GNUNET_CONTAINER_DLL_remove (bc_head,
bc_tail,
bcc);
- MEMDEBUG_free (bcc, __LINE__);
+ GNUNET_free (bcc);
}
struct BlackListCheckContext *bcc;
struct GST_BlacklistCheck *bc;
- bcc =
- MEMDEBUG_malloc (sizeof (struct BlackListCheckContext), __LINE__);
+ bcc = GNUNET_malloc (sizeof (struct BlackListCheckContext));
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;
GNUNET_CONTAINER_DLL_insert (bc_head,
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;
}
}
}
+static int
+send_utilization_data (void *cls,
+ const struct GNUNET_PeerIdentity *key,
+ void *value)
+{
+ struct NeighbourMapEntry *n = value;
+ struct GNUNET_ATS_Information atsi[4];
+ uint32_t bps_pl_in;
+ uint32_t bps_pl_out;
+ uint32_t bps_in;
+ uint32_t bps_out;
+ struct GNUNET_TIME_Relative delta;
+
+ delta = GNUNET_TIME_absolute_get_difference(n->last_util_transmission, GNUNET_TIME_absolute_get());
+
+ bps_pl_in = 0;
+ if (0 != n->util_payload_bytes_recv)
+ bps_pl_in = (1000LL * 1000LL * n->util_payload_bytes_recv) / (delta.rel_value_us);
+ bps_pl_out = 0;
+ if (0 != n->util_payload_bytes_sent)
+ bps_pl_out = (1000LL * 1000LL * n->util_payload_bytes_sent) / delta.rel_value_us;
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "`%s' payload: received %u Bytes/s, sent %u Bytes/s \n",
+ GNUNET_i2s (key), bps_pl_in, bps_pl_out);
+
+ bps_in = 0;
+ if (0 != n->util_total_bytes_recv)
+ bps_in = (1000LL * 1000LL * n->util_total_bytes_recv) / (delta.rel_value_us);
+ bps_out = 0;
+ if (0 != n->util_total_bytes_sent)
+ bps_out = (1000LL * 1000LL * n->util_total_bytes_sent) / delta.rel_value_us;
+
+
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "`%s' total: received %u Bytes/s, sent %u Bytes/s \n",
+ GNUNET_i2s (key), bps_in, bps_out);
+
+ atsi[0].type = htonl (GNUNET_ATS_UTILIZATION_OUT);
+ atsi[0].value = htonl (bps_out);
+ atsi[1].type = htonl (GNUNET_ATS_UTILIZATION_IN);
+ atsi[1].value = htonl (bps_in);
+
+ atsi[2].type = htonl (GNUNET_ATS_UTILIZATION_PAYLOAD_OUT);
+ atsi[2].value = htonl (bps_pl_out);
+ atsi[3].type = htonl (GNUNET_ATS_UTILIZATION_PAYLOAD_IN);
+ atsi[3].value = htonl (bps_pl_in);
+
+ GST_ats_update_metrics (key, n->primary_address.address,
+ n->primary_address.session, atsi, 4);
+ n->util_payload_bytes_recv = 0;
+ n->util_payload_bytes_sent = 0;
+ n->util_total_bytes_recv = 0;
+ n->util_total_bytes_sent = 0;
+ n->last_util_transmission = GNUNET_TIME_absolute_get();
+ return GNUNET_OK;
+}
+
+/**
+ * Task transmitting utilization in a regular interval
+ *
+ * @param cls the 'struct NeighbourMapEntry' for which we are running
+ * @param tc scheduler context (unused)
+ */
+static void
+utilization_transmission (void *cls,
+ const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+ util_transmission_tk = GNUNET_SCHEDULER_NO_TASK;
+
+ if (0 < GNUNET_CONTAINER_multipeermap_size (neighbours))
+ GNUNET_CONTAINER_multipeermap_iterate (neighbours, send_utilization_data, NULL);
+
+ util_transmission_tk = GNUNET_SCHEDULER_add_delayed (UTIL_TRANSMISSION_INTERVAL,
+ utilization_transmission, NULL);
+
+}
+
+void
+GST_neighbours_notify_data_recv (const struct GNUNET_PeerIdentity *peer,
+ const struct GNUNET_HELLO_Address *address,
+ struct Session *session,
+ const struct GNUNET_MessageHeader *message)
+{
+ struct NeighbourMapEntry *n;
+ n = lookup_neighbour (peer);
+ if (NULL == n)
+ {
+ return;
+ }
+ n->util_total_bytes_recv += ntohs(message->size);
+}
+
+void
+GST_neighbours_notify_payload_recv (const struct GNUNET_PeerIdentity *peer,
+ const struct GNUNET_HELLO_Address *address,
+ struct Session *session,
+ const struct GNUNET_MessageHeader *message)
+{
+ struct NeighbourMapEntry *n;
+ n = lookup_neighbour (peer);
+ if (NULL == n)
+ {
+ return;
+ }
+ n->util_payload_bytes_recv += ntohs(message->size);
+}
+
+
+void
+GST_neighbours_notify_data_sent (const struct GNUNET_PeerIdentity *peer,
+ size_t size)
+{
+ struct NeighbourMapEntry *n;
+ n = lookup_neighbour (peer);
+ if (NULL == n)
+ {
+ return;
+ }
+ n->util_total_bytes_sent += size;
+}
+
+void
+GST_neighbours_notify_payload_sent (const struct GNUNET_PeerIdentity *peer,
+ size_t size)
+{
+ struct NeighbourMapEntry *n;
+ n = lookup_neighbour (peer);
+ if (NULL == n)
+ {
+ return;
+ }
+ n->util_payload_bytes_sent += size;
+}
+
/**
* Master task run for every neighbour. Performs all of the time-related
if (bcc->na.session == session)
{
GST_blacklist_test_cancel (bcc->bc);
- MEMDEBUG_free (bcc->na.address, __LINE__);
- //GNUNET_HELLO_address_free (bcc->na.address);
+ GNUNET_HELLO_address_free (bcc->na.address);
GNUNET_CONTAINER_DLL_remove (bc_head,
bc_tail,
bcc);
- MEMDEBUG_free (bcc, __LINE__);
+ GNUNET_free (bcc);
}
}
if (NULL == (n = lookup_neighbour (peer)))
return;
}
GNUNET_CRYPTO_hash (&sdm->public_key,
- sizeof (struct GNUNET_CRYPTO_EccPublicSignKey),
+ sizeof (struct GNUNET_CRYPTO_EddsaPublicKey),
&hc);
if (0 != memcmp (peer, &hc, sizeof (struct GNUNET_PeerIdentity)))
{
}
if (ntohl (sdm->purpose.size) !=
sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
- sizeof (struct GNUNET_CRYPTO_EccPublicSignKey) +
+ sizeof (struct GNUNET_CRYPTO_EddsaPublicKey) +
sizeof (struct GNUNET_TIME_AbsoluteNBO))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
return;
}
if (GNUNET_OK !=
- GNUNET_CRYPTO_ecc_verify
+ GNUNET_CRYPTO_eddsa_verify
(GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_DISCONNECT, &sdm->purpose,
&sdm->signature, &sdm->public_key))
{
disconnect_notify_cb = disconnect_cb;
address_change_cb = peer_address_cb;
neighbours = GNUNET_CONTAINER_multipeermap_create (NEIGHBOUR_TABLE_SIZE, GNUNET_NO);
+ util_transmission_tk = GNUNET_SCHEDULER_add_delayed (UTIL_TRANSMISSION_INTERVAL,
+ utilization_transmission, NULL);
}
{
if (NULL == neighbours)
return;
+ if (GNUNET_SCHEDULER_NO_TASK != util_transmission_tk)
+ {
+ GNUNET_SCHEDULER_cancel (util_transmission_tk);
+ util_transmission_tk = GNUNET_SCHEDULER_NO_TASK;
+ }
+
GNUNET_CONTAINER_multipeermap_iterate (neighbours,
&disconnect_all_neighbours,
NULL);