/*
This file is part of GNUnet.
- (C) 2009-2014 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2009-2014 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
#include "core.h"
-/**
- * How often do we transmit our typemap?
- */
-#define TYPEMAP_FREQUENCY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
-
-/**
- * How often do we transmit our typemap on first attempt?
- */
-#define TYPEMAP_FREQUENCY_FIRST GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
-
-
/**
* Message ready for encryption. This struct is followed by the
* actual content of the message.
struct GNUNET_TIME_Absolute deadline;
/**
- * How long is the message? (number of bytes following the "struct
- * MessageEntry", but not including the size of "struct
- * MessageEntry" itself!)
+ * How long is the message? (number of bytes following the `struct
+ * MessageEntry`, but not including the size of `struct
+ * MessageEntry` itself!)
*/
size_t size;
/**
* Task to transmit corked messages with a delay.
*/
- GNUNET_SCHEDULER_TaskIdentifier cork_task;
+ struct GNUNET_SCHEDULER_Task * cork_task;
/**
* Task to transmit our type map.
*/
- GNUNET_SCHEDULER_TaskIdentifier typemap_task;
+ struct GNUNET_SCHEDULER_Task * typemap_task;
/**
* Retransmission delay we currently use for the typemap
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Destroying session for peer `%4s'\n",
GNUNET_i2s (&session->peer));
- if (GNUNET_SCHEDULER_NO_TASK != session->cork_task)
+ if (NULL != session->cork_task)
{
GNUNET_SCHEDULER_cancel (session->cork_task);
- session->cork_task = GNUNET_SCHEDULER_NO_TASK;
+ session->cork_task = NULL;
}
while (NULL != (car = session->active_client_request_head))
{
sme);
GNUNET_free (sme);
}
- if (GNUNET_SCHEDULER_NO_TASK != session->typemap_task)
+ if (NULL != session->typemap_task)
{
GNUNET_SCHEDULER_cancel (session->typemap_task);
- session->typemap_task = GNUNET_SCHEDULER_NO_TASK;
+ session->typemap_task = NULL;
}
GSC_CLIENTS_notify_clients_about_neighbour (&session->peer,
session->tmap, NULL);
static void
start_typemap_task (struct Session *session)
{
- if (GNUNET_SCHEDULER_NO_TASK != session->typemap_task)
+ if (NULL != session->typemap_task)
GNUNET_SCHEDULER_cancel (session->typemap_task);
session->typemap_delay = GNUNET_TIME_UNIT_SECONDS;
session->typemap_task =
GNUNET_CONTAINER_multipeermap_size (sessions),
GNUNET_NO);
GSC_CLIENTS_notify_clients_about_neighbour (peer,
- NULL, session->tmap);
+ NULL,
+ session->tmap);
start_typemap_task (session);
}
1, GNUNET_NO);
return;
}
- if (GNUNET_SCHEDULER_NO_TASK != session->typemap_task)
+ if (NULL != session->typemap_task)
{
GNUNET_SCHEDULER_cancel (session->typemap_task);
- session->typemap_task = GNUNET_SCHEDULER_NO_TASK;
+ session->typemap_task = NULL;
}
GNUNET_STATISTICS_update (GSC_stats,
gettext_noop
struct GSC_Client *client = cls;
struct Session *session = value;
- GSC_CLIENTS_notify_client_about_neighbour (client, &session->peer,
+ GSC_CLIENTS_notify_client_about_neighbour (client,
+ &session->peer,
NULL, /* old TMAP: none */
session->tmap);
return GNUNET_OK;
void
GSC_SESSIONS_dequeue_request (struct GSC_ClientActiveRequest *car)
{
- struct Session *s;
+ struct Session *session;
if (0 ==
memcmp (&car->target, &GSC_my_identity,
sizeof (struct GNUNET_PeerIdentity)))
return;
- s = find_session (&car->target);
- GNUNET_assert (NULL != s);
- GNUNET_CONTAINER_DLL_remove (s->active_client_request_head,
- s->active_client_request_tail, car);
+ session = find_session (&car->target);
+ GNUNET_assert (NULL != session);
+ GNUNET_CONTAINER_DLL_remove (session->active_client_request_head,
+ session->active_client_request_tail,
+ car);
}
{
pos = nxt;
nxt = pos->next;
- if ((pos->deadline.abs_value_us < now.abs_value_us) &&
- (GNUNET_YES != pos->was_solicited))
+ if ( (pos->deadline.abs_value_us < now.abs_value_us) &&
+ (GNUNET_YES != pos->was_solicited) )
{
GNUNET_STATISTICS_update (GSC_stats,
gettext_noop
("# messages discarded (expired prior to transmission)"),
1, GNUNET_NO);
GNUNET_CONTAINER_DLL_remove (session->active_client_request_head,
- session->active_client_request_tail, pos);
+ session->active_client_request_tail,
+ pos);
GSC_CLIENTS_reject_request (pos);
}
}
{
struct Session *session = cls;
- session->cork_task = GNUNET_SCHEDULER_NO_TASK;
+ session->cork_task = NULL;
try_transmission (session);
}
GNUNET_assert (pos->size < GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE);
msize += pos->size;
maxp = GNUNET_MAX (maxp, pos->priority);
- min_deadline = GNUNET_TIME_absolute_min (min_deadline, pos->deadline);
+ min_deadline = GNUNET_TIME_absolute_min (min_deadline,
+ pos->deadline);
pos = pos->next;
}
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Calculating transmission set with %u priority (%s) and %s earliest deadline\n",
+ maxp,
+ (GNUNET_YES == excess) ? "excess bandwidth" : "limited bandwidth",
+ GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_remaining (min_deadline),
+ GNUNET_YES));
+
if (maxp < GNUNET_CORE_PRIO_CRITICAL_CONTROL)
{
/* if highest already solicited priority from clients is not critical,
/* we have messages waiting for solicitation that have a higher
priority than those that we already accepted; solicit the
high-priority messages first */
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Soliciting messages based on priority (%u > %u)\n",
+ maxpc,
+ maxp);
solicit_messages (session, 0);
return;
}
}
-
+ else
+ {
+ /* never solicit more, we have critical messages to process */
+ excess = GNUNET_NO;
+ maxpc = GNUNET_CORE_PRIO_BACKGROUND;
+ }
now = GNUNET_TIME_absolute_get ();
if ( ( (GNUNET_YES == excess) ||
(maxpc >= GNUNET_CORE_PRIO_BEST_EFFORT) ) &&
/* not enough ready yet (tiny message & cork possible), or no messages at all,
and either excess bandwidth or best-effort or higher message waiting at
client; in this case, we try to solicit more */
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Soliciting messages (excess %d, maxpc %d, message size %u, deadline %s)\n",
+ excess,
+ maxpc,
+ msize,
+ GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_remaining (min_deadline),
+ GNUNET_YES));
solicit_messages (session,
msize);
if (msize > 0)
{
/* if there is data to send, just not yet, make sure we do transmit
* it once the deadline is reached */
- if (GNUNET_SCHEDULER_NO_TASK != session->cork_task)
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Corking until %s\n",
+ GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_remaining (min_deadline),
+ GNUNET_YES));
+ if (NULL != session->cork_task)
GNUNET_SCHEDULER_cancel (session->cork_task);
session->cork_task =
- GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_absolute_get_remaining
- (min_deadline), &pop_cork_task,
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_absolute_get_remaining (min_deadline),
+ &pop_cork_task,
session);
}
return;
}
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Building combined plaintext buffer to transmit message!\n");
/* create plaintext buffer of all messages (that fit), encrypt and
transmit */
{
GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_MAX_CORK_DELAY);
pos = session->sme_head;
while ( (NULL != pos) &&
- (pos->priority > sme->priority) )
+ (pos->priority >= sme->priority) )
pos = pos->next;
if (NULL == pos)
GNUNET_CONTAINER_DLL_insert_tail (session->sme_head,