diff options
Diffstat (limited to 'src/namestore/gnunet-service-namestore.c')
-rw-r--r-- | src/namestore/gnunet-service-namestore.c | 2656 |
1 files changed, 1508 insertions, 1148 deletions
diff --git a/src/namestore/gnunet-service-namestore.c b/src/namestore/gnunet-service-namestore.c index d6c2998..a14ad92 100644 --- a/src/namestore/gnunet-service-namestore.c +++ b/src/namestore/gnunet-service-namestore.c @@ -1,6 +1,6 @@ /* 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 @@ -24,8 +24,8 @@ * @author Matthias Wachs */ #include "platform.h" -#include "gnunet_getopt_lib.h" -#include "gnunet_service_lib.h" +#include "gnunet_util_lib.h" +#include "gnunet_dnsparser_lib.h" #include "gnunet_namestore_service.h" #include "gnunet_namestore_plugin.h" #include "gnunet_signatures.h" @@ -38,16 +38,45 @@ */ struct GNUNET_NAMESTORE_ZoneIteration { + /** + * Next element in the DLL + */ struct GNUNET_NAMESTORE_ZoneIteration *next; + + /** + * Previous element in the DLL + */ struct GNUNET_NAMESTORE_ZoneIteration *prev; - struct GNUNET_NAMESTORE_Client * client; + /** + * Namestore client which intiated this zone iteration + */ + struct GNUNET_NAMESTORE_Client *client; + /** + * GNUNET_YES if we iterate over a specific zone + * GNUNET_NO if we iterate over all zones + */ int has_zone; + /** + * Hash of the specific zone if 'has_zone' is GNUNET_YES, + * othwerwise set to '\0' + */ struct GNUNET_CRYPTO_ShortHashCode zone; + /** + * The operation id fot the zone iteration in the response for the client + */ uint64_t request_id; + + /** + * Offset of the zone iteration used to address next result of the zone + * iteration in the store + * + * Initialy set to 0 in handle_iteration_start + * Incremented with by every call to handle_iteration_next + */ uint32_t offset; /** @@ -67,175 +96,300 @@ struct GNUNET_NAMESTORE_ZoneIteration */ struct GNUNET_NAMESTORE_Client { + /** + * Next element in the DLL + */ struct GNUNET_NAMESTORE_Client *next; + + /** + * Previous element in the DLL + */ struct GNUNET_NAMESTORE_Client *prev; - struct GNUNET_SERVER_Client * client; + /** + * The client + */ + struct GNUNET_SERVER_Client *client; + /** + * Head of the DLL of + * Zone iteration operations in progress initiated by this client + */ struct GNUNET_NAMESTORE_ZoneIteration *op_head; + + /** + * Tail of the DLL of + * Zone iteration operations in progress initiated by this client + */ struct GNUNET_NAMESTORE_ZoneIteration *op_tail; }; + +/** + * A container struct to store information belonging to a zone crypto key pair + */ struct GNUNET_NAMESTORE_CryptoContainer { - char * filename; + /** + * Filename where to store the container + */ + char *filename; + /** + * Short hash of the zone's public key + */ struct GNUNET_CRYPTO_ShortHashCode zone; + + /** + * Zone's private key + */ struct GNUNET_CRYPTO_RsaPrivateKey *privkey; - struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *pubkey; + }; /** -* Configuration handle. -*/ -const struct GNUNET_CONFIGURATION_Handle *GSN_cfg; + * Configuration handle. + */ +static const struct GNUNET_CONFIGURATION_Handle *GSN_cfg; /** -* Database handle -*/ -struct GNUNET_NAMESTORE_PluginFunctions *GSN_database; + * Database handle + */ +static struct GNUNET_NAMESTORE_PluginFunctions *GSN_database; /** -* Zonefile directory -*/ + * Zonefile directory + */ static char *zonefile_directory; +/** + * Name of the database plugin + */ static char *db_lib_name; - /** * Our notification context. */ static struct GNUNET_SERVER_NotificationContext *snc; +/** + * Head of the Client DLL + */ static struct GNUNET_NAMESTORE_Client *client_head; + +/** + * Tail of the Client DLL + */ static struct GNUNET_NAMESTORE_Client *client_tail; -struct GNUNET_CONTAINER_MultiHashMap *zonekeys; +/** + * Hashmap containing the zone keys this namestore has is authoritative for + * + * Keys are the GNUNET_CRYPTO_HashCode of the GNUNET_CRYPTO_ShortHashCode + * The values are 'struct GNUNET_NAMESTORE_CryptoContainer *' + */ +static struct GNUNET_CONTAINER_MultiHashMap *zonekeys; +/** + * DLL head for key loading contexts + */ +static struct KeyLoadContext *kl_head; /** - * Write zonefile to disk - * @param filename where to write - * @param c the crypto container - * - * @return GNUNET_OK on success, GNUNET_SYSERR on fail + * DLL tail for key loading contexts */ +static struct KeyLoadContext *kl_tail; -int -write_key_to_file (const char *filename, struct GNUNET_NAMESTORE_CryptoContainer *c) +struct KeyLoadContext +{ + struct KeyLoadContext *next; + struct KeyLoadContext *prev; + struct GNUNET_CRYPTO_RsaKeyGenerationContext *keygen; + char *filename; + unsigned int *counter; +}; + + +/** + * Writes the encrypted private key of a zone in a file + * + * @param filename where to store the zone + * @param c the crypto container containing private key of the zone + * @return GNUNET_OK on success, GNUNET_SYSERR on failure + */ +static int +write_key_to_file (const char *filename, + struct GNUNET_NAMESTORE_CryptoContainer *c) { struct GNUNET_CRYPTO_RsaPrivateKey *ret = c->privkey; struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded *enc; struct GNUNET_DISK_FileHandle *fd; + struct GNUNET_CRYPTO_ShortHashCode zone; + struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pubkey; + struct GNUNET_CRYPTO_RsaPrivateKey *privkey; - if (GNUNET_YES == GNUNET_DISK_file_test (filename)) + fd = GNUNET_DISK_file_open (filename, + GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE | GNUNET_DISK_OPEN_FAILIFEXISTS, + GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE); + if ( (NULL == fd) && (EEXIST == errno) ) { - struct GNUNET_CRYPTO_ShortHashCode zone; - struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pubkey; - struct GNUNET_CRYPTO_RsaPrivateKey * privkey; - - privkey = GNUNET_CRYPTO_rsa_key_create_from_file(filename); - if (privkey == NULL) + privkey = GNUNET_CRYPTO_rsa_key_create_from_file (filename); + if (NULL == privkey) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - _("File zone `%s' but corrupt content already exists, failed to write! \n"), GNUNET_short_h2s (&zone)); + _("Failed to write zone key to file `%s': %s\n"), + filename, + _("file exists but reading key failed")); return GNUNET_SYSERR; } - GNUNET_CRYPTO_rsa_key_get_public (privkey, &pubkey); GNUNET_CRYPTO_short_hash (&pubkey, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), &zone); GNUNET_CRYPTO_rsa_key_free (privkey); - if (0 == memcmp (&zone, &c->zone, sizeof(zone))) { - GNUNET_log (GNUNET_ERROR_TYPE_INFO, - _("File zone `%s' containing this key already exists\n"), GNUNET_short_h2s (&zone)); - return GNUNET_OK; - } - else - { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - _("File zone `%s' but different zone key already exists, failed to write! \n"), GNUNET_short_h2s (&zone)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "File zone `%s' containing this key already exists\n", + GNUNET_short_h2s (&zone)); return GNUNET_OK; } + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + _("Failed to write zone key to file `%s': %s\n"), + filename, + _("file exists with different key")); + return GNUNET_OK; } - fd = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE | GNUNET_DISK_OPEN_FAILIFEXISTS, GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE); if (NULL == fd) { - if (errno == EEXIST) - { - if (GNUNET_YES != GNUNET_DISK_file_test (filename)) - { - /* must exist but not be accessible, fail for good! */ - if (0 != ACCESS (filename, R_OK)) - LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "access", filename); - else - GNUNET_break (0); /* what is going on!? */ - return GNUNET_SYSERR; - } - } LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "open", filename); return GNUNET_SYSERR; } - if (GNUNET_YES != GNUNET_DISK_file_lock (fd, 0, sizeof (struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded), GNUNET_YES)) { - GNUNET_assert (GNUNET_YES == GNUNET_DISK_file_close (fd)); + GNUNET_break (GNUNET_YES == GNUNET_DISK_file_close (fd)); return GNUNET_SYSERR; } enc = GNUNET_CRYPTO_rsa_encode_key (ret); - GNUNET_assert (enc != NULL); + GNUNET_assert (NULL != enc); GNUNET_assert (ntohs (enc->len) == GNUNET_DISK_file_write (fd, enc, ntohs (enc->len))); GNUNET_free (enc); GNUNET_DISK_file_sync (fd); if (GNUNET_YES != GNUNET_DISK_file_unlock (fd, 0, sizeof (struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded))) LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename); 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; } -int zone_to_disk_it (void *cls, - const GNUNET_HashCode *key, - void *value) -{ - struct GNUNET_NAMESTORE_CryptoContainer * c = value; - if (c->filename != NULL) - write_key_to_file(c->filename, c); - else - { - GNUNET_asprintf(&c->filename, "%s/%s.zkey", zonefile_directory, GNUNET_short_h2s (&c->zone)); - write_key_to_file(c->filename, c); - } - +/** + * Write allthe given zone key to disk and then removes the entry from the + * 'zonekeys' hash map. + * + * @param cls unused + * @param key zone key + * @param value 'struct GNUNET_NAMESTORE_CryptoContainer' containing the private + * key + * @return GNUNET_OK to continue iteration + */ +static int +zone_to_disk_it (void *cls, + const struct GNUNET_HashCode *key, + void *value) +{ + struct GNUNET_NAMESTORE_CryptoContainer *c = value; + + if (NULL == c->filename) + GNUNET_asprintf(&c->filename, + "%s/%s.zkey", + zonefile_directory, + GNUNET_short_h2s (&c->zone)); + (void) write_key_to_file(c->filename, c); GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multihashmap_remove (zonekeys, key, value)); GNUNET_CRYPTO_rsa_key_free (c->privkey); - GNUNET_free (c->pubkey); GNUNET_free (c->filename); GNUNET_free (c); - return GNUNET_OK; } -struct GNUNET_TIME_Absolute +/** + * Add the given private key to the set of private keys + * this namestore can use to sign records when needed. + * + * @param pkey private key to add to our list (reference will + * be taken over or freed and should not be used afterwards) + */ +static void +learn_private_key (struct GNUNET_CRYPTO_RsaPrivateKey *pkey) +{ + struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pub; + struct GNUNET_HashCode long_hash; + struct GNUNET_CRYPTO_ShortHashCode pubkey_hash; + struct GNUNET_NAMESTORE_CryptoContainer *cc; + + GNUNET_CRYPTO_rsa_key_get_public (pkey, &pub); + GNUNET_CRYPTO_short_hash (&pub, + sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), + &pubkey_hash); + GNUNET_CRYPTO_short_hash_double (&pubkey_hash, &long_hash); + + if (GNUNET_NO != GNUNET_CONTAINER_multihashmap_contains(zonekeys, &long_hash)) + { + GNUNET_CRYPTO_rsa_key_free (pkey); + return; + } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received new private key for zone `%s'\n", + GNUNET_short_h2s(&pubkey_hash)); + cc = GNUNET_malloc (sizeof (struct GNUNET_NAMESTORE_CryptoContainer)); + cc->privkey = pkey; + cc->zone = pubkey_hash; + GNUNET_assert (GNUNET_YES == + GNUNET_CONTAINER_multihashmap_put(zonekeys, &long_hash, cc, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); +} + + +/** + * Returns the expiration time of the given block of records. The block + * expiration time is the expiration time of the block with smallest + * expiration time. + * + * @param rd_count number of records given in 'rd' + * @param rd array of records + * @return absolute expiration time + */ +static struct GNUNET_TIME_Absolute get_block_expiration_time (unsigned int rd_count, const struct GNUNET_NAMESTORE_RecordData *rd) { unsigned int c; - struct GNUNET_TIME_Absolute expire = GNUNET_TIME_UNIT_FOREVER_ABS; + struct GNUNET_TIME_Absolute expire; + struct GNUNET_TIME_Absolute at; + struct GNUNET_TIME_Relative rt; if (NULL == rd) return GNUNET_TIME_UNIT_ZERO_ABS; + expire = GNUNET_TIME_UNIT_FOREVER_ABS; for (c = 0; c < rd_count; c++) - expire = GNUNET_TIME_absolute_min (rd[c].expiration, expire); + { + if (0 != (rd[c].flags & GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION)) + { + rt.rel_value = rd[c].expiration_time; + at = GNUNET_TIME_relative_to_absolute (rt); + } + else + { + at.abs_value = rd[c].expiration_time; + } + expire = GNUNET_TIME_absolute_min (at, expire); + } return expire; } + /** * Task run during shutdown. * @@ -245,240 +399,341 @@ get_block_expiration_time (unsigned int rd_count, const struct GNUNET_NAMESTORE_ static void cleanup_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { + struct GNUNET_NAMESTORE_ZoneIteration *no; + struct GNUNET_NAMESTORE_Client *nc; + struct KeyLoadContext *kl; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping namestore service\n"); - struct GNUNET_NAMESTORE_ZoneIteration * no; - struct GNUNET_NAMESTORE_ZoneIteration * tmp; - struct GNUNET_NAMESTORE_Client * nc; - struct GNUNET_NAMESTORE_Client * next; + if (NULL != snc) + { + GNUNET_SERVER_notification_context_destroy (snc); + snc = NULL; + } - GNUNET_SERVER_notification_context_destroy (snc); - snc = NULL; - GNUNET_CONTAINER_multihashmap_iterate(zonekeys, &zone_to_disk_it, NULL); - GNUNET_CONTAINER_multihashmap_destroy(zonekeys); + while (NULL != (kl = kl_head)) + { + GNUNET_CONTAINER_DLL_remove (kl_head, kl_tail, kl); + if (NULL != kl->keygen) + GNUNET_CRYPTO_rsa_key_create_stop (kl->keygen); + GNUNET_free (kl->filename); + GNUNET_free (kl); + } - for (nc = client_head; nc != NULL; nc = next) + GNUNET_CONTAINER_multihashmap_iterate (zonekeys, &zone_to_disk_it, NULL); + GNUNET_CONTAINER_multihashmap_destroy (zonekeys); + zonekeys = NULL; + while (NULL != (nc = client_head)) { - next = nc->next; - for (no = nc->op_head; no != NULL; no = tmp) + while (NULL != (no = nc->op_head)) { GNUNET_CONTAINER_DLL_remove (nc->op_head, nc->op_tail, no); - tmp = no->next; GNUNET_free (no); } GNUNET_SERVER_client_drop(nc->client); GNUNET_CONTAINER_DLL_remove (client_head, client_tail, nc); GNUNET_free (nc); } - GNUNET_break (NULL == GNUNET_PLUGIN_unload (db_lib_name, GSN_database)); GNUNET_free (db_lib_name); - GNUNET_free_non_null(zonefile_directory); + db_lib_name = NULL; + GNUNET_free_non_null (zonefile_directory); + zonefile_directory = NULL; } + +/** + * Lookup our internal data structure for a given client. + * + * @param client server client handle to use for the lookup + * @return our internal structure for the client, NULL if + * we do not have any yet + */ static struct GNUNET_NAMESTORE_Client * client_lookup (struct GNUNET_SERVER_Client *client) { - struct GNUNET_NAMESTORE_Client * nc; + struct GNUNET_NAMESTORE_Client *nc; GNUNET_assert (NULL != client); - - for (nc = client_head; nc != NULL; nc = nc->next) - { + for (nc = client_head; NULL != nc; nc = nc->next) if (client == nc->client) - break; - } - return nc; + return nc; + return NULL; } + /** - * Called whenever a client is disconnected. Frees our - * resources associated with that client. + * Called whenever a client is disconnected. + * Frees our resources associated with that client. * * @param cls closure * @param client identification of the client */ static void -client_disconnect_notification (void *cls, struct GNUNET_SERVER_Client *client) +client_disconnect_notification (void *cls, + struct GNUNET_SERVER_Client *client) { - struct GNUNET_NAMESTORE_ZoneIteration * no; - struct GNUNET_NAMESTORE_Client * nc; + struct GNUNET_NAMESTORE_ZoneIteration *no; + struct GNUNET_NAMESTORE_Client *nc; + if (NULL == client) return; - - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p disconnected \n", client); - - nc = client_lookup (client); - - if ((NULL == client) || (NULL == nc)) + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Client %p disconnected\n", + client); + if (NULL == (nc = client_lookup (client))) return; - - no = nc->op_head; - while (NULL != no) + while (NULL != (no = nc->op_head)) { GNUNET_CONTAINER_DLL_remove (nc->op_head, nc->op_tail, no); GNUNET_free (no); - no = nc->op_head; } - - GNUNET_SERVER_client_drop(nc->client); + GNUNET_SERVER_client_drop (nc->client); GNUNET_CONTAINER_DLL_remove (client_head, client_tail, nc); GNUNET_free (nc); - nc = NULL; } - -static void handle_start (void *cls, - struct GNUNET_SERVER_Client * client, - const struct GNUNET_MessageHeader * message) +/** + * Handles a 'GNUNET_MESSAGE_TYPE_NAMESTORE_START' message + * + * @param cls unused + * @param client GNUNET_SERVER_Client sending the message + * @param message unused + */ +static void +handle_start (void *cls, + struct GNUNET_SERVER_Client *client, + const struct GNUNET_MessageHeader *message) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p connected\n", client); + struct GNUNET_NAMESTORE_Client *nc; - struct GNUNET_NAMESTORE_Client * nc = GNUNET_malloc (sizeof (struct GNUNET_NAMESTORE_Client)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Client %p connected\n", client); + if (NULL != client_lookup (client)) + { + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); + return; + } + nc = GNUNET_malloc (sizeof (struct GNUNET_NAMESTORE_Client)); nc->client = client; GNUNET_SERVER_notification_context_add (snc, client); - GNUNET_CONTAINER_DLL_insert(client_head, client_tail, nc); + GNUNET_CONTAINER_DLL_insert (client_head, client_tail, nc); GNUNET_SERVER_client_keep (client); GNUNET_SERVER_receive_done (client, GNUNET_OK); } + +/** + * 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; + + /** + * Requested zone + */ + const struct GNUNET_CRYPTO_ShortHashCode *zone; + + /** + * Requested name + */ + const char *name; + + /** + * Operation id for the name lookup + */ uint32_t request_id; + + /** + * Requested specific record type + */ uint32_t record_type; - struct GNUNET_CRYPTO_ShortHashCode *zone; - char * name; }; -void drop_iterator (void *cls, - const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key, - struct GNUNET_TIME_Absolute expire, - const char *name, - unsigned int rd_len, - const struct GNUNET_NAMESTORE_RecordData *rd, - const struct GNUNET_CRYPTO_RsaSignature *signature) -{ - struct GNUNET_CRYPTO_ShortHashCode zone_hash; - int * stop = cls; - if (NULL != zone_key) - { - GNUNET_CRYPTO_short_hash(zone_key, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), &zone_hash); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Deleting zone `%s'\n", GNUNET_short_h2s (&zone_hash)); - GSN_database->delete_zone (GSN_database->cls, &zone_hash); - } - else - { - (*stop) = GNUNET_YES; - } -} - +/** + * 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, - struct GNUNET_TIME_Absolute expire, - const char *name, - unsigned int rd_count, - const struct GNUNET_NAMESTORE_RecordData *rd, - const struct GNUNET_CRYPTO_RsaSignature *signature) + const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key, + struct GNUNET_TIME_Absolute expire, + const char *name, + unsigned int rd_count, + const struct GNUNET_NAMESTORE_RecordData *rd, + const struct GNUNET_CRYPTO_RsaSignature *signature) { - /* send response */ struct LookupNameContext *lnc = cls; struct LookupNameResponseMessage *lnr_msg; - struct GNUNET_NAMESTORE_RecordData *rd_selected = NULL; + struct GNUNET_NAMESTORE_RecordData *rd_selected; struct GNUNET_NAMESTORE_CryptoContainer *cc; - struct GNUNET_CRYPTO_RsaSignature *signature_new = NULL; + struct GNUNET_CRYPTO_RsaSignature *signature_new; struct GNUNET_TIME_Absolute e; + struct GNUNET_TIME_Relative re; struct GNUNET_CRYPTO_ShortHashCode zone_key_hash; - GNUNET_HashCode long_hash; + struct GNUNET_HashCode long_hash; char *rd_tmp; char *name_tmp; size_t rd_ser_len; - size_t r_size = 0; - size_t name_len = 0; - - int copied_elements = 0; - int contains_signature = GNUNET_NO; - int authoritative = GNUNET_NO; - int c; + size_t r_size; + size_t name_len; + int copied_elements; + int contains_signature; + int authoritative; + int rd_modified; + unsigned int c; - if (NULL != name) - name_len = strlen(name) + 1; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Found %u records under name `%s'\n", + rd_count, + name); + authoritative = GNUNET_NO; + signature_new = NULL; + cc = NULL; + if (NULL != zone_key) + { + GNUNET_CRYPTO_short_hash (zone_key, + sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), + &zone_key_hash); + GNUNET_CRYPTO_short_hash_double (&zone_key_hash, &long_hash); + if (NULL != (cc = GNUNET_CONTAINER_multihashmap_get (zonekeys, &long_hash))) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Am authoritative for zone `%s'\n", + GNUNET_short_h2s (&zone_key_hash)); + authoritative = GNUNET_YES; + } + } + copied_elements = 0; + rd_modified = GNUNET_NO; + rd_selected = NULL; /* count records to copy */ - if (rd_count != 0) + for (c = 0; c < rd_count; c++) { - if (lnc->record_type != 0) + if ( (GNUNET_YES == authoritative) && + (GNUNET_YES == + GNUNET_NAMESTORE_is_expired (&rd[c]) ) ) { - /* special record type needed */ - for (c = 0; c < rd_count; c ++) - if (rd[c].record_type == lnc->record_type) - copied_elements++; /* found matching record */ - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found %u records with type %u for name `%s' in zone `%s'\n", - copied_elements, lnc->record_type, lnc->name, GNUNET_short_h2s(lnc->zone)); - rd_selected = GNUNET_malloc (copied_elements * sizeof (struct GNUNET_NAMESTORE_RecordData)); - copied_elements = 0; - for (c = 0; c < rd_count; c ++) - { - if (rd[c].record_type == lnc->record_type) - { - /* found matching record */ - memcpy (&rd_selected[copied_elements], &rd[c], sizeof (struct GNUNET_NAMESTORE_RecordData)); - copied_elements++; - } - } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Skipping expired record\n"); + continue; } + if ( (GNUNET_NAMESTORE_TYPE_ANY == lnc->record_type) || + (rd[c].record_type == lnc->record_type) ) + copied_elements++; /* found matching record */ else { - copied_elements = rd_count; - rd_selected = (struct GNUNET_NAMESTORE_RecordData *) rd; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Skipping non-mtaching record\n"); + rd_modified = GNUNET_YES; } } - else + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Found %u records with type %u for name `%s' in zone `%s'\n", + copied_elements, + lnc->record_type, + lnc->name, + GNUNET_short_h2s(lnc->zone)); + if (copied_elements > 0) { - /* No results */ + rd_selected = GNUNET_malloc (copied_elements * sizeof (struct GNUNET_NAMESTORE_RecordData)); copied_elements = 0; - rd_selected = NULL; - expire = GNUNET_TIME_UNIT_ZERO_ABS; + for (c = 0; c < rd_count; c++) + { + if ( (GNUNET_YES == authoritative) && + (GNUNET_YES == + GNUNET_NAMESTORE_is_expired (&rd[c])) ) + continue; + if ( (GNUNET_NAMESTORE_TYPE_ANY == lnc->record_type) || + (rd[c].record_type == lnc->record_type) ) + { + if (0 != (rd[c].flags & GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION)) + { + GNUNET_break (GNUNET_YES == authoritative); + rd_modified = GNUNET_YES; + re.rel_value = rd[c].expiration_time; + e = GNUNET_TIME_relative_to_absolute (re); + } + else + { + e.abs_value = rd[c].expiration_time; + } + /* found matching record, copy and convert flags to public format */ + rd_selected[copied_elements] = rd[c]; /* shallow copy! */ + rd_selected[copied_elements].expiration_time = e.abs_value; + if (0 != (rd_selected[copied_elements].flags & + (GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION | GNUNET_NAMESTORE_RF_AUTHORITY))) + { + rd_selected[copied_elements].flags &= ~ (GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION | + GNUNET_NAMESTORE_RF_AUTHORITY); + rd_modified = GNUNET_YES; + } + copied_elements++; + } + else + { + rd_modified = GNUNET_YES; + } + } } - - rd_ser_len = GNUNET_NAMESTORE_records_get_size(copied_elements, rd_selected); - char rd_ser[rd_ser_len]; - GNUNET_NAMESTORE_records_serialize(copied_elements, rd_selected, rd_ser_len, rd_ser); - - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found %u records for name `%s' in zone `%s'\n", - copied_elements, lnc->name, GNUNET_short_h2s(lnc->zone)); - - if ((copied_elements == rd_count) && (NULL != signature)) - contains_signature = GNUNET_YES; /* returning all records, so include signature */ else - contains_signature = GNUNET_NO; /* returning not all records, so do not include signature */ - + rd_selected = NULL; - if ((NULL != zone_key) && (copied_elements == rd_count)) + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Found %u matching records for name `%s' in zone `%s'\n", + copied_elements, + lnc->name, + GNUNET_short_h2s (lnc->zone)); + contains_signature = GNUNET_NO; + if (copied_elements > 0) { - GNUNET_CRYPTO_short_hash(zone_key, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), &zone_key_hash); - GNUNET_CRYPTO_short_hash_double (&zone_key_hash, &long_hash); - if (GNUNET_CONTAINER_multihashmap_contains(zonekeys, &long_hash)) + if (GNUNET_YES == authoritative) { - cc = GNUNET_CONTAINER_multihashmap_get(zonekeys, &long_hash); - e = get_block_expiration_time(rd_count, rd); - signature_new = GNUNET_NAMESTORE_create_signature(cc->privkey, e, name, rd, rd_count); - GNUNET_assert (signature_new != NULL); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Creating signature for name `%s' with %u records in zone `%s'\n",name, copied_elements, GNUNET_short_h2s(&zone_key_hash)); - authoritative = GNUNET_YES; + GNUNET_assert (NULL != cc); + e = get_block_expiration_time (rd_count, rd); + signature_new = GNUNET_NAMESTORE_create_signature (cc->privkey, e, name, rd_selected, copied_elements); + GNUNET_assert (NULL != signature_new); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Creating signature for name `%s' with %u records in zone `%s'\n", + name, + copied_elements, + GNUNET_short_h2s(&zone_key_hash)); } else - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "I am not authoritative for name `%s' in zone `%s'\n",name, GNUNET_short_h2s(&zone_key_hash)); + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Not authoritative, records modified is %d, have sig is %d\n", + rd_modified, + NULL != signature); + if ((GNUNET_NO == rd_modified) && (NULL != signature)) + contains_signature = GNUNET_YES; /* returning all records, so include signature */ + } } + rd_ser_len = GNUNET_NAMESTORE_records_get_size (copied_elements, rd_selected); + name_len = (NULL == name) ? 0 : strlen(name) + 1; r_size = sizeof (struct LookupNameResponseMessage) + sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) + name_len + rd_ser_len; - - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message\n", "NAMESTORE_LOOKUP_NAME_RESPONSE"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Sending `%s' message\n", + "NAMESTORE_LOOKUP_NAME_RESPONSE"); lnr_msg = GNUNET_malloc (r_size); lnr_msg->gns_header.header.type = ntohs (GNUNET_MESSAGE_TYPE_NAMESTORE_LOOKUP_NAME_RESPONSE); lnr_msg->gns_header.header.size = ntohs (r_size); @@ -486,20 +741,22 @@ handle_lookup_name_it (void *cls, lnr_msg->rd_count = htons (copied_elements); lnr_msg->rd_len = htons (rd_ser_len); lnr_msg->name_len = htons (name_len); - lnr_msg->expire = GNUNET_TIME_absolute_hton(get_block_expiration_time(copied_elements, rd_selected)); - + lnr_msg->expire = GNUNET_TIME_absolute_hton (get_block_expiration_time (copied_elements, + rd_selected)); + name_tmp = (char *) &lnr_msg[1]; + memcpy (name_tmp, name, name_len); + rd_tmp = &name_tmp[name_len]; + GNUNET_NAMESTORE_records_serialize (copied_elements, rd_selected, rd_ser_len, rd_tmp); if (rd_selected != rd) - GNUNET_free (rd_selected); - - if (zone_key != NULL) - lnr_msg->public_key = (*zone_key); - else - memset(&lnr_msg->public_key, '\0', sizeof (lnr_msg->public_key)); - - if (GNUNET_YES == authoritative) - { /* use new created signature */ + GNUNET_free_non_null (rd_selected); + if (NULL != zone_key) + lnr_msg->public_key = *zone_key; + if ( (GNUNET_YES == authoritative) && + (copied_elements > 0) ) + { + /* use new created signature */ lnr_msg->contains_sig = htons (GNUNET_YES); - GNUNET_assert (signature_new != NULL); + GNUNET_assert (NULL != signature_new); lnr_msg->signature = *signature_new; GNUNET_free (signature_new); } @@ -507,392 +764,433 @@ handle_lookup_name_it (void *cls, { /* use existing signature */ lnr_msg->contains_sig = htons (GNUNET_YES); - GNUNET_assert (signature != NULL); + GNUNET_assert (NULL != signature); lnr_msg->signature = *signature; } - else - { - /* use no signature */ - memset (&lnr_msg->signature, '\0', sizeof (lnr_msg->signature)); - } - - name_tmp = (char *) &lnr_msg[1]; - rd_tmp = &name_tmp[name_len]; - - memcpy (name_tmp, name, name_len); - memcpy (rd_tmp, rd_ser, rd_ser_len); - - GNUNET_SERVER_notification_context_unicast (snc, lnc->nc->client, (const struct GNUNET_MessageHeader *) lnr_msg, GNUNET_NO); + GNUNET_SERVER_notification_context_unicast (snc, lnc->nc->client, + &lnr_msg->gns_header.header, + GNUNET_NO); GNUNET_free (lnr_msg); } -static void handle_lookup_name (void *cls, - struct GNUNET_SERVER_Client * client, - const struct GNUNET_MessageHeader * message) + +/** + * Handles a 'GNUNET_MESSAGE_TYPE_NAMESTORE_LOOKUP_NAME' message + * + * @param cls unused + * @param client GNUNET_SERVER_Client sending the message + * @param message message of type 'struct LookupNameMessage' + */ +static void +handle_lookup_name (void *cls, + struct GNUNET_SERVER_Client *client, + const struct GNUNET_MessageHeader *message) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message\n", "NAMESTORE_LOOKUP_NAME"); + const struct LookupNameMessage *ln_msg; struct LookupNameContext lnc; struct GNUNET_NAMESTORE_Client *nc; size_t name_len; - char * name; - uint32_t rid = 0; - uint32_t type = 0; + const char *name; + uint32_t rid; + uint32_t type; + char *conv_name; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received `%s' message\n", + "NAMESTORE_LOOKUP_NAME"); if (ntohs (message->size) < sizeof (struct LookupNameMessage)) { - GNUNET_break_op (0); - GNUNET_SERVER_receive_done (client, GNUNET_OK); + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } - - nc = client_lookup(client); - if (nc == NULL) + if (NULL == (nc = client_lookup(client))) { - GNUNET_break_op (0); - GNUNET_SERVER_receive_done (client, GNUNET_OK); + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } - - struct LookupNameMessage * ln_msg = (struct LookupNameMessage *) message; + ln_msg = (const struct LookupNameMessage *) message; rid = ntohl (ln_msg->gns_header.r_id); name_len = ntohl (ln_msg->name_len); type = ntohl (ln_msg->record_type); - - if ((name_len == 0) || (name_len > 256)) + if ((0 == name_len) || (name_len > MAX_NAME_LEN)) { - GNUNET_break_op (0); - GNUNET_SERVER_receive_done (client, GNUNET_OK); + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } - - name = (char *) &ln_msg[1]; - if (name[name_len -1] != '\0') + name = (const char *) &ln_msg[1]; + if ('\0' != name[name_len -1]) { - GNUNET_break_op (0); - GNUNET_SERVER_receive_done (client, GNUNET_OK); + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } - - if (0 == type) - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Looking up all records for name `%s' in zone `%s'\n", name, GNUNET_short_h2s(&ln_msg->zone)); + if (GNUNET_NAMESTORE_TYPE_ANY == type) + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Looking up all records for name `%s' in zone `%s'\n", + name, + GNUNET_short_h2s(&ln_msg->zone)); else - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Looking up records with type %u for name `%s' in zone `%s'\n", type, name, GNUNET_short_h2s(&ln_msg->zone)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Looking up records with type %u for name `%s' in zone `%s'\n", + type, name, + GNUNET_short_h2s(&ln_msg->zone)); + + conv_name = GNUNET_NAMESTORE_normalize_string (name); + if (NULL == conv_name) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Error converting name `%s'\n", name); + return; + } /* do the actual lookup */ lnc.request_id = rid; lnc.nc = nc; lnc.record_type = type; - lnc.name = name; + lnc.name = conv_name; lnc.zone = &ln_msg->zone; - GSN_database->iterate_records(GSN_database->cls, &ln_msg->zone, name, 0, &handle_lookup_name_it, &lnc); - + if (GNUNET_SYSERR == + GSN_database->iterate_records (GSN_database->cls, + &ln_msg->zone, conv_name, 0 /* offset */, + &handle_lookup_name_it, &lnc)) + { + /* internal error (in database plugin); might be best to just hang up on + plugin rather than to signal that there are 'no' results, which + might also be false... */ + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); + GNUNET_free (conv_name); + return; + } + GNUNET_free (conv_name); GNUNET_SERVER_receive_done (client, GNUNET_OK); } -static void handle_record_put (void *cls, - struct GNUNET_SERVER_Client * client, - const struct GNUNET_MessageHeader * message) + +/** + * Handles a 'GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_PUT' message + * + * @param cls unused + * @param client GNUNET_SERVER_Client sending the message + * @param message message of type 'struct RecordPutMessage' + */ +static void +handle_record_put (void *cls, + struct GNUNET_SERVER_Client *client, + const struct GNUNET_MessageHeader *message) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message\n", "NAMESTORE_RECORD_PUT"); struct GNUNET_NAMESTORE_Client *nc; + const struct RecordPutMessage *rp_msg; struct GNUNET_TIME_Absolute expire; - struct GNUNET_CRYPTO_RsaSignature *signature; + const struct GNUNET_CRYPTO_RsaSignature *signature; struct RecordPutResponseMessage rpr_msg; + struct GNUNET_CRYPTO_ShortHashCode zone_hash; size_t name_len; size_t msg_size; size_t msg_size_exp; - char * name; - char * rd_ser; - uint32_t rid = 0; + const char *name; + const char *rd_ser; + char * conv_name; + uint32_t rid; uint32_t rd_ser_len; uint32_t rd_count; - int res = GNUNET_SYSERR; + int res; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received `%s' message\n", + "NAMESTORE_RECORD_PUT"); if (ntohs (message->size) < sizeof (struct RecordPutMessage)) { - GNUNET_break_op (0); - GNUNET_SERVER_receive_done (client, GNUNET_OK); + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } - - nc = client_lookup (client); - if (nc == NULL) + if (NULL == (nc = client_lookup (client))) { - GNUNET_break_op (0); - GNUNET_SERVER_receive_done (client, GNUNET_OK); + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } - - struct RecordPutMessage * rp_msg = (struct RecordPutMessage *) message; - + rp_msg = (const struct RecordPutMessage *) message; rid = ntohl (rp_msg->gns_header.r_id); msg_size = ntohs (rp_msg->gns_header.header.size); name_len = ntohs (rp_msg->name_len); rd_count = ntohs (rp_msg->rd_count); - rd_ser_len = ntohs(rp_msg->rd_len); - - if (msg_size > GNUNET_SERVER_MAX_MESSAGE_SIZE) - { - GNUNET_break_op (0); - GNUNET_SERVER_receive_done (client, GNUNET_OK); - return; - } - - if ((rd_count < 1) || (rd_ser_len < 1) || (name_len >=256) || (name_len == 0)) + rd_ser_len = ntohs (rp_msg->rd_len); + if ((rd_count < 1) || (rd_ser_len < 1) || (name_len >= MAX_NAME_LEN) || (0 == name_len)) { - GNUNET_break_op (0); - GNUNET_SERVER_receive_done (client, GNUNET_OK); + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } - - msg_size_exp = sizeof (struct RecordPutMessage) + name_len + rd_ser_len; + msg_size_exp = sizeof (struct RecordPutMessage) + name_len + rd_ser_len; if (msg_size != msg_size_exp) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Expected message %u size but message size is %u \n", msg_size_exp, msg_size); - GNUNET_break_op (0); - GNUNET_SERVER_receive_done (client, GNUNET_OK); + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } - if ((name_len == 0) || (name_len > 256)) + name = (const char *) &rp_msg[1]; + if ('\0' != name[name_len -1]) { - GNUNET_break_op (0); - GNUNET_SERVER_receive_done (client, GNUNET_OK); + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } + expire = GNUNET_TIME_absolute_ntoh (rp_msg->expire); + signature = &rp_msg->signature; + rd_ser = &name[name_len]; + struct GNUNET_NAMESTORE_RecordData rd[rd_count]; - name = (char *) &rp_msg[1]; - - if (name[name_len -1] != '\0') + if (GNUNET_OK != + GNUNET_NAMESTORE_records_deserialize (rd_ser_len, rd_ser, rd_count, rd)) { - GNUNET_break_op (0); - GNUNET_SERVER_receive_done (client, GNUNET_OK); + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } + GNUNET_CRYPTO_short_hash (&rp_msg->public_key, + sizeof (rp_msg->public_key), + &zone_hash); - expire = GNUNET_TIME_absolute_ntoh(rp_msg->expire); - signature = (struct GNUNET_CRYPTO_RsaSignature *) &rp_msg->signature; - - rd_ser = &name[name_len]; - struct GNUNET_NAMESTORE_RecordData rd[rd_count]; - res = GNUNET_NAMESTORE_records_deserialize(rd_ser_len, rd_ser, rd_count, rd); - if (res != GNUNET_OK) + conv_name = GNUNET_NAMESTORE_normalize_string (name); + if (NULL == conv_name) { - GNUNET_break_op (0); - goto send; + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Error converting name `%s'\n", name); + return; } - struct GNUNET_CRYPTO_ShortHashCode zone_hash; - GNUNET_CRYPTO_short_hash (&rp_msg->public_key, sizeof (rp_msg->public_key), &zone_hash); - - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Putting %u record for name `%s' in zone `%s'\n", rd_count, name, GNUNET_short_h2s(&zone_hash)); - - /* Database operation */ + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Putting %u records under name `%s' in zone `%s'\n", + rd_count, conv_name, + GNUNET_short_h2s (&zone_hash)); res = GSN_database->put_records(GSN_database->cls, - &rp_msg->public_key, - expire, - name, - rd_count, rd, - signature); - - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Putting record for name `%s': %s\n", - name, (res == GNUNET_OK) ? "OK" : "FAIL"); - - /* Send response */ -send: - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message\n", "RECORD_PUT_RESPONSE"); + &rp_msg->public_key, + expire, + conv_name, + rd_count, rd, + signature); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Putting record for name `%s': %s\n", + conv_name, + (GNUNET_OK == res) ? "OK" : "FAILED"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Sending `%s' message\n", + "RECORD_PUT_RESPONSE"); + GNUNET_free (conv_name); rpr_msg.gns_header.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_PUT_RESPONSE); rpr_msg.gns_header.header.size = htons (sizeof (struct RecordPutResponseMessage)); rpr_msg.gns_header.r_id = htonl (rid); rpr_msg.op_result = htonl (res); - GNUNET_SERVER_notification_context_unicast (snc, nc->client, (const struct GNUNET_MessageHeader *) &rpr_msg, GNUNET_NO); - + GNUNET_SERVER_notification_context_unicast (snc, + nc->client, + &rpr_msg.gns_header.header, + GNUNET_NO); GNUNET_SERVER_receive_done (client, GNUNET_OK); } + +/** + * Context for record create operations passed from 'handle_record_create' to + * 'handle_create_record_it' as closure + */ struct CreateRecordContext { - struct GNUNET_NAMESTORE_RecordData *rd; - struct GNUNET_CRYPTO_RsaPrivateKey *pkey; - struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *pubkey; + /** + * Record data + */ + const struct GNUNET_NAMESTORE_RecordData *rd; + + /** + * Zone's public key + */ + struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pubkey; + + /** + * Name for the record to create + */ + const char *name; + + /** + * Record expiration time + */ struct GNUNET_TIME_Absolute expire; - 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, - struct GNUNET_TIME_Absolute expire, - const char *name, - unsigned int rd_count, - const struct GNUNET_NAMESTORE_RecordData *rd, - const struct GNUNET_CRYPTO_RsaSignature *signature) + const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *pubkey, + struct GNUNET_TIME_Absolute expire, + const char *name, + unsigned int rd_count, + const struct GNUNET_NAMESTORE_RecordData *rd, + const struct GNUNET_CRYPTO_RsaSignature *signature) { - struct CreateRecordContext * crc = cls; - struct GNUNET_NAMESTORE_RecordData *rd_new = NULL; - struct GNUNET_CRYPTO_RsaSignature dummy_signature; + static struct GNUNET_CRYPTO_RsaSignature dummy_signature; + struct CreateRecordContext *crc = cls; + struct GNUNET_NAMESTORE_RecordData *rd_new; struct GNUNET_TIME_Absolute block_expiration; - int res; - int exist = GNUNET_SYSERR; - int update = GNUNET_NO; - int c; - int rd_count_new = 0; + int exist; + int update; + unsigned int c; + unsigned int rd_count_new; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found %u existing records for `%s'\n", rd_count, crc->name); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Found %u existing records for `%s'\n", + rd_count, crc->name); + exist = -1; + update = GNUNET_NO; for (c = 0; c < rd_count; c++) { - if ((crc->rd->record_type == GNUNET_NAMESTORE_TYPE_PKEY) && (rd[c].record_type == GNUNET_NAMESTORE_TYPE_PKEY)) - { - /* Update unique PKEY */ - exist = c; - update = GNUNET_YES; - break; - } - else if ((crc->rd->record_type == GNUNET_NAMESTORE_TYPE_PSEU) && (rd[c].record_type == GNUNET_NAMESTORE_TYPE_PSEU)) + if ( (crc->rd->record_type != rd[c].record_type) || + ((crc->rd->flags & GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION) + != (rd[c].flags & GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION)) ) + continue; /* no match */ + if ( (GNUNET_NAMESTORE_TYPE_PKEY == crc->rd->record_type) || + (GNUNET_NAMESTORE_TYPE_PSEU == crc->rd->record_type) || + (GNUNET_DNSPARSER_TYPE_CNAME == crc->rd->record_type) ) { - /* Update unique PSEU */ + /* Update unique PKEY, PSEU or CNAME record; for these + record types, only one can be active at any time */ exist = c; - update = GNUNET_YES; - break; + if ( (crc->rd->data_size != rd[c].data_size) || + (0 != memcmp (crc->rd->data, rd[c].data, rd[c].data_size)) || + (crc->rd->expiration_time != rd[c].expiration_time) ) + update = GNUNET_YES; + break; } - else if ((crc->rd->record_type == rd[c].record_type) && - (crc->rd->data_size == rd[c].data_size) && - (0 == memcmp (crc->rd->data, rd[c].data, rd[c].data_size))) + if ( (crc->rd->data_size == rd[c].data_size) && + (0 == memcmp (crc->rd->data, rd[c].data, rd[c].data_size))) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found existing records for `%s' to update expiration date!\n", crc->name); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Found matching existing record for `%s'; only updating expiration date!\n", + crc->name); exist = c; - if (crc->rd->expiration.abs_value != rd[c].expiration.abs_value) + if (crc->rd->expiration_time != rd[c].expiration_time) update = GNUNET_YES; - break; + break; } } - if (exist == GNUNET_SYSERR) - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "New record does not exist for name `%s'!\n", crc->name); - - if (exist == GNUNET_SYSERR) - { - rd_new = GNUNET_malloc ((rd_count+1) * sizeof (struct GNUNET_NAMESTORE_RecordData)); - memcpy (rd_new, rd, rd_count * sizeof (struct GNUNET_NAMESTORE_RecordData)); - rd_count_new = rd_count + 1; - rd_new[rd_count] = *(crc->rd); - } - else if (update == GNUNET_NO) + if ( (-1 != exist) && + (GNUNET_NO == update) ) { /* Exact same record already exists */ - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "No update for %s' record required!\n", crc->name); - res = GNUNET_NO; - goto end; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Matching record for %s' exists, no change required!\n", + crc->name); + crc->res = GNUNET_NO; /* identical record existed */ + return; } - else if (update == GNUNET_YES) + if (-1 == exist) { - /* Update record */ - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Updating existing records for `%s'!\n", crc->name); - rd_new = GNUNET_malloc ((rd_count) * sizeof (struct GNUNET_NAMESTORE_RecordData)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "No existing record for name `%s'!\n", + crc->name); + rd_count_new = rd_count + 1; + rd_new = GNUNET_malloc (rd_count_new * sizeof (struct GNUNET_NAMESTORE_RecordData)); memcpy (rd_new, rd, rd_count * sizeof (struct GNUNET_NAMESTORE_RecordData)); + rd_new[rd_count] = *(crc->rd); + } + else + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Updating existing records for `%s'!\n", + crc->name); rd_count_new = rd_count; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Updating expiration from %llu to %llu!\n", rd_new[exist].expiration.abs_value, crc->rd->expiration.abs_value); + rd_new = GNUNET_malloc (rd_count_new * sizeof (struct GNUNET_NAMESTORE_RecordData)); + memcpy (rd_new, rd, rd_count * sizeof (struct GNUNET_NAMESTORE_RecordData)); rd_new[exist] = *(crc->rd); } - - block_expiration = GNUNET_TIME_absolute_max(crc->expire, expire); - if (block_expiration.abs_value != expire.abs_value) - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Updated block expiration time\n"); - - memset (&dummy_signature, '\0', sizeof (dummy_signature)); - - /* Database operation */ - GNUNET_assert ((rd_new != NULL) && (rd_count_new > 0)); - res = GSN_database->put_records(GSN_database->cls, - (const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *) crc->pubkey, - block_expiration, - crc->name, - rd_count_new, rd_new, - &dummy_signature); - GNUNET_break (GNUNET_OK == res); - if (res == GNUNET_OK) - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Successfully put record for `%s' in database \n", crc->name); + block_expiration = GNUNET_TIME_absolute_max (crc->expire, expire); + if (GNUNET_OK != + GSN_database->put_records (GSN_database->cls, + &crc->pubkey, + block_expiration, + crc->name, + rd_count_new, rd_new, + &dummy_signature)) + crc->res = GNUNET_SYSERR; /* error */ + else if (GNUNET_YES == update) + crc->res = GNUNET_NO; /* update */ else - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed to put record for `%s' in database \n", crc->name); - res = GNUNET_YES; - -end: - GNUNET_free_non_null (rd_new); - - switch (res) { - case GNUNET_SYSERR: - /* failed to create the record */ - crc->res = GNUNET_SYSERR; - break; - case GNUNET_YES: - /* database operations OK */ - if (GNUNET_YES == update) - { - /* we updated an existing record */ - crc->res = GNUNET_NO; - } - else - { - /* we created a new record */ - crc->res = GNUNET_YES; - } - break; - case GNUNET_NO: - /* identical entry existed, so we did nothing */ - crc->res = GNUNET_NO; - break; - default: - break; - } - - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Update result for name `%s' %u\n", crc->name, res); - + crc->res = GNUNET_YES; /* created new record */ + GNUNET_free (rd_new); } -static void handle_record_create (void *cls, - struct GNUNET_SERVER_Client * client, - const struct GNUNET_MessageHeader * message) + +/** + * Handles a 'GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_CREATE' message + * + * @param cls unused + * @param client GNUNET_SERVER_Client sending the message + * @param message message of type 'struct RecordCreateMessage' + */ +static void +handle_record_create (void *cls, + struct GNUNET_SERVER_Client *client, + const struct GNUNET_MessageHeader *message) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message\n", "NAMESTORE_RECORD_CREATE"); struct GNUNET_NAMESTORE_Client *nc; - struct GNUNET_NAMESTORE_CryptoContainer *cc; + const struct RecordCreateMessage *rp_msg; struct CreateRecordContext crc; struct GNUNET_CRYPTO_RsaPrivateKey *pkey; - struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pub; struct RecordCreateResponseMessage rcr_msg; - struct GNUNET_CRYPTO_ShortHashCode pubkey_hash; - GNUNET_HashCode long_hash; size_t name_len; size_t msg_size; size_t msg_size_exp; size_t rd_ser_len; size_t key_len; - uint32_t rid = 0; - char *pkey_tmp; - char *name_tmp; - char *rd_ser; - int rd_count; - - int res = GNUNET_SYSERR; - crc.res = GNUNET_SYSERR; + uint32_t rid; + const char *pkey_tmp; + const char *name_tmp; + char *conv_name; + const char *rd_ser; + unsigned int rd_count; + int res; + struct GNUNET_NAMESTORE_RecordData rd; + struct GNUNET_CRYPTO_ShortHashCode pubkey_hash; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received `%s' message\n", "NAMESTORE_RECORD_CREATE"); if (ntohs (message->size) < sizeof (struct RecordCreateMessage)) { - GNUNET_break_op (0); - GNUNET_SERVER_receive_done (client, GNUNET_OK); + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } - - nc = client_lookup(client); - if (nc == NULL) + if (NULL == (nc = client_lookup (client))) { - GNUNET_break_op (0); - GNUNET_SERVER_receive_done (client, GNUNET_OK); + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } - - struct RecordCreateMessage * rp_msg = (struct RecordCreateMessage *) message; + rp_msg = (const struct RecordCreateMessage *) message; rid = ntohl (rp_msg->gns_header.r_id); name_len = ntohs (rp_msg->name_len); msg_size = ntohs (message->size); @@ -900,79 +1198,74 @@ static void handle_record_create (void *cls, rd_ser_len = ntohs (rp_msg->rd_len); key_len = ntohs (rp_msg->pkey_len); msg_size_exp = sizeof (struct RecordCreateMessage) + key_len + name_len + rd_ser_len; - - if (msg_size != msg_size_exp) + if ( (msg_size != msg_size_exp) || (1 != rd_count) ) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Expected message %u size but message size is %u \n", msg_size_exp, msg_size); - GNUNET_break_op (0); - GNUNET_SERVER_receive_done (client, GNUNET_OK); + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } - - if ((name_len == 0) || (name_len > 256)) + if ((0 == name_len) || (name_len > MAX_NAME_LEN)) { - GNUNET_break_op (0); - GNUNET_SERVER_receive_done (client, GNUNET_OK); + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } - - pkey_tmp = (char *) &rp_msg[1]; + pkey_tmp = (const char *) &rp_msg[1]; name_tmp = &pkey_tmp[key_len]; rd_ser = &name_tmp[name_len]; - - if (name_tmp[name_len -1] != '\0') + if ('\0' != name_tmp[name_len -1]) { - GNUNET_break_op (0); - GNUNET_SERVER_receive_done (client, GNUNET_OK); + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } - - struct GNUNET_NAMESTORE_RecordData rd[rd_count]; - - res = GNUNET_NAMESTORE_records_deserialize(rd_ser_len, rd_ser, rd_count, rd); - if ((res != GNUNET_OK) || (rd_count != 1)) + if (NULL == (pkey = GNUNET_CRYPTO_rsa_decode_key (pkey_tmp, key_len))) + { + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); + return; + } + if (GNUNET_OK != + GNUNET_NAMESTORE_records_deserialize (rd_ser_len, rd_ser, rd_count, &rd)) { - GNUNET_break_op (0); - goto send; + GNUNET_break (0); + GNUNET_CRYPTO_rsa_key_free (pkey); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); + return; } + /* Extracting and converting private key */ - pkey = GNUNET_CRYPTO_rsa_decode_key((char *) pkey_tmp, key_len); - GNUNET_assert (pkey != NULL); - GNUNET_CRYPTO_rsa_key_get_public(pkey, &pub); - GNUNET_CRYPTO_short_hash (&pub, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), &pubkey_hash); - GNUNET_CRYPTO_short_hash_double (&pubkey_hash, &long_hash); + GNUNET_CRYPTO_rsa_key_get_public (pkey, &crc.pubkey); + GNUNET_CRYPTO_short_hash (&crc.pubkey, + sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), + &pubkey_hash); + learn_private_key (pkey); - if (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains(zonekeys, &long_hash)) + conv_name = GNUNET_NAMESTORE_normalize_string(name_tmp); + if (NULL == conv_name) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received new private key for zone `%s'\n",GNUNET_short_h2s(&pubkey_hash)); - - cc = GNUNET_malloc (sizeof (struct GNUNET_NAMESTORE_CryptoContainer)); - cc->privkey = GNUNET_CRYPTO_rsa_decode_key((char *) pkey_tmp, key_len); - cc->pubkey = GNUNET_malloc(sizeof (pub)); - memcpy (cc->pubkey, &pub, sizeof(pub)); - cc->zone = pubkey_hash; - GNUNET_CONTAINER_multihashmap_put(zonekeys, &long_hash, cc, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY); + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Error converting name `%s'\n", name_tmp); + return; } - + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Creating record for name `%s' in zone `%s'\n", + conv_name, GNUNET_short_h2s(&pubkey_hash)); crc.expire = GNUNET_TIME_absolute_ntoh(rp_msg->expire); crc.res = GNUNET_SYSERR; - crc.pkey = pkey; - crc.pubkey = &pub; - crc.rd = rd; - crc.name = name_tmp; - - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Creating record for name `%s' in zone `%s'\n", name_tmp, GNUNET_short_h2s(&pubkey_hash)); + crc.rd = &rd; + crc.name = conv_name; /* Get existing records for name */ - res = GSN_database->iterate_records(GSN_database->cls, &pubkey_hash, name_tmp, 0, &handle_create_record_it, &crc); + res = GSN_database->iterate_records (GSN_database->cls, &pubkey_hash, conv_name, 0, + &handle_create_record_it, &crc); + GNUNET_free (conv_name); if (res != GNUNET_SYSERR) res = GNUNET_OK; - GNUNET_CRYPTO_rsa_key_free(pkey); - pkey = NULL; /* Send response */ -send: - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message\n", "RECORD_CREATE_RESPONSE"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Sending `%s' message\n", "RECORD_CREATE_RESPONSE"); rcr_msg.gns_header.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_CREATE_RESPONSE); rcr_msg.gns_header.header.size = htons (sizeof (struct RecordCreateResponseMessage)); rcr_msg.gns_header.r_id = htonl (rid); @@ -982,365 +1275,397 @@ send: rcr_msg.op_result = htonl (GNUNET_NO); else rcr_msg.op_result = htonl (GNUNET_SYSERR); - GNUNET_SERVER_notification_context_unicast (snc, nc->client, (const struct GNUNET_MessageHeader *) &rcr_msg, GNUNET_NO); - + GNUNET_SERVER_notification_context_unicast (snc, nc->client, + &rcr_msg.gns_header.header, + GNUNET_NO); GNUNET_SERVER_receive_done (client, GNUNET_OK); } +/** + * Context for record remove operations passed from 'handle_record_remove' to + * 'handle_record_remove_it' as closure + */ struct RemoveRecordContext { - struct GNUNET_NAMESTORE_RecordData *rd; - struct GNUNET_CRYPTO_RsaPrivateKey *pkey; - int remove_name; - uint16_t op_res; + /** + * Record to remove + */ + const struct GNUNET_NAMESTORE_RecordData *rd; + + /** + * See RECORD_REMOVE_RESULT_*-codes. Set by 'handle_record_remove_it' + * to the result of the operation. + */ + int32_t op_res; }; + +/** + * We are to remove a record (or all records for a given name). This function + * will be called with the existing records (if there are any) and is to then + * compute what to keep and trigger the necessary changes. + * + * @param cls the 'struct RecordRemoveContext' with information about what to remove + * @param zone_key public key of the zone + * @param expire when does the corresponding block in the DHT expire (until + * when should we never do a DHT lookup for the same name again)? + * @param name name that is being mapped (at most 255 characters long) + * @param rd_count number of entries in 'rd' array + * @param rd array of records with data to store + * @param signature signature of the record block, NULL if signature is unavailable (i.e. + * because the user queried for a particular record type only) + */ static void handle_record_remove_it (void *cls, - const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key, - struct GNUNET_TIME_Absolute expire, - const char *name, - unsigned int rd_count, - const struct GNUNET_NAMESTORE_RecordData *rd, - const struct GNUNET_CRYPTO_RsaSignature *signature) + const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key, + struct GNUNET_TIME_Absolute expire, + const char *name, + unsigned int rd_count, + const struct GNUNET_NAMESTORE_RecordData *rd, + const struct GNUNET_CRYPTO_RsaSignature *signature) { + static struct GNUNET_CRYPTO_RsaSignature dummy_signature; struct RemoveRecordContext *rrc = cls; unsigned int c; - int res; int found; - unsigned int rd_count_new; - - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Name `%s 'currently has %u records\n", name, rd_count); + struct GNUNET_CRYPTO_ShortHashCode pubkey_hash; - if (rd_count == 0) + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Name `%s 'currently has %u records\n", + name, rd_count); + if (0 == rd_count) { /* Could not find record to remove */ - rrc->op_res = 1; + rrc->op_res = RECORD_REMOVE_RESULT_NO_RECORDS; return; } - /* Find record to remove */ - found = GNUNET_SYSERR; + found = -1; for (c = 0; c < rd_count; c++) { - /* - if (rd[c].flags != rrc->rd->flags) - continue;*/ - if (rd[c].record_type != rrc->rd->record_type) - continue; - /* - if (rd[c].data_size != rrc->rd->data_size) - continue; - GNUNET_break(0); - if (0 != memcmp (rd[c].data, rrc->rd->data, rrc->rd->data_size)) - continue; - GNUNET_break(0); */ + if (GNUNET_YES != + GNUNET_NAMESTORE_records_cmp (&rd[c], + rrc->rd)) + continue; GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found record to remove!\n", rd_count); found = c; break; } - if (GNUNET_SYSERR == found) + if (-1 == found) { /* Could not find record to remove */ - rrc->op_res = 2; + rrc->op_res = RECORD_REMOVE_RESULT_RECORD_NOT_FOUND; return; } - - if (rd_count-1 == 0) + if (1 == rd_count) { - struct GNUNET_CRYPTO_ShortHashCode pubkey_hash; - GNUNET_CRYPTO_short_hash (zone_key, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), &pubkey_hash); - res = GSN_database->remove_records (GSN_database->cls, - &pubkey_hash, - name); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "No records left for name `%s', removing name\n", - name, res); - if (GNUNET_OK != res) + name); + GNUNET_CRYPTO_short_hash (zone_key, + sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), + &pubkey_hash); + if (GNUNET_OK != + GSN_database->remove_records (GSN_database->cls, + &pubkey_hash, + name)) { - /* Could put records into database */ - rrc->op_res = 4; + /* Could not remove records from database */ + rrc->op_res = RECORD_REMOVE_RESULT_FAILED_TO_REMOVE; return; } - rrc->op_res = 0; + rrc->op_res = RECORD_REMOVE_RESULT_SUCCESS; return; } - rd_count_new = rd_count -1; - struct GNUNET_NAMESTORE_RecordData rd_new[rd_count_new]; - - unsigned int c2 = 0; - for (c = 0; c < rd_count; c++) { - if (c != found) + struct GNUNET_NAMESTORE_RecordData rd_new[rd_count - 1]; + unsigned int c2 = 0; + + for (c = 0; c < rd_count; c++) { - GNUNET_assert (c2 < rd_count_new); - rd_new[c2] = rd[c]; - c2++; + if (c == found) + continue; + rd_new[c2++] = rd[c]; + } + if (GNUNET_OK != + GSN_database->put_records(GSN_database->cls, + zone_key, + expire, + name, + rd_count - 1, rd_new, + &dummy_signature)) + { + /* Could not put records into database */ + rrc->op_res = RECORD_REMOVE_RESULT_FAILED_TO_PUT_UPDATE; + return; } } - - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Name `%s' now has %u records\n", name, rd_count_new); - - /* Create dummy signature */ - struct GNUNET_CRYPTO_RsaSignature dummy_signature; - memset (&dummy_signature, '\0', sizeof (dummy_signature)); - - - /* Put records */ - res = GSN_database->put_records(GSN_database->cls, - zone_key, - expire, - name, - rd_count_new, rd_new, - &dummy_signature); - if (GNUNET_OK != res) - { - /* Could put records into database */ - rrc->op_res = 4; - return; - } - - rrc->op_res = 0; + rrc->op_res = RECORD_REMOVE_RESULT_SUCCESS; } -static void handle_record_remove (void *cls, - struct GNUNET_SERVER_Client * client, - const struct GNUNET_MessageHeader * message) + +/** + * Handles a 'GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_REMOVE' message + * + * @param cls unused + * @param client GNUNET_SERVER_Client sending the message + * @param message message of type 'struct RecordRemoveMessage' + */ +static void +handle_record_remove (void *cls, + struct GNUNET_SERVER_Client *client, + const struct GNUNET_MessageHeader *message) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message\n", "NAMESTORE_RECORD_REMOVE"); struct GNUNET_NAMESTORE_Client *nc; + const struct RecordRemoveMessage *rr_msg; struct RecordRemoveResponseMessage rrr_msg; struct GNUNET_CRYPTO_RsaPrivateKey *pkey; - struct GNUNET_NAMESTORE_CryptoContainer *cc = NULL; struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pub; struct GNUNET_CRYPTO_ShortHashCode pubkey_hash; - GNUNET_HashCode long_hash; - char * pkey_tmp = NULL; - char * name_tmp = NULL; - char * rd_ser = NULL; - size_t key_len = 0; - size_t name_len = 0; - size_t rd_ser_len = 0; - size_t msg_size = 0; - size_t msg_size_exp = 0; + struct GNUNET_NAMESTORE_RecordData rd; + const char *pkey_tmp; + const char *name_tmp; + const char *rd_ser; + char * conv_name; + size_t key_len; + size_t name_len; + size_t rd_ser_len; + size_t msg_size; + size_t msg_size_exp; uint32_t rd_count; - uint32_t rid = 0; - - int res = GNUNET_SYSERR; + uint32_t rid; + struct RemoveRecordContext rrc; + int res; + uint64_t off; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received `%s' message\n", + "NAMESTORE_RECORD_REMOVE"); if (ntohs (message->size) < sizeof (struct RecordRemoveMessage)) { - GNUNET_break_op (0); - GNUNET_SERVER_receive_done (client, GNUNET_OK); + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } - - nc = client_lookup(client); - if (nc == NULL) + if (NULL == (nc = client_lookup(client))) { - GNUNET_break_op (0); - GNUNET_SERVER_receive_done (client, GNUNET_OK); + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } - - struct RecordRemoveMessage * rr_msg = (struct RecordRemoveMessage *) message; + rr_msg = (const struct RecordRemoveMessage *) message; rid = ntohl (rr_msg->gns_header.r_id); name_len = ntohs (rr_msg->name_len); rd_ser_len = ntohs (rr_msg->rd_len); rd_count = ntohs (rr_msg->rd_count); key_len = ntohs (rr_msg->pkey_len); msg_size = ntohs (message->size); - - if (msg_size > GNUNET_SERVER_MAX_MESSAGE_SIZE) + if ((name_len >= MAX_NAME_LEN) || (0 == name_len) || (1 < rd_count) ) { - GNUNET_break_op (0); - GNUNET_SERVER_receive_done (client, GNUNET_OK); - return; - } - - if ((name_len >=256) || (name_len == 0)) - { - GNUNET_break_op (0); - GNUNET_SERVER_receive_done (client, GNUNET_OK); + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } - msg_size_exp = sizeof (struct RecordRemoveMessage) + key_len + name_len + rd_ser_len; if (msg_size != msg_size_exp) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Expected message %u size but message size is %u \n", msg_size_exp, msg_size); - GNUNET_break_op (0); - GNUNET_SERVER_receive_done (client, GNUNET_OK); + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } - - pkey_tmp = (char *) &rr_msg[1]; + pkey_tmp = (const char *) &rr_msg[1]; name_tmp = &pkey_tmp[key_len]; rd_ser = &name_tmp[name_len]; - - - if ((name_len == 0) || (name_len > 256)) + if ('\0' != name_tmp[name_len -1]) { - GNUNET_break_op (0); - GNUNET_SERVER_receive_done (client, GNUNET_OK); + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } - - if (name_tmp[name_len -1] != '\0') + if (NULL == (pkey = GNUNET_CRYPTO_rsa_decode_key (pkey_tmp, key_len))) { - GNUNET_break_op (0); - GNUNET_SERVER_receive_done (client, GNUNET_OK); + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } - - /* Extracting and converting private key */ - pkey = GNUNET_CRYPTO_rsa_decode_key((char *) pkey_tmp, key_len); - GNUNET_assert (pkey != NULL); - GNUNET_CRYPTO_rsa_key_get_public(pkey, &pub); - GNUNET_CRYPTO_short_hash (&pub, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), &pubkey_hash); - GNUNET_CRYPTO_short_hash_double (&pubkey_hash, &long_hash); - - if (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains(zonekeys, &long_hash)) + GNUNET_CRYPTO_rsa_key_get_public (pkey, &pub); + GNUNET_CRYPTO_short_hash (&pub, + sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), + &pubkey_hash); + learn_private_key (pkey); + if (GNUNET_OK != + GNUNET_NAMESTORE_records_deserialize (rd_ser_len, rd_ser, rd_count, &rd)) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received new private key for zone `%s'\n",GNUNET_short_h2s(&pubkey_hash)); - cc = GNUNET_malloc (sizeof (struct GNUNET_NAMESTORE_CryptoContainer)); - cc->privkey = GNUNET_CRYPTO_rsa_decode_key((char *) pkey_tmp, key_len); - cc->pubkey = GNUNET_malloc(sizeof (pub)); - memcpy (cc->pubkey, &pub, sizeof(pub)); - cc->zone = pubkey_hash; - - GNUNET_CONTAINER_multihashmap_put(zonekeys, &long_hash, cc, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY); + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); + return; } - - struct GNUNET_NAMESTORE_RecordData rd[rd_count]; - res = GNUNET_NAMESTORE_records_deserialize(rd_ser_len, rd_ser, rd_count, rd); - if ((res != GNUNET_OK) || (rd_count > 1)) + conv_name = GNUNET_NAMESTORE_normalize_string(name_tmp); + if (NULL == conv_name) { - GNUNET_break_op (0); - goto send; + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Error converting name `%s'\n", name_tmp); + return; } if (0 == rd_count) { /* remove the whole name and all records */ - /* Database operation */ res = GSN_database->remove_records (GSN_database->cls, - &pubkey_hash, - name_tmp); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Removing name `%s': %s\n", - name_tmp, (GNUNET_OK == res) ? "OK" : "FAIL"); - + &pubkey_hash, + conv_name); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Removing name `%s': %s\n", + conv_name, (GNUNET_OK == res) ? "OK" : "FAILED"); if (GNUNET_OK != res) /* Could not remove entry from database */ - res = 4; + res = RECORD_REMOVE_RESULT_FAILED_TO_PUT_UPDATE; else - res = 0; + res = RECORD_REMOVE_RESULT_SUCCESS; } else { /* remove a single record */ - struct RemoveRecordContext rrc; - rrc.rd = rd; - rrc.pkey = pkey; - - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Removing record for name `%s' in zone `%s'\n", name_tmp, GNUNET_short_h2s(&pubkey_hash)); - - /* Database operation */ - res = GSN_database->iterate_records (GSN_database->cls, - &pubkey_hash, - name_tmp, - 0, - handle_record_remove_it, &rrc); - - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Removing record for name `%s': %s\n", - name_tmp, (rrc.op_res == 0) ? "OK" : "FAIL"); - res = rrc.op_res; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Removing record for name `%s' in zone `%s'\n", conv_name, + GNUNET_short_h2s (&pubkey_hash)); + rrc.rd = &rd; + rrc.op_res = RECORD_REMOVE_RESULT_RECORD_NOT_FOUND; + off = 0; + res = GNUNET_OK; + while ( (RECORD_REMOVE_RESULT_RECORD_NOT_FOUND == rrc.op_res) && + (GNUNET_OK == res) ) + { + res = GSN_database->iterate_records (GSN_database->cls, + &pubkey_hash, + conv_name, + off++, + &handle_record_remove_it, &rrc); + } + switch (res) + { + case GNUNET_OK: + res = rrc.op_res; + break; + case GNUNET_NO: + GNUNET_break (RECORD_REMOVE_RESULT_NO_RECORDS == rrc.op_res); + res = RECORD_REMOVE_RESULT_NO_RECORDS; + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + _("Failed to find record to remove\n")); + break; + case GNUNET_SYSERR: + res = RECORD_REMOVE_RESULT_FAILED_ACCESS_DATABASE; + break; + default: + GNUNET_break (0); + res = RECORD_REMOVE_RESULT_FAILED_INTERNAL_ERROR; + break; + } } - /* Send response */ -send: - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message\n", "RECORD_REMOVE_RESPONSE"); + GNUNET_free (conv_name); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Sending `%s' message\n", + "RECORD_REMOVE_RESPONSE"); rrr_msg.gns_header.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_REMOVE_RESPONSE); rrr_msg.gns_header.header.size = htons (sizeof (struct RecordRemoveResponseMessage)); rrr_msg.gns_header.r_id = htonl (rid); rrr_msg.op_result = htonl (res); - GNUNET_SERVER_notification_context_unicast (snc, nc->client, (const struct GNUNET_MessageHeader *) &rrr_msg, GNUNET_NO); - - GNUNET_CRYPTO_rsa_key_free (pkey); - + GNUNET_SERVER_notification_context_unicast (snc, nc->client, + &rrr_msg.gns_header.header, + GNUNET_NO); GNUNET_SERVER_receive_done (client, GNUNET_OK); } +/** + * 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 (to be used in the response to the client). + */ uint32_t rid; + + /** + * Set to GNUNET_OK on success, GNUNET_SYSERR on error. Note that + * not finding a name for the zone still counts as a 'success' here, + * as this field is about the success of executing the IPC protocol. + */ + int success; }; + +/** + * 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, - struct GNUNET_TIME_Absolute expire, - const char *name, - unsigned int rd_count, - const struct GNUNET_NAMESTORE_RecordData *rd, - const struct GNUNET_CRYPTO_RsaSignature *signature) + const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key, + struct GNUNET_TIME_Absolute expire, + const char *name, + unsigned int rd_count, + const struct GNUNET_NAMESTORE_RecordData *rd, + const struct GNUNET_CRYPTO_RsaSignature *signature) { - struct ZoneToNameCtx * ztn_ctx = cls; + struct ZoneToNameCtx *ztn_ctx = cls; struct ZoneToNameResponseMessage *ztnr_msg; - int16_t res = GNUNET_SYSERR; - uint16_t name_len = 0; - uint16_t rd_ser_len = 0 ; - int32_t contains_sig = 0; - size_t msg_size = 0; - - char *rd_ser = NULL; + int16_t res; + size_t name_len; + size_t rd_ser_len; + size_t msg_size; char *name_tmp; char *rd_tmp; char *sig_tmp; - if ((zone_key != NULL) && (name != NULL)) + if ((NULL != zone_key) && (NULL != name)) { /* found result */ - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found results: name is `%s', has %u records\n", name, rd_count); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Found result: name `%s' has %u records\n", + name, rd_count); res = GNUNET_YES; - name_len = strlen (name) +1; + name_len = strlen (name) + 1; } else { /* no result found */ - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found no results\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Found no results\n"); res = GNUNET_NO; name_len = 0; } - - if (rd_count > 0) + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Sending `%s' message\n", + "ZONE_TO_NAME_RESPONSE"); + rd_ser_len = GNUNET_NAMESTORE_records_get_size (rd_count, rd); + msg_size = sizeof (struct ZoneToNameResponseMessage) + name_len + rd_ser_len; + if (NULL != signature) + msg_size += sizeof (struct GNUNET_CRYPTO_RsaSignature); + if (msg_size >= GNUNET_SERVER_MAX_MESSAGE_SIZE) { - rd_ser_len = GNUNET_NAMESTORE_records_get_size (rd_count, rd); - rd_ser = GNUNET_malloc (rd_ser_len); - GNUNET_NAMESTORE_records_serialize(rd_count, rd, rd_ser_len, rd_ser); + GNUNET_break (0); + ztn_ctx->success = GNUNET_SYSERR; + return; } - else - rd_ser_len = 0; - - if (signature != NULL) - contains_sig = GNUNET_YES; - 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); - - name_tmp = (char *) &ztnr_msg[1]; - rd_tmp = &name_tmp[name_len]; - sig_tmp = &rd_tmp[rd_ser_len]; - - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message\n", "ZONE_TO_NAME_RESPONSE"); ztnr_msg->gns_header.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE); ztnr_msg->gns_header.header.size = htons (msg_size); ztnr_msg->gns_header.r_id = htonl (ztn_ctx->rid); @@ -1348,369 +1673,384 @@ handle_zone_to_name_it (void *cls, ztnr_msg->rd_len = htons (rd_ser_len); ztnr_msg->rd_count = htons (rd_count); ztnr_msg->name_len = htons (name_len); - ztnr_msg->expire = GNUNET_TIME_absolute_hton(expire); - if (zone_key != NULL) + ztnr_msg->expire = GNUNET_TIME_absolute_hton (expire); + if (NULL != zone_key) ztnr_msg->zone_key = *zone_key; - else - memset (&ztnr_msg->zone_key, '\0', sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)); - - if ((name_len > 0) && (name != NULL)) + name_tmp = (char *) &ztnr_msg[1]; + if (NULL != name) memcpy (name_tmp, name, name_len); - - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Name is `%s', has %u records, rd ser len %u msg_size %u\n", name, rd_count, rd_ser_len, msg_size); - if ((rd_ser_len > 0) && (rd_ser != NULL)) - memcpy (rd_tmp, rd_ser, rd_ser_len); - if ((GNUNET_YES == contains_sig) && (signature != NULL)) - memcpy (sig_tmp, signature, contains_sig * sizeof (struct GNUNET_CRYPTO_RsaSignature)); - - GNUNET_SERVER_notification_context_unicast (snc, ztn_ctx->nc->client, (const struct GNUNET_MessageHeader *) ztnr_msg, GNUNET_NO); + rd_tmp = &name_tmp[name_len]; + GNUNET_NAMESTORE_records_serialize (rd_count, rd, rd_ser_len, rd_tmp); + sig_tmp = &rd_tmp[rd_ser_len]; + if (NULL != signature) + memcpy (sig_tmp, signature, sizeof (struct GNUNET_CRYPTO_RsaSignature)); + ztn_ctx->success = GNUNET_OK; + GNUNET_SERVER_notification_context_unicast (snc, ztn_ctx->nc->client, + &ztnr_msg->gns_header.header, + GNUNET_NO); GNUNET_free (ztnr_msg); - GNUNET_free_non_null (rd_ser); } -static void handle_zone_to_name (void *cls, - struct GNUNET_SERVER_Client * client, - const struct GNUNET_MessageHeader * message) +/** + * Handles a 'GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME' message + * + * @param cls unused + * @param client GNUNET_SERVER_Client sending the message + * @param message message of type 'struct ZoneToNameMessage' + */ +static void +handle_zone_to_name (void *cls, + struct GNUNET_SERVER_Client *client, + const struct GNUNET_MessageHeader *message) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message\n", "ZONE_TO_NAME"); struct GNUNET_NAMESTORE_Client *nc; + const struct ZoneToNameMessage *ztn_msg; struct ZoneToNameCtx ztn_ctx; - size_t msg_size = 0; - uint32_t rid = 0; - - if (ntohs (message->size) != sizeof (struct ZoneToNameMessage)) - { - GNUNET_break_op (0); - GNUNET_SERVER_receive_done (client, GNUNET_OK); - return; - } - nc = client_lookup(client); - if (nc == NULL) + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received `%s' message\n", + "ZONE_TO_NAME"); + ztn_msg = (const struct ZoneToNameMessage *) message; + if (NULL == (nc = client_lookup(client))) { - GNUNET_break_op (0); - GNUNET_SERVER_receive_done (client, GNUNET_OK); - return; - } - - struct ZoneToNameMessage *ztn_msg = (struct ZoneToNameMessage *) message; - - if (msg_size > GNUNET_SERVER_MAX_MESSAGE_SIZE) - { - GNUNET_break_op (0); - GNUNET_SERVER_receive_done (client, GNUNET_OK); + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } - - rid = ntohl (ztn_msg->gns_header.r_id); - - ztn_ctx.rid = rid; + ztn_ctx.rid = ntohl (ztn_msg->gns_header.r_id); ztn_ctx.nc = nc; - - struct GNUNET_CRYPTO_ShortHashAsciiEncoded z_tmp; - GNUNET_CRYPTO_short_hash_to_enc(&ztn_msg->zone, &z_tmp); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Looking up name for zone `%s' in zone `%s'\n", - (char *) &z_tmp, - GNUNET_short_h2s (&ztn_msg->value_zone)); - - GSN_database->zone_to_name (GSN_database->cls, &ztn_msg->zone, &ztn_msg->value_zone, &handle_zone_to_name_it, &ztn_ctx); - - GNUNET_SERVER_receive_done (client, GNUNET_OK); + ztn_ctx.success = GNUNET_SYSERR; + if (GNUNET_SYSERR == + GSN_database->zone_to_name (GSN_database->cls, + &ztn_msg->zone, + &ztn_msg->value_zone, + &handle_zone_to_name_it, &ztn_ctx)) + { + /* internal error, hang up instead of signalling something + that might be wrong */ + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); + return; + } + GNUNET_SERVER_receive_done (client, ztn_ctx.success); } /** - * Copy record, data has to be free separetely + * Zone iteration processor result */ -void -copy_record (const struct GNUNET_NAMESTORE_RecordData *src, struct GNUNET_NAMESTORE_RecordData *dest) +enum ZoneIterationResult { + /** + * Found records, but all records were filtered + * Continue to iterate + */ + IT_ALL_RECORDS_FILTERED = -1, + + /** + * Found records, + * Continue to iterate with next iteration_next call + */ + IT_SUCCESS_MORE_AVAILABLE = 0, + + /** + * Iteration complete + */ + IT_SUCCESS_NOT_MORE_RESULTS_AVAILABLE = 1 +}; - memcpy (dest, src, sizeof (struct GNUNET_NAMESTORE_RecordData)); - dest->data = GNUNET_malloc (src->data_size); - memcpy ((void *) dest->data, src->data, src->data_size); -} +/** + * Context for record remove operations passed from + * 'run_zone_iteration_round' to 'zone_iteraterate_proc' as closure + */ struct ZoneIterationProcResult { + /** + * The zone iteration handle + */ struct GNUNET_NAMESTORE_ZoneIteration *zi; + /** + * Iteration result: iteration done? + * IT_SUCCESS_MORE_AVAILABLE: if there may be more results overall but + * we got one for now and have sent it to the client + * IT_SUCCESS_NOT_MORE_RESULTS_AVAILABLE: if there are no further results, + * IT_ALL_RECORDS_FILTERED: if all results were filtered so far. + */ int res_iteration_finished; - int records_included; - int has_signature; - char *name; - struct GNUNET_CRYPTO_ShortHashCode zone_hash; - struct GNUNET_NAMESTORE_RecordData *rd; - struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded zone_key; - struct GNUNET_CRYPTO_RsaSignature signature; - struct GNUNET_TIME_Absolute expire; }; -void zone_iteraterate_proc (void *cls, - const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key, - struct GNUNET_TIME_Absolute expire, - const char *name, - unsigned int rd_count, - const struct GNUNET_NAMESTORE_RecordData *rd, - const struct GNUNET_CRYPTO_RsaSignature *signature) +/** + * 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, + struct GNUNET_TIME_Absolute expire, + const char *name, + unsigned int rd_count, + const struct GNUNET_NAMESTORE_RecordData *rd, + const struct GNUNET_CRYPTO_RsaSignature *signature) { struct ZoneIterationProcResult *proc = cls; - struct GNUNET_NAMESTORE_RecordData *rd_filtered; - struct GNUNET_CRYPTO_RsaSignature * new_signature; + struct GNUNET_NAMESTORE_RecordData rd_filtered[rd_count]; + struct GNUNET_CRYPTO_RsaSignature *new_signature = NULL; struct GNUNET_NAMESTORE_CryptoContainer *cc; - struct GNUNET_CRYPTO_ShortHashCode hash; - GNUNET_HashCode long_hash; - struct GNUNET_TIME_Absolute e; - unsigned int rd_count_filtered = 0; - int include; - int c; - - proc->res_iteration_finished = GNUNET_NO; - proc->records_included = 0; + struct GNUNET_HashCode long_hash; + struct GNUNET_CRYPTO_ShortHashCode zone_hash; + struct ZoneIterationResponseMessage *zir_msg; + struct GNUNET_TIME_Relative rt; + unsigned int rd_count_filtered; + unsigned int c; + size_t name_len; + size_t rd_ser_len; + size_t msg_size; + char *name_tmp; + char *rd_ser; - if ((zone_key == NULL) && (name == NULL)) + proc->res_iteration_finished = IT_SUCCESS_MORE_AVAILABLE; + if ((NULL == zone_key) && (NULL == name)) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Iteration done\n"); - proc->res_iteration_finished = GNUNET_YES; - proc->rd = NULL; - proc->name = NULL; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Iteration done\n"); + proc->res_iteration_finished = IT_SUCCESS_NOT_MORE_RESULTS_AVAILABLE; + return; } - else if ((zone_key != NULL) && (name != NULL)) /* just a safety check */ + if ((NULL == zone_key) || (NULL == name)) { - rd_filtered = GNUNET_malloc (rd_count * sizeof (struct GNUNET_NAMESTORE_RecordData)); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received result for zone iteration: `%s'\n", name); - for (c = 0; c < rd_count; c++) + /* what is this!? should never happen */ + GNUNET_break (0); + return; + } + rd_count_filtered = 0; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received result for zone iteration: `%s'\n", + name); + for (c = 0; c < rd_count; c++) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Record %u has flags: %x must have flags are %x, must not have flags are %x\n", + c, rd[c].flags, + proc->zi->must_have_flags, + proc->zi->must_not_have_flags); + /* Checking must have flags, except 'relative-expiration' which is a special flag */ + if ((rd[c].flags & proc->zi->must_have_flags & (~GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION)) + != (proc->zi->must_have_flags & (~ GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION))) { - include = GNUNET_YES; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Record %i has flags: 0x%x must have 0x%x \n", - c, rd[c].flags, proc->zi->must_have_flags); - /* Checking must have flags */ - if ((rd[c].flags & proc->zi->must_have_flags) == proc->zi->must_have_flags) - { - /* Include */ - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Record %i has flags: Include \n", c); - } - else - { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Record %i has flags: Not include \n", c); - include = GNUNET_NO; - } - - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Record %i has flags: 0x%x must not have 0x%x\n", - c, rd[c].flags, proc->zi->must_not_have_flags); - if ((rd[c].flags & proc->zi->must_not_have_flags) != 0) - { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Record %i has flags: Not include \n", c); - include = GNUNET_NO; - } - else - { - /* Include */ - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Record %i has flags: Include \n", c); - } - if (GNUNET_YES == include) - { - copy_record (&rd[c], &rd_filtered[rd_count_filtered]); - rd_count_filtered++; - } - + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Record %u lacks 'must-have' flags: Not included\n", c); + continue; } - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Included %i of %i records \n", rd_count_filtered, rd_count); - - proc->records_included = rd_count_filtered; - if (0 == rd_count_filtered) + /* Checking must-not-have flags */ + if (0 != (rd[c].flags & proc->zi->must_not_have_flags)) { - GNUNET_free (rd_filtered); - rd_filtered = NULL; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Record %u has 'must-not-have' flags: Not included\n", c); + continue; } - proc->rd = rd_filtered; - proc->name = GNUNET_strdup(name); - memcpy (&proc->zone_key, zone_key, sizeof (proc->zone_key)); - - /* Signature */ - proc->has_signature = GNUNET_NO; - GNUNET_CRYPTO_short_hash (zone_key, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), &hash); - GNUNET_CRYPTO_short_hash_double(&hash, &long_hash); - proc->zone_hash = hash; - - if (GNUNET_CONTAINER_multihashmap_contains(zonekeys, &long_hash)) + rd_filtered[rd_count_filtered] = rd[c]; + /* convert relative to absolute expiration time unless explicitly requested otherwise */ + if ( (0 == (proc->zi->must_have_flags & GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION)) && + (0 != (rd[c].flags & GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION)) ) + { + /* should convert relative-to-absolute expiration time */ + rt.rel_value = rd[c].expiration_time; + rd_filtered[c].expiration_time = GNUNET_TIME_relative_to_absolute (rt).abs_value; + rd_filtered[c].flags &= ~ GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION; + } + /* we NEVER keep the 'authority' flag */ + rd_filtered[c].flags &= ~ GNUNET_NAMESTORE_RF_AUTHORITY; + rd_count_filtered++; + } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Included %u of %u records\n", + rd_count_filtered, rd_count); + + signature = NULL; + if ( (rd_count_filtered > 0) && + (0 == (proc->zi->must_have_flags & GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION)) ) + { + /* compute / obtain signature, but only if we (a) have records and (b) expiration times were + converted to absolute expiration times */ + GNUNET_CRYPTO_short_hash (zone_key, + sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), + &zone_hash); + GNUNET_CRYPTO_short_hash_double (&zone_hash, &long_hash); + if (NULL != (cc = GNUNET_CONTAINER_multihashmap_get(zonekeys, &long_hash))) { - cc = GNUNET_CONTAINER_multihashmap_get(zonekeys, &long_hash); - e = get_block_expiration_time(rd_count_filtered, rd_filtered); - proc->expire = e; - new_signature = GNUNET_NAMESTORE_create_signature(cc->privkey, e, name, rd_filtered, rd_count_filtered); - GNUNET_assert (signature != NULL); - proc->signature = (*new_signature); - GNUNET_free (new_signature); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Creating signature for `%s' in zone `%s' with %u records and expiration %llu\n", - name, GNUNET_short_h2s(&hash), rd_count_filtered, e.abs_value); - proc->has_signature = GNUNET_YES; + expire = get_block_expiration_time (rd_count_filtered, rd_filtered); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Creating signature for `%s' in zone `%s' with %u records and expiration %llu\n", + name, GNUNET_short_h2s(&zone_hash), + rd_count_filtered, + (unsigned long long) expire.abs_value); + new_signature = GNUNET_NAMESTORE_create_signature (cc->privkey, expire, name, + rd_filtered, rd_count_filtered); + GNUNET_assert (NULL != new_signature); + signature = new_signature; } else if (rd_count_filtered == rd_count) { - proc->expire = expire; if (NULL != signature) - { - proc->signature = (*signature); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Using provided signature for `%s' in zone `%s' with %u records and expiration %llu\n", - name, GNUNET_short_h2s(&hash), rd_count_filtered, expire.abs_value); - proc->has_signature = GNUNET_YES; - } - else - { - memset (&proc->signature, '\0', sizeof (proc->signature)); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "No signature provided for `%s'\n", name); - } + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Using provided signature for `%s' in zone `%s' with %u records and expiration %llu\n", + name, GNUNET_short_h2s (&zone_hash), rd_count_filtered, + (unsigned long long) expire.abs_value); + return; + } } } - else + if (rd_count_filtered == 0) { - GNUNET_break (0); + /* After filtering records there are no records left to return */ + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "No records to transmit\n"); + proc->res_iteration_finished = IT_ALL_RECORDS_FILTERED; return; } + if (GNUNET_YES == proc->zi->has_zone) + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Sending name `%s' for iteration over zone `%s'\n", + name, GNUNET_short_h2s(&proc->zi->zone)); + else + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Sending name `%s' for iteration over all zones\n", + name); + name_len = strlen (name) + 1; + rd_ser_len = GNUNET_NAMESTORE_records_get_size (rd_count_filtered, rd_filtered); + msg_size = sizeof (struct ZoneIterationResponseMessage) + name_len + rd_ser_len; + + zir_msg = GNUNET_malloc (msg_size); + 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 (proc->zi->request_id); + zir_msg->expire = GNUNET_TIME_absolute_hton (expire); + zir_msg->reserved = htons (0); + zir_msg->name_len = htons (name_len); + zir_msg->rd_count = htons (rd_count_filtered); + zir_msg->rd_len = htons (rd_ser_len); + if (NULL != signature) + zir_msg->signature = *signature; + zir_msg->public_key = *zone_key; + name_tmp = (char *) &zir_msg[1]; + memcpy (name_tmp, name, name_len); + rd_ser = &name_tmp[name_len]; + GNUNET_NAMESTORE_records_serialize (rd_count_filtered, rd_filtered, rd_ser_len, rd_ser); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Sending `%s' message with size %u\n", + "ZONE_ITERATION_RESPONSE", + msg_size); + GNUNET_SERVER_notification_context_unicast (snc, proc->zi->client->client, + (const struct GNUNET_MessageHeader *) zir_msg, + GNUNET_NO); + proc->res_iteration_finished = IT_SUCCESS_MORE_AVAILABLE; + GNUNET_free (zir_msg); + GNUNET_free_non_null (new_signature); } -void find_next_zone_iteration_result (struct ZoneIterationProcResult *proc) -{ +/** + * 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; + struct ZoneIterationResponseMessage zir_end; struct GNUNET_CRYPTO_ShortHashCode *zone; - if (GNUNET_YES == proc->zi->has_zone) - zone = &proc->zi->zone; + memset (&proc, 0, sizeof (proc)); + proc.zi = zi; + if (GNUNET_YES == zi->has_zone) + zone = &zi->zone; else zone = NULL; - - do + proc.res_iteration_finished = IT_ALL_RECORDS_FILTERED; + while (IT_ALL_RECORDS_FILTERED == proc.res_iteration_finished) { - GSN_database->iterate_records (GSN_database->cls, zone , NULL, proc->zi->offset, &zone_iteraterate_proc, proc); - proc->zi->offset++; + if (GNUNET_SYSERR == + GSN_database->iterate_records (GSN_database->cls, zone, NULL, + zi->offset, + &zone_iteraterate_proc, &proc)) + { + GNUNET_break (0); + break; + } + zi->offset++; } - while ((proc->records_included == 0) && (GNUNET_NO == proc->res_iteration_finished)); -} - - -void send_zone_iteration_result (struct ZoneIterationProcResult *proc) -{ - struct GNUNET_NAMESTORE_ZoneIteration *zi = proc->zi; - - if (GNUNET_YES == proc->res_iteration_finished) + if (IT_SUCCESS_MORE_AVAILABLE == proc.res_iteration_finished) { - struct ZoneIterationResponseMessage zir_msg; - if (zi->has_zone == GNUNET_YES) - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "No more results for zone `%s'\n", GNUNET_short_h2s(&zi->zone)); - else - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "No more results for all zones\n"); - - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending empty `%s' message\n", "ZONE_ITERATION_RESPONSE"); - zir_msg.gns_header.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_RESPONSE); - zir_msg.gns_header.header.size = htons (sizeof (struct ZoneIterationResponseMessage)); - zir_msg.gns_header.r_id = htonl(zi->request_id); - zir_msg.expire = GNUNET_TIME_absolute_hton(GNUNET_TIME_UNIT_ZERO_ABS); - zir_msg.name_len = htons (0); - zir_msg.reserved = htons (0); - zir_msg.rd_count = htons (0); - zir_msg.rd_len = htons (0); - memset (&zir_msg.public_key, '\0', sizeof (zir_msg.public_key)); - memset (&zir_msg.signature, '\0', sizeof (zir_msg.signature)); - GNUNET_SERVER_notification_context_unicast (snc, zi->client->client, (const struct GNUNET_MessageHeader *) &zir_msg, GNUNET_NO); - - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Removing zone iterator\n"); - GNUNET_CONTAINER_DLL_remove (zi->client->op_head, zi->client->op_tail, zi); - GNUNET_free (zi); - return; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "More results available\n"); + return; /* more results later */ } + if (GNUNET_YES == zi->has_zone) + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "No more results for zone `%s'\n", + GNUNET_short_h2s(&zi->zone)); 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_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); - } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "No more results for all zones\n"); + memset (&zir_end, 0, sizeof (zir_end)); + zir_end.gns_header.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_RESPONSE); + zir_end.gns_header.header.size = htons (sizeof (struct ZoneIterationResponseMessage)); + zir_end.gns_header.r_id = htonl(zi->request_id); + GNUNET_SERVER_notification_context_unicast (snc, + zi->client->client, + &zir_end.gns_header.header, GNUNET_NO); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Removing zone iterator\n"); + GNUNET_CONTAINER_DLL_remove (zi->client->op_head, zi->client->op_tail, zi); + GNUNET_free (zi); } -void clean_up_zone_iteration_result (struct ZoneIterationProcResult *proc) -{ - int c; - GNUNET_free_non_null (proc->name); - for (c = 0; c < proc->records_included; c++) - { - GNUNET_free ((void *) proc->rd[c].data); - } - GNUNET_free_non_null (proc->rd); - proc->name = NULL; - proc->rd = NULL; -} -static void handle_iteration_start (void *cls, - struct GNUNET_SERVER_Client * client, - const struct GNUNET_MessageHeader * message) +/** + * Handles a 'GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START' message + * + * @param cls unused + * @param client GNUNET_SERVER_Client sending the message + * @param message message of type 'struct ZoneIterationStartMessage' + */ +static void +handle_iteration_start (void *cls, + 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; - nc = client_lookup(client); - if (nc == NULL) + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message\n", "ZONE_ITERATION_START"); + if (NULL == (nc = client_lookup (client))) { - GNUNET_break_op (0); - GNUNET_SERVER_receive_done (client, GNUNET_OK); + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); 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); - - struct GNUNET_CRYPTO_ShortHashCode dummy; - 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; @@ -1718,152 +2058,164 @@ static void handle_iteration_start (void *cls, } 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); - - 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); } -static void handle_iteration_stop (void *cls, - struct GNUNET_SERVER_Client * client, - const struct GNUNET_MessageHeader * message) -{ - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message\n", "ZONE_ITERATION_STOP"); +/** + * Handles a 'GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP' message + * + * @param cls unused + * @param client GNUNET_SERVER_Client sending the message + * @param message message of type 'struct ZoneIterationStopMessage' + */ +static void +handle_iteration_stop (void *cls, + struct GNUNET_SERVER_Client *client, + const struct GNUNET_MessageHeader *message) +{ struct GNUNET_NAMESTORE_Client *nc; struct GNUNET_NAMESTORE_ZoneIteration *zi; - struct ZoneIterationStopMessage * zis_msg = (struct ZoneIterationStopMessage *) message; + const struct ZoneIterationStopMessage *zis_msg; uint32_t rid; - nc = client_lookup(client); - if (nc == NULL) + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received `%s' message\n", + "ZONE_ITERATION_STOP"); + if (NULL == (nc = client_lookup(client))) { - GNUNET_break_op (0); - GNUNET_SERVER_receive_done (client, GNUNET_OK); + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } - + zis_msg = (const 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_SERVER_receive_done (client, GNUNET_OK); + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); 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); } -static void handle_iteration_next (void *cls, - struct GNUNET_SERVER_Client * client, - const struct GNUNET_MessageHeader * message) -{ - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message\n", "ZONE_ITERATION_NEXT"); +/** + * Handles a 'GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT' message + * + * @param cls unused + * @param client GNUNET_SERVER_Client sending the message + * @param message message of type 'struct ZoneIterationNextMessage' + */ +static void +handle_iteration_next (void *cls, + struct GNUNET_SERVER_Client *client, + const struct GNUNET_MessageHeader *message) +{ struct GNUNET_NAMESTORE_Client *nc; struct GNUNET_NAMESTORE_ZoneIteration *zi; - struct ZoneIterationStopMessage * zis_msg = (struct ZoneIterationStopMessage *) message; + const struct ZoneIterationNextMessage *zis_msg; uint32_t rid; - nc = client_lookup(client); - if (nc == NULL) + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message\n", "ZONE_ITERATION_NEXT"); + if (NULL == (nc = client_lookup(client))) { - GNUNET_break_op (0); - GNUNET_SERVER_receive_done (client, GNUNET_OK); + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } - + 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_SERVER_receive_done (client, GNUNET_OK); + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } + run_zone_iteration_round (zi); + GNUNET_SERVER_receive_done (client, GNUNET_OK); +} - struct ZoneIterationProcResult proc; - proc.zi = zi; +static void +zonekey_it_key_cb (void *cls, + struct GNUNET_CRYPTO_RsaPrivateKey *pk, + const char *emsg) +{ + struct KeyLoadContext *kl = cls; - 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) + kl->keygen = NULL; + if (NULL == pk) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Zone iteration return %u records\n", proc.records_included); + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + _("Could not parse zone key file `%s'\n"), + kl->filename); + return; } - send_zone_iteration_result (&proc); - clean_up_zone_iteration_result (&proc); + learn_private_key (pk); + (*kl->counter) ++; - GNUNET_SERVER_receive_done (client, GNUNET_OK); + GNUNET_CONTAINER_DLL_remove (kl_head, kl_tail, kl); + GNUNET_free (kl->filename); + GNUNET_free (kl); } -int zonekey_file_it (void *cls, const char *filename) + +/** + * 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) { - 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 KeyLoadContext *kl; + + if ((NULL == filename) || + (NULL == strstr(filename, ".zkey"))) + return GNUNET_OK; + + kl = GNUNET_malloc (sizeof (struct KeyLoadContext)); + kl->filename = strdup (filename); + kl->counter = cls; + kl->keygen = GNUNET_CRYPTO_rsa_key_create_start (filename, zonekey_it_key_cb, kl); + if (NULL == kl->keygen) + { + GNUNET_free (kl->filename); + GNUNET_free (kl); + return GNUNET_OK; + } + + GNUNET_CONTAINER_DLL_insert (kl_head, kl_tail, kl); + return GNUNET_OK; } /** - * Process template requests. + * Process namestore requests. * * @param cls closure * @param server the initialized server @@ -1873,10 +2225,6 @@ static void 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)}, @@ -1889,24 +2237,29 @@ run (void *cls, struct GNUNET_SERVER_Handle *server, {&handle_record_remove, NULL, GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_REMOVE, 0}, {&handle_zone_to_name, NULL, - GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME, 0}, + GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME, sizeof (struct ZoneToNameMessage) }, {&handle_iteration_start, NULL, - GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START, sizeof (struct ZoneIterationStartMessage)}, + GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START, sizeof (struct ZoneIterationStartMessage) }, {&handle_iteration_next, NULL, - GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT, 0}, + GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT, sizeof (struct ZoneIterationNextMessage) }, {&handle_iteration_stop, NULL, - GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP, 0}, + GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP, sizeof (struct ZoneIterationStopMessage) }, {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; } @@ -1915,17 +2268,25 @@ run (void *cls, struct GNUNET_SERVER_Handle *server, { 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, GNUNET_NO); + 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 != @@ -1936,10 +2297,11 @@ run (void *cls, struct GNUNET_SERVER_Handle *server, 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; } @@ -1950,10 +2312,8 @@ run (void *cls, struct GNUNET_SERVER_Handle *server, GNUNET_SERVER_disconnect_notify (server, &client_disconnect_notification, NULL); - GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &cleanup_task, NULL); - } |