gnunet-rest-server.c File Reference

REST service for GNUnet services. More...

#include "platform.h"
#include <microhttpd.h>
#include "gnunet_util_lib.h"
#include "gnunet_rest_plugin.h"
#include "gnunet_mhd_compat.h"

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

Go to the source code of this file.

Data Structures
struct	MhdConnectionHandle
	MHD Connection handle. 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 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	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	kill_httpd ()
	Kill the MHD daemon. More...
static void	schedule_httpd ()
	Schedule MHD. 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 void	load_plugin (void *cls, const char *libname, void *lib_ret)
	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...
int	main (int argc, char *const *argv)
	The main function for gnunet-rest-service. 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 struct GNUNET_CONTAINER_MultiHashMap *	plugin_map
	Map of loaded plugins. More...
static int	echo_origin
	Echo request Origin in CORS. 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...

Detailed Description

REST service for GNUnet services.

Author

Martin Schanzenbach

Definition in file gnunet-rest-server.c.

Macro Definition Documentation

GNUNET_REST_SERVICE_PORT

#define GNUNET_REST_SERVICE_PORT   7776

Default Socks5 listen port.

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

Referenced by run().

MAX_HTTP_URI_LENGTH

#define MAX_HTTP_URI_LENGTH   2048

Maximum supported length for a URI.

Should die.

Deprecated:

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

HTTP_PORT

#define HTTP_PORT   80

Port for plaintext HTTP.

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

HTTPS_PORT

#define HTTPS_PORT   443

Port for HTTPS.

Definition at line 51 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 56 of file gnunet-rest-server.c.

GN_REST_STATE_INIT

#define GN_REST_STATE_INIT   0

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

Referenced by create_response().

GN_REST_STATE_PROCESSING

#define GN_REST_STATE_PROCESSING   1

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

Referenced by create_response().

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

References httpd, and schedule_httpd().

Referenced by run_mhd_now(), and schedule_httpd().

{
  httpd_task = NULL;
  MHD_run (httpd);
  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 178 of file gnunet-rest-server.c.

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

Referenced by create_response(), and plugin_callback().

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

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

References MhdConnectionHandle::con, handle, MhdConnectionHandle::response, run_mhd_now(), and MhdConnectionHandle::status.

Referenced by create_response().

{
  struct MhdConnectionHandle *handle = cls;

  handle->status = status;
  handle->response = resp;
  MHD_resume_connection (handle->con);
  run_mhd_now ();
}

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

References GNUNET_free, and GNUNET_YES.

Referenced by cleanup_handle().

{
  GNUNET_free (value);
  return GNUNET_YES;
}

Here is the caller graph for this function:

cleanup_handle()

static void cleanup_handle ( struct MhdConnectionHandle *  handle )

static

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

References cleanup_url_map(), MhdConnectionHandle::data_handle, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_free, GNUNET_REST_RequestHandle::header_param_map, MhdConnectionHandle::response, and GNUNET_REST_RequestHandle::url_param_map.

Referenced by create_response().

{
  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);
}

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

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, and GNUNET_REST_RequestHandle::header_param_map.

Referenced by create_response().

{
  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;
}

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

References GNUNET_asprintf(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_OK, handle, MHD_RESULT, and GNUNET_REST_RequestHandle::url_param_map.

Referenced by create_response().

{
  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;
}

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

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, handle, MHD_RESULT, and GNUNET_REST_RequestHandle::url_param_map.

Referenced by create_response().

{
  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);
  GNUNET_asprintf (&val, "%s", data);
  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,
                data);
    GNUNET_free (val);
  }
  return MHD_YES;
}

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 (i.e. "HTTP/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 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

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

References allow_credentials, allow_headers, allow_origins, cleanup_handle(), MhdConnectionHandle::con, 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_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_strdup, GNUNET_YES, header_iterator(), GNUNET_REST_RequestHandle::header_param_map, GNUNET_REST_RequestHandle::method, MHD_RESULT, MhdConnectionHandle::plugin, plugin_callback(), plugin_name, post_data_iter(), MhdConnectionHandle::pp, GNUNET_REST_Plugin::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().

{
  char *plugin_name;
  char *origin;
  struct GNUNET_HashCode key;
  struct MhdConnectionHandle *con_handle;
  struct GNUNET_REST_RequestHandle *rest_conndata_handle;

  con_handle = *con_cls;

  if (NULL == *con_cls)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "New connection %s\n", url);
    char tmp_url[strlen (url) + 1];
    strcpy (tmp_url, url);
    con_handle = GNUNET_new (struct MhdConnectionHandle);
    con_handle->con = con;
    con_handle->state = GN_REST_STATE_INIT;
    *con_cls = con_handle;

    plugin_name = strtok (tmp_url, "/");

    if (NULL != plugin_name)
    {
      GNUNET_CRYPTO_hash (plugin_name, strlen (plugin_name), &key);

      con_handle->plugin = GNUNET_CONTAINER_multihashmap_get (plugin_map, &key);
    }
    if (NULL == con_handle->plugin)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Queueing response with MHD\n");
      GNUNET_free (con_handle);
      return MHD_queue_response (con, MHD_HTTP_NOT_FOUND, failure_response);
    }

    return MHD_YES;
  }
  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);
    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;
    con_handle->plugin->process_request (rest_conndata_handle,
                                         &plugin_callback,
                                         con_handle);
    *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://"))))
      {
        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)))
        {
          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)
  {
    MHD_add_response_header (con_handle->response,
                             "Access-Control-Allow-Credentials",
                             allow_credentials);
  }
  if (NULL != allow_headers)
  {
    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;
  }
}

Here is the call graph for this function:

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

References GNUNET_ERROR_TYPE_ERROR, and GNUNET_log.

Referenced by run().

{
  if (MHD_REQUEST_TERMINATED_COMPLETED_OK != toe)
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "MHD encountered error handling request: %d\n",
                toe);
}

Here is the caller graph for this function:

kill_httpd()

static void kill_httpd ( )

static

Kill the MHD daemon.

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

References GNUNET_NETWORK_socket_close(), GNUNET_SCHEDULER_cancel(), and httpd.

Referenced by do_shutdown(), and schedule_httpd().

{
  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;
  }
}

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

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, kill_httpd(), GNUNET_TIME_Relative::rel_value_us, and timeout.

Referenced by do_accept(), and do_httpd().

{
  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);
}

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
tc	the scheduler context

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

References _, GNUNET_NETWORK_Handle::fd, GNUNET_assert, 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_SCHEDULER_add_read_net(), GNUNET_TIME_UNIT_FOREVER_REL, httpd, len, and schedule_httpd().

Referenced by run().

{
  struct GNUNET_NETWORK_Handle *lsock = cls;
  struct GNUNET_NETWORK_Handle *s;
  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);
  s = GNUNET_NETWORK_socket_accept (lsock, NULL, NULL);
  if (NULL == s)
  {
    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 (s);
  addr = GNUNET_NETWORK_get_addr (s);
  len = GNUNET_NETWORK_get_addrlen (s);
  if (MHD_YES != MHD_add_connection (httpd, fd, addr, len))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Failed to pass client to MHD\n"));
    return;
  }
  GNUNET_free (s);
  schedule_httpd ();
}

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

References allow_credentials, allow_headers, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, and kill_httpd().

Referenced by run().

{
  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Shutting down...\n");
  kill_httpd ();
  GNUNET_free (allow_credentials);
  GNUNET_free (allow_headers);
}

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

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

Referenced by run().

{
  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;
}

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

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

Referenced by run().

{
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

load_plugin()

static void load_plugin ( void *  cls, const char *  libname, void *  lib_ret  )

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

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_OK, GNUNET_REST_Plugin::name, and MhdConnectionHandle::plugin.

Referenced by run().

{
  struct GNUNET_REST_Plugin *plugin = lib_ret;
  struct GNUNET_HashCode key;

  if (NULL == lib_ret)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Could not load plugin `%s'\n",
                libname);
    return;
  }
  GNUNET_assert (1 < strlen (plugin->name));
  GNUNET_assert ('/' == *plugin->name);
  GNUNET_CRYPTO_hash (plugin->name + 1, strlen (plugin->name + 1), &key);
  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (
        plugin_map,
        &key,
        plugin,
        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Could not load add plugin `%s'\n",
                libname);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Loaded plugin `%s'\n", libname);
}

Here is the call graph for this function:

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

References address, address6, allow_credentials, allow_headers, allow_origins, bind_v4(), bind_v6(), create_response(), do_accept(), do_shutdown(), echo_origin, GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_CONTAINER_multihashmap_create(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_log_strerror, GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_listen(), GNUNET_NO, GNUNET_OK, GNUNET_PLUGIN_load_all(), GNUNET_REST_SERVICE_PORT, GNUNET_SCHEDULER_add_read_net(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_TIME_UNIT_FOREVER_REL, httpd, load_plugin(), mhd_completed_cb(), and port.

Referenced by main().

{
  char *addr_str;

  cfg = c;
  plugin_map = GNUNET_CONTAINER_multihashmap_create (10, GNUNET_NO);

  /* 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);


  /* 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_COMPLETED,
                            &mhd_completed_cb,
                            NULL,
                            MHD_OPTION_END);
  if (NULL == httpd)
  {
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  /* Load plugins */
  GNUNET_PLUGIN_load_all ("libgnunet_plugin_rest",
                          (void *) cfg,
                          &load_plugin,
                          NULL);
  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char *const *	argv
	)

The main function for gnunet-rest-service.

Parameters

argc	number of arguments from the cli
argv	command line arguments

Returns

0 ok, 1 on error

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

References _, failure_response, GNUNET_free_nz, GNUNET_GETOPT_OPTION_END, GNUNET_log_setup(), GNUNET_OK, GNUNET_PROGRAM_run(), GNUNET_STRINGS_get_utf8_args(), ret, and run().

{
  struct GNUNET_GETOPT_CommandLineOption options[] =
  { GNUNET_GETOPT_OPTION_END };
  static const char *err_page = "{}";
  int ret;

  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
    return 2;
  GNUNET_log_setup ("gnunet-rest-server", "WARNING", NULL);
  failure_response = MHD_create_response_from_buffer (strlen (err_page),
                                                      (void *) err_page,
                                                      MHD_RESPMEM_PERSISTENT);
  ret = (GNUNET_OK == GNUNET_PROGRAM_run (argc,
                                          argv,
                                          "gnunet-rest-server",
                                          _ ("GNUnet REST server"),
                                          options,
                                          &run,
                                          NULL))
        ? 0
        : 1;
  MHD_destroy_response (failure_response);
  GNUNET_free_nz ((char *) argv);
  return ret;
}

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

address

in_addr_t address

static

The address to bind to.

Definition at line 70 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 75 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 80 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 85 of file gnunet-rest-server.c.

lsock6

struct GNUNET_NETWORK_Handle* lsock6

static

The listen socket of the service for IPv6.

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

ltask4

struct GNUNET_SCHEDULER_Task* ltask4

static

The listen task ID for IPv4.

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

ltask6

struct GNUNET_SCHEDULER_Task* ltask6

static

The listen task ID for IPv6.

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

httpd

struct MHD_Daemon* httpd

static

Daemon for HTTP.

Definition at line 105 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 110 of file gnunet-rest-server.c.

Referenced by create_response(), and main().

cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

static

Our configuration.

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

plugin_map

struct GNUNET_CONTAINER_MultiHashMap* plugin_map

static

Map of loaded plugins.

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

echo_origin

int echo_origin

static

Echo request Origin in CORS.

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

Referenced by create_response(), and run().

allow_origins

char* allow_origins

static

Allowed Origins (CORS)

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

Referenced by create_response(), and run().

allow_headers

char* allow_headers

static

Allowed Headers (CORS)

Definition at line 135 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 140 of file gnunet-rest-server.c.

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