gnunet-daemon-hostlist_server.c File Reference

application to provide an integrated hostlist HTTP server More...

#include "platform.h"
#include "gnunet_common.h"
#include <microhttpd.h>
#include "gnunet-daemon-hostlist_server.h"
#include "gnunet_hello_uri_lib.h"
#include "gnunet_peerstore_service.h"
#include "gnunet-daemon-hostlist.h"
#include "gnunet_resolver_service.h"
#include "gnunet_mhd_compat.h"
#include <jansson.h>
#include <strings.h>

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

Go to the source code of this file.

Data Structures
struct	HostSet
	Context for host_processor(). More...

Macros
#define	GNUNET_ADV_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
	How long until our hostlist advertisement transmission via CORE should time out?
#define	REBUILD_DELAY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
	How long do we wait after learning about a HELLO before we rebuild the hostlist we serve? Rebuilding walks every HELLO we know and re-encodes all of them, so a PEERSTORE notification must not trigger one on its own: they arrive in batches (the initial iteration of the monitor, or everything our own client half just downloaded), and one rebuild per batch is all that batch is worth.

Functions
static void	add_cors_headers (struct MHD_Response *resp)
	Add headers to a request indicating that we allow Cross-Origin Resource Sharing.
static struct MHD_Response *	build_json_response (const struct HostSet *host_set)
static void	finish_response ()
	Function that assembles our response.
static enum GNUNET_GenericReturnValue	host_processor (void *cls, const struct GNUNET_PeerIdentity *peer, void *value)
	Callback that processes each of the known HELLOs for the hostlist response construction.
static enum GNUNET_GenericReturnValue	free_hello (void *cls, const struct GNUNET_PeerIdentity *peer, void *value)
	Free one HELLO of hellos.
static void	rebuild_hostlist (void *cls)
	Rebuild the hostlist we serve from all the HELLOs we know.
static void	schedule_rebuild ()
	Ask for the hostlist to be rebuilt, unless that is already pending.
static MHD_RESULT	accept_policy_callback (void *cls, const struct sockaddr *addr, socklen_t addrlen)
	Hostlist access policy (very permissive, allows everything).
static int	header_iterator (void *cls, enum MHD_ValueKind kind, const char *key, const char *value)
static MHD_RESULT	access_handler_callback (void *cls, struct MHD_Connection *connection, const char *url, const char *method, const char *version, const char *upload_data, size_t *upload_data_size, void **con_cls)
	Main request handler.
static void	adv_transmit (struct GNUNET_MQ_Handle *mq)
	Handler called by CORE when CORE is ready to transmit message.
static void *	connect_handler (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq, enum GNUNET_CORE_PeerClass class)
	Method called whenever a given peer connects.
static void	process_notify (void *cls, const struct GNUNET_PEERSTORE_Record *record, const char *err_msg)
	PEERSTORE calls this function to let us know about a possible peer that we might want to connect to.
static struct GNUNET_SCHEDULER_Task *	prepare_daemon (struct MHD_Daemon *daemon_handle)
	Function that queries MHD's select sets and starts the task waiting for them.
static void	run_daemon (void *cls)
	Call MHD to process pending requests and then go back and schedule the next run.
static void	error_cb (void *cls)
static void	sync_cb (void *cls)
static void	start_notify (void *cls)
int	GNUNET_HOSTLIST_server_start (const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_STATISTICS_Handle *st, struct GNUNET_CORE_Handle *co, GNUNET_CORE_ConnectEventHandler *server_ch, int advertise)
	Start server offering our hostlist.
void	GNUNET_HOSTLIST_server_stop ()
	Stop server offering our hostlist.

Variables
struct GNUNET_CONTAINER_MultiPeerMap *	hellos
	Map with hellos we build the hostlist with.
static struct MHD_Daemon *	daemon_handle_v6
	Handle to the HTTP server as provided by libmicrohttpd for IPv6.
static struct MHD_Daemon *	daemon_handle_v4
	Handle to the HTTP server as provided by libmicrohttpd for IPv4.
static const struct GNUNET_CONFIGURATION_Handle *	cfg
	Our configuration.
static struct GNUNET_STATISTICS_Handle *	stats
	For keeping statistics.
static struct GNUNET_CORE_Handle *	core
	Handle to the core service (NULL until we've connected to it).
struct GNUNET_SCHEDULER_Task *	peerstore_notify_task
	The task to delayed start the notification process initially.
static struct GNUNET_PEERSTORE_Monitor *	peerstore_notify
	Our peerstore notification context.
static struct GNUNET_SCHEDULER_Task *	hostlist_task_v4
	Our primary task for IPv4.
static struct GNUNET_SCHEDULER_Task *	hostlist_task_v6
	Our primary task for IPv6.
static struct GNUNET_SCHEDULER_Task *	rebuild_task
	Task that rebuilds our response from hellos, or NULL if no rebuild is pending.
static struct MHD_Response *	response
	Our canonical response.
static struct MHD_Response *	response_json
	Our json response.
static struct GNUNET_PEERSTORE_Handle *	peerstore
	Handle to the PEERSTORE service.
static int	advertising
	Set if we are allowed to advertise our hostlist to others.
static char *	hostlist_uri
	Buffer for the hostlist address.
static struct HostSet *	builder
	NULL if we are not currently iterating over peer information.

Detailed Description

application to provide an integrated hostlist HTTP server

Author

Christian Grothoff

Matthias Wachs

David Barksdale

Definition in file gnunet-daemon-hostlist_server.c.

Macro Definition Documentation

GNUNET_ADV_TIMEOUT

#define GNUNET_ADV_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)

How long until our hostlist advertisement transmission via CORE should time out?

Definition at line 44 of file gnunet-daemon-hostlist_server.c.

{
  char *data;
 
  unsigned int size;
};
 
 
static struct HostSet *builder;
 
 
static void
add_cors_headers (struct MHD_Response *resp)
{
  GNUNET_assert (MHD_NO !=
                 MHD_add_response_header (resp,
                                          "Access-Control-Allow-Origin", "*"));
  GNUNET_assert (MHD_NO !=
                 MHD_add_response_header (resp,
                                          "Access-Control-Allow-Methods",
                                          "GET, OPTIONS"));
  GNUNET_assert (MHD_NO !=
                 MHD_add_response_header (resp, "Access-Control-Max-Age",
                                          "86400"));
}
 
 
static struct MHD_Response*
build_json_response (const struct HostSet *host_set)
{
  struct GNUNET_MessageHeader *hello;
  struct GNUNET_HELLO_Parser *hparser;
  json_t*hello_uri_j;
  json_t*hello_array;
  char *hello_uri;
  char *hello_uris;
  size_t offset = 0;
 
  hello_uri_j = json_object ();
  hello_array = json_array ();
  while (offset < host_set->size)
  {
    hello = (struct GNUNET_MessageHeader*) (host_set->data + offset);
    /* #process_notify() verified this HELLO when it entered #hellos, and
       these are our own bytes since.  Verifying again here cost one EdDSA
       verification per HELLO in the set, on every rebuild. */
    hparser = GNUNET_HELLO_parser_from_msg_ (hello, NULL, GNUNET_YES);
    if (NULL == hparser)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "HELLO from host set malformed, skipping...\n");
      offset += ntohs (hello->size);
      continue;
    }
    hello_uri = GNUNET_HELLO_parser_to_url (hparser);
    json_array_append_new (hello_array, json_string (hello_uri));
    GNUNET_free (hello_uri);
    GNUNET_HELLO_parser_free (hparser);
    offset += ntohs (hello->size);
  }
  json_object_set_new (hello_uri_j, "hellos", hello_array);
  hello_uris = json_dumps (hello_uri_j, JSON_INDENT (2));
  json_decref (hello_uri_j);
  return MHD_create_response_from_buffer (strlen (hello_uris),
                                          hello_uris,
                                          MHD_RESPMEM_MUST_FREE);
}
 
 
static void
finish_response ()
{
  if (NULL != response)
    MHD_destroy_response (response);
  if (NULL != response_json)
    MHD_destroy_response (response_json);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Creating hostlist response with %u bytes\n",
              (unsigned int) builder->size);
  response = MHD_create_response_from_buffer (builder->size,
                                              builder->data,
                                              MHD_RESPMEM_MUST_FREE);
  response_json = build_json_response (builder);
  GNUNET_assert (MHD_NO != MHD_add_response_header (response_json,
                                                    "Content-Type",
                                                    "application/json"));
  add_cors_headers (response);
  if ((NULL == daemon_handle_v4) && (NULL == daemon_handle_v6))
  {
    MHD_destroy_response (response);
    response = NULL;
    MHD_destroy_response (response_json);
    response_json = NULL;
  }
  GNUNET_STATISTICS_set (stats,
                         gettext_noop ("bytes in hostlist"),
                         builder->size,
                         GNUNET_YES);
  GNUNET_free (builder);
  builder = NULL;
}
 
 
static enum GNUNET_GenericReturnValue
host_processor (void *cls,
                const struct GNUNET_PeerIdentity *peer,
                void *value)
{
  size_t old;
  size_t s;
  struct GNUNET_MessageHeader *hello = value;
  (void) cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "host_processor\n");
  old = builder->size;
  s = ntohs (hello->size);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received %u bytes of `%s' from peer `%s' for hostlist.\n",
              (unsigned int) s,
              "HELLO",
              GNUNET_i2s (peer));
  if ((old + s >= GNUNET_MAX_MALLOC_CHECKED) ||
      (old + s >= MAX_BYTES_PER_HOSTLISTS))
  {
    /* too large, skip! */
    GNUNET_STATISTICS_update (stats,
                              gettext_noop (
                                "bytes not included in hostlist (size limit)"),
                              s,
                              GNUNET_NO);
    return GNUNET_YES;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Adding peer `%s' to hostlist (%u bytes)\n",
              GNUNET_i2s (peer),
              (unsigned int) s);
  GNUNET_array_grow (builder->data, builder->size, old + s);
  GNUNET_memcpy (&builder->data[old], hello, s);
 
  return GNUNET_YES;
}
 
 
static enum GNUNET_GenericReturnValue
free_hello (void *cls,
            const struct GNUNET_PeerIdentity *peer,
            void *value)
{
  (void) cls;
  (void) peer;
  GNUNET_free (value);
  return GNUNET_YES;
}
 
 
static void
rebuild_hostlist (void *cls)
{
  (void) cls;
  rebuild_task = NULL;
  if (NULL != builder)
  {
    GNUNET_free (builder->data);
    builder->size = 0;
    builder->data = NULL;
  }
  else
  {
    builder = GNUNET_new (struct HostSet);
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Rebuilding hostlist from %u HELLOs\n",
              GNUNET_CONTAINER_multipeermap_size (hellos));
  if (0 != GNUNET_CONTAINER_multipeermap_iterate (hellos,
                                                  &host_processor,
                                                  NULL))
    finish_response ();
}
 
 
static void
schedule_rebuild ()
{
  if (NULL != rebuild_task)
    return;
  rebuild_task = GNUNET_SCHEDULER_add_delayed (REBUILD_DELAY,
                                               &rebuild_hostlist,
                                               NULL);
}
 
 
static MHD_RESULT
accept_policy_callback (void *cls,
                        const struct sockaddr *addr,
                        socklen_t addrlen)
{
  if (NULL == response)
  {
    GNUNET_log (
      GNUNET_ERROR_TYPE_DEBUG,
      "Received request for hostlist, but I am not yet ready; rejecting!\n");
    return MHD_NO;
  }
  return MHD_YES; /* accept all */
}
 
 
static int
header_iterator (void *cls,
                 enum MHD_ValueKind kind,
                 const char *key,
                 const char *value)
{
  enum GNUNET_GenericReturnValue *want_json = cls;
 
  if (0 != strcasecmp (key, "Accept"))
    return GNUNET_YES;
  if (0 == strcasecmp (value, "application/json"))
    *want_json = GNUNET_YES;
  return MHD_YES;
}
 
 
static MHD_RESULT
access_handler_callback (void *cls,
                         struct MHD_Connection *connection,
                         const char *url,
                         const char *method,
                         const char *version,
                         const char *upload_data,
                         size_t *upload_data_size,
                         void **con_cls)
{
  static int dummy;
  struct MHD_Response *selected_response;
  enum GNUNET_GenericReturnValue want_json = GNUNET_NO;
 
  /* CORS pre-flight request */
  if (0 == strcmp (MHD_HTTP_METHOD_OPTIONS, method))
  {
    struct MHD_Response *options_response;
    int rc;
 
    options_response =
      MHD_create_response_from_buffer (0, NULL, MHD_RESPMEM_PERSISTENT);
    add_cors_headers (options_response);
    rc = MHD_queue_response (connection, MHD_HTTP_OK, options_response);
    MHD_destroy_response (options_response);
    return rc;
  }
  if (0 != strcmp (method, MHD_HTTP_METHOD_GET))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Refusing `%s' request to hostlist server\n"),
                method);
    GNUNET_STATISTICS_update (stats,
                              gettext_noop (
                                "hostlist requests refused (not HTTP GET)"),
                              1,
                              GNUNET_YES);
    return MHD_NO;
  }
  if (NULL == *con_cls)
  {
    (*con_cls) = &dummy;
    return MHD_YES;
  }
  if (0 != *upload_data_size)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Refusing `%s' request with %llu bytes of upload data\n"),
                method,
                (unsigned long long) *upload_data_size);
    GNUNET_STATISTICS_update (stats,
                              gettext_noop (
                                "hostlist requests refused (upload data)"),
                              1,
                              GNUNET_YES);
    return MHD_NO;   /* do not support upload data */
  }
  selected_response = response;
  MHD_get_connection_values (connection,
                             MHD_HEADER_KIND,
                             (MHD_KeyValueIterator) & header_iterator,
                             &want_json);
  if (GNUNET_YES == want_json)
  {
    selected_response = response_json;
  }
  if (NULL == selected_response)
  {
    GNUNET_log (
      GNUNET_ERROR_TYPE_WARNING,
      _ (
        "Could not handle hostlist request since I do not have a response yet\n"));
    GNUNET_STATISTICS_update (stats,
                              gettext_noop (
                                "hostlist requests refused (not ready)"),
                              1,
                              GNUNET_YES);
    return MHD_NO;   /* internal error, no response yet */
  }
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              _ ("Received request for our hostlist\n"));
  GNUNET_STATISTICS_update (stats,
                            gettext_noop ("hostlist requests processed"),
                            1,
                            GNUNET_YES);
  return MHD_queue_response (connection, MHD_HTTP_OK, selected_response);
}
 
 
static void
adv_transmit (struct GNUNET_MQ_Handle *mq)
{
  static uint64_t hostlist_adv_count;
  size_t uri_size; /* Including \0 termination! */
  struct GNUNET_MessageHeader *header;
  struct GNUNET_MQ_Envelope *env;
 
  uri_size = strlen (hostlist_uri) + 1;
  env = GNUNET_MQ_msg_extra (header,
                             uri_size,
                             GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT);
  GNUNET_memcpy (&header[1], hostlist_uri, uri_size);
  GNUNET_MQ_env_set_options (env,
                             GNUNET_MQ_PREF_CORK_ALLOWED
                             | GNUNET_MQ_PREF_UNRELIABLE);
  GNUNET_MQ_send (mq, env);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sent advertisement message: Copied %u bytes into buffer!\n",
              (unsigned int) uri_size);
  hostlist_adv_count++;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              " # Sent advertisement message: %llu\n",
              (unsigned long long) hostlist_adv_count);
  GNUNET_STATISTICS_update (stats,
                            gettext_noop ("# hostlist advertisements send"),
                            1,
                            GNUNET_NO);
}
 
 
static void *
connect_handler (void *cls,
                 const struct GNUNET_PeerIdentity *peer,
                 struct GNUNET_MQ_Handle *mq,
                 enum GNUNET_CORE_PeerClass class)
{
  size_t size;
 
  if (! advertising)
    return NULL;
  if (NULL == hostlist_uri)
    return NULL;
  size = strlen (hostlist_uri) + 1;
  if (size + sizeof(struct GNUNET_MessageHeader) >= GNUNET_MAX_MESSAGE_SIZE)
  {
    GNUNET_break (0);
    return NULL;
  }
  size += sizeof(struct GNUNET_MessageHeader);
  if (NULL == core)
  {
    GNUNET_break (0);
    return NULL;
  }
  GNUNET_log (
    GNUNET_ERROR_TYPE_DEBUG,
    "Asked CORE to transmit advertisement message with a size of %u bytes to peer `%s'\n",
    (unsigned int) size,
    GNUNET_i2s (peer));
  adv_transmit (mq);
  return NULL;
}
 
 
static void
process_notify (void *cls,
                const struct GNUNET_PEERSTORE_Record *record,
                const char *err_msg)
{
  unsigned int map_size;
  struct GNUNET_MessageHeader *hello_cpy;
  struct GNUNET_MessageHeader *old_hello;
  struct GNUNET_MessageHeader *hello;
 
  map_size = GNUNET_CONTAINER_multipeermap_size (hellos);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Peerstore is notifying us to rebuild our hostlist map size %u\n",
              map_size);
  if (NULL != err_msg)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                _ ("Error in communication with PEERSTORE service: %s\n"),
                err_msg);
    GNUNET_PEERSTORE_monitor_next (peerstore_notify, 1);
    return;
  }
  if (NULL == record)
  {
    GNUNET_break (0);
    GNUNET_PEERSTORE_monitor_next (peerstore_notify, 1);
    return;
  }
  hello = record->value;
  /* @e value and @e value_size are independent, and the HELLO is an
     unvalidated blob a remote peer published: a zero-length value leaves
     @a hello NULL, and a @e size field larger than @e value_size makes the
     GNUNET_memcpy() below read past the end of the record. */
  if ((NULL == hello) ||
      (record->value_size < sizeof (*hello)) ||
      (ntohs (hello->size) > record->value_size))
  {
    GNUNET_break_op (0);
    GNUNET_PEERSTORE_monitor_next (peerstore_notify, 1);
    return;
  }
  /* PEERSTORE stores what it is given (handle_store() validates nothing),
     and these records were published by other peers.  Check the signature
     once, here, instead of leaving it to whoever happens to parse the set
     later: it kept malformed HELLOs out of the JSON response only because
     build_json_response() had to parse to build a URL, and never kept
     them out of the binary one at all. */
  {
    struct GNUNET_HELLO_Parser *parser;
    const struct GNUNET_PeerIdentity *pid;
 
    parser = GNUNET_HELLO_parser_from_msg (hello,
                                           &record->peer);
    if (NULL == parser)
    {
      /* Not #GNUNET_break_op(): this is also how an expired HELLO fails,
         and a record outliving the signature over it is routine. */
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "HELLO for `%s' is expired or does not verify, skipping\n",
                  GNUNET_i2s (&record->peer));
      GNUNET_PEERSTORE_monitor_next (peerstore_notify, 1);
      return;
    }
    pid = GNUNET_HELLO_parser_get_id (parser);
    if ((NULL == pid) ||
        (0 != GNUNET_memcmp (pid, &record->peer)))
    {
      /* We key the map by the record's peer, so a HELLO filed under
         somebody else's identity would evict that peer's real one. */
      GNUNET_break_op (0);
      GNUNET_HELLO_parser_free (parser);
      GNUNET_PEERSTORE_monitor_next (peerstore_notify, 1);
      return;
    }
    GNUNET_HELLO_parser_free (parser);
  }
  /* A peer has exactly one current HELLO, and PEERSTORE tells us about
     every store of it -- our own client half alone re-stores everything
     it downloads, on every download round.  Appending here (as
     #GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE did) meant the map grew
     without bound, every entry was leaked, and each rebuild re-encoded
     the same HELLO once per copy. */
  hello_cpy = GNUNET_malloc (ntohs (hello->size));
  GNUNET_memcpy (hello_cpy, hello, ntohs (hello->size));
  old_hello = GNUNET_CONTAINER_multipeermap_get (hellos,
                                                 &record->peer);
  if (NULL != old_hello)
  {
    GNUNET_assert (GNUNET_YES ==
                   GNUNET_CONTAINER_multipeermap_remove (hellos,
                                                         &record->peer,
                                                         old_hello));
    GNUNET_free (old_hello);
  }
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multipeermap_put (hellos,
                                                    &record->peer,
                                                    hello_cpy,
                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  schedule_rebuild ();
  map_size = GNUNET_CONTAINER_multipeermap_size (hellos);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "1 Peerstore is notifying us to rebuild our hostlist map size %u peer %s\n",
              map_size,
              GNUNET_i2s (&record->peer));
  GNUNET_PEERSTORE_monitor_next (peerstore_notify, 1);
}
 
 
static struct GNUNET_SCHEDULER_Task *
prepare_daemon (struct MHD_Daemon *daemon_handle);
 
 
static void
run_daemon (void *cls)
{
  struct MHD_Daemon *daemon_handle = cls;
 
  if (daemon_handle == daemon_handle_v4)
    hostlist_task_v4 = NULL;
  else
    hostlist_task_v6 = NULL;
  GNUNET_assert (MHD_YES == MHD_run (daemon_handle));
  if (daemon_handle == daemon_handle_v4)
    hostlist_task_v4 = prepare_daemon (daemon_handle);
  else
    hostlist_task_v6 = prepare_daemon (daemon_handle);
}
 
 
static struct GNUNET_SCHEDULER_Task *
prepare_daemon (struct MHD_Daemon *daemon_handle)
{
  struct GNUNET_SCHEDULER_Task *ret;
  fd_set rs;
  fd_set ws;
  fd_set es;
  struct GNUNET_NETWORK_FDSet *wrs;
  struct GNUNET_NETWORK_FDSet *wws;
  int max;
  MHD_UNSIGNED_LONG_LONG timeout;
  int haveto;
  struct GNUNET_TIME_Relative tv;
 
  FD_ZERO (&rs);
  FD_ZERO (&ws);
  FD_ZERO (&es);
  wrs = GNUNET_NETWORK_fdset_create ();
  wws = GNUNET_NETWORK_fdset_create ();
  max = -1;
  GNUNET_assert (MHD_YES == MHD_get_fdset (daemon_handle, &rs, &ws, &es, &max));
  haveto = MHD_get_timeout (daemon_handle, &timeout);
  if (haveto == MHD_YES)
    tv.rel_value_us = (uint64_t) timeout * 1000LL;
  else
    tv = GNUNET_TIME_UNIT_FOREVER_REL;
  GNUNET_NETWORK_fdset_copy_native (wrs, &rs, max + 1);
  GNUNET_NETWORK_fdset_copy_native (wws, &ws, max + 1);
  ret = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH,
                                     tv,
                                     wrs,
                                     wws,
                                     &run_daemon,
                                     daemon_handle);
  GNUNET_NETWORK_fdset_destroy (wrs);
  GNUNET_NETWORK_fdset_destroy (wws);
  return ret;
}
 
 
static void
error_cb (void *cls)
{
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              "Error in PEERSTORE monitoring\n");
}
 
 
static void
sync_cb (void *cls)
{
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              "Done with initial PEERSTORE iteration during monitoring\n");
}
 
 
static void
start_notify (void *cls)
{
  (void) cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Starting to process new hellos to add to hostlist.\n");
  peerstore_notify = GNUNET_PEERSTORE_monitor_start (cfg,
                                                     GNUNET_YES,
                                                     "peerstore",
                                                     NULL,
                                                     GNUNET_PEERSTORE_HELLO_KEY,
                                                     &error_cb,
                                                     NULL,
                                                     &sync_cb,
                                                     NULL,
                                                     &process_notify, NULL);
}
 
 
int
GNUNET_HOSTLIST_server_start (const struct GNUNET_CONFIGURATION_Handle *c,
                              struct GNUNET_STATISTICS_Handle *st,
                              struct GNUNET_CORE_Handle *co,
                              GNUNET_CORE_ConnectEventHandler *server_ch,
                              int advertise)
{
  unsigned long long port;
  char *hostname;
  char *ipv4;
  char *ipv6;
  size_t size;
  struct in_addr i4;
  struct in6_addr i6;
  struct sockaddr_in v4;
  struct sockaddr_in6 v6;
  const struct sockaddr *sa4;
  const struct sockaddr *sa6;
 
  /* Keys are copied: #process_notify() puts the identity of a borrowed
     PEERSTORE record, which does not outlive the callback. */
  hellos = GNUNET_CONTAINER_multipeermap_create (16, GNUNET_NO);
  advertising = advertise;
  if (! advertising)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Advertising not enabled on this hostlist server\n");
  }
  else
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Advertising enabled on this hostlist server\n");
  }
  cfg = c;
  stats = st;
  peerstore = GNUNET_PEERSTORE_connect (cfg);
  if (NULL == peerstore)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Could not access PEERSTORE service.  Exiting.\n"));
    return GNUNET_SYSERR;
  }
  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg,
                                                          "HOSTLIST",
                                                          "HTTPPORT",
                                                          &port))
    return GNUNET_SYSERR;
  if ((0 == port) || (port > UINT16_MAX))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Invalid port number %llu.  Exiting.\n"),
                port);
    return GNUNET_SYSERR;
  }
 
  if (GNUNET_SYSERR ==
      GNUNET_CONFIGURATION_get_value_string (cfg,
                                             "HOSTLIST",
                                             "EXTERNAL_DNS_NAME",
                                             &hostname))
    hostname = GNUNET_RESOLVER_local_fqdn_get ();
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              _ ("Hostlist service starts on %s:%llu\n"),
              hostname,
              port);
  if (NULL != hostname)
  {
    size = strlen (hostname);
    if (size + 15 > MAX_URL_LEN)
    {
      GNUNET_break (0);
    }
    else
    {
      GNUNET_asprintf (&hostlist_uri,
                       "http://%s:%u/",
                       hostname,
                       (unsigned int) port);
      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                  _ ("Address to obtain hostlist: `%s'\n"),
                  hostlist_uri);
    }
    GNUNET_free (hostname);
  }
 
  if (GNUNET_CONFIGURATION_have_value (cfg, "HOSTLIST", "BINDTOIPV4"))
  {
    if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg,
                                                            "HOSTLIST",
                                                            "BINDTOIP",
                                                            &ipv4))
    {
      GNUNET_log (
        GNUNET_ERROR_TYPE_WARNING,
        _ ("BINDTOIP does not a valid IPv4 address! Ignoring BINDTOIPV4.\n"));
    }
  }
  else
    ipv4 = NULL;
  if (GNUNET_CONFIGURATION_have_value (cfg, "HOSTLIST", "BINDTOIPV6"))
  {
    if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg,
                                                            "HOSTLIST",
                                                            "BINDTOIP",
                                                            &ipv6))
    {
      GNUNET_log (
        GNUNET_ERROR_TYPE_WARNING,
        _ ("BINDTOIP does not a valid IPv4 address! Ignoring BINDTOIPV6.\n"));
    }
  }
  else
    ipv6 = NULL;
  sa4 = NULL;
  if (NULL != ipv4)
  {
    if (1 == inet_pton (AF_INET, ipv4, &i4))
    {
      memset (&v4, 0, sizeof(v4));
      v4.sin_family = AF_INET;
      v4.sin_addr = i4;
      v4.sin_port = htons (port);
#if HAVE_SOCKADDR_IN_SIN_LEN
      v4.sin_len = sizeof(v4);
#endif
      sa4 = (const struct sockaddr *) &v4;
    }
    else
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  _ (
                    "`%s' is not a valid IPv4 address! Ignoring BINDTOIPV4.\n"),
                  ipv4);
    GNUNET_free (ipv4);
  }
  sa6 = NULL;
  if (NULL != ipv6)
  {
    if (1 == inet_pton (AF_INET6, ipv6, &i6))
    {
      memset (&v6, 0, sizeof(v6));
      v6.sin6_family = AF_INET6;
      v6.sin6_addr = i6;
      v6.sin6_port = htons (port);
#if HAVE_SOCKADDR_IN_SIN_LEN
      v6.sin6_len = sizeof(v6);
#endif
      sa6 = (const struct sockaddr *) &v6;
    }
    else
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  _ (
                    "`%s' is not a valid IPv6 address! Ignoring BINDTOIPV6.\n"),
                  ipv6);
    GNUNET_free (ipv6);
  }
 
  daemon_handle_v6 = MHD_start_daemon (MHD_USE_IPv6 | MHD_USE_DEBUG,
                                       (uint16_t) port,
                                       &accept_policy_callback,
                                       NULL,
                                       &access_handler_callback,
                                       NULL,
                                       MHD_OPTION_CONNECTION_LIMIT,
                                       (unsigned int) 128,
                                       MHD_OPTION_PER_IP_CONNECTION_LIMIT,
                                       (unsigned int) 32,
                                       MHD_OPTION_CONNECTION_TIMEOUT,
                                       (unsigned int) 16,
                                       MHD_OPTION_CONNECTION_MEMORY_LIMIT,
                                       (size_t) (16 * 1024),
                                       MHD_OPTION_SOCK_ADDR,
                                       sa6,
                                       MHD_OPTION_END);
  daemon_handle_v4 = MHD_start_daemon (MHD_NO_FLAG | MHD_USE_DEBUG,
                                       (uint16_t) port,
                                       &accept_policy_callback,
                                       NULL,
                                       &access_handler_callback,
                                       NULL,
                                       MHD_OPTION_CONNECTION_LIMIT,
                                       (unsigned int) 128,
                                       MHD_OPTION_PER_IP_CONNECTION_LIMIT,
                                       (unsigned int) 32,
                                       MHD_OPTION_CONNECTION_TIMEOUT,
                                       (unsigned int) 16,
                                       MHD_OPTION_CONNECTION_MEMORY_LIMIT,
                                       (size_t) (16 * 1024),
                                       MHD_OPTION_SOCK_ADDR,
                                       sa4,
                                       MHD_OPTION_END);
 
  if ((NULL == daemon_handle_v6) && (NULL == daemon_handle_v4))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Could not start hostlist HTTP server on port %u\n"),
                (unsigned short) port);
    return GNUNET_SYSERR;
  }
 
  core = co;
  *server_ch = &connect_handler;
  if (NULL != daemon_handle_v4)
    hostlist_task_v4 = prepare_daemon (daemon_handle_v4);
  if (NULL != daemon_handle_v6)
    hostlist_task_v6 = prepare_daemon (daemon_handle_v6);
  peerstore_notify_task = GNUNET_SCHEDULER_add_delayed (
    GNUNET_TIME_UNIT_MINUTES,
    start_notify,
    NULL);
  return GNUNET_OK;
}
 
 
void
GNUNET_HOSTLIST_server_stop ()
{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Hostlist server shutdown\n");
  if (NULL != rebuild_task)
  {
    GNUNET_SCHEDULER_cancel (rebuild_task);
    rebuild_task = NULL;
  }
  if (NULL != hostlist_task_v6)
  {
    GNUNET_SCHEDULER_cancel (hostlist_task_v6);
    hostlist_task_v6 = NULL;
  }
  if (NULL != hostlist_task_v4)
  {
    GNUNET_SCHEDULER_cancel (hostlist_task_v4);
    hostlist_task_v4 = NULL;
  }
  if (NULL != daemon_handle_v4)
  {
    MHD_stop_daemon (daemon_handle_v4);
    daemon_handle_v4 = NULL;
  }
  if (NULL != daemon_handle_v6)
  {
    MHD_stop_daemon (daemon_handle_v6);
    daemon_handle_v6 = NULL;
  }
  if (NULL != response)
  {
    MHD_destroy_response (response);
    response = NULL;
  }
  if (NULL != response_json)
  {
    MHD_destroy_response (response_json);
    response_json = NULL;
  }
  if (NULL != peerstore_notify)
  {
    GNUNET_PEERSTORE_monitor_stop (peerstore_notify);
    peerstore_notify = NULL;
  }
  else if (NULL != peerstore_notify_task)
  {
    GNUNET_SCHEDULER_cancel (peerstore_notify_task);
  }
  if (NULL != builder)
  {
    GNUNET_free (builder->data);
    GNUNET_free (builder);
    builder = NULL;
  }
  if (NULL != hellos)
  {
    GNUNET_CONTAINER_multipeermap_iterate (hellos,
                                           &free_hello,
                                           NULL);
    GNUNET_CONTAINER_multipeermap_destroy (hellos);
    hellos = NULL;
  }
  if (NULL != peerstore)
  {
    GNUNET_PEERSTORE_disconnect (peerstore);
    peerstore = NULL;
  }
  cfg = NULL;
  stats = NULL;
  core = NULL;
}
 
 
/* end of gnunet-daemon-hostlist_server.c */

REBUILD_DELAY

#define REBUILD_DELAY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)

How long do we wait after learning about a HELLO before we rebuild the hostlist we serve? Rebuilding walks every HELLO we know and re-encodes all of them, so a PEERSTORE notification must not trigger one on its own: they arrive in batches (the initial iteration of the monitor, or everything our own client half just downloaded), and one rebuild per batch is all that batch is worth.

Definition at line 55 of file gnunet-daemon-hostlist_server.c.

Function Documentation

add_cors_headers()

static void add_cors_headers ( struct MHD_Response *  resp )

static

Add headers to a request indicating that we allow Cross-Origin Resource Sharing.

Parameters

response

response to add headers to

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

{
  GNUNET_assert (MHD_NO !=
                 MHD_add_response_header (resp,
                                          "Access-Control-Allow-Origin", "*"));
  GNUNET_assert (MHD_NO !=
                 MHD_add_response_header (resp,
                                          "Access-Control-Allow-Methods",
                                          "GET, OPTIONS"));
  GNUNET_assert (MHD_NO !=
                 MHD_add_response_header (resp, "Access-Control-Max-Age",
                                          "86400"));
}

References GNUNET_assert.

Referenced by access_handler_callback(), and finish_response().

Here is the caller graph for this function:

build_json_response()

static struct MHD_Response * build_json_response ( const struct HostSet *  host_set )

static

Definition at line 188 of file gnunet-daemon-hostlist_server.c.

{
  struct GNUNET_MessageHeader *hello;
  struct GNUNET_HELLO_Parser *hparser;
  json_t*hello_uri_j;
  json_t*hello_array;
  char *hello_uri;
  char *hello_uris;
  size_t offset = 0;
 
  hello_uri_j = json_object ();
  hello_array = json_array ();
  while (offset < host_set->size)
  {
    hello = (struct GNUNET_MessageHeader*) (host_set->data + offset);
    /* #process_notify() verified this HELLO when it entered #hellos, and
       these are our own bytes since.  Verifying again here cost one EdDSA
       verification per HELLO in the set, on every rebuild. */
    hparser = GNUNET_HELLO_parser_from_msg_ (hello, NULL, GNUNET_YES);
    if (NULL == hparser)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "HELLO from host set malformed, skipping...\n");
      offset += ntohs (hello->size);
      continue;
    }
    hello_uri = GNUNET_HELLO_parser_to_url (hparser);
    json_array_append_new (hello_array, json_string (hello_uri));
    GNUNET_free (hello_uri);
    GNUNET_HELLO_parser_free (hparser);
    offset += ntohs (hello->size);
  }
  json_object_set_new (hello_uri_j, "hellos", hello_array);
  hello_uris = json_dumps (hello_uri_j, JSON_INDENT (2));
  json_decref (hello_uri_j);
  return MHD_create_response_from_buffer (strlen (hello_uris),
                                          hello_uris,
                                          MHD_RESPMEM_MUST_FREE);
}

References HostSet::data, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_HELLO_parser_free(), GNUNET_HELLO_parser_from_msg_(), GNUNET_HELLO_parser_to_url(), GNUNET_log, GNUNET_YES, GNUNET_MessageHeader::size, and size.

Referenced by finish_response().

Here is the call graph for this function:

Here is the caller graph for this function:

finish_response()

static void finish_response ( )

static

Function that assembles our response.

Definition at line 233 of file gnunet-daemon-hostlist_server.c.

{
  if (NULL != response)
    MHD_destroy_response (response);
  if (NULL != response_json)
    MHD_destroy_response (response_json);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Creating hostlist response with %u bytes\n",
              (unsigned int) builder->size);
  response = MHD_create_response_from_buffer (builder->size,
                                              builder->data,
                                              MHD_RESPMEM_MUST_FREE);
  response_json = build_json_response (builder);
  GNUNET_assert (MHD_NO != MHD_add_response_header (response_json,
                                                    "Content-Type",
                                                    "application/json"));
  add_cors_headers (response);
  if ((NULL == daemon_handle_v4) && (NULL == daemon_handle_v6))
  {
    MHD_destroy_response (response);
    response = NULL;
    MHD_destroy_response (response_json);
    response_json = NULL;
  }
  GNUNET_STATISTICS_set (stats,
                         gettext_noop ("bytes in hostlist"),
                         builder->size,
                         GNUNET_YES);
  GNUNET_free (builder);
  builder = NULL;
}

References add_cors_headers(), build_json_response(), builder, daemon_handle_v4, daemon_handle_v6, HostSet::data, gettext_noop, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_STATISTICS_set(), GNUNET_YES, response, response_json, HostSet::size, and stats.

Referenced by rebuild_hostlist().

Here is the call graph for this function:

Here is the caller graph for this function:

host_processor()

static enum GNUNET_GenericReturnValue host_processor ( void *  cls, const struct GNUNET_PeerIdentity *  peer, void *  value  )

static

Callback that processes each of the known HELLOs for the hostlist response construction.

Parameters

cls	closure, NULL
peer	id of the peer, NULL for last call
hello	hello message for the peer (can be NULL)
err_msg	message

Definition at line 276 of file gnunet-daemon-hostlist_server.c.

{
  size_t old;
  size_t s;
  struct GNUNET_MessageHeader *hello = value;
  (void) cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "host_processor\n");
  old = builder->size;
  s = ntohs (hello->size);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received %u bytes of `%s' from peer `%s' for hostlist.\n",
              (unsigned int) s,
              "HELLO",
              GNUNET_i2s (peer));
  if ((old + s >= GNUNET_MAX_MALLOC_CHECKED) ||
      (old + s >= MAX_BYTES_PER_HOSTLISTS))
  {
    /* too large, skip! */
    GNUNET_STATISTICS_update (stats,
                              gettext_noop (
                                "bytes not included in hostlist (size limit)"),
                              s,
                              GNUNET_NO);
    return GNUNET_YES;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Adding peer `%s' to hostlist (%u bytes)\n",
              GNUNET_i2s (peer),
              (unsigned int) s);
  GNUNET_array_grow (builder->data, builder->size, old + s);
  GNUNET_memcpy (&builder->data[old], hello, s);
 
  return GNUNET_YES;
}

References builder, HostSet::data, gettext_noop, GNUNET_array_grow, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_log, GNUNET_MAX_MALLOC_CHECKED, GNUNET_memcpy, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_YES, MAX_BYTES_PER_HOSTLISTS, GNUNET_MessageHeader::size, HostSet::size, stats, and value.

Referenced by rebuild_hostlist().

Here is the call graph for this function:

Here is the caller graph for this function:

free_hello()

static enum GNUNET_GenericReturnValue free_hello ( void *  cls, const struct GNUNET_PeerIdentity *  peer, void *  value  )

static

Free one HELLO of hellos.

Parameters

cls	closure, NULL
peer	the peer the HELLO is for
value	the struct GNUNET_MessageHeader * to free

Returns

GNUNET_YES (continue to iterate)

Definition at line 325 of file gnunet-daemon-hostlist_server.c.

{
  (void) cls;
  (void) peer;
  GNUNET_free (value);
  return GNUNET_YES;
}

References GNUNET_free, GNUNET_YES, and value.

Referenced by GNUNET_HOSTLIST_server_stop().

Here is the caller graph for this function:

rebuild_hostlist()

static void rebuild_hostlist ( void *  cls )

static

Rebuild the hostlist we serve from all the HELLOs we know.

Parameters

cls	closure, NULL

Definition at line 342 of file gnunet-daemon-hostlist_server.c.

{
  (void) cls;
  rebuild_task = NULL;
  if (NULL != builder)
  {
    GNUNET_free (builder->data);
    builder->size = 0;
    builder->data = NULL;
  }
  else
  {
    builder = GNUNET_new (struct HostSet);
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Rebuilding hostlist from %u HELLOs\n",
              GNUNET_CONTAINER_multipeermap_size (hellos));
  if (0 != GNUNET_CONTAINER_multipeermap_iterate (hellos,
                                                  &host_processor,
                                                  NULL))
    finish_response ();
}

References builder, HostSet::data, finish_response(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_new, hellos, host_processor(), rebuild_task, and HostSet::size.

Referenced by schedule_rebuild().

Here is the call graph for this function:

Here is the caller graph for this function:

schedule_rebuild()

static void schedule_rebuild ( )

static

Ask for the hostlist to be rebuilt, unless that is already pending.

Definition at line 370 of file gnunet-daemon-hostlist_server.c.

{
  if (NULL != rebuild_task)
    return;
  rebuild_task = GNUNET_SCHEDULER_add_delayed (REBUILD_DELAY,
                                               &rebuild_hostlist,
                                               NULL);
}

References GNUNET_SCHEDULER_add_delayed(), REBUILD_DELAY, rebuild_hostlist(), and rebuild_task.

Referenced by process_notify().

Here is the call graph for this function:

Here is the caller graph for this function:

accept_policy_callback()

static MHD_RESULT accept_policy_callback ( void *  cls, const struct sockaddr *  addr, socklen_t  addrlen  )

static

Hostlist access policy (very permissive, allows everything).

Returns #MHD_NO only if we are not yet ready to serve.

Parameters

cls	closure
addr	address information from the client
addrlen	length of addr

Returns

#MHD_YES if connection is allowed, #MHD_NO if not (we are not ready)

Definition at line 390 of file gnunet-daemon-hostlist_server.c.

{
  if (NULL == response)
  {
    GNUNET_log (
      GNUNET_ERROR_TYPE_DEBUG,
      "Received request for hostlist, but I am not yet ready; rejecting!\n");
    return MHD_NO;
  }
  return MHD_YES; /* accept all */
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, and response.

Referenced by GNUNET_HOSTLIST_server_start().

Here is the caller graph for this function:

header_iterator()

static int header_iterator ( void *  cls, enum MHD_ValueKind  kind, const char *  key, const char *  value  )

static

Definition at line 406 of file gnunet-daemon-hostlist_server.c.

{
  enum GNUNET_GenericReturnValue *want_json = cls;
 
  if (0 != strcasecmp (key, "Accept"))
    return GNUNET_YES;
  if (0 == strcasecmp (value, "application/json"))
    *want_json = GNUNET_YES;
  return MHD_YES;
}

References GNUNET_YES, key, and value.

Referenced by access_handler_callback().

Here is the caller graph for this function:

access_handler_callback()

static MHD_RESULT access_handler_callback ( void *  cls, struct MHD_Connection *  connection, const char *  url, const char *  method, const char *  version, const char *  upload_data, size_t *  upload_data_size, void **  con_cls  )

static

Main request handler.

Parameters

cls	argument given together with the function pointer when the handler was registered with MHD
connection
url	the requested url
method	the HTTP method used (#MHD_HTTP_METHOD_GET, #MHD_HTTP_METHOD_PUT, etc.)
version	the HTTP version string (e.g. #MHD_HTTP_VERSION_1_1)
upload_data	the data being uploaded (excluding HEADERS, for a POST that fits into memory and that is encoded with a supported encoding, the POST data will NOT be given in upload_data and is instead available as part of #MHD_get_connection_values; very large POST data will be made available incrementally in upload_data)
upload_data_size	set initially to the size of the upload_data provided; the method must update this value to the number of bytes NOT processed;
con_cls	pointer that the callback can set to some address and that will be preserved by MHD for future calls for this request; since the access handler may be called many times (e.g. for a PUT/POST operation with plenty of upload data) this allows the application to easily associate some request-specific state. If necessary, this state can be cleaned up in the global #MHD_RequestCompletedCallback (which can be set with the #MHD_OPTION_NOTIFY_COMPLETED). Initially, *con_cls will be NULL.

Returns

#MHD_YES if the connection was handled successfully, #MHD_NO if the socket must be closed due to a serious error while handling the request

Definition at line 457 of file gnunet-daemon-hostlist_server.c.

{
  static int dummy;
  struct MHD_Response *selected_response;
  enum GNUNET_GenericReturnValue want_json = GNUNET_NO;
 
  /* CORS pre-flight request */
  if (0 == strcmp (MHD_HTTP_METHOD_OPTIONS, method))
  {
    struct MHD_Response *options_response;
    int rc;
 
    options_response =
      MHD_create_response_from_buffer (0, NULL, MHD_RESPMEM_PERSISTENT);
    add_cors_headers (options_response);
    rc = MHD_queue_response (connection, MHD_HTTP_OK, options_response);
    MHD_destroy_response (options_response);
    return rc;
  }
  if (0 != strcmp (method, MHD_HTTP_METHOD_GET))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Refusing `%s' request to hostlist server\n"),
                method);
    GNUNET_STATISTICS_update (stats,
                              gettext_noop (
                                "hostlist requests refused (not HTTP GET)"),
                              1,
                              GNUNET_YES);
    return MHD_NO;
  }
  if (NULL == *con_cls)
  {
    (*con_cls) = &dummy;
    return MHD_YES;
  }
  if (0 != *upload_data_size)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Refusing `%s' request with %llu bytes of upload data\n"),
                method,
                (unsigned long long) *upload_data_size);
    GNUNET_STATISTICS_update (stats,
                              gettext_noop (
                                "hostlist requests refused (upload data)"),
                              1,
                              GNUNET_YES);
    return MHD_NO;   /* do not support upload data */
  }
  selected_response = response;
  MHD_get_connection_values (connection,
                             MHD_HEADER_KIND,
                             (MHD_KeyValueIterator) & header_iterator,
                             &want_json);
  if (GNUNET_YES == want_json)
  {
    selected_response = response_json;
  }
  if (NULL == selected_response)
  {
    GNUNET_log (
      GNUNET_ERROR_TYPE_WARNING,
      _ (
        "Could not handle hostlist request since I do not have a response yet\n"));
    GNUNET_STATISTICS_update (stats,
                              gettext_noop (
                                "hostlist requests refused (not ready)"),
                              1,
                              GNUNET_YES);
    return MHD_NO;   /* internal error, no response yet */
  }
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              _ ("Received request for our hostlist\n"));
  GNUNET_STATISTICS_update (stats,
                            gettext_noop ("hostlist requests processed"),
                            1,
                            GNUNET_YES);
  return MHD_queue_response (connection, MHD_HTTP_OK, selected_response);
}

References _, add_cors_headers(), dummy, gettext_noop, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_YES, header_iterator(), response, response_json, and stats.

Referenced by GNUNET_HOSTLIST_server_start().

Here is the call graph for this function:

Here is the caller graph for this function:

adv_transmit()

static void adv_transmit ( struct GNUNET_MQ_Handle *  mq )

static

Handler called by CORE when CORE is ready to transmit message.

Parameters

cls	closure with the const struct GNUNET_PeerIdentity * of the peer we are sending to
size	size of buffer to copy message to
buf	buffer to copy message to

Returns

number of bytes copied to buf

Definition at line 555 of file gnunet-daemon-hostlist_server.c.

{
  static uint64_t hostlist_adv_count;
  size_t uri_size; /* Including \0 termination! */
  struct GNUNET_MessageHeader *header;
  struct GNUNET_MQ_Envelope *env;
 
  uri_size = strlen (hostlist_uri) + 1;
  env = GNUNET_MQ_msg_extra (header,
                             uri_size,
                             GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT);
  GNUNET_memcpy (&header[1], hostlist_uri, uri_size);
  GNUNET_MQ_env_set_options (env,
                             GNUNET_MQ_PREF_CORK_ALLOWED
                             | GNUNET_MQ_PREF_UNRELIABLE);
  GNUNET_MQ_send (mq, env);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sent advertisement message: Copied %u bytes into buffer!\n",
              (unsigned int) uri_size);
  hostlist_adv_count++;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              " # Sent advertisement message: %llu\n",
              (unsigned long long) hostlist_adv_count);
  GNUNET_STATISTICS_update (stats,
                            gettext_noop ("# hostlist advertisements send"),
                            1,
                            GNUNET_NO);
}

References env, gettext_noop, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT, GNUNET_MQ_env_set_options(), GNUNET_MQ_msg_extra, GNUNET_MQ_PREF_CORK_ALLOWED, GNUNET_MQ_PREF_UNRELIABLE, GNUNET_MQ_send(), GNUNET_NO, GNUNET_STATISTICS_update(), hostlist_uri, mq, and stats.

Referenced by connect_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

connect_handler()

static void * connect_handler ( void *  cls, const struct GNUNET_PeerIdentity *  peer, struct GNUNET_MQ_Handle *  mq, enum GNUNET_CORE_PeerClass  class  )

static

Method called whenever a given peer connects.

Parameters

cls	closure
peer	peer identity this notification is about
mq	queue for transmission to peer
class	class of the connecting peer

Returns

NULL (must!)

Definition at line 595 of file gnunet-daemon-hostlist_server.c.

{
  size_t size;
 
  if (! advertising)
    return NULL;
  if (NULL == hostlist_uri)
    return NULL;
  size = strlen (hostlist_uri) + 1;
  if (size + sizeof(struct GNUNET_MessageHeader) >= GNUNET_MAX_MESSAGE_SIZE)
  {
    GNUNET_break (0);
    return NULL;
  }
  size += sizeof(struct GNUNET_MessageHeader);
  if (NULL == core)
  {
    GNUNET_break (0);
    return NULL;
  }
  GNUNET_log (
    GNUNET_ERROR_TYPE_DEBUG,
    "Asked CORE to transmit advertisement message with a size of %u bytes to peer `%s'\n",
    (unsigned int) size,
    GNUNET_i2s (peer));
  adv_transmit (mq);
  return NULL;
}

References adv_transmit(), advertising, core, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_MAX_MESSAGE_SIZE, hostlist_uri, mq, and size.

Referenced by GNUNET_HOSTLIST_server_start().

Here is the call graph for this function:

Here is the caller graph for this function:

process_notify()

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

static

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

Parameters

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

Definition at line 638 of file gnunet-daemon-hostlist_server.c.

{
  unsigned int map_size;
  struct GNUNET_MessageHeader *hello_cpy;
  struct GNUNET_MessageHeader *old_hello;
  struct GNUNET_MessageHeader *hello;
 
  map_size = GNUNET_CONTAINER_multipeermap_size (hellos);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Peerstore is notifying us to rebuild our hostlist map size %u\n",
              map_size);
  if (NULL != err_msg)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                _ ("Error in communication with PEERSTORE service: %s\n"),
                err_msg);
    GNUNET_PEERSTORE_monitor_next (peerstore_notify, 1);
    return;
  }
  if (NULL == record)
  {
    GNUNET_break (0);
    GNUNET_PEERSTORE_monitor_next (peerstore_notify, 1);
    return;
  }
  hello = record->value;
  /* @e value and @e value_size are independent, and the HELLO is an
     unvalidated blob a remote peer published: a zero-length value leaves
     @a hello NULL, and a @e size field larger than @e value_size makes the
     GNUNET_memcpy() below read past the end of the record. */
  if ((NULL == hello) ||
      (record->value_size < sizeof (*hello)) ||
      (ntohs (hello->size) > record->value_size))
  {
    GNUNET_break_op (0);
    GNUNET_PEERSTORE_monitor_next (peerstore_notify, 1);
    return;
  }
  /* PEERSTORE stores what it is given (handle_store() validates nothing),
     and these records were published by other peers.  Check the signature
     once, here, instead of leaving it to whoever happens to parse the set
     later: it kept malformed HELLOs out of the JSON response only because
     build_json_response() had to parse to build a URL, and never kept
     them out of the binary one at all. */
  {
    struct GNUNET_HELLO_Parser *parser;
    const struct GNUNET_PeerIdentity *pid;
 
    parser = GNUNET_HELLO_parser_from_msg (hello,
                                           &record->peer);
    if (NULL == parser)
    {
      /* Not #GNUNET_break_op(): this is also how an expired HELLO fails,
         and a record outliving the signature over it is routine. */
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "HELLO for `%s' is expired or does not verify, skipping\n",
                  GNUNET_i2s (&record->peer));
      GNUNET_PEERSTORE_monitor_next (peerstore_notify, 1);
      return;
    }
    pid = GNUNET_HELLO_parser_get_id (parser);
    if ((NULL == pid) ||
        (0 != GNUNET_memcmp (pid, &record->peer)))
    {
      /* We key the map by the record's peer, so a HELLO filed under
         somebody else's identity would evict that peer's real one. */
      GNUNET_break_op (0);
      GNUNET_HELLO_parser_free (parser);
      GNUNET_PEERSTORE_monitor_next (peerstore_notify, 1);
      return;
    }
    GNUNET_HELLO_parser_free (parser);
  }
  /* A peer has exactly one current HELLO, and PEERSTORE tells us about
     every store of it -- our own client half alone re-stores everything
     it downloads, on every download round.  Appending here (as
     #GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE did) meant the map grew
     without bound, every entry was leaked, and each rebuild re-encoded
     the same HELLO once per copy. */
  hello_cpy = GNUNET_malloc (ntohs (hello->size));
  GNUNET_memcpy (hello_cpy, hello, ntohs (hello->size));
  old_hello = GNUNET_CONTAINER_multipeermap_get (hellos,
                                                 &record->peer);
  if (NULL != old_hello)
  {
    GNUNET_assert (GNUNET_YES ==
                   GNUNET_CONTAINER_multipeermap_remove (hellos,
                                                         &record->peer,
                                                         old_hello));
    GNUNET_free (old_hello);
  }
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multipeermap_put (hellos,
                                                    &record->peer,
                                                    hello_cpy,
                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  schedule_rebuild ();
  map_size = GNUNET_CONTAINER_multipeermap_size (hellos);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "1 Peerstore is notifying us to rebuild our hostlist map size %u peer %s\n",
              map_size,
              GNUNET_i2s (&record->peer));
  GNUNET_PEERSTORE_monitor_next (peerstore_notify, 1);
}

References _, GNUNET_assert, GNUNET_break, GNUNET_break_op, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_get(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_HELLO_parser_free(), GNUNET_HELLO_parser_from_msg(), GNUNET_HELLO_parser_get_id(), GNUNET_i2s(), GNUNET_log, GNUNET_malloc, GNUNET_memcmp, GNUNET_memcpy, GNUNET_PEERSTORE_monitor_next(), GNUNET_YES, hellos, map_size, peerstore_notify, record(), schedule_rebuild(), and GNUNET_MessageHeader::size.

Referenced by start_notify().

Here is the call graph for this function:

Here is the caller graph for this function:

prepare_daemon()

static struct GNUNET_SCHEDULER_Task * prepare_daemon ( struct MHD_Daemon *  daemon_handle )

static

Function that queries MHD's select sets and starts the task waiting for them.

Parameters

daemon_handle

HTTP server to prepare to run

Definition at line 784 of file gnunet-daemon-hostlist_server.c.

{
  struct GNUNET_SCHEDULER_Task *ret;
  fd_set rs;
  fd_set ws;
  fd_set es;
  struct GNUNET_NETWORK_FDSet *wrs;
  struct GNUNET_NETWORK_FDSet *wws;
  int max;
  MHD_UNSIGNED_LONG_LONG timeout;
  int haveto;
  struct GNUNET_TIME_Relative tv;
 
  FD_ZERO (&rs);
  FD_ZERO (&ws);
  FD_ZERO (&es);
  wrs = GNUNET_NETWORK_fdset_create ();
  wws = GNUNET_NETWORK_fdset_create ();
  max = -1;
  GNUNET_assert (MHD_YES == MHD_get_fdset (daemon_handle, &rs, &ws, &es, &max));
  haveto = MHD_get_timeout (daemon_handle, &timeout);
  if (haveto == MHD_YES)
    tv.rel_value_us = (uint64_t) timeout * 1000LL;
  else
    tv = GNUNET_TIME_UNIT_FOREVER_REL;
  GNUNET_NETWORK_fdset_copy_native (wrs, &rs, max + 1);
  GNUNET_NETWORK_fdset_copy_native (wws, &ws, max + 1);
  ret = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH,
                                     tv,
                                     wrs,
                                     wws,
                                     &run_daemon,
                                     daemon_handle);
  GNUNET_NETWORK_fdset_destroy (wrs);
  GNUNET_NETWORK_fdset_destroy (wws);
  return ret;
}

References GNUNET_assert, GNUNET_NETWORK_fdset_copy_native(), GNUNET_NETWORK_fdset_create(), GNUNET_NETWORK_fdset_destroy(), GNUNET_SCHEDULER_add_select(), GNUNET_SCHEDULER_PRIORITY_HIGH, GNUNET_TIME_UNIT_FOREVER_REL, max, GNUNET_TIME_Relative::rel_value_us, ret, run_daemon(), and timeout.

Referenced by GNUNET_HOSTLIST_server_start(), and run_daemon().

Here is the call graph for this function:

Here is the caller graph for this function:

run_daemon()

static void run_daemon ( void *  cls )

static

Call MHD to process pending requests and then go back and schedule the next run.

Parameters

cls	the struct MHD_Daemon of the HTTP server to run

Definition at line 761 of file gnunet-daemon-hostlist_server.c.

{
  struct MHD_Daemon *daemon_handle = cls;
 
  if (daemon_handle == daemon_handle_v4)
    hostlist_task_v4 = NULL;
  else
    hostlist_task_v6 = NULL;
  GNUNET_assert (MHD_YES == MHD_run (daemon_handle));
  if (daemon_handle == daemon_handle_v4)
    hostlist_task_v4 = prepare_daemon (daemon_handle);
  else
    hostlist_task_v6 = prepare_daemon (daemon_handle);
}

References daemon_handle_v4, GNUNET_assert, hostlist_task_v4, hostlist_task_v6, and prepare_daemon().

Referenced by prepare_daemon().

Here is the call graph for this function:

Here is the caller graph for this function:

error_cb()

static void error_cb ( void *  cls )

static

Definition at line 824 of file gnunet-daemon-hostlist_server.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              "Error in PEERSTORE monitoring\n");
}

References GNUNET_ERROR_TYPE_WARNING, and GNUNET_log.

Referenced by start_notify().

Here is the caller graph for this function:

sync_cb()

static void sync_cb ( void *  cls )

static

Definition at line 832 of file gnunet-daemon-hostlist_server.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              "Done with initial PEERSTORE iteration during monitoring\n");
}

References GNUNET_ERROR_TYPE_WARNING, and GNUNET_log.

Referenced by start_notify().

Here is the caller graph for this function:

start_notify()

static void start_notify ( void *  cls )

static

Definition at line 840 of file gnunet-daemon-hostlist_server.c.

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

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

Referenced by GNUNET_HOSTLIST_server_start().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_HOSTLIST_server_start()

int GNUNET_HOSTLIST_server_start	(	const struct GNUNET_CONFIGURATION_Handle *	c,
		struct GNUNET_STATISTICS_Handle *	st,
		struct GNUNET_CORE_Handle *	co,
		GNUNET_CORE_ConnectEventHandler *	server_ch,
		int	advertise
	)

Start server offering our hostlist.

Parameters

	c	configuration to use
	st	statistics handle to use
	co	core handle to use
[out]	server_ch	set to handler for CORE connect events
	advertise	GNUNET_YES if we should advertise our hostlist

Returns

GNUNET_OK on success

Definition at line 870 of file gnunet-daemon-hostlist_server.c.

{
  unsigned long long port;
  char *hostname;
  char *ipv4;
  char *ipv6;
  size_t size;
  struct in_addr i4;
  struct in6_addr i6;
  struct sockaddr_in v4;
  struct sockaddr_in6 v6;
  const struct sockaddr *sa4;
  const struct sockaddr *sa6;
 
  /* Keys are copied: #process_notify() puts the identity of a borrowed
     PEERSTORE record, which does not outlive the callback. */
  hellos = GNUNET_CONTAINER_multipeermap_create (16, GNUNET_NO);
  advertising = advertise;
  if (! advertising)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Advertising not enabled on this hostlist server\n");
  }
  else
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Advertising enabled on this hostlist server\n");
  }
  cfg = c;
  stats = st;
  peerstore = GNUNET_PEERSTORE_connect (cfg);
  if (NULL == peerstore)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Could not access PEERSTORE service.  Exiting.\n"));
    return GNUNET_SYSERR;
  }
  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg,
                                                          "HOSTLIST",
                                                          "HTTPPORT",
                                                          &port))
    return GNUNET_SYSERR;
  if ((0 == port) || (port > UINT16_MAX))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Invalid port number %llu.  Exiting.\n"),
                port);
    return GNUNET_SYSERR;
  }
 
  if (GNUNET_SYSERR ==
      GNUNET_CONFIGURATION_get_value_string (cfg,
                                             "HOSTLIST",
                                             "EXTERNAL_DNS_NAME",
                                             &hostname))
    hostname = GNUNET_RESOLVER_local_fqdn_get ();
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              _ ("Hostlist service starts on %s:%llu\n"),
              hostname,
              port);
  if (NULL != hostname)
  {
    size = strlen (hostname);
    if (size + 15 > MAX_URL_LEN)
    {
      GNUNET_break (0);
    }
    else
    {
      GNUNET_asprintf (&hostlist_uri,
                       "http://%s:%u/",
                       hostname,
                       (unsigned int) port);
      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                  _ ("Address to obtain hostlist: `%s'\n"),
                  hostlist_uri);
    }
    GNUNET_free (hostname);
  }
 
  if (GNUNET_CONFIGURATION_have_value (cfg, "HOSTLIST", "BINDTOIPV4"))
  {
    if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg,
                                                            "HOSTLIST",
                                                            "BINDTOIP",
                                                            &ipv4))
    {
      GNUNET_log (
        GNUNET_ERROR_TYPE_WARNING,
        _ ("BINDTOIP does not a valid IPv4 address! Ignoring BINDTOIPV4.\n"));
    }
  }
  else
    ipv4 = NULL;
  if (GNUNET_CONFIGURATION_have_value (cfg, "HOSTLIST", "BINDTOIPV6"))
  {
    if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg,
                                                            "HOSTLIST",
                                                            "BINDTOIP",
                                                            &ipv6))
    {
      GNUNET_log (
        GNUNET_ERROR_TYPE_WARNING,
        _ ("BINDTOIP does not a valid IPv4 address! Ignoring BINDTOIPV6.\n"));
    }
  }
  else
    ipv6 = NULL;
  sa4 = NULL;
  if (NULL != ipv4)
  {
    if (1 == inet_pton (AF_INET, ipv4, &i4))
    {
      memset (&v4, 0, sizeof(v4));
      v4.sin_family = AF_INET;
      v4.sin_addr = i4;
      v4.sin_port = htons (port);
#if HAVE_SOCKADDR_IN_SIN_LEN
      v4.sin_len = sizeof(v4);
#endif
      sa4 = (const struct sockaddr *) &v4;
    }
    else
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  _ (
                    "`%s' is not a valid IPv4 address! Ignoring BINDTOIPV4.\n"),
                  ipv4);
    GNUNET_free (ipv4);
  }
  sa6 = NULL;
  if (NULL != ipv6)
  {
    if (1 == inet_pton (AF_INET6, ipv6, &i6))
    {
      memset (&v6, 0, sizeof(v6));
      v6.sin6_family = AF_INET6;
      v6.sin6_addr = i6;
      v6.sin6_port = htons (port);
#if HAVE_SOCKADDR_IN_SIN_LEN
      v6.sin6_len = sizeof(v6);
#endif
      sa6 = (const struct sockaddr *) &v6;
    }
    else
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  _ (
                    "`%s' is not a valid IPv6 address! Ignoring BINDTOIPV6.\n"),
                  ipv6);
    GNUNET_free (ipv6);
  }
 
  daemon_handle_v6 = MHD_start_daemon (MHD_USE_IPv6 | MHD_USE_DEBUG,
                                       (uint16_t) port,
                                       &accept_policy_callback,
                                       NULL,
                                       &access_handler_callback,
                                       NULL,
                                       MHD_OPTION_CONNECTION_LIMIT,
                                       (unsigned int) 128,
                                       MHD_OPTION_PER_IP_CONNECTION_LIMIT,
                                       (unsigned int) 32,
                                       MHD_OPTION_CONNECTION_TIMEOUT,
                                       (unsigned int) 16,
                                       MHD_OPTION_CONNECTION_MEMORY_LIMIT,
                                       (size_t) (16 * 1024),
                                       MHD_OPTION_SOCK_ADDR,
                                       sa6,
                                       MHD_OPTION_END);
  daemon_handle_v4 = MHD_start_daemon (MHD_NO_FLAG | MHD_USE_DEBUG,
                                       (uint16_t) port,
                                       &accept_policy_callback,
                                       NULL,
                                       &access_handler_callback,
                                       NULL,
                                       MHD_OPTION_CONNECTION_LIMIT,
                                       (unsigned int) 128,
                                       MHD_OPTION_PER_IP_CONNECTION_LIMIT,
                                       (unsigned int) 32,
                                       MHD_OPTION_CONNECTION_TIMEOUT,
                                       (unsigned int) 16,
                                       MHD_OPTION_CONNECTION_MEMORY_LIMIT,
                                       (size_t) (16 * 1024),
                                       MHD_OPTION_SOCK_ADDR,
                                       sa4,
                                       MHD_OPTION_END);
 
  if ((NULL == daemon_handle_v6) && (NULL == daemon_handle_v4))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Could not start hostlist HTTP server on port %u\n"),
                (unsigned short) port);
    return GNUNET_SYSERR;
  }
 
  core = co;
  *server_ch = &connect_handler;
  if (NULL != daemon_handle_v4)
    hostlist_task_v4 = prepare_daemon (daemon_handle_v4);
  if (NULL != daemon_handle_v6)
    hostlist_task_v6 = prepare_daemon (daemon_handle_v6);
  peerstore_notify_task = GNUNET_SCHEDULER_add_delayed (
    GNUNET_TIME_UNIT_MINUTES,
    start_notify,
    NULL);
  return GNUNET_OK;
}

References _, accept_policy_callback(), access_handler_callback(), advertising, cfg, connect_handler(), core, daemon_handle_v4, daemon_handle_v6, GNUNET_asprintf(), GNUNET_break, GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_have_value(), GNUNET_CONTAINER_multipeermap_create(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_PEERSTORE_connect(), GNUNET_RESOLVER_local_fqdn_get(), GNUNET_SCHEDULER_add_delayed(), GNUNET_SYSERR, GNUNET_TIME_UNIT_MINUTES, hellos, hostlist_task_v4, hostlist_task_v6, hostlist_uri, ipv4, ipv6, MAX_URL_LEN, peerstore, peerstore_notify_task, port, prepare_daemon(), server_ch, size, st, start_notify(), and stats.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_HOSTLIST_server_stop()

void GNUNET_HOSTLIST_server_stop

(

void

)

Stop server offering our hostlist.

Definition at line 1086 of file gnunet-daemon-hostlist_server.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Hostlist server shutdown\n");
  if (NULL != rebuild_task)
  {
    GNUNET_SCHEDULER_cancel (rebuild_task);
    rebuild_task = NULL;
  }
  if (NULL != hostlist_task_v6)
  {
    GNUNET_SCHEDULER_cancel (hostlist_task_v6);
    hostlist_task_v6 = NULL;
  }
  if (NULL != hostlist_task_v4)
  {
    GNUNET_SCHEDULER_cancel (hostlist_task_v4);
    hostlist_task_v4 = NULL;
  }
  if (NULL != daemon_handle_v4)
  {
    MHD_stop_daemon (daemon_handle_v4);
    daemon_handle_v4 = NULL;
  }
  if (NULL != daemon_handle_v6)
  {
    MHD_stop_daemon (daemon_handle_v6);
    daemon_handle_v6 = NULL;
  }
  if (NULL != response)
  {
    MHD_destroy_response (response);
    response = NULL;
  }
  if (NULL != response_json)
  {
    MHD_destroy_response (response_json);
    response_json = NULL;
  }
  if (NULL != peerstore_notify)
  {
    GNUNET_PEERSTORE_monitor_stop (peerstore_notify);
    peerstore_notify = NULL;
  }
  else if (NULL != peerstore_notify_task)
  {
    GNUNET_SCHEDULER_cancel (peerstore_notify_task);
  }
  if (NULL != builder)
  {
    GNUNET_free (builder->data);
    GNUNET_free (builder);
    builder = NULL;
  }
  if (NULL != hellos)
  {
    GNUNET_CONTAINER_multipeermap_iterate (hellos,
                                           &free_hello,
                                           NULL);
    GNUNET_CONTAINER_multipeermap_destroy (hellos);
    hellos = NULL;
  }
  if (NULL != peerstore)
  {
    GNUNET_PEERSTORE_disconnect (peerstore);
    peerstore = NULL;
  }
  cfg = NULL;
  stats = NULL;
  core = NULL;
}

References builder, cfg, core, daemon_handle_v4, daemon_handle_v6, HostSet::data, free_hello(), GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_PEERSTORE_disconnect(), GNUNET_PEERSTORE_monitor_stop(), GNUNET_SCHEDULER_cancel(), hellos, hostlist_task_v4, hostlist_task_v6, peerstore, peerstore_notify, peerstore_notify_task, rebuild_task, response, response_json, and stats.

Referenced by cleaning_task().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

hellos

struct GNUNET_CONTAINER_MultiPeerMap* hellos

Map with hellos we build the hostlist with.

At most one HELLO per peer.

Definition at line 61 of file gnunet-daemon-hostlist_server.c.

Referenced by GNUNET_HOSTLIST_server_start(), GNUNET_HOSTLIST_server_stop(), process_notify(), and rebuild_hostlist().

daemon_handle_v6

struct MHD_Daemon* daemon_handle_v6

static

Handle to the HTTP server as provided by libmicrohttpd for IPv6.

Definition at line 66 of file gnunet-daemon-hostlist_server.c.

Referenced by finish_response(), GNUNET_HOSTLIST_server_start(), and GNUNET_HOSTLIST_server_stop().

daemon_handle_v4

struct MHD_Daemon* daemon_handle_v4

static

Handle to the HTTP server as provided by libmicrohttpd for IPv4.

Definition at line 71 of file gnunet-daemon-hostlist_server.c.

Referenced by finish_response(), GNUNET_HOSTLIST_server_start(), GNUNET_HOSTLIST_server_stop(), and run_daemon().

cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

static

Our configuration.

Definition at line 76 of file gnunet-daemon-hostlist_server.c.

Referenced by GNUNET_HOSTLIST_server_start(), GNUNET_HOSTLIST_server_stop(), and start_notify().

stats

struct GNUNET_STATISTICS_Handle* stats

static

For keeping statistics.

Definition at line 81 of file gnunet-daemon-hostlist_server.c.

Referenced by access_handler_callback(), adv_transmit(), finish_response(), GNUNET_HOSTLIST_server_start(), GNUNET_HOSTLIST_server_stop(), and host_processor().

core

struct GNUNET_CORE_Handle* core

static

Handle to the core service (NULL until we've connected to it).

Definition at line 86 of file gnunet-daemon-hostlist_server.c.

Referenced by connect_handler(), GNUNET_HOSTLIST_server_start(), and GNUNET_HOSTLIST_server_stop().

peerstore_notify_task

struct GNUNET_SCHEDULER_Task* peerstore_notify_task

The task to delayed start the notification process initially.

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

Definition at line 92 of file gnunet-daemon-hostlist_server.c.

Referenced by GNUNET_HOSTLIST_server_start(), and GNUNET_HOSTLIST_server_stop().

peerstore_notify

struct GNUNET_PEERSTORE_Monitor* peerstore_notify

static

Our peerstore notification context.

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

Definition at line 98 of file gnunet-daemon-hostlist_server.c.

Referenced by GNUNET_HOSTLIST_server_stop(), process_notify(), and start_notify().

hostlist_task_v4

struct GNUNET_SCHEDULER_Task* hostlist_task_v4

static

Our primary task for IPv4.

Definition at line 103 of file gnunet-daemon-hostlist_server.c.

Referenced by GNUNET_HOSTLIST_server_start(), GNUNET_HOSTLIST_server_stop(), and run_daemon().

hostlist_task_v6

struct GNUNET_SCHEDULER_Task* hostlist_task_v6

static

Our primary task for IPv6.

Definition at line 108 of file gnunet-daemon-hostlist_server.c.

Referenced by GNUNET_HOSTLIST_server_start(), GNUNET_HOSTLIST_server_stop(), and run_daemon().

rebuild_task

struct GNUNET_SCHEDULER_Task* rebuild_task

static

Task that rebuilds our response from hellos, or NULL if no rebuild is pending.

Definition at line 114 of file gnunet-daemon-hostlist_server.c.

Referenced by GNUNET_HOSTLIST_server_stop(), rebuild_hostlist(), and schedule_rebuild().

response

struct MHD_Response* response

static

Our canonical response.

Definition at line 119 of file gnunet-daemon-hostlist_server.c.

Referenced by accept_policy_callback(), access_handler_callback(), callback_found_message(), clean_result(), do_error(), do_error(), do_error(), finish_response(), get_cont(), GNUNET_CURL_perform2(), GNUNET_HOSTLIST_server_stop(), GNUNET_SCALARPRODUCT_accept_computation(), GNUNET_SCALARPRODUCT_start_computation(), iterate_srv_handle_sync_finished(), on_message(), open_static_resource(), and reconnect_task().

response_json

struct MHD_Response* response_json

static

Our json response.

Definition at line 124 of file gnunet-daemon-hostlist_server.c.

Referenced by access_handler_callback(), finish_response(), and GNUNET_HOSTLIST_server_stop().

peerstore

struct GNUNET_PEERSTORE_Handle* peerstore

static

Handle to the PEERSTORE service.

Definition at line 129 of file gnunet-daemon-hostlist_server.c.

Referenced by GNUNET_HOSTLIST_server_start(), and GNUNET_HOSTLIST_server_stop().

advertising

int advertising

static

Set if we are allowed to advertise our hostlist to others.

Definition at line 134 of file gnunet-daemon-hostlist_server.c.

Referenced by connect_handler(), and GNUNET_HOSTLIST_server_start().

hostlist_uri

char* hostlist_uri

static

Buffer for the hostlist address.

Definition at line 139 of file gnunet-daemon-hostlist_server.c.

Referenced by adv_transmit(), connect_handler(), and GNUNET_HOSTLIST_server_start().

builder

struct HostSet* builder

static

NULL if we are not currently iterating over peer information.

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

Referenced by do_generate_pid(), env_resign_cb(), finish_response(), GNUNET_HELLO_build_url(), GNUNET_HELLO_builder_add_address(), GNUNET_HELLO_builder_del_address(), GNUNET_HELLO_builder_free(), GNUNET_HELLO_builder_from_parser(), GNUNET_HELLO_builder_hash_addresses(), GNUNET_HELLO_builder_iterate(), GNUNET_HELLO_builder_new(), GNUNET_HELLO_builder_to_block(), GNUNET_HELLO_builder_to_dht_hello_msg(), GNUNET_HELLO_builder_to_env(), GNUNET_HELLO_builder_to_url(), GNUNET_HELLO_builder_to_url2(), GNUNET_HELLO_get_builder_to_block_size(), GNUNET_HOSTLIST_server_stop(), GNUNET_PILS_feed_addresses(), GNUNET_PILS_sign_hello(), host_processor(), pid_changed_cb(), rebuild_hostlist(), and url_resign_cb().