src/fs/gnunet-search.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2001, 2002, 2004, 2005, 2006, 2007, 2009 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 */
  20 /**
  21  * @file fs/gnunet-search.c
  22  * @brief searching for files on GNUnet
  23  * @author Christian Grothoff
  24  * @author Krista Bennett
  25  * @author James Blackwell
  26  * @author Igor Wronsky
  27  */
  28 #include "platform.h"
  29 #include "gnunet_fs_service.h"
  30
  31 static int ret;
  32
  33 static const struct GNUNET_CONFIGURATION_Handle *cfg;
  34
  35 static struct GNUNET_FS_Handle *ctx;
  36
  37 static struct GNUNET_FS_SearchContext *sc;
  38
  39 static char *output_filename;
  40
  41 static struct GNUNET_FS_DirectoryBuilder *db;
  42
  43 static unsigned int anonymity = 1;
  44
  45 /**
  46  * Timeout for the search, 0 means to wait for CTRL-C.
  47  */
  48 static struct GNUNET_TIME_Relative timeout;
  49
  50 static unsigned int results_limit;
  51
  52 static unsigned int results;
  53
  54 static unsigned int verbose;
  55
  56 static int local_only;
  57
  58 static struct GNUNET_SCHEDULER_Task *tt;
  59
  60
  61 /**
  62  * Type of a function that libextractor calls for each
  63  * meta data item found.
  64  *
  65  * @param cls closure (user-defined, unused)
  66  * @param plugin_name name of the plugin that produced this value;
  67  *        special values can be used (i.e. '&lt;zlib&gt;' for zlib being
  68  *        used in the main libextractor library and yielding
  69  *        meta data).
  70  * @param type libextractor-type describing the meta data
  71  * @param format basic format information about data
  72  * @param data_mime_type mime-type of data (not of the original file);
  73  *        can be NULL (if mime-type is not known)
  74  * @param data actual meta-data found
  75  * @param data_size number of bytes in @a data
  76  * @return 0 to continue extracting, 1 to abort
  77  */
  78 static int
  79 item_printer (void *cls,
  80               const char *plugin_name,
  81               enum EXTRACTOR_MetaType type,
  82               enum EXTRACTOR_MetaFormat format,
  83               const char *data_mime_type,
  84               const char *data,
  85               size_t data_size)
  86 {
  87   if ((format != EXTRACTOR_METAFORMAT_UTF8) &&
  88       (format != EXTRACTOR_METAFORMAT_C_STRING))
  89     return 0;
  90   if (type == EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME)
  91     return 0;
  92 #if HAVE_LIBEXTRACTOR
  93   printf ("\t%20s: %s\n",
  94           dgettext (LIBEXTRACTOR_GETTEXT_DOMAIN,
  95                     EXTRACTOR_metatype_to_string (type)), data);
  96 #else
  97   printf ("\t%20d: %s\n",
  98           type,
  99           data);
 100 #endif
 101   return 0;
 102 }
 103
 104
 105 static void
 106 clean_task (void *cls)
 107 {
 108   size_t dsize;
 109   void *ddata;
 110
 111   GNUNET_FS_stop (ctx);
 112   ctx = NULL;
 113   if (output_filename == NULL)
 114     return;
 115   if (GNUNET_OK != GNUNET_FS_directory_builder_finish (db, &dsize, &ddata))
 116   {
 117     GNUNET_break (0);
 118     GNUNET_free (output_filename);
 119     return;
 120   }
 121   if (dsize !=
 122       GNUNET_DISK_fn_write (output_filename, ddata, dsize,
 123                             GNUNET_DISK_PERM_USER_READ |
 124                             GNUNET_DISK_PERM_USER_WRITE))
 125   {
 126     FPRINTF (stderr,
 127              _("Failed to write directory with search results to `%s'\n"),
 128              output_filename);
 129   }
 130   GNUNET_free_non_null (ddata);
 131   GNUNET_free (output_filename);
 132 }
 133
 134
 135 /**
 136  * Called by FS client to give information about the progress of an
 137  * operation.
 138  *
 139  * @param cls closure
 140  * @param info details about the event, specifying the event type
 141  *        and various bits about the event
 142  * @return client-context (for the next progress call
 143  *         for this operation; should be set to NULL for
 144  *         SUSPEND and STOPPED events).  The value returned
 145  *         will be passed to future callbacks in the respective
 146  *         field in the GNUNET_FS_ProgressInfo struct.
 147  */
 148 static void *
 149 progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *info)
 150 {
 151   static unsigned int cnt;
 152   int is_directory;
 153   char *uri;
 154   char *filename;
 155
 156   switch (info->status)
 157   {
 158   case GNUNET_FS_STATUS_SEARCH_START:
 159     break;
 160   case GNUNET_FS_STATUS_SEARCH_RESULT:
 161     if (db != NULL)
 162       GNUNET_FS_directory_builder_add (db,
 163                                        info->value.search.specifics.result.uri,
 164                                        info->value.search.specifics.result.meta,
 165                                        NULL);
 166     uri = GNUNET_FS_uri_to_string (info->value.search.specifics.result.uri);
 167     printf ("#%u:\n", ++cnt);
 168     filename =
 169         GNUNET_CONTAINER_meta_data_get_by_type (info->value.search.
 170                                                 specifics.result.meta,
 171                                                 EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME);
 172     is_directory =
 173         GNUNET_FS_meta_data_test_for_directory (info->value.search.
 174                                                 specifics.result.meta);
 175     if (NULL != filename)
 176     {
 177       while ( (filename[0] != '\0') &&
 178               ('/' == filename[strlen(filename)-1]) )
 179         filename[strlen(filename)-1] = '\0';
 180       GNUNET_DISK_filename_canonicalize (filename);
 181       if (GNUNET_YES == is_directory)
 182         printf ("gnunet-download -o \"%s%s\" -R %s\n", filename, GNUNET_FS_DIRECTORY_EXT, uri);
 183       else
 184         printf ("gnunet-download -o \"%s\" %s\n", filename, uri);
 185     }
 186     else if (GNUNET_YES == is_directory)
 187       printf ("gnunet-download -o \"collection%s\" -R %s\n", GNUNET_FS_DIRECTORY_EXT, uri);
 188     else
 189       printf ("gnunet-download %s\n", uri);
 190     if (verbose)
 191       GNUNET_CONTAINER_meta_data_iterate (info->value.search.specifics.
 192                                           result.meta, &item_printer, NULL);
 193     printf ("\n");
 194     fflush (stdout);
 195     GNUNET_free_non_null (filename);
 196     GNUNET_free (uri);
 197     results++;
 198     if ((results_limit > 0) && (results >= results_limit))
 199       GNUNET_SCHEDULER_shutdown ();
 200     break;
 201   case GNUNET_FS_STATUS_SEARCH_UPDATE:
 202     break;
 203   case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED:
 204     /* ignore */
 205     break;
 206   case GNUNET_FS_STATUS_SEARCH_ERROR:
 207     FPRINTF (stderr, _("Error searching: %s.\n"),
 208              info->value.search.specifics.error.message);
 209     GNUNET_SCHEDULER_shutdown ();
 210     break;
 211   case GNUNET_FS_STATUS_SEARCH_STOPPED:
 212     GNUNET_SCHEDULER_add_now (&clean_task, NULL);
 213     break;
 214   default:
 215     FPRINTF (stderr, _("Unexpected status: %d\n"), info->status);
 216     break;
 217   }
 218   return NULL;
 219 }
 220
 221
 222 static void
 223 shutdown_task (void *cls)
 224 {
 225   if (sc != NULL)
 226   {
 227     GNUNET_FS_search_stop (sc);
 228     sc = NULL;
 229   }
 230 }
 231
 232
 233 static void
 234 timeout_task (void *cls)
 235 {
 236   tt = NULL;
 237   GNUNET_SCHEDULER_shutdown ();
 238 }
 239
 240
 241 /**
 242  * Main function that will be run by the scheduler.
 243  *
 244  * @param cls closure
 245  * @param args remaining command-line arguments
 246  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
 247  * @param c configuration
 248  */
 249 static void
 250 run (void *cls, char *const *args, const char *cfgfile,
 251      const struct GNUNET_CONFIGURATION_Handle *c)
 252 {
 253   struct GNUNET_FS_Uri *uri;
 254   unsigned int argc;
 255   enum GNUNET_FS_SearchOptions options;
 256
 257   argc = 0;
 258   while (NULL != args[argc])
 259     argc++;
 260   uri = GNUNET_FS_uri_ksk_create_from_args (argc, (const char **) args);
 261   if (NULL == uri)
 262   {
 263     FPRINTF (stderr, "%s",  _("Could not create keyword URI from arguments.\n"));
 264     ret = 1;
 265     return;
 266   }
 267   cfg = c;
 268   ctx =
 269       GNUNET_FS_start (cfg, "gnunet-search", &progress_cb, NULL,
 270                        GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
 271   if (NULL == ctx)
 272   {
 273     FPRINTF (stderr, _("Could not initialize `%s' subsystem.\n"), "FS");
 274     GNUNET_FS_uri_destroy (uri);
 275     ret = 1;
 276     return;
 277   }
 278   if (output_filename != NULL)
 279     db = GNUNET_FS_directory_builder_create (NULL);
 280   options = GNUNET_FS_SEARCH_OPTION_NONE;
 281   if (local_only)
 282     options |= GNUNET_FS_SEARCH_OPTION_LOOPBACK_ONLY;
 283   sc = GNUNET_FS_search_start (ctx, uri, anonymity, options, NULL);
 284   GNUNET_FS_uri_destroy (uri);
 285   if (NULL == sc)
 286   {
 287     FPRINTF (stderr, "%s",  _("Could not start searching.\n"));
 288     GNUNET_FS_stop (ctx);
 289     ret = 1;
 290     return;
 291   }
 292   if (0 != timeout.rel_value_us)
 293     tt = GNUNET_SCHEDULER_add_delayed (timeout,
 294                                        &timeout_task,
 295                                        NULL);
 296   GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
 297                                  NULL);
 298 }
 299
 300
 301 /**
 302  * The main function to search GNUnet.
 303  *
 304  * @param argc number of arguments from the command line
 305  * @param argv command line arguments
 306  * @return 0 ok, 1 on error
 307  */
 308 int
 309 main (int argc, char *const *argv)
 310 {
 311   struct GNUNET_GETOPT_CommandLineOption options[] = {
 312     GNUNET_GETOPT_option_uint ('a',
 313                                "anonymity",
 314                                "LEVEL",
 315                                gettext_noop ("set the desired LEVEL of receiver-anonymity"),
 316                                &anonymity),
 317     GNUNET_GETOPT_option_flag ('n',
 318                                "no-network",
 319                                gettext_noop ("only search the local peer (no P2P network search)"),
 320                                &local_only),
 321     GNUNET_GETOPT_option_string ('o',
 322                                  "output",
 323                                  "PREFIX",
 324                                  gettext_noop ("write search results to file starting with PREFIX"),
 325                                  &output_filename),
 326     GNUNET_GETOPT_option_relative_time ('t',
 327                                         "timeout",
 328                                         "DELAY",
 329                                         gettext_noop ("automatically terminate search after DELAY"),
 330                                         &timeout),
 331     GNUNET_GETOPT_option_verbose (&verbose),
 332     GNUNET_GETOPT_option_uint ('N',
 333                                "results",
 334                                "VALUE",
 335                                gettext_noop ("automatically terminate search "
 336                                              "after VALUE results are found"),
 337                                &results_limit),
 338     GNUNET_GETOPT_OPTION_END
 339   };
 340
 341   if (GNUNET_OK !=
 342       GNUNET_STRINGS_get_utf8_args (argc, argv,
 343                                     &argc, &argv))
 344     return 2;
 345
 346   ret = (GNUNET_OK ==
 347          GNUNET_PROGRAM_run (argc,
 348                              argv,
 349                              "gnunet-search [OPTIONS] KEYWORD",
 350                              gettext_noop
 351                              ("Search GNUnet for files that were published on GNUnet"),
 352                              options, &run, NULL)) ? ret : 1;
 353   GNUNET_free ((void*) argv);
 354   return ret;
 355 }
 356
 357 /* end of gnunet-search.c */