gnunet-bcd.c File Reference

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

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

Include dependency graph for gnunet-bcd.c:

Go to the source code of this file.

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 155 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 267 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;
 
  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);
 
  int max = -1;
  GNUNET_assert (MHD_YES == MHD_get_fdset (httpd, &rs, &ws, &es, &max));
 
  unsigned MHD_LONG_LONG timeout = 0;
  struct GNUNET_TIME_Relative gtime = GNUNET_TIME_UNIT_FOREVER_REL;
  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 288 of file gnunet-bcd.c.

{
  (void) cls;
  (void) version;
  (void) upload_data;
  (void) upload_data_size;
 
  bool isget = (0 == strcmp (method, MHD_HTTP_METHOD_GET));
  bool ishead = (0 == strcmp (method, MHD_HTTP_METHOD_HEAD));
 
  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);
  }
 
  bool isfull = (0 == strcmp ("/submit/full", url));
  bool issimple = (0 == strcmp ("/submit/simple", url));
 
  if (!isfull && !issimple)
  {
    return MHD_queue_response (connection,
                               MHD_HTTP_NOT_FOUND,
                               notfound_error->response);
  }
 
  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");
 
  struct GNUNET_IDENTITY_PublicKey pk;
  if (NULL == gnskey
      || GNUNET_OK != GNUNET_IDENTITY_public_key_from_string (gnskey, &pk))
  {
    return MHD_queue_response (connection,
                               MHD_HTTP_BAD_REQUEST,
                               key_error->response);
  }
 
  char *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);
  }
 
  char *defpath = NULL;
  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;
  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");
 
  int ret = system (command);
 
  GNUNET_free (command);
 
  if (WIFSIGNALED (ret) || 0 != WEXITSTATUS (ret))
  {
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "system", command);
  }
 
  GNUNET_asprintf (&defpath,
                   "%s%s%s",
                   tmpd,
                   DIR_SEPARATOR_STR,
                   (NULL == qrpng) ? "gns-bcd.pdf" : "gns-bcd.png");
 
  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);
  }
 
  struct stat statret;
  GNUNET_break (0 == stat (defpath, &statret));
 
  GNUNET_free (defpath);
 
  struct MHD_Response *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\""));
  MHD_RESULT 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_DISK_directory_remove(), GNUNET_DISK_mkdtemp(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_IDENTITY_public_key_from_string(), GNUNET_log, GNUNET_log_strerror_file, GNUNET_OK, GNUNET_strdup, GNUNET_strndup, index_full, index_simple, internal_error, key_error, len, MHD_HTTP_BAD_REQUEST, MHD_HTTP_INTERNAL_SERVER_ERROR, MHD_HTTP_NOT_FOUND, MHD_HTTP_NOT_IMPLEMENTED, MHD_HTTP_OK, 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 512 of file gnunet-bcd.c.

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

References DIR_SEPARATOR_STR, removetrailingwhitespace::f, GNUNET_asprintf(), GNUNET_DISK_file_close(), GNUNET_DISK_file_handle_size(), GNUNET_DISK_file_open(), GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_NONE, GNUNET_free, GNUNET_new, GNUNET_SYSERR, 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 561 of file gnunet-bcd.c.

{
  (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);
 
  char *datadir = GNUNET_OS_installation_get_path (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 _, consensus-simulation::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_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 653 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 (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_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 67 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 72 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 77 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 82 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 87 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 92 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 97 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 102 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 107 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 112 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 117 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 122 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 122 of file gnunet-bcd.c.

Referenced by create_response(), and run().

port

uint16_t port = 8888

static

Port number.

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

Referenced by advertise_dns_exit(), associate_shared_service(), client_release_ports(), connect_tunnel(), convert_messenger_key_to_port(), create_channel(), destroy_port_cb(), dns_string_to_value(), extract_port(), GC_u2h(), GCCH_bind(), GCCH_channel_local_new(), GCCH_get_id(), GCCH_handle_channel_open_ack(), gen_rsh_args(), get_cadet(), get_server_addresses(), GNUNET_CADET_channel_create(), GNUNET_CADET_open_port(), GNUNET_CLIENT_test(), GNUNET_CONNECTION_create_from_connect(), GNUNET_HOSTLIST_server_start(), GNUNET_NAT_mini_map_start(), GNUNET_NAT_stun_make_request(), GNUNET_NETWORK_test_port_free(), GNUNET_SOCKS_set_handshake_destination(), GNUNET_TESTBED_controller_start(), GNUNET_TESTBED_host_create(), GNUNET_TESTBED_host_create_with_id(), GNUNET_TESTBED_hosts_load_from_file(), GNUNET_TESTBED_is_host_habitable(), GNUNET_TESTING_release_port(), GNUNET_TUN_ipv4toregexsearch(), GNUNET_TUN_ipv6toregexsearch(), GSF_cadet_start_server(), handle_channel_created(), handle_regex_result(), handle_register(), ip_try_connect(), LEGACY_SERVICE_get_server_addresses(), libgnunet_plugin_dhtu_ip_init(), libgnunet_plugin_transport_udp_init(), 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(), server_configure_plugin(), server_get_addresses(), tcp_address_to_sockaddr(), tcp_address_to_sockaddr_numeric_v4(), tcp_address_to_sockaddr_numeric_v6(), tcp_address_to_sockaddr_port_only(), tcp_plugin_address_pretty_printer(), tcp_plugin_address_to_string(), test_service_configuration(), try_open_exit(), udp_address_to_sockaddr(), udp_address_to_string(), and udp_plugin_address_pretty_printer().