src/fs/gnunet-directory.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2001, 2002, 2004, 2005, 2006, 2007, 2009 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      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      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20 /**
  21  * @file fs/gnunet-directory.c
  22  * @brief display content of GNUnet directories
  23  * @author Christian Grothoff
  24  */
  25 #include "platform.h"
  26 #include "gnunet_fs_service.h"
  27
  28 static int ret;
  29
  30 /**
  31  * Print a meta data entry.
  32  *
  33  * @param cls closure (unused)
  34  * @param plugin_name name of the plugin that generated the meta data
  35  * @param type type of the keyword
  36  * @param format format of data
  37  * @param data_mime_type mime type of data
  38  * @param data value of the meta data
  39  * @param data_size number of bytes in data
  40  * @return always 0 (to continue iterating)
  41  */
  42 static int
  43 item_printer (void *cls,
  44               const char *plugin_name,
  45               enum EXTRACTOR_MetaType type,
  46               enum EXTRACTOR_MetaFormat format,
  47               const char *data_mime_type,
  48               const char *data,
  49               size_t data_size)
  50 {
  51   if (type == EXTRACTOR_METATYPE_GNUNET_FULL_DATA)
  52     {
  53       printf(_("\t<original file embedded in %u bytes of meta data>\n"),
  54              (unsigned int) data_size);
  55       return 0;
  56     }
  57   if ( (format != EXTRACTOR_METAFORMAT_UTF8) &&
  58        (format != EXTRACTOR_METAFORMAT_C_STRING) )
  59     return 0;
  60   if (type == EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME)
  61     return 0;
  62   printf ("\t%20s: %s\n",
  63           dgettext (LIBEXTRACTOR_GETTEXT_DOMAIN,
  64                     EXTRACTOR_metatype_to_string (type)), data);
  65   return 0;
  66 }
  67
  68
  69
  70 /**
  71  * Print an entry in a directory.
  72  *
  73  * @param cls closure (not used)
  74  * @param filename name of the file in the directory
  75  * @param uri URI of the file
  76  * @param meta metadata for the file; metadata for
  77  *        the directory if everything else is NULL/zero
  78  * @param length length of the available data for the file
  79  *           (of type size_t since data must certainly fit
  80  *            into memory; if files are larger than size_t
  81  *            permits, then they will certainly not be
  82  *            embedded with the directory itself).
  83  * @param data data available for the file (length bytes)
  84  */
  85 static void
  86 print_entry (void *cls,
  87              const char *filename,
  88              const struct GNUNET_FS_Uri *uri,
  89              const struct GNUNET_CONTAINER_MetaData *meta,
  90              size_t length,
  91              const void *data)
  92 {
  93   char *string;
  94   char *name;
  95
  96   name = GNUNET_CONTAINER_meta_data_get_by_type (meta,
  97                                                  EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME);
  98   if (uri == NULL)
  99     {
 100       printf (_("Directory `%s' meta data:\n"),
 101               name);
 102       GNUNET_CONTAINER_meta_data_iterate (meta,
 103                                           &item_printer,
 104                                           NULL);
 105       printf ("\n");
 106       printf (_("Directory `%s' contents:\n"),
 107               name);
 108       GNUNET_free (name);
 109       return;
 110     }
 111   string = GNUNET_FS_uri_to_string (uri);
 112   printf ("%s (%s):\n", name, string);
 113   GNUNET_free (string);
 114   GNUNET_CONTAINER_meta_data_iterate (meta,
 115                                       &item_printer,
 116                                       NULL);
 117   printf ("\n");
 118   GNUNET_free (name);
 119 }
 120
 121
 122 /**
 123  * Main function that will be run by the scheduler.
 124  *
 125  * @param cls closure
 126  * @param args remaining command-line arguments
 127  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
 128  * @param cfg configuration
 129  */
 130 static void
 131 run (void *cls,
 132      char *const *args,
 133      const char *cfgfile,
 134      const struct GNUNET_CONFIGURATION_Handle *cfg)
 135 {
 136   struct GNUNET_DISK_MapHandle *map;
 137   struct GNUNET_DISK_FileHandle *h;
 138   void *data;
 139   size_t len;
 140   uint64_t size;
 141   const char *filename;
 142   int i;
 143
 144   if (NULL == args[0])
 145     {
 146       fprintf (stderr,
 147                _("You must specify a filename to inspect."));
 148       ret = 1;
 149       return;
 150     }
 151   i = 0;
 152   while (NULL != (filename = args[i++]))
 153     {
 154       if ( (GNUNET_OK !=
 155             GNUNET_DISK_file_size (filename,
 156                                    &size,
 157                                    GNUNET_YES)) ||
 158            (NULL == (h = GNUNET_DISK_file_open (filename,
 159                                                 GNUNET_DISK_OPEN_READ,
 160                                                 GNUNET_DISK_PERM_NONE))) )
 161         {
 162           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 163                       _("Failed to read directory `%s'\n"),
 164                       filename);
 165           ret = 1;
 166           continue;
 167         }
 168       len = (size_t) size;
 169       data = GNUNET_DISK_file_map (h,
 170                                    &map,
 171                                    GNUNET_DISK_MAP_TYPE_READ,
 172                                    len);
 173       GNUNET_assert (NULL != data);
 174       GNUNET_FS_directory_list_contents (len,
 175                                          data,
 176                                          0,
 177                                          &print_entry,
 178                                          NULL);
 179       printf ("\n");
 180       GNUNET_DISK_file_unmap (map);
 181       GNUNET_DISK_file_close (h);
 182     }
 183 }
 184
 185 /**
 186  * The main function to inspect GNUnet directories.
 187  *
 188  * @param argc number of arguments from the command line
 189  * @param argv command line arguments
 190  * @return 0 ok, 1 on error
 191  */
 192 int
 193 main (int argc, char *const *argv)
 194 {
 195   static struct GNUNET_GETOPT_CommandLineOption options[] = {
 196     GNUNET_GETOPT_OPTION_END
 197   };
 198   return (GNUNET_OK ==
 199           GNUNET_PROGRAM_run (argc,
 200                               argv,
 201                               "gnunet-directory",
 202                               gettext_noop
 203                               ("Display GNUnet directories."),
 204                               options, &run, NULL)) ? ret : 1;
 205 }
 206
 207 /* end of gnunet-directory.c */