/*
This file is part of GNUnet.
- (C) 2009 Christian Grothoff (and other contributing authors)
+ (C) 2012 Christian Grothoff (and other contributing authors)
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
/**
-* Configuration handle.
-*/
+ * Configuration handle.
+ */
const struct GNUNET_CONFIGURATION_Handle *GSN_cfg;
/**
-* Database handle
-*/
+ * Database handle
+ */
struct GNUNET_NAMESTORE_PluginFunctions *GSN_database;
/**
-* Zonefile directory
-*/
+ * Zonefile directory
+ */
static char *zonefile_directory;
/**
*/
static char *db_lib_name;
-
/**
* Our notification context.
*/
if (privkey == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("File zone `%s' but corrupt content already exists, failed to write! \n"), GNUNET_short_h2s (&zone));
+ _("File zone `%s' but corrupt content already exists, failed to write! \n"),
+ GNUNET_short_h2s (&zone));
return GNUNET_SYSERR;
}
else
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("File zone `%s' but different zone key already exists, failed to write! \n"), GNUNET_short_h2s (&zone));
+ _("File zone `%s' but different zone key already exists, failed to write! \n"),
+ GNUNET_short_h2s (&zone));
return GNUNET_OK;
}
}
GNUNET_assert (GNUNET_YES == GNUNET_DISK_file_close (fd));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- _("Stored zonekey for zone `%s' in file `%s'\n"), GNUNET_short_h2s(&c->zone), c->filename);
+ "Stored zonekey for zone `%s' in file `%s'\n",
+ GNUNET_short_h2s(&c->zone), c->filename);
return GNUNET_OK;
}
return nc;
}
+
/**
* Called whenever a client is disconnected.
* Frees our resources associated with that client.
nc = NULL;
}
+
/**
* Handles a 'GNUNET_MESSAGE_TYPE_NAMESTORE_START' message
*
}
+/**
+ * LookupNameContext
+ *
+ * Context for name lookups passed from 'handle_lookup_name' to
+ * 'handle_lookup_name_it' as closure
+ */
struct LookupNameContext
{
-
+ /**
+ * The client to send the response to
+ */
struct GNUNET_NAMESTORE_Client *nc;
+
+ /**
+ * Operation id for the name lookup
+ */
uint32_t request_id;
+
+ /**
+ * Requested specific record type
+ */
uint32_t record_type;
+
+ /**
+ * Requested zone
+ */
struct GNUNET_CRYPTO_ShortHashCode *zone;
+
+ /**
+ * Requested name
+ */
char *name;
};
+/**
+ * A 'GNUNET_NAMESTORE_RecordIterator' for name lookups in handle_lookup_name
+ *
+ * @param cls a 'struct LookupNameContext *' with information about the request
+ * @param zone_key zone key of the zone
+ * @param expire expiration time
+ * @param name name
+ * @param rd_count number of records
+ * @param rd array of records
+ * @param signature signature
+ */
static void
handle_lookup_name_it (void *cls,
const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
GNUNET_SERVER_receive_done (client, GNUNET_OK);
}
+
+/**
+ * CreateRecordContext
+ *
+ * Context for record create operations passed from 'handle_record_create' to
+ * 'handle_create_record_it' as closure
+ */
struct CreateRecordContext
{
+ /**
+ * Record data
+ */
struct GNUNET_NAMESTORE_RecordData *rd;
+
+ /**
+ * Zone's private key
+ */
struct GNUNET_CRYPTO_RsaPrivateKey *pkey;
+
+ /**
+ * Zone's public key
+ */
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *pubkey;
+
+ /**
+ * Record expiration time
+ */
struct GNUNET_TIME_Absolute expire;
+
+ /**
+ * Name for the record to create
+ */
char *name;
+
+ /**
+ * result returned from 'handle_create_record_it'
+ * GNUNET_SYSERR: failed to create the record
+ * GNUNET_NO: we updated an existing record or identical entry existed
+ * GNUNET_YES : we created a new record
+ */
int res;
};
+/**
+ * A 'GNUNET_NAMESTORE_RecordIterator' for record create operations
+ * in handle_record_create
+ *
+ * @param cls a 'struct CreateRecordContext *' with information about the request
+ * @param pubkey zone key of the zone
+ * @param expire expiration time
+ * @param name name
+ * @param rd_count number of records
+ * @param rd array of records
+ * @param signature signature
+ */
static void
handle_create_record_it (void *cls,
const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *pubkey,
}
+/**
+ * RemoveRecordContext
+ *
+ * Context for record remove operations passed from 'handle_record_remove' to
+ * 'handle_record_remove_it' as closure
+ */
struct RemoveRecordContext
{
+ /**
+ * Record to remove
+ */
struct GNUNET_NAMESTORE_RecordData *rd;
+
+ /**
+ * Zone's private keys
+ */
struct GNUNET_CRYPTO_RsaPrivateKey *pkey;
+
+ /**
+ * Name to remove
+ */
int remove_name;
+
+ /**
+ * 0 : Success
+ * 1 : Could not find record to remove, empty result set
+ * 2 : Could not find record to remove, record did not exist in result set
+ * 3 : Could not remove records from database
+ * 4 : Could not put records into database
+ */
uint16_t op_res;
};
+
+/**
+ * FIXME...
+ */
static void
handle_record_remove_it (void *cls,
const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
name, res);
if (GNUNET_OK != res)
{
- /* Could put records into database */
- rrc->op_res = 4;
+ /* Could not remove records from database */
+ rrc->op_res = 3;
return;
}
rrc->op_res = 0;
&dummy_signature);
if (GNUNET_OK != res)
{
- /* Could put records into database */
+ /* Could not put records into database */
rrc->op_res = 4;
return;
}
rrc->op_res = 0;
}
+
/**
* Handles a 'GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_REMOVE' message
*
GNUNET_SERVER_receive_done (client, GNUNET_OK);
}
-
+/**
+ * ZoneToNameCtx
+ *
+ * Context for record remove operations passed from 'handle_zone_to_name' to
+ * 'handle_zone_to_name_it' as closure
+ */
struct ZoneToNameCtx
{
+ /**
+ * Namestore client
+ */
struct GNUNET_NAMESTORE_Client *nc;
+
+ /**
+ * Request id
+ */
uint32_t rid;
};
+
+/**
+ * Zone to name iterator
+ *
+ * @param cls struct ZoneToNameCtx *
+ * @param zone_key the zone key
+ * @param expire expiration date
+ * @param name name
+ * @param rd_count number of records
+ * @param rd record data
+ * @param signature signature
+ */
static void
handle_zone_to_name_it (void *cls,
const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
else
contains_sig = GNUNET_NO;
-
-
msg_size = sizeof (struct ZoneToNameResponseMessage) + name_len + rd_ser_len + contains_sig * sizeof (struct GNUNET_CRYPTO_RsaSignature);
ztnr_msg = GNUNET_malloc (msg_size);
GNUNET_free_non_null (rd_ser);
}
+
/**
* Handles a 'GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME' message
*
/**
- * Copy record, data has to be free separetely
+ * Copy record, data has to be free'd separetely
+ *
+ * @param src source record
+ * @param dest destination record
*/
static void
copy_record (const struct GNUNET_NAMESTORE_RecordData *src, struct GNUNET_NAMESTORE_RecordData *dest)
{
-
memcpy (dest, src, sizeof (struct GNUNET_NAMESTORE_RecordData));
dest->data = GNUNET_malloc (src->data_size);
memcpy ((void *) dest->data, src->data, src->data_size);
}
+
+/**
+ * ZoneIterationProcResult
+ *
+ * Context for record remove operations passed from
+ * 'find_next_zone_iteration_result' to 'zone_iteraterate_proc' as closure
+ */
struct ZoneIterationProcResult
{
+ /**
+ * The zone iteration handle
+ */
struct GNUNET_NAMESTORE_ZoneIteration *zi;
+ /**
+ * Iteration result: iteration done?
+ */
int res_iteration_finished;
+
+ /**
+ * Iteration result: number of records included
+ */
int records_included;
+
+ /**
+ * Iteration result: is a valid signature included?
+ */
int has_signature;
+ /**
+ * Name
+ */
char *name;
+
+ /**
+ * Zone hash
+ */
struct GNUNET_CRYPTO_ShortHashCode zone_hash;
+
+ /**
+ * Record data
+ */
struct GNUNET_NAMESTORE_RecordData *rd;
+
+ /**
+ * Zone's public key
+ */
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded zone_key;
+
+ /**
+ * Signature
+ */
struct GNUNET_CRYPTO_RsaSignature signature;
+
+ /**
+ * Expiration date
+ */
struct GNUNET_TIME_Absolute expire;
};
+/**
+ * Process results for zone iteration from database
+ *
+ * @param cls struct ZoneIterationProcResult *proc
+ * @param zone_key the zone key
+ * @param expire expiration time
+ * @param name name
+ * @param rd_count number of records for this name
+ * @param rd record data
+ * @param signature block signature
+ */
static void
zone_iteraterate_proc (void *cls,
const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
GNUNET_break (0);
return;
}
-
}
+
+/**
+ * Find next zone iteration result in database
+ * @param proc the zone iteration processing to use
+ */
static void
find_next_zone_iteration_result (struct ZoneIterationProcResult *proc)
{
do
{
- GSN_database->iterate_records (GSN_database->cls, zone , NULL, proc->zi->offset, &zone_iteraterate_proc, proc);
+ if (GNUNET_SYSERR ==
+ GSN_database->iterate_records (GSN_database->cls, zone, NULL, proc->zi->offset, &zone_iteraterate_proc, proc))
+ {
+ GNUNET_break (0);
+ break;
+ }
proc->zi->offset++;
}
- while ((proc->records_included == 0) && (GNUNET_NO == proc->res_iteration_finished));
+ while ((0 == proc->records_included) && (GNUNET_NO == proc->res_iteration_finished));
}
+/**
+ * Send zone iteration result to client
+ * @param proc the zone iteration processing result to send
+ */
static void
send_zone_iteration_result (struct ZoneIterationProcResult *proc)
{
GNUNET_free (zi);
return;
}
- else
- {
- GNUNET_assert (proc->records_included > 0);
- struct ZoneIterationResponseMessage *zir_msg;
- if (zi->has_zone == GNUNET_YES)
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending name `%s' for iteration over zone `%s'\n",
- proc->name, GNUNET_short_h2s(&zi->zone));
- if (zi->has_zone == GNUNET_NO)
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending name `%s' for iteration over all zones\n",
- proc->name);
-
- size_t name_len;
- size_t rd_ser_len;
- size_t msg_size;
- char *name_tmp;
- char *rd_tmp;
- name_len = strlen (proc->name) +1;
-
- rd_ser_len = GNUNET_NAMESTORE_records_get_size(proc->records_included, proc->rd);
- char rd_ser[rd_ser_len];
- GNUNET_NAMESTORE_records_serialize(proc->records_included, proc->rd, rd_ser_len, rd_ser);
- msg_size = sizeof (struct ZoneIterationResponseMessage) + name_len + rd_ser_len;
- zir_msg = GNUNET_malloc(msg_size);
-
- name_tmp = (char *) &zir_msg[1];
- rd_tmp = &name_tmp[name_len];
-
- zir_msg->gns_header.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_RESPONSE);
- zir_msg->gns_header.header.size = htons (msg_size);
- zir_msg->gns_header.r_id = htonl(zi->request_id);
- zir_msg->expire = GNUNET_TIME_absolute_hton(proc->expire);
- zir_msg->reserved = htons (0);
- zir_msg->name_len = htons (name_len);
- zir_msg->rd_count = htons (proc->records_included);
- zir_msg->rd_len = htons (rd_ser_len);
- zir_msg->signature = proc->signature;
- zir_msg->public_key = proc->zone_key;
- memcpy (name_tmp, proc->name, name_len);
- memcpy (rd_tmp, rd_ser, rd_ser_len);
+ GNUNET_assert (proc->records_included > 0);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message with size %u\n", "ZONE_ITERATION_RESPONSE", msg_size);
- GNUNET_SERVER_notification_context_unicast (snc, zi->client->client, (const struct GNUNET_MessageHeader *) zir_msg, GNUNET_NO);
- GNUNET_free (zir_msg);
- }
+ struct ZoneIterationResponseMessage *zir_msg;
+ size_t name_len;
+ size_t rd_ser_len;
+ size_t msg_size;
+ char *name_tmp;
+ char *rd_tmp;
+
+ if (zi->has_zone == GNUNET_YES)
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending name `%s' for iteration over zone `%s'\n",
+ proc->name, GNUNET_short_h2s(&zi->zone));
+ if (zi->has_zone == GNUNET_NO)
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending name `%s' for iteration over all zones\n",
+ proc->name);
+ name_len = strlen (proc->name) +1;
+ rd_ser_len = GNUNET_NAMESTORE_records_get_size(proc->records_included, proc->rd);
+ char rd_ser[rd_ser_len];
+ GNUNET_NAMESTORE_records_serialize(proc->records_included, proc->rd, rd_ser_len, rd_ser);
+ msg_size = sizeof (struct ZoneIterationResponseMessage) + name_len + rd_ser_len;
+ zir_msg = GNUNET_malloc(msg_size);
+ name_tmp = (char *) &zir_msg[1];
+ rd_tmp = &name_tmp[name_len];
+ zir_msg->gns_header.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_RESPONSE);
+ zir_msg->gns_header.header.size = htons (msg_size);
+ zir_msg->gns_header.r_id = htonl(zi->request_id);
+ zir_msg->expire = GNUNET_TIME_absolute_hton(proc->expire);
+ zir_msg->reserved = htons (0);
+ zir_msg->name_len = htons (name_len);
+ zir_msg->rd_count = htons (proc->records_included);
+ zir_msg->rd_len = htons (rd_ser_len);
+ zir_msg->signature = proc->signature;
+ zir_msg->public_key = proc->zone_key;
+ memcpy (name_tmp, proc->name, name_len);
+ memcpy (rd_tmp, rd_ser, rd_ser_len);
+
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Sending `%s' message with size %u\n", "ZONE_ITERATION_RESPONSE", msg_size);
+ GNUNET_SERVER_notification_context_unicast (snc, zi->client->client,
+ (const struct GNUNET_MessageHeader *) zir_msg,
+ GNUNET_NO);
+ GNUNET_free (zir_msg);
}
+
+/**
+ * Clean up after zone iteration
+ * @param proc the zone iteration processor
+ */
static void
clean_up_zone_iteration_result (struct ZoneIterationProcResult *proc)
{
- int c;
+ unsigned int c;
+
GNUNET_free_non_null (proc->name);
for (c = 0; c < proc->records_included; c++)
{
}
+/**
+ * Perform the next round of the zone iteration.
+ *
+ * @param zi zone iterator to process
+ */
+static void
+run_zone_iteration_round (struct GNUNET_NAMESTORE_ZoneIteration *zi)
+{
+ struct ZoneIterationProcResult proc;
+
+ memset (&proc, 0, sizeof (proc));
+ proc.zi = zi;
+ find_next_zone_iteration_result (&proc);
+ if (GNUNET_YES == proc.res_iteration_finished)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Zone iteration done\n");
+ }
+ else if (0 != proc.records_included)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Zone iteration return %u records\n",
+ proc.records_included);
+ }
+ send_zone_iteration_result (&proc);
+ clean_up_zone_iteration_result (&proc);
+}
+
+
/**
* Handles a 'GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START' message
*
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message\n", "ZONE_ITERATION_START");
-
- struct ZoneIterationStartMessage *zis_msg = (struct ZoneIterationStartMessage *) message;
+ static struct GNUNET_CRYPTO_ShortHashCode zeros;
+ const struct ZoneIterationStartMessage *zis_msg;
struct GNUNET_NAMESTORE_Client *nc;
struct GNUNET_NAMESTORE_ZoneIteration *zi;
- struct GNUNET_CRYPTO_ShortHashCode dummy;
- struct ZoneIterationProcResult proc;
- nc = client_lookup(client);
- if (nc == NULL)
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message\n", "ZONE_ITERATION_START");
+ nc = client_lookup (client);
+ if (NULL == nc)
{
GNUNET_break_op (0);
GNUNET_SERVER_receive_done (client, GNUNET_OK);
return;
}
-
+ zis_msg = (const struct ZoneIterationStartMessage *) message;
zi = GNUNET_malloc (sizeof (struct GNUNET_NAMESTORE_ZoneIteration));
zi->request_id = ntohl (zis_msg->gns_header.r_id);
zi->offset = 0;
zi->client = nc;
zi->must_have_flags = ntohs (zis_msg->must_have_flags);
zi->must_not_have_flags = ntohs (zis_msg->must_not_have_flags);
-
- memset (&dummy, '\0', sizeof (dummy));
- if (0 == memcmp (&dummy, &zis_msg->zone, sizeof (dummy)))
+ if (0 == memcmp (&zeros, &zis_msg->zone, sizeof (zeros)))
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting to iterate over all zones\n");
zi->zone = zis_msg->zone;
}
else
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting to iterate over zone `%s'\n", GNUNET_short_h2s (&zis_msg->zone));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Starting to iterate over zone `%s'\n", GNUNET_short_h2s (&zis_msg->zone));
zi->zone = zis_msg->zone;
zi->has_zone = GNUNET_YES;
}
-
GNUNET_CONTAINER_DLL_insert (nc->op_head, nc->op_tail, zi);
-
- proc.zi = zi;
- find_next_zone_iteration_result (&proc);
- if (GNUNET_YES == proc.res_iteration_finished)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Zone iteration done\n");
- }
- else if (proc.records_included != 0)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Zone iteration return %u records\n", proc.records_included);
- }
- send_zone_iteration_result (&proc);
- clean_up_zone_iteration_result (&proc);
-
+ run_zone_iteration_round (zi);
GNUNET_SERVER_receive_done (client, GNUNET_OK);
}
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message\n", "ZONE_ITERATION_STOP");
-
struct GNUNET_NAMESTORE_Client *nc;
struct GNUNET_NAMESTORE_ZoneIteration *zi;
struct ZoneIterationStopMessage *zis_msg;
uint32_t rid;
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Received `%s' message\n",
+ "ZONE_ITERATION_STOP");
nc = client_lookup(client);
- if (nc == NULL)
+ if (NULL == nc)
{
- GNUNET_break_op (0);
+ GNUNET_break (0);
GNUNET_SERVER_receive_done (client, GNUNET_OK);
return;
}
-
zis_msg = (struct ZoneIterationStopMessage *) message;
rid = ntohl (zis_msg->gns_header.r_id);
- for (zi = nc->op_head; zi != NULL; zi = zi->next)
- {
+ for (zi = nc->op_head; NULL != zi; zi = zi->next)
if (zi->request_id == rid)
break;
- }
- if (zi == NULL)
+ if (NULL == zi)
{
- GNUNET_break_op (0);
+ GNUNET_break (0);
GNUNET_SERVER_receive_done (client, GNUNET_OK);
return;
}
-
- GNUNET_CONTAINER_DLL_remove(nc->op_head, nc->op_tail, zi);
+ GNUNET_CONTAINER_DLL_remove (nc->op_head, nc->op_tail, zi);
if (GNUNET_YES == zi->has_zone)
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopped zone iteration for zone `%s'\n", GNUNET_short_h2s (&zi->zone));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Stopped zone iteration for zone `%s'\n",
+ GNUNET_short_h2s (&zi->zone));
else
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopped zone iteration all zones\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Stopped zone iteration over all zones\n");
GNUNET_free (zi);
-
GNUNET_SERVER_receive_done (client, GNUNET_OK);
}
/**
- * Handles a 'GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP' message
+ * Handles a 'GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT' message
*
* @param cls unused
* @param client GNUNET_SERVER_Client sending the message
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message\n", "ZONE_ITERATION_NEXT");
-
struct GNUNET_NAMESTORE_Client *nc;
struct GNUNET_NAMESTORE_ZoneIteration *zi;
- struct ZoneIterationNextMessage *zis_msg;
+ const struct ZoneIterationNextMessage *zis_msg;
uint32_t rid;
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message\n", "ZONE_ITERATION_NEXT");
nc = client_lookup(client);
- if (nc == NULL)
+ if (NULL == nc)
{
- GNUNET_break_op (0);
+ GNUNET_break (0);
GNUNET_SERVER_receive_done (client, GNUNET_OK);
return;
}
-
- zis_msg = (struct ZoneIterationNextMessage *) message;
+ zis_msg = (const struct ZoneIterationNextMessage *) message;
rid = ntohl (zis_msg->gns_header.r_id);
- for (zi = nc->op_head; zi != NULL; zi = zi->next)
- {
+ for (zi = nc->op_head; NULL != zi; zi = zi->next)
if (zi->request_id == rid)
break;
- }
- if (zi == NULL)
+ if (NULL == zi)
{
- GNUNET_break_op (0);
+ GNUNET_break (0);
GNUNET_SERVER_receive_done (client, GNUNET_OK);
return;
}
-
- struct ZoneIterationProcResult proc;
- proc.zi = zi;
-
- find_next_zone_iteration_result (&proc);
- if (GNUNET_YES == proc.res_iteration_finished)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Zone iteration done\n");
- }
- else if (proc.records_included != 0)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Zone iteration return %u records\n", proc.records_included);
- }
- send_zone_iteration_result (&proc);
- clean_up_zone_iteration_result (&proc);
-
+ run_zone_iteration_round (zi);
GNUNET_SERVER_receive_done (client, GNUNET_OK);
}
+
+/**
+ * Load zone keys from directory by reading all .zkey files in this directory
+ *
+ * @param cls int * 'counter' to store the number of files found
+ * @param filename directory to scan
+ * @return GNUNET_OK to continue
+ */
static int
zonekey_file_it (void *cls, const char *filename)
{
+ unsigned int *counter = cls;
struct GNUNET_HashCode long_hash;
- int *counter = cls;
- if ((filename != NULL) && (NULL != strstr(filename, ".zkey")))
- {
- struct GNUNET_CRYPTO_RsaPrivateKey *privkey;
- struct GNUNET_NAMESTORE_CryptoContainer *c;
- privkey = GNUNET_CRYPTO_rsa_key_create_from_file(filename);
- if (privkey == NULL)
- return GNUNET_OK;
-
- c = GNUNET_malloc (sizeof (struct GNUNET_NAMESTORE_CryptoContainer));
- c->pubkey = GNUNET_malloc(sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
- c->privkey = privkey;
- GNUNET_CRYPTO_rsa_key_get_public(privkey, c->pubkey);
- GNUNET_CRYPTO_short_hash(c->pubkey, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), &c->zone);
-
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found zonefile for zone `%s'\n", GNUNET_short_h2s (&c->zone));
- GNUNET_CRYPTO_short_hash_double (&c->zone, &long_hash);
- GNUNET_CONTAINER_multihashmap_put(zonekeys, &long_hash, c, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
- (*counter) ++;
- }
- return GNUNET_OK;
+ struct GNUNET_CRYPTO_RsaPrivateKey *privkey;
+ struct GNUNET_NAMESTORE_CryptoContainer *c;
+
+ if ((NULL == filename) ||
+ (NULL == strstr(filename, ".zkey")))
+ return GNUNET_OK;
+ privkey = GNUNET_CRYPTO_rsa_key_create_from_file (filename);
+ if (NULL == privkey)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _("Could not parse zone key file `%s'\n"),
+ filename);
+ return GNUNET_OK;
+ }
+ c = GNUNET_malloc (sizeof (struct GNUNET_NAMESTORE_CryptoContainer));
+ c->pubkey = GNUNET_malloc(sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
+ c->privkey = privkey;
+ GNUNET_CRYPTO_rsa_key_get_public(privkey, c->pubkey);
+ GNUNET_CRYPTO_short_hash(c->pubkey,
+ sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+ &c->zone);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Found zonefile for zone `%s'\n", GNUNET_short_h2s (&c->zone));
+ GNUNET_CRYPTO_short_hash_double (&c->zone, &long_hash);
+ GNUNET_assert (GNUNET_OK ==
+ GNUNET_CONTAINER_multihashmap_put (zonekeys, &long_hash, c,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+ (*counter)++;
+ return GNUNET_OK;
}
/**
- * Process template requests.
+ * Process namestore requests.
*
* @param cls closure
* @param server the initialized server
run (void *cls, struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
- char *database;
- int counter = 0;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting namestore service\n");
-
static const struct GNUNET_SERVER_MessageHandler handlers[] = {
{&handle_start, NULL,
GNUNET_MESSAGE_TYPE_NAMESTORE_START, sizeof (struct StartMessage)},
GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP, 0},
{NULL, NULL, 0, 0}
};
+ char *database;
+ unsigned int counter;
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting namestore service\n");
GSN_cfg = cfg;
/* Load private keys from disk */
if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_filename (cfg, "namestore", "zonefile_directory",
- &zonefile_directory))
+ GNUNET_CONFIGURATION_get_value_filename (cfg, "namestore",
+ "zonefile_directory",
+ &zonefile_directory))
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("No directory to load zonefiles specified in configuration\n"));
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ _("No directory to load zonefiles specified in configuration\n"));
GNUNET_SCHEDULER_add_now (&cleanup_task, NULL);
return;
}
{
if (GNUNET_SYSERR == GNUNET_DISK_directory_create (zonefile_directory))
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Creating directory `%s' for zone files failed!\n"), zonefile_directory);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ _("Creating directory `%s' for zone files failed!\n"),
+ zonefile_directory);
GNUNET_SCHEDULER_add_now (&cleanup_task, NULL);
return;
}
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Created directory `%s' for zone files\n", zonefile_directory);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Created directory `%s' for zone files\n",
+ zonefile_directory);
}
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Scanning directory `%s' for zone files\n", zonefile_directory);
- zonekeys = GNUNET_CONTAINER_multihashmap_create (10);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Scanning directory `%s' for zone files\n", zonefile_directory);
+ zonekeys = GNUNET_CONTAINER_multihashmap_create (16);
+ counter = 0;
GNUNET_DISK_directory_scan (zonefile_directory, zonekey_file_it, &counter);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found %u zone files\n", counter);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Found %u zone files\n",
+ counter);
/* Loading database plugin */
if (GNUNET_OK !=
GNUNET_asprintf (&db_lib_name, "libgnunet_plugin_namestore_%s", database);
GSN_database = GNUNET_PLUGIN_load (db_lib_name, (void *) GSN_cfg);
GNUNET_free (database);
- if (GSN_database == NULL)
+ if (NULL == GSN_database)
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not load database backend `%s'\n",
- db_lib_name);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Could not load database backend `%s'\n",
+ db_lib_name);
GNUNET_SCHEDULER_add_now (&cleanup_task, NULL);
return;
}
GNUNET_SERVER_disconnect_notify (server,
&client_disconnect_notification,
NULL);
-
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &cleanup_task,
NULL);
-
}