GNUnet 0.21.2
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 "gnunet_common.h"
29#include "platform.h"
30#include <gnunet_util_lib.h>
33#include <gnunet_gns_service.h>
35#include <inttypes.h>
36
41#define WARN_RELATIVE_EXPIRATION_LIMIT GNUNET_TIME_relative_multiply ( \
42 GNUNET_TIME_UNIT_MINUTES, 15)
43
48{
53
58};
59
64{
69
74
78 char *name;
79
84};
85
90{
94 struct EgoEntry *next;
95
99 struct EgoEntry *prev;
100
105
110};
111
116
121
126
130static char *ego_name;
131
136
141
146
151
156
161
166
170static struct EgoEntry *ego_head;
171
175static struct EgoEntry *ego_tail;
176
181
186
190static int list;
191
195static int add;
196
200static int del;
201
205static int is_public;
206
210static int is_shadow;
211
215static int is_maintenance;
216
220static int omit_private;
221
226
227
231static int purge_zone;
232
237
241static int purge_orphaned;
242
246static int list_orphaned;
247
252
257
262
266static char *name;
267
271static char *value;
272
276static char *uri;
277
281static char *reverse_pkey;
282
286static char *typestring;
287
291static char *expirationstring;
292
296static char *nickstring;
297
301static int ret;
302
306static uint32_t type;
307
311static void *data;
312
316static size_t data_size;
317
321static uint64_t etime;
322
327
332
336static int monitor;
337
342
347
348/* FIXME: Make array and grow as needed */
349#define INITIAL_RI_BUFFER_SIZE 5000
350
351static unsigned int ri_count = 0;
352
354
356static unsigned int record_info_capacity = 0;
357
358/* How many records to put simulatneously */
359static unsigned int max_batch_size = 1000;
360
369static int
371 int *etime_is_rel,
372 uint64_t *etime)
373{
374 struct GNUNET_TIME_Relative etime_rel;
375 struct GNUNET_TIME_Absolute etime_abs;
376
377 if (0 == strcmp (expirationstring, "never"))
378 {
379 *etime = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
381 return GNUNET_OK;
382 }
383 if (GNUNET_OK ==
385 {
387 *etime = etime_rel.rel_value_us;
389 {
391 "Relative expiration times of less than %s are not recommended. To improve availability, consider increasing this value.\n",
394 }
396 "Storing record with relative expiration time of %s\n",
398 return GNUNET_OK;
399 }
400 if (GNUNET_OK ==
402 {
404 *etime = etime_abs.abs_value_us;
406 "Storing record with absolute expiration time of %s\n",
408 return GNUNET_OK;
409 }
410 return GNUNET_SYSERR;
411}
412
413
414static int
416{
417 struct RecordSetEntry *r;
419 char *cp;
420 char *tok;
421 char *saveptr;
422 void *raw_data;
423
424 cp = GNUNET_strdup (line);
425 tok = strtok_r (cp, " ", &saveptr);
426 if (NULL == tok)
427 {
429 _ ("Missing entries in record line `%s'.\n"),
430 line);
431 GNUNET_free (cp);
432 return GNUNET_SYSERR;
433 }
435 if (UINT32_MAX == record.record_type)
436 {
437 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _ ("Unknown record type `%s'\n"), tok);
438 GNUNET_free (cp);
439 return GNUNET_SYSERR;
440 }
441 tok = strtok_r (NULL, " ", &saveptr);
442 if (NULL == tok)
443 {
445 _ ("Empty record line argument is not allowed.\n"));
446 GNUNET_free (cp);
447 return GNUNET_SYSERR;
448 }
449 if (1 != sscanf (tok, "%" SCNu64, &record.expiration_time))
450 {
451 fprintf (stderr,
452 _ ("Error parsing expiration time %s.\n"), tok);
453 GNUNET_free (cp);
454 return GNUNET_SYSERR;
455 }
456 tok = strtok_r (NULL, " ", &saveptr);
457 if (NULL == tok)
458 {
460 _ ("Empty record line argument is not allowed.\n"));
461 GNUNET_free (cp);
462 return GNUNET_SYSERR;
463 }
465 if (NULL != strchr (tok, (unsigned char) 'r'))
467 if (NULL == strchr (tok, (unsigned char) 'p')) /* p = public */
469 if (NULL != strchr (tok, (unsigned char) 'S'))
471 if (NULL != strchr (tok, (unsigned char) 's'))
473 if (NULL != strchr (tok, (unsigned char) 'C'))
475 tok += strlen (tok) + 1;
477 tok,
478 &raw_data,
479 &record.data_size))
480 {
482 _ ("Invalid record data for type %s: `%s'.\n"),
484 tok);
485 GNUNET_free (cp);
486 return GNUNET_SYSERR;
487 }
488 GNUNET_free (cp);
489
490 r = GNUNET_malloc (sizeof(struct RecordSetEntry) + record.data_size);
491 r->next = recordset;
492 record.data = &r[1];
493 memcpy (&r[1], raw_data, record.data_size);
494 GNUNET_free (raw_data);
495 r->record = record;
496 recordset = r;
497 return GNUNET_OK;
498}
499
500
501static void
503{
504 struct RecordSetEntry *rs_entry;
505
506 while (NULL != (rs_entry = recordset))
507 {
509 GNUNET_free (rs_entry);
510 }
511 recordset = NULL;
512}
513
514
515static void
517{
518 struct MarkedRecord *mrec;
519 struct MarkedRecord *mrec_tmp;
521 if (NULL != ego_name)
522 {
524 ego_name = NULL;
525 }
526 if (NULL != name)
527 {
529 name = NULL;
530 }
531 if (NULL != value)
532 {
534 value = NULL;
535 }
536 if (NULL != uri)
537 {
539 uri = NULL;
540 }
541 if (NULL != expirationstring)
542 {
544 expirationstring = NULL;
545 }
546 if (NULL != purge_task)
547 {
549 purge_task = NULL;
550 }
551 for (mrec = marked_head; NULL != mrec;)
552 {
553 mrec_tmp = mrec;
554 mrec = mrec->next;
555 GNUNET_free (mrec_tmp->name);
556 GNUNET_free (mrec_tmp);
557 }
558 if (NULL != list_it)
559 {
561 list_it = NULL;
562 }
563 if (NULL != add_qe)
564 {
566 add_qe = NULL;
567 }
568 if (NULL != set_qe)
569 {
571 set_qe = NULL;
572 }
573 if (NULL != add_qe_uri)
574 {
576 add_qe_uri = NULL;
577 }
578 if (NULL != get_qe)
579 {
581 get_qe = NULL;
582 }
583 if (NULL != del_qe)
584 {
586 del_qe = NULL;
587 }
588 if (NULL != reverse_qe)
589 {
591 reverse_qe = NULL;
592 }
593 memset (&zone_pkey, 0, sizeof(zone_pkey));
594 if (NULL != zm)
595 {
597 zm = NULL;
598 }
599 if (NULL != data)
600 {
602 data = NULL;
603 }
604 if (NULL != typestring)
605 {
607 typestring = NULL;
608 }
609 list = 0;
610 is_public = 0;
611 is_shadow = 0;
612 is_maintenance = 0;
613 purge_zone = 0;
614}
615
616
622static void
623do_shutdown (void *cls)
624{
625 struct EgoEntry *ego_entry;
626 struct EgoEntry *ego_tmp;
627 (void) cls;
628
629 reset_handles ();
630 if (NULL != record_info)
632 record_info = NULL;
633 if (NULL != ns_qe)
634 {
636 ns_qe = NULL;
637 }
638 if (NULL != ns)
639 {
641 ns = NULL;
642 }
643 if (NULL != idh)
644 {
646 idh = NULL;
647 }
648 for (ego_entry = ego_head; NULL != ego_entry;)
649 {
650 ego_tmp = ego_entry;
651 ego_entry = ego_entry->next;
652 GNUNET_free (ego_tmp->identifier);
653 GNUNET_free (ego_tmp);
654 }
655}
656
657
658static void
660
661static unsigned int ri_sent = 0;
662
669static void
671
672static void
674{
675 //if (ri_sent < ri_count)
676 //{
677 // batch_insert_recordinfo (cfg);
678 // return;
679 //}
680 //reset_handles ();
681 if (read_from_stdin)
682 {
684 return;
685 }
687}
688
689
690static void
692{
693 struct GNUNET_NAMESTORE_QueueEntry **qe = cls;
694
695 *qe = NULL;
696 if (GNUNET_EC_NONE != ec)
697 {
698 fprintf (stderr,
699 _ ("Adding record failed: %s\n"),
702 ret = 1;
704 return;
705 }
706 ret = 0;
708}
709
710
711static void
713{
714 (void) cls;
715 del_qe = NULL;
717 {
718 fprintf (stderr,
719 _ ("Deleting record failed: %s\n"), GNUNET_ErrorCode_get_hint (
720 ec));
721 }
723}
724
725
726static void
727purge_next_record (void *cls);
728
729static void
731{
732 del_qe = NULL;
733 if (GNUNET_EC_NONE != ec)
734 {
735 fprintf (stderr,
736 _ ("Deleting record failed: %s\n"),
738 }
740}
741
742
743static void
745{
746 struct MarkedRecord *mrec;
747 purge_task = NULL;
748
749 if (NULL == marked_head)
750 {
751 ret = 0;
753 return;
754 }
755 mrec = marked_head;
758 mrec);
760 &mrec->key,
761 mrec->name,
762 0, NULL,
764 NULL);
765 GNUNET_free (mrec->name);
766 GNUNET_free (mrec);
767}
768
769
773static void
775{
776 (void) cls;
777 list_it = NULL;
779 {
781 return;
782 }
783 ret = 0;
785}
786
787
791static void
793{
794 (void) cls;
795 list_it = NULL;
796 fprintf (stderr, "Error iterating over zone\n");
797 ret = 1;
799}
800
801
802static void
804 GNUNET_CRYPTO_PrivateKey *zone_key,
805 const char *rname,
806 unsigned int rd_len,
807 const struct GNUNET_GNSRECORD_Data *rd)
808{
809 struct MarkedRecord *mrec;
810
811 mrec = GNUNET_new (struct MarkedRecord);
812 mrec->key = *zone_key;
813 mrec->name = GNUNET_strdup (rname);
816 mrec);
817}
818
819
820static void
822 const char *rname,
823 unsigned int rd_len,
824 const struct GNUNET_GNSRECORD_Data *rd)
825{
826 struct EgoEntry *ego;
827 struct MarkedRecord *orphan;
828 int is_orphaned = 1;
829
830 for (ego = ego_head; NULL != ego; ego = ego->next)
831 {
832 if (0 == memcmp (GNUNET_IDENTITY_ego_get_private_key (ego->ego),
833 zone_key,
834 sizeof (*zone_key)))
835 {
836 is_orphaned = 0;
837 break;
838 }
839 }
840 if (is_orphaned)
841 {
842 orphan = GNUNET_new (struct MarkedRecord);
843 orphan->key = *zone_key;
844 orphan->name = GNUNET_strdup (rname);
847 orphan);
848 }
849}
850
851
859static void
861 const char *rname,
862 unsigned int rd_len,
863 const struct GNUNET_GNSRECORD_Data *rd)
864{
865 const char *typestr;
866 char *s;
867 const char *ets;
868 struct GNUNET_TIME_Absolute at;
869 struct GNUNET_TIME_Relative rt;
870 struct EgoEntry *ego;
871 int have_record;
872 int is_orphaned = 1;
873 char *orphaned_str;
874
875 if ((NULL != name) && (0 != strcmp (name, rname)))
876 return;
877 have_record = GNUNET_NO;
878 for (unsigned int i = 0; i < rd_len; i++)
879 {
880 if ((GNUNET_GNSRECORD_TYPE_NICK == rd[i].record_type) &&
881 (0 != strcmp (rname, GNUNET_GNS_EMPTY_LABEL_AT)))
882 continue;
883 if ((type != rd[i].record_type) && (GNUNET_GNSRECORD_TYPE_ANY != type))
884 continue;
885 have_record = GNUNET_YES;
886 break;
887 }
888 if (GNUNET_NO == have_record)
889 return;
890 for (ego = ego_head; NULL != ego; ego = ego->next)
891 {
892 if (0 == memcmp (GNUNET_IDENTITY_ego_get_private_key (ego->ego),
893 zone_key,
894 sizeof (*zone_key)))
895 {
896 is_orphaned = 0;
897 break;
898 }
899 }
900 if (list_orphaned && ! is_orphaned)
901 return;
902 if (! list_orphaned && is_orphaned)
903 return;
904 orphaned_str = GNUNET_CRYPTO_private_key_to_string (zone_key);
905 fprintf (stdout, "%s.%s:\n", rname, is_orphaned ? orphaned_str :
906 ego->identifier);
907 GNUNET_free (orphaned_str);
908 if (NULL != typestring)
910 else
912 for (unsigned int i = 0; i < rd_len; i++)
913 {
914 if ((GNUNET_GNSRECORD_TYPE_NICK == rd[i].record_type) &&
915 (0 != strcmp (rname, GNUNET_GNS_EMPTY_LABEL_AT)))
916 continue;
917 if ((type != rd[i].record_type) && (GNUNET_GNSRECORD_TYPE_ANY != type))
918 continue;
919 typestr = GNUNET_GNSRECORD_number_to_typename (rd[i].record_type);
920 s = GNUNET_GNSRECORD_value_to_string (rd[i].record_type,
921 rd[i].data,
922 rd[i].data_size);
923 if (NULL == s)
924 {
925 fprintf (stdout,
926 _ ("\tCorrupt or unsupported record of type %u\n"),
927 (unsigned int) rd[i].record_type);
928 continue;
929 }
930 if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
931 {
934 }
935 else
936 {
939 }
940 char flgstr[16];
941 sprintf (flgstr, "[%s%s%s%s%s]",
942 (rd[i].flags & GNUNET_GNSRECORD_RF_PRIVATE) ? "" : "p",
943 (rd[i].flags & GNUNET_GNSRECORD_RF_SUPPLEMENTAL) ? "S" : "",
944 (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION) ? "r" : "",
945 (rd[i].flags & GNUNET_GNSRECORD_RF_SHADOW) ? "S" : "",
946 (rd[i].flags & GNUNET_GNSRECORD_RF_CRITICAL) ? "C" : "");
948 fprintf (stdout,
949 " %s %" PRIu64 " %s %s\n",
950 typestr,
951 rd[i].expiration_time,
952 flgstr,
953 s);
954 else
955 fprintf (stdout,
956 "\t%s: %s (%s)\t%s\t%s\t%s\n",
957 typestr,
958 s,
959 ets,
960 (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_PRIVATE)) ? "PRIVATE"
961 : "PUBLIC",
962 (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_SHADOW)) ? "SHADOW"
963 : "",
964 (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_MAINTENANCE)) ?
965 "MAINTENANCE"
966 : "");
967 GNUNET_free (s);
968 }
969 // fprintf (stdout, "%s", "\n");
970}
971
972
973static void
975 const struct GNUNET_CRYPTO_PrivateKey *zone_key,
976 const char *rname,
977 unsigned int rd_len,
978 const struct GNUNET_GNSRECORD_Data *rd,
979 struct GNUNET_TIME_Absolute expiry)
980{
981 (void) cls;
982 (void) zone_key;
983 (void) expiry;
984 collect_zone_records_to_purge (zone_key, rname, rd_len, rd);
986}
987
988
989static void
991 const struct GNUNET_CRYPTO_PrivateKey *zone_key,
992 const char *rname,
993 unsigned int rd_len,
994 const struct GNUNET_GNSRECORD_Data *rd,
995 struct GNUNET_TIME_Absolute expiry)
996{
997 (void) cls;
998 (void) zone_key;
999 (void) expiry;
1000 collect_orphans (zone_key, rname, rd_len, rd);
1002}
1003
1004
1014static void
1016 const struct GNUNET_CRYPTO_PrivateKey *zone_key,
1017 const char *rname,
1018 unsigned int rd_len,
1019 const struct GNUNET_GNSRECORD_Data *rd,
1020 struct GNUNET_TIME_Absolute expiry)
1021{
1022 (void) cls;
1023 (void) zone_key;
1024 (void) expiry;
1025 display_record (zone_key, rname, rd_len, rd);
1027}
1028
1029
1039static void
1041 const struct GNUNET_CRYPTO_PrivateKey *zone_key,
1042 const char *rname,
1043 unsigned int rd_len,
1044 const struct GNUNET_GNSRECORD_Data *rd,
1045 struct GNUNET_TIME_Absolute expiry)
1046{
1047 (void) cls;
1048 (void) zone_key;
1049 (void) expiry;
1050 display_record (zone_key, rname, rd_len, rd);
1052}
1053
1054
1064static void
1066 const struct GNUNET_CRYPTO_PrivateKey *zone_key,
1067 const char *rname,
1068 unsigned int rd_len,
1069 const struct GNUNET_GNSRECORD_Data *rd)
1070{
1071 (void) cls;
1072 (void) zone_key;
1073 get_qe = NULL;
1074 display_record (zone_key, rname, rd_len, rd);
1075 finish_command ();
1076}
1077
1078
1084static void
1085sync_cb (void *cls)
1086{
1087 (void) cls;
1088 fprintf (stdout, "%s", "Monitor is now in sync.\n");
1089}
1090
1091
1097static void
1099{
1100 (void) cls;
1101 fprintf (stderr, "%s", "Monitor disconnected and out of sync.\n");
1102}
1103
1104
1110static void
1112{
1113 (void) cls;
1114 get_qe = NULL;
1115 fprintf (stderr, "%s", "Failed to lookup record.\n");
1116 finish_command ();
1117}
1118
1119
1123static void
1124add_error_cb (void *cls)
1125{
1126 (void) cls;
1127 add_qe = NULL;
1128 GNUNET_break (0);
1129 ret = 1;
1130 finish_command ();
1131}
1132
1133
1144static void
1146 const struct GNUNET_CRYPTO_PrivateKey *zone_key,
1147 const char *rec_name,
1148 unsigned int rd_count,
1149 const struct GNUNET_GNSRECORD_Data *rd)
1150{
1151 struct GNUNET_GNSRECORD_Data rdn[rd_count + 1];
1152 struct GNUNET_GNSRECORD_Data *rde;
1153
1154 (void) cls;
1155 (void) zone_key;
1156 add_qe = NULL;
1157 if (0 != strcmp (rec_name, name))
1158 {
1159 GNUNET_break (0);
1160 ret = 1;
1161 finish_command ();
1162 return;
1163 }
1164
1166 "Received %u records for name `%s'\n",
1167 rd_count,
1168 rec_name);
1169 for (unsigned int i = 0; i < rd_count; i++)
1170 {
1171 switch (rd[i].record_type)
1172 {
1175 {
1176 fprintf (
1177 stderr,
1178 _ (
1179 "A SOA record exists already under `%s', cannot add a second SOA to the same zone.\n"),
1180 rec_name);
1181 ret = 1;
1182 finish_command ();
1183 return;
1184 }
1185 break;
1186 }
1187 }
1188 memset (rdn, 0, sizeof(struct GNUNET_GNSRECORD_Data));
1189 GNUNET_memcpy (&rdn[1], rd, rd_count * sizeof(struct GNUNET_GNSRECORD_Data));
1190 rde = &rdn[0];
1191 rde->data = data;
1192 rde->data_size = data_size;
1193 rde->record_type = type;
1194 if (1 == is_shadow)
1196 if (1 == is_maintenance)
1198 if (1 != is_public)
1200 rde->expiration_time = etime;
1201 if (GNUNET_YES == etime_is_rel)
1203 else if (GNUNET_NO != etime_is_rel)
1205 GNUNET_assert (NULL != name);
1207 &zone_pkey,
1208 name,
1209 rd_count + 1,
1210 rde,
1212 &add_qe);
1213}
1214
1215
1219static void
1221{
1222 (void) cls;
1223 reverse_qe = NULL;
1224 fprintf (stdout, "%s.zkey\n", reverse_pkey);
1225}
1226
1227
1238static void
1240 const struct GNUNET_CRYPTO_PrivateKey *zone,
1241 const char *label,
1242 unsigned int rd_count,
1243 const struct GNUNET_GNSRECORD_Data *rd)
1244{
1245 (void) cls;
1246 (void) zone;
1247 (void) rd_count;
1248 (void) rd;
1249 reverse_qe = NULL;
1250 if (NULL == label)
1251 fprintf (stdout, "%s\n", reverse_pkey);
1252 else
1253 fprintf (stdout, "%s.%s\n", label, ego_name);
1254 finish_command ();
1255}
1256
1257
1261static void
1263{
1264 (void) cls;
1265 del_qe = NULL;
1266 GNUNET_break (0);
1267 ret = 1;
1268 finish_command ();
1269}
1270
1271
1283static void
1284del_monitor (void *cls,
1285 const struct GNUNET_CRYPTO_PrivateKey *zone,
1286 const char *label,
1287 unsigned int rd_count,
1288 const struct GNUNET_GNSRECORD_Data *rd)
1289{
1290 struct GNUNET_GNSRECORD_Data rdx[rd_count];
1291 unsigned int rd_left;
1292 uint32_t type;
1293 char *vs;
1294
1295 (void) cls;
1296 (void) zone;
1297 del_qe = NULL;
1298 if (0 == rd_count)
1299 {
1300 fprintf (stderr,
1301 _ (
1302 "There are no records under label `%s' that could be deleted.\n")
1303 ,
1304 label);
1305 ret = 1;
1306 finish_command ();
1307 return;
1308 }
1309 if ((NULL == value) && (NULL == typestring))
1310 {
1311 /* delete everything */
1313 &zone_pkey,
1314 name,
1315 0,
1316 NULL,
1318 NULL);
1319 return;
1320 }
1321 rd_left = 0;
1322 if (NULL != typestring)
1324 else
1326 for (unsigned int i = 0; i < rd_count; i++)
1327 {
1328 vs = NULL;
1329 if (! (((GNUNET_GNSRECORD_TYPE_ANY == type) ||
1330 (rd[i].record_type == type)) &&
1331 ((NULL == value) ||
1332 (NULL ==
1334 rd[i].data,
1335 rd[i].data_size)))) ||
1336 (0 == strcmp (vs, value)))))
1337 rdx[rd_left++] = rd[i];
1338 GNUNET_free (vs);
1339 }
1340 if (rd_count == rd_left)
1341 {
1342 /* nothing got deleted */
1343 fprintf (
1344 stderr,
1345 _ (
1346 "There are no records under label `%s' that match the request for deletion.\n"),
1347 label);
1348 finish_command ();
1349 return;
1350 }
1351 /* delete everything but what we copied to 'rdx' */
1353 &zone_pkey,
1354 name,
1355 rd_left,
1356 rdx,
1358 NULL);
1359}
1360
1361
1362static void
1364{
1366}
1367
1368static void
1369replace_cont (void *cls, enum GNUNET_ErrorCode ec)
1370{
1371 (void) cls;
1372
1373 set_qe = NULL;
1374 if (GNUNET_EC_NONE != ec)
1375 {
1377 _ ("%s\n"),
1379 ret = 1; /* fail from 'main' */
1380 }
1382}
1383
1384
1391static void
1393{
1394 unsigned int sent_here;
1395
1396 GNUNET_assert (0 != ri_count);
1398 &zone_pkey,
1399 ri_count - ri_sent,
1401 &sent_here,
1402 &replace_cont,
1403 NULL);
1404 ri_sent += sent_here;
1405 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sent %d/%d record infos\n", ri_sent, ri_count);
1406 if (ri_sent == ri_count)
1407 {
1408 for (int i = 0; i < ri_count; i++)
1409 {
1410 GNUNET_free (record_info[i].a_rd);
1411 record_info[i].a_rd = NULL;
1412 }
1413 ri_count = 0;
1414 ri_sent = 0;
1415 }
1416 return;
1417}
1418
1419
1426static void
1428{
1431
1432 if (omit_private)
1436 if (! (add | del | list | (NULL != nickstring) | (NULL != uri)
1437 | (NULL != reverse_pkey) | (NULL != recordset) | (monitor)
1439 {
1440 /* nothing more to be done */
1441 fprintf (stderr, _ ("No options given\n"));
1442 finish_command ();
1443 return;
1444 }
1445
1446 if (NULL != recordset)
1447 {
1448 /* replace entire record set */
1449 unsigned int rd_count;
1450 struct GNUNET_GNSRECORD_Data *rd;
1451
1452 /* FIXME: We could easily support append and delete with this as well */
1453 if (! add)
1454 {
1455 fprintf (stderr, _ ("Recordlines only work with option `%s'\n"),
1456 "-a");
1457 ret = 1;
1458 finish_command ();
1459 return;
1460 }
1461 if (NULL == name)
1462 {
1463 fprintf (stderr,
1464 _ ("Missing option `%s' for operation `%s'\n"),
1465 "-n",
1466 _ ("name"));
1467 ret = 1;
1468 finish_command ();
1469 return;
1470 }
1471 rd_count = 0;
1472 for (struct RecordSetEntry *e = recordset; NULL != e; e = e->next)
1473 rd_count++;
1475 rd_count = 0;
1476 for (struct RecordSetEntry *e = recordset; NULL != e; e = e->next)
1477 {
1478 rd[rd_count] = e->record;
1479 rd_count++;
1480 }
1482 &zone_pkey,
1483 name,
1484 rd_count,
1485 rd,
1486 &replace_cont,
1487 NULL);
1488 GNUNET_free (rd);
1489 return;
1490 }
1491 if (NULL != nickstring)
1492 {
1493 if (0 == strlen (nickstring))
1494 {
1495 fprintf (stderr, _ ("Invalid nick `%s'\n"), nickstring);
1496 ret = 1;
1497 finish_command ();
1498 return;
1499 }
1500 add = 1;
1505 is_public = 0;
1506 expirationstring = GNUNET_strdup ("never");
1508 nickstring = NULL;
1509 }
1510
1511 if (add)
1512 {
1513 if (NULL == ego_name)
1514 {
1515 fprintf (stderr,
1516 _ ("Missing option `%s' for operation `%s'\n"),
1517 "-z",
1518 _ ("add"));
1519 ret = 1;
1520 finish_command ();
1521 return;
1522 }
1523 if (NULL == name)
1524 {
1525 fprintf (stderr,
1526 _ ("Missing option `%s' for operation `%s'\n"),
1527 "-n",
1528 _ ("add"));
1529 ret = 1;
1530 finish_command ();
1531 return;
1532 }
1533 if (NULL == typestring)
1534 {
1535 fprintf (stderr,
1536 _ ("Missing option `%s' for operation `%s'\n"),
1537 "-t",
1538 _ ("add"));
1539 ret = 1;
1540 finish_command ();
1541 return;
1542 }
1544 if (UINT32_MAX == type)
1545 {
1546 fprintf (stderr, _ ("Unsupported type `%s'\n"), typestring);
1547 ret = 1;
1548 finish_command ();
1549 return;
1550 }
1555 {
1556 fprintf (stderr,
1557 _ (
1558 "For DNS record types `SRV', `TLSA', `SMIMEA' and `OPENPGPKEY'"));
1559 fprintf (stderr, ", please use a `BOX' record instead\n");
1560 ret = 1;
1561 finish_command ();
1562 return;
1563 }
1564 if (NULL == value)
1565 {
1566 fprintf (stderr,
1567 _ ("Missing option `%s' for operation `%s'\n"),
1568 "-V",
1569 _ ("add"));
1570 ret = 1;
1571 finish_command ();
1572 return;
1573 }
1574 if (GNUNET_OK !=
1576 {
1577 fprintf (stderr,
1578 _ ("Value `%s' invalid for record type `%s'\n"),
1579 value,
1580 typestring);
1581 ret = 1;
1582 finish_command ();
1583 return;
1584 }
1585 if (NULL == expirationstring)
1586 {
1587 fprintf (stderr,
1588 _ ("Missing option `%s' for operation `%s'\n"),
1589 "-e",
1590 _ ("add"));
1591 ret = 1;
1592 finish_command ();
1593 return;
1594 }
1596 {
1597 fprintf (stderr, _ ("Invalid time format `%s'\n"), expirationstring);
1598 ret = 1;
1599 finish_command ();
1600 return;
1601 }
1603 &zone_pkey,
1604 name,
1605 &add_error_cb,
1606 NULL,
1608 NULL);
1609 }
1610 if (del)
1611 {
1612 if (NULL == ego_name)
1613 {
1614 fprintf (stderr,
1615 _ ("Missing option `%s' for operation `%s'\n"),
1616 "-z",
1617 _ ("del"));
1618 ret = 1;
1619 finish_command ();
1620 return;
1621 }
1622 if (NULL == name)
1623 {
1624 fprintf (stderr,
1625 _ ("Missing option `%s' for operation `%s'\n"),
1626 "-n",
1627 _ ("del"));
1628 ret = 1;
1629 finish_command ();
1630 return;
1631 }
1633 &zone_pkey,
1634 name,
1636 NULL,
1637 &del_monitor,
1638 NULL,
1639 filter_flags);
1640 }
1641 if (purge_orphaned)
1642 {
1644 NULL,
1646 NULL,
1648 NULL,
1650 NULL,
1651 filter_flags);
1652
1653 }
1654 else if (purge_zone)
1655 {
1656 if (NULL == ego_name)
1657 {
1658 fprintf (stderr,
1659 _ ("Missing option `%s' for operation `%s'\n"),
1660 "-z",
1661 _ ("purge-zone"));
1662 ret = 1;
1663 finish_command ();
1664 return;
1665 }
1667 &zone_pkey,
1669 NULL,
1671 NULL,
1673 NULL,
1674 filter_flags);
1675
1676 }
1677 else if (list || list_orphaned)
1678 {
1679 if (NULL != name)
1680 {
1681 if (NULL == ego_name)
1682 {
1683 fprintf (stderr,
1684 _ ("Missing option `%s' for operation `%s'\n"),
1685 "-z",
1686 _ ("list"));
1687 ret = 1;
1688 finish_command ();
1689 return;
1690 }
1692 &zone_pkey,
1693 name,
1695 NULL,
1697 NULL);
1698 }
1699 else
1701 (NULL == ego_name) ?
1702 NULL : &zone_pkey,
1704 ,
1705 NULL,
1707 ,
1708 NULL,
1710 ,
1711 NULL,
1712 filter_flags);
1713 }
1714 if (NULL != reverse_pkey)
1715 {
1717
1718 if (NULL == ego_name)
1719 {
1720 fprintf (stderr,
1721 _ ("Missing option `%s' for operation `%s'\n"),
1722 "-z",
1723 _ ("reverse-pkey"));
1724 ret = 1;
1725 finish_command ();
1726 return;
1727 }
1728 if (GNUNET_OK !=
1730 &pubkey))
1731 {
1732 fprintf (stderr,
1733 _ ("Invalid public key for reverse lookup `%s'\n"),
1734 reverse_pkey);
1735 ret = 1;
1736 finish_command ();
1737 return;
1738 }
1740 &zone_pkey,
1741 &pubkey,
1743 NULL,
1745 NULL);
1746 }
1747 if (NULL != uri)
1748 {
1749 char sh[105];
1750 char sname[64];
1752 if (NULL == ego_name)
1753 {
1754 fprintf (stderr,
1755 _ ("Missing option `%s' for operation `%s'\n"),
1756 "-z",
1757 _ ("uri"));
1758 ret = 1;
1759 finish_command ();
1760 return;
1761 }
1762
1763 memset (sh, 0, 105);
1764 memset (sname, 0, 64);
1765
1766 if ((2 != (sscanf (uri, "gnunet://gns/%58s/%63s", sh, sname))) ||
1767 (GNUNET_OK !=
1769 {
1770 fprintf (stderr, _ ("Invalid URI `%s'\n"), uri);
1771 ret = 1;
1772 finish_command ();
1773 return;
1774 }
1775 if (NULL == expirationstring)
1776 {
1777 fprintf (stderr,
1778 _ ("Missing option `%s' for operation `%s'\n"),
1779 "-e",
1780 _ ("add"));
1781 ret = 1;
1782 finish_command ();
1783 return;
1784 }
1786 {
1787 fprintf (stderr, _ ("Invalid time format `%s'\n"), expirationstring);
1788 ret = 1;
1789 finish_command ();
1790 return;
1791 }
1792 memset (&rd, 0, sizeof(rd));
1793 rd.data = &pkey;
1795 rd.record_type = ntohl (pkey.type);
1797 if (GNUNET_YES == etime_is_rel)
1799 if (1 == is_shadow)
1801 if (1 == is_maintenance)
1804 &zone_pkey,
1805 sname,
1806 1,
1807 &rd,
1809 &add_qe_uri);
1810 }
1811 if (monitor)
1812 {
1814 (NULL != ego_name) ?
1815 &zone_pkey : NULL,
1816 GNUNET_YES,
1818 NULL,
1820 NULL,
1821 &sync_cb,
1822 NULL,
1823 filter_flags);
1824 }
1825}
1826
1827
1828#define MAX_LINE_LEN 4086
1829
1830#define MAX_ARGS 20
1831
1832static int
1834 struct GNUNET_CRYPTO_PrivateKey *zk)
1835{
1836 const struct GNUNET_CRYPTO_PrivateKey *privkey;
1838 struct GNUNET_CRYPTO_PublicKey ego_pubkey;
1839 struct EgoEntry *ego_entry;
1840
1842 &pubkey))
1843 {
1844 for (ego_entry = ego_head;
1845 NULL != ego_entry; ego_entry = ego_entry->next)
1846 {
1847 privkey = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
1848 GNUNET_IDENTITY_ego_get_public_key (ego_entry->ego, &ego_pubkey);
1849 if (0 == memcmp (&ego_pubkey, &pubkey, sizeof (pubkey)))
1850 {
1851 *zk = *privkey;
1852 return GNUNET_OK;
1853 }
1854 }
1855 }
1856 else
1857 {
1858 for (ego_entry = ego_head; NULL != ego_entry; ego_entry = ego_entry->next)
1859 {
1861 if (0 != strcmp (str, ego_entry->identifier))
1862 continue;
1863 *zk = *GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
1864 return GNUNET_OK;
1865 }
1866 }
1867 return GNUNET_NO;
1868}
1869
1870
1871static void
1873{
1874 char buf[MAX_LINE_LEN];
1875 static struct GNUNET_CRYPTO_PrivateKey next_zone_key;
1876 static char next_name[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
1877 static int finished = GNUNET_NO;
1878 static int have_next_recordline = GNUNET_NO;
1879 int zonekey_set = GNUNET_NO;
1880 char *tmp;
1881 char *current_name = NULL;
1882
1883
1884 if (GNUNET_YES == have_next_recordline)
1885 {
1886 zone_pkey = next_zone_key;
1887 if (NULL != current_name)
1888 GNUNET_free (current_name);
1889 current_name = GNUNET_strdup (next_name);
1890 zonekey_set = GNUNET_YES;
1891 }
1892 while (NULL != fgets (buf, sizeof (buf), stdin))
1893 {
1894 if (1 >= strlen (buf))
1895 continue;
1896 if (buf[strlen (buf) - 1] == '\n')
1897 buf[strlen (buf) - 1] = '\0';
1901 if (buf[strlen (buf) - 1] == ':')
1902 {
1903 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Switching to %s\n", buf);
1904 memset (next_name, 0, sizeof (next_name));
1905 strncpy (next_name, buf, strlen (buf) - 1);
1906 tmp = strchr (next_name, '.');
1907 if (NULL == tmp)
1908 {
1909 fprintf (stderr, "Error parsing name `%s'\n", next_name);
1911 ret = 1;
1912 return;
1913 }
1914 if (GNUNET_OK != get_identity_for_string (tmp + 1, &next_zone_key))
1915 {
1916 fprintf (stderr, "Error parsing zone name `%s'\n", tmp + 1);
1917 ret = 1;
1919 return;
1920 }
1921 *tmp = '\0';
1922 have_next_recordline = GNUNET_YES;
1923 /* Run a command for the previous record set */
1924 if (NULL != recordset)
1925 {
1927 {
1932 "Recordinfo array grown to %u bytes!\n", record_info_capacity);
1933 }
1934 record_info[ri_count].a_label = GNUNET_strdup (current_name);
1935 int rd_count = 0;
1936 for (struct RecordSetEntry *e = recordset; NULL != e; e = e->next)
1937 rd_count++;
1939 struct
1941 rd_count = 0;
1942 for (struct RecordSetEntry *e = recordset; NULL != e; e = e->next)
1943 {
1944 record_info[ri_count].a_rd[rd_count] = e->record;
1946 record.
1947 data_size);
1949 data_size;
1950 memcpy ((void*) record_info[ri_count].a_rd[rd_count].data,
1951 e->record.data, e->record.data_size);
1952 rd_count++;
1953 }
1955 ri_count++;
1956 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Added %d records to record info\n", rd_count);
1957 clear_recordset ();
1958 /* If the zone has changed, insert */
1959 /* If we have reached batch size, insert */
1960 if (0 != GNUNET_memcmp (&next_zone_key, &zone_pkey) ||
1962 {
1963 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Batch inserting %d RI\n", ri_count);
1965 return;
1966 }
1967 }
1968 zone_pkey = next_zone_key;
1969 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Switching from %s to %s\n", current_name, next_name);
1970 if (NULL != current_name)
1971 GNUNET_free (current_name);
1972 current_name = GNUNET_strdup (next_name);
1973 zonekey_set = GNUNET_YES;
1974 continue;
1975 }
1976 if (GNUNET_NO == zonekey_set)
1977 {
1978 fprintf (stderr, "Warning, encountered recordline without zone\n");
1979 continue;
1980 }
1981 parse_recordline (buf);
1982 }
1983 if (GNUNET_NO == finished)
1984 {
1985 if (NULL != recordset)
1986 {
1987 if (GNUNET_YES == zonekey_set)
1988 {
1989 record_info[ri_count].a_label = GNUNET_strdup (current_name);
1990 int rd_count = 0;
1991 for (struct RecordSetEntry *e = recordset; NULL != e; e = e->next)
1992 rd_count++;
1994 struct
1996 rd_count = 0;
1997 for (struct RecordSetEntry *e = recordset; NULL != e; e = e->next)
1998 {
1999 record_info[ri_count].a_rd[rd_count] = e->record;
2001 .
2002 data_size);
2003 record_info[ri_count].a_rd[rd_count].data_size = e->record.data_size
2004 ;
2005 memcpy ((void*) record_info[ri_count].a_rd[rd_count].data,
2006 e->record.data, e->record.data_size);
2007 rd_count++;
2008 }
2010 ri_count++;
2013 return;
2014 }
2015 fprintf (stderr, "Warning, encountered recordline without zone\n");
2016 }
2017 }
2018 if (ri_sent < ri_count)
2019 {
2021 return;
2022 }
2024 return;
2025}
2026
2027
2040static void
2041id_connect_cb (void *cls,
2042 struct GNUNET_IDENTITY_Ego *ego,
2043 void **ctx,
2044 const char *name)
2045{
2047 struct EgoEntry *ego_entry;
2048
2049 (void) ctx;
2050 (void) name;
2051 if ((NULL != name) && (NULL != ego))
2052 {
2053 ego_entry = GNUNET_new (struct EgoEntry);
2055 ego_entry->ego = ego;
2056 ego_entry->identifier = GNUNET_strdup (name);
2058 ego_tail,
2059 ego_entry);
2060 if ((NULL != ego_name) &&
2061 (0 == strcmp (name, ego_name)))
2063 return;
2064 }
2065 if (NULL != ego)
2066 return;
2067 if (read_from_stdin)
2068 {
2070 return;
2071 }
2073}
2074
2075
2084static void
2085run (void *cls,
2086 char *const *args,
2087 const char *cfgfile,
2088 const struct GNUNET_CONFIGURATION_Handle *_cfg)
2089{
2090 (void) cls;
2091 (void) args;
2092 (void) cfgfile;
2093 cfg = _cfg;
2094 if (NULL != args[0])
2095 GNUNET_log (
2097 _ ("Superfluous command line arguments (starting with `%s') ignored\n"),
2098 args[0]);
2099
2102 if (NULL == ns)
2103 {
2104 fprintf (stderr, _ ("Failed to connect to namestore\n"));
2106 return;
2107 }
2109 if (NULL == idh)
2110 {
2111 ret = -1;
2112 fprintf (stderr, _ ("Cannot connect to identity service\n"));
2114 }
2115}
2116
2117
2125int
2126main (int argc, char *const *argv)
2127{
2128 int lret;
2130 { GNUNET_GETOPT_option_flag ('a', "add", gettext_noop ("add record"), &add),
2132 "delete",
2133 gettext_noop ("delete record"),
2134 &del),
2136 "display",
2137 gettext_noop ("display records"),
2138 &list),
2140 "from-stdin",
2141 gettext_noop ("read commands from stdin"),
2144 'e',
2145 "expiration",
2146 "TIME",
2147 gettext_noop (
2148 "expiration time for record to use (for adding only), \"never\" is possible"),
2151 "nick",
2152 "NICKNAME",
2153 gettext_noop (
2154 "set the desired nick name for the zone"),
2155 &nickstring),
2157 "monitor",
2158 gettext_noop (
2159 "monitor changes in the namestore"),
2160 &monitor),
2162 "name",
2163 "NAME",
2164 gettext_noop (
2165 "name of the record to add/delete/display"),
2166 &name),
2168 "recordline",
2169 gettext_noop ("Output in recordline format"),
2172 "zone-to-name",
2173 "KEY",
2174 gettext_noop (
2175 "determine our name for the given KEY"),
2176 &reverse_pkey),
2178 "type",
2179 "TYPE",
2180 gettext_noop (
2181 "type of the record to add/delete/display"),
2182 &typestring),
2184 "uri",
2185 "URI",
2186 gettext_noop ("URI to import into our zone"),
2187 &uri),
2189 "value",
2190 "VALUE",
2191 gettext_noop (
2192 "value of the record to add/delete"),
2193 &value),
2195 "public",
2196 gettext_noop ("create or list public record"),
2197 &is_public),
2199 "omit-private",
2200 gettext_noop ("omit private records"),
2201 &omit_private),
2203 "include-maintenance",
2204 gettext_noop (
2205 "do not filter maintenance records"),
2208 "purge-orphans",
2209 gettext_noop (
2210 "purge namestore of all orphans"),
2213 "list-orphans",
2214 gettext_noop (
2215 "show private key for orphaned records for recovery using `gnunet-identity -C -P <key>'. Use in combination with --display"),
2216 &list_orphaned),
2218 "purge-zone-records",
2219 gettext_noop (
2220 "delete all records in specified zone"),
2221 &purge_zone),
2223 "batch-size",
2224 "NUMBER",
2225 gettext_noop (
2226 "delete all records in specified zone"),
2229 's',
2230 "shadow",
2231 gettext_noop (
2232 "create shadow record (only valid if all other records of the same type have expired)"),
2233 &is_shadow),
2235 'M',
2236 "maintenance",
2237 gettext_noop (
2238 "create maintenance record (e.g TOMBSTONEs)"),
2241 "zone",
2242 "EGO",
2243 gettext_noop (
2244 "name of the ego controlling the zone"),
2245 &ego_name),
2247
2248
2249 if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
2250 return 2;
2251
2252 is_public = -1;
2253 is_shadow = -1;
2254 is_maintenance = -1;
2255 GNUNET_log_setup ("gnunet-namestore", "WARNING", NULL);
2256 if (GNUNET_OK !=
2257 (lret = GNUNET_PROGRAM_run (argc,
2258 argv,
2259 "gnunet-namestore",
2260 _ ("GNUnet zone manipulation tool"),
2261 options,
2262 &run,
2263 NULL)))
2264 {
2265 GNUNET_free_nz ((void *) argv);
2266 // FIXME
2267 // GNUNET_CRYPTO_ecdsa_key_clear (&zone_pkey);
2268 return lret;
2269 }
2270 GNUNET_free_nz ((void *) argv);
2271 // FIXME
2272 // GNUNET_CRYPTO_ecdsa_key_clear (&zone_pkey);
2273 return ret;
2274}
2275
2276
2277/* end of gnunet-namestore.c */
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
#define gettext_noop(String)
Definition: gettext.h:74
static bool finished
Set to true once we are finished and should exit after sending our final message to the parent.
static void record(void *cls, size_t data_size, const void *data)
Process recorded audio data.
static char * line
Desired phone line (string to be converted to a hash).
static struct GNUNET_DATASTORE_QueueEntry * qe
Current operation.
static struct GNUNET_FS_Handle * ctx
static struct GNUNET_IDENTITY_Handle * sh
Handle to IDENTITY service.
struct GNUNET_CRYPTO_PrivateKey pk
Private key from command line option, or NULL.
static char * pkey
Public key of the zone to look in, in ASCII.
static struct GNUNET_CRYPTO_PublicKey pubkey
Public key of the zone to look in.
static unsigned int rd_count
Number of records for currently parsed set.
static struct GNUNET_GNSRECORD_Data rd[50]
The record data under a single label.
static struct EgoEntry * ego_tail
Ego list.
static struct GNUNET_NAMESTORE_QueueEntry * ns_qe
Queue entry for begin/commit.
#define MAX_LINE_LEN
static void display_record_monitor(void *cls, const struct GNUNET_CRYPTO_PrivateKey *zone_key, const char *rname, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd, struct GNUNET_TIME_Absolute expiry)
Process a record that was stored in the namestore.
static int output_recordline
Output in recordline format.
static int omit_private
Filter private records.
static void zone_iteration_finished(void *cls)
Function called when we are done with a zone iteration.
static void replace_cont(void *cls, enum GNUNET_ErrorCode ec)
static void sync_cb(void *cls)
Function called once we are in sync in monitor mode.
static struct GNUNET_NAMESTORE_QueueEntry * get_qe
Queue entry for the 'lookup' operation.
static void del_lookup_error_cb(void *cls)
Function called if lookup for deletion fails.
static void purge_zone_iterator(void *cls, const struct GNUNET_CRYPTO_PrivateKey *zone_key, const char *rname, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd, struct GNUNET_TIME_Absolute expiry)
static struct GNUNET_CRYPTO_PrivateKey zone_pkey
Private key for the our zone.
static struct GNUNET_NAMESTORE_ZoneMonitor * zm
Monitor handle.
static int parse_recordline(const char *line)
static void del_continuation(void *cls, enum GNUNET_ErrorCode ec)
static int list_orphaned
List records and zone keys of orphaned records.
#define WARN_RELATIVE_EXPIRATION_LIMIT
The upper bound for the zone iteration interval (per record).
static void purge_next_record(void *cls)
static int purge_orphaned
Purge orphaned records.
static struct GNUNET_NAMESTORE_QueueEntry * add_qe
Queue entry for the 'add' operation.
static char * nickstring
Desired nick name.
static void display_record_lookup(void *cls, const struct GNUNET_CRYPTO_PrivateKey *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 int monitor
Enables monitor mode.
static char * value
Value of the record to add/remove.
static int list
Desired action is to list records.
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration handle.
static struct GNUNET_NAMESTORE_QueueEntry * del_qe
Queue entry for the 'del' operation.
static void batch_insert_recordinfo(const struct GNUNET_CONFIGURATION_Handle *cfg)
We have obtained the zone's private key, so now process the main commands using it.
static int purge_zone
Purge zone contents.
static char * name
Name of the records to add/list/remove.
static int include_maintenance
Do not filter maintenance records.
static struct GNUNET_NAMESTORE_QueueEntry * set_qe
Queue entry for the 'set/replace' operation.
static int get_identity_for_string(const char *str, struct GNUNET_CRYPTO_PrivateKey *zk)
static void display_record(const struct GNUNET_CRYPTO_PrivateKey *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 collect_orphans(const struct GNUNET_CRYPTO_PrivateKey *zone_key, const char *rname, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd)
static int ret
Global return value.
static void handle_reverse_lookup(void *cls, const struct GNUNET_CRYPTO_PrivateKey *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 reset_handles(void)
static unsigned int max_batch_size
static void * data
Value in binary format.
static void lookup_error_cb(void *cls)
Function called on errors while monitoring.
static void clear_recordset()
static void do_shutdown(void *cls)
Task run on shutdown.
static struct GNUNET_IDENTITY_Handle * idh
Identity service handle.
static struct RecordSetEntry * recordset
Entry in record set for processing records in bulk.
static char * ego_name
Name of the ego controlling the zone.
static void reverse_error_cb(void *cls)
Function called if we encountered an error in zone-to-name.
static struct MarkedRecord * marked_head
Marked record list.
static struct EgoEntry * ego_head
Ego list.
static int is_shadow
Is record a shadow record (GNUNET_GNSRECORD_RF_SHADOW)
static void add_continuation(void *cls, enum GNUNET_ErrorCode ec)
static struct GNUNET_SCHEDULER_Task * purge_task
Purge task.
static void run(void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *_cfg)
Main function that will be run.
static unsigned int ri_sent
static void finish_command(void)
static int del
Desired action is to remove a record.
static int etime_is_rel
Is expiration time relative or absolute time?
static void add_error_cb(void *cls)
Function called if lookup fails.
static struct GNUNET_NAMESTORE_Handle * ns
Handle to the namestore.
static int parse_expiration(const char *expirationstring, int *etime_is_rel, uint64_t *etime)
Parse expiration time.
static void marked_deleted(void *cls, enum GNUNET_ErrorCode ec)
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...
static struct GNUNET_NAMESTORE_ZoneIterator * list_it
List iterator for the 'list' operation.
static int is_maintenance
Is record a maintenance record (GNUNET_GNSRECORD_RF_MAINTENANCE)
static struct MarkedRecord * marked_tail
Marked record list.
static void display_record_iterator(void *cls, const struct GNUNET_CRYPTO_PrivateKey *zone_key, const char *rname, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd, struct GNUNET_TIME_Absolute expiry)
Process a record that was stored in the namestore.
static void purge_orphans_iterator(void *cls, const struct GNUNET_CRYPTO_PrivateKey *zone_key, const char *rname, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd, struct GNUNET_TIME_Absolute expiry)
static void monitor_error_cb(void *cls)
Function called on errors while monitoring.
static int read_from_stdin
Run in read from stdin mode.
static void run_with_zone_pkey(const struct GNUNET_CONFIGURATION_Handle *cfg)
We have obtained the zone's private key, so now process the main commands using it.
int main(int argc, char *const *argv)
The main function for gnunet-namestore.
static uint32_t type
Type string converted to DNS type value.
static size_t data_size
Number of bytes in data.
static char * expirationstring
Desired expiration time.
static unsigned int record_info_capacity
Maximum capacity of record_info array.
static void collect_zone_records_to_purge(const struct GNUNET_CRYPTO_PrivateKey *zone_key, const char *rname, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd)
static struct GNUNET_NAMESTORE_RecordInfo * record_info
static struct GNUNET_NAMESTORE_QueueEntry * add_qe_uri
Queue entry for the 'add-uri' operation.
static void del_monitor(void *cls, const struct GNUNET_CRYPTO_PrivateKey *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.
static void schedule_finish(void *cls)
static void process_command_stdin()
static int add
Desired action is to add a record.
static struct GNUNET_NAMESTORE_QueueEntry * reverse_qe
Queue entry for the 'reverse lookup' operation (in combination with a name).
static void zone_iteration_error_cb(void *cls)
Function called when we encountered an error in a zone iteration.
static void get_existing_record(void *cls, const struct GNUNET_CRYPTO_PrivateKey *zone_key, const char *rec_name, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
We're storing a record; this function is given the existing record so that we can merge the informati...
static char * typestring
Type of the record to add/remove, NULL to remove all.
static char * uri
URI to import.
static uint64_t etime
Expiration string converted to numeric value.
static char * reverse_pkey
Reverse lookup to perform.
static unsigned int ri_count
static int is_public
Is record public (opposite of GNUNET_GNSRECORD_RF_PRIVATE)
commonly used definitions; globals in this file are exempt from the rule that the module name ("commo...
API to the GNS service.
API that can be used to manipulate GNS record data.
Identity service; implements identity management for GNUnet.
API that can be used to store naming information on a GNUnet node;.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
#define GNUNET_DNSPARSER_TYPE_OPENPGPKEY
#define GNUNET_DNSPARSER_TYPE_TLSA
#define GNUNET_DNSPARSER_TYPE_SRV
#define GNUNET_DNSPARSER_TYPE_SOA
#define GNUNET_DNSPARSER_TYPE_SMIMEA
#define GNUNET_DNSPARSER_MAX_NAME_LENGTH
Maximum length of a name in DNS.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_uint(char shortName, const char *name, const char *argumentHelp, const char *description, unsigned int *val)
Allow user to specify an unsigned int.
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_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.
const char * GNUNET_GNSRECORD_number_to_typename(uint32_t type)
Convert a type number to the corresponding type string (e.g.
Definition: gnsrecord.c:227
uint32_t GNUNET_GNSRECORD_typename_to_number(const char *dns_typename)
Convert a type name (e.g.
Definition: gnsrecord.c:200
int GNUNET_GNSRECORD_string_to_value(uint32_t type, const char *s, void **data, size_t *data_size)
Convert human-readable version of the value s of a record of type type to the respective binary repre...
Definition: gnsrecord.c:177
#define GNUNET_GNS_EMPTY_LABEL_AT
String we use to indicate an empty label (top-level entry in the zone).
GNUNET_GNSRECORD_Filter
Filter for GNUNET_GNSRECORD_normalize_record_set().
#define GNUNET_GNSRECORD_TYPE_ANY
Record type indicating any record/'*'.
char * GNUNET_GNSRECORD_value_to_string(uint32_t type, const void *data, size_t data_size)
Convert the binary value data of a record of type type to a human-readable string.
Definition: gnsrecord.c:155
@ GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION
This expiration time of the record is a relative time (not an absolute time).
@ GNUNET_GNSRECORD_RF_CRITICAL
This record is critical.
@ GNUNET_GNSRECORD_RF_SUPPLEMENTAL
This is a supplemental record.
@ GNUNET_GNSRECORD_RF_MAINTENANCE
Maintenance records.
@ GNUNET_GNSRECORD_RF_SHADOW
This record should not be used unless all (other) records in the set with an absolute expiration time...
@ GNUNET_GNSRECORD_RF_PRIVATE
This is a private record of this peer and it should thus not be published.
@ GNUNET_GNSRECORD_RF_NONE
Entry for no flags / cleared flags.
@ GNUNET_GNSRECORD_FILTER_NONE
No filter flags set.
@ GNUNET_GNSRECORD_FILTER_INCLUDE_MAINTENANCE
Include maintenance records (TOMBSTONE etc).
@ GNUNET_GNSRECORD_FILTER_OMIT_PRIVATE
Filter private records.
const struct GNUNET_CRYPTO_PrivateKey * GNUNET_IDENTITY_ego_get_private_key(const struct GNUNET_IDENTITY_Ego *ego)
Obtain the ECC key associated with a ego.
Definition: identity_api.c:517
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:487
void GNUNET_IDENTITY_disconnect(struct GNUNET_IDENTITY_Handle *h)
Disconnect from identity service.
Definition: identity_api.c:732
void GNUNET_IDENTITY_ego_get_public_key(struct GNUNET_IDENTITY_Ego *ego, struct GNUNET_CRYPTO_PublicKey *pk)
Get the identifier (public key) of an ego.
Definition: identity_api.c:529
ssize_t GNUNET_CRYPTO_public_key_get_length(const struct GNUNET_CRYPTO_PublicKey *key)
Get the compacted length of a GNUNET_CRYPTO_PublicKey.
Definition: crypto_pkey.c:85
#define GNUNET_log(kind,...)
char * GNUNET_CRYPTO_private_key_to_string(const struct GNUNET_CRYPTO_PrivateKey *key)
Creates a (Base32) string representation of the private key.
Definition: crypto_pkey.c:578
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_public_key_from_string(const char *str, struct GNUNET_CRYPTO_PublicKey *key)
Parses a (Base32) string representation of the public key.
Definition: crypto_pkey.c:588
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
@ GNUNET_SYSERR
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
enum GNUNET_GenericReturnValue GNUNET_log_setup(const char *comp, const char *loglevel, const char *logfile)
Setup logging.
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_MESSAGE
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_array_grow(arr, size, tsize)
Grow a well-typed (!) array.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
#define GNUNET_free_nz(ptr)
Wrapper around free.
struct GNUNET_NAMESTORE_ZoneIterator * GNUNET_NAMESTORE_zone_iteration_start2(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_CRYPTO_PrivateKey *zone, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_NAMESTORE_RecordSetMonitor proc, void *proc_cls, GNUNET_SCHEDULER_TaskCallback finish_cb, void *finish_cb_cls, enum GNUNET_GNSRECORD_Filter filter)
Starts a new zone iteration (used to periodically PUT all of our records into our DHT).
struct GNUNET_NAMESTORE_QueueEntry * GNUNET_NAMESTORE_records_lookup(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_CRYPTO_PrivateKey *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.
struct GNUNET_NAMESTORE_QueueEntry * GNUNET_NAMESTORE_record_set_store(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_CRYPTO_PrivateKey *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.
void GNUNET_NAMESTORE_disconnect(struct GNUNET_NAMESTORE_Handle *h)
Disconnect from the namestore service (and free associated resources).
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.
void GNUNET_NAMESTORE_cancel(struct GNUNET_NAMESTORE_QueueEntry *qe)
Cancel a namestore operation.
struct GNUNET_NAMESTORE_QueueEntry * GNUNET_NAMESTORE_records_lookup2(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_CRYPTO_PrivateKey *pkey, const char *label, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_NAMESTORE_RecordMonitor rm, void *rm_cls, enum GNUNET_GNSRECORD_Filter filter)
Lookup an item in the namestore with GNSRECORD filter.
void GNUNET_NAMESTORE_zone_monitor_stop(struct GNUNET_NAMESTORE_ZoneMonitor *zm)
Stop monitoring a zone for changes.
struct GNUNET_NAMESTORE_QueueEntry * GNUNET_NAMESTORE_zone_to_name(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_CRYPTO_PrivateKey *zone, const struct GNUNET_CRYPTO_PublicKey *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.
struct GNUNET_NAMESTORE_ZoneMonitor * GNUNET_NAMESTORE_zone_monitor_start2(const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_CRYPTO_PrivateKey *zone, int iterate_first, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_NAMESTORE_RecordSetMonitor monitor, void *monitor_cls, GNUNET_SCHEDULER_TaskCallback sync_cb, void *sync_cb_cls, enum GNUNET_GNSRECORD_Filter filter)
Begin monitoring a zone for changes.
struct GNUNET_NAMESTORE_QueueEntry * GNUNET_NAMESTORE_records_store(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_CRYPTO_PrivateKey *pkey, unsigned int rd_set_count, const struct GNUNET_NAMESTORE_RecordInfo *record_info, unsigned int *rds_sent, GNUNET_NAMESTORE_ContinuationWithStatus cont, void *cont_cls)
Store one or more record sets in the namestore.
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).
struct GNUNET_NAMESTORE_Handle * GNUNET_NAMESTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the namestore service.
void GNUNET_NAMESTORE_zone_iteration_stop(struct GNUNET_NAMESTORE_ZoneIterator *it)
Stops iteration and releases the namestore handle for further calls.
enum GNUNET_GenericReturnValue 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,...
Definition: program.c:400
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:567
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,...
Definition: scheduler.c:1340
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:981
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:1305
enum GNUNET_GenericReturnValue 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:260
enum GNUNET_GenericReturnValue GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1230
#define GNUNET_TIME_relative_cmp(t1, op, t2)
Compare two relative times.
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:570
const char * GNUNET_STRINGS_absolute_time_to_string(struct GNUNET_TIME_Absolute t)
Like asctime, except for GNUnet time.
Definition: strings.c:617
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
enum GNUNET_GenericReturnValue 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:302
#define _(String)
GNU gettext support macro.
Definition: platform.h:178
#define GNUNET_GNSRECORD_TYPE_NICK
GNS zone nickname.
const char * GNUNET_ErrorCode_get_hint(enum GNUNET_ErrorCode ec)
Returns a hint for a given error code.
GNUNET_ErrorCode
Taler error codes.
@ GNUNET_EC_NONE
No error (success).
@ GNUNET_EC_NAMESTORE_RECORD_EXISTS
Record already exists.
@ GNUNET_EC_NAMESTORE_RECORD_NOT_FOUND
Record not found.
The default namestore ego.
char * identifier
Ego Identifier.
struct EgoEntry * prev
DLL.
struct EgoEntry * next
DLL.
struct GNUNET_IDENTITY_Ego * ego
The Ego.
A private key for an identity as per LSD0001.
An identity key as per LSD0001.
Definition of a command line option.
uint32_t record_type
Type of the GNS/DNS record.
const void * data
Binary value stored in the DNS record.
size_t data_size
Number of bytes in data.
enum GNUNET_GNSRECORD_Flags flags
Flags for the record.
uint64_t expiration_time
Expiration time for the DNS record.
Handle for an ego.
Definition: identity.h:37
Handle for the service.
Definition: identity_api.c:97
Connection to the NAMESTORE service.
An QueueEntry used to store information for a pending NAMESTORE record operation.
Definition: namestore_api.c:49
A struct for record bulk import.
struct GNUNET_GNSRECORD_Data * a_rd
Handle for a zone iterator operation.
Handle for a monitoring activity.
Entry in list of pending tasks.
Definition: scheduler.c:136
Time for absolute times used by GNUnet, in microseconds.
uint64_t abs_value_us
The actual value.
Time for relative time used by GNUnet, in microseconds.
uint64_t rel_value_us
The actual value.
The record marked for deletion.
struct MarkedRecord * next
DLL.
struct GNUNET_CRYPTO_PrivateKey key
The zone key.
char * name
Ego Identifier.
struct MarkedRecord * prev
DLL.
Entry in record set for bulk processing.
struct GNUNET_GNSRECORD_Data record
The record to add/remove.
struct RecordSetEntry * next
Kept in a linked list.