src/namecache/plugin_namecache_flat.c

   1  /*
   2   * This file is part of GNUnet
   3   * Copyright (C) 2009-2015 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., 51 Franklin Street, Fifth Floor,
  18   * Boston, MA 02110-1301, USA.
  19   */
  20
  21 /**
  22  * @file namecache/plugin_namecache_flat.c
  23  * @brief flat file-based namecache backend
  24  * @author Martin Schanzenbach
  25  */
  26
  27 #include "platform.h"
  28 #include "gnunet_namecache_plugin.h"
  29 #include "gnunet_namecache_service.h"
  30 #include "gnunet_gnsrecord_lib.h"
  31 #include "namecache.h"
  32
  33 /**
  34  * Context for all functions in this plugin.
  35  */
  36 struct Plugin
  37 {
  38
  39   const struct GNUNET_CONFIGURATION_Handle *cfg;
  40
  41   /**
  42    * Database filename.
  43    */
  44   char *fn;
  45
  46   /**
  47    * HashMap
  48    */
  49   struct GNUNET_CONTAINER_MultiHashMap *hm;
  50
  51 };
  52
  53 struct FlatFileEntry
  54 {
  55   /**
  56    * Block
  57    */
  58   struct GNUNET_GNSRECORD_Block *block;
  59
  60   /**
  61    * query
  62    */
  63   struct GNUNET_HashCode query;
  64
  65 };
  66
  67 /**
  68  * Initialize the database connections and associated
  69  * data structures (create tables and indices
  70  * as needed as well).
  71  *
  72  * @param plugin the plugin context (state for this module)
  73  * @return #GNUNET_OK on success
  74  */
  75 static int
  76 database_setup (struct Plugin *plugin)
  77 {
  78   char *afsdir;
  79   char* block_buffer;
  80   char* buffer;
  81   char* line;
  82   char* query;
  83   char* block;
  84   size_t size;
  85   struct FlatFileEntry *entry;
  86   struct GNUNET_DISK_FileHandle *fh;
  87
  88   if (GNUNET_OK !=
  89       GNUNET_CONFIGURATION_get_value_filename (plugin->cfg, "namecache-flat",
  90                                                "FILENAME", &afsdir))
  91   {
  92     GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
  93                                "namecache-flat", "FILENAME");
  94     return GNUNET_SYSERR;
  95   }
  96   if (GNUNET_OK != GNUNET_DISK_file_test (afsdir))
  97   {
  98     if (GNUNET_OK != GNUNET_DISK_directory_create_for_file (afsdir))
  99     {
 100       GNUNET_break (0);
 101       GNUNET_free (afsdir);
 102       return GNUNET_SYSERR;
 103     }
 104   }
 105   /* afsdir should be UTF-8-encoded. If it isn't, it's a bug */
 106   plugin->fn = afsdir;
 107
 108   /* Load data from file into hashmap */
 109   plugin->hm = GNUNET_CONTAINER_multihashmap_create (10,
 110                                                      GNUNET_NO);
 111   fh = GNUNET_DISK_file_open (afsdir,
 112                               GNUNET_DISK_OPEN_CREATE |
 113                               GNUNET_DISK_OPEN_READWRITE,
 114                               GNUNET_DISK_PERM_USER_WRITE |
 115                               GNUNET_DISK_PERM_USER_READ);
 116   if (NULL == fh)
 117   {
 118     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 119                 _("Unable to initialize file: %s.\n"),
 120                 afsdir);
 121     return GNUNET_SYSERR;
 122   }
 123
 124   if (GNUNET_SYSERR == GNUNET_DISK_file_size (afsdir,
 125                                               &size,
 126                                               GNUNET_YES,
 127                                               GNUNET_YES))
 128   {
 129     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 130                 _("Unable to get filesize: %s.\n"),
 131                 afsdir);
 132     return GNUNET_SYSERR;
 133   }
 134
 135   if (0 == size)
 136     return GNUNET_OK;
 137
 138   buffer = GNUNET_malloc (size);
 139
 140   if (GNUNET_SYSERR == GNUNET_DISK_file_read (fh,
 141                                               buffer,
 142                                               size))
 143   {
 144     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 145                 _("Unable to read file: %s.\n"),
 146                 afsdir);
 147     return GNUNET_SYSERR;
 148   }
 149
 150   GNUNET_DISK_file_close (fh);
 151
 152   line = strtok ("\n", buffer);
 153   while (line != NULL) {
 154     query = strtok (",", line);
 155     block = strtok (NULL, line);
 156     line = strtok ("\n", buffer);
 157     entry = GNUNET_malloc (sizeof (struct FlatFileEntry));
 158     GNUNET_CRYPTO_hash_from_string (query,
 159                                     &entry->query);
 160     GNUNET_STRINGS_base64_decode (block,
 161                                   strlen (block),
 162                                   &block_buffer);
 163     entry->block = (struct GNUNET_GNSRECORD_Block *) block_buffer;
 164     if (GNUNET_OK !=
 165         GNUNET_CONTAINER_multihashmap_put (plugin->hm,
 166                                            &entry->query,
 167                                            entry,
 168                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
 169     {
 170       GNUNET_free (entry);
 171       GNUNET_break (0);
 172     }
 173   }
 174   GNUNET_free (buffer);
 175   return GNUNET_OK;
 176 }
 177
 178 /**
 179  * Store values in hashmap in file and free data
 180  *
 181  * @param plugin the plugin context
 182  */
 183 static int
 184 store_and_free_entries (void *cls,
 185                         const struct GNUNET_HashCode *key,
 186                         void *value)
 187 {
 188   struct GNUNET_DISK_FileHandle *fh = cls;
 189   struct FlatFileEntry *entry = value;
 190
 191   char *line;
 192   char *block_b64;
 193   struct GNUNET_CRYPTO_HashAsciiEncoded query;
 194   size_t block_size;
 195
 196   block_size = ntohl (entry->block->purpose.size) +
 197     sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey) +
 198     sizeof (struct GNUNET_CRYPTO_EcdsaSignature);
 199
 200   GNUNET_STRINGS_base64_encode ((char*)entry->block,
 201                                 block_size,
 202                                 &block_b64);
 203   GNUNET_CRYPTO_hash_to_enc (&entry->query,
 204                              &query);
 205   GNUNET_asprintf (&line,
 206                    "%s,%s\n",
 207                    (char*)&query,
 208                    block_b64);
 209
 210   GNUNET_free (block_b64);
 211
 212   GNUNET_DISK_file_write (fh,
 213                           line,
 214                           strlen (line));
 215
 216   GNUNET_free (entry->block);
 217   GNUNET_free (entry);
 218   return GNUNET_YES;
 219 }
 220
 221 /**
 222  * Shutdown database connection and associate data
 223  * structures.
 224  * @param plugin the plugin context (state for this module)
 225  */
 226 static void
 227 database_shutdown (struct Plugin *plugin)
 228 {
 229   struct GNUNET_DISK_FileHandle *fh;
 230   fh = GNUNET_DISK_file_open (plugin->fn,
 231                               GNUNET_DISK_OPEN_CREATE |
 232                               GNUNET_DISK_OPEN_TRUNCATE |
 233                               GNUNET_DISK_OPEN_READWRITE,
 234                               GNUNET_DISK_PERM_USER_WRITE |
 235                               GNUNET_DISK_PERM_USER_READ);
 236   if (NULL == fh)
 237   {
 238     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 239                 _("Unable to initialize file: %s.\n"),
 240                 plugin->fn);
 241     return;
 242   }
 243
 244   GNUNET_CONTAINER_multihashmap_iterate (plugin->hm,
 245                                          &store_and_free_entries,
 246                                          fh);
 247   GNUNET_CONTAINER_multihashmap_destroy (plugin->hm);
 248   GNUNET_DISK_file_close (fh);
 249
 250 }
 251
 252 static int
 253 expire_blocks (void *cls,
 254                const struct GNUNET_HashCode *key,
 255                void *value)
 256 {
 257   struct Plugin *plugin = cls;
 258   struct FlatFileEntry *entry = value;
 259   struct GNUNET_TIME_Absolute now;
 260   struct GNUNET_TIME_Absolute expiration;
 261
 262   now = GNUNET_TIME_absolute_get ();
 263   expiration = GNUNET_TIME_absolute_ntoh (entry->block->expiration_time);
 264
 265   if (0 == GNUNET_TIME_absolute_get_difference (now,
 266                                                 expiration).rel_value_us)
 267   {
 268     GNUNET_CONTAINER_multihashmap_remove_all (plugin->hm, key);
 269   }
 270   return GNUNET_YES;
 271 }
 272
 273
 274
 275 /**
 276  * Removes any expired block.
 277  *
 278  * @param plugin the plugin
 279  */
 280 static void
 281 namecache_expire_blocks (struct Plugin *plugin)
 282 {
 283   GNUNET_CONTAINER_multihashmap_iterate (plugin->hm,
 284                                          &expire_blocks,
 285                                          plugin);
 286 }
 287
 288
 289 /**
 290  * Cache a block in the datastore.
 291  *
 292  * @param cls closure (internal context for the plugin)
 293  * @param block block to cache
 294  * @return #GNUNET_OK on success, else #GNUNET_SYSERR
 295  */
 296 static int
 297 namecache_cache_block (void *cls,
 298                               const struct GNUNET_GNSRECORD_Block *block)
 299 {
 300   struct Plugin *plugin = cls;
 301   struct GNUNET_HashCode query;
 302   struct FlatFileEntry *entry;
 303   size_t block_size;
 304
 305   namecache_expire_blocks (plugin);
 306   GNUNET_CRYPTO_hash (&block->derived_key,
 307                       sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey),
 308                       &query);
 309   block_size = ntohl (block->purpose.size) +
 310     sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey) +
 311     sizeof (struct GNUNET_CRYPTO_EcdsaSignature);
 312   if (block_size > 64 * 65536)
 313   {
 314     GNUNET_break (0);
 315     return GNUNET_SYSERR;
 316   }
 317   entry = GNUNET_malloc (sizeof (struct FlatFileEntry));
 318   entry->block = GNUNET_malloc (block_size);
 319   memcpy (entry->block, block, block_size);
 320   GNUNET_CONTAINER_multihashmap_remove_all (plugin->hm, &query);
 321   if (GNUNET_OK !=
 322       GNUNET_CONTAINER_multihashmap_put (plugin->hm,
 323                                          &query,
 324                                          entry,
 325                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
 326   {
 327     GNUNET_free (entry);
 328     GNUNET_break (0);
 329     return GNUNET_SYSERR;
 330   }
 331   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 332               "Caching block under derived key `%s'\n",
 333               GNUNET_h2s_full (&query));
 334   return GNUNET_OK;
 335 }
 336
 337
 338 /**
 339  * Get the block for a particular zone and label in the
 340  * datastore.  Will return at most one result to the iterator.
 341  *
 342  * @param cls closure (internal context for the plugin)
 343  * @param query hash of public key derived from the zone and the label
 344  * @param iter function to call with the result
 345  * @param iter_cls closure for @a iter
 346  * @return #GNUNET_OK on success, #GNUNET_NO if there were no results, #GNUNET_SYSERR on error
 347  */
 348 static int
 349 namecache_lookup_block (void *cls,
 350                         const struct GNUNET_HashCode *query,
 351                         GNUNET_NAMECACHE_BlockCallback iter, void *iter_cls)
 352 {
 353   struct Plugin *plugin = cls;
 354   const struct GNUNET_GNSRECORD_Block *block;
 355
 356   block = GNUNET_CONTAINER_multihashmap_get (plugin->hm, query);
 357   if (NULL == block)
 358     return GNUNET_NO;
 359   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 360               "Found block under derived key `%s'\n",
 361               GNUNET_h2s_full (query));
 362   iter (iter_cls, block);
 363   return GNUNET_YES;
 364 }
 365
 366
 367 /**
 368  * Entry point for the plugin.
 369  *
 370  * @param cls the "struct GNUNET_NAMECACHE_PluginEnvironment*"
 371  * @return NULL on error, otherwise the plugin context
 372  */
 373 void *
 374 libgnunet_plugin_namecache_flat_init (void *cls)
 375 {
 376   static struct Plugin plugin;
 377   const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
 378   struct GNUNET_NAMECACHE_PluginFunctions *api;
 379
 380   if (NULL != plugin.cfg)
 381     return NULL;                /* can only initialize once! */
 382   memset (&plugin, 0, sizeof (struct Plugin));
 383   plugin.cfg = cfg;
 384   if (GNUNET_OK != database_setup (&plugin))
 385   {
 386     database_shutdown (&plugin);
 387     return NULL;
 388   }
 389   api = GNUNET_new (struct GNUNET_NAMECACHE_PluginFunctions);
 390   api->cls = &plugin;
 391   api->cache_block = &namecache_cache_block;
 392   api->lookup_block = &namecache_lookup_block;
 393   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 394        _("flat plugin running\n"));
 395   return api;
 396 }
 397
 398
 399 /**
 400  * Exit point from the plugin.
 401  *
 402  * @param cls the plugin context (as returned by "init")
 403  * @return always NULL
 404  */
 405 void *
 406 libgnunet_plugin_namecache_flat_done (void *cls)
 407 {
 408   struct GNUNET_NAMECACHE_PluginFunctions *api = cls;
 409   struct Plugin *plugin = api->cls;
 410
 411   database_shutdown (plugin);
 412   plugin->cfg = NULL;
 413   GNUNET_free (api);
 414   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 415        "flat plugin is finished\n");
 416   return NULL;
 417 }
 418
 419 /* end of plugin_namecache_sqlite.c */