gnunet-daemon-topology.c File Reference

code for maintaining the overlay topology More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_hello_uri_lib.h"
#include "gnunet_constants.h"
#include "gnunet_core_service.h"
#include "gnunet_protocols.h"
#include "gnunet_peerstore_service.h"
#include "gnunet_statistics_service.h"
#include "gnunet_transport_application_service.h"
#include <assert.h>

Include dependency graph for gnunet-daemon-topology.c:

Go to the source code of this file.

Data Structures
struct	Peer
	Record for neighbours and blacklisted peers. More...
struct	StoreHelloEntry
	Context for a add hello uri request. More...
struct	FindAdvHelloContext
	Closure for find_advertisable_hello(). More...

Macros
#define	HELLO_ADVERTISEMENT_MIN_FREQUENCY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
	At what frequency do we sent HELLOs to a peer? More...
#define	HELLO_ADVERTISEMENT_MIN_REPEAT_FREQUENCY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4)
	After what time period do we expire the HELLO Bloom filter? More...

Functions
static int	free_peer (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
	Free all resources associated with the given peer. More...
static void	attempt_connect (struct Peer *pos)
	Recalculate how much we want to be connected to the specified peer and let ATS know about the result. More...
static struct Peer *	make_peer (const struct GNUNET_PeerIdentity *peer, const struct GNUNET_MessageHeader *hello)
	Create a new entry in the peer list. More...
static void	setup_filter (struct Peer *peer)
	Setup bloom filter for the given peer entry. More...
static int	find_advertisable_hello (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
	Find a peer that would be reasonable for advertising. More...
static void	schedule_next_hello (void *cls)
	Calculate when we would like to send the next HELLO to this peer and ask for it. More...
static int	reschedule_hellos (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
	Cancel existing requests for sending HELLOs to this peer and recalculate when we should send HELLOs to it based on our current state (something changed!). More...
static void *	connect_notify (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
	Method called whenever a peer connects. More...
static int	try_add_peers (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
	Try to add more peers to our connection set. More...
static void	add_peer_task (void *cls)
	Add peers and schedule connection attempt. More...
static void	disconnect_notify (void *cls, const struct GNUNET_PeerIdentity *peer, void *internal_cls)
	Method called whenever a peer disconnects. More...
static void	address_iterator (void *cls, const struct GNUNET_PeerIdentity *pid, const char *uri)
	Iterator called on each address. More...
static void	consider_for_advertising (const struct GNUNET_MessageHeader *hello)
	We've gotten a HELLO from another peer. More...
static void	error_cb (void *cls)
static void	sync_cb (void *cls)
static void	process_peer (void *cls, const struct GNUNET_PEERSTORE_Record *record, const char *err_msg)
	PEERSTORE calls this function to let us know about a possible peer that we might want to connect to. More...
static void	start_notify (void *cls)
static void	core_init (void *cls, const struct GNUNET_PeerIdentity *my_id)
	Function called after GNUNET_CORE_connect has succeeded (or failed for good). More...
static int	check_hello (void *cls, const struct GNUNET_MessageHeader *message)
	This function is called whenever an encrypted HELLO message is received. More...
static void	shc_cont (void *cls, int success)
static void	handle_hello (void *cls, const struct GNUNET_MessageHeader *message)
	This function is called whenever an encrypted HELLO message is received. More...
static void	cleaning_task (void *cls)
	Last task run during shutdown. More...
static void	run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
	Main function that will be run. More...
int	main (int argc, char *const *argv)
	The main function for the topology daemon. More...

Variables
struct GNUNET_SCHEDULER_Task *	peerstore_notify_task
	The task to delayed start the notification process intially. More...
static struct GNUNET_PEERSTORE_Monitor *	peerstore_notify
	Our peerstore notification context. More...
static const struct GNUNET_CONFIGURATION_Handle *	cfg
	Our configuration. More...
static struct GNUNET_CORE_Handle *	handle
	Handle to the CORE service. More...
static struct GNUNET_PEERSTORE_Handle *	ps
	Handle to the PEERSTORE service. More...
struct GNUNET_TRANSPORT_ApplicationHandle *	transport
	Handle to Transport service. More...
static struct GNUNET_PeerIdentity	my_identity
	Identity of this peer. More...
static struct GNUNET_CRYPTO_EddsaPrivateKey *	my_private_key
	Our private key. More...
static struct GNUNET_CONTAINER_MultiPeerMap *	peers
	All of our current neighbours and all peers for which we have HELLOs. More...
static struct GNUNET_STATISTICS_Handle *	stats
	Handle for reporting statistics. More...
static struct GNUNET_SCHEDULER_Task *	add_task
	Task scheduled to asynchronously reconsider adding/removing peer connectivity suggestions. More...
static unsigned int	connection_count
	Number of peers that we are currently connected to. More...
static unsigned int	target_connection_count
	Target number of connections. More...
static struct StoreHelloEntry *	she_head
	Head of the linkd list to store the store context for hellos. More...
static struct StoreHelloEntry *	she_tail
	Tail of the linkd list to store the store context for hellos. More...

Detailed Description

code for maintaining the overlay topology

Author

Christian Grothoff

This daemon combines one Function:

• gossping HELLOs

Definition in file gnunet-daemon-topology.c.

Macro Definition Documentation

HELLO_ADVERTISEMENT_MIN_FREQUENCY

#define HELLO_ADVERTISEMENT_MIN_FREQUENCY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)

At what frequency do we sent HELLOs to a peer?

Definition at line 45 of file gnunet-daemon-topology.c.

HELLO_ADVERTISEMENT_MIN_REPEAT_FREQUENCY

#define HELLO_ADVERTISEMENT_MIN_REPEAT_FREQUENCY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4)

After what time period do we expire the HELLO Bloom filter?

Definition at line 51 of file gnunet-daemon-topology.c.

Function Documentation

free_peer()

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

static

Free all resources associated with the given peer.

Parameters

cls	closure (not used)
pid	identity of the peer
value	peer to free

Returns

GNUNET_YES (always: continue to iterate)

Definition at line 221 of file gnunet-daemon-topology.c.

{
  struct Peer *pos = value;
 
  GNUNET_break (NULL == pos->mq);
  GNUNET_break (GNUNET_OK ==
                GNUNET_CONTAINER_multipeermap_remove (peers, pid, pos));
  if (NULL != pos->hello_delay_task)
  {
    GNUNET_SCHEDULER_cancel (pos->hello_delay_task);
    pos->hello_delay_task = NULL;
  }
  if (NULL != pos->ash)
  {
    GNUNET_TRANSPORT_application_suggest_cancel (pos->ash);
    pos->ash = NULL;
  }
  if (NULL != pos->hello)
  {
    GNUNET_free (pos->hello);
    pos->hello = NULL;
  }
  if (NULL != pos->filter)
  {
    GNUNET_CONTAINER_bloomfilter_free (pos->filter);
    pos->filter = NULL;
  }
  GNUNET_free (pos);
  return GNUNET_YES;
}

References Peer::ash, Peer::filter, GNUNET_break, GNUNET_CONTAINER_bloomfilter_free(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_free, GNUNET_OK, GNUNET_SCHEDULER_cancel(), GNUNET_TRANSPORT_application_suggest_cancel(), GNUNET_YES, Peer::hello, Peer::hello_delay_task, Peer::mq, peers, pid, and value.

Referenced by cleaning_task(), and process_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

attempt_connect()

static void attempt_connect ( struct Peer *  pos )

static

Recalculate how much we want to be connected to the specified peer and let ATS know about the result.

Parameters

pos	peer to consider connecting to

Definition at line 260 of file gnunet-daemon-topology.c.

{
  uint32_t strength;
  struct GNUNET_BANDWIDTH_Value32NBO bw;
 
  if (0 == GNUNET_memcmp (&my_identity, &pos->pid))
    return; /* This is myself, nothing to do. */
  if (connection_count < target_connection_count)
    strength = 1;
  else
    strength = 0;
  if (NULL != pos->mq)
    strength *= 2; /* existing connections preferred */
  if (NULL != pos->ash)
  {
    GNUNET_TRANSPORT_application_suggest_cancel (pos->ash);
    pos->ash = NULL;
  }
  pos->strength = strength;
  if (0 != strength)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Asking to connect to `%s' with strength %u\n",
                GNUNET_i2s (&pos->pid),
                (unsigned int) strength);
    GNUNET_STATISTICS_update (stats,
                              gettext_noop ("# connect requests issued to ATS"),
                              1,
                              GNUNET_NO);
    // TODO Use strength somehow.
    bw.value__ = 0;
    pos->ash = GNUNET_TRANSPORT_application_suggest (transport,
                                                     &pos->pid,
                                                     GNUNET_MQ_PRIO_BEST_EFFORT,
                                                     bw);
  }
}

References Peer::ash, connection_count, gettext_noop, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_memcmp, GNUNET_MQ_PRIO_BEST_EFFORT, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_TRANSPORT_application_suggest(), GNUNET_TRANSPORT_application_suggest_cancel(), Peer::mq, my_identity, Peer::pid, stats, Peer::strength, target_connection_count, transport, and GNUNET_BANDWIDTH_Value32NBO::value__.

Referenced by process_peer(), and try_add_peers().

Here is the call graph for this function:

Here is the caller graph for this function:

make_peer()

static struct Peer * make_peer ( const struct GNUNET_PeerIdentity *  peer, const struct GNUNET_MessageHeader *  hello  )

static

Create a new entry in the peer list.

Parameters

peer	identity of the new entry
hello	hello message, can be NULL

Returns

the new entry

Definition at line 307 of file gnunet-daemon-topology.c.

{
  struct Peer *ret;
 
  ret = GNUNET_new (struct Peer);
  ret->pid = *peer;
  if (NULL != hello)
  {
    ret->hello = GNUNET_malloc (ntohs (hello->size));
    GNUNET_memcpy (ret->hello, hello, ntohs (hello->size));
  }
  GNUNET_break (GNUNET_OK ==
                GNUNET_CONTAINER_multipeermap_put (
                  peers,
                  peer,
                  ret,
                  GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  return ret;
}

References GNUNET_break, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_put(), GNUNET_malloc, GNUNET_memcpy, GNUNET_new, GNUNET_OK, Peer::hello, peers, ret, and GNUNET_MessageHeader::size.

Referenced by connect_notify(), consider_for_advertising(), and process_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

setup_filter()

static void setup_filter ( struct Peer *  peer )

static

Setup bloom filter for the given peer entry.

Parameters

peer	entry to initialize

Definition at line 335 of file gnunet-daemon-topology.c.

{
  struct GNUNET_HashCode hc;
 
  /* 2^{-5} chance of not sending a HELLO to a peer is
   * acceptably small (if the filter is 50% full);
   * 64 bytes of memory are small compared to the rest
   * of the data structure and would only really become
   * "useless" once a HELLO has been passed on to ~100
   * other peers, which is likely more than enough in
   * any case; hence 64, 5 as bloomfilter parameters. */peer->filter = GNUNET_CONTAINER_bloomfilter_init (NULL, 64, 5);
  peer->filter_expiration =
    GNUNET_TIME_relative_to_absolute (HELLO_ADVERTISEMENT_MIN_REPEAT_FREQUENCY);
  /* never send a peer its own HELLO */
  GNUNET_CRYPTO_hash (&peer->pid, sizeof(struct GNUNET_PeerIdentity), &hc);
  GNUNET_CONTAINER_bloomfilter_add (peer->filter, &hc);
}

References Peer::filter, Peer::filter_expiration, GNUNET_CONTAINER_bloomfilter_add(), GNUNET_CONTAINER_bloomfilter_init(), GNUNET_CRYPTO_hash(), GNUNET_TIME_relative_to_absolute(), HELLO_ADVERTISEMENT_MIN_REPEAT_FREQUENCY, and Peer::pid.

Referenced by consider_for_advertising(), and find_advertisable_hello().

Here is the call graph for this function:

Here is the caller graph for this function:

find_advertisable_hello()

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

static

Find a peer that would be reasonable for advertising.

Parameters

cls	closure
pid	identity of a peer
value	'struct Peer*' for the peer we are considering

Returns

GNUNET_YES (continue iteration)

Definition at line 387 of file gnunet-daemon-topology.c.

{
  struct FindAdvHelloContext *fah = cls;
  struct Peer *pos = value;
  struct GNUNET_TIME_Relative rst_time;
  struct GNUNET_HashCode hc;
  size_t hs;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "find_advertisable_hello\n");
  if (pos == fah->peer)
    return GNUNET_YES;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "find_advertisable_hello 2\n");
  if (pos->hello == NULL)
    return GNUNET_YES;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "find_advertisable_hello 3\n");
  rst_time = GNUNET_TIME_absolute_get_remaining (pos->filter_expiration);
  if (0 == rst_time.rel_value_us)
  {
    /* time to discard... */
    GNUNET_CONTAINER_bloomfilter_free (pos->filter);
    setup_filter (pos);
  }
  fah->next_adv = GNUNET_TIME_relative_min (rst_time, fah->next_adv);
  hs = pos->hello->size;
  if (hs > fah->max_size)
    return GNUNET_YES;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "find_advertisable_hello 4\n");
  GNUNET_CRYPTO_hash (&fah->peer->pid,
                      sizeof(struct GNUNET_PeerIdentity),
                      &hc);
  if (GNUNET_NO == GNUNET_CONTAINER_bloomfilter_test (pos->filter, &hc))
    fah->result = pos;
  return GNUNET_YES;
}

References Peer::filter, Peer::filter_expiration, GNUNET_CONTAINER_bloomfilter_free(), GNUNET_CONTAINER_bloomfilter_test(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_relative_min(), GNUNET_YES, Peer::hello, FindAdvHelloContext::max_size, FindAdvHelloContext::next_adv, FindAdvHelloContext::peer, Peer::pid, GNUNET_TIME_Relative::rel_value_us, FindAdvHelloContext::result, setup_filter(), GNUNET_MessageHeader::size, and value.

Referenced by schedule_next_hello().

Here is the call graph for this function:

Here is the caller graph for this function:

schedule_next_hello()

static void schedule_next_hello ( void *  cls )

static

Calculate when we would like to send the next HELLO to this peer and ask for it.

Parameters

cls	for which peer to schedule the HELLO

Definition at line 436 of file gnunet-daemon-topology.c.

{
  struct Peer *pl = cls;
  struct FindAdvHelloContext fah;
  struct GNUNET_MQ_Envelope *env;
  size_t want;
  struct GNUNET_TIME_Relative delay;
  struct GNUNET_HashCode hc;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "schedule_next_hello\n");
  pl->hello_delay_task = NULL;
  GNUNET_assert (NULL != pl->mq);
  /* find applicable HELLOs */
  fah.peer = pl;
  fah.result = NULL;
  fah.max_size = GNUNET_MAX_MESSAGE_SIZE - 1;
  fah.next_adv = GNUNET_TIME_UNIT_FOREVER_REL;
  GNUNET_CONTAINER_multipeermap_iterate (peers, &find_advertisable_hello, &fah);
  if (NULL == fah.result)
  {
    pl->hello_delay_task =
      GNUNET_SCHEDULER_add_delayed (fah.next_adv, &schedule_next_hello, pl);
 
    return;
  }
  want = ntohs (fah.result->hello->size);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending HELLO with %u bytes for peer %s\n",
              (unsigned int) want,
              GNUNET_i2s (&pl->pid));
  env = GNUNET_MQ_msg_copy (fah.result->hello);
  GNUNET_MQ_send (pl->mq, env);
 
  /* avoid sending this one again soon */
  GNUNET_CRYPTO_hash (&pl->pid, sizeof(struct GNUNET_PeerIdentity), &hc);
  GNUNET_CONTAINER_bloomfilter_add (fah.result->filter, &hc);
 
  GNUNET_STATISTICS_update (stats,
                            gettext_noop ("# HELLO messages gossipped"),
                            1,
                            GNUNET_NO);
  /* prepare to send the next one */
  pl->next_hello_allowed =
    GNUNET_TIME_relative_to_absolute (HELLO_ADVERTISEMENT_MIN_FREQUENCY);
  delay = GNUNET_TIME_absolute_get_remaining (pl->next_hello_allowed);
  pl->hello_delay_task = GNUNET_SCHEDULER_add_delayed (delay, &schedule_next_hello, pl);
}

References env, Peer::filter, find_advertisable_hello(), gettext_noop, GNUNET_assert, GNUNET_CONTAINER_bloomfilter_add(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_MAX_MESSAGE_SIZE, GNUNET_MQ_msg_copy(), GNUNET_MQ_send(), GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_FOREVER_REL, Peer::hello, HELLO_ADVERTISEMENT_MIN_FREQUENCY, Peer::hello_delay_task, FindAdvHelloContext::max_size, Peer::mq, FindAdvHelloContext::next_adv, Peer::next_hello_allowed, FindAdvHelloContext::peer, peers, Peer::pid, FindAdvHelloContext::result, schedule_next_hello(), GNUNET_MessageHeader::size, and stats.

Referenced by reschedule_hellos(), and schedule_next_hello().

Here is the call graph for this function:

Here is the caller graph for this function:

reschedule_hellos()

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

static

Cancel existing requests for sending HELLOs to this peer and recalculate when we should send HELLOs to it based on our current state (something changed!).

Parameters

cls	closure struct Peer to skip, or NULL
pid	identity of a peer
value	struct Peer * for the peer

Returns

GNUNET_YES (always)

Definition at line 497 of file gnunet-daemon-topology.c.

{
  (void) cls;
  struct Peer *peer = value;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Reschedule for `%s'\n",
              GNUNET_i2s (&peer->pid));
  if (NULL == peer->mq)
    return GNUNET_YES;
  if (NULL != peer->hello_delay_task)
  {
    GNUNET_SCHEDULER_cancel (peer->hello_delay_task);
    peer->hello_delay_task = NULL;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Schedule_next_hello\n");
  peer->hello_delay_task =
    GNUNET_SCHEDULER_add_now (&schedule_next_hello, peer);
  return GNUNET_YES;
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_YES, Peer::hello_delay_task, Peer::mq, Peer::pid, schedule_next_hello(), and value.

Referenced by connect_notify(), and consider_for_advertising().

Here is the call graph for this function:

Here is the caller graph for this function:

connect_notify()

static void * connect_notify ( void *  cls, const struct GNUNET_PeerIdentity *  peer, struct GNUNET_MQ_Handle *  mq  )

static

Method called whenever a peer connects.

Parameters

cls	closure
peer	peer identity this notification is about
mq	message queue for communicating with peer

Returns

our struct Peer for peer

Definition at line 531 of file gnunet-daemon-topology.c.

{
  struct Peer *pos;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Core told us that we are connecting to `%s'\n",
              GNUNET_i2s (peer));
  if (0 == GNUNET_memcmp (&my_identity, peer))
    return NULL;
  GNUNET_MQ_set_options (mq, GNUNET_MQ_PRIO_BEST_EFFORT);
  connection_count++;
  GNUNET_STATISTICS_set (stats,
                         gettext_noop ("# peers connected"),
                         connection_count,
                         GNUNET_NO);
  pos = GNUNET_CONTAINER_multipeermap_get (peers, peer);
  if (NULL == pos)
  {
    pos = make_peer (peer, NULL);
  }
  else
  {
    GNUNET_assert (NULL == pos->mq);
  }
  pos->mq = mq;
  reschedule_hellos (NULL, peer, pos);
  return pos;
}

References connection_count, gettext_noop, GNUNET_assert, GNUNET_CONTAINER_multipeermap_get(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_memcmp, GNUNET_MQ_PRIO_BEST_EFFORT, GNUNET_MQ_set_options(), GNUNET_NO, GNUNET_STATISTICS_set(), make_peer(), mq, Peer::mq, my_identity, peers, reschedule_hellos(), and stats.

Referenced by reconnect(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

try_add_peers()

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

static

Try to add more peers to our connection set.

Parameters

cls	closure, not used
pid	identity of a peer
value	struct Peer * for the peer

Returns

GNUNET_YES (continue to iterate)

Definition at line 572 of file gnunet-daemon-topology.c.

{
  struct Peer *pos = value;
 
  attempt_connect (pos);
  return GNUNET_YES;
}

References attempt_connect(), GNUNET_YES, and value.

Referenced by add_peer_task().

Here is the call graph for this function:

Here is the caller graph for this function:

add_peer_task()

static void add_peer_task ( void *  cls )

static

Add peers and schedule connection attempt.

Parameters

cls	unused, NULL

Definition at line 587 of file gnunet-daemon-topology.c.

{
  add_task = NULL;
 
  GNUNET_CONTAINER_multipeermap_iterate (peers, &try_add_peers, NULL);
}

References add_task, GNUNET_CONTAINER_multipeermap_iterate(), peers, and try_add_peers().

Referenced by disconnect_notify().

Here is the call graph for this function:

Here is the caller graph for this function:

disconnect_notify()

static void disconnect_notify ( void *  cls, const struct GNUNET_PeerIdentity *  peer, void *  internal_cls  )

static

Method called whenever a peer disconnects.

Parameters

cls	closure
peer	peer identity this notification is about
internal_cls	the struct Peer for this peer

Definition at line 603 of file gnunet-daemon-topology.c.

{
  struct Peer *pos = internal_cls;
 
  if (NULL == pos)
    return; /* myself, we're shutting down */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Core told us that we disconnected from `%s'\n",
              GNUNET_i2s (peer));
  if (NULL == pos->mq)
  {
    GNUNET_break (0);
    return;
  }
  pos->mq = NULL;
  connection_count--;
  if (NULL != pos->hello_delay_task)
  {
    GNUNET_SCHEDULER_cancel (pos->hello_delay_task);
    pos->hello_delay_task = NULL;
  }
  GNUNET_STATISTICS_set (stats,
                         gettext_noop ("# peers connected"),
                         connection_count,
                         GNUNET_NO);
  if ((connection_count < target_connection_count) &&
      (NULL == add_task))
    add_task = GNUNET_SCHEDULER_add_now (&add_peer_task, NULL);
 
}

References add_peer_task(), add_task, connection_count, gettext_noop, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_set(), Peer::hello_delay_task, Peer::mq, stats, and target_connection_count.

Referenced by reconnect(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

address_iterator()

static void address_iterator ( void *  cls, const struct GNUNET_PeerIdentity *  pid, const char *  uri  )

static

Iterator called on each address.

Parameters

cls	flag that we will set if we see any addresses
address	the address of the peer

Returns

GNUNET_SYSERR always, to terminate iteration

Definition at line 645 of file gnunet-daemon-topology.c.

{
  (void) pid;
  int *flag = cls;
 
  *flag = *flag + 1;
  // *flag = GNUNET_YES;
}

References pid.

Referenced by consider_for_advertising().

Here is the caller graph for this function:

consider_for_advertising()

static void consider_for_advertising ( const struct GNUNET_MessageHeader *  hello )

static

We've gotten a HELLO from another peer.

Consider it for advertising.

Parameters

hello

the HELLO we got

Definition at line 664 of file gnunet-daemon-topology.c.

{
  int num_addresses_old = 0;
  int num_addresses_new = 0;
  struct GNUNET_HELLO_Builder *builder = GNUNET_HELLO_builder_from_msg (hello);
  const struct GNUNET_PeerIdentity *pid;
  struct Peer *peer;
  uint16_t size;
 
  pid = GNUNET_HELLO_builder_iterate (builder,
                                      &address_iterator,
                                      &num_addresses_new);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "consider 0 for %s\n",
              GNUNET_i2s (pid));
  if (0 == num_addresses_new)
  {
    GNUNET_HELLO_builder_free (builder);
    return; /* no point in advertising this one... */
  }
  peer = GNUNET_CONTAINER_multipeermap_get (peers, pid);
  if (NULL == peer)
  {
    peer = make_peer (pid, hello);
  }
  else if (NULL != peer->hello)
  {
    struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
    struct GNUNET_TIME_Absolute new_hello_exp =
      GNUNET_HELLO_builder_get_expiration_time (hello);
    struct GNUNET_TIME_Absolute old_hello_exp =
      GNUNET_HELLO_builder_get_expiration_time (peer->hello);
    struct GNUNET_HELLO_Builder *builder_old = GNUNET_HELLO_builder_from_msg (
      peer->hello);
 
    GNUNET_HELLO_builder_iterate (builder_old,
                                  &address_iterator,
                                  &num_addresses_old);
    if (GNUNET_TIME_absolute_cmp (new_hello_exp, >, now) &&
        (GNUNET_TIME_absolute_cmp (new_hello_exp, >, old_hello_exp) ||
         num_addresses_old < num_addresses_new))
    {
      GNUNET_free (peer->hello);
      size = ntohs (hello->size);
      peer->hello = GNUNET_malloc (size);
      GNUNET_memcpy (peer->hello, hello, size);
    }
    else
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "consider 3\n");
      GNUNET_HELLO_builder_free (builder);
      return;
    }
  }
  else
  {
    size = ntohs (hello->size);
    peer->hello = GNUNET_malloc (size);
    GNUNET_memcpy (peer->hello, hello, size);
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Found HELLO from peer `%s' for advertising\n",
              GNUNET_i2s (pid));
  if (NULL != peer->filter)
  {
    GNUNET_CONTAINER_bloomfilter_free (peer->filter);
    peer->filter = NULL;
  }
  setup_filter (peer);
  /* since we have a new HELLO to pick from, re-schedule all
   * HELLO requests that are not bound by the HELLO send rate! */
  GNUNET_CONTAINER_multipeermap_iterate (peers, &reschedule_hellos, NULL);
  GNUNET_HELLO_builder_free (builder);
}

References address_iterator(), builder, Peer::filter, GNUNET_CONTAINER_bloomfilter_free(), GNUNET_CONTAINER_multipeermap_get(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_HELLO_builder_free(), GNUNET_HELLO_builder_from_msg(), GNUNET_HELLO_builder_get_expiration_time(), GNUNET_HELLO_builder_iterate(), GNUNET_i2s(), GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_TIME_absolute_cmp, GNUNET_TIME_absolute_get(), Peer::hello, make_peer(), peers, pid, reschedule_hellos(), setup_filter(), GNUNET_MessageHeader::size, and size.

Referenced by process_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

error_cb()

static void error_cb ( void *  cls )

static

Definition at line 742 of file gnunet-daemon-topology.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              _ (
                "Error in communication with PEERSTORE service to monitor.\n"));
  return;
}

References _, GNUNET_ERROR_TYPE_DEBUG, and GNUNET_log.

Referenced by process_peer(), and start_notify().

Here is the caller graph for this function:

sync_cb()

static void sync_cb ( void *  cls )

static

Definition at line 752 of file gnunet-daemon-topology.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              _ ("Finished initial PEERSTORE iteration in monitor.\n"));
  return;
}

References _, GNUNET_ERROR_TYPE_DEBUG, and GNUNET_log.

Referenced by process_peer(), and start_notify().

Here is the caller graph for this function:

process_peer()

static void process_peer ( void *  cls, const struct GNUNET_PEERSTORE_Record *  record, const char *  err_msg  )

static

PEERSTORE calls this function to let us know about a possible peer that we might want to connect to.

Parameters

cls	closure (not used)
peer	potential peer to connect to
hello	HELLO for this peer (or NULL)
err_msg	NULL if successful, otherwise contains error message

Definition at line 770 of file gnunet-daemon-topology.c.

{
  struct Peer *pos;
  struct GNUNET_MessageHeader *hello;
 
  if (NULL != err_msg)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                _ ("Error in communication with PEERSTORE service: %s\n"),
                err_msg);
    GNUNET_PEERSTORE_monitor_stop (peerstore_notify);
    peerstore_notify =
      GNUNET_PEERSTORE_monitor_start (cfg,
                                      GNUNET_YES,
                                      "peerstore",
                                      NULL,
                                      GNUNET_PEERSTORE_HELLO_KEY,
                                      error_cb,
                                      NULL,
                                      sync_cb,
                                      NULL,
                                      &process_peer,
                                      NULL);
    return;
  }
  GNUNET_assert (NULL != record);
  hello = record->value;
  if (NULL == hello)
  {
    /* free existing HELLO, if any */
    pos = GNUNET_CONTAINER_multipeermap_get (peers, &record->peer);
    if (NULL != pos)
    {
      GNUNET_free (pos->hello);
      pos->hello = NULL;
      if (NULL != pos->filter)
      {
        GNUNET_CONTAINER_bloomfilter_free (pos->filter);
        pos->filter = NULL;
      }
      if (NULL == pos->mq)
        free_peer (NULL, &pos->pid, pos);
    }
    GNUNET_PEERSTORE_monitor_next (peerstore_notify, 1);
    return;
  }
  consider_for_advertising (hello);
  pos = GNUNET_CONTAINER_multipeermap_get (peers, &record->peer);
  if (NULL == pos)
    pos = make_peer (&record->peer, hello);
  attempt_connect (pos);
  GNUNET_PEERSTORE_monitor_next (peerstore_notify, 1);
}

References _, attempt_connect(), cfg, consider_for_advertising(), error_cb(), Peer::filter, free_peer(), GNUNET_assert, GNUNET_CONTAINER_bloomfilter_free(), GNUNET_CONTAINER_multipeermap_get(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_PEERSTORE_HELLO_KEY, GNUNET_PEERSTORE_monitor_next(), GNUNET_PEERSTORE_monitor_start(), GNUNET_PEERSTORE_monitor_stop(), GNUNET_YES, Peer::hello, make_peer(), Peer::mq, peers, peerstore_notify, Peer::pid, process_peer(), record(), and sync_cb().

Referenced by process_peer(), and start_notify().

Here is the call graph for this function:

Here is the caller graph for this function:

start_notify()

static void start_notify ( void *  cls )

static

Definition at line 828 of file gnunet-daemon-topology.c.

{
  (void) cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Starting to process new hellos for gossiping.\n");
  peerstore_notify =
    GNUNET_PEERSTORE_monitor_start (cfg,
                                    GNUNET_YES,
                                    "peerstore",
                                    NULL,
                                    GNUNET_PEERSTORE_HELLO_KEY,
                                    &error_cb,
                                    NULL,
                                    &sync_cb,
                                    NULL,
                                    &process_peer,
                                    NULL);
}

References cfg, error_cb(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_PEERSTORE_HELLO_KEY, GNUNET_PEERSTORE_monitor_start(), GNUNET_YES, peerstore_notify, process_peer(), and sync_cb().

Referenced by core_init().

Here is the call graph for this function:

Here is the caller graph for this function:

core_init()

static void core_init ( void *  cls, const struct GNUNET_PeerIdentity *  my_id  )

static

Function called after GNUNET_CORE_connect has succeeded (or failed for good).

Parameters

cls	closure
my_id	ID of this peer, NULL if we failed

Definition at line 857 of file gnunet-daemon-topology.c.

{
  if (NULL == my_id)
  {
    GNUNET_log (
      GNUNET_ERROR_TYPE_ERROR,
      _ ("Failed to connect to core service, can not manage topology!\n"));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  my_identity = *my_id;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "I am peer `%s'\n", GNUNET_i2s (my_id));
  peerstore_notify_task = GNUNET_SCHEDULER_add_delayed (
    GNUNET_TIME_UNIT_MINUTES,
    start_notify,
    NULL);
}

References _, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_i2s(), GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_shutdown(), GNUNET_TIME_UNIT_MINUTES, my_identity, peerstore_notify_task, and start_notify().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

check_hello()

static int check_hello ( void *  cls, const struct GNUNET_MessageHeader *  message  )

static

This function is called whenever an encrypted HELLO message is received.

Parameters

cls	closure with the peer identity of the sender
message	the actual HELLO message

Returns

GNUNET_OK if message is well-formed GNUNET_SYSERR if message is invalid

Definition at line 886 of file gnunet-daemon-topology.c.

{
  struct GNUNET_HELLO_Builder *builder = GNUNET_HELLO_builder_from_msg (
    message);
  const struct GNUNET_PeerIdentity *pid = GNUNET_HELLO_builder_get_id (builder);
 
  if (NULL == pid)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References builder, GNUNET_break_op, GNUNET_HELLO_builder_from_msg(), GNUNET_HELLO_builder_get_id(), GNUNET_OK, GNUNET_SYSERR, and pid.

Here is the call graph for this function:

shc_cont()

static void shc_cont ( void *  cls, int  success  )

static

Definition at line 902 of file gnunet-daemon-topology.c.

{
  struct StoreHelloEntry *she =  cls;
 
  she->sc = NULL;
  if (GNUNET_YES == success)
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Hello stored successfully!\n");
  else
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Error storing hello!\n");
  GNUNET_CONTAINER_DLL_remove (she_head, she_tail, she);
  GNUNET_free (she);
}

References GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_YES, StoreHelloEntry::sc, she_head, and she_tail.

Referenced by handle_hello().

Here is the caller graph for this function:

handle_hello()

static void handle_hello ( void *  cls, const struct GNUNET_MessageHeader *  message  )

static

This function is called whenever an encrypted HELLO message is received.

Parameters

cls	closure with the peer identity of the sender
message	the actual HELLO message

Definition at line 926 of file gnunet-daemon-topology.c.

{
  struct StoreHelloEntry *she;
  const struct GNUNET_PeerIdentity *other = cls;
  struct GNUNET_HELLO_Builder *builder = GNUNET_HELLO_builder_from_msg (
    message);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received encrypted HELLO from peer `%s'\n",
              GNUNET_i2s (other));
  GNUNET_STATISTICS_update (stats,
                            gettext_noop ("# HELLO messages received"),
                            1,
                            GNUNET_NO);
  GNUNET_HELLO_builder_from_msg (message);
  she = GNUNET_new (struct StoreHelloEntry);
  she->sc = GNUNET_PEERSTORE_hello_add (ps, message, &shc_cont, she);
  if (NULL != she->sc)
  {
    GNUNET_CONTAINER_DLL_insert (she_head, she_tail, she);
  }
  else
    GNUNET_free (she);
  GNUNET_HELLO_builder_free (builder);
}

References builder, gettext_noop, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_HELLO_builder_free(), GNUNET_HELLO_builder_from_msg(), GNUNET_i2s(), GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_PEERSTORE_hello_add(), GNUNET_STATISTICS_update(), ps, StoreHelloEntry::sc, shc_cont(), she_head, she_tail, and stats.

Here is the call graph for this function:

cleaning_task()

static void cleaning_task ( void *  cls )

static

Last task run during shutdown.

Disconnects us from the transport and core.

Parameters

cls	unused, NULL

Definition at line 960 of file gnunet-daemon-topology.c.

{
  struct StoreHelloEntry *pos;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Topology shutdown\n");
  while (NULL != (pos = she_head))
  {
    GNUNET_CONTAINER_DLL_remove (she_head, she_tail, pos);
    if (NULL != pos->sc)
      GNUNET_PEERSTORE_hello_add_cancel (pos->sc);
    GNUNET_free (pos);
  }
  if (NULL != peerstore_notify)
  {
    GNUNET_PEERSTORE_monitor_stop (peerstore_notify);
    peerstore_notify = NULL;
  }
  else if (NULL != peerstore_notify_task)
  {
    GNUNET_SCHEDULER_cancel (peerstore_notify_task);
  }
  if (NULL != handle)
  {
    GNUNET_CORE_disconnect (handle);
    handle = NULL;
  }
  if (NULL != add_task)
  {
    GNUNET_SCHEDULER_cancel (add_task);
    add_task = NULL;
  }
  GNUNET_CONTAINER_multipeermap_iterate (peers, &free_peer, NULL);
  GNUNET_CONTAINER_multipeermap_destroy (peers);
  peers = NULL;
  if (NULL != transport)
  {
    GNUNET_TRANSPORT_application_done (transport);
    transport = NULL;
  }
  if (NULL != ps)
  {
    GNUNET_PEERSTORE_disconnect (ps);
    ps = NULL;
  }
  if (NULL != stats)
  {
    GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
    stats = NULL;
  }
  GNUNET_free (my_private_key);
}

References add_task, free_peer(), GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_CORE_disconnect(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_PEERSTORE_disconnect(), GNUNET_PEERSTORE_hello_add_cancel(), GNUNET_PEERSTORE_monitor_stop(), GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_destroy(), GNUNET_TRANSPORT_application_done(), handle, my_private_key, peers, peerstore_notify, peerstore_notify_task, ps, StoreHelloEntry::sc, she_head, she_tail, stats, and transport.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

run()

static void run ( void *  cls, char *const *  args, const char *  cfgfile, const struct GNUNET_CONFIGURATION_Handle *  c  )

static

Main function that will be run.

Parameters

cls	closure
args	remaining command-line arguments
cfgfile	name of the configuration file used (for saving, can be NULL!)
c	configuration

Definition at line 1022 of file gnunet-daemon-topology.c.

{
  struct GNUNET_MQ_MessageHandler handlers[] =
  { GNUNET_MQ_hd_var_size (hello,
                           GNUNET_MESSAGE_TYPE_HELLO_URI,
                           struct GNUNET_MessageHeader,
                           NULL),
    GNUNET_MQ_handler_end () };
  unsigned long long opt;
 
  cfg = c;
  my_private_key =
    GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg);
  stats = GNUNET_STATISTICS_create ("topology", cfg);
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_number (cfg,
                                             "TOPOLOGY",
                                             "TARGET-CONNECTION-COUNT",
                                             &opt))
    opt = 16;
  target_connection_count = (unsigned int) opt;
  peers = GNUNET_CONTAINER_multipeermap_create (target_connection_count * 2,
                                                GNUNET_NO);
  transport = GNUNET_TRANSPORT_application_init (cfg);
  ps = GNUNET_PEERSTORE_connect (cfg);
  handle = GNUNET_CORE_connect (cfg,
                                NULL,
                                &core_init,
                                &connect_notify,
                                &disconnect_notify,
                                handlers);
  GNUNET_SCHEDULER_add_shutdown (&cleaning_task, NULL);
  if (NULL == handle)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to connect to `%s' service.\n"),
                "core");
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
}

References _, cfg, cleaning_task(), connect_notify(), core_init(), disconnect_notify(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONTAINER_multipeermap_create(), GNUNET_CORE_connect(), GNUNET_CRYPTO_eddsa_key_create_from_configuration(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_MESSAGE_TYPE_HELLO_URI, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_NO, GNUNET_OK, GNUNET_PEERSTORE_connect(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_STATISTICS_create(), GNUNET_TRANSPORT_application_init(), handle, handlers, consensus-simulation::int, my_private_key, peers, ps, stats, target_connection_count, and transport.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char *const *	argv
	)

The main function for the topology daemon.

Parameters

argc	number of arguments from the command line
argv	command line arguments

Returns

0 ok, 1 on error

Definition at line 1077 of file gnunet-daemon-topology.c.

{
  static const struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_OPTION_END
  };
  int ret;
 
  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
    return 2;
 
  ret = (GNUNET_OK == GNUNET_PROGRAM_run (argc,
                                          argv,
                                          "gnunet-daemon-topology",
                                          _ ("GNUnet topology control"),
                                          options,
                                          &run,
                                          NULL))
        ? 0
        : 1;
  GNUNET_free_nz ((void *) argv);
  return ret;
}

References _, GNUNET_free_nz, GNUNET_GETOPT_OPTION_END, GNUNET_OK, GNUNET_PROGRAM_run(), GNUNET_STRINGS_get_utf8_args(), options, ret, and run().

Here is the call graph for this function:

Variable Documentation

peerstore_notify_task

struct GNUNET_SCHEDULER_Task* peerstore_notify_task

The task to delayed start the notification process intially.

We like to give transport some time to give us our hello to distribute it.

Definition at line 135 of file gnunet-daemon-topology.c.

Referenced by cleaning_task(), and core_init().

peerstore_notify

struct GNUNET_PEERSTORE_Monitor* peerstore_notify

static

Our peerstore notification context.

We use notification to instantly learn about new peers as they are discovered.

Definition at line 142 of file gnunet-daemon-topology.c.

Referenced by cleaning_task(), process_peer(), and start_notify().

cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

static

Our configuration.

Definition at line 147 of file gnunet-daemon-topology.c.

Referenced by process_peer(), run(), and start_notify().

handle

struct GNUNET_CORE_Handle* handle

static

Handle to the CORE service.

Definition at line 152 of file gnunet-daemon-topology.c.

Referenced by cleaning_task(), and run().

ps

struct GNUNET_PEERSTORE_Handle* ps

static

Handle to the PEERSTORE service.

Definition at line 157 of file gnunet-daemon-topology.c.

Referenced by cleaning_task(), database_prepare(), database_setup(), evaluate_connection(), GNUNET_JSON_pack_array_incref(), GNUNET_JSON_pack_array_steal(), GNUNET_JSON_pack_bool(), GNUNET_JSON_pack_data64_varsize(), GNUNET_JSON_pack_data_varsize(), GNUNET_JSON_pack_double(), GNUNET_JSON_pack_end_(), GNUNET_JSON_pack_int64(), GNUNET_JSON_pack_object_incref(), GNUNET_JSON_pack_object_steal(), GNUNET_JSON_pack_rsa_public_key(), GNUNET_JSON_pack_rsa_signature(), GNUNET_JSON_pack_string(), GNUNET_JSON_pack_timestamp(), GNUNET_JSON_pack_uint64(), GNUNET_PQ_connect(), GNUNET_PQ_connect2(), GNUNET_PQ_connect_with_cfg(), GNUNET_PQ_connect_with_cfg2(), GNUNET_PQ_make_prepare(), GNUNET_PQ_prepare_once(), GNUNET_PQ_prepare_statements(), GNUNET_SQ_make_prepare(), GNUNET_SQ_prepare(), GNUNET_TRANSPORT_TESTING_log_connect(), GNUNET_TRANSPORT_TESTING_log_disconnect(), handle_hello(), init_connection(), and run().

transport

struct GNUNET_TRANSPORT_ApplicationHandle* transport

Handle to Transport service.

Definition at line 162 of file gnunet-daemon-topology.c.

Referenced by attempt_connect(), cleaning_task(), and run().

my_identity

struct GNUNET_PeerIdentity my_identity

static

Identity of this peer.

Definition at line 167 of file gnunet-daemon-topology.c.

Referenced by attempt_connect(), connect_notify(), and core_init().

my_private_key

struct GNUNET_CRYPTO_EddsaPrivateKey* my_private_key

static

Our private key.

Definition at line 172 of file gnunet-daemon-topology.c.

Referenced by cleaning_task(), and run().

peers

struct GNUNET_CONTAINER_MultiPeerMap* peers

static

All of our current neighbours and all peers for which we have HELLOs.

So pretty much everyone. Maps peer identities to struct Peer * values.

Definition at line 179 of file gnunet-daemon-topology.c.

Referenced by add_peer_task(), cleaning_task(), connect_notify(), consider_for_advertising(), free_peer(), make_peer(), process_peer(), run(), and schedule_next_hello().

stats

struct GNUNET_STATISTICS_Handle* stats

static

Handle for reporting statistics.

Definition at line 184 of file gnunet-daemon-topology.c.

Referenced by attempt_connect(), cleaning_task(), connect_notify(), disconnect_notify(), handle_hello(), run(), and schedule_next_hello().

add_task

struct GNUNET_SCHEDULER_Task* add_task

static

Task scheduled to asynchronously reconsider adding/removing peer connectivity suggestions.

Definition at line 190 of file gnunet-daemon-topology.c.

Referenced by add_peer_task(), cleaning_task(), and disconnect_notify().

connection_count

unsigned int connection_count

static

Number of peers that we are currently connected to.

Definition at line 195 of file gnunet-daemon-topology.c.

Referenced by attempt_connect(), connect_notify(), and disconnect_notify().

target_connection_count

unsigned int target_connection_count

static

Target number of connections.

Definition at line 200 of file gnunet-daemon-topology.c.

Referenced by attempt_connect(), disconnect_notify(), and run().

she_head

struct StoreHelloEntry* she_head

static

Head of the linkd list to store the store context for hellos.

Definition at line 205 of file gnunet-daemon-topology.c.

Referenced by cleaning_task(), handle_hello(), and shc_cont().

she_tail

struct StoreHelloEntry* she_tail

static

Tail of the linkd list to store the store context for hellos.

Definition at line 210 of file gnunet-daemon-topology.c.

Referenced by cleaning_task(), handle_hello(), and shc_cont().