static int
testArithmetic ()
{
static struct GNUNET_CRYPTO_AesSessionKey zskey;
static struct GNUNET_CRYPTO_AesInitializationVector ziv;
struct GNUNET_HashCode h1;
struct GNUNET_HashCode h2;
struct GNUNET_HashCode d;
struct GNUNET_HashCode s;
struct GNUNET_CRYPTO_AesSessionKey skey;
struct GNUNET_CRYPTO_AesInitializationVector iv;
GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &h1);
GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &h2);
if (GNUNET_CRYPTO_hash_distance_u32 (&h1, &h2) !=
GNUNET_CRYPTO_hash_distance_u32 (&h2, &h1))
return 1;
GNUNET_CRYPTO_hash_difference (&h1, &h2, &d);
GNUNET_CRYPTO_hash_sum (&h1, &d, &s);
if (0 != GNUNET_CRYPTO_hash_cmp (&s, &h2))
return 1;
GNUNET_CRYPTO_hash_xor (&h1, &h2, &d);
GNUNET_CRYPTO_hash_xor (&h1, &d, &s);
if (0 != GNUNET_CRYPTO_hash_cmp (&s, &h2))
return 1;
if (0 != GNUNET_CRYPTO_hash_xorcmp (&s, &h2, &h1))
return 1;
if (-1 != GNUNET_CRYPTO_hash_xorcmp (&h1, &h2, &h1))
return 1;
if (1 != GNUNET_CRYPTO_hash_xorcmp (&h1, &h2, &h2))
return 1;
memset (&d, 0xF0, sizeof (d));
if (0 != GNUNET_CRYPTO_hash_get_bit (&d, 3))
return 1;
if (1 != GNUNET_CRYPTO_hash_get_bit (&d, 6))
return 1;
memset (&d, 0, sizeof (d));
GNUNET_CRYPTO_hash_to_aes_key (&d, &skey, &iv);
if ((0 != memcmp (&skey, &zskey, sizeof (skey) - sizeof (unsigned int))) ||
(0 != memcmp (&iv, &ziv, sizeof (iv))))
return 1;
return 0;
}
/**
* Function used to put all records successively into the DHT.
*
* @param cls the closure (NULL)
* @param key the public key of the authority (ours)
* @param expiration lifetime of the namestore entry
* @param name the name of the records
* @param rd_count the number of records in data
* @param rd the record data
* @param signature the signature for the record data
*/
static void
put_gns_record(void *cls,
const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
struct GNUNET_TIME_Absolute expiration,
const char *name,
unsigned int rd_count,
const struct GNUNET_NAMESTORE_RecordData *rd,
const struct GNUNET_CRYPTO_RsaSignature *signature)
{
struct GNSNameRecordBlock *nrb;
struct GNUNET_CRYPTO_ShortHashCode name_hash;
struct GNUNET_CRYPTO_ShortHashCode zhash;
GNUNET_HashCode xor_hash;
GNUNET_HashCode name_hash_double;
GNUNET_HashCode zone_hash_double;
uint32_t rd_payload_length;
char* nrb_data = NULL;
size_t namelen;
/* we're done */
if (NULL == name)
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"Zone iteration finished. Rescheduling put in %ds\n",
dht_max_update_interval);
zone_update_taskid = GNUNET_SCHEDULER_add_delayed (
GNUNET_TIME_relative_multiply(
GNUNET_TIME_UNIT_SECONDS,
dht_max_update_interval
),
&update_zone_dht_start,
NULL);
return;
}
namelen = strlen(name) + 1;
if (signature == NULL)
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
"No signature for %s record data provided! Skipping...\n",
name);
zone_update_taskid = GNUNET_SCHEDULER_add_now (&update_zone_dht_next,
NULL);
return;
}
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"Putting records for %s into the DHT\n", name);
rd_payload_length = GNUNET_NAMESTORE_records_get_size (rd_count, rd);
nrb = GNUNET_malloc(rd_payload_length + namelen
+ sizeof(struct GNSNameRecordBlock));
nrb->signature = *signature;
nrb->public_key = *key;
nrb->rd_count = htonl(rd_count);
memcpy(&nrb[1], name, namelen);
nrb_data = (char*)&nrb[1];
nrb_data += namelen;
rd_payload_length += sizeof(struct GNSNameRecordBlock) + namelen;
if (-1 == GNUNET_NAMESTORE_records_serialize (rd_count,
rd,
rd_payload_length,
nrb_data))
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
"Record serialization failed! Skipping...\n");
GNUNET_free(nrb);
zone_update_taskid = GNUNET_SCHEDULER_add_now (&update_zone_dht_next,
NULL);
return;
}
/*
* calculate DHT key: H(name) xor H(pubkey)
*/
GNUNET_CRYPTO_short_hash(key,
sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
&zhash);
GNUNET_CRYPTO_short_hash(name, strlen(name), &name_hash);
GNUNET_CRYPTO_short_hash_double (&name_hash, &name_hash_double);
GNUNET_CRYPTO_short_hash_double (&zhash, &zone_hash_double);
GNUNET_CRYPTO_hash_xor(&zone_hash_double, &name_hash_double, &xor_hash);
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"zone identity: %s\n", GNUNET_h2s (&zone_hash_double));
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"putting records for %s under key: %s with size %d\n",
name, GNUNET_h2s (&xor_hash), rd_payload_length);
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"DHT req to %d\n", DHT_OPERATION_TIMEOUT.rel_value);
/* FIXME: keep return value to possibly cancel? */
GNUNET_DHT_put (dht_handle, &xor_hash,
DHT_GNS_REPLICATION_LEVEL,
GNUNET_DHT_RO_NONE,
GNUNET_BLOCK_TYPE_GNS_NAMERECORD,
rd_payload_length,
(char*)nrb,
expiration,
DHT_OPERATION_TIMEOUT,
&record_dht_put,
NULL); //cls for cont
num_public_records++;
/**
* Reschedule periodic put
*/
zone_update_taskid = GNUNET_SCHEDULER_add_delayed (record_put_interval,
&update_zone_dht_next,
NULL);
GNUNET_free(nrb);
}
