/*
This file is part of GNUnet.
- Copyright (C) 2009-2013 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2009-2013 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
You should have received a copy of the GNU General Public License
along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
+ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
*/
/**
/**
* Maximum size of the datastore queue for P2P operations. Needs to
- * be large enough to queue MAX_QUEUE_PER_PEER operations for roughly
+ * be large enough to queue #MAX_QUEUE_PER_PEER operations for roughly
* the number of active (connected) peers.
*/
#define MAX_DATASTORE_QUEUE (16 * MAX_QUEUE_PER_PEER)
enum GNUNET_BLOCK_Type type,
const struct GNUNET_HashCode *query,
const struct GNUNET_PeerIdentity *target,
- const char *bf_data, size_t bf_size,
- uint32_t mingle, uint32_t anonymity_level,
- uint32_t priority, int32_t ttl,
+ const char *bf_data,
+ size_t bf_size,
+ uint32_t mingle,
+ uint32_t anonymity_level,
+ uint32_t priority,
+ int32_t ttl,
GNUNET_PEER_Id sender_pid,
GNUNET_PEER_Id origin_pid,
const struct GNUNET_HashCode *replies_seen,
unsigned int replies_seen_count,
- GSF_PendingRequestReplyHandler rh, void *rh_cls)
+ GSF_PendingRequestReplyHandler rh,
+ void *rh_cls)
{
struct GSF_PendingRequest *pr;
struct GSF_PendingRequest *dpr;
if (NULL != target)
{
pr->public_data.target = (struct GNUNET_PeerIdentity *) eptr;
- memcpy (eptr, target, sizeof (struct GNUNET_PeerIdentity));
+ memcpy (eptr,
+ target,
+ sizeof (struct GNUNET_PeerIdentity));
}
pr->public_data.anonymity_level = anonymity_level;
pr->public_data.priority = priority;
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,
+ memcpy (pr->replies_seen,
+ replies_seen,
replies_seen_count * sizeof (struct GNUNET_HashCode));
pr->replies_seen_count = replies_seen_count;
}
if (NULL != bf_data)
{
pr->bf =
- GNUNET_CONTAINER_bloomfilter_init (bf_data, bf_size,
+ GNUNET_CONTAINER_bloomfilter_init (bf_data,
+ bf_size,
GNUNET_CONSTANTS_BLOOMFILTER_K);
pr->mingle = mingle;
}
refresh_bloomfilter (pr);
}
GNUNET_CONTAINER_multihashmap_put (pr_map,
- &pr->public_data.query, pr,
+ &pr->public_data.query,
+ pr,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
if (0 == (options & GSF_PRO_REQUEST_NEVER_EXPIRES))
{
pr->hnode =
- GNUNET_CONTAINER_heap_insert (requests_by_expiration_heap, pr,
+ GNUNET_CONTAINER_heap_insert (requests_by_expiration_heap,
+ pr,
pr->public_data.ttl.abs_value_us);
/* make sure we don't track too many requests */
while (GNUNET_CONTAINER_heap_get_size (requests_by_expiration_heap) >
max_pending_requests)
{
dpr = GNUNET_CONTAINER_heap_peek (requests_by_expiration_heap);
- GNUNET_assert (dpr != NULL);
+ GNUNET_assert (NULL != dpr);
if (pr == dpr)
break; /* let the request live briefly... */
if (NULL != dpr->rh)
- dpr->rh (dpr->rh_cls, GNUNET_BLOCK_EVALUATION_REQUEST_VALID, dpr,
- UINT32_MAX, GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_TIME_UNIT_FOREVER_ABS,
- GNUNET_BLOCK_TYPE_ANY, NULL, 0);
- GSF_pending_request_cancel_ (dpr, GNUNET_YES);
+ dpr->rh (dpr->rh_cls,
+ GNUNET_BLOCK_EVALUATION_REQUEST_VALID,
+ dpr,
+ UINT32_MAX,
+ GNUNET_TIME_UNIT_FOREVER_ABS,
+ GNUNET_TIME_UNIT_FOREVER_ABS,
+ GNUNET_BLOCK_TYPE_ANY,
+ NULL,
+ 0);
+ GSF_pending_request_cancel_ (dpr,
+ GNUNET_YES);
}
}
GNUNET_STATISTICS_update (GSF_stats,
GSF_pending_request_is_compatible_ (struct GSF_PendingRequest *pra,
struct GSF_PendingRequest *prb)
{
- if ((pra->public_data.type != prb->public_data.type) ||
- (0 !=
- memcmp (&pra->public_data.query, &prb->public_data.query,
- sizeof (struct GNUNET_HashCode))))
+ if ( (pra->public_data.type != prb->public_data.type) ||
+ (0 != memcmp (&pra->public_data.query,
+ &prb->public_data.query,
+ sizeof (struct GNUNET_HashCode))))
return GNUNET_NO;
return GNUNET_OK;
}
-
/**
* Update a given pending request with additional replies
* that have been seen.
/* 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);
+ GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+ UINT32_MAX);
pr->bf =
- GNUNET_BLOCK_construct_bloomfilter (pr->mingle, replies_seen,
+ GNUNET_BLOCK_construct_bloomfilter (pr->mingle,
+ replies_seen,
replies_seen_count);
}
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_BLOCK_mingle_hash (&replies_seen[i],
+ pr->mingle,
+ &mhash);
+ GNUNET_CONTAINER_bloomfilter_add (pr->bf,
+ &mhash);
}
}
}
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_h2s (&pr->public_data.query),
+ pr->public_data.type);
k = 0;
bm = 0;
do_route = (0 == (pr->public_data.options & GSF_PRO_FORWARD_ONLY));
* @return #GNUNET_YES (we should continue to iterate)
*/
static int
-clean_request (void *cls, const struct GNUNET_HashCode *key, void *value)
+clean_request (void *cls,
+ const struct GNUNET_HashCode *key,
+ void *value)
{
struct GSF_PendingRequest *pr = value;
GSF_LocalLookupContinuation cont;
if (NULL != (cont = pr->llc_cont))
{
pr->llc_cont = NULL;
- cont (pr->llc_cont_cls, pr, pr->local_result);
+ cont (pr->llc_cont_cls,
+ pr,
+ pr->local_result);
}
GSF_plan_notify_request_done_ (pr);
GNUNET_free_non_null (pr->replies_seen);
&pr->public_data.query,
pr));
GNUNET_STATISTICS_update (GSF_stats,
- gettext_noop ("# Pending requests active"), -1,
+ gettext_noop ("# Pending requests active"),
+ -1,
GNUNET_NO);
GNUNET_free (pr);
return GNUNET_YES;
* @param full_cleanup fully purge the request
*/
void
-GSF_pending_request_cancel_ (struct GSF_PendingRequest *pr, int full_cleanup)
+GSF_pending_request_cancel_ (struct GSF_PendingRequest *pr,
+ int full_cleanup)
{
GSF_LocalLookupContinuation cont;
if (NULL == pr_map)
return; /* already cleaned up! */
- if (GNUNET_YES != full_cleanup)
+ if (GNUNET_NO == full_cleanup)
{
/* make request inactive (we're no longer interested in more results),
* but do NOT remove from our data-structures, we still need it there
if (NULL != (cont = pr->llc_cont))
{
pr->llc_cont = NULL;
- cont (pr->llc_cont_cls, pr, pr->local_result);
+ cont (pr->llc_cont_cls,
+ pr,
+ pr->local_result);
}
GSF_plan_notify_request_done_ (pr);
if (NULL != pr->qe)
return;
}
GNUNET_assert (GNUNET_YES ==
- clean_request (NULL, &pr->public_data.query, pr));
+ clean_request (NULL,
+ &pr->public_data.query,
+ pr));
}
* Iterate over all pending requests.
*
* @param it function to call for each request
- * @param cls closure for it
+ * @param cls closure for @a it
*/
void
GSF_iterate_pending_requests_ (GSF_PendingRequestIterator it, void *cls)
/* retry -- without delay, as this is non-anonymous
and cadet/cadet connect will take some time anyway */
pr->cadet_request = GSF_cadet_query (pr->public_data.target,
- &pr->public_data.query,
- pr->public_data.type,
- &cadet_reply_proc,
- pr);
+ &pr->public_data.query,
+ pr->public_data.type,
+ &cadet_reply_proc,
+ pr);
return;
}
if (GNUNET_YES !=
if (NULL != pr->cadet_request)
return;
pr->cadet_request = GSF_cadet_query (pr->public_data.target,
- &pr->public_data.query,
- pr->public_data.type,
- &cadet_reply_proc,
- pr);
+ &pr->public_data.query,
+ pr->public_data.type,
+ &cadet_reply_proc,
+ pr);
}
/**
* Task that issues a warning if the datastore lookup takes too long.
*
- * @param cls the 'struct GSF_PendingRequest'
- * @param tc task context
+ * @param cls the `struct GSF_PendingRequest`
*/
static void
-warn_delay_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+warn_delay_task (void *cls)
{
struct GSF_PendingRequest *pr = cls;
/**
* Task that issues a warning if the datastore lookup takes too long.
*
- * @param cls the 'struct GSF_PendingRequest'
- * @param tc task context
+ * @param cls the `struct GSF_PendingRequest`
*/
static void
-odc_warn_delay_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+odc_warn_delay_task (void *cls)
{
struct GSF_PendingRequest *pr = cls;
/* max queue size */ ,
GNUNET_TIME_UNIT_FOREVER_REL,
&process_local_reply, pr);
- if (pr->qe == NULL)
+ if (NULL == pr->qe)
{
GNUNET_STATISTICS_update (GSF_stats,
gettext_noop
}
+/**
+ * Check if the given request is still active.
+ *
+ * @param pr pending request
+ * @return #GNUNET_YES if the request is still active
+ */
+int
+GSF_pending_request_test_active_ (struct GSF_PendingRequest *pr)
+{
+ return (NULL != pr->rh) ? GNUNET_YES : GNUNET_NO;
+}
+
+
/**
* Setup the subsystem.
*/
void
GSF_pending_request_done_ ()
{
- GNUNET_CONTAINER_multihashmap_iterate (pr_map, &clean_request, NULL);
+ GNUNET_CONTAINER_multihashmap_iterate (pr_map,
+ &clean_request,
+ NULL);
GNUNET_CONTAINER_multihashmap_destroy (pr_map);
pr_map = NULL;
GNUNET_CONTAINER_heap_destroy (requests_by_expiration_heap);