GNUnet  0.11.x
Data Structures | Macros | Functions | Variables
gnunet-service-rps.c File Reference

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_peerinfo_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 <math.h>
#include <inttypes.h>
#include <string.h>
Include dependency graph for gnunet-service-rps.c:

Go to the source code of this file.

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. More...
 
#define check_peer_flag_set(peer_ctx, mask)   ((peer_ctx->peer_flags) & (mask) ? GNUNET_YES : GNUNET_NO)
 Get peer flag of given peer context. More...
 
#define UNSET_PEER_FLAG(peer_ctx, mask)   ((peer_ctx->peer_flags) &= ~(mask))
 Unset flag of given peer context. More...
 
#define check_channel_flag_set(channel_flags, mask)   ((*channel_flags) & (mask) ? GNUNET_YES : GNUNET_NO)
 Get channel flag of given channel context. More...
 
#define unset_channel_flag(channel_flags, mask)   ((*channel_flags) &= ~(mask))
 Unset flag of given channel context. More...
 
#define HISTOGRAM_FILE_SLOTS   32
 This number determines the number of slots for files that represent histograms. More...
 
#define SIZE_DUMP_FILE   (HISTOGRAM_FILE_SLOTS * 5) + 1
 The size (in bytes) a file needs to store the histogram. More...
 

Functions

static void do_round (void *cls)
 Send out PUSHes and PULLs, possibly update #view, samplers. More...
 
static struct PeerContextget_peer_ctx (const struct GNUNET_CONTAINER_MultiPeerMap *peer_map, const struct GNUNET_PeerIdentity *peer)
 Get the PeerContext associated with a peer. More...
 
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. More...
 
static struct PeerContextcreate_peer_ctx (struct Sub *sub, const struct GNUNET_PeerIdentity *peer)
 Create a new PeerContext and insert it into the peer map. More...
 
static struct PeerContextcreate_or_get_peer_ctx (struct Sub *sub, const struct GNUNET_PeerIdentity *peer)
 Create or get a PeerContext. More...
 
static int check_connected (struct PeerContext *peer_ctx)
 Check whether we have a connection to this peer. More...
 
static int get_rand_peer_iterator (void *cls, const struct GNUNET_PeerIdentity *peer, void *value)
 Iterator function for get_random_peer_from_peermap. More...
 
static const struct GNUNET_PeerIdentityget_random_peer_from_peermap (struct GNUNET_CONTAINER_MultiPeerMap *valid_peers)
 Get a random peer from peer_map. More...
 
static int add_valid_peer (const struct GNUNET_PeerIdentity *peer, struct GNUNET_CONTAINER_MultiPeerMap *valid_peers)
 Add a given peer to valid peers. More...
 
static void remove_pending_message (struct PendingMessage *pending_msg, int cancel)
 Remove a pending message from the respective DLL. More...
 
static void set_peer_online (struct PeerContext *peer_ctx)
 Set the peer flag to living and call the pending operations on this peer. More...
 
static void cleanup_destroyed_channel (void *cls, const struct GNUNET_CADET_Channel *channel)
 This is called when a channel is destroyed. More...
 
static void handle_peer_check (void *cls, const struct GNUNET_MessageHeader *msg)
 Handle a CHECK_LIVE message from another peer. More...
 
static void handle_peer_push (void *cls, const struct GNUNET_MessageHeader *msg)
 Handle a PUSH message from another peer. More...
 
static void handle_peer_pull_request (void *cls, const struct GNUNET_MessageHeader *msg)
 Handle PULL REQUEST request message from another peer. More...
 
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. More...
 
static void handle_peer_pull_reply (void *cls, const struct GNUNET_RPS_P2P_PullReplyMessage *msg)
 Handle PULL REPLY message from another peer. More...
 
static struct ChannelCtxadd_channel_ctx (struct PeerContext *peer_ctx)
 Allocate memory for a new channel context and insert it into DLL. More...
 
static void remove_channel_ctx (struct ChannelCtx *channel_ctx)
 Free memory and NULL pointers. More...
 
struct GNUNET_CADET_Channelget_channel (struct PeerContext *peer_ctx)
 Get the channel of a peer. More...
 
static struct GNUNET_MQ_Handleget_mq (struct PeerContext *peer_ctx)
 Get the message queue (GNUNET_MQ_Handle) of a specific peer. More...
 
static struct PendingMessageinsert_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. More...
 
static void mq_online_check_successful (void *cls)
 This is called in response to the first message we sent as a online check. More...
 
static void check_peer_online (struct PeerContext *peer_ctx)
 Issue a check whether peer is online. More...
 
static int check_operation_scheduled (const struct PeerContext *peer_ctx, const PeerOp peer_op)
 Check whether function of type PeerOp was already scheduled. More...
 
static void destroy_channel (struct ChannelCtx *channel_ctx)
 Callback for scheduler to destroy a channel. More...
 
static void destroy_channel_cb (void *cls)
 Destroy a cadet channel. More...
 
static void schedule_channel_destruction (struct ChannelCtx *channel_ctx)
 Schedule the destruction of a channel for immediately afterwards. More...
 
static int destroy_peer (struct PeerContext *peer_ctx)
 Remove peer. More...
 
static int peermap_clear_iterator (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
 Iterator over hash map entries. More...
 
static void mq_notify_sent_cb (void *cls)
 This is called once a message is sent. More...
 
static int store_peer_presistently_iterator (void *cls, const struct GNUNET_PeerIdentity *peer, void *value)
 Iterator function for store_valid_peers. More...
 
static void store_valid_peers (const struct Sub *sub)
 Store the peers currently in #valid_peers to disk. More...
 
static const struct GNUNET_PeerIdentitys2i_full (const char *string_repr)
 Convert string representation of peer id to peer id. More...
 
static void restore_valid_peers (const struct Sub *sub)
 Restore the peers on disk to #valid_peers. More...
 
static void peers_terminate (struct Sub *sub)
 Delete storage of peers that was created with #initialise_peers () More...
 
static int valid_peer_iterator (void *cls, const struct GNUNET_PeerIdentity *peer, void *value)
 Iterator over #valid_peers hash map entries. More...
 
static int get_valid_peers (struct GNUNET_CONTAINER_MultiPeerMap *valid_peers, PeersIterator iterator, void *it_cls)
 Get all currently known, valid peer ids. More...
 
static int insert_peer (struct Sub *sub, const struct GNUNET_PeerIdentity *peer)
 Add peer to known peers. More...
 
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. More...
 
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. More...
 
static int check_removable (const struct PeerContext *peer_ctx)
 Check if peer is removable. More...
 
static int check_peer_valid (const struct GNUNET_CONTAINER_MultiPeerMap *valid_peers, const struct GNUNET_PeerIdentity *peer)
 Check whether peer is actually a peer. More...
 
static void indicate_sending_intention (struct PeerContext *peer_ctx)
 Indicate that we want to send to the other peer. More...
 
static int check_peer_send_intention (const struct PeerContext *peer_ctx)
 Check whether other peer has the intention to send/opened channel towars us. More...
 
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. More...
 
static int check_sending_channel_exists (const struct PeerContext *peer_ctx)
 Check whether a sending channel towards the given peer exists. More...
 
static int destroy_sending_channel (struct PeerContext *peer_ctx)
 Destroy the send channel of a peer e.g. More...
 
static void send_message (struct PeerContext *peer_ctx, struct GNUNET_MQ_Envelope *ev, const char *type)
 Send a message to another peer. More...
 
static int schedule_operation (struct PeerContext *peer_ctx, const PeerOp peer_op, void *cls)
 Schedule a operation on given peer. More...
 
static void print_peer_list (struct GNUNET_PeerIdentity *list, unsigned int len)
 Print peerlist to log. More...
 
static void rem_from_list (struct GNUNET_PeerIdentity **peer_list, unsigned int *list_size, const struct GNUNET_PeerIdentity *peer)
 Remove peer from list. More...
 
static void insert_in_view_op (void *cls, const struct GNUNET_PeerIdentity *peer)
 Insert PeerID in #view. More...
 
static int insert_in_view (struct Sub *sub, const struct GNUNET_PeerIdentity *peer)
 Insert PeerID in #view. More...
 
static void send_view (const struct ClientContext *cli_ctx, const struct GNUNET_PeerIdentity *view_array, uint64_t view_size)
 Send view to client. More...
 
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. More...
 
static void clients_notify_view_update (const struct Sub *sub)
 sends updates to clients that are interested More...
 
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 More...
 
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. More...
 
static void resize_wrapper (struct RPS_Sampler *sampler, uint32_t new_size)
 Wrapper around RPS_sampler_resize() More...
 
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. More...
 
static void insert_in_pull_map (void *cls, const struct GNUNET_PeerIdentity *peer)
 Insert PeerID in #pull_map. More...
 
static void insert_in_sampler (void *cls, const struct GNUNET_PeerIdentity *peer)
 Update sampler with given PeerID. More...
 
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. More...
 
static int check_sending_channel_needed (const struct PeerContext *peer_ctx)
 Checks if there is a sending channel and if it is needed. More...
 
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. More...
 
static void clean_peer (struct Sub *sub, const struct GNUNET_PeerIdentity *peer)
 Remove data that is not needed anymore. More...
 
struct Subnew_sub (const struct GNUNET_HashCode *hash, uint32_t sampler_size, struct GNUNET_TIME_Relative round_interval)
 Create a new Sub. More...
 
static void destroy_sub (struct Sub *sub)
 Write all numbers in the given array into the given file. More...
 
void core_init (void *cls, const struct GNUNET_PeerIdentity *my_identity)
 Callback on initialisation of Core. More...
 
void * core_connects (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
 Callback for core. More...
 
void core_disconnects (void *cls, const struct GNUNET_PeerIdentity *peer, void *peer_cls)
 Callback for core. More...
 
static void destroy_cli_ctx (struct ClientContext *cli_ctx)
 Destroy the context for a (connected) client. More...
 
static void adapt_sizes (struct Sub *sub, double logestimate, double std_dev)
 Update sizes in sampler and view on estimate update from nse service. More...
 
static void nse_callback (void *cls, struct GNUNET_TIME_Absolute timestamp, double logestimate, double std_dev)
 Function called by NSE. More...
 
static int check_client_seed (void *cls, const struct GNUNET_RPS_CS_SeedMessage *msg)
 This function is called, when the client seeds peers. More...
 
static void handle_client_seed (void *cls, const struct GNUNET_RPS_CS_SeedMessage *msg)
 Handle seed from the client. More...
 
static void handle_client_view_request (void *cls, const struct GNUNET_RPS_CS_DEBUG_ViewRequest *msg)
 Handle RPS request from the client. More...
 
static void handle_client_view_cancel (void *cls, const struct GNUNET_MessageHeader *msg)
 Handle the cancellation of the view updates. More...
 
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. More...
 
static void handle_client_stream_cancel (void *cls, const struct GNUNET_MessageHeader *msg)
 Handles the cancellation of the stream of biased peer ids. More...
 
static void handle_client_start_sub (void *cls, const struct GNUNET_RPS_CS_SubStartMessage *msg)
 Create and start a Sub. More...
 
static void handle_client_stop_sub (void *cls, const struct GNUNET_RPS_CS_SubStopMessage *msg)
 Destroy the Sub. More...
 
static struct GNUNET_TIME_Relative compute_rand_delay (struct GNUNET_TIME_Relative mean, unsigned int spread)
 Compute a random delay. More...
 
static void send_pull_request (struct PeerContext *peer_ctx)
 Send single pull request. More...
 
static void send_push (struct PeerContext *peer_ctx)
 Send single push. More...
 
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(). More...
 
static int valid_peers_iterator (void *cls, const struct GNUNET_PeerIdentity *peer)
 Iterator function over stored, valid peers. More...
 
void process_peerinfo_peers (void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Message *hello, const char *err_msg)
 Iterator over peers from peerinfo. More...
 
static void shutdown_task (void *cls)
 Task run during shutdown. More...
 
static void * client_connect_cb (void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
 Handle client connecting to the service. More...
 
static void client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *client, void *internal_cls)
 Callback called when a client disconnected from the service. More...
 
static void run (void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
 Handle random peer sampling clients. More...
 
 GNUNET_SERVICE_MAIN ("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. More...
 

Variables

static const struct GNUNET_CONFIGURATION_Handlecfg
 Our configuration. More...
 
struct GNUNET_STATISTICS_Handlestats
 Handle to the statistics service. More...
 
struct GNUNET_CADET_Handlecadet_handle
 Handler to CADET. More...
 
struct GNUNET_CORE_Handlecore_handle
 Handle to CORE. More...
 
struct GNUNET_CONTAINER_MultiPeerMapmap_single_hop
 PeerMap to keep track of connected peers. More...
 
static struct GNUNET_PeerIdentity own_identity
 Our own identity. More...
 
static float alpha
 Percentage of total peer number in the view to send random PUSHes to. More...
 
static float beta
 Percentage of total peer number in the view to send random PULLs to. More...
 
static struct GNUNET_NSE_Handlense
 Handler to NSE. More...
 
static struct GNUNET_PEERINFO_Handlepeerinfo_handle
 Handler to PEERINFO. More...
 
static struct GNUNET_PEERINFO_NotifyContextpeerinfo_notify_handle
 Handle for cancellation of iteration over peers. More...
 
static struct Submsub
 Main Sub. More...
 
static const uint32_t num_valid_peers_max = UINT32_MAX
 Maximum number of valid peers to keep. More...
 
struct ClientContextcli_ctx_head
 DLL with all clients currently connected to us. More...
 
struct ClientContextcli_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__)

◆ 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 63 of file gnunet-service-rps.c.

Referenced by check_connected(), destroy_peer(), send_pull_request(), and set_peer_online().

◆ 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 68 of file gnunet-service-rps.c.

Referenced by check_peer_flag(), and check_removable().

◆ UNSET_PEER_FLAG

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

Unset flag of given peer context.

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

Referenced by check_connected(), destroy_peer(), and handle_peer_pull_reply().

◆ 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 79 of file gnunet-service-rps.c.

◆ unset_channel_flag

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

Unset flag of given channel context.

Definition at line 85 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 288 of file gnunet-service-rps.c.

Referenced by do_round().

◆ 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 296 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
clsClosure - Sub

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

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(), 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, 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(), to_file, Sub::view, View_clear(), View_get_as_array(), View_size(), and Sub::view_size_est_need.

Referenced by new_sub(), and send_push().

4275 {
4276  unsigned int i;
4277  const struct GNUNET_PeerIdentity *view_array;
4278  unsigned int *permut;
4279  unsigned int a_peers; /* Number of peers we send pushes to */
4280  unsigned int b_peers; /* Number of peers we send pull requests to */
4281  uint32_t first_border;
4282  uint32_t second_border;
4283  struct GNUNET_PeerIdentity peer;
4284  struct GNUNET_PeerIdentity *update_peer;
4285  struct Sub *sub = cls;
4286 
4287  sub->num_rounds++;
4289  "Going to execute next round.\n");
4290  if (sub == msub)
4291  {
4292  GNUNET_STATISTICS_update (stats, "# rounds", 1, GNUNET_NO);
4293  }
4294  sub->do_round_task = NULL;
4295 #ifdef TO_FILE_FULL
4296  to_file (sub->file_name_view_log,
4297  "___ new round ___");
4298 #endif /* TO_FILE_FULL */
4299  view_array = View_get_as_array (sub->view);
4300  for (i = 0; i < View_size (sub->view); i++)
4301  {
4303  "\t%s\n", GNUNET_i2s (&view_array[i]));
4304 #ifdef TO_FILE_FULL
4305  to_file (sub->file_name_view_log,
4306  "=%s\t(do round)",
4307  GNUNET_i2s_full (&view_array[i]));
4308 #endif /* TO_FILE_FULL */
4309  }
4310 
4311 
4312  /* Send pushes and pull requests */
4313  if (0 < View_size (sub->view))
4314  {
4316  View_size (sub->view));
4317 
4318  /* Send PUSHes */
4319  a_peers = ceil (alpha * View_size (sub->view));
4320 
4322  "Going to send pushes to %u (ceil (%f * %u)) peers.\n",
4323  a_peers, alpha, View_size (sub->view));
4324  for (i = 0; i < a_peers; i++)
4325  {
4326  peer = view_array[permut[i]];
4327  // FIXME if this fails schedule/loop this for later
4328  send_push (get_peer_ctx (sub->peer_map, &peer));
4329  }
4330 
4331  /* Send PULL requests */
4332  b_peers = ceil (beta * View_size (sub->view));
4333  first_border = a_peers;
4334  second_border = a_peers + b_peers;
4335  if (second_border > View_size (sub->view))
4336  {
4337  first_border = View_size (sub->view) - b_peers;
4338  second_border = View_size (sub->view);
4339  }
4341  "Going to send pulls to %u (ceil (%f * %u)) peers.\n",
4342  b_peers, beta, View_size (sub->view));
4343  for (i = first_border; i < second_border; i++)
4344  {
4345  peer = view_array[permut[i]];
4346  if (GNUNET_NO == check_peer_flag (sub->peer_map,
4347  &peer,
4349  { // FIXME if this fails schedule/loop this for later
4351  }
4352  }
4353 
4354  GNUNET_free (permut);
4355  permut = NULL;
4356  }
4357 
4358 
4359  /* Update view */
4360  /* TODO see how many peers are in push-/pull- list! */
4361 
4362  if ((CustomPeerMap_size (sub->push_map) <= alpha * sub->view_size_est_need) &&
4363  (0 < CustomPeerMap_size (sub->push_map)) &&
4364  (0 < CustomPeerMap_size (sub->pull_map)))
4365  { /* If conditions for update are fulfilled, update */
4366  LOG (GNUNET_ERROR_TYPE_DEBUG, "Update of the view.\n");
4367 
4368  uint32_t final_size;
4369  uint32_t peers_to_clean_size;
4370  struct GNUNET_PeerIdentity *peers_to_clean;
4371 
4372  peers_to_clean = NULL;
4373  peers_to_clean_size = 0;
4374  GNUNET_array_grow (peers_to_clean,
4375  peers_to_clean_size,
4376  View_size (sub->view));
4377  GNUNET_memcpy (peers_to_clean,
4378  view_array,
4379  View_size (sub->view) * sizeof(struct GNUNET_PeerIdentity));
4380 
4381  /* Seems like recreating is the easiest way of emptying the peermap */
4382  View_clear (sub->view);
4383 #ifdef TO_FILE_FULL
4384  to_file (sub->file_name_view_log,
4385  "--- emptied ---");
4386 #endif /* TO_FILE_FULL */
4387 
4388  first_border = GNUNET_MIN (ceil (alpha * sub->view_size_est_need),
4389  CustomPeerMap_size (sub->push_map));
4390  second_border = first_border
4391  + GNUNET_MIN (floor (beta * sub->view_size_est_need),
4392  CustomPeerMap_size (sub->pull_map));
4393  final_size = second_border
4394  + ceil ((1 - (alpha + beta)) * sub->view_size_est_need);
4396  "first border: %" PRIu32 ", second border: %" PRIu32 ", final size: %"
4397  PRIu32 "\n",
4398  first_border,
4399  second_border,
4400  final_size);
4401 
4402  /* Update view with peers received through PUSHes */
4404  CustomPeerMap_size (sub->push_map));
4405  for (i = 0; i < first_border; i++)
4406  {
4407  int inserted;
4408  inserted = insert_in_view (sub,
4410  permut[i]));
4411  if (GNUNET_OK == inserted)
4412  {
4414  1,
4416  sub->push_map, permut[i]));
4417  }
4418 #ifdef TO_FILE_FULL
4419  to_file (sub->file_name_view_log,
4420  "+%s\t(push list)",
4421  GNUNET_i2s_full (&view_array[i]));
4422 #endif /* TO_FILE_FULL */
4423  // TODO change the peer_flags accordingly
4424  }
4425  GNUNET_free (permut);
4426  permut = NULL;
4427 
4428  /* Update view with peers received through PULLs */
4430  CustomPeerMap_size (sub->pull_map));
4431  for (i = first_border; i < second_border; i++)
4432  {
4433  int inserted;
4434  inserted = insert_in_view (sub,
4436  permut[i
4437  -
4438  first_border
4439  ]));
4440  if (GNUNET_OK == inserted)
4441  {
4443  1,
4445  sub->pull_map,
4446  permut[i
4447  - first_border]));
4448  }
4449 #ifdef TO_FILE_FULL
4450  to_file (sub->file_name_view_log,
4451  "+%s\t(pull list)",
4452  GNUNET_i2s_full (&view_array[i]));
4453 #endif /* TO_FILE_FULL */
4454  // TODO change the peer_flags accordingly
4455  }
4456  GNUNET_free (permut);
4457  permut = NULL;
4458 
4459  /* Update view with peers from history */
4461  final_size - second_border,
4462  hist_update,
4463  sub);
4464  // TODO change the peer_flags accordingly
4465 
4466  for (i = 0; i < View_size (sub->view); i++)
4467  rem_from_list (&peers_to_clean, &peers_to_clean_size, &view_array[i]);
4468 
4469  /* Clean peers that were removed from the view */
4470  for (i = 0; i < peers_to_clean_size; i++)
4471  {
4472 #ifdef TO_FILE_FULL
4473  to_file (sub->file_name_view_log,
4474  "-%s",
4475  GNUNET_i2s_full (&peers_to_clean[i]));
4476 #endif /* TO_FILE_FULL */
4477  clean_peer (sub, &peers_to_clean[i]);
4478  }
4479 
4480  GNUNET_array_grow (peers_to_clean, peers_to_clean_size, 0);
4482  }
4483  else
4484  {
4485  LOG (GNUNET_ERROR_TYPE_DEBUG, "No update of the view.\n");
4486  if (sub == msub)
4487  {
4488  GNUNET_STATISTICS_update (stats, "# rounds blocked", 1, GNUNET_NO);
4489  if ((CustomPeerMap_size (sub->push_map) > alpha
4490  * sub->view_size_est_need) &&
4491  ! (0 >= CustomPeerMap_size (sub->pull_map)))
4492  GNUNET_STATISTICS_update (stats, "# rounds blocked - too many pushes",
4493  1, GNUNET_NO);
4494  if ((CustomPeerMap_size (sub->push_map) > alpha
4495  * sub->view_size_est_need) &&
4496  (0 >= CustomPeerMap_size (sub->pull_map)))
4498  "# rounds blocked - too many pushes, no pull replies",
4499  1, GNUNET_NO);
4500  if ((0 >= CustomPeerMap_size (sub->push_map)) &&
4501  ! (0 >= CustomPeerMap_size (sub->pull_map)))
4502  GNUNET_STATISTICS_update (stats, "# rounds blocked - no pushes", 1,
4503  GNUNET_NO);
4504  if ((0 >= CustomPeerMap_size (sub->push_map)) &&
4505  (0 >= CustomPeerMap_size (sub->pull_map)))
4507  "# rounds blocked - no pushes, no pull replies",
4508  1, GNUNET_NO);
4509  if ((0 >= CustomPeerMap_size (sub->pull_map)) &&
4511  * sub->view_size_est_need) &&
4512  (0 >= CustomPeerMap_size (sub->push_map)) )
4513  GNUNET_STATISTICS_update (stats, "# rounds blocked - no pull replies",
4514  1, GNUNET_NO);
4515  }
4516  }
4517  // TODO independent of that also get some peers from CADET_get_peers()?
4519  {
4520  sub->push_recv[CustomPeerMap_size (sub->push_map)]++;
4521  }
4522  else
4523  {
4525  "Push map size too big for histogram (%u, %u)\n",
4528  }
4529  // FIXME check bounds of histogram
4530  sub->push_delta[(int32_t) (CustomPeerMap_size (sub->push_map)
4531  - (alpha * sub->view_size_est_need))
4532  + (HISTOGRAM_FILE_SLOTS / 2)]++;
4533  if (sub == msub)
4534  {
4536  "# peers in push map at end of round",
4538  GNUNET_NO);
4540  "# peers in pull map at end of round",
4542  GNUNET_NO);
4544  "# peers in view at end of round",
4545  View_size (sub->view),
4546  GNUNET_NO);
4548  "# expected pushes",
4549  alpha * sub->view_size_est_need,
4550  GNUNET_NO);
4552  "delta expected - received pushes",
4554  * sub->
4555  view_size_est_need),
4556  GNUNET_NO);
4557  }
4558 
4560  "Received %u pushes and %u pulls last round (alpha (%.2f) * view_size (sub->view%u) = %.2f)\n",
4563  alpha,
4564  View_size (sub->view),
4565  alpha * View_size (sub->view));
4566 
4567  /* Update samplers */
4568  for (i = 0; i < CustomPeerMap_size (sub->push_map); i++)
4569  {
4570  update_peer = CustomPeerMap_get_peer_by_index (sub->push_map, i);
4572  "Updating with peer %s from push list\n",
4573  GNUNET_i2s (update_peer));
4574  insert_in_sampler (sub, update_peer);
4575  clean_peer (sub, update_peer); /* This cleans only if it is not in the view */
4576  }
4577 
4578  for (i = 0; i < CustomPeerMap_size (sub->pull_map); i++)
4579  {
4581  "Updating with peer %s from pull list\n",
4584  /* This cleans only if it is not in the view */
4586  }
4587 
4588 
4589  /* Empty push/pull lists */
4592 
4593  if (sub == msub)
4594  {
4596  "view size",
4597  View_size (sub->view),
4598  GNUNET_NO);
4599  }
4600 
4601  struct GNUNET_TIME_Relative time_next_round;
4602 
4603  time_next_round = compute_rand_delay (sub->round_interval, 2);
4604 
4605  /* Schedule next round */
4606  sub->do_round_task = GNUNET_SCHEDULER_add_delayed (time_next_round,
4607  &do_round, sub);
4608  LOG (GNUNET_ERROR_TYPE_DEBUG, "Finished round\n");
4609 }
static void do_round(void *cls)
Send out PUSHes and PULLs, possibly update #view, samplers.
static int insert_in_view(struct Sub *sub, const struct GNUNET_PeerIdentity *peer)
Insert PeerID in #view.
uint32_t num_rounds
Counts the executed rounds.
static void insert_in_sampler(void *cls, const struct GNUNET_PeerIdentity *peer)
Update sampler with given PeerID.
unsigned int * GNUNET_CRYPTO_random_permute(enum GNUNET_CRYPTO_Quality mode, unsigned int n)
Get an array with a random permutation of the numbers 0...n-1.
#define HISTOGRAM_FILE_SLOTS
This number determines the number of slots for files that represent histograms.
static float alpha
Percentage of total peer number in the view to send random PUSHes to.
struct GNUNET_PeerIdentity * CustomPeerMap_get_peer_by_index(const struct CustomPeerMap *c_peer_map, uint32_t index)
Get a peer by index.
#define to_file(file_name,...)
This function is used to facilitate writing important information to disk.
Definition: rps-test_util.h:65
static void send_pull_request(struct PeerContext *peer_ctx)
Send single pull request.
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.
struct RPS_Sampler * sampler
Sampler used for the Brahms protocol itself.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
const char * GNUNET_i2s_full(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
static struct Sub * msub
Main Sub.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
struct CustomPeerMap * push_map
List to store peers received through pushes temporary.
const struct GNUNET_PeerIdentity * View_get_as_array(const struct View *view)
Get the view as an array.
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.
unsigned int view_size_est_need
This is the estimate used as view size.
uint32_t push_delta[32]
Histogram of deltas between the expected and actual number of received pushes.
#define LOG(kind,...)
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
struct GNUNET_TIME_Relative round_interval
Time interval the do_round task runs in.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1269
If we are waiting for a reply from that peer (sent a pull request).
Definition: rps.h:250
#define GNUNET_array_grow(arr, size, tsize)
Grow a well-typed (!) array.
void CustomPeerMap_clear(const struct CustomPeerMap *c_peer_map)
Clear the custom peer map.
#define GNUNET_MIN(a, b)
Definition: gnunet_common.h:93
struct CustomPeerMap * pull_map
List to store peers received through pulls temporary.
struct RPS_SamplerRequestHandle * RPS_sampler_get_n_rand_peers(struct RPS_Sampler *sampler, uint32_t num_peers, RPS_sampler_n_rand_peers_ready_cb cb, void *cls)
Get n random peers out of the sampled peers.
static void rem_from_list(struct GNUNET_PeerIdentity **peer_list, unsigned int *list_size, const struct GNUNET_PeerIdentity *peer)
Remove peer from list.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
struct GNUNET_CONTAINER_MultiPeerMap * peer_map
Set of all peers to keep track of them.
One Sub.
uint32_t push_recv[32]
This array accumulates the number of received pushes per round.
unsigned int CustomPeerMap_size(const struct CustomPeerMap *c_peer_map)
Get the size of the custom peer map.
static void clean_peer(struct Sub *sub, const struct GNUNET_PeerIdentity *peer)
Remove data that is not needed anymore.
The identity of the host (wraps the signing key of the peer).
static void send_push(struct PeerContext *peer_ctx)
Send single push.
struct GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
unsigned int View_size(const struct View *view)
Get the size of the view.
void View_clear(struct View *view)
Clear the view.
struct GNUNET_SCHEDULER_Task * do_round_task
Identifier for the main task that runs periodically.
static float beta
Percentage of total peer number in the view to send random PULLs to.
struct View * view
The view.
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 struct GNUNET_TIME_Relative compute_rand_delay(struct GNUNET_TIME_Relative mean, unsigned int spread)
Compute a random delay.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
static void clients_notify_view_update(const struct Sub *sub)
sends updates to clients that are interested
#define GNUNET_free(ptr)
Wrapper around free.
Time for relative time used by GNUnet, in microseconds.
High-quality operations are desired.
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_mapThe peer map containing the context
peerthe peer id
Returns
the PeerContext

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

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

616 {
617  struct PeerContext *ctx;
618  int ret;
619 
620  ret = GNUNET_CONTAINER_multipeermap_contains (peer_map, peer);
621  GNUNET_assert (GNUNET_YES == ret);
622  ctx = GNUNET_CONTAINER_multipeermap_get (peer_map, peer);
623  GNUNET_assert (NULL != ctx);
624  return ctx;
625 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static struct GNUNET_DNSSTUB_Context * ctx
Context for DNS resolution.
Struct used to keep track of other peer&#39;s status.
void * GNUNET_CONTAINER_multipeermap_get(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Given a key find a value in the map matching the key.
int GNUNET_CONTAINER_multipeermap_contains(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Check if the map contains any value under the given key (including values that are NULL)...
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_mapThe peer map to check for the existence of peer
peerpeer in question
Returns
GNUNET_YES if peer is known GNUNET_NO if peer is not knwon

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

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

642 {
643  if (NULL != peer_map)
644  {
645  return GNUNET_CONTAINER_multipeermap_contains (peer_map, peer);
646  }
647  else
648  {
649  return GNUNET_NO;
650  }
651 }
int GNUNET_CONTAINER_multipeermap_contains(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Check if the map contains any value under the given key (including values that are NULL)...
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
subThe Sub this context belongs to.
peerthe peer to create the PeerContext for
Returns
the PeerContext

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

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(), peer, PeerContext::peer_id, Sub::peer_map, ret, and PeerContext::sub.

Referenced by create_or_get_peer_ctx(), and insert_peer().

665 {
666  struct PeerContext *ctx;
667  int ret;
668 
670 
671  ctx = GNUNET_new (struct PeerContext);
672  ctx->peer_id = *peer;
673  ctx->sub = sub;
674  ret = GNUNET_CONTAINER_multipeermap_put (sub->peer_map, peer, ctx,
676  GNUNET_assert (GNUNET_OK == ret);
677  if (sub == msub)
678  {
680  "# known peers",
682  GNUNET_NO);
683  }
684  return ctx;
685 }
struct GNUNET_PeerIdentity peer_id
Identity of the peer.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static struct Sub * msub
Main Sub.
static struct GNUNET_DNSSTUB_Context * ctx
Context for DNS resolution.
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.
Struct used to keep track of other peer&#39;s status.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
There must only be one value per key; storing a value should fail if a value under the same key alrea...
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
struct GNUNET_CONTAINER_MultiPeerMap * peer_map
Set of all peers to keep track of them.
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
struct GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
struct Sub * sub
The Sub this context belongs to.
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.
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
subThe Sub to which the created context belongs to
peerthe peer to get the associated context to
Returns
the context

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

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

Referenced by handle_inbound_channel().

699 {
700  if (GNUNET_NO == check_peer_known (sub->peer_map, peer))
701  {
702  return create_peer_ctx (sub, peer);
703  }
704  return get_peer_ctx (sub->peer_map, peer);
705 }
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 * 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.
struct GNUNET_CONTAINER_MultiPeerMap * peer_map
Set of all peers to keep track of them.
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_ctxContext of the peer of which connectivity is to be checked
Returns
GNUNET_YES if we are connected GNUNET_NO otherwise

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

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

720 {
721  /* If we don't know about this peer we don't know whether it's online */
722  if (GNUNET_NO == check_peer_known (peer_ctx->sub->peer_map,
723  &peer_ctx->peer_id))
724  {
725  return GNUNET_NO;
726  }
727  /* Get the context */
728  peer_ctx = get_peer_ctx (peer_ctx->sub->peer_map, &peer_ctx->peer_id);
729  /* If we have no channel to this peer we don't know whether it's online */
730  if ((NULL == peer_ctx->send_channel_ctx) &&
731  (NULL == peer_ctx->recv_channel_ctx))
732  {
733  UNSET_PEER_FLAG (peer_ctx, Peers_ONLINE);
734  return GNUNET_NO;
735  }
736  /* Otherwise (if we have a channel, we know that it's online */
737  SET_PEER_FLAG (peer_ctx, Peers_ONLINE);
738  return GNUNET_YES;
739 }
struct GNUNET_PeerIdentity peer_id
Identity of the peer.
#define UNSET_PEER_FLAG(peer_ctx, mask)
Unset flag of given peer context.
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.
#define SET_PEER_FLAG(peer_ctx, mask)
Set a peer flag of given peer context.
struct GNUNET_CONTAINER_MultiPeerMap * peer_map
Set of all peers to keep track of them.
struct ChannelCtx * send_channel_ctx
Channel open to client.
struct ChannelCtx * recv_channel_ctx
Channel open from client.
struct Sub * sub
The Sub this context belongs to.
We set this bit when we know the peer is online.
Definition: rps.h:259
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
clsthe GetRandPeerIteratorCls containing index and peer
peercurrent peer
valueunused
Returns
GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

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

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

Referenced by get_random_peer_from_peermap().

780 {
781  struct GetRandPeerIteratorCls *iterator_cls = cls;
782 
783  (void) value;
784 
785  if (0 >= iterator_cls->index)
786  {
787  iterator_cls->peer = peer;
788  return GNUNET_NO;
789  }
790  iterator_cls->index--;
791  return GNUNET_YES;
792 }
The closure to get_rand_peer_iterator.
static char * value
Value of the record to add/remove.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
uint32_t index
The index of the peer to return.
const struct GNUNET_PeerIdentity * peer
Pointer to peer to return.
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_peersPeer map containing valid peers from which to select a random one
Returns
a random peer

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

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

805 {
806  struct GetRandPeerIteratorCls *iterator_cls;
807  const struct GNUNET_PeerIdentity *ret;
808 
809  iterator_cls = GNUNET_new (struct GetRandPeerIteratorCls);
812  valid_peers));
813  (void) GNUNET_CONTAINER_multipeermap_iterate (valid_peers,
815  iterator_cls);
816  ret = iterator_cls->peer;
817  GNUNET_free (iterator_cls);
818  return ret;
819 }
The closure to get_rand_peer_iterator.
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
#define GNUNET_new(type)
Allocate a struct or union of the given type.
uint32_t index
The index of the peer to return.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
The identity of the host (wraps the signing key of the peer).
const struct GNUNET_PeerIdentity * peer
Pointer to peer to return.
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
#define GNUNET_free(ptr)
Wrapper around free.
static int get_rand_peer_iterator(void *cls, const struct GNUNET_PeerIdentity *peer, void *value)
Iterator function for get_random_peer_from_peermap.
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
peerThe peer that is added to the valid peers.
valid_peersPeer 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 834 of file gnunet-service-rps.c.

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, num_valid_peers_max, remove_pending_message(), ret, and Sub::valid_peers.

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

836 {
837  const struct GNUNET_PeerIdentity *rand_peer;
838  int ret;
839 
840  ret = GNUNET_YES;
841  /* Remove random peers until there is space for a new one */
842  while (num_valid_peers_max <=
844  {
845  rand_peer = get_random_peer_from_peermap (valid_peers);
846  GNUNET_CONTAINER_multipeermap_remove_all (valid_peers, rand_peer);
847  ret = GNUNET_NO;
848  }
849  (void) GNUNET_CONTAINER_multipeermap_put (valid_peers, peer, NULL,
851  if (valid_peers == msub->valid_peers)
852  {
854  "# valid peers",
856  GNUNET_NO);
857  }
858  return ret;
859 }
int GNUNET_CONTAINER_multipeermap_remove_all(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Remove all entries for the given key from the map.
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 ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static struct Sub * msub
Main Sub.
struct GNUNET_CONTAINER_MultiPeerMap * valid_peers
Hashmap of valid peers.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
There must only be one value per key; storing a value should fail if a value under the same key alrea...
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
The identity of the host (wraps the signing key of the peer).
struct GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.
static const uint32_t num_valid_peers_max
Maximum number of valid peers to keep.
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_msgthe pending message to remove
cancelwhether to cancel the pending message, too

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

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

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

1090 {
1091  struct PeerContext *peer_ctx;
1092 
1093  (void) cancel;
1094 
1095  peer_ctx = pending_msg->peer_ctx;
1096  GNUNET_assert (NULL != peer_ctx);
1098  peer_ctx->pending_messages_tail,
1099  pending_msg);
1100  // TODO wait for the cadet implementation of message cancellation
1101  // if (GNUNET_YES == cancel)
1102  // {
1103  // GNUNET_MQ_send_cancel (pending_msg->ev);
1104  // }
1105  GNUNET_free (pending_msg);
1106 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct PeerContext * peer_ctx
The corresponding context.
Struct used to keep track of other peer&#39;s status.
struct PendingMessage * pending_messages_head
DLL with all messages that are yet to be sent.
struct PendingMessage * pending_messages_tail
#define GNUNET_free(ptr)
Wrapper around free.
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_ctxthe PeerContext of the peer to set online

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

References check_peer_pull_reply(), cleanup_destroyed_channel(), GNUNET_array_grow, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_YES, handle_peer_check(), handle_peer_pull_reply(), handle_peer_pull_request(), handle_peer_push(), LOG, msg, PeerContext::num_pending_ops, PeerContext::online_check_pending, PeerPendingOp::op, PeerPendingOp::op_cls, peer, 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().

875 {
876  struct GNUNET_PeerIdentity *peer;
877  unsigned int i;
878 
879  peer = &peer_ctx->peer_id;
881  "Peer %s is online and valid, calling %i pending operations on it\n",
882  GNUNET_i2s (peer),
883  peer_ctx->num_pending_ops);
884 
885  if (NULL != peer_ctx->online_check_pending)
886  {
888  "Removing pending online check for peer %s\n",
889  GNUNET_i2s (&peer_ctx->peer_id));
890  // TODO wait until cadet sets mq->cancel_impl
891  // GNUNET_MQ_send_cancel (peer_ctx->online_check_pending->ev);
893  peer_ctx->online_check_pending = NULL;
894  }
895 
896  SET_PEER_FLAG (peer_ctx, Peers_ONLINE);
897 
898  /* Call pending operations */
899  for (i = 0; i < peer_ctx->num_pending_ops; i++)
900  {
901  peer_ctx->pending_ops[i].op (peer_ctx->pending_ops[i].op_cls, peer);
902  }
903  GNUNET_array_grow (peer_ctx->pending_ops, peer_ctx->num_pending_ops, 0);
904 }
struct PeerPendingOp * pending_ops
Array of pending operations on this peer.
struct GNUNET_PeerIdentity peer_id
Identity of the peer.
static void remove_pending_message(struct PendingMessage *pending_msg, int cancel)
Remove a pending message from the respective DLL.
struct PendingMessage * online_check_pending
Handle to the callback given to cadet_ntfy_tmt_rdy()
#define LOG(kind,...)
#define GNUNET_array_grow(arr, size, tsize)
Grow a well-typed (!) array.
#define SET_PEER_FLAG(peer_ctx, mask)
Set a peer flag of given peer context.
PeerOp op
Callback.
unsigned int num_pending_ops
Number of pending operations.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
The identity of the host (wraps the signing key of the peer).
void * op_cls
Closure.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
We set this bit when we know the peer is online.
Definition: rps.h:259
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
clsThe closure - Context to the channel
channelThe channel being closed

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

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

2832 {
2833  struct ChannelCtx *channel_ctx = cls;
2834  struct PeerContext *peer_ctx = channel_ctx->peer_ctx;
2835 
2836  (void) channel;
2837 
2838  channel_ctx->channel = NULL;
2839  remove_channel_ctx (channel_ctx);
2840  if ((NULL != peer_ctx) &&
2841  (peer_ctx->send_channel_ctx == channel_ctx) &&
2842  (GNUNET_YES == check_sending_channel_needed (channel_ctx->peer_ctx)) )
2843  {
2844  remove_peer (peer_ctx->sub, &peer_ctx->peer_id);
2845  }
2846 }
struct GNUNET_PeerIdentity peer_id
Identity of the peer.
struct PeerContext * peer_ctx
The peer context associated with the channel.
Context for a channel.
struct GNUNET_CADET_Channel * channel
The channel itself.
Struct used to keep track of other peer&#39;s status.
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.
struct ChannelCtx * send_channel_ctx
Channel open to client.
struct Sub * sub
The Sub this context belongs to.
static void remove_channel_ctx(struct ChannelCtx *channel_ctx)
Free memory and NULL pointers.
static int check_sending_channel_needed(const struct PeerContext *peer_ctx)
Checks if there is a sending channel and if it is needed.
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
clsClosure - Context of channel
msgMessage - unused

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

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

Referenced by set_peer_online().

3520 {
3521  const struct ChannelCtx *channel_ctx = cls;
3522  const struct GNUNET_PeerIdentity *peer = &channel_ctx->peer_ctx->peer_id;
3523 
3524  (void) msg;
3525 
3527  "Received CHECK_LIVE (%s)\n", GNUNET_i2s (peer));
3528  if (channel_ctx->peer_ctx->sub == msub)
3529  {
3531  "# pending online checks",
3532  -1,
3533  GNUNET_NO);
3534  }
3535 
3536  GNUNET_CADET_receive_done (channel_ctx->channel);
3537 }
struct GNUNET_PeerIdentity peer_id
Identity of the peer.
struct PeerContext * peer_ctx
The peer context associated with the channel.
static struct Sub * msub
Main Sub.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
#define LOG(kind,...)
Context for a channel.
struct GNUNET_CADET_Channel * channel
The channel itself.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
The identity of the host (wraps the signing key of the peer).
void GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
Send an ack on the channel to confirm the processing of a message.
Definition: cadet_api.c:888
struct GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
struct Sub * sub
The Sub this context belongs to.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
Here is the call graph for this function:
Here is the caller 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
clsClosure - Context of channel
msgMessage - unused

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

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, mal_type, peer, ChannelCtx::peer_ctx, PeerContext::peer_id, Sub::peer_map, Sub::push_map, and PeerContext::sub.

Referenced by set_peer_online().

3552 {
3553  const struct ChannelCtx *channel_ctx = cls;
3554  const struct GNUNET_PeerIdentity *peer = &channel_ctx->peer_ctx->peer_id;
3555 
3556  (void) msg;
3557 
3558  // (check the proof of work (?))
3559 
3561  "Received PUSH (%s)\n",
3562  GNUNET_i2s (peer));
3563  if (channel_ctx->peer_ctx->sub == msub)
3564  {
3565  GNUNET_STATISTICS_update (stats, "# push message received", 1, GNUNET_NO);
3566  if ((NULL != map_single_hop) &&
3568  peer)))
3569  {
3571  "# push message received (multi-hop peer)",
3572  1,
3573  GNUNET_NO);
3574  }
3575  }
3576 
3577  #if ENABLE_MALICIOUS
3578  struct AttackedPeer *tmp_att_peer;
3579 
3580  if ((1 == mal_type) ||
3581  (3 == mal_type))
3582  { /* Try to maximise representation */
3583  tmp_att_peer = GNUNET_new (struct AttackedPeer);
3584  tmp_att_peer->peer_id = *peer;
3585  if (NULL == att_peer_set)
3586  att_peer_set = GNUNET_CONTAINER_multipeermap_create (1, GNUNET_NO);
3588  peer))
3589  {
3590  GNUNET_CONTAINER_DLL_insert (att_peers_head,
3591  att_peers_tail,
3592  tmp_att_peer);
3593  add_peer_array_to_set (peer, 1, att_peer_set);
3594  }
3595  else
3596  {
3597  GNUNET_free (tmp_att_peer);
3598  }
3599  }
3600 
3601 
3602  else if (2 == mal_type)
3603  {
3604  /* We attack one single well-known peer - simply ignore */
3605  }
3606  #endif /* ENABLE_MALICIOUS */
3607 
3608  /* Add the sending peer to the push_map */
3609  CustomPeerMap_put (channel_ctx->peer_ctx->sub->push_map, peer);
3610 
3612  &channel_ctx->peer_ctx->peer_id));
3613  GNUNET_CADET_receive_done (channel_ctx->channel);
3614 }
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
struct GNUNET_PeerIdentity peer_id
Identity of the peer.
struct PeerContext * peer_ctx
The peer context associated with the channel.
static unsigned int mal_type
Portion of malicious peers.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static struct Sub * msub
Main Sub.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
struct CustomPeerMap * push_map
List to store peers received through pushes temporary.
struct GNUNET_CONTAINER_MultiPeerMap * GNUNET_CONTAINER_multipeermap_create(unsigned int len, int do_not_copy_keys)
Create a multi peer map (hash map for public keys of peers).
#define LOG(kind,...)
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.
int CustomPeerMap_put(const struct CustomPeerMap *c_peer_map, const struct GNUNET_PeerIdentity *peer)
Insert peer into the custom peer map.
Context for a channel.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
struct GNUNET_CADET_Channel * channel
The channel itself.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
struct GNUNET_CONTAINER_MultiPeerMap * peer_map
Set of all peers to keep track of them.
The identity of the host (wraps the signing key of the peer).
void GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
Send an ack on the channel to confirm the processing of a message.
Definition: cadet_api.c:888
struct GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
struct GNUNET_CONTAINER_MultiPeerMap * map_single_hop
PeerMap to keep track of connected peers.
struct Sub * sub
The Sub this context belongs to.
int GNUNET_CONTAINER_multipeermap_contains(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Check if the map contains any value under the given key (including values that are NULL)...
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller 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
clsClosure - Context of channel
msgMessage - unused

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

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, mal_type, ChannelCtx::peer_ctx, PeerContext::peer_id, Sub::peer_map, send_pull_reply(), PeerContext::sub, Sub::view, View_get_as_array(), and View_size().

Referenced by set_peer_online().

3628 {
3629  const struct ChannelCtx *channel_ctx = cls;
3630  struct PeerContext *peer_ctx = channel_ctx->peer_ctx;
3631  const struct GNUNET_PeerIdentity *peer = &peer_ctx->peer_id;
3632  const struct GNUNET_PeerIdentity *view_array;
3633 
3634  (void) msg;
3635 
3636  LOG (GNUNET_ERROR_TYPE_DEBUG, "Received PULL REQUEST (%s)\n", GNUNET_i2s (
3637  peer));
3638  if (peer_ctx->sub == msub)
3639  {
3641  "# pull request message received",
3642  1,
3643  GNUNET_NO);
3644  if ((NULL != map_single_hop) &&
3646  &peer_ctx->peer_id)))
3647  {
3649  "# pull request message received (multi-hop peer)",
3650  1,
3651  GNUNET_NO);
3652  }
3653  }
3654 
3655  #if ENABLE_MALICIOUS
3656  if ((1 == mal_type)
3657  || (3 == mal_type))
3658  { /* Try to maximise representation */
3659  send_pull_reply (peer_ctx, mal_peers, num_mal_peers);
3660  }
3661 
3662  else if (2 == mal_type)
3663  { /* Try to partition network */
3664  if (0 == GNUNET_memcmp (&attacked_peer, peer))
3665  {
3666  send_pull_reply (peer_ctx, mal_peers, num_mal_peers);
3667  }
3668  }
3669  #endif /* ENABLE_MALICIOUS */
3670 
3672  &channel_ctx->peer_ctx->peer_id));
3673  GNUNET_CADET_receive_done (channel_ctx->channel);
3674  view_array = View_get_as_array (channel_ctx->peer_ctx->sub->view);
3675  send_pull_reply (peer_ctx,
3676  view_array,
3677  View_size (channel_ctx->peer_ctx->sub->view));
3678 }
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.
struct GNUNET_PeerIdentity peer_id
Identity of the peer.
struct PeerContext * peer_ctx
The peer context associated with the channel.
static unsigned int mal_type
Portion of malicious peers.
static struct Sub * msub
Main Sub.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
const struct GNUNET_PeerIdentity * View_get_as_array(const struct View *view)
Get the view as an array.
#define LOG(kind,...)
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.
Context for a channel.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
struct GNUNET_CADET_Channel * channel
The channel itself.
Struct used to keep track of other peer&#39;s status.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
struct GNUNET_CONTAINER_MultiPeerMap * peer_map
Set of all peers to keep track of them.
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
The identity of the host (wraps the signing key of the peer).
void GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
Send an ack on the channel to confirm the processing of a message.
Definition: cadet_api.c:888
struct GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
unsigned int View_size(const struct View *view)
Get the size of the view.
struct GNUNET_CONTAINER_MultiPeerMap * map_single_hop
PeerMap to keep track of connected peers.
struct Sub * sub
The Sub this context belongs to.
struct View * view
The view.
int GNUNET_CONTAINER_multipeermap_contains(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Check if the map contains any value under the given key (including values that are NULL)...
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
Here is the call graph for this function:
Here is the caller 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
clsClosure - Context of channel
msgMessage containing the replied peers

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

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, GNUNET_RPS_P2P_PullReplyMessage::header, LOG, GNUNET_RPS_P2P_PullReplyMessage::num_peers, ChannelCtx::peer_ctx, PeerContext::peer_id, Sub::peer_map, Peers_PULL_REPLY_PENDING, GNUNET_MessageHeader::size, and PeerContext::sub.

Referenced by set_peer_online().

3691 {
3692  struct ChannelCtx *channel_ctx = cls;
3693  struct PeerContext *sender_ctx = channel_ctx->peer_ctx;
3694 
3695  if (sizeof(struct GNUNET_RPS_P2P_PullReplyMessage) > ntohs (msg->header.size))
3696  {
3697  GNUNET_break_op (0);
3698  return GNUNET_SYSERR;
3699  }
3700 
3701  if ((ntohs (msg->header.size) - sizeof(struct
3703  / sizeof(struct GNUNET_PeerIdentity) != ntohl (msg->num_peers))
3704  {
3706  "message says it sends %" PRIu32 " peers, have space for %lu peers\n",
3707  ntohl (msg->num_peers),
3708  (ntohs (msg->header.size) - sizeof(struct
3710  / sizeof(struct GNUNET_PeerIdentity));
3711  GNUNET_break_op (0);
3712  return GNUNET_SYSERR;
3713  }
3714 
3715  if (GNUNET_YES != check_peer_flag (sender_ctx->sub->peer_map,
3716  &sender_ctx->peer_id,
3718  {
3720  "Received a pull reply from a peer (%s) we didn't request one from!\n",
3721  GNUNET_i2s (&sender_ctx->peer_id));
3722  if (sender_ctx->sub == msub)
3723  {
3725  "# unrequested pull replies",
3726  1,
3727  GNUNET_NO);
3728  }
3729  }
3730  return GNUNET_OK;
3731 }
struct GNUNET_MessageHeader header
Header including size and type in NBO.
Definition: rps.h:48
struct GNUNET_PeerIdentity peer_id
Identity of the peer.
P2P Message to send PeerIDs to other peer.
Definition: rps.h:43
uint32_t num_peers
Number of PeerIDs sent.
Definition: rps.h:53
struct PeerContext * peer_ctx
The peer context associated with the channel.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
static struct Sub * msub
Main Sub.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
#define LOG(kind,...)
If we are waiting for a reply from that peer (sent a pull request).
Definition: rps.h:250
Context for a channel.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
Struct used to keep track of other peer&#39;s status.
struct GNUNET_CONTAINER_MultiPeerMap * peer_map
Set of all peers to keep track of them.
The identity of the host (wraps the signing key of the peer).
struct GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
struct Sub * sub
The Sub this context belongs to.
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.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
Here is the call graph for this function:
Here is the caller 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
clsClosure
msgThe message header

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

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, mal_type, GNUNET_RPS_P2P_PullReplyMessage::num_peers, 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(), PeerContext::sub, UNSET_PEER_FLAG, and Sub::valid_peers.

Referenced by set_peer_online().

3743 {
3744  const struct ChannelCtx *channel_ctx = cls;
3745  const struct GNUNET_PeerIdentity *sender = &channel_ctx->peer_ctx->peer_id;
3746  const struct GNUNET_PeerIdentity *peers;
3747  struct Sub *sub = channel_ctx->peer_ctx->sub;
3748  uint32_t i;
3749 
3750 #if ENABLE_MALICIOUS
3751  struct AttackedPeer *tmp_att_peer;
3752 #endif /* ENABLE_MALICIOUS */
3753 
3754  sub->pull_delays[sub->num_rounds - channel_ctx->peer_ctx->round_pull_req]++;
3755  LOG (GNUNET_ERROR_TYPE_DEBUG, "Received PULL REPLY (%s)\n", GNUNET_i2s (
3756  sender));
3757  if (channel_ctx->peer_ctx->sub == msub)
3758  {
3760  "# pull reply messages received",
3761  1,
3762  GNUNET_NO);
3763  if ((NULL != map_single_hop) &&
3765  &channel_ctx->
3766  peer_ctx->peer_id)) )
3767  {
3769  "# pull reply messages received (multi-hop peer)",
3770  1,
3771  GNUNET_NO);
3772  }
3773  }
3774 
3775  #if ENABLE_MALICIOUS
3776  // We shouldn't even receive pull replies as we're not sending
3777  if (2 == mal_type)
3778  {
3779  }
3780  #endif /* ENABLE_MALICIOUS */
3781 
3782  /* Do actual logic */
3783  peers = (const struct GNUNET_PeerIdentity *) &msg[1];
3784 
3786  "PULL REPLY received, got following %u peers:\n",
3787  ntohl (msg->num_peers));
3788 
3789  for (i = 0; i < ntohl (msg->num_peers); i++)
3790  {
3792  "%u. %s\n",
3793  i,
3794  GNUNET_i2s (&peers[i]));
3795 
3796  #if ENABLE_MALICIOUS
3797  if ((NULL != att_peer_set) &&
3798  ((1 == mal_type) || (3 == mal_type) ))
3799  { /* Add attacked peer to local list */
3800  // TODO check if we sent a request and this was the first reply
3801  if ((GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (att_peer_set,
3802  &peers[i]))
3804  &peers[i])) )
3805  {
3806  tmp_att_peer = GNUNET_new (struct AttackedPeer);
3807  tmp_att_peer->peer_id = peers[i];
3808  GNUNET_CONTAINER_DLL_insert (att_peers_head,
3809  att_peers_tail,
3810  tmp_att_peer);
3811  add_peer_array_to_set (&peers[i], 1, att_peer_set);
3812  }
3813  continue;
3814  }
3815  #endif /* ENABLE_MALICIOUS */
3816  /* Make sure we 'know' about this peer */
3817  (void) insert_peer (channel_ctx->peer_ctx->sub,
3818  &peers[i]);
3819 
3820  if (GNUNET_YES == check_peer_valid (channel_ctx->peer_ctx->sub->valid_peers,
3821  &peers[i]))
3822  {
3823  CustomPeerMap_put (channel_ctx->peer_ctx->sub->pull_map,
3824  &peers[i]);
3825  }
3826  else
3827  {
3828  schedule_operation (channel_ctx->peer_ctx,
3830  channel_ctx->peer_ctx->sub); /* cls */
3831  (void) issue_peer_online_check (channel_ctx->peer_ctx->sub,
3832  &peers[i]);
3833  }
3834  }
3835 
3837  sender),
3839  clean_peer (channel_ctx->peer_ctx->sub,
3840  sender);
3841 
3843  sender));
3844  GNUNET_CADET_receive_done (channel_ctx->channel);
3845 }
static int schedule_operation(struct PeerContext *peer_ctx, const PeerOp peer_op, void *cls)
Schedule a operation on given peer.
uint32_t num_rounds
Counts the executed rounds.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
struct GNUNET_PeerIdentity peer_id
Identity of the peer.
uint32_t num_peers
Number of PeerIDs sent.
Definition: rps.h:53
struct PeerContext * peer_ctx
The peer context associated with the channel.
#define UNSET_PEER_FLAG(peer_ctx, mask)
Unset flag of given peer context.
static unsigned int mal_type
Portion of malicious peers.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static struct Sub * msub
Main Sub.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
static struct PeerContext * get_peer_ctx(const struct GNUNET_CONTAINER_MultiPeerMap *peer_map, const struct GNUNET_PeerIdentity *peer)
Get the PeerContext associated with a peer.
#define LOG(kind,...)
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.
If we are waiting for a reply from that peer (sent a pull request).
Definition: rps.h:250
int CustomPeerMap_put(const struct CustomPeerMap *c_peer_map, const struct GNUNET_PeerIdentity *peer)
Insert peer into the custom peer map.
Context for a channel.
static void insert_in_pull_map(void *cls, const struct GNUNET_PeerIdentity *peer)
Insert PeerID in #pull_map.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
struct GNUNET_CONTAINER_MultiPeerMap * valid_peers
Hashmap of valid peers.
struct GNUNET_CADET_Channel * channel
The channel itself.
uint32_t round_pull_req
This is pobably followed by &#39;statistical&#39; data (when we first saw it, how did we get its ID...
struct CustomPeerMap * pull_map
List to store peers received through pulls temporary.
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.
struct GNUNET_CONTAINER_MultiPeerMap * peer_map
Set of all peers to keep track of them.
One Sub.
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 clean_peer(struct Sub *sub, const struct GNUNET_PeerIdentity *peer)
Remove data that is not needed anymore.
The identity of the host (wraps the signing key of the peer).
void GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
Send an ack on the channel to confirm the processing of a message.
Definition: cadet_api.c:888
static struct CadetPeer * peers
Operation to get peer ids.
struct GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
uint32_t pull_delays[32]
Number of pull replies with this delay measured in rounds.
struct GNUNET_CONTAINER_MultiPeerMap * map_single_hop
PeerMap to keep track of connected peers.
static int insert_peer(struct Sub *sub, const struct GNUNET_PeerIdentity *peer)
Add peer to known peers.
struct Sub * sub
The Sub this context belongs to.
int GNUNET_CONTAINER_multipeermap_contains(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Check if the map contains any value under the given key (including values that are NULL)...
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
Here is the call graph for this function:
Here is the caller 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_ctxcontext of the according peer
Returns
The channel context

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

References GNUNET_new, and ChannelCtx::peer_ctx.

Referenced by get_channel(), and handle_inbound_channel().

943 {
944  struct ChannelCtx *channel_ctx;
945 
946  channel_ctx = GNUNET_new (struct ChannelCtx);
947  channel_ctx->peer_ctx = peer_ctx;
948  return channel_ctx;
949 }
struct PeerContext * peer_ctx
The peer context associated with the channel.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Context for a 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_ctxThe channel context.

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

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

959 {
960  struct PeerContext *peer_ctx = channel_ctx->peer_ctx;
961 
962  if (NULL != channel_ctx->destruction_task)
963  {
965  channel_ctx->destruction_task = NULL;
966  }
967 
968  GNUNET_free (channel_ctx);
969 
970  if (NULL == peer_ctx)
971  return;
972  if (channel_ctx == peer_ctx->send_channel_ctx)
973  {
974  peer_ctx->send_channel_ctx = NULL;
975  peer_ctx->mq = NULL;
976  }
977  else if (channel_ctx == peer_ctx->recv_channel_ctx)
978  {
979  peer_ctx->recv_channel_ctx = NULL;
980  }
981 }
struct PeerContext * peer_ctx
The peer context associated with the channel.
struct GNUNET_SCHEDULER_Task * destruction_task
When channel destruction needs to be delayed (because it is called from within the cadet routine of a...
Struct used to keep track of other peer&#39;s status.
struct GNUNET_MQ_Handle * mq
Message queue open to client.
struct ChannelCtx * send_channel_ctx
Channel open to client.
struct ChannelCtx * recv_channel_ctx
Channel open from client.
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
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_ctxContext of the peer of which to get the channel
Returns
the GNUNET_CADET_Channel used to send data to peer_ctx

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

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

992 {
993  /* There exists a copy-paste-clone in run() */
994  struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
995  GNUNET_MQ_hd_fixed_size (peer_check,
997  struct GNUNET_MessageHeader,
998  NULL),
999  GNUNET_MQ_hd_fixed_size (peer_push,
1001  struct GNUNET_MessageHeader,
1002  NULL),
1003  GNUNET_MQ_hd_fixed_size (peer_pull_request,
1005  struct GNUNET_MessageHeader,
1006  NULL),
1007  GNUNET_MQ_hd_var_size (peer_pull_reply,
1010  NULL),
1012  };
1013 
1014 
1015  if (NULL == peer_ctx->send_channel_ctx)
1016  {
1018  "Trying to establish channel to peer %s\n",
1019  GNUNET_i2s (&peer_ctx->peer_id));
1020  peer_ctx->send_channel_ctx = add_channel_ctx (peer_ctx);
1021  peer_ctx->send_channel_ctx->channel =
1023  peer_ctx->send_channel_ctx, /* context */
1024  &peer_ctx->peer_id,
1025  &peer_ctx->sub->hash,
1026  NULL, /* WindowSize handler */
1027  &cleanup_destroyed_channel, /* Disconnect handler */
1028  cadet_handlers);
1029  }
1030  GNUNET_assert (NULL != peer_ctx->send_channel_ctx);
1031  GNUNET_assert (NULL != peer_ctx->send_channel_ctx->channel);
1032  return peer_ctx->send_channel_ctx->channel;
1033 }
struct GNUNET_HashCode hash
Hash of the shared value that defines Subs.
static void cleanup_destroyed_channel(void *cls, const struct GNUNET_CADET_Channel *channel)
This is called when a channel is destroyed.
struct GNUNET_PeerIdentity peer_id
Identity of the peer.
P2P Message to send PeerIDs to other peer.
Definition: rps.h:43
#define GNUNET_MESSAGE_TYPE_RPS_PP_CHECK_LIVE
RPS check liveliness message to check liveliness of other peer.
struct GNUNET_CADET_Handle * cadet_handle
Handler to CADET.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_MESSAGE_TYPE_RPS_PP_PUSH
RPS PUSH message to push own ID to another peer.
static struct ChannelCtx * add_channel_ctx(struct PeerContext *peer_ctx)
Allocate memory for a new channel context and insert it into DLL.
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
#define LOG(kind,...)
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
struct GNUNET_CADET_Channel * channel
The channel itself.
#define GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REQUEST
RPS PULL REQUEST message to request the local view of another peer.
Message handler for a specific message type.
struct GNUNET_CADET_Channel * GNUNET_CADET_channel_create(struct GNUNET_CADET_Handle *h, void *channel_cls, const struct GNUNET_PeerIdentity *destination, const struct GNUNET_HashCode *port, GNUNET_CADET_WindowSizeEventHandler window_changes, GNUNET_CADET_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Create a new channel towards a remote peer.
Definition: cadet_api.c:1031
struct ChannelCtx * send_channel_ctx
Channel open to client.
#define GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REPLY
RPS PULL REPLY message which contains the view of the other peer.
Header for all communications.
struct Sub * sub
The Sub this context belongs to.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
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, otherways create one.

Parameters
peer_ctxContext of the peer of whicht to get the mq
Returns
the GNUNET_MQ_Handle

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

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

Referenced by check_peer_online(), and send_message().

1047 {
1048  if (NULL == peer_ctx->mq)
1049  {
1050  peer_ctx->mq = GNUNET_CADET_get_mq (get_channel (peer_ctx));
1051  }
1052  return peer_ctx->mq;
1053 }
struct GNUNET_CADET_Channel * get_channel(struct PeerContext *peer_ctx)
Get the channel of a peer.
struct GNUNET_MQ_Handle * mq
Message queue open to client.
struct GNUNET_MQ_Handle * GNUNET_CADET_get_mq(const struct GNUNET_CADET_Channel *channel)
Obtain the message queue for a connected peer.
Definition: cadet_api.c:1082
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_ctxContext of the peer for which to insert the envelope
evenvelope to the message
typetype of the message to be sent
Returns
pointer to pending message

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

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

1068 {
1069  struct PendingMessage *pending_msg;
1070 
1071  pending_msg = GNUNET_new (struct PendingMessage);
1072  pending_msg->ev = ev;
1073  pending_msg->peer_ctx = peer_ctx;
1074  pending_msg->type = type;
1076  peer_ctx->pending_messages_tail,
1077  pending_msg);
1078  return pending_msg;
1079 }
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
struct PeerContext * peer_ctx
The corresponding context.
struct GNUNET_MQ_Envelope * ev
The envelope to the corresponding message.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
const char * type
The message type.
List containing all messages that are yet to be send.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
struct PendingMessage * pending_messages_head
DLL with all messages that are yet to be sent.
struct PendingMessage * pending_messages_tail
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
clsPeerContext of peer with pending online check

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

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

1117 {
1118  struct PeerContext *peer_ctx = cls;
1119 
1120  if (NULL != peer_ctx->online_check_pending)
1121  {
1123  "Online check for peer %s was successfull\n",
1124  GNUNET_i2s (&peer_ctx->peer_id));
1126  peer_ctx->online_check_pending = NULL;
1127  set_peer_online (peer_ctx);
1128  (void) add_valid_peer (&peer_ctx->peer_id, peer_ctx->sub->valid_peers);
1129  }
1130 }
struct GNUNET_PeerIdentity peer_id
Identity of the peer.
static void remove_pending_message(struct PendingMessage *pending_msg, int cancel)
Remove a pending message from the respective DLL.
struct PendingMessage * online_check_pending
Handle to the callback given to cadet_ntfy_tmt_rdy()
#define LOG(kind,...)
struct GNUNET_CONTAINER_MultiPeerMap * valid_peers
Hashmap of valid peers.
Struct used to keep track of other peer&#39;s status.
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 set_peer_online(struct PeerContext *peer_ctx)
Set the peer flag to living and call the pending operations on this peer.
struct Sub * sub
The Sub this context belongs to.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
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_ctxthe context of the peer

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

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(), PeerContext::online_check_pending, PeerContext::peer_id, and PeerContext::sub.

Referenced by issue_peer_online_check().

1140 {
1142  "Get informed about peer %s getting online\n",
1143  GNUNET_i2s (&peer_ctx->peer_id));
1144 
1145  struct GNUNET_MQ_Handle *mq;
1146  struct GNUNET_MQ_Envelope *ev;
1147 
1149  peer_ctx->online_check_pending =
1150  insert_pending_message (peer_ctx, ev, "Check online");
1151  mq = get_mq (peer_ctx);
1154  peer_ctx);
1155  GNUNET_MQ_send (mq, ev);
1156  if (peer_ctx->sub == msub)
1157  {
1159  "# pending online checks",
1160  1,
1161  GNUNET_NO);
1162  }
1163 }
struct GNUNET_PeerIdentity peer_id
Identity of the peer.
#define GNUNET_MESSAGE_TYPE_RPS_PP_CHECK_LIVE
RPS check liveliness message to check liveliness of other peer.
static struct Sub * msub
Main Sub.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
static void mq_online_check_successful(void *cls)
This is called in response to the first message we sent as a online check.
struct PendingMessage * online_check_pending
Handle to the callback given to cadet_ntfy_tmt_rdy()
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.
#define LOG(kind,...)
void GNUNET_MQ_notify_sent(struct GNUNET_MQ_Envelope *ev, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
Call a callback once the envelope has been sent, that is, sending it can not be canceled anymore...
Definition: mq.c:787
static struct GNUNET_MQ_Handle * get_mq(struct PeerContext *peer_ctx)
Get the message queue (GNUNET_MQ_Handle) of a specific peer.
Handle to a message queue.
Definition: mq.c:85
#define GNUNET_MQ_msg_header(type)
Allocate a GNUNET_MQ_Envelope, where the message only consists of a header.
Definition: gnunet_mq_lib.h:76
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
struct GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
struct Sub * sub
The Sub this context belongs to.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
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_ctxContext of the peer to check for the operation
peer_opthe operation (PeerOp) on the peer
Returns
GNUNET_YES if this operation is scheduled on that peer GNUNET_NO otherwise

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

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

Referenced by schedule_operation().

1181 {
1182  unsigned int i;
1183 
1184  for (i = 0; i < peer_ctx->num_pending_ops; i++)
1185  if (peer_op == peer_ctx->pending_ops[i].op)
1186  return GNUNET_YES;
1187  return GNUNET_NO;
1188 }
struct PeerPendingOp * pending_ops
Array of pending operations on this peer.
PeerOp op
Callback.
unsigned int num_pending_ops
Number of pending operations.
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
clsContext of the channel

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

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

1198 {
1199  struct GNUNET_CADET_Channel *channel;
1200 
1201  if (NULL != channel_ctx->destruction_task)
1202  {
1204  channel_ctx->destruction_task = NULL;
1205  }
1206  GNUNET_assert (channel_ctx->channel != NULL);
1207  channel = channel_ctx->channel;
1208  channel_ctx->channel = NULL;
1209  GNUNET_CADET_channel_destroy (channel);
1210  remove_channel_ctx (channel_ctx);
1211 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Opaque handle to a channel.
Definition: cadet.h:116
struct GNUNET_SCHEDULER_Task * destruction_task
When channel destruction needs to be delayed (because it is called from within the cadet routine of a...
struct GNUNET_CADET_Channel * channel
The channel itself.
static void remove_channel_ctx(struct ChannelCtx *channel_ctx)
Free memory and NULL pointers.
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:837
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
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 1222 of file gnunet-service-rps.c.

References destroy_channel(), and ChannelCtx::destruction_task.

Referenced by schedule_channel_destruction().

1223 {
1224  struct ChannelCtx *channel_ctx = cls;
1225 
1226  channel_ctx->destruction_task = NULL;
1227  destroy_channel (channel_ctx);
1228 }
struct GNUNET_SCHEDULER_Task * destruction_task
When channel destruction needs to be delayed (because it is called from within the cadet routine of a...
Context for a channel.
static void destroy_channel(struct ChannelCtx *channel_ctx)
Callback for scheduler to destroy a channel.
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_ctxchannel to be destroyed.

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

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

Referenced by destroy_peer().

1243 {
1244  GNUNET_assert (NULL ==
1245  channel_ctx->destruction_task);
1246  GNUNET_assert (NULL !=
1247  channel_ctx->channel);
1248  channel_ctx->destruction_task =
1250  channel_ctx);
1251 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_SCHEDULER_Task * destruction_task
When channel destruction needs to be delayed (because it is called from within the cadet routine of a...
static void destroy_channel_cb(void *cls)
Destroy a cadet channel.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1296
struct GNUNET_CADET_Channel * channel
The channel itself.
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_ctxContext of the peer to be destroyed
Returns
GNUNET_YES if peer was removed GNUNET_NO otherwise

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

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, 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, PeerContext::sub, PendingMessage::type, and UNSET_PEER_FLAG.

Referenced by peermap_clear_iterator(), and remove_peer().

1269 {
1270  GNUNET_assert (NULL != peer_ctx);
1271  GNUNET_assert (NULL != peer_ctx->sub->peer_map);
1272  if (GNUNET_NO ==
1274  &peer_ctx->peer_id))
1275  {
1276  return GNUNET_NO;
1277  }
1278  SET_PEER_FLAG (peer_ctx, Peers_TO_DESTROY);
1280  "Going to remove peer %s\n",
1281  GNUNET_i2s (&peer_ctx->peer_id));
1282  UNSET_PEER_FLAG (peer_ctx, Peers_ONLINE);
1283 
1284  /* Clear list of pending operations */
1285  // TODO this probably leaks memory
1286  // ('only' the cls to the function. Not sure what to do with it)
1287  GNUNET_array_grow (peer_ctx->pending_ops,
1288  peer_ctx->num_pending_ops,
1289  0);
1290  /* Remove all pending messages */
1291  while (NULL != peer_ctx->pending_messages_head)
1292  {
1294  "Removing unsent %s\n",
1295  peer_ctx->pending_messages_head->type);
1296  /* Cancle pending message, too */
1297  if ((NULL != peer_ctx->online_check_pending) &&
1298  (0 == memcmp (peer_ctx->pending_messages_head,
1299  peer_ctx->online_check_pending,
1300  sizeof(struct PendingMessage))))
1301  {
1302  peer_ctx->online_check_pending = NULL;
1303  if (peer_ctx->sub == msub)
1304  {
1306  "# pending online checks",
1307  -1,
1308  GNUNET_NO);
1309  }
1310  }
1312  GNUNET_YES);
1313  }
1314 
1315  /* If we are still waiting for notification whether this peer is online
1316  * cancel the according task */
1317  if (NULL != peer_ctx->online_check_pending)
1318  {
1320  "Removing pending online check for peer %s\n",
1321  GNUNET_i2s (&peer_ctx->peer_id));
1322  // TODO wait until cadet sets mq->cancel_impl
1323  // GNUNET_MQ_send_cancel (peer_ctx->online_check_pending->ev);
1325  GNUNET_YES);
1326  peer_ctx->online_check_pending = NULL;
1327  }
1328 
1329  if (NULL != peer_ctx->send_channel_ctx)
1330  {
1331  /* This is possibly called from within channel destruction */
1332  peer_ctx->send_channel_ctx->peer_ctx = NULL;
1334  peer_ctx->send_channel_ctx = NULL;
1335  peer_ctx->mq = NULL;
1336  }
1337  if (NULL != peer_ctx->recv_channel_ctx)
1338  {
1339  /* This is possibly called from within channel destruction */
1340  peer_ctx->recv_channel_ctx->peer_ctx = NULL;
1342  peer_ctx->recv_channel_ctx = NULL;
1343  }
1344 
1345  if (GNUNET_YES !=
1347  &peer_ctx->peer_id))
1348  {
1350  "removing peer from peer_ctx->sub->peer_map failed\n");
1351  }
1352  if (peer_ctx->sub == msub)
1353  {
1355  "# known peers",
1357  peer_ctx->sub->peer_map),
1358  GNUNET_NO);
1359  }
1360  GNUNET_free (peer_ctx);
1361  return GNUNET_YES;
1362 }
struct PeerPendingOp * pending_ops
Array of pending operations on this peer.
struct GNUNET_PeerIdentity peer_id
Identity of the peer.
int GNUNET_CONTAINER_multipeermap_remove_all(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Remove all entries for the given key from the map.
static void schedule_channel_destruction(struct ChannelCtx *channel_ctx)
Schedule the destruction of a channel for immediately afterwards.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct PeerContext * peer_ctx
The peer context associated with the channel.
#define UNSET_PEER_FLAG(peer_ctx, mask)
Unset flag of given peer context.
static struct Sub * msub
Main Sub.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
static void remove_pending_message(struct PendingMessage *pending_msg, int cancel)
Remove a pending message from the respective DLL.
struct PendingMessage * online_check_pending
Handle to the callback given to cadet_ntfy_tmt_rdy()
#define LOG(kind,...)
#define GNUNET_array_grow(arr, size, tsize)
Grow a well-typed (!) array.
const char * type
The message type.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
#define SET_PEER_FLAG(peer_ctx, mask)
Set a peer flag of given peer context.
We set this bit when we are going to destroy the channel to this peer.
Definition: rps.h:266
unsigned int num_pending_ops
Number of pending operations.
struct GNUNET_CONTAINER_MultiPeerMap * peer_map
Set of all peers to keep track of them.
#define GNUNET_log(kind,...)
struct GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
List containing all messages that are yet to be send.
struct GNUNET_MQ_Handle * mq
Message queue open to client.
struct ChannelCtx * send_channel_ctx
Channel open to client.
struct ChannelCtx * recv_channel_ctx
Channel open from client.
struct Sub * sub
The Sub this context belongs to.
struct PendingMessage * pending_messages_head
DLL with all messages that are yet to be sent.
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.
int GNUNET_CONTAINER_multipeermap_contains(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Check if the map contains any value under the given key (including values that are NULL)...
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
We set this bit when we know the peer is online.
Definition: rps.h:259
#define GNUNET_free(ptr)
Wrapper around free.
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
clsclosure
keycurrent public key
valuevalue in the hash map
Returns
GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

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

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

Referenced by peers_terminate().

1378 {
1379  struct Sub *sub = cls;
1380 
1381  (void) value;
1382 
1383  destroy_peer (get_peer_ctx (sub->peer_map, key));
1384  return GNUNET_YES;
1385 }
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 char * value
Value of the record to add/remove.
static int destroy_peer(struct PeerContext *peer_ctx)
Remove peer.
struct GNUNET_CONTAINER_MultiPeerMap * peer_map
Set of all peers to keep track of them.
One Sub.
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
clstype of the message that was sent

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

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

Referenced by send_message().

1397 {
1398  struct PendingMessage *pending_msg = (struct PendingMessage *) cls;
1399 
1401  "%s was sent.\n",
1402  pending_msg->type);
1403  if (pending_msg->peer_ctx->sub == msub)
1404  {
1405  if (0 == strncmp ("PULL REPLY", pending_msg->type, 10))
1406  GNUNET_STATISTICS_update (stats, "# pull replys sent", 1, GNUNET_NO);
1407  if (0 == strncmp ("PULL REQUEST", pending_msg->type, 12))
1408  GNUNET_STATISTICS_update (stats, "# pull requests sent", 1, GNUNET_NO);
1409  if (0 == strncmp ("PUSH", pending_msg->type, 4))
1410  GNUNET_STATISTICS_update (stats, "# pushes sent", 1, GNUNET_NO);
1411  if ((0 == strncmp ("PULL REQUEST", pending_msg->type, 12)) &&
1412  (NULL != map_single_hop) &&
1414  &pending_msg->
1415  peer_ctx->peer_id)) )
1417  "# pull requests sent (multi-hop peer)",
1418  1,
1419  GNUNET_NO);
1420  }
1421  /* Do not cancle message */
1422  remove_pending_message (pending_msg, GNUNET_NO);
1423 }
struct GNUNET_PeerIdentity peer_id
Identity of the peer.
struct PeerContext * peer_ctx
The corresponding context.
static struct Sub * msub
Main Sub.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
static void remove_pending_message(struct PendingMessage *pending_msg, int cancel)
Remove a pending message from the respective DLL.
#define LOG(kind,...)
const char * type
The message type.
struct GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
List containing all messages that are yet to be send.
struct GNUNET_CONTAINER_MultiPeerMap * map_single_hop
PeerMap to keep track of connected peers.
struct Sub * sub
The Sub this context belongs to.
int GNUNET_CONTAINER_multipeermap_contains(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Check if the map contains any value under the given key (including values that are NULL)...
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
clsthe file handle to write to.
peercurrent peer
valueunused
Returns
GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

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

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

Referenced by store_valid_peers().

1444 {
1445  const struct GNUNET_DISK_FileHandle *fh = cls;
1446  char peer_string[128];
1447  int size;
1448  ssize_t ret;
1449 
1450  (void) value;
1451 
1452  if (NULL == peer)
1453  {
1454  return GNUNET_YES;
1455  }
1456  size = GNUNET_snprintf (peer_string,
1457  sizeof(peer_string),
1458  "%s\n",
1459  GNUNET_i2s_full (peer));
1460  GNUNET_assert (53 == size);
1461  ret = GNUNET_DISK_file_write (fh,
1462  peer_string,
1463  size);
1464  GNUNET_assert (size == ret);
1465  return GNUNET_YES;
1466 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
const char * GNUNET_i2s_full(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
int GNUNET_snprintf(char *buf, size_t size, const char *format,...) __attribute__((format(printf
Like snprintf, just aborts if the buffer is of insufficient size.
static char * value
Value of the record to add/remove.
ssize_t GNUNET_DISK_file_write(const struct GNUNET_DISK_FileHandle *h, const void *buffer, size_t n)
Write a buffer to a file.
Definition: disk.c:820
static int fh
Handle to the unique file.
static unsigned int size
Size of the "table".
Definition: peer.c:67
Handle used to access files (and pipes).
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
subSub for which to store the valid peers

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

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

1476 {
1477  struct GNUNET_DISK_FileHandle *fh;
1478  uint32_t number_written_peers;
1479  int ret;
1480 
1481  if (0 == strncmp ("DISABLE", sub->filename_valid_peers, 7))
1482  {
1483  return;
1484  }
1485 
1487  if (GNUNET_SYSERR == ret)
1488  {
1490  "Not able to create directory for file `%s'\n",
1491  sub->filename_valid_peers);
1492  GNUNET_break (0);
1493  }
1494  else if (GNUNET_NO == ret)
1495  {
1497  "Directory for file `%s' exists but is not writable for us\n",
1498  sub->filename_valid_peers);
1499  GNUNET_break (0);
1500  }
1506  if (NULL == fh)
1507  {
1509  "Not able to write valid peers to file `%s'\n",
1510  sub->filename_valid_peers);
1511  return;
1512  }
1514  "Writing %u valid peers to disk\n",
1516  number_written_peers =
1519  fh);
1521  GNUNET_assert (number_written_peers ==
1523 }
Create file if it doesn&#39;t exist.
int GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1280
static int store_peer_presistently_iterator(void *cls, const struct GNUNET_PeerIdentity *peer, void *value)
Iterator function for store_valid_peers.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
int GNUNET_DISK_directory_create_for_file(const char *filename)
Create the directory structure for storing a file.
Definition: disk.c:684
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define LOG(kind,...)
struct GNUNET_CONTAINER_MultiPeerMap * valid_peers
Hashmap of valid peers.
static int fh
Handle to the unique file.
Open the file for writing.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.
struct GNUNET_DISK_FileHandle * GNUNET_DISK_file_open(const char *fn, enum GNUNET_DISK_OpenFlags flags, enum GNUNET_DISK_AccessPermissions perm)
Open a file.
Definition: disk.c:1203
Handle used to access files (and pipes).
char * filename_valid_peers
Filename of the file that stores the valid peers persistently.
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_reprThe string representation of the peer id
Returns
The peer id

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

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

Referenced by restore_valid_peers().

1537 {
1538  struct GNUNET_PeerIdentity *peer;
1539  size_t len;
1540  int ret;
1541 
1542  peer = GNUNET_new (struct GNUNET_PeerIdentity);
1543  len = strlen (string_repr);
1544  if (52 > len)
1545  {
1547  "Not able to convert string representation of PeerID to PeerID\n"
1548  "Sting representation: %s (len %lu) - too short\n",
1549  string_repr,
1550  len);
1551  GNUNET_break (0);
1552  }
1553  else if (52 < len)
1554  {
1555  len = 52;
1556  }
1557  ret = GNUNET_CRYPTO_eddsa_public_key_from_string (string_repr,
1558  len,
1559  &peer->public_key);
1560  if (GNUNET_OK != ret)
1561  {
1563  "Not able to convert string representation of PeerID to PeerID\n"
1564  "Sting representation: %s\n",
1565  string_repr);
1566  GNUNET_break (0);
1567  }
1568  return peer;
1569 }
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define LOG(kind,...)
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
int GNUNET_CRYPTO_eddsa_public_key_from_string(const char *enc, size_t enclen, struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Convert a string representing a public key to a public key.
Definition: crypto_ecc.c:399
The identity of the host (wraps the signing key of the peer).
struct GNUNET_CRYPTO_EddsaPublicKey public_key
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
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
subSub for which to restore the valid peers

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

References add_valid_peer(), buf, fh, 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, peer, s2i_full(), and Sub::valid_peers.

Referenced by run().

1579 {
1580  off_t file_size;
1581  uint32_t num_peers;
1582  struct GNUNET_DISK_FileHandle *fh;
1583  char *buf;
1584  ssize_t size_read;
1585  char *iter_buf;
1586  char *str_repr;
1587  const struct GNUNET_PeerIdentity *peer;
1588 
1589  if (0 == strncmp ("DISABLE", sub->filename_valid_peers, 7))
1590  {
1591  return;
1592  }
1593 
1595  {
1596  return;
1597  }
1601  GNUNET_assert (NULL != fh);
1603  num_peers = file_size / 53;
1604  buf = GNUNET_malloc (file_size);
1605  size_read = GNUNET_DISK_file_read (fh, buf, file_size);
1606  GNUNET_assert (size_read == file_size);
1608  "Restoring %" PRIu32 " peers from file `%s'\n",
1609  num_peers,
1610  sub->filename_valid_peers);
1611  for (iter_buf = buf; iter_buf < buf + file_size - 1; iter_buf += 53)
1612  {
1613  str_repr = GNUNET_strndup (iter_buf, 53);
1614  peer = s2i_full (str_repr);
1615  GNUNET_free (str_repr);
1616  add_valid_peer (peer, sub->valid_peers);
1618  "Restored valid peer %s from disk\n",
1619  GNUNET_i2s_full (peer));
1620  }
1621  iter_buf = NULL;
1622  GNUNET_free (buf);
1624  "num_peers: %" PRIu32 ", _size (sub->valid_peers): %u\n",
1625  num_peers,
1627  if (num_peers != GNUNET_CONTAINER_multipeermap_size (sub->valid_peers))
1628  {
1630  "Number of restored peers does not match file size. Have probably duplicates.\n");
1631  }
1634  "Restored %u valid peers from disk\n",
1636 }
int GNUNET_DISK_file_test(const char *fil)
Check that fil corresponds to a filename (of a file that exists and that is not a directory)...
Definition: disk.c:544
Open the file for reading.
int GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1280
ssize_t GNUNET_DISK_file_read(const struct GNUNET_DISK_FileHandle *h, void *result, size_t len)
Read the contents of a binary file into a buffer.
Definition: disk.c:732
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Nobody is allowed to do anything to the file.
const char * GNUNET_i2s_full(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define LOG(kind,...)
static const struct GNUNET_PeerIdentity * s2i_full(const char *string_repr)
Convert string representation of peer id to peer id.
struct GNUNET_CONTAINER_MultiPeerMap * valid_peers
Hashmap of valid peers.
static char buf[2048]
static int fh
Handle to the unique file.
static int add_valid_peer(const struct GNUNET_PeerIdentity *peer, struct GNUNET_CONTAINER_MultiPeerMap *valid_peers)
Add a given peer to valid peers.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
static unsigned int num_peers
#define GNUNET_strndup(a, length)
Wrapper around GNUNET_xstrndup_.
The identity of the host (wraps the signing key of the peer).
int GNUNET_DISK_file_handle_size(struct GNUNET_DISK_FileHandle *fh, off_t *size)
Get the size of an open file.
Definition: disk.c:206
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.
struct GNUNET_DISK_FileHandle * GNUNET_DISK_file_open(const char *fn, enum GNUNET_DISK_OpenFlags flags, enum GNUNET_DISK_AccessPermissions perm)
Open a file.
Definition: disk.c:1203
Handle used to access files (and pipes).
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
char * filename_valid_peers
Filename of the file that stores the valid peers persistently.
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
subSub for which the storage is deleted

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

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

1646 {
1647  if (GNUNET_SYSERR ==
1650  sub))
1651  {
1653  "Iteration destroying peers was aborted.\n");
1654  }
1656  sub->peer_map = NULL;
1657  store_valid_peers (sub);
1659  sub->filename_valid_peers = NULL;
1661  sub->valid_peers = NULL;
1662 }
static void store_valid_peers(const struct Sub *sub)
Store the peers currently in #valid_peers to disk.
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
#define LOG(kind,...)
struct GNUNET_CONTAINER_MultiPeerMap * valid_peers
Hashmap of valid peers.
struct GNUNET_CONTAINER_MultiPeerMap * peer_map
Set of all peers to keep track of them.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
static int peermap_clear_iterator(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Iterator over hash map entries.
#define GNUNET_free(ptr)
Wrapper around free.
char * filename_valid_peers
Filename of the file that stores the valid peers persistently.
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
clsClosure that contains iterator function and closure
peercurrent peer id
valuevalue in the hash map - unused
Returns
GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

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

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

Referenced by get_valid_peers().

1679 {
1680  struct PeersIteratorCls *it_cls = cls;
1681 
1682  (void) value;
1683 
1684  return it_cls->iterator (it_cls->cls, peer);
1685 }
void * cls
Closure to iterator.
Closure to valid_peer_iterator.
static char * value
Value of the record to add/remove.
PeersIterator iterator
Iterator function.
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_peersPeer map containing the valid peers in question
iteratorfunction to call on each peer id
it_clsextra argument to iterator
Returns
the number of key value pairs processed, GNUNET_SYSERR if it aborted iteration

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

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

Referenced by run().

1701 {
1702  struct PeersIteratorCls *cls;
1703  int ret;
1704 
1705  cls = GNUNET_new (struct PeersIteratorCls);
1706  cls->iterator = iterator;
1707  cls->cls = it_cls;
1708  ret = GNUNET_CONTAINER_multipeermap_iterate (valid_peers,
1710  cls);
1711  GNUNET_free (cls);
1712  return ret;
1713 }
static int iterator(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Iterator over hash map entries.
void * cls
Closure to iterator.
Closure to valid_peer_iterator.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
#define GNUNET_new(type)
Allocate a struct or union of the given type.
PeersIterator iterator
Iterator function.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
static int valid_peer_iterator(void *cls, const struct GNUNET_PeerIdentity *peer, void *value)
Iterator over #valid_peers hash map entries.
#define GNUNET_free(ptr)
Wrapper around free.
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
subSub with the peer map that the peer will be added to
peerthe new GNUNET_PeerIdentity
Returns
GNUNET_YES if peer was inserted GNUNET_NO otherwise

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

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

1731 {
1732  if (GNUNET_YES == check_peer_known (sub->peer_map, peer))
1733  {
1734  return GNUNET_NO; /* We already know this peer - nothing to do */
1735  }
1736  (void) create_peer_ctx (sub, peer);
1737  return GNUNET_YES;
1738 }
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 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.
struct GNUNET_CONTAINER_MultiPeerMap * peer_map
Set of all peers to keep track of them.
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_mapPeer map that is expected to contain the peer
peerthe peer to check the flag of
flagsthe 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 1753 of file gnunet-service-rps.c.

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

1756 {
1757  struct PeerContext *peer_ctx;
1758 
1759  if (GNUNET_NO == check_peer_known (peer_map, peer))
1760  {
1761  return GNUNET_SYSERR;
1762  }
1763  peer_ctx = get_peer_ctx (peer_map, peer);
1764  return check_peer_flag_set (peer_ctx, flags);
1765 }
#define check_peer_flag_set(peer_ctx, mask)
Get peer flag of given peer context.
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.
Struct used to keep track of other peer&#39;s status.
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
subSub which would contain the peer
peerthe peer whose online is to be checked
Returns
GNUNET_YES if the check was issued GNUNET_NO otherwise

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

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

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

1781 {
1782  struct PeerContext *peer_ctx;
1783 
1784  (void) insert_peer (sub, peer); // TODO even needed?
1785  peer_ctx = get_peer_ctx (sub->peer_map, peer);
1786  if ((GNUNET_NO == check_peer_flag (sub->peer_map, peer, Peers_ONLINE)) &&
1787  (NULL == peer_ctx->online_check_pending))
1788  {
1789  check_peer_online (peer_ctx);
1790  return GNUNET_YES;
1791  }
1792  return GNUNET_NO;
1793 }
static void check_peer_online(struct PeerContext *peer_ctx)
Issue a check whether peer is online.
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.
struct PendingMessage * online_check_pending
Handle to the callback given to cadet_ntfy_tmt_rdy()
Struct used to keep track of other peer&#39;s status.
struct GNUNET_CONTAINER_MultiPeerMap * peer_map
Set of all peers to keep track of them.
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.
We set this bit when we know the peer is online.
Definition: rps.h:259
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_ctxContext 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 1810 of file gnunet-service-rps.c.

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

1811 {
1813  peer_ctx->sub->peer_map,
1814  &peer_ctx->peer_id))
1815  {
1816  return GNUNET_SYSERR;
1817  }
1818 
1819  if ((NULL != peer_ctx->recv_channel_ctx) ||
1820  (NULL != peer_ctx->pending_messages_head) ||
1822  {
1823  return GNUNET_NO;
1824  }
1825  return GNUNET_YES;
1826 }
#define check_peer_flag_set(peer_ctx, mask)
Get peer flag of given peer context.
struct GNUNET_PeerIdentity peer_id
Identity of the peer.
If we are waiting for a reply from that peer (sent a pull request).
Definition: rps.h:250
struct GNUNET_CONTAINER_MultiPeerMap * peer_map
Set of all peers to keep track of them.
struct ChannelCtx * recv_channel_ctx
Channel open from client.
struct Sub * sub
The Sub this context belongs to.
struct PendingMessage * pending_messages_head
DLL with all messages that are yet to be sent.
int GNUNET_CONTAINER_multipeermap_contains(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Check if the map contains any value under the given key (including values that are NULL)...
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_peersPeer map that would contain the peer
peerpeer in question
Returns
GNUNET_YES if peer is valid GNUNET_NO if peer is not valid

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

References GNUNET_CONTAINER_multipeermap_contains().

Referenced by handle_peer_pull_reply().

1843 {
1844  return GNUNET_CONTAINER_multipeermap_contains (valid_peers, peer);
1845 }
int GNUNET_CONTAINER_multipeermap_contains(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Check if the map contains any value under the given key (including values that are NULL)...
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_ctxContext of the target peer

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

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

Referenced by insert_in_view().

1857 {
1859  &peer_ctx->peer_id));
1860  (void) get_channel (peer_ctx);
1861 }
struct GNUNET_PeerIdentity peer_id
Identity of the peer.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
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.
struct GNUNET_CADET_Channel * get_channel(struct PeerContext *peer_ctx)
Get the channel of a peer.
struct GNUNET_CONTAINER_MultiPeerMap * peer_map
Set of all peers to keep track of them.
struct Sub * sub
The Sub this context belongs to.
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_ctxContext of the peer in question
Returns
GNUNET_YES if peer has the intention to send GNUNET_NO otherwise

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

References GNUNET_NO, GNUNET_YES, and PeerContext::recv_channel_ctx.

Referenced by clean_peer(), and handle_inbound_channel().

1875 {
1876  if (NULL != peer_ctx->recv_channel_ctx)
1877  {
1878  return GNUNET_YES;
1879  }
1880  return GNUNET_NO;
1881 }
struct ChannelCtx * recv_channel_ctx
Channel open from client.
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
clsThe closure - Sub
channelThe channel the peer wants to establish
initiatorThe peer's peer ID
Returns
initial channel context for the channel (can be NULL – that's not an error)

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

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

1898 {
1899  struct PeerContext *peer_ctx;
1900  struct ChannelCtx *channel_ctx;
1901  struct Sub *sub = cls;
1902 
1904  "New channel was established to us (Peer %s).\n",
1905  GNUNET_i2s (initiator));
1906  GNUNET_assert (NULL != channel); /* according to cadet API */
1907  /* Make sure we 'know' about this peer */
1908  peer_ctx = create_or_get_peer_ctx (sub, initiator);
1909  set_peer_online (peer_ctx);
1910  (void) add_valid_peer (&peer_ctx->peer_id, peer_ctx->sub->valid_peers);
1911  channel_ctx = add_channel_ctx (peer_ctx);
1912  channel_ctx->channel = channel;
1913  /* We only accept one incoming channel per peer */
1915  initiator)))
1916  {
1918  "Already got one receive channel. Destroying old one.\n");
1919  GNUNET_break_op (0);
1920  destroy_channel (peer_ctx->recv_channel_ctx);
1921  peer_ctx->recv_channel_ctx = channel_ctx;
1922  /* return the channel context */
1923  return channel_ctx;
1924  }
1925  peer_ctx->recv_channel_ctx = channel_ctx;
1926  return channel_ctx;
1927 }
struct GNUNET_PeerIdentity peer_id
Identity of the peer.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static struct ChannelCtx * add_channel_ctx(struct PeerContext *peer_ctx)
Allocate memory for a new channel context and insert it into DLL.
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.
#define LOG(kind,...)
Context for a channel.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
struct GNUNET_CONTAINER_MultiPeerMap * valid_peers
Hashmap of valid peers.
struct GNUNET_CADET_Channel * channel
The channel itself.
Struct used to keep track of other peer&#39;s status.
static int add_valid_peer(const struct GNUNET_PeerIdentity *peer, struct GNUNET_CONTAINER_MultiPeerMap *valid_peers)
Add a given peer to valid peers.
struct GNUNET_CONTAINER_MultiPeerMap * peer_map
Set of all peers to keep track of them.
One Sub.
static void set_peer_online(struct PeerContext *peer_ctx)
Set the peer flag to living and call the pending operations on this peer.
static struct PeerContext * create_or_get_peer_ctx(struct Sub *sub, const struct GNUNET_PeerIdentity *peer)
Create or get a PeerContext.
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 destroy_channel(struct ChannelCtx *channel_ctx)
Callback for scheduler to destroy a channel.
struct ChannelCtx * recv_channel_ctx
Channel open from client.
struct Sub * sub
The Sub this context belongs to.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
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_ctxContext of the peer in question
Returns
GNUNET_YES if a sending channel towards that peer exists GNUNET_NO otherwise

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

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

1940 {
1941  if (GNUNET_NO == check_peer_known (peer_ctx->sub->peer_map,
1942  &peer_ctx->peer_id))
1943  { /* If no such peer exists, there is no channel */
1944  return GNUNET_NO;
1945  }
1946  if (NULL == peer_ctx->send_channel_ctx)
1947  {
1948  return GNUNET_NO;
1949  }
1950  return GNUNET_YES;
1951 }
struct GNUNET_PeerIdentity peer_id
Identity of the 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.
struct GNUNET_CONTAINER_MultiPeerMap * peer_map
Set of all peers to keep track of them.
struct ChannelCtx * send_channel_ctx
Channel open to client.
struct Sub * sub
The Sub this context belongs to.
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_ctxContext to the peer
Returns
GNUNET_YES if channel was destroyed GNUNET_NO otherwise

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

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

1964 {
1965  if (GNUNET_NO == check_peer_known (peer_ctx->sub->peer_map,
1966  &peer_ctx->peer_id))
1967  {
1968  return GNUNET_NO;
1969  }
1970  if (NULL != peer_ctx->send_channel_ctx)
1971  {
1972  destroy_channel (peer_ctx->send_channel_ctx);
1973  (void) check_connected (peer_ctx);
1974  return GNUNET_YES;
1975  }
1976  return GNUNET_NO;
1977 }
struct GNUNET_PeerIdentity peer_id
Identity of the 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.
struct GNUNET_CONTAINER_MultiPeerMap * peer_map
Set of all peers to keep track of them.
static int check_connected(struct PeerContext *peer_ctx)
Check whether we have a connection to this peer.
struct ChannelCtx * send_channel_ctx
Channel open to client.
static void destroy_channel(struct ChannelCtx *channel_ctx)
Callback for scheduler to destroy a channel.
struct Sub * sub
The Sub this context belongs to.
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_ctxContext of the peer to which the message is to be sent
evenvelope of the message
typetype of the message

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

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(), and PeerContext::peer_id.

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

1994 {
1995  struct PendingMessage *pending_msg;
1996  struct GNUNET_MQ_Handle *mq;
1997 
1999  "Sending message to %s of type %s\n",
2000  GNUNET_i2s (&peer_ctx->peer_id),
2001  type);
2002  pending_msg = insert_pending_message (peer_ctx, ev, type);
2003  mq = get_mq (peer_ctx);
2006  pending_msg);
2007  GNUNET_MQ_send (mq, ev);
2008 }
struct GNUNET_PeerIdentity peer_id
Identity of the peer.
static void mq_notify_sent_cb(void *cls)
This is called once a message is sent.
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.
void GNUNET_MQ_notify_sent(struct GNUNET_MQ_Envelope *ev, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
Call a callback once the envelope has been sent, that is, sending it can not be canceled anymore...
Definition: mq.c:787
static struct GNUNET_MQ_Handle * get_mq(struct PeerContext *peer_ctx)
Get the message queue (GNUNET_MQ_Handle) of a specific peer.
Handle to a message queue.
Definition: mq.c:85
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
#define GNUNET_log(kind,...)
List containing all messages that are yet to be send.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
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_ctxContext of the peer for which to schedule the operation
peer_opthe operation to schedule
clsClosure to peer_op
Returns
GNUNET_YES if the operation was scheduled GNUNET_NO otherwise

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

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

2027 {
2028  struct PeerPendingOp pending_op;
2029 
2031  &peer_ctx->peer_id));
2032 
2033  // TODO if ONLINE execute immediately
2034 
2035  if (GNUNET_NO == check_operation_scheduled (peer_ctx, peer_op))
2036  {
2037  pending_op.op = peer_op;
2038  pending_op.op_cls = cls;
2039  GNUNET_array_append (peer_ctx->pending_ops,
2040  peer_ctx->num_pending_ops,
2041  pending_op);
2042  return GNUNET_YES;
2043  }
2044  return GNUNET_NO;
2045 }
struct PeerPendingOp * pending_ops
Array of pending operations on this peer.
#define GNUNET_array_append(arr, len, element)
Append an element to an array (growing the array by one).
struct GNUNET_PeerIdentity peer_id
Identity of the peer.
static int check_operation_scheduled(const struct PeerContext *peer_ctx, const PeerOp peer_op)
Check whether function of type PeerOp was already scheduled.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
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.
unsigned int num_pending_ops
Number of pending operations.
struct GNUNET_CONTAINER_MultiPeerMap * peer_map
Set of all peers to keep track of them.
struct Sub * sub
The Sub this context belongs to.
Pending operation on peer consisting of callback and closure.
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 2144 of file gnunet-service-rps.c.

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

Referenced by handle_client_seed().

2146 {
2147  unsigned int i;
2148 
2150  "Printing peer list of length %u at %p:\n",
2151  len,
2152  list);
2153  for (i = 0; i < len; i++)
2154  {
2156  "%u. peer: %s\n",
2157  i, GNUNET_i2s (&list[i]));
2158  }
2159 }
#define LOG(kind,...)
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
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 2166 of file gnunet-service-rps.c.

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

Referenced by do_round().

2169 {
2170  unsigned int i;
2171  struct GNUNET_PeerIdentity *tmp;
2172 
2173  tmp = *peer_list;
2174 
2176  "Removing peer %s from list at %p\n",
2177  GNUNET_i2s (peer),
2178  tmp);
2179 
2180  for (i = 0; i < *list_size; i++)
2181  {
2182  if (0 == GNUNET_memcmp (&tmp[i], peer))
2183  {
2184  if (i < *list_size - 1)
2185  { /* Not at the last entry -- shift peers left */
2186  memmove (&tmp[i], &tmp[i + 1],
2187  ((*list_size) - i - 1) * sizeof(struct GNUNET_PeerIdentity));
2188  }
2189  /* Remove last entry (should be now useless PeerID) */
2190  GNUNET_array_grow (tmp, *list_size, (*list_size) - 1);
2191  }
2192  }
2193  *peer_list = tmp;
2194 }
#define LOG(kind,...)
#define GNUNET_array_grow(arr, size, tsize)
Grow a well-typed (!) array.
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
The identity of the host (wraps the signing key of the peer).
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
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
clsClosure - Sub with view to insert peer into
peerthe peer to insert

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

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

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

2594 {
2595  struct Sub *sub = cls;
2596  int inserted;
2597 
2598  inserted = insert_in_view (sub, peer);
2599  if (GNUNET_OK == inserted)
2600  {
2601  clients_notify_stream_peer (sub, 1, peer);
2602  }
2603 }
static int insert_in_view(struct Sub *sub, const struct GNUNET_PeerIdentity *peer)
Insert PeerID in #view.
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
One Sub.
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
subSub in with the view to insert in
peerthe peer to insert
Returns
GNUNET_OK if peer was actually inserted GNUNET_NO if peer was not inserted

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

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(), Sub::peer_map, Peers_ONLINE, ret, schedule_operation(), PeerContext::sub, Sub::view, View_put(), and View_size().

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

2224 {
2225  struct PeerContext *peer_ctx;
2226  int online;
2227  int ret;
2228 
2229  online = check_peer_flag (sub->peer_map, peer, Peers_ONLINE);
2230  peer_ctx = get_peer_ctx (sub->peer_map, peer); // TODO indirection needed?
2231  if ((GNUNET_NO == online) ||
2232  (GNUNET_SYSERR == online)) /* peer is not even known */
2233  {
2234  (void) issue_peer_online_check (sub, peer);
2235  (void) schedule_operation (peer_ctx, insert_in_view_op, sub);
2236  return GNUNET_NO;
2237  }
2238  /* Open channel towards peer to keep connection open */
2239  indicate_sending_intention (peer_ctx);
2240  ret = View_put (sub->view, peer);
2241  if (peer_ctx->sub == msub)
2242  {
2244  "view size",
2245  View_size (peer_ctx->sub->view),
2246  GNUNET_NO);
2247  }
2248  return ret;
2249 }
static int schedule_operation(struct PeerContext *peer_ctx, const PeerOp peer_op, void *cls)
Schedule a operation on given peer.
static void insert_in_view_op(void *cls, const struct GNUNET_PeerIdentity *peer)
Insert PeerID in #view.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static struct Sub * msub
Main Sub.
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 void indicate_sending_intention(struct PeerContext *peer_ctx)
Indicate that we want to send to the other peer.
int View_put(struct View *view, const struct GNUNET_PeerIdentity *peer)
Insert peer into the view.
Struct used to keep track of other peer&#39;s status.
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.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
struct GNUNET_CONTAINER_MultiPeerMap * peer_map
Set of all peers to keep track of them.
struct GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
unsigned int View_size(const struct View *view)
Get the size of the view.
struct Sub * sub
The Sub this context belongs to.
struct View * view
The view.
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.
We set this bit when we know the peer is online.
Definition: rps.h:259
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_ctxthe context of the client
view_arraythe peerids of the view as array (can be empty)
view_sizethe size of the view array (can be 0)

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

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

2263 {
2264  struct GNUNET_MQ_Envelope *ev;
2265  struct GNUNET_RPS_CS_DEBUG_ViewReply *out_msg;
2266  struct Sub *sub;
2267 
2268  if (NULL == view_array)
2269  {
2270  if (NULL == cli_ctx->sub)
2271  sub = msub;
2272  else
2273  sub = cli_ctx->sub;
2274  view_size = View_size (sub->view);
2275  view_array = View_get_as_array (sub->view);
2276  }
2277 
2278  ev = GNUNET_MQ_msg_extra (out_msg,
2279  view_size * sizeof(struct GNUNET_PeerIdentity),
2281  out_msg->num_peers = htonl (view_size);
2282 
2283  GNUNET_memcpy (&out_msg[1],
2284  view_array,
2285  view_size * sizeof(struct GNUNET_PeerIdentity));
2286  GNUNET_MQ_send (cli_ctx->mq, ev);
2287 }
Message from service to client containing current update of view.
Definition: rps.h:185
struct Sub * sub
The Sub this context belongs to.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_REPLY
Send update of the view.
static struct Sub * msub
Main Sub.
struct GNUNET_MQ_Handle * mq
The message queue to communicate with the client.
const struct GNUNET_PeerIdentity * View_get_as_array(const struct View *view)
Get the view as an array.
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct...
Definition: gnunet_mq_lib.h:52
One Sub.
The identity of the host (wraps the signing key of the peer).
unsigned int View_size(const struct View *view)
Get the size of the view.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
struct View * view
The view.
uint64_t num_peers
Number of peers in the view.
Definition: rps.h:200
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_ctxthe context of the client
view_arraythe peerids of the view as array (can be empty)
view_sizethe size of the view array (can be 0)

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

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

Referenced by clients_notify_stream_peer().

2303 {
2304  struct GNUNET_MQ_Envelope *ev;
2305  struct GNUNET_RPS_CS_DEBUG_StreamReply *out_msg;
2306 
2307  GNUNET_assert (NULL != peers);
2308 
2309  ev = GNUNET_MQ_msg_extra (out_msg,
2310  num_peers * sizeof(struct GNUNET_PeerIdentity),
2312  out_msg->num_peers = htonl (num_peers);
2313 
2314  GNUNET_memcpy (&out_msg[1],
2315  peers,
2316  num_peers * sizeof(struct GNUNET_PeerIdentity));
2317  GNUNET_MQ_send (cli_ctx->mq, ev);
2318 }
#define GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_STREAM_REPLY
Send peer of biased stream.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
struct GNUNET_MQ_Handle * mq
The message queue to communicate with the client.
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct...
Definition: gnunet_mq_lib.h:52
uint64_t num_peers
Number of peers.
Definition: rps.h:229
Message from service to client containing peer from biased stream.
Definition: rps.h:219
static unsigned int num_peers
The identity of the host (wraps the signing key of the peer).
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
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
subSub for which to notify clients

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

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

2328 {
2329  struct ClientContext *cli_ctx_iter;
2330  uint64_t num_peers;
2331  const struct GNUNET_PeerIdentity *view_array;
2332 
2333  num_peers = View_size (sub->view);
2334  view_array = View_get_as_array (sub->view);
2335  /* check size of view is small enough */
2336  if (GNUNET_MAX_MESSAGE_SIZE < num_peers)
2337  {
2339  "View is too big to send\n");
2340  return;
2341  }
2342 
2343  for (cli_ctx_iter = cli_ctx_head;
2344  NULL != cli_ctx_iter;
2345  cli_ctx_iter = cli_ctx_iter->next)
2346  {
2347  if (1 < cli_ctx_iter->view_updates_left)
2348  {
2349  /* Client wants to receive limited amount of updates */
2350  cli_ctx_iter->view_updates_left -= 1;
2351  }
2352  else if (1 == cli_ctx_iter->view_updates_left)
2353  {
2354  /* Last update of view for client */
2355  cli_ctx_iter->view_updates_left = -1;
2356  }
2357  else if (0 > cli_ctx_iter->view_updates_left)
2358  {
2359  /* Client is not interested in updates */
2360  continue;
2361  }
2362  /* else _updates_left == 0 - infinite amount of updates */
2363 
2364  /* send view */
2365  send_view (cli_ctx_iter, view_array, num_peers);
2366  }
2367 }
Struct used to store the context of a connected client.
struct ClientContext * next
DLL.
static void send_view(const struct ClientContext *cli_ctx, const struct GNUNET_PeerIdentity *view_array, uint64_t view_size)
Send view to client.
int64_t view_updates_left
How many updates this client expects to receive.
const struct GNUNET_PeerIdentity * View_get_as_array(const struct View *view)
Get the view as an array.
static unsigned int num_peers
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message...
The identity of the host (wraps the signing key of the peer).
#define GNUNET_log(kind,...)
unsigned int View_size(const struct View *view)
Get the size of the view.
struct ClientContext * cli_ctx_head
DLL with all clients currently connected to us.
struct View * view
The view.
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_peersNumber of peers to send
peersthe array of peers to send

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

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

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

2381 {
2382  struct ClientContext *cli_ctx_iter;
2383 
2385  "Got peer (%s) from biased stream - update all clients\n",
2386  GNUNET_i2s (peers));
2387 
2388  for (cli_ctx_iter = cli_ctx_head;
2389  NULL != cli_ctx_iter;
2390  cli_ctx_iter = cli_ctx_iter->next)
2391  {
2392  if ((GNUNET_YES == cli_ctx_iter->stream_update) &&
2393  ((sub == cli_ctx_iter->sub) || (sub == msub) ))
2394  {
2395  send_stream_peers (cli_ctx_iter, num_peers, peers);
2396  }
2397  }
2398 }
Struct used to store the context of a connected client.
struct ClientContext * next
DLL.
struct Sub * sub
The Sub this context belongs to.
static struct Sub * msub
Main Sub.
int8_t stream_update
Whether this client wants to receive stream updates.
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.
#define LOG(kind,...)
static unsigned int num_peers
struct ClientContext * cli_ctx_head
DLL with all clients currently connected to us.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
Here is the call graph for this function:
Here is the caller graph for this function: