struct GNUNET_NAMESTORE_Handle *h;
GNUNET_NAMESTORE_RecordProcessor proc;
void* proc_cls;
- GNUNET_HashCode zone;
+ struct GNUNET_CRYPTO_ShortHashCode zone;
uint32_t no_flags;
uint32_t flags;
int has_zone;
struct GNUNET_NAMESTORE_SimpleRecord *prev;
const char *name;
- const GNUNET_HashCode *zone;
+ const struct GNUNET_CRYPTO_ShortHashCode *zone;
uint32_t record_type;
struct GNUNET_TIME_Absolute expiration;
enum GNUNET_NAMESTORE_RecordFlags flags;
-/**
- * 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;
+
+ /* Operation done, remove */
+ GNUNET_CONTAINER_DLL_remove(h->op_head, h->op_tail, qe);
+
+
char *name;
char * rd_tmp;
}
name = (char *) &msg[1];
+ if (name_len > 0)
+ {
+ GNUNET_assert ('\0' == name[name_len -1]);
+ GNUNET_assert ((name_len - 1) == strlen(name));
+ }
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 (GNUNET_OK != GNUNET_NAMESTORE_records_deserialize(rd_len, rd_tmp, rd_count, rd))
+ {
+ GNUNET_break_op (0);
+ return;
+ }
+
/* reset values if values not contained */
if (contains_sig == GNUNET_NO)
{
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);
}
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' \n",
"RECORD_PUT_RESPONSE");
+
struct GNUNET_NAMESTORE_Handle *h = qe->nsh;
+ /* Operation done, remove */
+ GNUNET_CONTAINER_DLL_remove(h->op_head, h->op_tail, qe);
+
int res = ntohl (msg->op_result);
if (res == GNUNET_OK)
return;
}
- /* 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",
"RECORD_CREATE_RESPONSE");
+
struct GNUNET_NAMESTORE_Handle *h = qe->nsh;
- int res = ntohl (msg->op_result);
+ /* Operation done, remove */
+ GNUNET_CONTAINER_DLL_remove(h->op_head, h->op_tail, qe);
+ int res = ntohl (msg->op_result);
if (res == GNUNET_YES)
{
if (qe->cont != NULL)
}
}
- /* 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 = ntohl (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;
expire = GNUNET_TIME_absolute_ntoh(msg->expire);
name_tmp = (char *) &msg[1];
+ if (name_len > 0)
+ {
+ GNUNET_assert ('\0' == name_tmp[name_len -1]);
+ GNUNET_assert (name_len -1 == strlen(name_tmp));
+ }
rd_tmp = &name_tmp[name_len];
struct GNUNET_NAMESTORE_RecordData rd[rd_count];
- GNUNET_NAMESTORE_records_deserialize(rd_ser_len, rd_tmp, rd_count, rd);
+ if (GNUNET_OK != GNUNET_NAMESTORE_records_deserialize(rd_ser_len, rd_tmp, rd_count, rd))
+ {
+ GNUNET_break_op (0);
+ return;
+ }
if (qe->proc != NULL)
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, "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_CONTAINER_DLL_remove(ze->h->z_head, ze->h->z_tail, ze);
GNUNET_free (ze);
return;
}
while (NULL != (q = h->op_head))
{
- GNUNET_break (0);
GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, q);
GNUNET_free (q);
}
* to validate signatures received from the network.
*
* @param public_key public key of the zone
+ * @param expire block expiration
* @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
*/
int
GNUNET_NAMESTORE_verify_signature (const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *public_key,
+ const struct GNUNET_TIME_Absolute expire,
const char *name,
unsigned int rd_count,
const struct GNUNET_NAMESTORE_RecordData *rd,
char * name_tmp;
char * rd_tmp;
struct GNUNET_CRYPTO_RsaSignaturePurpose *sig_purpose;
+ struct GNUNET_TIME_AbsoluteNBO *expire_tmp;
+ struct GNUNET_TIME_AbsoluteNBO expire_nbo = GNUNET_TIME_absolute_hton(expire);
GNUNET_assert (public_key != NULL);
GNUNET_assert (name != NULL);
return GNUNET_SYSERR;
}
- sig_purpose = GNUNET_malloc(sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) + rd_ser_len + name_len);
+ sig_purpose = GNUNET_malloc(sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) + sizeof (struct GNUNET_TIME_AbsoluteNBO) + rd_ser_len + name_len);
sig_purpose->size = htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose)+ rd_ser_len + name_len);
sig_purpose->purpose = htonl (GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN);
- name_tmp = (char *) &sig_purpose[1];
+ expire_tmp = (struct GNUNET_TIME_AbsoluteNBO *) &sig_purpose[1];
+ name_tmp = (char *) &expire_tmp[1];
rd_tmp = &name_tmp[name_len];
+ memcpy (expire_tmp, &expire_nbo, sizeof (struct GNUNET_TIME_AbsoluteNBO));
memcpy (name_tmp, name, name_len);
memcpy (rd_tmp, rd_ser, rd_ser_len);
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);
* @param h handle to the namestore
* @param pkey private key of the zone
* @param name name that is being mapped (at most 255 characters long)
- * @param rd record data
+ * @param rd record data, remove specific record, NULL to remove the name and all records
* @param cont continuation to call when done
* @param cont_cls closure for cont
* @return handle to abort the request
size_t name_len = 0;
size_t key_len = 0;
uint32_t rid = 0;
+ uint16_t rd_count = 1;
GNUNET_assert (NULL != h);
GNUNET_assert (pkey_enc != NULL);
key_len = ntohs (pkey_enc->len);
- rd_ser_len = GNUNET_NAMESTORE_records_get_size(1, rd);
+ if (NULL == rd)
+ rd_count = 0;
+ else
+ rd_count = 1;
+ rd_ser_len = GNUNET_NAMESTORE_records_get_size (rd_count, rd);
char rd_ser[rd_ser_len];
- GNUNET_NAMESTORE_records_serialize(1, rd, rd_ser_len, rd_ser);
+ GNUNET_NAMESTORE_records_serialize (rd_count, rd, rd_ser_len, rd_ser);
name_len = strlen (name) + 1;
msg->gns_header.r_id = htonl (rid);
msg->name_len = htons (name_len);
msg->rd_len = htons (rd_ser_len);
- msg->rd_count = htons (1);
+ msg->rd_count = htons (rd_count);
msg->pkey_len = htons (key_len);
memcpy (pkey_tmp, pkey_enc, key_len);
memcpy (name_tmp, name, name_len);
*/
struct GNUNET_NAMESTORE_QueueEntry *
GNUNET_NAMESTORE_lookup_record (struct GNUNET_NAMESTORE_Handle *h,
- const GNUNET_HashCode *zone,
+ const struct GNUNET_CRYPTO_ShortHashCode *zone,
const char *name,
uint32_t record_type,
GNUNET_NAMESTORE_RecordProcessor proc, void *proc_cls)
*/
struct GNUNET_NAMESTORE_QueueEntry *
GNUNET_NAMESTORE_zone_to_name (struct GNUNET_NAMESTORE_Handle *h,
- const GNUNET_HashCode *zone,
- const GNUNET_HashCode *value_zone,
+ const struct GNUNET_CRYPTO_ShortHashCode *zone,
+ const struct GNUNET_CRYPTO_ShortHashCode *value_zone,
GNUNET_NAMESTORE_RecordProcessor proc, void *proc_cls)
{
struct GNUNET_NAMESTORE_QueueEntry *qe;
msg->zone = *zone;
msg->value_zone = *value_zone;
- char * z_tmp = strdup (GNUNET_h2s (zone));
+ char * z_tmp = strdup (GNUNET_short_h2s (zone));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message for zone `%s' in zone `%s'\n",
"NAMESTORE_ZONE_TO_NAME",
z_tmp,
- GNUNET_h2s (value_zone));
+ GNUNET_short_h2s (value_zone));
GNUNET_free (z_tmp);
/* transmit message */
*/
struct GNUNET_NAMESTORE_ZoneIterator *
GNUNET_NAMESTORE_zone_iteration_start (struct GNUNET_NAMESTORE_Handle *h,
- const GNUNET_HashCode *zone,
+ const struct GNUNET_CRYPTO_ShortHashCode *zone,
enum GNUNET_NAMESTORE_RecordFlags must_have_flags,
enum GNUNET_NAMESTORE_RecordFlags must_not_have_flags,
GNUNET_NAMESTORE_RecordProcessor proc,
it = GNUNET_malloc (sizeof (struct GNUNET_NAMESTORE_ZoneIterator));
it->h = h;
it->proc = proc;
- it->proc_cls = proc;
+ it->proc_cls = proc_cls;
it->op_id = rid;
if (NULL != zone)
msg->gns_header.header.size = htons (msg_size);
msg->gns_header.r_id = htonl (rid);
if (NULL != zone)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message for zone `%s'\n", "ZONE_ITERATION_START", GNUNET_short_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);
GNUNET_assert (NULL != it);
h = it->h;
+ struct GNUNET_NAMESTORE_ZoneIterator *tmp = it->h->z_head;
+
+ while (tmp != NULL)
+ {
+ if (tmp == it)
+ break;
+ tmp = tmp->next;
+ }
+ GNUNET_assert (NULL != tmp);
/* set msg_size*/
msg_size = sizeof (struct ZoneIterationNextMessage);
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);
struct PendingMessage *pe;
size_t msg_size = 0;
struct GNUNET_NAMESTORE_Handle *h = it->h;
+ struct GNUNET_NAMESTORE_ZoneIterator *tmp = it->h->z_head;
+
+ while (tmp != NULL)
+ {
+ if (tmp == it)
+ break;
+ tmp = tmp->next;
+ }
+ GNUNET_assert (NULL != tmp);
/* set msg_size*/
msg_size = sizeof (struct ZoneIterationStopMessage);
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_short_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);