GNUnet  0.11.x
Data Structures | Functions | Variables
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 StaticPageopen_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_Handlenamestore = NULL
 Connection with the namestore service. More...
 
static struct GNUNET_IDENTITY_Handleidentity = NULL
 Connection with the identity service. More...
 
static const struct GNUNET_IDENTITY_PrivateKeyzone_key = NULL
 Private key of the zone. More...
 
static struct MHD_Daemon * httpd = NULL
 The HTTP daemon. More...
 
static struct GNUNET_SCHEDULER_Taskhttpd_task = NULL
 Task executing the HTTP daemon. More...
 
static struct StaticPagemain_page = NULL
 The main page, a.k.a. More...
 
static struct StaticPagenotfound_page = NULL
 Page indicating the requested resource could not be found. More...
 
static struct StaticPageforbidden_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
clsunused

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

179 {
180  /* We cheat a bit here: the file descriptor is implicitly closed by MHD, so
181  calling `GNUNET_DISK_file_close' would generate a spurious warning message
182  in the log. Since that function does nothing but close the descriptor and
183  free the allocated memory, After destroying the response all that's left to
184  do is call `GNUNET_free'. */
185  if (NULL != main_page)
186  {
187  MHD_destroy_response (main_page->response);
190  }
191  if (NULL != notfound_page)
192  {
193  MHD_destroy_response (notfound_page->response);
196  }
197  if (NULL != forbidden_page)
198  {
199  MHD_destroy_response (forbidden_page->response);
202  }
203 
204  if (NULL != namestore)
205  {
207  }
208 
209  if (NULL != identity)
210  {
212  }
213 
214  if (NULL != httpd_task)
215  {
217  }
218  if (NULL != httpd)
219  {
220  MHD_stop_daemon (httpd);
221  }
222 }
static struct MHD_Daemon * httpd
The HTTP daemon.
static struct GNUNET_NAMESTORE_Handle * namestore
Connection with the namestore service.
static struct StaticPage * main_page
The main page, a.k.a.
static struct StaticPage * notfound_page
Page indicating the requested resource could not be found.
static struct GNUNET_SCHEDULER_Task * httpd_task
Task executing the HTTP daemon.
static struct StaticPage * forbidden_page
Page indicating the requested resource could not be accessed, and other errors.
static struct GNUNET_IDENTITY_Handle * identity
Connection with the identity service.
void GNUNET_IDENTITY_disconnect(struct GNUNET_IDENTITY_Handle *h)
Disconnect from identity service.
Definition: identity_api.c:921
#define GNUNET_free(ptr)
Wrapper around free.
void GNUNET_NAMESTORE_disconnect(struct GNUNET_NAMESTORE_Handle *h)
Disconnect from the namestore service (and free associated resources).
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:957
struct GNUNET_DISK_FileHandle * handle
Handle to file on disk.
struct MHD_Response * response
Cached response object to send to clients.

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
clsunused

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

285 {
286  httpd_task = NULL;
287  MHD_run (httpd);
288  run_httpd ();
289 }
static void run_httpd(void)
Schedule a task to run MHD.

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.

238 {
239  fd_set rs;
240  fd_set ws;
241  fd_set es;
242 
246 
247  FD_ZERO (&rs);
248  FD_ZERO (&ws);
249  FD_ZERO (&es);
250 
251  int max = -1;
252  GNUNET_assert (MHD_YES == MHD_get_fdset (httpd, &rs, &ws, &es, &max));
253 
254  unsigned MHD_LONG_LONG timeout = 0;
256  if (MHD_YES == MHD_get_timeout (httpd, &timeout))
257  {
259  timeout);
260  }
261 
262  GNUNET_NETWORK_fdset_copy_native (grs, &rs, max + 1);
263  GNUNET_NETWORK_fdset_copy_native (gws, &ws, max + 1);
264  GNUNET_NETWORK_fdset_copy_native (ges, &es, max + 1);
265 
267  gtime,
268  grs,
269  gws,
270  &do_httpd,
271  NULL);
275 }
static struct GNUNET_TIME_Relative timeout
Desired timeout for the lookup (default is no timeout).
Definition: gnunet-abd.c:61
static void do_httpd(void *cls)
Called when the HTTP server has some pending operations.
@ GNUNET_SCHEDULER_PRIORITY_HIGH
Run with high priority (important requests).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_NETWORK_FDSet * GNUNET_NETWORK_fdset_create(void)
Creates an fd set.
Definition: network.c:1193
void GNUNET_NETWORK_fdset_destroy(struct GNUNET_NETWORK_FDSet *fds)
Releases the associated memory of an fd set.
Definition: network.c:1209
void GNUNET_NETWORK_fdset_copy_native(struct GNUNET_NETWORK_FDSet *to, const fd_set *from, int nfds)
Copy a native fd set into the GNUnet representation.
Definition: network.c:1063
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_select(enum GNUNET_SCHEDULER_Priority prio, struct GNUNET_TIME_Relative delay, const struct GNUNET_NETWORK_FDSet *rs, const struct GNUNET_NETWORK_FDSet *ws, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when any of the specified file descriptor set...
Definition: scheduler.c:1826
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
#define GNUNET_TIME_UNIT_MILLISECONDS
One millisecond.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:483
#define max(x, y)
collection of IO descriptors
Time for relative time used by GNUnet, in microseconds.

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.

294 {
295  if (NULL != httpd_task)
296  {
298  httpd_task = NULL;
299  }
301 }
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1281

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
keythe key for the first element
valuethe 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.

314 {
315  va_list args;
316  va_start (args, value);
317 
318  json_t *obj = NULL;
319 
320  obj = json_object ();
321  if ((NULL == key) || (NULL == value))
322  {
323  va_end (args);
324  return json_dumps (obj, JSON_COMPACT);
325  }
326 
327  json_object_set (obj, key, json_string (value));
328 
329  char *k = va_arg (args, char *);
330  if (NULL == k)
331  {
332  va_end (args);
333  return json_dumps (obj, JSON_COMPACT);
334  }
335  char *v = va_arg (args, char *);
336  if (NULL == v)
337  {
338  va_end (args);
339  return json_dumps (obj, JSON_COMPACT);
340  }
341 
342  while (NULL != k && NULL != v)
343  {
344  json_object_set (obj, k, json_string (v));
345  k = va_arg (args, char *);
346  if (NULL != k)
347  {
348  v = va_arg (args, char *);
349  }
350  }
351 
352  va_end (args);
353 
354  char *json = json_dumps (obj, JSON_COMPACT);
355  json_decref (obj);
356 
357  return json;
358 }
struct GNUNET_HashCode key
The key used in the DHT.
static char * value
Value of the record to add/remove.

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
clsthe request data

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

368 {
369  struct RequestData *rd = cls;
370  MHD_resume_connection (rd->c);
371  rd->searching = NULL;
372  rd->body = make_json ("error", "true",
373  "message", _ ("can not search the namestore"),
374  NULL);
375  rd->body_length = strlen (rd->body);
376  rd->code = MHD_HTTP_INTERNAL_SERVER_ERROR;
377  run_httpd_now ();
378 }
static void run_httpd_now(void)
static char * make_json(const char *key, const char *value,...)
Generate a JSON object.
#define _(String)
GNU gettext support macro.
Definition: platform.h:177
Structure containing some request-specific data.
size_t body_length
Length in bytes of the body.
int code
Response code.
struct MHD_Connection * c
The connection this request was sent in.
char * body
Body of the response object.
struct GNUNET_NAMESTORE_QueueEntry * searching
Task started to search for an entry in the namestore.

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

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
clsclosure
zonethe private key of the zone
labelthe result label
countnumber of records found
drecords found

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

396 {
397  (void) zone;
398  (void) d;
399 
400  struct RequestData *rd = cls;
401  MHD_resume_connection (rd->c);
402 
403  rd->searching = NULL;
404  rd->body = make_json ("error", "false",
405  "free", (0 == count) ? "true" : "false",
406  NULL);
407  rd->body_length = strlen (rd->body);
408  rd->code = MHD_HTTP_OK;
409 
410  run_httpd_now ();
411 }
static char * zone
Name of the zone being managed.

References RequestData::body, RequestData::body_length, RequestData::c, RequestData::code, make_json(), run_httpd_now(), RequestData::searching, 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
clsthe connection

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

421 {
422  struct RequestData *rd = cls;
423 
424  MHD_resume_connection (rd->c);
425  rd->searching = NULL;
426  rd->body = make_json ("error", "true",
427  "message", _ ("unable to scan namestore"),
428  NULL);
429  rd->body_length = strlen (rd->body);
430  rd->code = MHD_HTTP_INTERNAL_SERVER_ERROR;
431  run_httpd_now ();
432 }

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

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,
int32_t  status,
const char *  emsg 
)
static

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

Parameters
clsthe connection
statusresult of the operation
emsgerror message if any

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

446 {
447  struct RequestData *rd = cls;
448 
449  MHD_resume_connection (rd->c);
450  rd->searching = NULL;
451 
452  if ((GNUNET_SYSERR == status) || (GNUNET_NO == status))
453  {
455  _ ("Failed to create record for `%s': %s\n"),
456  rd->register_name,
457  emsg);
458  rd->body = make_json ("error", "true",
459  "message", emsg,
460  NULL);
461  rd->body_length = strlen (rd->body);
462  rd->code = MHD_HTTP_INTERNAL_SERVER_ERROR;
463  }
464  else
465  {
466  rd->body = make_json ("error", "false",
467  "message", _ ("no errors"),
468  NULL);
469  rd->body_length = strlen (rd->body);
470  rd->code = MHD_HTTP_OK;
471  }
472 
473  run_httpd_now ();
474 }
uint16_t status
See PRISM_STATUS_*-constants.
#define GNUNET_log(kind,...)
@ GNUNET_NO
Definition: gnunet_common.h:94
@ GNUNET_SYSERR
Definition: gnunet_common.h:93
@ GNUNET_ERROR_TYPE_WARNING
char * register_name
Name requested to be registered.

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(), RequestData::searching, and status.

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
clsthe connection
keythe zone key
labelname of the record
countnumber of records found
drecords

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

492 {
493  (void) key;
494  (void) d;
495 
496  struct RequestData *rd = cls;
497 
498  rd->searching = NULL;
499 
500  if (0 != count)
501  {
503  _ ("The requested key `%s' exists as `%s'\n"),
504  rd->register_key,
505  label);
506 
507  MHD_resume_connection (rd->c);
508  rd->searching = NULL;
509  rd->body = make_json ("error", "true",
510  "message", _ ("key exists"),
511  NULL);
512  rd->body_length = strlen (rd->body);
513  rd->code = MHD_HTTP_FORBIDDEN;
514  run_httpd_now ();
515  return;
516  }
517 
518  struct GNUNET_GNSRECORD_Data gd;
519  char *gdraw = NULL;
520 
522  &gdraw,
523  &(gd.data_size),
524  &(gd.record_type)))
525  {
527  _ ("Error creating record data\n"));
528  MHD_resume_connection (rd->c);
529  rd->searching = NULL;
530  rd->body = make_json ("error", "true",
531  "message", _ ("unable to store record"),
532  NULL);
533  rd->body_length = strlen (rd->body);
534  rd->code = MHD_HTTP_INTERNAL_SERVER_ERROR;
535  run_httpd_now ();
536  return;
537  }
538 
539  gd.data = gdraw;
540  gd.expiration_time = record_exp.rel_value_us;
542 
544  zone_key,
545  rd->register_name,
546  1,
547  &gd,
549  rd);
550 
551  GNUNET_free (gdraw);
552 }
static struct GNUNET_TIME_Relative record_exp
The relative expiration time for added records.
static void register_done_cb(void *cls, int32_t status, const char *emsg)
A name/key pair has been successfully registered, or maybe not.
static const struct GNUNET_IDENTITY_PrivateKey * zone_key
Private key of the zone.
@ GNUNET_OK
Definition: gnunet_common.h:95
enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_data_from_identity(const struct GNUNET_IDENTITY_PublicKey *key, char **data, size_t *data_size, uint32_t *type)
Create record data and size from an identity key.
@ GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION
This expiration time of the record is a relative time (not an absolute time).
@ GNUNET_ERROR_TYPE_INFO
struct GNUNET_NAMESTORE_QueueEntry * GNUNET_NAMESTORE_records_store(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_IDENTITY_PrivateKey *pkey, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd, GNUNET_NAMESTORE_ContinuationWithStatus cont, void *cont_cls)
Store an item in the namestore.
uint64_t rel_value_us
The actual value.
struct GNUNET_IDENTITY_PublicKey key
Key to be associated with the requested name.
char * register_key
Key (encoded as a string) to be associated with the requested name.

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_RELATIVE_EXPIRATION, GNUNET_log, GNUNET_NAMESTORE_records_store(), GNUNET_OK, key, RequestData::key, make_json(), namestore, record_exp, GNUNET_GNSRECORD_Data::record_type, register_done_cb(), RequestData::register_key, RequestData::register_name, GNUNET_TIME_Relative::rel_value_us, run_httpd_now(), RequestData::searching, 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
clsthe connection

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

562 {
563  struct RequestData *rd = cls;
564 
565  MHD_resume_connection (rd->c);
566  rd->iterating = NULL;
567  rd->body = make_json ("error", "true",
568  "message", _ ("unable to scan namestore"),
569  NULL);
570  rd->body_length = strlen (rd->body);
571  rd->code = MHD_HTTP_INTERNAL_SERVER_ERROR;
572  run_httpd_now ();
573 }
struct GNUNET_NAMESTORE_ZoneIterator * iterating
Task started to iterate over the namestore.

References _, RequestData::body, RequestData::body_length, RequestData::c, RequestData::code, RequestData::iterating, make_json(), 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
clsthe connection
keythe zone key
labelthe records' label
countnumber of records found
dthe found records

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

591 {
592  (void) key;
593  (void) label;
594  (void) d;
595 
596  struct RequestData *rd = cls;
597 
598  if (0 == strcmp (label, rd->register_name))
599  {
600  GNUNET_break (0 != count);
602  _ ("Requested name `%s' exists with `%u' records\n"),
603  rd->register_name,
604  count);
605 
606  MHD_resume_connection (rd->c);
607  rd->body = make_json ("error", "true",
608  "message", _ ("name exists\n"),
609  NULL);
610  rd->body_length = strlen (rd->body);
611  rd->code = MHD_HTTP_FORBIDDEN;
613  run_httpd_now ();
614  return;
615  }
616 
618 }
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
void GNUNET_NAMESTORE_zone_iterator_next(struct GNUNET_NAMESTORE_ZoneIterator *it, uint64_t limit)
Calls the record processor specified in GNUNET_NAMESTORE_zone_iteration_start for the next record.
void GNUNET_NAMESTORE_zone_iteration_stop(struct GNUNET_NAMESTORE_ZoneIterator *it)
Stops iteration and releases the namestore handle for further calls.

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, key, make_json(), RequestData::register_name, 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
clsthe connection

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

628 {
629  struct RequestData *rd = cls;
630 
631  rd->iterating = NULL;
632 
633  /* See if the key was not registered already */
635  zone_key,
636  &(rd->key),
638  rd,
640  rd);
641 }
static void register_error_cb(void *cls)
An error occurred while registering a name.
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.
struct GNUNET_NAMESTORE_QueueEntry * GNUNET_NAMESTORE_zone_to_name(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_IDENTITY_PrivateKey *zone, const struct GNUNET_IDENTITY_PublicKey *value_zone, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_NAMESTORE_RecordMonitor proc, void *proc_cls)
Look for an existing PKEY delegation record for a given public key.

References GNUNET_NAMESTORE_zone_to_name(), RequestData::iterating, RequestData::key, namestore, register_do_cb(), register_error_cb(), RequestData::searching, 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
cthe connection
bodythe response body
lengththe body length in bytes
codethe response code
Returns
MHD_NO on error

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

658 {
659  struct MHD_Response *response =
660  MHD_create_response_from_buffer (length,
661  body,
662  MHD_RESPMEM_PERSISTENT);
663  MHD_RESULT r = MHD_queue_response (c, code, response);
664  MHD_destroy_response (response);
665  return r;
666 }
static struct MHD_Response * response
Our canonical response.
#define MHD_RESULT
Data type to use for functions return an "MHD result".

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
clsunused
connectionthe connection with the client
urlthe requested address
methodthe HTTP method used
versionthe protocol version (including the "HTTP/" part)
upload_datadata sent with a POST request
upload_data_sizelength in bytes of the POST data
ptrused to pass data between request handling phases
Returns
MHD_NO on error

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

691 {
692  (void) cls;
693  (void) version;
694 
695  struct RequestData *rd = *ptr;
696 
697  if (0 == strcmp (method, MHD_HTTP_METHOD_GET))
698  {
699  /* Handle a previously suspended request */
700  if (NULL != rd)
701  {
702  return serve_json (rd->c, rd->body, rd->body_length, rd->code);
703  }
704 
705  if (0 == strcmp ("/", url))
706  {
707  return MHD_queue_response (connection,
708  MHD_HTTP_OK,
710  }
711 
712  if (0 == strcmp ("/search", url))
713  {
714  const char *name = MHD_lookup_connection_value (connection,
715  MHD_GET_ARGUMENT_KIND,
716  "name");
717  if (NULL == name)
718  {
719  return MHD_queue_response (connection,
720  MHD_HTTP_BAD_REQUEST,
722  }
723 
724  MHD_suspend_connection (connection);
725  rd = GNUNET_new (struct RequestData);
726  rd->c = connection;
728  zone_key,
729  name,
731  rd,
733  rd);
734  *ptr = rd;
735  return MHD_YES;
736  }
737 
738  return MHD_queue_response (connection,
739  MHD_HTTP_NOT_FOUND,
741  }
742 
743  if (0 == strcmp (method, MHD_HTTP_METHOD_HEAD))
744  {
745  /* We take a shortcut here by always serving the main page: starting a
746  namestore lookup, allocating the necessary resources, waiting for the
747  lookup to complete and then discard everything just because it was a HEAD
748  and thus only the headers are significative, is an unnecessary waste of
749  resources. The handling of this method could be smarter, for example by
750  sending a proper content type header based on the endpoint, but this is
751  not a service in which HEAD requests are significant, so there's no need
752  to spend too much time here. */
753  return MHD_queue_response (connection,
754  MHD_HTTP_OK,
756  }
757 
758  if (0 == strcmp (method, MHD_HTTP_METHOD_POST))
759  {
760  if (0 == strcmp ("/register", url))
761  {
762  /* Handle a previously suspended request */
763  if ((NULL != rd) && (NULL != rd->body))
764  {
765  return serve_json (rd->c, rd->body, rd->body_length, rd->code);
766  }
767 
768  if (NULL == rd)
769  {
770  rd = GNUNET_new (struct RequestData);
771  rd->c = connection;
772  rd->body = NULL;
773  rd->ptr = NULL;
774  *ptr = rd;
775  }
776 
777  json_t *json = NULL;
779  GNUNET_JSON_post_parser (32 * 1024,
780  connection,
781  &(rd->ptr),
782  upload_data,
783  upload_data_size,
784  &json);
785 
786  switch (result)
787  {
789  /* Keep processing POST data */
790  return MHD_YES;
793  rd->body = make_json ("error", "true",
794  "message", _ ("unable to process submitted data"),
795  NULL);
796  rd->body_length = strlen (rd->body);
797 #ifdef MHD_HTTP_CONTENT_TOO_LARGE
798  rd->code = MHD_HTTP_CONTENT_TOO_LARGE;
799 #else
800  rd->code = MHD_HTTP_PAYLOAD_TOO_LARGE;
801 #endif
802  return MHD_YES;
804  rd->body = make_json ("error", "true",
805  "message", _ ("the submitted data is invalid"),
806  NULL);
807  rd->body_length = strlen (rd->body);
808  rd->code = MHD_HTTP_BAD_REQUEST;
809  return MHD_YES;
810  default:
811  break;
812  }
813 
814  /* POST data has been read in its entirety */
815 
816  const char *name = json_string_value (json_object_get (json, "name"));
817  const char *key = json_string_value (json_object_get (json, "key"));
818  if ((NULL == name) || (NULL == key) || (0 == strlen (name)) || (0 ==
819  strlen (
820  key)))
821  {
822  json_decref (json);
823  rd->body = make_json ("error", "true",
824  "message", _ ("invalid parameters"),
825  NULL);
826  rd->body_length = strlen (rd->body);
827  rd->code = MHD_HTTP_BAD_REQUEST;
828  return MHD_YES;
829  }
830 
831  rd->register_name = strdup (name);
832  rd->register_key = strdup (key);
833 
834  json_decref (json);
836 
837  if ((NULL != strchr (rd->register_name, '.')) ||
838  (NULL != strchr (rd->register_name, '+')))
839  {
840  rd->body = make_json ("error", "true",
841  "message", _ ("invalid name"),
842  NULL);
843  rd->body_length = strlen (rd->body);
844  rd->code = MHD_HTTP_BAD_REQUEST;
845  return MHD_YES;
846  }
847 
849  &(rd->key)))
850  {
852  _ ("Unable to parse key %s\n"),
853  rd->register_key);
854 
855  rd->body = make_json ("error", "true",
856  "message", _ ("unable to parse key"),
857  NULL);
858  rd->body_length = strlen (rd->body);
859  rd->code = MHD_HTTP_INTERNAL_SERVER_ERROR;
860  return MHD_YES;
861  }
862 
863  MHD_suspend_connection (connection);
864  /* See if the requested name is free */
865  rd->iterating =
867  zone_key,
869  rd,
870  &iterate_do_cb,
871  rd,
873  rd);
874  return MHD_YES;
875  }
876 
877  return MHD_queue_response (connection,
878  MHD_HTTP_FORBIDDEN,
880  }
881 
882  return MHD_queue_response (connection,
883  MHD_HTTP_NOT_IMPLEMENTED,
885 }
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.
static void iterate_error_cb(void *cls)
An error occurred while iterating the namestore.
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.
static void iterate_done_cb(void *cls)
All entries in the namestore have been iterated over.
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.
static void search_error_cb(void *cls)
The namestore search task failed.
static int result
Global testing status.
GNUNET_JSON_PostResult
Return codes from GNUNET_JSON_post_parser().
@ GNUNET_JSON_PR_CONTINUE
Parsing continues, call again soon!
@ GNUNET_JSON_PR_OUT_OF_MEMORY
Sorry, memory allocation (malloc()) failed.
@ GNUNET_JSON_PR_JSON_INVALID
JSON parsing failed.
@ GNUNET_JSON_PR_REQUEST_TOO_LARGE
Request size exceeded buffer_max argument.
enum GNUNET_JSON_PostResult GNUNET_JSON_post_parser(size_t buffer_max, struct MHD_Connection *connection, void **con_cls, const char *upload_data, size_t *upload_data_size, json_t **json)
Process a POST request containing a JSON object.
Definition: json_mhd.c:265
void GNUNET_JSON_post_parser_cleanup(void *con_cls)
Function called whenever we are done with a request to clean up our state.
Definition: json_mhd.c:367
enum GNUNET_GenericReturnValue GNUNET_IDENTITY_public_key_from_string(const char *str, struct GNUNET_IDENTITY_PublicKey *key)
Parses a (Base32) string representation of the public key.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_NAMESTORE_ZoneIterator * GNUNET_NAMESTORE_zone_iteration_start(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_IDENTITY_PrivateKey *zone, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_NAMESTORE_RecordMonitor proc, void *proc_cls, GNUNET_SCHEDULER_TaskCallback finish_cb, void *finish_cb_cls)
Starts a new zone iteration (used to periodically PUT all of our records into our DHT).
struct GNUNET_NAMESTORE_QueueEntry * GNUNET_NAMESTORE_records_lookup(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_IDENTITY_PrivateKey *pkey, const char *label, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_NAMESTORE_RecordMonitor rm, void *rm_cls)
Lookup an item in the namestore.
const char * name
void * ptr
Pointer used while processing POST data.

References _, RequestData::body, RequestData::body_length, RequestData::c, RequestData::code, 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(), RequestData::iterating, key, RequestData::key, main_page, make_json(), name, namestore, notfound_page, RequestData::ptr, RequestData::register_key, RequestData::register_name, StaticPage::response, result, search_done_cb(), search_error_cb(), RequestData::searching, 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
clsunused
connectionthe connection
ptrconnection-specific data
statusstatus code

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

901 {
902  (void) cls;
903  (void) connection;
904  (void) status;
905 
906  struct RequestData *rd = *ptr;
907 
908  if (NULL == rd)
909  {
910  return;
911  }
912 
913  if (NULL == rd->body)
914  {
915  GNUNET_free (rd->body);
916  }
917 
918  if (NULL != rd->searching)
919  {
921  }
922 
923  if (NULL != rd->register_name)
924  {
926  }
927 
928  if (NULL != rd->register_key)
929  {
931  }
932 
933  if (NULL != rd->iterating)
934  {
936  }
937 
938  GNUNET_free (rd);
939 }
void GNUNET_NAMESTORE_cancel(struct GNUNET_NAMESTORE_QueueEntry *qe)
Cancel a namestore operation.

References RequestData::body, GNUNET_free, GNUNET_NAMESTORE_cancel(), GNUNET_NAMESTORE_zone_iteration_stop(), RequestData::iterating, RequestData::ptr, RequestData::register_key, RequestData::register_name, RequestData::searching, 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
clsclosure
egothe ego
ctxapplication-provided data for the ego
namethe ego name

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

955 {
956  (void) cls;
957  (void) ctx;
958 
959  if ((NULL == name) || (0 != strcmp (name, zone)))
960  {
961  return;
962  }
963 
964  if (NULL == ego)
965  {
967  _ ("No ego configured for `fcfsd` subsystem\n"));
969  return;
970  }
971 
973 
974  int flags = MHD_USE_DUAL_STACK | MHD_USE_DEBUG | MHD_ALLOW_SUSPEND_RESUME;
975  do
976  {
977  httpd = MHD_start_daemon (flags,
978  (uint16_t) port,
979  NULL, NULL,
980  &create_response, NULL,
981  MHD_OPTION_CONNECTION_LIMIT, 128,
982  MHD_OPTION_PER_IP_CONNECTION_LIMIT, 1,
983  MHD_OPTION_CONNECTION_TIMEOUT, 4 * 1024,
984  MHD_OPTION_NOTIFY_COMPLETED, &completed_cb, NULL,
985  MHD_OPTION_END);
986  flags = MHD_USE_DEBUG;
987  } while (NULL == httpd && flags != MHD_USE_DEBUG);
988 
989  if (NULL == httpd)
990  {
992  _ ("Failed to start HTTP server\n"));
994  return;
995  }
996 
997  run_httpd ();
998 }
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.
static void completed_cb(void *cls, struct MHD_Connection *connection, void **ptr, enum MHD_RequestTerminationCode status)
Called when a request is completed.
static unsigned long long port
The port the daemon is listening to for HTTP requests.
static struct GNUNET_DNSSTUB_Context * ctx
Context for DNS resolution.
const struct GNUNET_IDENTITY_PrivateKey * GNUNET_IDENTITY_ego_get_private_key(const struct GNUNET_IDENTITY_Ego *ego)
Obtain the ECC key associated with a ego.
Definition: identity_api.c:639
@ GNUNET_ERROR_TYPE_ERROR
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:533

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
namename of the file to open
basedirdirectory where the file is located
Returns
NULL on error

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

1010 {
1011  char *fullname = NULL;
1012  GNUNET_asprintf (&fullname, "%s/fcfsd-%s", basedir, name);
1013 
1014  struct GNUNET_DISK_FileHandle *f =
1015  GNUNET_DISK_file_open (fullname,
1018  GNUNET_free (fullname);
1019 
1020  if (NULL == f)
1021  {
1022  return NULL;
1023  }
1024 
1025  off_t size = 0;
1027  {
1029  return NULL;
1030  }
1031 
1032  struct MHD_Response *response =
1033  MHD_create_response_from_fd64 (size,
1034  f->fd);
1035 
1036  if (NULL == response)
1037  {
1039  return NULL;
1040  }
1041 
1042  struct StaticPage *page = GNUNET_new (struct StaticPage);
1043  page->handle = f;
1044  page->size = (uint64_t) size;
1045  page->response = response;
1046  return page;
1047 }
struct GNUNET_DISK_FileHandle * GNUNET_DISK_file_open(const char *fn, enum GNUNET_DISK_OpenFlags flags, enum GNUNET_DISK_AccessPermissions perm)
Open a file.
Definition: disk.c:1235
enum GNUNET_GenericReturnValue GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1306
enum GNUNET_GenericReturnValue GNUNET_DISK_file_handle_size(struct GNUNET_DISK_FileHandle *fh, off_t *size)
Get the size of an open file.
Definition: disk.c:193
@ GNUNET_DISK_OPEN_READ
Open the file for reading.
@ GNUNET_DISK_PERM_NONE
Nobody is allowed to do anything to the file.
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
static unsigned int size
Size of the "table".
Definition: peer.c:67
Handle used to access files (and pipes).
Structure representing a static page.
uint64_t size
Size in bytes of the file.

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
clsclosure
argsremaining command line arguments
cfgfilename of the configuration file
cfgthe service configuration

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

1063 {
1064  (void) cls;
1065  (void) args;
1066  (void) cfgfile;
1067 
1068  GNUNET_log_setup ("fcfsd", "WARNING", NULL);
1069 
1071  "fcfsd",
1072  "RELATIVE_RECORD_EXPIRATION",
1073  &record_exp))
1074  {
1076  _("No expiration specified for records.\n"));
1078  return;
1079  }
1080 
1082  "fcfsd",
1083  "HTTPPORT",
1084  &port))
1085  {
1087  _ ("No port specified, using default value\n"));
1088  }
1089 
1091 
1093  if (NULL == namestore)
1094  {
1096  _ ("Failed to connect to namestore\n"));
1098  return;
1099  }
1100 
1102  if (NULL == identity)
1103  {
1105  _ ("Failed to connect to identity\n"));
1107  return;
1108  }
1109 
1110  char *basedir = NULL;
1112  "fcfsd",
1113  "HTMLDIR",
1114  &basedir))
1115  {
1117  }
1118 
1119  main_page = open_static_page ("index.html", basedir);
1120  notfound_page = open_static_page ("notfound.html", basedir);
1121  forbidden_page = open_static_page ("forbidden.html", basedir);
1122 
1123  GNUNET_free (basedir);
1124 
1125  if ((NULL == main_page) || (NULL == notfound_page) || (NULL ==
1126  forbidden_page) )
1127  {
1129  _ ("Unable to set up the daemon\n"));
1131  return;
1132  }
1133 }
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
static struct StaticPage * open_static_page(const char *name, const char *basedir)
Open a file on disk and generate a response object for it.
static void do_shutdown(void *cls)
Task ran at shutdown to clean up everything.
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.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_filename(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be the name of a file or directory.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_number(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *number)
Get a configuration value that should be a number.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_time(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, struct GNUNET_TIME_Relative *time)
Get a configuration value that should be a relative time.
struct GNUNET_IDENTITY_Handle * GNUNET_IDENTITY_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_IDENTITY_Callback cb, void *cb_cls)
Connect to the identity service.
Definition: identity_api.c:610
int GNUNET_log_setup(const char *comp, const char *loglevel, const char *logfile)
Setup logging.
struct GNUNET_NAMESTORE_Handle * GNUNET_NAMESTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the namestore service.
char * GNUNET_OS_installation_get_path(enum GNUNET_OS_InstallationPathKind dirkind)
Get the path to a specific GNUnet installation directory or, with GNUNET_OS_IPK_SELF_PREFIX,...
@ GNUNET_OS_IPK_DATADIR
Return the directory where data is installed (share/gnunet/)
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received,...
Definition: scheduler.c:1316

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
argcnumber of arguments from the command line @parsm argv the command line arguments
Returns
0 successful exit, a different value otherwise

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

1145 {
1149  "zone",
1150  "EGO",
1151  gettext_noop (
1152  "name of the zone managed by FCFSD"),
1153  &zone)),
1155  };
1156 
1157  return ((GNUNET_OK == GNUNET_PROGRAM_run (argc,
1158  argv,
1159  "gnunet-namestore-fcfsd",
1160  _ (
1161  "GNU Name System First-Come-First-Served name registration service"),
1162  options,
1163  &run_service,
1164  NULL)) ?
1165  0 :
1166  1);
1167 }
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
#define gettext_noop(String)
Definition: gettext.h:69
static void run_service(void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
Called after the service is up.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_mandatory(struct GNUNET_GETOPT_CommandLineOption opt)
Make the given option mandatory.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_string(char shortName, const char *name, const char *argumentHelp, const char *description, char **str)
Allow user to specify a string.
enum GNUNET_GenericReturnValue GNUNET_PROGRAM_run(int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls)
Run a standard GNUnet command startup sequence (initialize loggers and configuration,...
Definition: program.c:399
Definition of a command line option.

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

◆ 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

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