GNUnet  0.11.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 "gnunet_mhd_compat.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 MHD_RESULT 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 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)
 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 44 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 50 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 56 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 62 of file gnunet-namestore-fcfsd.c.

Referenced by zone_iteration_end().

◆ FCFS_ZONEINFO_URL

#define FCFS_ZONEINFO_URL   "/Zoneinfo"

Definition at line 65 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 70 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 75 of file gnunet-namestore-fcfsd.c.

◆ DEFAULT_ZONEINFO_BUFSIZE

#define DEFAULT_ZONEINFO_BUFSIZE   2048

Definition at line 77 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 929 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 82 of file gnunet-namestore-fcfsd.c.

83 {
87  RP_START = 0,
88 
92  RP_LOOKUP,
93 
97  RP_PUT,
98 
102  RP_SUCCESS,
103 
107  RP_FAIL
108 };
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 996 of file gnunet-namestore-fcfsd.c.

References httpd, and run_httpd().

Referenced by run_httpd(), and run_httpd_now().

997 {
998  (void) cls;
999  httpd_task = NULL;
1000  MHD_run (httpd);
1001  run_httpd ();
1002 }
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 260 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().

261 {
262  if (NULL != httpd_task)
263  {
265  httpd_task = NULL;
266  }
268 }
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:1296
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
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 408 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().

409 {
410  static struct ZoneinfoRequest zr;
411 
412  (void) cls;
415  NULL);
416  if (NULL != zr.list_it)
417  return;
418  zr.zoneinfo = GNUNET_malloc (DEFAULT_ZONEINFO_BUFSIZE);
419  zr.buf_len = DEFAULT_ZONEINFO_BUFSIZE;
420  zr.write_offset = 0;
424  &zr,
425  &iterate_cb,
426  &zr,
428  &zr);
429 }
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:1269
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 282 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().

283 {
284  struct ZoneinfoRequest *zr = cls;
285 
286  zr->list_it = NULL;
287  GNUNET_free (zr->zoneinfo);
290  NULL);
291 }
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:1296
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:972
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 298 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().

299 {
300  struct ZoneinfoRequest *zr = cls;
301  struct MHD_Response *response;
302  char*full_page;
303 
304  zr->list_it = NULL;
305 
306  /* return static form */
307  GNUNET_asprintf (&full_page,
309  zr->zoneinfo,
310  zr->zoneinfo);
311  response = MHD_create_response_from_buffer (strlen (full_page),
312  (void *) full_page,
313  MHD_RESPMEM_MUST_FREE);
314  MHD_add_response_header (response,
315  MHD_HTTP_HEADER_CONTENT_TYPE,
316  MIME_HTML);
317  MHD_destroy_response (info_page);
319  GNUNET_free (zr->zoneinfo);
320 }
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 334 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().

339 {
340  struct ZoneinfoRequest *zr = cls;
341  size_t bytes_free;
342  char*pkey;
343  char*new_buf;
344 
345  (void) zone_key;
346  if (1 != rd_len)
347  {
349  1);
350  return;
351  }
352 
354  {
356  1);
357  return;
358  }
359 
360  bytes_free = zr->buf_len - zr->write_offset;
362  rd->data,
363  rd->data_size);
364  if (NULL == pkey)
365  {
366  GNUNET_break (0);
368  1);
369  return;
370  }
371  if (bytes_free < (strlen (name) + strlen (pkey) + 40))
372  {
373  new_buf = GNUNET_malloc (zr->buf_len * 2);
374  GNUNET_memcpy (new_buf, zr->zoneinfo, zr->write_offset);
375  GNUNET_free (zr->zoneinfo);
376  zr->zoneinfo = new_buf;
377  zr->buf_len *= 2;
378  }
379  sprintf (zr->zoneinfo + zr->write_offset,
380  "<tr><td>%s</td><td>%s</td></tr>",
381  name,
382  pkey);
383  zr->write_offset = strlen (zr->zoneinfo);
385  1);
386  GNUNET_free (pkey);
387 }
struct GNUNET_NAMESTORE_ZoneIterator * list_it
List iterator.
static char * pkey
Public key of the zone to look in, in ASCII.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
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.
const void * data
Binary value stored in the DNS record.
#define GNUNET_GNSRECORD_TYPE_PKEY
Record type for GNS zone transfer ("PKEY").
size_t buf_len
Buffer length.
uint32_t record_type
Type of the GNS/DNS record.
const char * name
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 396 of file gnunet-namestore-fcfsd.c.

References info_page.

Referenced by create_response().

397 {
398  return MHD_queue_response (connection,
399  MHD_HTTP_OK,
400  info_page);
401 }
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 439 of file gnunet-namestore-fcfsd.c.

References MAIN_PAGE, MIME_HTML, response, and ret.

Referenced by create_response().

440 {
441  int ret;
442  struct MHD_Response *response;
443 
444  /* return static form */
445  response = MHD_create_response_from_buffer (strlen (MAIN_PAGE),
446  (void *) MAIN_PAGE,
447  MHD_RESPMEM_PERSISTENT);
448  MHD_add_response_header (response,
449  MHD_HTTP_HEADER_CONTENT_TYPE,
450  MIME_HTML);
451  ret = MHD_queue_response (connection,
452  MHD_HTTP_OK,
453  response);
454  MHD_destroy_response (response);
455  return ret;
456 }
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
#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 467 of file gnunet-namestore-fcfsd.c.

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

Referenced by create_response().

470 {
471  int ret;
472  char *reply;
473  struct MHD_Response *response;
474 
475  (void) request;
476  GNUNET_asprintf (&reply,
477  SUBMIT_PAGE,
478  info,
479  info);
480  /* return static form */
481  response = MHD_create_response_from_buffer (strlen (reply),
482  (void *) reply,
483  MHD_RESPMEM_MUST_FREE);
484  MHD_add_response_header (response,
485  MHD_HTTP_HEADER_CONTENT_TYPE,
486  MIME_HTML);
487  ret = MHD_queue_response (connection,
488  MHD_HTTP_OK,
489  response);
490  MHD_destroy_response (response);
491  return ret;
492 }
#define SUBMIT_PAGE
Second page (/S)
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
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 MHD_RESULT 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 515 of file gnunet-namestore-fcfsd.c.

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

Referenced by create_response().

524 {
525  struct Request *request = cls;
526 
527  (void) kind;
528  (void) filename;
529  (void) content_type;
530  (void) transfer_encoding;
531  if (0 == strcmp ("domain", key))
532  {
533  if (size + off >= sizeof(request->domain_name))
534  size = sizeof(request->domain_name) - off - 1;
535  GNUNET_memcpy (&request->domain_name[off],
536  data,
537  size);
538  request->domain_name[size + off] = '\0';
539  return MHD_YES;
540  }
541  if (0 == strcmp ("pkey", key))
542  {
543  if (size + off >= sizeof(request->public_key))
544  size = sizeof(request->public_key) - off - 1;
545  GNUNET_memcpy (&request->public_key[off],
546  data,
547  size);
548  request->public_key[size + off] = '\0';
549  return MHD_YES;
550  }
552  _ ("Unsupported form value `%s'\n"),
553  key);
554  return MHD_YES;
555 }
static struct GNUNET_VPN_RedirectionRequest * request
Opaque redirection request handle.
Definition: gnunet-vpn.c:41
char public_key[128]
Public key submitted via form.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define _(String)
GNU gettext support macro.
Definition: platform.h:184
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 569 of file gnunet-namestore-fcfsd.c.

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

Referenced by zone_to_name_cb().

572 {
573  struct Request *request = cls;
574 
575  request->qe = NULL;
576  if (0 >= success)
577  {
579  _ ("Failed to create record for domain `%s': %s\n"),
580  request->domain_name,
581  emsg);
582  request->phase = RP_FAIL;
583  }
584  else
585  request->phase = RP_SUCCESS;
586  MHD_resume_connection (request->con);
587  run_httpd_now ();
588 }
static struct GNUNET_VPN_RedirectionRequest * request
Opaque redirection request handle.
Definition: gnunet-vpn.c:41
struct MHD_Connection * con
MHD Connection.
#define _(String)
GNU gettext support macro.
Definition: platform.h:184
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 595 of file gnunet-namestore-fcfsd.c.

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

Referenced by lookup_it_finished().

596 {
597  struct Request *request = cls;
598 
600  _ ("Error when mapping zone to name\n"));
601  request->phase = RP_FAIL;
602  MHD_resume_connection (request->con);
603  run_httpd_now ();
604 }
static struct GNUNET_VPN_RedirectionRequest * request
Opaque redirection request handle.
Definition: gnunet-vpn.c:41
struct MHD_Connection * con
MHD Connection.
#define _(String)
GNU gettext support macro.
Definition: platform.h:184
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 617 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, request, RP_FAIL, and run_httpd_now().

Referenced by lookup_it_finished().

622 {
623  struct Request *request = cls;
624  struct GNUNET_GNSRECORD_Data r;
625 
626  (void) rd;
627  (void) zone_key;
628  request->qe = NULL;
629  if (0 != rd_count)
630  {
632  _ ("Found existing name `%s' for the given key\n"),
633  name);
634  request->phase = RP_FAIL;
635  MHD_resume_connection (request->con);
636  run_httpd_now ();
637  return;
638  }
639  r.data = &request->pub;
640  r.data_size = sizeof(request->pub);
641  r.expiration_time = UINT64_MAX;
642  r.record_type = GNUNET_GNSRECORD_TYPE_PKEY;
643  r.flags = GNUNET_GNSRECORD_RF_NONE;
646  request->domain_name,
647  1, &r,
649  request);
650 }
static struct GNUNET_VPN_RedirectionRequest * request
Opaque redirection request handle.
Definition: gnunet-vpn.c:41
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:184
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.
struct GNUNET_NAMESTORE_QueueEntry * qe
Active request with the namestore.
Request we should make.
const char * name
#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 657 of file gnunet-namestore-fcfsd.c.

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

Referenced by create_response().

658 {
659  struct Request *request = cls;
660 
661  MHD_resume_connection (request->con);
662  request->qe = NULL;
663  request->phase = RP_FAIL;
664  run_httpd_now ();
665 }
static struct GNUNET_VPN_RedirectionRequest * request
Opaque redirection request handle.
Definition: gnunet-vpn.c:41
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 679 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, request, and RP_FAIL.

Referenced by create_response().

684 {
685  struct Request *request = cls;
686 
687  (void) label;
688  (void) rd;
689  (void) zonekey;
690  if (0 == strcmp (label, request->domain_name))
691  {
692  GNUNET_break (0 != rd_count);
694  _ ("Found %u existing records for domain `%s'\n"),
695  rd_count,
696  request->domain_name);
697  request->phase = RP_FAIL;
698  }
700 }
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.
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:184
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 704 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, MHD_RESULT, Request::phase, Request::pub, Request::public_key, Request::qe, request, RP_FAIL, run_httpd_now(), zone_to_name_cb(), and zone_to_name_error().

Referenced by create_response().

705 {
706  struct Request *request = cls;
707 
708  if (RP_FAIL == request->phase)
709  {
710  MHD_resume_connection (request->con);
711  run_httpd_now ();
712  return;
713  }
714  if (GNUNET_OK !=
716  strlen (request->public_key),
717  &request->pub))
718  {
719  GNUNET_break (0);
720  request->phase = RP_FAIL;
721  MHD_resume_connection (request->con);
722  run_httpd_now ();
723  return;
724  }
725  request->qe = GNUNET_NAMESTORE_zone_to_name (ns,
727  &request->pub,
729  request,
731  request);
732 }
static struct GNUNET_VPN_RedirectionRequest * request
Opaque redirection request handle.
Definition: gnunet-vpn.c:41
char public_key[128]
Public key submitted via form.
#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:366
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 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

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 759 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, MHD_RESULT, 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().

767 {
768  struct MHD_Response *response;
769  struct Request *request;
771  MHD_RESULT ret;
772 
773  (void) cls;
774  (void) version;
775  if ((0 == strcmp (method, MHD_HTTP_METHOD_GET)) ||
776  (0 == strcmp (method, MHD_HTTP_METHOD_HEAD)))
777  {
778  if (0 == strcmp (url, FCFS_ZONEINFO_URL))
779  ret = serve_zoneinfo_page (connection);
780  else
781  ret = serve_main_page (connection);
782  if (ret != MHD_YES)
784  _ ("Failed to create page for `%s'\n"),
785  url);
786  return ret;
787  }
788  if (0 == strcmp (method, MHD_HTTP_METHOD_POST))
789  {
790  request = *ptr;
791  if (NULL == request)
792  {
793  request = GNUNET_new (struct Request);
794  request->con = connection;
795  *ptr = request;
796  request->pp = MHD_create_post_processor (connection,
797  1024,
798  &post_iterator,
799  request);
800  if (NULL == request->pp)
801  {
803  _ ("Failed to setup post processor for `%s'\n"),
804  url);
805  return MHD_NO; /* internal error */
806  }
807  return MHD_YES;
808  }
809  if (NULL != request->pp)
810  {
811  /* evaluate POST data */
812  MHD_post_process (request->pp,
813  upload_data,
814  *upload_data_size);
815  if (0 != *upload_data_size)
816  {
817  *upload_data_size = 0;
818  return MHD_YES;
819  }
820  /* done with POST data, serve response */
821  MHD_destroy_post_processor (request->pp);
822  request->pp = NULL;
823  }
824  if (GNUNET_OK !=
826  strlen (
827  request->public_key),
828  &pub))
829  {
830  /* parse error */
831  return fill_s_reply ("Failed to parse given public key",
832  request, connection);
833  }
834  switch (request->phase)
835  {
836  case RP_START:
837  if (NULL != strchr (request->domain_name, (int) '.'))
838  {
840  _ ("Domain name must not contain `.'\n"));
841  request->phase = RP_FAIL;
842  return fill_s_reply ("Domain name must not contain `.', sorry.",
843  request,
844  connection);
845  }
846  if (NULL != strchr (request->domain_name, (int) '+'))
847  {
849  _ ("Domain name must not contain `+'\n"));
850  request->phase = RP_FAIL;
851  return fill_s_reply ("Domain name must not contain `+', sorry.",
852  request, connection);
853  }
854  request->phase = RP_LOOKUP;
855  MHD_suspend_connection (request->con);
856  request->lookup_it
860  request,
862  request,
864  request);
865  break;
866 
867  case RP_LOOKUP:
868  break;
869 
870  case RP_PUT:
871  break;
872 
873  case RP_FAIL:
874  return fill_s_reply ("Request failed, sorry.",
875  request, connection);
876 
877  case RP_SUCCESS:
878  return fill_s_reply ("Success.",
879  request, connection);
880 
881  default:
882  GNUNET_break (0);
883  return MHD_NO;
884  }
885  return MHD_YES; /* will have a reply later... */
886  }
887  /* unsupported HTTP method */
888  response = MHD_create_response_from_buffer (strlen (METHOD_ERROR),
889  (void *) METHOD_ERROR,
890  MHD_RESPMEM_PERSISTENT);
891  ret = MHD_queue_response (connection,
892  MHD_HTTP_NOT_ACCEPTABLE,
893  response);
894  MHD_destroy_response (response);
895  return ret;
896 }
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.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#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:184
#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.
#define MHD_RESULT
Data type to use for functions return an "MHD result".
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.
static MHD_RESULT 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...
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:366
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.
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 909 of file gnunet-namestore-fcfsd.c.

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

Referenced by identity_cb().

913 {
914  struct Request *request = *con_cls;
915 
916  (void) cls;
917  (void) connection;
918  (void) toe;
919  if (NULL == request)
920  return;
921  if (NULL != request->pp)
922  MHD_destroy_post_processor (request->pp);
923  if (NULL != request->qe)
924  GNUNET_NAMESTORE_cancel (request->qe);
925  GNUNET_free (request);
926 }
static struct GNUNET_VPN_RedirectionRequest * request
Opaque redirection request handle.
Definition: gnunet-vpn.c:41
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 936 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().

937 {
938  fd_set rs;
939  fd_set ws;
940  fd_set es;
941  struct GNUNET_NETWORK_FDSet *wrs;
942  struct GNUNET_NETWORK_FDSet *wws;
943  struct GNUNET_NETWORK_FDSet *wes;
944  int max;
945  int haveto;
947  struct GNUNET_TIME_Relative tv;
948 
949  FD_ZERO (&rs);
950  FD_ZERO (&ws);
951  FD_ZERO (&es);
955  max = -1;
956  GNUNET_assert (MHD_YES ==
957  MHD_get_fdset (httpd,
958  &rs,
959  &ws,
960  &es,
961  &max));
962  haveto = MHD_get_timeout (httpd,
963  &timeout);
964  if (haveto == MHD_YES)
965  tv.rel_value_us = (uint64_t) timeout * 1000LL;
966  else
969  &rs,
970  max + 1);
972  &ws,
973  max + 1);
975  &es,
976  max + 1);
977  httpd_task =
979  tv,
980  wrs,
981  wws,
982  &do_httpd,
983  NULL);
987 }
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:1120
void GNUNET_NETWORK_fdset_destroy(struct GNUNET_NETWORK_FDSet *fds)
Releases the associated memory of an fd set.
Definition: network.c:1266
struct GNUNET_NETWORK_FDSet * GNUNET_NETWORK_fdset_create(void)
Creates an fd set.
Definition: network.c:1250
static struct GNUNET_TIME_Relative timeout
Desired timeout for the lookup (default is no timeout).
Definition: gnunet-abd.c:61
#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:1841
#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 1011 of file gnunet-namestore-fcfsd.c.

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

Referenced by run().

1012 {
1013  (void) cls;
1014  if (NULL != httpd_task)
1015  {
1017  httpd_task = NULL;
1018  }
1019  if (NULL != uzp_task)
1020  {
1022  uzp_task = NULL;
1023  }
1024  if (NULL != ns)
1025  {
1027  ns = NULL;
1028  }
1029  if (NULL != httpd)
1030  {
1031  MHD_stop_daemon (httpd);
1032  httpd = NULL;
1033  }
1034  if (NULL != id_op)
1035  {
1037  id_op = NULL;
1038  }
1039  if (NULL != identity)
1040  {
1042  identity = NULL;
1043  }
1044 }
void GNUNET_IDENTITY_cancel(struct GNUNET_IDENTITY_Operation *op)
Cancel an identity operation.
Definition: identity_api.c:867
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:884
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:972
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 1067 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().

1071 {
1072  int options;
1073 
1074  (void) cls;
1075  (void) ctx;
1076  if (NULL == name)
1077  return;
1078  if (0 != strcmp (name,
1079  zone))
1080  return;
1081  if (NULL == ego)
1082  {
1084  _ ("No ego configured for `fcfsd` subsystem\n"));
1086  return;
1087  }
1089 
1090  options = MHD_USE_DUAL_STACK | MHD_USE_DEBUG | MHD_ALLOW_SUSPEND_RESUME;
1091  do
1092  {
1093  httpd = MHD_start_daemon (options,
1094  (uint16_t) port,
1095  NULL, NULL,
1096  &create_response, NULL,
1097  MHD_OPTION_CONNECTION_LIMIT, (unsigned int) 128,
1098  MHD_OPTION_PER_IP_CONNECTION_LIMIT, (unsigned
1099  int) 1,
1100  MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 16,
1101  MHD_OPTION_CONNECTION_MEMORY_LIMIT, (size_t) (4
1102  *
1103  1024),
1104  MHD_OPTION_NOTIFY_COMPLETED,
1106  MHD_OPTION_END);
1107  if (MHD_USE_DEBUG == options)
1108  break;
1109  options = MHD_USE_DEBUG;
1110  }
1111  while (NULL == httpd);
1112  if (NULL == httpd)
1113  {
1115  _ ("Failed to start HTTP server\n"));
1117  return;
1118  }
1119  run_httpd ();
1120 }
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:595
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:531
static struct GNUNET_DNSSTUB_Context * ctx
Context for DNS resolution.
#define _(String)
GNU gettext support macro.
Definition: platform.h:184
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 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)
Main MHD callback for handling requests.
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 1132 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().

1136 {
1137  (void) cls;
1138  (void) args;
1139  (void) cfgfile;
1140  if (GNUNET_OK !=
1142  "fcfsd",
1143  "HTTPPORT",
1144  &port))
1145  {
1147  "fcfsd", "HTTPPORT");
1148  return;
1149  }
1150  ns = GNUNET_NAMESTORE_connect (cfg);
1151  if (NULL == ns)
1152  {
1154  _ ("Failed to connect to namestore\n"));
1155  return;
1156  }
1158  &identity_cb,
1159  NULL);
1160  if (NULL == identity)
1161  {
1163  _ ("Failed to connect to identity\n"));
1164  return;
1165  }
1167  NULL);
1169  NULL);
1170 }
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:566
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:1331
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:184
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:1296
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 1181 of file gnunet-namestore-fcfsd.c.

References _, fcfs_zone_pkey, gettext_noop, GNUNET_CRYPTO_ecdsa_key_clear(), GNUNET_free_nz, 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.

1183 {
1187  "zone",
1188  "EGO",
1189  gettext_noop (
1190  "name of the zone that is to be managed by FCFSD"),
1191  &zone)),
1193  };
1194  int ret;
1195 
1196  if (GNUNET_OK !=
1197  GNUNET_STRINGS_get_utf8_args (argc, argv,
1198  &argc, &argv))
1199  return 2;
1200 
1201  GNUNET_log_setup ("fcfsd",
1202  "WARNING",
1203  NULL);
1204  ret =
1205  (GNUNET_OK ==
1206  GNUNET_PROGRAM_run (argc,
1207  argv,
1208  "gnunet-namestore-fcfsd",
1209  _ (
1210  "GNU Name System First Come First Serve name registration service"),
1211  options,
1212  &run, NULL)) ? 0 : 1;
1213  GNUNET_free_nz ((void *) argv);
1215  return ret;
1216 }
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:483
int GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1457
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
Definition of a command line option.
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:184
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.
#define GNUNET_free_nz(ptr)
Wrapper around free.
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:367
int GNUNET_log_setup(const char *comp, const char *loglevel, const char *logfile)
Setup logging.
#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 199 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 204 of file gnunet-namestore-fcfsd.c.

◆ ns

struct GNUNET_NAMESTORE_Handle* ns
static

Handle to the namestore.

Definition at line 209 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 214 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 219 of file gnunet-namestore-fcfsd.c.

◆ info_page

struct MHD_Response* info_page
static

Zoneinfo page we currently use.

Definition at line 224 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 229 of file gnunet-namestore-fcfsd.c.

◆ id_op

struct GNUNET_IDENTITY_Operation* id_op
static

Request for our ego.

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

◆ port

unsigned long long port
static

Port we use for the HTTP server.

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

Referenced by identity_cb(), and run().

◆ zone

char* zone
static