GNUnet  0.20.0
gnunet-service-fs_pr.h File Reference

API to handle pending requests. More...

Include dependency graph for gnunet-service-fs_pr.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  GSF_PendingRequestData
 Public data (in the sense of not encapsulated within 'gnunet-service-fs_pr', not in the sense of network-wide known) associated with each pending request. More...


typedef void(* GSF_PendingRequestReplyHandler) (void *cls, enum GNUNET_BLOCK_ReplyEvaluationResult eval, struct GSF_PendingRequest *pr, uint32_t reply_anonymity_level, struct GNUNET_TIME_Absolute expiration, struct GNUNET_TIME_Absolute last_transmission, enum GNUNET_BLOCK_Type type, const void *data, size_t data_len)
 Handle a reply to a pending request. More...
typedef int(* GSF_PendingRequestIterator) (void *cls, const struct GNUNET_HashCode *key, struct GSF_PendingRequest *pr)
 Signature of function called on each request. More...
typedef void(* GSF_LocalLookupContinuation) (void *cls, struct GSF_PendingRequest *pr, enum GNUNET_BLOCK_ReplyEvaluationResult result)
 Function to be called after we're done processing replies from the local lookup. More...


enum  GSF_PendingRequestOptions {
 Options for pending requests (bits to be ORed). More...


struct GSF_PendingRequestGSF_pending_request_create_ (enum GSF_PendingRequestOptions options, 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 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)
 Create a new pending request. More...
void GSF_pending_request_update_ (struct GSF_PendingRequest *pr, const struct GNUNET_HashCode *replies_seen, unsigned int replies_seen_count)
 Update a given pending request with additional replies that have been seen. More...
struct GSF_PendingRequestDataGSF_pending_request_get_data_ (struct GSF_PendingRequest *pr)
 Obtain the public data associated with a pending request. More...
int GSF_pending_request_test_active_ (struct GSF_PendingRequest *pr)
 Check if the given request is still active. More...
int GSF_pending_request_is_compatible_ (struct GSF_PendingRequest *pra, struct GSF_PendingRequest *prb)
 Test if two pending requests are compatible (would generate the same query modulo filters and should thus be processed jointly). More...
struct GNUNET_MQ_EnvelopeGSF_pending_request_get_message_ (struct GSF_PendingRequest *pr)
 Generate the message corresponding to the given pending request for transmission to other peers. More...
void GSF_pending_request_cancel_ (struct GSF_PendingRequest *pr, int full_cleanup)
 Explicitly cancel a pending request. More...
void GSF_iterate_pending_requests_ (GSF_PendingRequestIterator it, void *cls)
 Iterate over all pending requests. More...
void handle_p2p_put (void *cls, const struct PutMessage *put)
 Handle P2P "CONTENT" message. More...
void GSF_dht_lookup_ (struct GSF_PendingRequest *pr)
 Consider looking up the data in the DHT (anonymity-level permitting). More...
void GSF_cadet_lookup_ (struct GSF_PendingRequest *pr)
 Consider downloading via cadet (if possible) More...
void GSF_local_lookup_ (struct GSF_PendingRequest *pr, GSF_LocalLookupContinuation cont, void *cont_cls)
 Look up the request in the local datastore. More...
int GSF_pending_request_test_target_ (struct GSF_PendingRequest *pr, const struct GNUNET_PeerIdentity *target)
 Is the given target a legitimate peer for forwarding the given request? More...
void GSF_pending_request_init_ (void)
 Setup the subsystem. More...
void GSF_pending_request_done_ (void)
 Shutdown the subsystem. More...

Detailed Description

API to handle pending requests.

Christian Grothoff

Definition in file gnunet-service-fs_pr.h.

Typedef Documentation

◆ GSF_PendingRequestReplyHandler

typedef void(* GSF_PendingRequestReplyHandler) (void *cls, enum GNUNET_BLOCK_ReplyEvaluationResult eval, struct GSF_PendingRequest *pr, uint32_t reply_anonymity_level, struct GNUNET_TIME_Absolute expiration, struct GNUNET_TIME_Absolute last_transmission, enum GNUNET_BLOCK_Type type, const void *data, size_t data_len)

Handle a reply to a pending request.

Also called if a request expires (then with data == NULL). The handler may be called many times (depending on the request type), but will not be called during or after a call to GSF_pending_request_cancel and will also not be called anymore after a call signalling expiration.

clsuser-specified closure
evalevaluation of the result
prhandle to the original pending request
reply_anonymity_levelanonymity level for the reply, UINT32_MAX for "unknown"
expirationwhen does data expire?
last_transmissionthe last time we've tried to get this block (FOREVER if unknown)
typetype of the block
dataresponse data, NULL on request expiration
data_lennumber of bytes in data

Definition at line 186 of file gnunet-service-fs_pr.h.

◆ GSF_PendingRequestIterator

typedef int(* GSF_PendingRequestIterator) (void *cls, const struct GNUNET_HashCode *key, struct GSF_PendingRequest *pr)

Signature of function called on each request.

(Note: 'subtype' of GNUNET_CONTAINER_HashMapIterator).

keyquery for the request
prhandle to the pending request
GNUNET_YES to continue to iterate

Definition at line 318 of file gnunet-service-fs_pr.h.

◆ GSF_LocalLookupContinuation

typedef void(* GSF_LocalLookupContinuation) (void *cls, struct GSF_PendingRequest *pr, enum GNUNET_BLOCK_ReplyEvaluationResult result)

Function to be called after we're done processing replies from the local lookup.

prthe pending request we were processing
resultfinal datastore lookup result

Definition at line 375 of file gnunet-service-fs_pr.h.

Enumeration Type Documentation

◆ GSF_PendingRequestOptions

Options for pending requests (bits to be ORed).


No special options (P2P-default).


Request must only be processed locally.


Request must only be forwarded (no routing)


Request persists indefinitely (no expiration).


Request is allowed to refresh bloomfilter and change mingle value.


Request priority is allowed to be exceeded.


Option mask for typical local requests.

Definition at line 35 of file gnunet-service-fs_pr.h.

36 {
73 };
No special options (P2P-default).
Option mask for typical local requests.
Request must only be processed locally.
Request priority is allowed to be exceeded.
Request must only be forwarded (no routing)
Request is allowed to refresh bloomfilter and change mingle value.
Request persists indefinitely (no expiration).

Function Documentation

◆ GSF_pending_request_create_()

struct GSF_PendingRequest* GSF_pending_request_create_ ( enum GSF_PendingRequestOptions  options,
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  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 

Create a new pending request.

optionsrequest options
typetype of the block that is being requested
querykey for the lookup
targetpreferred target for the request, NULL for none
bf_dataraw data for bloom filter for known replies, can be NULL
bf_sizenumber of bytes in bf_data
anonymity_leveldesired anonymity level
prioritymaximum outgoing cumulative request priority to use
ttlcurrent time-to-live for the request
sender_pidpeer ID to use for the sender when forwarding, 0 for none; reference counter is taken over by this function
origin_pidpeer ID of origin of query (do not loop back)
replies_seenhash codes of known local replies
replies_seen_countsize of the 'replies_seen' array
rhhandle to call when we get a reply
rh_clsclosure for rh
handle for the new pending request

Definition at line 278 of file gnunet-service-fs_pr.c.

293 {
294  struct GSF_PendingRequest *pr;
295  struct GSF_PendingRequest *dpr;
296  size_t extra;
297  struct GNUNET_HashCode *eptr;
300  "Creating request handle for `%s' of type %d\n",
301  GNUNET_h2s (query),
302  type);
305  gettext_noop ("# Pending requests created"),
306  1,
307  GNUNET_NO);
308 #endif
309  extra = 0;
310  if (NULL != target)
311  extra += sizeof(struct GNUNET_PeerIdentity);
312  pr = GNUNET_malloc (sizeof(struct GSF_PendingRequest) + extra);
313  pr->public_data.query = *query;
314  eptr = (struct GNUNET_HashCode *) &pr[1];
315  if (NULL != target)
316  {
317  pr-> = (struct GNUNET_PeerIdentity *) eptr;
318  GNUNET_memcpy (eptr, target, sizeof(struct GNUNET_PeerIdentity));
319  }
321  pr->public_data.priority = priority;
322  pr->public_data.original_priority = priority;
324  pr->public_data.type = type;
326  pr->sender_pid = sender_pid;
327  pr->origin_pid = origin_pid;
328  pr->rh = rh;
329  pr->rh_cls = rh_cls;
330  GNUNET_assert ((sender_pid != 0) || (0 == (options & GSF_PRO_FORWARD_ONLY)));
331  if (ttl >= 0)
334  else
338  (uint32_t) (-ttl)));
339  if (replies_seen_count > 0)
340  {
341  pr->replies_seen_size = replies_seen_count;
342  pr->replies_seen =
345  replies_seen,
346  replies_seen_count * sizeof(struct GNUNET_HashCode));
347  pr->replies_seen_count = replies_seen_count;
348  }
349  if ((NULL != bf_data) &&
351  {
353  pr->public_data.type,
354  bf_data,
355  bf_size,
356  "seen-set-size",
357  0,
358  NULL);
359  }
360  else if ((replies_seen_count > 0) &&
362  {
364  }
366  &pr->public_data.query,
367  pr,
370  {
372  pr,
374  /* make sure we don't track too many requests */
377  {
379  GNUNET_assert (NULL != dpr);
380  if (pr == dpr)
381  break; /* let the request live briefly... */
382  if (NULL != dpr->rh)
383  dpr->rh (dpr->rh_cls,
385  dpr,
386  UINT32_MAX,
390  NULL,
391  0);
393  }
394  }
396  gettext_noop ("# Pending requests active"),
397  1,
398  GNUNET_NO);
399  return pr;
400 }
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
Type of a block representing any type of search result (universal).
Identifier for any block.
#define gettext_noop(String)
Definition: gettext.h:70
static unsigned int anonymity_level
Anonymity level option to use for publishing.
static struct GNUNET_TIME_Relative ttl
Current record $TTL to use.
struct GNUNET_BLOCK_Context * GSF_block_ctx
Our block context.
struct GNUNET_STATISTICS_Handle * GSF_stats
Handle for reporting statistics.
static unsigned long long max_pending_requests
Maximum number of requests (from other peers, overall) that we're willing to have pending at any give...
static void refresh_bloomfilter(enum GNUNET_BLOCK_Type type, struct GSF_PendingRequest *pr)
Recalculate our bloom filter for filtering replies.
static struct GNUNET_CONTAINER_Heap * requests_by_expiration_heap
Heap with the request that will expire next at the top.
static struct GNUNET_CONTAINER_MultiHashMap * pr_map
All pending requests, ordered by the query.
void GSF_pending_request_cancel_(struct GSF_PendingRequest *pr, int full_cleanup)
Explicitly cancel a pending request.
struct GNUNET_BLOCK_Group * GNUNET_BLOCK_group_create(struct GNUNET_BLOCK_Context *ctx, enum GNUNET_BLOCK_Type type, const void *raw_data, size_t raw_data_size,...)
Create a new block group.
Definition: block.c:247
Specified block type not supported by any plugin.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
Allow multiple values with the same key.
struct GNUNET_CONTAINER_HeapNode * GNUNET_CONTAINER_heap_insert(struct GNUNET_CONTAINER_Heap *heap, void *element, GNUNET_CONTAINER_HeapCostType cost)
Inserts a new element into the heap.
void * GNUNET_CONTAINER_heap_peek(const struct GNUNET_CONTAINER_Heap *heap)
Get element stored at the root of heap.
unsigned int GNUNET_CONTAINER_heap_get_size(const struct GNUNET_CONTAINER_Heap *heap)
Get the current size of the heap.
#define GNUNET_log(kind,...)
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
One second.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:111
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_subtract(struct GNUNET_TIME_Absolute start, struct GNUNET_TIME_Relative duration)
Subtract a given relative duration from the given start time.
Definition: time.c:469
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:316
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:484
Constant used to specify "forever".
A 512-bit hashcode.
The identity of the host (wraps the signing key of the peer).
uint64_t abs_value_us
The actual value.
const struct GNUNET_PeerIdentity * target
Identity of a peer hosting the content, otherwise NULl.
struct GNUNET_TIME_Absolute ttl
Current TTL for the request.
enum GNUNET_BLOCK_Type type
Type of the requested block.
enum GSF_PendingRequestOptions options
Options for the request.
uint32_t anonymity_level
Desired anonymity level.
struct GNUNET_HashCode query
Primary query hash for this request.
struct GNUNET_TIME_Absolute start_time
When did we start with the request.
uint32_t priority
Priority that this request (still) has for us.
uint32_t original_priority
Priority that this request (originally) had for us.
An active request.
unsigned int replies_seen_size
Length of the 'replies_seen' array.
struct GNUNET_BLOCK_Group * bg
Block group for filtering replies we've already seen.
unsigned int replies_seen_count
Number of valid entries in the 'replies_seen' array.
GNUNET_PEER_Id sender_pid
Identity of the peer that we should use for the 'sender' (recipient of the response) when forwarding ...
GSF_PendingRequestReplyHandler rh
Function to call if we encounter a reply.
void * rh_cls
Closure for rh.
struct GSF_PendingRequestData public_data
Public data for the request.
struct GNUNET_CONTAINER_HeapNode * hnode
Entry for this pending request in the expiration heap, or NULL.
GNUNET_PEER_Id origin_pid
Identity of the peer that we should never forward this query to since it originated this query (0 for...
struct GNUNET_HashCode * replies_seen
Array of hash codes of replies we've already seen.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model

References GNUNET_TIME_Absolute::abs_value_us, anonymity_level, GSF_PendingRequestData::anonymity_level, GSF_PendingRequest::bg, gettext_noop, GNUNET_assert, GNUNET_BLOCK_group_create(), GNUNET_BLOCK_REPLY_TYPE_NOT_SUPPORTED, GNUNET_BLOCK_TYPE_ANY, GNUNET_BLOCK_TYPE_FS_UBLOCK, GNUNET_CONTAINER_heap_get_size(), GNUNET_CONTAINER_heap_insert(), GNUNET_CONTAINER_heap_peek(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_new_array, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_subtract(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_TIME_UNIT_SECONDS, GNUNET_YES, GSF_block_ctx, GSF_pending_request_cancel_(), GSF_PRO_BLOOMFILTER_FULL_REFRESH, GSF_PRO_FORWARD_ONLY, GSF_PRO_REQUEST_NEVER_EXPIRES, GSF_stats, GSF_PendingRequest::hnode, max_pending_requests, options, GSF_PendingRequestData::options, GSF_PendingRequest::origin_pid, GSF_PendingRequestData::original_priority, pr_map, GSF_PendingRequestData::priority, GSF_PendingRequest::public_data, GSF_PendingRequestData::query, refresh_bloomfilter(), GSF_PendingRequest::replies_seen, GSF_PendingRequest::replies_seen_count, GSF_PendingRequest::replies_seen_size, requests_by_expiration_heap, GSF_PendingRequest::rh, GSF_PendingRequest::rh_cls, GSF_PendingRequest::sender_pid, GSF_PendingRequestData::start_time, GSF_PendingRequestData::target, GSF_PendingRequestData::ttl, ttl, GSF_PendingRequestData::type, and type.

Referenced by handle_client_start_search(), and handle_p2p_get().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GSF_pending_request_update_()

void GSF_pending_request_update_ ( struct GSF_PendingRequest pr,
const struct GNUNET_HashCode replies_seen,
unsigned int  replies_seen_count 

Update a given pending request with additional replies that have been seen.

prrequest to update
replies_seenhash codes of replies that we've seen
replies_seen_countsize of the replies_seen array

Definition at line 439 of file gnunet-service-fs_pr.c.

442 {
443  if (replies_seen_count + pr->replies_seen_count < pr->replies_seen_count)
444  return; /* integer overflow */
446  {
447  /* we're responsible for the BF, full refresh */
448  if (replies_seen_count + pr->replies_seen_count > pr->replies_seen_size)
450  pr->replies_seen_size,
451  replies_seen_count + pr->replies_seen_count);
453  replies_seen,
454  sizeof(struct GNUNET_HashCode) * replies_seen_count);
455  pr->replies_seen_count += replies_seen_count;
457  }
458  else
459  {
460  if (NULL == pr->bg)
461  {
462  /* we're not the initiator, but the initiator did not give us
463  * any bloom-filter, so we need to create one on-the-fly */
465  }
466  else
467  {
470  replies_seen,
471  pr->replies_seen_count));
472  }
473  }
474  if (NULL != pr->gh)
476  replies_seen_count,
477  replies_seen);
478 }
enum GNUNET_GenericReturnValue GNUNET_BLOCK_group_set_seen(struct GNUNET_BLOCK_Group *bg, const struct GNUNET_HashCode *seen_results, unsigned int seen_results_count)
Update block group to filter out the given results.
Definition: block.c:363
void GNUNET_DHT_get_filter_known_results(struct GNUNET_DHT_GetHandle *get_handle, unsigned int num_results, const struct GNUNET_HashCode *results)
Tell the DHT not to return any of the following known results to this client.
Definition: dht_api.c:1213
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
#define GNUNET_array_grow(arr, size, tsize)
Grow a well-typed (!) array.
struct GNUNET_DHT_GetHandle * gh
DHT request handle for this request (or NULL for none).

References GSF_PendingRequest::bg, GSF_PendingRequest::gh, GNUNET_array_grow, GNUNET_BLOCK_group_set_seen(), GNUNET_break, GNUNET_DHT_get_filter_known_results(), GNUNET_memcpy, GNUNET_OK, GSF_PRO_BLOOMFILTER_FULL_REFRESH, GSF_PendingRequestData::options, GSF_PendingRequest::public_data, refresh_bloomfilter(), GSF_PendingRequest::replies_seen, GSF_PendingRequest::replies_seen_count, GSF_PendingRequest::replies_seen_size, and GSF_PendingRequestData::type.

Referenced by handle_client_start_search().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GSF_pending_request_get_data_()

struct GSF_PendingRequestData* GSF_pending_request_get_data_ ( struct GSF_PendingRequest pr)

Obtain the public data associated with a pending request.

prpending request
associated public data

Definition at line 410 of file gnunet-service-fs_pr.c.

411 {
412  return &pr->public_data;
413 }

References GSF_PendingRequest::public_data.

Referenced by client_response_handler(), free_pending_request(), get_latest(), get_rp_key(), GSF_plan_add_(), GSF_plan_notify_peer_disconnect_(), GSF_plan_notify_request_done_(), handle_client_start_search(), handle_p2p_get(), handle_p2p_reply(), merge_pr(), peer_request_destroy(), plan(), start_p2p_processing(), and test_exist_cb().

Here is the caller graph for this function:

◆ GSF_pending_request_test_active_()

int GSF_pending_request_test_active_ ( struct GSF_PendingRequest pr)

Check if the given request is still active.

prpending request
GNUNET_YES if the request is still active

Definition at line 1840 of file gnunet-service-fs_pr.c.

1841 {
1842  return (NULL != pr->rh) ? GNUNET_YES : GNUNET_NO;
1843 }

References GNUNET_NO, GNUNET_YES, and GSF_PendingRequest::rh.

Referenced by consider_peer_for_forwarding(), get_latest(), GSF_consider_forwarding(), GSF_plan_add_(), and merge_pr().

Here is the caller graph for this function:

◆ GSF_pending_request_is_compatible_()

int GSF_pending_request_is_compatible_ ( struct GSF_PendingRequest pra,
struct GSF_PendingRequest prb 

Test if two pending requests are compatible (would generate the same query modulo filters and should thus be processed jointly).

praa pending request
prbanother pending request
GNUNET_OK if the requests are compatible

Definition at line 426 of file gnunet-service-fs_pr.c.

428 {
429  if ((pra->public_data.type != prb->public_data.type) ||
430  (0 != memcmp (&pra->public_data.query,
431  &prb->public_data.query,
432  sizeof(struct GNUNET_HashCode))))
433  return GNUNET_NO;
434  return GNUNET_OK;
435 }

References GNUNET_NO, GNUNET_OK, GSF_PendingRequest::public_data, GSF_PendingRequestData::query, and GSF_PendingRequestData::type.

Referenced by merge_pr().

Here is the caller graph for this function:

◆ GSF_pending_request_get_message_()

struct GNUNET_MQ_Envelope* GSF_pending_request_get_message_ ( struct GSF_PendingRequest pr)

Generate the message corresponding to the given pending request for transmission to other peers.

prrequest to generate the message for
envelope with the request message

Definition at line 489 of file gnunet-service-fs_pr.c.

490 {
491  struct GNUNET_MQ_Envelope *env;
492  struct GetMessage *gm;
493  struct GNUNET_PeerIdentity *ext;
494  unsigned int k;
495  uint32_t bm;
496  uint32_t prio;
497  size_t bf_size;
498  struct GNUNET_TIME_Absolute now;
499  int64_t ttl;
500  int do_route;
501  void *bf_data;
504  "Building request message for `%s' of type %d\n",
506  pr->public_data.type);
507  k = 0;
508  bm = 0;
509  do_route = (0 == (pr->public_data.options & GSF_PRO_FORWARD_ONLY));
510  if ((! do_route) && (pr->sender_pid == 0))
511  {
512  GNUNET_break (0);
513  do_route = GNUNET_YES;
514  }
515  if (! do_route)
516  {
518  k++;
519  }
520  if (NULL != pr->
521  {
523  k++;
524  }
525  if (GNUNET_OK !=
527  &bf_data,
528  &bf_size))
529  {
530  bf_size = 0;
531  bf_data = NULL;
532  }
533  env = GNUNET_MQ_msg_extra (gm,
534  bf_size + k * sizeof(struct GNUNET_PeerIdentity),
536  gm->type = htonl (pr->public_data.type);
537  if (do_route)
539  pr->public_data.priority + 1);
540  else
541  prio = 0;
542  pr->public_data.priority -= prio;
544  pr->public_data.respect_offered += prio;
545  gm->priority = htonl (prio);
546  now = GNUNET_TIME_absolute_get ();
547  ttl = (int64_t) (pr->public_data.ttl.abs_value_us - now.abs_value_us);
548  gm->ttl = htonl (ttl / 1000LL / 1000LL);
549  gm->reserved = htonl (0);
550  gm->hash_bitmap = htonl (bm);
551  gm->query = pr->public_data.query;
552  ext = (struct GNUNET_PeerIdentity *) &gm[1];
553  k = 0;
554  if (! do_route)
555  GNUNET_PEER_resolve (pr->sender_pid, &ext[k++]);
556  if (NULL != pr->
557  ext[k++] = *pr->;
558  GNUNET_memcpy (&ext[k], bf_data, bf_size);
559  GNUNET_free (bf_data);
560  return env;
561 }
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
The peer identity of a peer that had claimed to have the content previously is included (can be used ...
The peer identity of a peer waiting for the reply is included (used if the response should be transmi...
enum GNUNET_GenericReturnValue GNUNET_BLOCK_group_serialize(struct GNUNET_BLOCK_Group *bg, void **raw_data, size_t *raw_data_size)
Serialize state of a block group.
Definition: block.c:175
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
#define GNUNET_free(ptr)
Wrapper around free.
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
Definition: gnunet_mq_lib.h:63
void GNUNET_PEER_resolve(GNUNET_PEER_Id id, struct GNUNET_PeerIdentity *pid)
Convert an interned PID to a normal peer identity.
Definition: peer.c:220
P2P request for content (one FS to another).
Time for absolute times used by GNUnet, in microseconds.
uint32_t respect_offered
How much respect did we (in total) offer for this request so far (estimate, because we might have the...
uint32_t num_transmissions
Counter for how often this request has been transmitted (estimate, because we might have the same req...
Message to the datastore service asking about specific content.
Definition: datastore.h:141
uint32_t type
Desired content type.
Definition: datastore.h:150
uint32_t priority
How important is this request (network byte order)
struct GNUNET_HashCode query
Hashcodes of the file(s) we're looking for.
uint32_t reserved
These days not used.
int32_t ttl
Relative time to live in MILLISECONDS (network byte order)
uint32_t hash_bitmap
Which of the optional hash codes are present at the end of the message? See GET_MESSAGE_BIT_xx consta...

References GNUNET_TIME_Absolute::abs_value_us, GSF_PendingRequest::bg, env, GET_MESSAGE_BIT_RETURN_TO, GET_MESSAGE_BIT_TRANSMIT_TO, GNUNET_BLOCK_group_serialize(), GNUNET_break, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_FS_GET, GNUNET_MQ_msg_extra, GNUNET_OK, GNUNET_PEER_resolve(), GNUNET_TIME_absolute_get(), GNUNET_YES, GSF_PRO_FORWARD_ONLY, GetMessage::hash_bitmap, GSF_PendingRequestData::num_transmissions, GSF_PendingRequestData::options, GetMessage::priority, GSF_PendingRequestData::priority, GSF_PendingRequest::public_data, GetMessage::query, GSF_PendingRequestData::query, GetMessage::reserved, GSF_PendingRequestData::respect_offered, GSF_PendingRequest::sender_pid, GSF_PendingRequestData::target, GetMessage::ttl, GSF_PendingRequestData::ttl, ttl, GetMessage::type, and GSF_PendingRequestData::type.

Referenced by schedule_peer_transmission().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GSF_pending_request_cancel_()

void GSF_pending_request_cancel_ ( struct GSF_PendingRequest pr,
int  full_cleanup 

Explicitly cancel a pending request.

prrequest to cancel
full_cleanupfully purge the request

Definition at line 641 of file gnunet-service-fs_pr.c.

642 {
645  if (NULL == pr_map)
646  return; /* already cleaned up! */
647  if (GNUNET_NO == full_cleanup)
648  {
649  /* make request inactive (we're no longer interested in more results),
650  * but do NOT remove from our data-structures, we still need it there
651  * to prevent the request from looping */
652  pr->rh = NULL;
653  if (NULL != pr->cadet_request)
654  {
657  pr->cadet_request = NULL;
658  }
659  if (NULL != (cont = pr->llc_cont))
660  {
661  pr->llc_cont = NULL;
662  cont (pr->llc_cont_cls,
663  pr,
664  pr->local_result);
665  }
667  if (NULL != pr->qe)
668  {
670  pr->qe = NULL;
671  }
672  if (NULL != pr->gh)
673  {
674  GNUNET_DHT_get_stop (pr->gh);
675  pr->gh = NULL;
676  }
677  if (NULL != pr->warn_task)
678  {
680  pr->warn_task = NULL;
681  }
682  return;
683  }
685  clean_request (NULL, &pr->public_data.query, pr));
686 }
void GSF_cadet_query_cancel(struct GSF_CadetRequest *sr)
Cancel an active request; must not be called after 'proc' was called.
void GSF_plan_notify_request_done_(struct GSF_PendingRequest *pr)
Notify the plan about a request being done; destroy all entries associated with this request.
If obtaining a block via cadet fails, how often do we retry it before giving up for good (and stickin...
static int clean_request(void *cls, const struct GNUNET_HashCode *key, void *value)
Iterator to free pending requests.
void(* GSF_LocalLookupContinuation)(void *cls, struct GSF_PendingRequest *pr, enum GNUNET_BLOCK_ReplyEvaluationResult result)
Function to be called after we're done processing replies from the local lookup.
void GNUNET_DATASTORE_cancel(struct GNUNET_DATASTORE_QueueEntry *qe)
Cancel a datastore operation.
void GNUNET_DHT_get_stop(struct GNUNET_DHT_GetHandle *get_handle)
Stop async DHT-get.
Definition: dht_api.c:1237
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:975
enum GNUNET_BLOCK_ReplyEvaluationResult local_result
Last result from the local datastore lookup evaluation.
struct GNUNET_DATASTORE_QueueEntry * qe
Datastore queue entry for this request (or NULL for none).
void * llc_cont_cls
Closure for llc_cont.
unsigned int cadet_retry_count
How often have we retried this request via 'cadet'? (used to bound overall retries).
struct GSF_CadetRequest * cadet_request
Cadet request handle for this request (or NULL for none).
GSF_LocalLookupContinuation llc_cont
Function to call upon completion of the local get request, or NULL for none.
struct GNUNET_SCHEDULER_Task * warn_task
Task that warns us if the local datastore lookup takes too long.

References GSF_PendingRequest::cadet_request, GSF_PendingRequest::cadet_retry_count, CADET_RETRY_MAX, clean_request(), GSF_PendingRequest::gh, GNUNET_assert, GNUNET_DATASTORE_cancel(), GNUNET_DHT_get_stop(), GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_YES, GSF_cadet_query_cancel(), GSF_plan_notify_request_done_(), GSF_PendingRequest::llc_cont, GSF_PendingRequest::llc_cont_cls, GSF_PendingRequest::local_result, pr_map, GSF_PendingRequest::public_data, GSF_PendingRequest::qe, GSF_PendingRequestData::query, GSF_PendingRequest::rh, and GSF_PendingRequest::warn_task.

Referenced by cancel_pending_request(), client_request_destroy(), GSF_pending_request_create_(), and test_exist_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GSF_iterate_pending_requests_()

void GSF_iterate_pending_requests_ ( GSF_PendingRequestIterator  it,
void *  cls 

Iterate over all pending requests.

itfunction to call for each request
clsclosure for it

Definition at line 690 of file gnunet-service-fs_pr.c.

691 {
693  pr_map,
695  cls);
696 }
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MultiHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
enum GNUNET_GenericReturnValue(* GNUNET_CONTAINER_MultiHashMapIteratorCallback)(void *cls, const struct GNUNET_HashCode *key, void *value)
Iterator over hash map entries.

References GNUNET_CONTAINER_multihashmap_iterate(), and pr_map.

Referenced by GSF_peer_connect_handler().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ handle_p2p_put()

void handle_p2p_put ( void *  cls,
const struct PutMessage put 

Handle P2P "CONTENT" message.

Checks that the message is well-formed and then checks if there are any pending requests for this content and possibly passes it on (to local clients or other peers). Does NOT perform migration (content caching at this peer).

clsthe other peer involved (sender)
putthe actual message

Checks that the message is well-formed and then checks if there are any pending requests for this content and possibly passes it on (to local clients or other peers). Does NOT perform migration (content caching at this peer).

clsthe other peer involved
putthe actual message

Definition at line 1698 of file gnunet-service-fs_pr.c.

1700 {
1701  struct GSF_ConnectedPeer *cp = cls;
1702  uint16_t msize;
1703  size_t dsize;
1704  enum GNUNET_BLOCK_Type type;
1706  struct GNUNET_HashCode query;
1707  struct ProcessReplyClosure prq;
1708  struct GNUNET_TIME_Relative block_time;
1709  double putl;
1710  struct PutMigrationContext *pmc;
1713  "Received P2P PUT from %s\n",
1716  msize = ntohs (put->header.size);
1717  dsize = msize - sizeof(struct PutMessage);
1718  type = ntohl (put->type);
1720  /* do not allow migrated content to live longer than 1 year */
1723  expiration);
1724  if (GNUNET_OK !=
1726  type,
1727  &put[1],
1728  dsize))
1729  {
1730  GNUNET_break_op (0);
1731  return;
1732  }
1733  if (GNUNET_OK !=
1735  type,
1736  &put[1],
1737  dsize,
1738  &query))
1739  {
1740  GNUNET_break_op (0);
1741  return;
1742  }
1744  gettext_noop ("# GAP PUT messages received"),
1745  1,
1746  GNUNET_NO);
1747  /* now, lookup 'query' */
1748 = (const void *) &put[1];
1749  prq.sender = cp;
1750  prq.size = dsize;
1751  prq.type = type;
1752  prq.expiration = expiration;
1753  prq.priority = 0;
1754  prq.anonymity_level = UINT32_MAX;
1755  prq.request_found = GNUNET_NO;
1757  &query,
1758  &process_reply,
1759  &prq);
1760  if (NULL != cp)
1761  {
1764  + 1000 * prq.priority);
1765  GSF_get_peer_performance_data_ (cp)->respect += prq.priority;
1766  }
1767  if ((GNUNET_YES == active_to_migration) && (NULL != cp) &&
1768  (GNUNET_NO == test_put_load_too_high (prq.priority)))
1769  {
1771  "Replicating result for query `%s' with priority %u\n",
1772  GNUNET_h2s (&query),
1773  prq.priority);
1774  pmc = GNUNET_new (struct PutMigrationContext);
1775  pmc->start = GNUNET_TIME_absolute_get ();
1776  pmc->requested = prq.request_found;
1779  &pmc->origin);
1780  if (NULL == GNUNET_DATASTORE_put (GSF_dsh,
1781  0,
1782  &query,
1783  dsize,
1784  &put[1],
1785  type,
1786  prq.priority,
1787  1 /* anonymity */,
1788  0 /* replication */,
1789  expiration,
1790  1 + prq.priority,
1793  pmc))
1794  {
1798  NULL);
1799  }
1800  }
1801  else if (NULL != cp)
1802  {
1804  "Choosing not to keep content `%s' (%d/%d)\n",
1805  GNUNET_h2s (&query),
1807  test_put_load_too_high (prq.priority));
1808  }
1810  if ((NULL != cp) && (GNUNET_NO == prq.request_found) &&
1812  (putl > 2.5 * (1 + prq.priority))))
1813  {
1816  block_time = GNUNET_TIME_relative_multiply (
1819  (unsigned int) (60000 * putl * putl)));
1820  GNUNET_log (
1822  "Asking to stop migration for %s because of load %f and events %d/%d\n",
1824  putl,
1826  (GNUNET_NO == prq.request_found));
1828  GNUNET_TIME_relative_to_absolute (block_time));
1829  }
1830 }
WARNING: This header is generated! In order to add DHT block types, you must register them in GANA,...
static char * expiration
Credential TTL.
Definition: gnunet-abd.c:96
unsigned int GSF_cover_content_count
How many content messages have we received 'recently' that have not yet been claimed as cover traffic...
struct GNUNET_DATASTORE_Handle * GSF_dsh
Our connection to the datastore.
void GSF_block_peer_migration_(struct GSF_ConnectedPeer *cp, struct GNUNET_TIME_Absolute block_time)
Ask a peer to stop migrating data to us until the given point in time.
void GSF_connected_peer_change_preference_(struct GSF_ConnectedPeer *cp, uint64_t pref)
Notify core about a preference we have for the given peer (to allocate more resources towards it).
struct GSF_PeerPerformanceData * GSF_get_peer_performance_data_(struct GSF_ConnectedPeer *cp)
Return the performance data record for the given peer.
static void put_migration_continuation(void *cls, int success, struct GNUNET_TIME_Absolute min_expiration, const char *msg)
Continuation called to notify client about result of the operation.
Maximum size of the datastore queue for P2P operations.
static int active_to_migration
Are we allowed to migrate content to this peer.
Bandwidth value of a 0-priority content (must be fairly high compared to query since content is typic...
static int test_put_load_too_high(uint32_t priority)
Test if the DATABASE (PUT) load on this peer is too high to even consider processing the query at all...
static enum GNUNET_GenericReturnValue process_reply(void *cls, const struct GNUNET_HashCode *key, void *value)
We have received a reply; handle it!
static struct GNUNET_LOAD_Value * datastore_put_load
Datastore 'PUT' load tracking.
static struct GNUNET_PeerIdentity pid
Identity of the peer we transmit to / connect to.
enum GNUNET_GenericReturnValue GNUNET_BLOCK_check_block(struct GNUNET_BLOCK_Context *ctx, enum GNUNET_BLOCK_Type type, const void *block, size_t block_size)
Function called to validate a block.
Definition: block.c:319
enum GNUNET_GenericReturnValue GNUNET_BLOCK_get_key(struct GNUNET_BLOCK_Context *ctx, enum GNUNET_BLOCK_Type type, const void *block, size_t block_size, struct GNUNET_HashCode *key)
Function called to obtain the key for a block.
Definition: block.c:276
struct GNUNET_DATASTORE_QueueEntry * GNUNET_DATASTORE_put(struct GNUNET_DATASTORE_Handle *h, uint32_t rid, const struct GNUNET_HashCode *key, size_t size, const void *data, enum GNUNET_BLOCK_Type type, uint32_t priority, uint32_t anonymity, uint32_t replication, struct GNUNET_TIME_Absolute expiration, unsigned int queue_priority, unsigned int max_queue_size, GNUNET_DATASTORE_ContinuationWithStatus cont, void *cont_cls)
Store an item in the datastore.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_get_multiple(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, GNUNET_CONTAINER_MultiHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map that match a particular key.
double GNUNET_LOAD_get_load(struct GNUNET_LOAD_Value *load)
Get the current load.
Definition: load.c:201
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_new(type)
Allocate a struct or union of the given type.
One millisecond.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:737
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_min(struct GNUNET_TIME_Absolute t1, struct GNUNET_TIME_Absolute t2)
Return the minimum of two absolute time values.
Definition: time.c:359
Absolute time zero.
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:569
One year (365 days).
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
Time for relative time used by GNUnet, in microseconds.
A connected peer.
uint32_t respect
Respect rating for this peer.
Closure for process_reply() function.
Response from FS service with a result for a previous FS search.
Definition: fs.h:330
struct GNUNET_MessageHeader header
Message type will be GNUNET_MESSAGE_TYPE_FS_PUT.
Definition: fs.h:334
uint32_t type
Type of the block (in big endian).
Definition: fs.h:339
struct GNUNET_TIME_AbsoluteNBO expiration
When does this result expire?
Definition: fs.h:344
Context for put_migration_continuation().
struct GNUNET_PeerIdentity origin
Request origin.
struct GNUNET_TIME_Absolute start
Start time for the operation.
int requested
GNUNET_YES if we had a matching request for this block, GNUNET_NO if not.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.

References active_to_migration, ProcessReplyClosure::anonymity_level, CONTENT_BANDWIDTH_VALUE, ProcessReplyClosure::data, datastore_put_load, expiration, PutMessage::expiration, ProcessReplyClosure::expiration, gettext_noop, GNUNET_assert, GNUNET_BLOCK_check_block(), GNUNET_BLOCK_get_key(), GNUNET_break_op, GNUNET_CONTAINER_multihashmap_get_multiple(), GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_DATASTORE_put(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_i2s(), GNUNET_LOAD_get_load(), GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_PEER_resolve(), GNUNET_STATISTICS_update(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_SYSERR, GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_min(), GNUNET_TIME_absolute_ntoh(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_MILLISECONDS, GNUNET_TIME_UNIT_YEARS, GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_YES, GSF_block_ctx, GSF_block_peer_migration_(), GSF_connected_peer_change_preference_(), GSF_cover_content_count, GSF_dsh, GSF_get_peer_performance_data_(), GSF_stats, PutMessage::header, MAX_DATASTORE_QUEUE, PutMigrationContext::origin, peer, pid, pr_map, ProcessReplyClosure::priority, process_reply(), put_migration_continuation(), ProcessReplyClosure::request_found, PutMigrationContext::requested, GSF_PeerPerformanceData::respect, ProcessReplyClosure::sender, ProcessReplyClosure::size, GNUNET_MessageHeader::size, PutMigrationContext::start, test_put_load_too_high(), PutMessage::type, ProcessReplyClosure::type, and type.

Here is the call graph for this function:

◆ GSF_dht_lookup_()

void GSF_dht_lookup_ ( struct GSF_PendingRequest pr)

Consider looking up the data in the DHT (anonymity-level permitting).

prthe pending request to process

Definition at line 1128 of file gnunet-service-fs_pr.c.

1129 {
1130  const void *xquery;
1131  size_t xquery_size;
1132  struct GNUNET_PeerIdentity pi;
1133  char buf[sizeof(struct GNUNET_HashCode) * 2] GNUNET_ALIGN;
1135  if (0 != pr->public_data.anonymity_level)
1136  return;
1137  if (NULL != pr->gh)
1138  {
1139  GNUNET_DHT_get_stop (pr->gh);
1140  pr->gh = NULL;
1141  }
1142  xquery = NULL;
1143  xquery_size = 0;
1144  if (0 != (pr->public_data.options & GSF_PRO_FORWARD_ONLY))
1145  {
1146  GNUNET_assert (0 != pr->sender_pid);
1148  GNUNET_memcpy (&buf[xquery_size], &pi, sizeof(struct GNUNET_PeerIdentity));
1149  xquery_size += sizeof(struct GNUNET_PeerIdentity);
1150  }
1152  pr->public_data.type,
1153  &pr->public_data.query,
1156  xquery,
1157  xquery_size,
1159  pr);
1160  if ((NULL != pr->gh) && (0 != pr->replies_seen_count))
1162  pr->replies_seen_count,
1163  pr->replies_seen);
1164 }
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
struct GNUNET_DHT_Handle * GSF_dht
Handle for DHT operations.
static void handle_dht_reply(void *cls, struct GNUNET_TIME_Absolute exp, const struct GNUNET_HashCode *key, const struct GNUNET_PeerIdentity *trunc_peer, const struct GNUNET_DHT_PathElement *get_path, unsigned int get_path_length, const struct GNUNET_DHT_PathElement *put_path, unsigned int put_path_length, enum GNUNET_BLOCK_Type type, size_t size, const void *data)
Iterator called on each result obtained for a DHT operation that expects a reply.
Desired replication level for GETs.
static char buf[2048]
struct GNUNET_DHT_GetHandle * GNUNET_DHT_get_start(struct GNUNET_DHT_Handle *handle, enum GNUNET_BLOCK_Type type, const struct GNUNET_HashCode *key, uint32_t desired_replication_level, enum GNUNET_DHT_RouteOption options, const void *xquery, size_t xquery_size, GNUNET_DHT_GetIterator iter, void *iter_cls)
Perform an asynchronous GET operation on the DHT identified.
Definition: dht_api.c:1164
Each peer along the way should process the request (otherwise only peers locally closest to the key w...
gcc-ism to force alignment; we use this to align char-arrays that may then be cast to 'struct's.

References GSF_PendingRequestData::anonymity_level, buf, DHT_GET_REPLICATION, GSF_PendingRequest::gh, GNUNET_ALIGN, GNUNET_assert, GNUNET_DHT_get_filter_known_results(), GNUNET_DHT_get_start(), GNUNET_DHT_get_stop(), GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, GNUNET_memcpy, GNUNET_PEER_resolve(), GSF_dht, GSF_PRO_FORWARD_ONLY, handle_dht_reply(), GSF_PendingRequestData::options, pi, GSF_PendingRequest::public_data, GSF_PendingRequestData::query, GSF_PendingRequest::replies_seen, GSF_PendingRequest::replies_seen_count, GSF_PendingRequest::sender_pid, and GSF_PendingRequestData::type.

Referenced by start_p2p_processing().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GSF_cadet_lookup_()

void GSF_cadet_lookup_ ( struct GSF_PendingRequest pr)

Consider downloading via cadet (if possible)

prthe pending request to process

Definition at line 1252 of file gnunet-service-fs_pr.c.

1253 {
1254  if (0 != pr->public_data.anonymity_level)
1255  return;
1256  if (0 == pr->
1257  {
1259  "Cannot do cadet-based download, target peer not known\n");
1260  return;
1261  }
1262  if (NULL != pr->cadet_request)
1263  return;
1265  &pr->public_data.query,
1266  pr->public_data.type,
1268  pr);
1269 }
struct GSF_CadetRequest * GSF_cadet_query(const struct GNUNET_PeerIdentity *target, const struct GNUNET_HashCode *query, enum GNUNET_BLOCK_Type type, GSF_CadetReplyProcessor proc, void *proc_cls)
Look for a block by directly contacting a particular peer.
static void cadet_reply_proc(void *cls, enum GNUNET_BLOCK_Type type, struct GNUNET_TIME_Absolute expiration, size_t data_size, const void *data)
Function called with a reply from the cadet.

References GSF_PendingRequestData::anonymity_level, cadet_reply_proc(), GSF_PendingRequest::cadet_request, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GSF_cadet_query(), GSF_PendingRequest::public_data, GSF_PendingRequestData::query, GSF_PendingRequestData::target, and GSF_PendingRequestData::type.

Referenced by start_p2p_processing().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GSF_local_lookup_()

void GSF_local_lookup_ ( struct GSF_PendingRequest pr,
GSF_LocalLookupContinuation  cont,
void *  cont_cls 

Look up the request in the local datastore.

prthe pending request to process
contfunction to call at the end
cont_clsclosure for cont

Definition at line 1669 of file gnunet-service-fs_pr.c.

1672 {
1673  GNUNET_assert (NULL == pr->gh);
1674  GNUNET_assert (NULL == pr->cadet_request);
1675  GNUNET_assert (NULL == pr->llc_cont);
1676  pr->llc_cont = cont;
1677  pr->llc_cont_cls = cont_cls;
1680  gettext_noop ("# Datastore lookups initiated"),
1681  1,
1682  GNUNET_NO);
1683 #endif
1684  start_local_query (pr, 0 /* next_uid */, true /* random */);
1685 }
static void start_local_query(struct GSF_PendingRequest *pr, uint64_t next_uid, bool random)

References GSF_PendingRequest::cadet_request, gettext_noop, GSF_PendingRequest::gh, GNUNET_assert, GNUNET_NO, GNUNET_STATISTICS_update(), GSF_stats, GSF_PendingRequest::llc_cont, GSF_PendingRequest::llc_cont_cls, and start_local_query().

Referenced by handle_client_start_search(), and handle_p2p_get().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GSF_pending_request_test_target_()

int GSF_pending_request_test_target_ ( struct GSF_PendingRequest pr,
const struct GNUNET_PeerIdentity target 

Is the given target a legitimate peer for forwarding the given request?

GNUNET_YES if this request could be forwarded to the given peer

Definition at line 1647 of file gnunet-service-fs_pr.c.

1649 {
1650  struct GNUNET_PeerIdentity pi;
1652  if (0 == pr->origin_pid)
1653  return GNUNET_YES;
1655  return (0 == memcmp (&pi, target, sizeof(struct GNUNET_PeerIdentity)))
1656  ? GNUNET_NO
1657  : GNUNET_YES;
1658 }

References GNUNET_NO, GNUNET_PEER_resolve(), GNUNET_YES, GSF_PendingRequest::origin_pid, and pi.

Referenced by consider_peer_for_forwarding(), and consider_request_for_forwarding().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GSF_pending_request_init_()

void GSF_pending_request_init_ ( void  )

Setup the subsystem.

Definition at line 1850 of file gnunet-service-fs_pr.c.

1851 {
1852  if (GNUNET_OK !=
1854  "fs",
1857  {
1859  "fs",
1861  }
1863  GNUNET_CONFIGURATION_get_value_yesno (GSF_cfg, "FS", "CONTENT_CACHING");
1868 }
const struct GNUNET_CONFIGURATION_Handle * GSF_cfg
Our configuration.
At what frequency should our datastore load decrease automatically (since if we don't use it,...
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_number(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *number)
Get a configuration value that should be a number.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_yesno(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option)
Get a configuration value that should be in a set of "YES" or "NO".
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
struct GNUNET_CONTAINER_Heap * GNUNET_CONTAINER_heap_create(enum GNUNET_CONTAINER_HeapOrder order)
Create a new heap.
Heap with the minimum cost at the root.
struct GNUNET_LOAD_Value * GNUNET_LOAD_value_init(struct GNUNET_TIME_Relative autodecline)
Create a new load value.
Definition: load.c:125
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.

References active_to_migration, DATASTORE_LOAD_AUTODECLINE, datastore_put_load, GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_CONTAINER_heap_create(), GNUNET_CONTAINER_HEAP_ORDER_MIN, GNUNET_CONTAINER_multihashmap_create(), GNUNET_ERROR_TYPE_INFO, GNUNET_LOAD_value_init(), GNUNET_log_config_missing(), GNUNET_OK, GNUNET_YES, GSF_cfg, max_pending_requests, pr_map, and requests_by_expiration_heap.

Referenced by run().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GSF_pending_request_done_()

void GSF_pending_request_done_ ( void  )

Shutdown the subsystem.

Definition at line 1875 of file gnunet-service-fs_pr.c.

1876 {
1879  pr_map = NULL;
1883  datastore_put_load = NULL;
1884 }
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
void GNUNET_CONTAINER_heap_destroy(struct GNUNET_CONTAINER_Heap *heap)
Destroys the heap.
#define GNUNET_LOAD_value_free(lv)
Free a load value.

Referenced by shutdown_task().

Here is the caller graph for this function: