GNUnet  0.10.x
Data Structures | Macros | Enumerations | 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 dependency graph for gnunet-namestore-fcfsd.c:

Go to the source code of this file.

Data Structures

struct  Request
 Request we should make. More...
 
struct  ZoneinfoRequest
 Zoneinfo request. More...
 

Macros

#define METHOD_ERROR   "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\"><html lang=\"en\" xmlns=\"http://www.w3.org/1999/xhtml\"><html><head><title>Illegal request</title></head><body>Go away.</body></html>"
 Invalid method page. More...
 
#define MAIN_PAGE   "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\"><html lang=\"en\" xmlns=\"http://www.w3.org/1999/xhtml\"><html><head><title>GNUnet FCFS Authority Name Registration Service</title></head><body><form action=\"S\" method=\"post\">What is your desired domain name? (at most 63 lowercase characters, no dots allowed.) <input type=\"text\" name=\"domain\" /> <p> What is your public key? (Copy from gnunet-setup.) <input type=\"text\" name=\"pkey\" /> <input type=\"submit\" value=\"Next\" /><br/><a href=./Zoneinfo> List of all registered names </a></body></html>"
 Front page. More...
 
#define SUBMIT_PAGE   "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\"><html lang=\"en\" xmlns=\"http://www.w3.org/1999/xhtml\"><html><head><title>%s</title></head><body>%s</body></html>"
 Second page (/S) More...
 
#define ZONEINFO_PAGE   "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\"><html lang=\"en\" xmlns=\"http://www.w3.org/1999/xhtml\"><html><head><title>FCFS Zoneinfo</title></head><body><h1> FCFS Zoneinfo </h1><table border=\"1\"><th>name</th><th>PKEY</th>%s</table></body></html>"
 Fcfs zoneinfo page (/Zoneinfo) More...
 
#define FCFS_ZONEINFO_URL   "/Zoneinfo"
 
#define MIME_HTML   "text/html"
 Mime type for HTML pages. More...
 
#define COOKIE_NAME   "namestore-fcfsd"
 Name of our cookie. More...
 
#define DEFAULT_ZONEINFO_BUFSIZE   2048
 
#define UNSIGNED_MHD_LONG_LONG   unsigned MHD_LONG_LONG
 

Enumerations

enum  Phase {
  RP_START = 0, RP_LOOKUP, RP_PUT, RP_SUCCESS,
  RP_FAIL
}
 Phases a request goes through. More...
 

Functions

static void do_httpd (void *cls)
 Task run whenever HTTP server operations are pending. More...
 
static void run_httpd_now ()
 Schedule task to run MHD server now. More...
 
static void update_zoneinfo_page (void *cls)
 Create fresh version of zone information. More...
 
static void zone_iteration_error (void *cls)
 Function called on error in zone iteration. More...
 
static void zone_iteration_end (void *cls)
 Function called once the zone iteration is done. More...
 
static void iterate_cb (void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key, const char *name, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd)
 Process a record that was stored in the namestore, adding the information to the HTML. More...
 
static int serve_zoneinfo_page (struct MHD_Connection *connection)
 Handler that returns FCFS zoneinfo page. More...
 
static int serve_main_page (struct MHD_Connection *connection)
 Handler that returns a simple static HTTP page. More...
 
static int fill_s_reply (const char *info, struct Request *request, struct MHD_Connection *connection)
 Send the 'SUBMIT_PAGE'. More...
 
static int post_iterator (void *cls, enum MHD_ValueKind kind, const char *key, const char *filename, const char *content_type, const char *transfer_encoding, const char *data, uint64_t off, size_t size)
 Iterator over key-value pairs where the value maybe made available in increments and/or may not be zero-terminated. More...
 
static void put_continuation (void *cls, int32_t success, const char *emsg)
 Continuation called to notify client about result of the operation. More...
 
static void zone_to_name_error (void *cls)
 Function called if we had an error in zone-to-name mapping. More...
 
static void zone_to_name_cb (void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key, const char *name, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
 Test if a name mapping was found, if so, refuse. More...
 
static void lookup_it_error (void *cls)
 We encountered an error in the name lookup. More...
 
static void lookup_it_processor (void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zonekey, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
 We got a block back from the namestore. More...
 
static void lookup_it_finished (void *cls)
 
static int 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)
 Main MHD callback for handling requests. More...
 
static void request_completed_callback (void *cls, struct MHD_Connection *connection, void **con_cls, enum MHD_RequestTerminationCode toe)
 Callback called upon completion of a request. More...
 
static void run_httpd ()
 Schedule tasks to run MHD server. More...
 
static void do_shutdown (void *cls)
 Task run on shutdown. More...
 
static void identity_cb (void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *name)
 Method called to inform about the egos of this peer. More...
 
static void run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 Main function that will be run. More...
 
int main (int argc, char *const *argv)
 The main function for the fcfs daemon. More...
 

Variables

static struct MHD_Daemon * httpd
 MHD deamon reference. More...
 
static struct GNUNET_SCHEDULER_Taskhttpd_task
 Main HTTP task. More...
 
static struct GNUNET_NAMESTORE_Handlens
 Handle to the namestore. More...
 
static struct GNUNET_CRYPTO_EcdsaPrivateKey fcfs_zone_pkey
 Private key for the fcfsd zone. More...
 
static struct GNUNET_IDENTITY_Handleidentity
 Connection to identity service. More...
 
static struct MHD_Response * info_page
 Zoneinfo page we currently use. More...
 
static struct GNUNET_SCHEDULER_Taskuzp_task
 Task that runs update_zoneinfo_page peridicially. More...
 
static struct GNUNET_IDENTITY_Operationid_op
 Request for our ego. More...
 
static unsigned long long port
 Port we use for the HTTP server. More...
 
static char * zone
 Name of the zone we manage. More...
 

Detailed Description

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

Author
Christian Grothoff

TODO:

Definition in file gnunet-namestore-fcfsd.c.

Macro Definition Documentation

◆ METHOD_ERROR

#define METHOD_ERROR   "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\"><html lang=\"en\" xmlns=\"http://www.w3.org/1999/xhtml\"><html><head><title>Illegal request</title></head><body>Go away.</body></html>"

Invalid method page.

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

Referenced by create_response().

◆ MAIN_PAGE

#define MAIN_PAGE   "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\"><html lang=\"en\" xmlns=\"http://www.w3.org/1999/xhtml\"><html><head><title>GNUnet FCFS Authority Name Registration Service</title></head><body><form action=\"S\" method=\"post\">What is your desired domain name? (at most 63 lowercase characters, no dots allowed.) <input type=\"text\" name=\"domain\" /> <p> What is your public key? (Copy from gnunet-setup.) <input type=\"text\" name=\"pkey\" /> <input type=\"submit\" value=\"Next\" /><br/><a href=./Zoneinfo> List of all registered names </a></body></html>"

Front page.

(/)

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

Referenced by serve_main_page().

◆ SUBMIT_PAGE

#define SUBMIT_PAGE   "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\"><html lang=\"en\" xmlns=\"http://www.w3.org/1999/xhtml\"><html><head><title>%s</title></head><body>%s</body></html>"

Second page (/S)

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

Referenced by fill_s_reply().

◆ ZONEINFO_PAGE

#define ZONEINFO_PAGE   "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\"><html lang=\"en\" xmlns=\"http://www.w3.org/1999/xhtml\"><html><head><title>FCFS Zoneinfo</title></head><body><h1> FCFS Zoneinfo </h1><table border=\"1\"><th>name</th><th>PKEY</th>%s</table></body></html>"

Fcfs zoneinfo page (/Zoneinfo)

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

Referenced by zone_iteration_end().

◆ FCFS_ZONEINFO_URL

#define FCFS_ZONEINFO_URL   "/Zoneinfo"

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

Referenced by create_response().

◆ MIME_HTML

#define MIME_HTML   "text/html"

Mime type for HTML pages.

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

Referenced by fill_s_reply(), serve_main_page(), and zone_iteration_end().

◆ COOKIE_NAME

#define COOKIE_NAME   "namestore-fcfsd"

Name of our cookie.

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

◆ DEFAULT_ZONEINFO_BUFSIZE

#define DEFAULT_ZONEINFO_BUFSIZE   2048

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

Referenced by update_zoneinfo_page().

◆ UNSIGNED_MHD_LONG_LONG

#define UNSIGNED_MHD_LONG_LONG   unsigned MHD_LONG_LONG

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

Referenced by run_httpd().

Enumeration Type Documentation

◆ Phase

enum Phase

Phases a request goes through.

Enumerator
RP_START 

Start phase (parsing POST, checking).

RP_LOOKUP 

Lookup to see if the domain name is taken.

RP_PUT 

Storing of the record.

RP_SUCCESS 

We're done with success.

RP_FAIL 

Send failure message.

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

78  {
82  RP_START = 0,
83 
87  RP_LOOKUP,
88 
92  RP_PUT,
93 
97  RP_SUCCESS,
98 
102  RP_FAIL
103  };
Storing of the record.
Lookup to see if the domain name is taken.
Start phase (parsing POST, checking).
Send failure message.
We&#39;re done with success.

Function Documentation

◆ do_httpd()

static void do_httpd ( void *  cls)
static

Task run whenever HTTP server operations are pending.

Parameters
clsunused

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

References httpd, and run_httpd().

Referenced by run_httpd(), and run_httpd_now().

984 {
985  (void) cls;
986  httpd_task = NULL;
987  MHD_run (httpd);
988  run_httpd ();
989 }
static struct GNUNET_SCHEDULER_Task * httpd_task
Main HTTP task.
static void run_httpd()
Schedule tasks to run MHD server.
static struct MHD_Daemon * httpd
MHD deamon reference.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ run_httpd_now()

static void run_httpd_now ( )
static

Schedule task to run MHD server now.

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

References GNUNET_IDENTITY_Operation::cls, do_httpd(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), and update_zoneinfo_page().

Referenced by lookup_it_error(), lookup_it_finished(), put_continuation(), zone_to_name_cb(), and zone_to_name_error().

258 {
259  if (NULL != httpd_task)
260  {
262  httpd_task = NULL;
263  }
265 }
static void do_httpd(void *cls)
Task run whenever HTTP server operations are pending.
static struct GNUNET_SCHEDULER_Task * httpd_task
Main HTTP task.
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:1273
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
Here is the call graph for this function:
Here is the caller graph for this function:

◆ update_zoneinfo_page()

static void update_zoneinfo_page ( void *  cls)
static

Create fresh version of zone information.

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

References ZoneinfoRequest::buf_len, DEFAULT_ZONEINFO_BUFSIZE, fcfs_zone_pkey, GNUNET_malloc, GNUNET_NAMESTORE_zone_iteration_start(), GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_UNIT_MINUTES, iterate_cb(), ZoneinfoRequest::list_it, ZoneinfoRequest::write_offset, zone_iteration_end(), zone_iteration_error(), and ZoneinfoRequest::zoneinfo.

Referenced by run(), run_httpd_now(), and zone_iteration_error().

406 {
407  static struct ZoneinfoRequest zr;
408 
409  (void) cls;
412  NULL);
413  if (NULL != zr.list_it)
414  return;
415  zr.zoneinfo = GNUNET_malloc (DEFAULT_ZONEINFO_BUFSIZE);
416  zr.buf_len = DEFAULT_ZONEINFO_BUFSIZE;
417  zr.write_offset = 0;
421  &zr,
422  &iterate_cb,
423  &zr,
425  &zr);
426 }
struct GNUNET_NAMESTORE_ZoneIterator * GNUNET_NAMESTORE_zone_iteration_start(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *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)...
#define GNUNET_TIME_UNIT_MINUTES
One minute.
#define DEFAULT_ZONEINFO_BUFSIZE
static void iterate_cb(void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key, const char *name, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd)
Process a record that was stored in the namestore, adding the information to the HTML.
Zoneinfo request.
static struct GNUNET_CRYPTO_EcdsaPrivateKey fcfs_zone_pkey
Private key for the fcfsd zone.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1246
static void update_zoneinfo_page(void *cls)
Create fresh version of zone information.
static struct GNUNET_NAMESTORE_Handle * ns
Handle to the namestore.
static void zone_iteration_error(void *cls)
Function called on error in zone iteration.
static void zone_iteration_end(void *cls)
Function called once the zone iteration is done.
static struct GNUNET_SCHEDULER_Task * uzp_task
Task that runs update_zoneinfo_page peridicially.
#define GNUNET_malloc(size)
Wrapper around malloc.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ zone_iteration_error()

static void zone_iteration_error ( void *  cls)
static

Function called on error in zone iteration.

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

References GNUNET_free, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), ZoneinfoRequest::list_it, update_zoneinfo_page(), and ZoneinfoRequest::zoneinfo.

Referenced by update_zoneinfo_page().

280 {
281  struct ZoneinfoRequest *zr = cls;
282 
283  zr->list_it = NULL;
284  GNUNET_free (zr->zoneinfo);
287  NULL);
288 }
struct GNUNET_NAMESTORE_ZoneIterator * list_it
List iterator.
Zoneinfo request.
static void update_zoneinfo_page(void *cls)
Create fresh version of zone information.
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:1273
static struct GNUNET_SCHEDULER_Task * uzp_task
Task that runs update_zoneinfo_page peridicially.
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
Here is the call graph for this function:
Here is the caller graph for this function:

◆ zone_iteration_end()

static void zone_iteration_end ( void *  cls)
static

Function called once the zone iteration is done.

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

References GNUNET_asprintf(), GNUNET_free, info_page, ZoneinfoRequest::list_it, MIME_HTML, response, ZoneinfoRequest::zoneinfo, and ZONEINFO_PAGE.

Referenced by update_zoneinfo_page().

296 {
297  struct ZoneinfoRequest *zr = cls;
298  struct MHD_Response *response;
299  char* full_page;
300 
301  zr->list_it = NULL;
302 
303  /* return static form */
304  GNUNET_asprintf (&full_page,
306  zr->zoneinfo,
307  zr->zoneinfo);
308  response = MHD_create_response_from_buffer (strlen (full_page),
309  (void *) full_page,
310  MHD_RESPMEM_MUST_FREE);
311  MHD_add_response_header (response,
312  MHD_HTTP_HEADER_CONTENT_TYPE,
313  MIME_HTML);
314  MHD_destroy_response (info_page);
316  GNUNET_free (zr->zoneinfo);
317 }
struct GNUNET_NAMESTORE_ZoneIterator * list_it
List iterator.
Zoneinfo request.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
static struct MHD_Response * info_page
Zoneinfo page we currently use.
#define ZONEINFO_PAGE
Fcfs zoneinfo page (/Zoneinfo)
static struct MHD_Response * response
Our canonical response.
#define MIME_HTML
Mime type for HTML pages.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ iterate_cb()

static void iterate_cb ( void *  cls,
const struct GNUNET_CRYPTO_EcdsaPrivateKey zone_key,
const char *  name,
unsigned int  rd_len,
const struct GNUNET_GNSRECORD_Data rd 
)
static

Process a record that was stored in the namestore, adding the information to the HTML.

Parameters
clsclosure with the struct ZoneinfoRequest *
zone_keyprivate key of the zone; NULL on disconnect
namelabel of the records; NULL on disconnect
rd_lennumber of entries in rd array, 0 if label was deleted
rdarray of records with data to store

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

References ZoneinfoRequest::buf_len, GNUNET_GNSRECORD_Data::data, GNUNET_GNSRECORD_Data::data_size, GNUNET_break, GNUNET_free, GNUNET_GNSRECORD_TYPE_PKEY, GNUNET_GNSRECORD_value_to_string(), GNUNET_malloc, GNUNET_memcpy, GNUNET_NAMESTORE_zone_iterator_next(), ZoneinfoRequest::list_it, pkey, GNUNET_GNSRECORD_Data::record_type, ZoneinfoRequest::write_offset, and ZoneinfoRequest::zoneinfo.

Referenced by update_zoneinfo_page().

336 {
337  struct ZoneinfoRequest *zr = cls;
338  size_t bytes_free;
339  char* pkey;
340  char* new_buf;
341 
342  (void) zone_key;
343  if (1 != rd_len)
344  {
346  1);
347  return;
348  }
349 
351  {
353  1);
354  return;
355  }
356 
357  bytes_free = zr->buf_len - zr->write_offset;
359  rd->data,
360  rd->data_size);
361  if (NULL == pkey)
362  {
363  GNUNET_break (0);
365  1);
366  return;
367  }
368  if (bytes_free < (strlen (name) + strlen (pkey) + 40))
369  {
370  new_buf = GNUNET_malloc (zr->buf_len * 2);
371  GNUNET_memcpy (new_buf, zr->zoneinfo, zr->write_offset);
372  GNUNET_free (zr->zoneinfo);
373  zr->zoneinfo = new_buf;
374  zr->buf_len *= 2;
375  }
376  sprintf (zr->zoneinfo + zr->write_offset,
377  "<tr><td>%s</td><td>%s</td></tr>",
378  name,
379  pkey);
380  zr->write_offset = strlen (zr->zoneinfo);
382  1);
383  GNUNET_free (pkey);
384 }
struct GNUNET_NAMESTORE_ZoneIterator * list_it
List iterator.
static char * pkey
Public key of the zone to look in, in ASCII.
size_t data_size
Number of bytes in data.
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...
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Zoneinfo request.
#define GNUNET_memcpy(dst, src, n)
const void * data
Binary value stored in the DNS record.
#define GNUNET_GNSRECORD_TYPE_PKEY
Record type for GNS zone transfer ("PKEY").
const char * name
size_t buf_len
Buffer length.
uint32_t record_type
Type of the GNS/DNS record.
size_t write_offset
Buffer write offset.
char * GNUNET_GNSRECORD_value_to_string(uint32_t type, const void *data, size_t data_size)
Convert the &#39;value&#39; of a record to a string.
Definition: gnsrecord.c:143
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ serve_zoneinfo_page()

static int serve_zoneinfo_page ( struct MHD_Connection *  connection)
static

Handler that returns FCFS zoneinfo page.

Parameters
connectionconnection to use

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

References info_page.

Referenced by create_response().

394 {
395  return MHD_queue_response (connection,
396  MHD_HTTP_OK,
397  info_page);
398 }
static struct MHD_Response * info_page
Zoneinfo page we currently use.
Here is the caller graph for this function:

◆ serve_main_page()

static int serve_main_page ( struct MHD_Connection *  connection)
static

Handler that returns a simple static HTTP page.

Parameters
connectionconnection to use
Returns
#MHD_YES on success

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

References MAIN_PAGE, MIME_HTML, response, and ret.

Referenced by create_response().

437 {
438  int ret;
439  struct MHD_Response *response;
440 
441  /* return static form */
442  response = MHD_create_response_from_buffer (strlen (MAIN_PAGE),
443  (void *) MAIN_PAGE,
444  MHD_RESPMEM_PERSISTENT);
445  MHD_add_response_header (response,
446  MHD_HTTP_HEADER_CONTENT_TYPE,
447  MIME_HTML);
448  ret = MHD_queue_response (connection,
449  MHD_HTTP_OK,
450  response);
451  MHD_destroy_response (response);
452  return ret;
453 }
static int ret
Final status code.
Definition: gnunet-arm.c:89
#define MAIN_PAGE
Front page.
static struct MHD_Response * response
Our canonical response.
#define MIME_HTML
Mime type for HTML pages.
Here is the caller graph for this function:

◆ fill_s_reply()

static int fill_s_reply ( const char *  info,
struct Request request,
struct MHD_Connection *  connection 
)
static

Send the 'SUBMIT_PAGE'.

Parameters
infoinformation string to send to the user
requestrequest information
connectionconnection to use

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

References GNUNET_asprintf(), MIME_HTML, response, ret, and SUBMIT_PAGE.

Referenced by create_response().

467 {
468  int ret;
469  char *reply;
470  struct MHD_Response *response;
471 
472  (void) request;
473  GNUNET_asprintf (&reply,
474  SUBMIT_PAGE,
475  info,
476  info);
477  /* return static form */
478  response = MHD_create_response_from_buffer (strlen (reply),
479  (void *) reply,
480  MHD_RESPMEM_MUST_FREE);
481  MHD_add_response_header (response,
482  MHD_HTTP_HEADER_CONTENT_TYPE,
483  MIME_HTML);
484  ret = MHD_queue_response (connection,
485  MHD_HTTP_OK,
486  response);
487  MHD_destroy_response (response);
488  return ret;
489 }
#define SUBMIT_PAGE
Second page (/S)
static int ret
Final status code.
Definition: gnunet-arm.c:89
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
static struct MHD_Response * response
Our canonical response.
#define MIME_HTML
Mime type for HTML pages.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ post_iterator()

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

Iterator over key-value pairs where the value maybe made available in increments and/or may not be zero-terminated.

Used for processing POST data.

Parameters
clsuser-specified closure
kindtype of the value
key0-terminated key for the value
filenamename of the uploaded file, NULL if not known
content_typemime-type of the data, NULL if not known
transfer_encodingencoding of the data, NULL if not known
datapointer to size bytes of data at the specified offset
offoffset of data in the overall value
sizenumber of bytes in data available
Returns
MHD_YES to continue iterating, MHD_NO to abort the iteration

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

References _, Request::domain_name, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_memcpy, and Request::public_key.

Referenced by create_response().

521 {
522  struct Request *request = cls;
523 
524  (void) kind;
525  (void) filename;
526  (void) content_type;
527  (void) transfer_encoding;
528  if (0 == strcmp ("domain", key))
529  {
530  if (size + off >= sizeof(request->domain_name))
531  size = sizeof (request->domain_name) - off - 1;
532  GNUNET_memcpy (&request->domain_name[off],
533  data,
534  size);
535  request->domain_name[size+off] = '\0';
536  return MHD_YES;
537  }
538  if (0 == strcmp ("pkey", key))
539  {
540  if (size + off >= sizeof(request->public_key))
541  size = sizeof (request->public_key) - off - 1;
542  GNUNET_memcpy (&request->public_key[off],
543  data,
544  size);
545  request->public_key[size+off] = '\0';
546  return MHD_YES;
547  }
549  _("Unsupported form value `%s'\n"),
550  key);
551  return MHD_YES;
552 }
char public_key[128]
Public key submitted via form.
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
#define GNUNET_memcpy(dst, src, n)
static char * filename
char domain_name[64]
Domain name submitted via form.
struct GNUNET_HashCode key
The key used in the DHT.
static unsigned int size
Size of the "table".
Definition: peer.c:67
Request we should make.
#define GNUNET_log(kind,...)
uint32_t data
The data value.
Here is the caller graph for this function:

◆ put_continuation()

static void put_continuation ( void *  cls,
int32_t  success,
const char *  emsg 
)
static

Continuation called to notify client about result of the operation.

Parameters
clsclosure
successGNUNET_SYSERR on failure (including timeout/queue drop/failure to validate) GNUNET_NO if content was already there GNUNET_YES (or other positive value) on success
emsgNULL on success, otherwise an error message

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

References _, Request::con, Request::domain_name, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, Request::phase, Request::qe, RP_FAIL, RP_SUCCESS, and run_httpd_now().

Referenced by zone_to_name_cb().

569 {
570  struct Request *request = cls;
571 
572  request->qe = NULL;
573  if (0 >= success)
574  {
576  _("Failed to create record for domain `%s': %s\n"),
577  request->domain_name,
578  emsg);
579  request->phase = RP_FAIL;
580  }
581  else
582  request->phase = RP_SUCCESS;
583  MHD_resume_connection (request->con);
584  run_httpd_now ();
585 }
struct MHD_Connection * con
MHD Connection.
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
char domain_name[64]
Domain name submitted via form.
static void run_httpd_now()
Schedule task to run MHD server now.
Send failure message.
struct GNUNET_NAMESTORE_QueueEntry * qe
Active request with the namestore.
Request we should make.
#define GNUNET_log(kind,...)
enum Phase phase
Current processing phase.
We&#39;re done with success.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ zone_to_name_error()

static void zone_to_name_error ( void *  cls)
static

Function called if we had an error in zone-to-name mapping.

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

References _, Request::con, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, Request::phase, RP_FAIL, and run_httpd_now().

Referenced by lookup_it_finished().

593 {
594  struct Request *request = cls;
595 
597  _("Error when mapping zone to name\n"));
598  request->phase = RP_FAIL;
599  MHD_resume_connection (request->con);
600  run_httpd_now ();
601 }
struct MHD_Connection * con
MHD Connection.
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
static void run_httpd_now()
Schedule task to run MHD server now.
Send failure message.
Request we should make.
#define GNUNET_log(kind,...)
enum Phase phase
Current processing phase.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ zone_to_name_cb()

static void zone_to_name_cb ( void *  cls,
const struct GNUNET_CRYPTO_EcdsaPrivateKey zone_key,
const char *  name,
unsigned int  rd_count,
const struct GNUNET_GNSRECORD_Data rd 
)
static

Test if a name mapping was found, if so, refuse.

If not, initiate storing of the record.

Parameters
clsclosure
zone_keypublic key of the zone
namename that is being mapped (at most 255 characters long)
rd_countnumber of entries in rd array
rdarray of records with data to store

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

References _, Request::con, GNUNET_GNSRECORD_Data::data, GNUNET_GNSRECORD_Data::data_size, Request::domain_name, GNUNET_GNSRECORD_Data::expiration_time, fcfs_zone_pkey, GNUNET_GNSRECORD_Data::flags, GNUNET_ERROR_TYPE_INFO, GNUNET_GNSRECORD_RF_NONE, GNUNET_GNSRECORD_TYPE_PKEY, GNUNET_log, GNUNET_NAMESTORE_records_store(), Request::phase, Request::pub, put_continuation(), Request::qe, GNUNET_GNSRECORD_Data::record_type, RP_FAIL, and run_httpd_now().

Referenced by lookup_it_finished().

619 {
620  struct Request *request = cls;
621  struct GNUNET_GNSRECORD_Data r;
622 
623  (void) rd;
624  (void) zone_key;
625  request->qe = NULL;
626  if (0 != rd_count)
627  {
629  _("Found existing name `%s' for the given key\n"),
630  name);
631  request->phase = RP_FAIL;
632  MHD_resume_connection (request->con);
633  run_httpd_now ();
634  return;
635  }
636  r.data = &request->pub;
637  r.data_size = sizeof (request->pub);
638  r.expiration_time = UINT64_MAX;
639  r.record_type = GNUNET_GNSRECORD_TYPE_PKEY;
640  r.flags = GNUNET_GNSRECORD_RF_NONE;
643  request->domain_name,
644  1, &r,
646  request);
647 }
static void put_continuation(void *cls, int32_t success, const char *emsg)
Continuation called to notify client about result of the operation.
struct MHD_Connection * con
MHD Connection.
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
struct GNUNET_NAMESTORE_QueueEntry * GNUNET_NAMESTORE_records_store(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *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.
static struct GNUNET_CRYPTO_EcdsaPrivateKey fcfs_zone_pkey
Private key for the fcfsd zone.
#define GNUNET_GNSRECORD_TYPE_PKEY
Record type for GNS zone transfer ("PKEY").
char domain_name[64]
Domain name submitted via form.
struct GNUNET_CRYPTO_EcdsaPublicKey pub
static struct GNUNET_NAMESTORE_Handle * ns
Handle to the namestore.
static void run_httpd_now()
Schedule task to run MHD server now.
Send failure message.
const char * name
struct GNUNET_NAMESTORE_QueueEntry * qe
Active request with the namestore.
Request we should make.
#define GNUNET_log(kind,...)
enum Phase phase
Current processing phase.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ lookup_it_error()

static void lookup_it_error ( void *  cls)
static

We encountered an error in the name lookup.

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

References Request::con, Request::phase, Request::qe, RP_FAIL, and run_httpd_now().

Referenced by create_response().

655 {
656  struct Request *request = cls;
657  MHD_resume_connection (request->con);
658  request->qe = NULL;
659  request->phase = RP_FAIL;
660  run_httpd_now ();
661 }
struct MHD_Connection * con
MHD Connection.
static void run_httpd_now()
Schedule task to run MHD server now.
Send failure message.
struct GNUNET_NAMESTORE_QueueEntry * qe
Active request with the namestore.
Request we should make.
enum Phase phase
Current processing phase.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ lookup_it_processor()

static void lookup_it_processor ( void *  cls,
const struct GNUNET_CRYPTO_EcdsaPrivateKey zonekey,
const char *  label,
unsigned int  rd_count,
const struct GNUNET_GNSRECORD_Data rd 
)
static

We got a block back from the namestore.

Decrypt it and continue to process the result.

Parameters
clsthe 'struct Request' we are processing
zonekeyprivate key of the zone; NULL on disconnect
labellabel of the records; NULL on disconnect
rd_countnumber of entries in rd array, 0 if label was deleted
rdarray of records with data to store

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

References _, Request::domain_name, GNUNET_break, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NAMESTORE_zone_iterator_next(), Request::lookup_it, Request::phase, and RP_FAIL.

Referenced by create_response().

680 {
681  struct Request *request = cls;
682 
683  (void) label;
684  (void) rd;
685  (void) zonekey;
686  if (0 == strcmp (label, request->domain_name)) {
687  GNUNET_break (0 != rd_count);
689  _("Found %u existing records for domain `%s'\n"),
690  rd_count,
691  request->domain_name);
692  request->phase = RP_FAIL;
693  }
695 }
struct GNUNET_NAMESTORE_ZoneIterator * lookup_it
Active lookup iterator TODO: deprecate or fix lookup by label and use above member.
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...
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
char domain_name[64]
Domain name submitted via form.
Send failure message.
Request we should make.
#define GNUNET_log(kind,...)
enum Phase phase
Current processing phase.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ lookup_it_finished()

static void lookup_it_finished ( void *  cls)
static

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

References Request::con, fcfs_zone_pkey, GNUNET_break, GNUNET_CRYPTO_ecdsa_public_key_from_string(), GNUNET_NAMESTORE_zone_to_name(), GNUNET_OK, Request::phase, Request::pub, Request::public_key, Request::qe, RP_FAIL, run_httpd_now(), zone_to_name_cb(), and zone_to_name_error().

Referenced by create_response().

699 {
700  struct Request *request = cls;
701 
702  if (RP_FAIL == request->phase)
703  {
704  MHD_resume_connection (request->con);
705  run_httpd_now ();
706  return;
707  }
708  if (GNUNET_OK !=
710  strlen (request->public_key),
711  &request->pub))
712  {
713  GNUNET_break (0);
714  request->phase = RP_FAIL;
715  MHD_resume_connection (request->con);
716  run_httpd_now ();
717  return;
718  }
719  request->qe = GNUNET_NAMESTORE_zone_to_name (ns,
721  &request->pub,
723  request,
725  request);
726 }
char public_key[128]
Public key submitted via form.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct MHD_Connection * con
MHD Connection.
static struct GNUNET_CRYPTO_EcdsaPrivateKey fcfs_zone_pkey
Private key for the fcfsd zone.
static void zone_to_name_cb(void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key, const char *name, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Test if a name mapping was found, if so, refuse.
struct GNUNET_CRYPTO_EcdsaPublicKey pub
static struct GNUNET_NAMESTORE_Handle * ns
Handle to the namestore.
static void run_httpd_now()
Schedule task to run MHD server now.
Send failure message.
struct GNUNET_NAMESTORE_QueueEntry * qe
Active request with the namestore.
Request we should make.
int GNUNET_CRYPTO_ecdsa_public_key_from_string(const char *enc, size_t enclen, struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Convert a string representing a public key to a public key.
Definition: crypto_ecc.c:468
struct GNUNET_NAMESTORE_QueueEntry * GNUNET_NAMESTORE_zone_to_name(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, const struct GNUNET_CRYPTO_EcdsaPublicKey *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.
enum Phase phase
Current processing phase.
static void zone_to_name_error(void *cls)
Function called if we had an error in zone-to-name mapping.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ create_response()

static int 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

Main MHD callback for handling requests.

Parameters
clsunused
connectionMHD connection handle
urlthe requested url
methodthe HTTP method used ("GET", "PUT", etc.)
versionthe HTTP version string (i.e. "HTTP/1.1")
upload_datathe data being uploaded (excluding HEADERS, for a POST that fits into memory and that is encoded with a supported encoding, the POST data will NOT be given in upload_data and is instead available as part of MHD_get_connection_values; very large POST data will be made available incrementally in upload_data)
upload_data_sizeset initially to the size of the upload_data provided; the method must update this value to the number of bytes NOT processed;
ptrpointer to location where we store the 'struct Request'
Returns
#MHD_YES if the connection was handled successfully, #MHD_NO if the socket must be closed due to a serious error while handling the request

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

References _, Request::con, Request::domain_name, fcfs_zone_pkey, FCFS_ZONEINFO_URL, fill_s_reply(), GNUNET_break, GNUNET_CRYPTO_ecdsa_public_key_from_string(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NAMESTORE_zone_iteration_start(), GNUNET_new, GNUNET_OK, Request::lookup_it, lookup_it_error(), lookup_it_finished(), lookup_it_processor(), METHOD_ERROR, Request::phase, post_iterator(), Request::pp, Request::public_key, request, response, ret, RP_FAIL, RP_LOOKUP, RP_PUT, RP_START, RP_SUCCESS, serve_main_page(), and serve_zoneinfo_page().

Referenced by identity_cb().

760 {
761  struct MHD_Response *response;
762  struct Request *request;
764  int ret;
765 
766  (void) cls;
767  (void) version;
768  if ( (0 == strcmp (method, MHD_HTTP_METHOD_GET)) ||
769  (0 == strcmp (method, MHD_HTTP_METHOD_HEAD)) )
770  {
771  if (0 == strcmp (url, FCFS_ZONEINFO_URL))
772  ret = serve_zoneinfo_page (connection);
773  else
774  ret = serve_main_page (connection);
775  if (ret != MHD_YES)
777  _("Failed to create page for `%s'\n"),
778  url);
779  return ret;
780  }
781  if (0 == strcmp (method, MHD_HTTP_METHOD_POST))
782  {
783  request = *ptr;
784  if (NULL == request)
785  {
786  request = GNUNET_new (struct Request);
787  request->con = connection;
788  *ptr = request;
789  request->pp = MHD_create_post_processor (connection,
790  1024,
791  &post_iterator,
792  request);
793  if (NULL == request->pp)
794  {
796  _("Failed to setup post processor for `%s'\n"),
797  url);
798  return MHD_NO; /* internal error */
799  }
800  return MHD_YES;
801  }
802  if (NULL != request->pp)
803  {
804  /* evaluate POST data */
805  MHD_post_process (request->pp,
806  upload_data,
807  *upload_data_size);
808  if (0 != *upload_data_size)
809  {
810  *upload_data_size = 0;
811  return MHD_YES;
812  }
813  /* done with POST data, serve response */
814  MHD_destroy_post_processor (request->pp);
815  request->pp = NULL;
816  }
817  if (GNUNET_OK !=
819  strlen (request->public_key),
820  &pub))
821  {
822  /* parse error */
823  return fill_s_reply ("Failed to parse given public key",
824  request, connection);
825  }
826  switch (request->phase)
827  {
828  case RP_START:
829  if (NULL != strchr (request->domain_name, (int) '.'))
830  {
832  _("Domain name must not contain `.'\n"));
833  request->phase = RP_FAIL;
834  return fill_s_reply ("Domain name must not contain `.', sorry.",
835  request,
836  connection);
837  }
838  if (NULL != strchr (request->domain_name, (int) '+'))
839  {
841  _("Domain name must not contain `+'\n"));
842  request->phase = RP_FAIL;
843  return fill_s_reply ("Domain name must not contain `+', sorry.",
844  request, connection);
845  }
846  request->phase = RP_LOOKUP;
847  MHD_suspend_connection (request->con);
848  request->lookup_it
852  request,
854  request,
856  request);
857  break;
858  case RP_LOOKUP:
859  break;
860  case RP_PUT:
861  break;
862  case RP_FAIL:
863  return fill_s_reply ("Request failed, sorry.",
864  request, connection);
865  case RP_SUCCESS:
866  return fill_s_reply ("Success.",
867  request, connection);
868  default:
869  GNUNET_break (0);
870  return MHD_NO;
871  }
872  return MHD_YES; /* will have a reply later... */
873  }
874  /* unsupported HTTP method */
875  response = MHD_create_response_from_buffer (strlen (METHOD_ERROR),
876  (void *) METHOD_ERROR,
877  MHD_RESPMEM_PERSISTENT);
878  ret = MHD_queue_response (connection,
879  MHD_HTTP_NOT_ACCEPTABLE,
880  response);
881  MHD_destroy_response (response);
882  return ret;
883 }
static int fill_s_reply(const char *info, struct Request *request, struct MHD_Connection *connection)
Send the &#39;SUBMIT_PAGE&#39;.
static struct GNUNET_VPN_RedirectionRequest * request
Opaque redirection request handle.
Definition: gnunet-vpn.c:41
struct GNUNET_NAMESTORE_ZoneIterator * lookup_it
Active lookup iterator TODO: deprecate or fix lookup by label and use above member.
struct GNUNET_NAMESTORE_ZoneIterator * GNUNET_NAMESTORE_zone_iteration_start(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *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)...
char public_key[128]
Public key submitted via form.
Storing of the record.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static int ret
Final status code.
Definition: gnunet-arm.c:89
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct MHD_Connection * con
MHD Connection.
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
#define METHOD_ERROR
Invalid method page.
static struct GNUNET_CRYPTO_EcdsaPrivateKey fcfs_zone_pkey
Private key for the fcfsd zone.
static void lookup_it_processor(void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zonekey, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
We got a block back from the namestore.
char domain_name[64]
Domain name submitted via form.
Lookup to see if the domain name is taken.
static struct GNUNET_NAMESTORE_Handle * ns
Handle to the namestore.
static void lookup_it_finished(void *cls)
Start phase (parsing POST, checking).
Send failure message.
static int serve_zoneinfo_page(struct MHD_Connection *connection)
Handler that returns FCFS zoneinfo page.
Request we should make.
static void lookup_it_error(void *cls)
We encountered an error in the name lookup.
int GNUNET_CRYPTO_ecdsa_public_key_from_string(const char *enc, size_t enclen, struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Convert a string representing a public key to a public key.
Definition: crypto_ecc.c:468
static struct GNUNET_CRYPTO_EddsaPublicKey pub
Definition: gnunet-scrypt.c:39
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
#define GNUNET_log(kind,...)
static struct MHD_Response * response
Our canonical response.
enum Phase phase
Current processing phase.
#define FCFS_ZONEINFO_URL
static int serve_main_page(struct MHD_Connection *connection)
Handler that returns a simple static HTTP page.
static int post_iterator(void *cls, enum MHD_ValueKind kind, const char *key, const char *filename, const char *content_type, const char *transfer_encoding, const char *data, uint64_t off, size_t size)
Iterator over key-value pairs where the value maybe made available in increments and/or may not be ze...
We&#39;re done with success.
struct MHD_PostProcessor * pp
Associated session.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ request_completed_callback()

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

Callback called upon completion of a request.

Decrements session reference counter.

Parameters
clsnot used
connectionconnection that completed
con_clssession handle
toestatus code

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

References GNUNET_free, GNUNET_NAMESTORE_cancel(), Request::pp, and Request::qe.

Referenced by identity_cb().

900 {
901  struct Request *request = *con_cls;
902 
903  (void) cls;
904  (void) connection;
905  (void) toe;
906  if (NULL == request)
907  return;
908  if (NULL != request->pp)
909  MHD_destroy_post_processor (request->pp);
910  if (NULL != request->qe)
911  GNUNET_NAMESTORE_cancel (request->qe);
912  GNUNET_free (request);
913 }
void GNUNET_NAMESTORE_cancel(struct GNUNET_NAMESTORE_QueueEntry *qe)
Cancel a namestore operation.
struct GNUNET_NAMESTORE_QueueEntry * qe
Active request with the namestore.
Request we should make.
#define GNUNET_free(ptr)
Wrapper around free.
struct MHD_PostProcessor * pp
Associated session.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ run_httpd()

static void run_httpd ( )
static

Schedule tasks to run MHD server.

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

References do_httpd(), GNUNET_assert, GNUNET_NETWORK_fdset_copy_native(), GNUNET_NETWORK_fdset_create(), GNUNET_NETWORK_fdset_destroy(), GNUNET_SCHEDULER_add_select(), GNUNET_SCHEDULER_PRIORITY_HIGH, GNUNET_TIME_UNIT_FOREVER_REL, httpd, GNUNET_TIME_Relative::rel_value_us, Request::rs, timeout, and UNSIGNED_MHD_LONG_LONG.

Referenced by do_httpd(), and identity_cb().

924 {
925  fd_set rs;
926  fd_set ws;
927  fd_set es;
928  struct GNUNET_NETWORK_FDSet *wrs;
929  struct GNUNET_NETWORK_FDSet *wws;
930  struct GNUNET_NETWORK_FDSet *wes;
931  int max;
932  int haveto;
934  struct GNUNET_TIME_Relative tv;
935 
936  FD_ZERO (&rs);
937  FD_ZERO (&ws);
938  FD_ZERO (&es);
942  max = -1;
943  GNUNET_assert (MHD_YES ==
944  MHD_get_fdset (httpd,
945  &rs,
946  &ws,
947  &es,
948  &max));
949  haveto = MHD_get_timeout (httpd,
950  &timeout);
951  if (haveto == MHD_YES)
952  tv.rel_value_us = (uint64_t) timeout * 1000LL;
953  else
956  &rs,
957  max + 1);
959  &ws,
960  max + 1);
962  &es,
963  max + 1);
964  httpd_task =
966  tv,
967  wrs,
968  wws,
969  &do_httpd,
970  NULL);
974 }
Run with high priority (important requests).
static void do_httpd(void *cls)
Task run whenever HTTP server operations are pending.
static struct GNUNET_SCHEDULER_Task * httpd_task
Main HTTP task.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
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:1308
void GNUNET_NETWORK_fdset_destroy(struct GNUNET_NETWORK_FDSet *fds)
Releases the associated memory of an fd set.
Definition: network.c:1554
struct GNUNET_NETWORK_FDSet * GNUNET_NETWORK_fdset_create(void)
Creates an fd set.
Definition: network.c:1538
static struct GNUNET_TIME_Relative timeout
User defined timestamp for completing operations.
Definition: gnunet-arm.c:114
#define UNSIGNED_MHD_LONG_LONG
collection of IO descriptors
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:1829
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
struct GNUNET_DNSSTUB_RequestSocket * rs
Socket used to make the request, NULL if not active.
static struct MHD_Daemon * httpd
MHD deamon reference.
Time for relative time used by GNUnet, in microseconds.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ do_shutdown()

static void do_shutdown ( void *  cls)
static

Task run on shutdown.

Cleans up everything.

Parameters
clsunused

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

References GNUNET_IDENTITY_cancel(), GNUNET_IDENTITY_disconnect(), GNUNET_NAMESTORE_disconnect(), GNUNET_SCHEDULER_cancel(), and httpd.

Referenced by run().

999 {
1000  (void) cls;
1001  if (NULL != httpd_task)
1002  {
1004  httpd_task = NULL;
1005  }
1006  if (NULL != uzp_task)
1007  {
1009  uzp_task = NULL;
1010  }
1011  if (NULL != ns)
1012  {
1014  ns = NULL;
1015  }
1016  if (NULL != httpd)
1017  {
1018  MHD_stop_daemon (httpd);
1019  httpd = NULL;
1020  }
1021  if (NULL != id_op)
1022  {
1024  id_op = NULL;
1025  }
1026  if (NULL != identity)
1027  {
1029  identity = NULL;
1030  }
1031 }
void GNUNET_IDENTITY_cancel(struct GNUNET_IDENTITY_Operation *op)
Cancel an identity operation.
Definition: identity_api.c:819
static struct GNUNET_SCHEDULER_Task * httpd_task
Main HTTP task.
static struct GNUNET_IDENTITY_Handle * identity
Connection to identity service.
void GNUNET_NAMESTORE_disconnect(struct GNUNET_NAMESTORE_Handle *h)
Disconnect from the namestore service (and free associated resources).
void GNUNET_IDENTITY_disconnect(struct GNUNET_IDENTITY_Handle *h)
Disconnect from identity service.
Definition: identity_api.c:838
static struct GNUNET_NAMESTORE_Handle * ns
Handle to the namestore.
static struct GNUNET_SCHEDULER_Task * uzp_task
Task that runs update_zoneinfo_page peridicially.
static struct MHD_Daemon * httpd
MHD deamon reference.
static struct GNUNET_IDENTITY_Operation * id_op
Request for our ego.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
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

Method called to inform about the egos of this peer.

When used with GNUNET_IDENTITY_create or GNUNET_IDENTITY_get, this function is only called ONCE, and 'NULL' being passed in ego does indicate an error (i.e. name is taken or no default value is known). If ego is non-NULL and if '*ctx' is set in those callbacks, the value WILL be passed to a subsequent call to the identity callback of GNUNET_IDENTITY_connect (if that one was not NULL).

Parameters
clsclosure, NULL
egoego handle
ctxcontext for application to store data for this ego (during the lifetime of this process, initially NULL)
namename assigned by the user for this ego, NULL if the user just deleted the ego and it must thus no longer be used

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

References _, create_response(), fcfs_zone_pkey, GNUNET_ERROR_TYPE_ERROR, GNUNET_IDENTITY_ego_get_private_key(), GNUNET_log, GNUNET_SCHEDULER_shutdown(), httpd, options, port, request_completed_callback(), run_httpd(), and Request::zone.

Referenced by run().

1058 {
1059  int options;
1060 
1061  (void) cls;
1062  (void) ctx;
1063  if (NULL == name)
1064  return;
1065  if (0 != strcmp (name,
1066  zone))
1067  return;
1068  if (NULL == ego)
1069  {
1071  _("No ego configured for `fcfsd` subsystem\n"));
1073  return;
1074  }
1076 
1077  options = MHD_USE_DUAL_STACK | MHD_USE_DEBUG | MHD_ALLOW_SUSPEND_RESUME;
1078  do
1079  {
1080  httpd = MHD_start_daemon (options,
1081  (uint16_t) port,
1082  NULL, NULL,
1083  &create_response, NULL,
1084  MHD_OPTION_CONNECTION_LIMIT, (unsigned int) 128,
1085  MHD_OPTION_PER_IP_CONNECTION_LIMIT, (unsigned int) 1,
1086  MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 16,
1087  MHD_OPTION_CONNECTION_MEMORY_LIMIT, (size_t) (4 * 1024),
1088  MHD_OPTION_NOTIFY_COMPLETED, &request_completed_callback, NULL,
1089  MHD_OPTION_END);
1090  if (MHD_USE_DEBUG == options)
1091  break;
1092  options = MHD_USE_DEBUG;
1093  }
1094  while (NULL == httpd);
1095  if (NULL == httpd)
1096  {
1097 
1099  _("Failed to start HTTP server\n"));
1101  return;
1102  }
1103  run_httpd ();
1104 }
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
const struct GNUNET_CRYPTO_EcdsaPrivateKey * GNUNET_IDENTITY_ego_get_private_key(const struct GNUNET_IDENTITY_Ego *ego)
Obtain the ECC key associated with a ego.
Definition: identity_api.c:556
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:524
static struct GNUNET_DNSSTUB_Context * ctx
Context for DNS resolution.
static int 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)
Main MHD callback for handling requests.
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
static char * zone
Name of the zone we manage.
static struct GNUNET_CRYPTO_EcdsaPrivateKey fcfs_zone_pkey
Private key for the fcfsd zone.
static void request_completed_callback(void *cls, struct MHD_Connection *connection, void **con_cls, enum MHD_RequestTerminationCode toe)
Callback called upon completion of a request.
const char * name
#define GNUNET_log(kind,...)
static void run_httpd()
Schedule tasks to run MHD server.
static struct MHD_Daemon * httpd
MHD deamon reference.
static unsigned long long port
Port we use for the HTTP server.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ run()

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

Main function that will be run.

Parameters
clsclosure
argsremaining command-line arguments
cfgfilename of the configuration file used (for saving, can be NULL!)
cfgconfiguration

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

References _, do_shutdown(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_ERROR_TYPE_ERROR, GNUNET_IDENTITY_connect(), GNUNET_log, GNUNET_log_config_missing(), GNUNET_NAMESTORE_connect(), GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_shutdown(), identity_cb(), port, and update_zoneinfo_page().

Referenced by main().

1120 {
1121  (void) cls;
1122  (void) args;
1123  (void) cfgfile;
1124  if (GNUNET_OK !=
1126  "fcfsd",
1127  "HTTPPORT",
1128  &port))
1129  {
1131  "fcfsd", "HTTPPORT");
1132  return;
1133  }
1134  ns = GNUNET_NAMESTORE_connect (cfg);
1135  if (NULL == ns)
1136  {
1138  _("Failed to connect to namestore\n"));
1139  return;
1140  }
1142  &identity_cb,
1143  NULL);
1144  if (NULL == identity)
1145  {
1147  _("Failed to connect to identity\n"));
1148  return;
1149  }
1151  NULL);
1153  NULL);
1154 }
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:528
int 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.
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, or when GNUNET_SCHEDULER_shutdown() is being invoked.
Definition: scheduler.c:1293
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
static struct GNUNET_IDENTITY_Handle * identity
Connection to identity service.
static void do_shutdown(void *cls)
Task run on shutdown.
static void identity_cb(void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *name)
Method called to inform about the egos of this peer.
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
static void update_zoneinfo_page(void *cls)
Create fresh version of zone information.
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:1273
static struct GNUNET_NAMESTORE_Handle * ns
Handle to the namestore.
struct GNUNET_NAMESTORE_Handle * GNUNET_NAMESTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the namestore service.
static struct GNUNET_SCHEDULER_Task * uzp_task
Task that runs update_zoneinfo_page peridicially.
#define GNUNET_log(kind,...)
static unsigned long long port
Port we use for the HTTP server.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ main()

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

The main function for the fcfs daemon.

Parameters
argcnumber of arguments from the command line
argvcommand line arguments
Returns
0 ok, 1 on error

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

References _, fcfs_zone_pkey, gettext_noop, GNUNET_CRYPTO_ecdsa_key_clear(), GNUNET_free, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_mandatory(), GNUNET_GETOPT_option_string(), GNUNET_log_setup(), GNUNET_OK, GNUNET_PROGRAM_run(), GNUNET_STRINGS_get_utf8_args(), ret, run(), and Request::zone.

1167 {
1171  "zone",
1172  "EGO",
1173  gettext_noop ("name of the zone that is to be managed by FCFSD"),
1174  &zone)),
1176  };
1177  int ret;
1178 
1179  if (GNUNET_OK !=
1180  GNUNET_STRINGS_get_utf8_args (argc, argv,
1181  &argc, &argv))
1182  return 2;
1183 
1184  GNUNET_log_setup ("fcfsd",
1185  "WARNING",
1186  NULL);
1187  ret =
1188  (GNUNET_OK ==
1189  GNUNET_PROGRAM_run (argc,
1190  argv,
1191  "gnunet-namestore-fcfsd",
1192  _("GNU Name System First Come First Serve name registration service"),
1193  options,
1194  &run, NULL)) ? 0 : 1;
1195  GNUNET_free ((void*) argv);
1197  return ret;
1198 }
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
void GNUNET_CRYPTO_ecdsa_key_clear(struct GNUNET_CRYPTO_EcdsaPrivateKey *pk)
Clear memory that was used to store a private key.
Definition: crypto_ecc.c:585
int GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1521
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
Definition of a command line option.
static int ret
Final status code.
Definition: gnunet-arm.c:89
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
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.
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
static char * zone
Name of the zone we manage.
static struct GNUNET_CRYPTO_EcdsaPrivateKey fcfs_zone_pkey
Private key for the fcfsd zone.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_mandatory(struct GNUNET_GETOPT_CommandLineOption opt)
Make the given option mandatory.
static void run(void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
Main function that will be run.
int 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, parse options).
Definition: program.c:361
int GNUNET_log_setup(const char *comp, const char *loglevel, const char *logfile)
Setup logging.
#define GNUNET_free(ptr)
Wrapper around free.
#define gettext_noop(String)
Definition: gettext.h:69
Here is the call graph for this function:

Variable Documentation

◆ httpd

struct MHD_Daemon* httpd
static

MHD deamon reference.

Definition at line 196 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
static

Main HTTP task.

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

◆ ns

struct GNUNET_NAMESTORE_Handle* ns
static

Handle to the namestore.

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

◆ fcfs_zone_pkey

struct GNUNET_CRYPTO_EcdsaPrivateKey fcfs_zone_pkey
static

Private key for the fcfsd zone.

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

Referenced by create_response(), identity_cb(), lookup_it_finished(), main(), update_zoneinfo_page(), and zone_to_name_cb().

◆ identity

struct GNUNET_IDENTITY_Handle* identity
static

Connection to identity service.

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

◆ info_page

struct MHD_Response* info_page
static

Zoneinfo page we currently use.

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

Referenced by serve_zoneinfo_page(), and zone_iteration_end().

◆ uzp_task

struct GNUNET_SCHEDULER_Task* uzp_task
static

Task that runs update_zoneinfo_page peridicially.

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

◆ id_op

struct GNUNET_IDENTITY_Operation* id_op
static

Request for our ego.

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

◆ port

unsigned long long port
static

Port we use for the HTTP server.

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

Referenced by identity_cb(), and run().

◆ zone

char* zone
static