GNUnet  0.10.x
gnunet-publish.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2001-2013 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 */
28 #include "platform.h"
29 #include "gnunet_fs_service.h"
31 
35 static int ret;
36 
40 static unsigned int verbose;
41 
45 static const struct GNUNET_CONFIGURATION_Handle *cfg;
46 
50 static struct GNUNET_FS_Handle *ctx;
51 
56 
61 
65 static struct GNUNET_FS_Uri *topKeywords;
66 
70 static struct GNUNET_FS_BlockOptions bo = { {0LL}, 1, 365, 1 };
71 
76 static char *uri_string;
77 
83 static struct GNUNET_FS_Uri *uri;
84 
89 static char *next_id;
90 
95 static char *this_id;
96 
100 static char *pseudonym;
101 
105 static int do_insert;
106 
110 static int disable_extractor;
111 
115 static int do_simulate;
116 
120 static int extract_only;
121 
126 
130 static struct GNUNET_FS_DirScanner *ds;
131 
136 static struct GNUNET_IDENTITY_Ego *namespace;
137 
142 
143 
150 static void
151 do_stop_task (void *cls)
152 {
153  struct GNUNET_FS_PublishContext *p;
154 
155  if (NULL != ds)
156  {
158  ds = NULL;
159  }
160  if (NULL != identity)
161  {
162  GNUNET_IDENTITY_disconnect (identity);
163  identity = NULL;
164  }
165  if (NULL != pc)
166  {
167  p = pc;
168  pc = NULL;
170  }
171  if (NULL != ctx)
172  {
173  GNUNET_FS_stop (ctx);
174  ctx = NULL;
175  }
176  if (NULL != meta)
177  {
179  meta = NULL;
180  }
181  if (NULL != uri)
182  {
183  GNUNET_FS_uri_destroy (uri);
184  uri = NULL;
185  }
186 }
187 
188 
202 static void *
203 progress_cb (void *cls,
204  const struct GNUNET_FS_ProgressInfo *info)
205 {
206  const char *s;
207  char *suri;
208 
209  switch (info->status)
210  {
212  break;
214  if (verbose)
215  {
217  GNUNET_YES);
218  FPRINTF (stdout,
219  _("Publishing `%s' at %llu/%llu (%s remaining)\n"),
220  info->value.publish.filename,
221  (unsigned long long) info->value.publish.completed,
222  (unsigned long long) info->value.publish.size, s);
223  }
224  break;
226  if (verbose)
227  {
228  s = GNUNET_STRINGS_relative_time_to_string (info->value.publish.specifics.progress_directory.eta,
229  GNUNET_YES);
230  FPRINTF (stdout,
231  _("Publishing `%s' at %llu/%llu (%s remaining)\n"),
232  info->value.publish.filename,
233  (unsigned long long) info->value.publish.specifics.progress_directory.completed,
234  (unsigned long long) info->value.publish.specifics.progress_directory.total, s);
235  }
236  break;
238  FPRINTF (stderr,
239  _("Error publishing: %s.\n"),
240  info->value.publish.specifics.error.message);
241  ret = 1;
243  break;
245  FPRINTF (stdout,
246  _("Publishing `%s' done.\n"),
247  info->value.publish.filename);
248  suri = GNUNET_FS_uri_to_string (info->value.publish.specifics.
249  completed.chk_uri);
250  FPRINTF (stdout,
251  _("URI is `%s'.\n"),
252  suri);
253  GNUNET_free (suri);
254  if (NULL != info->value.publish.specifics.completed.sks_uri)
255  {
256  suri = GNUNET_FS_uri_to_string (info->value.publish.specifics.
257  completed.sks_uri);
258  FPRINTF (stdout,
259  _("Namespace URI is `%s'.\n"),
260  suri);
261  GNUNET_free (suri);
262  }
263  if (NULL == info->value.publish.pctx)
264  {
265  ret = 0;
267  }
268  break;
270  GNUNET_break (NULL == pc);
271  return NULL;
273  FPRINTF (stderr,
274  "%s",
275  _("Starting cleanup after abort\n"));
276  return NULL;
278  return NULL;
280  FPRINTF (stderr,
281  "%s",
282  _("Cleanup after abort completed.\n"));
284  return NULL;
286  FPRINTF (stderr,
287  "%s",
288  _("Cleanup after abort failed.\n"));
290  return NULL;
292  return NULL;
293  default:
294  FPRINTF (stderr,
295  _("Unexpected status: %d\n"),
296  info->status);
297  return NULL;
298  }
299  return ""; /* non-null */
300 }
301 
302 
316 static int
317 meta_printer (void *cls,
318  const char *plugin_name,
320  enum EXTRACTOR_MetaFormat format,
321  const char *data_mime_type,
322  const char *data, size_t data_size)
323 {
324  if ((EXTRACTOR_METAFORMAT_UTF8 != format) &&
325  (EXTRACTOR_METAFORMAT_C_STRING != format))
326  return 0;
328  return 0;
329 #if HAVE_LIBEXTRACTOR
330  FPRINTF (stdout,
331  "\t%s - %s\n",
332  EXTRACTOR_metatype_to_string (type),
333  data);
334 #else
335  FPRINTF (stdout,
336  "\t%d - %s\n",
337  type,
338  data);
339 #endif
340  return 0;
341 }
342 
343 
352 static int
353 keyword_printer (void *cls,
354  const char *keyword,
355  int is_mandatory)
356 {
357  FPRINTF (stdout, "\t%s\n", keyword);
358  return GNUNET_OK;
359 }
360 
361 
379 static int
380 publish_inspector (void *cls,
382  uint64_t length,
384  struct GNUNET_FS_Uri **uri,
385  struct GNUNET_FS_BlockOptions *bo,
386  int *do_index,
387  void **client_info)
388 {
389  char *fn;
390  char *fs;
391  struct GNUNET_FS_Uri *new_uri;
392 
393  if (cls == fi)
394  return GNUNET_OK;
395  if ( (disable_extractor) &&
396  (NULL != *uri) )
397  {
398  GNUNET_FS_uri_destroy (*uri);
399  *uri = NULL;
400  }
401  if (NULL != topKeywords)
402  {
403  if (NULL != *uri)
404  {
405  new_uri = GNUNET_FS_uri_ksk_merge (topKeywords, *uri);
406  GNUNET_FS_uri_destroy (*uri);
407  *uri = new_uri;
408  GNUNET_FS_uri_destroy (topKeywords);
409  }
410  else
411  {
412  *uri = topKeywords;
413  }
414  topKeywords = NULL;
415  }
416  if (NULL != meta)
417  {
420  meta = NULL;
421  }
424  if (extract_only)
425  {
428  fs = GNUNET_STRINGS_byte_size_fancy (length);
429  FPRINTF (stdout,
430  _("Meta data for file `%s' (%s)\n"),
431  fn,
432  fs);
434  FPRINTF (stdout,
435  _("Keywords for file `%s' (%s)\n"),
436  fn,
437  fs);
438  GNUNET_free (fn);
439  GNUNET_free (fs);
440  if (NULL != *uri)
442  FPRINTF (stdout,
443  "%s",
444  "\n");
445  }
448  &publish_inspector, fi);
449  return GNUNET_OK;
450 }
451 
452 
462 static void
464  const struct GNUNET_FS_Uri *sks_uri,
465  const char *emsg)
466 {
467  if (NULL != emsg)
468  {
469  FPRINTF (stderr,
470  "%s\n",
471  emsg);
472  ret = 1;
473  }
475 }
476 
477 
487 static void
489  const struct GNUNET_FS_Uri *ksk_uri,
490  const char *emsg)
491 {
492  const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv;
493 
494  if (NULL != emsg)
495  {
496  FPRINTF (stderr,
497  "%s\n",
498  emsg);
499  ret = 1;
500  }
501  if (NULL == namespace)
502  {
504  return;
505  }
506  priv = GNUNET_IDENTITY_ego_get_private_key (namespace);
508  priv,
509  this_id,
510  next_id,
511  meta,
512  uri,
513  &bo,
516  NULL);
517 }
518 
519 
527 static struct GNUNET_FS_FileInformation *
529 {
530  struct GNUNET_FS_FileInformation *fi;
531  struct GNUNET_FS_FileInformation *fic;
533 
534  if (GNUNET_YES == item->is_directory)
535  {
536  if (NULL == item->meta)
540  NULL, 0);
542  if (NULL == item->ksk_uri)
543  {
544  const char *mime = GNUNET_FS_DIRECTORY_MIME;
545  item->ksk_uri = GNUNET_FS_uri_ksk_create_from_args (1, &mime);
546  }
547  else
549  GNUNET_NO);
551  item->ksk_uri,
552  item->meta,
553  &bo, item->filename);
554  for (child = item->children_head; child; child = child->next)
555  {
556  fic = get_file_information (child);
558  }
559  }
560  else
561  {
563  item->filename,
564  item->ksk_uri, item->meta,
565  !do_insert,
566  &bo);
567  }
568  return fi;
569 }
570 
571 
578 static void
579 directory_trim_complete (struct GNUNET_FS_ShareTreeItem *directory_scan_result)
580 {
581  struct GNUNET_FS_FileInformation *fi;
582  const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv;
583 
584  fi = get_file_information (directory_scan_result);
585  GNUNET_FS_share_tree_free (directory_scan_result);
586  if (NULL == fi)
587  {
588  FPRINTF (stderr,
589  "%s",
590  _("Could not publish\n"));
591  ret = 1;
593  return;
594  }
596  if (extract_only)
597  {
598  GNUNET_FS_file_information_destroy (fi, NULL, NULL);
600  return;
601  }
602  if (NULL == namespace)
603  priv = NULL;
604  else
605  priv = GNUNET_IDENTITY_ego_get_private_key (namespace);
606  pc = GNUNET_FS_publish_start (ctx, fi,
607  priv, this_id, next_id,
608  (do_simulate) ?
611  if (NULL == pc)
612  {
613  FPRINTF (stderr,
614  "%s",
615  _("Could not start publishing.\n"));
616  ret = 1;
618  return;
619  }
620 }
621 
622 
634 static void
635 directory_scan_cb (void *cls,
636  const char *filename,
637  int is_directory,
639 {
640  struct GNUNET_FS_ShareTreeItem *directory_scan_result;
641 
642  switch (reason)
643  {
645  if (verbose > 1)
646  {
647  if (is_directory == GNUNET_YES)
648  FPRINTF (stdout,
649  _("Scanning directory `%s'.\n"),
650  filename);
651  else
652  FPRINTF (stdout,
653  _("Scanning file `%s'.\n"),
654  filename);
655  }
656  break;
658  FPRINTF (stderr,
659  _("There was trouble processing file `%s', skipping it.\n"),
660  filename);
661  break;
663  if (verbose)
664  FPRINTF (stdout,
665  "%s",
666  _("Preprocessing complete.\n"));
667  break;
669  if (verbose > 2)
670  FPRINTF (stdout,
671  _("Extracting meta data from file `%s' complete.\n"),
672  filename);
673  break;
675  if (verbose > 1)
676  FPRINTF (stdout,
677  "%s",
678  _("Meta data extraction has finished.\n"));
679  directory_scan_result = GNUNET_FS_directory_scan_get_result (ds);
680  ds = NULL;
681  GNUNET_FS_share_tree_trim (directory_scan_result);
682  directory_trim_complete (directory_scan_result);
683  break;
685  FPRINTF (stdout,
686  "%s",
687  _("Error scanning directory.\n"));
688  ret = 1;
690  break;
691  default:
692  GNUNET_assert (0);
693  break;
694  }
695  fflush (stdout);
696 }
697 
698 
705 static void
706 identity_continuation (const char *args0)
707 {
708  char *ex;
709  char *emsg;
710 
711  if ( (NULL != pseudonym) &&
712  (NULL == namespace) )
713  {
714  FPRINTF (stderr,
715  _("Selected pseudonym `%s' unknown\n"),
716  pseudonym);
717  ret = 1;
719  return;
720  }
721  if (NULL != uri_string)
722  {
723  emsg = NULL;
724  if (NULL == (uri = GNUNET_FS_uri_parse (uri_string, &emsg)))
725  {
726  FPRINTF (stderr,
727  _("Failed to parse URI: %s\n"),
728  emsg);
729  GNUNET_free (emsg);
730  ret = 1;
732  return;
733  }
735  topKeywords,
736  meta, uri,
737  &bo,
740  NULL);
741  return;
742  }
743  if (GNUNET_OK !=
744  GNUNET_CONFIGURATION_get_value_string (cfg, "FS", "EXTRACTORS", &ex))
745  ex = NULL;
746  if (0 != ACCESS (args0, R_OK))
747  {
748  FPRINTF (stderr,
749  _("Failed to access `%s': %s\n"),
750  args0,
751  STRERROR (errno));
753  return;
754  }
755  ds = GNUNET_FS_directory_scan_start (args0,
757  ex,
758  &directory_scan_cb, NULL);
759  if (NULL == ds)
760  {
761  FPRINTF (stderr,
762  "%s",
763  _("Failed to start meta directory scanner. Is gnunet-helper-publish-fs installed?\n"));
765  return;
766  }
768 }
769 
770 
782 static void
783 identity_cb (void *cls,
784  struct GNUNET_IDENTITY_Ego *ego,
785  void **ctx,
786  const char *name)
787 {
788  const char *args0 = cls;
789 
790  if (NULL == ego)
791  {
792  identity_continuation (args0);
793  return;
794  }
795  if (NULL == name)
796  return;
797  if (0 == strcmp (name, pseudonym))
798  namespace = ego;
799 }
800 
801 
810 static void
811 run (void *cls,
812  char *const *args,
813  const char *cfgfile,
814  const struct GNUNET_CONFIGURATION_Handle *c)
815 {
816  /* check arguments */
817  if ((NULL != uri_string) && (extract_only))
818  {
819  printf (_("Cannot extract metadata from a URI!\n"));
820  ret = -1;
821  return;
822  }
823  if (((NULL == uri_string) || (extract_only)) &&
824  ((NULL == args[0]) || (NULL != args[1])))
825  {
826  printf (_("You must specify one and only one filename for insertion.\n"));
827  ret = -1;
828  return;
829  }
830  if ((NULL != uri_string) && (NULL != args[0]))
831  {
832  printf (_("You must NOT specify an URI and a filename.\n"));
833  ret = -1;
834  return;
835  }
836  if (NULL != pseudonym)
837  {
838  if (NULL == this_id)
839  {
840  FPRINTF (stderr, _("Option `%s' is required when using option `%s'.\n"),
841  "-t", "-P");
842  ret = -1;
843  return;
844  }
845  }
846  else
847  { /* ordinary insertion checks */
848  if (NULL != next_id)
849  {
850  FPRINTF (stderr,
851  _("Option `%s' makes no sense without option `%s'.\n"),
852  "-N", "-P");
853  ret = -1;
854  return;
855  }
856  if (NULL != this_id)
857  {
858  FPRINTF (stderr,
859  _("Option `%s' makes no sense without option `%s'.\n"),
860  "-t", "-P");
861  ret = -1;
862  return;
863  }
864  }
865  cfg = c;
866  ctx =
867  GNUNET_FS_start (cfg, "gnunet-publish", &progress_cb, NULL,
869  if (NULL == ctx)
870  {
871  FPRINTF (stderr,
872  _("Could not initialize `%s' subsystem.\n"),
873  "FS");
874  ret = 1;
875  return;
876  }
878  NULL);
879  if (NULL != pseudonym)
880  identity = GNUNET_IDENTITY_connect (cfg,
881  &identity_cb,
882  args[0]);
883  else
884  identity_continuation (args[0]);
885 }
886 
887 
895 int
896 main (int argc,
897  char *const *argv)
898 {
899  struct GNUNET_GETOPT_CommandLineOption options[] = {
901  "anonymity",
902  "LEVEL",
903  gettext_noop ("set the desired LEVEL of sender-anonymity"),
904  &bo.anonymity_level),
906  "disable-extractor",
907  gettext_noop ("do not use libextractor to add keywords or metadata"),
910  "enable-creation-time",
911  gettext_noop ("enable adding the creation time to the "
912  "metadata of the uploaded file"),
915  "extract",
916  gettext_noop ("print list of extracted keywords that would "
917  "be used, but do not perform upload"),
918  &extract_only),
920  "key",
921  "KEYWORD",
922  gettext_noop ("add an additional keyword for the top-level "
923  "file or directory (this option can be specified multiple times)"),
924  &topKeywords),
926  "meta",
927  "TYPE:VALUE",
928  gettext_noop ("set the meta-data for the given TYPE to the given VALUE"),
929  &meta),
931  "noindex",
932  gettext_noop ("do not index, perform full insertion (stores "
933  "entire file in encrypted form in GNUnet database)"),
934  &do_insert),
936  "next",
937  "ID",
938  gettext_noop ("specify ID of an updated version to be "
939  "published in the future (for namespace insertions only)"),
940  &next_id),
942  "priority",
943  "PRIORITY",
944  gettext_noop ("specify the priority of the content"),
945  &bo.content_priority),
947  "pseudonym",
948  "NAME",
949  gettext_noop ("publish the files under the pseudonym "
950  "NAME (place file into namespace)"),
951  &pseudonym),
953  "replication",
954  "LEVEL",
955  gettext_noop ("set the desired replication LEVEL"),
956  &bo.replication_level),
958  "simulate-only",
959  gettext_noop ("only simulate the process but do not do "
960  "any actual publishing (useful to compute URIs)"),
961  &do_simulate),
963  "this",
964  "ID",
965  gettext_noop ("set the ID of this version of the publication "
966  "(for namespace insertions only)"),
967  &this_id),
969  "uri",
970  "URI",
971  gettext_noop ("URI to be published (can be used instead of passing a "
972  "file to add keywords to the file with the respective URI)"),
973  &uri_string),
974 
976 
978  };
979  bo.expiration_time =
981 
982  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
983  return 2;
984  ret = (GNUNET_OK ==
985  GNUNET_PROGRAM_run (argc,
986  argv,
987  "gnunet-publish [OPTIONS] FILENAME",
989  ("Publish a file or directory on GNUnet"),
990  options,
991  &run,
992  NULL)) ? ret : 1;
993  GNUNET_free ((void*) argv);
994  return ret;
995 }
996 
997 /* end of gnunet-publish.c */
struct GNUNET_IDENTITY_Handle * GNUNET_IDENTITY_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_IDENTITY_Callback cb, void *cb_cls)
Connect to the identity service.
Definition: identity_api.c:528
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_TIME_Absolute GNUNET_TIME_year_to_time(unsigned int year)
Convert a year to an expiration time of January 1st of that year.
Definition: time.c:725
void GNUNET_FS_share_tree_trim(struct GNUNET_FS_ShareTreeItem *toplevel)
Process a share item tree, moving frequent keywords up and copying frequent metadata up...
Definition: fs_sharetree.c:412
struct GNUNET_FS_FileInformation * GNUNET_FS_file_information_create_empty_directory(struct GNUNET_FS_Handle *h, void *client_info, const struct GNUNET_FS_Uri *keywords, const struct GNUNET_CONTAINER_MetaData *meta, const struct GNUNET_FS_BlockOptions *bo, const char *filename)
Create an entry for an empty directory in a publish-structure.
EXTRACTOR_MetaFormat
Format in which the extracted meta data is presented.
void GNUNET_FS_publish_stop(struct GNUNET_FS_PublishContext *pc)
Stop an upload.
Definition: fs_publish.c:1558
void GNUNET_FS_unindex_stop(struct GNUNET_FS_UnindexContext *uc)
Clean up after completion of an unindex operation.
Definition: fs_unindex.c:833
Notification that we started to unindex a file.
struct GNUNET_FS_Uri * GNUNET_FS_uri_ksk_create_from_args(unsigned int argc, const char **argv)
Create an FS URI from a user-supplied command line of keywords.
Definition: fs_uri.c:1146
static void directory_trim_complete(struct GNUNET_FS_ShareTreeItem *directory_scan_result)
We&#39;ve finished scanning the directory and optimized the meta data.
void GNUNET_FS_meta_data_make_directory(struct GNUNET_CONTAINER_MetaData *md)
Set the MIMETYPE information for the given metadata to "application/gnunet-directory".
Definition: fs_directory.c:77
Notification that we are making progress sharing a file structure.
void GNUNET_FS_uri_ksk_add_keyword(struct GNUNET_FS_Uri *uri, const char *keyword, int is_mandatory)
Add the given keyword to the set of keywords represented by the URI.
Definition: fs_uri.c:751
static struct GNUNET_FS_FileInformation * get_file_information(struct GNUNET_FS_ShareTreeItem *item)
Iterate over the results from the directory scan and extract the desired information for the publishi...
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_FS_DirScanner * GNUNET_FS_directory_scan_start(const char *filename, int disable_extractor, const char *ex, GNUNET_FS_DirScannerProgressCallback cb, void *cb_cls)
Start a directory scanner thread.
char * GNUNET_STRINGS_byte_size_fancy(unsigned long long size)
Convert a given filesize into a fancy human-readable format.
Definition: strings.c:174
#define FPRINTF
Definition: plibc.h:683
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:635
Notification that we made progress unindexing a file.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received, or when GNUNET_SCHEDULER_shutdown() is being invoked.
Definition: scheduler.c:1293
Master context for most FS operations.
Definition: fs_api.h:1087
void GNUNET_CONTAINER_meta_data_add_publication_date(struct GNUNET_CONTAINER_MetaData *md)
Add the current time as the publication date to the meta-data.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_verbose(unsigned int *level)
Define the &#39;-V&#39; verbosity option.
int GNUNET_FS_file_information_add(struct GNUNET_FS_FileInformation *dir, struct GNUNET_FS_FileInformation *ent)
Add an entry to a directory in a publish-structure.
int GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1521
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define STRERROR(i)
Definition: plibc.h:676
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
static int meta_printer(void *cls, const char *plugin_name, enum EXTRACTOR_MetaType type, enum EXTRACTOR_MetaFormat format, const char *data_mime_type, const char *data, size_t data_size)
Print metadata entries (except binary metadata and the filename).
const struct GNUNET_CRYPTO_EcdsaPrivateKey * GNUNET_IDENTITY_ego_get_private_key(const struct GNUNET_IDENTITY_Ego *ego)
Obtain the ECC key associated with a ego.
Definition: identity_api.c:556
static int extract_only
Command-line option to only perform meta data extraction, but not publish.
static struct GNUNET_FS_Handle * ctx
Handle for interaction with file-sharing service.
Last option in the VARARG list.
#define GNUNET_FS_DIRECTORY_MIME
struct GNUNET_FS_FileInformation * GNUNET_FS_file_information_create_from_file(struct GNUNET_FS_Handle *h, void *client_info, const char *filename, const struct GNUNET_FS_Uri *keywords, const struct GNUNET_CONTAINER_MetaData *meta, int do_index, const struct GNUNET_FS_BlockOptions *bo)
Create an entry for a file in a publish-structure.
struct GNUNET_FS_Uri * ksk_uri
Keywords for this file or directory (derived from metadata).
static int publish_inspector(void *cls, struct GNUNET_FS_FileInformation *fi, uint64_t length, struct GNUNET_CONTAINER_MetaData *m, struct GNUNET_FS_Uri **uri, struct GNUNET_FS_BlockOptions *bo, int *do_index, void **client_info)
Function called on all entries before the publication.
int main(int argc, char *const *argv)
The main function to publish content to GNUnet.
0-terminated, UTF-8 encoded string.
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
An opaque structure a pointer to which is returned to the caller to be used to control the scanner...
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
Definition of a command line option.
Private ECC key encoded for transmission.
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.
EXTRACTOR_MetaType
Enumeration defining various sources of keywords.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:524
void GNUNET_FS_stop(struct GNUNET_FS_Handle *h)
Close our connection with the file-sharing service.
Definition: fs_api.c:3163
struct GNUNET_GETOPT_CommandLineOption GNUNET_FS_GETOPT_METADATA(char shortName, const char *name, const char *argumentHelp, const char *description, struct GNUNET_CONTAINER_MetaData **meta)
Allow user to specify metadata.
Definition: fs_getopt.c:251
We&#39;ve found all files (in the pre-pass).
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
static void uri_ksk_continuation(void *cls, const struct GNUNET_FS_Uri *ksk_uri, const char *emsg)
Function called upon completion of the publishing of the UBLOCK for the KSK URI.
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:3097
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_string(char shortName, const char *name, const char *argumentHelp, const char *description, char **str)
Allow user to specify a string.
No special flags set.
#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...
char * GNUNET_FS_uri_to_string(const struct GNUNET_FS_Uri *uri)
Convert a URI to a UTF-8 String.
Definition: fs_uri.c:1988
static int enable_creation_time
Command-line option to disable adding creation time.
static void uri_sks_continuation(void *cls, const struct GNUNET_FS_Uri *sks_uri, const char *emsg)
Function called upon completion of the publishing of the UBLOCK for the SKS URI.
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_ARM_MonitorHandle * m
Monitor connection with ARM.
Definition: gnunet-arm.c:99
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.
struct GNUNET_FS_ShareTreeItem * next
This is a doubly-linked list.
int GNUNET_FS_uri_ksk_get_keywords(const struct GNUNET_FS_Uri *uri, GNUNET_FS_KeywordIterator iterator, void *iterator_cls)
Iterate over all keywords in this keyword URI.
Definition: fs_uri.c:719
Notification that we have started to publish a file structure.
static char * uri_string
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
Meta data to associate with a file, directory or namespace.
Handle for an ego.
Definition: identity.h:245
static void * progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *info)
Called by FS client to give information about the progress of an operation.
union GNUNET_FS_ProgressInfo::@28 value
Values that depend on the event type.
static struct GNUNET_FS_Uri * topKeywords
Keywords provided via command-line option.
A node of a directory tree (produced by dirscanner)
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
Notification that we are making progress sharing a directory.
void GNUNET_CONTAINER_meta_data_merge(struct GNUNET_CONTAINER_MetaData *md, const struct GNUNET_CONTAINER_MetaData *in)
Extend metadata.
struct GNUNET_FS_ShareTreeItem * children_head
This is a doubly-linked tree NULL for files and empty directories.
static char * fn
Filename of the unique file.
Handle for the service.
Definition: identity_api.c:96
struct GNUNET_CONTAINER_MetaData * GNUNET_CONTAINER_meta_data_create(void)
Create a fresh meta data container.
enum GNUNET_FS_Status status
Specific status code (determines the event type).
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:727
struct GNUNET_FS_ProgressInfo::@28::@29 publish
Values for all "GNUNET_FS_STATUS_PUBLISH_*" events.
static void do_stop_task(void *cls)
We are finished with the publishing operation, clean up all FS state.
static char * filename
void GNUNET_CONTAINER_meta_data_destroy(struct GNUNET_CONTAINER_MetaData *md)
Free meta data.
static int ret
Global return value from main().
void GNUNET_IDENTITY_disconnect(struct GNUNET_IDENTITY_Handle *h)
Disconnect from identity service.
Definition: identity_api.c:838
static char * plugin_name
Solver plugin name as string.
void GNUNET_FS_directory_scan_abort(struct GNUNET_FS_DirScanner *ds)
Abort the scan.
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:670
There was an internal error.
Handle for controlling a publication process.
Definition: fs_api.h:1198
GNUNET_FS_DirScannerProgressUpdateReason
Progress reasons of the directory scanner.
int GNUNET_CONFIGURATION_get_value_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be a string.
int GNUNET_CONTAINER_meta_data_delete(struct GNUNET_CONTAINER_MetaData *md, enum EXTRACTOR_MetaType type, const char *data, size_t data_size)
Remove an item.
struct GNUNET_GETOPT_CommandLineOption GNUNET_FS_GETOPT_KEYWORDS(char shortName, const char *name, const char *argumentHelp, const char *description, struct GNUNET_FS_Uri **topKeywords)
Allow user to specify keywords.
Definition: fs_getopt.c:129
static struct GNUNET_IDENTITY_Handle * identity
Which namespace do we publish to? NULL if we do not publish to a namespace.
static int keyword_printer(void *cls, const char *keyword, int is_mandatory)
Iterator printing keywords.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Handle to our configuration.
Notification that the unindexing of this file was stopped (final event for this action).
static int do_insert
Command-line option for &#39;inserting&#39;.
const char * name
Last call to the progress function: we have finished scanning the directory.
Settings for publishing a block (which may of course also apply to an entire directory or file)...
Notification that the unindexing of this file was completed.
Notification that we completed sharing a file structure.
int is_directory
GNUNET_YES if this is a directory
static void run(void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
Main function that will be run by the scheduler.
char * filename
Name of the file/directory.
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
static struct GNUNET_FS_Handle * fs
Handle to FS service.
Definition: gnunet-fs.c:36
struct GNUNET_CONTAINER_MetaData * meta
Metadata for this file or directory.
static char * this_id
Command-line option for namespace publishing: identifier for this publication.
We&#39;ve started processing a file or directory.
uint32_t replication_level
How often should we try to migrate the block to other peers? Only used if "CONTENT_PUSHING" is set to...
unsigned int GNUNET_TIME_get_current_year(void)
Return the current year (i.e.
Definition: time.c:684
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
Notification that an error was encountered sharing a file structure.
static char * next_id
Command-line option for namespace publishing: identifier for updates to this publication.
static struct GNUNET_OS_Process * child
The child process we spawn.
configuration data
Definition: configuration.c:85
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.
void GNUNET_FS_share_tree_free(struct GNUNET_FS_ShareTreeItem *toplevel)
Release memory of a share item tree.
Definition: fs_sharetree.c:432
A Universal Resource Identifier (URI), opaque.
Definition: fs_api.h:168
static struct GNUNET_CONTAINER_MetaData * meta
Meta-data provided via command-line option.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_flag(char shortName, const char *name, const char *description, int *val)
Allow user to specify a flag (which internally means setting an integer to 1/GNUNET_YES/GNUNET_OK.
int GNUNET_CONTAINER_meta_data_iterate(const struct GNUNET_CONTAINER_MetaData *md, EXTRACTOR_MetaDataProcessor iter, void *iter_cls)
Iterate over MD entries.
We&#39;ve finished extracting meta data from a file.
void GNUNET_FS_file_information_destroy(struct GNUNET_FS_FileInformation *fi, GNUNET_FS_FileInformationProcessor cleaner, void *cleaner_cls)
Destroy publish-structure.
static int disable_extractor
Command-line option to disable meta data extraction.
uint32_t content_priority
How important is it for us to store the block? If we run out of space, the highest-priority, non-expired blocks will be kept.
static void identity_cb(void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *name)
Function called by identity service with known pseudonyms.
static unsigned int verbose
Command line option &#39;verbose&#39; set.
int GNUNET_PROGRAM_run(int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls)
Run a standard GNUnet command startup sequence (initialize loggers and configuration, parse options).
Definition: program.c:361
static void identity_continuation(const char *args0)
Continuation proceeding with initialization after identity subsystem has been initialized.
struct GNUNET_FS_Uri * GNUNET_FS_uri_ksk_merge(const struct GNUNET_FS_Uri *u1, const struct GNUNET_FS_Uri *u2)
Merge the sets of keywords from two KSK URIs.
Definition: fs_uri.c:931
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
struct GNUNET_FS_ShareTreeItem * GNUNET_FS_directory_scan_get_result(struct GNUNET_FS_DirScanner *ds)
Obtain the result of the scan after the scan has signalled completion.
#define GNUNET_YES
Definition: gnunet_common.h:80
static struct GNUNET_FS_DirScanner * ds
Handle to the directory scanner (for recursive insertions).
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_uint(char shortName, const char *name, const char *argumentHelp, const char *description, unsigned int *val)
Allow user to specify an unsigned int.
static void directory_scan_cb(void *cls, const char *filename, int is_directory, enum GNUNET_FS_DirScannerProgressUpdateReason reason)
Function called by the directory scanner as we build the tree that we will need to publish later...
static int do_simulate
Command-line option to merely simulate publishing operation.
No options (use defaults for everything).
uint32_t data
The data value.
struct GNUNET_FS_ProgressInfo::@28::@32 unindex
Values for all "GNUNET_FS_STATUS_UNINDEX_*" events.
#define ACCESS(p, m)
Definition: plibc.h:656
static size_t data_size
Number of bytes in data.
Notification that we encountered an error unindexing a file.
static struct GNUNET_FS_BlockOptions bo
Options we set for published blocks.
static char * pseudonym
Command-line option identifying the pseudonym to use for the publication.
#define GNUNET_free(ptr)
Wrapper around free.
Argument given to the progress callback with information about what is going on.
We&#39;re having trouble accessing a file (soft-error); it will be ignored.
#define gettext_noop(String)
Definition: gettext.h:69