#include <inttypes.h>
#include <string.h>
-#define LOG(kind, ...) GNUNET_log(kind, __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log (kind, __VA_ARGS__)
// TODO check for overflows
* When an operation cannot be executed right now this struct is used to store
* the callback and closure for later execution.
*/
-struct PeerPendingOp {
+struct PeerPendingOp
+{
/**
* Callback
*/
* This is used to keep track of all messages that have not been sent yet. When
* a peer is to be removed the pending messages can be removed properly.
*/
-struct PendingMessage {
+struct PendingMessage
+{
/**
* DLL next, prev
*/
* status about the channels, the pending operations on this peer and some flags
* about the status of the peer itself. (online, valid, ...)
*/
-struct PeerContext {
+struct PeerContext
+{
/**
* The Sub this context belongs to.
*/
/**
* @brief Closure to #valid_peer_iterator
*/
-struct PeersIteratorCls {
+struct PeersIteratorCls
+{
/**
* Iterator function
*/
/**
* @brief Context for a channel
*/
-struct ChannelCtx {
+struct ChannelCtx
+{
/**
* @brief The channel itself
*/
/**
* If type is 2 This struct is used to store the attacked peers in a DLL
*/
-struct AttackedPeer {
+struct AttackedPeer
+{
/**
* DLL
*/
* Essentially one instance of brahms that only connects to other instances
* with the same (secret) value.
*/
-struct Sub {
+struct Sub
+{
/**
* @brief Hash of the shared value that defines Subs.
*/
static void
-do_round(void *cls);
+do_round (void *cls);
static void
-do_mal_round(void *cls);
+do_mal_round (void *cls);
/**
* @return the #PeerContext
*/
static struct PeerContext *
-get_peer_ctx(const struct GNUNET_CONTAINER_MultiPeerMap *peer_map,
- const struct GNUNET_PeerIdentity *peer)
+get_peer_ctx (const struct GNUNET_CONTAINER_MultiPeerMap *peer_map,
+ const struct GNUNET_PeerIdentity *peer)
{
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);
+ 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;
}
* #GNUNET_NO if peer is not knwon
*/
static int
-check_peer_known(const struct GNUNET_CONTAINER_MultiPeerMap *peer_map,
- const struct GNUNET_PeerIdentity *peer)
+check_peer_known (const struct GNUNET_CONTAINER_MultiPeerMap *peer_map,
+ const struct GNUNET_PeerIdentity *peer)
{
if (NULL != peer_map)
- {
- return GNUNET_CONTAINER_multipeermap_contains(peer_map, peer);
- }
+ {
+ return GNUNET_CONTAINER_multipeermap_contains (peer_map, peer);
+ }
else
- {
- return GNUNET_NO;
- }
+ {
+ return GNUNET_NO;
+ }
}
* @return the #PeerContext
*/
static struct PeerContext *
-create_peer_ctx(struct Sub *sub,
- const struct GNUNET_PeerIdentity *peer)
+create_peer_ctx (struct Sub *sub,
+ const struct GNUNET_PeerIdentity *peer)
{
struct PeerContext *ctx;
int ret;
- GNUNET_assert(GNUNET_NO == check_peer_known(sub->peer_map, peer));
+ GNUNET_assert (GNUNET_NO == check_peer_known (sub->peer_map, peer));
- ctx = GNUNET_new(struct PeerContext);
+ 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);
+ ret = GNUNET_CONTAINER_multipeermap_put (sub->peer_map, peer, ctx,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+ GNUNET_assert (GNUNET_OK == ret);
if (sub == msub)
- {
- GNUNET_STATISTICS_set(stats,
- "# known peers",
- GNUNET_CONTAINER_multipeermap_size(sub->peer_map),
- GNUNET_NO);
- }
+ {
+ GNUNET_STATISTICS_set (stats,
+ "# known peers",
+ GNUNET_CONTAINER_multipeermap_size (sub->peer_map),
+ GNUNET_NO);
+ }
return ctx;
}
* @return the context
*/
static struct PeerContext *
-create_or_get_peer_ctx(struct Sub *sub,
- const struct GNUNET_PeerIdentity *peer)
+create_or_get_peer_ctx (struct Sub *sub,
+ const struct GNUNET_PeerIdentity *peer)
{
- if (GNUNET_NO == check_peer_known(sub->peer_map, peer))
- {
- return create_peer_ctx(sub, peer);
- }
- return get_peer_ctx(sub->peer_map, peer);
+ if (GNUNET_NO == check_peer_known (sub->peer_map, peer))
+ {
+ return create_peer_ctx (sub, peer);
+ }
+ return get_peer_ctx (sub->peer_map, peer);
}
* #GNUNET_NO otherwise
*/
static int
-check_connected(struct PeerContext *peer_ctx)
+check_connected (struct PeerContext *peer_ctx)
{
/* 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))
- {
- return GNUNET_NO;
- }
+ if (GNUNET_NO == check_peer_known (peer_ctx->sub->peer_map,
+ &peer_ctx->peer_id))
+ {
+ return GNUNET_NO;
+ }
/* Get the context */
- peer_ctx = get_peer_ctx(peer_ctx->sub->peer_map, &peer_ctx->peer_id);
+ 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;
- }
+ {
+ 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);
+ SET_PEER_FLAG (peer_ctx, Peers_ONLINE);
return GNUNET_YES;
}
/**
* @brief The closure to #get_rand_peer_iterator.
*/
-struct GetRandPeerIteratorCls {
+struct GetRandPeerIteratorCls
+{
/**
* @brief The index of the peer to return.
* Will be decreased until 0.
* #GNUNET_NO if not.
*/
static int
-get_rand_peer_iterator(void *cls,
- const struct GNUNET_PeerIdentity *peer,
- void *value)
+get_rand_peer_iterator (void *cls,
+ const struct GNUNET_PeerIdentity *peer,
+ void *value)
{
struct GetRandPeerIteratorCls *iterator_cls = cls;
- (void)value;
+ (void) value;
if (0 >= iterator_cls->index)
- {
- iterator_cls->peer = peer;
- return GNUNET_NO;
- }
+ {
+ iterator_cls->peer = peer;
+ return GNUNET_NO;
+ }
iterator_cls->index--;
return GNUNET_YES;
}
* @return a random peer
*/
static const struct GNUNET_PeerIdentity *
-get_random_peer_from_peermap(struct GNUNET_CONTAINER_MultiPeerMap *valid_peers)
+get_random_peer_from_peermap (struct GNUNET_CONTAINER_MultiPeerMap *valid_peers)
{
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);
+ 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);
+ GNUNET_free (iterator_cls);
return ret;
}
* #GNUNET_NO otherwise
*/
static int
-add_valid_peer(const struct GNUNET_PeerIdentity *peer,
- struct GNUNET_CONTAINER_MultiPeerMap *valid_peers)
+add_valid_peer (const struct GNUNET_PeerIdentity *peer,
+ struct GNUNET_CONTAINER_MultiPeerMap *valid_peers)
{
const struct GNUNET_PeerIdentity *rand_peer;
int ret;
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))
- {
- 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);
+ GNUNET_CONTAINER_multipeermap_size (valid_peers))
+ {
+ 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);
if (valid_peers == msub->valid_peers)
- {
- GNUNET_STATISTICS_set(stats,
- "# valid peers",
- GNUNET_CONTAINER_multipeermap_size(valid_peers),
- GNUNET_NO);
- }
+ {
+ 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);
+remove_pending_message (struct PendingMessage *pending_msg, int cancel);
/**
* @brief Set the peer flag to living and
* @param peer_ctx the #PeerContext of the peer to set online
*/
static void
-set_peer_online(struct PeerContext *peer_ctx)
+set_peer_online (struct PeerContext *peer_ctx)
{
struct GNUNET_PeerIdentity *peer;
unsigned int i;
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);
+ 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);
if (NULL != peer_ctx->online_check_pending)
- {
- 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;
- }
-
- SET_PEER_FLAG(peer_ctx, Peers_ONLINE);
+ {
+ 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;
+ }
+
+ 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);
+ {
+ 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);
}
static void
-cleanup_destroyed_channel(void *cls,
- const struct GNUNET_CADET_Channel *channel);
+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);
+handle_peer_check (void *cls,
+ const struct GNUNET_MessageHeader *msg);
static void
-handle_peer_push(void *cls,
- const struct GNUNET_MessageHeader *msg);
+handle_peer_push (void *cls,
+ const struct GNUNET_MessageHeader *msg);
static void
-handle_peer_pull_request(void *cls,
- const struct GNUNET_MessageHeader *msg);
+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);
+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);
+handle_peer_pull_reply (void *cls,
+ const struct GNUNET_RPS_P2P_PullReplyMessage *msg);
/* End declaration of handlers */
* @return The channel context
*/
static struct ChannelCtx *
-add_channel_ctx(struct PeerContext *peer_ctx)
+add_channel_ctx (struct PeerContext *peer_ctx)
{
struct ChannelCtx *channel_ctx;
- channel_ctx = GNUNET_new(struct ChannelCtx);
+ channel_ctx = GNUNET_new (struct ChannelCtx);
channel_ctx->peer_ctx = peer_ctx;
return channel_ctx;
}
* @param channel_ctx The channel context.
*/
static void
-remove_channel_ctx(struct ChannelCtx *channel_ctx)
+remove_channel_ctx (struct ChannelCtx *channel_ctx)
{
struct PeerContext *peer_ctx = channel_ctx->peer_ctx;
if (NULL != channel_ctx->destruction_task)
- {
- GNUNET_SCHEDULER_cancel(channel_ctx->destruction_task);
- channel_ctx->destruction_task = NULL;
- }
+ {
+ GNUNET_SCHEDULER_cancel (channel_ctx->destruction_task);
+ channel_ctx->destruction_task = NULL;
+ }
- GNUNET_free(channel_ctx);
+ GNUNET_free (channel_ctx);
if (NULL == peer_ctx)
return;
if (channel_ctx == peer_ctx->send_channel_ctx)
- {
- peer_ctx->send_channel_ctx = NULL;
- peer_ctx->mq = NULL;
- }
+ {
+ 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;
- }
+ {
+ peer_ctx->recv_channel_ctx = NULL;
+ }
}
* @return the #GNUNET_CADET_Channel used to send data to @a peer_ctx
*/
struct GNUNET_CADET_Channel *
-get_channel(struct PeerContext *peer_ctx)
+get_channel (struct PeerContext *peer_ctx)
{
/* 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()
+ 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,
- 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);
+ {
+ 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,
+ 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;
}
* @return the #GNUNET_MQ_Handle
*/
static struct GNUNET_MQ_Handle *
-get_mq(struct PeerContext *peer_ctx)
+get_mq (struct PeerContext *peer_ctx)
{
if (NULL == peer_ctx->mq)
- {
- peer_ctx->mq = GNUNET_CADET_get_mq(get_channel(peer_ctx));
- }
+ {
+ peer_ctx->mq = GNUNET_CADET_get_mq (get_channel (peer_ctx));
+ }
return peer_ctx->mq;
}
* @return pointer to pending message
*/
static struct PendingMessage *
-insert_pending_message(struct PeerContext *peer_ctx,
- struct GNUNET_MQ_Envelope *ev,
- const char *type)
+insert_pending_message (struct PeerContext *peer_ctx,
+ struct GNUNET_MQ_Envelope *ev,
+ const char *type)
{
struct PendingMessage *pending_msg;
- pending_msg = GNUNET_new(struct PendingMessage);
+ 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);
+ GNUNET_CONTAINER_DLL_insert (peer_ctx->pending_messages_head,
+ peer_ctx->pending_messages_tail,
+ pending_msg);
return pending_msg;
}
* @param cancel whether to cancel the pending message, too
*/
static void
-remove_pending_message(struct PendingMessage *pending_msg, int cancel)
+remove_pending_message (struct PendingMessage *pending_msg, int cancel)
{
struct PeerContext *peer_ctx;
- (void)cancel;
+ (void) cancel;
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);
+ 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)
- //{
+ // if (GNUNET_YES == cancel)
+ // {
// GNUNET_MQ_send_cancel (pending_msg->ev);
- //}
- GNUNET_free(pending_msg);
+ // }
+ GNUNET_free (pending_msg);
}
* @param cls #PeerContext of peer with pending online check
*/
static void
-mq_online_check_successful(void *cls)
+mq_online_check_successful (void *cls)
{
struct PeerContext *peer_ctx = cls;
if (NULL != peer_ctx->online_check_pending)
- {
- 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);
- }
+ {
+ 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);
+ }
}
/**
* @param peer_ctx the context of the peer
*/
static void
-check_peer_online(struct PeerContext *peer_ctx)
+check_peer_online (struct PeerContext *peer_ctx)
{
- LOG(GNUNET_ERROR_TYPE_DEBUG,
- "Get informed about peer %s getting online\n",
- GNUNET_i2s(&peer_ctx->peer_id));
+ 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;
- ev = GNUNET_MQ_msg_header(GNUNET_MESSAGE_TYPE_RPS_PP_CHECK_LIVE);
+ 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);
+ 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)
- {
- GNUNET_STATISTICS_update(stats,
- "# pending online checks",
- 1,
- GNUNET_NO);
- }
+ {
+ GNUNET_STATISTICS_update (stats,
+ "# pending online checks",
+ 1,
+ GNUNET_NO);
+ }
}
* #GNUNET_NO otherwise
*/
static int
-check_operation_scheduled(const struct PeerContext *peer_ctx,
- const PeerOp peer_op)
+check_operation_scheduled (const struct PeerContext *peer_ctx,
+ const PeerOp peer_op)
{
unsigned int i;
* @param cls Context of the channel
*/
static void
-destroy_channel(struct ChannelCtx *channel_ctx)
+destroy_channel (struct ChannelCtx *channel_ctx)
{
struct GNUNET_CADET_Channel *channel;
if (NULL != channel_ctx->destruction_task)
- {
- GNUNET_SCHEDULER_cancel(channel_ctx->destruction_task);
- channel_ctx->destruction_task = NULL;
- }
- GNUNET_assert(channel_ctx->channel != NULL);
+ {
+ 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);
+ GNUNET_CADET_channel_destroy (channel);
+ remove_channel_ctx (channel_ctx);
}
* @param cls
*/
static void
-destroy_channel_cb(void *cls)
+destroy_channel_cb (void *cls)
{
struct ChannelCtx *channel_ctx = cls;
channel_ctx->destruction_task = NULL;
- destroy_channel(channel_ctx);
+ destroy_channel (channel_ctx);
}
* @param channel_ctx channel to be destroyed.
*/
static void
-schedule_channel_destruction(struct ChannelCtx *channel_ctx)
+schedule_channel_destruction (struct ChannelCtx *channel_ctx)
{
- GNUNET_assert(NULL ==
- channel_ctx->destruction_task);
- GNUNET_assert(NULL !=
- channel_ctx->channel);
+ 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);
+ GNUNET_SCHEDULER_add_now (&destroy_channel_cb,
+ channel_ctx);
}
* #GNUNET_NO otherwise
*/
static int
-destroy_peer(struct PeerContext *peer_ctx)
+destroy_peer (struct PeerContext *peer_ctx)
{
- GNUNET_assert(NULL != peer_ctx);
- GNUNET_assert(NULL != peer_ctx->sub->peer_map);
+ GNUNET_assert (NULL != peer_ctx);
+ GNUNET_assert (NULL != peer_ctx->sub->peer_map);
if (GNUNET_NO ==
- GNUNET_CONTAINER_multipeermap_contains(peer_ctx->sub->peer_map,
- &peer_ctx->peer_id))
- {
- return GNUNET_NO;
- }
- 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));
- UNSET_PEER_FLAG(peer_ctx, Peers_ONLINE);
+ GNUNET_CONTAINER_multipeermap_contains (peer_ctx->sub->peer_map,
+ &peer_ctx->peer_id))
+ {
+ return GNUNET_NO;
+ }
+ 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));
+ 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);
+ GNUNET_array_grow (peer_ctx->pending_ops,
+ 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);
+ /* Cancle pending message, too */
+ if ((NULL != peer_ctx->online_check_pending) &&
+ (0 == memcmp (peer_ctx->pending_messages_head,
+ peer_ctx->online_check_pending,
+ sizeof(struct PendingMessage))))
{
- LOG(GNUNET_ERROR_TYPE_DEBUG,
- "Removing unsent %s\n",
- peer_ctx->pending_messages_head->type);
- /* Cancle pending message, too */
- if ((NULL != peer_ctx->online_check_pending) &&
- (0 == memcmp(peer_ctx->pending_messages_head,
- peer_ctx->online_check_pending,
- sizeof(struct PendingMessage))))
- {
- 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);
- }
+ 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);
+ }
/* If we are still waiting for notification whether this peer is online
* cancel the according task */
if (NULL != peer_ctx->online_check_pending)
- {
- GNUNET_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;
- }
+ {
+ GNUNET_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;
+ }
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);
- peer_ctx->send_channel_ctx = NULL;
- peer_ctx->mq = NULL;
- }
+ {
+ /* This is possibly called from within channel destruction */
+ peer_ctx->send_channel_ctx->peer_ctx = NULL;
+ schedule_channel_destruction (peer_ctx->send_channel_ctx);
+ peer_ctx->send_channel_ctx = NULL;
+ peer_ctx->mq = NULL;
+ }
if (NULL != peer_ctx->recv_channel_ctx)
- {
- /* 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;
- }
+ {
+ /* 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_ctx->sub->peer_map,
- &peer_ctx->peer_id))
- {
- LOG(GNUNET_ERROR_TYPE_WARNING,
- "removing peer from peer_ctx->sub->peer_map failed\n");
- }
+ GNUNET_CONTAINER_multipeermap_remove_all (peer_ctx->sub->peer_map,
+ &peer_ctx->peer_id))
+ {
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ "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);
+ {
+ GNUNET_STATISTICS_set (stats,
+ "# known peers",
+ GNUNET_CONTAINER_multipeermap_size (
+ peer_ctx->sub->peer_map),
+ GNUNET_NO);
+ }
+ GNUNET_free (peer_ctx);
return GNUNET_YES;
}
* #GNUNET_NO if not.
*/
static int
-peermap_clear_iterator(void *cls,
- const struct GNUNET_PeerIdentity *key,
- void *value)
+peermap_clear_iterator (void *cls,
+ const struct GNUNET_PeerIdentity *key,
+ void *value)
{
struct Sub *sub = cls;
- (void)value;
+ (void) value;
- destroy_peer(get_peer_ctx(sub->peer_map, key));
+ destroy_peer (get_peer_ctx (sub->peer_map, key));
return GNUNET_YES;
}
* @param cls type of the message that was sent
*/
static void
-mq_notify_sent_cb(void *cls)
+mq_notify_sent_cb (void *cls)
{
- struct PendingMessage *pending_msg = (struct PendingMessage *)cls;
+ struct PendingMessage *pending_msg = (struct PendingMessage *) cls;
- LOG(GNUNET_ERROR_TYPE_DEBUG,
- "%s was sent.\n",
- pending_msg->type);
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "%s was sent.\n",
+ pending_msg->type);
if (pending_msg->peer_ctx->sub == msub)
- {
- 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);
- }
+ {
+ 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);
+ remove_pending_message (pending_msg, GNUNET_NO);
}
* #GNUNET_NO if not.
*/
static int
-store_peer_presistently_iterator(void *cls,
- const struct GNUNET_PeerIdentity *peer,
- void *value)
+store_peer_presistently_iterator (void *cls,
+ const struct GNUNET_PeerIdentity *peer,
+ void *value)
{
const struct GNUNET_DISK_FileHandle *fh = cls;
char peer_string[128];
int size;
ssize_t ret;
- (void)value;
+ (void) value;
if (NULL == peer)
- {
- return GNUNET_YES;
- }
- 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;
+ }
+ 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;
}
* @param sub Sub for which to store the valid peers
*/
static void
-store_valid_peers(const struct Sub *sub)
+store_valid_peers (const struct Sub *sub)
{
struct GNUNET_DISK_FileHandle *fh;
uint32_t number_written_peers;
int ret;
- if (0 == strncmp("DISABLE", sub->filename_valid_peers, 7))
- {
- return;
- }
+ if (0 == strncmp ("DISABLE", sub->filename_valid_peers, 7))
+ {
+ return;
+ }
- ret = GNUNET_DISK_directory_create_for_file(sub->filename_valid_peers);
+ 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);
- }
+ {
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ "Not able to create directory for file `%s'\n",
+ sub->filename_valid_peers);
+ GNUNET_break (0);
+ }
else if (GNUNET_NO == ret)
- {
- LOG(GNUNET_ERROR_TYPE_WARNING,
- "Directory for file `%s' exists but is not writable for us\n",
- sub->filename_valid_peers);
- GNUNET_break(0);
- }
- 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);
+ {
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ "Directory for file `%s' exists but is not writable for us\n",
+ sub->filename_valid_peers);
+ GNUNET_break (0);
+ }
+ 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));
+ {
+ 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));
+ 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));
}
* @return The peer id
*/
static const struct GNUNET_PeerIdentity *
-s2i_full(const char *string_repr)
+s2i_full (const char *string_repr)
{
struct GNUNET_PeerIdentity *peer;
size_t len;
int ret;
- peer = GNUNET_new(struct GNUNET_PeerIdentity);
- len = strlen(string_repr);
+ 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);
- }
+ {
+ 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);
+ {
+ 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);
- }
+ {
+ 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;
}
* @param sub Sub for which to restore the valid peers
*/
static void
-restore_valid_peers(const struct Sub *sub)
+restore_valid_peers (const struct Sub *sub)
{
off_t file_size;
uint32_t num_peers;
char *str_repr;
const struct GNUNET_PeerIdentity *peer;
- if (0 == strncmp("DISABLE", sub->filename_valid_peers, 7))
- {
- return;
- }
+ if (0 == strncmp ("DISABLE", sub->filename_valid_peers, 7))
+ {
+ return;
+ }
- if (GNUNET_OK != GNUNET_DISK_file_test(sub->filename_valid_peers))
- {
- return;
- }
- 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));
+ if (GNUNET_OK != GNUNET_DISK_file_test (sub->filename_valid_peers))
+ {
+ return;
+ }
+ 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);
+ 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)
- {
- 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));
- }
+ {
+ 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));
+ }
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));
+ 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));
}
* @param sub Sub for which the storage is deleted
*/
static void
-peers_terminate(struct Sub *sub)
+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);
+ 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);
+ store_valid_peers (sub);
+ GNUNET_free (sub->filename_valid_peers);
sub->filename_valid_peers = NULL;
- GNUNET_CONTAINER_multipeermap_destroy(sub->valid_peers);
+ GNUNET_CONTAINER_multipeermap_destroy (sub->valid_peers);
sub->valid_peers = NULL;
}
* #GNUNET_NO if not.
*/
static int
-valid_peer_iterator(void *cls,
- const struct GNUNET_PeerIdentity *peer,
- void *value)
+valid_peer_iterator (void *cls,
+ const struct GNUNET_PeerIdentity *peer,
+ void *value)
{
struct PeersIteratorCls *it_cls = cls;
- (void)value;
+ (void) value;
- return it_cls->iterator(it_cls->cls, peer);
+ return it_cls->iterator (it_cls->cls, peer);
}
* #GNUNET_SYSERR if it aborted iteration
*/
static int
-get_valid_peers(struct GNUNET_CONTAINER_MultiPeerMap *valid_peers,
- PeersIterator iterator,
- void *it_cls)
+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 = 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);
+ ret = GNUNET_CONTAINER_multipeermap_iterate (valid_peers,
+ valid_peer_iterator,
+ cls);
+ GNUNET_free (cls);
return ret;
}
* #GNUNET_NO otherwise
*/
static int
-insert_peer(struct Sub *sub,
- const struct GNUNET_PeerIdentity *peer)
+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);
+ 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;
}
* #GNUNET_NO otherwise
*/
static int
-check_peer_flag(const struct GNUNET_CONTAINER_MultiPeerMap *peer_map,
- const struct GNUNET_PeerIdentity *peer,
- enum Peers_PeerFlags flags)
+check_peer_flag (const struct GNUNET_CONTAINER_MultiPeerMap *peer_map,
+ const struct GNUNET_PeerIdentity *peer,
+ enum Peers_PeerFlags flags)
{
struct PeerContext *peer_ctx;
- 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);
+ 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);
}
/**
* #GNUNET_NO otherwise
*/
static int
-issue_peer_online_check(struct Sub *sub,
- const struct GNUNET_PeerIdentity *peer)
+issue_peer_online_check (struct Sub *sub,
+ const struct GNUNET_PeerIdentity *peer)
{
struct PeerContext *peer_ctx;
- (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)) &&
+ (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;
- }
+ {
+ check_peer_online (peer_ctx);
+ return GNUNET_YES;
+ }
return GNUNET_NO;
}
* #GNUNET_SYSERR if peer is not known
*/
static int
-check_removable(const struct PeerContext *peer_ctx)
+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;
- }
+ if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (
+ peer_ctx->sub->peer_map,
+ &peer_ctx->peer_id))
+ {
+ return GNUNET_SYSERR;
+ }
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;
- }
+ (GNUNET_YES == check_peer_flag_set (peer_ctx, Peers_PULL_REPLY_PENDING)))
+ {
+ return GNUNET_NO;
+ }
return GNUNET_YES;
}
* #GNUNET_NO if peer is not valid
*/
static int
-check_peer_valid(const struct GNUNET_CONTAINER_MultiPeerMap *valid_peers,
- const struct GNUNET_PeerIdentity *peer)
+check_peer_valid (const struct GNUNET_CONTAINER_MultiPeerMap *valid_peers,
+ const struct GNUNET_PeerIdentity *peer)
{
- return GNUNET_CONTAINER_multipeermap_contains(valid_peers, peer);
+ return GNUNET_CONTAINER_multipeermap_contains (valid_peers, peer);
}
* @param peer_ctx Context of the target peer
*/
static void
-indicate_sending_intention(struct PeerContext *peer_ctx)
+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);
+ GNUNET_assert (GNUNET_YES == check_peer_known (peer_ctx->sub->peer_map,
+ &peer_ctx->peer_id));
+ (void) get_channel (peer_ctx);
}
* #GNUNET_NO otherwise
*/
static int
-check_peer_send_intention(const struct PeerContext *peer_ctx)
+check_peer_send_intention (const struct PeerContext *peer_ctx)
{
if (NULL != peer_ctx->recv_channel_ctx)
- {
- return GNUNET_YES;
- }
+ {
+ return GNUNET_YES;
+ }
return GNUNET_NO;
}
* (can be NULL -- that's not an error)
*/
static void *
-handle_inbound_channel(void *cls,
- struct GNUNET_CADET_Channel *channel,
- const struct GNUNET_PeerIdentity *initiator)
+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;
- 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 */
+ 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);
+ 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;
- }
+ 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;
}
* #GNUNET_NO otherwise
*/
static int
-check_sending_channel_exists(const struct PeerContext *peer_ctx)
+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 (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_NO;
+ }
return GNUNET_YES;
}
* #GNUNET_NO otherwise
*/
static int
-destroy_sending_channel(struct PeerContext *peer_ctx)
+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 (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;
- }
+ {
+ destroy_channel (peer_ctx->send_channel_ctx);
+ (void) check_connected (peer_ctx);
+ return GNUNET_YES;
+ }
return GNUNET_NO;
}
* @param type type of the message
*/
static void
-send_message(struct PeerContext *peer_ctx,
- struct GNUNET_MQ_Envelope *ev,
- const char *type)
+send_message (struct PeerContext *peer_ctx,
+ 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_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);
+ 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);
}
/**
* #GNUNET_NO otherwise
*/
static int
-schedule_operation(struct PeerContext *peer_ctx,
- const PeerOp peer_op,
- void *cls)
+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));
+ GNUNET_assert (GNUNET_YES == check_peer_known (peer_ctx->sub->peer_map,
+ &peer_ctx->peer_id));
- //TODO if ONLINE execute immediately
+ // TODO if ONLINE execute immediately
- 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;
- }
+ 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;
}
* Closure used to pass the client and the id to the callback
* that replies to a client's request
*/
-struct ReplyCls {
+struct ReplyCls
+{
/**
* DLL
*/
/**
* Struct used to store the context of a connected client.
*/
-struct ClientContext {
+struct ClientContext
+{
/**
* DLL
*/
* Print peerlist to log.
*/
static void
-print_peer_list(struct GNUNET_PeerIdentity *list,
- unsigned int len)
+print_peer_list (struct GNUNET_PeerIdentity *list,
+ unsigned int len)
{
unsigned int i;
- LOG(GNUNET_ERROR_TYPE_DEBUG,
- "Printing peer list of length %u at %p:\n",
- len,
- list);
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Printing peer list of length %u at %p:\n",
+ len,
+ list);
for (i = 0; i < len; i++)
- {
- LOG(GNUNET_ERROR_TYPE_DEBUG,
- "%u. peer: %s\n",
- i, GNUNET_i2s(&list[i]));
- }
+ {
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "%u. peer: %s\n",
+ i, GNUNET_i2s (&list[i]));
+ }
}
* Remove peer from list.
*/
static void
-rem_from_list(struct GNUNET_PeerIdentity **peer_list,
- unsigned int *list_size,
- const struct GNUNET_PeerIdentity *peer)
+rem_from_list (struct GNUNET_PeerIdentity **peer_list,
+ unsigned int *list_size,
+ const struct GNUNET_PeerIdentity *peer)
{
unsigned int i;
struct GNUNET_PeerIdentity *tmp;
tmp = *peer_list;
- LOG(GNUNET_ERROR_TYPE_DEBUG,
- "Removing peer %s from list at %p\n",
- GNUNET_i2s(peer),
- tmp);
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Removing peer %s from list at %p\n",
+ GNUNET_i2s (peer),
+ tmp);
for (i = 0; i < *list_size; i++)
+ {
+ if (0 == GNUNET_memcmp (&tmp[i], peer))
{
- if (0 == GNUNET_memcmp(&tmp[i], peer))
- {
- if (i < *list_size - 1)
- { /* Not at the last entry -- shift peers left */
- memmove(&tmp[i], &tmp[i + 1],
- ((*list_size) - i - 1) * sizeof(struct GNUNET_PeerIdentity));
- }
- /* Remove last entry (should be now useless PeerID) */
- GNUNET_array_grow(tmp, *list_size, (*list_size) - 1);
- }
- }
+ if (i < *list_size - 1)
+ { /* Not at the last entry -- shift peers left */
+ memmove (&tmp[i], &tmp[i + 1],
+ ((*list_size) - i - 1) * sizeof(struct GNUNET_PeerIdentity));
+ }
+ /* Remove last entry (should be now useless PeerID) */
+ GNUNET_array_grow (tmp, *list_size, (*list_size) - 1);
+ }
+ }
*peer_list = tmp;
}
* GNUNET_NO if peer was not inserted
*/
static void
-insert_in_view_op(void *cls,
- const struct GNUNET_PeerIdentity *peer);
+insert_in_view_op (void *cls,
+ const struct GNUNET_PeerIdentity *peer);
/**
* Insert PeerID in #view
* GNUNET_NO if peer was not inserted
*/
static int
-insert_in_view(struct Sub *sub,
- const struct GNUNET_PeerIdentity *peer)
+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?
+ 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;
- }
+ {
+ (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);
+ 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);
- }
+ {
+ GNUNET_STATISTICS_set (stats,
+ "view size",
+ View_size (peer_ctx->sub->view),
+ GNUNET_NO);
+ }
return ret;
}
* @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)
+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);
+ {
+ 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);
}
* @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)
+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);
+ 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);
+ 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);
+ GNUNET_memcpy (&out_msg[1],
+ peers,
+ num_peers * sizeof(struct GNUNET_PeerIdentity));
+ GNUNET_MQ_send (cli_ctx->mq, ev);
}
* @param sub Sub for which to notify clients
*/
static void
-clients_notify_view_update(const struct Sub *sub)
+clients_notify_view_update (const struct Sub *sub)
{
struct ClientContext *cli_ctx_iter;
uint64_t num_peers;
const struct GNUNET_PeerIdentity *view_array;
- num_peers = View_size(sub->view);
- view_array = View_get_as_array(sub->view);
+ 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)
- {
- GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
- "View is too big to send\n");
- return;
- }
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "View is too big to send\n");
+ return;
+ }
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)
{
- 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);
+ /* 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);
+ }
}
* @param peers the array of peers to send
*/
static void
-clients_notify_stream_peer(const struct Sub *sub,
- uint64_t num_peers,
- const struct GNUNET_PeerIdentity *peers)
+clients_notify_stream_peer (const struct Sub *sub,
+ uint64_t num_peers,
+ const struct GNUNET_PeerIdentity *peers)
// TODO enum StreamPeerSource)
{
struct ClientContext *cli_ctx_iter;
- LOG(GNUNET_ERROR_TYPE_DEBUG,
- "Got peer (%s) from biased stream - update all clients\n",
- GNUNET_i2s(peers));
+ 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)
+ {
+ if ((GNUNET_YES == cli_ctx_iter->stream_update) &&
+ ((sub == cli_ctx_iter->sub) ||(sub == msub) ))
{
- if (GNUNET_YES == cli_ctx_iter->stream_update &&
- (sub == cli_ctx_iter->sub || sub == msub))
- {
- send_stream_peers(cli_ctx_iter, num_peers, peers);
- }
+ send_stream_peers (cli_ctx_iter, num_peers, peers);
}
+ }
}
* @param cls Closure - The Sub for which this is to be done
*/
static void
-hist_update(const struct GNUNET_PeerIdentity *ids,
- uint32_t num_peers,
- void *cls)
+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++)
+ {
+ int inserted;
+ if (GNUNET_YES != check_peer_known (sub->peer_map, &ids[i]))
{
- 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]);
- }
+ 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));
+ to_file (sub->file_name_view_log,
+ "+%s\t(hist)",
+ GNUNET_i2s_full (ids));
#endif /* TO_FILE_FULL */
- }
- clients_notify_view_update(sub);
+ }
+ clients_notify_view_update (sub);
}
* @param new_size New size to which to resize
*/
static void
-resize_wrapper(struct RPS_Sampler *sampler, uint32_t new_size)
+resize_wrapper (struct RPS_Sampler *sampler, uint32_t new_size)
{
unsigned int sampler_size;
// TODO statistics
// TODO respect the min, max
- sampler_size = RPS_sampler_get_size(sampler);
+ sampler_size = RPS_sampler_get_size (sampler);
if (sampler_size > new_size * 4)
- { /* Shrinking */
- RPS_sampler_resize(sampler, sampler_size / 2);
- }
+ { /* Shrinking */
+ RPS_sampler_resize (sampler, sampler_size / 2);
+ }
else if (sampler_size < new_size)
- { /* Growing */
- RPS_sampler_resize(sampler, sampler_size * 2);
- }
- LOG(GNUNET_ERROR_TYPE_DEBUG, "sampler_size is now %u\n", sampler_size);
+ { /* Growing */
+ RPS_sampler_resize (sampler, sampler_size * 2);
+ }
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "sampler_size is now %u\n", sampler_size);
}
* @param peer_map the peermap to use as set
*/
static void
-add_peer_array_to_set(const struct GNUNET_PeerIdentity *peer_array,
- unsigned int num_peers,
- struct GNUNET_CONTAINER_MultiPeerMap *peer_map)
+add_peer_array_to_set (const struct GNUNET_PeerIdentity *peer_array,
+ unsigned int num_peers,
+ struct GNUNET_CONTAINER_MultiPeerMap *peer_map)
{
unsigned int i;
if (NULL == peer_map)
- {
- LOG(GNUNET_ERROR_TYPE_WARNING,
- "Trying to add peers to non-existing peermap.\n");
- return;
- }
+ {
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ "Trying to add peers to non-existing peermap.\n");
+ return;
+ }
for (i = 0; i < num_peers; i++)
+ {
+ GNUNET_CONTAINER_multipeermap_put (peer_map,
+ &peer_array[i],
+ NULL,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
+ if (msub->peer_map == peer_map)
{
- GNUNET_CONTAINER_multipeermap_put(peer_map,
- &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);
- }
+ GNUNET_STATISTICS_set (stats,
+ "# known peers",
+ GNUNET_CONTAINER_multipeermap_size (peer_map),
+ GNUNET_NO);
}
+ }
}
* @param num_peer_ids the number of peers to send to @a peer_id
*/
static void
-send_pull_reply(struct PeerContext *peer_ctx,
- const struct GNUNET_PeerIdentity *peer_ids,
- unsigned int num_peer_ids)
+send_pull_reply (struct PeerContext *peer_ctx,
+ const struct GNUNET_PeerIdentity *peer_ids,
+ unsigned int num_peer_ids)
{
uint32_t send_size;
struct GNUNET_MQ_Envelope *ev;
struct GNUNET_RPS_P2P_PullReplyMessage *out_msg;
/* Compute actual size */
- send_size = sizeof(struct GNUNET_RPS_P2P_PullReplyMessage) +
- num_peer_ids * sizeof(struct GNUNET_PeerIdentity);
+ send_size = sizeof(struct GNUNET_RPS_P2P_PullReplyMessage)
+ + num_peer_ids * sizeof(struct GNUNET_PeerIdentity);
if (GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE < send_size)
/* Compute number of peers to send
// TODO select random ones via permutation
// or even better: do good protocol design
send_size =
- (GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE -
- sizeof(struct GNUNET_RPS_P2P_PullReplyMessage)) /
- sizeof(struct GNUNET_PeerIdentity);
+ (GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE
+ - sizeof(struct GNUNET_RPS_P2P_PullReplyMessage))
+ / sizeof(struct GNUNET_PeerIdentity);
else
send_size = num_peer_ids;
- LOG(GNUNET_ERROR_TYPE_DEBUG,
- "Going to send PULL REPLY with %u peers to %s\n",
- send_size, GNUNET_i2s(&peer_ctx->peer_id));
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Going to send PULL REPLY with %u peers to %s\n",
+ send_size, GNUNET_i2s (&peer_ctx->peer_id));
- ev = GNUNET_MQ_msg_extra(out_msg,
- send_size * sizeof(struct GNUNET_PeerIdentity),
- GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REPLY);
- out_msg->num_peers = htonl(send_size);
- GNUNET_memcpy(&out_msg[1], peer_ids,
- send_size * sizeof(struct GNUNET_PeerIdentity));
+ ev = GNUNET_MQ_msg_extra (out_msg,
+ send_size * sizeof(struct GNUNET_PeerIdentity),
+ GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REPLY);
+ out_msg->num_peers = htonl (send_size);
+ GNUNET_memcpy (&out_msg[1], peer_ids,
+ send_size * sizeof(struct GNUNET_PeerIdentity));
- send_message(peer_ctx, ev, "PULL REPLY");
+ send_message (peer_ctx, ev, "PULL REPLY");
if (peer_ctx->sub == msub)
- {
- GNUNET_STATISTICS_update(stats, "# pull reply send issued", 1, GNUNET_NO);
- }
+ {
+ 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?
* @param peer Peer to insert
*/
static void
-insert_in_pull_map(void *cls,
- const struct GNUNET_PeerIdentity *peer)
+insert_in_pull_map (void *cls,
+ const struct GNUNET_PeerIdentity *peer)
{
struct Sub *sub = cls;
- CustomPeerMap_put(sub->pull_map, peer);
+ CustomPeerMap_put (sub->pull_map, peer);
}
* @param peer the peer to insert
*/
static void
-insert_in_view_op(void *cls,
- const struct GNUNET_PeerIdentity *peer)
+insert_in_view_op (void *cls,
+ const struct GNUNET_PeerIdentity *peer)
{
struct Sub *sub = cls;
int inserted;
- inserted = insert_in_view(sub, peer);
+ inserted = insert_in_view (sub, peer);
if (GNUNET_OK == inserted)
- {
- clients_notify_stream_peer(sub, 1, peer);
- }
+ {
+ clients_notify_stream_peer (sub, 1, peer);
+ }
}
* @param peer Peer to insert
*/
static void
-insert_in_sampler(void *cls,
- const struct GNUNET_PeerIdentity *peer)
+insert_in_sampler (void *cls,
+ 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(sub->sampler, peer);
- if (0 < RPS_sampler_count_id(sub->sampler, peer))
- {
- /* Make sure we 'know' about this peer */
- (void)issue_peer_online_check(sub, peer);
- /* Establish a channel towards that peer to indicate we are going to send
- * messages to it */
- //indicate_sending_intention (peer);
- }
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Updating samplers with peer %s from insert_in_sampler()\n",
+ GNUNET_i2s (peer));
+ RPS_sampler_update (sub->sampler, peer);
+ if (0 < RPS_sampler_count_id (sub->sampler, peer))
+ {
+ /* Make sure we 'know' about this peer */
+ (void) issue_peer_online_check (sub, peer);
+ /* Establish a channel towards that peer to indicate we are going to send
+ * messages to it */
+ // indicate_sending_intention (peer);
+ }
if (sub == msub)
- {
- GNUNET_STATISTICS_update(stats,
- "# observed peers in gossip",
- 1,
- GNUNET_NO);
- }
+ {
+ GNUNET_STATISTICS_update (stats,
+ "# observed peers in gossip",
+ 1,
+ GNUNET_NO);
+ }
#ifdef TO_FILE
sub->num_observed_peers++;
GNUNET_CONTAINER_multipeermap_put
NULL,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
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);
+ 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",
- sub->num_observed_peers,
- num_observed_unique_peers,
- 1.0 * num_observed_unique_peers / sub->num_observed_peers)
+ to_file (sub->file_name_observed_log,
+ "%" PRIu32 " %" PRIu32 " %f\n",
+ sub->num_observed_peers,
+ num_observed_unique_peers,
+ 1.0 * num_observed_unique_peers / sub->num_observed_peers)
#endif /* TO_FILE_FULL */
#endif /* TO_FILE */
}
* @param peer peer to insert/peer received
*/
static void
-got_peer(struct Sub *sub,
- 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 == 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 (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)
- {
- GNUNET_STATISTICS_update(stats,
- "# learnd peers",
- 1,
- GNUNET_NO);
- }
+ {
+ GNUNET_STATISTICS_update (stats,
+ "# learnd peers",
+ 1,
+ GNUNET_NO);
+ }
}
* GNUNET_NO otherwise
*/
static int
-check_sending_channel_needed(const struct PeerContext *peer_ctx)
+check_sending_channel_needed (const struct PeerContext *peer_ctx)
{
/* struct GNUNET_CADET_Channel *channel; */
- if (GNUNET_NO == check_peer_known(peer_ctx->sub->peer_map,
- &peer_ctx->peer_id))
- {
- return GNUNET_NO;
- }
- if (GNUNET_YES == check_sending_channel_exists(peer_ctx))
- {
- 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;
+ if (GNUNET_NO == check_peer_known (peer_ctx->sub->peer_map,
+ &peer_ctx->peer_id))
+ {
+ return GNUNET_NO;
+ }
+ if (GNUNET_YES == check_sending_channel_exists (peer_ctx))
+ {
+ 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;
+ }
return GNUNET_NO;
}
* @param peer the peer to remove
*/
static void
-remove_peer(struct Sub *sub,
- const struct GNUNET_PeerIdentity *peer)
+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);
+ (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,
+ if (GNUNET_YES == check_peer_known (sub->peer_map,
+ peer))
+ {
+ destroy_peer (get_peer_ctx (sub->peer_map,
peer));
- }
+ }
}
* @param peer the peer whose data is about to be cleaned
*/
static void
-clean_peer(struct Sub *sub,
- const struct GNUNET_PeerIdentity *peer)
+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 (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));
+ 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));
+ (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;
- }
+ }
+
+ 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;
+ }
}
* @param channel The channel being closed
*/
static void
-cleanup_destroyed_channel(void *cls,
- const struct GNUNET_CADET_Channel *channel)
+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;
+ (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);
- }
+ 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);
+ }
}
/***********************************************************************
* @return Sub
*/
struct Sub *
-new_sub(const struct GNUNET_HashCode *hash,
- uint32_t sampler_size,
- struct GNUNET_TIME_Relative round_interval)
+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);
+ 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()
+ 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);
+ 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);
- }
+ {
+ 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);
+ 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);
+ 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);
+ 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);
+ 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");
+ 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");
+ 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);
+ 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->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);
+ 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);
- }
+ {
+ 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);
+ sub->do_round_task = GNUNET_SCHEDULER_add_now (&do_round, sub);
return sub;
}
* @param file_name file to dump into
*/
static void
-write_histogram_to_file(const uint32_t hist_array[],
- const char *file_name)
+write_histogram_to_file (const uint32_t hist_array[],
+ const char *file_name)
{
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);
+ 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);
+ {
+ 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 */
* @param sub Sub to destroy
*/
static void
-destroy_sub(struct Sub *sub)
+destroy_sub (struct Sub *sub)
{
- GNUNET_assert(NULL != sub);
- GNUNET_assert(NULL != sub->do_round_task);
- GNUNET_SCHEDULER_cancel(sub->do_round_task);
+ 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);
+ GNUNET_CADET_close_port (sub->cadet_port);
sub->cadet_port = NULL;
/* Clean up data structures for peers */
- RPS_sampler_destroy(sub->sampler);
+ RPS_sampler_destroy (sub->sampler);
sub->sampler = NULL;
- View_destroy(sub->view);
+ View_destroy (sub->view);
sub->view = NULL;
- CustomPeerMap_destroy(sub->push_map);
+ CustomPeerMap_destroy (sub->push_map);
sub->push_map = NULL;
- CustomPeerMap_destroy(sub->pull_map);
+ CustomPeerMap_destroy (sub->pull_map);
sub->pull_map = NULL;
- peers_terminate(sub);
+ peers_terminate (sub);
/* Free leftover data structures */
#ifdef TO_FILE_FULL
- GNUNET_free(sub->file_name_view_log);
+ 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);
+ GNUNET_free (sub->file_name_observed_log);
sub->file_name_observed_log = NULL;
#endif /* TO_FILE_FULL */
/* Write push frequencies to disk */
- write_histogram_to_file(sub->push_recv,
- "push_recv");
+ write_histogram_to_file (sub->push_recv,
+ "push_recv");
/* Write push deltas to disk */
- write_histogram_to_file(sub->push_delta,
- "push_delta");
+ write_histogram_to_file (sub->push_delta,
+ "push_delta");
/* Write pull delays to disk */
- write_histogram_to_file(sub->pull_delays,
- "pull_delays");
+ write_histogram_to_file (sub->pull_delays,
+ "pull_delays");
- GNUNET_CONTAINER_multipeermap_destroy(sub->observed_unique_peers);
+ GNUNET_CONTAINER_multipeermap_destroy (sub->observed_unique_peers);
sub->observed_unique_peers = NULL;
#endif /* TO_FILE */
- GNUNET_free(sub);
+ GNUNET_free (sub);
}
* @param my_identity - unused
*/
void
-core_init(void *cls,
- const struct GNUNET_PeerIdentity *my_identity)
+core_init (void *cls,
+ const struct GNUNET_PeerIdentity *my_identity)
{
- (void)cls;
- (void)my_identity;
+ (void) cls;
+ (void) my_identity;
- map_single_hop = GNUNET_CONTAINER_multipeermap_create(4, GNUNET_NO);
+ map_single_hop = GNUNET_CONTAINER_multipeermap_create (4, GNUNET_NO);
}
* @return closure given to #core_disconnects as peer_cls
*/
void *
-core_connects(void *cls,
- const struct GNUNET_PeerIdentity *peer,
- struct GNUNET_MQ_Handle *mq)
+core_connects (void *cls,
+ const struct GNUNET_PeerIdentity *peer,
+ struct GNUNET_MQ_Handle *mq)
{
- (void)cls;
- (void)mq;
-
- GNUNET_assert(GNUNET_YES ==
- GNUNET_CONTAINER_multipeermap_put(map_single_hop,
- peer,
- NULL,
- GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+ (void) cls;
+ (void) mq;
+
+ GNUNET_assert (GNUNET_YES ==
+ GNUNET_CONTAINER_multipeermap_put (map_single_hop,
+ peer,
+ NULL,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
return NULL;
}
* @param peer_cls closure given in #core_connects - unused
*/
void
-core_disconnects(void *cls,
- const struct GNUNET_PeerIdentity *peer,
- void *peer_cls)
+core_disconnects (void *cls,
+ const struct GNUNET_PeerIdentity *peer,
+ void *peer_cls)
{
- (void)cls;
- (void)peer_cls;
+ (void) cls;
+ (void) peer_cls;
- GNUNET_CONTAINER_multipeermap_remove_all(map_single_hop, peer);
+ GNUNET_CONTAINER_multipeermap_remove_all (map_single_hop, peer);
}
/***********************************************************************
* @param cli_ctx Context to destroy
*/
static void
-destroy_cli_ctx(struct ClientContext *cli_ctx)
+destroy_cli_ctx (struct ClientContext *cli_ctx)
{
- GNUNET_assert(NULL != cli_ctx);
- GNUNET_CONTAINER_DLL_remove(cli_ctx_head,
- cli_ctx_tail,
- cli_ctx);
+ GNUNET_assert (NULL != cli_ctx);
+ 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);
+ {
+ destroy_sub (cli_ctx->sub);
+ cli_ctx->sub = NULL;
+ }
+ GNUNET_free (cli_ctx);
}
* @param std_dev standard deviation for the estimate
*/
static void
-adapt_sizes(struct Sub *sub, 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
+ // 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(sub->sampler));
- //scale = .01;
- estimate = GNUNET_NSE_log_estimate_to_n(logestimate);
+ 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 (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);
+ estimate = pow (estimate, 1.0 / 3);
// TODO add if std_dev is a number
// estimate += (std_dev * scale);
- if (sub->view_size_est_min < ceil(estimate))
- {
- LOG(GNUNET_ERROR_TYPE_DEBUG, "Changing estimate to %f\n", estimate);
- sub->sampler_size_est_need = estimate;
- sub->view_size_est_need = estimate;
- }
+ if (sub->view_size_est_min < ceil (estimate))
+ {
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Changing estimate to %f\n", 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);
- //sub->sampler_size_est_need = sub->view_size_est_min;
- sub->view_size_est_need = sub->view_size_est_min;
- }
+ {
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Not using estimate %f\n", estimate);
+ // 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);
- }
+ {
+ 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(sub->sampler, sub->sampler_size_est_need);
- View_change_len(sub->view, sub->view_size_est_need);
+ resize_wrapper (sub->sampler, sub->sampler_size_est_need);
+ View_change_len (sub->view, sub->view_size_est_need);
}
* @param std_dev standard deviation for the estimate
*/
static void
-nse_callback(void *cls,
- struct GNUNET_TIME_Absolute timestamp,
- double logestimate, double std_dev)
+nse_callback (void *cls,
+ struct GNUNET_TIME_Absolute timestamp,
+ double logestimate, double std_dev)
{
- (void)cls;
- (void)timestamp;
+ (void) cls;
+ (void) timestamp;
struct ClientContext *cli_ctx_iter;
- adapt_sizes(msub, logestimate, std_dev);
+ adapt_sizes (msub, logestimate, std_dev);
for (cli_ctx_iter = cli_ctx_head;
NULL != cli_ctx_iter;
cli_ctx_iter = cli_ctx_iter->next)
+ {
+ if (NULL != cli_ctx_iter->sub)
{
- if (NULL != cli_ctx_iter->sub)
- {
- adapt_sizes(cli_ctx_iter->sub, logestimate, std_dev);
- }
+ adapt_sizes (cli_ctx_iter->sub, logestimate, std_dev);
}
+ }
}
* #GNUNET_SYSERR otherwise
*/
static int
-check_client_seed(void *cls, const struct GNUNET_RPS_CS_SeedMessage *msg)
+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);
+ uint16_t msize = ntohs (msg->header.size);
+ uint32_t num_peers = ntohl (msg->num_peers);
msize -= sizeof(struct GNUNET_RPS_CS_SeedMessage);
if ((msize / sizeof(struct GNUNET_PeerIdentity) != num_peers) ||
(msize % sizeof(struct GNUNET_PeerIdentity) != 0))
- {
- 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;
- }
+ {
+ 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;
}
* @param message the actual message
*/
static void
-handle_client_seed(void *cls,
- const struct GNUNET_RPS_CS_SeedMessage *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 i;
- num_peers = ntohl(msg->num_peers);
- peers = (struct GNUNET_PeerIdentity *)&msg[1];
+ num_peers = ntohl (msg->num_peers);
+ peers = (struct GNUNET_PeerIdentity *) &msg[1];
- LOG(GNUNET_ERROR_TYPE_DEBUG,
- "Client seeded peers:\n");
- print_peer_list(peers, num_peers);
+ 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]));
-
- 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);
+ {
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Updating samplers with seed %" PRIu32 ": %s\n",
+ i,
+ GNUNET_i2s (&peers[i]));
+
+ 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);
}
* receive
*/
static void
-handle_client_view_request(void *cls,
- const struct GNUNET_RPS_CS_DEBUG_ViewRequest *msg)
+handle_client_view_request (void *cls,
+ const struct GNUNET_RPS_CS_DEBUG_ViewRequest *msg)
{
struct ClientContext *cli_ctx = cls;
uint64_t num_updates;
- num_updates = ntohl(msg->num_updates);
+ num_updates = ntohl (msg->num_updates);
- LOG(GNUNET_ERROR_TYPE_DEBUG,
- "Client requested %" PRIu64 " updates of view.\n",
- num_updates);
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Client requested %" PRIu64 " updates of view.\n",
+ num_updates);
- GNUNET_assert(NULL != cli_ctx);
+ 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);
+ send_view (cli_ctx, NULL, 0);
+ GNUNET_SERVICE_client_continue (cli_ctx->client);
}
* @param msg Unused
*/
static void
-handle_client_view_cancel(void *cls,
- const struct GNUNET_MessageHeader *msg)
+handle_client_view_cancel (void *cls,
+ const struct GNUNET_MessageHeader *msg)
{
struct ClientContext *cli_ctx = cls;
- (void)msg;
+ (void) msg;
- LOG(GNUNET_ERROR_TYPE_DEBUG,
- "Client does not want to receive updates of view any more.\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Client does not want to receive updates of view any more.\n");
- GNUNET_assert(NULL != cli_ctx);
+ GNUNET_assert (NULL != cli_ctx);
cli_ctx->view_updates_left = 0;
- GNUNET_SERVICE_client_continue(cli_ctx->client);
+ GNUNET_SERVICE_client_continue (cli_ctx->client);
if (GNUNET_YES == cli_ctx->stream_update)
- {
- destroy_cli_ctx(cli_ctx);
- }
+ {
+ destroy_cli_ctx (cli_ctx);
+ }
}
* @param message unused
*/
static void
-handle_client_stream_request(void *cls,
- const struct GNUNET_RPS_CS_DEBUG_StreamRequest *msg)
+handle_client_stream_request (void *cls,
+ const struct
+ GNUNET_RPS_CS_DEBUG_StreamRequest *msg)
{
struct ClientContext *cli_ctx = cls;
- (void)msg;
+ (void) msg;
- LOG(GNUNET_ERROR_TYPE_DEBUG,
- "Client requested peers from biased stream.\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Client requested peers from biased stream.\n");
cli_ctx->stream_update = GNUNET_YES;
- GNUNET_assert(NULL != cli_ctx);
- GNUNET_SERVICE_client_continue(cli_ctx->client);
+ GNUNET_assert (NULL != cli_ctx);
+ GNUNET_SERVICE_client_continue (cli_ctx->client);
}
* @param msg unused
*/
static void
-handle_client_stream_cancel(void *cls,
- const struct GNUNET_MessageHeader *msg)
+handle_client_stream_cancel (void *cls,
+ const struct GNUNET_MessageHeader *msg)
{
struct ClientContext *cli_ctx = cls;
- (void)msg;
+ (void) msg;
- LOG(GNUNET_ERROR_TYPE_DEBUG,
- "Client canceled receiving peers from biased stream.\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Client canceled receiving peers from biased stream.\n");
cli_ctx->stream_update = GNUNET_NO;
- GNUNET_assert(NULL != cli_ctx);
- GNUNET_SERVICE_client_continue(cli_ctx->client);
+ GNUNET_assert (NULL != cli_ctx);
+ GNUNET_SERVICE_client_continue (cli_ctx->client);
}
* @param msg Message containing the necessary information
*/
static void
-handle_client_start_sub(void *cls,
- const struct GNUNET_RPS_CS_SubStartMessage *msg)
+handle_client_start_sub (void *cls,
+ const struct GNUNET_RPS_CS_SubStartMessage *msg)
{
struct ClientContext *cli_ctx = cls;
- 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)))
- {
- 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);
+ 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))) )
+ {
+ 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);
}
* @param msg Message containing the hash that identifies the Sub
*/
static void
-handle_client_stop_sub(void *cls,
- const struct GNUNET_RPS_CS_SubStopMessage *msg)
+handle_client_stop_sub (void *cls,
+ const struct GNUNET_RPS_CS_SubStopMessage *msg)
{
struct ClientContext *cli_ctx = cls;
- 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);
+ 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);
+ GNUNET_SERVICE_client_continue (cli_ctx->client);
}
* @param msg Message - unused
*/
static void
-handle_peer_check(void *cls,
- const struct GNUNET_MessageHeader *msg)
+handle_peer_check (void *cls,
+ const struct GNUNET_MessageHeader *msg)
{
const struct ChannelCtx *channel_ctx = cls;
const struct GNUNET_PeerIdentity *peer = &channel_ctx->peer_ctx->peer_id;
- (void)msg;
+ (void) msg;
- LOG(GNUNET_ERROR_TYPE_DEBUG,
- "Received CHECK_LIVE (%s)\n", GNUNET_i2s(peer));
+ 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);
+ {
+ GNUNET_STATISTICS_update (stats,
+ "# pending online checks",
+ -1,
+ GNUNET_NO);
+ }
+
+ GNUNET_CADET_receive_done (channel_ctx->channel);
}
* @param msg Message - unused
*/
static void
-handle_peer_push(void *cls,
- const struct GNUNET_MessageHeader *msg)
+handle_peer_push (void *cls,
+ const struct GNUNET_MessageHeader *msg)
{
const struct ChannelCtx *channel_ctx = cls;
const struct GNUNET_PeerIdentity *peer = &channel_ctx->peer_ctx->peer_id;
- (void)msg;
+ (void) msg;
// (check the proof of work (?))
- LOG(GNUNET_ERROR_TYPE_DEBUG,
- "Received PUSH (%s)\n",
- GNUNET_i2s(peer));
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Received PUSH (%s)\n",
+ GNUNET_i2s (peer));
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", 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);
- }
+ GNUNET_STATISTICS_update (stats,
+ "# push message received (multi-hop peer)",
+ 1,
+ GNUNET_NO);
}
+ }
#if ENABLE_MALICIOUS
struct AttackedPeer *tmp_att_peer;
if ((1 == mal_type) ||
(3 == mal_type))
- { /* Try to maximise representation */
- tmp_att_peer = GNUNET_new(struct AttackedPeer);
- 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))
- {
- GNUNET_CONTAINER_DLL_insert(att_peers_head,
- att_peers_tail,
- tmp_att_peer);
- add_peer_array_to_set(peer, 1, att_peer_set);
- }
- else
- {
- GNUNET_free(tmp_att_peer);
- }
+ { /* Try to maximise representation */
+ tmp_att_peer = GNUNET_new (struct AttackedPeer);
+ 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))
+ {
+ GNUNET_CONTAINER_DLL_insert (att_peers_head,
+ att_peers_tail,
+ tmp_att_peer);
+ add_peer_array_to_set (peer, 1, att_peer_set);
}
+ else
+ {
+ GNUNET_free (tmp_att_peer);
+ }
+ }
else if (2 == mal_type)
- {
- /* We attack one single well-known peer - simply ignore */
- }
+ {
+ /* We attack one single well-known peer - simply ignore */
+ }
#endif /* ENABLE_MALICIOUS */
/* Add the sending peer to the push_map */
- CustomPeerMap_put(channel_ctx->peer_ctx->sub->push_map, peer);
+ CustomPeerMap_put (channel_ctx->peer_ctx->sub->push_map, 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);
+ 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);
}
* @param msg Message - unused
*/
static void
-handle_peer_pull_request(void *cls,
- const struct GNUNET_MessageHeader *msg)
+handle_peer_pull_request (void *cls,
+ const struct GNUNET_MessageHeader *msg)
{
const struct ChannelCtx *channel_ctx = cls;
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;
+ (void) msg;
- LOG(GNUNET_ERROR_TYPE_DEBUG, "Received PULL REQUEST (%s)\n", GNUNET_i2s(peer));
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Received PULL REQUEST (%s)\n", GNUNET_i2s (
+ peer));
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",
- 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);
- }
+ GNUNET_STATISTICS_update (stats,
+ "# pull request message received (multi-hop peer)",
+ 1,
+ GNUNET_NO);
}
+ }
#if ENABLE_MALICIOUS
- if (1 == mal_type
- || 3 == mal_type)
- { /* Try to maximise representation */
- send_pull_reply(peer_ctx, mal_peers, num_mal_peers);
- }
+ if ((1 == mal_type)
+ ||(3 == mal_type))
+ { /* Try to maximise representation */
+ send_pull_reply (peer_ctx, mal_peers, num_mal_peers);
+ }
else if (2 == mal_type)
- { /* Try to partition network */
- if (0 == GNUNET_memcmp(&attacked_peer, peer))
- {
- send_pull_reply(peer_ctx, mal_peers, num_mal_peers);
- }
+ { /* Try to partition network */
+ if (0 == GNUNET_memcmp (&attacked_peer, peer))
+ {
+ send_pull_reply (peer_ctx, mal_peers, num_mal_peers);
}
+ }
#endif /* ENABLE_MALICIOUS */
- 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(channel_ctx->peer_ctx->sub->view);
- send_pull_reply(peer_ctx,
- view_array,
- View_size(channel_ctx->peer_ctx->sub->view));
+ 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 (channel_ctx->peer_ctx->sub->view);
+ send_pull_reply (peer_ctx,
+ view_array,
+ View_size (channel_ctx->peer_ctx->sub->view));
}
* @param msg Message containing the replied peers
*/
static int
-check_peer_pull_reply(void *cls,
- const struct GNUNET_RPS_P2P_PullReplyMessage *msg)
+check_peer_pull_reply (void *cls,
+ const struct GNUNET_RPS_P2P_PullReplyMessage *msg)
{
struct ChannelCtx *channel_ctx = cls;
struct PeerContext *sender_ctx = channel_ctx->peer_ctx;
- if (sizeof(struct GNUNET_RPS_P2P_PullReplyMessage) > ntohs(msg->header.size))
- {
- GNUNET_break_op(0);
- return GNUNET_SYSERR;
- }
-
- if ((ntohs(msg->header.size) - sizeof(struct GNUNET_RPS_P2P_PullReplyMessage)) /
- sizeof(struct GNUNET_PeerIdentity) != ntohl(msg->num_peers))
- {
- LOG(GNUNET_ERROR_TYPE_ERROR,
- "message says it sends %" PRIu32 " peers, have space for %lu peers\n",
- ntohl(msg->num_peers),
- (ntohs(msg->header.size) - sizeof(struct GNUNET_RPS_P2P_PullReplyMessage)) /
- sizeof(struct GNUNET_PeerIdentity));
- GNUNET_break_op(0);
- return GNUNET_SYSERR;
- }
-
- if (GNUNET_YES != check_peer_flag(sender_ctx->sub->peer_map,
- &sender_ctx->peer_id,
- Peers_PULL_REPLY_PENDING))
+ if (sizeof(struct GNUNET_RPS_P2P_PullReplyMessage) > ntohs (msg->header.size))
+ {
+ GNUNET_break_op (0);
+ return GNUNET_SYSERR;
+ }
+
+ if ((ntohs (msg->header.size) - sizeof(struct
+ GNUNET_RPS_P2P_PullReplyMessage))
+ / sizeof(struct GNUNET_PeerIdentity) != ntohl (msg->num_peers))
+ {
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ "message says it sends %" PRIu32 " peers, have space for %lu peers\n",
+ ntohl (msg->num_peers),
+ (ntohs (msg->header.size) - sizeof(struct
+ GNUNET_RPS_P2P_PullReplyMessage))
+ / sizeof(struct GNUNET_PeerIdentity));
+ GNUNET_break_op (0);
+ return GNUNET_SYSERR;
+ }
+
+ 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_ctx->peer_id));
+ if (sender_ctx->sub == msub)
{
- LOG(GNUNET_ERROR_TYPE_WARNING,
- "Received a pull reply from a peer (%s) we didn't request one from!\n",
- GNUNET_i2s(&sender_ctx->peer_id));
- if (sender_ctx->sub == msub)
- {
- GNUNET_STATISTICS_update(stats,
- "# unrequested pull replies",
- 1,
- GNUNET_NO);
- }
+ GNUNET_STATISTICS_update (stats,
+ "# unrequested pull replies",
+ 1,
+ GNUNET_NO);
}
+ }
return GNUNET_OK;
}
* @param msg The message header
*/
static void
-handle_peer_pull_reply(void *cls,
- const struct GNUNET_RPS_P2P_PullReplyMessage *msg)
+handle_peer_pull_reply (void *cls,
+ const struct GNUNET_RPS_P2P_PullReplyMessage *msg)
{
const struct ChannelCtx *channel_ctx = cls;
const struct GNUNET_PeerIdentity *sender = &channel_ctx->peer_ctx->peer_id;
#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));
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Received PULL REPLY (%s)\n", GNUNET_i2s (
+ sender));
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",
- 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);
- }
+ GNUNET_STATISTICS_update (stats,
+ "# pull reply messages received (multi-hop peer)",
+ 1,
+ GNUNET_NO);
}
+ }
#if ENABLE_MALICIOUS
// We shouldn't even receive pull replies as we're not sending
if (2 == mal_type)
- {
- }
+ {
+ }
#endif /* ENABLE_MALICIOUS */
/* Do actual logic */
- peers = (const struct GNUNET_PeerIdentity *)&msg[1];
+ peers = (const struct GNUNET_PeerIdentity *) &msg[1];
- LOG(GNUNET_ERROR_TYPE_DEBUG,
- "PULL REPLY received, got following %u peers:\n",
- ntohl(msg->num_peers));
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "PULL REPLY received, got following %u peers:\n",
+ ntohl (msg->num_peers));
- for (i = 0; i < ntohl(msg->num_peers); i++)
- {
- LOG(GNUNET_ERROR_TYPE_DEBUG,
- "%u. %s\n",
- i,
- GNUNET_i2s(&peers[i]));
+ for (i = 0; i < ntohl (msg->num_peers); i++)
+ {
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "%u. %s\n",
+ i,
+ GNUNET_i2s (&peers[i]));
#if ENABLE_MALICIOUS
- if ((NULL != att_peer_set) &&
- (1 == mal_type || 3 == mal_type))
- { /* Add attacked peer to local list */
+ if ((NULL != att_peer_set) &&
+ ((1 == mal_type) ||(3 == mal_type) ))
+ { /* Add attacked peer to local list */
// TODO check if we sent a request and this was the first reply
- if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains(att_peer_set,
- &peers[i])
- && GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains(mal_peer_set,
- &peers[i]))
- {
- tmp_att_peer = GNUNET_new(struct AttackedPeer);
- tmp_att_peer->peer_id = peers[i];
- GNUNET_CONTAINER_DLL_insert(att_peers_head,
- att_peers_tail,
- tmp_att_peer);
- add_peer_array_to_set(&peers[i], 1, att_peer_set);
- }
- continue;
- }
+ if ((GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (att_peer_set,
+ &peers[i]))
+ &&(GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (mal_peer_set,
+ &peers[i])) )
+ {
+ tmp_att_peer = GNUNET_new (struct AttackedPeer);
+ tmp_att_peer->peer_id = peers[i];
+ GNUNET_CONTAINER_DLL_insert (att_peers_head,
+ att_peers_tail,
+ tmp_att_peer);
+ add_peer_array_to_set (&peers[i], 1, att_peer_set);
+ }
+ continue;
+ }
#endif /* ENABLE_MALICIOUS */
- /* Make sure we 'know' about this peer */
- (void)insert_peer(channel_ctx->peer_ctx->sub,
+ /* Make sure we 'know' about this peer */
+ (void) insert_peer (channel_ctx->peer_ctx->sub,
&peers[i]);
- if (GNUNET_YES == check_peer_valid(channel_ctx->peer_ctx->sub->valid_peers,
- &peers[i]))
- {
- CustomPeerMap_put(channel_ctx->peer_ctx->sub->pull_map,
- &peers[i]);
- }
- else
- {
- 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]);
- }
+ if (GNUNET_YES == check_peer_valid (channel_ctx->peer_ctx->sub->valid_peers,
+ &peers[i]))
+ {
+ CustomPeerMap_put (channel_ctx->peer_ctx->sub->pull_map,
+ &peers[i]);
}
-
- 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(check_peer_known(channel_ctx->peer_ctx->sub->peer_map,
- sender));
- GNUNET_CADET_receive_done(channel_ctx->channel);
+ else
+ {
+ 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]);
+ }
+ }
+
+ 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 (check_peer_known (channel_ctx->peer_ctx->sub->peer_map,
+ sender));
+ GNUNET_CADET_receive_done (channel_ctx->channel);
}
* @param spread the inverse amount of deviation from the mean
*/
static struct GNUNET_TIME_Relative
-compute_rand_delay(struct GNUNET_TIME_Relative mean,
- unsigned int spread)
+compute_rand_delay (struct GNUNET_TIME_Relative mean,
+ unsigned int spread)
{
struct GNUNET_TIME_Relative half_interval;
struct GNUNET_TIME_Relative ret;
unsigned int max_rand_delay;
if (0 == spread)
- {
- LOG(GNUNET_ERROR_TYPE_WARNING,
- "Not accepting spread of 0\n");
- GNUNET_break(0);
- GNUNET_assert(0);
- }
- GNUNET_assert(0 != mean.rel_value_us);
+ {
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ "Not accepting spread of 0\n");
+ GNUNET_break (0);
+ GNUNET_assert (0);
+ }
+ GNUNET_assert (0 != mean.rel_value_us);
/* Compute random time value between spread * mean and spread * mean */
- half_interval = GNUNET_TIME_relative_divide(mean, spread);
+ half_interval = GNUNET_TIME_relative_divide (mean, spread);
- max_rand_delay = GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us / mean.rel_value_us * (2 / spread);
+ max_rand_delay = GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us
+ / mean.rel_value_us * (2 / spread);
/**
* Compute random value between (0 and 1) * round_interval
* via multiplying round_interval with a 'fraction' (0 to value)/value
*/
- rand_delay = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, max_rand_delay);
- ret = GNUNET_TIME_relative_saturating_multiply(mean, rand_delay);
- ret = GNUNET_TIME_relative_divide(ret, max_rand_delay);
- ret = GNUNET_TIME_relative_add(ret, half_interval);
+ rand_delay = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+ max_rand_delay);
+ ret = GNUNET_TIME_relative_saturating_multiply (mean, rand_delay);
+ ret = GNUNET_TIME_relative_divide (ret, max_rand_delay);
+ ret = GNUNET_TIME_relative_add (ret, half_interval);
if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us == ret.rel_value_us)
- LOG(GNUNET_ERROR_TYPE_WARNING,
- "Returning FOREVER_REL\n");
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ "Returning FOREVER_REL\n");
return ret;
}
* @param peer_ctx Context to the peer to send request to
*/
static void
-send_pull_request(struct PeerContext *peer_ctx)
+send_pull_request (struct PeerContext *peer_ctx)
{
struct GNUNET_MQ_Envelope *ev;
- 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);
+ 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_ctx->peer_id));
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Going to send PULL REQUEST to peer %s.\n",
+ GNUNET_i2s (&peer_ctx->peer_id));
- ev = GNUNET_MQ_msg_header(GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REQUEST);
- send_message(peer_ctx,
- ev,
- "PULL REQUEST");
+ ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REQUEST);
+ 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",
- 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);
- }
+ GNUNET_STATISTICS_update (stats,
+ "# pull request send issued (multi-hop peer)",
+ 1,
+ GNUNET_NO);
}
+ }
}
* @param peer_ctx Context of peer to send push to
*/
static void
-send_push(struct PeerContext *peer_ctx)
+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_ctx->peer_id));
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Going to send PUSH to peer %s.\n",
+ GNUNET_i2s (&peer_ctx->peer_id));
- ev = GNUNET_MQ_msg_header(GNUNET_MESSAGE_TYPE_RPS_PP_PUSH);
- send_message(peer_ctx, ev, "PUSH");
+ ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_RPS_PP_PUSH);
+ 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",
- 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);
- }
+ GNUNET_STATISTICS_update (stats,
+ "# push send issued (multi-hop peer)",
+ 1,
+ GNUNET_NO);
}
+ }
}
* @return #GNUNET_OK if @a msg is well-formed
*/
static int
-check_client_act_malicious(void *cls,
- const struct GNUNET_RPS_CS_ActMaliciousMessage *msg)
+check_client_act_malicious (void *cls,
+ const struct GNUNET_RPS_CS_ActMaliciousMessage *msg)
{
struct ClientContext *cli_ctx = cls;
- uint16_t msize = ntohs(msg->header.size);
- uint32_t num_peers = ntohl(msg->num_peers);
+ uint16_t msize = ntohs (msg->header.size);
+ uint32_t num_peers = ntohl (msg->num_peers);
msize -= sizeof(struct GNUNET_RPS_CS_ActMaliciousMessage);
if ((msize / sizeof(struct GNUNET_PeerIdentity) != num_peers) ||
(msize % sizeof(struct GNUNET_PeerIdentity) != 0))
- {
- LOG(GNUNET_ERROR_TYPE_ERROR,
- "message says it sends %" PRIu32 " peers, have space for %lu peers\n",
- ntohl(msg->num_peers),
- (msize / sizeof(struct GNUNET_PeerIdentity)));
- GNUNET_break(0);
- GNUNET_SERVICE_client_drop(cli_ctx->client);
- return GNUNET_SYSERR;
- }
+ {
+ 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;
}
* @param msg The message header
*/
static void
-handle_client_act_malicious(void *cls,
- const struct GNUNET_RPS_CS_ActMaliciousMessage *msg)
+handle_client_act_malicious (void *cls,
+ const struct
+ GNUNET_RPS_CS_ActMaliciousMessage *msg)
{
struct ClientContext *cli_ctx = cls;
struct GNUNET_PeerIdentity *peers;
if (NULL == sub)
sub = msub;
/* Do actual logic */
- peers = (struct GNUNET_PeerIdentity *)&msg[1];
- mal_type = ntohl(msg->type);
+ peers = (struct GNUNET_PeerIdentity *) &msg[1];
+ mal_type = ntohl (msg->type);
if (NULL == mal_peer_set)
- mal_peer_set = GNUNET_CONTAINER_multipeermap_create(1, GNUNET_NO);
+ mal_peer_set = GNUNET_CONTAINER_multipeermap_create (1, GNUNET_NO);
- LOG(GNUNET_ERROR_TYPE_DEBUG,
- "Now acting malicious type %" PRIu32 ", got %" PRIu32 " peers.\n",
- mal_type,
- ntohl(msg->num_peers));
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Now acting malicious type %" PRIu32 ", got %" PRIu32 " peers.\n",
+ mal_type,
+ ntohl (msg->num_peers));
if (1 == mal_type)
- { /* Try to maximise representation */
+ { /* Try to maximise representation */
/* Add other malicious peers to those we already know */
- num_mal_peers_sent = ntohl(msg->num_peers);
- num_mal_peers_old = num_mal_peers;
- GNUNET_array_grow(mal_peers,
- num_mal_peers,
- num_mal_peers + num_mal_peers_sent);
- GNUNET_memcpy(&mal_peers[num_mal_peers_old],
- peers,
- num_mal_peers_sent * sizeof(struct GNUNET_PeerIdentity));
-
- /* Add all mal peers to mal_peer_set */
- add_peer_array_to_set(&mal_peers[num_mal_peers_old],
- num_mal_peers_sent,
- mal_peer_set);
-
- /* Substitute do_round () with do_mal_round () */
- 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);
- }
+ num_mal_peers_sent = ntohl (msg->num_peers);
+ num_mal_peers_old = num_mal_peers;
+ GNUNET_array_grow (mal_peers,
+ num_mal_peers,
+ num_mal_peers + num_mal_peers_sent);
+ GNUNET_memcpy (&mal_peers[num_mal_peers_old],
+ peers,
+ num_mal_peers_sent * sizeof(struct GNUNET_PeerIdentity));
+
+ /* Add all mal peers to mal_peer_set */
+ add_peer_array_to_set (&mal_peers[num_mal_peers_old],
+ num_mal_peers_sent,
+ mal_peer_set);
+
+ /* Substitute do_round () with do_mal_round () */
+ 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) ||
(3 == mal_type))
- { /* Try to partition the network */
+ { /* Try to partition the network */
/* Add other malicious peers to those we already know */
- num_mal_peers_sent = ntohl(msg->num_peers) - 1;
- num_mal_peers_old = num_mal_peers;
- GNUNET_assert(GNUNET_MAX_MALLOC_CHECKED > num_mal_peers_sent);
- GNUNET_array_grow(mal_peers,
- num_mal_peers,
- num_mal_peers + num_mal_peers_sent);
- if (NULL != mal_peers &&
- 0 != num_mal_peers)
- {
- GNUNET_memcpy(&mal_peers[num_mal_peers_old],
- peers,
- num_mal_peers_sent * sizeof(struct GNUNET_PeerIdentity));
-
- /* Add all mal peers to mal_peer_set */
- add_peer_array_to_set(&mal_peers[num_mal_peers_old],
- num_mal_peers_sent,
- mal_peer_set);
- }
-
- /* Store the one attacked peer */
- GNUNET_memcpy(&attacked_peer,
- &msg->attacked_peer,
- sizeof(struct GNUNET_PeerIdentity));
- /* Set the flag of the attacked peer to valid to avoid problems */
- if (GNUNET_NO == check_peer_known(sub->peer_map, &attacked_peer))
- {
- (void)issue_peer_online_check(sub, &attacked_peer);
- }
-
- LOG(GNUNET_ERROR_TYPE_DEBUG,
- "Attacked peer is %s\n",
- GNUNET_i2s(&attacked_peer));
-
- /* Substitute do_round () with do_mal_round () */
- 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);
- }
+ num_mal_peers_sent = ntohl (msg->num_peers) - 1;
+ num_mal_peers_old = num_mal_peers;
+ GNUNET_assert (GNUNET_MAX_MALLOC_CHECKED > num_mal_peers_sent);
+ GNUNET_array_grow (mal_peers,
+ num_mal_peers,
+ num_mal_peers + num_mal_peers_sent);
+ if ((NULL != mal_peers) &&
+ (0 != num_mal_peers) )
+ {
+ GNUNET_memcpy (&mal_peers[num_mal_peers_old],
+ peers,
+ num_mal_peers_sent * sizeof(struct GNUNET_PeerIdentity));
+
+ /* Add all mal peers to mal_peer_set */
+ add_peer_array_to_set (&mal_peers[num_mal_peers_old],
+ num_mal_peers_sent,
+ mal_peer_set);
}
- 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(sub->do_round_task);
- sub->do_round_task = GNUNET_SCHEDULER_add_now(&do_round, sub);
+ /* Store the one attacked peer */
+ GNUNET_memcpy (&attacked_peer,
+ &msg->attacked_peer,
+ sizeof(struct GNUNET_PeerIdentity));
+ /* Set the flag of the attacked peer to valid to avoid problems */
+ if (GNUNET_NO == check_peer_known (sub->peer_map, &attacked_peer))
+ {
+ (void) issue_peer_online_check (sub, &attacked_peer);
}
- else
+
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Attacked peer is %s\n",
+ GNUNET_i2s (&attacked_peer));
+
+ /* Substitute do_round () with do_mal_round () */
+ if (NULL != sub->do_round_task)
{
- GNUNET_break(0);
- GNUNET_SERVICE_client_continue(cli_ctx->client);
+ /* Probably in shutdown */
+ GNUNET_SCHEDULER_cancel (sub->do_round_task);
+ sub->do_round_task = GNUNET_SCHEDULER_add_now (&do_mal_round, sub);
}
- GNUNET_SERVICE_client_continue(cli_ctx->client);
+ }
+ 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 (sub->do_round_task);
+ sub->do_round_task = GNUNET_SCHEDULER_add_now (&do_round, sub);
+ }
+ else
+ {
+ GNUNET_break (0);
+ GNUNET_SERVICE_client_continue (cli_ctx->client);
+ }
+ GNUNET_SERVICE_client_continue (cli_ctx->client);
}
* @param cls Closure - Sub
*/
static void
-do_mal_round(void *cls)
+do_mal_round (void *cls)
{
uint32_t num_pushes;
uint32_t i;
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);
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Going to execute next round maliciously type %" PRIu32 ".\n",
+ mal_type);
sub->do_round_task = NULL;
- GNUNET_assert(mal_type <= 3);
+ GNUNET_assert (mal_type <= 3);
/* Do malicious actions */
if (1 == mal_type)
- { /* Try to maximise representation */
+ { /* Try to maximise representation */
/* The maximum of pushes we're going to send this round */
- num_pushes = GNUNET_MIN(GNUNET_MIN(push_limit,
+ num_pushes = GNUNET_MIN (GNUNET_MIN (push_limit,
num_attacked_peers),
- GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE);
-
- LOG(GNUNET_ERROR_TYPE_DEBUG,
- "Going to send %" PRIu32 " pushes\n",
- num_pushes);
-
- /* Send PUSHes to attacked peers */
- for (i = 0; i < num_pushes; i++)
- {
- if (att_peers_tail == att_peer_index)
- att_peer_index = att_peers_head;
- else
- att_peer_index = att_peer_index->next;
-
- 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 */
- tmp_att_peer = att_peer_index;
- for (i = 0; i < num_pushes * alpha; i++)
- {
- if (att_peers_tail == tmp_att_peer)
- tmp_att_peer = att_peers_head;
- else
- att_peer_index = tmp_att_peer->next;
-
- send_pull_request(get_peer_ctx(sub->peer_map, &tmp_att_peer->peer_id));
- }
+ GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE);
+
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Going to send %" PRIu32 " pushes\n",
+ num_pushes);
+
+ /* Send PUSHes to attacked peers */
+ for (i = 0; i < num_pushes; i++)
+ {
+ if (att_peers_tail == att_peer_index)
+ att_peer_index = att_peers_head;
+ else
+ att_peer_index = att_peer_index->next;
+
+ 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 */
+ tmp_att_peer = att_peer_index;
+ for (i = 0; i < num_pushes * alpha; i++)
+ {
+ if (att_peers_tail == tmp_att_peer)
+ tmp_att_peer = att_peers_head;
+ else
+ att_peer_index = tmp_att_peer->next;
+
+ send_pull_request (get_peer_ctx (sub->peer_map, &tmp_att_peer->peer_id));
}
+ }
else if (2 == mal_type)
- { /**
+ { /**
* Try to partition the network
* Send as many pushes to the attacked peer as possible
* That is one push per round as it will ignore more.
*/
- (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));
- }
+ (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));
+ }
if (3 == mal_type)
- { /* Combined attack */
+ { /* Combined attack */
/* Send PUSH to attacked peers */
- if (GNUNET_YES == check_peer_known(sub->peer_map, &attacked_peer))
- {
- (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(get_peer_ctx(sub->peer_map, &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,
+ if (GNUNET_YES == check_peer_known (sub->peer_map, &attacked_peer))
+ {
+ (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 (get_peer_ctx (sub->peer_map, &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,
num_attacked_peers),
- GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE);
-
- LOG(GNUNET_ERROR_TYPE_DEBUG,
- "Going to send %" PRIu32 " pushes\n",
- num_pushes);
-
- for (i = 0; i < num_pushes; i++)
- {
- if (att_peers_tail == att_peer_index)
- att_peer_index = att_peers_head;
- else
- att_peer_index = att_peer_index->next;
-
- 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 */
- tmp_att_peer = att_peer_index;
- for (i = 0; i < num_pushes * alpha; i++)
- {
- if (att_peers_tail == tmp_att_peer)
- tmp_att_peer = att_peers_head;
- else
- att_peer_index = tmp_att_peer->next;
-
- send_pull_request(get_peer_ctx(sub->peer_map, &tmp_att_peer->peer_id));
- }
+ GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE);
+
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Going to send %" PRIu32 " pushes\n",
+ num_pushes);
+
+ for (i = 0; i < num_pushes; i++)
+ {
+ if (att_peers_tail == att_peer_index)
+ att_peer_index = att_peers_head;
+ else
+ att_peer_index = att_peer_index->next;
+
+ 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 */
+ tmp_att_peer = att_peer_index;
+ for (i = 0; i < num_pushes * alpha; i++)
+ {
+ if (att_peers_tail == tmp_att_peer)
+ tmp_att_peer = att_peers_head;
+ else
+ att_peer_index = tmp_att_peer->next;
+
+ send_pull_request (get_peer_ctx (sub->peer_map, &tmp_att_peer->peer_id));
+ }
+ }
+
/* Schedule next round */
- time_next_round = compute_rand_delay(sub->round_interval, 2);
+ time_next_round = compute_rand_delay (sub->round_interval, 2);
- 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");
+ 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 */
* @param cls Closure - Sub
*/
static void
-do_round(void *cls)
+do_round (void *cls)
{
unsigned int i;
const struct GNUNET_PeerIdentity *view_array;
struct Sub *sub = cls;
sub->num_rounds++;
- LOG(GNUNET_ERROR_TYPE_DEBUG,
- "Going to execute next round.\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Going to execute next round.\n");
if (sub == msub)
- {
- GNUNET_STATISTICS_update(stats, "# rounds", 1, GNUNET_NO);
- }
+ {
+ 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 ___");
+ to_file (sub->file_name_view_log,
+ "___ new round ___");
#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]));
+ 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]));
#ifdef TO_FILE_FULL
- to_file(sub->file_name_view_log,
- "=%s\t(do round)",
- GNUNET_i2s_full(&view_array[i]));
+ 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(sub->view))
+ if (0 < View_size (sub->view))
+ {
+ permut = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_STRONG,
+ View_size (sub->view));
+
+ /* Send PUSHes */
+ 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 (sub->view));
+ for (i = 0; i < a_peers; i++)
{
- permut = GNUNET_CRYPTO_random_permute(GNUNET_CRYPTO_QUALITY_STRONG,
- View_size(sub->view));
-
- /* Send PUSHes */
- 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(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(get_peer_ctx(sub->peer_map, &peer));
- }
-
- /* Send PULL requests */
- b_peers = ceil(beta * View_size(sub->view));
- first_border = a_peers;
- second_border = a_peers + b_peers;
- if (second_border > View_size(sub->view))
- {
- 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(sub->view));
- for (i = first_border; i < second_border; i++)
- {
- peer = view_array[permut[i]];
- 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(get_peer_ctx(sub->peer_map, &peer));
- }
- }
-
- GNUNET_free(permut);
- permut = NULL;
+ peer = view_array[permut[i]];
+ // FIXME if this fails schedule/loop this for later
+ send_push (get_peer_ctx (sub->peer_map, &peer));
}
+ /* Send PULL requests */
+ b_peers = ceil (beta * View_size (sub->view));
+ first_border = a_peers;
+ second_border = a_peers + b_peers;
+ if (second_border > View_size (sub->view))
+ {
+ 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 (sub->view));
+ for (i = first_border; i < second_border; i++)
+ {
+ peer = view_array[permut[i]];
+ 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 (get_peer_ctx (sub->peer_map, &peer));
+ }
+ }
+
+ GNUNET_free (permut);
+ permut = NULL;
+ }
+
/* Update view */
/* TODO see how many peers are in push-/pull- list! */
- 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");
-
- uint32_t final_size;
- uint32_t peers_to_clean_size;
- struct GNUNET_PeerIdentity *peers_to_clean;
-
- peers_to_clean = NULL;
- peers_to_clean_size = 0;
- GNUNET_array_grow(peers_to_clean,
- peers_to_clean_size,
- View_size(sub->view));
- GNUNET_memcpy(peers_to_clean,
- view_array,
- View_size(sub->view) * sizeof(struct GNUNET_PeerIdentity));
-
- /* Seems like recreating is the easiest way of emptying the peermap */
- View_clear(sub->view);
+ 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");
+
+ uint32_t final_size;
+ uint32_t peers_to_clean_size;
+ struct GNUNET_PeerIdentity *peers_to_clean;
+
+ peers_to_clean = NULL;
+ peers_to_clean_size = 0;
+ GNUNET_array_grow (peers_to_clean,
+ peers_to_clean_size,
+ View_size (sub->view));
+ GNUNET_memcpy (peers_to_clean,
+ view_array,
+ View_size (sub->view) * sizeof(struct GNUNET_PeerIdentity));
+
+ /* Seems like recreating is the easiest way of emptying the peermap */
+ View_clear (sub->view);
#ifdef TO_FILE_FULL
- to_file(sub->file_name_view_log,
- "--- emptied ---");
+ to_file (sub->file_name_view_log,
+ "--- emptied ---");
#endif /* TO_FILE_FULL */
- first_border = GNUNET_MIN(ceil(alpha * sub->view_size_est_need),
- CustomPeerMap_size(sub->push_map));
- second_border = first_border +
- GNUNET_MIN(floor(beta * sub->view_size_est_need),
- CustomPeerMap_size(sub->pull_map));
- final_size = second_border +
- 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,
- second_border,
- final_size);
-
- /* Update view with peers received through PUSHes */
- permut = GNUNET_CRYPTO_random_permute(GNUNET_CRYPTO_QUALITY_STRONG,
- CustomPeerMap_size(sub->push_map));
- for (i = 0; i < first_border; i++)
- {
- 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]));
- }
+ first_border = GNUNET_MIN (ceil (alpha * sub->view_size_est_need),
+ CustomPeerMap_size (sub->push_map));
+ second_border = first_border
+ + GNUNET_MIN (floor (beta * sub->view_size_est_need),
+ CustomPeerMap_size (sub->pull_map));
+ final_size = second_border
+ + 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,
+ second_border,
+ final_size);
+
+ /* Update view with peers received through PUSHes */
+ permut = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_STRONG,
+ CustomPeerMap_size (sub->push_map));
+ for (i = 0; i < first_border; i++)
+ {
+ 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]));
+ 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);
- permut = NULL;
-
- /* Update view with peers received through PULLs */
- permut = GNUNET_CRYPTO_random_permute(GNUNET_CRYPTO_QUALITY_STRONG,
- CustomPeerMap_size(sub->pull_map));
- for (i = first_border; i < second_border; i++)
- {
- 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]));
- }
+ }
+ GNUNET_free (permut);
+ permut = NULL;
+
+ /* Update view with peers received through PULLs */
+ permut = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_STRONG,
+ CustomPeerMap_size (sub->pull_map));
+ for (i = first_border; i < second_border; i++)
+ {
+ 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]));
+ 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(sub->sampler,
- final_size - second_border,
- hist_update,
- sub);
- // TODO change the peer_flags accordingly
-
- 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++)
- {
+ }
+ GNUNET_free (permut);
+ permut = NULL;
+
+ /* Update view with peers from history */
+ RPS_sampler_get_n_rand_peers (sub->sampler,
+ final_size - second_border,
+ hist_update,
+ sub);
+ // TODO change the peer_flags accordingly
+
+ 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++)
+ {
#ifdef TO_FILE_FULL
- to_file(sub->file_name_view_log,
- "-%s",
- GNUNET_i2s_full(&peers_to_clean[i]));
+ to_file (sub->file_name_view_log,
+ "-%s",
+ GNUNET_i2s_full (&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(sub);
+ clean_peer (sub, &peers_to_clean[i]);
}
+
+ GNUNET_array_grow (peers_to_clean, peers_to_clean_size, 0);
+ clients_notify_view_update (sub);
+ }
else
+ {
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "No update of the view.\n");
+ if (sub == msub)
{
- LOG(GNUNET_ERROR_TYPE_DEBUG, "No update of the view.\n");
- 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);
- }
- }
+ 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()?
- if (CustomPeerMap_size(sub->push_map) < HISTOGRAM_FILE_SLOTS)
- {
- sub->push_recv[CustomPeerMap_size(sub->push_map)]++;
- }
+ 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);
- }
+ {
+ 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)]++;
+ 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 (sub->view%u) = %.2f)\n",
- CustomPeerMap_size(sub->push_map),
- CustomPeerMap_size(sub->pull_map),
- alpha,
- View_size(sub->view),
- alpha * View_size(sub->view));
+ {
+ 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 (sub->view%u) = %.2f)\n",
+ CustomPeerMap_size (sub->push_map),
+ CustomPeerMap_size (sub->pull_map),
+ alpha,
+ View_size (sub->view),
+ alpha * View_size (sub->view));
/* Update samplers */
- for (i = 0; i < CustomPeerMap_size(sub->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(sub, update_peer);
- clean_peer(sub, update_peer); /* This cleans only if it is not in the view */
- }
-
- 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(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(sub, CustomPeerMap_get_peer_by_index(sub->pull_map, i));
- }
+ for (i = 0; i < CustomPeerMap_size (sub->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 (sub, update_peer);
+ clean_peer (sub, update_peer); /* This cleans only if it is not in the view */
+ }
+
+ 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 (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 (sub, CustomPeerMap_get_peer_by_index (sub->pull_map, i));
+ }
/* Empty push/pull lists */
- CustomPeerMap_clear(sub->push_map);
- CustomPeerMap_clear(sub->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);
- }
+ {
+ 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(sub->round_interval, 2);
+ time_next_round = compute_rand_delay (sub->round_interval, 2);
/* Schedule next round */
- sub->do_round_task = GNUNET_SCHEDULER_add_delayed(time_next_round,
- &do_round, sub);
- LOG(GNUNET_ERROR_TYPE_DEBUG, "Finished round\n");
+ sub->do_round_task = GNUNET_SCHEDULER_add_delayed (time_next_round,
+ &do_round, sub);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Finished round\n");
}
* (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?
+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)" */
{
struct Sub *sub = cls;
- (void)tunnel;
- (void)n_paths;
- (void)best_path;
+ (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(sub, peer);
- }
+ {
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Got peer_id %s from cadet\n",
+ GNUNET_i2s (peer));
+ got_peer (sub, peer);
+ }
}
* #GNUNET_NO if not.
*/
static int
-valid_peers_iterator(void *cls,
- const struct GNUNET_PeerIdentity *peer)
+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(sub, peer);
- }
+ {
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Got stored, valid peer %s\n",
+ GNUNET_i2s (peer));
+ got_peer (sub, peer);
+ }
return GNUNET_YES;
}
* @param error message
*/
void
-process_peerinfo_peers(void *cls,
- const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_HELLO_Message *hello,
- const char *err_msg)
+process_peerinfo_peers (void *cls,
+ const struct GNUNET_PeerIdentity *peer,
+ const struct GNUNET_HELLO_Message *hello,
+ const char *err_msg)
{
struct Sub *sub = cls;
- (void)hello;
- (void)err_msg;
+ (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(sub, peer);
- }
+ {
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Got peer_id %s from peerinfo\n",
+ GNUNET_i2s (peer));
+ got_peer (sub, peer);
+ }
}
* @param cls Closure - unused
*/
static void
-shutdown_task(void *cls)
+shutdown_task (void *cls)
{
- (void)cls;
+ (void) cls;
struct ClientContext *client_ctx;
- LOG(GNUNET_ERROR_TYPE_DEBUG,
- "RPS service is going down\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "RPS service is going down\n");
/* Clean all clients */
for (client_ctx = cli_ctx_head;
NULL != cli_ctx_head;
client_ctx = cli_ctx_head)
- {
- destroy_cli_ctx(client_ctx);
- }
+ {
+ destroy_cli_ctx (client_ctx);
+ }
if (NULL != msub)
- {
- destroy_sub(msub);
- msub = NULL;
- }
+ {
+ destroy_sub (msub);
+ msub = NULL;
+ }
/* Disconnect from other services */
- GNUNET_PEERINFO_notify_cancel(peerinfo_notify_handle);
- GNUNET_PEERINFO_disconnect(peerinfo_handle);
+ GNUNET_PEERINFO_notify_cancel (peerinfo_notify_handle);
+ GNUNET_PEERINFO_disconnect (peerinfo_handle);
peerinfo_handle = NULL;
- GNUNET_NSE_disconnect(nse);
+ GNUNET_NSE_disconnect (nse);
if (NULL != map_single_hop)
- {
- /* 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;
- }
+ {
+ /* 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;
+ }
if (NULL != stats)
- {
- GNUNET_STATISTICS_destroy(stats,
- GNUNET_NO);
- stats = NULL;
- }
- GNUNET_CADET_disconnect(cadet_handle);
+ {
+ GNUNET_STATISTICS_destroy (stats,
+ GNUNET_NO);
+ stats = NULL;
+ }
+ GNUNET_CADET_disconnect (cadet_handle);
cadet_handle = NULL;
#if ENABLE_MALICIOUS
struct AttackedPeer *tmp_att_peer;
- GNUNET_array_grow(mal_peers,
- num_mal_peers,
- 0);
+ GNUNET_array_grow (mal_peers,
+ num_mal_peers,
+ 0);
if (NULL != mal_peer_set)
- GNUNET_CONTAINER_multipeermap_destroy(mal_peer_set);
+ GNUNET_CONTAINER_multipeermap_destroy (mal_peer_set);
if (NULL != att_peer_set)
- GNUNET_CONTAINER_multipeermap_destroy(att_peer_set);
+ GNUNET_CONTAINER_multipeermap_destroy (att_peer_set);
while (NULL != att_peers_head)
- {
- tmp_att_peer = att_peers_head;
- GNUNET_CONTAINER_DLL_remove(att_peers_head,
- att_peers_tail,
- tmp_att_peer);
- GNUNET_free(tmp_att_peer);
- }
+ {
+ tmp_att_peer = att_peers_head;
+ GNUNET_CONTAINER_DLL_remove (att_peers_head,
+ att_peers_tail,
+ tmp_att_peer);
+ GNUNET_free (tmp_att_peer);
+ }
#endif /* ENABLE_MALICIOUS */
- close_all_files();
+ close_all_files ();
}
* @return @a client
*/
static void *
-client_connect_cb(void *cls,
- struct GNUNET_SERVICE_Client *client,
- struct GNUNET_MQ_Handle *mq)
+client_connect_cb (void *cls,
+ struct GNUNET_SERVICE_Client *client,
+ struct GNUNET_MQ_Handle *mq)
{
struct ClientContext *cli_ctx;
- (void)cls;
+ (void) cls;
- LOG(GNUNET_ERROR_TYPE_DEBUG,
- "Client connected\n");
+ 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 = GNUNET_new (struct ClientContext);
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,
- cli_ctx);
+ GNUNET_CONTAINER_DLL_insert (cli_ctx_head,
+ cli_ctx_tail,
+ cli_ctx);
return cli_ctx;
}
* @param internal_cls should be equal to @a c
*/
static void
-client_disconnect_cb(void *cls,
- struct GNUNET_SERVICE_Client *client,
- void *internal_cls)
+client_disconnect_cb (void *cls,
+ struct GNUNET_SERVICE_Client *client,
+ void *internal_cls)
{
struct ClientContext *cli_ctx = internal_cls;
- (void)cls;
- GNUNET_assert(client == cli_ctx->client);
+ (void) cls;
+ GNUNET_assert (client == cli_ctx->client);
if (NULL == client)
- {/* shutdown task - destroy all clients */
- while (NULL != cli_ctx_head)
- destroy_cli_ctx(cli_ctx_head);
- }
+ { /* shutdown task - destroy all clients */
+ while (NULL != cli_ctx_head)
+ destroy_cli_ctx (cli_ctx_head);
+ }
else
- { /* destroy this client */
- LOG(GNUNET_ERROR_TYPE_DEBUG,
- "Client disconnected. Destroy its context.\n");
- destroy_cli_ctx(cli_ctx);
- }
+ { /* destroy this client */
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Client disconnected. Destroy its context.\n");
+ destroy_cli_ctx (cli_ctx);
+ }
}
* @param service the initialized service
*/
static void
-run(void *cls,
- const struct GNUNET_CONFIGURATION_Handle *c,
- struct GNUNET_SERVICE_Handle *service)
+run (void *cls,
+ const struct GNUNET_CONFIGURATION_Handle *c,
+ struct GNUNET_SERVICE_Handle *service)
{
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;
+ (void) cls;
+ (void) service;
- GNUNET_log_setup("rps",
- GNUNET_error_type_to_string(GNUNET_ERROR_TYPE_DEBUG),
- NULL);
+ GNUNET_log_setup ("rps",
+ 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
- GNUNET_log(GNUNET_ERROR_TYPE_INFO,
- "STARTING SERVICE (rps) for peer [%s]\n",
- GNUNET_i2s(&own_identity));
+ GNUNET_CRYPTO_get_peer_identity (cfg,
+ &own_identity); // TODO check return value
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "STARTING SERVICE (rps) for peer [%s]\n",
+ GNUNET_i2s (&own_identity));
#if ENABLE_MALICIOUS
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
- "Malicious execution compiled in.\n");
+ 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))
- {
- GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR,
- "RPS", "ROUNDINTERVAL");
- GNUNET_SCHEDULER_shutdown();
- return;
- }
+ GNUNET_CONFIGURATION_get_value_time (cfg,
+ "RPS",
+ "ROUNDINTERVAL",
+ &round_interval))
+ {
+ GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+ "RPS", "ROUNDINTERVAL");
+ GNUNET_SCHEDULER_shutdown ();
+ return;
+ }
/* Get initial size of sampler/view from the configuration */
if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_number(cfg,
- "RPS",
- "MINSIZE",
- &sampler_size))
- {
- GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR,
- "RPS", "MINSIZE");
- GNUNET_SCHEDULER_shutdown();
- return;
- }
+ GNUNET_CONFIGURATION_get_value_number (cfg,
+ "RPS",
+ "MINSIZE",
+ &sampler_size))
+ {
+ GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+ "RPS", "MINSIZE");
+ GNUNET_SCHEDULER_shutdown ();
+ return;
+ }
- 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);
+ 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;
/* 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);
+ 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);
+ peerinfo_handle = GNUNET_PEERINFO_connect (cfg);
/* connect to NSE */
- nse = GNUNET_NSE_connect(cfg, nse_callback, NULL);
+ 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, msub);
+ // LOG (GNUNET_ERROR_TYPE_DEBUG, "Requesting peers from CADET\n");
+ // GNUNET_CADET_get_peers (cadet_handle, &init_peer_cb, msub);
// TODO send push/pull to each of those peers?
- LOG(GNUNET_ERROR_TYPE_DEBUG, "Requesting stored valid peers\n");
- restore_valid_peers(msub);
- get_valid_peers(msub->valid_peers, valid_peers_iterator, msub);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Requesting stored valid peers\n");
+ 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,
- msub);
+ peerinfo_notify_handle = GNUNET_PEERINFO_notify (cfg,
+ GNUNET_NO,
+ process_peerinfo_peers,
+ msub);
- LOG(GNUNET_ERROR_TYPE_INFO, "Ready to receive requests from clients\n");
+ LOG (GNUNET_ERROR_TYPE_INFO, "Ready to receive requests from clients\n");
- GNUNET_SCHEDULER_add_shutdown(&shutdown_task, NULL);
- stats = GNUNET_STATISTICS_create("rps", cfg);
+ GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
+ stats = GNUNET_STATISTICS_create ("rps", cfg);
}
&client_connect_cb,
&client_disconnect_cb,
NULL,
- GNUNET_MQ_hd_var_size(client_seed,
- GNUNET_MESSAGE_TYPE_RPS_CS_SEED,
- struct GNUNET_RPS_CS_SeedMessage,
- NULL),
+ GNUNET_MQ_hd_var_size (client_seed,
+ GNUNET_MESSAGE_TYPE_RPS_CS_SEED,
+ struct GNUNET_RPS_CS_SeedMessage,
+ NULL),
#if ENABLE_MALICIOUS
- GNUNET_MQ_hd_var_size(client_act_malicious,
- GNUNET_MESSAGE_TYPE_RPS_ACT_MALICIOUS,
- struct GNUNET_RPS_CS_ActMaliciousMessage,
- NULL),
+ GNUNET_MQ_hd_var_size (client_act_malicious,
+ GNUNET_MESSAGE_TYPE_RPS_ACT_MALICIOUS,
+ struct GNUNET_RPS_CS_ActMaliciousMessage,
+ NULL),
#endif /* ENABLE_MALICIOUS */
- GNUNET_MQ_hd_fixed_size(client_view_request,
- GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_REQUEST,
- struct GNUNET_RPS_CS_DEBUG_ViewRequest,
- NULL),
- GNUNET_MQ_hd_fixed_size(client_view_cancel,
- GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_CANCEL,
- struct GNUNET_MessageHeader,
- NULL),
- GNUNET_MQ_hd_fixed_size(client_stream_request,
- GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_STREAM_REQUEST,
- struct GNUNET_RPS_CS_DEBUG_StreamRequest,
- NULL),
- GNUNET_MQ_hd_fixed_size(client_stream_cancel,
- GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_STREAM_CANCEL,
- struct GNUNET_MessageHeader,
- NULL),
- GNUNET_MQ_hd_fixed_size(client_start_sub,
- GNUNET_MESSAGE_TYPE_RPS_CS_SUB_START,
- struct GNUNET_RPS_CS_SubStartMessage,
- NULL),
- GNUNET_MQ_hd_fixed_size(client_stop_sub,
- GNUNET_MESSAGE_TYPE_RPS_CS_SUB_STOP,
- struct GNUNET_RPS_CS_SubStopMessage,
- NULL),
- GNUNET_MQ_handler_end());
+ GNUNET_MQ_hd_fixed_size (client_view_request,
+ GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_REQUEST,
+ struct GNUNET_RPS_CS_DEBUG_ViewRequest,
+ NULL),
+ GNUNET_MQ_hd_fixed_size (client_view_cancel,
+ GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_CANCEL,
+ struct GNUNET_MessageHeader,
+ NULL),
+ GNUNET_MQ_hd_fixed_size (client_stream_request,
+ GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_STREAM_REQUEST,
+ struct GNUNET_RPS_CS_DEBUG_StreamRequest,
+ NULL),
+ GNUNET_MQ_hd_fixed_size (client_stream_cancel,
+ GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_STREAM_CANCEL,
+ struct GNUNET_MessageHeader,
+ NULL),
+ GNUNET_MQ_hd_fixed_size (client_start_sub,
+ GNUNET_MESSAGE_TYPE_RPS_CS_SUB_START,
+ struct GNUNET_RPS_CS_SubStartMessage,
+ NULL),
+ GNUNET_MQ_hd_fixed_size (client_stop_sub,
+ GNUNET_MESSAGE_TYPE_RPS_CS_SUB_STOP,
+ struct GNUNET_RPS_CS_SubStopMessage,
+ NULL),
+ GNUNET_MQ_handler_end ());
/* end of gnunet-service-rps.c */
projects / oweals / gnunet.git / blobdiff