#include "platform.h"
#include <microhttpd.h>
#include "gnunet_util_lib.h"
#include "gnunet_rest_plugin.h"
#include "gnunet_mhd_compat.h"
#include "config_plugin.h"
#include "copying_plugin.h"
#include "identity_plugin.h"
#include "namestore_plugin.h"
#include "gns_plugin.h"
#include "reclaim_plugin.h"

Include dependency graph for gnunet-rest-server.c:

Data Structures
struct	PluginListEntry
	A plugin list entry. More...

struct	MhdConnectionHandle
	MHD Connection handle. More...

struct	AcceptedRequest
	Accepted requests. More...

Macros
#define	GNUNET_REST_SERVICE_PORT 7776
	Default Socks5 listen port. More...

#define	MAX_HTTP_URI_LENGTH 2048
	Maximum supported length for a URI. More...

#define	HTTP_PORT 80
	Port for plaintext HTTP. More...

#define	HTTPS_PORT 443
	Port for HTTPS. More...

#define	MHD_CACHE_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
	After how long do we clean up unused MHD SSL/TLS instances? More...

#define	GN_REST_STATE_INIT 0

#define	GN_REST_STATE_PROCESSING 1

Functions
static void	do_httpd (void *cls)
	Task run whenever HTTP server operations are pending. More...

static void	run_mhd_now ()
	Run MHD now, we have extra data ready for the callback. More...

static void	plugin_callback (void cls, struct MHD_Response resp, int status)
	Plugin result callback. More...

static int	cleanup_url_map (void cls, const struct GNUNET_HashCode key, void *value)

static void	cleanup_handle (struct MhdConnectionHandle *handle)

static void	cleanup_ar (struct AcceptedRequest *ar)

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

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

static MHD_RESULT	post_data_iter (void cls, enum MHD_ValueKind kind, const char key, const char filename, const char content_type, const char transfer_encoding, const char data, uint64_t off, size_t size)

static MHD_RESULT	create_response (void cls, struct MHD_Connection con, const char url, const char meth, const char ver, const char upload_data, size_t upload_data_size, void *con_cls)
	Main MHD callback for handling requests. More...

static void	kill_httpd ()
	Kill the MHD daemon. More...

static void	schedule_httpd ()
	Schedule MHD. More...

static void *	mhd_log_callback (void cls, const char url, struct MHD_Connection *connection)
	Function called when MHD first processes an incoming connection. More...

static void	mhd_completed_cb (void cls, struct MHD_Connection connection, void **con_cls, enum MHD_RequestTerminationCode toe)
	Function called when MHD decides that we are done with a connection. More...

static void	mhd_connection_cb (void cls, struct MHD_Connection connection, void **con_cls, enum MHD_ConnectionNotificationCode cnc)
	Function called when MHD connection is opened or closed. More...

static void	do_accept (void *cls)
	Accept new incoming connections. More...

static void	do_shutdown (void *cls)
	Task run on shutdown. More...

static struct GNUNET_NETWORK_Handle *	bind_v4 ()
	Create an IPv4 listen socket bound to our port. More...

static struct GNUNET_NETWORK_Handle *	bind_v6 ()
	Create an IPv6 listen socket bound to our port. More...

static enum GNUNET_GenericReturnValue	setup_plugin (const char name, GNUNET_REST_ProcessingFunction proc, void plugin_cls)
	Callback for plugin load. More...

static void	run (void cls, char const args, const char cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
	Main function that will be run. More...

Variables
static struct GNUNET_SCHEDULER_Task *	httpd_task
	The task ID. More...

static in_addr_t	address
	The address to bind to. More...

static struct in6_addr	address6
	The IPv6 address to bind to. More...

static unsigned long long	port = 7776
	The port the service is running on (default 7776) More...

static struct GNUNET_NETWORK_Handle *	lsock4
	The listen socket of the service for IPv4. More...

static struct GNUNET_NETWORK_Handle *	lsock6
	The listen socket of the service for IPv6. More...

static struct GNUNET_SCHEDULER_Task *	ltask4
	The listen task ID for IPv4. More...

static struct GNUNET_SCHEDULER_Task *	ltask6
	The listen task ID for IPv6. More...

static struct MHD_Daemon *	httpd
	Daemon for HTTP. More...

static struct MHD_Response *	failure_response
	Response we return on failures. More...

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

static int	echo_origin
	Echo request Origin in CORS. More...

static int	basic_auth_enabled
	Do basic auth of user. More...

static char *	basic_auth_secret
	Basic auth secret. More...

char	cuser [_POSIX_LOGIN_NAME_MAX]
	User of the service. More...

static char *	allow_origins
	Allowed Origins (CORS) More...

static char *	allow_headers
	Allowed Headers (CORS) More...

static char *	allow_credentials
	Allowed Credentials (CORS) More...

static struct PluginListEntry *	plugins_head
	Plugin list head. More...

static struct PluginListEntry *	plugins_tail
	Plugin list tail. More...

static struct AcceptedRequest *	req_list_head
	AcceptedRequest list head. More...

static struct AcceptedRequest *	req_list_tail
	AcceptedRequest list tail. More...

struct GNUNET_REST_Plugin *	config_plugin
	plugins More...

struct GNUNET_REST_Plugin *	copying_plugin

struct GNUNET_REST_Plugin *	identity_plugin

struct GNUNET_REST_Plugin *	namestore_plugin

struct GNUNET_REST_Plugin *	gns_plugin

struct GNUNET_REST_Plugin *	reclaim_plugin

Macro Definition Documentation

◆ GNUNET_REST_SERVICE_PORT

#define GNUNET_REST_SERVICE_PORT 7776

Default Socks5 listen port.

Definition at line 45 of file gnunet-rest-server.c.

◆ MAX_HTTP_URI_LENGTH

#define MAX_HTTP_URI_LENGTH 2048

Maximum supported length for a URI.

Should die.

Deprecated:

Definition at line 51 of file gnunet-rest-server.c.

◆ HTTP_PORT

#define HTTP_PORT 80

Port for plaintext HTTP.

Definition at line 56 of file gnunet-rest-server.c.

◆ HTTPS_PORT

#define HTTPS_PORT 443

Port for HTTPS.

Definition at line 61 of file gnunet-rest-server.c.

◆ MHD_CACHE_TIMEOUT

#define MHD_CACHE_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)

After how long do we clean up unused MHD SSL/TLS instances?

Definition at line 66 of file gnunet-rest-server.c.

◆ GN_REST_STATE_INIT

#define GN_REST_STATE_INIT 0

Definition at line 69 of file gnunet-rest-server.c.

◆ GN_REST_STATE_PROCESSING

#define GN_REST_STATE_PROCESSING 1

Definition at line 70 of file gnunet-rest-server.c.

Function Documentation

◆ do_httpd()

static void do_httpd ( void * cls )

static

Task run whenever HTTP server operations are pending.

Parameters

cls NULL

Definition at line 932 of file gnunet-rest-server.c.

{
  httpd_task = NULL;
  MHD_run (httpd);
  schedule_httpd ();
}

References httpd, httpd_task, and schedule_httpd().

Referenced by run_mhd_now(), and schedule_httpd().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ run_mhd_now()

static void run_mhd_now ( )

static

Run MHD now, we have extra data ready for the callback.

Definition at line 289 of file gnunet-rest-server.c.

{
  if (NULL != httpd_task)
  {
    GNUNET_SCHEDULER_cancel (httpd_task);
    httpd_task = NULL;
  }
  httpd_task = GNUNET_SCHEDULER_add_now (&do_httpd, NULL);
}

References do_httpd(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), and httpd_task.

Referenced by create_response(), and plugin_callback().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ plugin_callback()

static void plugin_callback	(	void *	cls,
		struct MHD_Response *	resp,
		int	status
	)

static

Plugin result callback.

Parameters

cls	closure (MHD connection handle)
data	the data to return to the caller
len	length of the data
status	GNUNET_OK if successful

Definition at line 309 of file gnunet-rest-server.c.

{
  struct MhdConnectionHandle *handle = cls;
 
  handle->status = status;
  handle->response = resp;
  MHD_resume_connection (handle->con);
  run_mhd_now ();
}

References handle, run_mhd_now(), and status.

Referenced by create_response().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cleanup_url_map()

static int cleanup_url_map	(	void *	cls,
		const struct GNUNET_HashCode *	key,
		void *	value
	)

static

Definition at line 321 of file gnunet-rest-server.c.

{
  GNUNET_free (value);
  return GNUNET_YES;
}

References GNUNET_free, GNUNET_YES, and value.

Referenced by cleanup_handle().

Here is the caller graph for this function:

◆ cleanup_handle()

static void cleanup_handle ( struct MhdConnectionHandle * handle )

static

Definition at line 329 of file gnunet-rest-server.c.

{
  if (NULL != handle->response)
    MHD_destroy_response (handle->response);
  if (NULL != handle->data_handle)
  {
    if (NULL != handle->data_handle->header_param_map)
    {
      GNUNET_CONTAINER_multihashmap_iterate (handle->data_handle
                                             ->header_param_map,
                                             &cleanup_url_map,
                                             NULL);
      GNUNET_CONTAINER_multihashmap_destroy (
        handle->data_handle->header_param_map);
    }
    if (NULL != handle->data_handle->url_param_map)
    {
      GNUNET_CONTAINER_multihashmap_iterate (handle->data_handle->url_param_map,
                                             &cleanup_url_map,
                                             NULL);
      GNUNET_CONTAINER_multihashmap_destroy (
        handle->data_handle->url_param_map);
    }
    GNUNET_free (handle->data_handle);
  }
  GNUNET_free (handle);
}

References cleanup_url_map(), GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_free, and handle.

Referenced by cleanup_ar(), and mhd_completed_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cleanup_ar()

static void cleanup_ar ( struct AcceptedRequest * ar )

static

Definition at line 359 of file gnunet-rest-server.c.

{
  if (NULL != ar->con_handle)
  {
    cleanup_handle (ar->con_handle);
  }
  if (GNUNET_YES == ar->socket_with_mhd)
  {
    GNUNET_NETWORK_socket_free_memory_only_ (ar->sock);
  }
  else
  {
    GNUNET_NETWORK_socket_close (ar->sock);
  }
  ar->sock = NULL;
  GNUNET_CONTAINER_DLL_remove (req_list_head,
                               req_list_tail,
                               ar);
  GNUNET_free (ar);
}

References cleanup_handle(), AcceptedRequest::con_handle, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_free_memory_only_(), GNUNET_YES, req_list_head, req_list_tail, AcceptedRequest::sock, and AcceptedRequest::socket_with_mhd.

Referenced by mhd_connection_cb().

Here is the call graph for this function:

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 382 of file gnunet-rest-server.c.

{
  struct GNUNET_REST_RequestHandle *handle = cls;
  struct GNUNET_HashCode hkey;
  char *val;
  char *lowerkey;
 
  lowerkey = GNUNET_strdup (key);
  GNUNET_STRINGS_utf8_tolower (key, lowerkey);
  GNUNET_CRYPTO_hash (lowerkey, strlen (lowerkey), &hkey);
  GNUNET_asprintf (&val, "%s", value);
  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (
        handle->header_param_map,
        &hkey,
        val,
        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Could not load add header `%s'=%s\n",
                lowerkey,
                value);
  }
  GNUNET_free (lowerkey);
  return MHD_YES;
}

References GNUNET_asprintf(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_OK, GNUNET_strdup, GNUNET_STRINGS_utf8_tolower(), handle, key, and value.

Referenced by create_response().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ url_iterator()

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

static

Definition at line 413 of file gnunet-rest-server.c.

{
  struct GNUNET_REST_RequestHandle *handle = cls;
  struct GNUNET_HashCode hkey;
  char *val;
 
  GNUNET_CRYPTO_hash (key, strlen (key), &hkey);
  GNUNET_asprintf (&val, "%s", value);
  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (
        handle->url_param_map,
        &hkey,
        val,
        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Could not load add url param `%s'=%s\n",
                key,
                value);
  }
  return MHD_YES;
}

References GNUNET_asprintf(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_OK, handle, key, and value.

Referenced by create_response().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ post_data_iter()

static MHD_RESULT post_data_iter	(	void *	cls,
		enum MHD_ValueKind	kind,
		const char *	key,
		const char *	filename,
		const char *	content_type,
		const char *	transfer_encoding,
		const char *	data,
		uint64_t	off,
		size_t	size
	)

static

Definition at line 440 of file gnunet-rest-server.c.

{
  struct GNUNET_REST_RequestHandle *handle = cls;
  struct GNUNET_HashCode hkey;
  char *val;
 
  if (MHD_POSTDATA_KIND != kind)
    return MHD_YES;
 
  GNUNET_CRYPTO_hash (key, strlen (key), &hkey);
  val = GNUNET_CONTAINER_multihashmap_get (handle->url_param_map,
                                           &hkey);
  if (NULL == val)
  {
    val = GNUNET_malloc (65536);
    if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (
          handle->url_param_map,
          &hkey,
          val,
          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Could not add url param '%s'\n",
                  key);
      GNUNET_free (val);
    }
  }
  memcpy (val + off, data, size);
  return MHD_YES;
}

References data, GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_malloc, GNUNET_OK, handle, key, and size.

Referenced by create_response().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_response()

static MHD_RESULT create_response	(	void *	cls,
		struct MHD_Connection *	con,
		const char *	url,
		const char *	meth,
		const char *	ver,
		const char *	upload_data,
		size_t *	upload_data_size,
		void **	con_cls
	)

static

Main MHD callback for handling requests.

Parameters

cls	unused
con	MHD connection handle
url	the url in the request
meth	the HTTP method used ("GET", "PUT", etc.)
ver	the HTTP version string ("HTTP/1.1" for version 1.1, etc.)
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 to location where we store the 'struct Request'

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

Request not handled

Definition at line 506 of file gnunet-rest-server.c.

{
  char *origin;
  char *pw;
  char *user;
  struct AcceptedRequest *ar;
  struct GNUNET_HashCode key;
  struct MhdConnectionHandle *con_handle;
  struct GNUNET_REST_RequestHandle *rest_conndata_handle;
  struct PluginListEntry *ple;
 
  ar = *con_cls;
  if (NULL == ar)
  {
    GNUNET_break (0);
    return MHD_NO;
  }
 
  if (NULL == ar->con_handle)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "New connection %s\n", url);
    con_handle = GNUNET_new (struct MhdConnectionHandle);
    con_handle->con = con;
    con_handle->state = GN_REST_STATE_INIT;
    ar->con_handle = con_handle;
    return MHD_YES;
  }
  con_handle = ar->con_handle;
  if (GN_REST_STATE_INIT == con_handle->state)
  {
    rest_conndata_handle = GNUNET_new (struct GNUNET_REST_RequestHandle);
    rest_conndata_handle->method = meth;
    rest_conndata_handle->url = url;
    rest_conndata_handle->data = upload_data;
    rest_conndata_handle->data_size = *upload_data_size;
    rest_conndata_handle->url_param_map =
      GNUNET_CONTAINER_multihashmap_create (16, GNUNET_NO);
    rest_conndata_handle->header_param_map =
      GNUNET_CONTAINER_multihashmap_create (16, GNUNET_NO);
    con_handle->data_handle = rest_conndata_handle;
    MHD_get_connection_values (con,
                               MHD_GET_ARGUMENT_KIND,
                               (MHD_KeyValueIterator) & url_iterator,
                               rest_conndata_handle);
    MHD_get_connection_values (con,
                               MHD_HEADER_KIND,
                               (MHD_KeyValueIterator) & header_iterator,
                               rest_conndata_handle);
    if (GNUNET_YES == basic_auth_enabled)
    {
      pw = NULL;
      user = MHD_basic_auth_get_username_password (con, &pw);
      if ((NULL == user) ||
          (0 != strcmp (user, cuser)))
      {
        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                    "Unknown user %s\n", user);
        MHD_queue_basic_auth_fail_response (con, "gnunet", failure_response);
        return MHD_YES;
      }
      if ((NULL == pw) ||
          (0 != strcmp (pw, basic_auth_secret)))
      {
        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                    "Password incorrect\n");
        MHD_queue_basic_auth_fail_response (con, "gnunet", failure_response);
        GNUNET_free (pw);
        return MHD_YES;
      }
      GNUNET_free (pw);
    }
 
    con_handle->pp = MHD_create_post_processor (con,
                                                65536,
                                                &post_data_iter,
                                                rest_conndata_handle);
    if (*upload_data_size)
    {
      MHD_post_process (con_handle->pp, upload_data, *upload_data_size);
    }
    MHD_destroy_post_processor (con_handle->pp);
 
    con_handle->state = GN_REST_STATE_PROCESSING;
    for (ple = plugins_head; NULL != ple; ple = ple->next)
    {
      if (GNUNET_YES == ple->process_request (ple->plugin,
                                              rest_conndata_handle,
                                              &plugin_callback,
                                              con_handle))
        break; /* Request handled */
    }
    if (NULL == ple)
    {
      MHD_queue_response (con, MHD_HTTP_NOT_FOUND, failure_response);
    }
    *upload_data_size = 0;
    run_mhd_now ();
    return MHD_YES;
  }
  if (NULL == con_handle->response)
  {
    // Suspend connection until plugin is done
    MHD_suspend_connection (con_handle->con);
    return MHD_YES;
  }
  // MHD_resume_connection (con_handle->con);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Queueing response from plugin with MHD\n");
  // Handle Preflights for extensions
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Checking origin\n");
  GNUNET_CRYPTO_hash ("origin", strlen ("origin"), &key);
  origin = GNUNET_CONTAINER_multihashmap_get (con_handle->data_handle
                                              ->header_param_map,
                                              &key);
  if (NULL != origin)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Origin: %s\n", origin);
    // Only echo for browser plugins
    if (GNUNET_YES == echo_origin)
    {
      if ((0 ==
           strncmp ("moz-extension://", origin, strlen ("moz-extension://"))) ||
          (0 == strncmp ("chrome-extension://",
                         origin,
                         strlen ("chrome-extension://"))))
      {
        GNUNET_assert (MHD_NO != MHD_add_response_header (con_handle->response,
                                                          MHD_HTTP_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
                                                          origin));
      }
    }
    if (NULL != allow_origins)
    {
      char *tmp = GNUNET_strdup (allow_origins);
      char *allow_origin = strtok (tmp, ",");
      while (NULL != allow_origin)
      {
        if (0 == strncmp (allow_origin, origin, strlen (allow_origin)))
        {
          GNUNET_assert (MHD_NO != MHD_add_response_header (
                           con_handle->response,
                           MHD_HTTP_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
                           allow_origin));
          break;
        }
        allow_origin = strtok (NULL, ",");
      }
      GNUNET_free (tmp);
    }
  }
  if (NULL != allow_credentials)
  {
    GNUNET_assert (MHD_NO != MHD_add_response_header (con_handle->response,
                                                      "Access-Control-Allow-Credentials",
                                                      allow_credentials));
  }
  if (NULL != allow_headers)
  {
    GNUNET_assert (MHD_NO != MHD_add_response_header (con_handle->response,
                                                      "Access-Control-Allow-Headers",
                                                      allow_headers));
  }
  run_mhd_now ();
  {
    MHD_RESULT ret = MHD_queue_response (con,
                                         con_handle->status,
                                         con_handle->response);
    // cleanup_handle (con_handle);
    return ret;
  }
}

References allow_credentials, allow_headers, allow_origins, basic_auth_enabled, basic_auth_secret, MhdConnectionHandle::con, AcceptedRequest::con_handle, cuser, GNUNET_REST_RequestHandle::data, MhdConnectionHandle::data_handle, GNUNET_REST_RequestHandle::data_size, echo_origin, failure_response, GN_REST_STATE_INIT, GN_REST_STATE_PROCESSING, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_strdup, GNUNET_YES, header_iterator(), GNUNET_REST_RequestHandle::header_param_map, key, GNUNET_REST_RequestHandle::method, MHD_RESULT, PluginListEntry::next, origin, PluginListEntry::plugin, plugin_callback(), plugins_head, post_data_iter(), MhdConnectionHandle::pp, PluginListEntry::process_request, MhdConnectionHandle::response, ret, run_mhd_now(), MhdConnectionHandle::state, MhdConnectionHandle::status, GNUNET_REST_RequestHandle::url, url_iterator(), and GNUNET_REST_RequestHandle::url_param_map.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ kill_httpd()

static void kill_httpd ( )

static

Kill the MHD daemon.

Definition at line 694 of file gnunet-rest-server.c.

{
  if (NULL != httpd)
  {
    MHD_stop_daemon (httpd);
    httpd = NULL;
  }
  if (NULL != httpd_task)
  {
    GNUNET_SCHEDULER_cancel (httpd_task);
    httpd_task = NULL;
  }
  if (NULL != ltask4)
  {
    GNUNET_SCHEDULER_cancel (ltask4);
    ltask4 = NULL;
  }
  if (NULL != ltask6)
  {
    GNUNET_SCHEDULER_cancel (ltask6);
    ltask6 = NULL;
  }
 
  if (NULL != lsock4)
  {
    GNUNET_NETWORK_socket_close (lsock4);
    lsock4 = NULL;
  }
  if (NULL != lsock6)
  {
    GNUNET_NETWORK_socket_close (lsock6);
    lsock6 = NULL;
  }
}

References GNUNET_NETWORK_socket_close(), GNUNET_SCHEDULER_cancel(), httpd, httpd_task, lsock4, lsock6, ltask4, and ltask6.

Referenced by do_shutdown(), and schedule_httpd().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ schedule_httpd()

static void schedule_httpd ( )

static

Schedule MHD.

This function should be called initially when an MHD is first getting its client socket, and will then automatically always be called later whenever there is work to be done.

Parameters

hd	the daemon to schedule

Definition at line 738 of file gnunet-rest-server.c.

{
  fd_set rs;
  fd_set ws;
  fd_set es;
  struct GNUNET_NETWORK_FDSet *wrs;
  struct GNUNET_NETWORK_FDSet *wws;
  int max;
  int haveto;
  MHD_UNSIGNED_LONG_LONG timeout;
  struct GNUNET_TIME_Relative tv;
 
  FD_ZERO (&rs);
  FD_ZERO (&ws);
  FD_ZERO (&es);
  max = -1;
  if (MHD_YES != MHD_get_fdset (httpd, &rs, &ws, &es, &max))
  {
    kill_httpd ();
    return;
  }
  haveto = MHD_get_timeout (httpd, &timeout);
  if (MHD_YES == haveto)
    tv.rel_value_us = (uint64_t) timeout * 1000LL;
  else
    tv = GNUNET_TIME_UNIT_FOREVER_REL;
  if (-1 != max)
  {
    wrs = GNUNET_NETWORK_fdset_create ();
    wws = GNUNET_NETWORK_fdset_create ();
    GNUNET_NETWORK_fdset_copy_native (wrs, &rs, max + 1);
    GNUNET_NETWORK_fdset_copy_native (wws, &ws, max + 1);
  }
  else
  {
    wrs = NULL;
    wws = NULL;
  }
  if (NULL != httpd_task)
  {
    GNUNET_SCHEDULER_cancel (httpd_task);
    httpd_task = NULL;
  }
  if ((MHD_YES == haveto) || (-1 != max))
  {
    httpd_task = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
                                              tv,
                                              wrs,
                                              wws,
                                              &do_httpd,
                                              NULL);
  }
  if (NULL != wrs)
    GNUNET_NETWORK_fdset_destroy (wrs);
  if (NULL != wws)
    GNUNET_NETWORK_fdset_destroy (wws);
}

References do_httpd(), GNUNET_NETWORK_fdset_copy_native(), GNUNET_NETWORK_fdset_create(), GNUNET_NETWORK_fdset_destroy(), GNUNET_SCHEDULER_add_select(), GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_PRIORITY_DEFAULT, GNUNET_TIME_UNIT_FOREVER_REL, httpd, httpd_task, kill_httpd(), max, GNUNET_TIME_Relative::rel_value_us, and timeout.

Referenced by do_accept(), and do_httpd().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mhd_log_callback()

static void * mhd_log_callback	(	void *	cls,
		const char *	url,
		struct MHD_Connection *	connection
	)

static

Function called when MHD first processes an incoming connection.

Gives us the respective URI information.

We use this to associate the struct MHD_Connection with our internal struct AcceptedRequest data structure (by checking for matching sockets).

Parameters

cls	the HTTP server handle (a `struct MhdHttpList`)
url	the URL that is being requested
connection	MHD connection object for the request

Returns: the struct Socks5Request that this connection is for

Definition at line 811 of file gnunet-rest-server.c.

{
  struct AcceptedRequest *ar;
  const union MHD_ConnectionInfo *ci;
 
  ci = MHD_get_connection_info (connection,
                                MHD_CONNECTION_INFO_SOCKET_CONTEXT);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Processing %s\n", url);
  if (NULL == ci)
  {
    GNUNET_break (0);
    return NULL;
  }
  ar = ci->socket_context;
  return ar;
}

References GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, and GNUNET_log.

Referenced by run().

Here is the caller graph for this function:

◆ mhd_completed_cb()

static void mhd_completed_cb	(	void *	cls,
		struct MHD_Connection *	connection,
		void **	con_cls,
		enum MHD_RequestTerminationCode	toe
	)

static

Function called when MHD decides that we are done with a connection.

Parameters

cls	NULL
connection	connection handle
con_cls	value as set by the last call to the MHD_AccessHandlerCallback, should be our handle
toe	reason for request termination (ignored)

Definition at line 841 of file gnunet-rest-server.c.

{
  struct AcceptedRequest *ar = *con_cls;
  if (MHD_REQUEST_TERMINATED_COMPLETED_OK != toe)
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "MHD encountered error handling request: %d\n",
                toe);
  if (NULL == ar)
    return;
  if (NULL != ar->con_handle)
  {
    cleanup_handle (ar->con_handle);
    ar->con_handle = NULL;
  }
  ar->socket_with_mhd = GNUNET_YES;
  *con_cls = NULL;
}

References cleanup_handle(), AcceptedRequest::con_handle, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_YES, and AcceptedRequest::socket_with_mhd.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mhd_connection_cb()

static void mhd_connection_cb	(	void *	cls,
		struct MHD_Connection *	connection,
		void **	con_cls,
		enum MHD_ConnectionNotificationCode	cnc
	)

static

Function called when MHD connection is opened or closed.

Parameters

cls	NULL
connection	connection handle
con_cls	value as set by the last call to the MHD_AccessHandlerCallback, should be our `struct Socks5Request *`
toe	connection notification type

Definition at line 873 of file gnunet-rest-server.c.

{
  struct AcceptedRequest *ar;
  const union MHD_ConnectionInfo *ci;
  int sock;
 
  switch (cnc)
  {
  case MHD_CONNECTION_NOTIFY_STARTED:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connection started...\n");
    ci = MHD_get_connection_info (connection,
                                  MHD_CONNECTION_INFO_CONNECTION_FD);
    if (NULL == ci)
    {
      GNUNET_break (0);
      return;
    }
    sock = ci->connect_fd;
    for (ar = req_list_head; NULL != ar; ar = ar->next)
    {
      if (GNUNET_NETWORK_get_fd (ar->sock) == sock)
      {
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Context set...\n");
        *con_cls = ar;
        break;
      }
    }
    break;
 
  case MHD_CONNECTION_NOTIFY_CLOSED:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Connection closed... cleaning up\n");
    ar = *con_cls;
    if (NULL == ar)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Connection stale!\n");
      return;
    }
    cleanup_ar (ar);
    *con_cls = NULL;
    break;
 
  default:
    GNUNET_break (0);
  }
}

References cleanup_ar(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_NETWORK_get_fd(), AcceptedRequest::next, req_list_head, and AcceptedRequest::sock.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ do_accept()

static void do_accept ( void * cls )

static

Accept new incoming connections.

Parameters

cls	the closure with the lsock4 or lsock6

Definition at line 946 of file gnunet-rest-server.c.

{
  struct GNUNET_NETWORK_Handle *lsock = cls;
  struct AcceptedRequest *ar;
  int fd;
  const struct sockaddr *addr;
  socklen_t len;
 
  GNUNET_assert (NULL != lsock);
  if (lsock == lsock4)
  {
    ltask4 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                            lsock,
                                            &do_accept,
                                            lsock);
  }
  else if (lsock == lsock6)
  {
    ltask6 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                            lsock,
                                            &do_accept,
                                            lsock);
  }
  else
    GNUNET_assert (0);
  ar = GNUNET_new (struct AcceptedRequest);
  ar->socket_with_mhd = GNUNET_YES;
  ar->sock = GNUNET_NETWORK_socket_accept (lsock, NULL, NULL);
  if (NULL == ar->sock)
  {
    GNUNET_free (ar);
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "accept");
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Got an inbound connection, waiting for data\n");
  fd = GNUNET_NETWORK_get_fd (ar->sock);
  addr = GNUNET_NETWORK_get_addr (ar->sock);
  len = GNUNET_NETWORK_get_addrlen (ar->sock);
  GNUNET_CONTAINER_DLL_insert (req_list_head,
                               req_list_tail,
                               ar);
  if (MHD_YES != MHD_add_connection (httpd, fd, addr, len))
  {
    GNUNET_NETWORK_socket_close (ar->sock);
    GNUNET_free (ar);
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Failed to pass client to MHD\n"));
    return;
  }
  schedule_httpd ();
}

References _, do_accept(), GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_log_strerror, GNUNET_NETWORK_get_addr(), GNUNET_NETWORK_get_addrlen(), GNUNET_NETWORK_get_fd(), GNUNET_NETWORK_socket_accept(), GNUNET_NETWORK_socket_close(), GNUNET_new, GNUNET_SCHEDULER_add_read_net(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, httpd, lsock4, lsock6, ltask4, ltask6, req_list_head, req_list_tail, schedule_httpd(), AcceptedRequest::sock, and AcceptedRequest::socket_with_mhd.

Referenced by do_accept(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ do_shutdown()

static void do_shutdown ( void * cls )

static

Task run on shutdown.

Parameters

cls closure

Definition at line 1006 of file gnunet-rest-server.c.

{
  struct PluginListEntry *ple;
 
  while (NULL != plugins_head)
  {
    ple = plugins_head;
    GNUNET_CONTAINER_DLL_remove (plugins_head,
                                 plugins_tail,
                                 ple);
    GNUNET_free (ple->libname);
    GNUNET_free (ple);
  }
  REST_config_done (config_plugin);
  REST_copying_done (copying_plugin);
  REST_identity_done (identity_plugin);
  REST_namestore_done (namestore_plugin);
  REST_gns_done (gns_plugin);
#if HAVE_JOSE
  REST_openid_done (openid_plugin);
#endif
  REST_reclaim_done (reclaim_plugin);
  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Shutting down...\n");
  kill_httpd ();
  GNUNET_free (allow_credentials);
  GNUNET_free (allow_headers);
  MHD_destroy_response (failure_response);
}

References allow_credentials, allow_headers, config_plugin, copying_plugin, failure_response, gns_plugin, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, identity_plugin, kill_httpd(), PluginListEntry::libname, namestore_plugin, plugins_head, plugins_tail, reclaim_plugin, REST_config_done(), REST_copying_done(), REST_gns_done(), REST_identity_done(), REST_namestore_done(), REST_openid_done(), and REST_reclaim_done().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bind_v4()

static struct GNUNET_NETWORK_Handle * bind_v4 ( )

static

Create an IPv4 listen socket bound to our port.

Returns: NULL on error

Definition at line 1042 of file gnunet-rest-server.c.

{
  struct GNUNET_NETWORK_Handle *ls;
  struct sockaddr_in sa4;
  int eno;
 
  memset (&sa4, 0, sizeof(sa4));
  sa4.sin_family = AF_INET;
  sa4.sin_port = htons (port);
  sa4.sin_addr.s_addr = address;
#if HAVE_SOCKADDR_IN_SIN_LEN
  sa4.sin_len = sizeof(sa4);
#endif
  ls = GNUNET_NETWORK_socket_create (AF_INET, SOCK_STREAM, 0);
  if (NULL == ls)
    return NULL;
  if (GNUNET_OK != GNUNET_NETWORK_socket_bind (ls,
                                               (const struct sockaddr *) &sa4,
                                               sizeof(sa4)))
  {
    eno = errno;
    GNUNET_NETWORK_socket_close (ls);
    errno = eno;
    return NULL;
  }
  return ls;
}

References address, GNUNET_NETWORK_socket_bind(), GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_create(), GNUNET_OK, ls, and port.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bind_v6()

static struct GNUNET_NETWORK_Handle * bind_v6 ( )

static

Create an IPv6 listen socket bound to our port.

Returns: NULL on error

Definition at line 1077 of file gnunet-rest-server.c.

{
  struct GNUNET_NETWORK_Handle *ls;
  struct sockaddr_in6 sa6;
  int eno;
 
  memset (&sa6, 0, sizeof(sa6));
  sa6.sin6_family = AF_INET6;
  sa6.sin6_port = htons (port);
  sa6.sin6_addr = address6;
#if HAVE_SOCKADDR_IN_SIN_LEN
  sa6.sin6_len = sizeof(sa6);
#endif
  ls = GNUNET_NETWORK_socket_create (AF_INET6, SOCK_STREAM, 0);
  if (NULL == ls)
    return NULL;
  if (GNUNET_OK != GNUNET_NETWORK_socket_bind (ls,
                                               (const struct sockaddr *) &sa6,
                                               sizeof(sa6)))
  {
    eno = errno;
    GNUNET_NETWORK_socket_close (ls);
    errno = eno;
    return NULL;
  }
  return ls;
}

References address6, GNUNET_NETWORK_socket_bind(), GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_create(), GNUNET_OK, ls, and port.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setup_plugin()

static enum GNUNET_GenericReturnValue setup_plugin	(	const char *	name,
		GNUNET_REST_ProcessingFunction	proc,
		void *	plugin_cls
	)

static

Callback for plugin load.

Parameters

cls	NULL
libname	the name of the library loaded
lib_ret	the object returned by the plugin initializer

Definition at line 1114 of file gnunet-rest-server.c.

{
  struct PluginListEntry *ple;
 
  if (NULL == plugin_cls)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Could not load plugin\n");
    return GNUNET_SYSERR;
  }
  GNUNET_assert (1 < strlen (name));
  GNUNET_assert ('/' == *name);
  ple = GNUNET_new (struct PluginListEntry);
  ple->libname = GNUNET_strdup (name);
  ple->plugin = plugin_cls;
  ple->process_request = proc;
  GNUNET_CONTAINER_DLL_insert (plugins_head,
                               plugins_tail,
                               ple);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Loaded plugin `%s'\n", name);
  return GNUNET_OK;
}

References GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, GNUNET_OK, GNUNET_strdup, GNUNET_SYSERR, PluginListEntry::libname, name, PluginListEntry::plugin, plugins_head, plugins_tail, and PluginListEntry::process_request.

Referenced by run().

Here is the caller graph for this function:

◆ run()

static void run	(	void *	cls,
		char const	args,
		const char *	cfgfile,
		const struct GNUNET_CONFIGURATION_Handle *	c
	)

static

Main function that will be run.

Parameters

cls	closure
args	remaining command-line arguments
cfgfile	name of the configuration file used (for saving, can be NULL)
c	configuration

Definition at line 1149 of file gnunet-rest-server.c.

{
  static const char *err_page = "{}";
  char *addr_str;
  char *basic_auth_file;
  uint64_t secret;
 
  cfg = c;
  plugins_head = NULL;
  plugins_tail = NULL;
  failure_response = MHD_create_response_from_buffer (strlen (err_page),
                                                      (void *) err_page,
                                                      MHD_RESPMEM_PERSISTENT);
  /* Get port to bind to */
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_number (cfg, "rest", "HTTP_PORT", &port))
  {
    // No address specified
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Using default port...\n");
    port = GNUNET_REST_SERVICE_PORT;
  }
 
  /* Get address to bind to */
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_string (cfg, "rest", "BIND_TO", &addr_str))
  {
    // No address specified
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Don't know what to bind to...\n");
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if (1 != inet_pton (AF_INET, addr_str, &address))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Unable to parse address %s\n",
                addr_str);
    GNUNET_free (addr_str);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  GNUNET_free (addr_str);
  /* Get address to bind to */
  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg,
                                                          "rest",
                                                          "BIND_TO6",
                                                          &addr_str))
  {
    // No address specified
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Don't know what to bind6 to...\n");
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if (1 != inet_pton (AF_INET6, addr_str, &address6))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Unable to parse IPv6 address %s\n",
                addr_str);
    GNUNET_free (addr_str);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  GNUNET_free (addr_str);
 
  basic_auth_enabled = GNUNET_CONFIGURATION_get_value_yesno (cfg,
                                                             "rest",
                                                             "BASIC_AUTH_ENABLED");
  if (basic_auth_enabled)
  {
    if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg,
                                                              "rest",
                                                              "BASIC_AUTH_SECRET_FILE",
                                                              &basic_auth_file))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "No basic auth secret file location set...\n");
      GNUNET_SCHEDULER_shutdown ();
      return;
    }
    if (GNUNET_YES != GNUNET_DISK_file_test (basic_auth_file))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "No basic auth secret found... generating\n");
      secret = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
                                         UINT64_MAX);
      basic_auth_secret = GNUNET_STRINGS_data_to_string_alloc (&secret,
                                                               sizeof(secret));
      if (GNUNET_OK !=
          GNUNET_DISK_fn_write (basic_auth_file,
                                basic_auth_secret,
                                strlen (basic_auth_secret),
                                GNUNET_DISK_PERM_USER_READ
                                | GNUNET_DISK_PERM_USER_WRITE))
        GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
                                  "write",
                                  basic_auth_file);
      GNUNET_free (basic_auth_file);
    }
    else
    {
      char basic_auth_secret_tmp[16]; // Should be more than enough
      memset (basic_auth_secret_tmp, 0, 16);
      if (GNUNET_SYSERR == GNUNET_DISK_fn_read (basic_auth_file,
                                                basic_auth_secret_tmp,
                                                sizeof (basic_auth_secret_tmp)
                                                - 1))
      {
        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                    "Unable to read basic auth secret file.\n");
        GNUNET_SCHEDULER_shutdown ();
        GNUNET_free (basic_auth_file);
        return;
      }
      GNUNET_free (basic_auth_file);
      if (0 != getlogin_r (cuser, _POSIX_LOGIN_NAME_MAX))
      {
        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                    "Unable to get user.\n");
        GNUNET_SCHEDULER_shutdown ();
        return;
      }
      basic_auth_secret = GNUNET_strdup (basic_auth_secret_tmp);
    }
  }
 
  /* Get CORS data from cfg */
  echo_origin =
    GNUNET_CONFIGURATION_get_value_yesno (cfg,
                                          "rest",
                                          "REST_ECHO_ORIGIN_WEBEXT");
  allow_origins = NULL;
  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg,
                                                          "rest",
                                                          "REST_ALLOW_ORIGIN",
                                                          &allow_origins))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "No CORS Access-Control-Allow-Origin header will be sent...\n");
  }
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_string (cfg,
                                             "rest",
                                             "REST_ALLOW_CREDENTIALS",
                                             &allow_credentials))
  {
    // No origin specified
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "No CORS Credential Header will be sent...\n");
  }
 
  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg,
                                                          "rest",
                                                          "REST_ALLOW_HEADERS",
                                                          &allow_headers))
  {
    // No origin specified
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "No CORS Access-Control-Allow-Headers Header will be sent...\n");
  }
 
/* Open listen socket proxy */
  lsock6 = bind_v6 ();
  if (NULL == lsock6)
  {
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind");
  }
  else
  {
    if (GNUNET_OK != GNUNET_NETWORK_socket_listen (lsock6, 5))
    {
      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "listen");
      GNUNET_NETWORK_socket_close (lsock6);
      lsock6 = NULL;
    }
    else
    {
      ltask6 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                              lsock6,
                                              &do_accept,
                                              lsock6);
    }
  }
  lsock4 = bind_v4 ();
  if (NULL == lsock4)
  {
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind");
  }
  else
  {
    if (GNUNET_OK != GNUNET_NETWORK_socket_listen (lsock4, 5))
    {
      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "listen");
      GNUNET_NETWORK_socket_close (lsock4);
      lsock4 = NULL;
    }
    else
    {
      ltask4 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                              lsock4,
                                              &do_accept,
                                              lsock4);
    }
  }
  if ((NULL == lsock4) && (NULL == lsock6))
  {
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Service listens on port %llu\n",
              port);
  httpd = MHD_start_daemon (MHD_USE_DEBUG | MHD_USE_NO_LISTEN_SOCKET
                            | MHD_ALLOW_SUSPEND_RESUME,
                            0,
                            NULL,
                            NULL,
                            &create_response,
                            NULL,
                            MHD_OPTION_CONNECTION_TIMEOUT,
                            (unsigned int) 16,
                            MHD_OPTION_NOTIFY_CONNECTION,
                            &mhd_connection_cb,
                            NULL,
                            MHD_OPTION_URI_LOG_CALLBACK,
                            mhd_log_callback,
                            NULL,
                            MHD_OPTION_NOTIFY_COMPLETED,
                            &mhd_completed_cb,
                            NULL,
                            MHD_OPTION_END);
  if (NULL == httpd)
  {
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  /* Load plugins */
  // FIXME: Use per-plugin rest plugin structs
  config_plugin = REST_config_init (cfg);
  if (GNUNET_OK != setup_plugin (config_plugin->name,
                                 &REST_config_process_request, config_plugin))
  {
    GNUNET_SCHEDULER_shutdown ();
  }
  copying_plugin = REST_copying_init (cfg);
  if (GNUNET_OK != setup_plugin (copying_plugin->name,
                                 &REST_copying_process_request, copying_plugin))
  {
    GNUNET_SCHEDULER_shutdown ();
  }
  identity_plugin = REST_identity_init (cfg);
  if (GNUNET_OK != setup_plugin (identity_plugin->name,
                                 &REST_identity_process_request,
                                 identity_plugin))
  {
    GNUNET_SCHEDULER_shutdown ();
  }
  namestore_plugin = REST_namestore_init (cfg);
  if (GNUNET_OK != setup_plugin (namestore_plugin->name,
                                 &REST_namestore_process_request,
                                 namestore_plugin))
  {
    GNUNET_SCHEDULER_shutdown ();
  }
  gns_plugin = REST_gns_init (cfg);
  if (GNUNET_OK != setup_plugin (gns_plugin->name, &REST_gns_process_request,
                                 gns_plugin))
  {
    GNUNET_SCHEDULER_shutdown ();
  }
#if HAVE_JOSE
  openid_plugin = REST_openid_init (cfg);
  if (GNUNET_OK != setup_plugin (openid_plugin->name,
                                 &REST_openid_process_request, openid_plugin))
  {
    GNUNET_SCHEDULER_shutdown ();
  }
#endif
  reclaim_plugin = REST_reclaim_init (cfg);
  if (GNUNET_OK != setup_plugin (reclaim_plugin->name,
                                 &REST_reclaim_process_request, reclaim_plugin))
  {
    GNUNET_SCHEDULER_shutdown ();
  }
  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
}

References address, address6, allow_credentials, allow_headers, allow_origins, basic_auth_enabled, basic_auth_secret, bind_v4(), bind_v6(), cfg, config_plugin, copying_plugin, create_response(), cuser, do_accept(), do_shutdown(), echo_origin, failure_response, gns_plugin, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u64(), GNUNET_DISK_file_test(), GNUNET_DISK_fn_read(), GNUNET_DISK_fn_write(), GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_log_strerror, GNUNET_log_strerror_file, GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_listen(), GNUNET_OK, GNUNET_REST_SERVICE_PORT, GNUNET_SCHEDULER_add_read_net(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_strdup, GNUNET_STRINGS_data_to_string_alloc(), GNUNET_SYSERR, GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, httpd, identity_plugin, lsock4, lsock6, ltask4, ltask6, mhd_completed_cb(), mhd_connection_cb(), mhd_log_callback(), GNUNET_REST_Plugin::name, namestore_plugin, plugins_head, plugins_tail, port, reclaim_plugin, REST_config_init(), REST_config_process_request(), REST_copying_init(), REST_copying_process_request(), REST_gns_init(), REST_gns_process_request(), REST_identity_init(), REST_identity_process_request(), REST_namestore_init(), REST_namestore_process_request(), REST_openid_init(), REST_openid_process_request(), REST_reclaim_init(), REST_reclaim_process_request(), and setup_plugin().

Here is the call graph for this function:

Variable Documentation

◆ httpd_task

struct GNUNET_SCHEDULER_Task* httpd_task

static

The task ID.

Definition at line 75 of file gnunet-rest-server.c.

Referenced by do_httpd(), kill_httpd(), run_mhd_now(), and schedule_httpd().

◆ address

in_addr_t address

static

The address to bind to.

Definition at line 80 of file gnunet-rest-server.c.

Referenced by bind_v4(), and run().

◆ address6

struct in6_addr address6

static

The IPv6 address to bind to.

Definition at line 85 of file gnunet-rest-server.c.

Referenced by bind_v6(), and run().

◆ port

unsigned long long port = 7776

static

The port the service is running on (default 7776)

Definition at line 90 of file gnunet-rest-server.c.

Referenced by bind_v4(), bind_v6(), and run().

◆ lsock4

struct GNUNET_NETWORK_Handle* lsock4

static

The listen socket of the service for IPv4.

Definition at line 95 of file gnunet-rest-server.c.

Referenced by do_accept(), kill_httpd(), and run().

◆ lsock6

struct GNUNET_NETWORK_Handle* lsock6

static

The listen socket of the service for IPv6.

Definition at line 100 of file gnunet-rest-server.c.

Referenced by do_accept(), kill_httpd(), and run().

◆ ltask4

struct GNUNET_SCHEDULER_Task* ltask4

static

The listen task ID for IPv4.

Definition at line 105 of file gnunet-rest-server.c.

Referenced by do_accept(), kill_httpd(), and run().

◆ ltask6

struct GNUNET_SCHEDULER_Task* ltask6

static

The listen task ID for IPv6.

Definition at line 110 of file gnunet-rest-server.c.

Referenced by do_accept(), kill_httpd(), and run().

◆ httpd

struct MHD_Daemon* httpd

static

Daemon for HTTP.

Definition at line 115 of file gnunet-rest-server.c.

Referenced by do_accept(), do_httpd(), kill_httpd(), run(), and schedule_httpd().

◆ failure_response

struct MHD_Response* failure_response

static

Response we return on failures.

Definition at line 120 of file gnunet-rest-server.c.

Referenced by create_response(), do_shutdown(), and run().

◆ cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

static

Our configuration.

Definition at line 125 of file gnunet-rest-server.c.

Referenced by run().

◆ echo_origin

int echo_origin

static

Echo request Origin in CORS.

Definition at line 130 of file gnunet-rest-server.c.

Referenced by create_response(), and run().

◆ basic_auth_enabled

int basic_auth_enabled

static

Do basic auth of user.

Definition at line 135 of file gnunet-rest-server.c.

Referenced by create_response(), and run().

◆ basic_auth_secret

char* basic_auth_secret

static

Basic auth secret.

Definition at line 140 of file gnunet-rest-server.c.

Referenced by create_response(), and run().

◆ cuser

char cuser[_POSIX_LOGIN_NAME_MAX]

User of the service.

Definition at line 145 of file gnunet-rest-server.c.

Referenced by create_response(), and run().

◆ allow_origins

char* allow_origins

static

Allowed Origins (CORS)

Definition at line 150 of file gnunet-rest-server.c.

Referenced by create_response(), and run().

◆ allow_headers

char* allow_headers

static

Allowed Headers (CORS)

Definition at line 155 of file gnunet-rest-server.c.

Referenced by create_response(), do_shutdown(), and run().

◆ allow_credentials

char* allow_credentials

static

Allowed Credentials (CORS)

Definition at line 160 of file gnunet-rest-server.c.

Referenced by create_response(), do_shutdown(), and run().

◆ plugins_head

struct PluginListEntry* plugins_head

static

Plugin list head.

Definition at line 165 of file gnunet-rest-server.c.

Referenced by create_response(), do_shutdown(), run(), and setup_plugin().

◆ plugins_tail

struct PluginListEntry* plugins_tail

static

Plugin list tail.

Definition at line 170 of file gnunet-rest-server.c.

Referenced by do_shutdown(), run(), and setup_plugin().

◆ req_list_head

struct AcceptedRequest* req_list_head

static

AcceptedRequest list head.

Definition at line 251 of file gnunet-rest-server.c.

Referenced by cleanup_ar(), do_accept(), and mhd_connection_cb().

◆ req_list_tail

struct AcceptedRequest* req_list_tail

static

AcceptedRequest list tail.

Definition at line 256 of file gnunet-rest-server.c.

Referenced by cleanup_ar(), and do_accept().

◆ config_plugin

struct GNUNET_REST_Plugin* config_plugin

plugins

Definition at line 263 of file gnunet-rest-server.c.

Referenced by do_shutdown(), and run().

◆ copying_plugin

struct GNUNET_REST_Plugin* copying_plugin

Definition at line 264 of file gnunet-rest-server.c.

Referenced by do_shutdown(), and run().

◆ identity_plugin

struct GNUNET_REST_Plugin* identity_plugin

Definition at line 265 of file gnunet-rest-server.c.

Referenced by do_shutdown(), and run().

◆ namestore_plugin

struct GNUNET_REST_Plugin* namestore_plugin

Definition at line 266 of file gnunet-rest-server.c.

Referenced by do_shutdown(), and run().

◆ gns_plugin

struct GNUNET_REST_Plugin* gns_plugin

Definition at line 267 of file gnunet-rest-server.c.

Referenced by do_shutdown(), and run().

◆ reclaim_plugin

struct GNUNET_REST_Plugin* reclaim_plugin

Definition at line 271 of file gnunet-rest-server.c.

Referenced by do_shutdown(), and run().

Data Structures

Macros

Functions

Variables

Macro Definition Documentation

◆ GNUNET_REST_SERVICE_PORT

◆ MAX_HTTP_URI_LENGTH

◆ HTTP_PORT

◆ HTTPS_PORT

◆ MHD_CACHE_TIMEOUT

◆ GN_REST_STATE_INIT

◆ GN_REST_STATE_PROCESSING

Function Documentation

◆ do_httpd()

◆ run_mhd_now()

◆ plugin_callback()

◆ cleanup_url_map()

◆ cleanup_handle()

◆ cleanup_ar()

◆ header_iterator()

◆ url_iterator()

◆ post_data_iter()

◆ create_response()

◆ kill_httpd()

◆ schedule_httpd()

◆ mhd_log_callback()

◆ mhd_completed_cb()

◆ mhd_connection_cb()

◆ do_accept()

◆ do_shutdown()

◆ bind_v4()

◆ bind_v6()

◆ setup_plugin()

◆ run()

Variable Documentation

◆ httpd_task

◆ address

◆ address6

◆ port

◆ lsock4

◆ lsock6

◆ ltask4

◆ ltask6

◆ httpd

◆ failure_response

◆ cfg

◆ echo_origin

◆ basic_auth_enabled

◆ basic_auth_secret

◆ cuser

◆ allow_origins

◆ allow_headers

◆ allow_credentials

◆ plugins_head

◆ plugins_tail

◆ req_list_head

◆ req_list_tail

◆ config_plugin

◆ copying_plugin

◆ identity_plugin

◆ namestore_plugin

◆ gns_plugin

◆ reclaim_plugin