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_pils_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?
#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?
#define	RECONSIDER_FREQUENCY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 1)
	How often do we reconsider which peers we would like to be connected to?

Functions
static int	free_peer (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
	Free all resources associated with the given peer.
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.
static struct Peer *	make_peer (const struct GNUNET_PeerIdentity *peer, const struct GNUNET_MessageHeader *hello)
	Create a new entry in the peer list.
static void	setup_filter (struct Peer *peer)
	Setup bloom filter for the given peer entry.
static int	find_advertisable_hello (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
	Find a peer that would be reasonable for advertising.
static void	schedule_next_hello (void *cls)
	Calculate when we would like to send the next HELLO to this peer and ask for it.
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!).
static void *	connect_notify (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq, enum GNUNET_CORE_PeerClass class)
	Method called whenever a peer connects.
static int	try_add_peers (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
	Try to add more peers to our connection set.
static void	add_peer_task (void *cls)
	Add peers and schedule connection attempt.
static void	disconnect_notify (void *cls, const struct GNUNET_PeerIdentity *peer, void *internal_cls)
	Method called whenever a peer disconnects.
static void	address_iterator (void *cls, const struct GNUNET_PeerIdentity *pid, const char *uri)
	Iterator called on each address.
static void	consider_for_advertising (const struct GNUNET_MessageHeader *hello)
	We've gotten a HELLO from another peer.
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.
static void	start_notify (void *cls)
static void	pid_change_cb (void *cls, const struct GNUNET_HELLO_Parser *parser, const struct GNUNET_HashCode *addr_hash)
static void	core_init (void *cls, const struct GNUNET_PeerIdentity *my_id)
	Function called after GNUNET_CORE_connect has succeeded (or failed for good).
static int	check_hello (void *cls, const struct GNUNET_MessageHeader *msg)
	This function is called whenever an encrypted HELLO message is received.
static void	shc_cont (void *cls, int success)
static void	handle_hello (void *cls, const struct GNUNET_MessageHeader *msg)
	This function is called whenever an encrypted HELLO message is received.
static void	cleaning_task (void *cls)
	Last task run during shutdown.
static void	run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
	Main function that will be run.
int	main (int argc, char *const *argv)
	The main function for the topology daemon.

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

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

{
  struct GNUNET_PeerIdentity pid;
 
  struct GNUNET_MQ_Handle *mq;
 
  struct GNUNET_MessageHeader *hello;
 
  struct GNUNET_CONTAINER_BloomFilter *filter;
 
  struct GNUNET_TIME_Absolute next_hello_allowed;
 
  struct GNUNET_TIME_Absolute filter_expiration;
 
  struct GNUNET_SCHEDULER_Task *hello_delay_task;
 
  struct GNUNET_TRANSPORT_ApplicationSuggestHandle *ash;
 
  uint32_t strength;
 
};
 
struct StoreHelloEntry
{
  struct StoreHelloEntry *prev;
 
  struct StoreHelloEntry *next;
 
  struct GNUNET_PEERSTORE_StoreHelloContext *sc;
};
 
struct GNUNET_SCHEDULER_Task *peerstore_notify_task;
 
 
static struct GNUNET_PEERSTORE_Monitor *peerstore_notify;
 
static const struct GNUNET_CONFIGURATION_Handle *cfg;
 
static struct GNUNET_PILS_Handle *pils;
 
static struct GNUNET_CORE_Handle *handle;
 
static struct GNUNET_PEERSTORE_Handle *ps;
 
struct GNUNET_TRANSPORT_ApplicationHandle *transport;
 
static struct GNUNET_PeerIdentity my_identity;
 
static struct GNUNET_CONTAINER_MultiPeerMap *peers;
 
static struct GNUNET_STATISTICS_Handle *stats;
 
static struct GNUNET_SCHEDULER_Task *add_task;
 
static unsigned int connection_count;
 
static unsigned int target_connection_count;
 
static struct StoreHelloEntry *she_head;
 
static struct StoreHelloEntry *she_tail;
 
static int
free_peer (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
{
  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;
}
 
 
static void
attempt_connect (struct Peer *pos)
{
  uint32_t strength;
  struct GNUNET_BANDWIDTH_Value32NBO bw;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Checking if we want to attempt connection to `%s'\n",
              GNUNET_i2s (&pos->pid));
  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 ((strength == pos->strength) &&
      ((NULL == pos->ash) == (0 == strength)))
    return;   /* nothing changed; re-issuing the suggestion would only reset
                 the retry state transport keeps for it */
  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);
  }
}
 
 
static struct Peer *
make_peer (const struct GNUNET_PeerIdentity *peer,
           const struct GNUNET_MessageHeader *hello)
{
  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;
}
 
 
static void
setup_filter (struct Peer *peer)
{
  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);
}
 
 
struct FindAdvHelloContext
{
  struct Peer *peer;
 
  struct Peer *result;
 
  size_t max_size;
 
  struct GNUNET_TIME_Relative next_adv;
};
 
 
static int
find_advertisable_hello (void *cls,
                         const struct GNUNET_PeerIdentity *pid,
                         void *value)
{
  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;
}
 
 
static void
schedule_next_hello (void *cls)
{
  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);
}
 
 
static int
reschedule_hellos (void *cls,
                   const struct GNUNET_PeerIdentity *pid,
                   void *value)
{
  struct Peer *peer = value;
  (void) cls;
 
  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;
}
 
 
static void *
connect_notify (void *cls,
                const struct GNUNET_PeerIdentity *peer,
                struct GNUNET_MQ_Handle *mq,
                enum GNUNET_CORE_PeerClass class)
{
  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;
}
 
 
static int
try_add_peers (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
{
  struct Peer *pos = value;
 
  attempt_connect (pos);
  return GNUNET_YES;
}
 
 
static void
add_peer_task (void *cls)
{
  add_task = NULL;
 
  GNUNET_CONTAINER_multipeermap_iterate (peers, &try_add_peers, NULL);
  /* Keep going.  A suggestion that did not work out produces no event of
     its own -- the peer simply never connects -- so without a periodic
     re-run the only things that ever call attempt_connect() again are a
     CORE disconnect and a HELLO showing up in PEERSTORE.  A peer we cannot
     reach delivers neither, and a peer whose HELLO we learned while we were
     already at the target connection count never gets a suggestion at
     all. */
  add_task = GNUNET_SCHEDULER_add_delayed (RECONSIDER_FREQUENCY,
                                           &add_peer_task,
                                           NULL);
}
 
 
static void
disconnect_notify (void *cls,
                   const struct GNUNET_PeerIdentity *peer,
                   void *internal_cls)
{
  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)
  {
    /* Do not wait for the next periodic run. */
    if (NULL != add_task)
      GNUNET_SCHEDULER_cancel (add_task);
    add_task = GNUNET_SCHEDULER_add_now (&add_peer_task, NULL);
  }
}
 
 
static void
address_iterator (void *cls,
                  const struct GNUNET_PeerIdentity *pid,
                  const char *uri)
{
  int *flag = cls;
  (void) pid;
 
  *flag = *flag + 1;
  // *flag = GNUNET_YES;
}
 
 
static void
consider_for_advertising (const struct GNUNET_MessageHeader *hello)
{
  int num_addresses_old = 0;
  int num_addresses_new = 0;
  struct GNUNET_HELLO_Parser *parser;
  const struct GNUNET_PeerIdentity *pid;
  struct Peer *peer;
  uint16_t size;
 
  parser = GNUNET_HELLO_parser_from_msg (hello, NULL);
  if (NULL == parser)
  {
    return;
  }
  pid = GNUNET_HELLO_parser_iterate (parser,
                                     &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_parser_free (parser);
    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_get_expiration_time_from_msg (hello);
    struct GNUNET_TIME_Absolute old_hello_exp =
      GNUNET_HELLO_get_expiration_time_from_msg (peer->hello);
    struct GNUNET_HELLO_Parser *parser_old =
      GNUNET_HELLO_parser_from_msg (peer->hello, &peer->pid);
 
    GNUNET_HELLO_parser_iterate (parser_old,
                                 &address_iterator,
                                 &num_addresses_old);
    GNUNET_HELLO_parser_free (parser_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_parser_free (parser);
      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_parser_free (parser);
}
 
 
static void
error_cb (void *cls)
{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              _ (
                "Error in communication with PEERSTORE service to monitor.\n"));
  return;
}
 
 
static void
sync_cb (void *cls)
{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              _ ("Finished initial PEERSTORE iteration in monitor.\n"));
  return;
}
 
 
static void
process_peer (void *cls,
              const struct GNUNET_PEERSTORE_Record *record,
              const char *err_msg)
{
  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);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Processing HELLO from peerstore from peer `%s'\n",
              GNUNET_i2s (&record->peer));
  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);
}
 
 
static void
start_notify (void *cls)
{
  (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);
}
 
 
static void
pid_change_cb (void *cls,
               const struct GNUNET_HELLO_Parser *parser,
               const struct GNUNET_HashCode *addr_hash)
{
  my_identity = *GNUNET_HELLO_parser_get_id (parser);
}
 
 
static void
core_init (void *cls, const struct GNUNET_PeerIdentity *my_id)
{
  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_SECONDS,
    start_notify,
    NULL);
}
 
 
static int
check_hello (void *cls, const struct GNUNET_MessageHeader *msg)
{
  struct GNUNET_HELLO_Parser *parser = GNUNET_HELLO_parser_from_msg (msg, NULL);
  const struct GNUNET_PeerIdentity *pid = GNUNET_HELLO_parser_get_id (parser);
 
  if (NULL == pid)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}
 
 
static void
shc_cont (void *cls, int success)
{
  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);
}
 
 
static void
handle_hello (void *cls, const struct GNUNET_MessageHeader *msg)
{
  struct StoreHelloEntry *she;
  const struct GNUNET_PeerIdentity *other = cls;
  struct GNUNET_HELLO_Parser *parser;
 
  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);
  parser = GNUNET_HELLO_parser_from_msg (msg, NULL);
  she = GNUNET_new (struct StoreHelloEntry);
  she->sc = GNUNET_PEERSTORE_hello_add (ps, msg, &shc_cont, she);
  if (NULL != she->sc)
  {
    GNUNET_CONTAINER_DLL_insert (she_head, she_tail, she);
  }
  else
    GNUNET_free (she);
  GNUNET_HELLO_parser_free (parser);
}
 
 
static void
cleaning_task (void *cls)
{
  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 != pils)
  {
    GNUNET_PILS_disconnect (pils);
    pils = NULL;
  }
  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;
  }
}
 
 
static void
run (void *cls,
     char *const *args,
     const char *cfgfile,
     const struct GNUNET_CONFIGURATION_Handle *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;
  const struct GNUNET_CORE_ServiceInfo service_info = {
    .service = GNUNET_CORE_SERVICE_TOPOLOGY,
    .version = { 1, 0 },
    .version_max = { 1, 0 },
    .version_min = { 1, 0 },
  };
 
  cfg = c;
  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,
                                &service_info);
  pils = GNUNET_PILS_connect (cfg, &pid_change_cb, NULL);
  GNUNET_SCHEDULER_add_shutdown (&cleaning_task, NULL);
  if (NULL == pils)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to connect to `%s' service.\n"),
                "pils");
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if (NULL == handle)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to connect to `%s' service.\n"),
                "core");
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  add_task = GNUNET_SCHEDULER_add_delayed (RECONSIDER_FREQUENCY,
                                           &add_peer_task,
                                           NULL);
}
 
 
int
main (int argc, char *const *argv)
{
  static const struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_OPTION_END
  };
  int ret;
 
  ret = (GNUNET_OK ==
         GNUNET_PROGRAM_run (GNUNET_OS_project_data_gnunet (),
                             argc,
                             argv,
                             "gnunet-daemon-topology",
                             _ ("GNUnet topology control"),
                             options,
                             &run,
                             NULL))
        ? 0
        : 1;
  return ret;
}
 
 
#if defined(__linux__) && defined(__GLIBC__)
#include <malloc.h>
 
void __attribute__ ((constructor))
GNUNET_TOPOLOGY_memory_init (void);
 
void __attribute__ ((constructor))
GNUNET_TOPOLOGY_memory_init (void)
{
  mallopt (M_TRIM_THRESHOLD, 4 * 1024);
  mallopt (M_TOP_PAD, 1 * 1024);
  malloc_trim (0);
}
 
 
#endif
 
/* end of 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 52 of file gnunet-daemon-topology.c.

RECONSIDER_FREQUENCY

#define RECONSIDER_FREQUENCY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 1)

How often do we reconsider which peers we would like to be connected to?

Definition at line 58 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 228 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, Peer::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 267 of file gnunet-daemon-topology.c.

{
  uint32_t strength;
  struct GNUNET_BANDWIDTH_Value32NBO bw;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Checking if we want to attempt connection to `%s'\n",
              GNUNET_i2s (&pos->pid));
  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 ((strength == pos->strength) &&
      ((NULL == pos->ash) == (0 == strength)))
    return;   /* nothing changed; re-issuing the suggestion would only reset
                 the retry state transport keeps for it */
  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 321 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 349 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 401 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 450 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 512 of file gnunet-daemon-topology.c.

{
  struct Peer *peer = value;
  (void) cls;
 
  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, enum GNUNET_CORE_PeerClass  class  )

static

Method called whenever a peer connects.

Parameters

cls	closure
peer	peer identity this notification is about
mq	message queue for communicating with peer
class	class of the connecting peer

Returns

our struct Peer for peer

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

{
  add_task = NULL;
 
  GNUNET_CONTAINER_multipeermap_iterate (peers, &try_add_peers, NULL);
  /* Keep going.  A suggestion that did not work out produces no event of
     its own -- the peer simply never connects -- so without a periodic
     re-run the only things that ever call attempt_connect() again are a
     CORE disconnect and a HELLO showing up in PEERSTORE.  A peer we cannot
     reach delivers neither, and a peer whose HELLO we learned while we were
     already at the target connection count never gets a suggestion at
     all. */
  add_task = GNUNET_SCHEDULER_add_delayed (RECONSIDER_FREQUENCY,
                                           &add_peer_task,
                                           NULL);
}

References add_peer_task(), add_task, GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_SCHEDULER_add_delayed(), peers, RECONSIDER_FREQUENCY, and try_add_peers().

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

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 630 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)
  {
    /* Do not wait for the next periodic run. */
    if (NULL != add_task)
      GNUNET_SCHEDULER_cancel (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 675 of file gnunet-daemon-topology.c.

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

References Peer::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 694 of file gnunet-daemon-topology.c.

{
  int num_addresses_old = 0;
  int num_addresses_new = 0;
  struct GNUNET_HELLO_Parser *parser;
  const struct GNUNET_PeerIdentity *pid;
  struct Peer *peer;
  uint16_t size;
 
  parser = GNUNET_HELLO_parser_from_msg (hello, NULL);
  if (NULL == parser)
  {
    return;
  }
  pid = GNUNET_HELLO_parser_iterate (parser,
                                     &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_parser_free (parser);
    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_get_expiration_time_from_msg (hello);
    struct GNUNET_TIME_Absolute old_hello_exp =
      GNUNET_HELLO_get_expiration_time_from_msg (peer->hello);
    struct GNUNET_HELLO_Parser *parser_old =
      GNUNET_HELLO_parser_from_msg (peer->hello, &peer->pid);
 
    GNUNET_HELLO_parser_iterate (parser_old,
                                 &address_iterator,
                                 &num_addresses_old);
    GNUNET_HELLO_parser_free (parser_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_parser_free (parser);
      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_parser_free (parser);
}

References address_iterator(), Peer::filter, GNUNET_CONTAINER_bloomfilter_free(), GNUNET_CONTAINER_multipeermap_get(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_HELLO_get_expiration_time_from_msg(), GNUNET_HELLO_parser_free(), GNUNET_HELLO_parser_from_msg(), GNUNET_HELLO_parser_iterate(), GNUNET_i2s(), GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_TIME_absolute_cmp, GNUNET_TIME_absolute_get(), Peer::hello, make_peer(), peers, GNUNET_HELLO_Parser::pid, Peer::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 778 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 788 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 806 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);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Processing HELLO from peerstore from peer `%s'\n",
              GNUNET_i2s (&record->peer));
  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_i2s(), 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 867 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:

pid_change_cb()

static void pid_change_cb ( void *  cls, const struct GNUNET_HELLO_Parser *  parser, const struct GNUNET_HashCode *  addr_hash  )

static

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

{
  my_identity = *GNUNET_HELLO_parser_get_id (parser);
}

References GNUNET_HELLO_parser_get_id(), and my_identity.

Referenced by run().

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 905 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_SECONDS,
    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_SECONDS, 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 *  msg  )

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_HELLO_Parser *parser = GNUNET_HELLO_parser_from_msg (msg, NULL);
  const struct GNUNET_PeerIdentity *pid = GNUNET_HELLO_parser_get_id (parser);
 
  if (NULL == pid)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_HELLO_parser_from_msg(), GNUNET_HELLO_parser_get_id(), GNUNET_OK, GNUNET_SYSERR, and msg.

Here is the call graph for this function:

shc_cont()

static void shc_cont ( void *  cls, int  success  )

static

Definition at line 949 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 *  msg  )

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

{
  struct StoreHelloEntry *she;
  const struct GNUNET_PeerIdentity *other = cls;
  struct GNUNET_HELLO_Parser *parser;
 
  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);
  parser = GNUNET_HELLO_parser_from_msg (msg, NULL);
  she = GNUNET_new (struct StoreHelloEntry);
  she->sc = GNUNET_PEERSTORE_hello_add (ps, msg, &shc_cont, she);
  if (NULL != she->sc)
  {
    GNUNET_CONTAINER_DLL_insert (she_head, she_tail, she);
  }
  else
    GNUNET_free (she);
  GNUNET_HELLO_parser_free (parser);
}

References gettext_noop, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_HELLO_parser_free(), GNUNET_HELLO_parser_from_msg(), GNUNET_i2s(), GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_PEERSTORE_hello_add(), GNUNET_STATISTICS_update(), msg, 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 1006 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 != pils)
  {
    GNUNET_PILS_disconnect (pils);
    pils = NULL;
  }
  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;
  }
}

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_PILS_disconnect(), GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_destroy(), GNUNET_TRANSPORT_application_done(), handle, peers, peerstore_notify, peerstore_notify_task, pils, 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 1072 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;
  const struct GNUNET_CORE_ServiceInfo service_info = {
    .service = GNUNET_CORE_SERVICE_TOPOLOGY,
    .version = { 1, 0 },
    .version_max = { 1, 0 },
    .version_min = { 1, 0 },
  };
 
  cfg = c;
  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,
                                &service_info);
  pils = GNUNET_PILS_connect (cfg, &pid_change_cb, NULL);
  GNUNET_SCHEDULER_add_shutdown (&cleaning_task, NULL);
  if (NULL == pils)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to connect to `%s' service.\n"),
                "pils");
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if (NULL == handle)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to connect to `%s' service.\n"),
                "core");
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  add_task = GNUNET_SCHEDULER_add_delayed (RECONSIDER_FREQUENCY,
                                           &add_peer_task,
                                           NULL);
}

References _, add_peer_task(), add_task, cfg, cleaning_task(), connect_notify(), core_init(), disconnect_notify(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONTAINER_multipeermap_create(), GNUNET_CORE_connect(), GNUNET_CORE_SERVICE_TOPOLOGY, 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_PILS_connect(), GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_STATISTICS_create(), GNUNET_TRANSPORT_application_init(), handle, handlers, peers, pid_change_cb(), pils, ps, RECONSIDER_FREQUENCY, GNUNET_CORE_ServiceInfo::service, 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 1144 of file gnunet-daemon-topology.c.

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

References _, GNUNET_GETOPT_OPTION_END, GNUNET_OK, GNUNET_OS_project_data_gnunet(), GNUNET_PROGRAM_run(), 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 initially.

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

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

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

pils

struct GNUNET_PILS_Handle* pils

static

Handle to the PILS service.

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

Referenced by cleaning_task(), and run().

handle

struct GNUNET_CORE_Handle* handle

static

Handle to the CORE service.

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

Referenced by cleaning_task(), connection_write_streams(), database_prepare(), database_setup(), evaluate_connection(), GNUNET_JSON_pack_array_incref(), GNUNET_JSON_pack_array_steal(), GNUNET_JSON_pack_blinded_message(), GNUNET_JSON_pack_blinded_sig(), 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_JSON_pack_unblinded_signature(), GNUNET_PQ_make_prepare(), GNUNET_PQ_prepare_statements(), GNUNET_SQ_make_prepare(), GNUNET_SQ_prepare(), GNUNET_TRANSPORT_TESTING_log_connect(), GNUNET_TRANSPORT_TESTING_log_disconnect(), handle_hello(), reconnect_setup(), reconnect_setup(), reconnect_setup(), reconnect_setup(), run(), and start_closing_period().

transport

struct GNUNET_TRANSPORT_ApplicationHandle* transport

Handle to Transport service.

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

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

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 186 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 191 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 197 of file gnunet-daemon-topology.c.

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

connection_count

unsigned int connection_count

static

Number of peers that we are currently connected to.

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

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