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

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_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. 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_PendingRequestData *	GSF_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_Envelope *	GSF_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_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.

Parameters

cls	user-specified closure
eval	evaluation of the result
pr	handle to the original pending request
reply_anonymity_level	anonymity level for the reply, UINT32_MAX for "unknown"
expiration	when does data expire?
last_transmission	the last time we've tried to get this block (FOREVER if unknown)
type	type of the block
data	response data, NULL on request expiration
data_len	number 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).

Parameters

cls	closure
key	query for the request
pr	handle to the pending request

Returns

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.

Parameters

cls	closure
pr	the pending request we were processing
result	final datastore lookup result

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

Enumeration Type Documentation

GSF_PendingRequestOptions

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

{
  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 =
    (GSF_PRO_BLOOMFILTER_FULL_REFRESH | GSF_PRO_PRIORITY_UNLIMITED
     | GSF_PRO_REQUEST_NEVER_EXPIRES)
};

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.

Parameters

options	request options
type	type of the block that is being requested
query	key for the lookup
target	preferred target for the request, NULL for none
bf_data	raw data for bloom filter for known replies, can be NULL
bf_size	number of bytes in bf_data
anonymity_level	desired anonymity level
priority	maximum outgoing cumulative request priority to use
ttl	current time-to-live for the request
sender_pid	peer ID to use for the sender when forwarding, 0 for none; reference counter is taken over by this function
origin_pid	peer ID of origin of query (do not loop back)
replies_seen	hash codes of known local replies
replies_seen_count	size of the 'replies_seen' array
rh	handle to call when we get a reply
rh_cls	closure for rh

Returns

handle for the new pending request

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

{
  struct GSF_PendingRequest *pr;
  struct GSF_PendingRequest *dpr;
  size_t extra;
  struct GNUNET_HashCode *eptr;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Creating request handle for `%s' of type %d\n",
              GNUNET_h2s (query),
              type);
#if INSANE_STATISTICS
  GNUNET_STATISTICS_update (GSF_stats,
                            gettext_noop ("# Pending requests created"),
                            1,
                            GNUNET_NO);
#endif
  extra = 0;
  if (NULL != target)
    extra += sizeof(struct GNUNET_PeerIdentity);
  pr = GNUNET_malloc (sizeof(struct GSF_PendingRequest) + extra);
  pr->public_data.query = *query;
  eptr = (struct GNUNET_HashCode *) &pr[1];
  if (NULL != target)
  {
    pr->public_data.target = (struct GNUNET_PeerIdentity *) eptr;
    GNUNET_memcpy (eptr, target, sizeof(struct GNUNET_PeerIdentity));
  }
  pr->public_data.anonymity_level = anonymity_level;
  pr->public_data.priority = priority;
  pr->public_data.original_priority = priority;
  pr->public_data.options = options;
  pr->public_data.type = type;
  pr->public_data.start_time = GNUNET_TIME_absolute_get ();
  pr->sender_pid = sender_pid;
  pr->origin_pid = origin_pid;
  pr->rh = rh;
  pr->rh_cls = rh_cls;
  GNUNET_assert ((sender_pid != 0) || (0 == (options & GSF_PRO_FORWARD_ONLY)));
  if (ttl >= 0)
    pr->public_data.ttl = GNUNET_TIME_relative_to_absolute (
      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, (uint32_t) ttl));
  else
    pr->public_data.ttl = GNUNET_TIME_absolute_subtract (
      pr->public_data.start_time,
      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
                                     (uint32_t) (-ttl)));
  if (replies_seen_count > 0)
  {
    pr->replies_seen_size = replies_seen_count;
    pr->replies_seen =
      GNUNET_new_array (pr->replies_seen_size, struct GNUNET_HashCode);
    GNUNET_memcpy (pr->replies_seen,
                   replies_seen,
                   replies_seen_count * sizeof(struct GNUNET_HashCode));
    pr->replies_seen_count = replies_seen_count;
  }
  if ((NULL != bf_data) &&
      (GNUNET_BLOCK_TYPE_FS_UBLOCK == pr->public_data.type))
  {
    pr->bg = GNUNET_BLOCK_group_create (GSF_block_ctx,
                                        pr->public_data.type,
                                        bf_data,
                                        bf_size,
                                        "seen-set-size",
                                        0,
                                        NULL);
  }
  else if ((replies_seen_count > 0) &&
           (0 != (options & GSF_PRO_BLOOMFILTER_FULL_REFRESH)))
  {
    refresh_bloomfilter (pr->public_data.type, pr);
  }
  GNUNET_CONTAINER_multihashmap_put (pr_map,
                                     &pr->public_data.query,
                                     pr,
                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
  if (0 == (options & GSF_PRO_REQUEST_NEVER_EXPIRES))
  {
    pr->hnode = GNUNET_CONTAINER_heap_insert (requests_by_expiration_heap,
                                              pr,
                                              pr->public_data.ttl.abs_value_us);
    /* make sure we don't track too many requests */
    while (GNUNET_CONTAINER_heap_get_size (requests_by_expiration_heap) >
           max_pending_requests)
    {
      dpr = GNUNET_CONTAINER_heap_peek (requests_by_expiration_heap);
      GNUNET_assert (NULL != dpr);
      if (pr == dpr)
        break;     /* let the request live briefly... */
      if (NULL != dpr->rh)
        dpr->rh (dpr->rh_cls,
                 GNUNET_BLOCK_REPLY_TYPE_NOT_SUPPORTED,
                 dpr,
                 UINT32_MAX,
                 GNUNET_TIME_UNIT_FOREVER_ABS,
                 GNUNET_TIME_UNIT_FOREVER_ABS,
                 GNUNET_BLOCK_TYPE_ANY,
                 NULL,
                 0);
      GSF_pending_request_cancel_ (dpr, GNUNET_YES);
    }
  }
  GNUNET_STATISTICS_update (GSF_stats,
                            gettext_noop ("# Pending requests active"),
                            1,
                            GNUNET_NO);
  return pr;
}

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, ttl, GSF_PendingRequestData::ttl, type, and GSF_PendingRequestData::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.

Parameters

pr	request to update
replies_seen	hash codes of replies that we've seen
replies_seen_count	size of the replies_seen array

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

{
  if (replies_seen_count + pr->replies_seen_count < pr->replies_seen_count)
    return; /* integer overflow */
  if (0 != (pr->public_data.options & GSF_PRO_BLOOMFILTER_FULL_REFRESH))
  {
    /* we're responsible for the BF, full refresh */
    if (replies_seen_count + pr->replies_seen_count > pr->replies_seen_size)
      GNUNET_array_grow (pr->replies_seen,
                         pr->replies_seen_size,
                         replies_seen_count + pr->replies_seen_count);
    GNUNET_memcpy (&pr->replies_seen[pr->replies_seen_count],
                   replies_seen,
                   sizeof(struct GNUNET_HashCode) * replies_seen_count);
    pr->replies_seen_count += replies_seen_count;
    refresh_bloomfilter (pr->public_data.type, pr);
  }
  else
  {
    if (NULL == pr->bg)
    {
      /* we're not the initiator, but the initiator did not give us
       * any bloom-filter, so we need to create one on-the-fly */
      refresh_bloomfilter (pr->public_data.type, pr);
    }
    else
    {
      GNUNET_break (GNUNET_OK ==
                    GNUNET_BLOCK_group_set_seen (pr->bg,
                                                 replies_seen,
                                                 pr->replies_seen_count));
    }
  }
  if (NULL != pr->gh)
    GNUNET_DHT_get_filter_known_results (pr->gh,
                                         replies_seen_count,
                                         replies_seen);
}

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

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

pr	pending request

Returns

associated public data

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

{
  return &pr->public_data;
}

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.

Parameters

pr	pending request

Returns

GNUNET_YES if the request is still active

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

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

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

Parameters

pra	a pending request
prb	another pending request

Returns

GNUNET_OK if the requests are compatible

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

{
  if ((pra->public_data.type != prb->public_data.type) ||
      (0 != memcmp (&pra->public_data.query,
                    &prb->public_data.query,
                    sizeof(struct GNUNET_HashCode))))
    return GNUNET_NO;
  return GNUNET_OK;
}

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.

Parameters

pr	request to generate the message for

Returns

envelope with the request message

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

{
  struct GNUNET_MQ_Envelope *env;
  struct GetMessage *gm;
  struct GNUNET_PeerIdentity *ext;
  unsigned int k;
  uint32_t bm;
  uint32_t prio;
  size_t bf_size;
  struct GNUNET_TIME_Absolute now;
  int64_t ttl;
  int do_route;
  void *bf_data;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Building request message for `%s' of type %d\n",
              GNUNET_h2s (&pr->public_data.query),
              pr->public_data.type);
  k = 0;
  bm = 0;
  do_route = (0 == (pr->public_data.options & GSF_PRO_FORWARD_ONLY));
  if ((! do_route) && (pr->sender_pid == 0))
  {
    GNUNET_break (0);
    do_route = GNUNET_YES;
  }
  if (! do_route)
  {
    bm |= GET_MESSAGE_BIT_RETURN_TO;
    k++;
  }
  if (NULL != pr->public_data.target)
  {
    bm |= GET_MESSAGE_BIT_TRANSMIT_TO;
    k++;
  }
  if (GNUNET_OK !=
      GNUNET_BLOCK_group_serialize (pr->bg,
                                    &bf_data,
                                    &bf_size))
  {
    bf_size = 0;
    bf_data = NULL;
  }
  env = GNUNET_MQ_msg_extra (gm,
                             bf_size + k * sizeof(struct GNUNET_PeerIdentity),
                             GNUNET_MESSAGE_TYPE_FS_GET);
  gm->type = htonl (pr->public_data.type);
  if (do_route)
    prio = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
                                     pr->public_data.priority + 1);
  else
    prio = 0;
  pr->public_data.priority -= prio;
  pr->public_data.num_transmissions++;
  pr->public_data.respect_offered += prio;
  gm->priority = htonl (prio);
  now = GNUNET_TIME_absolute_get ();
  ttl = (int64_t) (pr->public_data.ttl.abs_value_us - now.abs_value_us);
  gm->ttl = htonl (ttl / 1000LL / 1000LL);
  gm->reserved = htonl (0);
  gm->hash_bitmap = htonl (bm);
  gm->query = pr->public_data.query;
  ext = (struct GNUNET_PeerIdentity *) &gm[1];
  k = 0;
  if (! do_route)
    GNUNET_PEER_resolve (pr->sender_pid, &ext[k++]);
  if (NULL != pr->public_data.target)
    ext[k++] = *pr->public_data.target;
  GNUNET_memcpy (&ext[k], bf_data, bf_size);
  GNUNET_free (bf_data);
  return env;
}

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, ttl, GetMessage::ttl, GSF_PendingRequestData::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.

Parameters

pr	request to cancel
full_cleanup	fully purge the request

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

{
  GSF_LocalLookupContinuation cont;
 
  if (NULL == pr_map)
    return; /* already cleaned up! */
  if (GNUNET_NO == full_cleanup)
  {
    /* make request inactive (we're no longer interested in more results),
     * but do NOT remove from our data-structures, we still need it there
     * to prevent the request from looping */
    pr->rh = NULL;
    if (NULL != pr->cadet_request)
    {
      pr->cadet_retry_count = CADET_RETRY_MAX;
      GSF_cadet_query_cancel (pr->cadet_request);
      pr->cadet_request = NULL;
    }
    if (NULL != (cont = pr->llc_cont))
    {
      pr->llc_cont = NULL;
      cont (pr->llc_cont_cls,
            pr,
            pr->local_result);
    }
    GSF_plan_notify_request_done_ (pr);
    if (NULL != pr->qe)
    {
      GNUNET_DATASTORE_cancel (pr->qe);
      pr->qe = NULL;
    }
    if (NULL != pr->gh)
    {
      GNUNET_DHT_get_stop (pr->gh);
      pr->gh = NULL;
    }
    if (NULL != pr->warn_task)
    {
      GNUNET_SCHEDULER_cancel (pr->warn_task);
      pr->warn_task = NULL;
    }
    return;
  }
  GNUNET_assert (GNUNET_YES ==
                 clean_request (NULL, &pr->public_data.query, pr));
}

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.

Parameters

it	function to call for each request
cls	closure for it

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

{
  GNUNET_CONTAINER_multihashmap_iterate (
    pr_map,
    (GNUNET_CONTAINER_MultiHashMapIteratorCallback) it,
    cls);
}

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

Parameters

cls	the other peer involved (sender)
put	the 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

cls	the other peer involved
put	the actual message

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

{
  struct GSF_ConnectedPeer *cp = cls;
  uint16_t msize;
  size_t dsize;
  enum GNUNET_BLOCK_Type type;
  struct GNUNET_TIME_Absolute expiration;
  struct GNUNET_HashCode query;
  struct ProcessReplyClosure prq;
  struct GNUNET_TIME_Relative block_time;
  double putl;
  struct PutMigrationContext *pmc;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received P2P PUT from %s\n",
              GNUNET_i2s (GSF_get_peer_performance_data_ (cp)->peer));
  GSF_cover_content_count++;
  msize = ntohs (put->header.size);
  dsize = msize - sizeof(struct PutMessage);
  type = ntohl (put->type);
  expiration = GNUNET_TIME_absolute_ntoh (put->expiration);
  /* do not allow migrated content to live longer than 1 year */
  expiration = GNUNET_TIME_absolute_min (GNUNET_TIME_relative_to_absolute (
                                           GNUNET_TIME_UNIT_YEARS),
                                         expiration);
  if (GNUNET_OK !=
      GNUNET_BLOCK_check_block (GSF_block_ctx,
                                type,
                                &put[1],
                                dsize))
  {
    GNUNET_break_op (0);
    return;
  }
  if (GNUNET_OK !=
      GNUNET_BLOCK_get_key (GSF_block_ctx,
                            type,
                            &put[1],
                            dsize,
                            &query))
  {
    GNUNET_break_op (0);
    return;
  }
  GNUNET_STATISTICS_update (GSF_stats,
                            gettext_noop ("# GAP PUT messages received"),
                            1,
                            GNUNET_NO);
  /* now, lookup 'query' */
  prq.data = (const void *) &put[1];
  prq.sender = cp;
  prq.size = dsize;
  prq.type = type;
  prq.expiration = expiration;
  prq.priority = 0;
  prq.anonymity_level = UINT32_MAX;
  prq.request_found = GNUNET_NO;
  GNUNET_CONTAINER_multihashmap_get_multiple (pr_map,
                                              &query,
                                              &process_reply,
                                              &prq);
  if (NULL != cp)
  {
    GSF_connected_peer_change_preference_ (cp,
                                           CONTENT_BANDWIDTH_VALUE
                                           + 1000 * prq.priority);
    GSF_get_peer_performance_data_ (cp)->respect += prq.priority;
  }
  if ((GNUNET_YES == active_to_migration) && (NULL != cp) &&
      (GNUNET_NO == test_put_load_too_high (prq.priority)))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Replicating result for query `%s' with priority %u\n",
                GNUNET_h2s (&query),
                prq.priority);
    pmc = GNUNET_new (struct PutMigrationContext);
    pmc->start = GNUNET_TIME_absolute_get ();
    pmc->requested = prq.request_found;
    GNUNET_assert (0 != GSF_get_peer_performance_data_ (cp)->pid);
    GNUNET_PEER_resolve (GSF_get_peer_performance_data_ (cp)->pid,
                         &pmc->origin);
    if (NULL == GNUNET_DATASTORE_put (GSF_dsh,
                                      0,
                                      &query,
                                      dsize,
                                      &put[1],
                                      type,
                                      prq.priority,
                                      1 /* anonymity */,
                                      0 /* replication */,
                                      expiration,
                                      1 + prq.priority,
                                      MAX_DATASTORE_QUEUE,
                                      &put_migration_continuation,
                                      pmc))
    {
      put_migration_continuation (pmc,
                                  GNUNET_SYSERR,
                                  GNUNET_TIME_UNIT_ZERO_ABS,
                                  NULL);
    }
  }
  else if (NULL != cp)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Choosing not to keep content `%s' (%d/%d)\n",
                GNUNET_h2s (&query),
                active_to_migration,
                test_put_load_too_high (prq.priority));
  }
  putl = GNUNET_LOAD_get_load (datastore_put_load);
  if ((NULL != cp) && (GNUNET_NO == prq.request_found) &&
      ((GNUNET_YES != active_to_migration) ||
       (putl > 2.5 * (1 + prq.priority))))
  {
    if (GNUNET_YES != active_to_migration)
      putl = 1.0 + GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 5);
    block_time = GNUNET_TIME_relative_multiply (
      GNUNET_TIME_UNIT_MILLISECONDS,
      5000 + GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
                                       (unsigned int) (60000 * putl * putl)));
    GNUNET_log (
      GNUNET_ERROR_TYPE_DEBUG,
      "Asking to stop migration for %s because of load %f and events %d/%d\n",
      GNUNET_STRINGS_relative_time_to_string (block_time, GNUNET_YES),
      putl,
      active_to_migration,
      (GNUNET_NO == prq.request_found));
    GSF_block_peer_migration_ (cp,
                               GNUNET_TIME_relative_to_absolute (block_time));
  }
}

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, pid, pr_map, 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.

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

pr	the pending request to process

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

{
  const void *xquery;
  size_t xquery_size;
  struct GNUNET_PeerIdentity pi;
  char buf[sizeof(struct GNUNET_HashCode) * 2] GNUNET_ALIGN;
 
  if (0 != pr->public_data.anonymity_level)
    return;
  if (NULL != pr->gh)
  {
    GNUNET_DHT_get_stop (pr->gh);
    pr->gh = NULL;
  }
  xquery = NULL;
  xquery_size = 0;
  if (0 != (pr->public_data.options & GSF_PRO_FORWARD_ONLY))
  {
    GNUNET_assert (0 != pr->sender_pid);
    GNUNET_PEER_resolve (pr->sender_pid, &pi);
    GNUNET_memcpy (&buf[xquery_size], &pi, sizeof(struct GNUNET_PeerIdentity));
    xquery_size += sizeof(struct GNUNET_PeerIdentity);
  }
  pr->gh = GNUNET_DHT_get_start (GSF_dht,
                                 pr->public_data.type,
                                 &pr->public_data.query,
                                 DHT_GET_REPLICATION,
                                 GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
                                 xquery,
                                 xquery_size,
                                 &handle_dht_reply,
                                 pr);
  if ((NULL != pr->gh) && (0 != pr->replies_seen_count))
    GNUNET_DHT_get_filter_known_results (pr->gh,
                                         pr->replies_seen_count,
                                         pr->replies_seen);
}

References GSF_PendingRequestData::anonymity_level, 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().

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

pr	the pending request to process

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

{
  if (0 != pr->public_data.anonymity_level)
    return;
  if (0 == pr->public_data.target)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Cannot do cadet-based download, target peer not known\n");
    return;
  }
  if (NULL != pr->cadet_request)
    return;
  pr->cadet_request = GSF_cadet_query (pr->public_data.target,
                                       &pr->public_data.query,
                                       pr->public_data.type,
                                       &cadet_reply_proc,
                                       pr);
}

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.

Parameters

pr	the pending request to process
cont	function to call at the end
cont_cls	closure for cont

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

{
  GNUNET_assert (NULL == pr->gh);
  GNUNET_assert (NULL == pr->cadet_request);
  GNUNET_assert (NULL == pr->llc_cont);
  pr->llc_cont = cont;
  pr->llc_cont_cls = cont_cls;
#if INSANE_STATISTICS
  GNUNET_STATISTICS_update (GSF_stats,
                            gettext_noop ("# Datastore lookups initiated"),
                            1,
                            GNUNET_NO);
#endif
  start_local_query (pr, 0 /* next_uid */, true /* 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?

Parameters

pr	request
target

Returns

GNUNET_YES if this request could be forwarded to the given peer

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

{
  struct GNUNET_PeerIdentity pi;
 
  if (0 == pr->origin_pid)
    return GNUNET_YES;
  GNUNET_PEER_resolve (pr->origin_pid, &pi);
  return (0 == memcmp (&pi, target, sizeof(struct GNUNET_PeerIdentity)))
         ? GNUNET_NO
         : GNUNET_YES;
}

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

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.

{
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_number (GSF_cfg,
                                             "fs",
                                             "MAX_PENDING_REQUESTS",
                                             &max_pending_requests))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_INFO,
                               "fs",
                               "MAX_PENDING_REQUESTS");
  }
  active_to_migration =
    GNUNET_CONFIGURATION_get_value_yesno (GSF_cfg, "FS", "CONTENT_CACHING");
  datastore_put_load = GNUNET_LOAD_value_init (DATASTORE_LOAD_AUTODECLINE);
  pr_map = GNUNET_CONTAINER_multihashmap_create (32 * 1024, GNUNET_YES);
  requests_by_expiration_heap =
    GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
}

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.

{
  GNUNET_CONTAINER_multihashmap_iterate (pr_map, &clean_request, NULL);
  GNUNET_CONTAINER_multihashmap_destroy (pr_map);
  pr_map = NULL;
  GNUNET_CONTAINER_heap_destroy (requests_by_expiration_heap);
  requests_by_expiration_heap = NULL;
  GNUNET_LOAD_value_free (datastore_put_load);
  datastore_put_load = NULL;
}

References clean_request(), datastore_put_load, GNUNET_CONTAINER_heap_destroy(), GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_LOAD_value_free, pr_map, and requests_by_expiration_heap.

Referenced by shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function: