GNUnet  0.11.x
gnunet-namestore-fcfsd.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2012-2014 GNUnet e.V.
4 
5  GNUnet is free software: you can redistribute it and/or modify it
6  under the terms of the GNU Affero General Public License as published
7  by the Free Software Foundation, either version 3 of the License,
8  or (at your option) any later version.
9 
10  GNUnet is distributed in the hope that it will be useful, but
11  WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  Affero General Public License for more details.
14 
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>.
17 
18  SPDX-License-Identifier: AGPL3.0-or-later
19  */
33 #include "platform.h"
34 #include <microhttpd.h>
35 #include "gnunet_util_lib.h"
37 #include "gnunet_gnsrecord_lib.h"
39 #include "gnunet_mhd_compat.h"
40 
44 #define METHOD_ERROR \
45  "<!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>"
46 
50 #define MAIN_PAGE \
51  "<!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>"
52 
56 #define SUBMIT_PAGE \
57  "<!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>"
58 
62 #define ZONEINFO_PAGE \
63  "<!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>"
64 
65 #define FCFS_ZONEINFO_URL "/Zoneinfo"
66 
70 #define MIME_HTML "text/html"
71 
75 #define COOKIE_NAME "namestore-fcfsd"
76 
77 #define DEFAULT_ZONEINFO_BUFSIZE 2048
78 
82 enum Phase
83 {
87  RP_START = 0,
88 
93 
98 
103 
108 };
109 
110 
114 struct Request
115 {
119  // FIXME: struct Session *session;
120 
125  struct MHD_PostProcessor *pp;
126 
130  struct MHD_Connection *con;
135  const char *post_url;
136 
141 
151 
155  enum Phase phase;
156 
160  char domain_name[64];
161 
165  char public_key[128];
166 
168 };
169 
174 {
179 
183  char*zoneinfo;
184 
188  size_t buf_len;
189 
193  size_t write_offset;
194 };
195 
199 static struct MHD_Daemon *httpd;
200 
205 
210 
215 
220 
224 static struct MHD_Response *info_page;
225 
230 
235 
239 static unsigned long long port;
240 
244 static char *zone;
245 
246 
252 static void
253 do_httpd (void *cls);
254 
255 
259 static void
261 {
262  if (NULL != httpd_task)
263  {
264  GNUNET_SCHEDULER_cancel (httpd_task);
265  httpd_task = NULL;
266  }
267  httpd_task = GNUNET_SCHEDULER_add_now (&do_httpd, NULL);
268 }
269 
270 
274 static void
275 update_zoneinfo_page (void *cls);
276 
277 
281 static void
283 {
284  struct ZoneinfoRequest *zr = cls;
285 
286  zr->list_it = NULL;
287  GNUNET_free (zr->zoneinfo);
288  GNUNET_SCHEDULER_cancel (uzp_task);
290  NULL);
291 }
292 
293 
297 static void
299 {
300  struct ZoneinfoRequest *zr = cls;
301  struct MHD_Response *response;
302  char*full_page;
303 
304  zr->list_it = NULL;
305 
306  /* return static form */
307  GNUNET_asprintf (&full_page,
309  zr->zoneinfo,
310  zr->zoneinfo);
311  response = MHD_create_response_from_buffer (strlen (full_page),
312  (void *) full_page,
313  MHD_RESPMEM_MUST_FREE);
314  MHD_add_response_header (response,
315  MHD_HTTP_HEADER_CONTENT_TYPE,
316  MIME_HTML);
317  MHD_destroy_response (info_page);
319  GNUNET_free (zr->zoneinfo);
320 }
321 
322 
333 static void
334 iterate_cb (void *cls,
335  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
336  const char *name,
337  unsigned int rd_len,
338  const struct GNUNET_GNSRECORD_Data *rd)
339 {
340  struct ZoneinfoRequest *zr = cls;
341  size_t bytes_free;
342  char*pkey;
343  char*new_buf;
344 
345  (void) zone_key;
346  if (1 != rd_len)
347  {
349  1);
350  return;
351  }
352 
354  {
356  1);
357  return;
358  }
359 
360  bytes_free = zr->buf_len - zr->write_offset;
362  rd->data,
363  rd->data_size);
364  if (NULL == pkey)
365  {
366  GNUNET_break (0);
368  1);
369  return;
370  }
371  if (bytes_free < (strlen (name) + strlen (pkey) + 40))
372  {
373  new_buf = GNUNET_malloc (zr->buf_len * 2);
374  GNUNET_memcpy (new_buf, zr->zoneinfo, zr->write_offset);
375  GNUNET_free (zr->zoneinfo);
376  zr->zoneinfo = new_buf;
377  zr->buf_len *= 2;
378  }
379  sprintf (zr->zoneinfo + zr->write_offset,
380  "<tr><td>%s</td><td>%s</td></tr>",
381  name,
382  pkey);
383  zr->write_offset = strlen (zr->zoneinfo);
385  1);
386  GNUNET_free (pkey);
387 }
388 
389 
395 static int
396 serve_zoneinfo_page (struct MHD_Connection *connection)
397 {
398  return MHD_queue_response (connection,
399  MHD_HTTP_OK,
400  info_page);
401 }
402 
403 
407 static void
409 {
410  static struct ZoneinfoRequest zr;
411 
412  (void) cls;
415  NULL);
416  if (NULL != zr.list_it)
417  return;
420  zr.write_offset = 0;
424  &zr,
425  &iterate_cb,
426  &zr,
428  &zr);
429 }
430 
431 
438 static int
439 serve_main_page (struct MHD_Connection *connection)
440 {
441  int ret;
442  struct MHD_Response *response;
443 
444  /* return static form */
445  response = MHD_create_response_from_buffer (strlen (MAIN_PAGE),
446  (void *) MAIN_PAGE,
447  MHD_RESPMEM_PERSISTENT);
448  MHD_add_response_header (response,
449  MHD_HTTP_HEADER_CONTENT_TYPE,
450  MIME_HTML);
451  ret = MHD_queue_response (connection,
452  MHD_HTTP_OK,
453  response);
454  MHD_destroy_response (response);
455  return ret;
456 }
457 
458 
466 static int
467 fill_s_reply (const char *info,
468  struct Request *request,
469  struct MHD_Connection *connection)
470 {
471  int ret;
472  char *reply;
473  struct MHD_Response *response;
474 
475  (void) request;
476  GNUNET_asprintf (&reply,
477  SUBMIT_PAGE,
478  info,
479  info);
480  /* return static form */
481  response = MHD_create_response_from_buffer (strlen (reply),
482  (void *) reply,
483  MHD_RESPMEM_MUST_FREE);
484  MHD_add_response_header (response,
485  MHD_HTTP_HEADER_CONTENT_TYPE,
486  MIME_HTML);
487  ret = MHD_queue_response (connection,
488  MHD_HTTP_OK,
489  response);
490  MHD_destroy_response (response);
491  return ret;
492 }
493 
494 
514 static MHD_RESULT
515 post_iterator (void *cls,
516  enum MHD_ValueKind kind,
517  const char *key,
518  const char *filename,
519  const char *content_type,
520  const char *transfer_encoding,
521  const char *data,
522  uint64_t off,
523  size_t size)
524 {
525  struct Request *request = cls;
526 
527  (void) kind;
528  (void) filename;
529  (void) content_type;
530  (void) transfer_encoding;
531  if (0 == strcmp ("domain", key))
532  {
533  if (size + off >= sizeof(request->domain_name))
534  size = sizeof(request->domain_name) - off - 1;
535  GNUNET_memcpy (&request->domain_name[off],
536  data,
537  size);
538  request->domain_name[size + off] = '\0';
539  return MHD_YES;
540  }
541  if (0 == strcmp ("pkey", key))
542  {
543  if (size + off >= sizeof(request->public_key))
544  size = sizeof(request->public_key) - off - 1;
545  GNUNET_memcpy (&request->public_key[off],
546  data,
547  size);
548  request->public_key[size + off] = '\0';
549  return MHD_YES;
550  }
552  _ ("Unsupported form value `%s'\n"),
553  key);
554  return MHD_YES;
555 }
556 
557 
568 static void
569 put_continuation (void *cls,
570  int32_t success,
571  const char *emsg)
572 {
573  struct Request *request = cls;
574 
575  request->qe = NULL;
576  if (0 >= success)
577  {
579  _ ("Failed to create record for domain `%s': %s\n"),
580  request->domain_name,
581  emsg);
582  request->phase = RP_FAIL;
583  }
584  else
585  request->phase = RP_SUCCESS;
586  MHD_resume_connection (request->con);
587  run_httpd_now ();
588 }
589 
590 
594 static void
596 {
597  struct Request *request = cls;
598 
600  _ ("Error when mapping zone to name\n"));
601  request->phase = RP_FAIL;
602  MHD_resume_connection (request->con);
603  run_httpd_now ();
604 }
605 
606 
616 static void
617 zone_to_name_cb (void *cls,
618  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
619  const char *name,
620  unsigned int rd_count,
621  const struct GNUNET_GNSRECORD_Data *rd)
622 {
623  struct Request *request = cls;
624  struct GNUNET_GNSRECORD_Data r;
625 
626  (void) rd;
627  (void) zone_key;
628  request->qe = NULL;
629  if (0 != rd_count)
630  {
632  _ ("Found existing name `%s' for the given key\n"),
633  name);
634  request->phase = RP_FAIL;
635  MHD_resume_connection (request->con);
636  run_httpd_now ();
637  return;
638  }
639  r.data = &request->pub;
640  r.data_size = sizeof(request->pub);
641  r.expiration_time = UINT64_MAX;
644  request->qe = GNUNET_NAMESTORE_records_store (ns,
646  request->domain_name,
647  1, &r,
649  request);
650 }
651 
652 
656 static void
657 lookup_it_error (void *cls)
658 {
659  struct Request *request = cls;
660 
661  MHD_resume_connection (request->con);
662  request->qe = NULL;
663  request->phase = RP_FAIL;
664  run_httpd_now ();
665 }
666 
667 
678 static void
680  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zonekey,
681  const char *label,
682  unsigned int rd_count,
683  const struct GNUNET_GNSRECORD_Data *rd)
684 {
685  struct Request *request = cls;
686 
687  (void) label;
688  (void) rd;
689  (void) zonekey;
690  if (0 == strcmp (label, request->domain_name))
691  {
692  GNUNET_break (0 != rd_count);
694  _ ("Found %u existing records for domain `%s'\n"),
695  rd_count,
696  request->domain_name);
697  request->phase = RP_FAIL;
698  }
700 }
701 
702 
703 static void
705 {
706  struct Request *request = cls;
707 
708  if (RP_FAIL == request->phase)
709  {
710  MHD_resume_connection (request->con);
711  run_httpd_now ();
712  return;
713  }
714  if (GNUNET_OK !=
716  strlen (request->public_key),
717  &request->pub))
718  {
719  GNUNET_break (0);
720  request->phase = RP_FAIL;
721  MHD_resume_connection (request->con);
722  run_httpd_now ();
723  return;
724  }
725  request->qe = GNUNET_NAMESTORE_zone_to_name (ns,
727  &request->pub,
729  request,
731  request);
732 }
733 
734 
758 static MHD_RESULT
759 create_response (void *cls,
760  struct MHD_Connection *connection,
761  const char *url,
762  const char *method,
763  const char *version,
764  const char *upload_data,
765  size_t *upload_data_size,
766  void **ptr)
767 {
768  struct MHD_Response *response;
769  struct Request *request;
770  struct GNUNET_CRYPTO_EcdsaPublicKey pub;
771  MHD_RESULT ret;
772 
773  (void) cls;
774  (void) version;
775  if ((0 == strcmp (method, MHD_HTTP_METHOD_GET)) ||
776  (0 == strcmp (method, MHD_HTTP_METHOD_HEAD)))
777  {
778  if (0 == strcmp (url, FCFS_ZONEINFO_URL))
779  ret = serve_zoneinfo_page (connection);
780  else
781  ret = serve_main_page (connection);
782  if (ret != MHD_YES)
784  _ ("Failed to create page for `%s'\n"),
785  url);
786  return ret;
787  }
788  if (0 == strcmp (method, MHD_HTTP_METHOD_POST))
789  {
790  request = *ptr;
791  if (NULL == request)
792  {
793  request = GNUNET_new (struct Request);
794  request->con = connection;
795  *ptr = request;
796  request->pp = MHD_create_post_processor (connection,
797  1024,
798  &post_iterator,
799  request);
800  if (NULL == request->pp)
801  {
803  _ ("Failed to setup post processor for `%s'\n"),
804  url);
805  return MHD_NO; /* internal error */
806  }
807  return MHD_YES;
808  }
809  if (NULL != request->pp)
810  {
811  /* evaluate POST data */
812  MHD_post_process (request->pp,
813  upload_data,
814  *upload_data_size);
815  if (0 != *upload_data_size)
816  {
817  *upload_data_size = 0;
818  return MHD_YES;
819  }
820  /* done with POST data, serve response */
821  MHD_destroy_post_processor (request->pp);
822  request->pp = NULL;
823  }
824  if (GNUNET_OK !=
826  strlen (
827  request->public_key),
828  &pub))
829  {
830  /* parse error */
831  return fill_s_reply ("Failed to parse given public key",
832  request, connection);
833  }
834  switch (request->phase)
835  {
836  case RP_START:
837  if (NULL != strchr (request->domain_name, (int) '.'))
838  {
840  _ ("Domain name must not contain `.'\n"));
841  request->phase = RP_FAIL;
842  return fill_s_reply ("Domain name must not contain `.', sorry.",
843  request,
844  connection);
845  }
846  if (NULL != strchr (request->domain_name, (int) '+'))
847  {
849  _ ("Domain name must not contain `+'\n"));
850  request->phase = RP_FAIL;
851  return fill_s_reply ("Domain name must not contain `+', sorry.",
852  request, connection);
853  }
854  request->phase = RP_LOOKUP;
855  MHD_suspend_connection (request->con);
856  request->lookup_it
860  request,
862  request,
864  request);
865  break;
866 
867  case RP_LOOKUP:
868  break;
869 
870  case RP_PUT:
871  break;
872 
873  case RP_FAIL:
874  return fill_s_reply ("Request failed, sorry.",
875  request, connection);
876 
877  case RP_SUCCESS:
878  return fill_s_reply ("Success.",
879  request, connection);
880 
881  default:
882  GNUNET_break (0);
883  return MHD_NO;
884  }
885  return MHD_YES; /* will have a reply later... */
886  }
887  /* unsupported HTTP method */
888  response = MHD_create_response_from_buffer (strlen (METHOD_ERROR),
889  (void *) METHOD_ERROR,
890  MHD_RESPMEM_PERSISTENT);
891  ret = MHD_queue_response (connection,
892  MHD_HTTP_NOT_ACCEPTABLE,
893  response);
894  MHD_destroy_response (response);
895  return ret;
896 }
897 
898 
908 static void
910  struct MHD_Connection *connection,
911  void **con_cls,
912  enum MHD_RequestTerminationCode toe)
913 {
914  struct Request *request = *con_cls;
915 
916  (void) cls;
917  (void) connection;
918  (void) toe;
919  if (NULL == request)
920  return;
921  if (NULL != request->pp)
922  MHD_destroy_post_processor (request->pp);
923  if (NULL != request->qe)
924  GNUNET_NAMESTORE_cancel (request->qe);
925  GNUNET_free (request);
926 }
927 
928 
929 #define UNSIGNED_MHD_LONG_LONG unsigned MHD_LONG_LONG
930 
931 
935 static void
937 {
938  fd_set rs;
939  fd_set ws;
940  fd_set es;
941  struct GNUNET_NETWORK_FDSet *wrs;
942  struct GNUNET_NETWORK_FDSet *wws;
943  struct GNUNET_NETWORK_FDSet *wes;
944  int max;
945  int haveto;
947  struct GNUNET_TIME_Relative tv;
948 
949  FD_ZERO (&rs);
950  FD_ZERO (&ws);
951  FD_ZERO (&es);
955  max = -1;
956  GNUNET_assert (MHD_YES ==
957  MHD_get_fdset (httpd,
958  &rs,
959  &ws,
960  &es,
961  &max));
962  haveto = MHD_get_timeout (httpd,
963  &timeout);
964  if (haveto == MHD_YES)
965  tv.rel_value_us = (uint64_t) timeout * 1000LL;
966  else
969  &rs,
970  max + 1);
972  &ws,
973  max + 1);
975  &es,
976  max + 1);
977  httpd_task =
979  tv,
980  wrs,
981  wws,
982  &do_httpd,
983  NULL);
987 }
988 
989 
995 static void
996 do_httpd (void *cls)
997 {
998  (void) cls;
999  httpd_task = NULL;
1000  MHD_run (httpd);
1001  run_httpd ();
1002 }
1003 
1004 
1010 static void
1011 do_shutdown (void *cls)
1012 {
1013  (void) cls;
1014  if (NULL != httpd_task)
1015  {
1016  GNUNET_SCHEDULER_cancel (httpd_task);
1017  httpd_task = NULL;
1018  }
1019  if (NULL != uzp_task)
1020  {
1021  GNUNET_SCHEDULER_cancel (uzp_task);
1022  uzp_task = NULL;
1023  }
1024  if (NULL != ns)
1025  {
1027  ns = NULL;
1028  }
1029  if (NULL != httpd)
1030  {
1031  MHD_stop_daemon (httpd);
1032  httpd = NULL;
1033  }
1034  if (NULL != id_op)
1035  {
1036  GNUNET_IDENTITY_cancel (id_op);
1037  id_op = NULL;
1038  }
1039  if (NULL != identity)
1040  {
1041  GNUNET_IDENTITY_disconnect (identity);
1042  identity = NULL;
1043  }
1044 }
1045 
1046 
1066 static void
1067 identity_cb (void *cls,
1068  struct GNUNET_IDENTITY_Ego *ego,
1069  void **ctx,
1070  const char *name)
1071 {
1072  int options;
1073 
1074  (void) cls;
1075  (void) ctx;
1076  if (NULL == name)
1077  return;
1078  if (0 != strcmp (name,
1079  zone))
1080  return;
1081  if (NULL == ego)
1082  {
1084  _ ("No ego configured for `fcfsd` subsystem\n"));
1086  return;
1087  }
1089 
1090  options = MHD_USE_DUAL_STACK | MHD_USE_DEBUG | MHD_ALLOW_SUSPEND_RESUME;
1091  do
1092  {
1093  httpd = MHD_start_daemon (options,
1094  (uint16_t) port,
1095  NULL, NULL,
1096  &create_response, NULL,
1097  MHD_OPTION_CONNECTION_LIMIT, (unsigned int) 128,
1098  MHD_OPTION_PER_IP_CONNECTION_LIMIT, (unsigned
1099  int) 1,
1100  MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 16,
1101  MHD_OPTION_CONNECTION_MEMORY_LIMIT, (size_t) (4
1102  *
1103  1024),
1104  MHD_OPTION_NOTIFY_COMPLETED,
1106  MHD_OPTION_END);
1107  if (MHD_USE_DEBUG == options)
1108  break;
1109  options = MHD_USE_DEBUG;
1110  }
1111  while (NULL == httpd);
1112  if (NULL == httpd)
1113  {
1115  _ ("Failed to start HTTP server\n"));
1117  return;
1118  }
1119  run_httpd ();
1120 }
1121 
1122 
1131 static void
1132 run (void *cls,
1133  char *const *args,
1134  const char *cfgfile,
1135  const struct GNUNET_CONFIGURATION_Handle *cfg)
1136 {
1137  (void) cls;
1138  (void) args;
1139  (void) cfgfile;
1140  if (GNUNET_OK !=
1142  "fcfsd",
1143  "HTTPPORT",
1144  &port))
1145  {
1147  "fcfsd", "HTTPPORT");
1148  return;
1149  }
1150  ns = GNUNET_NAMESTORE_connect (cfg);
1151  if (NULL == ns)
1152  {
1154  _ ("Failed to connect to namestore\n"));
1155  return;
1156  }
1157  identity = GNUNET_IDENTITY_connect (cfg,
1158  &identity_cb,
1159  NULL);
1160  if (NULL == identity)
1161  {
1163  _ ("Failed to connect to identity\n"));
1164  return;
1165  }
1167  NULL);
1169  NULL);
1170 }
1171 
1172 
1180 int
1181 main (int argc,
1182  char *const *argv)
1183 {
1184  struct GNUNET_GETOPT_CommandLineOption options[] = {
1187  "zone",
1188  "EGO",
1189  gettext_noop (
1190  "name of the zone that is to be managed by FCFSD"),
1191  &zone)),
1193  };
1194  int ret;
1195 
1196  if (GNUNET_OK !=
1197  GNUNET_STRINGS_get_utf8_args (argc, argv,
1198  &argc, &argv))
1199  return 2;
1200 
1201  GNUNET_log_setup ("fcfsd",
1202  "WARNING",
1203  NULL);
1204  ret =
1205  (GNUNET_OK ==
1206  GNUNET_PROGRAM_run (argc,
1207  argv,
1208  "gnunet-namestore-fcfsd",
1209  _ (
1210  "GNU Name System First Come First Serve name registration service"),
1211  options,
1212  &run, NULL)) ? 0 : 1;
1213  GNUNET_free_nz ((void *) argv);
1215  return ret;
1216 }
1217 
1218 
1219 /* end of gnunet-namestore-fcfsd.c */
struct GNUNET_IDENTITY_Handle * GNUNET_IDENTITY_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_IDENTITY_Callback cb, void *cb_cls)
Connect to the identity service.
Definition: identity_api.c:566
struct GNUNET_NAMESTORE_ZoneIterator * list_it
List iterator.
void GNUNET_IDENTITY_cancel(struct GNUNET_IDENTITY_Operation *op)
Cancel an identity operation.
Definition: identity_api.c:867
static int fill_s_reply(const char *info, struct Request *request, struct MHD_Connection *connection)
Send the &#39;SUBMIT_PAGE&#39;.
Run with high priority (important requests).
#define SUBMIT_PAGE
Second page (/S)
static struct GNUNET_VPN_RedirectionRequest * request
Opaque redirection request handle.
Definition: gnunet-vpn.c:41
struct GNUNET_NAMESTORE_ZoneIterator * lookup_it
Active lookup iterator TODO: deprecate or fix lookup by label and use above member.
int GNUNET_CONFIGURATION_get_value_number(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *number)
Get a configuration value that should be a number.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
uint64_t rel_value_us
The actual value.
static char * pkey
Public key of the zone to look in, in ASCII.
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
void GNUNET_CRYPTO_ecdsa_key_clear(struct GNUNET_CRYPTO_EcdsaPrivateKey *pk)
Clear memory that was used to store a private key.
Definition: crypto_ecc.c:483
static void do_httpd(void *cls)
Task run whenever HTTP server operations are pending.
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
struct GNUNET_NAMESTORE_ZoneIterator * GNUNET_NAMESTORE_zone_iteration_start(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_NAMESTORE_RecordMonitor proc, void *proc_cls, GNUNET_SCHEDULER_TaskCallback finish_cb, void *finish_cb_cls)
Starts a new zone iteration (used to periodically PUT all of our records into our DHT)...
static void put_continuation(void *cls, int32_t success, const char *emsg)
Continuation called to notify client about result of the operation.
#define GNUNET_TIME_UNIT_MINUTES
One minute.
int GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1458
static struct GNUNET_SCHEDULER_Task * httpd_task
Main HTTP task.
char public_key[128]
Public key submitted via form.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
const struct GNUNET_CRYPTO_EcdsaPrivateKey * GNUNET_IDENTITY_ego_get_private_key(const struct GNUNET_IDENTITY_Ego *ego)
Obtain the ECC key associated with a ego.
Definition: identity_api.c:595
#define DEFAULT_ZONEINFO_BUFSIZE
Storing of the record.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
size_t data_size
Number of bytes in data.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Definition of a command line option.
void GNUNET_NAMESTORE_zone_iterator_next(struct GNUNET_NAMESTORE_ZoneIterator *it, uint64_t limit)
Calls the record processor specified in GNUNET_NAMESTORE_zone_iteration_start for the next record...
Private ECC key encoded for transmission.
static struct GNUNET_IDENTITY_Handle * identity
Connection to identity service.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:531
static void iterate_cb(void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key, const char *name, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd)
Process a record that was stored in the namestore, adding the information to the HTML.
static void do_shutdown(void *cls)
Task run on shutdown.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct MHD_Connection * con
MHD Connection.
static 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.
Handle for an operation with the identity service.
Definition: identity_api.c:39
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
static struct GNUNET_DNSSTUB_Context * ctx
Context for DNS resolution.
#define MAIN_PAGE
Front page.
void GNUNET_NETWORK_fdset_copy_native(struct GNUNET_NETWORK_FDSet *to, const fd_set *from, int nfds)
Copy a native fd set into the GNUnet representation.
Definition: network.c:1120
void GNUNET_NAMESTORE_cancel(struct GNUNET_NAMESTORE_QueueEntry *qe)
Cancel a namestore operation.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_string(char shortName, const char *name, const char *argumentHelp, const char *description, char **str)
Allow user to specify a string.
#define _(String)
GNU gettext support macro.
Definition: platform.h:184
struct GNUNET_NAMESTORE_QueueEntry * GNUNET_NAMESTORE_records_store(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd, GNUNET_NAMESTORE_ContinuationWithStatus cont, void *cont_cls)
Store an item in the namestore.
#define METHOD_ERROR
Invalid method page.
void GNUNET_NETWORK_fdset_destroy(struct GNUNET_NETWORK_FDSet *fds)
Releases the associated memory of an fd set.
Definition: network.c:1266
void GNUNET_NAMESTORE_disconnect(struct GNUNET_NAMESTORE_Handle *h)
Disconnect from the namestore service (and free associated resources).
Zoneinfo request.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
static struct GNUNET_CRYPTO_EcdsaPrivateKey fcfs_zone_pkey
Private key for the fcfsd zone.
static void request_completed_callback(void *cls, struct MHD_Connection *connection, void **con_cls, enum MHD_RequestTerminationCode toe)
Callback called upon completion of a request.
Handle for a zone iterator operation.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1269
Handle for an ego.
Definition: identity.h:245
struct GNUNET_NETWORK_FDSet * GNUNET_NETWORK_fdset_create(void)
Creates an fd set.
Definition: network.c:1250
Phase
Phases a request goes through.
static struct MHD_Response * info_page
Zoneinfo page we currently use.
static struct GNUNET_TIME_Relative timeout
Desired timeout for the lookup (default is no timeout).
Definition: gnunet-abd.c:61
const void * data
Binary value stored in the DNS record.
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
static void lookup_it_processor(void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zonekey, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
We got a block back from the namestore.
static void update_zoneinfo_page(void *cls)
Create fresh version of zone information.
#define GNUNET_GNSRECORD_TYPE_PKEY
Record type for GNS zone transfer ("PKEY").
static void zone_to_name_cb(void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key, const char *name, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Test if a name mapping was found, if so, refuse.
#define UNSIGNED_MHD_LONG_LONG
Connection to the NAMESTORE service.
Handle for the service.
Definition: identity_api.c:95
uint64_t expiration_time
Expiration time for the DNS record.
struct GNUNET_NAMESTORE_ZoneIterator * zi
Active iteration with the namestore.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1296
collection of IO descriptors
static char * filename
char domain_name[64]
Domain name submitted via form.
struct GNUNET_CRYPTO_EcdsaPublicKey pub
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_select(enum GNUNET_SCHEDULER_Priority prio, struct GNUNET_TIME_Relative delay, const struct GNUNET_NETWORK_FDSet *rs, const struct GNUNET_NETWORK_FDSet *ws, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when any of the specified file descriptor set...
Definition: scheduler.c:1841
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
Lookup to see if the domain name is taken.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_mandatory(struct GNUNET_GETOPT_CommandLineOption opt)
Make the given option mandatory.
void GNUNET_IDENTITY_disconnect(struct GNUNET_IDENTITY_Handle *h)
Disconnect from identity service.
Definition: identity_api.c:884
static struct GNUNET_NAMESTORE_Handle * ns
Handle to the namestore.
static void lookup_it_finished(void *cls)
static void run_httpd_now()
Schedule task to run MHD server now.
Start phase (parsing POST, checking).
const char * post_url
URL to serve in response to this POST (if this request was a &#39;POST&#39;)
Send failure message.
#define ZONEINFO_PAGE
Fcfs zoneinfo page (/Zoneinfo)
#define GNUNET_free_nz(ptr)
Wrapper around free.
struct GNUNET_HashCode key
The key used in the DHT.
static unsigned int size
Size of the "table".
Definition: peer.c:67
An QueueEntry used to store information for a pending NAMESTORE record operation. ...
Definition: namestore_api.c:53
struct GNUNET_NAMESTORE_Handle * GNUNET_NAMESTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the namestore service.
static void zone_iteration_error(void *cls)
Function called on error in zone iteration.
#define MHD_RESULT
Data type to use for functions return an "MHD result".
static int serve_zoneinfo_page(struct MHD_Connection *connection)
Handler that returns FCFS zoneinfo page.
size_t buf_len
Buffer length.
static void zone_iteration_end(void *cls)
Function called once the zone iteration is done.
struct GNUNET_NAMESTORE_QueueEntry * qe
Active request with the namestore.
static struct GNUNET_SCHEDULER_Task * uzp_task
Task that runs update_zoneinfo_page peridicially.
Request we should make.
struct GNUNET_DNSSTUB_RequestSocket * rs
Socket used to make the request, NULL if not active.
static void lookup_it_error(void *cls)
We encountered an error in the name lookup.
static MHD_RESULT post_iterator(void *cls, enum MHD_ValueKind kind, const char *key, const char *filename, const char *content_type, const char *transfer_encoding, const char *data, uint64_t off, size_t size)
Iterator over key-value pairs where the value maybe made available in increments and/or may not be ze...
int GNUNET_CRYPTO_ecdsa_public_key_from_string(const char *enc, size_t enclen, struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Convert a string representing a public key to a public key.
Definition: crypto_ecc.c:366
uint32_t record_type
Type of the GNS/DNS record.
configuration data
Definition: configuration.c:84
const char * name
size_t write_offset
Buffer write offset.
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
void * cls
Closure for cont or cb.
Definition: identity_api.c:88
static void run(void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
Main function that will be run.
struct GNUNET_NAMESTORE_QueueEntry * GNUNET_NAMESTORE_zone_to_name(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, const struct GNUNET_CRYPTO_EcdsaPublicKey *value_zone, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_NAMESTORE_RecordMonitor proc, void *proc_cls)
Look for an existing PKEY delegation record for a given public key.
#define GNUNET_log(kind,...)
Entry in list of pending tasks.
Definition: scheduler.c:134
static MHD_RESULT create_response(void *cls, struct MHD_Connection *connection, const char *url, const char *method, const char *version, const char *upload_data, size_t *upload_data_size, void **ptr)
Main MHD callback for handling requests.
static void run_httpd()
Schedule tasks to run MHD server.
const struct Zone * zone
Zone responsible for this request.
static struct MHD_Response * response
Our canonical response.
static struct MHD_Daemon * httpd
MHD deamon reference.
int GNUNET_PROGRAM_run(int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls)
Run a standard GNUnet command startup sequence (initialize loggers and configuration, parse options).
Definition: program.c:367
enum Phase phase
Current processing phase.
#define MIME_HTML
Mime type for HTML pages.
#define FCFS_ZONEINFO_URL
enum GNUNET_GNSRECORD_Flags flags
Flags for the record.
int GNUNET_log_setup(const char *comp, const char *loglevel, const char *logfile)
Setup logging.
static int serve_main_page(struct MHD_Connection *connection)
Handler that returns a simple static HTTP page.
uint32_t data
The data value.
char * GNUNET_GNSRECORD_value_to_string(uint32_t type, const void *data, size_t data_size)
Convert the &#39;value&#39; of a record to a string.
Definition: gnsrecord.c:159
static void zone_to_name_error(void *cls)
Function called if we had an error in zone-to-name mapping.
#define GNUNET_malloc(size)
Wrapper around malloc.
static unsigned long long port
Port we use for the HTTP server.
#define GNUNET_free(ptr)
Wrapper around free.
Time for relative time used by GNUnet, in microseconds.
We&#39;re done with success.
struct MHD_PostProcessor * pp
Associated session.
static struct GNUNET_IDENTITY_Operation * id_op
Request for our ego.
#define gettext_noop(String)
Definition: gettext.h:69
int main(int argc, char *const *argv)
The main function for the fcfs daemon.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972