GNUnet 0.21.0
gnunet-service-fs_cp.c
Go to the documentation of this file.
1/*
2 This file is part of GNUnet.
3 Copyright (C) 2011, 2016 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 */
25#include "platform.h"
26#include "gnunet_util_lib.h"
27#include "gnunet_load_lib.h"
28#include "gnunet-service-fs.h"
34
35
41#define RUNAVG_DELAY_N 16
42
46#define RESPECT_FLUSH_FREQ GNUNET_TIME_relative_multiply ( \
47 GNUNET_TIME_UNIT_MINUTES, 5)
48
52#define REPLY_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, \
53 2)
54
58#define INSANE_STATISTICS GNUNET_NO
59
60
65{
70
75
80
85
90
95
99 uint32_t priority;
100};
101
102
107{
112
117
122
127
132
136 size_t msize;
137};
138
139
144{
149
154
159};
160
161
166{
171
177
182
188
194
200
206
211
216
222
228
232 unsigned int delay_queue_size;
233
237 uint32_t disk_respect;
238
244
250
255
260};
261
262
267
272
277
278
285void
287 struct GNUNET_TIME_Relative latency)
288{
289 struct GSF_ConnectedPeer *cp;
290
291 cp = GSF_peer_get_ (id);
292 if (NULL == cp)
293 return; /* we're not yet connected at the core level, ignore */
295 latency);
296}
297
298
307{
308 return &cp->ppd;
309}
310
311
317static void
319
320
327static void
329{
330 struct GSF_ConnectedPeer *cp;
331 struct GNUNET_PeerIdentity target;
332
333 cp = pth->cp;
334 GNUNET_assert (0 != cp->ppd.pid);
335 GNUNET_PEER_resolve (cp->ppd.pid, &target);
336
337 peer_transmit (cp);
338}
339
340
346static void
348{
349 struct GSF_PeerTransmitHandle *pth = cp->pth_head;
350 struct GSF_PeerTransmitHandle *pos;
351
352 if (NULL == pth)
353 return;
355 cp->pth_tail,
356 pth);
357 if (GNUNET_YES == pth->is_query)
358 {
363 }
364 else if (GNUNET_NO == pth->is_query)
365 {
367 }
372 pth->env);
373 GNUNET_free (pth);
374 if (NULL != (pos = cp->pth_head))
375 {
376 GNUNET_assert (pos != pth);
378 }
379}
380
381
389static void
391 const struct GNUNET_PEERSTORE_Record *record,
392 const char *emsg)
393{
394 struct GSF_ConnectedPeer *cp = cls;
395
397 if ((NULL == record) && (NULL == emsg))
398 {
399 cp->respect_iterate_req = NULL;
400 return;
401 }
402 if ((NULL != record) &&
403 (sizeof(cp->disk_respect) == record->value_size))
404 {
405 cp->disk_respect = *((uint32_t *) record->value);
406 cp->ppd.respect += *((uint32_t *) record->value);
407 }
408 GSF_push_start_ (cp);
409 if (NULL != record)
410 {
412 return;
413 }
414 cp->respect_iterate_req = NULL;
416}
417
418
429static int
431 const struct GNUNET_HashCode *key,
432 struct GSF_PendingRequest *pr)
433{
434 struct GSF_ConnectedPeer *cp = cls;
436
437 if (GNUNET_YES !=
439 return GNUNET_YES; /* request is not actually active, skip! */
441 if (GNUNET_YES !=
443 {
445 gettext_noop ("# Loopback routes suppressed"),
446 1,
447 GNUNET_NO);
448 return GNUNET_YES;
449 }
450 GSF_plan_add_ (cp, pr);
451 return GNUNET_YES;
452}
453
454
455void *
457 const struct GNUNET_PeerIdentity *peer,
458 struct GNUNET_MQ_Handle *mq)
459{
460 struct GSF_ConnectedPeer *cp;
461
462 if (0 ==
464 peer))
465 return NULL;
467 "Connected to peer %s\n",
468 GNUNET_i2s (peer));
469 cp = GNUNET_new (struct GSF_ConnectedPeer);
470 cp->ppd.pid = GNUNET_PEER_intern (peer);
471 cp->ppd.peer = peer;
472 cp->mq = mq;
474
476 GNUNET_YES);
480 cp),
481 cp,
484 gettext_noop ("# peers connected"),
486 GNUNET_NO);
489 "fs",
490 peer,
491 "respect",
493 cp);
495 cp);
496 return cp;
497}
498
499
506static void
508{
509 struct GSF_ConnectedPeer *cp = cls;
510 struct GNUNET_TIME_Relative bt;
511
512 cp->mig_revive_task = NULL;
514 if (0 != bt.rel_value_us)
515 {
516 /* still time left... */
517 cp->mig_revive_task =
519 return;
520 }
521 GSF_push_start_ (cp);
522}
523
524
525struct GSF_ConnectedPeer *
527{
528 if (NULL == cp_map)
529 return NULL;
531}
532
533
540void
542 const struct MigrationStopMessage *msm)
543{
544 struct GSF_ConnectedPeer *cp = cls;
545 struct GNUNET_TIME_Relative bt;
546
548 gettext_noop ("# migration stop messages received"),
549 1, GNUNET_NO);
552 _ ("Migration of content to peer `%s' blocked for %s\n"),
553 GNUNET_i2s (cp->ppd.peer),
556 if ((NULL == cp->mig_revive_task) &&
557 (NULL == cp->respect_iterate_req))
558 {
559 GSF_push_stop_ (cp);
560 cp->mig_revive_task =
562 &revive_migration, cp);
563 }
564}
565
566
572static void
574{
575 struct GSF_ConnectedPeer *cp = peerreq->cp;
576 struct GSF_PendingRequestData *prd;
577
578 prd = GSF_pending_request_get_data_ (peerreq->pr);
579 if (NULL != peerreq->kill_task)
580 {
582 peerreq->kill_task = NULL;
583 }
585 gettext_noop ("# P2P searches active"),
586 -1,
587 GNUNET_NO);
590 &prd->query,
591 peerreq));
592 GNUNET_free (peerreq);
593}
594
595
604static int
606 const struct GNUNET_HashCode *query,
607 void *value)
608{
609 struct PeerRequest *peerreq = value;
610 struct GSF_PendingRequest *pr = peerreq->pr;
611
612 free_pending_request (peerreq);
614 GNUNET_NO);
615 return GNUNET_OK;
616}
617
618
624static void
626{
627 struct PeerRequest *peerreq = cls;
628 struct GSF_PendingRequest *pr = peerreq->pr;
629 struct GSF_PendingRequestData *prd;
630
631 peerreq->kill_task = NULL;
634 &prd->query,
635 peerreq);
636}
637
638
644static void
646{
647 struct GSF_DelayedHandle *dh = cls;
648 struct GSF_ConnectedPeer *cp = dh->cp;
649
651 cp->delayed_tail,
652 dh);
653 cp->delay_queue_size--;
655 GNUNET_NO,
656 UINT32_MAX,
657 dh->env);
658 GNUNET_free (dh);
659}
660
661
667static struct GNUNET_TIME_Relative
669{
671
672 ret =
677#if INSANE_STATISTICS
680 ("# artificial delays introduced (ms)"),
681 ret.rel_value_us / 1000LL, GNUNET_NO);
682#endif
683 return ret;
684}
685
686
705static void
708 struct GSF_PendingRequest *pr,
709 uint32_t reply_anonymity_level,
711 struct GNUNET_TIME_Absolute last_transmission,
713 const void *data,
714 size_t data_len)
715{
716 struct PeerRequest *peerreq = cls;
717 struct GSF_ConnectedPeer *cp = peerreq->cp;
718 struct GSF_PendingRequestData *prd;
719 struct GNUNET_MQ_Envelope *env;
720 struct PutMessage *pm;
721 size_t msize;
722
723 GNUNET_assert (data_len + sizeof(struct PutMessage) <
725 GNUNET_assert (peerreq->pr == pr);
727 if (NULL == data)
728 {
729 free_pending_request (peerreq);
730 return;
731 }
733 if ( (prd->type != type) &&
734 (GNUNET_BLOCK_TYPE_ANY != prd->type) )
735 {
737 "# replies dropped due to type mismatch",
738 1, GNUNET_NO);
739 return;
740 }
742 "Transmitting result for query `%s' to peer\n",
743 GNUNET_h2s (&prd->query));
745 "# replies received for other peers",
746 1,
747 GNUNET_NO);
748 msize = sizeof(struct PutMessage) + data_len;
749 if (msize >= GNUNET_MAX_MESSAGE_SIZE)
750 {
751 GNUNET_break (0);
752 return;
753 }
754 if ( (UINT32_MAX != reply_anonymity_level) &&
755 (reply_anonymity_level > 1) )
756 {
757 if (reply_anonymity_level - 1 > GSF_cover_content_count)
758 {
760 "# replies dropped due to insufficient cover traffic",
761 1, GNUNET_NO);
762 return;
763 }
764 GSF_cover_content_count -= (reply_anonymity_level - 1);
765 }
766
768 data_len,
770 pm->type = htonl (type);
772 GNUNET_memcpy (&pm[1],
773 data,
774 data_len);
775 if ((UINT32_MAX != reply_anonymity_level) &&
776 (0 != reply_anonymity_level) &&
778 {
779 struct GSF_DelayedHandle *dh;
780
781 dh = GNUNET_new (struct GSF_DelayedHandle);
782 dh->cp = cp;
783 dh->env = env;
784 dh->msize = msize;
787 dh);
789 dh->delay_task =
792 dh);
793 }
794 else
795 {
797 GNUNET_NO,
798 UINT32_MAX,
799 env);
800 }
801 if (GNUNET_BLOCK_REPLY_OK_LAST != eval)
802 return;
803 if (NULL == peerreq->kill_task)
804 {
806 "# P2P searches destroyed due to ultimate reply",
807 1,
808 GNUNET_NO);
809 peerreq->kill_task =
811 peerreq);
812 }
813}
814
815
824static int
826{
827 if (0 == value)
828 return 0;
829 GNUNET_assert (NULL != cp);
830 if (value > 0)
831 {
832 if (cp->ppd.respect + value < cp->ppd.respect)
833 {
834 value = UINT32_MAX - cp->ppd.respect;
835 cp->ppd.respect = UINT32_MAX;
836 }
837 else
838 cp->ppd.respect += value;
839 }
840 else
841 {
842 if (cp->ppd.respect < -value)
843 {
844 value = -cp->ppd.respect;
845 cp->ppd.respect = 0;
846 }
847 else
848 cp->ppd.respect += value;
849 }
850 return value;
851}
852
853
862static int32_t
863bound_priority (uint32_t prio_in,
864 struct GSF_ConnectedPeer *cp)
865{
866#define N ((double) 128.0)
867 uint32_t ret;
868 double rret;
869 int ld;
870
872 if (GNUNET_SYSERR == ld)
873 {
874#if INSANE_STATISTICS
877 ("# requests done for free (low load)"), 1,
878 GNUNET_NO);
879#endif
880 return 0; /* excess resources */
881 }
882 if (prio_in > INT32_MAX)
883 prio_in = INT32_MAX;
884 ret = -change_peer_respect (cp, -(int) prio_in);
885 if (ret > 0)
886 {
888 rret = GSF_current_priorities + N;
889 else
890 rret = ret;
892 }
893 if ((GNUNET_YES == ld) && (ret > 0))
894 {
895 /* try with charging */
897 }
898 if (GNUNET_YES == ld)
899 {
902 ("# request dropped, priority insufficient"), 1,
903 GNUNET_NO);
904 /* undo charge */
905 change_peer_respect (cp, (int) ret);
906 return -1; /* not enough resources */
907 }
908 else
909 {
912 ("# requests done for a price (normal load)"),
913 1,
914 GNUNET_NO);
915 }
916#undef N
917 return ret;
918}
919
920
930static int32_t
931bound_ttl (int32_t ttl_in,
932 uint32_t prio)
933{
934 unsigned long long allowed;
935
936 if (ttl_in <= 0)
937 return ttl_in;
938 allowed = ((unsigned long long) prio) * TTL_DECREMENT / 1000;
939 if (ttl_in > allowed)
940 {
941 if (allowed >= (1 << 30))
942 return 1 << 30;
943 return allowed;
944 }
945 return ttl_in;
946}
947
948
953{
957 int32_t priority;
958
962 int32_t ttl;
963
968
973};
974
975
986static int
987test_exist_cb (void *cls,
988 const struct GNUNET_HashCode *hc,
989 void *value)
990{
991 struct TestExistClosure *tec = cls;
992 struct PeerRequest *peerreq = value;
993 struct GSF_PendingRequest *pr;
994 struct GSF_PendingRequestData *prd;
995
996 pr = peerreq->pr;
998 if (prd->type != tec->type)
999 return GNUNET_YES;
1000 if (prd->ttl.abs_value_us >=
1001 GNUNET_TIME_absolute_get ().abs_value_us + tec->ttl * 1000LL)
1002 {
1003 /* existing request has higher TTL, drop new one! */
1004 prd->priority += tec->priority;
1006 "Have existing request with higher TTL, dropping new request.\n");
1009 ("# requests dropped due to higher-TTL request"),
1010 1, GNUNET_NO);
1011 tec->finished = GNUNET_YES;
1012 return GNUNET_NO;
1013 }
1014 /* existing request has lower TTL, drop old one! */
1015 tec->priority += prd->priority;
1016 free_pending_request (peerreq);
1018 GNUNET_YES);
1019 return GNUNET_NO;
1020}
1021
1022
1032void
1034 const struct GetMessage *gm)
1035{
1036 struct GSF_ConnectedPeer *cps = cls;
1037 struct PeerRequest *peerreq;
1038 struct GSF_PendingRequest *pr;
1039 struct GSF_ConnectedPeer *cp;
1040 const struct GNUNET_PeerIdentity *target;
1042 uint16_t msize;
1043 unsigned int bits;
1044 const struct GNUNET_PeerIdentity *opt;
1045 uint32_t bm;
1046 size_t bfsize;
1047 uint32_t ttl_decrement;
1048 struct TestExistClosure tec;
1049 GNUNET_PEER_Id spid;
1050 const struct GSF_PendingRequestData *prd;
1051
1052 msize = ntohs (gm->header.size);
1053 tec.type = ntohl (gm->type);
1054 bm = ntohl (gm->hash_bitmap);
1055 bits = 0;
1056 while (bm > 0)
1057 {
1058 if (1 == (bm & 1))
1059 bits++;
1060 bm >>= 1;
1061 }
1062 opt = (const struct GNUNET_PeerIdentity *) &gm[1];
1063 bfsize = msize - sizeof(struct GetMessage) - bits * sizeof(struct
1067 ("# GET requests received (from other peers)"),
1068 1,
1069 GNUNET_NO);
1071 bm = ntohl (gm->hash_bitmap);
1072 bits = 0;
1073 if (0 != (bm & GET_MESSAGE_BIT_RETURN_TO))
1074 cp = GSF_peer_get_ (&opt[bits++]);
1075 else
1076 cp = cps;
1077 if (NULL == cp)
1078 {
1079 if (0 != (bm & GET_MESSAGE_BIT_RETURN_TO))
1081 "Failed to find RETURN-TO peer `%s' in connection set. Dropping query.\n",
1082 GNUNET_i2s (&opt[bits - 1]));
1083
1084 else
1086 "Failed to find peer `%s' in connection set. Dropping query.\n",
1087 GNUNET_i2s (cps->ppd.peer));
1090 (
1091 "# requests dropped due to missing reverse route"),
1092 1,
1093 GNUNET_NO);
1094 return;
1095 }
1096 unsigned int queue_size = GNUNET_MQ_get_length (cp->mq);
1097 queue_size += cp->ppd.pending_replies + cp->delay_queue_size;
1098 if (queue_size > MAX_QUEUE_PER_PEER)
1099 {
1101 "Peer `%s' has too many replies queued already. Dropping query.\n",
1102 GNUNET_i2s (cps->ppd.peer));
1104 gettext_noop (
1105 "# requests dropped due to full reply queue"),
1106 1,
1107 GNUNET_NO);
1108 return;
1109 }
1110 /* note that we can really only check load here since otherwise
1111 * peers could find out that we are overloaded by not being
1112 * disconnected after sending us a malformed query... */
1113 tec.priority = bound_priority (ntohl (gm->priority),
1114 cps);
1115 if (tec.priority < 0)
1116 {
1118 "Dropping query from `%s', this peer is too busy.\n",
1119 GNUNET_i2s (cps->ppd.peer));
1120 return;
1121 }
1123 "Received request for `%s' of type %u from peer `%s' with flags %u\n",
1124 GNUNET_h2s (&gm->query),
1125 (unsigned int) tec.type,
1126 GNUNET_i2s (cps->ppd.peer),
1127 (unsigned int) bm);
1128 target =
1129 (0 !=
1130 (bm & GET_MESSAGE_BIT_TRANSMIT_TO)) ? (&opt[bits++]) : NULL;
1132 spid = 0;
1133 if ((GNUNET_LOAD_get_load (cp->ppd.transmission_delay) > 3 * (1
1134 + tec.priority))
1136 GNUNET_CONSTANTS_MAX_CORK_DELAY.rel_value_us * 2
1138 {
1139 /* don't have BW to send to peer, or would likely take longer than we have for it,
1140 * so at best indirect the query */
1141 tec.priority = 0;
1143 spid = GNUNET_PEER_intern (cps->ppd.peer);
1144 GNUNET_assert (0 != spid);
1145 }
1146 tec.ttl = bound_ttl (ntohl (gm->ttl),
1147 tec.priority);
1148 /* decrement ttl (always) */
1149 ttl_decrement =
1152 if ((tec.ttl < 0) &&
1153 (((int32_t) (tec.ttl - ttl_decrement)) > 0))
1154 {
1156 "Dropping query from `%s' due to TTL underflow (%d - %u).\n",
1157 GNUNET_i2s (cps->ppd.peer),
1158 tec.ttl,
1159 ttl_decrement);
1162 ("# requests dropped due TTL underflow"), 1,
1163 GNUNET_NO);
1164 /* integer underflow => drop (should be very rare)! */
1165 return;
1166 }
1167 tec.ttl -= ttl_decrement;
1168
1169 /* test if the request already exists */
1170 tec.finished = GNUNET_NO;
1172 &gm->query,
1174 &tec);
1175 if (GNUNET_YES == tec.finished)
1176 return; /* merged into existing request, we're done */
1177
1178 peerreq = GNUNET_new (struct PeerRequest);
1179 peerreq->cp = cp;
1181 tec.type,
1182 &gm->query,
1183 target,
1184 (bfsize > 0)
1185 ? (const char *) &opt[bits]
1186 : NULL,
1187 bfsize,
1188 1 /* anonymity */,
1189 (uint32_t) tec.priority,
1190 tec.ttl,
1191 spid,
1193 NULL, 0, /* replies_seen */
1195 peerreq);
1196 GNUNET_assert (NULL != pr);
1198 peerreq->pr = pr;
1201 &prd->query,
1202 peerreq,
1205 gettext_noop (
1206 "# P2P query messages received and processed"),
1207 1,
1208 GNUNET_NO);
1210 gettext_noop ("# P2P searches active"),
1211 1,
1212 GNUNET_NO);
1216 NULL);
1217}
1218
1219
1230void
1232 int is_query,
1233 uint32_t priority,
1234 struct GNUNET_MQ_Envelope *env)
1235{
1236 struct GSF_PeerTransmitHandle *pth;
1237 struct GSF_PeerTransmitHandle *pos;
1239
1240 pth = GNUNET_new (struct GSF_PeerTransmitHandle);
1242 pth->env = env;
1243 pth->is_query = is_query;
1244 pth->priority = priority;
1245 pth->cp = cp;
1246 /* insertion sort (by priority, descending) */
1247 prev = NULL;
1248 pos = cp->pth_head;
1249 while ((NULL != pos) && (pos->priority > priority))
1250 {
1251 prev = pos;
1252 pos = pos->next;
1253 }
1255 cp->pth_tail,
1256 prev,
1257 pth);
1258 if (GNUNET_YES == is_query)
1260 else if (GNUNET_NO == is_query)
1263}
1264
1265
1273void
1275 struct GNUNET_TIME_Absolute request_time,
1276 uint32_t request_priority)
1277{
1278 struct GNUNET_TIME_Relative delay;
1279
1280 delay = GNUNET_TIME_absolute_get_duration (request_time);
1283 + delay.rel_value_us) / RUNAVG_DELAY_N;
1284 cp->ppd.avg_priority =
1285 (cp->ppd.avg_priority * (RUNAVG_DELAY_N - 1)
1286 + request_priority) / RUNAVG_DELAY_N;
1287}
1288
1289
1297void
1299 struct GSF_LocalClient *initiator_client)
1300{
1302 % CS2P_SUCCESS_LIST_SIZE] = initiator_client;
1303}
1304
1305
1313void
1315 const struct GSF_ConnectedPeer *initiator_peer)
1316{
1317 unsigned int woff;
1318
1321 cp->ppd.last_p2p_replies[woff] = initiator_peer->ppd.pid;
1322 GNUNET_PEER_change_rc (initiator_peer->ppd.pid, 1);
1324}
1325
1326
1335static int
1336flush_respect (void *cls,
1337 const struct GNUNET_PeerIdentity *key,
1338 void *value)
1339{
1340 struct GSF_ConnectedPeer *cp = value;
1341 struct GNUNET_PeerIdentity pid;
1342
1343 if (cp->ppd.respect == cp->disk_respect)
1344 return GNUNET_OK; /* unchanged */
1345 GNUNET_assert (0 != cp->ppd.pid);
1347 GNUNET_PEERSTORE_store (peerstore, "fs", &pid, "respect", &cp->ppd.respect,
1348 sizeof(cp->ppd.respect),
1351 NULL,
1352 NULL);
1353 return GNUNET_OK;
1354}
1355
1356
1357void
1359 const struct GNUNET_PeerIdentity *peer,
1360 void *internal_cls)
1361{
1362 struct GSF_ConnectedPeer *cp = internal_cls;
1363 struct GSF_PeerTransmitHandle *pth;
1364 struct GSF_DelayedHandle *dh;
1365
1366 if (NULL == cp)
1367 return; /* must have been disconnect from core with
1368 * 'peer' == my_id, ignore */
1369 flush_respect (NULL,
1370 peer,
1371 cp);
1374 peer,
1375 cp));
1377 gettext_noop ("# peers connected"),
1379 GNUNET_NO);
1380 if (NULL != cp->respect_iterate_req)
1381 {
1383 cp->respect_iterate_req = NULL;
1384 }
1387 cp);
1389 cp->request_map = NULL;
1394 memset (cp->ppd.last_p2p_replies,
1395 0,
1396 sizeof(cp->ppd.last_p2p_replies));
1398 while (NULL != (pth = cp->pth_head))
1399 {
1401 cp->pth_tail,
1402 pth);
1403 if (GNUNET_YES == pth->is_query)
1405 else if (GNUNET_NO == pth->is_query)
1407 GNUNET_free (pth);
1408 }
1409 while (NULL != (dh = cp->delayed_head))
1410 {
1413 dh);
1414 GNUNET_MQ_discard (dh->env);
1417 GNUNET_free (dh);
1418 }
1420 if (NULL != cp->mig_revive_task)
1421 {
1423 cp->mig_revive_task = NULL;
1424 }
1427 GNUNET_free (cp);
1428}
1429
1430
1435{
1440
1444 void *it_cls;
1445};
1446
1447
1456static int
1457call_iterator (void *cls,
1458 const struct GNUNET_PeerIdentity *key,
1459 void *value)
1460{
1461 struct IterationContext *ic = cls;
1462 struct GSF_ConnectedPeer *cp = value;
1463
1464 ic->it (ic->it_cls,
1465 key, cp,
1466 &cp->ppd);
1467 return GNUNET_YES;
1468}
1469
1470
1471void
1473 void *it_cls)
1474{
1475 struct IterationContext ic;
1476
1477 ic.it = it;
1478 ic.it_cls = it_cls;
1481 &ic);
1482}
1483
1484
1491void
1493 struct GNUNET_PeerIdentity *id)
1494{
1495 GNUNET_assert (0 != cp->ppd.pid);
1496 GNUNET_PEER_resolve (cp->ppd.pid, id);
1497}
1498
1499
1506const struct GNUNET_PeerIdentity *
1508{
1509 GNUNET_assert (0 != cp->ppd.pid);
1510 return GNUNET_PEER_resolve2 (cp->ppd.pid);
1511}
1512
1513
1521void
1523 struct GNUNET_TIME_Absolute block_time)
1524{
1525 struct GNUNET_MQ_Envelope *env;
1526 struct MigrationStopMessage *msm;
1527
1528 if (cp->last_migration_block.abs_value_us > block_time.abs_value_us)
1529 {
1531 "Migration already blocked for another %s\n",
1534 (cp->
1535 last_migration_block), GNUNET_YES));
1536 return; /* already blocked */
1537 }
1538 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Asking to stop migration for %s\n",
1541 GNUNET_YES));
1542 cp->last_migration_block = block_time;
1543 env = GNUNET_MQ_msg (msm,
1545 msm->reserved = htonl (0);
1546 msm->duration
1548 (cp->last_migration_block));
1550 gettext_noop ("# migration stop messages sent"),
1551 1,
1552 GNUNET_NO);
1555 UINT32_MAX,
1556 env);
1557}
1558
1559
1569void
1571 uint64_t pref)
1572{
1573 cp->inc_preference += pref;
1574}
1575
1576
1582static void
1584{
1585 fr_task = NULL;
1588 NULL);
1592 NULL);
1593}
1594
1595
1599void
1601{
1605 &cron_flush_respect, NULL);
1606}
1607
1608
1612void
1614{
1617 NULL);
1619 fr_task = NULL;
1621 cp_map = NULL;
1623}
1624
1625
1634static int
1636 const struct GNUNET_PeerIdentity *key,
1637 void *value)
1638{
1639 const struct GSF_LocalClient *lc = cls;
1640 struct GSF_ConnectedPeer *cp = value;
1641 unsigned int i;
1642
1643 for (i = 0; i < CS2P_SUCCESS_LIST_SIZE; i++)
1644 if (cp->ppd.last_client_replies[i] == lc)
1645 cp->ppd.last_client_replies[i] = NULL;
1646 return GNUNET_YES;
1647}
1648
1649
1656void
1658{
1659 if (NULL == cp_map)
1660 return; /* already cleaned up */
1663 (void *) lc);
1664}
1665
1666
1667/* end of gnunet-service-fs_cp.c */
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
#define gettext_noop(String)
Definition: gettext.h:70
static int ret
Final status code.
Definition: gnunet-arm.c:94
static void record(void *cls, size_t data_size, const void *data)
Process recorded audio data.
static char * data
The data to insert into the dht.
struct GNUNET_HashCode key
The key used in the DHT.
static struct GNUNET_TIME_Relative expiration
User supplied expiration value.
static char * value
Value of the record to add/remove.
static uint32_t type
Type string converted to DNS type value.
int GSF_enable_randomized_delays
Are we introducing randomized delays for better anonymity?
int GSF_test_get_load_too_high_(uint32_t priority)
Test if the DATABASE (GET) load on this peer is too high to even consider processing the query at all...
struct GNUNET_STATISTICS_Handle * GSF_stats
Handle for reporting statistics.
double GSF_current_priorities
Typical priorities we're seeing from other peers right now.
unsigned int GSF_cover_query_count
How many query messages have we received 'recently' that have not yet been claimed as cover traffic?
const struct GNUNET_CONFIGURATION_Handle * GSF_cfg
Our configuration.
void GSF_consider_forwarding(void *cls, struct GSF_PendingRequest *pr, enum GNUNET_BLOCK_ReplyEvaluationResult result)
Function to be called after we're done processing replies from the local lookup.
struct GNUNET_PeerIdentity GSF_my_id
Identity of this peer.
unsigned int GSF_cover_content_count
How many content messages have we received 'recently' that have not yet been claimed as cover traffic...
struct GNUNET_TIME_Relative GSF_avg_latency
Running average of the observed latency to other peers (round trip).
struct GNUNET_LOAD_Value * GSF_rt_entry_lifetime
How long do requests typically stay in the routing table?
shared data structures of gnunet-service-fs.c
#define GET_MESSAGE_BIT_TRANSMIT_TO
The peer identity of a peer that had claimed to have the content previously is included (can be used ...
#define TTL_DECREMENT
By which amount do we decrement the TTL for simple forwarding / indirection of the query; in milli-se...
#define GET_MESSAGE_BIT_RETURN_TO
The peer identity of a peer waiting for the reply is included (used if the response should be transmi...
static void handle_p2p_reply(void *cls, enum GNUNET_BLOCK_ReplyEvaluationResult eval, struct GSF_PendingRequest *pr, uint32_t reply_anonymity_level, struct GNUNET_TIME_Absolute expiration, struct GNUNET_TIME_Absolute last_transmission, enum GNUNET_BLOCK_Type type, const void *data, size_t data_len)
Handle a reply to a pending request.
void GSF_connected_peer_done_()
Shutdown peer management subsystem.
static int flush_respect(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Write peer-respect information to a file - flush the buffer entry!
#define N
void GSF_peer_disconnect_handler(void *cls, const struct GNUNET_PeerIdentity *peer, void *internal_cls)
A peer disconnected from us.
void handle_p2p_get(void *cls, const struct GetMessage *gm)
Handle P2P "QUERY" message.
static struct GNUNET_TIME_Relative get_randomized_delay()
Get the randomized delay a response should be subjected to.
static int test_exist_cb(void *cls, const struct GNUNET_HashCode *hc, void *value)
Test if the query already exists.
static void cron_flush_respect(void *cls)
Call this method periodically to flush respect information to disk.
struct GSF_PeerPerformanceData * GSF_get_peer_performance_data_(struct GSF_ConnectedPeer *cp)
Return the performance data record for the given peer.
static void free_pending_request(struct PeerRequest *peerreq)
Free resources associated with the given peer request.
static void transmit_delayed_now(void *cls)
The artificial delay is over, transmit the message now.
void GSF_update_peer_latency_(const struct GNUNET_PeerIdentity *id, struct GNUNET_TIME_Relative latency)
Update the latency information kept for the given peer.
static void revive_migration(void *cls)
It may be time to re-start migrating content to this peer.
void * GSF_peer_connect_handler(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
A peer connected to us.
static int clean_local_client(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Iterator to remove references to LC entry.
static void peer_request_destroy(void *cls)
Free the given request.
static struct GNUNET_PEERSTORE_Handle * peerstore
Handle to peerstore service.
static void peer_respect_cb(void *cls, const struct GNUNET_PEERSTORE_Record *record, const char *emsg)
Function called by PEERSTORE with peer respect record.
static void peer_transmit(struct GSF_ConnectedPeer *cp)
Core is ready to transmit to a peer, get the message.
void GSF_iterate_connected_peers_(GSF_ConnectedPeerIterator it, void *it_cls)
Iterate over all connected peers.
void GSF_connected_peer_get_identity_(const struct GSF_ConnectedPeer *cp, struct GNUNET_PeerIdentity *id)
Obtain the identity of a connected peer.
void GSF_handle_local_client_disconnect_(const struct GSF_LocalClient *lc)
Notification that a local client disconnected.
const struct GNUNET_PeerIdentity * GSF_connected_peer_get_identity2_(const struct GSF_ConnectedPeer *cp)
Obtain the identity of a connected peer.
static int consider_peer_for_forwarding(void *cls, const struct GNUNET_HashCode *key, struct GSF_PendingRequest *pr)
Function called for each pending request whenever a new peer connects, giving us a chance to decide a...
static int cancel_pending_request(void *cls, const struct GNUNET_HashCode *query, void *value)
Cancel all requests associated with the peer.
static struct GNUNET_CONTAINER_MultiPeerMap * cp_map
Map from peer identities to struct GSF_ConnectPeer entries.
struct GSF_ConnectedPeer * GSF_peer_get_(const struct GNUNET_PeerIdentity *peer)
Get a handle for a connected peer.
void GSF_connected_peer_init_()
Initialize peer management subsystem.
void GSF_peer_update_responder_peer_(struct GSF_ConnectedPeer *cp, const struct GSF_ConnectedPeer *initiator_peer)
Report on receiving a reply in response to an initiating peer.
static int call_iterator(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Function that calls the callback for each peer.
void handle_p2p_migration_stop(void *cls, const struct MigrationStopMessage *msm)
Handle P2P GNUNET_MESSAGE_TYPE_FS_MIGRATION_STOP message.
void GSF_peer_update_responder_client_(struct GSF_ConnectedPeer *cp, struct GSF_LocalClient *initiator_client)
Report on receiving a reply in response to an initiating client.
static void schedule_transmission(struct GSF_PeerTransmitHandle *pth)
If ready (bandwidth reserved), try to schedule transmission via core for the given handle.
#define RESPECT_FLUSH_FREQ
How often do we flush respect values to disk?
void GSF_peer_transmit_(struct GSF_ConnectedPeer *cp, int is_query, uint32_t priority, struct GNUNET_MQ_Envelope *env)
Transmit a message to the given peer as soon as possible.
static struct GNUNET_SCHEDULER_Task * fr_task
Task used to flush respect values to disk.
#define RUNAVG_DELAY_N
Ratio for moving average delay calculation.
static int change_peer_respect(struct GSF_ConnectedPeer *cp, int value)
Increase the peer's respect by a value.
void GSF_block_peer_migration_(struct GSF_ConnectedPeer *cp, struct GNUNET_TIME_Absolute block_time)
Ask a peer to stop migrating data to us until the given point in time.
static int32_t bound_priority(uint32_t prio_in, struct GSF_ConnectedPeer *cp)
We've received a request with the specified priority.
void GSF_peer_update_performance_(struct GSF_ConnectedPeer *cp, struct GNUNET_TIME_Absolute request_time, uint32_t request_priority)
Report on receiving a reply; update the performance record of the given peer.
void GSF_connected_peer_change_preference_(struct GSF_ConnectedPeer *cp, uint64_t pref)
Notify core about a preference we have for the given peer (to allocate more resources towards it).
static int32_t bound_ttl(int32_t ttl_in, uint32_t prio)
The priority level imposes a bound on the maximum value for the ttl that can be requested.
API to handle 'connected peers'.
void(* GSF_ConnectedPeerIterator)(void *cls, const struct GNUNET_PeerIdentity *peer, struct GSF_ConnectedPeer *cp, const struct GSF_PeerPerformanceData *ppd)
Signature of function called on a connected peer.
#define P2P_SUCCESS_LIST_SIZE
Length of the P2P success tracker.
#define CS2P_SUCCESS_LIST_SIZE
Length of the CS-2-P success tracker.
#define MAX_QUEUE_PER_PEER
Maximum number of outgoing messages we queue per peer.
void GSF_plan_notify_peer_disconnect_(const struct GSF_ConnectedPeer *cp)
Notify the plan about a peer being no longer available; destroy all entries associated with this peer...
void GSF_plan_add_(struct GSF_ConnectedPeer *cp, struct GSF_PendingRequest *pr)
Create a new query plan entry.
API to manage query plan.
int GSF_pending_request_test_target_(struct GSF_PendingRequest *pr, const struct GNUNET_PeerIdentity *target)
Is the given target a legitimate peer for forwarding the given request?
struct GSF_PendingRequest * GSF_pending_request_create_(enum GSF_PendingRequestOptions options, enum GNUNET_BLOCK_Type type, const struct GNUNET_HashCode *query, const struct GNUNET_PeerIdentity *target, const char *bf_data, size_t bf_size, uint32_t anonymity_level, uint32_t priority, int32_t ttl, GNUNET_PEER_Id sender_pid, GNUNET_PEER_Id origin_pid, const struct GNUNET_HashCode *replies_seen, unsigned int replies_seen_count, GSF_PendingRequestReplyHandler rh, void *rh_cls)
Create a new pending request.
void GSF_iterate_pending_requests_(GSF_PendingRequestIterator it, void *cls)
Iterate over all pending requests.
void GSF_local_lookup_(struct GSF_PendingRequest *pr, GSF_LocalLookupContinuation cont, void *cont_cls)
Look up the request in the local datastore.
struct GSF_PendingRequestData * GSF_pending_request_get_data_(struct GSF_PendingRequest *pr)
Obtain the public data associated with a pending request.
int GSF_pending_request_test_active_(struct GSF_PendingRequest *pr)
Check if the given request is still active.
void GSF_pending_request_cancel_(struct GSF_PendingRequest *pr, int full_cleanup)
Explicitly cancel a pending request.
API to handle pending requests.
GSF_PendingRequestOptions
Options for pending requests (bits to be ORed).
@ GSF_PRO_DEFAULTS
No special options (P2P-default).
@ GSF_PRO_FORWARD_ONLY
Request must only be forwarded (no routing)
void GSF_push_stop_(struct GSF_ConnectedPeer *peer)
A peer disconnected from us.
void GSF_push_start_(struct GSF_ConnectedPeer *peer)
A peer connected to us.
support for pushing out content
static struct GNUNET_PeerIdentity pid
Identity of the peer we transmit to / connect to.
static struct GNUNET_TRANSPORT_PluginMonitor * pm
Handle if we are monitoring plugin session activity.
Functions related to load calculations.
API to the peerstore service.
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message,...
GNUNET_BLOCK_ReplyEvaluationResult
Possible ways for how a block may relate to a query.
@ GNUNET_BLOCK_REPLY_OK_LAST
Last possible valid result.
#define GNUNET_CONSTANTS_MAX_CORK_DELAY
How long do we delay messages to get larger packet sizes (CORKing)?
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
@ GNUNET_CRYPTO_QUALITY_WEAK
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_CONTAINER_DLL_insert_after(head, tail, other, element)
Insert an element into a DLL after the given other element.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
void * GNUNET_CONTAINER_multipeermap_get(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Given a key find a value in the map matching the key.
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MultiHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash 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.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in 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.
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.
struct GNUNET_CONTAINER_MultiPeerMap * GNUNET_CONTAINER_multipeermap_create(unsigned int len, int do_not_copy_keys)
Create a multi peer map (hash map for public keys of peers).
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.
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multipeermap_remove(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, const void *value)
Remove the given key-value pair from the map.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE
Allow multiple values with the same key.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY
There must only be one value per key; storing a value should fail if a value under the same key alrea...
#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_SCHEDULER_PRIORITY_HIGH
Run with high priority (important requests).
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
@ GNUNET_SYSERR
void GNUNET_LOAD_value_set_decline(struct GNUNET_LOAD_Value *load, struct GNUNET_TIME_Relative autodecline)
Change the value by which the load automatically declines.
Definition: load.c:143
double GNUNET_LOAD_get_average(struct GNUNET_LOAD_Value *load)
Get the average value given to update so far.
Definition: load.c:216
struct GNUNET_LOAD_Value * GNUNET_LOAD_value_init(struct GNUNET_TIME_Relative autodecline)
Create a new load value.
Definition: load.c:125
void GNUNET_LOAD_update(struct GNUNET_LOAD_Value *load, uint64_t data)
Update the current load.
Definition: load.c:237
double GNUNET_LOAD_get_load(struct GNUNET_LOAD_Value *load)
Get the current load.
Definition: load.c:201
#define GNUNET_LOAD_value_free(lv)
Free a load value.
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_DEBUG
@ GNUNET_ERROR_TYPE_INFO
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
unsigned int GNUNET_MQ_get_length(struct GNUNET_MQ_Handle *mq)
Obtain the current length of the message queue.
Definition: mq.c:293
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:304
void GNUNET_MQ_discard(struct GNUNET_MQ_Envelope *mqm)
Discard the message queue message, free all allocated resources.
Definition: mq.c:285
#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
void GNUNET_PEER_decrement_rcs(const GNUNET_PEER_Id *ids, unsigned int count)
Decrement multiple RCs of peer identities by one.
Definition: peer.c:157
unsigned int GNUNET_PEER_Id
A GNUNET_PEER_Id is simply a shorter version of a "struct GNUNET_PeerIdentifier" that can be used ins...
void GNUNET_PEER_change_rc(GNUNET_PEER_Id id, int delta)
Change the reference counter of an interned PID.
Definition: peer.c:192
const struct GNUNET_PeerIdentity * GNUNET_PEER_resolve2(GNUNET_PEER_Id id)
Convert an interned PID to a normal peer identity.
Definition: peer.c:234
void GNUNET_PEER_resolve(GNUNET_PEER_Id id, struct GNUNET_PeerIdentity *pid)
Convert an interned PID to a normal peer identity.
Definition: peer.c:220
GNUNET_PEER_Id GNUNET_PEER_intern(const struct GNUNET_PeerIdentity *pid)
Intern an peer identity.
Definition: peer.c:108
struct GNUNET_PEERSTORE_IterateContext * GNUNET_PEERSTORE_iteration_start(struct GNUNET_PEERSTORE_Handle *h, const char *sub_system, const struct GNUNET_PeerIdentity *peer, const char *key, GNUNET_PEERSTORE_Processor callback, void *callback_cls)
Iterate over peerstore entries.
void GNUNET_PEERSTORE_iteration_next(struct GNUNET_PEERSTORE_IterateContext *ic, uint64_t limit)
Continue an iteration.
void GNUNET_PEERSTORE_disconnect(struct GNUNET_PEERSTORE_Handle *h)
Disconnect from the PEERSTORE service.
struct GNUNET_PEERSTORE_Handle * GNUNET_PEERSTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the PEERSTORE service.
struct GNUNET_PEERSTORE_StoreContext * GNUNET_PEERSTORE_store(struct GNUNET_PEERSTORE_Handle *h, const char *sub_system, const struct GNUNET_PeerIdentity *peer, const char *key, const void *value, size_t size, struct GNUNET_TIME_Absolute expiry, enum GNUNET_PEERSTORE_StoreOption options, GNUNET_PEERSTORE_Continuation cont, void *cont_cls)
Store a new entry in the PEERSTORE.
void GNUNET_PEERSTORE_iteration_stop(struct GNUNET_PEERSTORE_IterateContext *ic)
Cancel an iteration.
@ GNUNET_PEERSTORE_STOREOPTION_REPLACE
Delete any previous values for the given key before storing the given value.
#define GNUNET_MESSAGE_TYPE_FS_PUT
P2P response with content or active migration of content.
#define GNUNET_MESSAGE_TYPE_FS_MIGRATION_STOP
Peer asks us to stop migrating content towards it for a while.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:975
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:1299
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:1272
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed_with_priority(struct GNUNET_TIME_Relative delay, enum GNUNET_SCHEDULER_Priority priority, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1202
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_with_priority(enum GNUNET_SCHEDULER_Priority prio, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified priority.
Definition: scheduler.c:1226
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_ntoh(struct GNUNET_TIME_RelativeNBO a)
Convert relative time from network byte order.
Definition: time.c:628
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:436
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:405
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
#define GNUNET_TIME_UNIT_MILLISECONDS
One millisecond.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:111
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:316
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:484
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
struct GNUNET_TIME_RelativeNBO GNUNET_TIME_relative_hton(struct GNUNET_TIME_Relative a)
Convert relative time to network byte order.
Definition: time.c:618
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:638
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
#define _(String)
GNU gettext support macro.
Definition: platform.h:178
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.
Internal representation of the hash map.
Internal representation of the hash map.
A 512-bit hashcode.
Handle to a message queue.
Definition: mq.c:87
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
Handle to the PEERSTORE service.
Definition: peerstore_api.c:46
Context for a iterate request.
Single PEERSTORE record.
The identity of the host (wraps the signing key of the peer).
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.
A connected peer.
unsigned int last_p2p_replies_woff
Which offset in last_p2p_replies will be updated next? (we go round-robin).
struct GNUNET_TIME_Absolute last_migration_block
Time until when we blocked this peer from migrating data to us.
struct GSF_DelayedHandle * delayed_tail
Messages (replies, queries, content migration) we would like to send to this peer in the near future.
unsigned int last_client_replies_woff
Which offset in last_client_replies will be updated next? (we go round-robin).
unsigned int delay_queue_size
Number of entries in delayed_head DLL.
struct GSF_DelayedHandle * delayed_head
Messages (replies, queries, content migration) we would like to send to this peer in the near future.
struct GNUNET_PEERSTORE_IterateContext * respect_iterate_req
Handle to the PEERSTORE iterate request for peer respect value.
struct GSF_PeerTransmitHandle * pth_head
Messages (replies, queries, content migration) we would like to send to this peer in the near future.
struct GSF_PeerPerformanceData ppd
Performance data for this peer.
struct GNUNET_CONTAINER_MultiHashMap * request_map
Active requests from this neighbour, map of query to struct PeerRequest.
struct GNUNET_MQ_Handle * mq
Handle for an active request for transmission to this peer.
unsigned int last_request_times_off
Current offset into last_request_times ring buffer.
struct GNUNET_SCHEDULER_Task * rc_delay_task
Task scheduled if we need to retry bandwidth reservation later.
struct GNUNET_SCHEDULER_Task * mig_revive_task
Task scheduled to revive migration to this peer.
uint32_t disk_respect
Respect rating for this peer on disk.
struct GSF_PeerTransmitHandle * pth_tail
Messages (replies, queries, content migration) we would like to send to this peer in the near future.
uint64_t inc_preference
Increase in traffic preference still to be submitted to the core service for this peer.
Handle for an entry in our delay list.
struct GSF_DelayedHandle * next
Kept in a doubly-linked list.
struct GSF_DelayedHandle * prev
Kept in a doubly-linked list.
struct GNUNET_SCHEDULER_Task * delay_task
Task for the delay.
size_t msize
Size of the message.
struct GSF_ConnectedPeer * cp
Peer this transmission belongs to.
struct GNUNET_MQ_Envelope * env
Envelope of the message that was delayed.
A local client.
Performance data kept for a peer.
double avg_priority
Average priority of successful replies.
struct GNUNET_TIME_Relative avg_reply_delay
Average delay between sending the peer a request and getting a reply (only calculated over the reques...
unsigned int pending_replies
Number of pending replies (queries are not counted)
struct GSF_LocalClient * last_client_replies[8]
List of the last clients for which this peer successfully answered a query.
struct GNUNET_LOAD_Value * transmission_delay
How long does it typically take for us to transmit a message to this peer? (delay between the request...
struct GNUNET_TIME_Absolute migration_blocked_until
Point in time until which this peer does not want us to migrate content to it.
const struct GNUNET_PeerIdentity * peer
The peer's identity (pointer).
unsigned int pending_queries
Number of pending queries (replies are not counted)
GNUNET_PEER_Id pid
The peer's identity (interned version).
uint32_t respect
Respect rating for this peer.
struct GNUNET_TIME_Absolute last_request_times[24]
Transmission times for the last MAX_QUEUE_PER_PEER requests for this peer.
GNUNET_PEER_Id last_p2p_replies[8]
List of the last PIDs for which this peer successfully answered a query; We use 0 to indicate no succ...
Handle to cancel a transmission request.
int is_query
GNUNET_YES if this is a query, GNUNET_NO for content.
struct GSF_PeerTransmitHandle * next
Kept in a doubly-linked list.
uint32_t priority
Priority of this request.
struct GNUNET_TIME_Absolute transmission_request_start_time
Time when this transmission request was issued.
struct GSF_PeerTransmitHandle * prev
Kept in a doubly-linked list.
struct GSF_ConnectedPeer * cp
Peer this request targets.
struct GNUNET_MQ_Envelope * env
Envelope with the actual message.
Public data (in the sense of not encapsulated within 'gnunet-service-fs_pr', not in the sense of netw...
int has_started
Has this request been started yet (local/p2p operations)? Or are we still constructing it?
struct GNUNET_TIME_Absolute ttl
Current TTL for the request.
enum GNUNET_BLOCK_Type type
Type of the requested block.
struct GNUNET_HashCode query
Primary query hash for this request.
uint32_t priority
Priority that this request (still) has for us.
An active request.
Message to the datastore service asking about specific content.
Definition: datastore.h:141
uint32_t type
Desired content type.
Definition: datastore.h:150
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_DATASTORE_GET.
Definition: datastore.h:145
uint32_t priority
How important is this request (network byte order)
struct GNUNET_HashCode query
Hashcodes of the file(s) we're looking for.
int32_t ttl
Relative time to live in MILLISECONDS (network byte order)
uint32_t hash_bitmap
Which of the optional hash codes are present at the end of the message? See GET_MESSAGE_BIT_xx consta...
Closure for call_iterator().
void * it_cls
Closure for it.
GSF_ConnectedPeerIterator it
Function to call on each entry.
Message send by a peer that wants to be excluded from migration for a while.
struct GNUNET_TIME_RelativeNBO duration
How long should the block last?
uint32_t reserved
Always zero.
Information per peer and request.
struct GSF_ConnectedPeer * cp
Which specific peer issued this request?
struct GSF_PendingRequest * pr
Handle to generic request (generic: from peer or local client).
struct GNUNET_SCHEDULER_Task * kill_task
Task for asynchronous stopping of this request.
Response from FS service with a result for a previous FS search.
Definition: fs.h:330
Closure for test_exist_cb().
int finished
Set to GNUNET_YES if we are done handling the query.
int32_t ttl
Relative TTL of the incoming request.
int32_t priority
Priority of the incoming request.
enum GNUNET_BLOCK_Type type
Type of the incoming request.