GNUnet  0.20.0
gnunet-service-fs_cp.c File Reference

API to handle 'connected peers'. More...

Include dependency graph for gnunet-service-fs_cp.c:

Go to the source code of this file.

Data Structures

struct  GSF_PeerTransmitHandle
 Handle to cancel a transmission request. More...
 
struct  GSF_DelayedHandle
 Handle for an entry in our delay list. More...
 
struct  PeerRequest
 Information per peer and request. More...
 
struct  GSF_ConnectedPeer
 A connected peer. More...
 
struct  TestExistClosure
 Closure for test_exist_cb(). More...
 
struct  IterationContext
 Closure for call_iterator(). More...
 

Macros

#define RUNAVG_DELAY_N   16
 Ratio for moving average delay calculation. More...
 
#define RESPECT_FLUSH_FREQ
 How often do we flush respect values to disk? More...
 
#define REPLY_TIMEOUT
 After how long do we discard a reply? More...
 
#define INSANE_STATISTICS   GNUNET_NO
 Collect an instance number of statistics? May cause excessive IPC. More...
 
#define N   ((double) 128.0)
 

Functions

void GSF_update_peer_latency_ (const struct GNUNET_PeerIdentity *id, struct GNUNET_TIME_Relative latency)
 Update the latency information kept for the given peer. More...
 
struct GSF_PeerPerformanceDataGSF_get_peer_performance_data_ (struct GSF_ConnectedPeer *cp)
 Return the performance data record for the given peer. More...
 
static void peer_transmit (struct GSF_ConnectedPeer *cp)
 Core is ready to transmit to a peer, get the message. More...
 
static void ats_reserve_callback (void *cls, const struct GNUNET_PeerIdentity *peer, int32_t amount, struct GNUNET_TIME_Relative res_delay)
 Function called by core upon success or failure of our bandwidth reservation request. More...
 
static void schedule_transmission (struct GSF_PeerTransmitHandle *pth)
 If ready (bandwidth reserved), try to schedule transmission via core for the given handle. More...
 
static void retry_reservation (void *cls)
 (re)try to reserve bandwidth from the given peer. More...
 
static void peer_respect_cb (void *cls, const struct GNUNET_PEERSTORE_Record *record, const char *emsg)
 Function called by PEERSTORE with peer respect record. More...
 
static int consider_peer_for_forwarding (void *cls, const struct GNUNET_HashCode *key, struct GSF_PendingRequest *pr)
 Function called for each pending request whenever a new peer connects, giving us a chance to decide about submitting the existing request to the new peer. More...
 
void * GSF_peer_connect_handler (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
 A peer connected to us. More...
 
static void revive_migration (void *cls)
 It may be time to re-start migrating content to this peer. More...
 
struct GSF_ConnectedPeerGSF_peer_get_ (const struct GNUNET_PeerIdentity *peer)
 Get a handle for a connected peer. More...
 
void handle_p2p_migration_stop (void *cls, const struct MigrationStopMessage *msm)
 Handle P2P GNUNET_MESSAGE_TYPE_FS_MIGRATION_STOP message. More...
 
static void free_pending_request (struct PeerRequest *peerreq)
 Free resources associated with the given peer request. More...
 
static int cancel_pending_request (void *cls, const struct GNUNET_HashCode *query, void *value)
 Cancel all requests associated with the peer. More...
 
static void peer_request_destroy (void *cls)
 Free the given request. More...
 
static void transmit_delayed_now (void *cls)
 The artificial delay is over, transmit the message now. More...
 
static struct GNUNET_TIME_Relative get_randomized_delay ()
 Get the randomized delay a response should be subjected to. More...
 
static void handle_p2p_reply (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...
 
static int change_peer_respect (struct GSF_ConnectedPeer *cp, int value)
 Increase the peer's respect by a value. More...
 
static int32_t bound_priority (uint32_t prio_in, struct GSF_ConnectedPeer *cp)
 We've received a request with the specified priority. More...
 
static int32_t bound_ttl (int32_t ttl_in, uint32_t prio)
 The priority level imposes a bound on the maximum value for the ttl that can be requested. More...
 
static int test_exist_cb (void *cls, const struct GNUNET_HashCode *hc, void *value)
 Test if the query already exists. More...
 
void handle_p2p_get (void *cls, const struct GetMessage *gm)
 Handle P2P "QUERY" message. More...
 
void GSF_peer_transmit_ (struct GSF_ConnectedPeer *cp, int is_query, uint32_t priority, struct GNUNET_MQ_Envelope *env)
 Transmit a message to the given peer as soon as possible. More...
 
void GSF_peer_update_performance_ (struct GSF_ConnectedPeer *cp, struct GNUNET_TIME_Absolute request_time, uint32_t request_priority)
 Report on receiving a reply; update the performance record of the given peer. More...
 
void GSF_peer_update_responder_client_ (struct GSF_ConnectedPeer *cp, struct GSF_LocalClient *initiator_client)
 Report on receiving a reply in response to an initiating client. More...
 
void GSF_peer_update_responder_peer_ (struct GSF_ConnectedPeer *cp, const struct GSF_ConnectedPeer *initiator_peer)
 Report on receiving a reply in response to an initiating peer. More...
 
static int flush_respect (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
 Write peer-respect information to a file - flush the buffer entry! More...
 
void GSF_peer_disconnect_handler (void *cls, const struct GNUNET_PeerIdentity *peer, void *internal_cls)
 A peer disconnected from us. More...
 
static int call_iterator (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
 Function that calls the callback for each peer. More...
 
void GSF_iterate_connected_peers_ (GSF_ConnectedPeerIterator it, void *it_cls)
 Iterate over all connected peers. More...
 
void GSF_connected_peer_get_identity_ (const struct GSF_ConnectedPeer *cp, struct GNUNET_PeerIdentity *id)
 Obtain the identity of a connected peer. More...
 
const struct GNUNET_PeerIdentityGSF_connected_peer_get_identity2_ (const struct GSF_ConnectedPeer *cp)
 Obtain the identity of a connected peer. More...
 
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. More...
 
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). More...
 
static void cron_flush_respect (void *cls)
 Call this method periodically to flush respect information to disk. More...
 
void GSF_connected_peer_init_ ()
 Initialize peer management subsystem. More...
 
void GSF_connected_peer_done_ ()
 Shutdown peer management subsystem. More...
 
static int clean_local_client (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
 Iterator to remove references to LC entry. More...
 
void GSF_handle_local_client_disconnect_ (const struct GSF_LocalClient *lc)
 Notification that a local client disconnected. More...
 

Variables

static struct GNUNET_CONTAINER_MultiPeerMapcp_map
 Map from peer identities to struct GSF_ConnectPeer entries. More...
 
static struct GNUNET_PEERSTORE_Handlepeerstore
 Handle to peerstore service. More...
 
static struct GNUNET_SCHEDULER_Taskfr_task
 Task used to flush respect values to disk. More...
 

Detailed Description

API to handle 'connected peers'.

Author
Christian Grothoff

Definition in file gnunet-service-fs_cp.c.

Macro Definition Documentation

◆ RUNAVG_DELAY_N

#define RUNAVG_DELAY_N   16

Ratio for moving average delay calculation.

The previous average goes in with a factor of (n-1) into the calculation. Must be > 0.

Definition at line 41 of file gnunet-service-fs_cp.c.

◆ RESPECT_FLUSH_FREQ

#define RESPECT_FLUSH_FREQ
Value:
#define GNUNET_TIME_UNIT_MINUTES
One minute.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:484

How often do we flush respect values to disk?

Definition at line 46 of file gnunet-service-fs_cp.c.

◆ REPLY_TIMEOUT

#define REPLY_TIMEOUT
Value:

After how long do we discard a reply?

Definition at line 52 of file gnunet-service-fs_cp.c.

◆ INSANE_STATISTICS

#define INSANE_STATISTICS   GNUNET_NO

Collect an instance number of statistics? May cause excessive IPC.

Definition at line 58 of file gnunet-service-fs_cp.c.

◆ N

#define N   ((double) 128.0)

Function Documentation

◆ GSF_update_peer_latency_()

void GSF_update_peer_latency_ ( const struct GNUNET_PeerIdentity id,
struct GNUNET_TIME_Relative  latency 
)

Update the latency information kept for the given peer.

Parameters
idpeer record to update
latencycurrent latency value

Definition at line 302 of file gnunet-service-fs_cp.c.

304 {
305  struct GSF_ConnectedPeer *cp;
306 
307  cp = GSF_peer_get_ (id);
308  if (NULL == cp)
309  return; /* we're not yet connected at the core level, ignore */
311  latency);
312 }
struct GSF_ConnectedPeer * GSF_peer_get_(const struct GNUNET_PeerIdentity *peer)
Get a handle for a connected peer.
void GNUNET_LOAD_value_set_decline(struct GNUNET_LOAD_Value *load, struct GNUNET_TIME_Relative autodecline)
Change the value by which the load automatically declines.
Definition: load.c:143
A connected peer.
struct GSF_PeerPerformanceData ppd
Performance data for this peer.
struct GNUNET_LOAD_Value * transmission_delay
How long does it typically take for us to transmit a message to this peer? (delay between the request...

References GNUNET_LOAD_value_set_decline(), GSF_peer_get_(), GSF_ConnectedPeer::ppd, and GSF_PeerPerformanceData::transmission_delay.

Referenced by update_latencies().

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

◆ GSF_get_peer_performance_data_()

struct GSF_PeerPerformanceData* GSF_get_peer_performance_data_ ( struct GSF_ConnectedPeer cp)

Return the performance data record for the given peer.

Parameters
cppeer to query
Returns
performance data record for the peer

Definition at line 322 of file gnunet-service-fs_cp.c.

323 {
324  return &cp->ppd;
325 }

References GSF_ConnectedPeer::ppd.

Referenced by handle_p2p_put(), put_migration_continuation(), score_content(), and transmit_content().

Here is the caller graph for this function:

◆ peer_transmit()

static void peer_transmit ( struct GSF_ConnectedPeer cp)
static

Core is ready to transmit to a peer, get the message.

Parameters
cpwhich peer to send a message to

Definition at line 406 of file gnunet-service-fs_cp.c.

407 {
408  struct GSF_PeerTransmitHandle *pth = cp->pth_head;
409  struct GSF_PeerTransmitHandle *pos;
410 
411  if (NULL == pth)
412  return;
414  cp->pth_tail,
415  pth);
416  if (GNUNET_YES == pth->is_query)
417  {
419  % MAX_QUEUE_PER_PEER] =
422  }
423  else if (GNUNET_NO == pth->is_query)
424  {
426  }
430  GNUNET_MQ_send (cp->mq,
431  pth->env);
432  GNUNET_free (pth);
433  if (NULL != (pos = cp->pth_head))
434  {
435  GNUNET_assert (pos != pth);
436  schedule_transmission (pos);
437  }
438 }
static void schedule_transmission(struct GSF_PeerTransmitHandle *pth)
If ready (bandwidth reserved), try to schedule transmission via core for the given handle.
#define MAX_QUEUE_PER_PEER
Maximum number of outgoing messages we queue per peer.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
@ GNUNET_YES
@ GNUNET_NO
void GNUNET_LOAD_update(struct GNUNET_LOAD_Value *load, uint64_t data)
Update the current load.
Definition: load.c:237
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_free(ptr)
Wrapper around free.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:304
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:436
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:111
uint64_t rel_value_us
The actual value.
struct GSF_PeerTransmitHandle * pth_head
Messages (replies, queries, content migration) we would like to send to this peer in the near future.
struct GNUNET_MQ_Handle * mq
Handle for an active request for transmission to this peer.
unsigned int last_request_times_off
Current offset into last_request_times ring buffer.
struct GSF_PeerTransmitHandle * pth_tail
Messages (replies, queries, content migration) we would like to send to this peer in the near future.
unsigned int pending_replies
Number of pending replies (queries are not counted)
unsigned int pending_queries
Number of pending queries (replies are not counted)
struct GNUNET_TIME_Absolute last_request_times[24]
Transmission times for the last MAX_QUEUE_PER_PEER requests for this peer.
Handle to cancel a transmission request.
int is_query
GNUNET_YES if this is a query, GNUNET_NO for content.
struct GNUNET_TIME_Absolute transmission_request_start_time
Time when this transmission request was issued.
struct GSF_ConnectedPeer * cp
Peer this request targets.
struct GNUNET_MQ_Envelope * env
Envelope with the actual message.

References GSF_PeerTransmitHandle::cp, GSF_PeerTransmitHandle::env, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_LOAD_update(), GNUNET_MQ_send(), GNUNET_NO, GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_duration(), GNUNET_YES, GSF_PeerTransmitHandle::is_query, GSF_PeerPerformanceData::last_request_times, GSF_ConnectedPeer::last_request_times_off, MAX_QUEUE_PER_PEER, GSF_ConnectedPeer::mq, GSF_PeerPerformanceData::pending_queries, GSF_PeerPerformanceData::pending_replies, GSF_ConnectedPeer::ppd, GSF_ConnectedPeer::pth_head, GSF_ConnectedPeer::pth_tail, GNUNET_TIME_Relative::rel_value_us, schedule_transmission(), GSF_PeerPerformanceData::transmission_delay, and GSF_PeerTransmitHandle::transmission_request_start_time.

Referenced by ats_reserve_callback(), and schedule_transmission().

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

◆ ats_reserve_callback()

static void ats_reserve_callback ( void *  cls,
const struct GNUNET_PeerIdentity peer,
int32_t  amount,
struct GNUNET_TIME_Relative  res_delay 
)
static

Function called by core upon success or failure of our bandwidth reservation request.

Parameters
clsthe struct GSF_ConnectedPeer of the peer for which we made the request
peeridentifies the peer
amountset to the amount that was actually reserved or unreserved; either the full requested amount or zero (no partial reservations)
res_delayif the reservation could not be satisfied (amount was 0), how long should the client wait until re-trying?

Definition at line 473 of file gnunet-service-fs_cp.c.

477 {
478  struct GSF_ConnectedPeer *cp = cls;
479  struct GSF_PeerTransmitHandle *pth;
480 
482  "Reserved %d bytes / need to wait %s for reservation\n",
483  (int) amount,
485  cp->rc = NULL;
486  if (0 == amount)
487  {
488  cp->rc_delay_task =
489  GNUNET_SCHEDULER_add_delayed (res_delay,
491  cp);
492  return;
493  }
495  pth = cp->pth_head;
496  if (NULL != pth)
497  {
498  /* reservation success, try transmission now! */
499  peer_transmit (cp);
500  }
501 }
static void peer_transmit(struct GSF_ConnectedPeer *cp)
Core is ready to transmit to a peer, get the message.
static void retry_reservation(void *cls)
(re)try to reserve bandwidth from the given peer.
#define GNUNET_log(kind,...)
@ GNUNET_ERROR_TYPE_DEBUG
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1272
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:569
int did_reserve
GNUNET_YES if we did successfully reserve 32k bandwidth, GNUNET_NO if not.
struct GNUNET_ATS_ReservationContext * rc
Context of our GNUNET_ATS_reserve_bandwidth call (or NULL).
struct GNUNET_SCHEDULER_Task * rc_delay_task
Task scheduled if we need to retry bandwidth reservation later.

References GSF_PeerTransmitHandle::cp, GSF_ConnectedPeer::did_reserve, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_YES, peer_transmit(), GSF_ConnectedPeer::pth_head, GSF_ConnectedPeer::rc, GSF_ConnectedPeer::rc_delay_task, and retry_reservation().

Referenced by GSF_peer_connect_handler(), retry_reservation(), and schedule_transmission().

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

◆ schedule_transmission()

static void schedule_transmission ( struct GSF_PeerTransmitHandle pth)
static

If ready (bandwidth reserved), try to schedule transmission via core for the given handle.

Parameters
pthtransmission handle to schedule

Definition at line 361 of file gnunet-service-fs_cp.c.

362 {
363  struct GSF_ConnectedPeer *cp;
364  struct GNUNET_PeerIdentity target;
365 
366  cp = pth->cp;
367  GNUNET_assert (0 != cp->ppd.pid);
368  GNUNET_PEER_resolve (cp->ppd.pid, &target);
369 
370  if (0 != cp->inc_preference)
371  {
373  &target,
375  (double) cp->inc_preference,
377  cp->inc_preference = 0;
378  }
379 
380  if ((GNUNET_YES == pth->is_query) &&
381  (GNUNET_YES != pth->was_reserved))
382  {
383  /* query, need reservation */
384  if (GNUNET_YES != cp->did_reserve)
385  return; /* not ready */
386  cp->did_reserve = GNUNET_NO;
387  /* reservation already done! */
388  pth->was_reserved = GNUNET_YES;
390  &target,
391  DBLOCK_SIZE,
393  cp);
394  return;
395  }
396  peer_transmit (cp);
397 }
#define DBLOCK_SIZE
Size of the individual blocks used for file-sharing.
Definition: fs.h:41
struct GNUNET_ATS_PerformanceHandle * GSF_ats
Handle to ATS service.
static void ats_reserve_callback(void *cls, const struct GNUNET_PeerIdentity *peer, int32_t amount, struct GNUNET_TIME_Relative res_delay)
Function called by core upon success or failure of our bandwidth reservation request.
void GNUNET_ATS_performance_change_preference(struct GNUNET_ATS_PerformanceHandle *ph, const struct GNUNET_PeerIdentity *peer,...)
Change preferences for the given peer.
struct GNUNET_ATS_ReservationContext * GNUNET_ATS_reserve_bandwidth(struct GNUNET_ATS_PerformanceHandle *ph, const struct GNUNET_PeerIdentity *peer, int32_t amount, GNUNET_ATS_ReservationCallback rcb, void *rcb_cls)
Reserve inbound bandwidth from the given peer.
@ GNUNET_ATS_PREFERENCE_BANDWIDTH
Change the peer's bandwidth value (value per byte of bandwidth in the goal function) to the given amo...
@ GNUNET_ATS_PREFERENCE_END
End of preference list.
void GNUNET_PEER_resolve(GNUNET_PEER_Id id, struct GNUNET_PeerIdentity *pid)
Convert an interned PID to a normal peer identity.
Definition: peer.c:220
The identity of the host (wraps the signing key of the peer).
uint64_t inc_preference
Increase in traffic preference still to be submitted to the core service for this peer.
GNUNET_PEER_Id pid
The peer's identity (interned version).
int was_reserved
Did we get a reservation already?

References ats_reserve_callback(), GSF_PeerTransmitHandle::cp, DBLOCK_SIZE, GSF_ConnectedPeer::did_reserve, GNUNET_assert, GNUNET_ATS_performance_change_preference(), GNUNET_ATS_PREFERENCE_BANDWIDTH, GNUNET_ATS_PREFERENCE_END, GNUNET_ATS_reserve_bandwidth(), GNUNET_NO, GNUNET_PEER_resolve(), GNUNET_YES, GSF_ats, GSF_ConnectedPeer::inc_preference, GSF_PeerTransmitHandle::is_query, peer_transmit(), GSF_PeerPerformanceData::pid, GSF_ConnectedPeer::ppd, GSF_ConnectedPeer::rc, and GSF_PeerTransmitHandle::was_reserved.

Referenced by GSF_peer_transmit_(), and peer_transmit().

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

◆ retry_reservation()

static void retry_reservation ( void *  cls)
static

(re)try to reserve bandwidth from the given peer.

Parameters
clsthe struct GSF_ConnectedPeer to reserve from

Definition at line 447 of file gnunet-service-fs_cp.c.

448 {
449  struct GSF_ConnectedPeer *cp = cls;
450  struct GNUNET_PeerIdentity target;
451 
452  GNUNET_PEER_resolve (cp->ppd.pid, &target);
453  cp->rc_delay_task = NULL;
454  cp->rc =
456  &target,
457  DBLOCK_SIZE,
458  &ats_reserve_callback, cp);
459 }

References ats_reserve_callback(), DBLOCK_SIZE, GNUNET_ATS_reserve_bandwidth(), GNUNET_PEER_resolve(), GSF_ats, GSF_PeerPerformanceData::pid, GSF_ConnectedPeer::ppd, GSF_ConnectedPeer::rc, and GSF_ConnectedPeer::rc_delay_task.

Referenced by ats_reserve_callback().

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

◆ peer_respect_cb()

static void peer_respect_cb ( void *  cls,
const struct GNUNET_PEERSTORE_Record record,
const char *  emsg 
)
static

Function called by PEERSTORE with peer respect record.

Parameters
clshandle to connected peer entry
recordpeerstore record information
emsgerror message, or NULL if no errors

Definition at line 512 of file gnunet-service-fs_cp.c.

515 {
516  struct GSF_ConnectedPeer *cp = cls;
517 
518  GNUNET_assert (NULL != cp->respect_iterate_req);
519  if ((NULL != record) &&
520  (sizeof(cp->disk_respect) == record->value_size))
521  {
522  cp->disk_respect = *((uint32_t *) record->value);
523  cp->ppd.respect += *((uint32_t *) record->value);
524  }
525  GSF_push_start_ (cp);
526  if (NULL != record)
528  cp->respect_iterate_req = NULL;
529 }
static void record(void *cls, size_t data_size, const void *data)
Process recorded audio data.
void GSF_push_start_(struct GSF_ConnectedPeer *peer)
A peer connected to us.
void GNUNET_PEERSTORE_iterate_cancel(struct GNUNET_PEERSTORE_IterateContext *ic)
Cancel an iterate request Please do not call after the iterate request is done.
struct GNUNET_PEERSTORE_IterateContext * respect_iterate_req
Handle to the PEERSTORE iterate request for peer respect value.
uint32_t disk_respect
Respect rating for this peer on disk.
uint32_t respect
Respect rating for this peer.

References GSF_ConnectedPeer::disk_respect, GNUNET_assert, GNUNET_PEERSTORE_iterate_cancel(), GSF_push_start_(), GSF_ConnectedPeer::ppd, record(), GSF_PeerPerformanceData::respect, and GSF_ConnectedPeer::respect_iterate_req.

Referenced by GSF_peer_connect_handler().

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

◆ consider_peer_for_forwarding()

static int consider_peer_for_forwarding ( void *  cls,
const struct GNUNET_HashCode key,
struct GSF_PendingRequest pr 
)
static

Function called for each pending request whenever a new peer connects, giving us a chance to decide about submitting the existing request to the new peer.

Parameters
clsthe struct GSF_ConnectedPeer of the new peer
keyquery for the request
prhandle to the pending request
Returns
GNUNET_YES to continue to iterate

Definition at line 543 of file gnunet-service-fs_cp.c.

546 {
547  struct GSF_ConnectedPeer *cp = cls;
548  struct GNUNET_PeerIdentity pid;
549 
550  if (GNUNET_YES !=
552  return GNUNET_YES; /* request is not actually active, skip! */
554  if (GNUNET_YES !=
556  {
558  gettext_noop ("# Loopback routes suppressed"),
559  1,
560  GNUNET_NO);
561  return GNUNET_YES;
562  }
563  GSF_plan_add_ (cp, pr);
564  return GNUNET_YES;
565 }
#define gettext_noop(String)
Definition: gettext.h:70
struct GNUNET_STATISTICS_Handle * GSF_stats
Handle for reporting statistics.
void GSF_connected_peer_get_identity_(const struct GSF_ConnectedPeer *cp, struct GNUNET_PeerIdentity *id)
Obtain the identity of a connected peer.
void GSF_plan_add_(struct GSF_ConnectedPeer *cp, struct GSF_PendingRequest *pr)
Create a new query plan entry.
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?
int GSF_pending_request_test_active_(struct GSF_PendingRequest *pr)
Check if the given request is still active.
static struct GNUNET_PeerIdentity pid
Identity of the peer we transmit to / connect to.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.

References gettext_noop, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_YES, GSF_connected_peer_get_identity_(), GSF_pending_request_test_active_(), GSF_pending_request_test_target_(), GSF_plan_add_(), GSF_stats, and pid.

Referenced by GSF_peer_connect_handler().

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

◆ GSF_peer_connect_handler()

void* GSF_peer_connect_handler ( void *  cls,
const struct GNUNET_PeerIdentity peer,
struct GNUNET_MQ_Handle mq 
)

A peer connected to us.

Setup the connected peer records.

Parameters
clsNULL
peeridentity of peer that connected
mqmessage queue for talking to peer
Returns
internal handle for the peer

Definition at line 569 of file gnunet-service-fs_cp.c.

572 {
573  struct GSF_ConnectedPeer *cp;
574 
575  if (0 ==
577  peer))
578  return NULL;
580  "Connected to peer %s\n",
581  GNUNET_i2s (peer));
582  cp = GNUNET_new (struct GSF_ConnectedPeer);
583  cp->ppd.pid = GNUNET_PEER_intern (peer);
584  cp->ppd.peer = peer;
585  cp->mq = mq;
587  cp->rc =
589  peer,
590  DBLOCK_SIZE,
591  &ats_reserve_callback, cp);
593  GNUNET_YES);
597  cp),
598  cp,
601  gettext_noop ("# peers connected"),
603  GNUNET_NO);
606  "fs",
607  peer,
608  "respect",
610  cp);
612  cp);
613  return cp;
614 }
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
struct GNUNET_PeerIdentity GSF_my_id
Identity of this peer.
const struct GNUNET_PeerIdentity * GSF_connected_peer_get_identity2_(const struct GSF_ConnectedPeer *cp)
Obtain the identity of a connected peer.
static struct GNUNET_PEERSTORE_Handle * peerstore
Handle to peerstore service.
static void peer_respect_cb(void *cls, const struct GNUNET_PEERSTORE_Record *record, const char *emsg)
Function called by PEERSTORE with peer respect record.
static int consider_peer_for_forwarding(void *cls, const struct GNUNET_HashCode *key, struct GSF_PendingRequest *pr)
Function called for each pending request whenever a new peer connects, giving us a chance to decide a...
static struct GNUNET_CONTAINER_MultiPeerMap * cp_map
Map from peer identities to struct GSF_ConnectPeer entries.
void GSF_iterate_pending_requests_(GSF_PendingRequestIterator it, void *cls)
Iterate over all pending requests.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY
There must only be one value per key; storing a value should fail if a value under the same key alrea...
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
@ GNUNET_OK
struct GNUNET_LOAD_Value * GNUNET_LOAD_value_init(struct GNUNET_TIME_Relative autodecline)
Create a new load value.
Definition: load.c:125
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
GNUNET_PEER_Id GNUNET_PEER_intern(const struct GNUNET_PeerIdentity *pid)
Intern an peer identity.
Definition: peer.c:108
struct GNUNET_PEERSTORE_IterateContext * GNUNET_PEERSTORE_iterate(struct GNUNET_PEERSTORE_Handle *h, const char *sub_system, const struct GNUNET_PeerIdentity *peer, const char *key, GNUNET_PEERSTORE_Processor callback, void *callback_cls)
Iterate over records matching supplied key information.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
struct GNUNET_CONTAINER_MultiHashMap * request_map
Active requests from this neighbour, map of query to struct PeerRequest.
const struct GNUNET_PeerIdentity * peer
The peer's identity (pointer).
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.

References ats_reserve_callback(), consider_peer_for_forwarding(), cp_map, DBLOCK_SIZE, gettext_noop, GNUNET_ATS_reserve_bandwidth(), GNUNET_break, GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_put(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_LOAD_value_init(), GNUNET_log, GNUNET_memcmp, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_PEER_intern(), GNUNET_PEERSTORE_iterate(), GNUNET_STATISTICS_set(), GNUNET_TIME_UNIT_ZERO, GNUNET_YES, GSF_ats, GSF_connected_peer_get_identity2_(), GSF_iterate_pending_requests_(), GSF_my_id, GSF_stats, mq, GSF_ConnectedPeer::mq, GSF_PeerPerformanceData::peer, peer, peer_respect_cb(), peerstore, GSF_PeerPerformanceData::pid, GSF_ConnectedPeer::ppd, GSF_ConnectedPeer::rc, GSF_ConnectedPeer::request_map, GSF_ConnectedPeer::respect_iterate_req, and GSF_PeerPerformanceData::transmission_delay.

Referenced by main_init().

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

◆ revive_migration()

static void revive_migration ( void *  cls)
static

It may be time to re-start migrating content to this peer.

Check, and if so, restart migration.

Parameters
clsthe struct GSF_ConnectedPeer

Definition at line 624 of file gnunet-service-fs_cp.c.

625 {
626  struct GSF_ConnectedPeer *cp = cls;
627  struct GNUNET_TIME_Relative bt;
628 
629  cp->mig_revive_task = NULL;
631  if (0 != bt.rel_value_us)
632  {
633  /* still time left... */
634  cp->mig_revive_task =
636  return;
637  }
638  GSF_push_start_ (cp);
639 }
static void revive_migration(void *cls)
It may be time to re-start migrating content to this peer.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:405
Time for relative time used by GNUnet, in microseconds.
struct GNUNET_SCHEDULER_Task * mig_revive_task
Task scheduled to revive migration to this peer.
struct GNUNET_TIME_Absolute migration_blocked_until
Point in time until which this peer does not want us to migrate content to it.

References GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_absolute_get_remaining(), GSF_push_start_(), GSF_ConnectedPeer::mig_revive_task, GSF_PeerPerformanceData::migration_blocked_until, GSF_ConnectedPeer::ppd, and GNUNET_TIME_Relative::rel_value_us.

Referenced by handle_p2p_migration_stop().

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

◆ GSF_peer_get_()

struct GSF_ConnectedPeer* GSF_peer_get_ ( const struct GNUNET_PeerIdentity peer)

Get a handle for a connected peer.

Parameters
peerpeer's identity
Returns
NULL if this peer is not currently connected

Definition at line 643 of file gnunet-service-fs_cp.c.

644 {
645  if (NULL == cp_map)
646  return NULL;
648 }
void * GNUNET_CONTAINER_multipeermap_get(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Given a key find a value in the map matching the key.

References cp_map, GNUNET_CONTAINER_multipeermap_get(), and peer.

Referenced by GSF_update_peer_latency_(), handle_p2p_get(), and put_migration_continuation().

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

◆ handle_p2p_migration_stop()

void handle_p2p_migration_stop ( void *  cls,
const struct MigrationStopMessage msm 
)

Handle P2P GNUNET_MESSAGE_TYPE_FS_MIGRATION_STOP message.

Parameters
clsclosure, the struct GSF_ConnectedPeer
msmthe actual message

Definition at line 658 of file gnunet-service-fs_cp.c.

660 {
661  struct GSF_ConnectedPeer *cp = cls;
662  struct GNUNET_TIME_Relative bt;
663 
665  gettext_noop ("# migration stop messages received"),
666  1, GNUNET_NO);
669  _ ("Migration of content to peer `%s' blocked for %s\n"),
670  GNUNET_i2s (cp->ppd.peer),
673  if ((NULL == cp->mig_revive_task) &&
674  (NULL == cp->respect_iterate_req))
675  {
676  GSF_push_stop_ (cp);
677  cp->mig_revive_task =
679  &revive_migration, cp);
680  }
681 }
void GSF_push_stop_(struct GSF_ConnectedPeer *peer)
A peer disconnected from us.
@ GNUNET_ERROR_TYPE_INFO
struct GNUNET_TIME_Relative GNUNET_TIME_relative_ntoh(struct GNUNET_TIME_RelativeNBO a)
Convert relative time from network byte order.
Definition: time.c:628
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:316
#define _(String)
GNU gettext support macro.
Definition: platform.h:178
struct GNUNET_TIME_RelativeNBO duration
How long should the block last?

References _, MigrationStopMessage::duration, gettext_noop, GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_STATISTICS_update(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_relative_ntoh(), GNUNET_TIME_relative_to_absolute(), GNUNET_YES, GSF_push_stop_(), GSF_stats, GSF_ConnectedPeer::mig_revive_task, GSF_PeerPerformanceData::migration_blocked_until, GSF_PeerPerformanceData::peer, GSF_ConnectedPeer::ppd, GSF_ConnectedPeer::respect_iterate_req, and revive_migration().

Here is the call graph for this function:

◆ free_pending_request()

static void free_pending_request ( struct PeerRequest peerreq)
static

Free resources associated with the given peer request.

Parameters
peerreqrequest to free

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

691 {
692  struct GSF_ConnectedPeer *cp = peerreq->cp;
693  struct GSF_PendingRequestData *prd;
694 
695  prd = GSF_pending_request_get_data_ (peerreq->pr);
696  if (NULL != peerreq->kill_task)
697  {
699  peerreq->kill_task = NULL;
700  }
702  gettext_noop ("# P2P searches active"),
703  -1,
704  GNUNET_NO);
707  &prd->query,
708  peerreq));
709  GNUNET_free (peerreq);
710 }
struct GSF_PendingRequestData * GSF_pending_request_get_data_(struct GSF_PendingRequest *pr)
Obtain the public data associated with a pending request.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_remove(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, const void *value)
Remove the given key-value pair from the map.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:975
Public data (in the sense of not encapsulated within 'gnunet-service-fs_pr', not in the sense of netw...
struct GNUNET_HashCode query
Primary query hash for this request.
struct GSF_ConnectedPeer * cp
Which specific peer issued this request?
struct GSF_PendingRequest * pr
Handle to generic request (generic: from peer or local client).
struct GNUNET_SCHEDULER_Task * kill_task
Task for asynchronous stopping of this request.

References PeerRequest::cp, gettext_noop, GNUNET_break, GNUNET_CONTAINER_multihashmap_remove(), GNUNET_free, GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_update(), GNUNET_YES, GSF_pending_request_get_data_(), GSF_stats, PeerRequest::kill_task, PeerRequest::pr, GSF_PendingRequestData::query, and GSF_ConnectedPeer::request_map.

Referenced by cancel_pending_request(), handle_p2p_reply(), and test_exist_cb().

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

◆ cancel_pending_request()

static int cancel_pending_request ( void *  cls,
const struct GNUNET_HashCode query,
void *  value 
)
static

Cancel all requests associated with the peer.

Parameters
clsunused
queryhash code of the request
valuethe struct GSF_PendingRequest
Returns
GNUNET_YES (continue to iterate)

Definition at line 722 of file gnunet-service-fs_cp.c.

725 {
726  struct PeerRequest *peerreq = value;
727  struct GSF_PendingRequest *pr = peerreq->pr;
728 
729  free_pending_request (peerreq);
731  GNUNET_NO);
732  return GNUNET_OK;
733 }
static char * value
Value of the record to add/remove.
static void free_pending_request(struct PeerRequest *peerreq)
Free resources associated with the given peer request.
void GSF_pending_request_cancel_(struct GSF_PendingRequest *pr, int full_cleanup)
Explicitly cancel a pending request.
An active request.
Information per peer and request.

References free_pending_request(), GNUNET_NO, GNUNET_OK, GSF_pending_request_cancel_(), PeerRequest::pr, and value.

Referenced by GSF_peer_disconnect_handler(), and peer_request_destroy().

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

◆ peer_request_destroy()

static void peer_request_destroy ( void *  cls)
static

Free the given request.

Parameters
clsthe request to free

Definition at line 742 of file gnunet-service-fs_cp.c.

743 {
744  struct PeerRequest *peerreq = cls;
745  struct GSF_PendingRequest *pr = peerreq->pr;
746  struct GSF_PendingRequestData *prd;
747 
748  peerreq->kill_task = NULL;
751  &prd->query,
752  peerreq);
753 }
static int cancel_pending_request(void *cls, const struct GNUNET_HashCode *query, void *value)
Cancel all requests associated with the peer.

References cancel_pending_request(), GSF_pending_request_get_data_(), PeerRequest::kill_task, PeerRequest::pr, and GSF_PendingRequestData::query.

Referenced by handle_p2p_reply().

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

◆ transmit_delayed_now()

static void transmit_delayed_now ( void *  cls)
static

The artificial delay is over, transmit the message now.

Parameters
clsthe struct GSF_DelayedHandle with the message

Definition at line 762 of file gnunet-service-fs_cp.c.

763 {
764  struct GSF_DelayedHandle *dh = cls;
765  struct GSF_ConnectedPeer *cp = dh->cp;
766 
768  cp->delayed_tail,
769  dh);
770  cp->delay_queue_size--;
771  GSF_peer_transmit_ (cp,
772  GNUNET_NO,
773  UINT32_MAX,
774  dh->env);
775  GNUNET_free (dh);
776 }
void GSF_peer_transmit_(struct GSF_ConnectedPeer *cp, int is_query, uint32_t priority, struct GNUNET_MQ_Envelope *env)
Transmit a message to the given peer as soon as possible.
struct GSF_DelayedHandle * delayed_tail
Messages (replies, queries, content migration) we would like to send to this peer in the near future.
unsigned int delay_queue_size
Number of entries in delayed_head DLL.
struct GSF_DelayedHandle * delayed_head
Messages (replies, queries, content migration) we would like to send to this peer in the near future.
Handle for an entry in our delay list.
struct GSF_ConnectedPeer * cp
Peer this transmission belongs to.
struct GNUNET_MQ_Envelope * env
Envelope of the message that was delayed.

Referenced by handle_p2p_reply().

Here is the caller graph for this function:

◆ get_randomized_delay()

static struct GNUNET_TIME_Relative get_randomized_delay ( )
static

Get the randomized delay a response should be subjected to.

Returns
desired delay

Definition at line 762 of file gnunet-service-fs_cp.c.

786 {
787  struct GNUNET_TIME_Relative ret;
788 
789  ret =
793  2 * GSF_avg_latency.rel_value_us + 1));
794 #if INSANE_STATISTICS
797  ("# artificial delays introduced (ms)"),
798  ret.rel_value_us / 1000LL, GNUNET_NO);
799 #endif
800  return ret;
801 }
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
struct GNUNET_TIME_Relative GSF_avg_latency
Running average of the observed latency to other peers (round trip).
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
@ GNUNET_CRYPTO_QUALITY_WEAK
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
#define GNUNET_TIME_UNIT_MILLISECONDS
One millisecond.

References GSF_DelayedHandle::cp, GSF_ConnectedPeer::delay_queue_size, GSF_ConnectedPeer::delayed_head, GSF_ConnectedPeer::delayed_tail, GSF_DelayedHandle::env, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_NO, and GSF_peer_transmit_().

Referenced by handle_p2p_reply().

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

◆ handle_p2p_reply()

static void handle_p2p_reply ( 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 
)
static

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
clsstruct PeerRequest this is an answer for
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_transmissionwhen did we last transmit a request for this block
typetype of the block
dataresponse data, NULL on request expiration
data_lennumber of bytes in data

Definition at line 823 of file gnunet-service-fs_cp.c.

832 {
833  struct PeerRequest *peerreq = cls;
834  struct GSF_ConnectedPeer *cp = peerreq->cp;
835  struct GSF_PendingRequestData *prd;
836  struct GNUNET_MQ_Envelope *env;
837  struct PutMessage *pm;
838  size_t msize;
839 
840  GNUNET_assert (data_len + sizeof(struct PutMessage) <
842  GNUNET_assert (peerreq->pr == pr);
844  if (NULL == data)
845  {
846  free_pending_request (peerreq);
847  return;
848  }
850  if ( (prd->type != type) &&
851  (GNUNET_BLOCK_TYPE_ANY != prd->type) )
852  {
854  "# replies dropped due to type mismatch",
855  1, GNUNET_NO);
856  return;
857  }
859  "Transmitting result for query `%s' to peer\n",
860  GNUNET_h2s (&prd->query));
862  "# replies received for other peers",
863  1,
864  GNUNET_NO);
865  msize = sizeof(struct PutMessage) + data_len;
866  if (msize >= GNUNET_MAX_MESSAGE_SIZE)
867  {
868  GNUNET_break (0);
869  return;
870  }
871  if ( (UINT32_MAX != reply_anonymity_level) &&
872  (reply_anonymity_level > 1) )
873  {
874  if (reply_anonymity_level - 1 > GSF_cover_content_count)
875  {
877  "# replies dropped due to insufficient cover traffic",
878  1, GNUNET_NO);
879  return;
880  }
881  GSF_cover_content_count -= (reply_anonymity_level - 1);
882  }
883 
885  data_len,
887  pm->type = htonl (type);
888  pm->expiration = GNUNET_TIME_absolute_hton (expiration);
889  GNUNET_memcpy (&pm[1],
890  data,
891  data_len);
892  if ((UINT32_MAX != reply_anonymity_level) &&
893  (0 != reply_anonymity_level) &&
895  {
896  struct GSF_DelayedHandle *dh;
897 
898  dh = GNUNET_new (struct GSF_DelayedHandle);
899  dh->cp = cp;
900  dh->env = env;
901  dh->msize = msize;
903  cp->delayed_tail,
904  dh);
905  cp->delay_queue_size++;
906  dh->delay_task =
909  dh);
910  }
911  else
912  {
914  GNUNET_NO,
915  UINT32_MAX,
916  env);
917  }
918  if (GNUNET_BLOCK_REPLY_OK_LAST != eval)
919  return;
920  if (NULL == peerreq->kill_task)
921  {
923  "# P2P searches destroyed due to ultimate reply",
924  1,
925  GNUNET_NO);
926  peerreq->kill_task =
928  peerreq);
929  }
930 }
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
@ GNUNET_BLOCK_TYPE_ANY
Identifier for any block.
static char * expiration
Credential TTL.
Definition: gnunet-abd.c:96
uint32_t data
The data value.
int GSF_enable_randomized_delays
Are we introducing randomized delays for better anonymity?
unsigned int GSF_cover_content_count
How many content messages have we received 'recently' that have not yet been claimed as cover traffic...
static struct GNUNET_TIME_Relative get_randomized_delay()
Get the randomized delay a response should be subjected to.
static void transmit_delayed_now(void *cls)
The artificial delay is over, transmit the message now.
static void peer_request_destroy(void *cls)
Free the given request.
static struct GNUNET_TRANSPORT_PluginMonitor * pm
Handle if we are monitoring plugin session activity.
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message,...
@ GNUNET_BLOCK_REPLY_OK_LAST
Last possible valid result.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
Definition: gnunet_mq_lib.h:63
#define GNUNET_MESSAGE_TYPE_FS_PUT
P2P response with content or active migration of content.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1299
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:638
struct GNUNET_SCHEDULER_Task * delay_task
Task for the delay.
size_t msize
Size of the message.
enum GNUNET_BLOCK_Type type
Type of the requested block.
Response from FS service with a result for a previous FS search.
Definition: fs.h:330
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model

References GSF_DelayedHandle::cp, PeerRequest::cp, data, GSF_ConnectedPeer::delay_queue_size, GSF_DelayedHandle::delay_task, GSF_ConnectedPeer::delayed_head, GSF_ConnectedPeer::delayed_tail, env, GSF_DelayedHandle::env, expiration, free_pending_request(), get_randomized_delay(), GNUNET_assert, GNUNET_BLOCK_REPLY_OK_LAST, GNUNET_BLOCK_TYPE_ANY, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_FS_PUT, GNUNET_MQ_msg_extra, GNUNET_new, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_hton(), GNUNET_YES, GSF_cover_content_count, GSF_enable_randomized_delays, GSF_peer_transmit_(), GSF_pending_request_get_data_(), GSF_stats, PeerRequest::kill_task, GSF_DelayedHandle::msize, peer_request_destroy(), pm, PeerRequest::pr, GSF_PendingRequestData::query, transmit_delayed_now(), GSF_PendingRequestData::type, and type.

Referenced by handle_p2p_get().

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

◆ change_peer_respect()

static int change_peer_respect ( struct GSF_ConnectedPeer cp,
int  value 
)
static

Increase the peer's respect by a value.

Parameters
cpwhich peer to change the respect value on
valueis the int value by which the peer's credit is to be increased or decreased
Returns
the actual change in respect (positive or negative)

Definition at line 942 of file gnunet-service-fs_cp.c.

943 {
944  if (0 == value)
945  return 0;
946  GNUNET_assert (NULL != cp);
947  if (value > 0)
948  {
949  if (cp->ppd.respect + value < cp->ppd.respect)
950  {
951  value = UINT32_MAX - cp->ppd.respect;
952  cp->ppd.respect = UINT32_MAX;
953  }
954  else
955  cp->ppd.respect += value;
956  }
957  else
958  {
959  if (cp->ppd.respect < -value)
960  {
961  value = -cp->ppd.respect;
962  cp->ppd.respect = 0;
963  }
964  else
965  cp->ppd.respect += value;
966  }
967  return value;
968 }

References GSF_DelayedHandle::cp, GNUNET_assert, GSF_ConnectedPeer::ppd, GSF_PeerPerformanceData::respect, and value.

Referenced by bound_priority().

Here is the caller graph for this function:

◆ bound_priority()

static int32_t bound_priority ( uint32_t  prio_in,
struct GSF_ConnectedPeer cp 
)
static

We've received a request with the specified priority.

Bound it according to how much we respect the given peer.

Parameters
prio_inrequested priority
cpthe peer making the request
Returns
effective priority

Definition at line 980 of file gnunet-service-fs_cp.c.

982 {
983 #define N ((double) 128.0)
984  uint32_t ret;
985  double rret;
986  int ld;
987 
989  if (GNUNET_SYSERR == ld)
990  {
991 #if INSANE_STATISTICS
994  ("# requests done for free (low load)"), 1,
995  GNUNET_NO);
996 #endif
997  return 0; /* excess resources */
998  }
999  if (prio_in > INT32_MAX)
1000  prio_in = INT32_MAX;
1001  ret = -change_peer_respect (cp, -(int) prio_in);
1002  if (ret > 0)
1003  {
1004  if (ret > GSF_current_priorities + N)
1005  rret = GSF_current_priorities + N;
1006  else
1007  rret = ret;
1008  GSF_current_priorities = (GSF_current_priorities * (N - 1) + rret) / N;
1009  }
1010  if ((GNUNET_YES == ld) && (ret > 0))
1011  {
1012  /* try with charging */
1014  }
1015  if (GNUNET_YES == ld)
1016  {
1018  gettext_noop
1019  ("# request dropped, priority insufficient"), 1,
1020  GNUNET_NO);
1021  /* undo charge */
1022  change_peer_respect (cp, (int) ret);
1023  return -1; /* not enough resources */
1024  }
1025  else
1026  {
1028  gettext_noop
1029  ("# requests done for a price (normal load)"),
1030  1,
1031  GNUNET_NO);
1032  }
1033 #undef N
1034  return ret;
1035 }
int GSF_test_get_load_too_high_(uint32_t priority)
Test if the DATABASE (GET) load on this peer is too high to even consider processing the query at all...
double GSF_current_priorities
Typical priorities we're seeing from other peers right now.
#define N
static int change_peer_respect(struct GSF_ConnectedPeer *cp, int value)
Increase the peer's respect by a value.
@ GNUNET_SYSERR

References change_peer_respect(), GSF_DelayedHandle::cp, gettext_noop, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_YES, GSF_current_priorities, GSF_stats, GSF_test_get_load_too_high_(), N, and ret.

Referenced by handle_p2p_get().

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

◆ bound_ttl()

static int32_t bound_ttl ( int32_t  ttl_in,
uint32_t  prio 
)
static

The priority level imposes a bound on the maximum value for the ttl that can be requested.

Parameters
ttl_inrequested ttl
priogiven priority
Returns
ttl_in if ttl_in is below the limit, otherwise the ttl-limit for the given prio

Definition at line 1048 of file gnunet-service-fs_cp.c.

1050 {
1051  unsigned long long allowed;
1052 
1053  if (ttl_in <= 0)
1054  return ttl_in;
1055  allowed = ((unsigned long long) prio) * TTL_DECREMENT / 1000;
1056  if (ttl_in > allowed)
1057  {
1058  if (allowed >= (1 << 30))
1059  return 1 << 30;
1060  return allowed;
1061  }
1062  return ttl_in;
1063 }
#define TTL_DECREMENT
By which amount do we decrement the TTL for simple forwarding / indirection of the query; in milli-se...

References TTL_DECREMENT.

Referenced by handle_p2p_get().

Here is the caller graph for this function:

◆ test_exist_cb()

static int test_exist_cb ( void *  cls,
const struct GNUNET_HashCode hc,
void *  value 
)
static

Test if the query already exists.

If so, merge it, otherwise keep finished at GNUNET_NO.

Parameters
clsour struct TestExistClosure
hcthe key of the query
valuethe existing struct PeerRequest.
Returns
GNUNET_YES to continue to iterate, GNUNET_NO if we successfully merged

Definition at line 1104 of file gnunet-service-fs_cp.c.

1107 {
1108  struct TestExistClosure *tec = cls;
1109  struct PeerRequest *peerreq = value;
1110  struct GSF_PendingRequest *pr;
1111  struct GSF_PendingRequestData *prd;
1112 
1113  pr = peerreq->pr;
1114  prd = GSF_pending_request_get_data_ (pr);
1115  if (prd->type != tec->type)
1116  return GNUNET_YES;
1117  if (prd->ttl.abs_value_us >=
1118  GNUNET_TIME_absolute_get ().abs_value_us + tec->ttl * 1000LL)
1119  {
1120  /* existing request has higher TTL, drop new one! */
1121  prd->priority += tec->priority;
1123  "Have existing request with higher TTL, dropping new request.\n");
1125  gettext_noop
1126  ("# requests dropped due to higher-TTL request"),
1127  1, GNUNET_NO);
1128  tec->finished = GNUNET_YES;
1129  return GNUNET_NO;
1130  }
1131  /* existing request has lower TTL, drop old one! */
1132  tec->priority += prd->priority;
1133  free_pending_request (peerreq);
1135  GNUNET_YES);
1136  return GNUNET_NO;
1137 }
uint64_t abs_value_us
The actual value.
struct GNUNET_TIME_Absolute ttl
Current TTL for the request.
uint32_t priority
Priority that this request (still) has for us.
Closure for test_exist_cb().
int finished
Set to GNUNET_YES if we are done handling the query.
int32_t ttl
Relative TTL of the incoming request.
int32_t priority
Priority of the incoming request.
enum GNUNET_BLOCK_Type type
Type of the incoming request.

References GNUNET_TIME_Absolute::abs_value_us, TestExistClosure::finished, free_pending_request(), gettext_noop, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_get(), GNUNET_YES, GSF_pending_request_cancel_(), GSF_pending_request_get_data_(), GSF_stats, PeerRequest::pr, TestExistClosure::priority, GSF_PendingRequestData::priority, TestExistClosure::ttl, GSF_PendingRequestData::ttl, TestExistClosure::type, GSF_PendingRequestData::type, and value.

Referenced by handle_p2p_get().

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

◆ handle_p2p_get()

void handle_p2p_get ( void *  cls,
const struct GetMessage gm 
)

Handle P2P "QUERY" message.

Creates the pending request entry and sets up all of the data structures to that we will process replies properly. Does not initiate forwarding or local database lookups.

Parameters
clsthe other peer involved (sender of the message)
gmthe GET message

Definition at line 1150 of file gnunet-service-fs_cp.c.

1152 {
1153  struct GSF_ConnectedPeer *cps = cls;
1154  struct PeerRequest *peerreq;
1155  struct GSF_PendingRequest *pr;
1156  struct GSF_ConnectedPeer *cp;
1157  const struct GNUNET_PeerIdentity *target;
1159  uint16_t msize;
1160  unsigned int bits;
1161  const struct GNUNET_PeerIdentity *opt;
1162  uint32_t bm;
1163  size_t bfsize;
1164  uint32_t ttl_decrement;
1165  struct TestExistClosure tec;
1166  GNUNET_PEER_Id spid;
1167  const struct GSF_PendingRequestData *prd;
1168 
1169  msize = ntohs (gm->header.size);
1170  tec.type = ntohl (gm->type);
1171  bm = ntohl (gm->hash_bitmap);
1172  bits = 0;
1173  while (bm > 0)
1174  {
1175  if (1 == (bm & 1))
1176  bits++;
1177  bm >>= 1;
1178  }
1179  opt = (const struct GNUNET_PeerIdentity *) &gm[1];
1180  bfsize = msize - sizeof(struct GetMessage) - bits * sizeof(struct
1183  gettext_noop
1184  ("# GET requests received (from other peers)"),
1185  1,
1186  GNUNET_NO);
1188  bm = ntohl (gm->hash_bitmap);
1189  bits = 0;
1190  if (0 != (bm & GET_MESSAGE_BIT_RETURN_TO))
1191  cp = GSF_peer_get_ (&opt[bits++]);
1192  else
1193  cp = cps;
1194  if (NULL == cp)
1195  {
1196  if (0 != (bm & GET_MESSAGE_BIT_RETURN_TO))
1198  "Failed to find RETURN-TO peer `%s' in connection set. Dropping query.\n",
1199  GNUNET_i2s (&opt[bits - 1]));
1200 
1201  else
1203  "Failed to find peer `%s' in connection set. Dropping query.\n",
1204  GNUNET_i2s (cps->ppd.peer));
1206  gettext_noop
1207  (
1208  "# requests dropped due to missing reverse route"),
1209  1,
1210  GNUNET_NO);
1211  return;
1212  }
1213  unsigned int queue_size = GNUNET_MQ_get_length (cp->mq);
1214  queue_size += cp->ppd.pending_replies + cp->delay_queue_size;
1215  if (queue_size > MAX_QUEUE_PER_PEER)
1216  {
1218  "Peer `%s' has too many replies queued already. Dropping query.\n",
1219  GNUNET_i2s (cps->ppd.peer));
1221  gettext_noop (
1222  "# requests dropped due to full reply queue"),
1223  1,
1224  GNUNET_NO);
1225  return;
1226  }
1227  /* note that we can really only check load here since otherwise
1228  * peers could find out that we are overloaded by not being
1229  * disconnected after sending us a malformed query... */
1230  tec.priority = bound_priority (ntohl (gm->priority),
1231  cps);
1232  if (tec.priority < 0)
1233  {
1235  "Dropping query from `%s', this peer is too busy.\n",
1236  GNUNET_i2s (cps->ppd.peer));
1237  return;
1238  }
1240  "Received request for `%s' of type %u from peer `%s' with flags %u\n",
1241  GNUNET_h2s (&gm->query),
1242  (unsigned int) tec.type,
1243  GNUNET_i2s (cps->ppd.peer),
1244  (unsigned int) bm);
1245  target =
1246  (0 !=
1247  (bm & GET_MESSAGE_BIT_TRANSMIT_TO)) ? (&opt[bits++]) : NULL;
1249  spid = 0;
1250  if ((GNUNET_LOAD_get_load (cp->ppd.transmission_delay) > 3 * (1
1251  + tec.priority))
1253  GNUNET_CONSTANTS_MAX_CORK_DELAY.rel_value_us * 2
1255  {
1256  /* don't have BW to send to peer, or would likely take longer than we have for it,
1257  * so at best indirect the query */
1258  tec.priority = 0;
1260  spid = GNUNET_PEER_intern (cps->ppd.peer);
1261  GNUNET_assert (0 != spid);
1262  }
1263  tec.ttl = bound_ttl (ntohl (gm->ttl),
1264  tec.priority);
1265  /* decrement ttl (always) */
1266  ttl_decrement =
1268  TTL_DECREMENT);
1269  if ((tec.ttl < 0) &&
1270  (((int32_t) (tec.ttl - ttl_decrement)) > 0))
1271  {
1273  "Dropping query from `%s' due to TTL underflow (%d - %u).\n",
1274  GNUNET_i2s (cps->ppd.peer),
1275  tec.ttl,
1276  ttl_decrement);
1278  gettext_noop
1279  ("# requests dropped due TTL underflow"), 1,
1280  GNUNET_NO);
1281  /* integer underflow => drop (should be very rare)! */
1282  return;
1283  }
1284  tec.ttl -= ttl_decrement;
1285 
1286  /* test if the request already exists */
1287  tec.finished = GNUNET_NO;
1289  &gm->query,
1290  &test_exist_cb,
1291  &tec);
1292  if (GNUNET_YES == tec.finished)
1293  return; /* merged into existing request, we're done */
1294 
1295  peerreq = GNUNET_new (struct PeerRequest);
1296  peerreq->cp = cp;
1298  tec.type,
1299  &gm->query,
1300  target,
1301  (bfsize > 0)
1302  ? (const char *) &opt[bits]
1303  : NULL,
1304  bfsize,
1305  1 /* anonymity */,
1306  (uint32_t) tec.priority,
1307  tec.ttl,
1308  spid,
1309  GNUNET_PEER_intern (cps->ppd.peer),
1310  NULL, 0, /* replies_seen */
1312  peerreq);
1313  GNUNET_assert (NULL != pr);
1314  prd = GSF_pending_request_get_data_ (pr);
1315  peerreq->pr = pr;
1318  &prd->query,
1319  peerreq,
1322  gettext_noop (
1323  "# P2P query messages received and processed"),
1324  1,
1325  GNUNET_NO);
1327  gettext_noop ("# P2P searches active"),
1328  1,
1329  GNUNET_NO);
1331  GSF_local_lookup_ (pr,
1333  NULL);
1334 }
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
unsigned int GSF_cover_query_count
How many query messages have we received 'recently' that have not yet been claimed as cover traffic?
void GSF_consider_forwarding(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.
struct GNUNET_LOAD_Value * GSF_rt_entry_lifetime
How long do requests typically stay in the routing table?
#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 ...
#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...
static void handle_p2p_reply(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.
static int test_exist_cb(void *cls, const struct GNUNET_HashCode *hc, void *value)
Test if the query already exists.
static int32_t bound_priority(uint32_t prio_in, struct GSF_ConnectedPeer *cp)
We've received a request with the specified priority.
static int32_t bound_ttl(int32_t ttl_in, uint32_t prio)
The priority level imposes a bound on the maximum value for the ttl that can be requested.
void GSF_local_lookup_(struct GSF_PendingRequest *pr, GSF_LocalLookupContinuation cont, void *cont_cls)
Look up the request in the local datastore.
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.
GSF_PendingRequestOptions
Options for pending requests (bits to be ORed).
@ GSF_PRO_DEFAULTS
No special options (P2P-default).
@ GSF_PRO_FORWARD_ONLY
Request must only be forwarded (no routing)
#define GNUNET_CONSTANTS_MAX_CORK_DELAY
How long do we delay messages to get larger packet sizes (CORKing)?
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_get_multiple(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, GNUNET_CONTAINER_MultiHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map that match a particular key.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE
Allow multiple values with the same key.
double GNUNET_LOAD_get_average(struct GNUNET_LOAD_Value *load)
Get the average value given to update so far.
Definition: load.c:216
double GNUNET_LOAD_get_load(struct GNUNET_LOAD_Value *load)
Get the current load.
Definition: load.c:201
unsigned int GNUNET_MQ_get_length(struct GNUNET_MQ_Handle *mq)
Obtain the current length of the message queue.
Definition: mq.c:293
unsigned int GNUNET_PEER_Id
A GNUNET_PEER_Id is simply a shorter version of a "struct GNUNET_PeerIdentifier" that can be used ins...
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
int has_started
Has this request been started yet (local/p2p operations)? Or are we still constructing it?
Message to the datastore service asking about specific content.
Definition: datastore.h:141
uint32_t type
Desired content type.
Definition: datastore.h:150
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_DATASTORE_GET.
Definition: datastore.h:145
uint32_t priority
How important is this request (network byte order)
struct GNUNET_HashCode query
Hashcodes of the file(s) we're looking for.
int32_t ttl
Relative time to live in MILLISECONDS (network byte order)
uint32_t hash_bitmap
Which of the optional hash codes are present at the end of the message? See GET_MESSAGE_BIT_xx consta...

References bound_priority(), bound_ttl(), PeerRequest::cp, GSF_ConnectedPeer::delay_queue_size, TestExistClosure::finished, GET_MESSAGE_BIT_RETURN_TO, GET_MESSAGE_BIT_TRANSMIT_TO, gettext_noop, GNUNET_assert, GNUNET_break, GNUNET_CONSTANTS_MAX_CORK_DELAY, GNUNET_CONTAINER_multihashmap_get_multiple(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_i2s(), GNUNET_LOAD_get_average(), GNUNET_LOAD_get_load(), GNUNET_log, GNUNET_MQ_get_length(), GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_PEER_intern(), GNUNET_STATISTICS_update(), GNUNET_YES, GSF_consider_forwarding(), GSF_cover_query_count, GSF_local_lookup_(), GSF_peer_get_(), GSF_pending_request_create_(), GSF_pending_request_get_data_(), GSF_PRO_DEFAULTS, GSF_PRO_FORWARD_ONLY, GSF_rt_entry_lifetime, GSF_stats, handle_p2p_reply(), GSF_PendingRequestData::has_started, GetMessage::hash_bitmap, GetMessage::header, MAX_QUEUE_PER_PEER, GSF_ConnectedPeer::mq, options, GSF_PeerPerformanceData::peer, GSF_PeerPerformanceData::pending_replies, GSF_ConnectedPeer::ppd, PeerRequest::pr, GetMessage::priority, TestExistClosure::priority, GetMessage::query, GSF_PendingRequestData::query, GSF_ConnectedPeer::request_map, GNUNET_MessageHeader::size, test_exist_cb(), GSF_PeerPerformanceData::transmission_delay, GetMessage::ttl, TestExistClosure::ttl, TTL_DECREMENT, GetMessage::type, and TestExistClosure::type.

Here is the call graph for this function:

◆ GSF_peer_transmit_()

void GSF_peer_transmit_ ( struct GSF_ConnectedPeer cp,
int  is_query,
uint32_t  priority,
struct GNUNET_MQ_Envelope env 
)

Transmit a message to the given peer as soon as possible.

If the peer disconnects before the transmission can happen, the callback is invoked with a NULL buffer.

Parameters
cptarget peer
is_queryis this a query (GNUNET_YES) or content (GNUNET_NO) or neither (GNUNET_SYSERR)
priorityhow important is this request?
envmessage to send

Definition at line 1348 of file gnunet-service-fs_cp.c.

1352 {
1353  struct GSF_PeerTransmitHandle *pth;
1354  struct GSF_PeerTransmitHandle *pos;
1355  struct GSF_PeerTransmitHandle *prev;
1356 
1357  pth = GNUNET_new (struct GSF_PeerTransmitHandle);
1359  pth->env = env;
1360  pth->is_query = is_query;
1361  pth->priority = priority;
1362  pth->cp = cp;
1363  /* insertion sort (by priority, descending) */
1364  prev = NULL;
1365  pos = cp->pth_head;
1366  while ((NULL != pos) && (pos->priority > priority))
1367  {
1368  prev = pos;
1369  pos = pos->next;
1370  }
1372  cp->pth_tail,
1373  prev,
1374  pth);
1375  if (GNUNET_YES == is_query)
1376  cp->ppd.pending_queries++;
1377  else if (GNUNET_NO == is_query)
1378  cp->ppd.pending_replies++;
1379  schedule_transmission (pth);
1380 }
#define GNUNET_CONTAINER_DLL_insert_after(head, tail, other, element)
Insert an element into a DLL after the given other element.
struct GSF_PeerTransmitHandle * next
Kept in a doubly-linked list.
uint32_t priority
Priority of this request.
struct GSF_PeerTransmitHandle * prev
Kept in a doubly-linked list.

References GSF_PeerTransmitHandle::cp, env, GSF_PeerTransmitHandle::env, GNUNET_CONTAINER_DLL_insert_after, GNUNET_new, GNUNET_NO, GNUNET_TIME_absolute_get(), GNUNET_YES, GSF_PeerTransmitHandle::is_query, GSF_PeerTransmitHandle::next, GSF_PeerPerformanceData::pending_queries, GSF_PeerPerformanceData::pending_replies, GSF_ConnectedPeer::ppd, GSF_PeerTransmitHandle::prev, GSF_PeerTransmitHandle::priority, GSF_ConnectedPeer::pth_head, GSF_ConnectedPeer::pth_tail, schedule_transmission(), and GSF_PeerTransmitHandle::transmission_request_start_time.

Referenced by get_randomized_delay(), GSF_block_peer_migration_(), handle_p2p_reply(), schedule_peer_transmission(), and transmit_content().

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

◆ GSF_peer_update_performance_()

void GSF_peer_update_performance_ ( struct GSF_ConnectedPeer cp,
struct GNUNET_TIME_Absolute  request_time,
uint32_t  request_priority 
)

Report on receiving a reply; update the performance record of the given peer.

Parameters
cpresponding peer (will be updated)
request_timetime at which the original query was transmitted
request_prioritypriority of the original request

Definition at line 1391 of file gnunet-service-fs_cp.c.

1394 {
1395  struct GNUNET_TIME_Relative delay;
1396 
1397  delay = GNUNET_TIME_absolute_get_duration (request_time);
1401  cp->ppd.avg_priority =
1402  (cp->ppd.avg_priority * (RUNAVG_DELAY_N - 1)
1403  + request_priority) / RUNAVG_DELAY_N;
1404 }
static struct GNUNET_TIME_Relative delay
When should dkg communication start?
#define RUNAVG_DELAY_N
Ratio for moving average delay calculation.
double avg_priority
Average priority of successful replies.
struct GNUNET_TIME_Relative avg_reply_delay
Average delay between sending the peer a request and getting a reply (only calculated over the reques...

References GSF_PeerPerformanceData::avg_priority, GSF_PeerPerformanceData::avg_reply_delay, delay, GNUNET_TIME_absolute_get_duration(), GSF_ConnectedPeer::ppd, GNUNET_TIME_Relative::rel_value_us, and RUNAVG_DELAY_N.

Referenced by process_reply().

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

◆ GSF_peer_update_responder_client_()

void GSF_peer_update_responder_client_ ( struct GSF_ConnectedPeer cp,
struct GSF_LocalClient initiator_client 
)

Report on receiving a reply in response to an initiating client.

Remember that this peer is good for this client.

Parameters
cpresponding peer (will be updated)
initiator_clientlocal client on responsible for query

Definition at line 1415 of file gnunet-service-fs_cp.c.

1417 {
1419  % CS2P_SUCCESS_LIST_SIZE] = initiator_client;
1420 }
#define CS2P_SUCCESS_LIST_SIZE
Length of the CS-2-P success tracker.
unsigned int last_client_replies_woff
Which offset in last_client_replies will be updated next? (we go round-robin).
struct GSF_LocalClient * last_client_replies[8]
List of the last clients for which this peer successfully answered a query.

References CS2P_SUCCESS_LIST_SIZE, GSF_PeerPerformanceData::last_client_replies, GSF_ConnectedPeer::last_client_replies_woff, and GSF_ConnectedPeer::ppd.

◆ GSF_peer_update_responder_peer_()

void GSF_peer_update_responder_peer_ ( struct GSF_ConnectedPeer cp,
const struct GSF_ConnectedPeer initiator_peer 
)

Report on receiving a reply in response to an initiating peer.

Remember that this peer is good for this initiating peer.

Parameters
cpresponding peer (will be updated)
initiator_peerother peer responsible for query

Definition at line 1431 of file gnunet-service-fs_cp.c.

1433 {
1434  unsigned int woff;
1435 
1437  GNUNET_PEER_change_rc (cp->ppd.last_p2p_replies[woff], -1);
1438  cp->ppd.last_p2p_replies[woff] = initiator_peer->ppd.pid;
1439  GNUNET_PEER_change_rc (initiator_peer->ppd.pid, 1);
1440  cp->last_p2p_replies_woff = (woff + 1) % P2P_SUCCESS_LIST_SIZE;
1441 }
#define P2P_SUCCESS_LIST_SIZE
Length of the P2P success tracker.
void GNUNET_PEER_change_rc(GNUNET_PEER_Id id, int delta)
Change the reference counter of an interned PID.
Definition: peer.c:192
unsigned int last_p2p_replies_woff
Which offset in last_p2p_replies will be updated next? (we go round-robin).
GNUNET_PEER_Id last_p2p_replies[8]
List of the last PIDs for which this peer successfully answered a query; We use 0 to indicate no succ...

References GNUNET_PEER_change_rc(), GSF_PeerPerformanceData::last_p2p_replies, GSF_ConnectedPeer::last_p2p_replies_woff, P2P_SUCCESS_LIST_SIZE, GSF_PeerPerformanceData::pid, and GSF_ConnectedPeer::ppd.

Here is the call graph for this function:

◆ flush_respect()

static int flush_respect ( void *  cls,
const struct GNUNET_PeerIdentity key,
void *  value 
)
static

Write peer-respect information to a file - flush the buffer entry!

Parameters
clsunused
keypeer identity
valuethe struct GSF_ConnectedPeer to flush
Returns
GNUNET_OK to continue iteration

Definition at line 1453 of file gnunet-service-fs_cp.c.

1456 {
1457  struct GSF_ConnectedPeer *cp = value;
1458  struct GNUNET_PeerIdentity pid;
1459 
1460  if (cp->ppd.respect == cp->disk_respect)
1461  return GNUNET_OK; /* unchanged */
1462  GNUNET_assert (0 != cp->ppd.pid);
1463  GNUNET_PEER_resolve (cp->ppd.pid, &pid);
1464  GNUNET_PEERSTORE_store (peerstore, "fs", &pid, "respect", &cp->ppd.respect,
1465  sizeof(cp->ppd.respect),
1468  NULL,
1469  NULL);
1470  return GNUNET_OK;
1471 }
struct GNUNET_PEERSTORE_StoreContext * GNUNET_PEERSTORE_store(struct GNUNET_PEERSTORE_Handle *h, const char *sub_system, const struct GNUNET_PeerIdentity *peer, const char *key, const void *value, size_t size, struct GNUNET_TIME_Absolute expiry, enum GNUNET_PEERSTORE_StoreOption options, GNUNET_PEERSTORE_Continuation cont, void *cont_cls)
Store a new entry in the PEERSTORE.
@ GNUNET_PEERSTORE_STOREOPTION_REPLACE
Delete any previous values for the given key before storing the given value.
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".

References GSF_ConnectedPeer::disk_respect, GNUNET_assert, GNUNET_OK, GNUNET_PEER_resolve(), GNUNET_PEERSTORE_store(), GNUNET_PEERSTORE_STOREOPTION_REPLACE, GNUNET_TIME_UNIT_FOREVER_ABS, peerstore, GSF_PeerPerformanceData::pid, pid, GSF_ConnectedPeer::ppd, GSF_PeerPerformanceData::respect, and value.

Referenced by cron_flush_respect(), GSF_connected_peer_done_(), and GSF_peer_disconnect_handler().

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

◆ GSF_peer_disconnect_handler()

void GSF_peer_disconnect_handler ( void *  cls,
const struct GNUNET_PeerIdentity peer,
void *  internal_cls 
)

A peer disconnected from us.

Tear down the connected peer record.

Parameters
clsunused
peeridentity of peer that disconnected
internal_clsthe corresponding struct GSF_ConnectedPeer

Definition at line 1475 of file gnunet-service-fs_cp.c.

1478 {
1479  struct GSF_ConnectedPeer *cp = internal_cls;
1480  struct GSF_PeerTransmitHandle *pth;
1481  struct GSF_DelayedHandle *dh;
1482 
1483  if (NULL == cp)
1484  return; /* must have been disconnect from core with
1485  * 'peer' == my_id, ignore */
1486  flush_respect (NULL,
1487  peer,
1488  cp);
1491  peer,
1492  cp));
1494  gettext_noop ("# peers connected"),
1496  GNUNET_NO);
1497  if (NULL != cp->respect_iterate_req)
1498  {
1500  cp->respect_iterate_req = NULL;
1501  }
1502  if (NULL != cp->rc)
1503  {
1505  cp->rc = NULL;
1506  }
1507  if (NULL != cp->rc_delay_task)
1508  {
1510  cp->rc_delay_task = NULL;
1511  }
1514  cp);
1516  cp->request_map = NULL;
1521  memset (cp->ppd.last_p2p_replies,
1522  0,
1523  sizeof(cp->ppd.last_p2p_replies));
1524  GSF_push_stop_ (cp);
1525  while (NULL != (pth = cp->pth_head))
1526  {
1528  cp->pth_tail,
1529  pth);
1530  if (GNUNET_YES == pth->is_query)
1532  else if (GNUNET_NO == pth->is_query)
1534  GNUNET_free (pth);
1535  }
1536  while (NULL != (dh = cp->delayed_head))
1537  {
1539  cp->delayed_tail,
1540  dh);
1541  GNUNET_MQ_discard (dh->env);
1542  cp->delay_queue_size--;
1544  GNUNET_free (dh);
1545  }
1547  if (NULL != cp->mig_revive_task)
1548  {
1550  cp->mig_revive_task = NULL;
1551  }
1554  GNUNET_free (cp);
1555 }
static int flush_respect(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Write peer-respect information to a file - flush the buffer entry!
void GSF_plan_notify_peer_disconnect_(const struct GSF_ConnectedPeer *cp)
Notify the plan about a peer being no longer available; destroy all entries associated with this peer...
void GNUNET_ATS_reserve_bandwidth_cancel(struct GNUNET_ATS_ReservationContext *rc)
Cancel request for reserving bandwidth.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MultiHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multipeermap_remove(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, const void *value)
Remove the given key-value pair from the map.
#define GNUNET_LOAD_value_free(lv)
Free a load value.
void GNUNET_MQ_discard(struct GNUNET_MQ_Envelope *mqm)
Discard the message queue message, free all allocated resources.
Definition: mq.c:285
void GNUNET_PEER_decrement_rcs(const GNUNET_PEER_Id *ids, unsigned int count)
Decrement multiple RCs of peer identities by one.
Definition: peer.c:157

References cancel_pending_request(), GSF_DelayedHandle::cp, cp_map, GSF_ConnectedPeer::delay_queue_size, GSF_DelayedHandle::delay_task, GSF_ConnectedPeer::delayed_head, GSF_ConnectedPeer::delayed_tail, GSF_DelayedHandle::env, flush_respect(), gettext_noop, GNUNET_assert, GNUNET_ATS_reserve_bandwidth_cancel(), GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_free, GNUNET_LOAD_value_free, GNUNET_MQ_discard(), GNUNET_NO, GNUNET_PEER_change_rc(), GNUNET_PEER_decrement_rcs(), GNUNET_PEERSTORE_iterate_cancel(), GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_set(), GNUNET_YES, GSF_plan_notify_peer_disconnect_(), GSF_push_stop_(), GSF_stats, GSF_PeerTransmitHandle::is_query, GSF_PeerPerformanceData::last_p2p_replies, GSF_ConnectedPeer::mig_revive_task, P2P_SUCCESS_LIST_SIZE, peer, GSF_PeerPerformanceData::pending_queries, GSF_PeerPerformanceData::pending_replies, GSF_PeerPerformanceData::pid, GSF_ConnectedPeer::ppd, GSF_ConnectedPeer::pth_head, GSF_ConnectedPeer::pth_tail, GSF_ConnectedPeer::rc, GSF_ConnectedPeer::rc_delay_task, GSF_ConnectedPeer::request_map, GSF_ConnectedPeer::respect_iterate_req, and GSF_PeerPerformanceData::transmission_delay.

Referenced by main_init().

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

◆ call_iterator()

static int call_iterator ( void *  cls,
const struct GNUNET_PeerIdentity key,
void *  value 
)
static

Function that calls the callback for each peer.

Parameters
clsthe struct IterationContext *
keyidentity of the peer
valuethe struct GSF_ConnectedPeer *
Returns
GNUNET_YES to continue iteration

Definition at line 1584 of file gnunet-service-fs_cp.c.

1587 {
1588  struct IterationContext *ic = cls;
1589  struct GSF_ConnectedPeer *cp = value;
1590 
1591  ic->it (ic->it_cls,
1592  key, cp,
1593  &cp->ppd);
1594  return GNUNET_YES;
1595 }
struct GNUNET_HashCode key
The key used in the DHT.
Closure for call_iterator().
void * it_cls
Closure for it.
GSF_ConnectedPeerIterator it
Function to call on each entry.

References GNUNET_YES, IterationContext::it, IterationContext::it_cls, key, GSF_ConnectedPeer::ppd, and value.

Referenced by GSF_iterate_connected_peers_().

Here is the caller graph for this function:

◆ GSF_iterate_connected_peers_()

void GSF_iterate_connected_peers_ ( GSF_ConnectedPeerIterator  it,
void *  it_cls 
)

Iterate over all connected peers.

Parameters
itfunction to call for each peer
it_clsclosure for it

Definition at line 1599 of file gnunet-service-fs_cp.c.

1601 {
1602  struct IterationContext ic;
1603 
1604  ic.it = it;
1605  ic.it_cls = it_cls;
1607  &call_iterator,
1608  &ic);
1609 }
static int call_iterator(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Function that calls the callback for each peer.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.

References call_iterator(), cp_map, GNUNET_CONTAINER_multipeermap_iterate(), IterationContext::it, and IterationContext::it_cls.

Referenced by GSF_consider_forwarding().

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

◆ GSF_connected_peer_get_identity_()

void GSF_connected_peer_get_identity_ ( const struct GSF_ConnectedPeer cp,
struct GNUNET_PeerIdentity id 
)

Obtain the identity of a connected peer.

Parameters
cppeer to get identity of
ididentity to set (written to)

Definition at line 1619 of file gnunet-service-fs_cp.c.

1621 {
1622  GNUNET_assert (0 != cp->ppd.pid);
1623  GNUNET_PEER_resolve (cp->ppd.pid, id);
1624 }

References GNUNET_assert, GNUNET_PEER_resolve(), GSF_PeerPerformanceData::pid, and GSF_ConnectedPeer::ppd.

Referenced by consider_peer_for_forwarding().

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

◆ GSF_connected_peer_get_identity2_()

const struct GNUNET_PeerIdentity* GSF_connected_peer_get_identity2_ ( const struct GSF_ConnectedPeer cp)

Obtain the identity of a connected peer.

Parameters
cppeer to get identity of
Returns
reference to peer identity, valid until peer disconnects (!)

Definition at line 1634 of file gnunet-service-fs_cp.c.

1635 {
1636  GNUNET_assert (0 != cp->ppd.pid);
1637  return GNUNET_PEER_resolve2 (cp->ppd.pid);
1638 }
const struct GNUNET_PeerIdentity * GNUNET_PEER_resolve2(GNUNET_PEER_Id id)
Convert an interned PID to a normal peer identity.
Definition: peer.c:234

References GNUNET_assert, GNUNET_PEER_resolve2(), GSF_PeerPerformanceData::pid, and GSF_ConnectedPeer::ppd.

Referenced by GSF_peer_connect_handler(), GSF_plan_add_(), GSF_plan_notify_peer_disconnect_(), GSF_push_start_(), and process_migration_content().

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

◆ GSF_block_peer_migration_()

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.

Parameters
cppeer to ask
block_timeuntil when to block

Definition at line 1649 of file gnunet-service-fs_cp.c.

1651 {
1652  struct GNUNET_MQ_Envelope *env;
1653  struct MigrationStopMessage *msm;
1654 
1655  if (cp->last_migration_block.abs_value_us > block_time.abs_value_us)
1656  {
1658  "Migration already blocked for another %s\n",
1661  (cp->
1662  last_migration_block), GNUNET_YES));
1663  return; /* already blocked */
1664  }
1665  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Asking to stop migration for %s\n",
1668  GNUNET_YES));
1669  cp->last_migration_block = block_time;
1670  env = GNUNET_MQ_msg (msm,
1672  msm->reserved = htonl (0);
1673  msm->duration
1675  (cp->last_migration_block));
1677  gettext_noop ("# migration stop messages sent"),
1678  1,
1679  GNUNET_NO);
1680  GSF_peer_transmit_ (cp,
1681  GNUNET_SYSERR,
1682  UINT32_MAX,
1683  env);
1684 }
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:78
#define GNUNET_MESSAGE_TYPE_FS_MIGRATION_STOP
Peer asks us to stop migrating content towards it for a while.
struct GNUNET_TIME_RelativeNBO GNUNET_TIME_relative_hton(struct GNUNET_TIME_Relative a)
Convert relative time to network byte order.
Definition: time.c:618
struct GNUNET_TIME_Absolute last_migration_block
Time until when we blocked this peer from migrating data to us.
Message send by a peer that wants to be excluded from migration for a while.
uint32_t reserved
Always zero.

References GNUNET_TIME_Absolute::abs_value_us, MigrationStopMessage::duration, env, gettext_noop, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_FS_MIGRATION_STOP, GNUNET_MQ_msg, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_SYSERR, GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_relative_hton(), GNUNET_YES, GSF_peer_transmit_(), GSF_stats, GSF_ConnectedPeer::last_migration_block, and MigrationStopMessage::reserved.

Referenced by handle_p2p_put(), and put_migration_continuation().

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

◆ GSF_connected_peer_change_preference_()

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

The change will be communicated the next time we reserve bandwidth with core (not instantly).

Parameters
cppeer to reserve bandwidth from
prefpreference change

Definition at line 1697 of file gnunet-service-fs_cp.c.

1699 {
1700  cp->inc_preference += pref;
1701 }

References GSF_ConnectedPeer::inc_preference.

Referenced by handle_p2p_put().

Here is the caller graph for this function:

◆ cron_flush_respect()

static void cron_flush_respect ( void *  cls)
static

Call this method periodically to flush respect information to disk.

Parameters
clsclosure, not used

Definition at line 1710 of file gnunet-service-fs_cp.c.

1711 {
1712  fr_task = NULL;
1714  &flush_respect,
1715  NULL);
1719  NULL);
1720 }
static void cron_flush_respect(void *cls)
Call this method periodically to flush respect information to disk.
#define RESPECT_FLUSH_FREQ
How often do we flush respect values to disk?
static struct GNUNET_SCHEDULER_Task * fr_task
Task used to flush respect values to disk.
@ GNUNET_SCHEDULER_PRIORITY_HIGH
Run with high priority (important requests).
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed_with_priority(struct GNUNET_TIME_Relative delay, enum GNUNET_SCHEDULER_Priority priority, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1202

References cp_map, flush_respect(), fr_task, GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_SCHEDULER_add_delayed_with_priority(), GNUNET_SCHEDULER_PRIORITY_HIGH, and RESPECT_FLUSH_FREQ.

Referenced by GSF_connected_peer_init_().

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

◆ GSF_connected_peer_init_()

void GSF_connected_peer_init_ ( void  )

Initialize peer management subsystem.

Definition at line 1727 of file gnunet-service-fs_cp.c.

1728 {
1732  &cron_flush_respect, NULL);
1733 }
const struct GNUNET_CONFIGURATION_Handle * GSF_cfg
Our configuration.
struct GNUNET_CONTAINER_MultiPeerMap * GNUNET_CONTAINER_multipeermap_create(unsigned int len, int do_not_copy_keys)
Create a multi peer map (hash map for public keys of peers).
struct GNUNET_PEERSTORE_Handle * GNUNET_PEERSTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the PEERSTORE service.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_with_priority(enum GNUNET_SCHEDULER_Priority prio, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified priority.
Definition: scheduler.c:1226

References cp_map, cron_flush_respect(), fr_task, GNUNET_CONTAINER_multipeermap_create(), GNUNET_PEERSTORE_connect(), GNUNET_SCHEDULER_add_with_priority(), GNUNET_SCHEDULER_PRIORITY_HIGH, GNUNET_YES, GSF_cfg, and peerstore.

Referenced by run().

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

◆ GSF_connected_peer_done_()

void GSF_connected_peer_done_ ( void  )

Shutdown peer management subsystem.

Definition at line 1740 of file gnunet-service-fs_cp.c.

1741 {
1743  &flush_respect,
1744  NULL);
1746  fr_task = NULL;
1748  cp_map = NULL;
1750  GNUNET_YES);
1751 }
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
void GNUNET_PEERSTORE_disconnect(struct GNUNET_PEERSTORE_Handle *h, int sync_first)
Disconnect from the PEERSTORE service.

References cp_map, flush_respect(), fr_task, GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_PEERSTORE_disconnect(), GNUNET_SCHEDULER_cancel(), GNUNET_YES, and peerstore.

Referenced by shutdown_task().

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

◆ clean_local_client()

static int clean_local_client ( void *  cls,
const struct GNUNET_PeerIdentity key,
void *  value 
)
static

Iterator to remove references to LC entry.

Parameters
clsthe struct GSF_LocalClient * to look for
keycurrent key code
valuevalue in the hash map (peer entry)
Returns
GNUNET_YES (we should continue to iterate)

Definition at line 1763 of file gnunet-service-fs_cp.c.

1766 {
1767  const struct GSF_LocalClient *lc = cls;
1768  struct GSF_ConnectedPeer *cp = value;
1769  unsigned int i;
1770 
1771  for (i = 0; i < CS2P_SUCCESS_LIST_SIZE; i++)
1772  if (cp->ppd.last_client_replies[i] == lc)
1773  cp->ppd.last_client_replies[i] = NULL;
1774  return GNUNET_YES;
1775 }
A local client.

References CS2P_SUCCESS_LIST_SIZE, GNUNET_YES, GSF_PeerPerformanceData::last_client_replies, GSF_ConnectedPeer::ppd, and value.

Referenced by GSF_handle_local_client_disconnect_().

Here is the caller graph for this function:

◆ GSF_handle_local_client_disconnect_()

void GSF_handle_local_client_disconnect_ ( const struct GSF_LocalClient lc)

Notification that a local client disconnected.

Clean up all of our references to the given handle.

Parameters
lchandle to the local client (henceforth invalid)

Definition at line 1785 of file gnunet-service-fs_cp.c.

1786 {
1787  if (NULL == cp_map)
1788  return; /* already cleaned up */
1791  (void *) lc);
1792 }
static int clean_local_client(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Iterator to remove references to LC entry.

References clean_local_client(), cp_map, and GNUNET_CONTAINER_multipeermap_iterate().

Here is the call graph for this function:

Variable Documentation

◆ cp_map

◆ peerstore

struct GNUNET_PEERSTORE_Handle* peerstore
static

Handle to peerstore service.

Definition at line 287 of file gnunet-service-fs_cp.c.

Referenced by flush_respect(), GSF_connected_peer_done_(), GSF_connected_peer_init_(), and GSF_peer_connect_handler().

◆ fr_task

struct GNUNET_SCHEDULER_Task* fr_task
static

Task used to flush respect values to disk.

Definition at line 292 of file gnunet-service-fs_cp.c.

Referenced by cron_flush_respect(), GSF_connected_peer_done_(), and GSF_connected_peer_init_().