static int
testMap (int i)
{
struct GNUNET_CONTAINER_MultiHashMap *m;
GNUNET_HashCode k1;
GNUNET_HashCode k2;
const char *ret;
int j;
CHECK (NULL != (m = GNUNET_CONTAINER_multihashmap_create (i)));
memset (&k1, 0, sizeof (k1));
memset (&k2, 1, sizeof (k2));
CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains (m, &k1));
CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains (m, &k2));
CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_remove (m, &k1, NULL));
CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_remove (m, &k2, NULL));
CHECK (NULL == GNUNET_CONTAINER_multihashmap_get (m, &k1));
CHECK (NULL == GNUNET_CONTAINER_multihashmap_get (m, &k2));
CHECK (0 == GNUNET_CONTAINER_multihashmap_remove_all (m, &k1));
CHECK (0 == GNUNET_CONTAINER_multihashmap_size (m));
CHECK (0 == GNUNET_CONTAINER_multihashmap_iterate (m, NULL, NULL));
CHECK (0 == GNUNET_CONTAINER_multihashmap_get_multiple (m, &k1, NULL, NULL));
CHECK (GNUNET_OK ==
GNUNET_CONTAINER_multihashmap_put (m, &k1, "v1",
GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
CHECK (1 == GNUNET_CONTAINER_multihashmap_size (m));
ret = GNUNET_CONTAINER_multihashmap_get (m, &k1);
GNUNET_assert (ret != NULL);
CHECK (0 == strcmp ("v1", ret));
CHECK (GNUNET_NO ==
GNUNET_CONTAINER_multihashmap_put (m, &k1, "v1",
GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
CHECK (1 == GNUNET_CONTAINER_multihashmap_size (m));
CHECK (GNUNET_OK ==
GNUNET_CONTAINER_multihashmap_put (m, &k1, "v2",
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
CHECK (GNUNET_OK ==
GNUNET_CONTAINER_multihashmap_put (m, &k1, "v3",
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
CHECK (3 == GNUNET_CONTAINER_multihashmap_size (m));
CHECK (GNUNET_OK == GNUNET_CONTAINER_multihashmap_remove (m, &k1, "v3"));
CHECK (2 == GNUNET_CONTAINER_multihashmap_size (m));
CHECK (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (m, &k1));
CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains (m, &k2));
CHECK (2 == GNUNET_CONTAINER_multihashmap_get_multiple (m, &k1, NULL, NULL));
CHECK (0 == GNUNET_CONTAINER_multihashmap_get_multiple (m, &k2, NULL, NULL));
CHECK (2 == GNUNET_CONTAINER_multihashmap_iterate (m, NULL, NULL));
CHECK (2 == GNUNET_CONTAINER_multihashmap_remove_all (m, &k1));
for (j = 0; j < 1024; j++)
CHECK (GNUNET_OK ==
GNUNET_CONTAINER_multihashmap_put (m, &k1, "v2",
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
GNUNET_CONTAINER_multihashmap_destroy (m);
return 0;
}
static int
peer_it (void *cls,
const struct GNUNET_HashCode * key,
void *value)
{
struct PeerIteratorContext *ip_ctx = cls;
struct GNUNET_PeerIdentity tmp;
if (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains(ip_ctx->peers_returned, key))
{
GNUNET_CONTAINER_multihashmap_put(ip_ctx->peers_returned, key, NULL, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
tmp.hashPubKey = (*key);
ip_ctx->it (ip_ctx->it_cls, &tmp);
}
return GNUNET_OK;
}
static void
run (void *cls,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
struct GNUNET_HashCode id;
struct IBF_Key ibf_key;
int i;
int side;
int res;
struct GNUNET_TIME_Absolute start_time;
struct GNUNET_TIME_Relative delta_time;
set_a = GNUNET_CONTAINER_multihashmap_create (((asize == 0) ? 1 : (asize + csize)),
GNUNET_NO);
set_b = GNUNET_CONTAINER_multihashmap_create (((bsize == 0) ? 1 : (bsize + csize)),
GNUNET_NO);
set_c = GNUNET_CONTAINER_multihashmap_create (((csize == 0) ? 1 : csize),
GNUNET_NO);
key_to_hashcode = GNUNET_CONTAINER_multihashmap_create (((asize+bsize+csize == 0) ? 1 : (asize+bsize+csize)),
GNUNET_NO);
printf ("hash-num=%u, size=%u, #(A-B)=%u, #(B-A)=%u, #(A&B)=%u\n",
hash_num, ibf_size, asize, bsize, csize);
i = 0;
while (i < asize)
{
GNUNET_CRYPTO_hash_create_random (random_quality, &id);
if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_a, &id))
continue;
GNUNET_break (GNUNET_OK ==
GNUNET_CONTAINER_multihashmap_put (set_a, &id, NULL,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
register_hashcode (&id);
i++;
}
i = 0;
while (i < bsize)
{
GNUNET_CRYPTO_hash_create_random (random_quality, &id);
if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_a, &id))
continue;
if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_b, &id))
continue;
GNUNET_break (GNUNET_OK ==
GNUNET_CONTAINER_multihashmap_put (set_b, &id, NULL,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
register_hashcode (&id);
i++;
}
i = 0;
while (i < csize)
{
GNUNET_CRYPTO_hash_create_random (random_quality, &id);
if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_a, &id))
continue;
if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_b, &id))
continue;
if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_c, &id))
continue;
GNUNET_break (GNUNET_OK ==
GNUNET_CONTAINER_multihashmap_put (set_c, &id, NULL,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
register_hashcode (&id);
i++;
}
ibf_a = ibf_create (ibf_size, hash_num);
ibf_b = ibf_create (ibf_size, hash_num);
if ( (NULL == ibf_a) ||
(NULL == ibf_b) )
{
/* insufficient memory */
GNUNET_break (0);
GNUNET_SCHEDULER_shutdown ();
return;
}
printf ("generated sets\n");
start_time = GNUNET_TIME_absolute_get ();
GNUNET_CONTAINER_multihashmap_iterate (set_a, &insert_iterator, ibf_a);
GNUNET_CONTAINER_multihashmap_iterate (set_b, &insert_iterator, ibf_b);
GNUNET_CONTAINER_multihashmap_iterate (set_c, &insert_iterator, ibf_a);
GNUNET_CONTAINER_multihashmap_iterate (set_c, &insert_iterator, ibf_b);
delta_time = GNUNET_TIME_absolute_get_duration (start_time);
printf ("encoded in: %s\n",
GNUNET_STRINGS_relative_time_to_string (delta_time,
GNUNET_NO));
ibf_subtract (ibf_a, ibf_b);
start_time = GNUNET_TIME_absolute_get ();
for (i = 0; i <= asize + bsize; i++)
{
res = ibf_decode (ibf_a, &side, &ibf_key);
if (GNUNET_SYSERR == res)
{
printf ("decode failed, %u/%u elements left\n",
GNUNET_CONTAINER_multihashmap_size (set_a) + GNUNET_CONTAINER_multihashmap_size (set_b),
asize + bsize);
return;
}
if (GNUNET_NO == res)
{
if ((0 == GNUNET_CONTAINER_multihashmap_size (set_b)) &&
(0 == GNUNET_CONTAINER_multihashmap_size (set_a)))
{
delta_time = GNUNET_TIME_absolute_get_duration (start_time);
printf ("decoded successfully in: %s\n",
GNUNET_STRINGS_relative_time_to_string (delta_time,
GNUNET_NO));
}
else
{
printf ("decode missed elements (should never happen)\n");
}
return;
}
if (side == 1)
iter_hashcodes (ibf_key, remove_iterator, set_a);
if (side == -1)
iter_hashcodes (ibf_key, remove_iterator, set_b);
}
printf("cyclic IBF, %u/%u elements left\n",
GNUNET_CONTAINER_multihashmap_size (set_a) + GNUNET_CONTAINER_multihashmap_size (set_b),
asize + bsize);
}
/**
* Jump to the next edge, with the longest matching token.
*
* @param block Block found in the DHT.
* @param size Size of the block.
* @param ctx Context of the search.
*/
static void
regex_next_edge (const struct RegexBlock *block,
size_t size,
struct RegexSearchContext *ctx)
{
struct RegexSearchContext *new_ctx;
struct REGEX_INTERNAL_Search *info = ctx->info;
struct GNUNET_DHT_GetHandle *get_h;
struct GNUNET_HashCode *hash;
const char *rest;
int result;
LOG (GNUNET_ERROR_TYPE_DEBUG, "Next edge\n");
/* Find the longest match for the current string position,
* among tokens in the given block */
ctx->longest_match = 0;
result = REGEX_BLOCK_iterate (block, size,
®ex_edge_iterator, ctx);
GNUNET_break (GNUNET_OK == result);
/* Did anything match? */
if (0 == ctx->longest_match)
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"no match in block\n");
return;
}
hash = &ctx->hash;
new_ctx = GNUNET_new (struct RegexSearchContext);
new_ctx->info = info;
new_ctx->position = ctx->position + ctx->longest_match;
GNUNET_array_append (info->contexts, info->n_contexts, new_ctx);
/* Check whether we already have a DHT GET running for it */
if (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap_contains (info->dht_get_handles, hash))
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"GET for %s running, END\n",
GNUNET_h2s (hash));
GNUNET_CONTAINER_multihashmap_get_multiple (info->dht_get_results,
hash,
®ex_result_iterator,
new_ctx);
return; /* We are already looking for it */
}
GNUNET_STATISTICS_update (info->stats, "# regex nodes traversed",
1, GNUNET_NO);
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Following edges at %s for offset %u in `%s'\n",
GNUNET_h2s (hash),
(unsigned int) ctx->position,
info->description);
rest = &new_ctx->info->description[new_ctx->position];
get_h =
GNUNET_DHT_get_start (info->dht, /* handle */
GNUNET_BLOCK_TYPE_REGEX, /* type */
hash, /* key to search */
DHT_REPLICATION, /* replication level */
DHT_OPT,
rest, /* xquery */
strlen (rest) + 1, /* xquery bits */
&dht_get_string_handler, new_ctx);
if (GNUNET_OK !=
GNUNET_CONTAINER_multihashmap_put(info->dht_get_handles,
hash,
get_h,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
{
GNUNET_break (0);
return;
}
}
/**
* This function updates the old token with new attributes,
* removes deleted attributes and expiration times.
*
* @param cls the ego entry
* @param tc task context
*/
static void
handle_token_update (void *cls,
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
char *token_header;
char *token_payload;
char *token_payload_json;
char *new_token;
char *new_payload_str;
char *new_payload_base64;
char *sig_str;
char *key;
char *padding;
const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key;
struct EgoEntry *ego_entry = cls;
struct GNUNET_GNSRECORD_Data token_record;
struct GNUNET_CRYPTO_EccSignaturePurpose *purpose;
struct GNUNET_CRYPTO_EcdsaSignature sig;
struct GNUNET_HashCode key_hash;
struct GNUNET_TIME_Relative token_rel_exp;
struct GNUNET_TIME_Relative token_ttl;
struct GNUNET_TIME_Absolute token_exp;
struct GNUNET_TIME_Absolute token_nbf;
struct GNUNET_TIME_Absolute new_exp;
struct GNUNET_TIME_Absolute new_iat;
struct GNUNET_TIME_Absolute new_nbf;
json_t *payload_json;
json_t *value;
json_t *cur_value;
json_t *new_payload_json;
json_t *token_nbf_json;
json_t *token_exp_json;
json_error_t json_err;
priv_key = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
//Note: We need the token expiration time here. Not the record expiration
//time.
//There are two types of tokens: Token that expire on GNS level with
//an absolute expiration time. Those are basically tokens that will
//be automatically revoked on (record)expiration.
//Tokens stored with relative expiration times will expire on the token level (token expiration)
//but this service will reissue new tokens that can be retrieved from GNS
//automatically.
token_header = strtok (token, ".");
token_payload = strtok (NULL, ".");
GNUNET_STRINGS_base64_decode (token_payload,
strlen (token_payload),
&token_payload_json);
payload_json = json_loads (token_payload_json, JSON_DECODE_ANY, &json_err);
GNUNET_free (token_payload_json);
token_exp_json = json_object_get (payload_json, "exp");
token_nbf_json = json_object_get (payload_json, "nbf");
token_exp.abs_value_us = json_integer_value(token_exp_json);
token_nbf.abs_value_us = json_integer_value(token_nbf_json);
token_rel_exp = GNUNET_TIME_absolute_get_difference (token_nbf, token_exp);
token_ttl = GNUNET_TIME_absolute_get_remaining (token_exp);
if (0 != GNUNET_TIME_absolute_get_remaining (token_exp).rel_value_us)
{
//This token is not yet expired! Save and skip
if (min_rel_exp.rel_value_us > token_ttl.rel_value_us)
{
min_rel_exp = token_ttl;
}
json_decref (payload_json);
GNUNET_free (token);
token = NULL;
GNUNET_free (label);
label = NULL;
GNUNET_NAMESTORE_zone_iterator_next (ns_it);
return;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Token is expired. Create a new one\n");
new_exp = GNUNET_TIME_relative_to_absolute (token_rel_exp);
new_nbf = GNUNET_TIME_absolute_get ();
new_iat = new_nbf;
new_payload_json = json_object();
json_object_foreach(payload_json, key, value) {
if (0 == strcmp (key, "exp"))
{
json_object_set_new (new_payload_json, key, json_integer (new_exp.abs_value_us));
}
else if (0 == strcmp (key, "nbf"))
{
json_object_set_new (new_payload_json, key, json_integer (new_nbf.abs_value_us));
}
else if (0 == strcmp (key, "iat"))
{
json_object_set_new (new_payload_json, key, json_integer (new_iat.abs_value_us));
}
else if ((0 == strcmp (key, "iss"))
|| (0 == strcmp (key, "aud"))
|| (0 == strcmp (key, "sub"))
|| (0 == strcmp (key, "rnl")))
{
json_object_set (new_payload_json, key, value);
}
else {
GNUNET_CRYPTO_hash (key,
strlen (key),
&key_hash);
//Check if attr still exists. omit of not
if (GNUNET_NO != GNUNET_CONTAINER_multihashmap_contains (ego_entry->attr_map,
&key_hash))
{
cur_value = GNUNET_CONTAINER_multihashmap_get (ego_entry->attr_map,
&key_hash);
json_object_set (new_payload_json, key, cur_value);
}
}
}
// reassemble and set
new_payload_str = json_dumps (new_payload_json, JSON_COMPACT);
json_decref (payload_json);
json_decref (new_payload_json);
GNUNET_STRINGS_base64_encode (new_payload_str,
strlen (new_payload_str),
&new_payload_base64);
//Remove padding
padding = strtok(new_payload_base64, "=");
while (NULL != padding)
padding = strtok(NULL, "=");
GNUNET_asprintf (&new_token, "%s,%s", token_header, new_payload_base64);
purpose =
GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
strlen (new_token));
purpose->size =
htonl (strlen (new_token) + sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose));
purpose->purpose = htonl(GNUNET_SIGNATURE_PURPOSE_GNUID_TOKEN);
memcpy (&purpose[1], new_token, strlen (new_token));
if (GNUNET_OK != GNUNET_CRYPTO_ecdsa_sign (priv_key,
purpose,
&sig))
GNUNET_break(0);
GNUNET_free (new_token);
sig_str = GNUNET_STRINGS_data_to_string_alloc (&sig,
sizeof (struct GNUNET_CRYPTO_EcdsaSignature));
GNUNET_asprintf (&new_token, "%s.%s.%s",
token_header, new_payload_base64, sig_str);
GNUNET_free (sig_str);
GNUNET_free (new_payload_str);
GNUNET_free (new_payload_base64);
GNUNET_free (purpose);
token_record.data = new_token;
token_record.data_size = strlen (new_token);
token_record.expiration_time = new_exp.abs_value_us;
token_record.record_type = GNUNET_GNSRECORD_TYPE_ID_TOKEN;
token_record.flags = GNUNET_GNSRECORD_RF_NONE | GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
ns_qe = GNUNET_NAMESTORE_records_store (ns_handle,
priv_key,
label,
1,
&token_record,
&store_token_cont,
ego_entry);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, ">>> Updating Token w/ %s\n", new_token);
GNUNET_free (new_token);
GNUNET_free (token);
token = NULL;
GNUNET_free (label);
label = NULL;
}
/**
* Function called from datastore with result from us looking for
* a UBlock. There are four cases:
* 1) no result, means we move on to the next keyword
* 2) UID is the same as the first UID, means we move on to next keyword
* 3) UBlock for a different CHK, means we keep looking for more
* 4) UBlock is for our CHK, means we remove the block and then move
* on to the next keyword
*
* @param cls the 'struct GNUNET_FS_UnindexContext *'
* @param key key for the content
* @param size number of bytes in data
* @param data content stored
* @param type type of the content
* @param priority priority of the content
* @param anonymity anonymity-level for the content
* @param expiration expiration time for the content
* @param uid unique identifier for the datum;
* maybe 0 if no unique identifier is available
*/
static void
process_kblock_for_unindex (void *cls,
const struct GNUNET_HashCode *key,
size_t size,
const void *data,
enum GNUNET_BLOCK_Type type,
uint32_t priority,
uint32_t anonymity,
struct GNUNET_TIME_Absolute expiration,
uint64_t uid)
{
struct GNUNET_FS_UnindexContext *uc = cls;
const struct UBlock *ub;
struct GNUNET_FS_Uri *chk_uri;
struct GNUNET_HashCode query;
struct GNUNET_HashCode dh;
uc->dqe = NULL;
if (NULL == data)
{
/* no result */
GNUNET_CONTAINER_multihashmap_clear (uc->seen_dh);
uc->ksk_offset++;
GNUNET_FS_unindex_do_remove_kblocks_ (uc);
return;
}
GNUNET_CRYPTO_hash (data,
size,
&dh);
if (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap_contains (uc->seen_dh,
&dh))
{
GNUNET_CONTAINER_multihashmap_clear (uc->seen_dh);
uc->ksk_offset++;
GNUNET_FS_unindex_do_remove_kblocks_ (uc);
return;
}
GNUNET_assert (GNUNET_OK ==
GNUNET_CONTAINER_multihashmap_put (uc->seen_dh,
&dh,
uc,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
GNUNET_assert (GNUNET_BLOCK_TYPE_FS_UBLOCK == type);
if (size < sizeof (struct UBlock))
{
GNUNET_break (0);
goto get_next;
}
ub = data;
GNUNET_CRYPTO_hash (&ub->verification_key,
sizeof (ub->verification_key),
&query);
if (0 != memcmp (&query,
key,
sizeof (struct GNUNET_HashCode)))
{
/* result does not match our keyword, skip */
goto get_next;
}
{
char pt[size - sizeof (struct UBlock)];
struct GNUNET_CRYPTO_EcdsaPublicKey anon_pub;
const char *keyword;
GNUNET_CRYPTO_ecdsa_key_get_public (GNUNET_CRYPTO_ecdsa_key_get_anonymous (),
&anon_pub);
keyword = &uc->ksk_uri->data.ksk.keywords[uc->ksk_offset][1];
GNUNET_FS_ublock_decrypt_ (&ub[1], size - sizeof (struct UBlock),
&anon_pub,
keyword,
pt);
if (NULL == memchr (&pt[1], 0, sizeof (pt) - 1))
{
GNUNET_break_op (0); /* malformed UBlock */
goto get_next;
}
chk_uri = GNUNET_FS_uri_parse (&pt[1], NULL);
if (NULL == chk_uri)
{
GNUNET_break_op (0); /* malformed UBlock */
goto get_next;
}
}
if (0 != memcmp (&uc->chk,
&chk_uri->data.chk.chk,
sizeof (struct ContentHashKey)))
{
/* different CHK, ignore */
GNUNET_FS_uri_destroy (chk_uri);
goto get_next;
}
GNUNET_FS_uri_destroy (chk_uri);
/* matches! */
uc->dqe = GNUNET_DATASTORE_remove (uc->dsh,
key,
size,
data,
0 /* priority */,
1 /* queue size */,
GNUNET_TIME_UNIT_FOREVER_REL,
&continue_after_remove,
uc);
return;
get_next:
uc->dqe = GNUNET_DATASTORE_get_key (uc->dsh,
uc->roff++,
&uc->uquery,
GNUNET_BLOCK_TYPE_FS_UBLOCK,
0 /* priority */,
1 /* queue size */,
GNUNET_TIME_UNIT_FOREVER_REL,
&process_kblock_for_unindex,
uc);
}