gnunet-service-cadet_peer.c File Reference

Information we track per peer. More...

#include "platform.h"
#include "gnunet_time_lib.h"
#include "gnunet_util_lib.h"
#include "gnunet_hello_uri_lib.h"
#include "gnunet_signatures.h"
#include "gnunet_transport_application_service.h"
#include "gnunet_core_service.h"
#include "gnunet_statistics_service.h"
#include "gnunet-service-cadet_peer.h"
#include "gnunet-service-cadet.h"
#include "gnunet-service-cadet_connection.h"
#include "gnunet-service-cadet_dht.h"
#include "gnunet-service-cadet_paths.h"
#include "gnunet-service-cadet_tunnels.h"

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

Go to the source code of this file.

Data Structures
struct	GCP_MessageQueueManager
	Data structure used to track whom we have to notify about changes to our message queue. More...
struct	CadetPeer
	Struct containing all information regarding a given peer. More...

Macros
#define	LOG(level, ...)   GNUNET_log_from (level, "cadet-per", __VA_ARGS__)
#define	IDLE_PEER_TIMEOUT
	How long do we wait until tearing down an idle peer?
#define	IDLE_PATH_TIMEOUT
	How long do we keep paths around if we no longer care about the peer?
#define	MAX_OOO_QUEUE_SIZE   100
	Queue size when we start dropping OOO messages.

Functions
const char *	GCP_2s (const struct CadetPeer *cp)
	Get the static string for a peer ID.
double	GCP_get_desirability_of_path (struct CadetPeer *cp, unsigned int off)
	Calculate how desirable a path is for cp if cp is at offset off in the path.
static void	destroy_peer (void *cls)
	This peer is no longer be needed, clean it up now.
static void	consider_peer_activate (struct CadetPeer *cp)
	This peer is now on more "active" duty, activate processes related to it.
static void	consider_peer_destroy (struct CadetPeer *cp)
	This peer may no longer be needed, consider cleaning it up.
static void	drop_paths (void *cls)
	We really no longere care about a peer, stop hogging memory with paths to it.
void	GCP_set_mq (struct CadetPeer *cp, struct GNUNET_MQ_Handle *mq)
	Set the message queue to mq for peer cp and notify watchers.
static int	should_I_drop (void)
	Debug function should NEVER return true in production code, useful to simulate losses for testcases.
static void	mqm_send_done (void *cls)
	Function called when CORE took one of the messages from a message queue manager and transmitted it.
static void	mqm_execute (struct GCP_MessageQueueManager *mqm)
	Transmit current envelope from this mqm.
static void	send_next_ready (struct CadetPeer *cp)
	Find the next ready message in the queue (starting the search from the cp->mqm_ready_ptr) and if possible execute the transmission.
void	GCP_send (struct GCP_MessageQueueManager *mqm, struct GNUNET_MQ_Envelope *env)
	Send the message in env to cp.
static int	destroy_iterator_cb (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
	Function called to destroy a peer now.
void	GCP_destroy_all_peers ()
	Clean up all entries about all peers.
void	GCP_drop_owned_paths (struct CadetPeer *cp)
	Drop all paths owned by this peer, and do not allow new ones to be added: We are shutting down.
void	GCP_path_entry_add (struct CadetPeer *cp, struct CadetPeerPathEntry *entry, unsigned int off)
	Add an entry to the DLL of all of the paths that this peer is on.
void	GCP_path_entry_remove (struct CadetPeer *cp, struct CadetPeerPathEntry *entry, unsigned int off)
	Remove an entry from the DLL of all of the paths that this peer is on.
static void	path_heap_cleanup (void *cls)
	Prune down the number of paths to this peer, we seem to have way too many.
struct GNUNET_CONTAINER_HeapNode *	GCP_attach_path (struct CadetPeer *cp, struct CadetPeerPath *path, unsigned int off, int force)
	Try adding a path to this cp.
void	GCP_detach_path (struct CadetPeer *cp, struct CadetPeerPath *path, struct GNUNET_CONTAINER_HeapNode *hn)
	This peer can no longer own path as the path has been extended and a peer further down the line is now the new owner.
void	GCP_add_connection (struct CadetPeer *cp, struct CadetConnection *cc)
	Add a connection to this cp.
void	GCP_remove_connection (struct CadetPeer *cp, struct CadetConnection *cc)
	Remove a connection that went via this cp.
struct CadetPeer *	GCP_get (const struct GNUNET_PeerIdentity *peer_id, int create)
	Retrieve the CadetPeer structure associated with the peer.
const struct GNUNET_PeerIdentity *	GCP_get_id (struct CadetPeer *cp)
	Obtain the peer identity for a struct CadetPeer.
void	GCP_iterate_all (GNUNET_CONTAINER_PeerMapIterator iter, void *cls)
	Iterate over all known peers.
unsigned int	GCP_count_paths (const struct CadetPeer *cp)
	Count the number of known paths toward the peer.
unsigned int	GCP_iterate_paths (struct CadetPeer *cp, GCP_PathIterator callback, void *callback_cls)
	Iterate over the paths to a peer.
unsigned int	GCP_iterate_indirect_paths (struct CadetPeer *cp, GCP_PathIterator callback, void *callback_cls)
	Iterate over the paths to a peer without direct link.
unsigned int	GCP_iterate_paths_at (struct CadetPeer *cp, unsigned int dist, GCP_PathIterator callback, void *callback_cls)
	Iterate over the paths to peer where peer is at distance dist from us.
struct CadetTunnel *	GCP_get_tunnel (struct CadetPeer *cp, int create)
	Get the tunnel towards a peer.
void	GCP_set_hello (struct CadetPeer *cp, const struct GNUNET_MessageHeader *hello)
	We got a HELLO for a cp, remember it, and possibly trigger adequate actions (like trying to connect).
void	GCP_drop_tunnel (struct CadetPeer *cp, struct CadetTunnel *t)
	The tunnel to the given peer no longer exists, remove it from our data structures, and possibly clean up the peer itself.
int	GCP_has_core_connection (struct CadetPeer *cp)
	Test if cp has a core-level connection.
struct GCP_MessageQueueManager *	GCP_request_mq (struct CadetPeer *cp, GCP_MessageQueueNotificationCallback cb, void *cb_cls)
	Start message queue change notifications.
void	GCP_request_mq_cancel (struct GCP_MessageQueueManager *mqm, struct GNUNET_MQ_Envelope *last_env)
	Stops message queue change notifications.
void	GCP_send_ooo (struct CadetPeer *cp, struct GNUNET_MQ_Envelope *env)
	Send the message in env to cp, overriding queueing logic.
int	GCP_check_and_update_monotime (struct CadetPeer *peer, struct GNUNET_TIME_AbsoluteNBO monotime)
	Checking if a monotime value is newer than the last monotime value received from a peer.
int	GCP_check_monotime_sig (struct CadetPeer *peer, const struct GNUNET_CADET_ConnectionCreateMessage *msg)
	Checking the signature for a monotime of a GNUNET_CADET_ConnectionCreateMessage.

Detailed Description

Information we track per peer.

Author

Bartlomiej Polot

Christian Grothoff

TODO:

• optimize stopping/restarting DHT search to situations where we actually need it (i.e. not if we have a direct connection, or if we already have plenty of good short ones, or maybe even to take a break if we have some connections and have searched a lot (?))

Definition in file gnunet-service-cadet_peer.c.

Macro Definition Documentation

LOG

#define LOG	(		level,
			...
	)		GNUNET_log_from (level, "cadet-per", __VA_ARGS__)

Definition at line 49 of file gnunet-service-cadet_peer.c.

IDLE_PEER_TIMEOUT

#define IDLE_PEER_TIMEOUT

Value:

          GNUNET_TIME_relative_multiply ( \
          GNUNET_TIME_UNIT_MINUTES, 5)

How long do we wait until tearing down an idle peer?

Definition at line 55 of file gnunet-service-cadet_peer.c.

{
  struct GCP_MessageQueueManager *next;
 
  struct GCP_MessageQueueManager *prev;
 
  GCP_MessageQueueNotificationCallback cb;
 
  void *cb_cls;
 
  struct CadetPeer *cp;
 
  struct GNUNET_MQ_Envelope *env;
};
 
 
struct CadetPeer
{
  struct GNUNET_PeerIdentity pid;
 
  struct GNUNET_TIME_Absolute last_connection_create;
 
  struct CadetPeerPathEntry **path_heads;
 
  struct CadetPeerPathEntry **path_tails;
 
  struct GCP_MessageQueueManager *mqm_head;
 
  struct GCP_MessageQueueManager *mqm_tail;
 
  struct GCP_MessageQueueManager *mqm_ready_ptr;
 
  struct GNUNET_CONTAINER_Heap *path_heap;
 
  struct GCD_search_handle *search_h;
 
  struct GNUNET_SCHEDULER_Task *heap_cleanup_task;
 
  struct GNUNET_SCHEDULER_Task *destroy_task;
 
  struct CadetTunnel *t;
 
  struct GNUNET_CONTAINER_MultiShortmap *connections;
 
  struct GNUNET_MQ_Handle *core_mq;
 
  struct GNUNET_MessageHeader *hello;
 
  struct GNUNET_TRANSPORT_OfferHelloHandle *hello_offer;
 
  struct GNUNET_TRANSPORT_ApplicationSuggestHandle *ash;
 
  unsigned int queue_n;
 
  unsigned int num_paths;
 
  unsigned int off_sum;
 
  unsigned int mqm_ready_counter;
 
  unsigned int path_dll_length;
};
 
 
const char *
GCP_2s (const struct CadetPeer *cp)
{
  static char buf[5];
  char *ret;
 
  if ((NULL == cp) ||
      (GNUNET_YES == GNUNET_is_zero (&cp->pid.public_key)))
    return "NULL";
 
  ret = GNUNET_CRYPTO_eddsa_public_key_to_string (&cp->pid.public_key);
  if (NULL == ret)
    return "NULL";
 
  GNUNET_strlcpy (buf,
                  ret,
                  sizeof(buf));
  GNUNET_free (ret);
  return buf;
}
 
 
double
GCP_get_desirability_of_path (struct CadetPeer *cp,
                              unsigned int off)
{
  unsigned int num_alts = cp->num_paths;
  unsigned int off_sum;
  double avg_sum;
  double path_delta;
  double weight_alts;
 
  GNUNET_assert (num_alts >= 1);  /* 'path' should be in there! */
  GNUNET_assert (0 != cp->path_dll_length);
 
  /* We maintain 'off_sum' in 'peer' and thereby
     avoid the SLOW recalculation each time. Kept here
     just to document what is going on. */
#if SLOW
  off_sum = 0;
  for (unsigned int j = 0; j < cp->path_dll_length; j++)
    for (struct CadetPeerPathEntry *pe = cp->path_heads[j];
         NULL != pe;
         pe = pe->next)
      off_sum += j;
  GNUNET_assert (off_sum == cp->off_sum);
#else
  off_sum = cp->off_sum;
#endif
  avg_sum = off_sum * 1.0 / cp->path_dll_length;
  path_delta = off - avg_sum;
  /* path_delta positive: path off of peer above average (bad path for peer),
     path_delta negative: path off of peer below average (good path for peer) */
  if (path_delta <= -1.0)
    weight_alts = -num_alts / path_delta;  /* discount alternative paths */
  else if (path_delta >= 1.0)
    weight_alts = num_alts * path_delta; /* overcount alternative paths */
  else
    weight_alts = num_alts; /* count alternative paths normally */
 
 
  /* off+1: long paths are generally harder to find and thus count
     a bit more as they get longer.  However, above-average paths
     still need to count less, hence the squaring of that factor. */
  return (off + 1.0) / (weight_alts * weight_alts);
}
 
 
static void
destroy_peer (void *cls)
{
  struct CadetPeer *cp = cls;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Destroying state about peer %s\n",
       GCP_2s (cp));
  cp->destroy_task = NULL;
  GNUNET_assert (NULL == cp->t);
  GNUNET_assert (NULL == cp->core_mq);
  GNUNET_assert (0 == cp->num_paths);
  for (unsigned int i = 0; i < cp->path_dll_length; i++)
    GNUNET_assert (NULL == cp->path_heads[i]);
  GNUNET_assert (0 == GNUNET_CONTAINER_multishortmap_size (cp->connections));
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multipeermap_remove (peers,
                                                       &cp->pid,
                                                       cp));
  GNUNET_free (cp->path_heads);
  GNUNET_free (cp->path_tails);
  cp->path_dll_length = 0;
  if (NULL != cp->search_h)
  {
    GCD_search_stop (cp->search_h);
    cp->search_h = NULL;
  }
  /* FIXME: clean up search_delayedXXX! */
 
 
  if (NULL != cp->ash)
  {
    GNUNET_TRANSPORT_application_suggest_cancel (cp->ash);
    cp->ash = NULL;
  }
  GNUNET_CONTAINER_multishortmap_destroy (cp->connections);
  if (NULL != cp->path_heap)
  {
    GNUNET_CONTAINER_heap_destroy (cp->path_heap);
    cp->path_heap = NULL;
  }
  if (NULL != cp->heap_cleanup_task)
  {
    GNUNET_SCHEDULER_cancel (cp->heap_cleanup_task);
    cp->heap_cleanup_task = NULL;
  }
  GNUNET_free (cp->hello);
  /* Peer should not be freed if paths exist; if there are no paths,
     there ought to be no connections, and without connections, no
     notifications. Thus we can assert that mqm_head is empty at this
     point. */
  GNUNET_assert (NULL == cp->mqm_head);
  GNUNET_assert (NULL == cp->mqm_ready_ptr);
  GNUNET_free (cp);
}
 
 
static void
consider_peer_activate (struct CadetPeer *cp)
{
  struct GNUNET_BANDWIDTH_Value32NBO bw;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Updating peer %s activation state (%u connections)%s%s\n",
       GCP_2s (cp),
       GNUNET_CONTAINER_multishortmap_size (cp->connections),
       (NULL == cp->t) ? "" : " with tunnel",
       (NULL == cp->core_mq) ? "" : " with CORE link");
  if (NULL != cp->destroy_task)
  {
    /* It's active, do not destroy! */
    GNUNET_SCHEDULER_cancel (cp->destroy_task);
    cp->destroy_task = NULL;
  }
  if ((0 == GNUNET_CONTAINER_multishortmap_size (cp->connections)) &&
      (NULL == cp->t))
  {
    /* We're just on a path or directly connected; don't bother too much */
    if (NULL != cp->ash)
    {
      GNUNET_TRANSPORT_application_suggest_cancel (cp->ash);
      cp->ash = NULL;
    }
    if (NULL != cp->search_h)
    {
      GCD_search_stop (cp->search_h);
      cp->search_h = NULL;
    }
    return;
  }
  if (NULL == cp->core_mq)
  {
    /* Lacks direct connection, try to create one by querying the DHT */
    if ((NULL == cp->search_h) &&
        (DESIRED_CONNECTIONS_PER_TUNNEL > cp->num_paths))
      cp->search_h
        = GCD_search (&cp->pid);
  }
  else
  {
    /* Have direct connection, stop DHT search if active */
    if (NULL != cp->search_h)
    {
      GCD_search_stop (cp->search_h);
      cp->search_h = NULL;
    }
  }
 
  if (NULL != cp->ash)
    GNUNET_TRANSPORT_application_suggest_cancel (cp->ash);
  bw.value__ = 0;
  cp->ash
    = GNUNET_TRANSPORT_application_suggest (transport,
                                            &cp->pid,
                                            GNUNET_MQ_PRIO_BEST_EFFORT,
                                            bw);
}
 
 
static void
consider_peer_destroy (struct CadetPeer *cp);
 
 
static void
drop_paths (void *cls)
{
  struct CadetPeer *cp = cls;
  struct CadetPeerPath *path;
 
  cp->destroy_task = NULL;
  while (NULL != (path = GNUNET_CONTAINER_heap_remove_root (cp->path_heap)))
    GCPP_release (path);
  consider_peer_destroy (cp);
}
 
 
static void
consider_peer_destroy (struct CadetPeer *cp)
{
  struct GNUNET_TIME_Relative exp;
 
  if (NULL != cp->destroy_task)
  {
    GNUNET_SCHEDULER_cancel (cp->destroy_task);
    cp->destroy_task = NULL;
  }
  if (NULL != cp->t)
    return; /* still relevant! */
  if (NULL != cp->core_mq)
    return; /* still relevant! */
  if (0 != GNUNET_CONTAINER_multishortmap_size (cp->connections))
    return; /* still relevant! */
  if ((NULL != cp->path_heap) &&
      (0 < GNUNET_CONTAINER_heap_get_size (cp->path_heap)))
  {
    cp->destroy_task = GNUNET_SCHEDULER_add_delayed (IDLE_PATH_TIMEOUT,
                                                     &drop_paths,
                                                     cp);
    return;
  }
  if (0 != cp->num_paths)
    return; /* still relevant! */
  if (NULL != cp->hello)
  {
    /* relevant only until HELLO expires */
    exp = GNUNET_TIME_absolute_get_remaining (
      GNUNET_HELLO_get_expiration_time_from_msg (cp->hello));
    cp->destroy_task = GNUNET_SCHEDULER_add_delayed (exp,
                                                     &destroy_peer,
                                                     cp);
    return;
  }
  cp->destroy_task = GNUNET_SCHEDULER_add_delayed (IDLE_PEER_TIMEOUT,
                                                   &destroy_peer,
                                                   cp);
}
 
 
void
GCP_set_mq (struct CadetPeer *cp,
            struct GNUNET_MQ_Handle *mq)
{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Message queue for peer %s is now %p\n",
       GCP_2s (cp),
       mq);
  cp->core_mq = mq;
  for (struct GCP_MessageQueueManager *mqm = cp->mqm_head, *next;
       NULL != mqm;
       mqm = next)
  {
    /* Save next pointer in case mqm gets freed by the callback */
    next = mqm->next;
    if (NULL == mq)
    {
      if (NULL != mqm->env)
      {
        GNUNET_MQ_discard (mqm->env);
        mqm->env = NULL;
        mqm->cb (mqm->cb_cls,
                 GNUNET_SYSERR);
      }
      else
      {
        mqm->cb (mqm->cb_cls,
                 GNUNET_NO);
      }
    }
    else
    {
      GNUNET_assert (NULL == mqm->env);
      mqm->cb (mqm->cb_cls,
               GNUNET_YES);
    }
  }
  if ((NULL != mq) ||
      (NULL != cp->t))
    consider_peer_activate (cp);
  else
    consider_peer_destroy (cp);
 
  if ((NULL != mq) &&
      (NULL != cp->t))
  {
    /* have a new, direct path to the target, notify tunnel */
    struct CadetPeerPath *path;
 
    path = GCPP_get_path_from_route (1,
                                     &cp->pid);
    GCT_consider_path (cp->t,
                       path,
                       0);
  }
}
 
 
static int
should_I_drop (void)
{
  if (0 == drop_percent)
    return GNUNET_NO;
  if (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
                                101) < drop_percent)
    return GNUNET_YES;
  return GNUNET_NO;
}
 
 
static void
mqm_send_done (void *cls);
 
 
static void
mqm_execute (struct GCP_MessageQueueManager *mqm)
{
  struct CadetPeer *cp = mqm->cp;
 
  /* Move ready pointer to the next entry that might be ready. */
  if ((mqm == cp->mqm_ready_ptr) &&
      (NULL != mqm->next))
    cp->mqm_ready_ptr = mqm->next;
  /* Move entry to the end of the DLL, to be fair. */
  if (mqm != cp->mqm_tail)
  {
    GNUNET_CONTAINER_DLL_remove (cp->mqm_head,
                                 cp->mqm_tail,
                                 mqm);
    GNUNET_CONTAINER_DLL_insert_tail (cp->mqm_head,
                                      cp->mqm_tail,
                                      mqm);
  }
  cp->mqm_ready_counter--;
  if (GNUNET_YES == should_I_drop ())
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "DROPPING message to peer %s from MQM %p\n",
         GCP_2s (cp),
         mqm);
    GNUNET_MQ_discard (mqm->env);
    mqm->env = NULL;
    mqm_send_done (cp);
  }
  else
  {
    {
      const struct GNUNET_MessageHeader *mh;
 
      mh = GNUNET_MQ_env_get_msg (mqm->env);
      switch (ntohs (mh->type))
      {
      case GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX:
        {
          const struct GNUNET_CADET_TunnelKeyExchangeMessage *msg
            = (const struct GNUNET_CADET_TunnelKeyExchangeMessage *) mh;
          LOG (GNUNET_ERROR_TYPE_DEBUG,
               "P2P forwarding KX with ephemeral %s to %s on CID %s\n",
               GNUNET_e2s (&msg->ephemeral_key),
               GCP_2s (cp),
               GNUNET_sh2s (&msg->cid.connection_of_tunnel));
        }
        break;
 
      default:
        break;
      }
    }
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Sending to peer %s from MQM %p\n",
         GCP_2s (cp),
         mqm);
    GNUNET_MQ_send (cp->core_mq,
                    mqm->env);
    mqm->env = NULL;
  }
  mqm->cb (mqm->cb_cls,
           GNUNET_YES);
}
 
 
static void
send_next_ready (struct CadetPeer *cp)
{
  struct GCP_MessageQueueManager *mqm;
 
  if (0 == cp->mqm_ready_counter)
    return;
  while ((NULL != (mqm = cp->mqm_ready_ptr)) &&
         (NULL == mqm->env))
    cp->mqm_ready_ptr = mqm->next;
  if (NULL == mqm)
    return; /* nothing to do */
  mqm_execute (mqm);
}
 
 
static void
mqm_send_done (void *cls)
{
  struct CadetPeer *cp = cls;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Sending to peer %s completed\n",
       GCP_2s (cp));
  send_next_ready (cp);
}
 
 
void
GCP_send (struct GCP_MessageQueueManager *mqm,
          struct GNUNET_MQ_Envelope *env)
{
  struct CadetPeer *cp = mqm->cp;
 
  GNUNET_assert (NULL != env);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Queueing message to peer %s in MQM %p\n",
       GCP_2s (cp),
       mqm);
  GNUNET_assert (NULL != cp->core_mq);
  GNUNET_assert (NULL == mqm->env);
  GNUNET_MQ_notify_sent (env,
                         &mqm_send_done,
                         cp);
  mqm->env = env;
  cp->mqm_ready_counter++;
  if (mqm != cp->mqm_ready_ptr)
    cp->mqm_ready_ptr = cp->mqm_head;
  if (1 == cp->mqm_ready_counter)
    cp->mqm_ready_ptr = mqm;
  if (0 != GNUNET_MQ_get_length (cp->core_mq))
    return;
  send_next_ready (cp);
}
 
 
static int
destroy_iterator_cb (void *cls,
                     const struct GNUNET_PeerIdentity *pid,
                     void *value)
{
  struct CadetPeer *cp = value;
 
  if (NULL != cp->destroy_task)
  {
    GNUNET_SCHEDULER_cancel (cp->destroy_task);
    cp->destroy_task = NULL;
  }
  destroy_peer (cp);
  return GNUNET_OK;
}
 
 
void
GCP_destroy_all_peers ()
{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Destroying all peers now\n");
  GNUNET_CONTAINER_multipeermap_iterate (peers,
                                         &destroy_iterator_cb,
                                         NULL);
}
 
 
void
GCP_drop_owned_paths (struct CadetPeer *cp)
{
  struct CadetPeerPath *path;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Destroying all paths to %s\n",
       GCP_2s (cp));
  while (NULL != (path =
                    GNUNET_CONTAINER_heap_remove_root (cp->path_heap)))
    GCPP_release (path);
  GNUNET_CONTAINER_heap_destroy (cp->path_heap);
  cp->path_heap = NULL;
}
 
 
void
GCP_path_entry_add (struct CadetPeer *cp,
                    struct CadetPeerPathEntry *entry,
                    unsigned int off)
{
  GNUNET_assert (cp == GCPP_get_peer_at_offset (entry->path,
                                                off));
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Discovered that peer %s is on path %s at offset %u\n",
       GCP_2s (cp),
       GCPP_2s (entry->path),
       off);
  if (off >= cp->path_dll_length)
  {
    unsigned int len = cp->path_dll_length;
 
    GNUNET_array_grow (cp->path_heads,
                       len,
                       off + 4);
    GNUNET_array_grow (cp->path_tails,
                       cp->path_dll_length,
                       off + 4);
  }
  GNUNET_CONTAINER_DLL_insert (cp->path_heads[off],
                               cp->path_tails[off],
                               entry);
  cp->off_sum += off;
  cp->num_paths++;
 
  /* If we have a tunnel to this peer, tell the tunnel that there is a
     new path available. */
  if (NULL != cp->t)
    GCT_consider_path (cp->t,
                       entry->path,
                       off);
 
  if ((NULL != cp->search_h) &&
      (DESIRED_CONNECTIONS_PER_TUNNEL <= cp->num_paths))
  {
    /* Now I have enough paths, stop search */
    GCD_search_stop (cp->search_h);
    cp->search_h = NULL;
  }
  if (NULL != cp->destroy_task)
  {
    /* paths changed, this resets the destroy timeout counter
       and aborts a destroy task that may no longer be valid
       to have (as we now have more paths via this peer). */
    consider_peer_destroy (cp);
  }
}
 
 
void
GCP_path_entry_remove (struct CadetPeer *cp,
                       struct CadetPeerPathEntry *entry,
                       unsigned int off)
{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Removing knowledge about peer %s being on path %s at offset %u\n",
       GCP_2s (cp),
       GCPP_2s (entry->path),
       off);
  GNUNET_CONTAINER_DLL_remove (cp->path_heads[off],
                               cp->path_tails[off],
                               entry);
  GNUNET_assert (0 < cp->num_paths);
  cp->off_sum -= off;
  cp->num_paths--;
  if ((NULL == cp->core_mq) &&
      (NULL != cp->t) &&
      (NULL == cp->search_h) &&
      (DESIRED_CONNECTIONS_PER_TUNNEL > cp->num_paths))
    cp->search_h
      = GCD_search (&cp->pid);
  if (NULL == cp->destroy_task)
  {
    /* paths changed, we might now be ready for destruction, check again */
    consider_peer_destroy (cp);
  }
}
 
 
static void
path_heap_cleanup (void *cls)
{
  struct CadetPeer *cp = cls;
  struct CadetPeerPath *root;
 
  cp->heap_cleanup_task = NULL;
  while (GNUNET_CONTAINER_heap_get_size (cp->path_heap) >=
         2 * DESIRED_CONNECTIONS_PER_TUNNEL)
  {
    /* Now we have way too many, drop least desirable UNLESS it is in use!
       (Note that this intentionally keeps highly desirable, but currently
       unused paths around in the hope that we might be able to switch, even
       if the number of paths exceeds the threshold.) */
    root = GNUNET_CONTAINER_heap_peek (cp->path_heap);
    GNUNET_assert (NULL != root);
    if (NULL !=
        GCPP_get_connection (root,
                             cp,
                             GCPP_get_length (root) - 1))
      break;   /* can't fix */
    /* Got plenty of paths to this destination, and this is a low-quality
       one that we don't care about. Allow it to die. */
    GNUNET_assert (root ==
                   GNUNET_CONTAINER_heap_remove_root (cp->path_heap));
    GCPP_release (root);
  }
}
 
 
struct GNUNET_CONTAINER_HeapNode *
GCP_attach_path (struct CadetPeer *cp,
                 struct CadetPeerPath *path,
                 unsigned int off,
                 int force)
{
  GNUNET_CONTAINER_HeapCostType desirability;
  struct CadetPeerPath *root;
  GNUNET_CONTAINER_HeapCostType root_desirability;
  struct GNUNET_CONTAINER_HeapNode *hn;
 
  GNUNET_assert (off == GCPP_get_length (path) - 1);
  GNUNET_assert (cp == GCPP_get_peer_at_offset (path,
                                                off));
  if (NULL == cp->path_heap)
  {
    /* #GCP_drop_owned_paths() was already called, we cannot take new ones! */
    GNUNET_assert (GNUNET_NO == force);
    return NULL;
  }
  desirability = GCPP_get_desirability (path);
  if (GNUNET_NO == force)
  {
    /* FIXME: desirability is not yet initialized; tricky! */
    if (GNUNET_NO ==
        GNUNET_CONTAINER_heap_peek2 (cp->path_heap,
                                     (void **) &root,
                                     &root_desirability))
    {
      root = NULL;
      root_desirability = 0;
    }
 
    if ((DESIRED_CONNECTIONS_PER_TUNNEL > cp->num_paths) &&
        (desirability < root_desirability))
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Decided to not attach path %s to peer %s due to undesirability\n",
           GCPP_2s (path),
           GCP_2s (cp));
      return NULL;
    }
  }
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Attaching path %s to peer %s (%s)\n",
       GCPP_2s (path),
       GCP_2s (cp),
       (GNUNET_NO == force) ? "desirable" : "forced");
 
  /* Yes, we'd like to add this path, add to our heap */
  hn = GNUNET_CONTAINER_heap_insert (cp->path_heap,
                                     path,
                                     desirability);
 
  /* Consider maybe dropping other paths because of the new one */
  if ((GNUNET_CONTAINER_heap_get_size (cp->path_heap) >=
       2 * DESIRED_CONNECTIONS_PER_TUNNEL) &&
      (NULL != cp->heap_cleanup_task))
    cp->heap_cleanup_task = GNUNET_SCHEDULER_add_now (&path_heap_cleanup,
                                                      cp);
  return hn;
}
 
 
void
GCP_detach_path (struct CadetPeer *cp,
                 struct CadetPeerPath *path,
                 struct GNUNET_CONTAINER_HeapNode *hn)
{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Detaching path %s from peer %s\n",
       GCPP_2s (path),
       GCP_2s (cp));
  GNUNET_assert (path ==
                 GNUNET_CONTAINER_heap_remove_node (hn));
}
 
 
void
GCP_add_connection (struct CadetPeer *cp,
                    struct CadetConnection *cc)
{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Adding %s to peer %s\n",
       GCC_2s (cc),
       GCP_2s (cp));
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multishortmap_put (cp->connections,
                                                     &GCC_get_id (
                                                       cc)->connection_of_tunnel
                                                     ,
                                                     cc,
                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  if (NULL != cp->destroy_task)
  {
    GNUNET_SCHEDULER_cancel (cp->destroy_task);
    cp->destroy_task = NULL;
  }
}
 
 
void
GCP_remove_connection (struct CadetPeer *cp,
                       struct CadetConnection *cc)
{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Removing connection %s from peer %s\n",
       GCC_2s (cc),
       GCP_2s (cp));
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multishortmap_remove (cp->connections,
                                                        &GCC_get_id (
                                                          cc)->
                                                        connection_of_tunnel,
                                                        cc));
  consider_peer_destroy (cp);
}
 
 
struct CadetPeer *
GCP_get (const struct GNUNET_PeerIdentity *peer_id,
         int create)
{
  struct CadetPeer *cp;
 
  cp = GNUNET_CONTAINER_multipeermap_get (peers,
                                          peer_id);
  if (NULL != cp)
    return cp;
  if (GNUNET_NO == create)
    return NULL;
  cp = GNUNET_new (struct CadetPeer);
  cp->pid = *peer_id;
  cp->connections = GNUNET_CONTAINER_multishortmap_create (32,
                                                           GNUNET_YES);
  cp->path_heap = GNUNET_CONTAINER_heap_create (
    GNUNET_CONTAINER_HEAP_ORDER_MIN);
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multipeermap_put (peers,
                                                    &cp->pid,
                                                    cp,
                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Creating peer %s\n",
       GCP_2s (cp));
  return cp;
}
 
 
const struct GNUNET_PeerIdentity *
GCP_get_id (struct CadetPeer *cp)
{
  return &cp->pid;
}
 
 
void
GCP_iterate_all (GNUNET_CONTAINER_PeerMapIterator iter,
                 void *cls)
{
  GNUNET_CONTAINER_multipeermap_iterate (peers,
                                         iter,
                                         cls);
}
 
 
unsigned int
GCP_count_paths (const struct CadetPeer *cp)
{
  return cp->num_paths;
}
 
 
unsigned int
GCP_iterate_paths (struct CadetPeer *cp,
                   GCP_PathIterator callback,
                   void *callback_cls)
{
  unsigned int ret = 0;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Iterating over paths to peer %s%s\n",
       GCP_2s (cp),
       (NULL == cp->core_mq) ? "" : " including direct link");
  if (NULL != cp->core_mq)
  {
    /* FIXME: this branch seems to duplicate the
       i=0 case below (direct link). Leave out!??? -CG */
    struct CadetPeerPath *path;
 
    path = GCPP_get_path_from_route (1,
                                     &cp->pid);
    ret++;
    if (GNUNET_NO ==
        callback (callback_cls,
                  path,
                  0))
      return ret;
  }
  for (unsigned int i = 0; i < cp->path_dll_length; i++)
  {
    for (struct CadetPeerPathEntry *pe = cp->path_heads[i];
         NULL != pe;
         pe = pe->next)
    {
      ret++;
      if (GNUNET_NO ==
          callback (callback_cls,
                    pe->path,
                    i))
        return ret;
    }
  }
  return ret;
}
 
 
unsigned int
GCP_iterate_indirect_paths (struct CadetPeer *cp,
                            GCP_PathIterator callback,
                            void *callback_cls)
{
  unsigned int ret = 0;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Iterating over paths to peer %s without direct link\n",
       GCP_2s (cp));
  for (unsigned int i = 1; i < cp->path_dll_length; i++)
  {
    for (struct CadetPeerPathEntry *pe = cp->path_heads[i];
         NULL != pe;
         pe = pe->next)
    {
      ret++;
      if (GNUNET_NO ==
          callback (callback_cls,
                    pe->path,
                    i))
        return ret;
    }
  }
  return ret;
}
 
 
unsigned int
GCP_iterate_paths_at (struct CadetPeer *cp,
                      unsigned int dist,
                      GCP_PathIterator callback,
                      void *callback_cls)
{
  unsigned int ret = 0;
 
  if (dist >= cp->path_dll_length)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Asked to look for paths at distance %u, but maximum for me is < %u\n",
         dist,
         cp->path_dll_length);
    return 0;
  }
  for (struct CadetPeerPathEntry *pe = cp->path_heads[dist];
       NULL != pe;
       pe = pe->next)
  {
    if (GNUNET_NO ==
        callback (callback_cls,
                  pe->path,
                  dist))
      return ret;
    ret++;
  }
  return ret;
}
 
 
struct CadetTunnel *
GCP_get_tunnel (struct CadetPeer *cp,
                int create)
{
  if (NULL == cp)
    return NULL;
  if ((NULL != cp->t) ||
      (GNUNET_NO == create))
    return cp->t;
  cp->t = GCT_create_tunnel (cp);
  consider_peer_activate (cp);
  return cp->t;
}
 
 
void
GCP_set_hello (struct CadetPeer *cp,
               const struct GNUNET_MessageHeader *hello)
{
  struct GNUNET_BANDWIDTH_Value32NBO bw;
  uint16_t size = ntohs (hello->size);
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Got %u byte HELLO for peer %s\n",
       (unsigned int) size,
       GCP_2s (cp));
  if (NULL != cp->hello)
  {
    struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
 
    struct GNUNET_TIME_Absolute new_hello_exp =
      GNUNET_HELLO_get_expiration_time_from_msg (hello);
    struct GNUNET_TIME_Absolute old_hello_exp =
      GNUNET_HELLO_get_expiration_time_from_msg (cp->hello);
 
    if (GNUNET_TIME_absolute_cmp (new_hello_exp, >, now) &&
        GNUNET_TIME_absolute_cmp (new_hello_exp, >, old_hello_exp))
    {
      GNUNET_free (cp->hello);
      cp->hello = GNUNET_malloc (size);
      GNUNET_memcpy (cp->hello, hello, size);
    }
    else
    {
      return;
    }
  }
  else
  {
    cp->hello = GNUNET_memdup (hello,
                               size);
  }
  if (NULL != cp->ash)
    GNUNET_TRANSPORT_application_suggest_cancel (cp->ash);
  bw.value__ = 0;
  cp->ash
    = GNUNET_TRANSPORT_application_suggest (transport,
                                            &cp->pid,
                                            GNUNET_MQ_PRIO_BEST_EFFORT,
                                            bw);
  /* New HELLO means cp's destruction time may change... */
  consider_peer_destroy (cp);
}
 
 
void
GCP_drop_tunnel (struct CadetPeer *cp,
                 struct CadetTunnel *t)
{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Dropping tunnel %s to peer %s\n",
       GCT_2s (t),
       GCP_2s (cp));
  GNUNET_assert (cp->t == t);
  cp->t = NULL;
  consider_peer_destroy (cp);
}
 
 
int
GCP_has_core_connection (struct CadetPeer *cp)
{
  return (NULL != cp->core_mq) ? GNUNET_YES : GNUNET_NO;
}
 
 
struct GCP_MessageQueueManager *
GCP_request_mq (struct CadetPeer *cp,
                GCP_MessageQueueNotificationCallback cb,
                void *cb_cls)
{
  struct GCP_MessageQueueManager *mqm;
 
  mqm = GNUNET_new (struct GCP_MessageQueueManager);
  mqm->cb = cb;
  mqm->cb_cls = cb_cls;
  mqm->cp = cp;
  GNUNET_CONTAINER_DLL_insert (cp->mqm_head,
                               cp->mqm_tail,
                               mqm);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Creating MQM %p for peer %s\n",
       mqm,
       GCP_2s (cp));
  if (NULL != cp->core_mq)
    cb (cb_cls,
        GNUNET_YES);
  return mqm;
}
 
 
void
GCP_request_mq_cancel (struct GCP_MessageQueueManager *mqm,
                       struct GNUNET_MQ_Envelope *last_env)
{
  struct CadetPeer *cp = mqm->cp;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Destroying MQM %p for peer %s%s\n",
       mqm,
       GCP_2s (cp),
       (NULL == last_env) ? "" : " with last ditch transmission");
  if (NULL != mqm->env)
    GNUNET_MQ_discard (mqm->env);
  if (NULL != last_env)
  {
    if (NULL != cp->core_mq)
    {
      GNUNET_MQ_notify_sent (last_env,
                             &mqm_send_done,
                             cp);
      GNUNET_MQ_send (cp->core_mq,
                      last_env);
    }
    else
    {
      GNUNET_MQ_discard (last_env);
    }
  }
  if (cp->mqm_ready_ptr == mqm)
    cp->mqm_ready_ptr = mqm->next;
  GNUNET_CONTAINER_DLL_remove (cp->mqm_head,
                               cp->mqm_tail,
                               mqm);
  GNUNET_free (mqm);
}
 
 
void
GCP_send_ooo (struct CadetPeer *cp,
              struct GNUNET_MQ_Envelope *env)
{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Sending message to %s out of management\n",
       GCP_2s (cp));
  if (NULL == cp->core_mq)
  {
    GNUNET_MQ_discard (env);
    return;
  }
  if (GNUNET_MQ_get_length (cp->core_mq) > MAX_OOO_QUEUE_SIZE)
  {
    GNUNET_MQ_discard (env);
    return;
  }
  GNUNET_MQ_notify_sent (env,
                         &mqm_send_done,
                         cp);
  GNUNET_MQ_send (cp->core_mq,
                  env);
}
 
 
int
GCP_check_and_update_monotime (struct CadetPeer *peer,
                               struct GNUNET_TIME_AbsoluteNBO monotime)
{
 
  struct GNUNET_TIME_Absolute mt = GNUNET_TIME_absolute_ntoh (monotime);
 
  if (mt.abs_value_us > *(&peer->last_connection_create.abs_value_us))
  {
    peer->last_connection_create = mt;
    return GNUNET_YES;
  }
  return GNUNET_NO;
}
 
 
int
GCP_check_monotime_sig (struct CadetPeer *peer,
                        const struct GNUNET_CADET_ConnectionCreateMessage *msg)
{
  struct CadetConnectionCreatePS cp = { .purpose.purpose = htonl (
                                          GNUNET_SIGNATURE_PURPOSE_CADET_CONNECTION_INITIATOR),
                                        .purpose.size = htonl (sizeof(cp)),
                                        .monotonic_time = msg->monotime};
 
  if (GNUNET_OK !=
      GNUNET_CRYPTO_eddsa_verify (
        GNUNET_SIGNATURE_PURPOSE_CADET_CONNECTION_INITIATOR,
        &cp,
        &msg->monotime_sig,
        &peer->pid.public_key))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}
 
 
/* end of gnunet-service-cadet-new_peer.c */

IDLE_PATH_TIMEOUT

#define IDLE_PATH_TIMEOUT

Value:

          GNUNET_TIME_relative_multiply ( \
          GNUNET_TIME_UNIT_MINUTES, 2)

How long do we keep paths around if we no longer care about the peer?

Definition at line 61 of file gnunet-service-cadet_peer.c.

MAX_OOO_QUEUE_SIZE

#define MAX_OOO_QUEUE_SIZE   100

Queue size when we start dropping OOO messages.

Definition at line 67 of file gnunet-service-cadet_peer.c.

Function Documentation

GCP_2s()

const char * GCP_2s

(

const struct CadetPeer *

peer

)

Get the static string for a peer ID.

Parameters

peer

Peer.

Returns

Static string for it's ID.

Definition at line 234 of file gnunet-service-cadet_peer.c.

{
  static char buf[5];
  char *ret;
 
  if ((NULL == cp) ||
      (GNUNET_YES == GNUNET_is_zero (&cp->pid.public_key)))
    return "NULL";
 
  ret = GNUNET_CRYPTO_eddsa_public_key_to_string (&cp->pid.public_key);
  if (NULL == ret)
    return "NULL";
 
  GNUNET_strlcpy (buf,
                  ret,
                  sizeof(buf));
  GNUNET_free (ret);
  return buf;
}

References GNUNET_CRYPTO_eddsa_public_key_to_string(), GNUNET_free, GNUNET_is_zero, GNUNET_strlcpy(), GNUNET_YES, CadetPeer::pid, GNUNET_PeerIdentity::public_key, and ret.

Referenced by consider_path_cb(), consider_peer_activate(), destroy_peer(), dht_get_id_handler(), GCC_debug(), GCCH_channel_incoming_new(), GCCH_channel_local_new(), GCP_add_connection(), GCP_attach_path(), GCP_detach_path(), GCP_drop_owned_paths(), GCP_drop_tunnel(), GCP_get(), GCP_iterate_indirect_paths(), GCP_iterate_paths(), GCP_path_entry_add(), GCP_path_entry_remove(), GCP_remove_connection(), GCP_request_mq(), GCP_request_mq_cancel(), GCP_send(), GCP_send_ooo(), GCP_set_hello(), GCP_set_mq(), GSC_bind(), handle_connection_create(), mqm_execute(), mqm_send_done(), route_message(), send_broken(), and timeout_closed_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GCP_get_desirability_of_path()

double GCP_get_desirability_of_path	(	struct CadetPeer *	cp,
		unsigned int	off
	)

Calculate how desirable a path is for cp if cp is at offset off in the path.

The 'desirability_table.c' program can be used to compute a list of sample outputs for different scenarios. Basically, we score paths lower if there are many alternatives, and higher if they are shorter than average, and very high if they are much shorter than average and without many alternatives.

Parameters

cp	a peer reachable via a path
off	offset of cp in a path

Returns

score how useful a path is to reach cp, positive scores mean path is more desirable

Definition at line 256 of file gnunet-service-cadet_peer.c.

{
  unsigned int num_alts = cp->num_paths;
  unsigned int off_sum;
  double avg_sum;
  double path_delta;
  double weight_alts;
 
  GNUNET_assert (num_alts >= 1);  /* 'path' should be in there! */
  GNUNET_assert (0 != cp->path_dll_length);
 
  /* We maintain 'off_sum' in 'peer' and thereby
     avoid the SLOW recalculation each time. Kept here
     just to document what is going on. */
#if SLOW
  off_sum = 0;
  for (unsigned int j = 0; j < cp->path_dll_length; j++)
    for (struct CadetPeerPathEntry *pe = cp->path_heads[j];
         NULL != pe;
         pe = pe->next)
      off_sum += j;
  GNUNET_assert (off_sum == cp->off_sum);
#else
  off_sum = cp->off_sum;
#endif
  avg_sum = off_sum * 1.0 / cp->path_dll_length;
  path_delta = off - avg_sum;
  /* path_delta positive: path off of peer above average (bad path for peer),
     path_delta negative: path off of peer below average (good path for peer) */
  if (path_delta <= -1.0)
    weight_alts = -num_alts / path_delta;  /* discount alternative paths */
  else if (path_delta >= 1.0)
    weight_alts = num_alts * path_delta; /* overcount alternative paths */
  else
    weight_alts = num_alts; /* count alternative paths normally */
 
 
  /* off+1: long paths are generally harder to find and thus count
     a bit more as they get longer.  However, above-average paths
     still need to count less, hence the squaring of that factor. */
  return (off + 1.0) / (weight_alts * weight_alts);
}

References GNUNET_assert, CadetPeer::num_paths, CadetPeer::off_sum, CadetPeer::path_dll_length, and CadetPeer::path_heads.

Referenced by recalculate_path_desirability().

Here is the caller graph for this function:

destroy_peer()

static void destroy_peer ( void *  cls )

static

This peer is no longer be needed, clean it up now.

Parameters

cls	peer to clean up

Definition at line 307 of file gnunet-service-cadet_peer.c.

{
  struct CadetPeer *cp = cls;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Destroying state about peer %s\n",
       GCP_2s (cp));
  cp->destroy_task = NULL;
  GNUNET_assert (NULL == cp->t);
  GNUNET_assert (NULL == cp->core_mq);
  GNUNET_assert (0 == cp->num_paths);
  for (unsigned int i = 0; i < cp->path_dll_length; i++)
    GNUNET_assert (NULL == cp->path_heads[i]);
  GNUNET_assert (0 == GNUNET_CONTAINER_multishortmap_size (cp->connections));
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multipeermap_remove (peers,
                                                       &cp->pid,
                                                       cp));
  GNUNET_free (cp->path_heads);
  GNUNET_free (cp->path_tails);
  cp->path_dll_length = 0;
  if (NULL != cp->search_h)
  {
    GCD_search_stop (cp->search_h);
    cp->search_h = NULL;
  }
  /* FIXME: clean up search_delayedXXX! */
 
 
  if (NULL != cp->ash)
  {
    GNUNET_TRANSPORT_application_suggest_cancel (cp->ash);
    cp->ash = NULL;
  }
  GNUNET_CONTAINER_multishortmap_destroy (cp->connections);
  if (NULL != cp->path_heap)
  {
    GNUNET_CONTAINER_heap_destroy (cp->path_heap);
    cp->path_heap = NULL;
  }
  if (NULL != cp->heap_cleanup_task)
  {
    GNUNET_SCHEDULER_cancel (cp->heap_cleanup_task);
    cp->heap_cleanup_task = NULL;
  }
  GNUNET_free (cp->hello);
  /* Peer should not be freed if paths exist; if there are no paths,
     there ought to be no connections, and without connections, no
     notifications. Thus we can assert that mqm_head is empty at this
     point. */
  GNUNET_assert (NULL == cp->mqm_head);
  GNUNET_assert (NULL == cp->mqm_ready_ptr);
  GNUNET_free (cp);
}

References CadetPeer::ash, CadetPeer::connections, CadetPeer::core_mq, CadetPeer::destroy_task, GCD_search_stop(), GCP_2s(), GNUNET_assert, GNUNET_CONTAINER_heap_destroy(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_CONTAINER_multishortmap_destroy(), GNUNET_CONTAINER_multishortmap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_SCHEDULER_cancel(), GNUNET_TRANSPORT_application_suggest_cancel(), GNUNET_YES, CadetPeer::heap_cleanup_task, CadetPeer::hello, LOG, CadetPeer::mqm_head, CadetPeer::mqm_ready_ptr, CadetPeer::num_paths, CadetPeer::path_dll_length, CadetPeer::path_heads, CadetPeer::path_heap, CadetPeer::path_tails, peers, CadetPeer::pid, CadetPeer::search_h, and CadetPeer::t.

Referenced by consider_peer_destroy(), and destroy_iterator_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

consider_peer_activate()

static void consider_peer_activate ( struct CadetPeer *  cp )

static

This peer is now on more "active" duty, activate processes related to it.

Parameters

cp	the more-active peer

Definition at line 369 of file gnunet-service-cadet_peer.c.

{
  struct GNUNET_BANDWIDTH_Value32NBO bw;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Updating peer %s activation state (%u connections)%s%s\n",
       GCP_2s (cp),
       GNUNET_CONTAINER_multishortmap_size (cp->connections),
       (NULL == cp->t) ? "" : " with tunnel",
       (NULL == cp->core_mq) ? "" : " with CORE link");
  if (NULL != cp->destroy_task)
  {
    /* It's active, do not destroy! */
    GNUNET_SCHEDULER_cancel (cp->destroy_task);
    cp->destroy_task = NULL;
  }
  if ((0 == GNUNET_CONTAINER_multishortmap_size (cp->connections)) &&
      (NULL == cp->t))
  {
    /* We're just on a path or directly connected; don't bother too much */
    if (NULL != cp->ash)
    {
      GNUNET_TRANSPORT_application_suggest_cancel (cp->ash);
      cp->ash = NULL;
    }
    if (NULL != cp->search_h)
    {
      GCD_search_stop (cp->search_h);
      cp->search_h = NULL;
    }
    return;
  }
  if (NULL == cp->core_mq)
  {
    /* Lacks direct connection, try to create one by querying the DHT */
    if ((NULL == cp->search_h) &&
        (DESIRED_CONNECTIONS_PER_TUNNEL > cp->num_paths))
      cp->search_h
        = GCD_search (&cp->pid);
  }
  else
  {
    /* Have direct connection, stop DHT search if active */
    if (NULL != cp->search_h)
    {
      GCD_search_stop (cp->search_h);
      cp->search_h = NULL;
    }
  }
 
  if (NULL != cp->ash)
    GNUNET_TRANSPORT_application_suggest_cancel (cp->ash);
  bw.value__ = 0;
  cp->ash
    = GNUNET_TRANSPORT_application_suggest (transport,
                                            &cp->pid,
                                            GNUNET_MQ_PRIO_BEST_EFFORT,
                                            bw);
}

References CadetPeer::ash, CadetPeer::connections, CadetPeer::core_mq, DESIRED_CONNECTIONS_PER_TUNNEL, CadetPeer::destroy_task, GCD_search(), GCD_search_stop(), GCP_2s(), GNUNET_CONTAINER_multishortmap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_MQ_PRIO_BEST_EFFORT, GNUNET_SCHEDULER_cancel(), GNUNET_TRANSPORT_application_suggest(), GNUNET_TRANSPORT_application_suggest_cancel(), LOG, CadetPeer::num_paths, CadetPeer::pid, CadetPeer::search_h, CadetPeer::t, transport, and GNUNET_BANDWIDTH_Value32NBO::value__.

Referenced by GCP_get_tunnel(), and GCP_set_mq().

Here is the call graph for this function:

Here is the caller graph for this function:

consider_peer_destroy()

static void consider_peer_destroy ( struct CadetPeer *  cp )

static

This peer may no longer be needed, consider cleaning it up.

Parameters

cp	peer to clean up

Definition at line 464 of file gnunet-service-cadet_peer.c.

{
  struct GNUNET_TIME_Relative exp;
 
  if (NULL != cp->destroy_task)
  {
    GNUNET_SCHEDULER_cancel (cp->destroy_task);
    cp->destroy_task = NULL;
  }
  if (NULL != cp->t)
    return; /* still relevant! */
  if (NULL != cp->core_mq)
    return; /* still relevant! */
  if (0 != GNUNET_CONTAINER_multishortmap_size (cp->connections))
    return; /* still relevant! */
  if ((NULL != cp->path_heap) &&
      (0 < GNUNET_CONTAINER_heap_get_size (cp->path_heap)))
  {
    cp->destroy_task = GNUNET_SCHEDULER_add_delayed (IDLE_PATH_TIMEOUT,
                                                     &drop_paths,
                                                     cp);
    return;
  }
  if (0 != cp->num_paths)
    return; /* still relevant! */
  if (NULL != cp->hello)
  {
    /* relevant only until HELLO expires */
    exp = GNUNET_TIME_absolute_get_remaining (
      GNUNET_HELLO_get_expiration_time_from_msg (cp->hello));
    cp->destroy_task = GNUNET_SCHEDULER_add_delayed (exp,
                                                     &destroy_peer,
                                                     cp);
    return;
  }
  cp->destroy_task = GNUNET_SCHEDULER_add_delayed (IDLE_PEER_TIMEOUT,
                                                   &destroy_peer,
                                                   cp);
}

References CadetPeer::connections, CadetPeer::core_mq, destroy_peer(), CadetPeer::destroy_task, drop_paths(), GNUNET_CONTAINER_heap_get_size(), GNUNET_CONTAINER_multishortmap_size(), GNUNET_HELLO_get_expiration_time_from_msg(), GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_TIME_absolute_get_remaining(), CadetPeer::hello, IDLE_PATH_TIMEOUT, IDLE_PEER_TIMEOUT, CadetPeer::num_paths, CadetPeer::path_heap, and CadetPeer::t.

Referenced by drop_paths(), GCP_drop_tunnel(), GCP_path_entry_add(), GCP_path_entry_remove(), GCP_remove_connection(), GCP_set_hello(), and GCP_set_mq().

Here is the call graph for this function:

Here is the caller graph for this function:

drop_paths()

static void drop_paths ( void *  cls )

static

We really no longere care about a peer, stop hogging memory with paths to it.

Afterwards, see if there is more to be cleaned up about this peer.

Parameters

cls	a struct CadetPeer.

Definition at line 446 of file gnunet-service-cadet_peer.c.

{
  struct CadetPeer *cp = cls;
  struct CadetPeerPath *path;
 
  cp->destroy_task = NULL;
  while (NULL != (path = GNUNET_CONTAINER_heap_remove_root (cp->path_heap)))
    GCPP_release (path);
  consider_peer_destroy (cp);
}

References consider_peer_destroy(), CadetPeer::destroy_task, GCPP_release(), GNUNET_CONTAINER_heap_remove_root(), and CadetPeer::path_heap.

Referenced by consider_peer_destroy().

Here is the call graph for this function:

Here is the caller graph for this function:

GCP_set_mq()

void GCP_set_mq	(	struct CadetPeer *	cp,
		struct GNUNET_MQ_Handle *	mq
	)

Set the message queue to mq for peer cp and notify watchers.

Parameters

cp	peer to modify
mq	message queue to set (can be NULL)

Definition at line 512 of file gnunet-service-cadet_peer.c.

{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Message queue for peer %s is now %p\n",
       GCP_2s (cp),
       mq);
  cp->core_mq = mq;
  for (struct GCP_MessageQueueManager *mqm = cp->mqm_head, *next;
       NULL != mqm;
       mqm = next)
  {
    /* Save next pointer in case mqm gets freed by the callback */
    next = mqm->next;
    if (NULL == mq)
    {
      if (NULL != mqm->env)
      {
        GNUNET_MQ_discard (mqm->env);
        mqm->env = NULL;
        mqm->cb (mqm->cb_cls,
                 GNUNET_SYSERR);
      }
      else
      {
        mqm->cb (mqm->cb_cls,
                 GNUNET_NO);
      }
    }
    else
    {
      GNUNET_assert (NULL == mqm->env);
      mqm->cb (mqm->cb_cls,
               GNUNET_YES);
    }
  }
  if ((NULL != mq) ||
      (NULL != cp->t))
    consider_peer_activate (cp);
  else
    consider_peer_destroy (cp);
 
  if ((NULL != mq) &&
      (NULL != cp->t))
  {
    /* have a new, direct path to the target, notify tunnel */
    struct CadetPeerPath *path;
 
    path = GCPP_get_path_from_route (1,
                                     &cp->pid);
    GCT_consider_path (cp->t,
                       path,
                       0);
  }
}

References consider_peer_activate(), consider_peer_destroy(), CadetPeer::core_mq, GCP_2s(), GCPP_get_path_from_route(), GCT_consider_path(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MQ_discard(), GNUNET_NO, GNUNET_SYSERR, GNUNET_YES, LOG, mq, CadetPeer::mqm_head, CadetPeer::pid, and CadetPeer::t.

Referenced by core_connect_cb(), and core_disconnect_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

should_I_drop()

static int should_I_drop ( void  )

static

Debug function should NEVER return true in production code, useful to simulate losses for testcases.

Returns

GNUNET_YES or GNUNET_NO with the decision to drop.

Definition at line 576 of file gnunet-service-cadet_peer.c.

{
  if (0 == drop_percent)
    return GNUNET_NO;
  if (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
                                101) < drop_percent)
    return GNUNET_YES;
  return GNUNET_NO;
}

References drop_percent, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_NO, and GNUNET_YES.

Referenced by mqm_execute().

Here is the call graph for this function:

Here is the caller graph for this function:

mqm_send_done()

static void mqm_send_done ( void *  cls )

static

Function called when CORE took one of the messages from a message queue manager and transmitted it.

Parameters

cls	the struct CadetPeeer where we made progress

Definition at line 699 of file gnunet-service-cadet_peer.c.

{
  struct CadetPeer *cp = cls;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Sending to peer %s completed\n",
       GCP_2s (cp));
  send_next_ready (cp);
}

References GCP_2s(), GNUNET_ERROR_TYPE_DEBUG, LOG, and send_next_ready().

Referenced by GCP_request_mq_cancel(), GCP_send(), GCP_send_ooo(), and mqm_execute().

Here is the call graph for this function:

Here is the caller graph for this function:

mqm_execute()

static void mqm_execute ( struct GCP_MessageQueueManager *  mqm )

static

Transmit current envelope from this mqm.

Parameters

mqm	mqm to transmit message for now

Definition at line 603 of file gnunet-service-cadet_peer.c.

{
  struct CadetPeer *cp = mqm->cp;
 
  /* Move ready pointer to the next entry that might be ready. */
  if ((mqm == cp->mqm_ready_ptr) &&
      (NULL != mqm->next))
    cp->mqm_ready_ptr = mqm->next;
  /* Move entry to the end of the DLL, to be fair. */
  if (mqm != cp->mqm_tail)
  {
    GNUNET_CONTAINER_DLL_remove (cp->mqm_head,
                                 cp->mqm_tail,
                                 mqm);
    GNUNET_CONTAINER_DLL_insert_tail (cp->mqm_head,
                                      cp->mqm_tail,
                                      mqm);
  }
  cp->mqm_ready_counter--;
  if (GNUNET_YES == should_I_drop ())
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "DROPPING message to peer %s from MQM %p\n",
         GCP_2s (cp),
         mqm);
    GNUNET_MQ_discard (mqm->env);
    mqm->env = NULL;
    mqm_send_done (cp);
  }
  else
  {
    {
      const struct GNUNET_MessageHeader *mh;
 
      mh = GNUNET_MQ_env_get_msg (mqm->env);
      switch (ntohs (mh->type))
      {
      case GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX:
        {
          const struct GNUNET_CADET_TunnelKeyExchangeMessage *msg
            = (const struct GNUNET_CADET_TunnelKeyExchangeMessage *) mh;
          LOG (GNUNET_ERROR_TYPE_DEBUG,
               "P2P forwarding KX with ephemeral %s to %s on CID %s\n",
               GNUNET_e2s (&msg->ephemeral_key),
               GCP_2s (cp),
               GNUNET_sh2s (&msg->cid.connection_of_tunnel));
        }
        break;
 
      default:
        break;
      }
    }
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Sending to peer %s from MQM %p\n",
         GCP_2s (cp),
         mqm);
    GNUNET_MQ_send (cp->core_mq,
                    mqm->env);
    mqm->env = NULL;
  }
  mqm->cb (mqm->cb_cls,
           GNUNET_YES);
}

References GCP_MessageQueueManager::cb, GCP_MessageQueueManager::cb_cls, CadetPeer::core_mq, GCP_MessageQueueManager::cp, GCP_MessageQueueManager::env, GCP_2s(), GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_e2s(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX, GNUNET_MQ_discard(), GNUNET_MQ_env_get_msg(), GNUNET_MQ_send(), GNUNET_sh2s(), GNUNET_YES, LOG, mh, CadetPeer::mqm_head, CadetPeer::mqm_ready_counter, CadetPeer::mqm_ready_ptr, mqm_send_done(), CadetPeer::mqm_tail, msg, GCP_MessageQueueManager::next, and should_I_drop().

Referenced by send_next_ready().

Here is the call graph for this function:

Here is the caller graph for this function:

send_next_ready()

static void send_next_ready ( struct CadetPeer *  cp )

static

Find the next ready message in the queue (starting the search from the cp->mqm_ready_ptr) and if possible execute the transmission.

Parameters

cp	peer to try to send the next ready message to

Definition at line 677 of file gnunet-service-cadet_peer.c.

{
  struct GCP_MessageQueueManager *mqm;
 
  if (0 == cp->mqm_ready_counter)
    return;
  while ((NULL != (mqm = cp->mqm_ready_ptr)) &&
         (NULL == mqm->env))
    cp->mqm_ready_ptr = mqm->next;
  if (NULL == mqm)
    return; /* nothing to do */
  mqm_execute (mqm);
}

References GCP_MessageQueueManager::cp, GCP_MessageQueueManager::env, mqm_execute(), CadetPeer::mqm_ready_counter, CadetPeer::mqm_ready_ptr, and GCP_MessageQueueManager::next.

Referenced by GCP_send(), and mqm_send_done().

Here is the call graph for this function:

Here is the caller graph for this function:

GCP_send()

void GCP_send	(	struct GCP_MessageQueueManager *	mqm,
		struct GNUNET_MQ_Envelope *	env
	)

Send the message in env to cp.

Send the message in env via a mqm.

Parameters

mqm	the message queue manager to use for transmission
env	envelope with the message to send; must NOT yet have a GNUNET_MQ_notify_sent() callback attached to it

Definition at line 718 of file gnunet-service-cadet_peer.c.

{
  struct CadetPeer *cp = mqm->cp;
 
  GNUNET_assert (NULL != env);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Queueing message to peer %s in MQM %p\n",
       GCP_2s (cp),
       mqm);
  GNUNET_assert (NULL != cp->core_mq);
  GNUNET_assert (NULL == mqm->env);
  GNUNET_MQ_notify_sent (env,
                         &mqm_send_done,
                         cp);
  mqm->env = env;
  cp->mqm_ready_counter++;
  if (mqm != cp->mqm_ready_ptr)
    cp->mqm_ready_ptr = cp->mqm_head;
  if (1 == cp->mqm_ready_counter)
    cp->mqm_ready_ptr = mqm;
  if (0 != GNUNET_MQ_get_length (cp->core_mq))
    return;
  send_next_ready (cp);
}

References CadetPeer::core_mq, GCP_MessageQueueManager::cp, env, GCP_MessageQueueManager::env, GCP_2s(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MQ_get_length(), GNUNET_MQ_notify_sent(), LOG, CadetPeer::mqm_head, CadetPeer::mqm_ready_counter, CadetPeer::mqm_ready_ptr, mqm_send_done(), and send_next_ready().

Referenced by dir_ready_cb(), GCC_transmit(), route_message(), send_create(), and send_create_ack().

Here is the call graph for this function:

Here is the caller graph for this function:

destroy_iterator_cb()

static int destroy_iterator_cb ( void *  cls, const struct GNUNET_PeerIdentity *  pid, void *  value  )

static

Function called to destroy a peer now.

Parameters

cls	NULL
pid	identity of the peer (unused)
value	the struct CadetPeer to clean up

Returns

GNUNET_OK (continue to iterate)

Definition at line 754 of file gnunet-service-cadet_peer.c.

{
  struct CadetPeer *cp = value;
 
  if (NULL != cp->destroy_task)
  {
    GNUNET_SCHEDULER_cancel (cp->destroy_task);
    cp->destroy_task = NULL;
  }
  destroy_peer (cp);
  return GNUNET_OK;
}

References destroy_peer(), CadetPeer::destroy_task, GNUNET_OK, GNUNET_SCHEDULER_cancel(), and value.

Referenced by GCP_destroy_all_peers().

Here is the call graph for this function:

Here is the caller graph for this function:

GCP_destroy_all_peers()

void GCP_destroy_all_peers

(

void

)

Clean up all entries about all peers.

Must only be called after all tunnels, CORE-connections and connections are down.

Definition at line 776 of file gnunet-service-cadet_peer.c.

{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Destroying all peers now\n");
  GNUNET_CONTAINER_multipeermap_iterate (peers,
                                         &destroy_iterator_cb,
                                         NULL);
}

References destroy_iterator_cb(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_ERROR_TYPE_DEBUG, LOG, and peers.

Referenced by shutdown_rest().

Here is the call graph for this function:

Here is the caller graph for this function:

GCP_drop_owned_paths()

void GCP_drop_owned_paths

(

struct CadetPeer *

cp

)

Drop all paths owned by this peer, and do not allow new ones to be added: We are shutting down.

Parameters

cp	peer to drop paths to

Definition at line 793 of file gnunet-service-cadet_peer.c.

{
  struct CadetPeerPath *path;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Destroying all paths to %s\n",
       GCP_2s (cp));
  while (NULL != (path =
                    GNUNET_CONTAINER_heap_remove_root (cp->path_heap)))
    GCPP_release (path);
  GNUNET_CONTAINER_heap_destroy (cp->path_heap);
  cp->path_heap = NULL;
}

References GCP_2s(), GCPP_release(), GNUNET_CONTAINER_heap_destroy(), GNUNET_CONTAINER_heap_remove_root(), GNUNET_ERROR_TYPE_DEBUG, LOG, and CadetPeer::path_heap.

Referenced by destroy_paths_now().

Here is the call graph for this function:

Here is the caller graph for this function:

GCP_path_entry_add()

void GCP_path_entry_add	(	struct CadetPeer *	cp,
		struct CadetPeerPathEntry *	entry,
		unsigned int	off
	)

Add an entry to the DLL of all of the paths that this peer is on.

Parameters

cp	peer to modify
entry	an entry on a path
off	offset of this peer on the path

Definition at line 816 of file gnunet-service-cadet_peer.c.

{
  GNUNET_assert (cp == GCPP_get_peer_at_offset (entry->path,
                                                off));
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Discovered that peer %s is on path %s at offset %u\n",
       GCP_2s (cp),
       GCPP_2s (entry->path),
       off);
  if (off >= cp->path_dll_length)
  {
    unsigned int len = cp->path_dll_length;
 
    GNUNET_array_grow (cp->path_heads,
                       len,
                       off + 4);
    GNUNET_array_grow (cp->path_tails,
                       cp->path_dll_length,
                       off + 4);
  }
  GNUNET_CONTAINER_DLL_insert (cp->path_heads[off],
                               cp->path_tails[off],
                               entry);
  cp->off_sum += off;
  cp->num_paths++;
 
  /* If we have a tunnel to this peer, tell the tunnel that there is a
     new path available. */
  if (NULL != cp->t)
    GCT_consider_path (cp->t,
                       entry->path,
                       off);
 
  if ((NULL != cp->search_h) &&
      (DESIRED_CONNECTIONS_PER_TUNNEL <= cp->num_paths))
  {
    /* Now I have enough paths, stop search */
    GCD_search_stop (cp->search_h);
    cp->search_h = NULL;
  }
  if (NULL != cp->destroy_task)
  {
    /* paths changed, this resets the destroy timeout counter
       and aborts a destroy task that may no longer be valid
       to have (as we now have more paths via this peer). */
    consider_peer_destroy (cp);
  }
}

References consider_peer_destroy(), CadetPeer::destroy_task, GCD_search_stop(), GCP_2s(), GCPP_2s(), GCPP_get_peer_at_offset(), GCT_consider_path(), GNUNET_array_grow, GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, LOG, CadetPeer::num_paths, CadetPeer::off_sum, CadetPeerPathEntry::path, CadetPeer::path_dll_length, CadetPeer::path_heads, CadetPeer::path_tails, CadetPeer::search_h, and CadetPeer::t.

Referenced by extend_path(), GCPP_get_path_from_route(), and GCPP_try_path_from_dht().

Here is the call graph for this function:

Here is the caller graph for this function:

GCP_path_entry_remove()

void GCP_path_entry_remove	(	struct CadetPeer *	cp,
		struct CadetPeerPathEntry *	entry,
		unsigned int	off
	)

Remove an entry from the DLL of all of the paths that this peer is on.

Parameters

cp	peer to modify
entry	an entry on a path
off	offset of this peer on the path

Definition at line 876 of file gnunet-service-cadet_peer.c.

{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Removing knowledge about peer %s being on path %s at offset %u\n",
       GCP_2s (cp),
       GCPP_2s (entry->path),
       off);
  GNUNET_CONTAINER_DLL_remove (cp->path_heads[off],
                               cp->path_tails[off],
                               entry);
  GNUNET_assert (0 < cp->num_paths);
  cp->off_sum -= off;
  cp->num_paths--;
  if ((NULL == cp->core_mq) &&
      (NULL != cp->t) &&
      (NULL == cp->search_h) &&
      (DESIRED_CONNECTIONS_PER_TUNNEL > cp->num_paths))
    cp->search_h
      = GCD_search (&cp->pid);
  if (NULL == cp->destroy_task)
  {
    /* paths changed, we might now be ready for destruction, check again */
    consider_peer_destroy (cp);
  }
}

References consider_peer_destroy(), CadetPeer::core_mq, DESIRED_CONNECTIONS_PER_TUNNEL, CadetPeer::destroy_task, GCD_search(), GCP_2s(), GCPP_2s(), GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, LOG, CadetPeer::num_paths, CadetPeer::off_sum, CadetPeerPathEntry::path, CadetPeer::path_heads, CadetPeer::path_tails, CadetPeer::pid, CadetPeer::search_h, and CadetPeer::t.

Referenced by attach_path(), and GCPP_release().

Here is the call graph for this function:

Here is the caller graph for this function:

path_heap_cleanup()

static void path_heap_cleanup ( void *  cls )

static

Prune down the number of paths to this peer, we seem to have way too many.

Parameters

cls	the struct CadetPeer to maintain the path heap for

Definition at line 912 of file gnunet-service-cadet_peer.c.

{
  struct CadetPeer *cp = cls;
  struct CadetPeerPath *root;
 
  cp->heap_cleanup_task = NULL;
  while (GNUNET_CONTAINER_heap_get_size (cp->path_heap) >=
         2 * DESIRED_CONNECTIONS_PER_TUNNEL)
  {
    /* Now we have way too many, drop least desirable UNLESS it is in use!
       (Note that this intentionally keeps highly desirable, but currently
       unused paths around in the hope that we might be able to switch, even
       if the number of paths exceeds the threshold.) */
    root = GNUNET_CONTAINER_heap_peek (cp->path_heap);
    GNUNET_assert (NULL != root);
    if (NULL !=
        GCPP_get_connection (root,
                             cp,
                             GCPP_get_length (root) - 1))
      break;   /* can't fix */
    /* Got plenty of paths to this destination, and this is a low-quality
       one that we don't care about. Allow it to die. */
    GNUNET_assert (root ==
                   GNUNET_CONTAINER_heap_remove_root (cp->path_heap));
    GCPP_release (root);
  }
}

References DESIRED_CONNECTIONS_PER_TUNNEL, GCPP_get_connection(), GCPP_get_length(), GCPP_release(), GNUNET_assert, GNUNET_CONTAINER_heap_get_size(), GNUNET_CONTAINER_heap_peek(), GNUNET_CONTAINER_heap_remove_root(), CadetPeer::heap_cleanup_task, and CadetPeer::path_heap.

Referenced by GCP_attach_path().

Here is the call graph for this function:

Here is the caller graph for this function:

GCP_attach_path()

struct GNUNET_CONTAINER_HeapNode * GCP_attach_path	(	struct CadetPeer *	cp,
		struct CadetPeerPath *	path,
		unsigned int	off,
		int	force
	)

Try adding a path to this cp.

If the peer already has plenty of paths, return NULL.

Parameters

cp	peer to which the path leads to
path	a path looking for an owner; may not be fully initialized yet!
off	offset of cp in path
force	force attaching the path

Returns

NULL if this peer does not care to become a new owner, otherwise the node in the peer's path heap for the path.

Definition at line 942 of file gnunet-service-cadet_peer.c.

{
  GNUNET_CONTAINER_HeapCostType desirability;
  struct CadetPeerPath *root;
  GNUNET_CONTAINER_HeapCostType root_desirability;
  struct GNUNET_CONTAINER_HeapNode *hn;
 
  GNUNET_assert (off == GCPP_get_length (path) - 1);
  GNUNET_assert (cp == GCPP_get_peer_at_offset (path,
                                                off));
  if (NULL == cp->path_heap)
  {
    /* #GCP_drop_owned_paths() was already called, we cannot take new ones! */
    GNUNET_assert (GNUNET_NO == force);
    return NULL;
  }
  desirability = GCPP_get_desirability (path);
  if (GNUNET_NO == force)
  {
    /* FIXME: desirability is not yet initialized; tricky! */
    if (GNUNET_NO ==
        GNUNET_CONTAINER_heap_peek2 (cp->path_heap,
                                     (void **) &root,
                                     &root_desirability))
    {
      root = NULL;
      root_desirability = 0;
    }
 
    if ((DESIRED_CONNECTIONS_PER_TUNNEL > cp->num_paths) &&
        (desirability < root_desirability))
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Decided to not attach path %s to peer %s due to undesirability\n",
           GCPP_2s (path),
           GCP_2s (cp));
      return NULL;
    }
  }
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Attaching path %s to peer %s (%s)\n",
       GCPP_2s (path),
       GCP_2s (cp),
       (GNUNET_NO == force) ? "desirable" : "forced");
 
  /* Yes, we'd like to add this path, add to our heap */
  hn = GNUNET_CONTAINER_heap_insert (cp->path_heap,
                                     path,
                                     desirability);
 
  /* Consider maybe dropping other paths because of the new one */
  if ((GNUNET_CONTAINER_heap_get_size (cp->path_heap) >=
       2 * DESIRED_CONNECTIONS_PER_TUNNEL) &&
      (NULL != cp->heap_cleanup_task))
    cp->heap_cleanup_task = GNUNET_SCHEDULER_add_now (&path_heap_cleanup,
                                                      cp);
  return hn;
}

References DESIRED_CONNECTIONS_PER_TUNNEL, GCP_2s(), GCPP_2s(), GCPP_get_desirability(), GCPP_get_length(), GCPP_get_peer_at_offset(), GNUNET_assert, GNUNET_CONTAINER_heap_get_size(), GNUNET_CONTAINER_heap_insert(), GNUNET_CONTAINER_heap_peek2(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_NO, GNUNET_SCHEDULER_add_now(), CadetPeer::heap_cleanup_task, LOG, CadetPeer::num_paths, CadetPeer::path_heap, and path_heap_cleanup().

Referenced by attach_path(), extend_path(), and GCPP_get_path_from_route().

Here is the call graph for this function:

Here is the caller graph for this function:

GCP_detach_path()

void GCP_detach_path	(	struct CadetPeer *	cp,
		struct CadetPeerPath *	path,
		struct GNUNET_CONTAINER_HeapNode *	hn
	)

This peer can no longer own path as the path has been extended and a peer further down the line is now the new owner.

Parameters

cp	old owner of the path
path	path where the ownership is lost
hn	note in cp's path heap that must be deleted

Definition at line 1016 of file gnunet-service-cadet_peer.c.

{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Detaching path %s from peer %s\n",
       GCPP_2s (path),
       GCP_2s (cp));
  GNUNET_assert (path ==
                 GNUNET_CONTAINER_heap_remove_node (hn));
}

References GCP_2s(), GCPP_2s(), GNUNET_assert, GNUNET_CONTAINER_heap_remove_node(), GNUNET_ERROR_TYPE_DEBUG, and LOG.

Referenced by extend_path().

Here is the call graph for this function:

Here is the caller graph for this function:

GCP_add_connection()

void GCP_add_connection	(	struct CadetPeer *	cp,
		struct CadetConnection *	cc
	)

Add a connection to this cp.

Parameters

cp	peer via which the connection goes
cc	the connection to add

Definition at line 1036 of file gnunet-service-cadet_peer.c.

{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Adding %s to peer %s\n",
       GCC_2s (cc),
       GCP_2s (cp));
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multishortmap_put (cp->connections,
                                                     &GCC_get_id (
                                                       cc)->connection_of_tunnel
                                                     ,
                                                     cc,
                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  if (NULL != cp->destroy_task)
  {
    GNUNET_SCHEDULER_cancel (cp->destroy_task);
    cp->destroy_task = NULL;
  }
}

References CadetPeer::connections, CadetPeer::destroy_task, GCC_2s(), GCC_get_id(), GCP_2s(), GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multishortmap_put(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_OK, GNUNET_SCHEDULER_cancel(), and LOG.

Referenced by connection_create().

Here is the call graph for this function:

Here is the caller graph for this function:

GCP_remove_connection()

void GCP_remove_connection	(	struct CadetPeer *	cp,
		struct CadetConnection *	cc
	)

Remove a connection that went via this cp.

Parameters

cp	peer via which the connection went
cc	the connection to remove

Definition at line 1065 of file gnunet-service-cadet_peer.c.

{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Removing connection %s from peer %s\n",
       GCC_2s (cc),
       GCP_2s (cp));
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multishortmap_remove (cp->connections,
                                                        &GCC_get_id (
                                                          cc)->
                                                        connection_of_tunnel,
                                                        cc));
  consider_peer_destroy (cp);
}

References CadetPeer::connections, consider_peer_destroy(), GCC_2s(), GCC_get_id(), GCP_2s(), GNUNET_assert, GNUNET_CONTAINER_multishortmap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_YES, and LOG.

Referenced by GCC_destroy().

Here is the call graph for this function:

Here is the caller graph for this function:

GCP_get()

struct CadetPeer * GCP_get	(	const struct GNUNET_PeerIdentity *	peer_id,
		int	create
	)

Retrieve the CadetPeer structure associated with the peer.

Optionally create one and insert it in the appropriate structures if the peer is not known yet.

Parameters

peer_id	Full identity of the peer.
create	GNUNET_YES if a new peer should be created if unknown. GNUNET_NO to return NULL if peer is unknown.

Returns

Existing or newly created peer structure. NULL if unknown and not requested create

Definition at line 1094 of file gnunet-service-cadet_peer.c.

{
  struct CadetPeer *cp;
 
  cp = GNUNET_CONTAINER_multipeermap_get (peers,
                                          peer_id);
  if (NULL != cp)
    return cp;
  if (GNUNET_NO == create)
    return NULL;
  cp = GNUNET_new (struct CadetPeer);
  cp->pid = *peer_id;
  cp->connections = GNUNET_CONTAINER_multishortmap_create (32,
                                                           GNUNET_YES);
  cp->path_heap = GNUNET_CONTAINER_heap_create (
    GNUNET_CONTAINER_HEAP_ORDER_MIN);
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multipeermap_put (peers,
                                                    &cp->pid,
                                                    cp,
                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Creating peer %s\n",
       GCP_2s (cp));
  return cp;
}

References CadetPeer::connections, create, GCP_2s(), GNUNET_assert, GNUNET_CONTAINER_heap_create(), GNUNET_CONTAINER_HEAP_ORDER_MIN, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_get(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_CONTAINER_multishortmap_create(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_new, GNUNET_NO, GNUNET_YES, LOG, CadetPeer::path_heap, peer_id, peers, and CadetPeer::pid.

Referenced by core_connect_cb(), dht_get_id_handler(), GCCH_bind(), GCPP_get_path_from_route(), GCPP_try_path_from_dht(), got_hello(), handle_channel_create(), handle_connection_create(), and handle_show_path().

Here is the call graph for this function:

Here is the caller graph for this function:

GCP_get_id()

const struct GNUNET_PeerIdentity * GCP_get_id

(

struct CadetPeer *

cp

)

Obtain the peer identity for a struct CadetPeer.

Parameters

cp	our peer handle

Returns

the peer identity

Definition at line 1130 of file gnunet-service-cadet_peer.c.

{
  return &cp->pid;
}

References CadetPeer::pid.

Referenced by destroy_route(), dir_ready_cb(), GCCH_2s(), GCCH_channel_local_new(), GCPP_2s(), GCT_2s(), GCT_handle_kx(), GCT_handle_kx_auth(), get_next_free_ctn(), GSC_bind(), path_info_iterator(), route_message(), send_create(), and send_kx().

Here is the caller graph for this function:

GCP_iterate_all()

void GCP_iterate_all	(	GNUNET_CONTAINER_PeerMapIterator	iter,
		void *	cls
	)

Iterate over all known peers.

Parameters

iter	Iterator.
cls	Closure for iter.

Definition at line 1143 of file gnunet-service-cadet_peer.c.

{
  GNUNET_CONTAINER_multipeermap_iterate (peers,
                                         iter,
                                         cls);
}

References GNUNET_CONTAINER_multipeermap_iterate(), and peers.

Referenced by handle_get_peers(), handle_info_tunnels(), and shutdown_rest().

Here is the call graph for this function:

Here is the caller graph for this function:

GCP_count_paths()

unsigned int GCP_count_paths

(

const struct CadetPeer *

cp

)

Count the number of known paths toward the peer.

Parameters

cp	Peer to get path info.

Returns

Number of known paths.

Definition at line 1159 of file gnunet-service-cadet_peer.c.

{
  return cp->num_paths;
}

References CadetPeer::num_paths.

Referenced by get_all_peers_iterator().

Here is the caller graph for this function:

GCP_iterate_paths()

unsigned int GCP_iterate_paths	(	struct CadetPeer *	cp,
		GCP_PathIterator	callback,
		void *	callback_cls
	)

Iterate over the paths to a peer.

Parameters

cp	Peer to get path info.
callback	Function to call for every path.
callback_cls	Closure for callback.

Returns

Number of iterated paths.

Definition at line 1174 of file gnunet-service-cadet_peer.c.

{
  unsigned int ret = 0;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Iterating over paths to peer %s%s\n",
       GCP_2s (cp),
       (NULL == cp->core_mq) ? "" : " including direct link");
  if (NULL != cp->core_mq)
  {
    /* FIXME: this branch seems to duplicate the
       i=0 case below (direct link). Leave out!??? -CG */
    struct CadetPeerPath *path;
 
    path = GCPP_get_path_from_route (1,
                                     &cp->pid);
    ret++;
    if (GNUNET_NO ==
        callback (callback_cls,
                  path,
                  0))
      return ret;
  }
  for (unsigned int i = 0; i < cp->path_dll_length; i++)
  {
    for (struct CadetPeerPathEntry *pe = cp->path_heads[i];
         NULL != pe;
         pe = pe->next)
    {
      ret++;
      if (GNUNET_NO ==
          callback (callback_cls,
                    pe->path,
                    i))
        return ret;
    }
  }
  return ret;
}

References CadetPeer::core_mq, GCP_2s(), GCPP_get_path_from_route(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_NO, LOG, CadetPeer::path_dll_length, CadetPeer::path_heads, CadetPeer::pid, and ret.

Referenced by maintain_connections_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GCP_iterate_indirect_paths()

unsigned int GCP_iterate_indirect_paths	(	struct CadetPeer *	cp,
		GCP_PathIterator	callback,
		void *	callback_cls
	)

Iterate over the paths to a peer without direct link.

Parameters

cp	Peer to get path info.
callback	Function to call for every path.
callback_cls	Closure for callback.

Returns

Number of iterated paths.

Definition at line 1226 of file gnunet-service-cadet_peer.c.

{
  unsigned int ret = 0;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Iterating over paths to peer %s without direct link\n",
       GCP_2s (cp));
  for (unsigned int i = 1; i < cp->path_dll_length; i++)
  {
    for (struct CadetPeerPathEntry *pe = cp->path_heads[i];
         NULL != pe;
         pe = pe->next)
    {
      ret++;
      if (GNUNET_NO ==
          callback (callback_cls,
                    pe->path,
                    i))
        return ret;
    }
  }
  return ret;
}

References GCP_2s(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_NO, LOG, CadetPeer::path_dll_length, CadetPeer::path_heads, and ret.

Referenced by handle_show_path().

Here is the call graph for this function:

Here is the caller graph for this function:

GCP_iterate_paths_at()

unsigned int GCP_iterate_paths_at	(	struct CadetPeer *	cp,
		unsigned int	dist,
		GCP_PathIterator	callback,
		void *	callback_cls
	)

Iterate over the paths to peer where peer is at distance dist from us.

Parameters

cp	Peer to get path info.
dist	desired distance of peer to us on the path
callback	Function to call for every path.
callback_cls	Closure for callback.

Returns

Number of iterated paths.

Definition at line 1254 of file gnunet-service-cadet_peer.c.

{
  unsigned int ret = 0;
 
  if (dist >= cp->path_dll_length)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Asked to look for paths at distance %u, but maximum for me is < %u\n",
         dist,
         cp->path_dll_length);
    return 0;
  }
  for (struct CadetPeerPathEntry *pe = cp->path_heads[dist];
       NULL != pe;
       pe = pe->next)
  {
    if (GNUNET_NO ==
        callback (callback_cls,
                  pe->path,
                  dist))
      return ret;
    ret++;
  }
  return ret;
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_NO, LOG, CadetPeer::path_dll_length, CadetPeer::path_heads, and ret.

Referenced by GCPP_get_path_from_route(), and GCPP_try_path_from_dht().

Here is the caller graph for this function:

GCP_get_tunnel()

struct CadetTunnel * GCP_get_tunnel	(	struct CadetPeer *	cp,
		int	create
	)

Get the tunnel towards a peer.

Parameters

cp	Peer to get from.
create	GNUNET_YES to create a tunnel if we do not have one

Returns

Tunnel towards peer.

Definition at line 1292 of file gnunet-service-cadet_peer.c.

{
  if (NULL == cp)
    return NULL;
  if ((NULL != cp->t) ||
      (GNUNET_NO == create))
    return cp->t;
  cp->t = GCT_create_tunnel (cp);
  consider_peer_activate (cp);
  return cp->t;
}

References consider_peer_activate(), create, GCT_create_tunnel(), GNUNET_NO, and CadetPeer::t.

Referenced by destroy_tunnels_now(), GCCH_channel_local_new(), get_all_peers_iterator(), get_all_tunnels_iterator(), handle_connection_create(), and send_create().

Here is the call graph for this function:

Here is the caller graph for this function:

GCP_set_hello()

void GCP_set_hello	(	struct CadetPeer *	cp,
		const struct GNUNET_MessageHeader *	hello
	)

We got a HELLO for a cp, remember it, and possibly trigger adequate actions (like trying to connect).

Parameters

cp	the peer we got a HELLO for
hello	the HELLO to remember

Definition at line 1307 of file gnunet-service-cadet_peer.c.

{
  struct GNUNET_BANDWIDTH_Value32NBO bw;
  uint16_t size = ntohs (hello->size);
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Got %u byte HELLO for peer %s\n",
       (unsigned int) size,
       GCP_2s (cp));
  if (NULL != cp->hello)
  {
    struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
 
    struct GNUNET_TIME_Absolute new_hello_exp =
      GNUNET_HELLO_get_expiration_time_from_msg (hello);
    struct GNUNET_TIME_Absolute old_hello_exp =
      GNUNET_HELLO_get_expiration_time_from_msg (cp->hello);
 
    if (GNUNET_TIME_absolute_cmp (new_hello_exp, >, now) &&
        GNUNET_TIME_absolute_cmp (new_hello_exp, >, old_hello_exp))
    {
      GNUNET_free (cp->hello);
      cp->hello = GNUNET_malloc (size);
      GNUNET_memcpy (cp->hello, hello, size);
    }
    else
    {
      return;
    }
  }
  else
  {
    cp->hello = GNUNET_memdup (hello,
                               size);
  }
  if (NULL != cp->ash)
    GNUNET_TRANSPORT_application_suggest_cancel (cp->ash);
  bw.value__ = 0;
  cp->ash
    = GNUNET_TRANSPORT_application_suggest (transport,
                                            &cp->pid,
                                            GNUNET_MQ_PRIO_BEST_EFFORT,
                                            bw);
  /* New HELLO means cp's destruction time may change... */
  consider_peer_destroy (cp);
}

References CadetPeer::ash, consider_peer_destroy(), GCP_2s(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_HELLO_get_expiration_time_from_msg(), GNUNET_malloc, GNUNET_memcpy, GNUNET_memdup, GNUNET_MQ_PRIO_BEST_EFFORT, GNUNET_TIME_absolute_cmp, GNUNET_TIME_absolute_get(), GNUNET_TRANSPORT_application_suggest(), GNUNET_TRANSPORT_application_suggest_cancel(), CadetPeer::hello, LOG, CadetPeer::pid, GNUNET_MessageHeader::size, size, transport, and GNUNET_BANDWIDTH_Value32NBO::value__.

Referenced by dht_get_id_handler(), and got_hello().

Here is the call graph for this function:

Here is the caller graph for this function:

GCP_drop_tunnel()

void GCP_drop_tunnel	(	struct CadetPeer *	cp,
		struct CadetTunnel *	t
	)

The tunnel to the given peer no longer exists, remove it from our data structures, and possibly clean up the peer itself.

Parameters

cp	the peer affected
t	the dead tunnel

Definition at line 1364 of file gnunet-service-cadet_peer.c.

{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Dropping tunnel %s to peer %s\n",
       GCT_2s (t),
       GCP_2s (cp));
  GNUNET_assert (cp->t == t);
  cp->t = NULL;
  consider_peer_destroy (cp);
}

References consider_peer_destroy(), GCP_2s(), GCT_2s(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, LOG, t, and CadetPeer::t.

Referenced by destroy_tunnel().

Here is the call graph for this function:

Here is the caller graph for this function:

GCP_has_core_connection()

int GCP_has_core_connection

(

struct CadetPeer *

cp

)

Test if cp has a core-level connection.

Parameters

cp	peer to test

Returns

GNUNET_YES if cp has a core-level connection

Definition at line 1384 of file gnunet-service-cadet_peer.c.

{
  return (NULL != cp->core_mq) ? GNUNET_YES : GNUNET_NO;
}

References CadetPeer::core_mq, GNUNET_NO, and GNUNET_YES.

Referenced by handle_connection_create().

Here is the caller graph for this function:

GCP_request_mq()

struct GCP_MessageQueueManager * GCP_request_mq	(	struct CadetPeer *	cp,
		GCP_MessageQueueNotificationCallback	cb,
		void *	cb_cls
	)

Start message queue change notifications.

Parameters

cp	peer to notify for
cb	function to call if mq becomes available or unavailable
cb_cls	closure for cb

Returns

handle to cancel request

Definition at line 1399 of file gnunet-service-cadet_peer.c.

{
  struct GCP_MessageQueueManager *mqm;
 
  mqm = GNUNET_new (struct GCP_MessageQueueManager);
  mqm->cb = cb;
  mqm->cb_cls = cb_cls;
  mqm->cp = cp;
  GNUNET_CONTAINER_DLL_insert (cp->mqm_head,
                               cp->mqm_tail,
                               mqm);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Creating MQM %p for peer %s\n",
       mqm,
       GCP_2s (cp));
  if (NULL != cp->core_mq)
    cb (cb_cls,
        GNUNET_YES);
  return mqm;
}

References GCP_MessageQueueManager::cb, GCP_MessageQueueManager::cb_cls, CadetPeer::core_mq, GCP_MessageQueueManager::cp, GCP_2s(), GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_new, GNUNET_YES, LOG, CadetPeer::mqm_head, and CadetPeer::mqm_tail.

Referenced by connection_create(), and dir_init().

Here is the call graph for this function:

Here is the caller graph for this function:

GCP_request_mq_cancel()

void GCP_request_mq_cancel	(	struct GCP_MessageQueueManager *	mqm,
		struct GNUNET_MQ_Envelope *	last_env
	)

Stops message queue change notifications.

Stops message queue change notifications and sends a last message.

Parameters

mqm	handle matching request to cancel
last_env	final message to transmit, or NULL

Definition at line 1430 of file gnunet-service-cadet_peer.c.

{
  struct CadetPeer *cp = mqm->cp;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Destroying MQM %p for peer %s%s\n",
       mqm,
       GCP_2s (cp),
       (NULL == last_env) ? "" : " with last ditch transmission");
  if (NULL != mqm->env)
    GNUNET_MQ_discard (mqm->env);
  if (NULL != last_env)
  {
    if (NULL != cp->core_mq)
    {
      GNUNET_MQ_notify_sent (last_env,
                             &mqm_send_done,
                             cp);
      GNUNET_MQ_send (cp->core_mq,
                      last_env);
    }
    else
    {
      GNUNET_MQ_discard (last_env);
    }
  }
  if (cp->mqm_ready_ptr == mqm)
    cp->mqm_ready_ptr = mqm->next;
  GNUNET_CONTAINER_DLL_remove (cp->mqm_head,
                               cp->mqm_tail,
                               mqm);
  GNUNET_free (mqm);
}

References CadetPeer::core_mq, GCP_MessageQueueManager::cp, GCP_MessageQueueManager::env, GCP_2s(), GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_MQ_discard(), GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), LOG, CadetPeer::mqm_head, CadetPeer::mqm_ready_ptr, mqm_send_done(), CadetPeer::mqm_tail, and GCP_MessageQueueManager::next.

Referenced by destroy_direction(), GCC_destroy(), GCC_destroy_without_tunnel(), and send_broken().

Here is the call graph for this function:

Here is the caller graph for this function:

GCP_send_ooo()

void GCP_send_ooo	(	struct CadetPeer *	cp,
		struct GNUNET_MQ_Envelope *	env
	)

Send the message in env to cp, overriding queueing logic.

This function should only be used to send error messages outside of flow and congestion control, similar to ICMP. Note that the envelope may be silently discarded as well.

Parameters

cp	peer to send the message to
env	envelope with the message to send

Definition at line 1476 of file gnunet-service-cadet_peer.c.

{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Sending message to %s out of management\n",
       GCP_2s (cp));
  if (NULL == cp->core_mq)
  {
    GNUNET_MQ_discard (env);
    return;
  }
  if (GNUNET_MQ_get_length (cp->core_mq) > MAX_OOO_QUEUE_SIZE)
  {
    GNUNET_MQ_discard (env);
    return;
  }
  GNUNET_MQ_notify_sent (env,
                         &mqm_send_done,
                         cp);
  GNUNET_MQ_send (cp->core_mq,
                  env);
}

References CadetPeer::core_mq, env, GCP_2s(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_MQ_discard(), GNUNET_MQ_get_length(), GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), LOG, MAX_OOO_QUEUE_SIZE, and mqm_send_done().

Referenced by route_message(), and send_broken_without_mqm().

Here is the call graph for this function:

Here is the caller graph for this function:

GCP_check_and_update_monotime()

int GCP_check_and_update_monotime	(	struct CadetPeer *	peer,
		struct GNUNET_TIME_AbsoluteNBO	monotime
	)

Checking if a monotime value is newer than the last monotime value received from a peer.

If the time value is newer it will be stored at the peer.

Parameters

peer	The peer we received a new time value from.
monotime	Time value we check against the last time value we received from a peer.

Returns

GNUNET_YES if monotime is newer than the last received time value, GNUNET_NO if monotime is not newer.

Definition at line 1508 of file gnunet-service-cadet_peer.c.

{
 
  struct GNUNET_TIME_Absolute mt = GNUNET_TIME_absolute_ntoh (monotime);
 
  if (mt.abs_value_us > *(&peer->last_connection_create.abs_value_us))
  {
    peer->last_connection_create = mt;
    return GNUNET_YES;
  }
  return GNUNET_NO;
}

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_NO, GNUNET_TIME_absolute_ntoh(), GNUNET_YES, and CadetPeer::last_connection_create.

Referenced by handle_connection_create().

Here is the call graph for this function:

Here is the caller graph for this function:

GCP_check_monotime_sig()

int GCP_check_monotime_sig	(	struct CadetPeer *	peer,
		const struct GNUNET_CADET_ConnectionCreateMessage *	msg
	)

Checking the signature for a monotime of a GNUNET_CADET_ConnectionCreateMessage.

Parameters

peer	The peer that signed the monotime value.
msg	The GNUNET_CADET_ConnectionCreateMessage with the monotime value.

Returns

GNUNET_OK if the signature is good, GNUNET_SYSERR if not.

Definition at line 1531 of file gnunet-service-cadet_peer.c.

{
  struct CadetConnectionCreatePS cp = { .purpose.purpose = htonl (
                                          GNUNET_SIGNATURE_PURPOSE_CADET_CONNECTION_INITIATOR),
                                        .purpose.size = htonl (sizeof(cp)),
                                        .monotonic_time = msg->monotime};
 
  if (GNUNET_OK !=
      GNUNET_CRYPTO_eddsa_verify (
        GNUNET_SIGNATURE_PURPOSE_CADET_CONNECTION_INITIATOR,
        &cp,
        &msg->monotime_sig,
        &peer->pid.public_key))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_CRYPTO_eddsa_verify, GNUNET_OK, GNUNET_SIGNATURE_PURPOSE_CADET_CONNECTION_INITIATOR, GNUNET_SYSERR, msg, CadetPeer::pid, GNUNET_PeerIdentity::public_key, GNUNET_CRYPTO_EccSignaturePurpose::purpose, and CadetConnectionCreatePS::purpose.

Referenced by handle_connection_create().

Here is the caller graph for this function: