GNUnet  0.16.x
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 
129 static const char *
130 print_escape_sequence (const char *const esc)
131 {
132  unsigned int probe;
133  const char * cursor = esc + 1;
134  char tmp;
135  switch (*cursor)
136  {
137  /* Trivia */
138  case '\\': putchar ('\\'); return cursor + 1;
139  case 'a': putchar ('\a'); return cursor + 1;
140  case 'b': putchar ('\b'); return cursor + 1;
141  case 'e': putchar ('\x1B'); return cursor + 1;
142  case 'f': putchar ('\f'); return cursor + 1;
143  case 'n': putchar ('\n'); return cursor + 1;
144  case 'r': putchar ('\r'); return cursor + 1;
145  case 't': putchar ('\t'); return cursor + 1;
146  case 'v': putchar ('\v'); return cursor + 1;
147 
148  /* Possibly hexadecimal code point */
149  case 'x':
150  probe = 0;
151  while (probe < 256 && isxdigit((tmp = *++cursor)))
152  probe = (probe << 4) + tmp - (tmp > 96 ? 87 : tmp > 64 ? 55 : 48);
153  goto maybe_codepoint;
154 
155  /* Possibly octal code point */
156  case '0': case '1': case '2': case '3':
157  case '4': case '5': case '6': case '7':
158  probe = *cursor++ - 48;
159  do probe = (probe << 3) + *cursor++ - 48;
160  while (probe < 256 && cursor < esc + 4 && *cursor > 47 && *cursor < 56);
161  goto maybe_codepoint;
162 
163  /* Boredom */
164  case '\0': putchar ('\\'); return cursor;
165  default: printf ("\\%c", *cursor); return cursor + 1;
166  }
167 
168 maybe_codepoint:
169  if (probe < 256)
170  putchar (probe);
171  else
172  fwrite (esc, 1, cursor - esc, stdout);
173  return cursor;
174 }
175 
176 
194 static int
195 item_printer (void *const cls,
196  const char *const plugin_name,
197  const enum EXTRACTOR_MetaType type,
198  const enum EXTRACTOR_MetaFormat format,
199  const char *const data_mime_type,
200  const char *const data,
201  const size_t data_size)
202 {
203 #define info ((struct GNUNET_SEARCH_MetadataPrinterInfo *) cls)
204  if ((format != EXTRACTOR_METAFORMAT_UTF8 &&
205  format != EXTRACTOR_METAFORMAT_C_STRING) ||
207  return 0;
208  info->counter++;
209  if ((info->flags & METADATA_PRINTER_FLAG_HAVE_TYPE) && type != info->type)
210  return 0;
211 
212  const char *cursor = meta_format_string;
213  const char *next_spec = strchr(cursor, '%');
214  const char *next_esc = strchr(cursor, '\\');
215 
216 parse_format:
217 
218  /* If an escape sequence exists before the next format specifier... */
219  if (next_esc && (!next_spec || next_esc < next_spec))
220  {
221  if (next_esc > cursor)
222  fwrite (cursor, 1, next_esc - cursor, stdout);
223 
224  cursor = print_escape_sequence (next_esc);
225  next_esc = strchr(cursor, '\\');
226  goto parse_format;
227  }
228 
229  /* If a format specifier exists before the next escape sequence... */
230  if (next_spec && (!next_esc || next_spec < next_esc))
231  {
232  if (next_spec > cursor)
233  fwrite (cursor, 1, next_spec - cursor, stdout);
234 
235  switch (*++next_spec)
236  {
237  case '%': putchar('%'); break;
238  case 'i': printf ("%d", type); break;
239  case 'l': printf ("%lu", (long unsigned int) data_size); break;
240  case 'n': printf ("%u", info->counter); break;
241  case 'p': printf ("%s", data); break;
242 #if HAVE_LIBEXTRACTOR
243  case 't':
244  printf ("%s",
246  EXTRACTOR_metatype_to_string (type)));
247  break;
248 #endif
249  case 'w': printf ("%s", plugin_name); break;
250  case '\0': putchar('%'); return 0;
251  default: printf ("%%%c", *next_spec); break;
252  }
253  cursor = next_spec + 1;
254  next_spec = strchr(cursor, '%');
255  goto parse_format;
256  }
257 
258  if (*cursor)
259  printf ("%s", cursor);
260 
261  return info->flags & METADATA_PRINTER_FLAG_ONE_RUN;
262 #undef info
263 }
264 
265 
277 static void
278 print_search_result (const char *const filename,
279  const struct GNUNET_FS_Uri *const uri,
280  const struct GNUNET_CONTAINER_MetaData *const metadata,
281  const unsigned int resultnum,
282  const int is_directory)
283 {
284 
285  const char *cursor = GNUNET_YES == is_directory ?
287  : format_string;
288 
289  const char *next_spec = strchr(cursor, '%');
290  const char *next_esc = strchr(cursor, '\\');
291  char *placeholder;
293 
294 parse_format:
295  /* If an escape sequence exists before the next format specifier... */
296  if (next_esc && (!next_spec || next_esc < next_spec))
297  {
298  if (next_esc > cursor)
299  fwrite (cursor, 1, next_esc - cursor, stdout);
300 
301  cursor = print_escape_sequence (next_esc);
302  next_esc = strchr(cursor, '\\');
303  goto parse_format;
304  }
305 
306  /* If a format specifier exists before the next escape sequence... */
307  if (next_spec && (!next_esc || next_spec < next_esc))
308  {
309  if (next_spec > cursor)
310  fwrite (cursor, 1, next_spec - cursor, stdout);
311 
312  switch (*++next_spec)
313  {
314  /* All metadata fields */
315  case 'a':
317 
318 iterate_meta:
319  info.counter = 0;
321  break;
322  /* File's name */
323  case 'f':
324  if (GNUNET_YES == is_directory)
325  {
326  printf ("%s%s", filename, GNUNET_FS_DIRECTORY_EXT);
327  break;
328  }
329  printf ("%s", filename);
330  break;
331  /* Only the first metadata field */
332  case 'j':
334  goto iterate_meta;
335  /* File name's length */
336  case 'l':
337  printf ("%lu",
338  (long unsigned int) ( GNUNET_YES == is_directory ?
339  strlen(filename) +
340  (sizeof(GNUNET_FS_DIRECTORY_EXT) - 1)
341  :
342  strlen(filename)));
343  break;
344  /* File's mime type */
345  case 'm':
346  if (GNUNET_YES == is_directory)
347  {
348  printf ("%s", GNUNET_FS_DIRECTORY_MIME);
349  break;
350  }
352  metadata,
354  printf ("%s", placeholder ? placeholder : GENERIC_FILE_MIMETYPE);
355  GNUNET_free (placeholder);
356  break;
357  /* Result number */
358  case 'n': printf ("%u", resultnum); break;
359  /* File's size */
360  case 's':
361  printf ("%" PRIu64, GNUNET_FS_uri_chk_get_file_size (uri));
362  break;
363  /* File's URI */
364  case 'u':
365  placeholder = GNUNET_FS_uri_to_string (uri);
366  printf ("%s", placeholder);
367  GNUNET_free (placeholder);
368  break;
369 
370  /* We can add as many cases as we want here... */
371 
372  /* Handle `%123#a` and `%123#j` (e.g. `%5#j` is a book title) */
373  case '0': case '1': case '2': case '3': case '4':
374  case '5': case '6': case '7': case '8': case '9':
375  cursor = next_spec;
376  info.type = *cursor - 48;
377  while (isdigit(*++cursor) && info.type < (INT_MAX - *cursor + 48) / 10)
378  info.type = info.type * 10 + *cursor - 48;
379  if (info.type == 0 || *cursor != '#')
380  goto not_a_specifier;
381  switch (*++cursor)
382  {
383  /* All metadata fields of type `info.type` */
384  case 'a':
385  next_spec = cursor;
387  goto iterate_meta;
388 
389  /* Only the first metadata field of type `info.type` */
390  case 'j':
391  next_spec = cursor;
394  goto iterate_meta;
395  }
396  goto not_a_specifier;
397 
398  /* All other cases */
399  case '%': putchar('%'); break;
400  case '\0': putchar('%'); return;
401 
402 not_a_specifier:
403  default: printf ("%%%c", *next_spec); break;
404  }
405  cursor = next_spec + 1;
406  next_spec = strchr(cursor, '%');
407  goto parse_format;
408  }
409 
410  if (*cursor)
411  printf ("%s", cursor);
412 }
413 
414 
415 static void
416 clean_task (void *const cls)
417 {
418  size_t dsize;
419  void *ddata;
420 
422  ctx = NULL;
423  if (output_filename == NULL)
424  return;
425  if (GNUNET_OK !=
426  GNUNET_FS_directory_builder_finish (db, &dsize, &ddata))
427  {
428  GNUNET_break (0);
430  return;
431  }
433  if (GNUNET_OK !=
435  ddata,
436  dsize,
439  {
441  _ ("Failed to write directory with search results to "
442  "`%s'\n"),
444  }
445  GNUNET_free (ddata);
447 }
448 
449 
463 static void *
464 progress_cb (void *const cls,
465  const struct GNUNET_FS_ProgressInfo *const info)
466 {
467  static unsigned int cnt;
468  int is_directory;
469  char *filename;
470 
471  switch (info->status)
472  {
474  break;
475 
477  if (silent_mode)
478  break;
479 
480  if (db != NULL)
482  db,
483  info->value.search.specifics.result.uri,
484  info->value.search.specifics.result.meta,
485  NULL);
486 
487  cnt++;
489  info->value.search.specifics.result.meta,
492  info->value.search.specifics.result.meta);
493  if (NULL != filename)
494  {
495  while ((filename[0] != '\0') && ('/' == filename[strlen (filename) - 1]))
496  filename[strlen (filename) - 1] = '\0';
498  }
500  filename
501  : is_directory ?
503  :
505  info->value.search.specifics.result.uri,
506  info->value.search.specifics.result.meta,
507  cnt,
508  is_directory);
509  fflush (stdout);
511  results++;
512  if ((results_limit > 0) && (results >= results_limit))
513  {
515  /* otherwise the function might keep printing results for a while... */
517  }
518  break;
519 
522  /* ignore */
523  break;
524 
527  _ ("Error searching: %s.\n"),
528  info->value.search.specifics.error.message);
530  break;
531 
534  break;
535 
536  default:
538  _ ("Unexpected status: %d\n"),
539  info->status);
540  break;
541  }
542  return NULL;
543 }
544 
545 
546 static void
547 shutdown_task (void *const cls)
548 {
549  if (sc != NULL)
550  {
552  sc = NULL;
553  }
554 }
555 
556 
557 static void
558 timeout_task (void *const cls)
559 {
560  tt = NULL;
563 }
564 
565 
574 static void
575 run (void *const cls,
576  char *const *const args,
577  const char *const cfgfile,
578  const struct GNUNET_CONFIGURATION_Handle *const cfgarg)
579 {
580  struct GNUNET_FS_Uri *uri;
581  unsigned int argc;
583 
584  if (silent_mode && bookmark_only)
585  {
586  fprintf (stderr,
587  _ ("Conflicting options --bookmark-only and --silent.\n"));
588  ret = 1;
589  return;
590  }
592  {
593  fprintf (stderr,
594  _ ("Conflicting options --bookmark-only and --output.\n"));
595  ret = 1;
596  return;
597  }
599  {
600  fprintf (stderr, _ ("An output file is mandatory for silent mode.\n"));
601  ret = 1;
602  return;
603  }
604  if (NULL == dir_format_string)
608  if (NULL == format_string)
611  if (NULL == meta_format_string)
613  argc = 0;
614  while (NULL != args[argc])
615  argc++;
616  uri = GNUNET_FS_uri_ksk_create_from_args (argc, (const char **) args);
617  if (NULL == uri)
618  {
619  fprintf (stderr,
620  "%s",
621  _ ("Could not create keyword URI from arguments.\n"));
622  ret = 1;
623  return;
624  }
626  {
627  fprintf (stderr,
628  "%s",
629  _ ("Invalid URI. Valid URIs for searching are keyword query "
630  "URIs\n(\"gnunet://fs/ksk/...\") and namespace content URIs "
631  "(\"gnunet://fs/sks/...\").\n"));
633  ret = 1;
634  return;
635  }
636  if (bookmark_only)
637  {
638  char * bmstr = GNUNET_FS_uri_to_string (uri);
639  printf ("%s\n", bmstr);
640  GNUNET_free (bmstr);
642  ret = 0;
643  return;
644  }
645  cfg = cfgarg;
647  "gnunet-search",
648  &progress_cb,
649  NULL,
652  if (NULL == ctx)
653  {
654  fprintf (stderr, _ ("Could not initialize the `%s` subsystem.\n"), "FS");
656  ret = 1;
657  return;
658  }
659  if (output_filename != NULL)
662  if (local_only)
666  if (NULL == sc)
667  {
668  fprintf (stderr, "%s", _ ("Could not start searching.\n"));
670  ret = 1;
671  return;
672  }
673  if (0 != timeout.rel_value_us)
676 }
677 
678 
686 int
687 main (int argc, char *const *argv)
688 {
691  'a',
692  "anonymity",
693  "LEVEL",
694  gettext_noop ("set the desired LEVEL of receiver-anonymity (default: "
695  "1)"),
696  &anonymity),
698  'b',
699  "bookmark-only",
700  gettext_noop ("do not search, print only the URI that points to this "
701  "search"),
702  &bookmark_only),
704  'F',
705  "dir-printf",
706  "FORMAT",
707  gettext_noop ("write search results for directories according to "
708  "FORMAT; accepted placeholders are: %a, %f, %j, %l, %m, "
709  "%n, %s; defaults to the value of --printf when omitted "
710  "or to `" HELP_DEFAULT_DIR_FORMAT "` if --printf is "
711  "omitted too"),
714  'f',
715  "printf",
716  "FORMAT",
717  gettext_noop ("write search results according to FORMAT; accepted "
718  "placeholders are: %a, %f, %j, %l, %m, %n, %s; defaults "
719  "to `" HELP_DEFAULT_FILE_FORMAT "` when omitted"),
720  &format_string),
722  'i',
723  "iter-printf",
724  "FORMAT",
725  gettext_noop ("when the %a or %j placeholders appear in --printf or "
726  "--dir-printf, list each metadata property according to "
727  "FORMAT; accepted placeholders are: %i, %l, %n, %p"
728  HELP_EXTRACTOR_TEXTADD ", %w; defaults to `"
729  HELP_DEFAULT_META_FORMAT "` when omitted"),
732  "results",
733  "VALUE",
734  gettext_noop ("automatically terminate search "
735  "after VALUE results are found"),
736  &results_limit),
738  'n',
739  "no-network",
740  gettext_noop ("only search the local peer (no P2P network search)"),
741  &local_only),
743  'o',
744  "output",
745  "FILENAME",
746  gettext_noop ("create a GNUnet directory with search results at "
747  "FILENAME (e.g. `gnunet-search --output=commons"
748  GNUNET_FS_DIRECTORY_EXT " commons`)"),
749  &output_filename),
751  's',
752  "silent",
753  gettext_noop ("silent mode (requires the --output argument)"),
754  &silent_mode),
756  't',
757  "timeout",
758  "DELAY",
759  gettext_noop ("automatically terminate search after DELAY; the value "
760  "given must be a number followed by a space and a time "
761  "unit, for example \"500 ms\"; without a unit it defaults "
762  "to microseconds - 1000000 = 1 second; if 0 or omitted "
763  "it means to wait for CTRL-C"),
764  &timeout),
766  'V',
767  "verbose",
768  gettext_noop ("be verbose (append \"%a\\n\" to the default --printf and "
769  "--dir-printf arguments - ignored when these are provided "
770  "by the user)"),
771  &verbose),
773 
774  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
775  return 12;
776 
777  if (GNUNET_SYSERR ==
778  GNUNET_PROGRAM_run (argc,
779  argv,
780  "gnunet-search [OPTIONS] KEYWORD1 KEYWORD2 ...",
781  gettext_noop ("Search for files that have been "
782  "published on GNUnet\n"),
783  options,
784  &run,
785  NULL))
786  ret = 1;
787 
788  GNUNET_free_nz ((void *) argv);
789  return ret;
790 }
791 
792 
793 /* 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.
#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.
@ GNUNET_OK
Definition: gnunet_common.h:95
@ GNUNET_YES
Definition: gnunet_common.h:97
@ GNUNET_SYSERR
Definition: gnunet_common.h:93
EXTRACTOR_MetaFormat
Format in which the extracted meta data is presented.
@ EXTRACTOR_METAFORMAT_C_STRING
0-terminated string.
@ EXTRACTOR_METAFORMAT_UTF8
0-terminated, UTF-8 encoded string.
EXTRACTOR_MetaType
Enumeration defining various sources of keywords.
@ EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME
@ EXTRACTOR_METATYPE_MIMETYPE
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:1778
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:3263
#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:3338
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:1619
@ 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.
#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