diff options
Diffstat (limited to 'src/namestore/gnunet-service-namestore.c')
| -rw-r--r-- | src/namestore/gnunet-service-namestore.c | 1501 |
1 files changed, 1316 insertions, 185 deletions
diff --git a/src/namestore/gnunet-service-namestore.c b/src/namestore/gnunet-service-namestore.c index 92eb218..d6c2998 100644 --- a/src/namestore/gnunet-service-namestore.c +++ b/src/namestore/gnunet-service-namestore.c @@ -28,9 +28,10 @@ #include "gnunet_service_lib.h" #include "gnunet_namestore_service.h" #include "gnunet_namestore_plugin.h" +#include "gnunet_signatures.h" #include "namestore.h" - +#define LOG_STRERROR_FILE(kind,syscall,filename) GNUNET_log_from_strerror_file (kind, "util", syscall, filename) /** * A namestore operation. @@ -42,11 +43,22 @@ struct GNUNET_NAMESTORE_ZoneIteration struct GNUNET_NAMESTORE_Client * client; - GNUNET_HashCode zone; + int has_zone; + + struct GNUNET_CRYPTO_ShortHashCode zone; - uint64_t op_id; + uint64_t request_id; uint32_t offset; + /** + * Which flags must be included + */ + uint16_t must_have_flags; + + /** + * Which flags must not be included + */ + uint16_t must_not_have_flags; }; @@ -64,25 +76,165 @@ struct GNUNET_NAMESTORE_Client struct GNUNET_NAMESTORE_ZoneIteration *op_tail; }; +struct GNUNET_NAMESTORE_CryptoContainer +{ + char * filename; + + struct GNUNET_CRYPTO_ShortHashCode zone; + struct GNUNET_CRYPTO_RsaPrivateKey *privkey; + struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *pubkey; +}; /** - * Configuration handle. - */ +* Configuration handle. +*/ const struct GNUNET_CONFIGURATION_Handle *GSN_cfg; -static struct GNUNET_NAMESTORE_PluginFunctions *GSN_database; +/** +* Database handle +*/ +struct GNUNET_NAMESTORE_PluginFunctions *GSN_database; + +/** +* Zonefile directory +*/ +static char *zonefile_directory; + +static char *db_lib_name; + /** * Our notification context. */ static struct GNUNET_SERVER_NotificationContext *snc; -static char *db_lib_name; - static struct GNUNET_NAMESTORE_Client *client_head; static struct GNUNET_NAMESTORE_Client *client_tail; +struct GNUNET_CONTAINER_MultiHashMap *zonekeys; + + +/** + * Write zonefile to disk + * @param filename where to write + * @param c the crypto container + * + * @return GNUNET_OK on success, GNUNET_SYSERR on fail + */ + +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; + + if (GNUNET_YES == GNUNET_DISK_file_test (filename)) + { + 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) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + _("File zone `%s' but corrupt content already exists, failed to write! \n"), GNUNET_short_h2s (&zone)); + 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)); + 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)); + return GNUNET_SYSERR; + } + enc = GNUNET_CRYPTO_rsa_encode_key (ret); + GNUNET_assert (enc != NULL); + 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); + 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); + } + + + 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 +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; + + if (NULL == rd) + return GNUNET_TIME_UNIT_ZERO_ABS; + for (c = 0; c < rd_count; c++) + expire = GNUNET_TIME_absolute_min (rd[c].expiration, expire); + return expire; +} /** * Task run during shutdown. @@ -94,12 +246,16 @@ static void cleanup_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { 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; + GNUNET_SERVER_notification_context_destroy (snc); + snc = NULL; + GNUNET_CONTAINER_multihashmap_iterate(zonekeys, &zone_to_disk_it, NULL); + GNUNET_CONTAINER_multihashmap_destroy(zonekeys); + for (nc = client_head; nc != NULL; nc = next) { next = nc->next; @@ -109,17 +265,14 @@ cleanup_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 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_SERVER_notification_context_destroy (snc); - snc = NULL; - GNUNET_break (NULL == GNUNET_PLUGIN_unload (db_lib_name, GSN_database)); GNUNET_free (db_lib_name); + GNUNET_free_non_null(zonefile_directory); } static struct GNUNET_NAMESTORE_Client * @@ -137,7 +290,6 @@ client_lookup (struct GNUNET_SERVER_Client *client) return nc; } - /** * Called whenever a client is disconnected. Frees our * resources associated with that client. @@ -160,16 +312,22 @@ client_disconnect_notification (void *cls, struct GNUNET_SERVER_Client *client) if ((NULL == client) || (NULL == nc)) return; - for (no = nc->op_head; no != NULL; no = no->next) + no = nc->op_head; + while (NULL != no) { 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_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) @@ -180,18 +338,40 @@ static void handle_start (void *cls, nc->client = client; GNUNET_SERVER_notification_context_add (snc, client); GNUNET_CONTAINER_DLL_insert(client_head, client_tail, nc); - + GNUNET_SERVER_client_keep (client); GNUNET_SERVER_receive_done (client, GNUNET_OK); } struct LookupNameContext { struct GNUNET_NAMESTORE_Client *nc; - uint32_t id; + uint32_t request_id; 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; + } +} static void @@ -206,24 +386,26 @@ handle_lookup_name_it (void *cls, /* send response */ struct LookupNameContext *lnc = cls; struct LookupNameResponseMessage *lnr_msg; - - struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key_tmp; - struct GNUNET_NAMESTORE_RecordData * rd_tmp; + struct GNUNET_NAMESTORE_RecordData *rd_selected = NULL; + struct GNUNET_NAMESTORE_CryptoContainer *cc; + struct GNUNET_CRYPTO_RsaSignature *signature_new = NULL; + struct GNUNET_TIME_Absolute e; + struct GNUNET_CRYPTO_ShortHashCode zone_key_hash; + GNUNET_HashCode long_hash; + char *rd_tmp; char *name_tmp; - struct GNUNET_CRYPTO_RsaSignature *signature_tmp; - - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message\n", "NAMESTORE_LOOKUP_NAME_RESPONSE"); - + size_t rd_ser_len; size_t r_size = 0; - size_t name_len = 0; - if (NULL != name) - name_len = strlen(name) + 1; int copied_elements = 0; - int contains_signature = 0; + int contains_signature = GNUNET_NO; + int authoritative = GNUNET_NO; int c; + if (NULL != name) + name_len = strlen(name) + 1; + /* count records to copy */ if (rd_count != 0) { @@ -233,68 +415,114 @@ handle_lookup_name_it (void *cls, 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++; + } + } } else + { copied_elements = rd_count; + rd_selected = (struct GNUNET_NAMESTORE_RecordData *) rd; + } + } + else + { + /* No results */ + copied_elements = 0; + rd_selected = NULL; + expire = GNUNET_TIME_UNIT_ZERO_ABS; } - if ((copied_elements == rd_count) && (signature != NULL)) - contains_signature = 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 */ + + + if ((NULL != zone_key) && (copied_elements == rd_count)) + { + 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)) + { + 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; + } + 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)); + } r_size = sizeof (struct LookupNameResponseMessage) + sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) + name_len + - copied_elements * sizeof (struct GNUNET_NAMESTORE_RecordData) + - contains_signature * sizeof (struct GNUNET_CRYPTO_RsaSignature); + rd_ser_len; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message\n", "NAMESTORE_LOOKUP_NAME_RESPONSE"); lnr_msg = GNUNET_malloc (r_size); - - lnr_msg->header.type = ntohs (GNUNET_MESSAGE_TYPE_NAMESTORE_LOOKUP_NAME_RESPONSE); - lnr_msg->header.size = ntohs (r_size); - lnr_msg->op_id = htonl (lnc->id); - lnr_msg->rc_count = htonl (copied_elements); + lnr_msg->gns_header.header.type = ntohs (GNUNET_MESSAGE_TYPE_NAMESTORE_LOOKUP_NAME_RESPONSE); + lnr_msg->gns_header.header.size = ntohs (r_size); + lnr_msg->gns_header.r_id = htonl (lnc->request_id); + 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(expire); - lnr_msg->contains_sig = htons (contains_signature); + lnr_msg->expire = GNUNET_TIME_absolute_hton(get_block_expiration_time(copied_elements, rd_selected)); - - zone_key_tmp = (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *) &lnr_msg[1]; - name_tmp = (char *) &zone_key_tmp[1]; - rd_tmp = (struct GNUNET_NAMESTORE_RecordData *) &name_tmp[name_len]; - signature_tmp = (struct GNUNET_CRYPTO_RsaSignature *) &rd_tmp[copied_elements]; + if (rd_selected != rd) + GNUNET_free (rd_selected); if (zone_key != NULL) - memcpy (zone_key_tmp, zone_key, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)); + 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 */ + lnr_msg->contains_sig = htons (GNUNET_YES); + GNUNET_assert (signature_new != NULL); + lnr_msg->signature = *signature_new; + GNUNET_free (signature_new); + } + else if (GNUNET_YES == contains_signature) { - struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded dummy; - memset (&dummy, '0', sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)); - memcpy (zone_key_tmp, &dummy, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)); + /* use existing signature */ + lnr_msg->contains_sig = htons (GNUNET_YES); + GNUNET_assert (signature != NULL); + lnr_msg->signature = *signature; } - memcpy (name_tmp, name, name_len); - /* copy records */ - copied_elements = 0; - if (rd_count != 0) + else { - if (lnc->record_type != 0) - { - /* special record type needed */ - for (c = 0; c < rd_count; c ++) - if (rd[c].record_type == lnc->record_type) - { - /* found matching record */ - memcpy (&rd_tmp[copied_elements], &rd[c], rd_count * sizeof (struct GNUNET_NAMESTORE_RecordData)); - copied_elements++; - } - } - else - memcpy (rd_tmp, rd, rd_count * sizeof (struct GNUNET_NAMESTORE_RecordData)); + /* use no signature */ + memset (&lnr_msg->signature, '\0', sizeof (lnr_msg->signature)); } - if (GNUNET_YES == contains_signature) - memcpy (signature_tmp, signature, sizeof (struct GNUNET_CRYPTO_RsaSignature)); - GNUNET_SERVER_notification_context_unicast (snc, lnc->nc->client, (const struct GNUNET_MessageHeader *) lnr_msg, GNUNET_NO); + 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_free (lnr_msg); } @@ -305,13 +533,11 @@ static void handle_lookup_name (void *cls, GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message\n", "NAMESTORE_LOOKUP_NAME"); struct LookupNameContext lnc; struct GNUNET_NAMESTORE_Client *nc; - GNUNET_HashCode name_hash; size_t name_len; char * name; - uint32_t id = 0; + uint32_t rid = 0; uint32_t type = 0; - if (ntohs (message->size) < sizeof (struct LookupNameMessage)) { GNUNET_break_op (0); @@ -328,7 +554,7 @@ static void handle_lookup_name (void *cls, } struct LookupNameMessage * ln_msg = (struct LookupNameMessage *) message; - id = ntohl (ln_msg->op_id); + rid = ntohl (ln_msg->gns_header.r_id); name_len = ntohl (ln_msg->name_len); type = ntohl (ln_msg->record_type); @@ -339,17 +565,26 @@ static void handle_lookup_name (void *cls, return; } - name = GNUNET_malloc (name_len); - memcpy (name, &ln_msg[1], name_len); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Looking up record for name `%s'\n", name); - GNUNET_CRYPTO_hash(name, name_len-1, &name_hash); - GNUNET_free (name); + name = (char *) &ln_msg[1]; + if (name[name_len -1] != '\0') + { + GNUNET_break_op (0); + GNUNET_SERVER_receive_done (client, GNUNET_OK); + 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)); + 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)); /* do the actual lookup */ - lnc.id = id; + lnc.request_id = rid; lnc.nc = nc; lnc.record_type = type; - GSN_database->iterate_records(GSN_database->cls, &ln_msg->zone, &ln_msg->zone, 0, &handle_lookup_name_it, &lnc); + lnc.name = name; + lnc.zone = &ln_msg->zone; + GSN_database->iterate_records(GSN_database->cls, &ln_msg->zone, name, 0, &handle_lookup_name_it, &lnc); GNUNET_SERVER_receive_done (client, GNUNET_OK); } @@ -361,8 +596,6 @@ static void handle_record_put (void *cls, GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message\n", "NAMESTORE_RECORD_PUT"); struct GNUNET_NAMESTORE_Client *nc; struct GNUNET_TIME_Absolute expire; - struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key; - struct GNUNET_NAMESTORE_RecordData *rd; struct GNUNET_CRYPTO_RsaSignature *signature; struct RecordPutResponseMessage rpr_msg; size_t name_len; @@ -370,7 +603,7 @@ static void handle_record_put (void *cls, size_t msg_size_exp; char * name; char * rd_ser; - uint32_t id = 0; + uint32_t rid = 0; uint32_t rd_ser_len; uint32_t rd_count; int res = GNUNET_SYSERR; @@ -391,12 +624,28 @@ static void handle_record_put (void *cls, } struct RecordPutMessage * rp_msg = (struct RecordPutMessage *) message; - id = ntohl (rp_msg->op_id); + + 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); - msg_size = ntohs (message->size); - msg_size_exp = sizeof (struct RecordPutMessage) + sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) + name_len + rd_ser_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)) + { + GNUNET_break_op (0); + GNUNET_SERVER_receive_done (client, GNUNET_OK); + return; + } + + 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); @@ -404,25 +653,42 @@ static void handle_record_put (void *cls, GNUNET_SERVER_receive_done (client, GNUNET_OK); return; } + if ((name_len == 0) || (name_len > 256)) + { + GNUNET_break_op (0); + GNUNET_SERVER_receive_done (client, GNUNET_OK); + return; + } + name = (char *) &rp_msg[1]; - if ((name_len == 0) || (name_len > 256)) + if (name[name_len -1] != '\0') { GNUNET_break_op (0); GNUNET_SERVER_receive_done (client, GNUNET_OK); return; } - zone_key = (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *) &rp_msg[1]; - name = (char *) &zone_key[1]; expire = GNUNET_TIME_absolute_ntoh(rp_msg->expire); signature = (struct GNUNET_CRYPTO_RsaSignature *) &rp_msg->signature; + rd_ser = &name[name_len]; - rd_count = GNUNET_NAMESTORE_records_deserialize(&rd, rd_ser, rd_ser_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) + { + GNUNET_break_op (0); + goto send; + } + + 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 */ res = GSN_database->put_records(GSN_database->cls, - zone_key, + &rp_msg->public_key, expire, name, rd_count, rd, @@ -432,20 +698,157 @@ static void handle_record_put (void *cls, name, (res == GNUNET_OK) ? "OK" : "FAIL"); /* Send response */ - +send: GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message\n", "RECORD_PUT_RESPONSE"); - rpr_msg.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_PUT_RESPONSE); - rpr_msg.op_id = rp_msg->op_id; - rpr_msg.header.size = htons (sizeof (struct RecordPutResponseMessage)); - if (GNUNET_OK == res) - rpr_msg.op_result = htons (GNUNET_OK); - else - rpr_msg.op_result = htons (GNUNET_NO); + 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_receive_done (client, GNUNET_OK); } +struct CreateRecordContext +{ + struct GNUNET_NAMESTORE_RecordData *rd; + struct GNUNET_CRYPTO_RsaPrivateKey *pkey; + struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *pubkey; + struct GNUNET_TIME_Absolute expire; + char *name; + int res; +}; + + +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) +{ + struct CreateRecordContext * crc = cls; + struct GNUNET_NAMESTORE_RecordData *rd_new = NULL; + struct GNUNET_CRYPTO_RsaSignature dummy_signature; + struct GNUNET_TIME_Absolute block_expiration; + int res; + int exist = GNUNET_SYSERR; + int update = GNUNET_NO; + int c; + int rd_count_new = 0; + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found %u existing records for `%s'\n", rd_count, crc->name); + 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)) + { + /* Update unique PSEU */ + exist = c; + 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))) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found existing records for `%s' to update expiration date!\n", crc->name); + exist = c; + if (crc->rd->expiration.abs_value != rd[c].expiration.abs_value) + update = GNUNET_YES; + 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) + { + /* 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; + } + else if (update == GNUNET_YES) + { + /* 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)); + memcpy (rd_new, rd, rd_count * sizeof (struct GNUNET_NAMESTORE_RecordData)); + 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[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); + 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); + +} static void handle_record_create (void *cls, struct GNUNET_SERVER_Client * client, @@ -453,13 +856,26 @@ static void handle_record_create (void *cls, { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message\n", "NAMESTORE_RECORD_CREATE"); struct GNUNET_NAMESTORE_Client *nc; + struct GNUNET_NAMESTORE_CryptoContainer *cc; + 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; - uint32_t id = 0; + 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; if (ntohs (message->size) < sizeof (struct RecordCreateMessage)) { @@ -477,10 +893,13 @@ static void handle_record_create (void *cls, } struct RecordCreateMessage * rp_msg = (struct RecordCreateMessage *) message; - id = ntohl (rp_msg->op_id); + rid = ntohl (rp_msg->gns_header.r_id); name_len = ntohs (rp_msg->name_len); msg_size = ntohs (message->size); - msg_size_exp = sizeof (struct RecordCreateMessage) + name_len + sizeof (struct GNUNET_NAMESTORE_RecordData); + rd_count = ntohs (rp_msg->rd_count); + 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) { @@ -490,7 +909,6 @@ static void handle_record_create (void *cls, return; } - if ((name_len == 0) || (name_len > 256)) { GNUNET_break_op (0); @@ -498,23 +916,195 @@ static void handle_record_create (void *cls, return; } - /* DO WORK HERE */ + pkey_tmp = (char *) &rp_msg[1]; + name_tmp = &pkey_tmp[key_len]; + rd_ser = &name_tmp[name_len]; - /* Send response */ + if (name_tmp[name_len -1] != '\0') + { + GNUNET_break_op (0); + GNUNET_SERVER_receive_done (client, GNUNET_OK); + 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)) + { + GNUNET_break_op (0); + goto send; + } + /* 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_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); + } + + 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)); + + /* Get existing records for name */ + res = GSN_database->iterate_records(GSN_database->cls, &pubkey_hash, name_tmp, 0, &handle_create_record_it, &crc); + 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"); - rcr_msg.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_CREATE_RESPONSE); - rcr_msg.op_id = rp_msg->op_id; - rcr_msg.header.size = htons (sizeof (struct RecordCreateResponseMessage)); - if (GNUNET_OK == res) - rcr_msg.op_result = htons (GNUNET_OK); + 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); + if ((GNUNET_OK == res) && (crc.res == GNUNET_YES)) + rcr_msg.op_result = htonl (GNUNET_YES); + else if ((GNUNET_OK == res) && (crc.res == GNUNET_NO)) + rcr_msg.op_result = htonl (GNUNET_NO); else - rcr_msg.op_result = htons (GNUNET_NO); + 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_receive_done (client, GNUNET_OK); } + +struct RemoveRecordContext +{ + struct GNUNET_NAMESTORE_RecordData *rd; + struct GNUNET_CRYPTO_RsaPrivateKey *pkey; + int remove_name; + uint16_t op_res; +}; + +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) +{ + 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); + + if (rd_count == 0) + { + /* Could not find record to remove */ + rrc->op_res = 1; + return; + } + + /* Find record to remove */ + found = GNUNET_SYSERR; + 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); */ + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found record to remove!\n", rd_count); + found = c; + break; + } + if (GNUNET_SYSERR == found) + { + /* Could not find record to remove */ + rrc->op_res = 2; + return; + } + + if (rd_count-1 == 0) + { + 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) + { + /* Could put records into database */ + rrc->op_res = 4; + return; + } + rrc->op_res = 0; + 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) + { + GNUNET_assert (c2 < rd_count_new); + rd_new[c2] = rd[c]; + c2++; + } + } + + 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; +} + static void handle_record_remove (void *cls, struct GNUNET_SERVER_Client * client, const struct GNUNET_MessageHeader * message) @@ -522,10 +1112,21 @@ static void handle_record_remove (void *cls, GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message\n", "NAMESTORE_RECORD_REMOVE"); struct GNUNET_NAMESTORE_Client *nc; struct RecordRemoveResponseMessage rrr_msg; - size_t name_len; - size_t msg_size; - size_t msg_size_exp; - uint32_t id = 0; + 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; + uint32_t rd_count; + uint32_t rid = 0; int res = GNUNET_SYSERR; @@ -544,12 +1145,29 @@ static void handle_record_remove (void *cls, return; } - struct RecordRemoveMessage * rp_msg = (struct RecordRemoveMessage *) message; - id = ntohl (rp_msg->op_id); - name_len = ntohs (rp_msg->name_len); + struct RecordRemoveMessage * rr_msg = (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); - msg_size_exp = sizeof (struct RecordRemoveMessage) + name_len + sizeof (struct GNUNET_NAMESTORE_RecordData); + if (msg_size > GNUNET_SERVER_MAX_MESSAGE_SIZE) + { + 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); + 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); @@ -558,6 +1176,10 @@ static void handle_record_remove (void *cls, return; } + pkey_tmp = (char *) &rr_msg[1]; + name_tmp = &pkey_tmp[key_len]; + rd_ser = &name_tmp[name_len]; + if ((name_len == 0) || (name_len > 256)) { @@ -566,41 +1188,268 @@ static void handle_record_remove (void *cls, return; } - /* DO WORK HERE */ + if (name_tmp[name_len -1] != '\0') + { + GNUNET_break_op (0); + GNUNET_SERVER_receive_done (client, GNUNET_OK); + return; + } - /* Send response */ + /* 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_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message\n", "RECORD_REMOVE_RESPONSE"); - rrr_msg.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_REMOVE_RESPONSE); - rrr_msg.op_id = rp_msg->op_id; - rrr_msg.header.size = htons (sizeof (struct RecordRemoveResponseMessage)); - if (GNUNET_OK == res) - rrr_msg.op_result = htons (GNUNET_OK); + if (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains(zonekeys, &long_hash)) + { + 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); + } + + + 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)) + { + GNUNET_break_op (0); + goto send; + } + + 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"); + + if (GNUNET_OK != res) + /* Could not remove entry from database */ + res = 4; + else + res = 0; + } else - rrr_msg.op_result = htons (GNUNET_NO); + { + /* 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; + } + /* Send response */ +send: + 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_receive_done (client, GNUNET_OK); +} + + +struct ZoneToNameCtx +{ + struct GNUNET_NAMESTORE_Client *nc; + uint32_t rid; +}; + +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) +{ + 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; + char *name_tmp; + char *rd_tmp; + char *sig_tmp; + + if ((zone_key != NULL) && (name != NULL)) + { + /* found result */ + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found results: name is `%s', has %u records\n", name, rd_count); + res = GNUNET_YES; + name_len = strlen (name) +1; + } + else + { + /* no result found */ + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found no results\n"); + res = GNUNET_NO; + name_len = 0; + } + + if (rd_count > 0) + { + 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); + } + 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); + ztnr_msg->res = htons (res); + 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->zone_key = *zone_key; + else + memset (&ztnr_msg->zone_key, '\0', sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)); + + if ((name_len > 0) && (name != NULL)) + 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); + 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) +{ + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message\n", "ZONE_TO_NAME"); + struct GNUNET_NAMESTORE_Client *nc; + 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_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); + return; + } + + rid = ntohl (ztn_msg->gns_header.r_id); + + ztn_ctx.rid = rid; + 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); } + +/** + * Copy record, data has to be free separetely + */ +void +copy_record (const struct GNUNET_NAMESTORE_RecordData *src, struct GNUNET_NAMESTORE_RecordData *dest) +{ + + memcpy (dest, src, sizeof (struct GNUNET_NAMESTORE_RecordData)); + dest->data = GNUNET_malloc (src->data_size); + memcpy ((void *) dest->data, src->data, src->data_size); +} + struct ZoneIterationProcResult { - int have_zone_key; - struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded zone_key; + struct GNUNET_NAMESTORE_ZoneIteration *zi; - int have_signature; + 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; - - int have_name; - char name[256]; - - unsigned int rd_count; - char *rd_ser; }; -void zone_iteration_proc (void *cls, +void zone_iteraterate_proc (void *cls, const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key, struct GNUNET_TIME_Absolute expire, const char *name, @@ -608,40 +1457,230 @@ void zone_iteration_proc (void *cls, const struct GNUNET_NAMESTORE_RecordData *rd, const struct GNUNET_CRYPTO_RsaSignature *signature) { - struct ZoneIterationProcResult *zipr = cls; - size_t len; - if (zone_key != NULL) + struct ZoneIterationProcResult *proc = cls; + struct GNUNET_NAMESTORE_RecordData *rd_filtered; + struct GNUNET_CRYPTO_RsaSignature * new_signature; + 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; + + if ((zone_key == NULL) && (name == NULL)) { - zipr->zone_key = *zone_key; - zipr->have_zone_key = GNUNET_YES; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Iteration done\n"); + proc->res_iteration_finished = GNUNET_YES; + proc->rd = NULL; + proc->name = NULL; } - else - zipr->have_zone_key = GNUNET_NO; + else if ((zone_key != NULL) && (name != NULL)) /* just a safety check */ + { + 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++) + { + 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, "Included %i of %i records \n", rd_count_filtered, rd_count); + + proc->records_included = rd_count_filtered; + if (0 == rd_count_filtered) + { + GNUNET_free (rd_filtered); + rd_filtered = NULL; + } + proc->rd = rd_filtered; + proc->name = GNUNET_strdup(name); + memcpy (&proc->zone_key, zone_key, sizeof (proc->zone_key)); - zipr->expire = expire; + /* 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 (name != NULL) + if (GNUNET_CONTAINER_multihashmap_contains(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; + } + 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); + } + } + } + else { - memcpy (zipr->name, name, strlen(name) + 1); - zipr->have_name = GNUNET_YES; + GNUNET_break (0); + return; } + +} + +void find_next_zone_iteration_result (struct ZoneIterationProcResult *proc) +{ + + struct GNUNET_CRYPTO_ShortHashCode *zone; + + if (GNUNET_YES == proc->zi->has_zone) + zone = &proc->zi->zone; else - zipr->have_name = GNUNET_NO; + zone = NULL; + + do + { + GSN_database->iterate_records (GSN_database->cls, zone , NULL, proc->zi->offset, &zone_iteraterate_proc, proc); + proc->zi->offset++; + } + while ((proc->records_included == 0) && (GNUNET_NO == proc->res_iteration_finished)); +} - zipr->rd_count = rd_count; - if (signature != NULL) +void send_zone_iteration_result (struct ZoneIterationProcResult *proc) +{ + struct GNUNET_NAMESTORE_ZoneIteration *zi = proc->zi; + + if (GNUNET_YES == proc->res_iteration_finished) { - zipr->signature = *signature; - zipr->have_signature = GNUNET_YES; + 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; } else - zipr->have_signature = GNUNET_NO; + { + 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); + } +} - if ((rd_count > 0) && (rd != NULL)) +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++) { - len = GNUNET_NAMESTORE_records_serialize (&zipr->rd_ser, rd_count, rd); + 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, @@ -653,9 +1692,6 @@ static void handle_iteration_start (void *cls, struct ZoneIterationStartMessage * zis_msg = (struct ZoneIterationStartMessage *) message; struct GNUNET_NAMESTORE_Client *nc; struct GNUNET_NAMESTORE_ZoneIteration *zi; - struct ZoneIterationResponseMessage zir_msg; - struct ZoneIterationProcResult zipr; - int res; nc = client_lookup(client); if (nc == NULL) @@ -666,22 +1702,43 @@ static void handle_iteration_start (void *cls, } zi = GNUNET_malloc (sizeof (struct GNUNET_NAMESTORE_ZoneIteration)); - zi->op_id = ntohl (zis_msg->op_id); + zi->request_id = ntohl (zis_msg->gns_header.r_id); zi->offset = 0; zi->client = nc; - zi->zone = zis_msg->zone; - - GNUNET_CONTAINER_DLL_insert (nc->op_head, nc->op_tail, zi); + zi->must_have_flags = ntohs (zis_msg->must_have_flags); + zi->must_not_have_flags = ntohs (zis_msg->must_not_have_flags); - res = GSN_database->iterate_records (GSN_database->cls, &zis_msg->zone, NULL, zi->offset , &zone_iteration_proc, &zipr); + struct GNUNET_CRYPTO_ShortHashCode dummy; + memset (&dummy, '\0', sizeof (dummy)); + if (0 == memcmp (&dummy, &zis_msg->zone, sizeof (dummy))) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting to iterate over all zones\n"); + zi->zone = zis_msg->zone; + zi->has_zone = GNUNET_NO; + } + else + { + 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_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message\n", "ZONE_ITERATION_RESPONSE"); - zir_msg.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_RESPONSE); - zir_msg.op_id = htonl(zi->op_id); - zir_msg.header.size = htons (sizeof (struct ZoneIterationResponseMessage)); + GNUNET_CONTAINER_DLL_insert (nc->op_head, nc->op_tail, zi); - GNUNET_SERVER_notification_context_unicast (snc, zi->client->client, (const struct GNUNET_MessageHeader *) &zir_msg, GNUNET_NO); + 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); GNUNET_SERVER_receive_done (client, GNUNET_OK); } @@ -695,7 +1752,7 @@ static void handle_iteration_stop (void *cls, struct GNUNET_NAMESTORE_Client *nc; struct GNUNET_NAMESTORE_ZoneIteration *zi; struct ZoneIterationStopMessage * zis_msg = (struct ZoneIterationStopMessage *) message; - uint32_t id; + uint32_t rid; nc = client_lookup(client); if (nc == NULL) @@ -705,10 +1762,10 @@ static void handle_iteration_stop (void *cls, return; } - id = ntohl (zis_msg->op_id); + rid = ntohl (zis_msg->gns_header.r_id); for (zi = nc->op_head; zi != NULL; zi = zi->next) { - if (zi->op_id == id) + if (zi->request_id == rid) break; } if (zi == NULL) @@ -719,7 +1776,10 @@ static void handle_iteration_stop (void *cls, } GNUNET_CONTAINER_DLL_remove(nc->op_head, nc->op_tail, zi); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopped zone iteration for zone `%s'\n", GNUNET_h2s (&zi->zone)); + if (GNUNET_YES == zi->has_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_free (zi); GNUNET_SERVER_receive_done (client, GNUNET_OK); @@ -734,8 +1794,7 @@ static void handle_iteration_next (void *cls, struct GNUNET_NAMESTORE_Client *nc; struct GNUNET_NAMESTORE_ZoneIteration *zi; struct ZoneIterationStopMessage * zis_msg = (struct ZoneIterationStopMessage *) message; - uint32_t id; - int res; + uint32_t rid; nc = client_lookup(client); if (nc == NULL) @@ -745,10 +1804,10 @@ static void handle_iteration_next (void *cls, return; } - id = ntohl (zis_msg->op_id); + rid = ntohl (zis_msg->gns_header.r_id); for (zi = nc->op_head; zi != NULL; zi = zi->next) { - if (zi->op_id == id) + if (zi->request_id == rid) break; } if (zi == NULL) @@ -758,10 +1817,49 @@ static void handle_iteration_next (void *cls, return; } - zi->offset++; - res = GSN_database->iterate_records (GSN_database->cls, &zi->zone, NULL, zi->offset , &zone_iteration_proc, 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); + + GNUNET_SERVER_receive_done (client, GNUNET_OK); } +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; +} /** @@ -776,7 +1874,7 @@ 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[] = { @@ -790,17 +1888,45 @@ run (void *cls, struct GNUNET_SERVER_Handle *server, GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_CREATE, 0}, {&handle_record_remove, NULL, GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_REMOVE, 0}, + {&handle_zone_to_name, NULL, + GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME, 0}, {&handle_iteration_start, NULL, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START, sizeof (struct ZoneIterationStartMessage)}, - {&handle_iteration_stop, NULL, - GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP, sizeof (struct ZoneIterationStopMessage)}, {&handle_iteration_next, NULL, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT, 0}, + {&handle_iteration_stop, NULL, + GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP, 0}, {NULL, NULL, 0, 0} }; GSN_cfg = cfg; + /* Load private keys from disk */ + if (GNUNET_OK != + 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_SCHEDULER_add_now (&cleanup_task, NULL); + return; + } + + if (GNUNET_NO == GNUNET_DISK_file_test (zonefile_directory)) + { + 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_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, "Scanning directory `%s' for zone files\n", zonefile_directory); + zonekeys = GNUNET_CONTAINER_multihashmap_create (10); + GNUNET_DISK_directory_scan (zonefile_directory, zonekey_file_it, &counter); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found %u zone files\n", counter); + /* Loading database plugin */ if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, "namestore", "database", @@ -809,10 +1935,14 @@ 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) + { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not load database backend `%s'\n", db_lib_name); - GNUNET_free (database); + GNUNET_SCHEDULER_add_now (&cleanup_task, NULL); + return; + } /* Configuring server handles */ GNUNET_SERVER_add_handlers (server, handlers); @@ -843,3 +1973,4 @@ main (int argc, char *const *argv) } /* end of gnunet-service-namestore.c */ + |