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           entry->private_key,
 527           entry->label,
 528           entry->record_count,
 529           entry->record_data);
 530   return GNUNET_YES;
 531 }
 532
 533
 534 /**
 535  * Closure for #iterate_zones.
 536  */
 537 struct IterateContext
 538 {
 539   /**
 540    * How many more records should we skip before returning results?
 541    */
 542   uint64_t offset;
 543
 544   /**
 545    * How many more records should we return?
 546    */
 547   uint64_t limit;
 548
 549   /**
 550    * Target zone.
 551    */
 552   const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone;
 553
 554   /**
 555    * Function to call on each record.
 556    */
 557   GNUNET_NAMESTORE_RecordIterator iter;
 558
 559   /**
 560    * Closure for @e iter.
 561    */
 562   void *iter_cls;
 563
 564 };
 565
 566
 567 /**
 568  * Helper function for #namestore_flat_iterate_records().
 569  *
 570  * @param cls a `struct IterateContext`
 571  * @param key unused
 572  * @param value a `struct FlatFileEntry`
 573  * @return #GNUNET_YES to continue the iteration
 574  */
 575 static int
 576 iterate_zones (void *cls,
 577                const struct GNUNET_HashCode *key,
 578                void *value)
 579 {
 580   struct IterateContext *ic = cls;
 581   struct FlatFileEntry *entry = value;
 582
 583   (void) key;
 584   if (0 == ic->limit)
 585     return GNUNET_NO;
 586   if ( (NULL != ic->zone) &&
 587        (0 != memcmp (entry->private_key,
 588                      ic->zone,
 589                      sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey))) )
 590     return GNUNET_YES;
 591   if (ic->offset > 0)
 592   {
 593     ic->offset--;
 594     return GNUNET_YES;
 595   }
 596   ic->iter (ic->iter_cls,
 597             entry->private_key,
 598             entry->label,
 599             entry->record_count,
 600             entry->record_data);
 601   ic->limit--;
 602   if (0 == ic->limit)
 603     return GNUNET_NO;
 604   return GNUNET_YES;
 605 }
 606
 607
 608 /**
 609  * Iterate over the results for a particular key and zone in the
 610  * datastore.  Will return at most one result to the iterator.
 611  *
 612  * @param cls closure (internal context for the plugin)
 613  * @param zone hash of public key of the zone, NULL to iterate over all zones
 614  * @param offset offset in the list of all matching records
 615  * @param limit maximum number of results to return to @a iter
 616  * @param iter function to call with the result
 617  * @param iter_cls closure for @a iter
 618  * @return #GNUNET_OK on success, #GNUNET_NO if there were no more results, #GNUNET_SYSERR on error
 619  */
 620 static int
 621 namestore_flat_iterate_records (void *cls,
 622                                 const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
 623                                 uint64_t offset,
 624                                 uint64_t limit,
 625                                 GNUNET_NAMESTORE_RecordIterator iter,
 626                                 void *iter_cls)
 627 {
 628   struct Plugin *plugin = cls;
 629   struct IterateContext ic;
 630
 631   ic.offset = offset;
 632   ic.limit = limit;
 633   ic.iter = iter;
 634   ic.iter_cls = iter_cls;
 635   ic.zone = zone;
 636   GNUNET_CONTAINER_multihashmap_iterate (plugin->hm,
 637                                          &iterate_zones,
 638                                          &ic);
 639   return (0 == ic.limit) ? GNUNET_OK : GNUNET_NO;
 640 }
 641
 642
 643 static int
 644 zone_to_name (void *cls,
 645               const struct GNUNET_HashCode *key,
 646               void *value)
 647 {
 648   struct Plugin *plugin = cls;
 649   struct FlatFileEntry *entry = value;
 650
 651   (void) key;
 652   if (0 != memcmp (entry->private_key,
 653                    plugin->iter_zone,
 654                    sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey)))
 655     return GNUNET_YES;
 656
 657   for (unsigned int i = 0; i < entry->record_count; i++)
 658   {
 659     if (GNUNET_GNSRECORD_TYPE_PKEY != entry->record_data[i].record_type)
 660       continue;
 661     if (0 == memcmp (plugin->iter_pkey,
 662                      entry->record_data[i].data,
 663                      sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey)))
 664     {
 665       plugin->iter (plugin->iter_cls,
 666                     entry->private_key,
 667                     entry->label,
 668                     entry->record_count,
 669                     entry->record_data);
 670       plugin->iter_result_found = GNUNET_YES;
 671
 672     }
 673   }
 674   return GNUNET_YES;
 675 }
 676
 677
 678 /**
 679  * Look for an existing PKEY delegation record for a given public key.
 680  * Returns at most one result to the iterator.
 681  *
 682  * @param cls closure (internal context for the plugin)
 683  * @param zone private key of the zone to look up in, never NULL
 684  * @param value_zone public key of the target zone (value), never NULL
 685  * @param iter function to call with the result
 686  * @param iter_cls closure for @a iter
 687  * @return #GNUNET_OK on success, #GNUNET_NO if there were no results, #GNUNET_SYSERR on error
 688  */
 689 static int
 690 namestore_flat_zone_to_name (void *cls,
 691                              const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
 692                              const struct GNUNET_CRYPTO_EcdsaPublicKey *value_zone,
 693                              GNUNET_NAMESTORE_RecordIterator iter,
 694                              void *iter_cls)
 695 {
 696   struct Plugin *plugin = cls;
 697
 698   /* FIXME: maybe use separate closure to better handle
 699      recursive calls? */
 700   plugin->iter = iter;
 701   plugin->iter_cls = iter_cls;
 702   plugin->iter_zone = zone;
 703   plugin->iter_pkey = value_zone;
 704   plugin->iter_result_found = GNUNET_NO;
 705   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 706               "Performing reverse lookup for `%s'\n",
 707               GNUNET_GNSRECORD_z2s (value_zone));
 708   GNUNET_CONTAINER_multihashmap_iterate (plugin->hm,
 709                                          &zone_to_name,
 710                                          plugin);
 711   return plugin->iter_result_found;
 712 }
 713
 714
 715 /**
 716  * Entry point for the plugin.
 717  *
 718  * @param cls the "struct GNUNET_NAMESTORE_PluginEnvironment*"
 719  * @return NULL on error, otherwise the plugin context
 720  */
 721 void *
 722 libgnunet_plugin_namestore_flat_init (void *cls)
 723 {
 724   static struct Plugin plugin;
 725   const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
 726   struct GNUNET_NAMESTORE_PluginFunctions *api;
 727
 728   if (NULL != plugin.cfg)
 729     return NULL;                /* can only initialize once! */
 730   memset (&plugin,
 731           0,
 732           sizeof (struct Plugin));
 733   plugin.cfg = cfg;
 734   if (GNUNET_OK != database_setup (&plugin))
 735   {
 736     database_shutdown (&plugin);
 737     return NULL;
 738   }
 739   api = GNUNET_new (struct GNUNET_NAMESTORE_PluginFunctions);
 740   api->cls = &plugin;
 741   api->store_records = &namestore_flat_store_records;
 742   api->iterate_records = &namestore_flat_iterate_records;
 743   api->zone_to_name = &namestore_flat_zone_to_name;
 744   api->lookup_records = &namestore_flat_lookup_records;
 745   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 746               _("flat file database running\n"));
 747   return api;
 748 }
 749
 750
 751 /**
 752  * Exit point from the plugin.
 753  *
 754  * @param cls the plugin context (as returned by "init")
 755  * @return always NULL
 756  */
 757 void *
 758 libgnunet_plugin_namestore_flat_done (void *cls)
 759 {
 760   struct GNUNET_NAMESTORE_PluginFunctions *api = cls;
 761   struct Plugin *plugin = api->cls;
 762
 763   database_shutdown (plugin);
 764   plugin->cfg = NULL;
 765   GNUNET_free (api);
 766   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 767               "flat file plugin is finished\n");
 768   return NULL;
 769 }
 770
 771 /* end of plugin_namestore_flat.c */