/**
* Continuation called to notify client about result of the remove
* operation for the UBlock.
*
* @param cls the 'struct GNUNET_FS_UnindexContext *'
* @param success GNUNET_SYSERR on failure (including timeout/queue drop)
* GNUNET_NO if content was already there
* GNUNET_YES (or other positive value) on success
* @param min_expiration minimum expiration time required for 0-priority content to be stored
* by the datacache at this time, zero for unknown, forever if we have no
* space for 0-priority content
* @param msg NULL on success, otherwise an error message
*/
static void
continue_after_remove (void *cls,
int32_t success,
struct GNUNET_TIME_Absolute min_expiration,
const char *msg)
{
struct GNUNET_FS_UnindexContext *uc = cls;
uc->dqe = NULL;
if (success != GNUNET_YES)
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
_("Failed to remove UBlock: %s\n"),
msg);
GNUNET_CONTAINER_multihashmap_clear (uc->seen_dh);
uc->ksk_offset++;
GNUNET_FS_unindex_do_remove_kblocks_ (uc);
}
/**
*
* Update all ID_TOKEN records for an identity and store them
*
* @param cls the identity entry
* @param zone the identity
* @param lbl the name of the record
* @param rd_count number of records
* @param rd record data
*
*/
static void
token_collect (void *cls,
const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
const char *lbl,
unsigned int rd_count,
const struct GNUNET_GNSRECORD_Data *rd)
{
struct EgoEntry *ego_entry = cls;
if (NULL == lbl)
{
//Done
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
">>> Updating Ego finished\n");
//Clear attribute map for ego
GNUNET_CONTAINER_multihashmap_iterate (ego_entry->attr_map,
&clear_ego_attrs,
ego_entry);
GNUNET_CONTAINER_multihashmap_clear (ego_entry->attr_map);
GNUNET_SCHEDULER_add_now (&update_identities, ego_entry->next);
return;
}
//There should be only a single record for a token under a label
if ((1 != rd_count)
|| (rd->record_type != GNUNET_GNSRECORD_TYPE_ID_TOKEN)
|| (0 == (GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION & rd->flags)))
{
GNUNET_NAMESTORE_zone_iterator_next (ns_it);
return;
}
token = GNUNET_GNSRECORD_value_to_string (rd->record_type,
rd->data,
rd->data_size);
label = GNUNET_strdup (lbl);
GNUNET_SCHEDULER_add_now (&handle_token_update, ego_entry);
}
/**
* 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);
}
