GNUnet  0.17.6
gnunet-search.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2001, 2002, 2004, 2005, 2006, 2007, 2009, 2022 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  */
29 #include <ctype.h>
30 #include <inttypes.h>
31 #include <limits.h>
32 #include "platform.h"
33 #include "gnunet_fs_service.h"
34 
35 
36 #define GNUNET_SEARCH_log(kind, ...) \
37  GNUNET_log_from(kind, "gnunet-search", __VA_ARGS__)
38 
39 
40 /* The default settings that we use for the printed output */
41 
42 #define DEFAULT_DIR_FORMAT "#%n:\ngnunet-download -o \"%f\" -R %u\n\n"
43 #define HELP_DEFAULT_DIR_FORMAT "#%n:\\ngnunet-download -o \"%f\" -R %u\\n\\n"
44 #define DEFAULT_FILE_FORMAT "#%n:\ngnunet-download -o \"%f\" %u\n\n"
45 #define HELP_DEFAULT_FILE_FORMAT "#%n:\\ngnunet-download -o \"%f\" %u\\n\\n"
46 #define VERB_DEFAULT_DIR_FORMAT DEFAULT_DIR_FORMAT "%a\n"
47 #define VERB_DEFAULT_FILE_FORMAT DEFAULT_FILE_FORMAT "%a\n"
48 
49 #if HAVE_LIBEXTRACTOR
50 #define DEFAULT_META_FORMAT " %t: %p\n"
51 #define HELP_DEFAULT_META_FORMAT " %t: %p\\n"
52 #define HELP_EXTRACTOR_TEXTADD ", %t"
53 #else
54 #define DEFAULT_META_FORMAT " MetaType #%i: %p\n"
55 #define HELP_DEFAULT_META_FORMAT " MetaType #%i: %p\\n"
56 #define HELP_EXTRACTOR_TEXTADD ""
57 #endif
58 
59 #define GENERIC_DIRECTORY_NAME "collection"
60 #define GENERIC_FILE_NAME "no-name"
61 #define GENERIC_FILE_MIMETYPE "application/octet-stream"
62 
63 
68 };
69 
70 
72  unsigned int counter;
73  unsigned int flags;
74  int type;
75 };
76 
77 
78 static int ret;
79 
80 static const struct GNUNET_CONFIGURATION_Handle *cfg;
81 
82 static struct GNUNET_FS_Handle *ctx;
83 
84 static struct GNUNET_FS_SearchContext *sc;
85 
86 static char *output_filename;
87 
88 static char *format_string;
89 
90 static char *dir_format_string;
91 
92 static char *meta_format_string;
93 
95 
96 static unsigned int anonymity = 1;
97 
101 static struct GNUNET_TIME_Relative timeout;
102 
103 static unsigned int results_limit;
104 
105 static unsigned int results;
106 
107 static unsigned int verbose;
108 
109 static int bookmark_only;
110 
111 static int local_only;
112 
113 static int silent_mode;
114 
115 static struct GNUNET_SCHEDULER_Task *tt;
116 
117 static int stop_searching;
118 
119 
131 static const char *
132 print_escape_sequence (const char *const esc)
133 {
134  unsigned int probe;
135  const char * cursor = esc + 1;
136  char tmp;
137  switch (*cursor)
138  {
139  /* Trivia */
140  case '\\': putchar ('\\'); return cursor + 1;
141  case 'a': putchar ('\a'); return cursor + 1;
142  case 'b': putchar ('\b'); return cursor + 1;
143  case 'e': putchar ('\x1B'); return cursor + 1;
144  case 'f': putchar ('\f'); return cursor + 1;
145  case 'n': putchar ('\n'); return cursor + 1;
146  case 'r': putchar ('\r'); return cursor + 1;
147  case 't': putchar ('\t'); return cursor + 1;
148  case 'v': putchar ('\v'); return cursor + 1;
149 
150  /* Possibly hexadecimal code point */
151  case 'x':
152  probe = 0;
153  while (probe < 256 && isxdigit((tmp = *++cursor)))
154  probe = (probe << 4) + tmp - (tmp > 96 ? 87 : tmp > 64 ? 55 : 48);
155  goto maybe_codepoint;
156 
157  /* Possibly octal code point */
158  case '0': case '1': case '2': case '3':
159  case '4': case '5': case '6': case '7':
160  probe = *cursor++ - 48;
161  do probe = (probe << 3) + *cursor++ - 48;
162  while (probe < 256 && cursor < esc + 4 && *cursor > 47 && *cursor < 56);
163  goto maybe_codepoint;
164 
165  /* Boredom */
166  case '\0': putchar ('\\'); return cursor;
167  default: printf ("\\%c", *cursor); return cursor + 1;
168  }
169 
170 maybe_codepoint:
171  if (probe < 256)
172  putchar (probe);
173  else
174  fwrite (esc, 1, cursor - esc, stdout);
175  return cursor;
176 }
177 
178 
196 static int
197 item_printer (void *const cls,
198  const char *const plugin_name,
199  const enum EXTRACTOR_MetaType type,
200  const enum EXTRACTOR_MetaFormat format,
201  const char *const data_mime_type,
202  const char *const data,
203  const size_t data_size)
204 {
205 #define info ((struct GNUNET_SEARCH_MetadataPrinterInfo *) cls)
206  if ((format != EXTRACTOR_METAFORMAT_UTF8 &&
207  format != EXTRACTOR_METAFORMAT_C_STRING) ||
209  return 0;
210  info->counter++;
211  if ((info->flags & METADATA_PRINTER_FLAG_HAVE_TYPE) && type != info->type)
212  return 0;
213 
214  const char *cursor = meta_format_string;
215  const char *next_spec = strchr(cursor, '%');
216  const char *next_esc = strchr(cursor, '\\');
217 
218 parse_format:
219 
220  /* If an escape sequence exists before the next format specifier... */
221  if (next_esc && (!next_spec || next_esc < next_spec))
222  {
223  if (next_esc > cursor)
224  fwrite (cursor, 1, next_esc - cursor, stdout);
225 
226  cursor = print_escape_sequence (next_esc);
227  next_esc = strchr(cursor, '\\');
228  goto parse_format;
229  }
230 
231  /* If a format specifier exists before the next escape sequence... */
232  if (next_spec && (!next_esc || next_spec < next_esc))
233  {
234  if (next_spec > cursor)
235  fwrite (cursor, 1, next_spec - cursor, stdout);
236 
237  switch (*++next_spec)
238  {
239  case '%': putchar('%'); break;
240  case 'i': printf ("%d", type); break;
241  case 'l': printf ("%lu", (long unsigned int) data_size); break;
242  case 'n': printf ("%u", info->counter); break;
243  case 'p': printf ("%s", data); break;
244 #if HAVE_LIBEXTRACTOR
245  case 't':
246  printf ("%s",
248  EXTRACTOR_metatype_to_string (type)));
249  break;
250 #endif
251  case 'w': printf ("%s", plugin_name); break;
252  case '\0': putchar('%'); return 0;
253  default: printf ("%%%c", *next_spec); break;
254  }
255  cursor = next_spec + 1;
256  next_spec = strchr(cursor, '%');
257  goto parse_format;
258  }
259 
260  if (*cursor)
261  printf ("%s", cursor);
262 
263  return info->flags & METADATA_PRINTER_FLAG_ONE_RUN;
264 #undef info
265 }
266 
267 
279 static void
280 print_search_result (const char *const filename,
281  const struct GNUNET_FS_Uri *const uri,
282  const struct GNUNET_CONTAINER_MetaData *const metadata,
283  const unsigned int resultnum,
284  const int is_directory)
285 {
286 
287  const char *cursor = GNUNET_YES == is_directory ?
289  : format_string;
290 
291  const char *next_spec = strchr(cursor, '%');
292  const char *next_esc = strchr(cursor, '\\');
293  char *placeholder;
295 
296 parse_format:
297  /* If an escape sequence exists before the next format specifier... */
298  if (next_esc && (!next_spec || next_esc < next_spec))
299  {
300  if (next_esc > cursor)
301  fwrite (cursor, 1, next_esc - cursor, stdout);
302 
303  cursor = print_escape_sequence (next_esc);
304  next_esc = strchr(cursor, '\\');
305  goto parse_format;
306  }
307 
308  /* If a format specifier exists before the next escape sequence... */
309  if (next_spec && (!next_esc || next_spec < next_esc))
310  {
311  if (next_spec > cursor)
312  fwrite (cursor, 1, next_spec - cursor, stdout);
313 
314  switch (*++next_spec)
315  {
316  /* All metadata fields */
317  case 'a':
319 
320 iterate_meta:
321  info.counter = 0;
323  break;
324  /* File's name */
325  case 'f':
326  if (GNUNET_YES == is_directory)
327  {
328  printf ("%s%s", filename, GNUNET_FS_DIRECTORY_EXT);
329  break;
330  }
331  printf ("%s", filename);
332  break;
333  /* Only the first metadata field */
334  case 'j':
336  goto iterate_meta;
337  /* File name's length */
338  case 'l':
339  printf ("%lu",
340  (long unsigned int) ( GNUNET_YES == is_directory ?
341  strlen(filename) +
342  (sizeof(GNUNET_FS_DIRECTORY_EXT) - 1)
343  :
344  strlen(filename)));
345  break;
346  /* File's mime type */
347  case 'm':
348  if (GNUNET_YES == is_directory)
349  {
350  printf ("%s", GNUNET_FS_DIRECTORY_MIME);
351  break;
352  }
354  metadata,
356  printf ("%s", placeholder ? placeholder : GENERIC_FILE_MIMETYPE);
357  GNUNET_free (placeholder);
358  break;
359  /* Result number */
360  case 'n': printf ("%u", resultnum); break;
361  /* File's size */
362  case 's':
363  printf ("%" PRIu64, GNUNET_FS_uri_chk_get_file_size (uri));
364  break;
365  /* File's URI */
366  case 'u':
367  placeholder = GNUNET_FS_uri_to_string (uri);
368  printf ("%s", placeholder);
369  GNUNET_free (placeholder);
370  break;
371 
372  /* We can add as many cases as we want here... */
373 
374  /* Handle `%123#a` and `%123#j` (e.g. `%5#j` is a book title) */
375  case '0': case '1': case '2': case '3': case '4':
376  case '5': case '6': case '7': case '8': case '9':
377  cursor = next_spec;
378  info.type = *cursor - 48;
379  while (isdigit(*++cursor) && info.type < (INT_MAX - *cursor + 48) / 10)
380  info.type = info.type * 10 + *cursor - 48;
381  if (info.type == 0 || *cursor != '#')
382  goto not_a_specifier;
383  switch (*++cursor)
384  {
385  /* All metadata fields of type `info.type` */
386  case 'a':
387  next_spec = cursor;
389  goto iterate_meta;
390 
391  /* Only the first metadata field of type `info.type` */
392  case 'j':
393  next_spec = cursor;
396  goto iterate_meta;
397  }
398  goto not_a_specifier;
399 
400  /* All other cases */
401  case '%': putchar('%'); break;
402  case '\0': putchar('%'); return;
403 
404 not_a_specifier:
405  default: printf ("%%%c", *next_spec); break;
406  }
407  cursor = next_spec + 1;
408  next_spec = strchr(cursor, '%');
409  goto parse_format;
410  }
411 
412  if (*cursor)
413  printf ("%s", cursor);
414 }
415 
416 
417 static void
418 clean_task (void *const cls)
419 {
420  size_t dsize;
421  void *ddata;
422 
424  ctx = NULL;
425  if (output_filename == NULL)
426  return;
427  if (GNUNET_OK !=
428  GNUNET_FS_directory_builder_finish (db, &dsize, &ddata))
429  {
430  GNUNET_break (0);
432  return;
433  }
435  if (GNUNET_OK !=
437  ddata,
438  dsize,
441  {
443  _ ("Failed to write directory with search results to "
444  "`%s'\n"),
446  }
447  GNUNET_free (ddata);
449 }
450 
451 
465 static void *
466 progress_cb (void *const cls,
467  const struct GNUNET_FS_ProgressInfo *const info)
468 {
469  static unsigned int cnt;
470  int is_directory;
471  char *filename;
472 
473  switch (info->status)
474  {
476  break;
477 
479  if (stop_searching)
480  break;
481 
482  if (db != NULL)
484  db,
485  info->value.search.specifics.result.uri,
486  info->value.search.specifics.result.meta,
487  NULL);
488 
489  if (silent_mode)
490  break;
491 
492  cnt++;
494  info->value.search.specifics.result.meta,
497  info->value.search.specifics.result.meta);
498  if (NULL != filename)
499  {
500  while ((filename[0] != '\0') && ('/' == filename[strlen (filename) - 1]))
501  filename[strlen (filename) - 1] = '\0';
503  }
505  filename
506  : is_directory ?
508  :
510  info->value.search.specifics.result.uri,
511  info->value.search.specifics.result.meta,
512  cnt,
513  is_directory);
514  fflush (stdout);
516  results++;
517  if ((results_limit > 0) && (results >= results_limit))
518  {
520  /* otherwise the function might keep printing results for a while... */
522  }
523  break;
524 
527  /* ignore */
528  break;
529 
532  _ ("Error searching: %s.\n"),
533  info->value.search.specifics.error.message);
535  break;
536 
539  break;
540 
541  default:
543  _ ("Unexpected status: %d\n"),
544  info->status);
545  break;
546  }
547  return NULL;
548 }
549 
550 
551 static void
552 shutdown_task (void *const cls)
553 {
554  if (sc != NULL)
555  {
557  sc = NULL;
558  }
559 }
560 
561 
562 static void
563 timeout_task (void *const cls)
564 {
565  tt = NULL;
568 }
569 
570 
579 static void
580 run (void *const cls,
581  char *const *const args,
582  const char *const cfgfile,
583  const struct GNUNET_CONFIGURATION_Handle *const cfgarg)
584 {
585  struct GNUNET_FS_Uri *uri;
586  unsigned int argc;
588 
589  if (silent_mode && bookmark_only)
590  {
591  fprintf (stderr,
592  _ ("Conflicting options --bookmark-only and --silent.\n"));
593  ret = 1;
594  return;
595  }
597  {
598  fprintf (stderr,
599  _ ("Conflicting options --bookmark-only and --output.\n"));
600  ret = 1;
601  return;
602  }
604  {
605  fprintf (stderr, _ ("An output file is mandatory for silent mode.\n"));
606  ret = 1;
607  return;
608  }
609  if (NULL == dir_format_string)
613  if (NULL == format_string)
616  if (NULL == meta_format_string)
618  argc = 0;
619  while (NULL != args[argc])
620  argc++;
621  uri = GNUNET_FS_uri_ksk_create_from_args (argc, (const char **) args);
622  if (NULL == uri)
623  {
624  fprintf (stderr,
625  "%s",
626  _ ("Could not create keyword URI from arguments.\n"));
627  ret = 1;
628  return;
629  }
631  {
632  fprintf (stderr,
633  "%s",
634  _ ("Invalid URI. Valid URIs for searching are keyword query "
635  "URIs\n(\"gnunet://fs/ksk/...\") and namespace content URIs "
636  "(\"gnunet://fs/sks/...\").\n"));
638  ret = 1;
639  return;
640  }
641  if (bookmark_only)
642  {
643  char * bmstr = GNUNET_FS_uri_to_string (uri);
644  printf ("%s\n", bmstr);
645  GNUNET_free (bmstr);
647  ret = 0;
648  return;
649  }
650  cfg = cfgarg;
652  "gnunet-search",
653  &progress_cb,
654  NULL,
657  if (NULL == ctx)
658  {
659  fprintf (stderr, _ ("Could not initialize the `%s` subsystem.\n"), "FS");
661  ret = 1;
662  return;
663  }
664  if (output_filename != NULL)
667  if (local_only)
671  if (NULL == sc)
672  {
673  fprintf (stderr, "%s", _ ("Could not start searching.\n"));
675  ret = 1;
676  return;
677  }
678  if (0 != timeout.rel_value_us)
681 }
682 
683 
691 int
692 main (int argc, char *const *argv)
693 {
696  'a',
697  "anonymity",
698  "LEVEL",
699  gettext_noop ("set the desired LEVEL of receiver-anonymity (default: "
700  "1)"),
701  &anonymity),
703  'b',
704  "bookmark-only",
705  gettext_noop ("do not search, print only the URI that points to this "
706  "search"),
707  &bookmark_only),
709  'F',
710  "dir-printf",
711  "FORMAT",
712  gettext_noop ("write search results for directories according to "
713  "FORMAT; accepted placeholders are: %a, %f, %j, %l, %m, "
714  "%n, %s; defaults to the value of --printf when omitted "
715  "or to `" HELP_DEFAULT_DIR_FORMAT "` if --printf is "
716  "omitted too"),
719  'f',
720  "printf",
721  "FORMAT",
722  gettext_noop ("write search results according to FORMAT; accepted "
723  "placeholders are: %a, %f, %j, %l, %m, %n, %s; defaults "
724  "to `" HELP_DEFAULT_FILE_FORMAT "` when omitted"),
725  &format_string),
727  'i',
728  "iter-printf",
729  "FORMAT",
730  gettext_noop ("when the %a or %j placeholders appear in --printf or "
731  "--dir-printf, list each metadata property according to "
732  "FORMAT; accepted placeholders are: %i, %l, %n, %p"
733  HELP_EXTRACTOR_TEXTADD ", %w; defaults to `"
734  HELP_DEFAULT_META_FORMAT "` when omitted"),
737  "results",
738  "VALUE",
739  gettext_noop ("automatically terminate search "
740  "after VALUE results are found"),
741  &results_limit),
743  'n',
744  "no-network",
745  gettext_noop ("only search the local peer (no P2P network search)"),
746  &local_only),
748  'o',
749  "output",
750  "FILENAME",
751  gettext_noop ("create a GNUnet directory with search results at "
752  "FILENAME (e.g. `gnunet-search --output=commons"
753  GNUNET_FS_DIRECTORY_EXT " commons`)"),
754  &output_filename),
756  's',
757  "silent",
758  gettext_noop ("silent mode (requires the --output argument)"),
759  &silent_mode),
761  't',
762  "timeout",
763  "DELAY",
764  gettext_noop ("automatically terminate search after DELAY; the value "
765  "given must be a number followed by a space and a time "
766  "unit, for example \"500 ms\"; without a unit it defaults "
767  "to microseconds - 1000000 = 1 second; if 0 or omitted "
768  "it means to wait for CTRL-C"),
769  &timeout),
771  'V',
772  "verbose",
773  gettext_noop ("be verbose (append \"%a\\n\" to the default --printf and "
774  "--dir-printf arguments - ignored when these are provided "
775  "by the user)"),
776  &verbose),
778 
779  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
780  return 12;
781 
782  if (GNUNET_SYSERR ==
783  GNUNET_PROGRAM_run (argc,
784  argv,
785  "gnunet-search [OPTIONS] KEYWORD1 KEYWORD2 ...",
786  gettext_noop ("Search for files that have been "
787  "published on GNUnet\n"),
788  options,
789  &run,
790  NULL))
791  ret = 1;
792 
793  GNUNET_free_nz ((void *) argv);
794  return ret;
795 }
796 
797 
798 /* end of gnunet-search.c */
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
#define INT_MAX
#define gettext_noop(String)
Definition: gettext.h:69
#define dgettext(Domainname, Msgid)
Definition: gettext.h:46
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
static char * filename
uint32_t data
The data value.
static struct GNUNET_FS_Uri * uri
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
#define VERB_DEFAULT_DIR_FORMAT
Definition: gnunet-search.c:46
#define info
static char * output_filename
Definition: gnunet-search.c:86
#define DEFAULT_META_FORMAT
Definition: gnunet-search.c:54
static unsigned int verbose
#define HELP_DEFAULT_FILE_FORMAT
Definition: gnunet-search.c:45
#define DEFAULT_DIR_FORMAT
Definition: gnunet-search.c:42
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:84
#define HELP_DEFAULT_DIR_FORMAT
Definition: gnunet-search.c:43
static void timeout_task(void *const cls)
static char * dir_format_string
Definition: gnunet-search.c:90
#define HELP_DEFAULT_META_FORMAT
Definition: gnunet-search.c:55
static void shutdown_task(void *const cls)
static unsigned int anonymity
Definition: gnunet-search.c:96
#define GENERIC_FILE_NAME
Definition: gnunet-search.c:60
static void run(void *const cls, char *const *const args, const char *const cfgfile, const struct GNUNET_CONFIGURATION_Handle *const cfgarg)
Main function that will be run by the scheduler.
static void clean_task(void *const cls)
static int silent_mode
#define GNUNET_SEARCH_log(kind,...)
Definition: gnunet-search.c:36
static const struct GNUNET_CONFIGURATION_Handle * cfg
Definition: gnunet-search.c:80
static int bookmark_only
static char * meta_format_string
Definition: gnunet-search.c:92
static int ret
Definition: gnunet-search.c:78
static void print_search_result(const char *const filename, const struct GNUNET_FS_Uri *const uri, const struct GNUNET_CONTAINER_MetaData *const metadata, const unsigned int resultnum, const int is_directory)
Print a search result according to the current formats.
static struct GNUNET_SCHEDULER_Task * tt
static unsigned int results
static struct GNUNET_FS_Handle * ctx
Definition: gnunet-search.c:82
GNUNET_SEARCH_MetadataPrinterFlags
Definition: gnunet-search.c:64
@ METADATA_PRINTER_FLAG_HAVE_TYPE
Definition: gnunet-search.c:67
@ METADATA_PRINTER_FLAG_NONE
Definition: gnunet-search.c:65
@ METADATA_PRINTER_FLAG_ONE_RUN
Definition: gnunet-search.c:66
#define GENERIC_FILE_MIMETYPE
Definition: gnunet-search.c:61
static const char * print_escape_sequence(const char *const esc)
Print the escape sequence at the beginning of a string.
static struct GNUNET_TIME_Relative timeout
Timeout for the search, 0 means to wait for CTRL-C.
static int stop_searching
#define DEFAULT_FILE_FORMAT
Definition: gnunet-search.c:44
#define HELP_EXTRACTOR_TEXTADD
Definition: gnunet-search.c:56
static int local_only
static unsigned int results_limit
int main(int argc, char *const *argv)
The main function to search GNUnet.
static void * progress_cb(void *const cls, const struct GNUNET_FS_ProgressInfo *const info)
Called by FS client to give information about the progress of an operation.
#define GENERIC_DIRECTORY_NAME
Definition: gnunet-search.c:59
static char * format_string
Definition: gnunet-search.c:88
#define VERB_DEFAULT_FILE_FORMAT
Definition: gnunet-search.c:47
static int item_printer(void *const cls, const char *const plugin_name, const enum EXTRACTOR_MetaType type, const enum EXTRACTOR_MetaFormat format, const char *const data_mime_type, const char *const data, const size_t data_size)
Type of a function that libextractor calls for each meta data item found.
static struct GNUNET_FS_DirectoryBuilder * db
Definition: gnunet-search.c:94
static char * plugin_name
Name of our plugin.
API for file sharing via GNUnet.
void GNUNET_DISK_filename_canonicalize(char *fn)
Removes special characters as ':' from a filename.
Definition: disk.c:1189
enum GNUNET_GenericReturnValue GNUNET_DISK_fn_write(const char *fn, const void *buf, size_t buf_size, enum GNUNET_DISK_AccessPermissions mode)
Write a buffer to a file atomically.
Definition: disk.c:725
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_remove(const char *filename)
Remove all files in a directory (rm -rf).
Definition: disk.c:1085
@ GNUNET_DISK_PERM_USER_READ
Owner can read.
@ GNUNET_DISK_PERM_USER_WRITE
Owner can write.
GNUNET_FS_SearchOptions
Options for searching.
int GNUNET_FS_directory_builder_finish(struct GNUNET_FS_DirectoryBuilder *bld, size_t *rsize, void **rdata)
Finish building the directory.
Definition: fs_directory.c:577
int GNUNET_FS_meta_data_test_for_directory(const struct GNUNET_CONTAINER_MetaData *md)
Does the meta-data claim that this is a directory? Checks if the mime-type is that of a GNUnet direct...
Definition: fs_directory.c:54
uint64_t GNUNET_FS_uri_chk_get_file_size(const struct GNUNET_FS_Uri *uri)
What is the size of the file that this URI refers to?
Definition: fs_uri.c:1376
int GNUNET_FS_uri_test_ksk(const struct GNUNET_FS_Uri *uri)
Is this a keyword URI?
Definition: fs_uri.c:1340
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:391
#define GNUNET_FS_DIRECTORY_MIME
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:1160
char * GNUNET_FS_uri_to_string(const struct GNUNET_FS_Uri *uri)
Convert a URI to a UTF-8 String.
Definition: fs_uri.c:2033
void GNUNET_FS_search_stop(struct GNUNET_FS_SearchContext *sc)
Stop search for content.
Definition: fs_search.c:1765
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:684
int GNUNET_FS_uri_test_sks(const struct GNUNET_FS_Uri *uri)
Is this a namespace URI?
Definition: fs_uri.c:1287
struct GNUNET_FS_DirectoryBuilder * GNUNET_FS_directory_builder_create(const struct GNUNET_CONTAINER_MetaData *mdir)
Create a directory builder.
Definition: fs_directory.c:365
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:3246
#define GNUNET_FS_DIRECTORY_EXT
void GNUNET_FS_stop(struct GNUNET_FS_Handle *h)
Close our connection with the file-sharing service.
Definition: fs_api.c:3321
struct GNUNET_FS_SearchContext * GNUNET_FS_search_start(struct GNUNET_FS_Handle *h, const struct GNUNET_FS_Uri *uri, uint32_t anonymity, enum GNUNET_FS_SearchOptions options, void *cctx)
Start search for content.
Definition: fs_search.c:1606
@ GNUNET_FS_FLAGS_NONE
No special flags set.
@ GNUNET_FS_SEARCH_OPTION_LOOPBACK_ONLY
Only search the local host, do not search remote systems (no P2P)
@ GNUNET_FS_SEARCH_OPTION_NONE
No options (use defaults for everything).
@ GNUNET_FS_OPTIONS_END
Last option in the VARARG list.
@ GNUNET_FS_STATUS_SEARCH_UPDATE
We have additional data about the quality or availability of a search result.
@ GNUNET_FS_STATUS_SEARCH_ERROR
Signals a problem with this search.
@ GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED
Event generated for each search result when the respective search is stopped.
@ GNUNET_FS_STATUS_SEARCH_RESULT
This search has yielded a result.
@ GNUNET_FS_STATUS_SEARCH_START
First event generated when a client requests a search to begin or when a namespace result automatical...
@ GNUNET_FS_STATUS_SEARCH_STOPPED
Last message from a search; this signals that there will be no further events associated with this se...
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_increment_uint(char shortName, const char *name, const char *description, unsigned int *val)
Increment val each time the option flag is given by one.
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.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_relative_time(char shortName, const char *name, const char *argumentHelp, const char *description, struct GNUNET_TIME_Relative *val)
Allow user to specify a struct GNUNET_TIME_Relative (using human-readable "fancy" time).
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.
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.
EXTRACTOR_MetaFormat
Format in which the extracted meta data is presented.
EXTRACTOR_MetaType
Enumeration defining various sources of keywords.
@ EXTRACTOR_METAFORMAT_C_STRING
0-terminated string.
@ EXTRACTOR_METAFORMAT_UTF8
0-terminated, UTF-8 encoded string.
@ GNUNET_OK
Definition: gnunet_common.h:99
@ GNUNET_YES
@ GNUNET_SYSERR
Definition: gnunet_common.h:97
@ EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME
@ EXTRACTOR_METATYPE_MIMETYPE
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ GNUNET_ERROR_TYPE_ERROR
#define GNUNET_free(ptr)
Wrapper around free.
#define GNUNET_free_nz(ptr)
Wrapper around free.
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.
int GNUNET_CONTAINER_meta_data_iterate(const struct GNUNET_CONTAINER_MetaData *md, EXTRACTOR_MetaDataProcessor iter, void *iter_cls)
Iterate over MD entries.
enum GNUNET_GenericReturnValue 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,...
Definition: program.c:399
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:533
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1281
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,...
Definition: scheduler.c:1316
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1254
enum GNUNET_GenericReturnValue GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1223
#define _(String)
GNU gettext support macro.
Definition: platform.h:177
#define LIBEXTRACTOR_GETTEXT_DOMAIN
Definition: platform.h:178
Meta data to associate with a file, directory or namespace.
Internal state of a directory builder.
Definition: fs_directory.c:341
Master context for most FS operations.
Definition: fs_api.h:1069
Argument given to the progress callback with information about what is going on.
Handle for controlling a search.
Definition: fs_api.h:1510
A Universal Resource Identifier (URI), opaque.
Definition: fs_api.h:166
Definition of a command line option.
Entry in list of pending tasks.
Definition: scheduler.c:135
Time for relative time used by GNUnet, in microseconds.
uint64_t rel_value_us
The actual value.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model