[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[GNUnet-SVN] r30233 - gnunet/src/conversation gnunet/src/gns gnunet/src/
|
From: |
gnunet |
|
Subject: |
[GNUnet-SVN] r30233 - gnunet/src/conversation gnunet/src/gns gnunet/src/gnsrecord gnunet/src/include gnunet/src/namecache gnunet/src/namestore gnunet/src/pt gnunet-gtk/src/fs gnunet-gtk/src/namestore |
|
Date: |
Wed, 16 Oct 2013 22:21:27 +0200 |
Author: grothoff
Date: 2013-10-16 22:21:27 +0200 (Wed, 16 Oct 2013)
New Revision: 30233
Modified:
gnunet-gtk/src/fs/gnunet-fs-gtk.c
gnunet-gtk/src/fs/gnunet-fs-gtk_common.c
gnunet-gtk/src/fs/gnunet-fs-gtk_main-window-search.c
gnunet-gtk/src/namestore/gnunet-namestore-gtk.c
gnunet/src/conversation/conversation_api.c
gnunet/src/conversation/gnunet-conversation.c
gnunet/src/gns/gns.h
gnunet/src/gns/gns_api.c
gnunet/src/gns/gnunet-dns2gns.c
gnunet/src/gns/gnunet-gns-helper-service-w32.c
gnunet/src/gns/gnunet-gns-proxy.c
gnunet/src/gns/gnunet-gns.c
gnunet/src/gns/gnunet-service-gns.c
gnunet/src/gns/gnunet-service-gns_interceptor.c
gnunet/src/gns/gnunet-service-gns_resolver.c
gnunet/src/gns/gnunet-service-gns_resolver.h
gnunet/src/gns/gnunet-service-gns_shorten.c
gnunet/src/gns/plugin_block_gns.c
gnunet/src/gns/test_gns_proxy.c
gnunet/src/gns/test_gns_pseu_shorten.c
gnunet/src/gns/test_gns_revocation.c
gnunet/src/gns/test_gns_simple_shorten.c
gnunet/src/gns/test_gns_simple_srv_lookup.c
gnunet/src/gns/test_gns_simple_zkey_lookup.c
gnunet/src/gnsrecord/gnsrecord_crypto.c
gnunet/src/gnsrecord/gnsrecord_misc.c
gnunet/src/gnsrecord/gnsrecord_serialization.c
gnunet/src/gnsrecord/test_gnsrecord_crypto.c
gnunet/src/gnsrecord/test_gnsrecord_serialization.c
gnunet/src/include/gnunet_conversation_service.h
gnunet/src/include/gnunet_gns_service.h
gnunet/src/include/gnunet_gnsrecord_lib.h
gnunet/src/include/gnunet_namecache_plugin.h
gnunet/src/include/gnunet_namecache_service.h
gnunet/src/include/gnunet_namestore_plugin.h
gnunet/src/include/gnunet_namestore_service.h
gnunet/src/namecache/gnunet-namecache.c
gnunet/src/namecache/gnunet-service-namecache.c
gnunet/src/namecache/namecache_api.c
gnunet/src/namecache/plugin_namecache_postgres.c
gnunet/src/namecache/plugin_namecache_sqlite.c
gnunet/src/namecache/test_namecache_api_cache_block.c
gnunet/src/namestore/gnunet-namestore-fcfsd.c
gnunet/src/namestore/gnunet-namestore.c
gnunet/src/namestore/gnunet-service-namestore.c
gnunet/src/namestore/namestore_api.c
gnunet/src/namestore/namestore_api_monitor.c
gnunet/src/namestore/plugin_namestore_postgres.c
gnunet/src/namestore/plugin_namestore_sqlite.c
gnunet/src/namestore/test_namestore_api_cache_block.c
gnunet/src/namestore/test_namestore_api_lookup_public.c
gnunet/src/namestore/test_namestore_api_monitoring.c
gnunet/src/namestore/test_namestore_api_monitoring_existing.c
gnunet/src/namestore/test_namestore_api_put.c
gnunet/src/namestore/test_namestore_api_remove.c
gnunet/src/namestore/test_namestore_api_store.c
gnunet/src/namestore/test_namestore_api_store_update.c
gnunet/src/namestore/test_namestore_api_zone_iteration.c
gnunet/src/namestore/test_namestore_api_zone_iteration_specific_zone.c
gnunet/src/namestore/test_namestore_api_zone_iteration_stop.c
gnunet/src/namestore/test_namestore_api_zone_to_name.c
gnunet/src/namestore/test_plugin_namestore.c
gnunet/src/pt/test_gns_vpn.c
Log:
-another renaming fest for GNUNET_NAMESTORE_ to GNUNET_GNSRECORD_ symbols that
were moved
Modified: gnunet/src/conversation/conversation_api.c
===================================================================
--- gnunet/src/conversation/conversation_api.c 2013-10-16 20:14:02 UTC (rev
30232)
+++ gnunet/src/conversation/conversation_api.c 2013-10-16 20:21:27 UTC (rev
30233)
@@ -163,14 +163,14 @@
const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
const char *label,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
struct GNUNET_CONVERSATION_Phone *phone = cls;
char *name;
phone->qe = NULL;
if (NULL == label)
- name = GNUNET_strdup (GNUNET_NAMESTORE_pkey_to_zkey (&phone->caller_id));
+ name = GNUNET_strdup (GNUNET_GNSRECORD_pkey_to_zkey (&phone->caller_id));
else
GNUNET_asprintf (&name, "%.gnu", label);
phone->event_handler (phone->event_handler_cls,
@@ -452,13 +452,13 @@
*/
void
GNUNET_CONVERSATION_phone_get_record (struct GNUNET_CONVERSATION_Phone *phone,
- struct GNUNET_NAMESTORE_RecordData *rd)
+ struct GNUNET_GNSRECORD_Data *rd)
{
rd->data = &phone->my_record;
rd->expiration_time = 0;
rd->data_size = sizeof (struct GNUNET_CONVERSATION_PhoneRecord);
rd->record_type = GNUNET_GNSRECORD_TYPE_PHONE;
- rd->flags = GNUNET_NAMESTORE_RF_NONE;
+ rd->flags = GNUNET_GNSRECORD_RF_NONE;
}
@@ -904,7 +904,7 @@
static void
handle_gns_response (void *cls,
uint32_t rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
struct GNUNET_CONVERSATION_Call *call = cls;
uint32_t i;
Modified: gnunet/src/conversation/gnunet-conversation.c
===================================================================
--- gnunet/src/conversation/gnunet-conversation.c 2013-10-16 20:14:02 UTC
(rev 30232)
+++ gnunet/src/conversation/gnunet-conversation.c 2013-10-16 20:21:27 UTC
(rev 30233)
@@ -218,7 +218,7 @@
static void
start_phone ()
{
- struct GNUNET_NAMESTORE_RecordData rd;
+ struct GNUNET_GNSRECORD_Data rd;
if (NULL == caller_id)
{
Modified: gnunet/src/gns/gns.h
===================================================================
--- gnunet/src/gns/gns.h 2013-10-16 20:14:02 UTC (rev 30232)
+++ gnunet/src/gns/gns.h 2013-10-16 20:21:27 UTC (rev 30233)
@@ -109,7 +109,7 @@
*/
uint32_t rd_count GNUNET_PACKED;
- /* followed by rd_count GNUNET_NAMESTORE_RecordData structs*/
+ /* followed by rd_count GNUNET_GNSRECORD_Data structs*/
};
Modified: gnunet/src/gns/gns_api.c
===================================================================
--- gnunet/src/gns/gns_api.c 2013-10-16 20:14:02 UTC (rev 30232)
+++ gnunet/src/gns/gns_api.c 2013-10-16 20:21:27 UTC (rev 30233)
@@ -366,7 +366,7 @@
struct GNUNET_GNS_Handle *handle = qe->gns_handle;
struct PendingMessage *p = (struct PendingMessage *) &qe[1];
uint32_t rd_count = ntohl (msg->rd_count);
- struct GNUNET_NAMESTORE_RecordData rd[rd_count];
+ struct GNUNET_GNSRECORD_Data rd[rd_count];
size_t mlen;
if (GNUNET_YES != p->transmitted)
@@ -378,7 +378,7 @@
}
mlen = ntohs (msg->header.size);
mlen -= sizeof (struct GNUNET_GNS_ClientLookupResultMessage);
- if (GNUNET_SYSERR == GNUNET_NAMESTORE_records_deserialize (mlen,
+ if (GNUNET_SYSERR == GNUNET_GNSRECORD_records_deserialize (mlen,
(const char*)
&msg[1],
rd_count,
rd))
Modified: gnunet/src/gns/gnunet-dns2gns.c
===================================================================
--- gnunet/src/gns/gnunet-dns2gns.c 2013-10-16 20:14:02 UTC (rev 30232)
+++ gnunet/src/gns/gnunet-dns2gns.c 2013-10-16 20:21:27 UTC (rev 30233)
@@ -296,7 +296,7 @@
static void
result_processor (void *cls,
uint32_t rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
struct Request *request = cls;
struct GNUNET_DNSPARSER_Packet *packet;
@@ -316,7 +316,7 @@
//packet->flags.opcode = GNUNET_TUN_DNS_OPCODE_STATUS; // ???
for (i=0;i<rd_count;i++)
{
- // FIXME: do we need to hanlde #GNUNET_NAMESTORE_RF_SHADOW_RECORD
+ // FIXME: do we need to hanlde #GNUNET_GNSRECORD_RF_SHADOW_RECORD
// here? Or should we do this in libgnunetgns?
rec.expiration_time.abs_value_us = rd[i].expiration_time;
switch (rd[i].record_type)
Modified: gnunet/src/gns/gnunet-gns-helper-service-w32.c
===================================================================
--- gnunet/src/gns/gnunet-gns-helper-service-w32.c 2013-10-16 20:14:02 UTC
(rev 30232)
+++ gnunet/src/gns/gnunet-gns-helper-service-w32.c 2013-10-16 20:21:27 UTC
(rev 30233)
@@ -244,7 +244,7 @@
static void
process_ip_lookup_result (void* cls,
uint32_t rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
int i, j, csanum;
struct request *rq = (struct request *) cls;
Modified: gnunet/src/gns/gnunet-gns-proxy.c
===================================================================
--- gnunet/src/gns/gnunet-gns-proxy.c 2013-10-16 20:14:02 UTC (rev 30232)
+++ gnunet/src/gns/gnunet-gns-proxy.c 2013-10-16 20:21:27 UTC (rev 30233)
@@ -2208,11 +2208,11 @@
static void
handle_gns_result (void *cls,
uint32_t rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
struct Socks5Request *s5r = cls;
uint32_t i;
- const struct GNUNET_NAMESTORE_RecordData *r;
+ const struct GNUNET_GNSRECORD_Data *r;
int got_ip;
s5r->gns_lookup = NULL;
Modified: gnunet/src/gns/gnunet-gns.c
===================================================================
--- gnunet/src/gns/gnunet-gns.c 2013-10-16 20:14:02 UTC (rev 30232)
+++ gnunet/src/gns/gnunet-gns.c 2013-10-16 20:21:27 UTC (rev 30233)
@@ -138,7 +138,7 @@
*/
static void
process_lookup_result (void *cls, uint32_t rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
const char *name = cls;
uint32_t i;
Modified: gnunet/src/gns/gnunet-service-gns.c
===================================================================
--- gnunet/src/gns/gnunet-service-gns.c 2013-10-16 20:14:02 UTC (rev 30232)
+++ gnunet/src/gns/gnunet-service-gns.c 2013-10-16 20:21:27 UTC (rev 30233)
@@ -321,14 +321,14 @@
const struct GNUNET_CRYPTO_EcdsaPrivateKey *key,
const char *name,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
- struct GNUNET_NAMESTORE_Block *block;
+ struct GNUNET_GNSRECORD_Block *block;
struct GNUNET_HashCode query;
struct GNUNET_TIME_Absolute expire;
struct GNUNET_TIME_Absolute now;
size_t block_size;
- struct GNUNET_NAMESTORE_RecordData rd_public[rd_count];
+ struct GNUNET_GNSRECORD_Data rd_public[rd_count];
unsigned int rd_public_count;
unsigned int i;
@@ -387,13 +387,13 @@
rd_public_count = 0;
now = GNUNET_TIME_absolute_get ();
for (i=0;i<rd_count;i++)
- if (0 == (rd[i].flags & (GNUNET_NAMESTORE_RF_PRIVATE |
- GNUNET_NAMESTORE_RF_PENDING)))
+ if (0 == (rd[i].flags & (GNUNET_GNSRECORD_RF_PRIVATE |
+ GNUNET_GNSRECORD_RF_PENDING)))
{
rd_public[rd_public_count] = rd[i];
- if (0 != (rd[i].flags & GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION))
+ if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
{
- rd_public[rd_public_count].flags &=
~GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION;
+ rd_public[rd_public_count].flags &=
~GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
rd_public[rd_public_count].expiration_time += now.abs_value_us;
}
rd_public_count++;
@@ -406,9 +406,9 @@
NULL);
return;
}
- expire = GNUNET_NAMESTORE_record_get_expiration_time (rd_public_count,
+ expire = GNUNET_GNSRECORD_record_get_expiration_time (rd_public_count,
rd_public);
- block = GNUNET_NAMESTORE_block_create (key,
+ block = GNUNET_GNSRECORD_block_create (key,
expire,
name,
rd_public,
@@ -416,7 +416,7 @@
block_size = ntohl (block->purpose.size)
+ sizeof (struct GNUNET_CRYPTO_EcdsaSignature)
+ sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey);
- GNUNET_NAMESTORE_query_from_private_key (key,
+ GNUNET_GNSRECORD_query_from_private_key (key,
name,
&query);
@@ -475,7 +475,7 @@
static void
send_lookup_response (void* cls,
uint32_t rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
struct ClientLookupHandle *clh = cls;
struct GNUNET_GNS_ClientLookupResultMessage *rmsg;
@@ -486,13 +486,13 @@
"LOOKUP_RESULT",
rd_count);
- len = GNUNET_NAMESTORE_records_get_size (rd_count, rd);
+ len = GNUNET_GNSRECORD_records_get_size (rd_count, rd);
rmsg = GNUNET_malloc (len + sizeof (struct
GNUNET_GNS_ClientLookupResultMessage));
rmsg->header.type = htons (GNUNET_MESSAGE_TYPE_GNS_LOOKUP_RESULT);
rmsg->header.size = htons (len + sizeof(struct
GNUNET_GNS_ClientLookupResultMessage));
rmsg->id = clh->request_id;
rmsg->rd_count = htonl (rd_count);
- GNUNET_NAMESTORE_records_serialize (rd_count, rd, len,
+ GNUNET_GNSRECORD_records_serialize (rd_count, rd, len,
(char*) &rmsg[1]);
GNUNET_SERVER_notification_context_unicast (nc,
clh->client,
Modified: gnunet/src/gns/gnunet-service-gns_interceptor.c
===================================================================
--- gnunet/src/gns/gnunet-service-gns_interceptor.c 2013-10-16 20:14:02 UTC
(rev 30232)
+++ gnunet/src/gns/gnunet-service-gns_interceptor.c 2013-10-16 20:21:27 UTC
(rev 30233)
@@ -97,7 +97,7 @@
*/
static void
reply_to_dns (void *cls, uint32_t rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
struct InterceptLookupHandle *ilh = cls;
struct GNUNET_DNSPARSER_Packet *packet = ilh->packet;
@@ -125,7 +125,7 @@
packet->answers = answer_records;
packet->additional_records = additional_records;
- /* FIXME: need to handle #GNUNET_NAMESTORE_RF_SHADOW_RECORD option
+ /* FIXME: need to handle #GNUNET_GNSRECORD_RF_SHADOW_RECORD option
(by ignoring records where this flag is set if there is any
other record of that type in the result set) */
for (i=0; i < rd_count; i++)
@@ -183,7 +183,7 @@
answer_records[i - skip_answers].data.raw.data = (char*)rd[i].data;
break;
}
- GNUNET_break (0 == (rd[i - skip_answers].flags &
GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION));
+ GNUNET_break (0 == (rd[i - skip_answers].flags &
GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION));
answer_records[i - skip_answers].expiration_time.abs_value_us =
rd[i].expiration_time;
answer_records[i - skip_answers].dns_traffic_class =
GNUNET_TUN_DNS_CLASS_INTERNET;
}
@@ -240,7 +240,7 @@
additional_records[i - skip_additional].data.raw.data =
(char*)rd[i].data;
break;
}
- GNUNET_break (0 == (rd[i - skip_additional].flags &
GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION));
+ GNUNET_break (0 == (rd[i - skip_additional].flags &
GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION));
additional_records[i - skip_additional].expiration_time.abs_value_us =
rd[i].expiration_time;
additional_records[i - skip_additional].dns_traffic_class =
GNUNET_TUN_DNS_CLASS_INTERNET;
}
Modified: gnunet/src/gns/gnunet-service-gns_resolver.c
===================================================================
--- gnunet/src/gns/gnunet-service-gns_resolver.c 2013-10-16 20:14:02 UTC
(rev 30232)
+++ gnunet/src/gns/gnunet-service-gns_resolver.c 2013-10-16 20:21:27 UTC
(rev 30233)
@@ -504,7 +504,7 @@
"%.*s.%s",
(int) (s_len - 2),
name,
- GNUNET_NAMESTORE_pkey_to_zkey
(&rh->ac_tail->authority_info.gns_authority));
+ GNUNET_GNSRECORD_pkey_to_zkey
(&rh->ac_tail->authority_info.gns_authority));
GNUNET_free (name);
return ret;
}
@@ -598,7 +598,7 @@
for (pos = rh->dns_result_head; NULL != pos; pos = pos->next)
n++;
{
- struct GNUNET_NAMESTORE_RecordData rd[n];
+ struct GNUNET_GNSRECORD_Data rd[n];
i = 0;
for (pos = rh->dns_result_head; NULL != pos; pos = pos->next)
@@ -608,12 +608,12 @@
rd[i].record_type = pos->record_type;
if (0 == pos->expiration_time)
{
- rd[i].flags = GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION;
+ rd[i].flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
rd[i].expiration_time = 0;
}
else
{
- rd[i].flags = GNUNET_NAMESTORE_RF_NONE;
+ rd[i].flags = GNUNET_GNSRECORD_RF_NONE;
rd[i].expiration_time = pos->expiration_time;
}
i++;
@@ -785,7 +785,7 @@
/* convert from (parsed) DNS to (binary) GNS format! */
rd_count = p->num_answers + p->num_authority_records +
p->num_additional_records;
{
- struct GNUNET_NAMESTORE_RecordData rd[rd_count];
+ struct GNUNET_GNSRECORD_Data rd[rd_count];
unsigned int skip;
char buf[UINT16_MAX];
size_t buf_off;
@@ -1064,7 +1064,7 @@
static void
handle_gns_resolution_result (void *cls,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd);
+ const struct GNUNET_GNSRECORD_Data *rd);
/**
@@ -1088,13 +1088,13 @@
{
struct VpnContext *vpn_ctx = cls;
struct GNS_ResolverHandle *rh = vpn_ctx->rh;
- struct GNUNET_NAMESTORE_RecordData rd[vpn_ctx->rd_count];
+ struct GNUNET_GNSRECORD_Data rd[vpn_ctx->rd_count];
unsigned int i;
vpn_ctx->vpn_request = NULL;
rh->vpn_ctx = NULL;
GNUNET_assert (GNUNET_OK ==
- GNUNET_NAMESTORE_records_deserialize (vpn_ctx->rd_data_size,
+ GNUNET_GNSRECORD_records_deserialize (vpn_ctx->rd_data_size,
vpn_ctx->rd_data,
vpn_ctx->rd_count,
rd));
@@ -1143,7 +1143,7 @@
static void
handle_gns_resolution_result (void *cls,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
struct GNS_ResolverHandle *rh = cls;
struct AuthorityChain *ac;
@@ -1163,13 +1163,13 @@
size_t scratch_off;
size_t scratch_start;
size_t off;
- struct GNUNET_NAMESTORE_RecordData rd_new[rd_count];
+ struct GNUNET_GNSRECORD_Data rd_new[rd_count];
unsigned int rd_off;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Resolution succeeded for `%s' in zone %s, got %u records\n",
rh->ac_tail->label,
- GNUNET_NAMESTORE_z2s (&rh->ac_tail->authority_info.gns_authority),
+ GNUNET_GNSRECORD_z2s (&rh->ac_tail->authority_info.gns_authority),
rd_count);
if (0 == rh->name_resolution_pos)
{
@@ -1230,10 +1230,10 @@
vpn_ctx = GNUNET_new (struct VpnContext);
rh->vpn_ctx = vpn_ctx;
vpn_ctx->rh = rh;
- vpn_ctx->rd_data_size = GNUNET_NAMESTORE_records_get_size (rd_count,
+ vpn_ctx->rd_data_size = GNUNET_GNSRECORD_records_get_size (rd_count,
rd);
vpn_ctx->rd_data = GNUNET_malloc (vpn_ctx->rd_data_size);
- (void) GNUNET_NAMESTORE_records_serialize (rd_count,
+ (void) GNUNET_GNSRECORD_records_serialize (rd_count,
rd,
vpn_ctx->rd_data_size,
vpn_ctx->rd_data);
@@ -1720,7 +1720,7 @@
{
struct GNS_ResolverHandle *rh = cls;
struct AuthorityChain *ac = rh->ac_tail;
- const struct GNUNET_NAMESTORE_Block *block;
+ const struct GNUNET_GNSRECORD_Block *block;
struct CacheOps *co;
GNUNET_DHT_get_stop (rh->get_handle);
@@ -1729,7 +1729,7 @@
rh->dht_heap_node = NULL;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Handling response from the DHT\n");
- if (size < sizeof (struct GNUNET_NAMESTORE_Block))
+ if (size < sizeof (struct GNUNET_GNSRECORD_Block))
{
/* how did this pass DHT block validation!? */
GNUNET_break (0);
@@ -1750,7 +1750,7 @@
return;
}
if (GNUNET_OK !=
- GNUNET_NAMESTORE_block_decrypt (block,
+ GNUNET_GNSRECORD_block_decrypt (block,
&ac->authority_info.gns_authority,
ac->label,
&handle_gns_resolution_result,
@@ -1783,7 +1783,7 @@
*/
static void
handle_namestore_block_response (void *cls,
- const struct GNUNET_NAMESTORE_Block *block)
+ const struct GNUNET_GNSRECORD_Block *block)
{
struct GNS_ResolverHandle *rh = cls;
struct GNS_ResolverHandle *rx;
@@ -1792,7 +1792,7 @@
const struct GNUNET_CRYPTO_EcdsaPublicKey *auth =
&ac->authority_info.gns_authority;
struct GNUNET_HashCode query;
- GNUNET_NAMESTORE_query_from_public_key (auth,
+ GNUNET_GNSRECORD_query_from_public_key (auth,
label,
&query);
GNUNET_assert (NULL != rh->namestore_qe);
@@ -1805,7 +1805,7 @@
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Starting DHT lookup for `%s' in zone %s\n",
ac->label,
- GNUNET_NAMESTORE_z2s (&ac->authority_info.gns_authority));
+ GNUNET_GNSRECORD_z2s (&ac->authority_info.gns_authority));
GNUNET_assert (NULL == rh->get_handle);
rh->get_handle = GNUNET_DHT_get_start (dht_handle,
GNUNET_BLOCK_TYPE_GNS_NAMERECORD,
@@ -1834,7 +1834,7 @@
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Resolution failed for `%s' in zone %s (DHT lookup not
permitted by configuration)\n",
ac->label,
- GNUNET_NAMESTORE_z2s (&ac->authority_info.gns_authority));
+ GNUNET_GNSRECORD_z2s (&ac->authority_info.gns_authority));
rh->proc (rh->proc_cls, 0, NULL);
GNS_resolver_lookup_cancel (rh);
return;
@@ -1842,7 +1842,7 @@
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Decrypting block from the namestore\n");
if (GNUNET_OK !=
- GNUNET_NAMESTORE_block_decrypt (block,
+ GNUNET_GNSRECORD_block_decrypt (block,
auth,
label,
&handle_gns_resolution_result,
@@ -1870,8 +1870,8 @@
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Starting GNS resolution for `%s' in zone %s\n",
ac->label,
- GNUNET_NAMESTORE_z2s (&ac->authority_info.gns_authority));
- GNUNET_NAMESTORE_query_from_public_key (&ac->authority_info.gns_authority,
+ GNUNET_GNSRECORD_z2s (&ac->authority_info.gns_authority));
+ GNUNET_GNSRECORD_query_from_public_key (&ac->authority_info.gns_authority,
ac->label,
&query);
rh->namestore_qe = GNUNET_NAMESTORE_lookup_block (namestore_handle,
Modified: gnunet/src/gns/gnunet-service-gns_resolver.h
===================================================================
--- gnunet/src/gns/gnunet-service-gns_resolver.h 2013-10-16 20:14:02 UTC
(rev 30232)
+++ gnunet/src/gns/gnunet-service-gns_resolver.h 2013-10-16 20:21:27 UTC
(rev 30233)
@@ -66,7 +66,7 @@
*/
typedef void (*GNS_ResultProcessor)(void *cls,
uint32_t rd_count,
- const struct GNUNET_NAMESTORE_RecordData
*rd);
+ const struct GNUNET_GNSRECORD_Data *rd);
/**
Modified: gnunet/src/gns/gnunet-service-gns_shorten.c
===================================================================
--- gnunet/src/gns/gnunet-service-gns_shorten.c 2013-10-16 20:14:02 UTC (rev
30232)
+++ gnunet/src/gns/gnunet-service-gns_shorten.c 2013-10-16 20:21:27 UTC (rev
30233)
@@ -181,7 +181,7 @@
static void
process_pseu_lookup_ns (void *cls,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd);
+ const struct GNUNET_GNSRECORD_Data *rd);
/**
@@ -193,7 +193,7 @@
*/
static void
process_pseu_block_ns (void *cls,
- const struct GNUNET_NAMESTORE_Block *block)
+ const struct GNUNET_GNSRECORD_Block *block)
{
struct GetPseuAuthorityHandle *gph = cls;
struct GNUNET_CRYPTO_EcdsaPublicKey pub;
@@ -207,7 +207,7 @@
GNUNET_CRYPTO_ecdsa_key_get_public (&gph->shorten_zone_key,
&pub);
if (GNUNET_OK !=
- GNUNET_NAMESTORE_block_decrypt (block,
+ GNUNET_GNSRECORD_block_decrypt (block,
&pub,
gph->current_label,
&process_pseu_lookup_ns,
@@ -237,7 +237,7 @@
&pub);
GNUNET_free_non_null (gph->current_label);
gph->current_label = GNUNET_strdup (label);
- GNUNET_NAMESTORE_query_from_public_key (&pub,
+ GNUNET_GNSRECORD_query_from_public_key (&pub,
label,
&query);
gph->namestore_task = GNUNET_NAMESTORE_lookup_block (namestore_handle,
@@ -258,10 +258,10 @@
static void
process_pseu_lookup_ns (void *cls,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
struct GetPseuAuthorityHandle *gph = cls;
- struct GNUNET_NAMESTORE_RecordData new_pkey;
+ struct GNUNET_GNSRECORD_Data new_pkey;
gph->namestore_task = NULL;
if (rd_count > 0)
@@ -285,15 +285,15 @@
/* name is available */
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Shortening `%s' to `%s'\n",
- GNUNET_NAMESTORE_z2s (&gph->target_zone),
+ GNUNET_GNSRECORD_z2s (&gph->target_zone),
gph->current_label);
new_pkey.expiration_time = UINT64_MAX;
new_pkey.data_size = sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey);
new_pkey.data = &gph->target_zone;
new_pkey.record_type = GNUNET_GNSRECORD_TYPE_PKEY;
- new_pkey.flags = GNUNET_NAMESTORE_RF_NONE
- | GNUNET_NAMESTORE_RF_PRIVATE
- | GNUNET_NAMESTORE_RF_PENDING;
+ new_pkey.flags = GNUNET_GNSRECORD_RF_NONE
+ | GNUNET_GNSRECORD_RF_PRIVATE
+ | GNUNET_GNSRECORD_RF_PENDING;
gph->namestore_task
= GNUNET_NAMESTORE_records_store (namestore_handle,
&gph->shorten_zone_key,
@@ -358,7 +358,7 @@
static void
process_auth_records (void *cls,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
struct GetPseuAuthorityHandle *gph = cls;
unsigned int i;
@@ -412,7 +412,7 @@
const void *data)
{
struct GetPseuAuthorityHandle *gph = cls;
- const struct GNUNET_NAMESTORE_Block *block;
+ const struct GNUNET_GNSRECORD_Block *block;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Got DHT result for PSEU request\n");
@@ -428,7 +428,7 @@
process_pseu_result (gph, NULL);
return;
}
- if (size < sizeof (struct GNUNET_NAMESTORE_Block))
+ if (size < sizeof (struct GNUNET_GNSRECORD_Block))
{
/* how did this pass DHT block validation!? */
GNUNET_break (0);
@@ -447,7 +447,7 @@
return;
}
if (GNUNET_OK !=
- GNUNET_NAMESTORE_block_decrypt (block,
+ GNUNET_GNSRECORD_block_decrypt (block,
&gph->target_zone,
GNUNET_GNS_TLD_PLUS,
&process_auth_records,
@@ -476,7 +476,7 @@
const struct GNUNET_CRYPTO_EcdsaPrivateKey
*zone_key,
const char *name,
unsigned int rd_len,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
struct GetPseuAuthorityHandle* gph = cls;
struct GNUNET_HashCode lookup_key;
@@ -492,7 +492,7 @@
return;
}
/* record does not yet exist, go into DHT to find PSEU record */
- GNUNET_NAMESTORE_query_from_public_key (&gph->target_zone,
+ GNUNET_GNSRECORD_query_from_public_key (&gph->target_zone,
GNUNET_GNS_TLD_PLUS,
&lookup_key);
gph->timeout_task = GNUNET_SCHEDULER_add_delayed (DHT_LOOKUP_TIMEOUT,
@@ -533,7 +533,7 @@
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Starting shortening process for `%s' with old label `%s'\n",
- GNUNET_NAMESTORE_z2s (pub),
+ GNUNET_GNSRECORD_z2s (pub),
original_label);
gph = GNUNET_new (struct GetPseuAuthorityHandle);
gph->shorten_zone_key = *shorten_zone;
Modified: gnunet/src/gns/plugin_block_gns.c
===================================================================
--- gnunet/src/gns/plugin_block_gns.c 2013-10-16 20:14:02 UTC (rev 30232)
+++ gnunet/src/gns/plugin_block_gns.c 2013-10-16 20:21:27 UTC (rev 30233)
@@ -61,7 +61,7 @@
size_t xquery_size, const void *reply_block,
size_t reply_block_size)
{
- const struct GNUNET_NAMESTORE_Block *block;
+ const struct GNUNET_GNSRECORD_Block *block;
struct GNUNET_HashCode h;
struct GNUNET_HashCode chash;
struct GNUNET_HashCode mhash;
@@ -79,7 +79,7 @@
}
/* this is a reply */
- if (reply_block_size < sizeof (struct GNUNET_NAMESTORE_Block))
+ if (reply_block_size < sizeof (struct GNUNET_GNSRECORD_Block))
{
GNUNET_break_op (0);
return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
@@ -100,7 +100,7 @@
return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
}
if (GNUNET_OK !=
- GNUNET_NAMESTORE_block_verify (block))
+ GNUNET_GNSRECORD_block_verify (block))
{
GNUNET_break_op (0);
return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
@@ -140,11 +140,11 @@
const void *reply_block, size_t reply_block_size,
struct GNUNET_HashCode *key)
{
- const struct GNUNET_NAMESTORE_Block *block;
+ const struct GNUNET_GNSRECORD_Block *block;
if (type != GNUNET_BLOCK_TYPE_GNS_NAMERECORD)
return GNUNET_SYSERR;
- if (reply_block_size < sizeof (struct GNUNET_NAMESTORE_Block))
+ if (reply_block_size < sizeof (struct GNUNET_GNSRECORD_Block))
{
GNUNET_break_op (0);
return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
Modified: gnunet/src/gns/test_gns_proxy.c
===================================================================
--- gnunet/src/gns/test_gns_proxy.c 2013-10-16 20:14:02 UTC (rev 30232)
+++ gnunet/src/gns/test_gns_proxy.c 2013-10-16 20:21:27 UTC (rev 30233)
@@ -365,7 +365,7 @@
{
enum MHD_FLAG flags;
struct GNUNET_CRYPTO_EcdsaPrivateKey *host_key;
- struct GNUNET_NAMESTORE_RecordData rd;
+ struct GNUNET_GNSRECORD_Data rd;
char *zone_keyfile;
namestore = GNUNET_NAMESTORE_connect (cfg);
Modified: gnunet/src/gns/test_gns_pseu_shorten.c
===================================================================
--- gnunet/src/gns/test_gns_pseu_shorten.c 2013-10-16 20:14:02 UTC (rev
30232)
+++ gnunet/src/gns/test_gns_pseu_shorten.c 2013-10-16 20:21:27 UTC (rev
30233)
@@ -181,7 +181,7 @@
static void
on_lookup_result (void *cls, uint32_t rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
struct in_addr a;
int i;
@@ -266,9 +266,9 @@
uint32_t rd_payload_length;
char* nrb_data = NULL;
struct GNUNET_CRYPTO_EcdsaSignature *sig;
- struct GNUNET_NAMESTORE_RecordData rd;
+ struct GNUNET_GNSRECORD_Data rd;
- memset (&rd, 0, sizeof (struct GNUNET_NAMESTORE_RecordData));
+ memset (&rd, 0, sizeof (struct GNUNET_GNSRECORD_Data));
rd.expiration_time = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
rd.data_size = strlen(TEST_PSEU_ALICE)+1;
rd.data = TEST_PSEU_ALICE;
@@ -288,7 +288,7 @@
1,
&rd,
sig));
- rd_payload_length = GNUNET_NAMESTORE_records_get_size (1, &rd);
+ rd_payload_length = GNUNET_GNSRECORD_records_get_size (1, &rd);
nrb = GNUNET_malloc(rd_payload_length + strlen(GNUNET_GNS_MASTERZONE_STR) + 1
+ sizeof(struct GNSNameRecordBlock));
nrb->signature = *sig;
@@ -299,7 +299,7 @@
nrb_data = (char*)&nrb[1];
nrb_data += strlen(GNUNET_GNS_MASTERZONE_STR) + 1;
- if (-1 == GNUNET_NAMESTORE_records_serialize (1,
+ if (-1 == GNUNET_GNSRECORD_records_serialize (1,
&rd,
rd_payload_length,
nrb_data))
@@ -354,7 +354,7 @@
uint32_t rd_payload_length;
char* nrb_data = NULL;
struct GNUNET_CRYPTO_EcdsaSignature *sig;
- struct GNUNET_NAMESTORE_RecordData rd;
+ struct GNUNET_GNSRECORD_Data rd;
char* ip = TEST_IP;
struct in_addr *web = GNUNET_malloc(sizeof(struct in_addr));
@@ -363,7 +363,7 @@
rd.data_size = sizeof(struct in_addr);
rd.data = web;
rd.record_type = GNUNET_DNSPARSER_TYPE_A;
- rd.flags = GNUNET_NAMESTORE_RF_NONE;
+ rd.flags = GNUNET_GNSRECORD_RF_NONE;
sig = GNUNET_NAMESTORE_create_signature(alice_key,
GNUNET_TIME_UNIT_FOREVER_ABS,
@@ -376,7 +376,7 @@
1,
&rd,
sig));
- rd_payload_length = GNUNET_NAMESTORE_records_get_size (1, &rd);
+ rd_payload_length = GNUNET_GNSRECORD_records_get_size (1, &rd);
nrb = GNUNET_malloc(rd_payload_length + strlen(TEST_RECORD_NAME) + 1
+ sizeof(struct GNSNameRecordBlock));
nrb->signature = *sig;
@@ -387,7 +387,7 @@
nrb_data = (char*)&nrb[1];
nrb_data += strlen(TEST_RECORD_NAME) + 1;
- if (-1 == GNUNET_NAMESTORE_records_serialize (1,
+ if (-1 == GNUNET_GNSRECORD_records_serialize (1,
&rd,
rd_payload_length,
nrb_data))
@@ -442,13 +442,13 @@
uint32_t rd_payload_length;
char* nrb_data = NULL;
struct GNUNET_CRYPTO_EcdsaSignature *sig;
- struct GNUNET_NAMESTORE_RecordData rd;
+ struct GNUNET_GNSRECORD_Data rd;
rd.expiration_time = UINT64_MAX;
rd.data_size = sizeof(struct GNUNET_CRYPTO_ShortHashCode);
rd.data = &alice_hash;
rd.record_type = GNUNET_GNSRECORD_TYPE_PKEY;
- rd.flags = GNUNET_NAMESTORE_RF_NONE;
+ rd.flags = GNUNET_GNSRECORD_RF_NONE;
sig = GNUNET_NAMESTORE_create_signature (bob_key,
GNUNET_TIME_UNIT_FOREVER_ABS,
@@ -456,7 +456,7 @@
&rd,
1);
- rd_payload_length = GNUNET_NAMESTORE_records_get_size (1, &rd);
+ rd_payload_length = GNUNET_GNSRECORD_records_get_size (1, &rd);
nrb = GNUNET_malloc(rd_payload_length + strlen(TEST_AUTHORITY_ALICE) + 1
+ sizeof(struct GNSNameRecordBlock));
nrb->signature = *sig;
@@ -467,7 +467,7 @@
nrb_data = (char*)&nrb[1];
nrb_data += strlen(TEST_AUTHORITY_ALICE) + 1;
- if (-1 == GNUNET_NAMESTORE_records_serialize (1,
+ if (-1 == GNUNET_GNSRECORD_records_serialize (1,
&rd,
rd_payload_length,
nrb_data))
@@ -514,12 +514,12 @@
static void
fin_init_zone (void *cls, int32_t success, const char *emsg)
{
- struct GNUNET_NAMESTORE_RecordData rd;
+ struct GNUNET_GNSRECORD_Data rd;
rd.expiration_time = UINT64_MAX;
rd.data_size = sizeof(struct GNUNET_CRYPTO_ShortHashCode);
rd.data = &bob_hash;
rd.record_type = GNUNET_GNSRECORD_TYPE_PKEY;
- rd.flags = GNUNET_NAMESTORE_RF_NONE;
+ rd.flags = GNUNET_GNSRECORD_RF_NONE;
GNUNET_NAMESTORE_record_put_by_authority (namestore_handle,
our_key,
@@ -534,13 +534,13 @@
cont_init_zone (void *cls, int32_t success, const char *emsg)
{
- struct GNUNET_NAMESTORE_RecordData rd;
+ struct GNUNET_GNSRECORD_Data rd;
rd.expiration_time = UINT64_MAX;
rd.data_size = sizeof(struct GNUNET_CRYPTO_ShortHashCode);
rd.data = &short_zone;
rd.record_type = GNUNET_GNSRECORD_TYPE_PKEY;
- rd.flags = GNUNET_NAMESTORE_RF_NONE;
+ rd.flags = GNUNET_GNSRECORD_RF_NONE;
GNUNET_NAMESTORE_record_put_by_authority (namestore_handle,
priv_key,
@@ -559,7 +559,7 @@
char *private_keyfile;
char *shorten_keyfile;
char *our_keyfile;
- struct GNUNET_NAMESTORE_RecordData rd;
+ struct GNUNET_GNSRECORD_Data rd;
cfg = ccfg;
die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
@@ -641,7 +641,7 @@
rd.data_size = sizeof(struct GNUNET_CRYPTO_ShortHashCode);
rd.data = &priv_zone;
rd.record_type = GNUNET_GNSRECORD_TYPE_PKEY;
- rd.flags = GNUNET_NAMESTORE_RF_NONE;
+ rd.flags = GNUNET_GNSRECORD_RF_NONE;
GNUNET_NAMESTORE_record_put_by_authority (namestore_handle,
our_key,
Modified: gnunet/src/gns/test_gns_revocation.c
===================================================================
--- gnunet/src/gns/test_gns_revocation.c 2013-10-16 20:14:02 UTC (rev
30232)
+++ gnunet/src/gns/test_gns_revocation.c 2013-10-16 20:21:27 UTC (rev
30233)
@@ -104,7 +104,7 @@
static void
on_lookup_result(void *cls, uint32_t rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
struct in_addr a;
int i;
@@ -216,7 +216,7 @@
GNUNET_CRYPTO_ecdsa_key_get_public (alice_key, &alice_pkey);
GNUNET_CRYPTO_ecdsa_key_get_public (bob_key, &bob_pkey);
- struct GNUNET_NAMESTORE_RecordData rd;
+ struct GNUNET_GNSRECORD_Data rd;
char* ip = TEST_IP;
struct in_addr *web = GNUNET_malloc(sizeof(struct in_addr));
rd.expiration_time = UINT64_MAX;
@@ -227,7 +227,7 @@
rd.data_size = sizeof(struct GNUNET_CRYPTO_ShortHashCode);
rd.data = &bob_hash;
rd.record_type = GNUNET_GNSRECORD_TYPE_PKEY;
- rd.flags = GNUNET_NAMESTORE_RF_NONE;
+ rd.flags = GNUNET_GNSRECORD_RF_NONE;
GNUNET_NAMESTORE_record_put_by_authority (namestore_handle,
alice_key,
Modified: gnunet/src/gns/test_gns_simple_shorten.c
===================================================================
--- gnunet/src/gns/test_gns_simple_shorten.c 2013-10-16 20:14:02 UTC (rev
30232)
+++ gnunet/src/gns/test_gns_simple_shorten.c 2013-10-16 20:21:27 UTC (rev
30233)
@@ -246,7 +246,7 @@
GNUNET_CRYPTO_short_hash(&priv_pkey, sizeof(priv_pkey), &priv_zone);
GNUNET_CRYPTO_short_hash(&short_pkey, sizeof(short_pkey), &short_zone);
- struct GNUNET_NAMESTORE_RecordData rd;
+ struct GNUNET_GNSRECORD_Data rd;
char* ip = TEST_IP;
struct in_addr *web = GNUNET_malloc(sizeof(struct in_addr));
rd.expiration_time = UINT64_MAX;
@@ -257,7 +257,7 @@
rd.data_size = sizeof(struct GNUNET_CRYPTO_ShortHashCode);
rd.data = &bob_hash;
rd.record_type = GNUNET_GNSRECORD_TYPE_PKEY;
- rd.flags = GNUNET_NAMESTORE_RF_NONE;
+ rd.flags = GNUNET_GNSRECORD_RF_NONE;
/* put bob into our zone */
GNUNET_NAMESTORE_record_put_by_authority (namestore_handle,
Modified: gnunet/src/gns/test_gns_simple_srv_lookup.c
===================================================================
--- gnunet/src/gns/test_gns_simple_srv_lookup.c 2013-10-16 20:14:02 UTC (rev
30232)
+++ gnunet/src/gns/test_gns_simple_srv_lookup.c 2013-10-16 20:21:27 UTC (rev
30233)
@@ -104,7 +104,7 @@
static void
on_lookup_result(void *cls, uint32_t rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
int i;
uint16_t *srv_data;
@@ -219,7 +219,7 @@
GNUNET_CRYPTO_ecdsa_key_get_public (alice_key, &alice_pkey);
GNUNET_CRYPTO_ecdsa_key_get_public (bob_key, &bob_pkey);
- struct GNUNET_NAMESTORE_RecordData rd;
+ struct GNUNET_GNSRECORD_Data rd;
char* ip = TEST_IP;
struct in_addr *sipserver = GNUNET_malloc (sizeof (struct in_addr));
srv_data = GNUNET_malloc (sizeof (struct GNUNET_TUN_DnsSrvRecord) + strlen
(TEST_SRV_NAME) + 1);
@@ -235,7 +235,7 @@
rd.data_size = sizeof(struct GNUNET_CRYPTO_ShortHashCode);
rd.data = &bob_hash;
rd.record_type = GNUNET_GNSRECORD_TYPE_PKEY;
- rd.flags = GNUNET_NAMESTORE_RF_NONE;
+ rd.flags = GNUNET_GNSRECORD_RF_NONE;
GNUNET_NAMESTORE_record_put_by_authority (namestore_handle,
alice_key,
Modified: gnunet/src/gns/test_gns_simple_zkey_lookup.c
===================================================================
--- gnunet/src/gns/test_gns_simple_zkey_lookup.c 2013-10-16 20:14:02 UTC
(rev 30232)
+++ gnunet/src/gns/test_gns_simple_zkey_lookup.c 2013-10-16 20:21:27 UTC
(rev 30233)
@@ -105,7 +105,7 @@
static void
on_lookup_result(void *cls, uint32_t rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
struct in_addr a;
int i;
@@ -233,7 +233,7 @@
GNUNET_CRYPTO_ecdsa_key_get_public (alice_key, &alice_pkey);
GNUNET_CRYPTO_ecdsa_key_get_public (bob_key, &bob_pkey);
- struct GNUNET_NAMESTORE_RecordData rd;
+ struct GNUNET_GNSRECORD_Data rd;
char* ip = TEST_IP;
struct in_addr *web = GNUNET_malloc(sizeof(struct in_addr));
rd.expiration_time = UINT64_MAX;
@@ -244,7 +244,7 @@
rd.data_size = sizeof(struct GNUNET_CRYPTO_ShortHashCode);
rd.data = &bob_hash;
rd.record_type = GNUNET_GNSRECORD_TYPE_PKEY;
- rd.flags = GNUNET_NAMESTORE_RF_NONE;
+ rd.flags = GNUNET_GNSRECORD_RF_NONE;
GNUNET_NAMESTORE_record_put_by_authority (namestore_handle,
alice_key,
Modified: gnunet/src/gnsrecord/gnsrecord_crypto.c
===================================================================
--- gnunet/src/gnsrecord/gnsrecord_crypto.c 2013-10-16 20:14:02 UTC (rev
30232)
+++ gnunet/src/gnsrecord/gnsrecord_crypto.c 2013-10-16 20:21:27 UTC (rev
30233)
@@ -78,30 +78,30 @@
* @param rd_count number of records
* @return NULL on error (block too large)
*/
-struct GNUNET_NAMESTORE_Block *
-GNUNET_NAMESTORE_block_create (const struct GNUNET_CRYPTO_EcdsaPrivateKey *key,
+struct GNUNET_GNSRECORD_Block *
+GNUNET_GNSRECORD_block_create (const struct GNUNET_CRYPTO_EcdsaPrivateKey *key,
struct GNUNET_TIME_Absolute expire,
const char *label,
- const struct GNUNET_NAMESTORE_RecordData *rd,
+ const struct GNUNET_GNSRECORD_Data *rd,
unsigned int rd_count)
{
- size_t payload_len = GNUNET_NAMESTORE_records_get_size (rd_count, rd);
+ size_t payload_len = GNUNET_GNSRECORD_records_get_size (rd_count, rd);
char payload[sizeof (uint32_t) + payload_len];
- struct GNUNET_NAMESTORE_Block *block;
+ struct GNUNET_GNSRECORD_Block *block;
struct GNUNET_CRYPTO_EcdsaPublicKey pkey;
struct GNUNET_CRYPTO_EcdsaPrivateKey *dkey;
struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
struct GNUNET_CRYPTO_SymmetricSessionKey skey;
uint32_t rd_count_nbo;
- if (payload_len > GNUNET_NAMESTORE_MAX_VALUE_SIZE)
+ if (payload_len > GNUNET_GNSRECORD_MAX_BLOCK_SIZE)
return NULL;
rd_count_nbo = htonl (rd_count);
memcpy (payload, &rd_count_nbo, sizeof (uint32_t));
GNUNET_assert (payload_len ==
- GNUNET_NAMESTORE_records_serialize (rd_count, rd,
+ GNUNET_GNSRECORD_records_serialize (rd_count, rd,
payload_len,
&payload[sizeof (uint32_t)]));
- block = GNUNET_malloc (sizeof (struct GNUNET_NAMESTORE_Block) +
+ block = GNUNET_malloc (sizeof (struct GNUNET_GNSRECORD_Block) +
sizeof (uint32_t) + payload_len);
block->purpose.size = htonl (sizeof (uint32_t) + payload_len +
sizeof (struct
GNUNET_CRYPTO_EccSignaturePurpose) +
@@ -143,7 +143,7 @@
* @return #GNUNET_OK if the signature is valid
*/
int
-GNUNET_NAMESTORE_block_verify (const struct GNUNET_NAMESTORE_Block *block)
+GNUNET_GNSRECORD_block_verify (const struct GNUNET_GNSRECORD_Block *block)
{
return GNUNET_CRYPTO_ecdsa_verify (GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN,
&block->purpose,
@@ -164,10 +164,10 @@
* not well-formed
*/
int
-GNUNET_NAMESTORE_block_decrypt (const struct GNUNET_NAMESTORE_Block *block,
+GNUNET_GNSRECORD_block_decrypt (const struct GNUNET_GNSRECORD_Block *block,
const struct GNUNET_CRYPTO_EcdsaPublicKey
*zone_key,
const char *label,
- GNUNET_NAMESTORE_RecordCallback proc,
+ GNUNET_GNSRECORD_RecordCallback proc,
void *proc_cls)
{
size_t payload_len = ntohl (block->purpose.size) -
@@ -203,10 +203,10 @@
return GNUNET_SYSERR;
}
{
- struct GNUNET_NAMESTORE_RecordData rd[rd_count];
+ struct GNUNET_GNSRECORD_Data rd[rd_count];
if (GNUNET_OK !=
- GNUNET_NAMESTORE_records_deserialize (payload_len - sizeof (uint32_t),
+ GNUNET_GNSRECORD_records_deserialize (payload_len - sizeof (uint32_t),
&payload[sizeof (uint32_t)],
rd_count,
rd))
@@ -230,14 +230,14 @@
* @param query hash to use for the query
*/
void
-GNUNET_NAMESTORE_query_from_private_key (const struct
GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+GNUNET_GNSRECORD_query_from_private_key (const struct
GNUNET_CRYPTO_EcdsaPrivateKey *zone,
const char *label,
struct GNUNET_HashCode *query)
{
struct GNUNET_CRYPTO_EcdsaPublicKey pub;
GNUNET_CRYPTO_ecdsa_key_get_public (zone, &pub);
- GNUNET_NAMESTORE_query_from_public_key (&pub, label, query);
+ GNUNET_GNSRECORD_query_from_public_key (&pub, label, query);
}
@@ -249,7 +249,7 @@
* @param query hash to use for the query
*/
void
-GNUNET_NAMESTORE_query_from_public_key (const struct
GNUNET_CRYPTO_EcdsaPublicKey *pub,
+GNUNET_GNSRECORD_query_from_public_key (const struct
GNUNET_CRYPTO_EcdsaPublicKey *pub,
const char *label,
struct GNUNET_HashCode *query)
{
Modified: gnunet/src/gnsrecord/gnsrecord_misc.c
===================================================================
--- gnunet/src/gnsrecord/gnsrecord_misc.c 2013-10-16 20:14:02 UTC (rev
30232)
+++ gnunet/src/gnsrecord/gnsrecord_misc.c 2013-10-16 20:21:27 UTC (rev
30233)
@@ -43,7 +43,7 @@
* @return converted result
*/
char *
-GNUNET_NAMESTORE_normalize_string (const char *src)
+GNUNET_GNSRECORD_string_to_lowercase (const char *src)
{
GNUNET_assert (NULL != src);
char *res = strdup (src);
@@ -59,10 +59,10 @@
* NOT reentrant!
*
* @param z the zone key
- * @return string form; will be overwritten by next call to
#GNUNET_NAMESTORE_z2s
+ * @return string form; will be overwritten by next call to
#GNUNET_GNSRECORD_z2s
*/
const char *
-GNUNET_NAMESTORE_z2s (const struct GNUNET_CRYPTO_EcdsaPublicKey *z)
+GNUNET_GNSRECORD_z2s (const struct GNUNET_CRYPTO_EcdsaPublicKey *z)
{
static char buf[sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey) * 8];
char *end;
@@ -90,8 +90,8 @@
* @return #GNUNET_YES if the records are equal or #GNUNET_NO if they are not
*/
int
-GNUNET_NAMESTORE_records_cmp (const struct GNUNET_NAMESTORE_RecordData *a,
- const struct GNUNET_NAMESTORE_RecordData *b)
+GNUNET_GNSRECORD_records_cmp (const struct GNUNET_GNSRECORD_Data *a,
+ const struct GNUNET_GNSRECORD_Data *b)
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Comparing records\n");
@@ -110,13 +110,13 @@
b->expiration_time);
return GNUNET_NO;
}
- if ((a->flags & GNUNET_NAMESTORE_RF_RCMP_FLAGS)
- != (b->flags & GNUNET_NAMESTORE_RF_RCMP_FLAGS))
+ if ((a->flags & GNUNET_GNSRECORD_RF_RCMP_FLAGS)
+ != (b->flags & GNUNET_GNSRECORD_RF_RCMP_FLAGS))
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Flags %lu (%lu) != %lu (%lu)\n", a->flags,
- a->flags & GNUNET_NAMESTORE_RF_RCMP_FLAGS, b->flags,
- b->flags & GNUNET_NAMESTORE_RF_RCMP_FLAGS);
+ a->flags & GNUNET_GNSRECORD_RF_RCMP_FLAGS, b->flags,
+ b->flags & GNUNET_GNSRECORD_RF_RCMP_FLAGS);
return GNUNET_NO;
}
if (a->data_size != b->data_size)
@@ -149,8 +149,8 @@
* @return absolute expiration time
*/
struct GNUNET_TIME_Absolute
-GNUNET_NAMESTORE_record_get_expiration_time (unsigned int rd_count,
- const struct
GNUNET_NAMESTORE_RecordData *rd)
+GNUNET_GNSRECORD_record_get_expiration_time (unsigned int rd_count,
+ const struct GNUNET_GNSRECORD_Data
*rd)
{
unsigned int c;
struct GNUNET_TIME_Absolute expire;
@@ -162,7 +162,7 @@
expire = GNUNET_TIME_UNIT_FOREVER_ABS;
for (c = 0; c < rd_count; c++)
{
- if (0 != (rd[c].flags & GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION))
+ if (0 != (rd[c].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
{
rt.rel_value_us = rd[c].expiration_time;
at = GNUNET_TIME_relative_to_absolute (rt);
@@ -188,11 +188,11 @@
* #GNUNET_NO if not
*/
int
-GNUNET_NAMESTORE_is_expired (const struct GNUNET_NAMESTORE_RecordData *rd)
+GNUNET_GNSRECORD_is_expired (const struct GNUNET_GNSRECORD_Data *rd)
{
struct GNUNET_TIME_Absolute at;
- if (0 != (rd->flags & GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION))
+ if (0 != (rd->flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
return GNUNET_NO;
at.abs_value_us = rd->expiration_time;
return (0 == GNUNET_TIME_absolute_get_remaining (at).rel_value_us) ?
GNUNET_YES : GNUNET_NO;
@@ -210,7 +210,7 @@
* key in an encoding suitable for DNS labels.
*/
const char *
-GNUNET_NAMESTORE_pkey_to_zkey (const struct GNUNET_CRYPTO_EcdsaPublicKey *pkey)
+GNUNET_GNSRECORD_pkey_to_zkey (const struct GNUNET_CRYPTO_EcdsaPublicKey *pkey)
{
static char ret[128];
char *pkeys;
@@ -235,7 +235,7 @@
* @return #GNUNET_SYSERR if @a zkey has the wrong syntax
*/
int
-GNUNET_NAMESTORE_zkey_to_pkey (const char *zkey,
+GNUNET_GNSRECORD_zkey_to_pkey (const char *zkey,
struct GNUNET_CRYPTO_EcdsaPublicKey *pkey)
{
char *cpy;
Modified: gnunet/src/gnsrecord/gnsrecord_serialization.c
===================================================================
--- gnunet/src/gnsrecord/gnsrecord_serialization.c 2013-10-16 20:14:02 UTC
(rev 30232)
+++ gnunet/src/gnsrecord/gnsrecord_serialization.c 2013-10-16 20:21:27 UTC
(rev 30233)
@@ -77,12 +77,12 @@
* records.
*
* @param rd_count number of records in the rd array
- * @param rd array of #GNUNET_NAMESTORE_RecordData with @a rd_count elements
+ * @param rd array of #GNUNET_GNSRECORD_Data with @a rd_count elements
* @return the required size to serialize
*/
size_t
-GNUNET_NAMESTORE_records_get_size (unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+GNUNET_GNSRECORD_records_get_size (unsigned int rd_count,
+ const struct GNUNET_GNSRECORD_Data *rd)
{
unsigned int i;
size_t ret;
@@ -101,14 +101,14 @@
* Serialize the given records to the given destination buffer.
*
* @param rd_count number of records in the rd array
- * @param rd array of #GNUNET_NAMESTORE_RecordData with @a rd_count elements
+ * @param rd array of #GNUNET_GNSRECORD_Data with @a rd_count elements
* @param dest_size size of the destination array
* @param dest where to write the result
* @return the size of serialized records, -1 if records do not fit
*/
ssize_t
-GNUNET_NAMESTORE_records_serialize (unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData
*rd,
+GNUNET_GNSRECORD_records_serialize (unsigned int rd_count,
+ const struct GNUNET_GNSRECORD_Data *rd,
size_t dest_size,
char *dest)
{
@@ -151,10 +151,10 @@
* @return #GNUNET_OK on success, #GNUNET_SYSERR on error
*/
int
-GNUNET_NAMESTORE_records_deserialize (size_t len,
+GNUNET_GNSRECORD_records_deserialize (size_t len,
const char *src,
unsigned int rd_count,
- struct GNUNET_NAMESTORE_RecordData *dest)
+ struct GNUNET_GNSRECORD_Data *dest)
{
struct NetworkRecord rec;
unsigned int i;
Modified: gnunet/src/gnsrecord/test_gnsrecord_crypto.c
===================================================================
--- gnunet/src/gnsrecord/test_gnsrecord_crypto.c 2013-10-16 20:14:02 UTC
(rev 30232)
+++ gnunet/src/gnsrecord/test_gnsrecord_crypto.c 2013-10-16 20:21:27 UTC
(rev 30233)
@@ -42,20 +42,20 @@
static struct GNUNET_CRYPTO_EcdsaPrivateKey * privkey;
-static struct GNUNET_NAMESTORE_RecordData *s_rd;
+static struct GNUNET_GNSRECORD_Data *s_rd;
static char *s_name;
static int res;
-static struct GNUNET_NAMESTORE_RecordData *
+static struct GNUNET_GNSRECORD_Data *
create_record (int count)
{
unsigned int c;
- struct GNUNET_NAMESTORE_RecordData * rd;
+ struct GNUNET_GNSRECORD_Data * rd;
- rd = GNUNET_malloc (count * sizeof (struct GNUNET_NAMESTORE_RecordData));
+ rd = GNUNET_malloc (count * sizeof (struct GNUNET_GNSRECORD_Data));
for (c = 0; c < count; c++)
{
rd[c].expiration_time = GNUNET_TIME_absolute_get().abs_value_us;
@@ -71,7 +71,7 @@
static void
rd_decrypt_cb (void *cls,
unsigned int rd_count,
- const struct
GNUNET_NAMESTORE_RecordData *rd)
+ const struct
GNUNET_GNSRECORD_Data *rd)
{
char rd_cmp_data[TEST_RECORD_DATALEN];
@@ -98,7 +98,7 @@
run (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
- struct GNUNET_NAMESTORE_Block *block;
+ struct GNUNET_GNSRECORD_Block *block;
struct GNUNET_CRYPTO_EcdsaPublicKey pubkey;
/* load privat key */
@@ -118,9 +118,9 @@
s_rd = create_record (RECORDS);
/* Create block */
- GNUNET_assert (NULL != (block = GNUNET_NAMESTORE_block_create (privkey,
expire,s_name, s_rd, RECORDS)));
- GNUNET_assert (GNUNET_OK == GNUNET_NAMESTORE_block_verify (block));
- GNUNET_assert (GNUNET_OK == GNUNET_NAMESTORE_block_decrypt (block, &pubkey,
s_name, &rd_decrypt_cb, s_name));
+ GNUNET_assert (NULL != (block = GNUNET_GNSRECORD_block_create (privkey,
expire,s_name, s_rd, RECORDS)));
+ GNUNET_assert (GNUNET_OK == GNUNET_GNSRECORD_block_verify (block));
+ GNUNET_assert (GNUNET_OK == GNUNET_GNSRECORD_block_decrypt (block, &pubkey,
s_name, &rd_decrypt_cb, s_name));
GNUNET_free (block);
}
Modified: gnunet/src/gnsrecord/test_gnsrecord_serialization.c
===================================================================
--- gnunet/src/gnsrecord/test_gnsrecord_serialization.c 2013-10-16 20:14:02 UTC
(rev 30232)
+++ gnunet/src/gnsrecord/test_gnsrecord_serialization.c 2013-10-16 20:21:27 UTC
(rev 30233)
@@ -39,9 +39,9 @@
int rd_count = 3;
size_t data_len;
- struct GNUNET_NAMESTORE_RecordData src[rd_count];
+ struct GNUNET_GNSRECORD_Data src[rd_count];
- memset(src, '\0', rd_count * sizeof (struct GNUNET_NAMESTORE_RecordData));
+ memset(src, '\0', rd_count * sizeof (struct GNUNET_GNSRECORD_Data));
data_len = 0;
for (c = 0; c < rd_count; c++)
@@ -56,16 +56,16 @@
}
res = 0;
- len = GNUNET_NAMESTORE_records_get_size(rd_count, src);
+ len = GNUNET_GNSRECORD_records_get_size(rd_count, src);
char rd_ser[len];
- GNUNET_assert (len == GNUNET_NAMESTORE_records_serialize(rd_count, src, len,
rd_ser));
+ GNUNET_assert (len == GNUNET_GNSRECORD_records_serialize(rd_count, src, len,
rd_ser));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Serialized data len: %u\n",len);
GNUNET_assert (rd_ser != NULL);
- struct GNUNET_NAMESTORE_RecordData dst[rd_count];
- GNUNET_assert (GNUNET_OK == GNUNET_NAMESTORE_records_deserialize (len,
rd_ser, rd_count, dst));
+ struct GNUNET_GNSRECORD_Data dst[rd_count];
+ GNUNET_assert (GNUNET_OK == GNUNET_GNSRECORD_records_deserialize (len,
rd_ser, rd_count, dst));
GNUNET_assert (dst != NULL);
Modified: gnunet/src/include/gnunet_conversation_service.h
===================================================================
--- gnunet/src/include/gnunet_conversation_service.h 2013-10-16 20:14:02 UTC
(rev 30232)
+++ gnunet/src/include/gnunet_conversation_service.h 2013-10-16 20:21:27 UTC
(rev 30233)
@@ -203,7 +203,7 @@
*/
void
GNUNET_CONVERSATION_phone_get_record (struct GNUNET_CONVERSATION_Phone *phone,
- struct GNUNET_NAMESTORE_RecordData *rd);
+ struct GNUNET_GNSRECORD_Data *rd);
/**
Modified: gnunet/src/include/gnunet_gns_service.h
===================================================================
--- gnunet/src/include/gnunet_gns_service.h 2013-10-16 20:14:02 UTC (rev
30232)
+++ gnunet/src/include/gnunet_gns_service.h 2013-10-16 20:21:27 UTC (rev
30233)
@@ -84,7 +84,7 @@
*/
typedef void (*GNUNET_GNS_LookupResultProcessor) (void *cls,
uint32_t rd_count,
- const struct
GNUNET_NAMESTORE_RecordData *rd);
+ const struct
GNUNET_GNSRECORD_Data *rd);
/**
Modified: gnunet/src/include/gnunet_gnsrecord_lib.h
===================================================================
--- gnunet/src/include/gnunet_gnsrecord_lib.h 2013-10-16 20:14:02 UTC (rev
30232)
+++ gnunet/src/include/gnunet_gnsrecord_lib.h 2013-10-16 20:21:27 UTC (rev
30233)
@@ -37,7 +37,7 @@
/**
* Maximum size of a value that can be stored in a GNS block.
*/
-#define GNUNET_NAMESTORE_MAX_VALUE_SIZE (63 * 1024)
+#define GNUNET_GNSRECORD_MAX_BLOCK_SIZE (63 * 1024)
/**
@@ -84,37 +84,37 @@
/**
* Flags that can be set for a record.
*/
-enum GNUNET_NAMESTORE_RecordFlags
+enum GNUNET_GNSRECORD_Flags
{
/**
* No special options.
*/
- GNUNET_NAMESTORE_RF_NONE = 0,
+ GNUNET_GNSRECORD_RF_NONE = 0,
/**
* This is a private record of this peer and it should
* thus not be handed out to other peers.
*/
- GNUNET_NAMESTORE_RF_PRIVATE = 2,
+ GNUNET_GNSRECORD_RF_PRIVATE = 2,
/**
* This record was added automatically by the system
* and is pending user confimation.
*/
- GNUNET_NAMESTORE_RF_PENDING = 4,
+ GNUNET_GNSRECORD_RF_PENDING = 4,
/**
* This expiration time of the record is a relative
* time (not an absolute time).
*/
- GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION = 8,
+ GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION = 8,
/**
* This record should not be used unless all (other) records with an absolute
* expiration time have expired.
*/
- GNUNET_NAMESTORE_RF_SHADOW_RECORD = 16
+ GNUNET_GNSRECORD_RF_SHADOW_RECORD = 16
/**
* When comparing flags for record equality for removal,
@@ -125,16 +125,16 @@
* pass the '--private' option when removing a record from
* the namestore, hence we don't require this particular option
* to match upon removal). See also
- * #GNUNET_NAMESTORE_records_cmp.
+ * #GNUNET_GNSRECORD_records_cmp.
*/
-#define GNUNET_NAMESTORE_RF_RCMP_FLAGS
(GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION)
+#define GNUNET_GNSRECORD_RF_RCMP_FLAGS
(GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION)
};
/**
* A GNS record.
*/
-struct GNUNET_NAMESTORE_RecordData
+struct GNUNET_GNSRECORD_Data
{
/**
@@ -164,7 +164,7 @@
/**
* Flags for the record.
*/
- enum GNUNET_NAMESTORE_RecordFlags flags;
+ enum GNUNET_GNSRECORD_Flags flags;
};
@@ -175,7 +175,7 @@
/**
* Information we have in an encrypted block with record data (i.e. in the
DHT).
*/
-struct GNUNET_NAMESTORE_Block
+struct GNUNET_GNSRECORD_Block
{
/**
@@ -212,9 +212,9 @@
* @param rd_count number of entries in @a rd array
* @param rd array of records with data to store
*/
-typedef void (*GNUNET_NAMESTORE_RecordCallback) (void *cls,
+typedef void (*GNUNET_GNSRECORD_RecordCallback) (void *cls,
unsigned int rd_count,
- const struct
GNUNET_NAMESTORE_RecordData *rd);
+ const struct
GNUNET_GNSRECORD_Data *rd);
@@ -279,26 +279,26 @@
* records.
*
* @param rd_count number of records in the @a rd array
- * @param rd array of #GNUNET_NAMESTORE_RecordData with @a rd_count elements
+ * @param rd array of #GNUNET_GNSRECORD_Data with @a rd_count elements
* @return the required size to serialize
*/
size_t
-GNUNET_NAMESTORE_records_get_size (unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData
*rd);
+GNUNET_GNSRECORD_records_get_size (unsigned int rd_count,
+ const struct GNUNET_GNSRECORD_Data *rd);
/**
* Serialize the given records to the given destination buffer.
*
* @param rd_count number of records in the @a rd array
- * @param rd array of #GNUNET_NAMESTORE_RecordData with @a rd_count elements
+ * @param rd array of #GNUNET_GNSRECORD_Data with @a rd_count elements
* @param dest_size size of the destination array @a dst
* @param dest where to write the result
* @return the size of serialized records, -1 if records do not fit
*/
ssize_t
-GNUNET_NAMESTORE_records_serialize (unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData
*rd,
+GNUNET_GNSRECORD_records_serialize (unsigned int rd_count,
+ const struct GNUNET_GNSRECORD_Data *rd,
size_t dest_size,
char *dest);
@@ -313,10 +313,10 @@
* @return #GNUNET_OK on success, #GNUNET_SYSERR on error
*/
int
-GNUNET_NAMESTORE_records_deserialize (size_t len,
+GNUNET_GNSRECORD_records_deserialize (size_t len,
const char *src,
unsigned int rd_count,
- struct GNUNET_NAMESTORE_RecordData *dest);
+ struct GNUNET_GNSRECORD_Data *dest);
/* ******* general APIs relating to blocks, records and labels ******** */
@@ -331,7 +331,7 @@
* #GNUNET_NO if not
*/
int
-GNUNET_NAMESTORE_is_expired (const struct GNUNET_NAMESTORE_RecordData *rd);
+GNUNET_GNSRECORD_is_expired (const struct GNUNET_GNSRECORD_Data *rd);
/**
@@ -340,7 +340,7 @@
* @return converted result
*/
char *
-GNUNET_NAMESTORE_normalize_string (const char *src);
+GNUNET_GNSRECORD_string_to_lowercase (const char *src);
/**
@@ -349,10 +349,10 @@
* NOT reentrant!
*
* @param z public key of a zone
- * @return string form; will be overwritten by next call to
#GNUNET_NAMESTORE_z2s.
+ * @return string form; will be overwritten by next call to
#GNUNET_GNSRECORD_z2s.
*/
const char *
-GNUNET_NAMESTORE_z2s (const struct GNUNET_CRYPTO_EcdsaPublicKey *z);
+GNUNET_GNSRECORD_z2s (const struct GNUNET_CRYPTO_EcdsaPublicKey *z);
/**
@@ -366,7 +366,7 @@
* key in an encoding suitable for DNS labels.
*/
const char *
-GNUNET_NAMESTORE_pkey_to_zkey (const struct GNUNET_CRYPTO_EcdsaPublicKey
*pkey);
+GNUNET_GNSRECORD_pkey_to_zkey (const struct GNUNET_CRYPTO_EcdsaPublicKey
*pkey);
/**
@@ -379,7 +379,7 @@
* @return #GNUNET_SYSERR if @a zkey has the wrong syntax
*/
int
-GNUNET_NAMESTORE_zkey_to_pkey (const char *zkey,
+GNUNET_GNSRECORD_zkey_to_pkey (const char *zkey,
struct GNUNET_CRYPTO_EcdsaPublicKey *pkey);
@@ -391,7 +391,7 @@
* @param query hash to use for the query
*/
void
-GNUNET_NAMESTORE_query_from_private_key (const struct
GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+GNUNET_GNSRECORD_query_from_private_key (const struct
GNUNET_CRYPTO_EcdsaPrivateKey *zone,
const char *label,
struct GNUNET_HashCode *query);
@@ -404,7 +404,7 @@
* @param query hash to use for the query
*/
void
-GNUNET_NAMESTORE_query_from_public_key (const struct
GNUNET_CRYPTO_EcdsaPublicKey *pub,
+GNUNET_GNSRECORD_query_from_public_key (const struct
GNUNET_CRYPTO_EcdsaPublicKey *pub,
const char *label,
struct GNUNET_HashCode *query);
@@ -418,11 +418,11 @@
* @param rd record data
* @param rd_count number of records in @a rd
*/
-struct GNUNET_NAMESTORE_Block *
-GNUNET_NAMESTORE_block_create (const struct GNUNET_CRYPTO_EcdsaPrivateKey *key,
+struct GNUNET_GNSRECORD_Block *
+GNUNET_GNSRECORD_block_create (const struct GNUNET_CRYPTO_EcdsaPrivateKey *key,
struct GNUNET_TIME_Absolute expire,
const char *label,
- const struct GNUNET_NAMESTORE_RecordData *rd,
+ const struct GNUNET_GNSRECORD_Data *rd,
unsigned int rd_count);
@@ -434,7 +434,7 @@
* @return #GNUNET_OK if the signature is valid
*/
int
-GNUNET_NAMESTORE_block_verify (const struct GNUNET_NAMESTORE_Block *block);
+GNUNET_GNSRECORD_block_verify (const struct GNUNET_GNSRECORD_Block *block);
/**
@@ -449,10 +449,10 @@
* not well-formed
*/
int
-GNUNET_NAMESTORE_block_decrypt (const struct GNUNET_NAMESTORE_Block *block,
+GNUNET_GNSRECORD_block_decrypt (const struct GNUNET_GNSRECORD_Block *block,
const struct GNUNET_CRYPTO_EcdsaPublicKey
*zone_key,
const char *label,
- GNUNET_NAMESTORE_RecordCallback proc,
+ GNUNET_GNSRECORD_RecordCallback proc,
void *proc_cls);
@@ -464,8 +464,8 @@
* @return #GNUNET_YES if the records are equal, or #GNUNET_NO if not.
*/
int
-GNUNET_NAMESTORE_records_cmp (const struct GNUNET_NAMESTORE_RecordData *a,
- const struct GNUNET_NAMESTORE_RecordData *b);
+GNUNET_GNSRECORD_records_cmp (const struct GNUNET_GNSRECORD_Data *a,
+ const struct GNUNET_GNSRECORD_Data *b);
/**
@@ -478,8 +478,8 @@
* @return absolute expiration time
*/
struct GNUNET_TIME_Absolute
-GNUNET_NAMESTORE_record_get_expiration_time (unsigned int rd_count,
- const struct
GNUNET_NAMESTORE_RecordData *rd);
+GNUNET_GNSRECORD_record_get_expiration_time (unsigned int rd_count,
+ const struct GNUNET_GNSRECORD_Data
*rd);
Modified: gnunet/src/include/gnunet_namecache_plugin.h
===================================================================
--- gnunet/src/include/gnunet_namecache_plugin.h 2013-10-16 20:14:02 UTC
(rev 30232)
+++ gnunet/src/include/gnunet_namecache_plugin.h 2013-10-16 20:21:27 UTC
(rev 30233)
@@ -46,7 +46,7 @@
* @param block lookup result
*/
typedef void (*GNUNET_NAMECACHE_BlockCallback) (void *cls,
- const struct
GNUNET_NAMESTORE_Block *block);
+ const struct
GNUNET_GNSRECORD_Block *block);
/**
@@ -69,7 +69,7 @@
* @return #GNUNET_OK on success, else #GNUNET_SYSERR
*/
int (*cache_block) (void *cls,
- const struct GNUNET_NAMESTORE_Block *block);
+ const struct GNUNET_GNSRECORD_Block *block);
/**
Modified: gnunet/src/include/gnunet_namecache_service.h
===================================================================
--- gnunet/src/include/gnunet_namecache_service.h 2013-10-16 20:14:02 UTC
(rev 30232)
+++ gnunet/src/include/gnunet_namecache_service.h 2013-10-16 20:21:27 UTC
(rev 30233)
@@ -107,7 +107,7 @@
*/
struct GNUNET_NAMECACHE_QueueEntry *
GNUNET_NAMECACHE_block_cache (struct GNUNET_NAMECACHE_Handle *h,
- const struct GNUNET_NAMESTORE_Block *block,
+ const struct GNUNET_GNSRECORD_Block *block,
GNUNET_NAMECACHE_ContinuationWithStatus cont,
void *cont_cls);
@@ -119,7 +119,7 @@
* @param block block that was stored in the namecache
*/
typedef void (*GNUNET_NAMECACHE_BlockProcessor) (void *cls,
- const struct
GNUNET_NAMESTORE_Block *block);
+ const struct
GNUNET_GNSRECORD_Block *block);
/**
Modified: gnunet/src/include/gnunet_namestore_plugin.h
===================================================================
--- gnunet/src/include/gnunet_namestore_plugin.h 2013-10-16 20:14:02 UTC
(rev 30232)
+++ gnunet/src/include/gnunet_namestore_plugin.h 2013-10-16 20:21:27 UTC
(rev 30233)
@@ -44,8 +44,8 @@
* @param cls closure
* @param block lookup result
*/
-typedef void (*GNUNET_NAMESTORE_BlockCallback) (void *cls,
- const struct
GNUNET_NAMESTORE_Block *block);
+typedef void (*GNUNET_GNSRECORD_BlockCallback) (void *cls,
+ const struct
GNUNET_GNSRECORD_Block *block);
/**
@@ -61,7 +61,7 @@
const struct
GNUNET_CRYPTO_EcdsaPrivateKey *private_key,
const char *label,
unsigned int rd_count,
- const struct
GNUNET_NAMESTORE_RecordData *rd);
+ const struct
GNUNET_GNSRECORD_Data *rd);
/**
@@ -84,7 +84,7 @@
* @return #GNUNET_OK on success, else #GNUNET_SYSERR
*/
int (*cache_block) (void *cls,
- const struct GNUNET_NAMESTORE_Block *block);
+ const struct GNUNET_GNSRECORD_Block *block);
/**
@@ -99,7 +99,7 @@
*/
int (*lookup_block) (void *cls,
const struct GNUNET_HashCode *query,
- GNUNET_NAMESTORE_BlockCallback iter, void *iter_cls);
+ GNUNET_GNSRECORD_BlockCallback iter, void *iter_cls);
@@ -118,7 +118,7 @@
const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
const char *label,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd);
+ const struct GNUNET_GNSRECORD_Data *rd);
/**
Modified: gnunet/src/include/gnunet_namestore_service.h
===================================================================
--- gnunet/src/include/gnunet_namestore_service.h 2013-10-16 20:14:02 UTC
(rev 30232)
+++ gnunet/src/include/gnunet_namestore_service.h 2013-10-16 20:21:27 UTC
(rev 30233)
@@ -106,7 +106,7 @@
*/
struct GNUNET_NAMESTORE_QueueEntry *
GNUNET_NAMESTORE_block_cache (struct GNUNET_NAMESTORE_Handle *h,
- const struct GNUNET_NAMESTORE_Block *block,
+ const struct GNUNET_GNSRECORD_Block *block,
GNUNET_NAMESTORE_ContinuationWithStatus cont,
void *cont_cls);
@@ -130,7 +130,7 @@
const struct GNUNET_CRYPTO_EcdsaPrivateKey
*pkey,
const char *label,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd,
+ const struct GNUNET_GNSRECORD_Data *rd,
GNUNET_NAMESTORE_ContinuationWithStatus cont,
void *cont_cls);
@@ -141,8 +141,8 @@
* @param cls closure
* @param block block that was stored in the namestore
*/
-typedef void (*GNUNET_NAMESTORE_BlockProcessor) (void *cls,
- const struct
GNUNET_NAMESTORE_Block *block);
+typedef void (*GNUNET_GNSRECORD_BlockProcessor) (void *cls,
+ const struct
GNUNET_GNSRECORD_Block *block);
/**
@@ -160,7 +160,7 @@
struct GNUNET_NAMESTORE_QueueEntry *
GNUNET_NAMESTORE_lookup_block (struct GNUNET_NAMESTORE_Handle *h,
const struct GNUNET_HashCode *derived_hash,
- GNUNET_NAMESTORE_BlockProcessor proc, void
*proc_cls);
+ GNUNET_GNSRECORD_BlockProcessor proc, void
*proc_cls);
/**
@@ -176,7 +176,7 @@
const struct
GNUNET_CRYPTO_EcdsaPrivateKey *zone,
const char *label,
unsigned int rd_count,
- const struct
GNUNET_NAMESTORE_RecordData *rd);
+ const struct
GNUNET_GNSRECORD_Data *rd);
/**
Modified: gnunet/src/namecache/gnunet-namecache.c
===================================================================
--- gnunet/src/namecache/gnunet-namecache.c 2013-10-16 20:14:02 UTC (rev
30232)
+++ gnunet/src/namecache/gnunet-namecache.c 2013-10-16 20:21:27 UTC (rev
30233)
@@ -99,7 +99,7 @@
static void
display_records_from_block (void *cls,
unsigned int rd_len,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
const char *typestring;
char *s;
@@ -145,7 +145,7 @@
*/
static void
handle_block (void *cls,
- const struct GNUNET_NAMESTORE_Block *block)
+ const struct GNUNET_GNSRECORD_Block *block)
{
qe = NULL;
if (NULL == block)
@@ -154,7 +154,7 @@
"No matching block found\n");
}
else if (GNUNET_OK !=
- GNUNET_NAMESTORE_block_decrypt (block,
+ GNUNET_GNSRECORD_block_decrypt (block,
&pubkey,
name,
&display_records_from_block,
@@ -202,7 +202,7 @@
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&do_shutdown,
NULL);
- GNUNET_NAMESTORE_query_from_public_key (&pubkey,
+ GNUNET_GNSRECORD_query_from_public_key (&pubkey,
name,
&dhash);
qe = GNUNET_NAMECACHE_lookup_block (ns,
Modified: gnunet/src/namecache/gnunet-service-namecache.c
===================================================================
--- gnunet/src/namecache/gnunet-service-namecache.c 2013-10-16 20:14:02 UTC
(rev 30232)
+++ gnunet/src/namecache/gnunet-service-namecache.c 2013-10-16 20:21:27 UTC
(rev 30233)
@@ -215,7 +215,7 @@
*/
static void
handle_lookup_block_it (void *cls,
- const struct GNUNET_NAMESTORE_Block *block)
+ const struct GNUNET_GNSRECORD_Block *block)
{
struct LookupBlockContext *lnc = cls;
struct LookupBlockResponseMessage *r;
@@ -316,7 +316,7 @@
struct NamecacheClient *nc;
const struct BlockCacheMessage *rp_msg;
struct BlockCacheResponseMessage rpr_msg;
- struct GNUNET_NAMESTORE_Block *block;
+ struct GNUNET_GNSRECORD_Block *block;
size_t esize;
int res;
@@ -329,7 +329,7 @@
}
rp_msg = (const struct BlockCacheMessage *) message;
esize = ntohs (rp_msg->gns_header.header.size) - sizeof (struct
BlockCacheMessage);
- block = GNUNET_malloc (sizeof (struct GNUNET_NAMESTORE_Block) + esize);
+ block = GNUNET_malloc (sizeof (struct GNUNET_GNSRECORD_Block) + esize);
block->signature = rp_msg->signature;
block->derived_key = rp_msg->derived_key;
block->purpose.size = htonl (sizeof (struct
GNUNET_CRYPTO_EccSignaturePurpose) +
Modified: gnunet/src/namecache/namecache_api.c
===================================================================
--- gnunet/src/namecache/namecache_api.c 2013-10-16 20:14:02 UTC (rev
30232)
+++ gnunet/src/namecache/namecache_api.c 2013-10-16 20:21:27 UTC (rev
30233)
@@ -76,7 +76,7 @@
/**
* Function to call with the blocks we get back; or NULL.
*/
- GNUNET_NAMESTORE_BlockProcessor block_proc;
+ GNUNET_GNSRECORD_BlockProcessor block_proc;
/**
* Closure for @e block_proc.
@@ -208,8 +208,8 @@
const struct LookupBlockResponseMessage *msg,
size_t size)
{
- struct GNUNET_NAMESTORE_Block *block;
- char buf[size + sizeof (struct GNUNET_NAMESTORE_Block)
+ struct GNUNET_GNSRECORD_Block *block;
+ char buf[size + sizeof (struct GNUNET_GNSRECORD_Block)
- sizeof (struct LookupBlockResponseMessage)];
LOG (GNUNET_ERROR_TYPE_DEBUG,
@@ -223,7 +223,7 @@
return GNUNET_OK;
}
- block = (struct GNUNET_NAMESTORE_Block *) buf;
+ block = (struct GNUNET_GNSRECORD_Block *) buf;
block->signature = msg->signature;
block->derived_key = msg->derived_key;
block->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN);
@@ -235,7 +235,7 @@
&msg[1],
size - sizeof (struct LookupBlockResponseMessage));
if (GNUNET_OK !=
- GNUNET_NAMESTORE_block_verify (block))
+ GNUNET_GNSRECORD_block_verify (block))
{
GNUNET_break (0);
return GNUNET_SYSERR;
@@ -623,7 +623,7 @@
*/
struct GNUNET_NAMECACHE_QueueEntry *
GNUNET_NAMECACHE_block_cache (struct GNUNET_NAMECACHE_Handle *h,
- const struct GNUNET_NAMESTORE_Block *block,
+ const struct GNUNET_GNSRECORD_Block *block,
GNUNET_NAMECACHE_ContinuationWithStatus cont,
void *cont_cls)
{
@@ -683,7 +683,7 @@
struct GNUNET_NAMECACHE_QueueEntry *
GNUNET_NAMECACHE_lookup_block (struct GNUNET_NAMECACHE_Handle *h,
const struct GNUNET_HashCode *derived_hash,
- GNUNET_NAMESTORE_BlockProcessor proc, void
*proc_cls)
+ GNUNET_GNSRECORD_BlockProcessor proc, void
*proc_cls)
{
struct GNUNET_NAMECACHE_QueueEntry *qe;
struct PendingMessage *pe;
Modified: gnunet/src/namecache/plugin_namecache_postgres.c
===================================================================
--- gnunet/src/namecache/plugin_namecache_postgres.c 2013-10-16 20:14:02 UTC
(rev 30232)
+++ gnunet/src/namecache/plugin_namecache_postgres.c 2013-10-16 20:21:27 UTC
(rev 30233)
@@ -255,7 +255,7 @@
*/
static int
namecache_postgres_cache_block (void *cls,
- const struct GNUNET_NAMESTORE_Block *block)
+ const struct GNUNET_GNSRECORD_Block *block)
{
struct Plugin *plugin = cls;
struct GNUNET_HashCode query;
@@ -327,7 +327,7 @@
PGresult *res;
unsigned int cnt;
size_t bsize;
- const struct GNUNET_NAMESTORE_Block *block;
+ const struct GNUNET_GNSRECORD_Block *block;
res = PQexecPrepared (plugin->dbh,
"lookup_block", 1,
@@ -353,7 +353,7 @@
GNUNET_assert (1 == cnt);
GNUNET_assert (1 != PQnfields (res));
bsize = PQgetlength (res, 0, 0);
- block = (const struct GNUNET_NAMESTORE_Block *) PQgetvalue (res, 0, 0);
+ block = (const struct GNUNET_GNSRECORD_Block *) PQgetvalue (res, 0, 0);
if ( (bsize < sizeof (*block)) ||
(bsize != ntohl (block->purpose.size) +
sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey) +
Modified: gnunet/src/namecache/plugin_namecache_sqlite.c
===================================================================
--- gnunet/src/namecache/plugin_namecache_sqlite.c 2013-10-16 20:14:02 UTC
(rev 30232)
+++ gnunet/src/namecache/plugin_namecache_sqlite.c 2013-10-16 20:21:27 UTC
(rev 30233)
@@ -366,7 +366,7 @@
*/
static int
namecache_sqlite_cache_block (void *cls,
- const struct GNUNET_NAMESTORE_Block *block)
+ const struct GNUNET_GNSRECORD_Block *block)
{
struct Plugin *plugin = cls;
struct GNUNET_HashCode query;
@@ -495,7 +495,7 @@
int ret;
int sret;
size_t block_size;
- const struct GNUNET_NAMESTORE_Block *block;
+ const struct GNUNET_GNSRECORD_Block *block;
if (SQLITE_OK != sqlite3_bind_blob (plugin->lookup_block, 1,
query, sizeof (struct GNUNET_HashCode),
@@ -514,7 +514,7 @@
{
block = sqlite3_column_blob (plugin->lookup_block, 0);
block_size = sqlite3_column_bytes (plugin->lookup_block, 0);
- if ( (block_size < sizeof (struct GNUNET_NAMESTORE_Block)) ||
+ if ( (block_size < sizeof (struct GNUNET_GNSRECORD_Block)) ||
(ntohl (block->purpose.size) +
sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey) +
sizeof (struct GNUNET_CRYPTO_EcdsaSignature) != block_size) )
Modified: gnunet/src/namecache/test_namecache_api_cache_block.c
===================================================================
--- gnunet/src/namecache/test_namecache_api_cache_block.c 2013-10-16
20:14:02 UTC (rev 30232)
+++ gnunet/src/namecache/test_namecache_api_cache_block.c 2013-10-16
20:21:27 UTC (rev 30233)
@@ -94,7 +94,7 @@
static void
rd_decrypt_cb (void *cls,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
char rd_cmp_data[TEST_RECORD_DATALEN];
@@ -115,7 +115,7 @@
static void
name_lookup_proc (void *cls,
- const struct GNUNET_NAMESTORE_Block *block)
+ const struct GNUNET_GNSRECORD_Block *block)
{
const char *name = cls;
nsqe = NULL;
@@ -140,7 +140,7 @@
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Namecache returned block, decrypting \n");
- GNUNET_assert (GNUNET_OK == GNUNET_NAMESTORE_block_decrypt(block,
+ GNUNET_assert (GNUNET_OK == GNUNET_GNSRECORD_block_decrypt(block,
&pubkey, name, &rd_decrypt_cb, (void *) name));
}
@@ -158,7 +158,7 @@
(success == GNUNET_OK) ? "SUCCESS" : "FAIL");
/* Create derived hash */
- GNUNET_NAMESTORE_query_from_public_key (&pubkey, name, &derived_hash);
+ GNUNET_GNSRECORD_query_from_public_key (&pubkey, name, &derived_hash);
nsqe = GNUNET_NAMECACHE_lookup_block (nsh, &derived_hash,
&name_lookup_proc, (void *) name);
@@ -170,8 +170,8 @@
const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TESTING_Peer *peer)
{
- struct GNUNET_NAMESTORE_RecordData rd;
- struct GNUNET_NAMESTORE_Block *block;
+ struct GNUNET_GNSRECORD_Data rd;
+ struct GNUNET_GNSRECORD_Block *block;
char *hostkey_file;
const char * name = "dummy.dummy.gnunet";
@@ -193,7 +193,7 @@
rd.data_size = TEST_RECORD_DATALEN;
rd.data = GNUNET_malloc (TEST_RECORD_DATALEN);
memset ((char *) rd.data, 'a', TEST_RECORD_DATALEN);
- block = GNUNET_NAMESTORE_block_create (privkey,
+ block = GNUNET_GNSRECORD_block_create (privkey,
GNUNET_TIME_UNIT_FOREVER_ABS, name, &rd, 1 );
if (NULL == block)
{
Modified: gnunet/src/namestore/gnunet-namestore-fcfsd.c
===================================================================
--- gnunet/src/namestore/gnunet-namestore-fcfsd.c 2013-10-16 20:14:02 UTC
(rev 30232)
+++ gnunet/src/namestore/gnunet-namestore-fcfsd.c 2013-10-16 20:21:27 UTC
(rev 30233)
@@ -246,7 +246,7 @@
const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
const char *name,
unsigned int rd_len,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
struct ZoneinfoRequest *zr = cls;
struct MHD_Response *response;
@@ -508,10 +508,10 @@
const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
const char *name,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
struct Request *request = cls;
- struct GNUNET_NAMESTORE_RecordData r;
+ struct GNUNET_GNSRECORD_Data r;
struct GNUNET_CRYPTO_EcdsaPublicKey pub;
request->qe = NULL;
@@ -530,7 +530,7 @@
r.data_size = sizeof (pub);
r.expiration_time = UINT64_MAX;
r.record_type = GNUNET_GNSRECORD_TYPE_PKEY;
- r.flags = GNUNET_NAMESTORE_RF_NONE;
+ r.flags = GNUNET_GNSRECORD_RF_NONE;
request->qe = GNUNET_NAMESTORE_records_store (ns,
&fcfs_zone_pkey,
request->domain_name,
@@ -552,7 +552,7 @@
static void
lookup_result_processor (void *cls,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
struct Request *request = cls;
struct GNUNET_CRYPTO_EcdsaPublicKey pub;
@@ -594,7 +594,7 @@
*/
static void
lookup_block_processor (void *cls,
- const struct GNUNET_NAMESTORE_Block *block)
+ const struct GNUNET_GNSRECORD_Block *block)
{
struct Request *request = cls;
struct GNUNET_CRYPTO_EcdsaPublicKey pub;
@@ -608,7 +608,7 @@
GNUNET_CRYPTO_ecdsa_key_get_public (&fcfs_zone_pkey,
&pub);
if (GNUNET_OK !=
- GNUNET_NAMESTORE_block_decrypt (block,
+ GNUNET_GNSRECORD_block_decrypt (block,
&pub,
request->domain_name,
&lookup_result_processor,
@@ -738,7 +738,7 @@
request->phase = RP_LOOKUP;
GNUNET_CRYPTO_ecdsa_key_get_public (&fcfs_zone_pkey,
&pub);
- GNUNET_NAMESTORE_query_from_public_key (&pub,
+ GNUNET_GNSRECORD_query_from_public_key (&pub,
request->domain_name,
&query);
request->qe = GNUNET_NAMESTORE_lookup_block (ns,
Modified: gnunet/src/namestore/gnunet-namestore.c
===================================================================
--- gnunet/src/namestore/gnunet-namestore.c 2013-10-16 20:14:02 UTC (rev
30232)
+++ gnunet/src/namestore/gnunet-namestore.c 2013-10-16 20:21:27 UTC (rev
30233)
@@ -100,12 +100,12 @@
static int del;
/**
- * Is record public (opposite of #GNUNET_NAMESTORE_RF_PRIVATE)
+ * Is record public (opposite of #GNUNET_GNSRECORD_RF_PRIVATE)
*/
static int public;
/**
- * Is record a shadow record (#GNUNET_NAMESTORE_RF_SHADOW_RECORD)
+ * Is record a shadow record (#GNUNET_GNSRECORD_RF_SHADOW_RECORD)
*/
static int shadow;
@@ -338,7 +338,7 @@
const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
const char *name,
unsigned int rd_len,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
const char *typestring;
char *s;
@@ -368,7 +368,7 @@
(unsigned int) rd[i].record_type);
continue;
}
- if (0 != (rd[i].flags & GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION))
+ if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
{
rt.rel_value_us = rd[i].expiration_time;
ets = GNUNET_STRINGS_relative_time_to_string (rt, GNUNET_YES);
@@ -417,10 +417,10 @@
const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
const char *rec_name,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
- struct GNUNET_NAMESTORE_RecordData rdn[rd_count + 1];
- struct GNUNET_NAMESTORE_RecordData *rde;
+ struct GNUNET_GNSRECORD_Data rdn[rd_count + 1];
+ struct GNUNET_GNSRECORD_Data *rde;
if ( (NULL != zone_key) &&
(0 != strcmp (rec_name, name)) )
@@ -428,8 +428,8 @@
GNUNET_NAMESTORE_zone_iterator_next (add_zit);
return;
}
- memset (rdn, 0, sizeof (struct GNUNET_NAMESTORE_RecordData));
- memcpy (&rdn[1], rd, rd_count * sizeof (struct GNUNET_NAMESTORE_RecordData));
+ memset (rdn, 0, sizeof (struct GNUNET_GNSRECORD_Data));
+ memcpy (&rdn[1], rd, rd_count * sizeof (struct GNUNET_GNSRECORD_Data));
/* FIXME: should add some logic to overwrite records if there
can only be one record of a particular type, and to check
if the combination of records is valid to begin with... */
@@ -438,13 +438,13 @@
rde->data_size = data_size;
rde->record_type = type;
if (1 != shadow)
- rde->flags |= GNUNET_NAMESTORE_RF_SHADOW_RECORD;
+ rde->flags |= GNUNET_GNSRECORD_RF_SHADOW_RECORD;
if (1 != public)
- rde->flags |= GNUNET_NAMESTORE_RF_PRIVATE;
+ rde->flags |= GNUNET_GNSRECORD_RF_PRIVATE;
if (GNUNET_YES == etime_is_rel)
{
rde->expiration_time = etime_rel.rel_value_us;
- rde->flags |= GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION;
+ rde->flags |= GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
}
else if (GNUNET_NO == etime_is_rel)
rde->expiration_time = etime_abs.abs_value_us;
@@ -477,7 +477,7 @@
static void
display_records_from_block (void *cls,
unsigned int rd_len,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
const char *typestring;
char *s;
@@ -523,7 +523,7 @@
*/
static void
handle_block (void *cls,
- const struct GNUNET_NAMESTORE_Block *block)
+ const struct GNUNET_GNSRECORD_Block *block)
{
struct GNUNET_CRYPTO_EcdsaPublicKey zone_pubkey;
@@ -536,7 +536,7 @@
"No matching block found\n");
}
else if (GNUNET_OK !=
- GNUNET_NAMESTORE_block_decrypt (block,
+ GNUNET_GNSRECORD_block_decrypt (block,
&zone_pubkey,
name,
&display_records_from_block,
@@ -564,7 +564,7 @@
const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
const char *label,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
reverse_qe = NULL;
if (NULL == label)
@@ -593,7 +593,7 @@
{
const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
struct GNUNET_CRYPTO_EcdsaPublicKey pub;
- struct GNUNET_NAMESTORE_RecordData rd;
+ struct GNUNET_GNSRECORD_Data rd;
if (GNUNET_YES != result)
{
@@ -743,7 +743,7 @@
GNUNET_CRYPTO_ecdsa_key_get_public (&zone_pkey,
&zone_pubkey);
- GNUNET_NAMESTORE_query_from_public_key (&zone_pubkey,
+ GNUNET_GNSRECORD_query_from_public_key (&zone_pubkey,
name,
&query);
list_qe = GNUNET_NAMESTORE_lookup_block (ns,
@@ -799,14 +799,14 @@
if (GNUNET_YES == etime_is_rel)
{
rd.expiration_time = etime_rel.rel_value_us;
- rd.flags |= GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION;
+ rd.flags |= GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
}
else if (GNUNET_NO == etime_is_rel)
rd.expiration_time = etime_abs.abs_value_us;
else
rd.expiration_time = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
if (1 != shadow)
- rd.flags |= GNUNET_NAMESTORE_RF_SHADOW_RECORD;
+ rd.flags |= GNUNET_GNSRECORD_RF_SHADOW_RECORD;
add_qe_uri = GNUNET_NAMESTORE_records_store (ns,
&zone_pkey,
sname,
Modified: gnunet/src/namestore/gnunet-service-namestore.c
===================================================================
--- gnunet/src/namestore/gnunet-service-namestore.c 2013-10-16 20:14:02 UTC
(rev 30232)
+++ gnunet/src/namestore/gnunet-service-namestore.c 2013-10-16 20:21:27 UTC
(rev 30233)
@@ -347,14 +347,14 @@
/**
- * A #GNUNET_NAMESTORE_BlockCallback for name lookups in #handle_lookup_block
+ * A #GNUNET_GNSRECORD_BlockCallback for name lookups in #handle_lookup_block
*
* @param cls a `struct LookupNameContext *` with information about the request
* @param block the block
*/
static void
handle_lookup_block_it (void *cls,
- const struct GNUNET_NAMESTORE_Block *block)
+ const struct GNUNET_GNSRECORD_Block *block)
{
struct LookupBlockContext *lnc = cls;
struct LookupBlockResponseMessage *r;
@@ -455,7 +455,7 @@
struct NamestoreClient *nc;
const struct BlockCacheMessage *rp_msg;
struct BlockCacheResponseMessage rpr_msg;
- struct GNUNET_NAMESTORE_Block *block;
+ struct GNUNET_GNSRECORD_Block *block;
size_t esize;
int res;
@@ -468,7 +468,7 @@
}
rp_msg = (const struct BlockCacheMessage *) message;
esize = ntohs (rp_msg->gns_header.header.size) - sizeof (struct
BlockCacheMessage);
- block = GNUNET_malloc (sizeof (struct GNUNET_NAMESTORE_Block) + esize);
+ block = GNUNET_malloc (sizeof (struct GNUNET_GNSRECORD_Block) + esize);
block->signature = rp_msg->signature;
block->derived_key = rp_msg->derived_key;
block->purpose.size = htonl (sizeof (struct
GNUNET_CRYPTO_EccSignaturePurpose) +
@@ -515,7 +515,7 @@
const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
const char *name,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
struct RecordResultMessage *zir_msg;
size_t name_len;
@@ -525,7 +525,7 @@
char *rd_ser;
name_len = strlen (name) + 1;
- rd_ser_len = GNUNET_NAMESTORE_records_get_size (rd_count, rd);
+ rd_ser_len = GNUNET_GNSRECORD_records_get_size (rd_count, rd);
msg_size = sizeof (struct RecordResultMessage) + name_len + rd_ser_len;
zir_msg = GNUNET_malloc (msg_size);
@@ -539,7 +539,7 @@
name_tmp = (char *) &zir_msg[1];
memcpy (name_tmp, name, name_len);
rd_ser = &name_tmp[name_len];
- GNUNET_NAMESTORE_records_serialize (rd_count, rd, rd_ser_len, rd_ser);
+ GNUNET_GNSRECORD_records_serialize (rd_count, rd, rd_ser_len, rd_ser);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Sending `%s' message with %u records and size %u\n",
"RECORD_RESULT",
@@ -566,18 +566,18 @@
refresh_block (const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
const char *name,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
- struct GNUNET_NAMESTORE_Block *block;
+ struct GNUNET_GNSRECORD_Block *block;
if (0 == rd_count)
- block = GNUNET_NAMESTORE_block_create (zone_key,
+ block = GNUNET_GNSRECORD_block_create (zone_key,
GNUNET_TIME_UNIT_ZERO_ABS,
name,
rd, rd_count);
else
- block = GNUNET_NAMESTORE_block_create (zone_key,
-
GNUNET_NAMESTORE_record_get_expiration_time (rd_count,
+ block = GNUNET_GNSRECORD_block_create (zone_key,
+
GNUNET_GNSRECORD_record_get_expiration_time (rd_count,
rd),
name,
rd, rd_count);
@@ -659,10 +659,10 @@
return;
}
{
- struct GNUNET_NAMESTORE_RecordData rd[rd_count];
+ struct GNUNET_GNSRECORD_Data rd[rd_count];
if (GNUNET_OK !=
- GNUNET_NAMESTORE_records_deserialize (rd_ser_len, rd_ser, rd_count, rd))
+ GNUNET_GNSRECORD_records_deserialize (rd_ser_len, rd_ser, rd_count, rd))
{
GNUNET_break (0);
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
@@ -672,7 +672,7 @@
/* Extracting and converting private key */
GNUNET_CRYPTO_ecdsa_key_get_public (&rp_msg->private_key,
&pubkey);
- conv_name = GNUNET_NAMESTORE_normalize_string (name_tmp);
+ conv_name = GNUNET_GNSRECORD_string_to_lowercase (name_tmp);
if (NULL == conv_name)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
@@ -684,7 +684,7 @@
"Creating %u records for name `%s' in zone `%s'\n",
(unsigned int) rd_count,
conv_name,
- GNUNET_NAMESTORE_z2s (&pubkey));
+ GNUNET_GNSRECORD_z2s (&pubkey));
if ( (0 == rd_count) &&
(GNUNET_NO ==
@@ -777,7 +777,7 @@
const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
const char *name,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
struct ZoneToNameCtx *ztn_ctx = cls;
struct ZoneToNameResponseMessage *ztnr_msg;
@@ -793,7 +793,7 @@
name);
res = GNUNET_YES;
name_len = (NULL == name) ? 0 : strlen (name) + 1;
- rd_ser_len = GNUNET_NAMESTORE_records_get_size (rd_count, rd);
+ rd_ser_len = GNUNET_GNSRECORD_records_get_size (rd_count, rd);
msg_size = sizeof (struct ZoneToNameResponseMessage) + name_len + rd_ser_len;
if (msg_size >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
{
@@ -814,7 +814,7 @@
if (NULL != name)
memcpy (name_tmp, name, name_len);
rd_tmp = &name_tmp[name_len];
- GNUNET_NAMESTORE_records_serialize (rd_count, rd, rd_ser_len, rd_tmp);
+ GNUNET_GNSRECORD_records_serialize (rd_count, rd, rd_ser_len, rd_tmp);
ztn_ctx->success = GNUNET_OK;
GNUNET_SERVER_notification_context_unicast (snc, ztn_ctx->nc->client,
&ztnr_msg->gns_header.header,
@@ -939,7 +939,7 @@
const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
const char *name,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
struct ZoneIterationProcResult *proc = cls;
unsigned int i;
@@ -969,8 +969,8 @@
rd);
do_refresh_block = GNUNET_NO;
for (i=0;i<rd_count;i++)
- if( (0 != (rd[i].flags & GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION)) &&
- (0 == (rd[i].flags & GNUNET_NAMESTORE_RF_PENDING)) )
+ if( (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION)) &&
+ (0 == (rd[i].flags & GNUNET_GNSRECORD_RF_PENDING)) )
{
do_refresh_block = GNUNET_YES;
break;
@@ -1201,7 +1201,7 @@
const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
const char *name,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
struct ZoneMonitor *zm = cls;
Modified: gnunet/src/namestore/namestore_api.c
===================================================================
--- gnunet/src/namestore/namestore_api.c 2013-10-16 20:14:02 UTC (rev
30232)
+++ gnunet/src/namestore/namestore_api.c 2013-10-16 20:21:27 UTC (rev
30233)
@@ -85,7 +85,7 @@
/**
* Function to call with the blocks we get back; or NULL.
*/
- GNUNET_NAMESTORE_BlockProcessor block_proc;
+ GNUNET_GNSRECORD_BlockProcessor block_proc;
/**
* Closure for @e block_proc.
@@ -271,8 +271,8 @@
const struct LookupBlockResponseMessage *msg,
size_t size)
{
- struct GNUNET_NAMESTORE_Block *block;
- char buf[size + sizeof (struct GNUNET_NAMESTORE_Block)
+ struct GNUNET_GNSRECORD_Block *block;
+ char buf[size + sizeof (struct GNUNET_GNSRECORD_Block)
- sizeof (struct LookupBlockResponseMessage)];
LOG (GNUNET_ERROR_TYPE_DEBUG,
@@ -286,7 +286,7 @@
return GNUNET_OK;
}
- block = (struct GNUNET_NAMESTORE_Block *) buf;
+ block = (struct GNUNET_GNSRECORD_Block *) buf;
block->signature = msg->signature;
block->derived_key = msg->derived_key;
block->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN);
@@ -298,7 +298,7 @@
&msg[1],
size - sizeof (struct LookupBlockResponseMessage));
if (GNUNET_OK !=
- GNUNET_NAMESTORE_block_verify (block))
+ GNUNET_GNSRECORD_block_verify (block))
{
GNUNET_break (0);
return GNUNET_SYSERR;
@@ -419,9 +419,9 @@
}
rd_tmp = &name[name_len];
{
- struct GNUNET_NAMESTORE_RecordData rd[rd_count];
+ struct GNUNET_GNSRECORD_Data rd[rd_count];
- if (GNUNET_OK != GNUNET_NAMESTORE_records_deserialize(rd_len, rd_tmp,
rd_count, rd))
+ if (GNUNET_OK != GNUNET_GNSRECORD_records_deserialize(rd_len, rd_tmp,
rd_count, rd))
{
GNUNET_break (0);
return GNUNET_SYSERR;
@@ -490,9 +490,9 @@
}
rd_tmp = &name_tmp[name_len];
{
- struct GNUNET_NAMESTORE_RecordData rd[rd_count];
+ struct GNUNET_GNSRECORD_Data rd[rd_count];
- if (GNUNET_OK != GNUNET_NAMESTORE_records_deserialize(rd_ser_len,
rd_tmp, rd_count, rd))
+ if (GNUNET_OK != GNUNET_GNSRECORD_records_deserialize(rd_ser_len,
rd_tmp, rd_count, rd))
{
GNUNET_break (0);
return GNUNET_SYSERR;
@@ -633,9 +633,9 @@
}
rd_ser_tmp = (const char *) &name_tmp[name_len];
{
- struct GNUNET_NAMESTORE_RecordData rd[rd_count];
+ struct GNUNET_GNSRECORD_Data rd[rd_count];
- if (GNUNET_OK != GNUNET_NAMESTORE_records_deserialize (rd_len,
+ if (GNUNET_OK != GNUNET_GNSRECORD_records_deserialize (rd_len,
rd_ser_tmp,
rd_count,
rd))
@@ -1020,7 +1020,7 @@
*/
struct GNUNET_NAMESTORE_QueueEntry *
GNUNET_NAMESTORE_block_cache (struct GNUNET_NAMESTORE_Handle *h,
- const struct GNUNET_NAMESTORE_Block *block,
+ const struct GNUNET_GNSRECORD_Block *block,
GNUNET_NAMESTORE_ContinuationWithStatus cont,
void *cont_cls)
{
@@ -1085,7 +1085,7 @@
const struct GNUNET_CRYPTO_EcdsaPrivateKey
*pkey,
const char *label,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd,
+ const struct GNUNET_GNSRECORD_Data *rd,
GNUNET_NAMESTORE_ContinuationWithStatus cont,
void *cont_cls)
{
@@ -1117,7 +1117,7 @@
GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, qe);
/* setup msg */
- rd_ser_len = GNUNET_NAMESTORE_records_get_size (rd_count, rd);
+ rd_ser_len = GNUNET_GNSRECORD_records_get_size (rd_count, rd);
msg_size = sizeof (struct RecordStoreMessage) + name_len + rd_ser_len;
pe = GNUNET_malloc (sizeof (struct PendingMessage) + msg_size);
pe->size = msg_size;
@@ -1135,7 +1135,7 @@
memcpy (name_tmp, label, name_len);
rd_ser = &name_tmp[name_len];
GNUNET_break (rd_ser_len ==
- GNUNET_NAMESTORE_records_serialize (rd_count, rd,
+ GNUNET_GNSRECORD_records_serialize (rd_count, rd,
rd_ser_len,
rd_ser));
LOG (GNUNET_ERROR_TYPE_DEBUG,
@@ -1162,7 +1162,7 @@
struct GNUNET_NAMESTORE_QueueEntry *
GNUNET_NAMESTORE_lookup_block (struct GNUNET_NAMESTORE_Handle *h,
const struct GNUNET_HashCode *derived_hash,
- GNUNET_NAMESTORE_BlockProcessor proc, void
*proc_cls)
+ GNUNET_GNSRECORD_BlockProcessor proc, void
*proc_cls)
{
struct GNUNET_NAMESTORE_QueueEntry *qe;
struct PendingMessage *pe;
Modified: gnunet/src/namestore/namestore_api_monitor.c
===================================================================
--- gnunet/src/namestore/namestore_api_monitor.c 2013-10-16 20:14:02 UTC
(rev 30232)
+++ gnunet/src/namestore/namestore_api_monitor.c 2013-10-16 20:21:27 UTC
(rev 30233)
@@ -186,9 +186,9 @@
}
rd_ser_tmp = (const char *) &name_tmp[name_len];
{
- struct GNUNET_NAMESTORE_RecordData rd[rd_count];
+ struct GNUNET_GNSRECORD_Data rd[rd_count];
- if (GNUNET_OK != GNUNET_NAMESTORE_records_deserialize (rd_len, rd_ser_tmp,
rd_count, rd))
+ if (GNUNET_OK != GNUNET_GNSRECORD_records_deserialize (rd_len, rd_ser_tmp,
rd_count, rd))
{
GNUNET_break (0);
reconnect (zm);
Modified: gnunet/src/namestore/plugin_namestore_postgres.c
===================================================================
--- gnunet/src/namestore/plugin_namestore_postgres.c 2013-10-16 20:14:02 UTC
(rev 30232)
+++ gnunet/src/namestore/plugin_namestore_postgres.c 2013-10-16 20:21:27 UTC
(rev 30233)
@@ -333,7 +333,7 @@
*/
static int
namestore_postgres_cache_block (void *cls,
- const struct GNUNET_NAMESTORE_Block *block)
+ const struct GNUNET_GNSRECORD_Block *block)
{
struct Plugin *plugin = cls;
struct GNUNET_HashCode query;
@@ -392,7 +392,7 @@
static int
namestore_postgres_lookup_block (void *cls,
const struct GNUNET_HashCode *query,
- GNUNET_NAMESTORE_BlockCallback iter, void
*iter_cls)
+ GNUNET_GNSRECORD_BlockCallback iter, void
*iter_cls)
{
struct Plugin *plugin = cls;
const char *paramValues[] = {
@@ -405,7 +405,7 @@
PGresult *res;
unsigned int cnt;
size_t bsize;
- const struct GNUNET_NAMESTORE_Block *block;
+ const struct GNUNET_GNSRECORD_Block *block;
res = PQexecPrepared (plugin->dbh,
"lookup_block", 1,
@@ -431,7 +431,7 @@
GNUNET_assert (1 == cnt);
GNUNET_assert (1 != PQnfields (res));
bsize = PQgetlength (res, 0, 0);
- block = (const struct GNUNET_NAMESTORE_Block *) PQgetvalue (res, 0, 0);
+ block = (const struct GNUNET_GNSRECORD_Block *) PQgetvalue (res, 0, 0);
if ( (bsize < sizeof (*block)) ||
(bsize != ntohl (block->purpose.size) +
sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey) +
@@ -465,7 +465,7 @@
const struct GNUNET_CRYPTO_EcdsaPrivateKey
*zone_key,
const char *label,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
struct Plugin *plugin = cls;
struct GNUNET_CRYPTO_EcdsaPublicKey pkey;
@@ -485,7 +485,7 @@
break;
}
rvalue = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, UINT64_MAX);
- data_size = GNUNET_NAMESTORE_records_get_size (rd_count, rd);
+ data_size = GNUNET_GNSRECORD_records_get_size (rd_count, rd);
if (data_size > 64 * 65536)
{
GNUNET_break (0);
@@ -512,7 +512,7 @@
const int paramFormats[] = { 1, 1, 1, 1, 1, 1 };
PGresult *res;
- if (data_size != GNUNET_NAMESTORE_records_serialize (rd_count, rd,
+ if (data_size != GNUNET_GNSRECORD_records_serialize (rd_count, rd,
data_size, data))
{
GNUNET_break (0);
@@ -610,13 +610,13 @@
return GNUNET_SYSERR;
}
{
- struct GNUNET_NAMESTORE_RecordData rd[record_count];
+ struct GNUNET_GNSRECORD_Data rd[record_count];
char buf[label_len + 1];
memcpy (buf, label, label_len);
buf[label_len] = '\0';
if (GNUNET_OK !=
- GNUNET_NAMESTORE_records_deserialize (data_size, data,
+ GNUNET_GNSRECORD_records_deserialize (data_size, data,
record_count, rd))
{
GNUNET_break (0);
Modified: gnunet/src/namestore/plugin_namestore_sqlite.c
===================================================================
--- gnunet/src/namestore/plugin_namestore_sqlite.c 2013-10-16 20:14:02 UTC
(rev 30232)
+++ gnunet/src/namestore/plugin_namestore_sqlite.c 2013-10-16 20:21:27 UTC
(rev 30233)
@@ -457,7 +457,7 @@
*/
static int
namestore_sqlite_cache_block (void *cls,
- const struct GNUNET_NAMESTORE_Block *block)
+ const struct GNUNET_GNSRECORD_Block *block)
{
struct Plugin *plugin = cls;
struct GNUNET_HashCode query;
@@ -580,13 +580,13 @@
static int
namestore_sqlite_lookup_block (void *cls,
const struct GNUNET_HashCode *query,
- GNUNET_NAMESTORE_BlockCallback iter, void
*iter_cls)
+ GNUNET_GNSRECORD_BlockCallback iter, void
*iter_cls)
{
struct Plugin *plugin = cls;
int ret;
int sret;
size_t block_size;
- const struct GNUNET_NAMESTORE_Block *block;
+ const struct GNUNET_GNSRECORD_Block *block;
if (SQLITE_OK != sqlite3_bind_blob (plugin->lookup_block, 1,
query, sizeof (struct GNUNET_HashCode),
@@ -605,7 +605,7 @@
{
block = sqlite3_column_blob (plugin->lookup_block, 0);
block_size = sqlite3_column_bytes (plugin->lookup_block, 0);
- if ( (block_size < sizeof (struct GNUNET_NAMESTORE_Block)) ||
+ if ( (block_size < sizeof (struct GNUNET_GNSRECORD_Block)) ||
(ntohl (block->purpose.size) +
sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey) +
sizeof (struct GNUNET_CRYPTO_EcdsaSignature) != block_size) )
@@ -660,7 +660,7 @@
const struct GNUNET_CRYPTO_EcdsaPrivateKey
*zone_key,
const char *label,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
struct Plugin *plugin = cls;
int n;
@@ -680,7 +680,7 @@
break;
}
rvalue = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, UINT64_MAX);
- data_size = GNUNET_NAMESTORE_records_get_size (rd_count, rd);
+ data_size = GNUNET_GNSRECORD_records_get_size (rd_count, rd);
if (data_size > 64 * 65536)
{
GNUNET_break (0);
@@ -689,7 +689,7 @@
{
char data[data_size];
- if (data_size != GNUNET_NAMESTORE_records_serialize (rd_count, rd,
+ if (data_size != GNUNET_GNSRECORD_records_serialize (rd_count, rd,
data_size, data))
{
GNUNET_break (0);
@@ -817,10 +817,10 @@
}
else
{
- struct GNUNET_NAMESTORE_RecordData rd[record_count];
+ struct GNUNET_GNSRECORD_Data rd[record_count];
if (GNUNET_OK !=
- GNUNET_NAMESTORE_records_deserialize (data_size, data,
+ GNUNET_GNSRECORD_records_deserialize (data_size, data,
record_count, rd))
{
GNUNET_break (0);
@@ -935,7 +935,7 @@
}
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Performing reverse lookup for `%s'\n",
- GNUNET_NAMESTORE_z2s (value_zone));
+ GNUNET_GNSRECORD_z2s (value_zone));
return get_record_and_call_iterator (plugin, stmt, zone, iter, iter_cls);
}
Modified: gnunet/src/namestore/test_namestore_api_cache_block.c
===================================================================
--- gnunet/src/namestore/test_namestore_api_cache_block.c 2013-10-16
20:14:02 UTC (rev 30232)
+++ gnunet/src/namestore/test_namestore_api_cache_block.c 2013-10-16
20:21:27 UTC (rev 30233)
@@ -94,7 +94,7 @@
static void
rd_decrypt_cb (void *cls,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
char rd_cmp_data[TEST_RECORD_DATALEN];
@@ -115,7 +115,7 @@
static void
name_lookup_proc (void *cls,
- const struct GNUNET_NAMESTORE_Block *block)
+ const struct GNUNET_GNSRECORD_Block *block)
{
const char *name = cls;
nsqe = NULL;
@@ -140,7 +140,7 @@
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Namestore returned block, decrypting \n");
- GNUNET_assert (GNUNET_OK == GNUNET_NAMESTORE_block_decrypt(block,
+ GNUNET_assert (GNUNET_OK == GNUNET_GNSRECORD_block_decrypt(block,
&pubkey, name, &rd_decrypt_cb, (void *) name));
}
@@ -158,7 +158,7 @@
(success == GNUNET_OK) ? "SUCCESS" : "FAIL");
/* Create derived hash */
- GNUNET_NAMESTORE_query_from_public_key (&pubkey, name, &derived_hash);
+ GNUNET_GNSRECORD_query_from_public_key (&pubkey, name, &derived_hash);
nsqe = GNUNET_NAMESTORE_lookup_block (nsh, &derived_hash,
&name_lookup_proc, (void *) name);
@@ -170,8 +170,8 @@
const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TESTING_Peer *peer)
{
- struct GNUNET_NAMESTORE_RecordData rd;
- struct GNUNET_NAMESTORE_Block *block;
+ struct GNUNET_GNSRECORD_Data rd;
+ struct GNUNET_GNSRECORD_Block *block;
char *hostkey_file;
const char * name = "dummy.dummy.gnunet";
@@ -193,7 +193,7 @@
rd.data_size = TEST_RECORD_DATALEN;
rd.data = GNUNET_malloc (TEST_RECORD_DATALEN);
memset ((char *) rd.data, 'a', TEST_RECORD_DATALEN);
- block = GNUNET_NAMESTORE_block_create (privkey,
+ block = GNUNET_GNSRECORD_block_create (privkey,
GNUNET_TIME_UNIT_FOREVER_ABS, name, &rd, 1 );
if (NULL == block)
{
Modified: gnunet/src/namestore/test_namestore_api_lookup_public.c
===================================================================
--- gnunet/src/namestore/test_namestore_api_lookup_public.c 2013-10-16
20:14:02 UTC (rev 30232)
+++ gnunet/src/namestore/test_namestore_api_lookup_public.c 2013-10-16
20:21:27 UTC (rev 30233)
@@ -94,7 +94,7 @@
static void
rd_decrypt_cb (void *cls,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
char rd_cmp_data[TEST_RECORD_DATALEN];
@@ -115,7 +115,7 @@
static void
name_lookup_proc (void *cls,
- const struct GNUNET_NAMESTORE_Block *block)
+ const struct GNUNET_GNSRECORD_Block *block)
{
const char *name = cls;
nsqe = NULL;
@@ -140,7 +140,7 @@
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Namestore returned block, decrypting \n");
- GNUNET_assert (GNUNET_OK == GNUNET_NAMESTORE_block_decrypt(block,
+ GNUNET_assert (GNUNET_OK == GNUNET_GNSRECORD_block_decrypt(block,
&pubkey, name, &rd_decrypt_cb, (void *) name));
}
@@ -160,7 +160,7 @@
/* Create derived hash */
GNUNET_CRYPTO_ecdsa_key_get_public (privkey, &pubkey);
- GNUNET_NAMESTORE_query_from_public_key (&pubkey, name, &derived_hash);
+ GNUNET_GNSRECORD_query_from_public_key (&pubkey, name, &derived_hash);
nsqe = GNUNET_NAMESTORE_lookup_block (nsh, &derived_hash,
&name_lookup_proc, (void *) name);
@@ -172,7 +172,7 @@
const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TESTING_Peer *peer)
{
- struct GNUNET_NAMESTORE_RecordData rd;
+ struct GNUNET_GNSRECORD_Data rd;
char *hostkey_file;
const char * name = "dummy.dummy.gnunet";
Modified: gnunet/src/namestore/test_namestore_api_monitoring.c
===================================================================
--- gnunet/src/namestore/test_namestore_api_monitoring.c 2013-10-16
20:14:02 UTC (rev 30232)
+++ gnunet/src/namestore/test_namestore_api_monitoring.c 2013-10-16
20:21:27 UTC (rev 30233)
@@ -44,15 +44,15 @@
static char * s_name_1;
-static struct GNUNET_NAMESTORE_RecordData *s_rd_1;
+static struct GNUNET_GNSRECORD_Data *s_rd_1;
static char * s_name_2;
-static struct GNUNET_NAMESTORE_RecordData *s_rd_2;
+static struct GNUNET_GNSRECORD_Data *s_rd_2;
static char * s_name_3;
-static struct GNUNET_NAMESTORE_RecordData *s_rd_3;
+static struct GNUNET_GNSRECORD_Data *s_rd_3;
struct GNUNET_NAMESTORE_QueueEntry * ns_ops[3];
@@ -148,7 +148,7 @@
const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
const char *name,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
static int returned_records;
static int fail = GNUNET_NO;
@@ -168,7 +168,7 @@
if (0 == strcmp (name, s_name_1))
{
- if (GNUNET_YES != GNUNET_NAMESTORE_records_cmp(rd, s_rd_1))
+ if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_1))
{
GNUNET_break (0);
fail = GNUNET_YES;
@@ -176,7 +176,7 @@
}
else if (0 == strcmp (name, s_name_2))
{
- if (GNUNET_YES != GNUNET_NAMESTORE_records_cmp(rd, s_rd_2))
+ if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_2))
{
GNUNET_break (0);
fail = GNUNET_YES;
@@ -234,13 +234,13 @@
}
-static struct GNUNET_NAMESTORE_RecordData *
+static struct GNUNET_GNSRECORD_Data *
create_record (unsigned int count)
{
unsigned int c;
- struct GNUNET_NAMESTORE_RecordData * rd;
+ struct GNUNET_GNSRECORD_Data * rd;
- rd = GNUNET_malloc (count * sizeof (struct GNUNET_NAMESTORE_RecordData));
+ rd = GNUNET_malloc (count * sizeof (struct GNUNET_GNSRECORD_Data));
for (c = 0; c < count; c++)
{
rd[c].expiration_time = GNUNET_TIME_relative_to_absolute
(GNUNET_TIME_UNIT_HOURS).abs_value_us;
Modified: gnunet/src/namestore/test_namestore_api_monitoring_existing.c
===================================================================
--- gnunet/src/namestore/test_namestore_api_monitoring_existing.c
2013-10-16 20:14:02 UTC (rev 30232)
+++ gnunet/src/namestore/test_namestore_api_monitoring_existing.c
2013-10-16 20:21:27 UTC (rev 30233)
@@ -45,15 +45,15 @@
static char * s_name_1;
-static struct GNUNET_NAMESTORE_RecordData *s_rd_1;
+static struct GNUNET_GNSRECORD_Data *s_rd_1;
static char * s_name_2;
-static struct GNUNET_NAMESTORE_RecordData *s_rd_2;
+static struct GNUNET_GNSRECORD_Data *s_rd_2;
static char * s_name_3;
-static struct GNUNET_NAMESTORE_RecordData *s_rd_3;
+static struct GNUNET_GNSRECORD_Data *s_rd_3;
struct GNUNET_NAMESTORE_QueueEntry * ns_ops[3];
@@ -149,7 +149,7 @@
const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
const char *name,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
static int returned_records;
static int fail = GNUNET_NO;
@@ -169,7 +169,7 @@
if (0 == strcmp (name, s_name_1))
{
- if (GNUNET_YES != GNUNET_NAMESTORE_records_cmp(rd, s_rd_1))
+ if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_1))
{
GNUNET_break (0);
fail = GNUNET_YES;
@@ -177,7 +177,7 @@
}
else if (0 == strcmp (name, s_name_2))
{
- if (GNUNET_YES != GNUNET_NAMESTORE_records_cmp(rd, s_rd_2))
+ if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_2))
{
GNUNET_break (0);
fail = GNUNET_YES;
@@ -252,13 +252,13 @@
}
-static struct GNUNET_NAMESTORE_RecordData *
+static struct GNUNET_GNSRECORD_Data *
create_record (unsigned int count)
{
unsigned int c;
- struct GNUNET_NAMESTORE_RecordData * rd;
+ struct GNUNET_GNSRECORD_Data * rd;
- rd = GNUNET_malloc (count * sizeof (struct GNUNET_NAMESTORE_RecordData));
+ rd = GNUNET_malloc (count * sizeof (struct GNUNET_GNSRECORD_Data));
for (c = 0; c < count; c++)
{
rd[c].expiration_time = GNUNET_TIME_relative_to_absolute
(GNUNET_TIME_UNIT_HOURS).abs_value_us;
Modified: gnunet/src/namestore/test_namestore_api_put.c
===================================================================
--- gnunet/src/namestore/test_namestore_api_put.c 2013-10-16 20:14:02 UTC
(rev 30232)
+++ gnunet/src/namestore/test_namestore_api_put.c 2013-10-16 20:21:27 UTC
(rev 30233)
@@ -45,7 +45,7 @@
static struct GNUNET_CRYPTO_EcdsaPublicKey pubkey;
-static struct GNUNET_NAMESTORE_RecordData *s_rd;
+static struct GNUNET_GNSRECORD_Data *s_rd;
static int res;
@@ -111,13 +111,13 @@
}
-static struct GNUNET_NAMESTORE_RecordData *
+static struct GNUNET_GNSRECORD_Data *
create_record (unsigned int count)
{
unsigned int c;
- struct GNUNET_NAMESTORE_RecordData * rd;
+ struct GNUNET_GNSRECORD_Data * rd;
- rd = GNUNET_malloc (count * sizeof (struct GNUNET_NAMESTORE_RecordData));
+ rd = GNUNET_malloc (count * sizeof (struct GNUNET_GNSRECORD_Data));
for (c = 0; c < count; c++)
{
rd[c].expiration_time = GNUNET_TIME_absolute_get().abs_value_us;
@@ -154,7 +154,7 @@
nsh = GNUNET_NAMESTORE_connect (cfg);
GNUNET_break (NULL != nsh);
/* create record */
- s_name = GNUNET_NAMESTORE_normalize_string ("DUMMY.dummy.gnunet");
+ s_name = GNUNET_GNSRECORD_string_to_lowercase ("DUMMY.dummy.gnunet");
s_rd = create_record (RECORDS);
et.abs_value_us = s_rd[0].expiration_time;
signature = GNUNET_NAMESTORE_create_signature(privkey, et, s_name, s_rd,
RECORDS);
Modified: gnunet/src/namestore/test_namestore_api_remove.c
===================================================================
--- gnunet/src/namestore/test_namestore_api_remove.c 2013-10-16 20:14:02 UTC
(rev 30232)
+++ gnunet/src/namestore/test_namestore_api_remove.c 2013-10-16 20:21:27 UTC
(rev 30233)
@@ -121,7 +121,7 @@
static void
rd_decrypt_cb (void *cls,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
const char *name = cls;
char rd_cmp_data[TEST_RECORD_DATALEN];
@@ -145,7 +145,7 @@
static void
name_lookup_proc (void *cls,
- const struct GNUNET_NAMESTORE_Block *block)
+ const struct GNUNET_GNSRECORD_Block *block)
{
const char *name = cls;
nsqe = NULL;
@@ -179,7 +179,7 @@
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Namestore returned block, decrypting \n");
GNUNET_assert (GNUNET_OK ==
- GNUNET_NAMESTORE_block_decrypt (block,
+ GNUNET_GNSRECORD_block_decrypt (block,
&pubkey, name, &rd_decrypt_cb,
(void *) name));
}
@@ -209,7 +209,7 @@
(success == GNUNET_OK) ? "SUCCESS" : "FAIL");
/* Create derived hash */
- GNUNET_NAMESTORE_query_from_private_key (privkey,
+ GNUNET_GNSRECORD_query_from_private_key (privkey,
name,
&derived_hash);
@@ -233,7 +233,7 @@
const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TESTING_Peer *peer)
{
- struct GNUNET_NAMESTORE_RecordData rd;
+ struct GNUNET_GNSRECORD_Data rd;
char *hostkey_file;
const char * name = "dummy.dummy.gnunet";
Modified: gnunet/src/namestore/test_namestore_api_store.c
===================================================================
--- gnunet/src/namestore/test_namestore_api_store.c 2013-10-16 20:14:02 UTC
(rev 30232)
+++ gnunet/src/namestore/test_namestore_api_store.c 2013-10-16 20:21:27 UTC
(rev 30233)
@@ -94,7 +94,7 @@
static void
rd_decrypt_cb (void *cls,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
char rd_cmp_data[TEST_RECORD_DATALEN];
@@ -115,7 +115,7 @@
static void
name_lookup_proc (void *cls,
- const struct GNUNET_NAMESTORE_Block *block)
+ const struct GNUNET_GNSRECORD_Block *block)
{
const char *name = cls;
nsqe = NULL;
@@ -140,7 +140,7 @@
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Namestore returned block, decrypting \n");
- GNUNET_assert (GNUNET_OK == GNUNET_NAMESTORE_block_decrypt(block,
+ GNUNET_assert (GNUNET_OK == GNUNET_GNSRECORD_block_decrypt(block,
&pubkey, name, &rd_decrypt_cb, (void *) name));
}
@@ -158,7 +158,7 @@
(success == GNUNET_OK) ? "SUCCESS" : "FAIL");
/* Create derived hash */
- GNUNET_NAMESTORE_query_from_private_key (privkey, name, &derived_hash);
+ GNUNET_GNSRECORD_query_from_private_key (privkey, name, &derived_hash);
nsqe = GNUNET_NAMESTORE_lookup_block (nsh, &derived_hash,
&name_lookup_proc, (void *) name);
@@ -170,7 +170,7 @@
const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TESTING_Peer *peer)
{
- struct GNUNET_NAMESTORE_RecordData rd;
+ struct GNUNET_GNSRECORD_Data rd;
char *hostkey_file;
const char * name = "dummy.dummy.gnunet";
Modified: gnunet/src/namestore/test_namestore_api_store_update.c
===================================================================
--- gnunet/src/namestore/test_namestore_api_store_update.c 2013-10-16
20:14:02 UTC (rev 30232)
+++ gnunet/src/namestore/test_namestore_api_store_update.c 2013-10-16
20:21:27 UTC (rev 30233)
@@ -112,9 +112,9 @@
static void
rd_decrypt_cb (void *cls,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
- struct GNUNET_NAMESTORE_RecordData rd_new;
+ struct GNUNET_GNSRECORD_Data rd_new;
GNUNET_assert (1 == rd_count);
GNUNET_assert (NULL != rd);
@@ -131,7 +131,7 @@
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Block was decrypted successfully, updating record \n");
- rd_new.flags = GNUNET_NAMESTORE_RF_NONE;
+ rd_new.flags = GNUNET_GNSRECORD_RF_NONE;
rd_new.expiration_time = GNUNET_TIME_absolute_get().abs_value_us;
rd_new.record_type = TEST_RECORD_TYPE2;
rd_new.data_size = TEST_RECORD_DATALEN2;
@@ -158,7 +158,7 @@
static void
name_lookup_proc (void *cls,
- const struct GNUNET_NAMESTORE_Block *block)
+ const struct GNUNET_GNSRECORD_Block *block)
{
const char *name = cls;
nsqe = NULL;
@@ -183,7 +183,7 @@
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Namestore returned block, decrypting \n");
- GNUNET_assert (GNUNET_OK == GNUNET_NAMESTORE_block_decrypt(block,
+ GNUNET_assert (GNUNET_OK == GNUNET_GNSRECORD_block_decrypt(block,
&pubkey, name, &rd_decrypt_cb, (void *) name));
}
@@ -202,7 +202,7 @@
(success == GNUNET_OK) ? "SUCCESS" : "FAIL");
/* Create derived hash */
- GNUNET_NAMESTORE_query_from_private_key (privkey, name, &derived_hash);
+ GNUNET_GNSRECORD_query_from_private_key (privkey, name, &derived_hash);
nsqe = GNUNET_NAMESTORE_lookup_block (nsh, &derived_hash,
&name_lookup_proc, (void *) name);
@@ -214,7 +214,7 @@
const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TESTING_Peer *peer)
{
- struct GNUNET_NAMESTORE_RecordData rd;
+ struct GNUNET_GNSRECORD_Data rd;
char *hostkey_file;
update_performed = GNUNET_NO;
@@ -230,7 +230,7 @@
GNUNET_assert (privkey != NULL);
GNUNET_CRYPTO_ecdsa_key_get_public (privkey, &pubkey);
- rd.flags = GNUNET_NAMESTORE_RF_NONE;
+ rd.flags = GNUNET_GNSRECORD_RF_NONE;
rd.expiration_time = GNUNET_TIME_absolute_get().abs_value_us;
rd.record_type = TEST_RECORD_TYPE;
rd.data_size = TEST_RECORD_DATALEN;
Modified: gnunet/src/namestore/test_namestore_api_zone_iteration.c
===================================================================
--- gnunet/src/namestore/test_namestore_api_zone_iteration.c 2013-10-16
20:14:02 UTC (rev 30232)
+++ gnunet/src/namestore/test_namestore_api_zone_iteration.c 2013-10-16
20:21:27 UTC (rev 30233)
@@ -46,15 +46,15 @@
static char * s_name_1;
-static struct GNUNET_NAMESTORE_RecordData *s_rd_1;
+static struct GNUNET_GNSRECORD_Data *s_rd_1;
static char * s_name_2;
-static struct GNUNET_NAMESTORE_RecordData *s_rd_2;
+static struct GNUNET_GNSRECORD_Data *s_rd_2;
static char * s_name_3;
-static struct GNUNET_NAMESTORE_RecordData *s_rd_3;
+static struct GNUNET_GNSRECORD_Data *s_rd_3;
/**
@@ -159,7 +159,7 @@
const struct
GNUNET_CRYPTO_EcdsaPrivateKey *zone,
const char *label,
unsigned int rd_count,
- const struct
GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
int failed = GNUNET_NO;
if ((zone == NULL) && (label == NULL))
@@ -187,7 +187,7 @@
{
if (rd_count == 1)
{
- if (GNUNET_YES != GNUNET_NAMESTORE_records_cmp(rd, s_rd_1))
+ if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_1))
{
failed = GNUNET_YES;
GNUNET_break (0);
@@ -203,7 +203,7 @@
{
if (rd_count == 1)
{
- if (GNUNET_YES != GNUNET_NAMESTORE_records_cmp(rd, s_rd_2))
+ if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_2))
{
failed = GNUNET_YES;
GNUNET_break (0);
@@ -231,7 +231,7 @@
{
if (rd_count == 1)
{
- if (GNUNET_YES != GNUNET_NAMESTORE_records_cmp(rd, s_rd_3))
+ if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_3))
{
failed = GNUNET_YES;
GNUNET_break (0);
@@ -319,13 +319,13 @@
}
-static struct GNUNET_NAMESTORE_RecordData *
+static struct GNUNET_GNSRECORD_Data *
create_record (unsigned int count)
{
unsigned int c;
- struct GNUNET_NAMESTORE_RecordData * rd;
+ struct GNUNET_GNSRECORD_Data * rd;
- rd = GNUNET_malloc (count * sizeof (struct GNUNET_NAMESTORE_RecordData));
+ rd = GNUNET_malloc (count * sizeof (struct GNUNET_GNSRECORD_Data));
for (c = 0; c < count; c++)
{
rd[c].expiration_time = GNUNET_TIME_relative_to_absolute
(GNUNET_TIME_UNIT_HOURS).abs_value_us;
@@ -348,7 +348,7 @@
const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
const char *label,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
char *hostkey_file;
Modified: gnunet/src/namestore/test_namestore_api_zone_iteration_specific_zone.c
===================================================================
--- gnunet/src/namestore/test_namestore_api_zone_iteration_specific_zone.c
2013-10-16 20:14:02 UTC (rev 30232)
+++ gnunet/src/namestore/test_namestore_api_zone_iteration_specific_zone.c
2013-10-16 20:21:27 UTC (rev 30233)
@@ -46,15 +46,15 @@
static char * s_name_1;
-static struct GNUNET_NAMESTORE_RecordData *s_rd_1;
+static struct GNUNET_GNSRECORD_Data *s_rd_1;
static char * s_name_2;
-static struct GNUNET_NAMESTORE_RecordData *s_rd_2;
+static struct GNUNET_GNSRECORD_Data *s_rd_2;
static char * s_name_3;
-static struct GNUNET_NAMESTORE_RecordData *s_rd_3;
+static struct GNUNET_GNSRECORD_Data *s_rd_3;
/**
@@ -159,7 +159,7 @@
const struct
GNUNET_CRYPTO_EcdsaPrivateKey *zone,
const char *label,
unsigned int rd_count,
- const struct
GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
int failed = GNUNET_NO;
if ((zone == NULL) && (label == NULL))
@@ -187,7 +187,7 @@
{
if (rd_count == 1)
{
- if (GNUNET_YES != GNUNET_NAMESTORE_records_cmp(rd, s_rd_1))
+ if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_1))
{
failed = GNUNET_YES;
GNUNET_break (0);
@@ -203,7 +203,7 @@
{
if (rd_count == 1)
{
- if (GNUNET_YES != GNUNET_NAMESTORE_records_cmp(rd, s_rd_2))
+ if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_2))
{
failed = GNUNET_YES;
GNUNET_break (0);
@@ -297,13 +297,13 @@
}
-static struct GNUNET_NAMESTORE_RecordData *
+static struct GNUNET_GNSRECORD_Data *
create_record (unsigned int count)
{
unsigned int c;
- struct GNUNET_NAMESTORE_RecordData * rd;
+ struct GNUNET_GNSRECORD_Data * rd;
- rd = GNUNET_malloc (count * sizeof (struct GNUNET_NAMESTORE_RecordData));
+ rd = GNUNET_malloc (count * sizeof (struct GNUNET_GNSRECORD_Data));
for (c = 0; c < count; c++)
{
rd[c].expiration_time = GNUNET_TIME_relative_to_absolute
(GNUNET_TIME_UNIT_HOURS).abs_value_us;
@@ -326,7 +326,7 @@
const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
const char *label,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
char *hostkey_file;
Modified: gnunet/src/namestore/test_namestore_api_zone_iteration_stop.c
===================================================================
--- gnunet/src/namestore/test_namestore_api_zone_iteration_stop.c
2013-10-16 20:14:02 UTC (rev 30232)
+++ gnunet/src/namestore/test_namestore_api_zone_iteration_stop.c
2013-10-16 20:21:27 UTC (rev 30233)
@@ -46,15 +46,15 @@
static char * s_name_1;
-static struct GNUNET_NAMESTORE_RecordData *s_rd_1;
+static struct GNUNET_GNSRECORD_Data *s_rd_1;
static char * s_name_2;
-static struct GNUNET_NAMESTORE_RecordData *s_rd_2;
+static struct GNUNET_GNSRECORD_Data *s_rd_2;
static char * s_name_3;
-static struct GNUNET_NAMESTORE_RecordData *s_rd_3;
+static struct GNUNET_GNSRECORD_Data *s_rd_3;
/**
@@ -159,7 +159,7 @@
const struct
GNUNET_CRYPTO_EcdsaPrivateKey *zone,
const char *label,
unsigned int rd_count,
- const struct
GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
int failed = GNUNET_NO;
if ((zone == NULL) && (label == NULL))
@@ -184,7 +184,7 @@
{
if (rd_count == 1)
{
- if (GNUNET_YES != GNUNET_NAMESTORE_records_cmp(rd, s_rd_1))
+ if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_1))
{
failed = GNUNET_YES;
GNUNET_break (0);
@@ -200,7 +200,7 @@
{
if (rd_count == 1)
{
- if (GNUNET_YES != GNUNET_NAMESTORE_records_cmp(rd, s_rd_2))
+ if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_2))
{
failed = GNUNET_YES;
GNUNET_break (0);
@@ -228,7 +228,7 @@
{
if (rd_count == 1)
{
- if (GNUNET_YES != GNUNET_NAMESTORE_records_cmp(rd, s_rd_3))
+ if (GNUNET_YES != GNUNET_GNSRECORD_records_cmp(rd, s_rd_3))
{
failed = GNUNET_YES;
GNUNET_break (0);
@@ -331,13 +331,13 @@
}
-static struct GNUNET_NAMESTORE_RecordData *
+static struct GNUNET_GNSRECORD_Data *
create_record (unsigned int count)
{
unsigned int c;
- struct GNUNET_NAMESTORE_RecordData * rd;
+ struct GNUNET_GNSRECORD_Data * rd;
- rd = GNUNET_malloc (count * sizeof (struct GNUNET_NAMESTORE_RecordData));
+ rd = GNUNET_malloc (count * sizeof (struct GNUNET_GNSRECORD_Data));
for (c = 0; c < count; c++)
{
rd[c].expiration_time = GNUNET_TIME_relative_to_absolute
(GNUNET_TIME_UNIT_HOURS).abs_value_us;
@@ -360,7 +360,7 @@
const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
const char *label,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
char *hostkey_file;
Modified: gnunet/src/namestore/test_namestore_api_zone_to_name.c
===================================================================
--- gnunet/src/namestore/test_namestore_api_zone_to_name.c 2013-10-16
20:14:02 UTC (rev 30232)
+++ gnunet/src/namestore/test_namestore_api_zone_to_name.c 2013-10-16
20:21:27 UTC (rev 30233)
@@ -100,7 +100,7 @@
struct GNUNET_TIME_Absolute expire,
const char *n,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd,
+ const struct GNUNET_GNSRECORD_Data *rd,
const struct GNUNET_CRYPTO_EcdsaSignature *signature)
{
int fail = GNUNET_NO;
@@ -184,7 +184,7 @@
GNUNET_CRYPTO_short_hash (s_name, strlen (s_name) + 1, &s_zone_value);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Using PKEY `%s' \n",
GNUNET_NAMESTORE_short_h2s (&s_zone_value));
- struct GNUNET_NAMESTORE_RecordData rd;
+ struct GNUNET_GNSRECORD_Data rd;
rd.expiration_time = GNUNET_TIME_absolute_get().abs_value_us;
rd.record_type = GNUNET_GNSRECORD_TYPE_PKEY;
rd.data_size = sizeof (struct GNUNET_CRYPTO_ShortHashCode);
Modified: gnunet/src/namestore/test_plugin_namestore.c
===================================================================
--- gnunet/src/namestore/test_plugin_namestore.c 2013-10-16 20:14:02 UTC
(rev 30232)
+++ gnunet/src/namestore/test_plugin_namestore.c 2013-10-16 20:21:27 UTC
(rev 30233)
@@ -84,7 +84,7 @@
const struct
GNUNET_CRYPTO_EcdsaPrivateKey *private_key,
const char *label,
unsigned int rd_count,
- const struct
GNUNET_NAMESTORE_RecordData *rd)
+ const struct
GNUNET_GNSRECORD_Data *rd)
{
int *idp = cls;
int id = *idp;
@@ -122,7 +122,7 @@
struct GNUNET_CRYPTO_EcdsaPrivateKey zone_private_key;
char label[64];
unsigned int rd_count = 1 + (id % 1024);
- struct GNUNET_NAMESTORE_RecordData rd[rd_count];
+ struct GNUNET_GNSRECORD_Data rd[rd_count];
struct GNUNET_CRYPTO_EcdsaSignature signature;
unsigned int i;
Modified: gnunet/src/pt/test_gns_vpn.c
===================================================================
--- gnunet/src/pt/test_gns_vpn.c 2013-10-16 20:14:02 UTC (rev 30232)
+++ gnunet/src/pt/test_gns_vpn.c 2013-10-16 20:21:27 UTC (rev 30233)
@@ -364,7 +364,7 @@
struct GNUNET_PeerIdentity id;
struct GNUNET_CRYPTO_HashAsciiEncoded peername;
struct GNUNET_CRYPTO_EddsaPrivateKey *host_key;
- struct GNUNET_NAMESTORE_RecordData rd;
+ struct GNUNET_GNSRECORD_Data rd;
char *rd_string;
char *zone_keyfile;
Modified: gnunet-gtk/src/fs/gnunet-fs-gtk.c
===================================================================
--- gnunet-gtk/src/fs/gnunet-fs-gtk.c 2013-10-16 20:14:02 UTC (rev 30232)
+++ gnunet-gtk/src/fs/gnunet-fs-gtk.c 2013-10-16 20:21:27 UTC (rev 30233)
@@ -568,7 +568,7 @@
const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
const char *label,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
GtkListStore *ls;
GtkTreeModel *tm;
Modified: gnunet-gtk/src/fs/gnunet-fs-gtk_common.c
===================================================================
--- gnunet-gtk/src/fs/gnunet-fs-gtk_common.c 2013-10-16 20:14:02 UTC (rev
30232)
+++ gnunet-gtk/src/fs/gnunet-fs-gtk_common.c 2013-10-16 20:21:27 UTC (rev
30233)
@@ -304,7 +304,7 @@
{
const char *ns_zkey;
- ns_zkey = GNUNET_NAMESTORE_pkey_to_zkey (&want);
+ ns_zkey = GNUNET_GNSRECORD_pkey_to_zkey (&want);
gtk_entry_set_text (ns_entry,
ns_zkey);
}
Modified: gnunet-gtk/src/fs/gnunet-fs-gtk_main-window-search.c
===================================================================
--- gnunet-gtk/src/fs/gnunet-fs-gtk_main-window-search.c 2013-10-16
20:14:02 UTC (rev 30232)
+++ gnunet-gtk/src/fs/gnunet-fs-gtk_main-window-search.c 2013-10-16
20:21:27 UTC (rev 30233)
@@ -110,7 +110,7 @@
static void
handle_gns_result (void *cls,
uint32_t rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
struct SearchLookup *sl = cls;
unsigned int i;
@@ -400,7 +400,7 @@
save_pseudonym_with_nick (struct PseuLookupContext *lctx,
const char *nick)
{
- struct GNUNET_NAMESTORE_RecordData rd;
+ struct GNUNET_GNSRECORD_Data rd;
struct GNUNET_GTK_MainWindowContext *main_ctx;
GNUNET_break (NULL == lctx->nick);
@@ -419,7 +419,7 @@
memset (&rd, 0, sizeof (rd));
rd.data_size = sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey);
rd.data = &lctx->pkey;
- rd.flags = GNUNET_NAMESTORE_RF_PRIVATE;
+ rd.flags = GNUNET_GNSRECORD_RF_PRIVATE;
rd.expiration_time = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
rd.record_type = GNUNET_GNSRECORD_TYPE_PKEY;
main_ctx = GNUNET_FS_GTK_get_main_context ();
@@ -539,7 +539,7 @@
static void
lookup_finished (void *cls,
uint32_t rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
struct PseuLookupContext *lctx = cls;
unsigned int i;
@@ -672,7 +672,7 @@
widget = GTK_COMBO_BOX (GNUNET_FS_GTK_get_main_window_object
("main_window_search_namespace_combobox"));
text = gtk_entry_get_text (GTK_ENTRY (gtk_bin_get_child (GTK_BIN (widget))));
- ret = GNUNET_NAMESTORE_zkey_to_pkey (text, &pkey);
+ ret = GNUNET_GNSRECORD_zkey_to_pkey (text, &pkey);
if (GNUNET_OK != ret)
{
GNUNET_break (0);
@@ -732,7 +732,7 @@
int ret;
text = gtk_entry_get_text (GTK_ENTRY (gtk_bin_get_child (GTK_BIN (widget))));
- ret = GNUNET_NAMESTORE_zkey_to_pkey (text, &pkey);
+ ret = GNUNET_GNSRECORD_zkey_to_pkey (text, &pkey);
button = GTK_BUTTON (GNUNET_FS_GTK_get_main_window_object
("GNUNET_FS_GTK_save_button"));
gtk_widget_set_visible (GTK_WIDGET (button),
Modified: gnunet-gtk/src/namestore/gnunet-namestore-gtk.c
===================================================================
--- gnunet-gtk/src/namestore/gnunet-namestore-gtk.c 2013-10-16 20:14:02 UTC
(rev 30232)
+++ gnunet-gtk/src/namestore/gnunet-namestore-gtk.c 2013-10-16 20:21:27 UTC
(rev 30233)
@@ -245,7 +245,7 @@
/**
* Record to merge.
*/
- struct GNUNET_NAMESTORE_RecordData rd;
+ struct GNUNET_GNSRECORD_Data rd;
};
@@ -439,7 +439,7 @@
pseu = gtk_entry_get_text (GTK_ENTRY(entry));
GNUNET_asprintf (&str,
"gnunet://gns/%s/%s\n",
- GNUNET_NAMESTORE_z2s (&pubkey),
+ GNUNET_GNSRECORD_z2s (&pubkey),
pseu);
if (0 != QRinput_append (qri,
QR_MODE_8,
@@ -613,7 +613,7 @@
*/
static int
check_record_permitted (unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd,
+ const struct GNUNET_GNSRECORD_Data *rd,
gint n_type)
{
unsigned int i;
@@ -800,11 +800,11 @@
static void
merge_with_existing_records (void *cls,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
struct MoveOperationContext *moc = cls;
struct EditDialogContext *edc = moc->edc;
- struct GNUNET_NAMESTORE_RecordData rd_new[rd_count + 1];
+ struct GNUNET_GNSRECORD_Data rd_new[rd_count + 1];
struct OperationContext *oc;
GNUNET_CONTAINER_DLL_remove (moc_head, moc_tail, moc);
@@ -820,7 +820,7 @@
return;
}
- memcpy (rd_new, rd, rd_count * sizeof (struct GNUNET_NAMESTORE_RecordData));
+ memcpy (rd_new, rd, rd_count * sizeof (struct GNUNET_GNSRECORD_Data));
rd_new[rd_count] = moc->rd;
/* FIXME: sanity-check merge... */
oc = GNUNET_new (struct OperationContext);
@@ -846,7 +846,7 @@
*/
static void
decrypt_block_for_merge (void *cls,
- const struct GNUNET_NAMESTORE_Block *block)
+ const struct GNUNET_GNSRECORD_Block *block)
{
struct MoveOperationContext *moc = cls;
struct GNUNET_CRYPTO_EcdsaPublicKey pubkey;
@@ -859,7 +859,7 @@
GNUNET_CRYPTO_ecdsa_key_get_public (&moc->pk,
&pubkey);
if (GNUNET_OK !=
- GNUNET_NAMESTORE_block_decrypt (block,
+ GNUNET_GNSRECORD_block_decrypt (block,
&pubkey,
moc->edc->name,
&merge_with_existing_records,
@@ -888,15 +888,15 @@
{
struct RecordInfo *ri = edc->ri;
unsigned int rd_count = (NULL == ri) ? 0 : ri->rd_count;
- struct GNUNET_NAMESTORE_RecordData rd_old[rd_count];
- struct GNUNET_NAMESTORE_RecordData rd;
+ struct GNUNET_GNSRECORD_Data rd_old[rd_count];
+ struct GNUNET_GNSRECORD_Data rd;
void *data;
size_t data_size;
struct OperationContext *oc;
if ( (NULL != ri) &&
(GNUNET_OK !=
- GNUNET_NAMESTORE_records_deserialize (ri->data_size,
+ GNUNET_GNSRECORD_records_deserialize (ri->data_size,
ri->data,
ri->rd_count,
rd_old)) )
@@ -919,15 +919,15 @@
return;
}
if (edc->n_public)
- rd.flags = GNUNET_NAMESTORE_RF_NONE;
+ rd.flags = GNUNET_GNSRECORD_RF_NONE;
else
- rd.flags = GNUNET_NAMESTORE_RF_PRIVATE;
+ rd.flags = GNUNET_GNSRECORD_RF_PRIVATE;
if (edc->n_is_shadow)
- rd.flags |= GNUNET_NAMESTORE_RF_SHADOW_RECORD;
+ rd.flags |= GNUNET_GNSRECORD_RF_SHADOW_RECORD;
rd.record_type = edc->record_type;
rd.expiration_time = edc->n_exp_time;
if (edc->n_is_relative)
- rd.flags |= GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION;
+ rd.flags |= GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
rd.data_size = data_size;
rd.data = data;
switch (ret)
@@ -936,10 +936,10 @@
if (GNUNET_YES == edc->old_record_in_namestore)
{
/* remove item from tree view and namestore */
- struct GNUNET_NAMESTORE_RecordData rd_new[rd_count - 1];
+ struct GNUNET_GNSRECORD_Data rd_new[rd_count - 1];
GNUNET_assert (NULL != ri);
- memcpy (rd_new, rd_old, (rd_count - 1) * sizeof (struct
GNUNET_NAMESTORE_RecordData));
+ memcpy (rd_new, rd_old, (rd_count - 1) * sizeof (struct
GNUNET_GNSRECORD_Data));
rd_new[edc->off] = rd_old[rd_count - 1];
oc = GNUNET_new (struct OperationContext);
GNUNET_CONTAINER_DLL_insert (oc_head, oc_tail, oc);
@@ -962,10 +962,10 @@
{
if (GNUNET_YES == edc->old_record_in_namestore)
{
- struct GNUNET_NAMESTORE_RecordData rd_new[rd_count];
+ struct GNUNET_GNSRECORD_Data rd_new[rd_count];
GNUNET_assert (NULL != ri);
- memcpy (rd_new, rd_old, rd_count * sizeof (struct
GNUNET_NAMESTORE_RecordData));
+ memcpy (rd_new, rd_old, rd_count * sizeof (struct
GNUNET_GNSRECORD_Data));
rd_new[edc->off] = rd;
oc = GNUNET_new (struct OperationContext);
GNUNET_CONTAINER_DLL_insert (oc_head, oc_tail, oc);
@@ -977,9 +977,9 @@
}
else
{
- struct GNUNET_NAMESTORE_RecordData rd_new[rd_count + 1];
+ struct GNUNET_GNSRECORD_Data rd_new[rd_count + 1];
- memcpy (rd_new, rd_old, rd_count * sizeof (struct
GNUNET_NAMESTORE_RecordData));
+ memcpy (rd_new, rd_old, rd_count * sizeof (struct
GNUNET_GNSRECORD_Data));
rd_new[rd_count] = rd;
oc = GNUNET_new (struct OperationContext);
GNUNET_CONTAINER_DLL_insert (oc_head, oc_tail, oc);
@@ -1000,7 +1000,7 @@
GNUNET_assert (NULL != edc->ego);
pk = GNUNET_IDENTITY_ego_get_private_key (edc->ego);
GNUNET_assert (NULL != pk);
- GNUNET_NAMESTORE_query_from_private_key (pk,
+ GNUNET_GNSRECORD_query_from_private_key (pk,
edc->name,
&query);
moc = GNUNET_new (struct MoveOperationContext);
@@ -1017,10 +1017,10 @@
if (GNUNET_YES == edc->old_record_in_namestore)
{
/* remove item from tree view and namestore */
- struct GNUNET_NAMESTORE_RecordData rd_new[rd_count - 1];
+ struct GNUNET_GNSRECORD_Data rd_new[rd_count - 1];
GNUNET_assert (NULL != ri);
- memcpy (rd_new, rd_old, (rd_count - 1) * sizeof (struct
GNUNET_NAMESTORE_RecordData));
+ memcpy (rd_new, rd_old, (rd_count - 1) * sizeof (struct
GNUNET_GNSRECORD_Data));
rd_new[edc->off] = rd_old[rd_count - 1];
oc = GNUNET_new (struct OperationContext);
GNUNET_CONTAINER_DLL_insert (oc_head, oc_tail, oc);
@@ -1065,19 +1065,19 @@
if ( (NULL != ri) &&
(off < ri->rd_count) )
{
- struct GNUNET_NAMESTORE_RecordData rd_old[ri->rd_count];
+ struct GNUNET_GNSRECORD_Data rd_old[ri->rd_count];
GNUNET_break (GNUNET_OK ==
- GNUNET_NAMESTORE_records_deserialize (ri->data_size,
+ GNUNET_GNSRECORD_records_deserialize (ri->data_size,
ri->data,
ri->rd_count,
rd_old));
edc->n_value = GNUNET_GNSRECORD_value_to_string (n_type,
rd_old[off].data,
rd_old[off].data_size);
- edc->n_public = (0 == (rd_old[off].flags & GNUNET_NAMESTORE_RF_PRIVATE));
- edc->n_is_relative = (0 != (rd_old[off].flags &
GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION));
- edc->n_is_shadow = (0 != (rd_old[off].flags &
GNUNET_NAMESTORE_RF_SHADOW_RECORD));
+ edc->n_public = (0 == (rd_old[off].flags & GNUNET_GNSRECORD_RF_PRIVATE));
+ edc->n_is_relative = (0 != (rd_old[off].flags &
GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION));
+ edc->n_is_shadow = (0 != (rd_old[off].flags &
GNUNET_GNSRECORD_RF_SHADOW_RECORD));
edc->n_exp_time = rd_old[off].expiration_time;
edc->old_record_in_namestore = GNUNET_YES;
}
@@ -1155,10 +1155,10 @@
check_permissions (struct RecordInfo *ri,
guint n_type)
{
- struct GNUNET_NAMESTORE_RecordData rd[ri->rd_count];
+ struct GNUNET_GNSRECORD_Data rd[ri->rd_count];
GNUNET_break (GNUNET_OK ==
- GNUNET_NAMESTORE_records_deserialize (ri->data_size,
+ GNUNET_GNSRECORD_records_deserialize (ri->data_size,
ri->data,
ri->rd_count,
rd));
@@ -1493,9 +1493,9 @@
if ( (gtk_tree_model_iter_parent (tm, &parent, &iter)) &&
(ri->rd_count > 0) )
{
- struct GNUNET_NAMESTORE_RecordData rd_old[ri->rd_count];
- struct GNUNET_NAMESTORE_RecordData rd_new[ri->rd_count - 1];
- struct GNUNET_NAMESTORE_RecordData rd;
+ struct GNUNET_GNSRECORD_Data rd_old[ri->rd_count];
+ struct GNUNET_GNSRECORD_Data rd_new[ri->rd_count - 1];
+ struct GNUNET_GNSRECORD_Data rd;
unsigned int off;
int n_type;
gboolean n_public;
@@ -1509,7 +1509,7 @@
"Removing single record for name `%s'\n",
name);
GNUNET_break (GNUNET_OK ==
- GNUNET_NAMESTORE_records_deserialize (ri->data_size,
+ GNUNET_GNSRECORD_records_deserialize (ri->data_size,
ri->data,
ri->rd_count,
rd_old));
@@ -1523,13 +1523,13 @@
-1);
/* valid name */
if (n_public)
- rd.flags = GNUNET_NAMESTORE_RF_NONE;
+ rd.flags = GNUNET_GNSRECORD_RF_NONE;
else
- rd.flags = GNUNET_NAMESTORE_RF_PRIVATE;
+ rd.flags = GNUNET_GNSRECORD_RF_PRIVATE;
if (n_is_relative)
- rd.flags |= GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION;
+ rd.flags |= GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
if (n_is_shadow)
- rd.flags |= GNUNET_NAMESTORE_RF_SHADOW_RECORD;
+ rd.flags |= GNUNET_GNSRECORD_RF_SHADOW_RECORD;
rd.record_type = n_type;
rd.expiration_time = n_exp_time;
if (GNUNET_OK !=
@@ -1544,11 +1544,11 @@
}
for (off=0;off<ri->rd_count;off++)
if (GNUNET_YES ==
- GNUNET_NAMESTORE_records_cmp (&rd,
+ GNUNET_GNSRECORD_records_cmp (&rd,
&rd_old[off]))
break;
GNUNET_assert (off != ri->rd_count);
- memcpy (rd_new, rd_old, (ri->rd_count - 1) * sizeof (struct
GNUNET_NAMESTORE_RecordData));
+ memcpy (rd_new, rd_old, (ri->rd_count - 1) * sizeof (struct
GNUNET_GNSRECORD_Data));
rd_new[off] = rd_old[ri->rd_count - 1];
oc = GNUNET_new (struct OperationContext);
GNUNET_CONTAINER_DLL_insert (oc_head, oc_tail, oc);
@@ -1626,19 +1626,19 @@
/* get old records, append new one or update/remove existing one */
{
- struct GNUNET_NAMESTORE_RecordData rd_old[rd_count];
- struct GNUNET_NAMESTORE_RecordData rd_new[rd_count + 1];
+ struct GNUNET_GNSRECORD_Data rd_old[rd_count];
+ struct GNUNET_GNSRECORD_Data rd_new[rd_count + 1];
unsigned int off;
unsigned int total;
total = rd_count;
if (NULL != ri)
GNUNET_break (GNUNET_OK ==
- GNUNET_NAMESTORE_records_deserialize (ri->data_size,
+ GNUNET_GNSRECORD_records_deserialize (ri->data_size,
ri->data,
rd_count,
rd_old));
- memcpy (rd_new, rd_old, sizeof (struct GNUNET_NAMESTORE_RecordData) *
rd_count);
+ memcpy (rd_new, rd_old, sizeof (struct GNUNET_GNSRECORD_Data) * rd_count);
for (off=0;off<rd_count;off++)
if (GNUNET_GNSRECORD_TYPE_PSEU == rd_new[off].record_type)
break;
@@ -1654,7 +1654,7 @@
{
rd_new[off].record_type = GNUNET_GNSRECORD_TYPE_PSEU;
rd_new[off].expiration_time = UINT64_MAX;
- rd_new[off].flags = GNUNET_NAMESTORE_RF_NONE;
+ rd_new[off].flags = GNUNET_GNSRECORD_RF_NONE;
rd_new[off].data_size = strlen (pseu) + 1;
rd_new[off].data = pseu;
}
@@ -1690,7 +1690,7 @@
return;
cb = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
gtk_clipboard_set_text (cb,
- GNUNET_NAMESTORE_z2s (&pubkey),
+ GNUNET_GNSRECORD_z2s (&pubkey),
-1);
}
@@ -1736,7 +1736,7 @@
const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
const char *name,
unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+ const struct GNUNET_GNSRECORD_Data *rd)
{
GtkTreeRowReference *rr;
GtkTreePath *path;
@@ -1838,11 +1838,11 @@
/* update record info serialized version of the records */
GNUNET_free_non_null (ri->data);
ri->rd_count = rd_count;
- ri->data_size = GNUNET_NAMESTORE_records_get_size (rd_count, rd);
+ ri->data_size = GNUNET_GNSRECORD_records_get_size (rd_count, rd);
if (0 != ri->data_size)
ri->data = GNUNET_malloc (ri->data_size);
GNUNET_break (ri->data_size ==
- GNUNET_NAMESTORE_records_serialize (rd_count, rd,
+ GNUNET_GNSRECORD_records_serialize (rd_count, rd,
ri->data_size, ri->data));
/* Append elements for records in tree view */
@@ -1855,9 +1855,9 @@
rd[c].data_size);
/* Set public toggle */
- public = ((rd[c].flags & GNUNET_NAMESTORE_RF_PRIVATE) !=
GNUNET_NAMESTORE_RF_PRIVATE);
+ public = ((rd[c].flags & GNUNET_GNSRECORD_RF_PRIVATE) !=
GNUNET_GNSRECORD_RF_PRIVATE);
/* Expiration time */
- time_is_relative = (0 != (rd[c].flags &
GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION));
+ time_is_relative = (0 != (rd[c].flags &
GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION));
if (time_is_relative)
{
@@ -1975,7 +1975,7 @@
*pkey = *GNUNET_IDENTITY_ego_get_private_key (ego);
GNUNET_CRYPTO_ecdsa_key_get_public (pkey, &pubkey);
label = g_markup_printf_escaped (_("<b>Editing zone %s</b>"),
- GNUNET_NAMESTORE_z2s (&pubkey));
+ GNUNET_GNSRECORD_z2s (&pubkey));
gtk_label_set_markup (GTK_LABEL (get_object
("gnunet_namestore_gtk_zone_label")),
label);
g_free (label);
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [GNUnet-SVN] r30233 - gnunet/src/conversation gnunet/src/gns gnunet/src/gnsrecord gnunet/src/include gnunet/src/namecache gnunet/src/namestore gnunet/src/pt gnunet-gtk/src/fs gnunet-gtk/src/namestore,
gnunet <=