code for managing of 'encrypted' sessions (key exchange done) More...

#include "gnunet_common.h"
#include "platform.h"
#include "gnunet-service-core.h"
#include "gnunet-service-core_kx.h"
#include "gnunet-service-core_sessions.h"
#include "gnunet_constants.h"
#include "core.h"

Include dependency graph for gnunet-service-core_sessions.c:

Data Structures
struct	SessionMessageEntry
	Message ready for encryption. More...

struct	Session
	Data kept per session. More...

Macros
#define	MAX_ENCRYPTED_MESSAGE_QUEUE_SIZE 4
	How many encrypted messages do we queue at most? Needed to bound memory consumption.

Functions
static struct Session *	find_session (const struct GNUNET_PeerIdentity *peer)
	Find the session for the given peer.

void	GSC_SESSIONS_end (const struct GNUNET_PeerIdentity *pid)
	End the session with the given peer (we are no longer connected).

void	GSC_SESSIONS_create (const struct GNUNET_PeerIdentity peer, struct GSC_KeyExchangeInfo kx, enum GNUNET_CORE_PeerClass class)
	Create a session, a key exchange was just completed.

void	GSC_SESSIONS_reinit (const struct GNUNET_PeerIdentity *peer)
	The other peer has indicated that it 'lost' the session (KX down), reinitialize the session on our end, in particular this means to restart the typemap transmission.

static int	notify_client_about_session (void cls, const struct GNUNET_PeerIdentity key, void *value)
	Notify the given client about the session (client is new).

void	GSC_SESSIONS_notify_client_about_sessions (struct GSC_Client *client)
	We have a new client, notify it about all current sessions.

static void	try_transmission (struct Session *session)
	Try to perform a transmission on the given session.

void	GSC_SESSIONS_queue_request (struct GSC_ClientActiveRequest *car)
	Queue a request from a client for transmission to a particular peer.

void	GSC_SESSIONS_dequeue_request (struct GSC_ClientActiveRequest *car)
	Dequeue a request from a client from transmission to a particular peer.

static void	solicit_messages (struct Session *session, size_t msize)
	Solicit messages for transmission, starting with those of the highest priority.

static void	pop_cork_task (void *cls)
	Some messages were delayed (corked), but the timeout has now expired.

void	GSC_SESSIONS_solicit (const struct GNUNET_PeerIdentity *pid)
	Traffic is being solicited for the given peer.

void	GSC_SESSIONS_transmit (struct GSC_ClientActiveRequest car, const struct GNUNET_MessageHeader msg, enum GNUNET_MQ_PriorityPreferences priority)
	Transmit a message to a particular peer.

void	GSC_SESSIONS_init ()
	Initialize sessions subsystem.

static int	free_session_helper (void cls, const struct GNUNET_PeerIdentity key, void *value)
	Helper function for GSC_SESSIONS_done() to free all active sessions.

void	GSC_SESSIONS_done ()
	Shutdown sessions subsystem.

Variables
static struct GNUNET_CONTAINER_MultiPeerMap *	sessions
	Map of peer identities to `struct Session`.

Detailed Description

code for managing of 'encrypted' sessions (key exchange done)

Author: Christian Grothoff

Definition in file gnunet-service-core_sessions.c.

Macro Definition Documentation

◆ MAX_ENCRYPTED_MESSAGE_QUEUE_SIZE

#define MAX_ENCRYPTED_MESSAGE_QUEUE_SIZE 4

How many encrypted messages do we queue at most? Needed to bound memory consumption.

Definition at line 39 of file gnunet-service-core_sessions.c.

Function Documentation

◆ find_session()

static struct Session * find_session ( const struct GNUNET_PeerIdentity * peer )

static

Find the session for the given peer.

Parameters

peer	identity of the peer

Returns: NULL if we are not connected, otherwise the session handle

Definition at line 145 of file gnunet-service-core_sessions.c.

{
  if (NULL == sessions)
    return NULL;
  return GNUNET_CONTAINER_multipeermap_get (sessions, peer);
}

References GNUNET_CONTAINER_multipeermap_get(), Session::peer, and sessions.

Referenced by GSC_SESSIONS_dequeue_request(), GSC_SESSIONS_end(), GSC_SESSIONS_queue_request(), GSC_SESSIONS_reinit(), GSC_SESSIONS_solicit(), and GSC_SESSIONS_transmit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GSC_SESSIONS_end()

void GSC_SESSIONS_end ( const struct GNUNET_PeerIdentity * pid )

End the session with the given peer (we are no longer connected).

Parameters

pid	identity of peer to kill session with

Definition at line 160 of file gnunet-service-core_sessions.c.

{
  struct Session *session;
  struct GSC_ClientActiveRequest *car;
  struct SessionMessageEntry *sme;
 
  if (NULL == pid)
  {
    /* We might not know the peer_id yet. */
    return;
  }
  session = find_session (pid);
  if (NULL == session)
    return;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Destroying session for peer `%s'\n",
              GNUNET_i2s (session->peer));
  if (NULL != session->cork_task)
  {
    GNUNET_SCHEDULER_cancel (session->cork_task);
    session->cork_task = NULL;
  }
  while (NULL != (car = session->active_client_request_head))
  {
    GNUNET_CONTAINER_DLL_remove (session->active_client_request_head,
                                 session->active_client_request_tail,
                                 car);
    GSC_CLIENTS_reject_request (car, GNUNET_NO);
  }
  while (NULL != (sme = session->sme_head))
  {
    GNUNET_CONTAINER_DLL_remove (session->sme_head, session->sme_tail, sme);
    GNUNET_free (sme);
  }
  // TODO
  GSC_CLIENTS_notify_clients_about_neighbour (session->peer,
                                              session->class);
  GNUNET_assert (
    GNUNET_YES ==
    GNUNET_CONTAINER_multipeermap_remove (sessions, session->peer, session));
  GNUNET_STATISTICS_set (GSC_stats,
                         gettext_noop ("# peers connected"),
                         GNUNET_CONTAINER_multipeermap_size (sessions),
                         GNUNET_NO);
  // TODO
  // GSC_SVCI_destroy (session->services);
  GNUNET_free (session);
}

References Session::active_client_request_head, Session::active_client_request_tail, Session::class, Session::cork_task, find_session(), gettext_noop, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multipeermap_remove(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_set(), GNUNET_YES, GSC_CLIENTS_notify_clients_about_neighbour(), GSC_CLIENTS_reject_request(), GSC_stats, Session::peer, pid, sessions, Session::sme_head, and Session::sme_tail.

Referenced by free_session_helper(), handle_encrypted_message(), handle_transport_notify_disconnect(), and send_heartbeat().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GSC_SESSIONS_create()

void GSC_SESSIONS_create	(	const struct GNUNET_PeerIdentity *	peer,
		struct GSC_KeyExchangeInfo *	kx,
		enum GNUNET_CORE_PeerClass	class
	)

Create a session, a key exchange was just completed.

Parameters

peer	peer that is now connected
kx	key exchange that completed
class	the class of the now connected peer

Definition at line 218 of file gnunet-service-core_sessions.c.

{
  struct Session *session;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Creating session for peer `%s'\n",
              GNUNET_i2s (peer));
  session = GNUNET_new (struct Session);
  // TODO
  // session->services = GSC_SVCI_init ();
  session->peer = peer;
  session->kx = kx;
  session->class = class;
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multipeermap_put (
                   sessions,
                   session->peer,
                   session,
                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  GNUNET_STATISTICS_set (GSC_stats,
                         gettext_noop ("# peers connected"),
                         GNUNET_CONTAINER_multipeermap_size (sessions),
                         GNUNET_NO);
  // TODO
  GSC_CLIENTS_notify_clients_about_neighbour (peer,
                                              session->class);
}

References Session::class, gettext_noop, GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_put(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_set(), GSC_CLIENTS_notify_clients_about_neighbour(), GSC_stats, Session::kx, Session::peer, and sessions.

Referenced by check_if_ack_or_heartbeat(), and handle_initiator_done().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GSC_SESSIONS_reinit()

void GSC_SESSIONS_reinit ( const struct GNUNET_PeerIdentity * peer )

The other peer has indicated that it 'lost' the session (KX down), reinitialize the session on our end, in particular this means to restart the typemap transmission.

XXX typemap does not exist anymore

Parameters

peer	peer that is now connected

Definition at line 258 of file gnunet-service-core_sessions.c.

{
  struct Session *session;
 
  session = find_session (peer);
  if (NULL == session)
  {
    /* KX/session is new for both sides; thus no need to restart what
       has not yet begun */
    return;
  }
}

References find_session(), and Session::peer.

Here is the call graph for this function:

◆ notify_client_about_session()

static int notify_client_about_session	(	void *	cls,
		const struct GNUNET_PeerIdentity *	key,
		void *	value
	)

static

Notify the given client about the session (client is new).

Parameters

cls	the `struct GSC_Client`
key	peer identity
value	the `struct Session`

Returns: GNUNET_OK (continue to iterate)

Definition at line 281 of file gnunet-service-core_sessions.c.

{
  struct GSC_Client *client = cls;
  struct Session *session = value;
 
  // TODO
  GSC_CLIENTS_notify_client_about_neighbour (client,
                                             session->peer,
                                             session->class);
  return GNUNET_OK;
}

References Session::class, GSC_Client::client, GNUNET_OK, GSC_CLIENTS_notify_client_about_neighbour(), Session::peer, and value.

Referenced by GSC_SESSIONS_notify_client_about_sessions().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GSC_SESSIONS_notify_client_about_sessions()

void GSC_SESSIONS_notify_client_about_sessions ( struct GSC_Client * client )

We have a new client, notify it about all current sessions.

Parameters

client the new client

Definition at line 302 of file gnunet-service-core_sessions.c.

{
  /* notify new client about existing sessions */
  GNUNET_CONTAINER_multipeermap_iterate (sessions,
                                         &notify_client_about_session,
                                         client);
}

References GNUNET_CONTAINER_multipeermap_iterate(), notify_client_about_session(), and sessions.

Referenced by handle_client_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ try_transmission()

static void try_transmission ( struct Session * session )

static

Try to perform a transmission on the given session.

Will solicit additional messages if the 'sme' queue is not full enough.

Parameters

session session to transmit messages from

Will solicit additional messages if the 'sme' queue is not full enough or has only low-priority messages.

Parameters

session session to transmit messages from

Definition at line 462 of file gnunet-service-core_sessions.c.

{
  struct SessionMessageEntry *pos;
  size_t msize;
  struct GNUNET_TIME_Absolute now;
  struct GNUNET_TIME_Absolute min_deadline;
  enum GNUNET_MQ_PriorityPreferences maxp;
  enum GNUNET_MQ_PriorityPreferences maxpc;
  struct GSC_ClientActiveRequest *car;
  int excess;
 
  msize = 0;
  min_deadline = GNUNET_TIME_UNIT_FOREVER_ABS;
  /* if the peer has excess bandwidth, background traffic is allowed,
     otherwise not */
  if (MAX_ENCRYPTED_MESSAGE_QUEUE_SIZE <=
      GSC_NEIGHBOURS_get_queue_length (session->kx))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Transmission queue already very long, waiting...\n");
    return;   /* queue already too long */
  }
  excess = GSC_NEIGHBOURS_check_excess_bandwidth (session->kx);
  if (GNUNET_YES == excess)
    maxp = GNUNET_MQ_PRIO_BACKGROUND;
  else
    maxp = GNUNET_MQ_PRIO_BEST_EFFORT;
  /* determine highest priority of 'ready' messages we already solicited from clients */
  pos = session->sme_head;
  while ((NULL != pos) &&
         (msize + pos->size <= GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE))
  {
    GNUNET_assert (pos->size < GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE);
    msize += pos->size;
    maxp = GNUNET_MAX (maxp, pos->priority & GNUNET_MQ_PRIORITY_MASK);
    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_MQ_PRIO_CRITICAL_CONTROL)
  {
    /* if highest already solicited priority from clients is not critical,
       check if there are higher-priority messages to be solicited from clients */
    if (GNUNET_YES == excess)
      maxpc = GNUNET_MQ_PRIO_BACKGROUND;
    else
      maxpc = GNUNET_MQ_PRIO_BEST_EFFORT;
    for (car = session->active_client_request_head; NULL != car;
         car = car->next)
    {
      if (GNUNET_YES == car->was_solicited)
        continue;
      maxpc = GNUNET_MAX (maxpc, car->priority & GNUNET_MQ_PRIORITY_MASK);
    }
    if (maxpc > maxp)
    {
      /* 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_MQ_PRIO_BACKGROUND;
  }
  now = GNUNET_TIME_absolute_get ();
  if (((GNUNET_YES == excess) || (maxpc >= GNUNET_MQ_PRIO_BEST_EFFORT)) &&
      ((0 == msize) ||
       ((msize < GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE / 2) &&
        (min_deadline.abs_value_us > now.abs_value_us))))
  {
    /* 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,
      (unsigned int) 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 */
      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_at (min_deadline, &pop_cork_task, session);
    }
    else
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Queue empty, waiting for solicitations\n");
    }
    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 */
  {
    static unsigned long long total_bytes;
    static unsigned int total_msgs;
    char pbuf[msize]; /* plaintext */
    size_t used;
 
    used = 0;
    while ((NULL != (pos = session->sme_head)) && (used + pos->size <= msize))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Adding message of type %d to payload for %s\n",
                  ntohs (((const struct GNUNET_MessageHeader *) &pos[1])->type),
                  GNUNET_i2s (session->peer));
      GNUNET_memcpy (&pbuf[used], &pos[1], pos->size);
      used += pos->size;
      GNUNET_CONTAINER_DLL_remove (session->sme_head, session->sme_tail, pos);
      GNUNET_free (pos);
    }
    /* compute average payload size */
    total_bytes += used;
    total_msgs++;
    if (0 == total_msgs)
    {
      /* 2^32 messages, wrap around... */
      total_msgs = 1;
      total_bytes = used;
    }
    GNUNET_STATISTICS_set (GSC_stats,
                           "# avg payload per encrypted message",
                           total_bytes / total_msgs,
                           GNUNET_NO);
    /* now actually transmit... */
    GSC_KX_encrypt_and_transmit (session->kx, pbuf, used);
  }
}

References GNUNET_TIME_Absolute::abs_value_us, Session::active_client_request_head, Session::cork_task, SessionMessageEntry::deadline, GNUNET_assert, GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_MAX, GNUNET_memcpy, GNUNET_MQ_PRIO_BACKGROUND, GNUNET_MQ_PRIO_BEST_EFFORT, GNUNET_MQ_PRIO_CRITICAL_CONTROL, GNUNET_MQ_PRIORITY_MASK, GNUNET_NO, GNUNET_SCHEDULER_add_at(), GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_set(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_absolute_min(), GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_YES, GSC_KX_encrypt_and_transmit(), GSC_NEIGHBOURS_check_excess_bandwidth(), GSC_NEIGHBOURS_get_queue_length(), GSC_stats, Session::kx, MAX_ENCRYPTED_MESSAGE_QUEUE_SIZE, GSC_ClientActiveRequest::msize, GSC_ClientActiveRequest::next, SessionMessageEntry::next, Session::peer, pop_cork_task(), GSC_ClientActiveRequest::priority, SessionMessageEntry::priority, GNUNET_MessageHeader::size, SessionMessageEntry::size, Session::sme_head, Session::sme_tail, solicit_messages(), type, and GSC_ClientActiveRequest::was_solicited.

Referenced by GSC_SESSIONS_dequeue_request(), GSC_SESSIONS_queue_request(), GSC_SESSIONS_solicit(), GSC_SESSIONS_transmit(), and pop_cork_task().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GSC_SESSIONS_queue_request()

void GSC_SESSIONS_queue_request ( struct GSC_ClientActiveRequest * car )

Queue a request from a client for transmission to a particular peer.

Parameters

car	request to queue; this handle is then shared between the caller (CLIENTS subsystem) and SESSIONS and must not be released by either until either #GSC_SESSIONS_dequeue(), GSC_SESSIONS_transmit() or #GSC_CLIENTS_failed() have been invoked on it

Definition at line 331 of file gnunet-service-core_sessions.c.

{
  struct Session *session;
 
  session = find_session (&car->target);
  if (NULL == session)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Dropped client request for transmission (am disconnected)\n");
    GNUNET_break (0);  /* should have been rejected earlier */
    GSC_CLIENTS_reject_request (car, GNUNET_NO);
    return;
  }
  if (car->msize > GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE)
  {
    GNUNET_break (0);
    GSC_CLIENTS_reject_request (car, GNUNET_YES);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received client transmission request. queueing\n");
  GNUNET_CONTAINER_DLL_insert_tail (session->active_client_request_head,
                                    session->active_client_request_tail,
                                    car);
  try_transmission (session);
}

References Session::active_client_request_head, Session::active_client_request_tail, find_session(), GNUNET_break, GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_YES, GSC_CLIENTS_reject_request(), GSC_ClientActiveRequest::msize, GSC_ClientActiveRequest::target, and try_transmission().

Referenced by handle_client_send_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GSC_SESSIONS_dequeue_request()

void GSC_SESSIONS_dequeue_request ( struct GSC_ClientActiveRequest * car )

Dequeue a request from a client from transmission to a particular peer.

Parameters

car	request to dequeue; this handle will then be 'owned' by the caller (CLIENTS sysbsystem)

Definition at line 366 of file gnunet-service-core_sessions.c.

{
  const struct GNUNET_PeerIdentity *my_identity;
  struct Session *session;
  my_identity = GNUNET_PILS_get_identity (GSC_pils);
  if (NULL == my_identity)
    return;
 
  if (0 == memcmp (&car->target,
                   my_identity,
                   sizeof(struct GNUNET_PeerIdentity)))
    return;
  session = find_session (&car->target);
  GNUNET_assert (NULL != session);
  GNUNET_CONTAINER_DLL_remove (session->active_client_request_head,
                               session->active_client_request_tail,
                               car);
  /* dequeueing of 'high' priority messages may unblock
     transmission for lower-priority messages, so we also
     need to try in this case. */
  try_transmission (session);
}

References Session::active_client_request_head, Session::active_client_request_tail, find_session(), GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_PILS_get_identity(), GSC_pils, my_identity, GSC_ClientActiveRequest::target, and try_transmission().

Referenced by destroy_active_client_request(), GSC_CLIENTS_solicit_request(), handle_client_send(), and handle_client_send_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ solicit_messages()

static void solicit_messages	(	struct Session *	session,
		size_t	msize
	)

static

Solicit messages for transmission, starting with those of the highest priority.

Parameters

session	session to solict messages for
msize	how many bytes do we have already

Definition at line 398 of file gnunet-service-core_sessions.c.

{
  struct GSC_ClientActiveRequest *car;
  struct GSC_ClientActiveRequest *nxt;
  size_t so_size;
  enum GNUNET_MQ_PriorityPreferences pmax;
 
  so_size = msize;
  pmax = GNUNET_MQ_PRIO_BACKGROUND;
  for (car = session->active_client_request_head; NULL != car; car = car->next)
  {
    if (GNUNET_YES == car->was_solicited)
      continue;
    pmax = GNUNET_MAX (pmax, car->priority & GNUNET_MQ_PRIORITY_MASK);
  }
  nxt = session->active_client_request_head;
  while (NULL != (car = nxt))
  {
    nxt = car->next;
    if (car->priority < pmax)
      continue;
    if (so_size + car->msize > GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE)
      break;
    so_size += car->msize;
    if (GNUNET_YES == car->was_solicited)
      continue;
    car->was_solicited = GNUNET_YES;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Soliciting message with priority %u\n",
                car->priority);
    GSC_CLIENTS_solicit_request (car);
    /* The above call may *dequeue* requests and thereby
       clobber 'nxt'. Hence we need to restart from the
       head of the list. */
    nxt = session->active_client_request_head;
    so_size = msize;
  }
}

References Session::active_client_request_head, GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MAX, GNUNET_MQ_PRIO_BACKGROUND, GNUNET_MQ_PRIORITY_MASK, GNUNET_YES, GSC_CLIENTS_solicit_request(), GSC_ClientActiveRequest::msize, GSC_ClientActiveRequest::next, GSC_ClientActiveRequest::priority, and GSC_ClientActiveRequest::was_solicited.

Referenced by try_transmission().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pop_cork_task()

static void pop_cork_task ( void * cls )

static

Some messages were delayed (corked), but the timeout has now expired.

Send them now.

Parameters

cls	`struct Session` with the messages to transmit now

Definition at line 445 of file gnunet-service-core_sessions.c.

{
  struct Session *session = cls;
 
  session->cork_task = NULL;
  try_transmission (session);
}

References Session::cork_task, and try_transmission().

Referenced by try_transmission().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GSC_SESSIONS_solicit()

void GSC_SESSIONS_solicit ( const struct GNUNET_PeerIdentity * pid )

Traffic is being solicited for the given peer.

This means that the message queue on the transport-level (NEIGHBOURS subsystem) is now empty and it is now OK to transmit another (non-control) message.

Parameters

pid	identity of peer ready to receive data

Definition at line 633 of file gnunet-service-core_sessions.c.

{
  struct Session *session;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Transport solicits for %s\n",
              GNUNET_i2s (pid));
  session = find_session (pid);
  if (NULL == session)
    return;
  try_transmission (session);
}

References find_session(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, pid, and try_transmission().

Here is the call graph for this function:

◆ GSC_SESSIONS_transmit()

void GSC_SESSIONS_transmit	(	struct GSC_ClientActiveRequest *	car,
		const struct GNUNET_MessageHeader *	msg,
		enum GNUNET_MQ_PriorityPreferences	priority
	)

Transmit a message to a particular peer.

Parameters

car	original request that was queued and then solicited, ownership does not change (dequeue will be called soon).
msg	message to transmit
priority	how important is this message

Definition at line 648 of file gnunet-service-core_sessions.c.

{
  struct Session *session;
  struct SessionMessageEntry *sme;
  struct SessionMessageEntry *pos;
  size_t msize;
 
  session = find_session (&car->target);
  if (NULL == session)
  {
    GSC_CLIENTS_reject_request (car, GNUNET_YES);
    return;
  }
  msize = ntohs (msg->size);
  sme = GNUNET_malloc (sizeof(struct SessionMessageEntry) + msize);
  GNUNET_memcpy (&sme[1], msg, msize);
  sme->size = msize;
  sme->priority = priority;
  if (0 != (GNUNET_MQ_PREF_CORK_ALLOWED & priority))
  {
    sme->deadline =
      GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_MAX_CORK_DELAY);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Message corked, delaying transmission\n");
  }
  pos = session->sme_head;
  while ((NULL != pos) && (pos->priority >= sme->priority))
    pos = pos->next;
  if (NULL == pos)
    GNUNET_CONTAINER_DLL_insert_tail (session->sme_head,
                                      session->sme_tail,
                                      sme);
  else
    GNUNET_CONTAINER_DLL_insert_after (session->sme_head,
                                       session->sme_tail,
                                       pos->prev,
                                       sme);
  try_transmission (session);
}

References SessionMessageEntry::deadline, find_session(), GNUNET_CONSTANTS_MAX_CORK_DELAY, GNUNET_CONTAINER_DLL_insert_after, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_MQ_PREF_CORK_ALLOWED, GNUNET_TIME_relative_to_absolute(), GNUNET_YES, GSC_CLIENTS_reject_request(), msg, SessionMessageEntry::next, SessionMessageEntry::prev, SessionMessageEntry::priority, GNUNET_MessageHeader::size, SessionMessageEntry::size, Session::sme_head, Session::sme_tail, GSC_ClientActiveRequest::target, and try_transmission().

Referenced by tokenized_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GSC_SESSIONS_init()

void GSC_SESSIONS_init ( void )

Initialize sessions subsystem.

Definition at line 695 of file gnunet-service-core_sessions.c.

{
  sessions = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_YES);
}

References GNUNET_CONTAINER_multipeermap_create(), GNUNET_YES, and sessions.

Referenced by GSC_complete_initialization_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ free_session_helper()

static int free_session_helper	(	void *	cls,
		const struct GNUNET_PeerIdentity *	key,
		void *	value
	)

static

Helper function for GSC_SESSIONS_done() to free all active sessions.

Parameters

cls	NULL
key	identity of the connected peer
value	the `struct Session` for the peer

Returns: GNUNET_OK (continue to iterate)

Definition at line 711 of file gnunet-service-core_sessions.c.

{
  /* struct Session *session = value; */
 
  GSC_SESSIONS_end (key);
  return GNUNET_OK;
}

References GNUNET_OK, GSC_SESSIONS_end(), and key.

Referenced by GSC_SESSIONS_done().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GSC_SESSIONS_done()

void GSC_SESSIONS_done ( void )

Shutdown sessions subsystem.

Definition at line 726 of file gnunet-service-core_sessions.c.

{
  if (NULL != sessions)
  {
    GNUNET_CONTAINER_multipeermap_iterate (sessions,
                                           &free_session_helper,
                                           NULL);
    GNUNET_CONTAINER_multipeermap_destroy (sessions);
    sessions = NULL;
  }
}

References free_session_helper(), GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multipeermap_iterate(), and sessions.

Referenced by shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

◆ sessions

struct GNUNET_CONTAINER_MultiPeerMap* sessions

static

Map of peer identities to struct Session.

Definition at line 134 of file gnunet-service-core_sessions.c.

Referenced by find_session(), GSC_SESSIONS_create(), GSC_SESSIONS_done(), GSC_SESSIONS_end(), GSC_SESSIONS_init(), and GSC_SESSIONS_notify_client_about_sessions().

Data Structures

Macros

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ MAX_ENCRYPTED_MESSAGE_QUEUE_SIZE

Function Documentation

◆ find_session()

◆ GSC_SESSIONS_end()

◆ GSC_SESSIONS_create()

◆ GSC_SESSIONS_reinit()

◆ notify_client_about_session()

◆ GSC_SESSIONS_notify_client_about_sessions()

◆ try_transmission()

◆ GSC_SESSIONS_queue_request()

◆ GSC_SESSIONS_dequeue_request()

◆ solicit_messages()

◆ pop_cork_task()

◆ GSC_SESSIONS_solicit()

◆ GSC_SESSIONS_transmit()

◆ GSC_SESSIONS_init()

◆ free_session_helper()

◆ GSC_SESSIONS_done()

Variable Documentation

◆ sessions