src/namecache/plugin_namecache_flat.c

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