#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_constants.h"
+#include "gnunet_signatures.h"
#include "gnunet_arm_service.h"
#include "gnunet_namestore_service.h"
#include "namestore.h"
/**
* Serialize the given records to the given destination buffer.
*
- * @param rd_cound number of records in the rd array
+ * @param rd_count number of records in the rd array
* @param rd array of GNUNET_NAMESTORE_RecordData with rd_count elements
* @param dest_size size of the destination array
* @param dest where to write the result
return off;
}
+/**
+ * Compares if two records are equal
+ *
+ * @param a record
+ * @param b record
+ *
+ * @return GNUNET_YES or GNUNET_NO
+ */
+int
+GNUNET_NAMESTORE_records_cmp (const struct GNUNET_NAMESTORE_RecordData *a,
+ const struct GNUNET_NAMESTORE_RecordData *b)
+{
+ if ((a->record_type == b->record_type) &&
+ (a->expiration.abs_value == b->expiration.abs_value) &&
+ (a->data_size == b->data_size) &&
+ (0 == memcmp (a->data, b->data, a->data_size)))
+ return GNUNET_YES;
+ else
+ return GNUNET_NO;
+}
+
/**
* Deserialize the given records to the given destination.
*
* @param len size of the serialized record data
* @param src the serialized record data
- * @param rd_cound number of records in the rd array
+ * @param rd_count number of records in the rd array
* @param dest where to put the data
*
* @return GNUNET_OK on success, GNUNET_SYSERR on error
dest[i].flags = ntohl (rec.flags);
off += sizeof (rec);
- if (off + sizeof (dest[i].data_size) > len)
+ if (off + dest[i].data_size > len)
return GNUNET_SYSERR;
dest[i].data = &src[off];
off += dest[i].data_size;
return GNUNET_OK;
}
-
-
-#if 0
-
-/**
- * Serialize an array of GNUNET_NAMESTORE_RecordData *rd to transmit over the
- * network
- *
- * @param dest where to write the serialized data
- * @param rd_count number of elements in array
- * @param rd array
- *
- * @return number of bytes written to destination dest
- */
-size_t
-GNUNET_NAMESTORE_records_serialize (char ** dest,
- unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
-{
- //size_t len = 0;
- struct GNUNET_NAMESTORE_NetworkRecord nr;
- char * d = (*dest);
- int c = 0;
- int offset;
-
- GNUNET_assert (rd != NULL);
-
- size_t total_len = rd_count * sizeof (struct GNUNET_NAMESTORE_NetworkRecord);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Struct size: %u\n", total_len);
-
- /* figure out total len required */
- for (c = 0; c < rd_count; c ++)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Data size record[%i] : %u\n", c, rd[c].data_size);
- total_len += rd[c].data_size;
- }
-
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Serializing %i records with total length of %llu\n", rd_count, total_len);
-
- (*dest) = GNUNET_malloc (total_len);
- d = (*dest);
-
- /* copy records */
- offset = 0;
-
- for (c = 0; c < rd_count; c ++)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Serialized record [%i]: data_size %i\n", c,rd[c].data_size);
-
- // nr = (struct GNUNET_NAMESTORE_NetworkRecord *) &d[offset];
- nr.data_size = htonl (rd[c].data_size);
- nr.flags = htonl (rd[c].flags);
- nr.record_type = htonl (rd[c].record_type);
- nr.expiration = GNUNET_TIME_absolute_hton(rd[c].expiration);
- memcpy (&d[offset], &nr, sizeof (nr));
- offset += sizeof (struct GNUNET_NAMESTORE_NetworkRecord);
-
- /*put data here */
- memcpy (&d[offset], rd[c].data, rd[c].data_size);
- offset += rd[c].data_size;
- }
-
- GNUNET_assert (offset == total_len);
- return total_len;
-}
-
-void
-GNUNET_NAMESTORE_records_free (unsigned int rd_count, struct GNUNET_NAMESTORE_RecordData *rd)
-{
- int c;
- if ((rd == NULL) || (rd_count == 0))
- return;
-
- for (c = 0; c < rd_count; c++)
- GNUNET_free_non_null ((void *) rd[c].data);
- GNUNET_free (rd);
-}
-
-
/**
- * Deserialize an array of GNUNET_NAMESTORE_RecordData *rd after transmission
- * over the network
+ * Sign name and records
*
- * @param source where to read the data to deserialize
- * @param rd_count number of elements in array
- * @param rd array
+ * @param key the private key
+ * @param name the name
+ * @param rd record data
+ * @param rd_count number of records
*
- * @return number of elements deserialized
+ * @return the signature
*/
-int
-GNUNET_NAMESTORE_records_deserialize ( struct GNUNET_NAMESTORE_RecordData **dest, char *src, size_t len)
+struct GNUNET_CRYPTO_RsaSignature *
+GNUNET_NAMESTORE_create_signature (const struct GNUNET_CRYPTO_RsaPrivateKey *key,
+ const char *name,
+ struct GNUNET_NAMESTORE_RecordData *rd,
+ unsigned int rd_count)
{
- struct GNUNET_NAMESTORE_NetworkRecord * nr;
- struct GNUNET_NAMESTORE_RecordData *d = (*dest);
- int elements;
- size_t offset;
- uint32_t data_size;
- int c;
-
- if (len == 0)
+ struct GNUNET_CRYPTO_RsaSignature *sig = GNUNET_malloc(sizeof (struct GNUNET_CRYPTO_RsaSignature));
+ struct GNUNET_CRYPTO_RsaSignaturePurpose *sig_purpose;
+ size_t rd_ser_len;
+ size_t name_len;
+ char * name_tmp;
+ char * rd_tmp;
+ int res;
+
+ if (name == NULL)
{
- (*dest) = NULL;
- return 0;
+ GNUNET_break (0);
+ GNUNET_free (sig);
+ return NULL;
}
+ name_len = strlen (name) + 1;
- offset = 0;
- elements = 0;
- while (offset < len)
- {
- nr = (struct GNUNET_NAMESTORE_NetworkRecord *) &src[offset];
- offset += sizeof (struct GNUNET_NAMESTORE_NetworkRecord);
+ rd_ser_len = GNUNET_NAMESTORE_records_get_size(rd_count, rd);
+ char rd_ser[rd_ser_len];
+ GNUNET_NAMESTORE_records_serialize(rd_count, rd, rd_ser_len, rd_ser);
- data_size = ntohl (nr->data_size);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Datasize record[%i]: %u\n", elements, data_size);
- offset += data_size;
- elements ++;
- }
-
- if (elements == 0)
- {
- (*dest) = NULL;
- return 0;
- }
+ sig_purpose = GNUNET_malloc(sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) + rd_ser_len + name_len);
+ sig_purpose->size = htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose)+ rd_ser_len + name_len);
+ sig_purpose->purpose = htonl (GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN);
+ name_tmp = (char *) &sig_purpose[1];
+ rd_tmp = &name_tmp[name_len];
+ memcpy (name_tmp, name, name_len);
+ memcpy (rd_tmp, rd_ser, rd_ser_len);
- GNUNET_assert (len == offset);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Deserializing %i records with total length of %u\n", elements, len);
+ res = GNUNET_CRYPTO_rsa_sign (key, sig_purpose, sig);
- (*dest) = GNUNET_malloc (elements * sizeof (struct GNUNET_NAMESTORE_RecordData));
- d = (*dest);
+ GNUNET_free (sig_purpose);
- offset = 0;
- for (c = 0; c < elements; c++)
+ if (GNUNET_OK != res)
{
- nr = (struct GNUNET_NAMESTORE_NetworkRecord *) &src[offset];
- d[c].expiration = GNUNET_TIME_absolute_ntoh(nr->expiration);
- d[c].record_type = ntohl (nr->record_type);
- d[c].flags = ntohl (nr->flags);
- d[c].data_size = ntohl (nr->data_size);
- if (d[c].data_size > 0)
- d[c].data = GNUNET_malloc (d[c].data_size);
- else
- d[c].data = NULL;
-
- offset += sizeof (struct GNUNET_NAMESTORE_NetworkRecord);
- memcpy((char *) d[c].data, &src[offset], d[c].data_size);
-
- offset += d[c].data_size;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Deserialized record[%i] /w data_size %i\n", c, d[c].data_size);
+ GNUNET_break (0);
+ GNUNET_free (sig);
+ return NULL;
}
- GNUNET_assert(offset == len);
-
- return elements;
+ return sig;
}
-#endif
-
/* end of namestore_api.c */
projects / oweals / gnunet.git / blobdiff