gnunet-service-set_intersection.c File Reference

two-peer set intersection More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_statistics_service.h"
#include "gnunet-service-set.h"
#include "gnunet_block_lib.h"
#include "gnunet-service-set_protocol.h"
#include "gnunet-service-set_intersection.h"
#include <gcrypt.h>

Include dependency graph for gnunet-service-set_intersection.c:

Go to the source code of this file.

Data Structures
struct	OperationState
	State of an evaluate operation with another peer. More...
struct	SetState
	Extra state required for efficient set intersection. More...

Enumerations
enum	IntersectionOperationPhase {   PHASE_INITIAL , PHASE_COUNT_SENT , PHASE_BF_EXCHANGE , PHASE_MUST_SEND_DONE ,   PHASE_DONE_RECEIVED , PHASE_FINISHED , PHASE_INITIAL , PHASE_COUNT_SENT ,   PHASE_BF_EXCHANGE , PHASE_MUST_SEND_DONE , PHASE_DONE_RECEIVED , PHASE_FINISHED }
	Current phase we are in for a intersection operation. More...

Functions
static void	send_client_removed_element (struct Operation *op, struct GNUNET_SET_Element *element)
	If applicable in the current operation mode, send a result message to the client indicating we removed an element. More...
static int	filtered_map_initialization (void *cls, const struct GNUNET_HashCode *key, void *value)
	Fills the "my_elements" hashmap with all relevant elements. More...
static int	iterator_bf_reduce (void *cls, const struct GNUNET_HashCode *key, void *value)
	Removes elements from our hashmap if they are not contained within the provided remote bloomfilter. More...
static int	iterator_bf_create (void *cls, const struct GNUNET_HashCode *key, void *value)
	Create initial bloomfilter based on all the elements given. More...
static void	fail_intersection_operation (struct Operation *op)
	Inform the client that the intersection operation has failed, and proceed to destroy the evaluate operation. More...
static void	send_bloomfilter (struct Operation *op)
	Send a bloomfilter to our peer. More...
static void	send_client_done_and_destroy (void *cls)
	Signal to the client that the operation has finished and destroy the operation. More...
static void	finished_local_operations (void *cls)
	Remember that we are done dealing with the local client AND have sent the other peer our message that we are done, so we are not just waiting for the channel to die before telling the local client that we are done as our last act. More...
static void	send_p2p_done (struct Operation *op)
	Notify the other peer that we are done. More...
static void	send_remaining_elements (void *cls)
	Send all elements in the full result iterator. More...
static int	initialize_map_unfiltered (void *cls, const struct GNUNET_HashCode *key, void *value)
	Fills the "my_elements" hashmap with the initial set of (non-deleted) elements from the set of the specification. More...
static void	send_element_count (struct Operation *op)
	Send our element count to the peer, in case our element count is lower than theirs. More...
static void	begin_bf_exchange (struct Operation *op)
	We go first, initialize our map with all elements and send the first Bloom filter. More...
void	handle_intersection_p2p_element_info (void *cls, const struct IntersectionElementInfoMessage *msg)
	Handle the initial struct IntersectionElementInfoMessage from a remote peer. More...
static void	process_bf (struct Operation *op)
	Process a Bloomfilter once we got all the chunks. More...
int	check_intersection_p2p_bf (void *cls, const struct BFMessage *msg)
	Check an BF message from a remote peer. More...
void	handle_intersection_p2p_bf (void *cls, const struct BFMessage *msg)
	Handle an BF message from a remote peer. More...
static int	filter_all (void *cls, const struct GNUNET_HashCode *key, void *value)
	Remove all elements from our hashmap. More...
void	handle_intersection_p2p_done (void *cls, const struct IntersectionDoneMessage *idm)
	Handle a done message from a remote peer. More...
static struct OperationState *	intersection_evaluate (struct Operation *op, const struct GNUNET_MessageHeader *opaque_context)
	Initiate a set intersection operation with a remote peer. More...
static struct OperationState *	intersection_accept (struct Operation *op)
	Accept an intersection operation request from a remote peer. More...
static void	intersection_op_cancel (struct Operation *op)
	Destroy the intersection operation. More...
static struct SetState *	intersection_set_create ()
	Create a new set supporting the intersection operation. More...
static void	intersection_add (struct SetState *set_state, struct ElementEntry *ee)
	Add the element from the given element message to the set. More...
static void	intersection_set_destroy (struct SetState *set_state)
	Destroy a set that supports the intersection operation. More...
static void	intersection_remove (struct SetState *set_state, struct ElementEntry *element)
	Remove the element given in the element message from the set. More...
static void	intersection_channel_death (struct Operation *op)
	Callback for channel death for the intersection operation. More...
const struct SetVT *	_GSS_intersection_vt ()
	Get the table with implementing functions for set intersection. More...

Detailed Description

two-peer set intersection

Author

Christian Fuchs

Christian Grothoff

Definition in file gnunet-service-set_intersection.c.

Enumeration Type Documentation

IntersectionOperationPhase

enum IntersectionOperationPhase

Current phase we are in for a intersection operation.

Enumerator
PHASE_INITIAL	We are just starting.
PHASE_COUNT_SENT	We have send the number of our elements to the other peer, but did not setup our element set yet.
PHASE_BF_EXCHANGE	We have initialized our set and are now reducing it by exchanging Bloom filters until one party notices the their element hashes are equal.
PHASE_MUST_SEND_DONE	We must next send the P2P DONE message (after finishing mostly with the local client). Then we will wait for the channel to close.
PHASE_DONE_RECEIVED	We have received the P2P DONE message, and must finish with the local client before terminating the channel.
PHASE_FINISHED	The protocol is over. Results may still have to be sent to the client.
PHASE_INITIAL	We are just starting.
PHASE_COUNT_SENT	We have send the number of our elements to the other peer, but did not setup our element set yet.
PHASE_BF_EXCHANGE	We have initialized our set and are now reducing it by exchanging Bloom filters until one party notices the their element hashes are equal.
PHASE_MUST_SEND_DONE	We must next send the P2P DONE message (after finishing mostly with the local client). Then we will wait for the channel to close.
PHASE_DONE_RECEIVED	We have received the P2P DONE message, and must finish with the local client before terminating the channel.
PHASE_FINISHED	The protocol is over. Results may still have to be sent to the client.

Definition at line 39 of file gnunet-service-set_intersection.c.

{
  PHASE_INITIAL,
 
  PHASE_COUNT_SENT,
 
  PHASE_BF_EXCHANGE,
 
  PHASE_MUST_SEND_DONE,
 
  PHASE_DONE_RECEIVED,
 
  PHASE_FINISHED
};

Function Documentation

send_client_removed_element()

static void send_client_removed_element ( struct Operation *  op, struct GNUNET_SET_Element *  element  )

static

If applicable in the current operation mode, send a result message to the client indicating we removed an element.

Parameters

op	intersection operation
element	element to send

Definition at line 209 of file gnunet-service-set_intersection.c.

{
  struct GNUNET_MQ_Envelope *ev;
  struct GNUNET_SET_ResultMessage *rm;
 
  if (GNUNET_SET_RESULT_REMOVED != op->result_mode)
    return; /* Wrong mode for transmitting removed elements */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending removed element (size %u) to client\n",
              element->size);
  GNUNET_STATISTICS_update (_GSS_statistics,
                            "# Element removed messages sent",
                            1,
                            GNUNET_NO);
  GNUNET_assert (0 != op->client_request_id);
  ev = GNUNET_MQ_msg_extra (rm,
                            element->size,
                            GNUNET_MESSAGE_TYPE_SET_RESULT);
  if (NULL == ev)
  {
    GNUNET_break (0);
    return;
  }
  rm->result_status = htons (GNUNET_SET_STATUS_OK);
  rm->request_id = htonl (op->client_request_id);
  rm->element_type = element->element_type;
  GNUNET_memcpy (&rm[1],
                 element->data,
                 element->size);
  GNUNET_MQ_send (op->set->cs->mq,
                  ev);
}

References _GSS_statistics, GNUNET_SET_Element::data, GNUNET_SET_ResultMessage::element_type, GNUNET_SET_Element::element_type, GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SET_RESULT, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_SET_RESULT_REMOVED, GNUNET_SET_STATUS_OK, GNUNET_STATISTICS_update(), op, GNUNET_SET_ResultMessage::request_id, GNUNET_SET_ResultMessage::result_status, and GNUNET_SET_Element::size.

Referenced by filter_all(), filtered_map_initialization(), and iterator_bf_reduce().

Here is the call graph for this function:

Here is the caller graph for this function:

filtered_map_initialization()

static int filtered_map_initialization ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Fills the "my_elements" hashmap with all relevant elements.

Parameters

cls	the struct Operation * we are performing
key	current key code
value	the struct ElementEntry * from the hash map

Returns

GNUNET_YES (we should continue to iterate)

Definition at line 253 of file gnunet-service-set_intersection.c.

{
  struct Operation *op = cls;
  struct ElementEntry *ee = value;
  struct GNUNET_HashCode mutated_hash;
 
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "FIMA called for %s:%u\n",
              GNUNET_h2s (&ee->element_hash),
              ee->element.size);
 
  if (GNUNET_NO == _GSS_is_element_of_operation (ee, op))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Reduced initialization, not starting with %s:%u (wrong generation)\n",
                GNUNET_h2s (&ee->element_hash),
                ee->element.size);
    return GNUNET_YES;   /* element not valid in our operation's generation */
  }
 
  /* Test if element is in other peer's bloomfilter */
  GNUNET_BLOCK_mingle_hash (&ee->element_hash,
                            op->state->salt,
                            &mutated_hash);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Testing mingled hash %s with salt %u\n",
              GNUNET_h2s (&mutated_hash),
              op->state->salt);
  if (GNUNET_NO ==
      GNUNET_CONTAINER_bloomfilter_test (op->state->remote_bf,
                                         &mutated_hash))
  {
    /* remove this element */
    send_client_removed_element (op,
                                 &ee->element);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Reduced initialization, not starting with %s:%u\n",
                GNUNET_h2s (&ee->element_hash),
                ee->element.size);
    return GNUNET_YES;
  }
  op->state->my_element_count++;
  GNUNET_CRYPTO_hash_xor (&op->state->my_xor,
                          &ee->element_hash,
                          &op->state->my_xor);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Filtered initialization of my_elements, adding %s:%u\n",
              GNUNET_h2s (&ee->element_hash),
              ee->element.size);
  GNUNET_break (GNUNET_YES ==
                GNUNET_CONTAINER_multihashmap_put (op->state->my_elements,
                                                   &ee->element_hash,
                                                   ee,
                                                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
 
  return GNUNET_YES;
}

References _GSS_is_element_of_operation(), ElementEntry::element, ElementEntry::element_hash, GNUNET_BLOCK_mingle_hash(), GNUNET_break, GNUNET_CONTAINER_bloomfilter_test(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CRYPTO_hash_xor(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_NO, GNUNET_YES, op, send_client_removed_element(), GNUNET_SET_Element::size, and value.

Referenced by process_bf().

Here is the call graph for this function:

Here is the caller graph for this function:

iterator_bf_reduce()

static int iterator_bf_reduce ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Removes elements from our hashmap if they are not contained within the provided remote bloomfilter.

Parameters

cls	closure with the struct Operation *
key	current key code
value	value in the hash map

Returns

GNUNET_YES (we should continue to iterate)

Definition at line 325 of file gnunet-service-set_intersection.c.

{
  struct Operation *op = cls;
  struct ElementEntry *ee = value;
  struct GNUNET_HashCode mutated_hash;
 
  GNUNET_BLOCK_mingle_hash (&ee->element_hash,
                            op->state->salt,
                            &mutated_hash);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Testing mingled hash %s with salt %u\n",
              GNUNET_h2s (&mutated_hash),
              op->state->salt);
  if (GNUNET_NO ==
      GNUNET_CONTAINER_bloomfilter_test (op->state->remote_bf,
                                         &mutated_hash))
  {
    GNUNET_break (0 < op->state->my_element_count);
    op->state->my_element_count--;
    GNUNET_CRYPTO_hash_xor (&op->state->my_xor,
                            &ee->element_hash,
                            &op->state->my_xor);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Bloom filter reduction of my_elements, removing %s:%u\n",
                GNUNET_h2s (&ee->element_hash),
                ee->element.size);
    GNUNET_assert (GNUNET_YES ==
                   GNUNET_CONTAINER_multihashmap_remove (op->state->my_elements,
                                                         &ee->element_hash,
                                                         ee));
    send_client_removed_element (op,
                                 &ee->element);
  }
  else
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Bloom filter reduction of my_elements, keeping %s:%u\n",
                GNUNET_h2s (&ee->element_hash),
                ee->element.size);
  }
  return GNUNET_YES;
}

References ElementEntry::element, ElementEntry::element_hash, GNUNET_assert, GNUNET_BLOCK_mingle_hash(), GNUNET_break, GNUNET_CONTAINER_bloomfilter_test(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_CRYPTO_hash_xor(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_NO, GNUNET_YES, op, send_client_removed_element(), GNUNET_SET_Element::size, and value.

Referenced by process_bf().

Here is the call graph for this function:

Here is the caller graph for this function:

iterator_bf_create()

static int iterator_bf_create ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Create initial bloomfilter based on all the elements given.

Parameters

cls	the struct Operation *
key	current key code
value	the struct ElementEntry to process

Returns

GNUNET_YES (we should continue to iterate)

Definition at line 380 of file gnunet-service-set_intersection.c.

{
  struct Operation *op = cls;
  struct ElementEntry *ee = value;
  struct GNUNET_HashCode mutated_hash;
 
  GNUNET_BLOCK_mingle_hash (&ee->element_hash,
                            op->state->salt,
                            &mutated_hash);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Initializing BF with hash %s with salt %u\n",
              GNUNET_h2s (&mutated_hash),
              op->state->salt);
  GNUNET_CONTAINER_bloomfilter_add (op->state->local_bf,
                                    &mutated_hash);
  return GNUNET_YES;
}

References ElementEntry::element_hash, GNUNET_BLOCK_mingle_hash(), GNUNET_CONTAINER_bloomfilter_add(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_YES, op, and value.

Referenced by send_bloomfilter().

Here is the call graph for this function:

Here is the caller graph for this function:

fail_intersection_operation()

static void fail_intersection_operation ( struct Operation *  op )

static

Inform the client that the intersection operation has failed, and proceed to destroy the evaluate operation.

Parameters

op	the intersection operation to fail

Definition at line 408 of file gnunet-service-set_intersection.c.

{
  struct GNUNET_MQ_Envelope *ev;
  struct GNUNET_SET_ResultMessage *msg;
 
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              "Intersection operation failed\n");
  GNUNET_STATISTICS_update (_GSS_statistics,
                            "# Intersection operations failed",
                            1,
                            GNUNET_NO);
  if (NULL != op->state->my_elements)
  {
    GNUNET_CONTAINER_multihashmap_destroy (op->state->my_elements);
    op->state->my_elements = NULL;
  }
  ev = GNUNET_MQ_msg (msg,
                      GNUNET_MESSAGE_TYPE_SET_RESULT);
  msg->result_status = htons (GNUNET_SET_STATUS_FAILURE);
  msg->request_id = htonl (op->client_request_id);
  msg->element_type = htons (0);
  GNUNET_MQ_send (op->set->cs->mq,
                  ev);
  _GSS_operation_destroy (op,
                          GNUNET_YES);
}

References _GSS_operation_destroy(), _GSS_statistics, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_MESSAGE_TYPE_SET_RESULT, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_NO, GNUNET_SET_STATUS_FAILURE, GNUNET_STATISTICS_update(), GNUNET_YES, msg, and op.

Referenced by handle_intersection_p2p_bf(), handle_intersection_p2p_done(), handle_intersection_p2p_element_info(), and process_bf().

Here is the call graph for this function:

Here is the caller graph for this function:

send_bloomfilter()

static void send_bloomfilter ( struct Operation *  op )

static

Send a bloomfilter to our peer.

After the result done message has been sent to the client, destroy the evaluate operation.

Parameters

op	intersection operation

Definition at line 443 of file gnunet-service-set_intersection.c.

{
  struct GNUNET_MQ_Envelope *ev;
  struct BFMessage *msg;
  uint32_t bf_size;
  uint32_t bf_elementbits;
  uint32_t chunk_size;
  char *bf_data;
  uint32_t offset;
 
  /* We consider the ratio of the set sizes to determine
     the number of bits per element, as the smaller set
     should use more bits to maximize its set reduction
     potential and minimize overall bandwidth consumption. */
  bf_elementbits = 2 + ceil (log2 ((double)
                                   (op->remote_element_count
                                    / (double) op->state->my_element_count)));
  if (bf_elementbits < 1)
    bf_elementbits = 1; /* make sure k is not 0 */
  /* optimize BF-size to ~50% of bits set */
  bf_size = ceil ((double) (op->state->my_element_count
                            * bf_elementbits / log (2)));
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending Bloom filter (%u) of size %u bytes\n",
              (unsigned int) bf_elementbits,
              (unsigned int) bf_size);
  op->state->local_bf = GNUNET_CONTAINER_bloomfilter_init (NULL,
                                                           bf_size,
                                                           bf_elementbits);
  op->state->salt = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
                                              UINT32_MAX);
  GNUNET_CONTAINER_multihashmap_iterate (op->state->my_elements,
                                         &iterator_bf_create,
                                         op);
 
  /* send our Bloom filter */
  GNUNET_STATISTICS_update (_GSS_statistics,
                            "# Intersection Bloom filters sent",
                            1,
                            GNUNET_NO);
  chunk_size = 60 * 1024 - sizeof(struct BFMessage);
  if (bf_size <= chunk_size)
  {
    /* singlepart */
    chunk_size = bf_size;
    ev = GNUNET_MQ_msg_extra (msg,
                              chunk_size,
                              GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_BF);
    GNUNET_assert (GNUNET_SYSERR !=
                   GNUNET_CONTAINER_bloomfilter_get_raw_data (
                     op->state->local_bf,
                     (char *) &msg[1],
                     bf_size));
    msg->sender_element_count = htonl (op->state->my_element_count);
    msg->bloomfilter_total_length = htonl (bf_size);
    msg->bits_per_element = htonl (bf_elementbits);
    msg->sender_mutator = htonl (op->state->salt);
    msg->element_xor_hash = op->state->my_xor;
    GNUNET_MQ_send (op->mq, ev);
  }
  else
  {
    /* multipart */
    bf_data = GNUNET_malloc (bf_size);
    GNUNET_assert (GNUNET_SYSERR !=
                   GNUNET_CONTAINER_bloomfilter_get_raw_data (
                     op->state->local_bf,
                     bf_data,
                     bf_size));
    offset = 0;
    while (offset < bf_size)
    {
      if (bf_size - chunk_size < offset)
        chunk_size = bf_size - offset;
      ev = GNUNET_MQ_msg_extra (msg,
                                chunk_size,
                                GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_BF);
      GNUNET_memcpy (&msg[1],
                     &bf_data[offset],
                     chunk_size);
      offset += chunk_size;
      msg->sender_element_count = htonl (op->state->my_element_count);
      msg->bloomfilter_total_length = htonl (bf_size);
      msg->bits_per_element = htonl (bf_elementbits);
      msg->sender_mutator = htonl (op->state->salt);
      msg->element_xor_hash = op->state->my_xor;
      GNUNET_MQ_send (op->mq, ev);
    }
    GNUNET_free (bf_data);
  }
  GNUNET_CONTAINER_bloomfilter_free (op->state->local_bf);
  op->state->local_bf = NULL;
}

References _GSS_statistics, GNUNET_assert, GNUNET_CONTAINER_bloomfilter_free(), GNUNET_CONTAINER_bloomfilter_get_raw_data(), GNUNET_CONTAINER_bloomfilter_init(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CRYPTO_QUALITY_NONCE, GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_BF, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_SYSERR, iterator_bf_create(), msg, and op.

Referenced by begin_bf_exchange(), and process_bf().

Here is the call graph for this function:

Here is the caller graph for this function:

send_client_done_and_destroy()

static void send_client_done_and_destroy ( void *  cls )

static

Signal to the client that the operation has finished and destroy the operation.

Parameters

cls	operation to destroy

Definition at line 545 of file gnunet-service-set_intersection.c.

{
  struct Operation *op = cls;
  struct GNUNET_MQ_Envelope *ev;
  struct GNUNET_SET_ResultMessage *rm;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Intersection succeeded, sending DONE to local client\n");
  GNUNET_STATISTICS_update (_GSS_statistics,
                            "# Intersection operations succeeded",
                            1,
                            GNUNET_NO);
  ev = GNUNET_MQ_msg (rm,
                      GNUNET_MESSAGE_TYPE_SET_RESULT);
  rm->request_id = htonl (op->client_request_id);
  rm->result_status = htons (GNUNET_SET_STATUS_DONE);
  rm->element_type = htons (0);
  GNUNET_MQ_send (op->set->cs->mq,
                  ev);
  _GSS_operation_destroy (op,
                          GNUNET_YES);
}

References _GSS_operation_destroy(), _GSS_statistics, GNUNET_SET_ResultMessage::element_type, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_SET_RESULT, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_NO, GNUNET_SET_STATUS_DONE, GNUNET_STATISTICS_update(), GNUNET_YES, op, GNUNET_SET_ResultMessage::request_id, and GNUNET_SET_ResultMessage::result_status.

Referenced by handle_intersection_p2p_done(), intersection_channel_death(), and send_remaining_elements().

Here is the call graph for this function:

Here is the caller graph for this function:

finished_local_operations()

static void finished_local_operations ( void *  cls )

static

Remember that we are done dealing with the local client AND have sent the other peer our message that we are done, so we are not just waiting for the channel to die before telling the local client that we are done as our last act.

Parameters

cls	the struct Operation.

Definition at line 578 of file gnunet-service-set_intersection.c.

{
  struct Operation *op = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "DONE sent to other peer, now waiting for other end to close the channel\n");
  op->state->phase = PHASE_FINISHED;
  op->state->channel_death_expected = GNUNET_YES;
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_YES, op, and PHASE_FINISHED.

Referenced by send_p2p_done().

Here is the caller graph for this function:

send_p2p_done()

static void send_p2p_done ( struct Operation *  op )

static

Notify the other peer that we are done.

Once this message is out, we still need to notify the local client that we are done.

Parameters

op	operation to notify for.

Definition at line 597 of file gnunet-service-set_intersection.c.

{
  struct GNUNET_MQ_Envelope *ev;
  struct IntersectionDoneMessage *idm;
 
  GNUNET_assert (PHASE_MUST_SEND_DONE == op->state->phase);
  GNUNET_assert (GNUNET_NO == op->state->channel_death_expected);
  ev = GNUNET_MQ_msg (idm,
                      GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_DONE);
  idm->final_element_count = htonl (op->state->my_element_count);
  idm->element_xor_hash = op->state->my_xor;
  GNUNET_MQ_notify_sent (ev,
                         &finished_local_operations,
                         op);
  GNUNET_MQ_send (op->mq,
                  ev);
}

References IntersectionDoneMessage::element_xor_hash, IntersectionDoneMessage::final_element_count, finished_local_operations(), GNUNET_assert, GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_DONE, GNUNET_MQ_msg, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), GNUNET_NO, op, and PHASE_MUST_SEND_DONE.

Referenced by process_bf(), and send_remaining_elements().

Here is the call graph for this function:

Here is the caller graph for this function:

send_remaining_elements()

static void send_remaining_elements ( void *  cls )

static

Send all elements in the full result iterator.

Parameters

cls	the struct Operation *

Definition at line 622 of file gnunet-service-set_intersection.c.

{
  struct Operation *op = cls;
  const void *nxt;
  const struct ElementEntry *ee;
  struct GNUNET_MQ_Envelope *ev;
  struct GNUNET_SET_ResultMessage *rm;
  const struct GNUNET_SET_Element *element;
  int res;
 
  res = GNUNET_CONTAINER_multihashmap_iterator_next (
    op->state->full_result_iter,
    NULL,
    &nxt);
  if (GNUNET_NO == res)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Sending done and destroy because iterator ran out\n");
    GNUNET_CONTAINER_multihashmap_iterator_destroy (
      op->state->full_result_iter);
    op->state->full_result_iter = NULL;
    if (PHASE_DONE_RECEIVED == op->state->phase)
    {
      op->state->phase = PHASE_FINISHED;
      send_client_done_and_destroy (op);
    }
    else if (PHASE_MUST_SEND_DONE == op->state->phase)
    {
      send_p2p_done (op);
    }
    else
    {
      GNUNET_assert (0);
    }
    return;
  }
  ee = nxt;
  element = &ee->element;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending element %s:%u to client (full set)\n",
              GNUNET_h2s (&ee->element_hash),
              element->size);
  GNUNET_assert (0 != op->client_request_id);
  ev = GNUNET_MQ_msg_extra (rm,
                            element->size,
                            GNUNET_MESSAGE_TYPE_SET_RESULT);
  GNUNET_assert (NULL != ev);
  rm->result_status = htons (GNUNET_SET_STATUS_OK);
  rm->request_id = htonl (op->client_request_id);
  rm->element_type = element->element_type;
  GNUNET_memcpy (&rm[1],
                 element->data,
                 element->size);
  GNUNET_MQ_notify_sent (ev,
                         &send_remaining_elements,
                         op);
  GNUNET_MQ_send (op->set->cs->mq,
                  ev);
}

References GNUNET_SET_Element::data, ElementEntry::element, ElementEntry::element_hash, GNUNET_SET_ResultMessage::element_type, GNUNET_SET_Element::element_type, GNUNET_assert, GNUNET_CONTAINER_multihashmap_iterator_destroy(), GNUNET_CONTAINER_multihashmap_iterator_next(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SET_RESULT, GNUNET_MQ_msg_extra, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), GNUNET_NO, GNUNET_SET_STATUS_OK, op, PHASE_DONE_RECEIVED, PHASE_FINISHED, PHASE_MUST_SEND_DONE, GNUNET_SET_ResultMessage::request_id, res, GNUNET_SET_ResultMessage::result_status, send_client_done_and_destroy(), send_p2p_done(), send_remaining_elements(), and GNUNET_SET_Element::size.

Referenced by handle_intersection_p2p_done(), process_bf(), and send_remaining_elements().

Here is the call graph for this function:

Here is the caller graph for this function:

initialize_map_unfiltered()

static int initialize_map_unfiltered ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Fills the "my_elements" hashmap with the initial set of (non-deleted) elements from the set of the specification.

Parameters

cls	closure with the struct Operation *
key	current key code for the element
value	value in the hash map with the struct ElementEntry *

Returns

GNUNET_YES (we should continue to iterate)

Definition at line 693 of file gnunet-service-set_intersection.c.

{
  struct ElementEntry *ee = value;
  struct Operation *op = cls;
 
  if (GNUNET_NO == _GSS_is_element_of_operation (ee, op))
    return GNUNET_YES; /* element not live in operation's generation */
  GNUNET_CRYPTO_hash_xor (&op->state->my_xor,
                          &ee->element_hash,
                          &op->state->my_xor);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Initial full initialization of my_elements, adding %s:%u\n",
              GNUNET_h2s (&ee->element_hash),
              ee->element.size);
  GNUNET_break (GNUNET_YES ==
                GNUNET_CONTAINER_multihashmap_put (op->state->my_elements,
                                                   &ee->element_hash,
                                                   ee,
                                                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  return GNUNET_YES;
}

References _GSS_is_element_of_operation(), ElementEntry::element, ElementEntry::element_hash, GNUNET_break, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CRYPTO_hash_xor(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_NO, GNUNET_YES, op, GNUNET_SET_Element::size, and value.

Referenced by begin_bf_exchange().

Here is the call graph for this function:

Here is the caller graph for this function:

send_element_count()

static void send_element_count ( struct Operation *  op )

static

Send our element count to the peer, in case our element count is lower than theirs.

Parameters

op	intersection operation

Definition at line 725 of file gnunet-service-set_intersection.c.

{
  struct GNUNET_MQ_Envelope *ev;
  struct IntersectionElementInfoMessage *msg;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending our element count (%u)\n",
              op->state->my_element_count);
  ev = GNUNET_MQ_msg (msg,
                      GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_ELEMENT_INFO);
  msg->sender_element_count = htonl (op->state->my_element_count);
  GNUNET_MQ_send (op->mq, ev);
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_ELEMENT_INFO, GNUNET_MQ_msg, GNUNET_MQ_send(), msg, and op.

Referenced by intersection_accept().

Here is the call graph for this function:

Here is the caller graph for this function:

begin_bf_exchange()

static void begin_bf_exchange ( struct Operation *  op )

static

We go first, initialize our map with all elements and send the first Bloom filter.

Parameters

op	operation to start exchange for

Definition at line 747 of file gnunet-service-set_intersection.c.

{
  op->state->phase = PHASE_BF_EXCHANGE;
  GNUNET_CONTAINER_multihashmap_iterate (op->set->content->elements,
                                         &initialize_map_unfiltered,
                                         op);
  send_bloomfilter (op);
}

References GNUNET_CONTAINER_multihashmap_iterate(), initialize_map_unfiltered(), op, PHASE_BF_EXCHANGE, and send_bloomfilter().

Referenced by handle_intersection_p2p_element_info(), and intersection_accept().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_intersection_p2p_element_info()

void handle_intersection_p2p_element_info	(	void *	cls,
		const struct IntersectionElementInfoMessage *	msg
	)

Handle the initial struct IntersectionElementInfoMessage from a remote peer.

Parameters

cls	the intersection operation
msg	the header of the message

Definition at line 758 of file gnunet-service-set_intersection.c.

{
  struct Operation *op = cls;
 
  if (GNUNET_SET_OPERATION_INTERSECTION != op->set->operation)
  {
    GNUNET_break_op (0);
    fail_intersection_operation (op);
    return;
  }
  op->remote_element_count = ntohl (msg->sender_element_count);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received remote element count (%u), I have %u\n",
              op->remote_element_count,
              op->state->my_element_count);
  if (((PHASE_INITIAL != op->state->phase) &&
       (PHASE_COUNT_SENT != op->state->phase)) ||
      (op->state->my_element_count > op->remote_element_count) ||
      (0 == op->state->my_element_count) ||
      (0 == op->remote_element_count))
  {
    GNUNET_break_op (0);
    fail_intersection_operation (op);
    return;
  }
  GNUNET_break (NULL == op->state->remote_bf);
  begin_bf_exchange (op);
  GNUNET_CADET_receive_done (op->channel);
}

References begin_bf_exchange(), fail_intersection_operation(), GNUNET_break, GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_SET_OPERATION_INTERSECTION, msg, op, PHASE_COUNT_SENT, and PHASE_INITIAL.

Here is the call graph for this function:

process_bf()

static void process_bf ( struct Operation *  op )

static

Process a Bloomfilter once we got all the chunks.

Parameters

op	the intersection operation

Definition at line 797 of file gnunet-service-set_intersection.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received BF in phase %u, foreign count is %u, my element count is %u/%u\n",
              op->state->phase,
              op->remote_element_count,
              op->state->my_element_count,
              GNUNET_CONTAINER_multihashmap_size (op->set->content->elements));
  switch (op->state->phase)
  {
  case PHASE_INITIAL:
    GNUNET_break_op (0);
    fail_intersection_operation (op);
    return;
 
  case PHASE_COUNT_SENT:
    /* This is the first BF being sent, build our initial map with
       filtering in place */
    op->state->my_element_count = 0;
    GNUNET_CONTAINER_multihashmap_iterate (op->set->content->elements,
                                           &filtered_map_initialization,
                                           op);
    break;
 
  case PHASE_BF_EXCHANGE:
    /* Update our set by reduction */
    GNUNET_CONTAINER_multihashmap_iterate (op->state->my_elements,
                                           &iterator_bf_reduce,
                                           op);
    break;
 
  case PHASE_MUST_SEND_DONE:
    GNUNET_break_op (0);
    fail_intersection_operation (op);
    return;
 
  case PHASE_DONE_RECEIVED:
    GNUNET_break_op (0);
    fail_intersection_operation (op);
    return;
 
  case PHASE_FINISHED:
    GNUNET_break_op (0);
    fail_intersection_operation (op);
    return;
  }
  GNUNET_CONTAINER_bloomfilter_free (op->state->remote_bf);
  op->state->remote_bf = NULL;
 
  if ((0 == op->state->my_element_count) ||  /* fully disjoint */
      ((op->state->my_element_count == op->remote_element_count) &&
       (0 == GNUNET_memcmp (&op->state->my_xor,
                            &op->state->other_xor))))
  {
    /* we are done */
    op->state->phase = PHASE_MUST_SEND_DONE;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Intersection succeeded, sending DONE to other peer\n");
    GNUNET_CONTAINER_bloomfilter_free (op->state->local_bf);
    op->state->local_bf = NULL;
    if (GNUNET_SET_RESULT_FULL == op->result_mode)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Sending full result set (%u elements)\n",
                  GNUNET_CONTAINER_multihashmap_size (op->state->my_elements));
      op->state->full_result_iter
        = GNUNET_CONTAINER_multihashmap_iterator_create (
            op->state->my_elements);
      send_remaining_elements (op);
      return;
    }
    send_p2p_done (op);
    return;
  }
  op->state->phase = PHASE_BF_EXCHANGE;
  send_bloomfilter (op);
}

References fail_intersection_operation(), filtered_map_initialization(), GNUNET_break_op, GNUNET_CONTAINER_bloomfilter_free(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CONTAINER_multihashmap_iterator_create(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_memcmp, GNUNET_SET_RESULT_FULL, iterator_bf_reduce(), op, PHASE_BF_EXCHANGE, PHASE_COUNT_SENT, PHASE_DONE_RECEIVED, PHASE_FINISHED, PHASE_INITIAL, PHASE_MUST_SEND_DONE, send_bloomfilter(), send_p2p_done(), and send_remaining_elements().

Referenced by handle_intersection_p2p_bf().

Here is the call graph for this function:

Here is the caller graph for this function:

check_intersection_p2p_bf()

int check_intersection_p2p_bf	(	void *	cls,
		const struct BFMessage *	msg
	)

Check an BF message from a remote peer.

Parameters

cls	the intersection operation
msg	the header of the message

Returns

GNUNET_OK if msg is well-formed

Definition at line 884 of file gnunet-service-set_intersection.c.

{
  struct Operation *op = cls;
 
  if (GNUNET_SET_OPERATION_INTERSECTION != op->set->operation)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_OK, GNUNET_SET_OPERATION_INTERSECTION, GNUNET_SYSERR, and op.

handle_intersection_p2p_bf()

void handle_intersection_p2p_bf	(	void *	cls,
		const struct BFMessage *	msg
	)

Handle an BF message from a remote peer.

Parameters

cls	the intersection operation
msg	the header of the message

Definition at line 905 of file gnunet-service-set_intersection.c.

{
  struct Operation *op = cls;
  uint32_t bf_size;
  uint32_t chunk_size;
  uint32_t bf_bits_per_element;
 
  switch (op->state->phase)
  {
  case PHASE_INITIAL:
    GNUNET_break_op (0);
    fail_intersection_operation (op);
    return;
 
  case PHASE_COUNT_SENT:
  case PHASE_BF_EXCHANGE:
    bf_size = ntohl (msg->bloomfilter_total_length);
    bf_bits_per_element = ntohl (msg->bits_per_element);
    chunk_size = htons (msg->header.size) - sizeof(struct BFMessage);
    op->state->other_xor = msg->element_xor_hash;
    if (bf_size == chunk_size)
    {
      if (NULL != op->state->bf_data)
      {
        GNUNET_break_op (0);
        fail_intersection_operation (op);
        return;
      }
      /* single part, done here immediately */
      op->state->remote_bf
        = GNUNET_CONTAINER_bloomfilter_init ((const char *) &msg[1],
                                             bf_size,
                                             bf_bits_per_element);
      op->state->salt = ntohl (msg->sender_mutator);
      op->remote_element_count = ntohl (msg->sender_element_count);
      process_bf (op);
      break;
    }
    /* multipart chunk */
    if (NULL == op->state->bf_data)
    {
      /* first chunk, initialize */
      op->state->bf_data = GNUNET_malloc (bf_size);
      op->state->bf_data_size = bf_size;
      op->state->bf_bits_per_element = bf_bits_per_element;
      op->state->bf_data_offset = 0;
      op->state->salt = ntohl (msg->sender_mutator);
      op->remote_element_count = ntohl (msg->sender_element_count);
    }
    else
    {
      /* increment */
      if ((op->state->bf_data_size != bf_size) ||
          (op->state->bf_bits_per_element != bf_bits_per_element) ||
          (op->state->bf_data_offset + chunk_size > bf_size) ||
          (op->state->salt != ntohl (msg->sender_mutator)) ||
          (op->remote_element_count != ntohl (msg->sender_element_count)))
      {
        GNUNET_break_op (0);
        fail_intersection_operation (op);
        return;
      }
    }
    GNUNET_memcpy (&op->state->bf_data[op->state->bf_data_offset],
                   (const char *) &msg[1],
                   chunk_size);
    op->state->bf_data_offset += chunk_size;
    if (op->state->bf_data_offset == bf_size)
    {
      /* last chunk, run! */
      op->state->remote_bf
        = GNUNET_CONTAINER_bloomfilter_init (op->state->bf_data,
                                             bf_size,
                                             bf_bits_per_element);
      GNUNET_free (op->state->bf_data);
      op->state->bf_data = NULL;
      op->state->bf_data_size = 0;
      process_bf (op);
    }
    break;
 
  default:
    GNUNET_break_op (0);
    fail_intersection_operation (op);
    return;
  }
  GNUNET_CADET_receive_done (op->channel);
}

References Operation::bf_bits_per_element, fail_intersection_operation(), GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_CONTAINER_bloomfilter_init(), GNUNET_free, GNUNET_malloc, GNUNET_memcpy, msg, op, PHASE_BF_EXCHANGE, PHASE_COUNT_SENT, PHASE_INITIAL, process_bf(), and GNUNET_MessageHeader::size.

Here is the call graph for this function:

filter_all()

static int filter_all ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Remove all elements from our hashmap.

Parameters

cls	closure with the struct Operation *
key	current key code
value	value in the hash map

Returns

GNUNET_YES (we should continue to iterate)

Definition at line 1005 of file gnunet-service-set_intersection.c.

{
  struct Operation *op = cls;
  struct ElementEntry *ee = value;
 
  GNUNET_break (0 < op->state->my_element_count);
  op->state->my_element_count--;
  GNUNET_CRYPTO_hash_xor (&op->state->my_xor,
                          &ee->element_hash,
                          &op->state->my_xor);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Final reduction of my_elements, removing %s:%u\n",
              GNUNET_h2s (&ee->element_hash),
              ee->element.size);
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multihashmap_remove (op->state->my_elements,
                                                       &ee->element_hash,
                                                       ee));
  send_client_removed_element (op,
                               &ee->element);
  return GNUNET_YES;
}

References ElementEntry::element, ElementEntry::element_hash, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_multihashmap_remove(), GNUNET_CRYPTO_hash_xor(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_YES, op, send_client_removed_element(), GNUNET_SET_Element::size, and value.

Referenced by handle_intersection_p2p_done().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_intersection_p2p_done()

void handle_intersection_p2p_done	(	void *	cls,
		const struct IntersectionDoneMessage *	idm
	)

Handle a done message from a remote peer.

Parameters

cls	the intersection operation
idm	the message

Definition at line 1038 of file gnunet-service-set_intersection.c.

{
  struct Operation *op = cls;
 
  if (GNUNET_SET_OPERATION_INTERSECTION != op->set->operation)
  {
    GNUNET_break_op (0);
    fail_intersection_operation (op);
    return;
  }
  if (PHASE_BF_EXCHANGE != op->state->phase)
  {
    /* wrong phase to conclude? FIXME: Or should we allow this
       if the other peer has _initially_ already an empty set? */
    GNUNET_break_op (0);
    fail_intersection_operation (op);
    return;
  }
  if (0 == ntohl (idm->final_element_count))
  {
    /* other peer determined empty set is the intersection,
       remove all elements */
    GNUNET_CONTAINER_multihashmap_iterate (op->state->my_elements,
                                           &filter_all,
                                           op);
  }
  if ((op->state->my_element_count != ntohl (idm->final_element_count)) ||
      (0 != GNUNET_memcmp (&op->state->my_xor,
                           &idm->element_xor_hash)))
  {
    /* Other peer thinks we are done, but we disagree on the result! */
    GNUNET_break_op (0);
    fail_intersection_operation (op);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Got IntersectionDoneMessage, have %u elements in intersection\n",
              op->state->my_element_count);
  op->state->phase = PHASE_DONE_RECEIVED;
  GNUNET_CADET_receive_done (op->channel);
 
  GNUNET_assert (GNUNET_NO == op->state->client_done_sent);
  if (GNUNET_SET_RESULT_FULL == op->result_mode)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Sending full result set to client (%u elements)\n",
                GNUNET_CONTAINER_multihashmap_size (op->state->my_elements));
    op->state->full_result_iter
      = GNUNET_CONTAINER_multihashmap_iterator_create (op->state->my_elements);
    send_remaining_elements (op);
    return;
  }
  op->state->phase = PHASE_FINISHED;
  send_client_done_and_destroy (op);
}

References IntersectionDoneMessage::element_xor_hash, fail_intersection_operation(), filter_all(), IntersectionDoneMessage::final_element_count, GNUNET_assert, GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CONTAINER_multihashmap_iterator_create(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_memcmp, GNUNET_NO, GNUNET_SET_OPERATION_INTERSECTION, GNUNET_SET_RESULT_FULL, op, PHASE_BF_EXCHANGE, PHASE_DONE_RECEIVED, PHASE_FINISHED, send_client_done_and_destroy(), and send_remaining_elements().

Here is the call graph for this function:

intersection_evaluate()

static struct OperationState * intersection_evaluate ( struct Operation *  op, const struct GNUNET_MessageHeader *  opaque_context  )

static

Initiate a set intersection operation with a remote peer.

Parameters

op	operation that is created, should be initialized to begin the evaluation
opaque_context	message to be transmitted to the listener to convince it to accept, may be NULL

Returns

operation-specific state to keep in op

Definition at line 1106 of file gnunet-service-set_intersection.c.

{
  struct OperationState *state;
  struct GNUNET_MQ_Envelope *ev;
  struct OperationRequestMessage *msg;
 
  ev = GNUNET_MQ_msg_nested_mh (msg,
                                GNUNET_MESSAGE_TYPE_SET_P2P_OPERATION_REQUEST,
                                opaque_context);
  if (NULL == ev)
  {
    /* the context message is too large!? */
    GNUNET_break (0);
    return NULL;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Initiating intersection operation evaluation\n");
  state = GNUNET_new (struct OperationState);
  /* we started the operation, thus we have to send the operation request */
  state->phase = PHASE_INITIAL;
  state->my_element_count = op->set->state->current_set_element_count;
  state->my_elements
    = GNUNET_CONTAINER_multihashmap_create (state->my_element_count,
                                            GNUNET_YES);
 
  msg->operation = htonl (GNUNET_SET_OPERATION_INTERSECTION);
  msg->element_count = htonl (state->my_element_count);
  GNUNET_MQ_send (op->mq,
                  ev);
  state->phase = PHASE_COUNT_SENT;
  if (NULL != opaque_context)
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Sent op request with context message\n");
  else
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Sent op request without context message\n");
  return state;
}

References GNUNET_break, GNUNET_CONTAINER_multihashmap_create(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_SET_P2P_OPERATION_REQUEST, GNUNET_MQ_msg_nested_mh, GNUNET_MQ_send(), GNUNET_new, GNUNET_SET_OPERATION_INTERSECTION, GNUNET_YES, msg, op, PHASE_COUNT_SENT, PHASE_INITIAL, and state.

Referenced by _GSS_intersection_vt().

Here is the call graph for this function:

Here is the caller graph for this function:

intersection_accept()

static struct OperationState * intersection_accept ( struct Operation *  op )

static

Accept an intersection operation request from a remote peer.

Only initializes the private operation state.

Parameters

op	operation that will be accepted as an intersection operation

Definition at line 1154 of file gnunet-service-set_intersection.c.

{
  struct OperationState *state;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Accepting set intersection operation\n");
  state = GNUNET_new (struct OperationState);
  state->phase = PHASE_INITIAL;
  state->my_element_count
    = op->set->state->current_set_element_count;
  state->my_elements
    = GNUNET_CONTAINER_multihashmap_create (GNUNET_MIN (state->my_element_count,
                                                        op->remote_element_count),
                                            GNUNET_YES);
  op->state = state;
  if (op->remote_element_count < state->my_element_count)
  {
    /* If the other peer (Alice) has fewer elements than us (Bob),
       we just send the count as Alice should send the first BF */
    send_element_count (op);
    state->phase = PHASE_COUNT_SENT;
    return state;
  }
  /* We have fewer elements, so we start with the BF */
  begin_bf_exchange (op);
  return state;
}

References begin_bf_exchange(), GNUNET_CONTAINER_multihashmap_create(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MIN, GNUNET_new, GNUNET_YES, op, PHASE_COUNT_SENT, PHASE_INITIAL, send_element_count(), and state.

Referenced by _GSS_intersection_vt().

Here is the call graph for this function:

Here is the caller graph for this function:

intersection_op_cancel()

static void intersection_op_cancel ( struct Operation *  op )

static

Destroy the intersection operation.

Only things specific to the intersection operation are destroyed.

Parameters

op	intersection operation to destroy

Definition at line 1190 of file gnunet-service-set_intersection.c.

{
  /* check if the op was canceled twice */
  GNUNET_assert (NULL != op->state);
  if (NULL != op->state->remote_bf)
  {
    GNUNET_CONTAINER_bloomfilter_free (op->state->remote_bf);
    op->state->remote_bf = NULL;
  }
  if (NULL != op->state->local_bf)
  {
    GNUNET_CONTAINER_bloomfilter_free (op->state->local_bf);
    op->state->local_bf = NULL;
  }
  if (NULL != op->state->my_elements)
  {
    GNUNET_CONTAINER_multihashmap_destroy (op->state->my_elements);
    op->state->my_elements = NULL;
  }
  if (NULL != op->state->full_result_iter)
  {
    GNUNET_CONTAINER_multihashmap_iterator_destroy (
      op->state->full_result_iter);
    op->state->full_result_iter = NULL;
  }
  GNUNET_free (op->state);
  op->state = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Destroying intersection op state done\n");
}

References GNUNET_assert, GNUNET_CONTAINER_bloomfilter_free(), GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterator_destroy(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, and op.

Referenced by _GSS_intersection_vt().

Here is the call graph for this function:

Here is the caller graph for this function:

intersection_set_create()

static struct SetState * intersection_set_create ( )

static

Create a new set supporting the intersection operation.

Returns

the newly created set

Definition at line 1228 of file gnunet-service-set_intersection.c.

{
  struct SetState *set_state;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Intersection set created\n");
  set_state = GNUNET_new (struct SetState);
  set_state->current_set_element_count = 0;
 
  return set_state;
}

References SetState::current_set_element_count, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, and GNUNET_new.

Referenced by _GSS_intersection_vt().

Here is the caller graph for this function:

intersection_add()

static void intersection_add ( struct SetState *  set_state, struct ElementEntry *  ee  )

static

Add the element from the given element message to the set.

Parameters

set_state	state of the set want to add to
ee	the element to add to the set

Definition at line 1248 of file gnunet-service-set_intersection.c.

{
  set_state->current_set_element_count++;
}

References SetState::current_set_element_count.

Referenced by _GSS_intersection_vt().

Here is the caller graph for this function:

intersection_set_destroy()

static void intersection_set_destroy ( struct SetState *  set_state )

static

Destroy a set that supports the intersection operation.

Parameters

set_state

the set to destroy

Definition at line 1261 of file gnunet-service-set_intersection.c.

{
  GNUNET_free (set_state);
}

References GNUNET_free.

Referenced by _GSS_intersection_vt().

Here is the caller graph for this function:

intersection_remove()

static void intersection_remove ( struct SetState *  set_state, struct ElementEntry *  element  )

static

Remove the element given in the element message from the set.

Parameters

set_state	state of the set to remove from
element	set element to remove

Definition at line 1274 of file gnunet-service-set_intersection.c.

{
  GNUNET_assert (0 < set_state->current_set_element_count);
  set_state->current_set_element_count--;
}

References SetState::current_set_element_count, and GNUNET_assert.

Referenced by _GSS_intersection_vt().

Here is the caller graph for this function:

intersection_channel_death()

static void intersection_channel_death ( struct Operation *  op )

static

Callback for channel death for the intersection operation.

Parameters

op	operation that lost the channel

Definition at line 1288 of file gnunet-service-set_intersection.c.

{
  if (GNUNET_YES == op->state->channel_death_expected)
  {
    /* oh goodie, we are done! */
    send_client_done_and_destroy (op);
  }
  else
  {
    /* sorry, channel went down early, too bad. */
    _GSS_operation_destroy (op,
                            GNUNET_YES);
  }
}

References _GSS_operation_destroy(), GNUNET_YES, op, and send_client_done_and_destroy().

Referenced by _GSS_intersection_vt().

Here is the call graph for this function:

Here is the caller graph for this function:

_GSS_intersection_vt()

const struct SetVT * _GSS_intersection_vt

(

void

)

Get the table with implementing functions for set intersection.

Returns

the operation specific VTable

Definition at line 1310 of file gnunet-service-set_intersection.c.

{
  static const struct SetVT intersection_vt = {
    .create = &intersection_set_create,
    .add = &intersection_add,
    .remove = &intersection_remove,
    .destroy_set = &intersection_set_destroy,
    .evaluate = &intersection_evaluate,
    .accept = &intersection_accept,
    .cancel = &intersection_op_cancel,
    .channel_death = &intersection_channel_death,
  };
 
  return &intersection_vt;
}

References SetVT::create, intersection_accept(), intersection_add(), intersection_channel_death(), intersection_evaluate(), intersection_op_cancel(), intersection_remove(), intersection_set_create(), and intersection_set_destroy().

Referenced by handle_client_copy_lazy_connect(), and handle_client_create_set().

Here is the call graph for this function:

Here is the caller graph for this function: