-another renaming fest for GNUNET_NAMESTORE_ to GNUNET_GNSRECORD_ symbols that were moved

5 files changed, 55 insertions, 55 deletions

diff --git a/src/gnsrecord/gnsrecord_crypto.c b/src/gnsrecord/gnsrecord_crypto.c
index 823ffcae3..99a97dcdd 100644
--- a/src/gnsrecord/gnsrecord_crypto.c
+++ b/src/gnsrecord/gnsrecord_crypto.c
@@ -78,30 +78,30 @@ derive_block_aes_key (struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
  * @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 @@ GNUNET_NAMESTORE_block_create (const struct GNUNET_CRYPTO_EcdsaPrivateKey *key,
  * @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 @@ GNUNET_NAMESTORE_block_verify (const struct GNUNET_NAMESTORE_Block *block)
  *        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 @@ GNUNET_NAMESTORE_block_decrypt (const struct GNUNET_NAMESTORE_Block *block,
       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 @@ GNUNET_NAMESTORE_block_decrypt (const struct GNUNET_NAMESTORE_Block *block,
  * @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 @@ GNUNET_NAMESTORE_query_from_private_key (const struct GNUNET_CRYPTO_EcdsaPrivate
  * @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)
 {
diff --git a/src/gnsrecord/gnsrecord_misc.c b/src/gnsrecord/gnsrecord_misc.c
index 7d73af376..aee1f9fd2 100644
--- a/src/gnsrecord/gnsrecord_misc.c
+++ b/src/gnsrecord/gnsrecord_misc.c
@@ -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 @@ GNUNET_NAMESTORE_normalize_string (const char *src)
  * 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 @@ GNUNET_NAMESTORE_z2s (const struct GNUNET_CRYPTO_EcdsaPublicKey *z)
  * @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 @@ GNUNET_NAMESTORE_records_cmp (const struct GNUNET_NAMESTORE_RecordData *a,
          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 @@ GNUNET_NAMESTORE_records_cmp (const struct GNUNET_NAMESTORE_RecordData *a,
  * @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 @@ GNUNET_NAMESTORE_record_get_expiration_time (unsigned int rd_count,
   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_NAMESTORE_record_get_expiration_time (unsigned int rd_count,
  *         #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 @@ GNUNET_NAMESTORE_is_expired (const struct GNUNET_NAMESTORE_RecordData *rd)
  *         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 @@ GNUNET_NAMESTORE_pkey_to_zkey (const struct GNUNET_CRYPTO_EcdsaPublicKey *pkey)
  * @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;
diff --git a/src/gnsrecord/gnsrecord_serialization.c b/src/gnsrecord/gnsrecord_serialization.c
index 0fd10b3e0..4b54bd366 100644
--- a/src/gnsrecord/gnsrecord_serialization.c
+++ b/src/gnsrecord/gnsrecord_serialization.c
@@ -77,12 +77,12 @@ GNUNET_NETWORK_STRUCT_END
  * 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 @@ GNUNET_NAMESTORE_records_get_size (unsigned int rd_count,
  * 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 @@ GNUNET_NAMESTORE_records_serialize (unsigned int rd_count,
  * @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;
diff --git a/src/gnsrecord/test_gnsrecord_crypto.c b/src/gnsrecord/test_gnsrecord_crypto.c
index 345bf353b..91bafdf21 100644
--- a/src/gnsrecord/test_gnsrecord_crypto.c
+++ b/src/gnsrecord/test_gnsrecord_crypto.c
@@ -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 @@ create_record (int count)
 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 @@ static void
 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 @@ run (void *cls, char *const *args, const char *cfgfile,
   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);
 }
diff --git a/src/gnsrecord/test_gnsrecord_serialization.c b/src/gnsrecord/test_gnsrecord_serialization.c
index de6a7ba1d..7ef2f1559 100644
--- a/src/gnsrecord/test_gnsrecord_serialization.c
+++ b/src/gnsrecord/test_gnsrecord_serialization.c
@@ -39,9 +39,9 @@ run (void *cls, char *const *args, const char *cfgfile,
 
   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 @@ run (void *cls, char *const *args, const char *cfgfile,
   }
   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);