From: Christian Grothoff Date: Tue, 27 Sep 2011 20:49:32 +0000 (+0000) Subject: fixes X-Git-Tag: initial-import-from-subversion-38251~16910 X-Git-Url: https://git.librecmc.org/?a=commitdiff_plain;h=2d10e77135a8db547c187c4aadcff8d1f1763412;p=oweals%2Fgnunet.git fixes --- diff --git a/src/dht/Makefile.am b/src/dht/Makefile.am index 147248234..d6045112b 100644 --- a/src/dht/Makefile.am +++ b/src/dht/Makefile.am @@ -15,21 +15,9 @@ if USE_COVERAGE endif lib_LTLIBRARIES = \ - libgnunetdht.la \ libgnunetdhtnew.la -libgnunetdht_la_SOURCES = \ - dht_api.c dht.h \ - dht_api_get_put.c \ - dht_api_find_peer.c -libgnunetdht_la_LIBADD = \ - $(top_builddir)/src/util/libgnunetutil.la \ - $(XLIB) -libgnunetdht_la_LDFLAGS = \ - $(GN_LIB_LDFLAGS) $(WINFLAGS) \ - -version-info 0:0:0 - libgnunetdhtnew_la_SOURCES = \ dht_api_new.c dht_new.h libgnunetdhtnew_la_LIBADD = \ @@ -44,11 +32,6 @@ bin_PROGRAMS = \ gnunet-dht-get \ gnunet-dht-put -if HAVE_MALICIOUS -noinst_PROGRAMS = \ - gnunet-dht-driver -endif - gnunet_service_dht_new_SOURCES = \ gnunet-service-dht-new.c gnunet-service-dht.h \ gnunet-service-dht_clients.c gnunet-service-dht_clients.h \ diff --git a/src/dht/dht.h b/src/dht/dht.h deleted file mode 100644 index 4832df490..000000000 --- a/src/dht/dht.h +++ /dev/null @@ -1,485 +0,0 @@ -/* - This file is part of GNUnet. - (C) 2001, 2002, 2003, 2004, 2009 Christian Grothoff (and other contributing authors) - - GNUnet is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published - by the Free Software Foundation; either version 3, or (at your - option) any later version. - - GNUnet is distributed in the hope that it will be useful, but - WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - General Public License for more details. - - You should have received a copy of the GNU General Public License - along with GNUnet; see the file COPYING. If not, write to the - Free Software Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. -*/ - -/** - * @author Christian Grothoff - * @author Nathan Evans - * @file dht/dht.h - */ - -#ifndef DHT_H_ -#define DHT_H_ - -#define DEBUG_DHT GNUNET_NO - -/** - * Add a unique ID to every request to make testing/profiling easier. - * Should NEVER be enabled in production and makes the DHT incompatible - * (since this changes the message format). - */ -#define HAVE_UID_FOR_TESTING GNUNET_NO - -/** - * Needs to be GNUNET_YES for logging to dhtlog to work! - */ -#define DEBUG_DHT_ROUTING GNUNET_YES - -/** - * Size of the bloom filter the DHT uses to filter peers. - */ -#define DHT_BLOOM_SIZE 128 - -/** - * Number of bits set per entry in the bloom filter for peers. - */ -#define DHT_BLOOM_K 6 - -/** - * How many requests to remember for forwarding responses. - */ -#define MAX_OUTSTANDING_FORWARDS 100 - -/** - * How long to remember requests so we can forward responses. - */ -#define DHT_FORWARD_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 5) - -/** - * Priority for routing results from other peers through - * the DHT. - */ -#define DHT_SEND_PRIORITY 4 - - -#define STAT_ROUTES "# DHT ROUTE Requests Seen" -#define STAT_ROUTE_FORWARDS "# DHT ROUTE Requests Forwarded" -#define STAT_ROUTE_FORWARDS_CLOSEST "# DHT ROUTE Requests Forwarded to Closest Known Peer" -#define STAT_RESULTS "# DHT ROUTE RESULT Requests Seen" -#define STAT_RESULTS_TO_CLIENT "# DHT ROUTE RESULT Sent to Client" -#define STAT_RESULT_FORWARDS "# DHT ROUTE RESULT Requests Forwarded" -#define STAT_GETS "# DHT GET Requests Handled" -#define STAT_PUTS "# DHT PUT Requests Handled" -#define STAT_PUTS_INSERTED "# DHT PUT Data Inserts" -#define STAT_FIND_PEER "# DHT FIND_PEER Requests Handled" -#define STAT_FIND_PEER_START "# DHT FIND_PEER Requests Initiated" -#define STAT_GET_START "# DHT GET Requests Initiated" -#define STAT_PUT_START "# DHT PUT Requests Initiated" -#define STAT_FIND_PEER_REPLY "# DHT FIND_PEER Responses Received" -#define STAT_GET_REPLY "# DHT GET Responses Received" -#define STAT_FIND_PEER_ANSWER "# DHT FIND_PEER Responses Initiated" -#define STAT_BLOOM_FIND_PEER "# DHT FIND_PEER Responses Ignored (bloom match)" -#define STAT_GET_RESPONSE_START "# DHT GET Responses Initiated" -#define STAT_HELLOS_PROVIDED "# HELLO Messages given to transport" -#define STAT_DISCONNECTS "# Disconnects received" -#define STAT_DUPLICATE_UID "# Duplicate UID's encountered (bad if any!)" -#define STAT_RECENT_SEEN "# recent requests seen again (routing loops, alternate paths)" -#define STAT_PEERS_KNOWN "# DHT Peers known" - - -/** - * FIXME: document. - */ -typedef void (*GNUNET_DHT_MessageReceivedHandler) (void *cls, - const struct - GNUNET_MessageHeader * msg); - - -/** - * FIXME: document. - */ -struct GNUNET_DHT_ControlMessage -{ - /** - * Type: GNUNET_MESSAGE_TYPE_DHT_CONTROL - */ - struct GNUNET_MessageHeader header; - - /** - * Command code of the message. - */ - uint16_t command; - - /** - * Variable parameter for the command. - */ - uint16_t variable; -}; - - -/** - * Message which indicates the DHT should cancel outstanding - * requests and discard any state. - */ -struct GNUNET_DHT_StopMessage -{ - /** - * Type: GNUNET_MESSAGE_TYPE_DHT_STOP - */ - struct GNUNET_MessageHeader header; - - /** - * Always zero. - */ - uint32_t reserved GNUNET_PACKED; - - /** - * Unique ID identifying this request - */ - uint64_t unique_id GNUNET_PACKED; - - /** - * Key of this request - */ - GNUNET_HashCode key; - -}; - - -/** - * Generic DHT message, indicates that a route request - * should be issued. - */ -struct GNUNET_DHT_RouteMessage -{ - /** - * Type: GNUNET_MESSAGE_TYPE_DHT_LOCAL_ROUTE - */ - struct GNUNET_MessageHeader header; - - /** - * Message options, actually an 'enum GNUNET_DHT_RouteOption' value. - */ - uint32_t options GNUNET_PACKED; - - /** - * Replication level for this message - */ - uint32_t desired_replication_level GNUNET_PACKED; - - /** - * For alignment, always zero. - */ - uint32_t reserved GNUNET_PACKED; - - /** - * The key to search for - */ - GNUNET_HashCode key; - - /** - * Unique ID identifying this request, if 0 then - * the client will not expect a response - */ - uint64_t unique_id GNUNET_PACKED; - - - /* GNUNET_MessageHeader *enc actual DHT message, copied to end of this dealy do */ - -}; - - -/** - * Generic local route result message - */ -struct GNUNET_DHT_RouteResultMessage -{ - /** - * Type: GNUNET_MESSAGE_TYPE_DHT_LOCAL_ROUTE_RESULT - */ - struct GNUNET_MessageHeader header; - - /** - * Number of peers recorded in the outgoing - * path from source to the final destination - * of this message. - */ - uint32_t outgoing_path_length GNUNET_PACKED; - - /** - * Unique ID identifying this request (necessary for - * client to compare to sent requests) - */ - uint64_t unique_id GNUNET_PACKED; - - /** - * The key that was searched for - */ - GNUNET_HashCode key; - - /* GNUNET_MessageHeader *enc actual DHT message, copied to end of this dealy do */ - - /* OUTGOING path */ -}; - - -/** - * Generic P2P DHT route message - */ -struct GNUNET_DHT_P2PRouteMessage -{ - /** - * Type: GNUNET_MESSAGE_TYPE_DHT_P2P_ROUTE - */ - struct GNUNET_MessageHeader header; - - /** - * Always zero. - */ - uint32_t reserved GNUNET_PACKED; - - /** - * Message options - */ - uint32_t options GNUNET_PACKED; - - /** - * Hop count - */ - uint32_t hop_count GNUNET_PACKED; - - /** - * Replication level for this message - */ - uint32_t desired_replication_level GNUNET_PACKED; - - /** - * Network size estimate - */ - uint32_t network_size GNUNET_PACKED; - - /** - * Generic route path length for a message in the - * DHT that arrived at a peer and generated - * a reply. Copied to the end of this message. - */ - uint32_t outgoing_path_length GNUNET_PACKED; - -#if HAVE_UID_FOR_TESTING - /** - * Unique ID identifying this request (may not be set) - */ - uint64_t unique_id GNUNET_PACKED; -#endif - - /** - * Bloomfilter (for peer identities) to stop circular routes - */ - char bloomfilter[DHT_BLOOM_SIZE]; - - /** - * The key to search for - */ - GNUNET_HashCode key; - - /* GNUNET_MessageHeader *enc actual DHT message, copied to end of this dealy do */ - - /* OUTGOING PATH */ - -}; - -/** - * Generic P2P route result - */ -struct GNUNET_DHT_P2PRouteResultMessage -{ - /** - * Type: GNUNET_MESSAGE_TYPE_DHT_P2P_ROUTE_RESULT - */ - struct GNUNET_MessageHeader header; - - /** - * Number of peers recorded in the path - * (inverse of the path the outgoing message took). - * These peer identities follow this message. - */ - uint32_t outgoing_path_length GNUNET_PACKED; - - /** - * Message options - */ - uint32_t options GNUNET_PACKED; - - /** - * Hop count - */ - uint32_t hop_count GNUNET_PACKED; - -#if HAVE_UID_FOR_TESTING - /** - * Unique ID identifying this request (may not be set) - */ - uint64_t unique_id GNUNET_PACKED; -#endif - - /** - * The key that was searched for - */ - GNUNET_HashCode key; - - /* GNUNET_MessageHeader *enc actual DHT message, copied to end of this dealy do */ - - /* OUTGOING PATH */ -}; - - -/** - * Message to insert data into the DHT, shared - * between api->server communication and P2P communication. - * The type must be different for the two purposes. - */ -struct GNUNET_DHT_PutMessage -{ - /** - * Type: GNUNET_MESSAGE_TYPE_DHT_PUT / GNUNET_MESSAGE_TYPE_DHT_P2P_PUT - */ - struct GNUNET_MessageHeader header; - - /** - * The type of data to insert. - */ - uint32_t type GNUNET_PACKED; - - /** - * How long should this data persist? - */ - struct GNUNET_TIME_AbsoluteNBO expiration; - - /* DATA copied to end of this message */ - -}; - - -/** - * Message to request data from the DHT, shared - * between P2P requests and local get requests. - * Main difference is that if the request comes in - * locally we need to remember it (for client response). - */ -struct GNUNET_DHT_GetMessage -{ - /** - * Type: GNUNET_MESSAGE_TYPE_DHT_GET / GNUNET_MESSAGE_TYPE_DHT_P2P_GET - */ - struct GNUNET_MessageHeader header; - - /** - * The type for the data for the GET request; actually an 'enum - * GNUNET_BLOCK_Type'. - */ - uint32_t type; - - /** - * Mutator used for the bloom filter (0 if no bf is used). - */ - uint32_t bf_mutator; - - /** - * Size of the eXtended query (xquery). - */ - uint16_t xquery_size; - - /** - * Size of the bloom filter. - */ - uint16_t bf_size; - - /* Followed by the xquery which has 'xquery_size' bytes */ - - /* Followed by the bloom filter (after xquery) with 'bf_size' bytes */ -}; - - -/** - * Generic DHT message, indicates that a route request - * should be issued, if coming from a client. Shared - * usage for api->server and P2P message passing. - */ -struct GNUNET_DHT_FindPeerMessage -{ - /** - * Type: GNUNET_MESSAGE_TYPE_DHT_FIND_PEER - */ - struct GNUNET_MessageHeader header; - - /** - * Bloomfilter to reduce find peer responses - */ - char bloomfilter[DHT_BLOOM_SIZE]; -}; - - -/** - * Message to return data either to the client API - * or to respond to a request received from another - * peer. Shared format, different types. - */ -struct GNUNET_DHT_GetResultMessage -{ - /** - * Type: GNUNET_MESSAGE_TYPE_DHT_GET_RESULT / GNUNET_MESSAGE_TYPE_DHT_P2P_GET_RESULT - */ - struct GNUNET_MessageHeader header; - - /** - * The type for the data for the GET request - * FIXME: use 32-bit types, as in block? What is this type exactly for? - */ - uint16_t type; - - /** - * The number of peer identities appended to the end of this - * message. - */ - uint16_t put_path_length; - - /** - * When does this entry expire? - */ - struct GNUNET_TIME_AbsoluteNBO expiration; - - /* OUTGOING path copied to end of this message */ - /* DATA result copied to end of this message */ - -}; - -/** - * Entry for inserting data into datacache from the DHT. - * Needed here so block library can verify entries that - * are shoveled into the DHT. - */ -struct DHTPutEntry -{ - /** - * Size of data. - */ - uint16_t data_size; - - /** - * Length of recorded path. - */ - uint16_t path_length; - - /* PUT DATA */ - - /* PATH ENTRIES */ -}; - - -#endif /* DHT_H_ */ diff --git a/src/dht/dht_api.c b/src/dht/dht_api.c deleted file mode 100644 index 2a14b216f..000000000 --- a/src/dht/dht_api.c +++ /dev/null @@ -1,909 +0,0 @@ -/* - This file is part of GNUnet. - (C) 2009, 2010 Christian Grothoff (and other contributing authors) - - GNUnet is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published - by the Free Software Foundation; either version 3, or (at your - option) any later version. - - GNUnet is distributed in the hope that it will be useful, but - WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - General Public License for more details. - - You should have received a copy of the GNU General Public License - along with GNUnet; see the file COPYING. If not, write to the - Free Software Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. -*/ - -/** - * @file dht/dht_api.c - * @brief library to access the DHT service - * @author Christian Grothoff - * @author Nathan Evans - */ - -#include "platform.h" -#include "gnunet_bandwidth_lib.h" -#include "gnunet_client_lib.h" -#include "gnunet_constants.h" -#include "gnunet_container_lib.h" -#include "gnunet_arm_service.h" -#include "gnunet_hello_lib.h" -#include "gnunet_protocols.h" -#include "gnunet_server_lib.h" -#include "gnunet_time_lib.h" -#include "gnunet_dht_service.h" -#include "dht.h" - -#define DEBUG_DHT_API GNUNET_NO - -/** - * Entry in our list of messages to be (re-)transmitted. - */ -struct PendingMessage -{ - /** - * This is a doubly-linked list. - */ - struct PendingMessage *prev; - - /** - * This is a doubly-linked list. - */ - struct PendingMessage *next; - - /** - * Message that is pending, allocated at the end - * of this struct. - */ - const struct GNUNET_MessageHeader *msg; - - /** - * Handle to the DHT API context. - */ - struct GNUNET_DHT_Handle *handle; - - /** - * Continuation to call when the request has been - * transmitted (for the first time) to the service; can be NULL. - */ - GNUNET_SCHEDULER_Task cont; - - /** - * Closure for 'cont'. - */ - void *cont_cls; - - /** - * Timeout task for this message - */ - GNUNET_SCHEDULER_TaskIdentifier timeout_task; - - /** - * Unique ID for this request - */ - uint64_t unique_id; - - /** - * Free the saved message once sent, set to GNUNET_YES for messages - * that do not receive responses; GNUNET_NO if this pending message - * is aliased from a 'struct GNUNET_DHT_RouteHandle' and will be freed - * from there. - */ - int free_on_send; - - /** - * GNUNET_YES if this message is in our pending queue right now. - */ - int in_pending_queue; - -}; - - -/** - * Handle to a route request - */ -struct GNUNET_DHT_RouteHandle -{ - - /** - * Iterator to call on data receipt - */ - GNUNET_DHT_ReplyProcessor iter; - - /** - * Closure for the iterator callback - */ - void *iter_cls; - - /** - * Main handle to this DHT api - */ - struct GNUNET_DHT_Handle *dht_handle; - - /** - * The actual message sent for this request, - * used for retransmitting requests on service - * failure/reconnect. Freed on route_stop. - */ - struct PendingMessage *message; - - /** - * Key that this get request is for - */ - GNUNET_HashCode key; - - /** - * Unique identifier for this request (for key collisions). FIXME: redundant!? - */ - uint64_t uid; - -}; - - -/** - * Connection to the DHT service. - */ -struct GNUNET_DHT_Handle -{ - - /** - * Configuration to use. - */ - const struct GNUNET_CONFIGURATION_Handle *cfg; - - /** - * Socket (if available). - */ - struct GNUNET_CLIENT_Connection *client; - - /** - * Currently pending transmission request (or NULL). - */ - struct GNUNET_CLIENT_TransmitHandle *th; - - /** - * Head of linked list of messages we would like to transmit. - */ - struct PendingMessage *pending_head; - - /** - * Tail of linked list of messages we would like to transmit. - */ - struct PendingMessage *pending_tail; - - /** - * Hash map containing the current outstanding unique requests - * (values are of type 'struct GNUNET_DHT_RouteHandle'). - */ - struct GNUNET_CONTAINER_MultiHashMap *active_requests; - - /** - * Task for trying to reconnect. - */ - GNUNET_SCHEDULER_TaskIdentifier reconnect_task; - - /** - * How quickly should we retry? Used for exponential back-off on - * connect-errors. - */ - struct GNUNET_TIME_Relative retry_time; - - /** - * Generator for unique ids. - */ - uint64_t uid_gen; - -}; - - -/** - * Transmit the next pending message, called by notify_transmit_ready - */ -static size_t -transmit_pending (void *cls, size_t size, void *buf); - - -/** - * Handler for messages received from the DHT service - * a demultiplexer which handles numerous message types - * - */ -static void -service_message_handler (void *cls, const struct GNUNET_MessageHeader *msg); - - - - -/** - * Try to (re)connect to the DHT service. - * - * @return GNUNET_YES on success, GNUNET_NO on failure. - */ -static int -try_connect (struct GNUNET_DHT_Handle *handle) -{ - if (handle->client != NULL) - return GNUNET_OK; - handle->client = GNUNET_CLIENT_connect ("dht", handle->cfg); - if (handle->client == NULL) - { - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, - _("Failed to connect to the DHT service!\n")); - return GNUNET_NO; - } -#if DEBUG_DHT - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Starting to process replies from DHT\n"); -#endif - GNUNET_CLIENT_receive (handle->client, &service_message_handler, handle, - GNUNET_TIME_UNIT_FOREVER_REL); - return GNUNET_YES; -} - - -/** - * Add the request corresponding to the given route handle - * to the pending queue (if it is not already in there). - * - * @param cls the 'struct GNUNET_DHT_Handle*' - * @param key key for the request (not used) - * @param value the 'struct GNUNET_DHT_RouteHandle*' - * @return GNUNET_YES (always) - */ -static int -add_request_to_pending (void *cls, const GNUNET_HashCode * key, void *value) -{ - struct GNUNET_DHT_Handle *handle = cls; - struct GNUNET_DHT_RouteHandle *rh = value; - - if (GNUNET_NO == rh->message->in_pending_queue) - { - GNUNET_CONTAINER_DLL_insert (handle->pending_head, handle->pending_tail, - rh->message); - rh->message->in_pending_queue = GNUNET_YES; - } - return GNUNET_YES; -} - - -/** - * Try to send messages from list of messages to send - * @param handle DHT_Handle - */ -static void -process_pending_messages (struct GNUNET_DHT_Handle *handle); - - -/** - * Try reconnecting to the dht service. - * - * @param cls GNUNET_DHT_Handle - * @param tc scheduler context - */ -static void -try_reconnect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) -{ - struct GNUNET_DHT_Handle *handle = cls; - - handle->reconnect_task = GNUNET_SCHEDULER_NO_TASK; - if (handle->retry_time.rel_value < GNUNET_CONSTANTS_SERVICE_RETRY.rel_value) - handle->retry_time = GNUNET_CONSTANTS_SERVICE_RETRY; - else - handle->retry_time = GNUNET_TIME_relative_multiply (handle->retry_time, 2); - if (handle->retry_time.rel_value > GNUNET_CONSTANTS_SERVICE_TIMEOUT.rel_value) - handle->retry_time = GNUNET_CONSTANTS_SERVICE_TIMEOUT; - handle->reconnect_task = GNUNET_SCHEDULER_NO_TASK; - handle->client = GNUNET_CLIENT_connect ("dht", handle->cfg); - if (handle->client == NULL) - { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "dht reconnect failed(!)\n"); - return; - } - GNUNET_CONTAINER_multihashmap_iterate (handle->active_requests, - &add_request_to_pending, handle); - process_pending_messages (handle); -} - - -/** - * Try reconnecting to the DHT service. - * - * @param handle handle to dht to (possibly) disconnect and reconnect - */ -static void -do_disconnect (struct GNUNET_DHT_Handle *handle) -{ - if (handle->client == NULL) - return; - GNUNET_assert (handle->reconnect_task == GNUNET_SCHEDULER_NO_TASK); - if (NULL != handle->th) - GNUNET_CLIENT_notify_transmit_ready_cancel(handle->th); - handle->th = NULL; - GNUNET_CLIENT_disconnect (handle->client, GNUNET_NO); - handle->client = NULL; - handle->reconnect_task = - GNUNET_SCHEDULER_add_delayed (handle->retry_time, &try_reconnect, handle); -} - - -/** - * Try to send messages from list of messages to send - */ -static void -process_pending_messages (struct GNUNET_DHT_Handle *handle) -{ - struct PendingMessage *head; - - if (handle->client == NULL) - { - do_disconnect (handle); - return; - } - if (handle->th != NULL) - return; - if (NULL == (head = handle->pending_head)) - return; - handle->th = - GNUNET_CLIENT_notify_transmit_ready (handle->client, - ntohs (head->msg->size), - GNUNET_TIME_UNIT_FOREVER_REL, - GNUNET_YES, &transmit_pending, - handle); - if (NULL == handle->th) - { - do_disconnect (handle); - return; - } -} - - -/** - * Transmit the next pending message, called by notify_transmit_ready - */ -static size_t -transmit_pending (void *cls, size_t size, void *buf) -{ - struct GNUNET_DHT_Handle *handle = cls; - struct PendingMessage *head; - size_t tsize; - - handle->th = NULL; - if (buf == NULL) - { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Transmission to DHT service failed! Reconnecting!\n"); - do_disconnect (handle); - return 0; - } - if (NULL == (head = handle->pending_head)) - return 0; - - tsize = ntohs (head->msg->size); - if (size < tsize) - { - process_pending_messages (handle); - return 0; - } - memcpy (buf, head->msg, tsize); - GNUNET_CONTAINER_DLL_remove (handle->pending_head, handle->pending_tail, - head); - if (head->timeout_task != GNUNET_SCHEDULER_NO_TASK) - { - GNUNET_SCHEDULER_cancel (head->timeout_task); - head->timeout_task = GNUNET_SCHEDULER_NO_TASK; - } - if (NULL != head->cont) - { - GNUNET_SCHEDULER_add_continuation (head->cont, head->cont_cls, - GNUNET_SCHEDULER_REASON_PREREQ_DONE); - head->cont = NULL; - head->cont_cls = NULL; - } - head->in_pending_queue = GNUNET_NO; - if (GNUNET_YES == head->free_on_send) - GNUNET_free (head); - process_pending_messages (handle); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Forwarded request of %u bytes to DHT service\n", - (unsigned int) tsize); - return tsize; -} - - -/** - * Process a given reply that might match the given - * request. - */ -static int -process_reply (void *cls, const GNUNET_HashCode * key, void *value) -{ - const struct GNUNET_DHT_RouteResultMessage *dht_msg = cls; - struct GNUNET_DHT_RouteHandle *rh = value; - const struct GNUNET_MessageHeader *enc_msg; - size_t enc_size; - const struct GNUNET_PeerIdentity **outgoing_path; - const struct GNUNET_PeerIdentity *pos; - uint32_t outgoing_path_length; - unsigned int i; - char *path_offset; -#if HAVE_UID_FOR_TESTING - uint64_t uid; - - uid = GNUNET_ntohll (dht_msg->unique_id); - if (uid != rh->uid) - { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Reply UID did not match request UID\n"); - return GNUNET_YES; - } -#endif - enc_msg = (const struct GNUNET_MessageHeader *) &dht_msg[1]; - enc_size = ntohs (enc_msg->size); - if (enc_size < sizeof (struct GNUNET_MessageHeader)) - { - GNUNET_break (0); - return GNUNET_NO; - } - path_offset = (char *) &dht_msg[1]; - path_offset += enc_size; - pos = (const struct GNUNET_PeerIdentity *) path_offset; - outgoing_path_length = ntohl (dht_msg->outgoing_path_length); - if (outgoing_path_length * sizeof (struct GNUNET_PeerIdentity) > - ntohs (dht_msg->header.size) - enc_size) - { - GNUNET_break (0); - return GNUNET_NO; - } - - if (outgoing_path_length > 0) - { - outgoing_path = - GNUNET_malloc ((outgoing_path_length + - 1) * sizeof (struct GNUNET_PeerIdentity *)); - for (i = 0; i < outgoing_path_length; i++) - { - outgoing_path[i] = pos; - pos++; - } - outgoing_path[outgoing_path_length] = NULL; - } - else - outgoing_path = NULL; - - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Processing reply.\n"); - rh->iter (rh->iter_cls, &rh->key, outgoing_path, enc_msg); - GNUNET_free_non_null (outgoing_path); - return GNUNET_YES; -} - - -/** - * Handler for messages received from the DHT service - * a demultiplexer which handles numerous message types - * - * @param cls the 'struct GNUNET_DHT_Handle' - * @param msg the incoming message - */ -static void -service_message_handler (void *cls, const struct GNUNET_MessageHeader *msg) -{ - struct GNUNET_DHT_Handle *handle = cls; - const struct GNUNET_DHT_RouteResultMessage *dht_msg; - - if (msg == NULL) - { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Error receiving data from DHT service, reconnecting\n"); - do_disconnect (handle); - return; - } - if (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_DHT_LOCAL_ROUTE_RESULT) - { - GNUNET_break (0); - do_disconnect (handle); - return; - } - if (ntohs (msg->size) < sizeof (struct GNUNET_DHT_RouteResultMessage)) - { - GNUNET_break (0); - do_disconnect (handle); - return; - } - dht_msg = (const struct GNUNET_DHT_RouteResultMessage *) msg; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Comparing reply `%s' against %u pending requests.\n", - GNUNET_h2s (&dht_msg->key), - GNUNET_CONTAINER_multihashmap_size (handle->active_requests)); - GNUNET_CONTAINER_multihashmap_get_multiple (handle->active_requests, - &dht_msg->key, &process_reply, - (void *) dht_msg); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Continuing to process replies from DHT\n"); - GNUNET_CLIENT_receive (handle->client, &service_message_handler, handle, - GNUNET_TIME_UNIT_FOREVER_REL); - -} - - -/** - * Initialize the connection with the DHT service. - * - * @param cfg configuration to use - * @param ht_len size of the internal hash table to use for - * processing multiple GET/FIND requests in parallel - * - * @return handle to the DHT service, or NULL on error - */ -struct GNUNET_DHT_Handle * -GNUNET_DHT_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, - unsigned int ht_len) -{ - struct GNUNET_DHT_Handle *handle; - - handle = GNUNET_malloc (sizeof (struct GNUNET_DHT_Handle)); - handle->cfg = cfg; - handle->uid_gen = - GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, UINT64_MAX); - handle->active_requests = GNUNET_CONTAINER_multihashmap_create (ht_len); - if (GNUNET_NO == try_connect (handle)) - { - GNUNET_DHT_disconnect (handle); - return NULL; - } - return handle; -} - - -/** - * Shutdown connection with the DHT service. - * - * @param handle handle of the DHT connection to stop - */ -void -GNUNET_DHT_disconnect (struct GNUNET_DHT_Handle *handle) -{ - struct PendingMessage *pm; - - GNUNET_assert (handle != NULL); - GNUNET_assert (0 == - GNUNET_CONTAINER_multihashmap_size (handle->active_requests)); - if (handle->th != NULL) - { - GNUNET_CLIENT_notify_transmit_ready_cancel (handle->th); - handle->th = NULL; - } - while (NULL != (pm = handle->pending_head)) - { - GNUNET_CONTAINER_DLL_remove (handle->pending_head, handle->pending_tail, - pm); - GNUNET_assert (GNUNET_YES == pm->free_on_send); - if (GNUNET_SCHEDULER_NO_TASK != pm->timeout_task) - GNUNET_SCHEDULER_cancel (pm->timeout_task); - if (NULL != pm->cont) - GNUNET_SCHEDULER_add_continuation (pm->cont, pm->cont_cls, - GNUNET_SCHEDULER_REASON_TIMEOUT); - pm->in_pending_queue = GNUNET_NO; - GNUNET_free (pm); - } - if (handle->client != NULL) - { - GNUNET_CLIENT_disconnect (handle->client, GNUNET_YES); - handle->client = NULL; - } - if (handle->reconnect_task != GNUNET_SCHEDULER_NO_TASK) - GNUNET_SCHEDULER_cancel (handle->reconnect_task); - GNUNET_CONTAINER_multihashmap_destroy (handle->active_requests); - GNUNET_free (handle); -} - - - - -/* ***** Special low-level API providing generic routing abstraction ***** */ - - -/** - * Timeout for the transmission of a fire&forget-request. Clean it up. - * - * @param cls the 'struct PendingMessage' - * @param tc scheduler context - */ -static void -timeout_route_request (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) -{ - struct PendingMessage *pending = cls; - struct GNUNET_DHT_Handle *handle; - - if (pending->free_on_send != GNUNET_YES) - { - /* timeouts should only apply to fire & forget requests! */ - GNUNET_break (0); - return; - } - handle = pending->handle; - GNUNET_CONTAINER_DLL_remove (handle->pending_head, handle->pending_tail, - pending); - if (pending->cont != NULL) - pending->cont (pending->cont_cls, tc); - GNUNET_free (pending); -} - - -/** - * Initiate a generic DHT route operation. - * - * @param handle handle to the DHT service - * @param key the key to look up - * @param desired_replication_level how many peers should ultimately receive - * this message (advisory only, target may be too high for the - * given DHT or not hit exactly). - * @param options options for routing - * @param enc send the encapsulated message to a peer close to the key - * @param iter function to call on each result, NULL if no replies are expected - * @param iter_cls closure for iter - * @param timeout when to abort with an error if we fail to get - * a confirmation for the request (when necessary) or how long - * to wait for tramission to the service; only applies - * if 'iter' is NULL - * @param cont continuation to call when the request has been transmitted - * the first time to the service - * @param cont_cls closure for cont - * @return handle to stop the request, NULL if the request is "fire and forget" - */ -struct GNUNET_DHT_RouteHandle * -GNUNET_DHT_route_start (struct GNUNET_DHT_Handle *handle, - const GNUNET_HashCode * key, - uint32_t desired_replication_level, - enum GNUNET_DHT_RouteOption options, - const struct GNUNET_MessageHeader *enc, - struct GNUNET_TIME_Relative timeout, - GNUNET_DHT_ReplyProcessor iter, void *iter_cls, - GNUNET_SCHEDULER_Task cont, void *cont_cls) -{ - struct PendingMessage *pending; - struct GNUNET_DHT_RouteMessage *message; - struct GNUNET_DHT_RouteHandle *route_handle; - uint16_t msize; - uint16_t esize; - - esize = ntohs (enc->size); - if (sizeof (struct GNUNET_DHT_RouteMessage) + esize >= - GNUNET_SERVER_MAX_MESSAGE_SIZE) - { - GNUNET_break (0); - return NULL; - } - msize = sizeof (struct GNUNET_DHT_RouteMessage) + esize; - pending = GNUNET_malloc (sizeof (struct PendingMessage) + msize); - message = (struct GNUNET_DHT_RouteMessage *) &pending[1]; - pending->msg = &message->header; - pending->handle = handle; - pending->cont = cont; - pending->cont_cls = cont_cls; - - message->header.size = htons (msize); - message->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_LOCAL_ROUTE); - message->options = htonl ((uint32_t) options); - message->desired_replication_level = htonl (desired_replication_level); - message->reserved = 0; - message->key = *key; - handle->uid_gen++; - message->unique_id = GNUNET_htonll (handle->uid_gen); - memcpy (&message[1], enc, esize); - - if (iter != NULL) - { - route_handle = GNUNET_malloc (sizeof (struct GNUNET_DHT_RouteHandle)); - route_handle->key = *key; - route_handle->iter = iter; - route_handle->iter_cls = iter_cls; - route_handle->dht_handle = handle; - route_handle->uid = handle->uid_gen; - route_handle->message = pending; - GNUNET_CONTAINER_multihashmap_put (handle->active_requests, key, - route_handle, - GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); - } - else - { - route_handle = NULL; - pending->free_on_send = GNUNET_YES; - pending->timeout_task = - GNUNET_SCHEDULER_add_delayed (timeout, &timeout_route_request, pending); - } - GNUNET_CONTAINER_DLL_insert (handle->pending_head, handle->pending_tail, - pending); - pending->in_pending_queue = GNUNET_YES; - process_pending_messages (handle); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "DHT route start request processed, returning %p\n", - route_handle); - return route_handle; -} - - -/** - * Stop a previously issued routing request - * - * @param route_handle handle to the request to stop - */ -void -GNUNET_DHT_route_stop (struct GNUNET_DHT_RouteHandle *route_handle) -{ - struct GNUNET_DHT_Handle *handle; - struct PendingMessage *pending; - struct GNUNET_DHT_StopMessage *message; - size_t msize; - - handle = route_handle->dht_handle; - if (GNUNET_NO == route_handle->message->in_pending_queue) - { - /* need to send stop message */ - msize = sizeof (struct GNUNET_DHT_StopMessage); - pending = GNUNET_malloc (sizeof (struct PendingMessage) + msize); - message = (struct GNUNET_DHT_StopMessage *) &pending[1]; - pending->msg = &message->header; - message->header.size = htons (msize); - message->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_LOCAL_ROUTE_STOP); - message->reserved = 0; - message->unique_id = GNUNET_htonll (route_handle->uid); - message->key = route_handle->key; - pending->handle = handle; - pending->free_on_send = GNUNET_YES; - pending->in_pending_queue = GNUNET_YES; - GNUNET_CONTAINER_DLL_insert (handle->pending_head, handle->pending_tail, - pending); - process_pending_messages (handle); - } - else - { - /* simply remove pending request from message queue before - * transmission, no need to transmit STOP request! */ - GNUNET_CONTAINER_DLL_remove (handle->pending_head, handle->pending_tail, - route_handle->message); - } - GNUNET_assert (GNUNET_YES == - GNUNET_CONTAINER_multihashmap_remove - (route_handle->dht_handle->active_requests, &route_handle->key, - route_handle)); - GNUNET_free (route_handle->message); - GNUNET_free (route_handle); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "DHT route stop request processed\n"); -} - - - -/* ***** Special API for controlling DHT routing maintenance ******* */ - - -/** - * Send a control message to the DHT. - * - * @param handle handle to the DHT service - * @param command command - * @param variable variable to the command - * @param cont continuation to call when done (transmitting request to service) - * @param cont_cls closure for cont - */ -static void -send_control_message (struct GNUNET_DHT_Handle *handle, uint16_t command, - uint16_t variable, GNUNET_SCHEDULER_Task cont, - void *cont_cls) -{ - struct GNUNET_DHT_ControlMessage *msg; - struct PendingMessage *pending; - - pending = - GNUNET_malloc (sizeof (struct PendingMessage) + - sizeof (struct GNUNET_DHT_ControlMessage)); - msg = (struct GNUNET_DHT_ControlMessage *) &pending[1]; - pending->msg = &msg->header; - msg->header.size = htons (sizeof (struct GNUNET_DHT_ControlMessage)); - msg->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_CONTROL); - msg->command = htons (command); - msg->variable = htons (variable); - pending->free_on_send = GNUNET_YES; - pending->cont = cont; - pending->cont_cls = cont_cls; - pending->in_pending_queue = GNUNET_YES; - GNUNET_CONTAINER_DLL_insert (handle->pending_head, handle->pending_tail, - pending); - process_pending_messages (handle); -} - - -/** - * Send a message to the DHT telling it to issue a single find - * peer request using the peers unique identifier as key. This - * is used to fill the routing table, and is normally controlled - * by the DHT itself. However, for testing and perhaps more - * close control over the DHT, this can be explicitly managed. - * - * @param handle handle to the DHT service - * @param cont continuation to call when done (transmitting request to service) - * @param cont_cls closure for cont - */ -void -GNUNET_DHT_find_peers (struct GNUNET_DHT_Handle *handle, - GNUNET_SCHEDULER_Task cont, void *cont_cls) -{ - send_control_message (handle, GNUNET_MESSAGE_TYPE_DHT_FIND_PEER, 0, cont, - cont_cls); -} - - - -#if HAVE_MALICIOUS - -/** - * Send a message to the DHT telling it to start issuing random GET - * requests every 'frequency' milliseconds. - * - * @param handle handle to the DHT service - * @param frequency delay between sending malicious messages - * @param cont continuation to call when done (transmitting request to service) - * @param cont_cls closure for cont - */ -void -GNUNET_DHT_set_malicious_getter (struct GNUNET_DHT_Handle *handle, - struct GNUNET_TIME_Relative frequency, - GNUNET_SCHEDULER_Task cont, void *cont_cls) -{ - if (frequency.rel_value > UINT16_MAX) - { - GNUNET_break (0); - return; - } - send_control_message (handle, GNUNET_MESSAGE_TYPE_DHT_MALICIOUS_GET, - frequency.rel_value, cont, cont_cls); -} - -/** - * Send a message to the DHT telling it to start issuing random PUT - * requests every 'frequency' milliseconds. - * - * @param handle handle to the DHT service - * @param frequency delay between sending malicious messages - * @param cont continuation to call when done (transmitting request to service) - * @param cont_cls closure for cont - */ -void -GNUNET_DHT_set_malicious_putter (struct GNUNET_DHT_Handle *handle, - struct GNUNET_TIME_Relative frequency, - GNUNET_SCHEDULER_Task cont, void *cont_cls) -{ - if (frequency.rel_value > UINT16_MAX) - { - GNUNET_break (0); - return; - } - - send_control_message (handle, GNUNET_MESSAGE_TYPE_DHT_MALICIOUS_PUT, - frequency.rel_value, cont, cont_cls); -} - - -/** - * Send a message to the DHT telling it to start dropping - * all requests received. - * - * @param handle handle to the DHT service - * @param cont continuation to call when done (transmitting request to service) - * @param cont_cls closure for cont - * - */ -void -GNUNET_DHT_set_malicious_dropper (struct GNUNET_DHT_Handle *handle, - GNUNET_SCHEDULER_Task cont, void *cont_cls) -{ - send_control_message (handle, GNUNET_MESSAGE_TYPE_DHT_MALICIOUS_DROP, 0, cont, - cont_cls); -} - -#endif - -/* end of dht_api.c */ diff --git a/src/dht/dht_api_find_peer.c b/src/dht/dht_api_find_peer.c deleted file mode 100644 index a9ecc7b59..000000000 --- a/src/dht/dht_api_find_peer.c +++ /dev/null @@ -1,150 +0,0 @@ -/* - This file is part of GNUnet. - (C) 2009, 2010 Christian Grothoff (and other contributing authors) - - GNUnet is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published - by the Free Software Foundation; either version 3, or (at your - option) any later version. - - GNUnet is distributed in the hope that it will be useful, but - WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - General Public License for more details. - - You should have received a copy of the GNU General Public License - along with GNUnet; see the file COPYING. If not, write to the - Free Software Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. -*/ - -/** - * @file dht/dht_api_find_peer.c - * @brief library to access the DHT to find peers - * @author Christian Grothoff - * @author Nathan Evans - */ - -#include "platform.h" -#include "gnunet_constants.h" -#include "gnunet_arm_service.h" -#include "gnunet_protocols.h" -#include "gnunet_util_lib.h" -#include "gnunet_dht_service.h" -#include "dht.h" - - -/** - * Handle to control a find peer operation. - */ -struct GNUNET_DHT_FindPeerHandle -{ - - /** - * Handle to the actual route operation for the request - */ - struct GNUNET_DHT_RouteHandle *route_handle; - - /** - * Iterator to call on data receipt - */ - GNUNET_DHT_FindPeerProcessor proc; - - /** - * Closure for the iterator callback - */ - void *proc_cls; - -}; - - - -/** - * Iterator called on each result obtained from a generic route - * operation - * - * @param cls closure - * @param key key that was used - * @param outgoing_path NULL-terminated array of pointers - * to the peers on reverse path - * (or NULL if not recorded) - * @param reply response - */ -static void -find_peer_reply_iterator (void *cls, const GNUNET_HashCode * key, - const struct GNUNET_PeerIdentity *const - *outgoing_path, - const struct GNUNET_MessageHeader *reply) -{ - struct GNUNET_DHT_FindPeerHandle *find_peer_handle = cls; - const struct GNUNET_MessageHeader *hello; - - if (ntohs (reply->type) != GNUNET_MESSAGE_TYPE_DHT_FIND_PEER_RESULT) - { - GNUNET_break (0); - return; - } - GNUNET_assert (ntohs (reply->size) >= sizeof (struct GNUNET_MessageHeader)); - hello = (const struct GNUNET_MessageHeader *) &reply[1]; - if (ntohs (hello->type) != GNUNET_MESSAGE_TYPE_HELLO) - { - GNUNET_break (0); - return; - } - find_peer_handle->proc (find_peer_handle->proc_cls, - (const struct GNUNET_HELLO_Message *) hello); -} - - - -/** - * Perform an asynchronous FIND PEER operation on the DHT. - * - * @param handle handle to the DHT service - * @param timeout timeout for this request to be sent to the - * service - * @param options routing options for this message - * @param key the key to look up - * @param proc function to call on each result - * @param proc_cls closure for proc - * @return handle to stop the async get, NULL on error - */ -struct GNUNET_DHT_FindPeerHandle * -GNUNET_DHT_find_peer_start (struct GNUNET_DHT_Handle *handle, - struct GNUNET_TIME_Relative timeout, - const GNUNET_HashCode * key, - enum GNUNET_DHT_RouteOption options, - GNUNET_DHT_FindPeerProcessor proc, void *proc_cls) -{ - struct GNUNET_DHT_FindPeerHandle *find_peer_handle; - struct GNUNET_DHT_FindPeerMessage find_peer_msg; - - find_peer_handle = GNUNET_malloc (sizeof (struct GNUNET_DHT_FindPeerHandle)); - find_peer_handle->proc = proc; - find_peer_handle->proc_cls = proc_cls; - find_peer_msg.header.size = - htons (sizeof (struct GNUNET_DHT_FindPeerMessage)); - find_peer_msg.header.type = htons (GNUNET_MESSAGE_TYPE_DHT_FIND_PEER); - find_peer_handle->route_handle = - GNUNET_DHT_route_start (handle, key, 0, options, &find_peer_msg.header, - timeout, &find_peer_reply_iterator, - find_peer_handle, NULL, NULL); - GNUNET_break (find_peer_handle->route_handle != NULL); - return find_peer_handle; -} - - -/** - * Stop async find peer. Frees associated resources. - * - * @param find_peer_handle GET operation to stop. - */ -void -GNUNET_DHT_find_peer_stop (struct GNUNET_DHT_FindPeerHandle *find_peer_handle) -{ - GNUNET_DHT_route_stop (find_peer_handle->route_handle); - GNUNET_free (find_peer_handle); -} - - -/* end of dht_api_find_peer.c */ diff --git a/src/dht/dht_api_get_put.c b/src/dht/dht_api_get_put.c deleted file mode 100644 index 20778908d..000000000 --- a/src/dht/dht_api_get_put.c +++ /dev/null @@ -1,274 +0,0 @@ -/* - This file is part of GNUnet. - (C) 2009, 2010 Christian Grothoff (and other contributing authors) - - GNUnet is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published - by the Free Software Foundation; either version 3, or (at your - option) any later version. - - GNUnet is distributed in the hope that it will be useful, but - WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - General Public License for more details. - - You should have received a copy of the GNU General Public License - along with GNUnet; see the file COPYING. If not, write to the - Free Software Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. -*/ - -/** - * @file dht/dht_api_get_put.c - * @brief library to perform DHT gets and puts - * @author Christian Grothoff - * @author Nathan Evans - */ - -#include "platform.h" -#include "gnunet_constants.h" -#include "gnunet_arm_service.h" -#include "gnunet_protocols.h" -#include "gnunet_util_lib.h" -#include "gnunet_dht_service.h" -#include "dht.h" - - -/** - * Perform a PUT operation storing data in the DHT. - * - * @param handle handle to DHT service - * @param key the key to store under - * @param desired_replication_level estimate of how many - * nearest peers this request should reach - * @param options routing options for this message - * @param type type of the value - * @param size number of bytes in data; must be less than 64k - * @param data the data to store - * @param exp desired expiration time for the value - * @param timeout how long to wait for transmission of this request - * @param cont continuation to call when done (transmitting request to service) - * @param cont_cls closure for cont - * @return GNUNET_YES if put message is queued for transmission - */ -void -GNUNET_DHT_put (struct GNUNET_DHT_Handle *handle, const GNUNET_HashCode * key, - uint32_t desired_replication_level, - enum GNUNET_DHT_RouteOption options, - enum GNUNET_BLOCK_Type type, size_t size, const char *data, - struct GNUNET_TIME_Absolute exp, - struct GNUNET_TIME_Relative timeout, GNUNET_SCHEDULER_Task cont, - void *cont_cls) -{ - char buf[GNUNET_SERVER_MAX_MESSAGE_SIZE]; - struct GNUNET_DHT_PutMessage *put_msg; - - if (size >= sizeof (buf) - sizeof (struct GNUNET_DHT_PutMessage)) - { - GNUNET_break (0); - return; - } - put_msg = (struct GNUNET_DHT_PutMessage *) buf; - put_msg->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_PUT); - put_msg->header.size = htons (sizeof (struct GNUNET_DHT_PutMessage) + size); - put_msg->type = htonl ((uint32_t) type); - put_msg->expiration = GNUNET_TIME_absolute_hton (exp); - memcpy (&put_msg[1], data, size); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Starting route for %u byte `%s' message of type %u \n", - (unsigned int) (sizeof (struct GNUNET_DHT_PutMessage) + size), - "PUT", type); - GNUNET_break (NULL == - GNUNET_DHT_route_start (handle, key, desired_replication_level, - options, &put_msg->header, timeout, - NULL, NULL, cont, cont_cls)); -} - - - -/** - * Handle to control a get operation. - */ -struct GNUNET_DHT_GetHandle -{ - /** - * Handle to the actual route operation for the get - */ - struct GNUNET_DHT_RouteHandle *route_handle; - - /** - * Iterator to call on data receipt - */ - GNUNET_DHT_GetIterator iter; - - /** - * Closure for the iterator callback - */ - void *iter_cls; - -}; - - - -/** - * Iterator called on each result obtained from a generic route - * operation - * - * @param cls the 'struct GNUNET_DHT_GetHandle' - * @param key key that was used - * @param outgoing_path path of the message from this peer - * to the target - * @param reply response - */ -static void -get_reply_iterator (void *cls, const GNUNET_HashCode * key, - const struct GNUNET_PeerIdentity *const *outgoing_path, - const struct GNUNET_MessageHeader *reply) -{ - struct GNUNET_DHT_GetHandle *get_handle = cls; - const struct GNUNET_DHT_GetResultMessage *result; - const struct GNUNET_PeerIdentity **put_path; - char *path_offset; - const struct GNUNET_PeerIdentity *pos; - unsigned int i; - uint16_t put_path_length; - uint16_t data_size; - - if (ntohs (reply->type) != GNUNET_MESSAGE_TYPE_DHT_GET_RESULT) - { - GNUNET_break (0); - return; - } - - GNUNET_assert (ntohs (reply->size) >= - sizeof (struct GNUNET_DHT_GetResultMessage)); - result = (const struct GNUNET_DHT_GetResultMessage *) reply; - - put_path = NULL; - put_path_length = ntohs (result->put_path_length); - data_size = - ntohs (result->header.size) - - (put_path_length * sizeof (struct GNUNET_PeerIdentity)) - - sizeof (struct GNUNET_DHT_GetResultMessage); - if (put_path_length > 0) - { - path_offset = (char *) &result[1]; - //GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "In get_reply_iterator, result->header.size is %d, put_path_length %d, offset is %d, data_size is %d\n", ntohs(result->header.size), put_path_length, ntohs(result->header.size) - (put_path_length * sizeof(struct GNUNET_PeerIdentity)), data_size); - path_offset += data_size; - pos = (const struct GNUNET_PeerIdentity *) path_offset; - //GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Found put peer %s\n", GNUNET_i2s((const struct GNUNET_PeerIdentity *)path_offset)); - put_path = - GNUNET_malloc ((put_path_length + - 1) * sizeof (struct GNUNET_PeerIdentity *)); - for (i = 0; i < put_path_length; i++) - { - put_path[i] = pos; - pos++; - } - put_path[put_path_length] = NULL; - } - - get_handle->iter (get_handle->iter_cls, - GNUNET_TIME_absolute_ntoh (result->expiration), key, - outgoing_path, put_path, ntohs (result->type), data_size, - &result[1]); - GNUNET_free_non_null (put_path); -} - - - -/** - * Perform an asynchronous GET operation on the DHT identified. See - * also "GNUNET_BLOCK_evaluate". - * - * @param handle handle to the DHT service - * @param timeout how long to wait for transmission of this request to the service - * @param type expected type of the response object - * @param key the key to look up - * @param desired_replication_level estimate of how many - nearest peers this request should reach - * @param options routing options for this message - * @param bf bloom filter associated with query (can be NULL) - * @param bf_mutator mutation value for bf - * @param xquery extended query data (can be NULL, depending on type) - * @param xquery_size number of bytes in xquery - * @param iter function to call on each result - * @param iter_cls closure for iter - * - * @return handle to stop the async get - */ -struct GNUNET_DHT_GetHandle * -GNUNET_DHT_get_start (struct GNUNET_DHT_Handle *handle, - struct GNUNET_TIME_Relative timeout, - enum GNUNET_BLOCK_Type type, const GNUNET_HashCode * key, - uint32_t desired_replication_level, - enum GNUNET_DHT_RouteOption options, - const struct GNUNET_CONTAINER_BloomFilter *bf, - int32_t bf_mutator, const void *xquery, - size_t xquery_size, GNUNET_DHT_GetIterator iter, - void *iter_cls) -{ - struct GNUNET_DHT_GetHandle *get_handle; - char buf[GNUNET_SERVER_MAX_MESSAGE_SIZE - 1]; - struct GNUNET_DHT_GetMessage *get_msg; - size_t bf_size; - - bf_size = GNUNET_CONTAINER_bloomfilter_get_size (bf); - if ((sizeof (buf) <= - sizeof (struct GNUNET_DHT_GetMessage) + xquery_size + bf_size) || - (sizeof (buf) <= bf_size)) - { - GNUNET_break (0); - return NULL; - } - get_handle = GNUNET_malloc (sizeof (struct GNUNET_DHT_GetHandle)); - get_handle->iter = iter; - get_handle->iter_cls = iter_cls; - get_msg = (struct GNUNET_DHT_GetMessage *) buf; - get_msg->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_GET); - get_msg->header.size = - htons (sizeof (struct GNUNET_DHT_GetMessage) + xquery_size + bf_size); - get_msg->type = htonl ((uint32_t) type); - get_msg->bf_mutator = bf_mutator; - get_msg->xquery_size = htons ((uint16_t) xquery_size); - get_msg->bf_size = htons (bf_size); - if (xquery != NULL) - memcpy (&buf[sizeof (struct GNUNET_DHT_GetMessage)], xquery, xquery_size); - else - GNUNET_assert (xquery_size == 0); - (void) GNUNET_CONTAINER_bloomfilter_get_raw_data (bf, - &buf[sizeof - (struct - GNUNET_DHT_GetMessage) - + xquery_size], - bf_size); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Starting route for %u byte `%s' message\n", - (unsigned int) (sizeof (struct GNUNET_DHT_GetMessage) + - xquery_size + bf_size), "GET"); - get_handle->route_handle = - GNUNET_DHT_route_start (handle, key, desired_replication_level, options, - &get_msg->header, timeout, &get_reply_iterator, - get_handle, NULL, NULL); - GNUNET_break (NULL != get_handle->route_handle); - return get_handle; -} - - -/** - * Stop async DHT-get. - * - * @param get_handle handle to the GET operation to stop - * - * On return get_handle will no longer be valid, caller - * must not use again!!! - */ -void -GNUNET_DHT_get_stop (struct GNUNET_DHT_GetHandle *get_handle) -{ - GNUNET_DHT_route_stop (get_handle->route_handle); - GNUNET_free (get_handle); -} - - -/* end of dht_api_get_put.c */ diff --git a/src/dht/gnunet-service-dht_neighbours.c b/src/dht/gnunet-service-dht_neighbours.c index 1dfd1fbb1..80efd5d40 100644 --- a/src/dht/gnunet-service-dht_neighbours.c +++ b/src/dht/gnunet-service-dht_neighbours.c @@ -38,7 +38,6 @@ #include "gnunet_hello_lib.h" #include "gnunet_dht_service_new.h" #include "gnunet_statistics_service.h" -#include "dht.h" #include "gnunet-service-dht.h" #include "gnunet-service-dht_clients.h" #include "gnunet-service-dht_datacache.h" @@ -593,7 +592,7 @@ send_find_peer_message (void *cls, } bcc.bf_mutator = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, UINT32_MAX); bcc.bloom = - GNUNET_CONTAINER_bloomfilter_init (NULL, DHT_BLOOM_SIZE, DHT_BLOOM_K); + GNUNET_CONTAINER_bloomfilter_init (NULL, DHT_BLOOM_SIZE, GNUNET_CONSTANTS_BLOOMFILTER_K); GNUNET_CONTAINER_multihashmap_iterate (all_known_peers, &add_known_to_bloom, &bcc); @@ -1508,7 +1507,7 @@ handle_dht_p2p_put (void *cls, } bf = GNUNET_CONTAINER_bloomfilter_init (put->bloomfilter, DHT_BLOOM_SIZE, - DHT_BLOOM_K); + GNUNET_CONSTANTS_BLOOMFILTER_K); { struct GNUNET_PeerIdentity pp[putlen+1]; @@ -1710,7 +1709,7 @@ handle_dht_p2p_get (void *cls, const struct GNUNET_PeerIdentity *peer, peer_bf = GNUNET_CONTAINER_bloomfilter_init (get->bloomfilter, DHT_BLOOM_SIZE, - DHT_BLOOM_K); + GNUNET_CONSTANTS_BLOOMFILTER_K); /* remember request for routing replies */ GDS_ROUTING_add (peer,