GNUnet  0.11.x
gnunet-service-fs.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2009-2014, 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  */
20 
26 #include "platform.h"
27 #include <float.h>
28 #include "gnunet_constants.h"
29 #include "gnunet_core_service.h"
30 #include "gnunet_dht_service.h"
32 #include "gnunet_load_lib.h"
33 #include "gnunet_peer_lib.h"
34 #include "gnunet_protocols.h"
35 #include "gnunet_signatures.h"
38 #include "gnunet_util_lib.h"
39 #include "gnunet-service-fs_cp.h"
41 #include "gnunet-service-fs_pe.h"
42 #include "gnunet-service-fs_pr.h"
43 #include "gnunet-service-fs_push.h"
44 #include "gnunet-service-fs_put.h"
46 #include "fs.h"
47 #include "fs_api.h"
48 
54 #define FS_DHT_HT_SIZE 1024
55 
56 
62 #define COVER_AGE_FREQUENCY GNUNET_TIME_relative_multiply ( \
63  GNUNET_TIME_UNIT_SECONDS, 5)
64 
68 #define INSANE_STATISTICS GNUNET_NO
69 
70 
76 {
81 
86 
91 
96 
101 };
102 
103 
109 {
114 
119 
124 
128  size_t msize;
129 };
130 
131 
137 {
142 
147 
151  char *filename;
152 
157 
162 
166  struct GNUNET_HashCode file_id;
167 };
168 
169 
174 {
179 
184 
190 
196 
201 
206 
211 
216 };
217 
218 
219 /* ****************************** globals ****************************** */
220 
225 
230 
235 
240 
245 
250 struct GNUNET_TIME_Relative GSF_avg_latency = { 500 };
251 
256 
257 
269 
274 
280 
286 
291 
297 
302 
307 
308 /* ***************************** locals ******************************* */
309 
314 
318 static struct GNUNET_CRYPTO_EddsaPrivateKey pk;
319 
324 
329 
330 
339 static void *
340 client_connect_cb (void *cls,
341  struct GNUNET_SERVICE_Client *client,
342  struct GNUNET_MQ_Handle *mq)
343 {
344  struct GSF_LocalClient *pos;
345 
346  pos = GNUNET_new (struct GSF_LocalClient);
347  pos->client = client;
348  pos->mq = mq;
349  return pos;
350 }
351 
352 
358 static void
360 {
361  struct ClientRequest *cr = cls;
362  struct GSF_LocalClient *lc = cr->lc;
363 
364  cr->kill_task = NULL;
366  lc->cr_tail,
367  cr);
369  GNUNET_YES);
371  gettext_noop ("# client searches active"),
372  -1,
373  GNUNET_NO);
374  GNUNET_free (cr);
375 }
376 
377 
396 static void
399  struct GSF_PendingRequest *pr,
400  uint32_t reply_anonymity_level,
403  enum GNUNET_BLOCK_Type type,
404  const void *data,
405  size_t data_len)
406 {
407  struct ClientRequest *cr = cls;
408  struct GSF_LocalClient *lc;
409  struct GNUNET_MQ_Envelope *env;
410  struct ClientPutMessage *pm;
411  const struct GSF_PendingRequestData *prd;
412 
413  if (NULL == data)
414  {
415  /* local-only request, with no result, clean up. */
416  if (NULL == cr->kill_task)
418  cr);
419  return;
420  }
423  if ((prd->type != type) && (prd->type != GNUNET_BLOCK_TYPE_ANY))
424  {
425  GNUNET_break (0);
426  return;
427  }
430  ("# replies received for local clients"), 1,
431  GNUNET_NO);
432  GNUNET_assert (pr == cr->pr);
433  lc = cr->lc;
435  data_len,
437  pm->type = htonl (type);
438  pm->expiration = GNUNET_TIME_absolute_hton (expiration);
439  pm->last_transmission = GNUNET_TIME_absolute_hton (last_transmission);
440  pm->num_transmissions = htonl (prd->num_transmissions);
441  pm->respect_offered = htonl (prd->respect_offered);
442  GNUNET_memcpy (&pm[1],
443  data,
444  data_len);
445  GNUNET_MQ_send (lc->mq,
446  env);
448  "Queued reply to query `%s' for local client\n",
449  GNUNET_h2s (&prd->query));
451  {
453  "Evaluation %d - keeping query alive\n",
454  (int) eval);
455  return;
456  }
457  if (NULL == cr->kill_task)
459  cr);
460 }
461 
462 
471 static void
473  struct GNUNET_SERVICE_Client *client,
474  void *app_ctx)
475 {
476  struct GSF_LocalClient *lc = app_ctx;
477  struct IndexStartContext *isc;
478  struct ClientRequest *cr;
479  struct ClientResponse *res;
480 
481  while (NULL != (cr = lc->cr_head))
482  {
483  if (NULL != cr->kill_task)
486  }
487  while (NULL != (res = lc->res_head))
488  {
490  lc->res_tail,
491  res);
492  GNUNET_free (res);
493  }
494  while (NULL != (isc = lc->isc_head))
495  {
497  lc->isc_tail,
498  isc);
500  GNUNET_free (isc);
501  }
502  GNUNET_free (lc);
503 }
504 
505 
511 static void
513 {
519  NULL);
520 }
521 
522 
529 void
531 {
533 
536 }
537 
538 
549 int
550 GSF_test_get_load_too_high_ (uint32_t priority)
551 {
552  double ld;
553 
555  if (ld < 1)
556  return GNUNET_SYSERR;
557  if (ld <= priority)
558  return GNUNET_NO;
559  return GNUNET_YES;
560 }
561 
562 
574 static void
575 update_latencies (void *cls,
576  const struct GNUNET_HELLO_Address *address,
577  int active,
578  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
579  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
580  const struct GNUNET_ATS_Properties *prop)
581 {
582  if (NULL == address)
583  {
584  /* ATS service temporarily disconnected */
585  return;
586  }
587 
588  if (GNUNET_YES != active)
589  return;
591  prop->delay);
594  + GNUNET_MIN (5000, prop->delay.rel_value_us)) / 32;
596  gettext_noop ("# running average P2P latency (ms)"),
597  GSF_avg_latency.rel_value_us / 1000LL,
598  GNUNET_NO);
599 }
600 
601 
610 static int
611 check_p2p_put (void *cls,
612  const struct PutMessage *put)
613 {
614  enum GNUNET_BLOCK_Type type;
615 
616  type = ntohl (put->type);
618  {
619  GNUNET_break_op (0);
620  return GNUNET_SYSERR;
621  }
622  return GNUNET_OK;
623 }
624 
625 
635 static void
637  const struct GNUNET_PeerIdentity *peer,
638  struct GSF_ConnectedPeer *cp,
639  const struct GSF_PeerPerformanceData *ppd)
640 {
641  struct GSF_PendingRequest *pr = cls;
642 
643  if (GNUNET_YES !=
645  {
646 #if INSANE_STATISTICS
648  gettext_noop ("# Loopback routes suppressed"), 1,
649  GNUNET_NO);
650 #endif
651  return;
652  }
653  GSF_plan_add_ (cp,
654  pr);
655 }
656 
657 
668 void
670  struct GSF_PendingRequest *pr,
672 {
674  return; /* we're done... */
675  if (GNUNET_YES !=
677  return; /* request is not actually active, skip! */
679  pr);
680 }
681 
682 
691 static int
692 check_p2p_get (void *cls,
693  const struct GetMessage *gm)
694 {
695  size_t msize;
696  unsigned int bm;
697  unsigned int bits;
698  size_t bfsize;
699 
700  msize = ntohs (gm->header.size);
701  bm = ntohl (gm->hash_bitmap);
702  bits = 0;
703  while (bm > 0)
704  {
705  if (1 == (bm & 1))
706  bits++;
707  bm >>= 1;
708  }
709  if (msize < sizeof(struct GetMessage) + bits * sizeof(struct
711  {
712  GNUNET_break_op (0);
713  return GNUNET_SYSERR;
714  }
715  bfsize = msize - sizeof(struct GetMessage) - bits * sizeof(struct
717  /* bfsize must be power of 2, check! */
718  if (0 != ((bfsize - 1) & bfsize))
719  {
720  GNUNET_break_op (0);
721  return GNUNET_SYSERR;
722  }
723  return GNUNET_OK;
724 }
725 
726 
737 static void
739  struct GSF_PendingRequest *pr,
741 {
742  struct GSF_LocalClient *lc = cls;
743  struct GSF_PendingRequestData *prd;
744 
747  return; /* we're done, 'pr' was already destroyed... */
750  "Finished database lookup for local request `%s' with result %d\n",
751  GNUNET_h2s (&prd->query),
752  result);
753  if (0 == prd->anonymity_level)
754  {
755  switch (prd->type)
756  {
759  /* the above block types MAY be available via 'cadet' */
761  "Considering cadet-based download for block\n");
762  GSF_cadet_lookup_ (pr);
763  break;
764 
766  /* the above block types are in the DHT */
768  "Considering DHT-based search for block\n");
769  GSF_dht_lookup_ (pr);
770  break;
771 
772  default:
773  GNUNET_break (0);
774  break;
775  }
776  }
778  pr,
779  result);
780 }
781 
782 
791 static int
793  const struct SearchMessage *sm)
794 {
795  uint16_t msize;
796 
797  msize = ntohs (sm->header.size) - sizeof(struct SearchMessage);
798  if (0 != msize % sizeof(struct GNUNET_HashCode))
799  {
800  GNUNET_break (0);
801  return GNUNET_SYSERR;
802  }
803  return GNUNET_OK;
804 }
805 
806 
817 static void
819  const struct SearchMessage *sm)
820 {
821  static struct GNUNET_PeerIdentity all_zeros;
822  struct GSF_LocalClient *lc = cls;
823  struct ClientRequest *cr;
824  struct GSF_PendingRequestData *prd;
825  uint16_t msize;
826  unsigned int sc;
827  enum GNUNET_BLOCK_Type type;
829 
831  gettext_noop ("# client searches received"),
832  1,
833  GNUNET_NO);
834  msize = ntohs (sm->header.size) - sizeof(struct SearchMessage);
835  sc = msize / sizeof(struct GNUNET_HashCode);
836  type = ntohl (sm->type);
838  "Received request for `%s' of type %u from local client\n",
839  GNUNET_h2s (&sm->query),
840  (unsigned int) type);
841  cr = NULL;
842  /* detect duplicate UBLOCK requests */
845  {
846  cr = lc->cr_head;
847  while (NULL != cr)
848  {
849  prd = GSF_pending_request_get_data_ (cr->pr);
850  /* only unify with queries that hae not yet started local processing
851  (SEARCH_MESSAGE_OPTION_CONTINUED was always set) and that have a
852  matching query and type */
853  if ((GNUNET_YES != prd->has_started) &&
854  (0 != memcmp (&prd->query,
855  &sm->query,
856  sizeof(struct GNUNET_HashCode))) &&
857  (prd->type == type))
858  break;
859  cr = cr->next;
860  }
861  }
862  if (NULL != cr)
863  {
865  "Have existing request, merging content-seen lists.\n");
867  (const struct GNUNET_HashCode *) &sm[1],
868  sc);
870  gettext_noop (
871  "# client searches updated (merged content seen list)"),
872  1,
873  GNUNET_NO);
874  }
875  else
876  {
878  gettext_noop ("# client searches active"),
879  1,
880  GNUNET_NO);
881  cr = GNUNET_new (struct ClientRequest);
882  cr->lc = lc;
884  lc->cr_tail,
885  cr);
887  if (0 != (SEARCH_MESSAGE_OPTION_LOOPBACK_ONLY & ntohl (sm->options)))
890  &sm->query,
891  (0 !=
892  memcmp (&sm->target,
893  &all_zeros,
894  sizeof(struct
896  ? &sm->target : NULL, NULL, 0,
897  0 /* bf */,
898  ntohl (sm->anonymity_level),
899  0 /* priority */,
900  0 /* ttl */,
901  0 /* sender PID */,
902  0 /* origin PID */,
903  (const struct
904  GNUNET_HashCode *) &sm[1], sc,
906  cr);
907  }
908  if (0 != (SEARCH_MESSAGE_OPTION_CONTINUED & ntohl (sm->options)))
909  {
911  return;
912  }
914  GSF_local_lookup_ (cr->pr,
916  lc);
917 }
918 
919 
926 static void
928  const struct RequestLocSignatureMessage *msg)
929 {
930  struct GSF_LocalClient *lc = cls;
931  struct GNUNET_FS_Uri base;
932  struct GNUNET_FS_Uri *loc;
933  struct GNUNET_MQ_Envelope *env;
934  struct ResponseLocSignatureMessage *resp;
935 
937  ntohl (msg->purpose));
938  base.type = GNUNET_FS_URI_CHK;
939  base.data.chk.chk = msg->chk;
940  base.data.chk.file_length = GNUNET_ntohll (msg->file_length);
941  loc = GNUNET_FS_uri_loc_create (&base,
942  &pk,
944  msg->expiration_time));
945  env = GNUNET_MQ_msg (resp,
949  loc->data.loc.expirationTime);
950  resp->signature = loc->data.loc.contentSignature;
951  resp->peer = loc->data.loc.peer;
952  GNUNET_FS_uri_destroy (loc);
953  GNUNET_MQ_send (lc->mq,
954  env);
956 }
957 
958 
966 static int
968  const struct IndexStartMessage *ism)
969 {
970  char *fn;
971 
973  if (0 != ism->reserved)
974  {
975  GNUNET_break (0);
976  return GNUNET_SYSERR;
977  }
978  fn = GNUNET_STRINGS_filename_expand ((const char *) &ism[1]);
979  if (NULL == fn)
980  {
981  GNUNET_break (0);
982  return GNUNET_SYSERR;
983  }
984  GNUNET_free (fn);
985  return GNUNET_OK;
986 }
987 
988 
995 static void
997 {
998  struct GSF_LocalClient *lc = isc->lc;
999  struct GNUNET_MQ_Envelope *env;
1000  struct GNUNET_MessageHeader *msg;
1001 
1003  &isc->file_id);
1004  env = GNUNET_MQ_msg (msg,
1006  GNUNET_MQ_send (lc->mq,
1007  env);
1008  GNUNET_free (isc->filename);
1009  GNUNET_free (isc);
1011 }
1012 
1013 
1021 static void
1023  const struct GNUNET_HashCode *res)
1024 {
1025  struct IndexStartContext *isc = cls;
1026  struct GSF_LocalClient *lc = isc->lc;
1027  struct GNUNET_MQ_Envelope *env;
1028  struct GNUNET_MessageHeader *msg;
1029 
1031  lc->isc_tail,
1032  isc);
1033  isc->fhc = NULL;
1034  if ((NULL == res) ||
1035  (0 != memcmp (res,
1036  &isc->file_id,
1037  sizeof(struct GNUNET_HashCode))))
1038  {
1040  _ (
1041  "Hash mismatch trying to index file `%s' which does not have hash `%s'\n"),
1042  isc->filename,
1043  GNUNET_h2s (&isc->file_id));
1044  env = GNUNET_MQ_msg (msg,
1046  GNUNET_MQ_send (lc->mq,
1047  env);
1049  GNUNET_free (isc);
1050  return;
1051  }
1052  signal_index_ok (isc);
1053 }
1054 
1055 
1062 static void
1064  const struct IndexStartMessage *ism)
1065 {
1066  struct GSF_LocalClient *lc = cls;
1067  struct IndexStartContext *isc;
1068  char *fn;
1069  uint64_t dev;
1070  uint64_t ino;
1071  uint64_t mydev;
1072  uint64_t myino;
1073 
1074  fn = GNUNET_STRINGS_filename_expand ((const char *) &ism[1]);
1075  GNUNET_assert (NULL != fn);
1076  dev = GNUNET_ntohll (ism->device);
1077  ino = GNUNET_ntohll (ism->inode);
1078  isc = GNUNET_new (struct IndexStartContext);
1079  isc->filename = fn;
1080  isc->file_id = ism->file_id;
1082  "Received START_INDEX message for file `%s'\n",
1083  isc->filename);
1084  isc->lc = lc;
1085  mydev = 0;
1086  myino = 0;
1087  if (((dev != 0) ||
1088  (ino != 0)) &&
1090  &mydev,
1091  &myino)) &&
1092  (dev == mydev) &&
1093  (ino == myino))
1094  {
1095  /* fast validation OK! */
1096  signal_index_ok (isc);
1097  return;
1098  }
1100  "Mismatch in file identifiers (%llu != %llu or %u != %u), need to hash.\n",
1101  (unsigned long long) ino,
1102  (unsigned long long) myino,
1103  (unsigned int) dev,
1104  (unsigned int) mydev);
1105  /* slow validation, need to hash full file (again) */
1107  lc->isc_tail,
1108  isc);
1110  isc->filename,
1113  isc);
1114  if (NULL == isc->fhc)
1115  hash_for_index_val (isc,
1116  NULL);
1117 }
1118 
1119 
1126 static void
1128  const struct GNUNET_MessageHeader *message)
1129 {
1130  struct GSF_LocalClient *lc = cls;
1131 
1134 }
1135 
1136 
1143 static void
1145  const struct UnindexMessage *um)
1146 {
1147  struct GSF_LocalClient *lc = cls;
1148  struct GNUNET_MQ_Envelope *env;
1149  struct GNUNET_MessageHeader *msg;
1150  int found;
1151 
1152  GNUNET_break (0 == um->reserved);
1153  found = GNUNET_FS_indexing_do_unindex (&um->file_id);
1155  "Client requested unindexing of file `%s': %s\n",
1156  GNUNET_h2s (&um->file_id),
1157  found ? "found" : "not found");
1158  env = GNUNET_MQ_msg (msg,
1160  GNUNET_MQ_send (lc->mq,
1161  env);
1163 }
1164 
1165 
1171 static void
1172 shutdown_task (void *cls)
1173 {
1175  if (NULL != GSF_core)
1176  {
1178  GSF_core = NULL;
1179  }
1180  if (NULL != GSF_ats)
1181  {
1183  GSF_ats = NULL;
1184  }
1185  GSF_put_done_ ();
1186  GSF_push_done_ ();
1188  GSF_plan_done ();
1191  GNUNET_NO);
1192  GSF_dsh = NULL;
1194  GSF_dht = NULL;
1196  GSF_block_ctx = NULL;
1198  block_cfg = NULL;
1200  GSF_stats = NULL;
1201  if (NULL != cover_age_task)
1202  {
1204  cover_age_task = NULL;
1205  }
1208  datastore_get_load = NULL;
1210  GSF_rt_entry_lifetime = NULL;
1211 }
1212 
1213 
1224 static void
1226  const struct GNUNET_PeerIdentity *my_identity)
1227 {
1228  if (0 != GNUNET_memcmp (&GSF_my_id,
1229  my_identity))
1230  {
1232  "Peer identity mismatch, refusing to start!\n");
1234  }
1235 }
1236 
1237 
1243 static int
1245 {
1246  struct GNUNET_MQ_MessageHandler no_p2p_handlers[] = {
1248  };
1249  struct GNUNET_MQ_MessageHandler p2p_handlers[] = {
1250  GNUNET_MQ_hd_var_size (p2p_get,
1252  struct GetMessage,
1253  NULL),
1254  GNUNET_MQ_hd_var_size (p2p_put,
1256  struct PutMessage,
1257  NULL),
1258  GNUNET_MQ_hd_fixed_size (p2p_migration_stop,
1260  struct MigrationStopMessage,
1261  NULL),
1263  };
1264  int anon_p2p_off;
1265  char *keyfile;
1266 
1267  /* this option is really only for testcases that need to disable
1268  _anonymous_ file-sharing for some reason */
1269  anon_p2p_off = (GNUNET_YES ==
1271  "fs",
1272  "DISABLE_ANON_TRANSFER"));
1273 
1274  if (GNUNET_OK !=
1276  "PEER",
1277  "PRIVATE_KEY",
1278  &keyfile))
1279  {
1281  _ (
1282  "FS service is lacking HOSTKEY configuration setting. Exiting.\n"));
1284  return GNUNET_SYSERR;
1285  }
1286  if (GNUNET_SYSERR ==
1288  GNUNET_YES,
1289  &pk))
1290  {
1292  "Failed to setup peer's private key\n");
1294  GNUNET_free (keyfile);
1295  return GNUNET_SYSERR;
1296  }
1297  GNUNET_free (keyfile);
1300 
1302  "I am peer %s\n",
1303  GNUNET_i2s (&GSF_my_id));
1304  GSF_core
1306  NULL,
1310  (GNUNET_YES == anon_p2p_off)
1311  ? no_p2p_handlers
1312  : p2p_handlers);
1313  if (NULL == GSF_core)
1314  {
1316  _ ("Failed to connect to `%s' service.\n"),
1317  "core");
1318  return GNUNET_SYSERR;
1319  }
1320  cover_age_task =
1323  NULL);
1327  NULL);
1328  return GNUNET_OK;
1329 }
1330 
1331 
1339 static void
1340 run (void *cls,
1341  const struct GNUNET_CONFIGURATION_Handle *cfg,
1343 {
1344  unsigned long long dqs;
1345 
1346  GSF_cfg = cfg;
1347  if (GNUNET_OK !=
1349  "fs",
1350  "DATASTORE_QUEUE_SIZE",
1351  &dqs))
1352  {
1354  "fs",
1355  "DATASTORE_QUEUE_SIZE");
1356  dqs = 32;
1357  }
1358  GSF_datastore_queue_size = (unsigned int) dqs;
1360  GNUNET_CONFIGURATION_get_value_yesno (cfg, "fs", "DELAY");
1362  if (NULL == GSF_dsh)
1363  {
1365  return;
1366  }
1371  GNUNET_assert (NULL != GSF_block_ctx);
1373  GSF_plan_init ();
1378  NULL);
1379  GSF_push_init_ ();
1380  GSF_put_init_ ();
1382  GSF_dsh)) ||
1383  (GNUNET_OK != main_init (cfg)))
1384  {
1386  shutdown_task (NULL);
1387  return;
1388  }
1389 }
1390 
1391 
1396  ("fs",
1398  &run,
1401  NULL,
1402  GNUNET_MQ_hd_var_size (client_index_start,
1404  struct IndexStartMessage,
1405  NULL),
1406  GNUNET_MQ_hd_fixed_size (client_index_list_get,
1408  struct GNUNET_MessageHeader,
1409  NULL),
1410  GNUNET_MQ_hd_fixed_size (client_unindex,
1412  struct UnindexMessage,
1413  NULL),
1414  GNUNET_MQ_hd_var_size (client_start_search,
1416  struct SearchMessage,
1417  NULL),
1418  GNUNET_MQ_hd_fixed_size (client_loc_sign,
1421  NULL),
1423 
1424 
1425 /* end of gnunet-service-fs.c */
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
definitions for the entire fs module
#define HASHING_BLOCKSIZE
Blocksize to use when hashing files for indexing (blocksize for IO, not for the DBlocks).
Definition: fs.h:47
#define SEARCH_MESSAGE_OPTION_LOOPBACK_ONLY
Only search the local datastore (no network)
Definition: fs.h:253
#define SEARCH_MESSAGE_OPTION_CONTINUED
Request is too large to fit in 64k format.
Definition: fs.h:261
shared definitions for the FS library
@ GNUNET_FS_URI_CHK
Content-hash-key (simple file).
Definition: fs_api.h:143
#define gettext_noop(String)
Definition: gettext.h:69
static char * expiration
Credential TTL.
Definition: gnunet-abd.c:96
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
static int start
Set if we are to start default services (including ARM).
Definition: gnunet-arm.c:39
static int res
static char * address
GNS address for this phone.
uint32_t data
The data value.
static int result
Global testing status.
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
static struct GNUNET_TIME_Relative delay
When should dkg communication start?
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
static struct GNUNET_PeerIdentity my_identity
Identity of this peer.
GNUNET_SERVICE_MAIN("fs", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_var_size(client_index_start, GNUNET_MESSAGE_TYPE_FS_INDEX_START, struct IndexStartMessage, NULL), GNUNET_MQ_hd_fixed_size(client_index_list_get, GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_GET, struct GNUNET_MessageHeader, NULL), GNUNET_MQ_hd_fixed_size(client_unindex, GNUNET_MESSAGE_TYPE_FS_UNINDEX, struct UnindexMessage, NULL), GNUNET_MQ_hd_var_size(client_start_search, GNUNET_MESSAGE_TYPE_FS_START_SEARCH, struct SearchMessage, NULL), GNUNET_MQ_hd_fixed_size(client_loc_sign, GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGN, struct RequestLocSignatureMessage, NULL), GNUNET_MQ_handler_end())
Define "main" method using service macro.
static struct GNUNET_SCHEDULER_Task * cover_age_task
ID of our task that we use to age the cover counters.
static void handle_client_loc_sign(void *cls, const struct RequestLocSignatureMessage *msg)
Handle request to sign a LOC URI (from client).
#define COVER_AGE_FREQUENCY
How quickly do we age cover traffic? At the given time interval, remaining cover traffic counters are...
int GSF_enable_randomized_delays
Are we introducing randomized delays for better anonymity?
static struct GNUNET_LOAD_Value * datastore_get_load
Datastore 'GET' load tracking.
static int check_p2p_get(void *cls, const struct GetMessage *gm)
Check P2P "GET" request.
void GSF_update_datastore_delay_(struct GNUNET_TIME_Absolute start)
We've just now completed a datastore request.
struct GNUNET_BLOCK_Context * GSF_block_ctx
Our block context.
static void hash_for_index_val(void *cls, const struct GNUNET_HashCode *res)
Function called once the hash computation over an indexed file has completed.
static void handle_client_start_search(void *cls, const struct SearchMessage *sm)
Handle GNUNET_MESSAGE_TYPE_FS_START_SEARCH-message (search request from client).
static void handle_client_unindex(void *cls, const struct UnindexMessage *um)
Handle UNINDEX-message.
static void handle_client_index_start(void *cls, const struct IndexStartMessage *ism)
Handle INDEX_START-message.
static int check_client_index_start(void *cls, const struct IndexStartMessage *ism)
Check INDEX_START-message.
static void update_latencies(void *cls, const struct GNUNET_HELLO_Address *address, int active, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in, const struct GNUNET_ATS_Properties *prop)
We've received peer performance information.
static void handle_client_index_list_get(void *cls, const struct GNUNET_MessageHeader *message)
Handle INDEX_LIST_GET-message.
struct GNUNET_DHT_Handle * GSF_dht
Handle for DHT operations.
static struct GNUNET_CRYPTO_EddsaPrivateKey pk
Private key of this peer.
static void consider_request_for_forwarding(void *cls, const struct GNUNET_PeerIdentity *peer, struct GSF_ConnectedPeer *cp, const struct GSF_PeerPerformanceData *ppd)
We have a new request, consider forwarding it to the given peer.
static void shutdown_task(void *cls)
Task run during shutdown.
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.
static void signal_index_ok(struct IndexStartContext *isc)
We've validated the hash of the file we're about to index.
double GSF_current_priorities
Typical priorities we're seeing from other peers right now.
static void client_response_handler(void *cls, enum GNUNET_BLOCK_EvaluationResult 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.
static void peer_init_handler(void *cls, const struct GNUNET_PeerIdentity *my_identity)
Function called after GNUNET_CORE_connect has succeeded (or failed for good).
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.
static int check_p2p_put(void *cls, const struct PutMessage *put)
Check P2P "PUT" message.
static void age_cover_counters(void *cls)
Task that periodically ages our cover traffic statistics.
static void * client_connect_cb(void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
Creates a fresh local client handle.
static void start_p2p_processing(void *cls, struct GSF_PendingRequest *pr, enum GNUNET_BLOCK_EvaluationResult result)
We're done with the local lookup, now consider P2P processing (depending on request options and resul...
struct GNUNET_PeerIdentity GSF_my_id
Identity of this peer.
struct GNUNET_ATS_PerformanceHandle * GSF_ats
Handle to ATS service.
struct GNUNET_CORE_Handle * GSF_core
Pointer to handle to the core service (points to NULL until we've connected to it).
unsigned int GSF_cover_content_count
How many content messages have we received 'recently' that have not yet been claimed as cover traffic...
static void client_disconnect_cb(void *cls, struct GNUNET_SERVICE_Client *client, void *app_ctx)
A client disconnected from us.
struct GNUNET_TIME_Relative GSF_avg_latency
Running average of the observed latency to other peers (round trip).
static int main_init(const struct GNUNET_CONFIGURATION_Handle *c)
Process fs requests.
struct GNUNET_LOAD_Value * GSF_rt_entry_lifetime
How long do requests typically stay in the routing table?
struct GNUNET_DATASTORE_Handle * GSF_dsh
Our connection to the datastore.
#define FS_DHT_HT_SIZE
Size for the hash map for DHT requests from the FS service.
static void client_request_destroy(void *cls)
Free the given client request.
unsigned int GSF_datastore_queue_size
Size of the datastore queue we assume for common requests.
static int check_client_start_search(void *cls, const struct SearchMessage *sm)
Check GNUNET_MESSAGE_TYPE_FS_START_SEARCH-message (search request from client).
static void run(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_SERVICE_Handle *service)
Process fs requests.
static struct GNUNET_CONFIGURATION_Handle * block_cfg
Configuration for block library.
void GSF_consider_forwarding(void *cls, struct GSF_PendingRequest *pr, enum GNUNET_BLOCK_EvaluationResult result)
Function to be called after we're done processing replies from the local lookup.
#define DATASTORE_LOAD_AUTODECLINE
At what frequency should our datastore load decrease automatically (since if we don't use it,...
non-anonymous file-transfer
void GSF_cadet_stop_server(void)
Shutdown subsystem for non-anonymous file-sharing.
void GSF_cadet_start_server(void)
Initialize subsystem for non-anonymous file-sharing.
void GSF_connected_peer_done_()
Shutdown peer management subsystem.
void GSF_peer_disconnect_handler(void *cls, const struct GNUNET_PeerIdentity *peer, void *internal_cls)
A peer disconnected from us.
void GSF_update_peer_latency_(const struct GNUNET_PeerIdentity *id, struct GNUNET_TIME_Relative latency)
Update the latency information kept for the given peer.
void GSF_iterate_connected_peers_(GSF_ConnectedPeerIterator it, void *it_cls)
Iterate over all connected peers.
void * GSF_peer_connect_handler(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
A peer connected to us.
void GSF_connected_peer_init_()
Initialize peer management subsystem.
API to handle 'connected peers'.
int GNUNET_FS_indexing_do_unindex(const struct GNUNET_HashCode *fid)
Remove a file from the index.
void GNUNET_FS_add_to_index(const char *filename, const struct GNUNET_HashCode *file_id)
Add the given file to the list of indexed files.
int GNUNET_FS_indexing_init(const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_DATASTORE_Handle *d)
Initialize the indexing submodule.
void GNUNET_FS_indexing_send_list(struct GNUNET_MQ_Handle *mq)
Transmit information about indexed files to mq.
void GNUNET_FS_indexing_done()
Shutdown the module.
indexing for the file-sharing service
void GSF_plan_init()
Initialize plan subsystem.
void GSF_plan_add_(struct GSF_ConnectedPeer *cp, struct GSF_PendingRequest *pr)
Create a new query plan entry.
void GSF_plan_done()
Shutdown plan subsystem.
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_cadet_lookup_(struct GSF_PendingRequest *pr)
Consider downloading via cadet (if possible)
void GSF_dht_lookup_(struct GSF_PendingRequest *pr)
Consider looking up the data in the DHT (anonymity-level permitting).
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 mingle, 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_local_lookup_(struct GSF_PendingRequest *pr, GSF_LocalLookupContinuation cont, void *cont_cls)
Look up the request in the local datastore.
void GSF_pending_request_init_()
Setup the subsystem.
int GSF_pending_request_test_active_(struct GSF_PendingRequest *pr)
Check if the given request is still active.
void GSF_pending_request_done_()
Shutdown the subsystem.
struct GSF_PendingRequestData * GSF_pending_request_get_data_(struct GSF_PendingRequest *pr)
Obtain the public data associated with a pending request.
void GSF_pending_request_cancel_(struct GSF_PendingRequest *pr, int full_cleanup)
Explicitly cancel a pending request.
void GSF_pending_request_update_(struct GSF_PendingRequest *pr, const struct GNUNET_HashCode *replies_seen, unsigned int replies_seen_count)
Update a given pending request with additional replies that have been seen.
API to handle pending requests.
GSF_PendingRequestOptions
Options for pending requests (bits to be ORed).
@ GSF_PRO_LOCAL_REQUEST
Option mask for typical local requests.
@ GSF_PRO_LOCAL_ONLY
Request must only be processed locally.
void GSF_push_init_()
Setup the module.
void GSF_push_done_()
Shutdown the module.
support for pushing out content
void GSF_put_init_()
Setup the module.
void GSF_put_done_()
Shutdown the module.
support for putting content into the DHT
static struct GNUNET_PeerIdentity all_zeros
Peer identity that is all zeros, used as a way to indicate "all peers".
static struct GNUNET_TRANSPORT_PluginMonitor * pm
Handle if we are monitoring plugin session activity.
#define GNUNET_log(kind,...)
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:53
@ GNUNET_SCHEDULER_PRIORITY_IDLE
Run when otherwise idle.
#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_OK
Definition: gnunet_common.h:95
@ GNUNET_YES
Definition: gnunet_common.h:97
@ GNUNET_NO
Definition: gnunet_common.h:94
@ GNUNET_SYSERR
Definition: gnunet_common.h:93
#define GNUNET_MIN(a, b)
void GNUNET_CRYPTO_hash_file_cancel(struct GNUNET_CRYPTO_FileHashContext *fhc)
Cancel a file hashing operation.
struct GNUNET_ATS_PerformanceHandle * GNUNET_ATS_performance_init(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_ATS_AddressInformationCallback addr_info_cb, void *addr_info_cb_cls)
Get handle to access performance API of the ATS subsystem.
void GNUNET_ATS_performance_done(struct GNUNET_ATS_PerformanceHandle *ph)
Client is done using the ATS performance subsystem, release resources.
void GNUNET_BLOCK_context_destroy(struct GNUNET_BLOCK_Context *ctx)
Destroy the block context.
Definition: block.c:152
struct GNUNET_BLOCK_Context * GNUNET_BLOCK_context_create(const struct GNUNET_CONFIGURATION_Handle *cfg)
Create a block context.
Definition: block.c:131
GNUNET_BLOCK_EvaluationResult
Possible ways for how a block may relate to a query.
GNUNET_BLOCK_Type
Blocks in the datastore and the datacache must have a unique type.
@ GNUNET_BLOCK_EVALUATION_OK_LAST
Last possible valid result.
@ GNUNET_BLOCK_TYPE_FS_DBLOCK
Data block (leaf) in the CHK tree.
@ GNUNET_BLOCK_TYPE_FS_ONDEMAND
Type of a block representing a block to be encoded on demand from disk.
@ GNUNET_BLOCK_TYPE_FS_IBLOCK
Inner block in the CHK tree.
@ GNUNET_BLOCK_TYPE_ANY
Any type of block, used as a wildcard when searching.
@ GNUNET_BLOCK_TYPE_FS_UBLOCK
Type of a block representing any type of search result (universal).
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_filename(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be the name of a file or directory.
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_create(void)
Create a new configuration object.
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_size(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *size)
Get a configuration value that should be a size in bytes.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_yesno(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option)
Get a configuration value that should be in a set of "YES" or "NO".
struct GNUNET_CORE_Handle * GNUNET_CORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, void *cls, GNUNET_CORE_StartupCallback init, GNUNET_CORE_ConnectEventHandler connects, GNUNET_CORE_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Connect to the core service.
Definition: core_api.c:692
void GNUNET_CORE_disconnect(struct GNUNET_CORE_Handle *handle)
Disconnect from the core service.
Definition: core_api.c:730
int GNUNET_CRYPTO_eddsa_key_from_file(const char *filename, int do_create, struct GNUNET_CRYPTO_EddsaPrivateKey *pkey)
Create a new private key by reading it from a file.
void GNUNET_CRYPTO_eddsa_key_get_public(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Extract the public key for the given private key.
Definition: crypto_ecc.c:197
struct GNUNET_DATASTORE_Handle * GNUNET_DATASTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the datastore service.
void GNUNET_DATASTORE_disconnect(struct GNUNET_DATASTORE_Handle *h, int drop)
Disconnect from the datastore service (and free associated resources).
struct GNUNET_DHT_Handle * GNUNET_DHT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, unsigned int ht_len)
Initialize the connection with the DHT service.
Definition: dht_api.c:890
void GNUNET_DHT_disconnect(struct GNUNET_DHT_Handle *handle)
Shutdown connection with the DHT service.
Definition: dht_api.c:918
enum GNUNET_GenericReturnValue GNUNET_DISK_file_get_identifiers(const char *filename, uint64_t *dev, uint64_t *ino)
Obtain some unique identifiers for the given file that can be used to identify it in the local system...
Definition: disk.c:241
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
struct GNUNET_FS_Uri * GNUNET_FS_uri_loc_create(const struct GNUNET_FS_Uri *base_uri, const struct GNUNET_CRYPTO_EddsaPrivateKey *sign_key, struct GNUNET_TIME_Absolute expiration_time)
Construct a location URI (this peer will be used for the location).
Definition: fs_uri.c:879
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:678
struct GNUNET_CRYPTO_FileHashContext * GNUNET_CRYPTO_hash_file(enum GNUNET_SCHEDULER_Priority priority, const char *filename, size_t blocksize, GNUNET_CRYPTO_HashCompletedCallback callback, void *callback_cls)
Compute the hash of an entire file.
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.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_ERROR
@ 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.
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:355
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#define GNUNET_MQ_check_zero_termination(m)
Insert code for a "check_" function that verifies that a given variable-length message received over ...
void * cls
Closure for mv and cb.
#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:52
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
#define GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_GET
Request from client for list of indexed files.
#define GNUNET_MESSAGE_TYPE_FS_UNINDEX_OK
Reply to client indicating unindex receipt.
#define GNUNET_MESSAGE_TYPE_FS_START_SEARCH
Client asks FS service to start a (keyword) search.
#define GNUNET_MESSAGE_TYPE_FS_INDEX_START
Message sent by fs client to start indexing.
#define GNUNET_MESSAGE_TYPE_FS_PUT
P2P response with content or active migration of content.
#define GNUNET_MESSAGE_TYPE_FS_GET
P2P request for content (one FS to another).
#define GNUNET_MESSAGE_TYPE_FS_MIGRATION_STOP
Peer asks us to stop migrating content towards it for a while.
#define GNUNET_MESSAGE_TYPE_FS_UNINDEX
Request from client to unindex a file.
#define GNUNET_MESSAGE_TYPE_FS_INDEX_START_FAILED
Response to a request for start indexing that refuses.
#define GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGN
Message sent by fs client to request LOC signature.
#define GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGNATURE
Reply sent by fs service with LOC signature.
#define GNUNET_MESSAGE_TYPE_FS_INDEX_START_OK
Affirmative response to a request for start indexing.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:531
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:1296
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received,...
Definition: scheduler.c:1331
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
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:1269
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2244
@ GNUNET_SERVICE_OPTION_NONE
Use defaults.
#define GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT
Signature by which a peer affirms that it is providing a certain bit of content (used in LOCation URI...
struct GNUNET_STATISTICS_Handle * GNUNET_STATISTICS_create(const char *subsystem, const struct GNUNET_CONFIGURATION_Handle *cfg)
Get handle for the statistics service.
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.
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).
char * GNUNET_STRINGS_filename_expand(const char *fil)
Complete filename (a la shell) from abbrevition.
Definition: strings.c:482
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
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:263
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:542
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:464
#define _(String)
GNU gettext support macro.
Definition: platform.h:177
static GNUNET_CronTime last_transmission
Response from FS service with a result for a previous FS search.
Definition: fs.h:355
Doubly-linked list of requests we are performing on behalf of the same client.
struct ClientRequest * prev
This is a doubly-linked list.
struct GNUNET_SCHEDULER_Task * kill_task
Task scheduled to destroy the request.
struct ClientRequest * next
This is a doubly-linked list.
struct GSF_LocalClient * lc
Client list this request belongs to.
struct GSF_PendingRequest * pr
Request this entry represents.
Replies to be transmitted to the client.
size_t msize
Number of bytes in the response.
struct ClientResponse * prev
This is a doubly-linked list.
struct GSF_LocalClient * lc
Client list entry this response belongs to.
struct ClientResponse * next
This is a doubly-linked list.
struct ContentHashKey chk
Query and key of the top GNUNET_EC_IBlock.
Definition: fs_api.h:103
uint64_t file_length
Total size of the file in bytes.
Definition: fs_api.h:98
ATS Handle to obtain and/or modify performance information.
ATS performance characteristics for an address.
struct GNUNET_TIME_Relative delay
Delay.
32-bit bandwidth used for network exchange by GNUnet, in bytes per second.
Handle to an initialized block library.
Definition: block.c:55
Context for the core service connection.
Definition: core_api.c:78
Private ECC key encoded for transmission.
Context used when hashing a file.
Handle to the datastore service.
Connection to the DHT service.
Definition: dht_api.c:202
A Universal Resource Identifier (URI), opaque.
Definition: fs_api.h:166
union GNUNET_FS_Uri::@13 data
enum GNUNET_FS_UriType type
Type of the URI.
Definition: fs_api.h:170
struct Location loc
Information needed to retrieve a file including signed location (identity of a peer) of the content.
Definition: fs_api.h:217
struct FileIdentifier chk
Information needed to retrieve a file (content-hash-key plus file size).
Definition: fs_api.h:211
An address for communicating with a peer.
A 512-bit hashcode.
Values we track for load calculations.
Definition: load.c:36
Handle to a message queue.
Definition: mq.c:86
Message handler for a specific message type.
Header for all communications.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
The identity of the host (wraps the signing key of the peer).
struct GNUNET_CRYPTO_EddsaPublicKey public_key
Entry in list of pending tasks.
Definition: scheduler.c:135
Handle to a client that is connected to a service.
Definition: service.c:251
Handle to a service.
Definition: service.c:117
Handle for the service.
Time for absolute times used by GNUnet, in microseconds.
Time for relative time used by GNUnet, in microseconds.
uint64_t rel_value_us
The actual value.
A connected peer.
A local client.
struct IndexStartContext * isc_head
This is a doubly linked list.
struct ClientRequest * cr_head
Head of list of requests performed on behalf of this client right now.
struct ClientResponse * res_tail
Tail of linked list of responses.
struct ClientRequest * cr_tail
Tail of list of requests performed on behalf of this client right now.
struct GNUNET_MQ_Handle * mq
Queue for sending replies.
struct IndexStartContext * isc_tail
This is a doubly linked list.
struct ClientResponse * res_head
Head of linked list of responses.
struct GNUNET_SERVICE_Client * client
ID of the client.
Performance data kept for a peer.
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?
uint32_t respect_offered
How much respect did we (in total) offer for this request so far (estimate, because we might have the...
enum GNUNET_BLOCK_Type type
Type of the requested block.
uint32_t num_transmissions
Counter for how often this request has been transmitted (estimate, because we might have the same req...
uint32_t anonymity_level
Desired anonymity level.
struct GNUNET_HashCode query
Primary query hash for this request.
An active request.
Message to the datastore service asking about specific content.
Definition: datastore.h:141
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_DATASTORE_GET.
Definition: datastore.h:145
uint32_t hash_bitmap
Which of the optional hash codes are present at the end of the message? See GET_MESSAGE_BIT_xx consta...
Information we track while handling an index start request from a client.
struct GNUNET_CRYPTO_FileHashContext * fhc
Context for hashing of the file.
struct GNUNET_HashCode file_id
Hash of the contents of the file.
struct IndexStartContext * next
This is a doubly linked list.
struct IndexStartContext * prev
This is a doubly linked list.
struct GSF_LocalClient * lc
Context for transmitting confirmation to client.
char * filename
Name of the indexed file.
Message sent from a GNUnet (fs) publishing activity to the gnunet-fs-service to initiate indexing of ...
Definition: fs.h:152
uint64_t inode
Inode of the file on the given device, as seen by the client ("st_ino" field from "struct stat").
Definition: fs.h:178
struct GNUNET_HashCode file_id
Hash of the file that we would like to index.
Definition: fs.h:183
uint32_t reserved
For alignment.
Definition: fs.h:161
uint64_t device
ID of device containing the file, as seen by the client.
Definition: fs.h:170
struct GNUNET_TIME_Absolute expirationTime
Time when this location URI expires.
Definition: fs_api.h:126
struct GNUNET_CRYPTO_EddsaSignature contentSignature
Signature over the GNUNET_EC_FileIdentifier, peer identity and expiration time.
Definition: fs_api.h:132
struct GNUNET_PeerIdentity peer
Identity of the peer sharing the file.
Definition: fs_api.h:121
Message send by a peer that wants to be excluded from migration for a while.
Response from FS service with a result for a previous FS search.
Definition: fs.h:329
uint32_t type
Type of the block (in big endian).
Definition: fs.h:338
Message sent from a GNUnet (fs) publishing activity to sign a LOC URI.
Definition: fs.h:75
Message sent from the service with the signed LOC URI.
Definition: fs.h:108
struct GNUNET_CRYPTO_EddsaSignature signature
The requested signature.
Definition: fs.h:129
struct GNUNET_PeerIdentity peer
Identity of the peer sharing the file.
Definition: fs.h:134
uint32_t purpose
Purpose of the generated signature.
Definition: fs.h:119
struct GNUNET_TIME_AbsoluteNBO expiration_time
Expiration time that was actually used (rounded!).
Definition: fs.h:124
Message sent from a GNUnet (fs) search activity to the gnunet-service-fs to start a search.
Definition: fs.h:269
struct GNUNET_PeerIdentity target
If the request is for a DBLOCK or IBLOCK, this is the identity of the peer that is known to have a re...
Definition: fs.h:306
uint32_t type
Type of the content that we're looking for.
Definition: fs.h:289
struct GNUNET_HashCode query
Hash of the public key for UBLOCKs; Hash of the CHK-encoded block for DBLOCKS and IBLOCKS.
Definition: fs.h:312
uint32_t anonymity_level
Desired anonymity level, big-endian.
Definition: fs.h:294
struct GNUNET_MessageHeader header
Message type will be GNUNET_MESSAGE_TYPE_FS_START_SEARCH.
Definition: fs.h:273
uint32_t options
Bitmask with options.
Definition: fs.h:284
Message sent from a GNUnet (fs) unindexing activity to the gnunet-service-fs to indicate that a file ...
Definition: fs.h:227
struct GNUNET_HashCode file_id
Hash of the file that we will unindex.
Definition: fs.h:241
uint32_t reserved
Always zero.
Definition: fs.h:236
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.