From c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207 Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Sat, 5 Oct 2019 15:09:28 +0200 Subject: global reindent, now with uncrustify hook enabled --- src/rps/gnunet-service-rps.c | 4251 +++++++++++++++++++++--------------------- 1 file changed, 2148 insertions(+), 2103 deletions(-) (limited to 'src/rps/gnunet-service-rps.c') diff --git a/src/rps/gnunet-service-rps.c b/src/rps/gnunet-service-rps.c index 32f3103ed..66ffd173a 100644 --- a/src/rps/gnunet-service-rps.c +++ b/src/rps/gnunet-service-rps.c @@ -41,7 +41,7 @@ #include #include -#define LOG(kind, ...) GNUNET_log(kind, __VA_ARGS__) +#define LOG(kind, ...) GNUNET_log (kind, __VA_ARGS__) // TODO check for overflows @@ -92,7 +92,8 @@ * 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 */ @@ -110,7 +111,8 @@ struct PeerPendingOp { * 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 */ @@ -146,7 +148,8 @@ struct ChannelCtx; * 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. */ @@ -221,7 +224,8 @@ struct PeerContext { /** * @brief Closure to #valid_peer_iterator */ -struct PeersIteratorCls { +struct PeersIteratorCls +{ /** * Iterator function */ @@ -236,7 +240,8 @@ struct PeersIteratorCls { /** * @brief Context for a channel */ -struct ChannelCtx { +struct ChannelCtx +{ /** * @brief The channel itself */ @@ -261,7 +266,8 @@ struct ChannelCtx { /** * If type is 2 This struct is used to store the attacked peers in a DLL */ -struct AttackedPeer { +struct AttackedPeer +{ /** * DLL */ @@ -296,7 +302,8 @@ struct AttackedPeer { * 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. */ @@ -588,10 +595,10 @@ static const uint32_t num_valid_peers_max = UINT32_MAX; static void -do_round(void *cls); +do_round (void *cls); static void -do_mal_round(void *cls); +do_mal_round (void *cls); /** @@ -603,16 +610,16 @@ 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; } @@ -628,17 +635,17 @@ get_peer_ctx(const struct GNUNET_CONTAINER_MultiPeerMap *peer_map, * #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; + } } @@ -651,27 +658,27 @@ check_peer_known(const struct GNUNET_CONTAINER_MultiPeerMap *peer_map, * @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; } @@ -685,14 +692,14 @@ create_peer_ctx(struct Sub *sub, * @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); } @@ -707,25 +714,25 @@ create_or_get_peer_ctx(struct Sub *sub, * #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; } @@ -733,7 +740,8 @@ check_connected(struct PeerContext *peer_ctx) /** * @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. @@ -764,19 +772,19 @@ struct GetRandPeerIteratorCls { * #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; } @@ -791,19 +799,20 @@ get_rand_peer_iterator(void *cls, * @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; } @@ -820,8 +829,8 @@ get_random_peer_from_peermap(struct GNUNET_CONTAINER_MultiPeerMap *valid_peers) * #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; @@ -829,26 +838,26 @@ add_valid_peer(const struct GNUNET_PeerIdentity *peer, ret = GNUNET_YES; /* Remove random peers until there is space for a new one */ while (num_valid_peers_max <= - GNUNET_CONTAINER_multipeermap_size(valid_peers)) - { - 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 @@ -859,62 +868,62 @@ remove_pending_message(struct PendingMessage *pending_msg, int cancel); * @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 */ @@ -926,11 +935,11 @@ handle_peer_pull_reply(void *cls, * @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; } @@ -942,29 +951,29 @@ add_channel_ctx(struct PeerContext *peer_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; + } } @@ -975,47 +984,47 @@ remove_channel_ctx(struct ChannelCtx *channel_ctx) * @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; } @@ -1030,12 +1039,12 @@ get_channel(struct PeerContext *peer_ctx) * @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; } @@ -1048,19 +1057,19 @@ get_mq(struct PeerContext *peer_ctx) * @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; } @@ -1072,23 +1081,23 @@ insert_pending_message(struct PeerContext *peer_ctx, * @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); } @@ -1099,20 +1108,20 @@ remove_pending_message(struct PendingMessage *pending_msg, int cancel) * @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); + } } /** @@ -1121,30 +1130,30 @@ mq_online_check_successful(void *cls) * @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); + } } @@ -1161,8 +1170,8 @@ check_peer_online(struct PeerContext *peer_ctx) * #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; @@ -1179,20 +1188,20 @@ check_operation_scheduled(const struct PeerContext *peer_ctx, * @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); } @@ -1204,12 +1213,12 @@ destroy_channel(struct ChannelCtx *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); } @@ -1224,15 +1233,15 @@ destroy_channel_cb(void *cls) * @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); } @@ -1250,98 +1259,99 @@ schedule_channel_destruction(struct ChannelCtx *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; } @@ -1356,15 +1366,15 @@ destroy_peer(struct PeerContext *peer_ctx) * #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; } @@ -1377,32 +1387,33 @@ peermap_clear_iterator(void *cls, * @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); } @@ -1421,30 +1432,30 @@ mq_notify_sent_cb(void *cls) * #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; } @@ -1455,54 +1466,54 @@ store_peer_presistently_iterator(void *cls, * @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)); } @@ -1516,38 +1527,38 @@ store_valid_peers(const struct Sub *sub) * @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; } @@ -1558,7 +1569,7 @@ s2i_full(const char *string_repr) * @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; @@ -1569,53 +1580,53 @@ restore_valid_peers(const struct Sub *sub) 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)); } @@ -1625,22 +1636,22 @@ restore_valid_peers(const struct Sub *sub) * @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; } @@ -1656,15 +1667,15 @@ peers_terminate(struct Sub *sub) * #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); } @@ -1678,20 +1689,20 @@ valid_peer_iterator(void *cls, * #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; } @@ -1709,14 +1720,14 @@ get_valid_peers(struct GNUNET_CONTAINER_MultiPeerMap *valid_peers, * #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; } @@ -1733,18 +1744,18 @@ insert_peer(struct Sub *sub, * #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); } /** @@ -1758,19 +1769,19 @@ check_peer_flag(const struct GNUNET_CONTAINER_MultiPeerMap *peer_map, * #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; } @@ -1789,20 +1800,21 @@ issue_peer_online_check(struct Sub *sub, * #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; } @@ -1819,10 +1831,10 @@ check_removable(const struct PeerContext *peer_ctx) * #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); } @@ -1834,11 +1846,11 @@ check_peer_valid(const struct GNUNET_CONTAINER_MultiPeerMap *valid_peers, * @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); } @@ -1852,12 +1864,12 @@ indicate_sending_intention(struct PeerContext *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; } @@ -1873,36 +1885,36 @@ check_peer_send_intention(const struct PeerContext *peer_ctx) * (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; } @@ -1917,17 +1929,17 @@ handle_inbound_channel(void *cls, * #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; } @@ -1941,19 +1953,19 @@ check_sending_channel_exists(const struct PeerContext *peer_ctx) * #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; } @@ -1968,23 +1980,23 @@ destroy_sending_channel(struct PeerContext *peer_ctx) * @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); } /** @@ -2000,26 +2012,26 @@ send_message(struct PeerContext *peer_ctx, * #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; } @@ -2036,7 +2048,8 @@ schedule_operation(struct PeerContext *peer_ctx, * Closure used to pass the client and the id to the callback * that replies to a client's request */ -struct ReplyCls { +struct ReplyCls +{ /** * DLL */ @@ -2063,7 +2076,8 @@ struct ReplyCls { /** * Struct used to store the context of a connected client. */ -struct ClientContext { +struct ClientContext +{ /** * DLL */ @@ -2120,21 +2134,21 @@ struct ClientContext *cli_ctx_tail; * 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])); + } } @@ -2142,33 +2156,33 @@ print_peer_list(struct GNUNET_PeerIdentity *list, * 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; } @@ -2183,8 +2197,8 @@ rem_from_list(struct GNUNET_PeerIdentity **peer_list, * 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 @@ -2198,32 +2212,32 @@ insert_in_view_op(void *cls, * 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; } @@ -2236,33 +2250,33 @@ insert_in_view(struct Sub *sub, * @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); } @@ -2276,24 +2290,24 @@ send_view(const struct ClientContext *cli_ctx, * @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); } @@ -2303,46 +2317,46 @@ send_stream_peers(const struct ClientContext *cli_ctx, * @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); + } } @@ -2353,27 +2367,27 @@ clients_notify_view_update(const struct Sub *sub) * @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); } + } } @@ -2385,34 +2399,34 @@ clients_notify_stream_peer(const struct Sub *sub, * @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); } @@ -2426,22 +2440,22 @@ hist_update(const struct GNUNET_PeerIdentity *ids, * @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); } @@ -2453,33 +2467,33 @@ resize_wrapper(struct RPS_Sampler *sampler, uint32_t new_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); } + } } @@ -2491,17 +2505,17 @@ add_peer_array_to_set(const struct GNUNET_PeerIdentity *peer_array, * @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 @@ -2509,28 +2523,28 @@ send_pull_reply(struct PeerContext *peer_ctx, // 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? @@ -2547,12 +2561,12 @@ send_pull_reply(struct PeerContext *peer_ctx, * @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); } @@ -2566,17 +2580,17 @@ insert_in_pull_map(void *cls, * @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); + } } @@ -2588,30 +2602,30 @@ insert_in_view_op(void *cls, * @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 @@ -2620,17 +2634,17 @@ insert_in_sampler(void *cls, 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 */ } @@ -2647,24 +2661,24 @@ insert_in_sampler(void *cls, * @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); + } } @@ -2676,32 +2690,32 @@ got_peer(struct Sub *sub, * 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; } @@ -2714,26 +2728,26 @@ check_sending_channel_needed(const struct PeerContext *peer_ctx) * @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)); - } + } } @@ -2746,49 +2760,49 @@ remove_peer(struct Sub *sub, * @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; + } } @@ -2804,22 +2818,22 @@ clean_peer(struct Sub *sub, * @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); + } } /*********************************************************************** @@ -2843,119 +2857,119 @@ cleanup_destroyed_channel(void *cls, * @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; } @@ -2971,36 +2985,36 @@ new_sub(const struct GNUNET_HashCode *hash, * @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 */ @@ -3011,56 +3025,56 @@ write_histogram_to_file(const uint32_t hist_array[], * @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); } @@ -3080,13 +3094,13 @@ destroy_sub(struct Sub *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); } @@ -3099,18 +3113,18 @@ core_init(void *cls, * @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; } @@ -3124,14 +3138,14 @@ core_connects(void *cls, * @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); } /*********************************************************************** @@ -3145,18 +3159,18 @@ core_disconnects(void *cls, * @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); } @@ -3168,44 +3182,44 @@ destroy_cli_ctx(struct ClientContext *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); } @@ -3223,24 +3237,24 @@ adapt_sizes(struct Sub *sub, double logestimate, double std_dev) * @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); } + } } @@ -3254,24 +3268,24 @@ nse_callback(void *cls, * #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; } @@ -3283,34 +3297,34 @@ check_client_seed(void *cls, const struct GNUNET_RPS_CS_SeedMessage *msg) * @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); } @@ -3322,22 +3336,22 @@ handle_client_seed(void *cls, * 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); } @@ -3348,23 +3362,23 @@ handle_client_view_request(void *cls, * @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); + } } @@ -3375,19 +3389,20 @@ handle_client_view_cancel(void *cls, * @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); } @@ -3398,19 +3413,19 @@ handle_client_stream_request(void *cls, * @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); } @@ -3421,25 +3436,26 @@ handle_client_stream_cancel(void *cls, * @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); } @@ -3450,19 +3466,21 @@ handle_client_start_sub(void *cls, * @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); } @@ -3476,25 +3494,25 @@ handle_client_stop_sub(void *cls, * @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); } @@ -3508,70 +3526,70 @@ handle_peer_check(void *cls, * @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); } @@ -3584,57 +3602,58 @@ handle_peer_push(void *cls, * @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)); } @@ -3646,45 +3665,47 @@ handle_peer_pull_request(void *cls, * @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; } @@ -3696,8 +3717,8 @@ check_peer_pull_reply(void *cls, * @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; @@ -3710,94 +3731,96 @@ handle_peer_pull_reply(void *cls, #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); } @@ -3812,8 +3835,8 @@ handle_peer_pull_reply(void *cls, * @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; @@ -3821,30 +3844,32 @@ compute_rand_delay(struct GNUNET_TIME_Relative mean, 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; } @@ -3856,41 +3881,41 @@ compute_rand_delay(struct GNUNET_TIME_Relative mean, * @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); } + } } @@ -3900,32 +3925,32 @@ send_pull_request(struct PeerContext *peer_ctx) * @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); } + } } @@ -3941,25 +3966,25 @@ send_push(struct PeerContext *peer_ctx) * @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; } @@ -3971,8 +3996,9 @@ check_client_act_malicious(void *cls, * @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; @@ -3983,100 +4009,100 @@ handle_client_act_malicious(void *cls, 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); } @@ -4088,7 +4114,7 @@ handle_client_act_malicious(void *cls, * @param cls Closure - Sub */ static void -do_mal_round(void *cls) +do_mal_round (void *cls) { uint32_t num_pushes; uint32_t i; @@ -4096,119 +4122,119 @@ do_mal_round(void *cls) 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 */ @@ -4221,7 +4247,7 @@ do_mal_round(void *cls) * @param cls Closure - Sub */ static void -do_round(void *cls) +do_round (void *cls) { unsigned int i; const struct GNUNET_PeerIdentity *view_array; @@ -4235,308 +4261,327 @@ do_round(void *cls) 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"); } @@ -4556,26 +4601,26 @@ do_round(void *cls) * (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); + } } @@ -4591,18 +4636,18 @@ init_peer_cb(void *cls, * #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; } @@ -4616,23 +4661,23 @@ valid_peers_iterator(void *cls, * @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); + } } @@ -4642,69 +4687,69 @@ process_peerinfo_peers(void *cls, * @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 (); } @@ -4717,26 +4762,26 @@ shutdown_task(void *cls) * @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; } @@ -4748,25 +4793,25 @@ client_connect_cb(void *cls, * @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); + } } @@ -4778,68 +4823,68 @@ client_disconnect_cb(void *cls, * @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; @@ -4847,35 +4892,35 @@ run(void *cls, /* 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); } @@ -4889,40 +4934,40 @@ GNUNET_SERVICE_MAIN &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 */ -- cgit v1.2.3