gnunet-service-set_union.c File Reference

two-peer set operations More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_statistics_service.h"
#include "gnunet-service-set.h"
#include "ibf.h"
#include "gnunet-service-set_union.h"
#include "gnunet-service-set_union_strata_estimator.h"
#include "gnunet-service-set_protocol.h"
#include <gcrypt.h>

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

Go to the source code of this file.

Data Structures
struct	OperationState
	State of an evaluate operation with another peer. More...
struct	KeyEntry
	The key entry is used to associate an ibf key with an element. More...
struct	SendElementClosure
	Used as a closure for sending elements with a specific IBF key. More...
struct	SetState
	Extra state required for efficient set intersection. More...
struct	GetElementContext
	Context for op_get_element_iterator. More...

Macros
#define	LOG(kind, ...)   GNUNET_log_from (kind, "set-union", __VA_ARGS__)
#define	SE_STRATA_COUNT   32
	Number of IBFs in a strata estimator.
#define	SE_IBF_SIZE   80
	Size of the IBFs in the strata estimator.
#define	SE_IBF_HASH_NUM   4
	The hash num parameter for the difference digests and strata estimators.
#define	MAX_BUCKETS_PER_MESSAGE   ((1 << 15) / IBF_BUCKET_SIZE)
	Number of buckets that can be transmitted in one message.
#define	MAX_IBF_ORDER   (20)
	The maximum size of an ibf we use is 2^(MAX_IBF_ORDER).
#define	IBF_ALPHA   4
	Number of buckets used in the ibf per estimated difference.

Enumerations
enum	UnionOperationPhase {   PHASE_EXPECT_SE , PHASE_EXPECT_IBF , PHASE_EXPECT_IBF_CONT , PHASE_INVENTORY_ACTIVE ,   PHASE_INVENTORY_PASSIVE , PHASE_FINISH_CLOSING , PHASE_FINISH_WAITING , PHASE_DONE ,   PHASE_FULL_SENDING }
	Current phase we are in for a union operation. More...

Functions
static int	destroy_key_to_element_iter (void *cls, uint32_t key, void *value)
	Iterator over hash map entries, called to destroy the linked list of colliding ibf key entries.
static void	union_op_cancel (struct Operation *op)
	Destroy the union operation.
static void	fail_union_operation (struct Operation *op)
	Inform the client that the union operation has failed, and proceed to destroy the evaluate operation.
static struct IBF_Key	get_ibf_key (const struct GNUNET_HashCode *src)
	Derive the IBF key from a hash code and a salt.
static int	op_get_element_iterator (void *cls, uint32_t key, void *value)
	Iterator over the mapping from IBF keys to element entries.
static struct KeyEntry *	op_get_element (struct Operation *op, const struct GNUNET_HashCode *element_hash)
	Determine whether the given element is already in the operation's element set.
static void	op_register_element (struct Operation *op, struct ElementEntry *ee, int received)
	Insert an element into the union operation's key-to-element mapping.
static void	salt_key (const struct IBF_Key *k_in, uint32_t salt, struct IBF_Key *k_out)
	FIXME.
static void	unsalt_key (const struct IBF_Key *k_in, uint32_t salt, struct IBF_Key *k_out)
	FIXME.
static int	prepare_ibf_iterator (void *cls, uint32_t key, void *value)
	Insert a key into an ibf.
static int	init_key_to_element_iterator (void *cls, const struct GNUNET_HashCode *key, void *value)
	Iterator for initializing the key-to-element mapping of a union operation.
static void	initialize_key_to_element (struct Operation *op)
	Initialize the IBF key to element mapping local to this set operation.
static int	prepare_ibf (struct Operation *op, uint32_t size)
	Create an ibf with the operation's elements of the specified size.
static int	send_ibf (struct Operation *op, uint16_t ibf_order)
	Send an ibf of appropriate size.
static unsigned int	get_order_from_difference (unsigned int diff)
	Compute the necessary order of an ibf from the size of the symmetric set difference.
static int	send_full_element_iterator (void *cls, const struct GNUNET_HashCode *key, void *value)
	Send a set element.
static void	send_full_set (struct Operation *op)
	Switch to full set transmission for op.
int	check_union_p2p_strata_estimator (void *cls, const struct StrataEstimatorMessage *msg)
	Handle a strata estimator from a remote peer.
void	handle_union_p2p_strata_estimator (void *cls, const struct StrataEstimatorMessage *msg)
	Handle a strata estimator from a remote peer.
static int	send_offers_iterator (void *cls, uint32_t key, void *value)
	Iterator to send elements to a remote peer.
static void	send_offers_for_key (struct Operation *op, struct IBF_Key ibf_key)
	Send offers (in the form of GNUNET_Hash-es) to the remote peer for the given IBF key.
static int	decode_and_send (struct Operation *op)
	Decode which elements are missing on each side, and send the appropriate offers and inquiries.
int	check_union_p2p_ibf (void *cls, const struct IBFMessage *msg)
	Check an IBF message from a remote peer.
void	handle_union_p2p_ibf (void *cls, const struct IBFMessage *msg)
	Handle an IBF message from a remote peer.
static void	send_client_element (struct Operation *op, struct GNUNET_SET_Element *element, int status)
	Send a result message to the client indicating that there is a new element.
static void	send_client_done (void *cls)
	Signal to the client that the operation has finished and destroy the operation.
static void	maybe_finish (struct Operation *op)
	Tests if the operation is finished, and if so notify.
int	check_union_p2p_elements (void *cls, const struct GNUNET_SET_ElementMessage *emsg)
	Check an element message from a remote peer.
void	handle_union_p2p_elements (void *cls, const struct GNUNET_SET_ElementMessage *emsg)
	Handle an element message from a remote peer.
int	check_union_p2p_full_element (void *cls, const struct GNUNET_SET_ElementMessage *emsg)
	Check a full element message from a remote peer.
void	handle_union_p2p_full_element (void *cls, const struct GNUNET_SET_ElementMessage *emsg)
	Handle an element message from a remote peer.
int	check_union_p2p_inquiry (void *cls, const struct InquiryMessage *msg)
	Send offers (for GNUNET_Hash-es) in response to inquiries (for IBF_Key-s).
void	handle_union_p2p_inquiry (void *cls, const struct InquiryMessage *msg)
	Send offers (for GNUNET_Hash-es) in response to inquiries (for IBF_Key-s).
static int	send_missing_full_elements_iter (void *cls, uint32_t key, void *value)
	Iterator over hash map entries, called to destroy the linked list of colliding ibf key entries.
void	handle_union_p2p_request_full (void *cls, const struct GNUNET_MessageHeader *mh)
	Handle a request for full set transmission.
void	handle_union_p2p_full_done (void *cls, const struct GNUNET_MessageHeader *mh)
	Handle a "full done" message.
int	check_union_p2p_demand (void *cls, const struct GNUNET_MessageHeader *mh)
	Check a demand by the other peer for elements based on a list of struct GNUNET_HashCodes.
void	handle_union_p2p_demand (void *cls, const struct GNUNET_MessageHeader *mh)
	Handle a demand by the other peer for elements based on a list of struct GNUNET_HashCodes.
int	check_union_p2p_offer (void *cls, const struct GNUNET_MessageHeader *mh)
	Check offer (of struct GNUNET_HashCodes).
void	handle_union_p2p_offer (void *cls, const struct GNUNET_MessageHeader *mh)
	Handle offers (of struct GNUNET_HashCodes) and respond with demands (of struct GNUNET_HashCodes).
void	handle_union_p2p_done (void *cls, const struct GNUNET_MessageHeader *mh)
	Handle a done message from a remote peer.
void	handle_union_p2p_over (void *cls, const struct GNUNET_MessageHeader *mh)
	Handle an over message from a remote peer.
static struct OperationState *	union_evaluate (struct Operation *op, const struct GNUNET_MessageHeader *opaque_context)
	Initiate operation to evaluate a set union with a remote peer.
static struct OperationState *	union_accept (struct Operation *op)
	Accept an union operation request from a remote peer.
static struct SetState *	union_set_create (void)
	Create a new set supporting the union operation.
static void	union_add (struct SetState *set_state, struct ElementEntry *ee)
	Add the element from the given element message to the set.
static void	union_remove (struct SetState *set_state, struct ElementEntry *ee)
	Remove the element given in the element message from the set.
static void	union_set_destroy (struct SetState *set_state)
	Destroy a set that supports the union operation.
static struct SetState *	union_copy_state (struct SetState *state)
	Copy union-specific set state.
static void	union_channel_death (struct Operation *op)
	Handle case where channel went down for an operation.
const struct SetVT *	_GSS_union_vt ()
	Get the table with implementing functions for set union.

Detailed Description

two-peer set operations

Author

Florian Dold

Christian Grothoff

Definition in file gnunet-service-set_union.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from (kind, "set-union", __VA_ARGS__)

Definition at line 37 of file gnunet-service-set_union.c.

SE_STRATA_COUNT

#define SE_STRATA_COUNT   32

Number of IBFs in a strata estimator.

Definition at line 43 of file gnunet-service-set_union.c.

SE_IBF_SIZE

#define SE_IBF_SIZE   80

Size of the IBFs in the strata estimator.

Definition at line 48 of file gnunet-service-set_union.c.

SE_IBF_HASH_NUM

#define SE_IBF_HASH_NUM   4

The hash num parameter for the difference digests and strata estimators.

Definition at line 53 of file gnunet-service-set_union.c.

MAX_BUCKETS_PER_MESSAGE

#define MAX_BUCKETS_PER_MESSAGE   ((1 << 15) / IBF_BUCKET_SIZE)

Number of buckets that can be transmitted in one message.

Definition at line 58 of file gnunet-service-set_union.c.

MAX_IBF_ORDER

#define MAX_IBF_ORDER   (20)

The maximum size of an ibf we use is 2^(MAX_IBF_ORDER).

Choose this value so that computing the IBF is still cheaper than transmitting all values.

Definition at line 65 of file gnunet-service-set_union.c.

IBF_ALPHA

#define IBF_ALPHA   4

Number of buckets used in the ibf per estimated difference.

Definition at line 71 of file gnunet-service-set_union.c.

Enumeration Type Documentation

UnionOperationPhase

enum UnionOperationPhase

Current phase we are in for a union operation.

Enumerator
PHASE_EXPECT_SE	We sent the request message, and expect a strata estimator.
PHASE_EXPECT_IBF	We sent the strata estimator, and expect an IBF. This phase is entered once upon initialization and later via #PHASE_EXPECT_ELEMENTS_AND_REQUESTS. XXX: could use better wording. XXX: repurposed to also expect a "request full set" message, should be renamed After receiving the complete IBF, we enter #PHASE_EXPECT_ELEMENTS
PHASE_EXPECT_IBF_CONT	Continuation for multi part IBFs.
PHASE_INVENTORY_ACTIVE	We are decoding an IBF.
PHASE_INVENTORY_PASSIVE	The other peer is decoding the IBF we just sent.
PHASE_FINISH_CLOSING	The protocol is almost finished, but we still have to flush our message queue and/or expect some elements.
PHASE_FINISH_WAITING	In the penultimate phase, we wait until all our demands are satisfied. Then we send a done message, and wait for another done message.
PHASE_DONE	In the ultimate phase, we wait until our demands are satisfied and then quit (sending another DONE message).
PHASE_FULL_SENDING	After sending the full set, wait for responses with the elements that the local peer is missing.

Definition at line 77 of file gnunet-service-set_union.c.

{
  PHASE_EXPECT_SE,
 
  PHASE_EXPECT_IBF,
 
  PHASE_EXPECT_IBF_CONT,
 
  PHASE_INVENTORY_ACTIVE,
 
  PHASE_INVENTORY_PASSIVE,
 
  PHASE_FINISH_CLOSING,
 
  PHASE_FINISH_WAITING,
 
  PHASE_DONE,
 
  PHASE_FULL_SENDING,
};

Function Documentation

destroy_key_to_element_iter()

static int destroy_key_to_element_iter ( void *  cls, uint32_t  key, void *  value  )

static

Iterator over hash map entries, called to destroy the linked list of colliding ibf key entries.

Parameters

cls	closure
key	current key code
value	value in the hash map

Returns

GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

Definition at line 290 of file gnunet-service-set_union.c.

{
  struct KeyEntry *k = value;
 
  GNUNET_assert (NULL != k);
  if (GNUNET_YES == k->element->remote)
  {
    GNUNET_free (k->element);
    k->element = NULL;
  }
  GNUNET_free (k);
  return GNUNET_YES;
}

References KeyEntry::element, GNUNET_assert, GNUNET_free, GNUNET_YES, ElementEntry::remote, and value.

Referenced by union_op_cancel().

Here is the caller graph for this function:

union_op_cancel()

static void union_op_cancel ( struct Operation *  op )

static

Destroy the union operation.

Only things specific to the union operation are destroyed.

Parameters

op	union operation to destroy

Definition at line 314 of file gnunet-service-set_union.c.

{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "destroying union op\n");
  /* check if the op was canceled twice */
  GNUNET_assert (NULL != op->state);
  if (NULL != op->state->remote_ibf)
  {
    ibf_destroy (op->state->remote_ibf);
    op->state->remote_ibf = NULL;
  }
  if (NULL != op->state->demanded_hashes)
  {
    GNUNET_CONTAINER_multihashmap_destroy (op->state->demanded_hashes);
    op->state->demanded_hashes = NULL;
  }
  if (NULL != op->state->local_ibf)
  {
    ibf_destroy (op->state->local_ibf);
    op->state->local_ibf = NULL;
  }
  if (NULL != op->state->se)
  {
    strata_estimator_destroy (op->state->se);
    op->state->se = NULL;
  }
  if (NULL != op->state->key_to_element)
  {
    GNUNET_CONTAINER_multihashmap32_iterate (op->state->key_to_element,
                                             &destroy_key_to_element_iter,
                                             NULL);
    GNUNET_CONTAINER_multihashmap32_destroy (op->state->key_to_element);
    op->state->key_to_element = NULL;
  }
  GNUNET_free (op->state);
  op->state = NULL;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "destroying union op done\n");
}

References destroy_key_to_element_iter(), GNUNET_assert, GNUNET_CONTAINER_multihashmap32_destroy(), GNUNET_CONTAINER_multihashmap32_iterate(), GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, ibf_destroy(), LOG, op, and strata_estimator_destroy().

Referenced by _GSS_union_vt().

Here is the call graph for this function:

Here is the caller graph for this function:

fail_union_operation()

static void fail_union_operation ( struct Operation *  op )

static

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

Parameters

op	the union operation to fail

Definition at line 362 of file gnunet-service-set_union.c.

{
  struct GNUNET_MQ_Envelope *ev;
  struct GNUNET_SET_ResultMessage *msg;
 
  LOG (GNUNET_ERROR_TYPE_WARNING,
       "union operation failed\n");
  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(), GNUNET_ERROR_TYPE_WARNING, GNUNET_MESSAGE_TYPE_SET_RESULT, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_SET_STATUS_FAILURE, GNUNET_YES, LOG, msg, and op.

Referenced by decode_and_send(), handle_union_p2p_demand(), handle_union_p2p_done(), handle_union_p2p_elements(), handle_union_p2p_full_done(), handle_union_p2p_full_element(), handle_union_p2p_ibf(), handle_union_p2p_request_full(), and handle_union_p2p_strata_estimator().

Here is the call graph for this function:

Here is the caller graph for this function:

get_ibf_key()

static struct IBF_Key get_ibf_key ( const struct GNUNET_HashCode *  src )

static

Derive the IBF key from a hash code and a salt.

Parameters

src	the hash code

Returns

the derived IBF key

Definition at line 387 of file gnunet-service-set_union.c.

{
  struct IBF_Key key;
  uint16_t salt = 0;
 
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CRYPTO_kdf (&key, sizeof(key),
                                    src, sizeof *src,
                                    &salt, sizeof(salt),
                                    NULL, 0));
  return key;
}

References GNUNET_assert, GNUNET_CRYPTO_kdf(), GNUNET_OK, key, and salt.

Referenced by op_get_element(), op_register_element(), union_add(), and union_remove().

Here is the call graph for this function:

Here is the caller graph for this function:

op_get_element_iterator()

static int op_get_element_iterator ( void *  cls, uint32_t  key, void *  value  )

static

Iterator over the mapping from IBF keys to element entries.

Checks if we have an element with a given GNUNET_HashCode.

Parameters

cls	closure
key	current key code
value	value in the hash map

Returns

GNUNET_YES if we should search further, GNUNET_NO if we've found the element.

Definition at line 429 of file gnunet-service-set_union.c.

{
  struct GetElementContext *ctx = cls;
  struct KeyEntry *k = value;
 
  GNUNET_assert (NULL != k);
  if (0 == GNUNET_CRYPTO_hash_cmp (&k->element->element_hash,
                                   &ctx->hash))
  {
    ctx->k = k;
    return GNUNET_NO;
  }
  return GNUNET_YES;
}

References ctx, KeyEntry::element, ElementEntry::element_hash, GNUNET_assert, GNUNET_CRYPTO_hash_cmp(), GNUNET_NO, GNUNET_YES, and value.

Referenced by op_get_element().

Here is the call graph for this function:

Here is the caller graph for this function:

op_get_element()

static struct KeyEntry * op_get_element ( struct Operation *  op, const struct GNUNET_HashCode *  element_hash  )

static

Determine whether the given element is already in the operation's element set.

Parameters

op	operation that should be tested for 'element_hash'
element_hash	hash of the element to look for

Returns

GNUNET_YES if the element has been found, GNUNET_NO otherwise

Definition at line 456 of file gnunet-service-set_union.c.

{
  int ret;
  struct IBF_Key ibf_key;
  struct GetElementContext ctx = { { { 0 } }, 0 };
 
  ctx.hash = *element_hash;
 
  ibf_key = get_ibf_key (element_hash);
  ret = GNUNET_CONTAINER_multihashmap32_get_multiple (op->state->key_to_element,
                                                      (uint32_t) ibf_key.key_val,
                                                      op_get_element_iterator,
                                                      &ctx);
 
  /* was the iteration aborted because we found the element? */
  if (GNUNET_SYSERR == ret)
  {
    GNUNET_assert (NULL != ctx.k);
    return ctx.k;
  }
  return NULL;
}

References ctx, get_ibf_key(), GNUNET_assert, GNUNET_CONTAINER_multihashmap32_get_multiple(), GNUNET_SYSERR, IBF_Key::key_val, op, op_get_element_iterator(), and ret.

Referenced by handle_union_p2p_elements(), and handle_union_p2p_full_element().

Here is the call graph for this function:

Here is the caller graph for this function:

op_register_element()

static void op_register_element ( struct Operation *  op, struct ElementEntry *  ee, int  received  )

static

Insert an element into the union operation's key-to-element mapping.

Takes ownership of 'ee'. Note that this does not insert the element in the set, only in the operation's key-element mapping. This is done to speed up re-tried operations, if some elements were transmitted, and then the IBF fails to decode.

XXX: clarify ownership, doesn't sound right.

Parameters

op	the union operation
ee	the element entry
received	was this element received from the remote peer?

Definition at line 496 of file gnunet-service-set_union.c.

{
  struct IBF_Key ibf_key;
  struct KeyEntry *k;
 
  ibf_key = get_ibf_key (&ee->element_hash);
  k = GNUNET_new (struct KeyEntry);
  k->element = ee;
  k->ibf_key = ibf_key;
  k->received = received;
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multihashmap32_put (op->state->key_to_element,
                                                      (uint32_t) ibf_key.key_val,
                                                      k,
                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
}

References KeyEntry::element, ElementEntry::element_hash, get_ibf_key(), GNUNET_assert, GNUNET_CONTAINER_multihashmap32_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_new, GNUNET_OK, KeyEntry::ibf_key, IBF_Key::key_val, op, and KeyEntry::received.

Referenced by handle_union_p2p_elements(), handle_union_p2p_full_element(), and init_key_to_element_iterator().

Here is the call graph for this function:

Here is the caller graph for this function:

salt_key()

static void salt_key ( const struct IBF_Key *  k_in, uint32_t  salt, struct IBF_Key *  k_out  )

static

FIXME.

Definition at line 520 of file gnunet-service-set_union.c.

{
  int s = salt % 64;
  uint64_t x = k_in->key_val;
 
  /* rotate ibf key */
  x = (x >> s) | (x << (64 - s));
  k_out->key_val = x;
}

References IBF_Key::key_val, and salt.

Referenced by prepare_ibf_iterator().

Here is the caller graph for this function:

unsalt_key()

static void unsalt_key ( const struct IBF_Key *  k_in, uint32_t  salt, struct IBF_Key *  k_out  )

static

FIXME.

Definition at line 537 of file gnunet-service-set_union.c.

{
  int s = salt % 64;
  uint64_t x = k_in->key_val;
 
  x = (x << s) | (x >> (64 - s));
  k_out->key_val = x;
}

References IBF_Key::key_val, and salt.

Referenced by decode_and_send(), and handle_union_p2p_inquiry().

Here is the caller graph for this function:

prepare_ibf_iterator()

static int prepare_ibf_iterator ( void *  cls, uint32_t  key, void *  value  )

static

Insert a key into an ibf.

Parameters

cls	the ibf
key	unused
value	the key entry to get the key from

Definition at line 557 of file gnunet-service-set_union.c.

{
  struct Operation *op = cls;
  struct KeyEntry *ke = value;
  struct IBF_Key salted_key;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "[OP %p] inserting %lx (hash %s) into ibf\n",
       op,
       (unsigned long) ke->ibf_key.key_val,
       GNUNET_h2s (&ke->element->element_hash));
  salt_key (&ke->ibf_key,
            op->state->salt_send,
            &salted_key);
  ibf_insert (op->state->local_ibf, salted_key);
  return GNUNET_YES;
}

References KeyEntry::element, ElementEntry::element_hash, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_YES, ibf_insert(), KeyEntry::ibf_key, IBF_Key::key_val, LOG, op, salt_key(), and value.

Referenced by prepare_ibf().

Here is the call graph for this function:

Here is the caller graph for this function:

init_key_to_element_iterator()

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

static

Iterator for initializing the key-to-element mapping of a union operation.

Parameters

cls	the union operation struct Operation *
key	unused
value	the struct ElementEntry * to insert into the key-to-element mapping

Returns

GNUNET_YES (to continue iterating)

Definition at line 589 of file gnunet-service-set_union.c.

{
  struct Operation *op = cls;
  struct ElementEntry *ee = value;
 
  /* make sure that the element belongs to the set at the time
   * of creating the operation */
  if (GNUNET_NO ==
      _GSS_is_element_of_operation (ee,
                                    op))
    return GNUNET_YES;
  GNUNET_assert (GNUNET_NO == ee->remote);
  op_register_element (op,
                       ee,
                       GNUNET_NO);
  return GNUNET_YES;
}

References _GSS_is_element_of_operation(), GNUNET_assert, GNUNET_NO, GNUNET_YES, op, op_register_element(), ElementEntry::remote, and value.

Referenced by initialize_key_to_element().

Here is the call graph for this function:

Here is the caller graph for this function:

initialize_key_to_element()

static void initialize_key_to_element ( struct Operation *  op )

static

Initialize the IBF key to element mapping local to this set operation.

Parameters

op	the set union operation

Definition at line 617 of file gnunet-service-set_union.c.

{
  unsigned int len;
 
  GNUNET_assert (NULL == op->state->key_to_element);
  len = GNUNET_CONTAINER_multihashmap_size (op->set->content->elements);
  op->state->key_to_element = GNUNET_CONTAINER_multihashmap32_create (len + 1);
  GNUNET_CONTAINER_multihashmap_iterate (op->set->content->elements,
                                         &init_key_to_element_iterator,
                                         op);
}

References GNUNET_assert, GNUNET_CONTAINER_multihashmap32_create(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CONTAINER_multihashmap_size(), init_key_to_element_iterator(), and op.

Referenced by union_accept(), and union_evaluate().

Here is the call graph for this function:

Here is the caller graph for this function:

prepare_ibf()

static int prepare_ibf ( struct Operation *  op, uint32_t  size  )

static

Create an ibf with the operation's elements of the specified size.

Parameters

op	the union operation
size	size of the ibf to create

Returns

GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 639 of file gnunet-service-set_union.c.

{
  GNUNET_assert (NULL != op->state->key_to_element);
 
  if (NULL != op->state->local_ibf)
    ibf_destroy (op->state->local_ibf);
  op->state->local_ibf = ibf_create (size, SE_IBF_HASH_NUM);
  if (NULL == op->state->local_ibf)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to allocate local IBF\n");
    return GNUNET_SYSERR;
  }
  GNUNET_CONTAINER_multihashmap32_iterate (op->state->key_to_element,
                                           &prepare_ibf_iterator,
                                           op);
  return GNUNET_OK;
}

References GNUNET_assert, GNUNET_CONTAINER_multihashmap32_iterate(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_OK, GNUNET_SYSERR, ibf_create(), ibf_destroy(), op, prepare_ibf_iterator(), SE_IBF_HASH_NUM, and size.

Referenced by decode_and_send(), and send_ibf().

Here is the call graph for this function:

Here is the caller graph for this function:

send_ibf()

static int send_ibf ( struct Operation *  op, uint16_t  ibf_order  )

static

Send an ibf of appropriate size.

Fragments the IBF into multiple messages if necessary.

Parameters

op	the union operation
ibf_order	order of the ibf to send, size=2^order

Returns

GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 670 of file gnunet-service-set_union.c.

{
  unsigned int buckets_sent = 0;
  struct InvertibleBloomFilter *ibf;
 
  if (GNUNET_OK !=
      prepare_ibf (op, 1 << ibf_order))
  {
    /* allocation failed */
    return GNUNET_SYSERR;
  }
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "sending ibf of size %u\n",
       1 << ibf_order);
 
  {
    char name[64] = { 0 };
    snprintf (name, sizeof(name), "# sent IBF (order %u)", ibf_order);
    GNUNET_STATISTICS_update (_GSS_statistics, name, 1, GNUNET_NO);
  }
 
  ibf = op->state->local_ibf;
 
  while (buckets_sent < (1 << ibf_order))
  {
    unsigned int buckets_in_message;
    struct GNUNET_MQ_Envelope *ev;
    struct IBFMessage *msg;
 
    buckets_in_message = (1 << ibf_order) - buckets_sent;
    /* limit to maximum */
    if (buckets_in_message > MAX_BUCKETS_PER_MESSAGE)
      buckets_in_message = MAX_BUCKETS_PER_MESSAGE;
 
    ev = GNUNET_MQ_msg_extra (msg,
                              buckets_in_message * IBF_BUCKET_SIZE,
                              GNUNET_MESSAGE_TYPE_SET_UNION_P2P_IBF);
    msg->reserved1 = 0;
    msg->reserved2 = 0;
    msg->order = ibf_order;
    msg->offset = htonl (buckets_sent);
    msg->salt = htonl (op->state->salt_send);
    ibf_write_slice (ibf, buckets_sent,
                     buckets_in_message, &msg[1]);
    buckets_sent += buckets_in_message;
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "ibf chunk size %u, %u/%u sent\n",
         buckets_in_message,
         buckets_sent,
         1 << ibf_order);
    GNUNET_MQ_send (op->mq, ev);
  }
 
  /* The other peer must decode the IBF, so
   * we're passive. */
  op->state->phase = PHASE_INVENTORY_PASSIVE;
  return GNUNET_OK;
}

References _GSS_statistics, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_SET_UNION_P2P_IBF, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_SYSERR, IBF_BUCKET_SIZE, ibf_write_slice(), LOG, MAX_BUCKETS_PER_MESSAGE, msg, name, op, PHASE_INVENTORY_PASSIVE, and prepare_ibf().

Referenced by decode_and_send(), and handle_union_p2p_strata_estimator().

Here is the call graph for this function:

Here is the caller graph for this function:

get_order_from_difference()

static unsigned int get_order_from_difference ( unsigned int  diff )

static

Compute the necessary order of an ibf from the size of the symmetric set difference.

Parameters

diff	the difference

Returns

the required size of the ibf

Definition at line 740 of file gnunet-service-set_union.c.

{
  unsigned int ibf_order;
 
  ibf_order = 2;
  while (((1 << ibf_order) < (IBF_ALPHA * diff) ||
          ((1 << ibf_order) < SE_IBF_HASH_NUM)) &&
         (ibf_order < MAX_IBF_ORDER))
    ibf_order++;
  // add one for correction
  return ibf_order + 1;
}

References IBF_ALPHA, MAX_IBF_ORDER, and SE_IBF_HASH_NUM.

Referenced by handle_union_p2p_strata_estimator().

Here is the caller graph for this function:

send_full_element_iterator()

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

static

Send a set element.

Parameters

cls	the union operation struct Operation *
key	unused
value	the struct ElementEntry * to insert into the key-to-element mapping

Returns

GNUNET_YES (to continue iterating)

Definition at line 764 of file gnunet-service-set_union.c.

{
  struct Operation *op = cls;
  struct GNUNET_SET_ElementMessage *emsg;
  struct ElementEntry *ee = value;
  struct GNUNET_SET_Element *el = &ee->element;
  struct GNUNET_MQ_Envelope *ev;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Sending element %s\n",
       GNUNET_h2s (key));
  ev = GNUNET_MQ_msg_extra (emsg,
                            el->size,
                            GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_ELEMENT);
  emsg->element_type = htons (el->element_type);
  GNUNET_memcpy (&emsg[1],
                 el->data,
                 el->size);
  GNUNET_MQ_send (op->mq,
                  ev);
  return GNUNET_YES;
}

References el, ElementEntry::element, GNUNET_SET_ElementMessage::element_type, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_ELEMENT, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_YES, key, LOG, op, and value.

Referenced by send_full_set().

Here is the call graph for this function:

Here is the caller graph for this function:

send_full_set()

static void send_full_set ( struct Operation *  op )

static

Switch to full set transmission for op.

Parameters

op	operation to switch to full set transmission.

Definition at line 796 of file gnunet-service-set_union.c.

{
  struct GNUNET_MQ_Envelope *ev;
 
  op->state->phase = PHASE_FULL_SENDING;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Dedicing to transmit the full set\n");
  /* FIXME: use a more memory-friendly way of doing this with an
     iterator, just as we do in the non-full case! */
  (void) GNUNET_CONTAINER_multihashmap_iterate (op->set->content->elements,
                                                &send_full_element_iterator,
                                                op);
  ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_DONE);
  GNUNET_MQ_send (op->mq,
                  ev);
}

References GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_DONE, GNUNET_MQ_msg_header, GNUNET_MQ_send(), LOG, op, PHASE_FULL_SENDING, and send_full_element_iterator().

Referenced by handle_union_p2p_request_full(), and handle_union_p2p_strata_estimator().

Here is the call graph for this function:

Here is the caller graph for this function:

check_union_p2p_strata_estimator()

int check_union_p2p_strata_estimator	(	void *	cls,
		const struct StrataEstimatorMessage *	msg
	)

Handle a strata estimator from a remote peer.

Parameters

cls	the union operation
msg	the message

Definition at line 821 of file gnunet-service-set_union.c.

{
  struct Operation *op = cls;
  int is_compressed;
  size_t len;
 
  if (op->state->phase != PHASE_EXPECT_SE)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  is_compressed = (GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SEC == htons (
                     msg->header.type));
  len = ntohs (msg->header.size) - sizeof(struct StrataEstimatorMessage);
  if ((GNUNET_NO == is_compressed) &&
      (len != SE_STRATA_COUNT * SE_IBF_SIZE * IBF_BUCKET_SIZE))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SEC, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, IBF_BUCKET_SIZE, msg, op, PHASE_EXPECT_SE, SE_IBF_SIZE, SE_STRATA_COUNT, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

handle_union_p2p_strata_estimator()

void handle_union_p2p_strata_estimator	(	void *	cls,
		const struct StrataEstimatorMessage *	msg
	)

Handle a strata estimator from a remote peer.

Parameters

cls	the union operation
msg	the message

Definition at line 853 of file gnunet-service-set_union.c.

{
  struct Operation *op = cls;
  struct StrataEstimator *remote_se;
  unsigned int diff;
  uint64_t other_size;
  size_t len;
  int is_compressed;
 
  is_compressed = (GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SEC == htons (
                     msg->header.type));
  GNUNET_STATISTICS_update (_GSS_statistics,
                            "# bytes of SE received",
                            ntohs (msg->header.size),
                            GNUNET_NO);
  len = ntohs (msg->header.size) - sizeof(struct StrataEstimatorMessage);
  other_size = GNUNET_ntohll (msg->set_size);
  remote_se = strata_estimator_create (SE_STRATA_COUNT,
                                       SE_IBF_SIZE,
                                       SE_IBF_HASH_NUM);
  if (NULL == remote_se)
  {
    /* insufficient resources, fail */
    fail_union_operation (op);
    return;
  }
  if (GNUNET_OK !=
      strata_estimator_read (&msg[1],
                             len,
                             is_compressed,
                             remote_se))
  {
    /* decompression failed */
    strata_estimator_destroy (remote_se);
    fail_union_operation (op);
    return;
  }
  GNUNET_assert (NULL != op->state->se);
  diff = strata_estimator_difference (remote_se,
                                      op->state->se);
 
  if (diff > 200)
    diff = diff * 3 / 2;
 
  strata_estimator_destroy (remote_se);
  strata_estimator_destroy (op->state->se);
  op->state->se = NULL;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "got se diff=%d, using ibf size %d\n",
       diff,
       1U << get_order_from_difference (diff));
 
  {
    char *set_debug;
 
    set_debug = getenv ("GNUNET_SET_BENCHMARK");
    if ((NULL != set_debug) &&
        (0 == strcmp (set_debug, "1")))
    {
      FILE *f = fopen ("set.log", "a");
      fprintf (f, "%llu\n", (unsigned long long) diff);
      fclose (f);
    }
  }
 
  if ((GNUNET_YES == op->byzantine) &&
      (other_size < op->byzantine_lower_bound))
  {
    GNUNET_break (0);
    fail_union_operation (op);
    return;
  }
 
  if ((GNUNET_YES == op->force_full) ||
      (diff > op->state->initial_size / 4) ||
      (0 == other_size))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Deciding to go for full set transmission (diff=%d, own set=%llu)\n",
         diff,
         (unsigned long long) op->state->initial_size);
    GNUNET_STATISTICS_update (_GSS_statistics,
                              "# of full sends",
                              1,
                              GNUNET_NO);
    if ((op->state->initial_size <= other_size) ||
        (0 == other_size))
    {
      send_full_set (op);
    }
    else
    {
      struct GNUNET_MQ_Envelope *ev;
 
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Telling other peer that we expect its full set\n");
      op->state->phase = PHASE_EXPECT_IBF;
      ev = GNUNET_MQ_msg_header (
        GNUNET_MESSAGE_TYPE_SET_UNION_P2P_REQUEST_FULL);
      GNUNET_MQ_send (op->mq,
                      ev);
    }
  }
  else
  {
    GNUNET_STATISTICS_update (_GSS_statistics,
                              "# of ibf sends",
                              1,
                              GNUNET_NO);
    if (GNUNET_OK !=
        send_ibf (op,
                  get_order_from_difference (diff)))
    {
      /* Internal error, best we can do is shut the connection */
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Failed to send IBF, closing connection\n");
      fail_union_operation (op);
      return;
    }
  }
  GNUNET_CADET_receive_done (op->channel);
}

References _GSS_statistics, fail_union_operation(), get_order_from_difference(), getenv(), GNUNET_assert, GNUNET_break, GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_MESSAGE_TYPE_SET_UNION_P2P_REQUEST_FULL, GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SEC, GNUNET_MQ_msg_header, GNUNET_MQ_send(), GNUNET_NO, GNUNET_ntohll(), GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_YES, LOG, msg, op, PHASE_EXPECT_IBF, SE_IBF_HASH_NUM, SE_IBF_SIZE, SE_STRATA_COUNT, send_full_set(), send_ibf(), GNUNET_MessageHeader::size, strata_estimator_create(), strata_estimator_destroy(), strata_estimator_difference(), strata_estimator_read(), and GNUNET_MessageHeader::type.

Here is the call graph for this function:

send_offers_iterator()

static int send_offers_iterator ( void *  cls, uint32_t  key, void *  value  )

static

Iterator to send elements to a remote peer.

Parameters

cls	closure with the element key and the union operation
key	ignored
value	the key entry

Definition at line 986 of file gnunet-service-set_union.c.

{
  struct SendElementClosure *sec = cls;
  struct Operation *op = sec->op;
  struct KeyEntry *ke = value;
  struct GNUNET_MQ_Envelope *ev;
  struct GNUNET_MessageHeader *mh;
 
  /* Detect 32-bit key collision for the 64-bit IBF keys. */
  if (ke->ibf_key.key_val != sec->ibf_key.key_val)
    return GNUNET_YES;
 
  ev = GNUNET_MQ_msg_header_extra (mh,
                                   sizeof(struct GNUNET_HashCode),
                                   GNUNET_MESSAGE_TYPE_SET_UNION_P2P_OFFER);
 
  GNUNET_assert (NULL != ev);
  *(struct GNUNET_HashCode *) &mh[1] = ke->element->element_hash;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "[OP %p] sending element offer (%s) to peer\n",
       op,
       GNUNET_h2s (&ke->element->element_hash));
  GNUNET_MQ_send (op->mq, ev);
  return GNUNET_YES;
}

References KeyEntry::element, ElementEntry::element_hash, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_MESSAGE_TYPE_SET_UNION_P2P_OFFER, GNUNET_MQ_msg_header_extra, GNUNET_MQ_send(), GNUNET_YES, KeyEntry::ibf_key, SendElementClosure::ibf_key, IBF_Key::key_val, LOG, mh, op, SendElementClosure::op, and value.

Referenced by send_offers_for_key().

Here is the call graph for this function:

Here is the caller graph for this function:

send_offers_for_key()

static void send_offers_for_key ( struct Operation *  op, struct IBF_Key  ibf_key  )

static

Send offers (in the form of GNUNET_Hash-es) to the remote peer for the given IBF key.

Parameters

op	union operation
ibf_key	IBF key of interest

Definition at line 1022 of file gnunet-service-set_union.c.

{
  struct SendElementClosure send_cls;
 
  send_cls.ibf_key = ibf_key;
  send_cls.op = op;
  (void) GNUNET_CONTAINER_multihashmap32_get_multiple (
    op->state->key_to_element,
    (uint32_t) ibf_key.
    key_val,
    &send_offers_iterator,
    &send_cls);
}

References GNUNET_CONTAINER_multihashmap32_get_multiple(), SendElementClosure::ibf_key, op, SendElementClosure::op, and send_offers_iterator().

Referenced by decode_and_send(), and handle_union_p2p_inquiry().

Here is the call graph for this function:

Here is the caller graph for this function:

decode_and_send()

static int decode_and_send ( struct Operation *  op )

static

Decode which elements are missing on each side, and send the appropriate offers and inquiries.

Parameters

op	union operation

Returns

GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 1046 of file gnunet-service-set_union.c.

{
  struct IBF_Key key;
  struct IBF_Key last_key;
  int side;
  unsigned int num_decoded;
  struct InvertibleBloomFilter *diff_ibf;
 
  GNUNET_assert (PHASE_INVENTORY_ACTIVE == op->state->phase);
 
  if (GNUNET_OK !=
      prepare_ibf (op,
                   op->state->remote_ibf->size))
  {
    GNUNET_break (0);
    /* allocation failed */
    return GNUNET_SYSERR;
  }
  diff_ibf = ibf_dup (op->state->local_ibf);
  ibf_subtract (diff_ibf,
                op->state->remote_ibf);
 
  ibf_destroy (op->state->remote_ibf);
  op->state->remote_ibf = NULL;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "decoding IBF (size=%u)\n",
       diff_ibf->size);
 
  num_decoded = 0;
  key.key_val = 0; /* just to avoid compiler thinking we use undef'ed variable */
 
  while (1)
  {
    int res;
    int cycle_detected = GNUNET_NO;
 
    last_key = key;
 
    res = ibf_decode (diff_ibf, &side, &key);
    if (res == GNUNET_OK)
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "decoded ibf key %lx\n",
           (unsigned long) key.key_val);
      num_decoded += 1;
      if ((num_decoded > diff_ibf->size) ||
          ((num_decoded > 1) &&
           (last_key.key_val == key.key_val)))
      {
        LOG (GNUNET_ERROR_TYPE_DEBUG,
             "detected cyclic ibf (decoded %u/%u)\n",
             num_decoded,
             diff_ibf->size);
        cycle_detected = GNUNET_YES;
      }
    }
    if ((GNUNET_SYSERR == res) ||
        (GNUNET_YES == cycle_detected))
    {
      int next_order;
      next_order = 0;
      while (1 << next_order < diff_ibf->size)
        next_order++;
      next_order++;
      if (next_order <= MAX_IBF_ORDER)
      {
        LOG (GNUNET_ERROR_TYPE_DEBUG,
             "decoding failed, sending larger ibf (size %u)\n",
             1 << next_order);
        GNUNET_STATISTICS_update (_GSS_statistics,
                                  "# of IBF retries",
                                  1,
                                  GNUNET_NO);
        op->state->salt_send++;
        if (GNUNET_OK !=
            send_ibf (op, next_order))
        {
          /* Internal error, best we can do is shut the connection */
          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                      "Failed to send IBF, closing connection\n");
          fail_union_operation (op);
          ibf_destroy (diff_ibf);
          return GNUNET_SYSERR;
        }
      }
      else
      {
        GNUNET_STATISTICS_update (_GSS_statistics,
                                  "# of failed union operations (too large)",
                                  1,
                                  GNUNET_NO);
        // XXX: Send the whole set, element-by-element
        LOG (GNUNET_ERROR_TYPE_ERROR,
             "set union failed: reached ibf limit\n");
        fail_union_operation (op);
        ibf_destroy (diff_ibf);
        return GNUNET_SYSERR;
      }
      break;
    }
    if (GNUNET_NO == res)
    {
      struct GNUNET_MQ_Envelope *ev;
 
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "transmitted all values, sending DONE\n");
      ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SET_UNION_P2P_DONE);
      GNUNET_MQ_send (op->mq, ev);
      /* We now wait until we get a DONE message back
       * and then wait for our MQ to be flushed and all our
       * demands be delivered. */
      break;
    }
    if (1 == side)
    {
      struct IBF_Key unsalted_key;
 
      unsalt_key (&key,
                  op->state->salt_receive,
                  &unsalted_key);
      send_offers_for_key (op,
                           unsalted_key);
    }
    else if (-1 == side)
    {
      struct GNUNET_MQ_Envelope *ev;
      struct InquiryMessage *msg;
 
      /* It may be nice to merge multiple requests, but with CADET's corking it is not worth
       * the effort additional complexity. */
      ev = GNUNET_MQ_msg_extra (msg,
                                sizeof(struct IBF_Key),
                                GNUNET_MESSAGE_TYPE_SET_UNION_P2P_INQUIRY);
      msg->salt = htonl (op->state->salt_receive);
      GNUNET_memcpy (&msg[1],
                     &key,
                     sizeof(struct IBF_Key));
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "sending element inquiry for IBF key %lx\n",
           (unsigned long) key.key_val);
      GNUNET_MQ_send (op->mq, ev);
    }
    else
    {
      GNUNET_assert (0);
    }
  }
  ibf_destroy (diff_ibf);
  return GNUNET_OK;
}

References _GSS_statistics, fail_union_operation(), GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SET_UNION_P2P_DONE, GNUNET_MESSAGE_TYPE_SET_UNION_P2P_INQUIRY, GNUNET_MQ_msg_extra, GNUNET_MQ_msg_header, GNUNET_MQ_send(), GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_YES, ibf_decode(), ibf_destroy(), ibf_dup(), ibf_subtract(), key, IBF_Key::key_val, LOG, MAX_IBF_ORDER, msg, op, PHASE_INVENTORY_ACTIVE, prepare_ibf(), res, send_ibf(), send_offers_for_key(), InvertibleBloomFilter::size, size, and unsalt_key().

Referenced by handle_union_p2p_ibf().

Here is the call graph for this function:

Here is the caller graph for this function:

check_union_p2p_ibf()

int check_union_p2p_ibf	(	void *	cls,
		const struct IBFMessage *	msg
	)

Check an IBF message from a remote peer.

Reassemble the IBF from multiple pieces, and process the whole IBF once possible.

Parameters

cls	the union operation
msg	the header of the message

Returns

GNUNET_OK if msg is well-formed

Definition at line 1210 of file gnunet-service-set_union.c.

{
  struct Operation *op = cls;
  unsigned int buckets_in_message;
 
  if (GNUNET_SET_OPERATION_UNION != op->set->operation)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  buckets_in_message = (ntohs (msg->header.size) - sizeof *msg)
                       / IBF_BUCKET_SIZE;
  if (0 == buckets_in_message)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if ((ntohs (msg->header.size) - sizeof *msg) != buckets_in_message
      * IBF_BUCKET_SIZE)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if (op->state->phase == PHASE_EXPECT_IBF_CONT)
  {
    if (ntohl (msg->offset) != op->state->ibf_buckets_received)
    {
      GNUNET_break_op (0);
      return GNUNET_SYSERR;
    }
    if (1 << msg->order != op->state->remote_ibf->size)
    {
      GNUNET_break_op (0);
      return GNUNET_SYSERR;
    }
    if (ntohl (msg->salt) != op->state->salt_receive)
    {
      GNUNET_break_op (0);
      return GNUNET_SYSERR;
    }
  }
  else if ((op->state->phase != PHASE_INVENTORY_PASSIVE) &&
           (op->state->phase != PHASE_EXPECT_IBF))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
 
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_OK, GNUNET_SET_OPERATION_UNION, GNUNET_SYSERR, IBF_BUCKET_SIZE, msg, op, PHASE_EXPECT_IBF, PHASE_EXPECT_IBF_CONT, PHASE_INVENTORY_PASSIVE, and GNUNET_MessageHeader::size.

handle_union_p2p_ibf()

void handle_union_p2p_ibf	(	void *	cls,
		const struct IBFMessage *	msg
	)

Handle an IBF message from a remote peer.

Reassemble the IBF from multiple pieces, and process the whole IBF once possible.

Parameters

cls	the union operation
msg	the header of the message

Definition at line 1273 of file gnunet-service-set_union.c.

{
  struct Operation *op = cls;
  unsigned int buckets_in_message;
 
  buckets_in_message = (ntohs (msg->header.size) - sizeof *msg)
                       / IBF_BUCKET_SIZE;
  if ((op->state->phase == PHASE_INVENTORY_PASSIVE) ||
      (op->state->phase == PHASE_EXPECT_IBF))
  {
    op->state->phase = PHASE_EXPECT_IBF_CONT;
    GNUNET_assert (NULL == op->state->remote_ibf);
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Creating new ibf of size %u\n",
         1 << msg->order);
    op->state->remote_ibf = ibf_create (1 << msg->order, SE_IBF_HASH_NUM);
    op->state->salt_receive = ntohl (msg->salt);
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Receiving new IBF with salt %u\n",
         op->state->salt_receive);
    if (NULL == op->state->remote_ibf)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Failed to parse remote IBF, closing connection\n");
      fail_union_operation (op);
      return;
    }
    op->state->ibf_buckets_received = 0;
    if (0 != ntohl (msg->offset))
    {
      GNUNET_break_op (0);
      fail_union_operation (op);
      return;
    }
  }
  else
  {
    GNUNET_assert (op->state->phase == PHASE_EXPECT_IBF_CONT);
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Received more of IBF\n");
  }
  GNUNET_assert (NULL != op->state->remote_ibf);
 
  ibf_read_slice (&msg[1],
                  op->state->ibf_buckets_received,
                  buckets_in_message,
                  op->state->remote_ibf);
  op->state->ibf_buckets_received += buckets_in_message;
 
  if (op->state->ibf_buckets_received == op->state->remote_ibf->size)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "received full ibf\n");
    op->state->phase = PHASE_INVENTORY_ACTIVE;
    if (GNUNET_OK !=
        decode_and_send (op))
    {
      /* Internal error, best we can do is shut down */
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Failed to decode IBF, closing connection\n");
      fail_union_operation (op);
      return;
    }
  }
  GNUNET_CADET_receive_done (op->channel);
}

References decode_and_send(), fail_union_operation(), GNUNET_assert, GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_OK, IBF_BUCKET_SIZE, ibf_create(), ibf_read_slice(), LOG, msg, op, PHASE_EXPECT_IBF, PHASE_EXPECT_IBF_CONT, PHASE_INVENTORY_ACTIVE, PHASE_INVENTORY_PASSIVE, SE_IBF_HASH_NUM, and GNUNET_MessageHeader::size.

Here is the call graph for this function:

send_client_element()

static void send_client_element ( struct Operation *  op, struct GNUNET_SET_Element *  element, int  status  )

static

Send a result message to the client indicating that there is a new element.

Parameters

op	union operation
element	element to send
status	status to send with the new element

Definition at line 1351 of file gnunet-service-set_union.c.

{
  struct GNUNET_MQ_Envelope *ev;
  struct GNUNET_SET_ResultMessage *rm;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "sending element (size %u) to client\n",
       element->size);
  GNUNET_assert (0 != op->client_request_id);
  ev = GNUNET_MQ_msg_extra (rm, element->size, GNUNET_MESSAGE_TYPE_SET_RESULT);
  if (NULL == ev)
  {
    GNUNET_MQ_discard (ev);
    GNUNET_break (0);
    return;
  }
  rm->result_status = htons (status);
  rm->request_id = htonl (op->client_request_id);
  rm->element_type = htons (element->element_type);
  rm->current_size = GNUNET_htonll (GNUNET_CONTAINER_multihashmap32_size (
                                      op->state->key_to_element));
  GNUNET_memcpy (&rm[1],
                 element->data,
                 element->size);
  GNUNET_MQ_send (op->set->cs->mq,
                  ev);
}

References GNUNET_SET_ResultMessage::current_size, GNUNET_SET_Element::data, GNUNET_SET_ResultMessage::element_type, GNUNET_SET_Element::element_type, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_multihashmap32_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_htonll(), GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SET_RESULT, GNUNET_MQ_discard(), GNUNET_MQ_msg_extra, GNUNET_MQ_send(), LOG, op, GNUNET_SET_ResultMessage::request_id, GNUNET_SET_ResultMessage::result_status, GNUNET_SET_Element::size, and status.

Referenced by handle_union_p2p_demand(), handle_union_p2p_elements(), and handle_union_p2p_full_element().

Here is the call graph for this function:

Here is the caller graph for this function:

send_client_done()

static void send_client_done ( void *  cls )

static

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

Parameters

cls	operation to destroy

Definition at line 1389 of file gnunet-service-set_union.c.

{
  struct Operation *op = cls;
  struct GNUNET_MQ_Envelope *ev;
  struct GNUNET_SET_ResultMessage *rm;
 
  if (GNUNET_YES == op->state->client_done_sent)
  {
    return;
  }
 
  if (PHASE_DONE != op->state->phase)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Union operation failed\n");
    GNUNET_STATISTICS_update (_GSS_statistics,
                              "# Union operations failed",
                              1,
                              GNUNET_NO);
    ev = GNUNET_MQ_msg (rm, GNUNET_MESSAGE_TYPE_SET_RESULT);
    rm->result_status = htons (GNUNET_SET_STATUS_FAILURE);
    rm->request_id = htonl (op->client_request_id);
    rm->element_type = htons (0);
    GNUNET_MQ_send (op->set->cs->mq,
                    ev);
    return;
  }
 
  op->state->client_done_sent = GNUNET_YES;
 
  GNUNET_STATISTICS_update (_GSS_statistics,
                            "# Union operations succeeded",
                            1,
                            GNUNET_NO);
  LOG (GNUNET_ERROR_TYPE_INFO,
       "Signalling client that union operation is done\n");
  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);
  rm->current_size = GNUNET_htonll (GNUNET_CONTAINER_multihashmap32_size (
                                      op->state->key_to_element));
  GNUNET_MQ_send (op->set->cs->mq,
                  ev);
}

References _GSS_statistics, GNUNET_SET_ResultMessage::current_size, GNUNET_SET_ResultMessage::element_type, GNUNET_CONTAINER_multihashmap32_size(), GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_htonll(), GNUNET_MESSAGE_TYPE_SET_RESULT, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_NO, GNUNET_SET_STATUS_DONE, GNUNET_SET_STATUS_FAILURE, GNUNET_STATISTICS_update(), GNUNET_YES, LOG, op, PHASE_DONE, GNUNET_SET_ResultMessage::request_id, and GNUNET_SET_ResultMessage::result_status.

Referenced by handle_union_p2p_full_done(), handle_union_p2p_over(), maybe_finish(), and union_channel_death().

Here is the call graph for this function:

Here is the caller graph for this function:

maybe_finish()

static void maybe_finish ( struct Operation *  op )

static

Tests if the operation is finished, and if so notify.

Parameters

op	operation to check

Definition at line 1443 of file gnunet-service-set_union.c.

{
  unsigned int num_demanded;
 
  num_demanded = GNUNET_CONTAINER_multihashmap_size (
    op->state->demanded_hashes);
 
  if (PHASE_FINISH_WAITING == op->state->phase)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "In PHASE_FINISH_WAITING, pending %u demands\n",
         num_demanded);
    if (0 == num_demanded)
    {
      struct GNUNET_MQ_Envelope *ev;
 
      op->state->phase = PHASE_DONE;
      ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SET_UNION_P2P_DONE);
      GNUNET_MQ_send (op->mq,
                      ev);
      /* We now wait until the other peer sends P2P_OVER
       * after it got all elements from us. */
    }
  }
  if (PHASE_FINISH_CLOSING == op->state->phase)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "In PHASE_FINISH_CLOSING, pending %u demands\n",
         num_demanded);
    if (0 == num_demanded)
    {
      op->state->phase = PHASE_DONE;
      send_client_done (op);
      _GSS_operation_destroy2 (op);
    }
  }
}

References _GSS_operation_destroy2(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_SET_UNION_P2P_DONE, GNUNET_MQ_msg_header, GNUNET_MQ_send(), LOG, op, PHASE_DONE, PHASE_FINISH_CLOSING, PHASE_FINISH_WAITING, and send_client_done().

Referenced by handle_union_p2p_done(), and handle_union_p2p_elements().

Here is the call graph for this function:

Here is the caller graph for this function:

check_union_p2p_elements()

int check_union_p2p_elements	(	void *	cls,
		const struct GNUNET_SET_ElementMessage *	emsg
	)

Check an element message from a remote peer.

Parameters

cls	the union operation
emsg	the message

Definition at line 1489 of file gnunet-service-set_union.c.

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

References GNUNET_break_op, GNUNET_CONTAINER_multihashmap_size(), GNUNET_OK, GNUNET_SET_OPERATION_UNION, GNUNET_SYSERR, and op.

Here is the call graph for this function:

handle_union_p2p_elements()

void handle_union_p2p_elements	(	void *	cls,
		const struct GNUNET_SET_ElementMessage *	emsg
	)

Handle an element message from a remote peer.

Sent by the other peer either because we decoded an IBF and placed a demand, or because the other peer switched to full set transmission.

Parameters

cls	the union operation
emsg	the message

Definition at line 1517 of file gnunet-service-set_union.c.

{
  struct Operation *op = cls;
  struct ElementEntry *ee;
  struct KeyEntry *ke;
  uint16_t element_size;
 
  element_size = ntohs (emsg->header.size) - sizeof(struct
                                                    GNUNET_SET_ElementMessage);
  ee = GNUNET_malloc (sizeof(struct ElementEntry) + element_size);
  GNUNET_memcpy (&ee[1],
                 &emsg[1],
                 element_size);
  ee->element.size = element_size;
  ee->element.data = &ee[1];
  ee->element.element_type = ntohs (emsg->element_type);
  ee->remote = GNUNET_YES;
  GNUNET_SET_element_hash (&ee->element,
                           &ee->element_hash);
  if (GNUNET_NO ==
      GNUNET_CONTAINER_multihashmap_remove (op->state->demanded_hashes,
                                            &ee->element_hash,
                                            NULL))
  {
    /* We got something we didn't demand, since it's not in our map. */
    GNUNET_break_op (0);
    fail_union_operation (op);
    return;
  }
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Got element (size %u, hash %s) from peer\n",
       (unsigned int) element_size,
       GNUNET_h2s (&ee->element_hash));
 
  GNUNET_STATISTICS_update (_GSS_statistics,
                            "# received elements",
                            1,
                            GNUNET_NO);
  GNUNET_STATISTICS_update (_GSS_statistics,
                            "# exchanged elements",
                            1,
                            GNUNET_NO);
 
  op->state->received_total++;
 
  ke = op_get_element (op, &ee->element_hash);
  if (NULL != ke)
  {
    /* Got repeated element.  Should not happen since
     * we track demands. */
    GNUNET_STATISTICS_update (_GSS_statistics,
                              "# repeated elements",
                              1,
                              GNUNET_NO);
    ke->received = GNUNET_YES;
    GNUNET_free (ee);
  }
  else
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Registering new element from remote peer\n");
    op->state->received_fresh++;
    op_register_element (op, ee, GNUNET_YES);
    /* only send results immediately if the client wants it */
    switch (op->result_mode)
    {
    case GNUNET_SET_RESULT_ADDED:
      send_client_element (op, &ee->element, GNUNET_SET_STATUS_OK);
      break;
 
    case GNUNET_SET_RESULT_SYMMETRIC:
      send_client_element (op, &ee->element, GNUNET_SET_STATUS_ADD_LOCAL);
      break;
 
    default:
      /* Result mode not supported, should have been caught earlier. */
      GNUNET_break (0);
      break;
    }
  }
 
  if ((op->state->received_total > 8) &&
      (op->state->received_fresh < op->state->received_total / 3))
  {
    /* The other peer gave us lots of old elements, there's something wrong. */
    GNUNET_break_op (0);
    fail_union_operation (op);
    return;
  }
  GNUNET_CADET_receive_done (op->channel);
  maybe_finish (op);
}

References _GSS_statistics, GNUNET_SET_Element::data, ElementEntry::element, ElementEntry::element_hash, GNUNET_SET_ElementMessage::element_type, GNUNET_SET_Element::element_type, fail_union_operation(), GNUNET_break, GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_SET_element_hash(), GNUNET_SET_RESULT_ADDED, GNUNET_SET_RESULT_SYMMETRIC, GNUNET_SET_STATUS_ADD_LOCAL, GNUNET_SET_STATUS_OK, GNUNET_STATISTICS_update(), GNUNET_YES, GNUNET_SET_ElementMessage::header, LOG, maybe_finish(), op, op_get_element(), op_register_element(), KeyEntry::received, ElementEntry::remote, send_client_element(), GNUNET_MessageHeader::size, and GNUNET_SET_Element::size.

Here is the call graph for this function:

check_union_p2p_full_element()

int check_union_p2p_full_element	(	void *	cls,
		const struct GNUNET_SET_ElementMessage *	emsg
	)

Check a full element message from a remote peer.

Parameters

cls	the union operation
emsg	the message

Definition at line 1620 of file gnunet-service-set_union.c.

{
  struct Operation *op = cls;
 
  if (GNUNET_SET_OPERATION_UNION != op->set->operation)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  // FIXME: check that we expect full elements here?
  return GNUNET_OK;
}

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

handle_union_p2p_full_element()

void handle_union_p2p_full_element	(	void *	cls,
		const struct GNUNET_SET_ElementMessage *	emsg
	)

Handle an element message from a remote peer.

Parameters

cls	the union operation
emsg	the message

Definition at line 1642 of file gnunet-service-set_union.c.

{
  struct Operation *op = cls;
  struct ElementEntry *ee;
  struct KeyEntry *ke;
  uint16_t element_size;
 
  element_size = ntohs (emsg->header.size) - sizeof(struct
                                                    GNUNET_SET_ElementMessage);
  ee = GNUNET_malloc (sizeof(struct ElementEntry) + element_size);
  GNUNET_memcpy (&ee[1], &emsg[1], element_size);
  ee->element.size = element_size;
  ee->element.data = &ee[1];
  ee->element.element_type = ntohs (emsg->element_type);
  ee->remote = GNUNET_YES;
  GNUNET_SET_element_hash (&ee->element, &ee->element_hash);
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Got element (full diff, size %u, hash %s) from peer\n",
       (unsigned int) element_size,
       GNUNET_h2s (&ee->element_hash));
 
  GNUNET_STATISTICS_update (_GSS_statistics,
                            "# received elements",
                            1,
                            GNUNET_NO);
  GNUNET_STATISTICS_update (_GSS_statistics,
                            "# exchanged elements",
                            1,
                            GNUNET_NO);
 
  op->state->received_total++;
 
  ke = op_get_element (op, &ee->element_hash);
  if (NULL != ke)
  {
    /* Got repeated element.  Should not happen since
     * we track demands. */
    GNUNET_STATISTICS_update (_GSS_statistics,
                              "# repeated elements",
                              1,
                              GNUNET_NO);
    ke->received = GNUNET_YES;
    GNUNET_free (ee);
  }
  else
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Registering new element from remote peer\n");
    op->state->received_fresh++;
    op_register_element (op, ee, GNUNET_YES);
    /* only send results immediately if the client wants it */
    switch (op->result_mode)
    {
    case GNUNET_SET_RESULT_ADDED:
      send_client_element (op, &ee->element, GNUNET_SET_STATUS_OK);
      break;
 
    case GNUNET_SET_RESULT_SYMMETRIC:
      send_client_element (op, &ee->element, GNUNET_SET_STATUS_ADD_LOCAL);
      break;
 
    default:
      /* Result mode not supported, should have been caught earlier. */
      GNUNET_break (0);
      break;
    }
  }
 
  if ((GNUNET_YES == op->byzantine) &&
      (op->state->received_total > 384 + op->state->received_fresh * 4) &&
      (op->state->received_fresh < op->state->received_total / 6))
  {
    /* The other peer gave us lots of old elements, there's something wrong. */
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Other peer sent only %llu/%llu fresh elements, failing operation\n",
         (unsigned long long) op->state->received_fresh,
         (unsigned long long) op->state->received_total);
    GNUNET_break_op (0);
    fail_union_operation (op);
    return;
  }
  GNUNET_CADET_receive_done (op->channel);
}

References _GSS_statistics, GNUNET_SET_Element::data, ElementEntry::element, ElementEntry::element_hash, GNUNET_SET_ElementMessage::element_type, GNUNET_SET_Element::element_type, fail_union_operation(), GNUNET_break, GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_h2s(), GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_SET_element_hash(), GNUNET_SET_RESULT_ADDED, GNUNET_SET_RESULT_SYMMETRIC, GNUNET_SET_STATUS_ADD_LOCAL, GNUNET_SET_STATUS_OK, GNUNET_STATISTICS_update(), GNUNET_YES, GNUNET_SET_ElementMessage::header, LOG, op, op_get_element(), op_register_element(), KeyEntry::received, ElementEntry::remote, send_client_element(), GNUNET_MessageHeader::size, and GNUNET_SET_Element::size.

Here is the call graph for this function:

check_union_p2p_inquiry()

int check_union_p2p_inquiry	(	void *	cls,
		const struct InquiryMessage *	msg
	)

Send offers (for GNUNET_Hash-es) in response to inquiries (for IBF_Key-s).

Parameters

cls	the union operation
msg	the message

Definition at line 1737 of file gnunet-service-set_union.c.

{
  struct Operation *op = cls;
  unsigned int num_keys;
 
  if (GNUNET_SET_OPERATION_UNION != op->set->operation)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if (op->state->phase != PHASE_INVENTORY_PASSIVE)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  num_keys = (ntohs (msg->header.size) - sizeof(struct InquiryMessage))
             / sizeof(struct IBF_Key);
  if ((ntohs (msg->header.size) - sizeof(struct InquiryMessage))
      != num_keys * sizeof(struct IBF_Key))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_OK, GNUNET_SET_OPERATION_UNION, GNUNET_SYSERR, msg, op, PHASE_INVENTORY_PASSIVE, and GNUNET_MessageHeader::size.

handle_union_p2p_inquiry()

void handle_union_p2p_inquiry	(	void *	cls,
		const struct InquiryMessage *	msg
	)

Send offers (for GNUNET_Hash-es) in response to inquiries (for IBF_Key-s).

Parameters

cls	the union operation
msg	the message

Definition at line 1773 of file gnunet-service-set_union.c.

{
  struct Operation *op = cls;
  const struct IBF_Key *ibf_key;
  unsigned int num_keys;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received union inquiry\n");
  num_keys = (ntohs (msg->header.size) - sizeof(struct InquiryMessage))
             / sizeof(struct IBF_Key);
  ibf_key = (const struct IBF_Key *) &msg[1];
  while (0 != num_keys--)
  {
    struct IBF_Key unsalted_key;
 
    unsalt_key (ibf_key,
                ntohl (msg->salt),
                &unsalted_key);
    send_offers_for_key (op,
                         unsalted_key);
    ibf_key++;
  }
  GNUNET_CADET_receive_done (op->channel);
}

References GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, LOG, msg, op, send_offers_for_key(), GNUNET_MessageHeader::size, and unsalt_key().

Here is the call graph for this function:

send_missing_full_elements_iter()

static int send_missing_full_elements_iter ( void *  cls, uint32_t  key, void *  value  )

static

Iterator over hash map entries, called to destroy the linked list of colliding ibf key entries.

Parameters

cls	closure
key	current key code
value	value in the hash map

Returns

GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

Definition at line 1811 of file gnunet-service-set_union.c.

{
  struct Operation *op = cls;
  struct KeyEntry *ke = value;
  struct GNUNET_MQ_Envelope *ev;
  struct GNUNET_SET_ElementMessage *emsg;
  struct ElementEntry *ee = ke->element;
 
  if (GNUNET_YES == ke->received)
    return GNUNET_YES;
  ev = GNUNET_MQ_msg_extra (emsg,
                            ee->element.size,
                            GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_ELEMENT);
  GNUNET_memcpy (&emsg[1],
                 ee->element.data,
                 ee->element.size);
  emsg->element_type = htons (ee->element.element_type);
  GNUNET_MQ_send (op->mq,
                  ev);
  return GNUNET_YES;
}

References GNUNET_SET_Element::data, ElementEntry::element, KeyEntry::element, GNUNET_SET_ElementMessage::element_type, GNUNET_SET_Element::element_type, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_ELEMENT, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_YES, op, KeyEntry::received, GNUNET_SET_Element::size, and value.

Referenced by handle_union_p2p_full_done().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_union_p2p_request_full()

void handle_union_p2p_request_full	(	void *	cls,
		const struct GNUNET_MessageHeader *	mh
	)

Handle a request for full set transmission.

Parameters

cls	closure, a set union operation
mh	the demand message

Definition at line 1843 of file gnunet-service-set_union.c.

{
  struct Operation *op = cls;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received request for full set transmission\n");
  if (GNUNET_SET_OPERATION_UNION != op->set->operation)
  {
    GNUNET_break_op (0);
    fail_union_operation (op);
    return;
  }
  if (PHASE_EXPECT_IBF != op->state->phase)
  {
    GNUNET_break_op (0);
    fail_union_operation (op);
    return;
  }
 
  // FIXME: we need to check that our set is larger than the
  // byzantine_lower_bound by some threshold
  send_full_set (op);
  GNUNET_CADET_receive_done (op->channel);
}

References fail_union_operation(), GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_SET_OPERATION_UNION, LOG, op, PHASE_EXPECT_IBF, and send_full_set().

Here is the call graph for this function:

handle_union_p2p_full_done()

void handle_union_p2p_full_done	(	void *	cls,
		const struct GNUNET_MessageHeader *	mh
	)

Handle a "full done" message.

Parameters

cls	closure, a set union operation
mh	the demand message

Definition at line 1877 of file gnunet-service-set_union.c.

{
  struct Operation *op = cls;
 
  switch (op->state->phase)
  {
  case PHASE_EXPECT_IBF:
    {
      struct GNUNET_MQ_Envelope *ev;
 
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "got FULL DONE, sending elements that other peer is missing\n");
 
      /* send all the elements that did not come from the remote peer */
      GNUNET_CONTAINER_multihashmap32_iterate (op->state->key_to_element,
                                               &send_missing_full_elements_iter,
                                               op);
 
      ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_DONE);
      GNUNET_MQ_send (op->mq,
                      ev);
      op->state->phase = PHASE_DONE;
      /* we now wait until the other peer sends us the OVER message*/
    }
    break;
 
  case PHASE_FULL_SENDING:
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "got FULL DONE, finishing\n");
      /* We sent the full set, and got the response for that.  We're done. */
      op->state->phase = PHASE_DONE;
      GNUNET_CADET_receive_done (op->channel);
      send_client_done (op);
      _GSS_operation_destroy2 (op);
      return;
    }
    break;
 
  default:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Handle full done phase is %u\n",
                (unsigned) op->state->phase);
    GNUNET_break_op (0);
    fail_union_operation (op);
    return;
  }
  GNUNET_CADET_receive_done (op->channel);
}

References _GSS_operation_destroy2(), fail_union_operation(), GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_CONTAINER_multihashmap32_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_DONE, GNUNET_MQ_msg_header, GNUNET_MQ_send(), LOG, op, PHASE_DONE, PHASE_EXPECT_IBF, PHASE_FULL_SENDING, send_client_done(), and send_missing_full_elements_iter().

Here is the call graph for this function:

check_union_p2p_demand()

int check_union_p2p_demand	(	void *	cls,
		const struct GNUNET_MessageHeader *	mh
	)

Check a demand by the other peer for elements based on a list of struct GNUNET_HashCodes.

Parameters

cls	closure, a set union operation
mh	the demand message

Returns

GNUNET_OK if mh is well-formed

Definition at line 1938 of file gnunet-service-set_union.c.

{
  struct Operation *op = cls;
  unsigned int num_hashes;
 
  if (GNUNET_SET_OPERATION_UNION != op->set->operation)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  num_hashes = (ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader))
               / sizeof(struct GNUNET_HashCode);
  if ((ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader))
      != num_hashes * sizeof(struct GNUNET_HashCode))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_OK, GNUNET_SET_OPERATION_UNION, GNUNET_SYSERR, mh, and op.

handle_union_p2p_demand()

void handle_union_p2p_demand	(	void *	cls,
		const struct GNUNET_MessageHeader *	mh
	)

Handle a demand by the other peer for elements based on a list of struct GNUNET_HashCodes.

Parameters

cls	closure, a set union operation
mh	the demand message

Definition at line 1969 of file gnunet-service-set_union.c.

{
  struct Operation *op = cls;
  struct ElementEntry *ee;
  struct GNUNET_SET_ElementMessage *emsg;
  const struct GNUNET_HashCode *hash;
  unsigned int num_hashes;
  struct GNUNET_MQ_Envelope *ev;
 
  num_hashes = (ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader))
               / sizeof(struct GNUNET_HashCode);
  for (hash = (const struct GNUNET_HashCode *) &mh[1];
       num_hashes > 0;
       hash++, num_hashes--)
  {
    ee = GNUNET_CONTAINER_multihashmap_get (op->set->content->elements,
                                            hash);
    if (NULL == ee)
    {
      /* Demand for non-existing element. */
      GNUNET_break_op (0);
      fail_union_operation (op);
      return;
    }
    if (GNUNET_NO == _GSS_is_element_of_operation (ee, op))
    {
      /* Probably confused lazily copied sets. */
      GNUNET_break_op (0);
      fail_union_operation (op);
      return;
    }
    ev = GNUNET_MQ_msg_extra (emsg, ee->element.size,
                              GNUNET_MESSAGE_TYPE_SET_P2P_ELEMENTS);
    GNUNET_memcpy (&emsg[1], ee->element.data, ee->element.size);
    emsg->reserved = htons (0);
    emsg->element_type = htons (ee->element.element_type);
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "[OP %p] Sending demanded element (size %u, hash %s) to peer\n",
         op,
         (unsigned int) ee->element.size,
         GNUNET_h2s (&ee->element_hash));
    GNUNET_MQ_send (op->mq, ev);
    GNUNET_STATISTICS_update (_GSS_statistics,
                              "# exchanged elements",
                              1,
                              GNUNET_NO);
 
    switch (op->result_mode)
    {
    case GNUNET_SET_RESULT_ADDED:
      /* Nothing to do. */
      break;
 
    case GNUNET_SET_RESULT_SYMMETRIC:
      send_client_element (op, &ee->element, GNUNET_SET_STATUS_ADD_REMOTE);
      break;
 
    default:
      /* Result mode not supported, should have been caught earlier. */
      GNUNET_break (0);
      break;
    }
  }
  GNUNET_CADET_receive_done (op->channel);
}

References _GSS_is_element_of_operation(), _GSS_statistics, GNUNET_SET_Element::data, ElementEntry::element, ElementEntry::element_hash, GNUNET_SET_ElementMessage::element_type, GNUNET_SET_Element::element_type, fail_union_operation(), GNUNET_break, GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SET_P2P_ELEMENTS, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_SET_RESULT_ADDED, GNUNET_SET_RESULT_SYMMETRIC, GNUNET_SET_STATUS_ADD_REMOTE, GNUNET_STATISTICS_update(), LOG, mh, op, GNUNET_SET_ElementMessage::reserved, send_client_element(), and GNUNET_SET_Element::size.

Here is the call graph for this function:

check_union_p2p_offer()

int check_union_p2p_offer	(	void *	cls,
		const struct GNUNET_MessageHeader *	mh
	)

Check offer (of struct GNUNET_HashCodes).

Parameters

cls	the union operation
mh	the message

Returns

GNUNET_OK if mh is well-formed

Definition at line 2045 of file gnunet-service-set_union.c.

{
  struct Operation *op = cls;
  unsigned int num_hashes;
 
  if (GNUNET_SET_OPERATION_UNION != op->set->operation)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  /* look up elements and send them */
  if ((op->state->phase != PHASE_INVENTORY_PASSIVE) &&
      (op->state->phase != PHASE_INVENTORY_ACTIVE))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  num_hashes = (ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader))
               / sizeof(struct GNUNET_HashCode);
  if ((ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader)) !=
      num_hashes * sizeof(struct GNUNET_HashCode))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_OK, GNUNET_SET_OPERATION_UNION, GNUNET_SYSERR, mh, op, PHASE_INVENTORY_ACTIVE, and PHASE_INVENTORY_PASSIVE.

handle_union_p2p_offer()

void handle_union_p2p_offer	(	void *	cls,
		const struct GNUNET_MessageHeader *	mh
	)

Handle offers (of struct GNUNET_HashCodes) and respond with demands (of struct GNUNET_HashCodes).

Parameters

cls	the union operation
mh	the message

Definition at line 2083 of file gnunet-service-set_union.c.

{
  struct Operation *op = cls;
  const struct GNUNET_HashCode *hash;
  unsigned int num_hashes;
 
  num_hashes = (ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader))
               / sizeof(struct GNUNET_HashCode);
  for (hash = (const struct GNUNET_HashCode *) &mh[1];
       num_hashes > 0;
       hash++, num_hashes--)
  {
    struct ElementEntry *ee;
    struct GNUNET_MessageHeader *demands;
    struct GNUNET_MQ_Envelope *ev;
 
    ee = GNUNET_CONTAINER_multihashmap_get (op->set->content->elements,
                                            hash);
    if (NULL != ee)
      if (GNUNET_YES == _GSS_is_element_of_operation (ee, op))
        continue;
 
    if (GNUNET_YES ==
        GNUNET_CONTAINER_multihashmap_contains (op->state->demanded_hashes,
                                                hash))
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Skipped sending duplicate demand\n");
      continue;
    }
 
    GNUNET_assert (GNUNET_OK ==
                   GNUNET_CONTAINER_multihashmap_put (
                     op->state->demanded_hashes,
                     hash,
                     NULL,
                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
 
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "[OP %p] Requesting element (hash %s)\n",
         op, GNUNET_h2s (hash));
    ev = GNUNET_MQ_msg_header_extra (demands,
                                     sizeof(struct GNUNET_HashCode),
                                     GNUNET_MESSAGE_TYPE_SET_UNION_P2P_DEMAND);
    GNUNET_memcpy (&demands[1],
                   hash,
                   sizeof(struct GNUNET_HashCode));
    GNUNET_MQ_send (op->mq, ev);
  }
  GNUNET_CADET_receive_done (op->channel);
}

References _GSS_is_element_of_operation(), GNUNET_assert, GNUNET_CADET_receive_done(), GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SET_UNION_P2P_DEMAND, GNUNET_MQ_msg_header_extra, GNUNET_MQ_send(), GNUNET_OK, GNUNET_YES, LOG, mh, and op.

Here is the call graph for this function:

handle_union_p2p_done()

void handle_union_p2p_done	(	void *	cls,
		const struct GNUNET_MessageHeader *	mh
	)

Handle a done message from a remote peer.

Parameters

cls	the union operation
mh	the message

Definition at line 2144 of file gnunet-service-set_union.c.

{
  struct Operation *op = cls;
 
  if (GNUNET_SET_OPERATION_UNION != op->set->operation)
  {
    GNUNET_break_op (0);
    fail_union_operation (op);
    return;
  }
  switch (op->state->phase)
  {
  case PHASE_INVENTORY_PASSIVE:
    /* We got all requests, but still have to send our elements in response. */
    op->state->phase = PHASE_FINISH_WAITING;
 
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "got DONE (as passive partner), waiting for our demands to be satisfied\n");
    /* The active peer is done sending offers
     * and inquiries.  This means that all
     * our responses to that (demands and offers)
     * must be in flight (queued or in mesh).
     *
     * We should notify the active peer once
     * all our demands are satisfied, so that the active
     * peer can quit if we gave it everything.
     */GNUNET_CADET_receive_done (op->channel);
    maybe_finish (op);
    return;
 
  case PHASE_INVENTORY_ACTIVE:
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "got DONE (as active partner), waiting to finish\n");
    /* All demands of the other peer are satisfied,
     * and we processed all offers, thus we know
     * exactly what our demands must be.
     *
     * We'll close the channel
     * to the other peer once our demands are met.
     */op->state->phase = PHASE_FINISH_CLOSING;
    GNUNET_CADET_receive_done (op->channel);
    maybe_finish (op);
    return;
 
  default:
    GNUNET_break_op (0);
    fail_union_operation (op);
    return;
  }
}

References fail_union_operation(), GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_SET_OPERATION_UNION, LOG, maybe_finish(), op, PHASE_FINISH_CLOSING, PHASE_FINISH_WAITING, PHASE_INVENTORY_ACTIVE, and PHASE_INVENTORY_PASSIVE.

Here is the call graph for this function:

handle_union_p2p_over()

void handle_union_p2p_over	(	void *	cls,
		const struct GNUNET_MessageHeader *	mh
	)

Handle an over message from a remote peer.

Parameters

cls	the union operation
mh	the message

Definition at line 2198 of file gnunet-service-set_union.c.

{
  send_client_done (cls);
}

References send_client_done().

Here is the call graph for this function:

union_evaluate()

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

static

Initiate operation to evaluate a set union with a remote peer.

Parameters

op	operation to perform (to be initialized)
opaque_context	message to be transmitted to the listener to convince it to accept, may be NULL

Definition at line 2213 of file gnunet-service-set_union.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;
  }
  state = GNUNET_new (struct OperationState);
  state->demanded_hashes = GNUNET_CONTAINER_multihashmap_create (32,
                                                                 GNUNET_NO);
  /* copy the current generation's strata estimator for this operation */
  state->se = strata_estimator_dup (op->set->state->se);
  /* we started the operation, thus we have to send the operation request */
  state->phase = PHASE_EXPECT_SE;
  state->salt_receive = state->salt_send = 42; // FIXME?????
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Initiating union operation evaluation\n");
  GNUNET_STATISTICS_update (_GSS_statistics,
                            "# of total union operations",
                            1,
                            GNUNET_NO);
  GNUNET_STATISTICS_update (_GSS_statistics,
                            "# of initiated union operations",
                            1,
                            GNUNET_NO);
  msg->operation = htonl (GNUNET_SET_OPERATION_UNION);
  GNUNET_MQ_send (op->mq,
                  ev);
 
  if (NULL != opaque_context)
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "sent op request with context message\n");
  else
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "sent op request without context message\n");
 
  op->state = state;
  initialize_key_to_element (op);
  state->initial_size = GNUNET_CONTAINER_multihashmap32_size (
    state->key_to_element);
  return state;
}

References _GSS_statistics, GNUNET_break, GNUNET_CONTAINER_multihashmap32_size(), GNUNET_CONTAINER_multihashmap_create(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_SET_P2P_OPERATION_REQUEST, GNUNET_MQ_msg_nested_mh, GNUNET_MQ_send(), GNUNET_new, GNUNET_NO, GNUNET_SET_OPERATION_UNION, GNUNET_STATISTICS_update(), initialize_key_to_element(), LOG, msg, op, PHASE_EXPECT_SE, state, and strata_estimator_dup().

Referenced by _GSS_union_vt().

Here is the call graph for this function:

Here is the caller graph for this function:

union_accept()

static struct OperationState * union_accept ( struct Operation *  op )

static

Accept an union operation request from a remote peer.

Only initializes the private operation state.

Parameters

op	operation that will be accepted as a union operation

Definition at line 2273 of file gnunet-service-set_union.c.

{
  struct OperationState *state;
  const struct StrataEstimator *se;
  struct GNUNET_MQ_Envelope *ev;
  struct StrataEstimatorMessage *strata_msg;
  char *buf;
  size_t len;
  uint16_t type;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "accepting set union operation\n");
  GNUNET_STATISTICS_update (_GSS_statistics,
                            "# of accepted union operations",
                            1,
                            GNUNET_NO);
  GNUNET_STATISTICS_update (_GSS_statistics,
                            "# of total union operations",
                            1,
                            GNUNET_NO);
 
  state = GNUNET_new (struct OperationState);
  state->se = strata_estimator_dup (op->set->state->se);
  state->demanded_hashes = GNUNET_CONTAINER_multihashmap_create (32,
                                                                 GNUNET_NO);
  state->salt_receive = state->salt_send = 42; // FIXME?????
  op->state = state;
  initialize_key_to_element (op);
  state->initial_size = GNUNET_CONTAINER_multihashmap32_size (
    state->key_to_element);
 
  /* kick off the operation */
  se = state->se;
  buf = GNUNET_malloc (se->strata_count * IBF_BUCKET_SIZE * se->ibf_size);
  len = strata_estimator_write (se,
                                buf);
  if (len < se->strata_count * IBF_BUCKET_SIZE * se->ibf_size)
    type = GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SEC;
  else
    type = GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SE;
  ev = GNUNET_MQ_msg_extra (strata_msg,
                            len,
                            type);
  GNUNET_memcpy (&strata_msg[1],
                 buf,
                 len);
  GNUNET_free (buf);
  strata_msg->set_size
    = GNUNET_htonll (GNUNET_CONTAINER_multihashmap_size (
                       op->set->content->elements));
  GNUNET_MQ_send (op->mq,
                  ev);
  state->phase = PHASE_EXPECT_IBF;
  return state;
}

References _GSS_statistics, GNUNET_CONTAINER_multihashmap32_size(), GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_htonll(), GNUNET_malloc, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SE, GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SEC, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new, GNUNET_NO, GNUNET_STATISTICS_update(), IBF_BUCKET_SIZE, StrataEstimator::ibf_size, initialize_key_to_element(), LOG, op, PHASE_EXPECT_IBF, StrataEstimatorMessage::set_size, state, StrataEstimator::strata_count, strata_estimator_dup(), strata_estimator_write(), and type.

Referenced by _GSS_union_vt().

Here is the call graph for this function:

Here is the caller graph for this function:

union_set_create()

static struct SetState * union_set_create ( void  )

static

Create a new set supporting the union operation.

We maintain one strata estimator per set and then manipulate it over the lifetime of the set, as recreating a strata estimator would be expensive.

Returns

the newly created set, NULL on error

Definition at line 2339 of file gnunet-service-set_union.c.

{
  struct SetState *set_state;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "union set created\n");
  set_state = GNUNET_new (struct SetState);
  set_state->se = strata_estimator_create (SE_STRATA_COUNT,
                                           SE_IBF_SIZE, SE_IBF_HASH_NUM);
  if (NULL == set_state->se)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to allocate strata estimator\n");
    GNUNET_free (set_state);
    return NULL;
  }
  return set_state;
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_new, LOG, SetState::se, SE_IBF_HASH_NUM, SE_IBF_SIZE, SE_STRATA_COUNT, and strata_estimator_create().

Referenced by _GSS_union_vt().

Here is the call graph for this function:

Here is the caller graph for this function:

union_add()

static void union_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 2366 of file gnunet-service-set_union.c.

{
  strata_estimator_insert (set_state->se,
                           get_ibf_key (&ee->element_hash));
}

References ElementEntry::element_hash, get_ibf_key(), SetState::se, and strata_estimator_insert().

Referenced by _GSS_union_vt().

Here is the call graph for this function:

Here is the caller graph for this function:

union_remove()

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

static

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

Only marks the element as removed, so that older set operations can still exchange it.

Parameters

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

Definition at line 2382 of file gnunet-service-set_union.c.

{
  strata_estimator_remove (set_state->se,
                           get_ibf_key (&ee->element_hash));
}

References ElementEntry::element_hash, get_ibf_key(), SetState::se, and strata_estimator_remove().

Referenced by _GSS_union_vt().

Here is the call graph for this function:

Here is the caller graph for this function:

union_set_destroy()

static void union_set_destroy ( struct SetState *  set_state )

static

Destroy a set that supports the union operation.

Parameters

set_state

the set to destroy

Definition at line 2396 of file gnunet-service-set_union.c.

{
  if (NULL != set_state->se)
  {
    strata_estimator_destroy (set_state->se);
    set_state->se = NULL;
  }
  GNUNET_free (set_state);
}

References GNUNET_free, SetState::se, and strata_estimator_destroy().

Referenced by _GSS_union_vt().

Here is the call graph for this function:

Here is the caller graph for this function:

union_copy_state()

static struct SetState * union_copy_state ( struct SetState *  state )

static

Copy union-specific set state.

Parameters

state

source state for copying the union state

Returns

a copy of the union-specific set state

Definition at line 2414 of file gnunet-service-set_union.c.

{
  struct SetState *new_state;
 
  GNUNET_assert ((NULL != state) &&
                 (NULL != state->se));
  new_state = GNUNET_new (struct SetState);
  new_state->se = strata_estimator_dup (state->se);
 
  return new_state;
}

References GNUNET_assert, GNUNET_new, SetState::se, state, and strata_estimator_dup().

Referenced by _GSS_union_vt().

Here is the call graph for this function:

Here is the caller graph for this function:

union_channel_death()

static void union_channel_death ( struct Operation *  op )

static

Handle case where channel went down for an operation.

Parameters

op	operation that lost the channel

Definition at line 2433 of file gnunet-service-set_union.c.

{
  send_client_done (op);
  _GSS_operation_destroy (op,
                          GNUNET_YES);
}

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

Referenced by _GSS_union_vt().

Here is the call graph for this function:

Here is the caller graph for this function:

_GSS_union_vt()

const struct SetVT * _GSS_union_vt

(

void

)

Get the table with implementing functions for set union.

Returns

the operation specific VTable

Definition at line 2448 of file gnunet-service-set_union.c.

{
  static const struct SetVT union_vt = {
    .create = &union_set_create,
    .add = &union_add,
    .remove = &union_remove,
    .destroy_set = &union_set_destroy,
    .evaluate = &union_evaluate,
    .accept = &union_accept,
    .cancel = &union_op_cancel,
    .copy_state = &union_copy_state,
    .channel_death = &union_channel_death
  };
 
  return &union_vt;
}

References SetVT::create, union_accept(), union_add(), union_channel_death(), union_copy_state(), union_evaluate(), union_op_cancel(), union_remove(), union_set_create(), and union_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: