gnunet-service-set_union.h File Reference

two-peer set operations More...

#include "gnunet-service-set.h"
#include "gnunet-service-set_protocol.h"

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

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
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.
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.
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).
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.

Detailed Description

two-peer set operations

Author

Florian Dold

Christian Grothoff

Definition in file gnunet-service-set_union.h.

Function Documentation

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 826 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 858 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:

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 1215 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 1278 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:

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 1494 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 1522 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 1625 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 1647 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 1742 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 1778 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:

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 1848 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 1882 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 1943 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 1974 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 2050 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 2088 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 2149 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 2203 of file gnunet-service-set_union.c.

{
  send_client_done (cls);
}

References send_client_done().

Here is the call graph for this function: