GNUnet 0.22.0
fs_api.c
Go to the documentation of this file.
1/*
2 This file is part of GNUnet.
3 Copyright (C) 2001--2012 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
27#include "platform.h"
28#include "gnunet_util_lib.h"
29
30#include "gnunet_fs_service.h"
31#include "fs_api.h"
32#include "fs_tree.h"
33
37#define DEFAULT_MAX_PARALLEL_REQUESTS (1024 * 10)
38
42#define DEFAULT_MAX_PARALLEL_DOWNLOADS 16
43
50static void
52{
53 qe->active = GNUNET_YES;
54 qe->start (qe->cls);
55 qe->start_times++;
56 qe->h->active_blocks += qe->blocks;
57 qe->h->active_downloads++;
58 qe->start_time = GNUNET_TIME_absolute_get ();
60 "Starting job %p (%u active)\n",
61 qe,
62 qe->h->active_downloads);
63 GNUNET_CONTAINER_DLL_remove (qe->h->pending_head, qe->h->pending_tail, qe);
65 qe->h->running_tail,
66 qe->h->running_tail,
67 qe);
68}
69
70
77static void
79{
80 qe->active = GNUNET_NO;
81 qe->stop (qe->cls);
82 GNUNET_assert (0 < qe->h->active_downloads);
83 qe->h->active_downloads--;
84 qe->h->active_blocks -= qe->blocks;
85 qe->run_time = GNUNET_TIME_relative_add (qe->run_time,
87 qe->start_time));
89 "Stopping job %p (%u active)\n",
90 qe,
91 qe->h->active_downloads);
92 GNUNET_CONTAINER_DLL_remove (qe->h->running_head, qe->h->running_tail, qe);
94 qe->h->pending_tail,
95 qe->h->pending_tail,
96 qe);
97}
98
99
106static void
108{
109 struct GNUNET_FS_Handle *h = cls;
110 struct GNUNET_FS_QueueEntry *qe;
112 struct GNUNET_TIME_Relative run_time;
113 struct GNUNET_TIME_Relative restart_at;
114 struct GNUNET_TIME_Relative rst;
116 unsigned int num_downloads_waiting;
117 unsigned int num_downloads_active;
118 unsigned int num_downloads_expired;
119 unsigned int num_probes_active;
120 unsigned int num_probes_waiting;
121 unsigned int num_probes_expired;
122 int num_probes_change;
123 int num_downloads_change;
124 int block_limit_hit;
125
126 h->queue_job = NULL;
127 /* restart_at will be set to the time when it makes sense to
128 re-evaluate the job queue (unless, of course, jobs complete
129 or are added, then we'll be triggered immediately */
130 restart_at = GNUNET_TIME_UNIT_FOREVER_REL;
131 /* first, calculate some basic statistics on pending jobs */
132 num_probes_waiting = 0;
133 num_downloads_waiting = 0;
134 for (qe = h->pending_head; NULL != qe; qe = qe->next)
135 {
136 switch (qe->priority)
137 {
139 num_probes_waiting++;
140 break;
141
143 num_downloads_waiting++;
144 break;
145
146 default:
147 GNUNET_break (0);
148 break;
149 }
150 }
151 /* now, calculate some basic statistics on running jobs */
152 num_probes_active = 0;
153 num_probes_expired = 0;
154 num_downloads_active = 0;
155 num_downloads_expired = 0;
156 next = h->running_head;
157 while (NULL != (qe = next))
158 {
159 next = qe->next;
160 switch (qe->priority)
161 {
164 end_time = GNUNET_TIME_absolute_add (qe->start_time, run_time);
166 if (0 == rst.rel_value_us)
167 {
168 num_probes_expired++;
169 stop_job (qe);
170 }
171 else
172 {
173 num_probes_active++;
174 restart_at = GNUNET_TIME_relative_min (rst, restart_at);
175 }
176 break;
177
179 run_time =
181 qe->blocks * qe->start_times);
182 end_time = GNUNET_TIME_absolute_add (qe->start_time, run_time);
184 if (0 == rst.rel_value_us)
185 {
186 num_downloads_expired++;
187 stop_job (qe);
188 }
189 else
190 {
191 num_downloads_active++;
192 restart_at = GNUNET_TIME_relative_min (rst, restart_at);
193 }
194 break;
195
196 default:
197 GNUNET_break (0);
198 break;
199 }
200 }
201 GNUNET_break (h->active_downloads ==
202 num_downloads_active + num_probes_active);
204 "PA: %u, PE: %u, PW: %u; DA: %u, DE: %u, DW: %u\n",
205 num_probes_active,
206 num_probes_expired,
207 num_probes_waiting,
208 num_downloads_active,
209 num_downloads_expired,
210 num_downloads_waiting);
211 GNUNET_break (h->active_downloads + num_probes_active <=
212 h->max_parallel_downloads);
213 /* calculate start/stop decisions */
214 if (h->active_downloads + num_downloads_waiting > h->max_parallel_downloads)
215 {
216 /* stop as many probes as there are downloads and probes */
217 num_probes_change = -GNUNET_MIN (num_probes_active, num_downloads_waiting);
218 /* start as many downloads as there are free slots, including those
219 we just opened up */
220 num_downloads_change =
221 h->max_parallel_downloads - h->active_downloads - num_probes_change;
222 }
223 else
224 {
225 /* start all downloads (we can) */
226 num_downloads_change = num_downloads_waiting;
227 /* also start probes if there is room, but use a lower cap of (mpd/4) + 1 */
228 if (1 + h->max_parallel_downloads / 4 >=
229 (h->active_downloads + num_downloads_change))
230 num_probes_change =
231 GNUNET_MIN (num_probes_waiting,
232 (1 + h->max_parallel_downloads / 4)
233 - (h->active_downloads + num_downloads_change));
234 else
235 num_probes_change = 0;
236 }
237 GNUNET_break (num_downloads_change <= num_downloads_waiting);
239 "Changing %d probes and %d/%u/%u downloads\n",
240 num_probes_change,
241 num_downloads_change,
242 (unsigned int) h->active_downloads,
243 (unsigned int) h->max_parallel_downloads);
244 /* actually stop probes */
245 next = h->running_head;
246 while (NULL != (qe = next))
247 {
248 next = qe->next;
250 continue;
251 if (num_probes_change < 0)
252 {
253 stop_job (qe);
254 num_probes_change++;
255 if (0 == num_probes_change)
256 break;
257 }
258 }
259 GNUNET_break (0 <= num_probes_change);
260
261 /* start some more tasks if we now have empty slots */
262 block_limit_hit = GNUNET_NO;
263 next = h->pending_head;
264 while ((NULL != (qe = next)) &&
265 ((num_probes_change > 0) || (num_downloads_change > 0)))
266 {
267 next = qe->next;
268 switch (qe->priority)
269 {
271 if (num_probes_change > 0)
272 {
273 start_job (qe);
274 num_probes_change--;
276 restart_at = GNUNET_TIME_relative_min (run_time, restart_at);
277 }
278 break;
279
281 if ((num_downloads_change > 0) &&
282 ((qe->blocks + h->active_blocks <= h->max_parallel_requests) ||
283 ((qe->blocks > h->max_parallel_requests) &&
284 (0 == h->active_downloads))))
285 {
286 start_job (qe);
287 num_downloads_change--;
288 }
289 else if (num_downloads_change > 0)
290 block_limit_hit = GNUNET_YES;
291 break;
292
293 default:
294 GNUNET_break (0);
295 break;
296 }
297 }
298 GNUNET_break ((0 == num_downloads_change) || (GNUNET_YES == block_limit_hit));
299 GNUNET_break (0 == num_probes_change);
300
301 GNUNET_log (
303 "AD: %u, MP: %u; %d probes and %d downloads to start, will run again in %s\n",
304 h->active_downloads,
305 h->max_parallel_requests,
306 num_probes_change,
307 num_downloads_change,
309
310 /* make sure we run again, callbacks might have
311 already re-scheduled the job, so cancel such
312 an operation (if it exists) */
313 if (NULL != h->queue_job)
314 GNUNET_SCHEDULER_cancel (h->queue_job);
315 h->queue_job =
317}
318
319
324 void *cls,
325 unsigned int blocks,
327{
328 struct GNUNET_FS_QueueEntry *qe;
329
331 qe->h = h;
332 qe->start = start;
333 qe->stop = stop;
334 qe->cls = cls;
335 qe->queue_time = GNUNET_TIME_absolute_get ();
336 qe->blocks = blocks;
339 h->pending_tail,
340 h->pending_tail,
341 qe);
342 if (NULL != h->queue_job)
343 GNUNET_SCHEDULER_cancel (h->queue_job);
345 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Queueing job %p\n", qe);
346 return qe;
347}
348
349
355void
357{
358 struct GNUNET_FS_Handle *h;
359
360 h = qe->h;
361 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Dequeueing job %p\n", qe);
362 if (GNUNET_YES == qe->active)
363 stop_job (qe);
364 GNUNET_CONTAINER_DLL_remove (h->pending_head, h->pending_tail, qe);
365 GNUNET_free (qe);
366 if (NULL != h->queue_job)
367 GNUNET_SCHEDULER_cancel (h->queue_job);
369}
370
371
380struct TopLevelActivity *
383 void *ssf_cls)
384{
385 struct TopLevelActivity *ret;
386
388 ret->ssf = ssf;
389 ret->ssf_cls = ssf_cls;
390 GNUNET_CONTAINER_DLL_insert (h->top_head, h->top_tail, ret);
391 return ret;
392}
393
394
401void
403{
404 GNUNET_CONTAINER_DLL_remove (h->top_head, h->top_tail, top);
405 GNUNET_free (top);
406}
407
408
413{
417 char *filename;
418
423};
424
425
446size_t
448 uint64_t offset,
449 size_t max,
450 void *buf,
451 char **emsg)
452{
453 struct FileInfo *fi = cls;
454 ssize_t ret;
455
456 if (UINT64_MAX == offset)
457 {
458 if (NULL != fi->fd)
459 {
461 fi->fd = NULL;
462 }
463 return 0;
464 }
465 if (0 == max)
466 {
467 if (NULL != fi->fd)
469 GNUNET_free (fi->filename);
470 GNUNET_free (fi);
471 return 0;
472 }
473 if (NULL == fi->fd)
474 {
478 if (NULL == fi->fd)
479 {
480 GNUNET_asprintf (emsg,
481 _ ("Could not open file `%s': %s"),
482 fi->filename,
483 strerror (errno));
484 return 0;
485 }
486 }
487 if ((GNUNET_SYSERR ==
489 (-1 == (ret = GNUNET_DISK_file_read (fi->fd, buf, max))))
490 {
491 GNUNET_asprintf (emsg,
492 _ ("Could not read file `%s': %s"),
493 fi->filename,
494 strerror (errno));
495 return 0;
496 }
497 if (ret != max)
498 {
499 GNUNET_asprintf (emsg,
500 _ ("Short read reading from file `%s'!"),
501 fi->filename);
502 return 0;
503 }
504 return max;
505}
506
507
508void *
510{
511 struct FileInfo *fi;
512
513 fi = GNUNET_new (struct FileInfo);
515 if (NULL == fi->filename)
516 {
517 GNUNET_free (fi);
518 return NULL;
519 }
520 return fi;
521}
522
523
544size_t
546 uint64_t offset,
547 size_t max,
548 void *buf,
549 char **emsg)
550{
551 char *data = cls;
552
553 if (UINT64_MAX == offset)
554 return 0;
555 if (0 == max)
556 {
558 return 0;
559 }
560 GNUNET_memcpy (buf, &data[offset], max);
561 return max;
562}
563
564
574static char *
576 const char *ext,
577 const char *ent)
578{
579 char *basename;
580 char *ret;
581
582 if (0 == (h->flags & GNUNET_FS_FLAGS_PERSISTENCE))
583 return NULL; /* persistence not requested */
585 "fs",
586 "STATE_DIR",
587 &basename))
588 return NULL;
590 "%s%s%s%s%s%s%s",
591 basename,
593 h->client_name,
595 ext,
597 ent);
598 GNUNET_free (basename);
599 return ret;
600}
601
602
614static char *
616 const char *ext,
617 const char *uni,
618 const char *ent)
619{
620 char *basename;
621 char *ret;
622
623 if (0 == (h->flags & GNUNET_FS_FLAGS_PERSISTENCE))
624 return NULL; /* persistence not requested */
626 "fs",
627 "STATE_DIR",
628 &basename))
629 return NULL;
631 "%s%s%s%s%s%s%s.dir%s%s",
632 basename,
634 h->client_name,
636 ext,
638 uni,
640 ent);
641 GNUNET_free (basename);
642 return ret;
643}
644
645
654static struct GNUNET_BIO_ReadHandle *
655get_read_handle (struct GNUNET_FS_Handle *h, const char *ext, const char *ent)
656{
657 char *fn;
659
660 fn = get_serialization_file_name (h, ext, ent);
661 if (NULL == fn)
662 return NULL;
664 GNUNET_free (fn);
665 return ret;
666}
667
668
677static struct GNUNET_BIO_WriteHandle *
678get_write_handle (struct GNUNET_FS_Handle *h, const char *ext, const char *ent)
679{
680 char *fn;
682
683 fn = get_serialization_file_name (h, ext, ent);
684 if (NULL == fn)
685 return NULL;
687 GNUNET_break (NULL != ret);
688 GNUNET_free (fn);
689 return ret;
690}
691
692
702static struct GNUNET_BIO_WriteHandle *
704 const char *ext,
705 const char *uni,
706 const char *ent)
707{
708 char *fn;
710
711 fn = get_serialization_file_name_in_dir (h, ext, uni, ent);
712 if (NULL == fn)
713 return NULL;
715 GNUNET_free (fn);
716 return ret;
717}
718
719
727void
729 const char *ext,
730 const char *ent)
731{
732 char *filename;
733
734 if ((NULL == ent) || (0 == strlen (ent)))
735 {
736 GNUNET_break (0);
737 return;
738 }
740 if (NULL != filename)
741 {
742 if ((0 != unlink (filename)) && (ENOENT != errno))
745 }
746}
747
748
757static void
759 const char *ext,
760 const char *uni,
761 const char *ent)
762{
763 char *filename;
764
765 if ((NULL == ent) || (0 == strlen (ent)))
766 {
767 GNUNET_break (0);
768 return;
769 }
771 if (NULL == filename)
772 return;
773 if (0 != unlink (filename))
776}
777
778
786void
788 const char *ext,
789 const char *uni)
790{
791 char *dn;
792
793 if (NULL == uni)
794 return;
795 dn = get_serialization_file_name_in_dir (h, ext, uni, "");
796 if (NULL == dn)
797 return;
801 GNUNET_free (dn);
802}
803
804
819static int
822{
823 struct GNUNET_TIME_Relative dur;
824
826 return GNUNET_BIO_write_int64 (wh, "start time", dur.rel_value_us);
827}
828
829
844static int
847{
848 struct GNUNET_TIME_Relative dur;
849
850 if (GNUNET_OK != GNUNET_BIO_read_int64 (rh, "start time",
851 (int64_t *) &dur.rel_value_us))
852 return GNUNET_SYSERR;
854 return GNUNET_OK;
855}
856
857
867static struct GNUNET_FS_FileInformation *
869
870
881static struct GNUNET_FS_FileInformation *
883 const char *fn,
884 struct GNUNET_BIO_ReadHandle *rh)
885{
887 struct GNUNET_FS_FileInformation *nxt;
888 char b;
889 char *ksks;
890 char *chks;
891 char *skss;
892 char *filename;
893 uint32_t dsize;
894
895 if (GNUNET_OK != GNUNET_BIO_read (rh, "status flag", &b, sizeof(b)))
896 {
897 GNUNET_break (0);
898 return NULL;
899 }
901 ret->h = h;
902 ksks = NULL;
903 chks = NULL;
904 skss = NULL;
905 filename = NULL;
906 if ((GNUNET_OK != GNUNET_FS_read_meta_data (rh, "metadata", &ret->meta)) ||
907 (GNUNET_OK != GNUNET_BIO_read_string (rh, "ksk-uri", &ksks, 32 * 1024)) ||
908 ((NULL != ksks) &&
909 ((NULL == (ret->keywords = GNUNET_FS_uri_parse (ksks, NULL))) ||
910 (GNUNET_YES != GNUNET_FS_uri_test_ksk (ret->keywords)))) ||
911 (GNUNET_OK != GNUNET_BIO_read_string (rh, "chk-uri", &chks, 1024)) ||
912 ((NULL != chks) &&
913 ((NULL == (ret->chk_uri = GNUNET_FS_uri_parse (chks, NULL))) ||
914 (GNUNET_YES != GNUNET_FS_uri_test_chk (ret->chk_uri)))) ||
915 (GNUNET_OK != GNUNET_BIO_read_string (rh, "sks-uri", &skss, 1024)) ||
916 ((NULL != skss) &&
917 ((NULL == (ret->sks_uri = GNUNET_FS_uri_parse (skss, NULL))) ||
918 (GNUNET_YES != GNUNET_FS_uri_test_sks (ret->sks_uri)))) ||
919 (GNUNET_OK != read_start_time (rh, &ret->start_time)) ||
920 (GNUNET_OK !=
921 GNUNET_BIO_read_string (rh, "emsg", &ret->emsg, 16 * 1024)) ||
922 (GNUNET_OK !=
923 GNUNET_BIO_read_string (rh, "fn", &ret->filename, 16 * 1024)) ||
924 (GNUNET_OK !=
926 rh,
927 "expiration time",
928 (int64_t *) &ret->bo.expiration_time.abs_value_us)) ||
930 rh,
931 "anonymity level",
932 (int32_t *) &ret->bo.anonymity_level)) ||
934 rh,
935 "content priority",
936 (int32_t *) &ret->bo.content_priority)) ||
938 rh,
939 "replication level",
940 (int32_t *) &ret->bo.replication_level)))
941 {
942 GNUNET_break (0);
943 goto cleanup;
944 }
945 switch (b)
946 {
947 case 0: /* file-insert */
949 rh,
950 "file size",
951 (int64_t *) &ret->data.file.file_size))
952 {
953 GNUNET_break (0);
954 goto cleanup;
955 }
956 ret->is_directory = GNUNET_NO;
957 ret->data.file.do_index = GNUNET_NO;
958 ret->data.file.have_hash = GNUNET_NO;
959 ret->data.file.index_start_confirmed = GNUNET_NO;
960 if (GNUNET_NO == ret->is_published)
961 {
962 if (NULL == ret->filename)
963 {
964 ret->data.file.reader = &GNUNET_FS_data_reader_copy_;
965 ret->data.file.reader_cls =
966 GNUNET_malloc_large (ret->data.file.file_size);
967 if (ret->data.file.reader_cls == NULL)
968 goto cleanup;
969 if (GNUNET_OK != GNUNET_BIO_read (rh,
970 "file-data",
971 ret->data.file.reader_cls,
972 ret->data.file.file_size))
973 {
974 GNUNET_break (0);
975 goto cleanup;
976 }
977 }
978 else
979 {
980 ret->data.file.reader = &GNUNET_FS_data_reader_file_;
981 ret->data.file.reader_cls =
983 }
984 }
985 break;
986
987 case 1: /* file-index, no hash */
988 if (NULL == ret->filename)
989 {
990 GNUNET_break (0);
991 goto cleanup;
992 }
994 rh,
995 "file size",
996 (int64_t *) &ret->data.file.file_size))
997 {
998 GNUNET_break (0);
999 goto cleanup;
1000 }
1001 ret->is_directory = GNUNET_NO;
1002 ret->data.file.do_index = GNUNET_YES;
1003 ret->data.file.have_hash = GNUNET_NO;
1004 ret->data.file.index_start_confirmed = GNUNET_NO;
1005 ret->data.file.reader = &GNUNET_FS_data_reader_file_;
1006 ret->data.file.reader_cls =
1008 break;
1009
1010 case 2: /* file-index-with-hash */
1011 if (NULL == ret->filename)
1012 {
1013 GNUNET_break (0);
1014 goto cleanup;
1015 }
1017 rh,
1018 "file size",
1019 (int64_t *) &ret->data.file.file_size)) ||
1020 (GNUNET_OK != GNUNET_BIO_read (rh,
1021 "fileid",
1022 &ret->data.file.file_id,
1023 sizeof(struct GNUNET_HashCode))))
1024 {
1025 GNUNET_break (0);
1026 goto cleanup;
1027 }
1028 ret->is_directory = GNUNET_NO;
1029 ret->data.file.do_index = GNUNET_YES;
1030 ret->data.file.have_hash = GNUNET_YES;
1031 ret->data.file.index_start_confirmed = GNUNET_NO;
1032 ret->data.file.reader = &GNUNET_FS_data_reader_file_;
1033 ret->data.file.reader_cls =
1035 break;
1036
1037 case 3: /* file-index-with-hash-confirmed */
1038 if (NULL == ret->filename)
1039 {
1040 GNUNET_break (0);
1041 goto cleanup;
1042 }
1044 rh,
1045 "file size",
1046 (int64_t *) &ret->data.file.file_size)) ||
1047 (GNUNET_OK != GNUNET_BIO_read (rh,
1048 "fileid",
1049 &ret->data.file.file_id,
1050 sizeof(struct GNUNET_HashCode))))
1051 {
1052 GNUNET_break (0);
1053 goto cleanup;
1054 }
1055 ret->is_directory = GNUNET_NO;
1056 ret->data.file.do_index = GNUNET_YES;
1057 ret->data.file.have_hash = GNUNET_YES;
1058 ret->data.file.index_start_confirmed = GNUNET_YES;
1059 ret->data.file.reader = &GNUNET_FS_data_reader_file_;
1060 ret->data.file.reader_cls =
1062 break;
1063
1064 case 4: /* directory */
1065 ret->is_directory = GNUNET_YES;
1066 if ((GNUNET_OK != GNUNET_BIO_read_int32 (rh, "dsize",
1067 (int32_t *) &dsize)) ||
1068 (GNUNET_OK !=
1070 rh,
1071 "contents completed",
1072 (int64_t *) &ret->data.dir.contents_completed)) ||
1073 (GNUNET_OK !=
1075 rh,
1076 "contents size",
1077 (int64_t *) &ret->data.dir.contents_size)) ||
1078 (NULL == (ret->data.dir.dir_data = GNUNET_malloc_large (dsize))) ||
1079 (GNUNET_OK !=
1080 GNUNET_BIO_read (rh, "dir-data", ret->data.dir.dir_data, dsize)) ||
1081 (GNUNET_OK !=
1082 GNUNET_BIO_read_string (rh, "ent-filename", &filename, 16 * 1024)))
1083 {
1084 GNUNET_break (0);
1085 goto cleanup;
1086 }
1087 ret->data.dir.dir_size = (uint32_t) dsize;
1088 if (NULL != filename)
1089 {
1090 ret->data.dir.entries = deserialize_file_information (h, filename);
1092 filename = NULL;
1093 nxt = ret->data.dir.entries;
1094 while (NULL != nxt)
1095 {
1096 nxt->dir = ret;
1097 nxt = nxt->next;
1098 }
1099 }
1100 break;
1101
1102 default:
1103 GNUNET_break (0);
1104 goto cleanup;
1105 }
1106 ret->serialization = GNUNET_strdup (fn);
1107 if (GNUNET_OK !=
1108 GNUNET_BIO_read_string (rh, "nxt-filename", &filename, 16 * 1024))
1109 {
1110 GNUNET_break (0);
1111 goto cleanup;
1112 }
1113 if (NULL != filename)
1114 {
1117 filename = NULL;
1118 }
1119 GNUNET_free (ksks);
1120 GNUNET_free (skss);
1121 GNUNET_free (chks);
1122 return ret;
1123cleanup:
1124 GNUNET_free (ksks);
1125 GNUNET_free (chks);
1126 GNUNET_free (skss);
1129 return NULL;
1130}
1131
1132
1142static struct GNUNET_FS_FileInformation *
1144{
1146 struct GNUNET_BIO_ReadHandle *rh;
1147 char *emsg;
1148 char *fn;
1149
1151 if (NULL == rh)
1152 return NULL;
1154 if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
1155 {
1157 _ ("Failed to resume publishing information `%s': %s\n"),
1158 filename,
1159 emsg);
1160 GNUNET_free (emsg);
1161 }
1162 if (NULL == ret)
1163 {
1164 fn =
1166 if (NULL != fn)
1167 {
1168 if (0 != unlink (fn))
1170 GNUNET_free (fn);
1171 }
1172 }
1173 return ret;
1174}
1175
1176
1185static char *
1186get_serialization_short_name (const char *fullname)
1187{
1188 const char *end;
1189 const char *nxt;
1190
1191 end = NULL;
1192 nxt = fullname;
1193 /* FIXME: we could do this faster since we know
1194 * the length of 'end'... */
1195 while ('\0' != *nxt)
1196 {
1197 if (DIR_SEPARATOR == *nxt)
1198 end = nxt + 1;
1199 nxt++;
1200 }
1201 if ((NULL == end) || (0 == strlen (end)))
1202 {
1203 GNUNET_break (0);
1204 return NULL;
1205 }
1206 GNUNET_break (6 == strlen (end));
1207 return GNUNET_strdup (end);
1208}
1209
1210
1219static char *
1221{
1222 char *fn;
1223 char *dn;
1224 char *ret;
1225
1226 if (0 == (h->flags & GNUNET_FS_FLAGS_PERSISTENCE))
1227 return NULL; /* persistence not requested */
1228 dn = get_serialization_file_name (h, ext, "");
1229 if (NULL == dn)
1230 return NULL;
1232 {
1233 GNUNET_free (dn);
1234 return NULL;
1235 }
1236 fn = GNUNET_DISK_mktemp (dn);
1237 GNUNET_free (dn);
1238 if (NULL == fn)
1239 return NULL; /* epic fail */
1241 GNUNET_free (fn);
1242 return ret;
1243}
1244
1245
1255static char *
1257 const char *ext,
1258 const char *uni)
1259{
1260 char *fn;
1261 char *dn;
1262 char *ret;
1263
1264 if (0 == (h->flags & GNUNET_FS_FLAGS_PERSISTENCE))
1265 return NULL; /* persistence not requested */
1266 dn = get_serialization_file_name_in_dir (h, ext, uni, "");
1267 if (NULL == dn)
1268 return NULL;
1270 {
1271 GNUNET_free (dn);
1272 return NULL;
1273 }
1274 fn = GNUNET_DISK_mktemp (dn);
1275 GNUNET_free (dn);
1276 if (NULL == fn)
1277 return NULL; /* epic fail */
1279 GNUNET_free (fn);
1280 return ret;
1281}
1282
1283
1291static int
1293 struct GNUNET_FS_FileInformation *fi)
1294{
1295 char buf[32 * 1024];
1296 uint64_t off;
1297 size_t ret;
1298 size_t left;
1299 char *emsg;
1300
1301 emsg = NULL;
1302 off = 0;
1303 while (off < fi->data.file.file_size)
1304 {
1305 left = GNUNET_MIN (sizeof(buf), fi->data.file.file_size - off);
1306 ret =
1307 fi->data.file.reader (fi->data.file.reader_cls, off, left, buf, &emsg);
1308 if (0 == ret)
1309 {
1310 GNUNET_free (emsg);
1311 return GNUNET_SYSERR;
1312 }
1313 if (GNUNET_OK != GNUNET_BIO_write (wh, "copied from reader", buf, ret))
1314 return GNUNET_SYSERR;
1315 off += ret;
1316 }
1317 return GNUNET_OK;
1318}
1319
1320
1327void
1329{
1330 char *fn;
1331 struct GNUNET_BIO_WriteHandle *wh;
1332 char b;
1333 char *ksks;
1334 char *chks;
1335 char *skss;
1336
1337 if (NULL == fi->serialization)
1338 fi->serialization =
1340 if (NULL == fi->serialization)
1341 return;
1342 wh =
1344 if (NULL == wh)
1345 {
1347 fi->serialization = NULL;
1348 return;
1349 }
1350 if (GNUNET_YES == fi->is_directory)
1351 b = 4;
1352 else if (GNUNET_YES == fi->data.file.index_start_confirmed)
1353 b = 3;
1354 else if (GNUNET_YES == fi->data.file.have_hash)
1355 b = 2;
1356 else if (GNUNET_YES == fi->data.file.do_index)
1357 b = 1;
1358 else
1359 b = 0;
1360 if (NULL != fi->keywords)
1361 ksks = GNUNET_FS_uri_to_string (fi->keywords);
1362 else
1363 ksks = NULL;
1364 if (NULL != fi->chk_uri)
1365 chks = GNUNET_FS_uri_to_string (fi->chk_uri);
1366 else
1367 chks = NULL;
1368 if (NULL != fi->sks_uri)
1369 skss = GNUNET_FS_uri_to_string (fi->sks_uri);
1370 else
1371 skss = NULL;
1372 {
1373 struct GNUNET_BIO_WriteSpec ws1[] = {
1374 GNUNET_BIO_write_spec_object ("b", &b, sizeof (b)),
1376 GNUNET_BIO_write_spec_string ("ksks", ksks),
1377 GNUNET_BIO_write_spec_string ("chks", chks),
1378 GNUNET_BIO_write_spec_string ("skss", skss),
1380 };
1381 struct GNUNET_BIO_WriteSpec ws2[] = {
1382 GNUNET_BIO_write_spec_string ("emsg", fi->emsg),
1383 GNUNET_BIO_write_spec_string ("filename", fi->filename),
1385 "expiration time",
1386 (int64_t *) &fi->bo.expiration_time.abs_value_us),
1388 "anonymity level",
1389 (int32_t *) &fi->bo.anonymity_level),
1391 "content priority",
1392 (int32_t *) &fi->bo.content_priority),
1394 "replication level",
1395 (int32_t *) &fi->bo.replication_level),
1397 };
1398 if ((GNUNET_OK != GNUNET_BIO_write_spec_commit (wh, ws1)) ||
1401 {
1402 GNUNET_break (0);
1403 goto cleanup;
1404 }
1405 }
1406 GNUNET_free (chks);
1407 chks = NULL;
1408 GNUNET_free (ksks);
1409 ksks = NULL;
1410 GNUNET_free (skss);
1411 skss = NULL;
1412
1413 switch (b)
1414 {
1415 case 0: /* file-insert */
1416 if (GNUNET_OK != GNUNET_BIO_write_int64 (wh, "file size",
1417 fi->data.file.file_size))
1418 {
1419 GNUNET_break (0);
1420 goto cleanup;
1421 }
1422 if ((GNUNET_NO == fi->is_published) && (NULL == fi->filename))
1423 if (GNUNET_OK != copy_from_reader (wh, fi))
1424 {
1425 GNUNET_break (0);
1426 goto cleanup;
1427 }
1428 break;
1429
1430 case 1: /* file-index, no hash */
1431 if (NULL == fi->filename)
1432 {
1433 GNUNET_break (0);
1434 goto cleanup;
1435 }
1436 if (GNUNET_OK != GNUNET_BIO_write_int64 (wh, "file size",
1437 fi->data.file.file_size))
1438 {
1439 GNUNET_break (0);
1440 goto cleanup;
1441 }
1442 break;
1443
1444 case 2: /* file-index-with-hash */
1445 case 3: /* file-index-with-hash-confirmed */
1446 if (NULL == fi->filename)
1447 {
1448 GNUNET_break (0);
1449 goto cleanup;
1450 }
1451 if ((GNUNET_OK != GNUNET_BIO_write_int64 (wh, "file size",
1452 fi->data.file.file_size)) ||
1454 "file id",
1455 &fi->data.file.file_id,
1456 sizeof(struct GNUNET_HashCode))))
1457 {
1458 GNUNET_break (0);
1459 goto cleanup;
1460 }
1461 break;
1462
1463 case 4: /* directory */
1464 if ((NULL != fi->data.dir.entries) &&
1465 (NULL == fi->data.dir.entries->serialization))
1467 {
1468 struct GNUNET_BIO_WriteSpec ws[] = {
1469 GNUNET_BIO_write_spec_int32 ("dir size",
1470 (int32_t *) &fi->data.dir.dir_size),
1472 "contents completed",
1473 (int64_t *) &fi->data.dir.contents_completed),
1474 GNUNET_BIO_write_spec_int64 ("contents size",
1475 (int64_t *) &fi->data.dir.contents_size),
1476 GNUNET_BIO_write_spec_object ("dir data",
1477 fi->data.dir.dir_data,
1478 (uint32_t) fi->data.dir.dir_size),
1479 GNUNET_BIO_write_spec_string ("dir entries",
1480 (fi->data.dir.entries == NULL)
1481 ? NULL
1482 : fi->data.dir.entries->serialization),
1484 };
1486 {
1487 GNUNET_break (0);
1488 goto cleanup;
1489 }
1490 }
1491 break;
1492
1493 default:
1494 GNUNET_assert (0);
1495 goto cleanup;
1496 }
1497 if ((NULL != fi->next) && (NULL == fi->next->serialization))
1500 "serialization",
1501 (fi->next != NULL)
1502 ? fi->next->serialization
1503 : NULL))
1504 {
1505 GNUNET_break (0);
1506 goto cleanup;
1507 }
1508 if (GNUNET_OK != GNUNET_BIO_write_close (wh, NULL))
1509 {
1510 wh = NULL;
1511 GNUNET_break (0);
1512 goto cleanup;
1513 }
1514 return; /* done! */
1515cleanup:
1516 if (NULL != wh)
1517 (void) GNUNET_BIO_write_close (wh, NULL);
1518 GNUNET_free (chks);
1519 GNUNET_free (ksks);
1520 GNUNET_free (skss);
1523 fi->serialization);
1524 if (NULL != fn)
1525 {
1526 if (0 != unlink (fn))
1528 GNUNET_free (fn);
1529 }
1531 fi->serialization = NULL;
1532}
1533
1534
1543static struct GNUNET_FS_FileInformation *
1544find_file_position (struct GNUNET_FS_FileInformation *pos, const char *srch)
1545{
1546 struct GNUNET_FS_FileInformation *r;
1547
1548 while (NULL != pos)
1549 {
1550 if (0 == strcmp (srch, pos->serialization))
1551 return pos;
1552 if ((GNUNET_YES == pos->is_directory) &&
1553 (NULL != (r = find_file_position (pos->data.dir.entries, srch))))
1554 return r;
1555 pos = pos->next;
1556 }
1557 return NULL;
1558}
1559
1560
1575static int
1577 struct GNUNET_FS_FileInformation *fi,
1578 uint64_t length,
1579 struct GNUNET_FS_MetaData *meta,
1580 struct GNUNET_FS_Uri **uri,
1581 struct GNUNET_FS_BlockOptions *bo,
1582 int *do_index,
1583 void **client_info)
1584{
1585 struct GNUNET_FS_PublishContext *pc = cls;
1586 struct GNUNET_FS_ProgressInfo pi;
1587
1589 {
1591 return GNUNET_OK;
1592 }
1594 pi.value.publish.specifics.resume.message = fi->emsg;
1595 pi.value.publish.specifics.resume.chk_uri = fi->chk_uri;
1596 *client_info = GNUNET_FS_publish_make_status_ (&pi, pc, fi, 0);
1598 {
1599 /* process entries in directory */
1602 }
1603 return GNUNET_OK;
1604}
1605
1606
1615static int
1616deserialize_publish_file (void *cls, const char *filename)
1617{
1618 struct GNUNET_FS_Handle *h = cls;
1619 struct GNUNET_BIO_ReadHandle *rh;
1621 int32_t options;
1622 int32_t all_done;
1623 int32_t have_ns;
1624 char *fi_root;
1626 char *fi_pos;
1627 char *emsg;
1628
1630 pc->h = h;
1632 fi_root = NULL;
1633 fi_pos = NULL;
1635 if (NULL == rh)
1636 {
1637 GNUNET_break (0);
1638 goto cleanup;
1639 }
1640 {
1641 struct GNUNET_BIO_ReadSpec rs[] = {
1642 GNUNET_BIO_read_spec_string ("publish-nid", &pc->nid, 1024),
1643 GNUNET_BIO_read_spec_string ("publish-nuid", &pc->nuid, 1024),
1644 GNUNET_BIO_read_spec_int32 ("options", &options),
1645 GNUNET_BIO_read_spec_int32 ("all done", &all_done),
1646 GNUNET_BIO_read_spec_int32 ("have ns", &have_ns),
1647 GNUNET_BIO_read_spec_string ("publish-firoot", &fi_root, 128),
1648 GNUNET_BIO_read_spec_string ("publish-fipos", &fi_pos, 128),
1650 };
1651 if ((GNUNET_OK != GNUNET_BIO_read_spec_commit (rh, rs)) ||
1652 ((GNUNET_YES == have_ns) &&
1653 (GNUNET_OK != GNUNET_BIO_read (rh, "publish-ns", &ns, sizeof(ns)))))
1654 {
1655 GNUNET_break (0);
1656 goto cleanup;
1657 }
1658 }
1659 pc->options = options;
1660 pc->all_done = all_done;
1661 if (NULL == fi_root)
1662 {
1663 GNUNET_break (0);
1664 goto cleanup;
1665 }
1666 pc->fi = deserialize_file_information (h, fi_root);
1667 if (NULL == pc->fi)
1668 {
1669 GNUNET_break (0);
1670 goto cleanup;
1671 }
1672 if (GNUNET_YES == have_ns)
1673 {
1675 *pc->ns = ns;
1676 }
1678 (GNUNET_YES != pc->all_done))
1679 {
1681 if (NULL == pc->dsh)
1682 goto cleanup;
1683 }
1684 if (NULL != fi_pos)
1685 {
1686 pc->fi_pos = find_file_position (pc->fi, fi_pos);
1687 GNUNET_free (fi_pos);
1688 fi_pos = NULL;
1689 if (NULL == pc->fi_pos)
1690 {
1691 /* failed to find position for resuming, outch! Will start from root! */
1692 GNUNET_break (0);
1693 if (GNUNET_YES != pc->all_done)
1694 pc->fi_pos = pc->fi;
1695 }
1696 }
1697 GNUNET_free (fi_root);
1698 fi_root = NULL;
1699 /* generate RESUME event(s) */
1701
1702 /* re-start publishing (if needed)... */
1703 if (GNUNET_YES != pc->all_done)
1704 {
1705 GNUNET_assert (NULL == pc->upload_task);
1706 pc->upload_task =
1709 pc);
1710 }
1711 if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
1712 {
1714 _ ("Failure while resuming publishing operation `%s': %s\n"),
1715 filename,
1716 emsg);
1717 GNUNET_free (emsg);
1718 }
1720 return GNUNET_OK;
1721cleanup:
1722 GNUNET_free (pc->nid);
1723 GNUNET_free (pc->nuid);
1724 GNUNET_free (fi_root);
1725 GNUNET_free (fi_pos);
1726 if ((NULL != rh) && (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg)))
1727 {
1729 _ ("Failed to resume publishing operation `%s': %s\n"),
1730 filename,
1731 emsg);
1732 GNUNET_free (emsg);
1733 }
1734 if (NULL != pc->fi)
1736 if (0 != unlink (filename))
1739 GNUNET_free (pc);
1740 return GNUNET_OK;
1741}
1742
1743
1752void
1754{
1755 struct GNUNET_BIO_WriteHandle *wh;
1756 int32_t have_ns;
1757
1758 if (NULL == pc->serialization)
1759 pc->serialization =
1761 if (NULL == pc->serialization)
1762 return;
1763 if (NULL == pc->fi)
1764 return;
1765 if (NULL == pc->fi->serialization)
1766 {
1767 GNUNET_break (0);
1768 return;
1769 }
1770 wh = get_write_handle (pc->h,
1772 pc->serialization);
1773 if (NULL == wh)
1774 {
1775 GNUNET_break (0);
1776 goto cleanup;
1777 }
1778 have_ns = (NULL != pc->ns) ? GNUNET_YES : GNUNET_NO;
1779 {
1780 struct GNUNET_BIO_WriteSpec ws[] = {
1783 GNUNET_BIO_write_spec_int32 ("options", (int32_t *) &pc->options),
1784 GNUNET_BIO_write_spec_int32 ("all done", &pc->all_done),
1785 GNUNET_BIO_write_spec_int32 ("have ns", &have_ns),
1786 GNUNET_BIO_write_spec_string ("serialization", pc->fi->serialization),
1787 GNUNET_BIO_write_spec_string ("pos serialization", (NULL == pc->fi_pos)
1788 ? NULL
1789 : pc->fi_pos->serialization),
1791 };
1792 if ((GNUNET_OK != GNUNET_BIO_write_spec_commit (wh, ws)) ||
1793 ((NULL != pc->ns) &&
1794 (GNUNET_OK !=
1796 "ns",
1797 pc->ns,
1798 sizeof(struct GNUNET_CRYPTO_EcdsaPrivateKey)))))
1799 {
1800 GNUNET_break (0);
1801 goto cleanup;
1802 }
1803 }
1804 if (GNUNET_OK != GNUNET_BIO_write_close (wh, NULL))
1805 {
1806 wh = NULL;
1807 GNUNET_break (0);
1808 goto cleanup;
1809 }
1810 return;
1811cleanup:
1812 if (NULL != wh)
1813 (void) GNUNET_BIO_write_close (wh, NULL);
1816 pc->serialization);
1818 pc->serialization = NULL;
1819}
1820
1821
1830void
1832{
1833 struct GNUNET_BIO_WriteHandle *wh;
1834 char *uris;
1835
1836 if (NULL == uc->serialization)
1837 uc->serialization =
1839 if (NULL == uc->serialization)
1840 return;
1841 wh = get_write_handle (uc->h,
1843 uc->serialization);
1844 if (NULL == wh)
1845 {
1846 GNUNET_break (0);
1847 goto cleanup;
1848 }
1849 if (NULL != uc->ksk_uri)
1851 else
1852 uris = NULL;
1853 {
1854 struct GNUNET_BIO_WriteSpec ws1[] = {
1856 GNUNET_BIO_write_spec_int64 ("file size", (int64_t *) &uc->file_size),
1858 };
1859 struct GNUNET_BIO_WriteSpec ws2[] = {
1860 GNUNET_BIO_write_spec_int32 ("state", (int32_t *) &uc->state),
1861 GNUNET_BIO_write_spec_object ("hashkey", &uc->chk,
1862 sizeof (struct ContentHashKey)),
1863 GNUNET_BIO_write_spec_string ("uris", uris),
1864 GNUNET_BIO_write_spec_int32 ("ksk offset", (int32_t *) &uc->ksk_offset),
1866 };
1867 if ((GNUNET_OK != GNUNET_BIO_write_spec_commit (wh, ws1)) ||
1872 "file id",
1873 &uc->file_id,
1874 sizeof(struct GNUNET_HashCode)))) ||
1875 ((uc->state == UNINDEX_STATE_ERROR) &&
1876 (GNUNET_OK != GNUNET_BIO_write_string (wh, "emsg", uc->emsg))))
1877 {
1878 GNUNET_break (0);
1879 goto cleanup;
1880 }
1881 }
1882 if (GNUNET_OK != GNUNET_BIO_write_close (wh, NULL))
1883 {
1884 wh = NULL;
1885 GNUNET_break (0);
1886 goto cleanup;
1887 }
1888 return;
1889cleanup:
1890 if (NULL != wh)
1891 (void) GNUNET_BIO_write_close (wh, NULL);
1894 uc->serialization);
1896 uc->serialization = NULL;
1897}
1898
1899
1907static int
1909 struct DownloadRequest *dr)
1910{
1911 unsigned int i;
1912 struct GNUNET_BIO_WriteSpec ws[] = {
1913 GNUNET_BIO_write_spec_int32 ("state", (int32_t *) &dr->state),
1914 GNUNET_BIO_write_spec_int64 ("offset", (int64_t *) &dr->offset),
1915 GNUNET_BIO_write_spec_int32 ("num children", (int32_t *) &dr->num_children),
1916 GNUNET_BIO_write_spec_int32 ("depth", (int32_t *) &dr->depth),
1918 };
1919
1921 return GNUNET_NO;
1922 if ((BRS_CHK_SET == dr->state) &&
1923 (GNUNET_OK !=
1924 GNUNET_BIO_write (wh, "hashkey",
1925 &dr->chk, sizeof(struct ContentHashKey))))
1926 return GNUNET_NO;
1927 for (i = 0; i < dr->num_children; i++)
1929 return GNUNET_NO;
1930 return GNUNET_YES;
1931}
1932
1933
1940static struct DownloadRequest *
1942{
1943 struct DownloadRequest *dr;
1944 unsigned int i;
1945
1946 dr = GNUNET_new (struct DownloadRequest);
1947 {
1948 struct GNUNET_BIO_ReadSpec rs[] = {
1949 GNUNET_BIO_read_spec_int32 ("state", (int32_t *) &dr->state),
1950 GNUNET_BIO_read_spec_int64 ("offset", (int64_t *) &dr->offset),
1951 GNUNET_BIO_read_spec_int32 ("num children", (int32_t *) &dr->num_children)
1952 ,
1954 };
1955 if ((GNUNET_OK != GNUNET_BIO_read_spec_commit (rh, rs)) ||
1956 (dr->num_children > CHK_PER_INODE) ||
1957 (GNUNET_OK != GNUNET_BIO_read_int32 (rh, "depth",
1958 (int32_t *) &dr->depth)) ||
1959 ((0 == dr->depth) && (dr->num_children > 0)) ||
1960 ((dr->depth > 0) && (0 == dr->num_children)))
1961 {
1962 GNUNET_break (0);
1963 dr->num_children = 0;
1964 goto cleanup;
1965 }
1966 }
1967 if (dr->num_children > 0)
1968 dr->children =
1969 GNUNET_malloc (dr->num_children * sizeof(struct DownloadRequest *));
1970 switch (dr->state)
1971 {
1972 case BRS_INIT:
1975 case BRS_RECONSTRUCT_UP:
1976 break;
1977
1978 case BRS_CHK_SET:
1979 if (GNUNET_OK !=
1980 GNUNET_BIO_read (rh, "chk", &dr->chk, sizeof(struct ContentHashKey)))
1981 goto cleanup;
1982 break;
1983
1984 case BRS_DOWNLOAD_DOWN:
1985 case BRS_DOWNLOAD_UP:
1986 case BRS_ERROR:
1987 break;
1988
1989 default:
1990 GNUNET_break (0);
1991 goto cleanup;
1992 }
1993 for (i = 0; i < dr->num_children; i++)
1994 {
1995 if (NULL == (dr->children[i] = read_download_request (rh)))
1996 goto cleanup;
1997 dr->children[i]->parent = dr;
1998 }
1999 return dr;
2000cleanup:
2002 return NULL;
2003}
2004
2005
2015static char *
2017 const char *uni,
2018 const char *ext)
2019{
2020 char *par;
2021 char *epar;
2022
2023 if (dc->parent == NULL)
2025 (dc->search != NULL)
2028 uni);
2029 if (NULL == dc->parent->serialization)
2030 return NULL;
2032 if (NULL == par)
2033 return NULL;
2034 GNUNET_asprintf (&epar, "%s.dir%s%s%s", par, DIR_SEPARATOR_STR, uni, ext);
2035 GNUNET_free (par);
2036 return epar;
2037}
2038
2039
2048void
2050{
2051 struct GNUNET_BIO_WriteHandle *wh;
2052 char *uris;
2053 char *fn;
2054 char *dir;
2055
2057 return; /* we don't sync probes */
2058 if (NULL == dc->serialization)
2059 {
2060 dir = get_download_sync_filename (dc, "", "");
2061 if (NULL == dir)
2062 return;
2064 {
2065 GNUNET_free (dir);
2066 return;
2067 }
2068 fn = GNUNET_DISK_mktemp (dir);
2069 GNUNET_free (dir);
2070 if (NULL == fn)
2071 return;
2073 }
2074 else
2075 {
2077 if (NULL == fn)
2078 {
2080 dc->serialization = NULL;
2081 GNUNET_free (fn);
2082 return;
2083 }
2084 }
2086 if (NULL == wh)
2087 {
2089 dc->serialization = NULL;
2090 GNUNET_free (fn);
2091 return;
2092 }
2095 uris = GNUNET_FS_uri_to_string (dc->uri);
2096 {
2097 struct GNUNET_BIO_WriteSpec ws1[] = {
2098 GNUNET_BIO_write_spec_string ("uris", uris),
2099 GNUNET_FS_write_spec_meta_data ("metadata", dc->meta),
2102 GNUNET_BIO_write_spec_string ("temp filename", dc->temp_filename),
2103 GNUNET_BIO_write_spec_int64 ("old file size",
2104 (int64_t *) &dc->old_file_size),
2105 GNUNET_BIO_write_spec_int64 ("offset", (int64_t *) &dc->offset),
2106 GNUNET_BIO_write_spec_int64 ("length", (int64_t *) &dc->length),
2107 GNUNET_BIO_write_spec_int64 ("completed", (int64_t *) &dc->completed),
2109 };
2110 struct GNUNET_BIO_WriteSpec ws2[] = {
2111 GNUNET_BIO_write_spec_int32 ("anonymity", (int32_t *) &dc->anonymity),
2112 GNUNET_BIO_write_spec_int32 ("options", (int32_t *) &dc->options),
2113 GNUNET_BIO_write_spec_int32 ("has finished", (int32_t *) &dc->has_finished
2114 ),
2116 };
2117 if ((GNUNET_OK != GNUNET_BIO_write_spec_commit (wh, ws1)) ||
2120 {
2121 GNUNET_break (0);
2122 goto cleanup;
2123 }
2124 }
2125 if (NULL == dc->emsg)
2126 {
2127 GNUNET_assert (dc->top_request != NULL);
2129 {
2130 GNUNET_break (0);
2131 goto cleanup;
2132 }
2133 }
2134 GNUNET_free (uris);
2135 uris = NULL;
2136 if (GNUNET_OK != GNUNET_BIO_write_close (wh, NULL))
2137 {
2138 wh = NULL;
2139 GNUNET_break (0);
2140 goto cleanup;
2141 }
2142 GNUNET_free (fn);
2143 return;
2144cleanup:
2145 if (NULL != wh)
2146 (void) GNUNET_BIO_write_close (wh, NULL);
2147 GNUNET_free (uris);
2148 if (0 != unlink (fn))
2150 GNUNET_free (fn);
2152 dc->serialization = NULL;
2153}
2154
2155
2164void
2166{
2167 struct GNUNET_BIO_WriteHandle *wh;
2168 char *uris;
2169
2170 if (NULL == sr->sc)
2171 return;
2172 uris = NULL;
2173 if (NULL == sr->serialization)
2174 sr->serialization =
2176 (sr->sc->psearch_result == NULL)
2179 sr->sc->serialization);
2180 if (NULL == sr->serialization)
2181 return;
2182 wh = get_write_handle_in_dir (sr->h,
2183 (sr->sc->psearch_result == NULL)
2186 sr->sc->serialization,
2187 sr->serialization);
2188 if (NULL == wh)
2189 {
2190 GNUNET_break (0);
2191 goto cleanup;
2192 }
2193 uris = GNUNET_FS_uri_to_string (sr->uri);
2194 {
2195 struct GNUNET_BIO_WriteSpec ws[] = {
2196 GNUNET_BIO_write_spec_string ("uris", uris),
2197 GNUNET_BIO_write_spec_string ("download serialization",
2198 (sr->download != NULL)
2199 ? sr->download->serialization
2200 : NULL),
2201 GNUNET_BIO_write_spec_string ("update search serialization",
2202 (sr->update_search != NULL)
2204 : NULL),
2205 GNUNET_FS_write_spec_meta_data ("metadata", sr->meta),
2206 GNUNET_BIO_write_spec_object ("key", &sr->key,
2207 sizeof(struct GNUNET_HashCode)),
2208 GNUNET_BIO_write_spec_int32 ("mandatory missing",
2209 (int32_t *) &sr->mandatory_missing),
2210 GNUNET_BIO_write_spec_int32 ("optional support",
2211 (int32_t *) &sr->optional_support),
2212 GNUNET_BIO_write_spec_int32 ("availability success",
2213 (int32_t *) &sr->availability_success),
2214 GNUNET_BIO_write_spec_int32 ("availability trials",
2215 (int32_t *) &sr->availability_trials),
2217 };
2219 {
2220 GNUNET_break (0);
2221 goto cleanup;
2222 }
2223 }
2224 if ((NULL != sr->uri) && (GNUNET_FS_URI_KSK == sr->sc->uri->type) &&
2225 (GNUNET_OK !=
2227 "keyword bitmap",
2228 sr->keyword_bitmap,
2229 (sr->sc->uri->data.ksk.keywordCount + 7) / 8)))
2230 {
2231 GNUNET_break (0);
2232 goto cleanup;
2233 }
2234 if (GNUNET_OK != GNUNET_BIO_write_close (wh, NULL))
2235 {
2236 wh = NULL;
2237 GNUNET_break (0);
2238 goto cleanup;
2239 }
2240 GNUNET_free (uris);
2241 return;
2242cleanup:
2243 GNUNET_free (uris);
2244 if (NULL != wh)
2245 (void) GNUNET_BIO_write_close (wh, NULL);
2247 (NULL == sr->sc->psearch_result)
2250 sr->sc->serialization,
2251 sr->serialization);
2253 sr->serialization = NULL;
2254}
2255
2256
2265void
2267{
2268 struct GNUNET_BIO_WriteHandle *wh;
2269 char *uris;
2270 char in_pause;
2271 const char *category;
2272
2275 if (NULL == sc->serialization)
2277 if (NULL == sc->serialization)
2278 return;
2279 uris = NULL;
2280 wh = get_write_handle (sc->h, category, sc->serialization);
2281 if (NULL == wh)
2282 {
2283 GNUNET_break (0);
2284 goto cleanup;
2285 }
2288 uris = GNUNET_FS_uri_to_string (sc->uri);
2289 in_pause = (sc->task != NULL) ? 'r' : '\0';
2290 if ((GNUNET_OK != GNUNET_BIO_write_string (wh, "uris", uris)) ||
2292 (GNUNET_OK != GNUNET_BIO_write_string (wh, "emsg", sc->emsg)) ||
2293 (GNUNET_OK != GNUNET_BIO_write_int32 (wh, "options",
2294 (uint32_t) sc->options)) ||
2295 (GNUNET_OK != GNUNET_BIO_write (wh, "in pause",
2296 &in_pause, sizeof(in_pause))) ||
2297 (GNUNET_OK != GNUNET_BIO_write_int32 (wh, "anonymity", sc->anonymity)))
2298 {
2299 GNUNET_break (0);
2300 goto cleanup;
2301 }
2302 GNUNET_free (uris);
2303 uris = NULL;
2304 if (GNUNET_OK != GNUNET_BIO_write_close (wh, NULL))
2305 {
2306 wh = NULL;
2307 GNUNET_break (0);
2308 goto cleanup;
2309 }
2310 return;
2311cleanup:
2312 if (NULL != wh)
2313 (void) GNUNET_BIO_write_close (wh, NULL);
2314 GNUNET_free (uris);
2317 sc->serialization = NULL;
2318}
2319
2320
2329static int
2330deserialize_unindex_file (void *cls, const char *filename)
2331{
2332 struct GNUNET_FS_Handle *h = cls;
2333 struct GNUNET_BIO_ReadHandle *rh;
2335 struct GNUNET_FS_ProgressInfo pi;
2336 char *emsg;
2337 char *uris;
2338 uint32_t state;
2339
2341 uc->h = h;
2344 if (NULL == rh)
2345 {
2346 GNUNET_break (0);
2347 goto cleanup;
2348 }
2349 uris = NULL;
2350 if ((GNUNET_OK !=
2351 GNUNET_BIO_read_string (rh, "unindex-fn", &uc->filename, 10 * 1024)) ||
2352 (GNUNET_OK != GNUNET_BIO_read_int64 (rh, "file size",
2353 (int64_t *) &uc->file_size)) ||
2354 (GNUNET_OK != read_start_time (rh, &uc->start_time)) ||
2355 (GNUNET_OK != GNUNET_BIO_read_int32 (rh, "state",
2356 (int32_t *) &state)) ||
2357 (GNUNET_OK !=
2358 GNUNET_BIO_read (rh, "uri", &uc->chk, sizeof(struct ContentHashKey))) ||
2359 (GNUNET_OK !=
2360 GNUNET_BIO_read_string (rh, "unindex-kskuri", &uris, 10 * 1024)) ||
2361 (GNUNET_OK != GNUNET_BIO_read_int32 (rh, "ksk offset",
2362 (int32_t *) &uc->ksk_offset)))
2363 {
2364 GNUNET_free (uris);
2365 GNUNET_break (0);
2366 goto cleanup;
2367 }
2368 if (NULL != uris)
2369 {
2370 uc->ksk_uri = GNUNET_FS_uri_parse (uris, &emsg);
2371 GNUNET_free (uris);
2372 if (NULL == uc->ksk_uri)
2373 {
2374 GNUNET_break (0);
2375 GNUNET_free (emsg);
2376 goto cleanup;
2377 }
2378 }
2379 if ((uc->ksk_offset > 0) &&
2380 ((NULL == uc->ksk_uri) ||
2382 {
2383 GNUNET_break (0);
2384 goto cleanup;
2385 }
2386 uc->state = (enum UnindexState) state;
2387 switch (state)
2388 {
2390 break;
2391
2393 if (GNUNET_OK != GNUNET_BIO_read (rh,
2394 "unindex-hash",
2395 &uc->file_id,
2396 sizeof(struct GNUNET_HashCode)))
2397 {
2398 GNUNET_break (0);
2399 goto cleanup;
2400 }
2401 break;
2402
2406 break;
2407
2409 break;
2410
2412 if (GNUNET_OK !=
2413 GNUNET_BIO_read_string (rh, "unindex-emsg", &uc->emsg, 10 * 1024))
2414 {
2415 GNUNET_break (0);
2416 goto cleanup;
2417 }
2418 break;
2419
2420 default:
2421 GNUNET_break (0);
2422 goto cleanup;
2423 }
2426 pi.value.unindex.specifics.resume.message = uc->emsg;
2428 uc,
2430 ? uc->file_size
2431 : 0);
2432 switch (uc->state)
2433 {
2436 uc->filename,
2439 uc);
2440 break;
2441
2445 break;
2446
2449 break;
2450
2453 break;
2454
2457 break;
2458
2461 /* no need to resume any operation, we were done */
2462 break;
2463
2464 default:
2465 break;
2466 }
2467 if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
2468 {
2470 _ ("Failure while resuming unindexing operation `%s': %s\n"),
2471 filename,
2472 emsg);
2473 GNUNET_free (emsg);
2474 }
2475 return GNUNET_OK;
2476cleanup:
2478 if ((NULL != rh) && (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg)))
2479 {
2481 _ ("Failed to resume unindexing operation `%s': %s\n"),
2482 filename,
2483 emsg);
2484 GNUNET_free (emsg);
2485 }
2486 if (NULL != uc->serialization)
2489 uc->serialization);
2491 GNUNET_free (uc);
2492 return GNUNET_OK;
2493}
2494
2495
2505static void
2507 struct GNUNET_BIO_ReadHandle *rh,
2508 struct GNUNET_FS_DownloadContext *parent,
2510 const char *serialization);
2511
2512
2521static struct GNUNET_FS_SearchContext *
2523 struct GNUNET_BIO_ReadHandle *rh,
2525 const char *serialization);
2526
2527
2536static int
2537deserialize_search_result (void *cls, const char *filename)
2538{
2539 struct GNUNET_FS_SearchContext *sc = cls;
2540 char *serialized;
2541 char *uris;
2542 char *emsg;
2543 char *download;
2544 char *update_srch;
2545 struct GNUNET_BIO_ReadHandle *rh;
2546 struct GNUNET_BIO_ReadHandle *drh;
2547 struct GNUNET_FS_SearchResult *sr;
2548
2551 if (NULL == rh)
2552 {
2553 if (NULL != serialized)
2554 {
2556 (NULL == sc->psearch_result)
2560 serialized);
2561 GNUNET_free (serialized);
2562 }
2563 return GNUNET_OK;
2564 }
2565 emsg = NULL;
2566 uris = NULL;
2567 download = NULL;
2568 update_srch = NULL;
2569 sr = GNUNET_new (struct GNUNET_FS_SearchResult);
2570 sr->h = sc->h;
2571 sr->sc = sc;
2572 sr->serialization = serialized;
2573 if ((GNUNET_OK !=
2574 GNUNET_BIO_read_string (rh, "result-uri", &uris, 10 * 1024)) ||
2575 (NULL == (sr->uri = GNUNET_FS_uri_parse (uris, &emsg))) ||
2576 (GNUNET_OK !=
2577 GNUNET_BIO_read_string (rh, "download-lnk", &download, 16)) ||
2578 (GNUNET_OK !=
2579 GNUNET_BIO_read_string (rh, "search-lnk", &update_srch, 16)) ||
2580 (GNUNET_OK != GNUNET_FS_read_meta_data (rh, "result-meta", &sr->meta)) ||
2581 (GNUNET_OK != GNUNET_BIO_read (rh,
2582 "result-key",
2583 &sr->key,
2584 sizeof(struct GNUNET_HashCode))) ||
2586 rh,
2587 "mandatory missing",
2588 (int32_t *) &sr->mandatory_missing)) ||
2590 rh,
2591 "optional support",
2592 (int32_t *) &sr->optional_support)) ||
2594 rh,
2595 "availability success",
2596 (int32_t *) &sr->availability_success)) ||
2598 rh,
2599 "availability trials",
2600 (int32_t *) &sr->availability_trials)))
2601 {
2602 GNUNET_break (0);
2603 goto cleanup;
2604 }
2605 if (GNUNET_FS_URI_KSK == sr->sc->uri->type)
2606 {
2608 (sr->sc->uri->data.ksk.keywordCount + 7) / 8); /* round up, count bits */
2609 if (GNUNET_OK !=
2610 GNUNET_BIO_read (rh,
2611 "keyword-bitmap",
2612 sr->keyword_bitmap,
2613 (sr->sc->uri->data.ksk.keywordCount + 7) / 8))
2614 {
2615 GNUNET_break (0);
2616 goto cleanup;
2617 }
2618 }
2619 GNUNET_free (uris);
2620 if (NULL != download)
2621 {
2623 if (NULL != drh)
2624 {
2625 deserialize_download (sc->h, drh, NULL, sr, download);
2626 if (GNUNET_OK != GNUNET_BIO_read_close (drh, &emsg))
2627 {
2629 _ ("Failed to resume sub-download `%s': %s\n"),
2630 download,
2631 emsg);
2632 GNUNET_free (emsg);
2633 }
2634 }
2636 }
2637 if (NULL != update_srch)
2638 {
2639 drh =
2641 if (NULL != drh)
2642 {
2643 deserialize_search (sc->h, drh, sr, update_srch);
2644 if (GNUNET_OK != GNUNET_BIO_read_close (drh, &emsg))
2645 {
2647 _ ("Failed to resume sub-search `%s': %s\n"),
2648 update_srch,
2649 emsg);
2650 GNUNET_free (emsg);
2651 }
2652 }
2653 GNUNET_free (update_srch);
2654 }
2657 &sr->key,
2658 sr,
2660 if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
2661 {
2663 _ ("Failure while resuming search operation `%s': %s\n"),
2664 filename,
2665 emsg);
2666 GNUNET_free (emsg);
2667 }
2668 return GNUNET_OK;
2669cleanup:
2671 GNUNET_free (emsg);
2672 GNUNET_free (uris);
2673 GNUNET_free (update_srch);
2674 if (NULL != sr->uri)
2676 if (NULL != sr->meta)
2679 GNUNET_free (sr);
2680 if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
2681 {
2683 _ ("Failure while resuming search operation `%s': %s\n"),
2684 filename,
2685 emsg);
2686 GNUNET_free (emsg);
2687 }
2688 return GNUNET_OK;
2689}
2690
2691
2700static void
2702{
2703 struct GNUNET_FS_DownloadContext *dcc;
2704 struct GNUNET_FS_ProgressInfo pi;
2705
2707 pi.value.download.specifics.resume.meta = dc->meta;
2708 pi.value.download.specifics.resume.message = dc->emsg;
2710 dcc = dc->child_head;
2711 while (NULL != dcc)
2712 {
2714 dcc = dcc->next;
2715 }
2716}
2717
2718
2725static void
2727
2728
2738static int
2739signal_result_resume (void *cls, const struct GNUNET_HashCode *key, void *value)
2740{
2741 struct GNUNET_FS_SearchContext *sc = cls;
2742 struct GNUNET_FS_ProgressInfo pi;
2743 struct GNUNET_FS_SearchResult *sr = value;
2744
2745 if (0 == sr->mandatory_missing)
2746 {
2748 pi.value.search.specifics.resume_result.meta = sr->meta;
2749 pi.value.search.specifics.resume_result.uri = sr->uri;
2750 pi.value.search.specifics.resume_result.result = sr;
2751 pi.value.search.specifics.resume_result.availability_rank =
2753 pi.value.search.specifics.resume_result.availability_certainty =
2755 pi.value.search.specifics.resume_result.applicability_rank =
2756 sr->optional_support;
2758 }
2759 if (NULL != sr->download)
2760 {
2762 }
2763 else
2764 {
2766 }
2767 if (NULL != sr->update_search)
2769 return GNUNET_YES;
2770}
2771
2772
2778static void
2780
2781
2790static int
2791free_result (void *cls, const struct GNUNET_HashCode *key, void *value)
2792{
2793 struct GNUNET_FS_SearchResult *sr = value;
2794
2795 if (NULL != sr->update_search)
2796 {
2798 GNUNET_assert (NULL == sr->update_search);
2799 }
2802 GNUNET_free (sr);
2803 return GNUNET_YES;
2804}
2805
2806
2812static void
2814{
2815 if (NULL != sc->serialization)
2816 {
2818 (sc->psearch_result == NULL)
2821 sc->serialization);
2823 (sc->psearch_result == NULL)
2826 sc->serialization);
2827 }
2829 GNUNET_free (sc->emsg);
2830 if (NULL != sc->uri)
2832 if (NULL != sc->master_result_map)
2833 {
2835 &free_result,
2836 sc);
2838 }
2839 GNUNET_free (sc);
2840}
2841
2842
2851static int
2852deserialize_subdownload (void *cls, const char *filename)
2853{
2854 struct GNUNET_FS_DownloadContext *parent = cls;
2855 char *serialized;
2856 char *emsg;
2857 struct GNUNET_BIO_ReadHandle *rh;
2858
2861 if (NULL == rh)
2862 {
2864 _ (
2865 "Failed to resume sub-download `%s': could not open file `%s'\n"),
2866 serialized,
2867 filename);
2868 GNUNET_free (serialized);
2869 return GNUNET_OK;
2870 }
2871 deserialize_download (parent->h, rh, parent, NULL, serialized);
2872 if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
2873 {
2875 _ ("Failed to resume sub-download `%s': %s\n"),
2876 serialized,
2877 emsg);
2878 GNUNET_free (emsg);
2879 }
2880 GNUNET_free (serialized);
2881 return GNUNET_OK;
2882}
2883
2884
2892static void
2894{
2895 struct GNUNET_FS_DownloadContext *dcc;
2896
2897 if (NULL != dc->meta)
2899 if (NULL != dc->uri)
2902 GNUNET_free (dc->emsg);
2905 while (NULL != (dcc = dc->child_head))
2906 {
2909 }
2911 if (NULL != dc->active)
2913 GNUNET_free (dc);
2914}
2915
2916
2926static void
2928 struct GNUNET_BIO_ReadHandle *rh,
2931 const char *serialization)
2932{
2934 char *emsg;
2935 char *uris;
2936 char *dn;
2937 uint32_t options;
2938 uint32_t status;
2939
2940 uris = NULL;
2941 emsg = NULL;
2943 dc->parent = parent;
2944 dc->h = h;
2946 {
2947 struct GNUNET_BIO_ReadSpec rs[] = {
2948 GNUNET_FS_read_spec_meta_data ("download-meta", &dc->meta),
2949 GNUNET_BIO_read_spec_string ("download-emsg", &dc->emsg, 10 * 1024),
2950 GNUNET_BIO_read_spec_string ("download-fn", &dc->filename, 10 * 1024),
2951 GNUNET_BIO_read_spec_string ("download-tfn",
2952 &dc->temp_filename, 10 * 1024),
2953 GNUNET_BIO_read_spec_int64 ("old file size",
2954 (int64_t *) &dc->old_file_size),
2956 (int64_t *) &dc->offset),
2958 (int64_t *) &dc->length),
2959 GNUNET_BIO_read_spec_int64 ("completed",
2960 (int64_t *) &dc->completed),
2962 };
2963 if ((GNUNET_OK !=
2964 GNUNET_BIO_read_string (rh, "download-uri", &uris, 10 * 1024)) ||
2965 (NULL == (dc->uri = GNUNET_FS_uri_parse (uris, &emsg))) ||
2970 (GNUNET_OK != GNUNET_BIO_read_int32 (rh, "anonymity",
2971 (int32_t *) &dc->anonymity)) ||
2972 (GNUNET_OK != GNUNET_BIO_read_int32 (rh, "options",
2973 (int32_t *) &options)) ||
2974 (GNUNET_OK != GNUNET_BIO_read_int32 (rh, "status",
2975 (int32_t *) &status)))
2976 {
2977 GNUNET_break (0);
2978 goto cleanup;
2979 }
2980 }
2982 dc->active =
2984 GNUNET_NO);
2986 dc->treedepth =
2991 if (NULL == dc->emsg)
2992 {
2994 if (NULL == dc->top_request)
2995 {
2996 GNUNET_break (0);
2997 goto cleanup;
2998 }
2999 }
3001 if (NULL != dn)
3002 {
3005 GNUNET_free (dn);
3006 }
3007 if (NULL != parent)
3008 {
3010 }
3011 if (NULL != search)
3012 {
3013 dc->search = search;
3014 search->download = dc;
3015 }
3016 if ((NULL == parent) && (NULL == search))
3017 {
3018 dc->top =
3021 }
3022 GNUNET_free (uris);
3023 GNUNET_assert (NULL == dc->job_queue);
3025 return;
3026cleanup:
3027 GNUNET_free (uris);
3028 GNUNET_free (emsg);
3030}
3031
3032
3039static void
3041{
3042 struct GNUNET_FS_ProgressInfo pi;
3043
3045 pi.value.search.specifics.resume.message = sc->emsg;
3046 pi.value.search.specifics.resume.is_paused =
3047 (NULL == sc->mq) ? GNUNET_YES : GNUNET_NO;
3051 sc);
3052}
3053
3054
3063static struct GNUNET_FS_SearchContext *
3065 struct GNUNET_BIO_ReadHandle *rh,
3067 const char *serialization)
3068{
3070 char *emsg;
3071 char *uris;
3072 char *dn;
3073 uint32_t options;
3074 char in_pause;
3075
3076 if ((NULL != psearch_result) && (NULL != psearch_result->update_search))
3077 {
3078 GNUNET_break (0);
3079 return NULL;
3080 }
3081 uris = NULL;
3082 emsg = NULL;
3084 if (NULL != psearch_result)
3085 {
3088 }
3089 sc->h = h;
3091 if ((GNUNET_OK !=
3092 GNUNET_BIO_read_string (rh, "search-uri", &uris, 10 * 1024)) ||
3093 (NULL == (sc->uri = GNUNET_FS_uri_parse (uris, &emsg))) ||
3096 (GNUNET_OK != read_start_time (rh, &sc->start_time)) ||
3097 (GNUNET_OK !=
3098 GNUNET_BIO_read_string (rh, "search-emsg", &sc->emsg, 10 * 1024)) ||
3099 (GNUNET_OK != GNUNET_BIO_read_int32 (rh, "options",
3100 (int32_t *) &options)) ||
3101 (GNUNET_OK !=
3102 GNUNET_BIO_read (rh, "search-pause", &in_pause, sizeof(in_pause))) ||
3103 (GNUNET_OK != GNUNET_BIO_read_int32 (rh, "anonymity",
3104 (int32_t *) &sc->anonymity)))
3105 {
3106 GNUNET_break (0);
3107 goto cleanup;
3108 }
3112 (NULL == sc->psearch_result)
3116 "");
3117 if (NULL != dn)
3118 {
3121 GNUNET_free (dn);
3122 }
3123 if (('\0' == in_pause) &&
3125 {
3126 GNUNET_log (
3128 _ ("Could not resume running search, will resume as paused search\n"));
3129 }
3131 GNUNET_free (uris);
3132 return sc;
3133cleanup:
3134 GNUNET_free (emsg);
3136 GNUNET_free (uris);
3137 return NULL;
3138}
3139
3140
3149static int
3150deserialize_search_file (void *cls, const char *filename)
3151{
3152 struct GNUNET_FS_Handle *h = cls;
3153 char *set;
3154 char *emsg;
3155 struct GNUNET_BIO_ReadHandle *rh;
3157 struct stat buf;
3158
3159 if (0 != stat (filename, &buf))
3160 {
3162 return GNUNET_OK;
3163 }
3164 if (S_ISDIR (buf.st_mode))
3165 return GNUNET_OK; /* skip directories */
3168 if (NULL == rh)
3169 {
3170 if (NULL != set)
3171 {
3173 GNUNET_free (set);
3174 }
3175 return GNUNET_OK;
3176 }
3177 sc = deserialize_search (h, rh, NULL, set);
3178 if (NULL != sc)
3180 GNUNET_free (set);
3181 if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
3182 {
3184 _ ("Failure while resuming search operation `%s': %s\n"),
3185 filename,
3186 emsg);
3187 GNUNET_free (emsg);
3188 }
3189 return GNUNET_OK;
3190}
3191
3192
3201static int
3202deserialize_download_file (void *cls, const char *filename)
3203{
3204 struct GNUNET_FS_Handle *h = cls;
3205 char *set;
3206 char *emsg;
3207 struct GNUNET_BIO_ReadHandle *rh;
3208
3211 if (NULL == rh)
3212 {
3213 if (0 != unlink (filename))
3215 "unlink",
3216 filename);
3217 GNUNET_free (set);
3218 return GNUNET_OK;
3219 }
3220 deserialize_download (h, rh, NULL, NULL, set);
3221 GNUNET_free (set);
3222 if (GNUNET_OK !=
3224 &emsg))
3225 {
3227 "Failure while resuming download operation `%s': %s\n",
3228 filename,
3229 emsg);
3230 GNUNET_free (emsg);
3231 }
3232 return GNUNET_OK;
3233}
3234
3235
3243static void
3244deserialization_master (const char *master_path,
3246 struct GNUNET_FS_Handle *h)
3247{
3248 char *dn;
3249
3250 dn = get_serialization_file_name (h, master_path, "");
3251 if (NULL == dn)
3252 return;
3253 if (GNUNET_YES ==
3255 GNUNET_YES))
3257 proc,
3258 h);
3259 GNUNET_free (dn);
3260}
3261
3262
3263struct GNUNET_FS_Handle *
3265 const char *client_name,
3267 void *upcb_cls,
3269 ...)
3270{
3271 struct GNUNET_FS_Handle *ret;
3272 enum GNUNET_FS_OPTIONS opt;
3273 va_list ap;
3274
3275 ret = GNUNET_new (struct GNUNET_FS_Handle);
3276 ret->cfg = cfg;
3277 ret->client_name = GNUNET_strdup (client_name);
3278 ret->upcb = upcb;
3279 ret->upcb_cls = upcb_cls;
3280 ret->flags = flags;
3281 ret->max_parallel_downloads = DEFAULT_MAX_PARALLEL_DOWNLOADS;
3282 ret->max_parallel_requests = DEFAULT_MAX_PARALLEL_REQUESTS;
3283 ret->avg_block_latency =
3284 GNUNET_TIME_UNIT_MINUTES; /* conservative starting point */
3285 va_start (ap, flags);
3286 while (GNUNET_FS_OPTIONS_END !=
3287 (opt = ((enum GNUNET_FS_OPTIONS) va_arg (ap, int))))
3288 {
3289 switch (opt)
3290 {
3292 ret->max_parallel_downloads = va_arg (ap, unsigned int);
3293
3294 break;
3295
3297 ret->max_parallel_requests = va_arg (ap, unsigned int);
3298
3299 break;
3300
3301 default:
3302 GNUNET_break (0);
3303 GNUNET_free (ret->client_name);
3304 GNUNET_free (ret);
3305 va_end (ap);
3306 return NULL;
3307 }
3308 }
3309 va_end (ap);
3311 {
3314 ret);
3317 ret);
3320 ret);
3323 ret);
3324 }
3325 return ret;
3326}
3327
3328
3329void
3331{
3332 while (NULL != h->top_head)
3333 h->top_head->ssf (h->top_head->ssf_cls);
3334 if (NULL != h->queue_job)
3335 GNUNET_SCHEDULER_cancel (h->queue_job);
3336 GNUNET_free (h->client_name);
3337 GNUNET_free (h);
3338}
3339
3340
3341/* end of fs_api.c */
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
#define HASHING_BLOCKSIZE
Blocksize to use when hashing files for indexing (blocksize for IO, not for the DBlocks).
Definition: fs.h:48
#define DBLOCK_SIZE
Size of the individual blocks used for file-sharing.
Definition: fs.h:41
static int deserialize_download_file(void *cls, const char *filename)
Function called with a filename of serialized download operation to deserialize.
Definition: fs_api.c:3202
static void remove_sync_file_in_dir(struct GNUNET_FS_Handle *h, const char *ext, const char *uni, const char *ent)
Remove serialization/deserialization file from disk.
Definition: fs_api.c:758
void GNUNET_FS_search_result_sync_(struct GNUNET_FS_SearchResult *sr)
Synchronize this search result with its mirror on disk.
Definition: fs_api.c:2165
#define DEFAULT_MAX_PARALLEL_REQUESTS
How many block requests can we have outstanding in parallel at a time by default?
Definition: fs_api.c:37
static int deserialize_unindex_file(void *cls, const char *filename)
Function called with a filename of serialized unindexing operation to deserialize.
Definition: fs_api.c:2330
static int copy_from_reader(struct GNUNET_BIO_WriteHandle *wh, struct GNUNET_FS_FileInformation *fi)
Copy all of the data from the reader to the write handle.
Definition: fs_api.c:1292
static struct GNUNET_FS_FileInformation * deserialize_file_information(struct GNUNET_FS_Handle *h, const char *filename)
Using the given serialization filename, try to deserialize the file-information tree associated with ...
Definition: fs_api.c:1143
void GNUNET_FS_unindex_sync_(struct GNUNET_FS_UnindexContext *uc)
Synchronize this unindex struct with its mirror on disk.
Definition: fs_api.c:1831
static int deserialize_search_file(void *cls, const char *filename)
Function called with a filename of serialized search operation to deserialize.
Definition: fs_api.c:3150
static char * get_serialization_file_name(struct GNUNET_FS_Handle *h, const char *ext, const char *ent)
Return the full filename where we would store state information (for serialization/deserialization).
Definition: fs_api.c:575
static void start_job(struct GNUNET_FS_QueueEntry *qe)
Start the given job (send signal, remove from pending queue, update counters and state).
Definition: fs_api.c:51
void GNUNET_FS_search_sync_(struct GNUNET_FS_SearchContext *sc)
Synchronize this search struct with its mirror on disk.
Definition: fs_api.c:2266
static struct DownloadRequest * read_download_request(struct GNUNET_BIO_ReadHandle *rh)
Read a download request tree.
Definition: fs_api.c:1941
struct GNUNET_FS_QueueEntry * GNUNET_FS_queue_(struct GNUNET_FS_Handle *h, GNUNET_SCHEDULER_TaskCallback start, GNUNET_SCHEDULER_TaskCallback stop, void *cls, unsigned int blocks, enum GNUNET_FS_QueuePriority priority)
Add a job to the queue.
Definition: fs_api.c:321
static void deserialize_download(struct GNUNET_FS_Handle *h, struct GNUNET_BIO_ReadHandle *rh, struct GNUNET_FS_DownloadContext *parent, struct GNUNET_FS_SearchResult *search, const char *serialization)
Deserialize a download.
Definition: fs_api.c:2927
static struct GNUNET_BIO_ReadHandle * get_read_handle(struct GNUNET_FS_Handle *h, const char *ext, const char *ent)
Return a read handle for deserialization.
Definition: fs_api.c:655
static int fip_signal_resume(void *cls, struct GNUNET_FS_FileInformation *fi, uint64_t length, struct GNUNET_FS_MetaData *meta, struct GNUNET_FS_Uri **uri, struct GNUNET_FS_BlockOptions *bo, int *do_index, void **client_info)
Signal the FS's progress function that we are resuming an upload.
Definition: fs_api.c:1576
static void stop_job(struct GNUNET_FS_QueueEntry *qe)
Stop the given job (send signal, remove from active queue, update counters and state).
Definition: fs_api.c:78
void * GNUNET_FS_make_file_reader_context_(const char *filename)
Create the closure for the GNUNET_FS_data_reader_file_() callback.
Definition: fs_api.c:509
static void signal_download_resume(struct GNUNET_FS_DownloadContext *dc)
Send the 'resume' signal to the callback; also actually resume the download (put it in the queue).
Definition: fs_api.c:2701
static void deserialization_master(const char *master_path, GNUNET_FileNameCallback proc, struct GNUNET_FS_Handle *h)
Deserialize information about pending operations.
Definition: fs_api.c:3244
static char * get_serialization_file_name_in_dir(struct GNUNET_FS_Handle *h, const char *ext, const char *uni, const char *ent)
Return the full filename where we would store state information (for serialization/deserialization) t...
Definition: fs_api.c:615
size_t GNUNET_FS_data_reader_copy_(void *cls, uint64_t offset, size_t max, void *buf, char **emsg)
Function that provides data by copying from a buffer.
Definition: fs_api.c:545
static char * make_serialization_file_name(struct GNUNET_FS_Handle *h, const char *ext)
Create a new random name for serialization.
Definition: fs_api.c:1220
static int read_start_time(struct GNUNET_BIO_ReadHandle *rh, struct GNUNET_TIME_Absolute *timestamp)
Deserialize a start-time.
Definition: fs_api.c:845
static int write_download_request(struct GNUNET_BIO_WriteHandle *wh, struct DownloadRequest *dr)
Serialize a download request.
Definition: fs_api.c:1908
static struct GNUNET_BIO_WriteHandle * get_write_handle_in_dir(struct GNUNET_FS_Handle *h, const char *ext, const char *uni, const char *ent)
Return a write handle for serialization.
Definition: fs_api.c:703
static struct GNUNET_BIO_WriteHandle * get_write_handle(struct GNUNET_FS_Handle *h, const char *ext, const char *ent)
Return a write handle for serialization.
Definition: fs_api.c:678
static int free_result(void *cls, const struct GNUNET_HashCode *key, void *value)
Iterator over search results freeing each.
Definition: fs_api.c:2791
void GNUNET_FS_download_sync_(struct GNUNET_FS_DownloadContext *dc)
Synchronize this download struct with its mirror on disk.
Definition: fs_api.c:2049
static struct GNUNET_FS_SearchContext * deserialize_search(struct GNUNET_FS_Handle *h, struct GNUNET_BIO_ReadHandle *rh, struct GNUNET_FS_SearchResult *psearch_result, const char *serialization)
Deserialize a search.
Definition: fs_api.c:3064
static char * get_download_sync_filename(struct GNUNET_FS_DownloadContext *dc, const char *uni, const char *ext)
Compute the name of the sync file (or directory) for the given download context.
Definition: fs_api.c:2016
static void process_job_queue(void *cls)
Process the jobs in the job queue, possibly starting some and stopping others.
Definition: fs_api.c:107
static void signal_search_resume(struct GNUNET_FS_SearchContext *sc)
Signal resuming of a search to our clients (for the top level search and all sub-searches).
Definition: fs_api.c:3040
void GNUNET_FS_remove_sync_file_(struct GNUNET_FS_Handle *h, const char *ext, const char *ent)
Remove serialization/deserialization file from disk.
Definition: fs_api.c:728
static void free_search_context(struct GNUNET_FS_SearchContext *sc)
Free memory allocated by the search context and its children.
Definition: fs_api.c:2813
#define DEFAULT_MAX_PARALLEL_DOWNLOADS
How many downloads can we have outstanding in parallel at a time by default?
Definition: fs_api.c:42
static char * get_serialization_short_name(const char *fullname)
Given a serialization name (full absolute path), return the basename of the file (without the path),...
Definition: fs_api.c:1186
static int write_start_time(struct GNUNET_BIO_WriteHandle *wh, struct GNUNET_TIME_Absolute timestamp)
Serialize a start-time.
Definition: fs_api.c:820
struct TopLevelActivity * GNUNET_FS_make_top(struct GNUNET_FS_Handle *h, SuspendSignalFunction ssf, void *ssf_cls)
Create a top-level activity entry.
Definition: fs_api.c:381
static struct GNUNET_FS_FileInformation * find_file_position(struct GNUNET_FS_FileInformation *pos, const char *srch)
Find the entry in the file information struct where the serialization filename matches the given name...
Definition: fs_api.c:1544
static int deserialize_subdownload(void *cls, const char *filename)
Function called with a filename of serialized sub-download to deserialize.
Definition: fs_api.c:2852
void GNUNET_FS_remove_sync_dir_(struct GNUNET_FS_Handle *h, const char *ext, const char *uni)
Remove serialization/deserialization directory from disk.
Definition: fs_api.c:787
void GNUNET_FS_file_information_sync_(struct GNUNET_FS_FileInformation *fi)
Create a temporary file on disk to store the current state of fi in.
Definition: fs_api.c:1328
void GNUNET_FS_dequeue_(struct GNUNET_FS_QueueEntry *qe)
Dequeue a job from the queue.
Definition: fs_api.c:356
static char * make_serialization_file_name_in_dir(struct GNUNET_FS_Handle *h, const char *ext, const char *uni)
Create a new random name for serialization.
Definition: fs_api.c:1256
static int deserialize_search_result(void *cls, const char *filename)
Function called with a filename of serialized search result to deserialize.
Definition: fs_api.c:2537
static int signal_result_resume(void *cls, const struct GNUNET_HashCode *key, void *value)
Iterator over search results signaling resume to the client for each result.
Definition: fs_api.c:2739
static void free_download_context(struct GNUNET_FS_DownloadContext *dc)
Free this download context and all of its descendants.
Definition: fs_api.c:2893
size_t GNUNET_FS_data_reader_file_(void *cls, uint64_t offset, size_t max, void *buf, char **emsg)
Function that provides data by reading from a file.
Definition: fs_api.c:447
void GNUNET_FS_end_top(struct GNUNET_FS_Handle *h, struct TopLevelActivity *top)
Destroy a top-level activity entry.
Definition: fs_api.c:402
void GNUNET_FS_publish_sync_(struct GNUNET_FS_PublishContext *pc)
Synchronize this publishing struct with its mirror on disk.
Definition: fs_api.c:1753
static struct GNUNET_FS_FileInformation * deserialize_fi_node(struct GNUNET_FS_Handle *h, const char *fn, struct GNUNET_BIO_ReadHandle *rh)
Using the given serialization filename, try to deserialize the file-information tree associated with ...
Definition: fs_api.c:882
static int deserialize_publish_file(void *cls, const char *filename)
Function called with a filename of serialized publishing operation to deserialize.
Definition: fs_api.c:1616
shared definitions for the FS library
@ BRS_DOWNLOAD_UP
This block and all of its children have been downloaded successfully (full completion propagates up).
Definition: fs_api.h:1661
@ BRS_RECONSTRUCT_META_UP
We've calculated the CHK bottom-up based on the meta data.
Definition: fs_api.h:1629
@ BRS_CHK_SET
We've determined the real, desired CHK for this block (full tree reconstruction failed),...
Definition: fs_api.h:1646
@ BRS_ERROR
We got a block back that matched the query but did not hash to the key (malicious publisher or hash c...
Definition: fs_api.h:1668
@ BRS_RECONSTRUCT_DOWN
We've checked the block on the path down the tree, and the content on disk did match the desired CHK,...
Definition: fs_api.h:1621
@ BRS_INIT
Initial state, block has only been allocated (since it is relevant to the overall download request).
Definition: fs_api.h:1613
@ BRS_DOWNLOAD_DOWN
We've successfully downloaded this block, but the children still need to be either downloaded or veri...
Definition: fs_api.h:1655
@ BRS_RECONSTRUCT_UP
We've calculated the CHK bottom-up based on what we have on disk, which may not be what the desired C...
Definition: fs_api.h:1637
void GNUNET_FS_download_signal_suspend_(void *cls)
Create SUSPEND event for the given download operation and then clean up our state (without stop signa...
Definition: fs_download.c:1952
void * GNUNET_FS_search_make_status_(struct GNUNET_FS_ProgressInfo *pi, struct GNUNET_FS_Handle *h, struct GNUNET_FS_SearchContext *sc)
Fill in all of the generic fields for a search event and call the callback.
Definition: fs_search.c:49
UnindexState
Phases of unindex processing (state machine).
Definition: fs_api.h:1307
@ UNINDEX_STATE_EXTRACT_KEYWORDS
Find out which keywords apply.
Definition: fs_api.h:1322
@ UNINDEX_STATE_COMPLETE
We're done.
Definition: fs_api.h:1338
@ UNINDEX_STATE_DS_REMOVE
We're telling the datastore to delete the respective DBlocks and IBlocks.
Definition: fs_api.h:1317
@ UNINDEX_STATE_HASHING
We're currently hashing the file.
Definition: fs_api.h:1311
@ UNINDEX_STATE_ERROR
We've encountered a fatal error.
Definition: fs_api.h:1343
@ UNINDEX_STATE_FS_NOTIFY
We're notifying the FS service about the unindexing.
Definition: fs_api.h:1333
@ UNINDEX_STATE_DS_REMOVE_KBLOCKS
We're telling the datastore to remove KBlocks.
Definition: fs_api.h:1327
@ GNUNET_FS_URI_KSK
Keyword search key (query with keywords).
Definition: fs_api.h:154
#define GNUNET_FS_SYNC_PATH_MASTER_DOWNLOAD
Name of the directory with master downloads (not associated with search or part of another download).
Definition: fs_api.h:66
void GNUNET_FS_unindex_do_remove_kblocks_(struct GNUNET_FS_UnindexContext *uc)
If necessary, connect to the datastore and remove the KBlocks.
Definition: fs_unindex.c:581
void GNUNET_FS_free_download_request_(struct DownloadRequest *dr)
(recursively) free download request structure
Definition: fs_download.c:997
#define GNUNET_FS_SYNC_PATH_MASTER_SEARCH
Name of the directory with top-level searches.
Definition: fs_api.h:55
void GNUNET_FS_publish_signal_suspend_(void *cls)
Create SUSPEND event for the given publish operation and then clean up our state (without stop signal...
Definition: fs_publish.c:1355
#define GNUNET_FS_SYNC_PATH_MASTER_UNINDEX
Name of the directory with unindex operations.
Definition: fs_api.h:87
#define GNUNET_FS_SYNC_PATH_MASTER_PUBLISH
Name of the directory with publishing operations.
Definition: fs_api.h:77
#define CHK_PER_INODE
Pick a multiple of 2 here to achieve 8-byte alignment! We also probably want DBlocks to have (roughly...
Definition: fs_api.h:44
void GNUNET_FS_unindex_make_status_(struct GNUNET_FS_ProgressInfo *pi, struct GNUNET_FS_UnindexContext *uc, uint64_t offset)
Fill in all of the generic fields for an unindex event and call the callback.
Definition: fs_unindex.c:85
void GNUNET_FS_download_make_status_(struct GNUNET_FS_ProgressInfo *pi, struct GNUNET_FS_DownloadContext *dc)
Fill in all of the generic fields for a download event and call the callback.
Definition: fs_download.c:104
void GNUNET_FS_download_start_task_(void *cls)
Task that creates the initial (top-level) download request for the file.
Definition: fs_download.c:1799
#define GNUNET_FS_SYNC_PATH_CHILD_SEARCH
Name of the directory with sub-searches (namespace-updates).
Definition: fs_api.h:60
void GNUNET_FS_unindex_do_extract_keywords_(struct GNUNET_FS_UnindexContext *uc)
Extract the keywords for KBlock removal.
Definition: fs_unindex.c:407
void GNUNET_FS_unindex_do_remove_(struct GNUNET_FS_UnindexContext *uc)
Connect to the datastore and remove the blocks.
Definition: fs_unindex.c:650
void * GNUNET_FS_publish_make_status_(struct GNUNET_FS_ProgressInfo *pi, struct GNUNET_FS_PublishContext *pc, const struct GNUNET_FS_FileInformation *p, uint64_t offset)
Fill in all of the generic fields for a publish event and call the callback.
Definition: fs_publish.c:48
void GNUNET_FS_search_start_probe_(struct GNUNET_FS_SearchResult *sr)
Start download probes for the given search result.
Definition: fs_search.c:431
GNUNET_FS_QueuePriority
Priorities for the queue.
Definition: fs_api.h:404
@ GNUNET_FS_QUEUE_PRIORITY_NORMAL
Default priority.
Definition: fs_api.h:413
@ GNUNET_FS_QUEUE_PRIORITY_PROBE
This is a probe (low priority).
Definition: fs_api.h:408
void(* SuspendSignalFunction)(void *cls)
Function signature of the functions that can be called to trigger suspend signals and clean-up for to...
Definition: fs_api.h:1011
void GNUNET_FS_unindex_signal_suspend_(void *cls)
Create SUSPEND event for the given unindex operation and then clean up our state (without stop signal...
Definition: fs_unindex.c:728
int GNUNET_FS_search_start_searching_(struct GNUNET_FS_SearchContext *sc)
Build the request and actually initiate the search using the GNUnet FS service.
Definition: fs_search.c:1402
void GNUNET_FS_unindex_process_hash_(void *cls, const struct GNUNET_HashCode *file_id)
Function called once the hash of the file that is being unindexed has been computed.
Definition: fs_unindex.c:695
#define GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD
Name of the directory with downloads that are part of another download or a search.
Definition: fs_api.h:72
void GNUNET_FS_publish_main_(void *cls)
Main function that performs the upload.
Definition: fs_publish.c:1063
#define GNUNET_FS_SYNC_PATH_FILE_INFO
Name of the directory with files that are being published.
Definition: fs_api.h:82
void GNUNET_FS_search_signal_suspend_(void *cls)
Create SUSPEND event for the given search operation and then clean up our state (without stop signal)...
Definition: fs_search.c:1555
unsigned int GNUNET_FS_compute_depth(uint64_t flen)
Compute the depth of the CHK tree.
Definition: fs_tree.c:125
Merkle-tree-ish-CHK file encoding for GNUnet.
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:98
static int start
Set if we are to start default services (including ARM).
Definition: gnunet-arm.c:38
static int ret
Final status code.
Definition: gnunet-arm.c:93
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:108
static char * dir
Set to the directory where runtime files are stored.
Definition: gnunet-arm.c:88
static int end
Set if we are to shutdown all services (including ARM).
Definition: gnunet-arm.c:33
static uint64_t timestamp(void)
Get current timestamp.
static struct GNUNET_TIME_Absolute end_time
At what time MUST the current hostlist request be done?
static struct GNUNET_DATASTORE_QueueEntry * qe
Current operation.
static char * data
The data to insert into the dht.
struct GNUNET_HashCode key
The key used in the DHT.
static void cleanup(void *cls)
Disconnect and shutdown.
Definition: gnunet-did.c:130
static struct GNUNET_FS_DownloadContext * dc
static char * filename
static struct GNUNET_NAMECACHE_Handle * ns
Handle to the namecache.
static char * value
Value of the record to add/remove.
static int status
The program status; 0 for success.
Definition: gnunet-nse.c:39
static struct GNUNET_FS_Uri * uri
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
static struct GNUNET_FS_MetaData * meta
Meta-data provided via command-line option.
static struct GNUNET_FS_BlockOptions bo
Options we set for published blocks.
static struct GNUNET_FS_PublishContext * pc
Handle to FS-publishing operation.
enum State state
current state of profiling
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:87
static struct GNUNET_FS_UnindexContext * uc
API for file sharing via GNUnet.
enum GNUNET_GenericReturnValue GNUNET_BIO_read(struct GNUNET_BIO_ReadHandle *h, const char *what, void *result, size_t len)
Read some contents into a buffer.
Definition: bio.c:291
enum GNUNET_GenericReturnValue GNUNET_BIO_write_close(struct GNUNET_BIO_WriteHandle *h, char **emsg)
Close an IO handle.
Definition: bio.c:556
struct GNUNET_BIO_ReadSpec GNUNET_BIO_read_spec_string(const char *what, char **result, size_t max_length)
Create the specification to read a 0-terminated string.
Definition: bio.c:954
struct GNUNET_BIO_WriteHandle * GNUNET_BIO_write_open_file(const char *fn)
Open a file for writing.
Definition: bio.c:508
enum GNUNET_GenericReturnValue GNUNET_BIO_write_int32(struct GNUNET_BIO_WriteHandle *h, const char *what, int32_t i)
Write an (u)int32_t.
Definition: bio.c:845
enum GNUNET_GenericReturnValue GNUNET_BIO_read_spec_commit(struct GNUNET_BIO_ReadHandle *h, struct GNUNET_BIO_ReadSpec *rs)
Execute the read specifications in order.
Definition: bio.c:1106
enum GNUNET_GenericReturnValue GNUNET_BIO_write(struct GNUNET_BIO_WriteHandle *h, const char *what, const void *buffer, size_t n)
Write a buffer to a handle.
Definition: bio.c:750
enum GNUNET_GenericReturnValue GNUNET_BIO_read_string(struct GNUNET_BIO_ReadHandle *h, const char *what, char **result, size_t max_length)
Read 0-terminated string.
Definition: bio.c:330
struct GNUNET_BIO_WriteSpec GNUNET_BIO_write_spec_string(const char *what, const char *s)
Create the specification to write a 0-terminated string.
Definition: bio.c:1199
#define GNUNET_BIO_read_spec_end()
End of specifications marker.
enum GNUNET_GenericReturnValue GNUNET_BIO_write_string(struct GNUNET_BIO_WriteHandle *h, const char *what, const char *s)
Write a 0-terminated string.
Definition: bio.c:787
struct GNUNET_BIO_ReadSpec GNUNET_BIO_read_spec_int32(const char *what, int32_t *i)
Create the specification to read an (u)int32_t.
Definition: bio.c:999
#define GNUNET_BIO_write_spec_end()
End of specifications marker.
struct GNUNET_BIO_WriteSpec GNUNET_BIO_write_spec_object(const char *what, void *source, size_t size)
Create the specification to read some bytes.
Definition: bio.c:1152
enum GNUNET_GenericReturnValue GNUNET_BIO_write_spec_commit(struct GNUNET_BIO_WriteHandle *h, struct GNUNET_BIO_WriteSpec *ws)
Execute the write specifications in order.
Definition: bio.c:1357
enum GNUNET_GenericReturnValue GNUNET_BIO_read_close(struct GNUNET_BIO_ReadHandle *h, char **emsg)
Close an open handle.
Definition: bio.c:162
enum GNUNET_GenericReturnValue GNUNET_BIO_read_int64(struct GNUNET_BIO_ReadHandle *h, const char *what, int64_t *i)
Read an (u)int64_t.
Definition: bio.c:449
enum GNUNET_GenericReturnValue GNUNET_BIO_read_int32(struct GNUNET_BIO_ReadHandle *h, const char *what, int32_t *i)
Read an (u)int32_t.
Definition: bio.c:427
struct GNUNET_BIO_WriteSpec GNUNET_BIO_write_spec_int32(const char *what, int32_t *i)
Create the specification to write an (u)int32_t.
Definition: bio.c:1244
struct GNUNET_BIO_ReadSpec GNUNET_BIO_read_spec_int64(const char *what, int64_t *i)
Create the specification to read an (u)int64_t.
Definition: bio.c:1043
struct GNUNET_BIO_ReadHandle * GNUNET_BIO_read_open_file(const char *fn)
Open a file for reading.
Definition: bio.c:114
enum GNUNET_GenericReturnValue GNUNET_BIO_write_int64(struct GNUNET_BIO_WriteHandle *h, const char *what, int64_t i)
Write an (u)int64_t.
Definition: bio.c:865
struct GNUNET_BIO_WriteSpec GNUNET_BIO_write_spec_int64(const char *what, int64_t *i)
Create the specification to write an (u)int64_t.
Definition: bio.c:1289
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_filename(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be the name of a file or directory.
struct GNUNET_DATASTORE_Handle * GNUNET_DATASTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the datastore service.
struct GNUNET_DISK_FileHandle * GNUNET_DISK_file_open(const char *fn, enum GNUNET_DISK_OpenFlags flags, enum GNUNET_DISK_AccessPermissions perm)
Open a file.
Definition: disk.c:1238
char * GNUNET_DISK_mktemp(const char *t)
Create an (empty) temporary file on disk.
Definition: disk.c:381
off_t GNUNET_DISK_file_seek(const struct GNUNET_DISK_FileHandle *h, off_t offset, enum GNUNET_DISK_Seek whence)
Move the read/write pointer in a file.
Definition: disk.c:206
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_remove(const char *filename)
Remove all files in a directory (rm -rf).
Definition: disk.c:1088
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_test(const char *fil, int is_readable)
Test if fil is a directory and listable.
Definition: disk.c:404
enum GNUNET_GenericReturnValue GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1309
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_create_for_file(const char *filename)
Create the directory structure for storing a file.
Definition: disk.c:583
ssize_t GNUNET_DISK_file_read(const struct GNUNET_DISK_FileHandle *h, void *result, size_t len)
Read the contents of a binary file into a buffer.
Definition: disk.c:623
int GNUNET_DISK_directory_scan(const char *dir_name, GNUNET_FileNameCallback callback, void *callback_cls)
Scan a directory for files.
Definition: disk.c:815
@ GNUNET_DISK_OPEN_READ
Open the file for reading.
@ GNUNET_DISK_PERM_NONE
Nobody is allowed to do anything to the file.
@ GNUNET_DISK_SEEK_SET
Seek an absolute position (from the start of the file).
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_CONTAINER_DLL_insert_after(head, tail, other, element)
Insert an element into a DLL after the given other element.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
GNUNET_FS_Flags
General (global) option flags for file-sharing.
GNUNET_FS_SearchOptions
Options for searching.
GNUNET_FS_DownloadOptions
Options for downloading.
uint64_t GNUNET_FS_uri_chk_get_file_size(const struct GNUNET_FS_Uri *uri)
What is the size of the file that this URI refers to?
Definition: fs_uri.c:1360
int GNUNET_FS_uri_test_ksk(const struct GNUNET_FS_Uri *uri)
Is this a keyword URI?
Definition: fs_uri.c:1324
GNUNET_FS_OPTIONS
Options specified in the VARARGs portion of GNUNET_FS_start.
void GNUNET_FS_file_information_inspect(struct GNUNET_FS_FileInformation *dir, GNUNET_FS_FileInformationProcessor proc, void *proc_cls)
Inspect a file or directory in a publish-structure.
enum GNUNET_GenericReturnValue GNUNET_FS_read_meta_data(struct GNUNET_BIO_ReadHandle *h, const char *what, struct GNUNET_FS_MetaData **result)
Read a metadata container.
Definition: meta_data.c:1051
int GNUNET_FS_uri_test_loc(const struct GNUNET_FS_Uri *uri)
Is this a location URI?
Definition: fs_uri.c:1401
char * GNUNET_FS_uri_to_string(const struct GNUNET_FS_Uri *uri)
Convert a URI to a UTF-8 String.
Definition: fs_uri.c:2034
struct GNUNET_FS_Handle * GNUNET_FS_start(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *client_name, GNUNET_FS_ProgressCallback upcb, void *upcb_cls, enum GNUNET_FS_Flags flags,...)
Setup a connection to the file-sharing service.
Definition: fs_api.c:3264
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:677
int GNUNET_FS_uri_test_sks(const struct GNUNET_FS_Uri *uri)
Is this a namespace URI?
Definition: fs_uri.c:1271
int GNUNET_FS_meta_data_test_for_directory(const struct GNUNET_FS_MetaData *md)
Does the meta-data claim that this is a directory? Checks if the mime-type is that of a GNUnet direct...
Definition: fs_directory.c:55
int GNUNET_FS_uri_test_chk(const struct GNUNET_FS_Uri *uri)
Is this a file (or directory) URI?
Definition: fs_uri.c:1346
void GNUNET_FS_stop(struct GNUNET_FS_Handle *h)
Close our connection with the file-sharing service.
Definition: fs_api.c:3330
struct GNUNET_FS_Uri * GNUNET_FS_uri_parse(const char *uri, char **emsg)
Convert a UTF-8 String to a URI.
Definition: fs_uri.c:637
struct GNUNET_BIO_ReadSpec GNUNET_FS_read_spec_meta_data(const char *what, struct GNUNET_FS_MetaData **result)
Create the specification to read a metadata container.
Definition: meta_data.c:1185
struct GNUNET_BIO_WriteSpec GNUNET_FS_write_spec_meta_data(const char *what, const struct GNUNET_FS_MetaData *m)
Create the specification to write a metadata container.
Definition: meta_data.c:1223
void GNUNET_FS_file_information_destroy(struct GNUNET_FS_FileInformation *fi, GNUNET_FS_FileInformationProcessor cleaner, void *cleaner_cls)
Destroy publish-structure.
int GNUNET_FS_uri_loc_get_peer_identity(const struct GNUNET_FS_Uri *uri, struct GNUNET_PeerIdentity *peer)
Obtain the identity of the peer offering the data.
Definition: fs_uri.c:812
void *(* GNUNET_FS_ProgressCallback)(void *cls, const struct GNUNET_FS_ProgressInfo *info)
Notification of FS to a client about the progress of an operation.
@ GNUNET_FS_FLAGS_PERSISTENCE
Is persistence of operations desired? (will create SUSPEND/RESUME events).
@ GNUNET_FS_DOWNLOAD_IS_PROBE
Internal option used to flag this download as a 'probe' for a search result.
@ GNUNET_FS_OPTIONS_DOWNLOAD_PARALLELISM
Select the desired amount of parallelism (this option should be followed by an "unsigned int" giving ...
@ GNUNET_FS_OPTIONS_END
Last option in the VARARG list.
@ GNUNET_FS_OPTIONS_REQUEST_PARALLELISM
Maximum number of requests that should be pending at a given point in time (individual downloads may ...
@ GNUNET_FS_STATUS_UNINDEX_RESUME
Notification that we resumed unindexing of a file.
@ GNUNET_FS_STATUS_DOWNLOAD_RESUME
Notification that this download is being resumed.
@ GNUNET_FS_STATUS_SEARCH_RESUME
Last event when a search is being resumed; note that "GNUNET_FS_SEARCH_START" will not be generated i...
@ GNUNET_FS_STATUS_SEARCH_RESUME_RESULT
Event generated for each search result when the respective search is resumed.
@ GNUNET_FS_STATUS_PUBLISH_RESUME
Notification that we have resumed sharing a file structure.
@ GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY
Simulate publishing.
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.
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MultiHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE
Allow multiple values with the same key.
enum GNUNET_GenericReturnValue(* GNUNET_FileNameCallback)(void *cls, const char *filename)
Function called with a filename.
#define GNUNET_log(kind,...)
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_MIN(a, b)
@ GNUNET_SCHEDULER_PRIORITY_IDLE
Run when otherwise idle.
@ GNUNET_SCHEDULER_PRIORITY_BACKGROUND
Run as background job (higher than idle, lower than default).
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
@ GNUNET_SYSERR
#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.
#define GNUNET_log_strerror_file(level, cmd, filename)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_DEBUG
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_malloc_large(size)
Wrapper around malloc.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
void GNUNET_FS_meta_data_destroy(struct GNUNET_FS_MetaData *md)
Free meta data.
Definition: meta_data.c:166
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:979
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:1303
void(* GNUNET_SCHEDULER_TaskCallback)(void *cls)
Signature of the main function of a task.
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:1276
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_with_priority(enum GNUNET_SCHEDULER_Priority prio, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified priority.
Definition: scheduler.c:1230
char * GNUNET_STRINGS_filename_expand(const char *fil)
Complete filename (a la shell) from abbrevition.
Definition: strings.c:504
struct GNUNET_TIME_Relative GNUNET_TIME_relative_min(struct GNUNET_TIME_Relative t1, struct GNUNET_TIME_Relative t2)
Return the minimum of two relative time values.
Definition: time.c:344
#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:438
struct GNUNET_TIME_Relative GNUNET_TIME_relative_saturating_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Saturating multiply relative time by a given factor.
Definition: time.c:533
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:406
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:579
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:111
#define GNUNET_TIME_UNIT_MINUTES
One minute.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_add(struct GNUNET_TIME_Relative a1, struct GNUNET_TIME_Relative a2)
Add relative times together.
Definition: time.c:587
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_subtract(struct GNUNET_TIME_Absolute start, struct GNUNET_TIME_Relative duration)
Subtract a given relative duration from the given start time.
Definition: time.c:471
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:486
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_add(struct GNUNET_TIME_Absolute start, struct GNUNET_TIME_Relative duration)
Add a given relative duration to the given start time.
Definition: time.c:452
#define max(x, y)
#define DIR_SEPARATOR
Definition: platform.h:165
#define DIR_SEPARATOR_STR
Definition: platform.h:166
#define _(String)
GNU gettext support macro.
Definition: platform.h:178
content hash key
Definition: fs.h:55
Information about an active download request.
Definition: fs_api.h:1676
struct DownloadRequest ** children
Array (!) of child-requests, or NULL for the bottom of the tree.
Definition: fs_api.h:1685
unsigned int num_children
Number of entries in children array.
Definition: fs_api.h:1703
uint64_t offset
Offset of the corresponding block.
Definition: fs_api.h:1698
enum BlockRequestState state
State in the FSM.
Definition: fs_api.h:1718
unsigned int depth
Depth of the corresponding block in the tree.
Definition: fs_api.h:1708
struct DownloadRequest * parent
Parent in the CHK-tree.
Definition: fs_api.h:1680
struct ContentHashKey chk
CHK for the request for this block (set during reconstruction to what we have on disk,...
Definition: fs_api.h:1691
Closure for GNUNET_FS_data_reader_file_().
Definition: fs_api.c:413
struct GNUNET_DISK_FileHandle * fd
File descriptor, NULL if it has not yet been opened.
Definition: fs_api.c:422
char * filename
Name of the file to read.
Definition: fs_api.c:417
const struct GNUNET_CONFIGURATION_Handle * cfg
The configuration that we are using.
Definition: arm_api.c:112
Handle for buffered reading.
Definition: bio.c:69
char * emsg
Error message, NULL if there were no errors.
Definition: bio.c:83
Structure specifying a reading operation on an IO handle.
GNUNET_BIO_ReadHandler rh
Function performing data deserialization.
Handle for buffered writing.
Definition: bio.c:466
Structure specifying a writing operation on an IO handle.
GNUNET_BIO_WriteHandler wh
Function performing data serialization.
Private ECC key encoded for transmission.
unsigned int priority
Priority in the queue.
struct GNUNET_DATASTORE_Handle * h
Handle to the master context.
struct GNUNET_DATASTORE_QueueEntry * next
This is a linked list.
Handle used to access files (and pipes).
Settings for publishing a block (which may of course also apply to an entire directory or file).
uint32_t anonymity_level
At which anonymity level should the block be shared? (0: no anonymity, 1: normal GAP,...
uint32_t content_priority
How important is it for us to store the block? If we run out of space, the highest-priority,...
uint32_t replication_level
How often should we try to migrate the block to other peers? Only used if "CONTENT_PUSHING" is set to...
struct GNUNET_TIME_Absolute expiration_time
At what time should the block expire? Data blocks (DBLOCKS and IBLOCKS) may still be used even if the...
Context for controlling a download.
Definition: fs_api.h:1744
int has_finished
Flag set upon transitive completion (includes child downloads).
Definition: fs_api.h:1930
unsigned int treedepth
The depth of the file-tree.
Definition: fs_api.h:1918
char * filename
Where are we writing the data (name of the file, can be NULL!).
Definition: fs_api.h:1822
struct GNUNET_FS_Uri * uri
URI that identifies the file that we are downloading.
Definition: fs_api.h:1800
struct GNUNET_FS_MetaData * meta
Known meta-data for the file (can be NULL).
Definition: fs_api.h:1805
uint64_t old_file_size
What was the size of the file on disk that we're downloading before we started? Used to detect if the...
Definition: fs_api.h:1898
uint64_t completed
How many bytes have we already received within the specified range (DBlocks only).
Definition: fs_api.h:1890
uint64_t offset
What is the first offset that we're interested in?
Definition: fs_api.h:1878
struct GNUNET_FS_QueueEntry * job_queue
Our entry in the job queue.
Definition: fs_api.h:1834
char * emsg
Error message, NULL if we're doing OK.
Definition: fs_api.h:1810
struct GNUNET_SCHEDULER_Task * task
ID of a task that is using this struct and that must be cancelled when the download is being stopped ...
Definition: fs_api.h:1872
struct GNUNET_FS_SearchResult * search
Associated search (used when downloading files based on search results), or NULL for none.
Definition: fs_api.h:1770
struct GNUNET_FS_DownloadContext * child_tail
Tail of list of child downloads.
Definition: fs_api.h:1780
struct GNUNET_CONTAINER_MultiHashMap * active
Map of active requests (those waiting for a response).
Definition: fs_api.h:1851
struct GNUNET_FS_DownloadContext * child_head
Head of list of child downloads.
Definition: fs_api.h:1775
uint64_t length
How many bytes starting from offset are desired? This is NOT the overall length of the file!
Definition: fs_api.h:1884
char * serialization
Random portion of filename we use for syncing state of this download.
Definition: fs_api.h:1816
uint32_t anonymity
Desired level of anonymity.
Definition: fs_api.h:1913
char * temp_filename
Where are we writing the data temporarily (name of the file, can be NULL!); used if we do not have a ...
Definition: fs_api.h:1829
struct GNUNET_FS_DownloadContext * next
Next download belonging to the same parent.
Definition: fs_api.h:1790
struct GNUNET_FS_DownloadContext * parent
Parent download (used when downloading files in directories).
Definition: fs_api.h:1764
struct DownloadRequest * top_request
Top-level download request.
Definition: fs_api.h:1856
struct GNUNET_PeerIdentity target
Identity of the peer having the content, or all-zeros if we don't know of such a peer.
Definition: fs_api.h:1862
enum GNUNET_FS_DownloadOptions options
Options for the download.
Definition: fs_api.h:1923
struct GNUNET_FS_Handle * h
Global FS context.
Definition: fs_api.h:1748
struct GNUNET_TIME_Absolute start_time
Time download was started.
Definition: fs_api.h:1903
struct TopLevelActivity * top
Our top-level activity entry (if we are top-level, otherwise NULL).
Definition: fs_api.h:1753
Information for a file or directory that is about to be published.
Definition: fs_api.h:228
char * serialization
Under what filename is this struct serialized (for operational persistence).
Definition: fs_api.h:287
struct GNUNET_FS_Uri * keywords
Keywords to use for KBlocks.
Definition: fs_api.h:258
char * filename
Name of the file or directory (must be an absolute path).
Definition: fs_api.h:302
size_t dir_size
Size of the directory itself (in bytes); 0 if the size has not yet been calculated.
Definition: fs_api.h:368
uint64_t contents_completed
How much of the directory have we published (relative to contents_size).
Definition: fs_api.h:379
struct GNUNET_FS_FileInformation::@52::@53 file
Data for a file.
GNUNET_FS_DataReader reader
Function that can be used to read the data for the file.
Definition: fs_api.h:317
struct GNUNET_HashCode file_id
If this file is being indexed, this value is set to the hash over the entire file (when the indexing ...
Definition: fs_api.h:329
uint64_t file_size
Size of the file (in bytes).
Definition: fs_api.h:334
char * emsg
Error message (non-NULL if this operation failed).
Definition: fs_api.h:297
void * client_info
Pointer kept for the client.
Definition: fs_api.h:248
struct GNUNET_FS_FileInformation * next
Files in a directory are kept as a linked list.
Definition: fs_api.h:232
struct GNUNET_FS_BlockOptions bo
Block options for the file.
Definition: fs_api.h:275
int is_published
Are we done publishing this file?
Definition: fs_api.h:396
struct GNUNET_FS_MetaData * meta
Metadata to use for the file.
Definition: fs_api.h:253
union GNUNET_FS_FileInformation::@52 data
Data describing either the file or the directory.
int have_hash
Is "file_id" already valid? Set to GNUNET_YES once the hash has been calculated.
Definition: fs_api.h:345
struct GNUNET_FS_Uri * sks_uri
SKS URI for this file or directory.
Definition: fs_api.h:270
int index_start_confirmed
Has the service confirmed our INDEX_START request? GNUNET_YES if this step has been completed.
Definition: fs_api.h:351
void * dir_data
Pointer to the data for the directory (or NULL if not available).
Definition: fs_api.h:374
uint64_t contents_size
Sum of all of the sizes of all of the files in the directory.
Definition: fs_api.h:384
int do_index
Should the file be indexed or inserted?
Definition: fs_api.h:339
void * reader_cls
Closure for reader.
Definition: fs_api.h:322
struct GNUNET_FS_Handle * h
Handle to the master context.
Definition: fs_api.h:243
struct GNUNET_TIME_Absolute start_time
At what time did we start this upload?
Definition: fs_api.h:280
struct GNUNET_FS_FileInformation * entries
Linked list of entries in the directory.
Definition: fs_api.h:362
struct GNUNET_FS_FileInformation * dir
If this is a file in a directory, "dir" refers to the directory; otherwise NULL.
Definition: fs_api.h:238
struct GNUNET_FS_Uri * chk_uri
CHK for this file or directory.
Definition: fs_api.h:264
int is_directory
Is this struct for a file or directory?
Definition: fs_api.h:391
Master context for most FS operations.
Definition: fs_api.h:1070
enum GNUNET_FS_Flags flags
General flags.
Definition: fs_api.h:1162
char * client_name
Name of our client.
Definition: fs_api.h:1079
void * upcb_cls
Closure for upcb.
Definition: fs_api.h:1089
GNUNET_FS_ProgressCallback upcb
Function to call with updates on our progress.
Definition: fs_api.h:1084
Meta data to associate with a file, directory or namespace.
Definition: meta_data.c:92
Argument given to the progress callback with information about what is going on.
struct GNUNET_FS_ProgressInfo::@21::GNUNET_FS_DownloadStatusEvent download
struct GNUNET_FS_ProgressInfo::@21::GNUNET_FS_PublishStatusEvent publish
enum GNUNET_FS_Status status
Specific status code (determines the event type).
struct GNUNET_FS_ProgressInfo::@21::GNUNET_FS_UnindexEvent unindex
union GNUNET_FS_ProgressInfo::@21 value
Values that depend on the event type.
struct GNUNET_FS_ProgressInfo::@21::GNUNET_FS_SearchStatusEvent search
const struct GNUNET_FS_FileInformation * fi
Information about the file that is being published.
Handle for controlling a publication process.
Definition: fs_api.h:1180
int skip_next_fi_callback
Flag set to GNUNET_YES if the next callback from GNUNET_FS_file_information_inspect should be skipped...
Definition: fs_api.h:1299
enum GNUNET_FS_PublishOptions options
Options for publishing.
Definition: fs_api.h:1275
struct GNUNET_DATASTORE_Handle * dsh
Connection to the datastore service.
Definition: fs_api.h:1236
struct TopLevelActivity * top
Our top-level activity entry (if we are top-level, otherwise NULL).
Definition: fs_api.h:1189
struct GNUNET_FS_FileInformation * fi_pos
Current position in the file-tree for the upload.
Definition: fs_api.h:1226
char * nuid
ID for future updates, NULL if we have no namespace or no updates.
Definition: fs_api.h:1209
int all_done
Set to GNUNET_YES if all processing has completed.
Definition: fs_api.h:1292
struct GNUNET_FS_FileInformation * fi
File-structure that is being shared.
Definition: fs_api.h:1194
char * nid
ID of the content in the namespace, NULL if we have no namespace.
Definition: fs_api.h:1204
struct GNUNET_FS_Handle * h
Handle to the global fs context.
Definition: fs_api.h:1184
struct GNUNET_CRYPTO_EcdsaPrivateKey * ns
Namespace that we are publishing in, NULL if we have no namespace.
Definition: fs_api.h:1199
struct GNUNET_SCHEDULER_Task * upload_task
ID of the task performing the upload.
Definition: fs_api.h:1259
char * serialization
Filename used for serializing information about this operation (should be determined using 'mktemp').
Definition: fs_api.h:1215
Entry in the job queue.
Definition: fs_api.h:421
GNUNET_SCHEDULER_TaskCallback stop
Function to call when the job needs to stop (or is done / dequeued).
Definition: fs_api.h:440
void * cls
Closure for start and stop.
Definition: fs_api.h:445
enum GNUNET_FS_QueuePriority priority
How important is this download?
Definition: fs_api.h:481
unsigned int blocks
How many blocks do the active downloads have?
Definition: fs_api.h:476
struct GNUNET_FS_QueueEntry * next
This is a linked list.
Definition: fs_api.h:425
Handle for controlling a search.
Definition: fs_api.h:1511
struct GNUNET_CONTAINER_MultiHashMap * master_result_map
Map that contains a struct GNUNET_FS_SearchResult for each result that was found in the search.
Definition: fs_api.h:1559
char * emsg
Error message (non-NULL if this operation failed).
Definition: fs_api.h:1551
char * serialization
Name of the file on disk we use for persistence.
Definition: fs_api.h:1546
void * client_info
Pointer we keep for the client.
Definition: fs_api.h:1541
struct GNUNET_FS_SearchResult * psearch_result
For update-searches, link to the search result that triggered the update search; otherwise NULL.
Definition: fs_api.h:1531
struct GNUNET_SCHEDULER_Task * task
ID of a task that is using this struct and that must be cancelled when the search is being stopped (i...
Definition: fs_api.h:1583
enum GNUNET_FS_SearchOptions options
Options for the search.
Definition: fs_api.h:1598
uint32_t anonymity
Anonymity level for the search.
Definition: fs_api.h:1588
struct TopLevelActivity * top
Our top-level activity entry (if we are top-level, otherwise NULL).
Definition: fs_api.h:1520
struct GNUNET_FS_Uri * uri
List of keywords that we're looking for.
Definition: fs_api.h:1525
struct GNUNET_FS_Handle * h
Handle to the global FS context.
Definition: fs_api.h:1515
struct GNUNET_MQ_Handle * mq
Connection to the FS service.
Definition: fs_api.h:1536
struct GNUNET_TIME_Absolute start_time
When did we start?
Definition: fs_api.h:1570
Information we store for each search result.
Definition: fs_api.h:499
uint32_t optional_support
Number of optional keywords under which this result was also found.
Definition: fs_api.h:602
struct GNUNET_FS_DownloadContext * download
ID of an associated download based on this search result (or NULL for none).
Definition: fs_api.h:546
struct GNUNET_FS_SearchContext * update_search
If this search result triggered an update search, this field links to the update search.
Definition: fs_api.h:552
void * client_info
Client info for this search result.
Definition: fs_api.h:534
uint32_t availability_trials
Number of availability trials that we have performed for this search result.
Definition: fs_api.h:613
struct GNUNET_FS_Uri * uri
URI to which this search result refers to.
Definition: fs_api.h:524
uint8_t * keyword_bitmap
Bitmap that specifies precisely which keywords have been matched already.
Definition: fs_api.h:562
struct GNUNET_FS_Handle * h
File-sharing context this result belongs to.
Definition: fs_api.h:503
struct GNUNET_HashCode key
Key for the search result based on the URI.
Definition: fs_api.h:567
char * serialization
Name under which this search result is stored on disk.
Definition: fs_api.h:557
uint32_t availability_success
Number of availability tests that have succeeded for this result.
Definition: fs_api.h:607
struct GNUNET_FS_MetaData * meta
Metadata for the search result.
Definition: fs_api.h:529
struct GNUNET_FS_SearchContext * sc
Search context this result belongs to; can be NULL for probes that come from a directory result.
Definition: fs_api.h:519
uint32_t mandatory_missing
Number of mandatory keywords for which we have NOT yet found the search result; when this value hits ...
Definition: fs_api.h:596
Handle for controlling an unindexing operation.
Definition: fs_api.h:1351
enum UnindexState state
Current operatinonal phase.
Definition: fs_api.h:1464
char * emsg
Error message, NULL on success.
Definition: fs_api.h:1439
struct GNUNET_TIME_Absolute start_time
When did we start?
Definition: fs_api.h:1454
struct ContentHashKey chk
The content hash key of the last block we processed, will in the end be set to the CHK from the URI.
Definition: fs_api.h:1356
struct GNUNET_CRYPTO_FileHashContext * fhc
Context for hashing of the file.
Definition: fs_api.h:1444
struct TopLevelActivity * top
Our top-level activity entry.
Definition: fs_api.h:1366
char * filename
Name of the file that we are unindexing.
Definition: fs_api.h:1386
struct GNUNET_FS_Handle * h
Global FS context.
Definition: fs_api.h:1361
uint32_t ksk_offset
Current offset in KSK removal.
Definition: fs_api.h:1381
char * serialization
Short name under which we are serializing the state of this operation.
Definition: fs_api.h:1391
struct GNUNET_FS_Uri * ksk_uri
Keywords found (telling us which KBlocks to remove).
Definition: fs_api.h:1376
struct GNUNET_HashCode file_id
Hash of the file's contents (once computed).
Definition: fs_api.h:1459
uint64_t file_size
Overall size of the file.
Definition: fs_api.h:1449
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 GNUNET_FS_Uri::@49::@50 ksk
unsigned int keywordCount
Size of the keywords array.
Definition: fs_api.h:191
A 512-bit hashcode.
Time for absolute times used by GNUnet, in microseconds.
uint64_t abs_value_us
The actual value.
Time for relative time used by GNUnet, in microseconds.
uint64_t rel_value_us
The actual value.
We track all of the top-level activities of FS so that we can signal 'suspend' on shutdown.
Definition: fs_api.h:1018
void * ssf_cls
Closure for 'ssf' (some struct GNUNET_FS_XXXHandle*)
Definition: fs_api.h:1037
SuspendSignalFunction ssf
Function to call for suspend-signalling and clean up.
Definition: fs_api.h:1032