gnunet-daemon-topology.c File Reference

code for maintaining the overlay topology More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_friends_lib.h"
#include "gnunet_constants.h"
#include "gnunet_core_service.h"
#include "gnunet_protocols.h"
#include "gnunet_peerinfo_service.h"
#include "gnunet_statistics_service.h"
#include "gnunet_transport_service.h"
#include "gnunet_ats_service.h"

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

Go to the source code of this file.

Data Structures
struct	Peer
	A peer. 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	blacklist_check (void *cls, const struct GNUNET_PeerIdentity *pid)
	Function that decides if a connection is acceptable or not. More...
static void	whitelist_peers ()
	Whitelist all peers that we blacklisted; we've passed the minimum number of friends. More...
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_HELLO_Message *hello, int is_friend)
	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 int	address_iterator (void *cls, const struct GNUNET_HELLO_Address *address, struct GNUNET_TIME_Absolute expiration)
	Iterator called on each address. More...
static void	consider_for_advertising (const struct GNUNET_HELLO_Message *hello)
	We've gotten a HELLO from another peer. More...
static void	process_peer (void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Message *hello, const char *err_msg)
	PEERINFO calls this function to let us know about a possible peer that we might want to connect to. More...
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 void	handle_friend (void *cls, const struct GNUNET_PeerIdentity *pid)
	Process friend found in FRIENDS file. More...
static void	read_friends_file (const struct GNUNET_CONFIGURATION_Handle *cfg)
	Read the friends file. More...
static int	check_hello (void *cls, const struct GNUNET_HELLO_Message *message)
	This function is called whenever an encrypted HELLO message is received. More...
static void	handle_hello (void *cls, const struct GNUNET_HELLO_Message *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
static struct GNUNET_PEERINFO_NotifyContext *	peerinfo_notify
	Our peerinfo 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_PEERINFO_Handle *	pi
	Handle to the PEERINFO service. More...
static struct GNUNET_ATS_ConnectivityHandle *	ats
	Handle to the ATS service. More...
static struct GNUNET_PeerIdentity	my_identity
	Identity of this peer. More...
static struct GNUNET_CONTAINER_MultiPeerMap *	peers
	All of our friends, 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_TRANSPORT_Blacklist *	blacklist
	Blacklist (NULL if we have none). More...
static struct GNUNET_SCHEDULER_Task *	add_task
	Task scheduled to asynchronously reconsider adding/removing peer connectivity suggestions. More...
static struct GNUNET_TRANSPORT_OfferHelloHandle *	oh
	Active HELLO offering to transport service. More...
static int	friends_only
	Flag to disallow non-friend connections (pure F2F mode). More...
static unsigned int	minimum_friend_count
	Minimum number of friends to have in the connection set before we allow non-friends. More...
static unsigned int	connection_count
	Number of peers (friends and others) that we are currently connected to. More...
static unsigned int	target_connection_count
	Target number of connections. More...
static unsigned int	friend_count
	Number of friends that we are currently connected to. More...

Detailed Description

code for maintaining the overlay topology

Author

Christian Grothoff

This daemon combines three functions:

• suggesting to ATS which peers we might want to connect to
• enforcing the F2F restrictions (by blacklisting)
• gossping HELLOs

All three require similar information (who are our friends impacts connectivity suggestions; connectivity suggestions should consider blacklisting; connectivity suggestions should consider available/known HELLOs; gossip requires connectivity data; connectivity suggestions require connectivity data), which is why they are combined in this program.

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 54 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 60 of file gnunet-daemon-topology.c.

Function Documentation

blacklist_check()

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

static

Function that decides if a connection is acceptable or not.

If we have a blacklist, only friends are allowed, so the check is rather simple.

Parameters

cls	closure
pid	peer to approve or disapprove

Returns

GNUNET_OK if the connection is allowed

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

{
  struct Peer *pos;
 
  pos = GNUNET_CONTAINER_multipeermap_get (peers, pid);
  if ((NULL != pos) && (GNUNET_YES == pos->is_friend))
    return GNUNET_OK;
  GNUNET_STATISTICS_update (stats,
                            gettext_noop ("# peers blacklisted"),
                            1,
                            GNUNET_NO);
  return GNUNET_SYSERR;
}

References gettext_noop, GNUNET_CONTAINER_multipeermap_get(), GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_YES, Peer::is_friend, peers, pid, and stats.

Referenced by disconnect_notify(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

whitelist_peers()

static void whitelist_peers ( )

static

Whitelist all peers that we blacklisted; we've passed the minimum number of friends.

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

{
  if (NULL != blacklist)
  {
    GNUNET_TRANSPORT_blacklist_cancel (blacklist);
    blacklist = NULL;
  }
}

References blacklist, and GNUNET_TRANSPORT_blacklist_cancel().

Referenced by cleaning_task(), and connect_notify().

Here is the call graph for this function:

Here is the caller graph for this function:

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 259 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->sh)
  {
    GNUNET_ATS_connectivity_suggest_cancel (pos->sh);
    pos->sh = 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::filter, GNUNET_ATS_connectivity_suggest_cancel(), GNUNET_break, GNUNET_CONTAINER_bloomfilter_free(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_free, GNUNET_OK, GNUNET_SCHEDULER_cancel(), GNUNET_YES, Peer::hello, Peer::hello_delay_task, Peer::mq, peers, pid, Peer::sh, 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 298 of file gnunet-daemon-topology.c.

{
  uint32_t strength;
 
  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 ((friend_count < minimum_friend_count) || (GNUNET_YES == friends_only))
  {
    if (pos->is_friend)
      strength += 10;   /* urgently needed */
    else
      strength = 0;   /* disallowed */
  }
  if (pos->is_friend)
    strength *= 2; /* friends always count more */
  if (NULL != pos->mq)
    strength *= 2; /* existing connections preferred */
  if (strength == pos->strength)
    return; /* nothing to do */
  if (NULL != pos->sh)
  {
    GNUNET_ATS_connectivity_suggest_cancel (pos->sh);
    pos->sh = 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);
    pos->sh = GNUNET_ATS_connectivity_suggest (ats, &pos->pid, strength);
  }
}

References ats, connection_count, friend_count, friends_only, gettext_noop, GNUNET_ATS_connectivity_suggest(), GNUNET_ATS_connectivity_suggest_cancel(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_memcmp, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_YES, Peer::is_friend, minimum_friend_count, Peer::mq, my_identity, Peer::pid, Peer::sh, stats, Peer::strength, and target_connection_count.

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_HELLO_Message *  hello, int  is_friend  )

static

Create a new entry in the peer list.

Parameters

peer	identity of the new entry
hello	hello message, can be NULL
is_friend	is the new entry for a friend?

Returns

the new entry

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

{
  struct Peer *ret;
 
  ret = GNUNET_new (struct Peer);
  ret->pid = *peer;
  ret->is_friend = is_friend;
  if (NULL != hello)
  {
    ret->hello = GNUNET_malloc (GNUNET_HELLO_size (hello));
    GNUNET_memcpy (ret->hello, hello, GNUNET_HELLO_size (hello));
  }
  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_HELLO_size(), GNUNET_malloc, GNUNET_memcpy, GNUNET_new, GNUNET_OK, Peer::hello, Peer::is_friend, peer, peers, and ret.

Referenced by connect_notify(), consider_for_advertising(), handle_friend(), 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 381 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 GNUNET_CONTAINER_bloomfilter_add(), GNUNET_CONTAINER_bloomfilter_init(), GNUNET_CRYPTO_hash(), GNUNET_TIME_relative_to_absolute(), HELLO_ADVERTISEMENT_MIN_REPEAT_FREQUENCY, and peer.

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 433 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;
 
  if (pos == fah->peer)
    return GNUNET_YES;
  if (pos->hello == NULL)
    return GNUNET_YES;
  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 = GNUNET_HELLO_size (pos->hello);
  if (hs > fah->max_size)
    return GNUNET_YES;
  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_HELLO_size(), 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(), 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 474 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;
 
  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);
  pl->hello_delay_task =
    GNUNET_SCHEDULER_add_delayed (fah.next_adv, &schedule_next_hello, pl);
  if (NULL == fah.result)
    return;
  delay = GNUNET_TIME_absolute_get_remaining (pl->next_hello_allowed);
  if (0 != delay.rel_value_us)
    return;
 
  want = GNUNET_HELLO_size (fah.result->hello);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending HELLO with %u bytes",
              (unsigned int) want);
  env = GNUNET_MQ_msg_copy (&fah.result->hello->header);
  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);
  if (NULL != pl->hello_delay_task)
    GNUNET_SCHEDULER_cancel (pl->hello_delay_task);
  pl->hello_delay_task = GNUNET_SCHEDULER_add_now (&schedule_next_hello, pl);
}

References delay, 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_HELLO_size(), GNUNET_log, GNUNET_MAX_MESSAGE_SIZE, GNUNET_MQ_msg_copy(), GNUNET_MQ_send(), GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_HELLO_Message::header, 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, GNUNET_TIME_Relative::rel_value_us, FindAdvHelloContext::result, and stats.

Referenced by reschedule_hellos().

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 534 of file gnunet-daemon-topology.c.

{
  struct Peer *peer = value;
  struct Peer *skip = cls;
 
  if (skip == peer)
    return GNUNET_YES;
  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;
  }
  peer->hello_delay_task =
    GNUNET_SCHEDULER_add_now (&schedule_next_hello, peer);
  return GNUNET_YES;
}

References GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_YES, peer, 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 565 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, GNUNET_NO);
  }
  else
  {
    GNUNET_assert (NULL == pos->mq);
  }
  pos->mq = mq;
  if (pos->is_friend)
  {
    friend_count++;
    if ((friend_count == minimum_friend_count) && (GNUNET_YES != friends_only))
      whitelist_peers ();
    GNUNET_STATISTICS_set (stats,
                           gettext_noop ("# friends connected"),
                           friend_count,
                           GNUNET_NO);
  }
  reschedule_hellos (NULL, peer, pos);
  return pos;
}

References connection_count, friend_count, friends_only, 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(), GNUNET_YES, Peer::is_friend, make_peer(), minimum_friend_count, mq, Peer::mq, my_identity, peer, peers, reschedule_hellos(), stats, and whitelist_peers().

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 616 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 631 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 647 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 (pos->is_friend)
  {
    friend_count--;
    GNUNET_STATISTICS_set (stats,
                           gettext_noop ("# friends connected"),
                           friend_count,
                           GNUNET_NO);
  }
  if (((connection_count < target_connection_count) ||
       (friend_count < minimum_friend_count)) &&
      (NULL == add_task))
    add_task = GNUNET_SCHEDULER_add_now (&add_peer_task, NULL);
  if ((friend_count < minimum_friend_count) && (NULL == blacklist))
    blacklist = GNUNET_TRANSPORT_blacklist (cfg, &blacklist_check, NULL);
}

References add_peer_task(), add_task, blacklist, blacklist_check(), cfg, connection_count, friend_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(), GNUNET_TRANSPORT_blacklist(), Peer::hello_delay_task, Peer::is_friend, minimum_friend_count, Peer::mq, peer, 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 int address_iterator ( void *  cls, const struct GNUNET_HELLO_Address *  address, struct GNUNET_TIME_Absolute  expiration  )

static

Iterator called on each address.

Parameters

cls	flag that we will set if we see any addresses
address	the address of the peer
expiration	when will the given address expire

Returns

GNUNET_SYSERR always, to terminate iteration

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

{
  int *flag = cls;
 
  *flag = GNUNET_YES;
  return GNUNET_SYSERR;
}

References GNUNET_SYSERR, and GNUNET_YES.

Referenced by consider_for_advertising().

Here is the caller graph for this function:

consider_for_advertising()

static void consider_for_advertising ( const struct GNUNET_HELLO_Message *  hello )

static

We've gotten a HELLO from another peer.

Consider it for advertising.

Parameters

hello

the HELLO we got

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

{
  int have_address;
  struct GNUNET_PeerIdentity pid;
  struct GNUNET_TIME_Absolute dt;
  struct GNUNET_HELLO_Message *nh;
  struct Peer *peer;
  uint16_t size;
 
  if (GNUNET_OK != GNUNET_HELLO_get_id (hello, &pid))
  {
    GNUNET_break (0);
    return;
  }
  if (0 == GNUNET_memcmp (&pid, &my_identity))
    return; /* that's me! */
  have_address = GNUNET_NO;
  GNUNET_HELLO_iterate_addresses (hello,
                                  GNUNET_NO,
                                  &address_iterator,
                                  &have_address);
  if (GNUNET_NO == have_address)
    return; /* no point in advertising this one... */
  peer = GNUNET_CONTAINER_multipeermap_get (peers, &pid);
  if (NULL == peer)
  {
    peer = make_peer (&pid, hello, GNUNET_NO);
  }
  else if (NULL != peer->hello)
  {
    dt = GNUNET_HELLO_equals (peer->hello, hello, GNUNET_TIME_absolute_get ());
    if (dt.abs_value_us == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us)
      return;   /* nothing new here */
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Found HELLO from peer `%s' for advertising\n",
              GNUNET_i2s (&pid));
  if (NULL != peer->hello)
  {
    nh = GNUNET_HELLO_merge (peer->hello, hello);
    GNUNET_free (peer->hello);
    peer->hello = nh;
  }
  else
  {
    size = GNUNET_HELLO_size (hello);
    peer->hello = GNUNET_malloc (size);
    GNUNET_memcpy (peer->hello, hello, size);
  }
  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, peer);
}

References GNUNET_TIME_Absolute::abs_value_us, address_iterator(), GNUNET_break, GNUNET_CONTAINER_bloomfilter_free(), GNUNET_CONTAINER_multipeermap_get(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_HELLO_equals(), GNUNET_HELLO_get_id(), GNUNET_HELLO_iterate_addresses(), GNUNET_HELLO_merge(), GNUNET_HELLO_size(), GNUNET_i2s(), GNUNET_log, GNUNET_malloc, GNUNET_memcmp, GNUNET_memcpy, GNUNET_NO, GNUNET_OK, GNUNET_TIME_absolute_get(), GNUNET_TIME_UNIT_FOREVER_ABS, Peer::hello, make_peer(), my_identity, nh, peer, peers, pid, reschedule_hellos(), setup_filter(), and size.

Referenced by process_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

process_peer()

static void process_peer ( void *  cls, const struct GNUNET_PeerIdentity *  peer, const struct GNUNET_HELLO_Message *  hello, const char *  err_msg  )

static

PEERINFO 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 789 of file gnunet-daemon-topology.c.

{
  struct Peer *pos;
 
  if (NULL != err_msg)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                _ ("Error in communication with PEERINFO service: %s\n"),
                err_msg);
    GNUNET_PEERINFO_notify_cancel (peerinfo_notify);
    peerinfo_notify =
      GNUNET_PEERINFO_notify (cfg, GNUNET_NO, &process_peer, NULL);
    return;
  }
  GNUNET_assert (NULL != peer);
  if (0 == GNUNET_memcmp (&my_identity, peer))
    return; /* that's me! */
  if (NULL == hello)
  {
    /* free existing HELLO, if any */
    pos = GNUNET_CONTAINER_multipeermap_get (peers, 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) && (GNUNET_NO == pos->is_friend))
        free_peer (NULL, &pos->pid, pos);
    }
    return;
  }
  consider_for_advertising (hello);
  pos = GNUNET_CONTAINER_multipeermap_get (peers, peer);
  if (NULL == pos)
    pos = make_peer (peer, hello, GNUNET_NO);
  attempt_connect (pos);
}

References _, attempt_connect(), cfg, consider_for_advertising(), Peer::filter, free_peer(), GNUNET_assert, GNUNET_CONTAINER_bloomfilter_free(), GNUNET_CONTAINER_multipeermap_get(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_memcmp, GNUNET_NO, GNUNET_PEERINFO_notify(), GNUNET_PEERINFO_notify_cancel(), Peer::hello, Peer::is_friend, make_peer(), Peer::mq, my_identity, peer, peerinfo_notify, peers, and Peer::pid.

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 843 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));
  peerinfo_notify =
    GNUNET_PEERINFO_notify (cfg, GNUNET_NO, &process_peer, NULL);
}

References _, cfg, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_PEERINFO_notify(), GNUNET_SCHEDULER_shutdown(), my_identity, peerinfo_notify, and process_peer().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_friend()

static void handle_friend ( void *  cls, const struct GNUNET_PeerIdentity *  pid  )

static

Process friend found in FRIENDS file.

Parameters

cls	pointer to an unsigned int to be incremented per friend found
pid	identity of the friend

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

{
  unsigned int *entries_found = cls;
  struct Peer *fl;
 
  if (0 == GNUNET_memcmp (pid, &my_identity))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Found myself `%s' in friend list (useless, ignored)\n"),
                GNUNET_i2s (pid));
    return;
  }
  (*entries_found)++;
  fl = make_peer (pid, NULL, GNUNET_YES);
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              _ ("Found friend `%s' in configuration\n"),
              GNUNET_i2s (&fl->pid));
}

References _, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_i2s(), GNUNET_log, GNUNET_memcmp, GNUNET_YES, make_peer(), my_identity, Peer::pid, and pid.

Referenced by read_friends_file().

Here is the call graph for this function:

Here is the caller graph for this function:

read_friends_file()

static void read_friends_file ( const struct GNUNET_CONFIGURATION_Handle *  cfg )

static

Read the friends file.

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

{
  unsigned int entries_found;
 
  entries_found = 0;
  if (GNUNET_OK != GNUNET_FRIENDS_parse (cfg, &handle_friend, &entries_found))
  {
    if ((GNUNET_YES == friends_only) || (minimum_friend_count > 0))
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  _ ("Encountered errors parsing friends list!\n"));
  }
  GNUNET_STATISTICS_update (stats,
                            gettext_noop ("# friends in configuration"),
                            entries_found,
                            GNUNET_NO);
  if ((minimum_friend_count > entries_found) && (GNUNET_NO == friends_only))
  {
    GNUNET_log (
      GNUNET_ERROR_TYPE_WARNING,
      _ (
        "Fewer friends specified than required by minimum friend count. Will only connect to friends.\n"));
  }
  if ((minimum_friend_count > target_connection_count) &&
      (GNUNET_NO == friends_only))
  {
    GNUNET_log (
      GNUNET_ERROR_TYPE_WARNING,
      _ (
        "More friendly connections required than target total number of connections.\n"));
  }
}

References _, cfg, friends_only, gettext_noop, GNUNET_ERROR_TYPE_WARNING, GNUNET_FRIENDS_parse(), GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_YES, handle_friend(), minimum_friend_count, stats, and target_connection_count.

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_HELLO_Message *  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 934 of file gnunet-daemon-topology.c.

{
  struct GNUNET_PeerIdentity pid;
 
  if (GNUNET_OK != GNUNET_HELLO_get_id (message, &pid))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_HELLO_get_id(), GNUNET_OK, GNUNET_SYSERR, and pid.

Here is the call graph for this function:

handle_hello()

static void handle_hello ( void *  cls, const struct GNUNET_HELLO_Message *  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 955 of file gnunet-daemon-topology.c.

{
  const struct GNUNET_PeerIdentity *other = cls;
  struct Peer *peer;
  struct GNUNET_PeerIdentity pid;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received encrypted HELLO from peer `%s'",
              GNUNET_i2s (other));
  GNUNET_assert (GNUNET_OK == GNUNET_HELLO_get_id (message, &pid));
  GNUNET_STATISTICS_update (stats,
                            gettext_noop ("# HELLO messages received"),
                            1,
                            GNUNET_NO);
  peer = GNUNET_CONTAINER_multipeermap_get (peers, &pid);
  if (NULL == peer)
  {
    if ((GNUNET_YES == friends_only) || (friend_count < minimum_friend_count))
      return;
  }
  else
  {
    if ((GNUNET_YES != peer->is_friend) && (GNUNET_YES == friends_only))
      return;
    if ((GNUNET_YES != peer->is_friend) &&
        (friend_count < minimum_friend_count))
      return;
  }
  (void) GNUNET_PEERINFO_add_peer (pi, message, NULL, NULL);
}

References friend_count, friends_only, gettext_noop, GNUNET_assert, GNUNET_CONTAINER_multipeermap_get(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_HELLO_get_id(), GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_PEERINFO_add_peer(), GNUNET_STATISTICS_update(), GNUNET_YES, minimum_friend_count, peer, peers, pi, pid, 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 994 of file gnunet-daemon-topology.c.

{
  if (NULL != peerinfo_notify)
  {
    GNUNET_PEERINFO_notify_cancel (peerinfo_notify);
    peerinfo_notify = NULL;
  }
  if (NULL != handle)
  {
    GNUNET_CORE_disconnect (handle);
    handle = NULL;
  }
  whitelist_peers ();
  if (NULL != add_task)
  {
    GNUNET_SCHEDULER_cancel (add_task);
    add_task = NULL;
  }
  if (NULL != oh)
  {
    GNUNET_TRANSPORT_offer_hello_cancel (oh);
    oh = NULL;
  }
  GNUNET_CONTAINER_multipeermap_iterate (peers, &free_peer, NULL);
  GNUNET_CONTAINER_multipeermap_destroy (peers);
  peers = NULL;
  if (NULL != ats)
  {
    GNUNET_ATS_connectivity_done (ats);
    ats = NULL;
  }
  if (NULL != pi)
  {
    GNUNET_PEERINFO_disconnect (pi);
    pi = NULL;
  }
  if (NULL != stats)
  {
    GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
    stats = NULL;
  }
}

References add_task, ats, free_peer(), GNUNET_ATS_connectivity_done(), GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_CORE_disconnect(), GNUNET_NO, GNUNET_PEERINFO_disconnect(), GNUNET_PEERINFO_notify_cancel(), GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_destroy(), GNUNET_TRANSPORT_offer_hello_cancel(), handle, oh, peerinfo_notify, peers, pi, stats, and whitelist_peers().

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 1047 of file gnunet-daemon-topology.c.

{
  struct GNUNET_MQ_MessageHandler handlers[] =
  { GNUNET_MQ_hd_var_size (hello,
                           GNUNET_MESSAGE_TYPE_HELLO,
                           struct GNUNET_HELLO_Message,
                           NULL),
    GNUNET_MQ_handler_end () };
  unsigned long long opt;
 
  cfg = c;
  stats = GNUNET_STATISTICS_create ("topology", cfg);
  friends_only =
    GNUNET_CONFIGURATION_get_value_yesno (cfg, "TOPOLOGY", "FRIENDS-ONLY");
  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg,
                                                          "TOPOLOGY",
                                                          "MINIMUM-FRIENDS",
                                                          &opt))
    opt = 0;
  minimum_friend_count = (unsigned int) opt;
  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);
  read_friends_file (cfg);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Topology would like %u connections with at least %u friends\n",
              target_connection_count,
              minimum_friend_count);
  if ((GNUNET_YES == friends_only) || (minimum_friend_count > 0))
    blacklist = GNUNET_TRANSPORT_blacklist (cfg, &blacklist_check, NULL);
  ats = GNUNET_ATS_connectivity_init (cfg);
  pi = GNUNET_PEERINFO_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 _, ats, blacklist, blacklist_check(), cfg, cleaning_task(), connect_notify(), core_init(), disconnect_notify(), friends_only, GNUNET_ATS_connectivity_init(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_CONTAINER_multipeermap_create(), GNUNET_CORE_connect(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_MESSAGE_TYPE_HELLO, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_NO, GNUNET_OK, GNUNET_PEERINFO_connect(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_STATISTICS_create(), GNUNET_TRANSPORT_blacklist(), GNUNET_YES, handle, handlers, consensus-simulation::int, minimum_friend_count, peers, pi, read_friends_file(), stats, and target_connection_count.

Here is the call 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 1114 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;
}

Variable Documentation

peerinfo_notify

struct GNUNET_PEERINFO_NotifyContext* peerinfo_notify

static

Our peerinfo notification context.

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

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

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

cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

static

Our configuration.

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

Referenced by core_init(), disconnect_notify(), process_peer(), read_friends_file(), and run().

handle

struct GNUNET_CORE_Handle* handle

static

Handle to the CORE service.

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

Referenced by cleaning_task(), and run().

pi

struct GNUNET_PEERINFO_Handle* pi

static

Handle to the PEERINFO service.

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

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

ats

struct GNUNET_ATS_ConnectivityHandle* ats

static

Handle to the ATS service.

Definition at line 148 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 148 of file gnunet-daemon-topology.c.

Referenced by attempt_connect(), connect_notify(), consider_for_advertising(), core_init(), handle_friend(), and process_peer().

peers

struct GNUNET_CONTAINER_MultiPeerMap* peers

static

All of our friends, 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 160 of file gnunet-daemon-topology.c.

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

stats

struct GNUNET_STATISTICS_Handle* stats

static

Handle for reporting statistics.

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

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

blacklist

struct GNUNET_TRANSPORT_Blacklist* blacklist

static

Blacklist (NULL if we have none).

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

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

add_task

struct GNUNET_SCHEDULER_Task* add_task

static

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

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

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

oh

struct GNUNET_TRANSPORT_OfferHelloHandle* oh

static

Active HELLO offering to transport service.

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

Referenced by cleaning_task(), GNUNET_SET_accept(), GNUNET_SET_commit(), GNUNET_SET_operation_cancel(), GNUNET_SET_prepare(), GNUNET_SETI_accept(), GNUNET_SETI_commit(), GNUNET_SETI_operation_cancel(), GNUNET_SETI_prepare(), GNUNET_SETU_accept(), GNUNET_SETU_commit(), GNUNET_SETU_operation_cancel(), GNUNET_SETU_prepare(), handle_result(), and set_operation_destroy().

friends_only

int friends_only

static

Flag to disallow non-friend connections (pure F2F mode).

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

Referenced by attempt_connect(), connect_notify(), handle_hello(), read_friends_file(), and run().

minimum_friend_count

unsigned int minimum_friend_count

static

Minimum number of friends to have in the connection set before we allow non-friends.

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

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

connection_count

unsigned int connection_count

static

Number of peers (friends and others) that we are currently connected to.

Definition at line 197 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 202 of file gnunet-daemon-topology.c.

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

friend_count

unsigned int friend_count

static

Number of friends that we are currently connected to.

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

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