/*
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
* @author Julius Bünger
*/
#include "platform.h"
+#include "gnunet_applications.h"
#include "gnunet_util_lib.h"
#include "gnunet_cadet_service.h"
#include "gnunet_peerinfo_service.h"
/***********************************************************************
- * Housekeeping with peers
+ * Housekeeping with clients
***********************************************************************/
/**
/**
* The client handle to send the reply to
*/
- struct GNUNET_SERVER_Client *client;
+ struct ClientContext *cli_ctx;
};
*/
struct ReplyCls *rep_cls_head;
struct ReplyCls *rep_cls_tail;
+
+ /**
+ * The client handle to send the reply to
+ */
+ struct GNUNET_SERVICE_Client *client;
};
/**
struct ClientContext *cli_ctx_tail;
/***********************************************************************
- * /Housekeeping with peers
+ * /Housekeeping with clients
***********************************************************************/
*/
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.
*
+ * Counts how many requets clients already issued.
* Only needed in the beginning to check how many of the 64 deltas
* we already have
*/
/**
* 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)
{
if (i < *list_size -1)
{ /* Not at the last entry -- shift peers left */
- memcpy (&tmp[i], &tmp[i +1],
+ memmove (&tmp[i], &tmp[i +1],
((*list_size) - i -1) * sizeof (struct GNUNET_PeerIdentity));
}
/* Remove last entry (should be now useless PeerID) */
/**
* 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;
if ( 1 < req_counter)
{
/* Shift last request deltas to the right */
- memcpy (&request_deltas[1],
+ memmove (&request_deltas[1],
request_deltas,
(req_counter - 1) * sizeof (struct GNUNET_TIME_Relative));
send_size * sizeof (struct GNUNET_PeerIdentity),
GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REPLY);
out_msg->num_peers = htonl (send_size);
- memcpy (&out_msg[1], peer_ids,
+ GNUNET_memcpy (&out_msg[1], peer_ids,
send_size * sizeof (struct GNUNET_PeerIdentity));
Peers_send_message (peer_id, ev, "PULL REPLY");
*
* 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 (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 This is called on peers from external sources (cadet, peerinfo, ...)
+ * If the peer is not known, liveliness check is issued and it is
+ * scheduled to be inserted in sampler and view.
+ *
+ * "External sources" refer to every source except the gossip.
+ *
+ * @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
static void
remove_peer (const struct GNUNET_PeerIdentity *peer)
{
- View_remove_peer (peer);
+ (void) View_remove_peer (peer);
CustomPeerMap_remove_peer (pull_map, peer);
CustomPeerMap_remove_peer (push_map, peer);
RPS_sampler_reinitialise_by_value (prot_sampler, peer);
{
if (GNUNET_NO == check_sending_channel_needed (peer))
{
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Going to remove send channel to peer %s\n",
+ GNUNET_i2s (peer));
#ifdef ENABLE_MALICIOUS
if (0 != GNUNET_CRYPTO_cmp_peer_identity (&attacked_peer, peer))
- Peers_destroy_sending_channel (peer);
+ (void) Peers_destroy_sending_channel (peer);
#else /* ENABLE_MALICIOUS */
- Peers_destroy_sending_channel (peer);
+ (void) Peers_destroy_sending_channel (peer);
#endif /* ENABLE_MALICIOUS */
}
(GNUNET_NO == CustomPeerMap_contains_peer (push_map, peer)) &&
(GNUNET_NO == CustomPeerMap_contains_peer (push_map, peer)) &&
(0 == RPS_sampler_count_id (prot_sampler, peer)) &&
- (0 == RPS_sampler_count_id (client_sampler, peer)) )
- { /* We can safely remov this peer */
+ (0 == RPS_sampler_count_id (client_sampler, peer)) &&
+ (GNUNET_NO != Peers_check_removable (peer)) )
+ { /* We can safely remove this peer */
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Going to remove peer %s\n",
+ GNUNET_i2s (peer));
remove_peer (peer);
return;
}
- Peers_clean_peer (peer);
}
/**
*
* 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.
*
* @param cls The closure
* @param channel The channel being closed
{
struct ClientContext *cli_ctx;
- cli_ctx = GNUNET_SERVER_client_get_user_context (rep_cls->client,
- struct ClientContext);
+ cli_ctx = rep_cls->cli_ctx;
GNUNET_assert (NULL != cli_ctx);
+ if (NULL != rep_cls->req_handle)
+ {
+ RPS_sampler_request_cancel (rep_cls->req_handle);
+ }
GNUNET_CONTAINER_DLL_remove (cli_ctx->rep_cls_head,
cli_ctx->rep_cls_tail,
rep_cls);
GNUNET_free (rep_cls);
}
+
static void
destroy_cli_ctx (struct ClientContext *cli_ctx)
{
* 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)
{
+ struct ReplyCls *reply_cls = cls;
uint32_t i;
struct GNUNET_MQ_Envelope *ev;
struct GNUNET_RPS_CS_ReplyMessage *out_msg;
- struct ReplyCls *reply_cls = (struct ReplyCls *) cls;
uint32_t size_needed;
struct ClientContext *cli_ctx;
for (i = 0; i < num_peers; i++)
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
- " %lu: %s\n",
+ " %" PRIu32 ": %s\n",
i,
GNUNET_i2s (&peer_ids[i]));
}
out_msg->num_peers = htonl (num_peers);
out_msg->id = htonl (reply_cls->id);
- memcpy (&out_msg[1],
+ GNUNET_memcpy (&out_msg[1],
peer_ids,
num_peers * sizeof (struct GNUNET_PeerIdentity));
GNUNET_free (peer_ids);
- cli_ctx = GNUNET_SERVER_client_get_user_context (reply_cls->client,
- struct ClientContext);
+ cli_ctx = reply_cls->cli_ctx;
GNUNET_assert (NULL != cli_ctx);
+ reply_cls->req_handle = NULL;
destroy_reply_cls (reply_cls);
GNUNET_MQ_send (cli_ctx->mq, ev);
}
*/
static void
handle_client_request (void *cls,
- struct GNUNET_SERVER_Client *client,
- const struct GNUNET_MessageHeader *message)
+ const struct GNUNET_RPS_CS_RequestMessage *msg)
{
- struct GNUNET_RPS_CS_RequestMessage *msg;
+ struct ClientContext *cli_ctx = cls;
uint32_t num_peers;
uint32_t size_needed;
struct ReplyCls *reply_cls;
uint32_t i;
- struct ClientContext *cli_ctx;
-
- msg = (struct GNUNET_RPS_CS_RequestMessage *) message;
num_peers = ntohl (msg->num_peers);
size_needed = sizeof (struct GNUNET_RPS_CS_RequestMessage) +
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Message received from client has size larger than expected\n");
- GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+ GNUNET_SERVICE_client_drop (cli_ctx->client);
return;
}
reply_cls = GNUNET_new (struct ReplyCls);
reply_cls->id = ntohl (msg->id);
- reply_cls->client = client;
+ reply_cls->cli_ctx = cli_ctx;
reply_cls->req_handle = RPS_sampler_get_n_rand_peers (client_sampler,
client_respond,
reply_cls,
num_peers);
- cli_ctx = GNUNET_SERVER_client_get_user_context (client, struct ClientContext);
GNUNET_assert (NULL != cli_ctx);
GNUNET_CONTAINER_DLL_insert (cli_ctx->rep_cls_head,
cli_ctx->rep_cls_tail,
reply_cls);
- GNUNET_SERVER_receive_done (client,
- GNUNET_OK);
+ GNUNET_SERVICE_client_continue (cli_ctx->client);
}
*/
static void
handle_client_request_cancel (void *cls,
- struct GNUNET_SERVER_Client *client,
- const struct GNUNET_MessageHeader *message)
+ const struct GNUNET_RPS_CS_RequestCancelMessage *msg)
{
- struct GNUNET_RPS_CS_RequestCancelMessage *msg =
- (struct GNUNET_RPS_CS_RequestCancelMessage *) message;
- struct ClientContext *cli_ctx;
+ struct ClientContext *cli_ctx = cls;
struct ReplyCls *rep_cls;
- cli_ctx = GNUNET_SERVER_client_get_user_context (client, struct ClientContext);
+ GNUNET_assert (NULL != cli_ctx);
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)) )
GNUNET_assert (rep_cls->id == ntohl (msg->id));
RPS_sampler_request_cancel (rep_cls->req_handle);
destroy_reply_cls (rep_cls);
- GNUNET_SERVER_receive_done (client,
- GNUNET_OK);
+ GNUNET_SERVICE_client_continue (cli_ctx->client);
+}
+
+
+/**
+ * @brief This function is called, when the client seeds peers.
+ * It verifies that @a msg is well-formed.
+ *
+ * @param cls the closure (#ClientContext)
+ * @param msg the message
+ * @return #GNUNET_OK if @a msg is well-formed
+ */
+static int
+check_client_seed (void *cls, const struct GNUNET_RPS_CS_SeedMessage *msg)
+{
+ struct ClientContext *cli_ctx = cls;
+ uint16_t msize = ntohs (msg->header.size);
+ uint32_t num_peers = ntohl (msg->num_peers);
+
+ msize -= sizeof (struct GNUNET_RPS_CS_SeedMessage);
+ if ( (msize / sizeof (struct GNUNET_PeerIdentity) != num_peers) ||
+ (msize % sizeof (struct GNUNET_PeerIdentity) != 0) )
+ {
+ GNUNET_break (0);
+ GNUNET_SERVICE_client_drop (cli_ctx->client);
+ return GNUNET_SYSERR;
+ }
+ return GNUNET_OK;
}
* @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)
+ const struct GNUNET_RPS_CS_SeedMessage *msg)
{
- struct GNUNET_RPS_CS_SeedMessage *in_msg;
+ struct ClientContext *cli_ctx = cls;
struct GNUNET_PeerIdentity *peers;
uint32_t num_peers;
uint32_t i;
- if (sizeof (struct GNUNET_RPS_CS_SeedMessage) > ntohs (message->size))
- {
- GNUNET_break_op (0);
- GNUNET_SERVER_receive_done (client,
- GNUNET_SYSERR);
- }
-
- in_msg = (struct GNUNET_RPS_CS_SeedMessage *) message;
- num_peers = ntohl (in_msg->num_peers);
- peers = (struct GNUNET_PeerIdentity *) &in_msg[1];
+ num_peers = ntohl (msg->num_peers);
+ peers = (struct GNUNET_PeerIdentity *) &msg[1];
//peers = GNUNET_new_array (num_peers, struct GNUNET_PeerIdentity);
- //memcpy (peers, &in_msg[1], num_peers * sizeof (struct GNUNET_PeerIdentity));
-
- if ((ntohs (message->size) - sizeof (struct GNUNET_RPS_CS_SeedMessage)) /
- sizeof (struct GNUNET_PeerIdentity) != num_peers)
- {
- GNUNET_break_op (0);
- GNUNET_SERVER_receive_done (client,
- GNUNET_SYSERR);
- return;
- }
+ //GNUNET_memcpy (peers, &in_msg[1], num_peers * sizeof (struct GNUNET_PeerIdentity));
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Client seeded peers:\n");
i,
GNUNET_i2s (&peers[i]));
- if (GNUNET_YES == Peers_insert_peer (&peers[i]))
- {
- Peers_schedule_operation (&peers[i], insert_in_sampler);
- Peers_schedule_operation (&peers[i], insert_in_view);
- }
-
- //RPS_sampler_update (prot_sampler, &peers[i]);
- //RPS_sampler_update (client_sampler, &peers[i]);
+ got_peer (&peers[i]);
}
////GNUNET_free (peers);
- GNUNET_SERVER_receive_done (client,
- GNUNET_OK);
+ GNUNET_SERVICE_client_continue (cli_ctx->client);
}
+/**
+ * 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.
+ *
+ * @param cls Closure
+ * @param channel The channel the CHECK was received over
+ * @param channel_ctx The context associated with this channel
+ * @param msg The message header
+ */
+static int
+handle_peer_check (void *cls,
+ struct GNUNET_CADET_Channel *channel,
+ void **channel_ctx,
+ const struct GNUNET_MessageHeader *msg)
+{
+ GNUNET_CADET_receive_done (channel);
+ return GNUNET_OK;
+}
/**
* Handle a PUSH message from another peer.
*/
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
struct AttackedPeer *tmp_att_peer;
- tmp_att_peer = GNUNET_new (struct AttackedPeer);
- memcpy (&tmp_att_peer->peer_id, peer, sizeof (struct GNUNET_PeerIdentity));
- if (1 == mal_type
- || 3 == mal_type)
+ if ( (1 == mal_type) ||
+ (3 == mal_type) )
{ /* Try to maximise representation */
+ tmp_att_peer = GNUNET_new (struct AttackedPeer);
+ GNUNET_memcpy (&tmp_att_peer->peer_id, peer, sizeof (struct GNUNET_PeerIdentity));
if (NULL == att_peer_set)
att_peer_set = GNUNET_CONTAINER_multipeermap_create (1, GNUNET_NO);
if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (att_peer_set,
tmp_att_peer);
add_peer_array_to_set (peer, 1, att_peer_set);
}
+ GNUNET_CADET_receive_done (channel);
return GNUNET_OK;
}
else if (2 == mal_type)
{ /* We attack one single well-known peer - simply ignore */
+ GNUNET_CADET_receive_done (channel);
return GNUNET_OK;
}
- else
- {
- GNUNET_free (tmp_att_peer);
- }
-
#endif /* ENABLE_MALICIOUS */
/* Add the sending peer to the push_map */
*/
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;
|| 3 == mal_type)
{ /* Try to maximise representation */
send_pull_reply (peer, mal_peers, num_mal_peers);
+ GNUNET_CADET_receive_done (channel);
return GNUNET_OK;
}
{
send_pull_reply (peer, mal_peers, num_mal_peers);
}
+ GNUNET_CADET_receive_done (channel);
return GNUNET_OK;
}
#endif /* ENABLE_MALICIOUS */
* @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));
{
LOG (GNUNET_ERROR_TYPE_WARNING,
"Received a pull reply from a peer we didn't request one from!\n");
- GNUNET_break_op (0);
GNUNET_CADET_receive_done (channel);
+ GNUNET_break_op (0);
return GNUNET_OK;
}
#ifdef ENABLE_MALICIOUS
// We shouldn't even receive pull replies as we're not sending
if (2 == mal_type)
+ {
+ GNUNET_CADET_receive_done (channel);
return GNUNET_OK;
+ }
#endif /* ENABLE_MALICIOUS */
/* Do actual logic */
/* Make sure we 'know' about this peer */
(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;
LOG (GNUNET_ERROR_TYPE_WARNING,
"Not accepting spread of 0\n");
GNUNET_break (0);
+ GNUNET_assert (0);
}
+ GNUNET_assert (0 != mean.rel_value_us);
/* Compute random time value between spread * mean and spread * mean */
half_interval = GNUNET_TIME_relative_divide (mean, spread);
* via multiplying round_interval with a 'fraction' (0 to value)/value
*/
rand_delay = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, max_rand_delay);
- ret = GNUNET_TIME_relative_multiply (mean, rand_delay);
+ ret = GNUNET_TIME_relative_saturating_multiply (mean, rand_delay);
ret = GNUNET_TIME_relative_divide (ret, max_rand_delay);
ret = GNUNET_TIME_relative_add (ret, half_interval);
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
+
+
+/**
+ * @brief This function is called, when the client tells us to act malicious.
+ * It verifies that @a msg is well-formed.
+ *
+ * @param cls the closure (#ClientContext)
+ * @param msg the message
+ * @return #GNUNET_OK if @a msg is well-formed
+ */
+static int
+check_client_act_malicious (void *cls,
+ const struct GNUNET_RPS_CS_ActMaliciousMessage *msg)
+{
+ struct ClientContext *cli_ctx = cls;
+ uint16_t msize = ntohs (msg->header.size);
+ uint32_t num_peers = ntohl (msg->num_peers);
+
+ msize -= sizeof (struct GNUNET_RPS_CS_ActMaliciousMessage);
+ if ( (msize / sizeof (struct GNUNET_PeerIdentity) != num_peers) ||
+ (msize % sizeof (struct GNUNET_PeerIdentity) != 0) )
+ {
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ "message says it sends %" PRIu32 " peers, have space for %lu peers\n",
+ ntohl (msg->num_peers),
+ (msize / sizeof (struct GNUNET_PeerIdentity)));
+ GNUNET_break (0);
+ GNUNET_SERVICE_client_drop (cli_ctx->client);
+ return GNUNET_SYSERR;
+ }
+ return GNUNET_OK;
+}
+
/**
* Turn RPS service to act 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)
+ const struct GNUNET_RPS_CS_ActMaliciousMessage *msg)
{
- struct GNUNET_RPS_CS_ActMaliciousMessage *in_msg;
+ struct ClientContext *cli_ctx = cls;
struct GNUNET_PeerIdentity *peers;
uint32_t num_mal_peers_sent;
uint32_t num_mal_peers_old;
- /* Check for protocol violation */
- if (sizeof (struct GNUNET_RPS_CS_ActMaliciousMessage) > ntohs (msg->size))
- {
- GNUNET_break_op (0);
- }
-
- in_msg = (struct GNUNET_RPS_CS_ActMaliciousMessage *) msg;
- if ((ntohs (msg->size) - sizeof (struct GNUNET_RPS_CS_ActMaliciousMessage)) /
- 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",
- ntohl (in_msg->num_peers),
- (ntohs (msg->size) - sizeof (struct GNUNET_RPS_CS_ActMaliciousMessage)) /
- sizeof (struct GNUNET_PeerIdentity));
- GNUNET_break_op (0);
- }
-
-
/* Do actual logic */
peers = (struct GNUNET_PeerIdentity *) &msg[1];
- mal_type = ntohl (in_msg->type);
+ mal_type = ntohl (msg->type);
if (NULL == mal_peer_set)
mal_peer_set = GNUNET_CONTAINER_multipeermap_create (1, GNUNET_NO);
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Now acting malicious type %" PRIu32 ", got %" PRIu32 " peers.\n",
mal_type,
- ntohl (in_msg->num_peers));
+ ntohl (msg->num_peers));
if (1 == mal_type)
{ /* Try to maximise representation */
/* Add other malicious peers to those we already know */
- num_mal_peers_sent = ntohl (in_msg->num_peers);
+ num_mal_peers_sent = ntohl (msg->num_peers);
num_mal_peers_old = num_mal_peers;
GNUNET_array_grow (mal_peers,
num_mal_peers,
num_mal_peers + num_mal_peers_sent);
- memcpy (&mal_peers[num_mal_peers_old],
+ GNUNET_memcpy (&mal_peers[num_mal_peers_old],
peers,
num_mal_peers_sent * sizeof (struct GNUNET_PeerIdentity));
{ /* Try to partition the network */
/* Add other malicious peers to those we already know */
- num_mal_peers_sent = ntohl (in_msg->num_peers) - 1;
+ num_mal_peers_sent = ntohl (msg->num_peers) - 1;
num_mal_peers_old = num_mal_peers;
GNUNET_array_grow (mal_peers,
num_mal_peers,
if (NULL != mal_peers &&
0 != num_mal_peers)
{
- memcpy (&mal_peers[num_mal_peers_old],
+ GNUNET_memcpy (&mal_peers[num_mal_peers_old],
peers,
num_mal_peers_sent * sizeof (struct GNUNET_PeerIdentity));
}
/* Store the one attacked peer */
- memcpy (&attacked_peer,
- &in_msg->attacked_peer,
+ GNUNET_memcpy (&attacked_peer,
+ &msg->attacked_peer,
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 (&attacked_peer);
- Peers_issue_peer_liveliness_check (&attacked_peer);
+ (void) Peers_issue_peer_liveliness_check (&attacked_peer);
}
LOG (GNUNET_ERROR_TYPE_DEBUG,
else
{
GNUNET_break (0);
+ GNUNET_SERVICE_client_continue (cli_ctx->client);
}
-
- GNUNET_SERVER_receive_done (client, GNUNET_OK);
+ GNUNET_SERVICE_client_continue (cli_ctx->client);
}
* 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 (&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_flag (&attacked_peer, Peers_ONLINE))
send_push (&attacked_peer);
}
/* Send PUSH to attacked peers */
if (GNUNET_YES == Peers_check_peer_known (&attacked_peer))
{
- Peers_insert_peer (&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_flag (&attacked_peer, Peers_ONLINE))
{
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 (&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");
peers_to_clean = NULL;
peers_to_clean_size = 0;
GNUNET_array_grow (peers_to_clean, peers_to_clean_size, View_size ());
- memcpy (peers_to_clean,
+ GNUNET_memcpy (peers_to_clean,
view_array,
View_size () * sizeof (struct GNUNET_PeerIdentity));
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++)
to_file (file_name_view_log,
"-%s",
GNUNET_i2s_full (&peers_to_clean[i]));
- Peers_clean_peer (&peers_to_clean[i]);
+ clean_peer (&peers_to_clean[i]);
//peer_destroy_channel_send (sender);
}
GNUNET_array_grow (peers_to_clean, peers_to_clean_size, 0);
- peers_to_clean = NULL;
}
else
{
"Updating with peer %s from push list\n",
GNUNET_i2s (update_peer));
insert_in_sampler (NULL, update_peer);
- Peers_clean_peer (update_peer); /* This cleans only if it is not in the view */
+ clean_peer (update_peer); /* This cleans only if it is not in the view */
//peer_destroy_channel_send (sender);
}
GNUNET_i2s (CustomPeerMap_get_peer_by_index (pull_map, i)));
insert_in_sampler (NULL, CustomPeerMap_get_peer_by_index (pull_map, i));
/* This cleans only if it is not in the view */
- Peers_clean_peer (CustomPeerMap_get_peer_by_index (pull_map, i));
+ clean_peer (CustomPeerMap_get_peer_by_index (pull_map, i));
//peer_destroy_channel_send (sender);
}
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");
}
-static void
-rps_start (struct GNUNET_SERVER_Handle *server);
-
-
/**
* This is called from GNUNET_CADET_get_peers().
*
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Got peer_id %s from cadet\n",
GNUNET_i2s (peer));
- Peers_insert_peer (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;
}
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Got peer_id %s from peerinfo\n",
GNUNET_i2s (peer));
- Peers_insert_peer (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)
{
+ struct ClientContext *client_ctx;
+ struct ReplyCls *reply_cls;
- LOG (GNUNET_ERROR_TYPE_DEBUG, "RPS is going down\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "RPS is going down\n");
+ /* Clean all clients */
+ for (client_ctx = cli_ctx_head;
+ NULL != cli_ctx_head;
+ client_ctx = cli_ctx_head)
+ {
+ /* Clean pending requests to the sampler */
+ for (reply_cls = client_ctx->rep_cls_head;
+ NULL != client_ctx->rep_cls_head;
+ reply_cls = client_ctx->rep_cls_head)
+ {
+ RPS_sampler_request_cancel (reply_cls->req_handle);
+ GNUNET_CONTAINER_DLL_remove (client_ctx->rep_cls_head,
+ client_ctx->rep_cls_tail,
+ reply_cls);
+ GNUNET_free (reply_cls);
+ }
+ GNUNET_MQ_destroy (client_ctx->mq);
+ GNUNET_CONTAINER_DLL_remove (cli_ctx_head, cli_ctx_tail, client_ctx);
+ GNUNET_free (client_ctx);
+ }
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);
/**
- * @brief Get informed about a connecting client.
+ * Handle client connecting to the service.
*
- * @param cls unused
- * @param client the client that connects
- */
-static void
-handle_client_connect (void *cls,
- struct GNUNET_SERVER_Client *client)
+ * @param cls NULL
+ * @param client the new client
+ * @param mq the message queue of @a client
+ * @return @a client
+ */
+static void *
+client_connect_cb (void *cls,
+ struct GNUNET_SERVICE_Client *client,
+ struct GNUNET_MQ_Handle *mq)
{
struct ClientContext *cli_ctx;
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Client connected\n");
if (NULL == client)
- return; /* Server was destroyed before a client connected. Shutting down */
+ return client; /* Server was destroyed before a client connected. Shutting down */
cli_ctx = GNUNET_new (struct ClientContext);
- cli_ctx->mq = GNUNET_MQ_queue_for_server_client (client);
- GNUNET_SERVER_client_set_user_context (client, cli_ctx);
+ cli_ctx->mq = GNUNET_SERVICE_client_get_mq (client);
+ cli_ctx->client = client;
GNUNET_CONTAINER_DLL_insert (cli_ctx_head,
cli_ctx_tail,
cli_ctx);
+ return cli_ctx;
}
/**
- * A client disconnected. Remove all of its data structure entries.
+ * Callback called when a client disconnected from the service
*
- * @param cls closure, NULL
- * @param client identification of the client
+ * @param cls closure for the service
+ * @param c the client that disconnected
+ * @param internal_cls should be equal to @a c
*/
static void
-handle_client_disconnect (void *cls,
- struct GNUNET_SERVER_Client *client)
+client_disconnect_cb (void *cls,
+ struct GNUNET_SERVICE_Client *client,
+ void *internal_cls)
{
- struct ClientContext *cli_ctx;
+ struct ClientContext *cli_ctx = internal_cls;
+ GNUNET_assert (client == cli_ctx->client);
if (NULL == client)
- {/* shutdown task */
+ {/* shutdown task - destroy all clients */
while (NULL != cli_ctx_head)
destroy_cli_ctx (cli_ctx_head);
}
else
- {
- cli_ctx = GNUNET_SERVER_client_get_user_context (client, struct ClientContext);
+ { /* destroy this client */
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Client disconnected. Destroy its context.\n");
destroy_cli_ctx (cli_ctx);
}
}
/**
- * Actually start the service.
- */
- static void
-rps_start (struct GNUNET_SERVER_Handle *server)
-{
- static const struct GNUNET_SERVER_MessageHandler handlers[] = {
- {&handle_client_request, NULL, GNUNET_MESSAGE_TYPE_RPS_CS_REQUEST,
- sizeof (struct GNUNET_RPS_CS_RequestMessage)},
- {&handle_client_request_cancel, NULL, GNUNET_MESSAGE_TYPE_RPS_CS_REQUEST_CANCEL,
- sizeof (struct GNUNET_RPS_CS_RequestCancelMessage)},
- {&handle_client_seed, NULL, GNUNET_MESSAGE_TYPE_RPS_CS_SEED, 0},
- #ifdef ENABLE_MALICIOUS
- {&handle_client_act_malicious, NULL, GNUNET_MESSAGE_TYPE_RPS_ACT_MALICIOUS , 0},
- #endif /* ENABLE_MALICIOUS */
- {NULL, NULL, 0, 0}
- };
-
- GNUNET_SERVER_add_handlers (server, handlers);
- GNUNET_SERVER_connect_notify (server,
- &handle_client_connect,
- NULL);
- GNUNET_SERVER_disconnect_notify (server,
- &handle_client_disconnect,
- NULL);
- LOG (GNUNET_ERROR_TYPE_INFO, "Ready to receive requests from clients\n");
-
-
- 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);
-}
-
-
-/**
- * Process statistics requests.
+ * Handle random peer sampling clients.
*
* @param cls closure
- * @param server the initialized server
* @param c configuration to use
+ * @param service the initialized service
*/
- static void
+static void
run (void *cls,
- struct GNUNET_SERVER_Handle *server,
- const struct GNUNET_CONFIGURATION_Handle *c)
+ const struct GNUNET_CONFIGURATION_Handle *c,
+ struct GNUNET_SERVICE_Handle *service)
{
+ static const struct GNUNET_CADET_MessageHandler cadet_handlers[] = {
+ {&handle_peer_check , GNUNET_MESSAGE_TYPE_RPS_PP_CHECK_LIVE,
+ sizeof (struct GNUNET_MessageHeader)},
+ {&handle_peer_push , GNUNET_MESSAGE_TYPE_RPS_PP_PUSH,
+ sizeof (struct GNUNET_MessageHeader)},
+ {&handle_peer_pull_request, GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REQUEST,
+ sizeof (struct GNUNET_MessageHeader)},
+ {&handle_peer_pull_reply , GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REPLY, 0},
+ {NULL, 0, 0}
+ };
+
int size;
int out_size;
+ char* fn_valid_peers;
+ struct GNUNET_HashCode port;
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);
/* Initialise cadet */
- static const struct GNUNET_CADET_MessageHandler cadet_handlers[] = {
- {&handle_peer_push , GNUNET_MESSAGE_TYPE_RPS_PP_PUSH ,
- sizeof (struct GNUNET_MessageHeader)},
- {&handle_peer_pull_request, GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REQUEST,
- sizeof (struct GNUNET_MessageHeader)},
- {&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,
- &Peers_handle_inbound_channel,
&cleanup_destroyed_channel,
- cadet_handlers,
- ports);
+ cadet_handlers);
+ GNUNET_assert (NULL != cadet_handle);
+ GNUNET_CRYPTO_hash (GNUNET_APPLICATION_PORT_RPS,
+ strlen (GNUNET_APPLICATION_PORT_RPS),
+ &port);
+ GNUNET_CADET_open_port (cadet_handle,
+ &port,
+ &Peers_handle_inbound_channel, cls);
+
+
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;
struct GNUNET_TIME_Relative max_round_interval;
- half_round_interval = GNUNET_TIME_relative_multiply (round_interval, .5);
+ half_round_interval = GNUNET_TIME_relative_divide (round_interval, 2);
max_round_interval = GNUNET_TIME_relative_add (round_interval, half_round_interval);
prot_sampler = RPS_sampler_init (sampler_size_est_need, max_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);
+ //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,
process_peerinfo_peers,
NULL);
- rps_start (server);
+ LOG (GNUNET_ERROR_TYPE_INFO, "Ready to receive requests from clients\n");
+
+ do_round_task = GNUNET_SCHEDULER_add_now (&do_round, NULL);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Scheduled first round\n");
+
+ GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
}
/**
- * The main function for the rps service.
- *
- * @param argc number of arguments from the command line
- * @param argv command line arguments
- * @return 0 ok, 1 on error
- */
-int
-main (int argc, char *const *argv)
-{
- return (GNUNET_OK ==
- GNUNET_SERVICE_run (argc,
- argv,
- "rps",
- GNUNET_SERVICE_OPTION_NONE,
- &run, NULL)) ? 0 : 1;
-}
+ * Define "main" method using service macro.
+ */
+GNUNET_SERVICE_MAIN
+("rps",
+ GNUNET_SERVICE_OPTION_NONE,
+ &run,
+ &client_connect_cb,
+ &client_disconnect_cb,
+ NULL,
+ GNUNET_MQ_hd_fixed_size (client_request,
+ GNUNET_MESSAGE_TYPE_RPS_CS_REQUEST,
+ struct GNUNET_RPS_CS_RequestMessage,
+ NULL),
+ GNUNET_MQ_hd_fixed_size (client_request_cancel,
+ GNUNET_MESSAGE_TYPE_RPS_CS_REQUEST_CANCEL,
+ struct GNUNET_RPS_CS_RequestCancelMessage,
+ NULL),
+ GNUNET_MQ_hd_var_size (client_seed,
+ GNUNET_MESSAGE_TYPE_RPS_CS_SEED,
+ struct GNUNET_RPS_CS_SeedMessage,
+ NULL),
+#ifdef ENABLE_MALICIOUS
+ GNUNET_MQ_hd_var_size (client_act_malicious,
+ GNUNET_MESSAGE_TYPE_RPS_ACT_MALICIOUS,
+ struct GNUNET_RPS_CS_ActMaliciousMessage,
+ NULL),
+#endif /* ENABLE_MALICIOUS */
+ GNUNET_MQ_handler_end());
/* end of gnunet-service-rps.c */
projects / oweals / gnunet.git / blobdiff