ng

7 files changed, 1533 insertions, 0 deletions

diff --git a/src/peerinfo/Makefile.am b/src/peerinfo/Makefile.am
new file mode 100644
index 000000000..294ff5cca
--- /dev/null
+++ b/src/peerinfo/Makefile.am
@@ -0,0 +1,56 @@
+INCLUDES = -I$(top_srcdir)/src/include
+
+if MINGW
+ WINFLAGS = -Wl,--no-undefined -Wl,--export-all-symbols -lole32 -lshell32 -luuid -liconv -lstdc++ -lcomdlg32 -lgdi32
+endif
+
+if USE_COVERAGE
+  AM_CFLAGS = -fprofile-arcs -ftest-coverage
+endif
+
+lib_LTLIBRARIES = libgnunetpeerinfo.la
+
+libgnunetpeerinfo_la_SOURCES = \
+  peerinfo_api.c peerinfo.h
+libgnunetpeerinfo_la_LIBADD = \
+  $(top_builddir)/src/hello/libgnunethello.la \
+  $(top_builddir)/src/util/libgnunetutil.la 
+libgnunetpeerinfo_la_LDFLAGS = \
+  $(GN_LIB_LDFLAGS) $(WINFLAGS) \
+  -version-info 0:0:0
+
+
+bin_PROGRAMS = \
+ gnunet-peerinfo \
+ gnunet-service-peerinfo
+
+gnunet_peerinfo_SOURCES = \
+ gnunet-peerinfo.c         
+gnunet_peerinfo_LDADD = \
+  $(top_builddir)/src/peerinfo/libgnunetpeerinfo.la \
+  $(top_builddir)/src/util/libgnunetutil.la 
+
+gnunet_service_peerinfo_SOURCES = \
+ gnunet-service-peerinfo.c         
+gnunet_service_peerinfo_LDADD = \
+  $(top_builddir)/src/hello/libgnunethello.la \
+  $(top_builddir)/src/util/libgnunetutil.la 
+
+
+check_PROGRAMS = \
+ test_peerinfo_api
+
+TESTS = $(check_PROGRAMS) # $(check_SCRIPTS)
+
+test_peerinfo_api_SOURCES = \
+ test_peerinfo_api.c
+test_peerinfo_api_LDADD = \
+ $(top_builddir)/src/hello/libgnunethello.la \
+ $(top_builddir)/src/peerinfo/libgnunetpeerinfo.la \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+EXTRA_DIST = \
+  test_peerinfo_api_data.conf 
+
+#check_SCRIPTS = \
+#  test_gnunet_peerinfo.sh
diff --git a/src/peerinfo/gnunet-peerinfo.c b/src/peerinfo/gnunet-peerinfo.c
new file mode 100644
index 000000000..6c737c88a
--- /dev/null
+++ b/src/peerinfo/gnunet-peerinfo.c
@@ -0,0 +1,152 @@
+/*
+     This file is part of GNUnet.
+     (C) 2001, 2002, 2003, 2004, 2006, 2009 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 2, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file peerinfo/gnunet-peerinfo.c
+ * @brief Print information about other known peers.
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_crypto_lib.h"
+#include "gnunet_configuration_lib.h"
+#include "gnunet_getopt_lib.h"
+#include "gnunet_peerinfo_service.h"
+#include "gnunet_program_lib.h"
+
+static int no_resolve;
+
+static int be_quiet;
+
+static int get_self;
+
+/**
+ * Print information about the peer.
+ * Currently prints the GNUNET_PeerIdentity, trust and the IP.
+ * Could of course do more (e.g. resolve via DNS).
+ */
+static void
+print_peer_info (void *cls,
+                 const struct GNUNET_PeerIdentity *peer,
+                 const struct GNUNET_HELLO_Message *hello, uint32_t trust)
+{
+  struct GNUNET_CRYPTO_HashAsciiEncoded enc;
+
+  /* FIXME: add printing of address information!
+     => need extended transport API! */
+  GNUNET_CRYPTO_hash_to_enc (&peer->hashPubKey, &enc);
+  if (be_quiet)
+    printf ("%s\n", (const char *) &enc);
+  else
+    printf (_("Peer `%s' with trust %8u\n"), (const char *) &enc, trust);
+}
+
+/**
+ * Main function that will be run by the scheduler.
+ *
+ * @param cls closure
+ * @param sched the scheduler to use
+ * @param args remaining command-line arguments
+ * @param cfgfile name of the configuration file used (for saving, can be NULL!)
+ * @param cfg configuration
+ */
+static void
+run (void *cls,
+     struct GNUNET_SCHEDULER_Handle *sched,
+     char *const *args,
+     const char *cfgfile, struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  struct GNUNET_CRYPTO_RsaPrivateKey *priv;
+  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pub;
+  struct GNUNET_PeerIdentity pid;
+  struct GNUNET_CRYPTO_HashAsciiEncoded enc;
+  char *fn;
+
+  if (get_self != GNUNET_YES)
+    {
+      GNUNET_PEERINFO_for_all (cfg,
+                               sched,
+                               NULL,
+                               0,
+                               GNUNET_TIME_relative_multiply
+                               (GNUNET_TIME_UNIT_SECONDS, 30),
+                               &print_peer_info, NULL);
+    }
+  else
+    {
+      if (GNUNET_OK !=
+          GNUNET_CONFIGURATION_get_value_filename (cfg,
+                                                   "GNUNET",
+                                                   "HOSTKEYFILE", &fn))
+        return;
+      priv = GNUNET_CRYPTO_rsa_key_create_from_file (fn);
+      if (priv == NULL)
+        {
+          fprintf (stderr, _("Loading hostkey from `%s' failed.\n"), fn);
+          GNUNET_free (fn);
+          return;
+        }
+      GNUNET_free (fn);
+      GNUNET_CRYPTO_rsa_key_get_public (priv, &pub);
+      GNUNET_CRYPTO_rsa_key_free (priv);
+      GNUNET_CRYPTO_hash (&pub, sizeof (pub), &pid.hashPubKey);
+      GNUNET_CRYPTO_hash_to_enc (&pid.hashPubKey, &enc);
+      if (be_quiet)
+        printf ("%s\n", (char *) &enc);
+      else
+        printf (_("I am peer `%s'.\n"), (const char *) &enc);
+    }
+}
+
+
+/**
+ * gnunet-peerinfo command line options
+ */
+static struct GNUNET_GETOPT_CommandLineOption options[] = {
+  {'n', "numeric", NULL,
+   gettext_noop ("don't resolve host names"),
+   0, &GNUNET_GETOPT_set_one, &no_resolve},
+  {'q', "quiet", NULL,
+   gettext_noop ("output only the identity strings"),
+   0, &GNUNET_GETOPT_set_one, &be_quiet},
+  {'s', "self", NULL,
+   gettext_noop ("output our own identity only"),
+   0, &GNUNET_GETOPT_set_one, &get_self},
+  GNUNET_GETOPT_OPTION_END
+};
+
+/**
+ * The main function to obtain peer information.
+ *
+ * @param argc number of arguments from the command line
+ * @param argv command line arguments
+ * @return 0 ok, 1 on error
+ */
+int
+main (int argc, char *const *argv)
+{
+  return (GNUNET_OK ==
+          GNUNET_PROGRAM_run (argc,
+                              argv,
+                              "gnunet-peerinfo",
+                              gettext_noop ("Print information about peers."),
+                              options, &run, NULL)) ? 0 : 1;
+}
+
+/* end of gnunet-peerinfo.c */
diff --git a/src/peerinfo/gnunet-service-peerinfo.c b/src/peerinfo/gnunet-service-peerinfo.c
new file mode 100644
index 000000000..b81c7b6ee
--- /dev/null
+++ b/src/peerinfo/gnunet-service-peerinfo.c
@@ -0,0 +1,708 @@
+/*
+     This file is part of GNUnet.
+     (C) 2001, 2002, 2004, 2005, 2007, 2009 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 2, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file peerinfo/gnunet-service-peerinfo.c
+ * @brief maintains list of known peers
+ *
+ * Code to maintain the list of currently known hosts (in memory
+ * structure of data/hosts/ and data/credit/).
+ *
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include "gnunet_crypto_lib.h"
+#include "gnunet_disk_lib.h"
+#include "gnunet_hello_lib.h"
+#include "gnunet_protocols.h"
+#include "gnunet_service_lib.h"
+#include "peerinfo.h"
+
+/**
+ * How often do we scan the HOST_DIR for new entries?
+ */
+#define DATA_HOST_FREQ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
+
+/**
+ * How often do we flush trust values to disk?
+ */
+#define TRUST_FLUSH_FREQ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
+
+/**
+ * How often do we discard old entries in data/hosts/?
+ */
+#define DATA_HOST_CLEAN_FREQ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 60)
+
+/**
+ * In-memory cache of known hosts.
+ */
+struct HostEntry
+{
+
+  /**
+   * This is a linked list.
+   */
+  struct HostEntry *next;
+
+  /**
+   * Identity of the peer.
+   */
+  struct GNUNET_PeerIdentity identity;
+
+  /**
+   * Hello for the peer (can be NULL)
+   */
+  struct GNUNET_HELLO_Message *hello;
+
+  /**
+   * Trust rating for this peer
+   */
+  uint32_t trust;
+
+  /**
+   * Trust rating for this peer on disk.
+   */
+  uint32_t disk_trust;
+
+};
+
+/**
+ * The in-memory list of known hosts.
+ */
+static struct HostEntry *hosts;
+
+/**
+ * Directory where the hellos are stored in (data/hosts)
+ */
+static char *networkIdDirectory;
+
+/**
+ * Where do we store trust information?
+ */
+static char *trustDirectory;
+
+
+/**
+ * Address iterator that causes expired entries to be discarded.
+ *
+ * @param cls pointer to the current time
+ * @return GNUNET_NO if expiration smaller than the current time
+ */
+static int
+discard_expired (void *cls,
+                 const char *tname,
+                 struct GNUNET_TIME_Absolute expiration,
+                 const void *addr, size_t addrlen)
+{
+  const struct GNUNET_TIME_Absolute *now = cls;
+  if (now->value > expiration.value)
+    return GNUNET_NO;
+  return GNUNET_OK;
+}
+
+
+/**
+ * Get the filename under which we would store the GNUNET_HELLO_Message
+ * for the given host and protocol.
+ * @return filename of the form DIRECTORY/HOSTID
+ */
+static char *
+get_host_filename (const struct GNUNET_PeerIdentity *id)
+{
+  struct GNUNET_CRYPTO_HashAsciiEncoded fil;
+  char *fn;
+
+  GNUNET_CRYPTO_hash_to_enc (&id->hashPubKey, &fil);
+  GNUNET_asprintf (&fn,
+                   "%s%s%s", networkIdDirectory, DIR_SEPARATOR_STR, &fil);
+  return fn;
+}
+
+
+/**
+ * Get the filename under which we would store the GNUNET_HELLO_Message
+ * for the given host and protocol.
+ * @return filename of the form DIRECTORY/HOSTID
+ */
+static char *
+get_trust_filename (const struct GNUNET_PeerIdentity *id)
+{
+  struct GNUNET_CRYPTO_HashAsciiEncoded fil;
+  char *fn;
+
+  GNUNET_CRYPTO_hash_to_enc (&id->hashPubKey, &fil);
+  GNUNET_asprintf (&fn, "%s%s%s", trustDirectory, DIR_SEPARATOR_STR, &fil);
+  return fn;
+}
+
+/**
+ * Find the host entry for the given peer.  Call
+ * only when synchronized!
+ * @return NULL if not found
+ */
+static struct HostEntry *
+lookup_host_entry (const struct GNUNET_PeerIdentity *id)
+{
+  struct HostEntry *pos;
+
+  pos = hosts;
+  while ((pos != NULL) &&
+         (0 !=
+          memcmp (id, &pos->identity, sizeof (struct GNUNET_PeerIdentity))))
+    pos = pos->next;
+  return pos;
+}
+
+
+/**
+ * Add a host to the list.
+ *
+ * @param identity the identity of the host
+ * @param protocol the protocol for the host
+ */
+static void
+add_host_to_known_hosts (const struct GNUNET_PeerIdentity *identity)
+{
+  struct HostEntry *entry;
+  char *fn;
+  uint32_t trust;
+  char buffer[GNUNET_SERVER_MAX_MESSAGE_SIZE];
+  const struct GNUNET_HELLO_Message *hello;
+  struct GNUNET_HELLO_Message *hello_clean;
+  int size;
+  struct GNUNET_TIME_Absolute now;
+
+  entry = lookup_host_entry (identity);
+  if (entry != NULL)
+    return;
+  entry = GNUNET_malloc (sizeof (struct HostEntry));
+  entry->identity = *identity;
+  fn = get_trust_filename (identity);
+  if ((GNUNET_DISK_file_test (fn) == GNUNET_YES) &&
+      (sizeof (trust) == GNUNET_DISK_file_read (fn, sizeof (trust), &trust)))
+    entry->disk_trust = entry->trust = ntohl (trust);
+  GNUNET_free (fn);
+
+  fn = get_host_filename (identity);
+  if (GNUNET_DISK_file_test (fn) == GNUNET_YES)
+    {
+      size = GNUNET_DISK_file_read (fn, sizeof (buffer), buffer);
+      hello = (const struct GNUNET_HELLO_Message *) buffer;
+      now = GNUNET_TIME_absolute_get ();
+      hello_clean = GNUNET_HELLO_iterate_addresses (hello,
+                                                    GNUNET_YES,
+                                                    &discard_expired, &now);
+      entry->hello = hello_clean;
+    }
+  GNUNET_free (fn);
+  entry->next = hosts;
+  hosts = entry;
+}
+
+
+/**
+ * Increase the host credit by a value.
+ *
+ * @param hostId is the identity of the host
+ * @param value is the int value by which the
+ *  host credit is to be increased or decreased
+ * @returns the actual change in trust (positive or negative)
+ */
+static int
+change_host_trust (const struct GNUNET_PeerIdentity *hostId, int value)
+{
+  struct HostEntry *host;
+
+  if (value == 0)
+    return 0;
+  host = lookup_host_entry (hostId);
+  if (host == NULL)
+    {
+      add_host_to_known_hosts (hostId);
+      host = lookup_host_entry (hostId);
+    }
+  GNUNET_assert (host != NULL);
+  if (value > 0)
+    {
+      if (host->trust + value < host->trust)
+        {
+          value = ((uint32_t) - 1) - host->trust;
+          host->trust = (uint32_t) - 1; /* maximized */
+        }
+      else
+        host->trust += value;
+    }
+  else
+    {
+      if (host->trust < -value)
+        {
+          value = -host->trust;
+          host->trust = 0;
+        }
+      else
+        host->trust += value;
+    }
+  return value;
+}
+
+
+/**
+ * Remove a file that should not be there.  LOG
+ * success or failure.
+ */
+static void
+remove_garbage (const char *fullname)
+{
+  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);
+}
+
+
+static int
+hosts_directory_scan_callback (void *cls, const char *fullname)
+{
+  unsigned int *matched = cls;
+  struct GNUNET_PeerIdentity identity;
+  const char *filename;
+
+  if (GNUNET_DISK_file_test (fullname) != GNUNET_YES)
+    return GNUNET_OK;           /* ignore non-files */
+  if (strlen (fullname) < sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded))
+    {
+      remove_garbage (fullname);
+      return GNUNET_OK;
+    }
+  filename =
+    &fullname[strlen (fullname) -
+              sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) + 1];
+  if (filename[-1] != DIR_SEPARATOR)
+    {
+      remove_garbage (fullname);
+      return GNUNET_OK;
+    }
+  if (GNUNET_OK != GNUNET_CRYPTO_hash_from_string (filename,
+                                                   &identity.hashPubKey))
+    {
+      remove_garbage (fullname);
+      return GNUNET_OK;
+    }
+  (*matched)++;
+  add_host_to_known_hosts (&identity);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Call this method periodically to scan data/hosts for new hosts.
+ */
+static void
+cron_scan_directory_data_hosts (void *cls,
+                                const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  static unsigned int retries;
+  unsigned int count;
+
+  count = 0;
+  GNUNET_DISK_directory_scan (networkIdDirectory,
+                              &hosts_directory_scan_callback, &count);
+  if ((0 == count) && (0 == (++retries & 31)))
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING |
+                GNUNET_ERROR_TYPE_BULK,
+                _("Still no peers found in `%s'!\n"), networkIdDirectory);
+  GNUNET_SCHEDULER_add_delayed (tc->sched,
+                                GNUNET_NO,
+                                GNUNET_SCHEDULER_PRIORITY_KEEP,
+                                GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                DATA_HOST_FREQ,
+                                &cron_scan_directory_data_hosts, NULL);
+}
+
+
+/**
+ * Bind a host address (hello) to a hostId.
+ *
+ * @param peer the peer for which this is a hello
+ * @param hello the verified (!) hello message
+ */
+static void
+bind_address (const struct GNUNET_PeerIdentity *peer,
+              const struct GNUNET_HELLO_Message *hello)
+{
+  char *fn;
+  struct HostEntry *host;
+  struct GNUNET_HELLO_Message *mrg;
+
+  add_host_to_known_hosts (peer);
+  host = lookup_host_entry (peer);
+  GNUNET_assert (host != NULL);
+  if (host->hello == NULL)
+    {
+      host->hello = GNUNET_malloc (GNUNET_HELLO_size (hello));
+      memcpy (host->hello, hello, GNUNET_HELLO_size (hello));
+    }
+  else
+    {
+      mrg = GNUNET_HELLO_merge (host->hello, hello);
+      GNUNET_free (host->hello);
+      host->hello = mrg;
+    }
+  fn = get_host_filename (peer);
+  GNUNET_DISK_file_write (fn, host->hello, GNUNET_HELLO_size (hello), "644");
+  GNUNET_free (fn);
+}
+
+
+/**
+ * Do transmit info either for only the host matching the given
+ * argument or for all known hosts and change their trust values by
+ * the given delta.
+ *
+ * @param only NULL to hit all hosts
+ */
+static void
+send_to_each_host (const struct GNUNET_PeerIdentity *only,
+                   int trust_change,
+                   struct GNUNET_SERVER_Client *client,
+                   struct GNUNET_SERVER_Handle *server)
+{
+  struct HostEntry *pos;
+  struct InfoMessage *im;
+  const struct GNUNET_MessageHeader *end;
+  uint16_t hs;
+  char buf[GNUNET_SERVER_MAX_MESSAGE_SIZE];
+  struct GNUNET_SERVER_TransmitContext *tc;
+
+  tc = GNUNET_SERVER_transmit_context_create (client);
+  pos = hosts;
+  while (pos != NULL)
+    {
+      if ((only == NULL) ||
+          (0 ==
+           memcmp (only, &pos->identity,
+                   sizeof (struct GNUNET_PeerIdentity))))
+        {
+          change_host_trust (&pos->identity, trust_change);
+          hs = 0;
+          im = (struct InfoMessage *) buf;
+          if (pos->hello != NULL)
+            {
+              hs = GNUNET_HELLO_size (pos->hello);
+              GNUNET_assert (hs <
+                             GNUNET_SERVER_MAX_MESSAGE_SIZE -
+                             sizeof (struct InfoMessage));
+              memcpy (&im[1], pos->hello, hs);
+            }
+          im->trust = htonl (pos->trust);
+          im->peer = pos->identity;
+          end = &im->header;
+          GNUNET_SERVER_transmit_context_append (tc,
+                                                 &end[1],
+                                                 hs +
+                                                 sizeof (struct InfoMessage) -
+                                                 sizeof (struct
+                                                         GNUNET_MessageHeader),
+                                                 GNUNET_MESSAGE_TYPE_PEERINFO_INFO);
+        }
+      pos = pos->next;
+    }
+  GNUNET_SERVER_transmit_context_append (tc, NULL, 0,
+                                         GNUNET_MESSAGE_TYPE_PEERINFO_INFO_END);
+  GNUNET_SERVER_transmit_context_run (tc, GNUNET_TIME_UNIT_FOREVER_REL);
+}
+
+
+/**
+ * Write host-trust information to a file - flush the buffer entry!
+ * Assumes synchronized access.
+ */
+static void
+flush_trust (struct HostEntry *host)
+{
+  char *fn;
+  uint32_t trust;
+
+  if (host->trust == host->disk_trust)
+    return;                     /* unchanged */
+  fn = get_trust_filename (&host->identity);
+  if (host->trust == 0)
+    {
+      if ((0 != UNLINK (fn)) && (errno != ENOENT))
+        GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING |
+                                  GNUNET_ERROR_TYPE_BULK, "unlink", fn);
+    }
+  else
+    {
+      trust = htonl (host->trust);
+      if (GNUNET_OK ==
+          GNUNET_DISK_file_write (fn, &trust, sizeof (uint32_t), "644"))
+        host->disk_trust = host->trust;
+    }
+  GNUNET_free (fn);
+}
+
+/**
+ * Call this method periodically to scan data/hosts for new hosts.
+ */
+static void
+cron_flush_trust (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct HostEntry *pos;
+
+  pos = hosts;
+  while (pos != NULL)
+    {
+      flush_trust (pos);
+      pos = pos->next;
+    }
+  if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
+    GNUNET_SCHEDULER_add_delayed (tc->sched,
+                                  GNUNET_YES,
+                                  GNUNET_SCHEDULER_PRIORITY_KEEP,
+                                  GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                  TRUST_FLUSH_FREQ, &cron_flush_trust, NULL);
+}
+
+
+/**
+ * @brief delete expired HELLO entries in data/hosts/
+ */
+static int
+discard_hosts_helper (void *cls, const char *fn)
+{
+  struct GNUNET_TIME_Absolute *now = cls;
+  char buffer[GNUNET_SERVER_MAX_MESSAGE_SIZE];
+  const struct GNUNET_HELLO_Message *hello;
+  struct GNUNET_HELLO_Message *new_hello;
+  int size;
+
+  size = GNUNET_DISK_file_read (fn, sizeof (buffer), buffer);
+  if ((size < sizeof (struct GNUNET_MessageHeader)) && (0 != UNLINK (fn)))
+    {
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING |
+                                GNUNET_ERROR_TYPE_BULK, "unlink", fn);
+      return GNUNET_OK;
+    }
+  hello = (const struct GNUNET_HELLO_Message *) buffer;
+  new_hello = GNUNET_HELLO_iterate_addresses (hello,
+                                              GNUNET_YES,
+                                              &discard_expired, now);
+  if ((new_hello == NULL) && (0 != UNLINK (fn)))
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING |
+                              GNUNET_ERROR_TYPE_BULK, "unlink", fn);
+  if (new_hello != NULL)
+    {
+      GNUNET_DISK_file_write (fn,
+                              new_hello,
+                              GNUNET_HELLO_size (new_hello), "644");
+      GNUNET_free (new_hello);
+    }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Call this method periodically to scan data/hosts for new hosts.
+ */
+static void
+cron_clean_data_hosts (void *cls,
+                       const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_TIME_Absolute now;
+
+  now = GNUNET_TIME_absolute_get ();
+  GNUNET_DISK_directory_scan (networkIdDirectory,
+                              &discard_hosts_helper, &now);
+
+  GNUNET_SCHEDULER_add_delayed (tc->sched,
+                                GNUNET_NO,
+                                GNUNET_SCHEDULER_PRIORITY_KEEP,
+                                GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                DATA_HOST_CLEAN_FREQ,
+                                &cron_clean_data_hosts, NULL);
+}
+
+
+/**
+ * Handle ADD-message.
+ *
+ * @param cls closure
+ * @param server the server handling the message
+ * @param client identification of the client
+ * @param message the actual message
+ */
+static void
+handle_add (void *cls,
+            struct GNUNET_SERVER_Handle *server,
+            struct GNUNET_SERVER_Client *client,
+            const struct GNUNET_MessageHeader *message)
+{
+  const struct PeerAddMessage *pam;
+  const struct GNUNET_MessageHeader *hello;
+  uint16_t size;
+
+  size = ntohs (message->size);
+  if (size <
+      sizeof (struct PeerAddMessage) + sizeof (struct GNUNET_MessageHeader))
+    {
+      GNUNET_break (0);
+      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+      return;
+    }
+  pam = (const struct PeerAddMessage *) message;
+  hello = (const struct GNUNET_MessageHeader *) &pam[1];
+  if (size != sizeof (struct PeerAddMessage) + ntohs (hello->size))
+    {
+      GNUNET_break (0);
+      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+      return;
+    }
+  bind_address (&pam->peer, (const struct GNUNET_HELLO_Message *) hello);
+  GNUNET_SERVER_receive_done (client, GNUNET_OK);
+}
+
+
+/**
+ * Handle GET-message.
+ *
+ * @param cls closure
+ * @param server the server handling the message
+ * @param client identification of the client
+ * @param message the actual message
+ */
+static void
+handle_get (void *cls,
+            struct GNUNET_SERVER_Handle *server,
+            struct GNUNET_SERVER_Client *client,
+            const struct GNUNET_MessageHeader *message)
+{
+  const struct ListPeerMessage *lpm;
+
+  lpm = (const struct ListPeerMessage *) message;
+  send_to_each_host (&lpm->peer, ntohl (lpm->trust_change), client, server);
+}
+
+
+/**
+ * Handle GET-ALL-message.
+ *
+ * @param cls closure
+ * @param server the server handling the message
+ * @param client identification of the client
+ * @param message the actual message
+ */
+static void
+handle_get_all (void *cls,
+                struct GNUNET_SERVER_Handle *server,
+                struct GNUNET_SERVER_Client *client,
+                const struct GNUNET_MessageHeader *message)
+{
+  const struct ListAllPeersMessage *lpm;
+
+  lpm = (const struct ListAllPeersMessage *) message;
+  send_to_each_host (NULL, ntohl (lpm->trust_change), client, server);
+}
+
+
+/**
+ * List of handlers for the messages understood by this
+ * service.
+ */
+static struct GNUNET_SERVER_MessageHandler handlers[] = {
+  {&handle_add, NULL, GNUNET_MESSAGE_TYPE_PEERINFO_ADD, 0},
+  {&handle_get, NULL, GNUNET_MESSAGE_TYPE_PEERINFO_GET,
+   sizeof (struct ListPeerMessage)},
+  {&handle_get_all, NULL, GNUNET_MESSAGE_TYPE_PEERINFO_GET_ALL,
+   sizeof (struct ListAllPeersMessage)},
+  {NULL, NULL, 0, 0}
+};
+
+
+/**
+ * Process statistics requests.
+ *
+ * @param cls closure
+ * @param sched scheduler to use
+ * @param server the initialized server
+ * @param cfg configuration to use
+ */
+static void
+run (void *cls,
+     struct GNUNET_SCHEDULER_Handle *sched,
+     struct GNUNET_SERVER_Handle *server,
+     struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONFIGURATION_get_value_filename (cfg,
+                                                          "peerinfo",
+                                                          "HOSTS",
+                                                          &networkIdDirectory));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONFIGURATION_get_value_filename (cfg,
+                                                          "peerinfo",
+                                                          "TRUST",
+                                                          &trustDirectory));
+  GNUNET_DISK_directory_create (networkIdDirectory);
+  GNUNET_DISK_directory_create (trustDirectory);
+  GNUNET_SCHEDULER_add_delayed (sched,
+                                GNUNET_NO,
+                                GNUNET_SCHEDULER_PRIORITY_IDLE,
+                                GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                GNUNET_TIME_UNIT_MILLISECONDS,
+                                &cron_scan_directory_data_hosts, NULL);
+  GNUNET_SCHEDULER_add_delayed (sched,
+                                GNUNET_YES,
+                                GNUNET_SCHEDULER_PRIORITY_HIGH,
+                                GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                TRUST_FLUSH_FREQ, &cron_flush_trust, NULL);
+  GNUNET_SCHEDULER_add_delayed (sched,
+                                GNUNET_NO,
+                                GNUNET_SCHEDULER_PRIORITY_IDLE,
+                                GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                DATA_HOST_CLEAN_FREQ,
+                                &cron_clean_data_hosts, NULL);
+  GNUNET_SERVER_add_handlers (server, handlers);
+}
+
+
+/**
+ * The main function for the statistics service.
+ *
+ * @param argc number of arguments from the command line
+ * @param argv command line arguments
+ * @return 0 ok, 1 on error
+ */
+int
+main (int argc, char *const *argv)
+{
+  return (GNUNET_OK ==
+          GNUNET_SERVICE_run (argc,
+                              argv,
+                              "peerinfo", &run, NULL, NULL, NULL)) ? 0 : 1;
+}
+
+
+/* end of gnunet-service-peerinfo.c */
diff --git a/src/peerinfo/peerinfo.h b/src/peerinfo/peerinfo.h
new file mode 100644
index 000000000..040b084e4
--- /dev/null
+++ b/src/peerinfo/peerinfo.h
@@ -0,0 +1,135 @@
+/*
+     This file is part of GNUnet.
+     (C) 2009 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 2, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file peerinfo/peerinfo.h
+ * @brief common internal definitions for peerinfo service
+ * @author Christian Grothoff
+ */
+#include "gnunet_crypto_lib.h"
+#include "gnunet_time_lib.h"
+#include "gnunet_peerinfo_service.h"
+
+
+/**
+ * Add the given peer to the list.  This message
+ * is always followed by a verified HELLO message.
+ */
+struct PeerAddMessage
+{
+
+  /**
+   * Type will be GNUNET_MESSAGE_TYPE_PEERINFO_ADD
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Always zero.
+   */
+  uint32_t reserved GNUNET_PACKED;
+
+  /**
+   * For which peer do we provide a HELLO message here?
+   */
+  struct GNUNET_PeerIdentity peer;
+
+};
+
+
+/**
+ * Message requesting a listing of all known peers,
+ * possibly modified by the specified trust value
+ * and restricted to the specified peer identity.
+ */
+struct ListPeerMessage
+{
+
+  /**
+   * Type will be GNUNET_MESSAGE_TYPE_PEERINFO_GET
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * How much to change the trust in each returned peer,
+   * in network byte order.
+   */
+  int32_t trust_change GNUNET_PACKED;
+
+  /**
+   * Restrict to peers with this identity (optional
+   * field, check header.size!).
+   */
+  struct GNUNET_PeerIdentity peer;
+
+};
+
+
+/**
+ * Message requesting a listing of all known peers,
+ * possibly modified by the specified trust value
+ * and restricted to the specified peer identity.
+ */
+struct ListAllPeersMessage
+{
+
+  /**
+   * Type will be GNUNET_MESSAGE_TYPE_PEERINFO_GET
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * How much to change the trust in each returned peer,
+   * in network byte order.
+   */
+  int32_t trust_change GNUNET_PACKED;
+
+};
+
+
+/**
+ * Message used to inform the client about
+ * a particular peer; this message is optionally followed
+ * by a HELLO message for the respective peer (if available).
+ * Check the header.size field to see if a HELLO is
+ * present.
+ */
+struct InfoMessage
+{
+
+  /**
+   * Type will be GNUNET_MESSAGE_TYPE_PEERINFO_INFO
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Amount of trust we now have in the peer,
+   * in network byte order.
+   */
+  uint32_t trust GNUNET_PACKED;
+
+  /**
+   * About which peer are we talking here?
+   */
+  struct GNUNET_PeerIdentity peer;
+
+};
+
+
+/* end of peerinfo.h */
diff --git a/src/peerinfo/peerinfo_api.c b/src/peerinfo/peerinfo_api.c
new file mode 100644
index 000000000..ba5ade199
--- /dev/null
+++ b/src/peerinfo/peerinfo_api.c
@@ -0,0 +1,302 @@
+/*
+     This file is part of GNUnet.
+     (C) 2001, 2002, 2004, 2005, 2007, 2009 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 2, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file peerinfo/peerinfo_api.c
+ * @brief API to access peerinfo service
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_client_lib.h"
+#include "gnunet_peerinfo_service.h"
+#include "gnunet_protocols.h"
+#include "gnunet_time_lib.h"
+#include "peerinfo.h"
+
+#define ADD_PEER_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
+
+
+struct CAFContext
+{
+  struct GNUNET_CLIENT_Connection *client;
+  struct GNUNET_MessageHeader *msg;
+};
+
+
+static size_t
+copy_and_free (void *cls, size_t size, void *buf)
+{
+  struct CAFContext *cc = cls;
+  struct GNUNET_MessageHeader *msg = cc->msg;
+  uint16_t msize;
+
+  if (buf == NULL)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _
+                  ("Failed to transmit message of type %u to `%s' service.\n"),
+                  ntohs (msg->type), "peerinfo");
+      GNUNET_free (msg);
+      GNUNET_CLIENT_disconnect (cc->client);
+      GNUNET_free (cc);
+      return 0;
+    }
+  msize = ntohs (msg->size);
+  GNUNET_assert (size >= msize);
+  memcpy (buf, msg, msize);
+  GNUNET_free (msg);
+  GNUNET_CLIENT_disconnect (cc->client);
+  GNUNET_free (cc);
+  return msize;
+}
+
+
+
+/**
+ * Add a host to the persistent list.
+ *
+ * @param cfg configuration to use
+ * @param sched scheduler to use
+ * @param peer identity of the peer
+ * @param hello the verified (!) HELLO message
+ * @param expiration when the HELLO will expire
+ */
+void
+GNUNET_PEERINFO_add_peer (struct GNUNET_CONFIGURATION_Handle *cfg,
+                          struct GNUNET_SCHEDULER_Handle *sched,
+                          const struct GNUNET_PeerIdentity *peer,
+                          const struct GNUNET_HELLO_Message *hello)
+{
+  struct GNUNET_CLIENT_Connection *client;
+  struct PeerAddMessage *pam;
+  uint16_t hs;
+  struct CAFContext *cc;
+
+  client = GNUNET_CLIENT_connect (sched, "peerinfo", cfg);
+  if (client == NULL)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _("Could not connect to `%s' service.\n"), "peerinfo");
+      return;
+    }
+  hs = GNUNET_HELLO_size (hello);
+  pam = GNUNET_malloc (sizeof (struct PeerAddMessage) + hs);
+  pam->header.size = htons (hs + sizeof (struct PeerAddMessage));
+  pam->header.type = htons (GNUNET_MESSAGE_TYPE_PEERINFO_ADD);
+  memcpy (&pam->peer, peer, sizeof (struct GNUNET_PeerIdentity));
+  memcpy (&pam[1], hello, hs);
+  cc = GNUNET_malloc (sizeof (struct CAFContext));
+  cc->client = client;
+  cc->msg = &pam->header;
+  GNUNET_CLIENT_notify_transmit_ready (client,
+                                       ntohs (pam->header.size),
+                                       ADD_PEER_TIMEOUT, &copy_and_free, cc);
+}
+
+
+/**
+ * Context for the info handler.
+ */
+struct InfoContext
+{
+
+  /**
+   * Our connection to the PEERINFO service.
+   */
+  struct GNUNET_CLIENT_Connection *client;
+
+  /**
+   * Function to call with information.
+   */
+  GNUNET_PEERINFO_Processor callback;
+
+  /**
+   * Closure for callback.
+   */
+  void *callback_cls;
+
+  /**
+   * When should we time out?
+   */
+  struct GNUNET_TIME_Absolute timeout;
+
+};
+
+
+/**
+ * Type of a function to call when we receive a message
+ * from the service.
+ *
+ * @param cls closure
+ * @param msg message received, NULL on timeout or fatal error
+ */
+static void
+info_handler (void *cls, const struct GNUNET_MessageHeader *msg)
+{
+  struct InfoContext *ic = cls;
+  const struct InfoMessage *im;
+  const struct GNUNET_HELLO_Message *hello;
+  uint16_t ms;
+
+  if (msg == NULL)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _("Failed to receive response from `%s' service.\n"),
+                  "peerinfo");
+      ic->callback (ic->callback_cls, NULL, NULL, 1);
+      GNUNET_CLIENT_disconnect (ic->client);
+      GNUNET_free (ic);
+      return;
+    }
+  if (ntohs (msg->type) == GNUNET_MESSAGE_TYPE_PEERINFO_INFO_END)
+    {
+      ic->callback (ic->callback_cls, NULL, NULL, 0);
+      GNUNET_CLIENT_disconnect (ic->client);
+      GNUNET_free (ic);
+      return;
+    }
+  ms = ntohs (msg->size);
+  if ((ms < sizeof (struct InfoMessage)) ||
+      (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_PEERINFO_INFO))
+    {
+      GNUNET_break (0);
+      ic->callback (ic->callback_cls, NULL, NULL, 2);
+      GNUNET_CLIENT_disconnect (ic->client);
+      GNUNET_free (ic);
+      return;
+    }
+  im = (const struct InfoMessage *) msg;
+  hello = NULL;
+  if (ms > sizeof (struct InfoMessage) + sizeof (struct GNUNET_MessageHeader))
+    {
+      hello = (const struct GNUNET_HELLO_Message *) &im[1];
+      if (ms != sizeof (struct InfoMessage) + GNUNET_HELLO_size (hello))
+        {
+          GNUNET_break (0);
+          ic->callback (ic->callback_cls, NULL, NULL, 2);
+          GNUNET_CLIENT_disconnect (ic->client);
+          GNUNET_free (ic);
+          return;
+        }
+    }
+  ic->callback (ic->callback_cls, &im->peer, hello, ntohl (im->trust));
+  GNUNET_CLIENT_receive (ic->client,
+                         &info_handler,
+                         ic,
+                         GNUNET_TIME_absolute_get_remaining (ic->timeout));
+}
+
+
+static size_t
+copy_then_receive (void *cls, size_t size, void *buf)
+{
+  struct InfoContext *ic = cls;
+  const struct GNUNET_MessageHeader *msg =
+    (const struct GNUNET_MessageHeader *) &ic[1];
+  uint16_t msize;
+
+  if (buf == NULL)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _
+                  ("Failed to transmit message of type %u to `%s' service.\n"),
+                  ntohs (msg->type), "peerinfo");
+      ic->callback (ic->callback_cls, NULL, NULL, 1);
+      GNUNET_CLIENT_disconnect (ic->client);
+      GNUNET_free (ic);
+      return 0;
+    }
+  msize = ntohs (msg->size);
+  GNUNET_assert (size >= msize);
+  memcpy (buf, msg, msize);
+  GNUNET_CLIENT_receive (ic->client,
+                         &info_handler,
+                         ic,
+                         GNUNET_TIME_absolute_get_remaining (ic->timeout));
+  return msize;
+}
+
+
+/**
+ * Call a method for each known matching host and change
+ * its trust value.  The method will be invoked once for
+ * each host and then finally once with a NULL pointer.
+ * Note that the last call can be triggered by timeout or
+ * by simply being done; however, the trust argument will
+ * be set to zero if we are done and to 1 if we timed out.
+ *
+ * @param cfg configuration to use
+ * @param sched scheduler to use
+ * @param peer restrict iteration to this peer only (can be NULL)
+ * @param trust_delta how much to change the trust in all matching peers
+ * @param timeout how long to wait until timing out
+ * @param callback the method to call for each peer
+ * @param callback_cls closure for callback
+ */
+void
+GNUNET_PEERINFO_for_all (struct GNUNET_CONFIGURATION_Handle *cfg,
+                         struct GNUNET_SCHEDULER_Handle *sched,
+                         const struct GNUNET_PeerIdentity *peer,
+                         int trust_delta,
+                         struct GNUNET_TIME_Relative timeout,
+                         GNUNET_PEERINFO_Processor callback,
+                         void *callback_cls)
+{
+  struct GNUNET_CLIENT_Connection *client;
+  struct ListAllPeersMessage *lapm;
+  struct ListPeerMessage *lpm;
+  size_t hs;
+  struct InfoContext *ihc;
+
+  client = GNUNET_CLIENT_connect (sched, "peerinfo", cfg);
+  if (client == NULL)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _("Could not connect to `%s' service.\n"), "peerinfo");
+      callback (callback_cls, NULL, NULL, 2);
+      return;
+    }
+  ihc = GNUNET_malloc (sizeof (struct InfoContext) +
+                       sizeof (struct ListPeerMessage));
+  ihc->client = client;
+  ihc->callback = callback;
+  ihc->callback_cls = callback_cls;
+  ihc->timeout = GNUNET_TIME_relative_to_absolute (timeout);
+  hs = 0;
+  if (peer == NULL)
+    {
+      lapm = (struct ListAllPeersMessage *) &ihc[1];
+      lapm->header.size = htons (hs = sizeof (struct ListAllPeersMessage));
+      lapm->header.type = htons (GNUNET_MESSAGE_TYPE_PEERINFO_GET_ALL);
+      lapm->trust_change = htonl (trust_delta);
+    }
+  else
+    {
+      lpm = (struct ListPeerMessage *) &ihc[1];
+      lpm->header.size = htons (hs = sizeof (struct ListPeerMessage));
+      lpm->header.type = htons (GNUNET_MESSAGE_TYPE_PEERINFO_GET);
+      lpm->trust_change = htonl (trust_delta);
+      memcpy (&lpm->peer, peer, sizeof (struct GNUNET_PeerIdentity));
+    }
+  GNUNET_CLIENT_notify_transmit_ready (client,
+                                       hs, timeout, &copy_then_receive, ihc);
+}
+
+/* end of peerinfo_api.c */
diff --git a/src/peerinfo/test_peerinfo_api.c b/src/peerinfo/test_peerinfo_api.c
new file mode 100644
index 000000000..e7d632fd5
--- /dev/null
+++ b/src/peerinfo/test_peerinfo_api.c
@@ -0,0 +1,175 @@
+/*
+     This file is part of GNUnet.
+     (C) 2004, 2009 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 2, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file peerinfo/test_peerinfo_api.c
+ * @brief testcase for peerinfo_api.c
+ * @author Christian Grothoff
+ *
+ * TODO:
+ * - test merging of HELLOs (add same peer twice...)
+ */
+
+#include "platform.h"
+#include "gnunet_hello_lib.h"
+#include "gnunet_getopt_lib.h"
+#include "gnunet_os_lib.h"
+#include "gnunet_peerinfo_service.h"
+#include "gnunet_program_lib.h"
+#include "gnunet_time_lib.h"
+
+
+static int
+check_it (void *cls,
+          const char *tname,
+          struct GNUNET_TIME_Absolute expiration,
+          const void *addr, size_t addrlen)
+{
+  unsigned int *agc = cls;
+
+  if (addrlen > 0)
+    {
+      GNUNET_assert (0 == strcmp ("peerinfotest", tname));
+      GNUNET_assert (0 == strncmp ("Address", addr, addrlen));
+      (*agc) -= (1 << (addrlen - 1));
+    }
+  return GNUNET_OK;
+}
+
+
+static void
+process (void *cls,
+         const struct GNUNET_PeerIdentity *peer,
+         const struct GNUNET_HELLO_Message *hello, uint32_t trust)
+{
+  int *ok = cls;
+  unsigned int agc;
+
+  if (peer == NULL)
+    {
+      GNUNET_assert (peer == NULL);
+      GNUNET_assert (2 == *ok);
+      GNUNET_assert (trust == 0);
+      *ok = 0;
+      return;
+    }
+
+  if (hello != NULL)
+    {
+      GNUNET_assert (3 == *ok);
+      agc = 3;
+      GNUNET_HELLO_iterate_addresses (hello, GNUNET_NO, &check_it, &agc);
+      GNUNET_assert (agc == 0);
+      *ok = 2;
+    }
+}
+
+
+static size_t
+address_generator (void *cls, size_t max, void *buf)
+{
+  size_t *agc = cls;
+  size_t ret;
+
+  if (0 == *agc)
+    return 0;
+  ret = GNUNET_HELLO_add_address ("peerinfotest",
+                                  GNUNET_TIME_relative_to_absolute
+                                  (GNUNET_TIME_UNIT_HOURS), "Address", *agc,
+                                  buf, max);
+  (*agc)--;
+  return ret;
+}
+
+
+static void
+run (void *cls,
+     struct GNUNET_SCHEDULER_Handle *sched,
+     char *const *args,
+     const char *cfgfile, struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  struct GNUNET_HELLO_Message *hello;
+  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
+  size_t agc;
+  struct GNUNET_PeerIdentity pid;
+
+  memset (&pkey, 32, sizeof (pkey));
+  GNUNET_CRYPTO_hash (&pkey, sizeof (pkey), &pid.hashPubKey);
+  agc = 2;
+  hello = GNUNET_HELLO_create (&pkey, &address_generator, &agc);
+  GNUNET_assert (hello != NULL);
+  GNUNET_PEERINFO_add_peer (cfg, sched, &pid, hello);
+  GNUNET_PEERINFO_for_all (cfg,
+                           sched,
+                           NULL,
+                           0,
+                           GNUNET_TIME_relative_multiply
+                           (GNUNET_TIME_UNIT_SECONDS, 15), &process, cls);
+  GNUNET_free (hello);
+}
+
+
+static int
+check ()
+{
+  int ok = 3;
+  pid_t pid;
+  char *const argv[] = { "test-peerinfo-api",
+    "-c",
+    "test_peerinfo_api_data.conf",
+#if DEBUG_PEERINFO
+    "-L", "DEBUG",
+#endif
+    NULL
+  };
+  struct GNUNET_GETOPT_CommandLineOption options[] = {
+    GNUNET_GETOPT_OPTION_END
+  };
+  pid = GNUNET_OS_start_process ("gnunet-service-peerinfo",
+                                 "gnunet-service-peerinfo",
+#if DEBUG_PEERINFO
+                                 "-L", "DEBUG",
+#endif
+                                 "-c", "test_peerinfo_api_data.conf", NULL);
+  sleep (1);
+  GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
+                      argv, "test-peerinfo-api", "nohelp",
+                      options, &run, &ok);
+  if (0 != PLIBC_KILL (pid, SIGTERM))
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+      ok = 1;
+    }
+  waitpid (pid, NULL, 0);
+  return ok;
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  int ret = 0;
+
+  ret = check ();
+
+  return ret;
+}
+
+/* end of test_peerinfo_api.c */
diff --git a/src/peerinfo/test_peerinfo_api_data.conf b/src/peerinfo/test_peerinfo_api_data.conf
new file mode 100644
index 000000000..a81ffccb9
--- /dev/null
+++ b/src/peerinfo/test_peerinfo_api_data.conf
@@ -0,0 +1,5 @@
+[PATHS]
+SERVICEHOME = /tmp/test-gnunetd-peerinfo/
+
+[peerinfo]
+PORT = 22354