GNUnet  0.10.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 
43 #define METHOD_ERROR "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\"><html lang=\"en\" xmlns=\"http://www.w3.org/1999/xhtml\"><html><head><title>Illegal request</title></head><body>Go away.</body></html>"
44 
48 #define MAIN_PAGE "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\"><html lang=\"en\" xmlns=\"http://www.w3.org/1999/xhtml\"><html><head><title>GNUnet FCFS Authority Name Registration Service</title></head><body><form action=\"S\" method=\"post\">What is your desired domain name? (at most 63 lowercase characters, no dots allowed.) <input type=\"text\" name=\"domain\" /> <p> What is your public key? (Copy from gnunet-setup.) <input type=\"text\" name=\"pkey\" /> <input type=\"submit\" value=\"Next\" /><br/><a href=./Zoneinfo> List of all registered names </a></body></html>"
49 
53 #define SUBMIT_PAGE "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\"><html lang=\"en\" xmlns=\"http://www.w3.org/1999/xhtml\"><html><head><title>%s</title></head><body>%s</body></html>"
54 
58 #define ZONEINFO_PAGE "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\"><html lang=\"en\" xmlns=\"http://www.w3.org/1999/xhtml\"><html><head><title>FCFS Zoneinfo</title></head><body><h1> FCFS Zoneinfo </h1><table border=\"1\"><th>name</th><th>PKEY</th>%s</table></body></html>"
59 
60 #define FCFS_ZONEINFO_URL "/Zoneinfo"
61 
65 #define MIME_HTML "text/html"
66 
70 #define COOKIE_NAME "namestore-fcfsd"
71 
72 #define DEFAULT_ZONEINFO_BUFSIZE 2048
73 
77 enum Phase
78  {
82  RP_START = 0,
83 
88 
93 
98 
103  };
104 
105 
109 struct Request
110 {
111 
115  // FIXME: struct Session *session;
116 
121  struct MHD_PostProcessor *pp;
122 
126  struct MHD_Connection *con;
131  const char *post_url;
132 
137 
147 
151  enum Phase phase;
152 
156  char domain_name[64];
157 
161  char public_key[128];
162 
164 
165 };
166 
171 {
176 
180  char* zoneinfo;
181 
185  size_t buf_len;
186 
190  size_t write_offset;
191 };
192 
196 static struct MHD_Daemon *httpd;
197 
202 
207 
212 
217 
221 static struct MHD_Response *info_page;
222 
227 
232 
236 static unsigned long long port;
237 
241 static char *zone;
242 
243 
249 static void
250 do_httpd (void *cls);
251 
252 
256 static void
258 {
259  if (NULL != httpd_task)
260  {
261  GNUNET_SCHEDULER_cancel (httpd_task);
262  httpd_task = NULL;
263  }
264  httpd_task = GNUNET_SCHEDULER_add_now (&do_httpd, NULL);
265 }
266 
267 
271 static void
272 update_zoneinfo_page (void *cls);
273 
274 
278 static void
280 {
281  struct ZoneinfoRequest *zr = cls;
282 
283  zr->list_it = NULL;
284  GNUNET_free (zr->zoneinfo);
285  GNUNET_SCHEDULER_cancel (uzp_task);
287  NULL);
288 }
289 
290 
294 static void
296 {
297  struct ZoneinfoRequest *zr = cls;
298  struct MHD_Response *response;
299  char* full_page;
300 
301  zr->list_it = NULL;
302 
303  /* return static form */
304  GNUNET_asprintf (&full_page,
306  zr->zoneinfo,
307  zr->zoneinfo);
308  response = MHD_create_response_from_buffer (strlen (full_page),
309  (void *) full_page,
310  MHD_RESPMEM_MUST_FREE);
311  MHD_add_response_header (response,
312  MHD_HTTP_HEADER_CONTENT_TYPE,
313  MIME_HTML);
314  MHD_destroy_response (info_page);
316  GNUNET_free (zr->zoneinfo);
317 }
318 
319 
330 static void
331 iterate_cb (void *cls,
332  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
333  const char *name,
334  unsigned int rd_len,
335  const struct GNUNET_GNSRECORD_Data *rd)
336 {
337  struct ZoneinfoRequest *zr = cls;
338  size_t bytes_free;
339  char* pkey;
340  char* new_buf;
341 
342  (void) zone_key;
343  if (1 != rd_len)
344  {
346  1);
347  return;
348  }
349 
351  {
353  1);
354  return;
355  }
356 
357  bytes_free = zr->buf_len - zr->write_offset;
359  rd->data,
360  rd->data_size);
361  if (NULL == pkey)
362  {
363  GNUNET_break (0);
365  1);
366  return;
367  }
368  if (bytes_free < (strlen (name) + strlen (pkey) + 40))
369  {
370  new_buf = GNUNET_malloc (zr->buf_len * 2);
371  GNUNET_memcpy (new_buf, zr->zoneinfo, zr->write_offset);
372  GNUNET_free (zr->zoneinfo);
373  zr->zoneinfo = new_buf;
374  zr->buf_len *= 2;
375  }
376  sprintf (zr->zoneinfo + zr->write_offset,
377  "<tr><td>%s</td><td>%s</td></tr>",
378  name,
379  pkey);
380  zr->write_offset = strlen (zr->zoneinfo);
382  1);
383  GNUNET_free (pkey);
384 }
385 
386 
392 static int
393 serve_zoneinfo_page (struct MHD_Connection *connection)
394 {
395  return MHD_queue_response (connection,
396  MHD_HTTP_OK,
397  info_page);
398 }
399 
400 
404 static void
406 {
407  static struct ZoneinfoRequest zr;
408 
409  (void) cls;
412  NULL);
413  if (NULL != zr.list_it)
414  return;
417  zr.write_offset = 0;
421  &zr,
422  &iterate_cb,
423  &zr,
425  &zr);
426 }
427 
428 
435 static int
436 serve_main_page (struct MHD_Connection *connection)
437 {
438  int ret;
439  struct MHD_Response *response;
440 
441  /* return static form */
442  response = MHD_create_response_from_buffer (strlen (MAIN_PAGE),
443  (void *) MAIN_PAGE,
444  MHD_RESPMEM_PERSISTENT);
445  MHD_add_response_header (response,
446  MHD_HTTP_HEADER_CONTENT_TYPE,
447  MIME_HTML);
448  ret = MHD_queue_response (connection,
449  MHD_HTTP_OK,
450  response);
451  MHD_destroy_response (response);
452  return ret;
453 }
454 
455 
463 static int
464 fill_s_reply (const char *info,
465  struct Request *request,
466  struct MHD_Connection *connection)
467 {
468  int ret;
469  char *reply;
470  struct MHD_Response *response;
471 
472  (void) request;
473  GNUNET_asprintf (&reply,
474  SUBMIT_PAGE,
475  info,
476  info);
477  /* return static form */
478  response = MHD_create_response_from_buffer (strlen (reply),
479  (void *) reply,
480  MHD_RESPMEM_MUST_FREE);
481  MHD_add_response_header (response,
482  MHD_HTTP_HEADER_CONTENT_TYPE,
483  MIME_HTML);
484  ret = MHD_queue_response (connection,
485  MHD_HTTP_OK,
486  response);
487  MHD_destroy_response (response);
488  return ret;
489 }
490 
491 
511 static int
512 post_iterator (void *cls,
513  enum MHD_ValueKind kind,
514  const char *key,
515  const char *filename,
516  const char *content_type,
517  const char *transfer_encoding,
518  const char *data,
519  uint64_t off,
520  size_t size)
521 {
522  struct Request *request = cls;
523 
524  (void) kind;
525  (void) filename;
526  (void) content_type;
527  (void) transfer_encoding;
528  if (0 == strcmp ("domain", key))
529  {
530  if (size + off >= sizeof(request->domain_name))
531  size = sizeof (request->domain_name) - off - 1;
532  GNUNET_memcpy (&request->domain_name[off],
533  data,
534  size);
535  request->domain_name[size+off] = '\0';
536  return MHD_YES;
537  }
538  if (0 == strcmp ("pkey", key))
539  {
540  if (size + off >= sizeof(request->public_key))
541  size = sizeof (request->public_key) - off - 1;
542  GNUNET_memcpy (&request->public_key[off],
543  data,
544  size);
545  request->public_key[size+off] = '\0';
546  return MHD_YES;
547  }
549  _("Unsupported form value `%s'\n"),
550  key);
551  return MHD_YES;
552 }
553 
554 
565 static void
566 put_continuation (void *cls,
567  int32_t success,
568  const char *emsg)
569 {
570  struct Request *request = cls;
571 
572  request->qe = NULL;
573  if (0 >= success)
574  {
576  _("Failed to create record for domain `%s': %s\n"),
577  request->domain_name,
578  emsg);
579  request->phase = RP_FAIL;
580  }
581  else
582  request->phase = RP_SUCCESS;
583  MHD_resume_connection (request->con);
584  run_httpd_now ();
585 }
586 
587 
591 static void
593 {
594  struct Request *request = cls;
595 
597  _("Error when mapping zone to name\n"));
598  request->phase = RP_FAIL;
599  MHD_resume_connection (request->con);
600  run_httpd_now ();
601 }
602 
603 
613 static void
614 zone_to_name_cb (void *cls,
615  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
616  const char *name,
617  unsigned int rd_count,
618  const struct GNUNET_GNSRECORD_Data *rd)
619 {
620  struct Request *request = cls;
621  struct GNUNET_GNSRECORD_Data r;
622 
623  (void) rd;
624  (void) zone_key;
625  request->qe = NULL;
626  if (0 != rd_count)
627  {
629  _("Found existing name `%s' for the given key\n"),
630  name);
631  request->phase = RP_FAIL;
632  MHD_resume_connection (request->con);
633  run_httpd_now ();
634  return;
635  }
636  r.data = &request->pub;
637  r.data_size = sizeof (request->pub);
638  r.expiration_time = UINT64_MAX;
641  request->qe = GNUNET_NAMESTORE_records_store (ns,
643  request->domain_name,
644  1, &r,
646  request);
647 }
648 
649 
653 static void
654 lookup_it_error (void *cls)
655 {
656  struct Request *request = cls;
657  MHD_resume_connection (request->con);
658  request->qe = NULL;
659  request->phase = RP_FAIL;
660  run_httpd_now ();
661 }
662 
663 
674 static void
676  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zonekey,
677  const char *label,
678  unsigned int rd_count,
679  const struct GNUNET_GNSRECORD_Data *rd)
680 {
681  struct Request *request = cls;
682 
683  (void) label;
684  (void) rd;
685  (void) zonekey;
686  if (0 == strcmp (label, request->domain_name)) {
687  GNUNET_break (0 != rd_count);
689  _("Found %u existing records for domain `%s'\n"),
690  rd_count,
691  request->domain_name);
692  request->phase = RP_FAIL;
693  }
695 }
696 
697 static void
699 {
700  struct Request *request = cls;
701 
702  if (RP_FAIL == request->phase)
703  {
704  MHD_resume_connection (request->con);
705  run_httpd_now ();
706  return;
707  }
708  if (GNUNET_OK !=
710  strlen (request->public_key),
711  &request->pub))
712  {
713  GNUNET_break (0);
714  request->phase = RP_FAIL;
715  MHD_resume_connection (request->con);
716  run_httpd_now ();
717  return;
718  }
719  request->qe = GNUNET_NAMESTORE_zone_to_name (ns,
721  &request->pub,
723  request,
725  request);
726 }
727 
751 static int
752 create_response (void *cls,
753  struct MHD_Connection *connection,
754  const char *url,
755  const char *method,
756  const char *version,
757  const char *upload_data,
758  size_t *upload_data_size,
759  void **ptr)
760 {
761  struct MHD_Response *response;
762  struct Request *request;
763  struct GNUNET_CRYPTO_EcdsaPublicKey pub;
764  int ret;
765 
766  (void) cls;
767  (void) version;
768  if ( (0 == strcmp (method, MHD_HTTP_METHOD_GET)) ||
769  (0 == strcmp (method, MHD_HTTP_METHOD_HEAD)) )
770  {
771  if (0 == strcmp (url, FCFS_ZONEINFO_URL))
772  ret = serve_zoneinfo_page (connection);
773  else
774  ret = serve_main_page (connection);
775  if (ret != MHD_YES)
777  _("Failed to create page for `%s'\n"),
778  url);
779  return ret;
780  }
781  if (0 == strcmp (method, MHD_HTTP_METHOD_POST))
782  {
783  request = *ptr;
784  if (NULL == request)
785  {
786  request = GNUNET_new (struct Request);
787  request->con = connection;
788  *ptr = request;
789  request->pp = MHD_create_post_processor (connection,
790  1024,
791  &post_iterator,
792  request);
793  if (NULL == request->pp)
794  {
796  _("Failed to setup post processor for `%s'\n"),
797  url);
798  return MHD_NO; /* internal error */
799  }
800  return MHD_YES;
801  }
802  if (NULL != request->pp)
803  {
804  /* evaluate POST data */
805  MHD_post_process (request->pp,
806  upload_data,
807  *upload_data_size);
808  if (0 != *upload_data_size)
809  {
810  *upload_data_size = 0;
811  return MHD_YES;
812  }
813  /* done with POST data, serve response */
814  MHD_destroy_post_processor (request->pp);
815  request->pp = NULL;
816  }
817  if (GNUNET_OK !=
819  strlen (request->public_key),
820  &pub))
821  {
822  /* parse error */
823  return fill_s_reply ("Failed to parse given public key",
824  request, connection);
825  }
826  switch (request->phase)
827  {
828  case RP_START:
829  if (NULL != strchr (request->domain_name, (int) '.'))
830  {
832  _("Domain name must not contain `.'\n"));
833  request->phase = RP_FAIL;
834  return fill_s_reply ("Domain name must not contain `.', sorry.",
835  request,
836  connection);
837  }
838  if (NULL != strchr (request->domain_name, (int) '+'))
839  {
841  _("Domain name must not contain `+'\n"));
842  request->phase = RP_FAIL;
843  return fill_s_reply ("Domain name must not contain `+', sorry.",
844  request, connection);
845  }
846  request->phase = RP_LOOKUP;
847  MHD_suspend_connection (request->con);
848  request->lookup_it
852  request,
854  request,
856  request);
857  break;
858  case RP_LOOKUP:
859  break;
860  case RP_PUT:
861  break;
862  case RP_FAIL:
863  return fill_s_reply ("Request failed, sorry.",
864  request, connection);
865  case RP_SUCCESS:
866  return fill_s_reply ("Success.",
867  request, connection);
868  default:
869  GNUNET_break (0);
870  return MHD_NO;
871  }
872  return MHD_YES; /* will have a reply later... */
873  }
874  /* unsupported HTTP method */
875  response = MHD_create_response_from_buffer (strlen (METHOD_ERROR),
876  (void *) METHOD_ERROR,
877  MHD_RESPMEM_PERSISTENT);
878  ret = MHD_queue_response (connection,
879  MHD_HTTP_NOT_ACCEPTABLE,
880  response);
881  MHD_destroy_response (response);
882  return ret;
883 }
884 
885 
895 static void
897  struct MHD_Connection *connection,
898  void **con_cls,
899  enum MHD_RequestTerminationCode toe)
900 {
901  struct Request *request = *con_cls;
902 
903  (void) cls;
904  (void) connection;
905  (void) toe;
906  if (NULL == request)
907  return;
908  if (NULL != request->pp)
909  MHD_destroy_post_processor (request->pp);
910  if (NULL != request->qe)
911  GNUNET_NAMESTORE_cancel (request->qe);
912  GNUNET_free (request);
913 }
914 
915 
916 #define UNSIGNED_MHD_LONG_LONG unsigned MHD_LONG_LONG
917 
918 
922 static void
924 {
925  fd_set rs;
926  fd_set ws;
927  fd_set es;
928  struct GNUNET_NETWORK_FDSet *wrs;
929  struct GNUNET_NETWORK_FDSet *wws;
930  struct GNUNET_NETWORK_FDSet *wes;
931  int max;
932  int haveto;
934  struct GNUNET_TIME_Relative tv;
935 
936  FD_ZERO (&rs);
937  FD_ZERO (&ws);
938  FD_ZERO (&es);
942  max = -1;
943  GNUNET_assert (MHD_YES ==
944  MHD_get_fdset (httpd,
945  &rs,
946  &ws,
947  &es,
948  &max));
949  haveto = MHD_get_timeout (httpd,
950  &timeout);
951  if (haveto == MHD_YES)
952  tv.rel_value_us = (uint64_t) timeout * 1000LL;
953  else
956  &rs,
957  max + 1);
959  &ws,
960  max + 1);
962  &es,
963  max + 1);
964  httpd_task =
966  tv,
967  wrs,
968  wws,
969  &do_httpd,
970  NULL);
974 }
975 
976 
982 static void
983 do_httpd (void *cls)
984 {
985  (void) cls;
986  httpd_task = NULL;
987  MHD_run (httpd);
988  run_httpd ();
989 }
990 
991 
997 static void
998 do_shutdown (void *cls)
999 {
1000  (void) cls;
1001  if (NULL != httpd_task)
1002  {
1003  GNUNET_SCHEDULER_cancel (httpd_task);
1004  httpd_task = NULL;
1005  }
1006  if (NULL != uzp_task)
1007  {
1008  GNUNET_SCHEDULER_cancel (uzp_task);
1009  uzp_task = NULL;
1010  }
1011  if (NULL != ns)
1012  {
1014  ns = NULL;
1015  }
1016  if (NULL != httpd)
1017  {
1018  MHD_stop_daemon (httpd);
1019  httpd = NULL;
1020  }
1021  if (NULL != id_op)
1022  {
1023  GNUNET_IDENTITY_cancel (id_op);
1024  id_op = NULL;
1025  }
1026  if (NULL != identity)
1027  {
1028  GNUNET_IDENTITY_disconnect (identity);
1029  identity = NULL;
1030  }
1031 }
1032 
1033 
1053 static void
1054 identity_cb (void *cls,
1055  struct GNUNET_IDENTITY_Ego *ego,
1056  void **ctx,
1057  const char *name)
1058 {
1059  int options;
1060 
1061  (void) cls;
1062  (void) ctx;
1063  if (NULL == name)
1064  return;
1065  if (0 != strcmp (name,
1066  zone))
1067  return;
1068  if (NULL == ego)
1069  {
1071  _("No ego configured for `fcfsd` subsystem\n"));
1073  return;
1074  }
1076 
1077  options = MHD_USE_DUAL_STACK | MHD_USE_DEBUG | MHD_ALLOW_SUSPEND_RESUME;
1078  do
1079  {
1080  httpd = MHD_start_daemon (options,
1081  (uint16_t) port,
1082  NULL, NULL,
1083  &create_response, NULL,
1084  MHD_OPTION_CONNECTION_LIMIT, (unsigned int) 128,
1085  MHD_OPTION_PER_IP_CONNECTION_LIMIT, (unsigned int) 1,
1086  MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 16,
1087  MHD_OPTION_CONNECTION_MEMORY_LIMIT, (size_t) (4 * 1024),
1088  MHD_OPTION_NOTIFY_COMPLETED, &request_completed_callback, NULL,
1089  MHD_OPTION_END);
1090  if (MHD_USE_DEBUG == options)
1091  break;
1092  options = MHD_USE_DEBUG;
1093  }
1094  while (NULL == httpd);
1095  if (NULL == httpd)
1096  {
1097 
1099  _("Failed to start HTTP server\n"));
1101  return;
1102  }
1103  run_httpd ();
1104 }
1105 
1106 
1115 static void
1116 run (void *cls,
1117  char *const *args,
1118  const char *cfgfile,
1119  const struct GNUNET_CONFIGURATION_Handle *cfg)
1120 {
1121  (void) cls;
1122  (void) args;
1123  (void) cfgfile;
1124  if (GNUNET_OK !=
1126  "fcfsd",
1127  "HTTPPORT",
1128  &port))
1129  {
1131  "fcfsd", "HTTPPORT");
1132  return;
1133  }
1134  ns = GNUNET_NAMESTORE_connect (cfg);
1135  if (NULL == ns)
1136  {
1138  _("Failed to connect to namestore\n"));
1139  return;
1140  }
1141  identity = GNUNET_IDENTITY_connect (cfg,
1142  &identity_cb,
1143  NULL);
1144  if (NULL == identity)
1145  {
1147  _("Failed to connect to identity\n"));
1148  return;
1149  }
1151  NULL);
1153  NULL);
1154 }
1155 
1156 
1164 int
1165 main (int argc,
1166  char *const *argv)
1167 {
1168  struct GNUNET_GETOPT_CommandLineOption options[] = {
1171  "zone",
1172  "EGO",
1173  gettext_noop ("name of the zone that is to be managed by FCFSD"),
1174  &zone)),
1176  };
1177  int ret;
1178 
1179  if (GNUNET_OK !=
1180  GNUNET_STRINGS_get_utf8_args (argc, argv,
1181  &argc, &argv))
1182  return 2;
1183 
1184  GNUNET_log_setup ("fcfsd",
1185  "WARNING",
1186  NULL);
1187  ret =
1188  (GNUNET_OK ==
1189  GNUNET_PROGRAM_run (argc,
1190  argv,
1191  "gnunet-namestore-fcfsd",
1192  _("GNU Name System First Come First Serve name registration service"),
1193  options,
1194  &run, NULL)) ? 0 : 1;
1195  GNUNET_free ((void*) argv);
1197  return ret;
1198 }
1199 
1200 /* 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:528
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:819
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.
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:585
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:1293
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:1521
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:556
#define DEFAULT_ZONEINFO_BUFSIZE
Storing of the record.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
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:524
static int ret
Final status code.
Definition: gnunet-arm.c:89
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:1308
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.
static int 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.
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
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:1554
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:1246
Handle for an ego.
Definition: identity.h:245
struct GNUNET_NETWORK_FDSet * GNUNET_NETWORK_fdset_create(void)
Creates an fd set.
Definition: network.c:1538
Phase
Phases a request goes through.
static struct MHD_Response * info_page
Zoneinfo page we currently use.
static struct GNUNET_TIME_Relative timeout
User defined timestamp for completing operations.
Definition: gnunet-arm.c:114
#define GNUNET_memcpy(dst, src, n)
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:96
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:1273
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:1829
#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:838
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.
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:104
#define ZONEINFO_PAGE
Fcfs zoneinfo page (/Zoneinfo)
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.
const char * name
static void zone_iteration_error(void *cls)
Function called on error in zone iteration.
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.
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:468
uint32_t record_type
Type of the GNS/DNS record.
configuration data
Definition: configuration.c:85
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:89
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 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:361
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:143
static int 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...
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:965