GNUnet  0.10.x
fs_publish.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2009, 2010 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 */
27 #include "platform.h"
28 #include "gnunet_constants.h"
29 #include "gnunet_signatures.h"
30 #include "gnunet_util_lib.h"
31 #include "gnunet_fs_service.h"
32 #include "fs_api.h"
33 #include "fs_tree.h"
34 
35 
46 void *
49  const struct GNUNET_FS_FileInformation *p,
50  uint64_t offset)
51 {
52  pi->value.publish.pc = pc;
53  pi->value.publish.fi = p;
54  pi->value.publish.cctx = p->client_info;
55  pi->value.publish.pctx = (NULL == p->dir) ? NULL : p->dir->client_info;
56  pi->value.publish.filename = p->filename;
57  pi->value.publish.size =
58  (GNUNET_YES == p->is_directory) ? p->data.dir.dir_size : p->data.file.file_size;
59  pi->value.publish.eta =
61  pi->value.publish.size);
62  pi->value.publish.completed = offset;
63  pi->value.publish.duration =
65  pi->value.publish.anonymity = p->bo.anonymity_level;
66  pi->fsh = pc->h;
67  return pc->h->upcb (pc->h->upcb_cls, pi);
68 }
69 
70 
76 static void
78 {
80  "Cleaning up publish context (done!)\n");
81  if (NULL != pc->fhc)
82  {
84  pc->fhc = NULL;
85  }
86  GNUNET_FS_file_information_destroy (pc->fi, NULL, NULL);
90  if (NULL != pc->dsh)
91  {
93  pc->dsh = NULL;
94  }
95  if (NULL != pc->mq)
96  {
97  GNUNET_MQ_destroy (pc->mq);
98  pc->mq = NULL;
99  }
100  GNUNET_assert (NULL == pc->upload_task);
101  GNUNET_free (pc);
102 }
103 
104 
114 static void
115 ds_put_cont (void *cls,
116  int success,
118  const char *msg)
119 {
120  struct GNUNET_FS_PublishContext *pc = cls;
121  struct GNUNET_FS_ProgressInfo pi;
122 
123  pc->qre = NULL;
124  if (GNUNET_SYSERR == success)
125  {
126  GNUNET_asprintf (&pc->fi_pos->emsg,
127  _("Publishing failed: %s"),
128  msg);
131  pi.value.publish.specifics.error.message = pc->fi_pos->emsg;
132  pc->fi_pos->client_info =
133  GNUNET_FS_publish_make_status_ (&pi, pc, pc->fi_pos, 0);
134  if ((GNUNET_YES != pc->fi_pos->is_directory) &&
135  (NULL != pc->fi_pos->filename) &&
136  (GNUNET_YES == pc->any_done) &&
137  (GNUNET_YES == pc->fi_pos->data.file.do_index))
138  {
139  /* run unindex to clean up */
141  pc->fi_pos->filename,
142  NULL);
143  }
144  return;
145  }
146  pc->any_done = GNUNET_YES;
147  GNUNET_assert (NULL == pc->upload_task);
148  pc->upload_task =
151 }
152 
153 
162 static void
165 {
166  struct GNUNET_FS_ProgressInfo pi;
167 
170  pi.value.publish.specifics.completed.chk_uri = p->chk_uri;
171  pi.value.publish.specifics.completed.sks_uri = p->sks_uri;
172  p->client_info =
173  GNUNET_FS_publish_make_status_ (&pi, pc, p,
174  p->data.file.file_size);
175 }
176 
177 
187 static void
190  const char *emsg)
191 {
192  struct GNUNET_FS_ProgressInfo pi;
193 
194  p->emsg = GNUNET_strdup (emsg);
197  pi.value.publish.specifics.error.message = emsg;
198  p->client_info = GNUNET_FS_publish_make_status_ (&pi, pc, p, 0);
199  if ((p->is_directory != GNUNET_YES) &&
200  (NULL != p->filename) &&
201  (GNUNET_YES == pc->any_done) &&
202  (p->data.file.do_index == GNUNET_YES))
203  {
204  /* run unindex to clean up */
206  p->filename,
207  NULL);
208  }
209 
210 }
211 
212 
221 static void
222 finish_release_reserve (void *cls, int success,
224  const char *msg)
225 {
226  struct GNUNET_FS_PublishContext *pc = cls;
227 
228  pc->qre = NULL;
230  "Releasing reserve done!\n");
231  signal_publish_completion (pc->fi, pc);
232  pc->all_done = GNUNET_YES;
234 }
235 
236 
245 static void
247  const struct GNUNET_FS_Uri *uri,
248  const char *emsg)
249 {
250  struct GNUNET_FS_PublishContext *pc = cls;
251 
252  pc->sks_pc = NULL;
253  if (NULL != emsg)
254  {
255  signal_publish_error (pc->fi, pc, emsg);
257  return;
258  }
259  if (NULL != uri)
260  {
261  /* sks publication, remember namespace URI */
262  pc->fi->sks_uri = GNUNET_FS_uri_dup (uri);
263  }
264  GNUNET_assert (pc->qre == NULL);
265  if ((pc->dsh != NULL) && (pc->rid != 0))
266  {
267  pc->qre =
268  GNUNET_DATASTORE_release_reserve (pc->dsh, pc->rid, UINT_MAX, UINT_MAX,
270  }
271  else
272  {
274  }
275 }
276 
277 
284 static void
286 {
287  if (NULL != pc->ns)
288  pc->sks_pc = GNUNET_FS_publish_sks (pc->h,
289  pc->ns,
290  pc->nid,
291  pc->nuid,
292  pc->fi->meta,
293  pc->fi->chk_uri,
294  &pc->fi->bo,
295  pc->options,
296  &publish_sblocks_cont, pc);
297  else
298  publish_sblocks_cont (pc, NULL, NULL);
299 }
300 
301 
311 static void
313  const struct GNUNET_FS_Uri *uri,
314  const char *emsg)
315 {
316  struct GNUNET_FS_PublishContext *pc = cls;
317  struct GNUNET_FS_FileInformation *p = pc->fi_pos;
318 
319  pc->ksk_pc = NULL;
320  if (NULL != emsg)
321  {
323  "Error uploading KSK blocks: %s\n",
324  emsg);
325  signal_publish_error (p, pc, emsg);
328  GNUNET_assert (NULL == pc->upload_task);
329  pc->upload_task =
333  pc);
334  return;
335  }
337  "KSK blocks published, moving on to next file\n");
338  if (NULL != p->dir)
340  /* move on to next file */
341  if (NULL != p->next)
342  pc->fi_pos = p->next;
343  else
344  pc->fi_pos = p->dir;
346  GNUNET_assert (NULL == pc->upload_task);
347  pc->upload_task =
350 }
351 
352 
366 static size_t
367 block_reader (void *cls,
368  uint64_t offset,
369  size_t max,
370  void *buf,
371  char **emsg)
372 {
373  struct GNUNET_FS_PublishContext *pc = cls;
375  const char *dd;
376  size_t pt_size;
377 
378  p = pc->fi_pos;
379  if (GNUNET_YES == p->is_directory)
380  {
381  pt_size = GNUNET_MIN (max, p->data.dir.dir_size - offset);
382  dd = p->data.dir.dir_data;
383  GNUNET_memcpy (buf, &dd[offset], pt_size);
384  }
385  else
386  {
387  if (UINT64_MAX == offset)
388  {
389  if (&GNUNET_FS_data_reader_file_ == p->data.file.reader)
390  {
391  /* force closing the file to avoid keeping too many files open */
392  p->data.file.reader (p->data.file.reader_cls, offset, 0, NULL, NULL);
393  }
394  return 0;
395  }
396  pt_size = GNUNET_MIN (max, p->data.file.file_size - offset);
397  if (0 == pt_size)
398  return 0; /* calling reader with pt_size==0
399  * might free buf, so don't! */
400  if (pt_size !=
401  p->data.file.reader (p->data.file.reader_cls, offset, pt_size, buf,
402  emsg))
403  return 0;
404  }
405  return pt_size;
406 }
407 
408 
416 static void
417 encode_cont (void *cls)
418 {
419  struct GNUNET_FS_PublishContext *pc = cls;
421  struct GNUNET_FS_ProgressInfo pi;
422  char *emsg;
423  uint64_t flen;
424 
426  "Finished with tree encoder\n");
427  p = pc->fi_pos;
430  GNUNET_FS_tree_encoder_finish (p->te, &emsg);
431  p->te = NULL;
432  if (NULL != emsg)
433  {
435  "Error during tree walk: %s\n",
436  emsg);
437  GNUNET_asprintf (&p->emsg,
438  _("Publishing failed: %s"),
439  emsg);
440  GNUNET_free (emsg);
443  pi.value.publish.specifics.error.message = p->emsg;
444  p->client_info = GNUNET_FS_publish_make_status_ (&pi, pc, p, 0);
445  }
446  else
447  {
448  /* final progress event */
449  GNUNET_assert (NULL != p->chk_uri);
452  pi.value.publish.specifics.progress.data = NULL;
453  pi.value.publish.specifics.progress.offset = flen;
454  pi.value.publish.specifics.progress.data_len = 0;
455  pi.value.publish.specifics.progress.depth = GNUNET_FS_compute_depth (flen);
456  p->client_info = GNUNET_FS_publish_make_status_ (&pi, pc, p, flen);
457  }
458  /* continue with main */ /* continue with main */
459  GNUNET_assert (NULL == pc->upload_task);
460  pc->upload_task =
463 }
464 
465 
480 static void
481 block_proc (void *cls,
482  const struct ContentHashKey *chk,
483  uint64_t offset,
484  unsigned int depth,
485  enum GNUNET_BLOCK_Type type,
486  const void *block,
487  uint16_t block_size)
488 {
489  struct GNUNET_FS_PublishContext *pc = cls;
491  struct OnDemandBlock odb;
492 
493  p = pc->fi_pos;
494  if (NULL == pc->dsh)
495  {
497  "Waiting for datastore connection\n");
498  GNUNET_assert (NULL == pc->upload_task);
499  pc->upload_task =
502  return;
503  }
504 
505  if ( (GNUNET_YES != p->is_directory) &&
506  (GNUNET_YES == p->data.file.do_index) &&
507  (GNUNET_BLOCK_TYPE_FS_DBLOCK == type) )
508  {
510  "Indexing block `%s' for offset %llu with index size %u\n",
511  GNUNET_h2s (&chk->query),
512  (unsigned long long) offset,
513  (unsigned int) sizeof (struct OnDemandBlock));
514  odb.offset = GNUNET_htonll (offset);
515  odb.file_id = p->data.file.file_id;
516  GNUNET_assert (pc->qre == NULL);
517  pc->qre =
519  (p->is_directory == GNUNET_YES) ? 0 : pc->rid,
520  &chk->query,
521  sizeof (struct OnDemandBlock),
522  &odb,
524  p->bo.content_priority,
525  p->bo.anonymity_level,
526  p->bo.replication_level,
527  p->bo.expiration_time,
528  -2, 1,
529  &ds_put_cont, pc);
530  return;
531  }
533  "Publishing block `%s' for offset %llu with size %u\n",
534  GNUNET_h2s (&chk->query),
535  (unsigned long long) offset,
536  (unsigned int) block_size);
537  GNUNET_assert (pc->qre == NULL);
538  pc->qre =
539  GNUNET_DATASTORE_put (pc->dsh, (p->is_directory == GNUNET_YES) ? 0 : pc->rid,
540  &chk->query,
541  block_size,
542  block,
543  type,
544  p->bo.content_priority,
545  p->bo.anonymity_level,
546  p->bo.replication_level,
547  p->bo.expiration_time,
548  -2, 1,
549  &ds_put_cont,
550  pc);
551 }
552 
553 
564 static void
565 progress_proc (void *cls, uint64_t offset,
566  const void *pt_block,
567  size_t pt_size,
568  unsigned int depth)
569 {
570  struct GNUNET_FS_PublishContext *pc = cls;
572  struct GNUNET_FS_FileInformation *par;
573  struct GNUNET_FS_ProgressInfo pi;
574 
575  p = pc->fi_pos;
577  pi.value.publish.specifics.progress.data = pt_block;
578  pi.value.publish.specifics.progress.offset = offset;
579  pi.value.publish.specifics.progress.data_len = pt_size;
580  pi.value.publish.specifics.progress.depth = depth;
581  p->client_info = GNUNET_FS_publish_make_status_ (&pi, pc, p, offset);
582  if ( (0 != depth) ||
583  (GNUNET_YES == p->is_directory) )
584  return;
585  while (NULL != (par = p->dir))
586  {
587  p = par;
589  p->data.dir.contents_completed += pt_size;
591  pi.value.publish.specifics.progress_directory.completed = p->data.dir.contents_completed;
592  pi.value.publish.specifics.progress_directory.total = p->data.dir.contents_size;
593  pi.value.publish.specifics.progress_directory.eta = GNUNET_TIME_calculate_eta (p->start_time,
594  p->data.dir.contents_completed,
595  p->data.dir.contents_size);
596  p->client_info = GNUNET_FS_publish_make_status_ (&pi, pc, p, 0);
597 
598  }
599 }
600 
601 
609 static void
611 {
613  char *emsg;
615  struct GNUNET_FS_FileInformation *dirpos;
616  void *raw_data;
617  uint64_t size;
618 
619  p = pc->fi_pos;
620  GNUNET_assert (NULL != p);
621  if (NULL == p->te)
622  {
623  if (GNUNET_YES == p->is_directory)
624  {
625  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Creating directory\n");
627  dirpos = p->data.dir.entries;
628  while (NULL != dirpos)
629  {
630  if (GNUNET_YES == dirpos->is_directory)
631  {
632  raw_data = dirpos->data.dir.dir_data;
633  dirpos->data.dir.dir_data = NULL;
634  }
635  else
636  {
637  raw_data = NULL;
638  if ((dirpos->data.file.file_size < MAX_INLINE_SIZE) &&
639  (dirpos->data.file.file_size > 0))
640  {
641  raw_data = GNUNET_malloc (dirpos->data.file.file_size);
642  emsg = NULL;
643  if (dirpos->data.file.file_size !=
644  dirpos->data.file.reader (dirpos->data.file.reader_cls, 0,
645  dirpos->data.file.file_size, raw_data,
646  &emsg))
647  {
648  GNUNET_free_non_null (emsg);
649  GNUNET_free (raw_data);
650  raw_data = NULL;
651  }
652  dirpos->data.file.reader (dirpos->data.file.reader_cls, UINT64_MAX, 0, 0, NULL);
653  }
654  }
655  GNUNET_FS_directory_builder_add (db, dirpos->chk_uri, dirpos->meta,
656  raw_data);
657  GNUNET_free_non_null (raw_data);
658  dirpos = dirpos->next;
659  }
661  p->data.dir.dir_data = NULL;
662  p->data.dir.dir_size = 0;
664  &p->data.dir.dir_data);
666  }
667  size = (GNUNET_YES == p->is_directory) ? p->data.dir.dir_size : p->data.file.file_size;
669  "Creating tree encoder\n");
670  p->te =
673  &encode_cont);
674 
675  }
677  "Processing next block from tree\n");
679 }
680 
681 
689 static int
691  const struct GNUNET_MessageHeader *msg)
692 {
693  size_t msize = ntohs (msg->size) - sizeof (*msg);
694  const char *emsg = (const char *) &msg[1];
695 
696  if (emsg[msize - sizeof (struct GNUNET_MessageHeader) - 1] != '\0')
697  {
698  GNUNET_break (0);
699  return GNUNET_SYSERR;
700  }
701  return GNUNET_OK;
702 }
703 
704 
712 static void
714  const struct GNUNET_MessageHeader *msg)
715 {
716  struct GNUNET_FS_PublishContext *pc = cls;
718  const char *emsg = (const char *) &msg[1];
719  char *msgtxt;
720 
721  GNUNET_MQ_destroy (pc->mq);
722  pc->mq = NULL;
723  p = pc->fi_pos;
724  GNUNET_asprintf (&msgtxt,
725  _("Can not index file `%s': %s.\n"),
726  p->filename,
727  gettext (emsg));
729  pc,
730  msgtxt);
731  GNUNET_free (msgtxt);
734 }
735 
736 
744 static void
746  const struct GNUNET_MessageHeader *msg)
747 {
748  struct GNUNET_FS_PublishContext *pc = cls;
750 
751  GNUNET_MQ_destroy (pc->mq);
752  pc->mq = NULL;
753  p = pc->fi_pos;
754  p->data.file.index_start_confirmed = GNUNET_YES;
756  publish_content (pc);
757 }
758 
759 
768 static void
770  enum GNUNET_MQ_Error error)
771 {
772  struct GNUNET_FS_PublishContext *pc = cls;
774 
775  if (NULL != pc->mq)
776  {
777  GNUNET_MQ_destroy (pc->mq);
778  pc->mq = NULL;
779  }
780  p = pc->fi_pos;
782  _("Can not index file `%s': %s. Will try to insert instead.\n"),
783  p->filename,
784  _("error on index-start request to `fs' service"));
785  p->data.file.do_index = GNUNET_NO;
787  publish_content (pc);
788 }
789 
790 
798 static void
799 hash_for_index_cb (void *cls,
800  const struct GNUNET_HashCode *res)
801 {
802  struct GNUNET_FS_PublishContext *pc = cls;
803  struct GNUNET_MQ_MessageHandler handlers[] = {
804  GNUNET_MQ_hd_fixed_size (index_start_ok,
806  struct GNUNET_MessageHeader,
807  pc),
808  GNUNET_MQ_hd_var_size (index_start_failed,
810  struct GNUNET_MessageHeader,
811  pc),
813  };
815  struct GNUNET_MQ_Envelope *env;
816  struct IndexStartMessage *ism;
817  size_t slen;
818  uint64_t dev;
819  uint64_t ino;
820  char *fn;
821 
822  pc->fhc = NULL;
823  p = pc->fi_pos;
824  if (NULL == res)
825  {
827  _("Can not index file `%s': %s. Will try to insert instead.\n"),
828  p->filename,
829  _("failed to compute hash"));
830  p->data.file.do_index = GNUNET_NO;
832  publish_content (pc);
833  return;
834  }
835  if (GNUNET_YES == p->data.file.index_start_confirmed)
836  {
837  publish_content (pc);
838  return;
839  }
841  GNUNET_assert (fn != NULL);
842  slen = strlen (fn) + 1;
843  if (slen >=
844  GNUNET_MAX_MESSAGE_SIZE - sizeof (struct IndexStartMessage))
845  {
847  _
848  ("Can not index file `%s': %s. Will try to insert instead.\n"),
849  fn, _("filename too long"));
850  GNUNET_free (fn);
851  p->data.file.do_index = GNUNET_NO;
853  publish_content (pc);
854  return;
855  }
857  "Hash of indexed file `%s' is `%s'\n",
858  p->filename,
859  GNUNET_h2s (res));
861  {
862  p->data.file.file_id = *res;
863  p->data.file.have_hash = GNUNET_YES;
864  p->data.file.index_start_confirmed = GNUNET_YES;
866  publish_content (pc);
867  GNUNET_free (fn);
868  return;
869  }
870  pc->mq = GNUNET_CLIENT_connect (pc->h->cfg,
871  "fs",
872  handlers,
874  pc);
875  if (NULL == pc->mq)
876  {
878  _("Can not index file `%s': %s. Will try to insert instead.\n"),
879  p->filename,
880  _("could not connect to `fs' service"));
881  p->data.file.do_index = GNUNET_NO;
882  publish_content (pc);
883  GNUNET_free (fn);
884  return;
885  }
886  if (p->data.file.have_hash != GNUNET_YES)
887  {
888  p->data.file.file_id = *res;
889  p->data.file.have_hash = GNUNET_YES;
891  }
892  env = GNUNET_MQ_msg_extra (ism,
893  slen,
895  if (GNUNET_OK ==
897  &dev,
898  &ino))
899  {
900  ism->device = GNUNET_htonll (dev);
901  ism->inode = GNUNET_htonll (ino);
902  }
903  else
904  {
906  _("Failed to get file identifiers for `%s'\n"),
907  p->filename);
908  }
909  ism->file_id = *res;
910  GNUNET_memcpy (&ism[1],
911  fn,
912  slen);
913  GNUNET_free (fn);
914  GNUNET_MQ_send (pc->mq,
915  env);
916 }
917 
918 
924 static void
926 {
928 
929  p = pc->fi_pos;
930  /* upload of "p" complete, publish KBlocks! */
931  if (NULL != p->keywords)
932  {
933  pc->ksk_pc = GNUNET_FS_publish_ksk (pc->h,
934  p->keywords,
935  p->meta,
936  p->chk_uri,
937  &p->bo,
938  pc->options,
940  pc);
941  }
942  else
943  {
944  publish_kblocks_cont (pc, p->chk_uri, NULL);
945  }
946 }
947 
948 
955 static void
957  const struct ResponseLocSignatureMessage *sig)
958 {
959  struct GNUNET_FS_PublishContext *pc = cls;
961 
962  p = pc->fi_pos;
964  /* p->data.loc.fi kept from CHK before */
965  p->chk_uri->data.loc.peer = sig->peer;
971  publish_kblocks (pc);
972 }
973 
974 
983 static void
985  enum GNUNET_MQ_Error error)
986 {
987  struct GNUNET_FS_PublishContext *pc = cls;
988 
989  if (NULL != pc->mq)
990  {
991  GNUNET_MQ_destroy (pc->mq);
992  pc->mq = NULL;
993  }
995  _("Can not create LOC URI. Will continue with CHK instead.\n"));
996  publish_kblocks (pc);
997 }
998 
999 
1007 static void
1009 {
1010  struct GNUNET_MQ_MessageHandler handlers[] = {
1011  GNUNET_MQ_hd_fixed_size (signature_response,
1014  pc),
1016  };
1017  struct GNUNET_MQ_Envelope *env;
1018  struct RequestLocSignatureMessage *req;
1019  struct GNUNET_FS_FileInformation *p;
1020 
1021  if (NULL != pc->mq)
1022  GNUNET_MQ_destroy (pc->mq);
1023  pc->mq = GNUNET_CLIENT_connect (pc->h->cfg,
1024  "fs",
1025  handlers,
1027  pc);
1028  if (NULL == pc->mq)
1029  {
1031  _("Can not create LOC URI. Will continue with CHK instead.\n"));
1032  publish_kblocks (pc);
1033  return;
1034  }
1035  p = pc->fi_pos;
1036  env = GNUNET_MQ_msg (req,
1040  req->chk = p->chk_uri->data.chk.chk;
1042  GNUNET_MQ_send (pc->mq,
1043  env);
1044 }
1045 
1046 
1052 void
1054 {
1055  struct GNUNET_FS_PublishContext *pc = cls;
1056  struct GNUNET_FS_ProgressInfo pi;
1057  struct GNUNET_FS_FileInformation *p;
1058  char *fn;
1059 
1060  pc->upload_task = NULL;
1061  p = pc->fi_pos;
1062  if (NULL == p)
1063  {
1065  "Publishing complete, now publishing SKS and KSK blocks.\n");
1066  /* upload of entire hierarchy complete,
1067  * publish namespace entries */
1069  publish_sblock (pc);
1070  return;
1071  }
1072  /* find starting position */
1073  while ( (GNUNET_YES == p->is_directory) &&
1074  (NULL != p->data.dir.entries) &&
1075  (NULL == p->emsg) &&
1076  (NULL == p->data.dir.entries->chk_uri) )
1077  {
1078  p = p->data.dir.entries;
1079  pc->fi_pos = p;
1081  }
1082  /* abort on error */
1083  if (NULL != p->emsg)
1084  {
1086  "Error uploading: %s\n",
1087  p->emsg);
1088  /* error with current file, abort all
1089  * related files as well! */
1090  while (NULL != p->dir)
1091  {
1094  p = p->dir;
1095  if (fn != NULL)
1096  {
1097  GNUNET_asprintf (&p->emsg,
1098  _("Recursive upload failed at `%s': %s"),
1099  fn,
1100  p->emsg);
1101  GNUNET_free (fn);
1102  }
1103  else
1104  {
1105  GNUNET_asprintf (&p->emsg,
1106  _("Recursive upload failed: %s"),
1107  p->emsg);
1108  }
1111  pi.value.publish.specifics.error.message = p->emsg;
1112  p->client_info = GNUNET_FS_publish_make_status_ (&pi, pc, p, 0);
1113  }
1114  pc->all_done = GNUNET_YES;
1116  return;
1117  }
1118  /* handle completion */
1119  if (NULL != p->chk_uri)
1120  {
1122  "File upload complete, now publishing KSK blocks.\n");
1124 
1125  if ( (0 == p->bo.anonymity_level) &&
1126  (GNUNET_YES !=
1128  {
1129  /* zero anonymity, box CHK URI in LOC URI */
1130  create_loc_uri (pc);
1131  }
1132  else
1133  {
1134  publish_kblocks (pc);
1135  }
1136  return;
1137  }
1138  if ((GNUNET_YES != p->is_directory) && (p->data.file.do_index))
1139  {
1140  if (NULL == p->filename)
1141  {
1142  p->data.file.do_index = GNUNET_NO;
1144  _("Can not index file `%s': %s. Will try to insert instead.\n"),
1145  "<no-name>",
1146  _("needs to be an actual file"));
1148  publish_content (pc);
1149  return;
1150  }
1151  if (p->data.file.have_hash)
1152  {
1153  hash_for_index_cb (pc, &p->data.file.file_id);
1154  }
1155  else
1156  {
1158  pc->fhc =
1161  }
1162  return;
1163  }
1164  publish_content (pc);
1165 }
1166 
1167 
1182 static int
1183 fip_signal_start (void *cls,
1184  struct GNUNET_FS_FileInformation *fi,
1185  uint64_t length,
1187  struct GNUNET_FS_Uri **uri,
1188  struct GNUNET_FS_BlockOptions *bo,
1189  int *do_index,
1190  void **client_info)
1191 {
1192  struct GNUNET_FS_PublishContext *pc = cls;
1193  struct GNUNET_FS_ProgressInfo pi;
1194  unsigned int kc;
1195  uint64_t left;
1196 
1197  if (GNUNET_YES == pc->skip_next_fi_callback)
1198  {
1200  return GNUNET_OK;
1201  }
1203  "Starting publish operation\n");
1204  if (*do_index)
1205  {
1206  /* space for on-demand blocks */
1207  pc->reserve_space +=
1208  ((length + DBLOCK_SIZE -
1209  1) / DBLOCK_SIZE) * sizeof (struct OnDemandBlock);
1210  }
1211  else
1212  {
1213  /* space for DBlocks */
1214  pc->reserve_space += length;
1215  }
1216  /* entries for IBlocks and DBlocks, space for IBlocks */
1217  left = length;
1218  while (1)
1219  {
1220  left = (left + DBLOCK_SIZE - 1) / DBLOCK_SIZE;
1221  pc->reserve_entries += left;
1222  if (left <= 1)
1223  break;
1224  left = left * sizeof (struct ContentHashKey);
1225  pc->reserve_space += left;
1226  }
1227  pc->reserve_entries++;
1228  /* entries and space for keywords */
1229  if (NULL != *uri)
1230  {
1232  pc->reserve_entries += kc;
1234  }
1236  *client_info = GNUNET_FS_publish_make_status_ (&pi, pc, fi, 0);
1238  if ((fi->is_directory) && (fi->dir != NULL))
1239  {
1240  /* We are a directory, and we are not top-level; process entries in directory */
1243  }
1244  return GNUNET_OK;
1245 }
1246 
1247 
1255 static void
1257  struct GNUNET_FS_PublishContext *pc)
1258 {
1259  struct GNUNET_FS_ProgressInfo pi;
1260  uint64_t off;
1261 
1262  if (NULL != pc->ksk_pc)
1263  {
1265  pc->ksk_pc = NULL;
1266  }
1267  if (NULL != pc->sks_pc)
1268  {
1270  pc->sks_pc = NULL;
1271  }
1273  "Suspending publish operation\n");
1275  fi->serialization = NULL;
1276  off = (NULL == fi->chk_uri) ? 0 : (GNUNET_YES == fi->is_directory) ? fi->data.dir.dir_size : fi->data.file.file_size;
1278  GNUNET_break (NULL == GNUNET_FS_publish_make_status_ (&pi, pc, fi, off));
1279  if (NULL != pc->qre)
1280  {
1282  pc->qre = NULL;
1283  }
1284  if (NULL != pc->dsh)
1285  {
1287  pc->dsh = NULL;
1288  }
1289  pc->rid = 0;
1290 }
1291 
1292 
1307 static int
1309  struct GNUNET_FS_FileInformation *fi,
1310  uint64_t length,
1312  struct GNUNET_FS_Uri **uri,
1313  struct GNUNET_FS_BlockOptions *bo,
1314  int *do_index,
1315  void **client_info)
1316 {
1317  struct GNUNET_FS_PublishContext *pc = cls;
1318 
1319  if (GNUNET_YES == pc->skip_next_fi_callback)
1320  {
1322  return GNUNET_OK;
1323  }
1325  {
1326  /* process entries in directory */
1329  }
1330  suspend_operation (fi, pc);
1331  *client_info = NULL;
1332  return GNUNET_OK;
1333 }
1334 
1335 
1342 void
1344 {
1345  struct GNUNET_FS_PublishContext *pc = cls;
1346 
1347  if (NULL != pc->upload_task)
1348  {
1350  pc->upload_task = NULL;
1351  }
1354  suspend_operation (pc->fi, pc);
1355  GNUNET_FS_end_top (pc->h, pc->top);
1356  pc->top = NULL;
1357  publish_cleanup (pc);
1358 }
1359 
1360 
1370 static void
1371 finish_reserve (void *cls,
1372  int success,
1374  const char *msg)
1375 {
1376  struct GNUNET_FS_PublishContext *pc = cls;
1377 
1378  pc->qre = NULL;
1380  "Reservation complete (%d)!\n",
1381  success);
1382  if ((msg != NULL) || (success <= 0))
1383  {
1384  GNUNET_asprintf (&pc->fi->emsg,
1385  _("Datastore failure: %s"),
1386  msg);
1387  signal_publish_error (pc->fi, pc, pc->fi->emsg);
1388  return;
1389  }
1390  pc->rid = success;
1391  GNUNET_assert (NULL == pc->upload_task);
1392  pc->upload_task =
1395 }
1396 
1397 
1403 static uint64_t
1405 {
1406  struct GNUNET_FS_FileInformation *ent;
1407 
1408  if (GNUNET_YES != fi->is_directory)
1409  return fi->data.file.file_size;
1410  fi->data.dir.contents_size = 0;
1411  for (ent = fi->data.dir.entries; NULL != ent; ent = ent->next)
1413  return fi->data.dir.contents_size;
1414 }
1415 
1416 
1430 struct GNUNET_FS_PublishContext *
1432  struct GNUNET_FS_FileInformation *fi,
1433  const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns,
1434  const char *nid,
1435  const char *nuid,
1437 {
1438  struct GNUNET_FS_PublishContext *ret;
1439  struct GNUNET_DATASTORE_Handle *dsh;
1440 
1441  GNUNET_assert (NULL != h);
1442  compute_contents_size (fi);
1443  if (0 == (options & GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY))
1444  {
1445  dsh = GNUNET_DATASTORE_connect (h->cfg);
1446  if (NULL == dsh)
1447  return NULL;
1448  }
1449  else
1450  {
1451  dsh = NULL;
1452  }
1453  ret = GNUNET_new (struct GNUNET_FS_PublishContext);
1454  ret->dsh = dsh;
1455  ret->h = h;
1456  ret->fi = fi;
1457  if (NULL != ns)
1458  {
1460  *ret->ns = *ns;
1461  GNUNET_assert (NULL != nid);
1462  ret->nid = GNUNET_strdup (nid);
1463  if (NULL != nuid)
1464  ret->nuid = GNUNET_strdup (nuid);
1465  }
1466  ret->options = options;
1467  /* signal start */
1469  ret->fi_pos = ret->fi;
1472  if (NULL != ret->dsh)
1473  {
1474  GNUNET_assert (NULL == ret->qre);
1476  _("Reserving space for %u entries and %llu bytes for publication\n"),
1477  (unsigned int) ret->reserve_entries,
1478  (unsigned long long) ret->reserve_space);
1479  ret->qre =
1481  ret->reserve_entries,
1482  &finish_reserve,
1483  ret);
1484  }
1485  else
1486  {
1487  GNUNET_assert (NULL == ret->upload_task);
1488  ret->upload_task =
1491  }
1492  return ret;
1493 }
1494 
1495 
1510 static int
1511 fip_signal_stop (void *cls,
1512  struct GNUNET_FS_FileInformation *fi,
1513  uint64_t length,
1515  struct GNUNET_FS_Uri **uri,
1516  struct GNUNET_FS_BlockOptions *bo,
1517  int *do_index, void **client_info)
1518 {
1519  struct GNUNET_FS_PublishContext *pc = cls;
1520  struct GNUNET_FS_ProgressInfo pi;
1521  uint64_t off;
1522 
1523  if (GNUNET_YES == pc->skip_next_fi_callback)
1524  {
1526  return GNUNET_OK;
1527  }
1529  {
1530  /* process entries in directory first */
1533  }
1534  if (NULL != fi->serialization)
1535  {
1537  fi->serialization);
1538  GNUNET_free (fi->serialization);
1539  fi->serialization = NULL;
1540  }
1541  off = (fi->chk_uri == NULL) ? 0 : length;
1543  GNUNET_break (NULL == GNUNET_FS_publish_make_status_ (&pi, pc, fi, off));
1544  *client_info = NULL;
1545  return GNUNET_OK;
1546 }
1547 
1548 
1557 void
1559 {
1560  struct GNUNET_FS_ProgressInfo pi;
1561  uint64_t off;
1562 
1564  "Publish stop called\n");
1565  GNUNET_FS_end_top (pc->h, pc->top);
1566  if (NULL != pc->ksk_pc)
1567  {
1569  pc->ksk_pc = NULL;
1570  }
1571  if (NULL != pc->sks_pc)
1572  {
1574  pc->sks_pc = NULL;
1575  }
1576  if (NULL != pc->upload_task)
1577  {
1579  pc->upload_task = NULL;
1580  }
1583 
1584  if (NULL != pc->fi->serialization)
1585  {
1587  pc->fi->serialization);
1588  GNUNET_free (pc->fi->serialization);
1589  pc->fi->serialization = NULL;
1590  }
1591  off = (NULL == pc->fi->chk_uri) ? 0 : GNUNET_ntohll (pc->fi->chk_uri->data.chk.file_length);
1592 
1593  if (NULL != pc->serialization)
1594  {
1596  pc->serialization);
1597  GNUNET_free (pc->serialization);
1598  pc->serialization = NULL;
1599  }
1600  if (NULL != pc->qre)
1601  {
1603  pc->qre = NULL;
1604  }
1606  GNUNET_break (NULL == GNUNET_FS_publish_make_status_ (&pi, pc, pc->fi, off));
1607  publish_cleanup (pc);
1608 }
1609 
1610 
1611 /* end of fs_publish.c */
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...
struct GNUNET_FS_FileInformation * entries
Linked list of entries in the directory.
Definition: fs_api.h:371
unsigned int depth
Depth of the given block in the tree; 0 would be the lowest level (DBLOCKs).
static struct GNUNET_TIME_Absolute min_expiration
Minimum time that content should have to not be discarded instantly (time stamp of any content that w...
char * nid
ID of the content in the namespace, NULL if we have no namespace.
Definition: fs_api.h:1223
int GNUNET_FS_directory_builder_finish(struct GNUNET_FS_DirectoryBuilder *bld, size_t *rsize, void **rdata)
Finish building the directory.
Definition: fs_directory.c:574
static void publish_kblocks_cont(void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
We&#39;ve finished publishing a KBlock as part of a larger upload.
Definition: fs_publish.c:312
struct GNUNET_SCHEDULER_Task * upload_task
ID of the task performing the upload.
Definition: fs_api.h:1278
struct ContentHashKey chk
Query and key of the top GNUNET_EC_IBlock.
Definition: fs_api.h:104
struct GNUNET_FS_FileInformation * dir
If this is a file in a directory, "dir" refers to the directory; otherwise NULL.
Definition: fs_api.h:243
void GNUNET_FS_publish_stop(struct GNUNET_FS_PublishContext *pc)
Stop an upload.
Definition: fs_publish.c:1558
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:670
int rid
Space reservation ID with datastore service for this upload.
Definition: fs_api.h:1300
#define GNUNET_TIME_UNIT_ZERO_ABS
Absolute time zero.
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:1296
struct FileIdentifier chk
Information needed to retrieve a file (content-hash-key plus file size).
Definition: fs_api.h:215
struct GNUNET_CONTAINER_MetaData * meta
Metadata to use for the file.
Definition: fs_api.h:258
struct GNUNET_FS_FileInformation::@19::@20 file
Data for a file.
Notification that we are making progress sharing a file structure.
struct GNUNET_FS_PublishContext * GNUNET_FS_publish_start(struct GNUNET_FS_Handle *h, struct GNUNET_FS_FileInformation *fi, const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns, const char *nid, const char *nuid, enum GNUNET_FS_PublishOptions options)
Publish a file or directory.
Definition: fs_publish.c:1431
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
struct GNUNET_MQ_Handle * GNUNET_CLIENT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *service_name, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *error_handler_cls)
Create a message queue to connect to a GNUnet service.
Definition: client.c:901
static void finish_release_reserve(void *cls, int success, struct GNUNET_TIME_Absolute min_expiration, const char *msg)
Datastore returns from reservation cancel request.
Definition: fs_publish.c:222
GNUNET_BLOCK_Type
Blocks in the datastore and the datacache must have a unique type.
content hash key
Definition: fs.h:53
void * client_info
Pointer kept for the client.
Definition: fs_api.h:253
uint32_t purpose
Requested signature purpose.
Definition: fs.h:86
char * emsg
Error message (non-NULL if this operation failed).
Definition: fs_api.h:302
GNUNET_MQ_Error
Error codes for the queue.
char * serialization
Under what filename is this struct serialized (for operational persistence).
Definition: fs_api.h:292
static void publish_content(struct GNUNET_FS_PublishContext *pc)
We are uploading a file or directory; load (if necessary) the next block into memory, encrypt it and send it to the FS service.
Definition: fs_publish.c:610
static void signal_publish_completion(struct GNUNET_FS_FileInformation *p, struct GNUNET_FS_PublishContext *pc)
Generate the callback that signals clients that a file (or directory) has been completely published...
Definition: fs_publish.c:163
Master context for most FS operations.
Definition: fs_api.h:1087
#define GNUNET_MESSAGE_TYPE_FS_INDEX_START_FAILED
Response to a request for start indexing that refuses.
static void ds_put_cont(void *cls, int success, struct GNUNET_TIME_Absolute min_expiration, const char *msg)
Function called by the datastore API with the result from the PUT request.
Definition: fs_publish.c:115
#define gettext(Msgid)
Definition: gettext.h:45
struct GNUNET_DATASTORE_QueueEntry * GNUNET_DATASTORE_put(struct GNUNET_DATASTORE_Handle *h, uint32_t rid, const struct GNUNET_HashCode *key, size_t size, const void *data, enum GNUNET_BLOCK_Type type, uint32_t priority, uint32_t anonymity, uint32_t replication, struct GNUNET_TIME_Absolute expiration, unsigned int queue_priority, unsigned int max_queue_size, GNUNET_DATASTORE_ContinuationWithStatus cont, void *cont_cls)
Store an item in the datastore.
void GNUNET_FS_publish_ksk_cancel(struct GNUNET_FS_PublishKskContext *pkc)
Abort the KSK publishing operation.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_FS_PublishSksContext * GNUNET_FS_publish_sks(struct GNUNET_FS_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns, const char *identifier, const char *update, const struct GNUNET_CONTAINER_MetaData *meta, const struct GNUNET_FS_Uri *uri, const struct GNUNET_FS_BlockOptions *bo, enum GNUNET_FS_PublishOptions options, GNUNET_FS_PublishContinuation cont, void *cont_cls)
Publish an SBlock on GNUnet.
Definition: fs_namespace.c:440
struct GNUNET_DATASTORE_QueueEntry * GNUNET_DATASTORE_reserve(struct GNUNET_DATASTORE_Handle *h, uint64_t amount, uint32_t entries, GNUNET_DATASTORE_ContinuationWithStatus cont, void *cont_cls)
Reserve space in the datastore.
struct GNUNET_TIME_Absolute start_time
At what time did we start this upload?
Definition: fs_api.h:285
uint64_t reserve_space
Storage space to reserve for the operation.
Definition: fs_api.h:1283
char * filename
Name of the file or directory (must be an absolute path).
Definition: fs_api.h:307
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
void GNUNET_FS_tree_encoder_next(struct GNUNET_FS_TreeEncoder *te)
Encrypt the next block of the file (and call proc and progress accordingly; or of course "cont" if we...
Definition: fs_tree.c:332
static void handle_index_start_ok(void *cls, const struct GNUNET_MessageHeader *msg)
Process the response from the "fs" service to our &#39;start index&#39; request.
Definition: fs_publish.c:745
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
uint64_t file_length
Size of the shared file (to be signed).
Definition: fs.h:101
Internal state of a directory builder.
Definition: fs_directory.c:337
enum GNUNET_FS_PublishOptions options
Options for publishing.
Definition: fs_api.h:1294
#define GNUNET_NO
Definition: gnunet_common.h:81
struct GNUNET_CRYPTO_FileHashContext * fhc
Non-null if we are currently hashing a file.
Definition: fs_api.h:1250
struct GNUNET_DATASTORE_Handle * dsh
Connection to the datastore service.
Definition: fs_api.h:1255
struct GNUNET_FS_Handle * h
Handle to the global fs context.
Definition: fs_api.h:1203
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
int GNUNET_DISK_file_get_identifiers(const char *filename, uint64_t *dev, uint64_t *ino)
Obtain some unique identifiers for the given file that can be used to identify it in the local system...
Definition: disk.c:323
#define GNUNET_new(type)
Allocate a struct or union of the given type.
char * serialization
Filename used for serializing information about this operation (should be determined using &#39;mktemp&#39;)...
Definition: fs_api.h:1234
Private ECC key encoded for transmission.
struct GNUNET_PeerIdentity peer
Identity of the peer sharing the file.
Definition: fs_api.h:123
uint64_t offset
At what offset in the file is "data"?
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:464
struct GNUNET_DATASTORE_QueueEntry * GNUNET_DATASTORE_release_reserve(struct GNUNET_DATASTORE_Handle *h, uint32_t rid, unsigned int queue_priority, unsigned int max_queue_size, GNUNET_DATASTORE_ContinuationWithStatus cont, void *cont_cls)
Signal that all of the data for which a reservation was made has been stored and that whatever excess...
Information for a file or directory that is about to be published.
Definition: fs_api.h:231
char * GNUNET_CONTAINER_meta_data_get_by_type(const struct GNUNET_CONTAINER_MetaData *md, enum EXTRACTOR_MetaType type)
Get the first MD entry of the given type.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
Run as background job (higher than idle, lower than default).
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.
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
static int ret
Final status code.
Definition: gnunet-arm.c:89
#define GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGNATURE
Reply sent by fs service with LOC signature.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
void * dir_data
Pointer to the data for the directory (or NULL if not available).
Definition: fs_api.h:383
struct GNUNET_FS_Uri * GNUNET_FS_tree_encoder_get_uri(struct GNUNET_FS_TreeEncoder *te)
Get the resulting URI from the encoding.
Definition: fs_tree.c:425
Message sent from a GNUnet (fs) publishing activity to the gnunet-fs-service to initiate indexing of ...
Definition: fs.h:153
static void hash_for_index_cb(void *cls, const struct GNUNET_HashCode *res)
Function called once the hash computation over an indexed file has completed.
Definition: fs_publish.c:799
static void signal_publish_error(struct GNUNET_FS_FileInformation *p, struct GNUNET_FS_PublishContext *pc, const char *emsg)
Generate the callback that signals clients that a file (or directory) has encountered a problem durin...
Definition: fs_publish.c:188
const struct GNUNET_FS_FileInformation * fi
Information about the file that is being publishd.
struct GNUNET_FS_Uri * GNUNET_FS_uri_dup(const struct GNUNET_FS_Uri *uri)
Duplicate URI.
Definition: fs_uri.c:988
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Type of a block representing a block to be encoded on demand from disk.
static uint64_t compute_contents_size(struct GNUNET_FS_FileInformation *fi)
Calculate the total size of all of the files in the directory structure.
Definition: fs_publish.c:1404
static void handle_signature_response(void *cls, const struct ResponseLocSignatureMessage *sig)
Process the response from the "fs" service to our LOC sign request.
Definition: fs_publish.c:956
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
static void finish_reserve(void *cls, int success, struct GNUNET_TIME_Absolute min_expiration, const char *msg)
We have gotten a reply for our space reservation request.
Definition: fs_publish.c:1371
#define GNUNET_MESSAGE_TYPE_FS_INDEX_START_OK
Affirmative response to a request for start indexing.
void GNUNET_FS_publish_main_(void *cls)
Main function that performs the upload.
Definition: fs_publish.c:1053
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
Notification that we have stopped the process of uploading a file structure; no futher events will be...
int GNUNET_FS_uri_test_loc(const struct GNUNET_FS_Uri *uri)
Is this a location URI?
Definition: fs_uri.c:1381
#define MAX_INLINE_SIZE
Maximum size for a file to be considered for inlining in a directory.
Definition: fs_api.h:49
static void publish_kblocks(struct GNUNET_FS_PublishContext *pc)
We&#39;ve computed the CHK/LOC URI, now publish the KSKs (if applicable).
Definition: fs_publish.c:925
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 int fip_signal_stop(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&#39;s progress function that we are stopping an upload.
Definition: fs_publish.c:1511
uint32_t anonymity_level
At which anonymity level should the block be shared? (0: no anonymity, 1: normal GAP, >1: with cover traffic).
struct GNUNET_FS_PublishKskContext * GNUNET_FS_publish_ksk(struct GNUNET_FS_Handle *h, const struct GNUNET_FS_Uri *ksk_uri, const struct GNUNET_CONTAINER_MetaData *meta, const struct GNUNET_FS_Uri *uri, const struct GNUNET_FS_BlockOptions *bo, enum GNUNET_FS_PublishOptions options, GNUNET_FS_PublishContinuation cont, void *cont_cls)
Publish a CHK under various keywords on GNUnet.
unsigned int GNUNET_FS_compute_depth(uint64_t flen)
Compute the depth of the CHK tree.
Definition: fs_tree.c:126
static void publish_sblock(struct GNUNET_FS_PublishContext *pc)
We are almost done publishing the structure, add SBlocks (if needed).
Definition: fs_publish.c:285
Notification that we have started to publish a file structure.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
Meta data to associate with a file, directory or namespace.
#define GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT
Signature by which a peer affirms that it is providing a certain bit of content (used in LOCation URI...
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct...
Definition: gnunet_mq_lib.h:52
void GNUNET_FS_directory_builder_add(struct GNUNET_FS_DirectoryBuilder *bld, const struct GNUNET_FS_Uri *uri, const struct GNUNET_CONTAINER_MetaData *md, const void *data)
Add an entry to a directory.
Definition: fs_directory.c:388
struct GNUNET_FS_TreeEncoder * te
Encoder being used to publish this file.
Definition: fs_api.h:297
union GNUNET_FS_ProgressInfo::@28 value
Values that depend on the event type.
static void create_loc_uri(struct GNUNET_FS_PublishContext *pc)
We&#39;re publishing without anonymity.
Definition: fs_publish.c:1008
void GNUNET_FS_publish_sync_(struct GNUNET_FS_PublishContext *pc)
Synchronize this publishing struct with its mirror on disk.
Definition: fs_api.c:1685
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:1200
#define GNUNET_memcpy(dst, src, n)
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
static void progress_proc(void *cls, uint64_t offset, const void *pt_block, size_t pt_size, unsigned int depth)
Function called with information about our progress in computing the tree encoding.
Definition: fs_publish.c:565
Notification that we are making progress sharing a directory.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
static char * fn
Filename of the unique file.
struct GNUNET_FS_UnindexContext * GNUNET_FS_unindex_start(struct GNUNET_FS_Handle *h, const char *filename, void *cctx)
Unindex a file.
Definition: fs_unindex.c:791
void GNUNET_FS_end_top(struct GNUNET_FS_Handle *h, struct TopLevelActivity *top)
Destroy a top-level activity entry.
Definition: fs_api.c:416
uint64_t device
ID of device containing the file, as seen by the client.
Definition: fs.h:173
char * nuid
ID for future updates, NULL if we have no namespace or no updates.
Definition: fs_api.h:1228
enum GNUNET_FS_Status status
Specific status code (determines the event type).
int is_directory
Is this struct for a file or directory?
Definition: fs_api.h:402
struct GNUNET_HashCode query
Hash of the encrypted content, used for querying.
Definition: fs.h:63
union GNUNET_FS_Uri::@16 data
void GNUNET_FS_publish_sks_cancel(struct GNUNET_FS_PublishSksContext *psc)
Abort the SKS publishing operation.
Definition: fs_namespace.c:503
#define GNUNET_MIN(a, b)
Definition: gnunet_common.h:83
struct GNUNET_FS_ProgressInfo::@28::@29 publish
Values for all "GNUNET_FS_STATUS_PUBLISH_*" events.
struct GNUNET_TIME_AbsoluteNBO expiration_time
Expiration time that was actually used (rounded!).
Definition: fs.h:126
static char buf[2048]
static void handle_index_start_failed(void *cls, const struct GNUNET_MessageHeader *msg)
Process the response from the "fs" service to our &#39;start index&#39; request.
Definition: fs_publish.c:713
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
struct GNUNET_FS_FileInformation * fi_pos
Current position in the file-tree for the upload.
Definition: fs_api.h:1245
GNUNET_FS_PublishOptions
Options for publishing.
static int check_index_start_failed(void *cls, const struct GNUNET_MessageHeader *msg)
Check the response from the "fs" service to our &#39;start index&#39; request.
Definition: fs_publish.c:690
struct GNUNET_FS_Uri * chk_uri
CHK for this file or directory.
Definition: fs_api.h:269
struct GNUNET_FS_TreeEncoder * GNUNET_FS_tree_encoder_create(struct GNUNET_FS_Handle *h, uint64_t size, void *cls, GNUNET_FS_DataReader reader, GNUNET_FS_TreeBlockProcessor proc, GNUNET_FS_TreeProgressCallback progress, GNUNET_SCHEDULER_TaskCallback cont)
Initialize a tree encoder.
Definition: fs_tree.c:270
void GNUNET_CRYPTO_hash_file_cancel(struct GNUNET_CRYPTO_FileHashContext *fhc)
Cancel a file hashing operation.
static void publish_cleanup(struct GNUNET_FS_PublishContext *pc)
Cleanup the publish context, we&#39;re done with it.
Definition: fs_publish.c:77
struct GNUNET_FS_PublishKskContext * ksk_pc
Context for KSK publishing operation that is part of this publishing operation (NULL if not active)...
Definition: fs_api.h:1272
Handle for controlling a publication process.
Definition: fs_api.h:1198
A 512-bit hashcode.
Message handler for a specific message type.
static int res
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
Run when otherwise idle.
#define DBLOCK_SIZE
Size of the individual blocks used for file-sharing.
Definition: fs.h:40
uint64_t contents_size
Sum of all of the sizes of all of the files in the directory.
Definition: fs_api.h:393
static size_t block_reader(void *cls, uint64_t offset, size_t max, void *buf, char **emsg)
Function called by the tree encoder to obtain a block of plaintext data (for the lowest level of the ...
Definition: fs_publish.c:367
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:35
static void suspend_operation(struct GNUNET_FS_FileInformation *fi, struct GNUNET_FS_PublishContext *pc)
Actually signal the FS&#39;s progress function that we are suspending an upload.
Definition: fs_publish.c:1256
#define GNUNET_MESSAGE_TYPE_FS_INDEX_START
Message sent by fs client to start indexing.
uint32_t reserve_entries
Overall number of entries to reserve for the publish operation.
Definition: fs_api.h:1289
#define GNUNET_FS_SYNC_PATH_FILE_INFO
Name of the directory with files that are being published.
Definition: fs_api.h:81
struct GNUNET_DATASTORE_QueueEntry * qre
Queue entry for reservation/unreservation.
Definition: fs_api.h:1260
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
static unsigned int size
Size of the "table".
Definition: peer.c:67
struct GNUNET_PeerIdentity peer
Identity of the peer sharing the file.
Definition: fs.h:136
struct GNUNET_HashCode file_id
Hash of the file that we would like to index.
Definition: fs.h:186
int all_done
Set to GNUNET_YES if all processing has completed.
Definition: fs_api.h:1311
char * GNUNET_STRINGS_filename_expand(const char *fil)
Complete filename (a la shell) from abbrevition.
Definition: strings.c:602
Settings for publishing a block (which may of course also apply to an entire directory or file)...
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
struct GNUNET_HashCode file_id
Hash code of the entire content of the file that was indexed (used to uniquely identify the plaintext...
Definition: block_fs.h:91
Notification that we completed sharing a file structure.
struct GNUNET_FS_PublishSksContext * sks_pc
Context for SKS publishing operation that is part of this publishing operation (NULL if not active)...
Definition: fs_api.h:1266
struct GNUNET_TIME_Absolute expirationTime
Time when this location URI expires.
Definition: fs_api.h:128
static struct GNUNET_NAMESTORE_Handle * ns
Handle to the namestore.
enum GNUNET_FS_UriType type
Type of the URI.
Definition: fs_api.h:173
struct GNUNET_FS_FileInformation * next
Files in a directory are kept as a linked list.
Definition: fs_api.h:237
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
struct GNUNET_MQ_Handle * mq
Our own message queue for the FS service; only briefly used when we start to index a file...
Definition: fs_api.h:1240
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
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message...
struct ContentHashKey chk
Information about the shared file (to be signed).
Definition: fs.h:96
static int fip_signal_start(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&#39;s progress function that we are starting an upload.
Definition: fs_publish.c:1183
struct GNUNET_FS_BlockOptions bo
Block options for the file.
Definition: fs_api.h:280
struct GNUNET_FS_Handle * fsh
File-sharing handle that generated the event.
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:393
Message sent from the service with the signed LOC URI.
Definition: fs.h:108
int do_index
Should the file be indexed or inserted?
Definition: fs_api.h:346
uint64_t inode
Inode of the file on the given device, as seen by the client ("st_ino" field from "struct stat")...
Definition: fs.h:181
struct TopLevelActivity * top
Our top-level activity entry (if we are top-level, otherwise NULL).
Definition: fs_api.h:1208
void GNUNET_DATASTORE_cancel(struct GNUNET_DATASTORE_QueueEntry *qe)
Cancel a datastore operation.
static struct GNUNET_FS_PublishContext * pc
Handle to FS-publishing operation.
struct GNUNET_FS_FileInformation * fi
File-structure that is being shared.
Definition: fs_api.h:1213
union GNUNET_FS_FileInformation::@19 data
Data describing either the file or the directory.
Notification that an error was encountered sharing a file structure.
GNUNET_FS_ProgressCallback upcb
Function to call with updates on our progress.
Definition: fs_api.h:1102
Notification that we have suspended sharing a file structure.
Message sent from a GNUnet (fs) publishing activity to sign a LOC URI.
Definition: fs.h:74
static struct GNUNET_FS_DirectoryBuilder * db
Definition: gnunet-search.c:41
#define HASHING_BLOCKSIZE
Blocksize to use when hashing files for indexing (blocksize for IO, not for the DBlocks).
Definition: fs.h:47
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:1359
shared definitions for the FS library
void GNUNET_DATASTORE_disconnect(struct GNUNET_DATASTORE_Handle *h, int drop)
Disconnect from the datastore service (and free associated resources).
struct GNUNET_CRYPTO_EcdsaPrivateKey * ns
Namespace that we are publishing in, NULL if we have no namespace.
Definition: fs_api.h:1218
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.
A Universal Resource Identifier (URI), opaque.
Definition: fs_api.h:168
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:373
Handle to the datastore service.
uint64_t file_length
Total size of the file in bytes.
Definition: fs_api.h:99
static struct GNUNET_CONTAINER_MetaData * meta
Meta-data provided via command-line option.
static struct GNUNET_DATASTORE_Handle * dsh
Datastore handle.
struct GNUNET_CRYPTO_EddsaSignature signature
The requested signature.
Definition: fs.h:131
void * upcb_cls
Closure for upcb.
Definition: fs_api.h:1107
struct GNUNET_CRYPTO_EddsaSignature contentSignature
Signature over the GNUNET_EC_FileIdentifier, peer identity and expiration time.
Definition: fs_api.h:134
struct GNUNET_FS_Uri * keywords
Keywords to use for KBlocks.
Definition: fs_api.h:263
#define GNUNET_log(kind,...)
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:1343
uint64_t offset
At which offset should we be able to find this on-demand encoded block? (in NBO)
Definition: block_fs.h:97
void GNUNET_FS_file_information_destroy(struct GNUNET_FS_FileInformation *fi, GNUNET_FS_FileInformationProcessor cleaner, void *cleaner_cls)
Destroy publish-structure.
static void loc_mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
Generic error handler, called with the appropriate error code and the same closure specified at the c...
Definition: fs_publish.c:984
#define GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGN
Message sent by fs client to request LOC signature.
Data block (leaf) in the CHK tree.
unsigned int GNUNET_FS_uri_ksk_get_keyword_count(const struct GNUNET_FS_Uri *uri)
How many keywords are ANDed in this keyword URI?
Definition: fs_uri.c:701
#define GNUNET_FS_SYNC_PATH_MASTER_PUBLISH
Name of the directory with publishing operations.
Definition: fs_api.h:76
Location (chk with identity of hosting peer).
Definition: fs_api.h:161
struct GNUNET_TIME_AbsoluteNBO expiration_time
Requested expiration time.
Definition: fs.h:91
struct GNUNET_TIME_Relative GNUNET_TIME_calculate_eta(struct GNUNET_TIME_Absolute start, uint64_t finished, uint64_t total)
Calculate the estimate time of arrival/completion for an operation.
Definition: time.c:549
struct Location loc
Information needed to retrieve a file including signed location (identity of a peer) of the content...
Definition: fs_api.h:221
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
Header for all communications.
void GNUNET_FS_tree_encoder_finish(struct GNUNET_FS_TreeEncoder *te, char **emsg)
Clean up a tree encoder and return information about possible errors.
Definition: fs_tree.c:444
Time for absolute times used by GNUnet, in microseconds.
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:824
#define GNUNET_YES
Definition: gnunet_common.h:80
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
static void block_proc(void *cls, const struct ContentHashKey *chk, uint64_t offset, unsigned int depth, enum GNUNET_BLOCK_Type type, const void *block, uint16_t block_size)
Function called asking for the current (encoded) block to be processed.
Definition: fs_publish.c:481
struct GNUNET_DATASTORE_Handle * GNUNET_DATASTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the datastore service.
struct GNUNET_FS_DirectoryBuilder * GNUNET_FS_directory_builder_create(const struct GNUNET_CONTAINER_MetaData *mdir)
Create a directory builder.
Definition: fs_directory.c:362
static int fip_signal_suspend(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&#39;s progress function that we are suspending an upload.
Definition: fs_publish.c:1308
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:654
int any_done
Set to GNUNET_YES if we were able to publish any block.
Definition: fs_api.h:1306
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:1318
static void encode_cont(void *cls)
The tree encoder has finished processing a file.
Definition: fs_publish.c:417
size_t dir_size
Size of the directory itself (in bytes); 0 if the size has not yet been calculated.
Definition: fs_api.h:377
struct GNUNET_FS_Uri * sks_uri
SKS URI for this file or directory.
Definition: fs_api.h:275
static void publish_sblocks_cont(void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
We&#39;ve finished publishing the SBlock as part of a larger upload.
Definition: fs_publish.c:246
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#define GNUNET_malloc(size)
Wrapper around malloc.
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:738
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:48
index block (indexing a DBlock that can be obtained directly from reading the plaintext file) ...
Definition: block_fs.h:84
static void index_mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
Generic error handler, called with the appropriate error code and the same closure specified at the c...
Definition: fs_publish.c:769
static struct GNUNET_FS_BlockOptions bo
Options we set for published blocks.
#define GNUNET_free(ptr)
Wrapper around free.
Argument given to the progress callback with information about what is going on.
Merkle-tree-ish-CHK file encoding for GNUnet.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration to use.
Definition: fs_api.h:1092