gnunet-namestore-fcfsd.c File Reference

HTTP daemon that offers first-come-first-serve GNS domain registration. More...

#include "platform.h"
#include <microhttpd.h>
#include "gnunet_util_lib.h"
#include "gnunet_identity_service.h"
#include "gnunet_gnsrecord_lib.h"
#include "gnunet_namestore_service.h"
#include "gnunet_mhd_compat.h"
#include "gnunet_json_lib.h"

Include dependency graph for gnunet-namestore-fcfsd.c:

Go to the source code of this file.

Data Structures
struct	StaticPage
	Structure representing a static page. More...
struct	RequestData
	Structure containing some request-specific data. More...

Functions
static void	do_shutdown (void *cls)
	Task ran at shutdown to clean up everything. More...
static void	do_httpd (void *cls)
	Called when the HTTP server has some pending operations. More...
static void	run_httpd (void)
	Schedule a task to run MHD. More...
static void	run_httpd_now (void)
static char *	make_json (const char *key, const char *value,...)
	Generate a JSON object. More...
static void	search_error_cb (void *cls)
	The namestore search task failed. More...
static void	search_done_cb (void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, unsigned int count, const struct GNUNET_GNSRECORD_Data *d)
	The lookup terminated with some results. More...
static void	register_error_cb (void *cls)
	An error occurred while registering a name. More...
static void	register_done_cb (void *cls, int32_t status, const char *emsg)
	A name/key pair has been successfully registered, or maybe not. More...
static void	register_do_cb (void *cls, const struct GNUNET_IDENTITY_PrivateKey *key, const char *label, unsigned int count, const struct GNUNET_GNSRECORD_Data *d)
	Attempt to register the requested name. More...
static void	iterate_error_cb (void *cls)
	An error occurred while iterating the namestore. More...
static void	iterate_do_cb (void *cls, const struct GNUNET_IDENTITY_PrivateKey *key, const char *label, unsigned int count, const struct GNUNET_GNSRECORD_Data *d)
	A block was received from the namestore. More...
static void	iterate_done_cb (void *cls)
	All entries in the namestore have been iterated over. More...
static MHD_RESULT	serve_json (struct MHD_Connection *c, char *body, size_t length, int code)
	Generate a response containing JSON and send it to the client. More...
static MHD_RESULT	create_response (void *cls, struct MHD_Connection *connection, const char *url, const char *method, const char *version, const char *upload_data, size_t *upload_data_size, void **ptr)
	Send a response back to a connected client. More...
static void	completed_cb (void *cls, struct MHD_Connection *connection, void **ptr, enum MHD_RequestTerminationCode status)
	Called when a request is completed. More...
static void	identity_cb (void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *name)
	Called for each ego provided by the identity service. More...
static struct StaticPage *	open_static_page (const char *name, const char *basedir)
	Open a file on disk and generate a response object for it. More...
static void	run_service (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Called after the service is up. More...
int	main (int argc, char *const *argv)
	The main function of the fcfs daemon. More...

Variables
static char *	zone = NULL
	Name of the zone being managed. More...
static unsigned long long	port = 18080
	The port the daemon is listening to for HTTP requests. More...
static struct GNUNET_NAMESTORE_Handle *	namestore = NULL
	Connection with the namestore service. More...
static struct GNUNET_IDENTITY_Handle *	identity = NULL
	Connection with the identity service. More...
static const struct GNUNET_IDENTITY_PrivateKey *	zone_key = NULL
	Private key of the zone. More...
static struct MHD_Daemon *	httpd = NULL
	The HTTP daemon. More...
static struct GNUNET_SCHEDULER_Task *	httpd_task = NULL
	Task executing the HTTP daemon. More...
static struct StaticPage *	main_page = NULL
	The main page, a.k.a. More...
static struct StaticPage *	notfound_page = NULL
	Page indicating the requested resource could not be found. More...
static struct StaticPage *	forbidden_page = NULL
	Page indicating the requested resource could not be accessed, and other errors. More...

Detailed Description

HTTP daemon that offers first-come-first-serve GNS domain registration.

Author

Christian Grothoff

Definition in file gnunet-namestore-fcfsd.c.

Function Documentation

do_shutdown()

static void do_shutdown ( void *  cls )

static

Task ran at shutdown to clean up everything.

Parameters

cls

unused

Definition at line 173 of file gnunet-namestore-fcfsd.c.

References do_httpd(), GNUNET_free, GNUNET_IDENTITY_disconnect(), GNUNET_NAMESTORE_disconnect(), StaticPage::handle, and StaticPage::response.

Referenced by run_service().

{
  /* We cheat a bit here: the file descriptor is implicitly closed by MHD, so
   calling `GNUNET_DISK_file_close' would generate a spurious warning message
   in the log. Since that function does nothing but close the descriptor and
   free the allocated memory, After destroying the response all that's left to
   do is call `GNUNET_free'. */
  if (NULL != main_page)
  {
    MHD_destroy_response (main_page->response);
    GNUNET_free (main_page->handle);
    GNUNET_free (main_page);
  }
  if (NULL != notfound_page)
  {
    MHD_destroy_response (main_page->response);
    GNUNET_free (main_page->handle);
    GNUNET_free (main_page);
  }
  if (NULL != forbidden_page)
  {
    MHD_destroy_response (main_page->response);
    GNUNET_free (main_page->handle);
    GNUNET_free (main_page);
  }

  if (NULL != namestore)
  {
    GNUNET_NAMESTORE_disconnect (namestore);
  }

  if (NULL != identity)
  {
    GNUNET_IDENTITY_disconnect (identity);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

do_httpd()

static void do_httpd ( void *  cls )

static

Called when the HTTP server has some pending operations.

Parameters

cls

unused

Definition at line 270 of file gnunet-namestore-fcfsd.c.

References httpd, and run_httpd().

Referenced by do_shutdown(), run_httpd(), and run_httpd_now().

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

Here is the call graph for this function:

Here is the caller graph for this function:

run_httpd()

static void run_httpd ( void  )

static

Schedule a task to run MHD.

Definition at line 223 of file gnunet-namestore-fcfsd.c.

References do_httpd(), GNUNET_assert, GNUNET_NETWORK_fdset_copy_native(), GNUNET_NETWORK_fdset_create(), GNUNET_NETWORK_fdset_destroy(), GNUNET_SCHEDULER_add_select(), GNUNET_SCHEDULER_PRIORITY_HIGH, GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TIME_UNIT_MILLISECONDS, httpd, max, and timeout.

Referenced by do_httpd(), and identity_cb().

{
  fd_set rs;
  fd_set ws;
  fd_set es;

  struct GNUNET_NETWORK_FDSet *grs = GNUNET_NETWORK_fdset_create ();
  struct GNUNET_NETWORK_FDSet *gws = GNUNET_NETWORK_fdset_create ();
  struct GNUNET_NETWORK_FDSet *ges = GNUNET_NETWORK_fdset_create ();

  FD_ZERO (&rs);
  FD_ZERO (&ws);
  FD_ZERO (&es);

  int max = -1;
  GNUNET_assert (MHD_YES == MHD_get_fdset (httpd, &rs, &ws, &es, &max));

  unsigned MHD_LONG_LONG timeout = 0;
  struct GNUNET_TIME_Relative gtime = GNUNET_TIME_UNIT_FOREVER_REL;
  if (MHD_YES == MHD_get_timeout (httpd, &timeout))
  {
    gtime = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,
                                           timeout);
  }

  GNUNET_NETWORK_fdset_copy_native (grs, &rs, max + 1);
  GNUNET_NETWORK_fdset_copy_native (gws, &ws, max + 1);
  GNUNET_NETWORK_fdset_copy_native (ges, &es, max + 1);

  httpd_task = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH,
                                            gtime,
                                            grs,
                                            gws,
                                            &do_httpd,
                                            NULL);
  GNUNET_NETWORK_fdset_destroy (grs);
  GNUNET_NETWORK_fdset_destroy (gws);
  GNUNET_NETWORK_fdset_destroy (ges);
}

Here is the call graph for this function:

Here is the caller graph for this function:

run_httpd_now()

static void run_httpd_now ( void  )

static

Definition at line 279 of file gnunet-namestore-fcfsd.c.

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

Referenced by iterate_do_cb(), iterate_error_cb(), register_do_cb(), register_done_cb(), register_error_cb(), search_done_cb(), and search_error_cb().

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

make_json()

static char* make_json ( const char *  key, const char *  value,   ...  )

static

Generate a JSON object.

Parameters

key	the key for the first element
value	the value for the first element
...	key-value pairs of the object, terminated by NULL

Returns

a JSON string (allocated)

Definition at line 299 of file gnunet-namestore-fcfsd.c.

References consensus-simulation::args.

Referenced by create_response(), iterate_do_cb(), iterate_error_cb(), register_do_cb(), register_done_cb(), register_error_cb(), search_done_cb(), and search_error_cb().

{
  va_list args;
  va_start (args, value);

  json_t *obj = NULL;

  obj = json_object ();
  if ((NULL == key) || (NULL == value))
  {
    va_end (args);
    return json_dumps (obj, JSON_COMPACT);
  }

  json_object_set (obj, key, json_string (value));

  char *k = va_arg (args, char *);
  if (NULL == k)
  {
    va_end (args);
    return json_dumps (obj, JSON_COMPACT);
  }
  char *v = va_arg (args, char *);
  if (NULL == v)
  {
    va_end (args);
    return json_dumps (obj, JSON_COMPACT);
  }

  while (NULL != k && NULL != v)
  {
    json_object_set (obj, k, json_string (v));
    k = va_arg (args, char *);
    if (NULL != k)
    {
      v = va_arg (args, char *);
    }
  }

  va_end (args);

  char *json = json_dumps (obj, JSON_COMPACT);
  json_decref (obj);

  return json;
}

Here is the caller graph for this function:

search_error_cb()

static void search_error_cb ( void *  cls )

static

The namestore search task failed.

Parameters

cls	the request data

Definition at line 353 of file gnunet-namestore-fcfsd.c.

References _, RequestData::body, RequestData::body_length, RequestData::c, RequestData::code, make_json(), run_httpd_now(), and RequestData::searching.

Referenced by create_response().

{
  struct RequestData *rd = cls;
  MHD_resume_connection (rd->c);
  rd->searching = NULL;
  rd->body = make_json ("error", "true",
                        "message", _ ("can not search the namestore"),
                        NULL);
  rd->body_length = strlen (rd->body);
  rd->code = MHD_HTTP_INTERNAL_SERVER_ERROR;
  run_httpd_now ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

search_done_cb()

static void search_done_cb ( void *  cls, const struct GNUNET_IDENTITY_PrivateKey *  zone, const char *  label, unsigned int  count, const struct GNUNET_GNSRECORD_Data *  d  )

static

The lookup terminated with some results.

Parameters

cls	closure
zone	the private key of the zone
label	the result label
count	number of records found
d	records found

Definition at line 377 of file gnunet-namestore-fcfsd.c.

References RequestData::body, RequestData::body_length, RequestData::c, RequestData::code, make_json(), run_httpd_now(), and RequestData::searching.

Referenced by create_response().

{
  (void) zone;
  (void) d;

  struct RequestData *rd = cls;
  MHD_resume_connection (rd->c);

  rd->searching = NULL;
  rd->body = make_json ("error", "false",
                        "free", (0 == count) ? "true" : "false",
                        NULL);
  rd->body_length = strlen (rd->body);
  rd->code = MHD_HTTP_OK;

  run_httpd_now ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

register_error_cb()

static void register_error_cb ( void *  cls )

static

An error occurred while registering a name.

Parameters

cls	the connection

Definition at line 406 of file gnunet-namestore-fcfsd.c.

References _, RequestData::body, RequestData::body_length, RequestData::c, RequestData::code, make_json(), run_httpd_now(), and RequestData::searching.

Referenced by iterate_done_cb().

{
  struct RequestData *rd = cls;

  MHD_resume_connection (rd->c);
  rd->searching = NULL;
  rd->body = make_json ("error", "true",
                        "message", _ ("unable to scan namestore"),
                        NULL);
  rd->body_length = strlen (rd->body);
  rd->code = MHD_HTTP_INTERNAL_SERVER_ERROR;
  run_httpd_now ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

register_done_cb()

static void register_done_cb ( void *  cls, int32_t  status, const char *  emsg  )

static

A name/key pair has been successfully registered, or maybe not.

Parameters

cls	the connection
status	result of the operation
emsg	error message if any

Definition at line 429 of file gnunet-namestore-fcfsd.c.

References _, RequestData::body, RequestData::body_length, RequestData::c, RequestData::code, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_NO, GNUNET_SYSERR, make_json(), RequestData::register_name, run_httpd_now(), and RequestData::searching.

Referenced by register_do_cb().

{
  struct RequestData *rd = cls;

  MHD_resume_connection (rd->c);
  rd->searching = NULL;

  if ((GNUNET_SYSERR == status) || (GNUNET_NO == status))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Failed to create record for `%s': %s\n"),
                rd->register_name,
                emsg);
    rd->body = make_json ("error", "true",
                          "message", emsg,
                          NULL);
    rd->body_length = strlen (rd->body);
    rd->code = MHD_HTTP_INTERNAL_SERVER_ERROR;
  }
  else
  {
    rd->body = make_json ("error", "false",
                          "message", _ ("no errors"),
                          NULL);
    rd->body_length = strlen (rd->body);
    rd->code = MHD_HTTP_OK;
  }

  run_httpd_now ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

register_do_cb()

static void register_do_cb ( void *  cls, const struct GNUNET_IDENTITY_PrivateKey *  key, const char *  label, unsigned int  count, const struct GNUNET_GNSRECORD_Data *  d  )

static

Attempt to register the requested name.

Parameters

cls	the connection
key	the zone key
label	name of the record
count	number of records found
d	records

Definition at line 473 of file gnunet-namestore-fcfsd.c.

References _, RequestData::body, RequestData::body_length, RequestData::c, RequestData::code, GNUNET_GNSRECORD_Data::data, GNUNET_GNSRECORD_Data::data_size, GNUNET_GNSRECORD_Data::expiration_time, GNUNET_GNSRECORD_Data::flags, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_GNSRECORD_data_from_identity(), GNUNET_GNSRECORD_RF_NONE, GNUNET_log, GNUNET_NAMESTORE_records_store(), GNUNET_OK, RequestData::key, make_json(), GNUNET_GNSRECORD_Data::record_type, register_done_cb(), RequestData::register_key, RequestData::register_name, run_httpd_now(), and RequestData::searching.

Referenced by iterate_done_cb().

{
  (void) key;
  (void) d;

  struct RequestData *rd = cls;

  rd->searching = NULL;

  if (0 != count)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                _ ("The requested key `%s' exists as `%s'\n"),
                rd->register_key,
                label);

    MHD_resume_connection (rd->c);
    rd->searching = NULL;
    rd->body = make_json ("error", "true",
                          "message", _ ("key exists"),
                          NULL);
    rd->body_length = strlen (rd->body);
    rd->code = MHD_HTTP_FORBIDDEN;
    run_httpd_now ();
    return;
  }

  struct GNUNET_GNSRECORD_Data gd;
  char *gdraw = NULL;

  if (GNUNET_OK != GNUNET_GNSRECORD_data_from_identity (&(rd->key),
                                                        &gdraw,
                                                        &(gd.data_size),
                                                        &(gd.record_type)))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                _ ("Error creating record data\n"));
    MHD_resume_connection (rd->c);
    rd->searching = NULL;
    rd->body = make_json ("error", "true",
                          "message", _ ("unable to store record"),
                          NULL);
    rd->body_length = strlen (rd->body);
    rd->code = MHD_HTTP_INTERNAL_SERVER_ERROR;
    run_httpd_now ();
    return;
  }

  gd.data = gdraw;
  gd.expiration_time = UINT64_MAX;
  gd.flags = GNUNET_GNSRECORD_RF_NONE;

  rd->searching = GNUNET_NAMESTORE_records_store (namestore,
                                                  zone_key,
                                                  rd->register_name,
                                                  1,
                                                  &gd,
                                                  &register_done_cb,
                                                  rd);

  GNUNET_free (gdraw);
}

Here is the call graph for this function:

Here is the caller graph for this function:

iterate_error_cb()

static void iterate_error_cb ( void *  cls )

static

An error occurred while iterating the namestore.

Parameters

cls	the connection

Definition at line 547 of file gnunet-namestore-fcfsd.c.

References _, RequestData::body, RequestData::body_length, RequestData::c, RequestData::code, RequestData::iterating, make_json(), and run_httpd_now().

Referenced by create_response().

{
  struct RequestData *rd = cls;

  MHD_resume_connection (rd->c);
  rd->iterating = NULL;
  rd->body = make_json ("error", "true",
                        "message", _ ("unable to scan namestore"),
                        NULL);
  rd->body_length = strlen (rd->body);
  rd->code = MHD_HTTP_INTERNAL_SERVER_ERROR;
  run_httpd_now ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

iterate_do_cb()

static void iterate_do_cb ( void *  cls, const struct GNUNET_IDENTITY_PrivateKey *  key, const char *  label, unsigned int  count, const struct GNUNET_GNSRECORD_Data *  d  )

static

A block was received from the namestore.

Parameters

cls	the connection
key	the zone key
label	the records' label
count	number of records found
d	the found records

Definition at line 572 of file gnunet-namestore-fcfsd.c.

References _, RequestData::body, RequestData::body_length, RequestData::c, RequestData::code, GNUNET_break, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NAMESTORE_zone_iteration_stop(), GNUNET_NAMESTORE_zone_iterator_next(), RequestData::iterating, make_json(), RequestData::register_name, and run_httpd_now().

Referenced by create_response().

{
  (void) key;
  (void) label;
  (void) d;

  struct RequestData *rd = cls;

  if (0 == strcmp (label, rd->register_name))
  {
    GNUNET_break (0 != count);
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                _ ("Requested name `%s' exists with `%u' records\n"),
                rd->register_name,
                count);

    MHD_resume_connection (rd->c);
    rd->body = make_json ("error", "true",
                          "message", _ ("name exists\n"),
                          NULL);
    rd->body_length = strlen (rd->body);
    rd->code = MHD_HTTP_FORBIDDEN;
    GNUNET_NAMESTORE_zone_iteration_stop (rd->iterating);
    run_httpd_now ();
    return;
  }

  GNUNET_NAMESTORE_zone_iterator_next (rd->iterating, 1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

iterate_done_cb()

static void iterate_done_cb ( void *  cls )

static

All entries in the namestore have been iterated over.

Parameters

cls	the connection

Definition at line 613 of file gnunet-namestore-fcfsd.c.

References GNUNET_NAMESTORE_zone_to_name(), RequestData::iterating, RequestData::key, MHD_RESULT, register_do_cb(), register_error_cb(), and RequestData::searching.

Referenced by create_response().

{
  struct RequestData *rd = cls;

  rd->iterating = NULL;

  /* See if the key was not registered already */
  rd->searching = GNUNET_NAMESTORE_zone_to_name (namestore,
                                                 zone_key,
                                                 &(rd->key),
                                                 &register_error_cb,
                                                 rd,
                                                 &register_do_cb,
                                                 rd);
}

Here is the call graph for this function:

Here is the caller graph for this function:

serve_json()

static MHD_RESULT serve_json ( struct MHD_Connection *  c, char *  body, size_t  length, int  code  )

static

Generate a response containing JSON and send it to the client.

Parameters

c	the connection
body	the response body
length	the body length in bytes
code	the response code

Returns

MHD_NO on error

Definition at line 640 of file gnunet-namestore-fcfsd.c.

References MHD_RESULT, and StaticPage::response.

Referenced by create_response().

{
  struct MHD_Response *response =
    MHD_create_response_from_buffer (length,
                                     body,
                                     MHD_RESPMEM_PERSISTENT);
  MHD_RESULT r = MHD_queue_response (c, code, response);
  MHD_destroy_response (response);
  return r;
}

Here is the caller graph for this function:

create_response()

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

static

Send a response back to a connected client.

Parameters

cls	unused
connection	the connection with the client
url	the requested address
method	the HTTP method used
version	the protocol version (including the "HTTP/" part)
upload_data	data sent with a POST request
upload_data_size	length in bytes of the POST data
ptr	used to pass data between request handling phases

Returns

MHD_NO on error

Definition at line 669 of file gnunet-namestore-fcfsd.c.

References _, RequestData::body, RequestData::body_length, RequestData::c, RequestData::code, GNUNET_ERROR_TYPE_WARNING, GNUNET_IDENTITY_public_key_from_string(), GNUNET_JSON_post_parser(), GNUNET_JSON_post_parser_cleanup(), GNUNET_JSON_PR_CONTINUE, GNUNET_JSON_PR_JSON_INVALID, GNUNET_JSON_PR_OUT_OF_MEMORY, GNUNET_JSON_PR_REQUEST_TOO_LARGE, GNUNET_log, GNUNET_NAMESTORE_records_lookup(), GNUNET_NAMESTORE_zone_iteration_start(), GNUNET_new, GNUNET_OK, iterate_do_cb(), iterate_done_cb(), iterate_error_cb(), RequestData::iterating, RequestData::key, make_json(), name, RequestData::ptr, RequestData::register_key, RequestData::register_name, StaticPage::response, result, search_done_cb(), search_error_cb(), RequestData::searching, and serve_json().

Referenced by identity_cb().

{
  (void) cls;
  (void) version;

  struct RequestData *rd = *ptr;

  if (0 == strcmp (method, MHD_HTTP_METHOD_GET))
  {
    /* Handle a previously suspended request */
    if (NULL != rd)
    {
      return serve_json (rd->c, rd->body, rd->body_length, rd->code);
    }

    if (0 == strcmp ("/", url))
    {
      return MHD_queue_response (connection,
                                 MHD_HTTP_OK,
                                 main_page->response);
    }

    if (0 == strcmp ("/search", url))
    {
      const char *name = MHD_lookup_connection_value (connection,
                                                      MHD_GET_ARGUMENT_KIND,
                                                      "name");
      if (NULL == name)
      {
        return MHD_queue_response (connection,
                                   MHD_HTTP_BAD_REQUEST,
                                   forbidden_page->response);
      }

      MHD_suspend_connection (connection);
      rd = GNUNET_new (struct RequestData);
      rd->c = connection;
      rd->searching = GNUNET_NAMESTORE_records_lookup (namestore,
                                                       zone_key,
                                                       name,
                                                       &search_error_cb,
                                                       rd,
                                                       &search_done_cb,
                                                       rd);
      *ptr = rd;
      return MHD_YES;
    }

    return MHD_queue_response (connection,
                               MHD_HTTP_NOT_FOUND,
                               notfound_page->response);
  }

  if (0 == strcmp (method, MHD_HTTP_METHOD_HEAD))
  {
    /* We take a shortcut here by always serving the main page: starting a
     namestore lookup, allocating the necessary resources, waiting for the
     lookup to complete and then discard everything just because it was a HEAD
     and thus only the headers are significative, is an unnecessary waste of
     resources. The handling of this method could be smarter, for example by
     sending a proper content type header based on the endpoint, but this is
     not a service in which HEAD requests are significant, so there's no need
     to spend too much time here. */
    return MHD_queue_response (connection,
                               MHD_HTTP_OK,
                               main_page->response);
  }

  if (0 == strcmp (method, MHD_HTTP_METHOD_POST))
  {
    if (0 == strcmp ("/register", url))
    {
      /* Handle a previously suspended request */
      if ((NULL != rd) && (NULL != rd->body))
      {
        return serve_json (rd->c, rd->body, rd->body_length, rd->code);
      }

      if (NULL == rd)
      {
        rd = GNUNET_new (struct RequestData);
        rd->c = connection;
        rd->body = NULL;
        rd->ptr = NULL;
        *ptr = rd;
      }

      json_t *json = NULL;
      enum GNUNET_JSON_PostResult result =
        GNUNET_JSON_post_parser (32 * 1024,
                                 connection,
                                 &(rd->ptr),
                                 upload_data,
                                 upload_data_size,
                                 &json);

      switch (result)
      {
      case GNUNET_JSON_PR_CONTINUE:
        /* Keep processing POST data */
        return MHD_YES;
      case GNUNET_JSON_PR_OUT_OF_MEMORY:
      case GNUNET_JSON_PR_REQUEST_TOO_LARGE:
        rd->body = make_json ("error", "true",
                              "message", _ ("unable to process submitted data"),
                              NULL);
        rd->body_length = strlen (rd->body);
        rd->code = MHD_HTTP_PAYLOAD_TOO_LARGE;
        return MHD_YES;
      case GNUNET_JSON_PR_JSON_INVALID:
        rd->body = make_json ("error", "true",
                              "message", _ ("the submitted data is invalid"),
                              NULL);
        rd->body_length = strlen (rd->body);
        rd->code = MHD_HTTP_BAD_REQUEST;
        return MHD_YES;
      default:
        break;
      }

      /* POST data has been read in its entirety */

      const char *name = json_string_value (json_object_get (json, "name"));
      const char *key = json_string_value (json_object_get (json, "key"));
      if ((NULL == name) || (NULL == key) || (0 == strlen (name)) || (0 ==
                                                                      strlen (
                                                                        key)))
      {
        json_decref (json);
        rd->body = make_json ("error", "true",
                              "message", _ ("invalid parameters"),
                              NULL);
        rd->body_length = strlen (rd->body);
        rd->code = MHD_HTTP_BAD_REQUEST;
        return MHD_YES;
      }

      rd->register_name = strdup (name);
      rd->register_key = strdup (key);

      json_decref (json);
      GNUNET_JSON_post_parser_cleanup (rd->ptr);

      if ((NULL != strchr (rd->register_name, '.')) ||
          (NULL != strchr (rd->register_name, '+')))
      {
        rd->body = make_json ("error", "true",
                              "message", _ ("invalid name"),
                              NULL);
        rd->body_length = strlen (rd->body);
        rd->code = MHD_HTTP_BAD_REQUEST;
        return MHD_YES;
      }

      if (GNUNET_OK != GNUNET_IDENTITY_public_key_from_string (rd->register_key,
                                                               &(rd->key)))
      {
        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                    _ ("Unable to parse key %s\n"),
                    rd->register_key);

        rd->body = make_json ("error", "true",
                              "message", _ ("unable to parse key"),
                              NULL);
        rd->body_length = strlen (rd->body);
        rd->code = MHD_HTTP_INTERNAL_SERVER_ERROR;
        return MHD_YES;
      }

      MHD_suspend_connection (connection);
      /* See if the requested name is free */
      rd->iterating =
        GNUNET_NAMESTORE_zone_iteration_start (namestore,
                                               zone_key,
                                               &iterate_error_cb,
                                               rd,
                                               &iterate_do_cb,
                                               rd,
                                               &iterate_done_cb,
                                               rd);
      return MHD_YES;
    }

    return MHD_queue_response (connection,
                               MHD_HTTP_FORBIDDEN,
                               forbidden_page->response);
  }

  return MHD_queue_response (connection,
                             MHD_HTTP_NOT_IMPLEMENTED,
                             forbidden_page->response);
}

Here is the call graph for this function:

Here is the caller graph for this function:

completed_cb()

static void completed_cb ( void *  cls, struct MHD_Connection *  connection, void **  ptr, enum MHD_RequestTerminationCode  status  )

static

Called when a request is completed.

Parameters

cls	unused
connection	the connection
ptr	connection-specific data
status	status code

Definition at line 879 of file gnunet-namestore-fcfsd.c.

References RequestData::body, GNUNET_free, GNUNET_NAMESTORE_cancel(), GNUNET_NAMESTORE_zone_iteration_stop(), RequestData::iterating, RequestData::ptr, RequestData::register_key, RequestData::register_name, and RequestData::searching.

Referenced by identity_cb().

{
  (void) cls;
  (void) connection;
  (void) status;

  struct RequestData *rd = *ptr;

  if (NULL == rd)
  {
    return;
  }

  if (NULL == rd->body)
  {
    GNUNET_free (rd->body);
  }

  if (NULL != rd->searching)
  {
    GNUNET_NAMESTORE_cancel (rd->searching);
  }

  if (NULL != rd->register_name)
  {
    GNUNET_free (rd->register_name);
  }

  if (NULL != rd->register_key)
  {
    GNUNET_free (rd->register_key);
  }

  if (NULL != rd->iterating)
  {
    GNUNET_NAMESTORE_zone_iteration_stop (rd->iterating);
  }

  GNUNET_free (rd);
}

Here is the call graph for this function:

Here is the caller graph for this function:

identity_cb()

static void identity_cb ( void *  cls, struct GNUNET_IDENTITY_Ego *  ego, void **  ctx, const char *  name  )

static

Called for each ego provided by the identity service.

Parameters

cls	closure
ego	the ego
ctx	application-provided data for the ego
name	the ego name

Definition at line 933 of file gnunet-namestore-fcfsd.c.

References _, completed_cb(), create_response(), GNUNET_ERROR_TYPE_ERROR, GNUNET_IDENTITY_ego_get_private_key(), GNUNET_log, GNUNET_SCHEDULER_shutdown(), httpd, port, run_httpd(), and zone.

Referenced by run_service().

{
  (void) cls;
  (void) ctx;

  if ((NULL == name) || (0 != strcmp (name, zone)))
  {
    return;
  }

  if (NULL == ego)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("No ego configured for `fcfsd` subsystem\n"));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }

  zone_key = GNUNET_IDENTITY_ego_get_private_key (ego);

  int flags = MHD_USE_DUAL_STACK | MHD_USE_DEBUG | MHD_ALLOW_SUSPEND_RESUME;
  do
  {
    httpd = MHD_start_daemon (flags,
                              (uint16_t) port,
                              NULL, NULL,
                              &create_response, NULL,
                              MHD_OPTION_CONNECTION_LIMIT, 128,
                              MHD_OPTION_PER_IP_CONNECTION_LIMIT, 1,
                              MHD_OPTION_CONNECTION_TIMEOUT, 4 * 1024,
                              MHD_OPTION_NOTIFY_COMPLETED, &completed_cb, NULL,
                              MHD_OPTION_END);
    flags = MHD_USE_DEBUG;
  } while (NULL == httpd && flags != MHD_USE_DEBUG);

  if (NULL == httpd)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to start HTTP server\n"));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }

  run_httpd ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

open_static_page()

static struct StaticPage* open_static_page ( const char *  name, const char *  basedir  )

static

Open a file on disk and generate a response object for it.

Parameters

name	name of the file to open
basedir	directory where the file is located

Returns

GNUNET_SYSERR on error

Definition at line 991 of file gnunet-namestore-fcfsd.c.

References removetrailingwhitespace::f, GNUNET_DISK_FileHandle::fd, GNUNET_asprintf(), GNUNET_DISK_file_close(), GNUNET_DISK_file_handle_size(), GNUNET_DISK_file_open(), GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_NONE, GNUNET_free, GNUNET_new, GNUNET_SYSERR, StaticPage::handle, StaticPage::response, and StaticPage::size.

Referenced by run_service().

{
  char *fullname = NULL;
  GNUNET_asprintf (&fullname, "%s/fcfsd-%s", basedir, name);

  struct GNUNET_DISK_FileHandle *f =
    GNUNET_DISK_file_open (fullname,
                           GNUNET_DISK_OPEN_READ,
                           GNUNET_DISK_PERM_NONE);
  GNUNET_free (fullname);

  if (NULL == f)
  {
    return NULL;
  }

  off_t size = 0;
  if (GNUNET_SYSERR == GNUNET_DISK_file_handle_size (f, &size))
  {
    GNUNET_DISK_file_close (f);
    return NULL;
  }

  struct MHD_Response *response =
    MHD_create_response_from_fd64 (size,
                                   f->fd);

  if (NULL == response)
  {
    GNUNET_DISK_file_close (f);
    return NULL;
  }

  struct StaticPage *page = GNUNET_new (struct StaticPage);
  page->handle = f;
  page->size = (uint64_t) size;
  page->response = response;
  return page;
}

Here is the call graph for this function:

Here is the caller graph for this function:

run_service()

static void run_service ( void *  cls, char *const *  args, const char *  cfgfile, const struct GNUNET_CONFIGURATION_Handle *  cfg  )

static

Called after the service is up.

Parameters

cls	closure
args	remaining command line arguments
cfgfile	name of the configuration file
cfg	the service configuration

Definition at line 1041 of file gnunet-namestore-fcfsd.c.

References _, do_shutdown(), GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_IDENTITY_connect(), GNUNET_log, GNUNET_log_setup(), GNUNET_NAMESTORE_connect(), GNUNET_OK, GNUNET_OS_installation_get_path(), GNUNET_OS_IPK_DATADIR, GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), identity_cb(), open_static_page(), and port.

Referenced by main().

{
  (void) cls;
  (void) args;
  (void) cfgfile;

  GNUNET_log_setup ("fcfsd", "WARNING", NULL);

  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg,
                                                          "fcfsd",
                                                          "HTTPPORT",
                                                          &port))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                _ ("No port specified, using default value\n"));
  }

  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);

  namestore = GNUNET_NAMESTORE_connect (cfg);
  if (NULL == namestore)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to connect to namestore\n"));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }

  identity = GNUNET_IDENTITY_connect (cfg, &identity_cb, NULL);
  if (NULL == identity)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to connect to identity\n"));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }

  char *basedir = NULL;
  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg,
                                                            "fcfsd",
                                                            "HTMLDIR",
                                                            &basedir))
  {
    basedir = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_DATADIR);
  }

  main_page = open_static_page ("index.html", basedir);
  notfound_page = open_static_page ("notfound.html", basedir);
  forbidden_page = open_static_page ("forbidden.html", basedir);

  GNUNET_free (basedir);

  if ((NULL == main_page) || (NULL == notfound_page) || (NULL ==
                                                         forbidden_page) )
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Unable to set up the daemon\n"));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
}

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 of the fcfs daemon.

Parameters

argc	number of arguments from the command line argv the command line arguments

Returns

0 successful exit, a different value otherwise

Definition at line 1115 of file gnunet-namestore-fcfsd.c.

References _, gettext_noop, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_mandatory(), GNUNET_GETOPT_option_string(), GNUNET_OK, GNUNET_PROGRAM_run(), run_service(), and zone.

{
  struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_option_mandatory
      (GNUNET_GETOPT_option_string ('z',
                                    "zone",
                                    "EGO",
                                    gettext_noop (
                                      "name of the zone managed by FCFSD"),
                                    &zone)),
    GNUNET_GETOPT_OPTION_END
  };

  return ((GNUNET_OK == GNUNET_PROGRAM_run (argc,
                                            argv,
                                            "gnunet-namestore-fcfsd",
                                            _ (
                                              "GNU Name System First-Come-First-Served name registration service"),
                                            options,
                                            &run_service,
                                            NULL)) ?
          0 :
          1);
}

Here is the call graph for this function:

Variable Documentation

zone

char* zone = NULL

static

Name of the zone being managed.

Definition at line 119 of file gnunet-namestore-fcfsd.c.

Referenced by do_shutdown(), GNS_resolver_lookup(), GNUNET_GNS_lookup_limited(), GNUNET_NAMESTORE_zone_iteration_start(), GNUNET_NAMESTORE_zone_to_name(), handle_gns_cname_result(), identity_cb(), main(), namestore_flat_iterate_records(), namestore_flat_zone_to_name(), namestore_postgres_iterate_records(), namestore_postgres_lookup_records(), namestore_postgres_zone_to_name(), ns_lookup_error_cb(), ns_lookup_result_cb(), queue(), and recursive_gns2dns_resolution().

port

unsigned long long port = 18080

static

The port the daemon is listening to for HTTP requests.

Definition at line 124 of file gnunet-namestore-fcfsd.c.

Referenced by identity_cb(), and run_service().

namestore

struct GNUNET_NAMESTORE_Handle* namestore = NULL

static

Connection with the namestore service.

Definition at line 129 of file gnunet-namestore-fcfsd.c.

identity

struct GNUNET_IDENTITY_Handle* identity = NULL

static

Connection with the identity service.

Definition at line 134 of file gnunet-namestore-fcfsd.c.

zone_key

const struct GNUNET_IDENTITY_PrivateKey* zone_key = NULL

static

Private key of the zone.

Definition at line 139 of file gnunet-namestore-fcfsd.c.

Referenced by get_records_and_call_iterator(), handle_zone_to_name_it(), and send_lookup_response().

httpd

struct MHD_Daemon* httpd = NULL

static

The HTTP daemon.

Definition at line 144 of file gnunet-namestore-fcfsd.c.

Referenced by do_httpd(), identity_cb(), and run_httpd().

httpd_task

struct GNUNET_SCHEDULER_Task* httpd_task = NULL

static

Task executing the HTTP daemon.

Definition at line 149 of file gnunet-namestore-fcfsd.c.

main_page

struct StaticPage* main_page = NULL

static

The main page, a.k.a.

"index.html"

Definition at line 154 of file gnunet-namestore-fcfsd.c.

notfound_page

struct StaticPage* notfound_page = NULL

static

Page indicating the requested resource could not be found.

Definition at line 159 of file gnunet-namestore-fcfsd.c.

forbidden_page

struct StaticPage* forbidden_page = NULL

static

Page indicating the requested resource could not be accessed, and other errors.

Definition at line 165 of file gnunet-namestore-fcfsd.c.