d2/d90/gnunet-bcd_8c_source.html

 /*
      This file is part of GNUnet.
      Copyright (C) 2013 GNUnet e.V.

      GNUnet is free software: you can redistribute it and/or modify it
      under the terms of the GNU Affero General Public License as published
      by the Free Software Foundation, either version 3 of the License,
      or (at your option) any later version.

      GNUnet is distributed in the hope that it will be useful, but
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.

      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.

      SPDX-License-Identifier: AGPL3.0-or-later
  */

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

 #define INVALID_GNSKEY \
   "<html><head><title>Error</title><body>Invalid GNS public key given.</body></html>"

 #define NOT_FOUND \
   "<html><head><title>Error</title><body>404 not found</body></html>"

 static struct MHD_Daemon *daemon_handle;

 static const struct GNUNET_CONFIGURATION_Handle *cfg;

 static struct GNUNET_SCHEDULER_Task *http_task;

 static struct MHD_Response *main_response;

 static struct MHD_Response *invalid_gnskey_response;

 static struct MHD_Response *not_found_response;

 static char *resfile;

 static uint16_t port = 8888;


 struct Entry
 {
   const char *formname;
   const char *texname;
 };


 static MHD_RESULT
 access_handler_callback (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 **con_cls)
 {
   static int dummy;
   static const struct Entry map[] = { { "prefix", "prefix" },
                                       { "name", "name" },
                                       { "suffix", "suffix" },
                                       { "street", "street" },
                                       { "city", "city" },
                                       { "phone", "phone" },
                                       { "fax", "fax" },
                                       { "email", "email" },
                                       { "homepage", "homepage" },
                                       { "orga", "orga" },
                                       { "departmenti18n", "departmentde" },
                                       { "departmenten", "departmenten" },
                                       { "subdepartmenti18n",
                                         "subdepartmentde" },
                                       { "subdepartmenten", "subdepartmenten" },
                                       { "jobtitlei18n", "jobtitlegerman" },
                                       { "jobtitleen", "jobtitleenglish" },
                                       { "subdepartmenten", "subdepartmenten" },
                                       { NULL, NULL } };

   (void) cls;
   (void) version;
   (void) upload_data;
   (void) upload_data_size;
   if (0 != strcmp (method, MHD_HTTP_METHOD_GET))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                 _ ("Refusing `%s' request to HTTP server\n"),
                 method);
     return MHD_NO;
   }
   if (NULL == *con_cls)
   {
     (*con_cls) = &dummy;
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending 100 CONTINUE reply\n");
     return MHD_YES;   /* send 100 continue */
   }
   if (0 == strcasecmp (url, "/"))
     return MHD_queue_response (connection, MHD_HTTP_OK, main_response);
   if (0 == strcasecmp (url, "/submit.pdf"))
   {
     unsigned int i;
     char *p;
     char *tmp;
     char *deffile;
     struct GNUNET_CRYPTO_EcdsaPublicKey pub;
     size_t slen;
     FILE *f;
     struct stat st;
     struct MHD_Response *response;
     int fd;
     MHD_RESULT ret;

     const char *gpg_fp = MHD_lookup_connection_value (connection,
                                                       MHD_GET_ARGUMENT_KIND,
                                                       "gpgfingerprint");
     const char *gns_nick = MHD_lookup_connection_value (connection,
                                                         MHD_GET_ARGUMENT_KIND,
                                                         "gnsnick");
     const char *gnskey =
       MHD_lookup_connection_value (connection, MHD_GET_ARGUMENT_KIND, "gnskey");
     if ((NULL == gnskey) ||
         (GNUNET_OK !=
          GNUNET_CRYPTO_ecdsa_public_key_from_string (gnskey,
                                                      strlen (gnskey),
                                                      &pub)))
     {
       return MHD_queue_response (connection,
                                  MHD_HTTP_OK,
                                  invalid_gnskey_response);
     }
     tmp = GNUNET_DISK_mkdtemp (gnskey);
     if (NULL == tmp)
     {
       GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "mktemp", gnskey);
       return MHD_NO;
     }
     GNUNET_asprintf (&deffile, "%s%s%s", tmp, DIR_SEPARATOR_STR, "def.tex");
     f = fopen (deffile, "w");
     if (NULL == f)
     {
       GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", deffile);
       GNUNET_free (deffile);
       GNUNET_DISK_directory_remove (tmp);
       GNUNET_free (tmp);
       return MHD_NO;
     }
     for (i = 0; NULL != map[i].formname; i++)
     {
       const char *val = MHD_lookup_connection_value (connection,
                                                      MHD_GET_ARGUMENT_KIND,
                                                      map[i].formname);
       if (NULL != val)
         fprintf (f, "\\def\\%s{%s}\n", map[i].texname, val);
       else
         fprintf (f, "\\def\\%s{}\n", map[i].texname);
     }
     if (NULL != gpg_fp)
     {
       char *gpg1;
       char *gpg2;

       slen = strlen (gpg_fp);
       gpg1 = GNUNET_strndup (gpg_fp, slen / 2);
       gpg2 = GNUNET_strdup (&gpg_fp[slen / 2]);
       fprintf (f, "\\def\\gpglineone{%s}\n\\def\\gpglinetwo{%s}\n", gpg1, gpg2);
       GNUNET_free (gpg2);
       GNUNET_free (gpg1);
     }
     fprintf (f,
              "\\def\\gns{%s/%s}\n",
              gnskey,
              (NULL == gns_nick) ? "" : gns_nick);
     fclose (f);
     GNUNET_asprintf (
       &p,
       "cd %s; cp %s gns-bcd.tex | pdflatex --enable-write18 gns-bcd.tex > /dev/null 2> /dev/null",
       tmp,
       resfile);
     GNUNET_free (deffile);
     ret = system (p);
     if (WIFSIGNALED (ret) || (0 != WEXITSTATUS (ret)))
       GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "system", p);
     GNUNET_asprintf (&deffile, "%s%s%s", tmp, DIR_SEPARATOR_STR, "gns-bcd.pdf");
     fd = open (deffile, O_RDONLY);
     if (-1 == fd)
     {
       GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", deffile);
       GNUNET_free (deffile);
       GNUNET_free (p);
       GNUNET_DISK_directory_remove (tmp);
       GNUNET_free (tmp);
       return MHD_NO;
     }
     GNUNET_break (0 == stat (deffile, &st));
     if (NULL ==
         (response = MHD_create_response_from_fd ((size_t) st.st_size, fd)))
     {
       GNUNET_break (0);
       GNUNET_break (0 == close (fd));
       GNUNET_free (deffile);
       GNUNET_free (p);
       GNUNET_DISK_directory_remove (tmp);
       GNUNET_free (tmp);
       return MHD_NO;
     }
     (void) MHD_add_response_header (response,
                                     MHD_HTTP_HEADER_CONTENT_TYPE,
                                     "application/pdf");
     ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
     MHD_destroy_response (response);
     GNUNET_free (deffile);
     GNUNET_free (p);
     GNUNET_DISK_directory_remove (tmp);
     GNUNET_free (tmp);
     return ret;
   }
   return MHD_queue_response (connection,
                              MHD_HTTP_NOT_FOUND,
                              not_found_response);
 }


 static struct GNUNET_SCHEDULER_Task *
 prepare_daemon (struct MHD_Daemon *daemon_handle);


 static void
 run_daemon (void *cls)
 {
   struct MHD_Daemon *daemon_handle = cls;

   http_task = NULL;
   GNUNET_assert (MHD_YES == MHD_run (daemon_handle));
   http_task = prepare_daemon (daemon_handle);
 }


 static struct GNUNET_SCHEDULER_Task *
 prepare_daemon (struct MHD_Daemon *daemon_handle)
 {
   struct GNUNET_SCHEDULER_Task *ret;
   fd_set rs;
   fd_set ws;
   fd_set es;
   struct GNUNET_NETWORK_FDSet *wrs;
   struct GNUNET_NETWORK_FDSet *wws;
   int max;
   MHD_UNSIGNED_LONG_LONG timeout;
   int haveto;
   struct GNUNET_TIME_Relative tv;

   FD_ZERO (&rs);
   FD_ZERO (&ws);
   FD_ZERO (&es);
   wrs = GNUNET_NETWORK_fdset_create ();
   wws = GNUNET_NETWORK_fdset_create ();
   max = -1;
   GNUNET_assert (MHD_YES == MHD_get_fdset (daemon_handle, &rs, &ws, &es, &max));
   haveto = MHD_get_timeout (daemon_handle, &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);
   ret = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH,
                                      tv,
                                      wrs,
                                      wws,
                                      &run_daemon,
                                      daemon_handle);
   GNUNET_NETWORK_fdset_destroy (wrs);
   GNUNET_NETWORK_fdset_destroy (wws);
   return ret;
 }


 static int
 server_start ()
 {
   if (0 == port)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 _ ("Invalid port number %u.  Exiting.\n"),
                 port);
     return GNUNET_SYSERR;
   }
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               _ ("Businesscard HTTP server starts on %u\n"),
               port);
   daemon_handle = MHD_start_daemon (MHD_USE_DUAL_STACK | MHD_USE_DEBUG,
                                     port,
                                     NULL /* accept_policy_callback */,
                                     NULL,
                                     &access_handler_callback,
                                     NULL,
                                     MHD_OPTION_CONNECTION_LIMIT,
                                     (unsigned int) 512,
                                     MHD_OPTION_PER_IP_CONNECTION_LIMIT,
                                     (unsigned int) 2,
                                     MHD_OPTION_CONNECTION_TIMEOUT,
                                     (unsigned int) 60,
                                     MHD_OPTION_CONNECTION_MEMORY_LIMIT,
                                     (size_t) (16 * 1024),
                                     MHD_OPTION_END);
   if (NULL == daemon_handle)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 _ ("Could not start businesscard HTTP server on port %u\n"),
                 (unsigned int) port);
     return GNUNET_SYSERR;
   }
   http_task = prepare_daemon (daemon_handle);
   return GNUNET_OK;
 }


 static void
 server_stop (void *cls)
 {
   (void) cls;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "HTTP server shutdown\n");
   if (NULL != http_task)
   {
     GNUNET_SCHEDULER_cancel (http_task);
     http_task = NULL;
   }
   if (NULL != daemon_handle)
   {
     MHD_stop_daemon (daemon_handle);
     daemon_handle = NULL;
   }
   if (NULL != main_response)
   {
     MHD_destroy_response (main_response);
     main_response = NULL;
   }
   if (NULL != invalid_gnskey_response)
   {
     MHD_destroy_response (invalid_gnskey_response);
     invalid_gnskey_response = NULL;
   }
   if (NULL != not_found_response)
   {
     MHD_destroy_response (not_found_response);
     not_found_response = NULL;
   }
   if (NULL != resfile)
   {
     GNUNET_free (resfile);
     resfile = NULL;
   }
 }


 static void
 run (void *cls,
      char *const *args,
      const char *cfgfile,
      const struct GNUNET_CONFIGURATION_Handle *c)
 {
   struct stat st;
   char *dir;
   char *fn;
   int fd;

   (void) cls;
   (void) args;
   (void) cfgfile;
   cfg = c;
   dir = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_DATADIR);
   GNUNET_assert (NULL != dir);
   GNUNET_asprintf (&fn, "%s%s%s", dir, DIR_SEPARATOR_STR, "gns-bcd.html");
   GNUNET_asprintf (&resfile, "%s%s%s", dir, DIR_SEPARATOR_STR, "gns-bcd.tex");
   GNUNET_free (dir);
   fd = open (fn, O_RDONLY);
   if (-1 == fd)
   {
     GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", fn);
     GNUNET_free (fn);
     return;
   }
   if (0 != stat (fn, &st))
   {
     GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", fn);
     GNUNET_free (fn);
     GNUNET_break (0 == close (fd));
     return;
   }
   GNUNET_free (fn);
   if (NULL ==
       (main_response = MHD_create_response_from_fd ((size_t) st.st_size, fd)))
   {
     GNUNET_break (0);
     GNUNET_break (0 == close (fd));
     return;
   }
   (void) MHD_add_response_header (main_response,
                                   MHD_HTTP_HEADER_CONTENT_TYPE,
                                   "text/html");
   invalid_gnskey_response =
     MHD_create_response_from_buffer (strlen (INVALID_GNSKEY),
                                      INVALID_GNSKEY,
                                      MHD_RESPMEM_PERSISTENT);
   (void) MHD_add_response_header (invalid_gnskey_response,
                                   MHD_HTTP_HEADER_CONTENT_TYPE,
                                   "text/html");
   not_found_response = MHD_create_response_from_buffer (strlen (NOT_FOUND),
                                                         NOT_FOUND,
                                                         MHD_RESPMEM_PERSISTENT);
   (void) MHD_add_response_header (not_found_response,
                                   MHD_HTTP_HEADER_CONTENT_TYPE,
                                   "text/html");
   if (GNUNET_OK != server_start ())
     return;
   GNUNET_SCHEDULER_add_shutdown (&server_stop, NULL);
 }


 int
 main (int argc, char *const *argv)
 {
   struct GNUNET_GETOPT_CommandLineOption options[] = {
     GNUNET_GETOPT_option_uint16 ('p',
                                  "port",
                                  "PORT",
                                  gettext_noop (
                                    "Run HTTP serve on port PORT (default is 8888)"),
                                  &port),
     GNUNET_GETOPT_OPTION_END
   };
   int ret;

   if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
     return 2;
   GNUNET_log_setup ("gnunet-bcd", "WARNING", NULL);
   ret = (GNUNET_OK ==
          GNUNET_PROGRAM_run (argc,
                              argv,
                              "gnunet-bcd",
                              _ ("GNUnet HTTP server to create business cards"),
                              options,
                              &run,
                              NULL))
         ? 0
         : 1;
   GNUNET_free_nz ((void *) argv);
   return ret;
 }


 /* end of gnunet-bcd.c */
cfg
static const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-bcd.c:52

daemon_handle
static struct MHD_Daemon * daemon_handle
Handle to the HTTP server as provided by libmicrohttpd.
Definition: gnunet-bcd.c:47

dir
static char * dir
Set to the directory where runtime files are stored.
Definition: gnunet-arm.c:89

invalid_gnskey_response
static struct MHD_Response * invalid_gnskey_response
Error: invalid gns key.
Definition: gnunet-bcd.c:67

GNUNET_SCHEDULER_PRIORITY_HIGH
Run with high priority (important requests).
Definition: gnunet_common.h:1746

removetrailingwhitespace.f
f
Definition: removetrailingwhitespace.py:8

GNUNET_TIME_Relative::rel_value_us
uint64_t rel_value_us
The actual value.
Definition: gnunet_time_lib.h:65

gnunet_mhd_compat.h

main
int main(int argc, char *const *argv)
The main function for gnunet-gns.
Definition: gnunet-bcd.c:502

run
static void run(void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
Main function that will be run.
Definition: gnunet-bcd.c:431

NOT_FOUND
#define NOT_FOUND
Error page to display on 404.
Definition: gnunet-bcd.c:41

not_found_response
static struct MHD_Response * not_found_response
Error: 404.
Definition: gnunet-bcd.c:72

GNUNET_SCHEDULER_add_shutdown
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received, or when GNUNET_SCHEDULER_shutdown() is being invoked.
Definition: scheduler.c:1331

GNUNET_STRINGS_get_utf8_args
int GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1459

GNUNET_assert
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Definition: gnunet_common.h:853

http_task
static struct GNUNET_SCHEDULER_Task * http_task
Our primary task for the HTTPD.
Definition: gnunet-bcd.c:57

ret
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81

server_start
static int server_start()
Start server offering our hostlist.
Definition: gnunet-bcd.c:342

GNUNET_GETOPT_CommandLineOption
Definition of a command line option.
Definition: gnunet_getopt_lib.h:100

Entry::texname
const char * texname
Definition: gnunet-bcd.c:88

platform.h

gnunet_util_lib.h

GNUNET_strdup
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
Definition: gnunet_common.h:1336

GNUNET_break
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Definition: gnunet_common.h:934

GNUNET_GETOPT_OPTION_END
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13

GNUNET_NETWORK_fdset_copy_native
void GNUNET_NETWORK_fdset_copy_native(struct GNUNET_NETWORK_FDSet *to, const fd_set *from, int nfds)
Copy a native fd set into the GNUnet representation.
Definition: network.c:1120

_
#define _(String)
GNU gettext support macro.
Definition: platform.h:184

GNUNET_NETWORK_fdset_destroy
void GNUNET_NETWORK_fdset_destroy(struct GNUNET_NETWORK_FDSet *fds)
Releases the associated memory of an fd set.
Definition: network.c:1266

GNUNET_NETWORK_fdset_create
struct GNUNET_NETWORK_FDSet * GNUNET_NETWORK_fdset_create(void)
Creates an fd set.
Definition: network.c:1250

GNUNET_OK
Definition: gnunet_common.h:87

timeout
static struct GNUNET_TIME_Relative timeout
Desired timeout for the lookup (default is no timeout).
Definition: gnunet-abd.c:61

p
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59

GNUNET_log_strerror_file
#define GNUNET_log_strerror_file(level, cmd, filename)
Log an error message at log-level &#39;level&#39; that indicates a failure of the command &#39;cmd&#39; with the mess...
Definition: gnunet_common.h:1012

fn
static char * fn
Filename of the unique file.
Definition: gnunet_testbed_mpi_spawn.c:41

DIR_SEPARATOR_STR
#define DIR_SEPARATOR_STR
Definition: platform.h:171

GNUNET_DISK_directory_remove
int GNUNET_DISK_directory_remove(const char *filename)
Remove all files in a directory (rm -rf).
Definition: disk.c:1028

GNUNET_OS_installation_get_path
char * GNUNET_OS_installation_get_path(enum GNUNET_OS_InstallationPathKind dirkind)
Get the path to a specific GNUnet installation directory or, with GNUNET_OS_IPK_SELF_PREFIX, the current running apps installation directory.
Definition: os_installation.c:446

GNUNET_NETWORK_FDSet
collection of IO descriptors
Definition: gnunet_network_lib.h:58

GNUNET_SCHEDULER_add_select
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_select(enum GNUNET_SCHEDULER_Priority prio, struct GNUNET_TIME_Relative delay, const struct GNUNET_NETWORK_FDSet *rs, const struct GNUNET_NETWORK_FDSet *ws, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when any of the specified file descriptor set...
Definition: scheduler.c:1841

access_handler_callback
static MHD_RESULT access_handler_callback(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 **con_cls)
Main request handler.
Definition: gnunet-bcd.c:96

GNUNET_TIME_UNIT_FOREVER_REL
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
Definition: gnunet_time_lib.h:157

GNUNET_SYSERR
Definition: gnunet_common.h:85

GNUNET_asprintf
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.

GNUNET_free_nz
#define GNUNET_free_nz(ptr)
Wrapper around free.
Definition: gnunet_common.h:1308

GNUNET_DISK_mkdtemp
char * GNUNET_DISK_mkdtemp(const char *t)
Create an (empty) temporary directory on disk.
Definition: disk.c:409

Entry::formname
const char * formname
Definition: gnunet-bcd.c:87

MHD_RESULT
#define MHD_RESULT
Data type to use for functions return an "MHD result".
Definition: gnunet_mhd_compat.h:41

prepare_daemon
static struct GNUNET_SCHEDULER_Task * prepare_daemon(struct MHD_Daemon *daemon_handle)
Function that queries MHD&#39;s select sets and starts the task waiting for them.
Definition: gnunet-bcd.c:297

main_response
static struct MHD_Response * main_response
Our main website.
Definition: gnunet-bcd.c:62

dummy
static struct in_addr dummy
Target "dummy" address of the packet we pretend to respond to.
Definition: gnunet-helper-nat-client.c:199

GNUNET_strndup
#define GNUNET_strndup(a, length)
Wrapper around GNUNET_xstrndup_.
Definition: gnunet_common.h:1347

GNUNET_CRYPTO_ecdsa_public_key_from_string
int GNUNET_CRYPTO_ecdsa_public_key_from_string(const char *enc, size_t enclen, struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Convert a string representing a public key to a public key.
Definition: crypto_ecc.c:366

GNUNET_ERROR_TYPE_WARNING
Definition: gnunet_common.h:392

port
static uint16_t port
Port number.
Definition: gnunet-bcd.c:82

GNUNET_CONFIGURATION_Handle
configuration data
Definition: configuration.c:84

GNUNET_ERROR_TYPE_INFO
Definition: gnunet_common.h:397

GNUNET_CRYPTO_EcdsaPublicKey
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
Definition: gnunet_crypto_lib.h:206

gnunet-chk.args
args
Definition: gnunet-chk.py:369

GNUNET_log
#define GNUNET_log(kind,...)
Definition: gnunet_common.h:521

GNUNET_SCHEDULER_Task
Entry in list of pending tasks.
Definition: scheduler.c:134

GNUNET_ERROR_TYPE_DEBUG
Definition: gnunet_common.h:398

response
static struct MHD_Response * response
Our canonical response.
Definition: gnunet-daemon-hostlist_server.c:89

GNUNET_PROGRAM_run
int GNUNET_PROGRAM_run(int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls)
Run a standard GNUnet command startup sequence (initialize loggers and configuration, parse options).
Definition: program.c:372

server_stop
static void server_stop(void *cls)
Stop HTTP server.
Definition: gnunet-bcd.c:385

GNUNET_ERROR_TYPE_ERROR
Definition: gnunet_common.h:391

GNUNET_log_setup
int GNUNET_log_setup(const char *comp, const char *loglevel, const char *logfile)
Setup logging.
Definition: common_logging.c:708

resfile
static char * resfile
Absolute name of the &#39;gns-bcd.tex&#39; file.
Definition: gnunet-bcd.c:77

Entry
Entry type to be used in the map to store old latency values.
Definition: gnunet-bcd.c:85

run_daemon
static void run_daemon(void *cls)
Call MHD to process pending requests and then go back and schedule the next run.
Definition: gnunet-bcd.c:282

GNUNET_OS_IPK_DATADIR
Return the directory where data is installed (share/gnunet/)
Definition: gnunet_os_lib.h:141

GNUNET_free
#define GNUNET_free(ptr)
Wrapper around free.
Definition: gnunet_common.h:1322

GNUNET_TIME_Relative
Time for relative time used by GNUnet, in microseconds.
Definition: gnunet_time_lib.h:60

GNUNET_GETOPT_option_uint16
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_uint16(char shortName, const char *name, const char *argumentHelp, const char *description, uint16_t *val)
Allow user to specify an uint16_t.
Definition: getopt_helpers.c:951

gettext_noop
#define gettext_noop(String)
Definition: gettext.h:69

GNUNET_SCHEDULER_cancel
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972

INVALID_GNSKEY
#define INVALID_GNSKEY
Error page to display if submitted GNS key is invalid.
Definition: gnunet-bcd.c:35