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

#include "platform.h"
#include <microhttpd.h>
#include "gnunet-daemon-hostlist_server.h"
#include "gnunet_hello_lib.h"
#include "gnunet_peerinfo_service.h"
#include "gnunet-daemon-hostlist.h"
#include "gnunet_resolver_service.h"
#include "gnunet_mhd_compat.h"

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

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? More...

Functions
static void	add_cors_headers (struct MHD_Response *response)
	Add headers to a request indicating that we allow Cross-Origin Resource Sharing. More...

static void	finish_response ()
	Function that assembles our response. More...

static int	check_has_addr (void cls, const struct GNUNET_HELLO_Address address, struct GNUNET_TIME_Absolute expiration)
	Set cls to GNUNET_YES (we have an address!). More...

static void	host_processor (void cls, const struct GNUNET_PeerIdentity peer, const struct GNUNET_HELLO_Message hello, const char err_msg)
	Callback that processes each of the known HELLOs for the hostlist response construction. More...

static MHD_RESULT	accept_policy_callback (void cls, const struct sockaddr addr, socklen_t addrlen)
	Hostlist access policy (very permissive, allows everything). More...

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. More...

static void	adv_transmit (struct GNUNET_MQ_Handle *mq)
	Handler called by CORE when CORE is ready to transmit message. More...

static void *	connect_handler (void cls, const struct GNUNET_PeerIdentity peer, struct GNUNET_MQ_Handle *mq)
	Method called whenever a given peer connects. More...

static void	process_notify (void cls, const struct GNUNET_PeerIdentity peer, const struct GNUNET_HELLO_Message hello, const char err_msg)
	PEERINFO calls this function to let us know about a possible peer that we might want to connect to. More...

static 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. More...

static void	run_daemon (void *cls)
	Call MHD to process pending requests and then go back and schedule the next run. More...

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. More...

void	GNUNET_HOSTLIST_server_stop ()
	Stop server offering our hostlist. More...

Variables
static struct MHD_Daemon *	daemon_handle_v6
	Handle to the HTTP server as provided by libmicrohttpd for IPv6. More...

static struct MHD_Daemon *	daemon_handle_v4
	Handle to the HTTP server as provided by libmicrohttpd for IPv4. More...

static const struct GNUNET_CONFIGURATION_Handle *	cfg
	Our configuration. More...

static struct GNUNET_STATISTICS_Handle *	stats
	For keeping statistics. More...

static struct GNUNET_CORE_Handle *	core
	Handle to the core service (NULL until we've connected to it). More...

static struct GNUNET_PEERINFO_NotifyContext *	notify
	Handle to the peerinfo notify service (NULL until we've connected to it). More...

static struct GNUNET_SCHEDULER_Task *	hostlist_task_v4
	Our primary task for IPv4. More...

static struct GNUNET_SCHEDULER_Task *	hostlist_task_v6
	Our primary task for IPv6. More...

static struct MHD_Response *	response
	Our canonical response. More...

static struct GNUNET_PEERINFO_Handle *	peerinfo
	Handle for accessing peerinfo service. More...

static int	advertising
	Set if we are allowed to advertise our hostlist to others. More...

static char *	hostlist_uri
	Buffer for the hostlist address. More...

static struct HostSet *	builder
	NULL if we are not currently iterating over peer information. More...

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 42 of file gnunet-daemon-hostlist_server.c.

Function Documentation

◆ add_cors_headers()

static void add_cors_headers ( struct MHD_Response * response )

static

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

Parameters

response response to add headers to

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

 {
   MHD_add_response_header (response, "Access-Control-Allow-Origin", "*");
   MHD_add_response_header (response,
                            "Access-Control-Allow-Methods",
                            "GET, OPTIONS");
   MHD_add_response_header (response, "Access-Control-Max-Age", "86400");
 }

References response.

Referenced by access_handler_callback(), and finish_response().

Here is the caller graph for this function:

◆ finish_response()

static void finish_response ( )

static

Function that assembles our response.

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

 {
   if (NULL != response)
     MHD_destroy_response (response);
   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);
   add_cors_headers (response);
   if ((NULL == daemon_handle_v4) && (NULL == daemon_handle_v6))
   {
     MHD_destroy_response (response);
     response = NULL;
   }
   GNUNET_STATISTICS_set (stats,
                          gettext_noop ("bytes in hostlist"),
                          builder->size,
                          GNUNET_YES);
   GNUNET_free (builder);
   builder = NULL;
 }

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

Referenced by host_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_has_addr()

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

static

Set cls to GNUNET_YES (we have an address!).

Parameters

cls	closure, an `int *`
address	the address (ignored)
expiration	expiration time (call is ignored if this is in the past)

Returns: GNUNET_SYSERR to stop iterating (unless expiration has occurred)

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

 {
   int *arg = cls;
  
   if (0 == GNUNET_TIME_absolute_get_remaining (expiration).rel_value_us)
   {
     GNUNET_STATISTICS_update (stats,
                               gettext_noop ("expired addresses encountered"),
                               1,
                               GNUNET_YES);
     return GNUNET_YES;   /* ignore this address */
   }
   *arg = GNUNET_YES;
   return GNUNET_SYSERR;
 }

References find_typedefs::arg, expiration, gettext_noop, GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_TIME_absolute_get_remaining(), GNUNET_YES, and stats.

Referenced by host_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ host_processor()

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

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 219 of file gnunet-daemon-hostlist_server.c.

 {
   size_t old;
   size_t s;
   int has_addr;
  
   if (NULL != err_msg)
   {
     GNUNET_assert (NULL == peer);
     builder->pitr = NULL;
     GNUNET_free (builder->data);
     GNUNET_free (builder);
     builder = NULL;
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                 _ ("Error in communication with PEERINFO service: %s\n"),
                 err_msg);
     return;
   }
   if (NULL == peer)
   {
     builder->pitr = NULL;
     finish_response ();
     return;
   }
   if (NULL == hello)
     return;
   has_addr = GNUNET_NO;
   GNUNET_HELLO_iterate_addresses (hello, GNUNET_NO, &check_has_addr, &has_addr);
   if (GNUNET_NO == has_addr)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "HELLO for peer `%4s' has no address, not suitable for hostlist!\n",
                 GNUNET_i2s (peer));
     GNUNET_STATISTICS_update (stats,
                               gettext_noop (
                                 "HELLOs without addresses encountered (ignored)"),
                               1,
                               GNUNET_NO);
     return;
   }
   old = builder->size;
   s = GNUNET_HELLO_size (hello);
   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_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);
 }

References _, builder, check_has_addr(), HostSet::data, finish_response(), gettext_noop, GNUNET_array_grow, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_HELLO_iterate_addresses(), GNUNET_HELLO_size(), GNUNET_i2s(), GNUNET_log, GNUNET_MAX_MALLOC_CHECKED, GNUNET_memcpy, GNUNET_NO, GNUNET_STATISTICS_update(), MAX_BYTES_PER_HOSTLISTS, peer, HostSet::pitr, HostSet::size, and stats.

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 299 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:

◆ 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 350 of file gnunet-daemon-hostlist_server.c.

 {
   static int dummy;
  
   /* 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 */
   }
   if (NULL == 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, response);
 }

References _, add_cors_headers(), dummy, gettext_noop, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_STATISTICS_update(), GNUNET_YES, MHD_HTTP_OK, response, 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 437 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
	)

static

Method called whenever a given peer connects.

Parameters

cls	closure
peer	peer identity this notification is about
mq	queue for transmission to peer

Returns: NULL (must!)

Definition at line 476 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, peer, 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_PeerIdentity *	peer,
		const struct GNUNET_HELLO_Message *	hello,
		const char *	err_msg
	)

static

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

Parameters

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

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

 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Peerinfo is notifying us to rebuild our hostlist\n");
   if (NULL != err_msg)
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                 _ ("Error in communication with PEERINFO service: %s\n"),
                 err_msg);
   if (NULL != builder)
   {
     /* restart re-build already in progress ... */
     if (NULL != builder->pitr)
     {
       GNUNET_PEERINFO_iterate_cancel (builder->pitr);
       builder->pitr = NULL;
     }
     GNUNET_free (builder->data);
     builder->size = 0;
     builder->data = NULL;
   }
   else
   {
     builder = GNUNET_new (struct HostSet);
   }
   GNUNET_assert (NULL != peerinfo);
   builder->pitr =
     GNUNET_PEERINFO_iterate (peerinfo, GNUNET_NO, NULL, &host_processor, NULL);
 }

References _, builder, HostSet::data, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_PEERINFO_iterate(), GNUNET_PEERINFO_iterate_cancel(), host_processor(), peerinfo, HostSet::pitr, and HostSet::size.

Referenced by GNUNET_HOSTLIST_server_start().

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 589 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 566 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:

◆ 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 639 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;
  
   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;
   peerinfo = GNUNET_PEERINFO_connect (cfg);
   if (NULL == peerinfo)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 _ ("Could not access PEERINFO 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);
   notify = GNUNET_PEERINFO_notify (cfg, GNUNET_NO, &process_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_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_PEERINFO_connect(), GNUNET_PEERINFO_notify(), GNUNET_RESOLVER_local_fqdn_get(), GNUNET_SYSERR, hostlist_task_v4, hostlist_task_v6, hostlist_uri, hostname, ipv4, ipv6, MAX_URL_LEN, notify, peerinfo, port, prepare_daemon(), process_notify(), server_ch, size, st, 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 849 of file gnunet-daemon-hostlist_server.c.

 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Hostlist server shutdown\n");
   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 != notify)
   {
     GNUNET_PEERINFO_notify_cancel (notify);
     notify = NULL;
   }
   if (NULL != builder)
   {
     if (NULL != builder->pitr)
     {
       GNUNET_PEERINFO_iterate_cancel (builder->pitr);
       builder->pitr = NULL;
     }
     GNUNET_free (builder->data);
     GNUNET_free (builder);
     builder = NULL;
   }
   if (NULL != peerinfo)
   {
     GNUNET_PEERINFO_disconnect (peerinfo);
     peerinfo = NULL;
   }
   cfg = NULL;
   stats = NULL;
   core = NULL;
 }