GNUnet  0.11.x
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 #include "gnunet_fs_service.h"
30 #include "fs_api.h"
31 #include "fs_tree.h"
32 
36 #define DEFAULT_MAX_PARALLEL_REQUESTS (1024 * 10)
37 
41 #define DEFAULT_MAX_PARALLEL_DOWNLOADS 16
42 
49 static void
51 {
52  qe->active = GNUNET_YES;
53  qe->start (qe->cls);
54  qe->start_times++;
55  qe->h->active_blocks += qe->blocks;
56  qe->h->active_downloads++;
57  qe->start_time = GNUNET_TIME_absolute_get ();
59  "Starting job %p (%u active)\n",
60  qe,
61  qe->h->active_downloads);
62  GNUNET_CONTAINER_DLL_remove (qe->h->pending_head, qe->h->pending_tail, qe);
63  GNUNET_CONTAINER_DLL_insert_after (qe->h->running_head,
64  qe->h->running_tail,
65  qe->h->running_tail,
66  qe);
67 }
68 
69 
76 static void
78 {
79  qe->active = GNUNET_NO;
80  qe->stop (qe->cls);
81  GNUNET_assert (0 < qe->h->active_downloads);
82  qe->h->active_downloads--;
83  qe->h->active_blocks -= qe->blocks;
84  qe->run_time = GNUNET_TIME_relative_add (qe->run_time,
86  qe->start_time));
88  "Stopping job %p (%u active)\n",
89  qe,
90  qe->h->active_downloads);
91  GNUNET_CONTAINER_DLL_remove (qe->h->running_head, qe->h->running_tail, qe);
92  GNUNET_CONTAINER_DLL_insert_after (qe->h->pending_head,
93  qe->h->pending_tail,
94  qe->h->pending_tail,
95  qe);
96 }
97 
98 
105 static void
106 process_job_queue (void *cls)
107 {
108  struct GNUNET_FS_Handle *h = cls;
109  struct GNUNET_FS_QueueEntry *qe;
110  struct GNUNET_FS_QueueEntry *next;
111  struct GNUNET_TIME_Relative run_time;
112  struct GNUNET_TIME_Relative restart_at;
113  struct GNUNET_TIME_Relative rst;
115  unsigned int num_downloads_waiting;
116  unsigned int num_downloads_active;
117  unsigned int num_downloads_expired;
118  unsigned int num_probes_active;
119  unsigned int num_probes_waiting;
120  unsigned int num_probes_expired;
121  int num_probes_change;
122  int num_downloads_change;
123  int block_limit_hit;
124 
125  h->queue_job = NULL;
126  /* restart_at will be set to the time when it makes sense to
127  re-evaluate the job queue (unless, of course, jobs complete
128  or are added, then we'll be triggered immediately */
129  restart_at = GNUNET_TIME_UNIT_FOREVER_REL;
130  /* first, calculate some basic statistics on pending jobs */
131  num_probes_waiting = 0;
132  num_downloads_waiting = 0;
133  for (qe = h->pending_head; NULL != qe; qe = qe->next)
134  {
135  switch (qe->priority)
136  {
138  num_probes_waiting++;
139  break;
140 
142  num_downloads_waiting++;
143  break;
144 
145  default:
146  GNUNET_break (0);
147  break;
148  }
149  }
150  /* now, calculate some basic statistics on running jobs */
151  num_probes_active = 0;
152  num_probes_expired = 0;
153  num_downloads_active = 0;
154  num_downloads_expired = 0;
155  next = h->running_head;
156  while (NULL != (qe = next))
157  {
158  next = qe->next;
159  switch (qe->priority)
160  {
163  end_time = GNUNET_TIME_absolute_add (qe->start_time, run_time);
165  if (0 == rst.rel_value_us)
166  {
167  num_probes_expired++;
168  stop_job (qe);
169  }
170  else
171  {
172  num_probes_active++;
173  restart_at = GNUNET_TIME_relative_min (rst, restart_at);
174  }
175  break;
176 
178  run_time =
179  GNUNET_TIME_relative_saturating_multiply (h->avg_block_latency,
180  qe->blocks * qe->start_times);
181  end_time = GNUNET_TIME_absolute_add (qe->start_time, run_time);
183  if (0 == rst.rel_value_us)
184  {
185  num_downloads_expired++;
186  stop_job (qe);
187  }
188  else
189  {
190  num_downloads_active++;
191  restart_at = GNUNET_TIME_relative_min (rst, restart_at);
192  }
193  break;
194 
195  default:
196  GNUNET_break (0);
197  break;
198  }
199  }
200  GNUNET_break (h->active_downloads ==
201  num_downloads_active + num_probes_active);
203  "PA: %u, PE: %u, PW: %u; DA: %u, DE: %u, DW: %u\n",
204  num_probes_active,
205  num_probes_expired,
206  num_probes_waiting,
207  num_downloads_active,
208  num_downloads_expired,
209  num_downloads_waiting);
210  GNUNET_break (h->active_downloads + num_probes_active <=
211  h->max_parallel_downloads);
212  /* calculate start/stop decisions */
213  if (h->active_downloads + num_downloads_waiting > h->max_parallel_downloads)
214  {
215  /* stop as many probes as there are downloads and probes */
216  num_probes_change = -GNUNET_MIN (num_probes_active, num_downloads_waiting);
217  /* start as many downloads as there are free slots, including those
218  we just opened up */
219  num_downloads_change =
220  h->max_parallel_downloads - h->active_downloads - num_probes_change;
221  }
222  else
223  {
224  /* start all downloads (we can) */
225  num_downloads_change = num_downloads_waiting;
226  /* also start probes if there is room, but use a lower cap of (mpd/4) + 1 */
227  if (1 + h->max_parallel_downloads / 4 >=
228  (h->active_downloads + num_downloads_change))
229  num_probes_change =
230  GNUNET_MIN (num_probes_waiting,
231  (1 + h->max_parallel_downloads / 4)
232  - (h->active_downloads + num_downloads_change));
233  else
234  num_probes_change = 0;
235  }
236  GNUNET_break (num_downloads_change <= num_downloads_waiting);
238  "Changing %d probes and %d/%u/%u downloads\n",
239  num_probes_change,
240  num_downloads_change,
241  (unsigned int) h->active_downloads,
242  (unsigned int) h->max_parallel_downloads);
243  /* actually stop probes */
244  next = h->running_head;
245  while (NULL != (qe = next))
246  {
247  next = qe->next;
249  continue;
250  if (num_probes_change < 0)
251  {
252  stop_job (qe);
253  num_probes_change++;
254  if (0 == num_probes_change)
255  break;
256  }
257  }
258  GNUNET_break (0 <= num_probes_change);
259 
260  /* start some more tasks if we now have empty slots */
261  block_limit_hit = GNUNET_NO;
262  next = h->pending_head;
263  while ((NULL != (qe = next)) &&
264  ((num_probes_change > 0) || (num_downloads_change > 0)))
265  {
266  next = qe->next;
267  switch (qe->priority)
268  {
270  if (num_probes_change > 0)
271  {
272  start_job (qe);
273  num_probes_change--;
275  restart_at = GNUNET_TIME_relative_min (run_time, restart_at);
276  }
277  break;
278 
280  if ((num_downloads_change > 0) &&
281  ((qe->blocks + h->active_blocks <= h->max_parallel_requests) ||
282  ((qe->blocks > h->max_parallel_requests) &&
283  (0 == h->active_downloads))))
284  {
285  start_job (qe);
286  num_downloads_change--;
287  }
288  else if (num_downloads_change > 0)
289  block_limit_hit = GNUNET_YES;
290  break;
291 
292  default:
293  GNUNET_break (0);
294  break;
295  }
296  }
297  GNUNET_break ((0 == num_downloads_change) || (GNUNET_YES == block_limit_hit));
298  GNUNET_break (0 == num_probes_change);
299 
300  GNUNET_log (
302  "AD: %u, MP: %u; %d probes and %d downloads to start, will run again in %s\n",
303  h->active_downloads,
304  h->max_parallel_requests,
305  num_probes_change,
306  num_downloads_change,
308 
309  /* make sure we run again, callbacks might have
310  already re-scheduled the job, so cancel such
311  an operation (if it exists) */
312  if (NULL != h->queue_job)
313  GNUNET_SCHEDULER_cancel (h->queue_job);
314  h->queue_job =
316 }
317 
318 
330 struct GNUNET_FS_QueueEntry *
334  void *cls,
335  unsigned int blocks,
337 {
338  struct GNUNET_FS_QueueEntry *qe;
339 
341  qe->h = h;
342  qe->start = start;
343  qe->stop = stop;
344  qe->cls = cls;
345  qe->queue_time = GNUNET_TIME_absolute_get ();
346  qe->blocks = blocks;
347  qe->priority = priority;
348  GNUNET_CONTAINER_DLL_insert_after (h->pending_head,
349  h->pending_tail,
350  h->pending_tail,
351  qe);
352  if (NULL != h->queue_job)
353  GNUNET_SCHEDULER_cancel (h->queue_job);
355  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Queueing job %p\n", qe);
356  return qe;
357 }
358 
359 
365 void
367 {
368  struct GNUNET_FS_Handle *h;
369 
370  h = qe->h;
371  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Dequeueing job %p\n", qe);
372  if (GNUNET_YES == qe->active)
373  stop_job (qe);
374  GNUNET_CONTAINER_DLL_remove (h->pending_head, h->pending_tail, qe);
375  GNUNET_free (qe);
376  if (NULL != h->queue_job)
377  GNUNET_SCHEDULER_cancel (h->queue_job);
379 }
380 
381 
390 struct TopLevelActivity *
393  void *ssf_cls)
394 {
395  struct TopLevelActivity *ret;
396 
397  ret = GNUNET_new (struct TopLevelActivity);
398  ret->ssf = ssf;
399  ret->ssf_cls = ssf_cls;
400  GNUNET_CONTAINER_DLL_insert (h->top_head, h->top_tail, ret);
401  return ret;
402 }
403 
404 
411 void
413 {
414  GNUNET_CONTAINER_DLL_remove (h->top_head, h->top_tail, top);
415  GNUNET_free (top);
416 }
417 
418 
422 struct FileInfo
423 {
427  char *filename;
428 
433 };
434 
435 
456 size_t
458  uint64_t offset,
459  size_t max,
460  void *buf,
461  char **emsg)
462 {
463  struct FileInfo *fi = cls;
464  ssize_t ret;
465 
466  if (UINT64_MAX == offset)
467  {
468  if (NULL != fi->fd)
469  {
471  fi->fd = NULL;
472  }
473  return 0;
474  }
475  if (0 == max)
476  {
477  if (NULL != fi->fd)
479  GNUNET_free (fi->filename);
480  GNUNET_free (fi);
481  return 0;
482  }
483  if (NULL == fi->fd)
484  {
485  fi->fd = GNUNET_DISK_file_open (fi->filename,
488  if (NULL == fi->fd)
489  {
490  GNUNET_asprintf (emsg,
491  _ ("Could not open file `%s': %s"),
492  fi->filename,
493  strerror (errno));
494  return 0;
495  }
496  }
497  if ((GNUNET_SYSERR ==
499  (-1 == (ret = GNUNET_DISK_file_read (fi->fd, buf, max))))
500  {
501  GNUNET_asprintf (emsg,
502  _ ("Could not read file `%s': %s"),
503  fi->filename,
504  strerror (errno));
505  return 0;
506  }
507  if (ret != max)
508  {
509  GNUNET_asprintf (emsg,
510  _ ("Short read reading from file `%s'!"),
511  fi->filename);
512  return 0;
513  }
514  return max;
515 }
516 
517 
524 void *
526 {
527  struct FileInfo *fi;
528 
529  fi = GNUNET_new (struct FileInfo);
531  if (NULL == fi->filename)
532  {
533  GNUNET_free (fi);
534  return NULL;
535  }
536  return fi;
537 }
538 
539 
560 size_t
562  uint64_t offset,
563  size_t max,
564  void *buf,
565  char **emsg)
566 {
567  char *data = cls;
568 
569  if (UINT64_MAX == offset)
570  return 0;
571  if (0 == max)
572  {
573  GNUNET_free (data);
574  return 0;
575  }
576  GNUNET_memcpy (buf, &data[offset], max);
577  return max;
578 }
579 
580 
590 static char *
592  const char *ext,
593  const char *ent)
594 {
595  char *basename;
596  char *ret;
597 
598  if (0 == (h->flags & GNUNET_FS_FLAGS_PERSISTENCE))
599  return NULL; /* persistence not requested */
601  "fs",
602  "STATE_DIR",
603  &basename))
604  return NULL;
606  "%s%s%s%s%s%s%s",
607  basename,
609  h->client_name,
611  ext,
613  ent);
614  GNUNET_free (basename);
615  return ret;
616 }
617 
618 
630 static char *
632  const char *ext,
633  const char *uni,
634  const char *ent)
635 {
636  char *basename;
637  char *ret;
638 
639  if (0 == (h->flags & GNUNET_FS_FLAGS_PERSISTENCE))
640  return NULL; /* persistence not requested */
642  "fs",
643  "STATE_DIR",
644  &basename))
645  return NULL;
647  "%s%s%s%s%s%s%s.dir%s%s",
648  basename,
650  h->client_name,
652  ext,
654  uni,
656  ent);
657  GNUNET_free (basename);
658  return ret;
659 }
660 
661 
670 static struct GNUNET_BIO_ReadHandle *
671 get_read_handle (struct GNUNET_FS_Handle *h, const char *ext, const char *ent)
672 {
673  char *fn;
674  struct GNUNET_BIO_ReadHandle *ret;
675 
676  fn = get_serialization_file_name (h, ext, ent);
677  if (NULL == fn)
678  return NULL;
680  GNUNET_free (fn);
681  return ret;
682 }
683 
684 
693 static struct GNUNET_BIO_WriteHandle *
694 get_write_handle (struct GNUNET_FS_Handle *h, const char *ext, const char *ent)
695 {
696  char *fn;
697  struct GNUNET_BIO_WriteHandle *ret;
698 
699  fn = get_serialization_file_name (h, ext, ent);
700  if (NULL == fn)
701  return NULL;
703  GNUNET_break (NULL != ret);
704  GNUNET_free (fn);
705  return ret;
706 }
707 
708 
718 static struct GNUNET_BIO_WriteHandle *
720  const char *ext,
721  const char *uni,
722  const char *ent)
723 {
724  char *fn;
725  struct GNUNET_BIO_WriteHandle *ret;
726 
727  fn = get_serialization_file_name_in_dir (h, ext, uni, ent);
728  if (NULL == fn)
729  return NULL;
731  GNUNET_free (fn);
732  return ret;
733 }
734 
735 
743 void
745  const char *ext,
746  const char *ent)
747 {
748  char *filename;
749 
750  if ((NULL == ent) || (0 == strlen (ent)))
751  {
752  GNUNET_break (0);
753  return;
754  }
755  filename = get_serialization_file_name (h, ext, ent);
756  if (NULL != filename)
757  {
758  if ((0 != unlink (filename)) && (ENOENT != errno))
761  }
762 }
763 
764 
773 static void
775  const char *ext,
776  const char *uni,
777  const char *ent)
778 {
779  char *filename;
780 
781  if ((NULL == ent) || (0 == strlen (ent)))
782  {
783  GNUNET_break (0);
784  return;
785  }
786  filename = get_serialization_file_name_in_dir (h, ext, uni, ent);
787  if (NULL == filename)
788  return;
789  if (0 != unlink (filename))
792 }
793 
794 
802 void
804  const char *ext,
805  const char *uni)
806 {
807  char *dn;
808 
809  if (NULL == uni)
810  return;
811  dn = get_serialization_file_name_in_dir (h, ext, uni, "");
812  if (NULL == dn)
813  return;
817  GNUNET_free (dn);
818 }
819 
820 
835 static int
837  struct GNUNET_TIME_Absolute timestamp)
838 {
839  struct GNUNET_TIME_Relative dur;
840 
841  dur = GNUNET_TIME_absolute_get_duration (timestamp);
842  return GNUNET_BIO_write_int64 (wh, "start time", dur.rel_value_us);
843 }
844 
845 
860 static int
862  struct GNUNET_TIME_Absolute *timestamp)
863 {
864  struct GNUNET_TIME_Relative dur;
865 
866  if (GNUNET_OK != GNUNET_BIO_read_int64 (rh, "start time",
867  (int64_t *) &dur.rel_value_us))
868  return GNUNET_SYSERR;
870  return GNUNET_OK;
871 }
872 
873 
883 static struct GNUNET_FS_FileInformation *
885 
886 
897 static struct GNUNET_FS_FileInformation *
899  const char *fn,
900  struct GNUNET_BIO_ReadHandle *rh)
901 {
903  struct GNUNET_FS_FileInformation *nxt;
904  char b;
905  char *ksks;
906  char *chks;
907  char *skss;
908  char *filename;
909  uint32_t dsize;
910 
911  if (GNUNET_OK != GNUNET_BIO_read (rh, "status flag", &b, sizeof(b)))
912  {
913  GNUNET_break (0);
914  return NULL;
915  }
917  ret->h = h;
918  ksks = NULL;
919  chks = NULL;
920  skss = NULL;
921  filename = NULL;
922  if ((GNUNET_OK != GNUNET_BIO_read_meta_data (rh, "metadata", &ret->meta)) ||
923  (GNUNET_OK != GNUNET_BIO_read_string (rh, "ksk-uri", &ksks, 32 * 1024)) ||
924  ((NULL != ksks) &&
925  ((NULL == (ret->keywords = GNUNET_FS_uri_parse (ksks, NULL))) ||
926  (GNUNET_YES != GNUNET_FS_uri_test_ksk (ret->keywords)))) ||
927  (GNUNET_OK != GNUNET_BIO_read_string (rh, "chk-uri", &chks, 1024)) ||
928  ((NULL != chks) &&
929  ((NULL == (ret->chk_uri = GNUNET_FS_uri_parse (chks, NULL))) ||
930  (GNUNET_YES != GNUNET_FS_uri_test_chk (ret->chk_uri)))) ||
931  (GNUNET_OK != GNUNET_BIO_read_string (rh, "sks-uri", &skss, 1024)) ||
932  ((NULL != skss) &&
933  ((NULL == (ret->sks_uri = GNUNET_FS_uri_parse (skss, NULL))) ||
934  (GNUNET_YES != GNUNET_FS_uri_test_sks (ret->sks_uri)))) ||
935  (GNUNET_OK != read_start_time (rh, &ret->start_time)) ||
936  (GNUNET_OK !=
937  GNUNET_BIO_read_string (rh, "emsg", &ret->emsg, 16 * 1024)) ||
938  (GNUNET_OK !=
939  GNUNET_BIO_read_string (rh, "fn", &ret->filename, 16 * 1024)) ||
940  (GNUNET_OK !=
942  rh,
943  "expiration time",
944  (int64_t *) &ret->bo.expiration_time.abs_value_us)) ||
946  rh,
947  "anonymity level",
948  (int32_t *) &ret->bo.anonymity_level)) ||
950  rh,
951  "content priority",
952  (int32_t *) &ret->bo.content_priority)) ||
954  rh,
955  "replication level",
956  (int32_t *) &ret->bo.replication_level)))
957  {
958  GNUNET_break (0);
959  goto cleanup;
960  }
961  switch (b)
962  {
963  case 0: /* file-insert */
965  rh,
966  "file size",
967  (int64_t *) &ret->data.file.file_size))
968  {
969  GNUNET_break (0);
970  goto cleanup;
971  }
972  ret->is_directory = GNUNET_NO;
973  ret->data.file.do_index = GNUNET_NO;
974  ret->data.file.have_hash = GNUNET_NO;
975  ret->data.file.index_start_confirmed = GNUNET_NO;
976  if (GNUNET_NO == ret->is_published)
977  {
978  if (NULL == ret->filename)
979  {
980  ret->data.file.reader = &GNUNET_FS_data_reader_copy_;
981  ret->data.file.reader_cls =
982  GNUNET_malloc_large (ret->data.file.file_size);
983  if (ret->data.file.reader_cls == NULL)
984  goto cleanup;
985  if (GNUNET_OK != GNUNET_BIO_read (rh,
986  "file-data",
987  ret->data.file.reader_cls,
988  ret->data.file.file_size))
989  {
990  GNUNET_break (0);
991  goto cleanup;
992  }
993  }
994  else
995  {
996  ret->data.file.reader = &GNUNET_FS_data_reader_file_;
997  ret->data.file.reader_cls =
999  }
1000  }
1001  break;
1002 
1003  case 1: /* file-index, no hash */
1004  if (NULL == ret->filename)
1005  {
1006  GNUNET_break (0);
1007  goto cleanup;
1008  }
1010  rh,
1011  "file size",
1012  (int64_t *) &ret->data.file.file_size))
1013  {
1014  GNUNET_break (0);
1015  goto cleanup;
1016  }
1017  ret->is_directory = GNUNET_NO;
1018  ret->data.file.do_index = GNUNET_YES;
1019  ret->data.file.have_hash = GNUNET_NO;
1020  ret->data.file.index_start_confirmed = GNUNET_NO;
1021  ret->data.file.reader = &GNUNET_FS_data_reader_file_;
1022  ret->data.file.reader_cls =
1024  break;
1025 
1026  case 2: /* file-index-with-hash */
1027  if (NULL == ret->filename)
1028  {
1029  GNUNET_break (0);
1030  goto cleanup;
1031  }
1033  rh,
1034  "file size",
1035  (int64_t *) &ret->data.file.file_size)) ||
1036  (GNUNET_OK != GNUNET_BIO_read (rh,
1037  "fileid",
1038  &ret->data.file.file_id,
1039  sizeof(struct GNUNET_HashCode))))
1040  {
1041  GNUNET_break (0);
1042  goto cleanup;
1043  }
1044  ret->is_directory = GNUNET_NO;
1045  ret->data.file.do_index = GNUNET_YES;
1046  ret->data.file.have_hash = GNUNET_YES;
1047  ret->data.file.index_start_confirmed = GNUNET_NO;
1048  ret->data.file.reader = &GNUNET_FS_data_reader_file_;
1049  ret->data.file.reader_cls =
1051  break;
1052 
1053  case 3: /* file-index-with-hash-confirmed */
1054  if (NULL == ret->filename)
1055  {
1056  GNUNET_break (0);
1057  goto cleanup;
1058  }
1060  rh,
1061  "file size",
1062  (int64_t *) &ret->data.file.file_size)) ||
1063  (GNUNET_OK != GNUNET_BIO_read (rh,
1064  "fileid",
1065  &ret->data.file.file_id,
1066  sizeof(struct GNUNET_HashCode))))
1067  {
1068  GNUNET_break (0);
1069  goto cleanup;
1070  }
1071  ret->is_directory = GNUNET_NO;
1072  ret->data.file.do_index = GNUNET_YES;
1073  ret->data.file.have_hash = GNUNET_YES;
1074  ret->data.file.index_start_confirmed = GNUNET_YES;
1075  ret->data.file.reader = &GNUNET_FS_data_reader_file_;
1076  ret->data.file.reader_cls =
1078  break;
1079 
1080  case 4: /* directory */
1081  ret->is_directory = GNUNET_YES;
1082  if ((GNUNET_OK != GNUNET_BIO_read_int32 (rh, "dsize",
1083  (int32_t *) &dsize)) ||
1084  (GNUNET_OK !=
1086  rh,
1087  "contents completed",
1088  (int64_t *) &ret->data.dir.contents_completed)) ||
1089  (GNUNET_OK !=
1091  rh,
1092  "contents size",
1093  (int64_t *) &ret->data.dir.contents_size)) ||
1094  (NULL == (ret->data.dir.dir_data = GNUNET_malloc_large (dsize))) ||
1095  (GNUNET_OK !=
1096  GNUNET_BIO_read (rh, "dir-data", ret->data.dir.dir_data, dsize)) ||
1097  (GNUNET_OK !=
1098  GNUNET_BIO_read_string (rh, "ent-filename", &filename, 16 * 1024)))
1099  {
1100  GNUNET_break (0);
1101  goto cleanup;
1102  }
1103  ret->data.dir.dir_size = (uint32_t) dsize;
1104  if (NULL != filename)
1105  {
1106  ret->data.dir.entries = deserialize_file_information (h, filename);
1108  filename = NULL;
1109  nxt = ret->data.dir.entries;
1110  while (NULL != nxt)
1111  {
1112  nxt->dir = ret;
1113  nxt = nxt->next;
1114  }
1115  }
1116  break;
1117 
1118  default:
1119  GNUNET_break (0);
1120  goto cleanup;
1121  }
1122  ret->serialization = GNUNET_strdup (fn);
1123  if (GNUNET_OK !=
1124  GNUNET_BIO_read_string (rh, "nxt-filename", &filename, 16 * 1024))
1125  {
1126  GNUNET_break (0);
1127  goto cleanup;
1128  }
1129  if (NULL != filename)
1130  {
1133  filename = NULL;
1134  }
1135  GNUNET_free (ksks);
1136  GNUNET_free (skss);
1137  GNUNET_free (chks);
1138  return ret;
1139 cleanup:
1140  GNUNET_free (ksks);
1141  GNUNET_free (chks);
1142  GNUNET_free (skss);
1145  return NULL;
1146 }
1147 
1148 
1158 static struct GNUNET_FS_FileInformation *
1160 {
1162  struct GNUNET_BIO_ReadHandle *rh;
1163  char *emsg;
1164  char *fn;
1165 
1167  if (NULL == rh)
1168  return NULL;
1169  ret = deserialize_fi_node (h, filename, rh);
1170  if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
1171  {
1173  _ ("Failed to resume publishing information `%s': %s\n"),
1174  filename,
1175  emsg);
1176  GNUNET_free (emsg);
1177  }
1178  if (NULL == ret)
1179  {
1180  fn =
1182  if (NULL != fn)
1183  {
1184  if (0 != unlink (fn))
1186  GNUNET_free (fn);
1187  }
1188  }
1189  return ret;
1190 }
1191 
1192 
1201 static char *
1202 get_serialization_short_name (const char *fullname)
1203 {
1204  const char *end;
1205  const char *nxt;
1206 
1207  end = NULL;
1208  nxt = fullname;
1209  /* FIXME: we could do this faster since we know
1210  * the length of 'end'... */
1211  while ('\0' != *nxt)
1212  {
1213  if (DIR_SEPARATOR == *nxt)
1214  end = nxt + 1;
1215  nxt++;
1216  }
1217  if ((NULL == end) || (0 == strlen (end)))
1218  {
1219  GNUNET_break (0);
1220  return NULL;
1221  }
1222  GNUNET_break (6 == strlen (end));
1223  return GNUNET_strdup (end);
1224 }
1225 
1226 
1235 static char *
1237 {
1238  char *fn;
1239  char *dn;
1240  char *ret;
1241 
1242  if (0 == (h->flags & GNUNET_FS_FLAGS_PERSISTENCE))
1243  return NULL; /* persistence not requested */
1244  dn = get_serialization_file_name (h, ext, "");
1245  if (NULL == dn)
1246  return NULL;
1248  {
1249  GNUNET_free (dn);
1250  return NULL;
1251  }
1252  fn = GNUNET_DISK_mktemp (dn);
1253  GNUNET_free (dn);
1254  if (NULL == fn)
1255  return NULL; /* epic fail */
1257  GNUNET_free (fn);
1258  return ret;
1259 }
1260 
1261 
1271 static char *
1273  const char *ext,
1274  const char *uni)
1275 {
1276  char *fn;
1277  char *dn;
1278  char *ret;
1279 
1280  if (0 == (h->flags & GNUNET_FS_FLAGS_PERSISTENCE))
1281  return NULL; /* persistence not requested */
1282  dn = get_serialization_file_name_in_dir (h, ext, uni, "");
1283  if (NULL == dn)
1284  return NULL;
1286  {
1287  GNUNET_free (dn);
1288  return NULL;
1289  }
1290  fn = GNUNET_DISK_mktemp (dn);
1291  GNUNET_free (dn);
1292  if (NULL == fn)
1293  return NULL; /* epic fail */
1295  GNUNET_free (fn);
1296  return ret;
1297 }
1298 
1299 
1307 static int
1309  struct GNUNET_FS_FileInformation *fi)
1310 {
1311  char buf[32 * 1024];
1312  uint64_t off;
1313  size_t ret;
1314  size_t left;
1315  char *emsg;
1316 
1317  emsg = NULL;
1318  off = 0;
1319  while (off < fi->data.file.file_size)
1320  {
1321  left = GNUNET_MIN (sizeof(buf), fi->data.file.file_size - off);
1322  ret =
1323  fi->data.file.reader (fi->data.file.reader_cls, off, left, buf, &emsg);
1324  if (0 == ret)
1325  {
1326  GNUNET_free (emsg);
1327  return GNUNET_SYSERR;
1328  }
1329  if (GNUNET_OK != GNUNET_BIO_write (wh, "copied from reader", buf, ret))
1330  return GNUNET_SYSERR;
1331  off += ret;
1332  }
1333  return GNUNET_OK;
1334 }
1335 
1336 
1343 void
1345 {
1346  char *fn;
1347  struct GNUNET_BIO_WriteHandle *wh;
1348  char b;
1349  char *ksks;
1350  char *chks;
1351  char *skss;
1352 
1353  if (NULL == fi->serialization)
1354  fi->serialization =
1356  if (NULL == fi->serialization)
1357  return;
1358  wh =
1360  if (NULL == wh)
1361  {
1362  GNUNET_free (fi->serialization);
1363  fi->serialization = NULL;
1364  return;
1365  }
1366  if (GNUNET_YES == fi->is_directory)
1367  b = 4;
1368  else if (GNUNET_YES == fi->data.file.index_start_confirmed)
1369  b = 3;
1370  else if (GNUNET_YES == fi->data.file.have_hash)
1371  b = 2;
1372  else if (GNUNET_YES == fi->data.file.do_index)
1373  b = 1;
1374  else
1375  b = 0;
1376  if (NULL != fi->keywords)
1377  ksks = GNUNET_FS_uri_to_string (fi->keywords);
1378  else
1379  ksks = NULL;
1380  if (NULL != fi->chk_uri)
1381  chks = GNUNET_FS_uri_to_string (fi->chk_uri);
1382  else
1383  chks = NULL;
1384  if (NULL != fi->sks_uri)
1385  skss = GNUNET_FS_uri_to_string (fi->sks_uri);
1386  else
1387  skss = NULL;
1388  struct GNUNET_BIO_WriteSpec ws1[] = {
1389  GNUNET_BIO_write_spec_object ("b", &b, sizeof (b)),
1390  GNUNET_BIO_write_spec_meta_data ("meta", fi->meta),
1391  GNUNET_BIO_write_spec_string ("ksks", ksks),
1392  GNUNET_BIO_write_spec_string ("chks", chks),
1393  GNUNET_BIO_write_spec_string ("skss", skss),
1395  };
1396  struct GNUNET_BIO_WriteSpec ws2[] = {
1397  GNUNET_BIO_write_spec_string ("emsg", fi->emsg),
1398  GNUNET_BIO_write_spec_string ("filename", fi->filename),
1400  "expiration time",
1401  (int64_t *) &fi->bo.expiration_time.abs_value_us),
1403  "anonymity level",
1404  (int32_t *) &fi->bo.anonymity_level),
1406  "content priority",
1407  (int32_t *) &fi->bo.content_priority),
1409  "replication level",
1410  (int32_t *) &fi->bo.replication_level),
1412  };
1413  if ((GNUNET_OK != GNUNET_BIO_write_spec_commit (wh, ws1)) ||
1414  (GNUNET_OK != write_start_time (wh, fi->start_time)) ||
1416  {
1417  GNUNET_break (0);
1418  goto cleanup;
1419  }
1420  GNUNET_free (chks);
1421  chks = NULL;
1422  GNUNET_free (ksks);
1423  ksks = NULL;
1424  GNUNET_free (skss);
1425  skss = NULL;
1426 
1427  switch (b)
1428  {
1429  case 0: /* file-insert */
1430  if (GNUNET_OK != GNUNET_BIO_write_int64 (wh, "file size",
1431  fi->data.file.file_size))
1432  {
1433  GNUNET_break (0);
1434  goto cleanup;
1435  }
1436  if ((GNUNET_NO == fi->is_published) && (NULL == fi->filename))
1437  if (GNUNET_OK != copy_from_reader (wh, fi))
1438  {
1439  GNUNET_break (0);
1440  goto cleanup;
1441  }
1442  break;
1443 
1444  case 1: /* file-index, no hash */
1445  if (NULL == fi->filename)
1446  {
1447  GNUNET_break (0);
1448  goto cleanup;
1449  }
1450  if (GNUNET_OK != GNUNET_BIO_write_int64 (wh, "file size",
1451  fi->data.file.file_size))
1452  {
1453  GNUNET_break (0);
1454  goto cleanup;
1455  }
1456  break;
1457 
1458  case 2: /* file-index-with-hash */
1459  case 3: /* file-index-with-hash-confirmed */
1460  if (NULL == fi->filename)
1461  {
1462  GNUNET_break (0);
1463  goto cleanup;
1464  }
1465  if ((GNUNET_OK != GNUNET_BIO_write_int64 (wh, "file size",
1466  fi->data.file.file_size)) ||
1468  "file id",
1469  &fi->data.file.file_id,
1470  sizeof(struct GNUNET_HashCode))))
1471  {
1472  GNUNET_break (0);
1473  goto cleanup;
1474  }
1475  break;
1476 
1477  case 4: /* directory */
1478  if ((NULL != fi->data.dir.entries) &&
1479  (NULL == fi->data.dir.entries->serialization))
1481  struct GNUNET_BIO_WriteSpec ws[] = {
1482  GNUNET_BIO_write_spec_int32 ("dir size",
1483  (int32_t *) &fi->data.dir.dir_size),
1485  "contents completed",
1486  (int64_t *) &fi->data.dir.contents_completed),
1487  GNUNET_BIO_write_spec_int64 ("contents size",
1488  (int64_t *) &fi->data.dir.contents_size),
1489  GNUNET_BIO_write_spec_object ("dir data",
1490  fi->data.dir.dir_data,
1491  (uint32_t) fi->data.dir.dir_size),
1492  GNUNET_BIO_write_spec_string ("dir entries",
1493  (fi->data.dir.entries == NULL)
1494  ? NULL
1495  : fi->data.dir.entries->serialization),
1497  };
1498  if ((GNUNET_OK != GNUNET_BIO_write_spec_commit (wh, ws)))
1499  {
1500  GNUNET_break (0);
1501  goto cleanup;
1502  }
1503  break;
1504 
1505  default:
1506  GNUNET_assert (0);
1507  goto cleanup;
1508  }
1509  if ((NULL != fi->next) && (NULL == fi->next->serialization))
1512  "serialization",
1513  (fi->next != NULL)
1514  ? fi->next->serialization
1515  : NULL))
1516  {
1517  GNUNET_break (0);
1518  goto cleanup;
1519  }
1520  if (GNUNET_OK != GNUNET_BIO_write_close (wh, NULL))
1521  {
1522  wh = NULL;
1523  GNUNET_break (0);
1524  goto cleanup;
1525  }
1526  return; /* done! */
1527 cleanup:
1528  if (NULL != wh)
1529  (void) GNUNET_BIO_write_close (wh, NULL);
1530  GNUNET_free (chks);
1531  GNUNET_free (ksks);
1532  GNUNET_free (skss);
1533  fn = get_serialization_file_name (fi->h,
1535  fi->serialization);
1536  if (NULL != fn)
1537  {
1538  if (0 != unlink (fn))
1540  GNUNET_free (fn);
1541  }
1542  GNUNET_free (fi->serialization);
1543  fi->serialization = NULL;
1544 }
1545 
1546 
1555 static struct GNUNET_FS_FileInformation *
1556 find_file_position (struct GNUNET_FS_FileInformation *pos, const char *srch)
1557 {
1558  struct GNUNET_FS_FileInformation *r;
1559 
1560  while (NULL != pos)
1561  {
1562  if (0 == strcmp (srch, pos->serialization))
1563  return pos;
1564  if ((GNUNET_YES == pos->is_directory) &&
1565  (NULL != (r = find_file_position (pos->data.dir.entries, srch))))
1566  return r;
1567  pos = pos->next;
1568  }
1569  return NULL;
1570 }
1571 
1572 
1587 static int
1589  struct GNUNET_FS_FileInformation *fi,
1590  uint64_t length,
1592  struct GNUNET_FS_Uri **uri,
1593  struct GNUNET_FS_BlockOptions *bo,
1594  int *do_index,
1595  void **client_info)
1596 {
1597  struct GNUNET_FS_PublishContext *pc = cls;
1598  struct GNUNET_FS_ProgressInfo pi;
1599 
1601  {
1603  return GNUNET_OK;
1604  }
1606  pi.value.publish.specifics.resume.message = fi->emsg;
1607  pi.value.publish.specifics.resume.chk_uri = fi->chk_uri;
1608  *client_info = GNUNET_FS_publish_make_status_ (&pi, pc, fi, 0);
1610  {
1611  /* process entries in directory */
1614  }
1615  return GNUNET_OK;
1616 }
1617 
1618 
1627 static int
1628 deserialize_publish_file (void *cls, const char *filename)
1629 {
1630  struct GNUNET_FS_Handle *h = cls;
1631  struct GNUNET_BIO_ReadHandle *rh;
1632  struct GNUNET_FS_PublishContext *pc;
1633  int32_t options;
1634  int32_t all_done;
1635  int32_t have_ns;
1636  char *fi_root;
1638  char *fi_pos;
1639  char *emsg;
1640 
1642  pc->h = h;
1644  fi_root = NULL;
1645  fi_pos = NULL;
1647  if (NULL == rh)
1648  {
1649  GNUNET_break (0);
1650  goto cleanup;
1651  }
1652  struct GNUNET_BIO_ReadSpec rs[] = {
1653  GNUNET_BIO_read_spec_string ("publish-nid", &pc->nid, 1024),
1654  GNUNET_BIO_read_spec_string ("publish-nuid", &pc->nuid, 1024),
1655  GNUNET_BIO_read_spec_int32 ("options", &options),
1656  GNUNET_BIO_read_spec_int32 ("all done", &all_done),
1657  GNUNET_BIO_read_spec_int32 ("have ns", &have_ns),
1658  GNUNET_BIO_read_spec_string ("publish-firoot", &fi_root, 128),
1659  GNUNET_BIO_read_spec_string ("publish-fipos", &fi_pos, 128),
1661  };
1662  if ((GNUNET_OK != GNUNET_BIO_read_spec_commit (rh, rs)) ||
1663  ((GNUNET_YES == have_ns) &&
1664  (GNUNET_OK != GNUNET_BIO_read (rh, "publish-ns", &ns, sizeof(ns)))))
1665  {
1666  GNUNET_break (0);
1667  goto cleanup;
1668  }
1669  pc->options = options;
1670  pc->all_done = all_done;
1671  if (NULL == fi_root)
1672  {
1673  GNUNET_break (0);
1674  goto cleanup;
1675  }
1676  pc->fi = deserialize_file_information (h, fi_root);
1677  if (NULL == pc->fi)
1678  {
1679  GNUNET_break (0);
1680  goto cleanup;
1681  }
1682  if (GNUNET_YES == have_ns)
1683  {
1685  *pc->ns = ns;
1686  }
1688  (GNUNET_YES != pc->all_done))
1689  {
1691  if (NULL == pc->dsh)
1692  goto cleanup;
1693  }
1694  if (NULL != fi_pos)
1695  {
1696  pc->fi_pos = find_file_position (pc->fi, fi_pos);
1697  GNUNET_free (fi_pos);
1698  fi_pos = NULL;
1699  if (NULL == pc->fi_pos)
1700  {
1701  /* failed to find position for resuming, outch! Will start from root! */
1702  GNUNET_break (0);
1703  if (GNUNET_YES != pc->all_done)
1704  pc->fi_pos = pc->fi;
1705  }
1706  }
1707  GNUNET_free (fi_root);
1708  fi_root = NULL;
1709  /* generate RESUME event(s) */
1711 
1712  /* re-start publishing (if needed)... */
1713  if (GNUNET_YES != pc->all_done)
1714  {
1715  GNUNET_assert (NULL == pc->upload_task);
1716  pc->upload_task =
1719  pc);
1720  }
1721  if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
1722  {
1724  _ ("Failure while resuming publishing operation `%s': %s\n"),
1725  filename,
1726  emsg);
1727  GNUNET_free (emsg);
1728  }
1730  return GNUNET_OK;
1731 cleanup:
1732  GNUNET_free (pc->nid);
1733  GNUNET_free (pc->nuid);
1734  GNUNET_free (fi_root);
1735  GNUNET_free (fi_pos);
1736  if ((NULL != rh) && (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg)))
1737  {
1739  _ ("Failed to resume publishing operation `%s': %s\n"),
1740  filename,
1741  emsg);
1742  GNUNET_free (emsg);
1743  }
1744  if (NULL != pc->fi)
1745  GNUNET_FS_file_information_destroy (pc->fi, NULL, NULL);
1746  if (0 != unlink (filename))
1749  GNUNET_free (pc);
1750  return GNUNET_OK;
1751 }
1752 
1753 
1762 void
1764 {
1765  struct GNUNET_BIO_WriteHandle *wh;
1766  int32_t have_ns;
1767 
1768  if (NULL == pc->serialization)
1769  pc->serialization =
1771  if (NULL == pc->serialization)
1772  return;
1773  if (NULL == pc->fi)
1774  return;
1775  if (NULL == pc->fi->serialization)
1776  {
1777  GNUNET_break (0);
1778  return;
1779  }
1780  wh = get_write_handle (pc->h,
1782  pc->serialization);
1783  if (NULL == wh)
1784  {
1785  GNUNET_break (0);
1786  goto cleanup;
1787  }
1788  have_ns = (NULL != pc->ns) ? GNUNET_YES : GNUNET_NO;
1789  struct GNUNET_BIO_WriteSpec ws[] = {
1792  GNUNET_BIO_write_spec_int32 ("options", (int32_t *) &pc->options),
1793  GNUNET_BIO_write_spec_int32 ("all done", &pc->all_done),
1794  GNUNET_BIO_write_spec_int32 ("have ns", &have_ns),
1795  GNUNET_BIO_write_spec_string ("serialization", pc->fi->serialization),
1796  GNUNET_BIO_write_spec_string ("pos serialization", (NULL == pc->fi_pos)
1797  ? NULL
1798  : pc->fi_pos->serialization),
1800  };
1801  if ((GNUNET_OK != GNUNET_BIO_write_spec_commit (wh, ws)) ||
1802  ((NULL != pc->ns) &&
1803  (GNUNET_OK !=
1805  "ns",
1806  pc->ns,
1807  sizeof(struct GNUNET_CRYPTO_EcdsaPrivateKey)))))
1808  {
1809  GNUNET_break (0);
1810  goto cleanup;
1811  }
1812  if (GNUNET_OK != GNUNET_BIO_write_close (wh, NULL))
1813  {
1814  wh = NULL;
1815  GNUNET_break (0);
1816  goto cleanup;
1817  }
1818  return;
1819 cleanup:
1820  if (NULL != wh)
1821  (void) GNUNET_BIO_write_close (wh, NULL);
1824  pc->serialization);
1826  pc->serialization = NULL;
1827 }
1828 
1829 
1838 void
1840 {
1841  struct GNUNET_BIO_WriteHandle *wh;
1842  char *uris;
1843 
1844  if (NULL == uc->serialization)
1845  uc->serialization =
1847  if (NULL == uc->serialization)
1848  return;
1849  wh = get_write_handle (uc->h,
1851  uc->serialization);
1852  if (NULL == wh)
1853  {
1854  GNUNET_break (0);
1855  goto cleanup;
1856  }
1857  if (NULL != uc->ksk_uri)
1859  else
1860  uris = NULL;
1861  struct GNUNET_BIO_WriteSpec ws1[] = {
1862  GNUNET_BIO_write_spec_string ("filename", uc->filename),
1863  GNUNET_BIO_write_spec_int64 ("file size", (int64_t *) &uc->file_size),
1865  };
1866  struct GNUNET_BIO_WriteSpec ws2[] = {
1867  GNUNET_BIO_write_spec_int32 ("state", (int32_t *) &uc->state),
1868  GNUNET_BIO_write_spec_object ("hashkey", &uc->chk,
1869  sizeof (struct ContentHashKey)),
1870  GNUNET_BIO_write_spec_string ("uris", uris),
1871  GNUNET_BIO_write_spec_int32 ("ksk offset", (int32_t *) &uc->ksk_offset),
1873  };
1874  if ((GNUNET_OK != GNUNET_BIO_write_spec_commit (wh, ws1)) ||
1877  ((uc->state == UNINDEX_STATE_FS_NOTIFY) &&
1879  "file id",
1880  &uc->file_id,
1881  sizeof(struct GNUNET_HashCode)))) ||
1882  ((uc->state == UNINDEX_STATE_ERROR) &&
1883  (GNUNET_OK != GNUNET_BIO_write_string (wh, "emsg", uc->emsg))))
1884  {
1885  GNUNET_break (0);
1886  goto cleanup;
1887  }
1888  if (GNUNET_OK != GNUNET_BIO_write_close (wh, NULL))
1889  {
1890  wh = NULL;
1891  GNUNET_break (0);
1892  goto cleanup;
1893  }
1894  return;
1895 cleanup:
1896  if (NULL != wh)
1897  (void) GNUNET_BIO_write_close (wh, NULL);
1900  uc->serialization);
1902  uc->serialization = NULL;
1903 }
1904 
1905 
1913 static int
1915  struct DownloadRequest *dr)
1916 {
1917  unsigned int i;
1918  struct GNUNET_BIO_WriteSpec ws[] = {
1919  GNUNET_BIO_write_spec_int32 ("state", (int32_t *) &dr->state),
1920  GNUNET_BIO_write_spec_int64 ("offset", (int64_t *) &dr->offset),
1921  GNUNET_BIO_write_spec_int32 ("num children", (int32_t *) &dr->num_children),
1922  GNUNET_BIO_write_spec_int32 ("depth", (int32_t *) &dr->depth),
1924  };
1925 
1926  if ((GNUNET_OK != GNUNET_BIO_write_spec_commit (wh, ws)))
1927  return GNUNET_NO;
1928  if ((BRS_CHK_SET == dr->state) &&
1929  (GNUNET_OK !=
1930  GNUNET_BIO_write (wh, "hashkey",
1931  &dr->chk, sizeof(struct ContentHashKey))))
1932  return GNUNET_NO;
1933  for (i = 0; i < dr->num_children; i++)
1934  if (GNUNET_NO == write_download_request (wh, dr->children[i]))
1935  return GNUNET_NO;
1936  return GNUNET_YES;
1937 }
1938 
1939 
1946 static struct DownloadRequest *
1948 {
1949  struct DownloadRequest *dr;
1950  unsigned int i;
1951 
1952  dr = GNUNET_new (struct DownloadRequest);
1953  struct GNUNET_BIO_ReadSpec rs[] = {
1954  GNUNET_BIO_read_spec_int32 ("state", (int32_t *) &dr->state),
1955  GNUNET_BIO_read_spec_int64 ("offset", (int64_t *) &dr->offset),
1956  GNUNET_BIO_read_spec_int32 ("num children", (int32_t *) &dr->num_children),
1958  };
1959  if ((GNUNET_OK != GNUNET_BIO_read_spec_commit (rh, rs)) ||
1960  (dr->num_children > CHK_PER_INODE) ||
1961  (GNUNET_OK != GNUNET_BIO_read_int32 (rh, "depth",
1962  (int32_t *) &dr->depth)) ||
1963  ((0 == dr->depth) && (dr->num_children > 0)) ||
1964  ((dr->depth > 0) && (0 == dr->num_children)))
1965  {
1966  GNUNET_break (0);
1967  dr->num_children = 0;
1968  goto cleanup;
1969  }
1970  if (dr->num_children > 0)
1971  dr->children =
1972  GNUNET_malloc (dr->num_children * sizeof(struct DownloadRequest *));
1973  switch (dr->state)
1974  {
1975  case BRS_INIT:
1976  case BRS_RECONSTRUCT_DOWN:
1978  case BRS_RECONSTRUCT_UP:
1979  break;
1980 
1981  case BRS_CHK_SET:
1982  if (GNUNET_OK !=
1983  GNUNET_BIO_read (rh, "chk", &dr->chk, sizeof(struct ContentHashKey)))
1984  goto cleanup;
1985  break;
1986 
1987  case BRS_DOWNLOAD_DOWN:
1988  case BRS_DOWNLOAD_UP:
1989  case BRS_ERROR:
1990  break;
1991 
1992  default:
1993  GNUNET_break (0);
1994  goto cleanup;
1995  }
1996  for (i = 0; i < dr->num_children; i++)
1997  {
1998  if (NULL == (dr->children[i] = read_download_request (rh)))
1999  goto cleanup;
2000  dr->children[i]->parent = dr;
2001  }
2002  return dr;
2003 cleanup:
2005  return NULL;
2006 }
2007 
2008 
2018 static char *
2020  const char *uni,
2021  const char *ext)
2022 {
2023  char *par;
2024  char *epar;
2025 
2026  if (dc->parent == NULL)
2027  return get_serialization_file_name (dc->h,
2028  (dc->search != NULL)
2031  uni);
2032  if (NULL == dc->parent->serialization)
2033  return NULL;
2035  if (NULL == par)
2036  return NULL;
2037  GNUNET_asprintf (&epar, "%s.dir%s%s%s", par, DIR_SEPARATOR_STR, uni, ext);
2038  GNUNET_free (par);
2039  return epar;
2040 }
2041 
2042 
2051 void
2053 {
2054  struct GNUNET_BIO_WriteHandle *wh;
2055  char *uris;
2056  char *fn;
2057  char *dir;
2058 
2059  if (0 != (dc->options & GNUNET_FS_DOWNLOAD_IS_PROBE))
2060  return; /* we don't sync probes */
2061  if (NULL == dc->serialization)
2062  {
2063  dir = get_download_sync_filename (dc, "", "");
2064  if (NULL == dir)
2065  return;
2067  {
2068  GNUNET_free (dir);
2069  return;
2070  }
2071  fn = GNUNET_DISK_mktemp (dir);
2072  GNUNET_free (dir);
2073  if (NULL == fn)
2074  return;
2076  }
2077  else
2078  {
2080  if (NULL == fn)
2081  {
2083  dc->serialization = NULL;
2084  GNUNET_free (fn);
2085  return;
2086  }
2087  }
2089  if (NULL == wh)
2090  {
2092  dc->serialization = NULL;
2093  GNUNET_free (fn);
2094  return;
2095  }
2098  uris = GNUNET_FS_uri_to_string (dc->uri);
2099  struct GNUNET_BIO_WriteSpec ws1[] = {
2100  GNUNET_BIO_write_spec_string ("uris", uris),
2101  GNUNET_BIO_write_spec_meta_data ("metadata", dc->meta),
2103  GNUNET_BIO_write_spec_string ("filename", dc->filename),
2104  GNUNET_BIO_write_spec_string ("temp filename", dc->temp_filename),
2105  GNUNET_BIO_write_spec_int64 ("old file size",
2106  (int64_t *) &dc->old_file_size),
2107  GNUNET_BIO_write_spec_int64 ("offset", (int64_t *) &dc->offset),
2108  GNUNET_BIO_write_spec_int64 ("length", (int64_t *) &dc->length),
2109  GNUNET_BIO_write_spec_int64 ("completed", (int64_t *) &dc->completed),
2111  };
2112  struct GNUNET_BIO_WriteSpec ws2[] = {
2113  GNUNET_BIO_write_spec_int32 ("anonymity", (int32_t *) &dc->anonymity),
2114  GNUNET_BIO_write_spec_int32 ("options", (int32_t *) &dc->options),
2115  GNUNET_BIO_write_spec_int32 ("has finished", (int32_t *) &dc->has_finished),
2117  };
2118  if ((GNUNET_OK != GNUNET_BIO_write_spec_commit (wh, ws1)) ||
2121  {
2122  GNUNET_break (0);
2123  goto cleanup;
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;
2144 cleanup:
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 
2164 void
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  struct GNUNET_BIO_WriteSpec ws[] = {
2195  GNUNET_BIO_write_spec_string ("uris", uris),
2196  GNUNET_BIO_write_spec_string ("download serialization",
2197  (sr->download != NULL)
2198  ? sr->download->serialization
2199  : NULL),
2200  GNUNET_BIO_write_spec_string ("update search serialization",
2201  (sr->update_search != NULL)
2203  : NULL),
2204  GNUNET_BIO_write_spec_meta_data ("metadata", sr->meta),
2205  GNUNET_BIO_write_spec_object ("key", &sr->key,
2206  sizeof(struct GNUNET_HashCode)),
2207  GNUNET_BIO_write_spec_int32 ("mandatory missing",
2208  (int32_t *) &sr->mandatory_missing),
2209  GNUNET_BIO_write_spec_int32 ("optional support",
2210  (int32_t *) &sr->optional_support),
2211  GNUNET_BIO_write_spec_int32 ("availability success",
2212  (int32_t *) &sr->availability_success),
2213  GNUNET_BIO_write_spec_int32 ("availability trials",
2214  (int32_t *) &sr->availability_trials),
2216  };
2217  if ((GNUNET_OK != GNUNET_BIO_write_spec_commit (wh, ws)))
2218  {
2219  GNUNET_break (0);
2220  goto cleanup;
2221  }
2222  if ((NULL != sr->uri) && (GNUNET_FS_URI_KSK == sr->sc->uri->type) &&
2223  (GNUNET_OK !=
2225  "keyword bitmap",
2226  sr->keyword_bitmap,
2227  (sr->sc->uri->data.ksk.keywordCount + 7) / 8)))
2228  {
2229  GNUNET_break (0);
2230  goto cleanup;
2231  }
2232  if (GNUNET_OK != GNUNET_BIO_write_close (wh, NULL))
2233  {
2234  wh = NULL;
2235  GNUNET_break (0);
2236  goto cleanup;
2237  }
2238  GNUNET_free (uris);
2239  return;
2240 cleanup:
2241  GNUNET_free (uris);
2242  if (NULL != wh)
2243  (void) GNUNET_BIO_write_close (wh, NULL);
2245  (NULL == sr->sc->psearch_result)
2248  sr->sc->serialization,
2249  sr->serialization);
2250  GNUNET_free (sr->serialization);
2251  sr->serialization = NULL;
2252 }
2253 
2254 
2263 void
2265 {
2266  struct GNUNET_BIO_WriteHandle *wh;
2267  char *uris;
2268  char in_pause;
2269  const char *category;
2270 
2271  category = (NULL == sc->psearch_result) ? GNUNET_FS_SYNC_PATH_MASTER_SEARCH
2273  if (NULL == sc->serialization)
2275  if (NULL == sc->serialization)
2276  return;
2277  uris = NULL;
2278  wh = get_write_handle (sc->h, category, sc->serialization);
2279  if (NULL == wh)
2280  {
2281  GNUNET_break (0);
2282  goto cleanup;
2283  }
2286  uris = GNUNET_FS_uri_to_string (sc->uri);
2287  in_pause = (sc->task != NULL) ? 'r' : '\0';
2288  if ((GNUNET_OK != GNUNET_BIO_write_string (wh, "uris", uris)) ||
2290  (GNUNET_OK != GNUNET_BIO_write_string (wh, "emsg", sc->emsg)) ||
2291  (GNUNET_OK != GNUNET_BIO_write_int32 (wh, "options",
2292  (uint32_t) sc->options)) ||
2293  (GNUNET_OK != GNUNET_BIO_write (wh, "in pause",
2294  &in_pause, sizeof(in_pause))) ||
2295  (GNUNET_OK != GNUNET_BIO_write_int32 (wh, "anonymity", sc->anonymity)))
2296  {
2297  GNUNET_break (0);
2298  goto cleanup;
2299  }
2300  GNUNET_free (uris);
2301  uris = NULL;
2302  if (GNUNET_OK != GNUNET_BIO_write_close (wh, NULL))
2303  {
2304  wh = NULL;
2305  GNUNET_break (0);
2306  goto cleanup;
2307  }
2308  return;
2309 cleanup:
2310  if (NULL != wh)
2311  (void) GNUNET_BIO_write_close (wh, NULL);
2312  GNUNET_free (uris);
2315  sc->serialization = NULL;
2316 }
2317 
2318 
2327 static int
2328 deserialize_unindex_file (void *cls, const char *filename)
2329 {
2330  struct GNUNET_FS_Handle *h = cls;
2331  struct GNUNET_BIO_ReadHandle *rh;
2332  struct GNUNET_FS_UnindexContext *uc;
2333  struct GNUNET_FS_ProgressInfo pi;
2334  char *emsg;
2335  char *uris;
2336  uint32_t state;
2337 
2339  uc->h = h;
2342  if (NULL == rh)
2343  {
2344  GNUNET_break (0);
2345  goto cleanup;
2346  }
2347  uris = NULL;
2348  if ((GNUNET_OK !=
2349  GNUNET_BIO_read_string (rh, "unindex-fn", &uc->filename, 10 * 1024)) ||
2350  (GNUNET_OK != GNUNET_BIO_read_int64 (rh, "file size",
2351  (int64_t *) &uc->file_size)) ||
2352  (GNUNET_OK != read_start_time (rh, &uc->start_time)) ||
2353  (GNUNET_OK != GNUNET_BIO_read_int32 (rh, "state",
2354  (int32_t *) &state)) ||
2355  (GNUNET_OK !=
2356  GNUNET_BIO_read (rh, "uri", &uc->chk, sizeof(struct ContentHashKey))) ||
2357  (GNUNET_OK !=
2358  GNUNET_BIO_read_string (rh, "unindex-kskuri", &uris, 10 * 1024)) ||
2359  (GNUNET_OK != GNUNET_BIO_read_int32 (rh, "ksk offset",
2360  (int32_t *) &uc->ksk_offset)))
2361  {
2362  GNUNET_free (uris);
2363  GNUNET_break (0);
2364  goto cleanup;
2365  }
2366  if (NULL != uris)
2367  {
2368  uc->ksk_uri = GNUNET_FS_uri_parse (uris, &emsg);
2369  GNUNET_free (uris);
2370  if (NULL == uc->ksk_uri)
2371  {
2372  GNUNET_break (0);
2373  GNUNET_free (emsg);
2374  goto cleanup;
2375  }
2376  }
2377  if ((uc->ksk_offset > 0) &&
2378  ((NULL == uc->ksk_uri) ||
2379  (uc->ksk_offset > uc->ksk_uri->data.ksk.keywordCount)))
2380  {
2381  GNUNET_break (0);
2382  goto cleanup;
2383  }
2384  uc->state = (enum UnindexState) state;
2385  switch (state)
2386  {
2387  case UNINDEX_STATE_HASHING:
2388  break;
2389 
2391  if (GNUNET_OK != GNUNET_BIO_read (rh,
2392  "unindex-hash",
2393  &uc->file_id,
2394  sizeof(struct GNUNET_HashCode)))
2395  {
2396  GNUNET_break (0);
2397  goto cleanup;
2398  }
2399  break;
2400 
2404  break;
2405 
2407  break;
2408 
2409  case UNINDEX_STATE_ERROR:
2410  if (GNUNET_OK !=
2411  GNUNET_BIO_read_string (rh, "unindex-emsg", &uc->emsg, 10 * 1024))
2412  {
2413  GNUNET_break (0);
2414  goto cleanup;
2415  }
2416  break;
2417 
2418  default:
2419  GNUNET_break (0);
2420  goto cleanup;
2421  }
2424  pi.value.unindex.specifics.resume.message = uc->emsg;
2426  uc,
2428  ? uc->file_size
2429  : 0);
2430  switch (uc->state)
2431  {
2432  case UNINDEX_STATE_HASHING:
2434  uc->filename,
2437  uc);
2438  break;
2439 
2443  break;
2444 
2447  break;
2448 
2451  break;
2452 
2455  break;
2456 
2458  case UNINDEX_STATE_ERROR:
2459  /* no need to resume any operation, we were done */
2460  break;
2461 
2462  default:
2463  break;
2464  }
2465  if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
2466  {
2468  _ ("Failure while resuming unindexing operation `%s': %s\n"),
2469  filename,
2470  emsg);
2471  GNUNET_free (emsg);
2472  }
2473  return GNUNET_OK;
2474 cleanup:
2475  GNUNET_free (uc->filename);
2476  if ((NULL != rh) && (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg)))
2477  {
2479  _ ("Failed to resume unindexing operation `%s': %s\n"),
2480  filename,
2481  emsg);
2482  GNUNET_free (emsg);
2483  }
2484  if (NULL != uc->serialization)
2487  uc->serialization);
2489  GNUNET_free (uc);
2490  return GNUNET_OK;
2491 }
2492 
2493 
2503 static void
2505  struct GNUNET_BIO_ReadHandle *rh,
2506  struct GNUNET_FS_DownloadContext *parent,
2508  const char *serialization);
2509 
2510 
2519 static struct GNUNET_FS_SearchContext *
2521  struct GNUNET_BIO_ReadHandle *rh,
2523  const char *serialization);
2524 
2525 
2534 static int
2535 deserialize_search_result (void *cls, const char *filename)
2536 {
2537  struct GNUNET_FS_SearchContext *sc = cls;
2538  char *serialized;
2539  char *uris;
2540  char *emsg;
2541  char *download;
2542  char *update_srch;
2543  struct GNUNET_BIO_ReadHandle *rh;
2544  struct GNUNET_BIO_ReadHandle *drh;
2545  struct GNUNET_FS_SearchResult *sr;
2546 
2547  serialized = get_serialization_short_name (filename);
2549  if (NULL == rh)
2550  {
2551  if (NULL != serialized)
2552  {
2554  (NULL == sc->psearch_result)
2557  sc->serialization,
2558  serialized);
2559  GNUNET_free (serialized);
2560  }
2561  return GNUNET_OK;
2562  }
2563  emsg = NULL;
2564  uris = NULL;
2565  download = NULL;
2566  update_srch = NULL;
2567  sr = GNUNET_new (struct GNUNET_FS_SearchResult);
2568  sr->h = sc->h;
2569  sr->sc = sc;
2570  sr->serialization = serialized;
2571  if ((GNUNET_OK !=
2572  GNUNET_BIO_read_string (rh, "result-uri", &uris, 10 * 1024)) ||
2573  (NULL == (sr->uri = GNUNET_FS_uri_parse (uris, &emsg))) ||
2574  (GNUNET_OK !=
2575  GNUNET_BIO_read_string (rh, "download-lnk", &download, 16)) ||
2576  (GNUNET_OK !=
2577  GNUNET_BIO_read_string (rh, "search-lnk", &update_srch, 16)) ||
2578  (GNUNET_OK != GNUNET_BIO_read_meta_data (rh, "result-meta", &sr->meta)) ||
2579  (GNUNET_OK != GNUNET_BIO_read (rh,
2580  "result-key",
2581  &sr->key,
2582  sizeof(struct GNUNET_HashCode))) ||
2584  rh,
2585  "mandatory missing",
2586  (int32_t *) &sr->mandatory_missing)) ||
2588  rh,
2589  "optional support",
2590  (int32_t *) &sr->optional_support)) ||
2592  rh,
2593  "availability success",
2594  (int32_t *) &sr->availability_success)) ||
2596  rh,
2597  "availability trials",
2598  (int32_t *) &sr->availability_trials)))
2599  {
2600  GNUNET_break (0);
2601  goto cleanup;
2602  }
2603  if (GNUNET_FS_URI_KSK == sr->sc->uri->type)
2604  {
2606  (sr->sc->uri->data.ksk.keywordCount + 7) / 8); /* round up, count bits */
2607  if (GNUNET_OK !=
2608  GNUNET_BIO_read (rh,
2609  "keyword-bitmap",
2610  sr->keyword_bitmap,
2611  (sr->sc->uri->data.ksk.keywordCount + 7) / 8))
2612  {
2613  GNUNET_break (0);
2614  goto cleanup;
2615  }
2616  }
2617  GNUNET_free (uris);
2618  if (NULL != download)
2619  {
2621  if (NULL != drh)
2622  {
2623  deserialize_download (sc->h, drh, NULL, sr, download);
2624  if (GNUNET_OK != GNUNET_BIO_read_close (drh, &emsg))
2625  {
2627  _ ("Failed to resume sub-download `%s': %s\n"),
2628  download,
2629  emsg);
2630  GNUNET_free (emsg);
2631  }
2632  }
2634  }
2635  if (NULL != update_srch)
2636  {
2637  drh =
2639  if (NULL != drh)
2640  {
2641  deserialize_search (sc->h, drh, sr, update_srch);
2642  if (GNUNET_OK != GNUNET_BIO_read_close (drh, &emsg))
2643  {
2645  _ ("Failed to resume sub-search `%s': %s\n"),
2646  update_srch,
2647  emsg);
2648  GNUNET_free (emsg);
2649  }
2650  }
2651  GNUNET_free (update_srch);
2652  }
2655  &sr->key,
2656  sr,
2658  if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
2659  {
2661  _ ("Failure while resuming search operation `%s': %s\n"),
2662  filename,
2663  emsg);
2664  GNUNET_free (emsg);
2665  }
2666  return GNUNET_OK;
2667 cleanup:
2669  GNUNET_free (emsg);
2670  GNUNET_free (uris);
2671  GNUNET_free (update_srch);
2672  if (NULL != sr->uri)
2673  GNUNET_FS_uri_destroy (sr->uri);
2674  if (NULL != sr->meta)
2676  GNUNET_free (sr->serialization);
2677  GNUNET_free (sr);
2678  if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
2679  {
2681  _ ("Failure while resuming search operation `%s': %s\n"),
2682  filename,
2683  emsg);
2684  GNUNET_free (emsg);
2685  }
2686  return GNUNET_OK;
2687 }
2688 
2689 
2698 static void
2700 {
2701  struct GNUNET_FS_DownloadContext *dcc;
2702  struct GNUNET_FS_ProgressInfo pi;
2703 
2705  pi.value.download.specifics.resume.meta = dc->meta;
2706  pi.value.download.specifics.resume.message = dc->emsg;
2708  dcc = dc->child_head;
2709  while (NULL != dcc)
2710  {
2711  signal_download_resume (dcc);
2712  dcc = dcc->next;
2713  }
2714 }
2715 
2716 
2723 static void
2725 
2726 
2736 static int
2737 signal_result_resume (void *cls, const struct GNUNET_HashCode *key, void *value)
2738 {
2739  struct GNUNET_FS_SearchContext *sc = cls;
2740  struct GNUNET_FS_ProgressInfo pi;
2741  struct GNUNET_FS_SearchResult *sr = value;
2742 
2743  if (0 == sr->mandatory_missing)
2744  {
2746  pi.value.search.specifics.resume_result.meta = sr->meta;
2747  pi.value.search.specifics.resume_result.uri = sr->uri;
2748  pi.value.search.specifics.resume_result.result = sr;
2749  pi.value.search.specifics.resume_result.availability_rank =
2751  pi.value.search.specifics.resume_result.availability_certainty =
2752  sr->availability_trials;
2753  pi.value.search.specifics.resume_result.applicability_rank =
2754  sr->optional_support;
2756  }
2757  if (NULL != sr->download)
2758  {
2760  }
2761  else
2762  {
2764  }
2765  if (NULL != sr->update_search)
2767  return GNUNET_YES;
2768 }
2769 
2770 
2776 static void
2778 
2779 
2788 static int
2789 free_result (void *cls, const struct GNUNET_HashCode *key, void *value)
2790 {
2791  struct GNUNET_FS_SearchResult *sr = value;
2792 
2793  if (NULL != sr->update_search)
2794  {
2796  GNUNET_assert (NULL == sr->update_search);
2797  }
2799  GNUNET_FS_uri_destroy (sr->uri);
2800  GNUNET_free (sr);
2801  return GNUNET_YES;
2802 }
2803 
2804 
2810 static void
2812 {
2813  if (NULL != sc->serialization)
2814  {
2816  (sc->psearch_result == NULL)
2819  sc->serialization);
2821  (sc->psearch_result == NULL)
2824  sc->serialization);
2825  }
2827  GNUNET_free (sc->emsg);
2828  if (NULL != sc->uri)
2830  if (NULL != sc->master_result_map)
2831  {
2833  &free_result,
2834  sc);
2836  }
2837  GNUNET_free (sc);
2838 }
2839 
2840 
2849 static int
2850 deserialize_subdownload (void *cls, const char *filename)
2851 {
2852  struct GNUNET_FS_DownloadContext *parent = cls;
2853  char *serialized;
2854  char *emsg;
2855  struct GNUNET_BIO_ReadHandle *rh;
2856 
2857  serialized = get_serialization_short_name (filename);
2859  if (NULL == rh)
2860  {
2862  _ (
2863  "Failed to resume sub-download `%s': could not open file `%s'\n"),
2864  serialized,
2865  filename);
2866  GNUNET_free (serialized);
2867  return GNUNET_OK;
2868  }
2869  deserialize_download (parent->h, rh, parent, NULL, serialized);
2870  if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
2871  {
2873  _ ("Failed to resume sub-download `%s': %s\n"),
2874  serialized,
2875  emsg);
2876  GNUNET_free (emsg);
2877  }
2878  GNUNET_free (serialized);
2879  return GNUNET_OK;
2880 }
2881 
2882 
2890 static void
2892 {
2893  struct GNUNET_FS_DownloadContext *dcc;
2894 
2895  if (NULL != dc->meta)
2897  if (NULL != dc->uri)
2900  GNUNET_free (dc->emsg);
2901  GNUNET_free (dc->filename);
2903  while (NULL != (dcc = dc->child_head))
2904  {
2906  free_download_context (dcc);
2907  }
2909  if (NULL != dc->active)
2911  GNUNET_free (dc);
2912 }
2913 
2914 
2924 static void
2926  struct GNUNET_BIO_ReadHandle *rh,
2929  const char *serialization)
2930 {
2931  struct GNUNET_FS_DownloadContext *dc;
2932  char *emsg;
2933  char *uris;
2934  char *dn;
2935  uint32_t options;
2936  uint32_t status;
2937 
2938  uris = NULL;
2939  emsg = NULL;
2941  dc->parent = parent;
2942  dc->h = h;
2944  struct GNUNET_BIO_ReadSpec rs[] = {
2945  GNUNET_BIO_read_spec_meta_data ("download-meta", &dc->meta),
2946  GNUNET_BIO_read_spec_string ("download-emsg", &dc->emsg, 10 * 1024),
2947  GNUNET_BIO_read_spec_string ("download-fn", &dc->filename, 10 * 1024),
2948  GNUNET_BIO_read_spec_string ("download-tfn",
2949  &dc->temp_filename, 10 * 1024),
2950  GNUNET_BIO_read_spec_int64 ("old file size",
2951  (int64_t *) &dc->old_file_size),
2952  GNUNET_BIO_read_spec_int64 ("offset",
2953  (int64_t *) &dc->offset),
2954  GNUNET_BIO_read_spec_int64 ("length",
2955  (int64_t *) &dc->length),
2956  GNUNET_BIO_read_spec_int64 ("completed",
2957  (int64_t *) &dc->completed),
2959  };
2960  if ((GNUNET_OK !=
2961  GNUNET_BIO_read_string (rh, "download-uri", &uris, 10 * 1024)) ||
2962  (NULL == (dc->uri = GNUNET_FS_uri_parse (uris, &emsg))) ||
2967  (GNUNET_OK != GNUNET_BIO_read_int32 (rh, "anonymity",
2968  (int32_t *) &dc->anonymity)) ||
2969  (GNUNET_OK != GNUNET_BIO_read_int32 (rh, "options",
2970  (int32_t *) &options)) ||
2971  (GNUNET_OK != GNUNET_BIO_read_int32 (rh, "status",
2972  (int32_t *) &status)))
2973  {
2974  GNUNET_break (0);
2975  goto cleanup;
2976  }
2978  dc->active =
2980  GNUNET_NO);
2981  dc->has_finished = (int) status;
2982  dc->treedepth =
2984  if (GNUNET_FS_uri_test_loc (dc->uri))
2987  if (NULL == dc->emsg)
2988  {
2990  if (NULL == dc->top_request)
2991  {
2992  GNUNET_break (0);
2993  goto cleanup;
2994  }
2995  }
2996  dn = get_download_sync_filename (dc, dc->serialization, ".dir");
2997  if (NULL != dn)
2998  {
3001  GNUNET_free (dn);
3002  }
3003  if (NULL != parent)
3004  {
3006  }
3007  if (NULL != search)
3008  {
3009  dc->search = search;
3010  search->download = dc;
3011  }
3012  if ((NULL == parent) && (NULL == search))
3013  {
3014  dc->top =
3017  }
3018  GNUNET_free (uris);
3019  GNUNET_assert (NULL == dc->job_queue);
3021  return;
3022 cleanup:
3023  GNUNET_free (uris);
3024  GNUNET_free (emsg);
3026 }
3027 
3028 
3035 static void
3037 {
3038  struct GNUNET_FS_ProgressInfo pi;
3039 
3041  pi.value.search.specifics.resume.message = sc->emsg;
3042  pi.value.search.specifics.resume.is_paused =
3043  (NULL == sc->mq) ? GNUNET_YES : GNUNET_NO;
3047  sc);
3048 }
3049 
3050 
3059 static struct GNUNET_FS_SearchContext *
3061  struct GNUNET_BIO_ReadHandle *rh,
3063  const char *serialization)
3064 {
3065  struct GNUNET_FS_SearchContext *sc;
3066  char *emsg;
3067  char *uris;
3068  char *dn;
3069  uint32_t options;
3070  char in_pause;
3071 
3072  if ((NULL != psearch_result) && (NULL != psearch_result->update_search))
3073  {
3074  GNUNET_break (0);
3075  return NULL;
3076  }
3077  uris = NULL;
3078  emsg = NULL;
3080  if (NULL != psearch_result)
3081  {
3084  }
3085  sc->h = h;
3087  if ((GNUNET_OK !=
3088  GNUNET_BIO_read_string (rh, "search-uri", &uris, 10 * 1024)) ||
3089  (NULL == (sc->uri = GNUNET_FS_uri_parse (uris, &emsg))) ||
3092  (GNUNET_OK != read_start_time (rh, &sc->start_time)) ||
3093  (GNUNET_OK !=
3094  GNUNET_BIO_read_string (rh, "search-emsg", &sc->emsg, 10 * 1024)) ||
3095  (GNUNET_OK != GNUNET_BIO_read_int32 (rh, "options",
3096  (int32_t *) &options)) ||
3097  (GNUNET_OK !=
3098  GNUNET_BIO_read (rh, "search-pause", &in_pause, sizeof(in_pause))) ||
3099  (GNUNET_OK != GNUNET_BIO_read_int32 (rh, "anonymity",
3100  (int32_t *) &sc->anonymity)))
3101  {
3102  GNUNET_break (0);
3103  goto cleanup;
3104  }
3108  (NULL == sc->psearch_result)
3111  sc->serialization,
3112  "");
3113  if (NULL != dn)
3114  {
3117  GNUNET_free (dn);
3118  }
3119  if (('\0' == in_pause) &&
3121  {
3122  GNUNET_log (
3124  _ ("Could not resume running search, will resume as paused search\n"));
3125  }
3127  GNUNET_free (uris);
3128  return sc;
3129 cleanup:
3130  GNUNET_free (emsg);
3132  GNUNET_free (uris);
3133  return NULL;
3134 }
3135 
3136 
3145 static int
3146 deserialize_search_file (void *cls, const char *filename)
3147 {
3148  struct GNUNET_FS_Handle *h = cls;
3149  char *set;
3150  char *emsg;
3151  struct GNUNET_BIO_ReadHandle *rh;
3152  struct GNUNET_FS_SearchContext *sc;
3153  struct stat buf;
3154 
3155  if (0 != stat (filename, &buf))
3156  {
3158  return GNUNET_OK;
3159  }
3160  if (S_ISDIR (buf.st_mode))
3161  return GNUNET_OK; /* skip directories */
3164  if (NULL == rh)
3165  {
3166  if (NULL != set)
3167  {
3169  GNUNET_free (set);
3170  }
3171  return GNUNET_OK;
3172  }
3173  sc = deserialize_search (h, rh, NULL, set);
3174  if (NULL != sc)
3176  GNUNET_free (set);
3177  if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
3178  {
3180  _ ("Failure while resuming search operation `%s': %s\n"),
3181  filename,
3182  emsg);
3183  GNUNET_free (emsg);
3184  }
3185  return GNUNET_OK;
3186 }
3187 
3188 
3197 static int
3198 deserialize_download_file (void *cls, const char *filename)
3199 {
3200  struct GNUNET_FS_Handle *h = cls;
3201  char *set;
3202  char *emsg;
3203  struct GNUNET_BIO_ReadHandle *rh;
3204 
3207  if (NULL == rh)
3208  {
3209  if (0 != unlink (filename))
3211  GNUNET_free (set);
3212  return GNUNET_OK;
3213  }
3214  deserialize_download (h, rh, NULL, NULL, set);
3215  GNUNET_free (set);
3216  if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
3217  {
3219  _ ("Failure while resuming download operation `%s': %s\n"),
3220  filename,
3221  emsg);
3222  GNUNET_free (emsg);
3223  }
3224  return GNUNET_OK;
3225 }
3226 
3227 
3235 static void
3236 deserialization_master (const char *master_path,
3238  struct GNUNET_FS_Handle *h)
3239 {
3240  char *dn;
3241 
3242  dn = get_serialization_file_name (h, master_path, "");
3243  if (NULL == dn)
3244  return;
3246  GNUNET_DISK_directory_scan (dn, proc, h);
3247  GNUNET_free (dn);
3248 }
3249 
3250 
3262 struct GNUNET_FS_Handle *
3264  const char *client_name,
3266  void *upcb_cls,
3267  enum GNUNET_FS_Flags flags,
3268  ...)
3269 {
3270  struct GNUNET_FS_Handle *ret;
3271  enum GNUNET_FS_OPTIONS opt;
3272  va_list ap;
3273 
3274  ret = GNUNET_new (struct GNUNET_FS_Handle);
3275  ret->cfg = cfg;
3276  ret->client_name = GNUNET_strdup (client_name);
3277  ret->upcb = upcb;
3278  ret->upcb_cls = upcb_cls;
3279  ret->flags = flags;
3280  ret->max_parallel_downloads = DEFAULT_MAX_PARALLEL_DOWNLOADS;
3281  ret->max_parallel_requests = DEFAULT_MAX_PARALLEL_REQUESTS;
3282  ret->avg_block_latency =
3283  GNUNET_TIME_UNIT_MINUTES; /* conservative starting point */
3284  va_start (ap, flags);
3285  while (GNUNET_FS_OPTIONS_END !=
3286  (opt = GNUNET_VA_ARG_ENUM (ap, GNUNET_FS_OPTIONS)))
3287  {
3288  switch (opt)
3289  {
3291  ret->max_parallel_downloads = va_arg (ap, unsigned int);
3292 
3293  break;
3294 
3296  ret->max_parallel_requests = va_arg (ap, unsigned int);
3297 
3298  break;
3299 
3300  default:
3301  GNUNET_break (0);
3302  GNUNET_free (ret->client_name);
3303  GNUNET_free (ret);
3304  va_end (ap);
3305  return NULL;
3306  }
3307  }
3308  va_end (ap);
3309  if (0 != (GNUNET_FS_FLAGS_PERSISTENCE & flags))
3310  {
3313  ret);
3316  ret);
3319  ret);
3322  ret);
3323  }
3324  return ret;
3325 }
3326 
3327 
3337 void
3339 {
3340  while (NULL != h->top_head)
3341  h->top_head->ssf (h->top_head->ssf_cls);
3342  if (NULL != h->queue_job)
3343  GNUNET_SCHEDULER_cancel (h->queue_job);
3344  GNUNET_free (h->client_name);
3345  GNUNET_free (h);
3346 }
3347 
3348 
3349 /* 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:47
#define DBLOCK_SIZE
Size of the individual blocks used for file-sharing.
Definition: fs.h:40
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:3198
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:774
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:36
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:2328
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:1272
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:898
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:1308
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:1159
void GNUNET_FS_unindex_sync_(struct GNUNET_FS_UnindexContext *uc)
Synchronize this unindex struct with its mirror on disk.
Definition: fs_api.c:1839
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:3146
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:525
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:391
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:50
void GNUNET_FS_search_sync_(struct GNUNET_FS_SearchContext *sc)
Synchronize this search struct with its mirror on disk.
Definition: fs_api.c:2264
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:719
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:1236
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:2925
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:671
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:77
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:2699
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:3236
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:1556
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:561
static int read_start_time(struct GNUNET_BIO_ReadHandle *rh, struct GNUNET_TIME_Absolute *timestamp)
Deserialize a start-time.
Definition: fs_api.c:861
static int write_download_request(struct GNUNET_BIO_WriteHandle *wh, struct DownloadRequest *dr)
Serialize a download request.
Definition: fs_api.c:1914
static int free_result(void *cls, const struct GNUNET_HashCode *key, void *value)
Iterator over search results freeing each.
Definition: fs_api.c:2789
void GNUNET_FS_download_sync_(struct GNUNET_FS_DownloadContext *dc)
Synchronize this download struct with its mirror on disk.
Definition: fs_api.c:2052
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:3060
static void process_job_queue(void *cls)
Process the jobs in the job queue, possibly starting some and stopping others.
Definition: fs_api.c:106
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:3036
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:744
static void free_search_context(struct GNUNET_FS_SearchContext *sc)
Free memory allocated by the search context and its children.
Definition: fs_api.c:2811
#define DEFAULT_MAX_PARALLEL_DOWNLOADS
How many downloads can we have outstanding in parallel at a time by default?
Definition: fs_api.c:41
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:631
static struct DownloadRequest * read_download_request(struct GNUNET_BIO_ReadHandle *rh)
Read a download request tree.
Definition: fs_api.c:1947
static int write_start_time(struct GNUNET_BIO_WriteHandle *wh, struct GNUNET_TIME_Absolute timestamp)
Serialize a start-time.
Definition: fs_api.c:836
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:591
static int deserialize_subdownload(void *cls, const char *filename)
Function called with a filename of serialized sub-download to deserialize.
Definition: fs_api.c:2850
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:694
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:803
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:1344
void GNUNET_FS_dequeue_(struct GNUNET_FS_QueueEntry *qe)
Dequeue a job from the queue.
Definition: fs_api.c:366
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:331
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:2535
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:2737
static void free_download_context(struct GNUNET_FS_DownloadContext *dc)
Free this download context and all of its descendants.
Definition: fs_api.c:2891
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:457
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:2019
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:1202
void GNUNET_FS_end_top(struct GNUNET_FS_Handle *h, struct TopLevelActivity *top)
Destroy a top-level activity entry.
Definition: fs_api.c:412
void GNUNET_FS_publish_sync_(struct GNUNET_FS_PublishContext *pc)
Synchronize this publishing struct with its mirror on disk.
Definition: fs_api.c:1763
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:1628
static int fip_signal_resume(void *cls, struct GNUNET_FS_FileInformation *fi, uint64_t length, struct GNUNET_CONTAINER_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:1588
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:1660
@ BRS_RECONSTRUCT_META_UP
We've calculated the CHK bottom-up based on the meta data.
Definition: fs_api.h:1628
@ BRS_CHK_SET
We've determined the real, desired CHK for this block (full tree reconstruction failed),...
Definition: fs_api.h:1645
@ 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:1667
@ 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:1620
@ BRS_INIT
Initial state, block has only been allocated (since it is relevant to the overall download request).
Definition: fs_api.h:1612
@ BRS_DOWNLOAD_DOWN
We've successfully downloaded this block, but the children still need to be either downloaded or veri...
Definition: fs_api.h:1654
@ 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:1636
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:1968
UnindexState
Phases of unindex processing (state machine).
Definition: fs_api.h:1306
@ UNINDEX_STATE_EXTRACT_KEYWORDS
Find out which keywords apply.
Definition: fs_api.h:1321
@ UNINDEX_STATE_COMPLETE
We're done.
Definition: fs_api.h:1337
@ UNINDEX_STATE_DS_REMOVE
We're telling the datastore to delete the respective DBlocks and IBlocks.
Definition: fs_api.h:1316
@ UNINDEX_STATE_HASHING
We're currently hashing the file.
Definition: fs_api.h:1310
@ UNINDEX_STATE_ERROR
We've encountered a fatal error.
Definition: fs_api.h:1342
@ UNINDEX_STATE_FS_NOTIFY
We're notifying the FS service about the unindexing.
Definition: fs_api.h:1332
@ UNINDEX_STATE_DS_REMOVE_KBLOCKS
We're telling the datastore to remove KBlocks.
Definition: fs_api.h:1326
@ GNUNET_FS_URI_KSK
Keyword search key (query with keywords).
Definition: fs_api.h:153
#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:65
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:580
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:48
void GNUNET_FS_free_download_request_(struct DownloadRequest *dr)
(recursively) free download request structure
Definition: fs_download.c:996
#define GNUNET_FS_SYNC_PATH_MASTER_SEARCH
Name of the directory with top-level searches.
Definition: fs_api.h:54
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:1354
#define GNUNET_FS_SYNC_PATH_MASTER_UNINDEX
Name of the directory with unindex operations.
Definition: fs_api.h:86
#define GNUNET_FS_SYNC_PATH_MASTER_PUBLISH
Name of the directory with publishing operations.
Definition: fs_api.h:76
#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:43
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:84
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:103
void GNUNET_FS_download_start_task_(void *cls)
Task that creates the initial (top-level) download request for the file.
Definition: fs_download.c:1809
#define GNUNET_FS_SYNC_PATH_CHILD_SEARCH
Name of the directory with sub-searches (namespace-updates).
Definition: fs_api.h:59
void GNUNET_FS_unindex_do_extract_keywords_(struct GNUNET_FS_UnindexContext *uc)
Extract the keywords for KBlock removal.
Definition: fs_unindex.c:406
void GNUNET_FS_unindex_do_remove_(struct GNUNET_FS_UnindexContext *uc)
Connect to the datastore and remove the blocks.
Definition: fs_unindex.c:649
void GNUNET_FS_search_start_probe_(struct GNUNET_FS_SearchResult *sr)
Start download probes for the given search result.
Definition: fs_search.c:430
GNUNET_FS_QueuePriority
Priorities for the queue.
Definition: fs_api.h:403
@ GNUNET_FS_QUEUE_PRIORITY_NORMAL
Default priority.
Definition: fs_api.h:412
@ GNUNET_FS_QUEUE_PRIORITY_PROBE
This is a probe (low priority).
Definition: fs_api.h:407
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:1010
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:727
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:1408
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:47
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:694
#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:71
void GNUNET_FS_publish_main_(void *cls)
Main function that performs the upload.
Definition: fs_publish.c:1062
#define GNUNET_FS_SYNC_PATH_FILE_INFO
Name of the directory with files that are being published.
Definition: fs_api.h:81
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:1567
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 const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static struct GNUNET_NAMESTORE_Handle * ns
Handle to the namestore.
Definition: gnunet-abd.c:41
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
static int start
Set if we are to start default services (including ARM).
Definition: gnunet-arm.c:39
static char * dir
Set to the directory where runtime files are stored.
Definition: gnunet-arm.c:89
static int end
Set if we are to shutdown all services (including ARM).
Definition: gnunet-arm.c:34
static void cleanup(void *cls)
Function scheduled as very last function, cleans up after us.
static struct GNUNET_TIME_Absolute end_time
At what time MUST the current hostlist request be done?
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
static struct GNUNET_DATASTORE_QueueEntry * qe
Current operation.
struct GNUNET_HashCode key
The key used in the DHT.
static struct GNUNET_FS_DownloadContext * dc
static char * filename
uint32_t data
The data value.
uint16_t status
See PRISM_STATUS_*-constants.
static char * value
Value of the record to add/remove.
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_BlockOptions bo
Options we set for published blocks.
static struct GNUNET_CONTAINER_MetaData * meta
Meta-data provided via command-line option.
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:37
static struct GNUNET_TESTBED_BarrierWaitHandle * wh
Our barrier wait handle.
static char buf[2048]
static struct GNUNET_FS_UnindexContext * uc
enum GNUNET_GenericReturnValue(* GNUNET_FileNameCallback)(void *cls, const char *filename)
Function called with a filename.
#define GNUNET_log(kind,...)
#define GNUNET_VA_ARG_ENUM(va, X)
wrap va_arg for enums
@ GNUNET_SCHEDULER_PRIORITY_IDLE
Run when otherwise idle.
@ GNUNET_SCHEDULER_PRIORITY_BACKGROUND
Run as background job (higher than idle, lower than default).
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_OK
Definition: gnunet_common.h:95
@ GNUNET_YES
Definition: gnunet_common.h:97
@ GNUNET_NO
Definition: gnunet_common.h:94
@ GNUNET_SYSERR
Definition: gnunet_common.h:93
#define GNUNET_MIN(a, b)
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:1045
int 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:326
int GNUNET_BIO_read_meta_data(struct GNUNET_BIO_ReadHandle *h, const char *what, struct GNUNET_CONTAINER_MetaData **result)
Read a metadata container.
Definition: bio.c:389
int GNUNET_BIO_write_spec_commit(struct GNUNET_BIO_WriteHandle *h, struct GNUNET_BIO_WriteSpec *ws)
Execute the write specifications in order.
Definition: bio.c:1539
int GNUNET_BIO_read_int32(struct GNUNET_BIO_ReadHandle *h, const char *what, int32_t *i)
Read an (u)int32_t.
Definition: bio.c:478
struct GNUNET_BIO_ReadHandle * GNUNET_BIO_read_open_file(const char *fn)
Open a file for reading.
Definition: bio.c:119
int 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:795
int GNUNET_BIO_read_int64(struct GNUNET_BIO_ReadHandle *h, const char *what, int64_t *i)
Read an (u)int64_t.
Definition: bio.c:500
int GNUNET_BIO_write_string(struct GNUNET_BIO_WriteHandle *h, const char *what, const char *s)
Write a 0-terminated string.
Definition: bio.c:832
int GNUNET_BIO_write_close(struct GNUNET_BIO_WriteHandle *h, char **emsg)
Close an IO handle.
Definition: bio.c:608
int GNUNET_BIO_write_int32(struct GNUNET_BIO_WriteHandle *h, const char *what, int32_t i)
Write an (u)int32_t.
Definition: bio.c:936
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:1335
#define GNUNET_BIO_read_spec_end()
End of specifications marker.
int GNUNET_BIO_read_spec_commit(struct GNUNET_BIO_ReadHandle *h, struct GNUNET_BIO_ReadSpec *rs)
Execute the read specifications in order.
Definition: bio.c:1242
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:1135
#define GNUNET_BIO_write_spec_end()
End of specifications marker.
int GNUNET_BIO_read_close(struct GNUNET_BIO_ReadHandle *h, char **emsg)
Close an open handle.
Definition: bio.c:166
int GNUNET_BIO_write_int64(struct GNUNET_BIO_WriteHandle *h, const char *what, int64_t i)
Write an (u)int64_t.
Definition: bio.c:956
int 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:287
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:1288
struct GNUNET_BIO_WriteHandle * GNUNET_BIO_write_open_file(const char *fn)
Open a file for writing.
Definition: bio.c:559
struct GNUNET_BIO_WriteSpec GNUNET_BIO_write_spec_meta_data(const char *what, const struct GNUNET_CONTAINER_MetaData *m)
Create the specification to write a metadata container.
Definition: bio.c:1381
struct GNUNET_BIO_ReadSpec GNUNET_BIO_read_spec_meta_data(const char *what, struct GNUNET_CONTAINER_MetaData **result)
Create the specification to read a metadata container.
Definition: bio.c:1091
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:1426
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:1179
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:1471
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:1235
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:1085
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:1306
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_create_for_file(const char *filename)
Create the directory structure for storing a file.
Definition: disk.c:582
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:622
int GNUNET_DISK_directory_scan(const char *dir_name, GNUNET_FileNameCallback callback, void *callback_cls)
Scan a directory for files.
Definition: disk.c:814
@ 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.
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:644
GNUNET_FS_DownloadOptions
Options for downloading.
void *(* GNUNET_FS_ProgressCallback)(void *cls, const struct GNUNET_FS_ProgressInfo *info)
Notification of FS to a client about the progress of an operation.
int GNUNET_FS_meta_data_test_for_directory(const struct GNUNET_CONTAINER_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:54
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:1370
int GNUNET_FS_uri_test_ksk(const struct GNUNET_FS_Uri *uri)
Is this a keyword URI?
Definition: fs_uri.c:1334
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.
int GNUNET_FS_uri_test_loc(const struct GNUNET_FS_Uri *uri)
Is this a location URI?
Definition: fs_uri.c:1394
char * GNUNET_FS_uri_to_string(const struct GNUNET_FS_Uri *uri)
Convert a URI to a UTF-8 String.
Definition: fs_uri.c:2027
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:678
int GNUNET_FS_uri_test_sks(const struct GNUNET_FS_Uri *uri)
Is this a namespace URI?
Definition: fs_uri.c:1281
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:3263
int GNUNET_FS_uri_test_chk(const struct GNUNET_FS_Uri *uri)
Is this a file (or directory) URI?
Definition: fs_uri.c:1356
void GNUNET_FS_stop(struct GNUNET_FS_Handle *h)
Close our connection with the file-sharing service.
Definition: fs_api.c:3338
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:822
@ 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 (invidivual 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.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
int 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.
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE
Allow multiple values with the same key.
#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_CONTAINER_meta_data_destroy(struct GNUNET_CONTAINER_MetaData *md)
Free meta data.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1296
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_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:1223
void(* GNUNET_SCHEDULER_TaskCallback)(void *cls)
Signature of the main function of a task.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1269
char * GNUNET_STRINGS_filename_expand(const char *fil)
Complete filename (a la shell) from abbrevition.
Definition: strings.c:482
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:200
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:263
struct GNUNET_TIME_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:357
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:232
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:86
#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:411
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:296
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:311
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:277
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:557
#define max(x, y)
#define DIR_SEPARATOR
Definition: platform.h:164
#define DIR_SEPARATOR_STR
Definition: platform.h:165
#define _(String)
GNU gettext support macro.
Definition: platform.h:177
content hash key
Definition: fs.h:54
Information about an active download request.
Definition: fs_api.h:1675
struct DownloadRequest ** children
Array (!) of child-requests, or NULL for the bottom of the tree.
Definition: fs_api.h:1684
unsigned int num_children
Number of entries in children array.
Definition: fs_api.h:1702
uint64_t offset
Offset of the corresponding block.
Definition: fs_api.h:1697
enum BlockRequestState state
State in the FSM.
Definition: fs_api.h:1717
unsigned int depth
Depth of the corresponding block in the tree.
Definition: fs_api.h:1707
struct DownloadRequest * parent
Parent in the CHK-tree.
Definition: fs_api.h:1679
struct ContentHashKey chk
CHK for the request for this block (set during reconstruction to what we have on disk,...
Definition: fs_api.h:1690
Closure for GNUNET_FS_data_reader_file_().
Definition: fs_api.c:423
struct GNUNET_DISK_FileHandle * fd
File descriptor, NULL if it has not yet been opened.
Definition: fs_api.c:432
char * filename
Name of the file to read.
Definition: fs_api.c:427
const struct GNUNET_CONFIGURATION_Handle * cfg
The configuration that we are using.
Definition: arm_api.c:112
Handle for buffered reading.
Definition: bio.c:74
char * emsg
Error message, NULL if there were no errors.
Definition: bio.c:88
Structure specifying a reading operation on an IO handle.
GNUNET_BIO_ReadHandler rh
Function performing data deserialization.
Handle for buffered writing.
Definition: bio.c:517
Structure specifying a writing operation on an IO handle.
Meta data to associate with a file, directory or namespace.
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:1743
int has_finished
Flag set upon transitive completion (includes child downloads).
Definition: fs_api.h:1929
unsigned int treedepth
The depth of the file-tree.
Definition: fs_api.h:1917
char * filename
Where are we writing the data (name of the file, can be NULL!).
Definition: fs_api.h:1821
struct GNUNET_FS_Uri * uri
URI that identifies the file that we are downloading.
Definition: fs_api.h:1799
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:1897
uint64_t completed
How many bytes have we already received within the specified range (DBlocks only).
Definition: fs_api.h:1889
uint64_t offset
What is the first offset that we're interested in?
Definition: fs_api.h:1877
struct GNUNET_FS_QueueEntry * job_queue
Our entry in the job queue.
Definition: fs_api.h:1833
char * emsg
Error message, NULL if we're doing OK.
Definition: fs_api.h:1809
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:1871
struct GNUNET_FS_SearchResult * search
Associated search (used when downloading files based on search results), or NULL for none.
Definition: fs_api.h:1769
struct GNUNET_FS_DownloadContext * child_tail
Tail of list of child downloads.
Definition: fs_api.h:1779
struct GNUNET_CONTAINER_MultiHashMap * active
Map of active requests (those waiting for a response).
Definition: fs_api.h:1850
struct GNUNET_FS_DownloadContext * child_head
Head of list of child downloads.
Definition: fs_api.h:1774
uint64_t length
How many bytes starting from offset are desired? This is NOT the overall length of the file!
Definition: fs_api.h:1883
char * serialization
Random portion of filename we use for syncing state of this download.
Definition: fs_api.h:1815
uint32_t anonymity
Desired level of anonymity.
Definition: fs_api.h:1912
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:1828
struct GNUNET_FS_DownloadContext * next
Next download belonging to the same parent.
Definition: fs_api.h:1789
struct GNUNET_FS_DownloadContext * parent
Parent download (used when downloading files in directories).
Definition: fs_api.h:1763
struct DownloadRequest * top_request
Top-level download request.
Definition: fs_api.h:1855
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:1861
struct GNUNET_CONTAINER_MetaData * meta
Known meta-data for the file (can be NULL).
Definition: fs_api.h:1804
enum GNUNET_FS_DownloadOptions options
Options for the download.
Definition: fs_api.h:1922
struct GNUNET_FS_Handle * h
Global FS context.
Definition: fs_api.h:1747
struct GNUNET_TIME_Absolute start_time
Time download was started.
Definition: fs_api.h:1902
struct TopLevelActivity * top
Our top-level activity entry (if we are top-level, otherwise NULL).
Definition: fs_api.h:1752
Information for a file or directory that is about to be published.
Definition: fs_api.h:227
char * serialization
Under what filename is this struct serialized (for operational persistence).
Definition: fs_api.h:286
struct GNUNET_FS_Uri * keywords
Keywords to use for KBlocks.
Definition: fs_api.h:257
char * filename
Name of the file or directory (must be an absolute path).
Definition: fs_api.h:301
size_t dir_size
Size of the directory itself (in bytes); 0 if the size has not yet been calculated.
Definition: fs_api.h:367
uint64_t contents_completed
How much of the directory have we published (relative to contents_size).
Definition: fs_api.h:378
struct GNUNET_FS_FileInformation::@16::@17 file
Data for a file.
char * emsg
Error message (non-NULL if this operation failed).
Definition: fs_api.h:296
void * client_info
Pointer kept for the client.
Definition: fs_api.h:247
struct GNUNET_FS_FileInformation * next
Files in a directory are kept as a linked list.
Definition: fs_api.h:231
struct GNUNET_FS_BlockOptions bo
Block options for the file.
Definition: fs_api.h:274
struct GNUNET_CONTAINER_MetaData * meta
Metadata to use for the file.
Definition: fs_api.h:252
int is_published
Are we done publishing this file?
Definition: fs_api.h:395
struct GNUNET_FS_Uri * sks_uri
SKS URI for this file or directory.
Definition: fs_api.h:269
void * dir_data
Pointer to the data for the directory (or NULL if not available).
Definition: fs_api.h:373
uint64_t contents_size
Sum of all of the sizes of all of the files in the directory.
Definition: fs_api.h:383
int do_index
Should the file be indexed or inserted?
Definition: fs_api.h:338
union GNUNET_FS_FileInformation::@16 data
Data describing either the file or the directory.
struct GNUNET_FS_Handle * h
Handle to the master context.
Definition: fs_api.h:242
struct GNUNET_TIME_Absolute start_time
At what time did we start this upload?
Definition: fs_api.h:279
struct GNUNET_FS_FileInformation * entries
Linked list of entries in the directory.
Definition: fs_api.h:361
struct GNUNET_FS_FileInformation * dir
If this is a file in a directory, "dir" refers to the directory; otherwise NULL.
Definition: fs_api.h:237
struct GNUNET_FS_Uri * chk_uri
CHK for this file or directory.
Definition: fs_api.h:263
int is_directory
Is this struct for a file or directory?
Definition: fs_api.h:390
Master context for most FS operations.
Definition: fs_api.h:1069
enum GNUNET_FS_Flags flags
General flags.
Definition: fs_api.h:1161
char * client_name
Name of our client.
Definition: fs_api.h:1078
void * upcb_cls
Closure for upcb.
Definition: fs_api.h:1088
GNUNET_FS_ProgressCallback upcb
Function to call with updates on our progress.
Definition: fs_api.h:1083
Argument given to the progress callback with information about what is going on.
struct GNUNET_FS_ProgressInfo::@25::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:1179
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:1298
enum GNUNET_FS_PublishOptions options
Options for publishing.
Definition: fs_api.h:1274
struct GNUNET_DATASTORE_Handle * dsh
Connection to the datastore service.
Definition: fs_api.h:1235
struct TopLevelActivity * top
Our top-level activity entry (if we are top-level, otherwise NULL).
Definition: fs_api.h:1188
struct GNUNET_FS_FileInformation * fi_pos
Current position in the file-tree for the upload.
Definition: fs_api.h:1225
char * nuid
ID for future updates, NULL if we have no namespace or no updates.
Definition: fs_api.h:1208
int all_done
Set to GNUNET_YES if all processing has completed.
Definition: fs_api.h:1291
struct GNUNET_FS_FileInformation * fi
File-structure that is being shared.
Definition: fs_api.h:1193
char * nid
ID of the content in the namespace, NULL if we have no namespace.
Definition: fs_api.h:1203
struct GNUNET_FS_Handle * h
Handle to the global fs context.
Definition: fs_api.h:1183
struct GNUNET_CRYPTO_EcdsaPrivateKey * ns
Namespace that we are publishing in, NULL if we have no namespace.
Definition: fs_api.h:1198
struct GNUNET_SCHEDULER_Task * upload_task
ID of the task performing the upload.
Definition: fs_api.h:1258
char * serialization
Filename used for serializing information about this operation (should be determined using 'mktemp').
Definition: fs_api.h:1214
Entry in the job queue.
Definition: fs_api.h:420
GNUNET_SCHEDULER_TaskCallback stop
Function to call when the job needs to stop (or is done / dequeued).
Definition: fs_api.h:439
void * cls
Closure for start and stop.
Definition: fs_api.h:444
enum GNUNET_FS_QueuePriority priority
How important is this download?
Definition: fs_api.h:480
unsigned int blocks
How many blocks do the active downloads have?
Definition: fs_api.h:475
struct GNUNET_FS_QueueEntry * next
This is a linked list.
Definition: fs_api.h:424
Handle for controlling a search.
Definition: fs_api.h:1510
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:1558
char * emsg
Error message (non-NULL if this operation failed).
Definition: fs_api.h:1550
char * serialization
Name of the file on disk we use for persistence.
Definition: fs_api.h:1545
void * client_info
Pointer we keep for the client.
Definition: fs_api.h:1540
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:1530
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:1582
enum GNUNET_FS_SearchOptions options
Options for the search.
Definition: fs_api.h:1597
uint32_t anonymity
Anonymity level for the search.
Definition: fs_api.h:1587
struct TopLevelActivity * top
Our top-level activity entry (if we are top-level, otherwise NULL).
Definition: fs_api.h:1519
struct GNUNET_FS_Uri * uri
List of keywords that we're looking for.
Definition: fs_api.h:1524
struct GNUNET_FS_Handle * h
Handle to the global FS context.
Definition: fs_api.h:1514
struct GNUNET_MQ_Handle * mq
Connection to the FS service.
Definition: fs_api.h:1535
struct GNUNET_TIME_Absolute start_time
When did we start?
Definition: fs_api.h:1569
Information we store for each search result.
Definition: fs_api.h:498
uint32_t optional_support
Number of optional keywords under which this result was also found.
Definition: fs_api.h:601
struct GNUNET_FS_DownloadContext * download
ID of an associated download based on this search result (or NULL for none).
Definition: fs_api.h:545
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:551
void * client_info
Client info for this search result.
Definition: fs_api.h:533
uint32_t availability_trials
Number of availability trials that we have performed for this search result.
Definition: fs_api.h:612
struct GNUNET_FS_Uri * uri
URI to which this search result refers to.
Definition: fs_api.h:523
uint8_t * keyword_bitmap
Bitmap that specifies precisely which keywords have been matched already.
Definition: fs_api.h:561
struct GNUNET_FS_Handle * h
File-sharing context this result belongs to.
Definition: fs_api.h:502
struct GNUNET_HashCode key
Key for the search result based on the URI.
Definition: fs_api.h:566
char * serialization
Name under which this search result is stored on disk.
Definition: fs_api.h:556
struct GNUNET_CONTAINER_MetaData * meta
Metadata for the search result.
Definition: fs_api.h:528
uint32_t availability_success
Number of availability tests that have succeeded for this result.
Definition: fs_api.h:606
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:518
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:595
Handle for controlling an unindexing operation.
Definition: fs_api.h:1350
enum UnindexState state
Current operatinonal phase.
Definition: fs_api.h:1463
char * emsg
Error message, NULL on success.
Definition: fs_api.h:1438
struct GNUNET_TIME_Absolute start_time
When did we start?
Definition: fs_api.h:1453
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:1355
struct GNUNET_CRYPTO_FileHashContext * fhc
Context for hashing of the file.
Definition: fs_api.h:1443
struct TopLevelActivity * top
Our top-level activity entry.
Definition: fs_api.h:1365
char * filename
Name of the file that we are unindexing.
Definition: fs_api.h:1385
struct GNUNET_FS_Handle * h
Global FS context.
Definition: fs_api.h:1360
uint32_t ksk_offset
Current offset in KSK removal.
Definition: fs_api.h:1380
char * serialization
Short name under which we are serializing the state of this operation.
Definition: fs_api.h:1390
struct GNUNET_FS_Uri * ksk_uri
Keywords found (telling us which KBlocks to remove).
Definition: fs_api.h:1375
struct GNUNET_HashCode file_id
Hash of the file's contents (once computed).
Definition: fs_api.h:1458
uint64_t file_size
Overall size of the file.
Definition: fs_api.h:1448
A Universal Resource Identifier (URI), opaque.
Definition: fs_api.h:166
struct GNUNET_FS_Uri::@13::@14 ksk
union GNUNET_FS_Uri::@13 data
enum GNUNET_FS_UriType type
Type of the URI.
Definition: fs_api.h:170
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:1017
void * ssf_cls
Closure for 'ssf' (some struct GNUNET_FS_XXXHandle*)
Definition: fs_api.h:1036
SuspendSignalFunction ssf
Function to call for suspend-signalling and clean up.
Definition: fs_api.h:1031