GNUnet  0.19.4
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"
29 #include "gnunet-service-fs_cp.h"
30 #include "gnunet-service-fs_pe.h"
31 #include "gnunet-service-fs_pr.h"
32 #include "gnunet-service-fs_push.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 
94  int is_query;
95 
100 
104  uint32_t priority;
105 };
106 
107 
112 {
117 
122 
127 
132 
137 
141  size_t msize;
142 };
143 
144 
149 {
154 
159 
164 };
165 
166 
171 {
176 
182 
187 
193 
199 
205 
211 
216 
221 
226 
232 
237  uint64_t inc_preference;
238 
242  unsigned int delay_queue_size;
243 
247  uint32_t disk_respect;
248 
253  unsigned int last_p2p_replies_woff;
254 
260 
265 
271 
276 };
277 
278 
283 
288 
293 
294 
301 void
303  struct GNUNET_TIME_Relative latency)
304 {
305  struct GSF_ConnectedPeer *cp;
306 
307  cp = GSF_peer_get_ (id);
308  if (NULL == cp)
309  return; /* we're not yet connected at the core level, ignore */
311  latency);
312 }
313 
314 
323 {
324  return &cp->ppd;
325 }
326 
327 
333 static void
334 peer_transmit (struct GSF_ConnectedPeer *cp);
335 
336 
347 static void
348 ats_reserve_callback (void *cls,
349  const struct GNUNET_PeerIdentity *peer,
350  int32_t amount,
351  struct GNUNET_TIME_Relative res_delay);
352 
353 
360 static void
362 {
363  struct GSF_ConnectedPeer *cp;
364  struct GNUNET_PeerIdentity target;
365 
366  cp = pth->cp;
367  GNUNET_assert (0 != cp->ppd.pid);
368  GNUNET_PEER_resolve (cp->ppd.pid, &target);
369 
370  if (0 != cp->inc_preference)
371  {
373  &target,
375  (double) cp->inc_preference,
377  cp->inc_preference = 0;
378  }
379 
380  if ((GNUNET_YES == pth->is_query) &&
381  (GNUNET_YES != pth->was_reserved))
382  {
383  /* query, need reservation */
384  if (GNUNET_YES != cp->did_reserve)
385  return; /* not ready */
386  cp->did_reserve = GNUNET_NO;
387  /* reservation already done! */
388  pth->was_reserved = GNUNET_YES;
390  &target,
391  DBLOCK_SIZE,
393  cp);
394  return;
395  }
396  peer_transmit (cp);
397 }
398 
399 
405 static void
407 {
408  struct GSF_PeerTransmitHandle *pth = cp->pth_head;
409  struct GSF_PeerTransmitHandle *pos;
410 
411  if (NULL == pth)
412  return;
414  cp->pth_tail,
415  pth);
416  if (GNUNET_YES == pth->is_query)
417  {
419  % MAX_QUEUE_PER_PEER] =
422  }
423  else if (GNUNET_NO == pth->is_query)
424  {
426  }
430  GNUNET_MQ_send (cp->mq,
431  pth->env);
432  GNUNET_free (pth);
433  if (NULL != (pos = cp->pth_head))
434  {
435  GNUNET_assert (pos != pth);
436  schedule_transmission (pos);
437  }
438 }
439 
440 
446 static void
447 retry_reservation (void *cls)
448 {
449  struct GSF_ConnectedPeer *cp = cls;
450  struct GNUNET_PeerIdentity target;
451 
452  GNUNET_PEER_resolve (cp->ppd.pid, &target);
453  cp->rc_delay_task = NULL;
454  cp->rc =
456  &target,
457  DBLOCK_SIZE,
458  &ats_reserve_callback, cp);
459 }
460 
461 
472 static void
474  const struct GNUNET_PeerIdentity *peer,
475  int32_t amount,
476  struct GNUNET_TIME_Relative res_delay)
477 {
478  struct GSF_ConnectedPeer *cp = cls;
479  struct GSF_PeerTransmitHandle *pth;
480 
482  "Reserved %d bytes / need to wait %s for reservation\n",
483  (int) amount,
485  cp->rc = NULL;
486  if (0 == amount)
487  {
488  cp->rc_delay_task =
489  GNUNET_SCHEDULER_add_delayed (res_delay,
491  cp);
492  return;
493  }
495  pth = cp->pth_head;
496  if (NULL != pth)
497  {
498  /* reservation success, try transmission now! */
499  peer_transmit (cp);
500  }
501 }
502 
503 
511 static void
512 peer_respect_cb (void *cls,
513  const struct GNUNET_PEERSTORE_Record *record,
514  const char *emsg)
515 {
516  struct GSF_ConnectedPeer *cp = cls;
517 
518  GNUNET_assert (NULL != cp->respect_iterate_req);
519  if ((NULL != record) &&
520  (sizeof(cp->disk_respect) == record->value_size))
521  {
522  cp->disk_respect = *((uint32_t *) record->value);
523  cp->ppd.respect += *((uint32_t *) record->value);
524  }
525  GSF_push_start_ (cp);
526  if (NULL != record)
528  cp->respect_iterate_req = NULL;
529 }
530 
531 
542 static int
544  const struct GNUNET_HashCode *key,
545  struct GSF_PendingRequest *pr)
546 {
547  struct GSF_ConnectedPeer *cp = cls;
548  struct GNUNET_PeerIdentity pid;
549 
550  if (GNUNET_YES !=
552  return GNUNET_YES; /* request is not actually active, skip! */
554  if (GNUNET_YES !=
556  {
558  gettext_noop ("# Loopback routes suppressed"),
559  1,
560  GNUNET_NO);
561  return GNUNET_YES;
562  }
563  GSF_plan_add_ (cp, pr);
564  return GNUNET_YES;
565 }
566 
567 
568 void *
570  const struct GNUNET_PeerIdentity *peer,
571  struct GNUNET_MQ_Handle *mq)
572 {
573  struct GSF_ConnectedPeer *cp;
574 
575  if (0 ==
577  peer))
578  return NULL;
580  "Connected to peer %s\n",
581  GNUNET_i2s (peer));
582  cp = GNUNET_new (struct GSF_ConnectedPeer);
583  cp->ppd.pid = GNUNET_PEER_intern (peer);
584  cp->ppd.peer = peer;
585  cp->mq = mq;
587  cp->rc =
589  peer,
590  DBLOCK_SIZE,
591  &ats_reserve_callback, cp);
593  GNUNET_YES);
597  cp),
598  cp,
601  gettext_noop ("# peers connected"),
603  GNUNET_NO);
606  "fs",
607  peer,
608  "respect",
610  cp);
612  cp);
613  return cp;
614 }
615 
616 
623 static void
624 revive_migration (void *cls)
625 {
626  struct GSF_ConnectedPeer *cp = cls;
627  struct GNUNET_TIME_Relative bt;
628 
629  cp->mig_revive_task = NULL;
631  if (0 != bt.rel_value_us)
632  {
633  /* still time left... */
634  cp->mig_revive_task =
636  return;
637  }
638  GSF_push_start_ (cp);
639 }
640 
641 
642 struct GSF_ConnectedPeer *
644 {
645  if (NULL == cp_map)
646  return NULL;
648 }
649 
650 
657 void
659  const struct MigrationStopMessage *msm)
660 {
661  struct GSF_ConnectedPeer *cp = cls;
662  struct GNUNET_TIME_Relative bt;
663 
665  gettext_noop ("# migration stop messages received"),
666  1, GNUNET_NO);
669  _ ("Migration of content to peer `%s' blocked for %s\n"),
670  GNUNET_i2s (cp->ppd.peer),
673  if ((NULL == cp->mig_revive_task) &&
674  (NULL == cp->respect_iterate_req))
675  {
676  GSF_push_stop_ (cp);
677  cp->mig_revive_task =
679  &revive_migration, cp);
680  }
681 }
682 
683 
689 static void
691 {
692  struct GSF_ConnectedPeer *cp = peerreq->cp;
693  struct GSF_PendingRequestData *prd;
694 
695  prd = GSF_pending_request_get_data_ (peerreq->pr);
696  if (NULL != peerreq->kill_task)
697  {
699  peerreq->kill_task = NULL;
700  }
702  gettext_noop ("# P2P searches active"),
703  -1,
704  GNUNET_NO);
707  &prd->query,
708  peerreq));
709  GNUNET_free (peerreq);
710 }
711 
712 
721 static int
723  const struct GNUNET_HashCode *query,
724  void *value)
725 {
726  struct PeerRequest *peerreq = value;
727  struct GSF_PendingRequest *pr = peerreq->pr;
728 
729  free_pending_request (peerreq);
731  GNUNET_NO);
732  return GNUNET_OK;
733 }
734 
735 
741 static void
743 {
744  struct PeerRequest *peerreq = cls;
745  struct GSF_PendingRequest *pr = peerreq->pr;
746  struct GSF_PendingRequestData *prd;
747 
748  peerreq->kill_task = NULL;
751  &prd->query,
752  peerreq);
753 }
754 
755 
761 static void
763 {
764  struct GSF_DelayedHandle *dh = cls;
765  struct GSF_ConnectedPeer *cp = dh->cp;
766 
768  cp->delayed_tail,
769  dh);
770  cp->delay_queue_size--;
771  GSF_peer_transmit_ (cp,
772  GNUNET_NO,
773  UINT32_MAX,
774  dh->env);
775  GNUNET_free (dh);
776 }
777 
778 
784 static struct GNUNET_TIME_Relative
786 {
787  struct GNUNET_TIME_Relative ret;
788 
789  ret =
793  2 * GSF_avg_latency.rel_value_us + 1));
794 #if INSANE_STATISTICS
797  ("# artificial delays introduced (ms)"),
798  ret.rel_value_us / 1000LL, GNUNET_NO);
799 #endif
800  return ret;
801 }
802 
803 
822 static void
823 handle_p2p_reply (void *cls,
825  struct GSF_PendingRequest *pr,
826  uint32_t reply_anonymity_level,
829  enum GNUNET_BLOCK_Type type,
830  const void *data,
831  size_t data_len)
832 {
833  struct PeerRequest *peerreq = cls;
834  struct GSF_ConnectedPeer *cp = peerreq->cp;
835  struct GSF_PendingRequestData *prd;
836  struct GNUNET_MQ_Envelope *env;
837  struct PutMessage *pm;
838  size_t msize;
839 
840  GNUNET_assert (data_len + sizeof(struct PutMessage) <
842  GNUNET_assert (peerreq->pr == pr);
844  if (NULL == data)
845  {
846  free_pending_request (peerreq);
847  return;
848  }
850  if ( (prd->type != type) &&
851  (GNUNET_BLOCK_TYPE_ANY != prd->type) )
852  {
854  "# replies dropped due to type mismatch",
855  1, GNUNET_NO);
856  return;
857  }
859  "Transmitting result for query `%s' to peer\n",
860  GNUNET_h2s (&prd->query));
862  "# replies received for other peers",
863  1,
864  GNUNET_NO);
865  msize = sizeof(struct PutMessage) + data_len;
866  if (msize >= GNUNET_MAX_MESSAGE_SIZE)
867  {
868  GNUNET_break (0);
869  return;
870  }
871  if ( (UINT32_MAX != reply_anonymity_level) &&
872  (reply_anonymity_level > 1) )
873  {
874  if (reply_anonymity_level - 1 > GSF_cover_content_count)
875  {
877  "# replies dropped due to insufficient cover traffic",
878  1, GNUNET_NO);
879  return;
880  }
881  GSF_cover_content_count -= (reply_anonymity_level - 1);
882  }
883 
885  data_len,
887  pm->type = htonl (type);
888  pm->expiration = GNUNET_TIME_absolute_hton (expiration);
889  GNUNET_memcpy (&pm[1],
890  data,
891  data_len);
892  if ((UINT32_MAX != reply_anonymity_level) &&
893  (0 != reply_anonymity_level) &&
895  {
896  struct GSF_DelayedHandle *dh;
897 
898  dh = GNUNET_new (struct GSF_DelayedHandle);
899  dh->cp = cp;
900  dh->env = env;
901  dh->msize = msize;
903  cp->delayed_tail,
904  dh);
905  cp->delay_queue_size++;
906  dh->delay_task =
909  dh);
910  }
911  else
912  {
914  GNUNET_NO,
915  UINT32_MAX,
916  env);
917  }
918  if (GNUNET_BLOCK_REPLY_OK_LAST != eval)
919  return;
920  if (NULL == peerreq->kill_task)
921  {
923  "# P2P searches destroyed due to ultimate reply",
924  1,
925  GNUNET_NO);
926  peerreq->kill_task =
928  peerreq);
929  }
930 }
931 
932 
941 static int
943 {
944  if (0 == value)
945  return 0;
946  GNUNET_assert (NULL != cp);
947  if (value > 0)
948  {
949  if (cp->ppd.respect + value < cp->ppd.respect)
950  {
951  value = UINT32_MAX - cp->ppd.respect;
952  cp->ppd.respect = UINT32_MAX;
953  }
954  else
955  cp->ppd.respect += value;
956  }
957  else
958  {
959  if (cp->ppd.respect < -value)
960  {
961  value = -cp->ppd.respect;
962  cp->ppd.respect = 0;
963  }
964  else
965  cp->ppd.respect += value;
966  }
967  return value;
968 }
969 
970 
979 static int32_t
980 bound_priority (uint32_t prio_in,
981  struct GSF_ConnectedPeer *cp)
982 {
983 #define N ((double) 128.0)
984  uint32_t ret;
985  double rret;
986  int ld;
987 
989  if (GNUNET_SYSERR == ld)
990  {
991 #if INSANE_STATISTICS
994  ("# requests done for free (low load)"), 1,
995  GNUNET_NO);
996 #endif
997  return 0; /* excess resources */
998  }
999  if (prio_in > INT32_MAX)
1000  prio_in = INT32_MAX;
1001  ret = -change_peer_respect (cp, -(int) prio_in);
1002  if (ret > 0)
1003  {
1004  if (ret > GSF_current_priorities + N)
1005  rret = GSF_current_priorities + N;
1006  else
1007  rret = ret;
1008  GSF_current_priorities = (GSF_current_priorities * (N - 1) + rret) / N;
1009  }
1010  if ((GNUNET_YES == ld) && (ret > 0))
1011  {
1012  /* try with charging */
1014  }
1015  if (GNUNET_YES == ld)
1016  {
1018  gettext_noop
1019  ("# request dropped, priority insufficient"), 1,
1020  GNUNET_NO);
1021  /* undo charge */
1022  change_peer_respect (cp, (int) ret);
1023  return -1; /* not enough resources */
1024  }
1025  else
1026  {
1028  gettext_noop
1029  ("# requests done for a price (normal load)"),
1030  1,
1031  GNUNET_NO);
1032  }
1033 #undef N
1034  return ret;
1035 }
1036 
1037 
1047 static int32_t
1048 bound_ttl (int32_t ttl_in,
1049  uint32_t prio)
1050 {
1051  unsigned long long allowed;
1052 
1053  if (ttl_in <= 0)
1054  return ttl_in;
1055  allowed = ((unsigned long long) prio) * TTL_DECREMENT / 1000;
1056  if (ttl_in > allowed)
1057  {
1058  if (allowed >= (1 << 30))
1059  return 1 << 30;
1060  return allowed;
1061  }
1062  return ttl_in;
1063 }
1064 
1065 
1070 {
1074  int32_t priority;
1075 
1079  int32_t ttl;
1080 
1084  enum GNUNET_BLOCK_Type type;
1085 
1090 };
1091 
1092 
1103 static int
1104 test_exist_cb (void *cls,
1105  const struct GNUNET_HashCode *hc,
1106  void *value)
1107 {
1108  struct TestExistClosure *tec = cls;
1109  struct PeerRequest *peerreq = value;
1110  struct GSF_PendingRequest *pr;
1111  struct GSF_PendingRequestData *prd;
1112 
1113  pr = peerreq->pr;
1114  prd = GSF_pending_request_get_data_ (pr);
1115  if (prd->type != tec->type)
1116  return GNUNET_YES;
1117  if (prd->ttl.abs_value_us >=
1118  GNUNET_TIME_absolute_get ().abs_value_us + tec->ttl * 1000LL)
1119  {
1120  /* existing request has higher TTL, drop new one! */
1121  prd->priority += tec->priority;
1123  "Have existing request with higher TTL, dropping new request.\n");
1125  gettext_noop
1126  ("# requests dropped due to higher-TTL request"),
1127  1, GNUNET_NO);
1128  tec->finished = GNUNET_YES;
1129  return GNUNET_NO;
1130  }
1131  /* existing request has lower TTL, drop old one! */
1132  tec->priority += prd->priority;
1133  free_pending_request (peerreq);
1135  GNUNET_YES);
1136  return GNUNET_NO;
1137 }
1138 
1139 
1149 void
1150 handle_p2p_get (void *cls,
1151  const struct GetMessage *gm)
1152 {
1153  struct GSF_ConnectedPeer *cps = cls;
1154  struct PeerRequest *peerreq;
1155  struct GSF_PendingRequest *pr;
1156  struct GSF_ConnectedPeer *cp;
1157  const struct GNUNET_PeerIdentity *target;
1159  uint16_t msize;
1160  unsigned int bits;
1161  const struct GNUNET_PeerIdentity *opt;
1162  uint32_t bm;
1163  size_t bfsize;
1164  uint32_t ttl_decrement;
1165  struct TestExistClosure tec;
1166  GNUNET_PEER_Id spid;
1167  const struct GSF_PendingRequestData *prd;
1168 
1169  msize = ntohs (gm->header.size);
1170  tec.type = ntohl (gm->type);
1171  bm = ntohl (gm->hash_bitmap);
1172  bits = 0;
1173  while (bm > 0)
1174  {
1175  if (1 == (bm & 1))
1176  bits++;
1177  bm >>= 1;
1178  }
1179  opt = (const struct GNUNET_PeerIdentity *) &gm[1];
1180  bfsize = msize - sizeof(struct GetMessage) - bits * sizeof(struct
1183  gettext_noop
1184  ("# GET requests received (from other peers)"),
1185  1,
1186  GNUNET_NO);
1188  bm = ntohl (gm->hash_bitmap);
1189  bits = 0;
1190  if (0 != (bm & GET_MESSAGE_BIT_RETURN_TO))
1191  cp = GSF_peer_get_ (&opt[bits++]);
1192  else
1193  cp = cps;
1194  if (NULL == cp)
1195  {
1196  if (0 != (bm & GET_MESSAGE_BIT_RETURN_TO))
1198  "Failed to find RETURN-TO peer `%s' in connection set. Dropping query.\n",
1199  GNUNET_i2s (&opt[bits - 1]));
1200 
1201  else
1203  "Failed to find peer `%s' in connection set. Dropping query.\n",
1204  GNUNET_i2s (cps->ppd.peer));
1206  gettext_noop
1207  (
1208  "# requests dropped due to missing reverse route"),
1209  1,
1210  GNUNET_NO);
1211  return;
1212  }
1213  unsigned int queue_size = GNUNET_MQ_get_length (cp->mq);
1214  queue_size += cp->ppd.pending_replies + cp->delay_queue_size;
1215  if (queue_size > MAX_QUEUE_PER_PEER)
1216  {
1218  "Peer `%s' has too many replies queued already. Dropping query.\n",
1219  GNUNET_i2s (cps->ppd.peer));
1221  gettext_noop (
1222  "# requests dropped due to full reply queue"),
1223  1,
1224  GNUNET_NO);
1225  return;
1226  }
1227  /* note that we can really only check load here since otherwise
1228  * peers could find out that we are overloaded by not being
1229  * disconnected after sending us a malformed query... */
1230  tec.priority = bound_priority (ntohl (gm->priority),
1231  cps);
1232  if (tec.priority < 0)
1233  {
1235  "Dropping query from `%s', this peer is too busy.\n",
1236  GNUNET_i2s (cps->ppd.peer));
1237  return;
1238  }
1240  "Received request for `%s' of type %u from peer `%s' with flags %u\n",
1241  GNUNET_h2s (&gm->query),
1242  (unsigned int) tec.type,
1243  GNUNET_i2s (cps->ppd.peer),
1244  (unsigned int) bm);
1245  target =
1246  (0 !=
1247  (bm & GET_MESSAGE_BIT_TRANSMIT_TO)) ? (&opt[bits++]) : NULL;
1249  spid = 0;
1250  if ((GNUNET_LOAD_get_load (cp->ppd.transmission_delay) > 3 * (1
1251  + tec.priority))
1253  GNUNET_CONSTANTS_MAX_CORK_DELAY.rel_value_us * 2
1255  {
1256  /* don't have BW to send to peer, or would likely take longer than we have for it,
1257  * so at best indirect the query */
1258  tec.priority = 0;
1260  spid = GNUNET_PEER_intern (cps->ppd.peer);
1261  GNUNET_assert (0 != spid);
1262  }
1263  tec.ttl = bound_ttl (ntohl (gm->ttl),
1264  tec.priority);
1265  /* decrement ttl (always) */
1266  ttl_decrement =
1268  TTL_DECREMENT);
1269  if ((tec.ttl < 0) &&
1270  (((int32_t) (tec.ttl - ttl_decrement)) > 0))
1271  {
1273  "Dropping query from `%s' due to TTL underflow (%d - %u).\n",
1274  GNUNET_i2s (cps->ppd.peer),
1275  tec.ttl,
1276  ttl_decrement);
1278  gettext_noop
1279  ("# requests dropped due TTL underflow"), 1,
1280  GNUNET_NO);
1281  /* integer underflow => drop (should be very rare)! */
1282  return;
1283  }
1284  tec.ttl -= ttl_decrement;
1285 
1286  /* test if the request already exists */
1287  tec.finished = GNUNET_NO;
1289  &gm->query,
1290  &test_exist_cb,
1291  &tec);
1292  if (GNUNET_YES == tec.finished)
1293  return; /* merged into existing request, we're done */
1294 
1295  peerreq = GNUNET_new (struct PeerRequest);
1296  peerreq->cp = cp;
1298  tec.type,
1299  &gm->query,
1300  target,
1301  (bfsize > 0)
1302  ? (const char *) &opt[bits]
1303  : NULL,
1304  bfsize,
1305  1 /* anonymity */,
1306  (uint32_t) tec.priority,
1307  tec.ttl,
1308  spid,
1309  GNUNET_PEER_intern (cps->ppd.peer),
1310  NULL, 0, /* replies_seen */
1312  peerreq);
1313  GNUNET_assert (NULL != pr);
1314  prd = GSF_pending_request_get_data_ (pr);
1315  peerreq->pr = pr;
1318  &prd->query,
1319  peerreq,
1322  gettext_noop (
1323  "# P2P query messages received and processed"),
1324  1,
1325  GNUNET_NO);
1327  gettext_noop ("# P2P searches active"),
1328  1,
1329  GNUNET_NO);
1331  GSF_local_lookup_ (pr,
1333  NULL);
1334 }
1335 
1336 
1347 void
1349  int is_query,
1350  uint32_t priority,
1351  struct GNUNET_MQ_Envelope *env)
1352 {
1353  struct GSF_PeerTransmitHandle *pth;
1354  struct GSF_PeerTransmitHandle *pos;
1355  struct GSF_PeerTransmitHandle *prev;
1356 
1357  pth = GNUNET_new (struct GSF_PeerTransmitHandle);
1359  pth->env = env;
1360  pth->is_query = is_query;
1361  pth->priority = priority;
1362  pth->cp = cp;
1363  /* insertion sort (by priority, descending) */
1364  prev = NULL;
1365  pos = cp->pth_head;
1366  while ((NULL != pos) && (pos->priority > priority))
1367  {
1368  prev = pos;
1369  pos = pos->next;
1370  }
1372  cp->pth_tail,
1373  prev,
1374  pth);
1375  if (GNUNET_YES == is_query)
1376  cp->ppd.pending_queries++;
1377  else if (GNUNET_NO == is_query)
1378  cp->ppd.pending_replies++;
1379  schedule_transmission (pth);
1380 }
1381 
1382 
1390 void
1392  struct GNUNET_TIME_Absolute request_time,
1393  uint32_t request_priority)
1394 {
1395  struct GNUNET_TIME_Relative delay;
1396 
1397  delay = GNUNET_TIME_absolute_get_duration (request_time);
1401  cp->ppd.avg_priority =
1402  (cp->ppd.avg_priority * (RUNAVG_DELAY_N - 1)
1403  + request_priority) / RUNAVG_DELAY_N;
1404 }
1405 
1406 
1414 void
1416  struct GSF_LocalClient *initiator_client)
1417 {
1419  % CS2P_SUCCESS_LIST_SIZE] = initiator_client;
1420 }
1421 
1422 
1430 void
1432  const struct GSF_ConnectedPeer *initiator_peer)
1433 {
1434  unsigned int woff;
1435 
1437  GNUNET_PEER_change_rc (cp->ppd.last_p2p_replies[woff], -1);
1438  cp->ppd.last_p2p_replies[woff] = initiator_peer->ppd.pid;
1439  GNUNET_PEER_change_rc (initiator_peer->ppd.pid, 1);
1440  cp->last_p2p_replies_woff = (woff + 1) % P2P_SUCCESS_LIST_SIZE;
1441 }
1442 
1443 
1452 static int
1453 flush_respect (void *cls,
1454  const struct GNUNET_PeerIdentity *key,
1455  void *value)
1456 {
1457  struct GSF_ConnectedPeer *cp = value;
1458  struct GNUNET_PeerIdentity pid;
1459 
1460  if (cp->ppd.respect == cp->disk_respect)
1461  return GNUNET_OK; /* unchanged */
1462  GNUNET_assert (0 != cp->ppd.pid);
1463  GNUNET_PEER_resolve (cp->ppd.pid, &pid);
1464  GNUNET_PEERSTORE_store (peerstore, "fs", &pid, "respect", &cp->ppd.respect,
1465  sizeof(cp->ppd.respect),
1468  NULL,
1469  NULL);
1470  return GNUNET_OK;
1471 }
1472 
1473 
1474 void
1476  const struct GNUNET_PeerIdentity *peer,
1477  void *internal_cls)
1478 {
1479  struct GSF_ConnectedPeer *cp = internal_cls;
1480  struct GSF_PeerTransmitHandle *pth;
1481  struct GSF_DelayedHandle *dh;
1482 
1483  if (NULL == cp)
1484  return; /* must have been disconnect from core with
1485  * 'peer' == my_id, ignore */
1486  flush_respect (NULL,
1487  peer,
1488  cp);
1491  peer,
1492  cp));
1494  gettext_noop ("# peers connected"),
1496  GNUNET_NO);
1497  if (NULL != cp->respect_iterate_req)
1498  {
1500  cp->respect_iterate_req = NULL;
1501  }
1502  if (NULL != cp->rc)
1503  {
1505  cp->rc = NULL;
1506  }
1507  if (NULL != cp->rc_delay_task)
1508  {
1510  cp->rc_delay_task = NULL;
1511  }
1514  cp);
1516  cp->request_map = NULL;
1521  memset (cp->ppd.last_p2p_replies,
1522  0,
1523  sizeof(cp->ppd.last_p2p_replies));
1524  GSF_push_stop_ (cp);
1525  while (NULL != (pth = cp->pth_head))
1526  {
1528  cp->pth_tail,
1529  pth);
1530  if (GNUNET_YES == pth->is_query)
1532  else if (GNUNET_NO == pth->is_query)
1534  GNUNET_free (pth);
1535  }
1536  while (NULL != (dh = cp->delayed_head))
1537  {
1539  cp->delayed_tail,
1540  dh);
1541  GNUNET_MQ_discard (dh->env);
1542  cp->delay_queue_size--;
1544  GNUNET_free (dh);
1545  }
1547  if (NULL != cp->mig_revive_task)
1548  {
1550  cp->mig_revive_task = NULL;
1551  }
1554  GNUNET_free (cp);
1555 }
1556 
1557 
1562 {
1567 
1571  void *it_cls;
1572 };
1573 
1574 
1583 static int
1584 call_iterator (void *cls,
1585  const struct GNUNET_PeerIdentity *key,
1586  void *value)
1587 {
1588  struct IterationContext *ic = cls;
1589  struct GSF_ConnectedPeer *cp = value;
1590 
1591  ic->it (ic->it_cls,
1592  key, cp,
1593  &cp->ppd);
1594  return GNUNET_YES;
1595 }
1596 
1597 
1598 void
1600  void *it_cls)
1601 {
1602  struct IterationContext ic;
1603 
1604  ic.it = it;
1605  ic.it_cls = it_cls;
1607  &call_iterator,
1608  &ic);
1609 }
1610 
1611 
1618 void
1620  struct GNUNET_PeerIdentity *id)
1621 {
1622  GNUNET_assert (0 != cp->ppd.pid);
1623  GNUNET_PEER_resolve (cp->ppd.pid, id);
1624 }
1625 
1626 
1633 const struct GNUNET_PeerIdentity *
1635 {
1636  GNUNET_assert (0 != cp->ppd.pid);
1637  return GNUNET_PEER_resolve2 (cp->ppd.pid);
1638 }
1639 
1640 
1648 void
1650  struct GNUNET_TIME_Absolute block_time)
1651 {
1652  struct GNUNET_MQ_Envelope *env;
1653  struct MigrationStopMessage *msm;
1654 
1655  if (cp->last_migration_block.abs_value_us > block_time.abs_value_us)
1656  {
1658  "Migration already blocked for another %s\n",
1661  (cp->
1662  last_migration_block), GNUNET_YES));
1663  return; /* already blocked */
1664  }
1665  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Asking to stop migration for %s\n",
1668  GNUNET_YES));
1669  cp->last_migration_block = block_time;
1670  env = GNUNET_MQ_msg (msm,
1672  msm->reserved = htonl (0);
1673  msm->duration
1675  (cp->last_migration_block));
1677  gettext_noop ("# migration stop messages sent"),
1678  1,
1679  GNUNET_NO);
1680  GSF_peer_transmit_ (cp,
1681  GNUNET_SYSERR,
1682  UINT32_MAX,
1683  env);
1684 }
1685 
1686 
1696 void
1698  uint64_t pref)
1699 {
1700  cp->inc_preference += pref;
1701 }
1702 
1703 
1709 static void
1711 {
1712  fr_task = NULL;
1714  &flush_respect,
1715  NULL);
1719  NULL);
1720 }
1721 
1722 
1726 void
1728 {
1732  &cron_flush_respect, NULL);
1733 }
1734 
1735 
1739 void
1741 {
1743  &flush_respect,
1744  NULL);
1746  fr_task = NULL;
1748  cp_map = NULL;
1750  GNUNET_YES);
1751 }
1752 
1753 
1762 static int
1764  const struct GNUNET_PeerIdentity *key,
1765  void *value)
1766 {
1767  const struct GSF_LocalClient *lc = cls;
1768  struct GSF_ConnectedPeer *cp = value;
1769  unsigned int i;
1770 
1771  for (i = 0; i < CS2P_SUCCESS_LIST_SIZE; i++)
1772  if (cp->ppd.last_client_replies[i] == lc)
1773  cp->ppd.last_client_replies[i] = NULL;
1774  return GNUNET_YES;
1775 }
1776 
1777 
1784 void
1786 {
1787  if (NULL == cp_map)
1788  return; /* already cleaned up */
1791  (void *) lc);
1792 }
1793 
1794 
1795 /* 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
GNUNET_BLOCK_Type
WARNING: This header is generated! In order to add DHT block types, you must register them in GANA,...
@ GNUNET_BLOCK_TYPE_ANY
Identifier for any block.
#define DBLOCK_SIZE
Size of the individual blocks used for file-sharing.
Definition: fs.h:41
#define gettext_noop(String)
Definition: gettext.h:70
static char * expiration
Credential TTL.
Definition: gnunet-abd.c:96
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static void record(void *cls, size_t data_size, const void *data)
Process recorded audio data.
struct GNUNET_HashCode key
The key used in the DHT.
uint32_t data
The data value.
static char * value
Value of the record to add/remove.
static struct GNUNET_TIME_Relative delay
When should dkg communication start?
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.
struct GNUNET_ATS_PerformanceHandle * GSF_ats
Handle to ATS service.
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.
const struct GNUNET_PeerIdentity * GSF_connected_peer_get_identity2_(const struct GSF_ConnectedPeer *cp)
Obtain the identity of a connected peer.
static void cron_flush_respect(void *cls)
Call this method periodically to flush respect information to disk.
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.
struct GSF_ConnectedPeer * GSF_peer_get_(const struct GNUNET_PeerIdentity *peer)
Get a handle for a connected peer.
static void ats_reserve_callback(void *cls, const struct GNUNET_PeerIdentity *peer, int32_t amount, struct GNUNET_TIME_Relative res_delay)
Function called by core upon success or failure of our bandwidth reservation request.
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.
static void retry_reservation(void *cls)
(re)try to reserve bandwidth from the given 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.
void * GSF_peer_connect_handler(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
A peer connected to us.
static struct GNUNET_CONTAINER_MultiPeerMap * cp_map
Map from peer identities to struct GSF_ConnectPeer entries.
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.
struct GSF_PeerPerformanceData * GSF_get_peer_performance_data_(struct GSF_ConnectedPeer *cp)
Return the performance data record for the given peer.
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?
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.
int GSF_pending_request_test_active_(struct GSF_PendingRequest *pr)
Check if the given request is still active.
struct GSF_PendingRequestData * GSF_pending_request_get_data_(struct GSF_PendingRequest *pr)
Obtain the public data associated with a pending 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_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,...
void GNUNET_ATS_reserve_bandwidth_cancel(struct GNUNET_ATS_ReservationContext *rc)
Cancel request for reserving bandwidth.
void GNUNET_ATS_performance_change_preference(struct GNUNET_ATS_PerformanceHandle *ph, const struct GNUNET_PeerIdentity *peer,...)
Change preferences for the given peer.
struct GNUNET_ATS_ReservationContext * GNUNET_ATS_reserve_bandwidth(struct GNUNET_ATS_PerformanceHandle *ph, const struct GNUNET_PeerIdentity *peer, int32_t amount, GNUNET_ATS_ReservationCallback rcb, void *rcb_cls)
Reserve inbound bandwidth from the given peer.
@ GNUNET_ATS_PREFERENCE_BANDWIDTH
Change the peer's bandwidth value (value per byte of bandwidth in the goal function) to the given amo...
@ GNUNET_ATS_PREFERENCE_END
End of preference list.
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.
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.
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).
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
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_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:62
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:77
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
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
const struct GNUNET_PeerIdentity * GNUNET_PEER_resolve2(GNUNET_PEER_Id id)
Convert an interned PID to a normal peer identity.
Definition: peer.c:234
GNUNET_PEER_Id GNUNET_PEER_intern(const struct GNUNET_PeerIdentity *pid)
Intern an peer identity.
Definition: peer.c:108
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_iterate_cancel(struct GNUNET_PEERSTORE_IterateContext *ic)
Cancel an iterate request Please do not call after the iterate request is done.
void GNUNET_PEERSTORE_disconnect(struct GNUNET_PEERSTORE_Handle *h, int sync_first)
Disconnect from the PEERSTORE service.
struct GNUNET_PEERSTORE_IterateContext * GNUNET_PEERSTORE_iterate(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 records matching supplied key information.
@ 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.
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_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_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_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
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
#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
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:569
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
static GNUNET_CronTime last_transmission
Linked list of pending reservations.
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:41
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.
int did_reserve
GNUNET_YES if we did successfully reserve 32k bandwidth, GNUNET_NO if not.
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 GNUNET_ATS_ReservationContext * rc
Context of our GNUNET_ATS_reserve_bandwidth call (or NULL).
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.
int was_reserved
Did we get a reservation already?
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.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.