WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Affero General Public License for more details.
-
+
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+ SPDX-License-Identifier: AGPL3.0-or-later
*/
/**
#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 <math.h>
#include <inttypes.h>
+#include <string.h>
#define LOG(kind, ...) GNUNET_log(kind, __VA_ARGS__)
-// TODO modify @brief in every file
-
// TODO check for overflows
// TODO align message structs
// TODO connect to friends
-// TODO store peers somewhere persistent
-
// TODO blacklist? (-> mal peer detection on top of brahms)
// hist_size_init, hist_size_max
-/**
- * Our configuration.
- */
-static const struct GNUNET_CONFIGURATION_Handle *cfg;
-
-/**
- * Handle to the statistics service.
- */
-static struct GNUNET_STATISTICS_Handle *stats;
-
-/**
- * Our own identity.
- */
-static struct GNUNET_PeerIdentity own_identity;
-
-static int in_shutdown = GNUNET_NO;
-
-/**
- * @brief Port used for cadet.
- *
- * Don't compute multiple times through making it global
- */
-static struct GNUNET_HashCode port;
-
/***********************************************************************
* Old gnunet-service-rps_peers.c
***********************************************************************/
/**
* Set a peer flag of given peer context.
*/
-#define set_peer_flag(peer_ctx, mask) ((peer_ctx->peer_flags) |= (mask))
+#define SET_PEER_FLAG(peer_ctx, mask) ((peer_ctx->peer_flags) |= (mask))
/**
* Get peer flag of given peer context.
/**
* Unset flag of given peer context.
*/
-#define unset_peer_flag(peer_ctx, mask) ((peer_ctx->peer_flags) &= ~(mask))
+#define UNSET_PEER_FLAG(peer_ctx, mask) ((peer_ctx->peer_flags) &= ~(mask))
/**
* Get channel flag of given channel context.
* This is stored in a multipeermap.
* It contains information such as cadet channels, a message queue for sending,
* status about the channels, the pending operations on this peer and some flags
- * about the status of the peer itself. (live, valid, ...)
+ * about the status of the peer itself. (online, valid, ...)
*/
struct PeerContext
{
+ /**
+ * The Sub this context belongs to.
+ */
+ struct Sub *sub;
+
/**
* Message queue open to client
*/
*
* To be canceled on shutdown.
*/
- struct PendingMessage *liveliness_check_pending;
+ struct PendingMessage *online_check_pending;
/**
* Number of pending operations.
struct PendingMessage *pending_messages_head;
struct PendingMessage *pending_messages_tail;
- /**
- * @brief Task to destroy this context.
- */
- struct GNUNET_SCHEDULER_Task *destruction_task;
-
/**
* This is pobably followed by 'statistical' data (when we first saw
* it, how did we get its ID, how many pushes (in a timeinterval),
* ...)
*/
+ uint32_t round_pull_req;
};
/**
*/
struct ChannelCtx
{
- /**
- * @brief Meant to be used in a DLL
- */
- struct ChannelCtx *next;
- struct ChannelCtx *prev;
-
/**
* @brief The channel itself
*/
struct PeerContext *peer_ctx;
/**
- * @brief Scheduled task that will destroy this context
+ * @brief When channel destruction needs to be delayed (because it is called
+ * from within the cadet routine of another channel destruction) this task
+ * refers to the respective _SCHEDULER_Task.
*/
struct GNUNET_SCHEDULER_Task *destruction_task;
};
-/**
- * @brief Hashmap of valid peers.
- */
-static struct GNUNET_CONTAINER_MultiPeerMap *valid_peers;
-/**
- * @brief Maximum number of valid peers to keep.
- * TODO read from config
- */
-static uint32_t num_valid_peers_max = UINT32_MAX;
+#if ENABLE_MALICIOUS
/**
- * @brief Filename of the file that stores the valid peers persistently.
+ * If type is 2 This struct is used to store the attacked peers in a DLL
*/
-static char *filename_valid_peers;
+struct AttackedPeer
+{
+ /**
+ * DLL
+ */
+ struct AttackedPeer *next;
+ struct AttackedPeer *prev;
+
+ /**
+ * PeerID
+ */
+ struct GNUNET_PeerIdentity peer_id;
+};
+
+#endif /* ENABLE_MALICIOUS */
/**
- * Set of all peers to keep track of them.
+ * @brief This number determines the number of slots for files that represent
+ * histograms
*/
-static struct GNUNET_CONTAINER_MultiPeerMap *peer_map;
+#define HISTOGRAM_FILE_SLOTS 32
/**
- * Cadet handle.
+ * @brief The size (in bytes) a file needs to store the histogram
+ *
+ * Per slot: 1 newline, up to 4 chars,
+ * Additionally: 1 null termination
*/
-static struct GNUNET_CADET_Handle *cadet_handle;
-
-
+#define SIZE_DUMP_FILE (HISTOGRAM_FILE_SLOTS * 5) + 1
/**
- * @brief Get the #PeerContext associated with a peer
- *
- * @param peer the peer id
+ * @brief One Sub.
*
- * @return the #PeerContext
+ * Essentially one instance of brahms that only connects to other instances
+ * with the same (secret) value.
*/
-static struct PeerContext *
-get_peer_ctx (const struct GNUNET_PeerIdentity *peer)
+struct Sub
{
- struct PeerContext *ctx;
- int ret;
+ /**
+ * @brief Hash of the shared value that defines Subs.
+ */
+ struct GNUNET_HashCode hash;
- ret = GNUNET_CONTAINER_multipeermap_contains (peer_map, peer);
- GNUNET_assert (GNUNET_YES == ret);
- ctx = GNUNET_CONTAINER_multipeermap_get (peer_map, peer);
- GNUNET_assert (NULL != ctx);
- return ctx;
-}
+ /**
+ * @brief Port to communicate to other peers.
+ */
+ struct GNUNET_CADET_Port *cadet_port;
-int
-Peers_check_peer_known (const struct GNUNET_PeerIdentity *peer);
+ /**
+ * @brief Hashmap of valid peers.
+ */
+ struct GNUNET_CONTAINER_MultiPeerMap *valid_peers;
-/**
- * @brief Create a new #PeerContext and insert it into the peer map
- *
- * @param peer the peer to create the #PeerContext for
- *
- * @return the #PeerContext
- */
-static struct PeerContext *
-create_peer_ctx (const struct GNUNET_PeerIdentity *peer)
-{
- struct PeerContext *ctx;
- int ret;
+ /**
+ * @brief Filename of the file that stores the valid peers persistently.
+ */
+ char *filename_valid_peers;
- GNUNET_assert (GNUNET_NO == Peers_check_peer_known (peer));
+ /**
+ * Set of all peers to keep track of them.
+ */
+ struct GNUNET_CONTAINER_MultiPeerMap *peer_map;
- ctx = GNUNET_new (struct PeerContext);
- ctx->peer_id = *peer;
- ret = GNUNET_CONTAINER_multipeermap_put (peer_map, peer, ctx,
- GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
- GNUNET_assert (GNUNET_OK == ret);
- return ctx;
-}
+ /**
+ * @brief This is the minimum estimate used as sampler size.
+ *
+ * It is configured by the user.
+ */
+ unsigned int sampler_size_est_min;
+ /**
+ * The size of sampler we need to be able to satisfy the Brahms protocol's
+ * need of random peers.
+ *
+ * This is one minimum size the sampler grows to.
+ */
+ unsigned int sampler_size_est_need;
-/**
- * @brief Create or get a #PeerContext
- *
- * @param peer the peer to get the associated context to
- *
- * @return the context
- */
-static struct PeerContext *
-create_or_get_peer_ctx (const struct GNUNET_PeerIdentity *peer)
-{
- if (GNUNET_NO == Peers_check_peer_known (peer))
- {
- return create_peer_ctx (peer);
- }
- return get_peer_ctx (peer);
-}
+ /**
+ * Time interval the do_round task runs in.
+ */
+ struct GNUNET_TIME_Relative round_interval;
-void
-Peers_unset_peer_flag (const struct GNUNET_PeerIdentity *peer, enum Peers_PeerFlags flags);
+ /**
+ * Sampler used for the Brahms protocol itself.
+ */
+ struct RPS_Sampler *sampler;
-void
-Peers_set_peer_flag (const struct GNUNET_PeerIdentity *peer, enum Peers_PeerFlags flags);
+#ifdef TO_FILE_FULL
+ /**
+ * Name to log view to
+ */
+ char *file_name_view_log;
+#endif /* TO_FILE_FULL */
-/**
- * @brief Check whether we have a connection to this @a peer
- *
- * Also sets the #Peers_ONLINE flag accordingly
- *
- * @param peer the peer in question
- *
- * @return #GNUNET_YES if we are connected
- * #GNUNET_NO otherwise
- */
-int
-Peers_check_connected (const struct GNUNET_PeerIdentity *peer)
-{
- const struct PeerContext *peer_ctx;
+#ifdef TO_FILE
+#ifdef TO_FILE_FULL
+ /**
+ * Name to log number of observed peers to
+ */
+ char *file_name_observed_log;
+#endif /* TO_FILE_FULL */
- /* If we don't know about this peer we don't know whether it's online */
- if (GNUNET_NO == Peers_check_peer_known (peer))
- {
- return GNUNET_NO;
- }
- /* Get the context */
- peer_ctx = get_peer_ctx (peer);
- /* If we have no channel to this peer we don't know whether it's online */
- if ( (NULL == peer_ctx->send_channel_ctx) &&
- (NULL == peer_ctx->recv_channel_ctx) )
- {
- Peers_unset_peer_flag (peer, Peers_ONLINE);
- return GNUNET_NO;
- }
- /* Otherwise (if we have a channel, we know that it's online */
- Peers_set_peer_flag (peer, Peers_ONLINE);
- return GNUNET_YES;
-}
+ /**
+ * @brief Count the observed peers
+ */
+ uint32_t num_observed_peers;
+ /**
+ * @brief Multipeermap (ab-) used to count unique peer_ids
+ */
+ struct GNUNET_CONTAINER_MultiPeerMap *observed_unique_peers;
+#endif /* TO_FILE */
-/**
- * @brief The closure to #get_rand_peer_iterator.
- */
-struct GetRandPeerIteratorCls
-{
/**
- * @brief The index of the peer to return.
- * Will be decreased until 0.
- * Then current peer is returned.
+ * List to store peers received through pushes temporary.
*/
- uint32_t index;
+ struct CustomPeerMap *push_map;
/**
- * @brief Pointer to peer to return.
+ * List to store peers received through pulls temporary.
*/
- const struct GNUNET_PeerIdentity *peer;
+ struct CustomPeerMap *pull_map;
+
+ /**
+ * @brief This is the estimate used as view size.
+ *
+ * It is initialised with the minimum
+ */
+ unsigned int view_size_est_need;
+
+ /**
+ * @brief This is the minimum estimate used as view size.
+ *
+ * It is configured by the user.
+ */
+ unsigned int view_size_est_min;
+
+ /**
+ * @brief The view.
+ */
+ struct View *view;
+
+ /**
+ * Identifier for the main task that runs periodically.
+ */
+ struct GNUNET_SCHEDULER_Task *do_round_task;
+
+ /* === stats === */
+
+ /**
+ * @brief Counts the executed rounds.
+ */
+ uint32_t num_rounds;
+
+ /**
+ * @brief This array accumulates the number of received pushes per round.
+ *
+ * Number at index i represents the number of rounds with i observed pushes.
+ */
+ uint32_t push_recv[HISTOGRAM_FILE_SLOTS];
+
+ /**
+ * @brief Histogram of deltas between the expected and actual number of
+ * received pushes.
+ *
+ * As half of the entries are expected to be negative, this is shifted by
+ * #HISTOGRAM_FILE_SLOTS/2.
+ */
+ uint32_t push_delta[HISTOGRAM_FILE_SLOTS];
+
+ /**
+ * @brief Number of pull replies with this delay measured in rounds.
+ *
+ * Number at index i represents the number of pull replies with a delay of i
+ * rounds.
+ */
+ uint32_t pull_delays[HISTOGRAM_FILE_SLOTS];
};
+/***********************************************************************
+ * Globals
+***********************************************************************/
+
/**
- * @brief 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.
- *
- * @param cls the #GetRandPeerIteratorCls containing index and peer
- * @param peer current peer
- * @param value unused
- *
- * @return #GNUNET_YES if we should continue to
- * iterate,
- * #GNUNET_NO if not.
+ * Our configuration.
*/
-static int
-get_rand_peer_iterator (void *cls,
- const struct GNUNET_PeerIdentity *peer,
- void *value)
-{
- struct GetRandPeerIteratorCls *iterator_cls = cls;
- if (0 >= iterator_cls->index)
- {
- iterator_cls->peer = peer;
- return GNUNET_NO;
- }
- iterator_cls->index--;
- return GNUNET_YES;
-}
+static const struct GNUNET_CONFIGURATION_Handle *cfg;
+/**
+ * Handle to the statistics service.
+ */
+struct GNUNET_STATISTICS_Handle *stats;
/**
- * @brief Get a random peer from @a peer_map
- *
- * @param peer_map the peer_map to get the peer from
- *
- * @return a random peer
+ * Handler to CADET.
*/
-static const struct GNUNET_PeerIdentity *
-get_random_peer_from_peermap (const struct
- GNUNET_CONTAINER_MultiPeerMap *peer_map)
-{
- struct GetRandPeerIteratorCls *iterator_cls;
- const struct GNUNET_PeerIdentity *ret;
+struct GNUNET_CADET_Handle *cadet_handle;
- iterator_cls = GNUNET_new (struct GetRandPeerIteratorCls);
- iterator_cls->index = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
- GNUNET_CONTAINER_multipeermap_size (peer_map));
- (void) GNUNET_CONTAINER_multipeermap_iterate (valid_peers,
- get_rand_peer_iterator,
- iterator_cls);
- ret = iterator_cls->peer;
- GNUNET_free (iterator_cls);
- return ret;
-}
+/**
+ * Handle to CORE
+ */
+struct GNUNET_CORE_Handle *core_handle;
+/**
+ * @brief PeerMap to keep track of connected peers.
+ */
+struct GNUNET_CONTAINER_MultiPeerMap *map_single_hop;
/**
- * @brief Add a given @a peer to valid peers.
- *
- * If valid peers are already #num_valid_peers_max, delete a peer previously.
- *
- * @param peer the peer that is added to the valid peers.
- *
- * @return #GNUNET_YES if no other peer had to be removed
- * #GNUNET_NO otherwise
+ * Our own identity.
*/
-static int
-add_valid_peer (const struct GNUNET_PeerIdentity *peer)
-{
- const struct GNUNET_PeerIdentity *rand_peer;
- int ret;
+static struct GNUNET_PeerIdentity own_identity;
- ret = GNUNET_YES;
- while (GNUNET_CONTAINER_multipeermap_size (valid_peers) >= num_valid_peers_max)
- {
- rand_peer = get_random_peer_from_peermap (valid_peers);
- GNUNET_CONTAINER_multipeermap_remove_all (valid_peers, rand_peer);
- ret = GNUNET_NO;
- }
- (void) GNUNET_CONTAINER_multipeermap_put (valid_peers, peer, NULL,
- GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
- return ret;
-}
+/**
+ * Percentage of total peer number in the view
+ * to send random PUSHes to
+ */
+static float alpha;
-static void
-remove_pending_message (struct PendingMessage *pending_msg, int cancel);
+/**
+ * Percentage of total peer number in the view
+ * to send random PULLs to
+ */
+static float beta;
/**
- * @brief Set the peer flag to living and
- * call the pending operations on this peer.
- *
- * Also adds peer to #valid_peers.
- *
- * @param peer_ctx the #PeerContext of the peer to set live
+ * Handler to NSE.
*/
-static void
-set_peer_live (struct PeerContext *peer_ctx)
-{
- struct GNUNET_PeerIdentity *peer;
- unsigned int i;
+static struct GNUNET_NSE_Handle *nse;
- peer = &peer_ctx->peer_id;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Peer %s is live and valid, calling %i pending operations on it\n",
- GNUNET_i2s (peer),
- peer_ctx->num_pending_ops);
+/**
+ * Handler to PEERINFO.
+ */
+static struct GNUNET_PEERINFO_Handle *peerinfo_handle;
- if (NULL != peer_ctx->liveliness_check_pending)
- {
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Removing pending liveliness check for peer %s\n",
- GNUNET_i2s (&peer_ctx->peer_id));
- // TODO wait until cadet sets mq->cancel_impl
- //GNUNET_MQ_send_cancel (peer_ctx->liveliness_check_pending->ev);
- remove_pending_message (peer_ctx->liveliness_check_pending, GNUNET_YES);
- peer_ctx->liveliness_check_pending = NULL;
- }
+/**
+ * Handle for cancellation of iteration over peers.
+ */
+static struct GNUNET_PEERINFO_NotifyContext *peerinfo_notify_handle;
- (void) add_valid_peer (peer);
- set_peer_flag (peer_ctx, Peers_ONLINE);
- /* Call pending operations */
- for (i = 0; i < peer_ctx->num_pending_ops; i++)
- {
- peer_ctx->pending_ops[i].op (peer_ctx->pending_ops[i].op_cls, peer);
- }
- GNUNET_array_grow (peer_ctx->pending_ops, peer_ctx->num_pending_ops, 0);
-}
+#if ENABLE_MALICIOUS
+/**
+ * Type of malicious peer
+ *
+ * 0 Don't act malicious at all - Default
+ * 1 Try to maximise representation
+ * 2 Try to partition the network
+ * 3 Combined attack
+ */
+static uint32_t mal_type;
-static void
-cleanup_destroyed_channel (void *cls,
- const struct GNUNET_CADET_Channel *channel);
+/**
+ * Other malicious peers
+ */
+static struct GNUNET_PeerIdentity *mal_peers;
-/* Declaration of handlers */
-static void
-handle_peer_check (void *cls,
- const struct GNUNET_MessageHeader *msg);
+/**
+ * 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;
-static void
-handle_peer_push (void *cls,
- const struct GNUNET_MessageHeader *msg);
+/**
+ * Number of other malicious peers
+ */
+static uint32_t num_mal_peers;
-static void
-handle_peer_pull_request (void *cls,
- const struct GNUNET_MessageHeader *msg);
-static int
-check_peer_pull_reply (void *cls,
- const struct GNUNET_RPS_P2P_PullReplyMessage *msg);
+/**
+ * If type is 2 this is the DLL of attacked peers
+ */
+static struct AttackedPeer *att_peers_head;
+static struct AttackedPeer *att_peers_tail;
-static void
-handle_peer_pull_reply (void *cls,
- const struct GNUNET_RPS_P2P_PullReplyMessage *msg);
+/**
+ * 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;
-/* End declaration of handlers */
+/**
+ * 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;
/**
- * @brief Allocate memory for a new channel context and insert it into DLL
- *
- * @param peer_ctx context of the according peer
- *
- * @return The channel context
+ * Number of attacked peers
*/
-static struct ChannelCtx *
-add_channel_ctx (struct PeerContext *peer_ctx);
+static uint32_t num_attacked_peers;
+
+/**
+ * If type is 1 this is the attacked peer
+ */
+static struct GNUNET_PeerIdentity attacked_peer;
+
+/**
+ * The limit of PUSHes we can send in one round.
+ * This is an assumption of the Brahms protocol and either implemented
+ * via proof of work
+ * or
+ * assumend to be the bandwidth limitation.
+ */
+static uint32_t push_limit = 10000;
+#endif /* ENABLE_MALICIOUS */
/**
- * @brief Remove the channel context from the DLL and free the memory.
+ * @brief Main Sub.
*
- * @param channel_ctx The channel context.
+ * This is run in any case by all peers and connects to all peers without
+ * specifying a shared value.
+ */
+static struct Sub *msub;
+
+/**
+ * @brief Maximum number of valid peers to keep.
+ * TODO read from config
*/
+static const uint32_t num_valid_peers_max = UINT32_MAX;
+
+/***********************************************************************
+ * /Globals
+***********************************************************************/
+
+
+static void
+do_round (void *cls);
+
static void
-remove_channel_ctx (struct ChannelCtx *channel_ctx);
+do_mal_round (void *cls);
/**
- * @brief Get the channel of a peer. If not existing, create.
+ * @brief Get the #PeerContext associated with a peer
*
+ * @param peer_map The peer map containing the context
* @param peer the peer id
- * @return the #GNUNET_CADET_Channel used to send data to @a peer
+ *
+ * @return the #PeerContext
*/
-struct GNUNET_CADET_Channel *
-get_channel (const struct GNUNET_PeerIdentity *peer)
+static struct PeerContext *
+get_peer_ctx (const struct GNUNET_CONTAINER_MultiPeerMap *peer_map,
+ const struct GNUNET_PeerIdentity *peer)
{
- struct PeerContext *peer_ctx;
- struct GNUNET_PeerIdentity *ctx_peer;
- /* There exists a copy-paste-clone in run() */
- struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
- GNUNET_MQ_hd_fixed_size (peer_check,
- GNUNET_MESSAGE_TYPE_RPS_PP_CHECK_LIVE,
- struct GNUNET_MessageHeader,
- NULL),
- GNUNET_MQ_hd_fixed_size (peer_push,
- GNUNET_MESSAGE_TYPE_RPS_PP_PUSH,
- struct GNUNET_MessageHeader,
- NULL),
- GNUNET_MQ_hd_fixed_size (peer_pull_request,
- GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REQUEST,
- struct GNUNET_MessageHeader,
- NULL),
- GNUNET_MQ_hd_var_size (peer_pull_reply,
- GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REPLY,
- struct GNUNET_RPS_P2P_PullReplyMessage,
- NULL),
- GNUNET_MQ_handler_end ()
- };
+ struct PeerContext *ctx;
+ int ret;
+ ret = GNUNET_CONTAINER_multipeermap_contains (peer_map, peer);
+ GNUNET_assert (GNUNET_YES == ret);
+ ctx = GNUNET_CONTAINER_multipeermap_get (peer_map, peer);
+ GNUNET_assert (NULL != ctx);
+ return ctx;
+}
- peer_ctx = get_peer_ctx (peer);
- if (NULL == peer_ctx->send_channel_ctx)
+/**
+ * @brief Check whether we have information about the given peer.
+ *
+ * FIXME probably deprecated. Make this the new _online.
+ *
+ * @param peer_map The peer map to check for the existence of @a peer
+ * @param peer peer in question
+ *
+ * @return #GNUNET_YES if peer is known
+ * #GNUNET_NO if peer is not knwon
+ */
+static int
+check_peer_known (const struct GNUNET_CONTAINER_MultiPeerMap *peer_map,
+ const struct GNUNET_PeerIdentity *peer)
+{
+ if (NULL != peer_map)
{
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Trying to establish channel to peer %s\n",
- GNUNET_i2s (peer));
- ctx_peer = GNUNET_new (struct GNUNET_PeerIdentity);
- *ctx_peer = *peer;
- peer_ctx->send_channel_ctx = add_channel_ctx (peer_ctx);
- peer_ctx->send_channel_ctx->channel =
- GNUNET_CADET_channel_create (cadet_handle,
- peer_ctx->send_channel_ctx, /* context */
- peer,
- &port,
- GNUNET_CADET_OPTION_RELIABLE,
- NULL, /* WindowSize handler */
- cleanup_destroyed_channel, /* Disconnect handler */
- cadet_handlers);
+ return GNUNET_CONTAINER_multipeermap_contains (peer_map, peer);
+ }
+ else
+ {
+ return GNUNET_NO;
}
- GNUNET_assert (NULL != peer_ctx->send_channel_ctx);
- GNUNET_assert (NULL != peer_ctx->send_channel_ctx->channel);
- return peer_ctx->send_channel_ctx->channel;
}
/**
- * Get the message queue (#GNUNET_MQ_Handle) of a specific peer.
+ * @brief Create a new #PeerContext and insert it into the peer map
*
- * If we already have a message queue open to this client,
- * simply return it, otherways create one.
+ * @param sub The Sub this context belongs to.
+ * @param peer the peer to create the #PeerContext for
*
- * @param peer the peer to get the mq to
- * @return the #GNUNET_MQ_Handle
+ * @return the #PeerContext
*/
-static struct GNUNET_MQ_Handle *
-get_mq (const struct GNUNET_PeerIdentity *peer)
+static struct PeerContext *
+create_peer_ctx (struct Sub *sub,
+ const struct GNUNET_PeerIdentity *peer)
{
- struct PeerContext *peer_ctx;
+ struct PeerContext *ctx;
+ int ret;
- peer_ctx = get_peer_ctx (peer);
+ GNUNET_assert (GNUNET_NO == check_peer_known (sub->peer_map, peer));
- if (NULL == peer_ctx->mq)
+ ctx = GNUNET_new (struct PeerContext);
+ ctx->peer_id = *peer;
+ ctx->sub = sub;
+ ret = GNUNET_CONTAINER_multipeermap_put (sub->peer_map, peer, ctx,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+ GNUNET_assert (GNUNET_OK == ret);
+ if (sub == msub)
{
- peer_ctx->mq = GNUNET_CADET_get_mq (get_channel (peer));
+ GNUNET_STATISTICS_set (stats,
+ "# known peers",
+ GNUNET_CONTAINER_multipeermap_size (sub->peer_map),
+ GNUNET_NO);
}
- return peer_ctx->mq;
+ return ctx;
}
+
/**
- * @brief Add an envelope to a message passed to mq to list of pending messages
+ * @brief Create or get a #PeerContext
*
- * @param peer peer the message was sent to
- * @param ev envelope to the message
- * @param type type of the message to be sent
- * @return pointer to pending message
- */
-static struct PendingMessage *
-insert_pending_message (const struct GNUNET_PeerIdentity *peer,
- struct GNUNET_MQ_Envelope *ev,
- const char *type)
-{
- struct PendingMessage *pending_msg;
- struct PeerContext *peer_ctx;
-
- peer_ctx = get_peer_ctx (peer);
- pending_msg = GNUNET_new (struct PendingMessage);
- pending_msg->ev = ev;
- pending_msg->peer_ctx = peer_ctx;
- pending_msg->type = type;
- GNUNET_CONTAINER_DLL_insert (peer_ctx->pending_messages_head,
- peer_ctx->pending_messages_tail,
- pending_msg);
- return pending_msg;
-}
-
-
-/**
- * @brief Remove a pending message from the respective DLL
+ * @param sub The Sub to which the created context belongs to
+ * @param peer the peer to get the associated context to
*
- * @param pending_msg the pending message to remove
- * @param cancel cancel the pending message, too
+ * @return the context
*/
-static void
-remove_pending_message (struct PendingMessage *pending_msg, int cancel)
+static struct PeerContext *
+create_or_get_peer_ctx (struct Sub *sub,
+ const struct GNUNET_PeerIdentity *peer)
{
- struct PeerContext *peer_ctx;
-
- peer_ctx = pending_msg->peer_ctx;
- GNUNET_assert (NULL != peer_ctx);
- GNUNET_CONTAINER_DLL_remove (peer_ctx->pending_messages_head,
- peer_ctx->pending_messages_tail,
- pending_msg);
- // TODO wait for the cadet implementation of message cancellation
- //if (GNUNET_YES == cancel)
- //{
- // GNUNET_MQ_send_cancel (pending_msg->ev);
- //}
- GNUNET_free (pending_msg);
+ if (GNUNET_NO == check_peer_known (sub->peer_map, peer))
+ {
+ return create_peer_ctx (sub, peer);
+ }
+ return get_peer_ctx (sub->peer_map, peer);
}
/**
- * @brief This is called in response to the first message we sent as a
- * liveliness check.
+ * @brief Check whether we have a connection to this @a peer
+ *
+ * Also sets the #Peers_ONLINE flag accordingly
+ *
+ * @param peer_ctx Context of the peer of which connectivity is to be checked
*
- * @param cls #PeerContext of peer with pending liveliness check
+ * @return #GNUNET_YES if we are connected
+ * #GNUNET_NO otherwise
*/
-static void
-mq_liveliness_check_successful (void *cls)
+static int
+check_connected (struct PeerContext *peer_ctx)
{
- struct PeerContext *peer_ctx = cls;
-
- if (NULL != peer_ctx->liveliness_check_pending)
+ /* If we don't know about this peer we don't know whether it's online */
+ if (GNUNET_NO == check_peer_known (peer_ctx->sub->peer_map,
+ &peer_ctx->peer_id))
{
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Liveliness check for peer %s was successfull\n",
- GNUNET_i2s (&peer_ctx->peer_id));
- remove_pending_message (peer_ctx->liveliness_check_pending, GNUNET_YES);
- peer_ctx->liveliness_check_pending = NULL;
- set_peer_live (peer_ctx);
+ return GNUNET_NO;
+ }
+ /* Get the context */
+ peer_ctx = get_peer_ctx (peer_ctx->sub->peer_map, &peer_ctx->peer_id);
+ /* If we have no channel to this peer we don't know whether it's online */
+ if ( (NULL == peer_ctx->send_channel_ctx) &&
+ (NULL == peer_ctx->recv_channel_ctx) )
+ {
+ UNSET_PEER_FLAG (peer_ctx, Peers_ONLINE);
+ return GNUNET_NO;
}
+ /* Otherwise (if we have a channel, we know that it's online */
+ SET_PEER_FLAG (peer_ctx, Peers_ONLINE);
+ return GNUNET_YES;
}
+
/**
- * Issue a check whether peer is live
- *
- * @param peer_ctx the context of the peer
+ * @brief The closure to #get_rand_peer_iterator.
*/
-static void
-check_peer_live (struct PeerContext *peer_ctx)
+struct GetRandPeerIteratorCls
{
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Get informed about peer %s getting live\n",
- GNUNET_i2s (&peer_ctx->peer_id));
-
- struct GNUNET_MQ_Handle *mq;
- struct GNUNET_MQ_Envelope *ev;
+ /**
+ * @brief The index of the peer to return.
+ * Will be decreased until 0.
+ * Then current peer is returned.
+ */
+ uint32_t index;
- ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_RPS_PP_CHECK_LIVE);
- peer_ctx->liveliness_check_pending =
- insert_pending_message (&peer_ctx->peer_id, ev, "Check liveliness");
- mq = get_mq (&peer_ctx->peer_id);
- GNUNET_MQ_notify_sent (ev,
- mq_liveliness_check_successful,
- peer_ctx);
- GNUNET_MQ_send (mq, ev);
-}
+ /**
+ * @brief Pointer to peer to return.
+ */
+ const struct GNUNET_PeerIdentity *peer;
+};
/**
- * @brief 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.
+ * @brief Iterator function for #get_random_peer_from_peermap.
*
- * @param peer the peer to check
- * @param peer_op the operation (#PeerOp) on the peer
+ * Implements #GNUNET_CONTAINER_PeerMapIterator.
+ * Decreases the index until the index is null.
+ * Then returns the current peer.
*
- * @return #GNUNET_YES if this operation is scheduled on that peer
- * #GNUNET_NO otherwise
- */
-static int
-check_operation_scheduled (const struct GNUNET_PeerIdentity *peer,
- const PeerOp peer_op)
-{
- const struct PeerContext *peer_ctx;
- unsigned int i;
-
- peer_ctx = get_peer_ctx (peer);
- for (i = 0; i < peer_ctx->num_pending_ops; i++)
- if (peer_op == peer_ctx->pending_ops[i].op)
- return GNUNET_YES;
- return GNUNET_NO;
-}
-
-static int
-Peers_remove_peer (const struct GNUNET_PeerIdentity *peer);
-
-/**
- * Iterator over hash map entries. Deletes all contexts of peers.
+ * @param cls the #GetRandPeerIteratorCls containing index and peer
+ * @param peer current peer
+ * @param value unused
*
- * @param cls closure
- * @param key current public key
- * @param value value in the hash map
- * @return #GNUNET_YES if we should continue to iterate,
- * #GNUNET_NO if not.
+ * @return #GNUNET_YES if we should continue to
+ * iterate,
+ * #GNUNET_NO if not.
*/
static int
-peermap_clear_iterator (void *cls,
- const struct GNUNET_PeerIdentity *key,
+get_rand_peer_iterator (void *cls,
+ const struct GNUNET_PeerIdentity *peer,
void *value)
{
- Peers_remove_peer (key);
+ struct GetRandPeerIteratorCls *iterator_cls = cls;
+ (void) value;
+
+ if (0 >= iterator_cls->index)
+ {
+ iterator_cls->peer = peer;
+ return GNUNET_NO;
+ }
+ iterator_cls->index--;
return GNUNET_YES;
}
/**
- * @brief This is called once a message is sent.
+ * @brief Get a random peer from @a peer_map
*
- * Removes the pending message
+ * @param valid_peers Peer map containing valid peers from which to select a
+ * random one
*
- * @param cls type of the message that was sent
+ * @return a random peer
*/
-static void
-mq_notify_sent_cb (void *cls)
+static const struct GNUNET_PeerIdentity *
+get_random_peer_from_peermap (struct GNUNET_CONTAINER_MultiPeerMap *valid_peers)
{
- struct PendingMessage *pending_msg = (struct PendingMessage *) cls;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "%s was sent.\n",
- pending_msg->type);
- if (0 == strncmp ("PULL REPLY", pending_msg->type, 10))
- GNUNET_STATISTICS_update(stats, "# pull replys sent", 1, GNUNET_NO);
- if (0 == strncmp ("PULL REQUEST", pending_msg->type, 12))
- GNUNET_STATISTICS_update(stats, "# pull requests sent", 1, GNUNET_NO);
- if (0 == strncmp ("PUSH", pending_msg->type, 4))
- GNUNET_STATISTICS_update(stats, "# pushes sent", 1, GNUNET_NO);
- /* Do not cancle message */
- remove_pending_message (pending_msg, GNUNET_NO);
+ struct GetRandPeerIteratorCls *iterator_cls;
+ const struct GNUNET_PeerIdentity *ret;
+
+ iterator_cls = GNUNET_new (struct GetRandPeerIteratorCls);
+ iterator_cls->index = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+ GNUNET_CONTAINER_multipeermap_size (valid_peers));
+ (void) GNUNET_CONTAINER_multipeermap_iterate (valid_peers,
+ get_rand_peer_iterator,
+ iterator_cls);
+ ret = iterator_cls->peer;
+ GNUNET_free (iterator_cls);
+ return ret;
}
/**
- * @brief Iterator function for #store_valid_peers.
+ * @brief Add a given @a peer to valid peers.
*
- * Implements #GNUNET_CONTAINER_PeerMapIterator.
- * Writes single peer to disk.
+ * If valid peers are already #num_valid_peers_max, delete a peer previously.
*
- * @param cls the file handle to write to.
- * @param peer current peer
- * @param value unused
+ * @param peer The peer that is added to the valid peers.
+ * @param valid_peers Peer map of valid peers to which to add the @a peer
*
- * @return #GNUNET_YES if we should continue to
- * iterate,
- * #GNUNET_NO if not.
+ * @return #GNUNET_YES if no other peer had to be removed
+ * #GNUNET_NO otherwise
*/
static int
-store_peer_presistently_iterator (void *cls,
- const struct GNUNET_PeerIdentity *peer,
- void *value)
+add_valid_peer (const struct GNUNET_PeerIdentity *peer,
+ struct GNUNET_CONTAINER_MultiPeerMap *valid_peers)
{
- const struct GNUNET_DISK_FileHandle *fh = cls;
- char peer_string[128];
- int size;
- ssize_t ret;
+ const struct GNUNET_PeerIdentity *rand_peer;
+ int ret;
- if (NULL == peer)
+ ret = GNUNET_YES;
+ /* Remove random peers until there is space for a new one */
+ while (num_valid_peers_max <=
+ GNUNET_CONTAINER_multipeermap_size (valid_peers))
{
- return GNUNET_YES;
+ rand_peer = get_random_peer_from_peermap (valid_peers);
+ GNUNET_CONTAINER_multipeermap_remove_all (valid_peers, rand_peer);
+ ret = GNUNET_NO;
}
- size = GNUNET_snprintf (peer_string,
- sizeof (peer_string),
- "%s\n",
- GNUNET_i2s_full (peer));
- GNUNET_assert (53 == size);
- ret = GNUNET_DISK_file_write (fh,
- peer_string,
- size);
- GNUNET_assert (size == ret);
- return GNUNET_YES;
+ (void) GNUNET_CONTAINER_multipeermap_put (valid_peers, peer, NULL,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+ if (valid_peers == msub->valid_peers)
+ {
+ GNUNET_STATISTICS_set (stats,
+ "# valid peers",
+ GNUNET_CONTAINER_multipeermap_size (valid_peers),
+ GNUNET_NO);
+ }
+ return ret;
}
+static void
+remove_pending_message (struct PendingMessage *pending_msg, int cancel);
/**
- * @brief Store the peers currently in #valid_peers to disk.
+ * @brief Set the peer flag to living and
+ * call the pending operations on this peer.
+ *
+ * Also adds peer to #valid_peers.
+ *
+ * @param peer_ctx the #PeerContext of the peer to set online
*/
static void
-store_valid_peers ()
+set_peer_online (struct PeerContext *peer_ctx)
{
- struct GNUNET_DISK_FileHandle *fh;
- uint32_t number_written_peers;
- int ret;
+ struct GNUNET_PeerIdentity *peer;
+ unsigned int i;
- if (0 == strncmp ("DISABLE", filename_valid_peers, 7))
- {
- return;
- }
+ peer = &peer_ctx->peer_id;
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Peer %s is online and valid, calling %i pending operations on it\n",
+ GNUNET_i2s (peer),
+ peer_ctx->num_pending_ops);
- ret = GNUNET_DISK_directory_create_for_file (filename_valid_peers);
- if (GNUNET_SYSERR == ret)
+ if (NULL != peer_ctx->online_check_pending)
{
- LOG (GNUNET_ERROR_TYPE_WARNING,
- "Not able to create directory for file `%s'\n",
- filename_valid_peers);
- GNUNET_break (0);
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Removing pending online check for peer %s\n",
+ GNUNET_i2s (&peer_ctx->peer_id));
+ // TODO wait until cadet sets mq->cancel_impl
+ //GNUNET_MQ_send_cancel (peer_ctx->online_check_pending->ev);
+ remove_pending_message (peer_ctx->online_check_pending, GNUNET_YES);
+ peer_ctx->online_check_pending = NULL;
}
- else if (GNUNET_NO == ret)
+
+ SET_PEER_FLAG (peer_ctx, Peers_ONLINE);
+
+ /* Call pending operations */
+ for (i = 0; i < peer_ctx->num_pending_ops; i++)
{
- LOG (GNUNET_ERROR_TYPE_WARNING,
- "Directory for file `%s' exists but is not writable for us\n",
- filename_valid_peers);
- GNUNET_break (0);
+ peer_ctx->pending_ops[i].op (peer_ctx->pending_ops[i].op_cls, peer);
}
- fh = GNUNET_DISK_file_open (filename_valid_peers,
- GNUNET_DISK_OPEN_WRITE |
- GNUNET_DISK_OPEN_CREATE,
- GNUNET_DISK_PERM_USER_READ |
- GNUNET_DISK_PERM_USER_WRITE);
- if (NULL == fh)
- {
- LOG (GNUNET_ERROR_TYPE_WARNING,
- "Not able to write valid peers to file `%s'\n",
- filename_valid_peers);
- return;
- }
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Writing %u valid peers to disk\n",
- GNUNET_CONTAINER_multipeermap_size (valid_peers));
- number_written_peers =
- GNUNET_CONTAINER_multipeermap_iterate (valid_peers,
- store_peer_presistently_iterator,
- fh);
- GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
- GNUNET_assert (number_written_peers ==
- GNUNET_CONTAINER_multipeermap_size (valid_peers));
+ GNUNET_array_grow (peer_ctx->pending_ops, peer_ctx->num_pending_ops, 0);
}
+static void
+cleanup_destroyed_channel (void *cls,
+ const struct GNUNET_CADET_Channel *channel);
+
+/* Declaration of handlers */
+static void
+handle_peer_check (void *cls,
+ const struct GNUNET_MessageHeader *msg);
+
+static void
+handle_peer_push (void *cls,
+ const struct GNUNET_MessageHeader *msg);
+
+static void
+handle_peer_pull_request (void *cls,
+ const struct GNUNET_MessageHeader *msg);
+
+static int
+check_peer_pull_reply (void *cls,
+ const struct GNUNET_RPS_P2P_PullReplyMessage *msg);
+
+static void
+handle_peer_pull_reply (void *cls,
+ const struct GNUNET_RPS_P2P_PullReplyMessage *msg);
+
+/* End declaration of handlers */
/**
- * @brief Convert string representation of peer id to peer id.
- *
- * Counterpart to #GNUNET_i2s_full.
+ * @brief Allocate memory for a new channel context and insert it into DLL
*
- * @param string_repr The string representation of the peer id
+ * @param peer_ctx context of the according peer
*
- * @return The peer id
+ * @return The channel context
*/
-static const struct GNUNET_PeerIdentity *
-s2i_full (const char *string_repr)
+static struct ChannelCtx *
+add_channel_ctx (struct PeerContext *peer_ctx)
{
- struct GNUNET_PeerIdentity *peer;
- size_t len;
- int ret;
-
- peer = GNUNET_new (struct GNUNET_PeerIdentity);
- len = strlen (string_repr);
- if (52 > len)
- {
- LOG (GNUNET_ERROR_TYPE_WARNING,
- "Not able to convert string representation of PeerID to PeerID\n"
- "Sting representation: %s (len %lu) - too short\n",
- string_repr,
- len);
- GNUNET_break (0);
- }
- else if (52 < len)
- {
- len = 52;
- }
- ret = GNUNET_CRYPTO_eddsa_public_key_from_string (string_repr,
- len,
- &peer->public_key);
- if (GNUNET_OK != ret)
- {
- LOG (GNUNET_ERROR_TYPE_WARNING,
- "Not able to convert string representation of PeerID to PeerID\n"
- "Sting representation: %s\n",
- string_repr);
- GNUNET_break (0);
- }
- return peer;
+ struct ChannelCtx *channel_ctx;
+ channel_ctx = GNUNET_new (struct ChannelCtx);
+ channel_ctx->peer_ctx = peer_ctx;
+ return channel_ctx;
}
/**
- * @brief Restore the peers on disk to #valid_peers.
+ * @brief Free memory and NULL pointers.
+ *
+ * @param channel_ctx The channel context.
*/
static void
-restore_valid_peers ()
+remove_channel_ctx (struct ChannelCtx *channel_ctx)
{
- off_t file_size;
- uint32_t num_peers;
- struct GNUNET_DISK_FileHandle *fh;
- char *buf;
- ssize_t size_read;
- char *iter_buf;
- char *str_repr;
- const struct GNUNET_PeerIdentity *peer;
+ struct PeerContext *peer_ctx = channel_ctx->peer_ctx;
- if (0 == strncmp ("DISABLE", filename_valid_peers, 7))
+ if (NULL != channel_ctx->destruction_task)
{
- return;
+ GNUNET_SCHEDULER_cancel (channel_ctx->destruction_task);
+ channel_ctx->destruction_task = NULL;
}
- if (GNUNET_OK != GNUNET_DISK_file_test (filename_valid_peers))
- {
- return;
- }
- fh = GNUNET_DISK_file_open (filename_valid_peers,
- GNUNET_DISK_OPEN_READ,
- GNUNET_DISK_PERM_NONE);
- GNUNET_assert (NULL != fh);
- GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_handle_size (fh, &file_size));
- num_peers = file_size / 53;
- buf = GNUNET_malloc (file_size);
- size_read = GNUNET_DISK_file_read (fh, buf, file_size);
- GNUNET_assert (size_read == file_size);
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Restoring %" PRIu32 " peers from file `%s'\n",
- num_peers,
- filename_valid_peers);
- for (iter_buf = buf; iter_buf < buf + file_size - 1; iter_buf += 53)
+ GNUNET_free (channel_ctx);
+
+ if (NULL == peer_ctx) return;
+ if (channel_ctx == peer_ctx->send_channel_ctx)
{
- str_repr = GNUNET_strndup (iter_buf, 53);
- peer = s2i_full (str_repr);
- GNUNET_free (str_repr);
- add_valid_peer (peer);
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Restored valid peer %s from disk\n",
- GNUNET_i2s_full (peer));
+ peer_ctx->send_channel_ctx = NULL;
+ peer_ctx->mq = NULL;
}
- iter_buf = NULL;
- GNUNET_free (buf);
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "num_peers: %" PRIu32 ", _size (valid_peers): %u\n",
- num_peers,
- GNUNET_CONTAINER_multipeermap_size (valid_peers));
- if (num_peers != GNUNET_CONTAINER_multipeermap_size (valid_peers))
+ else if (channel_ctx == peer_ctx->recv_channel_ctx)
{
- LOG (GNUNET_ERROR_TYPE_WARNING,
- "Number of restored peers does not match file size. Have probably duplicates.\n");
+ peer_ctx->recv_channel_ctx = NULL;
}
- GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Restored %u valid peers from disk\n",
- GNUNET_CONTAINER_multipeermap_size (valid_peers));
}
/**
- * @brief Initialise storage of peers
+ * @brief Get the channel of a peer. If not existing, create.
*
- * @param fn_valid_peers filename of the file used to store valid peer ids
- * @param cadet_h cadet handle
- * @param own_id own peer identity
+ * @param peer_ctx Context of the peer of which to get the channel
+ * @return the #GNUNET_CADET_Channel used to send data to @a peer_ctx
*/
-void
-Peers_initialise (char* fn_valid_peers,
- struct GNUNET_CADET_Handle *cadet_h)
+struct GNUNET_CADET_Channel *
+get_channel (struct PeerContext *peer_ctx)
{
- filename_valid_peers = GNUNET_strdup (fn_valid_peers);
- cadet_handle = cadet_h;
- peer_map = GNUNET_CONTAINER_multipeermap_create (4, GNUNET_NO);
- valid_peers = GNUNET_CONTAINER_multipeermap_create (4, GNUNET_NO);
- restore_valid_peers ();
+ /* There exists a copy-paste-clone in run() */
+ struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
+ GNUNET_MQ_hd_fixed_size (peer_check,
+ GNUNET_MESSAGE_TYPE_RPS_PP_CHECK_LIVE,
+ struct GNUNET_MessageHeader,
+ NULL),
+ GNUNET_MQ_hd_fixed_size (peer_push,
+ GNUNET_MESSAGE_TYPE_RPS_PP_PUSH,
+ struct GNUNET_MessageHeader,
+ NULL),
+ GNUNET_MQ_hd_fixed_size (peer_pull_request,
+ GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REQUEST,
+ struct GNUNET_MessageHeader,
+ NULL),
+ GNUNET_MQ_hd_var_size (peer_pull_reply,
+ GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REPLY,
+ struct GNUNET_RPS_P2P_PullReplyMessage,
+ NULL),
+ GNUNET_MQ_handler_end ()
+ };
+
+
+ if (NULL == peer_ctx->send_channel_ctx)
+ {
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Trying to establish channel to peer %s\n",
+ GNUNET_i2s (&peer_ctx->peer_id));
+ peer_ctx->send_channel_ctx = add_channel_ctx (peer_ctx);
+ peer_ctx->send_channel_ctx->channel =
+ GNUNET_CADET_channel_create (cadet_handle,
+ peer_ctx->send_channel_ctx, /* context */
+ &peer_ctx->peer_id,
+ &peer_ctx->sub->hash,
+ GNUNET_CADET_OPTION_RELIABLE,
+ NULL, /* WindowSize handler */
+ &cleanup_destroyed_channel, /* Disconnect handler */
+ cadet_handlers);
+ }
+ GNUNET_assert (NULL != peer_ctx->send_channel_ctx);
+ GNUNET_assert (NULL != peer_ctx->send_channel_ctx->channel);
+ return peer_ctx->send_channel_ctx->channel;
}
/**
- * @brief Delete storage of peers that was created with #Peers_initialise ()
+ * 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.
+ *
+ * @param peer_ctx Context of the peer of whicht to get the mq
+ * @return the #GNUNET_MQ_Handle
*/
-static void
-peers_terminate ()
+static struct GNUNET_MQ_Handle *
+get_mq (struct PeerContext *peer_ctx)
{
- if (GNUNET_SYSERR ==
- GNUNET_CONTAINER_multipeermap_iterate (peer_map,
- &peermap_clear_iterator,
- NULL))
+ if (NULL == peer_ctx->mq)
{
- LOG (GNUNET_ERROR_TYPE_WARNING,
- "Iteration destroying peers was aborted.\n");
+ peer_ctx->mq = GNUNET_CADET_get_mq (get_channel (peer_ctx));
}
- GNUNET_CONTAINER_multipeermap_destroy (peer_map);
- peer_map = NULL;
- store_valid_peers ();
- GNUNET_free (filename_valid_peers);
- filename_valid_peers = NULL;
- GNUNET_CONTAINER_multipeermap_destroy (valid_peers);
- valid_peers = NULL;
+ return peer_ctx->mq;
}
-
/**
- * Iterator over #valid_peers hash map entries.
+ * @brief Add an envelope to a message passed to mq to list of pending messages
*
- * @param cls closure - unused
- * @param peer current peer id
- * @param value value in the hash map - unused
- * @return #GNUNET_YES if we should continue to
- * iterate,
- * #GNUNET_NO if not.
+ * @param peer_ctx Context of the peer for which to insert the envelope
+ * @param ev envelope to the message
+ * @param type type of the message to be sent
+ * @return pointer to pending message
*/
-static int
-valid_peer_iterator (void *cls,
- const struct GNUNET_PeerIdentity *peer,
- void *value)
+static struct PendingMessage *
+insert_pending_message (struct PeerContext *peer_ctx,
+ struct GNUNET_MQ_Envelope *ev,
+ const char *type)
{
- struct PeersIteratorCls *it_cls = cls;
+ struct PendingMessage *pending_msg;
- return it_cls->iterator (it_cls->cls,
- peer);
+ pending_msg = GNUNET_new (struct PendingMessage);
+ pending_msg->ev = ev;
+ pending_msg->peer_ctx = peer_ctx;
+ pending_msg->type = type;
+ GNUNET_CONTAINER_DLL_insert (peer_ctx->pending_messages_head,
+ peer_ctx->pending_messages_tail,
+ pending_msg);
+ return pending_msg;
}
/**
- * @brief Get all currently known, valid peer ids.
+ * @brief Remove a pending message from the respective DLL
*
- * @param it function to call on each peer id
- * @param it_cls extra argument to @a it
- * @return the number of key value pairs processed,
- * #GNUNET_SYSERR if it aborted iteration
+ * @param pending_msg the pending message to remove
+ * @param cancel whether to cancel the pending message, too
*/
-int
-Peers_get_valid_peers (PeersIterator iterator,
- void *it_cls)
+static void
+remove_pending_message (struct PendingMessage *pending_msg, int cancel)
{
- struct PeersIteratorCls *cls;
- int ret;
+ struct PeerContext *peer_ctx;
+ (void) cancel;
- cls = GNUNET_new (struct PeersIteratorCls);
- cls->iterator = iterator;
- cls->cls = it_cls;
- ret = GNUNET_CONTAINER_multipeermap_iterate (valid_peers,
- valid_peer_iterator,
- cls);
- GNUNET_free (cls);
- return ret;
+ peer_ctx = pending_msg->peer_ctx;
+ GNUNET_assert (NULL != peer_ctx);
+ GNUNET_CONTAINER_DLL_remove (peer_ctx->pending_messages_head,
+ peer_ctx->pending_messages_tail,
+ pending_msg);
+ // TODO wait for the cadet implementation of message cancellation
+ //if (GNUNET_YES == cancel)
+ //{
+ // GNUNET_MQ_send_cancel (pending_msg->ev);
+ //}
+ GNUNET_free (pending_msg);
}
/**
- * @brief Add peer to known peers.
- *
- * This function is called on new peer_ids from 'external' sources
- * (client seed, cadet get_peers(), ...)
- *
- * @param peer the new #GNUNET_PeerIdentity
+ * @brief This is called in response to the first message we sent as a
+ * online check.
*
- * @return #GNUNET_YES if peer was inserted
- * #GNUNET_NO otherwise
+ * @param cls #PeerContext of peer with pending online check
*/
-int
-Peers_insert_peer (const struct GNUNET_PeerIdentity *peer)
+static void
+mq_online_check_successful (void *cls)
{
- if (GNUNET_YES == Peers_check_peer_known (peer))
+ struct PeerContext *peer_ctx = cls;
+
+ if (NULL != peer_ctx->online_check_pending)
{
- return GNUNET_NO; /* We already know this peer - nothing to do */
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Online check for peer %s was successfull\n",
+ GNUNET_i2s (&peer_ctx->peer_id));
+ remove_pending_message (peer_ctx->online_check_pending, GNUNET_YES);
+ peer_ctx->online_check_pending = NULL;
+ set_peer_online (peer_ctx);
+ (void) add_valid_peer (&peer_ctx->peer_id, peer_ctx->sub->valid_peers);
}
- (void) create_peer_ctx (peer);
- return GNUNET_YES;
}
-int
-Peers_check_peer_flag (const struct GNUNET_PeerIdentity *peer, enum Peers_PeerFlags flags);
-
/**
- * @brief Try connecting to a peer to see whether it is online
- *
- * If not known yet, insert into known peers
+ * Issue a check whether peer is online
*
- * @param peer the peer whose liveliness is to be checked
- * @return #GNUNET_YES if peer had to be inserted
- * #GNUNET_NO otherwise
+ * @param peer_ctx the context of the peer
*/
-int
-Peers_issue_peer_liveliness_check (const struct GNUNET_PeerIdentity *peer)
+static void
+check_peer_online (struct PeerContext *peer_ctx)
{
- struct PeerContext *peer_ctx;
- int ret;
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Get informed about peer %s getting online\n",
+ GNUNET_i2s (&peer_ctx->peer_id));
+
+ struct GNUNET_MQ_Handle *mq;
+ struct GNUNET_MQ_Envelope *ev;
- ret = Peers_insert_peer (peer);
- peer_ctx = get_peer_ctx (peer);
- if ( (GNUNET_NO == Peers_check_peer_flag (peer, Peers_ONLINE)) &&
- (NULL == peer_ctx->liveliness_check_pending) )
+ ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_RPS_PP_CHECK_LIVE);
+ peer_ctx->online_check_pending =
+ insert_pending_message (peer_ctx, ev, "Check online");
+ mq = get_mq (peer_ctx);
+ GNUNET_MQ_notify_sent (ev,
+ mq_online_check_successful,
+ peer_ctx);
+ GNUNET_MQ_send (mq, ev);
+ if (peer_ctx->sub == msub)
{
- check_peer_live (peer_ctx);
+ GNUNET_STATISTICS_update (stats,
+ "# pending online checks",
+ 1,
+ GNUNET_NO);
}
- return ret;
}
/**
- * @brief Check if peer is removable.
+ * @brief Check whether function of type #PeerOp was already scheduled
*
- * Check if
- * - a recv channel exists
- * - there are pending messages
- * - there is no pending pull reply
+ * The array with pending operations will probably never grow really big, so
+ * iterating over it should be ok.
*
- * @param peer the peer in question
- * @return #GNUNET_YES if peer is removable
- * #GNUNET_NO if peer is NOT removable
- * #GNUNET_SYSERR if peer is not known
+ * @param peer_ctx Context of the peer to check for the operation
+ * @param peer_op the operation (#PeerOp) on the peer
+ *
+ * @return #GNUNET_YES if this operation is scheduled on that peer
+ * #GNUNET_NO otherwise
*/
-int
-Peers_check_removable (const struct GNUNET_PeerIdentity *peer)
+static int
+check_operation_scheduled (const struct PeerContext *peer_ctx,
+ const PeerOp peer_op)
{
- struct PeerContext *peer_ctx;
-
- if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (peer_map, peer))
- {
- return GNUNET_SYSERR;
- }
+ unsigned int i;
- peer_ctx = get_peer_ctx (peer);
- if ( (NULL != peer_ctx->recv_channel_ctx) ||
- (NULL != peer_ctx->pending_messages_head) ||
- (GNUNET_NO == check_peer_flag_set (peer_ctx, Peers_PULL_REPLY_PENDING)) )
- {
- return GNUNET_NO;
- }
- return GNUNET_YES;
+ for (i = 0; i < peer_ctx->num_pending_ops; i++)
+ if (peer_op == peer_ctx->pending_ops[i].op)
+ return GNUNET_YES;
+ return GNUNET_NO;
}
-uint32_t *
-Peers_get_channel_flag (const struct GNUNET_PeerIdentity *peer,
- enum Peers_ChannelRole role);
-
-int
-Peers_check_channel_flag (uint32_t *channel_flags, enum Peers_ChannelFlags flags);
/**
- * @brief Callback for the scheduler to destroy the knowledge of a peer.
+ * @brief Callback for scheduler to destroy a channel
*
- * @param cls Context of the peer
+ * @param cls Context of the channel
*/
static void
-destroy_peer (void *cls)
+destroy_channel (struct ChannelCtx *channel_ctx)
{
- struct PeerContext *peer_ctx = cls;
+ struct GNUNET_CADET_Channel *channel;
- GNUNET_assert (NULL != peer_ctx);
- peer_ctx->destruction_task = NULL;
- Peers_remove_peer (&peer_ctx->peer_id);
+ if (NULL != channel_ctx->destruction_task)
+ {
+ GNUNET_SCHEDULER_cancel (channel_ctx->destruction_task);
+ channel_ctx->destruction_task = NULL;
+ }
+ GNUNET_assert (channel_ctx->channel != NULL);
+ channel = channel_ctx->channel;
+ channel_ctx->channel = NULL;
+ GNUNET_CADET_channel_destroy (channel);
+ remove_channel_ctx (channel_ctx);
}
-static void
-destroy_channel (void *cls);
-
-
/**
- * @brief Schedule the destruction of the given channel.
+ * @brief Destroy a cadet channel.
*
- * Do so only if it was not already scheduled and not during shutdown.
+ * This satisfies the function signature of #GNUNET_SCHEDULER_TaskCallback.
*
- * @param channel_ctx The context of the channel to destroy.
+ * @param cls
*/
static void
-schedule_channel_destruction (struct ChannelCtx *channel_ctx)
+destroy_channel_cb (void *cls)
{
- GNUNET_assert (NULL != channel_ctx);
- if (NULL != channel_ctx->destruction_task &&
- GNUNET_NO == in_shutdown)
- {
- channel_ctx->destruction_task =
- GNUNET_SCHEDULER_add_now (&destroy_channel,
- channel_ctx);
- }
+ struct ChannelCtx *channel_ctx = cls;
+
+ channel_ctx->destruction_task = NULL;
+ destroy_channel (channel_ctx);
}
/**
- * @brief Schedule the destruction of the given peer.
+ * @brief Schedule the destruction of a channel for immediately afterwards.
*
- * Do so only if it was not already scheduled and not during shutdown.
+ * 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.
*
- * @param peer_ctx The context of the peer to destroy.
+ * @param channel_ctx channel to be destroyed.
*/
static void
-schedule_peer_destruction (struct PeerContext *peer_ctx)
+schedule_channel_destruction (struct ChannelCtx *channel_ctx)
{
- GNUNET_assert (NULL != peer_ctx);
- if (NULL != peer_ctx->destruction_task &&
- GNUNET_NO == in_shutdown)
- {
- peer_ctx->destruction_task =
- GNUNET_SCHEDULER_add_now (&destroy_peer,
- peer_ctx);
- }
+ GNUNET_assert (NULL ==
+ channel_ctx->destruction_task);
+ GNUNET_assert (NULL !=
+ channel_ctx->channel);
+ channel_ctx->destruction_task =
+ GNUNET_SCHEDULER_add_now (&destroy_channel_cb,
+ channel_ctx);
}
/**
* @brief Remove peer
*
- * @param peer the peer to clean
+ * - 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
+ *
+ * @param peer_ctx Context of the peer to be destroyed
* @return #GNUNET_YES if peer was removed
* #GNUNET_NO otherwise
*/
static int
-Peers_remove_peer (const struct GNUNET_PeerIdentity *peer)
+destroy_peer (struct PeerContext *peer_ctx)
{
- struct PeerContext *peer_ctx;
-
- GNUNET_assert (NULL != peer_map);
+ GNUNET_assert (NULL != peer_ctx);
+ GNUNET_assert (NULL != peer_ctx->sub->peer_map);
if (GNUNET_NO ==
- GNUNET_CONTAINER_multipeermap_contains (peer_map,
- peer))
+ GNUNET_CONTAINER_multipeermap_contains (peer_ctx->sub->peer_map,
+ &peer_ctx->peer_id))
{
return GNUNET_NO;
}
- peer_ctx = get_peer_ctx (peer);
- set_peer_flag (peer_ctx, Peers_TO_DESTROY);
+ SET_PEER_FLAG (peer_ctx, Peers_TO_DESTROY);
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Going to remove peer %s\n",
GNUNET_i2s (&peer_ctx->peer_id));
- Peers_unset_peer_flag (peer, Peers_ONLINE);
+ UNSET_PEER_FLAG (peer_ctx, Peers_ONLINE);
/* Clear list of pending operations */
// TODO this probably leaks memory
// ('only' the cls to the function. Not sure what to do with it)
GNUNET_array_grow (peer_ctx->pending_ops,
- peer_ctx->num_pending_ops,
- 0);
+ peer_ctx->num_pending_ops,
+ 0);
/* Remove all pending messages */
while (NULL != peer_ctx->pending_messages_head)
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Removing unsent %s\n",
- peer_ctx->pending_messages_head->type);
+ "Removing unsent %s\n",
+ peer_ctx->pending_messages_head->type);
/* Cancle pending message, too */
- if ( (NULL != peer_ctx->liveliness_check_pending) &&
+ if ( (NULL != peer_ctx->online_check_pending) &&
(0 == memcmp (peer_ctx->pending_messages_head,
- peer_ctx->liveliness_check_pending,
+ peer_ctx->online_check_pending,
sizeof (struct PendingMessage))) )
{
- // TODO this may leak memory
- peer_ctx->liveliness_check_pending = NULL;
+ peer_ctx->online_check_pending = NULL;
+ if (peer_ctx->sub == msub)
+ {
+ GNUNET_STATISTICS_update (stats,
+ "# pending online checks",
+ -1,
+ GNUNET_NO);
+ }
}
remove_pending_message (peer_ctx->pending_messages_head,
- GNUNET_YES);
+ GNUNET_YES);
}
- /* If we are still waiting for notification whether this peer is live
+ /* If we are still waiting for notification whether this peer is online
* cancel the according task */
- if (NULL != peer_ctx->liveliness_check_pending)
+ if (NULL != peer_ctx->online_check_pending)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Removing pending liveliness check for peer %s\n",
- GNUNET_i2s (&peer_ctx->peer_id));
+ "Removing pending online check for peer %s\n",
+ GNUNET_i2s (&peer_ctx->peer_id));
// TODO wait until cadet sets mq->cancel_impl
- //GNUNET_MQ_send_cancel (peer_ctx->liveliness_check_pending->ev);
- remove_pending_message (peer_ctx->liveliness_check_pending,
- GNUNET_YES);
- peer_ctx->liveliness_check_pending = NULL;
+ //GNUNET_MQ_send_cancel (peer_ctx->online_check_pending->ev);
+ remove_pending_message (peer_ctx->online_check_pending,
+ GNUNET_YES);
+ peer_ctx->online_check_pending = NULL;
}
-
- /* Do we still have to wait for destruction of channels
- * or issue the destruction? */
- if (NULL != peer_ctx->send_channel_ctx &&
- NULL != peer_ctx->send_channel_ctx->destruction_task)
- {
- schedule_peer_destruction (peer_ctx);
- return GNUNET_NO;
- }
- if (NULL != peer_ctx->recv_channel_ctx &&
- NULL != peer_ctx->recv_channel_ctx->destruction_task)
- {
- schedule_peer_destruction (peer_ctx);
- return GNUNET_NO;
- }
- if (NULL != peer_ctx->recv_channel_ctx)
- {
- schedule_channel_destruction (peer_ctx->recv_channel_ctx);
- schedule_peer_destruction (peer_ctx);
- return GNUNET_NO;
- }
if (NULL != peer_ctx->send_channel_ctx)
{
+ /* This is possibly called from within channel destruction */
+ peer_ctx->send_channel_ctx->peer_ctx = NULL;
schedule_channel_destruction (peer_ctx->send_channel_ctx);
- schedule_peer_destruction (peer_ctx);
- return GNUNET_NO;
+ peer_ctx->send_channel_ctx = NULL;
+ peer_ctx->mq = NULL;
}
-
- if (NULL != peer_ctx->destruction_task)
+ if (NULL != peer_ctx->recv_channel_ctx)
{
- GNUNET_SCHEDULER_cancel (peer_ctx->destruction_task);
+ /* This is possibly called from within channel destruction */
+ peer_ctx->recv_channel_ctx->peer_ctx = NULL;
+ schedule_channel_destruction (peer_ctx->recv_channel_ctx);
+ peer_ctx->recv_channel_ctx = NULL;
}
if (GNUNET_YES !=
- GNUNET_CONTAINER_multipeermap_remove_all (peer_map,
- &peer_ctx->peer_id))
+ GNUNET_CONTAINER_multipeermap_remove_all (peer_ctx->sub->peer_map,
+ &peer_ctx->peer_id))
{
LOG (GNUNET_ERROR_TYPE_WARNING,
- "removing peer from peer_map failed\n");
+ "removing peer from peer_ctx->sub->peer_map failed\n");
+ }
+ if (peer_ctx->sub == msub)
+ {
+ GNUNET_STATISTICS_set (stats,
+ "# known peers",
+ GNUNET_CONTAINER_multipeermap_size (peer_ctx->sub->peer_map),
+ GNUNET_NO);
}
GNUNET_free (peer_ctx);
return GNUNET_YES;
/**
- * @brief set flags on a given peer.
- *
- * @param peer the peer to set flags on
- * @param flags the flags
- */
-void
-Peers_set_peer_flag (const struct GNUNET_PeerIdentity *peer, enum Peers_PeerFlags flags)
-{
- struct PeerContext *peer_ctx;
-
- peer_ctx = get_peer_ctx (peer);
- set_peer_flag (peer_ctx, flags);
-}
-
-
-/**
- * @brief unset flags on a given peer.
+ * Iterator over hash map entries. Deletes all contexts of peers.
*
- * @param peer the peer to unset flags on
- * @param flags the flags
+ * @param cls closure
+ * @param key current public key
+ * @param value value in the hash map
+ * @return #GNUNET_YES if we should continue to iterate,
+ * #GNUNET_NO if not.
*/
-void
-Peers_unset_peer_flag (const struct GNUNET_PeerIdentity *peer, enum Peers_PeerFlags flags)
+static int
+peermap_clear_iterator (void *cls,
+ const struct GNUNET_PeerIdentity *key,
+ void *value)
{
- struct PeerContext *peer_ctx;
+ struct Sub *sub = cls;
+ (void) value;
- peer_ctx = get_peer_ctx (peer);
- unset_peer_flag (peer_ctx, flags);
+ destroy_peer (get_peer_ctx (sub->peer_map, key));
+ return GNUNET_YES;
}
/**
- * @brief Check whether flags on a peer are set.
- *
- * @param peer the peer to check the flag of
- * @param flags the flags to check
- *
- * @return #GNUNET_SYSERR if peer is not known
- * #GNUNET_YES if all given flags are set
- * #GNUNET_NO otherwise
- */
-int
-Peers_check_peer_flag (const struct GNUNET_PeerIdentity *peer, enum Peers_PeerFlags flags)
-{
- struct PeerContext *peer_ctx;
-
- if (GNUNET_NO == Peers_check_peer_known (peer))
- {
- return GNUNET_SYSERR;
- }
- peer_ctx = get_peer_ctx (peer);
- return check_peer_flag_set (peer_ctx, flags);
-}
-
-/**
- * @brief Check whether we have information about the given peer.
- *
- * FIXME probably deprecated. Make this the new _online.
+ * @brief This is called once a message is sent.
*
- * @param peer peer in question
+ * Removes the pending message
*
- * @return #GNUNET_YES if peer is known
- * #GNUNET_NO if peer is not knwon
+ * @param cls type of the message that was sent
*/
-int
-Peers_check_peer_known (const struct GNUNET_PeerIdentity *peer)
+static void
+mq_notify_sent_cb (void *cls)
{
- if (NULL != peer_map)
- {
- return GNUNET_CONTAINER_multipeermap_contains (peer_map, peer);
- } else
+ struct PendingMessage *pending_msg = (struct PendingMessage *) cls;
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "%s was sent.\n",
+ pending_msg->type);
+ if (pending_msg->peer_ctx->sub == msub)
{
- return GNUNET_NO;
+ if (0 == strncmp ("PULL REPLY", pending_msg->type, 10))
+ GNUNET_STATISTICS_update(stats, "# pull replys sent", 1, GNUNET_NO);
+ if (0 == strncmp ("PULL REQUEST", pending_msg->type, 12))
+ GNUNET_STATISTICS_update(stats, "# pull requests sent", 1, GNUNET_NO);
+ if (0 == strncmp ("PUSH", pending_msg->type, 4))
+ GNUNET_STATISTICS_update(stats, "# pushes sent", 1, GNUNET_NO);
+ if (0 == strncmp ("PULL REQUEST", pending_msg->type, 12) &&
+ NULL != map_single_hop &&
+ GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (map_single_hop,
+ &pending_msg->peer_ctx->peer_id))
+ GNUNET_STATISTICS_update(stats,
+ "# pull requests sent (multi-hop peer)",
+ 1,
+ GNUNET_NO);
}
+ /* Do not cancle message */
+ remove_pending_message (pending_msg, GNUNET_NO);
}
/**
- * @brief Check whether @a peer is actually a peer.
- *
- * A valid peer is a peer that we know exists eg. we were connected to once.
- *
- * @param peer peer in question
- *
- * @return #GNUNET_YES if peer is valid
- * #GNUNET_NO if peer is not valid
- */
-int
-Peers_check_peer_valid (const struct GNUNET_PeerIdentity *peer)
-{
- return GNUNET_CONTAINER_multipeermap_contains (valid_peers, peer);
-}
-
-
-/**
- * @brief Indicate that we want to send to the other peer
- *
- * This establishes a sending channel
+ * @brief Iterator function for #store_valid_peers.
*
- * @param peer the peer to establish channel to
- */
-void
-Peers_indicate_sending_intention (const struct GNUNET_PeerIdentity *peer)
-{
- GNUNET_assert (GNUNET_YES == Peers_check_peer_known (peer));
- (void) get_channel (peer);
-}
-
-
-/**
- * @brief Check whether other peer has the intention to send/opened channel
- * towars us
+ * Implements #GNUNET_CONTAINER_PeerMapIterator.
+ * Writes single peer to disk.
*
- * @param peer the peer in question
+ * @param cls the file handle to write to.
+ * @param peer current peer
+ * @param value unused
*
- * @return #GNUNET_YES if peer has the intention to send
- * #GNUNET_NO otherwise
+ * @return #GNUNET_YES if we should continue to
+ * iterate,
+ * #GNUNET_NO if not.
*/
-int
-Peers_check_peer_send_intention (const struct GNUNET_PeerIdentity *peer)
+static int
+store_peer_presistently_iterator (void *cls,
+ const struct GNUNET_PeerIdentity *peer,
+ void *value)
{
- const struct PeerContext *peer_ctx;
+ const struct GNUNET_DISK_FileHandle *fh = cls;
+ char peer_string[128];
+ int size;
+ ssize_t ret;
+ (void) value;
- peer_ctx = get_peer_ctx (peer);
- if (NULL != peer_ctx->recv_channel_ctx)
+ if (NULL == peer)
{
return GNUNET_YES;
}
- return GNUNET_NO;
+ size = GNUNET_snprintf (peer_string,
+ sizeof (peer_string),
+ "%s\n",
+ GNUNET_i2s_full (peer));
+ GNUNET_assert (53 == size);
+ ret = GNUNET_DISK_file_write (fh,
+ peer_string,
+ size);
+ GNUNET_assert (size == ret);
+ return GNUNET_YES;
}
/**
- * Handle the channel a peer opens to us.
- *
- * @param cls The closure
- * @param channel The channel the peer wants to establish
- * @param initiator The peer's peer ID
+ * @brief Store the peers currently in #valid_peers to disk.
*
- * @return initial channel context for the channel
- * (can be NULL -- that's not an error)
+ * @param sub Sub for which to store the valid peers
*/
-void *
-Peers_handle_inbound_channel (void *cls,
- struct GNUNET_CADET_Channel *channel,
- const struct GNUNET_PeerIdentity *initiator)
+static void
+store_valid_peers (const struct Sub *sub)
{
- struct PeerContext *peer_ctx;
- struct GNUNET_PeerIdentity *ctx_peer;
- struct ChannelCtx *channel_ctx;
+ struct GNUNET_DISK_FileHandle *fh;
+ uint32_t number_written_peers;
+ int ret;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "New channel was established to us (Peer %s).\n",
- GNUNET_i2s (initiator));
- GNUNET_assert (NULL != channel); /* according to cadet API */
- /* Make sure we 'know' about this peer */
- peer_ctx = create_or_get_peer_ctx (initiator);
- set_peer_live (peer_ctx);
- ctx_peer = GNUNET_new (struct GNUNET_PeerIdentity);
- *ctx_peer = *initiator;
- channel_ctx = add_channel_ctx (peer_ctx);
- channel_ctx->channel = channel;
- /* We only accept one incoming channel per peer */
- if (GNUNET_YES == Peers_check_peer_send_intention (initiator))
+ if (0 == strncmp ("DISABLE", sub->filename_valid_peers, 7))
{
- LOG (GNUNET_ERROR_TYPE_WARNING,
- "Already got one receive channel. Destroying old one.\n");
- GNUNET_break_op (0);
- GNUNET_CADET_channel_destroy (peer_ctx->recv_channel_ctx->channel);
- peer_ctx->recv_channel_ctx->channel = NULL;
- remove_channel_ctx (peer_ctx->recv_channel_ctx);
- peer_ctx->recv_channel_ctx = channel_ctx;
- /* return the channel context */
- return channel_ctx;
+ return;
}
- peer_ctx->recv_channel_ctx = channel_ctx;
- return channel_ctx;
-}
-
-
-/**
- * @brief Check whether a sending channel towards the given peer exists
- *
- * @param peer the peer to check for
- *
- * @return #GNUNET_YES if a sending channel towards that peer exists
- * #GNUNET_NO otherwise
- */
-int
-Peers_check_sending_channel_exists (const struct GNUNET_PeerIdentity *peer)
-{
- struct PeerContext *peer_ctx;
- if (GNUNET_NO == Peers_check_peer_known (peer))
- { /* If no such peer exists, there is no channel */
- return GNUNET_NO;
+ ret = GNUNET_DISK_directory_create_for_file (sub->filename_valid_peers);
+ if (GNUNET_SYSERR == ret)
+ {
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ "Not able to create directory for file `%s'\n",
+ sub->filename_valid_peers);
+ GNUNET_break (0);
}
- peer_ctx = get_peer_ctx (peer);
- if (NULL == peer_ctx->send_channel_ctx)
+ else if (GNUNET_NO == ret)
{
- return GNUNET_NO;
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ "Directory for file `%s' exists but is not writable for us\n",
+ sub->filename_valid_peers);
+ GNUNET_break (0);
}
- return GNUNET_YES;
+ fh = GNUNET_DISK_file_open (sub->filename_valid_peers,
+ GNUNET_DISK_OPEN_WRITE |
+ GNUNET_DISK_OPEN_CREATE,
+ GNUNET_DISK_PERM_USER_READ |
+ GNUNET_DISK_PERM_USER_WRITE);
+ if (NULL == fh)
+ {
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ "Not able to write valid peers to file `%s'\n",
+ sub->filename_valid_peers);
+ return;
+ }
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Writing %u valid peers to disk\n",
+ GNUNET_CONTAINER_multipeermap_size (sub->valid_peers));
+ number_written_peers =
+ GNUNET_CONTAINER_multipeermap_iterate (sub->valid_peers,
+ store_peer_presistently_iterator,
+ fh);
+ GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
+ GNUNET_assert (number_written_peers ==
+ GNUNET_CONTAINER_multipeermap_size (sub->valid_peers));
}
/**
- * @brief check whether the given channel is the sending channel of the given
- * peer
+ * @brief Convert string representation of peer id to peer id.
*
- * @param peer the peer in question
- * @param channel the channel to check for
- * @param role either #Peers_CHANNEL_ROLE_SENDING, or
- * #Peers_CHANNEL_ROLE_RECEIVING
+ * Counterpart to #GNUNET_i2s_full.
*
- * @return #GNUNET_YES if the given chennel is the sending channel of the peer
- * #GNUNET_NO otherwise
+ * @param string_repr The string representation of the peer id
+ *
+ * @return The peer id
*/
-int
-Peers_check_channel_role (const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_CADET_Channel *channel,
- enum Peers_ChannelRole role)
+static const struct GNUNET_PeerIdentity *
+s2i_full (const char *string_repr)
{
- const struct PeerContext *peer_ctx;
+ struct GNUNET_PeerIdentity *peer;
+ size_t len;
+ int ret;
- if (GNUNET_NO == Peers_check_peer_known (peer))
+ peer = GNUNET_new (struct GNUNET_PeerIdentity);
+ len = strlen (string_repr);
+ if (52 > len)
{
- return GNUNET_NO;
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ "Not able to convert string representation of PeerID to PeerID\n"
+ "Sting representation: %s (len %lu) - too short\n",
+ string_repr,
+ len);
+ GNUNET_break (0);
}
- peer_ctx = get_peer_ctx (peer);
- if ( (Peers_CHANNEL_ROLE_SENDING == role) &&
- (NULL != peer_ctx->send_channel_ctx) &&
- (channel == peer_ctx->send_channel_ctx->channel) )
+ else if (52 < len)
{
- return GNUNET_YES;
+ len = 52;
}
- if ( (Peers_CHANNEL_ROLE_RECEIVING == role) &&
- (NULL != peer_ctx->recv_channel_ctx) &&
- (channel == peer_ctx->recv_channel_ctx->channel) )
+ ret = GNUNET_CRYPTO_eddsa_public_key_from_string (string_repr,
+ len,
+ &peer->public_key);
+ if (GNUNET_OK != ret)
{
- return GNUNET_YES;
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ "Not able to convert string representation of PeerID to PeerID\n"
+ "Sting representation: %s\n",
+ string_repr);
+ GNUNET_break (0);
}
- return GNUNET_NO;
+ return peer;
}
/**
- * @brief Destroy the send channel of a peer e.g. stop indicating a sending
- * intention to another peer
- *
- * If there is also no channel to receive messages from that peer, remove it
- * from the peermap.
- * TODO really?
+ * @brief Restore the peers on disk to #valid_peers.
*
- * @peer the peer identity of the peer whose sending channel to destroy
- * @return #GNUNET_YES if channel was destroyed
- * #GNUNET_NO otherwise
+ * @param sub Sub for which to restore the valid peers
*/
-int
-Peers_destroy_sending_channel (const struct GNUNET_PeerIdentity *peer)
+static void
+restore_valid_peers (const struct Sub *sub)
{
- struct PeerContext *peer_ctx;
+ off_t file_size;
+ uint32_t num_peers;
+ struct GNUNET_DISK_FileHandle *fh;
+ char *buf;
+ ssize_t size_read;
+ char *iter_buf;
+ char *str_repr;
+ const struct GNUNET_PeerIdentity *peer;
- if (GNUNET_NO == Peers_check_peer_known (peer))
+ if (0 == strncmp ("DISABLE", sub->filename_valid_peers, 7))
{
- return GNUNET_NO;
+ return;
}
- peer_ctx = get_peer_ctx (peer);
- if (NULL != peer_ctx->send_channel_ctx)
+
+ if (GNUNET_OK != GNUNET_DISK_file_test (sub->filename_valid_peers))
{
- schedule_channel_destruction (peer_ctx->send_channel_ctx);
- (void) Peers_check_connected (peer);
- return GNUNET_YES;
+ return;
}
- return GNUNET_NO;
-}
-
-/**
- * @brief Callback for scheduler to destroy a channel
- *
- * @param cls Context of the channel
- */
-static void
-destroy_channel (void *cls)
-{
- struct ChannelCtx *channel_ctx = cls;
- struct PeerContext *peer_ctx = channel_ctx->peer_ctx;
-
- GNUNET_assert (channel_ctx == peer_ctx->send_channel_ctx ||
- channel_ctx == peer_ctx->recv_channel_ctx);
-
- channel_ctx->destruction_task = NULL;
- GNUNET_CADET_channel_destroy (channel_ctx->channel);
- remove_channel_ctx (peer_ctx->send_channel_ctx);
-}
-
-
-/**
- * @brief Send a message to another peer.
- *
- * Keeps track about pending messages so they can be properly removed when the
- * peer is destroyed.
- *
- * @param peer receeiver of the message
- * @param ev envelope of the message
- * @param type type of the message
- */
-void
-Peers_send_message (const struct GNUNET_PeerIdentity *peer,
- struct GNUNET_MQ_Envelope *ev,
- const char *type)
-{
- struct PendingMessage *pending_msg;
- struct GNUNET_MQ_Handle *mq;
-
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Sending message to %s of type %s\n",
- GNUNET_i2s (peer),
- type);
- pending_msg = insert_pending_message (peer, ev, type);
- mq = get_mq (peer);
- GNUNET_MQ_notify_sent (ev,
- mq_notify_sent_cb,
- pending_msg);
- GNUNET_MQ_send (mq, ev);
-}
-
-/**
- * @brief Schedule a operation on given peer
- *
- * Avoids scheduling an operation twice.
- *
- * @param peer the peer we want to schedule the operation for once it gets live
- *
- * @return #GNUNET_YES if the operation was scheduled
- * #GNUNET_NO otherwise
- */
-int
-Peers_schedule_operation (const struct GNUNET_PeerIdentity *peer,
- const PeerOp peer_op)
-{
- struct PeerPendingOp pending_op;
- struct PeerContext *peer_ctx;
-
- GNUNET_assert (GNUNET_YES == Peers_check_peer_known (peer));
-
- //TODO if LIVE/ONLINE execute immediately
-
- if (GNUNET_NO == check_operation_scheduled (peer, peer_op))
+ fh = GNUNET_DISK_file_open (sub->filename_valid_peers,
+ GNUNET_DISK_OPEN_READ,
+ GNUNET_DISK_PERM_NONE);
+ GNUNET_assert (NULL != fh);
+ GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_handle_size (fh, &file_size));
+ num_peers = file_size / 53;
+ buf = GNUNET_malloc (file_size);
+ size_read = GNUNET_DISK_file_read (fh, buf, file_size);
+ GNUNET_assert (size_read == file_size);
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Restoring %" PRIu32 " peers from file `%s'\n",
+ num_peers,
+ sub->filename_valid_peers);
+ for (iter_buf = buf; iter_buf < buf + file_size - 1; iter_buf += 53)
{
- peer_ctx = get_peer_ctx (peer);
- pending_op.op = peer_op;
- pending_op.op_cls = NULL;
- GNUNET_array_append (peer_ctx->pending_ops,
- peer_ctx->num_pending_ops,
- pending_op);
- return GNUNET_YES;
+ str_repr = GNUNET_strndup (iter_buf, 53);
+ peer = s2i_full (str_repr);
+ GNUNET_free (str_repr);
+ add_valid_peer (peer, sub->valid_peers);
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Restored valid peer %s from disk\n",
+ GNUNET_i2s_full (peer));
}
- return GNUNET_NO;
+ iter_buf = NULL;
+ GNUNET_free (buf);
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "num_peers: %" PRIu32 ", _size (sub->valid_peers): %u\n",
+ num_peers,
+ GNUNET_CONTAINER_multipeermap_size (sub->valid_peers));
+ if (num_peers != GNUNET_CONTAINER_multipeermap_size (sub->valid_peers))
+ {
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ "Number of restored peers does not match file size. Have probably duplicates.\n");
+ }
+ GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Restored %u valid peers from disk\n",
+ GNUNET_CONTAINER_multipeermap_size (sub->valid_peers));
}
-/**
- * @brief Get the recv_channel of @a peer.
- * Needed to correctly handle (call #GNUNET_CADET_receive_done()) incoming
- * messages.
- *
- * @param peer The peer to get the recv_channel from.
- *
- * @return The recv_channel.
- */
-struct GNUNET_CADET_Channel *
-Peers_get_recv_channel (const struct GNUNET_PeerIdentity *peer)
-{
- struct PeerContext *peer_ctx;
-
- GNUNET_assert (GNUNET_YES == Peers_check_peer_known (peer));
- peer_ctx = get_peer_ctx (peer);
- return peer_ctx->recv_channel_ctx->channel;
-}
-/***********************************************************************
- * /Old gnunet-service-rps_peers.c
-***********************************************************************/
-
-
-/***********************************************************************
- * Housekeeping with clients
-***********************************************************************/
/**
- * Closure used to pass the client and the id to the callback
- * that replies to a client's request
+ * @brief Delete storage of peers that was created with #initialise_peers ()
+ *
+ * @param sub Sub for which the storage is deleted
*/
-struct ReplyCls
-{
- /**
- * DLL
- */
- struct ReplyCls *next;
- struct ReplyCls *prev;
-
- /**
- * The identifier of the request
- */
- uint32_t id;
-
- /**
- * The handle to the request
- */
- struct RPS_SamplerRequestHandle *req_handle;
-
- /**
- * The client handle to send the reply to
- */
- struct ClientContext *cli_ctx;
-};
+static void
+peers_terminate (struct Sub *sub)
+{
+ if (GNUNET_SYSERR ==
+ GNUNET_CONTAINER_multipeermap_iterate (sub->peer_map,
+ &peermap_clear_iterator,
+ sub))
+ {
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ "Iteration destroying peers was aborted.\n");
+ }
+ GNUNET_CONTAINER_multipeermap_destroy (sub->peer_map);
+ sub->peer_map = NULL;
+ store_valid_peers (sub);
+ GNUNET_free (sub->filename_valid_peers);
+ sub->filename_valid_peers = NULL;
+ GNUNET_CONTAINER_multipeermap_destroy (sub->valid_peers);
+ sub->valid_peers = NULL;
+}
/**
- * Struct used to store the context of a connected client.
+ * Iterator over #valid_peers hash map entries.
+ *
+ * @param cls Closure that contains iterator function and closure
+ * @param peer current peer id
+ * @param value value in the hash map - unused
+ * @return #GNUNET_YES if we should continue to
+ * iterate,
+ * #GNUNET_NO if not.
*/
-struct ClientContext
+static int
+valid_peer_iterator (void *cls,
+ const struct GNUNET_PeerIdentity *peer,
+ void *value)
{
- /**
- * DLL
- */
- struct ClientContext *next;
- struct ClientContext *prev;
-
- /**
- * The message queue to communicate with the client.
- */
- struct GNUNET_MQ_Handle *mq;
-
- /**
- * DLL with handles to single requests from the client
- */
- struct ReplyCls *rep_cls_head;
- struct ReplyCls *rep_cls_tail;
+ struct PeersIteratorCls *it_cls = cls;
+ (void) value;
- /**
- * @brief How many updates this client expects to receive.
- */
- int64_t view_updates_left;
+ return it_cls->iterator (it_cls->cls, peer);
+}
- /**
- * The client handle to send the reply to
- */
- struct GNUNET_SERVICE_Client *client;
-};
/**
- * DLL with all clients currently connected to us
+ * @brief Get all currently known, valid peer ids.
+ *
+ * @param valid_peers Peer map containing the valid peers in question
+ * @param iterator function to call on each peer id
+ * @param it_cls extra argument to @a iterator
+ * @return the number of key value pairs processed,
+ * #GNUNET_SYSERR if it aborted iteration
*/
-struct ClientContext *cli_ctx_head;
-struct ClientContext *cli_ctx_tail;
-
-/***********************************************************************
- * /Housekeeping with clients
-***********************************************************************/
-
-
-
+static int
+get_valid_peers (struct GNUNET_CONTAINER_MultiPeerMap *valid_peers,
+ PeersIterator iterator,
+ void *it_cls)
+{
+ struct PeersIteratorCls *cls;
+ int ret;
+ cls = GNUNET_new (struct PeersIteratorCls);
+ cls->iterator = iterator;
+ cls->cls = it_cls;
+ ret = GNUNET_CONTAINER_multipeermap_iterate (valid_peers,
+ valid_peer_iterator,
+ cls);
+ GNUNET_free (cls);
+ return ret;
+}
-/***********************************************************************
- * Globals
-***********************************************************************/
/**
- * Sampler used for the Brahms protocol itself.
+ * @brief Add peer to known peers.
+ *
+ * This function is called on new peer_ids from 'external' sources
+ * (client seed, cadet get_peers(), ...)
+ *
+ * @param sub Sub with the peer map that the @a peer will be added to
+ * @param peer the new #GNUNET_PeerIdentity
+ *
+ * @return #GNUNET_YES if peer was inserted
+ * #GNUNET_NO otherwise
*/
-static struct RPS_Sampler *prot_sampler;
+static int
+insert_peer (struct Sub *sub,
+ const struct GNUNET_PeerIdentity *peer)
+{
+ if (GNUNET_YES == check_peer_known (sub->peer_map, peer))
+ {
+ return GNUNET_NO; /* We already know this peer - nothing to do */
+ }
+ (void) create_peer_ctx (sub, peer);
+ return GNUNET_YES;
+}
-/**
- * Sampler used for the clients.
- */
-static struct RPS_Sampler *client_sampler;
/**
- * Name to log view to
+ * @brief Check whether flags on a peer are set.
+ *
+ * @param peer_map Peer map that is expected to contain the @a peer
+ * @param peer the peer to check the flag of
+ * @param flags the flags to check
+ *
+ * @return #GNUNET_SYSERR if peer is not known
+ * #GNUNET_YES if all given flags are set
+ * #GNUNET_NO otherwise
*/
-static const char *file_name_view_log;
+static int
+check_peer_flag (const struct GNUNET_CONTAINER_MultiPeerMap *peer_map,
+ const struct GNUNET_PeerIdentity *peer,
+ enum Peers_PeerFlags flags)
+{
+ struct PeerContext *peer_ctx;
-#ifdef TO_FILE
-/**
- * Name to log number of observed peers to
- */
-static const char *file_name_observed_log;
+ if (GNUNET_NO == check_peer_known (peer_map, peer))
+ {
+ return GNUNET_SYSERR;
+ }
+ peer_ctx = get_peer_ctx (peer_map, peer);
+ return check_peer_flag_set (peer_ctx, flags);
+}
/**
- * @brief Count the observed peers
+ * @brief Try connecting to a peer to see whether it is online
+ *
+ * If not known yet, insert into known peers
+ *
+ * @param sub Sub which would contain the @a peer
+ * @param peer the peer whose online is to be checked
+ * @return #GNUNET_YES if the check was issued
+ * #GNUNET_NO otherwise
*/
-static uint32_t num_observed_peers;
+static int
+issue_peer_online_check (struct Sub *sub,
+ const struct GNUNET_PeerIdentity *peer)
+{
+ struct PeerContext *peer_ctx;
-/**
- * @brief Multipeermap (ab-) used to count unique peer_ids
- */
-static struct GNUNET_CONTAINER_MultiPeerMap *observed_unique_peers;
-#endif /* TO_FILE */
+ (void) insert_peer (sub, peer); // TODO even needed?
+ peer_ctx = get_peer_ctx (sub->peer_map, peer);
+ if ( (GNUNET_NO == check_peer_flag (sub->peer_map, peer, Peers_ONLINE)) &&
+ (NULL == peer_ctx->online_check_pending) )
+ {
+ check_peer_online (peer_ctx);
+ return GNUNET_YES;
+ }
+ return GNUNET_NO;
+}
-/**
- * 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;
/**
- * The size of sampler we need to be able to satisfy the Brahms protocol's
- * need of random peers.
+ * @brief Check if peer is removable.
*
- * This is one minimum size the sampler grows to.
- */
-static unsigned int sampler_size_est_need;
-
-/**
- * @brief This is the minimum estimate used as sampler size.
+ * Check if
+ * - a recv channel exists
+ * - there are pending messages
+ * - there is no pending pull reply
*
- * It is configured by the user.
+ * @param peer_ctx Context of the peer in question
+ * @return #GNUNET_YES if peer is removable
+ * #GNUNET_NO if peer is NOT removable
+ * #GNUNET_SYSERR if peer is not known
*/
-static unsigned int sampler_size_est_min;
+static int
+check_removable (const struct PeerContext *peer_ctx)
+{
+ if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (peer_ctx->sub->peer_map,
+ &peer_ctx->peer_id))
+ {
+ return GNUNET_SYSERR;
+ }
-/**
- * @brief This is the estimate used as view size.
- *
- * It is initialised with the minimum
- */
-static unsigned int view_size_est_need;
+ if ( (NULL != peer_ctx->recv_channel_ctx) ||
+ (NULL != peer_ctx->pending_messages_head) ||
+ (GNUNET_YES == check_peer_flag_set (peer_ctx, Peers_PULL_REPLY_PENDING)) )
+ {
+ return GNUNET_NO;
+ }
+ return GNUNET_YES;
+}
-/**
- * @brief This is the minimum estimate used as view size.
- *
- * It is configured by the user.
- */
-static unsigned int view_size_est_min;
/**
- * Percentage of total peer number in the view
- * to send random PUSHes to
+ * @brief Check whether @a peer is actually a peer.
+ *
+ * A valid peer is a peer that we know exists eg. we were connected to once.
+ *
+ * @param valid_peers Peer map that would contain the @a peer
+ * @param peer peer in question
+ *
+ * @return #GNUNET_YES if peer is valid
+ * #GNUNET_NO if peer is not valid
*/
-static float alpha;
+static int
+check_peer_valid (const struct GNUNET_CONTAINER_MultiPeerMap *valid_peers,
+ const struct GNUNET_PeerIdentity *peer)
+{
+ return GNUNET_CONTAINER_multipeermap_contains (valid_peers, peer);
+}
-/**
- * Percentage of total peer number in the view
- * to send random PULLs to
- */
-static float beta;
/**
- * Identifier for the main task that runs periodically.
+ * @brief Indicate that we want to send to the other peer
+ *
+ * This establishes a sending channel
+ *
+ * @param peer_ctx Context of the target peer
*/
-static struct GNUNET_SCHEDULER_Task *do_round_task;
+static void
+indicate_sending_intention (struct PeerContext *peer_ctx)
+{
+ GNUNET_assert (GNUNET_YES == check_peer_known (peer_ctx->sub->peer_map,
+ &peer_ctx->peer_id));
+ (void) get_channel (peer_ctx);
+}
-/**
- * Time inverval the do_round task runs in.
- */
-static struct GNUNET_TIME_Relative round_interval;
/**
- * List to store peers received through pushes temporary.
+ * @brief Check whether other peer has the intention to send/opened channel
+ * towars us
+ *
+ * @param peer_ctx Context of the peer in question
+ *
+ * @return #GNUNET_YES if peer has the intention to send
+ * #GNUNET_NO otherwise
*/
-static struct CustomPeerMap *push_map;
+static int
+check_peer_send_intention (const struct PeerContext *peer_ctx)
+{
+ if (NULL != peer_ctx->recv_channel_ctx)
+ {
+ return GNUNET_YES;
+ }
+ return GNUNET_NO;
+}
-/**
- * List to store peers received through pulls temporary.
- */
-static struct CustomPeerMap *pull_map;
/**
- * Handler to NSE.
+ * Handle the channel a peer opens to us.
+ *
+ * @param cls The closure - Sub
+ * @param channel The channel the peer wants to establish
+ * @param initiator The peer's peer ID
+ *
+ * @return initial channel context for the channel
+ * (can be NULL -- that's not an error)
*/
-static struct GNUNET_NSE_Handle *nse;
+static void *
+handle_inbound_channel (void *cls,
+ struct GNUNET_CADET_Channel *channel,
+ const struct GNUNET_PeerIdentity *initiator)
+{
+ struct PeerContext *peer_ctx;
+ struct ChannelCtx *channel_ctx;
+ struct Sub *sub = cls;
-/**
- * Handler to CADET.
- */
-static struct GNUNET_CADET_Handle *cadet_handle;
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "New channel was established to us (Peer %s).\n",
+ GNUNET_i2s (initiator));
+ GNUNET_assert (NULL != channel); /* according to cadet API */
+ /* Make sure we 'know' about this peer */
+ peer_ctx = create_or_get_peer_ctx (sub, initiator);
+ set_peer_online (peer_ctx);
+ (void) add_valid_peer (&peer_ctx->peer_id, peer_ctx->sub->valid_peers);
+ channel_ctx = add_channel_ctx (peer_ctx);
+ channel_ctx->channel = channel;
+ /* We only accept one incoming channel per peer */
+ if (GNUNET_YES == check_peer_send_intention (get_peer_ctx (sub->peer_map,
+ initiator)))
+ {
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ "Already got one receive channel. Destroying old one.\n");
+ GNUNET_break_op (0);
+ destroy_channel (peer_ctx->recv_channel_ctx);
+ peer_ctx->recv_channel_ctx = channel_ctx;
+ /* return the channel context */
+ return channel_ctx;
+ }
+ peer_ctx->recv_channel_ctx = channel_ctx;
+ return channel_ctx;
+}
-/**
- * @brief Port to communicate to other peers.
- */
-static struct GNUNET_CADET_Port *cadet_port;
/**
- * Handler to PEERINFO.
+ * @brief Check whether a sending channel towards the given peer exists
+ *
+ * @param peer_ctx Context of the peer in question
+ *
+ * @return #GNUNET_YES if a sending channel towards that peer exists
+ * #GNUNET_NO otherwise
*/
-static struct GNUNET_PEERINFO_Handle *peerinfo_handle;
+static int
+check_sending_channel_exists (const struct PeerContext *peer_ctx)
+{
+ if (GNUNET_NO == check_peer_known (peer_ctx->sub->peer_map,
+ &peer_ctx->peer_id))
+ { /* If no such peer exists, there is no channel */
+ return GNUNET_NO;
+ }
+ if (NULL == peer_ctx->send_channel_ctx)
+ {
+ return GNUNET_NO;
+ }
+ return GNUNET_YES;
+}
-/**
- * Handle for cancellation of iteration over peers.
- */
-static struct GNUNET_PEERINFO_NotifyContext *peerinfo_notify_handle;
/**
- * Request counter.
+ * @brief Destroy the send channel of a peer e.g. stop indicating a sending
+ * intention to another peer
*
- * Counts how many requets clients already issued.
- * Only needed in the beginning to check how many of the 64 deltas
- * we already have
+ * @param peer_ctx Context to the peer
+ * @return #GNUNET_YES if channel was destroyed
+ * #GNUNET_NO otherwise
*/
-static unsigned int req_counter;
+static int
+destroy_sending_channel (struct PeerContext *peer_ctx)
+{
+ if (GNUNET_NO == check_peer_known (peer_ctx->sub->peer_map,
+ &peer_ctx->peer_id))
+ {
+ return GNUNET_NO;
+ }
+ if (NULL != peer_ctx->send_channel_ctx)
+ {
+ destroy_channel (peer_ctx->send_channel_ctx);
+ (void) check_connected (peer_ctx);
+ return GNUNET_YES;
+ }
+ return GNUNET_NO;
+}
/**
- * Time of the last request we received.
+ * @brief Send a message to another peer.
*
- * Used to compute the expected request rate.
- */
-static struct GNUNET_TIME_Absolute last_request;
-
-/**
- * Size of #request_deltas.
+ * Keeps track about pending messages so they can be properly removed when the
+ * peer is destroyed.
+ *
+ * @param peer_ctx Context of the peer to which the message is to be sent
+ * @param ev envelope of the message
+ * @param type type of the message
*/
-#define REQUEST_DELTAS_SIZE 64
-static unsigned int request_deltas_size = REQUEST_DELTAS_SIZE;
+static void
+send_message (struct PeerContext *peer_ctx,
+ struct GNUNET_MQ_Envelope *ev,
+ const char *type)
+{
+ struct PendingMessage *pending_msg;
+ struct GNUNET_MQ_Handle *mq;
-/**
- * Last 64 deltas between requests
- */
-static struct GNUNET_TIME_Relative request_deltas[REQUEST_DELTAS_SIZE];
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Sending message to %s of type %s\n",
+ GNUNET_i2s (&peer_ctx->peer_id),
+ type);
+ pending_msg = insert_pending_message (peer_ctx, ev, type);
+ mq = get_mq (peer_ctx);
+ GNUNET_MQ_notify_sent (ev,
+ mq_notify_sent_cb,
+ pending_msg);
+ GNUNET_MQ_send (mq, ev);
+}
/**
- * The prediction of the rate of requests
+ * @brief Schedule a operation on given peer
+ *
+ * Avoids scheduling an operation twice.
+ *
+ * @param peer_ctx Context of the peer for which to schedule the operation
+ * @param peer_op the operation to schedule
+ * @param cls Closure to @a peer_op
+ *
+ * @return #GNUNET_YES if the operation was scheduled
+ * #GNUNET_NO otherwise
*/
-static struct GNUNET_TIME_Relative request_rate;
+static int
+schedule_operation (struct PeerContext *peer_ctx,
+ const PeerOp peer_op,
+ void *cls)
+{
+ struct PeerPendingOp pending_op;
+ GNUNET_assert (GNUNET_YES == check_peer_known (peer_ctx->sub->peer_map,
+ &peer_ctx->peer_id));
-#ifdef ENABLE_MALICIOUS
-/**
- * Type of malicious peer
- *
- * 0 Don't act malicious at all - Default
- * 1 Try to maximise representation
- * 2 Try to partition the network
- * 3 Combined attack
- */
-static uint32_t mal_type;
+ //TODO if ONLINE execute immediately
-/**
- * Other malicious peers
- */
-static struct GNUNET_PeerIdentity *mal_peers;
+ if (GNUNET_NO == check_operation_scheduled (peer_ctx, peer_op))
+ {
+ pending_op.op = peer_op;
+ pending_op.op_cls = cls;
+ GNUNET_array_append (peer_ctx->pending_ops,
+ peer_ctx->num_pending_ops,
+ pending_op);
+ return GNUNET_YES;
+ }
+ return GNUNET_NO;
+}
-/**
- * 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;
+/***********************************************************************
+ * /Old gnunet-service-rps_peers.c
+***********************************************************************/
-/**
- * Number of other malicious peers
- */
-static uint32_t num_mal_peers;
+/***********************************************************************
+ * Housekeeping with clients
+***********************************************************************/
/**
- * If type is 2 This struct is used to store the attacked peers in a DLL
+ * Closure used to pass the client and the id to the callback
+ * that replies to a client's request
*/
-struct AttackedPeer
+struct ReplyCls
{
/**
* DLL
*/
- struct AttackedPeer *next;
- struct AttackedPeer *prev;
+ struct ReplyCls *next;
+ struct ReplyCls *prev;
/**
- * PeerID
+ * The identifier of the request
*/
- struct GNUNET_PeerIdentity peer_id;
+ uint32_t id;
+
+ /**
+ * The handle to the request
+ */
+ struct RPS_SamplerRequestHandle *req_handle;
+
+ /**
+ * The client handle to send the reply to
+ */
+ struct ClientContext *cli_ctx;
};
-/**
- * If type is 2 this is the DLL of attacked peers
- */
-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.
+ * Struct used to store the context of a connected client.
*/
-static struct AttackedPeer *att_peer_index;
+struct ClientContext
+{
+ /**
+ * DLL
+ */
+ struct ClientContext *next;
+ struct ClientContext *prev;
-/**
- * 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;
+ /**
+ * The message queue to communicate with the client.
+ */
+ struct GNUNET_MQ_Handle *mq;
-/**
- * Number of attacked peers
- */
-static uint32_t num_attacked_peers;
+ /**
+ * @brief How many updates this client expects to receive.
+ */
+ int64_t view_updates_left;
-/**
- * If type is 1 this is the attacked peer
- */
-static struct GNUNET_PeerIdentity attacked_peer;
+ /**
+ * @brief Whether this client wants to receive stream updates.
+ * Either #GNUNET_YES or #GNUNET_NO
+ */
+ int8_t stream_update;
+
+ /**
+ * The client handle to send the reply to
+ */
+ struct GNUNET_SERVICE_Client *client;
+
+ /**
+ * The #Sub this context belongs to
+ */
+ struct Sub *sub;
+};
/**
- * The limit of PUSHes we can send in one round.
- * This is an assumption of the Brahms protocol and either implemented
- * via proof of work
- * or
- * assumend to be the bandwidth limitation.
+ * DLL with all clients currently connected to us
*/
-static uint32_t push_limit = 10000;
-#endif /* ENABLE_MALICIOUS */
-
+struct ClientContext *cli_ctx_head;
+struct ClientContext *cli_ctx_tail;
/***********************************************************************
- * /Globals
+ * /Housekeeping with clients
***********************************************************************/
+
+
+
/***********************************************************************
* Util functions
***********************************************************************/
for ( i = 0 ; i < *list_size ; i++ )
{
- if (0 == GNUNET_CRYPTO_cmp_peer_identity (&tmp[i], peer))
+ if (0 == GNUNET_memcmp (&tmp[i], peer))
{
if (i < *list_size -1)
{ /* Not at the last entry -- shift peers left */
/**
- * Sum all time relatives of an array.
+ * Insert PeerID in #view
+ *
+ * Called once we know a peer is online.
+ * 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 online.
+ *
+ * @param sub Sub in with the view to insert in
+ * @param peer the peer to insert
+ *
+ * @return GNUNET_OK if peer was actually inserted
+ * GNUNET_NO if peer was not inserted
+ */
+static int
+insert_in_view (struct Sub *sub,
+ const struct GNUNET_PeerIdentity *peer)
+{
+ struct PeerContext *peer_ctx;
+ int online;
+ int ret;
+
+ online = check_peer_flag (sub->peer_map, peer, Peers_ONLINE);
+ peer_ctx = get_peer_ctx (sub->peer_map, peer); // TODO indirection needed?
+ if ( (GNUNET_NO == online) ||
+ (GNUNET_SYSERR == online) ) /* peer is not even known */
+ {
+ (void) issue_peer_online_check (sub, peer);
+ (void) schedule_operation (peer_ctx, insert_in_view_op, sub);
+ return GNUNET_NO;
+ }
+ /* Open channel towards peer to keep connection open */
+ indicate_sending_intention (peer_ctx);
+ ret = View_put (sub->view, peer);
+ if (peer_ctx->sub == msub)
+ {
+ GNUNET_STATISTICS_set (stats,
+ "view size",
+ View_size (peer_ctx->sub->view),
+ GNUNET_NO);
+ }
+ return ret;
+}
+
+
+/**
+ * @brief Send view to client
+ *
+ * @param cli_ctx the context of the client
+ * @param view_array the peerids of the view as array (can be empty)
+ * @param view_size the size of the view array (can be 0)
+ */
+static void
+send_view (const struct ClientContext *cli_ctx,
+ const struct GNUNET_PeerIdentity *view_array,
+ uint64_t view_size)
+{
+ struct GNUNET_MQ_Envelope *ev;
+ struct GNUNET_RPS_CS_DEBUG_ViewReply *out_msg;
+ struct Sub *sub;
+
+ if (NULL == view_array)
+ {
+ if (NULL == cli_ctx->sub) sub = msub;
+ else sub = cli_ctx->sub;
+ view_size = View_size (sub->view);
+ view_array = View_get_as_array (sub->view);
+ }
+
+ ev = GNUNET_MQ_msg_extra (out_msg,
+ view_size * sizeof (struct GNUNET_PeerIdentity),
+ GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_REPLY);
+ out_msg->num_peers = htonl (view_size);
+
+ GNUNET_memcpy (&out_msg[1],
+ view_array,
+ view_size * sizeof (struct GNUNET_PeerIdentity));
+ GNUNET_MQ_send (cli_ctx->mq, ev);
+}
+
+
+/**
+ * @brief Send peer from biased stream to client.
+ *
+ * TODO merge with send_view, parameterise
+ *
+ * @param cli_ctx the context of the client
+ * @param view_array the peerids of the view as array (can be empty)
+ * @param view_size the size of the view array (can be 0)
+ */
+static void
+send_stream_peers (const struct ClientContext *cli_ctx,
+ uint64_t num_peers,
+ const struct GNUNET_PeerIdentity *peers)
+{
+ struct GNUNET_MQ_Envelope *ev;
+ struct GNUNET_RPS_CS_DEBUG_StreamReply *out_msg;
+
+ GNUNET_assert (NULL != peers);
+
+ ev = GNUNET_MQ_msg_extra (out_msg,
+ num_peers * sizeof (struct GNUNET_PeerIdentity),
+ GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_STREAM_REPLY);
+ out_msg->num_peers = htonl (num_peers);
+
+ GNUNET_memcpy (&out_msg[1],
+ peers,
+ num_peers * sizeof (struct GNUNET_PeerIdentity));
+ GNUNET_MQ_send (cli_ctx->mq, ev);
+}
+
+
+/**
+ * @brief sends updates to clients that are interested
+ *
+ * @param sub Sub for which to notify clients
*/
-static struct GNUNET_TIME_Relative
-T_relative_sum (const struct GNUNET_TIME_Relative *rel_array,
- uint32_t arr_size)
+static void
+clients_notify_view_update (const struct Sub *sub)
{
- struct GNUNET_TIME_Relative sum;
- uint32_t i;
+ struct ClientContext *cli_ctx_iter;
+ uint64_t num_peers;
+ const struct GNUNET_PeerIdentity *view_array;
- sum = GNUNET_TIME_UNIT_ZERO;
- for ( i = 0 ; i < arr_size ; i++ )
+ num_peers = View_size (sub->view);
+ view_array = View_get_as_array(sub->view);
+ /* check size of view is small enough */
+ if (GNUNET_MAX_MESSAGE_SIZE < num_peers)
{
- sum = GNUNET_TIME_relative_add (sum, rel_array[i]);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "View is too big to send\n");
+ return;
}
- return sum;
-}
+ for (cli_ctx_iter = cli_ctx_head;
+ NULL != cli_ctx_iter;
+ cli_ctx_iter = cli_ctx_iter->next)
+ {
+ if (1 < cli_ctx_iter->view_updates_left)
+ {
+ /* Client wants to receive limited amount of updates */
+ cli_ctx_iter->view_updates_left -= 1;
+ } else if (1 == cli_ctx_iter->view_updates_left)
+ {
+ /* Last update of view for client */
+ cli_ctx_iter->view_updates_left = -1;
+ } else if (0 > cli_ctx_iter->view_updates_left) {
+ /* Client is not interested in updates */
+ continue;
+ }
+ /* else _updates_left == 0 - infinite amount of updates */
-/**
- * Compute the average of given time relatives.
- */
-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);
+ /* send view */
+ send_view (cli_ctx_iter, view_array, num_peers);
+ }
}
/**
- * Insert PeerID in #view
- *
- * Called once we know a peer is live.
- * Implements #PeerOp
+ * @brief sends updates to clients that are interested
*
- * @return GNUNET_OK if peer was actually inserted
- * GNUNET_NO if peer was not inserted
+ * @param num_peers Number of peers to send
+ * @param peers the array of peers to send
*/
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)
+clients_notify_stream_peer (const struct Sub *sub,
+ uint64_t num_peers,
+ const struct GNUNET_PeerIdentity *peers)
+ // TODO enum StreamPeerSource)
{
- int online;
+ struct ClientContext *cli_ctx_iter;
- online = Peers_check_peer_flag (peer, Peers_ONLINE);
- if ( (GNUNET_NO == online) ||
- (GNUNET_SYSERR == online) ) /* peer is not even known */
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Got peer (%s) from biased stream - update all clients\n",
+ GNUNET_i2s (peers));
+
+ for (cli_ctx_iter = cli_ctx_head;
+ NULL != cli_ctx_iter;
+ cli_ctx_iter = cli_ctx_iter->next)
{
- (void) Peers_issue_peer_liveliness_check (peer);
- (void) Peers_schedule_operation (peer, insert_in_view_op);
- return GNUNET_NO;
+ if (GNUNET_YES == cli_ctx_iter->stream_update &&
+ (sub == cli_ctx_iter->sub || sub == msub))
+ {
+ send_stream_peers (cli_ctx_iter, num_peers, peers);
+ }
}
- /* Open channel towards peer to keep connection open */
- Peers_indicate_sending_intention (peer);
- return View_put (peer);
}
-/**
- * @brief sends updates to clients that are interested
- */
-static void
-clients_notify_view_update (void);
/**
* Put random peer from sampler into the view as history update.
+ *
+ * @param ids Array of Peers to insert into view
+ * @param num_peers Number of peers to insert
+ * @param cls Closure - The Sub for which this is to be done
*/
static void
-hist_update (void *cls,
- struct GNUNET_PeerIdentity *ids,
- uint32_t num_peers)
+hist_update (const struct GNUNET_PeerIdentity *ids,
+ uint32_t num_peers,
+ void *cls)
{
unsigned int i;
+ struct Sub *sub = cls;
for (i = 0; i < num_peers; i++)
{
- (void) insert_in_view (&ids[i]);
- to_file (file_name_view_log,
+ int inserted;
+ if (GNUNET_YES != check_peer_known (sub->peer_map, &ids[i]))
+ {
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ "Peer in history update not known!\n");
+ continue;
+ }
+ inserted = insert_in_view (sub, &ids[i]);
+ if (GNUNET_OK == inserted)
+ {
+ clients_notify_stream_peer (sub, 1, &ids[i]);
+ }
+#ifdef TO_FILE_FULL
+ to_file (sub->file_name_view_log,
"+%s\t(hist)",
GNUNET_i2s_full (ids));
+#endif /* TO_FILE_FULL */
}
- clients_notify_view_update();
+ clients_notify_view_update (sub);
}
*
* If we do not have enough sampler elements, double current sampler size
* If we have more than enough sampler elements, halv current sampler size
+ *
+ * @param sampler The sampler to resize
+ * @param new_size New size to which to resize
*/
static void
resize_wrapper (struct RPS_Sampler *sampler, uint32_t new_size)
}
-/**
- * Wrapper around #RPS_sampler_resize() resizing the client sampler
- */
-static void
-client_resize_wrapper ()
-{
- uint32_t bigger_size;
-
- // TODO statistics
-
- bigger_size = GNUNET_MAX (sampler_size_est_need, sampler_size_client_need);
-
- // TODO respect the min, max
- resize_wrapper (client_sampler, bigger_size);
- LOG (GNUNET_ERROR_TYPE_DEBUG, "sampler_size_client is now %" PRIu32 "\n",
- bigger_size);
-}
-
-
-/**
- * Estimate request rate
- *
- * Called every time we receive a request from the client.
- */
-static void
-est_request_rate()
-{
- struct GNUNET_TIME_Relative max_round_duration;
-
- if (request_deltas_size > req_counter)
- req_counter++;
- if ( 1 < req_counter)
- {
- /* Shift last request deltas to the right */
- memmove (&request_deltas[1],
- request_deltas,
- (req_counter - 1) * sizeof (struct GNUNET_TIME_Relative));
-
- /* Add current delta to beginning */
- request_deltas[0] =
- GNUNET_TIME_absolute_get_difference (last_request,
- GNUNET_TIME_absolute_get ());
- request_rate = T_relative_avg (request_deltas, req_counter);
- request_rate = (request_rate.rel_value_us < 1) ?
- GNUNET_TIME_relative_get_unit_ () : request_rate;
-
- /* Compute the duration a round will maximally take */
- max_round_duration =
- GNUNET_TIME_relative_add (round_interval,
- GNUNET_TIME_relative_divide (round_interval, 2));
-
- /* Set the estimated size the sampler has to have to
- * satisfy the current client request rate */
- sampler_size_client_need =
- max_round_duration.rel_value_us / request_rate.rel_value_us;
-
- /* Resize the sampler */
- client_resize_wrapper ();
- }
- last_request = GNUNET_TIME_absolute_get ();
-}
-
-
/**
* Add all peers in @a peer_array to @a peer_map used as set.
*
&peer_array[i],
NULL,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
+ if (msub->peer_map == peer_map)
+ {
+ GNUNET_STATISTICS_set (stats,
+ "# known peers",
+ GNUNET_CONTAINER_multipeermap_size (peer_map),
+ GNUNET_NO);
+ }
}
}
/**
* Send a PULL REPLY to @a peer_id
*
- * @param peer_id the peer to send the reply to.
+ * @param peer_ctx Context of the peer to send the reply to
* @param peer_ids the peers to send to @a peer_id
* @param num_peer_ids the number of peers to send to @a peer_id
*/
static void
-send_pull_reply (const struct GNUNET_PeerIdentity *peer_id,
+send_pull_reply (struct PeerContext *peer_ctx,
const struct GNUNET_PeerIdentity *peer_ids,
unsigned int num_peer_ids)
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Going to send PULL REPLY with %u peers to %s\n",
- send_size, GNUNET_i2s (peer_id));
+ send_size, GNUNET_i2s (&peer_ctx->peer_id));
ev = GNUNET_MQ_msg_extra (out_msg,
send_size * sizeof (struct GNUNET_PeerIdentity),
GNUNET_memcpy (&out_msg[1], peer_ids,
send_size * sizeof (struct GNUNET_PeerIdentity));
- Peers_send_message (peer_id, ev, "PULL REPLY");
- GNUNET_STATISTICS_update(stats, "# pull reply send issued", 1, GNUNET_NO);
+ send_message (peer_ctx, ev, "PULL REPLY");
+ if (peer_ctx->sub == msub)
+ {
+ GNUNET_STATISTICS_update(stats, "# pull reply send issued", 1, GNUNET_NO);
+ }
// TODO check with send intention: as send_channel is used/opened we indicate
// a sending intention without intending it.
// -> clean peer afterwards?
+ // -> use recv_channel?
}
/**
* Insert PeerID in #pull_map
*
- * Called once we know a peer is live.
+ * Called once we know a peer is online.
+ *
+ * @param cls Closure - Sub with the pull map to insert into
+ * @param peer Peer to insert
*/
static void
insert_in_pull_map (void *cls,
- const struct GNUNET_PeerIdentity *peer)
+ const struct GNUNET_PeerIdentity *peer)
{
- CustomPeerMap_put (pull_map, peer);
+ struct Sub *sub = cls;
+
+ CustomPeerMap_put (sub->pull_map, peer);
}
/**
* Insert PeerID in #view
*
- * Called once we know a peer is live.
+ * Called once we know a peer is online.
* Implements #PeerOp
+ *
+ * @param cls Closure - Sub with view to insert peer into
+ * @param peer the peer to insert
*/
static void
insert_in_view_op (void *cls,
- const struct GNUNET_PeerIdentity *peer)
+ const struct GNUNET_PeerIdentity *peer)
{
- (void) insert_in_view (peer);
+ struct Sub *sub = cls;
+ int inserted;
+
+ inserted = insert_in_view (sub, peer);
+ if (GNUNET_OK == inserted)
+ {
+ clients_notify_stream_peer (sub, 1, peer);
+ }
}
/**
* Update sampler with given PeerID.
* Implements #PeerOp
+ *
+ * @param cls Closure - Sub containing the sampler to insert into
+ * @param peer Peer to insert
*/
static void
insert_in_sampler (void *cls,
- const struct GNUNET_PeerIdentity *peer)
+ const struct GNUNET_PeerIdentity *peer)
{
+ struct Sub *sub = cls;
+
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Updating samplers with peer %s from insert_in_sampler()\n",
GNUNET_i2s (peer));
- RPS_sampler_update (prot_sampler, peer);
- RPS_sampler_update (client_sampler, peer);
- if (0 < RPS_sampler_count_id (prot_sampler, peer))
+ RPS_sampler_update (sub->sampler, peer);
+ if (0 < RPS_sampler_count_id (sub->sampler, peer))
{
/* Make sure we 'know' about this peer */
- (void) Peers_issue_peer_liveliness_check (peer);
+ (void) issue_peer_online_check (sub, peer);
/* Establish a channel towards that peer to indicate we are going to send
* messages to it */
- //Peers_indicate_sending_intention (peer);
+ //indicate_sending_intention (peer);
+ }
+ if (sub == msub)
+ {
+ GNUNET_STATISTICS_update (stats,
+ "# observed peers in gossip",
+ 1,
+ GNUNET_NO);
}
- #ifdef TO_FILE
- num_observed_peers++;
+#ifdef TO_FILE
+ sub->num_observed_peers++;
GNUNET_CONTAINER_multipeermap_put
- (observed_unique_peers,
+ (sub->observed_unique_peers,
peer,
NULL,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
- uint32_t num_observed_unique_peers = GNUNET_CONTAINER_multipeermap_size (
- observed_unique_peers);
- to_file (file_name_observed_log,
+ uint32_t num_observed_unique_peers =
+ GNUNET_CONTAINER_multipeermap_size (sub->observed_unique_peers);
+ GNUNET_STATISTICS_set (stats,
+ "# unique peers in gossip",
+ num_observed_unique_peers,
+ GNUNET_NO);
+#ifdef TO_FILE_FULL
+ to_file (sub->file_name_observed_log,
"%" PRIu32 " %" PRIu32 " %f\n",
- num_observed_peers,
+ sub->num_observed_peers,
num_observed_unique_peers,
- 1.0*num_observed_unique_peers/num_observed_peers)
- #endif /* TO_FILE */
+ 1.0*num_observed_unique_peers/sub->num_observed_peers)
+#endif /* TO_FILE_FULL */
+#endif /* TO_FILE */
}
+
/**
* @brief This is called on peers from external sources (cadet, peerinfo, ...)
- * If the peer is not known, liveliness check is issued and it is
+ * If the peer is not known, online check is issued and it is
* scheduled to be inserted in sampler and view.
*
* "External sources" refer to every source except the gossip.
*
- * @param peer peer to insert
+ * @param sub Sub for which @a peer was received
+ * @param peer peer to insert/peer received
*/
static void
-got_peer (const struct GNUNET_PeerIdentity *peer)
+got_peer (struct Sub *sub,
+ 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))
+ if (GNUNET_YES == issue_peer_online_check (sub, peer))
+ {
+ schedule_operation (get_peer_ctx (sub->peer_map, peer),
+ &insert_in_sampler, sub);
+ schedule_operation (get_peer_ctx (sub->peer_map, peer),
+ &insert_in_view_op, sub);
+ }
+ if (sub == msub)
{
- Peers_schedule_operation (peer, insert_in_sampler);
- Peers_schedule_operation (peer, insert_in_view_op);
+ GNUNET_STATISTICS_update (stats,
+ "# learnd peers",
+ 1,
+ GNUNET_NO);
}
}
+
/**
* @brief Checks if there is a sending channel and if it is needed
*
- * @param peer the peer whose sending channel is checked
+ * @param peer_ctx Context of the peer to check
* @return GNUNET_YES if sending channel exists and is still needed
* GNUNET_NO otherwise
*/
static int
-check_sending_channel_needed (const struct GNUNET_PeerIdentity *peer)
+check_sending_channel_needed (const struct PeerContext *peer_ctx)
{
/* struct GNUNET_CADET_Channel *channel; */
- if (GNUNET_NO == Peers_check_peer_known (peer))
+ if (GNUNET_NO == check_peer_known (peer_ctx->sub->peer_map,
+ &peer_ctx->peer_id))
{
return GNUNET_NO;
}
- if (GNUNET_YES == Peers_check_sending_channel_exists (peer))
+ if (GNUNET_YES == check_sending_channel_exists (peer_ctx))
{
- if ( (0 < RPS_sampler_count_id (prot_sampler, peer)) ||
- (GNUNET_YES == View_contains_peer (peer)) ||
- (GNUNET_YES == CustomPeerMap_contains_peer (push_map, peer)) ||
- (GNUNET_YES == CustomPeerMap_contains_peer (pull_map, peer)) ||
- (GNUNET_YES == Peers_check_peer_flag (peer, Peers_PULL_REPLY_PENDING)))
+ if ( (0 < RPS_sampler_count_id (peer_ctx->sub->sampler,
+ &peer_ctx->peer_id)) ||
+ (GNUNET_YES == View_contains_peer (peer_ctx->sub->view,
+ &peer_ctx->peer_id)) ||
+ (GNUNET_YES == CustomPeerMap_contains_peer (peer_ctx->sub->push_map,
+ &peer_ctx->peer_id)) ||
+ (GNUNET_YES == CustomPeerMap_contains_peer (peer_ctx->sub->pull_map,
+ &peer_ctx->peer_id)) ||
+ (GNUNET_YES == check_peer_flag (peer_ctx->sub->peer_map,
+ &peer_ctx->peer_id,
+ Peers_PULL_REPLY_PENDING)))
{ /* If we want to keep the connection to peer open */
return GNUNET_YES;
}
return GNUNET_NO;
}
+
+/**
+ * @brief remove peer from our knowledge, the view, push and pull maps and
+ * samplers.
+ *
+ * @param sub Sub with the data structures the peer is to be removed from
+ * @param peer the peer to remove
+ */
+static void
+remove_peer (struct Sub *sub,
+ const struct GNUNET_PeerIdentity *peer)
+{
+ (void) View_remove_peer (sub->view,
+ peer);
+ CustomPeerMap_remove_peer (sub->pull_map,
+ peer);
+ CustomPeerMap_remove_peer (sub->push_map,
+ peer);
+ RPS_sampler_reinitialise_by_value (sub->sampler,
+ peer);
+ /* We want to destroy the peer now.
+ * Sometimes, it just seems that it's already been removed from the peer_map,
+ * so check the peer_map first. */
+ if (GNUNET_YES == check_peer_known (sub->peer_map,
+ peer))
+ {
+ destroy_peer (get_peer_ctx (sub->peer_map,
+ peer));
+ }
+}
+
+
+/**
+ * @brief Remove data that is not needed anymore.
+ *
+ * If the sending channel is no longer needed it is destroyed.
+ *
+ * @param sub Sub in which the current peer is to be cleaned
+ * @param peer the peer whose data is about to be cleaned
+ */
+static void
+clean_peer (struct Sub *sub,
+ const struct GNUNET_PeerIdentity *peer)
+{
+ if (GNUNET_NO == check_sending_channel_needed (get_peer_ctx (sub->peer_map,
+ peer)))
+ {
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Going to remove send channel to peer %s\n",
+ GNUNET_i2s (peer));
+ #if ENABLE_MALICIOUS
+ if (0 != GNUNET_memcmp (&attacked_peer,
+ peer))
+ (void) destroy_sending_channel (get_peer_ctx (sub->peer_map,
+ peer));
+ #else /* ENABLE_MALICIOUS */
+ (void) destroy_sending_channel (get_peer_ctx (sub->peer_map,
+ peer));
+ #endif /* ENABLE_MALICIOUS */
+ }
+
+ if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (sub->peer_map,
+ peer))
+ {
+ /* Peer was already removed by callback on destroyed channel */
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ "Peer was removed from our knowledge during cleanup\n");
+ return;
+ }
+
+ if ( (GNUNET_NO == check_peer_send_intention (get_peer_ctx (sub->peer_map,
+ peer))) &&
+ (GNUNET_NO == View_contains_peer (sub->view, peer)) &&
+ (GNUNET_NO == CustomPeerMap_contains_peer (sub->push_map, peer)) &&
+ (GNUNET_NO == CustomPeerMap_contains_peer (sub->push_map, peer)) &&
+ (0 == RPS_sampler_count_id (sub->sampler, peer)) &&
+ (GNUNET_YES == check_removable (get_peer_ctx (sub->peer_map, peer))) )
+ { /* We can safely remove this peer */
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Going to remove peer %s\n",
+ GNUNET_i2s (peer));
+ remove_peer (sub, peer);
+ return;
+ }
+}
+
+
+/**
+ * @brief 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.
+ *
+ * @param cls The closure - Context to the channel
+ * @param channel The channel being closed
+ */
+static void
+cleanup_destroyed_channel (void *cls,
+ const struct GNUNET_CADET_Channel *channel)
+{
+ struct ChannelCtx *channel_ctx = cls;
+ struct PeerContext *peer_ctx = channel_ctx->peer_ctx;
+ (void) channel;
+
+ channel_ctx->channel = NULL;
+ remove_channel_ctx (channel_ctx);
+ if (NULL != peer_ctx &&
+ peer_ctx->send_channel_ctx == channel_ctx &&
+ GNUNET_YES == check_sending_channel_needed (channel_ctx->peer_ctx))
+ {
+ remove_peer (peer_ctx->sub, &peer_ctx->peer_id);
+ }
+}
+
+/***********************************************************************
+ * /Util functions
+***********************************************************************/
+
+
+
+/***********************************************************************
+ * Sub
+***********************************************************************/
+
+/**
+ * @brief Create a new Sub
+ *
+ * @param hash Hash of value shared among rps instances on other hosts that
+ * defines a subgroup to sample from.
+ * @param sampler_size Size of the sampler
+ * @param round_interval Interval (in average) between two rounds
+ *
+ * @return Sub
+ */
+struct Sub *
+new_sub (const struct GNUNET_HashCode *hash,
+ uint32_t sampler_size,
+ struct GNUNET_TIME_Relative round_interval)
+{
+ struct Sub *sub;
+
+ sub = GNUNET_new (struct Sub);
+
+ /* With the hash generated from the secret value this service only connects
+ * to rps instances that share the value */
+ struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
+ GNUNET_MQ_hd_fixed_size (peer_check,
+ GNUNET_MESSAGE_TYPE_RPS_PP_CHECK_LIVE,
+ struct GNUNET_MessageHeader,
+ NULL),
+ GNUNET_MQ_hd_fixed_size (peer_push,
+ GNUNET_MESSAGE_TYPE_RPS_PP_PUSH,
+ struct GNUNET_MessageHeader,
+ NULL),
+ GNUNET_MQ_hd_fixed_size (peer_pull_request,
+ GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REQUEST,
+ struct GNUNET_MessageHeader,
+ NULL),
+ GNUNET_MQ_hd_var_size (peer_pull_reply,
+ GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REPLY,
+ struct GNUNET_RPS_P2P_PullReplyMessage,
+ NULL),
+ GNUNET_MQ_handler_end ()
+ };
+ sub->hash = *hash;
+ sub->cadet_port =
+ GNUNET_CADET_open_port (cadet_handle,
+ &sub->hash,
+ &handle_inbound_channel, /* Connect handler */
+ sub, /* cls */
+ NULL, /* WindowSize handler */
+ &cleanup_destroyed_channel, /* Disconnect handler */
+ cadet_handlers);
+ if (NULL == sub->cadet_port)
+ {
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ "Cadet port `%s' is already in use.\n",
+ GNUNET_APPLICATION_PORT_RPS);
+ GNUNET_assert (0);
+ }
+
+ /* Set up general data structure to keep track about peers */
+ sub->valid_peers = GNUNET_CONTAINER_multipeermap_create (4, GNUNET_NO);
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_filename (cfg,
+ "rps",
+ "FILENAME_VALID_PEERS",
+ &sub->filename_valid_peers))
+ {
+ GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+ "rps",
+ "FILENAME_VALID_PEERS");
+ }
+ if (0 != strncmp ("DISABLE", sub->filename_valid_peers, 7))
+ {
+ char *tmp_filename_valid_peers;
+ char str_hash[105];
+
+ GNUNET_snprintf (str_hash,
+ sizeof (str_hash),
+ GNUNET_h2s_full (hash));
+ tmp_filename_valid_peers = sub->filename_valid_peers;
+ GNUNET_asprintf (&sub->filename_valid_peers,
+ "%s%s",
+ tmp_filename_valid_peers,
+ str_hash);
+ GNUNET_free (tmp_filename_valid_peers);
+ }
+ sub->peer_map = GNUNET_CONTAINER_multipeermap_create (4, GNUNET_NO);
+
+ /* Set up the sampler */
+ sub->sampler_size_est_min = sampler_size;
+ sub->sampler_size_est_need = sampler_size;;
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "MINSIZE is %u\n", sub->sampler_size_est_min);
+ GNUNET_assert (0 != round_interval.rel_value_us);
+ sub->round_interval = round_interval;
+ sub->sampler = RPS_sampler_init (sampler_size,
+ round_interval);
+
+ /* Logging of internals */
+#ifdef TO_FILE_FULL
+ sub->file_name_view_log = store_prefix_file_name (&own_identity, "view");
+#endif /* TO_FILE_FULL */
+#ifdef TO_FILE
+#ifdef TO_FILE_FULL
+ sub->file_name_observed_log = store_prefix_file_name (&own_identity,
+ "observed");
+#endif /* TO_FILE_FULL */
+ sub->num_observed_peers = 0;
+ sub->observed_unique_peers = GNUNET_CONTAINER_multipeermap_create (1,
+ GNUNET_NO);
+#endif /* TO_FILE */
+
+ /* Set up data structures for gossip */
+ sub->push_map = CustomPeerMap_create (4);
+ sub->pull_map = CustomPeerMap_create (4);
+ sub->view_size_est_min = sampler_size;;
+ sub->view = View_create (sub->view_size_est_min);
+ if (sub == msub)
+ {
+ GNUNET_STATISTICS_set (stats,
+ "view size aim",
+ sub->view_size_est_min,
+ GNUNET_NO);
+ }
+
+ /* Start executing rounds */
+ sub->do_round_task = GNUNET_SCHEDULER_add_now (&do_round, sub);
+
+ return sub;
+}
+
+
+#ifdef TO_FILE
/**
- * @brief remove peer from our knowledge, the view, push and pull maps and
- * samplers.
+ * @brief Write all numbers in the given array into the given file
*
- * @param peer the peer to remove
+ * Single numbers devided by a newline
+ *
+ * @param hist_array[] the array to dump
+ * @param file_name file to dump into
*/
static void
-remove_peer (const struct GNUNET_PeerIdentity *peer)
+write_histogram_to_file (const uint32_t hist_array[],
+ const char *file_name)
{
- (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);
- RPS_sampler_reinitialise_by_value (client_sampler, peer);
- schedule_peer_destruction (get_peer_ctx (peer));
+ char collect_str[SIZE_DUMP_FILE + 1] = "";
+ char *recv_str_iter;
+ char *file_name_full;
+
+ recv_str_iter = collect_str;
+ file_name_full = store_prefix_file_name (&own_identity,
+ file_name);
+ for (uint32_t i = 0; i < HISTOGRAM_FILE_SLOTS; i++)
+ {
+ char collect_str_tmp[8];
+
+ GNUNET_snprintf (collect_str_tmp,
+ sizeof (collect_str_tmp),
+ "%" PRIu32 "\n",
+ hist_array[i]);
+ recv_str_iter = stpncpy (recv_str_iter,
+ collect_str_tmp,
+ 6);
+ }
+ (void) stpcpy (recv_str_iter,
+ "\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Writing push stats to disk\n");
+ to_file_w_len (file_name_full,
+ SIZE_DUMP_FILE,
+ collect_str);
+ GNUNET_free (file_name_full);
}
+#endif /* TO_FILE */
/**
- * @brief Remove data that is not needed anymore.
+ * @brief Destroy Sub.
*
- * If the sending channel is no longer needed it is destroyed.
- *
- * @param peer the peer whose data is about to be cleaned
+ * @param sub Sub to destroy
*/
static void
-clean_peer (const struct GNUNET_PeerIdentity *peer)
+destroy_sub (struct Sub *sub)
{
- 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))
- (void) Peers_destroy_sending_channel (peer);
- #else /* ENABLE_MALICIOUS */
- (void) Peers_destroy_sending_channel (peer);
- #endif /* ENABLE_MALICIOUS */
- }
+ GNUNET_assert (NULL != sub);
+ GNUNET_assert (NULL != sub->do_round_task);
+ GNUNET_SCHEDULER_cancel (sub->do_round_task);
+ sub->do_round_task = NULL;
+
+ /* Disconnect from cadet */
+ GNUNET_CADET_close_port (sub->cadet_port);
+ sub->cadet_port= NULL;
+
+ /* Clean up data structures for peers */
+ RPS_sampler_destroy (sub->sampler);
+ sub->sampler = NULL;
+ View_destroy (sub->view);
+ sub->view = NULL;
+ CustomPeerMap_destroy (sub->push_map);
+ sub->push_map = NULL;
+ CustomPeerMap_destroy (sub->pull_map);
+ sub->pull_map = NULL;
+ peers_terminate (sub);
+
+ /* Free leftover data structures */
+#ifdef TO_FILE_FULL
+ GNUNET_free (sub->file_name_view_log);
+ sub->file_name_view_log = NULL;
+#endif /* TO_FILE_FULL */
+#ifdef TO_FILE
+#ifdef TO_FILE_FULL
+ GNUNET_free (sub->file_name_observed_log);
+ sub->file_name_observed_log = NULL;
+#endif /* TO_FILE_FULL */
- if ( (GNUNET_NO == Peers_check_peer_send_intention (peer)) &&
- (GNUNET_NO == View_contains_peer (peer)) &&
- (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)) &&
- (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;
- }
+ /* Write push frequencies to disk */
+ write_histogram_to_file (sub->push_recv,
+ "push_recv");
+
+ /* Write push deltas to disk */
+ write_histogram_to_file (sub->push_delta,
+ "push_delta");
+
+ /* Write pull delays to disk */
+ write_histogram_to_file (sub->pull_delays,
+ "pull_delays");
+
+ GNUNET_CONTAINER_multipeermap_destroy (sub->observed_unique_peers);
+ sub->observed_unique_peers = NULL;
+#endif /* TO_FILE */
+
+ GNUNET_free (sub);
}
+
+/***********************************************************************
+ * /Sub
+***********************************************************************/
+
+
+/***********************************************************************
+ * Core handlers
+***********************************************************************/
+
/**
- * @brief Allocate memory for a new channel context and insert it into DLL
- *
- * @param peer_ctx context of the according peer
+ * @brief Callback on initialisation of Core.
*
- * @return The channel context
+ * @param cls - unused
+ * @param my_identity - unused
*/
-static struct ChannelCtx *
-add_channel_ctx (struct PeerContext *peer_ctx)
+void
+core_init (void *cls,
+ const struct GNUNET_PeerIdentity *my_identity)
{
- struct ChannelCtx *channel_ctx;
- channel_ctx = GNUNET_new (struct ChannelCtx);
- channel_ctx->peer_ctx = peer_ctx;
- return channel_ctx;
+ (void) cls;
+ (void) my_identity;
+
+ map_single_hop = GNUNET_CONTAINER_multipeermap_create (4, GNUNET_NO);
}
/**
- * @brief Remove the channel context from the DLL and free the memory.
+ * @brief Callback for core.
+ * Method called whenever a given peer connects.
*
- * @param channel_ctx The channel context.
+ * @param cls closure - unused
+ * @param peer peer identity this notification is about
+ * @return closure given to #core_disconnects as peer_cls
*/
-static void
-remove_channel_ctx (struct ChannelCtx *channel_ctx)
+void *
+core_connects (void *cls,
+ const struct GNUNET_PeerIdentity *peer,
+ struct GNUNET_MQ_Handle *mq)
{
- struct PeerContext *peer_ctx = channel_ctx->peer_ctx;
-
- if (NULL != channel_ctx->destruction_task)
- {
- GNUNET_SCHEDULER_cancel (channel_ctx->destruction_task);
- }
- GNUNET_free (channel_ctx);
- if (channel_ctx == peer_ctx->send_channel_ctx)
- {
- peer_ctx->send_channel_ctx = NULL;
- peer_ctx->mq = NULL;
- }
- else if (channel_ctx == peer_ctx->recv_channel_ctx)
- {
- peer_ctx->recv_channel_ctx = NULL;
- }
- else
- {
- GNUNET_assert (0);
- }
+ (void) cls;
+ (void) mq;
+
+ GNUNET_assert (GNUNET_YES ==
+ GNUNET_CONTAINER_multipeermap_put (map_single_hop,
+ peer,
+ NULL,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+ return NULL;
}
/**
- * @brief 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.
+ * @brief Callback for core.
+ * Method called whenever a peer disconnects.
*
- * @param cls The closure
- * @param channel The channel being closed
- * @param channel_ctx The context associated with this channel
+ * @param cls closure - unused
+ * @param peer peer identity this notification is about
+ * @param peer_cls closure given in #core_connects - unused
*/
-static void
-cleanup_destroyed_channel (void *cls,
- const struct GNUNET_CADET_Channel *channel)
+void
+core_disconnects (void *cls,
+ const struct GNUNET_PeerIdentity *peer,
+ void *peer_cls)
{
- struct ChannelCtx *channel_ctx = cls;
- struct PeerContext *peer_ctx = channel_ctx->peer_ctx;
-
- // What should be done here:
- // * cleanup everything related to the channel
- // * memory
- // * remove peer if necessary
+ (void) cls;
+ (void) peer_cls;
- if (peer_ctx->recv_channel_ctx == channel_ctx)
- {
- remove_channel_ctx (channel_ctx);
- }
- else if (peer_ctx->send_channel_ctx == channel_ctx)
- {
- remove_channel_ctx (channel_ctx);
- remove_peer (&peer_ctx->peer_id);
- }
+ GNUNET_CONTAINER_multipeermap_remove_all (map_single_hop, peer);
}
/***********************************************************************
- * /Util functions
+ * /Core handlers
***********************************************************************/
-static void
-destroy_reply_cls (struct ReplyCls *rep_cls)
-{
- struct ClientContext *cli_ctx;
-
- 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);
-}
-
+/**
+ * @brief Destroy the context for a (connected) client
+ *
+ * @param cli_ctx Context to destroy
+ */
static void
destroy_cli_ctx (struct ClientContext *cli_ctx)
{
GNUNET_assert (NULL != cli_ctx);
- if (NULL != cli_ctx->rep_cls_head)
- {
- LOG (GNUNET_ERROR_TYPE_WARNING,
- "Trying to destroy the context of a client that still has pending requests. Going to clean those\n");
- while (NULL != cli_ctx->rep_cls_head)
- destroy_reply_cls (cli_ctx->rep_cls_head);
- }
GNUNET_CONTAINER_DLL_remove (cli_ctx_head,
cli_ctx_tail,
cli_ctx);
+ if (NULL != cli_ctx->sub)
+ {
+ destroy_sub (cli_ctx->sub);
+ cli_ctx->sub = NULL;
+ }
GNUNET_free (cli_ctx);
}
/**
- * Function called by NSE.
+ * @brief Update sizes in sampler and view on estimate update from nse service
*
- * Updates sizes of sampler list and view and adapt those lists
- * accordingly.
+ * @param sub Sub
+ * @param logestimate the log(Base 2) value of the current network size estimate
+ * @param std_dev standard deviation for the estimate
*/
static void
-nse_callback (void *cls,
- struct GNUNET_TIME_Absolute timestamp,
- double logestimate, double std_dev)
+adapt_sizes (struct Sub *sub, double logestimate, double std_dev)
{
double estimate;
//double scale; // TODO this might go gloabal/config
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Received a ns estimate - logest: %f, std_dev: %f (old_size: %u)\n",
- logestimate, std_dev, RPS_sampler_get_size (prot_sampler));
+ logestimate, std_dev, RPS_sampler_get_size (sub->sampler));
//scale = .01;
estimate = GNUNET_NSE_log_estimate_to_n (logestimate);
// GNUNET_NSE_log_estimate_to_n (logestimate);
estimate = pow (estimate, 1.0 / 3);
// TODO add if std_dev is a number
// estimate += (std_dev * scale);
- if (view_size_est_min < ceil (estimate))
+ if (sub->view_size_est_min < ceil (estimate))
{
LOG (GNUNET_ERROR_TYPE_DEBUG, "Changing estimate to %f\n", estimate);
- sampler_size_est_need = estimate;
- view_size_est_need = estimate;
+ sub->sampler_size_est_need = estimate;
+ sub->view_size_est_need = estimate;
} else
{
LOG (GNUNET_ERROR_TYPE_DEBUG, "Not using estimate %f\n", estimate);
- //sampler_size_est_need = view_size_est_min;
- view_size_est_need = view_size_est_min;
+ //sub->sampler_size_est_need = sub->view_size_est_min;
+ sub->view_size_est_need = sub->view_size_est_min;
+ }
+ if (sub == msub)
+ {
+ GNUNET_STATISTICS_set (stats,
+ "view size aim",
+ sub->view_size_est_need,
+ GNUNET_NO);
}
/* If the NSE has changed adapt the lists accordingly */
- resize_wrapper (prot_sampler, sampler_size_est_need);
- client_resize_wrapper ();
+ resize_wrapper (sub->sampler, sub->sampler_size_est_need);
+ View_change_len (sub->view, sub->view_size_est_need);
}
/**
- * Callback called once the requested PeerIDs are ready.
+ * Function called by NSE.
+ *
+ * Updates sizes of sampler list and view and adapt those lists
+ * accordingly.
*
- * Sends those to the requesting client.
+ * implements #GNUNET_NSE_Callback
+ *
+ * @param cls Closure - unused
+ * @param timestamp time when the estimate was received from the server (or created by the server)
+ * @param logestimate the log(Base 2) value of the current network size estimate
+ * @param std_dev standard deviation for the estimate
*/
static void
-client_respond (void *cls,
- struct GNUNET_PeerIdentity *peer_ids,
- uint32_t num_peers)
+nse_callback (void *cls,
+ struct GNUNET_TIME_Absolute timestamp,
+ double logestimate, double std_dev)
{
- struct ReplyCls *reply_cls = cls;
- uint32_t i;
- struct GNUNET_MQ_Envelope *ev;
- struct GNUNET_RPS_CS_ReplyMessage *out_msg;
- uint32_t size_needed;
- struct ClientContext *cli_ctx;
+ (void) cls;
+ (void) timestamp;
+ struct ClientContext *cli_ctx_iter;
- GNUNET_assert (NULL != reply_cls);
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "sampler returned %" PRIu32 " peers:\n",
- num_peers);
- for (i = 0; i < num_peers; i++)
+ adapt_sizes (msub, logestimate, std_dev);
+ for (cli_ctx_iter = cli_ctx_head;
+ NULL != cli_ctx_iter;
+ cli_ctx_iter = cli_ctx_iter->next)
{
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- " %" PRIu32 ": %s\n",
- i,
- GNUNET_i2s (&peer_ids[i]));
+ if (NULL != cli_ctx_iter->sub)
+ {
+ adapt_sizes (cli_ctx_iter->sub, logestimate, std_dev);
+ }
}
+}
- size_needed = sizeof (struct GNUNET_RPS_CS_ReplyMessage) +
- num_peers * sizeof (struct GNUNET_PeerIdentity);
-
- GNUNET_assert (GNUNET_MAX_MESSAGE_SIZE >= size_needed);
-
- ev = GNUNET_MQ_msg_extra (out_msg,
- num_peers * sizeof (struct GNUNET_PeerIdentity),
- GNUNET_MESSAGE_TYPE_RPS_CS_REPLY);
- out_msg->num_peers = htonl (num_peers);
- out_msg->id = htonl (reply_cls->id);
- GNUNET_memcpy (&out_msg[1],
- peer_ids,
- num_peers * sizeof (struct GNUNET_PeerIdentity));
+/**
+ * @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
+ * #GNUNET_SYSERR otherwise
+ */
+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);
- 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);
+ msize -= sizeof (struct GNUNET_RPS_CS_SeedMessage);
+ if ( (msize / sizeof (struct GNUNET_PeerIdentity) != num_peers) ||
+ (msize % sizeof (struct GNUNET_PeerIdentity) != 0) )
+ {
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ "message says it sends %" PRIu32 " peers, have space for %lu peers\n",
+ ntohl (msg->num_peers),
+ (msize / sizeof (struct GNUNET_PeerIdentity)));
+ GNUNET_break (0);
+ GNUNET_SERVICE_client_drop (cli_ctx->client);
+ return GNUNET_SYSERR;
+ }
+ return GNUNET_OK;
}
/**
- * Handle RPS request from the client.
+ * Handle seed from the client.
*
* @param cls closure
* @param message the actual message
*/
static void
-handle_client_request (void *cls,
- const struct GNUNET_RPS_CS_RequestMessage *msg)
+handle_client_seed (void *cls,
+ const struct GNUNET_RPS_CS_SeedMessage *msg)
{
struct ClientContext *cli_ctx = cls;
+ struct GNUNET_PeerIdentity *peers;
uint32_t num_peers;
- uint32_t size_needed;
- struct ReplyCls *reply_cls;
uint32_t i;
num_peers = ntohl (msg->num_peers);
- size_needed = sizeof (struct GNUNET_RPS_CS_RequestMessage) +
- num_peers * sizeof (struct GNUNET_PeerIdentity);
-
- if (GNUNET_MAX_MESSAGE_SIZE < size_needed)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Message received from client has size larger than expected\n");
- GNUNET_SERVICE_client_drop (cli_ctx->client);
- return;
- }
-
- for (i = 0 ; i < num_peers ; i++)
- est_request_rate();
+ peers = (struct GNUNET_PeerIdentity *) &msg[1];
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Client requested %" PRIu32 " random peer(s).\n",
- num_peers);
+ "Client seeded peers:\n");
+ print_peer_list (peers, num_peers);
- reply_cls = GNUNET_new (struct ReplyCls);
- reply_cls->id = ntohl (msg->id);
- reply_cls->cli_ctx = cli_ctx;
- reply_cls->req_handle = RPS_sampler_get_n_rand_peers (client_sampler,
- client_respond,
- reply_cls,
- num_peers);
+ for (i = 0; i < num_peers; i++)
+ {
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Updating samplers with seed %" PRIu32 ": %s\n",
+ i,
+ GNUNET_i2s (&peers[i]));
- GNUNET_assert (NULL != cli_ctx);
- GNUNET_CONTAINER_DLL_insert (cli_ctx->rep_cls_head,
- cli_ctx->rep_cls_tail,
- reply_cls);
+ if (NULL != msub) got_peer (msub, &peers[i]); /* Condition needed? */
+ if (NULL != cli_ctx->sub) got_peer (cli_ctx->sub, &peers[i]);
+ }
GNUNET_SERVICE_client_continue (cli_ctx->client);
}
/**
- * @brief Handle a message that requests the cancellation of a request
+ * Handle RPS request from the client.
*
- * @param cls unused
- * @param message the message containing the id of the request
+ * @param cls Client context
+ * @param message Message containing the numer of updates the client wants to
+ * receive
*/
static void
-handle_client_request_cancel (void *cls,
- const struct GNUNET_RPS_CS_RequestCancelMessage *msg)
+handle_client_view_request (void *cls,
+ const struct GNUNET_RPS_CS_DEBUG_ViewRequest *msg)
{
struct ClientContext *cli_ctx = cls;
- struct ReplyCls *rep_cls;
+ uint64_t num_updates;
+
+ num_updates = ntohl (msg->num_updates);
- 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 %" PRIu32 "\n",
- ntohl (msg->id));
- while ( (NULL != rep_cls->next) &&
- (rep_cls->id != ntohl (msg->id)) )
- rep_cls = rep_cls->next;
- GNUNET_assert (rep_cls->id == ntohl (msg->id));
- destroy_reply_cls (rep_cls);
+ "Client requested %" PRIu64 " updates of view.\n",
+ num_updates);
+
+ GNUNET_assert (NULL != cli_ctx);
+ cli_ctx->view_updates_left = num_updates;
+ send_view (cli_ctx, NULL, 0);
GNUNET_SERVICE_client_continue (cli_ctx->client);
}
/**
- * @brief This function is called, when the client seeds peers.
- * It verifies that @a msg is well-formed.
+ * @brief Handle the cancellation of the view updates.
*
- * @param cls the closure (#ClientContext)
- * @param msg the message
- * @return #GNUNET_OK if @a msg is well-formed
+ * @param cls The client context
+ * @param msg Unused
*/
-static int
-check_client_seed (void *cls, const struct GNUNET_RPS_CS_SeedMessage *msg)
+static void
+handle_client_view_cancel (void *cls,
+ const struct GNUNET_MessageHeader *msg)
{
struct ClientContext *cli_ctx = cls;
- uint16_t msize = ntohs (msg->header.size);
- uint32_t num_peers = ntohl (msg->num_peers);
+ (void) msg;
- msize -= sizeof (struct GNUNET_RPS_CS_SeedMessage);
- if ( (msize / sizeof (struct GNUNET_PeerIdentity) != num_peers) ||
- (msize % sizeof (struct GNUNET_PeerIdentity) != 0) )
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Client does not want to receive updates of view any more.\n");
+
+ GNUNET_assert (NULL != cli_ctx);
+ cli_ctx->view_updates_left = 0;
+ GNUNET_SERVICE_client_continue (cli_ctx->client);
+ if (GNUNET_YES == cli_ctx->stream_update)
{
- GNUNET_break (0);
- GNUNET_SERVICE_client_drop (cli_ctx->client);
- return GNUNET_SYSERR;
+ destroy_cli_ctx (cli_ctx);
}
- return GNUNET_OK;
}
/**
- * Handle seed from the client.
- *
- * @param cls closure
- * @param message the actual message
- */
-static void
-handle_client_seed (void *cls,
- const struct GNUNET_RPS_CS_SeedMessage *msg)
-{
- struct ClientContext *cli_ctx = cls;
- struct GNUNET_PeerIdentity *peers;
- uint32_t num_peers;
- uint32_t i;
-
- num_peers = ntohl (msg->num_peers);
- peers = (struct GNUNET_PeerIdentity *) &msg[1];
+ * Handle RPS request for biased stream from the client.
+ *
+ * @param cls Client context
+ * @param message unused
+ */
+static void
+handle_client_stream_request (void *cls,
+ const struct GNUNET_RPS_CS_DEBUG_StreamRequest *msg)
+{
+ struct ClientContext *cli_ctx = cls;
+ (void) msg;
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Client seeded peers:\n");
- print_peer_list (peers, num_peers);
-
- for (i = 0; i < num_peers; i++)
- {
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Updating samplers with seed %" PRIu32 ": %s\n",
- i,
- GNUNET_i2s (&peers[i]));
+ "Client requested peers from biased stream.\n");
+ cli_ctx->stream_update = GNUNET_YES;
- got_peer (&peers[i]);
- }
+ GNUNET_assert (NULL != cli_ctx);
GNUNET_SERVICE_client_continue (cli_ctx->client);
}
+
/**
- * @brief Send view to client
+ * @brief Handles the cancellation of the stream of biased peer ids
*
- * @param cli_ctx the context of the client
- * @param view_array the peerids of the view as array (can be empty)
- * @param view_size the size of the view array (can be 0)
+ * @param cls The client context
+ * @param msg unused
*/
-void
-send_view (const struct ClientContext *cli_ctx,
- const struct GNUNET_PeerIdentity *view_array,
- uint64_t view_size)
+static void
+handle_client_stream_cancel (void *cls,
+ const struct GNUNET_MessageHeader *msg)
{
- struct GNUNET_MQ_Envelope *ev;
- struct GNUNET_RPS_CS_DEBUG_ViewReply *out_msg;
-
- if (NULL == view_array)
- {
- view_size = View_size ();
- view_array = View_get_as_array();
- }
+ struct ClientContext *cli_ctx = cls;
+ (void) msg;
- ev = GNUNET_MQ_msg_extra (out_msg,
- view_size * sizeof (struct GNUNET_PeerIdentity),
- GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_REPLY);
- out_msg->num_peers = htonl (view_size);
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Client canceled receiving peers from biased stream.\n");
+ cli_ctx->stream_update = GNUNET_NO;
- GNUNET_memcpy (&out_msg[1],
- view_array,
- view_size * sizeof (struct GNUNET_PeerIdentity));
- GNUNET_MQ_send (cli_ctx->mq, ev);
+ GNUNET_assert (NULL != cli_ctx);
+ GNUNET_SERVICE_client_continue (cli_ctx->client);
}
+
/**
- * @brief sends updates to clients that are interested
+ * @brief Create and start a Sub.
+ *
+ * @param cls Closure - unused
+ * @param msg Message containing the necessary information
*/
static void
-clients_notify_view_update (void)
+handle_client_start_sub (void *cls,
+ const struct GNUNET_RPS_CS_SubStartMessage *msg)
{
- struct ClientContext *cli_ctx_iter;
- uint64_t num_peers;
- const struct GNUNET_PeerIdentity *view_array;
-
- num_peers = View_size ();
- view_array = View_get_as_array();
- /* check size of view is small enough */
- if (GNUNET_MAX_MESSAGE_SIZE < num_peers)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "View is too big to send\n");
- return;
- }
+ struct ClientContext *cli_ctx = cls;
- for (cli_ctx_iter = cli_ctx_head;
- NULL != cli_ctx_iter;
- cli_ctx_iter = cli_ctx_head->next)
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Client requested start of a new sub.\n");
+ if (NULL != cli_ctx->sub &&
+ 0 != memcmp (&cli_ctx->sub->hash,
+ &msg->hash,
+ sizeof (struct GNUNET_HashCode)))
{
- if (1 < cli_ctx_iter->view_updates_left)
- {
- /* Client wants to receive limited amount of updates */
- cli_ctx_iter->view_updates_left -= 1;
- } else if (1 == cli_ctx_iter->view_updates_left)
- {
- /* Last update of view for client */
- cli_ctx_iter->view_updates_left = -1;
- } else if (0 > cli_ctx_iter->view_updates_left) {
- /* Client is not interested in updates */
- continue;
- }
- /* else _updates_left == 0 - infinite amount of updates */
-
- /* send view */
- send_view (cli_ctx_iter, view_array, num_peers);
+ LOG (GNUNET_ERROR_TYPE_WARNING, "Already have a Sub with different share for this client. Remove old one, add new.\n");
+ destroy_sub (cli_ctx->sub);
+ cli_ctx->sub = NULL;
}
+ cli_ctx->sub = new_sub (&msg->hash,
+ msub->sampler_size_est_min, // TODO make api input?
+ GNUNET_TIME_relative_ntoh (msg->round_interval));
+ GNUNET_SERVICE_client_continue (cli_ctx->client);
}
/**
- * Handle RPS request from the client.
+ * @brief Destroy the Sub
*
- * @param cls closure
- * @param message the actual message
+ * @param cls Closure - unused
+ * @param msg Message containing the hash that identifies the Sub
*/
static void
-handle_client_view_request (void *cls,
- const struct GNUNET_RPS_CS_DEBUG_ViewRequest *msg)
+handle_client_stop_sub (void *cls,
+ const struct GNUNET_RPS_CS_SubStopMessage *msg)
{
struct ClientContext *cli_ctx = cls;
- uint64_t num_updates;
-
- num_updates = ntohl (msg->num_updates);
-
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Client requested %" PRIu64 " updates of view.\n",
- num_updates);
- GNUNET_assert (NULL != cli_ctx);
- cli_ctx->view_updates_left = num_updates;
- send_view (cli_ctx, NULL, 0);
+ GNUNET_assert (NULL != cli_ctx->sub);
+ if (0 != memcmp (&cli_ctx->sub->hash, &msg->hash, sizeof (struct GNUNET_HashCode)))
+ {
+ LOG (GNUNET_ERROR_TYPE_WARNING, "Share of current sub and request differ!\n");
+ }
+ destroy_sub (cli_ctx->sub);
+ cli_ctx->sub = NULL;
GNUNET_SERVICE_client_continue (cli_ctx->client);
}
+
/**
* 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 msg The message header
+ * @param cls Closure - Context of channel
+ * @param msg Message - unused
*/
static void
handle_peer_check (void *cls,
{
const struct ChannelCtx *channel_ctx = cls;
const struct GNUNET_PeerIdentity *peer = &channel_ctx->peer_ctx->peer_id;
+ (void) msg;
+
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Received CHECK_LIVE (%s)\n", GNUNET_i2s (peer));
+ if (channel_ctx->peer_ctx->sub == msub)
+ {
+ GNUNET_STATISTICS_update (stats,
+ "# pending online checks",
+ -1,
+ GNUNET_NO);
+ }
GNUNET_CADET_receive_done (channel_ctx->channel);
}
+
/**
* Handle a PUSH message from another peer.
*
* Check the proof of work and store the PeerID
* in the temporary list for pushed PeerIDs.
*
- * @param cls Closure
- * @param msg The message header
+ * @param cls Closure - Context of channel
+ * @param msg Message - unused
*/
static void
handle_peer_push (void *cls,
{
const struct ChannelCtx *channel_ctx = cls;
const struct GNUNET_PeerIdentity *peer = &channel_ctx->peer_ctx->peer_id;
+ (void) msg;
// (check the proof of work (?))
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Received PUSH (%s)\n",
GNUNET_i2s (peer));
- GNUNET_STATISTICS_update(stats, "# push message received", 1, GNUNET_NO);
+ if (channel_ctx->peer_ctx->sub == msub)
+ {
+ GNUNET_STATISTICS_update(stats, "# push message received", 1, GNUNET_NO);
+ if (NULL != map_single_hop &&
+ GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (map_single_hop,
+ peer))
+ {
+ GNUNET_STATISTICS_update (stats,
+ "# push message received (multi-hop peer)",
+ 1,
+ GNUNET_NO);
+ }
+ }
- #ifdef ENABLE_MALICIOUS
+ #if ENABLE_MALICIOUS
struct AttackedPeer *tmp_att_peer;
if ( (1 == mal_type) ||
tmp_att_peer->peer_id = *peer;
if (NULL == att_peer_set)
att_peer_set = GNUNET_CONTAINER_multipeermap_create (1, GNUNET_NO);
- if (GNUNET_NO ==
- GNUNET_CONTAINER_multipeermap_contains (att_peer_set,
- peer))
+ if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (att_peer_set,
+ peer))
{
GNUNET_CONTAINER_DLL_insert (att_peers_head,
att_peers_tail,
#endif /* ENABLE_MALICIOUS */
/* Add the sending peer to the push_map */
- CustomPeerMap_put (push_map, peer);
+ CustomPeerMap_put (channel_ctx->peer_ctx->sub->push_map, peer);
- GNUNET_break_op (Peers_check_peer_known (peer));
+ GNUNET_break_op (check_peer_known (channel_ctx->peer_ctx->sub->peer_map,
+ &channel_ctx->peer_ctx->peer_id));
GNUNET_CADET_receive_done (channel_ctx->channel);
}
*
* Reply with the view of PeerIDs.
*
- * @param cls Closure
- * @param msg The message header
+ * @param cls Closure - Context of channel
+ * @param msg Message - unused
*/
static void
handle_peer_pull_request (void *cls,
const struct GNUNET_MessageHeader *msg)
{
const struct ChannelCtx *channel_ctx = cls;
- const struct GNUNET_PeerIdentity *peer = &channel_ctx->peer_ctx->peer_id;
+ struct PeerContext *peer_ctx = channel_ctx->peer_ctx;
+ const struct GNUNET_PeerIdentity *peer = &peer_ctx->peer_id;
const struct GNUNET_PeerIdentity *view_array;
+ (void) msg;
LOG (GNUNET_ERROR_TYPE_DEBUG, "Received PULL REQUEST (%s)\n", GNUNET_i2s (peer));
- GNUNET_STATISTICS_update(stats, "# pull request message received", 1, GNUNET_NO);
+ if (peer_ctx->sub == msub)
+ {
+ GNUNET_STATISTICS_update(stats,
+ "# pull request message received",
+ 1,
+ GNUNET_NO);
+ if (NULL != map_single_hop &&
+ GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (map_single_hop,
+ &peer_ctx->peer_id))
+ {
+ GNUNET_STATISTICS_update (stats,
+ "# pull request message received (multi-hop peer)",
+ 1,
+ GNUNET_NO);
+ }
+ }
- #ifdef ENABLE_MALICIOUS
+ #if ENABLE_MALICIOUS
if (1 == mal_type
|| 3 == mal_type)
{ /* Try to maximise representation */
- send_pull_reply (peer, mal_peers, num_mal_peers);
+ send_pull_reply (peer_ctx, mal_peers, num_mal_peers);
}
else if (2 == mal_type)
{ /* Try to partition network */
- if (0 == GNUNET_CRYPTO_cmp_peer_identity (&attacked_peer, peer))
+ if (0 == GNUNET_memcmp (&attacked_peer, peer))
{
- send_pull_reply (peer, mal_peers, num_mal_peers);
+ send_pull_reply (peer_ctx, mal_peers, num_mal_peers);
}
}
#endif /* ENABLE_MALICIOUS */
- GNUNET_break_op (Peers_check_peer_known (peer));
+ GNUNET_break_op (check_peer_known (channel_ctx->peer_ctx->sub->peer_map,
+ &channel_ctx->peer_ctx->peer_id));
GNUNET_CADET_receive_done (channel_ctx->channel);
- view_array = View_get_as_array ();
- send_pull_reply (peer, view_array, View_size ());
+ view_array = View_get_as_array (channel_ctx->peer_ctx->sub->view);
+ send_pull_reply (peer_ctx,
+ view_array,
+ View_size (channel_ctx->peer_ctx->sub->view));
}
* Check whether we sent a corresponding request and
* whether this reply is the first one.
*
- * @param cls Closure
- * @param msg The message header
+ * @param cls Closure - Context of channel
+ * @param msg Message containing the replied peers
*/
static int
check_peer_pull_reply (void *cls,
const struct GNUNET_RPS_P2P_PullReplyMessage *msg)
{
- struct GNUNET_PeerIdentity *sender = cls;
+ struct ChannelCtx *channel_ctx = cls;
+ struct PeerContext *sender_ctx = channel_ctx->peer_ctx;
if (sizeof (struct GNUNET_RPS_P2P_PullReplyMessage) > ntohs (msg->header.size))
{
return GNUNET_SYSERR;
}
- if (GNUNET_YES != Peers_check_peer_flag (sender, Peers_PULL_REPLY_PENDING))
+ if (GNUNET_YES != check_peer_flag (sender_ctx->sub->peer_map,
+ &sender_ctx->peer_id,
+ Peers_PULL_REPLY_PENDING))
{
LOG (GNUNET_ERROR_TYPE_WARNING,
"Received a pull reply from a peer (%s) we didn't request one from!\n",
- GNUNET_i2s (sender));
- GNUNET_break_op (0);
- return GNUNET_SYSERR;
+ GNUNET_i2s (&sender_ctx->peer_id));
+ if (sender_ctx->sub == msub)
+ {
+ GNUNET_STATISTICS_update (stats,
+ "# unrequested pull replies",
+ 1,
+ GNUNET_NO);
+ }
}
return GNUNET_OK;
}
+
/**
* Handle PULL REPLY message from another peer.
*
const struct ChannelCtx *channel_ctx = cls;
const struct GNUNET_PeerIdentity *sender = &channel_ctx->peer_ctx->peer_id;
const struct GNUNET_PeerIdentity *peers;
+ struct Sub *sub = channel_ctx->peer_ctx->sub;
uint32_t i;
-#ifdef ENABLE_MALICIOUS
+#if ENABLE_MALICIOUS
struct AttackedPeer *tmp_att_peer;
#endif /* ENABLE_MALICIOUS */
+ sub->pull_delays[sub->num_rounds - channel_ctx->peer_ctx->round_pull_req]++;
LOG (GNUNET_ERROR_TYPE_DEBUG, "Received PULL REPLY (%s)\n", GNUNET_i2s (sender));
- GNUNET_STATISTICS_update(stats, "# pull reply messages received", 1, GNUNET_NO);
+ if (channel_ctx->peer_ctx->sub == msub)
+ {
+ GNUNET_STATISTICS_update (stats,
+ "# pull reply messages received",
+ 1,
+ GNUNET_NO);
+ if (NULL != map_single_hop &&
+ GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (map_single_hop,
+ &channel_ctx->peer_ctx->peer_id))
+ {
+ GNUNET_STATISTICS_update (stats,
+ "# pull reply messages received (multi-hop peer)",
+ 1,
+ GNUNET_NO);
+ }
+ }
- #ifdef ENABLE_MALICIOUS
+ #if ENABLE_MALICIOUS
// We shouldn't even receive pull replies as we're not sending
if (2 == mal_type)
{
i,
GNUNET_i2s (&peers[i]));
- #ifdef ENABLE_MALICIOUS
+ #if ENABLE_MALICIOUS
if ((NULL != att_peer_set) &&
(1 == mal_type || 3 == mal_type))
{ /* Add attacked peer to local list */
}
#endif /* ENABLE_MALICIOUS */
/* Make sure we 'know' about this peer */
- (void) Peers_insert_peer (&peers[i]);
+ (void) insert_peer (channel_ctx->peer_ctx->sub,
+ &peers[i]);
- if (GNUNET_YES == Peers_check_peer_valid (&peers[i]))
+ if (GNUNET_YES == check_peer_valid (channel_ctx->peer_ctx->sub->valid_peers,
+ &peers[i]))
{
- CustomPeerMap_put (pull_map, &peers[i]);
+ CustomPeerMap_put (channel_ctx->peer_ctx->sub->pull_map,
+ &peers[i]);
}
else
{
- Peers_schedule_operation (&peers[i], insert_in_pull_map);
- (void) Peers_issue_peer_liveliness_check (&peers[i]);
+ schedule_operation (channel_ctx->peer_ctx,
+ insert_in_pull_map,
+ channel_ctx->peer_ctx->sub); /* cls */
+ (void) issue_peer_online_check (channel_ctx->peer_ctx->sub,
+ &peers[i]);
}
}
- Peers_unset_peer_flag (sender, Peers_PULL_REPLY_PENDING);
- clean_peer (sender);
+ UNSET_PEER_FLAG (get_peer_ctx (channel_ctx->peer_ctx->sub->peer_map,
+ sender),
+ Peers_PULL_REPLY_PENDING);
+ clean_peer (channel_ctx->peer_ctx->sub,
+ sender);
- GNUNET_break_op (Peers_check_peer_known (sender));
+ GNUNET_break_op (check_peer_known (channel_ctx->peer_ctx->sub->peer_map,
+ sender));
GNUNET_CADET_receive_done (channel_ctx->channel);
}
* For example for mean 4 min and spread 2 the minimum is (4 min - (1/2 * 4 min))
* It would return a random value between 2 and 6 min.
*
- * @param mean the mean
+ * @param mean the mean time until the next round
* @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)
+ unsigned int spread)
{
struct GNUNET_TIME_Relative half_interval;
struct GNUNET_TIME_Relative ret;
/**
* Send single pull request
*
- * @param peer_id the peer to send the pull request to.
+ * @param peer_ctx Context to the peer to send request to
*/
static void
-send_pull_request (const struct GNUNET_PeerIdentity *peer)
+send_pull_request (struct PeerContext *peer_ctx)
{
struct GNUNET_MQ_Envelope *ev;
- GNUNET_assert (GNUNET_NO == Peers_check_peer_flag (peer,
- Peers_PULL_REPLY_PENDING));
- Peers_set_peer_flag (peer, Peers_PULL_REPLY_PENDING);
+ GNUNET_assert (GNUNET_NO == check_peer_flag (peer_ctx->sub->peer_map,
+ &peer_ctx->peer_id,
+ Peers_PULL_REPLY_PENDING));
+ SET_PEER_FLAG (peer_ctx,
+ Peers_PULL_REPLY_PENDING);
+ peer_ctx->round_pull_req = peer_ctx->sub->num_rounds;
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Going to send PULL REQUEST to peer %s.\n",
- GNUNET_i2s (peer));
+ GNUNET_i2s (&peer_ctx->peer_id));
ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REQUEST);
- Peers_send_message (peer, ev, "PULL REQUEST");
- GNUNET_STATISTICS_update(stats, "# pull request send issued", 1, GNUNET_NO);
+ send_message (peer_ctx,
+ ev,
+ "PULL REQUEST");
+ if (peer_ctx->sub)
+ {
+ GNUNET_STATISTICS_update (stats,
+ "# pull request send issued",
+ 1,
+ GNUNET_NO);
+ if (NULL != map_single_hop &&
+ GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (map_single_hop,
+ &peer_ctx->peer_id))
+ {
+ GNUNET_STATISTICS_update (stats,
+ "# pull request send issued (multi-hop peer)",
+ 1,
+ GNUNET_NO);
+ }
+ }
}
/**
* Send single push
*
- * @param peer_id the peer to send the push to.
+ * @param peer_ctx Context of peer to send push to
*/
static void
-send_push (const struct GNUNET_PeerIdentity *peer_id)
+send_push (struct PeerContext *peer_ctx)
{
struct GNUNET_MQ_Envelope *ev;
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Going to send PUSH to peer %s.\n",
- GNUNET_i2s (peer_id));
+ GNUNET_i2s (&peer_ctx->peer_id));
ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_RPS_PP_PUSH);
- Peers_send_message (peer_id, ev, "PUSH");
- GNUNET_STATISTICS_update(stats, "# push send issued", 1, GNUNET_NO);
+ send_message (peer_ctx, ev, "PUSH");
+ if (peer_ctx->sub)
+ {
+ GNUNET_STATISTICS_update (stats,
+ "# push send issued",
+ 1,
+ GNUNET_NO);
+ if (NULL != map_single_hop &&
+ GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (map_single_hop,
+ &peer_ctx->peer_id))
+ {
+ GNUNET_STATISTICS_update (stats,
+ "# push send issued (multi-hop peer)",
+ 1,
+ GNUNET_NO);
+ }
+ }
}
-static void
-do_round (void *cls);
-
-static void
-do_mal_round (void *cls);
-
-#ifdef ENABLE_MALICIOUS
+#if ENABLE_MALICIOUS
/**
struct GNUNET_PeerIdentity *peers;
uint32_t num_mal_peers_sent;
uint32_t num_mal_peers_old;
+ struct Sub *sub = cli_ctx->sub;
+ if (NULL == sub) sub = msub;
/* Do actual logic */
peers = (struct GNUNET_PeerIdentity *) &msg[1];
mal_type = ntohl (msg->type);
mal_peer_set);
/* Substitute do_round () with do_mal_round () */
- GNUNET_SCHEDULER_cancel (do_round_task);
- do_round_task = GNUNET_SCHEDULER_add_now (&do_mal_round, NULL);
+ GNUNET_assert (NULL != sub->do_round_task);
+ GNUNET_SCHEDULER_cancel (sub->do_round_task);
+ sub->do_round_task = GNUNET_SCHEDULER_add_now (&do_mal_round, sub);
}
else if ( (2 == mal_type) ||
&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))
+ if (GNUNET_NO == check_peer_known (sub->peer_map, &attacked_peer))
{
- (void) Peers_issue_peer_liveliness_check (&attacked_peer);
+ (void) issue_peer_online_check (sub, &attacked_peer);
}
LOG (GNUNET_ERROR_TYPE_DEBUG,
GNUNET_i2s (&attacked_peer));
/* Substitute do_round () with do_mal_round () */
- GNUNET_SCHEDULER_cancel (do_round_task);
- do_round_task = GNUNET_SCHEDULER_add_now (&do_mal_round, NULL);
+ if (NULL != sub->do_round_task)
+ {
+ /* Probably in shutdown */
+ GNUNET_SCHEDULER_cancel (sub->do_round_task);
+ sub->do_round_task = GNUNET_SCHEDULER_add_now (&do_mal_round, sub);
+ }
}
else if (0 == mal_type)
{ /* Stop acting malicious */
GNUNET_array_grow (mal_peers, num_mal_peers, 0);
/* Substitute do_mal_round () with do_round () */
- GNUNET_SCHEDULER_cancel (do_round_task);
- do_round_task = GNUNET_SCHEDULER_add_now (&do_round, NULL);
+ GNUNET_SCHEDULER_cancel (sub->do_round_task);
+ sub->do_round_task = GNUNET_SCHEDULER_add_now (&do_round, sub);
}
else
{
* Send out PUSHes and PULLs maliciously.
*
* This is executed regylary.
+ *
+ * @param cls Closure - Sub
*/
static void
do_mal_round (void *cls)
uint32_t i;
struct GNUNET_TIME_Relative time_next_round;
struct AttackedPeer *tmp_att_peer;
+ struct Sub *sub = cls;
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Going to execute next round maliciously type %" PRIu32 ".\n",
mal_type);
- do_round_task = NULL;
+ sub->do_round_task = NULL;
GNUNET_assert (mal_type <= 3);
/* Do malicious actions */
if (1 == mal_type)
else
att_peer_index = att_peer_index->next;
- send_push (&att_peer_index->peer_id);
+ send_push (get_peer_ctx (sub->peer_map, &att_peer_index->peer_id));
}
/* Send PULLs to some peers to learn about additional peers to attack */
else
att_peer_index = tmp_att_peer->next;
- send_pull_request (&tmp_att_peer->peer_id);
+ send_pull_request (get_peer_ctx (sub->peer_map, &tmp_att_peer->peer_id));
}
}
* Send as many pushes to the attacked peer as possible
* That is one push per round as it will ignore more.
*/
- (void) Peers_issue_peer_liveliness_check (&attacked_peer);
- if (GNUNET_YES == Peers_check_peer_flag (&attacked_peer, Peers_ONLINE))
- send_push (&attacked_peer);
+ (void) issue_peer_online_check (sub, &attacked_peer);
+ if (GNUNET_YES == check_peer_flag (sub->peer_map,
+ &attacked_peer,
+ Peers_ONLINE))
+ send_push (get_peer_ctx (sub->peer_map, &attacked_peer));
}
{ /* Combined attack */
/* Send PUSH to attacked peers */
- if (GNUNET_YES == Peers_check_peer_known (&attacked_peer))
+ if (GNUNET_YES == check_peer_known (sub->peer_map, &attacked_peer))
{
- (void) Peers_issue_peer_liveliness_check (&attacked_peer);
- if (GNUNET_YES == Peers_check_peer_flag (&attacked_peer, Peers_ONLINE))
+ (void) issue_peer_online_check (sub, &attacked_peer);
+ if (GNUNET_YES == check_peer_flag (sub->peer_map,
+ &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);
+ send_push (get_peer_ctx (sub->peer_map, &attacked_peer));
}
}
- (void) Peers_issue_peer_liveliness_check (&attacked_peer);
+ (void) issue_peer_online_check (sub, &attacked_peer);
/* The maximum of pushes we're going to send this round */
num_pushes = GNUNET_MIN (GNUNET_MIN (push_limit - 1,
else
att_peer_index = att_peer_index->next;
- send_push (&att_peer_index->peer_id);
+ send_push (get_peer_ctx (sub->peer_map, &att_peer_index->peer_id));
}
/* Send PULLs to some peers to learn about additional peers to attack */
else
att_peer_index = tmp_att_peer->next;
- send_pull_request (&tmp_att_peer->peer_id);
+ send_pull_request (get_peer_ctx (sub->peer_map, &tmp_att_peer->peer_id));
}
}
/* Schedule next round */
- time_next_round = compute_rand_delay (round_interval, 2);
+ time_next_round = compute_rand_delay (sub->round_interval, 2);
- //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);
+ GNUNET_assert (NULL == sub->do_round_task);
+ sub->do_round_task = GNUNET_SCHEDULER_add_delayed (time_next_round,
+ &do_mal_round, sub);
LOG (GNUNET_ERROR_TYPE_DEBUG, "Finished round\n");
}
#endif /* ENABLE_MALICIOUS */
+
/**
* Send out PUSHes and PULLs, possibly update #view, samplers.
*
* This is executed regylary.
+ *
+ * @param cls Closure - Sub
*/
static void
do_round (void *cls)
{
- uint32_t i;
+ unsigned int i;
const struct GNUNET_PeerIdentity *view_array;
unsigned int *permut;
unsigned int a_peers; /* Number of peers we send pushes to */
uint32_t second_border;
struct GNUNET_PeerIdentity peer;
struct GNUNET_PeerIdentity *update_peer;
+ struct Sub *sub = cls;
+ sub->num_rounds++;
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Going to execute next round.\n");
- GNUNET_STATISTICS_update(stats, "# rounds", 1, GNUNET_NO);
- do_round_task = NULL;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Printing view:\n");
- to_file (file_name_view_log,
+ if (sub == msub)
+ {
+ GNUNET_STATISTICS_update (stats, "# rounds", 1, GNUNET_NO);
+ }
+ sub->do_round_task = NULL;
+#ifdef TO_FILE_FULL
+ to_file (sub->file_name_view_log,
"___ new round ___");
- view_array = View_get_as_array ();
- for (i = 0; i < View_size (); i++)
+#endif /* TO_FILE_FULL */
+ view_array = View_get_as_array (sub->view);
+ for (i = 0; i < View_size (sub->view); i++)
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"\t%s\n", GNUNET_i2s (&view_array[i]));
- to_file (file_name_view_log,
+#ifdef TO_FILE_FULL
+ to_file (sub->file_name_view_log,
"=%s\t(do round)",
GNUNET_i2s_full (&view_array[i]));
+#endif /* TO_FILE_FULL */
}
/* Send pushes and pull requests */
- if (0 < View_size ())
+ if (0 < View_size (sub->view))
{
permut = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_STRONG,
- View_size ());
+ View_size (sub->view));
/* Send PUSHes */
- a_peers = ceil (alpha * View_size ());
+ a_peers = ceil (alpha * View_size (sub->view));
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Going to send pushes to %u (ceil (%f * %u)) peers.\n",
- a_peers, alpha, View_size ());
+ a_peers, alpha, View_size (sub->view));
for (i = 0; i < a_peers; i++)
{
peer = view_array[permut[i]];
// FIXME if this fails schedule/loop this for later
- send_push (&peer);
+ send_push (get_peer_ctx (sub->peer_map, &peer));
}
/* Send PULL requests */
- b_peers = ceil (beta * View_size ());
+ b_peers = ceil (beta * View_size (sub->view));
first_border = a_peers;
second_border = a_peers + b_peers;
- if (second_border > View_size ())
+ if (second_border > View_size (sub->view))
{
- first_border = View_size () - b_peers;
- second_border = View_size ();
+ first_border = View_size (sub->view) - b_peers;
+ second_border = View_size (sub->view);
}
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Going to send pulls to %u (ceil (%f * %u)) peers.\n",
- b_peers, beta, View_size ());
+ b_peers, beta, View_size (sub->view));
for (i = first_border; i < second_border; i++)
{
peer = view_array[permut[i]];
- if ( GNUNET_NO == Peers_check_peer_flag (&peer, Peers_PULL_REPLY_PENDING))
+ if ( GNUNET_NO == check_peer_flag (sub->peer_map,
+ &peer,
+ Peers_PULL_REPLY_PENDING))
{ // FIXME if this fails schedule/loop this for later
- send_pull_request (&peer);
+ send_pull_request (get_peer_ctx (sub->peer_map, &peer));
}
}
/* Update view */
/* TODO see how many peers are in push-/pull- list! */
- if ((CustomPeerMap_size (push_map) <= alpha * view_size_est_need) &&
- (0 < CustomPeerMap_size (push_map)) &&
- (0 < CustomPeerMap_size (pull_map)))
- //if (GNUNET_YES) // disable blocking temporarily
+ if ((CustomPeerMap_size (sub->push_map) <= alpha * sub->view_size_est_need) &&
+ (0 < CustomPeerMap_size (sub->push_map)) &&
+ (0 < CustomPeerMap_size (sub->pull_map)))
{ /* If conditions for update are fulfilled, update */
LOG (GNUNET_ERROR_TYPE_DEBUG, "Update of the view.\n");
peers_to_clean = NULL;
peers_to_clean_size = 0;
- GNUNET_array_grow (peers_to_clean, peers_to_clean_size, View_size ());
+ GNUNET_array_grow (peers_to_clean,
+ peers_to_clean_size,
+ View_size (sub->view));
GNUNET_memcpy (peers_to_clean,
view_array,
- View_size () * sizeof (struct GNUNET_PeerIdentity));
+ View_size (sub->view) * sizeof (struct GNUNET_PeerIdentity));
/* Seems like recreating is the easiest way of emptying the peermap */
- View_clear ();
- to_file (file_name_view_log,
+ View_clear (sub->view);
+#ifdef TO_FILE_FULL
+ to_file (sub->file_name_view_log,
"--- emptied ---");
+#endif /* TO_FILE_FULL */
- first_border = GNUNET_MIN (ceil (alpha * view_size_est_need),
- CustomPeerMap_size (push_map));
+ first_border = GNUNET_MIN (ceil (alpha * sub->view_size_est_need),
+ CustomPeerMap_size (sub->push_map));
second_border = first_border +
- GNUNET_MIN (floor (beta * view_size_est_need),
- CustomPeerMap_size (pull_map));
+ GNUNET_MIN (floor (beta * sub->view_size_est_need),
+ CustomPeerMap_size (sub->pull_map));
final_size = second_border +
- ceil ((1 - (alpha + beta)) * view_size_est_need);
+ ceil ((1 - (alpha + beta)) * sub->view_size_est_need);
LOG (GNUNET_ERROR_TYPE_DEBUG,
"first border: %" PRIu32 ", second border: %" PRIu32 ", final size: %"PRIu32 "\n",
first_border,
/* Update view with peers received through PUSHes */
permut = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_STRONG,
- CustomPeerMap_size (push_map));
+ CustomPeerMap_size (sub->push_map));
for (i = 0; i < first_border; i++)
{
- (void) insert_in_view (CustomPeerMap_get_peer_by_index (push_map,
- permut[i]));
- to_file (file_name_view_log,
+ int inserted;
+ inserted = insert_in_view (sub,
+ CustomPeerMap_get_peer_by_index (sub->push_map,
+ permut[i]));
+ if (GNUNET_OK == inserted)
+ {
+ clients_notify_stream_peer (sub,
+ 1,
+ CustomPeerMap_get_peer_by_index (sub->push_map, permut[i]));
+ }
+#ifdef TO_FILE_FULL
+ to_file (sub->file_name_view_log,
"+%s\t(push list)",
GNUNET_i2s_full (&view_array[i]));
+#endif /* TO_FILE_FULL */
// TODO change the peer_flags accordingly
}
GNUNET_free (permut);
/* Update view with peers received through PULLs */
permut = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_STRONG,
- CustomPeerMap_size (pull_map));
+ CustomPeerMap_size (sub->pull_map));
for (i = first_border; i < second_border; i++)
{
- (void) insert_in_view (CustomPeerMap_get_peer_by_index (pull_map,
- permut[i - first_border]));
- to_file (file_name_view_log,
+ int inserted;
+ inserted = insert_in_view (sub,
+ CustomPeerMap_get_peer_by_index (sub->pull_map,
+ permut[i - first_border]));
+ if (GNUNET_OK == inserted)
+ {
+ clients_notify_stream_peer (sub,
+ 1,
+ CustomPeerMap_get_peer_by_index (sub->pull_map,
+ permut[i - first_border]));
+ }
+#ifdef TO_FILE_FULL
+ to_file (sub->file_name_view_log,
"+%s\t(pull list)",
GNUNET_i2s_full (&view_array[i]));
+#endif /* TO_FILE_FULL */
// TODO change the peer_flags accordingly
}
GNUNET_free (permut);
permut = NULL;
/* Update view with peers from history */
- RPS_sampler_get_n_rand_peers (prot_sampler,
+ RPS_sampler_get_n_rand_peers (sub->sampler,
+ final_size - second_border,
hist_update,
- NULL,
- final_size - second_border);
+ sub);
// TODO change the peer_flags accordingly
- for (i = 0; i < View_size (); i++)
+ for (i = 0; i < View_size (sub->view); i++)
rem_from_list (&peers_to_clean, &peers_to_clean_size, &view_array[i]);
/* Clean peers that were removed from the view */
for (i = 0; i < peers_to_clean_size; i++)
{
- to_file (file_name_view_log,
+#ifdef TO_FILE_FULL
+ to_file (sub->file_name_view_log,
"-%s",
GNUNET_i2s_full (&peers_to_clean[i]));
- clean_peer (&peers_to_clean[i]);
+#endif /* TO_FILE_FULL */
+ clean_peer (sub, &peers_to_clean[i]);
}
GNUNET_array_grow (peers_to_clean, peers_to_clean_size, 0);
- clients_notify_view_update();
+ clients_notify_view_update (sub);
} else {
LOG (GNUNET_ERROR_TYPE_DEBUG, "No update of the view.\n");
- GNUNET_STATISTICS_update(stats, "# rounds blocked", 1, GNUNET_NO);
- if (CustomPeerMap_size (push_map) > alpha * View_size () &&
- !(0 >= CustomPeerMap_size (pull_map)))
- GNUNET_STATISTICS_update(stats, "# rounds blocked - too many pushes", 1, GNUNET_NO);
- if (CustomPeerMap_size (push_map) > alpha * View_size () &&
- (0 >= CustomPeerMap_size (pull_map)))
- GNUNET_STATISTICS_update(stats, "# rounds blocked - too many pushes, no pull replies", 1, GNUNET_NO);
- if (0 >= CustomPeerMap_size (push_map) &&
- !(0 >= CustomPeerMap_size (pull_map)))
- GNUNET_STATISTICS_update(stats, "# rounds blocked - no pushes", 1, GNUNET_NO);
- if (0 >= CustomPeerMap_size (push_map) &&
- (0 >= CustomPeerMap_size (pull_map)))
- GNUNET_STATISTICS_update(stats, "# rounds blocked - no pushes, no pull replies", 1, GNUNET_NO);
- if (0 >= CustomPeerMap_size (pull_map) &&
- CustomPeerMap_size (push_map) > alpha * View_size () &&
- 0 >= CustomPeerMap_size (push_map))
- GNUNET_STATISTICS_update(stats, "# rounds blocked - no pull replies", 1, GNUNET_NO);
+ if (sub == msub)
+ {
+ GNUNET_STATISTICS_update(stats, "# rounds blocked", 1, GNUNET_NO);
+ if (CustomPeerMap_size (sub->push_map) > alpha * sub->view_size_est_need &&
+ !(0 >= CustomPeerMap_size (sub->pull_map)))
+ GNUNET_STATISTICS_update(stats, "# rounds blocked - too many pushes", 1, GNUNET_NO);
+ if (CustomPeerMap_size (sub->push_map) > alpha * sub->view_size_est_need &&
+ (0 >= CustomPeerMap_size (sub->pull_map)))
+ GNUNET_STATISTICS_update(stats, "# rounds blocked - too many pushes, no pull replies", 1, GNUNET_NO);
+ if (0 >= CustomPeerMap_size (sub->push_map) &&
+ !(0 >= CustomPeerMap_size (sub->pull_map)))
+ GNUNET_STATISTICS_update(stats, "# rounds blocked - no pushes", 1, GNUNET_NO);
+ if (0 >= CustomPeerMap_size (sub->push_map) &&
+ (0 >= CustomPeerMap_size (sub->pull_map)))
+ GNUNET_STATISTICS_update(stats, "# rounds blocked - no pushes, no pull replies", 1, GNUNET_NO);
+ if (0 >= CustomPeerMap_size (sub->pull_map) &&
+ CustomPeerMap_size (sub->push_map) > alpha * sub->view_size_est_need &&
+ 0 >= CustomPeerMap_size (sub->push_map))
+ GNUNET_STATISTICS_update(stats, "# rounds blocked - no pull replies", 1, GNUNET_NO);
+ }
}
// TODO independent of that also get some peers from CADET_get_peers()?
- GNUNET_STATISTICS_set (stats,
- "# peers in push map at end of round",
- CustomPeerMap_size (push_map),
- GNUNET_NO);
- GNUNET_STATISTICS_set (stats,
- "# peers in pull map at end of round",
- CustomPeerMap_size (pull_map),
- GNUNET_NO);
- GNUNET_STATISTICS_set (stats,
- "# peers in view at end of round",
- View_size (),
- GNUNET_NO);
+ if (CustomPeerMap_size (sub->push_map) < HISTOGRAM_FILE_SLOTS)
+ {
+ sub->push_recv[CustomPeerMap_size (sub->push_map)]++;
+ }
+ else
+ {
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ "Push map size too big for histogram (%u, %u)\n",
+ CustomPeerMap_size (sub->push_map),
+ HISTOGRAM_FILE_SLOTS);
+ }
+ // FIXME check bounds of histogram
+ sub->push_delta[(int32_t) (CustomPeerMap_size (sub->push_map) -
+ (alpha * sub->view_size_est_need)) +
+ (HISTOGRAM_FILE_SLOTS/2)]++;
+ if (sub == msub)
+ {
+ GNUNET_STATISTICS_set (stats,
+ "# peers in push map at end of round",
+ CustomPeerMap_size (sub->push_map),
+ GNUNET_NO);
+ GNUNET_STATISTICS_set (stats,
+ "# peers in pull map at end of round",
+ CustomPeerMap_size (sub->pull_map),
+ GNUNET_NO);
+ GNUNET_STATISTICS_set (stats,
+ "# peers in view at end of round",
+ View_size (sub->view),
+ GNUNET_NO);
+ GNUNET_STATISTICS_set (stats,
+ "# expected pushes",
+ alpha * sub->view_size_est_need,
+ GNUNET_NO);
+ GNUNET_STATISTICS_set (stats,
+ "delta expected - received pushes",
+ CustomPeerMap_size (sub->push_map) - (alpha * sub->view_size_est_need),
+ GNUNET_NO);
+ }
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Received %u pushes and %u pulls last round (alpha (%.2f) * view_size (%u) = %.2f)\n",
- CustomPeerMap_size (push_map),
- CustomPeerMap_size (pull_map),
+ "Received %u pushes and %u pulls last round (alpha (%.2f) * view_size (sub->view%u) = %.2f)\n",
+ CustomPeerMap_size (sub->push_map),
+ CustomPeerMap_size (sub->pull_map),
alpha,
- View_size (),
- alpha * View_size ());
+ View_size (sub->view),
+ alpha * View_size (sub->view));
/* Update samplers */
- for (i = 0; i < CustomPeerMap_size (push_map); i++)
+ for (i = 0; i < CustomPeerMap_size (sub->push_map); i++)
{
- update_peer = CustomPeerMap_get_peer_by_index (push_map, i);
+ update_peer = CustomPeerMap_get_peer_by_index (sub->push_map, i);
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Updating with peer %s from push list\n",
GNUNET_i2s (update_peer));
- insert_in_sampler (NULL, update_peer);
- clean_peer (update_peer); /* This cleans only if it is not in the view */
+ insert_in_sampler (sub, update_peer);
+ clean_peer (sub, update_peer); /* This cleans only if it is not in the view */
}
- for (i = 0; i < CustomPeerMap_size (pull_map); i++)
+ for (i = 0; i < CustomPeerMap_size (sub->pull_map); i++)
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Updating with peer %s from pull list\n",
- GNUNET_i2s (CustomPeerMap_get_peer_by_index (pull_map, i)));
- insert_in_sampler (NULL, CustomPeerMap_get_peer_by_index (pull_map, i));
+ GNUNET_i2s (CustomPeerMap_get_peer_by_index (sub->pull_map, i)));
+ insert_in_sampler (sub, CustomPeerMap_get_peer_by_index (sub->pull_map, i));
/* This cleans only if it is not in the view */
- clean_peer (CustomPeerMap_get_peer_by_index (pull_map, i));
+ clean_peer (sub, CustomPeerMap_get_peer_by_index (sub->pull_map, i));
}
/* Empty push/pull lists */
- CustomPeerMap_clear (push_map);
- CustomPeerMap_clear (pull_map);
+ CustomPeerMap_clear (sub->push_map);
+ CustomPeerMap_clear (sub->pull_map);
+
+ if (sub == msub)
+ {
+ GNUNET_STATISTICS_set (stats,
+ "view size",
+ View_size(sub->view),
+ GNUNET_NO);
+ }
struct GNUNET_TIME_Relative time_next_round;
- time_next_round = compute_rand_delay (round_interval, 2);
+ time_next_round = compute_rand_delay (sub->round_interval, 2);
/* Schedule next round */
- do_round_task = GNUNET_SCHEDULER_add_delayed (time_next_round,
- &do_round, NULL);
+ sub->do_round_task = GNUNET_SCHEDULER_add_delayed (time_next_round,
+ &do_round, sub);
LOG (GNUNET_ERROR_TYPE_DEBUG, "Finished round\n");
}
*
* It is called on every peer(ID) that cadet somehow has contact with.
* We use those to initialise the sampler.
+ *
+ * implements #GNUNET_CADET_PeersCB
+ *
+ * @param cls Closure - Sub
+ * @param peer Peer, or NULL on "EOF".
+ * @param tunnel Do we have a tunnel towards this peer?
+ * @param n_paths Number of known paths towards this peer.
+ * @param best_path How long is the best path?
+ * (0 = unknown, 1 = ourselves, 2 = neighbor)
*/
void
init_peer_cb (void *cls,
const struct GNUNET_PeerIdentity *peer,
- int tunnel, // "Do we have a tunnel towards this peer?"
- unsigned int n_paths, // "Number of known paths towards this peer"
- unsigned int best_path) // "How long is the best path?
- // (0 = unknown, 1 = ourselves, 2 = neighbor)"
+ int tunnel, /* "Do we have a tunnel towards this peer?" */
+ unsigned int n_paths, /* "Number of known paths towards this peer" */
+ unsigned int best_path) /* "How long is the best path?
+ * (0 = unknown, 1 = ourselves, 2 = neighbor)" */
{
+ struct Sub *sub = cls;
+ (void) tunnel;
+ (void) n_paths;
+ (void) best_path;
+
if (NULL != peer)
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Got peer_id %s from cadet\n",
GNUNET_i2s (peer));
- got_peer (peer);
+ got_peer (sub, peer);
}
}
+
/**
* @brief Iterator function over stored, valid peers.
*
* We initialise the sampler with those.
*
- * @param cls the closure
+ * @param cls Closure - Sub
* @param peer the peer id
* @return #GNUNET_YES if we should continue to
* iterate,
valid_peers_iterator (void *cls,
const struct GNUNET_PeerIdentity *peer)
{
+ struct Sub *sub = cls;
+
if (NULL != peer)
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Got stored, valid peer %s\n",
GNUNET_i2s (peer));
- got_peer (peer);
+ got_peer (sub, peer);
}
return GNUNET_YES;
}
/**
* Iterator over peers from peerinfo.
*
- * @param cls closure
+ * @param cls Closure - Sub
* @param peer id of the peer, NULL for last call
* @param hello hello message for the peer (can be NULL)
* @param error message
const struct GNUNET_HELLO_Message *hello,
const char *err_msg)
{
+ struct Sub *sub = cls;
+ (void) hello;
+ (void) err_msg;
+
if (NULL != peer)
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Got peer_id %s from peerinfo\n",
GNUNET_i2s (peer));
- got_peer (peer);
+ got_peer (sub, peer);
}
}
/**
* Task run during shutdown.
*
- * @param cls unused
+ * @param cls Closure - unused
*/
static void
shutdown_task (void *cls)
{
+ (void) cls;
struct ClientContext *client_ctx;
- struct ReplyCls *reply_cls;
-
- in_shutdown = GNUNET_YES;
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "RPS is going down\n");
+ "RPS service 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_CONTAINER_DLL_remove (cli_ctx_head,
- cli_ctx_tail,
- client_ctx);
- GNUNET_free (client_ctx);
+ destroy_cli_ctx (client_ctx);
+ }
+ if (NULL != msub)
+ {
+ destroy_sub (msub);
+ msub = NULL;
}
+
+ /* Disconnect from other services */
GNUNET_PEERINFO_notify_cancel (peerinfo_notify_handle);
GNUNET_PEERINFO_disconnect (peerinfo_handle);
peerinfo_handle = NULL;
- if (NULL != do_round_task)
+ GNUNET_NSE_disconnect (nse);
+ if (NULL != map_single_hop)
{
- GNUNET_SCHEDULER_cancel (do_round_task);
- do_round_task = NULL;
+ /* core_init was called - core was initialised */
+ /* disconnect first, so no callback tries to access missing peermap */
+ GNUNET_CORE_disconnect (core_handle);
+ core_handle = NULL;
+ GNUNET_CONTAINER_multipeermap_destroy (map_single_hop);
+ map_single_hop = NULL;
}
- Peers_terminate ();
-
- GNUNET_NSE_disconnect (nse);
- RPS_sampler_destroy (prot_sampler);
- RPS_sampler_destroy (client_sampler);
- GNUNET_CADET_close_port (cadet_port);
- GNUNET_CADET_disconnect (cadet_handle);
- View_destroy ();
- CustomPeerMap_destroy (push_map);
- CustomPeerMap_destroy (pull_map);
if (NULL != stats)
{
GNUNET_STATISTICS_destroy (stats,
- GNUNET_NO);
+ GNUNET_NO);
stats = NULL;
}
-#ifdef ENABLE_MALICIOUS
+ GNUNET_CADET_disconnect (cadet_handle);
+ cadet_handle = NULL;
+#if ENABLE_MALICIOUS
struct AttackedPeer *tmp_att_peer;
- /* it is ok to free this const during shutdown: */
- GNUNET_free ((char *) file_name_view_log);
-#ifdef TO_FILE
- GNUNET_free ((char *) file_name_observed_log);
- GNUNET_CONTAINER_multipeermap_destroy (observed_unique_peers);
-#endif /* TO_FILE */
GNUNET_array_grow (mal_peers,
- num_mal_peers,
- 0);
+ num_mal_peers,
+ 0);
if (NULL != mal_peer_set)
GNUNET_CONTAINER_multipeermap_destroy (mal_peer_set);
if (NULL != att_peer_set)
{
tmp_att_peer = att_peers_head;
GNUNET_CONTAINER_DLL_remove (att_peers_head,
- att_peers_tail,
- tmp_att_peer);
+ att_peers_tail,
+ tmp_att_peer);
GNUNET_free (tmp_att_peer);
}
#endif /* ENABLE_MALICIOUS */
+ close_all_files();
}
/**
* Handle client connecting to the service.
*
- * @param cls NULL
+ * @param cls unused
* @param client the new client
* @param mq the message queue of @a client
* @return @a client
struct GNUNET_MQ_Handle *mq)
{
struct ClientContext *cli_ctx;
+ (void) cls;
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Client connected\n");
if (NULL == client)
return client; /* Server was destroyed before a client connected. Shutting down */
cli_ctx = GNUNET_new (struct ClientContext);
- cli_ctx->mq = GNUNET_SERVICE_client_get_mq (client);
+ cli_ctx->mq = mq;
cli_ctx->view_updates_left = -1;
+ cli_ctx->stream_update = GNUNET_NO;
cli_ctx->client = client;
GNUNET_CONTAINER_DLL_insert (cli_ctx_head,
cli_ctx_tail,
const struct GNUNET_CONFIGURATION_Handle *c,
struct GNUNET_SERVICE_Handle *service)
{
- char *fn_valid_peers;
+ struct GNUNET_TIME_Relative round_interval;
+ long long unsigned int sampler_size;
+ char hash_port_string[] = GNUNET_APPLICATION_PORT_RPS;
+ struct GNUNET_HashCode hash;
(void) cls;
(void) service;
+
GNUNET_log_setup ("rps",
- GNUNET_error_type_to_string (GNUNET_ERROR_TYPE_DEBUG),
- NULL);
+ GNUNET_error_type_to_string (GNUNET_ERROR_TYPE_DEBUG),
+ NULL);
cfg = c;
/* Get own ID */
GNUNET_CRYPTO_get_peer_identity (cfg,
- &own_identity); // TODO check return value
+ &own_identity); // TODO check return value
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"STARTING SERVICE (rps) for peer [%s]\n",
GNUNET_i2s (&own_identity));
-#ifdef ENABLE_MALICIOUS
+#if ENABLE_MALICIOUS
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Malicious execution compiled in.\n");
#endif /* ENABLE_MALICIOUS */
/* Get time interval from the configuration */
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_time (cfg,
- "RPS",
- "ROUNDINTERVAL",
- &round_interval))
+ "RPS",
+ "ROUNDINTERVAL",
+ &round_interval))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
"RPS", "ROUNDINTERVAL");
/* Get initial size of sampler/view from the configuration */
if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_number (cfg, "RPS", "MINSIZE",
- (long long unsigned int *) &sampler_size_est_min))
+ GNUNET_CONFIGURATION_get_value_number (cfg,
+ "RPS",
+ "MINSIZE",
+ &sampler_size))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
"RPS", "MINSIZE");
GNUNET_SCHEDULER_shutdown ();
return;
}
- sampler_size_est_need = sampler_size_est_min;
- view_size_est_min = sampler_size_est_min;
- LOG (GNUNET_ERROR_TYPE_DEBUG, "MINSIZE is %u\n", sampler_size_est_min);
-
- 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 (view_size_est_min);
- /* file_name_view_log */
- file_name_view_log = store_prefix_file_name (&own_identity, "view");
- #ifdef TO_FILE
- file_name_observed_log = store_prefix_file_name (&own_identity, "observed");
- observed_unique_peers = GNUNET_CONTAINER_multipeermap_create (1, GNUNET_NO);
- #endif /* TO_FILE */
-
- /* connect to NSE */
- nse = GNUNET_NSE_connect (cfg, nse_callback, NULL);
+ cadet_handle = GNUNET_CADET_connect (cfg);
+ GNUNET_assert (NULL != cadet_handle);
+ core_handle = GNUNET_CORE_connect (cfg,
+ NULL, /* cls */
+ core_init, /* init */
+ core_connects, /* connects */
+ core_disconnects, /* disconnects */
+ NULL); /* handlers */
+ GNUNET_assert (NULL != core_handle);
alpha = 0.45;
beta = 0.45;
- /* Initialise cadet */
- /* There exists a copy-paste-clone in get_channel() */
- struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
- GNUNET_MQ_hd_fixed_size (peer_check,
- GNUNET_MESSAGE_TYPE_RPS_PP_CHECK_LIVE,
- struct GNUNET_MessageHeader,
- NULL),
- GNUNET_MQ_hd_fixed_size (peer_push,
- GNUNET_MESSAGE_TYPE_RPS_PP_PUSH,
- struct GNUNET_MessageHeader,
- NULL),
- GNUNET_MQ_hd_fixed_size (peer_pull_request,
- GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REQUEST,
- struct GNUNET_MessageHeader,
- NULL),
- GNUNET_MQ_hd_var_size (peer_pull_reply,
- GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REPLY,
- struct GNUNET_RPS_P2P_PullReplyMessage,
- NULL),
- GNUNET_MQ_handler_end ()
- };
-
- cadet_handle = GNUNET_CADET_connect (cfg);
- GNUNET_assert (NULL != cadet_handle);
- GNUNET_CRYPTO_hash (GNUNET_APPLICATION_PORT_RPS,
- strlen (GNUNET_APPLICATION_PORT_RPS),
- &port);
- cadet_port = GNUNET_CADET_open_port (cadet_handle,
- &port,
- &Peers_handle_inbound_channel, /* Connect handler */
- NULL, /* cls */
- NULL, /* WindowSize handler */
- &cleanup_destroyed_channel, /* Disconnect handler */
- cadet_handlers);
- if (NULL == cadet_port)
- {
- LOG (GNUNET_ERROR_TYPE_ERROR,
- "Cadet port `%s' is already in use.\n",
- GNUNET_APPLICATION_PORT_RPS);
- GNUNET_assert (0);
- }
+ /* Set up main Sub */
+ GNUNET_CRYPTO_hash (hash_port_string,
+ strlen (hash_port_string),
+ &hash);
+ msub = new_sub (&hash,
+ sampler_size, /* Will be overwritten by config */
+ round_interval);
peerinfo_handle = GNUNET_PEERINFO_connect (cfg);
- Peers_initialise (fn_valid_peers, cadet_handle);
- 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_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);
- client_sampler = RPS_sampler_mod_init (sampler_size_est_need, max_round_interval);
-
- /* Initialise push and pull maps */
- push_map = CustomPeerMap_create (4);
- pull_map = CustomPeerMap_create (4);
+ /* connect to NSE */
+ nse = GNUNET_NSE_connect (cfg, nse_callback, NULL);
//LOG (GNUNET_ERROR_TYPE_DEBUG, "Requesting peers from CADET\n");
- //GNUNET_CADET_get_peers (cadet_handle, &init_peer_cb, NULL);
+ //GNUNET_CADET_get_peers (cadet_handle, &init_peer_cb, msub);
// 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);
+ restore_valid_peers (msub);
+ get_valid_peers (msub->valid_peers, valid_peers_iterator, msub);
peerinfo_notify_handle = GNUNET_PEERINFO_notify (cfg,
GNUNET_NO,
process_peerinfo_peers,
- NULL);
+ msub);
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);
stats = GNUNET_STATISTICS_create ("rps", cfg);
-
}
&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
+#if ENABLE_MALICIOUS
GNUNET_MQ_hd_var_size (client_act_malicious,
GNUNET_MESSAGE_TYPE_RPS_ACT_MALICIOUS,
struct GNUNET_RPS_CS_ActMaliciousMessage,
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());
/* end of gnunet-service-rps.c */
projects / oweals / gnunet.git / blobdiff