GNUnet  0.11.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;
662 
664  fprintf (
665  stderr,
666  _ (
667  "A %s record exists already under `%s', no other records can be added.\n"),
668  "PKEY",
669  rec_name);
670  ret = 1;
671  test_finished ();
672  return;
673 
676  {
677  fprintf (
678  stderr,
679  _ (
680  "A SOA record exists already under `%s', cannot add a second SOA to the same zone.\n"),
681  rec_name);
682  ret = 1;
683  test_finished ();
684  return;
685  }
686  break;
687  }
688  }
689  switch (type)
690  {
692  if (0 != rd_count)
693  {
694  fprintf (stderr,
695  _ (
696  "Records already exist under `%s', cannot add `%s' record.\n"),
697  rec_name,
698  "CNAME");
699  ret = 1;
700  test_finished ();
701  return;
702  }
703  break;
704 
706  if (0 != rd_count)
707  {
708  fprintf (stderr,
709  _ (
710  "Records already exist under `%s', cannot add `%s' record.\n"),
711  rec_name,
712  "PKEY");
713  ret = 1;
714  test_finished ();
715  return;
716  }
717  break;
718 
720  for (unsigned int i = 0; i < rd_count; i++)
722  {
723  fprintf (
724  stderr,
725  _ (
726  "Non-GNS2DNS records already exist under `%s', cannot add GNS2DNS record.\n"),
727  rec_name);
728  ret = 1;
729  test_finished ();
730  return;
731  }
732  break;
733  }
734  memset (rdn, 0, sizeof(struct GNUNET_GNSRECORD_Data));
735  GNUNET_memcpy (&rdn[1], rd, rd_count * sizeof(struct GNUNET_GNSRECORD_Data));
736  rde = &rdn[0];
737  rde->data = data;
738  rde->data_size = data_size;
739  rde->record_type = type;
740  if (1 == is_shadow)
742  if (1 != is_public)
744  rde->expiration_time = etime;
745  if (GNUNET_YES == etime_is_rel)
747  else if (GNUNET_NO != etime_is_rel)
748  rde->expiration_time = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
749  GNUNET_assert (NULL != name);
750  add_qe = GNUNET_NAMESTORE_records_store (ns,
751  &zone_pkey,
752  name,
753  rd_count + 1,
754  rde,
756  &add_qe);
757 }
758 
759 
763 static void
764 reverse_error_cb (void *cls)
765 {
766  (void) cls;
767  reverse_qe = NULL;
768  fprintf (stdout, "%s.zkey\n", reverse_pkey);
769 }
770 
771 
782 static void
784  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
785  const char *label,
786  unsigned int rd_count,
787  const struct GNUNET_GNSRECORD_Data *rd)
788 {
789  (void) cls;
790  (void) zone;
791  (void) rd_count;
792  (void) rd;
793  reverse_qe = NULL;
794  if (NULL == label)
795  fprintf (stdout, "%s\n", reverse_pkey);
796  else
797  fprintf (stdout, "%s.%s\n", label, ego_name);
798  test_finished ();
799 }
800 
801 
805 static void
807 {
808  (void) cls;
809  del_qe = NULL;
810  GNUNET_break (0);
811  ret = 1;
812  test_finished ();
813 }
814 
815 
827 static void
828 del_monitor (void *cls,
829  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
830  const char *label,
831  unsigned int rd_count,
832  const struct GNUNET_GNSRECORD_Data *rd)
833 {
834  struct GNUNET_GNSRECORD_Data rdx[rd_count];
835  unsigned int rd_left;
836  uint32_t type;
837  char *vs;
838 
839  (void) cls;
840  (void) zone;
841  del_qe = NULL;
842  if (0 == rd_count)
843  {
844  fprintf (stderr,
845  _ (
846  "There are no records under label `%s' that could be deleted.\n"),
847  label);
848  ret = 1;
849  test_finished ();
850  return;
851  }
852  if ((NULL == value) && (NULL == typestring))
853  {
854  /* delete everything */
855  del_qe = GNUNET_NAMESTORE_records_store (ns,
856  &zone_pkey,
857  name,
858  0,
859  NULL,
861  NULL);
862  return;
863  }
864  rd_left = 0;
865  if (NULL != typestring)
867  else
869  for (unsigned int i = 0; i < rd_count; i++)
870  {
871  vs = NULL;
872  if (! (((GNUNET_GNSRECORD_TYPE_ANY == type) ||
873  (rd[i].record_type == type)) &&
874  ((NULL == value) ||
875  (NULL ==
877  rd[i].data,
878  rd[i].data_size)))) ||
879  (0 == strcmp (vs, value)))))
880  rdx[rd_left++] = rd[i];
882  }
883  if (rd_count == rd_left)
884  {
885  /* nothing got deleted */
886  fprintf (
887  stderr,
888  _ (
889  "There are no records under label `%s' that match the request for deletion.\n"),
890  label);
891  test_finished ();
892  return;
893  }
894  /* delete everything but what we copied to 'rdx' */
895  del_qe = GNUNET_NAMESTORE_records_store (ns,
896  &zone_pkey,
897  name,
898  rd_left,
899  rdx,
901  NULL);
902 }
903 
904 
913 static int
915  int *etime_is_rel,
916  uint64_t *etime)
917 {
918  struct GNUNET_TIME_Relative etime_rel;
919  struct GNUNET_TIME_Absolute etime_abs;
920 
921  if (0 == strcmp (expirationstring, "never"))
922  {
923  *etime = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
924  *etime_is_rel = GNUNET_NO;
925  return GNUNET_OK;
926  }
927  if (GNUNET_OK ==
928  GNUNET_STRINGS_fancy_time_to_relative (expirationstring, &etime_rel))
929  {
930  *etime_is_rel = GNUNET_YES;
931  *etime = etime_rel.rel_value_us;
933  "Storing record with relative expiration time of %s\n",
935  return GNUNET_OK;
936  }
937  if (GNUNET_OK ==
938  GNUNET_STRINGS_fancy_time_to_absolute (expirationstring, &etime_abs))
939  {
940  *etime_is_rel = GNUNET_NO;
941  *etime = etime_abs.abs_value_us;
943  "Storing record with absolute expiration time of %s\n",
945  return GNUNET_OK;
946  }
947  return GNUNET_SYSERR;
948 }
949 
950 
961 static void
962 replace_cont (void *cls, int success, const char *emsg)
963 {
964  (void) cls;
965 
966  set_qe = NULL;
967  if (GNUNET_OK != success)
968  {
970  _ ("Failed to replace records: %s\n"),
971  emsg);
972  ret = 1; /* fail from 'main' */
973  }
975 }
976 
977 
984 static void
986 {
987  struct GNUNET_GNSRECORD_Data rd;
988 
989  if (! (add | del | list | (NULL != nickstring) | (NULL != uri)
990  | (NULL != reverse_pkey) | (NULL != recordset)))
991  {
992  /* nothing more to be done */
993  fprintf (stderr, _ ("No options given\n"));
995  return;
996  }
997  ns = GNUNET_NAMESTORE_connect (cfg);
998  if (NULL == ns)
999  {
1001  _ ("Failed to connect to namestore\n"));
1002  return;
1003  }
1004 
1005  if (NULL != recordset)
1006  {
1007  /* replace entire record set */
1008  unsigned int rd_count;
1009  struct GNUNET_GNSRECORD_Data *rd;
1010 
1011  if (NULL == name)
1012  {
1013  fprintf (stderr,
1014  _ ("Missing option `%s' for operation `%s'\n"),
1015  "-R",
1016  _ ("replace"));
1018  ret = 1;
1019  return;
1020  }
1021  rd_count = 0;
1022  for (struct RecordSetEntry *e = recordset; NULL != e; e = e->next)
1023  rd_count++;
1024  rd = GNUNET_new_array (rd_count, struct GNUNET_GNSRECORD_Data);
1025  rd_count = 0;
1026  for (struct RecordSetEntry *e = recordset; NULL != e; e = e->next)
1027  {
1028  rd[rd_count] = e->record;
1029  rd_count++;
1030  }
1031  set_qe = GNUNET_NAMESTORE_records_store (ns,
1032  &zone_pkey,
1033  name,
1034  rd_count,
1035  rd,
1036  &replace_cont,
1037  NULL);
1038  GNUNET_free (rd);
1039  return;
1040  }
1041 
1042  if (add)
1043  {
1044  if (NULL == name)
1045  {
1046  fprintf (stderr,
1047  _ ("Missing option `%s' for operation `%s'\n"),
1048  "-n",
1049  _ ("add"));
1051  ret = 1;
1052  return;
1053  }
1054  if (NULL == typestring)
1055  {
1056  fprintf (stderr,
1057  _ ("Missing option `%s' for operation `%s'\n"),
1058  "-t",
1059  _ ("add"));
1061  ret = 1;
1062  return;
1063  }
1065  if (UINT32_MAX == type)
1066  {
1067  fprintf (stderr, _ ("Unsupported type `%s'\n"), typestring);
1069  ret = 1;
1070  return;
1071  }
1072  if (NULL == value)
1073  {
1074  fprintf (stderr,
1075  _ ("Missing option `%s' for operation `%s'\n"),
1076  "-V",
1077  _ ("add"));
1078  ret = 1;
1080  return;
1081  }
1082  if (GNUNET_OK !=
1084  {
1085  fprintf (stderr,
1086  _ ("Value `%s' invalid for record type `%s'\n"),
1087  value,
1088  typestring);
1090  ret = 1;
1091  return;
1092  }
1093  if (NULL == expirationstring)
1094  {
1095  fprintf (stderr,
1096  _ ("Missing option `%s' for operation `%s'\n"),
1097  "-e",
1098  _ ("add"));
1100  ret = 1;
1101  return;
1102  }
1104  {
1105  fprintf (stderr, _ ("Invalid time format `%s'\n"), expirationstring);
1107  ret = 1;
1108  return;
1109  }
1110  add_qe = GNUNET_NAMESTORE_records_lookup (ns,
1111  &zone_pkey,
1112  name,
1113  &add_error_cb,
1114  NULL,
1116  NULL);
1117  }
1118  if (del)
1119  {
1120  if (NULL == name)
1121  {
1122  fprintf (stderr,
1123  _ ("Missing option `%s' for operation `%s'\n"),
1124  "-n",
1125  _ ("del"));
1127  ret = 1;
1128  return;
1129  }
1130  del_qe = GNUNET_NAMESTORE_records_lookup (ns,
1131  &zone_pkey,
1132  name,
1134  NULL,
1135  &del_monitor,
1136  NULL);
1137  }
1138  if (list)
1139  {
1140  if (NULL != name)
1141  get_qe = GNUNET_NAMESTORE_records_lookup (ns,
1142  &zone_pkey,
1143  name,
1144  &lookup_error_cb,
1145  NULL,
1147  NULL);
1148  else
1150  &zone_pkey,
1152  NULL,
1154  NULL,
1156  NULL);
1157  }
1158  if (NULL != reverse_pkey)
1159  {
1160  struct GNUNET_CRYPTO_EcdsaPublicKey pubkey;
1161 
1162  if (GNUNET_OK !=
1164  strlen (reverse_pkey),
1165  &pubkey))
1166  {
1167  fprintf (stderr,
1168  _ ("Invalid public key for reverse lookup `%s'\n"),
1169  reverse_pkey);
1171  }
1172  reverse_qe = GNUNET_NAMESTORE_zone_to_name (ns,
1173  &zone_pkey,
1174  &pubkey,
1176  NULL,
1178  NULL);
1179  }
1180  if (NULL != uri)
1181  {
1182  char sh[105];
1183  char sname[64];
1184  struct GNUNET_CRYPTO_EcdsaPublicKey pkey;
1185 
1187  if ((2 != (sscanf (uri, "gnunet://gns/%52s/%63s", sh, sname))) ||
1188  (GNUNET_OK !=
1189  GNUNET_CRYPTO_ecdsa_public_key_from_string (sh, strlen (sh), &pkey)))
1190  {
1191  fprintf (stderr, _ ("Invalid URI `%s'\n"), uri);
1193  ret = 1;
1194  return;
1195  }
1196  memset (&rd, 0, sizeof(rd));
1197  rd.data = &pkey;
1198  rd.data_size = sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey);
1200  rd.expiration_time = etime;
1201  if (GNUNET_YES == etime_is_rel)
1203  if (1 == is_shadow)
1205  add_qe_uri = GNUNET_NAMESTORE_records_store (ns,
1206  &zone_pkey,
1207  sname,
1208  1,
1209  &rd,
1211  &add_qe_uri);
1212  }
1213  if (NULL != nickstring)
1214  {
1215  if (0 == strlen (nickstring))
1216  {
1217  fprintf (stderr, _ ("Invalid nick `%s'\n"), nickstring);
1219  ret = 1;
1220  return;
1221  }
1222  add_qe_uri = GNUNET_NAMESTORE_set_nick (ns,
1223  &zone_pkey,
1224  nickstring,
1226  &add_qe_uri);
1227  }
1228  if (monitor)
1229  {
1231  &zone_pkey,
1232  GNUNET_YES,
1234  NULL,
1236  NULL,
1237  &sync_cb,
1238  NULL);
1239  }
1240 }
1241 
1242 
1250 static void
1251 identity_cb (void *cls, const struct GNUNET_IDENTITY_Ego *ego)
1252 {
1253  const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
1254 
1255  el = NULL;
1256  if ((NULL != name) && (0 != strchr (name, '.')))
1257  {
1258  fprintf (stderr,
1259  _ ("Label `%s' contains `.' which is not allowed\n"),
1260  name);
1262  ret = -1;
1263  return;
1264  }
1265 
1266  if (NULL == ego)
1267  {
1268  if (NULL != ego_name)
1269  {
1270  fprintf (stderr,
1271  _ ("Ego `%s' not known to identity service\n"),
1272  ego_name);
1273  }
1275  ret = -1;
1276  return;
1277  }
1280  ego_name = NULL;
1281  run_with_zone_pkey (cfg);
1282 }
1283 
1284 
1295 static void
1296 default_ego_cb (void *cls,
1297  struct GNUNET_IDENTITY_Ego *ego,
1298  void **ctx,
1299  const char *name)
1300 {
1301  const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
1302 
1303  (void) ctx;
1304  (void) name;
1305  get_default = NULL;
1306  if (NULL == ego)
1307  {
1308  fprintf (stderr, _ ("No default ego configured in identity service\n"));
1310  ret = -1;
1311  return;
1312  }
1313  else
1314  {
1315  identity_cb ((void *) cfg, ego);
1316  }
1317 }
1318 
1319 
1332 static void
1333 id_connect_cb (void *cls,
1334  struct GNUNET_IDENTITY_Ego *ego,
1335  void **ctx,
1336  const char *name)
1337 {
1338  const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
1339 
1340  (void) ctx;
1341  (void) name;
1342  if (NULL != ego)
1343  return;
1344  get_default =
1345  GNUNET_IDENTITY_get (idh, "namestore", &default_ego_cb, (void *) cfg);
1346 }
1347 
1348 
1357 static void
1358 run (void *cls,
1359  char *const *args,
1360  const char *cfgfile,
1361  const struct GNUNET_CONFIGURATION_Handle *cfg)
1362 {
1363  const char *pkey_str;
1364 
1365  (void) cls;
1366  (void) args;
1367  (void) cfgfile;
1368  if (NULL != args[0])
1369  GNUNET_log (
1371  _ ("Superfluous command line arguments (starting with `%s') ignored\n"),
1372  args[0]);
1373  if ((NULL != args[0]) && (NULL == uri))
1374  uri = GNUNET_strdup (args[0]);
1375 
1376  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, (void *) cfg);
1377  pkey_str = getenv ("GNUNET_NAMESTORE_EGO_PRIVATE_KEY");
1378  if (NULL != pkey_str)
1379  {
1380  if (GNUNET_OK != GNUNET_STRINGS_string_to_data (pkey_str,
1381  strlen (pkey_str),
1382  &zone_pkey,
1383  sizeof(zone_pkey)))
1384  {
1385  fprintf (stderr,
1386  "Malformed private key `%s' in $%s\n",
1387  pkey_str,
1388  "GNUNET_NAMESTORE_EGO_PRIVATE_KEY");
1389  ret = 1;
1391  return;
1392  }
1393  run_with_zone_pkey (cfg);
1394  return;
1395  }
1396  if (NULL == ego_name)
1397  {
1398  idh = GNUNET_IDENTITY_connect (cfg, &id_connect_cb, (void *) cfg);
1399  if (NULL == idh)
1400  fprintf (stderr, _ ("Cannot connect to identity service\n"));
1401  ret = -1;
1402  return;
1403  }
1404  el = GNUNET_IDENTITY_ego_lookup (cfg, ego_name, &identity_cb, (void *) cfg);
1405 }
1406 
1407 
1425 static int
1427  void *scls,
1428  const char *option,
1429  const char *value)
1430 {
1431  struct RecordSetEntry **head = scls;
1432  struct RecordSetEntry *r;
1433  struct GNUNET_GNSRECORD_Data record;
1434  char *cp;
1435  char *tok;
1436  char *saveptr;
1437  int etime_is_rel;
1438  void *raw_data;
1439 
1440  (void) ctx;
1441  (void) option;
1442  cp = GNUNET_strdup (value);
1443  tok = strtok_r (cp, " ", &saveptr);
1444  if (NULL == tok)
1445  {
1447  _ ("Empty record line argument is not allowed.\n"));
1448  GNUNET_free (cp);
1449  return GNUNET_SYSERR;
1450  }
1451  {
1452  char *etime_in_s;
1453 
1454  GNUNET_asprintf (&etime_in_s, "%s s", tok);
1455  if (GNUNET_OK !=
1456  parse_expiration (etime_in_s, &etime_is_rel, &record.expiration_time))
1457  {
1459  _ ("Invalid expiration time `%s' (must be without unit)\n"),
1460  tok);
1461  GNUNET_free (cp);
1462  GNUNET_free (etime_in_s);
1463  return GNUNET_SYSERR;
1464  }
1465  GNUNET_free (etime_in_s);
1466  }
1467  tok = strtok_r (NULL, " ", &saveptr);
1468  if (NULL == tok)
1469  {
1471  _ ("Missing entries in record line `%s'.\n"),
1472  value);
1473  GNUNET_free (cp);
1474  return GNUNET_SYSERR;
1475  }
1477  if (UINT32_MAX == record.record_type)
1478  {
1479  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _ ("Unknown record type `%s'\n"), tok);
1480  GNUNET_free (cp);
1481  return GNUNET_SYSERR;
1482  }
1483  tok = strtok_r (NULL, " ", &saveptr);
1484  if (NULL == tok)
1485  {
1487  _ ("Missing entries in record line `%s'.\n"),
1488  value);
1489  GNUNET_free (cp);
1490  return GNUNET_SYSERR;
1491  }
1493  if (etime_is_rel)
1495  if (NULL == strchr (tok, (unsigned char) 'p')) /* p = public */
1497  if (NULL != strchr (tok, (unsigned char) 's'))
1499  /* find beginning of record value */
1500  tok = strchr (&value[tok - cp], (unsigned char) ' ');
1501  if (NULL == tok)
1502  {
1504  _ ("Missing entries in record line `%s'.\n"),
1505  value);
1506  GNUNET_free (cp);
1507  return GNUNET_SYSERR;
1508  }
1509  GNUNET_free (cp);
1510  tok++; /* skip space */
1512  tok,
1513  &raw_data,
1514  &record.data_size))
1515  {
1517  _ ("Invalid record data for type %s: `%s'.\n"),
1519  tok);
1520  return GNUNET_SYSERR;
1521  }
1522 
1523  r = GNUNET_malloc (sizeof(struct RecordSetEntry) + record.data_size);
1524  r->next = *head;
1525  record.data = &r[1];
1526  memcpy (&r[1], raw_data, record.data_size);
1527  GNUNET_free (raw_data);
1528  r->record = record;
1529  *head = r;
1530  return GNUNET_OK;
1531 }
1532 
1533 
1545  const char *name,
1546  const char *argumentHelp,
1547  const char *description,
1548  struct RecordSetEntry **rs)
1549 {
1551  .name = name,
1552  .argumentHelp = argumentHelp,
1553  .description = description,
1554  .require_argument = 1,
1555  .processor =
1557  .scls = (void *) rs };
1558 
1559  return clo;
1560 }
1561 
1562 
1570 int
1571 main (int argc, char *const *argv)
1572 {
1573  struct GNUNET_GETOPT_CommandLineOption options[] =
1574  { GNUNET_GETOPT_option_flag ('a', "add", gettext_noop ("add record"), &add),
1576  "delete",
1577  gettext_noop ("delete record"),
1578  &del),
1580  "display",
1581  gettext_noop ("display records"),
1582  &list),
1584  'e',
1585  "expiration",
1586  "TIME",
1587  gettext_noop (
1588  "expiration time for record to use (for adding only), \"never\" is possible"),
1589  &expirationstring),
1591  "nick",
1592  "NICKNAME",
1593  gettext_noop (
1594  "set the desired nick name for the zone"),
1595  &nickstring),
1597  "monitor",
1598  gettext_noop (
1599  "monitor changes in the namestore"),
1600  &monitor),
1602  "name",
1603  "NAME",
1604  gettext_noop (
1605  "name of the record to add/delete/display"),
1606  &name),
1608  "reverse",
1609  "PKEY",
1610  gettext_noop (
1611  "determine our name for the given PKEY"),
1612  &reverse_pkey),
1614  'R',
1615  "replace",
1616  "RECORDLINE",
1617  gettext_noop (
1618  "set record set to values given by (possibly multiple) RECORDLINES; can be specified multiple times"),
1619  &recordset),
1621  "type",
1622  "TYPE",
1623  gettext_noop (
1624  "type of the record to add/delete/display"),
1625  &typestring),
1627  "uri",
1628  "URI",
1629  gettext_noop ("URI to import into our zone"),
1630  &uri),
1632  "value",
1633  "VALUE",
1634  gettext_noop (
1635  "value of the record to add/delete"),
1636  &value),
1638  "public",
1639  gettext_noop ("create or list public record"),
1640  &is_public),
1642  's',
1643  "shadow",
1644  gettext_noop (
1645  "create shadow record (only valid if all other records of the same type have expired"),
1646  &is_shadow),
1648  "zone",
1649  "EGO",
1650  gettext_noop (
1651  "name of the ego controlling the zone"),
1652  &ego_name),
1654  int lret;
1655 
1656  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
1657  return 2;
1658 
1659  is_public = -1;
1660  is_shadow = -1;
1661  GNUNET_log_setup ("gnunet-namestore", "WARNING", NULL);
1662  if (GNUNET_OK !=
1663  (lret = GNUNET_PROGRAM_run (argc,
1664  argv,
1665  "gnunet-namestore",
1666  _ ("GNUnet zone manipulation tool"),
1667  options,
1668  &run,
1669  NULL)))
1670  {
1671  GNUNET_free ((void *) argv);
1673  return lret;
1674  }
1675  GNUNET_free ((void *) argv);
1677  return ret;
1678 }
1679 
1680 
1681 /* 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:527
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:818
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.
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 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.
#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:583
#define GNUNET_DNSPARSER_TYPE_CNAME
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:1300
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:1438
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:351
#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:555
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.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
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:402
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:586
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:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
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:526
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:181
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
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:95
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:687
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:837
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 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:76
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:466
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:230
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:367
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:77
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:742
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:952
#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:553
#define gettext_noop(String)
Definition: gettext.h:69