rps service implementation More...

#include "platform.h"
#include "gnunet_applications.h"
#include "gnunet_util_lib.h"
#include "gnunet_cadet_service.h"
#include "gnunet_core_service.h"
#include "gnunet_peerstore_service.h"
#include "gnunet_nse_service.h"
#include "gnunet_statistics_service.h"
#include "rps.h"
#include "rps-test_util.h"
#include "gnunet-service-rps_sampler.h"
#include "gnunet-service-rps_custommap.h"
#include "gnunet-service-rps_view.h"
#include "gnunet_constants.h"
#include <math.h>
#include <inttypes.h>
#include <string.h>

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

Data Structures
struct	PeerPendingOp
	Pending operation on peer consisting of callback and closure. More...

struct	PendingMessage
	List containing all messages that are yet to be send. More...

struct	PeerContext
	Struct used to keep track of other peer's status. More...

struct	PeersIteratorCls
	Closure to valid_peer_iterator. More...

struct	ChannelCtx
	Context for a channel. More...

struct	Sub
	One Sub. More...

struct	GetRandPeerIteratorCls
	The closure to get_rand_peer_iterator. More...

struct	ReplyCls
	Closure used to pass the client and the id to the callback that replies to a client's request. More...

struct	ClientContext
	Struct used to store the context of a connected client. More...

Macros
#define	LOG(kind, ...) GNUNET_log (kind, __VA_ARGS__)

#define	SET_PEER_FLAG(peer_ctx, mask) ((peer_ctx->peer_flags) \|= (mask))
	Set a peer flag of given peer context.

#define	check_peer_flag_set(peer_ctx, mask) ((peer_ctx->peer_flags) & (mask) ? GNUNET_YES : GNUNET_NO)
	Get peer flag of given peer context.

#define	UNSET_PEER_FLAG(peer_ctx, mask) ((peer_ctx->peer_flags) &= ~(mask))
	Unset flag of given peer context.

#define	check_channel_flag_set(channel_flags, mask) ((*channel_flags) & (mask) ? GNUNET_YES : GNUNET_NO)
	Get channel flag of given channel context.

#define	unset_channel_flag(channel_flags, mask) ((*channel_flags) &= ~(mask))
	Unset flag of given channel context.

#define	HISTOGRAM_FILE_SLOTS 32
	This number determines the number of slots for files that represent histograms.

#define	SIZE_DUMP_FILE (HISTOGRAM_FILE_SLOTS * 5) + 1
	The size (in bytes) a file needs to store the histogram.

Functions
static void	do_round (void *cls)
	Send out PUSHes and PULLs, possibly update #view, samplers.

static struct PeerContext *	get_peer_ctx (const struct GNUNET_CONTAINER_MultiPeerMap peer_map, const struct GNUNET_PeerIdentity peer)
	Get the PeerContext associated with a peer.

static int	check_peer_known (const struct GNUNET_CONTAINER_MultiPeerMap peer_map, const struct GNUNET_PeerIdentity peer)
	Check whether we have information about the given peer.

static struct PeerContext *	create_peer_ctx (struct Sub sub, const struct GNUNET_PeerIdentity peer)
	Create a new PeerContext and insert it into the peer map.

static struct PeerContext *	create_or_get_peer_ctx (struct Sub sub, const struct GNUNET_PeerIdentity peer)
	Create or get a PeerContext.

static int	check_connected (struct PeerContext *peer_ctx)
	Check whether we have a connection to this peer.

static int	get_rand_peer_iterator (void cls, const struct GNUNET_PeerIdentity peer, void *value)
	Iterator function for get_random_peer_from_peermap.

static const struct GNUNET_PeerIdentity *	get_random_peer_from_peermap (struct GNUNET_CONTAINER_MultiPeerMap *valid_peers)
	Get a random peer from peer_map.

static int	add_valid_peer (const struct GNUNET_PeerIdentity peer, struct GNUNET_CONTAINER_MultiPeerMap valid_peers)
	Add a given peer to valid peers.

static void	remove_pending_message (struct PendingMessage *pending_msg, int cancel)
	Remove a pending message from the respective DLL.

static void	set_peer_online (struct PeerContext *peer_ctx)
	Set the peer flag to living and call the pending operations on this peer.

static void	cleanup_destroyed_channel (void cls, const struct GNUNET_CADET_Channel channel)
	This is called when a channel is destroyed.

static void	handle_peer_check (void cls, const struct GNUNET_MessageHeader msg)
	Handle a CHECK_LIVE message from another peer.

static void	handle_peer_push (void cls, const struct GNUNET_MessageHeader msg)
	Handle a PUSH message from another peer.

static void	handle_peer_pull_request (void cls, const struct GNUNET_MessageHeader msg)
	Handle PULL REQUEST request message from another peer.

static int	check_peer_pull_reply (void cls, const struct GNUNET_RPS_P2P_PullReplyMessage msg)
	Check whether we sent a corresponding request and whether this reply is the first one.

static void	handle_peer_pull_reply (void cls, const struct GNUNET_RPS_P2P_PullReplyMessage msg)
	Handle PULL REPLY message from another peer.

static struct ChannelCtx *	add_channel_ctx (struct PeerContext *peer_ctx)
	Allocate memory for a new channel context and insert it into DLL.

static void	remove_channel_ctx (struct ChannelCtx *channel_ctx)
	Free memory and NULL pointers.

struct GNUNET_CADET_Channel *	get_channel (struct PeerContext *peer_ctx)
	Get the channel of a peer.

static struct GNUNET_MQ_Handle *	get_mq (struct PeerContext *peer_ctx)
	Get the message queue (GNUNET_MQ_Handle) of a specific peer.

static struct PendingMessage *	insert_pending_message (struct PeerContext peer_ctx, struct GNUNET_MQ_Envelope ev, const char *type)
	Add an envelope to a message passed to mq to list of pending messages.

static void	mq_online_check_successful (void *cls)
	This is called in response to the first message we sent as a online check.

static void	check_peer_online (struct PeerContext *peer_ctx)
	Issue a check whether peer is online.

static int	check_operation_scheduled (const struct PeerContext *peer_ctx, const PeerOp peer_op)
	Check whether function of type PeerOp was already scheduled.

static void	destroy_channel (struct ChannelCtx *channel_ctx)
	Callback for scheduler to destroy a channel.

static void	destroy_channel_cb (void *cls)
	Destroy a cadet channel.

static void	schedule_channel_destruction (struct ChannelCtx *channel_ctx)
	Schedule the destruction of a channel for immediately afterwards.

static int	destroy_peer (struct PeerContext *peer_ctx)
	Remove peer.

static int	peermap_clear_iterator (void cls, const struct GNUNET_PeerIdentity key, void *value)
	Iterator over hash map entries.

static void	mq_notify_sent_cb (void *cls)
	This is called once a message is sent.

static int	store_peer_presistently_iterator (void cls, const struct GNUNET_PeerIdentity peer, void *value)
	Iterator function for store_valid_peers.

static void	store_valid_peers (const struct Sub *sub)
	Store the peers currently in #valid_peers to disk.

static const struct GNUNET_PeerIdentity *	s2i_full (const char *string_repr)
	Convert string representation of peer id to peer id.

static void	restore_valid_peers (const struct Sub *sub)
	Restore the peers on disk to #valid_peers.

static void	peers_terminate (struct Sub *sub)
	Delete storage of peers that was created with #initialise_peers ()

static int	valid_peer_iterator (void cls, const struct GNUNET_PeerIdentity peer, void *value)
	Iterator over #valid_peers hash map entries.

static int	get_valid_peers (struct GNUNET_CONTAINER_MultiPeerMap valid_peers, PeersIterator iterator, void it_cls)
	Get all currently known, valid peer ids.

static int	insert_peer (struct Sub sub, const struct GNUNET_PeerIdentity peer)
	Add peer to known peers.

static int	check_peer_flag (const struct GNUNET_CONTAINER_MultiPeerMap peer_map, const struct GNUNET_PeerIdentity peer, enum Peers_PeerFlags flags)
	Check whether flags on a peer are set.

static int	issue_peer_online_check (struct Sub sub, const struct GNUNET_PeerIdentity peer)
	Try connecting to a peer to see whether it is online.

static int	check_removable (const struct PeerContext *peer_ctx)
	Check if peer is removable.

static int	check_peer_valid (const struct GNUNET_CONTAINER_MultiPeerMap valid_peers, const struct GNUNET_PeerIdentity peer)
	Check whether peer is actually a peer.

static void	indicate_sending_intention (struct PeerContext *peer_ctx)
	Indicate that we want to send to the other peer.

static int	check_peer_send_intention (const struct PeerContext *peer_ctx)
	Check whether other peer has the intention to send/opened channel towars us.

static void *	handle_inbound_channel (void cls, struct GNUNET_CADET_Channel channel, const struct GNUNET_PeerIdentity *initiator)
	Handle the channel a peer opens to us.

static int	check_sending_channel_exists (const struct PeerContext *peer_ctx)
	Check whether a sending channel towards the given peer exists.

static int	destroy_sending_channel (struct PeerContext *peer_ctx)
	Destroy the send channel of a peer e.g.

static void	send_message (struct PeerContext peer_ctx, struct GNUNET_MQ_Envelope ev, const char *type)
	Send a message to another peer.

static int	schedule_operation (struct PeerContext peer_ctx, const PeerOp peer_op, void cls)
	Schedule a operation on given peer.

static void	print_peer_list (struct GNUNET_PeerIdentity *list, unsigned int len)
	Print peerlist to log.

static void	rem_from_list (struct GNUNET_PeerIdentity *peer_list, unsigned int list_size, const struct GNUNET_PeerIdentity *peer)
	Remove peer from list.

static void	insert_in_view_op (void cls, const struct GNUNET_PeerIdentity peer)
	Insert PeerID in #view.

static int	insert_in_view (struct Sub sub, const struct GNUNET_PeerIdentity peer)
	Insert PeerID in #view.

static void	send_view (const struct ClientContext cli_ctx, const struct GNUNET_PeerIdentity view_array, uint64_t view_size)
	Send view to client.

static void	send_stream_peers (const struct ClientContext cli_ctx, uint64_t num_peers, const struct GNUNET_PeerIdentity peers)
	Send peer from biased stream to client.

static void	clients_notify_view_update (const struct Sub *sub)
	sends updates to clients that are interested

static void	clients_notify_stream_peer (const struct Sub sub, uint64_t num_peers, const struct GNUNET_PeerIdentity peers)
	sends updates to clients that are interested

static void	hist_update (const struct GNUNET_PeerIdentity ids, uint32_t num_peers, void cls)
	Put random peer from sampler into the view as history update.

static void	resize_wrapper (struct RPS_Sampler *sampler, uint32_t new_size)
	Wrapper around RPS_sampler_resize()

static void	send_pull_reply (struct PeerContext peer_ctx, const struct GNUNET_PeerIdentity peer_ids, unsigned int num_peer_ids)
	Send a PULL REPLY to peer_id.

static void	insert_in_pull_map (void cls, const struct GNUNET_PeerIdentity peer)
	Insert PeerID in #pull_map.

static void	insert_in_sampler (void cls, const struct GNUNET_PeerIdentity peer)
	Update sampler with given PeerID.

static void	got_peer (struct Sub sub, const struct GNUNET_PeerIdentity peer)
	This is called on peers from external sources (cadet, peerinfo, ...) If the peer is not known, online check is issued and it is scheduled to be inserted in sampler and view.

static int	check_sending_channel_needed (const struct PeerContext *peer_ctx)
	Checks if there is a sending channel and if it is needed.

static void	remove_peer (struct Sub sub, const struct GNUNET_PeerIdentity peer)
	remove peer from our knowledge, the view, push and pull maps and samplers.

static void	clean_peer (struct Sub sub, const struct GNUNET_PeerIdentity peer)
	Remove data that is not needed anymore.

struct Sub *	new_sub (const struct GNUNET_HashCode *hash, uint32_t sampler_size, struct GNUNET_TIME_Relative round_interval)
	Create a new Sub.

static void	destroy_sub (struct Sub *sub)
	Destroy Sub.

void	core_init (void cls, const struct GNUNET_PeerIdentity my_identity)
	Callback on initialisation of Core.

void *	core_connects (void cls, const struct GNUNET_PeerIdentity peer, struct GNUNET_MQ_Handle *mq, enum GNUNET_CORE_PeerClass class)
	Callback for core.

void	core_disconnects (void cls, const struct GNUNET_PeerIdentity peer, void *peer_cls)
	Callback for core.

static void	destroy_cli_ctx (struct ClientContext *cli_ctx)
	Destroy the context for a (connected) client.

static void	adapt_sizes (struct Sub *sub, double logestimate, double std_dev)
	Update sizes in sampler and view on estimate update from nse service.

static void	nse_callback (void *cls, struct GNUNET_TIME_Absolute timestamp, double logestimate, double std_dev)
	Function called by NSE.

static int	check_client_seed (void cls, const struct GNUNET_RPS_CS_SeedMessage msg)
	This function is called, when the client seeds peers.

static void	handle_client_seed (void cls, const struct GNUNET_RPS_CS_SeedMessage msg)
	Handle seed from the client.

static void	handle_client_view_request (void cls, const struct GNUNET_RPS_CS_DEBUG_ViewRequest msg)
	Handle RPS request from the client.

static void	handle_client_view_cancel (void cls, const struct GNUNET_MessageHeader msg)
	Handle the cancellation of the view updates.

static void	handle_client_stream_request (void cls, const struct GNUNET_RPS_CS_DEBUG_StreamRequest msg)
	Handle RPS request for biased stream from the client.

static void	handle_client_stream_cancel (void cls, const struct GNUNET_MessageHeader msg)
	Handles the cancellation of the stream of biased peer ids.

static void	handle_client_start_sub (void cls, const struct GNUNET_RPS_CS_SubStartMessage msg)
	Create and start a Sub.

static void	handle_client_stop_sub (void cls, const struct GNUNET_RPS_CS_SubStopMessage msg)
	Destroy the Sub.

static struct GNUNET_TIME_Relative	compute_rand_delay (struct GNUNET_TIME_Relative mean, unsigned int spread)
	Compute a random delay.

static void	send_pull_request (struct PeerContext *peer_ctx)
	Send single pull request.

static void	send_push (struct PeerContext *peer_ctx)
	Send single push.

void	init_peer_cb (void cls, const struct GNUNET_PeerIdentity peer, int tunnel, unsigned int n_paths, unsigned int best_path)
	This is called from GNUNET_CADET_get_peers().

static int	valid_peers_iterator (void cls, const struct GNUNET_PeerIdentity peer)
	Iterator function over stored, valid peers.

void	process_peerinfo_peers (void cls, const struct GNUNET_PEERSTORE_Record record, const char *emsg)
	Iterator over peers from peerinfo.

static void	shutdown_task (void *cls)
	Task run during shutdown.

static void *	client_connect_cb (void cls, struct GNUNET_SERVICE_Client client, struct GNUNET_MQ_Handle *mq)
	Handle client connecting to the service.

static void	client_disconnect_cb (void cls, struct GNUNET_SERVICE_Client client, void *internal_cls)
	Callback called when a client disconnected from the service.

static void	error_cb (void *cls)

static void	sync_cb (void *cls)

static void	run (void cls, const struct GNUNET_CONFIGURATION_Handle c, struct GNUNET_SERVICE_Handle *service)
	Handle random peer sampling clients.

	GNUNET_SERVICE_MAIN (GNUNET_OS_project_data_gnunet(), "rps", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_var_size(client_seed, GNUNET_MESSAGE_TYPE_RPS_CS_SEED, struct GNUNET_RPS_CS_SeedMessage, NULL), GNUNET_MQ_hd_fixed_size(client_view_request, GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_REQUEST, struct GNUNET_RPS_CS_DEBUG_ViewRequest, NULL), GNUNET_MQ_hd_fixed_size(client_view_cancel, GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_CANCEL, struct GNUNET_MessageHeader, NULL), GNUNET_MQ_hd_fixed_size(client_stream_request, GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_STREAM_REQUEST, struct GNUNET_RPS_CS_DEBUG_StreamRequest, NULL), GNUNET_MQ_hd_fixed_size(client_stream_cancel, GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_STREAM_CANCEL, struct GNUNET_MessageHeader, NULL), GNUNET_MQ_hd_fixed_size(client_start_sub, GNUNET_MESSAGE_TYPE_RPS_CS_SUB_START, struct GNUNET_RPS_CS_SubStartMessage, NULL), GNUNET_MQ_hd_fixed_size(client_stop_sub, GNUNET_MESSAGE_TYPE_RPS_CS_SUB_STOP, struct GNUNET_RPS_CS_SubStopMessage, NULL), GNUNET_MQ_handler_end())
	Define "main" method using service macro.

Variables
static const struct GNUNET_CONFIGURATION_Handle *	cfg
	Our configuration.

struct GNUNET_STATISTICS_Handle *	stats
	Handle to the statistics service.

struct GNUNET_CADET_Handle *	cadet_handle
	Handler to CADET.

struct GNUNET_CORE_Handle *	core_handle
	Handle to CORE.

struct GNUNET_CONTAINER_MultiPeerMap *	map_single_hop
	PeerMap to keep track of connected peers.

static struct GNUNET_PeerIdentity	own_identity
	Our own identity.

static float	alpha
	Percentage of total peer number in the view to send random PUSHes to.

static float	beta
	Percentage of total peer number in the view to send random PULLs to.

static struct GNUNET_NSE_Handle *	nse
	Handler to NSE.

static struct GNUNET_PEERSTORE_Handle *	peerstore
	Handle to the PEERSTORE service.

static struct GNUNET_PEERSTORE_Monitor *	peerstore_notify
	Our peerstore notification context.

static struct Sub *	msub
	Main Sub.

static const uint32_t	num_valid_peers_max = UINT32_MAX
	Maximum number of valid peers to keep.

struct ClientContext *	cli_ctx_head
	DLL with all clients currently connected to us.

struct ClientContext *	cli_ctx_tail

Detailed Description

rps service implementation

Author: Julius Bünger

Definition in file gnunet-service-rps.c.

Macro Definition Documentation

◆ LOG

#define LOG	(	kind,
		...
	)	GNUNET_log (kind, __VA_ARGS__)

Definition at line 45 of file gnunet-service-rps.c.

◆ SET_PEER_FLAG

#define SET_PEER_FLAG	(	peer_ctx,
		mask
	)	((peer_ctx->peer_flags) \|= (mask))

Set a peer flag of given peer context.

Definition at line 64 of file gnunet-service-rps.c.

◆ check_peer_flag_set

#define check_peer_flag_set	(	peer_ctx,
		mask
	)	((peer_ctx->peer_flags) & (mask) ? GNUNET_YES : GNUNET_NO)

Get peer flag of given peer context.

Definition at line 69 of file gnunet-service-rps.c.

70 : GNUNET_NO)

GNUNET_NO

@ GNUNET_NO

Definition gnunet_common.h:113

◆ UNSET_PEER_FLAG

#define UNSET_PEER_FLAG	(	peer_ctx,
		mask
	)	((peer_ctx->peer_flags) &= ~(mask))

Unset flag of given peer context.

Definition at line 75 of file gnunet-service-rps.c.

◆ check_channel_flag_set

#define check_channel_flag_set	(	channel_flags,
		mask
	)	((*channel_flags) & (mask) ? GNUNET_YES : GNUNET_NO)

Get channel flag of given channel context.

Definition at line 80 of file gnunet-service-rps.c.

81 : GNUNET_NO)

◆ unset_channel_flag

#define unset_channel_flag	(	channel_flags,
		mask
	)	((*channel_flags) &= ~(mask))

Unset flag of given channel context.

Definition at line 86 of file gnunet-service-rps.c.

◆ HISTOGRAM_FILE_SLOTS

#define HISTOGRAM_FILE_SLOTS 32

This number determines the number of slots for files that represent histograms.

Definition at line 289 of file gnunet-service-rps.c.

◆ SIZE_DUMP_FILE

#define SIZE_DUMP_FILE (HISTOGRAM_FILE_SLOTS * 5) + 1

The size (in bytes) a file needs to store the histogram.

Per slot: 1 newline, up to 4 chars, Additionally: 1 null termination

Definition at line 297 of file gnunet-service-rps.c.

Function Documentation

◆ do_round()

static void do_round ( void * cls )

static

Send out PUSHes and PULLs, possibly update #view, samplers.

This is executed regylary.

Parameters

cls	Closure - Sub

Definition at line 4293 of file gnunet-service-rps.c.

{
  unsigned int i;
  const struct GNUNET_PeerIdentity *view_array;
  unsigned int *permut;
  unsigned int a_peers; /* Number of peers we send pushes to */
  unsigned int b_peers; /* Number of peers we send pull requests to */
  uint32_t first_border;
  uint32_t second_border;
  struct GNUNET_PeerIdentity peer;
  struct GNUNET_PeerIdentity *update_peer;
  struct Sub *sub = cls;
 
  sub->num_rounds++;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Going to execute next round.\n");
  if (sub == msub)
  {
    GNUNET_STATISTICS_update (stats, "# rounds", 1, GNUNET_NO);
  }
  sub->do_round_task = NULL;
#ifdef TO_FILE_FULL
  to_file (sub->file_name_view_log,
           "___ new round ___");
#endif /* TO_FILE_FULL */
  view_array = View_get_as_array (sub->view);
  for (i = 0; i < View_size (sub->view); i++)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "\t%s\n", GNUNET_i2s (&view_array[i]));
#ifdef TO_FILE_FULL
    to_file (sub->file_name_view_log,
             "=%s\t(do round)",
             GNUNET_i2s_full (&view_array[i]));
#endif /* TO_FILE_FULL */
  }
 
 
  /* Send pushes and pull requests */
  if (0 < View_size (sub->view))
  {
    permut = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_STRONG,
                                           View_size (sub->view));
 
    /* Send PUSHes */
    a_peers = ceil (alpha * View_size (sub->view));
 
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Going to send pushes to %u (ceil (%f * %u)) peers.\n",
         a_peers, alpha, View_size (sub->view));
    for (i = 0; i < a_peers; i++)
    {
      peer = view_array[permut[i]];
      // FIXME if this fails schedule/loop this for later
      send_push (get_peer_ctx (sub->peer_map, &peer));
    }
 
    /* Send PULL requests */
    b_peers = ceil (beta * View_size (sub->view));
    first_border = a_peers;
    second_border = a_peers + b_peers;
    if (second_border > View_size (sub->view))
    {
      first_border = View_size (sub->view) - b_peers;
      second_border = View_size (sub->view);
    }
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Going to send pulls to %u (ceil (%f * %u)) peers.\n",
         b_peers, beta, View_size (sub->view));
    for (i = first_border; i < second_border; i++)
    {
      peer = view_array[permut[i]];
      if (GNUNET_NO == check_peer_flag (sub->peer_map,
                                        &peer,
                                        Peers_PULL_REPLY_PENDING))
      {       // FIXME if this fails schedule/loop this for later
        send_pull_request (get_peer_ctx (sub->peer_map, &peer));
      }
    }
 
    GNUNET_free (permut);
    permut = NULL;
  }
 
 
  /* Update view */
  /* TODO see how many peers are in push-/pull- list! */
 
  if ((CustomPeerMap_size (sub->push_map) <= alpha * sub->view_size_est_need) &&
      (0 < CustomPeerMap_size (sub->push_map)) &&
      (0 < CustomPeerMap_size (sub->pull_map)))
  {   /* If conditions for update are fulfilled, update */
    LOG (GNUNET_ERROR_TYPE_DEBUG, "Update of the view.\n");
 
    uint32_t final_size;
    uint32_t peers_to_clean_size;
    struct GNUNET_PeerIdentity *peers_to_clean;
 
    peers_to_clean = NULL;
    peers_to_clean_size = 0;
    GNUNET_array_grow (peers_to_clean,
                       peers_to_clean_size,
                       View_size (sub->view));
    GNUNET_memcpy (peers_to_clean,
                   view_array,
                   View_size (sub->view) * sizeof(struct GNUNET_PeerIdentity));
 
    /* Seems like recreating is the easiest way of emptying the peermap */
    View_clear (sub->view);
#ifdef TO_FILE_FULL
    to_file (sub->file_name_view_log,
             "--- emptied ---");
#endif /* TO_FILE_FULL */
 
    first_border = GNUNET_MIN (ceil (alpha * sub->view_size_est_need),
                               CustomPeerMap_size (sub->push_map));
    second_border = first_border
                    + GNUNET_MIN (floor (beta * sub->view_size_est_need),
                                  CustomPeerMap_size (sub->pull_map));
    final_size = second_border
                 + ceil ((1 - (alpha + beta)) * sub->view_size_est_need);
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "first border: %" PRIu32 ", second border: %" PRIu32 ", final size: %"
         PRIu32 "\n",
         first_border,
         second_border,
         final_size);
 
    /* Update view with peers received through PUSHes */
    permut = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_STRONG,
                                           CustomPeerMap_size (sub->push_map));
    for (i = 0; i < first_border; i++)
    {
      int inserted;
      inserted = insert_in_view (sub,
                                 CustomPeerMap_get_peer_by_index (sub->push_map,
                                                                  permut[i]));
      if (GNUNET_OK == inserted)
      {
        clients_notify_stream_peer (sub,
                                    1,
                                    CustomPeerMap_get_peer_by_index (
                                      sub->push_map, permut[i]));
      }
#ifdef TO_FILE_FULL
      to_file (sub->file_name_view_log,
               "+%s\t(push list)",
               GNUNET_i2s_full (&view_array[i]));
#endif /* TO_FILE_FULL */
      // TODO change the peer_flags accordingly
    }
    GNUNET_free (permut);
    permut = NULL;
 
    /* Update view with peers received through PULLs */
    permut = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_STRONG,
                                           CustomPeerMap_size (sub->pull_map));
    for (i = first_border; i < second_border; i++)
    {
      int inserted;
      inserted = insert_in_view (sub,
                                 CustomPeerMap_get_peer_by_index (sub->pull_map,
                                                                  permut[i
                                                                         -
                                                                         first_border
                                                                  ]));
      if (GNUNET_OK == inserted)
      {
        clients_notify_stream_peer (sub,
                                    1,
                                    CustomPeerMap_get_peer_by_index (
                                      sub->pull_map,
                                      permut[i
                                             - first_border]));
      }
#ifdef TO_FILE_FULL
      to_file (sub->file_name_view_log,
               "+%s\t(pull list)",
               GNUNET_i2s_full (&view_array[i]));
#endif /* TO_FILE_FULL */
      // TODO change the peer_flags accordingly
    }
    GNUNET_free (permut);
    permut = NULL;
 
    /* Update view with peers from history */
    RPS_sampler_get_n_rand_peers (sub->sampler,
                                  final_size - second_border,
                                  hist_update,
                                  sub);
    // TODO change the peer_flags accordingly
 
    for (i = 0; i < View_size (sub->view); i++)
      rem_from_list (&peers_to_clean, &peers_to_clean_size, &view_array[i]);
 
    /* Clean peers that were removed from the view */
    for (i = 0; i < peers_to_clean_size; i++)
    {
#ifdef TO_FILE_FULL
      to_file (sub->file_name_view_log,
               "-%s",
               GNUNET_i2s_full (&peers_to_clean[i]));
#endif /* TO_FILE_FULL */
      clean_peer (sub, &peers_to_clean[i]);
    }
 
    GNUNET_array_grow (peers_to_clean, peers_to_clean_size, 0);
    clients_notify_view_update (sub);
  }
  else
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG, "No update of the view.\n");
    if (sub == msub)
    {
      GNUNET_STATISTICS_update (stats, "# rounds blocked", 1, GNUNET_NO);
      if ((CustomPeerMap_size (sub->push_map) > alpha
           * sub->view_size_est_need) &&
          ! (0 >= CustomPeerMap_size (sub->pull_map)))
        GNUNET_STATISTICS_update (stats, "# rounds blocked - too many pushes",
                                  1, GNUNET_NO);
      if ((CustomPeerMap_size (sub->push_map) > alpha
           * sub->view_size_est_need) &&
          (0 >= CustomPeerMap_size (sub->pull_map)))
        GNUNET_STATISTICS_update (stats,
                                  "# rounds blocked - too many pushes, no pull replies",
                                  1, GNUNET_NO);
      if ((0 >= CustomPeerMap_size (sub->push_map)) &&
          ! (0 >= CustomPeerMap_size (sub->pull_map)))
        GNUNET_STATISTICS_update (stats, "# rounds blocked - no pushes", 1,
                                  GNUNET_NO);
      if ((0 >= CustomPeerMap_size (sub->push_map)) &&
          (0 >= CustomPeerMap_size (sub->pull_map)))
        GNUNET_STATISTICS_update (stats,
                                  "# rounds blocked - no pushes, no pull replies",
                                  1, GNUNET_NO);
      if ((0 >= CustomPeerMap_size (sub->pull_map)) &&
          (CustomPeerMap_size (sub->push_map) > alpha
           * sub->view_size_est_need) &&
          (0 >= CustomPeerMap_size (sub->push_map)) )
        GNUNET_STATISTICS_update (stats, "# rounds blocked - no pull replies",
                                  1, GNUNET_NO);
    }
  }
  // TODO independent of that also get some peers from CADET_get_peers()?
  if (CustomPeerMap_size (sub->push_map) < HISTOGRAM_FILE_SLOTS)
  {
    sub->push_recv[CustomPeerMap_size (sub->push_map)]++;
  }
  else
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Push map size too big for histogram (%u, %u)\n",
         CustomPeerMap_size (sub->push_map),
         HISTOGRAM_FILE_SLOTS);
  }
  // FIXME check bounds of histogram
  sub->push_delta[(int32_t) (CustomPeerMap_size (sub->push_map)
                             - (alpha * sub->view_size_est_need))
                  + (HISTOGRAM_FILE_SLOTS / 2)]++;
  if (sub == msub)
  {
    GNUNET_STATISTICS_set (stats,
                           "# peers in push map at end of round",
                           CustomPeerMap_size (sub->push_map),
                           GNUNET_NO);
    GNUNET_STATISTICS_set (stats,
                           "# peers in pull map at end of round",
                           CustomPeerMap_size (sub->pull_map),
                           GNUNET_NO);
    GNUNET_STATISTICS_set (stats,
                           "# peers in view at end of round",
                           View_size (sub->view),
                           GNUNET_NO);
    GNUNET_STATISTICS_set (stats,
                           "# expected pushes",
                           alpha * sub->view_size_est_need,
                           GNUNET_NO);
    GNUNET_STATISTICS_set (stats,
                           "delta expected - received pushes",
                           CustomPeerMap_size (sub->push_map) - (alpha
                                                                 * sub->
                                                                 view_size_est_need),
                           GNUNET_NO);
  }
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received %u pushes and %u pulls last round (alpha (%.2f) * view_size (sub->view%u) = %.2f)\n",
       CustomPeerMap_size (sub->push_map),
       CustomPeerMap_size (sub->pull_map),
       alpha,
       View_size (sub->view),
       alpha * View_size (sub->view));
 
  /* Update samplers */
  for (i = 0; i < CustomPeerMap_size (sub->push_map); i++)
  {
    update_peer = CustomPeerMap_get_peer_by_index (sub->push_map, i);
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Updating with peer %s from push list\n",
         GNUNET_i2s (update_peer));
    insert_in_sampler (sub, update_peer);
    clean_peer (sub, update_peer);  /* This cleans only if it is not in the view */
  }
 
  for (i = 0; i < CustomPeerMap_size (sub->pull_map); i++)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Updating with peer %s from pull list\n",
         GNUNET_i2s (CustomPeerMap_get_peer_by_index (sub->pull_map, i)));
    insert_in_sampler (sub, CustomPeerMap_get_peer_by_index (sub->pull_map, i));
    /* This cleans only if it is not in the view */
    clean_peer (sub, CustomPeerMap_get_peer_by_index (sub->pull_map, i));
  }
 
 
  /* Empty push/pull lists */
  CustomPeerMap_clear (sub->push_map);
  CustomPeerMap_clear (sub->pull_map);
 
  if (sub == msub)
  {
    GNUNET_STATISTICS_set (stats,
                           "view size",
                           View_size (sub->view),
                           GNUNET_NO);
  }
 
  struct GNUNET_TIME_Relative time_next_round;
 
  time_next_round = compute_rand_delay (sub->round_interval, 2);
 
  /* Schedule next round */
  sub->do_round_task = GNUNET_SCHEDULER_add_delayed (time_next_round,
                                                     &do_round, sub);
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Finished round\n");
}

References alpha, beta, check_peer_flag(), clean_peer(), clients_notify_stream_peer(), clients_notify_view_update(), compute_rand_delay(), CustomPeerMap_clear(), CustomPeerMap_get_peer_by_index(), CustomPeerMap_size(), do_round(), Sub::do_round_task, get_peer_ctx(), GNUNET_array_grow, GNUNET_CRYPTO_QUALITY_STRONG, GNUNET_CRYPTO_random_permute(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_i2s(), GNUNET_i2s_full(), GNUNET_memcpy, GNUNET_MIN, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_STATISTICS_set(), GNUNET_STATISTICS_update(), hist_update(), HISTOGRAM_FILE_SLOTS, insert_in_sampler(), insert_in_view(), LOG, msub, Sub::num_rounds, Sub::peer_map, Peers_PULL_REPLY_PENDING, Sub::pull_map, Sub::push_delta, Sub::push_map, Sub::push_recv, rem_from_list(), Sub::round_interval, RPS_sampler_get_n_rand_peers(), Sub::sampler, send_pull_request(), send_push(), stats, to_file, Sub::view, View_clear(), View_get_as_array(), View_size(), and Sub::view_size_est_need.

Referenced by do_round(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_relative2s(), and new_sub().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_peer_ctx()

static struct PeerContext * get_peer_ctx	(	const struct GNUNET_CONTAINER_MultiPeerMap *	peer_map,
		const struct GNUNET_PeerIdentity *	peer
	)

static

Get the PeerContext associated with a peer.

Parameters

peer_map	The peer map containing the context
peer	the peer id

Returns: the PeerContext

Definition at line 617 of file gnunet-service-rps.c.

{
  struct PeerContext *ctx;
  int ret;
 
  ret = GNUNET_CONTAINER_multipeermap_contains (peer_map, peer);
  GNUNET_assert (GNUNET_YES == ret);
  ctx = GNUNET_CONTAINER_multipeermap_get (peer_map, peer);
  GNUNET_assert (NULL != ctx);
  return ctx;
}

References ctx, GNUNET_assert, GNUNET_CONTAINER_multipeermap_contains(), GNUNET_CONTAINER_multipeermap_get(), GNUNET_YES, and ret.

Referenced by check_connected(), check_peer_flag(), clean_peer(), create_or_get_peer_ctx(), do_round(), got_peer(), handle_inbound_channel(), handle_peer_pull_reply(), insert_in_view(), issue_peer_online_check(), peermap_clear_iterator(), and remove_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_peer_known()

static int check_peer_known	(	const struct GNUNET_CONTAINER_MultiPeerMap *	peer_map,
		const struct GNUNET_PeerIdentity *	peer
	)

static

Check whether we have information about the given peer.

FIXME probably deprecated. Make this the new _online.

Parameters

peer_map	The peer map to check for the existence of peer
peer	peer in question

Returns: GNUNET_YES if peer is known GNUNET_NO if peer is not known

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

{
  if (NULL != peer_map)
  {
    return GNUNET_CONTAINER_multipeermap_contains (peer_map, peer);
  }
  else
  {
    return GNUNET_NO;
  }
}

References GNUNET_CONTAINER_multipeermap_contains(), and GNUNET_NO.

Referenced by check_connected(), check_peer_flag(), check_sending_channel_exists(), check_sending_channel_needed(), create_or_get_peer_ctx(), create_peer_ctx(), destroy_sending_channel(), handle_peer_pull_reply(), handle_peer_pull_request(), handle_peer_push(), hist_update(), indicate_sending_intention(), insert_peer(), remove_peer(), and schedule_operation().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_peer_ctx()

static struct PeerContext * create_peer_ctx	(	struct Sub *	sub,
		const struct GNUNET_PeerIdentity *	peer
	)

static

Create a new PeerContext and insert it into the peer map.

Parameters

sub	The Sub this context belongs to.
peer	the peer to create the PeerContext for

Returns: the PeerContext

Definition at line 666 of file gnunet-service-rps.c.

{
  struct PeerContext *ctx;
  int ret;
 
  GNUNET_assert (GNUNET_NO == check_peer_known (sub->peer_map, peer));
 
  ctx = GNUNET_new (struct PeerContext);
  ctx->peer_id = *peer;
  ctx->sub = sub;
  ret = GNUNET_CONTAINER_multipeermap_put (sub->peer_map, peer, ctx,
                                           GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
  GNUNET_assert (GNUNET_OK == ret);
  if (sub == msub)
  {
    GNUNET_STATISTICS_set (stats,
                           "# known peers",
                           GNUNET_CONTAINER_multipeermap_size (sub->peer_map),
                           GNUNET_NO);
  }
  return ctx;
}

References check_peer_known(), ctx, GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_put(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_set(), msub, Sub::peer_map, ret, stats, and PeerContext::sub.

Referenced by create_or_get_peer_ctx(), and insert_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_or_get_peer_ctx()

static struct PeerContext * create_or_get_peer_ctx	(	struct Sub *	sub,
		const struct GNUNET_PeerIdentity *	peer
	)

static

Create or get a PeerContext.

Parameters

sub	The Sub to which the created context belongs to
peer	the peer to get the associated context to

Returns: the context

Definition at line 700 of file gnunet-service-rps.c.

{
  if (GNUNET_NO == check_peer_known (sub->peer_map, peer))
  {
    return create_peer_ctx (sub, peer);
  }
  return get_peer_ctx (sub->peer_map, peer);
}

References check_peer_known(), create_peer_ctx(), get_peer_ctx(), GNUNET_NO, Sub::peer_map, and PeerContext::sub.

Referenced by handle_inbound_channel().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_connected()

static int check_connected ( struct PeerContext * peer_ctx )

static

Check whether we have a connection to this peer.

Also sets the Peers_ONLINE flag accordingly

Parameters

peer_ctx Context of the peer of which connectivity is to be checked

Returns: GNUNET_YES if we are connected GNUNET_NO otherwise

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

{
  /* If we don't know about this peer we don't know whether it's online */
  if (GNUNET_NO == check_peer_known (peer_ctx->sub->peer_map,
                                     &peer_ctx->peer_id))
  {
    return GNUNET_NO;
  }
  /* Get the context */
  peer_ctx = get_peer_ctx (peer_ctx->sub->peer_map, &peer_ctx->peer_id);
  /* If we have no channel to this peer we don't know whether it's online */
  if ((NULL == peer_ctx->send_channel_ctx) &&
      (NULL == peer_ctx->recv_channel_ctx))
  {
    UNSET_PEER_FLAG (peer_ctx, Peers_ONLINE);
    return GNUNET_NO;
  }
  /* Otherwise (if we have a channel, we know that it's online */
  SET_PEER_FLAG (peer_ctx, Peers_ONLINE);
  return GNUNET_YES;
}

References check_peer_known(), get_peer_ctx(), GNUNET_NO, GNUNET_YES, PeerContext::peer_id, Sub::peer_map, Peers_ONLINE, PeerContext::recv_channel_ctx, PeerContext::send_channel_ctx, SET_PEER_FLAG, PeerContext::sub, and UNSET_PEER_FLAG.

Referenced by destroy_sending_channel().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_rand_peer_iterator()

static int get_rand_peer_iterator	(	void *	cls,
		const struct GNUNET_PeerIdentity *	peer,
		void *	value
	)

static

Iterator function for get_random_peer_from_peermap.

Implements GNUNET_CONTAINER_PeerMapIterator. Decreases the index until the index is null. Then returns the current peer.

Parameters

cls	the GetRandPeerIteratorCls containing index and peer
peer	current peer
value	unused

Returns: GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

Definition at line 780 of file gnunet-service-rps.c.

{
  struct GetRandPeerIteratorCls *iterator_cls = cls;
 
  (void) value;
 
  if (0 >= iterator_cls->index)
  {
    iterator_cls->peer = peer;
    return GNUNET_NO;
  }
  iterator_cls->index--;
  return GNUNET_YES;
}

References GNUNET_NO, GNUNET_YES, GetRandPeerIteratorCls::index, GetRandPeerIteratorCls::peer, and value.

Referenced by get_random_peer_from_peermap().

Here is the caller graph for this function:

◆ get_random_peer_from_peermap()

static const struct GNUNET_PeerIdentity * get_random_peer_from_peermap ( struct GNUNET_CONTAINER_MultiPeerMap * valid_peers )

static

Get a random peer from peer_map.

Parameters

valid_peers Peer map containing valid peers from which to select a random one

Returns: a random peer

Definition at line 807 of file gnunet-service-rps.c.

{
  struct GetRandPeerIteratorCls *iterator_cls;
  const struct GNUNET_PeerIdentity *ret;
 
  iterator_cls = GNUNET_new (struct GetRandPeerIteratorCls);
  iterator_cls->index = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
                                                  GNUNET_CONTAINER_multipeermap_size
                                                  (
                                                    valid_peers));
  (void) GNUNET_CONTAINER_multipeermap_iterate (valid_peers,
                                                get_rand_peer_iterator,
                                                iterator_cls);
  ret = iterator_cls->peer;
  GNUNET_free (iterator_cls);
  return ret;
}

References get_rand_peer_iterator(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_free, GNUNET_new, GetRandPeerIteratorCls::index, GetRandPeerIteratorCls::peer, and ret.

Referenced by add_valid_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_valid_peer()

static int add_valid_peer	(	const struct GNUNET_PeerIdentity *	peer,
		struct GNUNET_CONTAINER_MultiPeerMap *	valid_peers
	)

static

Add a given peer to valid peers.

If valid peers are already num_valid_peers_max, delete a peer previously.

Parameters

peer	The peer that is added to the valid peers.
valid_peers	Peer map of valid peers to which to add the peer

Returns: GNUNET_YES if no other peer had to be removed GNUNET_NO otherwise

Definition at line 838 of file gnunet-service-rps.c.

{
  const struct GNUNET_PeerIdentity *rand_peer;
  int ret;
 
  ret = GNUNET_YES;
  /* Remove random peers until there is space for a new one */
  while (num_valid_peers_max <=
         GNUNET_CONTAINER_multipeermap_size (valid_peers))
  {
    rand_peer = get_random_peer_from_peermap (valid_peers);
    GNUNET_CONTAINER_multipeermap_remove_all (valid_peers, rand_peer);
    ret = GNUNET_NO;
  }
  (void) GNUNET_CONTAINER_multipeermap_put (valid_peers, peer, NULL,
                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
  if (valid_peers == msub->valid_peers)
  {
    GNUNET_STATISTICS_set (stats,
                           "# valid peers",
                           GNUNET_CONTAINER_multipeermap_size (valid_peers),
                           GNUNET_NO);
  }
  return ret;
}

References get_random_peer_from_peermap(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_put(), GNUNET_CONTAINER_multipeermap_remove_all(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_NO, GNUNET_STATISTICS_set(), GNUNET_YES, msub, num_valid_peers_max, ret, stats, and Sub::valid_peers.

Referenced by handle_inbound_channel(), mq_online_check_successful(), and restore_valid_peers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ remove_pending_message()

static void remove_pending_message	(	struct PendingMessage *	pending_msg,
		int	cancel
	)

static

Remove a pending message from the respective DLL.

Parameters

pending_msg	the pending message to remove
cancel	whether to cancel the pending message, too

Definition at line 1092 of file gnunet-service-rps.c.

{
  struct PeerContext *peer_ctx;
 
  (void) cancel;
 
  peer_ctx = pending_msg->peer_ctx;
  GNUNET_assert (NULL != peer_ctx);
  GNUNET_CONTAINER_DLL_remove (peer_ctx->pending_messages_head,
                               peer_ctx->pending_messages_tail,
                               pending_msg);
  // TODO wait for the cadet implementation of message cancellation
  // if (GNUNET_YES == cancel)
  // {
  //  GNUNET_MQ_send_cancel (pending_msg->ev);
  // }
  GNUNET_free (pending_msg);
}

References GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_free, PendingMessage::peer_ctx, PeerContext::pending_messages_head, and PeerContext::pending_messages_tail.

Referenced by destroy_peer(), mq_notify_sent_cb(), mq_online_check_successful(), and set_peer_online().

Here is the caller graph for this function:

◆ set_peer_online()

static void set_peer_online ( struct PeerContext * peer_ctx )

static

Set the peer flag to living and call the pending operations on this peer.

Also adds peer to #valid_peers.

Parameters

peer_ctx the PeerContext of the peer to set online

Definition at line 878 of file gnunet-service-rps.c.

{
  struct GNUNET_PeerIdentity *peer;
  unsigned int i;
 
  peer = &peer_ctx->peer_id;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Peer %s is online and valid, calling %i pending operations on it\n",
       GNUNET_i2s (peer),
       peer_ctx->num_pending_ops);
 
  if (NULL != peer_ctx->online_check_pending)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Removing pending online check for peer %s\n",
         GNUNET_i2s (&peer_ctx->peer_id));
    // TODO wait until cadet sets mq->cancel_impl
    // GNUNET_MQ_send_cancel (peer_ctx->online_check_pending->ev);
    remove_pending_message (peer_ctx->online_check_pending, GNUNET_YES);
    peer_ctx->online_check_pending = NULL;
  }
 
  SET_PEER_FLAG (peer_ctx, Peers_ONLINE);
 
  /* Call pending operations */
  for (i = 0; i < peer_ctx->num_pending_ops; i++)
  {
    peer_ctx->pending_ops[i].op (peer_ctx->pending_ops[i].op_cls, peer);
  }
  GNUNET_array_grow (peer_ctx->pending_ops, peer_ctx->num_pending_ops, 0);
}

References GNUNET_array_grow, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_YES, LOG, PeerContext::num_pending_ops, PeerContext::online_check_pending, PeerPendingOp::op, PeerPendingOp::op_cls, PeerContext::peer_id, Peers_ONLINE, PeerContext::pending_ops, remove_pending_message(), and SET_PEER_FLAG.

Referenced by handle_inbound_channel(), and mq_online_check_successful().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cleanup_destroyed_channel()

static void cleanup_destroyed_channel	(	void *	cls,
		const struct GNUNET_CADET_Channel *	channel
	)

static

This is called when a channel is destroyed.

Removes peer completely from our knowledge if the send_channel was destroyed Otherwise simply delete the recv_channel Also check if the knowledge about this peer is still needed. If not, remove this peer from our knowledge.

Parameters

cls	The closure - Context to the channel
channel	The channel being closed

Definition at line 2836 of file gnunet-service-rps.c.

{
  struct ChannelCtx *channel_ctx = cls;
  struct PeerContext *peer_ctx = channel_ctx->peer_ctx;
 
  (void) channel;
 
  channel_ctx->channel = NULL;
  if ((NULL != peer_ctx) &&
      (peer_ctx->send_channel_ctx == channel_ctx) &&
      (GNUNET_YES == check_sending_channel_needed (peer_ctx)) )
  {
    remove_channel_ctx (channel_ctx);
    remove_peer (peer_ctx->sub, &peer_ctx->peer_id);
  }
  else
  {
    /* We need this if-else construct because we need to make sure the channel
     * (context) is cleaned up before removing the peer, but still need to
     * compare it while checking the condition */
    remove_channel_ctx (channel_ctx);
  }
}

References ChannelCtx::channel, check_sending_channel_needed(), GNUNET_YES, ChannelCtx::peer_ctx, PeerContext::peer_id, remove_channel_ctx(), remove_peer(), PeerContext::send_channel_ctx, and PeerContext::sub.

Referenced by get_channel(), and new_sub().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_peer_check()

static void handle_peer_check	(	void *	cls,
		const struct GNUNET_MessageHeader *	msg
	)

static

Handle a CHECK_LIVE message from another peer.

This does nothing. But without calling GNUNET_CADET_receive_done() the channel is blocked for all other communication.

Parameters

cls	Closure - Context of channel
msg	Message - unused

Definition at line 3533 of file gnunet-service-rps.c.

{
  const struct ChannelCtx *channel_ctx = cls;
  const struct GNUNET_PeerIdentity *peer = &channel_ctx->peer_ctx->peer_id;
 
  (void) msg;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received CHECK_LIVE (%s)\n", GNUNET_i2s (peer));
  if (channel_ctx->peer_ctx->sub == msub)
  {
    GNUNET_STATISTICS_update (stats,
                              "# pending online checks",
                              -1,
                              GNUNET_NO);
  }
 
  GNUNET_CADET_receive_done (channel_ctx->channel);
}

References ChannelCtx::channel, GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_NO, GNUNET_STATISTICS_update(), LOG, msg, msub, ChannelCtx::peer_ctx, PeerContext::peer_id, stats, and PeerContext::sub.

Here is the call graph for this function:

◆ handle_peer_push()

static void handle_peer_push	(	void *	cls,
		const struct GNUNET_MessageHeader *	msg
	)

static

Handle a PUSH message from another peer.

Check the proof of work and store the PeerID in the temporary list for pushed PeerIDs.

Parameters

cls	Closure - Context of channel
msg	Message - unused

Definition at line 3565 of file gnunet-service-rps.c.

{
  const struct ChannelCtx *channel_ctx = cls;
  const struct GNUNET_PeerIdentity *peer = &channel_ctx->peer_ctx->peer_id;
 
  (void) msg;
 
  // (check the proof of work (?))
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received PUSH (%s)\n",
       GNUNET_i2s (peer));
  if (channel_ctx->peer_ctx->sub == msub)
  {
    GNUNET_STATISTICS_update (stats, "# push message received", 1, GNUNET_NO);
    if ((NULL != map_single_hop) &&
        (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (map_single_hop,
                                                              peer)))
    {
      GNUNET_STATISTICS_update (stats,
                                "# push message received (multi-hop peer)",
                                1,
                                GNUNET_NO);
    }
  }
 
  #if ENABLE_MALICIOUS
  struct AttackedPeer *tmp_att_peer;
 
  if ((1 == mal_type) ||
      (3 == mal_type))
  {   /* Try to maximise representation */
    tmp_att_peer = GNUNET_new (struct AttackedPeer);
    tmp_att_peer->peer_id = *peer;
    if (NULL == att_peer_set)
      att_peer_set = GNUNET_CONTAINER_multipeermap_create (1, GNUNET_NO);
    if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (att_peer_set,
                                                             peer))
    {
      GNUNET_CONTAINER_DLL_insert (att_peers_head,
                                   att_peers_tail,
                                   tmp_att_peer);
      add_peer_array_to_set (peer, 1, att_peer_set);
    }
    else
    {
      GNUNET_free (tmp_att_peer);
    }
  }
 
 
  else if (2 == mal_type)
  {
    /* We attack one single well-known peer - simply ignore */
  }
  #endif /* ENABLE_MALICIOUS */
 
  /* Add the sending peer to the push_map */
  CustomPeerMap_put (channel_ctx->peer_ctx->sub->push_map, peer);
 
  GNUNET_break_op (check_peer_known (channel_ctx->peer_ctx->sub->peer_map,
                                     &channel_ctx->peer_ctx->peer_id));
  GNUNET_CADET_receive_done (channel_ctx->channel);
}

References ChannelCtx::channel, check_peer_known(), CustomPeerMap_put(), GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_multipeermap_contains(), GNUNET_CONTAINER_multipeermap_create(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_new, GNUNET_NO, GNUNET_STATISTICS_update(), LOG, map_single_hop, msg, msub, ChannelCtx::peer_ctx, PeerContext::peer_id, Sub::peer_map, Sub::push_map, stats, and PeerContext::sub.

Here is the call graph for this function:

◆ handle_peer_pull_request()

static void handle_peer_pull_request	(	void *	cls,
		const struct GNUNET_MessageHeader *	msg
	)

static

Handle PULL REQUEST request message from another peer.

Reply with the view of PeerIDs.

Parameters

cls	Closure - Context of channel
msg	Message - unused

Definition at line 3641 of file gnunet-service-rps.c.

{
  const struct ChannelCtx *channel_ctx = cls;
  struct PeerContext *peer_ctx = channel_ctx->peer_ctx;
  const struct GNUNET_PeerIdentity *peer = &peer_ctx->peer_id;
  const struct GNUNET_PeerIdentity *view_array;
 
  (void) msg;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Received PULL REQUEST (%s)\n", GNUNET_i2s (
         peer));
  if (peer_ctx->sub == msub)
  {
    GNUNET_STATISTICS_update (stats,
                              "# pull request message received",
                              1,
                              GNUNET_NO);
    if ((NULL != map_single_hop) &&
        (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (map_single_hop,
                                                              &peer_ctx->peer_id
                                                              )))
    {
      GNUNET_STATISTICS_update (stats,
                                "# pull request message received (multi-hop peer)",
                                1,
                                GNUNET_NO);
    }
  }
 
  #if ENABLE_MALICIOUS
  if ((1 == mal_type)
      || (3 == mal_type))
  {   /* Try to maximise representation */
    send_pull_reply (peer_ctx, mal_peers, num_mal_peers);
  }
 
  else if (2 == mal_type)
  {   /* Try to partition network */
    if (0 == GNUNET_memcmp (&attacked_peer, peer))
    {
      send_pull_reply (peer_ctx, mal_peers, num_mal_peers);
    }
  }
  #endif /* ENABLE_MALICIOUS */
 
  GNUNET_break_op (check_peer_known (channel_ctx->peer_ctx->sub->peer_map,
                                     &channel_ctx->peer_ctx->peer_id));
  GNUNET_CADET_receive_done (channel_ctx->channel);
  view_array = View_get_as_array (channel_ctx->peer_ctx->sub->view);
  send_pull_reply (peer_ctx,
                   view_array,
                   View_size (channel_ctx->peer_ctx->sub->view));
}

References ChannelCtx::channel, check_peer_known(), GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_CONTAINER_multipeermap_contains(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_memcmp, GNUNET_NO, GNUNET_STATISTICS_update(), LOG, map_single_hop, msg, msub, ChannelCtx::peer_ctx, PeerContext::peer_id, Sub::peer_map, send_pull_reply(), stats, PeerContext::sub, Sub::view, View_get_as_array(), and View_size().

Here is the call graph for this function:

◆ check_peer_pull_reply()

static int check_peer_pull_reply	(	void *	cls,
		const struct GNUNET_RPS_P2P_PullReplyMessage *	msg
	)

static

Check whether we sent a corresponding request and whether this reply is the first one.

Parameters

cls	Closure - Context of channel
msg	Message containing the replied peers

Definition at line 3705 of file gnunet-service-rps.c.

{
  struct ChannelCtx *channel_ctx = cls;
  struct PeerContext *sender_ctx = channel_ctx->peer_ctx;
 
  if (sizeof(struct GNUNET_RPS_P2P_PullReplyMessage) > ntohs (msg->header.size))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
 
  if ((ntohs (msg->header.size) - sizeof(struct
                                         GNUNET_RPS_P2P_PullReplyMessage))
      / sizeof(struct GNUNET_PeerIdentity) != ntohl (msg->num_peers))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "message says it sends %" PRIu32 " peers, have space for %lu peers\n",
         ntohl (msg->num_peers),
         (ntohs (msg->header.size) - sizeof(struct
                                            GNUNET_RPS_P2P_PullReplyMessage))
         / sizeof(struct GNUNET_PeerIdentity));
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
 
  if (GNUNET_YES != check_peer_flag (sender_ctx->sub->peer_map,
                                     &sender_ctx->peer_id,
                                     Peers_PULL_REPLY_PENDING))
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Received a pull reply from a peer (%s) we didn't request one from!\n",
         GNUNET_i2s (&sender_ctx->peer_id));
    if (sender_ctx->sub == msub)
    {
      GNUNET_STATISTICS_update (stats,
                                "# unrequested pull replies",
                                1,
                                GNUNET_NO);
    }
  }
  return GNUNET_OK;
}

References check_peer_flag(), GNUNET_break_op, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_i2s(), GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_YES, LOG, msg, msub, ChannelCtx::peer_ctx, PeerContext::peer_id, Sub::peer_map, Peers_PULL_REPLY_PENDING, GNUNET_MessageHeader::size, stats, and PeerContext::sub.

Here is the call graph for this function:

◆ handle_peer_pull_reply()

static void handle_peer_pull_reply	(	void *	cls,
		const struct GNUNET_RPS_P2P_PullReplyMessage *	msg
	)

static

Handle PULL REPLY message from another peer.

Parameters

cls	Closure
msg	The message header

Definition at line 3757 of file gnunet-service-rps.c.

{
  const struct ChannelCtx *channel_ctx = cls;
  const struct GNUNET_PeerIdentity *sender = &channel_ctx->peer_ctx->peer_id;
  const struct GNUNET_PeerIdentity *peers;
  struct Sub *sub = channel_ctx->peer_ctx->sub;
  uint32_t i;
 
#if ENABLE_MALICIOUS
  struct AttackedPeer *tmp_att_peer;
#endif /* ENABLE_MALICIOUS */
 
  sub->pull_delays[sub->num_rounds - channel_ctx->peer_ctx->round_pull_req]++;
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Received PULL REPLY (%s)\n", GNUNET_i2s (
         sender));
  if (channel_ctx->peer_ctx->sub == msub)
  {
    GNUNET_STATISTICS_update (stats,
                              "# pull reply messages received",
                              1,
                              GNUNET_NO);
    if ((NULL != map_single_hop) &&
        (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (map_single_hop,
                                                              &channel_ctx->
                                                              peer_ctx->peer_id)
        ) )
    {
      GNUNET_STATISTICS_update (stats,
                                "# pull reply messages received (multi-hop peer)",
                                1,
                                GNUNET_NO);
    }
  }
 
  #if ENABLE_MALICIOUS
  // We shouldn't even receive pull replies as we're not sending
  if (2 == mal_type)
  {
  }
  #endif /* ENABLE_MALICIOUS */
 
  /* Do actual logic */
  peers = (const struct GNUNET_PeerIdentity *) &msg[1];
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "PULL REPLY received, got following %u peers:\n",
       ntohl (msg->num_peers));
 
  for (i = 0; i < ntohl (msg->num_peers); i++)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "%u. %s\n",
         i,
         GNUNET_i2s (&peers[i]));
 
    #if ENABLE_MALICIOUS
    if ((NULL != att_peer_set) &&
        ((1 == mal_type) || (3 == mal_type) ))
    {     /* Add attacked peer to local list */
          // TODO check if we sent a request and this was the first reply
      if ((GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (att_peer_set,
                                                                &peers[i]))
          && (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (mal_peer_set,
                                                                   &peers[i])) )
      {
        tmp_att_peer = GNUNET_new (struct AttackedPeer);
        tmp_att_peer->peer_id = peers[i];
        GNUNET_CONTAINER_DLL_insert (att_peers_head,
                                     att_peers_tail,
                                     tmp_att_peer);
        add_peer_array_to_set (&peers[i], 1, att_peer_set);
      }
      continue;
    }
    #endif /* ENABLE_MALICIOUS */
    /* Make sure we 'know' about this peer */
    (void) insert_peer (channel_ctx->peer_ctx->sub,
                        &peers[i]);
 
    if (GNUNET_YES == check_peer_valid (channel_ctx->peer_ctx->sub->valid_peers,
                                        &peers[i]))
    {
      CustomPeerMap_put (channel_ctx->peer_ctx->sub->pull_map,
                         &peers[i]);
    }
    else
    {
      schedule_operation (channel_ctx->peer_ctx,
                          insert_in_pull_map,
                          channel_ctx->peer_ctx->sub);    /* cls */
      (void) issue_peer_online_check (channel_ctx->peer_ctx->sub,
                                      &peers[i]);
    }
  }
 
  UNSET_PEER_FLAG (get_peer_ctx (channel_ctx->peer_ctx->sub->peer_map,
                                 sender),
                   Peers_PULL_REPLY_PENDING);
  clean_peer (channel_ctx->peer_ctx->sub,
              sender);
 
  GNUNET_break_op (check_peer_known (channel_ctx->peer_ctx->sub->peer_map,
                                     sender));
  GNUNET_CADET_receive_done (channel_ctx->channel);
}

References ChannelCtx::channel, check_peer_known(), check_peer_valid(), clean_peer(), CustomPeerMap_put(), get_peer_ctx(), GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_multipeermap_contains(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_new, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_YES, insert_in_pull_map(), insert_peer(), issue_peer_online_check(), LOG, map_single_hop, msg, msub, Sub::num_rounds, ChannelCtx::peer_ctx, PeerContext::peer_id, Sub::peer_map, peers, Peers_PULL_REPLY_PENDING, Sub::pull_delays, Sub::pull_map, PeerContext::round_pull_req, schedule_operation(), stats, PeerContext::sub, UNSET_PEER_FLAG, and Sub::valid_peers.

Here is the call graph for this function:

◆ add_channel_ctx()

static struct ChannelCtx * add_channel_ctx ( struct PeerContext * peer_ctx )

static

Allocate memory for a new channel context and insert it into DLL.

Parameters

peer_ctx context of the according peer

Returns: The channel context

Definition at line 946 of file gnunet-service-rps.c.

{
  struct ChannelCtx *channel_ctx;
 
  channel_ctx = GNUNET_new (struct ChannelCtx);
  channel_ctx->peer_ctx = peer_ctx;
  return channel_ctx;
}

References GNUNET_new, and ChannelCtx::peer_ctx.

Referenced by get_channel(), and handle_inbound_channel().

Here is the caller graph for this function:

◆ remove_channel_ctx()

static void remove_channel_ctx ( struct ChannelCtx * channel_ctx )

static

Free memory and NULL pointers.

Parameters

channel_ctx The channel context.

Definition at line 962 of file gnunet-service-rps.c.

{
  struct PeerContext *peer_ctx = channel_ctx->peer_ctx;
 
  if (NULL != channel_ctx->destruction_task)
  {
    GNUNET_SCHEDULER_cancel (channel_ctx->destruction_task);
    channel_ctx->destruction_task = NULL;
  }
 
  if (NULL == peer_ctx)
    return;
  if (channel_ctx == peer_ctx->send_channel_ctx)
  {
    peer_ctx->send_channel_ctx = NULL;
    peer_ctx->mq = NULL;
  }
  else if (channel_ctx == peer_ctx->recv_channel_ctx)
  {
    peer_ctx->recv_channel_ctx = NULL;
  }
  GNUNET_free (channel_ctx);
}

References ChannelCtx::destruction_task, GNUNET_free, GNUNET_SCHEDULER_cancel(), PeerContext::mq, ChannelCtx::peer_ctx, PeerContext::recv_channel_ctx, and PeerContext::send_channel_ctx.

Referenced by cleanup_destroyed_channel(), and destroy_channel().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_channel()

struct GNUNET_CADET_Channel * get_channel ( struct PeerContext * peer_ctx )

Get the channel of a peer.

If not existing, create.

Parameters

peer_ctx Context of the peer of which to get the channel

Returns: the GNUNET_CADET_Channel used to send data to peer_ctx

Definition at line 994 of file gnunet-service-rps.c.

{
  /* There exists a copy-paste-clone in run() */
  struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
    GNUNET_MQ_hd_fixed_size (peer_check,
                             GNUNET_MESSAGE_TYPE_RPS_PP_CHECK_LIVE,
                             struct GNUNET_MessageHeader,
                             NULL),
    GNUNET_MQ_hd_fixed_size (peer_push,
                             GNUNET_MESSAGE_TYPE_RPS_PP_PUSH,
                             struct GNUNET_MessageHeader,
                             NULL),
    GNUNET_MQ_hd_fixed_size (peer_pull_request,
                             GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REQUEST,
                             struct GNUNET_MessageHeader,
                             NULL),
    GNUNET_MQ_hd_var_size (peer_pull_reply,
                           GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REPLY,
                           struct GNUNET_RPS_P2P_PullReplyMessage,
                           NULL),
    GNUNET_MQ_handler_end ()
  };
 
 
  if (NULL == peer_ctx->send_channel_ctx)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Trying to establish channel to peer %s\n",
         GNUNET_i2s (&peer_ctx->peer_id));
    peer_ctx->send_channel_ctx = add_channel_ctx (peer_ctx);
    peer_ctx->send_channel_ctx->channel =
      GNUNET_CADET_channel_create (cadet_handle,
                                   peer_ctx->send_channel_ctx,  /* context */
                                   &peer_ctx->peer_id,
                                   &peer_ctx->sub->hash,
                                   NULL,  /* WindowSize handler */
                                   &cleanup_destroyed_channel,  /* Disconnect handler */
                                   cadet_handlers);
  }
  GNUNET_assert (NULL != peer_ctx->send_channel_ctx);
  GNUNET_assert (NULL != peer_ctx->send_channel_ctx->channel);
  return peer_ctx->send_channel_ctx->channel;
}

References add_channel_ctx(), cadet_handle, ChannelCtx::channel, cleanup_destroyed_channel(), GNUNET_assert, GNUNET_CADET_channel_create(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_MESSAGE_TYPE_RPS_PP_CHECK_LIVE, GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REPLY, GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REQUEST, GNUNET_MESSAGE_TYPE_RPS_PP_PUSH, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, Sub::hash, LOG, PeerContext::peer_id, PeerContext::send_channel_ctx, and PeerContext::sub.

Referenced by get_mq(), and indicate_sending_intention().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_mq()

static struct GNUNET_MQ_Handle * get_mq ( struct PeerContext * peer_ctx )

static

Get the message queue (GNUNET_MQ_Handle) of a specific peer.

If we already have a message queue open to this client, simply return it, otherwise create one.

Parameters

peer_ctx Context of the peer of which to get the mq

Returns: the GNUNET_MQ_Handle

Definition at line 1049 of file gnunet-service-rps.c.

{
  if (NULL == peer_ctx->mq)
  {
    peer_ctx->mq = GNUNET_CADET_get_mq (get_channel (peer_ctx));
  }
  return peer_ctx->mq;
}

References get_channel(), GNUNET_CADET_get_mq(), and PeerContext::mq.

Referenced by check_peer_online(), and send_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ insert_pending_message()

static struct PendingMessage * insert_pending_message	(	struct PeerContext *	peer_ctx,
		struct GNUNET_MQ_Envelope *	ev,
		const char *	type
	)

static

Add an envelope to a message passed to mq to list of pending messages.

Parameters

peer_ctx	Context of the peer for which to insert the envelope
ev	envelope to the message
type	type of the message to be sent

Returns: pointer to pending message

Definition at line 1068 of file gnunet-service-rps.c.

{
  struct PendingMessage *pending_msg;
 
  pending_msg = GNUNET_new (struct PendingMessage);
  pending_msg->ev = ev;
  pending_msg->peer_ctx = peer_ctx;
  pending_msg->type = type;
  GNUNET_CONTAINER_DLL_insert (peer_ctx->pending_messages_head,
                               peer_ctx->pending_messages_tail,
                               pending_msg);
  return pending_msg;
}

References PendingMessage::ev, GNUNET_CONTAINER_DLL_insert, GNUNET_new, PendingMessage::peer_ctx, PeerContext::pending_messages_head, PeerContext::pending_messages_tail, type, and PendingMessage::type.

Referenced by check_peer_online(), and send_message().

Here is the caller graph for this function:

◆ mq_online_check_successful()

static void mq_online_check_successful ( void * cls )

static

This is called in response to the first message we sent as a online check.

Parameters

cls	PeerContext of peer with pending online check

Definition at line 1119 of file gnunet-service-rps.c.

{
  struct PeerContext *peer_ctx = cls;
 
  if (NULL != peer_ctx->online_check_pending)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Online check for peer %s was successful\n",
         GNUNET_i2s (&peer_ctx->peer_id));
    remove_pending_message (peer_ctx->online_check_pending, GNUNET_YES);
    peer_ctx->online_check_pending = NULL;
    set_peer_online (peer_ctx);
    (void) add_valid_peer (&peer_ctx->peer_id, peer_ctx->sub->valid_peers);
  }
}

References add_valid_peer(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_YES, LOG, PeerContext::online_check_pending, PeerContext::peer_id, remove_pending_message(), set_peer_online(), PeerContext::sub, and Sub::valid_peers.

Referenced by check_peer_online().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_peer_online()

static void check_peer_online ( struct PeerContext * peer_ctx )

static

Issue a check whether peer is online.

Parameters

peer_ctx the context of the peer

Definition at line 1142 of file gnunet-service-rps.c.

{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Get informed about peer %s getting online\n",
       GNUNET_i2s (&peer_ctx->peer_id));
 
  struct GNUNET_MQ_Handle *mq;
  struct GNUNET_MQ_Envelope *ev;
 
  ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_RPS_PP_CHECK_LIVE);
  peer_ctx->online_check_pending =
    insert_pending_message (peer_ctx, ev, "Check online");
  mq = get_mq (peer_ctx);
  GNUNET_MQ_notify_sent (ev,
                         mq_online_check_successful,
                         peer_ctx);
  GNUNET_MQ_send (mq, ev);
  if (peer_ctx->sub == msub)
  {
    GNUNET_STATISTICS_update (stats,
                              "# pending online checks",
                              1,
                              GNUNET_NO);
  }
}

References get_mq(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_MESSAGE_TYPE_RPS_PP_CHECK_LIVE, GNUNET_MQ_msg_header, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), GNUNET_NO, GNUNET_STATISTICS_update(), insert_pending_message(), LOG, mq, mq_online_check_successful(), msub, PeerContext::online_check_pending, PeerContext::peer_id, stats, and PeerContext::sub.

Referenced by issue_peer_online_check().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_operation_scheduled()

static int check_operation_scheduled	(	const struct PeerContext *	peer_ctx,
		const PeerOp	peer_op
	)

static

Check whether function of type PeerOp was already scheduled.

The array with pending operations will probably never grow really big, so iterating over it should be ok.

Parameters

peer_ctx	Context of the peer to check for the operation
peer_op	the operation (PeerOp) on the peer

Returns: GNUNET_YES if this operation is scheduled on that peer GNUNET_NO otherwise

Definition at line 1182 of file gnunet-service-rps.c.

{
  unsigned int i;
 
  for (i = 0; i < peer_ctx->num_pending_ops; i++)
    if (peer_op == peer_ctx->pending_ops[i].op)
      return GNUNET_YES;
  return GNUNET_NO;
}

References GNUNET_NO, GNUNET_YES, PeerContext::num_pending_ops, PeerPendingOp::op, and PeerContext::pending_ops.

Referenced by schedule_operation().

Here is the caller graph for this function:

◆ destroy_channel()

static void destroy_channel ( struct ChannelCtx * channel_ctx )

static

Callback for scheduler to destroy a channel.

Parameters

channel_ctx Context of the channel

Definition at line 1200 of file gnunet-service-rps.c.

{
  struct GNUNET_CADET_Channel *channel;
 
  if (NULL != channel_ctx->destruction_task)
  {
    GNUNET_SCHEDULER_cancel (channel_ctx->destruction_task);
    channel_ctx->destruction_task = NULL;
  }
  GNUNET_assert (channel_ctx->channel != NULL);
  channel = channel_ctx->channel;
  channel_ctx->channel = NULL;
  GNUNET_CADET_channel_destroy (channel);
  remove_channel_ctx (channel_ctx);
}

References ChannelCtx::channel, ChannelCtx::destruction_task, GNUNET_assert, GNUNET_CADET_channel_destroy(), GNUNET_SCHEDULER_cancel(), and remove_channel_ctx().

Referenced by destroy_channel_cb(), destroy_sending_channel(), and handle_inbound_channel().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ destroy_channel_cb()

static void destroy_channel_cb ( void * cls )

static

Destroy a cadet channel.

This satisfies the function signature of GNUNET_SCHEDULER_TaskCallback.

Parameters

cls

Definition at line 1225 of file gnunet-service-rps.c.

{
  struct ChannelCtx *channel_ctx = cls;
 
  channel_ctx->destruction_task = NULL;
  destroy_channel (channel_ctx);
}

References destroy_channel(), and ChannelCtx::destruction_task.

Referenced by schedule_channel_destruction().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ schedule_channel_destruction()

static void schedule_channel_destruction ( struct ChannelCtx * channel_ctx )

static

Schedule the destruction of a channel for immediately afterwards.

In case a channel is to be destroyed from within the callback to the destruction of another channel (send channel), we cannot call GNUNET_CADET_channel_destroy directly, but need to use this scheduling construction.

Parameters

channel_ctx channel to be destroyed.

Definition at line 1245 of file gnunet-service-rps.c.

{
  GNUNET_assert (NULL ==
                 channel_ctx->destruction_task);
  GNUNET_assert (NULL !=
                 channel_ctx->channel);
  channel_ctx->destruction_task =
    GNUNET_SCHEDULER_add_now (&destroy_channel_cb,
                              channel_ctx);
}

References ChannelCtx::channel, destroy_channel_cb(), ChannelCtx::destruction_task, GNUNET_assert, and GNUNET_SCHEDULER_add_now().

Referenced by destroy_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ destroy_peer()

static int destroy_peer ( struct PeerContext * peer_ctx )

static

Remove peer.

Empties the list with pending operations
Empties the list with pending messages
Cancels potentially existing online check
Schedules closing of send and recv channels
Removes peer from peer map

Parameters

peer_ctx Context of the peer to be destroyed

Returns: GNUNET_YES if peer was removed GNUNET_NO otherwise

Definition at line 1271 of file gnunet-service-rps.c.

{
  GNUNET_assert (NULL != peer_ctx);
  GNUNET_assert (NULL != peer_ctx->sub->peer_map);
  if (GNUNET_NO ==
      GNUNET_CONTAINER_multipeermap_contains (peer_ctx->sub->peer_map,
                                              &peer_ctx->peer_id))
  {
    return GNUNET_NO;
  }
  SET_PEER_FLAG (peer_ctx, Peers_TO_DESTROY);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Going to remove peer %s\n",
       GNUNET_i2s (&peer_ctx->peer_id));
  UNSET_PEER_FLAG (peer_ctx, Peers_ONLINE);
 
  /* Clear list of pending operations */
  // TODO this probably leaks memory
  //      ('only' the cls to the function. Not sure what to do with it)
  GNUNET_array_grow (peer_ctx->pending_ops,
                     peer_ctx->num_pending_ops,
                     0);
  /* Remove all pending messages */
  while (NULL != peer_ctx->pending_messages_head)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Removing unsent %s\n",
         peer_ctx->pending_messages_head->type);
    /* Cancel pending message, too */
    if ((NULL != peer_ctx->online_check_pending) &&
        (0 == memcmp (peer_ctx->pending_messages_head,
                      peer_ctx->online_check_pending,
                      sizeof(struct PendingMessage))))
    {
      peer_ctx->online_check_pending = NULL;
      if (peer_ctx->sub == msub)
      {
        GNUNET_STATISTICS_update (stats,
                                  "# pending online checks",
                                  -1,
                                  GNUNET_NO);
      }
    }
    remove_pending_message (peer_ctx->pending_messages_head,
                            GNUNET_YES);
  }
 
  /* If we are still waiting for notification whether this peer is online
   * cancel the according task */
  if (NULL != peer_ctx->online_check_pending)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Removing pending online check for peer %s\n",
                GNUNET_i2s (&peer_ctx->peer_id));
    // TODO wait until cadet sets mq->cancel_impl
    // GNUNET_MQ_send_cancel (peer_ctx->online_check_pending->ev);
    remove_pending_message (peer_ctx->online_check_pending,
                            GNUNET_YES);
    peer_ctx->online_check_pending = NULL;
  }
 
  if (NULL != peer_ctx->send_channel_ctx)
  {
    /* This is possibly called from within channel destruction */
    peer_ctx->send_channel_ctx->peer_ctx = NULL;
    schedule_channel_destruction (peer_ctx->send_channel_ctx);
    peer_ctx->send_channel_ctx = NULL;
    peer_ctx->mq = NULL;
  }
  if (NULL != peer_ctx->recv_channel_ctx)
  {
    /* This is possibly called from within channel destruction */
    peer_ctx->recv_channel_ctx->peer_ctx = NULL;
    schedule_channel_destruction (peer_ctx->recv_channel_ctx);
    peer_ctx->recv_channel_ctx = NULL;
  }
 
  if (GNUNET_YES !=
      GNUNET_CONTAINER_multipeermap_remove_all (peer_ctx->sub->peer_map,
                                                &peer_ctx->peer_id))
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "removing peer from peer_ctx->sub->peer_map failed\n");
  }
  if (peer_ctx->sub == msub)
  {
    GNUNET_STATISTICS_set (stats,
                           "# known peers",
                           GNUNET_CONTAINER_multipeermap_size (
                             peer_ctx->sub->peer_map),
                           GNUNET_NO);
  }
  GNUNET_free (peer_ctx);
  return GNUNET_YES;
}

References GNUNET_array_grow, GNUNET_assert, GNUNET_CONTAINER_multipeermap_contains(), GNUNET_CONTAINER_multipeermap_remove_all(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_set(), GNUNET_STATISTICS_update(), GNUNET_YES, LOG, PeerContext::mq, msub, PeerContext::num_pending_ops, PeerContext::online_check_pending, ChannelCtx::peer_ctx, PeerContext::peer_id, Sub::peer_map, Peers_ONLINE, Peers_TO_DESTROY, PeerContext::pending_messages_head, PeerContext::pending_ops, PeerContext::recv_channel_ctx, remove_pending_message(), schedule_channel_destruction(), PeerContext::send_channel_ctx, SET_PEER_FLAG, stats, PeerContext::sub, PendingMessage::type, and UNSET_PEER_FLAG.

Referenced by peermap_clear_iterator(), and remove_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ peermap_clear_iterator()

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

static

Iterator over hash map entries.

Deletes all contexts of peers.

Parameters

cls	closure
key	current public key
value	value in the hash map

Returns: GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

Definition at line 1378 of file gnunet-service-rps.c.

{
  struct Sub *sub = cls;
 
  (void) value;
 
  destroy_peer (get_peer_ctx (sub->peer_map, key));
  return GNUNET_YES;
}

References destroy_peer(), get_peer_ctx(), GNUNET_YES, key, Sub::peer_map, and value.

Referenced by peers_terminate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mq_notify_sent_cb()

static void mq_notify_sent_cb ( void * cls )

static

This is called once a message is sent.

Removes the pending message

Parameters

cls	type of the message that was sent

Definition at line 1399 of file gnunet-service-rps.c.

{
  struct PendingMessage *pending_msg = (struct PendingMessage *) cls;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "%s was sent.\n",
       pending_msg->type);
  if (pending_msg->peer_ctx->sub == msub)
  {
    if (0 == strncmp ("PULL REPLY", pending_msg->type, 10))
      GNUNET_STATISTICS_update (stats, "# pull replies sent", 1, GNUNET_NO);
    if (0 == strncmp ("PULL REQUEST", pending_msg->type, 12))
      GNUNET_STATISTICS_update (stats, "# pull requests sent", 1, GNUNET_NO);
    if (0 == strncmp ("PUSH", pending_msg->type, 4))
      GNUNET_STATISTICS_update (stats, "# pushes sent", 1, GNUNET_NO);
    if ((0 == strncmp ("PULL REQUEST", pending_msg->type, 12)) &&
        (NULL != map_single_hop) &&
        (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (map_single_hop,
                                                              &pending_msg->
                                                              peer_ctx->peer_id)
        ) )
      GNUNET_STATISTICS_update (stats,
                                "# pull requests sent (multi-hop peer)",
                                1,
                                GNUNET_NO);
  }
  /* Do not cancel message */
  remove_pending_message (pending_msg, GNUNET_NO);
}

References GNUNET_CONTAINER_multipeermap_contains(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_NO, GNUNET_STATISTICS_update(), LOG, map_single_hop, msub, PendingMessage::peer_ctx, PeerContext::peer_id, remove_pending_message(), stats, PeerContext::sub, and PendingMessage::type.

Referenced by send_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ store_peer_presistently_iterator()

static int store_peer_presistently_iterator	(	void *	cls,
		const struct GNUNET_PeerIdentity *	peer,
		void *	value
	)

static

Iterator function for store_valid_peers.

Implements GNUNET_CONTAINER_PeerMapIterator. Writes single peer to disk.

Parameters

cls	the file handle to write to.
peer	current peer
value	unused

Returns: GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

Definition at line 1445 of file gnunet-service-rps.c.

{
  const struct GNUNET_DISK_FileHandle *fh = cls;
  char peer_string[128];
  int size;
  ssize_t ret;
 
  (void) value;
 
  if (NULL == peer)
  {
    return GNUNET_YES;
  }
  size = GNUNET_snprintf (peer_string,
                          sizeof(peer_string),
                          "%s\n",
                          GNUNET_i2s_full (peer));
  GNUNET_assert (53 == size);
  ret = GNUNET_DISK_file_write (fh,
                                peer_string,
                                size);
  GNUNET_assert (size == ret);
  return GNUNET_YES;
}

References GNUNET_assert, GNUNET_DISK_file_write(), GNUNET_i2s_full(), GNUNET_snprintf(), GNUNET_YES, ret, size, and value.

Referenced by store_valid_peers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ store_valid_peers()

static void store_valid_peers ( const struct Sub * sub )

static

Store the peers currently in #valid_peers to disk.

Parameters

sub	Sub for which to store the valid peers

Definition at line 1479 of file gnunet-service-rps.c.

{
  struct GNUNET_DISK_FileHandle *fh;
  uint32_t number_written_peers;
  int ret;
 
  if (0 == strncmp ("DISABLE", sub->filename_valid_peers, 7))
  {
    return;
  }
 
  ret = GNUNET_DISK_directory_create_for_file (sub->filename_valid_peers);
  if (GNUNET_SYSERR == ret)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Not able to create directory for file `%s'\n",
         sub->filename_valid_peers);
    GNUNET_break (0);
  }
  else if (GNUNET_NO == ret)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Directory for file `%s' exists but is not writable for us\n",
         sub->filename_valid_peers);
    GNUNET_break (0);
  }
  fh = GNUNET_DISK_file_open (sub->filename_valid_peers,
                              GNUNET_DISK_OPEN_WRITE
                              | GNUNET_DISK_OPEN_CREATE,
                              GNUNET_DISK_PERM_USER_READ
                              | GNUNET_DISK_PERM_USER_WRITE);
  if (NULL == fh)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Not able to write valid peers to file `%s'\n",
         sub->filename_valid_peers);
    return;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Writing %u valid peers to disk\n",
       GNUNET_CONTAINER_multipeermap_size (sub->valid_peers));
  number_written_peers =
    GNUNET_CONTAINER_multipeermap_iterate (sub->valid_peers,
                                           store_peer_presistently_iterator,
                                           fh);
  GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
  GNUNET_assert (number_written_peers ==
                 GNUNET_CONTAINER_multipeermap_size (sub->valid_peers));
}

References Sub::filename_valid_peers, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_DISK_directory_create_for_file(), GNUNET_DISK_file_close(), GNUNET_DISK_file_open(), GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_OPEN_WRITE, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, LOG, ret, store_peer_presistently_iterator(), and Sub::valid_peers.

Referenced by peers_terminate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ s2i_full()

static const struct GNUNET_PeerIdentity * s2i_full ( const char * string_repr )

static

Convert string representation of peer id to peer id.

Counterpart to GNUNET_i2s_full.

Parameters

string_repr The string representation of the peer id

Returns: The peer id

Definition at line 1540 of file gnunet-service-rps.c.

{
  struct GNUNET_PeerIdentity *peer;
  size_t len;
  int ret;
 
  peer = GNUNET_new (struct GNUNET_PeerIdentity);
  len = strlen (string_repr);
  if (52 > len)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Not able to convert string representation of PeerID to PeerID\n"
         "String representation: %s (len %lu) - too short\n",
         string_repr,
         len);
    GNUNET_break (0);
  }
  else if (52 < len)
  {
    len = 52;
  }
  ret = GNUNET_CRYPTO_eddsa_public_key_from_string (string_repr,
                                                    len,
                                                    &peer->public_key);
  if (GNUNET_OK != ret)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Not able to convert string representation of PeerID to PeerID\n"
         "String representation: %s\n",
         string_repr);
    GNUNET_break (0);
  }
  return peer;
}

References GNUNET_break, GNUNET_CRYPTO_eddsa_public_key_from_string(), GNUNET_ERROR_TYPE_WARNING, GNUNET_new, GNUNET_OK, LOG, GNUNET_PeerIdentity::public_key, and ret.

Referenced by restore_valid_peers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ restore_valid_peers()

static void restore_valid_peers ( const struct Sub * sub )

static

Restore the peers on disk to #valid_peers.

Parameters

sub	Sub for which to restore the valid peers

Definition at line 1582 of file gnunet-service-rps.c.

{
  off_t file_size;
  uint32_t num_peers;
  struct GNUNET_DISK_FileHandle *fh;
  char *buf;
  ssize_t size_read;
  char *iter_buf;
  char *str_repr;
  const struct GNUNET_PeerIdentity *peer;
 
  if (0 == strncmp ("DISABLE", sub->filename_valid_peers, 7))
  {
    return;
  }
 
  if (GNUNET_OK != GNUNET_DISK_file_test (sub->filename_valid_peers))
  {
    return;
  }
  fh = GNUNET_DISK_file_open (sub->filename_valid_peers,
                              GNUNET_DISK_OPEN_READ,
                              GNUNET_DISK_PERM_NONE);
  GNUNET_assert (NULL != fh);
  GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_handle_size (fh, &file_size));
  num_peers = file_size / 53;
  buf = GNUNET_malloc (file_size);
  size_read = GNUNET_DISK_file_read (fh, buf, file_size);
  GNUNET_assert (size_read == file_size);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Restoring %" PRIu32 " peers from file `%s'\n",
       num_peers,
       sub->filename_valid_peers);
  for (iter_buf = buf; iter_buf < buf + file_size - 1; iter_buf += 53)
  {
    str_repr = GNUNET_strndup (iter_buf, 53);
    peer = s2i_full (str_repr);
    GNUNET_free (str_repr);
    add_valid_peer (peer, sub->valid_peers);
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Restored valid peer %s from disk\n",
         GNUNET_i2s_full (peer));
  }
  iter_buf = NULL;
  GNUNET_free (buf);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "num_peers: %" PRIu32 ", _size (sub->valid_peers): %u\n",
       num_peers,
       GNUNET_CONTAINER_multipeermap_size (sub->valid_peers));
  if (num_peers != GNUNET_CONTAINER_multipeermap_size (sub->valid_peers))
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Number of restored peers does not match file size. Have probably duplicates.\n");
  }
  GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Restored %u valid peers from disk\n",
       GNUNET_CONTAINER_multipeermap_size (sub->valid_peers));
}

References add_valid_peer(), Sub::filename_valid_peers, GNUNET_assert, GNUNET_CONTAINER_multipeermap_size(), GNUNET_DISK_file_close(), GNUNET_DISK_file_handle_size(), GNUNET_DISK_file_open(), GNUNET_DISK_file_read(), GNUNET_DISK_file_test(), GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_NONE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_i2s_full(), GNUNET_malloc, GNUNET_OK, GNUNET_strndup, LOG, num_peers, s2i_full(), and Sub::valid_peers.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ peers_terminate()

static void peers_terminate ( struct Sub * sub )

static

Delete storage of peers that was created with #initialise_peers ()

Parameters

sub	Sub for which the storage is deleted

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

{
  if (GNUNET_SYSERR ==
      GNUNET_CONTAINER_multipeermap_iterate (sub->peer_map,
                                             &peermap_clear_iterator,
                                             sub))
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Iteration destroying peers was aborted.\n");
  }
  GNUNET_CONTAINER_multipeermap_destroy (sub->peer_map);
  sub->peer_map = NULL;
  store_valid_peers (sub);
  GNUNET_free (sub->filename_valid_peers);
  sub->filename_valid_peers = NULL;
  GNUNET_CONTAINER_multipeermap_destroy (sub->valid_peers);
  sub->valid_peers = NULL;
}

References Sub::filename_valid_peers, GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_SYSERR, LOG, Sub::peer_map, peermap_clear_iterator(), store_valid_peers(), and Sub::valid_peers.

Referenced by destroy_sub().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ valid_peer_iterator()

static int valid_peer_iterator	(	void *	cls,
		const struct GNUNET_PeerIdentity *	peer,
		void *	value
	)

static

Iterator over #valid_peers hash map entries.

Parameters

cls	Closure that contains iterator function and closure
peer	current peer id
value	value in the hash map - unused

Returns: GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

Definition at line 1680 of file gnunet-service-rps.c.

{
  struct PeersIteratorCls *it_cls = cls;
 
  (void) value;
 
  return it_cls->iterator (it_cls->cls, peer);
}

References PeersIteratorCls::cls, PeersIteratorCls::iterator, and value.

Referenced by get_valid_peers().

Here is the caller graph for this function:

◆ get_valid_peers()

static int get_valid_peers	(	struct GNUNET_CONTAINER_MultiPeerMap *	valid_peers,
		PeersIterator	iterator,
		void *	it_cls
	)

static

Get all currently known, valid peer ids.

Parameters

valid_peers	Peer map containing the valid peers in question
iterator	function to call on each peer id
it_cls	extra argument to iterator

Returns: the number of key value pairs processed, GNUNET_SYSERR if it aborted iteration

Definition at line 1702 of file gnunet-service-rps.c.

{
  struct PeersIteratorCls *cls;
  int ret;
 
  cls = GNUNET_new (struct PeersIteratorCls);
  cls->iterator = iterator;
  cls->cls = it_cls;
  ret = GNUNET_CONTAINER_multipeermap_iterate (valid_peers,
                                               valid_peer_iterator,
                                               cls);
  GNUNET_free (cls);
  return ret;
}

References PeersIteratorCls::cls, GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_free, GNUNET_new, PeersIteratorCls::iterator, ret, and valid_peer_iterator().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ insert_peer()

static int insert_peer	(	struct Sub *	sub,
		const struct GNUNET_PeerIdentity *	peer
	)

static

Add peer to known peers.

This function is called on new peer_ids from 'external' sources (client seed, cadet get_peers(), ...)

Parameters

sub	Sub with the peer map that the peer will be added to
peer	the new GNUNET_PeerIdentity

Returns: GNUNET_YES if peer was inserted GNUNET_NO otherwise

Definition at line 1733 of file gnunet-service-rps.c.

{
  if (GNUNET_YES == check_peer_known (sub->peer_map, peer))
  {
    return GNUNET_NO;   /* We already know this peer - nothing to do */
  }
  (void) create_peer_ctx (sub, peer);
  return GNUNET_YES;
}

References check_peer_known(), create_peer_ctx(), GNUNET_NO, GNUNET_YES, and Sub::peer_map.

Referenced by handle_peer_pull_reply(), and issue_peer_online_check().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_peer_flag()

static int check_peer_flag	(	const struct GNUNET_CONTAINER_MultiPeerMap *	peer_map,
		const struct GNUNET_PeerIdentity *	peer,
		enum Peers_PeerFlags	flags
	)

static

Check whether flags on a peer are set.

Parameters

peer_map	Peer map that is expected to contain the peer
peer	the peer to check the flag of
flags	the flags to check

Returns: GNUNET_SYSERR if peer is not known GNUNET_YES if all given flags are set GNUNET_NO otherwise

Definition at line 1757 of file gnunet-service-rps.c.

{
  struct PeerContext *peer_ctx;
 
  if (GNUNET_NO == check_peer_known (peer_map, peer))
  {
    return GNUNET_SYSERR;
  }
  peer_ctx = get_peer_ctx (peer_map, peer);
  return check_peer_flag_set (peer_ctx, flags);
}

References check_peer_flag_set, check_peer_known(), get_peer_ctx(), GNUNET_NO, and GNUNET_SYSERR.

Referenced by check_peer_pull_reply(), check_sending_channel_needed(), do_round(), insert_in_view(), issue_peer_online_check(), and send_pull_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ issue_peer_online_check()

static int issue_peer_online_check	(	struct Sub *	sub,
		const struct GNUNET_PeerIdentity *	peer
	)

static

Try connecting to a peer to see whether it is online.

If not known yet, insert into known peers

Parameters

sub	Sub which would contain the peer
peer	the peer whose online is to be checked

Returns: GNUNET_YES if the check was issued GNUNET_NO otherwise

Definition at line 1783 of file gnunet-service-rps.c.

{
  struct PeerContext *peer_ctx;
 
  (void) insert_peer (sub, peer);   // TODO even needed?
  peer_ctx = get_peer_ctx (sub->peer_map, peer);
  if ((GNUNET_NO == check_peer_flag (sub->peer_map, peer, Peers_ONLINE)) &&
      (NULL == peer_ctx->online_check_pending))
  {
    check_peer_online (peer_ctx);
    return GNUNET_YES;
  }
  return GNUNET_NO;
}

References check_peer_flag(), check_peer_online(), get_peer_ctx(), GNUNET_NO, GNUNET_YES, insert_peer(), PeerContext::online_check_pending, Sub::peer_map, Peers_ONLINE, and PeerContext::sub.

Referenced by got_peer(), handle_peer_pull_reply(), insert_in_sampler(), and insert_in_view().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_removable()

static int check_removable ( const struct PeerContext * peer_ctx )

static

Check if peer is removable.

Check if

a recv channel exists
there are pending messages
there is no pending pull reply

Parameters

peer_ctx Context of the peer in question

Returns: GNUNET_YES if peer is removable GNUNET_NO if peer is NOT removable GNUNET_SYSERR if peer is not known

Definition at line 1814 of file gnunet-service-rps.c.

{
  if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (
        peer_ctx->sub->peer_map,
        &peer_ctx->peer_id))
  {
    return GNUNET_SYSERR;
  }
 
  if ((NULL != peer_ctx->recv_channel_ctx) ||
      (NULL != peer_ctx->pending_messages_head) ||
      (GNUNET_YES == check_peer_flag_set (peer_ctx, Peers_PULL_REPLY_PENDING)))
  {
    return GNUNET_NO;
  }
  return GNUNET_YES;
}

References check_peer_flag_set, GNUNET_CONTAINER_multipeermap_contains(), GNUNET_NO, GNUNET_SYSERR, GNUNET_YES, PeerContext::peer_id, Sub::peer_map, Peers_PULL_REPLY_PENDING, PeerContext::pending_messages_head, PeerContext::recv_channel_ctx, and PeerContext::sub.

Referenced by clean_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_peer_valid()

static int check_peer_valid	(	const struct GNUNET_CONTAINER_MultiPeerMap *	valid_peers,
		const struct GNUNET_PeerIdentity *	peer
	)

static

Check whether peer is actually a peer.

A valid peer is a peer that we know exists eg. we were connected to once.

Parameters

valid_peers	Peer map that would contain the peer
peer	peer in question

Returns: GNUNET_YES if peer is valid GNUNET_NO if peer is not valid

Definition at line 1845 of file gnunet-service-rps.c.

{
  return GNUNET_CONTAINER_multipeermap_contains (valid_peers, peer);
}

References GNUNET_CONTAINER_multipeermap_contains().

Referenced by handle_peer_pull_reply().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ indicate_sending_intention()

static void indicate_sending_intention ( struct PeerContext * peer_ctx )

static

Indicate that we want to send to the other peer.

This establishes a sending channel

Parameters

peer_ctx Context of the target peer

Definition at line 1860 of file gnunet-service-rps.c.

{
  GNUNET_assert (GNUNET_YES == check_peer_known (peer_ctx->sub->peer_map,
                                                 &peer_ctx->peer_id));
  (void) get_channel (peer_ctx);
}

References check_peer_known(), get_channel(), GNUNET_assert, GNUNET_YES, PeerContext::peer_id, Sub::peer_map, and PeerContext::sub.

Referenced by insert_in_view().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_peer_send_intention()

static int check_peer_send_intention ( const struct PeerContext * peer_ctx )

static

Check whether other peer has the intention to send/opened channel towars us.

Parameters

peer_ctx Context of the peer in question

Returns: GNUNET_YES if peer has the intention to send GNUNET_NO otherwise

Definition at line 1878 of file gnunet-service-rps.c.

{
  if (NULL != peer_ctx->recv_channel_ctx)
  {
    return GNUNET_YES;
  }
  return GNUNET_NO;
}

References GNUNET_NO, GNUNET_YES, and PeerContext::recv_channel_ctx.

Referenced by clean_peer(), and handle_inbound_channel().

Here is the caller graph for this function:

◆ handle_inbound_channel()

static void * handle_inbound_channel	(	void *	cls,
		struct GNUNET_CADET_Channel *	channel,
		const struct GNUNET_PeerIdentity *	initiator
	)

static

Handle the channel a peer opens to us.

Parameters

cls	The closure - Sub
channel	The channel the peer wants to establish
initiator	The peer's peer ID

Returns: initial channel context for the channel (can be NULL – that's not an error)

Definition at line 1899 of file gnunet-service-rps.c.

{
  struct PeerContext *peer_ctx;
  struct ChannelCtx *channel_ctx;
  struct Sub *sub = cls;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "New channel was established to us (Peer %s).\n",
       GNUNET_i2s (initiator));
  GNUNET_assert (NULL != channel);  /* according to cadet API */
  /* Make sure we 'know' about this peer */
  peer_ctx = create_or_get_peer_ctx (sub, initiator);
  set_peer_online (peer_ctx);
  (void) add_valid_peer (&peer_ctx->peer_id, peer_ctx->sub->valid_peers);
  channel_ctx = add_channel_ctx (peer_ctx);
  channel_ctx->channel = channel;
  /* We only accept one incoming channel per peer */
  if (GNUNET_YES == check_peer_send_intention (get_peer_ctx (sub->peer_map,
                                                             initiator)))
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Already got one receive channel. Destroying old one.\n");
    GNUNET_break_op (0);
    destroy_channel (peer_ctx->recv_channel_ctx);
    peer_ctx->recv_channel_ctx = channel_ctx;
    /* return the channel context */
    return channel_ctx;
  }
  peer_ctx->recv_channel_ctx = channel_ctx;
  return channel_ctx;
}

References add_channel_ctx(), add_valid_peer(), ChannelCtx::channel, check_peer_send_intention(), create_or_get_peer_ctx(), destroy_channel(), get_peer_ctx(), GNUNET_assert, GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_i2s(), GNUNET_YES, LOG, PeerContext::peer_id, Sub::peer_map, PeerContext::recv_channel_ctx, set_peer_online(), PeerContext::sub, and Sub::valid_peers.

Referenced by new_sub().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_sending_channel_exists()

static int check_sending_channel_exists ( const struct PeerContext * peer_ctx )

static

Check whether a sending channel towards the given peer exists.

Parameters

peer_ctx Context of the peer in question

Returns: GNUNET_YES if a sending channel towards that peer exists GNUNET_NO otherwise

Definition at line 1943 of file gnunet-service-rps.c.

{
  if (GNUNET_NO == check_peer_known (peer_ctx->sub->peer_map,
                                     &peer_ctx->peer_id))
  {   /* If no such peer exists, there is no channel */
    return GNUNET_NO;
  }
  if (NULL == peer_ctx->send_channel_ctx)
  {
    return GNUNET_NO;
  }
  return GNUNET_YES;
}

References check_peer_known(), GNUNET_NO, GNUNET_YES, PeerContext::peer_id, Sub::peer_map, PeerContext::send_channel_ctx, and PeerContext::sub.

Referenced by check_sending_channel_needed().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ destroy_sending_channel()

static int destroy_sending_channel ( struct PeerContext * peer_ctx )

static

Destroy the send channel of a peer e.g.

stop indicating a sending intention to another peer

Parameters

peer_ctx Context to the peer

Returns: GNUNET_YES if channel was destroyed GNUNET_NO otherwise

Definition at line 1967 of file gnunet-service-rps.c.

{
  if (GNUNET_NO == check_peer_known (peer_ctx->sub->peer_map,
                                     &peer_ctx->peer_id))
  {
    return GNUNET_NO;
  }
  if (NULL != peer_ctx->send_channel_ctx)
  {
    destroy_channel (peer_ctx->send_channel_ctx);
    (void) check_connected (peer_ctx);
    return GNUNET_YES;
  }
  return GNUNET_NO;
}

References check_connected(), check_peer_known(), destroy_channel(), GNUNET_NO, GNUNET_YES, PeerContext::peer_id, Sub::peer_map, PeerContext::send_channel_ctx, and PeerContext::sub.

Referenced by clean_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_message()

static void send_message	(	struct PeerContext *	peer_ctx,
		struct GNUNET_MQ_Envelope *	ev,
		const char *	type
	)

static

Send a message to another peer.

Keeps track about pending messages so they can be properly removed when the peer is destroyed.

Parameters

peer_ctx	Context of the peer to which the message is to be sent
ev	envelope of the message
type	type of the message

Definition at line 1995 of file gnunet-service-rps.c.

{
  struct PendingMessage *pending_msg;
  struct GNUNET_MQ_Handle *mq;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending message to %s of type %s\n",
              GNUNET_i2s (&peer_ctx->peer_id),
              type);
  pending_msg = insert_pending_message (peer_ctx, ev, type);
  mq = get_mq (peer_ctx);
  GNUNET_MQ_notify_sent (ev,
                         mq_notify_sent_cb,
                         pending_msg);
  GNUNET_MQ_send (mq, ev);
}

References get_mq(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), insert_pending_message(), mq, mq_notify_sent_cb(), PeerContext::peer_id, and type.

Referenced by send_message_to_room(), send_pull_reply(), send_pull_request(), and send_push().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ schedule_operation()

static int schedule_operation	(	struct PeerContext *	peer_ctx,
		const PeerOp	peer_op,
		void *	cls
	)

static

Schedule a operation on given peer.

Avoids scheduling an operation twice.

Parameters

peer_ctx	Context of the peer for which to schedule the operation
peer_op	the operation to schedule
cls	Closure to peer_op

Returns: GNUNET_YES if the operation was scheduled GNUNET_NO otherwise

Definition at line 2028 of file gnunet-service-rps.c.

{
  struct PeerPendingOp pending_op;
 
  GNUNET_assert (GNUNET_YES == check_peer_known (peer_ctx->sub->peer_map,
                                                 &peer_ctx->peer_id));
 
  // TODO if ONLINE execute immediately
 
  if (GNUNET_NO == check_operation_scheduled (peer_ctx, peer_op))
  {
    pending_op.op = peer_op;
    pending_op.op_cls = cls;
    GNUNET_array_append (peer_ctx->pending_ops,
                         peer_ctx->num_pending_ops,
                         pending_op);
    return GNUNET_YES;
  }
  return GNUNET_NO;
}

References check_operation_scheduled(), check_peer_known(), GNUNET_array_append, GNUNET_assert, GNUNET_NO, GNUNET_YES, PeerContext::num_pending_ops, PeerPendingOp::op, PeerPendingOp::op_cls, PeerContext::peer_id, Sub::peer_map, PeerContext::pending_ops, and PeerContext::sub.

Referenced by got_peer(), handle_peer_pull_reply(), and insert_in_view().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ print_peer_list()

static void print_peer_list	(	struct GNUNET_PeerIdentity *	list,
		unsigned int	len
	)

static

Print peerlist to log.

Definition at line 2148 of file gnunet-service-rps.c.

{
  unsigned int i;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Printing peer list of length %u at %p:\n",
       len,
       list);
  for (i = 0; i < len; i++)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "%u. peer: %s\n",
         i, GNUNET_i2s (&list[i]));
  }
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), list, and LOG.

Referenced by handle_client_seed().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rem_from_list()

static void rem_from_list	(	struct GNUNET_PeerIdentity **	peer_list,
		unsigned int *	list_size,
		const struct GNUNET_PeerIdentity *	peer
	)

static

Remove peer from list.

Definition at line 2170 of file gnunet-service-rps.c.

{
  unsigned int i;
  struct GNUNET_PeerIdentity *tmp;
 
  tmp = *peer_list;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Removing peer %s from list at %p\n",
       GNUNET_i2s (peer),
       tmp);
 
  for (i = 0; i < *list_size; i++)
  {
    if (0 == GNUNET_memcmp (&tmp[i], peer))
    {
      if (i < *list_size - 1)
      {       /* Not at the last entry -- shift peers left */
        memmove (&tmp[i], &tmp[i + 1],
                 ((*list_size) - i - 1) * sizeof(struct GNUNET_PeerIdentity));
      }
      /* Remove last entry (should be now useless PeerID) */
      GNUNET_array_grow (tmp, *list_size, (*list_size) - 1);
    }
  }
  *peer_list = tmp;
}

References GNUNET_array_grow, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_memcmp, and LOG.

Referenced by do_round().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ insert_in_view_op()

static void insert_in_view_op	(	void *	cls,
		const struct GNUNET_PeerIdentity *	peer
	)

static

Insert PeerID in #view.

Called once we know a peer is online. Implements PeerOp

Returns: GNUNET_OK if peer was actually inserted GNUNET_NO if peer was not inserted

Called once we know a peer is online. Implements PeerOp

Parameters

cls	Closure - Sub with view to insert peer into
peer	the peer to insert

Definition at line 2598 of file gnunet-service-rps.c.

{
  struct Sub *sub = cls;
  int inserted;
 
  inserted = insert_in_view (sub, peer);
  if (GNUNET_OK == inserted)
  {
    clients_notify_stream_peer (sub, 1, peer);
  }
}

References clients_notify_stream_peer(), GNUNET_OK, and insert_in_view().

Referenced by got_peer(), and insert_in_view().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ insert_in_view()

static int insert_in_view	(	struct Sub *	sub,
		const struct GNUNET_PeerIdentity *	peer
	)

static

Insert PeerID in #view.

Called once we know a peer is online.

Parameters

sub	Sub in with the view to insert in
peer	the peer to insert

Returns: GNUNET_OK if peer was actually inserted GNUNET_NO if peer was not inserted

Definition at line 2226 of file gnunet-service-rps.c.

{
  struct PeerContext *peer_ctx;
  int online;
  int ret;
 
  online = check_peer_flag (sub->peer_map, peer, Peers_ONLINE);
  peer_ctx = get_peer_ctx (sub->peer_map, peer);  // TODO indirection needed?
  if ((GNUNET_NO == online) ||
      (GNUNET_SYSERR == online))   /* peer is not even known */
  {
    (void) issue_peer_online_check (sub, peer);
    (void) schedule_operation (peer_ctx, insert_in_view_op, sub);
    return GNUNET_NO;
  }
  /* Open channel towards peer to keep connection open */
  indicate_sending_intention (peer_ctx);
  ret = View_put (sub->view, peer);
  if (peer_ctx->sub == msub)
  {
    GNUNET_STATISTICS_set (stats,
                           "view size",
                           View_size (peer_ctx->sub->view),
                           GNUNET_NO);
  }
  return ret;
}

References check_peer_flag(), get_peer_ctx(), GNUNET_NO, GNUNET_STATISTICS_set(), GNUNET_SYSERR, indicate_sending_intention(), insert_in_view_op(), issue_peer_online_check(), msub, Sub::peer_map, Peers_ONLINE, ret, schedule_operation(), stats, PeerContext::sub, Sub::view, View_put(), and View_size().

Referenced by do_round(), hist_update(), and insert_in_view_op().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_view()

static void send_view	(	const struct ClientContext *	cli_ctx,
		const struct GNUNET_PeerIdentity *	view_array,
		uint64_t	view_size
	)

static

Send view to client.

Parameters

cli_ctx	the context of the client
view_array	the peerids of the view as array (can be empty)
view_size	the size of the view array (can be 0)

Definition at line 2264 of file gnunet-service-rps.c.

{
  struct GNUNET_MQ_Envelope *ev;
  struct GNUNET_RPS_CS_DEBUG_ViewReply *out_msg;
  struct Sub *sub;
 
  if (NULL == view_array)
  {
    if (NULL == cli_ctx->sub)
      sub = msub;
    else
      sub = cli_ctx->sub;
    view_size = View_size (sub->view);
    view_array = View_get_as_array (sub->view);
  }
 
  ev = GNUNET_MQ_msg_extra (out_msg,
                            view_size * sizeof(struct GNUNET_PeerIdentity),
                            GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_REPLY);
  out_msg->num_peers = htonl (view_size);
 
  GNUNET_memcpy (&out_msg[1],
                 view_array,
                 view_size * sizeof(struct GNUNET_PeerIdentity));
  GNUNET_MQ_send (cli_ctx->mq, ev);
}

References GNUNET_memcpy, GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_REPLY, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), ClientContext::mq, msub, GNUNET_RPS_CS_DEBUG_ViewReply::num_peers, ClientContext::sub, Sub::view, View_get_as_array(), and View_size().

Referenced by clients_notify_view_update(), and handle_client_view_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_stream_peers()

static void send_stream_peers	(	const struct ClientContext *	cli_ctx,
		uint64_t	num_peers,
		const struct GNUNET_PeerIdentity *	peers
	)

static

Send peer from biased stream to client.

TODO merge with send_view, parameterise

Parameters

cli_ctx	the context of the client
view_array	the peerids of the view as array (can be empty)
view_size	the size of the view array (can be 0)

Definition at line 2304 of file gnunet-service-rps.c.

{
  struct GNUNET_MQ_Envelope *ev;
  struct GNUNET_RPS_CS_DEBUG_StreamReply *out_msg;
 
  GNUNET_assert (NULL != peers);
 
  ev = GNUNET_MQ_msg_extra (out_msg,
                            num_peers * sizeof(struct GNUNET_PeerIdentity),
                            GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_STREAM_REPLY);
  out_msg->num_peers = htonl (num_peers);
 
  GNUNET_memcpy (&out_msg[1],
                 peers,
                 num_peers * sizeof(struct GNUNET_PeerIdentity));
  GNUNET_MQ_send (cli_ctx->mq, ev);
}

References GNUNET_assert, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_STREAM_REPLY, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), ClientContext::mq, GNUNET_RPS_CS_DEBUG_StreamReply::num_peers, num_peers, and peers.

Referenced by clients_notify_stream_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clients_notify_view_update()

static void clients_notify_view_update ( const struct Sub * sub )

static

sends updates to clients that are interested

Parameters

sub	Sub for which to notify clients

Definition at line 2331 of file gnunet-service-rps.c.

{
  struct ClientContext *cli_ctx_iter;
  uint64_t num_peers;
  const struct GNUNET_PeerIdentity *view_array;
 
  num_peers = View_size (sub->view);
  view_array = View_get_as_array (sub->view);
  /* check size of view is small enough */
  if (GNUNET_MAX_MESSAGE_SIZE < num_peers)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "View is too big to send\n");
    return;
  }
 
  for (cli_ctx_iter = cli_ctx_head;
       NULL != cli_ctx_iter;
       cli_ctx_iter = cli_ctx_iter->next)
  {
    if (1 < cli_ctx_iter->view_updates_left)
    {
      /* Client wants to receive limited amount of updates */
      cli_ctx_iter->view_updates_left -= 1;
    }
    else if (1 == cli_ctx_iter->view_updates_left)
    {
      /* Last update of view for client */
      cli_ctx_iter->view_updates_left = -1;
    }
    else if (0 > cli_ctx_iter->view_updates_left)
    {
      /* Client is not interested in updates */
      continue;
    }
    /* else _updates_left == 0 - infinite amount of updates */
 
    /* send view */
    send_view (cli_ctx_iter, view_array, num_peers);
  }
}

References cli_ctx_head, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_MAX_MESSAGE_SIZE, ClientContext::next, num_peers, send_view(), Sub::view, View_get_as_array(), View_size(), and ClientContext::view_updates_left.

Referenced by do_round(), and hist_update().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clients_notify_stream_peer()

static void clients_notify_stream_peer	(	const struct Sub *	sub,
		uint64_t	num_peers,
		const struct GNUNET_PeerIdentity *	peers
	)

static

sends updates to clients that are interested

Parameters

num_peers	Number of peers to send
peers	the array of peers to send

Definition at line 2381 of file gnunet-service-rps.c.

{
  struct ClientContext *cli_ctx_iter;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Got peer (%s) from biased stream - update all clients\n",
       GNUNET_i2s (peers));
 
  for (cli_ctx_iter = cli_ctx_head;
       NULL != cli_ctx_iter;
       cli_ctx_iter = cli_ctx_iter->next)
  {
    if ((GNUNET_YES == cli_ctx_iter->stream_update) &&
        ((sub == cli_ctx_iter->sub) || (sub == msub) ))
    {
      send_stream_peers (cli_ctx_iter, num_peers, peers);
    }
  }
}

References cli_ctx_head, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_YES, LOG, msub, ClientContext::next, num_peers, peers, send_stream_peers(), ClientContext::stream_update, and ClientContext::sub.

Referenced by do_round(), hist_update(), and insert_in_view_op().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ hist_update()

static void hist_update	(	const struct GNUNET_PeerIdentity *	ids,
		uint32_t	num_peers,
		void *	cls
	)

static

Put random peer from sampler into the view as history update.

Parameters

ids	Array of Peers to insert into view
num_peers	Number of peers to insert
cls	Closure - The Sub for which this is to be done

Definition at line 2413 of file gnunet-service-rps.c.

{
  unsigned int i;
  struct Sub *sub = cls;
 
  for (i = 0; i < num_peers; i++)
  {
    int inserted;
    if (GNUNET_YES != check_peer_known (sub->peer_map, &ids[i]))
    {
      LOG (GNUNET_ERROR_TYPE_WARNING,
           "Peer in history update not known!\n");
      continue;
    }
    inserted = insert_in_view (sub, &ids[i]);
    if (GNUNET_OK == inserted)
    {
      clients_notify_stream_peer (sub, 1, &ids[i]);
    }
#ifdef TO_FILE_FULL
    to_file (sub->file_name_view_log,
             "+%s\t(history)",
             GNUNET_i2s_full (ids));
#endif /* TO_FILE_FULL */
  }
  clients_notify_view_update (sub);
}

References check_peer_known(), clients_notify_stream_peer(), clients_notify_view_update(), GNUNET_ERROR_TYPE_WARNING, GNUNET_i2s_full(), GNUNET_OK, GNUNET_YES, insert_in_view(), LOG, num_peers, Sub::peer_map, and to_file.

Referenced by do_round().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resize_wrapper()

static void resize_wrapper	(	struct RPS_Sampler *	sampler,
		uint32_t	new_size
	)

static

Wrapper around RPS_sampler_resize()

If we do not have enough sampler elements, double current sampler size If we have more than enough sampler elements, halv current sampler size

Parameters

sampler	The sampler to resize
new_size	New size to which to resize

Definition at line 2454 of file gnunet-service-rps.c.

{
  unsigned int sampler_size;
 
  // TODO statistics
  // TODO respect the min, max
  sampler_size = RPS_sampler_get_size (sampler);
  if (sampler_size > new_size * 4)
  {   /* Shrinking */
    RPS_sampler_resize (sampler, sampler_size / 2);
  }
  else if (sampler_size < new_size)
  {   /* Growing */
    RPS_sampler_resize (sampler, sampler_size * 2);
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG, "sampler_size is now %u\n", sampler_size);
}

References GNUNET_ERROR_TYPE_DEBUG, LOG, RPS_sampler_get_size(), RPS_sampler_resize(), and Sub::sampler.

Referenced by adapt_sizes().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_pull_reply()

static void send_pull_reply	(	struct PeerContext *	peer_ctx,
		const struct GNUNET_PeerIdentity *	peer_ids,
		unsigned int	num_peer_ids
	)

static

Send a PULL REPLY to peer_id.

Parameters

peer_ctx	Context of the peer to send the reply to
peer_ids	the peers to send to peer_id
num_peer_ids	the number of peers to send to peer_id

Definition at line 2523 of file gnunet-service-rps.c.

{
  uint32_t send_size;
  struct GNUNET_MQ_Envelope *ev;
  struct GNUNET_RPS_P2P_PullReplyMessage *out_msg;
 
  /* Compute actual size */
  send_size = sizeof(struct GNUNET_RPS_P2P_PullReplyMessage)
              + num_peer_ids * sizeof(struct GNUNET_PeerIdentity);
 
  if (GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE < send_size)
    /* Compute number of peers to send
     * If too long, simply truncate */
    // TODO select random ones via permutation
    //      or even better: do good protocol design
    send_size =
      (GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE
       - sizeof(struct GNUNET_RPS_P2P_PullReplyMessage))
      / sizeof(struct GNUNET_PeerIdentity);
  else
    send_size = num_peer_ids;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Going to send PULL REPLY with %u peers to %s\n",
       send_size, GNUNET_i2s (&peer_ctx->peer_id));
 
  ev = GNUNET_MQ_msg_extra (out_msg,
                            send_size * sizeof(struct GNUNET_PeerIdentity),
                            GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REPLY);
  out_msg->num_peers = htonl (send_size);
  GNUNET_memcpy (&out_msg[1], peer_ids,
                 send_size * sizeof(struct GNUNET_PeerIdentity));
 
  send_message (peer_ctx, ev, "PULL REPLY");
  if (peer_ctx->sub == msub)
  {
    GNUNET_STATISTICS_update (stats, "# pull reply send issued", 1, GNUNET_NO);
  }
  // TODO check with send intention: as send_channel is used/opened we indicate
  // a sending intention without intending it.
  // -> clean peer afterwards?
  // -> use recv_channel?
}

References GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_memcpy, GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REPLY, GNUNET_MQ_msg_extra, GNUNET_NO, GNUNET_STATISTICS_update(), LOG, msub, GNUNET_RPS_P2P_PullReplyMessage::num_peers, PeerContext::peer_id, send_message(), stats, and PeerContext::sub.

Referenced by handle_peer_pull_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ insert_in_pull_map()

static void insert_in_pull_map	(	void *	cls,
		const struct GNUNET_PeerIdentity *	peer
	)

static

Insert PeerID in #pull_map.

Called once we know a peer is online.

Parameters

cls	Closure - Sub with the pull map to insert into
peer	Peer to insert

Definition at line 2579 of file gnunet-service-rps.c.

{
  struct Sub *sub = cls;
 
  CustomPeerMap_put (sub->pull_map, peer);
}

References CustomPeerMap_put(), and Sub::pull_map.

Referenced by handle_peer_pull_reply().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ insert_in_sampler()

static void insert_in_sampler	(	void *	cls,
		const struct GNUNET_PeerIdentity *	peer
	)

static

Update sampler with given PeerID.

Implements PeerOp

Parameters

cls	Closure - Sub containing the sampler to insert into
peer	Peer to insert

Definition at line 2620 of file gnunet-service-rps.c.

{
  struct Sub *sub = cls;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Updating samplers with peer %s from insert_in_sampler()\n",
       GNUNET_i2s (peer));
  RPS_sampler_update (sub->sampler, peer);
  if (0 < RPS_sampler_count_id (sub->sampler, peer))
  {
    /* Make sure we 'know' about this peer */
    (void) issue_peer_online_check (sub, peer);
    /* Establish a channel towards that peer to indicate we are going to send
     * messages to it */
    // indicate_sending_intention (peer);
  }
  if (sub == msub)
  {
    GNUNET_STATISTICS_update (stats,
                              "# observed peers in gossip",
                              1,
                              GNUNET_NO);
  }
#ifdef TO_FILE
  sub->num_observed_peers++;
  (void) GNUNET_CONTAINER_multipeermap_put
    (sub->observed_unique_peers,
    peer,
    NULL,
    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
  uint32_t num_observed_unique_peers =
    GNUNET_CONTAINER_multipeermap_size (sub->observed_unique_peers);
  GNUNET_STATISTICS_set (stats,
                         "# unique peers in gossip",
                         num_observed_unique_peers,
                         GNUNET_NO);
#ifdef TO_FILE_FULL
  to_file (sub->file_name_observed_log,
           "%" PRIu32 " %" PRIu32 " %f\n",
           sub->num_observed_peers,
           num_observed_unique_peers,
           1.0 * num_observed_unique_peers / sub->num_observed_peers)
#endif /* TO_FILE_FULL */
#endif /* TO_FILE */
}

References GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_put(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_NO, GNUNET_STATISTICS_set(), GNUNET_STATISTICS_update(), issue_peer_online_check(), LOG, msub, Sub::num_observed_peers, Sub::observed_unique_peers, RPS_sampler_count_id(), RPS_sampler_update(), Sub::sampler, stats, and to_file.

Referenced by do_round(), and got_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ got_peer()

static void got_peer	(	struct Sub *	sub,
		const struct GNUNET_PeerIdentity *	peer
	)

static

This is called on peers from external sources (cadet, peerinfo, ...) If the peer is not known, online check is issued and it is scheduled to be inserted in sampler and view.

"External sources" refer to every source except the gossip.

Parameters

sub	Sub for which peer was received
peer	peer to insert/peer received

Definition at line 2679 of file gnunet-service-rps.c.

{
  /* If we did not know this peer already, insert it into sampler and view */
  if (GNUNET_YES == issue_peer_online_check (sub, peer))
  {
    schedule_operation (get_peer_ctx (sub->peer_map, peer),
                        &insert_in_sampler, sub);
    schedule_operation (get_peer_ctx (sub->peer_map, peer),
                        &insert_in_view_op, sub);
  }
  if (sub == msub)
  {
    GNUNET_STATISTICS_update (stats,
                              "# learnd peers",
                              1,
                              GNUNET_NO);
  }
}

References get_peer_ctx(), GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_YES, insert_in_sampler(), insert_in_view_op(), issue_peer_online_check(), msub, Sub::peer_map, schedule_operation(), and stats.

Referenced by handle_client_seed(), init_peer_cb(), process_peerinfo_peers(), and valid_peers_iterator().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_sending_channel_needed()

static int check_sending_channel_needed ( const struct PeerContext * peer_ctx )

static

Checks if there is a sending channel and if it is needed.

Parameters

peer_ctx Context of the peer to check

Returns: GNUNET_YES if sending channel exists and is still needed GNUNET_NO otherwise

Definition at line 2708 of file gnunet-service-rps.c.

{
  /* struct GNUNET_CADET_Channel *channel; */
  if (GNUNET_NO == check_peer_known (peer_ctx->sub->peer_map,
                                     &peer_ctx->peer_id))
  {
    return GNUNET_NO;
  }
  if (GNUNET_YES == check_sending_channel_exists (peer_ctx))
  {
    if ((0 < RPS_sampler_count_id (peer_ctx->sub->sampler,
                                   &peer_ctx->peer_id)) ||
        (GNUNET_YES == View_contains_peer (peer_ctx->sub->view,
                                           &peer_ctx->peer_id)) ||
        (GNUNET_YES == CustomPeerMap_contains_peer (peer_ctx->sub->push_map,
                                                    &peer_ctx->peer_id)) ||
        (GNUNET_YES == CustomPeerMap_contains_peer (peer_ctx->sub->pull_map,
                                                    &peer_ctx->peer_id)) ||
        (GNUNET_YES == check_peer_flag (peer_ctx->sub->peer_map,
                                        &peer_ctx->peer_id,
                                        Peers_PULL_REPLY_PENDING)))
    {     /* If we want to keep the connection to peer open */
      return GNUNET_YES;
    }
    return GNUNET_NO;
  }
  return GNUNET_NO;
}

References check_peer_flag(), check_peer_known(), check_sending_channel_exists(), CustomPeerMap_contains_peer(), GNUNET_NO, GNUNET_YES, PeerContext::peer_id, Sub::peer_map, Peers_PULL_REPLY_PENDING, Sub::pull_map, Sub::push_map, RPS_sampler_count_id(), Sub::sampler, PeerContext::sub, Sub::view, and View_contains_peer().

Referenced by clean_peer(), and cleanup_destroyed_channel().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ remove_peer()

static void remove_peer	(	struct Sub *	sub,
		const struct GNUNET_PeerIdentity *	peer
	)

static

remove peer from our knowledge, the view, push and pull maps and samplers.

Parameters

sub	Sub with the data structures the peer is to be removed from
peer	the peer to remove

Definition at line 2746 of file gnunet-service-rps.c.

{
  (void) View_remove_peer (sub->view,
                           peer);
  CustomPeerMap_remove_peer (sub->pull_map,
                             peer);
  CustomPeerMap_remove_peer (sub->push_map,
                             peer);
  RPS_sampler_reinitialise_by_value (sub->sampler,
                                     peer);
  /* We want to destroy the peer now.
   * Sometimes, it just seems that it's already been removed from the peer_map,
   * so check the peer_map first. */
  if (GNUNET_YES == check_peer_known (sub->peer_map,
                                      peer))
  {
    destroy_peer (get_peer_ctx (sub->peer_map,
                                peer));
  }
}

References check_peer_known(), CustomPeerMap_remove_peer(), destroy_peer(), get_peer_ctx(), GNUNET_YES, Sub::peer_map, Sub::pull_map, Sub::push_map, RPS_sampler_reinitialise_by_value(), Sub::sampler, Sub::view, and View_remove_peer().

Referenced by clean_peer(), and cleanup_destroyed_channel().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clean_peer()

static void clean_peer	(	struct Sub *	sub,
		const struct GNUNET_PeerIdentity *	peer
	)

static

Remove data that is not needed anymore.

If the sending channel is no longer needed it is destroyed.

Parameters

sub	Sub in which the current peer is to be cleaned
peer	the peer whose data is about to be cleaned

Definition at line 2778 of file gnunet-service-rps.c.

{
  if (GNUNET_NO == check_sending_channel_needed (get_peer_ctx (sub->peer_map,
                                                               peer)))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Going to remove send channel to peer %s\n",
         GNUNET_i2s (peer));
    #if ENABLE_MALICIOUS
    if (0 != GNUNET_memcmp (&attacked_peer,
                            peer))
      (void) destroy_sending_channel (get_peer_ctx (sub->peer_map,
                                                    peer));
    #else /* ENABLE_MALICIOUS */
    (void) destroy_sending_channel (get_peer_ctx (sub->peer_map,
                                                  peer));
    #endif /* ENABLE_MALICIOUS */
  }
 
  if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (sub->peer_map,
                                                           peer))
  {
    /* Peer was already removed by callback on destroyed channel */
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Peer was removed from our knowledge during cleanup\n");
    return;
  }
 
  if ((GNUNET_NO == check_peer_send_intention (get_peer_ctx (sub->peer_map,
                                                             peer))) &&
      (GNUNET_NO == View_contains_peer (sub->view, peer)) &&
      (GNUNET_NO == CustomPeerMap_contains_peer (sub->push_map, peer)) &&
      (GNUNET_NO == CustomPeerMap_contains_peer (sub->pull_map, peer)) &&
      (0 == RPS_sampler_count_id (sub->sampler, peer)) &&
      (GNUNET_YES == check_removable (get_peer_ctx (sub->peer_map, peer))))
  {   /* We can safely remove this peer */
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Going to remove peer %s\n",
         GNUNET_i2s (peer));
    remove_peer (sub, peer);
    return;
  }
}

References check_peer_send_intention(), check_removable(), check_sending_channel_needed(), CustomPeerMap_contains_peer(), destroy_sending_channel(), get_peer_ctx(), GNUNET_CONTAINER_multipeermap_contains(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_i2s(), GNUNET_memcmp, GNUNET_NO, GNUNET_YES, LOG, Sub::peer_map, Sub::pull_map, Sub::push_map, remove_peer(), RPS_sampler_count_id(), Sub::sampler, Sub::view, and View_contains_peer().

Referenced by do_round(), and handle_peer_pull_reply().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ new_sub()

struct Sub * new_sub	(	const struct GNUNET_HashCode *	hash,
		uint32_t	sampler_size,
		struct GNUNET_TIME_Relative	round_interval
	)

Create a new Sub.

Parameters

hash	Hash of value shared among rps instances on other hosts that defines a subgroup to sample from.
sampler_size	Size of the sampler
round_interval	Interval (in average) between two rounds

Returns: Sub

Definition at line 2882 of file gnunet-service-rps.c.

{
  struct Sub *sub;
 
  sub = GNUNET_new (struct Sub);
 
  /* With the hash generated from the secret value this service only connects
   * to rps instances that share the value */
  struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
    GNUNET_MQ_hd_fixed_size (peer_check,
                             GNUNET_MESSAGE_TYPE_RPS_PP_CHECK_LIVE,
                             struct GNUNET_MessageHeader,
                             NULL),
    GNUNET_MQ_hd_fixed_size (peer_push,
                             GNUNET_MESSAGE_TYPE_RPS_PP_PUSH,
                             struct GNUNET_MessageHeader,
                             NULL),
    GNUNET_MQ_hd_fixed_size (peer_pull_request,
                             GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REQUEST,
                             struct GNUNET_MessageHeader,
                             NULL),
    GNUNET_MQ_hd_var_size (peer_pull_reply,
                           GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REPLY,
                           struct GNUNET_RPS_P2P_PullReplyMessage,
                           NULL),
    GNUNET_MQ_handler_end ()
  };
  sub->hash = *hash;
  sub->cadet_port =
    GNUNET_CADET_open_port (cadet_handle,
                            &sub->hash,
                            &handle_inbound_channel, /* Connect handler */
                            sub, /* cls */
                            NULL, /* WindowSize handler */
                            &cleanup_destroyed_channel, /* Disconnect handler */
                            cadet_handlers);
  if (NULL == sub->cadet_port)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Cadet port `%s' is already in use.\n",
         GNUNET_APPLICATION_PORT_RPS);
    GNUNET_assert (0);
  }
 
  /* Set up general data structure to keep track about peers */
  sub->valid_peers = GNUNET_CONTAINER_multipeermap_create (4, GNUNET_NO);
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (cfg,
                                               "rps",
                                               "FILENAME_VALID_PEERS",
                                               &sub->filename_valid_peers))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               "rps",
                               "FILENAME_VALID_PEERS");
  }
  if (0 != strncmp ("DISABLE", sub->filename_valid_peers, 7))
  {
    char *tmp_filename_valid_peers;
    char str_hash[105];
 
    GNUNET_snprintf (str_hash,
                     sizeof(str_hash), "%s",
                     GNUNET_h2s_full (hash));
    tmp_filename_valid_peers = sub->filename_valid_peers;
    GNUNET_asprintf (&sub->filename_valid_peers,
                     "%s%s",
                     tmp_filename_valid_peers,
                     str_hash);
    GNUNET_free (tmp_filename_valid_peers);
  }
  sub->peer_map = GNUNET_CONTAINER_multipeermap_create (4, GNUNET_NO);
 
  /* Set up the sampler */
  sub->sampler_size_est_min = sampler_size;
  sub->sampler_size_est_need = sampler_size;;
  LOG (GNUNET_ERROR_TYPE_DEBUG, "MINSIZE is %u\n", sub->sampler_size_est_min);
  GNUNET_assert (0 != round_interval.rel_value_us);
  sub->round_interval = round_interval;
  sub->sampler = RPS_sampler_init (sampler_size,
                                   round_interval);
 
  /* Logging of internals */
#ifdef TO_FILE_FULL
  // FIXME: The service cannot know the index, which is required by this
  // function:
  // sub->file_name_view_log = store_prefix_file_name (&own_identity, "view");
#endif /* TO_FILE_FULL */
#ifdef TO_FILE
#ifdef TO_FILE_FULL
  // FIXME: The service cannot know the index, which is required by this
  // function:
  // sub->file_name_observed_log = store_prefix_file_name (&own_identity,
  //                                                       "observed");
#endif /* TO_FILE_FULL */
  sub->num_observed_peers = 0;
  sub->observed_unique_peers = GNUNET_CONTAINER_multipeermap_create (1,
                                                                     GNUNET_NO);
#endif /* TO_FILE */
 
  /* Set up data structures for gossip */
  sub->push_map = CustomPeerMap_create (4);
  sub->pull_map = CustomPeerMap_create (4);
  sub->view_size_est_min = sampler_size;;
  sub->view = View_create (sub->view_size_est_min);
  if (sub == msub)
  {
    GNUNET_STATISTICS_set (stats,
                           "view size aim",
                           sub->view_size_est_min,
                           GNUNET_NO);
  }
 
  /* Start executing rounds */
  sub->do_round_task = GNUNET_SCHEDULER_add_now (&do_round, sub);
 
  return sub;
}

References cadet_handle, Sub::cadet_port, cfg, cleanup_destroyed_channel(), CustomPeerMap_create(), do_round(), Sub::do_round_task, Sub::filename_valid_peers, GNUNET_APPLICATION_PORT_RPS, GNUNET_asprintf(), GNUNET_assert, GNUNET_CADET_open_port(), GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONTAINER_multipeermap_create(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_h2s_full(), GNUNET_log_config_missing(), GNUNET_MESSAGE_TYPE_RPS_PP_CHECK_LIVE, GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REPLY, GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REQUEST, GNUNET_MESSAGE_TYPE_RPS_PP_PUSH, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_snprintf(), GNUNET_STATISTICS_set(), handle_inbound_channel(), Sub::hash, LOG, msub, Sub::num_observed_peers, Sub::observed_unique_peers, Sub::peer_map, Sub::pull_map, Sub::push_map, GNUNET_TIME_Relative::rel_value_us, Sub::round_interval, RPS_sampler_init(), Sub::sampler, Sub::sampler_size_est_min, Sub::sampler_size_est_need, stats, Sub::valid_peers, Sub::view, View_create(), and Sub::view_size_est_min.

Referenced by handle_client_start_sub(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ destroy_sub()

static void destroy_sub ( struct Sub * sub )

static

Destroy Sub.

Parameters

sub	Sub to destroy

Definition at line 3060 of file gnunet-service-rps.c.

{
  GNUNET_assert (NULL != sub);
  GNUNET_assert (NULL != sub->do_round_task);
  GNUNET_SCHEDULER_cancel (sub->do_round_task);
  sub->do_round_task = NULL;
 
  /* Disconnect from cadet */
  GNUNET_CADET_close_port (sub->cadet_port);
  sub->cadet_port = NULL;
 
  /* Clean up data structures for peers */
  RPS_sampler_destroy (sub->sampler);
  sub->sampler = NULL;
  View_destroy (sub->view);
  sub->view = NULL;
  CustomPeerMap_destroy (sub->push_map);
  sub->push_map = NULL;
  CustomPeerMap_destroy (sub->pull_map);
  sub->pull_map = NULL;
  peers_terminate (sub);
 
  /* Free leftover data structures */
#ifdef TO_FILE_FULL
  GNUNET_free (sub->file_name_view_log);
  sub->file_name_view_log = NULL;
#endif /* TO_FILE_FULL */
#ifdef TO_FILE
#ifdef TO_FILE_FULL
  GNUNET_free (sub->file_name_observed_log);
  sub->file_name_observed_log = NULL;
#endif /* TO_FILE_FULL */
 
  // FIXME: Currently this calls malfunctionning code
  // /* Write push frequencies to disk */
  // write_histogram_to_file (sub->push_recv,
  //                          "push_recv");
 
  // /* Write push deltas to disk */
  // write_histogram_to_file (sub->push_delta,
  //                          "push_delta");
 
  // /* Write pull delays to disk */
  // write_histogram_to_file (sub->pull_delays,
  //                          "pull_delays");
 
  GNUNET_CONTAINER_multipeermap_destroy (sub->observed_unique_peers);
  sub->observed_unique_peers = NULL;
#endif /* TO_FILE */
 
  GNUNET_free (sub);
}

References Sub::cadet_port, CustomPeerMap_destroy(), Sub::do_round_task, GNUNET_assert, GNUNET_CADET_close_port(), GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_free, GNUNET_SCHEDULER_cancel(), Sub::observed_unique_peers, peers_terminate(), Sub::pull_map, Sub::push_map, RPS_sampler_destroy(), Sub::sampler, Sub::view, and View_destroy().

Referenced by destroy_cli_ctx(), handle_client_start_sub(), handle_client_stop_sub(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ core_init()

void core_init	(	void *	cls,
		const struct GNUNET_PeerIdentity *	my_identity
	)

Callback on initialisation of Core.

Parameters

cls	- unused
my_identity	- unused

Definition at line 3130 of file gnunet-service-rps.c.

{
  (void) cls;
  (void) my_identity;
 
  map_single_hop = GNUNET_CONTAINER_multipeermap_create (4, GNUNET_NO);
}

References GNUNET_MQ_MessageHandler::cls, GNUNET_CONTAINER_multipeermap_create(), GNUNET_NO, map_single_hop, and my_identity.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ core_connects()

void * core_connects	(	void *	cls,
		const struct GNUNET_PeerIdentity *	peer,
		struct GNUNET_MQ_Handle *	mq,
		enum GNUNET_CORE_PeerClass	class
	)

Callback for core.

Method called whenever a given peer connects.

Parameters

cls	closure - unused
peer	peer identity this notification is about
class	class of the connecting peer

Returns: closure given to core_disconnects as peer_cls

Definition at line 3150 of file gnunet-service-rps.c.

{
  (void) cls;
  (void) mq;
 
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multipeermap_put (map_single_hop,
                                                    peer,
                                                    NULL,
                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  return NULL;
}

References GNUNET_MQ_MessageHandler::cls, GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_put(), GNUNET_YES, map_single_hop, and mq.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ core_disconnects()

void core_disconnects	(	void *	cls,
		const struct GNUNET_PeerIdentity *	peer,
		void *	peer_cls
	)

Callback for core.

Method called whenever a peer disconnects.

Parameters

cls	closure - unused
peer	peer identity this notification is about
peer_cls	closure given in core_connects - unused

Definition at line 3176 of file gnunet-service-rps.c.

{
  (void) cls;
  (void) peer_cls;
 
  GNUNET_CONTAINER_multipeermap_remove_all (map_single_hop, peer);
}

References GNUNET_MQ_MessageHandler::cls, GNUNET_CONTAINER_multipeermap_remove_all(), and map_single_hop.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ destroy_cli_ctx()

static void destroy_cli_ctx ( struct ClientContext * cli_ctx )

static

Destroy the context for a (connected) client.

Parameters

cli_ctx Context to destroy

Definition at line 3198 of file gnunet-service-rps.c.

{
  GNUNET_assert (NULL != cli_ctx);
  GNUNET_CONTAINER_DLL_remove (cli_ctx_head,
                               cli_ctx_tail,
                               cli_ctx);
  if (NULL != cli_ctx->sub)
  {
    destroy_sub (cli_ctx->sub);
    cli_ctx->sub = NULL;
  }
  GNUNET_free (cli_ctx);
}

References cli_ctx_head, cli_ctx_tail, destroy_sub(), GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_free, and ClientContext::sub.

Referenced by client_disconnect_cb(), handle_client_view_cancel(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ adapt_sizes()

static void adapt_sizes	(	struct Sub *	sub,
		double	logestimate,
		double	std_dev
	)

static

Update sizes in sampler and view on estimate update from nse service.

Parameters

sub	Sub
logestimate	the log(Base 2) value of the current network size estimate
std_dev	standard deviation for the estimate

Definition at line 3221 of file gnunet-service-rps.c.

{
  double estimate;
 
  // double scale; // TODO this might go global/config
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received a ns estimate - logest: %f, std_dev: %f (old_size: %u)\n",
       logestimate, std_dev, RPS_sampler_get_size (sub->sampler));
  // scale = .01;
  estimate = GNUNET_NSE_log_estimate_to_n (logestimate);
  // GNUNET_NSE_log_estimate_to_n (logestimate);
  estimate = pow (estimate, 1.0 / 3);
  // TODO add if std_dev is a number
  // estimate += (std_dev * scale);
  if (sub->view_size_est_min < ceil (estimate))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG, "Changing estimate to %f\n", estimate);
    sub->sampler_size_est_need = estimate;
    sub->view_size_est_need = estimate;
  }
  else
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG, "Not using estimate %f\n", estimate);
    // sub->sampler_size_est_need = sub->view_size_est_min;
    sub->view_size_est_need = sub->view_size_est_min;
  }
  if (sub == msub)
  {
    GNUNET_STATISTICS_set (stats,
                           "view size aim",
                           sub->view_size_est_need,
                           GNUNET_NO);
  }
 
  /* If the NSE has changed adapt the lists accordingly */
  resize_wrapper (sub->sampler, sub->sampler_size_est_need);
  View_change_len (sub->view, sub->view_size_est_need);
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_NO, GNUNET_NSE_log_estimate_to_n, GNUNET_STATISTICS_set(), LOG, msub, resize_wrapper(), RPS_sampler_get_size(), Sub::sampler, Sub::sampler_size_est_need, stats, Sub::view, View_change_len(), Sub::view_size_est_min, and Sub::view_size_est_need.

Referenced by nse_callback().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ nse_callback()

static void nse_callback	(	void *	cls,
		struct GNUNET_TIME_Absolute	timestamp,
		double	logestimate,
		double	std_dev
	)

static

Function called by NSE.

Updates sizes of sampler list and view and adapt those lists accordingly.

implements GNUNET_NSE_Callback

Parameters

cls	Closure - unused
timestamp	time when the estimate was received from the server (or created by the server)
logestimate	the log(Base 2) value of the current network size estimate
std_dev	standard deviation for the estimate

Definition at line 3276 of file gnunet-service-rps.c.

{
  (void) cls;
  (void) timestamp;
  struct ClientContext *cli_ctx_iter;
 
  adapt_sizes (msub, logestimate, std_dev);
  for (cli_ctx_iter = cli_ctx_head;
       NULL != cli_ctx_iter;
       cli_ctx_iter = cli_ctx_iter->next)
  {
    if (NULL != cli_ctx_iter->sub)
    {
      adapt_sizes (cli_ctx_iter->sub, logestimate, std_dev);
    }
  }
}

References adapt_sizes(), cli_ctx_head, GNUNET_MQ_MessageHandler::cls, msub, ClientContext::next, ClientContext::sub, and timestamp().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_client_seed()

static int check_client_seed	(	void *	cls,
		const struct GNUNET_RPS_CS_SeedMessage *	msg
	)

static

This function is called, when the client seeds peers.

It verifies that msg is well-formed.

Parameters

cls	the closure (ClientContext)
msg	the message

Returns: GNUNET_OK if msg is well-formed GNUNET_SYSERR otherwise

Definition at line 3307 of file gnunet-service-rps.c.

{
  struct ClientContext *cli_ctx = cls;
  uint16_t msize = ntohs (msg->header.size);
  uint32_t num_peers = ntohl (msg->num_peers);
 
  msize -= sizeof(struct GNUNET_RPS_CS_SeedMessage);
  if ((msize / sizeof(struct GNUNET_PeerIdentity) != num_peers) ||
      (msize % sizeof(struct GNUNET_PeerIdentity) != 0))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "message says it sends %" PRIu32 " peers, have space for %lu peers\n",
         ntohl (msg->num_peers),
         (msize / sizeof(struct GNUNET_PeerIdentity)));
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (cli_ctx->client);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References ClientContext::client, GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_OK, GNUNET_SERVICE_client_drop(), GNUNET_SYSERR, LOG, msg, num_peers, and GNUNET_MessageHeader::size.

Here is the call graph for this function:

◆ handle_client_seed()

static void handle_client_seed	(	void *	cls,
		const struct GNUNET_RPS_CS_SeedMessage *	msg
	)

static

Handle seed from the client.

Parameters

cls	closure
msg	the actual message

Definition at line 3336 of file gnunet-service-rps.c.

{
  struct ClientContext *cli_ctx = cls;
  struct GNUNET_PeerIdentity *peers;
  uint32_t num_peers;
  uint32_t i;
 
  num_peers = ntohl (msg->num_peers);
  peers = (struct GNUNET_PeerIdentity *) &msg[1];
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Client seeded peers:\n");
  print_peer_list (peers, num_peers);
 
  for (i = 0; i < num_peers; i++)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Updating samplers with seed %" PRIu32 ": %s\n",
         i,
         GNUNET_i2s (&peers[i]));
 
    if (NULL != msub)
      got_peer (msub, &peers[i]);                 /* Condition needed? */
    if (NULL != cli_ctx->sub)
      got_peer (cli_ctx->sub, &peers[i]);
  }
  GNUNET_SERVICE_client_continue (cli_ctx->client);
}

References ClientContext::client, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_SERVICE_client_continue(), got_peer(), LOG, msg, msub, num_peers, peers, print_peer_list(), and ClientContext::sub.

Here is the call graph for this function:

◆ handle_client_view_request()

static void handle_client_view_request	(	void *	cls,
		const struct GNUNET_RPS_CS_DEBUG_ViewRequest *	msg
	)

static

Handle RPS request from the client.

Parameters

cls	Client context
msg	Message containing the number of updates the client wants to receive

Definition at line 3375 of file gnunet-service-rps.c.

{
  struct ClientContext *cli_ctx = cls;
  uint64_t num_updates;
 
  num_updates = ntohl (msg->num_updates);
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Client requested %" PRIu64 " updates of view.\n",
       num_updates);
 
  GNUNET_assert (NULL != cli_ctx);
  cli_ctx->view_updates_left = num_updates;
  send_view (cli_ctx, NULL, 0);
  GNUNET_SERVICE_client_continue (cli_ctx->client);
}

References ClientContext::client, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_SERVICE_client_continue(), LOG, msg, send_view(), and ClientContext::view_updates_left.

Here is the call graph for this function:

◆ handle_client_view_cancel()

static void handle_client_view_cancel	(	void *	cls,
		const struct GNUNET_MessageHeader *	msg
	)

static

Handle the cancellation of the view updates.

Parameters

cls	The client context
msg	Unused

Definition at line 3401 of file gnunet-service-rps.c.

{
  struct ClientContext *cli_ctx = cls;
 
  (void) msg;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Client does not want to receive updates of view any more.\n");
 
  GNUNET_assert (NULL != cli_ctx);
  cli_ctx->view_updates_left = 0;
  GNUNET_SERVICE_client_continue (cli_ctx->client);
  if (GNUNET_YES == cli_ctx->stream_update)
  {
    destroy_cli_ctx (cli_ctx);
  }
}

References ClientContext::client, destroy_cli_ctx(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_SERVICE_client_continue(), GNUNET_YES, LOG, msg, ClientContext::stream_update, and ClientContext::view_updates_left.

Here is the call graph for this function:

◆ handle_client_stream_request()

static void handle_client_stream_request	(	void *	cls,
		const struct GNUNET_RPS_CS_DEBUG_StreamRequest *	msg
	)

static

Handle RPS request for biased stream from the client.

Parameters

cls	Client context
msg	unused

Definition at line 3428 of file gnunet-service-rps.c.

{
  struct ClientContext *cli_ctx = cls;
 
  (void) msg;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Client requested peers from biased stream.\n");
  cli_ctx->stream_update = GNUNET_YES;
 
  GNUNET_assert (NULL != cli_ctx);
  GNUNET_SERVICE_client_continue (cli_ctx->client);
}

References ClientContext::client, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_SERVICE_client_continue(), GNUNET_YES, LOG, msg, and ClientContext::stream_update.

Here is the call graph for this function:

◆ handle_client_stream_cancel()

static void handle_client_stream_cancel	(	void *	cls,
		const struct GNUNET_MessageHeader *	msg
	)

static

Handles the cancellation of the stream of biased peer ids.

Parameters

cls	The client context
msg	unused

Definition at line 3452 of file gnunet-service-rps.c.

{
  struct ClientContext *cli_ctx = cls;
 
  (void) msg;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Client canceled receiving peers from biased stream.\n");
  cli_ctx->stream_update = GNUNET_NO;
 
  GNUNET_assert (NULL != cli_ctx);
  GNUNET_SERVICE_client_continue (cli_ctx->client);
}

References ClientContext::client, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_NO, GNUNET_SERVICE_client_continue(), LOG, msg, and ClientContext::stream_update.

Here is the call graph for this function:

◆ handle_client_start_sub()

static void handle_client_start_sub	(	void *	cls,
		const struct GNUNET_RPS_CS_SubStartMessage *	msg
	)

static

Create and start a Sub.

Parameters

cls	Closure - unused
msg	Message containing the necessary information

Definition at line 3475 of file gnunet-service-rps.c.

{
  struct ClientContext *cli_ctx = cls;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Client requested start of a new sub.\n");
  if ((NULL != cli_ctx->sub) &&
      (0 != memcmp (&cli_ctx->sub->hash,
                    &msg->hash,
                    sizeof(struct GNUNET_HashCode))) )
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Already have a Sub with different share for this client. Remove old one, add new.\n");
    destroy_sub (cli_ctx->sub);
    cli_ctx->sub = NULL;
  }
  cli_ctx->sub = new_sub (&msg->hash,
                          msub->sampler_size_est_min, // TODO make api input?
                          GNUNET_TIME_relative_ntoh (msg->round_interval));
  GNUNET_SERVICE_client_continue (cli_ctx->client);
}

References ClientContext::client, destroy_sub(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_SERVICE_client_continue(), GNUNET_TIME_relative_ntoh(), Sub::hash, LOG, msg, msub, new_sub(), Sub::sampler_size_est_min, and ClientContext::sub.

Here is the call graph for this function:

◆ handle_client_stop_sub()

static void handle_client_stop_sub	(	void *	cls,
		const struct GNUNET_RPS_CS_SubStopMessage *	msg
	)

static

Destroy the Sub.

Parameters

cls	Closure - unused
msg	Message containing the hash that identifies the Sub

Definition at line 3505 of file gnunet-service-rps.c.

{
  struct ClientContext *cli_ctx = cls;
 
  GNUNET_assert (NULL != cli_ctx->sub);
  if (0 != memcmp (&cli_ctx->sub->hash, &msg->hash, sizeof(struct
                                                           GNUNET_HashCode)))
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Share of current sub and request differ!\n");
  }
  destroy_sub (cli_ctx->sub);
  cli_ctx->sub = NULL;
  GNUNET_SERVICE_client_continue (cli_ctx->client);
}

References ClientContext::client, destroy_sub(), GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_SERVICE_client_continue(), Sub::hash, LOG, msg, and ClientContext::sub.

Here is the call graph for this function:

◆ compute_rand_delay()

static struct GNUNET_TIME_Relative compute_rand_delay	(	struct GNUNET_TIME_Relative	mean,
		unsigned int	spread
	)

static

Compute a random delay.

A uniformly distributed value between mean + spread and mean - spread.

For example for mean 4 min and spread 2 the minimum is (4 min - (1/2 * 4 min)) It would return a random value between 2 and 6 min.

Parameters

mean	the mean time until the next round
spread	the inverse amount of deviation from the mean

Compute random value between (0 and 1) * round_interval via multiplying round_interval with a 'fraction' (0 to value)/value

Definition at line 3876 of file gnunet-service-rps.c.

{
  struct GNUNET_TIME_Relative half_interval;
  struct GNUNET_TIME_Relative ret;
  unsigned int rand_delay;
  unsigned int max_rand_delay;
 
  if (0 == spread)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Not accepting spread of 0\n");
    GNUNET_break (0);
    GNUNET_assert (0);
  }
  GNUNET_assert (0 != mean.rel_value_us);
 
  /* Compute random time value between spread * mean and spread * mean */
  half_interval = GNUNET_TIME_relative_divide (mean, spread);
 
  max_rand_delay = GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us
                   / mean.rel_value_us * (2 / spread);
  rand_delay = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
                                         max_rand_delay);
  ret = GNUNET_TIME_relative_saturating_multiply (mean, rand_delay);
  ret = GNUNET_TIME_relative_divide (ret, max_rand_delay);
  ret = GNUNET_TIME_relative_add (ret, half_interval);
 
  if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us == ret.rel_value_us)
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Returning FOREVER_REL\n");
 
  return ret;
}

References GNUNET_assert, GNUNET_break, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_WARNING, GNUNET_TIME_relative_add(), GNUNET_TIME_relative_divide(), GNUNET_TIME_relative_saturating_multiply(), GNUNET_TIME_UNIT_FOREVER_REL, LOG, and ret.

Referenced by do_round().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_pull_request()

static void send_pull_request ( struct PeerContext * peer_ctx )

static

Send single pull request.

Parameters

peer_ctx Context to the peer to send request to

Definition at line 3922 of file gnunet-service-rps.c.

{
  struct GNUNET_MQ_Envelope *ev;
 
  GNUNET_assert (GNUNET_NO == check_peer_flag (peer_ctx->sub->peer_map,
                                               &peer_ctx->peer_id,
                                               Peers_PULL_REPLY_PENDING));
  SET_PEER_FLAG (peer_ctx,
                 Peers_PULL_REPLY_PENDING);
  peer_ctx->round_pull_req = peer_ctx->sub->num_rounds;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Going to send PULL REQUEST to peer %s.\n",
       GNUNET_i2s (&peer_ctx->peer_id));
 
  ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REQUEST);
  send_message (peer_ctx,
                ev,
                "PULL REQUEST");
  if (peer_ctx->sub)
  {
    GNUNET_STATISTICS_update (stats,
                              "# pull request send issued",
                              1,
                              GNUNET_NO);
    if ((NULL != map_single_hop) &&
        (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (map_single_hop,
                                                              &peer_ctx->peer_id
                                                              )))
    {
      GNUNET_STATISTICS_update (stats,
                                "# pull request send issued (multi-hop peer)",
                                1,
                                GNUNET_NO);
    }
  }
}

References check_peer_flag(), GNUNET_assert, GNUNET_CONTAINER_multipeermap_contains(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REQUEST, GNUNET_MQ_msg_header, GNUNET_NO, GNUNET_STATISTICS_update(), LOG, map_single_hop, Sub::num_rounds, PeerContext::peer_id, Sub::peer_map, Peers_PULL_REPLY_PENDING, PeerContext::round_pull_req, send_message(), SET_PEER_FLAG, stats, and PeerContext::sub.

Referenced by do_round().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_push()

static void send_push ( struct PeerContext * peer_ctx )

static

Send single push.

Parameters

peer_ctx Context of peer to send push to

Definition at line 3967 of file gnunet-service-rps.c.

{
  struct GNUNET_MQ_Envelope *ev;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Going to send PUSH to peer %s.\n",
       GNUNET_i2s (&peer_ctx->peer_id));
 
  ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_RPS_PP_PUSH);
  send_message (peer_ctx, ev, "PUSH");
  if (peer_ctx->sub)
  {
    GNUNET_STATISTICS_update (stats,
                              "# push send issued",
                              1,
                              GNUNET_NO);
    if ((NULL != map_single_hop) &&
        (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (map_single_hop,
                                                              &peer_ctx->peer_id
                                                              )))
    {
      GNUNET_STATISTICS_update (stats,
                                "# push send issued (multi-hop peer)",
                                1,
                                GNUNET_NO);
    }
  }
}

References GNUNET_CONTAINER_multipeermap_contains(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_MESSAGE_TYPE_RPS_PP_PUSH, GNUNET_MQ_msg_header, GNUNET_NO, GNUNET_STATISTICS_update(), LOG, map_single_hop, PeerContext::peer_id, send_message(), stats, and PeerContext::sub.

Referenced by do_round().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_peer_cb()

void init_peer_cb	(	void *	cls,
		const struct GNUNET_PeerIdentity *	peer,
		int	tunnel,
		unsigned int	n_paths,
		unsigned int	best_path
	)

This is called from GNUNET_CADET_get_peers().

It is called on every peer(ID) that cadet somehow has contact with. We use those to initialise the sampler.

implements GNUNET_CADET_PeersCB

Parameters

cls	Closure - Sub
peer	Peer, or NULL on "EOF".
tunnel	Do we have a tunnel towards this peer?
n_paths	Number of known paths towards this peer.
best_path	How long is the best path? (0 = unknown, 1 = ourselves, 2 = neighbor)

Definition at line 4647 of file gnunet-service-rps.c.

{
  struct Sub *sub = cls;
 
  (void) tunnel;
  (void) n_paths;
  (void) best_path;
 
  if (NULL != peer)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Got peer_id %s from cadet\n",
         GNUNET_i2s (peer));
    got_peer (sub, peer);
  }
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), got_peer(), and LOG.

Here is the call graph for this function:

◆ valid_peers_iterator()

static int valid_peers_iterator	(	void *	cls,
		const struct GNUNET_PeerIdentity *	peer
	)

static

Iterator function over stored, valid peers.

We initialise the sampler with those.

Parameters

cls	Closure - Sub
peer	the peer id

Returns: GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

Definition at line 4682 of file gnunet-service-rps.c.

{
  struct Sub *sub = cls;
 
  if (NULL != peer)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Got stored, valid peer %s\n",
         GNUNET_i2s (peer));
    got_peer (sub, peer);
  }
  return GNUNET_YES;
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_YES, got_peer(), and LOG.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_peerinfo_peers()

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

Iterator over peers from peerinfo.

Parameters

cls	Closure - Sub
peer	id of the peer, NULL for last call
hello	hello message for the peer (can be NULL)
err_msg	error message

Definition at line 4707 of file gnunet-service-rps.c.

{
  struct Sub *sub = cls;
  (void) emsg;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Got peer_id %s from peerinfo\n",
       GNUNET_i2s (&record->peer));
  got_peer (sub, &record->peer);
  GNUNET_PEERSTORE_monitor_next (peerstore_notify, 1);
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_PEERSTORE_monitor_next(), got_peer(), LOG, peerstore_notify, and record().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ shutdown_task()

static void shutdown_task ( void * cls )

static

Task run during shutdown.

Parameters

cls	Closure - unused

Definition at line 4728 of file gnunet-service-rps.c.

{
  struct ClientContext *client_ctx;
 
  (void) cls;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "RPS service is going down\n");
 
  /* Clean all clients */
  for (client_ctx = cli_ctx_head;
       NULL != cli_ctx_head;
       client_ctx = cli_ctx_head)
  {
    destroy_cli_ctx (client_ctx);
  }
  if (NULL != msub)
  {
    destroy_sub (msub);
    msub = NULL;
  }
 
  /* Disconnect from other services */
  GNUNET_PEERSTORE_monitor_stop (peerstore_notify);
  peerstore_notify = NULL;
  GNUNET_PEERSTORE_disconnect (peerstore);
  peerstore = NULL;
  GNUNET_NSE_disconnect (nse);
  nse = NULL;
  if (NULL != core_handle)
  {
    /* core_init was called - core was initialised */
    /* disconnect first, so no callback tries to access missing peermap */
    GNUNET_CORE_disconnect (core_handle);
    core_handle = NULL;
  }
  if (NULL != map_single_hop)
  {
    GNUNET_CONTAINER_multipeermap_destroy (map_single_hop);
    map_single_hop = NULL;
  }
 
  if (NULL != stats)
  {
    GNUNET_STATISTICS_destroy (stats,
                               GNUNET_NO);
    stats = NULL;
  }
  GNUNET_CADET_disconnect (cadet_handle);
  cadet_handle = NULL;
#if ENABLE_MALICIOUS
  {
    struct AttackedPeer *tmp_att_peer;
 
    GNUNET_array_grow (mal_peers,
                       num_mal_peers,
                       0);
    if (NULL != mal_peer_set)
      GNUNET_CONTAINER_multipeermap_destroy (mal_peer_set);
    if (NULL != att_peer_set)
      GNUNET_CONTAINER_multipeermap_destroy (att_peer_set);
    while (NULL != att_peers_head)
    {
      tmp_att_peer = att_peers_head;
      GNUNET_CONTAINER_DLL_remove (att_peers_head,
                                   att_peers_tail,
                                   tmp_att_peer);
      GNUNET_free (tmp_att_peer);
    }
  }
#endif /* ENABLE_MALICIOUS */
  close_all_files ();
}

References cadet_handle, cli_ctx_head, close_all_files(), core_handle, destroy_cli_ctx(), destroy_sub(), GNUNET_array_grow, GNUNET_CADET_disconnect(), GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CORE_disconnect(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_NO, GNUNET_NSE_disconnect(), GNUNET_PEERSTORE_disconnect(), GNUNET_PEERSTORE_monitor_stop(), GNUNET_STATISTICS_destroy(), LOG, map_single_hop, msub, nse, peerstore, peerstore_notify, and stats.

Here is the call graph for this function:

◆ client_connect_cb()

static void * client_connect_cb	(	void *	cls,
		struct GNUNET_SERVICE_Client *	client,
		struct GNUNET_MQ_Handle *	mq
	)

static

Handle client connecting to the service.

Parameters

cls	unused
client	the new client
mq	the message queue of client

Returns: client

Definition at line 4811 of file gnunet-service-rps.c.

{
  struct ClientContext *cli_ctx;
 
  (void) cls;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Client connected\n");
  if (NULL == client)
    return client; /* Server was destroyed before a client connected. Shutting down */
  cli_ctx = GNUNET_new (struct ClientContext);
  cli_ctx->mq = mq;
  cli_ctx->view_updates_left = -1;
  cli_ctx->stream_update = GNUNET_NO;
  cli_ctx->client = client;
  GNUNET_CONTAINER_DLL_insert (cli_ctx_head,
                               cli_ctx_tail,
                               cli_ctx);
  return cli_ctx;
}

References cli_ctx_head, cli_ctx_tail, ClientContext::client, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_new, GNUNET_NO, LOG, ClientContext::mq, mq, ClientContext::stream_update, and ClientContext::view_updates_left.

◆ client_disconnect_cb()

static void client_disconnect_cb	(	void *	cls,
		struct GNUNET_SERVICE_Client *	client,
		void *	internal_cls
	)

static

Callback called when a client disconnected from the service.

Parameters

cls	closure for the service
client	the client that disconnected
internal_cls	should be equal to c

Definition at line 4843 of file gnunet-service-rps.c.

{
  struct ClientContext *cli_ctx = internal_cls;
 
  (void) cls;
  GNUNET_assert (client == cli_ctx->client);
  if (NULL == client)
  {  /* shutdown task - destroy all clients */
    while (NULL != cli_ctx_head)
      destroy_cli_ctx (cli_ctx_head);
  }
  else
  {   /* destroy this client */
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Client disconnected. Destroy its context.\n");
    destroy_cli_ctx (cli_ctx);
  }
}

References cli_ctx_head, ClientContext::client, destroy_cli_ctx(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, and LOG.

Here is the call graph for this function:

◆ error_cb()

static void error_cb ( void * cls )

static

Definition at line 4866 of file gnunet-service-rps.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              "Error in PEERSTORE monitoring\n");
}

References GNUNET_ERROR_TYPE_WARNING, and GNUNET_log.

Referenced by run().

Here is the caller graph for this function:

◆ sync_cb()

static void sync_cb ( void * cls )

static

Definition at line 4874 of file gnunet-service-rps.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              "Done with initial PEERSTORE iteration during monitoring\n");
}

References GNUNET_ERROR_TYPE_WARNING, and GNUNET_log.

Referenced by run().

Here is the caller graph for this function:

◆ run()

static void run	(	void *	cls,
		const struct GNUNET_CONFIGURATION_Handle *	c,
		struct GNUNET_SERVICE_Handle *	service
	)

static

Handle random peer sampling clients.

Parameters

cls	closure
c	configuration to use
service	the initialized service

Definition at line 4889 of file gnunet-service-rps.c.

{
  struct GNUNET_TIME_Relative round_interval;
  long long unsigned int sampler_size;
  char hash_port_string[] = GNUNET_APPLICATION_PORT_RPS;
  struct GNUNET_HashCode hash;
  const struct GNUNET_CORE_ServiceInfo service_info = {
    .service = GNUNET_CORE_SERVICE_RPS,
    .version = { 1, 0 },
    .version_max = { 1, 0 },
    .version_min = { 1, 0 },
  };
 
  (void) cls;
  (void) service;
 
  GNUNET_log_setup ("rps",
                    GNUNET_error_type_to_string (GNUNET_ERROR_TYPE_DEBUG),
                    NULL);
  cfg = c;
  /* Get own ID */
  GNUNET_CRYPTO_get_peer_identity (cfg,
                                   &own_identity); // TODO check return value
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "STARTING SERVICE (rps) for peer [%s]\n",
              GNUNET_i2s (&own_identity));
#if ENABLE_MALICIOUS
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              "Malicious execution compiled in.\n");
#endif /* ENABLE_MALICIOUS */
 
  /* Get time interval from the configuration */
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_time (cfg,
                                           "RPS",
                                           "ROUNDINTERVAL",
                                           &round_interval))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               "RPS", "ROUNDINTERVAL");
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
 
  /* Get initial size of sampler/view from the configuration */
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_number (cfg,
                                             "RPS",
                                             "MINSIZE",
                                             &sampler_size))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               "RPS", "MINSIZE");
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
 
  cadet_handle = GNUNET_CADET_connect (cfg);
  GNUNET_assert (NULL != cadet_handle);
  core_handle = GNUNET_CORE_connect (cfg,
                                     NULL, /* cls */
                                     core_init, /* init */
                                     core_connects, /* connects */
                                     core_disconnects, /* disconnects */
                                     NULL,
                                     &service_info); /* handlers */
  GNUNET_assert (NULL != core_handle);
 
 
  alpha = 0.45;
  beta = 0.45;
 
 
  /* Set up main Sub */
  GNUNET_CRYPTO_hash (hash_port_string,
                      strlen (hash_port_string),
                      &hash);
  msub = new_sub (&hash,
                  sampler_size, /* Will be overwritten by config */
                  round_interval);
 
 
  peerstore = GNUNET_PEERSTORE_connect (cfg);
 
  /* connect to NSE */
  nse = GNUNET_NSE_connect (cfg, nse_callback, NULL);
 
  // LOG (GNUNET_ERROR_TYPE_DEBUG, "Requesting peers from CADET\n");
  // GNUNET_CADET_get_peers (cadet_handle, &init_peer_cb, msub);
  // TODO send push/pull to each of those peers?
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Requesting stored valid peers\n");
  restore_valid_peers (msub);
  get_valid_peers (msub->valid_peers, valid_peers_iterator, msub);
 
  peerstore_notify =
    GNUNET_PEERSTORE_monitor_start (c,
                                    GNUNET_YES,
                                    "peerstore",
                                    NULL,
                                    GNUNET_PEERSTORE_HELLO_KEY,
                                    &error_cb,
                                    NULL,
                                    &sync_cb,
                                    NULL,
                                    &process_peerinfo_peers,
                                    msub);
 
  LOG (GNUNET_ERROR_TYPE_INFO, "Ready to receive requests from clients\n");
 
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
  stats = GNUNET_STATISTICS_create ("rps", cfg);
}

References alpha, beta, cadet_handle, cfg, core_connects(), core_disconnects(), core_handle, core_init(), error_cb(), get_valid_peers(), GNUNET_APPLICATION_PORT_RPS, GNUNET_assert, GNUNET_CADET_connect(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_time(), GNUNET_CORE_connect(), GNUNET_CORE_SERVICE_RPS, GNUNET_CRYPTO_get_peer_identity(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_error_type_to_string(), GNUNET_ERROR_TYPE_WARNING, GNUNET_i2s(), GNUNET_log, GNUNET_log_config_missing(), GNUNET_log_setup(), GNUNET_NSE_connect(), GNUNET_OK, GNUNET_PEERSTORE_connect(), GNUNET_PEERSTORE_HELLO_KEY, GNUNET_PEERSTORE_monitor_start(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_STATISTICS_create(), GNUNET_YES, LOG, msub, new_sub(), nse, nse_callback(), own_identity, peerstore, peerstore_notify, process_peerinfo_peers(), restore_valid_peers(), GNUNET_CORE_ServiceInfo::service, service, shutdown_task, stats, sync_cb(), Sub::valid_peers, and valid_peers_iterator().

Here is the call graph for this function:

◆ GNUNET_SERVICE_MAIN()

GNUNET_SERVICE_MAIN	(	GNUNET_OS_project_data_gnunet()	,
		"rps"	,
		GNUNET_SERVICE_OPTION_NONE	,
		&	run,
		&	client_connect_cb,
		&	client_disconnect_cb,
		NULL	,
		GNUNET_MQ_hd_var_size(client_seed, GNUNET_MESSAGE_TYPE_RPS_CS_SEED, struct GNUNET_RPS_CS_SeedMessage, NULL)	,
		GNUNET_MQ_hd_fixed_size(client_view_request, GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_REQUEST, struct GNUNET_RPS_CS_DEBUG_ViewRequest, NULL)	,
		GNUNET_MQ_hd_fixed_size(client_view_cancel, GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_CANCEL, struct GNUNET_MessageHeader, NULL)	,
		GNUNET_MQ_hd_fixed_size(client_stream_request, GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_STREAM_REQUEST, struct GNUNET_RPS_CS_DEBUG_StreamRequest, NULL)	,
		GNUNET_MQ_hd_fixed_size(client_stream_cancel, GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_STREAM_CANCEL, struct GNUNET_MessageHeader, NULL)	,
		GNUNET_MQ_hd_fixed_size(client_start_sub, GNUNET_MESSAGE_TYPE_RPS_CS_SUB_START, struct GNUNET_RPS_CS_SubStartMessage, NULL)	,
		GNUNET_MQ_hd_fixed_size(client_stop_sub, GNUNET_MESSAGE_TYPE_RPS_CS_SUB_STOP, struct GNUNET_RPS_CS_SubStopMessage, NULL)	,
		GNUNET_MQ_handler_end()
	)

Define "main" method using service macro.

Variable Documentation

◆ cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

static

Our configuration.

Definition at line 457 of file gnunet-service-rps.c.

Referenced by new_sub(), and run().

◆ stats

struct GNUNET_STATISTICS_Handle* stats

Handle to the statistics service.

Definition at line 462 of file gnunet-service-rps.c.

Referenced by adapt_sizes(), add_valid_peer(), check_peer_online(), check_peer_pull_reply(), create_peer_ctx(), destroy_peer(), do_round(), got_peer(), handle_peer_check(), handle_peer_pull_reply(), handle_peer_pull_request(), handle_peer_push(), insert_in_sampler(), insert_in_view(), mq_notify_sent_cb(), new_sub(), run(), send_pull_reply(), send_pull_request(), send_push(), and shutdown_task().

◆ cadet_handle

struct GNUNET_CADET_Handle* cadet_handle

Handler to CADET.

Cadet channel for creating outbound channels.

Definition at line 467 of file gnunet-service-rps.c.

Referenced by get_channel(), GSF_cadet_start_server(), GSF_cadet_stop_server(), new_sub(), run(), and shutdown_task().

◆ core_handle

struct GNUNET_CORE_Handle* core_handle

Handle to CORE.

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

Referenced by run(), and shutdown_task().

◆ map_single_hop

struct GNUNET_CONTAINER_MultiPeerMap* map_single_hop

PeerMap to keep track of connected peers.

Definition at line 477 of file gnunet-service-rps.c.

Referenced by core_connects(), core_disconnects(), core_init(), handle_peer_pull_reply(), handle_peer_pull_request(), handle_peer_push(), mq_notify_sent_cb(), send_pull_request(), send_push(), and shutdown_task().

◆ own_identity

struct GNUNET_PeerIdentity own_identity

static

Our own identity.

Definition at line 482 of file gnunet-service-rps.c.

Referenced by run().

◆ alpha

float alpha

static

Percentage of total peer number in the view to send random PUSHes to.

Definition at line 488 of file gnunet-service-rps.c.

Referenced by checkvec(), do_round(), GNUNET_CRYPTO_cs_blinding_secrets_derive(), output_vectors(), and run().

◆ beta

float beta

static

Percentage of total peer number in the view to send random PULLs to.

Definition at line 494 of file gnunet-service-rps.c.

Referenced by checkvec(), do_round(), GNUNET_CRYPTO_cs_blinding_secrets_derive(), insert_decrypt_element(), output_vectors(), and run().

◆ nse

struct GNUNET_NSE_Handle* nse

static

Handler to NSE.

Definition at line 499 of file gnunet-service-rps.c.

Referenced by run(), and shutdown_task().

◆ peerstore

struct GNUNET_PEERSTORE_Handle* peerstore

static

Handle to the PEERSTORE service.

Definition at line 504 of file gnunet-service-rps.c.

Referenced by run(), and shutdown_task().

◆ peerstore_notify

struct GNUNET_PEERSTORE_Monitor* peerstore_notify

static

Our peerstore notification context.

We use notification to instantly learn about new peers as they are discovered.

Definition at line 510 of file gnunet-service-rps.c.

Referenced by process_peerinfo_peers(), run(), and shutdown_task().

◆ msub

struct Sub* msub

static

Main Sub.

This is run in any case by all peers and connects to all peers without specifying a shared value.

Definition at line 585 of file gnunet-service-rps.c.

Referenced by adapt_sizes(), add_valid_peer(), check_peer_online(), check_peer_pull_reply(), clients_notify_stream_peer(), create_peer_ctx(), destroy_peer(), do_round(), got_peer(), handle_client_seed(), handle_client_start_sub(), handle_peer_check(), handle_peer_pull_reply(), handle_peer_pull_request(), handle_peer_push(), insert_in_sampler(), insert_in_view(), mq_notify_sent_cb(), new_sub(), nse_callback(), run(), send_pull_reply(), send_view(), and shutdown_task().

◆ num_valid_peers_max

const uint32_t num_valid_peers_max = UINT32_MAX

static

Maximum number of valid peers to keep.

TODO read from config

Definition at line 591 of file gnunet-service-rps.c.

Referenced by add_valid_peer().

◆ cli_ctx_head

struct ClientContext* cli_ctx_head

DLL with all clients currently connected to us.

Definition at line 2131 of file gnunet-service-rps.c.

Referenced by client_connect_cb(), client_disconnect_cb(), clients_notify_stream_peer(), clients_notify_view_update(), destroy_cli_ctx(), nse_callback(), and shutdown_task().

◆ cli_ctx_tail

struct ClientContext* cli_ctx_tail

Definition at line 2132 of file gnunet-service-rps.c.

Referenced by client_connect_cb(), and destroy_cli_ctx().

Data Structures

Macros

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ LOG

◆ SET_PEER_FLAG

◆ check_peer_flag_set

◆ UNSET_PEER_FLAG

◆ check_channel_flag_set

◆ unset_channel_flag

◆ HISTOGRAM_FILE_SLOTS

◆ SIZE_DUMP_FILE

Function Documentation

◆ do_round()

◆ get_peer_ctx()

◆ check_peer_known()

◆ create_peer_ctx()

◆ create_or_get_peer_ctx()

◆ check_connected()

◆ get_rand_peer_iterator()

◆ get_random_peer_from_peermap()

◆ add_valid_peer()

◆ remove_pending_message()

◆ set_peer_online()

◆ cleanup_destroyed_channel()

◆ handle_peer_check()

◆ handle_peer_push()

◆ handle_peer_pull_request()

◆ check_peer_pull_reply()

◆ handle_peer_pull_reply()

◆ add_channel_ctx()

◆ remove_channel_ctx()

◆ get_channel()

◆ get_mq()

◆ insert_pending_message()

◆ mq_online_check_successful()

◆ check_peer_online()

◆ check_operation_scheduled()

◆ destroy_channel()

◆ destroy_channel_cb()

◆ schedule_channel_destruction()

◆ destroy_peer()

◆ peermap_clear_iterator()

◆ mq_notify_sent_cb()

◆ store_peer_presistently_iterator()

◆ store_valid_peers()

◆ s2i_full()

◆ restore_valid_peers()

◆ peers_terminate()

◆ valid_peer_iterator()

◆ get_valid_peers()

◆ insert_peer()

◆ check_peer_flag()

◆ issue_peer_online_check()

◆ check_removable()

◆ check_peer_valid()

◆ indicate_sending_intention()

◆ check_peer_send_intention()

◆ handle_inbound_channel()

◆ check_sending_channel_exists()

◆ destroy_sending_channel()

◆ send_message()

◆ schedule_operation()

◆ print_peer_list()

◆ rem_from_list()

◆ insert_in_view_op()

◆ insert_in_view()

◆ send_view()

◆ send_stream_peers()

◆ clients_notify_view_update()

◆ clients_notify_stream_peer()

◆ hist_update()

◆ resize_wrapper()

◆ send_pull_reply()

◆ insert_in_pull_map()

◆ insert_in_sampler()

◆ got_peer()

◆ check_sending_channel_needed()