[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[gnunet] 50/90: -DOC: Documentation cleanup pass through NAMESTORE subsy
|
From: |
gnunet |
|
Subject: |
[gnunet] 50/90: -DOC: Documentation cleanup pass through NAMESTORE subsystem |
|
Date: |
Tue, 18 Oct 2022 03:06:49 +0200 |
This is an automated email from the git hooks/post-receive script.
martin-schanzenbach pushed a commit to branch master
in repository gnunet.
commit 35c0970096ca249ad63c073c0b74c49f8f4853d7
Author: Willow Liquorice <willow@howhill.com>
AuthorDate: Wed Sep 7 20:55:16 2022 +0100
-DOC: Documentation cleanup pass through NAMESTORE subsystem
---
src/namestore/gnunet-namestore.c | 4 +-
src/namestore/gnunet-service-namestore.c | 10 +-
src/namestore/gnunet-zoneimport.c | 2 +-
src/namestore/plugin_namestore_flat.c | 818 ++++++++++++++++++++++++++++++
src/namestore/plugin_namestore_postgres.c | 4 +-
src/namestore/plugin_rest_namestore.c | 2 +-
6 files changed, 829 insertions(+), 11 deletions(-)
diff --git a/src/namestore/gnunet-namestore.c b/src/namestore/gnunet-namestore.c
index af40f2dbe..9ed8f400c 100644
--- a/src/namestore/gnunet-namestore.c
+++ b/src/namestore/gnunet-namestore.c
@@ -849,8 +849,8 @@ del_monitor (void *cls,
* Parse expiration time.
*
* @param expirationstring text to parse
- * @param etime_is_rel[out] set to #GNUNET_YES if time is relative
- * @param etime[out] set to expiration time (abs or rel)
+ * @param[out] etime_is_rel set to #GNUNET_YES if time is relative
+ * @param[out] etime set to expiration time (abs or rel)
* @return #GNUNET_OK on success
*/
static int
diff --git a/src/namestore/gnunet-service-namestore.c
b/src/namestore/gnunet-service-namestore.c
index b860d7a3c..e926cfbd2 100644
--- a/src/namestore/gnunet-service-namestore.c
+++ b/src/namestore/gnunet-service-namestore.c
@@ -654,8 +654,8 @@ get_nick_record (const struct GNUNET_IDENTITY_PrivateKey
*zone)
* @param nick_rd the nick record to integrate
* @param rd2_length length of the @a rd2 array
* @param rd2 array of records
- * @param rdc_res[out] length of the resulting @a rd_res array
- * @param rd_res[out] set to an array of records,
+ * @param[out] rdc_res length of the resulting @a rd_res array
+ * @param[out] rd_res set to an array of records,
* including @a nick_rd and @a rd2;
* all of the variable-size 'data' fields in @a rd2 are
* allocated in the same chunk of memory!
@@ -874,7 +874,7 @@ send_lookup_response (struct NamestoreClient *nc,
/**
* Send response to the store request to the client.
*
- * @param client client to talk to
+ * @param nc client to talk to
* @param res status of the operation
* @param rid client's request ID
*/
@@ -1338,7 +1338,7 @@ struct RecordLookupContext
*
* @param cls closure with a `struct RecordLookupContext`
* @param seq unique serial number of the record, MUST NOT BE ZERO
- * @param zone_key private key of the zone
+ * @param private_key private key of the zone
* @param label name that is being mapped (at most 255 characters long)
* @param rd_count number of entries in @a rd array
* @param rd array of records with data to store
@@ -2200,7 +2200,7 @@ handle_iteration_stop (void *cls,
* Handles a #GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT message
*
* @param cls the client sending the message
- * @param message message from the client
+ * @param zis_msg message from the client
*/
static void
handle_iteration_next (void *cls,
diff --git a/src/namestore/gnunet-zoneimport.c
b/src/namestore/gnunet-zoneimport.c
index 68b43a016..9ae0fb146 100644
--- a/src/namestore/gnunet-zoneimport.c
+++ b/src/namestore/gnunet-zoneimport.c
@@ -437,7 +437,7 @@ get_label (struct Request *req)
* Build DNS query for @a hostname.
*
* @param hostname host to build query for
- * @param raw_size[out] number of bytes in the query
+ * @param[out] raw_size number of bytes in the query
* @return NULL on error, otherwise pointer to statically (!)
* allocated query buffer
*/
diff --git a/src/namestore/plugin_namestore_flat.c
b/src/namestore/plugin_namestore_flat.c
new file mode 100644
index 000000000..3249d524a
--- /dev/null
+++ b/src/namestore/plugin_namestore_flat.c
@@ -0,0 +1,818 @@
+/*
+ * This file is part of GNUnet
+ * Copyright (C) 2009-2015, 2018, 2019 GNUnet e.V.
+ *
+ * GNUnet is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License,
+ * or (at your option) any later version.
+ *
+ * GNUnet is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+ SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file namestore/plugin_namestore_flat.c
+ * @brief file-based namestore backend
+ * @author Martin Schanzenbach
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include "gnunet_namestore_plugin.h"
+#include "gnunet_namestore_service.h"
+#include "gnunet_gnsrecord_lib.h"
+#include "namestore.h"
+
+/**
+ * Context for all functions in this plugin.
+ */
+struct Plugin
+{
+ const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+ /**
+ * Database filename.
+ */
+ char *fn;
+
+ /**
+ * HashMap
+ */
+ struct GNUNET_CONTAINER_MultiHashMap *hm;
+};
+
+
+struct FlatFileEntry
+{
+ /**
+ * Entry zone
+ */
+ struct GNUNET_IDENTITY_PrivateKey private_key;
+
+ /**
+ * Record count.
+ */
+ uint32_t record_count;
+
+ /**
+ * Rvalue
+ */
+ uint64_t rvalue;
+
+ /**
+ * Record data
+ */
+ struct GNUNET_GNSRECORD_Data *record_data;
+
+ /**
+ * Label
+ */
+ char *label;
+};
+
+
+/**
+ * Hash contactenation of @a pkey and @a label into @a h
+ *
+ * @param pkey a key
+ * @param label a label
+ * @param[out] h initialized hash
+ */
+static void
+hash_pkey_and_label (const struct GNUNET_IDENTITY_PrivateKey *pkey,
+ const char *label,
+ struct GNUNET_HashCode *h)
+{
+ char *key;
+ size_t label_len;
+ size_t key_len;
+
+ label_len = strlen (label);
+ key_len = label_len + sizeof(struct GNUNET_IDENTITY_PrivateKey);
+ key = GNUNET_malloc (key_len);
+ GNUNET_memcpy (key,
+ label,
+ label_len);
+ GNUNET_memcpy (key + label_len,
+ pkey,
+ sizeof(struct GNUNET_IDENTITY_PrivateKey));
+ GNUNET_CRYPTO_hash (key,
+ key_len,
+ h);
+ GNUNET_free (key);
+}
+
+
+/**
+ * Initialize the database connections and associated
+ * data structures (create tables and indices
+ * as needed as well).
+ *
+ * @param plugin the plugin context (state for this module)
+ * @return #GNUNET_OK on success
+ */
+static int
+database_setup (struct Plugin *plugin)
+{
+ char *flatdbfile;
+ char *record_data;
+ char *zone_private_key;
+ char *record_data_b64;
+ char *buffer;
+ char *line;
+ char *label;
+ char *rvalue;
+ char *record_count;
+ size_t record_data_size;
+ uint64_t size;
+ struct GNUNET_HashCode hkey;
+ struct GNUNET_DISK_FileHandle *fh;
+ struct FlatFileEntry *entry;
+ struct GNUNET_DISK_MapHandle *mh;
+
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_filename (plugin->cfg,
+ "namestore-flat",
+ "FILENAME",
+ &flatdbfile))
+ {
+ GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+ "namestore-flat",
+ "FILENAME");
+ return GNUNET_SYSERR;
+ }
+ if (GNUNET_OK !=
+ GNUNET_DISK_file_test (flatdbfile))
+ {
+ if (GNUNET_OK !=
+ GNUNET_DISK_directory_create_for_file (flatdbfile))
+ {
+ GNUNET_break (0);
+ GNUNET_free (flatdbfile);
+ return GNUNET_SYSERR;
+ }
+ }
+ /* flatdbfile should be UTF-8-encoded. If it isn't, it's a bug */
+ plugin->fn = flatdbfile;
+
+ /* Load data from file into hashmap */
+ plugin->hm = GNUNET_CONTAINER_multihashmap_create (10,
+ GNUNET_NO);
+ fh = GNUNET_DISK_file_open (flatdbfile,
+ GNUNET_DISK_OPEN_CREATE
+ | GNUNET_DISK_OPEN_READWRITE,
+ GNUNET_DISK_PERM_USER_WRITE
+ | GNUNET_DISK_PERM_USER_READ);
+ if (NULL == fh)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ _ ("Unable to initialize file: %s.\n"),
+ flatdbfile);
+ return GNUNET_SYSERR;
+ }
+ if (GNUNET_SYSERR ==
+ GNUNET_DISK_file_size (flatdbfile,
+ &size,
+ GNUNET_YES,
+ GNUNET_YES))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ _ ("Unable to get filesize: %s.\n"),
+ flatdbfile);
+ GNUNET_DISK_file_close (fh);
+ return GNUNET_SYSERR;
+ }
+ if (size > SIZE_MAX)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ _ ("File too big to map: %llu bytes.\n"),
+ (unsigned long long) size);
+ GNUNET_DISK_file_close (fh);
+ return GNUNET_SYSERR;
+ }
+ if (0 == size)
+ {
+ GNUNET_DISK_file_close (fh);
+ return GNUNET_OK;
+ }
+ buffer = GNUNET_DISK_file_map (fh,
+ &mh,
+ GNUNET_DISK_MAP_TYPE_READ,
+ size);
+ if (NULL == buffer)
+ {
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
+ "mmap");
+ GNUNET_DISK_file_close (fh);
+ return GNUNET_SYSERR;
+ }
+ if ('\0' != buffer[size - 1])
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ _ ("Namestore database file `%s' malformed\n"),
+ flatdbfile);
+ GNUNET_DISK_file_unmap (mh);
+ GNUNET_DISK_file_close (fh);
+ return GNUNET_SYSERR;
+ }
+
+ line = strtok (buffer, "\n");
+ while (NULL != line)
+ {
+ zone_private_key = strtok (line, ",");
+ if (NULL == zone_private_key)
+ break;
+ rvalue = strtok (NULL, ",");
+ if (NULL == rvalue)
+ break;
+ record_count = strtok (NULL, ",");
+ if (NULL == record_count)
+ break;
+ record_data_b64 = strtok (NULL, ",");
+ if (NULL == record_data_b64)
+ break;
+ label = strtok (NULL, ",");
+ if (NULL == label)
+ break;
+ line = strtok (NULL, "\n");
+ entry = GNUNET_new (struct FlatFileEntry);
+ {
+ unsigned long long ll;
+
+ if (1 != sscanf (rvalue,
+ "%llu",
+ &ll))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Error parsing entry\n");
+ GNUNET_free (entry);
+ break;
+ }
+ entry->rvalue = (uint64_t) ll;
+ }
+ {
+ unsigned int ui;
+
+ if (1 != sscanf (record_count,
+ "%u",
+ &ui))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Error parsing entry\n");
+ GNUNET_free (entry);
+ break;
+ }
+ entry->record_count = (uint32_t) ui;
+ }
+ entry->label = GNUNET_strdup (label);
+ record_data_size
+ = GNUNET_STRINGS_base64_decode (record_data_b64,
+ strlen (record_data_b64),
+ (void **) &record_data);
+ entry->record_data =
+ GNUNET_new_array (entry->record_count,
+ struct GNUNET_GNSRECORD_Data);
+ if (GNUNET_OK !=
+ GNUNET_GNSRECORD_records_deserialize (record_data_size,
+ record_data,
+ entry->record_count,
+ entry->record_data))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Unable to deserialize record %s\n",
+ label);
+ GNUNET_free (entry->label);
+ GNUNET_free (entry);
+ GNUNET_free (record_data);
+ break;
+ }
+ GNUNET_free (record_data);
+
+ {
+ struct GNUNET_IDENTITY_PrivateKey *private_key;
+
+ GNUNET_STRINGS_base64_decode (zone_private_key,
+ strlen (zone_private_key),
+ (void **) &private_key);
+ entry->private_key = *private_key;
+ GNUNET_free (private_key);
+ }
+
+ hash_pkey_and_label (&entry->private_key,
+ label,
+ &hkey);
+ if (GNUNET_OK !=
+ GNUNET_CONTAINER_multihashmap_put (plugin->hm,
+ &hkey,
+ entry,
+
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
+ {
+ GNUNET_free (entry);
+ GNUNET_break (0);
+ }
+ }
+ GNUNET_DISK_file_unmap (mh);
+ GNUNET_DISK_file_close (fh);
+ return GNUNET_OK;
+}
+
+
+/**
+ * Store values in hashmap in file and free data
+ *
+ * @param plugin the plugin context
+ * @param key key in the map
+ * @param value a `struct FlatFileEntry`
+ */
+static int
+store_and_free_entries (void *cls,
+ const struct GNUNET_HashCode *key,
+ void *value)
+{
+ struct GNUNET_DISK_FileHandle *fh = cls;
+ struct FlatFileEntry *entry = value;
+ char *line;
+ char *zone_private_key;
+ char *record_data_b64;
+ ssize_t data_size;
+
+ (void) key;
+ GNUNET_STRINGS_base64_encode (&entry->private_key,
+ sizeof(struct GNUNET_IDENTITY_PrivateKey),
+ &zone_private_key);
+ data_size = GNUNET_GNSRECORD_records_get_size (entry->record_count,
+ entry->record_data);
+ if (data_size < 0)
+ {
+ GNUNET_break (0);
+ GNUNET_free (zone_private_key);
+ return GNUNET_SYSERR;
+ }
+ if (data_size >= UINT16_MAX)
+ {
+ GNUNET_break (0);
+ GNUNET_free (zone_private_key);
+ return GNUNET_SYSERR;
+ }
+ {
+ char data[data_size];
+ ssize_t ret;
+
+ ret = GNUNET_GNSRECORD_records_serialize (entry->record_count,
+ entry->record_data,
+ data_size,
+ data);
+ if ((ret < 0) ||
+ (data_size != ret))
+ {
+ GNUNET_break (0);
+ GNUNET_free (zone_private_key);
+ return GNUNET_SYSERR;
+ }
+ GNUNET_STRINGS_base64_encode (data,
+ data_size,
+ &record_data_b64);
+ }
+ GNUNET_asprintf (&line,
+ "%s,%llu,%u,%s,%s\n",
+ zone_private_key,
+ (unsigned long long) entry->rvalue,
+ (unsigned int) entry->record_count,
+ record_data_b64,
+ entry->label);
+ GNUNET_free (record_data_b64);
+ GNUNET_free (zone_private_key);
+
+ GNUNET_DISK_file_write (fh,
+ line,
+ strlen (line));
+
+ GNUNET_free (line);
+ GNUNET_free (entry->label);
+ GNUNET_free (entry->record_data);
+ GNUNET_free (entry);
+ return GNUNET_YES;
+}
+
+
+/**
+ * Shutdown database connection and associate data
+ * structures.
+ * @param plugin the plugin context (state for this module)
+ */
+static void
+database_shutdown (struct Plugin *plugin)
+{
+ struct GNUNET_DISK_FileHandle *fh;
+
+ fh = GNUNET_DISK_file_open (plugin->fn,
+ GNUNET_DISK_OPEN_CREATE
+ | GNUNET_DISK_OPEN_TRUNCATE
+ | GNUNET_DISK_OPEN_READWRITE,
+ GNUNET_DISK_PERM_USER_WRITE
+ | GNUNET_DISK_PERM_USER_READ);
+ if (NULL == fh)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ _ ("Unable to initialize file: %s.\n"),
+ plugin->fn);
+ return;
+ }
+
+ GNUNET_CONTAINER_multihashmap_iterate (plugin->hm,
+ &store_and_free_entries,
+ fh);
+ GNUNET_CONTAINER_multihashmap_destroy (plugin->hm);
+ /* append 0-terminator */
+ GNUNET_DISK_file_write (fh,
+ "",
+ 1);
+ GNUNET_DISK_file_close (fh);
+}
+
+
+/**
+ * Store a record in the datastore. Removes any existing record in the
+ * same zone with the same name.
+ *
+ * @param cls closure (internal context for the plugin)
+ * @param zone_key private key of the zone
+ * @param label name that is being mapped (at most 255 characters long)
+ * @param rd_count number of entries in @a rd array
+ * @param rd array of records with data to store
+ * @return #GNUNET_OK on success, else #GNUNET_SYSERR
+ */
+static int
+namestore_flat_store_records (void *cls,
+ const struct
+ GNUNET_IDENTITY_PrivateKey *zone_key,
+ const char *label,
+ unsigned int rd_count,
+ const struct GNUNET_GNSRECORD_Data *rd)
+{
+ struct Plugin *plugin = cls;
+ uint64_t rvalue;
+ struct GNUNET_HashCode hkey;
+ struct FlatFileEntry *entry;
+
+ rvalue = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
+ UINT64_MAX);
+ hash_pkey_and_label (zone_key,
+ label,
+ &hkey);
+ GNUNET_CONTAINER_multihashmap_remove_all (plugin->hm,
+ &hkey);
+ if (0 == rd_count)
+ {
+ GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+ "sqlite",
+ "Record deleted\n");
+ return GNUNET_OK;
+ }
+ entry = GNUNET_new (struct FlatFileEntry);
+ GNUNET_asprintf (&entry->label,
+ label,
+ strlen (label));
+ GNUNET_memcpy (&entry->private_key,
+ zone_key,
+ sizeof(struct GNUNET_IDENTITY_PrivateKey));
+ entry->rvalue = rvalue;
+ entry->record_count = rd_count;
+ entry->record_data = GNUNET_new_array (rd_count,
+ struct GNUNET_GNSRECORD_Data);
+ for (unsigned int i = 0; i < rd_count; i++)
+ {
+ entry->record_data[i].expiration_time = rd[i].expiration_time;
+ entry->record_data[i].record_type = rd[i].record_type;
+ entry->record_data[i].flags = rd[i].flags;
+ entry->record_data[i].data_size = rd[i].data_size;
+ entry->record_data[i].data = GNUNET_malloc (rd[i].data_size);
+ GNUNET_memcpy ((char *) entry->record_data[i].data,
+ rd[i].data,
+ rd[i].data_size);
+ }
+ return GNUNET_CONTAINER_multihashmap_put (plugin->hm,
+ &hkey,
+ entry,
+
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+}
+
+
+/**
+ * Lookup records in the datastore for which we are the authority.
+ *
+ * @param cls closure (internal context for the plugin)
+ * @param zone private key of the zone
+ * @param label name of the record in the zone
+ * @param iter function to call with the result
+ * @param iter_cls closure for @a iter
+ * @return #GNUNET_OK on success, #GNUNET_NO for no results, else
#GNUNET_SYSERR
+ */
+static int
+namestore_flat_lookup_records (void *cls,
+ const struct GNUNET_IDENTITY_PrivateKey *zone,
+ const char *label,
+ GNUNET_NAMESTORE_RecordIterator iter,
+ void *iter_cls)
+{
+ struct Plugin *plugin = cls;
+ struct FlatFileEntry *entry;
+ struct GNUNET_HashCode hkey;
+
+ if (NULL == zone)
+ {
+ GNUNET_break (0);
+ return GNUNET_SYSERR;
+ }
+ hash_pkey_and_label (zone,
+ label,
+ &hkey);
+ entry = GNUNET_CONTAINER_multihashmap_get (plugin->hm,
+ &hkey);
+
+ if (NULL == entry)
+ return GNUNET_NO;
+ if (NULL != iter)
+ iter (iter_cls,
+ 1, /* zero is illegal */
+ &entry->private_key,
+ entry->label,
+ entry->record_count,
+ entry->record_data);
+ return GNUNET_YES;
+}
+
+
+/**
+ * Closure for #iterate_zones.
+ */
+struct IterateContext
+{
+ /**
+ * How many more records should we skip before returning results?
+ */
+ uint64_t offset;
+
+ /**
+ * How many more records should we return?
+ */
+ uint64_t limit;
+
+ /**
+ * What is the position of the current entry, counting
+ * starts from 1.
+ */
+ uint64_t pos;
+
+ /**
+ * Target zone.
+ */
+ const struct GNUNET_IDENTITY_PrivateKey *zone;
+
+ /**
+ * Function to call on each record.
+ */
+ GNUNET_NAMESTORE_RecordIterator iter;
+
+ /**
+ * Closure for @e iter.
+ */
+ void *iter_cls;
+};
+
+
+/**
+ * Helper function for #namestore_flat_iterate_records().
+ *
+ * @param cls a `struct IterateContext`
+ * @param key unused
+ * @param value a `struct FlatFileEntry`
+ * @return #GNUNET_YES to continue the iteration
+ */
+static int
+iterate_zones (void *cls,
+ const struct GNUNET_HashCode *key,
+ void *value)
+{
+ struct IterateContext *ic = cls;
+ struct FlatFileEntry *entry = value;
+
+ (void) key;
+ if (0 == ic->limit)
+ return GNUNET_NO;
+ if ((NULL != ic->zone) &&
+ (0 != GNUNET_memcmp (&entry->private_key,
+ ic->zone)))
+ return GNUNET_YES;
+ ic->pos++;
+ if (ic->offset > 0)
+ {
+ ic->offset--;
+ return GNUNET_YES;
+ }
+ ic->iter (ic->iter_cls,
+ ic->pos,
+ (NULL == ic->zone)
+ ? &entry->private_key
+ : ic->zone,
+ entry->label,
+ entry->record_count,
+ entry->record_data);
+ ic->limit--;
+ if (0 == ic->limit)
+ return GNUNET_NO;
+ return GNUNET_YES;
+}
+
+
+/**
+ * Iterate over the results for a particular key and zone in the
+ * datastore. Will return at most one result to the iterator.
+ *
+ * @param cls closure (internal context for the plugin)
+ * @param zone hash of public key of the zone, NULL to iterate over all zones
+ * @param serial serial number to exclude in the list of all matching records
+ * @param limit maximum number of results to return to @a iter
+ * @param iter function to call with the result
+ * @param iter_cls closure for @a iter
+ * @return #GNUNET_OK on success, #GNUNET_NO if there were no more results,
#GNUNET_SYSERR on error
+ */
+static int
+namestore_flat_iterate_records (void *cls,
+ const struct
+ GNUNET_IDENTITY_PrivateKey *zone,
+ uint64_t serial,
+ uint64_t limit,
+ GNUNET_NAMESTORE_RecordIterator iter,
+ void *iter_cls)
+{
+ struct Plugin *plugin = cls;
+ struct IterateContext ic;
+
+ ic.offset = serial;
+ ic.pos = 0;
+ ic.limit = limit;
+ ic.iter = iter;
+ ic.iter_cls = iter_cls;
+ ic.zone = zone;
+ GNUNET_CONTAINER_multihashmap_iterate (plugin->hm,
+ &iterate_zones,
+ &ic);
+ return (0 == ic.limit) ? GNUNET_OK : GNUNET_NO;
+}
+
+
+/**
+ * Closure for #zone_to_name.
+ */
+struct ZoneToNameContext
+{
+ const struct GNUNET_IDENTITY_PrivateKey *zone;
+ const struct GNUNET_IDENTITY_PublicKey *value_zone;
+ GNUNET_NAMESTORE_RecordIterator iter;
+ void *iter_cls;
+
+ int result_found;
+};
+
+
+static int
+zone_to_name (void *cls,
+ const struct GNUNET_HashCode *key,
+ void *value)
+{
+ struct ZoneToNameContext *ztn = cls;
+ struct FlatFileEntry *entry = value;
+
+ (void) key;
+ if (0 != GNUNET_memcmp (&entry->private_key,
+ ztn->zone))
+ return GNUNET_YES;
+
+ for (unsigned int i = 0; i < entry->record_count; i++)
+ {
+ if (GNUNET_NO ==
+ GNUNET_GNSRECORD_is_zonekey_type (entry->record_data[i].record_type))
+ continue;
+ if (ztn->value_zone->type != entry->record_data[i].record_type)
+ continue;
+ if (0 == memcmp (ztn->value_zone,
+ entry->record_data[i].data,
+ entry->record_data[i].data_size))
+ {
+ ztn->iter (ztn->iter_cls,
+ i + 1, /* zero is illegal! */
+ &entry->private_key,
+ entry->label,
+ entry->record_count,
+ entry->record_data);
+ ztn->result_found = GNUNET_YES;
+ }
+ }
+ return GNUNET_YES;
+}
+
+
+/**
+ * Look for an existing PKEY delegation record for a given public key.
+ * Returns at most one result to the iterator.
+ *
+ * @param cls closure (internal context for the plugin)
+ * @param zone private key of the zone to look up in, never NULL
+ * @param value_zone public key of the target zone (value), never NULL
+ * @param iter function to call with the result
+ * @param iter_cls closure for @a iter
+ * @return #GNUNET_OK on success, #GNUNET_NO if there were no results,
#GNUNET_SYSERR on error
+ */
+static int
+namestore_flat_zone_to_name (void *cls,
+ const struct GNUNET_IDENTITY_PrivateKey *zone,
+ const struct
+ GNUNET_IDENTITY_PublicKey *value_zone,
+ GNUNET_NAMESTORE_RecordIterator iter,
+ void *iter_cls)
+{
+ struct Plugin *plugin = cls;
+ struct ZoneToNameContext ztn = {
+ .iter = iter,
+ .iter_cls = iter_cls,
+ .zone = zone,
+ .value_zone = value_zone,
+ .result_found = GNUNET_NO
+ };
+
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Performing reverse lookup for `%s'\n",
+ GNUNET_GNSRECORD_z2s (value_zone));
+ GNUNET_CONTAINER_multihashmap_iterate (plugin->hm,
+ &zone_to_name,
+ &ztn);
+ return ztn.result_found;
+}
+
+
+/**
+ * Entry point for the plugin.
+ *
+ * @param cls the "struct GNUNET_NAMESTORE_PluginEnvironment*"
+ * @return NULL on error, otherwise the plugin context
+ */
+void *
+libgnunet_plugin_namestore_flat_init (void *cls)
+{
+ static struct Plugin plugin;
+ const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
+ struct GNUNET_NAMESTORE_PluginFunctions *api;
+
+ if (NULL != plugin.cfg)
+ return NULL; /* can only initialize once! */
+ memset (&plugin,
+ 0,
+ sizeof(struct Plugin));
+ plugin.cfg = cfg;
+ if (GNUNET_OK != database_setup (&plugin))
+ {
+ database_shutdown (&plugin);
+ return NULL;
+ }
+ api = GNUNET_new (struct GNUNET_NAMESTORE_PluginFunctions);
+ api->cls = &plugin;
+ api->store_records = &namestore_flat_store_records;
+ api->iterate_records = &namestore_flat_iterate_records;
+ api->zone_to_name = &namestore_flat_zone_to_name;
+ api->lookup_records = &namestore_flat_lookup_records;
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ _ ("Flat file database running\n"));
+ return api;
+}
+
+
+/**
+ * Exit point from the plugin.
+ *
+ * @param cls the plugin context (as returned by "init")
+ * @return always NULL
+ */
+void *
+libgnunet_plugin_namestore_flat_done (void *cls)
+{
+ struct GNUNET_NAMESTORE_PluginFunctions *api = cls;
+ struct Plugin *plugin = api->cls;
+
+ database_shutdown (plugin);
+ plugin->cfg = NULL;
+ GNUNET_free (api);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Flat file plugin is finished\n");
+ return NULL;
+}
+
+
+/* end of plugin_namestore_flat.c */
diff --git a/src/namestore/plugin_namestore_postgres.c
b/src/namestore/plugin_namestore_postgres.c
index 6e5c1c718..1c3d2d2e8 100644
--- a/src/namestore/plugin_namestore_postgres.c
+++ b/src/namestore/plugin_namestore_postgres.c
@@ -403,8 +403,8 @@ struct ParserContext
* call the @a iter in @a cls with the result.
*
* @param cls closure of type `struct ParserContext *`
- * @param result the postgres result
- * @param num_result the number of results in @a result
+ * @param res the postgres result
+ * @param num_results the number of results in @a result
*/
static void
parse_result_call_iterator (void *cls,
diff --git a/src/namestore/plugin_rest_namestore.c
b/src/namestore/plugin_rest_namestore.c
index 0475960eb..746932d0b 100644
--- a/src/namestore/plugin_rest_namestore.c
+++ b/src/namestore/plugin_rest_namestore.c
@@ -280,7 +280,7 @@ static struct RequestHandle *requests_tail;
/**
* Cleanup lookup handle
- * @param handle Handle to clean up
+ * @param cls Handle to clean up
*/
static void
cleanup_handle (void *cls)
--
To stop receiving notification emails like this one, please contact
gnunet@gnunet.org.
- [gnunet] 74/90: -DOC: Documentation cleanup pass through EXIT daemon, (continued)
- [gnunet] 74/90: -DOC: Documentation cleanup pass through EXIT daemon, gnunet, 2022/10/17
- [gnunet] 81/90: -DOC: Documentation cleanup pass through STATISTICS subsystem, gnunet, 2022/10/17
- [gnunet] 24/90: -DOC: Comment stripping pass in SECRETSHARING service, gnunet, 2022/10/17
- [gnunet] 17/90: -DOC: Comment stripping pass in SQ library, gnunet, 2022/10/17
- [gnunet] 28/90: -DOC: used \f$ commands to bracket formulae here, so the inside is actually treated like LaTeX, gnunet, 2022/10/17
- [gnunet] 32/90: -DOC: Another comment stripping pass through TESTBED, gnunet, 2022/10/17
- [gnunet] 35/90: -DOC: Another comment stripping pass through old SET subsystem, gnunet, 2022/10/17
- [gnunet] 36/90: -DOC: Another comment stripping pass through SETU, gnunet, 2022/10/17
- [gnunet] 45/90: -DOC: Documentation cleanup pass through CADET subsystem, gnunet, 2022/10/17
- [gnunet] 47/90: -DOC: Documentation cleanup pass through RECLAIM subsystem, gnunet, 2022/10/17
- [gnunet] 50/90: -DOC: Documentation cleanup pass through NAMESTORE subsystem,
gnunet <=
- [gnunet] 58/90: -DOC: Documentation cleanup pass through SETU subsystem, gnunet, 2022/10/17
- [gnunet] 61/90: -DOC: Documentation cleanup pass through ATS subsystem, gnunet, 2022/10/17
- [gnunet] 54/90: -DOC: Documentation cleanup pass through TESTBED subsystem, gnunet, 2022/10/17
- [gnunet] 64/90: -DOC: Documentation cleanup pass through ARM service, gnunet, 2022/10/17
- [gnunet] 60/90: -DOC: Documentation cleanup pass through DATACACHE subsystem, gnunet, 2022/10/17
- [gnunet] 53/90: -DOC: Documentation cleanup pass through UTIL DNSSTUB library, gnunet, 2022/10/17
- [gnunet] 19/90: -DOC: Comment stripping pass in REGEX service, gnunet, 2022/10/17
- [gnunet] 42/90: -Minor tweaks to warningfilter.py regexes, gnunet, 2022/10/17
- [gnunet] 37/90: -DOC: Comment stripping pass through MySQL library, gnunet, 2022/10/17
- [gnunet] 82/90: -DOC: Documentation cleanup pass through VPN subsystem, gnunet, 2022/10/17