GNUnet  0.11.x
Data Structures | Typedefs | Enumerations | Functions
gnunet-service-fs_pr.h File Reference

API to handle pending requests. More...

#include "gnunet-service-fs.h"
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...
 

Typedefs

typedef void(* GSF_PendingRequestReplyHandler) (void *cls, enum GNUNET_BLOCK_EvaluationResult 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_EvaluationResult result)
 Function to be called after we're done processing replies from the local lookup. More...
 

Enumerations

enum  GSF_PendingRequestOptions {
  GSF_PRO_DEFAULTS = 0, GSF_PRO_LOCAL_ONLY = 1, GSF_PRO_FORWARD_ONLY = 2, GSF_PRO_REQUEST_NEVER_EXPIRES = 4,
  GSF_PRO_BLOOMFILTER_FULL_REFRESH = 8, GSF_PRO_PRIORITY_UNLIMITED = 16, GSF_PRO_LOCAL_REQUEST
}
 Options for pending requests (bits to be ORed). More...
 

Functions

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 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)
 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.

Author
Christian Grothoff

Definition in file gnunet-service-fs_pr.h.

Typedef Documentation

◆ GSF_PendingRequestReplyHandler

typedef void(* GSF_PendingRequestReplyHandler) (void *cls, enum GNUNET_BLOCK_EvaluationResult 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.

Parameters
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 187 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).

Parameters
clsclosure
keyquery for the request
prhandle to the pending request
Returns
GNUNET_YES to continue to iterate

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

◆ GSF_LocalLookupContinuation

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

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

Parameters
clsclosure
prthe pending request we were processing
resultfinal datastore lookup result

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

Enumeration Type Documentation

◆ GSF_PendingRequestOptions

Options for pending requests (bits to be ORed).

Enumerator
GSF_PRO_DEFAULTS 

No special options (P2P-default).

GSF_PRO_LOCAL_ONLY 

Request must only be processed locally.

GSF_PRO_FORWARD_ONLY 

Request must only be forwarded (no routing)

GSF_PRO_REQUEST_NEVER_EXPIRES 

Request persists indefinitely (no expiration).

GSF_PRO_BLOOMFILTER_FULL_REFRESH 

Request is allowed to refresh bloomfilter and change mingle value.

GSF_PRO_PRIORITY_UNLIMITED 

Request priority is allowed to be exceeded.

GSF_PRO_LOCAL_REQUEST 

Option mask for typical local requests.

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

36 {
40  GSF_PRO_DEFAULTS = 0,
41 
46 
51 
56 
61 
66 
73 };
Request is allowed to refresh bloomfilter and change mingle value.
No special options (P2P-default).
Request priority is allowed to be exceeded.
Request persists indefinitely (no expiration).
Request must only be processed locally.
Option mask for typical local requests.
Request must only be forwarded (no routing)

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  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 
)

Create a new pending request.

Parameters
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
minglemingle value for bf
anonymity_leveldesired anonymity level
prioritymaximum outgoing cummulative 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
Returns
handle for the new pending request
Parameters
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
minglemingle value for bf
anonymity_leveldesired anonymity level
prioritymaximum outgoing cummulative request priority to use
ttlcurrent time-to-live for the request
sender_pidpeer ID to use for the sender when forwarding, 0 for none
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
Returns
handle for the new pending request

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

References GNUNET_TIME_Absolute::abs_value_us, anonymity_level, GSF_PendingRequestData::anonymity_level, GSF_PendingRequest::bg, gettext_noop, GNUNET_assert, GNUNET_BLOCK_EVALUATION_REQUEST_VALID, GNUNET_BLOCK_group_create(), 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, 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, GSF_PendingRequest::rh, GSF_PendingRequest::rh_cls, GSF_PendingRequest::sender_pid, GSF_PendingRequestData::start_time, GSF_PendingRequestData::target, GSF_PendingRequestData::ttl, type, and GSF_PendingRequestData::type.

Referenced by handle_client_start_search(), and handle_p2p_get().

317 {
318  struct GSF_PendingRequest *pr;
319  struct GSF_PendingRequest *dpr;
320  size_t extra;
321  struct GNUNET_HashCode *eptr;
322 
324  "Creating request handle for `%s' of type %d\n",
325  GNUNET_h2s (query),
326  type);
327 #if INSANE_STATISTICS
329  gettext_noop ("# Pending requests created"),
330  1,
331  GNUNET_NO);
332 #endif
333  extra = 0;
334  if (NULL != target)
335  extra += sizeof(struct GNUNET_PeerIdentity);
336  pr = GNUNET_malloc (sizeof(struct GSF_PendingRequest) + extra);
337  pr->public_data.query = *query;
338  eptr = (struct GNUNET_HashCode *) &pr[1];
339  if (NULL != target)
340  {
341  pr->public_data.target = (struct GNUNET_PeerIdentity *) eptr;
342  GNUNET_memcpy (eptr, target, sizeof(struct GNUNET_PeerIdentity));
343  }
345  pr->public_data.priority = priority;
346  pr->public_data.original_priority = priority;
348  pr->public_data.type = type;
350  pr->sender_pid = sender_pid;
351  pr->origin_pid = origin_pid;
352  pr->rh = rh;
353  pr->rh_cls = rh_cls;
354  GNUNET_assert ((sender_pid != 0) || (0 == (options & GSF_PRO_FORWARD_ONLY)));
355  if (ttl >= 0)
358  else
362  (uint32_t) (-ttl)));
363  if (replies_seen_count > 0)
364  {
365  pr->replies_seen_size = replies_seen_count;
366  pr->replies_seen =
369  replies_seen,
370  replies_seen_count * sizeof(struct GNUNET_HashCode));
371  pr->replies_seen_count = replies_seen_count;
372  }
373  if ((NULL != bf_data) &&
375  {
377  pr->public_data.type,
378  mingle,
379  bf_data,
380  bf_size,
381  "seen-set-size",
382  0,
383  NULL);
384  }
385  else if ((replies_seen_count > 0) &&
387  {
389  }
391  &pr->public_data.query,
392  pr,
395  {
397  pr,
399  /* make sure we don't track too many requests */
402  {
404  GNUNET_assert (NULL != dpr);
405  if (pr == dpr)
406  break; /* let the request live briefly... */
407  if (NULL != dpr->rh)
408  dpr->rh (dpr->rh_cls,
410  dpr,
411  UINT32_MAX,
415  NULL,
416  0);
418  }
419  }
421  gettext_noop ("# Pending requests active"),
422  1,
423  GNUNET_NO);
424  return pr;
425 }
const struct GNUNET_PeerIdentity * target
Identity of a peer hosting the content, otherwise NULl.
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:422
Request is allowed to refresh bloomfilter and change mingle value.
Any type of block, used as a wildcard when searching.
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.
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
struct GNUNET_TIME_Absolute ttl
Current TTL for the request.
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:246
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_TIME_UNIT_SECONDS
One second.
uint32_t anonymity_level
Desired anonymity level.
static struct GNUNET_CONTAINER_Heap * requests_by_expiration_heap
Heap with the request that will expire next at the top.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
static struct GNUNET_CONTAINER_MultiHashMap * pr_map
All pending requests, ordered by the query.
struct GSF_PendingRequestData public_data
Public data for the request.
struct GNUNET_STATISTICS_Handle * GSF_stats
Handle for reporting statistics.
#define GNUNET_NO
Definition: gnunet_common.h:78
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
struct GNUNET_TIME_Absolute start_time
When did we start with the request.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
static void refresh_bloomfilter(enum GNUNET_BLOCK_Type type, struct GSF_PendingRequest *pr)
Recalculate our bloom filter for filtering replies.
uint64_t abs_value_us
The actual value.
static unsigned int anonymity_level
Anonymity level option to use for publishing.
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
struct GNUNET_HashCode query
Primary query hash for this request.
unsigned int replies_seen_count
Number of valid entries in the 'replies_seen' array.
Request persists indefinitely (no expiration).
GNUNET_PEER_Id origin_pid
Identity of the peer that we should never forward this query to since it originated this query (0 for...
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...
struct GNUNET_BLOCK_Context * GSF_block_ctx
Our block context.
void * GNUNET_CONTAINER_heap_peek(const struct GNUNET_CONTAINER_Heap *heap)
Get element stored at the root of heap.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
void * rh_cls
Closure for rh.
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:442
enum GNUNET_BLOCK_Type type
Type of the requested block.
Type of a block representing any type of search result (universal).
A 512-bit hashcode.
GSF_PendingRequestReplyHandler rh
Function to call if we encounter a reply.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
unsigned int GNUNET_CONTAINER_heap_get_size(const struct GNUNET_CONTAINER_Heap *heap)
Get the current size of the heap.
uint32_t original_priority
Priority that this request (originally) had for us.
int 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.
struct GNUNET_BLOCK_Group * GNUNET_BLOCK_group_create(struct GNUNET_BLOCK_Context *ctx, enum GNUNET_BLOCK_Type type, uint32_t nonce, const void *raw_data, size_t raw_data_size,...)
Create a new block group.
Definition: block.c:289
Allow multiple values with the same key.
unsigned int replies_seen_size
Length of the 'replies_seen' array.
The identity of the host (wraps the signing key of the peer).
enum GSF_PendingRequestOptions options
Options for the request.
Request must only be forwarded (no routing)
struct GNUNET_BLOCK_Group * bg
Block group for filtering replies we've already seen.
#define GNUNET_log(kind,...)
struct GNUNET_CONTAINER_HeapNode * hnode
Entry for this pending request in the expiration heap, or NULL.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
#define GNUNET_YES
Definition: gnunet_common.h:77
uint32_t priority
Priority that this request (still) has for us.
An active request.
void GSF_pending_request_cancel_(struct GSF_PendingRequest *pr, int full_cleanup)
Explicitly cancel a pending request.
Query is valid, no reply given.
GNUNET_PEER_Id sender_pid
Identity of the peer that we should use for the 'sender' (recipient of the response) when forwarding ...
#define GNUNET_malloc(size)
Wrapper around malloc.
struct GNUNET_HashCode * replies_seen
Array of hash codes of replies we've already seen.
#define gettext_noop(String)
Definition: gettext.h:69
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.

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

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

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(), and process_reply().

475 {
476  if (replies_seen_count + pr->replies_seen_count < pr->replies_seen_count)
477  return; /* integer overflow */
479  {
480  /* we're responsible for the BF, full refresh */
481  if (replies_seen_count + pr->replies_seen_count > pr->replies_seen_size)
483  pr->replies_seen_size,
484  replies_seen_count + pr->replies_seen_count);
486  replies_seen,
487  sizeof(struct GNUNET_HashCode) * replies_seen_count);
488  pr->replies_seen_count += replies_seen_count;
490  }
491  else
492  {
493  if (NULL == pr->bg)
494  {
495  /* we're not the initiator, but the initiator did not give us
496  * any bloom-filter, so we need to create one on-the-fly */
498  }
499  else
500  {
503  replies_seen,
504  pr->replies_seen_count));
505  }
506  }
507  if (NULL != pr->gh)
509  replies_seen_count,
510  replies_seen);
511 }
Request is allowed to refresh bloomfilter and change mingle value.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
struct GSF_PendingRequestData public_data
Public data for the request.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static void refresh_bloomfilter(enum GNUNET_BLOCK_Type type, struct GSF_PendingRequest *pr)
Recalculate our bloom filter for filtering replies.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
unsigned int replies_seen_count
Number of valid entries in the &#39;replies_seen&#39; array.
#define GNUNET_array_grow(arr, size, tsize)
Grow a well-typed (!) array.
enum GNUNET_BLOCK_Type type
Type of the requested block.
A 512-bit hashcode.
struct GNUNET_DHT_GetHandle * gh
DHT request handle for this request (or NULL for none).
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:1126
unsigned int replies_seen_size
Length of the &#39;replies_seen&#39; array.
enum GSF_PendingRequestOptions options
Options for the request.
struct GNUNET_BLOCK_Group * bg
Block group for filtering replies we&#39;ve already seen.
struct GNUNET_HashCode * replies_seen
Array of hash codes of replies we&#39;ve already seen.
int 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:409
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.

Parameters
prpending request
Returns
associated public data

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

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().

436 {
437  return &pr->public_data;
438 }
struct GSF_PendingRequestData public_data
Public data for the request.
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.

Parameters
prpending request
Returns
GNUNET_YES if the request is still active

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

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().

1854 {
1855  return (NULL != pr->rh) ? GNUNET_YES : GNUNET_NO;
1856 }
#define GNUNET_NO
Definition: gnunet_common.h:78
GSF_PendingRequestReplyHandler rh
Function to call if we encounter a reply.
#define GNUNET_YES
Definition: gnunet_common.h:77
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).

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

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

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

Referenced by merge_pr().

453 {
454  if ((pra->public_data.type != prb->public_data.type) ||
455  (0 != memcmp (&pra->public_data.query,
456  &prb->public_data.query,
457  sizeof(struct GNUNET_HashCode))))
458  return GNUNET_NO;
459  return GNUNET_OK;
460 }
struct GSF_PendingRequestData public_data
Public data for the request.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_HashCode query
Primary query hash for this request.
enum GNUNET_BLOCK_Type type
Type of the requested block.
A 512-bit hashcode.
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.

Parameters
prrequest to generate the message for
Returns
envelope with the request message

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

References GNUNET_TIME_Absolute::abs_value_us, GSF_PendingRequest::bg, env, GetMessage::filter_mutator, 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_non_null, 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, GSF_PendingRequestData::respect_offered, GSF_PendingRequest::sender_pid, GSF_PendingRequestData::target, GSF_PendingRequestData::ttl, GetMessage::ttl, GSF_PendingRequestData::type, and GetMessage::type.

Referenced by schedule_peer_transmission().

523 {
524  struct GNUNET_MQ_Envelope *env;
525  struct GetMessage *gm;
526  struct GNUNET_PeerIdentity *ext;
527  unsigned int k;
528  uint32_t bm;
529  uint32_t prio;
530  size_t bf_size;
531  struct GNUNET_TIME_Absolute now;
532  int64_t ttl;
533  int do_route;
534  void *bf_data;
535  uint32_t bf_nonce;
536 
538  "Building request message for `%s' of type %d\n",
540  pr->public_data.type);
541  k = 0;
542  bm = 0;
543  do_route = (0 == (pr->public_data.options & GSF_PRO_FORWARD_ONLY));
544  if ((! do_route) && (pr->sender_pid == 0))
545  {
546  GNUNET_break (0);
547  do_route = GNUNET_YES;
548  }
549  if (! do_route)
550  {
552  k++;
553  }
554  if (NULL != pr->public_data.target)
555  {
557  k++;
558  }
559  if (GNUNET_OK !=
560  GNUNET_BLOCK_group_serialize (pr->bg, &bf_nonce, &bf_data, &bf_size))
561  {
562  bf_size = 0;
563  bf_data = NULL;
564  }
565  env = GNUNET_MQ_msg_extra (gm,
566  bf_size + k * sizeof(struct GNUNET_PeerIdentity),
568  gm->type = htonl (pr->public_data.type);
569  if (do_route)
571  pr->public_data.priority + 1);
572  else
573  prio = 0;
574  pr->public_data.priority -= prio;
576  pr->public_data.respect_offered += prio;
577  gm->priority = htonl (prio);
578  now = GNUNET_TIME_absolute_get ();
579  ttl = (int64_t) (pr->public_data.ttl.abs_value_us - now.abs_value_us);
580  gm->ttl = htonl (ttl / 1000LL / 1000LL);
581  gm->filter_mutator = htonl (bf_nonce);
582  gm->hash_bitmap = htonl (bm);
583  gm->query = pr->public_data.query;
584  ext = (struct GNUNET_PeerIdentity *) &gm[1];
585  k = 0;
586  if (! do_route)
587  GNUNET_PEER_resolve (pr->sender_pid, &ext[k++]);
588  if (NULL != pr->public_data.target)
589  ext[k++] = *pr->public_data.target;
590  GNUNET_memcpy (&ext[k], bf_data, bf_size);
591  GNUNET_free_non_null (bf_data);
592  return env;
593 }
const struct GNUNET_PeerIdentity * target
Identity of a peer hosting the content, otherwise NULl.
uint32_t num_transmissions
Counter for how often this request has been transmitted (estimate, because we might have the same req...
#define GET_MESSAGE_BIT_TRANSMIT_TO
The peer identity of a peer that had claimed to have the content previously is included (can be used ...
int32_t ttl
Relative time to live in MILLISECONDS (network byte order)
uint32_t priority
How important is this request (network byte order)
struct GNUNET_TIME_Absolute ttl
Current TTL for the request.
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
struct GSF_PendingRequestData public_data
Public data for the request.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
void GNUNET_PEER_resolve(GNUNET_PEER_Id id, struct GNUNET_PeerIdentity *pid)
Convert an interned PID to a normal peer identity.
Definition: peer.c:225
uint64_t abs_value_us
The actual value.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
uint32_t filter_mutator
The content hash should be mutated using this value before checking against the bloomfilter (used to ...
struct GNUNET_HashCode query
Primary query hash for this request.
#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:52
Message to the datastore service asking about specific content.
Definition: datastore.h:140
uint32_t hash_bitmap
Which of the optional hash codes are present at the end of the message? See GET_MESSAGE_BIT_xx consta...
struct GNUNET_HashCode query
Hashcodes of the file(s) we&#39;re looking for.
#define GET_MESSAGE_BIT_RETURN_TO
The peer identity of a peer waiting for the reply is included (used if the response should be transmi...
uint32_t respect_offered
How much respect did we (in total) offer for this request so far (estimate, because we might have the...
enum GNUNET_BLOCK_Type type
Type of the requested block.
int GNUNET_BLOCK_group_serialize(struct GNUNET_BLOCK_Group *bg, uint32_t *nonce, void **raw_data, size_t *raw_data_size)
Serialize state of a block group.
Definition: block.c:180
uint32_t type
Desired content type.
Definition: datastore.h:150
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
The identity of the host (wraps the signing key of the peer).
enum GSF_PendingRequestOptions options
Options for the request.
Request must only be forwarded (no routing)
struct GNUNET_BLOCK_Group * bg
Block group for filtering replies we&#39;ve already seen.
#define GNUNET_log(kind,...)
Time for absolute times used by GNUnet, in microseconds.
#define GNUNET_YES
Definition: gnunet_common.h:77
uint32_t priority
Priority that this request (still) has for us.
#define GNUNET_MESSAGE_TYPE_FS_GET
P2P request for content (one FS to another).
GNUNET_PEER_Id sender_pid
Identity of the peer that we should use for the &#39;sender&#39; (recipient of the response) when forwarding ...
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
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.

Parameters
prrequest to cancel
full_cleanupfully purge the request

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

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, 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().

672 {
674 
675  if (NULL == pr_map)
676  return; /* already cleaned up! */
677  if (GNUNET_NO == full_cleanup)
678  {
679  /* make request inactive (we're no longer interested in more results),
680  * but do NOT remove from our data-structures, we still need it there
681  * to prevent the request from looping */
682  pr->rh = NULL;
683  if (NULL != pr->cadet_request)
684  {
687  pr->cadet_request = NULL;
688  }
689  if (NULL != (cont = pr->llc_cont))
690  {
691  pr->llc_cont = NULL;
692  cont (pr->llc_cont_cls, pr, pr->local_result);
693  }
695  if (NULL != pr->qe)
696  {
698  pr->qe = NULL;
699  }
700  if (NULL != pr->gh)
701  {
702  GNUNET_DHT_get_stop (pr->gh);
703  pr->gh = NULL;
704  }
705  if (NULL != pr->warn_task)
706  {
708  pr->warn_task = NULL;
709  }
710  return;
711  }
713  clean_request (NULL, &pr->public_data.query, pr));
714 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_SCHEDULER_Task * warn_task
Task that warns us if the local datastore lookup takes too long.
static struct GNUNET_CONTAINER_MultiHashMap * pr_map
All pending requests, ordered by the query.
struct GSF_PendingRequestData public_data
Public data for the request.
#define GNUNET_NO
Definition: gnunet_common.h:78
GSF_LocalLookupContinuation llc_cont
Function to call upon completion of the local get request, or NULL for none.
struct GNUNET_HashCode query
Primary query hash for this request.
void(* GSF_LocalLookupContinuation)(void *cls, struct GSF_PendingRequest *pr, enum GNUNET_BLOCK_EvaluationResult result)
Function to be called after we&#39;re done processing replies from the local lookup.
enum GNUNET_BLOCK_EvaluationResult local_result
Last result from the local datastore lookup evaluation.
void * llc_cont_cls
Closure for llc_cont.
GSF_PendingRequestReplyHandler rh
Function to call if we encounter a reply.
void GNUNET_DHT_get_stop(struct GNUNET_DHT_GetHandle *get_handle)
Stop async DHT-get.
Definition: dht_api.c:1155
struct GNUNET_DHT_GetHandle * gh
DHT request handle for this request (or NULL for none).
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...
#define CADET_RETRY_MAX
If obtaining a block via cadet fails, how often do we retry it before giving up for good (and stickin...
unsigned int cadet_retry_count
How often have we retried this request via &#39;cadet&#39;? (used to bound overall retries).
static int clean_request(void *cls, const struct GNUNET_HashCode *key, void *value)
Iterator to free pending requests.
void GNUNET_DATASTORE_cancel(struct GNUNET_DATASTORE_QueueEntry *qe)
Cancel a datastore operation.
struct GNUNET_DATASTORE_QueueEntry * qe
Datastore queue entry for this request (or NULL for none).
void GSF_cadet_query_cancel(struct GSF_CadetRequest *sr)
Cancel an active request; must not be called after &#39;proc&#39; was calld.
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GSF_CadetRequest * cadet_request
Cadet request handle for this request (or NULL for none).
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
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.

Parameters
itfunction to call for each request
clsclosure for it
itfunction to call for each request
clsclosure for it

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

References GNUNET_CONTAINER_multihashmap_iterate().

Referenced by GSF_peer_connect_handler().

725 {
727  pr_map,
729  cls);
730 }
int(* GNUNET_CONTAINER_MulitHashMapIteratorCallback)(void *cls, const struct GNUNET_HashCode *key, void *value)
Iterator over hash map entries.
static struct GNUNET_CONTAINER_MultiHashMap * pr_map
All pending requests, ordered by the query.
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
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).

Parameters
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).

Parameters
clsthe other peer involved
putthe actual message

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

References active_to_migration, ProcessReplyClosure::anonymity_level, CONTENT_BANDWIDTH_VALUE, ProcessReplyClosure::data, ProcessReplyClosure::eo, expiration, PutMessage::expiration, ProcessReplyClosure::expiration, gettext_noop, GNUNET_assert, GNUNET_BLOCK_EO_NONE, 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, ProcessReplyClosure::priority, process_reply(), put_migration_continuation(), ProcessReplyClosure::request_found, PutMigrationContext::requested, GSF_PeerPerformanceData::respect, ProcessReplyClosure::sender, GNUNET_MessageHeader::size, ProcessReplyClosure::size, PutMigrationContext::start, test_put_load_too_high(), type, PutMessage::type, and ProcessReplyClosure::type.

1725 {
1726  struct GSF_ConnectedPeer *cp = cls;
1727  uint16_t msize;
1728  size_t dsize;
1729  enum GNUNET_BLOCK_Type type;
1731  struct GNUNET_HashCode query;
1732  struct ProcessReplyClosure prq;
1733  struct GNUNET_TIME_Relative block_time;
1734  double putl;
1735  struct PutMigrationContext *pmc;
1736 
1738  "Received P2P PUT from %s\n",
1741  msize = ntohs (put->header.size);
1742  dsize = msize - sizeof(struct PutMessage);
1743  type = ntohl (put->type);
1745  /* do not allow migrated content to live longer than 1 year */
1748  expiration);
1749  if (GNUNET_OK !=
1750  GNUNET_BLOCK_get_key (GSF_block_ctx, type, &put[1], dsize, &query))
1751  {
1752  GNUNET_break_op (0);
1753  return;
1754  }
1756  gettext_noop ("# GAP PUT messages received"),
1757  1,
1758  GNUNET_NO);
1759  /* now, lookup 'query' */
1760  prq.data = (const void *) &put[1];
1761  prq.sender = cp;
1762  prq.size = dsize;
1763  prq.type = type;
1764  prq.expiration = expiration;
1765  prq.priority = 0;
1766  prq.anonymity_level = UINT32_MAX;
1767  prq.request_found = GNUNET_NO;
1768  prq.eo = GNUNET_BLOCK_EO_NONE;
1770  &query,
1771  &process_reply,
1772  &prq);
1773  if (NULL != cp)
1774  {
1777  + 1000 * prq.priority);
1778  GSF_get_peer_performance_data_ (cp)->respect += prq.priority;
1779  }
1780  if ((GNUNET_YES == active_to_migration) && (NULL != cp) &&
1781  (GNUNET_NO == test_put_load_too_high (prq.priority)))
1782  {
1784  "Replicating result for query `%s' with priority %u\n",
1785  GNUNET_h2s (&query),
1786  prq.priority);
1787  pmc = GNUNET_new (struct PutMigrationContext);
1788  pmc->start = GNUNET_TIME_absolute_get ();
1789  pmc->requested = prq.request_found;
1792  &pmc->origin);
1793  if (NULL == GNUNET_DATASTORE_put (GSF_dsh,
1794  0,
1795  &query,
1796  dsize,
1797  &put[1],
1798  type,
1799  prq.priority,
1800  1 /* anonymity */,
1801  0 /* replication */,
1802  expiration,
1803  1 + prq.priority,
1806  pmc))
1807  {
1809  GNUNET_SYSERR,
1811  NULL);
1812  }
1813  }
1814  else if (NULL != cp)
1815  {
1817  "Choosing not to keep content `%s' (%d/%d)\n",
1818  GNUNET_h2s (&query),
1820  test_put_load_too_high (prq.priority));
1821  }
1823  if ((NULL != cp) && (GNUNET_NO == prq.request_found) &&
1825  (putl > 2.5 * (1 + prq.priority))))
1826  {
1829  block_time = GNUNET_TIME_relative_multiply (
1832  (unsigned int) (60000 * putl * putl)));
1833  GNUNET_log (
1835  "Asking to stop migration for %s because of load %f and events %d/%d\n",
1837  putl,
1839  (GNUNET_NO == prq.request_found));
1841  GNUNET_TIME_relative_to_absolute (block_time));
1842  }
1843 }
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 GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:673
#define GNUNET_TIME_UNIT_ZERO_ABS
Absolute time zero.
Response from FS service with a result for a previous FS search.
Definition: fs.h:328
struct GNUNET_TIME_AbsoluteNBO expiration
When does this result expire?
Definition: fs.h:343
GNUNET_BLOCK_Type
Blocks in the datastore and the datacache must have a unique type.
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.
Closure for process_reply() function.
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:246
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
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.
double GNUNET_LOAD_get_load(struct GNUNET_LOAD_Value *load)
Get the current load.
Definition: load.c:200
static struct GNUNET_CONTAINER_MultiHashMap * pr_map
All pending requests, ordered by the query.
struct GNUNET_STATISTICS_Handle * GSF_stats
Handle for reporting statistics.
#define GNUNET_NO
Definition: gnunet_common.h:78
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Default behavior.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
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 int process_reply(void *cls, const struct GNUNET_HashCode *key, void *value)
We have received a reply; handle it!
void GNUNET_PEER_resolve(GNUNET_PEER_Id id, struct GNUNET_PeerIdentity *pid)
Convert an interned PID to a normal peer identity.
Definition: peer.c:225
int 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:378
struct GNUNET_TIME_Absolute start
Start time for the operation.
uint32_t respect
Respect rating for this peer.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
struct GSF_PeerPerformanceData * GSF_get_peer_performance_data_(struct GSF_ConnectedPeer *cp)
Return the performance data record for the given peer.
struct GNUNET_BLOCK_Context * GSF_block_ctx
Our block context.
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:687
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:442
#define CONTENT_BANDWIDTH_VALUE
Bandwidth value of a 0-priority content (must be fairly high compared to query since content is typic...
struct GNUNET_MessageHeader header
Message type will be GNUNET_MESSAGE_TYPE_FS_PUT.
Definition: fs.h:333
A 512-bit hashcode.
static char * expiration
Credential TTL.
Definition: gnunet-abd.c:96
#define GNUNET_TIME_UNIT_MILLISECONDS
One millisecond.
struct GNUNET_DATASTORE_Handle * GSF_dsh
Our connection to the datastore.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
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.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
uint32_t type
Type of the block (in big endian).
Definition: fs.h:338
static struct GNUNET_LOAD_Value * datastore_put_load
Datastore &#39;PUT&#39; load tracking.
int GNUNET_CONTAINER_multihashmap_get_multiple(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map that match a particular key.
#define MAX_DATASTORE_QUEUE
Maximum size of the datastore queue for P2P operations.
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:302
struct GNUNET_PeerIdentity origin
Request origin.
#define GNUNET_TIME_UNIT_YEARS
One year (365 days).
#define GNUNET_log(kind,...)
Context for put_migration_continuation().
A connected peer.
unsigned int GSF_cover_content_count
How many content messages have we received &#39;recently&#39; that have not yet been claimed as cover traffic...
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
Time for absolute times used by GNUnet, in microseconds.
#define GNUNET_YES
Definition: gnunet_common.h:77
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.
static struct GNUNET_PeerIdentity pid
Identity of the peer we transmit to / connect to.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
static int active_to_migration
Are we allowed to migrate content to this peer.
Time for relative time used by GNUnet, in microseconds.
#define gettext_noop(String)
Definition: gettext.h:69
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).

Parameters
prthe pending request to process

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

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, 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 process_reply(), and start_p2p_processing().

1178 {
1179  const void *xquery;
1180  size_t xquery_size;
1181  struct GNUNET_PeerIdentity pi;
1182  char buf[sizeof(struct GNUNET_HashCode) * 2] GNUNET_ALIGN;
1183 
1184  if (0 != pr->public_data.anonymity_level)
1185  return;
1186  if (NULL != pr->gh)
1187  {
1188  GNUNET_DHT_get_stop (pr->gh);
1189  pr->gh = NULL;
1190  }
1191  xquery = NULL;
1192  xquery_size = 0;
1193  if (0 != (pr->public_data.options & GSF_PRO_FORWARD_ONLY))
1194  {
1195  GNUNET_assert (0 != pr->sender_pid);
1197  GNUNET_memcpy (&buf[xquery_size], &pi, sizeof(struct GNUNET_PeerIdentity));
1198  xquery_size += sizeof(struct GNUNET_PeerIdentity);
1199  }
1201  pr->public_data.type,
1202  &pr->public_data.query,
1205  xquery,
1206  xquery_size,
1208  pr);
1209  if ((NULL != pr->gh) && (0 != pr->replies_seen_count))
1211  pr->replies_seen_count,
1212  pr->replies_seen);
1213 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
uint32_t anonymity_level
Desired anonymity level.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
struct GSF_PendingRequestData public_data
Public data for the request.
struct GNUNET_DHT_Handle * GSF_dht
Handle for DHT operations.
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
void GNUNET_PEER_resolve(GNUNET_PEER_Id id, struct GNUNET_PeerIdentity *pid)
Convert an interned PID to a normal peer identity.
Definition: peer.c:225
struct GNUNET_HashCode query
Primary query hash for this request.
unsigned int replies_seen_count
Number of valid entries in the &#39;replies_seen&#39; array.
static char buf[2048]
enum GNUNET_BLOCK_Type type
Type of the requested block.
A 512-bit hashcode.
void GNUNET_DHT_get_stop(struct GNUNET_DHT_GetHandle *get_handle)
Stop async DHT-get.
Definition: dht_api.c:1155
struct GNUNET_DHT_GetHandle * gh
DHT request handle for this request (or NULL for none).
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:1126
#define DHT_GET_REPLICATION
Desired replication level for GETs.
The identity of the host (wraps the signing key of the peer).
enum GSF_PendingRequestOptions options
Options for the request.
#define GNUNET_ALIGN
gcc-ism to force alignment; we use this to align char-arrays that may then be cast to &#39;struct&#39;s...
Request must only be forwarded (no routing)
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:1067
static void handle_dht_reply(void *cls, struct GNUNET_TIME_Absolute exp, const struct GNUNET_HashCode *key, const struct GNUNET_PeerIdentity *get_path, unsigned int get_path_length, const struct GNUNET_PeerIdentity *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. ...
GNUNET_PEER_Id sender_pid
Identity of the peer that we should use for the &#39;sender&#39; (recipient of the response) when forwarding ...
Each peer along the way should look at &#39;enc&#39; (otherwise only the k-peers closest to the key should lo...
struct GNUNET_HashCode * replies_seen
Array of hash codes of replies we&#39;ve already seen.
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)

Parameters
prthe pending request to process

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

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().

1288 {
1289  if (0 != pr->public_data.anonymity_level)
1290  return;
1291  if (0 == pr->public_data.target)
1292  {
1294  "Cannot do cadet-based download, target peer not known\n");
1295  return;
1296  }
1297  if (NULL != pr->cadet_request)
1298  return;
1300  &pr->public_data.query,
1301  pr->public_data.type,
1303  pr);
1304 }
const struct GNUNET_PeerIdentity * target
Identity of a peer hosting the content, otherwise NULl.
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.
uint32_t anonymity_level
Desired anonymity level.
struct GSF_PendingRequestData public_data
Public data for the request.
struct GNUNET_HashCode query
Primary query hash for this request.
enum GNUNET_BLOCK_Type type
Type of the requested block.
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.
#define GNUNET_log(kind,...)
struct GSF_CadetRequest * cadet_request
Cadet request handle for this request (or NULL for none).
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.

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

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

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().

1698 {
1699  GNUNET_assert (NULL == pr->gh);
1700  GNUNET_assert (NULL == pr->cadet_request);
1701  GNUNET_assert (NULL == pr->llc_cont);
1702  pr->llc_cont = cont;
1703  pr->llc_cont_cls = cont_cls;
1704 #if INSANE_STATISTICS
1706  gettext_noop ("# Datastore lookups initiated"),
1707  1,
1708  GNUNET_NO);
1709 #endif
1710  start_local_query (pr, 0 /* next_uid */, true /* random */);
1711 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_STATISTICS_Handle * GSF_stats
Handle for reporting statistics.
#define GNUNET_NO
Definition: gnunet_common.h:78
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
GSF_LocalLookupContinuation llc_cont
Function to call upon completion of the local get request, or NULL for none.
static void start_local_query(struct GSF_PendingRequest *pr, uint64_t next_uid, bool random)
void * llc_cont_cls
Closure for llc_cont.
struct GNUNET_DHT_GetHandle * gh
DHT request handle for this request (or NULL for none).
struct GSF_CadetRequest * cadet_request
Cadet request handle for this request (or NULL for none).
#define gettext_noop(String)
Definition: gettext.h:69
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?

Parameters
prrequest
target
Returns
GNUNET_YES if this request could be forwarded to the given peer

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

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

Referenced by consider_peer_for_forwarding(), and consider_request_for_forwarding().

1675 {
1676  struct GNUNET_PeerIdentity pi;
1677 
1678  if (0 == pr->origin_pid)
1679  return GNUNET_YES;
1681  return (0 == memcmp (&pi, target, sizeof(struct GNUNET_PeerIdentity)))
1682  ? GNUNET_NO
1683  : GNUNET_YES;
1684 }
#define GNUNET_NO
Definition: gnunet_common.h:78
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
void GNUNET_PEER_resolve(GNUNET_PEER_Id id, struct GNUNET_PeerIdentity *pid)
Convert an interned PID to a normal peer identity.
Definition: peer.c:225
GNUNET_PEER_Id origin_pid
Identity of the peer that we should never forward this query to since it originated this query (0 for...
The identity of the host (wraps the signing key of the peer).
#define GNUNET_YES
Definition: gnunet_common.h:77
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 1863 of file gnunet-service-fs_pr.c.

References active_to_migration, DATASTORE_LOAD_AUTODECLINE, 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, and max_pending_requests.

Referenced by run().

1864 {
1865  if (GNUNET_OK !=
1867  "fs",
1868  "MAX_PENDING_REQUESTS",
1870  {
1872  "fs",
1873  "MAX_PENDING_REQUESTS");
1874  }
1876  GNUNET_CONFIGURATION_get_value_yesno (GSF_cfg, "FS", "CONTENT_CACHING");
1881 }
int 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.
struct GNUNET_LOAD_Value * GNUNET_LOAD_value_init(struct GNUNET_TIME_Relative autodecline)
Create a new load value.
Definition: load.c:124
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.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
const struct GNUNET_CONFIGURATION_Handle * GSF_cfg
Our configuration.
static unsigned long long max_pending_requests
Maximum number of requests (from other peers, overall) that we&#39;re willing to have pending at any give...
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
Heap with the minimum cost at the root.
struct GNUNET_CONTAINER_Heap * GNUNET_CONTAINER_heap_create(enum GNUNET_CONTAINER_HeapOrder order)
Create a new heap.
static struct GNUNET_LOAD_Value * datastore_put_load
Datastore &#39;PUT&#39; load tracking.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
#define GNUNET_YES
Definition: gnunet_common.h:77
int 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".
#define DATASTORE_LOAD_AUTODECLINE
At what frequency should our datastore load decrease automatically (since if we don&#39;t use it...
static int active_to_migration
Are we allowed to migrate content to this peer.
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 1888 of file gnunet-service-fs_pr.c.

References clean_request(), GNUNET_CONTAINER_heap_destroy(), GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), and GNUNET_LOAD_value_free.

Referenced by shutdown_task().

1889 {
1892  pr_map = NULL;
1896  datastore_put_load = NULL;
1897 }
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 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.
static int clean_request(void *cls, const struct GNUNET_HashCode *key, void *value)
Iterator to free pending requests.
static struct GNUNET_LOAD_Value * datastore_put_load
Datastore &#39;PUT&#39; load tracking.
#define GNUNET_LOAD_value_free(lv)
Free a load value.
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
Here is the call graph for this function:
Here is the caller graph for this function: