/*
This file is part of GNUnet.
- Copyright (C)
+ Copyright (C) 2013-2015 GNUnet e.V.
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
*/
static struct RPS_Sampler *client_sampler;
-
/**
* Name to log view to
*/
static char *file_name_view_log;
-
/**
- * The size of sampler we need to be able to satisfy the client's need of
- * random peers.
+ * The size of sampler we need to be able to satisfy the client's need
+ * of random peers.
*/
static unsigned int sampler_size_client_need;
*/
static unsigned int sampler_size_est_need;
-
/**
* Percentage of total peer number in the view
* to send random PUSHes to
*/
static float beta;
-/**
- * The percentage gamma of history updates.
- * Simply 1 - alpha - beta
- */
-
-
/**
* Identifier for the main task that runs periodically.
*/
*/
static struct GNUNET_TIME_Relative round_interval;
-
-
/**
* List to store peers received through pushes temporary.
*/
*/
static struct CustomPeerMap *pull_map;
-
/**
* Handler to NSE.
*/
/**
* Handle for cancellation of iteration over peers.
*/
-struct GNUNET_PEERINFO_NotifyContext *peerinfo_notify_handle;
-
+static struct GNUNET_PEERINFO_NotifyContext *peerinfo_notify_handle;
/**
* Request counter.
/**
* The prediction of the rate of requests
*/
-static struct GNUNET_TIME_Relative request_rate;
-
-
-/**
- * Number of history update tasks.
- */
-uint32_t num_hist_update_tasks;
+static struct GNUNET_TIME_Relative request_rate;
#ifdef ENABLE_MALICIOUS
* 2 Try to partition the network
* 3 Combined attack
*/
-uint32_t mal_type = 0;
+static uint32_t mal_type;
/**
* Other malicious peers
*/
-static struct GNUNET_PeerIdentity *mal_peers = NULL;
+static struct GNUNET_PeerIdentity *mal_peers;
/**
* Hashmap of malicious peers used as set.
* Used to more efficiently check whether we know that peer.
*/
-static struct GNUNET_CONTAINER_MultiPeerMap *mal_peer_set = NULL;
+static struct GNUNET_CONTAINER_MultiPeerMap *mal_peer_set;
/**
* Number of other malicious peers
/**
* If type is 2 this is the DLL of attacked peers
*/
-static struct AttackedPeer *att_peers_head = NULL;
-static struct AttackedPeer *att_peers_tail = NULL;
+static struct AttackedPeer *att_peers_head;
+static struct AttackedPeer *att_peers_tail;
/**
* This index is used to point to an attacked peer to
* implement the round-robin-ish way to select attacked peers.
*/
-static struct AttackedPeer *att_peer_index = NULL;
+static struct AttackedPeer *att_peer_index;
/**
* Hashmap of attacked peers used as set.
* Used to more efficiently check whether we know that peer.
*/
-static struct GNUNET_CONTAINER_MultiPeerMap *att_peer_set = NULL;
+static struct GNUNET_CONTAINER_MultiPeerMap *att_peer_set;
/**
* Number of attacked peers
*/
-static uint32_t num_attacked_peers = 0;
-
+static uint32_t num_attacked_peers;
/**
* If type is 1 this is the attacked peer
***********************************************************************/
-
-
-
-
/***********************************************************************
* Util functions
***********************************************************************/
/**
* Print peerlist to log.
*/
-void
-print_peer_list (struct GNUNET_PeerIdentity *list, unsigned int len)
+static void
+print_peer_list (struct GNUNET_PeerIdentity *list,
+ unsigned int len)
{
unsigned int i;
/**
* Remove peer from list.
*/
- void
+static void
rem_from_list (struct GNUNET_PeerIdentity **peer_list,
unsigned int *list_size,
const struct GNUNET_PeerIdentity *peer)
/**
* Sum all time relatives of an array.
- */
- struct GNUNET_TIME_Relative
-T_relative_sum (const struct GNUNET_TIME_Relative *rel_array, uint32_t arr_size)
+ */
+static struct GNUNET_TIME_Relative
+T_relative_sum (const struct GNUNET_TIME_Relative *rel_array,
+ uint32_t arr_size)
{
struct GNUNET_TIME_Relative sum;
uint32_t i;
/**
* Compute the average of given time relatives.
*/
- struct GNUNET_TIME_Relative
-T_relative_avg (const struct GNUNET_TIME_Relative *rel_array, uint32_t arr_size)
+static struct GNUNET_TIME_Relative
+T_relative_avg (const struct GNUNET_TIME_Relative *rel_array,
+ uint32_t arr_size)
{
- return GNUNET_TIME_relative_divide (T_relative_sum (rel_array, arr_size), arr_size);
+ return GNUNET_TIME_relative_divide (T_relative_sum (rel_array,
+ arr_size),
+ arr_size);
}
+/**
+ * Insert PeerID in #view
+ *
+ * Called once we know a peer is live.
+ * Implements #PeerOp
+ *
+ * @return GNUNET_OK if peer was actually inserted
+ * GNUNET_NO if peer was not inserted
+ */
+static void
+insert_in_view_op (void *cls,
+ const struct GNUNET_PeerIdentity *peer);
+
+/**
+ * Insert PeerID in #view
+ *
+ * Called once we know a peer is live.
+ *
+ * @return GNUNET_OK if peer was actually inserted
+ * GNUNET_NO if peer was not inserted
+ */
+static int
+insert_in_view (const struct GNUNET_PeerIdentity *peer)
+{
+ int online;
+
+ online = Peers_check_peer_flag (peer, Peers_ONLINE);
+ if ( (GNUNET_NO == online) ||
+ (GNUNET_SYSERR == online) ) /* peer is not even known */
+ {
+ (void) Peers_issue_peer_liveliness_check (peer);
+ (void) Peers_schedule_operation (peer, insert_in_view_op);
+ return GNUNET_NO;
+ }
+ /* Open channel towards peer to keep connection open */
+ Peers_indicate_sending_intention (peer);
+ return View_put (peer);
+}
+
/**
* Put random peer from sampler into the view as history update.
*/
- void
-hist_update (void *cls, struct GNUNET_PeerIdentity *ids, uint32_t num_peers)
+static void
+hist_update (void *cls,
+ struct GNUNET_PeerIdentity *ids,
+ uint32_t num_peers)
{
unsigned int i;
for (i = 0; i < num_peers; i++)
{
- View_put (&ids[i]);
+ (void) insert_in_view (&ids[i]);
to_file (file_name_view_log,
"+%s\t(hist)",
GNUNET_i2s_full (ids));
}
- if (0 < num_hist_update_tasks)
- num_hist_update_tasks--;
}
-
/**
* Wrapper around #RPS_sampler_resize()
*
*
* Called every time we receive a request from the client.
*/
- void
+static void
est_request_rate()
{
struct GNUNET_TIME_Relative max_round_duration;
*
* Called once we know a peer is live.
*/
- void
-insert_in_pull_map (void *cls, const struct GNUNET_PeerIdentity *peer)
+static void
+insert_in_pull_map (void *cls,
+ const struct GNUNET_PeerIdentity *peer)
{
CustomPeerMap_put (pull_map, peer);
}
+
/**
* Insert PeerID in #view
*
* Called once we know a peer is live.
+ * Implements #PeerOp
*/
- void
-insert_in_view (void *cls, const struct GNUNET_PeerIdentity *peer)
+static void
+insert_in_view_op (void *cls,
+ const struct GNUNET_PeerIdentity *peer)
{
- View_put (peer);
+ (void) insert_in_view (peer);
}
+
/**
* Update sampler with given PeerID.
+ * Implements #PeerOp
*/
- void
-insert_in_sampler (void *cls, const struct GNUNET_PeerIdentity *peer)
+static void
+insert_in_sampler (void *cls,
+ const struct GNUNET_PeerIdentity *peer)
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Updating samplers with peer %s from insert_in_sampler()\n",
if (0 < RPS_sampler_count_id (prot_sampler, peer))
{
/* Make sure we 'know' about this peer */
- (void) Peers_insert_peer_check_liveliness (peer);
+ (void) Peers_issue_peer_liveliness_check (peer);
/* Establish a channel towards that peer to indicate we are going to send
* messages to it */
- Peers_indicate_sending_intention (peer);
- //Peers_issue_peer_liveliness_check (peer);
+ //Peers_indicate_sending_intention (peer);
}
}
+/**
+ * @brief If @a peer was unknown, check liveliness and insert it in view and
+ * sampler
+ *
+ * @param peer peer to insert
+ */
+static void
+got_peer (const struct GNUNET_PeerIdentity *peer)
+{
+ /* If we did not know this peer already, insert it into sampler and view */
+ if (GNUNET_YES == Peers_issue_peer_liveliness_check (peer))
+ {
+ Peers_schedule_operation (peer, insert_in_sampler);
+ Peers_schedule_operation (peer, insert_in_view_op);
+ }
+}
/**
* @brief Checks if there is a sending channel and if it is needed
GNUNET_free (rep_cls);
}
+
static void
destroy_cli_ctx (struct ClientContext *cli_ctx)
{
GNUNET_assert (NULL != cli_ctx);
+ if (NULL != cli_ctx->mq)
+ {
+ GNUNET_MQ_destroy (cli_ctx->mq);
+ }
if (NULL != cli_ctx->rep_cls_head)
{
LOG (GNUNET_ERROR_TYPE_WARNING,
* Updates sizes of sampler list and view and adapt those lists
* accordingly.
*/
- void
-nse_callback (void *cls, struct GNUNET_TIME_Absolute timestamp,
+static void
+nse_callback (void *cls,
+ struct GNUNET_TIME_Absolute timestamp,
double logestimate, double std_dev)
{
double estimate;
*
* Sends those to the requesting client.
*/
-void
+static void
client_respond (void *cls,
struct GNUNET_PeerIdentity *peer_ids,
uint32_t num_peers)
for (i = 0; i < num_peers; i++)
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
- " %lu: %s\n",
+ " %" PRIu32 ": %s\n",
i,
GNUNET_i2s (&peer_ids[i]));
}
GNUNET_assert (NULL != cli_ctx->rep_cls_head);
rep_cls = cli_ctx->rep_cls_head;
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Client cancels request with id %lu\n",
+ "Client cancels request with id %" PRIu32 "\n",
ntohl (msg->id));
while ( (NULL != rep_cls->next) &&
(rep_cls->id != ntohl (msg->id)) )
* @param client identification of the client
* @param message the actual message
*/
- static void
+static void
handle_client_seed (void *cls,
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
i,
GNUNET_i2s (&peers[i]));
- if (GNUNET_YES == Peers_insert_peer_check_liveliness (&peers[i]))
- {
- Peers_schedule_operation (&peers[i], insert_in_sampler);
- Peers_schedule_operation (&peers[i], insert_in_view);
- }
+ got_peer (&peers[i]);
//RPS_sampler_update (prot_sampler, &peers[i]);
//RPS_sampler_update (client_sampler, &peers[i]);
////GNUNET_free (peers);
GNUNET_SERVER_receive_done (client,
- GNUNET_OK);
+ GNUNET_OK);
}
*/
static int
handle_peer_push (void *cls,
- struct GNUNET_CADET_Channel *channel,
- void **channel_ctx,
- const struct GNUNET_MessageHeader *msg)
+ struct GNUNET_CADET_Channel *channel,
+ void **channel_ctx,
+ const struct GNUNET_MessageHeader *msg)
{
const struct GNUNET_PeerIdentity *peer;
GNUNET_CADET_channel_get_info (channel, GNUNET_CADET_OPTION_PEER);
// FIXME wait for cadet to change this function
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Received PUSH (%s)\n", GNUNET_i2s (peer));
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Received PUSH (%s)\n",
+ GNUNET_i2s (peer));
- #ifdef ENABLE_MALICIOUS
+#ifdef ENABLE_MALICIOUS
struct AttackedPeer *tmp_att_peer;
tmp_att_peer = GNUNET_new (struct AttackedPeer);
*/
static int
handle_peer_pull_request (void *cls,
- struct GNUNET_CADET_Channel *channel,
- void **channel_ctx,
- const struct GNUNET_MessageHeader *msg)
+ struct GNUNET_CADET_Channel *channel,
+ void **channel_ctx,
+ const struct GNUNET_MessageHeader *msg)
{
struct GNUNET_PeerIdentity *peer;
const struct GNUNET_PeerIdentity *view_array;
* @param channel_ctx The context associated with this channel
* @param msg The message header
*/
- static int
+static int
handle_peer_pull_reply (void *cls,
struct GNUNET_CADET_Channel *channel,
void **channel_ctx,
sizeof (struct GNUNET_PeerIdentity) != ntohl (in_msg->num_peers))
{
LOG (GNUNET_ERROR_TYPE_ERROR,
- "message says it sends %" PRIu32 " peers, have space for %i peers\n",
+ "message says it sends %" PRIu32 " peers, have space for %lu peers\n",
ntohl (in_msg->num_peers),
(ntohs (msg->size) - sizeof (struct GNUNET_RPS_P2P_PullReplyMessage)) /
sizeof (struct GNUNET_PeerIdentity));
&peers[i]))
{
/* Make sure we 'know' about this peer */
- (void) Peers_insert_peer_check_liveliness (&peers[i]);
+ (void) Peers_insert_peer (&peers[i]);
- if (GNUNET_YES == Peers_check_peer_flag (&peers[i], Peers_VALID))
+ if (GNUNET_YES == Peers_check_peer_valid (&peers[i]))
{
CustomPeerMap_put (pull_map, &peers[i]);
}
else
{
Peers_schedule_operation (&peers[i], insert_in_pull_map);
- Peers_issue_peer_liveliness_check (&peers[i]);
+ (void) Peers_issue_peer_liveliness_check (&peers[i]);
}
}
}
* @param spread the inverse amount of deviation from the mean
*/
static struct GNUNET_TIME_Relative
-compute_rand_delay (struct GNUNET_TIME_Relative mean, unsigned int spread)
+compute_rand_delay (struct GNUNET_TIME_Relative mean,
+ unsigned int spread)
{
struct GNUNET_TIME_Relative half_interval;
struct GNUNET_TIME_Relative ret;
static void
-do_round (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
+do_round (void *cls);
static void
-do_mal_round (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
+do_mal_round (void *cls);
#ifdef ENABLE_MALICIOUS
* @param client The client that sent the message
* @param msg The message header
*/
- static void
+static void
handle_client_act_malicious (void *cls,
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *msg)
sizeof (struct GNUNET_PeerIdentity) != ntohl (in_msg->num_peers))
{
LOG (GNUNET_ERROR_TYPE_ERROR,
- "message says it sends %" PRIu64 " peers, have space for %i peers\n",
+ "message says it sends %" PRIu32 " peers, have space for %lu peers\n",
ntohl (in_msg->num_peers),
(ntohs (msg->size) - sizeof (struct GNUNET_RPS_CS_ActMaliciousMessage)) /
sizeof (struct GNUNET_PeerIdentity));
/* Set the flag of the attacked peer to valid to avoid problems */
if (GNUNET_NO == Peers_check_peer_known (&attacked_peer))
{
- Peers_insert_peer_check_liveliness (&attacked_peer);
- Peers_issue_peer_liveliness_check (&attacked_peer);
+ (void) Peers_issue_peer_liveliness_check (&attacked_peer);
}
LOG (GNUNET_ERROR_TYPE_DEBUG,
{
GNUNET_break (0);
}
-
- GNUNET_SERVER_receive_done (client, GNUNET_OK);
+ GNUNET_SERVER_receive_done (client,
+ GNUNET_OK);
}
* This is executed regylary.
*/
static void
-do_mal_round (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_mal_round (void *cls)
{
uint32_t num_pushes;
uint32_t i;
struct GNUNET_TIME_Relative time_next_round;
struct AttackedPeer *tmp_att_peer;
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Going to execute next round maliciously type %" PRIu32 ".\n",
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Going to execute next round maliciously type %" PRIu32 ".\n",
mal_type);
do_round_task = NULL;
GNUNET_assert (mal_type <= 3);
* Send as many pushes to the attacked peer as possible
* That is one push per round as it will ignore more.
*/
- Peers_insert_peer_check_liveliness (&attacked_peer);
- if (GNUNET_YES == Peers_check_peer_flag (&attacked_peer, Peers_VALID))
+ (void) Peers_issue_peer_liveliness_check (&attacked_peer);
+ if (GNUNET_YES == Peers_check_peer_valid (&attacked_peer))
send_push (&attacked_peer);
}
/* Send PUSH to attacked peers */
if (GNUNET_YES == Peers_check_peer_known (&attacked_peer))
{
- Peers_insert_peer_check_liveliness (&attacked_peer);
- if (GNUNET_YES == Peers_check_peer_flag (&attacked_peer, Peers_VALID))
+ (void) Peers_issue_peer_liveliness_check (&attacked_peer);
+ if (GNUNET_YES == Peers_check_peer_valid (&attacked_peer))
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Goding to send push to attacked peer (%s)\n",
GNUNET_i2s (&attacked_peer));
send_push (&attacked_peer);
}
- else
- Peers_issue_peer_liveliness_check (&attacked_peer);
}
- else
- Peers_insert_peer_check_liveliness (&attacked_peer);
- Peers_issue_peer_liveliness_check (&attacked_peer);
+ (void) Peers_issue_peer_liveliness_check (&attacked_peer);
/* The maximum of pushes we're going to send this round */
num_pushes = GNUNET_MIN (GNUNET_MIN (push_limit - 1,
//do_round_task = GNUNET_SCHEDULER_add_delayed (round_interval, &do_mal_round,
//NULL);
GNUNET_assert (NULL == do_round_task);
- do_round_task = GNUNET_SCHEDULER_add_delayed (time_next_round, &do_mal_round, NULL);
+ do_round_task = GNUNET_SCHEDULER_add_delayed (time_next_round,
+ &do_mal_round, NULL);
LOG (GNUNET_ERROR_TYPE_DEBUG, "Finished round\n");
}
#endif /* ENABLE_MALICIOUS */
* This is executed regylary.
*/
static void
-do_round (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_round (void *cls)
{
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Going to execute next round.\n");
-
uint32_t i;
const struct GNUNET_PeerIdentity *view_array;
unsigned int *permut;
struct GNUNET_PeerIdentity peer;
struct GNUNET_PeerIdentity *update_peer;
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Going to execute next round.\n");
do_round_task = NULL;
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Printing view:\n");
CustomPeerMap_size (push_map));
for (i = 0; i < first_border; i++)
{
- View_put (CustomPeerMap_get_peer_by_index (push_map, permut[i]));
+ (void) insert_in_view (CustomPeerMap_get_peer_by_index (push_map,
+ permut[i]));
to_file (file_name_view_log,
"+%s\t(push list)",
GNUNET_i2s_full (&view_array[i]));
CustomPeerMap_size (pull_map));
for (i = first_border; i < second_border; i++)
{
- View_put (CustomPeerMap_get_peer_by_index (pull_map,
- permut[i - first_border]));
+ (void) insert_in_view (CustomPeerMap_get_peer_by_index (pull_map,
+ permut[i - first_border]));
to_file (file_name_view_log,
"+%s\t(pull list)",
GNUNET_i2s_full (&view_array[i]));
hist_update,
NULL,
final_size - second_border);
- num_hist_update_tasks = final_size - second_border;
// TODO change the peer_flags accordingly
for (i = 0; i < View_size (); i++)
time_next_round = compute_rand_delay (round_interval, 2);
/* Schedule next round */
- do_round_task = GNUNET_SCHEDULER_add_delayed (time_next_round, &do_round, NULL);
+ do_round_task = GNUNET_SCHEDULER_add_delayed (time_next_round,
+ &do_round, NULL);
LOG (GNUNET_ERROR_TYPE_DEBUG, "Finished round\n");
}
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Got peer_id %s from cadet\n",
GNUNET_i2s (peer));
- Peers_insert_peer_check_liveliness (peer);
- Peers_schedule_operation (peer, insert_in_sampler);
- Peers_schedule_operation (peer, insert_in_view);
+ got_peer (peer);
}
}
+/**
+ * @brief Iterator function over stored, valid peers.
+ *
+ * We initialise the sampler with those.
+ *
+ * @param cls the closure
+ * @param peer the peer id
+ * @return #GNUNET_YES if we should continue to
+ * iterate,
+ * #GNUNET_NO if not.
+ */
+static int
+valid_peers_iterator (void *cls,
+ const struct GNUNET_PeerIdentity *peer)
+{
+ if (NULL != peer)
+ {
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Got stored, valid peer %s\n",
+ GNUNET_i2s (peer));
+ got_peer (peer);
+ }
+ return GNUNET_YES;
+}
+
/**
* Iterator over peers from peerinfo.
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Got peer_id %s from peerinfo\n",
GNUNET_i2s (peer));
- Peers_insert_peer_check_liveliness (peer);
- Peers_schedule_operation (peer, insert_in_sampler);
- Peers_schedule_operation (peer, insert_in_view);
+ got_peer (peer);
}
}
* Task run during shutdown.
*
* @param cls unused
- * @param tc unused
*/
static void
-shutdown_task (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+shutdown_task (void *cls)
{
-
- LOG (GNUNET_ERROR_TYPE_DEBUG, "RPS is going down\n");
-
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "RPS is going down\n");
GNUNET_PEERINFO_notify_cancel (peerinfo_notify_handle);
GNUNET_PEERINFO_disconnect (peerinfo_handle);
CustomPeerMap_destroy (pull_map);
#ifdef ENABLE_MALICIOUS
struct AttackedPeer *tmp_att_peer;
+ GNUNET_free (file_name_view_log);
GNUNET_array_grow (mal_peers, num_mal_peers, 0);
if (NULL != mal_peer_set)
GNUNET_CONTAINER_multipeermap_destroy (mal_peer_set);
do_round_task = GNUNET_SCHEDULER_add_now (&do_round, NULL);
LOG (GNUNET_ERROR_TYPE_DEBUG, "Scheduled first round\n");
- GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
- &shutdown_task,
- NULL);
+ GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
+ NULL);
}
{
int size;
int out_size;
+ char* fn_valid_peers;
GNUNET_log_setup ("rps", GNUNET_error_type_to_string (GNUNET_ERROR_TYPE_DEBUG), NULL);
cfg = c;
GNUNET_SCHEDULER_shutdown ();
return;
}
- LOG (GNUNET_ERROR_TYPE_DEBUG, "INITSIZE is %" PRIu64 "\n", sampler_size_est_need);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "INITSIZE is %u\n", sampler_size_est_need);
+
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_filename (cfg,
+ "rps",
+ "FILENAME_VALID_PEERS",
+ &fn_valid_peers))
+ {
+ GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+ "rps", "FILENAME_VALID_PEERS");
+ }
View_create (4);
{&handle_peer_pull_reply , GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REPLY , 0},
{NULL, 0, 0}
};
-
const uint32_t ports[] = {GNUNET_RPS_CADET_PORT, 0}; // _PORT specified in src/rps/rps.h
cadet_handle = GNUNET_CADET_connect (cfg,
cls,
&cleanup_destroyed_channel,
cadet_handlers,
ports);
+
peerinfo_handle = GNUNET_PEERINFO_connect (cfg);
- Peers_initialise (cadet_handle, &own_identity);
+ Peers_initialise (fn_valid_peers, cadet_handle, &own_identity);
+ GNUNET_free (fn_valid_peers);
/* Initialise sampler */
struct GNUNET_TIME_Relative half_round_interval;
pull_map = CustomPeerMap_create (4);
- num_hist_update_tasks = 0;
-
-
LOG (GNUNET_ERROR_TYPE_DEBUG, "Requesting peers from CADET\n");
GNUNET_CADET_get_peers (cadet_handle, &init_peer_cb, NULL);
// TODO send push/pull to each of those peers?
+ // TODO read stored valid peers from last run
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Requesting stored valid peers\n");
+ Peers_get_valid_peers (valid_peers_iterator, NULL);
peerinfo_notify_handle = GNUNET_PEERINFO_notify (cfg,
GNUNET_NO,