GNUnet  0.10.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 (GNUNET_TIME_UNIT_SECONDS, 5)
63 
67 #define INSANE_STATISTICS GNUNET_NO
68 
69 
70 
76 {
77 
82 
87 
92 
97 
102 
103 };
104 
105 
111 {
116 
121 
126 
130  size_t msize;
131 };
132 
133 
139 {
140 
145 
150 
154  char *filename;
155 
160 
165 
169  struct GNUNET_HashCode file_id;
170 
171 };
172 
173 
178 {
179 
184 
189 
195 
201 
206 
211 
216 
221 
222 };
223 
224 
225 /* ****************************** globals ****************************** */
226 
231 
236 
241 
246 
251 
257 
262 
263 
275 
280 
286 
292 
297 
303 
308 
313 
314 /* ***************************** locals ******************************* */
315 
320 
325 
330 
335 
336 
345 static void *
346 client_connect_cb (void *cls,
347  struct GNUNET_SERVICE_Client *client,
348  struct GNUNET_MQ_Handle *mq)
349 {
350  struct GSF_LocalClient *pos;
351 
352  pos = GNUNET_new (struct GSF_LocalClient);
353  pos->client = client;
354  pos->mq = mq;
355  return pos;
356 }
357 
358 
364 static void
366 {
367  struct ClientRequest *cr = cls;
368  struct GSF_LocalClient *lc = cr->lc;
369 
370  cr->kill_task = NULL;
372  lc->cr_tail,
373  cr);
375  GNUNET_YES);
376  GNUNET_STATISTICS_update (GSF_stats,
377  gettext_noop ("# client searches active"),
378  -1,
379  GNUNET_NO);
380  GNUNET_free (cr);
381 }
382 
383 
402 static void
405  struct GSF_PendingRequest *pr,
406  uint32_t reply_anonymity_level,
409  enum GNUNET_BLOCK_Type type,
410  const void *data,
411  size_t data_len)
412 {
413  struct ClientRequest *cr = cls;
414  struct GSF_LocalClient *lc;
415  struct GNUNET_MQ_Envelope *env;
416  struct ClientPutMessage *pm;
417  const struct GSF_PendingRequestData *prd;
418 
419  if (NULL == data)
420  {
421  /* local-only request, with no result, clean up. */
422  if (NULL == cr->kill_task)
424  cr);
425  return;
426  }
429  if ((prd->type != type) && (prd->type != GNUNET_BLOCK_TYPE_ANY))
430  {
431  GNUNET_break (0);
432  return;
433  }
434  GNUNET_STATISTICS_update (GSF_stats,
436  ("# replies received for local clients"), 1,
437  GNUNET_NO);
438  GNUNET_assert (pr == cr->pr);
439  lc = cr->lc;
440  env = GNUNET_MQ_msg_extra (pm,
441  data_len,
443  pm->type = htonl (type);
444  pm->expiration = GNUNET_TIME_absolute_hton (expiration);
445  pm->last_transmission = GNUNET_TIME_absolute_hton (last_transmission);
446  pm->num_transmissions = htonl (prd->num_transmissions);
447  pm->respect_offered = htonl (prd->respect_offered);
448  GNUNET_memcpy (&pm[1],
449  data,
450  data_len);
451  GNUNET_MQ_send (lc->mq,
452  env);
454  "Queued reply to query `%s' for local client\n",
455  GNUNET_h2s (&prd->query));
457  {
459  "Evaluation %d - keeping query alive\n",
460  (int) eval);
461  return;
462  }
463  if (NULL == cr->kill_task)
465  cr);
466 }
467 
468 
477 static void
479  struct GNUNET_SERVICE_Client *client,
480  void *app_ctx)
481 {
482  struct GSF_LocalClient *lc = app_ctx;
483  struct IndexStartContext *isc;
484  struct ClientRequest *cr;
485  struct ClientResponse *res;
486 
487  while (NULL != (cr = lc->cr_head))
488  {
489  if (NULL != cr->kill_task)
492  }
493  while (NULL != (res = lc->res_head))
494  {
496  lc->res_tail,
497  res);
498  GNUNET_free (res);
499  }
500  while (NULL != (isc = lc->isc_head))
501  {
503  lc->isc_tail,
504  isc);
506  GNUNET_free (isc);
507  }
508  GNUNET_free (lc);
509 }
510 
511 
512 
513 
514 
520 static void
522 {
525  cover_age_task =
528  NULL);
529 }
530 
531 
538 void
540 {
541  struct GNUNET_TIME_Relative delay;
542 
543  delay = GNUNET_TIME_absolute_get_duration (start);
544  GNUNET_LOAD_update (datastore_get_load, delay.rel_value_us);
545 }
546 
547 
558 int
559 GSF_test_get_load_too_high_ (uint32_t priority)
560 {
561  double ld;
562 
563  ld = GNUNET_LOAD_get_load (datastore_get_load);
564  if (ld < 1)
565  return GNUNET_SYSERR;
566  if (ld <= priority)
567  return GNUNET_NO;
568  return GNUNET_YES;
569 }
570 
571 
583 static void
584 update_latencies (void *cls,
585  const struct GNUNET_HELLO_Address *address,
586  int active,
587  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
588  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
589  const struct GNUNET_ATS_Properties *prop)
590 {
591  if (NULL == address)
592  {
593  /* ATS service temporarily disconnected */
594  return;
595  }
596 
597  if (GNUNET_YES != active)
598  return;
599  GSF_update_peer_latency_ (&address->peer,
600  prop->delay);
601  GSF_avg_latency.rel_value_us =
602  (GSF_avg_latency.rel_value_us * 31 +
603  GNUNET_MIN (5000, prop->delay.rel_value_us)) / 32;
604  GNUNET_STATISTICS_set (GSF_stats,
605  gettext_noop ("# running average P2P latency (ms)"),
606  GSF_avg_latency.rel_value_us / 1000LL,
607  GNUNET_NO);
608 }
609 
610 
619 static int
620 check_p2p_put (void *cls,
621  const struct PutMessage *put)
622 {
623  enum GNUNET_BLOCK_Type type;
624 
625  type = ntohl (put->type);
626  if (GNUNET_BLOCK_TYPE_FS_ONDEMAND == type)
627  {
628  GNUNET_break_op (0);
629  return GNUNET_SYSERR;
630  }
631  return GNUNET_OK;
632 }
633 
634 
644 static void
646  const struct GNUNET_PeerIdentity *peer,
647  struct GSF_ConnectedPeer *cp,
648  const struct GSF_PeerPerformanceData *ppd)
649 {
650  struct GSF_PendingRequest *pr = cls;
651 
652  if (GNUNET_YES !=
654  {
655 #if INSANE_STATISTICS
656  GNUNET_STATISTICS_update (GSF_stats,
657  gettext_noop ("# Loopback routes suppressed"), 1,
658  GNUNET_NO);
659 #endif
660  return;
661  }
662  GSF_plan_add_ (cp,
663  pr);
664 }
665 
666 
677 void
679  struct GSF_PendingRequest *pr,
681 {
682  if (GNUNET_BLOCK_EVALUATION_OK_LAST == result)
683  return; /* we're done... */
684  if (GNUNET_YES !=
686  return; /* request is not actually active, skip! */
688  pr);
689 }
690 
691 
700 static int
701 check_p2p_get (void *cls,
702  const struct GetMessage *gm)
703 {
704  size_t msize;
705  unsigned int bm;
706  unsigned int bits;
707  size_t bfsize;
708 
709  msize = ntohs (gm->header.size);
710  bm = ntohl (gm->hash_bitmap);
711  bits = 0;
712  while (bm > 0)
713  {
714  if (1 == (bm & 1))
715  bits++;
716  bm >>= 1;
717  }
718  if (msize < sizeof (struct GetMessage) + bits * sizeof (struct GNUNET_PeerIdentity))
719  {
720  GNUNET_break_op (0);
721  return GNUNET_SYSERR;
722  }
723  bfsize = msize - sizeof (struct GetMessage) - bits * sizeof (struct GNUNET_PeerIdentity);
724  /* bfsize must be power of 2, check! */
725  if (0 != ((bfsize - 1) & bfsize))
726  {
727  GNUNET_break_op (0);
728  return GNUNET_SYSERR;
729  }
730  return GNUNET_OK;
731 }
732 
733 
744 static void
746  struct GSF_PendingRequest *pr,
748 {
749  struct GSF_LocalClient *lc = cls;
750  struct GSF_PendingRequestData *prd;
751 
753  if (GNUNET_BLOCK_EVALUATION_OK_LAST == result)
754  return; /* we're done, 'pr' was already destroyed... */
757  "Finished database lookup for local request `%s' with result %d\n",
758  GNUNET_h2s (&prd->query),
759  result);
760  if (0 == prd->anonymity_level)
761  {
762  switch (prd->type)
763  {
766  /* the above block types MAY be available via 'cadet' */
768  "Considering cadet-based download for block\n");
769  GSF_cadet_lookup_ (pr);
770  break;
772  /* the above block types are in the DHT */
774  "Considering DHT-based search for block\n");
775  GSF_dht_lookup_ (pr);
776  break;
777  default:
778  GNUNET_break (0);
779  break;
780  }
781  }
783  pr,
784  result);
785 }
786 
787 
796 static int
798  const struct SearchMessage *sm)
799 {
800  uint16_t msize;
801 
802  msize = ntohs (sm->header.size) - sizeof (struct SearchMessage);
803  if (0 != msize % sizeof (struct GNUNET_HashCode))
804  {
805  GNUNET_break (0);
806  return GNUNET_SYSERR;
807  }
808  return GNUNET_OK;
809 }
810 
811 
822 static void
824  const struct SearchMessage *sm)
825 {
826  static struct GNUNET_PeerIdentity all_zeros;
827  struct GSF_LocalClient *lc = cls;
828  struct ClientRequest *cr;
829  struct GSF_PendingRequestData *prd;
830  uint16_t msize;
831  unsigned int sc;
832  enum GNUNET_BLOCK_Type type;
834 
835  GNUNET_STATISTICS_update (GSF_stats,
836  gettext_noop ("# client searches received"),
837  1,
838  GNUNET_NO);
839  msize = ntohs (sm->header.size) - sizeof (struct SearchMessage);
840  sc = msize / sizeof (struct GNUNET_HashCode);
841  type = ntohl (sm->type);
843  "Received request for `%s' of type %u from local client\n",
844  GNUNET_h2s (&sm->query),
845  (unsigned int) type);
846  cr = NULL;
847  /* detect duplicate UBLOCK requests */
848  if ((type == GNUNET_BLOCK_TYPE_FS_UBLOCK) ||
849  (type == GNUNET_BLOCK_TYPE_ANY))
850  {
851  cr = lc->cr_head;
852  while (NULL != cr)
853  {
854  prd = GSF_pending_request_get_data_ (cr->pr);
855  /* only unify with queries that hae not yet started local processing
856  (SEARCH_MESSAGE_OPTION_CONTINUED was always set) and that have a
857  matching query and type */
858  if ((GNUNET_YES != prd->has_started) &&
859  (0 != memcmp (&prd->query,
860  &sm->query,
861  sizeof (struct GNUNET_HashCode))) &&
862  (prd->type == type))
863  break;
864  cr = cr->next;
865  }
866  }
867  if (NULL != cr)
868  {
870  "Have existing request, merging content-seen lists.\n");
872  (const struct GNUNET_HashCode *) &sm[1],
873  sc);
874  GNUNET_STATISTICS_update (GSF_stats,
875  gettext_noop ("# client searches updated (merged content seen list)"),
876  1,
877  GNUNET_NO);
878  }
879  else
880  {
881  GNUNET_STATISTICS_update (GSF_stats,
882  gettext_noop ("# client searches active"),
883  1,
884  GNUNET_NO);
885  cr = GNUNET_new (struct ClientRequest);
886  cr->lc = lc;
888  lc->cr_tail,
889  cr);
890  options = GSF_PRO_LOCAL_REQUEST;
891  if (0 != (SEARCH_MESSAGE_OPTION_LOOPBACK_ONLY & ntohl (sm->options)))
892  options |= GSF_PRO_LOCAL_ONLY;
893  cr->pr = GSF_pending_request_create_ (options, type,
894  &sm->query,
895  (0 !=
896  memcmp (&sm->target,
897  &all_zeros,
898  sizeof (struct GNUNET_PeerIdentity)))
899  ? &sm->target : NULL, NULL, 0,
900  0 /* bf */ ,
901  ntohl (sm->anonymity_level),
902  0 /* priority */ ,
903  0 /* ttl */ ,
904  0 /* sender PID */ ,
905  0 /* origin PID */ ,
906  (const struct GNUNET_HashCode *) &sm[1], sc,
908  cr);
909  }
910  if (0 != (SEARCH_MESSAGE_OPTION_CONTINUED & ntohl (sm->options)))
911  {
913  return;
914  }
916  GSF_local_lookup_ (cr->pr,
918  lc);
919 }
920 
921 
928 static void
930  const struct RequestLocSignatureMessage *msg)
931 {
932  struct GSF_LocalClient *lc = cls;
933  struct GNUNET_FS_Uri base;
934  struct GNUNET_FS_Uri *loc;
935  struct GNUNET_MQ_Envelope *env;
936  struct ResponseLocSignatureMessage *resp;
937 
939  ntohl (msg->purpose));
940  base.type = GNUNET_FS_URI_CHK;
941  base.data.chk.chk = msg->chk;
943  loc = GNUNET_FS_uri_loc_create (&base,
944  pk,
946  env = GNUNET_MQ_msg (resp,
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  _("Hash mismatch trying to index file `%s' which does not have hash `%s'\n"),
1041  isc->filename,
1042  GNUNET_h2s (&isc->file_id));
1043  env = GNUNET_MQ_msg (msg,
1045  GNUNET_MQ_send (lc->mq,
1046  env);
1048  GNUNET_free (isc);
1049  return;
1050  }
1051  signal_index_ok (isc);
1052 }
1053 
1054 
1061 static void
1063  const struct IndexStartMessage *ism)
1064 {
1065  struct GSF_LocalClient *lc = cls;
1066  struct IndexStartContext *isc;
1067  char *fn;
1068  uint64_t dev;
1069  uint64_t ino;
1070  uint64_t mydev;
1071  uint64_t myino;
1072 
1073  fn = GNUNET_STRINGS_filename_expand ((const char *) &ism[1]);
1074  GNUNET_assert (NULL != fn);
1075  dev = GNUNET_ntohll (ism->device);
1076  ino = GNUNET_ntohll (ism->inode);
1077  isc = GNUNET_new (struct IndexStartContext);
1078  isc->filename = fn;
1079  isc->file_id = ism->file_id;
1081  "Received START_INDEX message for file `%s'\n",
1082  isc->filename);
1083  isc->lc = lc;
1084  mydev = 0;
1085  myino = 0;
1086  if ( ( (dev != 0) ||
1087  (ino != 0) ) &&
1089  &mydev,
1090  &myino)) &&
1091  (dev == mydev) &&
1092  (ino == myino) )
1093  {
1094  /* fast validation OK! */
1095  signal_index_ok (isc);
1096  return;
1097  }
1099  "Mismatch in file identifiers (%llu != %llu or %u != %u), need to hash.\n",
1100  (unsigned long long) ino,
1101  (unsigned long long) myino,
1102  (unsigned int) dev,
1103  (unsigned int) mydev);
1104  /* slow validation, need to hash full file (again) */
1106  lc->isc_tail,
1107  isc);
1109  isc->filename,
1112  isc);
1113  if (NULL == isc->fhc)
1114  hash_for_index_val (isc,
1115  NULL);
1116 }
1117 
1118 
1125 static void
1127  const struct GNUNET_MessageHeader *message)
1128 {
1129  struct GSF_LocalClient *lc = cls;
1130 
1133 }
1134 
1135 
1142 static void
1144  const struct UnindexMessage *um)
1145 {
1146  struct GSF_LocalClient *lc = cls;
1147  struct GNUNET_MQ_Envelope *env;
1148  struct GNUNET_MessageHeader *msg;
1149  int found;
1150 
1151  GNUNET_break (0 == um->reserved);
1152  found = GNUNET_FS_indexing_do_unindex (&um->file_id);
1154  "Client requested unindexing of file `%s': %s\n",
1155  GNUNET_h2s (&um->file_id),
1156  found ? "found" : "not found");
1157  env = GNUNET_MQ_msg (msg,
1159  GNUNET_MQ_send (lc->mq,
1160  env);
1162 }
1163 
1164 
1170 static void
1171 shutdown_task (void *cls)
1172 {
1174  if (NULL != GSF_core)
1175  {
1176  GNUNET_CORE_disconnect (GSF_core);
1177  GSF_core = NULL;
1178  }
1179  if (NULL != GSF_ats)
1180  {
1181  GNUNET_ATS_performance_done (GSF_ats);
1182  GSF_ats = NULL;
1183  }
1184  GSF_put_done_ ();
1185  GSF_push_done_ ();
1187  GSF_plan_done ();
1189  GNUNET_DATASTORE_disconnect (GSF_dsh,
1190  GNUNET_NO);
1191  GSF_dsh = NULL;
1192  GNUNET_DHT_disconnect (GSF_dht);
1193  GSF_dht = NULL;
1194  GNUNET_BLOCK_context_destroy (GSF_block_ctx);
1195  GSF_block_ctx = NULL;
1196  GNUNET_CONFIGURATION_destroy (block_cfg);
1197  block_cfg = NULL;
1198  GNUNET_STATISTICS_destroy (GSF_stats, GNUNET_NO);
1199  GSF_stats = NULL;
1200  if (NULL != cover_age_task)
1201  {
1202  GNUNET_SCHEDULER_cancel (cover_age_task);
1203  cover_age_task = NULL;
1204  }
1206  GNUNET_LOAD_value_free (datastore_get_load);
1207  datastore_get_load = NULL;
1208  GNUNET_LOAD_value_free (GSF_rt_entry_lifetime);
1209  GSF_rt_entry_lifetime = NULL;
1210 }
1211 
1212 
1223 static void
1225  const struct GNUNET_PeerIdentity *my_identity)
1226 {
1227  if (0 != GNUNET_memcmp (&GSF_my_id,
1228  my_identity))
1229  {
1231  "Peer identity mismatch, refusing to start!\n");
1233  }
1234 }
1235 
1236 
1242 static int
1244 {
1245  struct GNUNET_MQ_MessageHandler no_p2p_handlers[] = {
1247  };
1248  struct GNUNET_MQ_MessageHandler p2p_handlers[] = {
1249  GNUNET_MQ_hd_var_size (p2p_get,
1251  struct GetMessage,
1252  NULL),
1253  GNUNET_MQ_hd_var_size (p2p_put,
1255  struct PutMessage,
1256  NULL),
1257  GNUNET_MQ_hd_fixed_size (p2p_migration_stop,
1259  struct MigrationStopMessage,
1260  NULL),
1262  };
1263  int anon_p2p_off;
1264  char *keyfile;
1265 
1266  /* this option is really only for testcases that need to disable
1267  _anonymous_ file-sharing for some reason */
1268  anon_p2p_off = (GNUNET_YES ==
1270  "fs",
1271  "DISABLE_ANON_TRANSFER"));
1272 
1273  if (GNUNET_OK !=
1275  "PEER",
1276  "PRIVATE_KEY",
1277  &keyfile))
1278  {
1280  _("FS service is lacking HOSTKEY configuration setting. Exiting.\n"));
1282  return GNUNET_SYSERR;
1283  }
1285  GNUNET_free (keyfile);
1286  GNUNET_assert (NULL != pk);
1289 
1291  "I am peer %s\n",
1292  GNUNET_i2s (&GSF_my_id));
1293  GSF_core
1294  = GNUNET_CORE_connect (GSF_cfg,
1295  NULL,
1299  (GNUNET_YES == anon_p2p_off)
1300  ? no_p2p_handlers
1301  : p2p_handlers);
1302  if (NULL == GSF_core)
1303  {
1305  _("Failed to connect to `%s' service.\n"),
1306  "core");
1307  return GNUNET_SYSERR;
1308  }
1309  cover_age_task =
1312  NULL);
1313  datastore_get_load = GNUNET_LOAD_value_init (DATASTORE_LOAD_AUTODECLINE);
1316  NULL);
1317  return GNUNET_OK;
1318 }
1319 
1320 
1328 static void
1329 run (void *cls,
1330  const struct GNUNET_CONFIGURATION_Handle *cfg,
1332 {
1333  unsigned long long dqs;
1334 
1335  GSF_cfg = cfg;
1336  if (GNUNET_OK !=
1338  "fs",
1339  "DATASTORE_QUEUE_SIZE",
1340  &dqs))
1341  {
1343  "fs",
1344  "DATASTORE_QUEUE_SIZE");
1345  dqs = 32;
1346  }
1347  GSF_datastore_queue_size = (unsigned int) dqs;
1349  GNUNET_CONFIGURATION_get_value_yesno (cfg, "fs", "DELAY");
1350  GSF_dsh = GNUNET_DATASTORE_connect (cfg);
1351  if (NULL == GSF_dsh)
1352  {
1354  return;
1355  }
1356  GSF_rt_entry_lifetime = GNUNET_LOAD_value_init (GNUNET_TIME_UNIT_FOREVER_REL);
1357  GSF_stats = GNUNET_STATISTICS_create ("fs", cfg);
1358  block_cfg = GNUNET_CONFIGURATION_create ();
1359  GSF_block_ctx = GNUNET_BLOCK_context_create (block_cfg);
1360  GNUNET_assert (NULL != GSF_block_ctx);
1361  GSF_dht = GNUNET_DHT_connect (cfg, FS_DHT_HT_SIZE);
1362  GSF_plan_init ();
1365  GSF_ats = GNUNET_ATS_performance_init (GSF_cfg,
1367  NULL);
1368  GSF_push_init_ ();
1369  GSF_put_init_ ();
1370  if ( (GNUNET_OK != GNUNET_FS_indexing_init (cfg,
1371  GSF_dsh)) ||
1372  (GNUNET_OK != main_init (cfg)) )
1373  {
1375  shutdown_task (NULL);
1376  return;
1377  }
1378 }
1379 
1380 
1385 ("fs",
1387  &run,
1390  NULL,
1391  GNUNET_MQ_hd_var_size (client_index_start,
1393  struct IndexStartMessage,
1394  NULL),
1395  GNUNET_MQ_hd_fixed_size (client_index_list_get,
1397  struct GNUNET_MessageHeader,
1398  NULL),
1399  GNUNET_MQ_hd_fixed_size (client_unindex,
1401  struct UnindexMessage,
1402  NULL),
1403  GNUNET_MQ_hd_var_size (client_start_search,
1405  struct SearchMessage,
1406  NULL),
1407  GNUNET_MQ_hd_fixed_size (client_loc_sign,
1410  NULL),
1412 
1413 
1414 /* end of gnunet-service-fs.c */
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct GNUNET_BLOCK_Context * GNUNET_BLOCK_context_create(const struct GNUNET_CONFIGURATION_Handle *cfg)
Create a block context.
Definition: block.c:132
API to handle &#39;connected peers&#39;.
struct ClientRequest * prev
This is a doubly-linked list.
int GNUNET_FS_indexing_do_unindex(const struct GNUNET_HashCode *fid)
Remove a file from the index.
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.
struct ContentHashKey chk
Query and key of the top GNUNET_EC_IBlock.
Definition: fs_api.h:104
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
Handle to an initialized block library.
Definition: block.c:54
static struct GNUNET_CRYPTO_EddsaPrivateKey * pk
Private key of this peer.
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
int GSF_enable_randomized_delays
Are we introducing randomized delays for better anonymity?
static char * expiration
Credential TTL.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:670
void GSF_plan_add_(struct GSF_ConnectedPeer *cp, struct GSF_PendingRequest *pr)
Create a new query plan entry.
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_DATASTORE_GET.
Definition: datastore.h:148
struct FileIdentifier chk
Information needed to retrieve a file (content-hash-key plus file size).
Definition: fs_api.h:215
uint64_t rel_value_us
The actual value.
struct GNUNET_LOAD_Value * GNUNET_LOAD_value_init(struct GNUNET_TIME_Relative autodecline)
Create a new load value.
Definition: load.c:125
void GSF_plan_done()
Shutdown plan subsystem.
uint32_t reserved
Always zero.
Definition: fs.h:242
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:867
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
static void handle_client_start_search(void *cls, const struct SearchMessage *sm)
Handle GNUNET_MESSAGE_TYPE_FS_START_SEARCH-message (search request from client).
void GSF_update_datastore_delay_(struct GNUNET_TIME_Absolute start)
We&#39;ve just now completed a datastore request.
Any type of block, used as a wildcard when searching.
static GNUNET_CronTime last_transmission
Context for the core service connection.
Definition: core_api.c:78
void GSF_connected_peer_init_()
Initialize peer management subsystem.
Response from FS service with a result for a previous FS search.
Definition: fs.h:336
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
uint32_t num_transmissions
Counter for how often this request has been transmitted (estimate, because we might have the same req...
Handle to a service.
Definition: service.c:116
GNUNET_BLOCK_Type
Blocks in the datastore and the datacache must have a unique type.
struct IndexStartContext * next
This is a doubly linked list.
uint32_t purpose
Requested signature purpose.
Definition: fs.h:86
double GSF_current_priorities
Typical priorities we&#39;re seeing from other peers right now.
void GNUNET_FS_indexing_done()
Shutdown the module.
Replies to be transmitted to the client.
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, or when GNUNET_SCHEDULER_shutdown() is being invoked.
Definition: scheduler.c:1293
void GSF_put_done_()
Shutdown the module.
struct IndexStartContext * isc_head
This is a doubly linked list.
#define GNUNET_MESSAGE_TYPE_FS_INDEX_START_FAILED
Response to a request for start indexing that refuses.
struct GNUNET_STATISTICS_Handle * GNUNET_STATISTICS_create(const char *subsystem, const struct GNUNET_CONFIGURATION_Handle *cfg)
Get handle for the statistics service.
void GSF_peer_disconnect_handler(void *cls, const struct GNUNET_PeerIdentity *peer, void *internal_cls)
A peer disconnected from us.
static int start
Set if we are to start default services (including ARM).
Definition: gnunet-arm.c:39
static struct GNUNET_LOAD_Value * datastore_get_load
Datastore &#39;GET&#39; load tracking.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
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).
static void client_disconnect_cb(void *cls, struct GNUNET_SERVICE_Client *client, void *app_ctx)
A client disconnected from us.
struct GSF_PendingRequest * pr
Request this entry represents.
uint32_t options
Bitmask with options.
Definition: fs.h:292
#define GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_GET
Request from client for list of indexed files.
struct GNUNET_MQ_Handle * mq
Queue for sending replies.
uint32_t anonymity_level
Desired anonymity level.
double GNUNET_LOAD_get_load(struct GNUNET_LOAD_Value *load)
Get the current load.
Definition: load.c:202
void GSF_cadet_stop_server(void)
Shutdown subsystem for non-anonymous file-sharing.
struct GNUNET_ATS_PerformanceHandle * GSF_ats
Handle to ATS service.
definitions for the entire fs module
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
void GNUNET_ATS_performance_done(struct GNUNET_ATS_PerformanceHandle *ph)
Client is done using the ATS performance subsystem, release resources.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
#define COVER_AGE_FREQUENCY
How quickly do we age cover traffic? At the given time interval, remaining cover traffic counters are...
uint64_t file_length
Size of the shared file (to be signed).
Definition: fs.h:101
unsigned int GSF_cover_query_count
How many query messages have we received &#39;recently&#39; that have not yet been claimed as cover traffic...
struct GNUNET_DHT_Handle * GSF_dht
Handle for DHT operations.
struct GNUNET_STATISTICS_Handle * GSF_stats
Handle for reporting statistics.
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
char * filename
Name of the indexed file.
struct GNUNET_TIME_AbsoluteNBO last_transmission
When was the last time we&#39;ve tried to download this block? (FOREVER if unknown/not relevant) ...
Definition: fs.h:386
int 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:323
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static int check_p2p_get(void *cls, const struct GetMessage *gm)
Check P2P "GET" request.
struct GNUNET_PeerIdentity peer
Identity of the peer sharing the file.
Definition: fs_api.h:123
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_create(void)
Create a new configuration object.
static struct GNUNET_PeerIdentity my_identity
Identity of this peer.
static int main_init(const struct GNUNET_CONFIGURATION_Handle *c)
Process fs requests.
struct IndexStartContext * isc_tail
This is a doubly linked list.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
struct ClientRequest * next
This is a doubly-linked list.
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
struct GNUNET_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.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:524
Handle for the service.
#define GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGNATURE
Reply sent by fs service with LOC signature.
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:314
struct GNUNET_SCHEDULER_Task * kill_task
Task scheduled to destroy the request.
Message sent from a GNUnet (fs) publishing activity to the gnunet-fs-service to initiate indexing of ...
Definition: fs.h:153
ATS performance characteristics for an address.
const struct GNUNET_CONFIGURATION_Handle * GSF_cfg
Our configuration.
void GSF_iterate_connected_peers_(GSF_ConnectedPeerIterator it, void *it_cls)
Iterate over all connected peers.
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.
void GSF_pending_request_init_()
Setup the subsystem.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Type of a block representing a block to be encoded on demand from disk.
Connection to the DHT service.
Definition: dht_api.c:205
int GNUNET_FS_indexing_init(const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_DATASTORE_Handle *d)
Initialize the indexing submodule.
#define GNUNET_MESSAGE_TYPE_FS_INDEX_START_OK
Affirmative response to a request for start indexing.
void GNUNET_FS_indexing_send_list(struct GNUNET_MQ_Handle *mq)
Transmit information about indexed files to mq.
void GNUNET_LOAD_update(struct GNUNET_LOAD_Value *load, uint64_t data)
Update the current load.
Definition: load.c:238
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
struct GNUNET_HashCode query
Primary query hash for this request.
Information we track while handling an index start request from a client.
Handle to a client that is connected to a service.
Definition: service.c:249
struct GNUNET_HashCode query
Hash of the public key for UBLOCKs; Hash of the CHK-encoded block for DBLOCKS and IBLOCKS...
Definition: fs.h:320
A local client.
void GSF_push_init_()
Setup the module.
API to handle pending requests.
struct GNUNET_TIME_AbsoluteNBO expiration
When does this result expire?
Definition: fs.h:380
static void handle_client_unindex(void *cls, const struct UnindexMessage *um)
Handle UNINDEX-message.
Public data (in the sense of not encapsulated within &#39;gnunet-service-fs_pr&#39;, not in the sense of netw...
#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...
#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
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:1246
API to manage query plan.
void GSF_update_peer_latency_(const struct GNUNET_PeerIdentity *id, struct GNUNET_TIME_Relative latency)
Update the latency information kept for the given peer.
static void 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.
#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_memcpy(dst, src, n)
void * cls
Closure for mv and cb.
static void run(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_SERVICE_Handle *service)
Process fs requests.
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
int GSF_pending_request_test_active_(struct GSF_PendingRequest *pr)
Check if the given request is still active.
static void start_p2p_processing(void *cls, struct GSF_PendingRequest *pr, enum GNUNET_BLOCK_EvaluationResult result)
We&#39;re done with the local lookup, now consider P2P processing (depending on request options and resul...
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
static char * fn
Filename of the unique file.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
Message to the datastore service asking about specific content.
Definition: datastore.h:143
uint32_t hash_bitmap
Which of the optional hash codes are present at the end of the message? See GET_MESSAGE_BIT_xx consta...
void GSF_plan_init()
Initialize plan subsystem.
struct GSF_LocalClient * lc
Client list this request belongs to.
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:1273
unsigned int GSF_datastore_queue_size
Size of the datastore queue we assume for common requests.
struct GNUNET_BLOCK_Context * GSF_block_ctx
Our block context.
non-anonymous file-transfer
union GNUNET_FS_Uri::@16 data
static struct GNUNET_CONFIGURATION_Handle * block_cfg
Configuration for block library.
#define GNUNET_MIN(a, b)
Definition: gnunet_common.h:83
Inner block in the CHK tree.
Message sent from a GNUnet (fs) unindexing activity to the gnunet-service-fs to indicate that a file ...
Definition: fs.h:231
struct GNUNET_HashCode file_id
Hash of the file that we will unindex.
Definition: fs.h:247
static void handle_client_loc_sign(void *cls, const struct RequestLocSignatureMessage *msg)
Handle request to sign a LOC URI (from client).
struct GNUNET_TIME_AbsoluteNBO expiration_time
Expiration time that was actually used (rounded!).
Definition: fs.h:126
Last possible valid result.
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
struct GSF_LocalClient * lc
Client list entry this response belongs to.
struct GNUNET_PeerIdentity GSF_my_id
Identity of this peer.
void GSF_local_lookup_(struct GSF_PendingRequest *pr, GSF_LocalLookupContinuation cont, void *cont_cls)
Look up the request in the local datastore.
uint32_t type
Type of the content that we&#39;re looking for.
Definition: fs.h:297
struct GNUNET_TIME_Relative delay
Delay.
static int result
Global testing status.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
uint32_t respect_offered
How much respect did we (in total) offer for this request so far (estimate, because we might have the...
static void age_cover_counters(void *cls)
Task that periodically ages our cover traffic statistics.
enum GNUNET_BLOCK_Type type
Type of the requested block.
support for putting content into the DHT
uint32_t purpose
Purpose of the generated signature.
Definition: fs.h:121
struct IndexStartContext * prev
This is a doubly linked list.
Request must only be processed locally.
void GNUNET_CRYPTO_hash_file_cancel(struct GNUNET_CRYPTO_FileHashContext *fhc)
Cancel a file hashing operation.
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:670
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
Type of a block representing any type of search result (universal).
A 512-bit hashcode.
int 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.
struct GNUNET_CORE_Handle * GSF_core
Pointer to handle to the core service (points to NULL until we&#39;ve connected to it).
Message handler for a specific message type.
static int res
struct GNUNET_DATASTORE_Handle * GSF_dsh
Our connection to the datastore.
#define GNUNET_MESSAGE_TYPE_FS_UNINDEX_OK
Reply to client indicating unindex receipt.
void GNUNET_BLOCK_context_destroy(struct GNUNET_BLOCK_Context *ctx)
Destroy the block context.
Definition: block.c:152
Run when otherwise idle.
struct GNUNET_MessageHeader header
Message type will be GNUNET_MESSAGE_TYPE_FS_START_SEARCH.
Definition: fs.h:281
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:104
struct GNUNET_CRYPTO_FileHashContext * fhc
Context for hashing of the file.
Content-hash-key (simple file).
Definition: fs_api.h:146
void GSF_cadet_lookup_(struct GSF_PendingRequest *pr)
Consider downloading via cadet (if possible)
struct ClientResponse * res_tail
Tail of linked list of responses.
#define GNUNET_MESSAGE_TYPE_FS_INDEX_START
Message sent by fs client to start indexing.
static void handle_client_index_start(void *cls, const struct IndexStartMessage *ism)
Handle INDEX_START-message.
void GSF_pending_request_done_()
Shutdown the subsystem.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
struct GNUNET_PeerIdentity peer
Identity of the peer sharing the file.
Definition: fs.h:136
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_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:895
Values we track for load calculations.
Definition: load.c:35
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:694
static struct GNUNET_SCHEDULER_Task * cover_age_task
ID of our task that we use to age the cover counters.
void GNUNET_CORE_disconnect(struct GNUNET_CORE_Handle *handle)
Disconnect from the core service.
Definition: core_api.c:732
char * GNUNET_STRINGS_filename_expand(const char *fil)
Complete filename (a la shell) from abbrevition.
Definition: strings.c:602
GNUNET_BLOCK_EvaluationResult
Possible ways for how a block may relate to a query.
size_t msize
Number of bytes in the response.
void GNUNET_DHT_disconnect(struct GNUNET_DHT_Handle *handle)
Shutdown connection with the DHT service.
Definition: dht_api.c:923
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
void GSF_consider_forwarding(void *cls, struct GSF_PendingRequest *pr, enum GNUNET_BLOCK_EvaluationResult result)
Function to be called after we&#39;re done processing replies from the local lookup.
indexing for the file-sharing service
#define GNUNET_MESSAGE_TYPE_FS_UNINDEX
Request from client to unindex a file.
Message send by a peer that wants to be excluded from migration for a while.
struct GNUNET_PeerIdentity peer
For which peer is this an address?
struct GNUNET_TIME_Absolute expirationTime
Time when this location URI expires.
Definition: fs_api.h:128
32-bit bandwidth used for network exchange by GNUnet, in bytes per second.
enum GNUNET_FS_UriType type
Type of the URI.
Definition: fs_api.h:173
Context used when hashing a file.
static int check_client_index_start(void *cls, const struct IndexStartMessage *ism)
Check INDEX_START-message.
uint32_t type
Type of the block (in big endian).
Definition: fs.h:347
uint32_t respect_offered
How much respect did we offer (in total) before getting an answer (estimate).
Definition: fs.h:398
struct ClientResponse * next
This is a doubly-linked list.
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
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:272
struct ContentHashKey chk
Information about the shared file (to be signed).
Definition: fs.h:96
ATS Handle to obtain and/or modify performance information.
#define GNUNET_MESSAGE_TYPE_FS_START_SEARCH
Client asks FS service to start a (keyword) search.
static int check_p2p_put(void *cls, const struct PutMessage *put)
Check P2P "PUT" message.
struct ClientResponse * prev
This is a doubly-linked list.
Message sent from the service with the signed LOC URI.
Definition: fs.h:108
Response from FS service with a result for a previous FS search.
Definition: fs.h:364
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.
Handle to a message queue.
Definition: mq.c:85
uint32_t type
Type of the block (in big endian).
Definition: fs.h:375
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?
Doubly-linked list of requests we are performing on behalf of the same client.
Private ECC key encoded for transmission.
The identity of the host (wraps the signing key of the peer).
struct GNUNET_LOAD_Value * GSF_rt_entry_lifetime
How long do requests typically stay in the routing table?
struct GSF_PendingRequestData * GSF_pending_request_get_data_(struct GSF_PendingRequest *pr)
Obtain the public data associated with a pending request.
void * GSF_peer_connect_handler(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
A peer connected to us.
Option mask for typical local requests.
Message sent from a GNUnet (fs) publishing activity to sign a LOC URI.
Definition: fs.h:74
Performance data kept for a peer.
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.
#define HASHING_BLOCKSIZE
Blocksize to use when hashing files for indexing (blocksize for IO, not for the DBlocks).
Definition: fs.h:47
configuration data
Definition: configuration.c:85
shared definitions for the FS library
void GNUNET_DATASTORE_disconnect(struct GNUNET_DATASTORE_Handle *h, int drop)
Disconnect from the datastore service (and free associated resources).
struct ClientResponse * res_head
Head of linked list of responses.
static int check_client_start_search(void *cls, const struct SearchMessage *sm)
Check GNUNET_MESSAGE_TYPE_FS_START_SEARCH-message (search request from client).
A Universal Resource Identifier (URI), opaque.
Definition: fs_api.h:168
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:373
Handle to the datastore service.
uint64_t file_length
Total size of the file in bytes.
Definition: fs_api.h:99
#define GNUNET_LOAD_value_free(lv)
Free a load value.
An address for communicating with a peer.
struct GNUNET_HashCode file_id
Hash of the contents of the file.
#define GNUNET_MESSAGE_TYPE_FS_MIGRATION_STOP
Peer asks us to stop migrating content towards it for a while.
static void shutdown_task(void *cls)
Task run during shutdown.
struct GNUNET_CRYPTO_EddsaSignature signature
The requested signature.
Definition: fs.h:131
struct GNUNET_CRYPTO_EddsaSignature contentSignature
Signature over the GNUNET_EC_FileIdentifier, peer identity and expiration time.
Definition: fs_api.h:134
void GSF_dht_lookup_(struct GSF_PendingRequest *pr)
Consider looking up the data in the DHT (anonymity-level permitting).
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
#define GNUNET_log(kind,...)
Entry in list of pending tasks.
Definition: scheduler.c:134
uint32_t reserved
For alignment.
Definition: fs.h:164
#define GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGN
Message sent by fs client to request LOC signature.
struct GSF_LocalClient * lc
Context for transmitting confirmation to client.
A connected peer.
static void handle_client_index_list_get(void *cls, const struct GNUNET_MessageHeader *message)
Handle INDEX_LIST_GET-message.
#define FS_DHT_HT_SIZE
Size for the hash map for DHT requests from the FS service.
struct GNUNET_CRYPTO_EddsaPrivateKey * GNUNET_CRYPTO_eddsa_key_create_from_file(const char *filename)
Create a new private key by reading it from a file.
int 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.
Data block (leaf) in the CHK tree.
void GSF_push_done_()
Shutdown the module.
#define SEARCH_MESSAGE_OPTION_CONTINUED
Request is too large to fit in 64k format.
Definition: fs.h:268
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&#39;ve received peer performance information.
unsigned int GSF_cover_content_count
How many content messages have we received &#39;recently&#39; that have not yet been claimed as cover traffic...
struct GNUNET_TIME_Relative GSF_avg_latency
Running average of the observed latency to other peers (round trip).
struct ClientRequest * cr_head
Head of list of requests performed on behalf of this client right now.
struct GNUNET_TIME_AbsoluteNBO expiration_time
Requested expiration time.
Definition: fs.h:91
struct ClientRequest * cr_tail
Tail of list of requests performed on behalf of this client right now.
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.
struct Location loc
Information needed to retrieve a file including signed location (identity of a peer) of the content...
Definition: fs_api.h:221
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
static void signal_index_ok(struct IndexStartContext *isc)
We&#39;ve validated the hash of the file we&#39;re about to index.
Header for all communications.
Time for absolute times used by GNUnet, in microseconds.
#define GNUNET_YES
Definition: gnunet_common.h:80
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:353
struct GNUNET_SERVICE_Client * client
ID of the client.
void GSF_cadet_start_server(void)
Initialize subsystem for non-anonymous file-sharing.
static void * client_connect_cb(void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
Creates a fresh local client handle.
void GSF_connected_peer_done_()
Shutdown peer management subsystem.
An active request.
support for pushing out content
#define SEARCH_MESSAGE_OPTION_LOOPBACK_ONLY
Only search the local datastore (no network)
Definition: fs.h:260
static void client_request_destroy(void *cls)
Free the given client request.
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.
void GSF_pending_request_cancel_(struct GSF_PendingRequest *pr, int full_cleanup)
Explicitly cancel a pending request.
int 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".
Message sent from a GNUnet (fs) search activity to the gnunet-service-fs to start a search...
Definition: fs.h:275
uint32_t data
The data value.
struct GNUNET_DATASTORE_Handle * GNUNET_DATASTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the datastore service.
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:654
static char * address
GNS address for this phone.
#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).
uint32_t anonymity_level
Desired anonymity level, big-endian.
Definition: fs.h:302
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
int has_started
Has this request been started yet (local/p2p operations)? Or are we still constructing it...
GSF_PendingRequestOptions
Options for pending requests (bits to be ORed).
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2533
#define DATASTORE_LOAD_AUTODECLINE
At what frequency should our datastore load decrease automatically (since if we don&#39;t use it...
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
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.
void GSF_put_init_()
Setup the module.
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:48
uint32_t num_transmissions
How often did we transmit this query before getting an answer (estimate).
Definition: fs.h:392
#define GNUNET_free(ptr)
Wrapper around free.
Time for relative time used by GNUnet, in microseconds.
struct GNUNET_CRYPTO_EddsaPublicKey public_key
static struct GNUNET_TRANSPORT_PluginMonitor * pm
Handle if we are monitoring plugin session activity.
#define gettext_noop(String)
Definition: gettext.h:69
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965