GNUnet 0.25.0
 
Loading...
Searching...
No Matches
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
101
102
138
139
160
161
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 cp->respect_iterate_req = NULL;
413 return;
414 }
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 enum GNUNET_CORE_PeerClass class)
460{
461 struct GSF_ConnectedPeer *cp;
462
463 if (0 ==
465 peer))
466 return NULL;
468 "Connected to peer %s\n",
469 GNUNET_i2s (peer));
470 cp = GNUNET_new (struct GSF_ConnectedPeer);
471 cp->ppd.pid = GNUNET_PEER_intern (peer);
472 cp->ppd.peer = peer;
473 cp->mq = mq;
475
477 GNUNET_YES);
481 cp),
482 cp,
485 gettext_noop ("# peers connected"),
487 GNUNET_NO);
490 "fs",
491 peer,
492 "respect",
494 cp);
496 cp);
497 return cp;
498}
499
500
507static void
509{
510 struct GSF_ConnectedPeer *cp = cls;
511 struct GNUNET_TIME_Relative bt;
512
513 cp->mig_revive_task = NULL;
515 if (0 != bt.rel_value_us)
516 {
517 /* still time left... */
518 cp->mig_revive_task =
520 return;
521 }
522 GSF_push_start_ (cp);
523}
524
525
526struct GSF_ConnectedPeer *
528{
529 if (NULL == cp_map)
530 return NULL;
532}
533
534
541void
543 const struct MigrationStopMessage *msm)
544{
545 struct GSF_ConnectedPeer *cp = cls;
546 struct GNUNET_TIME_Relative bt;
547
549 gettext_noop ("# migration stop messages received"),
550 1, GNUNET_NO);
553 _ ("Migration of content to peer `%s' blocked for %s\n"),
554 GNUNET_i2s (cp->ppd.peer),
557 if ((NULL == cp->mig_revive_task) &&
558 (NULL == cp->respect_iterate_req))
559 {
560 GSF_push_stop_ (cp);
561 cp->mig_revive_task =
563 &revive_migration, cp);
564 }
565}
566
567
573static void
575{
576 struct GSF_ConnectedPeer *cp = peerreq->cp;
577 struct GSF_PendingRequestData *prd;
578
579 prd = GSF_pending_request_get_data_ (peerreq->pr);
580 if (NULL != peerreq->kill_task)
581 {
583 peerreq->kill_task = NULL;
584 }
586 gettext_noop ("# P2P searches active"),
587 -1,
588 GNUNET_NO);
591 &prd->query,
592 peerreq));
593 GNUNET_free (peerreq);
594}
595
596
605static int
607 const struct GNUNET_HashCode *query,
608 void *value)
609{
610 struct PeerRequest *peerreq = value;
611 struct GSF_PendingRequest *pr = peerreq->pr;
612
613 free_pending_request (peerreq);
615 GNUNET_NO);
616 return GNUNET_OK;
617}
618
619
625static void
627{
628 struct PeerRequest *peerreq = cls;
629 struct GSF_PendingRequest *pr = peerreq->pr;
630 struct GSF_PendingRequestData *prd;
631
632 peerreq->kill_task = NULL;
635 &prd->query,
636 peerreq);
637}
638
639
645static void
647{
648 struct GSF_DelayedHandle *dh = cls;
649 struct GSF_ConnectedPeer *cp = dh->cp;
650
652 cp->delayed_tail,
653 dh);
654 cp->delay_queue_size--;
656 GNUNET_NO,
657 UINT32_MAX,
658 dh->env);
659 GNUNET_free (dh);
660}
661
662
668static struct GNUNET_TIME_Relative
670{
672
673 ret =
678#if INSANE_STATISTICS
681 ("# artificial delays introduced (ms)"),
682 ret.rel_value_us / 1000LL, GNUNET_NO);
683#endif
684 return ret;
685}
686
687
706static void
709 struct GSF_PendingRequest *pr,
710 uint32_t reply_anonymity_level,
712 struct GNUNET_TIME_Absolute last_transmission,
714 const void *data,
715 size_t data_len)
716{
717 struct PeerRequest *peerreq = cls;
718 struct GSF_ConnectedPeer *cp = peerreq->cp;
719 struct GSF_PendingRequestData *prd;
720 struct GNUNET_MQ_Envelope *env;
721 struct PutMessage *pm;
722 size_t msize;
723
724 GNUNET_assert (data_len + sizeof(struct PutMessage) <
726 GNUNET_assert (peerreq->pr == pr);
728 if (NULL == data)
729 {
730 free_pending_request (peerreq);
731 return;
732 }
734 if ( (prd->type != type) &&
735 (GNUNET_BLOCK_TYPE_ANY != prd->type) )
736 {
738 "# replies dropped due to type mismatch",
739 1, GNUNET_NO);
740 return;
741 }
743 "Transmitting result for query `%s' to peer\n",
744 GNUNET_h2s (&prd->query));
746 "# replies received for other peers",
747 1,
748 GNUNET_NO);
749 msize = sizeof(struct PutMessage) + data_len;
750 if (msize >= GNUNET_MAX_MESSAGE_SIZE)
751 {
752 GNUNET_break (0);
753 return;
754 }
755 if ( (UINT32_MAX != reply_anonymity_level) &&
756 (reply_anonymity_level > 1) )
757 {
758 if (reply_anonymity_level - 1 > GSF_cover_content_count)
759 {
761 "# replies dropped due to insufficient cover traffic",
762 1, GNUNET_NO);
763 return;
764 }
765 GSF_cover_content_count -= (reply_anonymity_level - 1);
766 }
767
769 data_len,
771 pm->type = htonl (type);
773 GNUNET_memcpy (&pm[1],
774 data,
775 data_len);
776 if ((UINT32_MAX != reply_anonymity_level) &&
777 (0 != reply_anonymity_level) &&
779 {
780 struct GSF_DelayedHandle *dh;
781
782 dh = GNUNET_new (struct GSF_DelayedHandle);
783 dh->cp = cp;
784 dh->env = env;
785 dh->msize = msize;
788 dh);
790 dh->delay_task =
793 dh);
794 }
795 else
796 {
798 GNUNET_NO,
799 UINT32_MAX,
800 env);
801 }
802 if (GNUNET_BLOCK_REPLY_OK_LAST != eval)
803 return;
804 if (NULL == peerreq->kill_task)
805 {
807 "# P2P searches destroyed due to ultimate reply",
808 1,
809 GNUNET_NO);
810 peerreq->kill_task =
812 peerreq);
813 }
814}
815
816
825static int
827{
828 if (0 == value)
829 return 0;
830 GNUNET_assert (NULL != cp);
831 if (value > 0)
832 {
833 if (cp->ppd.respect + value < cp->ppd.respect)
834 {
835 value = UINT32_MAX - cp->ppd.respect;
836 cp->ppd.respect = UINT32_MAX;
837 }
838 else
839 cp->ppd.respect += value;
840 }
841 else
842 {
843 if (cp->ppd.respect < -value)
844 {
845 value = -cp->ppd.respect;
846 cp->ppd.respect = 0;
847 }
848 else
849 cp->ppd.respect += value;
850 }
851 return value;
852}
853
854
863static int32_t
864bound_priority (uint32_t prio_in,
865 struct GSF_ConnectedPeer *cp)
866{
867#define N ((double) 128.0)
868 uint32_t ret;
869 double rret;
870 int ld;
871
873 if (GNUNET_SYSERR == ld)
874 {
875#if INSANE_STATISTICS
878 ("# requests done for free (low load)"), 1,
879 GNUNET_NO);
880#endif
881 return 0; /* excess resources */
882 }
883 if (prio_in > INT32_MAX)
884 prio_in = INT32_MAX;
885 ret = -change_peer_respect (cp, -(int) prio_in);
886 if (ret > 0)
887 {
889 rret = GSF_current_priorities + N;
890 else
891 rret = ret;
893 }
894 if ((GNUNET_YES == ld) && (ret > 0))
895 {
896 /* try with charging */
898 }
899 if (GNUNET_YES == ld)
900 {
903 ("# request dropped, priority insufficient"), 1,
904 GNUNET_NO);
905 /* undo charge */
906 change_peer_respect (cp, (int) ret);
907 return -1; /* not enough resources */
908 }
909 else
910 {
913 ("# requests done for a price (normal load)"),
914 1,
915 GNUNET_NO);
916 }
917#undef N
918 return ret;
919}
920
921
931static int32_t
932bound_ttl (int32_t ttl_in,
933 uint32_t prio)
934{
935 unsigned long long allowed;
936
937 if (ttl_in <= 0)
938 return ttl_in;
939 allowed = ((unsigned long long) prio) * TTL_DECREMENT / 1000;
940 if (ttl_in > allowed)
941 {
942 if (allowed >= (1 << 30))
943 return 1 << 30;
944 return allowed;
945 }
946 return ttl_in;
947}
948
949
954{
958 int32_t priority;
959
963 int32_t ttl;
964
969
974};
975
976
987static int
988test_exist_cb (void *cls,
989 const struct GNUNET_HashCode *hc,
990 void *value)
991{
992 struct TestExistClosure *tec = cls;
993 struct PeerRequest *peerreq = value;
994 struct GSF_PendingRequest *pr;
995 struct GSF_PendingRequestData *prd;
996
997 pr = peerreq->pr;
999 if (prd->type != tec->type)
1000 return GNUNET_YES;
1001 if (prd->ttl.abs_value_us >=
1002 GNUNET_TIME_absolute_get ().abs_value_us + tec->ttl * 1000LL)
1003 {
1004 /* existing request has higher TTL, drop new one! */
1005 prd->priority += tec->priority;
1007 "Have existing request with higher TTL, dropping new request.\n");
1010 ("# requests dropped due to higher-TTL request"),
1011 1, GNUNET_NO);
1012 tec->finished = GNUNET_YES;
1013 return GNUNET_NO;
1014 }
1015 /* existing request has lower TTL, drop old one! */
1016 tec->priority += prd->priority;
1017 free_pending_request (peerreq);
1019 GNUNET_YES);
1020 return GNUNET_NO;
1021}
1022
1023
1033void
1035 const struct GetMessage *gm)
1036{
1037 struct GSF_ConnectedPeer *cps = cls;
1038 struct PeerRequest *peerreq;
1039 struct GSF_PendingRequest *pr;
1040 struct GSF_ConnectedPeer *cp;
1041 const struct GNUNET_PeerIdentity *target;
1043 uint16_t msize;
1044 unsigned int bits;
1045 const struct GNUNET_PeerIdentity *opt;
1046 uint32_t bm;
1047 size_t bfsize;
1048 uint32_t ttl_decrement;
1049 struct TestExistClosure tec;
1050 GNUNET_PEER_Id spid;
1051 const struct GSF_PendingRequestData *prd;
1052
1053 msize = ntohs (gm->header.size);
1054 tec.type = ntohl (gm->type);
1055 bm = ntohl (gm->hash_bitmap);
1056 bits = 0;
1057 while (bm > 0)
1058 {
1059 if (1 == (bm & 1))
1060 bits++;
1061 bm >>= 1;
1062 }
1063 opt = (const struct GNUNET_PeerIdentity *) &gm[1];
1064 bfsize = msize - sizeof(struct GetMessage) - bits * sizeof(struct
1068 ("# GET requests received (from other peers)"),
1069 1,
1070 GNUNET_NO);
1072 bm = ntohl (gm->hash_bitmap);
1073 bits = 0;
1074 if (0 != (bm & GET_MESSAGE_BIT_RETURN_TO))
1075 cp = GSF_peer_get_ (&opt[bits++]);
1076 else
1077 cp = cps;
1078 if (NULL == cp)
1079 {
1080 if (0 != (bm & GET_MESSAGE_BIT_RETURN_TO))
1082 "Failed to find RETURN-TO peer `%s' in connection set. Dropping query.\n",
1083 GNUNET_i2s (&opt[bits - 1]));
1084
1085 else
1087 "Failed to find peer `%s' in connection set. Dropping query.\n",
1088 GNUNET_i2s (cps->ppd.peer));
1091 (
1092 "# requests dropped due to missing reverse route"),
1093 1,
1094 GNUNET_NO);
1095 return;
1096 }
1097 unsigned int queue_size = GNUNET_MQ_get_length (cp->mq);
1098 queue_size += cp->ppd.pending_replies + cp->delay_queue_size;
1099 if (queue_size > MAX_QUEUE_PER_PEER)
1100 {
1102 "Peer `%s' has too many replies queued already. Dropping query.\n",
1103 GNUNET_i2s (cps->ppd.peer));
1105 gettext_noop (
1106 "# requests dropped due to full reply queue"),
1107 1,
1108 GNUNET_NO);
1109 return;
1110 }
1111 /* note that we can really only check load here since otherwise
1112 * peers could find out that we are overloaded by not being
1113 * disconnected after sending us a malformed query... */
1114 tec.priority = bound_priority (ntohl (gm->priority),
1115 cps);
1116 if (tec.priority < 0)
1117 {
1119 "Dropping query from `%s', this peer is too busy.\n",
1120 GNUNET_i2s (cps->ppd.peer));
1121 return;
1122 }
1124 "Received request for `%s' of type %u from peer `%s' with flags %u\n",
1125 GNUNET_h2s (&gm->query),
1126 (unsigned int) tec.type,
1127 GNUNET_i2s (cps->ppd.peer),
1128 (unsigned int) bm);
1129 target =
1130 (0 !=
1131 (bm & GET_MESSAGE_BIT_TRANSMIT_TO)) ? (&opt[bits++]) : NULL;
1133 spid = 0;
1134 if ((GNUNET_LOAD_get_load (cp->ppd.transmission_delay) > 3 * (1
1135 + tec.priority))
1137 GNUNET_CONSTANTS_MAX_CORK_DELAY.rel_value_us * 2
1139 {
1140 /* don't have BW to send to peer, or would likely take longer than we have for it,
1141 * so at best indirect the query */
1142 tec.priority = 0;
1144 spid = GNUNET_PEER_intern (cps->ppd.peer);
1145 GNUNET_assert (0 != spid);
1146 }
1147 tec.ttl = bound_ttl (ntohl (gm->ttl),
1148 tec.priority);
1149 /* decrement ttl (always) */
1150 ttl_decrement =
1153 if ((tec.ttl < 0) &&
1154 (((int32_t) (tec.ttl - ttl_decrement)) > 0))
1155 {
1157 "Dropping query from `%s' due to TTL underflow (%d - %u).\n",
1158 GNUNET_i2s (cps->ppd.peer),
1159 tec.ttl,
1160 ttl_decrement);
1163 ("# requests dropped due TTL underflow"), 1,
1164 GNUNET_NO);
1165 /* integer underflow => drop (should be very rare)! */
1166 return;
1167 }
1168 tec.ttl -= ttl_decrement;
1169
1170 /* test if the request already exists */
1171 tec.finished = GNUNET_NO;
1173 &gm->query,
1175 &tec);
1176 if (GNUNET_YES == tec.finished)
1177 return; /* merged into existing request, we're done */
1178
1179 peerreq = GNUNET_new (struct PeerRequest);
1180 peerreq->cp = cp;
1182 tec.type,
1183 &gm->query,
1184 target,
1185 (bfsize > 0)
1186 ? (const char *) &opt[bits]
1187 : NULL,
1188 bfsize,
1189 1 /* anonymity */,
1190 (uint32_t) tec.priority,
1191 tec.ttl,
1192 spid,
1194 NULL, 0, /* replies_seen */
1196 peerreq);
1197 GNUNET_assert (NULL != pr);
1199 peerreq->pr = pr;
1202 &prd->query,
1203 peerreq,
1206 gettext_noop (
1207 "# P2P query messages received and processed"),
1208 1,
1209 GNUNET_NO);
1211 gettext_noop ("# P2P searches active"),
1212 1,
1213 GNUNET_NO);
1217 NULL);
1218}
1219
1220
1231void
1233 int is_query,
1234 uint32_t priority,
1235 struct GNUNET_MQ_Envelope *env)
1236{
1237 struct GSF_PeerTransmitHandle *pth;
1238 struct GSF_PeerTransmitHandle *pos;
1240
1241 pth = GNUNET_new (struct GSF_PeerTransmitHandle);
1243 pth->env = env;
1244 pth->is_query = is_query;
1245 pth->priority = priority;
1246 pth->cp = cp;
1247 /* insertion sort (by priority, descending) */
1248 prev = NULL;
1249 pos = cp->pth_head;
1250 while ((NULL != pos) && (pos->priority > priority))
1251 {
1252 prev = pos;
1253 pos = pos->next;
1254 }
1256 cp->pth_tail,
1257 prev,
1258 pth);
1259 if (GNUNET_YES == is_query)
1261 else if (GNUNET_NO == is_query)
1264}
1265
1266
1274void
1276 struct GNUNET_TIME_Absolute request_time,
1277 uint32_t request_priority)
1278{
1279 struct GNUNET_TIME_Relative delay;
1280
1281 delay = GNUNET_TIME_absolute_get_duration (request_time);
1284 + delay.rel_value_us) / RUNAVG_DELAY_N;
1285 cp->ppd.avg_priority =
1286 (cp->ppd.avg_priority * (RUNAVG_DELAY_N - 1)
1287 + request_priority) / RUNAVG_DELAY_N;
1288}
1289
1290
1298void
1300 struct GSF_LocalClient *initiator_client)
1301{
1303 % CS2P_SUCCESS_LIST_SIZE] = initiator_client;
1304}
1305
1306
1314void
1316 const struct GSF_ConnectedPeer *initiator_peer)
1317{
1318 unsigned int woff;
1319
1322 cp->ppd.last_p2p_replies[woff] = initiator_peer->ppd.pid;
1323 GNUNET_PEER_change_rc (initiator_peer->ppd.pid, 1);
1325}
1326
1327
1336static int
1337flush_respect (void *cls,
1338 const struct GNUNET_PeerIdentity *key,
1339 void *value)
1340{
1341 struct GSF_ConnectedPeer *cp = value;
1342 struct GNUNET_PeerIdentity pid;
1343
1344 if (cp->ppd.respect == cp->disk_respect)
1345 return GNUNET_OK; /* unchanged */
1346 GNUNET_assert (0 != cp->ppd.pid);
1348 GNUNET_PEERSTORE_store (peerstore, "fs", &pid, "respect", &cp->ppd.respect,
1349 sizeof(cp->ppd.respect),
1352 NULL,
1353 NULL);
1354 return GNUNET_OK;
1355}
1356
1357
1358void
1360 const struct GNUNET_PeerIdentity *peer,
1361 void *internal_cls)
1362{
1363 struct GSF_ConnectedPeer *cp = internal_cls;
1364 struct GSF_PeerTransmitHandle *pth;
1365 struct GSF_DelayedHandle *dh;
1366
1367 if (NULL == cp)
1368 return; /* must have been disconnect from core with
1369 * 'peer' == my_id, ignore */
1370 flush_respect (NULL,
1371 peer,
1372 cp);
1375 peer,
1376 cp));
1378 gettext_noop ("# peers connected"),
1380 GNUNET_NO);
1381 if (NULL != cp->respect_iterate_req)
1382 {
1384 cp->respect_iterate_req = NULL;
1385 }
1388 cp);
1390 cp->request_map = NULL;
1395 memset (cp->ppd.last_p2p_replies,
1396 0,
1397 sizeof(cp->ppd.last_p2p_replies));
1399 while (NULL != (pth = cp->pth_head))
1400 {
1402 cp->pth_tail,
1403 pth);
1404 if (GNUNET_YES == pth->is_query)
1406 else if (GNUNET_NO == pth->is_query)
1408 GNUNET_free (pth);
1409 }
1410 while (NULL != (dh = cp->delayed_head))
1411 {
1414 dh);
1415 GNUNET_MQ_discard (dh->env);
1418 GNUNET_free (dh);
1419 }
1421 if (NULL != cp->mig_revive_task)
1422 {
1424 cp->mig_revive_task = NULL;
1425 }
1428 GNUNET_free (cp);
1429}
1430
1431
1447
1448
1457static int
1458call_iterator (void *cls,
1459 const struct GNUNET_PeerIdentity *key,
1460 void *value)
1461{
1462 struct IterationContext *ic = cls;
1463 struct GSF_ConnectedPeer *cp = value;
1464
1465 ic->it (ic->it_cls,
1466 key, cp,
1467 &cp->ppd);
1468 return GNUNET_YES;
1469}
1470
1471
1472void
1474 void *it_cls)
1475{
1476 struct IterationContext ic;
1477
1478 ic.it = it;
1479 ic.it_cls = it_cls;
1482 &ic);
1483}
1484
1485
1492void
1494 struct GNUNET_PeerIdentity *id)
1495{
1496 GNUNET_assert (0 != cp->ppd.pid);
1497 GNUNET_PEER_resolve (cp->ppd.pid, id);
1498}
1499
1500
1507const struct GNUNET_PeerIdentity *
1509{
1510 GNUNET_assert (0 != cp->ppd.pid);
1511 return GNUNET_PEER_resolve2 (cp->ppd.pid);
1512}
1513
1514
1522void
1524 struct GNUNET_TIME_Absolute block_time)
1525{
1526 struct GNUNET_MQ_Envelope *env;
1527 struct MigrationStopMessage *msm;
1528
1529 if (cp->last_migration_block.abs_value_us > block_time.abs_value_us)
1530 {
1532 "Migration already blocked for another %s\n",
1535 (cp->
1536 last_migration_block), GNUNET_YES));
1537 return; /* already blocked */
1538 }
1539 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Asking to stop migration for %s\n",
1542 GNUNET_YES));
1543 cp->last_migration_block = block_time;
1544 env = GNUNET_MQ_msg (msm,
1546 msm->reserved = htonl (0);
1547 msm->duration
1549 (cp->last_migration_block));
1551 gettext_noop ("# migration stop messages sent"),
1552 1,
1553 GNUNET_NO);
1556 UINT32_MAX,
1557 env);
1558}
1559
1560
1570void
1572 uint64_t pref)
1573{
1574 cp->inc_preference += pref;
1575}
1576
1577
1583static void
1595
1596
1600void
1608
1609
1613void
1625
1626
1635static int
1637 const struct GNUNET_PeerIdentity *key,
1638 void *value)
1639{
1640 const struct GSF_LocalClient *lc = cls;
1641 struct GSF_ConnectedPeer *cp = value;
1642 unsigned int i;
1643
1644 for (i = 0; i < CS2P_SUCCESS_LIST_SIZE; i++)
1645 if (cp->ppd.last_client_replies[i] == lc)
1646 cp->ppd.last_client_replies[i] = NULL;
1647 return GNUNET_YES;
1648}
1649
1650
1657void
1659{
1660 if (NULL == cp_map)
1661 return; /* already cleaned up */
1664 (void *) lc);
1665}
1666
1667
1668/* end of gnunet-service-fs_cp.c */
struct GNUNET_GETOPT_CommandLineOption options[]
Definition 002.c:5
struct GNUNET_MQ_Envelope * env
Definition 005.c:1
#define gettext_noop(String)
Definition gettext.h:74
static int ret
Final status code.
Definition gnunet-arm.c:93
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.
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_connect_handler(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq, enum GNUNET_CORE_PeerClass class)
A peer connected to us.
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.
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.
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)?
GNUNET_CORE_PeerClass
The peer class gives a hint about the capabilities of a peer.
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.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
@ 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:142
double GNUNET_LOAD_get_average(struct GNUNET_LOAD_Value *load)
Get the average value given to update so far.
Definition load.c:215
struct GNUNET_LOAD_Value * GNUNET_LOAD_value_init(struct GNUNET_TIME_Relative autodecline)
Create a new load value.
Definition load.c:124
void GNUNET_LOAD_update(struct GNUNET_LOAD_Value *load, uint64_t data)
Update the current load.
Definition load.c:236
double GNUNET_LOAD_get_load(struct GNUNET_LOAD_Value *load)
Get the current load.
Definition load.c:200
#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:305
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.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
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:980
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:1304
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:1277
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:1207
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:1231
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:630
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:438
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:406
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:599
#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:486
#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:620
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_UNIT_FOREVER_ABS
Constant used to specify "forever".
#define _(String)
GNU gettext support macro.
Definition platform.h:179
static struct GNUNET_MQ_Handle * mq
Our connection to the resolver service, created on-demand, but then persists until error or shutdown.
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
Handle to the PEERSTORE service.
Context for a iterate request.
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.
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.