/**
* Initialize the first set, continue.
*/
static void
init_set1 (void)
{
struct GNUNET_SET_Element element;
if (empty)
{
init_set2 (NULL);
return;
}
element.element_type = 0;
element.data = "hello";
element.size = strlen(element.data);
GNUNET_SET_add_element (set1,
&element,
NULL,
NULL);
element.data = "bar";
element.size = strlen(element.data);
GNUNET_SET_add_element (set1,
&element,
&init_set2,
NULL);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"initialized set 1\n");
}
/**
* Initialize the second set, continue
*
* @param cls closure, unused
*/
static void
init_set2 (void *cls)
{
struct GNUNET_SET_Element element;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"initializing set 2\n");
if (empty)
{
start (NULL);
return;
}
element.element_type = 0;
element.data = "hello";
element.size = strlen(element.data);
GNUNET_SET_add_element (set2,
&element,
NULL,
NULL);
element.data = "quux";
element.size = strlen(element.data);
GNUNET_SET_add_element (set2,
&element,
NULL,
NULL);
element.data = "baz";
element.size = strlen(element.data);
GNUNET_SET_add_element (set2,
&element,
&start, NULL);
}
/**
* Initialize the first set, continue.
*/
static void
init_set1 (void)
{
struct GNUNET_SET_Element element;
element.element_type = 0;
element.data = "hello";
element.size = strlen(element.data);
GNUNET_SET_add_element (set1, &element, NULL, NULL);
element.data = "bar";
element.size = strlen(element.data);
GNUNET_SET_add_element (set1, &element, &init_set2, NULL);
}
static void
test_iter ()
{
struct GNUNET_SET_Element element;
struct GNUNET_SET_Handle *iter_set;
iter_set = GNUNET_SET_create (config, GNUNET_SET_OPERATION_INTERSECTION);
element.element_type = 0;
element.data = "hello";
element.size = strlen(element.data);
GNUNET_SET_add_element (iter_set, &element, NULL, NULL);
element.data = "bar";
element.size = strlen(element.data);
GNUNET_SET_add_element (iter_set, &element, NULL, NULL);
element.data = "quux";
element.size = strlen(element.data);
GNUNET_SET_add_element (iter_set, &element, NULL, NULL);
GNUNET_SET_iterate (iter_set, &iter_cb, iter_set);
}
/**
* We're receiving additional set data. Add it to our
* set and if we are done, initiate the transaction.
*
* @param cls identification of the client
* @param msg the actual message
*/
static void
handle_bob_client_message_multipart (void *cls,
const struct ComputationBobCryptodataMultipartMessage *msg)
{
struct BobServiceSession *s = cls;
uint32_t contained_count;
const struct GNUNET_SCALARPRODUCT_Element *elements;
struct GNUNET_SET_Element set_elem;
struct GNUNET_SCALARPRODUCT_Element *elem;
contained_count = ntohl (msg->element_count_contained);
elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
for (uint32_t i = 0; i < contained_count; i++)
{
elem = GNUNET_new (struct GNUNET_SCALARPRODUCT_Element);
GNUNET_memcpy (elem,
&elements[i],
sizeof (struct GNUNET_SCALARPRODUCT_Element));
if (GNUNET_SYSERR ==
GNUNET_CONTAINER_multihashmap_put (s->intersected_elements,
&elem->key,
elem,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
{
GNUNET_break (0);
GNUNET_free (elem);
continue;
}
set_elem.data = &elem->key;
set_elem.size = sizeof (elem->key);
set_elem.element_type = 0;
GNUNET_SET_add_element (s->intersection_set,
&set_elem,
NULL, NULL);
}
s->client_received_element_count += contained_count;
GNUNET_SERVICE_client_continue (s->client);
if (s->total != s->client_received_element_count)
{
/* more to come */
return;
}
if (NULL == s->cadet)
{
/* no Alice waiting for this request, wait for Alice */
return;
}
start_intersection (s);
}
/**
* Handler for Bob's a client request message. Bob is in the response
* role, keep the values + session and waiting for a matching session
* or process a waiting request from Alice.
*
* @param cls identification of the client
* @param msg the actual message
*/
static void
handle_bob_client_message (void *cls,
const struct BobComputationMessage *msg)
{
struct BobServiceSession *s = cls;
struct CadetIncomingSession *in;
uint32_t contained_count;
uint32_t total_count;
const struct GNUNET_SCALARPRODUCT_Element *elements;
struct GNUNET_SET_Element set_elem;
struct GNUNET_SCALARPRODUCT_Element *elem;
total_count = ntohl (msg->element_count_total);
contained_count = ntohl (msg->element_count_contained);
s->status = GNUNET_SCALARPRODUCT_STATUS_ACTIVE;
s->total = total_count;
s->client_received_element_count = contained_count;
s->session_id = msg->session_key;
s->port = GNUNET_CADET_open_port (my_cadet,
&msg->session_key,
&cb_channel_incoming,
s);
if (NULL == s->port)
{
GNUNET_break (0);
GNUNET_SERVICE_client_drop (s->client);
return;
}
GNUNET_break (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap_put (client_sessions,
&s->session_id,
s,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
s->intersected_elements
= GNUNET_CONTAINER_multihashmap_create (s->total,
GNUNET_YES);
s->intersection_set
= GNUNET_SET_create (cfg,
GNUNET_SET_OPERATION_INTERSECTION);
for (uint32_t i = 0; i < contained_count; i++)
{
if (0 == GNUNET_ntohll (elements[i].value))
continue;
elem = GNUNET_new (struct GNUNET_SCALARPRODUCT_Element);
GNUNET_memcpy (elem,
&elements[i],
sizeof (struct GNUNET_SCALARPRODUCT_Element));
if (GNUNET_SYSERR ==
GNUNET_CONTAINER_multihashmap_put (s->intersected_elements,
&elem->key,
elem,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
{
GNUNET_break (0);
GNUNET_free (elem);
continue;
}
set_elem.data = &elem->key;
set_elem.size = sizeof (elem->key);
set_elem.element_type = 0;
GNUNET_SET_add_element (s->intersection_set,
&set_elem,
NULL, NULL);
s->used_element_count++;
}
GNUNET_SERVICE_client_continue (s->client);
if (s->total != s->client_received_element_count)
{
/* multipart msg */
return;
}
in = find_matching_cadet_session (&s->session_id);
if (NULL == in)
{
/* nothing yet, wait for Alice */
return;
}
GNUNET_assert (NULL == in->s);
/* pair them up */
in->s = s;
s->cadet = in;
start_intersection (s);
}
