GNUnet  0.10.x
gnunet-namestore.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2012, 2013, 2014, 2019 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 */
28 #include "platform.h"
29 #include <gnunet_util_lib.h>
30 #include <gnunet_dnsparser_lib.h>
32 #include <gnunet_gnsrecord_lib.h>
33 #include <gnunet_gns_service.h>
35 
36 
41 {
46 
51 };
52 
53 
57 static struct GNUNET_NAMESTORE_Handle *ns;
58 
63 
68 
72 static struct GNUNET_IDENTITY_Handle *idh;
73 
78 
82 static char *ego_name;
83 
87 static int add;
88 
93 
98 
103 
108 
112 static int list;
113 
118 
122 static int del;
123 
127 static int is_public;
128 
132 static int is_shadow;
133 
138 
143 
147 static char *name;
148 
152 static char *value;
153 
157 static char *uri;
158 
162 static char *reverse_pkey;
163 
167 static char *typestring;
168 
172 static char *expirationstring;
173 
177 static char *nickstring;
178 
182 static int ret;
183 
187 static uint32_t type;
188 
192 static void *data;
193 
197 static size_t data_size;
198 
202 static uint64_t etime;
203 
208 
213 
217 static int monitor;
218 
222 static struct RecordSetEntry *recordset;
223 
224 
230 static void
231 do_shutdown (void *cls)
232 {
233  (void) cls;
234  if (NULL != get_default)
235  {
236  GNUNET_IDENTITY_cancel (get_default);
237  get_default = NULL;
238  }
239  if (NULL != idh)
240  {
242  idh = NULL;
243  }
244  if (NULL != el)
245  {
247  el = NULL;
248  }
249  if (NULL != list_it)
250  {
252  list_it = NULL;
253  }
254  if (NULL != add_qe)
255  {
256  GNUNET_NAMESTORE_cancel (add_qe);
257  add_qe = NULL;
258  }
259  if (NULL != set_qe)
260  {
261  GNUNET_NAMESTORE_cancel (set_qe);
262  set_qe = NULL;
263  }
264  if (NULL != add_qe_uri)
265  {
266  GNUNET_NAMESTORE_cancel (add_qe_uri);
267  add_qe_uri = NULL;
268  }
269  if (NULL != get_qe)
270  {
271  GNUNET_NAMESTORE_cancel (get_qe);
272  get_qe = NULL;
273  }
274  if (NULL != del_qe)
275  {
276  GNUNET_NAMESTORE_cancel (del_qe);
277  del_qe = NULL;
278  }
279  if (NULL != ns)
280  {
282  ns = NULL;
283  }
284  memset (&zone_pkey, 0, sizeof (zone_pkey));
285  if (NULL != uri)
286  {
287  GNUNET_free (uri);
288  uri = NULL;
289  }
290  if (NULL != zm)
291  {
293  zm = NULL;
294  }
295  if (NULL != data)
296  {
297  GNUNET_free (data);
298  data = NULL;
299  }
300 }
301 
302 
306 static void
308 {
309  if ((NULL == add_qe) && (NULL == add_qe_uri) && (NULL == get_qe) &&
310  (NULL == del_qe) && (NULL == reverse_qe) && (NULL == list_it))
312 }
313 
314 
325 static void
326 add_continuation (void *cls, int32_t success, const char *emsg)
327 {
328  struct GNUNET_NAMESTORE_QueueEntry **qe = cls;
329 
330  *qe = NULL;
331  if (GNUNET_YES != success)
332  {
333  fprintf (stderr,
334  _ ("Adding record failed: %s\n"),
335  (GNUNET_NO == success) ? "record exists" : emsg);
336  if (GNUNET_NO != success)
337  ret = 1;
338  }
339  ret = 0;
340  test_finished ();
341 }
342 
343 
354 static void
355 del_continuation (void *cls, int32_t success, const char *emsg)
356 {
357  (void) cls;
358  del_qe = NULL;
359  if (GNUNET_NO == success)
360  {
361  fprintf (stderr,
362  _ ("Deleting record failed, record does not exist%s%s\n"),
363  (NULL != emsg) ? ": " : "",
364  (NULL != emsg) ? emsg : "");
365  }
366  if (GNUNET_SYSERR == success)
367  {
368  fprintf (stderr,
369  _ ("Deleting record failed%s%s\n"),
370  (NULL != emsg) ? ": " : "",
371  (NULL != emsg) ? emsg : "");
372  }
373  test_finished ();
374 }
375 
376 
380 static void
382 {
383  (void) cls;
384  list_it = NULL;
385  test_finished ();
386 }
387 
388 
392 static void
394 {
395  (void) cls;
396  list_it = NULL;
397  fprintf (stderr, "Error iterating over zone\n");
398  ret = 1;
399  test_finished ();
400 }
401 
402 
410 static void
411 display_record (const char *rname,
412  unsigned int rd_len,
413  const struct GNUNET_GNSRECORD_Data *rd)
414 {
415  const char *typestr;
416  char *s;
417  const char *ets;
418  struct GNUNET_TIME_Absolute at;
419  struct GNUNET_TIME_Relative rt;
420  int have_record;
421 
422  if ((NULL != name) && (0 != strcmp (name, rname)))
423  {
425  return;
426  }
427  have_record = GNUNET_NO;
428  for (unsigned int i = 0; i < rd_len; i++)
429  {
430  if ((GNUNET_GNSRECORD_TYPE_NICK == rd[i].record_type) &&
431  (0 != strcmp (rname, GNUNET_GNS_EMPTY_LABEL_AT)))
432  continue;
433  if ((type != rd[i].record_type) && (GNUNET_GNSRECORD_TYPE_ANY != type))
434  continue;
435  have_record = GNUNET_YES;
436  break;
437  }
438  if (GNUNET_NO == have_record)
439  return;
440  FPRINTF (stdout, "%s:\n", rname);
441  if (NULL != typestring)
443  else
445  for (unsigned int i = 0; i < rd_len; i++)
446  {
447  if ((GNUNET_GNSRECORD_TYPE_NICK == rd[i].record_type) &&
448  (0 != strcmp (rname, GNUNET_GNS_EMPTY_LABEL_AT)))
449  continue;
450  if ((type != rd[i].record_type) && (GNUNET_GNSRECORD_TYPE_ANY != type))
451  continue;
452  typestr = GNUNET_GNSRECORD_number_to_typename (rd[i].record_type);
453  s = GNUNET_GNSRECORD_value_to_string (rd[i].record_type,
454  rd[i].data,
455  rd[i].data_size);
456  if (NULL == s)
457  {
458  FPRINTF (stdout,
459  _ ("\tCorrupt or unsupported record of type %u\n"),
460  (unsigned int) rd[i].record_type);
461  continue;
462  }
463  if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
464  {
465  rt.rel_value_us = rd[i].expiration_time;
467  }
468  else
469  {
470  at.abs_value_us = rd[i].expiration_time;
472  }
473  FPRINTF (stdout,
474  "\t%s: %s (%s)\t%s\t%s\n",
475  typestr,
476  s,
477  ets,
478  (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_PRIVATE)) ? "PRIVATE"
479  : "PUBLIC",
480  (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_SHADOW_RECORD)) ? "SHADOW"
481  : "");
482  GNUNET_free (s);
483  }
484  FPRINTF (stdout, "%s", "\n");
485 }
486 
487 
497 static void
499  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
500  const char *rname,
501  unsigned int rd_len,
502  const struct GNUNET_GNSRECORD_Data *rd)
503 {
504  (void) cls;
505  (void) zone_key;
506  display_record (rname, rd_len, rd);
508 }
509 
510 
520 static void
522  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
523  const char *rname,
524  unsigned int rd_len,
525  const struct GNUNET_GNSRECORD_Data *rd)
526 {
527  (void) cls;
528  (void) zone_key;
529  display_record (rname, rd_len, rd);
531 }
532 
533 
543 static void
545  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
546  const char *rname,
547  unsigned int rd_len,
548  const struct GNUNET_GNSRECORD_Data *rd)
549 {
550  (void) cls;
551  (void) zone_key;
552  get_qe = NULL;
553  display_record (rname, rd_len, rd);
554  test_finished ();
555 }
556 
557 
563 static void
564 sync_cb (void *cls)
565 {
566  (void) cls;
567  FPRINTF (stdout, "%s", "Monitor is now in sync.\n");
568 }
569 
570 
576 static void
577 monitor_error_cb (void *cls)
578 {
579  (void) cls;
580  FPRINTF (stderr, "%s", "Monitor disconnected and out of sync.\n");
581 }
582 
583 
589 static void
590 lookup_error_cb (void *cls)
591 {
592  (void) cls;
593  get_qe = NULL;
594  FPRINTF (stderr, "%s", "Failed to lookup record.\n");
595  test_finished ();
596 }
597 
598 
602 static void
603 add_error_cb (void *cls)
604 {
605  (void) cls;
606  add_qe = NULL;
607  GNUNET_break (0);
608  ret = 1;
609  test_finished ();
610 }
611 
612 
623 static void
625  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
626  const char *rec_name,
627  unsigned int rd_count,
628  const struct GNUNET_GNSRECORD_Data *rd)
629 {
630  struct GNUNET_GNSRECORD_Data rdn[rd_count + 1];
631  struct GNUNET_GNSRECORD_Data *rde;
632 
633  (void) cls;
634  (void) zone_key;
635  add_qe = NULL;
636  if (0 != strcmp (rec_name, name))
637  {
638  GNUNET_break (0);
639  ret = 1;
640  test_finished ();
641  return;
642  }
643 
645  "Received %u records for name `%s'\n",
646  rd_count,
647  rec_name);
648  for (unsigned int i = 0; i < rd_count; i++)
649  {
650  switch (rd[i].record_type)
651  {
653  fprintf (
654  stderr,
655  _ (
656  "A %s record exists already under `%s', no other records can be added.\n"),
657  "CNAME",
658  rec_name);
659  ret = 1;
660  test_finished ();
661  return;
663  fprintf (
664  stderr,
665  _ (
666  "A %s record exists already under `%s', no other records can be added.\n"),
667  "PKEY",
668  rec_name);
669  ret = 1;
670  test_finished ();
671  return;
674  {
675  fprintf (
676  stderr,
677  _ (
678  "A SOA record exists already under `%s', cannot add a second SOA to the same zone.\n"),
679  rec_name);
680  ret = 1;
681  test_finished ();
682  return;
683  }
684  break;
685  }
686  }
687  switch (type)
688  {
690  if (0 != rd_count)
691  {
692  fprintf (stderr,
693  _ (
694  "Records already exist under `%s', cannot add `%s' record.\n"),
695  rec_name,
696  "CNAME");
697  ret = 1;
698  test_finished ();
699  return;
700  }
701  break;
703  if (0 != rd_count)
704  {
705  fprintf (stderr,
706  _ (
707  "Records already exist under `%s', cannot add `%s' record.\n"),
708  rec_name,
709  "PKEY");
710  ret = 1;
711  test_finished ();
712  return;
713  }
714  break;
716  for (unsigned int i = 0; i < rd_count; i++)
718  {
719  fprintf (
720  stderr,
721  _ (
722  "Non-GNS2DNS records already exist under `%s', cannot add GNS2DNS record.\n"),
723  rec_name);
724  ret = 1;
725  test_finished ();
726  return;
727  }
728  break;
729  }
730  memset (rdn, 0, sizeof (struct GNUNET_GNSRECORD_Data));
731  GNUNET_memcpy (&rdn[1], rd, rd_count * sizeof (struct GNUNET_GNSRECORD_Data));
732  rde = &rdn[0];
733  rde->data = data;
734  rde->data_size = data_size;
735  rde->record_type = type;
736  if (1 == is_shadow)
738  if (1 != is_public)
740  rde->expiration_time = etime;
741  if (GNUNET_YES == etime_is_rel)
743  else if (GNUNET_NO != etime_is_rel)
744  rde->expiration_time = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
745  GNUNET_assert (NULL != name);
746  add_qe = GNUNET_NAMESTORE_records_store (ns,
747  &zone_pkey,
748  name,
749  rd_count + 1,
750  rde,
752  &add_qe);
753 }
754 
755 
759 static void
760 reverse_error_cb (void *cls)
761 {
762  (void) cls;
763  reverse_qe = NULL;
764  FPRINTF (stdout, "%s.zkey\n", reverse_pkey);
765 }
766 
767 
778 static void
780  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
781  const char *label,
782  unsigned int rd_count,
783  const struct GNUNET_GNSRECORD_Data *rd)
784 {
785  (void) cls;
786  (void) zone;
787  (void) rd_count;
788  (void) rd;
789  reverse_qe = NULL;
790  if (NULL == label)
791  FPRINTF (stdout, "%s\n", reverse_pkey);
792  else
793  FPRINTF (stdout, "%s.%s\n", label, ego_name);
794  test_finished ();
795 }
796 
797 
801 static void
803 {
804  (void) cls;
805  del_qe = NULL;
806  GNUNET_break (0);
807  ret = 1;
808  test_finished ();
809 }
810 
811 
823 static void
824 del_monitor (void *cls,
825  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
826  const char *label,
827  unsigned int rd_count,
828  const struct GNUNET_GNSRECORD_Data *rd)
829 {
830  struct GNUNET_GNSRECORD_Data rdx[rd_count];
831  unsigned int rd_left;
832  uint32_t type;
833  char *vs;
834 
835  (void) cls;
836  (void) zone;
837  del_qe = NULL;
838  if (0 == rd_count)
839  {
840  FPRINTF (stderr,
841  _ (
842  "There are no records under label `%s' that could be deleted.\n"),
843  label);
844  ret = 1;
845  test_finished ();
846  return;
847  }
848  if ((NULL == value) && (NULL == typestring))
849  {
850  /* delete everything */
851  del_qe = GNUNET_NAMESTORE_records_store (ns,
852  &zone_pkey,
853  name,
854  0,
855  NULL,
857  NULL);
858  return;
859  }
860  rd_left = 0;
861  if (NULL != typestring)
863  else
865  for (unsigned int i = 0; i < rd_count; i++)
866  {
867  vs = NULL;
868  if (! (((GNUNET_GNSRECORD_TYPE_ANY == type) ||
869  (rd[i].record_type == type)) &&
870  ((NULL == value) ||
871  (NULL ==
873  rd[i].data,
874  rd[i].data_size)))) ||
875  (0 == strcmp (vs, value)))))
876  rdx[rd_left++] = rd[i];
878  }
879  if (rd_count == rd_left)
880  {
881  /* nothing got deleted */
882  FPRINTF (
883  stderr,
884  _ (
885  "There are no records under label `%s' that match the request for deletion.\n"),
886  label);
887  test_finished ();
888  return;
889  }
890  /* delete everything but what we copied to 'rdx' */
891  del_qe = GNUNET_NAMESTORE_records_store (ns,
892  &zone_pkey,
893  name,
894  rd_left,
895  rdx,
897  NULL);
898 }
899 
900 
909 static int
911  int *etime_is_rel,
912  uint64_t *etime)
913 {
914  struct GNUNET_TIME_Relative etime_rel;
915  struct GNUNET_TIME_Absolute etime_abs;
916 
917  if (0 == strcmp (expirationstring, "never"))
918  {
919  *etime = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
920  *etime_is_rel = GNUNET_NO;
921  return GNUNET_OK;
922  }
923  if (GNUNET_OK ==
924  GNUNET_STRINGS_fancy_time_to_relative (expirationstring, &etime_rel))
925  {
926  *etime_is_rel = GNUNET_YES;
927  *etime = etime_rel.rel_value_us;
929  "Storing record with relative expiration time of %s\n",
931  return GNUNET_OK;
932  }
933  if (GNUNET_OK ==
934  GNUNET_STRINGS_fancy_time_to_absolute (expirationstring, &etime_abs))
935  {
936  *etime_is_rel = GNUNET_NO;
937  *etime = etime_abs.abs_value_us;
939  "Storing record with absolute expiration time of %s\n",
941  return GNUNET_OK;
942  }
943  return GNUNET_SYSERR;
944 }
945 
946 
957 static void
958 replace_cont (void *cls, int success, const char *emsg)
959 {
960  (void) cls;
961 
962  set_qe = NULL;
963  if (GNUNET_OK != success)
964  {
966  _ ("Failed to replace records: %s\n"),
967  emsg);
968  ret = 1; /* fail from 'main' */
969  }
971 }
972 
973 
980 static void
982 {
983  struct GNUNET_GNSRECORD_Data rd;
984 
985  if (! (add | del | list | (NULL != nickstring) | (NULL != uri) |
986  (NULL != reverse_pkey) | (NULL != recordset)))
987  {
988  /* nothing more to be done */
989  fprintf (stderr, _ ("No options given\n"));
991  return;
992  }
993  ns = GNUNET_NAMESTORE_connect (cfg);
994  if (NULL == ns)
995  {
997  _ ("Failed to connect to namestore\n"));
998  return;
999  }
1000 
1001  if (NULL != recordset)
1002  {
1003  /* replace entire record set */
1004  unsigned int rd_count;
1005  struct GNUNET_GNSRECORD_Data *rd;
1006 
1007  if (NULL == name)
1008  {
1009  fprintf (stderr,
1010  _ ("Missing option `%s' for operation `%s'\n"),
1011  "-R",
1012  _ ("replace"));
1014  ret = 1;
1015  return;
1016  }
1017  rd_count = 0;
1018  for (struct RecordSetEntry *e = recordset; NULL != e; e = e->next)
1019  rd_count++;
1020  rd = GNUNET_new_array (rd_count, struct GNUNET_GNSRECORD_Data);
1021  rd_count = 0;
1022  for (struct RecordSetEntry *e = recordset; NULL != e; e = e->next)
1023  {
1024  rd[rd_count] = e->record;
1025  rd_count++;
1026  }
1027  set_qe = GNUNET_NAMESTORE_records_store (ns,
1028  &zone_pkey,
1029  name,
1030  rd_count,
1031  rd,
1032  &replace_cont,
1033  NULL);
1034  GNUNET_free (rd);
1035  return;
1036  }
1037 
1038  if (add)
1039  {
1040  if (NULL == name)
1041  {
1042  fprintf (stderr,
1043  _ ("Missing option `%s' for operation `%s'\n"),
1044  "-n",
1045  _ ("add"));
1047  ret = 1;
1048  return;
1049  }
1050  if (NULL == typestring)
1051  {
1052  fprintf (stderr,
1053  _ ("Missing option `%s' for operation `%s'\n"),
1054  "-t",
1055  _ ("add"));
1057  ret = 1;
1058  return;
1059  }
1061  if (UINT32_MAX == type)
1062  {
1063  fprintf (stderr, _ ("Unsupported type `%s'\n"), typestring);
1065  ret = 1;
1066  return;
1067  }
1068  if (NULL == value)
1069  {
1070  fprintf (stderr,
1071  _ ("Missing option `%s' for operation `%s'\n"),
1072  "-V",
1073  _ ("add"));
1074  ret = 1;
1076  return;
1077  }
1078  if (GNUNET_OK !=
1080  {
1081  fprintf (stderr,
1082  _ ("Value `%s' invalid for record type `%s'\n"),
1083  value,
1084  typestring);
1086  ret = 1;
1087  return;
1088  }
1089  if (NULL == expirationstring)
1090  {
1091  fprintf (stderr,
1092  _ ("Missing option `%s' for operation `%s'\n"),
1093  "-e",
1094  _ ("add"));
1096  ret = 1;
1097  return;
1098  }
1100  {
1101  fprintf (stderr, _ ("Invalid time format `%s'\n"), expirationstring);
1103  ret = 1;
1104  return;
1105  }
1106  add_qe = GNUNET_NAMESTORE_records_lookup (ns,
1107  &zone_pkey,
1108  name,
1109  &add_error_cb,
1110  NULL,
1112  NULL);
1113  }
1114  if (del)
1115  {
1116  if (NULL == name)
1117  {
1118  fprintf (stderr,
1119  _ ("Missing option `%s' for operation `%s'\n"),
1120  "-n",
1121  _ ("del"));
1123  ret = 1;
1124  return;
1125  }
1126  del_qe = GNUNET_NAMESTORE_records_lookup (ns,
1127  &zone_pkey,
1128  name,
1130  NULL,
1131  &del_monitor,
1132  NULL);
1133  }
1134  if (list)
1135  {
1136  if (NULL != name)
1137  get_qe = GNUNET_NAMESTORE_records_lookup (ns,
1138  &zone_pkey,
1139  name,
1140  &lookup_error_cb,
1141  NULL,
1143  NULL);
1144  else
1146  &zone_pkey,
1148  NULL,
1150  NULL,
1152  NULL);
1153  }
1154  if (NULL != reverse_pkey)
1155  {
1156  struct GNUNET_CRYPTO_EcdsaPublicKey pubkey;
1157 
1158  if (GNUNET_OK !=
1160  strlen (reverse_pkey),
1161  &pubkey))
1162  {
1163  fprintf (stderr,
1164  _ ("Invalid public key for reverse lookup `%s'\n"),
1165  reverse_pkey);
1167  }
1168  reverse_qe = GNUNET_NAMESTORE_zone_to_name (ns,
1169  &zone_pkey,
1170  &pubkey,
1172  NULL,
1174  NULL);
1175  }
1176  if (NULL != uri)
1177  {
1178  char sh[105];
1179  char sname[64];
1180  struct GNUNET_CRYPTO_EcdsaPublicKey pkey;
1181 
1183  if ((2 != (sscanf (uri, "gnunet://gns/%52s/%63s", sh, sname))) ||
1184  (GNUNET_OK !=
1185  GNUNET_CRYPTO_ecdsa_public_key_from_string (sh, strlen (sh), &pkey)))
1186  {
1187  fprintf (stderr, _ ("Invalid URI `%s'\n"), uri);
1189  ret = 1;
1190  return;
1191  }
1192  memset (&rd, 0, sizeof (rd));
1193  rd.data = &pkey;
1194  rd.data_size = sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey);
1196  rd.expiration_time = etime;
1197  if (GNUNET_YES == etime_is_rel)
1199  if (1 == is_shadow)
1201  add_qe_uri = GNUNET_NAMESTORE_records_store (ns,
1202  &zone_pkey,
1203  sname,
1204  1,
1205  &rd,
1207  &add_qe_uri);
1208  }
1209  if (NULL != nickstring)
1210  {
1211  if (0 == strlen (nickstring))
1212  {
1213  fprintf (stderr, _ ("Invalid nick `%s'\n"), nickstring);
1215  ret = 1;
1216  return;
1217  }
1218  add_qe_uri = GNUNET_NAMESTORE_set_nick (ns,
1219  &zone_pkey,
1220  nickstring,
1222  &add_qe_uri);
1223  }
1224  if (monitor)
1225  {
1227  &zone_pkey,
1228  GNUNET_YES,
1230  NULL,
1232  NULL,
1233  &sync_cb,
1234  NULL);
1235  }
1236 }
1237 
1238 
1246 static void
1247 identity_cb (void *cls, const struct GNUNET_IDENTITY_Ego *ego)
1248 {
1249  const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
1250 
1251  el = NULL;
1252  if ((NULL != name) && (0 != strchr (name, '.')))
1253  {
1254  fprintf (stderr,
1255  _ ("Label `%s' contains `.' which is not allowed\n"),
1256  name);
1258  ret = -1;
1259  return;
1260  }
1261 
1262  if (NULL == ego)
1263  {
1264  if (NULL != ego_name)
1265  {
1266  fprintf (stderr,
1267  _ ("Ego `%s' not known to identity service\n"),
1268  ego_name);
1269  }
1271  ret = -1;
1272  return;
1273  }
1276  ego_name = NULL;
1277  run_with_zone_pkey (cfg);
1278 }
1279 
1280 
1291 static void
1292 default_ego_cb (void *cls,
1293  struct GNUNET_IDENTITY_Ego *ego,
1294  void **ctx,
1295  const char *name)
1296 {
1297  const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
1298 
1299  (void) ctx;
1300  (void) name;
1301  get_default = NULL;
1302  if (NULL == ego)
1303  {
1304  fprintf (stderr, _ ("No default ego configured in identity service\n"));
1306  ret = -1;
1307  return;
1308  }
1309  else
1310  {
1311  identity_cb ((void *) cfg, ego);
1312  }
1313 }
1314 
1315 
1328 static void
1329 id_connect_cb (void *cls,
1330  struct GNUNET_IDENTITY_Ego *ego,
1331  void **ctx,
1332  const char *name)
1333 {
1334  const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
1335 
1336  (void) ctx;
1337  (void) name;
1338  if (NULL != ego)
1339  return;
1340  get_default =
1341  GNUNET_IDENTITY_get (idh, "namestore", &default_ego_cb, (void *) cfg);
1342 }
1343 
1344 
1353 static void
1354 run (void *cls,
1355  char *const *args,
1356  const char *cfgfile,
1357  const struct GNUNET_CONFIGURATION_Handle *cfg)
1358 {
1359  const char *pkey_str;
1360 
1361  (void) cls;
1362  (void) args;
1363  (void) cfgfile;
1364  if (NULL != args[0])
1365  GNUNET_log (
1367  _ ("Superfluous command line arguments (starting with `%s') ignored\n"),
1368  args[0]);
1369  if ((NULL != args[0]) && (NULL == uri))
1370  uri = GNUNET_strdup (args[0]);
1371 
1372  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, (void *) cfg);
1373  pkey_str = getenv ("GNUNET_NAMESTORE_EGO_PRIVATE_KEY");
1374  if (NULL != pkey_str)
1375  {
1376  if (GNUNET_OK != GNUNET_STRINGS_string_to_data (pkey_str,
1377  strlen (pkey_str),
1378  &zone_pkey,
1379  sizeof (zone_pkey)))
1380  {
1381  fprintf (stderr,
1382  "Malformed private key `%s' in $%s\n",
1383  pkey_str,
1384  "GNUNET_NAMESTORE_EGO_PRIVATE_KEY");
1385  ret = 1;
1387  return;
1388  }
1389  run_with_zone_pkey (cfg);
1390  return;
1391  }
1392  if (NULL == ego_name)
1393  {
1394  idh = GNUNET_IDENTITY_connect (cfg, &id_connect_cb, (void *) cfg);
1395  if (NULL == idh)
1396  fprintf (stderr, _ ("Cannot connect to identity service\n"));
1397  ret = -1;
1398  return;
1399  }
1400  el = GNUNET_IDENTITY_ego_lookup (cfg, ego_name, &identity_cb, (void *) cfg);
1401 }
1402 
1403 
1421 static int
1423  void *scls,
1424  const char *option,
1425  const char *value)
1426 {
1427  struct RecordSetEntry **head = scls;
1428  struct RecordSetEntry *r;
1429  struct GNUNET_GNSRECORD_Data record;
1430  char *cp;
1431  char *tok;
1432  char *saveptr;
1433  int etime_is_rel;
1434  void *raw_data;
1435 
1436  (void) ctx;
1437  (void) option;
1438  cp = GNUNET_strdup (value);
1439  tok = strtok_r (cp, " ", &saveptr);
1440  if (NULL == tok)
1441  {
1443  _ ("Empty record line argument is not allowed.\n"));
1444  GNUNET_free (cp);
1445  return GNUNET_SYSERR;
1446  }
1447  {
1448  char *etime_in_s;
1449 
1450  GNUNET_asprintf (&etime_in_s, "%s s", tok);
1451  if (GNUNET_OK !=
1452  parse_expiration (etime_in_s, &etime_is_rel, &record.expiration_time))
1453  {
1455  _ ("Invalid expiration time `%s' (must be without unit)\n"),
1456  tok);
1457  GNUNET_free (cp);
1458  GNUNET_free (etime_in_s);
1459  return GNUNET_SYSERR;
1460  }
1461  GNUNET_free (etime_in_s);
1462  }
1463  tok = strtok_r (NULL, " ", &saveptr);
1464  if (NULL == tok)
1465  {
1467  _ ("Missing entries in record line `%s'.\n"),
1468  value);
1469  GNUNET_free (cp);
1470  return GNUNET_SYSERR;
1471  }
1473  if (UINT32_MAX == record.record_type)
1474  {
1475  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _ ("Unknown record type `%s'\n"), tok);
1476  GNUNET_free (cp);
1477  return GNUNET_SYSERR;
1478  }
1479  tok = strtok_r (NULL, " ", &saveptr);
1480  if (NULL == tok)
1481  {
1483  _ ("Missing entries in record line `%s'.\n"),
1484  value);
1485  GNUNET_free (cp);
1486  return GNUNET_SYSERR;
1487  }
1489  if (etime_is_rel)
1491  if (NULL == strchr (tok, (unsigned char) 'p')) /* p = public */
1493  if (NULL != strchr (tok, (unsigned char) 's'))
1495  /* find beginning of record value */
1496  tok = strchr (&value[tok - cp], (unsigned char) ' ');
1497  if (NULL == tok)
1498  {
1500  _ ("Missing entries in record line `%s'.\n"),
1501  value);
1502  GNUNET_free (cp);
1503  return GNUNET_SYSERR;
1504  }
1505  GNUNET_free (cp);
1506  tok++; /* skip space */
1508  tok,
1509  &raw_data,
1510  &record.data_size))
1511  {
1513  _ ("Invalid record data for type %s: `%s'.\n"),
1515  tok);
1516  return GNUNET_SYSERR;
1517  }
1518 
1519  r = GNUNET_malloc (sizeof (struct RecordSetEntry) + record.data_size);
1520  r->next = *head;
1521  record.data = &r[1];
1522  memcpy (&r[1], raw_data, record.data_size);
1523  GNUNET_free (raw_data);
1524  r->record = record;
1525  *head = r;
1526  return GNUNET_OK;
1527 }
1528 
1529 
1541  const char *name,
1542  const char *argumentHelp,
1543  const char *description,
1544  struct RecordSetEntry **rs)
1545 {
1547  .name = name,
1548  .argumentHelp = argumentHelp,
1549  .description = description,
1550  .require_argument = 1,
1551  .processor =
1553  .scls = (void *) rs};
1554 
1555  return clo;
1556 }
1557 
1558 
1566 int
1567 main (int argc, char *const *argv)
1568 {
1569  struct GNUNET_GETOPT_CommandLineOption options[] =
1570  {GNUNET_GETOPT_option_flag ('a', "add", gettext_noop ("add record"), &add),
1572  "delete",
1573  gettext_noop ("delete record"),
1574  &del),
1576  "display",
1577  gettext_noop ("display records"),
1578  &list),
1580  'e',
1581  "expiration",
1582  "TIME",
1583  gettext_noop (
1584  "expiration time for record to use (for adding only), \"never\" is possible"),
1585  &expirationstring),
1587  "nick",
1588  "NICKNAME",
1589  gettext_noop (
1590  "set the desired nick name for the zone"),
1591  &nickstring),
1593  "monitor",
1594  gettext_noop (
1595  "monitor changes in the namestore"),
1596  &monitor),
1598  "name",
1599  "NAME",
1600  gettext_noop (
1601  "name of the record to add/delete/display"),
1602  &name),
1604  "reverse",
1605  "PKEY",
1606  gettext_noop (
1607  "determine our name for the given PKEY"),
1608  &reverse_pkey),
1610  'R',
1611  "replace",
1612  "RECORDLINE",
1613  gettext_noop (
1614  "set record set to values given by (possibly multiple) RECORDLINES; can be specified multiple times"),
1615  &recordset),
1617  "type",
1618  "TYPE",
1619  gettext_noop (
1620  "type of the record to add/delete/display"),
1621  &typestring),
1623  "uri",
1624  "URI",
1625  gettext_noop ("URI to import into our zone"),
1626  &uri),
1628  "value",
1629  "VALUE",
1630  gettext_noop (
1631  "value of the record to add/delete"),
1632  &value),
1634  "public",
1635  gettext_noop ("create or list public record"),
1636  &is_public),
1638  's',
1639  "shadow",
1640  gettext_noop (
1641  "create shadow record (only valid if all other records of the same type have expired"),
1642  &is_shadow),
1644  "zone",
1645  "EGO",
1646  gettext_noop (
1647  "name of the ego controlling the zone"),
1648  &ego_name),
1650  int lret;
1651 
1652  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
1653  return 2;
1654 
1655  is_public = -1;
1656  is_shadow = -1;
1657  GNUNET_log_setup ("gnunet-namestore", "WARNING", NULL);
1658  if (GNUNET_OK !=
1659  (lret = GNUNET_PROGRAM_run (argc,
1660  argv,
1661  "gnunet-namestore",
1662  _ ("GNUnet zone manipulation tool"),
1663  options,
1664  &run,
1665  NULL)))
1666  {
1667  GNUNET_free ((void *) argv);
1669  return lret;
1670  }
1671  GNUNET_free ((void *) argv);
1673  return ret;
1674 }
1675 
1676 /* end of gnunet-namestore.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
General context for command line processors.
static void add_error_cb(void *cls)
Function called if lookup fails.
void GNUNET_IDENTITY_cancel(struct GNUNET_IDENTITY_Operation *op)
Cancel an identity operation.
Definition: identity_api.c:819
static struct GNUNET_DATASTORE_QueueEntry * qe
Current operation.
This record should not be used unless all (other) records with an absolute expiration time have expir...
struct RecordSetEntry * next
Kept in a linked list.
const char * argumentHelp
Name of the argument for the user in help text.
void GNUNET_IDENTITY_ego_lookup_cancel(struct GNUNET_IDENTITY_EgoLookup *el)
Abort ego lookup attempt.
Handle for ego lookup.
uint64_t rel_value_us
The actual value.
static struct GNUNET_NAMESTORE_QueueEntry * add_qe
Queue entry for the &#39;add&#39; operation.
static void lookup_error_cb(void *cls)
Function called on errors while monitoring.
static char * pkey
Public key of the zone to look in, in ASCII.
static int parse_expiration(const char *expirationstring, int *etime_is_rel, uint64_t *etime)
Parse expiration time.
static struct GNUNET_NAMESTORE_QueueEntry * add_qe_uri
Queue entry for the &#39;add-uri&#39; operation.
struct GNUNET_NAMESTORE_ZoneMonitor * GNUNET_NAMESTORE_zone_monitor_start(const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, int iterate_first, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_NAMESTORE_RecordMonitor monitor, void *monitor_cls, GNUNET_SCHEDULER_TaskCallback sync_cb, void *sync_cb_cls)
Begin monitoring a zone for changes.
Definition: w32nsp.c:83
#define GNUNET_GNS_EMPTY_LABEL_AT
String we use to indicate an empty label (top-level entry in the zone).
static void run_with_zone_pkey(const struct GNUNET_CONFIGURATION_Handle *cfg)
We have obtained the zone&#39;s private key, so now process the main commands using it.
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
#define GNUNET_DNSPARSER_TYPE_CNAME
#define FPRINTF
Definition: plibc.h:683
struct GNUNET_NAMESTORE_QueueEntry * GNUNET_NAMESTORE_records_lookup(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey, const char *label, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_NAMESTORE_RecordMonitor rm, void *rm_cls)
Lookup an item in the namestore.
static void sync_cb(void *cls)
Function called once we are in sync in monitor mode.
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)...
const char * description
Help text for the option (description)
static struct GNUNET_IDENTITY_EgoLookup * el
Handle to identity lookup.
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
uint32_t GNUNET_GNSRECORD_typename_to_number(const char *dns_typename)
Convert a type name (i.e.
Definition: gnsrecord.c:204
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
int GNUNET_STRINGS_fancy_time_to_relative(const char *fancy_time, struct GNUNET_TIME_Relative *rtime)
Convert a given fancy human-readable time to our internal representation.
Definition: strings.c:353
#define GNUNET_GNSRECORD_TYPE_ANY
Record type indicating any record/&#39;*&#39;.
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
static void handle_reverse_lookup(void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Function called with the result of our attempt to obtain a name for a given public key...
static void do_shutdown(void *cls)
Task run on shutdown.
static void * data
Value in binary format.
int GNUNET_STRINGS_fancy_time_to_absolute(const char *fancy_time, struct GNUNET_TIME_Absolute *atime)
Convert a given fancy human-readable time to our internal representation.
Definition: strings.c:408
struct GNUNET_IDENTITY_Operation * GNUNET_IDENTITY_get(struct GNUNET_IDENTITY_Handle *h, const char *service_name, GNUNET_IDENTITY_Callback cb, void *cb_cls)
Obtain the identity that is currently preferred/default for a service.
Definition: identity_api.c:587
void GNUNET_NAMESTORE_zone_monitor_stop(struct GNUNET_NAMESTORE_ZoneMonitor *zm)
Stop monitoring a zone for changes.
int main(int argc, char *const *argv)
The main function for gnunet-namestore.
static struct Experiment * e
static struct GNUNET_NAMESTORE_ZoneMonitor * zm
Monitor handle.
static void get_existing_record(void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key, const char *rec_name, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
We&#39;re storing a record; this function is given the existing record so that we can merge the informati...
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
size_t data_size
Number of bytes in data.
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
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 char * name
Name of the records to add/list/remove.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:524
static void zone_iteration_finished(void *cls)
Function called when we are done with a zone iteration.
const char shortName
Short name of the option.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_GNSRECORD_TYPE_NICK
Record type for GNS nick names ("NICK").
static struct RecordSetEntry * recordset
Entry in record set for processing records in bulk.
uint64_t abs_value_us
The actual value.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
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 void zone_iteration_error_cb(void *cls)
Function called when we encountered an error in a zone iteration.
static struct GNUNET_DNSSTUB_Context * ctx
Context for DNS resolution.
static int etime_is_rel
Is expiration time relative or absolute time?
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 GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
#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.
static struct GNUNET_IDENTITY_Handle * idh
Identity service handle.
static void add_continuation(void *cls, int32_t success, const char *emsg)
Continuation called to notify client about result of the operation.
static char * zone
Name of the zone we manage.
void GNUNET_NAMESTORE_disconnect(struct GNUNET_NAMESTORE_Handle *h)
Disconnect from the namestore service (and free associated resources).
Handle for a monitoring activity.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
Handle for a zone iterator operation.
Handle for an ego.
Definition: identity.h:245
static void replace_cont(void *cls, int success, const char *emsg)
Function called when namestore is done with the replace operation.
static int is_shadow
Is record a shadow record (GNUNET_GNSRECORD_RF_SHADOW_RECORD)
#define GNUNET_DNSPARSER_TYPE_SOA
#define GNUNET_memcpy(dst, src, n)
const void * data
Binary value stored in the DNS record.
static void identity_cb(void *cls, const struct GNUNET_IDENTITY_Ego *ego)
Callback invoked from identity service with ego information.
static char * value
Value of the record to add/remove.
static int monitor
Enables monitor mode.
static int del
Desired action is to remove a record.
#define GNUNET_GNSRECORD_TYPE_PKEY
Record type for GNS zone transfer ("PKEY").
Connection to the NAMESTORE service.
Handle for the service.
Definition: identity_api.c:96
uint64_t expiration_time
Expiration time for the DNS record.
static int ret
Global return value.
static struct SolverHandle * sh
#define GNUNET_GNSRECORD_TYPE_GNS2DNS
Record type for delegation to DNS.
static struct GNUNET_NAMESTORE_QueueEntry * set_qe
Queue entry for the &#39;set/replace&#39; operation.
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:727
static void display_record_lookup(void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key, const char *rname, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd)
Process a record that was stored in the namestore.
static char * option
Name of the option.
Definition: gnunet-config.c:38
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
static void id_connect_cb(void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *name)
Function called with ALL of the egos known to the identity service, used on startup if the user did n...
void GNUNET_IDENTITY_disconnect(struct GNUNET_IDENTITY_Handle *h)
Disconnect from identity service.
Definition: identity_api.c:838
static void del_continuation(void *cls, int32_t success, const char *emsg)
Continuation called to notify client about result of the operation.
This is a private record of this peer and it should thus not be handed out to other peers...
void GNUNET_NAMESTORE_zone_iteration_stop(struct GNUNET_NAMESTORE_ZoneIterator *it)
Stops iteration and releases the namestore handle for further calls.
static void del_monitor(void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
We were asked to delete something; this function is called with the existing records.
int GNUNET_GNSRECORD_string_to_value(uint32_t type, const char *s, void **data, size_t *data_size)
Convert human-readable version of a &#39;value&#39; of a record to the binary representation.
Definition: gnsrecord.c:175
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:104
static void run(void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
Main function that will be run.
static struct GNUNET_NAMESTORE_QueueEntry * reverse_qe
Queue entry for the &#39;reverse lookup&#39; operation (in combination with a name).
static uint64_t etime
Expiration string converted to numeric value.
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
An QueueEntry used to store information for a pending NAMESTORE record operation. ...
Definition: namestore_api.c:53
static char * reverse_pkey
Reverse lookup to perform.
static char * expirationstring
Desired expiration time.
struct GNUNET_NAMESTORE_Handle * GNUNET_NAMESTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the namestore service.
char * getenv()
static void test_finished()
Check if we are finished, and if so, perform shutdown.
static char * uri
URI to import.
struct GNUNET_GNSRECORD_Data record
The record to add/remove.
static int is_public
Is record public (opposite of GNUNET_GNSRECORD_RF_PRIVATE)
static int add
Desired action is to add a record.
static int list
Desired action is to list records.
static void display_record_iterator(void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key, const char *rname, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd)
Process a record that was stored in the namestore.
static void default_ego_cb(void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *name)
Function called with the default ego to be used for GNS operations.
Entry in record set for bulk processing.
static void display_record_monitor(void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key, const char *rname, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd)
Process a record that was stored in the namestore.
struct GNUNET_IDENTITY_EgoLookup * GNUNET_IDENTITY_ego_lookup(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *name, GNUNET_IDENTITY_EgoCallback cb, void *cb_cls)
Lookup an ego by name.
struct GNUNET_IDENTITY_Operation * get_default
Obtain default ego.
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
static uint32_t type
Type string converted to DNS type value.
uint32_t record_type
Type of the GNS/DNS record.
static void del_lookup_error_cb(void *cls)
Function called if lookup for deletion fails.
static char * nickstring
Desired nick name.
configuration data
Definition: configuration.c:85
static struct PendingResolutions * head
Head of list of pending resolution requests.
Definition: gnunet-ats.c:231
static char * ego_name
Name of the ego controlling the zone.
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
static struct GNUNET_CRYPTO_EcdsaPrivateKey zone_pkey
Private key for the our zone.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_flag(char shortName, const char *name, const char *description, int *val)
Allow user to specify a flag (which internally means setting an integer to 1/GNUNET_YES/GNUNET_OK.
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,...)
static struct GNUNET_NAMESTORE_ZoneIterator * list_it
List iterator for the &#39;list&#39; operation.
static void monitor_error_cb(void *cls)
Function called on errors while monitoring.
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
static struct GNUNET_NAMESTORE_QueueEntry * get_qe
Queue entry for the &#39;lookup&#39; operation.
static struct GNUNET_NAMESTORE_QueueEntry * del_qe
Queue entry for the &#39;del&#39; operation.
Time for absolute times used by GNUnet, in microseconds.
#define GNUNET_YES
Definition: gnunet_common.h:80
static char * typestring
Type of the record to add/remove, NULL to remove all.
static void display_record(const char *rname, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd)
Process a record that was stored in the namestore.
enum GNUNET_GNSRECORD_Flags flags
Flags for the record.
This flag is currently unused; former RF_PENDING flag.
const char * GNUNET_STRINGS_absolute_time_to_string(struct GNUNET_TIME_Absolute t)
Like asctime, except for GNUnet time.
Definition: strings.c:792
int GNUNET_log_setup(const char *comp, const char *loglevel, const char *logfile)
Setup logging.
static void reverse_error_cb(void *cls)
Function called if we encountered an error in zone-to-name.
struct GNUNET_NAMESTORE_QueueEntry * GNUNET_NAMESTORE_set_nick(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey, const char *nick, GNUNET_NAMESTORE_ContinuationWithStatus cont, void *cont_cls)
Set the desired nick name for a zone.
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 multirecord_process(struct GNUNET_GETOPT_CommandLineProcessorContext *ctx, void *scls, const char *option, const char *value)
Command-line option parser function that allows the user to specify a complete record as one argument...
static size_t data_size
Number of bytes in data.
const char * GNUNET_GNSRECORD_number_to_typename(uint32_t type)
Convert a type number (i.e.
Definition: gnsrecord.c:231
void GNUNET_NAMESTORE_zone_monitor_next(struct GNUNET_NAMESTORE_ZoneMonitor *zm, uint64_t limit)
Calls the monitor processor specified in GNUNET_NAMESTORE_zone_monitor_start for the next record(s)...
static struct GNUNET_NAMESTORE_Handle * ns
Handle to the namestore.
#define GNUNET_malloc(size)
Wrapper around malloc.
int GNUNET_STRINGS_string_to_data(const char *enc, size_t enclen, void *out, size_t out_size)
Convert CrockfordBase32 encoding back to data.
Definition: strings.c:1021
#define GNUNET_free(ptr)
Wrapper around free.
Time for relative time used by GNUnet, in microseconds.
struct GNUNET_GETOPT_CommandLineOption multirecord_option(char shortName, const char *name, const char *argumentHelp, const char *description, struct RecordSetEntry **rs)
Allow user to specify keywords.
void GNUNET_STRINGS_utf8_tolower(const char *input, char *output)
Convert the utf-8 input string to lower case.
Definition: strings.c:558
#define gettext_noop(String)
Definition: gettext.h:69