GNUnet  0.10.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 void do_mal_round (void *cls)
 
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 add_peer_array_to_set (const struct GNUNET_PeerIdentity *peer_array, unsigned int num_peers, struct GNUNET_CONTAINER_MultiPeerMap *peer_map)
 Add all peers in peer_array to peer_map used as set. 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 write_histogram_to_file (const uint32_t hist_array[], const char *file_name)
 Write all numbers in the given array into the given file. More...
 
static void destroy_sub (struct Sub *sub)
 Destroy Sub. 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 283 of file gnunet-service-rps.c.

Referenced by do_round(), and write_histogram_to_file().

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

Referenced by write_histogram_to_file().

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

4225 {
4226  unsigned int i;
4227  const struct GNUNET_PeerIdentity *view_array;
4228  unsigned int *permut;
4229  unsigned int a_peers; /* Number of peers we send pushes to */
4230  unsigned int b_peers; /* Number of peers we send pull requests to */
4231  uint32_t first_border;
4232  uint32_t second_border;
4233  struct GNUNET_PeerIdentity peer;
4234  struct GNUNET_PeerIdentity *update_peer;
4235  struct Sub *sub = cls;
4236 
4237  sub->num_rounds++;
4239  "Going to execute next round.\n");
4240  if (sub == msub)
4241  {
4242  GNUNET_STATISTICS_update(stats, "# rounds", 1, GNUNET_NO);
4243  }
4244  sub->do_round_task = NULL;
4245 #ifdef TO_FILE_FULL
4246  to_file(sub->file_name_view_log,
4247  "___ new round ___");
4248 #endif /* TO_FILE_FULL */
4249  view_array = View_get_as_array(sub->view);
4250  for (i = 0; i < View_size(sub->view); i++)
4251  {
4253  "\t%s\n", GNUNET_i2s(&view_array[i]));
4254 #ifdef TO_FILE_FULL
4255  to_file(sub->file_name_view_log,
4256  "=%s\t(do round)",
4257  GNUNET_i2s_full(&view_array[i]));
4258 #endif /* TO_FILE_FULL */
4259  }
4260 
4261 
4262  /* Send pushes and pull requests */
4263  if (0 < View_size(sub->view))
4264  {
4266  View_size(sub->view));
4267 
4268  /* Send PUSHes */
4269  a_peers = ceil(alpha * View_size(sub->view));
4270 
4272  "Going to send pushes to %u (ceil (%f * %u)) peers.\n",
4273  a_peers, alpha, View_size(sub->view));
4274  for (i = 0; i < a_peers; i++)
4275  {
4276  peer = view_array[permut[i]];
4277  // FIXME if this fails schedule/loop this for later
4279  }
4280 
4281  /* Send PULL requests */
4282  b_peers = ceil(beta * View_size(sub->view));
4283  first_border = a_peers;
4284  second_border = a_peers + b_peers;
4285  if (second_border > View_size(sub->view))
4286  {
4287  first_border = View_size(sub->view) - b_peers;
4288  second_border = View_size(sub->view);
4289  }
4291  "Going to send pulls to %u (ceil (%f * %u)) peers.\n",
4292  b_peers, beta, View_size(sub->view));
4293  for (i = first_border; i < second_border; i++)
4294  {
4295  peer = view_array[permut[i]];
4296  if (GNUNET_NO == check_peer_flag(sub->peer_map,
4297  &peer,
4299  { // FIXME if this fails schedule/loop this for later
4301  }
4302  }
4303 
4304  GNUNET_free(permut);
4305  permut = NULL;
4306  }
4307 
4308 
4309  /* Update view */
4310  /* TODO see how many peers are in push-/pull- list! */
4311 
4312  if ((CustomPeerMap_size(sub->push_map) <= alpha * sub->view_size_est_need) &&
4313  (0 < CustomPeerMap_size(sub->push_map)) &&
4314  (0 < CustomPeerMap_size(sub->pull_map)))
4315  { /* If conditions for update are fulfilled, update */
4316  LOG(GNUNET_ERROR_TYPE_DEBUG, "Update of the view.\n");
4317 
4318  uint32_t final_size;
4319  uint32_t peers_to_clean_size;
4320  struct GNUNET_PeerIdentity *peers_to_clean;
4321 
4322  peers_to_clean = NULL;
4323  peers_to_clean_size = 0;
4324  GNUNET_array_grow(peers_to_clean,
4325  peers_to_clean_size,
4326  View_size(sub->view));
4327  GNUNET_memcpy(peers_to_clean,
4328  view_array,
4329  View_size(sub->view) * sizeof(struct GNUNET_PeerIdentity));
4330 
4331  /* Seems like recreating is the easiest way of emptying the peermap */
4332  View_clear(sub->view);
4333 #ifdef TO_FILE_FULL
4334  to_file(sub->file_name_view_log,
4335  "--- emptied ---");
4336 #endif /* TO_FILE_FULL */
4337 
4338  first_border = GNUNET_MIN(ceil(alpha * sub->view_size_est_need),
4340  second_border = first_border +
4341  GNUNET_MIN(floor(beta * sub->view_size_est_need),
4343  final_size = second_border +
4344  ceil((1 - (alpha + beta)) * sub->view_size_est_need);
4346  "first border: %" PRIu32 ", second border: %" PRIu32 ", final size: %" PRIu32 "\n",
4347  first_border,
4348  second_border,
4349  final_size);
4350 
4351  /* Update view with peers received through PUSHes */
4354  for (i = 0; i < first_border; i++)
4355  {
4356  int inserted;
4357  inserted = insert_in_view(sub,
4359  permut[i]));
4360  if (GNUNET_OK == inserted)
4361  {
4363  1,
4364  CustomPeerMap_get_peer_by_index(sub->push_map, permut[i]));
4365  }
4366 #ifdef TO_FILE_FULL
4367  to_file(sub->file_name_view_log,
4368  "+%s\t(push list)",
4369  GNUNET_i2s_full(&view_array[i]));
4370 #endif /* TO_FILE_FULL */
4371  // TODO change the peer_flags accordingly
4372  }
4373  GNUNET_free(permut);
4374  permut = NULL;
4375 
4376  /* Update view with peers received through PULLs */
4379  for (i = first_border; i < second_border; i++)
4380  {
4381  int inserted;
4382  inserted = insert_in_view(sub,
4384  permut[i - first_border]));
4385  if (GNUNET_OK == inserted)
4386  {
4388  1,
4390  permut[i - first_border]));
4391  }
4392 #ifdef TO_FILE_FULL
4393  to_file(sub->file_name_view_log,
4394  "+%s\t(pull list)",
4395  GNUNET_i2s_full(&view_array[i]));
4396 #endif /* TO_FILE_FULL */
4397  // TODO change the peer_flags accordingly
4398  }
4399  GNUNET_free(permut);
4400  permut = NULL;
4401 
4402  /* Update view with peers from history */
4404  final_size - second_border,
4405  hist_update,
4406  sub);
4407  // TODO change the peer_flags accordingly
4408 
4409  for (i = 0; i < View_size(sub->view); i++)
4410  rem_from_list(&peers_to_clean, &peers_to_clean_size, &view_array[i]);
4411 
4412  /* Clean peers that were removed from the view */
4413  for (i = 0; i < peers_to_clean_size; i++)
4414  {
4415 #ifdef TO_FILE_FULL
4416  to_file(sub->file_name_view_log,
4417  "-%s",
4418  GNUNET_i2s_full(&peers_to_clean[i]));
4419 #endif /* TO_FILE_FULL */
4420  clean_peer(sub, &peers_to_clean[i]);
4421  }
4422 
4423  GNUNET_array_grow(peers_to_clean, peers_to_clean_size, 0);
4425  }
4426  else
4427  {
4428  LOG(GNUNET_ERROR_TYPE_DEBUG, "No update of the view.\n");
4429  if (sub == msub)
4430  {
4431  GNUNET_STATISTICS_update(stats, "# rounds blocked", 1, GNUNET_NO);
4432  if (CustomPeerMap_size(sub->push_map) > alpha * sub->view_size_est_need &&
4433  !(0 >= CustomPeerMap_size(sub->pull_map)))
4434  GNUNET_STATISTICS_update(stats, "# rounds blocked - too many pushes", 1, GNUNET_NO);
4435  if (CustomPeerMap_size(sub->push_map) > alpha * sub->view_size_est_need &&
4436  (0 >= CustomPeerMap_size(sub->pull_map)))
4437  GNUNET_STATISTICS_update(stats, "# rounds blocked - too many pushes, no pull replies", 1, GNUNET_NO);
4438  if (0 >= CustomPeerMap_size(sub->push_map) &&
4439  !(0 >= CustomPeerMap_size(sub->pull_map)))
4440  GNUNET_STATISTICS_update(stats, "# rounds blocked - no pushes", 1, GNUNET_NO);
4441  if (0 >= CustomPeerMap_size(sub->push_map) &&
4442  (0 >= CustomPeerMap_size(sub->pull_map)))
4443  GNUNET_STATISTICS_update(stats, "# rounds blocked - no pushes, no pull replies", 1, GNUNET_NO);
4444  if (0 >= CustomPeerMap_size(sub->pull_map) &&
4446  0 >= CustomPeerMap_size(sub->push_map))
4447  GNUNET_STATISTICS_update(stats, "# rounds blocked - no pull replies", 1, GNUNET_NO);
4448  }
4449  }
4450  // TODO independent of that also get some peers from CADET_get_peers()?
4452  {
4453  sub->push_recv[CustomPeerMap_size(sub->push_map)]++;
4454  }
4455  else
4456  {
4458  "Push map size too big for histogram (%u, %u)\n",
4461  }
4462  // FIXME check bounds of histogram
4463  sub->push_delta[(int32_t)(CustomPeerMap_size(sub->push_map) -
4464  (alpha * sub->view_size_est_need)) +
4465  (HISTOGRAM_FILE_SLOTS / 2)]++;
4466  if (sub == msub)
4467  {
4469  "# peers in push map at end of round",
4471  GNUNET_NO);
4473  "# peers in pull map at end of round",
4475  GNUNET_NO);
4477  "# peers in view at end of round",
4478  View_size(sub->view),
4479  GNUNET_NO);
4481  "# expected pushes",
4482  alpha * sub->view_size_est_need,
4483  GNUNET_NO);
4485  "delta expected - received pushes",
4487  GNUNET_NO);
4488  }
4489 
4491  "Received %u pushes and %u pulls last round (alpha (%.2f) * view_size (sub->view%u) = %.2f)\n",
4494  alpha,
4495  View_size(sub->view),
4496  alpha * View_size(sub->view));
4497 
4498  /* Update samplers */
4499  for (i = 0; i < CustomPeerMap_size(sub->push_map); i++)
4500  {
4501  update_peer = CustomPeerMap_get_peer_by_index(sub->push_map, i);
4503  "Updating with peer %s from push list\n",
4504  GNUNET_i2s(update_peer));
4505  insert_in_sampler(sub, update_peer);
4506  clean_peer(sub, update_peer); /* This cleans only if it is not in the view */
4507  }
4508 
4509  for (i = 0; i < CustomPeerMap_size(sub->pull_map); i++)
4510  {
4512  "Updating with peer %s from pull list\n",
4515  /* This cleans only if it is not in the view */
4517  }
4518 
4519 
4520  /* Empty push/pull lists */
4523 
4524  if (sub == msub)
4525  {
4527  "view size",
4528  View_size(sub->view),
4529  GNUNET_NO);
4530  }
4531 
4532  struct GNUNET_TIME_Relative time_next_round;
4533 
4534  time_next_round = compute_rand_delay(sub->round_interval, 2);
4535 
4536  /* Schedule next round */
4537  sub->do_round_task = GNUNET_SCHEDULER_add_delayed(time_next_round,
4538  &do_round, sub);
4539  LOG(GNUNET_ERROR_TYPE_DEBUG, "Finished round\n");
4540 }
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.
#define GNUNET_NO
Definition: gnunet_common.h:78
const char * GNUNET_i2s_full(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
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:1237
If we are waiting for a reply from that peer (sent a pull request).
Definition: rps.h:241
#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:80
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:

◆ do_mal_round()

static void do_mal_round ( void *  cls)
static

Referenced by send_push().

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

608 {
609  struct PeerContext *ctx;
610  int ret;
611 
612  ret = GNUNET_CONTAINER_multipeermap_contains(peer_map, peer);
613  GNUNET_assert(GNUNET_YES == ret);
614  ctx = GNUNET_CONTAINER_multipeermap_get(peer_map, peer);
615  GNUNET_assert(NULL != ctx);
616  return ctx;
617 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static int ret
Final status code.
Definition: gnunet-arm.c:89
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.
#define GNUNET_YES
Definition: gnunet_common.h:77
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 631 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().

633 {
634  if (NULL != peer_map)
635  {
636  return GNUNET_CONTAINER_multipeermap_contains(peer_map, peer);
637  }
638  else
639  {
640  return GNUNET_NO;
641  }
642 }
#define GNUNET_NO
Definition: gnunet_common.h:78
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 654 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().

656 {
657  struct PeerContext *ctx;
658  int ret;
659 
661 
662  ctx = GNUNET_new(struct PeerContext);
663  ctx->peer_id = *peer;
664  ctx->sub = sub;
665  ret = GNUNET_CONTAINER_multipeermap_put(sub->peer_map, peer, ctx,
667  GNUNET_assert(GNUNET_OK == ret);
668  if (sub == msub)
669  {
671  "# known peers",
673  GNUNET_NO);
674  }
675  return ctx;
676 }
struct GNUNET_PeerIdentity peer_id
Identity of the peer.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static struct Sub * msub
Main Sub.
static int ret
Final status code.
Definition: gnunet-arm.c:89
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 688 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().

690 {
691  if (GNUNET_NO == check_peer_known(sub->peer_map, peer))
692  {
693  return create_peer_ctx(sub, peer);
694  }
695  return get_peer_ctx(sub->peer_map, peer);
696 }
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.
#define GNUNET_NO
Definition: gnunet_common.h:78
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 710 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().

711 {
712  /* If we don't know about this peer we don't know whether it's online */
713  if (GNUNET_NO == check_peer_known(peer_ctx->sub->peer_map,
714  &peer_ctx->peer_id))
715  {
716  return GNUNET_NO;
717  }
718  /* Get the context */
719  peer_ctx = get_peer_ctx(peer_ctx->sub->peer_map, &peer_ctx->peer_id);
720  /* If we have no channel to this peer we don't know whether it's online */
721  if ((NULL == peer_ctx->send_channel_ctx) &&
722  (NULL == peer_ctx->recv_channel_ctx))
723  {
724  UNSET_PEER_FLAG(peer_ctx, Peers_ONLINE);
725  return GNUNET_NO;
726  }
727  /* Otherwise (if we have a channel, we know that it's online */
728  SET_PEER_FLAG(peer_ctx, Peers_ONLINE);
729  return GNUNET_YES;
730 }
struct GNUNET_PeerIdentity peer_id
Identity of the peer.
#define UNSET_PEER_FLAG(peer_ctx, mask)
Unset flag of given peer context.
#define GNUNET_NO
Definition: gnunet_common.h:78
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.
#define GNUNET_YES
Definition: gnunet_common.h:77
struct Sub * sub
The Sub this context belongs to.
We set this bit when we know the peer is online.
Definition: rps.h:250
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 767 of file gnunet-service-rps.c.

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

Referenced by get_random_peer_from_peermap().

770 {
771  struct GetRandPeerIteratorCls *iterator_cls = cls;
772 
773  (void)value;
774 
775  if (0 >= iterator_cls->index)
776  {
777  iterator_cls->peer = peer;
778  return GNUNET_NO;
779  }
780  iterator_cls->index--;
781  return GNUNET_YES;
782 }
The closure to get_rand_peer_iterator.
#define GNUNET_NO
Definition: gnunet_common.h:78
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.
#define GNUNET_YES
Definition: gnunet_common.h:77
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 794 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().

795 {
796  struct GetRandPeerIteratorCls *iterator_cls;
797  const struct GNUNET_PeerIdentity *ret;
798 
799  iterator_cls = GNUNET_new(struct GetRandPeerIteratorCls);
802  (void)GNUNET_CONTAINER_multipeermap_iterate(valid_peers,
804  iterator_cls);
805  ret = iterator_cls->peer;
806  GNUNET_free(iterator_cls);
807  return ret;
808 }
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.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static int ret
Final status code.
Definition: gnunet-arm.c:89
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 823 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().

825 {
826  const struct GNUNET_PeerIdentity *rand_peer;
827  int ret;
828 
829  ret = GNUNET_YES;
830  /* Remove random peers until there is space for a new one */
831  while (num_valid_peers_max <=
833  {
834  rand_peer = get_random_peer_from_peermap(valid_peers);
835  GNUNET_CONTAINER_multipeermap_remove_all(valid_peers, rand_peer);
836  ret = GNUNET_NO;
837  }
838  (void)GNUNET_CONTAINER_multipeermap_put(valid_peers, peer, NULL,
840  if (valid_peers == msub->valid_peers)
841  {
843  "# valid peers",
845  GNUNET_NO);
846  }
847  return ret;
848 }
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.
#define GNUNET_NO
Definition: gnunet_common.h:78
static struct Sub * msub
Main Sub.
static int ret
Final status code.
Definition: gnunet-arm.c:89
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.
#define GNUNET_YES
Definition: gnunet_common.h:77
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 1075 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().

1076 {
1077  struct PeerContext *peer_ctx;
1078 
1079  (void)cancel;
1080 
1081  peer_ctx = pending_msg->peer_ctx;
1082  GNUNET_assert(NULL != peer_ctx);
1084  peer_ctx->pending_messages_tail,
1085  pending_msg);
1086  // TODO wait for the cadet implementation of message cancellation
1087  //if (GNUNET_YES == cancel)
1088  //{
1089  // GNUNET_MQ_send_cancel (pending_msg->ev);
1090  //}
1091  GNUNET_free(pending_msg);
1092 }
#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 862 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().

863 {
864  struct GNUNET_PeerIdentity *peer;
865  unsigned int i;
866 
867  peer = &peer_ctx->peer_id;
869  "Peer %s is online and valid, calling %i pending operations on it\n",
870  GNUNET_i2s(peer),
871  peer_ctx->num_pending_ops);
872 
873  if (NULL != peer_ctx->online_check_pending)
874  {
876  "Removing pending online check for peer %s\n",
877  GNUNET_i2s(&peer_ctx->peer_id));
878  // TODO wait until cadet sets mq->cancel_impl
879  //GNUNET_MQ_send_cancel (peer_ctx->online_check_pending->ev);
881  peer_ctx->online_check_pending = NULL;
882  }
883 
884  SET_PEER_FLAG(peer_ctx, Peers_ONLINE);
885 
886  /* Call pending operations */
887  for (i = 0; i < peer_ctx->num_pending_ops; i++)
888  {
889  peer_ctx->pending_ops[i].op(peer_ctx->pending_ops[i].op_cls, peer);
890  }
891  GNUNET_array_grow(peer_ctx->pending_ops, peer_ctx->num_pending_ops, 0);
892 }
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.
#define GNUNET_YES
Definition: gnunet_common.h:77
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:250
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 2807 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().

2809 {
2810  struct ChannelCtx *channel_ctx = cls;
2811  struct PeerContext *peer_ctx = channel_ctx->peer_ctx;
2812 
2813  (void)channel;
2814 
2815  channel_ctx->channel = NULL;
2816  remove_channel_ctx(channel_ctx);
2817  if (NULL != peer_ctx &&
2818  peer_ctx->send_channel_ctx == channel_ctx &&
2820  {
2821  remove_peer(peer_ctx->sub, &peer_ctx->peer_id);
2822  }
2823 }
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.
#define GNUNET_YES
Definition: gnunet_common.h:77
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 3479 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().

3481 {
3482  const struct ChannelCtx *channel_ctx = cls;
3483  const struct GNUNET_PeerIdentity *peer = &channel_ctx->peer_ctx->peer_id;
3484 
3485  (void)msg;
3486 
3488  "Received CHECK_LIVE (%s)\n", GNUNET_i2s(peer));
3489  if (channel_ctx->peer_ctx->sub == msub)
3490  {
3492  "# pending online checks",
3493  -1,
3494  GNUNET_NO);
3495  }
3496 
3497  GNUNET_CADET_receive_done(channel_ctx->channel);
3498 }
struct GNUNET_PeerIdentity peer_id
Identity of the peer.
struct PeerContext * peer_ctx
The peer context associated with the channel.
#define GNUNET_NO
Definition: gnunet_common.h:78
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:951
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 3511 of file gnunet-service-rps.c.

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

3513 {
3514  const struct ChannelCtx *channel_ctx = cls;
3515  const struct GNUNET_PeerIdentity *peer = &channel_ctx->peer_ctx->peer_id;
3516 
3517  (void)msg;
3518 
3519  // (check the proof of work (?))
3520 
3522  "Received PUSH (%s)\n",
3523  GNUNET_i2s(peer));
3524  if (channel_ctx->peer_ctx->sub == msub)
3525  {
3526  GNUNET_STATISTICS_update(stats, "# push message received", 1, GNUNET_NO);
3527  if (NULL != map_single_hop &&
3529  peer))
3530  {
3532  "# push message received (multi-hop peer)",
3533  1,
3534  GNUNET_NO);
3535  }
3536  }
3537 
3538  #if ENABLE_MALICIOUS
3539  struct AttackedPeer *tmp_att_peer;
3540 
3541  if ((1 == mal_type) ||
3542  (3 == mal_type))
3543  { /* Try to maximise representation */
3544  tmp_att_peer = GNUNET_new(struct AttackedPeer);
3545  tmp_att_peer->peer_id = *peer;
3546  if (NULL == att_peer_set)
3549  peer))
3550  {
3551  GNUNET_CONTAINER_DLL_insert(att_peers_head,
3552  att_peers_tail,
3553  tmp_att_peer);
3554  add_peer_array_to_set(peer, 1, att_peer_set);
3555  }
3556  else
3557  {
3558  GNUNET_free(tmp_att_peer);
3559  }
3560  }
3561 
3562 
3563  else if (2 == mal_type)
3564  {
3565  /* We attack one single well-known peer - simply ignore */
3566  }
3567  #endif /* ENABLE_MALICIOUS */
3568 
3569  /* Add the sending peer to the push_map */
3570  CustomPeerMap_put(channel_ctx->peer_ctx->sub->push_map, peer);
3571 
3573  &channel_ctx->peer_ctx->peer_id));
3574  GNUNET_CADET_receive_done(channel_ctx->channel);
3575 }
#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
Type of malicious peer to test.
#define GNUNET_NO
Definition: gnunet_common.h:78
#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.
static void add_peer_array_to_set(const struct GNUNET_PeerIdentity *peer_array, unsigned int num_peers, struct GNUNET_CONTAINER_MultiPeerMap *peer_map)
Add all peers in peer_array to peer_map used as set.
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:951
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 3587 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().

3589 {
3590  const struct ChannelCtx *channel_ctx = cls;
3591  struct PeerContext *peer_ctx = channel_ctx->peer_ctx;
3592  const struct GNUNET_PeerIdentity *peer = &peer_ctx->peer_id;
3593  const struct GNUNET_PeerIdentity *view_array;
3594 
3595  (void)msg;
3596 
3597  LOG(GNUNET_ERROR_TYPE_DEBUG, "Received PULL REQUEST (%s)\n", GNUNET_i2s(peer));
3598  if (peer_ctx->sub == msub)
3599  {
3601  "# pull request message received",
3602  1,
3603  GNUNET_NO);
3604  if (NULL != map_single_hop &&
3606  &peer_ctx->peer_id))
3607  {
3609  "# pull request message received (multi-hop peer)",
3610  1,
3611  GNUNET_NO);
3612  }
3613  }
3614 
3615  #if ENABLE_MALICIOUS
3616  if (1 == mal_type
3617  || 3 == mal_type)
3618  { /* Try to maximise representation */
3619  send_pull_reply(peer_ctx, mal_peers, num_mal_peers);
3620  }
3621 
3622  else if (2 == mal_type)
3623  { /* Try to partition network */
3624  if (0 == GNUNET_memcmp(&attacked_peer, peer))
3625  {
3626  send_pull_reply(peer_ctx, mal_peers, num_mal_peers);
3627  }
3628  }
3629  #endif /* ENABLE_MALICIOUS */
3630 
3632  &channel_ctx->peer_ctx->peer_id));
3633  GNUNET_CADET_receive_done(channel_ctx->channel);
3634  view_array = View_get_as_array(channel_ctx->peer_ctx->sub->view);
3635  send_pull_reply(peer_ctx,
3636  view_array,
3637  View_size(channel_ctx->peer_ctx->sub->view));
3638 }
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
Type of malicious peer to test.
#define GNUNET_NO
Definition: gnunet_common.h:78
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:951
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 3649 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().

3651 {
3652  struct ChannelCtx *channel_ctx = cls;
3653  struct PeerContext *sender_ctx = channel_ctx->peer_ctx;
3654 
3655  if (sizeof(struct GNUNET_RPS_P2P_PullReplyMessage) > ntohs(msg->header.size))
3656  {
3657  GNUNET_break_op(0);
3658  return GNUNET_SYSERR;
3659  }
3660 
3661  if ((ntohs(msg->header.size) - sizeof(struct GNUNET_RPS_P2P_PullReplyMessage)) /
3662  sizeof(struct GNUNET_PeerIdentity) != ntohl(msg->num_peers))
3663  {
3665  "message says it sends %" PRIu32 " peers, have space for %lu peers\n",
3666  ntohl(msg->num_peers),
3667  (ntohs(msg->header.size) - sizeof(struct GNUNET_RPS_P2P_PullReplyMessage)) /
3668  sizeof(struct GNUNET_PeerIdentity));
3669  GNUNET_break_op(0);
3670  return GNUNET_SYSERR;
3671  }
3672 
3673  if (GNUNET_YES != check_peer_flag(sender_ctx->sub->peer_map,
3674  &sender_ctx->peer_id,
3676  {
3678  "Received a pull reply from a peer (%s) we didn't request one from!\n",
3679  GNUNET_i2s(&sender_ctx->peer_id));
3680  if (sender_ctx->sub == msub)
3681  {
3683  "# unrequested pull replies",
3684  1,
3685  GNUNET_NO);
3686  }
3687  }
3688  return GNUNET_OK;
3689 }
struct GNUNET_MessageHeader header
Header including size and type in NBO.
Definition: rps.h:47
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:52
struct PeerContext * peer_ctx
The peer context associated with the channel.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
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:241
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.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
The identity of the host (wraps the signing key of the peer).
struct GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
#define GNUNET_YES
Definition: gnunet_common.h:77
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 3699 of file gnunet-service-rps.c.

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

3701 {
3702  const struct ChannelCtx *channel_ctx = cls;
3703  const struct GNUNET_PeerIdentity *sender = &channel_ctx->peer_ctx->peer_id;
3704  const struct GNUNET_PeerIdentity *peers;
3705  struct Sub *sub = channel_ctx->peer_ctx->sub;
3706  uint32_t i;
3707 
3708 #if ENABLE_MALICIOUS
3709  struct AttackedPeer *tmp_att_peer;
3710 #endif /* ENABLE_MALICIOUS */
3711 
3712  sub->pull_delays[sub->num_rounds - channel_ctx->peer_ctx->round_pull_req]++;
3713  LOG(GNUNET_ERROR_TYPE_DEBUG, "Received PULL REPLY (%s)\n", GNUNET_i2s(sender));
3714  if (channel_ctx->peer_ctx->sub == msub)
3715  {
3717  "# pull reply messages received",
3718  1,
3719  GNUNET_NO);
3720  if (NULL != map_single_hop &&
3722  &channel_ctx->peer_ctx->peer_id))
3723  {
3725  "# pull reply messages received (multi-hop peer)",
3726  1,
3727  GNUNET_NO);
3728  }
3729  }
3730 
3731  #if ENABLE_MALICIOUS
3732  // We shouldn't even receive pull replies as we're not sending
3733  if (2 == mal_type)
3734  {
3735  }
3736  #endif /* ENABLE_MALICIOUS */
3737 
3738  /* Do actual logic */
3739  peers = (const struct GNUNET_PeerIdentity *)&msg[1];
3740 
3742  "PULL REPLY received, got following %u peers:\n",
3743  ntohl(msg->num_peers));
3744 
3745  for (i = 0; i < ntohl(msg->num_peers); i++)
3746  {
3748  "%u. %s\n",
3749  i,
3750  GNUNET_i2s(&peers[i]));
3751 
3752  #if ENABLE_MALICIOUS
3753  if ((NULL != att_peer_set) &&
3754  (1 == mal_type || 3 == mal_type))
3755  { /* Add attacked peer to local list */
3756  // TODO check if we sent a request and this was the first reply
3758  &peers[i])
3760  &peers[i]))
3761  {
3762  tmp_att_peer = GNUNET_new(struct AttackedPeer);
3763  tmp_att_peer->peer_id = peers[i];
3764  GNUNET_CONTAINER_DLL_insert(att_peers_head,
3765  att_peers_tail,
3766  tmp_att_peer);
3767  add_peer_array_to_set(&peers[i], 1, att_peer_set);
3768  }
3769  continue;
3770  }
3771  #endif /* ENABLE_MALICIOUS */
3772  /* Make sure we 'know' about this peer */
3773  (void)insert_peer(channel_ctx->peer_ctx->sub,
3774  &peers[i]);
3775 
3776  if (GNUNET_YES == check_peer_valid(channel_ctx->peer_ctx->sub->valid_peers,
3777  &peers[i]))
3778  {
3779  CustomPeerMap_put(channel_ctx->peer_ctx->sub->pull_map,
3780  &peers[i]);
3781  }
3782  else
3783  {
3784  schedule_operation(channel_ctx->peer_ctx,
3786  channel_ctx->peer_ctx->sub); /* cls */
3787  (void)issue_peer_online_check(channel_ctx->peer_ctx->sub,
3788  &peers[i]);
3789  }
3790  }
3791 
3793  sender),
3795  clean_peer(channel_ctx->peer_ctx->sub,
3796  sender);
3797 
3799  sender));
3800  GNUNET_CADET_receive_done(channel_ctx->channel);
3801 }
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:52
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
Type of malicious peer to test.
#define GNUNET_NO
Definition: gnunet_common.h:78
#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:241
static void add_peer_array_to_set(const struct GNUNET_PeerIdentity *peer_array, unsigned int num_peers, struct GNUNET_CONTAINER_MultiPeerMap *peer_map)
Add all peers in peer_array to peer_map used as set.
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:951
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.
#define GNUNET_YES
Definition: gnunet_common.h:77
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 929 of file gnunet-service-rps.c.

References GNUNET_new, and ChannelCtx::peer_ctx.

Referenced by get_channel(), and handle_inbound_channel().

930 {
931  struct ChannelCtx *channel_ctx;
932 
933  channel_ctx = GNUNET_new(struct ChannelCtx);
934  channel_ctx->peer_ctx = peer_ctx;
935  return channel_ctx;
936 }
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 945 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().

946 {
947  struct PeerContext *peer_ctx = channel_ctx->peer_ctx;
948 
949  if (NULL != channel_ctx->destruction_task)
950  {
952  channel_ctx->destruction_task = NULL;
953  }
954 
955  GNUNET_free(channel_ctx);
956 
957  if (NULL == peer_ctx)
958  return;
959  if (channel_ctx == peer_ctx->send_channel_ctx)
960  {
961  peer_ctx->send_channel_ctx = NULL;
962  peer_ctx->mq = NULL;
963  }
964  else if (channel_ctx == peer_ctx->recv_channel_ctx)
965  {
966  peer_ctx->recv_channel_ctx = NULL;
967  }
968 }
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:956
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 978 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().

979 {
980  /* There exists a copy-paste-clone in run() */
981  struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
982  GNUNET_MQ_hd_fixed_size(peer_check,
984  struct GNUNET_MessageHeader,
985  NULL),
986  GNUNET_MQ_hd_fixed_size(peer_push,
988  struct GNUNET_MessageHeader,
989  NULL),
990  GNUNET_MQ_hd_fixed_size(peer_pull_request,
992  struct GNUNET_MessageHeader,
993  NULL),
994  GNUNET_MQ_hd_var_size(peer_pull_reply,
997  NULL),
999  };
1000 
1001 
1002  if (NULL == peer_ctx->send_channel_ctx)
1003  {
1005  "Trying to establish channel to peer %s\n",
1006  GNUNET_i2s(&peer_ctx->peer_id));
1007  peer_ctx->send_channel_ctx = add_channel_ctx(peer_ctx);
1008  peer_ctx->send_channel_ctx->channel =
1010  peer_ctx->send_channel_ctx, /* context */
1011  &peer_ctx->peer_id,
1012  &peer_ctx->sub->hash,
1013  NULL, /* WindowSize handler */
1014  &cleanup_destroyed_channel, /* Disconnect handler */
1015  cadet_handlers);
1016  }
1017  GNUNET_assert(NULL != peer_ctx->send_channel_ctx);
1018  GNUNET_assert(NULL != peer_ctx->send_channel_ctx->channel);
1019  return peer_ctx->send_channel_ctx->channel;
1020 }
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:1065
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 1033 of file gnunet-service-rps.c.

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

Referenced by check_peer_online(), and send_message().

1034 {
1035  if (NULL == peer_ctx->mq)
1036  {
1037  peer_ctx->mq = GNUNET_CADET_get_mq(get_channel(peer_ctx));
1038  }
1039  return peer_ctx->mq;
1040 }
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:1116
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 1051 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().

1054 {
1055  struct PendingMessage *pending_msg;
1056 
1057  pending_msg = GNUNET_new(struct PendingMessage);
1058  pending_msg->ev = ev;
1059  pending_msg->peer_ctx = peer_ctx;
1060  pending_msg->type = type;
1062  peer_ctx->pending_messages_tail,
1063  pending_msg);
1064  return pending_msg;
1065 }
#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 1102 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().

1103 {
1104  struct PeerContext *peer_ctx = cls;
1105 
1106  if (NULL != peer_ctx->online_check_pending)
1107  {
1109  "Online check for peer %s was successfull\n",
1110  GNUNET_i2s(&peer_ctx->peer_id));
1112  peer_ctx->online_check_pending = NULL;
1113  set_peer_online(peer_ctx);
1114  (void)add_valid_peer(&peer_ctx->peer_id, peer_ctx->sub->valid_peers);
1115  }
1116 }
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.
#define GNUNET_YES
Definition: gnunet_common.h:77
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 1124 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().

1125 {
1127  "Get informed about peer %s getting online\n",
1128  GNUNET_i2s(&peer_ctx->peer_id));
1129 
1130  struct GNUNET_MQ_Handle *mq;
1131  struct GNUNET_MQ_Envelope *ev;
1132 
1134  peer_ctx->online_check_pending =
1135  insert_pending_message(peer_ctx, ev, "Check online");
1136  mq = get_mq(peer_ctx);
1139  peer_ctx);
1140  GNUNET_MQ_send(mq, ev);
1141  if (peer_ctx->sub == msub)
1142  {
1144  "# pending online checks",
1145  1,
1146  GNUNET_NO);
1147  }
1148 }
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.
#define GNUNET_NO
Definition: gnunet_common.h:78
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:772
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:84
#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:351
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 1164 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().

1166 {
1167  unsigned int i;
1168 
1169  for (i = 0; i < peer_ctx->num_pending_ops; i++)
1170  if (peer_op == peer_ctx->pending_ops[i].op)
1171  return GNUNET_YES;
1172  return GNUNET_NO;
1173 }
struct PeerPendingOp * pending_ops
Array of pending operations on this peer.
#define GNUNET_NO
Definition: gnunet_common.h:78
PeerOp op
Callback.
unsigned int num_pending_ops
Number of pending operations.
#define GNUNET_YES
Definition: gnunet_common.h:77
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 1182 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().

1183 {
1184  struct GNUNET_CADET_Channel *channel;
1185 
1186  if (NULL != channel_ctx->destruction_task)
1187  {
1189  channel_ctx->destruction_task = NULL;
1190  }
1191  GNUNET_assert(channel_ctx->channel != NULL);
1192  channel = channel_ctx->channel;
1193  channel_ctx->channel = NULL;
1195  remove_channel_ctx(channel_ctx);
1196 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Opaque handle to a channel.
Definition: cadet_api.c:79
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:900
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:956
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 1207 of file gnunet-service-rps.c.

References destroy_channel(), and ChannelCtx::destruction_task.

Referenced by schedule_channel_destruction().

1208 {
1209  struct ChannelCtx *channel_ctx = cls;
1210 
1211  channel_ctx->destruction_task = NULL;
1212  destroy_channel(channel_ctx);
1213 }
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 1227 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().

1228 {
1229  GNUNET_assert(NULL ==
1230  channel_ctx->destruction_task);
1231  GNUNET_assert(NULL !=
1232  channel_ctx->channel);
1233  channel_ctx->destruction_task =
1235  channel_ctx);
1236 }
#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:1264
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 1253 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().

1254 {
1255  GNUNET_assert(NULL != peer_ctx);
1256  GNUNET_assert(NULL != peer_ctx->sub->peer_map);
1257  if (GNUNET_NO ==
1259  &peer_ctx->peer_id))
1260  {
1261  return GNUNET_NO;
1262  }
1263  SET_PEER_FLAG(peer_ctx, Peers_TO_DESTROY);
1265  "Going to remove peer %s\n",
1266  GNUNET_i2s(&peer_ctx->peer_id));
1267  UNSET_PEER_FLAG(peer_ctx, Peers_ONLINE);
1268 
1269  /* Clear list of pending operations */
1270  // TODO this probably leaks memory
1271  // ('only' the cls to the function. Not sure what to do with it)
1272  GNUNET_array_grow(peer_ctx->pending_ops,
1273  peer_ctx->num_pending_ops,
1274  0);
1275  /* Remove all pending messages */
1276  while (NULL != peer_ctx->pending_messages_head)
1277  {
1279  "Removing unsent %s\n",
1280  peer_ctx->pending_messages_head->type);
1281  /* Cancle pending message, too */
1282  if ((NULL != peer_ctx->online_check_pending) &&
1283  (0 == memcmp(peer_ctx->pending_messages_head,
1284  peer_ctx->online_check_pending,
1285  sizeof(struct PendingMessage))))
1286  {
1287  peer_ctx->online_check_pending = NULL;
1288  if (peer_ctx->sub == msub)
1289  {
1291  "# pending online checks",
1292  -1,
1293  GNUNET_NO);
1294  }
1295  }
1297  GNUNET_YES);
1298  }
1299 
1300  /* If we are still waiting for notification whether this peer is online
1301  * cancel the according task */
1302  if (NULL != peer_ctx->online_check_pending)
1303  {
1305  "Removing pending online check for peer %s\n",
1306  GNUNET_i2s(&peer_ctx->peer_id));
1307  // TODO wait until cadet sets mq->cancel_impl
1308  //GNUNET_MQ_send_cancel (peer_ctx->online_check_pending->ev);
1310  GNUNET_YES);
1311  peer_ctx->online_check_pending = NULL;
1312  }
1313 
1314  if (NULL != peer_ctx->send_channel_ctx)
1315  {
1316  /* This is possibly called from within channel destruction */
1317  peer_ctx->send_channel_ctx->peer_ctx = NULL;
1319  peer_ctx->send_channel_ctx = NULL;
1320  peer_ctx->mq = NULL;
1321  }
1322  if (NULL != peer_ctx->recv_channel_ctx)
1323  {
1324  /* This is possibly called from within channel destruction */
1325  peer_ctx->recv_channel_ctx->peer_ctx = NULL;
1327  peer_ctx->recv_channel_ctx = NULL;
1328  }
1329 
1330  if (GNUNET_YES !=
1332  &peer_ctx->peer_id))
1333  {
1335  "removing peer from peer_ctx->sub->peer_map failed\n");
1336  }
1337  if (peer_ctx->sub == msub)
1338  {
1340  "# known peers",
1342  GNUNET_NO);
1343  }
1344  GNUNET_free(peer_ctx);
1345  return GNUNET_YES;
1346 }
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.
#define GNUNET_NO
Definition: gnunet_common.h:78
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:257
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.
#define GNUNET_YES
Definition: gnunet_common.h:77
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:250
#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 1359 of file gnunet-service-rps.c.

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

Referenced by peers_terminate().

1362 {
1363  struct Sub *sub = cls;
1364 
1365  (void)value;
1366 
1367  destroy_peer(get_peer_ctx(sub->peer_map, key));
1368  return GNUNET_YES;
1369 }
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.
#define GNUNET_YES
Definition: gnunet_common.h:77
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 1380 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().

1381 {
1382  struct PendingMessage *pending_msg = (struct PendingMessage *)cls;
1383 
1385  "%s was sent.\n",
1386  pending_msg->type);
1387  if (pending_msg->peer_ctx->sub == msub)
1388  {
1389  if (0 == strncmp("PULL REPLY", pending_msg->type, 10))
1390  GNUNET_STATISTICS_update(stats, "# pull replys sent", 1, GNUNET_NO);
1391  if (0 == strncmp("PULL REQUEST", pending_msg->type, 12))
1392  GNUNET_STATISTICS_update(stats, "# pull requests sent", 1, GNUNET_NO);
1393  if (0 == strncmp("PUSH", pending_msg->type, 4))
1394  GNUNET_STATISTICS_update(stats, "# pushes sent", 1, GNUNET_NO);
1395  if (0 == strncmp("PULL REQUEST", pending_msg->type, 12) &&
1396  NULL != map_single_hop &&
1398  &pending_msg->peer_ctx->peer_id))
1400  "# pull requests sent (multi-hop peer)",
1401  1,
1402  GNUNET_NO);
1403  }
1404  /* Do not cancle message */
1405  remove_pending_message(pending_msg, GNUNET_NO);
1406 }
struct GNUNET_PeerIdentity peer_id
Identity of the peer.
struct PeerContext * peer_ctx
The corresponding context.
#define GNUNET_NO
Definition: gnunet_common.h:78
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 1424 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().

1427 {
1428  const struct GNUNET_DISK_FileHandle *fh = cls;
1429  char peer_string[128];
1430  int size;
1431  ssize_t ret;
1432 
1433  (void)value;
1434 
1435  if (NULL == peer)
1436  {
1437  return GNUNET_YES;
1438  }
1439  size = GNUNET_snprintf(peer_string,
1440  sizeof(peer_string),
1441  "%s\n",
1442  GNUNET_i2s_full(peer));
1443  GNUNET_assert(53 == size);
1444  ret = GNUNET_DISK_file_write(fh,
1445  peer_string,
1446  size);
1447  GNUNET_assert(size == ret);
1448  return GNUNET_YES;
1449 }
int GNUNET_snprintf(char *buf, size_t size, const char *format,...)
Like snprintf, just aborts if the buffer is of insufficient size.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
const char * GNUNET_i2s_full(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
static int ret
Final status code.
Definition: gnunet-arm.c:89
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:817
static int fh
Handle to the unique file.
static unsigned int size
Size of the "table".
Definition: peer.c:66
#define GNUNET_YES
Definition: gnunet_common.h:77
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 1458 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().

1459 {
1460  struct GNUNET_DISK_FileHandle *fh;
1461  uint32_t number_written_peers;
1462  int ret;
1463 
1464  if (0 == strncmp("DISABLE", sub->filename_valid_peers, 7))
1465  {
1466  return;
1467  }
1468 
1470  if (GNUNET_SYSERR == ret)
1471  {
1473  "Not able to create directory for file `%s'\n",
1474  sub->filename_valid_peers);
1475  GNUNET_break(0);
1476  }
1477  else if (GNUNET_NO == ret)
1478  {
1480  "Directory for file `%s' exists but is not writable for us\n",
1481  sub->filename_valid_peers);
1482  GNUNET_break(0);
1483  }
1489  if (NULL == fh)
1490  {
1492  "Not able to write valid peers to file `%s'\n",
1493  sub->filename_valid_peers);
1494  return;
1495  }
1497  "Writing %u valid peers to disk\n",
1499  number_written_peers =
1502  fh);
1504  GNUNET_assert(number_written_peers ==
1506 }
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:1339
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.
int GNUNET_DISK_directory_create_for_file(const char *filename)
Create the directory structure for storing a file.
Definition: disk.c:681
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static int ret
Final status code.
Definition: gnunet-arm.c:89
#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.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
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:1262
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 1519 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().

1520 {
1521  struct GNUNET_PeerIdentity *peer;
1522  size_t len;
1523  int ret;
1524 
1525  peer = GNUNET_new(struct GNUNET_PeerIdentity);
1526  len = strlen(string_repr);
1527  if (52 > len)
1528  {
1530  "Not able to convert string representation of PeerID to PeerID\n"
1531  "Sting representation: %s (len %lu) - too short\n",
1532  string_repr,
1533  len);
1534  GNUNET_break(0);
1535  }
1536  else if (52 < len)
1537  {
1538  len = 52;
1539  }
1541  len,
1542  &peer->public_key);
1543  if (GNUNET_OK != ret)
1544  {
1546  "Not able to convert string representation of PeerID to PeerID\n"
1547  "Sting representation: %s\n",
1548  string_repr);
1549  GNUNET_break(0);
1550  }
1551  return peer;
1552 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static int ret
Final status code.
Definition: gnunet-arm.c:89
#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:501
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 1561 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().

1562 {
1563  off_t file_size;
1564  uint32_t num_peers;
1565  struct GNUNET_DISK_FileHandle *fh;
1566  char *buf;
1567  ssize_t size_read;
1568  char *iter_buf;
1569  char *str_repr;
1570  const struct GNUNET_PeerIdentity *peer;
1571 
1572  if (0 == strncmp("DISABLE", sub->filename_valid_peers, 7))
1573  {
1574  return;
1575  }
1576 
1578  {
1579  return;
1580  }
1584  GNUNET_assert(NULL != fh);
1586  num_peers = file_size / 53;
1587  buf = GNUNET_malloc(file_size);
1588  size_read = GNUNET_DISK_file_read(fh, buf, file_size);
1589  GNUNET_assert(size_read == file_size);
1591  "Restoring %" PRIu32 " peers from file `%s'\n",
1592  num_peers,
1593  sub->filename_valid_peers);
1594  for (iter_buf = buf; iter_buf < buf + file_size - 1; iter_buf += 53)
1595  {
1596  str_repr = GNUNET_strndup(iter_buf, 53);
1597  peer = s2i_full(str_repr);
1598  GNUNET_free(str_repr);
1599  add_valid_peer(peer, sub->valid_peers);
1601  "Restored valid peer %s from disk\n",
1602  GNUNET_i2s_full(peer));
1603  }
1604  iter_buf = NULL;
1605  GNUNET_free(buf);
1607  "num_peers: %" PRIu32 ", _size (sub->valid_peers): %u\n",
1608  num_peers,
1610  if (num_peers != GNUNET_CONTAINER_multipeermap_size(sub->valid_peers))
1611  {
1613  "Number of restored peers does not match file size. Have probably duplicates.\n");
1614  }
1617  "Restored %u valid peers from disk\n",
1619 }
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:541
Open the file for reading.
int GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1339
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:729
#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 GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#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:203
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:1262
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 1628 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().

1629 {
1630  if (GNUNET_SYSERR ==
1633  sub))
1634  {
1636  "Iteration destroying peers was aborted.\n");
1637  }
1639  sub->peer_map = NULL;
1640  store_valid_peers(sub);
1642  sub->filename_valid_peers = NULL;
1644  sub->valid_peers = NULL;
1645 }
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.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
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 1659 of file gnunet-service-rps.c.

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

Referenced by get_valid_peers().

1662 {
1663  struct PeersIteratorCls *it_cls = cls;
1664 
1665  (void)value;
1666 
1667  return it_cls->iterator(it_cls->cls, peer);
1668 }
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 1681 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().

1684 {
1685  struct PeersIteratorCls *cls;
1686  int ret;
1687 
1688  cls = GNUNET_new(struct PeersIteratorCls);
1689  cls->iterator = iterator;
1690  cls->cls = it_cls;
1691  ret = GNUNET_CONTAINER_multipeermap_iterate(valid_peers,
1693  cls);
1694  GNUNET_free(cls);
1695  return ret;
1696 }
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.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static int ret
Final status code.
Definition: gnunet-arm.c:89
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 1712 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().

1714 {
1715  if (GNUNET_YES == check_peer_known(sub->peer_map, peer))
1716  {
1717  return GNUNET_NO; /* We already know this peer - nothing to do */
1718  }
1719  (void)create_peer_ctx(sub, peer);
1720  return GNUNET_YES;
1721 }
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.
#define GNUNET_NO
Definition: gnunet_common.h:78
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.
#define GNUNET_YES
Definition: gnunet_common.h:77
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 1736 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().

1739 {
1740  struct PeerContext *peer_ctx;
1741 
1742  if (GNUNET_NO == check_peer_known(peer_map, peer))
1743  {
1744  return GNUNET_SYSERR;
1745  }
1746  peer_ctx = get_peer_ctx(peer_map, peer);
1747  return check_peer_flag_set(peer_ctx, flags);
1748 }
#define check_peer_flag_set(peer_ctx, mask)
Get peer flag of given peer context.
#define GNUNET_NO
Definition: gnunet_common.h:78
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.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
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 1761 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().

1763 {
1764  struct PeerContext *peer_ctx;
1765 
1766  (void)insert_peer(sub, peer); // TODO even needed?
1767  peer_ctx = get_peer_ctx(sub->peer_map, peer);
1768  if ((GNUNET_NO == check_peer_flag(sub->peer_map, peer, Peers_ONLINE)) &&
1769  (NULL == peer_ctx->online_check_pending))
1770  {
1771  check_peer_online(peer_ctx);
1772  return GNUNET_YES;
1773  }
1774  return GNUNET_NO;
1775 }
static void check_peer_online(struct PeerContext *peer_ctx)
Issue a check whether peer is online.
#define GNUNET_NO
Definition: gnunet_common.h:78
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.
#define GNUNET_YES
Definition: gnunet_common.h:77
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:250
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 1792 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().

1793 {
1795  &peer_ctx->peer_id))
1796  {
1797  return GNUNET_SYSERR;
1798  }
1799 
1800  if ((NULL != peer_ctx->recv_channel_ctx) ||
1801  (NULL != peer_ctx->pending_messages_head) ||
1803  {
1804  return GNUNET_NO;
1805  }
1806  return GNUNET_YES;
1807 }
#define check_peer_flag_set(peer_ctx, mask)
Get peer flag of given peer context.
struct GNUNET_PeerIdentity peer_id
Identity of the peer.
#define GNUNET_NO
Definition: gnunet_common.h:78
If we are waiting for a reply from that peer (sent a pull request).
Definition: rps.h:241
struct GNUNET_CONTAINER_MultiPeerMap * peer_map
Set of all peers to keep track of them.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
struct ChannelCtx * recv_channel_ctx
Channel open from client.
#define GNUNET_YES
Definition: gnunet_common.h:77
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 1822 of file gnunet-service-rps.c.

References GNUNET_CONTAINER_multipeermap_contains().

Referenced by handle_peer_pull_reply().

1824 {
1825  return GNUNET_CONTAINER_multipeermap_contains(valid_peers, peer);
1826 }
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 1837 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().

1838 {
1840  &peer_ctx->peer_id));
1841  (void)get_channel(peer_ctx);
1842 }
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.
#define GNUNET_YES
Definition: gnunet_common.h:77
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 1855 of file gnunet-service-rps.c.

References GNUNET_NO, GNUNET_YES, and PeerContext::recv_channel_ctx.

Referenced by clean_peer(), and handle_inbound_channel().

1856 {
1857  if (NULL != peer_ctx->recv_channel_ctx)
1858  {
1859  return GNUNET_YES;
1860  }
1861  return GNUNET_NO;
1862 }
#define GNUNET_NO
Definition: gnunet_common.h:78
struct ChannelCtx * recv_channel_ctx
Channel open from client.
#define GNUNET_YES
Definition: gnunet_common.h:77
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 1876 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().

1879 {
1880  struct PeerContext *peer_ctx;
1881  struct ChannelCtx *channel_ctx;
1882  struct Sub *sub = cls;
1883 
1885  "New channel was established to us (Peer %s).\n",
1886  GNUNET_i2s(initiator));
1887  GNUNET_assert(NULL != channel); /* according to cadet API */
1888  /* Make sure we 'know' about this peer */
1889  peer_ctx = create_or_get_peer_ctx(sub, initiator);
1890  set_peer_online(peer_ctx);
1891  (void)add_valid_peer(&peer_ctx->peer_id, peer_ctx->sub->valid_peers);
1892  channel_ctx = add_channel_ctx(peer_ctx);
1893  channel_ctx->channel = channel;
1894  /* We only accept one incoming channel per peer */
1896  initiator)))
1897  {
1899  "Already got one receive channel. Destroying old one.\n");
1900  GNUNET_break_op(0);
1901  destroy_channel(peer_ctx->recv_channel_ctx);
1902  peer_ctx->recv_channel_ctx = channel_ctx;
1903  /* return the channel context */
1904  return channel_ctx;
1905  }
1906  peer_ctx->recv_channel_ctx = channel_ctx;
1907  return channel_ctx;
1908 }
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.
#define GNUNET_YES
Definition: gnunet_common.h:77
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 1920 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().

1921 {
1922  if (GNUNET_NO == check_peer_known(peer_ctx->sub->peer_map,
1923  &peer_ctx->peer_id))
1924  { /* If no such peer exists, there is no channel */
1925  return GNUNET_NO;
1926  }
1927  if (NULL == peer_ctx->send_channel_ctx)
1928  {
1929  return GNUNET_NO;
1930  }
1931  return GNUNET_YES;
1932 }
struct GNUNET_PeerIdentity peer_id
Identity of the peer.
#define GNUNET_NO
Definition: gnunet_common.h:78
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.
#define GNUNET_YES
Definition: gnunet_common.h:77
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 1944 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().

1945 {
1946  if (GNUNET_NO == check_peer_known(peer_ctx->sub->peer_map,
1947  &peer_ctx->peer_id))
1948  {
1949  return GNUNET_NO;
1950  }
1951  if (NULL != peer_ctx->send_channel_ctx)
1952  {
1953  destroy_channel(peer_ctx->send_channel_ctx);
1954  (void)check_connected(peer_ctx);
1955  return GNUNET_YES;
1956  }
1957  return GNUNET_NO;
1958 }
struct GNUNET_PeerIdentity peer_id
Identity of the peer.
#define GNUNET_NO
Definition: gnunet_common.h:78
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.
#define GNUNET_YES
Definition: gnunet_common.h:77
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 1971 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 send_pull_reply(), send_pull_request(), and send_push().

1974 {
1975  struct PendingMessage *pending_msg;
1976  struct GNUNET_MQ_Handle *mq;
1977 
1979  "Sending message to %s of type %s\n",
1980  GNUNET_i2s(&peer_ctx->peer_id),
1981  type);
1982  pending_msg = insert_pending_message(peer_ctx, ev, type);
1983  mq = get_mq(peer_ctx);
1986  pending_msg);
1987  GNUNET_MQ_send(mq, ev);
1988 }
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:772
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:84
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:351
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 2003 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().

2006 {
2007  struct PeerPendingOp pending_op;
2008 
2010  &peer_ctx->peer_id));
2011 
2012  //TODO if ONLINE execute immediately
2013 
2014  if (GNUNET_NO == check_operation_scheduled(peer_ctx, peer_op))
2015  {
2016  pending_op.op = peer_op;
2017  pending_op.op_cls = cls;
2018  GNUNET_array_append(peer_ctx->pending_ops,
2019  peer_ctx->num_pending_ops,
2020  pending_op);
2021  return GNUNET_YES;
2022  }
2023  return GNUNET_NO;
2024 }
struct PeerPendingOp * pending_ops
Array of pending operations on this peer.
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.
#define GNUNET_NO
Definition: gnunet_common.h:78
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.
#define GNUNET_array_append(arr, size, element)
Append an element to a list (growing the list by one).
#define GNUNET_YES
Definition: gnunet_common.h:77
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 2123 of file gnunet-service-rps.c.

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

Referenced by handle_client_seed().

2125 {
2126  unsigned int i;
2127 
2129  "Printing peer list of length %u at %p:\n",
2130  len,
2131  list);
2132  for (i = 0; i < len; i++)
2133  {
2135  "%u. peer: %s\n",
2136  i, GNUNET_i2s(&list[i]));
2137  }
2138 }
#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 2145 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().

2148 {
2149  unsigned int i;
2150  struct GNUNET_PeerIdentity *tmp;
2151 
2152  tmp = *peer_list;
2153 
2155  "Removing peer %s from list at %p\n",
2156  GNUNET_i2s(peer),
2157  tmp);
2158 
2159  for (i = 0; i < *list_size; i++)
2160  {
2161  if (0 == GNUNET_memcmp(&tmp[i], peer))
2162  {
2163  if (i < *list_size - 1)
2164  { /* Not at the last entry -- shift peers left */
2165  memmove(&tmp[i], &tmp[i + 1],
2166  ((*list_size) - i - 1) * sizeof(struct GNUNET_PeerIdentity));
2167  }
2168  /* Remove last entry (should be now useless PeerID) */
2169  GNUNET_array_grow(tmp, *list_size, (*list_size) - 1);
2170  }
2171  }
2172  *peer_list = tmp;
2173 }
#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 2569 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().

2571 {
2572  struct Sub *sub = cls;
2573  int inserted;
2574 
2575  inserted = insert_in_view(sub, peer);
2576  if (GNUNET_OK == inserted)
2577  {
2578  clients_notify_stream_peer(sub, 1, peer);
2579  }
2580 }
static int insert_in_view(struct Sub *sub, const struct GNUNET_PeerIdentity *peer)
Insert PeerID in #view.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
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 2201 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().

2203 {
2204  struct PeerContext *peer_ctx;
2205  int online;
2206  int ret;
2207 
2208  online = check_peer_flag(sub->peer_map, peer, Peers_ONLINE);
2209  peer_ctx = get_peer_ctx(sub->peer_map, peer); // TODO indirection needed?
2210  if ((GNUNET_NO == online) ||
2211  (GNUNET_SYSERR == online)) /* peer is not even known */
2212  {
2213  (void)issue_peer_online_check(sub, peer);
2214  (void)schedule_operation(peer_ctx, insert_in_view_op, sub);
2215  return GNUNET_NO;
2216  }
2217  /* Open channel towards peer to keep connection open */
2218  indicate_sending_intention(peer_ctx);
2219  ret = View_put(sub->view, peer);
2220  if (peer_ctx->sub == msub)
2221  {
2223  "view size",
2224  View_size(peer_ctx->sub->view),
2225  GNUNET_NO);
2226  }
2227  return ret;
2228 }
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.
#define GNUNET_NO
Definition: gnunet_common.h:78
static struct Sub * msub
Main Sub.
static int ret
Final status code.
Definition: gnunet-arm.c:89
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.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
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:250
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 2239 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().

2242 {
2243  struct GNUNET_MQ_Envelope *ev;
2244  struct GNUNET_RPS_CS_DEBUG_ViewReply *out_msg;
2245  struct Sub *sub;
2246 
2247  if (NULL == view_array)
2248  {
2249  if (NULL == cli_ctx->sub)
2250  sub = msub;
2251  else
2252  sub = cli_ctx->sub;
2253  view_size = View_size(sub->view);
2254  view_array = View_get_as_array(sub->view);
2255  }
2256 
2257  ev = GNUNET_MQ_msg_extra(out_msg,
2258  view_size * sizeof(struct GNUNET_PeerIdentity),
2260  out_msg->num_peers = htonl(view_size);
2261 
2262  GNUNET_memcpy(&out_msg[1],
2263  view_array,
2264  view_size * sizeof(struct GNUNET_PeerIdentity));
2265  GNUNET_MQ_send(cli_ctx->mq, ev);
2266 }
Message from service to client containing current update of view.
Definition: rps.h:180
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:351
struct View * view
The view.
uint64_t num_peers
Number of peers in the view.
Definition: rps.h:194
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 2279 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().

2282 {
2283  struct GNUNET_MQ_Envelope *ev;
2284  struct GNUNET_RPS_CS_DEBUG_StreamReply *out_msg;
2285 
2286  GNUNET_assert(NULL != peers);
2287 
2288  ev = GNUNET_MQ_msg_extra(out_msg,
2289  num_peers * sizeof(struct GNUNET_PeerIdentity),
2291  out_msg->num_peers = htonl(num_peers);
2292 
2293  GNUNET_memcpy(&out_msg[1],
2294  peers,
2295  num_peers * sizeof(struct GNUNET_PeerIdentity));
2296  GNUNET_MQ_send(cli_ctx->mq, ev);
2297 }
#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:221
Message from service to client containing peer from biased stream.
Definition: rps.h:212
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:351
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 2306 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().

2307 {
2308  struct ClientContext *cli_ctx_iter;
2309  uint64_t num_peers;
2310  const struct GNUNET_PeerIdentity *view_array;
2311 
2312  num_peers = View_size(sub->view);
2313  view_array = View_get_as_array(sub->view);
2314  /* check size of view is small enough */
2315  if (GNUNET_MAX_MESSAGE_SIZE < num_peers)
2316  {
2318  "View is too big to send\n");
2319  return;
2320  }
2321 
2322  for (cli_ctx_iter = cli_ctx_head;
2323  NULL != cli_ctx_iter;
2324  cli_ctx_iter = cli_ctx_iter->next)
2325  {
2326  if (1 < cli_ctx_iter->view_updates_left)
2327  {
2328  /* Client wants to receive limited amount of updates */
2329  cli_ctx_iter->view_updates_left -= 1;
2330  }
2331  else if (1 == cli_ctx_iter->view_updates_left)
2332  {
2333  /* Last update of view for client */
2334  cli_ctx_iter->view_updates_left = -1;
2335  }
2336  else if (0 > cli_ctx_iter->view_updates_left)
2337  {
2338  /* Client is not interested in updates */
2339  continue;
2340  }
2341  /* else _updates_left == 0 - infinite amount of updates */
2342 
2343  /* send view */
2344  send_view(cli_ctx_iter, view_array, num_peers);
2345  }
2346 }
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 2356 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().

2360 {
2361  struct ClientContext *cli_ctx_iter;
2362 
2364  "Got peer (%s) from biased stream - update all clients\n",
2365  GNUNET_i2s(peers));
2366 
2367  for (cli_ctx_iter = cli_ctx_head;
2368  NULL != cli_ctx_iter;
2369  cli_ctx_iter = cli_ctx_iter->next)
2370  {
2371  if (GNUNET_YES == cli_ctx_iter->stream_update &&
2372  (sub == cli_ctx_iter->sub || sub == msub))
2373  {
2374  send_stream_peers(cli_ctx_iter, num_peers, peers);
2375  }
2376  }
2377 }
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.
#define GNUNET_YES
Definition: gnunet_common.h:77
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:

◆ hist_update()

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

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

Parameters
idsArray of Peers to insert into view
num_peersNumber of peers to insert
clsClosure - The Sub for which this is to be done

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

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

Referenced by do_round().

2391 {
2392  unsigned int i;
2393&