#include "gnunet-service-fs_indexing.h"
#include "gnunet-service-fs_pe.h"
#include "gnunet-service-fs_pr.h"
-#include "gnunet-service-fs_mesh.h"
+#include "gnunet-service-fs_cadet.h"
/**
#define INSANE_STATISTICS GNUNET_NO
/**
- * If obtaining a block via mesh fails, how often do we retry it before
+ * If obtaining a block via cadet fails, how often do we retry it before
* giving up for good (and sticking to non-anonymous transfer)?
*/
-#define MESH_RETRY_MAX 3
+#define CADET_RETRY_MAX 3
/**
struct GNUNET_DHT_GetHandle *gh;
/**
- * Mesh request handle for this request (or NULL for none).
+ * Cadet request handle for this request (or NULL for none).
*/
- struct GSF_MeshRequest *mesh_request;
+ struct GSF_CadetRequest *cadet_request;
/**
* Function to call upon completion of the local get
GSF_LocalLookupContinuation llc_cont;
/**
- * Closure for llc_cont.
+ * Closure for @e llc_cont.
*/
void *llc_cont_cls;
uint64_t first_uid;
/**
- * How often have we retried this request via 'mesh'?
+ * How often have we retried this request via 'cadet'?
* (used to bound overall retries).
*/
- unsigned int mesh_retry_count;
+ unsigned int cadet_retry_count;
/**
* Number of valid entries in the 'replies_seen' array.
{
char lbuf[GNUNET_SERVER_MAX_MESSAGE_SIZE];
struct GetMessage *gm;
- struct GNUNET_HashCode *ext;
+ struct GNUNET_PeerIdentity *ext;
size_t msize;
unsigned int k;
uint32_t bm;
k++;
}
bf_size = GNUNET_CONTAINER_bloomfilter_get_size (pr->bf);
- msize = sizeof (struct GetMessage) + bf_size + k * sizeof (struct GNUNET_HashCode);
+ 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->filter_mutator = htonl (pr->mingle);
gm->hash_bitmap = htonl (bm);
gm->query = pr->public_data.query;
- ext = (struct GNUNET_HashCode *) & gm[1];
+ ext = (struct GNUNET_PeerIdentity *) &gm[1];
k = 0;
if (!do_route)
GNUNET_PEER_resolve (pr->sender_pid,
- (struct GNUNET_PeerIdentity *) &ext[k++]);
+ &ext[k++]);
if (NULL != pr->public_data.target)
- memcpy (&ext[k++],
- pr->public_data.target,
- sizeof (struct GNUNET_PeerIdentity));
- if (pr->bf != NULL)
+ 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],
* @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;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Cleaning up pending request for `%s'.\n", GNUNET_h2s (key));
+ "Cleaning up pending request for `%s'.\n",
+ GNUNET_h2s (key));
+ if (NULL != pr->cadet_request)
+ {
+ pr->cadet_retry_count = CADET_RETRY_MAX;
+ GSF_cadet_query_cancel (pr->cadet_request);
+ pr->cadet_request = NULL;
+ }
if (NULL != (cont = pr->llc_cont))
{
pr->llc_cont = NULL;
GNUNET_DHT_get_stop (pr->gh);
pr->gh = NULL;
}
- if (NULL != pr->mesh_request)
- {
- GSF_mesh_query_cancel (pr->mesh_request);
- pr->mesh_request = NULL;
- }
if (GNUNET_SCHEDULER_NO_TASK != pr->warn_task)
{
GNUNET_SCHEDULER_cancel (pr->warn_task);
* but do NOT remove from our data-structures, we still need it there
* to prevent the request from looping */
pr->rh = NULL;
+ if (NULL != pr->cadet_request)
+ {
+ pr->cadet_retry_count = CADET_RETRY_MAX;
+ GSF_cadet_query_cancel (pr->cadet_request);
+ pr->cadet_request = NULL;
+ }
if (NULL != (cont = pr->llc_cont))
{
pr->llc_cont = NULL;
GNUNET_DHT_get_stop (pr->gh);
pr->gh = NULL;
}
- if (NULL != pr->mesh_request)
- {
- GSF_mesh_query_cancel (pr->mesh_request);
- pr->mesh_request = NULL;
- }
if (GNUNET_SCHEDULER_NO_TASK != pr->warn_task)
{
GNUNET_SCHEDULER_cancel (pr->warn_task);
}
-
-
/**
- * Closure for "process_reply" function.
+ * Closure for process_reply() function.
*/
struct ProcessReplyClosure
{
* @return #GNUNET_YES (we should continue to iterate)
*/
static int
-process_reply (void *cls, const struct GNUNET_HashCode * key, void *value)
+process_reply (void *cls,
+ const struct GNUNET_HashCode *key,
+ void *value)
{
struct ProcessReplyClosure *prq = cls;
struct GSF_PendingRequest *pr = value;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Replicating result for query `%s' with priority %u\n",
GNUNET_h2s (key), prq.priority);
- pmc = GNUNET_malloc (sizeof (struct PutMigrationContext));
+ pmc = GNUNET_new (struct PutMigrationContext);
pmc->start = GNUNET_TIME_absolute_get ();
pmc->requested = GNUNET_YES;
if (NULL ==
/**
- * Function called with a reply from the mesh.
+ * Function called with a reply from the cadet.
*
* @param cls the pending request struct
* @param type type of the block, ANY on error
* @param expiration expiration time for the block
- * @param data_size number of bytes in 'data', 0 on error
+ * @param data_size number of bytes in @a data, 0 on error
* @param data reply block data, NULL on error
*/
static void
-mesh_reply_proc (void *cls,
- enum GNUNET_BLOCK_Type type,
- struct GNUNET_TIME_Absolute expiration,
- size_t data_size,
- const void *data)
+cadet_reply_proc (void *cls,
+ enum GNUNET_BLOCK_Type type,
+ struct GNUNET_TIME_Absolute expiration,
+ size_t data_size,
+ const void *data)
{
struct GSF_PendingRequest *pr = cls;
struct ProcessReplyClosure prq;
struct GNUNET_HashCode query;
- pr->mesh_request = NULL;
+ pr->cadet_request = NULL;
if (GNUNET_BLOCK_TYPE_ANY == type)
{
GNUNET_break (NULL == data);
GNUNET_break (0 == data_size);
+ pr->cadet_retry_count++;
+ if (pr->cadet_retry_count >= CADET_RETRY_MAX)
+ return; /* give up on cadet */
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Error retrieiving block via mesh\n");
- pr->mesh_retry_count++;
- if (pr->mesh_retry_count >= MESH_RETRY_MAX)
- return; /* give up on mesh */
+ "Error retrieiving block via cadet\n");
/* retry -- without delay, as this is non-anonymous
- and mesh/mesh connect will take some time anyway */
- pr->mesh_request = GSF_mesh_query (pr->public_data.target,
- &pr->public_data.query,
- pr->public_data.type,
- &mesh_reply_proc,
- pr);
+ 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);
return;
}
if (GNUNET_YES !=
return;
}
GNUNET_STATISTICS_update (GSF_stats,
- gettext_noop ("# Replies received from MESH"), 1,
+ gettext_noop ("# Replies received from CADET"), 1,
GNUNET_NO);
memset (&prq, 0, sizeof (prq));
prq.data = data;
/**
- * Consider downloading via mesh (if possible)
+ * Consider downloading via cadet (if possible)
*
* @param pr the pending request to process
*/
void
-GSF_mesh_lookup_ (struct GSF_PendingRequest *pr)
+GSF_cadet_lookup_ (struct GSF_PendingRequest *pr)
{
if (0 != pr->public_data.anonymity_level)
return;
if (0 == pr->public_data.target)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Cannot do mesh-based download, target peer not known\n");
+ "Cannot do cadet-based download, target peer not known\n");
return;
}
- if (NULL != pr->mesh_request)
+ if (NULL != pr->cadet_request)
return;
- pr->mesh_request = GSF_mesh_query (pr->public_data.target,
+ pr->cadet_request = GSF_cadet_query (pr->public_data.target,
&pr->public_data.query,
pr->public_data.type,
- &mesh_reply_proc,
+ &cadet_reply_proc,
pr);
}
if (NULL == (cont = pr->llc_cont))
return; /* no continuation */
pr->llc_cont = NULL;
+ if (0 != (GSF_PRO_LOCAL_ONLY & pr->public_data.options))
+ {
+ if (GNUNET_BLOCK_EVALUATION_OK_LAST != pr->local_result)
+ {
+ /* Signal that we are done and that there won't be any
+ additional results to allow client to clean up state. */
+ pr->rh (pr->rh_cls,
+ GNUNET_BLOCK_EVALUATION_OK_LAST,
+ pr,
+ UINT32_MAX,
+ GNUNET_TIME_UNIT_ZERO_ABS,
+ GNUNET_TIME_UNIT_FOREVER_ABS,
+ GNUNET_BLOCK_TYPE_ANY,
+ NULL, 0);
+ }
+ /* Finally, call our continuation to signal that we are
+ done with local processing of this request; i.e. to
+ start reading again from the client. */
+ cont (pr->llc_cont_cls, NULL, GNUNET_BLOCK_EVALUATION_OK_LAST);
+ return;
+ }
+
cont (pr->llc_cont_cls, pr, pr->local_result);
}
GSF_LocalLookupContinuation cont, void *cont_cls)
{
GNUNET_assert (NULL == pr->gh);
- GNUNET_assert (NULL == pr->mesh_request);
+ GNUNET_assert (NULL == pr->cadet_request);
GNUNET_assert (NULL == pr->llc_cont);
pr->llc_cont = cont;
pr->llc_cont_cls = cont_cls;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Replicating result for query `%s' with priority %u\n",
GNUNET_h2s (&query), prq.priority);
- pmc = GNUNET_malloc (sizeof (struct PutMigrationContext));
+ pmc = GNUNET_new (struct PutMigrationContext);
pmc->start = GNUNET_TIME_absolute_get ();
pmc->requested = prq.request_found;
GNUNET_assert (0 != GSF_get_peer_performance_data_ (cp)->pid);
projects / oweals / gnunet.git / blobdiff