From 0b80f1a54fd5efba4bca8dc4269cc0cb8e25d77d Mon Sep 17 00:00:00 2001 From: Matthias Wachs Date: Fri, 25 Oct 2013 15:36:32 +0000 Subject: api communication done --- src/namestore/gnunet-service-namestore.c | 110 ++++++++++++++++++++-- src/namestore/namestore.h | 41 ++++++++ src/namestore/namestore_api.c | 75 ++++++++++++++- src/namestore/test_namestore_api_lookup_private.c | 40 +++++++- 4 files changed, 251 insertions(+), 15 deletions(-) (limited to 'src/namestore') diff --git a/src/namestore/gnunet-service-namestore.c b/src/namestore/gnunet-service-namestore.c index 79e154cc2..3332ffcc6 100644 --- a/src/namestore/gnunet-service-namestore.c +++ b/src/namestore/gnunet-service-namestore.c @@ -561,6 +561,48 @@ refresh_block (struct GNUNET_SERVER_Client *client, GNUNET_free (block); } + +struct RecordLookupContext +{ + const char *label; + + int found; + + unsigned int res_rd_count; + + size_t rd_ser_len; + + char *res_rd; +}; + +static void lookup_it (void *cls, + const struct GNUNET_CRYPTO_EcdsaPrivateKey *private_key, + const char *label, + unsigned int rd_count, + const struct GNUNET_GNSRECORD_Data *rd) +{ + struct RecordLookupContext *rlc = cls; + + if (0 == strcmp (label, rlc->label)) + { + rlc->found = GNUNET_YES; + if (0 != rd_count) + { + rlc->rd_ser_len = GNUNET_GNSRECORD_records_get_size (rd_count, rd); + rlc->res_rd_count = rd_count; + rlc->res_rd = GNUNET_malloc (rlc->rd_ser_len); + GNUNET_GNSRECORD_records_serialize (rd_count, rd, rlc->rd_ser_len , rlc->res_rd); + } + else + { + rlc->rd_ser_len = 0; + rlc->res_rd_count = 0; + rlc->res_rd = NULL; + } + } +} + + /** * Handles a #GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP message * @@ -573,11 +615,16 @@ handle_record_lookup (void *cls, struct GNUNET_SERVER_Client *client, const struct GNUNET_MessageHeader *message) { - const struct LabelLookupMessage * ll_msg; + const struct LabelLookupMessage *ll_msg; + struct LabelLookupResponseMessage *llr_msg; + struct RecordLookupContext rlc; const char *name_tmp; - uint32_t rid; + char *res_name; uint32_t name_len; - size_t msg_size; + size_t src_size; + size_t res_size; + int offset; + int res; if (ntohs (message->size) < sizeof (struct LabelLookupMessage)) { @@ -587,21 +634,64 @@ handle_record_lookup (void *cls, } ll_msg = (const struct LabelLookupMessage *) message; - rid = ntohl (ll_msg->gns_header.r_id); - name_len = ntohs (ll_msg->label_len); - msg_size = ntohs (message->size); + name_len = ntohl (ll_msg->label_len); + src_size = ntohs (message->size); + + if (name_len != src_size - sizeof (struct LabelLookupMessage)) + { + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); + return; + } - if (name_len != msg_size - sizeof (struct LabelLookupMessage)) + name_tmp = (const char *) &ll_msg[1]; + if ('\0' != name_tmp[name_len -1]) { GNUNET_break (0); GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } - name_tmp = &ll_msg[1]; + GNUNET_SERVER_receive_done (client, GNUNET_OK); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message for name `%s'\n", "NAMESTORE_RECORD_LOOKUP", name_tmp); + + + rlc.label = name_tmp; + rlc.found = GNUNET_NO; + rlc.res_rd_count = 0; + rlc.rd_ser_len = 0; + rlc.res_rd = NULL; + + offset = 0; + do + { + /* changee this call */ + res = GSN_database->iterate_records (GSN_database->cls, + &ll_msg->zone, offset, &lookup_it, &rlc); + offset++; + } + while ((GNUNET_NO == rlc.found) && (GNUNET_OK == res)); + + res_size = sizeof (struct LabelLookupResponseMessage) + name_len + rlc.rd_ser_len; + llr_msg = GNUNET_malloc (res_size); + llr_msg->gns_header.header.size = htons (res_size); + llr_msg->gns_header.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE); + llr_msg->gns_header.r_id = ll_msg->gns_header.r_id; + llr_msg->private_key = ll_msg->zone; + llr_msg->name_len = htons (name_len); + llr_msg->rd_count = htons (rlc.res_rd_count); + llr_msg->rd_len = htons (rlc.rd_ser_len); + res_name = (char *) &llr_msg[1]; + memcpy (&llr_msg[1], name_tmp, name_len); + memcpy (&res_name[name_len], rlc.res_rd, rlc.rd_ser_len); + + GNUNET_SERVER_notification_context_unicast (snc, client, &llr_msg->gns_header.header, + GNUNET_NO); + + GNUNET_free_non_null (rlc.res_rd); + GNUNET_free (llr_msg); } @@ -963,7 +1053,7 @@ struct ZoneIterationProcResult * @param rd record data */ static void -zone_iteraterate_proc (void *cls, +zone_iterate_proc (void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key, const char *name, unsigned int rd_count, @@ -1036,7 +1126,7 @@ run_zone_iteration_round (struct ZoneIteration *zi) ? NULL : &zi->zone, zi->offset, - &zone_iteraterate_proc, &proc))) + &zone_iterate_proc, &proc))) { GNUNET_break (0); break; diff --git a/src/namestore/namestore.h b/src/namestore/namestore.h index d633f7393..5e900dbcc 100644 --- a/src/namestore/namestore.h +++ b/src/namestore/namestore.h @@ -235,6 +235,47 @@ struct LabelLookupMessage }; +/** + * Lookup a label + */ +struct LabelLookupResponseMessage +{ + /** + * Type will be #GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE + */ + struct GNUNET_NAMESTORE_Header gns_header; + + /** + * Name length + */ + uint16_t name_len GNUNET_PACKED; + + /** + * Length of serialized record data + */ + uint16_t rd_len GNUNET_PACKED; + + /** + * Number of records contained + */ + uint16_t rd_count GNUNET_PACKED; + + /** + * always zero (for alignment) + */ + uint16_t reserved GNUNET_PACKED; + + /** + * The private key of the authority. + */ + struct GNUNET_CRYPTO_EcdsaPrivateKey private_key; + + /* followed by: + * name with length name_len + * serialized record data with rd_count records + */ +}; + /** diff --git a/src/namestore/namestore_api.c b/src/namestore/namestore_api.c index 9d290fca2..303b05c98 100644 --- a/src/namestore/namestore_api.c +++ b/src/namestore/namestore_api.c @@ -279,6 +279,72 @@ handle_record_store_response (struct GNUNET_NAMESTORE_QueueEntry *qe, } +/** + * Handle an incoming message of type + * #GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE + * + * @param qe the respective entry in the message queue + * @param msg the message we received + * @param size the message size + * @return #GNUNET_OK on success, #GNUNET_SYSERR on error and we did NOT notify the client + */ +static int +handle_lookup_result (struct GNUNET_NAMESTORE_QueueEntry *qe, + const struct LabelLookupResponseMessage *msg, + size_t size) +{ + const char *name; + const char *rd_tmp; + size_t exp_msg_len; + size_t msg_len; + size_t name_len; + size_t rd_len; + unsigned int rd_count; + + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Received `%s'\n", + "RECORD_LOOKUP_RESULT"); + + rd_len = ntohs (msg->rd_len); + rd_count = ntohs (msg->rd_count); + msg_len = ntohs (msg->gns_header.header.size); + name_len = ntohs (msg->name_len); + GNUNET_break (0 == ntohs (msg->reserved)); + exp_msg_len = sizeof (struct LabelLookupResponseMessage) + name_len + rd_len; + if (msg_len != exp_msg_len) + { + GNUNET_break (0); + return GNUNET_SYSERR; + } + name = (const char *) &msg[1]; + if ( (name_len > 0) && + ('\0' != name[name_len -1]) ) + { + GNUNET_break (0); + return GNUNET_SYSERR; + } + rd_tmp = &name[name_len]; + { + struct GNUNET_GNSRECORD_Data rd[rd_count]; + + if (GNUNET_OK != GNUNET_GNSRECORD_records_deserialize(rd_len, rd_tmp, rd_count, rd)) + { + GNUNET_break (0); + return GNUNET_SYSERR; + } + if (0 == name_len) + name = NULL; + if (NULL != qe->proc) + qe->proc (qe->proc_cls, + &msg->private_key, + name, + rd_count, + (rd_count > 0) ? rd : NULL); + } + return GNUNET_OK; +} + + /** * Handle an incoming message of type * #GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT @@ -462,6 +528,13 @@ manage_record_operations (struct GNUNET_NAMESTORE_QueueEntry *qe, return GNUNET_SYSERR; } return handle_record_result (qe, (const struct RecordResultMessage *) msg, size); + case GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE: + if (size < sizeof (struct LabelLookupResponseMessage)) + { + GNUNET_break (0); + return GNUNET_SYSERR; + } + return handle_lookup_result (qe, (const struct LabelLookupResponseMessage *) msg, size); default: GNUNET_break (0); return GNUNET_SYSERR; @@ -1026,7 +1099,7 @@ GNUNET_NAMESTORE_records_lookup (struct GNUNET_NAMESTORE_Handle *h, msg->gns_header.header.size = htons (msg_size); msg->gns_header.r_id = htonl (qe->op_id); msg->zone = *pkey; - msg->label_len = htons(label_len); + msg->label_len = htonl(label_len); memcpy (&msg[1], label, label_len); /* transmit message */ diff --git a/src/namestore/test_namestore_api_lookup_private.c b/src/namestore/test_namestore_api_lookup_private.c index 65b7f87c6..e1aa6b8b8 100644 --- a/src/namestore/test_namestore_api_lookup_private.c +++ b/src/namestore/test_namestore_api_lookup_private.c @@ -45,7 +45,8 @@ static int res; static struct GNUNET_NAMESTORE_QueueEntry *nsqe; -static const char * name = "dummy.dummy.gnunet"; +//static const char * name = "dummy.dummy.gnunet"; +static const char * name = "d"; static void cleanup () @@ -96,14 +97,45 @@ void lookup_it (void *cls, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd) { - nsqe = NULL; - /* Check here */ + nsqe = NULL; + + if (0 != memcmp(privkey, zone, sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey))) + { + GNUNET_break(0); + GNUNET_SCHEDULER_cancel (endbadly_task); + endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL ); + return; + } + if (NULL == label) + { + GNUNET_break(0); + GNUNET_SCHEDULER_cancel (endbadly_task); + endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL ); + return; + } + + if (0 != strcmp (label, name)) + { + GNUNET_break(0); + GNUNET_SCHEDULER_cancel (endbadly_task); + endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL ); + return; + } + + if (1 != rd_count) + { + GNUNET_break(0); + GNUNET_SCHEDULER_cancel (endbadly_task); + endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL ); + return; + } + /* Done */ GNUNET_SCHEDULER_cancel (endbadly_task); endbadly_task = GNUNET_SCHEDULER_NO_TASK; - GNUNET_SCHEDULER_add_now (&end, NULL); + GNUNET_SCHEDULER_add_now (&end, NULL ); } -- cgit v1.2.3