GNUnet 0.21.2
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_protocols.h"
34#include "gnunet_signatures.h"
36#include "gnunet_util_lib.h"
44#include "fs.h"
45#include "fs_api.h"
46
52#define FS_DHT_HT_SIZE 1024
53
54
60#define COVER_AGE_FREQUENCY GNUNET_TIME_relative_multiply ( \
61 GNUNET_TIME_UNIT_SECONDS, 5)
62
66#define INSANE_STATISTICS GNUNET_NO
67
68
74{
79
84
89
94
99};
100
101
107{
112
117
122
126 size_t msize;
127};
128
129
135{
140
145
149 char *filename;
150
155
160
165};
166
167
172{
177
182
188
194
199
204
209
214};
215
216
217/* ****************************** globals ****************************** */
218
223
228
233
238
243
249
250
262
267
273
279
284
290
295
300
301/* ***************************** locals ******************************* */
302
307
312
317
322
323
332static void *
334 struct GNUNET_SERVICE_Client *client,
335 struct GNUNET_MQ_Handle *mq)
336{
337 struct GSF_LocalClient *pos;
338
339 pos = GNUNET_new (struct GSF_LocalClient);
340 pos->client = client;
341 pos->mq = mq;
342 return pos;
343}
344
345
351static void
353{
354 struct ClientRequest *cr = cls;
355 struct GSF_LocalClient *lc = cr->lc;
356
357 cr->kill_task = NULL;
359 lc->cr_tail,
360 cr);
362 GNUNET_YES);
364 gettext_noop ("# client searches active"),
365 -1,
366 GNUNET_NO);
367 GNUNET_free (cr);
368}
369
370
389static void
392 struct GSF_PendingRequest *pr,
393 uint32_t reply_anonymity_level,
395 struct GNUNET_TIME_Absolute last_transmission,
397 const void *data,
398 size_t data_len)
399{
400 struct ClientRequest *cr = cls;
401 struct GSF_LocalClient *lc;
402 struct GNUNET_MQ_Envelope *env;
403 struct ClientPutMessage *pm;
404 const struct GSF_PendingRequestData *prd;
405
406 if (NULL == data)
407 {
408 /* local-only request, with no result, clean up. */
409 if (NULL == cr->kill_task)
411 cr);
412 return;
413 }
416 if ((prd->type != type) && (prd->type != GNUNET_BLOCK_TYPE_ANY))
417 {
418 GNUNET_break (0);
419 return;
420 }
423 ("# replies received for local clients"), 1,
424 GNUNET_NO);
425 GNUNET_assert (pr == cr->pr);
426 lc = cr->lc;
428 data_len,
430 pm->type = htonl (type);
432 pm->last_transmission = GNUNET_TIME_absolute_hton (last_transmission);
433 pm->num_transmissions = htonl (prd->num_transmissions);
434 pm->respect_offered = htonl (prd->respect_offered);
435 GNUNET_memcpy (&pm[1],
436 data,
437 data_len);
438 GNUNET_MQ_send (lc->mq,
439 env);
441 "Queued reply to query `%s' for local client\n",
442 GNUNET_h2s (&prd->query));
443 if (GNUNET_BLOCK_REPLY_OK_LAST != eval)
444 {
446 "Evaluation %d - keeping query alive\n",
447 (int) eval);
448 return;
449 }
450 if (NULL == cr->kill_task)
452 cr);
453}
454
455
464static void
466 struct GNUNET_SERVICE_Client *client,
467 void *app_ctx)
468{
469 struct GSF_LocalClient *lc = app_ctx;
470 struct IndexStartContext *isc;
471 struct ClientRequest *cr;
472 struct ClientResponse *res;
473
474 while (NULL != (cr = lc->cr_head))
475 {
476 if (NULL != cr->kill_task)
479 }
480 while (NULL != (res = lc->res_head))
481 {
483 lc->res_tail,
484 res);
486 }
487 while (NULL != (isc = lc->isc_head))
488 {
490 lc->isc_tail,
491 isc);
493 GNUNET_free (isc);
494 }
495 GNUNET_free (lc);
496}
497
498
504static void
506{
512 NULL);
513}
514
515
522void
524{
525 struct GNUNET_TIME_Relative delay;
526
529}
530
531
542int
544{
545 double ld;
546
548 if (ld < 1)
549 return GNUNET_SYSERR;
550 if (ld <= priority)
551 return GNUNET_NO;
552 return GNUNET_YES;
553}
554
555
564static int
565check_p2p_put (void *cls,
566 const struct PutMessage *put)
567{
569
570 type = ntohl (put->type);
572 {
573 GNUNET_break_op (0);
574 return GNUNET_SYSERR;
575 }
576 return GNUNET_OK;
577}
578
579
589static void
591 const struct GNUNET_PeerIdentity *peer,
592 struct GSF_ConnectedPeer *cp,
593 const struct GSF_PeerPerformanceData *ppd)
594{
595 struct GSF_PendingRequest *pr = cls;
596
597 if (GNUNET_YES !=
599 {
600#if INSANE_STATISTICS
602 gettext_noop ("# Loopback routes suppressed"), 1,
603 GNUNET_NO);
604#endif
605 return;
606 }
607 GSF_plan_add_ (cp,
608 pr);
609}
610
611
622void
624 struct GSF_PendingRequest *pr,
626{
628 return; /* we're done... */
629 if (GNUNET_YES !=
631 return; /* request is not actually active, skip! */
633 pr);
634}
635
636
645static int
646check_p2p_get (void *cls,
647 const struct GetMessage *gm)
648{
649 size_t msize;
650 unsigned int bm;
651 unsigned int bits;
652 size_t bfsize;
653
654 msize = ntohs (gm->header.size);
655 bm = ntohl (gm->hash_bitmap);
656 bits = 0;
657 while (bm > 0)
658 {
659 if (1 == (bm & 1))
660 bits++;
661 bm >>= 1;
662 }
663 if (msize < sizeof(struct GetMessage) + bits * sizeof(struct
665 {
666 GNUNET_break_op (0);
667 return GNUNET_SYSERR;
668 }
669 bfsize = msize - sizeof(struct GetMessage) - bits * sizeof(struct
671 /* bfsize must be power of 2, check! */
672 if (0 != ((bfsize - 1) & bfsize))
673 {
674 GNUNET_break_op (0);
675 return GNUNET_SYSERR;
676 }
677 return GNUNET_OK;
678}
679
680
691static void
693 struct GSF_PendingRequest *pr,
695{
696 struct GSF_LocalClient *lc = cls;
697 struct GSF_PendingRequestData *prd;
698
701 return; /* we're done, 'pr' was already destroyed... */
704 "Finished database lookup for local request `%s' with result %d\n",
705 GNUNET_h2s (&prd->query),
706 result);
707 if (0 == prd->anonymity_level)
708 {
709 switch (prd->type)
710 {
713 /* the above block types MAY be available via 'cadet' */
715 "Considering cadet-based download for block\n");
717 break;
718
720 /* the above block types are in the DHT */
722 "Considering DHT-based search for block\n");
723 GSF_dht_lookup_ (pr);
724 break;
725
726 default:
727 GNUNET_break (0);
728 break;
729 }
730 }
732 pr,
733 result);
734}
735
736
745static int
747 const struct SearchMessage *sm)
748{
749 uint16_t msize;
750
751 msize = ntohs (sm->header.size) - sizeof(struct SearchMessage);
752 if (0 != msize % sizeof(struct GNUNET_HashCode))
753 {
754 GNUNET_break (0);
755 return GNUNET_SYSERR;
756 }
757 return GNUNET_OK;
758}
759
760
771static void
773 const struct SearchMessage *sm)
774{
775 static struct GNUNET_PeerIdentity all_zeros;
776 struct GSF_LocalClient *lc = cls;
777 struct ClientRequest *cr;
778 struct GSF_PendingRequestData *prd;
779 uint16_t msize;
780 unsigned int sc;
783
785 gettext_noop ("# client searches received"),
786 1,
787 GNUNET_NO);
788 msize = ntohs (sm->header.size) - sizeof(struct SearchMessage);
789 sc = msize / sizeof(struct GNUNET_HashCode);
790 type = ntohl (sm->type);
792 "Received request for `%s' of type %u from local client\n",
793 GNUNET_h2s (&sm->query),
794 (unsigned int) type);
795 cr = NULL;
796 /* detect duplicate UBLOCK requests */
799 {
800 cr = lc->cr_head;
801 while (NULL != cr)
802 {
804 /* only unify with queries that hae not yet started local processing
805 (SEARCH_MESSAGE_OPTION_CONTINUED was always set) and that have a
806 matching query and type */
807 if ((GNUNET_YES != prd->has_started) &&
808 (0 != memcmp (&prd->query,
809 &sm->query,
810 sizeof(struct GNUNET_HashCode))) &&
811 (prd->type == type))
812 break;
813 cr = cr->next;
814 }
815 }
816 if (NULL != cr)
817 {
819 "Have existing request, merging content-seen lists.\n");
821 (const struct GNUNET_HashCode *) &sm[1],
822 sc);
825 "# client searches updated (merged content seen list)"),
826 1,
827 GNUNET_NO);
828 }
829 else
830 {
832 gettext_noop ("# client searches active"),
833 1,
834 GNUNET_NO);
835 cr = GNUNET_new (struct ClientRequest);
836 cr->lc = lc;
838 lc->cr_tail,
839 cr);
841 if (0 != (SEARCH_MESSAGE_OPTION_LOOPBACK_ONLY & ntohl (sm->options)))
844 &sm->query,
845 (0 !=
846 memcmp (&sm->target,
847 &all_zeros,
848 sizeof(struct
850 ? &sm->target : NULL, NULL,
851 0 /* bf */,
852 ntohl (sm->anonymity_level),
853 0 /* priority */,
854 0 /* ttl */,
855 0 /* sender PID */,
856 0 /* origin PID */,
857 (const struct
858 GNUNET_HashCode *) &sm[1], sc,
860 cr);
861 }
862 if (0 != (SEARCH_MESSAGE_OPTION_CONTINUED & ntohl (sm->options)))
863 {
865 return;
866 }
870 lc);
871}
872
873
880static void
882 const struct RequestLocSignatureMessage *msg)
883{
884 struct GSF_LocalClient *lc = cls;
885 struct GNUNET_FS_Uri base;
886 struct GNUNET_FS_Uri *loc;
887 struct GNUNET_MQ_Envelope *env;
888 struct ResponseLocSignatureMessage *resp;
889
891 ntohl (msg->purpose));
892 base.type = GNUNET_FS_URI_CHK;
893 base.data.chk.chk = msg->chk;
894 base.data.chk.file_length = GNUNET_ntohll (msg->file_length);
895 loc = GNUNET_FS_uri_loc_create (&base,
896 &pk,
898 msg->expiration_time));
899 env = GNUNET_MQ_msg (resp,
903 loc->data.loc.expirationTime);
904 resp->signature = loc->data.loc.contentSignature;
905 resp->peer = loc->data.loc.peer;
907 GNUNET_MQ_send (lc->mq,
908 env);
910}
911
912
920static int
922 const struct IndexStartMessage *ism)
923{
924 char *fn;
925
927 if (0 != ism->reserved)
928 {
929 GNUNET_break (0);
930 return GNUNET_SYSERR;
931 }
932 fn = GNUNET_STRINGS_filename_expand ((const char *) &ism[1]);
933 if (NULL == fn)
934 {
935 GNUNET_break (0);
936 return GNUNET_SYSERR;
937 }
938 GNUNET_free (fn);
939 return GNUNET_OK;
940}
941
942
949static void
951{
952 struct GSF_LocalClient *lc = isc->lc;
953 struct GNUNET_MQ_Envelope *env;
955
957 &isc->file_id);
960 GNUNET_MQ_send (lc->mq,
961 env);
962 GNUNET_free (isc->filename);
963 GNUNET_free (isc);
965}
966
967
975static void
977 const struct GNUNET_HashCode *res)
978{
979 struct IndexStartContext *isc = cls;
980 struct GSF_LocalClient *lc = isc->lc;
981 struct GNUNET_MQ_Envelope *env;
983
985 lc->isc_tail,
986 isc);
987 isc->fhc = NULL;
988 if ((NULL == res) ||
989 (0 != memcmp (res,
990 &isc->file_id,
991 sizeof(struct GNUNET_HashCode))))
992 {
994 _ (
995 "Hash mismatch trying to index file `%s' which does not have hash `%s'\n"),
996 isc->filename,
997 GNUNET_h2s (&isc->file_id));
998
999 const char *emsg = "hash mismatch";
1000 const size_t msize = strlen (emsg) + 1;
1001
1003 msize,
1005 memcpy ((char*) &msg[1], emsg, msize);
1006 GNUNET_MQ_send (lc->mq,
1007 env);
1009 GNUNET_free (isc);
1010 return;
1011 }
1012 signal_index_ok (isc);
1013}
1014
1015
1022static void
1024 const struct IndexStartMessage *ism)
1025{
1026 struct GSF_LocalClient *lc = cls;
1027 struct IndexStartContext *isc;
1028 char *fn;
1029 uint64_t dev;
1030 uint64_t ino;
1031 uint64_t mydev;
1032 uint64_t myino;
1033
1034 fn = GNUNET_STRINGS_filename_expand ((const char *) &ism[1]);
1035 GNUNET_assert (NULL != fn);
1036 dev = GNUNET_ntohll (ism->device);
1037 ino = GNUNET_ntohll (ism->inode);
1038 isc = GNUNET_new (struct IndexStartContext);
1039 isc->filename = fn;
1040 isc->file_id = ism->file_id;
1042 "Received START_INDEX message for file `%s'\n",
1043 isc->filename);
1044 isc->lc = lc;
1045 mydev = 0;
1046 myino = 0;
1047 if (((dev != 0) ||
1048 (ino != 0)) &&
1050 &mydev,
1051 &myino)) &&
1052 (dev == mydev) &&
1053 (ino == myino))
1054 {
1055 /* fast validation OK! */
1056 signal_index_ok (isc);
1057 return;
1058 }
1060 "Mismatch in file identifiers (%llu != %llu or %u != %u), need to hash.\n",
1061 (unsigned long long) ino,
1062 (unsigned long long) myino,
1063 (unsigned int) dev,
1064 (unsigned int) mydev);
1065 /* slow validation, need to hash full file (again) */
1067 lc->isc_tail,
1068 isc);
1070 isc->filename,
1073 isc);
1074 if (NULL == isc->fhc)
1075 hash_for_index_val (isc,
1076 NULL);
1077}
1078
1079
1086static void
1088 const struct GNUNET_MessageHeader *message)
1089{
1090 struct GSF_LocalClient *lc = cls;
1091
1094}
1095
1096
1103static void
1105 const struct UnindexMessage *um)
1106{
1107 struct GSF_LocalClient *lc = cls;
1108 struct GNUNET_MQ_Envelope *env;
1109 struct GNUNET_MessageHeader *msg;
1110 int found;
1111
1112 GNUNET_break (0 == um->reserved);
1115 "Client requested unindexing of file `%s': %s\n",
1116 GNUNET_h2s (&um->file_id),
1117 found ? "found" : "not found");
1120 GNUNET_MQ_send (lc->mq,
1121 env);
1123}
1124
1125
1131static void
1132shutdown_task (void *cls)
1133{
1135 if (NULL != GSF_core)
1136 {
1138 GSF_core = NULL;
1139 }
1140 GSF_put_done_ ();
1141 GSF_push_done_ ();
1143 GSF_plan_done ();
1146 GNUNET_NO);
1147 GSF_dsh = NULL;
1149 GSF_dht = NULL;
1151 GSF_block_ctx = NULL;
1153 block_cfg = NULL;
1155 GSF_stats = NULL;
1156 if (NULL != cover_age_task)
1157 {
1159 cover_age_task = NULL;
1160 }
1163 datastore_get_load = NULL;
1165 GSF_rt_entry_lifetime = NULL;
1166}
1167
1168
1179static void
1181 const struct GNUNET_PeerIdentity *my_identity)
1182{
1183 if (0 != GNUNET_memcmp (&GSF_my_id,
1184 my_identity))
1185 {
1187 "Peer identity mismatch, refusing to start!\n");
1189 }
1190}
1191
1192
1198static int
1200{
1201 struct GNUNET_MQ_MessageHandler no_p2p_handlers[] = {
1203 };
1204 struct GNUNET_MQ_MessageHandler p2p_handlers[] = {
1205 GNUNET_MQ_hd_var_size (p2p_get,
1207 struct GetMessage,
1208 NULL),
1209 GNUNET_MQ_hd_var_size (p2p_put,
1211 struct PutMessage,
1212 NULL),
1213 GNUNET_MQ_hd_fixed_size (p2p_migration_stop,
1215 struct MigrationStopMessage,
1216 NULL),
1218 };
1219 int anon_p2p_off;
1220 char *keyfile;
1221
1222 /* this option is really only for testcases that need to disable
1223 _anonymous_ file-sharing for some reason */
1224 anon_p2p_off = (GNUNET_YES ==
1226 "fs",
1227 "DISABLE_ANON_TRANSFER"));
1228
1229 if (GNUNET_OK !=
1231 "PEER",
1232 "PRIVATE_KEY",
1233 &keyfile))
1234 {
1236 _ (
1237 "FS service is lacking HOSTKEY configuration setting. Exiting.\n"));
1239 return GNUNET_SYSERR;
1240 }
1241 if (GNUNET_SYSERR ==
1243 GNUNET_YES,
1244 &pk))
1245 {
1247 "Failed to setup peer's private key\n");
1249 GNUNET_free (keyfile);
1250 return GNUNET_SYSERR;
1251 }
1252 GNUNET_free (keyfile);
1255
1257 "I am peer %s\n",
1259 GSF_core
1261 NULL,
1265 (GNUNET_YES == anon_p2p_off)
1266 ? no_p2p_handlers
1267 : p2p_handlers);
1268 if (NULL == GSF_core)
1269 {
1271 _ ("Failed to connect to `%s' service.\n"),
1272 "core");
1273 return GNUNET_SYSERR;
1274 }
1278 NULL);
1282 NULL);
1283 return GNUNET_OK;
1284}
1285
1286
1294static void
1295run (void *cls,
1296 const struct GNUNET_CONFIGURATION_Handle *cfg,
1298{
1299 unsigned long long dqs;
1300
1301 GSF_cfg = cfg;
1302 if (GNUNET_OK !=
1304 "fs",
1305 "DATASTORE_QUEUE_SIZE",
1306 &dqs))
1307 {
1309 "fs",
1310 "DATASTORE_QUEUE_SIZE");
1311 dqs = 32;
1312 }
1313 GSF_datastore_queue_size = (unsigned int) dqs;
1317 if (NULL == GSF_dsh)
1318 {
1320 return;
1321 }
1326 GNUNET_assert (NULL != GSF_block_ctx);
1328 GSF_plan_init ();
1331
1332 GSF_push_init_ ();
1333 GSF_put_init_ ();
1335 GSF_dsh)) ||
1336 (GNUNET_OK != main_init (cfg)))
1337 {
1339 shutdown_task (NULL);
1340 return;
1341 }
1342}
1343
1344
1349 ("fs",
1351 &run,
1354 NULL,
1355 GNUNET_MQ_hd_var_size (client_index_start,
1357 struct IndexStartMessage,
1358 NULL),
1359 GNUNET_MQ_hd_fixed_size (client_index_list_get,
1361 struct GNUNET_MessageHeader,
1362 NULL),
1363 GNUNET_MQ_hd_fixed_size (client_unindex,
1365 struct UnindexMessage,
1366 NULL),
1367 GNUNET_MQ_hd_var_size (client_start_search,
1369 struct SearchMessage,
1370 NULL),
1371 GNUNET_MQ_hd_fixed_size (client_loc_sign,
1374 NULL),
1376
1377
1378/* end of gnunet-service-fs.c */
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
definitions for the entire fs module
#define HASHING_BLOCKSIZE
Blocksize to use when hashing files for indexing (blocksize for IO, not for the DBlocks).
Definition: fs.h:48
#define SEARCH_MESSAGE_OPTION_LOOPBACK_ONLY
Only search the local datastore (no network)
Definition: fs.h:254
#define SEARCH_MESSAGE_OPTION_CONTINUED
Request is too large to fit in 64k format.
Definition: fs.h:262
shared definitions for the FS library
@ GNUNET_FS_URI_CHK
Content-hash-key (simple file).
Definition: fs_api.h:144
#define gettext_noop(String)
Definition: gettext.h:74
static int start
Set if we are to start default services (including ARM).
Definition: gnunet-arm.c:39
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:109
struct GNUNET_PeerIdentity my_identity
Our peer identity.
static char * data
The data to insert into the dht.
static struct GNUNET_TIME_Relative expiration
User supplied expiration value.
static char * res
Currently read line or NULL on EOF.
static uint32_t type
Type string converted to DNS type value.
static int result
Global testing status.
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:87
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
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 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...
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_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.
struct GNUNET_PeerIdentity GSF_my_id
Identity of this peer.
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_peer_connect_handler(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
A peer connected to us.
void GSF_iterate_connected_peers_(GSF_ConnectedPeerIterator it, void *it_cls)
Iterate over all connected peers.
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?
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_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.
struct GSF_PendingRequestData * GSF_pending_request_get_data_(struct GSF_PendingRequest *pr)
Obtain the public data associated with a pending request.
int GSF_pending_request_test_active_(struct GSF_PendingRequest *pr)
Check if the given request is still active.
void GSF_pending_request_done_()
Shutdown the subsystem.
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_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.
Functions related to load calculations.
Constants for network protocols.
API to create, modify and access statistics.
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.
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_CONFIGURATION_Handle * GNUNET_CONFIGURATION_create(void)
Create a new configuration object.
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:691
void GNUNET_CORE_disconnect(struct GNUNET_CORE_Handle *handle)
Disconnect from the core service.
Definition: core_api.c:729
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:201
void GNUNET_DATASTORE_disconnect(struct GNUNET_DATASTORE_Handle *h, int drop)
Disconnect from the datastore service (and free associated resources).
struct GNUNET_DATASTORE_Handle * GNUNET_DATASTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the datastore service.
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:1037
void GNUNET_DHT_disconnect(struct GNUNET_DHT_Handle *handle)
Shutdown connection with the DHT service.
Definition: dht_api.c:1060
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:240
#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:869
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:677
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:54
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.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
@ GNUNET_SCHEDULER_PRIORITY_IDLE
Run when otherwise idle.
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
@ GNUNET_SYSERR
struct GNUNET_LOAD_Value * GNUNET_LOAD_value_init(struct GNUNET_TIME_Relative autodecline)
Create a new load value.
Definition: load.c:125
void GNUNET_LOAD_update(struct GNUNET_LOAD_Value *load, uint64_t data)
Update the current load.
Definition: load.c:237
double GNUNET_LOAD_get_load(struct GNUNET_LOAD_Value *load)
Get the current load.
Definition: load.c:201
#define GNUNET_LOAD_value_free(lv)
Free a load value.
#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:304
#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:63
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:78
#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:567
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:1340
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:981
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:1305
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:1278
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2455
@ 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_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:436
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:737
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:638
#define _(String)
GNU gettext support macro.
Definition: platform.h:178
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_DBLOCK
Data block (leaf) in the CHK tree.
@ GNUNET_BLOCK_TYPE_FS_ONDEMAND
Type of a block representing a block to be encoded on demand from disk.
@ GNUNET_BLOCK_TYPE_FS_IBLOCK
Inner block in the CHK tree.
@ GNUNET_BLOCK_TYPE_ANY
Identifier for any block.
@ GNUNET_BLOCK_TYPE_FS_UBLOCK
Type of a block representing any type of search result (universal).
#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...
Response from FS service with a result for a previous FS search.
Definition: fs.h:356
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:104
uint64_t file_length
Total size of the file in bytes.
Definition: fs_api.h:99
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:235
A Universal Resource Identifier (URI), opaque.
Definition: fs_api.h:167
union GNUNET_FS_Uri::@49 data
enum GNUNET_FS_UriType type
Type of the URI.
Definition: fs_api.h:171
struct Location loc
Information needed to retrieve a file including signed location (identity of a peer) of the content.
Definition: fs_api.h:218
struct FileIdentifier chk
Information needed to retrieve a file (content-hash-key plus file size).
Definition: fs_api.h:212
A 512-bit hashcode.
Values we track for load calculations.
Definition: load.c:37
Handle to a message queue.
Definition: mq.c:87
Message handler for a specific message type.
Header for all communications.
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:136
Handle to a client that is connected to a service.
Definition: service.c:246
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:153
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:179
struct GNUNET_HashCode file_id
Hash of the file that we would like to index.
Definition: fs.h:184
uint32_t reserved
For alignment.
Definition: fs.h:162
uint64_t device
ID of device containing the file, as seen by the client.
Definition: fs.h:171
struct GNUNET_TIME_Absolute expirationTime
Time when this location URI expires.
Definition: fs_api.h:127
struct GNUNET_CRYPTO_EddsaSignature contentSignature
Signature over the GNUNET_EC_FileIdentifier, peer identity and expiration time.
Definition: fs_api.h:133
struct GNUNET_PeerIdentity peer
Identity of the peer sharing the file.
Definition: fs_api.h:122
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:330
uint32_t type
Type of the block (in big endian).
Definition: fs.h:339
Message sent from a GNUnet (fs) publishing activity to sign a LOC URI.
Definition: fs.h:76
Message sent from the service with the signed LOC URI.
Definition: fs.h:109
struct GNUNET_CRYPTO_EddsaSignature signature
The requested signature.
Definition: fs.h:130
struct GNUNET_PeerIdentity peer
Identity of the peer sharing the file.
Definition: fs.h:135
uint32_t purpose
Purpose of the generated signature.
Definition: fs.h:120
struct GNUNET_TIME_AbsoluteNBO expiration_time
Expiration time that was actually used (rounded!).
Definition: fs.h:125
Message sent from a GNUnet (fs) search activity to the gnunet-service-fs to start a search.
Definition: fs.h:270
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:307
uint32_t type
Type of the content that we're looking for.
Definition: fs.h:290
struct GNUNET_HashCode query
Hash of the public key for UBLOCKs; Hash of the CHK-encoded block for DBLOCKS and IBLOCKS.
Definition: fs.h:313
uint32_t anonymity_level
Desired anonymity level, big-endian.
Definition: fs.h:295
struct GNUNET_MessageHeader header
Message type will be GNUNET_MESSAGE_TYPE_FS_START_SEARCH.
Definition: fs.h:274
uint32_t options
Bitmask with options.
Definition: fs.h:285
Message sent from a GNUnet (fs) unindexing activity to the gnunet-service-fs to indicate that a file ...
Definition: fs.h:228
struct GNUNET_HashCode file_id
Hash of the file that we will unindex.
Definition: fs.h:242
uint32_t reserved
Always zero.
Definition: fs.h:237