src/namestore/plugin_namestore_postgres.c

   1  /*
   2   * This file is part of GNUnet
   3   * Copyright (C) 2009-2013, 2016-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_postgres.c
  23  * @brief postgres-based namestore backend
  24  * @author Christian Grothoff
  25  */
  26 #include "platform.h"
  27 #include "gnunet_namestore_plugin.h"
  28 #include "gnunet_namestore_service.h"
  29 #include "gnunet_gnsrecord_lib.h"
  30 #include "gnunet_pq_lib.h"
  31 #include "namestore.h"
  32
  33
  34 #define LOG(kind,...) GNUNET_log_from (kind, "namestore-postgres", __VA_ARGS__)
  35
  36
  37 /**
  38  * Context for all functions in this plugin.
  39  */
  40 struct Plugin
  41 {
  42
  43   /**
  44    * Our configuration.
  45    */
  46   const struct GNUNET_CONFIGURATION_Handle *cfg;
  47
  48   /**
  49    * Native Postgres database handle.
  50    */
  51   PGconn *dbh;
  52
  53 };
  54
  55
  56 /**
  57  * Initialize the database connections and associated
  58  * data structures (create tables and indices
  59  * as needed as well).
  60  *
  61  * @param plugin the plugin context (state for this module)
  62  * @return #GNUNET_OK on success
  63  */
  64 static int
  65 database_setup (struct Plugin *plugin)
  66 {
  67   struct GNUNET_PQ_ExecuteStatement es_temporary =
  68     GNUNET_PQ_make_execute ("CREATE TEMPORARY TABLE IF NOT EXISTS ns098records ("
  69                             " seq BIGSERIAL PRIMARY KEY,"
  70                             " zone_private_key BYTEA NOT NULL DEFAULT '',"
  71                             " pkey BYTEA DEFAULT '',"
  72                             " rvalue BYTEA NOT NULL DEFAULT '',"
  73                             " record_count INTEGER NOT NULL DEFAULT 0,"
  74                             " record_data BYTEA NOT NULL DEFAULT '',"
  75                             " label TEXT NOT NULL DEFAULT '',"
  76                             " CONSTRAINT zl UNIQUE (zone_private_key,label)"
  77                             ")"
  78                             "WITH OIDS");
  79   struct GNUNET_PQ_ExecuteStatement es_default =
  80     GNUNET_PQ_make_execute ("CREATE TABLE IF NOT EXISTS ns098records ("
  81                             " seq BIGSERIAL PRIMARY KEY,"
  82                             " zone_private_key BYTEA NOT NULL DEFAULT '',"
  83                             " pkey BYTEA DEFAULT '',"
  84                             " rvalue BYTEA NOT NULL DEFAULT '',"
  85                             " record_count INTEGER NOT NULL DEFAULT 0,"
  86                             " record_data BYTEA NOT NULL DEFAULT '',"
  87                             " label TEXT NOT NULL DEFAULT '',"
  88                             " CONSTRAINT zl UNIQUE (zone_private_key,label)"
  89                             ")"
  90                             "WITH OIDS");
  91   const struct GNUNET_PQ_ExecuteStatement *cr;
  92
  93   plugin->dbh = GNUNET_PQ_connect_with_cfg (plugin->cfg,
  94                                             "namestore-postgres");
  95   if (NULL == plugin->dbh)
  96     return GNUNET_SYSERR;
  97   if (GNUNET_YES ==
  98       GNUNET_CONFIGURATION_get_value_yesno (plugin->cfg,
  99                                             "namestore-postgres",
 100                                             "ASYNC_COMMIT"))
 101   {
 102     struct GNUNET_PQ_ExecuteStatement es[] = {
 103       GNUNET_PQ_make_try_execute ("SET synchronous_commit TO off"),
 104       GNUNET_PQ_EXECUTE_STATEMENT_END
 105     };
 106
 107     if (GNUNET_OK !=
 108         GNUNET_PQ_exec_statements (plugin->dbh,
 109                                    es))
 110     {
 111       PQfinish (plugin->dbh);
 112       plugin->dbh = NULL;
 113       return GNUNET_SYSERR;
 114     }
 115   }
 116   if (GNUNET_YES ==
 117       GNUNET_CONFIGURATION_get_value_yesno (plugin->cfg,
 118                                             "namestore-postgres",
 119                                             "TEMPORARY_TABLE"))
 120   {
 121     cr = &es_temporary;
 122   }
 123   else
 124   {
 125     cr = &es_default;
 126   }
 127
 128   {
 129     struct GNUNET_PQ_ExecuteStatement es[] = {
 130       *cr,
 131       GNUNET_PQ_make_try_execute ("CREATE INDEX IF NOT EXISTS ir_pkey_reverse "
 132                                   "ON ns098records (zone_private_key,pkey)"),
 133       GNUNET_PQ_make_try_execute ("CREATE INDEX IF NOT EXISTS ir_pkey_iter "
 134                                   "ON ns098records (zone_private_key,seq)"),
 135       GNUNET_PQ_make_try_execute ("CREATE INDEX IF NOT EXISTS ir_label "
 136                                   "ON ns098records (label)"),
 137       GNUNET_PQ_make_try_execute ("CREATE INDEX IF NOT EXISTS zone_label "
 138                                   "ON ns098records (zone_private_key,label)"),
 139       GNUNET_PQ_EXECUTE_STATEMENT_END
 140     };
 141
 142     if (GNUNET_OK !=
 143         GNUNET_PQ_exec_statements (plugin->dbh,
 144                                    es))
 145     {
 146       PQfinish (plugin->dbh);
 147       plugin->dbh = NULL;
 148       return GNUNET_SYSERR;
 149     }
 150   }
 151
 152   {
 153     struct GNUNET_PQ_PreparedStatement ps[] = {
 154       GNUNET_PQ_make_prepare ("store_records",
 155                               "INSERT INTO ns098records"
 156                               " (zone_private_key, pkey, rvalue, record_count, record_data, label)"
 157                               " VALUES ($1, $2, $3, $4, $5, $6)"
 158                               " ON CONFLICT ON CONSTRAINT zl"
 159                               " DO UPDATE"
 160                               "    SET pkey=$2,rvalue=$3,record_count=$4,record_data=$5"
 161                               "    WHERE ns098records.zone_private_key = $1"
 162                               "          AND ns098records.label = $6",
 163                               6),
 164       GNUNET_PQ_make_prepare ("delete_records",
 165                               "DELETE FROM ns098records "
 166                               "WHERE zone_private_key=$1 AND label=$2",
 167                               2),
 168       GNUNET_PQ_make_prepare ("zone_to_name",
 169                               "SELECT seq,record_count,record_data,label FROM ns098records"
 170                               " WHERE zone_private_key=$1 AND pkey=$2",
 171                               2),
 172       GNUNET_PQ_make_prepare ("iterate_zone",
 173                               "SELECT seq,record_count,record_data,label FROM ns098records "
 174                               "WHERE zone_private_key=$1 AND seq > $2 ORDER BY seq ASC LIMIT $3",
 175                               3),
 176       GNUNET_PQ_make_prepare ("iterate_all_zones",
 177                               "SELECT seq,record_count,record_data,label,zone_private_key"
 178                               " FROM ns098records WHERE seq > $1 ORDER BY seq ASC LIMIT $2",
 179                               2),
 180       GNUNET_PQ_make_prepare ("lookup_label",
 181                               "SELECT seq,record_count,record_data,label "
 182                               "FROM ns098records WHERE zone_private_key=$1 AND label=$2",
 183                               2),
 184       GNUNET_PQ_PREPARED_STATEMENT_END
 185     };
 186
 187     if (GNUNET_OK !=
 188         GNUNET_PQ_prepare_statements (plugin->dbh,
 189                                       ps))
 190     {
 191       PQfinish (plugin->dbh);
 192       plugin->dbh = NULL;
 193       return GNUNET_SYSERR;
 194     }
 195   }
 196
 197   return GNUNET_OK;
 198 }
 199
 200
 201 /**
 202  * Store a record in the datastore.  Removes any existing record in the
 203  * same zone with the same name.
 204  *
 205  * @param cls closure (internal context for the plugin)
 206  * @param zone_key private key of the zone
 207  * @param label name that is being mapped (at most 255 characters long)
 208  * @param rd_count number of entries in @a rd array
 209  * @param rd array of records with data to store
 210  * @return #GNUNET_OK on success, else #GNUNET_SYSERR
 211  */
 212 static int
 213 namestore_postgres_store_records (void *cls,
 214                                   const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
 215                                   const char *label,
 216                                   unsigned int rd_count,
 217                                   const struct GNUNET_GNSRECORD_Data *rd)
 218 {
 219   struct Plugin *plugin = cls;
 220   struct GNUNET_CRYPTO_EcdsaPublicKey pkey;
 221   uint64_t rvalue;
 222   uint32_t rd_count32 = (uint32_t) rd_count;
 223   size_t data_size;
 224
 225   memset (&pkey,
 226           0,
 227           sizeof (pkey));
 228   for (unsigned int i=0;i<rd_count;i++)
 229     if (GNUNET_GNSRECORD_TYPE_PKEY == rd[i].record_type)
 230     {
 231       GNUNET_break (sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey) == rd[i].data_size);
 232       GNUNET_memcpy (&pkey,
 233                      rd[i].data,
 234                      rd[i].data_size);
 235       break;
 236     }
 237   rvalue = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
 238                                      UINT64_MAX);
 239   data_size = GNUNET_GNSRECORD_records_get_size (rd_count,
 240                                                  rd);
 241   if (data_size > 64 * 65536)
 242   {
 243     GNUNET_break (0);
 244     return GNUNET_SYSERR;
 245   }
 246   /* if record set is empty, delete existing records */
 247   if (0 == rd_count)
 248   {
 249     struct GNUNET_PQ_QueryParam params[] = {
 250       GNUNET_PQ_query_param_auto_from_type (zone_key),
 251       GNUNET_PQ_query_param_string (label),
 252       GNUNET_PQ_query_param_end
 253     };
 254     enum GNUNET_DB_QueryStatus res;
 255
 256     res = GNUNET_PQ_eval_prepared_non_select (plugin->dbh,
 257                                               "delete_records",
 258                                               params);
 259     if ( (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != res) &&
 260          (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS != res) )
 261     {
 262       GNUNET_break (0);
 263       return GNUNET_SYSERR;
 264     }
 265     GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
 266                      "postgres",
 267                      "Record deleted\n");
 268     return GNUNET_OK;
 269   }
 270   /* otherwise, UPSERT (i.e. UPDATE if exists, otherwise INSERT) */
 271   {
 272     char data[data_size];
 273     struct GNUNET_PQ_QueryParam params[] = {
 274       GNUNET_PQ_query_param_auto_from_type (zone_key),
 275       GNUNET_PQ_query_param_auto_from_type (&pkey),
 276       GNUNET_PQ_query_param_uint64 (&rvalue),
 277       GNUNET_PQ_query_param_uint32 (&rd_count32),
 278       GNUNET_PQ_query_param_fixed_size (data, data_size),
 279       GNUNET_PQ_query_param_string (label),
 280       GNUNET_PQ_query_param_end
 281     };
 282     enum GNUNET_DB_QueryStatus res;
 283     ssize_t ret;
 284
 285     ret = GNUNET_GNSRECORD_records_serialize (rd_count,
 286                                               rd,
 287                                               data_size,
 288                                               data);
 289     if ( (ret < 0) ||
 290          (data_size != (size_t) ret) )
 291     {
 292       GNUNET_break (0);
 293       return GNUNET_SYSERR;
 294     }
 295
 296     res = GNUNET_PQ_eval_prepared_non_select (plugin->dbh,
 297                                               "store_records",
 298                                               params);
 299     if (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != res)
 300       return GNUNET_SYSERR;
 301   }
 302   return GNUNET_OK;
 303 }
 304
 305
 306 /**
 307  * Closure for #parse_result_call_iterator.
 308  */
 309 struct ParserContext
 310 {
 311   /**
 312    * Function to call for each result.
 313    */
 314   GNUNET_NAMESTORE_RecordIterator iter;
 315
 316   /**
 317    * Closure for @e iter.
 318    */
 319   void *iter_cls;
 320
 321   /**
 322    * Zone key, NULL if part of record.
 323    */
 324   const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key;
 325
 326   /**
 327    * Number of results still to return (counted down by
 328    * number of results given to iterator).
 329    */
 330   uint64_t limit;
 331 };
 332
 333
 334 /**
 335  * A statement has been run.  We should evaluate the result, and if possible
 336  * call the @a iter in @a cls with the result.
 337  *
 338  * @param cls closure of type `struct ParserContext *`
 339  * @param result the postgres result
 340  * @param num_result the number of results in @a result
 341  */
 342 static void
 343 parse_result_call_iterator (void *cls,
 344                             PGresult *res,
 345                             unsigned int num_results)
 346 {
 347   struct ParserContext *pc = cls;
 348
 349   if (NULL == pc->iter)
 350     return; /* no need to do more work */
 351   for (unsigned int i=0;i<num_results;i++)
 352   {
 353     uint64_t serial;
 354     void *data;
 355     size_t data_size;
 356     uint32_t record_count;
 357     char *label;
 358     struct GNUNET_CRYPTO_EcdsaPrivateKey zk;
 359     struct GNUNET_PQ_ResultSpec rs_with_zone[] = {
 360       GNUNET_PQ_result_spec_uint64 ("seq", &serial),
 361       GNUNET_PQ_result_spec_uint32 ("record_count", &record_count),
 362       GNUNET_PQ_result_spec_variable_size ("record_data", &data, &data_size),
 363       GNUNET_PQ_result_spec_string ("label", &label),
 364       GNUNET_PQ_result_spec_auto_from_type ("zone_private_key", &zk),
 365       GNUNET_PQ_result_spec_end
 366     };
 367     struct GNUNET_PQ_ResultSpec rs_without_zone[] = {
 368       GNUNET_PQ_result_spec_uint64 ("seq", &serial),
 369       GNUNET_PQ_result_spec_uint32 ("record_count", &record_count),
 370       GNUNET_PQ_result_spec_variable_size ("record_data", &data, &data_size),
 371       GNUNET_PQ_result_spec_string ("label", &label),
 372       GNUNET_PQ_result_spec_end
 373     };
 374     struct GNUNET_PQ_ResultSpec *rs;
 375
 376     rs = (NULL == pc->zone_key) ? rs_with_zone : rs_without_zone;
 377     if (GNUNET_YES !=
 378         GNUNET_PQ_extract_result (res,
 379                                   rs,
 380                                   i))
 381     {
 382       GNUNET_break (0);
 383       return;
 384     }
 385
 386     if (record_count > 64 * 1024)
 387     {
 388       /* sanity check, don't stack allocate far too much just
 389          because database might contain a large value here */
 390       GNUNET_break (0);
 391       GNUNET_PQ_cleanup_result (rs);
 392       return;
 393     }
 394
 395     {
 396       struct GNUNET_GNSRECORD_Data rd[GNUNET_NZL(record_count)];
 397
 398       if (GNUNET_OK !=
 399           GNUNET_GNSRECORD_records_deserialize (data_size,
 400                                                 data,
 401                                                 record_count,
 402                                                 rd))
 403       {
 404         GNUNET_break (0);
 405         GNUNET_PQ_cleanup_result (rs);
 406         return;
 407       }
 408       pc->iter (pc->iter_cls,
 409                 serial,
 410                 (NULL == pc->zone_key) ? &zk : pc->zone_key,
 411                 label,
 412                 record_count,
 413                 rd);
 414     }
 415     GNUNET_PQ_cleanup_result (rs);
 416   }
 417   pc->limit -= num_results;
 418 }
 419
 420
 421 /**
 422  * Lookup records in the datastore for which we are the authority.
 423  *
 424  * @param cls closure (internal context for the plugin)
 425  * @param zone private key of the zone
 426  * @param label name of the record in the zone
 427  * @param iter function to call with the result
 428  * @param iter_cls closure for @a iter
 429  * @return #GNUNET_OK on success, #GNUNET_NO for no results, else #GNUNET_SYSERR
 430  */
 431 static int
 432 namestore_postgres_lookup_records (void *cls,
 433                                    const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
 434                                    const char *label,
 435                                    GNUNET_NAMESTORE_RecordIterator iter,
 436                                    void *iter_cls)
 437 {
 438   struct Plugin *plugin = cls;
 439   struct GNUNET_PQ_QueryParam params[] = {
 440     GNUNET_PQ_query_param_auto_from_type (zone),
 441     GNUNET_PQ_query_param_string (label),
 442     GNUNET_PQ_query_param_end
 443   };
 444   struct ParserContext pc;
 445   enum GNUNET_DB_QueryStatus res;
 446
 447   if (NULL == zone)
 448   {
 449     GNUNET_break (0);
 450     return GNUNET_SYSERR;
 451   }
 452   pc.iter = iter;
 453   pc.iter_cls = iter_cls;
 454   pc.zone_key = zone;
 455   res = GNUNET_PQ_eval_prepared_multi_select (plugin->dbh,
 456                                               "lookup_label",
 457                                               params,
 458                                               &parse_result_call_iterator,
 459                                               &pc);
 460   if (res < 0)
 461     return GNUNET_SYSERR;
 462   if (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS == res)
 463     return GNUNET_NO;
 464   return GNUNET_OK;
 465 }
 466
 467
 468 /**
 469  * Iterate over the results for a particular key and zone in the
 470  * datastore.  Will return at most one result to the iterator.
 471  *
 472  * @param cls closure (internal context for the plugin)
 473  * @param zone hash of public key of the zone, NULL to iterate over all zones
 474  * @param serial serial number to exclude in the list of all matching records
 475  * @param limit maximum number of results to fetch
 476  * @param iter function to call with the result
 477  * @param iter_cls closure for @a iter
 478  * @return #GNUNET_OK on success, #GNUNET_NO if there were no more results, #GNUNET_SYSERR on error
 479  */
 480 static int
 481 namestore_postgres_iterate_records (void *cls,
 482                                     const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
 483                                     uint64_t serial,
 484                                     uint64_t limit,
 485                                     GNUNET_NAMESTORE_RecordIterator iter,
 486                                     void *iter_cls)
 487 {
 488   struct Plugin *plugin = cls;
 489   enum GNUNET_DB_QueryStatus res;
 490   struct ParserContext pc;
 491
 492   pc.iter = iter;
 493   pc.iter_cls = iter_cls;
 494   pc.zone_key = zone;
 495   pc.limit = limit;
 496   if (NULL == zone)
 497   {
 498     struct GNUNET_PQ_QueryParam params_without_zone[] = {
 499       GNUNET_PQ_query_param_uint64 (&serial),
 500       GNUNET_PQ_query_param_uint64 (&limit),
 501       GNUNET_PQ_query_param_end
 502     };
 503
 504     res = GNUNET_PQ_eval_prepared_multi_select (plugin->dbh,
 505                                                 "iterate_all_zones",
 506                                                 params_without_zone,
 507                                                 &parse_result_call_iterator,
 508                                                 &pc);
 509   }
 510   else
 511   {
 512     struct GNUNET_PQ_QueryParam params_with_zone[] = {
 513       GNUNET_PQ_query_param_auto_from_type (zone),
 514       GNUNET_PQ_query_param_uint64 (&serial),
 515       GNUNET_PQ_query_param_uint64 (&limit),
 516       GNUNET_PQ_query_param_end
 517     };
 518
 519     res = GNUNET_PQ_eval_prepared_multi_select (plugin->dbh,
 520                                                 "iterate_zone",
 521                                                 params_with_zone,
 522                                                 &parse_result_call_iterator,
 523                                                 &pc);
 524   }
 525   if (res < 0)
 526     return GNUNET_SYSERR;
 527
 528   if ( (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS == res) ||
 529        (pc.limit > 0) )
 530     return GNUNET_NO;
 531   return GNUNET_OK;
 532 }
 533
 534
 535 /**
 536  * Look for an existing PKEY delegation record for a given public key.
 537  * Returns at most one result to the iterator.
 538  *
 539  * @param cls closure (internal context for the plugin)
 540  * @param zone private key of the zone to look up in, never NULL
 541  * @param value_zone public key of the target zone (value), never NULL
 542  * @param iter function to call with the result
 543  * @param iter_cls closure for @a iter
 544  * @return #GNUNET_OK on success, #GNUNET_NO if there were no results, #GNUNET_SYSERR on error
 545  */
 546 static int
 547 namestore_postgres_zone_to_name (void *cls,
 548                                  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
 549                                  const struct GNUNET_CRYPTO_EcdsaPublicKey *value_zone,
 550                                  GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
 551 {
 552   struct Plugin *plugin = cls;
 553   struct GNUNET_PQ_QueryParam params[] = {
 554     GNUNET_PQ_query_param_auto_from_type (zone),
 555     GNUNET_PQ_query_param_auto_from_type (value_zone),
 556     GNUNET_PQ_query_param_end
 557   };
 558   enum GNUNET_DB_QueryStatus res;
 559   struct ParserContext pc;
 560
 561   pc.iter = iter;
 562   pc.iter_cls = iter_cls;
 563   pc.zone_key = zone;
 564   res = GNUNET_PQ_eval_prepared_multi_select (plugin->dbh,
 565                                               "zone_to_name",
 566                                               params,
 567                                               &parse_result_call_iterator,
 568                                               &pc);
 569   if (res < 0)
 570     return GNUNET_SYSERR;
 571   return GNUNET_OK;
 572 }
 573
 574
 575 /**
 576  * Shutdown database connection and associate data
 577  * structures.
 578  *
 579  * @param plugin the plugin context (state for this module)
 580  */
 581 static void
 582 database_shutdown (struct Plugin *plugin)
 583 {
 584   PQfinish (plugin->dbh);
 585   plugin->dbh = NULL;
 586 }
 587
 588
 589 /**
 590  * Entry point for the plugin.
 591  *
 592  * @param cls the `struct GNUNET_NAMESTORE_PluginEnvironment*`
 593  * @return NULL on error, othrewise the plugin context
 594  */
 595 void *
 596 libgnunet_plugin_namestore_postgres_init (void *cls)
 597 {
 598   static struct Plugin plugin;
 599   const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
 600   struct GNUNET_NAMESTORE_PluginFunctions *api;
 601
 602   if (NULL != plugin.cfg)
 603     return NULL;                /* can only initialize once! */
 604   memset (&plugin, 0, sizeof (struct Plugin));
 605   plugin.cfg = cfg;
 606   if (GNUNET_OK != database_setup (&plugin))
 607   {
 608     database_shutdown (&plugin);
 609     return NULL;
 610   }
 611   api = GNUNET_new (struct GNUNET_NAMESTORE_PluginFunctions);
 612   api->cls = &plugin;
 613   api->store_records = &namestore_postgres_store_records;
 614   api->iterate_records = &namestore_postgres_iterate_records;
 615   api->zone_to_name = &namestore_postgres_zone_to_name;
 616   api->lookup_records = &namestore_postgres_lookup_records;
 617   LOG (GNUNET_ERROR_TYPE_INFO,
 618        "Postgres namestore plugin running\n");
 619   return api;
 620 }
 621
 622
 623 /**
 624  * Exit point from the plugin.
 625  *
 626  * @param cls the plugin context (as returned by "init")
 627  * @return always NULL
 628  */
 629 void *
 630 libgnunet_plugin_namestore_postgres_done (void *cls)
 631 {
 632   struct GNUNET_NAMESTORE_PluginFunctions *api = cls;
 633   struct Plugin *plugin = api->cls;
 634
 635   database_shutdown (plugin);
 636   plugin->cfg = NULL;
 637   GNUNET_free (api);
 638   LOG (GNUNET_ERROR_TYPE_DEBUG,
 639        "Postgres namestore plugin is finished\n");
 640   return NULL;
 641 }
 642
 643 /* end of plugin_namestore_postgres.c */