src/namestore/plugin_namestore_flat.c

   1  /*
   2   * This file is part of GNUnet
   3   * Copyright (C) 2009-2015, 2018 GNUnet e.V.
   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 namestore/plugin_namestore_flat.c
  23  * @brief file-based namestore backend
  24  * @author Martin Schanzenbach
  25  * @author Christian Grothoff
  26  */
  27
  28 #include "platform.h"
  29 #include "gnunet_namestore_plugin.h"
  30 #include "gnunet_namestore_service.h"
  31 #include "gnunet_gnsrecord_lib.h"
  32 #include "namestore.h"
  33
  34 /**
  35  * Context for all functions in this plugin.
  36  */
  37 struct Plugin
  38 {
  39
  40   const struct GNUNET_CONFIGURATION_Handle *cfg;
  41
  42   /**
  43    * Database filename.
  44    */
  45   char *fn;
  46
  47   /**
  48    * HashMap
  49    */
  50   struct GNUNET_CONTAINER_MultiHashMap *hm;
  51
  52   /**
  53    * Offset
  54    */
  55   uint32_t offset;
  56
  57   /**
  58    * Target Offset
  59    */
  60   uint32_t target_offset;
  61
  62   /**
  63    * Iterator closure
  64    */
  65   void *iter_cls;
  66
  67   /**
  68    * Iterator
  69    */
  70   GNUNET_NAMESTORE_RecordIterator iter;
  71
  72   /**
  73    * Zone to iterate
  74    */
  75   const struct GNUNET_CRYPTO_EcdsaPrivateKey *iter_zone;
  76
  77   /**
  78    * PKEY to look for in zone to name
  79    */
  80   const struct GNUNET_CRYPTO_EcdsaPublicKey *iter_pkey;
  81
  82   /**
  83    * Iteration result found
  84    */
  85   int iter_result_found;
  86
  87 };
  88
  89
  90 struct FlatFileEntry
  91 {
  92   /**
  93    * Entry zone
  94    */
  95   struct GNUNET_CRYPTO_EcdsaPrivateKey *private_key;
  96
  97   /**
  98    * Record cound
  99    */
 100   uint32_t record_count;
 101
 102   /**
 103    * Rvalue
 104    */
 105   uint64_t rvalue;
 106
 107   /**
 108    * Record data
 109    */
 110   struct GNUNET_GNSRECORD_Data *record_data;
 111
 112   /**
 113    * Label
 114    */
 115   char *label;
 116
 117
 118 };
 119
 120
 121 /**
 122  * Initialize the database connections and associated
 123  * data structures (create tables and indices
 124  * as needed as well).
 125  *
 126  * @param plugin the plugin context (state for this module)
 127  * @return #GNUNET_OK on success
 128  */
 129 static int
 130 database_setup (struct Plugin *plugin)
 131 {
 132   char *afsdir;
 133   char *key;
 134   char *record_data;
 135   char *zone_private_key;
 136   char *record_data_b64;
 137   char *buffer;
 138   char *line;
 139   char *label;
 140   char *rvalue;
 141   char *record_count;
 142   size_t record_data_size;
 143   size_t size;
 144   size_t key_len;
 145   struct GNUNET_HashCode hkey;
 146   struct GNUNET_DISK_FileHandle *fh;
 147   struct FlatFileEntry *entry;
 148
 149   if (GNUNET_OK !=
 150       GNUNET_CONFIGURATION_get_value_filename (plugin->cfg,
 151                                                "namestore-flat",
 152                                                "FILENAME",
 153                                                &afsdir))
 154   {
 155     GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
 156                                "namestore-flat",
 157                                "FILENAME");
 158     return GNUNET_SYSERR;
 159   }
 160   if (GNUNET_OK !=
 161       GNUNET_DISK_file_test (afsdir))
 162   {
 163     if (GNUNET_OK !=
 164         GNUNET_DISK_directory_create_for_file (afsdir))
 165     {
 166       GNUNET_break (0);
 167       GNUNET_free (afsdir);
 168       return GNUNET_SYSERR;
 169     }
 170   }
 171   /* afsdir should be UTF-8-encoded. If it isn't, it's a bug */
 172   plugin->fn = afsdir;
 173
 174   /* Load data from file into hashmap */
 175   plugin->hm = GNUNET_CONTAINER_multihashmap_create (10,
 176                                                      GNUNET_NO);
 177   fh = GNUNET_DISK_file_open (afsdir,
 178                               GNUNET_DISK_OPEN_CREATE |
 179                               GNUNET_DISK_OPEN_READWRITE,
 180                               GNUNET_DISK_PERM_USER_WRITE |
 181                               GNUNET_DISK_PERM_USER_READ);
 182   if (NULL == fh)
 183   {
 184     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 185          _("Unable to initialize file: %s.\n"),
 186          afsdir);
 187     return GNUNET_SYSERR;
 188   }
 189   if (GNUNET_SYSERR ==
 190       GNUNET_DISK_file_size (afsdir,
 191                              &size,
 192                              GNUNET_YES,
 193                              GNUNET_YES))
 194   {
 195     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 196          _("Unable to get filesize: %s.\n"),
 197          afsdir);
 198     GNUNET_DISK_file_close (fh);
 199     return GNUNET_SYSERR;
 200   }
 201
 202   buffer = GNUNET_malloc (size + 1);
 203   if (GNUNET_SYSERR ==
 204       GNUNET_DISK_file_read (fh,
 205                              buffer,
 206                              size))
 207   {
 208     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 209          _("Unable to read file: %s.\n"),
 210          afsdir);
 211     GNUNET_free (buffer);
 212     GNUNET_DISK_file_close (fh);
 213     return GNUNET_SYSERR;
 214   }
 215   buffer[size] = '\0';
 216   GNUNET_DISK_file_close (fh);
 217
 218   if (0 < size)
 219   {
 220     line = strtok (buffer, "\n");
 221     while (line != NULL) {
 222       zone_private_key = strtok (line, ",");
 223       if (NULL == zone_private_key)
 224         break;
 225       rvalue = strtok (NULL, ",");
 226       if (NULL == rvalue)
 227         break;
 228       record_count = strtok (NULL, ",");
 229       if (NULL == record_count)
 230         break;
 231       record_data_b64 = strtok (NULL, ",");
 232       if (NULL == record_data_b64)
 233         break;
 234       label = strtok (NULL, ",");
 235       if (NULL == label)
 236         break;
 237       line = strtok (NULL, "\n");
 238       entry = GNUNET_new (struct FlatFileEntry);
 239       if (1 != sscanf (rvalue,
 240                        "%lu",
 241                        &entry->rvalue))
 242       {
 243         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 244                     "Error parsing entry\n");
 245         GNUNET_free (entry);
 246         break;
 247       }
 248       if (1 != sscanf (record_count,
 249                        "%u",
 250                        &entry->record_count))
 251       {
 252         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 253                     "Error parsing entry\n");
 254         GNUNET_free (entry);
 255         break;
 256       }
 257       entry->label = GNUNET_strdup (label);
 258       record_data_size
 259         = GNUNET_STRINGS_base64_decode (record_data_b64,
 260                                         strlen (record_data_b64),
 261                                         &record_data);
 262       entry->record_data =
 263         GNUNET_new_array (entry->record_count,
 264                           struct GNUNET_GNSRECORD_Data);
 265       if (GNUNET_OK !=
 266           GNUNET_GNSRECORD_records_deserialize (record_data_size,
 267                                                 record_data,
 268                                                 entry->record_count,
 269                                                 entry->record_data))
 270       {
 271         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 272                     "Unable to deserialize record %s\n",
 273                     label);
 274         GNUNET_free (entry->label);
 275         GNUNET_free (entry);
 276         GNUNET_free (record_data);
 277         break;
 278       }
 279       GNUNET_free (record_data);
 280       GNUNET_STRINGS_base64_decode (zone_private_key,
 281                                     strlen (zone_private_key),
 282                                     (char**)&entry->private_key);
 283       key_len = strlen (label) + sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey);
 284       key = GNUNET_malloc (strlen (label) + sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey));
 285       GNUNET_memcpy (key,
 286                      label,
 287                      strlen (label));
 288       GNUNET_memcpy (key+strlen(label),
 289                      entry->private_key,
 290                      sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey));
 291       GNUNET_CRYPTO_hash (key,
 292                           key_len,
 293                           &hkey);
 294       GNUNET_free (key);
 295       if (GNUNET_OK !=
 296           GNUNET_CONTAINER_multihashmap_put (plugin->hm,
 297                                              &hkey,
 298                                              entry,
 299                                              GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
 300       {
 301         GNUNET_free (entry);
 302         GNUNET_break (0);
 303       }
 304     }
 305   }
 306   GNUNET_free (buffer);
 307   return GNUNET_OK;
 308 }
 309
 310
 311 /**
 312  * Store values in hashmap in file and free data
 313  *
 314  * @param plugin the plugin context
 315  * @param key key in the map
 316  * @param value a `struct FlatFileEntry`
 317  */
 318 static int
 319 store_and_free_entries (void *cls,
 320                         const struct GNUNET_HashCode *key,
 321                         void *value)
 322 {
 323   struct GNUNET_DISK_FileHandle *fh = cls;
 324   struct FlatFileEntry *entry = value;
 325   char *line;
 326   char *zone_private_key;
 327   char *record_data_b64;
 328   size_t data_size;
 329
 330   (void) key;
 331   GNUNET_STRINGS_base64_encode ((char*)entry->private_key,
 332                                 sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey),
 333                                 &zone_private_key);
 334   data_size = GNUNET_GNSRECORD_records_get_size (entry->record_count,
 335                                                  entry->record_data);
 336   {
 337     char data[data_size];
 338     ssize_t ret;
 339
 340     ret = GNUNET_GNSRECORD_records_serialize (entry->record_count,
 341                                               entry->record_data,
 342                                               data_size,
 343                                               data);
 344     if ( (ret < 0) ||
 345          (data_size != (size_t) ret) )
 346     {
 347       GNUNET_break (0);
 348       GNUNET_free (zone_private_key);
 349       return GNUNET_SYSERR;
 350     }
 351     GNUNET_STRINGS_base64_encode (data,
 352                                   data_size,
 353                                   &record_data_b64);
 354   }
 355   GNUNET_asprintf (&line,
 356                    "%s,%lu,%u,%s,%s\n",
 357                    zone_private_key,
 358                    entry->rvalue,
 359                    entry->record_count,
 360                    record_data_b64,
 361                    entry->label);
 362   GNUNET_free (record_data_b64);
 363   GNUNET_free (zone_private_key);
 364
 365   GNUNET_DISK_file_write (fh,
 366                           line,
 367                           strlen (line));
 368
 369   GNUNET_free (line);
 370   GNUNET_free (entry->private_key);
 371   GNUNET_free (entry->label);
 372   GNUNET_free (entry->record_data);
 373   GNUNET_free (entry);
 374   return GNUNET_YES;
 375 }
 376
 377
 378 /**
 379  * Shutdown database connection and associate data
 380  * structures.
 381  * @param plugin the plugin context (state for this module)
 382  */
 383 static void
 384 database_shutdown (struct Plugin *plugin)
 385 {
 386   struct GNUNET_DISK_FileHandle *fh;
 387
 388   fh = GNUNET_DISK_file_open (plugin->fn,
 389                               GNUNET_DISK_OPEN_CREATE |
 390                               GNUNET_DISK_OPEN_TRUNCATE |
 391                               GNUNET_DISK_OPEN_READWRITE,
 392                               GNUNET_DISK_PERM_USER_WRITE |
 393                               GNUNET_DISK_PERM_USER_READ);
 394   if (NULL == fh)
 395   {
 396     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 397                 _("Unable to initialize file: %s.\n"),
 398                 plugin->fn);
 399     return;
 400   }
 401
 402   GNUNET_CONTAINER_multihashmap_iterate (plugin->hm,
 403                                          &store_and_free_entries,
 404                                          fh);
 405   GNUNET_CONTAINER_multihashmap_destroy (plugin->hm);
 406   GNUNET_DISK_file_close (fh);
 407 }
 408
 409
 410 /**
 411  * Store a record in the datastore.  Removes any existing record in the
 412  * same zone with the same name.
 413  *
 414  * @param cls closure (internal context for the plugin)
 415  * @param zone_key private key of the zone
 416  * @param label name that is being mapped (at most 255 characters long)
 417  * @param rd_count number of entries in @a rd array
 418  * @param rd array of records with data to store
 419  * @return #GNUNET_OK on success, else #GNUNET_SYSERR
 420  */
 421 static int
 422 namestore_flat_store_records (void *cls,
 423                               const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
 424                               const char *label,
 425                               unsigned int rd_count,
 426                               const struct GNUNET_GNSRECORD_Data *rd)
 427 {
 428   struct Plugin *plugin = cls;
 429   uint64_t rvalue;
 430   size_t key_len;
 431   char *key;
 432   struct GNUNET_HashCode hkey;
 433   struct FlatFileEntry *entry;
 434
 435   rvalue = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
 436                                      UINT64_MAX);
 437   key_len = strlen (label) + sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey);
 438   key = GNUNET_malloc (key_len);
 439   GNUNET_memcpy (key, label, strlen (label));
 440   GNUNET_memcpy (key+strlen(label),
 441           zone_key,
 442           sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey));
 443   GNUNET_CRYPTO_hash (key,
 444                       key_len,
 445                       &hkey);
 446
 447   GNUNET_CONTAINER_multihashmap_remove_all (plugin->hm, &hkey);
 448
 449   if (0 < rd_count)
 450   {
 451     entry = GNUNET_new (struct FlatFileEntry);
 452     entry->private_key = GNUNET_new (struct GNUNET_CRYPTO_EcdsaPrivateKey);
 453     GNUNET_asprintf (&entry->label,
 454                      label,
 455                      strlen (label));
 456     GNUNET_memcpy (entry->private_key,
 457                    zone_key,
 458                    sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey));
 459     entry->rvalue = rvalue;
 460     entry->record_count = rd_count;
 461     entry->record_data = GNUNET_new_array (rd_count,
 462                                            struct GNUNET_GNSRECORD_Data);
 463     for (unsigned int i = 0; i < rd_count; i++)
 464     {
 465       entry->record_data[i].expiration_time = rd[i].expiration_time;
 466       entry->record_data[i].record_type = rd[i].record_type;
 467       entry->record_data[i].flags = rd[i].flags;
 468       entry->record_data[i].data_size = rd[i].data_size;
 469       entry->record_data[i].data = GNUNET_malloc (rd[i].data_size);
 470       GNUNET_memcpy ((char*)entry->record_data[i].data, rd[i].data, rd[i].data_size);
 471     }
 472     return GNUNET_CONTAINER_multihashmap_put (plugin->hm,
 473                                               &hkey,
 474                                               entry,
 475                                               GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
 476   }
 477   return GNUNET_NO;
 478 }
 479
 480
 481 /**
 482  * Lookup records in the datastore for which we are the authority.
 483  *
 484  * @param cls closure (internal context for the plugin)
 485  * @param zone private key of the zone
 486  * @param label name of the record in the zone
 487  * @param iter function to call with the result
 488  * @param iter_cls closure for @a iter
 489  * @return #GNUNET_OK on success, else #GNUNET_SYSERR
 490  */
 491 static int
 492 namestore_flat_lookup_records (void *cls,
 493                                const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
 494                                const char *label,
 495                                GNUNET_NAMESTORE_RecordIterator iter,
 496                                void *iter_cls)
 497 {
 498   struct Plugin *plugin = cls;
 499   struct FlatFileEntry *entry;
 500   struct GNUNET_HashCode hkey;
 501   char *key;
 502   size_t key_len;
 503
 504   if (NULL == zone)
 505     return GNUNET_SYSERR;
 506   key_len = strlen (label) + sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey);
 507   key = GNUNET_malloc (key_len);
 508   GNUNET_memcpy (key,
 509                  label,
 510                  strlen (label));
 511   GNUNET_memcpy (key+strlen(label),
 512                  zone,
 513                  sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey));
 514   GNUNET_CRYPTO_hash (key,
 515                       key_len,
 516                       &hkey);
 517   GNUNET_free (key);
 518
 519   entry = GNUNET_CONTAINER_multihashmap_get (plugin->hm,
 520                                              &hkey);
 521
 522   if (NULL == entry)
 523     return GNUNET_NO;
 524   if (NULL != iter)
 525     iter (iter_cls,
 526           0,
 527           entry->private_key,
 528           entry->label,
 529           entry->record_count,
 530           entry->record_data);
 531   return GNUNET_YES;
 532 }
 533
 534
 535 /**
 536  * Closure for #iterate_zones.
 537  */
 538 struct IterateContext
 539 {
 540   /**
 541    * How many more records should we skip before returning results?
 542    */
 543   uint64_t offset;
 544
 545   /**
 546    * How many more records should we return?
 547    */
 548   uint64_t limit;
 549
 550   /**
 551    * What is the position of the current entry, counting
 552    * starts from 1.
 553    */
 554   uint64_t pos;
 555
 556   /**
 557    * Target zone.
 558    */
 559   const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone;
 560
 561   /**
 562    * Function to call on each record.
 563    */
 564   GNUNET_NAMESTORE_RecordIterator iter;
 565
 566   /**
 567    * Closure for @e iter.
 568    */
 569   void *iter_cls;
 570
 571 };
 572
 573
 574 /**
 575  * Helper function for #namestore_flat_iterate_records().
 576  *
 577  * @param cls a `struct IterateContext`
 578  * @param key unused
 579  * @param value a `struct FlatFileEntry`
 580  * @return #GNUNET_YES to continue the iteration
 581  */
 582 static int
 583 iterate_zones (void *cls,
 584                const struct GNUNET_HashCode *key,
 585                void *value)
 586 {
 587   struct IterateContext *ic = cls;
 588   struct FlatFileEntry *entry = value;
 589
 590   (void) key;
 591   ic->pos++;
 592   if (0 == ic->limit)
 593     return GNUNET_NO;
 594   if ( (NULL != ic->zone) &&
 595        (0 != memcmp (entry->private_key,
 596                      ic->zone,
 597                      sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey))) )
 598     return GNUNET_YES;
 599   if (ic->offset > 0)
 600   {
 601     ic->offset--;
 602     return GNUNET_YES;
 603   }
 604   ic->iter (ic->iter_cls,
 605             ic->pos,
 606             entry->private_key,
 607             entry->label,
 608             entry->record_count,
 609             entry->record_data);
 610   ic->limit--;
 611   if (0 == ic->limit)
 612     return GNUNET_NO;
 613   return GNUNET_YES;
 614 }
 615
 616
 617 /**
 618  * Iterate over the results for a particular key and zone in the
 619  * datastore.  Will return at most one result to the iterator.
 620  *
 621  * @param cls closure (internal context for the plugin)
 622  * @param zone hash of public key of the zone, NULL to iterate over all zones
 623  * @param serial serial number to exclude in the list of all matching records
 624  * @param limit maximum number of results to return to @a iter
 625  * @param iter function to call with the result
 626  * @param iter_cls closure for @a iter
 627  * @return #GNUNET_OK on success, #GNUNET_NO if there were no more results, #GNUNET_SYSERR on error
 628  */
 629 static int
 630 namestore_flat_iterate_records (void *cls,
 631                                 const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
 632                                 uint64_t serial,
 633                                 uint64_t limit,
 634                                 GNUNET_NAMESTORE_RecordIterator iter,
 635                                 void *iter_cls)
 636 {
 637   struct Plugin *plugin = cls;
 638   struct IterateContext ic;
 639
 640   ic.offset = serial;
 641   ic.pos = 0;
 642   ic.limit = limit;
 643   ic.iter = iter;
 644   ic.iter_cls = iter_cls;
 645   ic.zone = zone;
 646   GNUNET_CONTAINER_multihashmap_iterate (plugin->hm,
 647                                          &iterate_zones,
 648                                          &ic);
 649   return (0 == ic.limit) ? GNUNET_OK : GNUNET_NO;
 650 }
 651
 652
 653 static int
 654 zone_to_name (void *cls,
 655               const struct GNUNET_HashCode *key,
 656               void *value)
 657 {
 658   struct Plugin *plugin = cls;
 659   struct FlatFileEntry *entry = value;
 660
 661   (void) key;
 662   if (0 != memcmp (entry->private_key,
 663                    plugin->iter_zone,
 664                    sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey)))
 665     return GNUNET_YES;
 666
 667   for (unsigned int i = 0; i < entry->record_count; i++)
 668   {
 669     if (GNUNET_GNSRECORD_TYPE_PKEY != entry->record_data[i].record_type)
 670       continue;
 671     if (0 == memcmp (plugin->iter_pkey,
 672                      entry->record_data[i].data,
 673                      sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey)))
 674     {
 675       plugin->iter (plugin->iter_cls,
 676                     0,
 677                     entry->private_key,
 678                     entry->label,
 679                     entry->record_count,
 680                     entry->record_data);
 681       plugin->iter_result_found = GNUNET_YES;
 682
 683     }
 684   }
 685   return GNUNET_YES;
 686 }
 687
 688
 689 /**
 690  * Look for an existing PKEY delegation record for a given public key.
 691  * Returns at most one result to the iterator.
 692  *
 693  * @param cls closure (internal context for the plugin)
 694  * @param zone private key of the zone to look up in, never NULL
 695  * @param value_zone public key of the target zone (value), never NULL
 696  * @param iter function to call with the result
 697  * @param iter_cls closure for @a iter
 698  * @return #GNUNET_OK on success, #GNUNET_NO if there were no results, #GNUNET_SYSERR on error
 699  */
 700 static int
 701 namestore_flat_zone_to_name (void *cls,
 702                              const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
 703                              const struct GNUNET_CRYPTO_EcdsaPublicKey *value_zone,
 704                              GNUNET_NAMESTORE_RecordIterator iter,
 705                              void *iter_cls)
 706 {
 707   struct Plugin *plugin = cls;
 708
 709   /* FIXME: maybe use separate closure to better handle
 710      recursive calls? */
 711   plugin->iter = iter;
 712   plugin->iter_cls = iter_cls;
 713   plugin->iter_zone = zone;
 714   plugin->iter_pkey = value_zone;
 715   plugin->iter_result_found = GNUNET_NO;
 716   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 717               "Performing reverse lookup for `%s'\n",
 718               GNUNET_GNSRECORD_z2s (value_zone));
 719   GNUNET_CONTAINER_multihashmap_iterate (plugin->hm,
 720                                          &zone_to_name,
 721                                          plugin);
 722   return plugin->iter_result_found;
 723 }
 724
 725
 726 /**
 727  * Entry point for the plugin.
 728  *
 729  * @param cls the "struct GNUNET_NAMESTORE_PluginEnvironment*"
 730  * @return NULL on error, otherwise the plugin context
 731  */
 732 void *
 733 libgnunet_plugin_namestore_flat_init (void *cls)
 734 {
 735   static struct Plugin plugin;
 736   const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
 737   struct GNUNET_NAMESTORE_PluginFunctions *api;
 738
 739   if (NULL != plugin.cfg)
 740     return NULL;                /* can only initialize once! */
 741   memset (&plugin,
 742           0,
 743           sizeof (struct Plugin));
 744   plugin.cfg = cfg;
 745   if (GNUNET_OK != database_setup (&plugin))
 746   {
 747     database_shutdown (&plugin);
 748     return NULL;
 749   }
 750   api = GNUNET_new (struct GNUNET_NAMESTORE_PluginFunctions);
 751   api->cls = &plugin;
 752   api->store_records = &namestore_flat_store_records;
 753   api->iterate_records = &namestore_flat_iterate_records;
 754   api->zone_to_name = &namestore_flat_zone_to_name;
 755   api->lookup_records = &namestore_flat_lookup_records;
 756   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 757               _("flat file database running\n"));
 758   return api;
 759 }
 760
 761
 762 /**
 763  * Exit point from the plugin.
 764  *
 765  * @param cls the plugin context (as returned by "init")
 766  * @return always NULL
 767  */
 768 void *
 769 libgnunet_plugin_namestore_flat_done (void *cls)
 770 {
 771   struct GNUNET_NAMESTORE_PluginFunctions *api = cls;
 772   struct Plugin *plugin = api->cls;
 773
 774   database_shutdown (plugin);
 775   plugin->cfg = NULL;
 776   GNUNET_free (api);
 777   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 778               "flat file plugin is finished\n");
 779   return NULL;
 780 }
 781
 782 /* end of plugin_namestore_flat.c */