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, enum GNUNET_ErrorCode ec)
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...
static struct GNUNET_TIME_Relative	record_exp
	The relative expiration time for added records. 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 178 of file gnunet-namestore-fcfsd.c.

{
  /* 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 (notfound_page->response);
    GNUNET_free (notfound_page->handle);
    GNUNET_free (notfound_page);
  }
  if (NULL != forbidden_page)
  {
    MHD_destroy_response (forbidden_page->response);
    GNUNET_free (forbidden_page->handle);
    GNUNET_free (forbidden_page);
  }
 
  if (NULL != namestore)
  {
    GNUNET_NAMESTORE_disconnect (namestore);
  }
 
  if (NULL != identity)
  {
    GNUNET_IDENTITY_disconnect (identity);
  }
 
  if (NULL != httpd_task)
  {
    GNUNET_SCHEDULER_cancel (httpd_task);
  }
  if (NULL != httpd)
  {
    MHD_stop_daemon (httpd);
  }
}

References forbidden_page, GNUNET_free, GNUNET_IDENTITY_disconnect(), GNUNET_NAMESTORE_disconnect(), GNUNET_SCHEDULER_cancel(), StaticPage::handle, httpd, httpd_task, identity, main_page, namestore, notfound_page, and StaticPage::response.

Referenced by run_service().

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 284 of file gnunet-namestore-fcfsd.c.

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

References httpd, httpd_task, and run_httpd().

Referenced by run_httpd(), and run_httpd_now().

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 237 of file gnunet-namestore-fcfsd.c.

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

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, httpd_task, max, and timeout.

Referenced by do_httpd(), and identity_cb().

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 293 of file gnunet-namestore-fcfsd.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 iterate_do_cb(), iterate_error_cb(), register_do_cb(), register_done_cb(), register_error_cb(), search_done_cb(), and search_error_cb().

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 313 of file gnunet-namestore-fcfsd.c.

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

References consensus-simulation::args, key, and value.

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().

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 367 of file gnunet-namestore-fcfsd.c.

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

References _, make_json(), MHD_HTTP_INTERNAL_SERVER_ERROR, rd, and run_httpd_now().

Referenced by create_response().

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 391 of file gnunet-namestore-fcfsd.c.

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

References make_json(), MHD_HTTP_OK, rd, run_httpd_now(), and zone.

Referenced by create_response().

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 420 of file gnunet-namestore-fcfsd.c.

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

References _, make_json(), MHD_HTTP_INTERNAL_SERVER_ERROR, rd, and run_httpd_now().

Referenced by iterate_done_cb().

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, enum GNUNET_ErrorCode  ec  )

static

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

{
  struct RequestData *rd = cls;
 
  MHD_resume_connection (rd->c);
  rd->searching = NULL;
 
  if (GNUNET_EC_NONE != ec)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Failed to create record for `%s': %s\n"),
                rd->register_name,
                GNUNET_ErrorCode_get_hint (ec));
    rd->body = make_json ("error", "true",
                          "message",
                          GNUNET_ErrorCode_get_hint (ec),
                          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 ();
}

References _, GNUNET_EC_NONE, GNUNET_ERROR_TYPE_WARNING, GNUNET_ErrorCode_get_hint(), GNUNET_log, make_json(), MHD_HTTP_INTERNAL_SERVER_ERROR, MHD_HTTP_OK, rd, and run_httpd_now().

Referenced by register_do_cb().

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 480 of file gnunet-namestore-fcfsd.c.

{
  (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 = record_exp.rel_value_us;
  gd.flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
 
  rd->searching = GNUNET_NAMESTORE_records_store (namestore,
                                                  zone_key,
                                                  rd->register_name,
                                                  1,
                                                  &gd,
                                                  &register_done_cb,
                                                  rd);
 
  GNUNET_free (gdraw);
}

References _, 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_RELATIVE_EXPIRATION, GNUNET_log, GNUNET_NAMESTORE_records_store(), GNUNET_OK, key, make_json(), MHD_HTTP_FORBIDDEN, MHD_HTTP_INTERNAL_SERVER_ERROR, namestore, rd, record_exp, GNUNET_GNSRECORD_Data::record_type, register_done_cb(), GNUNET_TIME_Relative::rel_value_us, run_httpd_now(), and zone_key.

Referenced by iterate_done_cb().

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 554 of file gnunet-namestore-fcfsd.c.

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

References _, make_json(), MHD_HTTP_INTERNAL_SERVER_ERROR, rd, and run_httpd_now().

Referenced by create_response().

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 579 of file gnunet-namestore-fcfsd.c.

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

References _, GNUNET_break, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NAMESTORE_zone_iteration_stop(), GNUNET_NAMESTORE_zone_iterator_next(), key, make_json(), MHD_HTTP_FORBIDDEN, rd, and run_httpd_now().

Referenced by create_response().

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 620 of file gnunet-namestore-fcfsd.c.

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

References GNUNET_NAMESTORE_zone_to_name(), namestore, rd, register_do_cb(), register_error_cb(), and zone_key.

Referenced by create_response().

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 647 of file gnunet-namestore-fcfsd.c.

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

References MHD_RESULT, and response.

Referenced by create_response().

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 676 of file gnunet-namestore-fcfsd.c.

{
  (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);
#ifdef MHD_HTTP_CONTENT_TOO_LARGE
        rd->code = MHD_HTTP_CONTENT_TOO_LARGE;
#else
        rd->code = MHD_HTTP_PAYLOAD_TOO_LARGE;
#endif
        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);
}

References _, forbidden_page, 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(), key, main_page, make_json(), MHD_HTTP_BAD_REQUEST, MHD_HTTP_FORBIDDEN, MHD_HTTP_INTERNAL_SERVER_ERROR, MHD_HTTP_NOT_FOUND, MHD_HTTP_NOT_IMPLEMENTED, MHD_HTTP_OK, MHD_HTTP_PAYLOAD_TOO_LARGE, name, namestore, notfound_page, RequestData::ptr, rd, StaticPage::response, result, search_done_cb(), search_error_cb(), serve_json(), and zone_key.

Referenced by identity_cb().

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 890 of file gnunet-namestore-fcfsd.c.

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

References GNUNET_free, GNUNET_NAMESTORE_cancel(), GNUNET_NAMESTORE_zone_iteration_stop(), RequestData::ptr, rd, and status.

Referenced by identity_cb().

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 944 of file gnunet-namestore-fcfsd.c.

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

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

Referenced by run_service().

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

NULL on error

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

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

References removetrailingwhitespace::f, 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, name, response, StaticPage::response, StaticPage::size, and size.

Referenced by run_service().

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 1052 of file gnunet-namestore-fcfsd.c.

{
  (void) cls;
  (void) args;
  (void) cfgfile;
 
  GNUNET_log_setup ("fcfsd", "WARNING", NULL);
 
  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_time (cfg,
                                                        "fcfsd",
                                                        "RELATIVE_RECORD_EXPIRATION",
                                                        &record_exp))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                _("No expiration specified for records.\n"));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
 
  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;
  }
}

References _, consensus-simulation::args, cfg, do_shutdown(), forbidden_page, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_time(), 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, identity_cb(), main_page, namestore, notfound_page, open_static_page(), port, and record_exp.

Referenced by main().

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 1137 of file gnunet-namestore-fcfsd.c.

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

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

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 attr_iter_cb(), cache_nick(), check_credential_iteration_start(), del_monitor(), DID_create(), do_flood(), do_shutdown(), get_nick_record(), GNS_resolver_lookup(), GNUNET_GNS_lookup(), GNUNET_GNS_lookup_limited(), GNUNET_GNSRECORD_query_from_private_key(), GNUNET_NAMESTORE_zone_iteration_start(), GNUNET_NAMESTORE_zone_iteration_start2(), GNUNET_NAMESTORE_zone_monitor_start(), GNUNET_NAMESTORE_zone_monitor_start2(), GNUNET_NAMESTORE_zone_to_name(), handle_dns_request(), handle_gns_redirect_result(), handle_iteration_start(), handle_lookup(), handle_monitor_event(), handle_monitor_start(), handle_record_lookup(), handle_record_store(), handle_reverse_lookup(), handle_zone_to_name(), handle_zone_to_name_response(), identity_cb(), main(), namestore_flat_iterate_records(), namestore_flat_lookup_records(), namestore_flat_zone_to_name(), namestore_postgres_edit_records(), ns_lookup_error_cb(), ns_lookup_result_cb(), queue(), recursive_gns2dns_resolution(), and search_done_cb().

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.

Referenced by create_response(), do_shutdown(), iterate_done_cb(), register_do_cb(), and run_service().

identity

struct GNUNET_IDENTITY_Handle* identity = NULL

static

Connection with the identity service.

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

Referenced by do_shutdown(), and run_service().

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 check_monitor_start(), check_zone_to_name(), collect_orphans(), collect_zone_records_to_purge(), create_response(), display_record(), display_record_iterator(), display_record_lookup(), display_record_monitor(), get_existing_record(), identity_cb(), iterate_done_cb(), namestore_flat_store_records(), purge_orphans_iterator(), purge_zone_iterator(), register_do_cb(), send_lookup_response_with_filter(), and zone_iterate_proc().

httpd

struct MHD_Daemon* httpd = NULL

static

The HTTP daemon.

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

Referenced by do_httpd(), do_shutdown(), 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.

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

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.

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

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.

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

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.

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

record_exp

struct GNUNET_TIME_Relative record_exp

static

The relative expiration time for added records.

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

Referenced by register_do_cb(), and run_service().