gnunet-service-cadet_peer.h File Reference

Information we track per peer. More...

#include "gnunet-service-cadet.h"
#include "gnunet_hello_lib.h"

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

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Typedefs
typedef int(*	GCP_PathIterator) (void *cls, struct CadetPeerPath *path, unsigned int off)
	Peer path iterator. More...
typedef void(*	GCP_MessageQueueNotificationCallback) (void *cls, int available)
	Function to call with updated message queue object. More...

Functions
const char *	GCP_2s (const struct CadetPeer *peer)
	Get the static string for a peer ID. More...
struct CadetPeer *	GCP_get (const struct GNUNET_PeerIdentity *peer_id, int create)
	Retrieve the CadetPeer structure associated with the peer. More...
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. More...
const struct GNUNET_PeerIdentity *	GCP_get_id (struct CadetPeer *cp)
	Obtain the peer identity for a struct CadetPeer. More...
void	GCP_iterate_all (GNUNET_CONTAINER_PeerMapIterator iter, void *cls)
	Iterate over all known peers. More...
unsigned int	GCP_count_paths (const struct CadetPeer *cp)
	Count the number of known paths toward the peer. More...
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. More...
unsigned int	GCP_iterate_paths (struct CadetPeer *cp, GCP_PathIterator callback, void *callback_cls)
	Iterate over the paths to a peer. More...
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. More...
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. More...
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. More...
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. More...
struct CadetTunnel *	GCP_get_tunnel (struct CadetPeer *cp, int create)
	Get the tunnel towards a peer. More...
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. More...
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. More...
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. More...
void	GCP_add_connection (struct CadetPeer *cp, struct CadetConnection *cc)
	Add a connection to this cp. More...
void	GCP_remove_connection (struct CadetPeer *cp, struct CadetConnection *cc)
	Remove a connection that went via this cp. More...
void	GCP_set_hello (struct CadetPeer *cp, const struct GNUNET_HELLO_Message *hello)
	We got a HELLO for a cp, remember it, and possibly trigger adequate actions (like trying to connect). More...
void	GCP_destroy_all_peers (void)
	Clean up all entries about all peers. More...
struct GCP_MessageQueueManager *	GCP_request_mq (struct CadetPeer *cp, GCP_MessageQueueNotificationCallback cb, void *cb_cls)
	Start message queue change notifications. More...
int	GCP_has_core_connection (struct CadetPeer *cp)
	Test if cp has a core-level connection. More...
void	GCP_send (struct GCP_MessageQueueManager *mqm, struct GNUNET_MQ_Envelope *env)
	Send the message in env via a mqm. More...
void	GCP_send_ooo (struct CadetPeer *cp, struct GNUNET_MQ_Envelope *env)
	Send the message in env to cp, overriding queueing logic. More...
void	GCP_request_mq_cancel (struct GCP_MessageQueueManager *mqm, struct GNUNET_MQ_Envelope *last_env)
	Stops message queue change notifications and sends a last message. More...
void	GCP_set_mq (struct CadetPeer *cp, struct GNUNET_MQ_Handle *mq)
	Set the message queue to mq for peer cp and notify watchers. More...
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. More...
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. More...

Detailed Description

Information we track per peer.

Author

Bartlomiej Polot

Christian Grothoff

Definition in file gnunet-service-cadet_peer.h.

Typedef Documentation

GCP_PathIterator

typedef int(* GCP_PathIterator) (void *cls, struct CadetPeerPath *path, unsigned int off)

Peer path iterator.

Parameters

cls	Closure.
path	Path itself
off	offset of the target peer in path

Returns

GNUNET_YES if should keep iterating. GNUNET_NO otherwise.

Definition at line 131 of file gnunet-service-cadet_peer.h.

GCP_MessageQueueNotificationCallback

typedef void(* GCP_MessageQueueNotificationCallback) (void *cls, int available)

Function to call with updated message queue object.

Parameters

cls	closure
available	GNUNET_YES if sending is now possible, GNUNET_NO if sending is no longer possible GNUNET_SYSERR if sending is no longer possible and the last envelope was discarded

Definition at line 328 of file gnunet-service-cadet_peer.h.

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 236 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 buf, 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(), 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(), 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()

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 1099 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_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 258 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, CadetPeerPathEntry::next, 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:

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 1135 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_add_channel(), GCT_handle_kx(), 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 1148 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 1164 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_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 799 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_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 1179 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, CadetPeerPathEntry::next, 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 1231 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, CadetPeerPathEntry::next, 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 1259 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, CadetPeerPathEntry::next, 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_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 882 of file gnunet-service-cadet_peer.c.

{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Removing knowledge about peer %s beging 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:

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 822 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, len, 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_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 1297 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_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 1371 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, CadetPeer::t, and t.

Referenced by destroy_tunnel().

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 948 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 1022 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 1042 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 1070 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_set_hello()

void GCP_set_hello	(	struct CadetPeer *	cp,
		const struct GNUNET_HELLO_Message *	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 1327 of file gnunet-service-cadet_peer.c.

{
  struct GNUNET_HELLO_Message *mrg;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Got %u byte HELLO for peer %s\n",
       (unsigned int) GNUNET_HELLO_size (hello),
       GCP_2s (cp));
  if (NULL != cp->hello_offer)
  {
    GNUNET_TRANSPORT_offer_hello_cancel (cp->hello_offer);
    cp->hello_offer = NULL;
  }
  if (NULL != cp->hello)
  {
    mrg = GNUNET_HELLO_merge (hello,
                              cp->hello);
    GNUNET_free (cp->hello);
    cp->hello = mrg;
  }
  else
  {
    cp->hello = GNUNET_memdup (hello,
                               GNUNET_HELLO_size (hello));
  }
  cp->hello_offer
    = GNUNET_TRANSPORT_offer_hello (cfg,
                                    GNUNET_HELLO_get_header (cp->hello),
                                    &hello_offer_done,
                                    cp);
  /* New HELLO means cp's destruction time may change... */
  consider_peer_destroy (cp);
}

References cfg, consider_peer_destroy(), GCP_2s(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_HELLO_get_header(), GNUNET_HELLO_merge(), GNUNET_HELLO_size(), GNUNET_memdup, GNUNET_TRANSPORT_offer_hello(), GNUNET_TRANSPORT_offer_hello_cancel(), CadetPeer::hello, CadetPeer::hello_offer, hello_offer_done(), and LOG.

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_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 782 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_request_mq()

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

Start message queue change notifications.

Will create a new slot to manage the message queue to the given cp.

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

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 1406 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_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 1391 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_send()

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

Send the message in env via a mqm.

Must only be called at most once after the respective GCP_MessageQueueNotificationCallback was called with available set to GNUNET_YES, and not after the callback was called with available set to GNUNET_NO or GNUNET_SYSERR.

Parameters

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

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 724 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:

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 1483 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_request_mq_cancel()

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

Stops message queue change notifications and sends a last message.

In practice, this is implemented by sending that last_env message immediately (if any), ignoring queue order.

Parameters

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

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 1437 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_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 518 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:

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 1538 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, peer, CadetConnectionCreatePS::purpose, and GNUNET_CRYPTO_EccSignaturePurpose::purpose.

Referenced by handle_connection_create().

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 1515 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 peer.

Referenced by handle_connection_create().

Here is the call graph for this function:

Here is the caller graph for this function: