GNUnet  0.17.6
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));
450  if (GNUNET_BLOCK_REPLY_OK_LAST != eval)
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,
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 
1045  const char *emsg = "hash mismatch";
1046  const size_t msize = strlen(emsg) + 1;
1047 
1049  msize,
1051  memcpy((char*) &msg[1], emsg, msize);
1052  GNUNET_MQ_send (lc->mq,
1053  env);
1055  GNUNET_free (isc);
1056  return;
1057  }
1058  signal_index_ok (isc);
1059 }
1060 
1061 
1068 static void
1070  const struct IndexStartMessage *ism)
1071 {
1072  struct GSF_LocalClient *lc = cls;
1073  struct IndexStartContext *isc;
1074  char *fn;
1075  uint64_t dev;
1076  uint64_t ino;
1077  uint64_t mydev;
1078  uint64_t myino;
1079 
1080  fn = GNUNET_STRINGS_filename_expand ((const char *) &ism[1]);
1081  GNUNET_assert (NULL != fn);
1082  dev = GNUNET_ntohll (ism->device);
1083  ino = GNUNET_ntohll (ism->inode);
1084  isc = GNUNET_new (struct IndexStartContext);
1085  isc->filename = fn;
1086  isc->file_id = ism->file_id;
1088  "Received START_INDEX message for file `%s'\n",
1089  isc->filename);
1090  isc->lc = lc;
1091  mydev = 0;
1092  myino = 0;
1093  if (((dev != 0) ||
1094  (ino != 0)) &&
1096  &mydev,
1097  &myino)) &&
1098  (dev == mydev) &&
1099  (ino == myino))
1100  {
1101  /* fast validation OK! */
1102  signal_index_ok (isc);
1103  return;
1104  }
1106  "Mismatch in file identifiers (%llu != %llu or %u != %u), need to hash.\n",
1107  (unsigned long long) ino,
1108  (unsigned long long) myino,
1109  (unsigned int) dev,
1110  (unsigned int) mydev);
1111  /* slow validation, need to hash full file (again) */
1113  lc->isc_tail,
1114  isc);
1116  isc->filename,
1119  isc);
1120  if (NULL == isc->fhc)
1121  hash_for_index_val (isc,
1122  NULL);
1123 }
1124 
1125 
1132 static void
1134  const struct GNUNET_MessageHeader *message)
1135 {
1136  struct GSF_LocalClient *lc = cls;
1137 
1140 }
1141 
1142 
1149 static void
1151  const struct UnindexMessage *um)
1152 {
1153  struct GSF_LocalClient *lc = cls;
1154  struct GNUNET_MQ_Envelope *env;
1155  struct GNUNET_MessageHeader *msg;
1156  int found;
1157 
1158  GNUNET_break (0 == um->reserved);
1159  found = GNUNET_FS_indexing_do_unindex (&um->file_id);
1161  "Client requested unindexing of file `%s': %s\n",
1162  GNUNET_h2s (&um->file_id),
1163  found ? "found" : "not found");
1164  env = GNUNET_MQ_msg (msg,
1166  GNUNET_MQ_send (lc->mq,
1167  env);
1169 }
1170 
1171 
1177 static void
1178 shutdown_task (void *cls)
1179 {
1181  if (NULL != GSF_core)
1182  {
1184  GSF_core = NULL;
1185  }
1186  if (NULL != GSF_ats)
1187  {
1189  GSF_ats = NULL;
1190  }
1191  GSF_put_done_ ();
1192  GSF_push_done_ ();
1194  GSF_plan_done ();
1197  GNUNET_NO);
1198  GSF_dsh = NULL;
1200  GSF_dht = NULL;
1202  GSF_block_ctx = NULL;
1204  block_cfg = NULL;
1206  GSF_stats = NULL;
1207  if (NULL != cover_age_task)
1208  {
1210  cover_age_task = NULL;
1211  }
1214  datastore_get_load = NULL;
1216  GSF_rt_entry_lifetime = NULL;
1217 }
1218 
1219 
1230 static void
1232  const struct GNUNET_PeerIdentity *my_identity)
1233 {
1234  if (0 != GNUNET_memcmp (&GSF_my_id,
1235  my_identity))
1236  {
1238  "Peer identity mismatch, refusing to start!\n");
1240  }
1241 }
1242 
1243 
1249 static int
1251 {
1252  struct GNUNET_MQ_MessageHandler no_p2p_handlers[] = {
1254  };
1255  struct GNUNET_MQ_MessageHandler p2p_handlers[] = {
1256  GNUNET_MQ_hd_var_size (p2p_get,
1258  struct GetMessage,
1259  NULL),
1260  GNUNET_MQ_hd_var_size (p2p_put,
1262  struct PutMessage,
1263  NULL),
1264  GNUNET_MQ_hd_fixed_size (p2p_migration_stop,
1266  struct MigrationStopMessage,
1267  NULL),
1269  };
1270  int anon_p2p_off;
1271  char *keyfile;
1272 
1273  /* this option is really only for testcases that need to disable
1274  _anonymous_ file-sharing for some reason */
1275  anon_p2p_off = (GNUNET_YES ==
1277  "fs",
1278  "DISABLE_ANON_TRANSFER"));
1279 
1280  if (GNUNET_OK !=
1282  "PEER",
1283  "PRIVATE_KEY",
1284  &keyfile))
1285  {
1287  _ (
1288  "FS service is lacking HOSTKEY configuration setting. Exiting.\n"));
1290  return GNUNET_SYSERR;
1291  }
1292  if (GNUNET_SYSERR ==
1294  GNUNET_YES,
1295  &pk))
1296  {
1298  "Failed to setup peer's private key\n");
1300  GNUNET_free (keyfile);
1301  return GNUNET_SYSERR;
1302  }
1303  GNUNET_free (keyfile);
1306 
1308  "I am peer %s\n",
1309  GNUNET_i2s (&GSF_my_id));
1310  GSF_core
1312  NULL,
1316  (GNUNET_YES == anon_p2p_off)
1317  ? no_p2p_handlers
1318  : p2p_handlers);
1319  if (NULL == GSF_core)
1320  {
1322  _ ("Failed to connect to `%s' service.\n"),
1323  "core");
1324  return GNUNET_SYSERR;
1325  }
1326  cover_age_task =
1329  NULL);
1333  NULL);
1334  return GNUNET_OK;
1335 }
1336 
1337 
1345 static void
1346 run (void *cls,
1347  const struct GNUNET_CONFIGURATION_Handle *cfg,
1349 {
1350  unsigned long long dqs;
1351 
1352  GSF_cfg = cfg;
1353  if (GNUNET_OK !=
1355  "fs",
1356  "DATASTORE_QUEUE_SIZE",
1357  &dqs))
1358  {
1360  "fs",
1361  "DATASTORE_QUEUE_SIZE");
1362  dqs = 32;
1363  }
1364  GSF_datastore_queue_size = (unsigned int) dqs;
1366  GNUNET_CONFIGURATION_get_value_yesno (cfg, "fs", "DELAY");
1368  if (NULL == GSF_dsh)
1369  {
1371  return;
1372  }
1377  GNUNET_assert (NULL != GSF_block_ctx);
1379  GSF_plan_init ();
1384  NULL);
1385  GSF_push_init_ ();
1386  GSF_put_init_ ();
1388  GSF_dsh)) ||
1389  (GNUNET_OK != main_init (cfg)))
1390  {
1392  shutdown_task (NULL);
1393  return;
1394  }
1395 }
1396 
1397 
1402  ("fs",
1404  &run,
1407  NULL,
1408  GNUNET_MQ_hd_var_size (client_index_start,
1410  struct IndexStartMessage,
1411  NULL),
1412  GNUNET_MQ_hd_fixed_size (client_index_list_get,
1414  struct GNUNET_MessageHeader,
1415  NULL),
1416  GNUNET_MQ_hd_fixed_size (client_unindex,
1418  struct UnindexMessage,
1419  NULL),
1420  GNUNET_MQ_hd_var_size (client_start_search,
1422  struct SearchMessage,
1423  NULL),
1424  GNUNET_MQ_hd_fixed_size (client_loc_sign,
1427  NULL),
1429 
1430 
1431 /* 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
GNUNET_BLOCK_Type
WARNING: This header is generated! In order to add DHT block types, you must register them in GANA,...
@ GNUNET_BLOCK_TYPE_FS_UBLOCK
Type of a block representing any type of search result (universal).
@ GNUNET_BLOCK_TYPE_FS_IBLOCK
Inner block in the CHK tree.
@ GNUNET_BLOCK_TYPE_ANY
Identifier for any block.
@ GNUNET_BLOCK_TYPE_FS_ONDEMAND
Type of a block representing a block to be encoded on demand from disk.
@ GNUNET_BLOCK_TYPE_FS_DBLOCK
Data block (leaf) in the CHK tree.
#define GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT
Signature by which a peer affirms that it is providing a certain bit of content for use in LOCation U...
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:84
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 start_p2p_processing(void *cls, struct GSF_PendingRequest *pr, enum GNUNET_BLOCK_ReplyEvaluationResult result)
We're done with the local lookup, now consider P2P processing (depending on request options and resul...
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 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.
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.
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.
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_response_handler(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.
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.
#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).
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.
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.
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.
Core service; the main API for encrypted P2P communications.
API to the DHT service.
Helper library for interning of peer identifiers.
Constants for network protocols.
API to create, modify and access statistics.
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.
GNUNET_BLOCK_ReplyEvaluationResult
Possible ways for how a block may relate to a query.
void GNUNET_BLOCK_context_destroy(struct GNUNET_BLOCK_Context *ctx)
Destroy the block context.
Definition: block.c:156
struct GNUNET_BLOCK_Context * GNUNET_BLOCK_context_create(const struct GNUNET_CONFIGURATION_Handle *cfg)
Create a block context.
Definition: block.c:140
@ GNUNET_BLOCK_REPLY_OK_LAST
Last possible valid result.
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
enum GNUNET_GenericReturnValue 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:1039
void GNUNET_DHT_disconnect(struct GNUNET_DHT_Handle *handle)
Shutdown connection with the DHT service.
Definition: dht_api.c:1062
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:885
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:684
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.
#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
void * cls
Closure for mv and cb.
void GNUNET_CRYPTO_hash_file_cancel(struct GNUNET_CRYPTO_FileHashContext *fhc)
Cancel a file hashing operation.
#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.
#define GNUNET_MIN(a, b)
@ GNUNET_SCHEDULER_PRIORITY_IDLE
Run when otherwise idle.
@ GNUNET_OK
Definition: gnunet_common.h:99
@ GNUNET_YES
@ GNUNET_NO
Definition: gnunet_common.h:98
@ GNUNET_SYSERR
Definition: gnunet_common.h:97
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:302
#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 ...
#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:56
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:71
#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:533
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:1281
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:1316
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:957
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:1254
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2248
@ GNUNET_SERVICE_OPTION_NONE
Use defaults.
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:495
#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:435
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:736
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:637
#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:237
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.