GNUnet 0.22.0
dht_api.c
Go to the documentation of this file.
1/*
2 This file is part of GNUnet.
3 Copyright (C) 2009-2012, 2016, 2018, 2022 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 */
20
28#include "platform.h"
29#include "gnunet_constants.h"
30#include "gnunet_signatures.h"
31#include "gnunet_arm_service.h"
32#include "gnunet_protocols.h"
33#include "gnunet_dht_service.h"
34#include "dht.h"
35
36#define LOG(kind, ...) GNUNET_log_from (kind, "dht-api", __VA_ARGS__)
37
38
43{
48
53
58
63
67 void *cont_cls;
68
73};
74
79{
84
88 void *iter_cls;
89
94
100
105
109 uint64_t unique_id;
110
115
120
125
130
135 unsigned int seen_results_size;
136
141 unsigned int seen_results_end;
142};
143
144
149{
154
159
164
169
174
179
184
189
193 void *cb_cls;
194};
195
196
201{
202
207
212
217
221 void *cb_cls;
222
227
228};
229
230
235{
240
245
250
255
260
265
270
275
281
286
292
296 uint64_t uid_gen;
297};
298
299
308
309
315static void
317{
318 struct GNUNET_DHT_Handle *h = gh->dht_handle;
319 struct GNUNET_MQ_Envelope *env;
320 struct GNUNET_DHT_ClientGetMessage *get_msg;
321
322 env = GNUNET_MQ_msg_extra (get_msg,
323 gh->xquery_size,
325 get_msg->options = htonl ((uint32_t) gh->options);
327 get_msg->type = htonl (gh->type);
328 get_msg->key = gh->key;
329 get_msg->unique_id = gh->unique_id;
330 GNUNET_memcpy (&get_msg[1],
331 &gh[1],
332 gh->xquery_size);
334 env);
335}
336
337
347static void
349 unsigned int transmission_offset_start)
350{
351 struct GNUNET_DHT_Handle *h = gh->dht_handle;
352 struct GNUNET_MQ_Envelope *env;
354 unsigned int delta;
355 unsigned int max;
356 unsigned int transmission_offset;
357
358 max = (GNUNET_MAX_MESSAGE_SIZE - sizeof(*msg))
359 / sizeof(struct GNUNET_HashCode);
360 transmission_offset = transmission_offset_start;
361 while (transmission_offset < gh->seen_results_end)
362 {
363 delta = gh->seen_results_end - transmission_offset;
364 if (delta > max)
365 delta = max;
367 delta * sizeof(struct GNUNET_HashCode),
369 msg->key = gh->key;
370 msg->unique_id = gh->unique_id;
371 GNUNET_memcpy (&msg[1],
372 &gh->seen_results[transmission_offset],
373 sizeof(struct GNUNET_HashCode) * delta);
375 env);
376 transmission_offset += delta;
377 }
378}
379
380
392 const struct GNUNET_HashCode *key,
393 void *value)
394{
395 struct GNUNET_DHT_Handle *handle = cls;
396 struct GNUNET_DHT_GetHandle *gh = value;
397
399 "Retransmitting request related to %s to DHT %p\n",
400 GNUNET_h2s (key),
401 handle);
402 send_get (gh);
404 return GNUNET_YES;
405}
406
407
413static void
415{
416 struct GNUNET_DHT_Handle *h = mh->dht_handle;
417 struct GNUNET_MQ_Envelope *env;
419
422 m->type = htonl (mh->type);
423 m->get = htons (NULL != mh->get_cb);
424 m->get_resp = htons (NULL != mh->get_resp_cb);
425 m->put = htons (NULL != mh->put_cb);
426 if (NULL != mh->key)
427 {
428 m->filter_key = htons (1);
429 m->key = *mh->key;
430 }
432 env);
433}
434
435
441static void
442try_reconnect (void *cls)
443{
444 struct GNUNET_DHT_Handle *h = cls;
446
448 "Reconnecting with DHT %p\n",
449 h);
450 h->retry_time = GNUNET_TIME_STD_BACKOFF (h->retry_time);
451 h->reconnect_task = NULL;
452 if (GNUNET_YES != try_connect (h))
453 {
455 "DHT reconnect failed!\n");
457 = GNUNET_SCHEDULER_add_delayed (h->retry_time,
459 h);
460 return;
461 }
464 h);
465 for (mh = h->monitor_head; NULL != mh; mh = mh->next)
467}
468
469
475static void
477{
478 struct GNUNET_DHT_PutHandle *ph;
480 void *cont_cls;
481
482 if (NULL == h->mq)
483 return;
485 h->mq = NULL;
487 "Disconnecting from DHT service, will try to reconnect in %s\n",
489 GNUNET_YES));
490 /* notify client about all PUTs that (may) have failed due to disconnect */
491 while (NULL != (ph = h->put_head))
492 {
493 cont = ph->cont;
494 cont_cls = ph->cont_cls;
495 ph->env = NULL;
497 if (NULL != cont)
498 cont (cont_cls);
499 }
500 GNUNET_assert (NULL == h->reconnect_task);
502 = GNUNET_SCHEDULER_add_delayed (h->retry_time,
504 h);
505}
506
507
516static void
518 enum GNUNET_MQ_Error error)
519{
520 struct GNUNET_DHT_Handle *h = cls;
521
523}
524
525
532static void
534 const struct GNUNET_DHT_MonitorGetMessage *msg)
535{
536 struct GNUNET_DHT_Handle *handle = cls;
537 enum GNUNET_DHT_RouteOption ro = ntohl (msg->options);
538
539 for (struct GNUNET_DHT_MonitorHandle *mh = handle->monitor_head;
540 NULL != mh;
541 mh = mh->next)
542 {
543 if (NULL == mh->get_cb)
544 continue;
545 if ( (GNUNET_BLOCK_TYPE_ANY != mh->type) &&
546 (mh->type != ntohl (msg->type)))
547 continue;
548 if ( (NULL != mh->key) &&
549 (0 != GNUNET_memcmp (mh->key,
550 &msg->key)) )
551 continue;
552 mh->get_cb (mh->cb_cls,
553 ro,
554 ntohl (msg->type),
555 ntohl (msg->hop_count),
556 ntohl (msg->desired_replication_level),
557 &msg->key);
558 }
559}
560
561
573{
574 size_t msize = ntohs (msg->header.size) - sizeof(*msg);
575 uint32_t getl = ntohl (msg->get_path_length);
576 uint32_t putl = ntohl (msg->put_path_length);
577 enum GNUNET_DHT_RouteOption ro = ntohl (msg->options);
578 bool truncated = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
579
580 if (truncated)
581 {
582 if (msize < sizeof (struct GNUNET_PeerIdentity))
583 {
584 GNUNET_break (0);
585 return GNUNET_SYSERR;
586 }
587 msize -= sizeof (struct GNUNET_PeerIdentity);
588 }
589 if ((getl + putl < getl) ||
590 ((msize / sizeof(struct GNUNET_DHT_PathElement)) < getl + putl))
591 {
592 GNUNET_break (0);
593 return GNUNET_SYSERR;
594 }
595 return GNUNET_OK;
596}
597
598
605static void
608{
609 struct GNUNET_DHT_Handle *handle = cls;
610 size_t msize = ntohs (msg->header.size) - sizeof(*msg);
611 enum GNUNET_DHT_RouteOption ro = ntohl (msg->options);
612 uint32_t getl = ntohl (msg->get_path_length);
613 uint32_t putl = ntohl (msg->put_path_length);
614 bool truncated = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
615 const struct GNUNET_PeerIdentity *trunc_peer
616 = truncated
617 ? (const struct GNUNET_PeerIdentity *) &msg[1]
618 : NULL;
619 const struct GNUNET_DHT_PathElement *path
620 = truncated
621 ? (const struct GNUNET_DHT_PathElement *) &trunc_peer[1]
622 : (const struct GNUNET_DHT_PathElement *) &msg[1];
623
624 if (truncated)
625 msize -= sizeof (struct GNUNET_PeerIdentity);
626 msize -= sizeof(struct GNUNET_DHT_PathElement) * (putl + getl);
627 for (struct GNUNET_DHT_MonitorHandle *mh = handle->monitor_head;
628 NULL != mh;
629 mh = mh->next)
630 {
631 if (NULL == mh->get_resp_cb)
632 continue;
633 if ( (GNUNET_BLOCK_TYPE_ANY != mh->type) &&
634 (mh->type != ntohl (msg->type)) )
635 continue;
636 if ( (NULL != mh->key) &&
637 (0 != GNUNET_memcmp (mh->key,
638 &msg->key)) )
639 continue;
640 mh->get_resp_cb (mh->cb_cls,
641 ntohl (msg->type),
642 trunc_peer,
643 &path[putl],
644 getl,
645 path,
646 putl,
647 GNUNET_TIME_absolute_ntoh (msg->expiration_time),
648 &msg->key,
649 (const void *) &path[getl + putl],
650 msize);
651 }
652}
653
654
665 const struct GNUNET_DHT_MonitorPutMessage *msg)
666{
667 size_t msize = ntohs (msg->header.size) - sizeof(*msg);
668 uint32_t putl = ntohl (msg->put_path_length);
669 enum GNUNET_DHT_RouteOption ro = ntohl (msg->options);
670 bool truncated = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
671
672 if (truncated)
673 {
674 if (msize < sizeof (struct GNUNET_PeerIdentity))
675 {
676 GNUNET_break (0);
677 return GNUNET_SYSERR;
678 }
679 msize -= sizeof (struct GNUNET_PeerIdentity);
680 }
681 if ((msize / sizeof(struct GNUNET_DHT_PathElement)) < putl)
682 {
683 GNUNET_break (0);
684 return GNUNET_SYSERR;
685 }
686 return GNUNET_OK;
687}
688
689
696static void
698 const struct GNUNET_DHT_MonitorPutMessage *msg)
699{
700 struct GNUNET_DHT_Handle *handle = cls;
701 size_t msize = ntohs (msg->header.size) - sizeof(*msg);
702 uint32_t putl = ntohl (msg->put_path_length);
703 enum GNUNET_DHT_RouteOption ro = ntohl (msg->options);
704 bool truncated = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
705 const struct GNUNET_PeerIdentity *trunc_peer
706 = truncated
707 ? (const struct GNUNET_PeerIdentity *) &msg[1]
708 : NULL;
709 const struct GNUNET_DHT_PathElement *path
710 = truncated
711 ? (const struct GNUNET_DHT_PathElement *) &trunc_peer[1]
712 : (const struct GNUNET_DHT_PathElement *) &msg[1];
713
714 if (truncated)
715 msize -= sizeof (struct GNUNET_PeerIdentity);
716 msize -= sizeof(struct GNUNET_DHT_PathElement) * putl;
717 for (struct GNUNET_DHT_MonitorHandle *mh = handle->monitor_head;
718 NULL != mh;
719 mh = mh->next)
720 {
721 if (NULL == mh->put_cb)
722 continue;
723 if ( (GNUNET_BLOCK_TYPE_ANY != mh->type) &&
724 (mh->type != ntohl (msg->type)) )
725 continue;
726 if ( (NULL != mh->key) &&
727 (0 != GNUNET_memcmp (mh->key,
728 &msg->key)) )
729 continue;
730 mh->put_cb (mh->cb_cls,
731 ro,
732 ntohl (msg->type),
733 ntohl (msg->hop_count),
734 ntohl (msg->desired_replication_level),
735 trunc_peer,
736 putl,
737 path,
738 GNUNET_TIME_absolute_ntoh (msg->expiration_time),
739 &msg->key,
740 (const void *) &path[putl],
741 msize);
742 }
743}
744
745
757{
758 size_t msize = ntohs (msg->header.size) - sizeof(*msg);
759 uint32_t put_path_length = ntohl (msg->put_path_length);
760 uint32_t get_path_length = ntohl (msg->get_path_length);
761 enum GNUNET_DHT_RouteOption ro = ntohl (msg->options);
762 bool truncated = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
763 size_t meta_length;
764
765 if (truncated)
766 {
767 if (msize < sizeof (struct GNUNET_PeerIdentity))
768 {
769 GNUNET_break (0);
770 return GNUNET_SYSERR;
771 }
772 msize -= sizeof (struct GNUNET_PeerIdentity);
773 }
774 meta_length = msize / sizeof(struct GNUNET_DHT_PathElement);
775 if ( (get_path_length + put_path_length >
776 meta_length) ||
777 (get_path_length + put_path_length <
778 get_path_length) )
779 {
780 GNUNET_break (0);
781 return GNUNET_SYSERR;
782 }
783 return GNUNET_OK;
784}
785
786
797 const struct GNUNET_HashCode *key,
798 void *value)
799{
800 const struct GNUNET_DHT_ClientResultMessage *crm = cls;
802 size_t msize = ntohs (crm->header.size) - sizeof(*crm);
803 uint16_t type = ntohl (crm->type);
804 enum GNUNET_DHT_RouteOption ro = ntohl (crm->options);
805 bool truncated
806 = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
807 uint32_t put_path_length
808 = ntohl (crm->put_path_length);
809 uint32_t get_path_length
810 = ntohl (crm->get_path_length);
811 const struct GNUNET_PeerIdentity *trunc_peer
812 = truncated
813 ? (const struct GNUNET_PeerIdentity *) &crm[1]
814 : NULL;
815 const struct GNUNET_DHT_PathElement *put_path
816 = truncated
817 ? (const struct GNUNET_DHT_PathElement *) &trunc_peer[1]
818 : (const struct GNUNET_DHT_PathElement *) &crm[1];
819 const struct GNUNET_DHT_PathElement *get_path
820 = &put_path[put_path_length];
821 const void *data
822 = &get_path[get_path_length];
823 size_t meta_length
824 = sizeof(struct GNUNET_DHT_PathElement)
825 * (get_path_length + put_path_length);
826 size_t data_length
827 = msize - meta_length;
828 struct GNUNET_HashCode hc;
829
830 if (truncated)
831 data_length -= sizeof (struct GNUNET_PeerIdentity);
832 if (crm->unique_id != get_handle->unique_id)
833 {
834 /* UID mismatch */
836 "Ignoring reply for %s: UID mismatch: %llu/%llu\n",
837 GNUNET_h2s (key),
838 (unsigned long long) crm->unique_id,
839 (unsigned long long) get_handle->unique_id);
840 return GNUNET_YES;
841 }
843 (get_handle->type != type) )
844 {
845 /* type mismatch */
846 GNUNET_break (0);
847 return GNUNET_YES;
848 }
849
850 {
851 char *pp;
852 char *gp;
853
854 gp = GNUNET_DHT_pp2s (get_path,
855 get_path_length);
856 pp = GNUNET_DHT_pp2s (put_path,
857 put_path_length);
859 "Giving %u byte reply for %s to application (GP: %s, PP: %s)\n",
860 (unsigned int) data_length,
861 GNUNET_h2s (key),
862 gp,
863 pp);
864 GNUNET_free (gp);
865 GNUNET_free (pp);
866 }
867 /* remember that we've seen this result */
869 data_length,
870 &hc);
876 /* no need to block it explicitly, service already knows about it! */
879 key,
880 trunc_peer,
881 get_path,
882 get_path_length,
883 put_path,
884 put_path_length,
885 type,
886 data_length,
887 data);
888 return GNUNET_YES;
889}
890
891
898static void
901{
902 struct GNUNET_DHT_Handle *handle = cls;
903
905 &msg->key,
907 (void *) msg);
908}
909
910
920 const struct GNUNET_MessageHeader *hdr)
921{
922 uint16_t len = ntohs (hdr->size);
923 const char *buf = (const char *) &hdr[1];
924
925 (void) cls;
926 if ('\0' != buf[len - sizeof (*hdr) - 1])
927 {
928 GNUNET_break (0);
929 return GNUNET_SYSERR;
930 }
931 return GNUNET_OK;
932}
933
934
941static void
943 const struct GNUNET_MessageHeader *hdr)
944{
945 struct GNUNET_DHT_Handle *handle = cls;
946 const char *url = (const char *) &hdr[1];
947 struct GNUNET_DHT_HelloGetHandle *hgh;
948
949 while (NULL != (hgh = handle->hgh_head))
950 {
951 hgh->cb (hgh->cb_cls,
952 url);
954 }
955}
956
957
963static void
965{
966 struct GNUNET_DHT_PutHandle *ph = cls;
968 void *cont_cls;
969
970 cont = ph->cont;
971 cont_cls = ph->cont_cls;
972 ph->env = NULL;
974 if (NULL != cont)
975 cont (cont_cls);
976}
977
978
987{
989 GNUNET_MQ_hd_fixed_size (monitor_get,
992 h),
993 GNUNET_MQ_hd_var_size (monitor_get_resp,
996 h),
997 GNUNET_MQ_hd_var_size (monitor_put,
1000 h),
1001 GNUNET_MQ_hd_var_size (client_result,
1004 h),
1005 GNUNET_MQ_hd_var_size (client_hello,
1007 struct GNUNET_MessageHeader,
1008 h),
1010 };
1011
1012 if (NULL != h->mq)
1013 return GNUNET_OK;
1015 "dht",
1016 handlers,
1018 h);
1019 if (NULL == h->mq)
1020 {
1022 "Failed to connect to the DHT service!\n");
1023 return GNUNET_NO;
1024 }
1025 return GNUNET_YES;
1026}
1027
1028
1029struct GNUNET_DHT_Handle *
1031 unsigned int ht_len)
1032{
1033 struct GNUNET_DHT_Handle *handle;
1034
1036 handle->cfg = cfg;
1037 handle->uid_gen
1039 UINT64_MAX);
1040 handle->active_requests
1042 GNUNET_YES);
1043 if (GNUNET_NO == try_connect (handle))
1044 {
1046 return NULL;
1047 }
1048 return handle;
1049}
1050
1051
1052void
1054{
1055 struct GNUNET_DHT_PutHandle *ph;
1056
1057 GNUNET_assert (0 ==
1058 GNUNET_CONTAINER_multihashmap_size (handle->active_requests));
1059 while (NULL != (ph = handle->put_head))
1060 {
1061 if (NULL != ph->cont)
1062 ph->cont (ph->cont_cls);
1064 }
1065 if (NULL != handle->mq)
1066 {
1068 handle->mq = NULL;
1069 }
1070 if (NULL != handle->reconnect_task)
1071 {
1072 GNUNET_SCHEDULER_cancel (handle->reconnect_task);
1073 handle->reconnect_task = NULL;
1074 }
1077}
1078
1079
1080struct GNUNET_DHT_PutHandle *
1082 const struct GNUNET_HashCode *key,
1083 uint32_t desired_replication_level,
1086 size_t size,
1087 const void *data,
1088 struct GNUNET_TIME_Absolute exp,
1090 void *cont_cls)
1091{
1092 struct GNUNET_MQ_Envelope *env;
1093 struct GNUNET_DHT_ClientPutMessage *put_msg;
1094 size_t msize;
1095 struct GNUNET_DHT_PutHandle *ph;
1096
1097 msize = sizeof(struct GNUNET_DHT_ClientPutMessage) + size;
1098 if ((msize >= GNUNET_MAX_MESSAGE_SIZE) ||
1100 {
1101 GNUNET_break (0);
1102 return NULL;
1103 }
1104 if (NULL == handle->mq)
1105 return NULL;
1107 "Sending PUT for %s to DHT via %p\n",
1108 GNUNET_h2s (key),
1109 handle);
1110 ph = GNUNET_new (struct GNUNET_DHT_PutHandle);
1111 ph->dht_handle = handle;
1112 ph->cont = cont;
1113 ph->cont_cls = cont_cls;
1115 handle->put_tail,
1116 ph);
1117 env = GNUNET_MQ_msg_extra (put_msg,
1118 size,
1122 ph);
1123 ph->env = env;
1124 put_msg->type = htonl ((uint32_t) type);
1125 put_msg->options = htonl ((uint32_t) options);
1127 put_msg->expiration = GNUNET_TIME_absolute_hton (exp);
1128 put_msg->key = *key;
1129 GNUNET_memcpy (&put_msg[1],
1130 data,
1131 size);
1133 env);
1134 return ph;
1135}
1136
1137
1138void
1140{
1141 struct GNUNET_DHT_Handle *handle = ph->dht_handle;
1142
1143 if (NULL != ph->env)
1145 NULL,
1146 NULL);
1148 handle->put_tail,
1149 ph);
1150 GNUNET_free (ph);
1151}
1152
1153
1154struct GNUNET_DHT_GetHandle *
1157 const struct GNUNET_HashCode *key,
1160 const void *xquery,
1161 size_t xquery_size,
1163 void *iter_cls)
1164{
1165 struct GNUNET_DHT_GetHandle *gh;
1166 size_t msize;
1167
1168 msize = sizeof(struct GNUNET_DHT_ClientGetMessage) + xquery_size;
1169 if ((msize >= GNUNET_MAX_MESSAGE_SIZE) ||
1170 (xquery_size >= GNUNET_MAX_MESSAGE_SIZE))
1171 {
1172 GNUNET_break (0);
1173 return NULL;
1174 }
1176 "Sending query for %s to DHT %p\n",
1177 GNUNET_h2s (key),
1178 handle);
1179 gh = GNUNET_malloc (sizeof(struct GNUNET_DHT_GetHandle)
1180 + xquery_size);
1181 gh->iter = iter;
1182 gh->iter_cls = iter_cls;
1183 gh->dht_handle = handle;
1184 gh->key = *key;
1185 gh->unique_id = ++handle->uid_gen;
1186 gh->xquery_size = xquery_size;
1188 gh->type = type;
1189 gh->options = options;
1190 GNUNET_memcpy (&gh[1],
1191 xquery,
1192 xquery_size);
1193 GNUNET_CONTAINER_multihashmap_put (handle->active_requests,
1194 &gh->key,
1195 gh,
1197 if (NULL != handle->mq)
1198 send_get (gh);
1199 return gh;
1200}
1201
1202
1203void
1205 unsigned int num_results,
1206 const struct GNUNET_HashCode *results)
1207{
1208 unsigned int needed;
1209 unsigned int had;
1210
1212 needed = had + num_results;
1213 if (needed > get_handle->seen_results_size)
1216 needed);
1218 results,
1219 num_results * sizeof(struct GNUNET_HashCode));
1220 get_handle->seen_results_end += num_results;
1221 if (NULL != get_handle->dht_handle->mq)
1223 had);
1224}
1225
1226
1227void
1229{
1231
1233 "Sending STOP for %s to DHT via %p\n",
1235 handle);
1236 if (NULL != handle->mq)
1237 {
1238 struct GNUNET_MQ_Envelope *env;
1239 struct GNUNET_DHT_ClientGetStopMessage *stop_msg;
1240
1241 env = GNUNET_MQ_msg (stop_msg,
1243 stop_msg->reserved = htonl (0);
1244 stop_msg->unique_id = get_handle->unique_id;
1245 stop_msg->key = get_handle->key;
1247 env);
1248 }
1251 &get_handle->key,
1252 get_handle));
1255 0);
1257}
1258
1259
1263 const struct GNUNET_HashCode *key,
1267 void *cb_cls)
1268{
1270
1272 mh->get_cb = get_cb;
1273 mh->get_resp_cb = get_resp_cb;
1274 mh->put_cb = put_cb;
1275 mh->cb_cls = cb_cls;
1276 mh->type = type;
1277 mh->dht_handle = handle;
1278 if (NULL != key)
1279 {
1280 mh->key = GNUNET_new (struct GNUNET_HashCode);
1281 *mh->key = *key;
1282 }
1283 GNUNET_CONTAINER_DLL_insert (handle->monitor_head,
1284 handle->monitor_tail,
1285 mh);
1286 if (NULL != handle->mq)
1288 return mh;
1289}
1290
1291
1292void
1294{
1295 struct GNUNET_DHT_Handle *handle = mh->dht_handle;
1297 struct GNUNET_MQ_Envelope *env;
1298
1299 GNUNET_CONTAINER_DLL_remove (handle->monitor_head,
1300 handle->monitor_tail,
1301 mh);
1302 env = GNUNET_MQ_msg (m,
1304 m->type = htonl (mh->type);
1305 m->get = htons (NULL != mh->get_cb);
1306 m->get_resp = htons (NULL != mh->get_resp_cb);
1307 m->put = htons (NULL != mh->put_cb);
1308 if (NULL != mh->key)
1309 {
1310 m->filter_key = htons (1);
1311 m->key = *mh->key;
1312 }
1314 env);
1315 GNUNET_free (mh->key);
1316 GNUNET_free (mh);
1317}
1318
1319
1320char *
1322 unsigned int path_len)
1323{
1324 char *buf;
1325 size_t off;
1326 size_t plen = path_len * 5 + 1;
1327
1328 GNUNET_assert (path_len < UINT32_MAX / 5);
1329 off = 0;
1330 buf = GNUNET_malloc (plen);
1331 for (unsigned int i = 0; i < path_len; i++)
1332 {
1333 off += GNUNET_snprintf (&buf[off],
1334 plen - off,
1335 "%s%s",
1336 GNUNET_i2s (&path[i].pred),
1337 (i == path_len - 1) ? "" : "-");
1338 }
1339 return buf;
1340}
1341
1342
1343unsigned int
1345 size_t data_size,
1346 struct GNUNET_TIME_Absolute exp_time,
1347 const struct GNUNET_PeerIdentity *bpid,
1348 const struct GNUNET_DHT_PathElement *put_path,
1349 unsigned int put_path_len,
1350 const struct GNUNET_DHT_PathElement *get_path,
1351 unsigned int get_path_len,
1352 const struct GNUNET_PeerIdentity *me)
1353{
1354 static struct GNUNET_PeerIdentity zero;
1355 struct GNUNET_DHT_HopSignature hs = {
1357 .purpose.size = htonl (sizeof (hs)),
1358 .expiration_time = GNUNET_TIME_absolute_hton (exp_time)
1359 };
1360 unsigned int i;
1361
1362 if (0 == get_path_len + put_path_len)
1363 return 0;
1365 "%s is verifying signatures with GPL: %u PPL: %u!\n",
1366 GNUNET_i2s (me),
1367 get_path_len,
1368 put_path_len);
1369 for (unsigned int j = 0; j<put_path_len; j++)
1371 "PP%u=%s\n",
1372 j,
1373 GNUNET_i2s (&put_path[j].pred));
1374 for (unsigned int j = 0; j<get_path_len; j++)
1376 "GP%u=%s\n",
1377 j,
1378 GNUNET_i2s (&get_path[j].pred));
1380 data_size,
1381 &hs.h_data);
1382 i = put_path_len + get_path_len;
1383 while (i > 0)
1384 {
1385 const struct GNUNET_PeerIdentity *pred;
1386 const struct GNUNET_PeerIdentity *succ;
1387 const struct GNUNET_DHT_PathElement *pe;
1388
1389 i--;
1390 if (0 == i)
1391 {
1392 pred = (NULL == bpid) ? &zero : bpid;
1393 }
1394 else
1395 {
1396 unsigned int off = i - 1;
1397
1398 pred = (off >= put_path_len)
1399 ? &get_path[off - put_path_len].pred
1400 : &put_path[off].pred;
1401 }
1402 if (i == get_path_len + put_path_len - 1)
1403 {
1404 succ = me;
1405 }
1406 else
1407 {
1408 unsigned int off = i + 1;
1409
1410 succ = (off >= put_path_len)
1411 ? &get_path[off - put_path_len].pred
1412 : &put_path[off].pred;
1413 }
1414 hs.pred = *pred;
1415 hs.succ = *succ;
1416 pe = (i >= put_path_len)
1417 ? &get_path[i - put_path_len]
1418 : &put_path[i];
1419 if (GNUNET_OK !=
1422 &hs,
1423 &pe->sig,
1424 &pe->pred.public_key))
1425 {
1426 GNUNET_break_op (0);
1427 return i + 1;
1428 }
1429 }
1430 return i;
1431}
1432
1433
1437 void *cb_cls)
1438{
1439 struct GNUNET_DHT_HelloGetHandle *hgh;
1440 struct GNUNET_MessageHeader *hdr;
1441 struct GNUNET_MQ_Envelope *env;
1442
1444 hgh->cb = cb;
1445 hgh->cb_cls = cb_cls;
1446 hgh->dht_handle = dht_handle;
1448 dht_handle->hgh_tail,
1449 hgh);
1450 env = GNUNET_MQ_msg (hdr,
1453 env);
1454 return hgh;
1455}
1456
1457
1458void
1460{
1462
1464 dht_handle->hgh_tail,
1465 hgh);
1466 GNUNET_free (hgh);
1467}
1468
1469
1470void
1472 const char *url,
1474 void *cb_cls)
1475{
1476 struct GNUNET_MessageHeader *hdr;
1477 size_t slen = strlen (url) + 1;
1478 struct GNUNET_MQ_Envelope *env;
1479
1480 env = GNUNET_MQ_msg_extra (hdr,
1481 slen,
1483 memcpy (&hdr[1],
1484 url,
1485 slen);
1487 cb,
1488 cb_cls);
1490 env);
1491}
1492
1493
1494/* end of dht_api.c */
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
struct GNUNET_MQ_MessageHandlers handlers[]
Definition: 003.c:1
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
dht_handle
Definition: 018.c:1
static void send_get(struct GNUNET_DHT_GetHandle *gh)
Send GET message for a get_handle to DHT.
Definition: dht_api.c:316
static void handle_monitor_get_resp(void *cls, const struct GNUNET_DHT_MonitorGetRespMessage *msg)
Process a get response monitor message from the service.
Definition: dht_api.c:606
static enum GNUNET_GenericReturnValue try_connect(struct GNUNET_DHT_Handle *h)
Try to (re)connect to the DHT service.
Definition: dht_api.c:986
static void handle_client_result(void *cls, const struct GNUNET_DHT_ClientResultMessage *msg)
Process a client result message received from the service.
Definition: dht_api.c:899
static void handle_client_hello(void *cls, const struct GNUNET_MessageHeader *hdr)
Process a client HELLO message received from the service.
Definition: dht_api.c:942
static void try_reconnect(void *cls)
Try reconnecting to the dht service.
Definition: dht_api.c:442
static enum GNUNET_GenericReturnValue process_client_result(void *cls, const struct GNUNET_HashCode *key, void *value)
Process a given reply that might match the given request.
Definition: dht_api.c:796
static enum GNUNET_GenericReturnValue check_monitor_get_resp(void *cls, const struct GNUNET_DHT_MonitorGetRespMessage *msg)
Validate a get response monitor message from the service.
Definition: dht_api.c:571
static void mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
Generic error handler, called with the appropriate error code and the same closure specified at the c...
Definition: dht_api.c:517
static void handle_monitor_get(void *cls, const struct GNUNET_DHT_MonitorGetMessage *msg)
Process a get monitor message from the service.
Definition: dht_api.c:533
static enum GNUNET_GenericReturnValue check_client_result(void *cls, const struct GNUNET_DHT_ClientResultMessage *msg)
Verify that client result message received from the service is well-formed.
Definition: dht_api.c:755
static enum GNUNET_GenericReturnValue check_client_hello(void *cls, const struct GNUNET_MessageHeader *hdr)
Process a client HELLO message received from the service.
Definition: dht_api.c:919
static void do_disconnect(struct GNUNET_DHT_Handle *h)
Try reconnecting to the DHT service.
Definition: dht_api.c:476
static void handle_put_cont(void *cls)
Process a MQ PUT transmission notification.
Definition: dht_api.c:964
static enum GNUNET_GenericReturnValue add_get_request_to_pending(void *cls, const struct GNUNET_HashCode *key, void *value)
Add the GET request corresponding to the given route handle to the pending queue (if it is not alread...
Definition: dht_api.c:391
static void send_get_known_results(struct GNUNET_DHT_GetHandle *gh, unsigned int transmission_offset_start)
Send GET message(s) for indicating which results are already known for a get_handle to DHT.
Definition: dht_api.c:348
static void handle_monitor_put(void *cls, const struct GNUNET_DHT_MonitorPutMessage *msg)
Process a put monitor message from the service.
Definition: dht_api.c:697
#define LOG(kind,...)
Definition: dht_api.c:36
static enum GNUNET_GenericReturnValue check_monitor_put(void *cls, const struct GNUNET_DHT_MonitorPutMessage *msg)
Check validity of a put monitor message from the service.
Definition: dht_api.c:664
static void send_monitor_start(struct GNUNET_DHT_MonitorHandle *mh)
Send GNUNET_MESSAGE_TYPE_DHT_MONITOR_START message.
Definition: dht_api.c:414
static struct GNUNET_ARM_MonitorHandle * m
Monitor connection with ARM.
Definition: gnunet-arm.c:103
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:98
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:108
static struct GNUNET_CADET_Handle * mh
Cadet handle.
Definition: gnunet-cadet.c:92
static GNUNET_NETWORK_STRUCT_END struct GNUNET_PeerIdentity me
Our own peer identity.
static void get_cb(void *cls, const struct GNUNET_HashCode *key, size_t size, const void *data, enum GNUNET_BLOCK_Type type, uint32_t priority, uint32_t anonymity, uint32_t replication, struct GNUNET_TIME_Absolute expiration, uint64_t uid)
Process a datum that was stored in the datastore.
static void put_cb(void *cls, int32_t success, struct GNUNET_TIME_Absolute min_expiration, const char *msg)
Continuation called to notify client about result of the operation.
static struct GNUNET_DHT_GetHandle * get_handle
Handle for the get request.
static char * data
The data to insert into the dht.
struct GNUNET_HashCode key
The key used in the DHT.
static char * value
Value of the record to add/remove.
static uint32_t type
Type string converted to DNS type value.
static size_t data_size
Number of bytes in data.
static unsigned int results
static const struct GNUNET_CRYPTO_PrivateKey zero
Public key of all zeros.
static struct GNUNET_VPN_Handle * handle
Handle to vpn service.
Definition: gnunet-vpn.c:35
API to the DHT service.
Constants for network protocols.
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message,...
struct GNUNET_MQ_Handle * GNUNET_CLIENT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *service_name, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *error_handler_cls)
Create a message queue to connect to a GNUnet service.
Definition: client.c:1060
uint64_t GNUNET_CRYPTO_random_u64(enum GNUNET_CRYPTO_Quality mode, uint64_t max)
Generate a random unsigned 64-bit value.
#define GNUNET_CRYPTO_eddsa_verify(purp, ps, sig, pub)
Verify EdDSA signature.
@ GNUNET_CRYPTO_QUALITY_WEAK
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
void GNUNET_DHT_put_cancel(struct GNUNET_DHT_PutHandle *ph)
Cancels a DHT PUT operation.
Definition: dht_api.c:1139
GNUNET_DHT_RouteOption
Options for routing.
struct GNUNET_DHT_PutHandle * GNUNET_DHT_put(struct GNUNET_DHT_Handle *handle, const struct GNUNET_HashCode *key, uint32_t desired_replication_level, enum GNUNET_DHT_RouteOption options, enum GNUNET_BLOCK_Type type, size_t size, const void *data, struct GNUNET_TIME_Absolute exp, GNUNET_SCHEDULER_TaskCallback cont, void *cont_cls)
Perform a PUT operation storing data in the DHT.
Definition: dht_api.c:1081
char * GNUNET_DHT_pp2s(const struct GNUNET_DHT_PathElement *path, unsigned int path_len)
Convert a peer path to a human-readable string.
Definition: dht_api.c:1321
struct GNUNET_DHT_Handle * GNUNET_DHT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, unsigned int ht_len)
Initialize the connection with the DHT service.
Definition: dht_api.c:1030
void GNUNET_DHT_hello_get_cancel(struct GNUNET_DHT_HelloGetHandle *hgh)
Cancel hello get operation.
Definition: dht_api.c:1459
void GNUNET_DHT_get_stop(struct GNUNET_DHT_GetHandle *get_handle)
Stop async DHT-get.
Definition: dht_api.c:1228
void GNUNET_DHT_get_filter_known_results(struct GNUNET_DHT_GetHandle *get_handle, unsigned int num_results, const struct GNUNET_HashCode *results)
Tell the DHT not to return any of the following known results to this client.
Definition: dht_api.c:1204
void(* GNUNET_DHT_GetIterator)(void *cls, struct GNUNET_TIME_Absolute exp, const struct GNUNET_HashCode *query_hash, const struct GNUNET_PeerIdentity *trunc_peer, const struct GNUNET_DHT_PathElement *get_path, unsigned int get_path_length, const struct GNUNET_DHT_PathElement *put_path, unsigned int put_path_length, enum GNUNET_BLOCK_Type type, size_t size, const void *data)
Iterator called on each result obtained for a DHT operation that expects a reply.
void(* GNUNET_DHT_MonitorGetRespCB)(void *cls, enum GNUNET_BLOCK_Type type, const struct GNUNET_PeerIdentity *trunc_peer, const struct GNUNET_DHT_PathElement *get_path, unsigned int get_path_length, const struct GNUNET_DHT_PathElement *put_path, unsigned int put_path_length, struct GNUNET_TIME_Absolute exp, const struct GNUNET_HashCode *key, const void *data, size_t size)
Callback called on each GET reply going through the DHT.
void(* GNUNET_DHT_MonitorGetCB)(void *cls, enum GNUNET_DHT_RouteOption options, enum GNUNET_BLOCK_Type type, uint32_t hop_count, uint32_t desired_replication_level, const struct GNUNET_HashCode *key)
Callback called on each GET request going through the DHT.
void(* GNUNET_DHT_HelloGetCallback)(void *cls, const char *hello_url)
Signature called with the result of a HELLO GET operation.
struct GNUNET_DHT_MonitorHandle * GNUNET_DHT_monitor_start(struct GNUNET_DHT_Handle *handle, enum GNUNET_BLOCK_Type type, const struct GNUNET_HashCode *key, GNUNET_DHT_MonitorGetCB get_cb, GNUNET_DHT_MonitorGetRespCB get_resp_cb, GNUNET_DHT_MonitorPutCB put_cb, void *cb_cls)
Start monitoring the local DHT service.
Definition: dht_api.c:1261
struct GNUNET_DHT_GetHandle * GNUNET_DHT_get_start(struct GNUNET_DHT_Handle *handle, enum GNUNET_BLOCK_Type type, const struct GNUNET_HashCode *key, uint32_t desired_replication_level, enum GNUNET_DHT_RouteOption options, const void *xquery, size_t xquery_size, GNUNET_DHT_GetIterator iter, void *iter_cls)
Perform an asynchronous GET operation on the DHT identified.
Definition: dht_api.c:1155
struct GNUNET_DHT_HelloGetHandle * GNUNET_DHT_hello_get(struct GNUNET_DHT_Handle *dht_handle, GNUNET_DHT_HelloGetCallback cb, void *cb_cls)
Obtain HELLO URL of the DHT identified by dht_handle.
Definition: dht_api.c:1435
void GNUNET_DHT_disconnect(struct GNUNET_DHT_Handle *handle)
Shutdown connection with the DHT service.
Definition: dht_api.c:1053
void GNUNET_DHT_hello_offer(struct GNUNET_DHT_Handle *dht_handle, const char *url, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
Offer HELLO URL of the DHT identified by dht_handle.
Definition: dht_api.c:1471
void(* GNUNET_DHT_MonitorPutCB)(void *cls, enum GNUNET_DHT_RouteOption options, enum GNUNET_BLOCK_Type type, uint32_t hop_count, uint32_t desired_replication_level, const struct GNUNET_PeerIdentity *trunc_peer, unsigned int path_length, const struct GNUNET_DHT_PathElement *path, struct GNUNET_TIME_Absolute exp, const struct GNUNET_HashCode *key, const void *data, size_t size)
Callback called on each PUT request going through the DHT.
unsigned int GNUNET_DHT_verify_path(const void *data, size_t data_size, struct GNUNET_TIME_Absolute exp_time, const struct GNUNET_PeerIdentity *bpid, const struct GNUNET_DHT_PathElement *put_path, unsigned int put_path_len, const struct GNUNET_DHT_PathElement *get_path, unsigned int get_path_len, const struct GNUNET_PeerIdentity *me)
Verify signatures on a path consisting of put_path and get_path in reverse order (starting at the las...
Definition: dht_api.c:1344
void GNUNET_DHT_monitor_stop(struct GNUNET_DHT_MonitorHandle *mh)
Stop monitoring.
Definition: dht_api.c:1293
@ GNUNET_DHT_RO_TRUNCATED
Flag set if the path was truncated.
#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.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MultiHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_remove(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, const void *value)
Remove the given key-value pair from the map.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_get_multiple(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, GNUNET_CONTAINER_MultiHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map that match a particular key.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE
Allow multiple values with the same key.
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
#define GNUNET_log(kind,...)
#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.
GNUNET_GenericReturnValue
Named constants for return values.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
@ GNUNET_SYSERR
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#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.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_array_grow(arr, size, tsize)
Grow a well-typed (!) array.
int GNUNET_snprintf(char *buf, size_t size, const char *format,...) __attribute__((format(printf
Like snprintf, just aborts if the buffer is of insufficient size.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
GNUNET_MQ_Error
Error codes for the queue.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:305
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
Definition: gnunet_mq_lib.h:63
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:78
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
void GNUNET_MQ_notify_sent(struct GNUNET_MQ_Envelope *ev, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
Call a callback once the envelope has been sent, that is, sending it can not be canceled anymore.
Definition: mq.c:655
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:700
#define GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET
Receive information about transiting GETs.
#define GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET_RESP
Receive information about transiting GET responses.
#define GNUNET_MESSAGE_TYPE_DHT_CLIENT_PUT
Client wants to store item in DHT.
#define GNUNET_MESSAGE_TYPE_DHT_MONITOR_START
Request information about transiting messages.
#define GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET_RESULTS_KNOWN
Certain results are already known to the client, filter those.
#define GNUNET_MESSAGE_TYPE_DHT_MONITOR_PUT
Receive information about transiting PUTs.
#define GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET_STOP
Client wants to stop search in DHT.
#define GNUNET_MESSAGE_TYPE_DHT_CLIENT_RESULT
Service returns result to client.
#define GNUNET_MESSAGE_TYPE_DHT_MONITOR_STOP
Stop information about transiting messages.
#define GNUNET_MESSAGE_TYPE_DHT_CLIENT_HELLO_GET
Client requests DHT service's HELLO URL.
#define GNUNET_MESSAGE_TYPE_DHT_CLIENT_HELLO_URL
HELLO URL send between client and service (in either direction).
#define GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET
Client wants to lookup item in DHT.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:979
void(* GNUNET_SCHEDULER_TaskCallback)(void *cls)
Signature of the main function of a task.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1276
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:579
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:739
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:640
#define GNUNET_TIME_STD_BACKOFF(r)
Perform our standard exponential back-off calculation, starting at 1 ms and then going by a factor of...
#define max(x, y)
static unsigned int size
Size of the "table".
Definition: peer.c:68
static struct GNUNET_TIME_Relative delta
Definition: speedup.c:36
GNUNET_BLOCK_Type
WARNING: This header is generated! In order to add DHT block types, you must register them in GANA,...
@ GNUNET_BLOCK_TYPE_ANY
Identifier for any block.
#define GNUNET_SIGNATURE_PURPOSE_DHT_HOP
Signature by which a peer affirms that it forwarded a message in the DHT.
struct GNUNET_MQ_Handle * mq
Our connection to the ARM service.
Definition: arm_api.c:107
const struct GNUNET_CONFIGURATION_Handle * cfg
The configuration that we are using.
Definition: arm_api.c:112
struct GNUNET_SCHEDULER_Task * reconnect_task
ID of the reconnect task (if any).
Definition: arm_api.c:147
Internal representation of the hash map.
uint32_t purpose
What does this signature vouch for? This must contain a GNUNET_SIGNATURE_PURPOSE_XXX constant (from g...
DHT GET message sent from clients to service.
Definition: dht.h:72
uint64_t unique_id
Unique ID identifying this request, if 0 then the client will not expect a response.
Definition: dht.h:103
uint32_t options
Message options, actually an 'enum GNUNET_DHT_RouteOption' value.
Definition: dht.h:81
struct GNUNET_HashCode key
The key to search for.
Definition: dht.h:97
uint32_t type
The type for the data for the GET request; actually an 'enum GNUNET_BLOCK_Type'.
Definition: dht.h:92
uint32_t desired_replication_level
Replication level for this message.
Definition: dht.h:86
DHT GET RESULTS KNOWN message sent from clients to service.
Definition: dht.h:114
Message which indicates the DHT should cancel outstanding requests and discard any state.
Definition: dht.h:44
uint64_t unique_id
Unique ID identifying this request.
Definition: dht.h:58
struct GNUNET_HashCode key
Key of this request.
Definition: dht.h:63
uint32_t reserved
Always zero.
Definition: dht.h:53
Message to insert data into the DHT, sent from clients to DHT service.
Definition: dht.h:200
struct GNUNET_HashCode key
The key to store the value under.
Definition: dht.h:229
uint32_t type
The type of data to insert.
Definition: dht.h:209
uint32_t options
Message options, actually an 'enum GNUNET_DHT_RouteOption' value.
Definition: dht.h:214
uint32_t desired_replication_level
Replication level for this message.
Definition: dht.h:219
struct GNUNET_TIME_AbsoluteNBO expiration
How long should this data persist?
Definition: dht.h:224
Reply to a GET send from the service to a client.
Definition: dht.h:144
uint32_t put_path_length
Number of peers recorded in the outgoing path from source to the storgage location of this message.
Definition: dht.h:169
uint64_t unique_id
Unique ID of the matching GET request.
Definition: dht.h:180
struct GNUNET_TIME_AbsoluteNBO expiration
When does this entry expire?
Definition: dht.h:185
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_DHT_CLIENT_RESULT.
Definition: dht.h:148
uint32_t type
The type for the data.
Definition: dht.h:153
uint32_t options
Message options, actually an 'enum GNUNET_DHT_RouteOption' value.
Definition: dht.h:163
uint32_t get_path_length
The number of peer identities recorded from the storage location to this peer.
Definition: dht.h:175
Handle to a GET request.
Definition: dht_api.c:79
GNUNET_DHT_GetIterator iter
Iterator to call on data receipt.
Definition: dht_api.c:83
enum GNUNET_BLOCK_Type type
Type of the block we are looking for.
Definition: dht_api.c:124
void * iter_cls
Closure for iter.
Definition: dht_api.c:88
unsigned int seen_results_end
Offset into the seen_results array marking the end of the positions that are actually used.
Definition: dht_api.c:141
struct GNUNET_HashCode * seen_results
Array of hash codes over the results that we have already seen.
Definition: dht_api.c:99
size_t xquery_size
Size of the extended query, allocated at the end of this struct.
Definition: dht_api.c:114
uint32_t desired_replication_level
Desired replication level.
Definition: dht_api.c:119
struct GNUNET_HashCode key
Key that this get request is for.
Definition: dht_api.c:104
uint64_t unique_id
Unique identifier for this request (for key collisions).
Definition: dht_api.c:109
struct GNUNET_DHT_Handle * dht_handle
Main handle to this DHT api.
Definition: dht_api.c:93
enum GNUNET_DHT_RouteOption options
Routing options.
Definition: dht_api.c:129
unsigned int seen_results_size
Size of the seen_results array.
Definition: dht_api.c:135
Connection to the DHT service.
Definition: dht_api.c:235
struct GNUNET_CONTAINER_MultiHashMap * active_requests
Hash map containing the current outstanding unique GET requests (values are of type struct GNUNET_DHT...
Definition: dht_api.c:280
struct GNUNET_TIME_Relative retry_time
How quickly should we retry? Used for exponential back-off on connect-errors.
Definition: dht_api.c:291
struct GNUNET_SCHEDULER_Task * reconnect_task
Task for trying to reconnect.
Definition: dht_api.c:285
struct GNUNET_DHT_PutHandle * put_tail
Tail of active PUT requests.
Definition: dht_api.c:264
struct GNUNET_DHT_MonitorHandle * monitor_tail
Tail of linked list of messages we would like to monitor.
Definition: dht_api.c:254
struct GNUNET_MQ_Handle * mq
Connection to DHT service.
Definition: dht_api.c:244
struct GNUNET_DHT_PutHandle * put_head
Head of active PUT requests.
Definition: dht_api.c:259
struct GNUNET_DHT_MonitorHandle * monitor_head
Head of linked list of messages we would like to monitor.
Definition: dht_api.c:249
struct GNUNET_DHT_HelloGetHandle * hgh_tail
DLL.
Definition: dht_api.c:274
uint64_t uid_gen
Generator for unique ids.
Definition: dht_api.c:296
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration to use.
Definition: dht_api.c:239
struct GNUNET_DHT_HelloGetHandle * hgh_head
DLL.
Definition: dht_api.c:269
Handle to get a HELLO URL from the DHT for manual bootstrapping.
Definition: dht_api.c:201
struct GNUNET_DHT_Handle * dht_handle
Connection to the DHT service.
Definition: dht_api.c:226
GNUNET_DHT_HelloGetCallback cb
Function to call with the result.
Definition: dht_api.c:216
void * cb_cls
Closure for cb.
Definition: dht_api.c:221
struct GNUNET_DHT_HelloGetHandle * prev
DLL.
Definition: dht_api.c:211
struct GNUNET_DHT_HelloGetHandle * next
DLL.
Definition: dht_api.c:206
Message signed by a peer when doing path tracking.
struct GNUNET_HashCode h_data
Hash over the payload of the block.
struct GNUNET_CRYPTO_EccSignaturePurpose purpose
Must be GNUNET_SIGNATURE_PURPOSE_DHT_HOP.
struct GNUNET_PeerIdentity pred
Previous hop the message was received from.
struct GNUNET_PeerIdentity succ
Next hop the message was forwarded to.
Message to monitor get requests going through peer, DHT service -> clients.
Definition: dht.h:334
Message to monitor get results going through peer, DHT service -> clients.
Definition: dht.h:377
Handle to a monitoring request.
Definition: dht_api.c:149
GNUNET_DHT_MonitorGetRespCB get_resp_cb
Callback for each received message of type get response.
Definition: dht_api.c:183
struct GNUNET_HashCode * key
Key being looked for, NULL == all.
Definition: dht_api.c:173
struct GNUNET_DHT_MonitorHandle * prev
DLL.
Definition: dht_api.c:158
struct GNUNET_DHT_MonitorHandle * next
DLL.
Definition: dht_api.c:153
GNUNET_DHT_MonitorPutCB put_cb
Callback for each received message of type put.
Definition: dht_api.c:188
struct GNUNET_DHT_Handle * dht_handle
Main handle to this DHT api.
Definition: dht_api.c:163
GNUNET_DHT_MonitorGetCB get_cb
Callback for each received message of type get.
Definition: dht_api.c:178
void * cb_cls
Closure for get_cb, put_cb and get_resp_cb.
Definition: dht_api.c:193
enum GNUNET_BLOCK_Type type
Type of block looked for.
Definition: dht_api.c:168
Message to monitor put requests going through peer, DHT service -> clients.
Definition: dht.h:239
Message to request monitoring messages, clients -> DHT service.
Definition: dht.h:291
A (signed) path tracking a block's flow through the DHT is represented by an array of path elements,...
struct GNUNET_PeerIdentity pred
Previous peer on the path (matches "pred" in the signed field).
struct GNUNET_CRYPTO_EddsaSignature sig
Signature affirming the hop of type GNUNET_SIGNATURE_PURPOSE_DHT_HOP.
Handle to a PUT request.
Definition: dht_api.c:43
struct GNUNET_DHT_Handle * dht_handle
Main handle to this DHT api.
Definition: dht_api.c:62
struct GNUNET_DHT_PutHandle * prev
Kept in a DLL.
Definition: dht_api.c:52
void * cont_cls
Closure for cont.
Definition: dht_api.c:67
struct GNUNET_MQ_Envelope * env
Envelope from the PUT operation.
Definition: dht_api.c:72
struct GNUNET_DHT_PutHandle * next
Kept in a DLL.
Definition: dht_api.c:47
GNUNET_SCHEDULER_TaskCallback cont
Continuation to call when done.
Definition: dht_api.c:57
A 512-bit hashcode.
Handle to a message queue.
Definition: mq.c:87
Message handler for a specific message type.
Header for all communications.
The identity of the host (wraps the signing key of the peer).
struct GNUNET_CRYPTO_EddsaPublicKey public_key
Entry in list of pending tasks.
Definition: scheduler.c:135
Time for absolute times used by GNUnet, in microseconds.
Time for relative time used by GNUnet, in microseconds.
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we use.
Definition: vpn_api.c:39
struct GNUNET_MQ_Handle * mq
Connection to VPN service.
Definition: vpn_api.c:44