struct GNUNET_HashCode *replies_seen;
/**
- * Bloomfilter masking replies we've already seen.
+ * Block group for filtering replies we've already seen.
*/
- struct GNUNET_CONTAINER_BloomFilter *bf;
+ struct GNUNET_BLOCK_Group *bg;
/**
* Entry for this pending request in the expiration heap, or NULL.
*/
unsigned int replies_seen_size;
- /**
- * Mingle value we currently use for the bf.
- */
- uint32_t mingle;
-
/**
* Do we have a first UID yet?
*/
* fresh one of minimal size without problems) OR if our peer is the
* initiator (in which case we may resize to larger than mimimum size).
*
+ * @param type type of the request
* @param pr request for which the BF is to be recomputed
*/
static void
-refresh_bloomfilter (struct GSF_PendingRequest *pr)
+refresh_bloomfilter (enum GNUNET_BLOCK_Type type,
+ struct GSF_PendingRequest *pr)
{
- if (pr->bf != NULL)
- GNUNET_CONTAINER_bloomfilter_free (pr->bf);
- pr->mingle =
- GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, UINT32_MAX);
- pr->bf =
- GNUNET_BLOCK_construct_bloomfilter (pr->mingle, pr->replies_seen,
- pr->replies_seen_count);
+ if (NULL != pr->bg)
+ {
+ GNUNET_BLOCK_group_destroy (pr->bg);
+ pr->bg = NULL;
+ }
+ if (GNUNET_BLOCK_TYPE_FS_UBLOCK != type)
+ return; /* no need */
+ pr->bg
+ = GNUNET_BLOCK_group_create (GSF_block_ctx,
+ type,
+ GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+ UINT32_MAX),
+ NULL,
+ 0,
+ "seen-set-size",
+ pr->replies_seen_count,
+ NULL);
+ if (NULL == pr->bg)
+ return;
+ GNUNET_break (GNUNET_OK ==
+ GNUNET_BLOCK_group_set_seen (pr->bg,
+ pr->replies_seen,
+ pr->replies_seen_count));
}
if (NULL != target)
{
pr->public_data.target = (struct GNUNET_PeerIdentity *) eptr;
- memcpy (eptr,
+ GNUNET_memcpy (eptr,
target,
sizeof (struct GNUNET_PeerIdentity));
}
if (replies_seen_count > 0)
{
pr->replies_seen_size = replies_seen_count;
- pr->replies_seen =
- GNUNET_malloc (sizeof (struct GNUNET_HashCode) * pr->replies_seen_size);
- memcpy (pr->replies_seen,
- replies_seen,
- replies_seen_count * sizeof (struct GNUNET_HashCode));
+ pr->replies_seen = GNUNET_new_array (pr->replies_seen_size,
+ struct GNUNET_HashCode);
+ GNUNET_memcpy (pr->replies_seen,
+ replies_seen,
+ replies_seen_count * sizeof (struct GNUNET_HashCode));
pr->replies_seen_count = replies_seen_count;
}
- if (NULL != bf_data)
+ if ( (NULL != bf_data) &&
+ (GNUNET_BLOCK_TYPE_FS_UBLOCK == pr->public_data.type) )
{
- pr->bf =
- GNUNET_CONTAINER_bloomfilter_init (bf_data,
- bf_size,
- GNUNET_CONSTANTS_BLOOMFILTER_K);
- pr->mingle = mingle;
+ pr->bg
+ = GNUNET_BLOCK_group_create (GSF_block_ctx,
+ pr->public_data.type,
+ mingle,
+ bf_data,
+ bf_size,
+ "seen-set-size",
+ 0,
+ NULL);
}
else if ((replies_seen_count > 0) &&
(0 != (options & GSF_PRO_BLOOMFILTER_FULL_REFRESH)))
{
- refresh_bloomfilter (pr);
+ refresh_bloomfilter (pr->public_data.type,
+ pr);
}
GNUNET_CONTAINER_multihashmap_put (pr_map,
&pr->public_data.query,
const struct GNUNET_HashCode * replies_seen,
unsigned int replies_seen_count)
{
- unsigned int i;
- struct GNUNET_HashCode mhash;
-
if (replies_seen_count + pr->replies_seen_count < pr->replies_seen_count)
return; /* integer overflow */
if (0 != (pr->public_data.options & GSF_PRO_BLOOMFILTER_FULL_REFRESH))
{
/* we're responsible for the BF, full refresh */
if (replies_seen_count + pr->replies_seen_count > pr->replies_seen_size)
- GNUNET_array_grow (pr->replies_seen, pr->replies_seen_size,
+ GNUNET_array_grow (pr->replies_seen,
+ pr->replies_seen_size,
replies_seen_count + pr->replies_seen_count);
- memcpy (&pr->replies_seen[pr->replies_seen_count], replies_seen,
- sizeof (struct GNUNET_HashCode) * replies_seen_count);
+ GNUNET_memcpy (&pr->replies_seen[pr->replies_seen_count],
+ replies_seen,
+ sizeof (struct GNUNET_HashCode) * replies_seen_count);
pr->replies_seen_count += replies_seen_count;
- refresh_bloomfilter (pr);
+ refresh_bloomfilter (pr->public_data.type,
+ pr);
}
else
{
- if (NULL == pr->bf)
+ if (NULL == pr->bg)
{
/* we're not the initiator, but the initiator did not give us
* any bloom-filter, so we need to create one on-the-fly */
- pr->mingle =
- GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
- UINT32_MAX);
- pr->bf =
- GNUNET_BLOCK_construct_bloomfilter (pr->mingle,
- replies_seen,
- replies_seen_count);
+ refresh_bloomfilter (pr->public_data.type,
+ pr);
}
else
{
- for (i = 0; i < pr->replies_seen_count; i++)
- {
- GNUNET_BLOCK_mingle_hash (&replies_seen[i],
- pr->mingle,
- &mhash);
- GNUNET_CONTAINER_bloomfilter_add (pr->bf,
- &mhash);
- }
+ GNUNET_break (GNUNET_OK ==
+ GNUNET_BLOCK_group_set_seen (pr->bg,
+ replies_seen,
+ pr->replies_seen_count));
}
}
if (NULL != pr->gh)
/**
* Generate the message corresponding to the given pending request for
- * transmission to other peers (or at least determine its size).
+ * transmission to other peers.
*
* @param pr request to generate the message for
- * @param buf_size number of bytes available in @a buf
- * @param buf where to copy the message (can be NULL)
- * @return number of bytes needed (if `>` @a buf_size) or used
+ * @return envelope with the request message
*/
-size_t
-GSF_pending_request_get_message_ (struct GSF_PendingRequest *pr,
- size_t buf_size, void *buf)
+struct GNUNET_MQ_Envelope *
+GSF_pending_request_get_message_ (struct GSF_PendingRequest *pr)
{
- char lbuf[GNUNET_SERVER_MAX_MESSAGE_SIZE];
+ struct GNUNET_MQ_Envelope *env;
struct GetMessage *gm;
struct GNUNET_PeerIdentity *ext;
- size_t msize;
unsigned int k;
uint32_t bm;
uint32_t prio;
struct GNUNET_TIME_Absolute now;
int64_t ttl;
int do_route;
+ void *bf_data;
+ uint32_t bf_nonce;
- if (buf_size > 0)
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Building request message for `%s' of type %d\n",
- GNUNET_h2s (&pr->public_data.query),
- pr->public_data.type);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Building request message for `%s' of type %d\n",
+ GNUNET_h2s (&pr->public_data.query),
+ pr->public_data.type);
k = 0;
bm = 0;
do_route = (0 == (pr->public_data.options & GSF_PRO_FORWARD_ONLY));
bm |= GET_MESSAGE_BIT_TRANSMIT_TO;
k++;
}
- bf_size = GNUNET_CONTAINER_bloomfilter_get_size (pr->bf);
- msize = sizeof (struct GetMessage) + bf_size + k * sizeof (struct GNUNET_PeerIdentity);
- GNUNET_assert (msize < GNUNET_SERVER_MAX_MESSAGE_SIZE);
- if (buf_size < msize)
- return msize;
- gm = (struct GetMessage *) lbuf;
- gm->header.type = htons (GNUNET_MESSAGE_TYPE_FS_GET);
- gm->header.size = htons (msize);
+ if (GNUNET_OK !=
+ GNUNET_BLOCK_group_serialize (pr->bg,
+ &bf_nonce,
+ &bf_data,
+ &bf_size))
+ {
+ bf_size = 0;
+ bf_data = NULL;
+ }
+ env = GNUNET_MQ_msg_extra (gm,
+ bf_size + k * sizeof (struct GNUNET_PeerIdentity),
+ GNUNET_MESSAGE_TYPE_FS_GET);
gm->type = htonl (pr->public_data.type);
if (do_route)
prio =
now = GNUNET_TIME_absolute_get ();
ttl = (int64_t) (pr->public_data.ttl.abs_value_us - now.abs_value_us);
gm->ttl = htonl (ttl / 1000LL / 1000LL);
- gm->filter_mutator = htonl (pr->mingle);
+ gm->filter_mutator = htonl (bf_nonce);
gm->hash_bitmap = htonl (bm);
gm->query = pr->public_data.query;
ext = (struct GNUNET_PeerIdentity *) &gm[1];
k = 0;
- if (!do_route)
+ if (! do_route)
GNUNET_PEER_resolve (pr->sender_pid,
&ext[k++]);
if (NULL != pr->public_data.target)
ext[k++] = *pr->public_data.target;
- if (NULL != pr->bf)
- GNUNET_assert (GNUNET_SYSERR !=
- GNUNET_CONTAINER_bloomfilter_get_raw_data (pr->bf,
- (char *) &ext[k],
- bf_size));
- memcpy (buf, gm, msize);
- return msize;
+ GNUNET_memcpy (&ext[k],
+ bf_data,
+ bf_size);
+ GNUNET_free_non_null (bf_data);
+ return env;
}
}
GSF_plan_notify_request_done_ (pr);
GNUNET_free_non_null (pr->replies_seen);
- if (NULL != pr->bf)
- {
- GNUNET_CONTAINER_bloomfilter_free (pr->bf);
- pr->bf = NULL;
- }
+ GNUNET_BLOCK_group_destroy (pr->bg);
+ pr->bg = NULL;
GNUNET_PEER_change_rc (pr->sender_pid, -1);
pr->sender_pid = 0;
GNUNET_PEER_change_rc (pr->origin_pid, -1);
prq->eval =
GNUNET_BLOCK_evaluate (GSF_block_ctx,
prq->type,
+ pr->bg,
prq->eo,
key,
- &pr->bf,
- pr->mingle,
NULL,
0,
prq->data,
ppd->migration_delay);
mig_pause.rel_value_us = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
ppd->migration_delay.rel_value_us);
- ppd->migration_delay = GNUNET_TIME_relative_multiply (ppd->migration_delay, 2);
+ ppd->migration_delay = GNUNET_TIME_relative_saturating_multiply (ppd->migration_delay, 2);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Replicated content already exists locally, asking to stop migration for %s\n",
GNUNET_STRINGS_relative_time_to_string (mig_pause,
{
GNUNET_assert (0 != pr->sender_pid);
GNUNET_PEER_resolve (pr->sender_pid, &pi);
- memcpy (&buf[xquery_size], &pi, sizeof (struct GNUNET_PeerIdentity));
+ GNUNET_memcpy (&buf[xquery_size], &pi, sizeof (struct GNUNET_PeerIdentity));
xquery_size += sizeof (struct GNUNET_PeerIdentity);
}
pr->gh =
* this content and possibly passes it on (to local clients or other
* peers). Does NOT perform migration (content caching at this peer).
*
- * @param cp the other peer involved (sender or receiver, NULL
- * for loopback messages where we are both sender and receiver)
- * @param message the actual message
- * @return #GNUNET_OK if the message was well-formed,
- * #GNUNET_SYSERR if the message was malformed (close connection,
- * do not cache under any circumstances)
+ * @param cls the other peer involved
+ * @param put the actual message
*/
-int
-GSF_handle_p2p_content_ (struct GSF_ConnectedPeer *cp,
- const struct GNUNET_MessageHeader *message)
+void
+handle_p2p_put (void *cls,
+ const struct PutMessage *put)
{
- const struct PutMessage *put;
+ struct GSF_ConnectedPeer *cp = cls;
uint16_t msize;
size_t dsize;
enum GNUNET_BLOCK_Type type;
double putl;
struct PutMigrationContext *pmc;
- msize = ntohs (message->size);
- if (msize < sizeof (struct PutMessage))
- {
- GNUNET_break_op (0);
- return GNUNET_SYSERR;
- }
- put = (const struct PutMessage *) message;
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Received P2P PUT from %s\n",
+ GNUNET_i2s (GSF_get_peer_performance_data_ (cp)->peer));
+ GSF_cover_content_count++;
+ msize = ntohs (put->header.size);
dsize = msize - sizeof (struct PutMessage);
type = ntohl (put->type);
expiration = GNUNET_TIME_absolute_ntoh (put->expiration);
/* do not allow migrated content to live longer than 1 year */
expiration = GNUNET_TIME_absolute_min (GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_YEARS),
expiration);
- if (GNUNET_BLOCK_TYPE_FS_ONDEMAND == type)
- return GNUNET_SYSERR;
if (GNUNET_OK !=
GNUNET_BLOCK_get_key (GSF_block_ctx,
type,
&query))
{
GNUNET_break_op (0);
- return GNUNET_SYSERR;
+ return;
}
GNUNET_STATISTICS_update (GSF_stats,
gettext_noop ("# GAP PUT messages received"),
GNUNET_PEER_resolve (GSF_get_peer_performance_data_ (cp)->pid,
&pmc->origin);
if (NULL ==
- GNUNET_DATASTORE_put (GSF_dsh, 0, &query, dsize, &put[1], type,
- prq.priority, 1 /* anonymity */ ,
+ GNUNET_DATASTORE_put (GSF_dsh,
+ 0,
+ &query,
+ dsize,
+ &put[1],
+ type,
+ prq.priority,
+ 1 /* anonymity */ ,
0 /* replication */ ,
- expiration, 1 + prq.priority, MAX_DATASTORE_QUEUE,
- &put_migration_continuation, pmc))
+ expiration, 1 + prq.priority,
+ MAX_DATASTORE_QUEUE,
+ &put_migration_continuation,
+ pmc))
{
put_migration_continuation (pmc,
GNUNET_SYSERR,
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Choosing not to keep content `%s' (%d/%d)\n",
- GNUNET_h2s (&query), active_to_migration,
+ GNUNET_h2s (&query),
+ active_to_migration,
test_put_load_too_high (prq.priority));
}
putl = GNUNET_LOAD_get_load (datastore_put_load);
putl,
active_to_migration,
(GNUNET_NO == prq.request_found));
- GSF_block_peer_migration_ (cp, GNUNET_TIME_relative_to_absolute (block_time));
+ GSF_block_peer_migration_ (cp,
+ GNUNET_TIME_relative_to_absolute (block_time));
}
- return GNUNET_OK;
}
projects / oweals / gnunet.git / blobdiff