gnunet-service-peerinfo.c File Reference

maintains list of known peers More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_hello_lib.h"
#include "gnunet_protocols.h"
#include "gnunet_statistics_service.h"
#include "peerinfo.h"

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

Go to the source code of this file.

Data Structures
struct	HostEntry
	In-memory cache of known hosts. More...
struct	ReadHostFileContext
	Result of reading a file. More...
struct	DirScanContext
	Closure for hosts_directory_scan_callback(). More...
struct	TransmitContext
	Closure for add_to_tc() More...

Macros
#define	DATA_HOST_FREQ    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
	How often do we scan the HOST_DIR for new entries? More...
#define	DATA_HOST_CLEAN_FREQ    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 60)
	How often do we discard old entries in data/hosts/? More...

Functions
static struct InfoMessage *	make_info_message (const struct HostEntry *he, int include_friend_only)
	Notify all clients in the notify list about the given host entry changing. More...
static int	discard_expired (void *cls, const struct GNUNET_HELLO_Address *address, struct GNUNET_TIME_Absolute expiration)
	Address iterator that causes expired entries to be discarded. More...
static int	count_addresses (void *cls, const struct GNUNET_HELLO_Address *address, struct GNUNET_TIME_Absolute expiration)
	Address iterator that counts the remaining addresses. More...
static char *	get_host_filename (const struct GNUNET_PeerIdentity *id)
	Get the filename under which we would store the GNUNET_HELLO_Message for the given host and protocol. More...
static void	notify_all (struct HostEntry *entry)
	Broadcast information about the given entry to all clients that care. More...
static void	update_hello (const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Message *hello)
	Bind a host address (hello) to a hostId. More...
static void	read_host_file (const char *fn, int unlink_garbage, struct ReadHostFileContext *r)
	Try to read the HELLOs in the given filename and discard expired addresses. More...
static struct HostEntry *	add_host_to_known_hosts (const struct GNUNET_PeerIdentity *identity)
	Add a host to the list and notify clients about this event. More...
static void	remove_garbage (const char *fullname)
	Remove a file that should not be there. More...
static int	hosts_directory_scan_callback (void *cls, const char *fullname)
	Function that is called on each HELLO file in a particular directory. More...
static void	cron_scan_directory_data_hosts (void *cls)
	Call this method periodically to scan data/hosts for new hosts. More...
static struct GNUNET_HELLO_Message *	update_friend_hello (const struct GNUNET_HELLO_Message *hello, const struct GNUNET_HELLO_Message *friend_hello)
	Update the HELLO of a friend by merging the addresses. More...
static int	add_to_tc (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
	Do transmit info about peer to given host. More...
static int	discard_hosts_helper (void *cls, const char *fn)
	delete expired HELLO entries in directory More...
static void	cron_clean_data_hosts (void *cls)
	Call this method periodically to scan peerinfo/ for ancient HELLOs to expire. More...
static int	check_hello (void *cls, const struct GNUNET_HELLO_Message *hello)
	Check HELLO-message. More...
static void	handle_hello (void *cls, const struct GNUNET_HELLO_Message *hello)
	Handle HELLO-message. More...
static void	handle_get (void *cls, const struct ListPeerMessage *lpm)
	Handle GET-message. More...
static void	handle_get_all (void *cls, const struct ListAllPeersMessage *lapm)
	Handle GET-ALL-message. More...
static void	handle_notify (void *cls, const struct NotifyMessage *nm)
	Handle NOTIFY-message. More...
static void *	client_connect_cb (void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
	Client connect callback. More...
static void	client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *client, void *app_ctx)
	Client disconnect callback. More...
static int	free_host_entry (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
	Release memory taken by a host entry. More...
static void	shutdown_task (void *cls)
	Clean up our state. More...
static void	run (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_SERVICE_Handle *service)
	Start up peerinfo service. More...
	GNUNET_SERVICE_MAIN ("peerinfo", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_var_size(hello, GNUNET_MESSAGE_TYPE_HELLO, struct GNUNET_HELLO_Message, NULL), GNUNET_MQ_hd_fixed_size(get, GNUNET_MESSAGE_TYPE_PEERINFO_GET, struct ListPeerMessage, NULL), GNUNET_MQ_hd_fixed_size(get_all, GNUNET_MESSAGE_TYPE_PEERINFO_GET_ALL, struct ListAllPeersMessage, NULL), GNUNET_MQ_hd_fixed_size(notify, GNUNET_MESSAGE_TYPE_PEERINFO_NOTIFY, struct NotifyMessage, NULL), GNUNET_MQ_handler_end())
	Define "main" method using service macro. More...

Variables
static struct GNUNET_CONTAINER_MultiPeerMap *	hostmap
	The in-memory list of known hosts, mapping of host IDs to 'struct HostEntry*' values. More...
static struct GNUNET_NotificationContext *	notify_list
	Clients to immediately notify about all changes. More...
static struct GNUNET_NotificationContext *	notify_friend_only_list
	Clients to immediately notify about all changes, even for friend-only HELLOs. More...
static char *	networkIdDirectory
	Directory where the hellos are stored in (peerinfo/) More...
static struct GNUNET_STATISTICS_Handle *	stats
	Handle for reporting statistics. More...
static struct GNUNET_SCHEDULER_Task *	cron_clean
	Handle for task to run cron_clean_data_hosts() More...
static struct GNUNET_SCHEDULER_Task *	cron_scan
	Handle for task to run cron_scan_directory_data_hosts() More...

Detailed Description

maintains list of known peers

Code to maintain the list of currently known hosts (in memory structure of data/hosts/).

Author

Christian Grothoff

Definition in file gnunet-service-peerinfo.c.

Macro Definition Documentation

DATA_HOST_FREQ

#define DATA_HOST_FREQ    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)

How often do we scan the HOST_DIR for new entries?

Definition at line 41 of file gnunet-service-peerinfo.c.

DATA_HOST_CLEAN_FREQ

#define DATA_HOST_CLEAN_FREQ    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 60)

How often do we discard old entries in data/hosts/?

Definition at line 47 of file gnunet-service-peerinfo.c.

Function Documentation

make_info_message()

static struct InfoMessage* make_info_message ( const struct HostEntry *  he, int  include_friend_only  )

static

Notify all clients in the notify list about the given host entry changing.

Parameters

he	entry of the host for which we generate a notification
include_friend_only	create public of friend-only message

Returns

generated notification message

Definition at line 137 of file gnunet-service-peerinfo.c.

{
  struct InfoMessage *im;
  struct GNUNET_HELLO_Message *src;
  size_t hs;
 
  if (GNUNET_YES == include_friend_only)
    src = he->friend_only_hello;
  else
    src = he->hello;
  hs = (NULL == src) ? 0 : GNUNET_HELLO_size (src);
  im = GNUNET_malloc (sizeof(struct InfoMessage) + hs);
  im->header.size = htons (hs + sizeof(struct InfoMessage));
  im->header.type = htons (GNUNET_MESSAGE_TYPE_PEERINFO_INFO);
  im->peer = he->identity;
  GNUNET_memcpy (&im[1], src, hs);
  return im;
}

References HostEntry::friend_only_hello, GNUNET_HELLO_size(), GNUNET_malloc, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_PEERINFO_INFO, GNUNET_YES, InfoMessage::header, HostEntry::hello, HostEntry::identity, include_friend_only, InfoMessage::peer, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by notify_all().

Here is the call graph for this function:

Here is the caller graph for this function:

discard_expired()

static int discard_expired ( void *  cls, const struct GNUNET_HELLO_Address *  address, struct GNUNET_TIME_Absolute  expiration  )

static

Address iterator that causes expired entries to be discarded.

Parameters

cls	pointer to the current time
address	the address
expiration	expiration time for the address

Returns

GNUNET_NO if expiration smaller than the current time

Definition at line 166 of file gnunet-service-peerinfo.c.

{
  const struct GNUNET_TIME_Absolute *now = cls;
 
  if (now->abs_value_us > expiration.abs_value_us)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                _ ("Removing expired address of transport `%s'\n"),
                address->transport_name);
    return GNUNET_NO;
  }
  return GNUNET_OK;
}

References _, GNUNET_TIME_Absolute::abs_value_us, address, expiration, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NO, and GNUNET_OK.

Referenced by discard_hosts_helper(), and read_host_file().

Here is the caller graph for this function:

count_addresses()

static int count_addresses ( void *  cls, const struct GNUNET_HELLO_Address *  address, struct GNUNET_TIME_Absolute  expiration  )

static

Address iterator that counts the remaining addresses.

Parameters

cls	pointer to the counter
address	the address
expiration	expiration time for the address

Returns

GNUNET_OK (always)

Definition at line 192 of file gnunet-service-peerinfo.c.

{
  unsigned int *cnt = cls;
 
  (void) address;
  (void) expiration;
  (*cnt)++;
  return GNUNET_OK;
}

References address, expiration, and GNUNET_OK.

Referenced by discard_hosts_helper(), distribute_bandwidth(), read_host_file(), and update_hello().

Here is the caller graph for this function:

get_host_filename()

static char* get_host_filename ( const struct GNUNET_PeerIdentity *  id )

static

Get the filename under which we would store the GNUNET_HELLO_Message for the given host and protocol.

Parameters

id	peer for which we need the filename for the HELLO

Returns

filename of the form DIRECTORY/HOSTID

Definition at line 213 of file gnunet-service-peerinfo.c.

{
  char *fn;
 
  if (NULL == networkIdDirectory)
    return NULL;
  GNUNET_asprintf (&fn,
                   "%s%s%s",
                   networkIdDirectory,
                   DIR_SEPARATOR_STR,
                   GNUNET_i2s_full (id));
  return fn;
}

References DIR_SEPARATOR_STR, GNUNET_asprintf(), GNUNET_i2s_full(), and networkIdDirectory.

Referenced by add_host_to_known_hosts(), and update_hello().

Here is the call graph for this function:

Here is the caller graph for this function:

notify_all()

static void notify_all ( struct HostEntry *  entry )

static

Broadcast information about the given entry to all clients that care.

Parameters

entry

entry to broadcast about

Definition at line 235 of file gnunet-service-peerinfo.c.

{
  struct InfoMessage *msg_pub;
  struct InfoMessage *msg_friend;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Notifying all clients about peer `%s'\n",
              GNUNET_i2s (&entry->identity));
  msg_pub = make_info_message (entry, GNUNET_NO);
  GNUNET_notification_context_broadcast (notify_list,
                                         &msg_pub->header,
                                         GNUNET_NO);
  GNUNET_free (msg_pub);
  msg_friend = make_info_message (entry, GNUNET_YES);
  GNUNET_notification_context_broadcast (notify_friend_only_list,
                                         &msg_friend->header,
                                         GNUNET_NO);
  GNUNET_free (msg_friend);
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_notification_context_broadcast(), GNUNET_YES, InfoMessage::header, HostEntry::identity, make_info_message(), notify_friend_only_list, and notify_list.

Referenced by add_host_to_known_hosts(), and update_hello().

Here is the call graph for this function:

Here is the caller graph for this function:

update_hello()

static void update_hello ( const struct GNUNET_PeerIdentity *  peer, const struct GNUNET_HELLO_Message *  hello  )

static

Bind a host address (hello) to a hostId.

Parameters

peer	the peer for which this is a hello
hello	the verified (!) hello message

Definition at line 683 of file gnunet-service-peerinfo.c.

{
  char *fn;
  struct HostEntry *host;
  struct GNUNET_HELLO_Message *mrg;
  struct GNUNET_HELLO_Message **dest;
  struct GNUNET_TIME_Absolute delta;
  unsigned int cnt;
  unsigned int size;
  int friend_hello_type;
  int store_hello;
  int store_friend_hello;
  unsigned int pos;
  char *buffer;
 
  host = GNUNET_CONTAINER_multipeermap_get (hostmap, peer);
  GNUNET_assert (NULL != host);
 
  friend_hello_type = GNUNET_HELLO_is_friend_only (hello);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Updating %s HELLO for `%s'\n",
              (GNUNET_YES == friend_hello_type) ? "friend-only" : "public",
              GNUNET_i2s (peer));
 
  dest = NULL;
  if (GNUNET_YES == friend_hello_type)
  {
    dest = &host->friend_only_hello;
  }
  else
  {
    dest = &host->hello;
  }
 
  if (NULL == (*dest))
  {
    (*dest) = GNUNET_malloc (GNUNET_HELLO_size (hello));
    GNUNET_memcpy ((*dest), hello, GNUNET_HELLO_size (hello));
  }
  else
  {
    mrg = GNUNET_HELLO_merge ((*dest), hello);
    delta = GNUNET_HELLO_equals (mrg, (*dest), GNUNET_TIME_absolute_get ());
    if (delta.abs_value_us == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us)
    {
      /* no differences, just ignore the update */
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "No change in %s HELLO for `%s'\n",
                  (GNUNET_YES == friend_hello_type) ? "friend-only" : "public",
                  GNUNET_i2s (peer));
      GNUNET_free (mrg);
      return;
    }
    GNUNET_free ((*dest));
    (*dest) = mrg;
  }
 
  if ((NULL != (host->hello)) && (GNUNET_NO == friend_hello_type))
  {
    /* Update friend only hello */
    mrg = update_friend_hello (host->hello, host->friend_only_hello);
    if (NULL != host->friend_only_hello)
      GNUNET_free (host->friend_only_hello);
    host->friend_only_hello = mrg;
  }
 
  if (NULL != host->hello)
    GNUNET_assert ((GNUNET_NO == GNUNET_HELLO_is_friend_only (host->hello)));
  if (NULL != host->friend_only_hello)
    GNUNET_assert (
      (GNUNET_YES == GNUNET_HELLO_is_friend_only (host->friend_only_hello)));
 
  fn = get_host_filename (peer);
  if ((NULL != fn) && (GNUNET_OK == GNUNET_DISK_directory_create_for_file (fn)))
  {
    store_hello = GNUNET_NO;
    size = 0;
    cnt = 0;
    if (NULL != host->hello)
      (void) GNUNET_HELLO_iterate_addresses (host->hello,
                                             GNUNET_NO,
                                             &count_addresses,
                                             &cnt);
    if (cnt > 0)
    {
      store_hello = GNUNET_YES;
      size += GNUNET_HELLO_size (host->hello);
    }
    cnt = 0;
    if (NULL != host->friend_only_hello)
      (void) GNUNET_HELLO_iterate_addresses (host->friend_only_hello,
                                             GNUNET_NO,
                                             &count_addresses,
                                             &cnt);
    store_friend_hello = GNUNET_NO;
    if (0 < cnt)
    {
      store_friend_hello = GNUNET_YES;
      size += GNUNET_HELLO_size (host->friend_only_hello);
    }
 
    if ((GNUNET_NO == store_hello) && (GNUNET_NO == store_friend_hello))
    {
      /* no valid addresses, don't put HELLO on disk; in fact,
         if one exists on disk, remove it */
      (void) unlink (fn);
    }
    else
    {
      buffer = GNUNET_malloc (size);
      pos = 0;
 
      if (GNUNET_YES == store_hello)
      {
        GNUNET_memcpy (buffer, host->hello, GNUNET_HELLO_size (host->hello));
        pos += GNUNET_HELLO_size (host->hello);
      }
      if (GNUNET_YES == store_friend_hello)
      {
        GNUNET_memcpy (&buffer[pos],
                       host->friend_only_hello,
                       GNUNET_HELLO_size (host->friend_only_hello));
        pos += GNUNET_HELLO_size (host->friend_only_hello);
      }
      GNUNET_assert (pos == size);
 
      if (GNUNET_SYSERR ==
          GNUNET_DISK_fn_write (fn,
                                buffer,
                                size,
                                GNUNET_DISK_PERM_USER_READ
                                | GNUNET_DISK_PERM_USER_WRITE
                                | GNUNET_DISK_PERM_GROUP_READ
                                | GNUNET_DISK_PERM_OTHER_READ))
        GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "write", fn);
      else
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Stored %s %s HELLO in %s  with total size %u\n",
                    (GNUNET_YES == store_friend_hello) ? "friend-only" : "",
                    (GNUNET_YES == store_hello) ? "public" : "",
                    fn,
                    size);
      GNUNET_free (buffer);
    }
  }
  GNUNET_free (fn);
  notify_all (host);
}

References count_addresses(), delta, warningfilter::dest, HostEntry::friend_only_hello, get_host_filename(), GNUNET_assert, GNUNET_CONTAINER_multipeermap_get(), GNUNET_DISK_directory_create_for_file(), GNUNET_DISK_fn_write(), GNUNET_DISK_PERM_GROUP_READ, GNUNET_DISK_PERM_OTHER_READ, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_HELLO_equals(), GNUNET_HELLO_is_friend_only(), GNUNET_HELLO_iterate_addresses(), GNUNET_HELLO_merge(), GNUNET_HELLO_size(), GNUNET_i2s(), GNUNET_log, GNUNET_log_strerror_file, GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_TIME_absolute_get(), GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_YES, HostEntry::hello, hostmap, notify_all(), peer, size, and update_friend_hello().

Referenced by add_host_to_known_hosts(), handle_hello(), and hosts_directory_scan_callback().

Here is the call graph for this function:

Here is the caller graph for this function:

read_host_file()

static void read_host_file ( const char *  fn, int  unlink_garbage, struct ReadHostFileContext *  r  )

static

Try to read the HELLOs in the given filename and discard expired addresses.

Removes the file if one the HELLO is malformed. If all addresses are expired, the HELLO is also removed (but the HELLO with the public key is still returned if it was found and valid). The file can contain multiple HELLO messages.

Parameters

fn	name of the file
unlink_garbage	if GNUNET_YES, try to remove useless files
r	ReadHostFileContext to store the resutl

Definition at line 279 of file gnunet-service-peerinfo.c.

{
  char buffer[GNUNET_MAX_MESSAGE_SIZE - 1] GNUNET_ALIGN;
  ssize_t size_total;
  struct GNUNET_TIME_Absolute now;
  unsigned int left;
  const struct GNUNET_HELLO_Message *hello;
  struct GNUNET_HELLO_Message *hello_clean;
  size_t read_pos;
  uint16_t size_hello;
 
  r->friend_only_hello = NULL;
  r->hello = NULL;
 
  if (GNUNET_YES != GNUNET_DISK_file_test (fn))
    return;
  size_total = GNUNET_DISK_fn_read (fn, buffer, sizeof(buffer));
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Read %d bytes from `%s'\n",
              (int) size_total,
              fn);
  if ((size_total < 0) ||
      (((size_t) size_total) < sizeof(struct GNUNET_MessageHeader)))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to parse HELLO in file `%s': %s\n"),
                fn,
                "File has invalid size");
    if ((GNUNET_YES == unlink_garbage) && (0 != unlink (fn)) &&
        (ENOENT != errno))
      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", fn);
    return;
  }
 
  read_pos = 0;
  while (read_pos < (size_t) size_total)
  {
    hello = (const struct GNUNET_HELLO_Message *) &buffer[read_pos];
    size_hello = GNUNET_HELLO_size (hello);
    if ((0 == size_hello) || (((size_t) size_total) - read_pos < size_hello))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  _ ("Failed to parse HELLO in file `%s'\n"),
                  fn);
      if (0 == read_pos)
      {
        if ((GNUNET_YES == unlink_garbage) && (0 != unlink (fn)) &&
            (ENOENT != errno))
          GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", fn);
      }
      else
      {
        if ((GNUNET_YES == unlink_garbage) && (0 != truncate (fn, read_pos)) &&
            (ENOENT != errno))
          GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "truncate", fn);
      }
      return;
    }
 
    now = GNUNET_TIME_absolute_get ();
    hello_clean = GNUNET_HELLO_iterate_addresses (hello,
                                                  GNUNET_YES,
                                                  &discard_expired,
                                                  &now);
    if (NULL == hello_clean)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  _ ("Failed to parse HELLO in file `%s'\n"),
                  fn);
      if ((GNUNET_YES == unlink_garbage) && (0 != unlink (fn)) &&
          (ENOENT != errno))
        GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", fn);
      return;
    }
    left = 0;
    (void) GNUNET_HELLO_iterate_addresses (hello_clean,
                                           GNUNET_NO,
                                           &count_addresses,
                                           &left);
 
    if (0 == left)
    {
      GNUNET_free (hello_clean);
      break;
    }
 
    if (GNUNET_NO == GNUNET_HELLO_is_friend_only (hello_clean))
    {
      if (NULL == r->hello)
        r->hello = hello_clean;
      else
      {
        GNUNET_break (0);
        GNUNET_free (r->hello);
        r->hello = hello_clean;
      }
    }
    else
    {
      if (NULL == r->friend_only_hello)
        r->friend_only_hello = hello_clean;
      else
      {
        GNUNET_break (0);
        GNUNET_free (r->friend_only_hello);
        r->friend_only_hello = hello_clean;
      }
    }
    read_pos += size_hello;
  }
 
  if (0 == left)
  {
    /* no addresses left, remove from disk */
    if ((GNUNET_YES == unlink_garbage) && (0 != unlink (fn)))
      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", fn);
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Found `%s' and `%s' HELLO message in file\n",
              (NULL != r->hello) ? "public" : "NON-public",
              (NULL != r->friend_only_hello) ? "friend only"
              : "NO friend only");
}

References _, count_addresses(), discard_expired(), ReadHostFileContext::friend_only_hello, GNUNET_ALIGN, GNUNET_break, GNUNET_DISK_file_test(), GNUNET_DISK_fn_read(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_HELLO_is_friend_only(), GNUNET_HELLO_iterate_addresses(), GNUNET_HELLO_size(), GNUNET_log, GNUNET_log_strerror_file, GNUNET_MAX_MESSAGE_SIZE, GNUNET_NO, GNUNET_TIME_absolute_get(), GNUNET_YES, and ReadHostFileContext::hello.

Referenced by add_host_to_known_hosts(), and hosts_directory_scan_callback().

Here is the call graph for this function:

Here is the caller graph for this function:

add_host_to_known_hosts()

static struct HostEntry* add_host_to_known_hosts ( const struct GNUNET_PeerIdentity *  identity )

static

Add a host to the list and notify clients about this event.

Parameters

identity

the identity of the host

Returns

the HostEntry

Definition at line 413 of file gnunet-service-peerinfo.c.

{
  struct HostEntry *entry;
  struct ReadHostFileContext r;
  char *fn;
 
  entry = GNUNET_CONTAINER_multipeermap_get (hostmap, identity);
  if (NULL == entry)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Adding new peer `%s'\n",
                GNUNET_i2s (identity));
    GNUNET_STATISTICS_update (stats,
                              gettext_noop ("# peers known"),
                              1,
                              GNUNET_NO);
    entry = GNUNET_new (struct HostEntry);
    entry->identity = *identity;
    GNUNET_assert (GNUNET_OK ==
                   GNUNET_CONTAINER_multipeermap_put (
                     hostmap,
                     &entry->identity,
                     entry,
                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
    notify_all (entry);
    fn = get_host_filename (identity);
    if (NULL != fn)
    {
      read_host_file (fn, GNUNET_YES, &r);
      if (NULL != r.hello)
        update_hello (identity, r.hello);
      if (NULL != r.friend_only_hello)
        update_hello (identity, r.friend_only_hello);
      GNUNET_free (r.hello);
      GNUNET_free (r.friend_only_hello);
      GNUNET_free (fn);
    }
  }
  return entry;
}

References ReadHostFileContext::friend_only_hello, get_host_filename(), gettext_noop, GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_get(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_YES, ReadHostFileContext::hello, hostmap, identity, HostEntry::identity, notify_all(), read_host_file(), stats, and update_hello().

Referenced by handle_hello(), and hosts_directory_scan_callback().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_garbage()

static void remove_garbage ( const char *  fullname )

static

Remove a file that should not be there.

LOG success or failure.

Parameters

fullname

name of the file to remove

Definition at line 462 of file gnunet-service-peerinfo.c.

{
  if (0 == unlink (fullname))
    GNUNET_log (
      GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
      _ (
        "File `%s' in directory `%s' does not match naming convention. Removed.\n"),
      fullname,
      networkIdDirectory);
  else
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                              "unlink",
                              fullname);
}

References _, GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_log_strerror_file, and networkIdDirectory.

Referenced by hosts_directory_scan_callback().

Here is the caller graph for this function:

hosts_directory_scan_callback()

static int hosts_directory_scan_callback ( void *  cls, const char *  fullname  )

static

Function that is called on each HELLO file in a particular directory.

Try to parse the file and add the HELLO to our list.

Parameters

cls	pointer to 'unsigned int' to increment for each file, or NULL if the file is from a read-only, read-once resource directory
fullname	name of the file to parse

Returns

GNUNET_OK (continue iteration)

Definition at line 508 of file gnunet-service-peerinfo.c.

{
  struct DirScanContext *dsc = cls;
  struct GNUNET_PeerIdentity identity;
  struct ReadHostFileContext r;
  const char *filename;
  struct GNUNET_PeerIdentity id_public;
  struct GNUNET_PeerIdentity id_friend;
  struct GNUNET_PeerIdentity id;
 
  if (GNUNET_YES != GNUNET_DISK_file_test (fullname))
    return GNUNET_OK; /* ignore non-files */
 
  filename = strrchr (fullname, DIR_SEPARATOR);
  if ((NULL == filename) || (1 > strlen (filename)))
    filename = fullname;
  else
    filename++;
 
  read_host_file (fullname, dsc->remove_files, &r);
  if ((NULL == r.hello) && (NULL == r.friend_only_hello))
    return GNUNET_OK;
  if (NULL != r.friend_only_hello)
  {
    if (GNUNET_OK != GNUNET_HELLO_get_id (r.friend_only_hello, &id_friend))
    {
      if (GNUNET_YES == dsc->remove_files)
        remove_garbage (fullname);
      return GNUNET_OK;
    }
    id = id_friend;
  }
  if (NULL != r.hello)
  {
    if (GNUNET_OK != GNUNET_HELLO_get_id (r.hello, &id_public))
    {
      if (GNUNET_YES == dsc->remove_files)
        remove_garbage (fullname);
      return GNUNET_OK;
    }
    id = id_public;
  }
 
  if ((NULL != r.hello) && (NULL != r.friend_only_hello) &&
      (0 != GNUNET_memcmp (&id_friend, &id_public)))
  {
    /* HELLOs are not for the same peer */
    GNUNET_break (0);
    if (GNUNET_YES == dsc->remove_files)
      remove_garbage (fullname);
    return GNUNET_OK;
  }
  if (GNUNET_OK ==
      GNUNET_CRYPTO_eddsa_public_key_from_string (filename,
                                                  strlen (filename),
                                                  &identity.public_key))
  {
    if (0 != GNUNET_memcmp (&id, &identity))
    {
      /* HELLOs are not for the same peer */
      GNUNET_break (0);
      if (GNUNET_YES == dsc->remove_files)
        remove_garbage (fullname);
      return GNUNET_OK;
    }
  }
 
  /* ok, found something valid, remember HELLO */
  add_host_to_known_hosts (&id);
  if (NULL != r.hello)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Updating peer `%s' public HELLO \n",
                GNUNET_i2s (&id));
    update_hello (&id, r.hello);
    GNUNET_free (r.hello);
  }
  if (NULL != r.friend_only_hello)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Updating peer `%s' friend only HELLO \n",
                GNUNET_i2s (&id));
    update_hello (&id, r.friend_only_hello);
    GNUNET_free (r.friend_only_hello);
  }
  dsc->matched++;
  return GNUNET_OK;
}

References add_host_to_known_hosts(), DIR_SEPARATOR, filename, ReadHostFileContext::friend_only_hello, GNUNET_break, GNUNET_CRYPTO_eddsa_public_key_from_string(), GNUNET_DISK_file_test(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_HELLO_get_id(), GNUNET_i2s(), GNUNET_log, GNUNET_memcmp, GNUNET_OK, GNUNET_YES, ReadHostFileContext::hello, id, identity, DirScanContext::matched, read_host_file(), DirScanContext::remove_files, remove_garbage(), and update_hello().

Referenced by cron_scan_directory_data_hosts(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

cron_scan_directory_data_hosts()

static void cron_scan_directory_data_hosts ( void *  cls )

static

Call this method periodically to scan data/hosts for new hosts.

Parameters

cls

unused

Definition at line 604 of file gnunet-service-peerinfo.c.

{
  static unsigned int retries;
  struct DirScanContext dsc;
 
  (void) cls;
  cron_scan = NULL;
  if (GNUNET_SYSERR == GNUNET_DISK_directory_create (networkIdDirectory))
  {
    cron_scan =
      GNUNET_SCHEDULER_add_delayed_with_priority (DATA_HOST_FREQ,
                                                  GNUNET_SCHEDULER_PRIORITY_IDLE,
                                                  &
                                                  cron_scan_directory_data_hosts,
                                                  NULL);
    return;
  }
  dsc.matched = 0;
  dsc.remove_files = GNUNET_YES;
  GNUNET_log (GNUNET_ERROR_TYPE_INFO | GNUNET_ERROR_TYPE_BULK,
              _ ("Scanning directory `%s'\n"),
              networkIdDirectory);
  GNUNET_DISK_directory_scan (networkIdDirectory,
                              &hosts_directory_scan_callback,
                              &dsc);
  if ((0 == dsc.matched) && (0 == (++retries & 31)))
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
                _ ("Still no peers found in `%s'!\n"),
                networkIdDirectory);
  cron_scan =
    GNUNET_SCHEDULER_add_delayed_with_priority (DATA_HOST_FREQ,
                                                GNUNET_SCHEDULER_PRIORITY_IDLE,
                                                &cron_scan_directory_data_hosts,
                                                NULL);
}

References _, cron_scan, DATA_HOST_FREQ, GNUNET_DISK_directory_create(), GNUNET_DISK_directory_scan(), GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_SCHEDULER_add_delayed_with_priority(), GNUNET_SCHEDULER_PRIORITY_IDLE, GNUNET_SYSERR, GNUNET_YES, hosts_directory_scan_callback(), DirScanContext::matched, networkIdDirectory, and DirScanContext::remove_files.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

update_friend_hello()

static struct GNUNET_HELLO_Message* update_friend_hello ( const struct GNUNET_HELLO_Message *  hello, const struct GNUNET_HELLO_Message *  friend_hello  )

static

Update the HELLO of a friend by merging the addresses.

Parameters

hello	original hello
friend_hello	hello with additional addresses

Returns

merged HELLO

Definition at line 649 of file gnunet-service-peerinfo.c.

{
  struct GNUNET_HELLO_Message *res;
  struct GNUNET_HELLO_Message *tmp;
  struct GNUNET_PeerIdentity pid;
 
  if (NULL != friend_hello)
  {
    res = GNUNET_HELLO_merge (hello, friend_hello);
    GNUNET_assert (GNUNET_YES == GNUNET_HELLO_is_friend_only (res));
    return res;
  }
 
  if (GNUNET_OK != GNUNET_HELLO_get_id (hello, &pid))
  {
    GNUNET_break (0);
    return NULL;
  }
  tmp = GNUNET_HELLO_create (&pid.public_key, NULL, NULL, GNUNET_YES);
  res = GNUNET_HELLO_merge (hello, tmp);
  GNUNET_free (tmp);
  GNUNET_assert (GNUNET_YES == GNUNET_HELLO_is_friend_only (res));
  return res;
}

References GNUNET_assert, GNUNET_break, GNUNET_free, GNUNET_HELLO_create(), GNUNET_HELLO_get_id(), GNUNET_HELLO_is_friend_only(), GNUNET_HELLO_merge(), GNUNET_OK, GNUNET_YES, pid, GNUNET_PeerIdentity::public_key, and res.

Referenced by update_hello().

Here is the call graph for this function:

Here is the caller graph for this function:

add_to_tc()

static int add_to_tc ( void *  cls, const struct GNUNET_PeerIdentity *  key, void *  value  )

static

Do transmit info about peer to given host.

Parameters

cls	NULL to hit all hosts, otherwise specifies a particular target
key	hostID
value	information to transmit

Returns

GNUNET_YES (continue to iterate)

Definition at line 860 of file gnunet-service-peerinfo.c.

{
  struct TransmitContext *tc = cls;
  struct HostEntry *pos = value;
  struct InfoMessage *im;
  uint16_t hs;
  struct GNUNET_MQ_Envelope *env;
 
  hs = 0;
 
  if ((NULL != pos->hello) && (GNUNET_NO == tc->friend_only))
  {
    /* Copy public HELLO */
    hs = GNUNET_HELLO_size (pos->hello);
    GNUNET_assert (hs < GNUNET_MAX_MESSAGE_SIZE - sizeof(struct InfoMessage));
    env = GNUNET_MQ_msg_extra (im, hs, GNUNET_MESSAGE_TYPE_PEERINFO_INFO);
    GNUNET_memcpy (&im[1], pos->hello, hs);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Sending public HELLO with size %u for peer `%s'\n",
                hs,
                GNUNET_i2s (key));
  }
  else if ((NULL != pos->friend_only_hello) && (GNUNET_YES == tc->friend_only))
  {
    /* Copy friend only HELLO */
    hs = GNUNET_HELLO_size (pos->friend_only_hello);
    GNUNET_assert (hs < GNUNET_MAX_MESSAGE_SIZE - sizeof(struct InfoMessage));
    env = GNUNET_MQ_msg_extra (im, hs, GNUNET_MESSAGE_TYPE_PEERINFO_INFO);
    GNUNET_memcpy (&im[1], pos->friend_only_hello, hs);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Sending friend-only HELLO with size %u for peer `%s'\n",
                hs,
                GNUNET_i2s (key));
  }
  else
  {
    env = GNUNET_MQ_msg (im, GNUNET_MESSAGE_TYPE_PEERINFO_INFO);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Adding no HELLO for peer `%s'\n",
                GNUNET_i2s (key));
  }
  im->peer = pos->identity;
  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (tc->client), env);
  return GNUNET_YES;
}

References env, HostEntry::friend_only_hello, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_HELLO_size(), GNUNET_i2s(), GNUNET_log, GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_PEERINFO_INFO, GNUNET_MQ_msg, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_SERVICE_client_get_mq(), GNUNET_YES, HostEntry::hello, HostEntry::identity, key, InfoMessage::peer, tc, and value.

Referenced by handle_get(), handle_get_all(), and handle_notify().

Here is the call graph for this function:

Here is the caller graph for this function:

discard_hosts_helper()

static int discard_hosts_helper ( void *  cls, const char *  fn  )

static

delete expired HELLO entries in directory

Parameters

cls	pointer to current time (struct GNUNET_TIME_Absolute *)
fn	filename to test to see if the HELLO expired

Returns

GNUNET_OK (continue iteration)

Definition at line 915 of file gnunet-service-peerinfo.c.

{
  struct GNUNET_TIME_Absolute *now = cls;
  char buffer[GNUNET_MAX_MESSAGE_SIZE - 1] GNUNET_ALIGN;
  const struct GNUNET_HELLO_Message *hello;
  struct GNUNET_HELLO_Message *new_hello;
  int read_size;
  unsigned int cur_hello_size;
  unsigned int new_hello_size;
  int read_pos;
  int write_pos;
  unsigned int cnt;
  char *writebuffer;
  uint64_t fsize;
 
  if (GNUNET_OK != GNUNET_DISK_file_size (fn, &fsize, GNUNET_YES, GNUNET_YES))
  {
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING
                              | GNUNET_ERROR_TYPE_BULK,
                              "fstat",
                              fn);
    return GNUNET_OK;
  }
  read_size = GNUNET_DISK_fn_read (fn, buffer, sizeof(buffer));
 
  if ((read_size < (int) sizeof(struct GNUNET_MessageHeader)) ||
      (fsize > GNUNET_MAX_MESSAGE_SIZE))
  {
    if (0 != unlink (fn))
      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING
                                | GNUNET_ERROR_TYPE_BULK,
                                "unlink",
                                fn);
    return GNUNET_OK;
  }
 
  writebuffer = GNUNET_malloc (read_size);
  read_pos = 0;
  write_pos = 0;
  while (read_pos < read_size)
  {
    /* Check each HELLO */
    hello = (const struct GNUNET_HELLO_Message *) &buffer[read_pos];
    cur_hello_size = GNUNET_HELLO_size (hello);
    if (0 == cur_hello_size)
    {
      /* Invalid data, discard */
      if (0 != unlink (fn))
        GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING
                                  | GNUNET_ERROR_TYPE_BULK,
                                  "unlink",
                                  fn);
      GNUNET_free (writebuffer);
      return GNUNET_OK;
    }
    new_hello =
      GNUNET_HELLO_iterate_addresses (hello, GNUNET_YES, &discard_expired, now);
    cnt = 0;
    if (NULL != new_hello)
      (void) GNUNET_HELLO_iterate_addresses (hello,
                                             GNUNET_NO,
                                             &count_addresses,
                                             &cnt);
    if ((NULL != new_hello) && (0 < cnt))
    {
      /* Store new HELLO to write it when done */
      new_hello_size = GNUNET_HELLO_size (new_hello);
      GNUNET_memcpy (&writebuffer[write_pos], new_hello, new_hello_size);
      write_pos += new_hello_size;
    }
    read_pos += cur_hello_size;
    GNUNET_free (new_hello);
  }
 
  if (0 < write_pos)
  {
    (void) GNUNET_DISK_directory_remove (fn);
    GNUNET_assert (GNUNET_OK ==
                   GNUNET_DISK_fn_write (fn,
                                         writebuffer,
                                         write_pos,
                                         GNUNET_DISK_PERM_USER_READ
                                         | GNUNET_DISK_PERM_USER_WRITE
                                         | GNUNET_DISK_PERM_GROUP_READ
                                         | GNUNET_DISK_PERM_OTHER_READ));
  }
  else if (0 != unlink (fn))
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING
                              | GNUNET_ERROR_TYPE_BULK,
                              "unlink",
                              fn);
 
  GNUNET_free (writebuffer);
  return GNUNET_OK;
}

References count_addresses(), discard_expired(), GNUNET_ALIGN, GNUNET_assert, GNUNET_DISK_directory_remove(), GNUNET_DISK_file_size(), GNUNET_DISK_fn_read(), GNUNET_DISK_fn_write(), GNUNET_DISK_PERM_GROUP_READ, GNUNET_DISK_PERM_OTHER_READ, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_HELLO_iterate_addresses(), GNUNET_HELLO_size(), GNUNET_log_strerror_file, GNUNET_malloc, GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, GNUNET_NO, GNUNET_OK, and GNUNET_YES.

Referenced by cron_clean_data_hosts().

Here is the call graph for this function:

Here is the caller graph for this function:

cron_clean_data_hosts()

static void cron_clean_data_hosts ( void *  cls )

static

Call this method periodically to scan peerinfo/ for ancient HELLOs to expire.

Parameters

cls

unused

Definition at line 1019 of file gnunet-service-peerinfo.c.

{
  struct GNUNET_TIME_Absolute now;
 
  (void) cls;
  cron_clean = NULL;
  now = GNUNET_TIME_absolute_get ();
  GNUNET_log (GNUNET_ERROR_TYPE_INFO | GNUNET_ERROR_TYPE_BULK,
              _ ("Cleaning up directory `%s'\n"),
              networkIdDirectory);
  GNUNET_DISK_directory_scan (networkIdDirectory, &discard_hosts_helper, &now);
  cron_clean = GNUNET_SCHEDULER_add_delayed (DATA_HOST_CLEAN_FREQ,
                                             &cron_clean_data_hosts,
                                             NULL);
}

References _, cron_clean, DATA_HOST_CLEAN_FREQ, discard_hosts_helper(), GNUNET_DISK_directory_scan(), GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_absolute_get(), and networkIdDirectory.

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 *  hello  )

static

Check HELLO-message.

Parameters

cls	identification of the client
hello	the actual message

Returns

GNUNET_OK if hello is well-formed

Definition at line 1044 of file gnunet-service-peerinfo.c.

{
  struct GNUNET_PeerIdentity pid;
 
  (void) cls;
  if (GNUNET_OK != GNUNET_HELLO_get_id (hello, &pid))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, 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 *  hello  )

static

Handle HELLO-message.

Parameters

cls	identification of the client
hello	the actual message

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

{
  struct GNUNET_SERVICE_Client *client = cls;
  struct GNUNET_PeerIdentity pid;
 
  GNUNET_assert (GNUNET_OK == GNUNET_HELLO_get_id (hello, &pid));
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "HELLO message received for peer `%s'\n",
              GNUNET_i2s (&pid));
  add_host_to_known_hosts (&pid);
  update_hello (&pid, hello);
  GNUNET_SERVICE_client_continue (client);
}

References add_host_to_known_hosts(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_HELLO_get_id(), GNUNET_i2s(), GNUNET_log, GNUNET_OK, GNUNET_SERVICE_client_continue(), pid, and update_hello().

Here is the call graph for this function:

handle_get()

static void handle_get ( void *  cls, const struct ListPeerMessage *  lpm  )

static

Handle GET-message.

Parameters

cls	identification of the client
lpm	the actual message

Definition at line 1087 of file gnunet-service-peerinfo.c.

{
  struct GNUNET_SERVICE_Client *client = cls;
  struct TransmitContext tcx;
  struct GNUNET_MessageHeader *msg;
  struct GNUNET_MQ_Envelope *env;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "GET message received for peer `%s'\n",
              GNUNET_i2s (&lpm->peer));
  tcx.friend_only = ntohl (lpm->include_friend_only);
  tcx.client = client;
  GNUNET_CONTAINER_multipeermap_get_multiple (hostmap,
                                              &lpm->peer,
                                              &add_to_tc,
                                              &tcx);
  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_PEERINFO_INFO_END);
  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client), env);
  GNUNET_SERVICE_client_continue (client);
}

References add_to_tc(), TransmitContext::client, env, TransmitContext::friend_only, GNUNET_CONTAINER_multipeermap_get_multiple(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_PEERINFO_INFO_END, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_get_mq(), hostmap, ListPeerMessage::include_friend_only, msg, and ListPeerMessage::peer.

Here is the call graph for this function:

handle_get_all()

static void handle_get_all ( void *  cls, const struct ListAllPeersMessage *  lapm  )

static

Handle GET-ALL-message.

Parameters

cls	identification of the client
lapm	the actual message

Definition at line 1116 of file gnunet-service-peerinfo.c.

{
  struct GNUNET_SERVICE_Client *client = cls;
  struct TransmitContext tcx;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_MessageHeader *msg;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "GET_ALL message received\n");
  tcx.friend_only = ntohl (lapm->include_friend_only);
  tcx.client = client;
  GNUNET_CONTAINER_multipeermap_iterate (hostmap, &add_to_tc, &tcx);
  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_PEERINFO_INFO_END);
  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client), env);
  GNUNET_SERVICE_client_continue (client);
}

References add_to_tc(), TransmitContext::client, env, TransmitContext::friend_only, GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_PEERINFO_INFO_END, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_get_mq(), hostmap, ListAllPeersMessage::include_friend_only, and msg.

Here is the call graph for this function:

handle_notify()

static void handle_notify ( void *  cls, const struct NotifyMessage *  nm  )

static

Handle NOTIFY-message.

Parameters

cls	identification of the client
nm	the actual message

Definition at line 1140 of file gnunet-service-peerinfo.c.

{
  struct GNUNET_SERVICE_Client *client = cls;
  struct GNUNET_MQ_Handle *mq;
  struct TransmitContext tcx;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_MessageHeader *msg;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "NOTIFY message received\n");
  mq = GNUNET_SERVICE_client_get_mq (client);
  GNUNET_SERVICE_client_mark_monitor (client);
  if (ntohl (nm->include_friend_only))
    GNUNET_notification_context_add (notify_friend_only_list, mq);
  else
    GNUNET_notification_context_add (notify_list, mq);
  tcx.friend_only = ntohl (nm->include_friend_only);
  tcx.client = client;
  GNUNET_CONTAINER_multipeermap_iterate (hostmap, &add_to_tc, &tcx);
  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_PEERINFO_INFO_END);
  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client), env);
  GNUNET_SERVICE_client_continue (client);
}

References add_to_tc(), TransmitContext::client, env, TransmitContext::friend_only, GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_PEERINFO_INFO_END, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_notification_context_add(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_get_mq(), GNUNET_SERVICE_client_mark_monitor(), hostmap, NotifyMessage::include_friend_only, mq, msg, notify_friend_only_list, and notify_list.

Here is the call graph for this function:

client_connect_cb()

static void* client_connect_cb ( void *  cls, struct GNUNET_SERVICE_Client *  client, struct GNUNET_MQ_Handle *  mq  )

static

Client connect callback.

Parameters

cls	unused
client	server client
mq	for client

Returns

client

Definition at line 1173 of file gnunet-service-peerinfo.c.

{
  (void) cls;
  (void) mq;
  return client;
}

References mq.

client_disconnect_cb()

static void client_disconnect_cb ( void *  cls, struct GNUNET_SERVICE_Client *  client, void *  app_ctx  )

static

Client disconnect callback.

Parameters

cls	unused
client	server client
app_ctx	should be client

Definition at line 1191 of file gnunet-service-peerinfo.c.

{
  (void) cls;
  GNUNET_assert (app_ctx == client);
}

References GNUNET_assert.

free_host_entry()

static int free_host_entry ( void *  cls, const struct GNUNET_PeerIdentity *  key, void *  value  )

static

Release memory taken by a host entry.

Parameters

cls	NULL
key	key of the host entry
value	the struct HostEntry to free

Returns

GNUNET_YES (continue to iterate)

Definition at line 1209 of file gnunet-service-peerinfo.c.

{
  struct HostEntry *he = value;
 
  (void) cls;
  (void) key;
  GNUNET_free (he->hello);
  GNUNET_free (he->friend_only_hello);
  GNUNET_free (he);
  return GNUNET_YES;
}

References HostEntry::friend_only_hello, GNUNET_free, GNUNET_YES, HostEntry::hello, key, and value.

Referenced by shutdown_task().

Here is the caller graph for this function:

shutdown_task()

static void shutdown_task ( void *  cls )

static

Clean up our state.

Called during shutdown.

Parameters

cls

unused

Definition at line 1228 of file gnunet-service-peerinfo.c.

{
  (void) cls;
  GNUNET_notification_context_destroy (notify_list);
  notify_list = NULL;
  GNUNET_notification_context_destroy (notify_friend_only_list);
  notify_friend_only_list = NULL;
 
  GNUNET_CONTAINER_multipeermap_iterate (hostmap, &free_host_entry, NULL);
  GNUNET_CONTAINER_multipeermap_destroy (hostmap);
  if (NULL != stats)
  {
    GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
    stats = NULL;
  }
  if (NULL != cron_clean)
  {
    GNUNET_SCHEDULER_cancel (cron_clean);
    cron_clean = NULL;
  }
  if (NULL != cron_scan)
  {
    GNUNET_SCHEDULER_cancel (cron_scan);
    cron_scan = NULL;
  }
  if (NULL != networkIdDirectory)
  {
    GNUNET_free (networkIdDirectory);
    networkIdDirectory = NULL;
  }
}

References cron_clean, cron_scan, free_host_entry(), GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_free, GNUNET_NO, GNUNET_notification_context_destroy(), GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_destroy(), hostmap, networkIdDirectory, notify_friend_only_list, notify_list, and stats.

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, const struct GNUNET_CONFIGURATION_Handle *  cfg, struct GNUNET_SERVICE_Handle *  service  )

static

Start up peerinfo service.

Parameters

cls	closure
cfg	configuration to use
service	the initialized service

Definition at line 1269 of file gnunet-service-peerinfo.c.

{
  char *peerdir;
  char *ip;
  struct DirScanContext dsc;
  int noio;
  int use_included;
 
  (void) cls;
  (void) service;
  hostmap = GNUNET_CONTAINER_multipeermap_create (1024, GNUNET_YES);
  stats = GNUNET_STATISTICS_create ("peerinfo", cfg);
  notify_list = GNUNET_notification_context_create (0);
  notify_friend_only_list = GNUNET_notification_context_create (0);
  noio = GNUNET_CONFIGURATION_get_value_yesno (cfg, "peerinfo", "NO_IO");
  use_included = GNUNET_CONFIGURATION_get_value_yesno (cfg,
                                                       "peerinfo",
                                                       "USE_INCLUDED_HELLOS");
  if (GNUNET_SYSERR == use_included)
    use_included = GNUNET_NO;
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
  if (GNUNET_YES != noio)
  {
    GNUNET_assert (
      GNUNET_OK ==
      GNUNET_CONFIGURATION_get_value_filename (cfg,
                                               "peerinfo",
                                               "HOSTS",
                                               &networkIdDirectory));
    if (GNUNET_OK != GNUNET_DISK_directory_create (networkIdDirectory))
    {
      GNUNET_SCHEDULER_shutdown ();
      return;
    }
 
    cron_scan =
      GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
                                          &cron_scan_directory_data_hosts,
                                          NULL);
 
    cron_clean =
      GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
                                          &cron_clean_data_hosts,
                                          NULL);
    if (GNUNET_YES == use_included)
    {
      ip = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_DATADIR);
      GNUNET_asprintf (&peerdir, "%shellos", ip);
      GNUNET_free (ip);
 
      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                  _ ("Importing HELLOs from `%s'\n"),
                  peerdir);
      dsc.matched = 0;
      dsc.remove_files = GNUNET_NO;
 
      GNUNET_DISK_directory_scan (peerdir,
                                  &hosts_directory_scan_callback,
                                  &dsc);
      GNUNET_free (peerdir);
    }
    else
    {
      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                  _ ("Skipping import of included HELLOs\n"));
    }
  }
}

References _, cfg, cron_clean, cron_clean_data_hosts(), cron_scan, cron_scan_directory_data_hosts(), GNUNET_asprintf(), GNUNET_assert, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_CONTAINER_multipeermap_create(), GNUNET_DISK_directory_create(), GNUNET_DISK_directory_scan(), GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_notification_context_create(), GNUNET_OK, GNUNET_OS_installation_get_path(), GNUNET_OS_IPK_DATADIR, GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_add_with_priority(), GNUNET_SCHEDULER_PRIORITY_IDLE, GNUNET_SCHEDULER_shutdown(), GNUNET_STATISTICS_create(), GNUNET_SYSERR, GNUNET_YES, hostmap, hosts_directory_scan_callback(), DirScanContext::matched, networkIdDirectory, notify_friend_only_list, notify_list, DirScanContext::remove_files, service, shutdown_task(), and stats.

Here is the call graph for this function:

GNUNET_SERVICE_MAIN()

GNUNET_SERVICE_MAIN	(	"peerinfo"	,
		GNUNET_SERVICE_OPTION_NONE	,
		&	run,
		&	client_connect_cb,
		&	client_disconnect_cb,
		NULL	,
		GNUNET_MQ_hd_var_size(hello, GNUNET_MESSAGE_TYPE_HELLO, struct GNUNET_HELLO_Message, NULL)	,
		GNUNET_MQ_hd_fixed_size(get, GNUNET_MESSAGE_TYPE_PEERINFO_GET, struct ListPeerMessage, NULL)	,
		GNUNET_MQ_hd_fixed_size(get_all, GNUNET_MESSAGE_TYPE_PEERINFO_GET_ALL, struct ListAllPeersMessage, NULL)	,
		GNUNET_MQ_hd_fixed_size(notify, GNUNET_MESSAGE_TYPE_PEERINFO_NOTIFY, struct NotifyMessage, NULL)	,
		GNUNET_MQ_handler_end()
	)

Define "main" method using service macro.

Variable Documentation

hostmap

struct GNUNET_CONTAINER_MultiPeerMap* hostmap

static

The in-memory list of known hosts, mapping of host IDs to 'struct HostEntry*' values.

Definition at line 94 of file gnunet-service-peerinfo.c.

Referenced by add_host_to_known_hosts(), handle_get(), handle_get_all(), handle_notify(), run(), shutdown_task(), and update_hello().

notify_list

struct GNUNET_NotificationContext* notify_list

static

Clients to immediately notify about all changes.

Definition at line 99 of file gnunet-service-peerinfo.c.

Referenced by handle_notify(), notify_all(), run(), and shutdown_task().

notify_friend_only_list

struct GNUNET_NotificationContext* notify_friend_only_list

static

Clients to immediately notify about all changes, even for friend-only HELLOs.

Definition at line 105 of file gnunet-service-peerinfo.c.

Referenced by handle_notify(), notify_all(), run(), and shutdown_task().

networkIdDirectory

char* networkIdDirectory

static

Directory where the hellos are stored in (peerinfo/)

Definition at line 110 of file gnunet-service-peerinfo.c.

Referenced by cron_clean_data_hosts(), cron_scan_directory_data_hosts(), get_host_filename(), remove_garbage(), run(), and shutdown_task().

stats

struct GNUNET_STATISTICS_Handle* stats

static

Handle for reporting statistics.

Definition at line 115 of file gnunet-service-peerinfo.c.

Referenced by add_host_to_known_hosts(), run(), and shutdown_task().

cron_clean

struct GNUNET_SCHEDULER_Task* cron_clean

static

Handle for task to run cron_clean_data_hosts()

Definition at line 120 of file gnunet-service-peerinfo.c.

Referenced by cron_clean_data_hosts(), run(), and shutdown_task().

cron_scan

struct GNUNET_SCHEDULER_Task* cron_scan

static

Handle for task to run cron_scan_directory_data_hosts()

Definition at line 125 of file gnunet-service-peerinfo.c.

Referenced by cron_scan_directory_data_hosts(), run(), and shutdown_task().