2 This file is part of GNUnet.
3 Copyright (C) 2013-2015 GNUnet e.V.
5 GNUnet is free software: you can redistribute it and/or modify it
6 under the terms of the GNU Affero General Public License as published
7 by the Free Software Foundation, either version 3 of the License,
8 or (at your option) any later version.
10 GNUnet is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Affero General Public License for more details.
15 You should have received a copy of the GNU Affero General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>.
18 SPDX-License-Identifier: AGPL3.0-or-later
22 * @file rps/gnunet-service-rps.c
23 * @brief rps service implementation
24 * @author Julius Bünger
27 #include "gnunet_applications.h"
28 #include "gnunet_util_lib.h"
29 #include "gnunet_cadet_service.h"
30 #include "gnunet_core_service.h"
31 #include "gnunet_peerinfo_service.h"
32 #include "gnunet_nse_service.h"
33 #include "gnunet_statistics_service.h"
35 #include "rps-test_util.h"
36 #include "gnunet-service-rps_sampler.h"
37 #include "gnunet-service-rps_custommap.h"
38 #include "gnunet-service-rps_view.h"
44 #define LOG(kind, ...) GNUNET_log(kind, __VA_ARGS__)
46 // TODO check for overflows
48 // TODO align message structs
50 // TODO connect to friends
52 // TODO blacklist? (-> mal peer detection on top of brahms)
54 // hist_size_init, hist_size_max
56 /***********************************************************************
57 * Old gnunet-service-rps_peers.c
58 ***********************************************************************/
61 * Set a peer flag of given peer context.
63 #define SET_PEER_FLAG(peer_ctx, mask) ((peer_ctx->peer_flags) |= (mask))
66 * Get peer flag of given peer context.
68 #define check_peer_flag_set(peer_ctx, mask)\
69 ((peer_ctx->peer_flags) & (mask) ? GNUNET_YES : GNUNET_NO)
72 * Unset flag of given peer context.
74 #define UNSET_PEER_FLAG(peer_ctx, mask) ((peer_ctx->peer_flags) &= ~(mask))
77 * Get channel flag of given channel context.
79 #define check_channel_flag_set(channel_flags, mask)\
80 ((*channel_flags) & (mask) ? GNUNET_YES : GNUNET_NO)
83 * Unset flag of given channel context.
85 #define unset_channel_flag(channel_flags, mask) ((*channel_flags) &= ~(mask))
90 * Pending operation on peer consisting of callback and closure
92 * When an operation cannot be executed right now this struct is used to store
93 * the callback and closure for later execution.
109 * List containing all messages that are yet to be send
111 * This is used to keep track of all messages that have not been sent yet. When
112 * a peer is to be removed the pending messages can be removed properly.
114 struct PendingMessage
119 struct PendingMessage *next;
120 struct PendingMessage *prev;
123 * The envelope to the corresponding message
125 struct GNUNET_MQ_Envelope *ev;
128 * The corresponding context
130 struct PeerContext *peer_ctx;
139 * @brief Context for a channel
144 * Struct used to keep track of other peer's status
146 * This is stored in a multipeermap.
147 * It contains information such as cadet channels, a message queue for sending,
148 * status about the channels, the pending operations on this peer and some flags
149 * about the status of the peer itself. (online, valid, ...)
154 * The Sub this context belongs to.
159 * Message queue open to client
161 struct GNUNET_MQ_Handle *mq;
164 * Channel open to client.
166 struct ChannelCtx *send_channel_ctx;
169 * Channel open from client.
171 struct ChannelCtx *recv_channel_ctx;
174 * Array of pending operations on this peer.
176 struct PeerPendingOp *pending_ops;
179 * Handle to the callback given to cadet_ntfy_tmt_rdy()
181 * To be canceled on shutdown.
183 struct PendingMessage *online_check_pending;
186 * Number of pending operations.
188 unsigned int num_pending_ops;
191 * Identity of the peer
193 struct GNUNET_PeerIdentity peer_id;
196 * Flags indicating status of peer
201 * Last time we received something from that peer.
203 struct GNUNET_TIME_Absolute last_message_recv;
206 * Last time we received a keepalive message.
208 struct GNUNET_TIME_Absolute last_keepalive;
211 * DLL with all messages that are yet to be sent
213 struct PendingMessage *pending_messages_head;
214 struct PendingMessage *pending_messages_tail;
217 * This is pobably followed by 'statistical' data (when we first saw
218 * it, how did we get its ID, how many pushes (in a timeinterval),
221 uint32_t round_pull_req;
225 * @brief Closure to #valid_peer_iterator
227 struct PeersIteratorCls
232 PeersIterator iterator;
235 * Closure to iterator
241 * @brief Context for a channel
246 * @brief The channel itself
248 struct GNUNET_CADET_Channel *channel;
251 * @brief The peer context associated with the channel
253 struct PeerContext *peer_ctx;
256 * @brief When channel destruction needs to be delayed (because it is called
257 * from within the cadet routine of another channel destruction) this task
258 * refers to the respective _SCHEDULER_Task.
260 struct GNUNET_SCHEDULER_Task *destruction_task;
267 * If type is 2 This struct is used to store the attacked peers in a DLL
274 struct AttackedPeer *next;
275 struct AttackedPeer *prev;
280 struct GNUNET_PeerIdentity peer_id;
283 #endif /* ENABLE_MALICIOUS */
286 * @brief This number determines the number of slots for files that represent
289 #define HISTOGRAM_FILE_SLOTS 32
292 * @brief The size (in bytes) a file needs to store the histogram
294 * Per slot: 1 newline, up to 4 chars,
295 * Additionally: 1 null termination
297 #define SIZE_DUMP_FILE (HISTOGRAM_FILE_SLOTS * 5) + 1
302 * Essentially one instance of brahms that only connects to other instances
303 * with the same (secret) value.
308 * @brief Hash of the shared value that defines Subs.
310 struct GNUNET_HashCode hash;
313 * @brief Port to communicate to other peers.
315 struct GNUNET_CADET_Port *cadet_port;
318 * @brief Hashmap of valid peers.
320 struct GNUNET_CONTAINER_MultiPeerMap *valid_peers;
323 * @brief Filename of the file that stores the valid peers persistently.
325 char *filename_valid_peers;
328 * Set of all peers to keep track of them.
330 struct GNUNET_CONTAINER_MultiPeerMap *peer_map;
333 * @brief This is the minimum estimate used as sampler size.
335 * It is configured by the user.
337 unsigned int sampler_size_est_min;
340 * The size of sampler we need to be able to satisfy the Brahms protocol's
341 * need of random peers.
343 * This is one minimum size the sampler grows to.
345 unsigned int sampler_size_est_need;
348 * Time interval the do_round task runs in.
350 struct GNUNET_TIME_Relative round_interval;
353 * Sampler used for the Brahms protocol itself.
355 struct RPS_Sampler *sampler;
359 * Name to log view to
361 char *file_name_view_log;
362 #endif /* TO_FILE_FULL */
367 * Name to log number of observed peers to
369 char *file_name_observed_log;
370 #endif /* TO_FILE_FULL */
373 * @brief Count the observed peers
375 uint32_t num_observed_peers;
378 * @brief Multipeermap (ab-) used to count unique peer_ids
380 struct GNUNET_CONTAINER_MultiPeerMap *observed_unique_peers;
384 * List to store peers received through pushes temporary.
386 struct CustomPeerMap *push_map;
389 * List to store peers received through pulls temporary.
391 struct CustomPeerMap *pull_map;
394 * @brief This is the estimate used as view size.
396 * It is initialised with the minimum
398 unsigned int view_size_est_need;
401 * @brief This is the minimum estimate used as view size.
403 * It is configured by the user.
405 unsigned int view_size_est_min;
413 * Identifier for the main task that runs periodically.
415 struct GNUNET_SCHEDULER_Task *do_round_task;
420 * @brief Counts the executed rounds.
425 * @brief This array accumulates the number of received pushes per round.
427 * Number at index i represents the number of rounds with i observed pushes.
429 uint32_t push_recv[HISTOGRAM_FILE_SLOTS];
432 * @brief Histogram of deltas between the expected and actual number of
435 * As half of the entries are expected to be negative, this is shifted by
436 * #HISTOGRAM_FILE_SLOTS/2.
438 uint32_t push_delta[HISTOGRAM_FILE_SLOTS];
441 * @brief Number of pull replies with this delay measured in rounds.
443 * Number at index i represents the number of pull replies with a delay of i
446 uint32_t pull_delays[HISTOGRAM_FILE_SLOTS];
450 /***********************************************************************
452 ***********************************************************************/
457 static const struct GNUNET_CONFIGURATION_Handle *cfg;
460 * Handle to the statistics service.
462 struct GNUNET_STATISTICS_Handle *stats;
467 struct GNUNET_CADET_Handle *cadet_handle;
472 struct GNUNET_CORE_Handle *core_handle;
475 * @brief PeerMap to keep track of connected peers.
477 struct GNUNET_CONTAINER_MultiPeerMap *map_single_hop;
482 static struct GNUNET_PeerIdentity own_identity;
485 * Percentage of total peer number in the view
486 * to send random PUSHes to
491 * Percentage of total peer number in the view
492 * to send random PULLs to
499 static struct GNUNET_NSE_Handle *nse;
502 * Handler to PEERINFO.
504 static struct GNUNET_PEERINFO_Handle *peerinfo_handle;
507 * Handle for cancellation of iteration over peers.
509 static struct GNUNET_PEERINFO_NotifyContext *peerinfo_notify_handle;
514 * Type of malicious peer
516 * 0 Don't act malicious at all - Default
517 * 1 Try to maximise representation
518 * 2 Try to partition the network
521 static uint32_t mal_type;
524 * Other malicious peers
526 static struct GNUNET_PeerIdentity *mal_peers;
529 * Hashmap of malicious peers used as set.
530 * Used to more efficiently check whether we know that peer.
532 static struct GNUNET_CONTAINER_MultiPeerMap *mal_peer_set;
535 * Number of other malicious peers
537 static uint32_t num_mal_peers;
541 * If type is 2 this is the DLL of attacked peers
543 static struct AttackedPeer *att_peers_head;
544 static struct AttackedPeer *att_peers_tail;
547 * This index is used to point to an attacked peer to
548 * implement the round-robin-ish way to select attacked peers.
550 static struct AttackedPeer *att_peer_index;
553 * Hashmap of attacked peers used as set.
554 * Used to more efficiently check whether we know that peer.
556 static struct GNUNET_CONTAINER_MultiPeerMap *att_peer_set;
559 * Number of attacked peers
561 static uint32_t num_attacked_peers;
564 * If type is 1 this is the attacked peer
566 static struct GNUNET_PeerIdentity attacked_peer;
569 * The limit of PUSHes we can send in one round.
570 * This is an assumption of the Brahms protocol and either implemented
573 * assumend to be the bandwidth limitation.
575 static uint32_t push_limit = 10000;
576 #endif /* ENABLE_MALICIOUS */
581 * This is run in any case by all peers and connects to all peers without
582 * specifying a shared value.
584 static struct Sub *msub;
587 * @brief Maximum number of valid peers to keep.
588 * TODO read from config
590 static const uint32_t num_valid_peers_max = UINT32_MAX;
592 /***********************************************************************
594 ***********************************************************************/
598 do_round (void *cls);
601 do_mal_round (void *cls);
605 * @brief Get the #PeerContext associated with a peer
607 * @param peer_map The peer map containing the context
608 * @param peer the peer id
610 * @return the #PeerContext
612 static struct PeerContext *
613 get_peer_ctx (const struct GNUNET_CONTAINER_MultiPeerMap *peer_map,
614 const struct GNUNET_PeerIdentity *peer)
616 struct PeerContext *ctx;
619 ret = GNUNET_CONTAINER_multipeermap_contains (peer_map, peer);
620 GNUNET_assert (GNUNET_YES == ret);
621 ctx = GNUNET_CONTAINER_multipeermap_get (peer_map, peer);
622 GNUNET_assert (NULL != ctx);
627 * @brief Check whether we have information about the given peer.
629 * FIXME probably deprecated. Make this the new _online.
631 * @param peer_map The peer map to check for the existence of @a peer
632 * @param peer peer in question
634 * @return #GNUNET_YES if peer is known
635 * #GNUNET_NO if peer is not knwon
638 check_peer_known (const struct GNUNET_CONTAINER_MultiPeerMap *peer_map,
639 const struct GNUNET_PeerIdentity *peer)
641 if (NULL != peer_map)
643 return GNUNET_CONTAINER_multipeermap_contains (peer_map, peer);
653 * @brief Create a new #PeerContext and insert it into the peer map
655 * @param sub The Sub this context belongs to.
656 * @param peer the peer to create the #PeerContext for
658 * @return the #PeerContext
660 static struct PeerContext *
661 create_peer_ctx (struct Sub *sub,
662 const struct GNUNET_PeerIdentity *peer)
664 struct PeerContext *ctx;
667 GNUNET_assert (GNUNET_NO == check_peer_known (sub->peer_map, peer));
669 ctx = GNUNET_new (struct PeerContext);
670 ctx->peer_id = *peer;
672 ret = GNUNET_CONTAINER_multipeermap_put (sub->peer_map, peer, ctx,
673 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
674 GNUNET_assert (GNUNET_OK == ret);
677 GNUNET_STATISTICS_set (stats,
679 GNUNET_CONTAINER_multipeermap_size (sub->peer_map),
687 * @brief Create or get a #PeerContext
689 * @param sub The Sub to which the created context belongs to
690 * @param peer the peer to get the associated context to
692 * @return the context
694 static struct PeerContext *
695 create_or_get_peer_ctx (struct Sub *sub,
696 const struct GNUNET_PeerIdentity *peer)
698 if (GNUNET_NO == check_peer_known (sub->peer_map, peer))
700 return create_peer_ctx (sub, peer);
702 return get_peer_ctx (sub->peer_map, peer);
707 * @brief Check whether we have a connection to this @a peer
709 * Also sets the #Peers_ONLINE flag accordingly
711 * @param peer_ctx Context of the peer of which connectivity is to be checked
713 * @return #GNUNET_YES if we are connected
714 * #GNUNET_NO otherwise
717 check_connected (struct PeerContext *peer_ctx)
719 /* If we don't know about this peer we don't know whether it's online */
720 if (GNUNET_NO == check_peer_known (peer_ctx->sub->peer_map,
725 /* Get the context */
726 peer_ctx = get_peer_ctx (peer_ctx->sub->peer_map, &peer_ctx->peer_id);
727 /* If we have no channel to this peer we don't know whether it's online */
728 if ( (NULL == peer_ctx->send_channel_ctx) &&
729 (NULL == peer_ctx->recv_channel_ctx) )
731 UNSET_PEER_FLAG (peer_ctx, Peers_ONLINE);
734 /* Otherwise (if we have a channel, we know that it's online */
735 SET_PEER_FLAG (peer_ctx, Peers_ONLINE);
741 * @brief The closure to #get_rand_peer_iterator.
743 struct GetRandPeerIteratorCls
746 * @brief The index of the peer to return.
747 * Will be decreased until 0.
748 * Then current peer is returned.
753 * @brief Pointer to peer to return.
755 const struct GNUNET_PeerIdentity *peer;
760 * @brief Iterator function for #get_random_peer_from_peermap.
762 * Implements #GNUNET_CONTAINER_PeerMapIterator.
763 * Decreases the index until the index is null.
764 * Then returns the current peer.
766 * @param cls the #GetRandPeerIteratorCls containing index and peer
767 * @param peer current peer
768 * @param value unused
770 * @return #GNUNET_YES if we should continue to
775 get_rand_peer_iterator (void *cls,
776 const struct GNUNET_PeerIdentity *peer,
779 struct GetRandPeerIteratorCls *iterator_cls = cls;
782 if (0 >= iterator_cls->index)
784 iterator_cls->peer = peer;
787 iterator_cls->index--;
793 * @brief Get a random peer from @a peer_map
795 * @param valid_peers Peer map containing valid peers from which to select a
798 * @return a random peer
800 static const struct GNUNET_PeerIdentity *
801 get_random_peer_from_peermap (struct GNUNET_CONTAINER_MultiPeerMap *valid_peers)
803 struct GetRandPeerIteratorCls *iterator_cls;
804 const struct GNUNET_PeerIdentity *ret;
806 iterator_cls = GNUNET_new (struct GetRandPeerIteratorCls);
807 iterator_cls->index = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
808 GNUNET_CONTAINER_multipeermap_size (valid_peers));
809 (void) GNUNET_CONTAINER_multipeermap_iterate (valid_peers,
810 get_rand_peer_iterator,
812 ret = iterator_cls->peer;
813 GNUNET_free (iterator_cls);
819 * @brief Add a given @a peer to valid peers.
821 * If valid peers are already #num_valid_peers_max, delete a peer previously.
823 * @param peer The peer that is added to the valid peers.
824 * @param valid_peers Peer map of valid peers to which to add the @a peer
826 * @return #GNUNET_YES if no other peer had to be removed
827 * #GNUNET_NO otherwise
830 add_valid_peer (const struct GNUNET_PeerIdentity *peer,
831 struct GNUNET_CONTAINER_MultiPeerMap *valid_peers)
833 const struct GNUNET_PeerIdentity *rand_peer;
837 /* Remove random peers until there is space for a new one */
838 while (num_valid_peers_max <=
839 GNUNET_CONTAINER_multipeermap_size (valid_peers))
841 rand_peer = get_random_peer_from_peermap (valid_peers);
842 GNUNET_CONTAINER_multipeermap_remove_all (valid_peers, rand_peer);
845 (void) GNUNET_CONTAINER_multipeermap_put (valid_peers, peer, NULL,
846 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
847 if (valid_peers == msub->valid_peers)
849 GNUNET_STATISTICS_set (stats,
851 GNUNET_CONTAINER_multipeermap_size (valid_peers),
858 remove_pending_message (struct PendingMessage *pending_msg, int cancel);
861 * @brief Set the peer flag to living and
862 * call the pending operations on this peer.
864 * Also adds peer to #valid_peers.
866 * @param peer_ctx the #PeerContext of the peer to set online
869 set_peer_online (struct PeerContext *peer_ctx)
871 struct GNUNET_PeerIdentity *peer;
874 peer = &peer_ctx->peer_id;
875 LOG (GNUNET_ERROR_TYPE_DEBUG,
876 "Peer %s is online and valid, calling %i pending operations on it\n",
878 peer_ctx->num_pending_ops);
880 if (NULL != peer_ctx->online_check_pending)
882 LOG (GNUNET_ERROR_TYPE_DEBUG,
883 "Removing pending online check for peer %s\n",
884 GNUNET_i2s (&peer_ctx->peer_id));
885 // TODO wait until cadet sets mq->cancel_impl
886 //GNUNET_MQ_send_cancel (peer_ctx->online_check_pending->ev);
887 remove_pending_message (peer_ctx->online_check_pending, GNUNET_YES);
888 peer_ctx->online_check_pending = NULL;
891 SET_PEER_FLAG (peer_ctx, Peers_ONLINE);
893 /* Call pending operations */
894 for (i = 0; i < peer_ctx->num_pending_ops; i++)
896 peer_ctx->pending_ops[i].op (peer_ctx->pending_ops[i].op_cls, peer);
898 GNUNET_array_grow (peer_ctx->pending_ops, peer_ctx->num_pending_ops, 0);
902 cleanup_destroyed_channel (void *cls,
903 const struct GNUNET_CADET_Channel *channel);
905 /* Declaration of handlers */
907 handle_peer_check (void *cls,
908 const struct GNUNET_MessageHeader *msg);
911 handle_peer_push (void *cls,
912 const struct GNUNET_MessageHeader *msg);
915 handle_peer_pull_request (void *cls,
916 const struct GNUNET_MessageHeader *msg);
919 check_peer_pull_reply (void *cls,
920 const struct GNUNET_RPS_P2P_PullReplyMessage *msg);
923 handle_peer_pull_reply (void *cls,
924 const struct GNUNET_RPS_P2P_PullReplyMessage *msg);
926 /* End declaration of handlers */
929 * @brief Allocate memory for a new channel context and insert it into DLL
931 * @param peer_ctx context of the according peer
933 * @return The channel context
935 static struct ChannelCtx *
936 add_channel_ctx (struct PeerContext *peer_ctx)
938 struct ChannelCtx *channel_ctx;
939 channel_ctx = GNUNET_new (struct ChannelCtx);
940 channel_ctx->peer_ctx = peer_ctx;
946 * @brief Free memory and NULL pointers.
948 * @param channel_ctx The channel context.
951 remove_channel_ctx (struct ChannelCtx *channel_ctx)
953 struct PeerContext *peer_ctx = channel_ctx->peer_ctx;
955 if (NULL != channel_ctx->destruction_task)
957 GNUNET_SCHEDULER_cancel (channel_ctx->destruction_task);
958 channel_ctx->destruction_task = NULL;
961 GNUNET_free (channel_ctx);
963 if (NULL == peer_ctx) return;
964 if (channel_ctx == peer_ctx->send_channel_ctx)
966 peer_ctx->send_channel_ctx = NULL;
969 else if (channel_ctx == peer_ctx->recv_channel_ctx)
971 peer_ctx->recv_channel_ctx = NULL;
977 * @brief Get the channel of a peer. If not existing, create.
979 * @param peer_ctx Context of the peer of which to get the channel
980 * @return the #GNUNET_CADET_Channel used to send data to @a peer_ctx
982 struct GNUNET_CADET_Channel *
983 get_channel (struct PeerContext *peer_ctx)
985 /* There exists a copy-paste-clone in run() */
986 struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
987 GNUNET_MQ_hd_fixed_size (peer_check,
988 GNUNET_MESSAGE_TYPE_RPS_PP_CHECK_LIVE,
989 struct GNUNET_MessageHeader,
991 GNUNET_MQ_hd_fixed_size (peer_push,
992 GNUNET_MESSAGE_TYPE_RPS_PP_PUSH,
993 struct GNUNET_MessageHeader,
995 GNUNET_MQ_hd_fixed_size (peer_pull_request,
996 GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REQUEST,
997 struct GNUNET_MessageHeader,
999 GNUNET_MQ_hd_var_size (peer_pull_reply,
1000 GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REPLY,
1001 struct GNUNET_RPS_P2P_PullReplyMessage,
1003 GNUNET_MQ_handler_end ()
1007 if (NULL == peer_ctx->send_channel_ctx)
1009 LOG (GNUNET_ERROR_TYPE_DEBUG,
1010 "Trying to establish channel to peer %s\n",
1011 GNUNET_i2s (&peer_ctx->peer_id));
1012 peer_ctx->send_channel_ctx = add_channel_ctx (peer_ctx);
1013 peer_ctx->send_channel_ctx->channel =
1014 GNUNET_CADET_channel_create (cadet_handle,
1015 peer_ctx->send_channel_ctx, /* context */
1017 &peer_ctx->sub->hash,
1018 NULL, /* WindowSize handler */
1019 &cleanup_destroyed_channel, /* Disconnect handler */
1022 GNUNET_assert (NULL != peer_ctx->send_channel_ctx);
1023 GNUNET_assert (NULL != peer_ctx->send_channel_ctx->channel);
1024 return peer_ctx->send_channel_ctx->channel;
1029 * Get the message queue (#GNUNET_MQ_Handle) of a specific peer.
1031 * If we already have a message queue open to this client,
1032 * simply return it, otherways create one.
1034 * @param peer_ctx Context of the peer of whicht to get the mq
1035 * @return the #GNUNET_MQ_Handle
1037 static struct GNUNET_MQ_Handle *
1038 get_mq (struct PeerContext *peer_ctx)
1040 if (NULL == peer_ctx->mq)
1042 peer_ctx->mq = GNUNET_CADET_get_mq (get_channel (peer_ctx));
1044 return peer_ctx->mq;
1048 * @brief Add an envelope to a message passed to mq to list of pending messages
1050 * @param peer_ctx Context of the peer for which to insert the envelope
1051 * @param ev envelope to the message
1052 * @param type type of the message to be sent
1053 * @return pointer to pending message
1055 static struct PendingMessage *
1056 insert_pending_message (struct PeerContext *peer_ctx,
1057 struct GNUNET_MQ_Envelope *ev,
1060 struct PendingMessage *pending_msg;
1062 pending_msg = GNUNET_new (struct PendingMessage);
1063 pending_msg->ev = ev;
1064 pending_msg->peer_ctx = peer_ctx;
1065 pending_msg->type = type;
1066 GNUNET_CONTAINER_DLL_insert (peer_ctx->pending_messages_head,
1067 peer_ctx->pending_messages_tail,
1074 * @brief Remove a pending message from the respective DLL
1076 * @param pending_msg the pending message to remove
1077 * @param cancel whether to cancel the pending message, too
1080 remove_pending_message (struct PendingMessage *pending_msg, int cancel)
1082 struct PeerContext *peer_ctx;
1085 peer_ctx = pending_msg->peer_ctx;
1086 GNUNET_assert (NULL != peer_ctx);
1087 GNUNET_CONTAINER_DLL_remove (peer_ctx->pending_messages_head,
1088 peer_ctx->pending_messages_tail,
1090 // TODO wait for the cadet implementation of message cancellation
1091 //if (GNUNET_YES == cancel)
1093 // GNUNET_MQ_send_cancel (pending_msg->ev);
1095 GNUNET_free (pending_msg);
1100 * @brief This is called in response to the first message we sent as a
1103 * @param cls #PeerContext of peer with pending online check
1106 mq_online_check_successful (void *cls)
1108 struct PeerContext *peer_ctx = cls;
1110 if (NULL != peer_ctx->online_check_pending)
1112 LOG (GNUNET_ERROR_TYPE_DEBUG,
1113 "Online check for peer %s was successfull\n",
1114 GNUNET_i2s (&peer_ctx->peer_id));
1115 remove_pending_message (peer_ctx->online_check_pending, GNUNET_YES);
1116 peer_ctx->online_check_pending = NULL;
1117 set_peer_online (peer_ctx);
1118 (void) add_valid_peer (&peer_ctx->peer_id, peer_ctx->sub->valid_peers);
1123 * Issue a check whether peer is online
1125 * @param peer_ctx the context of the peer
1128 check_peer_online (struct PeerContext *peer_ctx)
1130 LOG (GNUNET_ERROR_TYPE_DEBUG,
1131 "Get informed about peer %s getting online\n",
1132 GNUNET_i2s (&peer_ctx->peer_id));
1134 struct GNUNET_MQ_Handle *mq;
1135 struct GNUNET_MQ_Envelope *ev;
1137 ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_RPS_PP_CHECK_LIVE);
1138 peer_ctx->online_check_pending =
1139 insert_pending_message (peer_ctx, ev, "Check online");
1140 mq = get_mq (peer_ctx);
1141 GNUNET_MQ_notify_sent (ev,
1142 mq_online_check_successful,
1144 GNUNET_MQ_send (mq, ev);
1145 if (peer_ctx->sub == msub)
1147 GNUNET_STATISTICS_update (stats,
1148 "# pending online checks",
1156 * @brief Check whether function of type #PeerOp was already scheduled
1158 * The array with pending operations will probably never grow really big, so
1159 * iterating over it should be ok.
1161 * @param peer_ctx Context of the peer to check for the operation
1162 * @param peer_op the operation (#PeerOp) on the peer
1164 * @return #GNUNET_YES if this operation is scheduled on that peer
1165 * #GNUNET_NO otherwise
1168 check_operation_scheduled (const struct PeerContext *peer_ctx,
1169 const PeerOp peer_op)
1173 for (i = 0; i < peer_ctx->num_pending_ops; i++)
1174 if (peer_op == peer_ctx->pending_ops[i].op)
1181 * @brief Callback for scheduler to destroy a channel
1183 * @param cls Context of the channel
1186 destroy_channel (struct ChannelCtx *channel_ctx)
1188 struct GNUNET_CADET_Channel *channel;
1190 if (NULL != channel_ctx->destruction_task)
1192 GNUNET_SCHEDULER_cancel (channel_ctx->destruction_task);
1193 channel_ctx->destruction_task = NULL;
1195 GNUNET_assert (channel_ctx->channel != NULL);
1196 channel = channel_ctx->channel;
1197 channel_ctx->channel = NULL;
1198 GNUNET_CADET_channel_destroy (channel);
1199 remove_channel_ctx (channel_ctx);
1204 * @brief Destroy a cadet channel.
1206 * This satisfies the function signature of #GNUNET_SCHEDULER_TaskCallback.
1211 destroy_channel_cb (void *cls)
1213 struct ChannelCtx *channel_ctx = cls;
1215 channel_ctx->destruction_task = NULL;
1216 destroy_channel (channel_ctx);
1221 * @brief Schedule the destruction of a channel for immediately afterwards.
1223 * In case a channel is to be destroyed from within the callback to the
1224 * destruction of another channel (send channel), we cannot call
1225 * GNUNET_CADET_channel_destroy directly, but need to use this scheduling
1228 * @param channel_ctx channel to be destroyed.
1231 schedule_channel_destruction (struct ChannelCtx *channel_ctx)
1233 GNUNET_assert (NULL ==
1234 channel_ctx->destruction_task);
1235 GNUNET_assert (NULL !=
1236 channel_ctx->channel);
1237 channel_ctx->destruction_task =
1238 GNUNET_SCHEDULER_add_now (&destroy_channel_cb,
1244 * @brief Remove peer
1246 * - Empties the list with pending operations
1247 * - Empties the list with pending messages
1248 * - Cancels potentially existing online check
1249 * - Schedules closing of send and recv channels
1250 * - Removes peer from peer map
1252 * @param peer_ctx Context of the peer to be destroyed
1253 * @return #GNUNET_YES if peer was removed
1254 * #GNUNET_NO otherwise
1257 destroy_peer (struct PeerContext *peer_ctx)
1259 GNUNET_assert (NULL != peer_ctx);
1260 GNUNET_assert (NULL != peer_ctx->sub->peer_map);
1262 GNUNET_CONTAINER_multipeermap_contains (peer_ctx->sub->peer_map,
1263 &peer_ctx->peer_id))
1267 SET_PEER_FLAG (peer_ctx, Peers_TO_DESTROY);
1268 LOG (GNUNET_ERROR_TYPE_DEBUG,
1269 "Going to remove peer %s\n",
1270 GNUNET_i2s (&peer_ctx->peer_id));
1271 UNSET_PEER_FLAG (peer_ctx, Peers_ONLINE);
1273 /* Clear list of pending operations */
1274 // TODO this probably leaks memory
1275 // ('only' the cls to the function. Not sure what to do with it)
1276 GNUNET_array_grow (peer_ctx->pending_ops,
1277 peer_ctx->num_pending_ops,
1279 /* Remove all pending messages */
1280 while (NULL != peer_ctx->pending_messages_head)
1282 LOG (GNUNET_ERROR_TYPE_DEBUG,
1283 "Removing unsent %s\n",
1284 peer_ctx->pending_messages_head->type);
1285 /* Cancle pending message, too */
1286 if ( (NULL != peer_ctx->online_check_pending) &&
1287 (0 == memcmp (peer_ctx->pending_messages_head,
1288 peer_ctx->online_check_pending,
1289 sizeof (struct PendingMessage))) )
1291 peer_ctx->online_check_pending = NULL;
1292 if (peer_ctx->sub == msub)
1294 GNUNET_STATISTICS_update (stats,
1295 "# pending online checks",
1300 remove_pending_message (peer_ctx->pending_messages_head,
1304 /* If we are still waiting for notification whether this peer is online
1305 * cancel the according task */
1306 if (NULL != peer_ctx->online_check_pending)
1308 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1309 "Removing pending online check for peer %s\n",
1310 GNUNET_i2s (&peer_ctx->peer_id));
1311 // TODO wait until cadet sets mq->cancel_impl
1312 //GNUNET_MQ_send_cancel (peer_ctx->online_check_pending->ev);
1313 remove_pending_message (peer_ctx->online_check_pending,
1315 peer_ctx->online_check_pending = NULL;
1318 if (NULL != peer_ctx->send_channel_ctx)
1320 /* This is possibly called from within channel destruction */
1321 peer_ctx->send_channel_ctx->peer_ctx = NULL;
1322 schedule_channel_destruction (peer_ctx->send_channel_ctx);
1323 peer_ctx->send_channel_ctx = NULL;
1324 peer_ctx->mq = NULL;
1326 if (NULL != peer_ctx->recv_channel_ctx)
1328 /* This is possibly called from within channel destruction */
1329 peer_ctx->recv_channel_ctx->peer_ctx = NULL;
1330 schedule_channel_destruction (peer_ctx->recv_channel_ctx);
1331 peer_ctx->recv_channel_ctx = NULL;
1335 GNUNET_CONTAINER_multipeermap_remove_all (peer_ctx->sub->peer_map,
1336 &peer_ctx->peer_id))
1338 LOG (GNUNET_ERROR_TYPE_WARNING,
1339 "removing peer from peer_ctx->sub->peer_map failed\n");
1341 if (peer_ctx->sub == msub)
1343 GNUNET_STATISTICS_set (stats,
1345 GNUNET_CONTAINER_multipeermap_size (peer_ctx->sub->peer_map),
1348 GNUNET_free (peer_ctx);
1354 * Iterator over hash map entries. Deletes all contexts of peers.
1356 * @param cls closure
1357 * @param key current public key
1358 * @param value value in the hash map
1359 * @return #GNUNET_YES if we should continue to iterate,
1360 * #GNUNET_NO if not.
1363 peermap_clear_iterator (void *cls,
1364 const struct GNUNET_PeerIdentity *key,
1367 struct Sub *sub = cls;
1370 destroy_peer (get_peer_ctx (sub->peer_map, key));
1376 * @brief This is called once a message is sent.
1378 * Removes the pending message
1380 * @param cls type of the message that was sent
1383 mq_notify_sent_cb (void *cls)
1385 struct PendingMessage *pending_msg = (struct PendingMessage *) cls;
1386 LOG (GNUNET_ERROR_TYPE_DEBUG,
1389 if (pending_msg->peer_ctx->sub == msub)
1391 if (0 == strncmp ("PULL REPLY", pending_msg->type, 10))
1392 GNUNET_STATISTICS_update(stats, "# pull replys sent", 1, GNUNET_NO);
1393 if (0 == strncmp ("PULL REQUEST", pending_msg->type, 12))
1394 GNUNET_STATISTICS_update(stats, "# pull requests sent", 1, GNUNET_NO);
1395 if (0 == strncmp ("PUSH", pending_msg->type, 4))
1396 GNUNET_STATISTICS_update(stats, "# pushes sent", 1, GNUNET_NO);
1397 if (0 == strncmp ("PULL REQUEST", pending_msg->type, 12) &&
1398 NULL != map_single_hop &&
1399 GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (map_single_hop,
1400 &pending_msg->peer_ctx->peer_id))
1401 GNUNET_STATISTICS_update(stats,
1402 "# pull requests sent (multi-hop peer)",
1406 /* Do not cancle message */
1407 remove_pending_message (pending_msg, GNUNET_NO);
1412 * @brief Iterator function for #store_valid_peers.
1414 * Implements #GNUNET_CONTAINER_PeerMapIterator.
1415 * Writes single peer to disk.
1417 * @param cls the file handle to write to.
1418 * @param peer current peer
1419 * @param value unused
1421 * @return #GNUNET_YES if we should continue to
1423 * #GNUNET_NO if not.
1426 store_peer_presistently_iterator (void *cls,
1427 const struct GNUNET_PeerIdentity *peer,
1430 const struct GNUNET_DISK_FileHandle *fh = cls;
1431 char peer_string[128];
1440 size = GNUNET_snprintf (peer_string,
1441 sizeof (peer_string),
1443 GNUNET_i2s_full (peer));
1444 GNUNET_assert (53 == size);
1445 ret = GNUNET_DISK_file_write (fh,
1448 GNUNET_assert (size == ret);
1454 * @brief Store the peers currently in #valid_peers to disk.
1456 * @param sub Sub for which to store the valid peers
1459 store_valid_peers (const struct Sub *sub)
1461 struct GNUNET_DISK_FileHandle *fh;
1462 uint32_t number_written_peers;
1465 if (0 == strncmp ("DISABLE", sub->filename_valid_peers, 7))
1470 ret = GNUNET_DISK_directory_create_for_file (sub->filename_valid_peers);
1471 if (GNUNET_SYSERR == ret)
1473 LOG (GNUNET_ERROR_TYPE_WARNING,
1474 "Not able to create directory for file `%s'\n",
1475 sub->filename_valid_peers);
1478 else if (GNUNET_NO == ret)
1480 LOG (GNUNET_ERROR_TYPE_WARNING,
1481 "Directory for file `%s' exists but is not writable for us\n",
1482 sub->filename_valid_peers);
1485 fh = GNUNET_DISK_file_open (sub->filename_valid_peers,
1486 GNUNET_DISK_OPEN_WRITE |
1487 GNUNET_DISK_OPEN_CREATE,
1488 GNUNET_DISK_PERM_USER_READ |
1489 GNUNET_DISK_PERM_USER_WRITE);
1492 LOG (GNUNET_ERROR_TYPE_WARNING,
1493 "Not able to write valid peers to file `%s'\n",
1494 sub->filename_valid_peers);
1497 LOG (GNUNET_ERROR_TYPE_DEBUG,
1498 "Writing %u valid peers to disk\n",
1499 GNUNET_CONTAINER_multipeermap_size (sub->valid_peers));
1500 number_written_peers =
1501 GNUNET_CONTAINER_multipeermap_iterate (sub->valid_peers,
1502 store_peer_presistently_iterator,
1504 GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
1505 GNUNET_assert (number_written_peers ==
1506 GNUNET_CONTAINER_multipeermap_size (sub->valid_peers));
1511 * @brief Convert string representation of peer id to peer id.
1513 * Counterpart to #GNUNET_i2s_full.
1515 * @param string_repr The string representation of the peer id
1517 * @return The peer id
1519 static const struct GNUNET_PeerIdentity *
1520 s2i_full (const char *string_repr)
1522 struct GNUNET_PeerIdentity *peer;
1526 peer = GNUNET_new (struct GNUNET_PeerIdentity);
1527 len = strlen (string_repr);
1530 LOG (GNUNET_ERROR_TYPE_WARNING,
1531 "Not able to convert string representation of PeerID to PeerID\n"
1532 "Sting representation: %s (len %lu) - too short\n",
1541 ret = GNUNET_CRYPTO_eddsa_public_key_from_string (string_repr,
1544 if (GNUNET_OK != ret)
1546 LOG (GNUNET_ERROR_TYPE_WARNING,
1547 "Not able to convert string representation of PeerID to PeerID\n"
1548 "Sting representation: %s\n",
1557 * @brief Restore the peers on disk to #valid_peers.
1559 * @param sub Sub for which to restore the valid peers
1562 restore_valid_peers (const struct Sub *sub)
1566 struct GNUNET_DISK_FileHandle *fh;
1571 const struct GNUNET_PeerIdentity *peer;
1573 if (0 == strncmp ("DISABLE", sub->filename_valid_peers, 7))
1578 if (GNUNET_OK != GNUNET_DISK_file_test (sub->filename_valid_peers))
1582 fh = GNUNET_DISK_file_open (sub->filename_valid_peers,
1583 GNUNET_DISK_OPEN_READ,
1584 GNUNET_DISK_PERM_NONE);
1585 GNUNET_assert (NULL != fh);
1586 GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_handle_size (fh, &file_size));
1587 num_peers = file_size / 53;
1588 buf = GNUNET_malloc (file_size);
1589 size_read = GNUNET_DISK_file_read (fh, buf, file_size);
1590 GNUNET_assert (size_read == file_size);
1591 LOG (GNUNET_ERROR_TYPE_DEBUG,
1592 "Restoring %" PRIu32 " peers from file `%s'\n",
1594 sub->filename_valid_peers);
1595 for (iter_buf = buf; iter_buf < buf + file_size - 1; iter_buf += 53)
1597 str_repr = GNUNET_strndup (iter_buf, 53);
1598 peer = s2i_full (str_repr);
1599 GNUNET_free (str_repr);
1600 add_valid_peer (peer, sub->valid_peers);
1601 LOG (GNUNET_ERROR_TYPE_DEBUG,
1602 "Restored valid peer %s from disk\n",
1603 GNUNET_i2s_full (peer));
1607 LOG (GNUNET_ERROR_TYPE_DEBUG,
1608 "num_peers: %" PRIu32 ", _size (sub->valid_peers): %u\n",
1610 GNUNET_CONTAINER_multipeermap_size (sub->valid_peers));
1611 if (num_peers != GNUNET_CONTAINER_multipeermap_size (sub->valid_peers))
1613 LOG (GNUNET_ERROR_TYPE_WARNING,
1614 "Number of restored peers does not match file size. Have probably duplicates.\n");
1616 GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
1617 LOG (GNUNET_ERROR_TYPE_DEBUG,
1618 "Restored %u valid peers from disk\n",
1619 GNUNET_CONTAINER_multipeermap_size (sub->valid_peers));
1624 * @brief Delete storage of peers that was created with #initialise_peers ()
1626 * @param sub Sub for which the storage is deleted
1629 peers_terminate (struct Sub *sub)
1631 if (GNUNET_SYSERR ==
1632 GNUNET_CONTAINER_multipeermap_iterate (sub->peer_map,
1633 &peermap_clear_iterator,
1636 LOG (GNUNET_ERROR_TYPE_WARNING,
1637 "Iteration destroying peers was aborted.\n");
1639 GNUNET_CONTAINER_multipeermap_destroy (sub->peer_map);
1640 sub->peer_map = NULL;
1641 store_valid_peers (sub);
1642 GNUNET_free (sub->filename_valid_peers);
1643 sub->filename_valid_peers = NULL;
1644 GNUNET_CONTAINER_multipeermap_destroy (sub->valid_peers);
1645 sub->valid_peers = NULL;
1650 * Iterator over #valid_peers hash map entries.
1652 * @param cls Closure that contains iterator function and closure
1653 * @param peer current peer id
1654 * @param value value in the hash map - unused
1655 * @return #GNUNET_YES if we should continue to
1657 * #GNUNET_NO if not.
1660 valid_peer_iterator (void *cls,
1661 const struct GNUNET_PeerIdentity *peer,
1664 struct PeersIteratorCls *it_cls = cls;
1667 return it_cls->iterator (it_cls->cls, peer);
1672 * @brief Get all currently known, valid peer ids.
1674 * @param valid_peers Peer map containing the valid peers in question
1675 * @param iterator function to call on each peer id
1676 * @param it_cls extra argument to @a iterator
1677 * @return the number of key value pairs processed,
1678 * #GNUNET_SYSERR if it aborted iteration
1681 get_valid_peers (struct GNUNET_CONTAINER_MultiPeerMap *valid_peers,
1682 PeersIterator iterator,
1685 struct PeersIteratorCls *cls;
1688 cls = GNUNET_new (struct PeersIteratorCls);
1689 cls->iterator = iterator;
1691 ret = GNUNET_CONTAINER_multipeermap_iterate (valid_peers,
1692 valid_peer_iterator,
1700 * @brief Add peer to known peers.
1702 * This function is called on new peer_ids from 'external' sources
1703 * (client seed, cadet get_peers(), ...)
1705 * @param sub Sub with the peer map that the @a peer will be added to
1706 * @param peer the new #GNUNET_PeerIdentity
1708 * @return #GNUNET_YES if peer was inserted
1709 * #GNUNET_NO otherwise
1712 insert_peer (struct Sub *sub,
1713 const struct GNUNET_PeerIdentity *peer)
1715 if (GNUNET_YES == check_peer_known (sub->peer_map, peer))
1717 return GNUNET_NO; /* We already know this peer - nothing to do */
1719 (void) create_peer_ctx (sub, peer);
1725 * @brief Check whether flags on a peer are set.
1727 * @param peer_map Peer map that is expected to contain the @a peer
1728 * @param peer the peer to check the flag of
1729 * @param flags the flags to check
1731 * @return #GNUNET_SYSERR if peer is not known
1732 * #GNUNET_YES if all given flags are set
1733 * #GNUNET_NO otherwise
1736 check_peer_flag (const struct GNUNET_CONTAINER_MultiPeerMap *peer_map,
1737 const struct GNUNET_PeerIdentity *peer,
1738 enum Peers_PeerFlags flags)
1740 struct PeerContext *peer_ctx;
1742 if (GNUNET_NO == check_peer_known (peer_map, peer))
1744 return GNUNET_SYSERR;
1746 peer_ctx = get_peer_ctx (peer_map, peer);
1747 return check_peer_flag_set (peer_ctx, flags);
1751 * @brief Try connecting to a peer to see whether it is online
1753 * If not known yet, insert into known peers
1755 * @param sub Sub which would contain the @a peer
1756 * @param peer the peer whose online is to be checked
1757 * @return #GNUNET_YES if the check was issued
1758 * #GNUNET_NO otherwise
1761 issue_peer_online_check (struct Sub *sub,
1762 const struct GNUNET_PeerIdentity *peer)
1764 struct PeerContext *peer_ctx;
1766 (void) insert_peer (sub, peer); // TODO even needed?
1767 peer_ctx = get_peer_ctx (sub->peer_map, peer);
1768 if ( (GNUNET_NO == check_peer_flag (sub->peer_map, peer, Peers_ONLINE)) &&
1769 (NULL == peer_ctx->online_check_pending) )
1771 check_peer_online (peer_ctx);
1779 * @brief Check if peer is removable.
1782 * - a recv channel exists
1783 * - there are pending messages
1784 * - there is no pending pull reply
1786 * @param peer_ctx Context of the peer in question
1787 * @return #GNUNET_YES if peer is removable
1788 * #GNUNET_NO if peer is NOT removable
1789 * #GNUNET_SYSERR if peer is not known
1792 check_removable (const struct PeerContext *peer_ctx)
1794 if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (peer_ctx->sub->peer_map,
1795 &peer_ctx->peer_id))
1797 return GNUNET_SYSERR;
1800 if ( (NULL != peer_ctx->recv_channel_ctx) ||
1801 (NULL != peer_ctx->pending_messages_head) ||
1802 (GNUNET_YES == check_peer_flag_set (peer_ctx, Peers_PULL_REPLY_PENDING)) )
1811 * @brief Check whether @a peer is actually a peer.
1813 * A valid peer is a peer that we know exists eg. we were connected to once.
1815 * @param valid_peers Peer map that would contain the @a peer
1816 * @param peer peer in question
1818 * @return #GNUNET_YES if peer is valid
1819 * #GNUNET_NO if peer is not valid
1822 check_peer_valid (const struct GNUNET_CONTAINER_MultiPeerMap *valid_peers,
1823 const struct GNUNET_PeerIdentity *peer)
1825 return GNUNET_CONTAINER_multipeermap_contains (valid_peers, peer);
1830 * @brief Indicate that we want to send to the other peer
1832 * This establishes a sending channel
1834 * @param peer_ctx Context of the target peer
1837 indicate_sending_intention (struct PeerContext *peer_ctx)
1839 GNUNET_assert (GNUNET_YES == check_peer_known (peer_ctx->sub->peer_map,
1840 &peer_ctx->peer_id));
1841 (void) get_channel (peer_ctx);
1846 * @brief Check whether other peer has the intention to send/opened channel
1849 * @param peer_ctx Context of the peer in question
1851 * @return #GNUNET_YES if peer has the intention to send
1852 * #GNUNET_NO otherwise
1855 check_peer_send_intention (const struct PeerContext *peer_ctx)
1857 if (NULL != peer_ctx->recv_channel_ctx)
1866 * Handle the channel a peer opens to us.
1868 * @param cls The closure - Sub
1869 * @param channel The channel the peer wants to establish
1870 * @param initiator The peer's peer ID
1872 * @return initial channel context for the channel
1873 * (can be NULL -- that's not an error)
1876 handle_inbound_channel (void *cls,
1877 struct GNUNET_CADET_Channel *channel,
1878 const struct GNUNET_PeerIdentity *initiator)
1880 struct PeerContext *peer_ctx;
1881 struct ChannelCtx *channel_ctx;
1882 struct Sub *sub = cls;
1884 LOG (GNUNET_ERROR_TYPE_DEBUG,
1885 "New channel was established to us (Peer %s).\n",
1886 GNUNET_i2s (initiator));
1887 GNUNET_assert (NULL != channel); /* according to cadet API */
1888 /* Make sure we 'know' about this peer */
1889 peer_ctx = create_or_get_peer_ctx (sub, initiator);
1890 set_peer_online (peer_ctx);
1891 (void) add_valid_peer (&peer_ctx->peer_id, peer_ctx->sub->valid_peers);
1892 channel_ctx = add_channel_ctx (peer_ctx);
1893 channel_ctx->channel = channel;
1894 /* We only accept one incoming channel per peer */
1895 if (GNUNET_YES == check_peer_send_intention (get_peer_ctx (sub->peer_map,
1898 LOG (GNUNET_ERROR_TYPE_WARNING,
1899 "Already got one receive channel. Destroying old one.\n");
1900 GNUNET_break_op (0);
1901 destroy_channel (peer_ctx->recv_channel_ctx);
1902 peer_ctx->recv_channel_ctx = channel_ctx;
1903 /* return the channel context */
1906 peer_ctx->recv_channel_ctx = channel_ctx;
1912 * @brief Check whether a sending channel towards the given peer exists
1914 * @param peer_ctx Context of the peer in question
1916 * @return #GNUNET_YES if a sending channel towards that peer exists
1917 * #GNUNET_NO otherwise
1920 check_sending_channel_exists (const struct PeerContext *peer_ctx)
1922 if (GNUNET_NO == check_peer_known (peer_ctx->sub->peer_map,
1923 &peer_ctx->peer_id))
1924 { /* If no such peer exists, there is no channel */
1927 if (NULL == peer_ctx->send_channel_ctx)
1936 * @brief Destroy the send channel of a peer e.g. stop indicating a sending
1937 * intention to another peer
1939 * @param peer_ctx Context to the peer
1940 * @return #GNUNET_YES if channel was destroyed
1941 * #GNUNET_NO otherwise
1944 destroy_sending_channel (struct PeerContext *peer_ctx)
1946 if (GNUNET_NO == check_peer_known (peer_ctx->sub->peer_map,
1947 &peer_ctx->peer_id))
1951 if (NULL != peer_ctx->send_channel_ctx)
1953 destroy_channel (peer_ctx->send_channel_ctx);
1954 (void) check_connected (peer_ctx);
1961 * @brief Send a message to another peer.
1963 * Keeps track about pending messages so they can be properly removed when the
1964 * peer is destroyed.
1966 * @param peer_ctx Context of the peer to which the message is to be sent
1967 * @param ev envelope of the message
1968 * @param type type of the message
1971 send_message (struct PeerContext *peer_ctx,
1972 struct GNUNET_MQ_Envelope *ev,
1975 struct PendingMessage *pending_msg;
1976 struct GNUNET_MQ_Handle *mq;
1978 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1979 "Sending message to %s of type %s\n",
1980 GNUNET_i2s (&peer_ctx->peer_id),
1982 pending_msg = insert_pending_message (peer_ctx, ev, type);
1983 mq = get_mq (peer_ctx);
1984 GNUNET_MQ_notify_sent (ev,
1987 GNUNET_MQ_send (mq, ev);
1991 * @brief Schedule a operation on given peer
1993 * Avoids scheduling an operation twice.
1995 * @param peer_ctx Context of the peer for which to schedule the operation
1996 * @param peer_op the operation to schedule
1997 * @param cls Closure to @a peer_op
1999 * @return #GNUNET_YES if the operation was scheduled
2000 * #GNUNET_NO otherwise
2003 schedule_operation (struct PeerContext *peer_ctx,
2004 const PeerOp peer_op,
2007 struct PeerPendingOp pending_op;
2009 GNUNET_assert (GNUNET_YES == check_peer_known (peer_ctx->sub->peer_map,
2010 &peer_ctx->peer_id));
2012 //TODO if ONLINE execute immediately
2014 if (GNUNET_NO == check_operation_scheduled (peer_ctx, peer_op))
2016 pending_op.op = peer_op;
2017 pending_op.op_cls = cls;
2018 GNUNET_array_append (peer_ctx->pending_ops,
2019 peer_ctx->num_pending_ops,
2026 /***********************************************************************
2027 * /Old gnunet-service-rps_peers.c
2028 ***********************************************************************/
2031 /***********************************************************************
2032 * Housekeeping with clients
2033 ***********************************************************************/
2036 * Closure used to pass the client and the id to the callback
2037 * that replies to a client's request
2044 struct ReplyCls *next;
2045 struct ReplyCls *prev;
2048 * The identifier of the request
2053 * The handle to the request
2055 struct RPS_SamplerRequestHandle *req_handle;
2058 * The client handle to send the reply to
2060 struct ClientContext *cli_ctx;
2065 * Struct used to store the context of a connected client.
2067 struct ClientContext
2072 struct ClientContext *next;
2073 struct ClientContext *prev;
2076 * The message queue to communicate with the client.
2078 struct GNUNET_MQ_Handle *mq;
2081 * @brief How many updates this client expects to receive.
2083 int64_t view_updates_left;
2086 * @brief Whether this client wants to receive stream updates.
2087 * Either #GNUNET_YES or #GNUNET_NO
2089 int8_t stream_update;
2092 * The client handle to send the reply to
2094 struct GNUNET_SERVICE_Client *client;
2097 * The #Sub this context belongs to
2103 * DLL with all clients currently connected to us
2105 struct ClientContext *cli_ctx_head;
2106 struct ClientContext *cli_ctx_tail;
2108 /***********************************************************************
2109 * /Housekeeping with clients
2110 ***********************************************************************/
2116 /***********************************************************************
2118 ***********************************************************************/
2122 * Print peerlist to log.
2125 print_peer_list (struct GNUNET_PeerIdentity *list,
2130 LOG (GNUNET_ERROR_TYPE_DEBUG,
2131 "Printing peer list of length %u at %p:\n",
2134 for (i = 0 ; i < len ; i++)
2136 LOG (GNUNET_ERROR_TYPE_DEBUG,
2138 i, GNUNET_i2s (&list[i]));
2144 * Remove peer from list.
2147 rem_from_list (struct GNUNET_PeerIdentity **peer_list,
2148 unsigned int *list_size,
2149 const struct GNUNET_PeerIdentity *peer)
2152 struct GNUNET_PeerIdentity *tmp;
2156 LOG (GNUNET_ERROR_TYPE_DEBUG,
2157 "Removing peer %s from list at %p\n",
2161 for ( i = 0 ; i < *list_size ; i++ )
2163 if (0 == GNUNET_memcmp (&tmp[i], peer))
2165 if (i < *list_size -1)
2166 { /* Not at the last entry -- shift peers left */
2167 memmove (&tmp[i], &tmp[i +1],
2168 ((*list_size) - i -1) * sizeof (struct GNUNET_PeerIdentity));
2170 /* Remove last entry (should be now useless PeerID) */
2171 GNUNET_array_grow (tmp, *list_size, (*list_size) -1);
2179 * Insert PeerID in #view
2181 * Called once we know a peer is online.
2182 * Implements #PeerOp
2184 * @return GNUNET_OK if peer was actually inserted
2185 * GNUNET_NO if peer was not inserted
2188 insert_in_view_op (void *cls,
2189 const struct GNUNET_PeerIdentity *peer);
2192 * Insert PeerID in #view
2194 * Called once we know a peer is online.
2196 * @param sub Sub in with the view to insert in
2197 * @param peer the peer to insert
2199 * @return GNUNET_OK if peer was actually inserted
2200 * GNUNET_NO if peer was not inserted
2203 insert_in_view (struct Sub *sub,
2204 const struct GNUNET_PeerIdentity *peer)
2206 struct PeerContext *peer_ctx;
2210 online = check_peer_flag (sub->peer_map, peer, Peers_ONLINE);
2211 peer_ctx = get_peer_ctx (sub->peer_map, peer); // TODO indirection needed?
2212 if ( (GNUNET_NO == online) ||
2213 (GNUNET_SYSERR == online) ) /* peer is not even known */
2215 (void) issue_peer_online_check (sub, peer);
2216 (void) schedule_operation (peer_ctx, insert_in_view_op, sub);
2219 /* Open channel towards peer to keep connection open */
2220 indicate_sending_intention (peer_ctx);
2221 ret = View_put (sub->view, peer);
2222 if (peer_ctx->sub == msub)
2224 GNUNET_STATISTICS_set (stats,
2226 View_size (peer_ctx->sub->view),
2234 * @brief Send view to client
2236 * @param cli_ctx the context of the client
2237 * @param view_array the peerids of the view as array (can be empty)
2238 * @param view_size the size of the view array (can be 0)
2241 send_view (const struct ClientContext *cli_ctx,
2242 const struct GNUNET_PeerIdentity *view_array,
2245 struct GNUNET_MQ_Envelope *ev;
2246 struct GNUNET_RPS_CS_DEBUG_ViewReply *out_msg;
2249 if (NULL == view_array)
2251 if (NULL == cli_ctx->sub) sub = msub;
2252 else sub = cli_ctx->sub;
2253 view_size = View_size (sub->view);
2254 view_array = View_get_as_array (sub->view);
2257 ev = GNUNET_MQ_msg_extra (out_msg,
2258 view_size * sizeof (struct GNUNET_PeerIdentity),
2259 GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_REPLY);
2260 out_msg->num_peers = htonl (view_size);
2262 GNUNET_memcpy (&out_msg[1],
2264 view_size * sizeof (struct GNUNET_PeerIdentity));
2265 GNUNET_MQ_send (cli_ctx->mq, ev);
2270 * @brief Send peer from biased stream to client.
2272 * TODO merge with send_view, parameterise
2274 * @param cli_ctx the context of the client
2275 * @param view_array the peerids of the view as array (can be empty)
2276 * @param view_size the size of the view array (can be 0)
2279 send_stream_peers (const struct ClientContext *cli_ctx,
2281 const struct GNUNET_PeerIdentity *peers)
2283 struct GNUNET_MQ_Envelope *ev;
2284 struct GNUNET_RPS_CS_DEBUG_StreamReply *out_msg;
2286 GNUNET_assert (NULL != peers);
2288 ev = GNUNET_MQ_msg_extra (out_msg,
2289 num_peers * sizeof (struct GNUNET_PeerIdentity),
2290 GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_STREAM_REPLY);
2291 out_msg->num_peers = htonl (num_peers);
2293 GNUNET_memcpy (&out_msg[1],
2295 num_peers * sizeof (struct GNUNET_PeerIdentity));
2296 GNUNET_MQ_send (cli_ctx->mq, ev);
2301 * @brief sends updates to clients that are interested
2303 * @param sub Sub for which to notify clients
2306 clients_notify_view_update (const struct Sub *sub)
2308 struct ClientContext *cli_ctx_iter;
2310 const struct GNUNET_PeerIdentity *view_array;
2312 num_peers = View_size (sub->view);
2313 view_array = View_get_as_array(sub->view);
2314 /* check size of view is small enough */
2315 if (GNUNET_MAX_MESSAGE_SIZE < num_peers)
2317 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2318 "View is too big to send\n");
2322 for (cli_ctx_iter = cli_ctx_head;
2323 NULL != cli_ctx_iter;
2324 cli_ctx_iter = cli_ctx_iter->next)
2326 if (1 < cli_ctx_iter->view_updates_left)
2328 /* Client wants to receive limited amount of updates */
2329 cli_ctx_iter->view_updates_left -= 1;
2330 } else if (1 == cli_ctx_iter->view_updates_left)
2332 /* Last update of view for client */
2333 cli_ctx_iter->view_updates_left = -1;
2334 } else if (0 > cli_ctx_iter->view_updates_left) {
2335 /* Client is not interested in updates */
2338 /* else _updates_left == 0 - infinite amount of updates */
2341 send_view (cli_ctx_iter, view_array, num_peers);
2347 * @brief sends updates to clients that are interested
2349 * @param num_peers Number of peers to send
2350 * @param peers the array of peers to send
2353 clients_notify_stream_peer (const struct Sub *sub,
2355 const struct GNUNET_PeerIdentity *peers)
2356 // TODO enum StreamPeerSource)
2358 struct ClientContext *cli_ctx_iter;
2360 LOG (GNUNET_ERROR_TYPE_DEBUG,
2361 "Got peer (%s) from biased stream - update all clients\n",
2362 GNUNET_i2s (peers));
2364 for (cli_ctx_iter = cli_ctx_head;
2365 NULL != cli_ctx_iter;
2366 cli_ctx_iter = cli_ctx_iter->next)
2368 if (GNUNET_YES == cli_ctx_iter->stream_update &&
2369 (sub == cli_ctx_iter->sub || sub == msub))
2371 send_stream_peers (cli_ctx_iter, num_peers, peers);
2378 * Put random peer from sampler into the view as history update.
2380 * @param ids Array of Peers to insert into view
2381 * @param num_peers Number of peers to insert
2382 * @param cls Closure - The Sub for which this is to be done
2385 hist_update (const struct GNUNET_PeerIdentity *ids,
2390 struct Sub *sub = cls;
2392 for (i = 0; i < num_peers; i++)
2395 if (GNUNET_YES != check_peer_known (sub->peer_map, &ids[i]))
2397 LOG (GNUNET_ERROR_TYPE_WARNING,
2398 "Peer in history update not known!\n");
2401 inserted = insert_in_view (sub, &ids[i]);
2402 if (GNUNET_OK == inserted)
2404 clients_notify_stream_peer (sub, 1, &ids[i]);
2407 to_file (sub->file_name_view_log,
2409 GNUNET_i2s_full (ids));
2410 #endif /* TO_FILE_FULL */
2412 clients_notify_view_update (sub);
2417 * Wrapper around #RPS_sampler_resize()
2419 * If we do not have enough sampler elements, double current sampler size
2420 * If we have more than enough sampler elements, halv current sampler size
2422 * @param sampler The sampler to resize
2423 * @param new_size New size to which to resize
2426 resize_wrapper (struct RPS_Sampler *sampler, uint32_t new_size)
2428 unsigned int sampler_size;
2431 // TODO respect the min, max
2432 sampler_size = RPS_sampler_get_size (sampler);
2433 if (sampler_size > new_size * 4)
2435 RPS_sampler_resize (sampler, sampler_size / 2);
2437 else if (sampler_size < new_size)
2439 RPS_sampler_resize (sampler, sampler_size * 2);
2441 LOG (GNUNET_ERROR_TYPE_DEBUG, "sampler_size is now %u\n", sampler_size);
2446 * Add all peers in @a peer_array to @a peer_map used as set.
2448 * @param peer_array array containing the peers
2449 * @param num_peers number of peers in @peer_array
2450 * @param peer_map the peermap to use as set
2453 add_peer_array_to_set (const struct GNUNET_PeerIdentity *peer_array,
2454 unsigned int num_peers,
2455 struct GNUNET_CONTAINER_MultiPeerMap *peer_map)
2458 if (NULL == peer_map)
2460 LOG (GNUNET_ERROR_TYPE_WARNING,
2461 "Trying to add peers to non-existing peermap.\n");
2465 for (i = 0; i < num_peers; i++)
2467 GNUNET_CONTAINER_multipeermap_put (peer_map,
2470 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
2471 if (msub->peer_map == peer_map)
2473 GNUNET_STATISTICS_set (stats,
2475 GNUNET_CONTAINER_multipeermap_size (peer_map),
2483 * Send a PULL REPLY to @a peer_id
2485 * @param peer_ctx Context of the peer to send the reply to
2486 * @param peer_ids the peers to send to @a peer_id
2487 * @param num_peer_ids the number of peers to send to @a peer_id
2490 send_pull_reply (struct PeerContext *peer_ctx,
2491 const struct GNUNET_PeerIdentity *peer_ids,
2492 unsigned int num_peer_ids)
2495 struct GNUNET_MQ_Envelope *ev;
2496 struct GNUNET_RPS_P2P_PullReplyMessage *out_msg;
2498 /* Compute actual size */
2499 send_size = sizeof (struct GNUNET_RPS_P2P_PullReplyMessage) +
2500 num_peer_ids * sizeof (struct GNUNET_PeerIdentity);
2502 if (GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE < send_size)
2503 /* Compute number of peers to send
2504 * If too long, simply truncate */
2505 // TODO select random ones via permutation
2506 // or even better: do good protocol design
2508 (GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE -
2509 sizeof (struct GNUNET_RPS_P2P_PullReplyMessage)) /
2510 sizeof (struct GNUNET_PeerIdentity);
2512 send_size = num_peer_ids;
2514 LOG (GNUNET_ERROR_TYPE_DEBUG,
2515 "Going to send PULL REPLY with %u peers to %s\n",
2516 send_size, GNUNET_i2s (&peer_ctx->peer_id));
2518 ev = GNUNET_MQ_msg_extra (out_msg,
2519 send_size * sizeof (struct GNUNET_PeerIdentity),
2520 GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REPLY);
2521 out_msg->num_peers = htonl (send_size);
2522 GNUNET_memcpy (&out_msg[1], peer_ids,
2523 send_size * sizeof (struct GNUNET_PeerIdentity));
2525 send_message (peer_ctx, ev, "PULL REPLY");
2526 if (peer_ctx->sub == msub)
2528 GNUNET_STATISTICS_update(stats, "# pull reply send issued", 1, GNUNET_NO);
2530 // TODO check with send intention: as send_channel is used/opened we indicate
2531 // a sending intention without intending it.
2532 // -> clean peer afterwards?
2533 // -> use recv_channel?
2538 * Insert PeerID in #pull_map
2540 * Called once we know a peer is online.
2542 * @param cls Closure - Sub with the pull map to insert into
2543 * @param peer Peer to insert
2546 insert_in_pull_map (void *cls,
2547 const struct GNUNET_PeerIdentity *peer)
2549 struct Sub *sub = cls;
2551 CustomPeerMap_put (sub->pull_map, peer);
2556 * Insert PeerID in #view
2558 * Called once we know a peer is online.
2559 * Implements #PeerOp
2561 * @param cls Closure - Sub with view to insert peer into
2562 * @param peer the peer to insert
2565 insert_in_view_op (void *cls,
2566 const struct GNUNET_PeerIdentity *peer)
2568 struct Sub *sub = cls;
2571 inserted = insert_in_view (sub, peer);
2572 if (GNUNET_OK == inserted)
2574 clients_notify_stream_peer (sub, 1, peer);
2580 * Update sampler with given PeerID.
2581 * Implements #PeerOp
2583 * @param cls Closure - Sub containing the sampler to insert into
2584 * @param peer Peer to insert
2587 insert_in_sampler (void *cls,
2588 const struct GNUNET_PeerIdentity *peer)
2590 struct Sub *sub = cls;
2592 LOG (GNUNET_ERROR_TYPE_DEBUG,
2593 "Updating samplers with peer %s from insert_in_sampler()\n",
2595 RPS_sampler_update (sub->sampler, peer);
2596 if (0 < RPS_sampler_count_id (sub->sampler, peer))
2598 /* Make sure we 'know' about this peer */
2599 (void) issue_peer_online_check (sub, peer);
2600 /* Establish a channel towards that peer to indicate we are going to send
2602 //indicate_sending_intention (peer);
2606 GNUNET_STATISTICS_update (stats,
2607 "# observed peers in gossip",
2612 sub->num_observed_peers++;
2613 GNUNET_CONTAINER_multipeermap_put
2614 (sub->observed_unique_peers,
2617 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
2618 uint32_t num_observed_unique_peers =
2619 GNUNET_CONTAINER_multipeermap_size (sub->observed_unique_peers);
2620 GNUNET_STATISTICS_set (stats,
2621 "# unique peers in gossip",
2622 num_observed_unique_peers,
2625 to_file (sub->file_name_observed_log,
2626 "%" PRIu32 " %" PRIu32 " %f\n",
2627 sub->num_observed_peers,
2628 num_observed_unique_peers,
2629 1.0*num_observed_unique_peers/sub->num_observed_peers)
2630 #endif /* TO_FILE_FULL */
2631 #endif /* TO_FILE */
2636 * @brief This is called on peers from external sources (cadet, peerinfo, ...)
2637 * If the peer is not known, online check is issued and it is
2638 * scheduled to be inserted in sampler and view.
2640 * "External sources" refer to every source except the gossip.
2642 * @param sub Sub for which @a peer was received
2643 * @param peer peer to insert/peer received
2646 got_peer (struct Sub *sub,
2647 const struct GNUNET_PeerIdentity *peer)
2649 /* If we did not know this peer already, insert it into sampler and view */
2650 if (GNUNET_YES == issue_peer_online_check (sub, peer))
2652 schedule_operation (get_peer_ctx (sub->peer_map, peer),
2653 &insert_in_sampler, sub);
2654 schedule_operation (get_peer_ctx (sub->peer_map, peer),
2655 &insert_in_view_op, sub);
2659 GNUNET_STATISTICS_update (stats,
2668 * @brief Checks if there is a sending channel and if it is needed
2670 * @param peer_ctx Context of the peer to check
2671 * @return GNUNET_YES if sending channel exists and is still needed
2672 * GNUNET_NO otherwise
2675 check_sending_channel_needed (const struct PeerContext *peer_ctx)
2677 /* struct GNUNET_CADET_Channel *channel; */
2678 if (GNUNET_NO == check_peer_known (peer_ctx->sub->peer_map,
2679 &peer_ctx->peer_id))
2683 if (GNUNET_YES == check_sending_channel_exists (peer_ctx))
2685 if ( (0 < RPS_sampler_count_id (peer_ctx->sub->sampler,
2686 &peer_ctx->peer_id)) ||
2687 (GNUNET_YES == View_contains_peer (peer_ctx->sub->view,
2688 &peer_ctx->peer_id)) ||
2689 (GNUNET_YES == CustomPeerMap_contains_peer (peer_ctx->sub->push_map,
2690 &peer_ctx->peer_id)) ||
2691 (GNUNET_YES == CustomPeerMap_contains_peer (peer_ctx->sub->pull_map,
2692 &peer_ctx->peer_id)) ||
2693 (GNUNET_YES == check_peer_flag (peer_ctx->sub->peer_map,
2695 Peers_PULL_REPLY_PENDING)))
2696 { /* If we want to keep the connection to peer open */
2706 * @brief remove peer from our knowledge, the view, push and pull maps and
2709 * @param sub Sub with the data structures the peer is to be removed from
2710 * @param peer the peer to remove
2713 remove_peer (struct Sub *sub,
2714 const struct GNUNET_PeerIdentity *peer)
2716 (void) View_remove_peer (sub->view,
2718 CustomPeerMap_remove_peer (sub->pull_map,
2720 CustomPeerMap_remove_peer (sub->push_map,
2722 RPS_sampler_reinitialise_by_value (sub->sampler,
2724 /* We want to destroy the peer now.
2725 * Sometimes, it just seems that it's already been removed from the peer_map,
2726 * so check the peer_map first. */
2727 if (GNUNET_YES == check_peer_known (sub->peer_map,
2730 destroy_peer (get_peer_ctx (sub->peer_map,
2737 * @brief Remove data that is not needed anymore.
2739 * If the sending channel is no longer needed it is destroyed.
2741 * @param sub Sub in which the current peer is to be cleaned
2742 * @param peer the peer whose data is about to be cleaned
2745 clean_peer (struct Sub *sub,
2746 const struct GNUNET_PeerIdentity *peer)
2748 if (GNUNET_NO == check_sending_channel_needed (get_peer_ctx (sub->peer_map,
2751 LOG (GNUNET_ERROR_TYPE_DEBUG,
2752 "Going to remove send channel to peer %s\n",
2754 #if ENABLE_MALICIOUS
2755 if (0 != GNUNET_memcmp (&attacked_peer,
2757 (void) destroy_sending_channel (get_peer_ctx (sub->peer_map,
2759 #else /* ENABLE_MALICIOUS */
2760 (void) destroy_sending_channel (get_peer_ctx (sub->peer_map,
2762 #endif /* ENABLE_MALICIOUS */
2765 if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (sub->peer_map,
2768 /* Peer was already removed by callback on destroyed channel */
2769 LOG (GNUNET_ERROR_TYPE_WARNING,
2770 "Peer was removed from our knowledge during cleanup\n");
2774 if ( (GNUNET_NO == check_peer_send_intention (get_peer_ctx (sub->peer_map,
2776 (GNUNET_NO == View_contains_peer (sub->view, peer)) &&
2777 (GNUNET_NO == CustomPeerMap_contains_peer (sub->push_map, peer)) &&
2778 (GNUNET_NO == CustomPeerMap_contains_peer (sub->push_map, peer)) &&
2779 (0 == RPS_sampler_count_id (sub->sampler, peer)) &&
2780 (GNUNET_YES == check_removable (get_peer_ctx (sub->peer_map, peer))) )
2781 { /* We can safely remove this peer */
2782 LOG (GNUNET_ERROR_TYPE_DEBUG,
2783 "Going to remove peer %s\n",
2785 remove_peer (sub, peer);
2792 * @brief This is called when a channel is destroyed.
2794 * Removes peer completely from our knowledge if the send_channel was destroyed
2795 * Otherwise simply delete the recv_channel
2796 * Also check if the knowledge about this peer is still needed.
2797 * If not, remove this peer from our knowledge.
2799 * @param cls The closure - Context to the channel
2800 * @param channel The channel being closed
2803 cleanup_destroyed_channel (void *cls,
2804 const struct GNUNET_CADET_Channel *channel)
2806 struct ChannelCtx *channel_ctx = cls;
2807 struct PeerContext *peer_ctx = channel_ctx->peer_ctx;
2810 channel_ctx->channel = NULL;
2811 remove_channel_ctx (channel_ctx);
2812 if (NULL != peer_ctx &&
2813 peer_ctx->send_channel_ctx == channel_ctx &&
2814 GNUNET_YES == check_sending_channel_needed (channel_ctx->peer_ctx))
2816 remove_peer (peer_ctx->sub, &peer_ctx->peer_id);
2820 /***********************************************************************
2822 ***********************************************************************/
2826 /***********************************************************************
2828 ***********************************************************************/
2831 * @brief Create a new Sub
2833 * @param hash Hash of value shared among rps instances on other hosts that
2834 * defines a subgroup to sample from.
2835 * @param sampler_size Size of the sampler
2836 * @param round_interval Interval (in average) between two rounds
2841 new_sub (const struct GNUNET_HashCode *hash,
2842 uint32_t sampler_size,
2843 struct GNUNET_TIME_Relative round_interval)
2847 sub = GNUNET_new (struct Sub);
2849 /* With the hash generated from the secret value this service only connects
2850 * to rps instances that share the value */
2851 struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
2852 GNUNET_MQ_hd_fixed_size (peer_check,
2853 GNUNET_MESSAGE_TYPE_RPS_PP_CHECK_LIVE,
2854 struct GNUNET_MessageHeader,
2856 GNUNET_MQ_hd_fixed_size (peer_push,
2857 GNUNET_MESSAGE_TYPE_RPS_PP_PUSH,
2858 struct GNUNET_MessageHeader,
2860 GNUNET_MQ_hd_fixed_size (peer_pull_request,
2861 GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REQUEST,
2862 struct GNUNET_MessageHeader,
2864 GNUNET_MQ_hd_var_size (peer_pull_reply,
2865 GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REPLY,
2866 struct GNUNET_RPS_P2P_PullReplyMessage,
2868 GNUNET_MQ_handler_end ()
2872 GNUNET_CADET_open_port (cadet_handle,
2874 &handle_inbound_channel, /* Connect handler */
2876 NULL, /* WindowSize handler */
2877 &cleanup_destroyed_channel, /* Disconnect handler */
2879 if (NULL == sub->cadet_port)
2881 LOG (GNUNET_ERROR_TYPE_ERROR,
2882 "Cadet port `%s' is already in use.\n",
2883 GNUNET_APPLICATION_PORT_RPS);
2887 /* Set up general data structure to keep track about peers */
2888 sub->valid_peers = GNUNET_CONTAINER_multipeermap_create (4, GNUNET_NO);
2890 GNUNET_CONFIGURATION_get_value_filename (cfg,
2892 "FILENAME_VALID_PEERS",
2893 &sub->filename_valid_peers))
2895 GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
2897 "FILENAME_VALID_PEERS");
2899 if (0 != strncmp ("DISABLE", sub->filename_valid_peers, 7))
2901 char *tmp_filename_valid_peers;
2904 GNUNET_snprintf (str_hash,
2906 GNUNET_h2s_full (hash));
2907 tmp_filename_valid_peers = sub->filename_valid_peers;
2908 GNUNET_asprintf (&sub->filename_valid_peers,
2910 tmp_filename_valid_peers,
2912 GNUNET_free (tmp_filename_valid_peers);
2914 sub->peer_map = GNUNET_CONTAINER_multipeermap_create (4, GNUNET_NO);
2916 /* Set up the sampler */
2917 sub->sampler_size_est_min = sampler_size;
2918 sub->sampler_size_est_need = sampler_size;;
2919 LOG (GNUNET_ERROR_TYPE_DEBUG, "MINSIZE is %u\n", sub->sampler_size_est_min);
2920 GNUNET_assert (0 != round_interval.rel_value_us);
2921 sub->round_interval = round_interval;
2922 sub->sampler = RPS_sampler_init (sampler_size,
2925 /* Logging of internals */
2927 sub->file_name_view_log = store_prefix_file_name (&own_identity, "view");
2928 #endif /* TO_FILE_FULL */
2931 sub->file_name_observed_log = store_prefix_file_name (&own_identity,
2933 #endif /* TO_FILE_FULL */
2934 sub->num_observed_peers = 0;
2935 sub->observed_unique_peers = GNUNET_CONTAINER_multipeermap_create (1,
2937 #endif /* TO_FILE */
2939 /* Set up data structures for gossip */
2940 sub->push_map = CustomPeerMap_create (4);
2941 sub->pull_map = CustomPeerMap_create (4);
2942 sub->view_size_est_min = sampler_size;;
2943 sub->view = View_create (sub->view_size_est_min);
2946 GNUNET_STATISTICS_set (stats,
2948 sub->view_size_est_min,
2952 /* Start executing rounds */
2953 sub->do_round_task = GNUNET_SCHEDULER_add_now (&do_round, sub);
2961 * @brief Write all numbers in the given array into the given file
2963 * Single numbers devided by a newline
2965 * @param hist_array[] the array to dump
2966 * @param file_name file to dump into
2969 write_histogram_to_file (const uint32_t hist_array[],
2970 const char *file_name)
2972 char collect_str[SIZE_DUMP_FILE + 1] = "";
2973 char *recv_str_iter;
2974 char *file_name_full;
2976 recv_str_iter = collect_str;
2977 file_name_full = store_prefix_file_name (&own_identity,
2979 for (uint32_t i = 0; i < HISTOGRAM_FILE_SLOTS; i++)
2981 char collect_str_tmp[8];
2983 GNUNET_snprintf (collect_str_tmp,
2984 sizeof (collect_str_tmp),
2987 recv_str_iter = stpncpy (recv_str_iter,
2991 (void) stpcpy (recv_str_iter,
2993 LOG (GNUNET_ERROR_TYPE_DEBUG,
2994 "Writing push stats to disk\n");
2995 to_file_w_len (file_name_full,
2998 GNUNET_free (file_name_full);
3000 #endif /* TO_FILE */
3004 * @brief Destroy Sub.
3006 * @param sub Sub to destroy
3009 destroy_sub (struct Sub *sub)
3011 GNUNET_assert (NULL != sub);
3012 GNUNET_assert (NULL != sub->do_round_task);
3013 GNUNET_SCHEDULER_cancel (sub->do_round_task);
3014 sub->do_round_task = NULL;
3016 /* Disconnect from cadet */
3017 GNUNET_CADET_close_port (sub->cadet_port);
3018 sub->cadet_port= NULL;
3020 /* Clean up data structures for peers */
3021 RPS_sampler_destroy (sub->sampler);
3022 sub->sampler = NULL;
3023 View_destroy (sub->view);
3025 CustomPeerMap_destroy (sub->push_map);
3026 sub->push_map = NULL;
3027 CustomPeerMap_destroy (sub->pull_map);
3028 sub->pull_map = NULL;
3029 peers_terminate (sub);
3031 /* Free leftover data structures */
3033 GNUNET_free (sub->file_name_view_log);
3034 sub->file_name_view_log = NULL;
3035 #endif /* TO_FILE_FULL */
3038 GNUNET_free (sub->file_name_observed_log);
3039 sub->file_name_observed_log = NULL;
3040 #endif /* TO_FILE_FULL */
3042 /* Write push frequencies to disk */
3043 write_histogram_to_file (sub->push_recv,
3046 /* Write push deltas to disk */
3047 write_histogram_to_file (sub->push_delta,
3050 /* Write pull delays to disk */
3051 write_histogram_to_file (sub->pull_delays,
3054 GNUNET_CONTAINER_multipeermap_destroy (sub->observed_unique_peers);
3055 sub->observed_unique_peers = NULL;
3056 #endif /* TO_FILE */
3062 /***********************************************************************
3064 ***********************************************************************/
3067 /***********************************************************************
3069 ***********************************************************************/
3072 * @brief Callback on initialisation of Core.
3074 * @param cls - unused
3075 * @param my_identity - unused
3078 core_init (void *cls,
3079 const struct GNUNET_PeerIdentity *my_identity)
3084 map_single_hop = GNUNET_CONTAINER_multipeermap_create (4, GNUNET_NO);
3089 * @brief Callback for core.
3090 * Method called whenever a given peer connects.
3092 * @param cls closure - unused
3093 * @param peer peer identity this notification is about
3094 * @return closure given to #core_disconnects as peer_cls
3097 core_connects (void *cls,
3098 const struct GNUNET_PeerIdentity *peer,
3099 struct GNUNET_MQ_Handle *mq)
3104 GNUNET_assert (GNUNET_YES ==
3105 GNUNET_CONTAINER_multipeermap_put (map_single_hop,
3108 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
3114 * @brief Callback for core.
3115 * Method called whenever a peer disconnects.
3117 * @param cls closure - unused
3118 * @param peer peer identity this notification is about
3119 * @param peer_cls closure given in #core_connects - unused
3122 core_disconnects (void *cls,
3123 const struct GNUNET_PeerIdentity *peer,
3129 GNUNET_CONTAINER_multipeermap_remove_all (map_single_hop, peer);
3132 /***********************************************************************
3134 ***********************************************************************/
3138 * @brief Destroy the context for a (connected) client
3140 * @param cli_ctx Context to destroy
3143 destroy_cli_ctx (struct ClientContext *cli_ctx)
3145 GNUNET_assert (NULL != cli_ctx);
3146 GNUNET_CONTAINER_DLL_remove (cli_ctx_head,
3149 if (NULL != cli_ctx->sub)
3151 destroy_sub (cli_ctx->sub);
3152 cli_ctx->sub = NULL;
3154 GNUNET_free (cli_ctx);
3159 * @brief Update sizes in sampler and view on estimate update from nse service
3162 * @param logestimate the log(Base 2) value of the current network size estimate
3163 * @param std_dev standard deviation for the estimate
3166 adapt_sizes (struct Sub *sub, double logestimate, double std_dev)
3169 //double scale; // TODO this might go gloabal/config
3171 LOG (GNUNET_ERROR_TYPE_DEBUG,
3172 "Received a ns estimate - logest: %f, std_dev: %f (old_size: %u)\n",
3173 logestimate, std_dev, RPS_sampler_get_size (sub->sampler));
3175 estimate = GNUNET_NSE_log_estimate_to_n (logestimate);
3176 // GNUNET_NSE_log_estimate_to_n (logestimate);
3177 estimate = pow (estimate, 1.0 / 3);
3178 // TODO add if std_dev is a number
3179 // estimate += (std_dev * scale);
3180 if (sub->view_size_est_min < ceil (estimate))
3182 LOG (GNUNET_ERROR_TYPE_DEBUG, "Changing estimate to %f\n", estimate);
3183 sub->sampler_size_est_need = estimate;
3184 sub->view_size_est_need = estimate;
3187 LOG (GNUNET_ERROR_TYPE_DEBUG, "Not using estimate %f\n", estimate);
3188 //sub->sampler_size_est_need = sub->view_size_est_min;
3189 sub->view_size_est_need = sub->view_size_est_min;
3193 GNUNET_STATISTICS_set (stats,
3195 sub->view_size_est_need,
3199 /* If the NSE has changed adapt the lists accordingly */
3200 resize_wrapper (sub->sampler, sub->sampler_size_est_need);
3201 View_change_len (sub->view, sub->view_size_est_need);
3206 * Function called by NSE.
3208 * Updates sizes of sampler list and view and adapt those lists
3211 * implements #GNUNET_NSE_Callback
3213 * @param cls Closure - unused
3214 * @param timestamp time when the estimate was received from the server (or created by the server)
3215 * @param logestimate the log(Base 2) value of the current network size estimate
3216 * @param std_dev standard deviation for the estimate
3219 nse_callback (void *cls,
3220 struct GNUNET_TIME_Absolute timestamp,
3221 double logestimate, double std_dev)
3225 struct ClientContext *cli_ctx_iter;
3227 adapt_sizes (msub, logestimate, std_dev);
3228 for (cli_ctx_iter = cli_ctx_head;
3229 NULL != cli_ctx_iter;
3230 cli_ctx_iter = cli_ctx_iter->next)
3232 if (NULL != cli_ctx_iter->sub)
3234 adapt_sizes (cli_ctx_iter->sub, logestimate, std_dev);
3241 * @brief This function is called, when the client seeds peers.
3242 * It verifies that @a msg is well-formed.
3244 * @param cls the closure (#ClientContext)
3245 * @param msg the message
3246 * @return #GNUNET_OK if @a msg is well-formed
3247 * #GNUNET_SYSERR otherwise
3250 check_client_seed (void *cls, const struct GNUNET_RPS_CS_SeedMessage *msg)
3252 struct ClientContext *cli_ctx = cls;
3253 uint16_t msize = ntohs (msg->header.size);
3254 uint32_t num_peers = ntohl (msg->num_peers);
3256 msize -= sizeof (struct GNUNET_RPS_CS_SeedMessage);
3257 if ( (msize / sizeof (struct GNUNET_PeerIdentity) != num_peers) ||
3258 (msize % sizeof (struct GNUNET_PeerIdentity) != 0) )
3260 LOG (GNUNET_ERROR_TYPE_ERROR,
3261 "message says it sends %" PRIu32 " peers, have space for %lu peers\n",
3262 ntohl (msg->num_peers),
3263 (msize / sizeof (struct GNUNET_PeerIdentity)));
3265 GNUNET_SERVICE_client_drop (cli_ctx->client);
3266 return GNUNET_SYSERR;
3273 * Handle seed from the client.
3275 * @param cls closure
3276 * @param message the actual message
3279 handle_client_seed (void *cls,
3280 const struct GNUNET_RPS_CS_SeedMessage *msg)
3282 struct ClientContext *cli_ctx = cls;
3283 struct GNUNET_PeerIdentity *peers;
3287 num_peers = ntohl (msg->num_peers);
3288 peers = (struct GNUNET_PeerIdentity *) &msg[1];
3290 LOG (GNUNET_ERROR_TYPE_DEBUG,
3291 "Client seeded peers:\n");
3292 print_peer_list (peers, num_peers);
3294 for (i = 0; i < num_peers; i++)
3296 LOG (GNUNET_ERROR_TYPE_DEBUG,
3297 "Updating samplers with seed %" PRIu32 ": %s\n",
3299 GNUNET_i2s (&peers[i]));
3301 if (NULL != msub) got_peer (msub, &peers[i]); /* Condition needed? */
3302 if (NULL != cli_ctx->sub) got_peer (cli_ctx->sub, &peers[i]);
3304 GNUNET_SERVICE_client_continue (cli_ctx->client);
3309 * Handle RPS request from the client.
3311 * @param cls Client context
3312 * @param message Message containing the numer of updates the client wants to
3316 handle_client_view_request (void *cls,
3317 const struct GNUNET_RPS_CS_DEBUG_ViewRequest *msg)
3319 struct ClientContext *cli_ctx = cls;
3320 uint64_t num_updates;
3322 num_updates = ntohl (msg->num_updates);
3324 LOG (GNUNET_ERROR_TYPE_DEBUG,
3325 "Client requested %" PRIu64 " updates of view.\n",
3328 GNUNET_assert (NULL != cli_ctx);
3329 cli_ctx->view_updates_left = num_updates;
3330 send_view (cli_ctx, NULL, 0);
3331 GNUNET_SERVICE_client_continue (cli_ctx->client);
3336 * @brief Handle the cancellation of the view updates.
3338 * @param cls The client context
3342 handle_client_view_cancel (void *cls,
3343 const struct GNUNET_MessageHeader *msg)
3345 struct ClientContext *cli_ctx = cls;
3348 LOG (GNUNET_ERROR_TYPE_DEBUG,
3349 "Client does not want to receive updates of view any more.\n");
3351 GNUNET_assert (NULL != cli_ctx);
3352 cli_ctx->view_updates_left = 0;
3353 GNUNET_SERVICE_client_continue (cli_ctx->client);
3354 if (GNUNET_YES == cli_ctx->stream_update)
3356 destroy_cli_ctx (cli_ctx);
3362 * Handle RPS request for biased stream from the client.
3364 * @param cls Client context
3365 * @param message unused
3368 handle_client_stream_request (void *cls,
3369 const struct GNUNET_RPS_CS_DEBUG_StreamRequest *msg)
3371 struct ClientContext *cli_ctx = cls;
3374 LOG (GNUNET_ERROR_TYPE_DEBUG,
3375 "Client requested peers from biased stream.\n");
3376 cli_ctx->stream_update = GNUNET_YES;
3378 GNUNET_assert (NULL != cli_ctx);
3379 GNUNET_SERVICE_client_continue (cli_ctx->client);
3384 * @brief Handles the cancellation of the stream of biased peer ids
3386 * @param cls The client context
3390 handle_client_stream_cancel (void *cls,
3391 const struct GNUNET_MessageHeader *msg)
3393 struct ClientContext *cli_ctx = cls;
3396 LOG (GNUNET_ERROR_TYPE_DEBUG,
3397 "Client canceled receiving peers from biased stream.\n");
3398 cli_ctx->stream_update = GNUNET_NO;
3400 GNUNET_assert (NULL != cli_ctx);
3401 GNUNET_SERVICE_client_continue (cli_ctx->client);
3406 * @brief Create and start a Sub.
3408 * @param cls Closure - unused
3409 * @param msg Message containing the necessary information
3412 handle_client_start_sub (void *cls,
3413 const struct GNUNET_RPS_CS_SubStartMessage *msg)
3415 struct ClientContext *cli_ctx = cls;
3417 LOG (GNUNET_ERROR_TYPE_DEBUG, "Client requested start of a new sub.\n");
3418 if (NULL != cli_ctx->sub &&
3419 0 != memcmp (&cli_ctx->sub->hash,
3421 sizeof (struct GNUNET_HashCode)))
3423 LOG (GNUNET_ERROR_TYPE_WARNING, "Already have a Sub with different share for this client. Remove old one, add new.\n");
3424 destroy_sub (cli_ctx->sub);
3425 cli_ctx->sub = NULL;
3427 cli_ctx->sub = new_sub (&msg->hash,
3428 msub->sampler_size_est_min, // TODO make api input?
3429 GNUNET_TIME_relative_ntoh (msg->round_interval));
3430 GNUNET_SERVICE_client_continue (cli_ctx->client);
3435 * @brief Destroy the Sub
3437 * @param cls Closure - unused
3438 * @param msg Message containing the hash that identifies the Sub
3441 handle_client_stop_sub (void *cls,
3442 const struct GNUNET_RPS_CS_SubStopMessage *msg)
3444 struct ClientContext *cli_ctx = cls;
3446 GNUNET_assert (NULL != cli_ctx->sub);
3447 if (0 != memcmp (&cli_ctx->sub->hash, &msg->hash, sizeof (struct GNUNET_HashCode)))
3449 LOG (GNUNET_ERROR_TYPE_WARNING, "Share of current sub and request differ!\n");
3451 destroy_sub (cli_ctx->sub);
3452 cli_ctx->sub = NULL;
3453 GNUNET_SERVICE_client_continue (cli_ctx->client);
3458 * Handle a CHECK_LIVE message from another peer.
3460 * This does nothing. But without calling #GNUNET_CADET_receive_done()
3461 * the channel is blocked for all other communication.
3463 * @param cls Closure - Context of channel
3464 * @param msg Message - unused
3467 handle_peer_check (void *cls,
3468 const struct GNUNET_MessageHeader *msg)
3470 const struct ChannelCtx *channel_ctx = cls;
3471 const struct GNUNET_PeerIdentity *peer = &channel_ctx->peer_ctx->peer_id;
3474 LOG (GNUNET_ERROR_TYPE_DEBUG,
3475 "Received CHECK_LIVE (%s)\n", GNUNET_i2s (peer));
3476 if (channel_ctx->peer_ctx->sub == msub)
3478 GNUNET_STATISTICS_update (stats,
3479 "# pending online checks",
3484 GNUNET_CADET_receive_done (channel_ctx->channel);
3489 * Handle a PUSH message from another peer.
3491 * Check the proof of work and store the PeerID
3492 * in the temporary list for pushed PeerIDs.
3494 * @param cls Closure - Context of channel
3495 * @param msg Message - unused
3498 handle_peer_push (void *cls,
3499 const struct GNUNET_MessageHeader *msg)
3501 const struct ChannelCtx *channel_ctx = cls;
3502 const struct GNUNET_PeerIdentity *peer = &channel_ctx->peer_ctx->peer_id;
3505 // (check the proof of work (?))
3507 LOG (GNUNET_ERROR_TYPE_DEBUG,
3508 "Received PUSH (%s)\n",
3510 if (channel_ctx->peer_ctx->sub == msub)
3512 GNUNET_STATISTICS_update(stats, "# push message received", 1, GNUNET_NO);
3513 if (NULL != map_single_hop &&
3514 GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (map_single_hop,
3517 GNUNET_STATISTICS_update (stats,
3518 "# push message received (multi-hop peer)",
3524 #if ENABLE_MALICIOUS
3525 struct AttackedPeer *tmp_att_peer;
3527 if ( (1 == mal_type) ||
3529 { /* Try to maximise representation */
3530 tmp_att_peer = GNUNET_new (struct AttackedPeer);
3531 tmp_att_peer->peer_id = *peer;
3532 if (NULL == att_peer_set)
3533 att_peer_set = GNUNET_CONTAINER_multipeermap_create (1, GNUNET_NO);
3534 if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (att_peer_set,
3537 GNUNET_CONTAINER_DLL_insert (att_peers_head,
3540 add_peer_array_to_set (peer, 1, att_peer_set);
3544 GNUNET_free (tmp_att_peer);
3549 else if (2 == mal_type)
3551 /* We attack one single well-known peer - simply ignore */
3553 #endif /* ENABLE_MALICIOUS */
3555 /* Add the sending peer to the push_map */
3556 CustomPeerMap_put (channel_ctx->peer_ctx->sub->push_map, peer);
3558 GNUNET_break_op (check_peer_known (channel_ctx->peer_ctx->sub->peer_map,
3559 &channel_ctx->peer_ctx->peer_id));
3560 GNUNET_CADET_receive_done (channel_ctx->channel);
3565 * Handle PULL REQUEST request message from another peer.
3567 * Reply with the view of PeerIDs.
3569 * @param cls Closure - Context of channel
3570 * @param msg Message - unused
3573 handle_peer_pull_request (void *cls,
3574 const struct GNUNET_MessageHeader *msg)
3576 const struct ChannelCtx *channel_ctx = cls;
3577 struct PeerContext *peer_ctx = channel_ctx->peer_ctx;
3578 const struct GNUNET_PeerIdentity *peer = &peer_ctx->peer_id;
3579 const struct GNUNET_PeerIdentity *view_array;
3582 LOG (GNUNET_ERROR_TYPE_DEBUG, "Received PULL REQUEST (%s)\n", GNUNET_i2s (peer));
3583 if (peer_ctx->sub == msub)
3585 GNUNET_STATISTICS_update(stats,
3586 "# pull request message received",
3589 if (NULL != map_single_hop &&
3590 GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (map_single_hop,
3591 &peer_ctx->peer_id))
3593 GNUNET_STATISTICS_update (stats,
3594 "# pull request message received (multi-hop peer)",
3600 #if ENABLE_MALICIOUS
3603 { /* Try to maximise representation */
3604 send_pull_reply (peer_ctx, mal_peers, num_mal_peers);
3607 else if (2 == mal_type)
3608 { /* Try to partition network */
3609 if (0 == GNUNET_memcmp (&attacked_peer, peer))
3611 send_pull_reply (peer_ctx, mal_peers, num_mal_peers);
3614 #endif /* ENABLE_MALICIOUS */
3616 GNUNET_break_op (check_peer_known (channel_ctx->peer_ctx->sub->peer_map,
3617 &channel_ctx->peer_ctx->peer_id));
3618 GNUNET_CADET_receive_done (channel_ctx->channel);
3619 view_array = View_get_as_array (channel_ctx->peer_ctx->sub->view);
3620 send_pull_reply (peer_ctx,
3622 View_size (channel_ctx->peer_ctx->sub->view));
3627 * Check whether we sent a corresponding request and
3628 * whether this reply is the first one.
3630 * @param cls Closure - Context of channel
3631 * @param msg Message containing the replied peers
3634 check_peer_pull_reply (void *cls,
3635 const struct GNUNET_RPS_P2P_PullReplyMessage *msg)
3637 struct ChannelCtx *channel_ctx = cls;
3638 struct PeerContext *sender_ctx = channel_ctx->peer_ctx;
3640 if (sizeof (struct GNUNET_RPS_P2P_PullReplyMessage) > ntohs (msg->header.size))
3642 GNUNET_break_op (0);
3643 return GNUNET_SYSERR;
3646 if ((ntohs (msg->header.size) - sizeof (struct GNUNET_RPS_P2P_PullReplyMessage)) /
3647 sizeof (struct GNUNET_PeerIdentity) != ntohl (msg->num_peers))
3649 LOG (GNUNET_ERROR_TYPE_ERROR,
3650 "message says it sends %" PRIu32 " peers, have space for %lu peers\n",
3651 ntohl (msg->num_peers),
3652 (ntohs (msg->header.size) - sizeof (struct GNUNET_RPS_P2P_PullReplyMessage)) /
3653 sizeof (struct GNUNET_PeerIdentity));
3654 GNUNET_break_op (0);
3655 return GNUNET_SYSERR;
3658 if (GNUNET_YES != check_peer_flag (sender_ctx->sub->peer_map,
3659 &sender_ctx->peer_id,
3660 Peers_PULL_REPLY_PENDING))
3662 LOG (GNUNET_ERROR_TYPE_WARNING,
3663 "Received a pull reply from a peer (%s) we didn't request one from!\n",
3664 GNUNET_i2s (&sender_ctx->peer_id));
3665 if (sender_ctx->sub == msub)
3667 GNUNET_STATISTICS_update (stats,
3668 "# unrequested pull replies",
3678 * Handle PULL REPLY message from another peer.
3680 * @param cls Closure
3681 * @param msg The message header
3684 handle_peer_pull_reply (void *cls,
3685 const struct GNUNET_RPS_P2P_PullReplyMessage *msg)
3687 const struct ChannelCtx *channel_ctx = cls;
3688 const struct GNUNET_PeerIdentity *sender = &channel_ctx->peer_ctx->peer_id;
3689 const struct GNUNET_PeerIdentity *peers;
3690 struct Sub *sub = channel_ctx->peer_ctx->sub;
3692 #if ENABLE_MALICIOUS
3693 struct AttackedPeer *tmp_att_peer;
3694 #endif /* ENABLE_MALICIOUS */
3696 sub->pull_delays[sub->num_rounds - channel_ctx->peer_ctx->round_pull_req]++;
3697 LOG (GNUNET_ERROR_TYPE_DEBUG, "Received PULL REPLY (%s)\n", GNUNET_i2s (sender));
3698 if (channel_ctx->peer_ctx->sub == msub)
3700 GNUNET_STATISTICS_update (stats,
3701 "# pull reply messages received",
3704 if (NULL != map_single_hop &&
3705 GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (map_single_hop,
3706 &channel_ctx->peer_ctx->peer_id))
3708 GNUNET_STATISTICS_update (stats,
3709 "# pull reply messages received (multi-hop peer)",
3715 #if ENABLE_MALICIOUS
3716 // We shouldn't even receive pull replies as we're not sending
3720 #endif /* ENABLE_MALICIOUS */
3722 /* Do actual logic */
3723 peers = (const struct GNUNET_PeerIdentity *) &msg[1];
3725 LOG (GNUNET_ERROR_TYPE_DEBUG,
3726 "PULL REPLY received, got following %u peers:\n",
3727 ntohl (msg->num_peers));
3729 for (i = 0; i < ntohl (msg->num_peers); i++)
3731 LOG (GNUNET_ERROR_TYPE_DEBUG,
3734 GNUNET_i2s (&peers[i]));
3736 #if ENABLE_MALICIOUS
3737 if ((NULL != att_peer_set) &&
3738 (1 == mal_type || 3 == mal_type))
3739 { /* Add attacked peer to local list */
3740 // TODO check if we sent a request and this was the first reply
3741 if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (att_peer_set,
3743 && GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (mal_peer_set,
3746 tmp_att_peer = GNUNET_new (struct AttackedPeer);
3747 tmp_att_peer->peer_id = peers[i];
3748 GNUNET_CONTAINER_DLL_insert (att_peers_head,
3751 add_peer_array_to_set (&peers[i], 1, att_peer_set);
3755 #endif /* ENABLE_MALICIOUS */
3756 /* Make sure we 'know' about this peer */
3757 (void) insert_peer (channel_ctx->peer_ctx->sub,
3760 if (GNUNET_YES == check_peer_valid (channel_ctx->peer_ctx->sub->valid_peers,
3763 CustomPeerMap_put (channel_ctx->peer_ctx->sub->pull_map,
3768 schedule_operation (channel_ctx->peer_ctx,
3770 channel_ctx->peer_ctx->sub); /* cls */
3771 (void) issue_peer_online_check (channel_ctx->peer_ctx->sub,
3776 UNSET_PEER_FLAG (get_peer_ctx (channel_ctx->peer_ctx->sub->peer_map,
3778 Peers_PULL_REPLY_PENDING);
3779 clean_peer (channel_ctx->peer_ctx->sub,
3782 GNUNET_break_op (check_peer_known (channel_ctx->peer_ctx->sub->peer_map,
3784 GNUNET_CADET_receive_done (channel_ctx->channel);
3789 * Compute a random delay.
3790 * A uniformly distributed value between mean + spread and mean - spread.
3792 * For example for mean 4 min and spread 2 the minimum is (4 min - (1/2 * 4 min))
3793 * It would return a random value between 2 and 6 min.
3795 * @param mean the mean time until the next round
3796 * @param spread the inverse amount of deviation from the mean
3798 static struct GNUNET_TIME_Relative
3799 compute_rand_delay (struct GNUNET_TIME_Relative mean,
3800 unsigned int spread)
3802 struct GNUNET_TIME_Relative half_interval;
3803 struct GNUNET_TIME_Relative ret;
3804 unsigned int rand_delay;
3805 unsigned int max_rand_delay;
3809 LOG (GNUNET_ERROR_TYPE_WARNING,
3810 "Not accepting spread of 0\n");
3814 GNUNET_assert (0 != mean.rel_value_us);
3816 /* Compute random time value between spread * mean and spread * mean */
3817 half_interval = GNUNET_TIME_relative_divide (mean, spread);
3819 max_rand_delay = GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us / mean.rel_value_us * (2/spread);
3821 * Compute random value between (0 and 1) * round_interval
3822 * via multiplying round_interval with a 'fraction' (0 to value)/value
3824 rand_delay = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, max_rand_delay);
3825 ret = GNUNET_TIME_relative_saturating_multiply (mean, rand_delay);
3826 ret = GNUNET_TIME_relative_divide (ret, max_rand_delay);
3827 ret = GNUNET_TIME_relative_add (ret, half_interval);
3829 if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us == ret.rel_value_us)
3830 LOG (GNUNET_ERROR_TYPE_WARNING,
3831 "Returning FOREVER_REL\n");
3838 * Send single pull request
3840 * @param peer_ctx Context to the peer to send request to
3843 send_pull_request (struct PeerContext *peer_ctx)
3845 struct GNUNET_MQ_Envelope *ev;
3847 GNUNET_assert (GNUNET_NO == check_peer_flag (peer_ctx->sub->peer_map,
3849 Peers_PULL_REPLY_PENDING));
3850 SET_PEER_FLAG (peer_ctx,
3851 Peers_PULL_REPLY_PENDING);
3852 peer_ctx->round_pull_req = peer_ctx->sub->num_rounds;
3854 LOG (GNUNET_ERROR_TYPE_DEBUG,
3855 "Going to send PULL REQUEST to peer %s.\n",
3856 GNUNET_i2s (&peer_ctx->peer_id));
3858 ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REQUEST);
3859 send_message (peer_ctx,
3864 GNUNET_STATISTICS_update (stats,
3865 "# pull request send issued",
3868 if (NULL != map_single_hop &&
3869 GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (map_single_hop,
3870 &peer_ctx->peer_id))
3872 GNUNET_STATISTICS_update (stats,
3873 "# pull request send issued (multi-hop peer)",
3884 * @param peer_ctx Context of peer to send push to
3887 send_push (struct PeerContext *peer_ctx)
3889 struct GNUNET_MQ_Envelope *ev;
3891 LOG (GNUNET_ERROR_TYPE_DEBUG,
3892 "Going to send PUSH to peer %s.\n",
3893 GNUNET_i2s (&peer_ctx->peer_id));
3895 ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_RPS_PP_PUSH);
3896 send_message (peer_ctx, ev, "PUSH");
3899 GNUNET_STATISTICS_update (stats,
3900 "# push send issued",
3903 if (NULL != map_single_hop &&
3904 GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (map_single_hop,
3905 &peer_ctx->peer_id))
3907 GNUNET_STATISTICS_update (stats,
3908 "# push send issued (multi-hop peer)",
3916 #if ENABLE_MALICIOUS
3920 * @brief This function is called, when the client tells us to act malicious.
3921 * It verifies that @a msg is well-formed.
3923 * @param cls the closure (#ClientContext)
3924 * @param msg the message
3925 * @return #GNUNET_OK if @a msg is well-formed
3928 check_client_act_malicious (void *cls,
3929 const struct GNUNET_RPS_CS_ActMaliciousMessage *msg)
3931 struct ClientContext *cli_ctx = cls;
3932 uint16_t msize = ntohs (msg->header.size);
3933 uint32_t num_peers = ntohl (msg->num_peers);
3935 msize -= sizeof (struct GNUNET_RPS_CS_ActMaliciousMessage);
3936 if ( (msize / sizeof (struct GNUNET_PeerIdentity) != num_peers) ||
3937 (msize % sizeof (struct GNUNET_PeerIdentity) != 0) )
3939 LOG (GNUNET_ERROR_TYPE_ERROR,
3940 "message says it sends %" PRIu32 " peers, have space for %lu peers\n",
3941 ntohl (msg->num_peers),
3942 (msize / sizeof (struct GNUNET_PeerIdentity)));
3944 GNUNET_SERVICE_client_drop (cli_ctx->client);
3945 return GNUNET_SYSERR;
3951 * Turn RPS service to act malicious.
3953 * @param cls Closure
3954 * @param client The client that sent the message
3955 * @param msg The message header
3958 handle_client_act_malicious (void *cls,
3959 const struct GNUNET_RPS_CS_ActMaliciousMessage *msg)
3961 struct ClientContext *cli_ctx = cls;
3962 struct GNUNET_PeerIdentity *peers;
3963 uint32_t num_mal_peers_sent;
3964 uint32_t num_mal_peers_old;
3965 struct Sub *sub = cli_ctx->sub;
3967 if (NULL == sub) sub = msub;
3968 /* Do actual logic */
3969 peers = (struct GNUNET_PeerIdentity *) &msg[1];
3970 mal_type = ntohl (msg->type);
3971 if (NULL == mal_peer_set)
3972 mal_peer_set = GNUNET_CONTAINER_multipeermap_create (1, GNUNET_NO);
3974 LOG (GNUNET_ERROR_TYPE_DEBUG,
3975 "Now acting malicious type %" PRIu32 ", got %" PRIu32 " peers.\n",
3977 ntohl (msg->num_peers));
3980 { /* Try to maximise representation */
3981 /* Add other malicious peers to those we already know */
3983 num_mal_peers_sent = ntohl (msg->num_peers);
3984 num_mal_peers_old = num_mal_peers;
3985 GNUNET_array_grow (mal_peers,
3987 num_mal_peers + num_mal_peers_sent);
3988 GNUNET_memcpy (&mal_peers[num_mal_peers_old],
3990 num_mal_peers_sent * sizeof (struct GNUNET_PeerIdentity));
3992 /* Add all mal peers to mal_peer_set */
3993 add_peer_array_to_set (&mal_peers[num_mal_peers_old],
3997 /* Substitute do_round () with do_mal_round () */
3998 GNUNET_assert (NULL != sub->do_round_task);
3999 GNUNET_SCHEDULER_cancel (sub->do_round_task);
4000 sub->do_round_task = GNUNET_SCHEDULER_add_now (&do_mal_round, sub);
4003 else if ( (2 == mal_type) ||
4005 { /* Try to partition the network */
4006 /* Add other malicious peers to those we already know */
4008 num_mal_peers_sent = ntohl (msg->num_peers) - 1;
4009 num_mal_peers_old = num_mal_peers;
4010 GNUNET_assert (GNUNET_MAX_MALLOC_CHECKED > num_mal_peers_sent);
4011 GNUNET_array_grow (mal_peers,
4013 num_mal_peers + num_mal_peers_sent);
4014 if (NULL != mal_peers &&
4017 GNUNET_memcpy (&mal_peers[num_mal_peers_old],
4019 num_mal_peers_sent * sizeof (struct GNUNET_PeerIdentity));
4021 /* Add all mal peers to mal_peer_set */
4022 add_peer_array_to_set (&mal_peers[num_mal_peers_old],
4027 /* Store the one attacked peer */
4028 GNUNET_memcpy (&attacked_peer,
4029 &msg->attacked_peer,
4030 sizeof (struct GNUNET_PeerIdentity));
4031 /* Set the flag of the attacked peer to valid to avoid problems */
4032 if (GNUNET_NO == check_peer_known (sub->peer_map, &attacked_peer))
4034 (void) issue_peer_online_check (sub, &attacked_peer);
4037 LOG (GNUNET_ERROR_TYPE_DEBUG,
4038 "Attacked peer is %s\n",
4039 GNUNET_i2s (&attacked_peer));
4041 /* Substitute do_round () with do_mal_round () */
4042 if (NULL != sub->do_round_task)
4044 /* Probably in shutdown */
4045 GNUNET_SCHEDULER_cancel (sub->do_round_task);
4046 sub->do_round_task = GNUNET_SCHEDULER_add_now (&do_mal_round, sub);
4049 else if (0 == mal_type)
4050 { /* Stop acting malicious */
4051 GNUNET_array_grow (mal_peers, num_mal_peers, 0);
4053 /* Substitute do_mal_round () with do_round () */
4054 GNUNET_SCHEDULER_cancel (sub->do_round_task);
4055 sub->do_round_task = GNUNET_SCHEDULER_add_now (&do_round, sub);
4060 GNUNET_SERVICE_client_continue (cli_ctx->client);
4062 GNUNET_SERVICE_client_continue (cli_ctx->client);
4067 * Send out PUSHes and PULLs maliciously.
4069 * This is executed regylary.
4071 * @param cls Closure - Sub
4074 do_mal_round (void *cls)
4076 uint32_t num_pushes;
4078 struct GNUNET_TIME_Relative time_next_round;
4079 struct AttackedPeer *tmp_att_peer;
4080 struct Sub *sub = cls;
4082 LOG (GNUNET_ERROR_TYPE_DEBUG,
4083 "Going to execute next round maliciously type %" PRIu32 ".\n",
4085 sub->do_round_task = NULL;
4086 GNUNET_assert (mal_type <= 3);
4087 /* Do malicious actions */
4089 { /* Try to maximise representation */
4091 /* The maximum of pushes we're going to send this round */
4092 num_pushes = GNUNET_MIN (GNUNET_MIN (push_limit,
4093 num_attacked_peers),
4094 GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE);
4096 LOG (GNUNET_ERROR_TYPE_DEBUG,
4097 "Going to send %" PRIu32 " pushes\n",
4100 /* Send PUSHes to attacked peers */
4101 for (i = 0 ; i < num_pushes ; i++)
4103 if (att_peers_tail == att_peer_index)
4104 att_peer_index = att_peers_head;
4106 att_peer_index = att_peer_index->next;
4108 send_push (get_peer_ctx (sub->peer_map, &att_peer_index->peer_id));
4111 /* Send PULLs to some peers to learn about additional peers to attack */
4112 tmp_att_peer = att_peer_index;
4113 for (i = 0 ; i < num_pushes * alpha ; i++)
4115 if (att_peers_tail == tmp_att_peer)
4116 tmp_att_peer = att_peers_head;
4118 att_peer_index = tmp_att_peer->next;
4120 send_pull_request (get_peer_ctx (sub->peer_map, &tmp_att_peer->peer_id));
4125 else if (2 == mal_type)
4127 * Try to partition the network
4128 * Send as many pushes to the attacked peer as possible
4129 * That is one push per round as it will ignore more.
4131 (void) issue_peer_online_check (sub, &attacked_peer);
4132 if (GNUNET_YES == check_peer_flag (sub->peer_map,
4135 send_push (get_peer_ctx (sub->peer_map, &attacked_peer));
4140 { /* Combined attack */
4142 /* Send PUSH to attacked peers */
4143 if (GNUNET_YES == check_peer_known (sub->peer_map, &attacked_peer))
4145 (void) issue_peer_online_check (sub, &attacked_peer);
4146 if (GNUNET_YES == check_peer_flag (sub->peer_map,
4150 LOG (GNUNET_ERROR_TYPE_DEBUG,
4151 "Goding to send push to attacked peer (%s)\n",
4152 GNUNET_i2s (&attacked_peer));
4153 send_push (get_peer_ctx (sub->peer_map, &attacked_peer));
4156 (void) issue_peer_online_check (sub, &attacked_peer);
4158 /* The maximum of pushes we're going to send this round */
4159 num_pushes = GNUNET_MIN (GNUNET_MIN (push_limit - 1,
4160 num_attacked_peers),
4161 GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE);
4163 LOG (GNUNET_ERROR_TYPE_DEBUG,
4164 "Going to send %" PRIu32 " pushes\n",
4167 for (i = 0; i < num_pushes; i++)
4169 if (att_peers_tail == att_peer_index)
4170 att_peer_index = att_peers_head;
4172 att_peer_index = att_peer_index->next;
4174 send_push (get_peer_ctx (sub->peer_map, &att_peer_index->peer_id));
4177 /* Send PULLs to some peers to learn about additional peers to attack */
4178 tmp_att_peer = att_peer_index;
4179 for (i = 0; i < num_pushes * alpha; i++)
4181 if (att_peers_tail == tmp_att_peer)
4182 tmp_att_peer = att_peers_head;
4184 att_peer_index = tmp_att_peer->next;
4186 send_pull_request (get_peer_ctx (sub->peer_map, &tmp_att_peer->peer_id));
4190 /* Schedule next round */
4191 time_next_round = compute_rand_delay (sub->round_interval, 2);
4193 GNUNET_assert (NULL == sub->do_round_task);
4194 sub->do_round_task = GNUNET_SCHEDULER_add_delayed (time_next_round,
4195 &do_mal_round, sub);
4196 LOG (GNUNET_ERROR_TYPE_DEBUG, "Finished round\n");
4198 #endif /* ENABLE_MALICIOUS */
4202 * Send out PUSHes and PULLs, possibly update #view, samplers.
4204 * This is executed regylary.
4206 * @param cls Closure - Sub
4209 do_round (void *cls)
4212 const struct GNUNET_PeerIdentity *view_array;
4213 unsigned int *permut;
4214 unsigned int a_peers; /* Number of peers we send pushes to */
4215 unsigned int b_peers; /* Number of peers we send pull requests to */
4216 uint32_t first_border;
4217 uint32_t second_border;
4218 struct GNUNET_PeerIdentity peer;
4219 struct GNUNET_PeerIdentity *update_peer;
4220 struct Sub *sub = cls;
4223 LOG (GNUNET_ERROR_TYPE_DEBUG,
4224 "Going to execute next round.\n");
4227 GNUNET_STATISTICS_update (stats, "# rounds", 1, GNUNET_NO);
4229 sub->do_round_task = NULL;
4231 to_file (sub->file_name_view_log,
4232 "___ new round ___");
4233 #endif /* TO_FILE_FULL */
4234 view_array = View_get_as_array (sub->view);
4235 for (i = 0; i < View_size (sub->view); i++)
4237 LOG (GNUNET_ERROR_TYPE_DEBUG,
4238 "\t%s\n", GNUNET_i2s (&view_array[i]));
4240 to_file (sub->file_name_view_log,
4242 GNUNET_i2s_full (&view_array[i]));
4243 #endif /* TO_FILE_FULL */
4247 /* Send pushes and pull requests */
4248 if (0 < View_size (sub->view))
4250 permut = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_STRONG,
4251 View_size (sub->view));
4254 a_peers = ceil (alpha * View_size (sub->view));
4256 LOG (GNUNET_ERROR_TYPE_DEBUG,
4257 "Going to send pushes to %u (ceil (%f * %u)) peers.\n",
4258 a_peers, alpha, View_size (sub->view));
4259 for (i = 0; i < a_peers; i++)
4261 peer = view_array[permut[i]];
4262 // FIXME if this fails schedule/loop this for later
4263 send_push (get_peer_ctx (sub->peer_map, &peer));
4266 /* Send PULL requests */
4267 b_peers = ceil (beta * View_size (sub->view));
4268 first_border = a_peers;
4269 second_border = a_peers + b_peers;
4270 if (second_border > View_size (sub->view))
4272 first_border = View_size (sub->view) - b_peers;
4273 second_border = View_size (sub->view);
4275 LOG (GNUNET_ERROR_TYPE_DEBUG,
4276 "Going to send pulls to %u (ceil (%f * %u)) peers.\n",
4277 b_peers, beta, View_size (sub->view));
4278 for (i = first_border; i < second_border; i++)
4280 peer = view_array[permut[i]];
4281 if ( GNUNET_NO == check_peer_flag (sub->peer_map,
4283 Peers_PULL_REPLY_PENDING))
4284 { // FIXME if this fails schedule/loop this for later
4285 send_pull_request (get_peer_ctx (sub->peer_map, &peer));
4289 GNUNET_free (permut);
4295 /* TODO see how many peers are in push-/pull- list! */
4297 if ((CustomPeerMap_size (sub->push_map) <= alpha * sub->view_size_est_need) &&
4298 (0 < CustomPeerMap_size (sub->push_map)) &&
4299 (0 < CustomPeerMap_size (sub->pull_map)))
4300 { /* If conditions for update are fulfilled, update */
4301 LOG (GNUNET_ERROR_TYPE_DEBUG, "Update of the view.\n");
4303 uint32_t final_size;
4304 uint32_t peers_to_clean_size;
4305 struct GNUNET_PeerIdentity *peers_to_clean;
4307 peers_to_clean = NULL;
4308 peers_to_clean_size = 0;
4309 GNUNET_array_grow (peers_to_clean,
4310 peers_to_clean_size,
4311 View_size (sub->view));
4312 GNUNET_memcpy (peers_to_clean,
4314 View_size (sub->view) * sizeof (struct GNUNET_PeerIdentity));
4316 /* Seems like recreating is the easiest way of emptying the peermap */
4317 View_clear (sub->view);
4319 to_file (sub->file_name_view_log,
4321 #endif /* TO_FILE_FULL */
4323 first_border = GNUNET_MIN (ceil (alpha * sub->view_size_est_need),
4324 CustomPeerMap_size (sub->push_map));
4325 second_border = first_border +
4326 GNUNET_MIN (floor (beta * sub->view_size_est_need),
4327 CustomPeerMap_size (sub->pull_map));
4328 final_size = second_border +
4329 ceil ((1 - (alpha + beta)) * sub->view_size_est_need);
4330 LOG (GNUNET_ERROR_TYPE_DEBUG,
4331 "first border: %" PRIu32 ", second border: %" PRIu32 ", final size: %"PRIu32 "\n",
4336 /* Update view with peers received through PUSHes */
4337 permut = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_STRONG,
4338 CustomPeerMap_size (sub->push_map));
4339 for (i = 0; i < first_border; i++)
4342 inserted = insert_in_view (sub,
4343 CustomPeerMap_get_peer_by_index (sub->push_map,
4345 if (GNUNET_OK == inserted)
4347 clients_notify_stream_peer (sub,
4349 CustomPeerMap_get_peer_by_index (sub->push_map, permut[i]));
4352 to_file (sub->file_name_view_log,
4354 GNUNET_i2s_full (&view_array[i]));
4355 #endif /* TO_FILE_FULL */
4356 // TODO change the peer_flags accordingly
4358 GNUNET_free (permut);
4361 /* Update view with peers received through PULLs */
4362 permut = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_STRONG,
4363 CustomPeerMap_size (sub->pull_map));
4364 for (i = first_border; i < second_border; i++)
4367 inserted = insert_in_view (sub,
4368 CustomPeerMap_get_peer_by_index (sub->pull_map,
4369 permut[i - first_border]));
4370 if (GNUNET_OK == inserted)
4372 clients_notify_stream_peer (sub,
4374 CustomPeerMap_get_peer_by_index (sub->pull_map,
4375 permut[i - first_border]));
4378 to_file (sub->file_name_view_log,
4380 GNUNET_i2s_full (&view_array[i]));
4381 #endif /* TO_FILE_FULL */
4382 // TODO change the peer_flags accordingly
4384 GNUNET_free (permut);
4387 /* Update view with peers from history */
4388 RPS_sampler_get_n_rand_peers (sub->sampler,
4389 final_size - second_border,
4392 // TODO change the peer_flags accordingly
4394 for (i = 0; i < View_size (sub->view); i++)
4395 rem_from_list (&peers_to_clean, &peers_to_clean_size, &view_array[i]);
4397 /* Clean peers that were removed from the view */
4398 for (i = 0; i < peers_to_clean_size; i++)
4401 to_file (sub->file_name_view_log,
4403 GNUNET_i2s_full (&peers_to_clean[i]));
4404 #endif /* TO_FILE_FULL */
4405 clean_peer (sub, &peers_to_clean[i]);
4408 GNUNET_array_grow (peers_to_clean, peers_to_clean_size, 0);
4409 clients_notify_view_update (sub);
4411 LOG (GNUNET_ERROR_TYPE_DEBUG, "No update of the view.\n");
4414 GNUNET_STATISTICS_update(stats, "# rounds blocked", 1, GNUNET_NO);
4415 if (CustomPeerMap_size (sub->push_map) > alpha * sub->view_size_est_need &&
4416 !(0 >= CustomPeerMap_size (sub->pull_map)))
4417 GNUNET_STATISTICS_update(stats, "# rounds blocked - too many pushes", 1, GNUNET_NO);
4418 if (CustomPeerMap_size (sub->push_map) > alpha * sub->view_size_est_need &&
4419 (0 >= CustomPeerMap_size (sub->pull_map)))
4420 GNUNET_STATISTICS_update(stats, "# rounds blocked - too many pushes, no pull replies", 1, GNUNET_NO);
4421 if (0 >= CustomPeerMap_size (sub->push_map) &&
4422 !(0 >= CustomPeerMap_size (sub->pull_map)))
4423 GNUNET_STATISTICS_update(stats, "# rounds blocked - no pushes", 1, GNUNET_NO);
4424 if (0 >= CustomPeerMap_size (sub->push_map) &&
4425 (0 >= CustomPeerMap_size (sub->pull_map)))
4426 GNUNET_STATISTICS_update(stats, "# rounds blocked - no pushes, no pull replies", 1, GNUNET_NO);
4427 if (0 >= CustomPeerMap_size (sub->pull_map) &&
4428 CustomPeerMap_size (sub->push_map) > alpha * sub->view_size_est_need &&
4429 0 >= CustomPeerMap_size (sub->push_map))
4430 GNUNET_STATISTICS_update(stats, "# rounds blocked - no pull replies", 1, GNUNET_NO);
4433 // TODO independent of that also get some peers from CADET_get_peers()?
4434 if (CustomPeerMap_size (sub->push_map) < HISTOGRAM_FILE_SLOTS)
4436 sub->push_recv[CustomPeerMap_size (sub->push_map)]++;
4440 LOG (GNUNET_ERROR_TYPE_WARNING,
4441 "Push map size too big for histogram (%u, %u)\n",
4442 CustomPeerMap_size (sub->push_map),
4443 HISTOGRAM_FILE_SLOTS);
4445 // FIXME check bounds of histogram
4446 sub->push_delta[(int32_t) (CustomPeerMap_size (sub->push_map) -
4447 (alpha * sub->view_size_est_need)) +
4448 (HISTOGRAM_FILE_SLOTS/2)]++;
4451 GNUNET_STATISTICS_set (stats,
4452 "# peers in push map at end of round",
4453 CustomPeerMap_size (sub->push_map),
4455 GNUNET_STATISTICS_set (stats,
4456 "# peers in pull map at end of round",
4457 CustomPeerMap_size (sub->pull_map),
4459 GNUNET_STATISTICS_set (stats,
4460 "# peers in view at end of round",
4461 View_size (sub->view),
4463 GNUNET_STATISTICS_set (stats,
4464 "# expected pushes",
4465 alpha * sub->view_size_est_need,
4467 GNUNET_STATISTICS_set (stats,
4468 "delta expected - received pushes",
4469 CustomPeerMap_size (sub->push_map) - (alpha * sub->view_size_est_need),
4473 LOG (GNUNET_ERROR_TYPE_DEBUG,
4474 "Received %u pushes and %u pulls last round (alpha (%.2f) * view_size (sub->view%u) = %.2f)\n",
4475 CustomPeerMap_size (sub->push_map),
4476 CustomPeerMap_size (sub->pull_map),
4478 View_size (sub->view),
4479 alpha * View_size (sub->view));
4481 /* Update samplers */
4482 for (i = 0; i < CustomPeerMap_size (sub->push_map); i++)
4484 update_peer = CustomPeerMap_get_peer_by_index (sub->push_map, i);
4485 LOG (GNUNET_ERROR_TYPE_DEBUG,
4486 "Updating with peer %s from push list\n",
4487 GNUNET_i2s (update_peer));
4488 insert_in_sampler (sub, update_peer);
4489 clean_peer (sub, update_peer); /* This cleans only if it is not in the view */
4492 for (i = 0; i < CustomPeerMap_size (sub->pull_map); i++)
4494 LOG (GNUNET_ERROR_TYPE_DEBUG,
4495 "Updating with peer %s from pull list\n",
4496 GNUNET_i2s (CustomPeerMap_get_peer_by_index (sub->pull_map, i)));
4497 insert_in_sampler (sub, CustomPeerMap_get_peer_by_index (sub->pull_map, i));
4498 /* This cleans only if it is not in the view */
4499 clean_peer (sub, CustomPeerMap_get_peer_by_index (sub->pull_map, i));
4503 /* Empty push/pull lists */
4504 CustomPeerMap_clear (sub->push_map);
4505 CustomPeerMap_clear (sub->pull_map);
4509 GNUNET_STATISTICS_set (stats,
4511 View_size(sub->view),
4515 struct GNUNET_TIME_Relative time_next_round;
4517 time_next_round = compute_rand_delay (sub->round_interval, 2);
4519 /* Schedule next round */
4520 sub->do_round_task = GNUNET_SCHEDULER_add_delayed (time_next_round,
4522 LOG (GNUNET_ERROR_TYPE_DEBUG, "Finished round\n");
4527 * This is called from GNUNET_CADET_get_peers().
4529 * It is called on every peer(ID) that cadet somehow has contact with.
4530 * We use those to initialise the sampler.
4532 * implements #GNUNET_CADET_PeersCB
4534 * @param cls Closure - Sub
4535 * @param peer Peer, or NULL on "EOF".
4536 * @param tunnel Do we have a tunnel towards this peer?
4537 * @param n_paths Number of known paths towards this peer.
4538 * @param best_path How long is the best path?
4539 * (0 = unknown, 1 = ourselves, 2 = neighbor)
4542 init_peer_cb (void *cls,
4543 const struct GNUNET_PeerIdentity *peer,
4544 int tunnel, /* "Do we have a tunnel towards this peer?" */
4545 unsigned int n_paths, /* "Number of known paths towards this peer" */
4546 unsigned int best_path) /* "How long is the best path?
4547 * (0 = unknown, 1 = ourselves, 2 = neighbor)" */
4549 struct Sub *sub = cls;
4556 LOG (GNUNET_ERROR_TYPE_DEBUG,
4557 "Got peer_id %s from cadet\n",
4559 got_peer (sub, peer);
4565 * @brief Iterator function over stored, valid peers.
4567 * We initialise the sampler with those.
4569 * @param cls Closure - Sub
4570 * @param peer the peer id
4571 * @return #GNUNET_YES if we should continue to
4573 * #GNUNET_NO if not.
4576 valid_peers_iterator (void *cls,
4577 const struct GNUNET_PeerIdentity *peer)
4579 struct Sub *sub = cls;
4583 LOG (GNUNET_ERROR_TYPE_DEBUG,
4584 "Got stored, valid peer %s\n",
4586 got_peer (sub, peer);
4593 * Iterator over peers from peerinfo.
4595 * @param cls Closure - Sub
4596 * @param peer id of the peer, NULL for last call
4597 * @param hello hello message for the peer (can be NULL)
4598 * @param error message
4601 process_peerinfo_peers (void *cls,
4602 const struct GNUNET_PeerIdentity *peer,
4603 const struct GNUNET_HELLO_Message *hello,
4604 const char *err_msg)
4606 struct Sub *sub = cls;
4612 LOG (GNUNET_ERROR_TYPE_DEBUG,
4613 "Got peer_id %s from peerinfo\n",
4615 got_peer (sub, peer);
4621 * Task run during shutdown.
4623 * @param cls Closure - unused
4626 shutdown_task (void *cls)
4629 struct ClientContext *client_ctx;
4631 LOG (GNUNET_ERROR_TYPE_DEBUG,
4632 "RPS service is going down\n");
4634 /* Clean all clients */
4635 for (client_ctx = cli_ctx_head;
4636 NULL != cli_ctx_head;
4637 client_ctx = cli_ctx_head)
4639 destroy_cli_ctx (client_ctx);
4647 /* Disconnect from other services */
4648 GNUNET_PEERINFO_notify_cancel (peerinfo_notify_handle);
4649 GNUNET_PEERINFO_disconnect (peerinfo_handle);
4650 peerinfo_handle = NULL;
4651 GNUNET_NSE_disconnect (nse);
4652 if (NULL != map_single_hop)
4654 /* core_init was called - core was initialised */
4655 /* disconnect first, so no callback tries to access missing peermap */
4656 GNUNET_CORE_disconnect (core_handle);
4658 GNUNET_CONTAINER_multipeermap_destroy (map_single_hop);
4659 map_single_hop = NULL;
4664 GNUNET_STATISTICS_destroy (stats,
4668 GNUNET_CADET_disconnect (cadet_handle);
4669 cadet_handle = NULL;
4670 #if ENABLE_MALICIOUS
4671 struct AttackedPeer *tmp_att_peer;
4672 GNUNET_array_grow (mal_peers,
4675 if (NULL != mal_peer_set)
4676 GNUNET_CONTAINER_multipeermap_destroy (mal_peer_set);
4677 if (NULL != att_peer_set)
4678 GNUNET_CONTAINER_multipeermap_destroy (att_peer_set);
4679 while (NULL != att_peers_head)
4681 tmp_att_peer = att_peers_head;
4682 GNUNET_CONTAINER_DLL_remove (att_peers_head,
4685 GNUNET_free (tmp_att_peer);
4687 #endif /* ENABLE_MALICIOUS */
4693 * Handle client connecting to the service.
4696 * @param client the new client
4697 * @param mq the message queue of @a client
4701 client_connect_cb (void *cls,
4702 struct GNUNET_SERVICE_Client *client,
4703 struct GNUNET_MQ_Handle *mq)
4705 struct ClientContext *cli_ctx;
4708 LOG (GNUNET_ERROR_TYPE_DEBUG,
4709 "Client connected\n");
4711 return client; /* Server was destroyed before a client connected. Shutting down */
4712 cli_ctx = GNUNET_new (struct ClientContext);
4714 cli_ctx->view_updates_left = -1;
4715 cli_ctx->stream_update = GNUNET_NO;
4716 cli_ctx->client = client;
4717 GNUNET_CONTAINER_DLL_insert (cli_ctx_head,
4724 * Callback called when a client disconnected from the service
4726 * @param cls closure for the service
4727 * @param c the client that disconnected
4728 * @param internal_cls should be equal to @a c
4731 client_disconnect_cb (void *cls,
4732 struct GNUNET_SERVICE_Client *client,
4735 struct ClientContext *cli_ctx = internal_cls;
4738 GNUNET_assert (client == cli_ctx->client);
4740 {/* shutdown task - destroy all clients */
4741 while (NULL != cli_ctx_head)
4742 destroy_cli_ctx (cli_ctx_head);
4745 { /* destroy this client */
4746 LOG (GNUNET_ERROR_TYPE_DEBUG,
4747 "Client disconnected. Destroy its context.\n");
4748 destroy_cli_ctx (cli_ctx);
4754 * Handle random peer sampling clients.
4756 * @param cls closure
4757 * @param c configuration to use
4758 * @param service the initialized service
4762 const struct GNUNET_CONFIGURATION_Handle *c,
4763 struct GNUNET_SERVICE_Handle *service)
4765 struct GNUNET_TIME_Relative round_interval;
4766 long long unsigned int sampler_size;
4767 char hash_port_string[] = GNUNET_APPLICATION_PORT_RPS;
4768 struct GNUNET_HashCode hash;
4773 GNUNET_log_setup ("rps",
4774 GNUNET_error_type_to_string (GNUNET_ERROR_TYPE_DEBUG),
4778 GNUNET_CRYPTO_get_peer_identity (cfg,
4779 &own_identity); // TODO check return value
4780 GNUNET_log (GNUNET_ERROR_TYPE_INFO,
4781 "STARTING SERVICE (rps) for peer [%s]\n",
4782 GNUNET_i2s (&own_identity));
4783 #if ENABLE_MALICIOUS
4784 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
4785 "Malicious execution compiled in.\n");
4786 #endif /* ENABLE_MALICIOUS */
4788 /* Get time interval from the configuration */
4790 GNUNET_CONFIGURATION_get_value_time (cfg,
4795 GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
4796 "RPS", "ROUNDINTERVAL");
4797 GNUNET_SCHEDULER_shutdown ();
4801 /* Get initial size of sampler/view from the configuration */
4803 GNUNET_CONFIGURATION_get_value_number (cfg,
4808 GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
4810 GNUNET_SCHEDULER_shutdown ();
4814 cadet_handle = GNUNET_CADET_connect (cfg);
4815 GNUNET_assert (NULL != cadet_handle);
4816 core_handle = GNUNET_CORE_connect (cfg,
4818 core_init, /* init */
4819 core_connects, /* connects */
4820 core_disconnects, /* disconnects */
4821 NULL); /* handlers */
4822 GNUNET_assert (NULL != core_handle);
4829 /* Set up main Sub */
4830 GNUNET_CRYPTO_hash (hash_port_string,
4831 strlen (hash_port_string),
4833 msub = new_sub (&hash,
4834 sampler_size, /* Will be overwritten by config */
4838 peerinfo_handle = GNUNET_PEERINFO_connect (cfg);
4840 /* connect to NSE */
4841 nse = GNUNET_NSE_connect (cfg, nse_callback, NULL);
4843 //LOG (GNUNET_ERROR_TYPE_DEBUG, "Requesting peers from CADET\n");
4844 //GNUNET_CADET_get_peers (cadet_handle, &init_peer_cb, msub);
4845 // TODO send push/pull to each of those peers?
4846 LOG (GNUNET_ERROR_TYPE_DEBUG, "Requesting stored valid peers\n");
4847 restore_valid_peers (msub);
4848 get_valid_peers (msub->valid_peers, valid_peers_iterator, msub);
4850 peerinfo_notify_handle = GNUNET_PEERINFO_notify (cfg,
4852 process_peerinfo_peers,
4855 LOG (GNUNET_ERROR_TYPE_INFO, "Ready to receive requests from clients\n");
4857 GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
4858 stats = GNUNET_STATISTICS_create ("rps", cfg);
4863 * Define "main" method using service macro.
4867 GNUNET_SERVICE_OPTION_NONE,
4870 &client_disconnect_cb,
4872 GNUNET_MQ_hd_var_size (client_seed,
4873 GNUNET_MESSAGE_TYPE_RPS_CS_SEED,
4874 struct GNUNET_RPS_CS_SeedMessage,
4876 #if ENABLE_MALICIOUS
4877 GNUNET_MQ_hd_var_size (client_act_malicious,
4878 GNUNET_MESSAGE_TYPE_RPS_ACT_MALICIOUS,
4879 struct GNUNET_RPS_CS_ActMaliciousMessage,
4881 #endif /* ENABLE_MALICIOUS */
4882 GNUNET_MQ_hd_fixed_size (client_view_request,
4883 GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_REQUEST,
4884 struct GNUNET_RPS_CS_DEBUG_ViewRequest,
4886 GNUNET_MQ_hd_fixed_size (client_view_cancel,
4887 GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_CANCEL,
4888 struct GNUNET_MessageHeader,
4890 GNUNET_MQ_hd_fixed_size (client_stream_request,
4891 GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_STREAM_REQUEST,
4892 struct GNUNET_RPS_CS_DEBUG_StreamRequest,
4894 GNUNET_MQ_hd_fixed_size (client_stream_cancel,
4895 GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_STREAM_CANCEL,
4896 struct GNUNET_MessageHeader,
4898 GNUNET_MQ_hd_fixed_size (client_start_sub,
4899 GNUNET_MESSAGE_TYPE_RPS_CS_SUB_START,
4900 struct GNUNET_RPS_CS_SubStartMessage,
4902 GNUNET_MQ_hd_fixed_size (client_stop_sub,
4903 GNUNET_MESSAGE_TYPE_RPS_CS_SUB_STOP,
4904 struct GNUNET_RPS_CS_SubStopMessage,
4906 GNUNET_MQ_handler_end());
4908 /* end of gnunet-service-rps.c */