{
struct MutationEvent *mut;
int is_present;
+ unsigned int i;
- if (NULL == ee->mutations)
- return GNUNET_YES;
+ GNUNET_assert (NULL != ee->mutations);
if (GNUNET_YES == is_excluded_generation (query_generation, excluded, excluded_size))
{
return GNUNET_NO;
}
- is_present = GNUNET_YES;
+ is_present = GNUNET_NO;
- // Could be made faster with binary search, but lists
- // are small, so why bother.
- for (mut = ee->mutations; 0 != mut->generation; mut++)
+ /* Could be made faster with binary search, but lists
+ are small, so why bother. */
+ for (i = 0; i < ee->mutations_size; i++)
{
- if ( (mut->generation > query_generation) ||
- (GNUNET_YES == is_excluded_generation (mut->generation, excluded, excluded_size)) )
+ mut = &ee->mutations[i];
+
+ if (mut->generation > query_generation)
{
+ /* The mutation doesn't apply to our generation
+ anymore. We can'b break here, since mutations aren't
+ sorted by generation. */
continue;
}
- // This would be an inconsistency in how we manage mutations.
+ if (GNUNET_YES == is_excluded_generation (mut->generation, excluded, excluded_size))
+ {
+ /* The generation is excluded (because it belongs to another
+ fork via a lazy copy) and thus mutations aren't considered
+ for membership testing. */
+ continue;
+ }
+
+ /* This would be an inconsistency in how we manage mutations. */
if ( (GNUNET_YES == is_present) && (GNUNET_YES == mut->added) )
GNUNET_assert (0);
+ /* Likewise. */
+ if ( (GNUNET_NO == is_present) && (GNUNET_NO == mut->added) )
+ GNUNET_assert (0);
+
is_present = mut->added;
}
- return GNUNET_YES;
+ return is_present;
}
}
+static int
+is_element_of_iteration (struct ElementEntry *ee,
+ struct Set *set)
+{
+ return is_element_of_generation (ee,
+ set->iter_generation,
+ set->excluded_generations,
+ set->excluded_generations_size);
+}
+
+
int
_GSS_is_element_of_operation (struct ElementEntry *ee,
struct Operation *op)
}
{
struct SetContent *content;
+ struct PendingMutation *pm;
+ struct PendingMutation *pm_current;
content = set->content;
+
+ // discard any pending mutations that reference this set
+ pm = content->pending_mutations_head;
+ while (NULL != pm)
+ {
+ pm_current = pm;
+ pm = pm->next;
+ if (pm_current-> set == set)
+ GNUNET_CONTAINER_DLL_remove (content->pending_mutations_head,
+ content->pending_mutations_tail,
+ pm_current);
+
+ }
+
set->content = NULL;
GNUNET_assert (0 != content->refcount);
content->refcount -= 1;
NULL);
GNUNET_CONTAINER_multihashmap_destroy (content->elements);
content->elements = NULL;
+ GNUNET_free (content);
}
}
GNUNET_free_non_null (set->excluded_generations);
sets_tail,
set);
- // FIXME: remove from lazy copy requests
+ // remove set from pending copy requests
+ {
+ struct LazyCopyRequest *lcr;
+ lcr = lazy_copy_head;
+ while (NULL != lcr)
+ {
+ struct LazyCopyRequest *lcr_current;
+ lcr_current = lcr;
+ lcr = lcr->next;
+ if (lcr_current->source_set == set)
+ GNUNET_CONTAINER_DLL_remove (lazy_copy_head,
+ lazy_copy_tail,
+ lcr_current);
+ }
+ }
GNUNET_free (set);
}
}
+static void
+execute_add (struct Set *set,
+ const struct GNUNET_MessageHeader *m)
+{
+ const struct GNUNET_SET_ElementMessage *msg;
+ struct GNUNET_SET_Element el;
+ struct ElementEntry *ee;
+ struct GNUNET_HashCode hash;
+
+ GNUNET_assert (GNUNET_MESSAGE_TYPE_SET_ADD == ntohs (m->type));
+
+ msg = (const struct GNUNET_SET_ElementMessage *) m;
+ el.size = ntohs (m->size) - sizeof *msg;
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Client inserts element of size %u\n",
+ el.size);
+ el.data = &msg[1];
+ GNUNET_CRYPTO_hash (el.data,
+ el.size,
+ &hash);
+
+ ee = GNUNET_CONTAINER_multihashmap_get (set->content->elements,
+ &hash);
+
+ if (NULL == ee)
+ {
+ ee = GNUNET_malloc (el.size + sizeof *ee);
+ ee->element.size = el.size;
+ memcpy (&ee[1],
+ el.data,
+ el.size);
+ ee->element.data = &ee[1];
+ ee->remote = GNUNET_NO;
+ ee->mutations = NULL;
+ ee->mutations_size = 0;
+ ee->element_hash = hash;
+ }
+ else if (GNUNET_YES == _GSS_is_element_of_set (ee, set))
+ {
+ /* same element inserted twice */
+ return;
+ }
+
+ {
+ struct MutationEvent mut = {
+ .generation = set->current_generation,
+ .added = GNUNET_YES
+ };
+ GNUNET_array_append (ee->mutations, ee->mutations_size, mut);
+ }
+
+ GNUNET_break (GNUNET_YES ==
+ GNUNET_CONTAINER_multihashmap_put (set->content->elements,
+ &ee->element_hash,
+ ee,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+ set->vt->add (set->state, ee);
+}
+
+
+static void
+execute_remove (struct Set *set,
+ const struct GNUNET_MessageHeader *m)
+{
+ const struct GNUNET_SET_ElementMessage *msg;
+ struct GNUNET_SET_Element el;
+ struct ElementEntry *ee;
+ struct GNUNET_HashCode hash;
+
+ GNUNET_assert (GNUNET_MESSAGE_TYPE_SET_REMOVE == ntohs (m->type));
+
+ msg = (const struct GNUNET_SET_ElementMessage *) m;
+ el.size = ntohs (m->size) - sizeof *msg;
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Client removes element of size %u\n",
+ el.size);
+ el.data = &msg[1];
+ GNUNET_CRYPTO_hash (el.data,
+ el.size,
+ &hash);
+ ee = GNUNET_CONTAINER_multihashmap_get (set->content->elements,
+ &hash);
+ if (NULL == ee)
+ {
+ /* Client tried to remove non-existing element. */
+ return;
+ }
+ if (GNUNET_NO == _GSS_is_element_of_set (ee, set))
+ {
+ /* Client tried to remove element twice */
+ return;
+ }
+ else
+ {
+ struct MutationEvent mut = {
+ .generation = set->current_generation,
+ .added = GNUNET_NO
+ };
+ GNUNET_array_append (ee->mutations, ee->mutations_size, mut);
+ }
+ set->vt->remove (set->state, ee);
+}
+
+
+
+static void
+execute_mutation (struct Set *set,
+ const struct GNUNET_MessageHeader *m)
+{
+ switch (ntohs (m->type))
+ {
+ case GNUNET_MESSAGE_TYPE_SET_ADD:
+ execute_add (set, m);
+ break;
+ case GNUNET_MESSAGE_TYPE_SET_REMOVE:
+ execute_remove (set, m);
+ break;
+ default:
+ GNUNET_break (0);
+ }
+}
+
+
+
/**
* Send the next element of a set to the set's client. The next element is given by
* the set's current hashmap iterator. The set's iterator will be set to NULL if there
struct GNUNET_SET_IterResponseMessage *msg;
GNUNET_assert (NULL != set->iter);
+
+again:
+
ret = GNUNET_CONTAINER_multihashmap_iterator_next (set->iter,
NULL,
(const void **) &ee);
if (GNUNET_NO == ret)
{
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Iteration on %p done.\n",
+ (void *) set);
ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SET_ITER_DONE);
GNUNET_CONTAINER_multihashmap_iterator_destroy (set->iter);
set->iter = NULL;
set->iteration_id++;
+
+ GNUNET_assert (set->content->iterator_count > 0);
+ set->content->iterator_count -= 1;
+
+ if (0 == set->content->iterator_count)
+ {
+ while (NULL != set->content->pending_mutations_head)
+ {
+ struct PendingMutation *pm;
+
+ pm = set->content->pending_mutations_head;
+ GNUNET_CONTAINER_DLL_remove (set->content->pending_mutations_head,
+ set->content->pending_mutations_tail,
+ pm);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Executing pending mutation on %p.\n",
+ (void *) pm->set);
+ execute_mutation (pm->set, pm->mutation_message);
+ GNUNET_free (pm->mutation_message);
+ GNUNET_free (pm);
+ }
+ }
+
}
else
{
GNUNET_assert (NULL != ee);
+
+ if (GNUNET_NO == is_element_of_iteration (ee, set))
+ goto again;
+
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Sending iteration element on %p.\n",
+ (void *) set);
ev = GNUNET_MQ_msg_extra (msg,
ee->element.size,
GNUNET_MESSAGE_TYPE_SET_ITER_ELEMENT);
return;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Iterating set with %u elements\n",
+ "Iterating set %p in gen %u with %u content elements\n",
+ (void *) set,
+ set->current_generation,
GNUNET_CONTAINER_multihashmap_size (set->content->elements));
GNUNET_SERVER_receive_done (client,
GNUNET_OK);
+ set->content->iterator_count += 1;
set->iter = GNUNET_CONTAINER_multihashmap_iterator_create (set->content->elements);
+ set->iter_generation = set->current_generation;
send_client_element (set);
}
}
+
/**
- * Called when a client wants to add an element to a set it inhabits.
+ * Called when a client wants to add or remove an element to a set it inhabits.
*
* @param cls unused
* @param client client that sent the message
* @param m message sent by the client
*/
static void
-handle_client_add (void *cls,
- struct GNUNET_SERVER_Client *client,
- const struct GNUNET_MessageHeader *m)
+handle_client_mutation (void *cls,
+ struct GNUNET_SERVER_Client *client,
+ const struct GNUNET_MessageHeader *m)
{
struct Set *set;
- const struct GNUNET_SET_ElementMessage *msg;
- struct GNUNET_SET_Element el;
- struct ElementEntry *ee;
- struct GNUNET_HashCode hash;
set = set_get (client);
if (NULL == set)
GNUNET_SERVER_client_disconnect (client);
return;
}
+
GNUNET_SERVER_receive_done (client,
GNUNET_OK);
- msg = (const struct GNUNET_SET_ElementMessage *) m;
- el.size = ntohs (m->size) - sizeof *msg;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Client inserts element of size %u\n",
- el.size);
- el.data = &msg[1];
- GNUNET_CRYPTO_hash (el.data,
- el.size,
- &hash);
- ee = GNUNET_CONTAINER_multihashmap_get (set->content->elements,
- &hash);
-
- if (NULL == ee)
+ if (0 != set->content->iterator_count)
{
- ee = GNUNET_malloc (el.size + sizeof *ee);
- ee->element.size = el.size;
- memcpy (&ee[1],
- el.data,
- el.size);
- ee->element.data = &ee[1];
- ee->remote = GNUNET_NO;
- ee->mutations = NULL;
- ee->mutations_size = 0;
- ee->element_hash = hash;
- } else if (GNUNET_YES == _GSS_is_element_of_set (ee, set)) {
- /* same element inserted twice */
- GNUNET_break (0);
- return;
- }
-
- if (0 != set->current_generation)
- {
- struct MutationEvent mut = {
- .generation = set->current_generation,
- .added = GNUNET_YES
- };
- GNUNET_array_append (ee->mutations, ee->mutations_size, mut);
- ee->mutations_size += 1;
- }
-
- GNUNET_break (GNUNET_YES ==
- GNUNET_CONTAINER_multihashmap_put (set->content->elements,
- &ee->element_hash,
- ee,
- GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
- set->vt->add (set->state, ee);
-}
+ struct PendingMutation *pm;
-
-/**
- * Called when a client wants to remove an element from a set it
- * inhabits.
- *
- * @param cls unused
- * @param client client that sent the message
- * @param m message sent by the client
- */
-static void
-handle_client_remove (void *cls,
- struct GNUNET_SERVER_Client *client,
- const struct GNUNET_MessageHeader *m)
-{
- struct Set *set;
- const struct GNUNET_SET_ElementMessage *msg;
- struct GNUNET_SET_Element el;
- struct ElementEntry *ee;
- struct GNUNET_HashCode hash;
-
- set = set_get (client);
- if (NULL == set)
- {
- /* client without a set requested an operation */
- GNUNET_break (0);
- GNUNET_SERVER_client_disconnect (client);
- return;
- }
- GNUNET_SERVER_receive_done (client,
- GNUNET_OK);
- msg = (const struct GNUNET_SET_ElementMessage *) m;
- el.size = ntohs (m->size) - sizeof *msg;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Client removes element of size %u\n",
- el.size);
- el.data = &msg[1];
- GNUNET_CRYPTO_hash (el.data,
- el.size,
- &hash);
- ee = GNUNET_CONTAINER_multihashmap_get (set->content->elements,
- &hash);
- if (NULL == ee)
- {
- /* Client tried to remove non-existing element */
- GNUNET_break (0);
- return;
- }
- if (GNUNET_NO == _GSS_is_element_of_set (ee, set))
- {
- /* Client tried to remove element twice */
- GNUNET_break (0);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Scheduling mutation on set\n");
+
+ pm = GNUNET_new (struct PendingMutation);
+ pm->mutation_message = GNUNET_copy_message (m);
+ pm->set = set;
+ GNUNET_CONTAINER_DLL_insert (set->content->pending_mutations_head,
+ set->content->pending_mutations_tail,
+ pm);
return;
}
- else if (0 == set->current_generation)
- {
- // If current_generation is 0, then there are no running set operations
- // or lazy copies, thus we can safely remove the element.
- (void) GNUNET_CONTAINER_multihashmap_remove_all (set->content->elements, &hash);
- }
- else
- {
- struct MutationEvent mut = {
- .generation = set->current_generation,
- .added = GNUNET_NO
- };
- GNUNET_array_append (ee->mutations, ee->mutations_size, mut);
- ee->mutations_size += 1;
- }
- set->vt->remove (set->state, ee);
-}
+ execute_mutation (set, m);
+}
/**
GNUNET_array_append (set->excluded_generations,
set->excluded_generations_size,
r);
-
- set->excluded_generations_size += 1;
}
/**
{
struct Set *set;
struct LazyCopyRequest *cr;
+ struct GNUNET_MQ_Envelope *ev;
+ struct GNUNET_SET_CopyLazyResponseMessage *resp_msg;
set = set_get (client);
if (NULL == set)
GNUNET_CONTAINER_DLL_insert (lazy_copy_head,
lazy_copy_tail,
cr);
+
+
+ ev = GNUNET_MQ_msg (resp_msg,
+ GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_RESPONSE);
+ resp_msg->cookie = cr->cookie;
+ GNUNET_MQ_send (set->client_mq, ev);
+
+
GNUNET_SERVER_receive_done (client,
GNUNET_OK);
+
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Client requested lazy copy\n");
}
GNUNET_break (0);
GNUNET_free (set);
GNUNET_free (cr);
+ GNUNET_SERVER_client_disconnect (client);
return;
}
set->operation = cr->source_set->operation;
- set->state = set->vt->copy_state (set);
+ set->state = set->vt->copy_state (cr->source_set);
set->content = cr->source_set->content;
set->content->refcount += 1;
+
+ set->current_generation = cr->source_set->current_generation;
+ set->excluded_generations_size = cr->source_set->excluded_generations_size;
+ set->excluded_generations = GNUNET_memdup (cr->source_set->excluded_generations,
+ set->excluded_generations_size * sizeof (struct GenerationRange));
+
+ /* Advance the generation of the new set, so that mutations to the
+ of the cloned set and the source set are independent. */
+ advance_generation (set);
+
+
set->client = client;
set->client_mq = GNUNET_MQ_queue_for_server_client (client);
GNUNET_CONTAINER_DLL_insert (sets_head,
GNUNET_SERVER_receive_done (client,
GNUNET_OK);
+
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Client connected to lazy set\n");
}
{ &handle_client_iter_ack, NULL,
GNUNET_MESSAGE_TYPE_SET_ITER_ACK,
sizeof (struct GNUNET_SET_IterAckMessage) },
- { &handle_client_add, NULL,
+ { &handle_client_mutation, NULL,
GNUNET_MESSAGE_TYPE_SET_ADD,
0},
{ &handle_client_create_set, NULL,
{ &handle_client_reject, NULL,
GNUNET_MESSAGE_TYPE_SET_REJECT,
sizeof (struct GNUNET_SET_RejectMessage)},
- { &handle_client_remove, NULL,
+ { &handle_client_mutation, NULL,
GNUNET_MESSAGE_TYPE_SET_REMOVE,
0},
{ &handle_client_cancel, NULL,
{ &dispatch_p2p_message, GNUNET_MESSAGE_TYPE_SET_P2P_OPERATION_REQUEST, 0},
{ &dispatch_p2p_message, GNUNET_MESSAGE_TYPE_SET_UNION_P2P_IBF, 0},
{ &dispatch_p2p_message, GNUNET_MESSAGE_TYPE_SET_P2P_ELEMENTS, 0},
- { &dispatch_p2p_message, GNUNET_MESSAGE_TYPE_SET_UNION_P2P_DONE, 0},
+ { &dispatch_p2p_message, GNUNET_MESSAGE_TYPE_SET_UNION_P2P_OFFER, 0},
+ { &dispatch_p2p_message, GNUNET_MESSAGE_TYPE_SET_UNION_P2P_INQUIRY, 0},
+ { &dispatch_p2p_message, GNUNET_MESSAGE_TYPE_SET_UNION_P2P_DEMAND, 0},
{ &dispatch_p2p_message, GNUNET_MESSAGE_TYPE_SET_P2P_ELEMENT_REQUESTS, 0},
+ { &dispatch_p2p_message, GNUNET_MESSAGE_TYPE_SET_UNION_P2P_DONE, 0},
{ &dispatch_p2p_message, GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SE, 0},
{ &dispatch_p2p_message, GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_ELEMENT_INFO, 0},
{ &dispatch_p2p_message, GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_BF, 0},
projects / oweals / gnunet.git / blobdiff