GNUnet  0.11.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, const struct GNUNET_FS_ProgressInfo *info)
204 {
205  const char *s;
206  char *suri;
207 
208  switch (info->status)
209  {
211  break;
212 
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,
223  s);
224  }
225  break;
226 
228  if (verbose)
229  {
231  .progress_directory.eta,
232  GNUNET_YES);
233  fprintf (stdout,
234  _ ("Publishing `%s' at %llu/%llu (%s remaining)\n"),
235  info->value.publish.filename,
236  (unsigned long long)
237  info->value.publish.specifics.progress_directory.completed,
238  (unsigned long long)
239  info->value.publish.specifics.progress_directory.total,
240  s);
241  }
242  break;
243 
245  fprintf (stderr,
246  _ ("Error publishing: %s.\n"),
247  info->value.publish.specifics.error.message);
248  ret = 1;
250  break;
251 
253  fprintf (stdout,
254  _ ("Publishing `%s' done.\n"),
255  info->value.publish.filename);
256  suri =
257  GNUNET_FS_uri_to_string (info->value.publish.specifics.completed.chk_uri);
258  fprintf (stdout, _ ("URI is `%s'.\n"), suri);
259  GNUNET_free (suri);
260  if (NULL != info->value.publish.specifics.completed.sks_uri)
261  {
262  suri = GNUNET_FS_uri_to_string (
263  info->value.publish.specifics.completed.sks_uri);
264  fprintf (stdout, _ ("Namespace URI is `%s'.\n"), suri);
265  GNUNET_free (suri);
266  }
267  if (NULL == info->value.publish.pctx)
268  {
269  ret = 0;
271  }
272  break;
273 
275  GNUNET_break (NULL == pc);
276  return NULL;
277 
279  fprintf (stderr, "%s", _ ("Starting cleanup after abort\n"));
280  return NULL;
281 
283  return NULL;
284 
286  fprintf (stderr, "%s", _ ("Cleanup after abort completed.\n"));
288  return NULL;
289 
291  fprintf (stderr, "%s", _ ("Cleanup after abort failed.\n"));
293  return NULL;
294 
296  return NULL;
297 
298  default:
299  fprintf (stderr, _ ("Unexpected status: %d\n"), info->status);
300  return NULL;
301  }
302  return ""; /* non-null */
303 }
304 
305 
319 static int
320 meta_printer (void *cls,
321  const char *plugin_name,
323  enum EXTRACTOR_MetaFormat format,
324  const char *data_mime_type,
325  const char *data,
326  size_t data_size)
327 {
328  if ((EXTRACTOR_METAFORMAT_UTF8 != format) &&
329  (EXTRACTOR_METAFORMAT_C_STRING != format))
330  return 0;
332  return 0;
333 #if HAVE_LIBEXTRACTOR
334  fprintf (stdout, "\t%s - %s\n", EXTRACTOR_metatype_to_string (type), data);
335 #else
336  fprintf (stdout, "\t%d - %s\n", type, data);
337 #endif
338  return 0;
339 }
340 
341 
350 static int
351 keyword_printer (void *cls, const char *keyword, int is_mandatory)
352 {
353  fprintf (stdout, "\t%s\n", keyword);
354  return GNUNET_OK;
355 }
356 
357 
375 static int
376 publish_inspector (void *cls,
378  uint64_t length,
380  struct GNUNET_FS_Uri **uri,
381  struct GNUNET_FS_BlockOptions *bo,
382  int *do_index,
383  void **client_info)
384 {
385  char *fn;
386  char *fs;
387  struct GNUNET_FS_Uri *new_uri;
388 
389  if (cls == fi)
390  return GNUNET_OK;
391  if ((disable_extractor) && (NULL != *uri))
392  {
393  GNUNET_FS_uri_destroy (*uri);
394  *uri = NULL;
395  }
396  if (NULL != topKeywords)
397  {
398  if (NULL != *uri)
399  {
400  new_uri = GNUNET_FS_uri_ksk_merge (topKeywords, *uri);
401  GNUNET_FS_uri_destroy (*uri);
402  *uri = new_uri;
403  GNUNET_FS_uri_destroy (topKeywords);
404  }
405  else
406  {
407  *uri = topKeywords;
408  }
409  topKeywords = NULL;
410  }
411  if (NULL != meta)
412  {
415  meta = NULL;
416  }
419  if (extract_only)
420  {
422  m,
424  fs = GNUNET_STRINGS_byte_size_fancy (length);
425  fprintf (stdout, _ ("Meta data for file `%s' (%s)\n"), fn, fs);
427  fprintf (stdout, _ ("Keywords for file `%s' (%s)\n"), fn, fs);
428  GNUNET_free (fn);
429  GNUNET_free (fs);
430  if (NULL != *uri)
432  fprintf (stdout, "%s", "\n");
433  }
436  return GNUNET_OK;
437 }
438 
439 
449 static void
451  const struct GNUNET_FS_Uri *sks_uri,
452  const char *emsg)
453 {
454  if (NULL != emsg)
455  {
456  fprintf (stderr, "%s\n", emsg);
457  ret = 1;
458  }
460 }
461 
462 
472 static void
474  const struct GNUNET_FS_Uri *ksk_uri,
475  const char *emsg)
476 {
477  const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv;
478 
479  if (NULL != emsg)
480  {
481  fprintf (stderr, "%s\n", emsg);
482  ret = 1;
483  }
484  if (NULL == namespace)
485  {
487  return;
488  }
489  priv = GNUNET_IDENTITY_ego_get_private_key (namespace);
491  priv,
492  this_id,
493  next_id,
494  meta,
495  uri,
496  &bo,
499  NULL);
500 }
501 
502 
510 static struct GNUNET_FS_FileInformation *
512 {
513  struct GNUNET_FS_FileInformation *fi;
514  struct GNUNET_FS_FileInformation *fic;
516 
517  if (GNUNET_YES == item->is_directory)
518  {
519  if (NULL == item->meta)
523  NULL,
524  0);
526  if (NULL == item->ksk_uri)
527  {
528  const char *mime = GNUNET_FS_DIRECTORY_MIME;
529  item->ksk_uri = GNUNET_FS_uri_ksk_create_from_args (1, &mime);
530  }
531  else
534  GNUNET_NO);
536  NULL,
537  item->ksk_uri,
538  item->meta,
539  &bo,
540  item->filename);
541  for (child = item->children_head; child; child = child->next)
542  {
543  fic = get_file_information (child);
545  }
546  }
547  else
548  {
550  NULL,
551  item->filename,
552  item->ksk_uri,
553  item->meta,
554  ! do_insert,
555  &bo);
556  }
557  return fi;
558 }
559 
560 
567 static void
568 directory_trim_complete (struct GNUNET_FS_ShareTreeItem *directory_scan_result)
569 {
570  struct GNUNET_FS_FileInformation *fi;
571  const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv;
572 
573  fi = get_file_information (directory_scan_result);
574  GNUNET_FS_share_tree_free (directory_scan_result);
575  if (NULL == fi)
576  {
577  fprintf (stderr, "%s", _ ("Could not publish\n"));
578  ret = 1;
580  return;
581  }
583  if (extract_only)
584  {
585  GNUNET_FS_file_information_destroy (fi, NULL, NULL);
587  return;
588  }
589  if (NULL == namespace)
590  priv = NULL;
591  else
592  priv = GNUNET_IDENTITY_ego_get_private_key (namespace);
593  pc = GNUNET_FS_publish_start (ctx,
594  fi,
595  priv,
596  this_id,
597  next_id,
598  (do_simulate)
601  if (NULL == pc)
602  {
603  fprintf (stderr, "%s", _ ("Could not start publishing.\n"));
604  ret = 1;
606  return;
607  }
608 }
609 
610 
622 static void
623 directory_scan_cb (void *cls,
624  const char *filename,
625  int is_directory,
627 {
628  struct GNUNET_FS_ShareTreeItem *directory_scan_result;
629 
630  switch (reason)
631  {
633  if (verbose > 1)
634  {
635  if (is_directory == GNUNET_YES)
636  fprintf (stdout, _ ("Scanning directory `%s'.\n"), filename);
637  else
638  fprintf (stdout, _ ("Scanning file `%s'.\n"), filename);
639  }
640  break;
641 
643  fprintf (stderr,
644  _ ("There was trouble processing file `%s', skipping it.\n"),
645  filename);
646  break;
647 
649  if (verbose)
650  fprintf (stdout, "%s", _ ("Preprocessing complete.\n"));
651  break;
652 
654  if (verbose > 2)
655  fprintf (stdout,
656  _ ("Extracting meta data from file `%s' complete.\n"),
657  filename);
658  break;
659 
661  if (verbose > 1)
662  fprintf (stdout, "%s", _ ("Meta data extraction has finished.\n"));
663  directory_scan_result = GNUNET_FS_directory_scan_get_result (ds);
664  ds = NULL;
665  GNUNET_FS_share_tree_trim (directory_scan_result);
666  directory_trim_complete (directory_scan_result);
667  break;
668 
670  fprintf (stdout, "%s", _ ("Error scanning directory.\n"));
671  ret = 1;
673  break;
674 
675  default:
676  GNUNET_assert (0);
677  break;
678  }
679  fflush (stdout);
680 }
681 
682 
689 static void
690 identity_continuation (const char *args0)
691 {
692  char *ex;
693  char *emsg;
694 
695  if ((NULL != pseudonym) && (NULL == namespace))
696  {
697  fprintf (stderr, _ ("Selected pseudonym `%s' unknown\n"), pseudonym);
698  ret = 1;
700  return;
701  }
702  if (NULL != uri_string)
703  {
704  emsg = NULL;
705  if (NULL == (uri = GNUNET_FS_uri_parse (uri_string, &emsg)))
706  {
707  fprintf (stderr, _ ("Failed to parse URI: %s\n"), emsg);
708  GNUNET_free (emsg);
709  ret = 1;
711  return;
712  }
714  topKeywords,
715  meta,
716  uri,
717  &bo,
720  NULL);
721  return;
722  }
723  if (GNUNET_OK !=
724  GNUNET_CONFIGURATION_get_value_string (cfg, "FS", "EXTRACTORS", &ex))
725  ex = NULL;
726  if (0 != access (args0, R_OK))
727  {
728  fprintf (stderr,
729  _ ("Failed to access `%s': %s\n"),
730  args0,
731  strerror (errno));
733  return;
734  }
735  ds = GNUNET_FS_directory_scan_start (args0,
737  ex,
739  NULL);
740  if (NULL == ds)
741  {
742  fprintf (
743  stderr,
744  "%s",
745  _ (
746  "Failed to start meta directory scanner. Is gnunet-helper-publish-fs installed?\n"));
748  return;
749  }
751 }
752 
753 
765 static void
766 identity_cb (void *cls,
767  struct GNUNET_IDENTITY_Ego *ego,
768  void **ctx,
769  const char *name)
770 {
771  const char *args0 = cls;
772 
773  if (NULL == ego)
774  {
775  identity_continuation (args0);
776  return;
777  }
778  if (NULL == name)
779  return;
780  if (0 == strcmp (name, pseudonym))
781  namespace = ego;
782 }
783 
784 
793 static void
794 run (void *cls,
795  char *const *args,
796  const char *cfgfile,
797  const struct GNUNET_CONFIGURATION_Handle *c)
798 {
799  /* check arguments */
800  if ((NULL != uri_string) && (extract_only))
801  {
802  printf (_ ("Cannot extract metadata from a URI!\n"));
803  ret = -1;
804  return;
805  }
806  if (((NULL == uri_string) || (extract_only)) &&
807  ((NULL == args[0]) || (NULL != args[1])))
808  {
809  printf (_ ("You must specify one and only one filename for insertion.\n"));
810  ret = -1;
811  return;
812  }
813  if ((NULL != uri_string) && (NULL != args[0]))
814  {
815  printf (_ ("You must NOT specify an URI and a filename.\n"));
816  ret = -1;
817  return;
818  }
819  if (NULL != pseudonym)
820  {
821  if (NULL == this_id)
822  {
823  fprintf (stderr,
824  _ ("Option `%s' is required when using option `%s'.\n"),
825  "-t",
826  "-P");
827  ret = -1;
828  return;
829  }
830  }
831  else
832  { /* ordinary insertion checks */
833  if (NULL != next_id)
834  {
835  fprintf (stderr,
836  _ ("Option `%s' makes no sense without option `%s'.\n"),
837  "-N",
838  "-P");
839  ret = -1;
840  return;
841  }
842  if (NULL != this_id)
843  {
844  fprintf (stderr,
845  _ ("Option `%s' makes no sense without option `%s'.\n"),
846  "-t",
847  "-P");
848  ret = -1;
849  return;
850  }
851  }
852  cfg = c;
853  ctx = GNUNET_FS_start (cfg,
854  "gnunet-publish",
855  &progress_cb,
856  NULL,
859  if (NULL == ctx)
860  {
861  fprintf (stderr, _ ("Could not initialize `%s' subsystem.\n"), "FS");
862  ret = 1;
863  return;
864  }
866  if (NULL != pseudonym)
867  identity = GNUNET_IDENTITY_connect (cfg, &identity_cb, args[0]);
868  else
869  identity_continuation (args[0]);
870 }
871 
872 
880 int
881 main (int argc, char *const *argv)
882 {
883  struct GNUNET_GETOPT_CommandLineOption options[] =
885  "anonymity",
886  "LEVEL",
887  gettext_noop (
888  "set the desired LEVEL of sender-anonymity"),
889  &bo.anonymity_level),
891  'D',
892  "disable-extractor",
893  gettext_noop ("do not use libextractor to add keywords or metadata"),
896  "enable-creation-time",
897  gettext_noop (
898  "enable adding the creation time to the "
899  "metadata of the uploaded file"),
902  "extract",
903  gettext_noop (
904  "print list of extracted keywords that would "
905  "be used, but do not perform upload"),
906  &extract_only),
908  'k',
909  "key",
910  "KEYWORD",
911  gettext_noop (
912  "add an additional keyword for the top-level "
913  "file or directory (this option can be specified multiple times)"),
914  &topKeywords),
916  'm',
917  "meta",
918  "TYPE:VALUE",
919  gettext_noop ("set the meta-data for the given TYPE to the given VALUE"),
920  &meta),
922  'n',
923  "noindex",
924  gettext_noop ("do not index, perform full insertion (stores "
925  "entire file in encrypted form in GNUnet database)"),
926  &do_insert),
928  'N',
929  "next",
930  "ID",
931  gettext_noop ("specify ID of an updated version to be "
932  "published in the future (for namespace insertions only)"),
933  &next_id),
935  "priority",
936  "PRIORITY",
937  gettext_noop (
938  "specify the priority of the content"),
939  &bo.content_priority),
941  "pseudonym",
942  "NAME",
943  gettext_noop (
944  "publish the files under the pseudonym "
945  "NAME (place file into namespace)"),
946  &pseudonym),
948  "replication",
949  "LEVEL",
950  gettext_noop (
951  "set the desired replication LEVEL"),
952  &bo.replication_level),
954  "simulate-only",
955  gettext_noop (
956  "only simulate the process but do not do "
957  "any actual publishing (useful to compute URIs)"),
958  &do_simulate),
960  "this",
961  "ID",
962  gettext_noop (
963  "set the ID of this version of the publication "
964  "(for namespace insertions only)"),
965  &this_id),
967  'u',
968  "uri",
969  "URI",
970  gettext_noop (
971  "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 =
985  (GNUNET_OK ==
986  GNUNET_PROGRAM_run (argc,
987  argv,
988  "gnunet-publish [OPTIONS] FILENAME",
989  gettext_noop ("Publish a file or directory on GNUnet"),
990  options,
991  &run,
992  NULL))
993  ? ret
994  : 1;
995  GNUNET_free ((void *) argv);
996  return ret;
997 }
998 
999 
1000 /* 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:527
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:726
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:416
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:1570
void GNUNET_FS_unindex_stop(struct GNUNET_FS_UnindexContext *uc)
Clean up after completion of an unindex operation.
Definition: fs_unindex.c:837
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:1155
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:80
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:762
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:1442
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:175
struct GNUNET_FS_Uri * GNUNET_FS_uri_parse(const char *uri, char **emsg)
Convert a UTF-8 String to a URI.
Definition: fs_uri.c:644
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:1300
Master context for most FS operations.
Definition: fs_api.h:1068
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:1438
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
#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:433
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:555
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:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
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:226
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:526
void GNUNET_FS_stop(struct GNUNET_FS_Handle *h)
Close our connection with the file-sharing service.
Definition: fs_api.c:3216
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:254
We&#39;ve found all files (in the pre-pass).
struct GNUNET_FS_ProgressInfo::@25::@29 unindex
Values for all "GNUNET_FS_STATUS_UNINDEX_*" events.
#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:3141
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:181
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:2028
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:104
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:730
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.
union GNUNET_FS_ProgressInfo::@25 value
Values that depend on the event type.
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.
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:95
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:687
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:837
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:678
There was an internal error.
Handle for controlling a publication process.
Definition: fs_api.h:1178
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;.
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:686
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:1193
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.
struct GNUNET_FS_ProgressInfo::@25::@26 publish
Values for all "GNUNET_FS_STATUS_PUBLISH_*" events.
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:436
const char * name
A Universal Resource Identifier (URI), opaque.
Definition: fs_api.h:165
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:367
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:942
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:77
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.
Notification that we encountered an error unindexing a file.
static char * plugin_name
Name of our plugin.
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