X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;ds=sidebyside;f=src%2Frps%2Fgnunet-service-rps.c;h=eb47903e000dd2b41adb5e38ef7f94c98a1dbb3a;hb=98ac2b34f979cf10da24c984e690dabf7b34794b;hp=82f09213789b171eb4b81caec12cf281ee8630b1;hpb=e268822d23cb12d7748c2f326b18e3fa7daceca6;p=oweals%2Fgnunet.git diff --git a/src/rps/gnunet-service-rps.c b/src/rps/gnunet-service-rps.c index 82f092137..eb47903e0 100644 --- a/src/rps/gnunet-service-rps.c +++ b/src/rps/gnunet-service-rps.c @@ -29,11 +29,11 @@ #include "gnunet_cadet_service.h" #include "gnunet_peerinfo_service.h" #include "gnunet_nse_service.h" +#include "gnunet_statistics_service.h" #include "rps.h" #include "rps-test_util.h" #include "gnunet-service-rps_sampler.h" #include "gnunet-service-rps_custommap.h" -#include "gnunet-service-rps_peers.h" #include "gnunet-service-rps_view.h" #include @@ -60,10 +60,1767 @@ */ static const struct GNUNET_CONFIGURATION_Handle *cfg; +/** + * Handle to the statistics service. + */ +static struct GNUNET_STATISTICS_Handle *stats; + /** * Our own identity. */ -static struct GNUNET_PeerIdentity own_identity; +static struct GNUNET_PeerIdentity own_identity; + + + +/*********************************************************************** + * Old gnunet-service-rps_peers.c +***********************************************************************/ + +/** + * Set a peer flag of given peer context. + */ +#define set_peer_flag(peer_ctx, mask) ((peer_ctx->peer_flags) |= (mask)) + +/** + * Get peer flag of given peer context. + */ +#define check_peer_flag_set(peer_ctx, mask)\ + ((peer_ctx->peer_flags) & (mask) ? GNUNET_YES : GNUNET_NO) + +/** + * Unset flag of given peer context. + */ +#define unset_peer_flag(peer_ctx, mask) ((peer_ctx->peer_flags) &= ~(mask)) + +/** + * Set a channel flag of given channel context. + */ +#define set_channel_flag(channel_flags, mask) ((*channel_flags) |= (mask)) + +/** + * Get channel flag of given channel context. + */ +#define check_channel_flag_set(channel_flags, mask)\ + ((*channel_flags) & (mask) ? GNUNET_YES : GNUNET_NO) + +/** + * Unset flag of given channel context. + */ +#define unset_channel_flag(channel_flags, mask) ((*channel_flags) &= ~(mask)) + + + +/** + * Pending operation on peer consisting of callback and closure + * + * When an operation cannot be executed right now this struct is used to store + * the callback and closure for later execution. + */ +struct PeerPendingOp +{ + /** + * Callback + */ + PeerOp op; + + /** + * Closure + */ + void *op_cls; +}; + +/** + * List containing all messages that are yet to be send + * + * This is used to keep track of all messages that have not been sent yet. When + * a peer is to be removed the pending messages can be removed properly. + */ +struct PendingMessage +{ + /** + * DLL next, prev + */ + struct PendingMessage *next; + struct PendingMessage *prev; + + /** + * The envelope to the corresponding message + */ + struct GNUNET_MQ_Envelope *ev; + + /** + * The corresponding context + */ + struct PeerContext *peer_ctx; + + /** + * The message type + */ + const char *type; +}; + +/** + * Struct used to keep track of other peer's status + * + * This is stored in a multipeermap. + * It contains information such as cadet channels, a message queue for sending, + * status about the channels, the pending operations on this peer and some flags + * about the status of the peer itself. (live, valid, ...) + */ +struct PeerContext +{ + /** + * Message queue open to client + */ + struct GNUNET_MQ_Handle *mq; + + /** + * Channel open to client. + */ + struct GNUNET_CADET_Channel *send_channel; + + /** + * Flags to the sending channel + */ + uint32_t *send_channel_flags; + + /** + * Channel open from client. + */ + struct GNUNET_CADET_Channel *recv_channel; // unneeded? + + /** + * Flags to the receiving channel + */ + uint32_t *recv_channel_flags; + + /** + * Array of pending operations on this peer. + */ + struct PeerPendingOp *pending_ops; + + /** + * Handle to the callback given to cadet_ntfy_tmt_rdy() + * + * To be canceled on shutdown. + */ + struct PendingMessage *liveliness_check_pending; + + /** + * Number of pending operations. + */ + unsigned int num_pending_ops; + + /** + * Identity of the peer + */ + struct GNUNET_PeerIdentity peer_id; + + /** + * Flags indicating status of peer + */ + uint32_t peer_flags; + + /** + * Last time we received something from that peer. + */ + struct GNUNET_TIME_Absolute last_message_recv; + + /** + * Last time we received a keepalive message. + */ + struct GNUNET_TIME_Absolute last_keepalive; + + /** + * DLL with all messages that are yet to be sent + */ + struct PendingMessage *pending_messages_head; + struct PendingMessage *pending_messages_tail; + + /** + * This is pobably followed by 'statistical' data (when we first saw + * him, how did we get his ID, how many pushes (in a timeinterval), + * ...) + */ +}; + +/** + * @brief Closure to #valid_peer_iterator + */ +struct PeersIteratorCls +{ + /** + * Iterator function + */ + PeersIterator iterator; + + /** + * Closure to iterator + */ + void *cls; +}; + +/** + * @brief Hashmap of valid peers. + */ +static struct GNUNET_CONTAINER_MultiPeerMap *valid_peers; + +/** + * @brief Maximum number of valid peers to keep. + * TODO read from config + */ +static uint32_t num_valid_peers_max = UINT32_MAX; + +/** + * @brief Filename of the file that stores the valid peers persistently. + */ +static char *filename_valid_peers; + +/** + * Set of all peers to keep track of them. + */ +static struct GNUNET_CONTAINER_MultiPeerMap *peer_map; + +/** + * Cadet handle. + */ +static struct GNUNET_CADET_Handle *cadet_handle; + + + +/** + * @brief Get the #PeerContext associated with a peer + * + * @param peer the peer id + * + * @return the #PeerContext + */ +static struct PeerContext * +get_peer_ctx (const struct GNUNET_PeerIdentity *peer) +{ + struct PeerContext *ctx; + int ret; + + ret = GNUNET_CONTAINER_multipeermap_contains (peer_map, peer); + GNUNET_assert (GNUNET_YES == ret); + ctx = GNUNET_CONTAINER_multipeermap_get (peer_map, peer); + GNUNET_assert (NULL != ctx); + return ctx; +} + +int +Peers_check_peer_known (const struct GNUNET_PeerIdentity *peer); + +/** + * @brief Create a new #PeerContext and insert it into the peer map + * + * @param peer the peer to create the #PeerContext for + * + * @return the #PeerContext + */ +static struct PeerContext * +create_peer_ctx (const struct GNUNET_PeerIdentity *peer) +{ + struct PeerContext *ctx; + int ret; + + GNUNET_assert (GNUNET_NO == Peers_check_peer_known (peer)); + + ctx = GNUNET_new (struct PeerContext); + ctx->peer_id = *peer; + ctx->send_channel_flags = GNUNET_new (uint32_t); + ctx->recv_channel_flags = GNUNET_new (uint32_t); + ret = GNUNET_CONTAINER_multipeermap_put (peer_map, peer, ctx, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY); + GNUNET_assert (GNUNET_OK == ret); + return ctx; +} + + +/** + * @brief Create or get a #PeerContext + * + * @param peer the peer to get the associated context to + * + * @return the context + */ +static struct PeerContext * +create_or_get_peer_ctx (const struct GNUNET_PeerIdentity *peer) +{ + if (GNUNET_NO == Peers_check_peer_known (peer)) + { + return create_peer_ctx (peer); + } + return get_peer_ctx (peer); +} + +void +Peers_unset_peer_flag (const struct GNUNET_PeerIdentity *peer, enum Peers_PeerFlags flags); + +void +Peers_set_peer_flag (const struct GNUNET_PeerIdentity *peer, enum Peers_PeerFlags flags); + +/** + * @brief Check whether we have a connection to this @a peer + * + * Also sets the #Peers_ONLINE flag accordingly + * + * @param peer the peer in question + * + * @return #GNUNET_YES if we are connected + * #GNUNET_NO otherwise + */ +int +Peers_check_connected (const struct GNUNET_PeerIdentity *peer) +{ + const struct PeerContext *peer_ctx; + + /* If we don't know about this peer we don't know whether it's online */ + if (GNUNET_NO == Peers_check_peer_known (peer)) + { + return GNUNET_NO; + } + /* Get the context */ + peer_ctx = get_peer_ctx (peer); + /* If we have no channel to this peer we don't know whether it's online */ + if ( (NULL == peer_ctx->send_channel) && + (NULL == peer_ctx->recv_channel) ) + { + Peers_unset_peer_flag (peer, Peers_ONLINE); + return GNUNET_NO; + } + /* Otherwise (if we have a channel, we know that it's online */ + Peers_set_peer_flag (peer, Peers_ONLINE); + return GNUNET_YES; +} + + +/** + * @brief The closure to #get_rand_peer_iterator. + */ +struct GetRandPeerIteratorCls +{ + /** + * @brief The index of the peer to return. + * Will be decreased until 0. + * Then current peer is returned. + */ + uint32_t index; + + /** + * @brief Pointer to peer to return. + */ + const struct GNUNET_PeerIdentity *peer; +}; + + +/** + * @brief Iterator function for #get_random_peer_from_peermap. + * + * Implements #GNUNET_CONTAINER_PeerMapIterator. + * Decreases the index until the index is null. + * Then returns the current peer. + * + * @param cls the #GetRandPeerIteratorCls containing index and peer + * @param peer current peer + * @param value unused + * + * @return #GNUNET_YES if we should continue to + * iterate, + * #GNUNET_NO if not. + */ +static int +get_rand_peer_iterator (void *cls, + const struct GNUNET_PeerIdentity *peer, + void *value) +{ + struct GetRandPeerIteratorCls *iterator_cls = cls; + if (0 >= iterator_cls->index) + { + iterator_cls->peer = peer; + return GNUNET_NO; + } + iterator_cls->index--; + return GNUNET_YES; +} + + +/** + * @brief Get a random peer from @a peer_map + * + * @param peer_map the peer_map to get the peer from + * + * @return a random peer + */ +static const struct GNUNET_PeerIdentity * +get_random_peer_from_peermap (const struct + GNUNET_CONTAINER_MultiPeerMap *peer_map) +{ + struct GetRandPeerIteratorCls *iterator_cls; + const struct GNUNET_PeerIdentity *ret; + + iterator_cls = GNUNET_new (struct GetRandPeerIteratorCls); + iterator_cls->index = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, + GNUNET_CONTAINER_multipeermap_size (peer_map)); + (void) GNUNET_CONTAINER_multipeermap_iterate (valid_peers, + get_rand_peer_iterator, + iterator_cls); + ret = iterator_cls->peer; + GNUNET_free (iterator_cls); + return ret; +} + + +/** + * @brief Add a given @a peer to valid peers. + * + * If valid peers are already #num_valid_peers_max, delete a peer previously. + * + * @param peer the peer that is added to the valid peers. + * + * @return #GNUNET_YES if no other peer had to be removed + * #GNUNET_NO otherwise + */ +static int +add_valid_peer (const struct GNUNET_PeerIdentity *peer) +{ + const struct GNUNET_PeerIdentity *rand_peer; + int ret; + + ret = GNUNET_YES; + while (GNUNET_CONTAINER_multipeermap_size (valid_peers) >= num_valid_peers_max) + { + rand_peer = get_random_peer_from_peermap (valid_peers); + GNUNET_CONTAINER_multipeermap_remove_all (valid_peers, rand_peer); + ret = GNUNET_NO; + } + (void) GNUNET_CONTAINER_multipeermap_put (valid_peers, peer, NULL, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY); + return ret; +} + + +/** + * @brief Set the peer flag to living and + * call the pending operations on this peer. + * + * Also adds peer to #valid_peers. + * + * @param peer_ctx the #PeerContext of the peer to set live + */ +static void +set_peer_live (struct PeerContext *peer_ctx) +{ + struct GNUNET_PeerIdentity *peer; + unsigned int i; + + peer = &peer_ctx->peer_id; + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Peer %s is live and valid, calling %i pending operations on it\n", + GNUNET_i2s (peer), + peer_ctx->num_pending_ops); + + if (NULL != peer_ctx->liveliness_check_pending) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Removing pending liveliness check for peer %s\n", + GNUNET_i2s (&peer_ctx->peer_id)); + // TODO wait until cadet sets mq->cancel_impl + //GNUNET_MQ_send_cancel (peer_ctx->liveliness_check_pending->ev); + GNUNET_free (peer_ctx->liveliness_check_pending); + peer_ctx->liveliness_check_pending = NULL; + } + + (void) add_valid_peer (peer); + set_peer_flag (peer_ctx, Peers_ONLINE); + + /* Call pending operations */ + for (i = 0; i < peer_ctx->num_pending_ops; i++) + { + peer_ctx->pending_ops[i].op (peer_ctx->pending_ops[i].op_cls, peer); + } + GNUNET_array_grow (peer_ctx->pending_ops, peer_ctx->num_pending_ops, 0); +} + +static void +cleanup_destroyed_channel (void *cls, + const struct GNUNET_CADET_Channel *channel); + +/* Declaration of handlers */ +static void +handle_peer_check (void *cls, + const struct GNUNET_MessageHeader *msg); + +static void +handle_peer_push (void *cls, + const struct GNUNET_MessageHeader *msg); + +static void +handle_peer_pull_request (void *cls, + const struct GNUNET_MessageHeader *msg); + +static int +check_peer_pull_reply (void *cls, + const struct GNUNET_RPS_P2P_PullReplyMessage *msg); + +static void +handle_peer_pull_reply (void *cls, + const struct GNUNET_RPS_P2P_PullReplyMessage *msg); + +/* End declaration of handlers */ + + +/** + * @brief Get the channel of a peer. If not existing, create. + * + * @param peer the peer id + * @return the #GNUNET_CADET_Channel used to send data to @a peer + */ +struct GNUNET_CADET_Channel * +get_channel (const struct GNUNET_PeerIdentity *peer) +{ + struct PeerContext *peer_ctx; + struct GNUNET_HashCode port; + struct GNUNET_PeerIdentity *ctx_peer; + /* There exists a copy-paste-clone in run() */ + struct GNUNET_MQ_MessageHandler cadet_handlers[] = { + GNUNET_MQ_hd_fixed_size (peer_check, + GNUNET_MESSAGE_TYPE_RPS_PP_CHECK_LIVE, + struct GNUNET_MessageHeader, + NULL), + GNUNET_MQ_hd_fixed_size (peer_push, + GNUNET_MESSAGE_TYPE_RPS_PP_PUSH, + struct GNUNET_MessageHeader, + NULL), + GNUNET_MQ_hd_fixed_size (peer_pull_request, + GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REQUEST, + struct GNUNET_MessageHeader, + NULL), + GNUNET_MQ_hd_var_size (peer_pull_reply, + GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REPLY, + struct GNUNET_RPS_P2P_PullReplyMessage, + NULL), + GNUNET_MQ_handler_end () + }; + + + peer_ctx = get_peer_ctx (peer); + if (NULL == peer_ctx->send_channel) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Trying to establish channel to peer %s\n", + GNUNET_i2s (peer)); + GNUNET_CRYPTO_hash (GNUNET_APPLICATION_PORT_RPS, + strlen (GNUNET_APPLICATION_PORT_RPS), + &port); + ctx_peer = GNUNET_new (struct GNUNET_PeerIdentity); + *ctx_peer = *peer; + peer_ctx->send_channel = + GNUNET_CADET_channel_create (cadet_handle, + (struct GNUNET_PeerIdentity *) ctx_peer, /* context */ + peer, + &port, + GNUNET_CADET_OPTION_RELIABLE, + NULL, /* WindowSize handler */ + cleanup_destroyed_channel, /* Disconnect handler */ + cadet_handlers); + } + GNUNET_assert (NULL != peer_ctx->send_channel); + return peer_ctx->send_channel; +} + + +/** + * Get the message queue (#GNUNET_MQ_Handle) of a specific peer. + * + * If we already have a message queue open to this client, + * simply return it, otherways create one. + * + * @param peer the peer to get the mq to + * @return the #GNUNET_MQ_Handle + */ +static struct GNUNET_MQ_Handle * +get_mq (const struct GNUNET_PeerIdentity *peer) +{ + struct PeerContext *peer_ctx; + + peer_ctx = get_peer_ctx (peer); + + if (NULL == peer_ctx->mq) + { + peer_ctx->mq = GNUNET_CADET_get_mq (get_channel (peer)); + } + return peer_ctx->mq; +} + + +/** + * @brief This is called in response to the first message we sent as a + * liveliness check. + * + * @param cls #PeerContext of peer with pending liveliness check + */ +static void +mq_liveliness_check_successful (void *cls) +{ + struct PeerContext *peer_ctx = cls; + + if (NULL != peer_ctx->liveliness_check_pending) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Liveliness check for peer %s was successfull\n", + GNUNET_i2s (&peer_ctx->peer_id)); + GNUNET_free (peer_ctx->liveliness_check_pending); + peer_ctx->liveliness_check_pending = NULL; + set_peer_live (peer_ctx); + } +} + +/** + * Issue a check whether peer is live + * + * @param peer_ctx the context of the peer + */ +static void +check_peer_live (struct PeerContext *peer_ctx) +{ + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Get informed about peer %s getting live\n", + GNUNET_i2s (&peer_ctx->peer_id)); + + struct GNUNET_MQ_Handle *mq; + struct GNUNET_MQ_Envelope *ev; + + ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_RPS_PP_CHECK_LIVE); + peer_ctx->liveliness_check_pending = GNUNET_new (struct PendingMessage); + peer_ctx->liveliness_check_pending->ev = ev; + peer_ctx->liveliness_check_pending->peer_ctx = peer_ctx; + peer_ctx->liveliness_check_pending->type = "Check liveliness"; + mq = get_mq (&peer_ctx->peer_id); + GNUNET_MQ_notify_sent (ev, + mq_liveliness_check_successful, + peer_ctx); + GNUNET_MQ_send (mq, ev); +} + +/** + * @brief Add an envelope to a message passed to mq to list of pending messages + * + * @param peer peer the message was sent to + * @param ev envelope to the message + * @param type type of the message to be sent + * @return pointer to pending message + */ +static struct PendingMessage * +insert_pending_message (const struct GNUNET_PeerIdentity *peer, + struct GNUNET_MQ_Envelope *ev, + const char *type) +{ + struct PendingMessage *pending_msg; + struct PeerContext *peer_ctx; + + peer_ctx = get_peer_ctx (peer); + pending_msg = GNUNET_new (struct PendingMessage); + pending_msg->ev = ev; + pending_msg->peer_ctx = peer_ctx; + pending_msg->type = type; + GNUNET_CONTAINER_DLL_insert (peer_ctx->pending_messages_head, + peer_ctx->pending_messages_tail, + pending_msg); + return pending_msg; +} + + +/** + * @brief Remove a pending message from the respective DLL + * + * @param pending_msg the pending message to remove + * @param cancel cancel the pending message, too + */ +static void +remove_pending_message (struct PendingMessage *pending_msg, int cancel) +{ + struct PeerContext *peer_ctx; + + peer_ctx = pending_msg->peer_ctx; + GNUNET_assert (NULL != peer_ctx); + GNUNET_CONTAINER_DLL_remove (peer_ctx->pending_messages_head, + peer_ctx->pending_messages_tail, + pending_msg); + // TODO wait for the cadet implementation of message cancellation + //if (GNUNET_YES == cancel) + //{ + // GNUNET_MQ_send_cancel (pending_msg->ev); + //} + GNUNET_free (pending_msg); +} + + +/** + * @brief Check whether function of type #PeerOp was already scheduled + * + * The array with pending operations will probably never grow really big, so + * iterating over it should be ok. + * + * @param peer the peer to check + * @param peer_op the operation (#PeerOp) on the peer + * + * @return #GNUNET_YES if this operation is scheduled on that peer + * #GNUNET_NO otherwise + */ +static int +check_operation_scheduled (const struct GNUNET_PeerIdentity *peer, + const PeerOp peer_op) +{ + const struct PeerContext *peer_ctx; + unsigned int i; + + peer_ctx = get_peer_ctx (peer); + for (i = 0; i < peer_ctx->num_pending_ops; i++) + if (peer_op == peer_ctx->pending_ops[i].op) + return GNUNET_YES; + return GNUNET_NO; +} + +int +Peers_remove_peer (const struct GNUNET_PeerIdentity *peer); + +/** + * Iterator over hash map entries. Deletes all contexts of peers. + * + * @param cls closure + * @param key current public key + * @param value value in the hash map + * @return #GNUNET_YES if we should continue to iterate, + * #GNUNET_NO if not. + */ +static int +peermap_clear_iterator (void *cls, + const struct GNUNET_PeerIdentity *key, + void *value) +{ + Peers_remove_peer (key); + return GNUNET_YES; +} + + +/** + * @brief This is called once a message is sent. + * + * Removes the pending message + * + * @param cls type of the message that was sent + */ +static void +mq_notify_sent_cb (void *cls) +{ + struct PendingMessage *pending_msg = (struct PendingMessage *) cls; + LOG (GNUNET_ERROR_TYPE_DEBUG, + "%s was sent.\n", + pending_msg->type); + if (0 == strncmp ("PULL REPLY", pending_msg->type, 10)) + GNUNET_STATISTICS_update(stats, "# pull replys sent", 1, GNUNET_NO); + if (0 == strncmp ("PULL REQUEST", pending_msg->type, 12)) + GNUNET_STATISTICS_update(stats, "# pull requests sent", 1, GNUNET_NO); + if (0 == strncmp ("PUSH", pending_msg->type, 4)) + GNUNET_STATISTICS_update(stats, "# pushes sent", 1, GNUNET_NO); + /* Do not cancle message */ + remove_pending_message (pending_msg, GNUNET_NO); +} + + +/** + * @brief Iterator function for #store_valid_peers. + * + * Implements #GNUNET_CONTAINER_PeerMapIterator. + * Writes single peer to disk. + * + * @param cls the file handle to write to. + * @param peer current peer + * @param value unused + * + * @return #GNUNET_YES if we should continue to + * iterate, + * #GNUNET_NO if not. + */ +static int +store_peer_presistently_iterator (void *cls, + const struct GNUNET_PeerIdentity *peer, + void *value) +{ + const struct GNUNET_DISK_FileHandle *fh = cls; + char peer_string[128]; + int size; + ssize_t ret; + + if (NULL == peer) + { + return GNUNET_YES; + } + size = GNUNET_snprintf (peer_string, + sizeof (peer_string), + "%s\n", + GNUNET_i2s_full (peer)); + GNUNET_assert (53 == size); + ret = GNUNET_DISK_file_write (fh, + peer_string, + size); + GNUNET_assert (size == ret); + return GNUNET_YES; +} + + +/** + * @brief Store the peers currently in #valid_peers to disk. + */ +static void +store_valid_peers () +{ + struct GNUNET_DISK_FileHandle *fh; + uint32_t number_written_peers; + int ret; + + if (0 == strncmp ("DISABLE", filename_valid_peers, 7)) + { + return; + } + + ret = GNUNET_DISK_directory_create_for_file (filename_valid_peers); + if (GNUNET_SYSERR == ret) + { + LOG (GNUNET_ERROR_TYPE_WARNING, + "Not able to create directory for file `%s'\n", + filename_valid_peers); + GNUNET_break (0); + } + else if (GNUNET_NO == ret) + { + LOG (GNUNET_ERROR_TYPE_WARNING, + "Directory for file `%s' exists but is not writable for us\n", + filename_valid_peers); + GNUNET_break (0); + } + fh = GNUNET_DISK_file_open (filename_valid_peers, + GNUNET_DISK_OPEN_WRITE | + GNUNET_DISK_OPEN_CREATE, + GNUNET_DISK_PERM_USER_READ | + GNUNET_DISK_PERM_USER_WRITE); + if (NULL == fh) + { + LOG (GNUNET_ERROR_TYPE_WARNING, + "Not able to write valid peers to file `%s'\n", + filename_valid_peers); + return; + } + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Writing %u valid peers to disk\n", + GNUNET_CONTAINER_multipeermap_size (valid_peers)); + number_written_peers = + GNUNET_CONTAINER_multipeermap_iterate (valid_peers, + store_peer_presistently_iterator, + fh); + GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh)); + GNUNET_assert (number_written_peers == + GNUNET_CONTAINER_multipeermap_size (valid_peers)); +} + + +/** + * @brief Convert string representation of peer id to peer id. + * + * Counterpart to #GNUNET_i2s_full. + * + * @param string_repr The string representation of the peer id + * + * @return The peer id + */ +static const struct GNUNET_PeerIdentity * +s2i_full (const char *string_repr) +{ + struct GNUNET_PeerIdentity *peer; + size_t len; + int ret; + + peer = GNUNET_new (struct GNUNET_PeerIdentity); + len = strlen (string_repr); + if (52 > len) + { + LOG (GNUNET_ERROR_TYPE_WARNING, + "Not able to convert string representation of PeerID to PeerID\n" + "Sting representation: %s (len %lu) - too short\n", + string_repr, + len); + GNUNET_break (0); + } + else if (52 < len) + { + len = 52; + } + ret = GNUNET_CRYPTO_eddsa_public_key_from_string (string_repr, + len, + &peer->public_key); + if (GNUNET_OK != ret) + { + LOG (GNUNET_ERROR_TYPE_WARNING, + "Not able to convert string representation of PeerID to PeerID\n" + "Sting representation: %s\n", + string_repr); + GNUNET_break (0); + } + return peer; +} + + +/** + * @brief Restore the peers on disk to #valid_peers. + */ +static void +restore_valid_peers () +{ + off_t file_size; + uint32_t num_peers; + struct GNUNET_DISK_FileHandle *fh; + char *buf; + ssize_t size_read; + char *iter_buf; + char *str_repr; + const struct GNUNET_PeerIdentity *peer; + + if (0 == strncmp ("DISABLE", filename_valid_peers, 7)) + { + return; + } + + if (GNUNET_OK != GNUNET_DISK_file_test (filename_valid_peers)) + { + return; + } + fh = GNUNET_DISK_file_open (filename_valid_peers, + GNUNET_DISK_OPEN_READ, + GNUNET_DISK_PERM_NONE); + GNUNET_assert (NULL != fh); + GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_handle_size (fh, &file_size)); + num_peers = file_size / 53; + buf = GNUNET_malloc (file_size); + size_read = GNUNET_DISK_file_read (fh, buf, file_size); + GNUNET_assert (size_read == file_size); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Restoring %" PRIu32 " peers from file `%s'\n", + num_peers, + filename_valid_peers); + for (iter_buf = buf; iter_buf < buf + file_size - 1; iter_buf += 53) + { + str_repr = GNUNET_strndup (iter_buf, 53); + peer = s2i_full (str_repr); + GNUNET_free (str_repr); + add_valid_peer (peer); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Restored valid peer %s from disk\n", + GNUNET_i2s_full (peer)); + } + iter_buf = NULL; + GNUNET_free (buf); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "num_peers: %" PRIu32 ", _size (valid_peers): %u\n", + num_peers, + GNUNET_CONTAINER_multipeermap_size (valid_peers)); + if (num_peers != GNUNET_CONTAINER_multipeermap_size (valid_peers)) + { + LOG (GNUNET_ERROR_TYPE_WARNING, + "Number of restored peers does not match file size. Have probably duplicates.\n"); + } + GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh)); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Restored %u valid peers from disk\n", + GNUNET_CONTAINER_multipeermap_size (valid_peers)); +} + + +/** + * @brief Initialise storage of peers + * + * @param fn_valid_peers filename of the file used to store valid peer ids + * @param cadet_h cadet handle + * @param own_id own peer identity + */ +void +Peers_initialise (char* fn_valid_peers, + struct GNUNET_CADET_Handle *cadet_h, + const struct GNUNET_PeerIdentity *own_id) +{ + filename_valid_peers = GNUNET_strdup (fn_valid_peers); + cadet_handle = cadet_h; + own_identity = *own_id; + peer_map = GNUNET_CONTAINER_multipeermap_create (4, GNUNET_NO); + valid_peers = GNUNET_CONTAINER_multipeermap_create (4, GNUNET_NO); + restore_valid_peers (); +} + + +/** + * @brief Delete storage of peers that was created with #Peers_initialise () + */ +void +Peers_terminate () +{ + if (GNUNET_SYSERR == + GNUNET_CONTAINER_multipeermap_iterate (peer_map, + peermap_clear_iterator, + NULL)) + { + LOG (GNUNET_ERROR_TYPE_WARNING, + "Iteration destroying peers was aborted.\n"); + } + GNUNET_CONTAINER_multipeermap_destroy (peer_map); + peer_map = NULL; + store_valid_peers (); + GNUNET_free (filename_valid_peers); + GNUNET_CONTAINER_multipeermap_destroy (valid_peers); +} + + +/** + * Iterator over #valid_peers hash map entries. + * + * @param cls closure - unused + * @param peer current peer id + * @param value value in the hash map - unused + * @return #GNUNET_YES if we should continue to + * iterate, + * #GNUNET_NO if not. + */ +static int +valid_peer_iterator (void *cls, + const struct GNUNET_PeerIdentity *peer, + void *value) +{ + struct PeersIteratorCls *it_cls = cls; + + return it_cls->iterator (it_cls->cls, + peer); +} + + +/** + * @brief Get all currently known, valid peer ids. + * + * @param it function to call on each peer id + * @param it_cls extra argument to @a it + * @return the number of key value pairs processed, + * #GNUNET_SYSERR if it aborted iteration + */ +int +Peers_get_valid_peers (PeersIterator iterator, + void *it_cls) +{ + struct PeersIteratorCls *cls; + int ret; + + cls = GNUNET_new (struct PeersIteratorCls); + cls->iterator = iterator; + cls->cls = it_cls; + ret = GNUNET_CONTAINER_multipeermap_iterate (valid_peers, + valid_peer_iterator, + cls); + GNUNET_free (cls); + return ret; +} + + +/** + * @brief Add peer to known peers. + * + * This function is called on new peer_ids from 'external' sources + * (client seed, cadet get_peers(), ...) + * + * @param peer the new #GNUNET_PeerIdentity + * + * @return #GNUNET_YES if peer was inserted + * #GNUNET_NO otherwise (if peer was already known or + * peer was #own_identity) + */ +int +Peers_insert_peer (const struct GNUNET_PeerIdentity *peer) +{ + if ( (GNUNET_YES == Peers_check_peer_known (peer)) || + (0 == GNUNET_CRYPTO_cmp_peer_identity (peer, &own_identity)) ) + { + return GNUNET_NO; /* We already know this peer - nothing to do */ + } + (void) create_peer_ctx (peer); + return GNUNET_YES; +} + +int +Peers_check_peer_flag (const struct GNUNET_PeerIdentity *peer, enum Peers_PeerFlags flags); + +/** + * @brief Try connecting to a peer to see whether it is online + * + * If not known yet, insert into known peers + * + * @param peer the peer whose liveliness is to be checked + * @return #GNUNET_YES if peer had to be inserted + * #GNUNET_NO otherwise (if peer was already known or + * peer was #own_identity) + */ +int +Peers_issue_peer_liveliness_check (const struct GNUNET_PeerIdentity *peer) +{ + struct PeerContext *peer_ctx; + int ret; + + if (0 == GNUNET_CRYPTO_cmp_peer_identity (peer, &own_identity)) + { + return GNUNET_NO; + } + ret = Peers_insert_peer (peer); + peer_ctx = get_peer_ctx (peer); + if (GNUNET_NO == Peers_check_peer_flag (peer, Peers_ONLINE)) + { + check_peer_live (peer_ctx); + } + return ret; +} + + +/** + * @brief Check if peer is removable. + * + * Check if + * - a recv channel exists + * - there are pending messages + * - there is no pending pull reply + * + * @param peer the peer in question + * @return #GNUNET_YES if peer is removable + * #GNUNET_NO if peer is NOT removable + * #GNUNET_SYSERR if peer is not known + */ +int +Peers_check_removable (const struct GNUNET_PeerIdentity *peer) +{ + struct PeerContext *peer_ctx; + + if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (peer_map, peer)) + { + return GNUNET_SYSERR; + } + + peer_ctx = get_peer_ctx (peer); + if ( (NULL != peer_ctx->recv_channel) || + (NULL != peer_ctx->pending_messages_head) || + (GNUNET_NO == check_peer_flag_set (peer_ctx, Peers_PULL_REPLY_PENDING)) ) + { + return GNUNET_NO; + } + return GNUNET_YES; +} + +uint32_t * +Peers_get_channel_flag (const struct GNUNET_PeerIdentity *peer, + enum Peers_ChannelRole role); + +int +Peers_check_channel_flag (uint32_t *channel_flags, enum Peers_ChannelFlags flags); + +/** + * @brief Remove peer + * + * @param peer the peer to clean + * @return #GNUNET_YES if peer was removed + * #GNUNET_NO otherwise + */ +int +Peers_remove_peer (const struct GNUNET_PeerIdentity *peer) +{ + struct PeerContext *peer_ctx; + uint32_t *channel_flag; + + if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (peer_map, peer)) + { + return GNUNET_NO; + } + + peer_ctx = get_peer_ctx (peer); + set_peer_flag (peer_ctx, Peers_TO_DESTROY); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Going to remove peer %s\n", + GNUNET_i2s (&peer_ctx->peer_id)); + Peers_unset_peer_flag (peer, Peers_ONLINE); + + GNUNET_array_grow (peer_ctx->pending_ops, peer_ctx->num_pending_ops, 0); + while (NULL != peer_ctx->pending_messages_head) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Removing unsent %s\n", + peer_ctx->pending_messages_head->type); + /* Cancle pending message, too */ + remove_pending_message (peer_ctx->pending_messages_head, GNUNET_YES); + } + /* If we are still waiting for notification whether this peer is live + * cancel the according task */ + if (NULL != peer_ctx->liveliness_check_pending) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Removing pending liveliness check for peer %s\n", + GNUNET_i2s (&peer_ctx->peer_id)); + // TODO wait until cadet sets mq->cancel_impl + //GNUNET_MQ_send_cancel (peer_ctx->liveliness_check_pending->ev); + GNUNET_free (peer_ctx->liveliness_check_pending); + peer_ctx->liveliness_check_pending = NULL; + } + channel_flag = Peers_get_channel_flag (peer, Peers_CHANNEL_ROLE_SENDING); + if (NULL != peer_ctx->send_channel && + GNUNET_YES != Peers_check_channel_flag (channel_flag, Peers_CHANNEL_DESTROING)) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Destroying send channel\n"); + GNUNET_CADET_channel_destroy (peer_ctx->send_channel); + peer_ctx->send_channel = NULL; + peer_ctx->mq = NULL; + } + channel_flag = Peers_get_channel_flag (peer, Peers_CHANNEL_ROLE_RECEIVING); + if (NULL != peer_ctx->recv_channel && + GNUNET_YES != Peers_check_channel_flag (channel_flag, Peers_CHANNEL_DESTROING)) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Destroying recv channel\n"); + GNUNET_CADET_channel_destroy (peer_ctx->recv_channel); + peer_ctx->recv_channel = NULL; + } + + GNUNET_free (peer_ctx->send_channel_flags); + GNUNET_free (peer_ctx->recv_channel_flags); + + if (GNUNET_YES != GNUNET_CONTAINER_multipeermap_remove_all (peer_map, &peer_ctx->peer_id)) + { + LOG (GNUNET_ERROR_TYPE_WARNING, "removing peer from peer_map failed\n"); + } + GNUNET_free (peer_ctx); + return GNUNET_YES; +} + + +/** + * @brief set flags on a given peer. + * + * @param peer the peer to set flags on + * @param flags the flags + */ +void +Peers_set_peer_flag (const struct GNUNET_PeerIdentity *peer, enum Peers_PeerFlags flags) +{ + struct PeerContext *peer_ctx; + + peer_ctx = get_peer_ctx (peer); + set_peer_flag (peer_ctx, flags); +} + + +/** + * @brief unset flags on a given peer. + * + * @param peer the peer to unset flags on + * @param flags the flags + */ +void +Peers_unset_peer_flag (const struct GNUNET_PeerIdentity *peer, enum Peers_PeerFlags flags) +{ + struct PeerContext *peer_ctx; + + peer_ctx = get_peer_ctx (peer); + unset_peer_flag (peer_ctx, flags); +} + + +/** + * @brief Check whether flags on a peer are set. + * + * @param peer the peer to check the flag of + * @param flags the flags to check + * + * @return #GNUNET_SYSERR if peer is not known + * #GNUNET_YES if all given flags are set + * #GNUNET_NO otherwise + */ +int +Peers_check_peer_flag (const struct GNUNET_PeerIdentity *peer, enum Peers_PeerFlags flags) +{ + struct PeerContext *peer_ctx; + + if (GNUNET_NO == Peers_check_peer_known (peer)) + { + return GNUNET_SYSERR; + } + peer_ctx = get_peer_ctx (peer); + return check_peer_flag_set (peer_ctx, flags); +} + + +/** + * @brief set flags on a given channel. + * + * @param channel the channel to set flags on + * @param flags the flags + */ +void +Peers_set_channel_flag (uint32_t *channel_flags, enum Peers_ChannelFlags flags) +{ + set_channel_flag (channel_flags, flags); +} + + +/** + * @brief unset flags on a given channel. + * + * @param channel the channel to unset flags on + * @param flags the flags + */ +void +Peers_unset_channel_flag (uint32_t *channel_flags, enum Peers_ChannelFlags flags) +{ + unset_channel_flag (channel_flags, flags); +} + + +/** + * @brief Check whether flags on a channel are set. + * + * @param channel the channel to check the flag of + * @param flags the flags to check + * + * @return #GNUNET_YES if all given flags are set + * #GNUNET_NO otherwise + */ +int +Peers_check_channel_flag (uint32_t *channel_flags, enum Peers_ChannelFlags flags) +{ + return check_channel_flag_set (channel_flags, flags); +} + +/** + * @brief Get the flags for the channel in @a role for @a peer. + * + * @param peer Peer to get the channel flags for. + * @param role Role of channel to get flags for + * + * @return The flags. + */ +uint32_t * +Peers_get_channel_flag (const struct GNUNET_PeerIdentity *peer, + enum Peers_ChannelRole role) +{ + const struct PeerContext *peer_ctx; + + peer_ctx = get_peer_ctx (peer); + if (Peers_CHANNEL_ROLE_SENDING == role) + { + return peer_ctx->send_channel_flags; + } + else if (Peers_CHANNEL_ROLE_RECEIVING == role) + { + return peer_ctx->recv_channel_flags; + } + else + { + GNUNET_assert (0); + } +} + +/** + * @brief Check whether we have information about the given peer. + * + * FIXME probably deprecated. Make this the new _online. + * + * @param peer peer in question + * + * @return #GNUNET_YES if peer is known + * #GNUNET_NO if peer is not knwon + */ +int +Peers_check_peer_known (const struct GNUNET_PeerIdentity *peer) +{ + if (NULL != peer_map) + { + return GNUNET_CONTAINER_multipeermap_contains (peer_map, peer); + } else + { + return GNUNET_NO; + } +} + + +/** + * @brief Check whether @a peer is actually a peer. + * + * A valid peer is a peer that we know exists eg. we were connected to once. + * + * @param peer peer in question + * + * @return #GNUNET_YES if peer is valid + * #GNUNET_NO if peer is not valid + */ +int +Peers_check_peer_valid (const struct GNUNET_PeerIdentity *peer) +{ + return GNUNET_CONTAINER_multipeermap_contains (valid_peers, peer); +} + + +/** + * @brief Indicate that we want to send to the other peer + * + * This establishes a sending channel + * + * @param peer the peer to establish channel to + */ +void +Peers_indicate_sending_intention (const struct GNUNET_PeerIdentity *peer) +{ + GNUNET_assert (GNUNET_YES == Peers_check_peer_known (peer)); + (void) get_channel (peer); +} + + +/** + * @brief Check whether other peer has the intention to send/opened channel + * towars us + * + * @param peer the peer in question + * + * @return #GNUNET_YES if peer has the intention to send + * #GNUNET_NO otherwise + */ +int +Peers_check_peer_send_intention (const struct GNUNET_PeerIdentity *peer) +{ + const struct PeerContext *peer_ctx; + + peer_ctx = get_peer_ctx (peer); + if (NULL != peer_ctx->recv_channel) + { + return GNUNET_YES; + } + return GNUNET_NO; +} + + +/** + * Handle the channel a peer opens to us. + * + * @param cls The closure + * @param channel The channel the peer wants to establish + * @param initiator The peer's peer ID + * + * @return initial channel context for the channel + * (can be NULL -- that's not an error) + */ +void * +Peers_handle_inbound_channel (void *cls, + struct GNUNET_CADET_Channel *channel, + const struct GNUNET_PeerIdentity *initiator) +{ + struct PeerContext *peer_ctx; + struct GNUNET_PeerIdentity *ctx_peer; + + LOG (GNUNET_ERROR_TYPE_DEBUG, + "New channel was established to us (Peer %s).\n", + GNUNET_i2s (initiator)); + GNUNET_assert (NULL != channel); /* according to cadet API */ + /* Make sure we 'know' about this peer */ + peer_ctx = create_or_get_peer_ctx (initiator); + set_peer_live (peer_ctx); + ctx_peer = GNUNET_new (struct GNUNET_PeerIdentity); + *ctx_peer = *initiator; + /* We only accept one incoming channel per peer */ + if (GNUNET_YES == Peers_check_peer_send_intention (initiator)) + { + set_channel_flag (peer_ctx->recv_channel_flags, + Peers_CHANNEL_ESTABLISHED_TWICE); + //GNUNET_CADET_channel_destroy (channel); + GNUNET_CADET_channel_destroy (peer_ctx->recv_channel); + peer_ctx->recv_channel = channel; + /* return the channel context */ + return ctx_peer; + } + peer_ctx->recv_channel = channel; + return ctx_peer; +} + + +/** + * @brief Check whether a sending channel towards the given peer exists + * + * @param peer the peer to check for + * + * @return #GNUNET_YES if a sending channel towards that peer exists + * #GNUNET_NO otherwise + */ +int +Peers_check_sending_channel_exists (const struct GNUNET_PeerIdentity *peer) +{ + struct PeerContext *peer_ctx; + + if (GNUNET_NO == Peers_check_peer_known (peer)) + { /* If no such peer exists, there is no channel */ + return GNUNET_NO; + } + peer_ctx = get_peer_ctx (peer); + if (NULL == peer_ctx->send_channel) + { + return GNUNET_NO; + } + return GNUNET_YES; +} + + +/** + * @brief check whether the given channel is the sending channel of the given + * peer + * + * @param peer the peer in question + * @param channel the channel to check for + * @param role either #Peers_CHANNEL_ROLE_SENDING, or + * #Peers_CHANNEL_ROLE_RECEIVING + * + * @return #GNUNET_YES if the given chennel is the sending channel of the peer + * #GNUNET_NO otherwise + */ +int +Peers_check_channel_role (const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_CADET_Channel *channel, + enum Peers_ChannelRole role) +{ + const struct PeerContext *peer_ctx; + + if (GNUNET_NO == Peers_check_peer_known (peer)) + { + return GNUNET_NO; + } + peer_ctx = get_peer_ctx (peer); + if ( (Peers_CHANNEL_ROLE_SENDING == role) && + (channel == peer_ctx->send_channel) ) + { + return GNUNET_YES; + } + if ( (Peers_CHANNEL_ROLE_RECEIVING == role) && + (channel == peer_ctx->recv_channel) ) + { + return GNUNET_YES; + } + return GNUNET_NO; +} + + +/** + * @brief Destroy the send channel of a peer e.g. stop indicating a sending + * intention to another peer + * + * If there is also no channel to receive messages from that peer, remove it + * from the peermap. + * TODO really? + * + * @peer the peer identity of the peer whose sending channel to destroy + * @return #GNUNET_YES if channel was destroyed + * #GNUNET_NO otherwise + */ +int +Peers_destroy_sending_channel (const struct GNUNET_PeerIdentity *peer) +{ + struct PeerContext *peer_ctx; + + if (GNUNET_NO == Peers_check_peer_known (peer)) + { + return GNUNET_NO; + } + peer_ctx = get_peer_ctx (peer); + if (NULL != peer_ctx->send_channel) + { + set_channel_flag (peer_ctx->send_channel_flags, Peers_CHANNEL_CLEAN); + GNUNET_CADET_channel_destroy (peer_ctx->send_channel); + peer_ctx->send_channel = NULL; + peer_ctx->mq = NULL; + (void) Peers_check_connected (peer); + return GNUNET_YES; + } + return GNUNET_NO; +} + +/** + * This is called when a channel is destroyed. + * + * @param cls The closure + * @param channel The channel being closed + */ +void +Peers_cleanup_destroyed_channel (void *cls, + const struct GNUNET_CADET_Channel *channel) +{ + struct GNUNET_PeerIdentity *peer = cls; + struct PeerContext *peer_ctx; + + if (GNUNET_NO == Peers_check_peer_known (peer)) + {/* We don't want to implicitly create a context that we're about to kill */ + LOG (GNUNET_ERROR_TYPE_DEBUG, + "channel (%s) without associated context was destroyed\n", + GNUNET_i2s (peer)); + return; + } + peer_ctx = get_peer_ctx (peer); + + /* If our peer issued the destruction of the channel, the #Peers_TO_DESTROY + * flag will be set. In this case simply make sure that the channels are + * cleaned. */ + /* FIXME This distinction seems to be redundant */ + if (Peers_check_peer_flag (peer, Peers_TO_DESTROY)) + {/* We initiatad the destruction of this particular peer */ + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Peer is in the process of being destroyed\n"); + if (channel == peer_ctx->send_channel) + { + peer_ctx->send_channel = NULL; + peer_ctx->mq = NULL; + } + else if (channel == peer_ctx->recv_channel) + { + peer_ctx->recv_channel = NULL; + } + + if (NULL != peer_ctx->send_channel) + { + GNUNET_CADET_channel_destroy (peer_ctx->send_channel); + peer_ctx->send_channel = NULL; + peer_ctx->mq = NULL; + } + if (NULL != peer_ctx->recv_channel) + { + GNUNET_CADET_channel_destroy (peer_ctx->recv_channel); + peer_ctx->recv_channel = NULL; + } + /* Set the #Peers_ONLINE flag accordingly */ + (void) Peers_check_connected (peer); + return; + } + + else + { /* We did not initiate the destruction of this peer */ + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Peer is NOT in the process of being destroyed\n"); + if (channel == peer_ctx->send_channel) + { /* Something (but us) killd the channel - clean up peer */ + LOG (GNUNET_ERROR_TYPE_DEBUG, + "send channel (%s) was destroyed - cleaning up\n", + GNUNET_i2s (peer)); + peer_ctx->send_channel = NULL; + peer_ctx->mq = NULL; + } + else if (channel == peer_ctx->recv_channel) + { /* Other peer doesn't want to send us messages anymore */ + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Peer %s destroyed recv channel - cleaning up channel\n", + GNUNET_i2s (peer)); + peer_ctx->recv_channel = NULL; + } + else + { + LOG (GNUNET_ERROR_TYPE_WARNING, + "unknown channel (%s) was destroyed\n", + GNUNET_i2s (peer)); + } + } + (void) Peers_check_connected (peer); +} + +/** + * @brief Send a message to another peer. + * + * Keeps track about pending messages so they can be properly removed when the + * peer is destroyed. + * + * @param peer receeiver of the message + * @param ev envelope of the message + * @param type type of the message + */ +void +Peers_send_message (const struct GNUNET_PeerIdentity *peer, + struct GNUNET_MQ_Envelope *ev, + const char *type) +{ + struct PendingMessage *pending_msg; + struct GNUNET_MQ_Handle *mq; + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Sending message to %s of type %s\n", + GNUNET_i2s (peer), + type); + pending_msg = insert_pending_message (peer, ev, type); + mq = get_mq (peer); + GNUNET_MQ_notify_sent (ev, + mq_notify_sent_cb, + pending_msg); + GNUNET_MQ_send (mq, ev); +} + +/** + * @brief Schedule a operation on given peer + * + * Avoids scheduling an operation twice. + * + * @param peer the peer we want to schedule the operation for once it gets live + * + * @return #GNUNET_YES if the operation was scheduled + * #GNUNET_NO otherwise + */ +int +Peers_schedule_operation (const struct GNUNET_PeerIdentity *peer, + const PeerOp peer_op) +{ + struct PeerPendingOp pending_op; + struct PeerContext *peer_ctx; + + if (0 == GNUNET_CRYPTO_cmp_peer_identity (peer, &own_identity)) + { + return GNUNET_NO; + } + GNUNET_assert (GNUNET_YES == Peers_check_peer_known (peer)); + + //TODO if LIVE/ONLINE execute immediately + + if (GNUNET_NO == check_operation_scheduled (peer, peer_op)) + { + peer_ctx = get_peer_ctx (peer); + pending_op.op = peer_op; + pending_op.op_cls = NULL; + GNUNET_array_append (peer_ctx->pending_ops, + peer_ctx->num_pending_ops, + pending_op); + return GNUNET_YES; + } + return GNUNET_NO; +} + +/** + * @brief Get the recv_channel of @a peer. + * Needed to correctly handle (call #GNUNET_CADET_receive_done()) incoming + * messages. + * + * @param peer The peer to get the recv_channel from. + * + * @return The recv_channel. + */ +struct GNUNET_CADET_Channel * +Peers_get_recv_channel (const struct GNUNET_PeerIdentity *peer) +{ + struct PeerContext *peer_ctx; + + GNUNET_assert (GNUNET_YES == Peers_check_peer_known (peer)); + peer_ctx = get_peer_ctx (peer); + return peer_ctx->recv_channel; +} +/*********************************************************************** + * /Old gnunet-service-rps_peers.c +***********************************************************************/ /*********************************************************************** @@ -95,7 +1852,7 @@ struct ReplyCls /** * The client handle to send the reply to */ - struct GNUNET_SERVER_Client *client; + struct ClientContext *cli_ctx; }; @@ -120,6 +1877,16 @@ struct ClientContext */ struct ReplyCls *rep_cls_head; struct ReplyCls *rep_cls_tail; + + /** + * @brief How many updates this client expects to receive. + */ + int64_t view_updates_left; + + /** + * The client handle to send the reply to + */ + struct GNUNET_SERVICE_Client *client; }; /** @@ -153,7 +1920,24 @@ static struct RPS_Sampler *client_sampler; /** * Name to log view to */ -static char *file_name_view_log; +static const char *file_name_view_log; + +#ifdef TO_FILE +/** + * Name to log number of observed peers to + */ +static const char *file_name_observed_log; + +/** + * @brief Count the observed peers + */ +static uint32_t num_observed_peers; + +/** + * @brief Multipeermap (ab-) used to count unique peer_ids + */ +static struct GNUNET_CONTAINER_MultiPeerMap *observed_unique_peers; +#endif /* TO_FILE */ /** * The size of sampler we need to be able to satisfy the client's need @@ -165,9 +1949,30 @@ static unsigned int sampler_size_client_need; * The size of sampler we need to be able to satisfy the Brahms protocol's * need of random peers. * - * This is one minimum size the sampler grows to. + * This is one minimum size the sampler grows to. + */ +static unsigned int sampler_size_est_need; + +/** + * @brief This is the minimum estimate used as sampler size. + * + * It is configured by the user. + */ +static unsigned int sampler_size_est_min; + +/** + * @brief This is the estimate used as view size. + * + * It is initialised with the minimum + */ +static unsigned int view_size_est_need; + +/** + * @brief This is the minimum estimate used as view size. + * + * It is configured by the user. */ -static unsigned int sampler_size_est_need; +static unsigned int view_size_est_min; /** * Percentage of total peer number in the view @@ -211,6 +2016,11 @@ static struct GNUNET_NSE_Handle *nse; */ static struct GNUNET_CADET_Handle *cadet_handle; +/** + * @brief Port to communicate to other peers. + */ +static struct GNUNET_CADET_Port *cadet_port; + /** * Handler to PEERINFO. */ @@ -394,7 +2204,7 @@ rem_from_list (struct GNUNET_PeerIdentity **peer_list, { if (i < *list_size -1) { /* Not at the last entry -- shift peers left */ - GNUNET_memcpy (&tmp[i], &tmp[i +1], + memmove (&tmp[i], &tmp[i +1], ((*list_size) - i -1) * sizeof (struct GNUNET_PeerIdentity)); } /* Remove last entry (should be now useless PeerID) */ @@ -476,6 +2286,12 @@ insert_in_view (const struct GNUNET_PeerIdentity *peer) return View_put (peer); } +/** + * @brief sends updates to clients that are interested + */ +static void +clients_notify_view_update (void); + /** * Put random peer from sampler into the view as history update. */ @@ -493,6 +2309,7 @@ hist_update (void *cls, "+%s\t(hist)", GNUNET_i2s_full (ids)); } + clients_notify_view_update(); } @@ -659,6 +2476,7 @@ send_pull_reply (const struct GNUNET_PeerIdentity *peer_id, send_size * sizeof (struct GNUNET_PeerIdentity)); Peers_send_message (peer_id, ev, "PULL REPLY"); + GNUNET_STATISTICS_update(stats, "# pull reply send issued", 1, GNUNET_NO); } @@ -710,6 +2528,21 @@ insert_in_sampler (void *cls, * messages to it */ //Peers_indicate_sending_intention (peer); } + #ifdef TO_FILE + num_observed_peers++; + GNUNET_CONTAINER_multipeermap_put + (observed_unique_peers, + peer, + NULL, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY); + uint32_t num_observed_unique_peers = GNUNET_CONTAINER_multipeermap_size ( + observed_unique_peers); + to_file (file_name_observed_log, + "%" PRIu32 " %" PRIu32 " %f\n", + num_observed_peers, + num_observed_unique_peers, + 1.0*num_observed_unique_peers/num_observed_peers) + #endif /* TO_FILE */ } /** @@ -792,11 +2625,14 @@ clean_peer (const struct GNUNET_PeerIdentity *peer) { if (GNUNET_NO == check_sending_channel_needed (peer)) { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Going to remove send channel to peer %s\n", + GNUNET_i2s (peer)); #ifdef ENABLE_MALICIOUS if (0 != GNUNET_CRYPTO_cmp_peer_identity (&attacked_peer, peer)) - Peers_destroy_sending_channel (peer); + (void) Peers_destroy_sending_channel (peer); #else /* ENABLE_MALICIOUS */ - Peers_destroy_sending_channel (peer); + (void) Peers_destroy_sending_channel (peer); #endif /* ENABLE_MALICIOUS */ } @@ -805,12 +2641,15 @@ clean_peer (const struct GNUNET_PeerIdentity *peer) (GNUNET_NO == CustomPeerMap_contains_peer (push_map, peer)) && (GNUNET_NO == CustomPeerMap_contains_peer (push_map, peer)) && (0 == RPS_sampler_count_id (prot_sampler, peer)) && - (0 == RPS_sampler_count_id (client_sampler, peer)) ) - { /* We can safely remov this peer */ + (0 == RPS_sampler_count_id (client_sampler, peer)) && + (GNUNET_NO != Peers_check_removable (peer)) ) + { /* We can safely remove this peer */ + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Going to remove peer %s\n", + GNUNET_i2s (peer)); remove_peer (peer); return; } - Peers_clean_peer (peer); } /** @@ -818,6 +2657,8 @@ clean_peer (const struct GNUNET_PeerIdentity *peer) * * Removes peer completely from our knowledge if the send_channel was destroyed * Otherwise simply delete the recv_channel + * Also check if the knowledge about this peer is still needed. + * If not, remove this peer from our knowledge. * * @param cls The closure * @param channel The channel being closed @@ -825,30 +2666,49 @@ clean_peer (const struct GNUNET_PeerIdentity *peer) */ static void cleanup_destroyed_channel (void *cls, - const struct GNUNET_CADET_Channel *channel, - void *channel_ctx) + const struct GNUNET_CADET_Channel *channel) { - struct GNUNET_PeerIdentity *peer; + struct GNUNET_PeerIdentity *peer = cls; + uint32_t *channel_flag; + struct PeerContext *peer_ctx; - peer = (struct GNUNET_PeerIdentity *) GNUNET_CADET_channel_get_info ( - (struct GNUNET_CADET_Channel *) channel, GNUNET_CADET_OPTION_PEER); - // FIXME wait for cadet to change this function + GNUNET_assert (NULL != peer); if (GNUNET_NO == Peers_check_peer_known (peer)) { /* We don't know a context to that peer */ LOG (GNUNET_ERROR_TYPE_WARNING, "channel (%s) without associated context was destroyed\n", GNUNET_i2s (peer)); + GNUNET_free (peer); return; } + peer_ctx = get_peer_ctx (peer); + if (GNUNET_YES == Peers_check_channel_role (peer, channel, Peers_CHANNEL_ROLE_RECEIVING)) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Callback on destruction of recv-channel was called (%s)\n", + GNUNET_i2s (peer)); + set_channel_flag (peer_ctx->recv_channel_flags, Peers_CHANNEL_DESTROING); + } else if (GNUNET_YES == Peers_check_channel_role (peer, channel, Peers_CHANNEL_ROLE_SENDING)) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Callback on destruction of send-channel was called (%s)\n", + GNUNET_i2s (peer)); + set_channel_flag (peer_ctx->send_channel_flags, Peers_CHANNEL_DESTROING); + } else { + LOG (GNUNET_ERROR_TYPE_ERROR, + "Channel to be destroyed has is neither sending nor receiving role\n"); + } + if (GNUNET_YES == Peers_check_peer_flag (peer, Peers_TO_DESTROY)) { /* We are in the middle of removing that peer from our knowledge. In this case simply make sure that the channels are cleaned. */ - Peers_cleanup_destroyed_channel (cls, channel, channel_ctx); + Peers_cleanup_destroyed_channel (cls, channel); to_file (file_name_view_log, "-%s\t(cleanup channel, ourself)", GNUNET_i2s_full (peer)); + GNUNET_free (peer); return; } @@ -859,17 +2719,20 @@ cleanup_destroyed_channel (void *cls, * - ourselves -> cleaning send channel -> clean context * - other peer -> peer probably went down -> remove */ - if (GNUNET_YES == Peers_check_channel_flag (channel_ctx, Peers_CHANNEL_CLEAN)) + channel_flag = Peers_get_channel_flag (peer, Peers_CHANNEL_ROLE_SENDING); + if (GNUNET_YES == Peers_check_channel_flag (channel_flag, Peers_CHANNEL_CLEAN)) { /* We are about to clean the sending channel. Clean the respective * context */ - Peers_cleanup_destroyed_channel (cls, channel, channel_ctx); + Peers_cleanup_destroyed_channel (cls, channel); + GNUNET_free (peer); return; } else { /* Other peer destroyed our sending channel that he is supposed to keep * open. It probably went down. Remove it from our knowledge. */ - Peers_cleanup_destroyed_channel (cls, channel, channel_ctx); + Peers_cleanup_destroyed_channel (cls, channel); remove_peer (peer); + GNUNET_free (peer); return; } } @@ -880,18 +2743,21 @@ cleanup_destroyed_channel (void *cls, * - ourselves -> peer tried to establish channel twice -> clean context * - other peer -> peer doesn't want to send us data -> clean */ + channel_flag = Peers_get_channel_flag (peer, Peers_CHANNEL_ROLE_RECEIVING); if (GNUNET_YES == - Peers_check_channel_flag (channel_ctx, Peers_CHANNEL_ESTABLISHED_TWICE)) + Peers_check_channel_flag (channel_flag, Peers_CHANNEL_ESTABLISHED_TWICE)) { /* Other peer tried to establish a channel to us twice. We do not accept * that. Clean the context. */ - Peers_cleanup_destroyed_channel (cls, channel, channel_ctx); + Peers_cleanup_destroyed_channel (cls, channel); + GNUNET_free (peer); return; } else { /* Other peer doesn't want to send us data anymore. We are free to clean * it. */ - Peers_cleanup_destroyed_channel (cls, channel, channel_ctx); + Peers_cleanup_destroyed_channel (cls, channel); clean_peer (peer); + GNUNET_free (peer); return; } } @@ -900,6 +2766,7 @@ cleanup_destroyed_channel (void *cls, LOG (GNUNET_ERROR_TYPE_WARNING, "Destroyed channel is neither sending nor receiving channel\n"); } + GNUNET_free (peer); } /*********************************************************************** @@ -911,9 +2778,12 @@ destroy_reply_cls (struct ReplyCls *rep_cls) { struct ClientContext *cli_ctx; - cli_ctx = GNUNET_SERVER_client_get_user_context (rep_cls->client, - struct ClientContext); + cli_ctx = rep_cls->cli_ctx; GNUNET_assert (NULL != cli_ctx); + if (NULL != rep_cls->req_handle) + { + RPS_sampler_request_cancel (rep_cls->req_handle); + } GNUNET_CONTAINER_DLL_remove (cli_ctx->rep_cls_head, cli_ctx->rep_cls_tail, rep_cls); @@ -925,10 +2795,6 @@ static void destroy_cli_ctx (struct ClientContext *cli_ctx) { GNUNET_assert (NULL != cli_ctx); - if (NULL != cli_ctx->mq) - { - GNUNET_MQ_destroy (cli_ctx->mq); - } if (NULL != cli_ctx->rep_cls_head) { LOG (GNUNET_ERROR_TYPE_WARNING, @@ -966,12 +2832,17 @@ nse_callback (void *cls, estimate = pow (estimate, 1.0 / 3); // TODO add if std_dev is a number // estimate += (std_dev * scale); - if (2 < ceil (estimate)) + if (view_size_est_min < ceil (estimate)) { LOG (GNUNET_ERROR_TYPE_DEBUG, "Changing estimate to %f\n", estimate); sampler_size_est_need = estimate; + view_size_est_need = estimate; } else + { LOG (GNUNET_ERROR_TYPE_DEBUG, "Not using estimate %f\n", estimate); + //sampler_size_est_need = view_size_est_min; + view_size_est_need = view_size_est_min; + } /* If the NSE has changed adapt the lists accordingly */ resize_wrapper (prot_sampler, sampler_size_est_need); @@ -989,10 +2860,10 @@ client_respond (void *cls, struct GNUNET_PeerIdentity *peer_ids, uint32_t num_peers) { + struct ReplyCls *reply_cls = cls; uint32_t i; struct GNUNET_MQ_Envelope *ev; struct GNUNET_RPS_CS_ReplyMessage *out_msg; - struct ReplyCls *reply_cls = (struct ReplyCls *) cls; uint32_t size_needed; struct ClientContext *cli_ctx; @@ -1011,7 +2882,7 @@ client_respond (void *cls, size_needed = sizeof (struct GNUNET_RPS_CS_ReplyMessage) + num_peers * sizeof (struct GNUNET_PeerIdentity); - GNUNET_assert (GNUNET_SERVER_MAX_MESSAGE_SIZE >= size_needed); + GNUNET_assert (GNUNET_MAX_MESSAGE_SIZE >= size_needed); ev = GNUNET_MQ_msg_extra (out_msg, num_peers * sizeof (struct GNUNET_PeerIdentity), @@ -1024,9 +2895,9 @@ client_respond (void *cls, num_peers * sizeof (struct GNUNET_PeerIdentity)); GNUNET_free (peer_ids); - cli_ctx = GNUNET_SERVER_client_get_user_context (reply_cls->client, - struct ClientContext); + cli_ctx = reply_cls->cli_ctx; GNUNET_assert (NULL != cli_ctx); + reply_cls->req_handle = NULL; destroy_reply_cls (reply_cls); GNUNET_MQ_send (cli_ctx->mq, ev); } @@ -1036,32 +2907,27 @@ client_respond (void *cls, * Handle RPS request from the client. * * @param cls closure - * @param client identification of the client * @param message the actual message */ static void handle_client_request (void *cls, - struct GNUNET_SERVER_Client *client, - const struct GNUNET_MessageHeader *message) + const struct GNUNET_RPS_CS_RequestMessage *msg) { - struct GNUNET_RPS_CS_RequestMessage *msg; + struct ClientContext *cli_ctx = cls; uint32_t num_peers; uint32_t size_needed; struct ReplyCls *reply_cls; uint32_t i; - struct ClientContext *cli_ctx; - - msg = (struct GNUNET_RPS_CS_RequestMessage *) message; num_peers = ntohl (msg->num_peers); size_needed = sizeof (struct GNUNET_RPS_CS_RequestMessage) + num_peers * sizeof (struct GNUNET_PeerIdentity); - if (GNUNET_SERVER_MAX_MESSAGE_SIZE < size_needed) + if (GNUNET_MAX_MESSAGE_SIZE < size_needed) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Message received from client has size larger than expected\n"); - GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); + GNUNET_SERVICE_client_drop (cli_ctx->client); return; } @@ -1074,19 +2940,17 @@ handle_client_request (void *cls, reply_cls = GNUNET_new (struct ReplyCls); reply_cls->id = ntohl (msg->id); - reply_cls->client = client; + reply_cls->cli_ctx = cli_ctx; reply_cls->req_handle = RPS_sampler_get_n_rand_peers (client_sampler, client_respond, reply_cls, num_peers); - cli_ctx = GNUNET_SERVER_client_get_user_context (client, struct ClientContext); GNUNET_assert (NULL != cli_ctx); GNUNET_CONTAINER_DLL_insert (cli_ctx->rep_cls_head, cli_ctx->rep_cls_tail, reply_cls); - GNUNET_SERVER_receive_done (client, - GNUNET_OK); + GNUNET_SERVICE_client_continue (cli_ctx->client); } @@ -1094,20 +2958,15 @@ handle_client_request (void *cls, * @brief Handle a message that requests the cancellation of a request * * @param cls unused - * @param client the client that requests the cancellation * @param message the message containing the id of the request */ static void handle_client_request_cancel (void *cls, - struct GNUNET_SERVER_Client *client, - const struct GNUNET_MessageHeader *message) + const struct GNUNET_RPS_CS_RequestCancelMessage *msg) { - struct GNUNET_RPS_CS_RequestCancelMessage *msg = - (struct GNUNET_RPS_CS_RequestCancelMessage *) message; - struct ClientContext *cli_ctx; + struct ClientContext *cli_ctx = cls; struct ReplyCls *rep_cls; - cli_ctx = GNUNET_SERVER_client_get_user_context (client, struct ClientContext); GNUNET_assert (NULL != cli_ctx); GNUNET_assert (NULL != cli_ctx->rep_cls_head); rep_cls = cli_ctx->rep_cls_head; @@ -1118,10 +2977,35 @@ handle_client_request_cancel (void *cls, (rep_cls->id != ntohl (msg->id)) ) rep_cls = rep_cls->next; GNUNET_assert (rep_cls->id == ntohl (msg->id)); - RPS_sampler_request_cancel (rep_cls->req_handle); destroy_reply_cls (rep_cls); - GNUNET_SERVER_receive_done (client, - GNUNET_OK); + GNUNET_SERVICE_client_continue (cli_ctx->client); +} + + +/** + * @brief This function is called, when the client seeds peers. + * It verifies that @a msg is well-formed. + * + * @param cls the closure (#ClientContext) + * @param msg the message + * @return #GNUNET_OK if @a msg is well-formed + */ +static int +check_client_seed (void *cls, const struct GNUNET_RPS_CS_SeedMessage *msg) +{ + struct ClientContext *cli_ctx = cls; + uint16_t msize = ntohs (msg->header.size); + uint32_t num_peers = ntohl (msg->num_peers); + + msize -= sizeof (struct GNUNET_RPS_CS_SeedMessage); + if ( (msize / sizeof (struct GNUNET_PeerIdentity) != num_peers) || + (msize % sizeof (struct GNUNET_PeerIdentity) != 0) ) + { + GNUNET_break (0); + GNUNET_SERVICE_client_drop (cli_ctx->client); + return GNUNET_SYSERR; + } + return GNUNET_OK; } @@ -1129,41 +3013,21 @@ handle_client_request_cancel (void *cls, * Handle seed from the client. * * @param cls closure - * @param client identification of the client * @param message the actual message */ static void handle_client_seed (void *cls, - struct GNUNET_SERVER_Client *client, - const struct GNUNET_MessageHeader *message) + const struct GNUNET_RPS_CS_SeedMessage *msg) { - struct GNUNET_RPS_CS_SeedMessage *in_msg; + struct ClientContext *cli_ctx = cls; struct GNUNET_PeerIdentity *peers; uint32_t num_peers; uint32_t i; - if (sizeof (struct GNUNET_RPS_CS_SeedMessage) > ntohs (message->size)) - { - GNUNET_SERVER_receive_done (client, - GNUNET_SYSERR); - GNUNET_break_op (0); - return; - } - - in_msg = (struct GNUNET_RPS_CS_SeedMessage *) message; - num_peers = ntohl (in_msg->num_peers); - peers = (struct GNUNET_PeerIdentity *) &in_msg[1]; + num_peers = ntohl (msg->num_peers); + peers = (struct GNUNET_PeerIdentity *) &msg[1]; //peers = GNUNET_new_array (num_peers, struct GNUNET_PeerIdentity); - //GNUNET_memcpy (peers, &in_msg[1], num_peers * sizeof (struct GNUNET_PeerIdentity)); - - if ((ntohs (message->size) - sizeof (struct GNUNET_RPS_CS_SeedMessage)) / - sizeof (struct GNUNET_PeerIdentity) != num_peers) - { - GNUNET_break_op (0); - GNUNET_SERVER_receive_done (client, - GNUNET_SYSERR); - return; - } + //GNUNET_memcpy (peers, &msg[1], num_peers * sizeof (struct GNUNET_PeerIdentity)); LOG (GNUNET_ERROR_TYPE_DEBUG, "Client seeded peers:\n"); @@ -1177,15 +3041,112 @@ handle_client_seed (void *cls, GNUNET_i2s (&peers[i])); got_peer (&peers[i]); - - //RPS_sampler_update (prot_sampler, &peers[i]); - //RPS_sampler_update (client_sampler, &peers[i]); } ////GNUNET_free (peers); - GNUNET_SERVER_receive_done (client, - GNUNET_OK); + GNUNET_SERVICE_client_continue (cli_ctx->client); +} + +/** + * @brief Send view to client + * + * @param cli_ctx the context of the client + * @param view_array the peerids of the view as array (can be empty) + * @param view_size the size of the view array (can be 0) + */ +void +send_view (const struct ClientContext *cli_ctx, + const struct GNUNET_PeerIdentity *view_array, + uint64_t view_size) +{ + struct GNUNET_MQ_Envelope *ev; + struct GNUNET_RPS_CS_DEBUG_ViewReply *out_msg; + + if (NULL == view_array) + { + view_size = View_size (); + view_array = View_get_as_array(); + } + + ev = GNUNET_MQ_msg_extra (out_msg, + view_size * sizeof (struct GNUNET_PeerIdentity), + GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_REPLY); + out_msg->num_peers = htonl (view_size); + + GNUNET_memcpy (&out_msg[1], + view_array, + view_size * sizeof (struct GNUNET_PeerIdentity)); + GNUNET_MQ_send (cli_ctx->mq, ev); +} + +/** + * @brief sends updates to clients that are interested + */ +static void +clients_notify_view_update (void) +{ + struct ClientContext *cli_ctx_iter; + uint64_t num_peers; + const struct GNUNET_PeerIdentity *view_array; + + num_peers = View_size (); + view_array = View_get_as_array(); + /* check size of view is small enough */ + if (GNUNET_MAX_MESSAGE_SIZE < num_peers) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "View is too big to send\n"); + return; + } + + for (cli_ctx_iter = cli_ctx_head; + NULL != cli_ctx_iter; + cli_ctx_iter = cli_ctx_head->next) + { + if (1 < cli_ctx_iter->view_updates_left) + { + /* Client wants to receive limited amount of updates */ + cli_ctx_iter->view_updates_left -= 1; + } else if (1 == cli_ctx_iter->view_updates_left) + { + /* Last update of view for client */ + cli_ctx_iter->view_updates_left = -1; + } else if (0 > cli_ctx_iter->view_updates_left) { + /* Client is not interested in updates */ + continue; + } + /* else _updates_left == 0 - infinite amount of updates */ + + /* send view */ + send_view (cli_ctx_iter, view_array, num_peers); + } +} + + +/** + * Handle RPS request from the client. + * + * @param cls closure + * @param message the actual message + */ +static void +handle_client_view_request (void *cls, + const struct GNUNET_RPS_CS_DEBUG_ViewRequest *msg) +{ + struct ClientContext *cli_ctx = cls; + uint64_t num_updates; + + num_updates = ntohl (msg->num_updates); + + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Client requested %" PRIu64 " updates of view.\n", + num_updates); + + GNUNET_assert (NULL != cli_ctx); + cli_ctx->view_updates_left = num_updates; + send_view (cli_ctx, NULL, 0); + GNUNET_SERVICE_client_continue (cli_ctx->client); } /** @@ -1195,18 +3156,18 @@ handle_client_seed (void *cls, * the channel is blocked for all other communication. * * @param cls Closure - * @param channel The channel the CHECK was received over - * @param channel_ctx The context associated with this channel * @param msg The message header */ -static int +static void handle_peer_check (void *cls, - struct GNUNET_CADET_Channel *channel, - void **channel_ctx, - const struct GNUNET_MessageHeader *msg) + const struct GNUNET_MessageHeader *msg) { - GNUNET_CADET_receive_done (channel); - return GNUNET_OK; + const struct GNUNET_PeerIdentity *peer = cls; + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Received CHECK_LIVE (%s)\n", GNUNET_i2s (peer)); + + GNUNET_break_op (Peers_check_peer_known (peer)); + GNUNET_CADET_receive_done (Peers_get_recv_channel (peer)); } /** @@ -1216,27 +3177,20 @@ handle_peer_check (void *cls, * in the temporary list for pushed PeerIDs. * * @param cls Closure - * @param channel The channel the PUSH was received over - * @param channel_ctx The context associated with this channel * @param msg The message header */ -static int +static void handle_peer_push (void *cls, - struct GNUNET_CADET_Channel *channel, - void **channel_ctx, - const struct GNUNET_MessageHeader *msg) + const struct GNUNET_MessageHeader *msg) { - const struct GNUNET_PeerIdentity *peer; + const struct GNUNET_PeerIdentity *peer = cls; // (check the proof of work (?)) - peer = (const struct GNUNET_PeerIdentity *) - GNUNET_CADET_channel_get_info (channel, GNUNET_CADET_OPTION_PEER); - // FIXME wait for cadet to change this function - LOG (GNUNET_ERROR_TYPE_DEBUG, "Received PUSH (%s)\n", GNUNET_i2s (peer)); + GNUNET_STATISTICS_update(stats, "# push message received", 1, GNUNET_NO); #ifdef ENABLE_MALICIOUS struct AttackedPeer *tmp_att_peer; @@ -1245,34 +3199,32 @@ handle_peer_push (void *cls, (3 == mal_type) ) { /* Try to maximise representation */ tmp_att_peer = GNUNET_new (struct AttackedPeer); - GNUNET_memcpy (&tmp_att_peer->peer_id, peer, sizeof (struct GNUNET_PeerIdentity)); + tmp_att_peer->peer_id = *peer; if (NULL == att_peer_set) att_peer_set = GNUNET_CONTAINER_multipeermap_create (1, GNUNET_NO); - if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (att_peer_set, - peer)) + if (GNUNET_NO == + GNUNET_CONTAINER_multipeermap_contains (att_peer_set, + peer)) { GNUNET_CONTAINER_DLL_insert (att_peers_head, att_peers_tail, tmp_att_peer); add_peer_array_to_set (peer, 1, att_peer_set); } - GNUNET_CADET_receive_done (channel); - return GNUNET_OK; } else if (2 == mal_type) - { /* We attack one single well-known peer - simply ignore */ - GNUNET_CADET_receive_done (channel); - return GNUNET_OK; + { + /* We attack one single well-known peer - simply ignore */ } #endif /* ENABLE_MALICIOUS */ /* Add the sending peer to the push_map */ CustomPeerMap_put (push_map, peer); - GNUNET_CADET_receive_done (channel); - return GNUNET_OK; + GNUNET_break_op (Peers_check_peer_known (peer)); + GNUNET_CADET_receive_done (Peers_get_recv_channel (peer)); } @@ -1282,33 +3234,23 @@ handle_peer_push (void *cls, * Reply with the view of PeerIDs. * * @param cls Closure - * @param channel The channel the PULL REQUEST was received over - * @param channel_ctx The context associated with this channel * @param msg The message header */ -static int +static void handle_peer_pull_request (void *cls, - struct GNUNET_CADET_Channel *channel, - void **channel_ctx, - const struct GNUNET_MessageHeader *msg) + const struct GNUNET_MessageHeader *msg) { - struct GNUNET_PeerIdentity *peer; + struct GNUNET_PeerIdentity *peer = cls; const struct GNUNET_PeerIdentity *view_array; - peer = (struct GNUNET_PeerIdentity *) - GNUNET_CADET_channel_get_info (channel, - GNUNET_CADET_OPTION_PEER); - // FIXME wait for cadet to change this function - LOG (GNUNET_ERROR_TYPE_DEBUG, "Received PULL REQUEST (%s)\n", GNUNET_i2s (peer)); + GNUNET_STATISTICS_update(stats, "# pull request message received", 1, GNUNET_NO); #ifdef ENABLE_MALICIOUS if (1 == mal_type || 3 == mal_type) { /* Try to maximise representation */ send_pull_reply (peer, mal_peers, num_mal_peers); - GNUNET_CADET_receive_done (channel); - return GNUNET_OK; } else if (2 == mal_type) @@ -1317,101 +3259,92 @@ handle_peer_pull_request (void *cls, { send_pull_reply (peer, mal_peers, num_mal_peers); } - GNUNET_CADET_receive_done (channel); - return GNUNET_OK; } #endif /* ENABLE_MALICIOUS */ + GNUNET_break_op (Peers_check_peer_known (peer)); + GNUNET_CADET_receive_done (Peers_get_recv_channel (peer)); view_array = View_get_as_array (); - send_pull_reply (peer, view_array, View_size ()); - - GNUNET_CADET_receive_done (channel); - return GNUNET_OK; } /** - * Handle PULL REPLY message from another peer. - * * Check whether we sent a corresponding request and * whether this reply is the first one. * * @param cls Closure - * @param channel The channel the PUSH was received over - * @param channel_ctx The context associated with this channel * @param msg The message header */ static int -handle_peer_pull_reply (void *cls, - struct GNUNET_CADET_Channel *channel, - void **channel_ctx, - const struct GNUNET_MessageHeader *msg) +check_peer_pull_reply (void *cls, + const struct GNUNET_RPS_P2P_PullReplyMessage *msg) { - struct GNUNET_RPS_P2P_PullReplyMessage *in_msg; - struct GNUNET_PeerIdentity *peers; - struct GNUNET_PeerIdentity *sender; - uint32_t i; -#ifdef ENABLE_MALICIOUS - struct AttackedPeer *tmp_att_peer; -#endif /* ENABLE_MALICIOUS */ + struct GNUNET_PeerIdentity *sender = cls; - /* Check for protocol violation */ - if (sizeof (struct GNUNET_RPS_P2P_PullReplyMessage) > ntohs (msg->size)) + if (sizeof (struct GNUNET_RPS_P2P_PullReplyMessage) > ntohs (msg->header.size)) { GNUNET_break_op (0); - GNUNET_CADET_receive_done (channel); return GNUNET_SYSERR; } - in_msg = (struct GNUNET_RPS_P2P_PullReplyMessage *) msg; - if ((ntohs (msg->size) - sizeof (struct GNUNET_RPS_P2P_PullReplyMessage)) / - sizeof (struct GNUNET_PeerIdentity) != ntohl (in_msg->num_peers)) + if ((ntohs (msg->header.size) - sizeof (struct GNUNET_RPS_P2P_PullReplyMessage)) / + sizeof (struct GNUNET_PeerIdentity) != ntohl (msg->num_peers)) { LOG (GNUNET_ERROR_TYPE_ERROR, "message says it sends %" PRIu32 " peers, have space for %lu peers\n", - ntohl (in_msg->num_peers), - (ntohs (msg->size) - sizeof (struct GNUNET_RPS_P2P_PullReplyMessage)) / + ntohl (msg->num_peers), + (ntohs (msg->header.size) - sizeof (struct GNUNET_RPS_P2P_PullReplyMessage)) / sizeof (struct GNUNET_PeerIdentity)); GNUNET_break_op (0); - GNUNET_CADET_receive_done (channel); return GNUNET_SYSERR; } - // Guess simply casting isn't the nicest way... - // FIXME wait for cadet to change this function - sender = (struct GNUNET_PeerIdentity *) - GNUNET_CADET_channel_get_info (channel, GNUNET_CADET_OPTION_PEER); - - LOG (GNUNET_ERROR_TYPE_DEBUG, "Received PULL REPLY (%s)\n", GNUNET_i2s (sender)); - if (GNUNET_YES != Peers_check_peer_flag (sender, Peers_PULL_REPLY_PENDING)) { LOG (GNUNET_ERROR_TYPE_WARNING, "Received a pull reply from a peer we didn't request one from!\n"); - GNUNET_CADET_receive_done (channel); GNUNET_break_op (0); - return GNUNET_OK; + return GNUNET_SYSERR; } + return GNUNET_OK; +} +/** + * Handle PULL REPLY message from another peer. + * + * @param cls Closure + * @param msg The message header + */ +static void +handle_peer_pull_reply (void *cls, + const struct GNUNET_RPS_P2P_PullReplyMessage *msg) +{ + const struct GNUNET_PeerIdentity *peers; + struct GNUNET_PeerIdentity *sender = cls; + uint32_t i; +#ifdef ENABLE_MALICIOUS + struct AttackedPeer *tmp_att_peer; +#endif /* ENABLE_MALICIOUS */ + + LOG (GNUNET_ERROR_TYPE_DEBUG, "Received PULL REPLY (%s)\n", GNUNET_i2s (sender)); + GNUNET_STATISTICS_update(stats, "# pull reply messages received", 1, GNUNET_NO); #ifdef ENABLE_MALICIOUS // We shouldn't even receive pull replies as we're not sending if (2 == mal_type) { - GNUNET_CADET_receive_done (channel); - return GNUNET_OK; } #endif /* ENABLE_MALICIOUS */ /* Do actual logic */ - peers = (struct GNUNET_PeerIdentity *) &in_msg[1]; + peers = (const struct GNUNET_PeerIdentity *) &msg[1]; LOG (GNUNET_ERROR_TYPE_DEBUG, "PULL REPLY received, got following %u peers:\n", - ntohl (in_msg->num_peers)); + ntohl (msg->num_peers)); - for (i = 0 ; i < ntohl (in_msg->num_peers) ; i++) + for (i = 0; i < ntohl (msg->num_peers); i++) { LOG (GNUNET_ERROR_TYPE_DEBUG, "%u. %s\n", @@ -1461,8 +3394,8 @@ handle_peer_pull_reply (void *cls, Peers_unset_peer_flag (sender, Peers_PULL_REPLY_PENDING); clean_peer (sender); - GNUNET_CADET_receive_done (channel); - return GNUNET_OK; + GNUNET_break_op (Peers_check_peer_known (sender)); + GNUNET_CADET_receive_done (Peers_get_recv_channel (sender)); } @@ -1503,7 +3436,7 @@ compute_rand_delay (struct GNUNET_TIME_Relative mean, * via multiplying round_interval with a 'fraction' (0 to value)/value */ rand_delay = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, max_rand_delay); - ret = GNUNET_TIME_relative_multiply (mean, rand_delay); + ret = GNUNET_TIME_relative_saturating_multiply (mean, rand_delay); ret = GNUNET_TIME_relative_divide (ret, max_rand_delay); ret = GNUNET_TIME_relative_add (ret, half_interval); @@ -1535,6 +3468,7 @@ send_pull_request (const struct GNUNET_PeerIdentity *peer) ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REQUEST); Peers_send_message (peer, ev, "PULL REQUEST"); + GNUNET_STATISTICS_update(stats, "# pull request send issued", 1, GNUNET_NO); } @@ -1554,6 +3488,7 @@ send_push (const struct GNUNET_PeerIdentity *peer_id) ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_RPS_PP_PUSH); Peers_send_message (peer_id, ev, "PUSH"); + GNUNET_STATISTICS_update(stats, "# push send issued", 1, GNUNET_NO); } @@ -1563,8 +3498,40 @@ do_round (void *cls); static void do_mal_round (void *cls); - #ifdef ENABLE_MALICIOUS + + +/** + * @brief This function is called, when the client tells us to act malicious. + * It verifies that @a msg is well-formed. + * + * @param cls the closure (#ClientContext) + * @param msg the message + * @return #GNUNET_OK if @a msg is well-formed + */ +static int +check_client_act_malicious (void *cls, + const struct GNUNET_RPS_CS_ActMaliciousMessage *msg) +{ + struct ClientContext *cli_ctx = cls; + uint16_t msize = ntohs (msg->header.size); + uint32_t num_peers = ntohl (msg->num_peers); + + msize -= sizeof (struct GNUNET_RPS_CS_ActMaliciousMessage); + if ( (msize / sizeof (struct GNUNET_PeerIdentity) != num_peers) || + (msize % sizeof (struct GNUNET_PeerIdentity) != 0) ) + { + LOG (GNUNET_ERROR_TYPE_ERROR, + "message says it sends %" PRIu32 " peers, have space for %lu peers\n", + ntohl (msg->num_peers), + (msize / sizeof (struct GNUNET_PeerIdentity))); + GNUNET_break (0); + GNUNET_SERVICE_client_drop (cli_ctx->client); + return GNUNET_SYSERR; + } + return GNUNET_OK; +} + /** * Turn RPS service to act malicious. * @@ -1574,51 +3541,29 @@ do_mal_round (void *cls); */ static void handle_client_act_malicious (void *cls, - struct GNUNET_SERVER_Client *client, - const struct GNUNET_MessageHeader *msg) + const struct GNUNET_RPS_CS_ActMaliciousMessage *msg) { - struct GNUNET_RPS_CS_ActMaliciousMessage *in_msg; + struct ClientContext *cli_ctx = cls; struct GNUNET_PeerIdentity *peers; uint32_t num_mal_peers_sent; uint32_t num_mal_peers_old; - /* Check for protocol violation */ - if (sizeof (struct GNUNET_RPS_CS_ActMaliciousMessage) > ntohs (msg->size)) - { - GNUNET_SERVER_receive_done (client, GNUNET_OK); - GNUNET_break_op (0); - } - - in_msg = (struct GNUNET_RPS_CS_ActMaliciousMessage *) msg; - if ((ntohs (msg->size) - sizeof (struct GNUNET_RPS_CS_ActMaliciousMessage)) / - sizeof (struct GNUNET_PeerIdentity) != ntohl (in_msg->num_peers)) - { - LOG (GNUNET_ERROR_TYPE_ERROR, - "message says it sends %" PRIu32 " peers, have space for %lu peers\n", - ntohl (in_msg->num_peers), - (ntohs (msg->size) - sizeof (struct GNUNET_RPS_CS_ActMaliciousMessage)) / - sizeof (struct GNUNET_PeerIdentity)); - GNUNET_SERVER_receive_done (client, GNUNET_OK); - GNUNET_break_op (0); - } - - /* Do actual logic */ peers = (struct GNUNET_PeerIdentity *) &msg[1]; - mal_type = ntohl (in_msg->type); + mal_type = ntohl (msg->type); if (NULL == mal_peer_set) mal_peer_set = GNUNET_CONTAINER_multipeermap_create (1, GNUNET_NO); LOG (GNUNET_ERROR_TYPE_DEBUG, "Now acting malicious type %" PRIu32 ", got %" PRIu32 " peers.\n", mal_type, - ntohl (in_msg->num_peers)); + ntohl (msg->num_peers)); if (1 == mal_type) { /* Try to maximise representation */ /* Add other malicious peers to those we already know */ - num_mal_peers_sent = ntohl (in_msg->num_peers); + num_mal_peers_sent = ntohl (msg->num_peers); num_mal_peers_old = num_mal_peers; GNUNET_array_grow (mal_peers, num_mal_peers, @@ -1642,7 +3587,7 @@ handle_client_act_malicious (void *cls, { /* Try to partition the network */ /* Add other malicious peers to those we already know */ - num_mal_peers_sent = ntohl (in_msg->num_peers) - 1; + num_mal_peers_sent = ntohl (msg->num_peers) - 1; num_mal_peers_old = num_mal_peers; GNUNET_array_grow (mal_peers, num_mal_peers, @@ -1662,7 +3607,7 @@ handle_client_act_malicious (void *cls, /* Store the one attacked peer */ GNUNET_memcpy (&attacked_peer, - &in_msg->attacked_peer, + &msg->attacked_peer, sizeof (struct GNUNET_PeerIdentity)); /* Set the flag of the attacked peer to valid to avoid problems */ if (GNUNET_NO == Peers_check_peer_known (&attacked_peer)) @@ -1689,9 +3634,9 @@ handle_client_act_malicious (void *cls, else { GNUNET_break (0); - GNUNET_SERVER_receive_done (client, GNUNET_OK); + GNUNET_SERVICE_client_continue (cli_ctx->client); } - GNUNET_SERVER_receive_done (client, GNUNET_OK); + GNUNET_SERVICE_client_continue (cli_ctx->client); } @@ -1824,7 +3769,6 @@ do_mal_round (void *cls) } #endif /* ENABLE_MALICIOUS */ - /** * Send out PUSHes and PULLs, possibly update #view, samplers. * @@ -1845,6 +3789,7 @@ do_round (void *cls) LOG (GNUNET_ERROR_TYPE_DEBUG, "Going to execute next round.\n"); + GNUNET_STATISTICS_update(stats, "# rounds", 1, GNUNET_NO); do_round_task = NULL; LOG (GNUNET_ERROR_TYPE_DEBUG, "Printing view:\n"); @@ -1912,9 +3857,10 @@ do_round (void *cls) /* Update view */ /* TODO see how many peers are in push-/pull- list! */ - if ((CustomPeerMap_size (push_map) <= alpha * View_size ()) && + if ((CustomPeerMap_size (push_map) <= alpha * view_size_est_need) && (0 < CustomPeerMap_size (push_map)) && (0 < CustomPeerMap_size (pull_map))) + //if (GNUNET_YES) // disable blocking temporarily { /* If conditions for update are fulfilled, update */ LOG (GNUNET_ERROR_TYPE_DEBUG, "Update of the view.\n"); @@ -1934,13 +3880,18 @@ do_round (void *cls) to_file (file_name_view_log, "--- emptied ---"); - first_border = GNUNET_MIN (ceil (alpha * sampler_size_est_need), + first_border = GNUNET_MIN (ceil (alpha * view_size_est_need), CustomPeerMap_size (push_map)); second_border = first_border + - GNUNET_MIN (floor (beta * sampler_size_est_need), + GNUNET_MIN (floor (beta * view_size_est_need), CustomPeerMap_size (pull_map)); final_size = second_border + - ceil ((1 - (alpha + beta)) * sampler_size_est_need); + ceil ((1 - (alpha + beta)) * view_size_est_need); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "first border: %" PRIu32 ", second border: %" PRIu32 ", final size: %"PRIu32 "\n", + first_border, + second_border, + final_size); /* Update view with peers received through PUSHes */ permut = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_STRONG, @@ -1988,17 +3939,45 @@ do_round (void *cls) to_file (file_name_view_log, "-%s", GNUNET_i2s_full (&peers_to_clean[i])); - Peers_clean_peer (&peers_to_clean[i]); + clean_peer (&peers_to_clean[i]); //peer_destroy_channel_send (sender); } GNUNET_array_grow (peers_to_clean, peers_to_clean_size, 0); - } - else - { + clients_notify_view_update(); + } else { LOG (GNUNET_ERROR_TYPE_DEBUG, "No update of the view.\n"); + GNUNET_STATISTICS_update(stats, "# rounds blocked", 1, GNUNET_NO); + if (CustomPeerMap_size (push_map) > alpha * View_size () && + !(0 >= CustomPeerMap_size (pull_map))) + GNUNET_STATISTICS_update(stats, "# rounds blocked - too many pushes", 1, GNUNET_NO); + if (CustomPeerMap_size (push_map) > alpha * View_size () && + (0 >= CustomPeerMap_size (pull_map))) + GNUNET_STATISTICS_update(stats, "# rounds blocked - too many pushes, no pull replies", 1, GNUNET_NO); + if (0 >= CustomPeerMap_size (push_map) && + !(0 >= CustomPeerMap_size (pull_map))) + GNUNET_STATISTICS_update(stats, "# rounds blocked - no pushes", 1, GNUNET_NO); + if (0 >= CustomPeerMap_size (push_map) && + (0 >= CustomPeerMap_size (pull_map))) + GNUNET_STATISTICS_update(stats, "# rounds blocked - no pushes, no pull replies", 1, GNUNET_NO); + if (0 >= CustomPeerMap_size (pull_map) && + CustomPeerMap_size (push_map) > alpha * View_size () && + 0 >= CustomPeerMap_size (push_map)) + GNUNET_STATISTICS_update(stats, "# rounds blocked - no pull replies", 1, GNUNET_NO); } // TODO independent of that also get some peers from CADET_get_peers()? + GNUNET_STATISTICS_set (stats, + "# peers in push map at end of round", + CustomPeerMap_size (push_map), + GNUNET_NO); + GNUNET_STATISTICS_set (stats, + "# peers in pull map at end of round", + CustomPeerMap_size (pull_map), + GNUNET_NO); + GNUNET_STATISTICS_set (stats, + "# peers in view at end of round", + View_size (), + GNUNET_NO); LOG (GNUNET_ERROR_TYPE_DEBUG, "Received %u pushes and %u pulls last round (alpha (%.2f) * view_size (%u) = %.2f)\n", @@ -2016,7 +3995,7 @@ do_round (void *cls) "Updating with peer %s from push list\n", GNUNET_i2s (update_peer)); insert_in_sampler (NULL, update_peer); - Peers_clean_peer (update_peer); /* This cleans only if it is not in the view */ + clean_peer (update_peer); /* This cleans only if it is not in the view */ //peer_destroy_channel_send (sender); } @@ -2027,7 +4006,7 @@ do_round (void *cls) GNUNET_i2s (CustomPeerMap_get_peer_by_index (pull_map, i))); insert_in_sampler (NULL, CustomPeerMap_get_peer_by_index (pull_map, i)); /* This cleans only if it is not in the view */ - Peers_clean_peer (CustomPeerMap_get_peer_by_index (pull_map, i)); + clean_peer (CustomPeerMap_get_peer_by_index (pull_map, i)); //peer_destroy_channel_send (sender); } @@ -2047,10 +4026,6 @@ do_round (void *cls) } -static void -rps_start (struct GNUNET_SERVER_Handle *server); - - /** * This is called from GNUNET_CADET_get_peers(). * @@ -2132,8 +4107,31 @@ process_peerinfo_peers (void *cls, static void shutdown_task (void *cls) { + struct ClientContext *client_ctx; + struct ReplyCls *reply_cls; + LOG (GNUNET_ERROR_TYPE_DEBUG, "RPS is going down\n"); + + /* Clean all clients */ + for (client_ctx = cli_ctx_head; + NULL != cli_ctx_head; + client_ctx = cli_ctx_head) + { + /* Clean pending requests to the sampler */ + for (reply_cls = client_ctx->rep_cls_head; + NULL != client_ctx->rep_cls_head; + reply_cls = client_ctx->rep_cls_head) + { + RPS_sampler_request_cancel (reply_cls->req_handle); + GNUNET_CONTAINER_DLL_remove (client_ctx->rep_cls_head, + client_ctx->rep_cls_tail, + reply_cls); + GNUNET_free (reply_cls); + } + GNUNET_CONTAINER_DLL_remove (cli_ctx_head, cli_ctx_tail, client_ctx); + GNUNET_free (client_ctx); + } GNUNET_PEERINFO_notify_cancel (peerinfo_notify_handle); GNUNET_PEERINFO_disconnect (peerinfo_handle); @@ -2148,13 +4146,24 @@ shutdown_task (void *cls) GNUNET_NSE_disconnect (nse); RPS_sampler_destroy (prot_sampler); RPS_sampler_destroy (client_sampler); + GNUNET_CADET_close_port (cadet_port); GNUNET_CADET_disconnect (cadet_handle); View_destroy (); CustomPeerMap_destroy (push_map); CustomPeerMap_destroy (pull_map); + if (NULL != stats) + { + GNUNET_STATISTICS_destroy (stats, GNUNET_NO); + stats = NULL; + } #ifdef ENABLE_MALICIOUS struct AttackedPeer *tmp_att_peer; - GNUNET_free (file_name_view_log); + /* it is ok to free this const during shutdown: */ + GNUNET_free ((char *) file_name_view_log); + #ifdef TO_FILE + GNUNET_free ((char *) file_name_observed_log); + GNUNET_CONTAINER_multipeermap_destroy (observed_unique_peers); + #endif /* TO_FILE */ GNUNET_array_grow (mal_peers, num_mal_peers, 0); if (NULL != mal_peer_set) GNUNET_CONTAINER_multipeermap_destroy (mal_peer_set); @@ -2170,115 +4179,75 @@ shutdown_task (void *cls) /** - * @brief Get informed about a connecting client. + * Handle client connecting to the service. * - * @param cls unused - * @param client the client that connects + * @param cls NULL + * @param client the new client + * @param mq the message queue of @a client + * @return @a client */ -static void -handle_client_connect (void *cls, - struct GNUNET_SERVER_Client *client) +static void * +client_connect_cb (void *cls, + struct GNUNET_SERVICE_Client *client, + struct GNUNET_MQ_Handle *mq) { struct ClientContext *cli_ctx; LOG (GNUNET_ERROR_TYPE_DEBUG, "Client connected\n"); if (NULL == client) - return; /* Server was destroyed before a client connected. Shutting down */ + return client; /* Server was destroyed before a client connected. Shutting down */ cli_ctx = GNUNET_new (struct ClientContext); - cli_ctx->mq = GNUNET_MQ_queue_for_server_client (client); - GNUNET_SERVER_client_set_user_context (client, cli_ctx); + cli_ctx->mq = GNUNET_SERVICE_client_get_mq (client); + cli_ctx->view_updates_left = -1; + cli_ctx->client = client; GNUNET_CONTAINER_DLL_insert (cli_ctx_head, cli_ctx_tail, cli_ctx); + return cli_ctx; } /** - * A client disconnected. Remove all of its data structure entries. + * Callback called when a client disconnected from the service * - * @param cls closure, NULL - * @param client identification of the client + * @param cls closure for the service + * @param c the client that disconnected + * @param internal_cls should be equal to @a c */ static void -handle_client_disconnect (void *cls, - struct GNUNET_SERVER_Client *client) +client_disconnect_cb (void *cls, + struct GNUNET_SERVICE_Client *client, + void *internal_cls) { - struct ClientContext *cli_ctx; + struct ClientContext *cli_ctx = internal_cls; + GNUNET_assert (client == cli_ctx->client); if (NULL == client) - {/* shutdown task */ + {/* shutdown task - destroy all clients */ while (NULL != cli_ctx_head) destroy_cli_ctx (cli_ctx_head); } else - { - cli_ctx = GNUNET_SERVER_client_get_user_context (client, struct ClientContext); + { /* destroy this client */ + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Client disconnected. Destroy its context.\n"); destroy_cli_ctx (cli_ctx); } } /** - * Actually start the service. - */ - static void -rps_start (struct GNUNET_SERVER_Handle *server) -{ - static const struct GNUNET_SERVER_MessageHandler handlers[] = { - {&handle_client_request, NULL, GNUNET_MESSAGE_TYPE_RPS_CS_REQUEST, - sizeof (struct GNUNET_RPS_CS_RequestMessage)}, - {&handle_client_request_cancel, NULL, GNUNET_MESSAGE_TYPE_RPS_CS_REQUEST_CANCEL, - sizeof (struct GNUNET_RPS_CS_RequestCancelMessage)}, - {&handle_client_seed, NULL, GNUNET_MESSAGE_TYPE_RPS_CS_SEED, 0}, - #ifdef ENABLE_MALICIOUS - {&handle_client_act_malicious, NULL, GNUNET_MESSAGE_TYPE_RPS_ACT_MALICIOUS , 0}, - #endif /* ENABLE_MALICIOUS */ - {NULL, NULL, 0, 0} - }; - - GNUNET_SERVER_add_handlers (server, handlers); - GNUNET_SERVER_connect_notify (server, - &handle_client_connect, - NULL); - GNUNET_SERVER_disconnect_notify (server, - &handle_client_disconnect, - NULL); - LOG (GNUNET_ERROR_TYPE_INFO, "Ready to receive requests from clients\n"); - - - do_round_task = GNUNET_SCHEDULER_add_now (&do_round, NULL); - LOG (GNUNET_ERROR_TYPE_DEBUG, "Scheduled first round\n"); - - GNUNET_SCHEDULER_add_shutdown (&shutdown_task, - NULL); -} - - -/** - * Process statistics requests. + * Handle random peer sampling clients. * * @param cls closure - * @param server the initialized server * @param c configuration to use + * @param service the initialized service */ static void run (void *cls, - struct GNUNET_SERVER_Handle *server, - const struct GNUNET_CONFIGURATION_Handle *c) -{ - static const struct GNUNET_CADET_MessageHandler cadet_handlers[] = { - {&handle_peer_check , GNUNET_MESSAGE_TYPE_RPS_PP_CHECK_LIVE, - sizeof (struct GNUNET_MessageHeader)}, - {&handle_peer_push , GNUNET_MESSAGE_TYPE_RPS_PP_PUSH, - sizeof (struct GNUNET_MessageHeader)}, - {&handle_peer_pull_request, GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REQUEST, - sizeof (struct GNUNET_MessageHeader)}, - {&handle_peer_pull_reply , GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REPLY, 0}, - {NULL, 0, 0} - }; - - int size; - int out_size; + const struct GNUNET_CONFIGURATION_Handle *c, + struct GNUNET_SERVICE_Handle *service) +{ char* fn_valid_peers; struct GNUNET_HashCode port; @@ -2311,15 +4280,17 @@ run (void *cls, /* Get initial size of sampler/view from the configuration */ if (GNUNET_OK != - GNUNET_CONFIGURATION_get_value_number (cfg, "RPS", "INITSIZE", - (long long unsigned int *) &sampler_size_est_need)) + GNUNET_CONFIGURATION_get_value_number (cfg, "RPS", "MINSIZE", + (long long unsigned int *) &sampler_size_est_min)) { GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, - "RPS", "INITSIZE"); + "RPS", "MINSIZE"); GNUNET_SCHEDULER_shutdown (); return; } - LOG (GNUNET_ERROR_TYPE_DEBUG, "INITSIZE is %u\n", sampler_size_est_need); + sampler_size_est_need = sampler_size_est_min; + view_size_est_min = sampler_size_est_min; + LOG (GNUNET_ERROR_TYPE_DEBUG, "MINSIZE is %u\n", sampler_size_est_min); if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, @@ -2332,30 +4303,14 @@ run (void *cls, } - View_create (4); + View_create (view_size_est_min); /* file_name_view_log */ - if (GNUNET_OK != GNUNET_DISK_directory_create ("/tmp/rps/")) - { - LOG (GNUNET_ERROR_TYPE_WARNING, - "Failed to create directory /tmp/rps/\n"); - } - - size = (14 + strlen (GNUNET_i2s_full (&own_identity)) + 1) * sizeof (char); - file_name_view_log = GNUNET_malloc (size); - out_size = GNUNET_snprintf (file_name_view_log, - size, - "/tmp/rps/view-%s", - GNUNET_i2s_full (&own_identity)); - if (size < out_size || - 0 > out_size) - { - LOG (GNUNET_ERROR_TYPE_WARNING, - "Failed to write string to buffer (size: %i, out_size: %i)\n", - size, - out_size); - } - + file_name_view_log = store_prefix_file_name (&own_identity, "view"); + #ifdef TO_FILE + file_name_observed_log = store_prefix_file_name (&own_identity, "observed"); + observed_unique_peers = GNUNET_CONTAINER_multipeermap_create (1, GNUNET_NO); + #endif /* TO_FILE */ /* connect to NSE */ nse = GNUNET_NSE_connect (cfg, nse_callback, NULL); @@ -2366,17 +4321,39 @@ run (void *cls, /* Initialise cadet */ - cadet_handle = GNUNET_CADET_connect (cfg, - cls, - &cleanup_destroyed_channel, - cadet_handlers); + /* There exists a copy-paste-clone in get_channel() */ + struct GNUNET_MQ_MessageHandler cadet_handlers[] = { + GNUNET_MQ_hd_fixed_size (peer_check, + GNUNET_MESSAGE_TYPE_RPS_PP_CHECK_LIVE, + struct GNUNET_MessageHeader, + NULL), + GNUNET_MQ_hd_fixed_size (peer_push, + GNUNET_MESSAGE_TYPE_RPS_PP_PUSH, + struct GNUNET_MessageHeader, + NULL), + GNUNET_MQ_hd_fixed_size (peer_pull_request, + GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REQUEST, + struct GNUNET_MessageHeader, + NULL), + GNUNET_MQ_hd_var_size (peer_pull_reply, + GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REPLY, + struct GNUNET_RPS_P2P_PullReplyMessage, + NULL), + GNUNET_MQ_handler_end () + }; + + cadet_handle = GNUNET_CADET_connect (cfg); GNUNET_assert (NULL != cadet_handle); GNUNET_CRYPTO_hash (GNUNET_APPLICATION_PORT_RPS, strlen (GNUNET_APPLICATION_PORT_RPS), &port); - GNUNET_CADET_open_port (cadet_handle, - &port, - &Peers_handle_inbound_channel, cls); + cadet_port = GNUNET_CADET_open_port (cadet_handle, + &port, + &Peers_handle_inbound_channel, /* Connect handler */ + NULL, /* cls */ + NULL, /* WindowSize handler */ + cleanup_destroyed_channel, /* Disconnect handler */ + cadet_handlers); peerinfo_handle = GNUNET_PEERINFO_connect (cfg); @@ -2387,7 +4364,7 @@ run (void *cls, struct GNUNET_TIME_Relative half_round_interval; struct GNUNET_TIME_Relative max_round_interval; - half_round_interval = GNUNET_TIME_relative_multiply (round_interval, .5); + half_round_interval = GNUNET_TIME_relative_divide (round_interval, 2); max_round_interval = GNUNET_TIME_relative_add (round_interval, half_round_interval); prot_sampler = RPS_sampler_init (sampler_size_est_need, max_round_interval); @@ -2410,26 +4387,49 @@ run (void *cls, process_peerinfo_peers, NULL); - rps_start (server); + LOG (GNUNET_ERROR_TYPE_INFO, "Ready to receive requests from clients\n"); + + do_round_task = GNUNET_SCHEDULER_add_now (&do_round, NULL); + LOG (GNUNET_ERROR_TYPE_DEBUG, "Scheduled first round\n"); + + GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL); + stats = GNUNET_STATISTICS_create ("rps", cfg); + } /** - * The main function for the rps service. - * - * @param argc number of arguments from the command line - * @param argv command line arguments - * @return 0 ok, 1 on error + * Define "main" method using service macro. */ -int -main (int argc, char *const *argv) -{ - return (GNUNET_OK == - GNUNET_SERVICE_run (argc, - argv, - "rps", - GNUNET_SERVICE_OPTION_NONE, - &run, NULL)) ? 0 : 1; -} +GNUNET_SERVICE_MAIN +("rps", + GNUNET_SERVICE_OPTION_NONE, + &run, + &client_connect_cb, + &client_disconnect_cb, + NULL, + GNUNET_MQ_hd_fixed_size (client_request, + GNUNET_MESSAGE_TYPE_RPS_CS_REQUEST, + struct GNUNET_RPS_CS_RequestMessage, + NULL), + GNUNET_MQ_hd_fixed_size (client_request_cancel, + GNUNET_MESSAGE_TYPE_RPS_CS_REQUEST_CANCEL, + struct GNUNET_RPS_CS_RequestCancelMessage, + NULL), + GNUNET_MQ_hd_var_size (client_seed, + GNUNET_MESSAGE_TYPE_RPS_CS_SEED, + struct GNUNET_RPS_CS_SeedMessage, + NULL), +#ifdef ENABLE_MALICIOUS + GNUNET_MQ_hd_var_size (client_act_malicious, + GNUNET_MESSAGE_TYPE_RPS_ACT_MALICIOUS, + struct GNUNET_RPS_CS_ActMaliciousMessage, + NULL), +#endif /* ENABLE_MALICIOUS */ + GNUNET_MQ_hd_fixed_size (client_view_request, + GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_REQUEST, + struct GNUNET_RPS_CS_DEBUG_ViewRequest, + NULL), + GNUNET_MQ_handler_end()); /* end of gnunet-service-rps.c */