GNUNET_HashCode zone;
uint32_t no_flags;
uint32_t flags;
+ int has_zone;
};
-/**
- * Convert a type name (i.e. "AAAA") to the corresponding number.
- *
- * @param typename name to convert
- * @return corresponding number, UINT32_MAX on error
- */
-uint32_t
-GNUNET_NAMESTORE_typename_to_number (const char *typename)
-{
- static struct {
- const char *name;
- uint32_t number;
- } map[] = {
- { "A", GNUNET_DNSPARSER_TYPE_A },
- { "NS", GNUNET_DNSPARSER_TYPE_NS },
- { "CNAME", GNUNET_DNSPARSER_TYPE_CNAME },
- { "SOA", GNUNET_DNSPARSER_TYPE_SOA },
- { "PTR", GNUNET_DNSPARSER_TYPE_PTR },
- { "MX", GNUNET_DNSPARSER_TYPE_MX },
- { "TXT", GNUNET_DNSPARSER_TYPE_TXT },
- { "AAAA", GNUNET_DNSPARSER_TYPE_AAAA },
- { "PKEY", GNUNET_NAMESTORE_TYPE_PKEY },
- { "PSEU", GNUNET_NAMESTORE_TYPE_PSEU },
- { NULL, UINT32_MAX }
- };
- unsigned int i;
-
- i=0;
- while ( (map[i].name != NULL) &&
- (0 != strcasecmp (typename, map[i].name)) )
- i++;
- return map[i].number;
-}
-
-
/**
* Disconnect from service and then reconnect.
*
"LOOKUP_NAME_RESPONSE");
struct GNUNET_NAMESTORE_Handle *h = qe->nsh;
- struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key;
+
+ /* Operation done, remove */
+ GNUNET_CONTAINER_DLL_remove(h->op_head, h->op_tail, qe);
+
+
char *name;
char * rd_tmp;
struct GNUNET_CRYPTO_RsaSignature *signature = NULL;
- struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded dummy;
struct GNUNET_TIME_Absolute expire;
+ struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *public_key_tmp;
size_t exp_msg_len;
size_t msg_len = 0;
size_t name_len = 0;
exp_msg_len = sizeof (struct LookupNameResponseMessage) +
sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) +
- name_len +
- rd_len +
- contains_sig * sizeof (struct GNUNET_CRYPTO_RsaSignature);
+ name_len + rd_len;
if (msg_len != exp_msg_len)
{
return;
}
- zone_key = (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *) &msg[1];
- name = (char *) &zone_key[1];
+ name = (char *) &msg[1];
rd_tmp = &name[name_len];
+ /* deserialize records */
struct GNUNET_NAMESTORE_RecordData rd[rd_count];
GNUNET_NAMESTORE_records_deserialize(rd_len, rd_tmp, rd_count, rd);
if (contains_sig == GNUNET_NO)
signature = NULL;
else
- signature = (struct GNUNET_CRYPTO_RsaSignature *) &rd_tmp[rd_len];
+ signature = &msg->signature;
if (name_len == 0)
name = NULL;
- memset (&dummy, '0', sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
- if (0 == memcmp (zone_key, &dummy, sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)))
- zone_key = NULL;
+ if (name != NULL)
+ public_key_tmp = &msg->public_key;
+ else
+ public_key_tmp = NULL;
if (qe->proc != NULL)
{
- qe->proc (qe->proc_cls, zone_key, expire, name, rd_count, (rd_count > 0) ? rd : NULL, signature);
+ qe->proc (qe->proc_cls, public_key_tmp, expire, name, rd_count, (rd_count > 0) ? rd : NULL, signature);
}
-
- /* Operation done, remove */
- GNUNET_CONTAINER_DLL_remove(h->op_head, h->op_tail, qe);
GNUNET_free (qe);
}
"RECORD_PUT_RESPONSE");
struct GNUNET_NAMESTORE_Handle *h = qe->nsh;
- int res = GNUNET_OK;
+ /* Operation done, remove */
+ GNUNET_CONTAINER_DLL_remove(h->op_head, h->op_tail, qe);
- if (ntohs (msg->op_result) == GNUNET_OK)
+ int res = ntohl (msg->op_result);
+
+ if (res == GNUNET_OK)
{
- res = GNUNET_OK;
if (qe->cont != NULL)
{
qe->cont (qe->cont_cls, res, _("Namestore added record successfully"));
}
}
- else if (ntohs (msg->op_result) == GNUNET_NO)
+ else if (res == GNUNET_SYSERR)
{
- res = GNUNET_SYSERR;
if (qe->cont != NULL)
{
qe->cont (qe->cont_cls, res, _("Namestore failed to add record"));
return;
}
- /* Operation done, remove */
- GNUNET_CONTAINER_DLL_remove(h->op_head, h->op_tail, qe);
-
GNUNET_free (qe);
}
"RECORD_CREATE_RESPONSE");
struct GNUNET_NAMESTORE_Handle *h = qe->nsh;
+ /* Operation done, remove */
+ GNUNET_CONTAINER_DLL_remove(h->op_head, h->op_tail, qe);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' %i\n",
- "RECORD_CREATE_RESPONSE", ntohs (msg->op_result));
- if (ntohs (msg->op_result) == GNUNET_YES)
+ int res = ntohl (msg->op_result);
+ if (res == GNUNET_YES)
{
if (qe->cont != NULL)
{
- qe->cont (qe->cont_cls, GNUNET_YES, _("Namestore added record successfully"));
+ qe->cont (qe->cont_cls, res, _("Namestore added record successfully"));
}
}
- else if (ntohs (msg->op_result) == GNUNET_NO)
+ else if (res == GNUNET_NO)
{
if (qe->cont != NULL)
{
- qe->cont (qe->cont_cls, GNUNET_NO, _("Namestore record already existed"));
+ qe->cont (qe->cont_cls, res, _("Namestore record already existed"));
}
}
else
}
}
- /* Operation done, remove */
- GNUNET_CONTAINER_DLL_remove(h->op_head, h->op_tail, qe);
-
GNUNET_free (qe);
}
"RECORD_REMOVE_RESPONSE");
struct GNUNET_NAMESTORE_Handle *h = qe->nsh;
- int res = ntohs (msg->op_result);
+ /* Operation done, remove */
+ GNUNET_CONTAINER_DLL_remove(h->op_head, h->op_tail, qe);
+ int res = ntohl (msg->op_result);
/**
* result:
* 0 : successful
break;
}
- /* Operation done, remove */
- GNUNET_CONTAINER_DLL_remove(h->op_head, h->op_tail, qe);
-
GNUNET_free (qe);
}
"ZONE_TO_NAME_RESPONSE");
struct GNUNET_NAMESTORE_Handle *h = qe->nsh;
+ /* Operation done, remove */
+ GNUNET_CONTAINER_DLL_remove(h->op_head, h->op_tail, qe);
+
int res = ntohs (msg->res);
struct GNUNET_TIME_Absolute expire;
size_t name_len;
size_t rd_ser_len;
unsigned int rd_count;
- int have_signature;
char * name_tmp;
char * rd_tmp;
- struct GNUNET_CRYPTO_RsaSignature* sig_tmp;
if (res == GNUNET_SYSERR)
{
name_len = ntohs (msg->name_len);
rd_count = ntohs (msg->rd_count);
rd_ser_len = ntohs (msg->rd_len);
- have_signature = ntohl (msg->contains_sig);
expire = GNUNET_TIME_absolute_ntoh(msg->expire);
name_tmp = (char *) &msg[1];
rd_tmp = &name_tmp[name_len];
- if (have_signature == GNUNET_YES)
- sig_tmp = (struct GNUNET_CRYPTO_RsaSignature *) &rd_tmp[rd_ser_len];
- else
- sig_tmp = NULL;
struct GNUNET_NAMESTORE_RecordData rd[rd_count];
GNUNET_NAMESTORE_records_deserialize(rd_ser_len, rd_tmp, rd_count, rd);
if (qe->proc != NULL)
- qe->proc (qe->proc_cls, &msg->zone_key, expire, name_tmp, rd_count, rd, sig_tmp);
-
+ qe->proc (qe->proc_cls, &msg->zone_key, expire, name_tmp, rd_count, rd, &msg->signature);
}
else
GNUNET_break_op (0);
- /* Operation done, remove */
- GNUNET_CONTAINER_DLL_remove(h->op_head, h->op_tail, qe);
GNUNET_free (qe);
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' \n",
"ZONE_ITERATION_RESPONSE");
+ struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pubdummy;
+ size_t msg_len = 0;
+ size_t exp_msg_len = 0;
+ size_t name_len = 0;
+ size_t rd_len = 0;
+ unsigned rd_count = 0;
- if (ze->proc != NULL)
+ char *name_tmp;
+ char *rd_ser_tmp;
+ struct GNUNET_TIME_Absolute expire;
+
+ msg_len = ntohs (msg->gns_header.header.size);
+ rd_len = ntohs (msg->rd_len);
+ rd_count = ntohs (msg->rd_count);
+ name_len = ntohs (msg->name_len);
+ expire = GNUNET_TIME_absolute_ntoh (msg->expire);
+
+ exp_msg_len = sizeof (struct ZoneIterationResponseMessage) + name_len + rd_len;
+ if (msg_len != exp_msg_len)
{
- // FIXME
- ze->proc(ze->proc_cls, NULL, GNUNET_TIME_absolute_get_forever(), "dummy", 0, NULL, NULL);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Message size describes with `%u' bytes but calculated size is %u bytes \n",
+ msg_len, exp_msg_len);
+ GNUNET_break_op (0);
+ return;
+ }
+ if (0 != ntohs (msg->reserved))
+ {
+ GNUNET_break_op (0);
+ return;
}
+
+ memset (&pubdummy, '\0', sizeof (pubdummy));
+ if ((0 == name_len) && (0 == (memcmp (&msg->public_key, &pubdummy, sizeof (pubdummy)))))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Zone iteration is completed!\n");
+
+ GNUNET_CONTAINER_DLL_remove(ze->h->z_head, ze->h->z_tail, ze);
+
+ if (ze->proc != NULL)
+ ze->proc(ze->proc_cls, NULL, GNUNET_TIME_absolute_get_zero (), NULL , 0, NULL, NULL);
+
+ GNUNET_free (ze);
+ return;
+ }
+
+ name_tmp = (char *) &msg[1];
+ if ((name_tmp[name_len -1] != '\0') || (name_len > 256))
+ {
+ GNUNET_break_op (0);
+ return;
+ }
+ rd_ser_tmp = (char *) &name_tmp[name_len];
+ struct GNUNET_NAMESTORE_RecordData rd[rd_count];
+ if (GNUNET_OK != GNUNET_NAMESTORE_records_deserialize (rd_len, rd_ser_tmp, rd_count, rd))
+ {
+ GNUNET_break_op (0);
+ return;
+ }
+
+ if (ze->proc != NULL)
+ ze->proc(ze->proc_cls, &msg->public_key, expire, name_tmp, rd_count, rd, &msg->signature);
}
return h;
}
-struct DisconnectContext
-{
- struct GNUNET_NAMESTORE_Handle *h;
- int drop;
-};
-
static void
clean_up_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
while (NULL != (q = h->op_head))
{
- GNUNET_break (0);
GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, q);
GNUNET_free (q);
}
h = NULL;
};
-static size_t
-transmit_disconnect_to_namestore (void *cls, size_t size, void *buf)
-{
- struct DisconnectContext * d_ctx = cls;
- struct DisconnectMessage d_msg;
- struct GNUNET_NAMESTORE_Handle *h = d_ctx->h;
- int res;
-
- d_msg.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_DISCONNECT);
- d_msg.header.size = htons (sizeof (struct DisconnectMessage));
- d_msg.drop = htonl (d_ctx->drop);
-
- h->th = NULL;
- if ((size == 0) || (buf == NULL) || (size < sizeof (struct DisconnectMessage)))
- {
- GNUNET_break (0);
- res = 0;
- }
- else
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message to service \n", "NAMESTORE_DISCONNECT");
- memcpy (buf, &d_msg, sizeof (struct DisconnectMessage));
- res = sizeof (struct DisconnectMessage);
- }
-
- GNUNET_SCHEDULER_add_now (&clean_up_task, h);
- GNUNET_free (d_ctx);
- return res;
-}
-
/**
* Disconnect from the namestore service (and free associated
* resources).
void
GNUNET_NAMESTORE_disconnect (struct GNUNET_NAMESTORE_Handle *h, int drop)
{
- if (h->th != NULL)
- {
- GNUNET_CLIENT_notify_transmit_ready_cancel(h->th);
- h->th = NULL;
- }
- if (h->client != NULL)
- {
- struct DisconnectContext *d_ctx = GNUNET_malloc (sizeof (struct DisconnectContext));
- d_ctx->h = h;
- d_ctx->drop = drop;
-
- h->th = GNUNET_CLIENT_notify_transmit_ready (h->client, sizeof (struct DisconnectMessage),
- GNUNET_TIME_UNIT_FOREVER_REL,
- GNUNET_NO, &transmit_disconnect_to_namestore,
- d_ctx);
- }
- else
- {
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Could not send disconnect notification to namestore service, we are not connected!\n");
- if (GNUNET_YES == drop)
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "NAMESTORE will not drop content\n");
- GNUNET_SCHEDULER_add_now (&clean_up_task, h);
- }
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from namestore service\n");
+ GNUNET_SCHEDULER_add_now (&clean_up_task, h);
}
struct PendingMessage *pe;
/* pointer to elements */
- char * zone_key_tmp;
char * rd_tmp;
char * name_tmp;
size_t msg_size = 0;
size_t name_len = 0;
size_t rd_ser_len = 0;
- size_t pubkey_len = 0;
uint32_t rid = 0;
GNUNET_assert (NULL != h);
char rd_ser[rd_ser_len];
GNUNET_NAMESTORE_records_serialize(rd_count, rd, rd_ser_len, rd_ser);
- pubkey_len = sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded);
struct RecordPutMessage * msg;
- msg_size = sizeof (struct RecordPutMessage) + pubkey_len + name_len + rd_ser_len;
+ msg_size = sizeof (struct RecordPutMessage) + name_len + rd_ser_len;
/* create msg here */
pe = GNUNET_malloc(sizeof (struct PendingMessage) + msg_size);
pe->size = msg_size;
pe->is_init = GNUNET_NO;
msg = (struct RecordPutMessage *) &pe[1];
- zone_key_tmp = (char *) &msg[1];
- name_tmp = (char *) &zone_key_tmp[pubkey_len];
+ name_tmp = (char *) &msg[1];
rd_tmp = &name_tmp[name_len];
msg->gns_header.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_PUT);
msg->gns_header.header.size = htons (msg_size);
msg->gns_header.r_id = htonl (rid);
- msg->key_len = htons (pubkey_len);
- memcpy (zone_key_tmp, zone_key, pubkey_len);
msg->signature = *signature;
msg->name_len = htons (name_len);
- memcpy (name_tmp, name, name_len);
msg->expire = GNUNET_TIME_absolute_hton (expire);
msg->rd_len = htons (rd_ser_len);
msg->rd_count = htons (rd_count);
+ msg->public_key = *zone_key;
+ memcpy (name_tmp, name, name_len);
memcpy (rd_tmp, rd_ser, rd_ser_len);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message for name `%s' with size %u\n", "NAMESTORE_RECORD_PUT", name, msg_size);
GNUNET_assert (public_key != NULL);
GNUNET_assert (name != NULL);
+ GNUNET_assert (rd != NULL);
GNUNET_assert (signature != NULL);
+
rd_ser_len = GNUNET_NAMESTORE_records_get_size(rd_count, rd);
char rd_ser[rd_ser_len];
GNUNET_NAMESTORE_records_serialize(rd_count, rd, rd_ser_len, rd_ser);
name_len = strlen (name) + 1;
+ if (name_len > 256)
+ {
+ GNUNET_break (0);
+ return GNUNET_SYSERR;
+ }
sig_purpose = GNUNET_malloc(sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) + rd_ser_len + name_len);
sig_purpose->size = htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose)+ rd_ser_len + name_len);
*
* @param h handle to the namestore
* @param pkey private key of the zone
+ * @param expire block expiration time
* @param name name that is being mapped (at most 255 characters long)
* @param rd record data to store
* @param cont continuation to call when done
msg->rd_count = htons (1);
msg->rd_len = htons (rd_ser_len);
msg->pkey_len = htons (key_len);
+ msg->expire = GNUNET_TIME_absolute_hton(GNUNET_TIME_absolute_get_forever());
memcpy (pkey_tmp, pkey_enc, key_len);
memcpy (name_tmp, name, name_len);
memcpy (rd_tmp, rd_ser, rd_ser_len);
msg->name_len = htons (name_len);
msg->rd_len = htons (rd_ser_len);
msg->rd_count = htons (1);
- msg->key_len = htons (key_len);
+ msg->pkey_len = htons (key_len);
memcpy (pkey_tmp, pkey_enc, key_len);
memcpy (name_tmp, name, name_len);
memcpy (rd_tmp, rd_ser, rd_ser_len);
msg->gns_header.header.size = htons (msg_size);
msg->gns_header.r_id = htonl (rid);
msg->record_type = htonl (record_type);
- msg->zone = *zone;
msg->name_len = htonl (name_len);
+ msg->zone = *zone;
memcpy (&msg[1], name, name_len);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message for name `%s'\n", "NAMESTORE_LOOKUP_NAME", name);
uint32_t rid = 0;
GNUNET_assert (NULL != h);
- GNUNET_assert (NULL != zone);
+
rid = get_op_id(h);
it = GNUNET_malloc (sizeof (struct GNUNET_NAMESTORE_ZoneIterator));
it->proc = proc;
it->proc_cls = proc;
it->op_id = rid;
- it->zone = *zone;
+
+ if (NULL != zone)
+ {
+ it->zone = *zone;
+ it->has_zone = GNUNET_YES;
+ }
+ else
+ {
+ memset (&it->zone, '\0', sizeof (it->zone));
+ it->has_zone = GNUNET_NO;
+ }
GNUNET_CONTAINER_DLL_insert_tail(h->z_head, h->z_tail, it);
/* set msg_size*/
msg->gns_header.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START);
msg->gns_header.header.size = htons (msg_size);
msg->gns_header.r_id = htonl (rid);
- msg->zone = *zone;
+ if (NULL != zone)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message for zone `%s'\n", "ZONE_ITERATION_START", GNUNET_h2s(zone));
+ msg->zone = *zone;
+ }
+ else
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message for all zones\n", "ZONE_ITERATION_START");
+ memset (&msg->zone, '\0', sizeof (msg->zone));
+ }
msg->must_have_flags = ntohs (must_have_flags);
msg->must_not_have_flags = ntohs (must_not_have_flags);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message for zone `%s'\n", "ZONE_ITERATION_START", GNUNET_h2s(zone));
+
/* transmit message */
GNUNET_CONTAINER_DLL_insert_tail (h->pending_head, h->pending_tail, pe);
msg->gns_header.header.size = htons (msg_size);
msg->gns_header.r_id = htonl (it->op_id);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message for name `%s'\n", "ZONE_ITERATION_NEXT", GNUNET_h2s(&it->zone));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message\n", "ZONE_ITERATION_NEXT");
/* transmit message */
GNUNET_CONTAINER_DLL_insert_tail (h->pending_head, h->pending_tail, pe);
msg->gns_header.header.size = htons (msg_size);
msg->gns_header.r_id = htonl (it->op_id);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message for name `%s'\n", "ZONE_ITERATION_STOP", GNUNET_h2s(&it->zone));
+ if (GNUNET_YES == it->has_zone)
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message for zone `%s'\n", "ZONE_ITERATION_STOP", GNUNET_h2s(&it->zone));
+ else
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message for all zones\n", "ZONE_ITERATION_STOP");
/* transmit message */
GNUNET_CONTAINER_DLL_insert_tail (h->pending_head, h->pending_tail, pe);
projects / oweals / gnunet.git / blobdiff