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:

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_IDENTITY_PrivateKey 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_IDENTITY_PrivateKey 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_IDENTITY_PrivateKey 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 daemon reference. More...

static struct GNUNET_SCHEDULER_Task *	httpd_task
	Main HTTP task. More...

static struct GNUNET_NAMESTORE_Handle *	ns
	Handle to the namestore. More...

static struct GNUNET_IDENTITY_PrivateKey	fcfs_zone_pkey
	Private key for the fcfsd zone. More...

static struct GNUNET_IDENTITY_Handle *	identity
	Connection to identity service. More...

static struct MHD_Response *	info_page
	Zoneinfo page we currently use. More...

static struct GNUNET_SCHEDULER_Task *	uzp_task
	Task that runs update_zoneinfo_page peridicially. More...

static struct GNUNET_IDENTITY_Operation *	id_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:

need to track active zone info requests so we can cancel them during shutdown, right?
the code currently contains a 'race' between checking that the domain name is available and allocating it to the new public key (should this race be solved by namestore or by fcfsd?)
nicer error reporting to browser

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 939 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.

 {
   RP_START = 0,
 
   RP_LOOKUP,
 
   RP_PUT,
 
   RP_SUCCESS,
 
   RP_FAIL
 };

Function Documentation

◆ do_httpd()

static void do_httpd ( void * cls )

static

Task run whenever HTTP server operations are pending.

Parameters

cls unused

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

References httpd, and run_httpd().

Referenced by run_httpd(), and run_httpd_now().

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
   if (NULL != httpd_task)
   {
     GNUNET_SCHEDULER_cancel (httpd_task);
     httpd_task = NULL;
   }
   httpd_task = GNUNET_SCHEDULER_add_now (&do_httpd, NULL);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
   static struct ZoneinfoRequest zr;
 
   (void) cls;
   uzp_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
                                            &update_zoneinfo_page,
                                            NULL);
   if (NULL != zr.list_it)
     return;
   zr.zoneinfo = GNUNET_malloc (DEFAULT_ZONEINFO_BUFSIZE);
   zr.buf_len = DEFAULT_ZONEINFO_BUFSIZE;
   zr.write_offset = 0;
   zr.list_it = GNUNET_NAMESTORE_zone_iteration_start (ns,
                                                       &fcfs_zone_pkey,
                                                       &zone_iteration_error,
                                                       &zr,
                                                       &iterate_cb,
                                                       &zr,
                                                       &zone_iteration_end,
                                                       &zr);
 }

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

 {
   struct ZoneinfoRequest *zr = cls;
 
   zr->list_it = NULL;
   GNUNET_free (zr->zoneinfo);
   GNUNET_SCHEDULER_cancel (uzp_task);
   uzp_task = GNUNET_SCHEDULER_add_now (&update_zoneinfo_page,
                                        NULL);
 }

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

 {
   struct ZoneinfoRequest *zr = cls;
   struct MHD_Response *response;
   char*full_page;
 
   zr->list_it = NULL;
 
   /* return static form */
   GNUNET_asprintf (&full_page,
                    ZONEINFO_PAGE,
                    zr->zoneinfo);
   response = MHD_create_response_from_buffer (strlen (full_page),
                                               (void *) full_page,
                                               MHD_RESPMEM_MUST_FREE);
   MHD_add_response_header (response,
                            MHD_HTTP_HEADER_CONTENT_TYPE,
                            MIME_HTML);
   MHD_destroy_response (info_page);
   info_page = response;
   GNUNET_free (zr->zoneinfo);
 }

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_IDENTITY_PrivateKey *	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

cls	closure with the `struct ZoneinfoRequest *`
zone_key	private key of the zone; NULL on disconnect
name	label of the records; NULL on disconnect
rd_len	number of entries in rd array, 0 if label was deleted
rd	array of records with data to store

Definition at line 333 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_EDKEY, 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().

 {
   struct ZoneinfoRequest *zr = cls;
   size_t bytes_free;
   char*pkey;
   char*new_buf;
 
   (void) zone_key;
   if (1 != rd_len)
   {
     GNUNET_NAMESTORE_zone_iterator_next (zr->list_it,
                                          1);
     return;
   }
 
   if ((GNUNET_GNSRECORD_TYPE_PKEY != rd->record_type) &&
       (GNUNET_GNSRECORD_TYPE_EDKEY != rd->record_type))
   {
     GNUNET_NAMESTORE_zone_iterator_next (zr->list_it,
                                          1);
     return;
   }
 
   bytes_free = zr->buf_len - zr->write_offset;
   pkey = GNUNET_GNSRECORD_value_to_string (rd->record_type,
                                            rd->data,
                                            rd->data_size);
   if (NULL == pkey)
   {
     GNUNET_break (0);
     GNUNET_NAMESTORE_zone_iterator_next (zr->list_it,
                                          1);
     return;
   }
   if (bytes_free < (strlen (name) + strlen (pkey) + 40))
   {
     new_buf = GNUNET_malloc (zr->buf_len * 2);
     GNUNET_memcpy (new_buf, zr->zoneinfo, zr->write_offset);
     GNUNET_free (zr->zoneinfo);
     zr->zoneinfo = new_buf;
     zr->buf_len *= 2;
   }
   sprintf (zr->zoneinfo + zr->write_offset,
            "<tr><td>%s</td><td>%s</td></tr>",
            name,
            pkey);
   zr->write_offset = strlen (zr->zoneinfo);
   GNUNET_NAMESTORE_zone_iterator_next (zr->list_it,
                                        1);
   GNUNET_free (pkey);
 }

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

connection connection to use

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

References info_page.

Referenced by create_response().

 {
   return MHD_queue_response (connection,
                              MHD_HTTP_OK,
                              info_page);
 }

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

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

 {
   int ret;
   struct MHD_Response *response;
 
   /* return static form */
   response = MHD_create_response_from_buffer (strlen (MAIN_PAGE),
                                               (void *) MAIN_PAGE,
                                               MHD_RESPMEM_PERSISTENT);
   MHD_add_response_header (response,
                            MHD_HTTP_HEADER_CONTENT_TYPE,
                            MIME_HTML);
   ret = MHD_queue_response (connection,
                             MHD_HTTP_OK,
                             response);
   MHD_destroy_response (response);
   return ret;
 }

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

info	information string to send to the user
request	request information
connection	connection 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().

 {
   int ret;
   char *reply;
   struct MHD_Response *response;
 
   (void) request;
   GNUNET_asprintf (&reply,
                    SUBMIT_PAGE,
                    info,
                    info);
   /* return static form */
   response = MHD_create_response_from_buffer (strlen (reply),
                                               (void *) reply,
                                               MHD_RESPMEM_MUST_FREE);
   MHD_add_response_header (response,
                            MHD_HTTP_HEADER_CONTENT_TYPE,
                            MIME_HTML);
   ret = MHD_queue_response (connection,
                             MHD_HTTP_OK,
                             response);
   MHD_destroy_response (response);
   return ret;
 }

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

cls	user-specified closure
kind	type of the value
key	0-terminated key for the value
filename	name of the uploaded file, NULL if not known
content_type	mime-type of the data, NULL if not known
transfer_encoding	encoding of the data, NULL if not known
data	pointer to size bytes of data at the specified offset
off	offset of data in the overall value
size	number 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().

 {
   struct Request *request = cls;
 
   (void) kind;
   (void) filename;
   (void) content_type;
   (void) transfer_encoding;
   if (0 == strcmp ("domain", key))
   {
     if (size + off >= sizeof(request->domain_name))
       size = sizeof(request->domain_name) - off - 1;
     GNUNET_memcpy (&request->domain_name[off],
                    data,
                    size);
     request->domain_name[size + off] = '\0';
     return MHD_YES;
   }
   if (0 == strcmp ("pkey", key))
   {
     if (size + off >= sizeof(request->public_key))
       size = sizeof(request->public_key) - off - 1;
     GNUNET_memcpy (&request->public_key[off],
                    data,
                    size);
     request->public_key[size + off] = '\0';
     return MHD_YES;
   }
   GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
               _ ("Unsupported form value `%s'\n"),
               key);
   return MHD_YES;
 }

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

cls	closure
success	GNUNET_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
emsg	NULL 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().

 {
   struct Request *request = cls;
 
   request->qe = NULL;
   if (0 >= success)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                 _ ("Failed to create record for domain `%s': %s\n"),
                 request->domain_name,
                 emsg);
     request->phase = RP_FAIL;
   }
   else
     request->phase = RP_SUCCESS;
   MHD_resume_connection (request->con);
   run_httpd_now ();
 }

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

 {
   struct Request *request = cls;
 
   GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
               _ ("Error when mapping zone to name\n"));
   request->phase = RP_FAIL;
   MHD_resume_connection (request->con);
   run_httpd_now ();
 }

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_IDENTITY_PrivateKey *	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

cls	closure
zone_key	public key of the zone
name	name that is being mapped (at most 255 characters long)
rd_count	number of entries in rd array
rd	array 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_free, GNUNET_GNSRECORD_data_from_identity(), GNUNET_GNSRECORD_RF_NONE, GNUNET_log, GNUNET_NAMESTORE_records_store(), GNUNET_OK, 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().

 {
   struct Request *request = cls;
   struct GNUNET_GNSRECORD_Data r;
   char *rdata;
 
   (void) rd;
   (void) zone_key;
   request->qe = NULL;
   if (0 != rd_count)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                 _ ("Found existing name `%s' for the given key\n"),
                 name);
     request->phase = RP_FAIL;
     MHD_resume_connection (request->con);
     run_httpd_now ();
     return;
   }
   if (GNUNET_OK != GNUNET_GNSRECORD_data_from_identity (&request->pub,
                                                         &rdata,
                                                         &r.data_size,
                                                         &r.record_type))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                 _ ("Error creating record data.\n"));
     request->phase = RP_FAIL;
     MHD_resume_connection (request->con);
     run_httpd_now ();
     return;
   }
 
   r.data = rdata;
   r.expiration_time = UINT64_MAX;
   r.flags = GNUNET_GNSRECORD_RF_NONE;
   request->qe = GNUNET_NAMESTORE_records_store (ns,
                                                 &fcfs_zone_pkey,
                                                 request->domain_name,
                                                 1, &r,
                                                 &put_continuation,
                                                 request);
   GNUNET_free (rdata);
 }

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

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

Referenced by create_response().

 {
   struct Request *request = cls;
 
   MHD_resume_connection (request->con);
   request->qe = NULL;
   request->phase = RP_FAIL;
   run_httpd_now ();
 }

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_IDENTITY_PrivateKey *	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

cls	the 'struct Request' we are processing
zonekey	private key of the zone; NULL on disconnect
label	label of the records; NULL on disconnect
rd_count	number of entries in rd array, 0 if label was deleted
rd	array of records with data to store

Definition at line 692 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().

 {
   struct Request *request = cls;
 
   (void) label;
   (void) rd;
   (void) zonekey;
   if (0 == strcmp (label, request->domain_name))
   {
     GNUNET_break (0 != rd_count);
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                 _ ("Found %u existing records for domain `%s'\n"),
                 rd_count,
                 request->domain_name);
     request->phase = RP_FAIL;
   }
   GNUNET_NAMESTORE_zone_iterator_next (request->lookup_it, 1);
 }

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

References Request::con, fcfs_zone_pkey, GNUNET_break, GNUNET_IDENTITY_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().

 {
   struct Request *request = cls;
 
   if (RP_FAIL == request->phase)
   {
     MHD_resume_connection (request->con);
     run_httpd_now ();
     return;
   }
   if (GNUNET_OK !=
       GNUNET_IDENTITY_public_key_from_string (request->public_key,
                                               &request->pub))
   {
     GNUNET_break (0);
     request->phase = RP_FAIL;
     MHD_resume_connection (request->con);
     run_httpd_now ();
     return;
   }
   request->qe = GNUNET_NAMESTORE_zone_to_name (ns,
                                                &fcfs_zone_pkey,
                                                &request->pub,
                                                &zone_to_name_error,
                                                request,
                                                &zone_to_name_cb,
                                                request);
 }

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

cls	unused
connection	MHD connection handle
url	the requested url
method	the HTTP method used ("GET", "PUT", etc.)
version	the HTTP version string ("HTTP/1.1" for version 1.1, etc.)
upload_data	the 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_size	set initially to the size of the upload_data provided; the method must update this value to the number of bytes NOT processed;
ptr	pointer 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 771 of file gnunet-namestore-fcfsd.c.

References _, Request::con, Request::domain_name, fcfs_zone_pkey, FCFS_ZONEINFO_URL, fill_s_reply(), GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_IDENTITY_public_key_from_string(), 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().

 {
   struct MHD_Response *response;
   struct Request *request;
   struct GNUNET_IDENTITY_PublicKey pub;
   MHD_RESULT ret;
 
   (void) cls;
   (void) version;
   if ((0 == strcmp (method, MHD_HTTP_METHOD_GET)) ||
       (0 == strcmp (method, MHD_HTTP_METHOD_HEAD)))
   {
     if (0 == strcmp (url, FCFS_ZONEINFO_URL))
       ret = serve_zoneinfo_page (connection);
     else
       ret = serve_main_page (connection);
     if (ret != MHD_YES)
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                   _ ("Failed to create page for `%s'\n"),
                   url);
     return ret;
   }
   if (0 == strcmp (method, MHD_HTTP_METHOD_POST))
   {
     request = *ptr;
     if (NULL == request)
     {
       request = GNUNET_new (struct Request);
       request->con = connection;
       *ptr = request;
       request->pp = MHD_create_post_processor (connection,
                                                1024,
                                                &post_iterator,
                                                request);
       if (NULL == request->pp)
       {
         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                     _ ("Failed to setup post processor for `%s'\n"),
                     url);
         return MHD_NO;       /* internal error */
       }
       return MHD_YES;
     }
     if (NULL != request->pp)
     {
       /* evaluate POST data */
       MHD_post_process (request->pp,
                         upload_data,
                         *upload_data_size);
       if (0 != *upload_data_size)
       {
         *upload_data_size = 0;
         return MHD_YES;
       }
       /* done with POST data, serve response */
       MHD_destroy_post_processor (request->pp);
       request->pp = NULL;
     }
     if (GNUNET_OK !=
         GNUNET_IDENTITY_public_key_from_string (request->public_key,
                                                 &pub))
     {
       /* parse error */
       return fill_s_reply ("Failed to parse given public key",
                            request, connection);
     }
     switch (request->phase)
     {
     case RP_START:
       if (NULL != strchr (request->domain_name, (int) '.'))
       {
         GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                     _ ("Domain name must not contain `.'\n"));
         request->phase = RP_FAIL;
         return fill_s_reply ("Domain name must not contain `.', sorry.",
                              request,
                              connection);
       }
       if (NULL != strchr (request->domain_name, (int) '+'))
       {
         GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                     _ ("Domain name must not contain `+'\n"));
         request->phase = RP_FAIL;
         return fill_s_reply ("Domain name must not contain `+', sorry.",
                              request, connection);
       }
       request->phase = RP_LOOKUP;
       MHD_suspend_connection (request->con);
       request->lookup_it
         = GNUNET_NAMESTORE_zone_iteration_start (ns,
                                                  &fcfs_zone_pkey,
                                                  &lookup_it_error,
                                                  request,
                                                  &lookup_it_processor,
                                                  request,
                                                  &lookup_it_finished,
                                                  request);
       break;
 
     case RP_LOOKUP:
       break;
 
     case RP_PUT:
       break;
 
     case RP_FAIL:
       return fill_s_reply ("Request failed, sorry.",
                            request, connection);
 
     case RP_SUCCESS:
       return fill_s_reply ("Success.",
                            request, connection);
 
     default:
       GNUNET_break (0);
       return MHD_NO;
     }
     return MHD_YES;   /* will have a reply later... */
   }
   /* unsupported HTTP method */
   response = MHD_create_response_from_buffer (strlen (METHOD_ERROR),
                                               (void *) METHOD_ERROR,
                                               MHD_RESPMEM_PERSISTENT);
   ret = MHD_queue_response (connection,
                             MHD_HTTP_NOT_ACCEPTABLE,
                             response);
   MHD_destroy_response (response);
   return ret;
 }

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

cls	not used
connection	connection that completed
con_cls	session handle
toe	status code

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

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

Referenced by identity_cb().

 {
   struct Request *request = *con_cls;
 
   (void) cls;
   (void) connection;
   (void) toe;
   if (NULL == request)
     return;
   if (NULL != request->pp)
     MHD_destroy_post_processor (request->pp);
   if (NULL != request->qe)
     GNUNET_NAMESTORE_cancel (request->qe);
   GNUNET_free (request);
 }

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 946 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, max, GNUNET_TIME_Relative::rel_value_us, Request::rs, timeout, and UNSIGNED_MHD_LONG_LONG.

Referenced by do_httpd(), and identity_cb().

 {
   fd_set rs;
   fd_set ws;
   fd_set es;
   struct GNUNET_NETWORK_FDSet *wrs;
   struct GNUNET_NETWORK_FDSet *wws;
   struct GNUNET_NETWORK_FDSet *wes;
   int max;
   int haveto;
   UNSIGNED_MHD_LONG_LONG timeout;
   struct GNUNET_TIME_Relative tv;
 
   FD_ZERO (&rs);
   FD_ZERO (&ws);
   FD_ZERO (&es);
   wrs = GNUNET_NETWORK_fdset_create ();
   wes = GNUNET_NETWORK_fdset_create ();
   wws = GNUNET_NETWORK_fdset_create ();
   max = -1;
   GNUNET_assert (MHD_YES ==
                  MHD_get_fdset (httpd,
                                 &rs,
                                 &ws,
                                 &es,
                                 &max));
   haveto = MHD_get_timeout (httpd,
                             &timeout);
   if (haveto == MHD_YES)
     tv.rel_value_us = (uint64_t) timeout * 1000LL;
   else
     tv = GNUNET_TIME_UNIT_FOREVER_REL;
   GNUNET_NETWORK_fdset_copy_native (wrs,
                                     &rs,
                                     max + 1);
   GNUNET_NETWORK_fdset_copy_native (wws,
                                     &ws,
                                     max + 1);
   GNUNET_NETWORK_fdset_copy_native (wes,
                                     &es,
                                     max + 1);
   httpd_task =
     GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH,
                                  tv,
                                  wrs,
                                  wws,
                                  &do_httpd,
                                  NULL);
   GNUNET_NETWORK_fdset_destroy (wrs);
   GNUNET_NETWORK_fdset_destroy (wws);
   GNUNET_NETWORK_fdset_destroy (wes);
 }

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

cls unused

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

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

Referenced by run().

 {
   (void) cls;
   if (NULL != httpd_task)
   {
     GNUNET_SCHEDULER_cancel (httpd_task);
     httpd_task = NULL;
   }
   if (NULL != uzp_task)
   {
     GNUNET_SCHEDULER_cancel (uzp_task);
     uzp_task = NULL;
   }
   if (NULL != ns)
   {
     GNUNET_NAMESTORE_disconnect (ns);
     ns = NULL;
   }
   if (NULL != httpd)
   {
     MHD_stop_daemon (httpd);
     httpd = NULL;
   }
   if (NULL != id_op)
   {
     GNUNET_IDENTITY_cancel (id_op);
     id_op = NULL;
   }
   if (NULL != identity)
   {
     GNUNET_IDENTITY_disconnect (identity);
     identity = NULL;
   }
 }

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 (for example because 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

cls	closure, NULL
ego	ego handle
ctx	context for application to store data for this ego (during the lifetime of this process, initially NULL)
name	name 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 1076 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().

 {
   int options;
 
   (void) cls;
   (void) ctx;
   if (NULL == name)
     return;
   if (0 != strcmp (name,
                    zone))
     return;
   if (NULL == ego)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 _ ("No ego configured for `fcfsd` subsystem\n"));
     GNUNET_SCHEDULER_shutdown ();
     return;
   }
   fcfs_zone_pkey = *GNUNET_IDENTITY_ego_get_private_key (ego);
 
   options = MHD_USE_DUAL_STACK | MHD_USE_DEBUG | MHD_ALLOW_SUSPEND_RESUME;
   do
   {
     httpd = MHD_start_daemon (options,
                               (uint16_t) port,
                               NULL, NULL,
                               &create_response, NULL,
                               MHD_OPTION_CONNECTION_LIMIT, (unsigned int) 128,
                               MHD_OPTION_PER_IP_CONNECTION_LIMIT, (unsigned
                                                                    int) 1,
                               MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 16,
                               MHD_OPTION_CONNECTION_MEMORY_LIMIT, (size_t) (4
                                                                             *
                                                                             1024),
                               MHD_OPTION_NOTIFY_COMPLETED,
                               &request_completed_callback, NULL,
                               MHD_OPTION_END);
     if (MHD_USE_DEBUG == options)
       break;
     options = MHD_USE_DEBUG;
   }
   while (NULL == httpd);
   if (NULL == httpd)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 _ ("Failed to start HTTP server\n"));
     GNUNET_SCHEDULER_shutdown ();
     return;
   }
   run_httpd ();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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

cls	closure
args	remaining command-line arguments
cfgfile	name of the configuration file used (for saving, can be NULL!)
cfg	configuration

Definition at line 1141 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().

 {
   (void) cls;
   (void) args;
   (void) cfgfile;
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_number (cfg,
                                              "fcfsd",
                                              "HTTPPORT",
                                              &port))
   {
     GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                                "fcfsd", "HTTPPORT");
     return;
   }
   ns = GNUNET_NAMESTORE_connect (cfg);
   if (NULL == ns)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 _ ("Failed to connect to namestore\n"));
     return;
   }
   identity = GNUNET_IDENTITY_connect (cfg,
                                       &identity_cb,
                                       NULL);
   if (NULL == identity)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 _ ("Failed to connect to identity\n"));
     return;
   }
   uzp_task = GNUNET_SCHEDULER_add_now (&update_zoneinfo_page,
                                        NULL);
   GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
                                  NULL);
 }

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

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

Returns: 0 ok, 1 on error

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

References _, gettext_noop, 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.

 {
   struct GNUNET_GETOPT_CommandLineOption options[] = {
     GNUNET_GETOPT_option_mandatory
       (GNUNET_GETOPT_option_string ('z',
                                     "zone",
                                     "EGO",
                                     gettext_noop (
                                       "name of the zone that is to be managed by FCFSD"),
                                     &zone)),
     GNUNET_GETOPT_OPTION_END
   };
   int ret;
 
   if (GNUNET_OK !=
       GNUNET_STRINGS_get_utf8_args (argc, argv,
                                     &argc, &argv))
     return 2;
 
   GNUNET_log_setup ("fcfsd",
                     "WARNING",
                     NULL);
   ret =
     (GNUNET_OK ==
      GNUNET_PROGRAM_run (argc,
                          argv,
                          "gnunet-namestore-fcfsd",
                          _ (
                            "GNU Name System First Come First Serve name registration service"),
                          options,
                          &run, NULL)) ? 0 : 1;
   GNUNET_free_nz ((void *) argv);
   // FIXME
   // GNUNET_CRYPTO_ecdsa_key_clear (&fcfs_zone_pkey);
   return ret;
 }

Here is the call graph for this function:

Variable Documentation

◆ httpd

struct MHD_Daemon* httpd

static

MHD daemon 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_IDENTITY_PrivateKey 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(), 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

Name of the zone we manage.

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

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

Data Structures

Macros

Enumerations

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ METHOD_ERROR

◆ MAIN_PAGE

◆ SUBMIT_PAGE

◆ ZONEINFO_PAGE

◆ FCFS_ZONEINFO_URL

◆ MIME_HTML

◆ COOKIE_NAME

◆ DEFAULT_ZONEINFO_BUFSIZE

◆ UNSIGNED_MHD_LONG_LONG

Enumeration Type Documentation

◆ Phase

Function Documentation

◆ do_httpd()

◆ run_httpd_now()

◆ update_zoneinfo_page()

◆ zone_iteration_error()

◆ zone_iteration_end()

◆ iterate_cb()

◆ serve_zoneinfo_page()

◆ serve_main_page()

◆ fill_s_reply()

◆ post_iterator()

◆ put_continuation()

◆ zone_to_name_error()

◆ zone_to_name_cb()

◆ lookup_it_error()

◆ lookup_it_processor()

◆ lookup_it_finished()

◆ create_response()

◆ request_completed_callback()

◆ run_httpd()

◆ do_shutdown()

◆ identity_cb()

◆ run()

◆ main()

Variable Documentation

◆ httpd

◆ httpd_task

◆ ns

◆ fcfs_zone_pkey

◆ identity

◆ info_page

◆ uzp_task

◆ id_op

◆ port

◆ zone