HTTP server to create GNS business cards. More...

#include "platform.h"
#include <microhttpd.h>
#include "gnunet_util_lib.h"
#include "gnunet_mhd_compat.h"

Include dependency graph for gnunet-bcd.c:

Data Structures
struct	StaticResource

struct	ParameterMap

Functions
static void	do_shutdown (void *cls)
	Task ran at shutdown to clean up everything. More...

static void	do_httpd (void *cls)
	Called when the HTTP server has some pending operations. More...

static void	run_httpd (void)
	Schedule a task to run MHD. More...

static MHD_RESULT	create_response (void cls, struct MHD_Connection connection, const char url, const char method, const char version, const char upload_data, size_t upload_data_size, void *ptr)
	Send a response back to a connected client. More...

static struct StaticResource *	open_static_resource (const char name, const char basedir)
	Open a file on disk and generate a response for it. More...

static void	run (void cls, char const args, const char cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
	Main function that will be run. More...

int	main (int argc, char const argv)
	The main function for gnunet-gns. More...

Variables
static struct MHD_Daemon *	httpd = NULL
	Handle to the HTTP server as provided by libmicrohttpd. More...

static struct GNUNET_SCHEDULER_Task *	httpd_task = NULL
	Our primary task for the HTTPD. More...

static struct StaticResource *	index_simple = NULL
	Index file resource (simple result). More...

static struct StaticResource *	index_full = NULL
	Index file resource (full result). More...

static struct StaticResource *	key_error = NULL
	Error: invalid gns key. More...

static struct StaticResource *	notfound_error = NULL
	Error: 404. More...

static struct StaticResource *	internal_error = NULL
	Errors after receiving the form data. More...

static struct StaticResource *	forbidden_error = NULL
	Other errors. More...

static char *	tex_file_simple = NULL
	Full path to the TeX template file (simple result) More...

static char *	tex_file_full = NULL
	Full path to the TeX template file (full result) More...

static char *	tex_file_png = NULL
	Full path to the TeX template file (PNG result) More...

static int	continue_100 = 100
	Used as a sort of singleton to send exactly one 100 CONTINUE per request. More...

static const struct ParameterMap	pmap []
	Map of names with TeX definitions, used during PDF generation. More...

static uint16_t	port = 8888
	Port number. More...

Detailed Description

HTTP server to create GNS business cards.

Author: Christian Grothoff

Definition in file gnunet-bcd.c.

Function Documentation

◆ do_shutdown()

static void do_shutdown ( void * cls )

static

Task ran at shutdown to clean up everything.

Parameters

cls unused

Definition at line 154 of file gnunet-bcd.c.

{
  /* We cheat a bit here: the file descriptor is implicitly closed by MHD, so
   calling `GNUNET_DISK_file_close' would generate a spurious warning message
   in the log. Since that function does nothing but close the descriptor and
   free the allocated memory, After destroying the response all that's left to
   do is call `GNUNET_free'. */
  if (NULL != index_simple)
  {
    MHD_destroy_response (index_simple->response);
    GNUNET_free (index_simple->handle);
    GNUNET_free (index_simple);
  }
  if (NULL != index_full)
  {
    MHD_destroy_response (index_full->response);
    GNUNET_free (index_full->handle);
    GNUNET_free (index_full);
  }
  if (NULL != key_error)
  {
    MHD_destroy_response (key_error->response);
    GNUNET_free (key_error->handle);
    GNUNET_free (key_error);
  }
  if (NULL != notfound_error)
  {
    MHD_destroy_response (notfound_error->response);
    GNUNET_free (notfound_error->handle);
    GNUNET_free (notfound_error);
  }
  if (NULL != internal_error)
  {
    MHD_destroy_response (internal_error->response);
    GNUNET_free (internal_error->handle);
    GNUNET_free (internal_error);
  }
  if (NULL != forbidden_error)
  {
    MHD_destroy_response (forbidden_error->response);
    GNUNET_free (forbidden_error->handle);
    GNUNET_free (forbidden_error);
  }
 
  if (NULL != httpd_task)
  {
    GNUNET_SCHEDULER_cancel (httpd_task);
  }
  if (NULL != httpd)
  {
    MHD_stop_daemon (httpd);
  }
}

References forbidden_error, GNUNET_free, GNUNET_SCHEDULER_cancel(), StaticResource::handle, httpd, httpd_task, index_full, index_simple, internal_error, key_error, notfound_error, and StaticResource::response.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ do_httpd()

static void do_httpd ( void * cls )

static

Called when the HTTP server has some pending operations.

Parameters

cls unused

Definition at line 268 of file gnunet-bcd.c.

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

References httpd, httpd_task, and run_httpd().

Referenced by run_httpd().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ run_httpd()

static void run_httpd ( void )

static

Schedule a task to run MHD.

Definition at line 221 of file gnunet-bcd.c.

{
  fd_set rs;
  fd_set ws;
  fd_set es;
  int max = -1;
  unsigned MHD_LONG_LONG timeout = 0;
  struct GNUNET_TIME_Relative gtime = GNUNET_TIME_UNIT_FOREVER_REL;
 
  struct GNUNET_NETWORK_FDSet *grs = GNUNET_NETWORK_fdset_create ();
  struct GNUNET_NETWORK_FDSet *gws = GNUNET_NETWORK_fdset_create ();
  struct GNUNET_NETWORK_FDSet *ges = GNUNET_NETWORK_fdset_create ();
 
  FD_ZERO (&rs);
  FD_ZERO (&ws);
  FD_ZERO (&es);
 
  GNUNET_assert (MHD_YES == MHD_get_fdset (httpd, &rs, &ws, &es, &max));
 
  if (MHD_YES == MHD_get_timeout (httpd, &timeout))
  {
    gtime = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,
                                           timeout);
  }
 
  GNUNET_NETWORK_fdset_copy_native (grs, &rs, max + 1);
  GNUNET_NETWORK_fdset_copy_native (gws, &ws, max + 1);
  GNUNET_NETWORK_fdset_copy_native (ges, &es, max + 1);
 
  httpd_task = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH,
                                            gtime,
                                            grs,
                                            gws,
                                            &do_httpd,
                                            NULL);
  GNUNET_NETWORK_fdset_destroy (grs);
  GNUNET_NETWORK_fdset_destroy (gws);
  GNUNET_NETWORK_fdset_destroy (ges);
}

References do_httpd(), GNUNET_assert, GNUNET_NETWORK_fdset_copy_native(), GNUNET_NETWORK_fdset_create(), GNUNET_NETWORK_fdset_destroy(), GNUNET_SCHEDULER_add_select(), GNUNET_SCHEDULER_PRIORITY_HIGH, GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TIME_UNIT_MILLISECONDS, httpd, httpd_task, max, and timeout.

Referenced by do_httpd(), and run().

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

Send a response back to a connected client.

Parameters

cls	unused
connection	the connection with the client
url	the requested address
method	the HTTP method used
version	the protocol version (including the "HTTP/" part)
upload_data	data sent with a POST request
upload_data_size	length in bytes of the POST data
ptr	used to pass data between request handling phases

Returns: MHD_NO on error

Definition at line 290 of file gnunet-bcd.c.

{
  struct GNUNET_CRYPTO_PublicKey pk;
  bool isget = (0 == strcmp (method, MHD_HTTP_METHOD_GET));
  bool ishead = (0 == strcmp (method, MHD_HTTP_METHOD_HEAD));
  bool isfull = (0 == strcmp ("/submit/full", url));
  bool issimple = (0 == strcmp ("/submit/simple", url));
  char *tmpd;
  char *defpath = NULL;
  const char *gpgfp = MHD_lookup_connection_value (connection,
                                                   MHD_GET_ARGUMENT_KIND,
                                                   "gpgfingerprint");
  const char *gnsnick = MHD_lookup_connection_value (connection,
                                                     MHD_GET_ARGUMENT_KIND,
                                                     "gnsnick");
  const char *gnskey = MHD_lookup_connection_value (connection,
                                                    MHD_GET_ARGUMENT_KIND,
                                                    "gnskey");
  const char *qrpng = MHD_lookup_connection_value (connection,
                                                   MHD_GET_ARGUMENT_KIND,
                                                   "gnspng");
 
  (void) cls;
  (void) version;
  (void) upload_data;
  (void) upload_data_size;
 
  if (! isget && ! ishead)
  {
    return MHD_queue_response (connection,
                               MHD_HTTP_NOT_IMPLEMENTED,
                               forbidden_error->response);
  }
 
  if (ishead)
  {
    /* Dedicated branch in case we want to provide a different result for some
       reason (e.g. a non-web browser application using the web UI) */
    return MHD_queue_response (connection,
                               MHD_HTTP_OK,
                               index_simple->response);
  }
 
  /* Send a 100 CONTINUE response to tell clients that the result of the
     request might take some time */
  if (NULL == *ptr)
  {
    *ptr = &continue_100;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending 100 CONTINUE\n");
    return MHD_YES;
  }
 
  if (0 == strcmp ("/", url))
  {
    return MHD_queue_response (connection,
                               MHD_HTTP_OK,
                               index_simple->response);
  }
 
  if (0 == strcmp ("/full", url))
  {
    return MHD_queue_response (connection,
                               MHD_HTTP_OK,
                               index_full->response);
  }
 
 
  if (! isfull && ! issimple)
  {
    return MHD_queue_response (connection,
                               MHD_HTTP_NOT_FOUND,
                               notfound_error->response);
  }
 
 
  if (NULL == gnskey
      || GNUNET_OK != GNUNET_CRYPTO_public_key_from_string (gnskey, &pk))
  {
    return MHD_queue_response (connection,
                               MHD_HTTP_BAD_REQUEST,
                               key_error->response);
  }
 
  tmpd = GNUNET_DISK_mkdtemp (gnskey);
  if (NULL == tmpd)
  {
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "mktemp", gnskey);
    return MHD_queue_response (connection,
                               MHD_HTTP_INTERNAL_SERVER_ERROR,
                               internal_error->response);
  }
 
  GNUNET_asprintf (&defpath, "%s%s%s", tmpd, DIR_SEPARATOR_STR, "def.tex");
 
  {
    FILE *deffile = fopen (defpath, "w");
    if (NULL == deffile)
    {
      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", defpath);
      GNUNET_free (defpath);
      GNUNET_DISK_directory_remove (tmpd);
      GNUNET_free (tmpd);
      return MHD_queue_response (connection,
                                 MHD_HTTP_INTERNAL_SERVER_ERROR,
                                 internal_error->response);
    }
 
    GNUNET_free (defpath);
 
    for (size_t i = 0; NULL!=pmap[i].name; ++i)
    {
      const char *value = MHD_lookup_connection_value (connection,
                                                       MHD_GET_ARGUMENT_KIND,
                                                       pmap[i].name);
      fprintf (deffile,
               "\\def\\%s{%s}\n",
               pmap[i].definition,
               (NULL == value) ? "" : value);
    }
 
    if (NULL != gpgfp)
    {
      size_t len = strlen (gpgfp);
      char *line1 = GNUNET_strndup (gpgfp, len / 2);
      char *line2 = GNUNET_strdup (&gpgfp[len / 2]);
      fprintf (deffile,
               "\\def\\gpglineone{%s}\n\\def\\gpglinetwo{%s}\n",
               line1,
               line2);
      GNUNET_free (line1);
      GNUNET_free (line2);
    }
 
    fprintf (deffile,
             "\\def\\gns{%s/%s}\n",
             gnskey,
             (NULL == gnsnick) ? "" : gnsnick);
 
    fclose (deffile);
  }
  {
    char *command = NULL;
    int ret;
    GNUNET_asprintf (&command,
                     "cd %s; cp %s gns-bcd.tex; "
                     "pdflatex %s gns-bcd.tex >/dev/null 2>&1",
                     tmpd,
                     (isfull) ? tex_file_full :
                     ((NULL == qrpng) ? tex_file_simple : tex_file_png),
                     (NULL == qrpng) ? "" : "-shell-escape");
 
    ret = system (command);
 
    if (WIFSIGNALED (ret) || 0 != WEXITSTATUS (ret))
    {
      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "system", command);
    }
 
    GNUNET_free (command);
  }
  GNUNET_asprintf (&defpath,
                   "%s%s%s",
                   tmpd,
                   DIR_SEPARATOR_STR,
                   (NULL == qrpng) ? "gns-bcd.pdf" : "gns-bcd.png");
  {
    MHD_RESULT r;
    struct MHD_Response *pdfrs;
    struct stat statret;
    int pdf = open (defpath, O_RDONLY);
    if (-1 == pdf)
    {
      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", defpath);
      GNUNET_free (defpath);
      GNUNET_DISK_directory_remove (tmpd);
      GNUNET_free (tmpd);
      return MHD_queue_response (connection,
                                 MHD_HTTP_INTERNAL_SERVER_ERROR,
                                 internal_error->response);
    }
 
    GNUNET_break (0 == stat (defpath, &statret));
 
    GNUNET_free (defpath);
 
    pdfrs = MHD_create_response_from_fd ((size_t) statret.st_size, pdf);
    if (NULL == pdfrs)
    {
      GNUNET_break (0);
      GNUNET_break (0 == close (pdf));
      GNUNET_DISK_directory_remove (tmpd);
      GNUNET_free (tmpd);
      return MHD_queue_response (connection,
                                 MHD_HTTP_INTERNAL_SERVER_ERROR,
                                 internal_error->response);
    }
 
    GNUNET_assert (MHD_NO != MHD_add_response_header (pdfrs,
                                                      MHD_HTTP_HEADER_CONTENT_TYPE,
                                                      (NULL == qrpng) ?
                                                      "application/pdf" :
                                                      "image/png"));
    GNUNET_assert (MHD_NO !=
                   MHD_add_response_header (pdfrs,
                                            MHD_HTTP_HEADER_CONTENT_DISPOSITION,
                                            (NULL == qrpng) ?
                                            "attachment; filename=\"gns-business-card.pdf\""
                                            :
                                            "attachment; filename=\"gns-qr-code.png\""));
    r = MHD_queue_response (connection, MHD_HTTP_OK, pdfrs);
 
    MHD_destroy_response (pdfrs);
    GNUNET_DISK_directory_remove (tmpd);
    GNUNET_free (tmpd);
    return r;
  }
}

References continue_100, DIR_SEPARATOR_STR, forbidden_error, GNUNET_asprintf(), GNUNET_assert, GNUNET_break, GNUNET_CRYPTO_public_key_from_string(), GNUNET_DISK_directory_remove(), GNUNET_DISK_mkdtemp(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_log_strerror_file, GNUNET_OK, GNUNET_strdup, GNUNET_strndup, index_full, index_simple, internal_error, key_error, MHD_RESULT, name, ParameterMap::name, notfound_error, pk, pmap, StaticResource::response, ret, tex_file_full, tex_file_png, tex_file_simple, and value.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ open_static_resource()

static struct StaticResource * open_static_resource	(	const char *	name,
		const char *	basedir
	)

static

Open a file on disk and generate a response for it.

Parameters

name	name of the file to open
basedir	directory where the file is located

Returns: NULL on error

Definition at line 524 of file gnunet-bcd.c.

{
  char *fullname = NULL;
  off_t size = 0;
  struct GNUNET_DISK_FileHandle *f;
  struct MHD_Response *response;
  struct StaticResource *res;
  GNUNET_asprintf (&fullname, "%s%s%s", basedir, DIR_SEPARATOR_STR, name);
 
  f = GNUNET_DISK_file_open (fullname,
                             GNUNET_DISK_OPEN_READ,
                             GNUNET_DISK_PERM_NONE);
 
  GNUNET_free (fullname);
 
  if (NULL == f)
  {
    return NULL;
  }
 
  if (GNUNET_SYSERR == GNUNET_DISK_file_handle_size (f, &size))
  {
    GNUNET_DISK_file_close (f);
    return NULL;
  }
 
  response = MHD_create_response_from_fd64 (size, f->fd);
 
  if (NULL == response)
  {
    GNUNET_DISK_file_close (f);
    return NULL;
  }
 
  res = GNUNET_new (struct StaticResource);
  res->handle = f;
  res->size = (uint64_t) size;
  res->response = response;
 
  return res;
}

References DIR_SEPARATOR_STR, GNUNET_DISK_FileHandle::fd, GNUNET_asprintf(), GNUNET_DISK_file_close(), GNUNET_DISK_file_handle_size(), GNUNET_DISK_file_open(), GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_NONE, GNUNET_free, GNUNET_new, GNUNET_SYSERR, name, res, response, and size.

Referenced by run().

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 *	c
	)

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!)
c	configuration

Definition at line 576 of file gnunet-bcd.c.

{
  char *datadir;
  (void) cls;
  (void) args;
  (void) cfgfile;
 
  if (0 == port)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Invalid port number %u\n"),
                port);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
 
  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
 
  datadir = GNUNET_OS_installation_get_path (GNUNET_OS_project_data_gnunet (),
                                             GNUNET_OS_IPK_DATADIR);
  GNUNET_assert (NULL != datadir);
 
  GNUNET_asprintf (&tex_file_full,
                   "%s%s%s",
                   datadir,
                   DIR_SEPARATOR_STR,
                   "gns-bcd.tex");
  GNUNET_asprintf (&tex_file_simple,
                   "%s%s%s",
                   datadir,
                   DIR_SEPARATOR_STR,
                   "gns-bcd-simple.tex");
  GNUNET_asprintf (&tex_file_png,
                   "%s%s%s",
                   datadir,
                   DIR_SEPARATOR_STR,
                   "gns-bcd-png.tex");
 
  index_simple = open_static_resource ("gns-bcd-simple.html", datadir);
  index_full = open_static_resource ("gns-bcd.html", datadir);
  key_error = open_static_resource ("gns-bcd-invalid-key.html", datadir);
  notfound_error = open_static_resource ("gns-bcd-not-found.html", datadir);
  internal_error = open_static_resource ("gns-bcd-internal-error.html", datadir)
  ;
  forbidden_error = open_static_resource ("gns-bcd-forbidden.html", datadir);
 
  GNUNET_free (datadir);
 
  if ((NULL == index_simple) || (NULL == index_full)
      || (NULL == key_error) || (NULL == notfound_error)
      || (NULL == internal_error) || (NULL == forbidden_error))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Unable to set up the daemon\n"));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
 
  {
    int flags = MHD_USE_DUAL_STACK | MHD_USE_DEBUG | MHD_ALLOW_SUSPEND_RESUME;
    do
    {
      httpd = MHD_start_daemon (flags,
                                port,
                                NULL, NULL,
                                &create_response, NULL,
                                MHD_OPTION_CONNECTION_LIMIT, 512,
                                MHD_OPTION_PER_IP_CONNECTION_LIMIT, 2,
                                MHD_OPTION_CONNECTION_TIMEOUT, 60,
                                MHD_OPTION_CONNECTION_MEMORY_LIMIT, 16 * 1024,
                                MHD_OPTION_END);
      flags = MHD_USE_DEBUG;
    } while (NULL == httpd && flags != MHD_USE_DEBUG);
  }
  if (NULL == httpd)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to start HTTP server\n"));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
 
  run_httpd ();
}

References _, warningfilter::args, create_response(), DIR_SEPARATOR_STR, do_shutdown(), forbidden_error, GNUNET_asprintf(), GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_OS_installation_get_path(), GNUNET_OS_IPK_DATADIR, GNUNET_OS_project_data_gnunet(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), httpd, index_full, index_simple, internal_error, key_error, notfound_error, open_static_resource(), port, run_httpd(), tex_file_full, tex_file_png, and tex_file_simple.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ main()

int main	(	int	argc,
		char const	argv
	)

The main function for gnunet-gns.

Parameters

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

Returns: 0 ok, 1 on error

Definition at line 673 of file gnunet-bcd.c.

{
  struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_option_uint16 (
      'p',
      "port",
      "PORT",
      gettext_noop ("Run HTTP server on port PORT (default is 8888)"),
      &port),
    GNUNET_GETOPT_OPTION_END,
  };
 
  return ((GNUNET_OK ==
           GNUNET_PROGRAM_run (GNUNET_OS_project_data_gnunet (),
                               argc,
                               argv,
                               "gnunet-bcd",
                               _ ("GNUnet HTTP server to create business cards")
                               ,
                               options,
                               &run,
                               NULL))
          ? 0
          : 1);
}

References _, gettext_noop, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_uint16(), GNUNET_OK, GNUNET_OS_project_data_gnunet(), GNUNET_PROGRAM_run(), options, port, and run().

Here is the call graph for this function:

Variable Documentation

◆ httpd

struct MHD_Daemon* httpd = NULL

static

Handle to the HTTP server as provided by libmicrohttpd.

Definition at line 66 of file gnunet-bcd.c.

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

◆ httpd_task

struct GNUNET_SCHEDULER_Task* httpd_task = NULL

static

Our primary task for the HTTPD.

Definition at line 71 of file gnunet-bcd.c.

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

◆ index_simple

struct StaticResource* index_simple = NULL

static

Index file resource (simple result).

Definition at line 76 of file gnunet-bcd.c.

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

◆ index_full

struct StaticResource* index_full = NULL

static

Index file resource (full result).

Definition at line 81 of file gnunet-bcd.c.

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

◆ key_error

struct StaticResource* key_error = NULL

static

Error: invalid gns key.

Definition at line 86 of file gnunet-bcd.c.

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

◆ notfound_error

struct StaticResource* notfound_error = NULL

static

Error: 404.

Definition at line 91 of file gnunet-bcd.c.

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

◆ internal_error

struct StaticResource* internal_error = NULL

static

Errors after receiving the form data.

Definition at line 96 of file gnunet-bcd.c.

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

◆ forbidden_error

struct StaticResource* forbidden_error = NULL

static

Other errors.

Definition at line 101 of file gnunet-bcd.c.

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

◆ tex_file_simple

char* tex_file_simple = NULL

static

Full path to the TeX template file (simple result)

Definition at line 106 of file gnunet-bcd.c.

Referenced by create_response(), and run().

◆ tex_file_full

char* tex_file_full = NULL

static

Full path to the TeX template file (full result)

Definition at line 111 of file gnunet-bcd.c.

Referenced by create_response(), and run().

◆ tex_file_png

char* tex_file_png = NULL

static

Full path to the TeX template file (PNG result)

Definition at line 116 of file gnunet-bcd.c.

Referenced by create_response(), and run().

◆ continue_100

int continue_100 = 100

static

Used as a sort of singleton to send exactly one 100 CONTINUE per request.

Definition at line 121 of file gnunet-bcd.c.

Referenced by create_response().

◆ pmap

const struct ParameterMap pmap[]

static

Initial value:

= {
  {"prefix", "prefix"},
  {"name", "name"},
  {"suffix", "suffix"},
  {"street", "street"},
  {"city", "city"},
  {"phone", "phone"},
  {"fax", "fax"},
  {"email", "email"},
  {"homepage", "homepage"},
  {"org", "organization"},
  {"department", "department"},
  {"subdepartment", "subdepartment"},
  {"jobtitle", "jobtitle"},
  {NULL, NULL},
}

Map of names with TeX definitions, used during PDF generation.

Definition at line 126 of file gnunet-bcd.c.

Referenced by create_response(), and run().

◆ port

uint16_t port = 8888

static

Port number.

Definition at line 146 of file gnunet-bcd.c.

Referenced by advertise_dns_exit(), client_release_ports(), connect_tunnel(), convert_messenger_key_to_port(), create_channel(), destroy_port_cb(), DHTU_ip_init(), dns_string_to_value(), extract_port(), GC_u2h(), GCCH_bind(), GCCH_channel_local_new(), GCCH_handle_channel_open_ack(), GCCH_hash_port(), get_cadet(), get_server_addresses(), GNUNET_CADET_channel_create(), GNUNET_CADET_open_port(), GNUNET_CLIENT_test(), GNUNET_GNS_service_port_number_to_name(), GNUNET_HOSTLIST_server_start(), GNUNET_NAT_mini_map_start(), GNUNET_NAT_stun_make_request(), GNUNET_NETWORK_test_port_free(), GNUNET_REGEX_ipv4toregexsearch(), GNUNET_REGEX_ipv6toregexsearch(), GNUNET_SOCKS_set_handshake_destination(), GNUNET_STRINGS_to_address_ipv4(), GNUNET_STRINGS_to_address_ipv6(), GNUNET_TESTBED_release_port(), GSC_bind(), GSF_cadet_start_server(), handle_channel_created(), handle_regex_result(), handle_register(), ip_try_connect(), lookup_hole_external(), main(), nat_server_read(), open_listen_socket(), open_port_cb(), open_srv_room(), process_icmp_response(), process_map_output(), reset_cadet(), run(), tcp_address_to_sockaddr(), tcp_address_to_sockaddr_numeric_v4(), tcp_address_to_sockaddr_numeric_v6(), tcp_address_to_sockaddr_port_only(), test_service_configuration(), try_open_exit(), and udp_address_to_sockaddr().

Data Structures

Functions

Variables

Detailed Description

Function Documentation

◆ do_shutdown()

◆ do_httpd()

◆ run_httpd()

◆ create_response()

◆ open_static_resource()

◆ run()

◆ main()

Variable Documentation

◆ httpd

◆ httpd_task

◆ index_simple

◆ index_full

◆ key_error

◆ notfound_error

◆ internal_error

◆ forbidden_error

◆ tex_file_simple

◆ tex_file_full

◆ tex_file_png

◆ continue_100

◆ pmap

◆ port