/*
This file is part of GNUnet
- Copyright (C) 2013-2015 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2013-2015 GNUnet e.V.
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
*/
/**
* @file set/gnunet-service-set_union.c
+
* @brief two-peer set operations
* @author Florian Dold
*/
* Choose this value so that computing the IBF is still cheaper
* than transmitting all values.
*/
-#define MAX_IBF_ORDER (16)
+#define MAX_IBF_ORDER (20)
/**
* Number of buckets used in the ibf per estimated
* Hashes for elements that we have demanded from the other peer.
*/
struct GNUNET_CONTAINER_MultiHashMap *demanded_hashes;
+
+ /**
+ * Salt that we're using for sending IBFs
+ */
+ uint32_t salt_send;
+
+ /**
+ * Salt for the IBF we've received and that we're currently decoding.
+ */
+ uint32_t salt_receive;
};
* a salt.
*
* @param src the hash code
- * @param salt salt to use
* @return the derived IBF key
*/
static struct IBF_Key
-get_ibf_key (const struct GNUNET_HashCode *src,
- uint16_t salt)
+get_ibf_key (const struct GNUNET_HashCode *src)
{
struct IBF_Key key;
-
- /* FIXME: Ensure that the salt is handled correctly.
- This is a quick fix so that consensus works for now. */
- salt = 0;
+ uint16_t salt = 0;
GNUNET_CRYPTO_kdf (&key, sizeof (key),
src, sizeof *src,
int ret;
struct IBF_Key ibf_key;
- ibf_key = get_ibf_key (element_hash, op->spec->salt);
+ 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_has_element_iterator,
struct IBF_Key ibf_key;
struct KeyEntry *k;
- ibf_key = get_ibf_key (&ee->element_hash, op->spec->salt);
+ ibf_key = get_ibf_key (&ee->element_hash);
k = GNUNET_new (struct KeyEntry);
k->element = ee;
k->ibf_key = ibf_key;
}
+static void
+salt_key (const struct IBF_Key *k_in,
+ uint32_t salt,
+ struct IBF_Key *k_out)
+{
+ 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;
+}
+
+
+static void
+unsalt_key (const struct IBF_Key *k_in,
+ uint32_t salt,
+ struct IBF_Key *k_out)
+{
+ int s = salt % 64;
+ uint64_t x = k_in->key_val;
+ x = (x << s) | (x >> (64 - s));
+ k_out->key_val = x;
+}
+
+
/**
* Insert a key into an ibf.
*
{
struct Operation *op = cls;
struct KeyEntry *ke = value;
+ struct IBF_Key salted_key;
LOG (GNUNET_ERROR_TYPE_DEBUG,
"[OP %x] inserting %lx (hash %s) into ibf\n",
(void *) op,
(unsigned long) ke->ibf_key.key_val,
GNUNET_h2s (&ke->element->element_hash));
- ibf_insert (op->state->local_ibf, ke->ibf_key);
+ salt_key (&ke->ibf_key, op->state->salt_send, &salted_key);
+ ibf_insert (op->state->local_ibf, salted_key);
return GNUNET_YES;
}
ev = GNUNET_MQ_msg_extra (msg,
buckets_in_message * IBF_BUCKET_SIZE,
GNUNET_MESSAGE_TYPE_SET_UNION_P2P_IBF);
- msg->reserved = 0;
+ msg->reserved1 = 0;
+ msg->reserved2 = 0;
msg->order = ibf_order;
- msg->offset = htons (buckets_sent);
+ 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;
int diff;
size_t len;
+ GNUNET_STATISTICS_update (_GSS_statistics,
+ "# bytes of SE received",
+ ntohs (mh->size),
+ GNUNET_NO);
+
if (op->state->phase != PHASE_EXPECT_SE)
{
fail_union_operation (op);
{
/* decompression failed */
fail_union_operation (op);
+ strata_estimator_destroy (remote_se);
return GNUNET_SYSERR;
}
GNUNET_assert (NULL != op->state->se);
if (GNUNET_OK !=
prepare_ibf (op, op->state->remote_ibf->size))
{
+ GNUNET_break (0);
/* allocation failed */
return GNUNET_SYSERR;
}
"# of IBF retries",
1,
GNUNET_NO);
+ op->state->salt_send++;
if (GNUNET_OK !=
send_ibf (op, next_order))
{
}
if (1 == side)
{
- send_offers_for_key (op, key);
+ 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 GNUNET_MessageHeader *msg;
+ 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_header_extra (msg,
- sizeof (struct IBF_Key),
- GNUNET_MESSAGE_TYPE_SET_UNION_P2P_INQUIRY);
-
+ ev = GNUNET_MQ_msg_extra (msg,
+ sizeof (struct IBF_Key),
+ GNUNET_MESSAGE_TYPE_SET_UNION_P2P_INQUIRY);
+ msg->salt = htonl (op->state->salt_receive);
memcpy (&msg[1],
&key,
sizeof (struct IBF_Key));
"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,
return GNUNET_SYSERR;
}
op->state->ibf_buckets_received = 0;
- if (0 != ntohs (msg->offset))
+ if (0 != ntohl (msg->offset))
{
GNUNET_break_op (0);
fail_union_operation (op);
}
else if (op->state->phase == PHASE_EXPECT_IBF_CONT)
{
- if ( (ntohs (msg->offset) != op->state->ibf_buckets_received) ||
- (1<<msg->order != op->state->remote_ibf->size) )
+ if (ntohl (msg->offset) != op->state->ibf_buckets_received)
+ {
+ GNUNET_break_op (0);
+ fail_union_operation (op);
+ return GNUNET_SYSERR;
+ }
+ if (1<<msg->order != op->state->remote_ibf->size)
+ {
+ GNUNET_break_op (0);
+ fail_union_operation (op);
+ return GNUNET_SYSERR;
+ }
+ if (ntohl (msg->salt) != op->state->salt_receive)
{
GNUNET_break_op (0);
fail_union_operation (op);
"# received elements",
1,
GNUNET_NO);
+ GNUNET_STATISTICS_update (_GSS_statistics,
+ "# exchanged elements",
+ 1,
+ GNUNET_NO);
if (GNUNET_YES == op_has_element (op, &ee->element_hash))
{
struct Operation *op = cls;
const struct IBF_Key *ibf_key;
unsigned int num_keys;
+ struct InquiryMessage *msg;
/* look up elements and send them */
if (op->state->phase != PHASE_INVENTORY_PASSIVE)
fail_union_operation (op);
return;
}
- num_keys = (ntohs (mh->size) - sizeof (struct GNUNET_MessageHeader))
+ num_keys = (ntohs (mh->size) - sizeof (struct InquiryMessage))
/ sizeof (struct IBF_Key);
- if ((ntohs (mh->size) - sizeof (struct GNUNET_MessageHeader))
+ if ((ntohs (mh->size) - sizeof (struct InquiryMessage))
!= num_keys * sizeof (struct IBF_Key))
{
GNUNET_break_op (0);
return;
}
- ibf_key = (const struct IBF_Key *) &mh[1];
+ msg = (struct InquiryMessage *) mh;
+
+ ibf_key = (const struct IBF_Key *) &msg[1];
while (0 != num_keys--)
{
- send_offers_for_key (op, *ibf_key);
+ struct IBF_Key unsalted_key;
+ unsalt_key (ibf_key, ntohl (msg->salt), &unsalted_key);
+ send_offers_for_key (op, unsalted_key);
ibf_key++;
}
}
(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->spec->result_mode)
{
op->state->se = strata_estimator_dup (op->spec->set->state->se);
/* we started the operation, thus we have to send the operation request */
op->state->phase = PHASE_EXPECT_SE;
+ op->state->salt_receive = op->state->salt_send = 42;
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,
"# of accepted union operations",
1,
GNUNET_NO);
+ GNUNET_STATISTICS_update (_GSS_statistics,
+ "# of total union operations",
+ 1,
+ GNUNET_NO);
op->state = GNUNET_new (struct OperationState);
op->state->se = strata_estimator_dup (op->spec->set->state->se);
op->state->demanded_hashes = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_NO);
+ op->state->salt_receive = op->state->salt_send = 42;
/* kick off the operation */
send_strata_estimator (op);
}
union_add (struct SetState *set_state, struct ElementEntry *ee)
{
strata_estimator_insert (set_state->se,
- get_ibf_key (&ee->element_hash, 0));
+ get_ibf_key (&ee->element_hash));
}
union_remove (struct SetState *set_state, struct ElementEntry *ee)
{
strata_estimator_remove (set_state->se,
- get_ibf_key (&ee->element_hash, 0));
+ get_ibf_key (&ee->element_hash));
}
projects / oweals / gnunet.git / blobdiff