diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/cadet/gnunet-service-cadet_dht.c | 3 | ||||
| -rw-r--r-- | src/dht/Makefile.am | 2 | ||||
| -rw-r--r-- | src/dht/dht.h | 31 | ||||
| -rw-r--r-- | src/dht/dht_api.c | 1481 | ||||
| -rw-r--r-- | src/dht/gnunet-dht-put.c | 26 | ||||
| -rw-r--r-- | src/dht/gnunet-service-xdht.c | 7 | ||||
| -rw-r--r-- | src/dht/gnunet-service-xdht_clients.c | 41 | ||||
| -rw-r--r-- | src/dht/gnunet-service-xdht_neighbours.c | 171 | ||||
| -rw-r--r-- | src/dht/gnunet-service-xdht_neighbours.h | 9 | ||||
| -rw-r--r-- | src/dht/gnunet_dht_profiler.c | 9 | ||||
| -rw-r--r-- | src/dht/test_dht_api.c | 2 | ||||
| -rw-r--r-- | src/dht/test_dht_monitor.c | 1 | ||||
| -rw-r--r-- | src/dht/test_dht_topo.c | 1 | ||||
| -rw-r--r-- | src/exit/gnunet-daemon-exit.c | 1 | ||||
| -rw-r--r-- | src/fs/gnunet-service-fs_put.c | 11 | ||||
| -rw-r--r-- | src/gns/gnunet-service-gns.c | 1 | ||||
| -rw-r--r-- | src/include/gnunet_dht_service.h | 146 | ||||
| -rw-r--r-- | src/regex/regex_internal_dht.c | 2 |
18 files changed, 653 insertions, 1292 deletions
diff --git a/src/cadet/gnunet-service-cadet_dht.c b/src/cadet/gnunet-service-cadet_dht.c index 88a601b52..da9bf7604 100644 --- a/src/cadet/gnunet-service-cadet_dht.c +++ b/src/cadet/gnunet-service-cadet_dht.c @@ -214,7 +214,6 @@ announce_id (void *cls) const struct GNUNET_HELLO_Message *hello; size_t size; struct GNUNET_TIME_Absolute expiration; - struct GNUNET_TIME_Relative retry_time; announce_id_task = NULL; LOG (GNUNET_ERROR_TYPE_DEBUG, "Announce ID\n"); @@ -235,7 +234,6 @@ announce_id (void *cls) return; } expiration = GNUNET_HELLO_get_last_expiration (hello); - retry_time = GNUNET_TIME_absolute_get_remaining (expiration); LOG (GNUNET_ERROR_TYPE_DEBUG, "Hello %p size: %u\n", hello, size); GNUNET_STATISTICS_update (stats, "# DHT announce", @@ -251,7 +249,6 @@ announce_id (void *cls) size, /* Size of the data */ (const char *) hello, /* Data itself */ expiration, /* Data expiration */ - retry_time, /* Retry time */ NULL, /* Continuation */ NULL); /* Continuation closure */ announce_id_task = diff --git a/src/dht/Makefile.am b/src/dht/Makefile.am index b252867b7..f44721094 100644 --- a/src/dht/Makefile.am +++ b/src/dht/Makefile.am @@ -29,7 +29,7 @@ libgnunetdht_la_LIBADD = \ $(LTLIBINTL) libgnunetdht_la_LDFLAGS = \ $(GN_LIB_LDFLAGS) $(WINFLAGS) \ - -version-info 2:0:2 + -version-info 3:0:0 plugin_LTLIBRARIES = \ diff --git a/src/dht/dht.h b/src/dht/dht.h index 8984b19ac..4c994f93a 100644 --- a/src/dht/dht.h +++ b/src/dht/dht.h @@ -441,37 +441,6 @@ struct GNUNET_DHT_MonitorGetRespMessage }; -#if ENABLE_MALICIOUS - -/** - * Message to confirming receipt of ACT MALICIOUS, sent from DHT service to clients. - */ -struct GNUNET_DHT_ClientActMaliciousConfirmationMessage -{ - /** - * Type: #GNUNET_MESSAGE_TYPE_DHT_CLIENT_PUT_OK - */ - struct GNUNET_MessageHeader header; -}; - - -/** - * Message to turn the service malicious - */ -struct GNUNET_DHT_ActMaliciousMessage -{ - /** - * Type: #GNUNET_MESSAGE_TYPE_ACT_MALICIOUS - */ - struct GNUNET_MessageHeader header; - - /** - * If set to 1, act maliciously - */ - uint32_t action; -}; -#endif - GNUNET_NETWORK_STRUCT_END #endif diff --git a/src/dht/dht_api.c b/src/dht/dht_api.c index b5ae2f8ce..de1043ca9 100644 --- a/src/dht/dht_api.c +++ b/src/dht/dht_api.c @@ -1,6 +1,6 @@ /* This file is part of GNUnet. - Copyright (C) 2009, 2010, 2011, 2012 GNUnet e.V. + Copyright (C) 2009, 2010, 2011, 2012, 2016 GNUnet e.V. GNUnet is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published @@ -36,85 +36,6 @@ #define LOG(kind,...) GNUNET_log_from (kind, "dht-api",__VA_ARGS__) -/** - * 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_TaskCallback cont; - - /** - * Closure for 'cont'. - */ - void *cont_cls; - - /** - * 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; - -}; - -#if ENABLE_MALICIOUS -/** - * Handle to act malicious message - */ -struct GNUNET_DHT_ActMaliciousHandle -{ - /** - * Continuation to call when done. - */ - GNUNET_DHT_ActMaliciousContinuation cont; - - /** - * Main handle to this DHT api - */ - struct GNUNET_DHT_Handle *dht_handle; - - /** - * Closure for 'cont'. - */ - void *cont_cls; -}; -#endif /** * Handle to a PUT request. @@ -137,27 +58,16 @@ struct GNUNET_DHT_PutHandle GNUNET_DHT_PutContinuation cont; /** - * Pending message associated with this PUT operation, - * NULL after the message has been transmitted to the service. - */ - struct PendingMessage *pending; - - /** * Main handle to this DHT api */ struct GNUNET_DHT_Handle *dht_handle; /** - * Closure for 'cont'. + * Closure for @e cont. */ void *cont_cls; /** - * Timeout task for this operation. - */ - struct GNUNET_SCHEDULER_Task * timeout_task; - - /** * Unique ID for the PUT operation. */ uint64_t unique_id; @@ -176,7 +86,7 @@ struct GNUNET_DHT_GetHandle GNUNET_DHT_GetIterator iter; /** - * Closure for the iterator callback + * Closure for @a iter. */ void *iter_cls; @@ -186,13 +96,6 @@ struct GNUNET_DHT_GetHandle 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; - - /** * Array of hash codes over the results that we have already * seen. */ @@ -209,25 +112,36 @@ struct GNUNET_DHT_GetHandle uint64_t unique_id; /** - * Size of the 'seen_results' array. Note that not - * all positions might be used (as we over-allocate). + * Size of the extended query, allocated at the end of this struct. */ - unsigned int seen_results_size; + size_t xquery_size; /** - * Offset into the 'seen_results' array marking the - * end of the positions that are actually used. + * Desired replication level. */ - unsigned int seen_results_end; + uint32_t desired_replication_level; + + /** + * Type of the block we are looking for. + */ + enum GNUNET_BLOCK_Type type; + + /** + * Routing options. + */ + enum GNUNET_DHT_RouteOption options; /** - * Offset into the 'seen_results' array marking the - * position up to where we've send the hash codes to - * the DHT for blocking (needed as we might not be - * able to send all hash codes at once). + * Size of the @e seen_results array. Note that not + * all positions might be used (as we over-allocate). */ - unsigned int seen_results_transmission_offset; + unsigned int seen_results_size; + /** + * Offset into the @e seen_results array marking the + * end of the positions that are actually used. + */ + unsigned int seen_results_end; }; @@ -278,7 +192,7 @@ struct GNUNET_DHT_MonitorHandle GNUNET_DHT_MonitorPutCB put_cb; /** - * Closure for cb. + * Closure for @e get_cb, @e put_cb and @e get_resp_cb. */ void *cb_cls; @@ -297,24 +211,9 @@ struct GNUNET_DHT_Handle 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. + * Connection to DHT service. */ - struct PendingMessage *pending_tail; + struct GNUNET_MQ_Handle *mq; /** * Head of linked list of messages we would like to monitor. @@ -345,7 +244,7 @@ struct GNUNET_DHT_Handle /** * Task for trying to reconnect. */ - struct GNUNET_SCHEDULER_Task * reconnect_task; + struct GNUNET_SCHEDULER_Task *reconnect_task; /** * How quickly should we retry? Used for exponential back-off on @@ -358,101 +257,93 @@ struct GNUNET_DHT_Handle */ uint64_t uid_gen; - /** - * Did we start our receive loop yet? - */ - int in_receive; -#if ENABLE_MALICIOUS - /** - * Handle of act malicious request. - */ - struct GNUNET_DHT_ActMaliciousHandle *mh; -#endif }; /** - * Handler for messages received from the DHT service - * a demultiplexer which handles numerous message types + * Try to (re)connect to the DHT service. * - * @param cls the `struct GNUNET_DHT_Handle` - * @param msg the incoming message + * @param h DHT handle to reconnect + * @return #GNUNET_YES on success, #GNUNET_NO on failure. */ -static void -service_message_handler (void *cls, - const struct GNUNET_MessageHeader *msg); +static int +try_connect (struct GNUNET_DHT_Handle *h); /** - * Try to (re)connect to the DHT service. + * Send GET message for a @a get_handle to DHT. * - * @param handle DHT handle to reconnect - * @return #GNUNET_YES on success, #GNUNET_NO on failure. + * @param gh GET to generate messages for. */ -static int -try_connect (struct GNUNET_DHT_Handle *handle) +static void +send_get (struct GNUNET_DHT_GetHandle *gh) { - if (NULL != handle->client) - return GNUNET_OK; - handle->in_receive = GNUNET_NO; - handle->client = GNUNET_CLIENT_connect ("dht", handle->cfg); - if (NULL == handle->client) - { - LOG (GNUNET_ERROR_TYPE_WARNING, - _("Failed to connect to the DHT service!\n")); - return GNUNET_NO; - } - return GNUNET_YES; + struct GNUNET_DHT_Handle *h = gh->dht_handle; + struct GNUNET_MQ_Envelope *env; + struct GNUNET_DHT_ClientGetMessage *get_msg; + + env = GNUNET_MQ_msg_extra (get_msg, + gh->xquery_size, + GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET); + get_msg->options = htonl ((uint32_t) gh->options); + get_msg->desired_replication_level = htonl (gh->desired_replication_level); + get_msg->type = htonl (gh->type); + get_msg->key = gh->key; + get_msg->unique_id = gh->unique_id; + memcpy (&get_msg[1], + &gh[1], + gh->xquery_size); + GNUNET_MQ_send (h->mq, + env); } /** - * Queue messages to DHT to block certain results from the result set. + * Send GET message(s) for indicating which results are already known + * for a @a get_handle to DHT. Complex as we need to send the list of + * known results, which means we may need mulitple messages to block + * known results from the result set. * - * @param get_handle GET to generate messages for. + * @param gh GET to generate messages for + * @param transmission_offset_start at which offset should we start? */ static void -queue_filter_messages (struct GNUNET_DHT_GetHandle *get_handle) +send_get_known_results (struct GNUNET_DHT_GetHandle *gh, + unsigned int transmission_offset_start) { - struct PendingMessage *pm; + struct GNUNET_DHT_Handle *h = gh->dht_handle; + struct GNUNET_MQ_Envelope *env; struct GNUNET_DHT_ClientGetResultSeenMessage *msg; - uint16_t msize; unsigned int delta; unsigned int max; + unsigned int transmission_offset; - while (get_handle->seen_results_transmission_offset < get_handle->seen_results_end) + max = (GNUNET_SERVER_MAX_MESSAGE_SIZE - sizeof (*msg)) + / sizeof (struct GNUNET_HashCode); + transmission_offset = transmission_offset_start; + while (transmission_offset < gh->seen_results_end) { - delta = get_handle->seen_results_end - get_handle->seen_results_transmission_offset; - max = (GNUNET_SERVER_MAX_MESSAGE_SIZE - sizeof (struct GNUNET_DHT_ClientGetResultSeenMessage)) / sizeof (struct GNUNET_HashCode); + delta = gh->seen_results_end - transmission_offset; if (delta > max) delta = max; - msize = sizeof (struct GNUNET_DHT_ClientGetResultSeenMessage) + delta * sizeof (struct GNUNET_HashCode); - - pm = GNUNET_malloc (sizeof (struct PendingMessage) + msize); - msg = (struct GNUNET_DHT_ClientGetResultSeenMessage *) &pm[1]; - pm->msg = &msg->header; - pm->handle = get_handle->dht_handle; - pm->unique_id = get_handle->unique_id; - pm->free_on_send = GNUNET_YES; - pm->in_pending_queue = GNUNET_YES; - msg->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET_RESULTS_KNOWN); - msg->header.size = htons (msize); - msg->key = get_handle->key; - msg->unique_id = get_handle->unique_id; + env = GNUNET_MQ_msg_extra (msg, + delta * sizeof (struct GNUNET_HashCode), + GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET_RESULTS_KNOWN); + msg->key = gh->key; + msg->unique_id = gh->unique_id; memcpy (&msg[1], - &get_handle->seen_results[get_handle->seen_results_transmission_offset], + &gh->seen_results[transmission_offset], sizeof (struct GNUNET_HashCode) * delta); - get_handle->seen_results_transmission_offset += delta; - GNUNET_CONTAINER_DLL_insert_tail (get_handle->dht_handle->pending_head, - get_handle->dht_handle->pending_tail, - pm); + GNUNET_MQ_send (h->mq, + env); + transmission_offset += delta; } } /** - * Add the request corresponding to the given route handle + * Add the GET 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 *` @@ -461,35 +352,49 @@ queue_filter_messages (struct GNUNET_DHT_GetHandle *get_handle) * @return #GNUNET_YES (always) */ static int -add_request_to_pending (void *cls, - const struct GNUNET_HashCode *key, - void *value) +add_get_request_to_pending (void *cls, + const struct GNUNET_HashCode *key, + void *value) { struct GNUNET_DHT_Handle *handle = cls; - struct GNUNET_DHT_GetHandle *get_handle = value; + struct GNUNET_DHT_GetHandle *gh = value; - if (GNUNET_NO == get_handle->message->in_pending_queue) - { - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Retransmitting request related to %s to DHT %p\n", GNUNET_h2s (key), - handle); - get_handle->seen_results_transmission_offset = 0; - GNUNET_CONTAINER_DLL_insert (handle->pending_head, handle->pending_tail, - get_handle->message); - queue_filter_messages (get_handle); - get_handle->message->in_pending_queue = GNUNET_YES; - } + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Retransmitting request related to %s to DHT %p\n", + GNUNET_h2s (key), + handle); + send_get (gh); + send_get_known_results (gh, 0); return GNUNET_YES; } /** - * Try to send messages from list of messages to send + * Send #GNUNET_MESSAGE_TYPE_DHT_MONITOR_START message. * - * @param handle DHT_Handle + * @param mh monitor handle to generate start message for */ static void -process_pending_messages (struct GNUNET_DHT_Handle *handle); +send_monitor_start (struct GNUNET_DHT_MonitorHandle *mh) +{ + struct GNUNET_DHT_Handle *h = mh->dht_handle; + struct GNUNET_MQ_Envelope *env; + struct GNUNET_DHT_MonitorStartStopMessage *m; + + env = GNUNET_MQ_msg (m, + GNUNET_MESSAGE_TYPE_DHT_MONITOR_START); + m->type = htonl (mh->type); + m->get = htons (NULL != mh->get_cb); + m->get_resp = htons (NULL != mh->get_resp_cb); + m->put = htons (NULL != mh->put_cb); + if (NULL != mh->key) + { + m->filter_key = htons(1); + m->key = *mh->key; + } + GNUNET_MQ_send (h->mq, + env); +} /** @@ -500,333 +405,238 @@ process_pending_messages (struct GNUNET_DHT_Handle *handle); static void try_reconnect (void *cls) { - struct GNUNET_DHT_Handle *handle = cls; + struct GNUNET_DHT_Handle *h = cls; + struct GNUNET_DHT_MonitorHandle *mh; - LOG (GNUNET_ERROR_TYPE_DEBUG, "Reconnecting with DHT %p\n", handle); - handle->retry_time = GNUNET_TIME_STD_BACKOFF (handle->retry_time); - handle->reconnect_task = NULL; - if (GNUNET_YES != try_connect (handle)) + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Reconnecting with DHT %p\n", + h); + h->retry_time = GNUNET_TIME_STD_BACKOFF (h->retry_time); + h->reconnect_task = NULL; + if (GNUNET_YES != try_connect (h)) { - LOG (GNUNET_ERROR_TYPE_DEBUG, "dht reconnect failed(!)\n"); + LOG (GNUNET_ERROR_TYPE_WARNING, + "DHT reconnect failed!\n"); + h->reconnect_task + = GNUNET_SCHEDULER_add_delayed (h->retry_time, + &try_reconnect, + h); return; } - GNUNET_CONTAINER_multihashmap_iterate (handle->active_requests, - &add_request_to_pending, handle); - process_pending_messages (handle); + GNUNET_CONTAINER_multihashmap_iterate (h->active_requests, + &add_get_request_to_pending, + h); + for (mh = h->monitor_head; NULL != mh; mh = mh->next) + send_monitor_start (mh); } /** * Try reconnecting to the DHT service. * - * @param handle handle to dht to (possibly) disconnect and reconnect + * @param h handle to dht to (possibly) disconnect and reconnect */ static void -do_disconnect (struct GNUNET_DHT_Handle *handle) +do_disconnect (struct GNUNET_DHT_Handle *h) { struct GNUNET_DHT_PutHandle *ph; - struct GNUNET_DHT_PutHandle *next; + GNUNET_DHT_PutContinuation cont; + void *cont_cls; - if (NULL == handle->client) + if (NULL == h->mq) return; - GNUNET_assert (NULL == handle->reconnect_task); - if (NULL != handle->th) - GNUNET_CLIENT_notify_transmit_ready_cancel (handle->th); - handle->th = NULL; + GNUNET_MQ_destroy (h->mq); + h->mq = NULL; GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from DHT service, will try to reconnect in %s\n", - GNUNET_STRINGS_relative_time_to_string (handle->retry_time, + GNUNET_STRINGS_relative_time_to_string (h->retry_time, GNUNET_YES)); - GNUNET_CLIENT_disconnect (handle->client); - handle->client = NULL; - - /* signal disconnect to all PUT requests that were transmitted but waiting - for the put confirmation */ - next = handle->put_head; - while (NULL != (ph = next)) + /* notify client about all PUTs that (may) have failed due to disconnect */ + while (NULL != (ph = h->put_head)) { - next = ph->next; - if (NULL == ph->pending) - { - if (NULL != ph->cont) - ph->cont (ph->cont_cls, GNUNET_SYSERR); - GNUNET_DHT_put_cancel (ph); - } + cont = ph->cont; + cont_cls = ph->cont_cls; + GNUNET_DHT_put_cancel (ph); + if (NULL != cont) + cont (cont_cls, + GNUNET_SYSERR); } - handle->reconnect_task = - GNUNET_SCHEDULER_add_delayed (handle->retry_time, &try_reconnect, handle); + GNUNET_assert (NULL == h->reconnect_task); + h->reconnect_task + = GNUNET_SCHEDULER_add_delayed (h->retry_time, + &try_reconnect, + h); } /** - * Transmit the next pending message, called by notify_transmit_ready + * Generic error handler, called with the appropriate error code and + * the same closure specified at the creation of the message queue. + * Not every message queue implementation supports an error handler. * - * @param cls the DHT handle - * @param size number of bytes available in @a buf for transmission - * @param buf where to copy messages for the service - * @return number of bytes written to @a buf + * @param cls closure with the `struct GNUNET_DHT_Handle *` + * @param error error code */ -static size_t -transmit_pending (void *cls, - size_t size, - void *buf); +static void +mq_error_handler (void *cls, + enum GNUNET_MQ_Error error) +{ + struct GNUNET_DHT_Handle *h = cls; + + do_disconnect (h); +} /** - * Try to send messages from list of messages to send + * Verify integrity of a get monitor message from the service. * - * @param handle handle to DHT + * @param cls The DHT handle. + * @param msg Monitor get message from the service. + * @return #GNUNET_OK if everything went fine, + * #GNUNET_SYSERR if the message is malformed. */ -static void -process_pending_messages (struct GNUNET_DHT_Handle *handle) +static int +check_monitor_get (void *cls, + const struct GNUNET_DHT_MonitorGetMessage *msg) { - struct PendingMessage *head; + uint32_t plen = ntohl (msg->get_path_length); + uint16_t msize = ntohs (msg->header.size) - sizeof (*msg); - if (NULL == handle->client) + if ( (plen > UINT16_MAX) || + (plen * sizeof (struct GNUNET_HashCode) != msize) ) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "process_pending_messages called, but client is NULL, reconnecting\n"); - do_disconnect (handle); - return; + GNUNET_break (0); + return GNUNET_SYSERR; } - if (NULL != handle->th) - 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) - return; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "notify_transmit_ready returned NULL, reconnecting\n"); - do_disconnect (handle); + return GNUNET_OK; } /** - * Transmit the next pending message, called by notify_transmit_ready + * Process a get monitor message from the service. * - * @param cls the DHT handle - * @param size number of bytes available in @a buf for transmission - * @param buf where to copy messages for the service - * @return number of bytes written to @a buf + * @param cls The DHT handle. + * @param msg Monitor get message from the service. */ -static size_t -transmit_pending (void *cls, - size_t size, - void *buf) +static void +handle_monitor_get (void *cls, + const struct GNUNET_DHT_MonitorGetMessage *msg) { struct GNUNET_DHT_Handle *handle = cls; - struct PendingMessage *head; - size_t tsize; + struct GNUNET_DHT_MonitorHandle *mh; - - handle->th = NULL; - if (NULL == buf) - { - 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); - head->in_pending_queue = GNUNET_NO; - if (NULL != head->cont) - { - head->cont (head->cont_cls); - head->cont = NULL; - head->cont_cls = NULL; - } - if (GNUNET_YES == head->free_on_send) - GNUNET_free (head); - process_pending_messages (handle); - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Forwarded request of %u bytes to DHT service\n", (unsigned int) tsize); - if (GNUNET_NO == handle->in_receive) + for (mh = handle->monitor_head; NULL != mh; mh = mh->next) { - LOG (GNUNET_ERROR_TYPE_DEBUG, "Starting to process replies from DHT\n"); - handle->in_receive = GNUNET_YES; - - GNUNET_CLIENT_receive (handle->client, &service_message_handler, handle, - GNUNET_TIME_UNIT_FOREVER_REL); + if (NULL == mh->get_cb) + continue; + if ( ( (GNUNET_BLOCK_TYPE_ANY == mh->type) || + (mh->type == ntohl (msg->type)) ) && + ( (NULL == mh->key) || + (0 == memcmp (mh->key, + &msg->key, + sizeof (struct GNUNET_HashCode))) ) ) + mh->get_cb (mh->cb_cls, + ntohl (msg->options), + (enum GNUNET_BLOCK_Type) ntohl(msg->type), + ntohl (msg->hop_count), + ntohl (msg->desired_replication_level), + ntohl (msg->get_path_length), + (struct GNUNET_PeerIdentity *) &msg[1], + &msg->key); } - return tsize; } /** - * Process a given reply that might match the given - * request. + * Validate a get response monitor message from the service. * - * @param cls the `struct GNUNET_DHT_ClientResultMessage` - * @param key query of the request - * @param value the `struct GNUNET_DHT_RouteHandle` of a request matching the same key - * @return #GNUNET_YES to continue to iterate over all results, - * #GNUNET_NO if the reply is malformed or we found a matching request + * @param cls The DHT handle. + * @param msg monitor get response message from the service + * @return #GNUNET_OK if everything went fine, + * #GNUNET_SYSERR if the message is malformed. */ static int -process_reply (void *cls, - const struct GNUNET_HashCode *key, - void *value) +check_monitor_get_resp (void *cls, + const struct GNUNET_DHT_MonitorGetRespMessage *msg) { - const struct GNUNET_DHT_ClientResultMessage *dht_msg = cls; - struct GNUNET_DHT_GetHandle *get_handle = value; - const struct GNUNET_PeerIdentity *put_path; - const struct GNUNET_PeerIdentity *get_path; - struct GNUNET_HashCode hc; - uint32_t put_path_length; - uint32_t get_path_length; - size_t data_length; - size_t msize; - size_t meta_length; - const void *data; + size_t msize = ntohs (msg->header.size) - sizeof (*msg); + uint32_t getl = ntohl (msg->get_path_length); + uint32_t putl = ntohl (msg->put_path_length); - if (dht_msg->unique_id != get_handle->unique_id) - { - /* UID mismatch */ - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Ignoring reply for %s: UID mismatch: %llu/%llu\n", GNUNET_h2s (key), - dht_msg->unique_id, get_handle->unique_id); - return GNUNET_YES; - } - msize = ntohs (dht_msg->header.size); - put_path_length = ntohl (dht_msg->put_path_length); - get_path_length = ntohl (dht_msg->get_path_length); - meta_length = - sizeof (struct GNUNET_DHT_ClientResultMessage) + - sizeof (struct GNUNET_PeerIdentity) * (get_path_length + put_path_length); - if ((msize < meta_length) || - (get_path_length > - GNUNET_SERVER_MAX_MESSAGE_SIZE / sizeof (struct GNUNET_PeerIdentity)) || - (put_path_length > - GNUNET_SERVER_MAX_MESSAGE_SIZE / sizeof (struct GNUNET_PeerIdentity))) + if ( (getl + putl < getl) || + ( (msize / sizeof (struct GNUNET_PeerIdentity)) < getl + putl) ) { GNUNET_break (0); - return GNUNET_NO; + return GNUNET_SYSERR; } - data_length = msize - meta_length; - LOG (GNUNET_ERROR_TYPE_DEBUG, "Giving %u byte reply for %s to application\n", - (unsigned int) data_length, GNUNET_h2s (key)); - put_path = (const struct GNUNET_PeerIdentity *) &dht_msg[1]; - get_path = &put_path[put_path_length]; - data = &get_path[get_path_length]; - /* remember that we've seen this result */ - GNUNET_CRYPTO_hash (data, data_length, &hc); - if (get_handle->seen_results_size == get_handle->seen_results_end) - GNUNET_array_grow (get_handle->seen_results, - get_handle->seen_results_size, - get_handle->seen_results_size * 2 + 1); - GNUNET_assert (get_handle->seen_results_end == get_handle->seen_results_transmission_offset); - get_handle->seen_results[get_handle->seen_results_end++] = hc; - /* no need to block it explicitly, service already knows about it! */ - get_handle->seen_results_transmission_offset++; - get_handle->iter (get_handle->iter_cls, - GNUNET_TIME_absolute_ntoh (dht_msg->expiration), key, - get_path, get_path_length, put_path, put_path_length, - ntohl (dht_msg->type), data_length, data); - return GNUNET_NO; + return GNUNET_OK; } /** - * Process a get monitor message from the service. + * Process a get response monitor message from the service. * - * @param handle The DHT handle. - * @param msg Monitor get message from the service. - * @return #GNUNET_OK if everything went fine, - * #GNUNET_SYSERR if the message is malformed. + * @param cls The DHT handle. + * @param msg monitor get response message from the service */ -static int -process_monitor_get_message (struct GNUNET_DHT_Handle *handle, - const struct GNUNET_DHT_MonitorGetMessage *msg) +static void +handle_monitor_get_resp (void *cls, + const struct GNUNET_DHT_MonitorGetRespMessage *msg) { - struct GNUNET_DHT_MonitorHandle *h; - - for (h = handle->monitor_head; NULL != h; h = h->next) + struct GNUNET_DHT_Handle *handle = cls; + size_t msize = ntohs (msg->header.size) - sizeof (*msg); + const struct GNUNET_PeerIdentity *path; + uint32_t getl = ntohl (msg->get_path_length); + uint32_t putl = ntohl (msg->put_path_length); + struct GNUNET_DHT_MonitorHandle *mh; + + path = (const struct GNUNET_PeerIdentity *) &msg[1]; + for (mh = handle->monitor_head; NULL != mh; mh = mh->next) { - int type_ok; - int key_ok; - - type_ok = (GNUNET_BLOCK_TYPE_ANY == h->type) || (h->type == ntohl(msg->type)); - key_ok = (NULL == h->key) || (0 == memcmp (h->key, &msg->key, - sizeof (struct GNUNET_HashCode))); - if (type_ok && key_ok && (NULL != h->get_cb)) - h->get_cb (h->cb_cls, - ntohl (msg->options), - (enum GNUNET_BLOCK_Type) ntohl(msg->type), - ntohl (msg->hop_count), - ntohl (msg->desired_replication_level), - ntohl (msg->get_path_length), - (struct GNUNET_PeerIdentity *) &msg[1], - &msg->key); + if (NULL == mh->get_resp_cb) + continue; + if ( ( (GNUNET_BLOCK_TYPE_ANY == mh->type) || + (mh->type == ntohl(msg->type)) ) && + ( (NULL == mh->key) || + (0 == memcmp (mh->key, + &msg->key, + sizeof (struct GNUNET_HashCode))) ) ) + mh->get_resp_cb (mh->cb_cls, + (enum GNUNET_BLOCK_Type) ntohl (msg->type), + path, + getl, + &path[getl], + putl, + GNUNET_TIME_absolute_ntoh(msg->expiration_time), + &msg->key, + (const void *) &path[getl + putl], + msize - sizeof (struct GNUNET_PeerIdentity) * (putl + getl)); } - return GNUNET_OK; } /** - * Process a get response monitor message from the service. + * Check validity of a put monitor message from the service. * - * @param handle The DHT handle. - * @param msg monitor get response message from the service + * @param cls The DHT handle. + * @param msg Monitor put message from the service. * @return #GNUNET_OK if everything went fine, * #GNUNET_SYSERR if the message is malformed. */ static int -process_monitor_get_resp_message (struct GNUNET_DHT_Handle *handle, - const struct GNUNET_DHT_MonitorGetRespMessage *msg) +check_monitor_put (void *cls, + const struct GNUNET_DHT_MonitorPutMessage *msg) { - struct GNUNET_DHT_MonitorHandle *h; - struct GNUNET_PeerIdentity *path; - uint32_t getl; - uint32_t putl; size_t msize; + uint32_t putl; - msize = ntohs (msg->header.size); - path = (struct GNUNET_PeerIdentity *) &msg[1]; - getl = ntohl (msg->get_path_length); + msize = ntohs (msg->header.size) - sizeof (*msg); putl = ntohl (msg->put_path_length); - if ( (getl + putl < getl) || - ( ((msize - sizeof (struct GNUNET_DHT_MonitorGetRespMessage)) / sizeof (struct GNUNET_PeerIdentity)) < getl + putl) ) + if ((msize / sizeof (struct GNUNET_PeerIdentity)) < putl) { GNUNET_break (0); return GNUNET_SYSERR; } - for (h = handle->monitor_head; NULL != h; h = h->next) - { - int type_ok; - int key_ok; - - type_ok = (GNUNET_BLOCK_TYPE_ANY == h->type) || (h->type == ntohl(msg->type)); - key_ok = (NULL == h->key) || (0 == memcmp (h->key, &msg->key, - sizeof (struct GNUNET_HashCode))); - if (type_ok && key_ok && (NULL != h->get_resp_cb)) - h->get_resp_cb (h->cb_cls, - (enum GNUNET_BLOCK_Type) ntohl(msg->type), - path, getl, - &path[getl], putl, - GNUNET_TIME_absolute_ntoh(msg->expiration_time), - &msg->key, - (void *) &path[getl + putl], - msize - - sizeof (struct GNUNET_DHT_MonitorGetRespMessage) - - sizeof (struct GNUNET_PeerIdentity) * (putl + getl)); - } return GNUNET_OK; } @@ -834,95 +644,177 @@ process_monitor_get_resp_message (struct GNUNET_DHT_Handle *handle, /** * Process a put monitor message from the service. * - * @param handle The DHT handle. + * @param cls The DHT handle. + * @param msg Monitor put message from the service. + */ +static void +handle_monitor_put (void *cls, + const struct GNUNET_DHT_MonitorPutMessage *msg) +{ + struct GNUNET_DHT_Handle *handle = cls; + size_t msize = ntohs (msg->header.size) - sizeof (*msg); + uint32_t putl = ntohl (msg->put_path_length); + const struct GNUNET_PeerIdentity *path; + struct GNUNET_DHT_MonitorHandle *mh; + + path = (const struct GNUNET_PeerIdentity *) &msg[1]; + for (mh = handle->monitor_head; NULL != mh; mh = mh->next) + { + if (NULL == mh->put_cb) + continue; + if ( ( (GNUNET_BLOCK_TYPE_ANY == mh->type) || + (mh->type == ntohl(msg->type)) ) && + ( (NULL == mh->key) || + (0 == memcmp (mh->key, + &msg->key, + sizeof (struct GNUNET_HashCode))) ) ) + mh->put_cb (mh->cb_cls, + ntohl (msg->options), + (enum GNUNET_BLOCK_Type) ntohl(msg->type), + ntohl (msg->hop_count), + ntohl (msg->desired_replication_level), + putl, + path, + GNUNET_TIME_absolute_ntoh(msg->expiration_time), + &msg->key, + (const void *) &path[putl], + msize - sizeof (struct GNUNET_PeerIdentity) * putl); + } +} + + +/** + * Verify that client result message received from the service is well-formed. + * + * @param cls The DHT handle. * @param msg Monitor put message from the service. * @return #GNUNET_OK if everything went fine, * #GNUNET_SYSERR if the message is malformed. */ static int -process_monitor_put_message (struct GNUNET_DHT_Handle *handle, - const struct GNUNET_DHT_MonitorPutMessage *msg) +check_client_result (void *cls, + const struct GNUNET_DHT_ClientResultMessage *msg) { - struct GNUNET_DHT_MonitorHandle *h; - size_t msize; - struct GNUNET_PeerIdentity *path; - uint32_t putl; + size_t msize = ntohs (msg->header.size) - sizeof (*msg); + uint32_t put_path_length = ntohl (msg->put_path_length); + uint32_t get_path_length = ntohl (msg->get_path_length); + size_t meta_length; - msize = ntohs (msg->header.size); - path = (struct GNUNET_PeerIdentity *) &msg[1]; - putl = ntohl (msg->put_path_length); - if (((msize - sizeof (struct GNUNET_DHT_MonitorGetRespMessage)) / sizeof (struct GNUNET_PeerIdentity)) < putl) + meta_length = + sizeof (struct GNUNET_PeerIdentity) * (get_path_length + put_path_length); + if ( (msize < meta_length) || + (get_path_length > + GNUNET_SERVER_MAX_MESSAGE_SIZE / sizeof (struct GNUNET_PeerIdentity)) || + (put_path_length > + GNUNET_SERVER_MAX_MESSAGE_SIZE / sizeof (struct GNUNET_PeerIdentity)) ) { GNUNET_break (0); return GNUNET_SYSERR; } - for (h = handle->monitor_head; NULL != h; h = h->next) - { - int type_ok; - int key_ok; - - type_ok = (GNUNET_BLOCK_TYPE_ANY == h->type) || (h->type == ntohl(msg->type)); - key_ok = (NULL == h->key) || (0 == memcmp (h->key, &msg->key, - sizeof (struct GNUNET_HashCode))); - if (type_ok && key_ok && (NULL != h->put_cb)) - h->put_cb (h->cb_cls, - ntohl (msg->options), - (enum GNUNET_BLOCK_Type) ntohl(msg->type), - ntohl (msg->hop_count), - ntohl (msg->desired_replication_level), - putl, path, - GNUNET_TIME_absolute_ntoh(msg->expiration_time), - &msg->key, - (void *) &path[putl], - msize - - sizeof (struct GNUNET_DHT_MonitorPutMessage) - - sizeof (struct GNUNET_PeerIdentity) * putl); - } return GNUNET_OK; } -#if ENABLE_MALICIOUS /** - * Process a act malicious confirmation from service. - * @param handle The DHT handle. - * @param msg confirmation message from the service. - * @return #GNUNET_OK if everything went fine, - * #GNUNET_SYSERR if the message is malformed. + * Process a given reply that might match the given request. + * + * @param cls the `struct GNUNET_DHT_ClientResultMessage` + * @param key query of the request + * @param value the `struct GNUNET_DHT_GetHandle` of a request matching the same key + * @return #GNUNET_YES to continue to iterate over all results */ static int -process_act_malicious_confirmation_message (struct GNUNET_DHT_Handle *handle, - const struct GNUNET_DHT_ClientActMaliciousConfirmationMessage *msg) +process_client_result (void *cls, + const struct GNUNET_HashCode *key, + void *value) { - struct GNUNET_DHT_ActMaliciousHandle *mh; - GNUNET_DHT_PutContinuation cont; - void *cont_cls; + const struct GNUNET_DHT_ClientResultMessage *crm = cls; + struct GNUNET_DHT_GetHandle *get_handle = value; + size_t msize = ntohs (crm->header.size) - sizeof (*crm); + uint32_t put_path_length = ntohl (crm->put_path_length); + uint32_t get_path_length = ntohl (crm->get_path_length); + const struct GNUNET_PeerIdentity *put_path; + const struct GNUNET_PeerIdentity *get_path; + struct GNUNET_HashCode hc; + size_t data_length; + size_t meta_length; + const void *data; - mh = handle->mh; - if (NULL == mh) - return GNUNET_OK; - cont = mh->cont; - cont_cls = mh->cont_cls; - if (NULL != cont) - cont (cont_cls, GNUNET_OK); + if (crm->unique_id != get_handle->unique_id) + { + /* UID mismatch */ + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Ignoring reply for %s: UID mismatch: %llu/%llu\n", + GNUNET_h2s (key), + crm->unique_id, + get_handle->unique_id); + return GNUNET_YES; + } + /* FIXME: might want to check that type matches */ + meta_length = + sizeof (struct GNUNET_PeerIdentity) * (get_path_length + put_path_length); + data_length = msize - meta_length; + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Giving %u byte reply for %s to application\n", + (unsigned int) data_length, + GNUNET_h2s (key)); + put_path = (const struct GNUNET_PeerIdentity *) &crm[1]; + get_path = &put_path[put_path_length]; + data = &get_path[get_path_length]; + /* remember that we've seen this result */ + GNUNET_CRYPTO_hash (data, + data_length, + &hc); + if (get_handle->seen_results_size == get_handle->seen_results_end) + GNUNET_array_grow (get_handle->seen_results, + get_handle->seen_results_size, + get_handle->seen_results_size * 2 + 1); + get_handle->seen_results[get_handle->seen_results_end++] = hc; + /* no need to block it explicitly, service already knows about it! */ + get_handle->iter (get_handle->iter_cls, + GNUNET_TIME_absolute_ntoh (crm->expiration), + key, + get_path, + get_path_length, + put_path, + put_path_length, + ntohl (crm->type), + data_length, + data); + return GNUNET_YES; +} - return GNUNET_OK; + +/** + * Process a client result message received from the service. + * + * @param cls The DHT handle. + * @param msg Monitor put message from the service. + */ +static void +handle_client_result (void *cls, + const struct GNUNET_DHT_ClientResultMessage *msg) +{ + struct GNUNET_DHT_Handle *handle = cls; + + GNUNET_CONTAINER_multihashmap_get_multiple (handle->active_requests, + &msg->key, + &process_client_result, + (void *) msg); } -#endif /** * Process a put confirmation message from the service. * - * @param handle The DHT handle. + * @param cls The DHT handle. * @param msg confirmation message from the service. - * @return #GNUNET_OK if everything went fine, - * #GNUNET_SYSERR if the message is malformed. */ -static int -process_put_confirmation_message (struct GNUNET_DHT_Handle *handle, - const struct GNUNET_DHT_ClientPutConfirmationMessage *msg) +static void +handle_put_confirmation (void *cls, + const struct GNUNET_DHT_ClientPutConfirmationMessage *msg) { + struct GNUNET_DHT_Handle *handle = cls; struct GNUNET_DHT_PutHandle *ph; GNUNET_DHT_PutContinuation cont; void *cont_cls; @@ -931,125 +823,62 @@ process_put_confirmation_message (struct GNUNET_DHT_Handle *handle, if (ph->unique_id == msg->unique_id) break; if (NULL == ph) - return GNUNET_OK; + return; cont = ph->cont; cont_cls = ph->cont_cls; GNUNET_DHT_put_cancel (ph); if (NULL != cont) - cont (cont_cls, GNUNET_OK); - return GNUNET_OK; + cont (cont_cls, + GNUNET_OK); } /** - * Handler for messages received from the DHT service - * a demultiplexer which handles numerous message types + * Try to (re)connect to the DHT service. * - * @param cls the `struct GNUNET_DHT_Handle` - * @param msg the incoming message + * @param h DHT handle to reconnect + * @return #GNUNET_YES on success, #GNUNET_NO on failure. */ -static void -service_message_handler (void *cls, const struct GNUNET_MessageHeader *msg) +static int +try_connect (struct GNUNET_DHT_Handle *h) { - struct GNUNET_DHT_Handle *handle = cls; - const struct GNUNET_DHT_ClientResultMessage *dht_msg; - uint16_t msize; - int ret; - - - if (NULL == msg) - { - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Error receiving data from DHT service, reconnecting\n"); - do_disconnect (handle); - return; - } - GNUNET_CLIENT_receive (handle->client, &service_message_handler, handle, - GNUNET_TIME_UNIT_FOREVER_REL); - ret = GNUNET_SYSERR; - msize = ntohs (msg->size); - switch (ntohs (msg->type)) + GNUNET_MQ_hd_var_size (monitor_get, + GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET, + struct GNUNET_DHT_MonitorGetMessage); + GNUNET_MQ_hd_var_size (monitor_get_resp, + GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET_RESP, + struct GNUNET_DHT_MonitorGetRespMessage); + GNUNET_MQ_hd_var_size (monitor_put, + GNUNET_MESSAGE_TYPE_DHT_MONITOR_PUT, + struct GNUNET_DHT_MonitorPutMessage); + GNUNET_MQ_hd_var_size (client_result, + GNUNET_MESSAGE_TYPE_DHT_CLIENT_RESULT, + struct GNUNET_DHT_ClientResultMessage); + GNUNET_MQ_hd_fixed_size (put_confirmation, + GNUNET_MESSAGE_TYPE_DHT_CLIENT_PUT_OK, + struct GNUNET_DHT_ClientPutConfirmationMessage); + struct GNUNET_MQ_MessageHandler handlers[] = { + make_monitor_get_handler (h), + make_monitor_get_resp_handler (h), + make_monitor_put_handler (h), + make_client_result_handler (h), + make_put_confirmation_handler (h), + GNUNET_MQ_handler_end () + }; + if (NULL != h->mq) + return GNUNET_OK; + h->mq = GNUNET_CLIENT_connecT (h->cfg, + "dht", + handlers, + &mq_error_handler, + h); + if (NULL == h->mq) { - case GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET: - if (msize < sizeof (struct GNUNET_DHT_MonitorGetMessage)) - { - GNUNET_break (0); - break; - } - ret = process_monitor_get_message(handle, - (const struct GNUNET_DHT_MonitorGetMessage *) msg); - break; - case GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET_RESP: - if (msize < sizeof (struct GNUNET_DHT_MonitorGetRespMessage)) - { - GNUNET_break (0); - break; - } - ret = process_monitor_get_resp_message(handle, - (const struct GNUNET_DHT_MonitorGetRespMessage *) msg); - break; - case GNUNET_MESSAGE_TYPE_DHT_MONITOR_PUT: - if (msize < sizeof (struct GNUNET_DHT_MonitorPutMessage)) - { - GNUNET_break (0); - break; - } - ret = process_monitor_put_message(handle, - (const struct GNUNET_DHT_MonitorPutMessage *) msg); - break; - case GNUNET_MESSAGE_TYPE_DHT_MONITOR_PUT_RESP: - /* Not implemented yet */ - GNUNET_break(0); - break; - case GNUNET_MESSAGE_TYPE_DHT_CLIENT_RESULT: - if (ntohs (msg->size) < sizeof (struct GNUNET_DHT_ClientResultMessage)) - { - GNUNET_break (0); - break; - } - dht_msg = (const struct GNUNET_DHT_ClientResultMessage *) msg; - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Received reply for `%s' from DHT service %p\n", - GNUNET_h2s (&dht_msg->key), handle); - GNUNET_CONTAINER_multihashmap_get_multiple (handle->active_requests, - &dht_msg->key, - &process_reply, - (void *) dht_msg); - ret = GNUNET_OK; - break; - case GNUNET_MESSAGE_TYPE_DHT_CLIENT_PUT_OK: - if (ntohs (msg->size) != sizeof (struct GNUNET_DHT_ClientPutConfirmationMessage)) - { - GNUNET_break (0); - break; - } - ret = process_put_confirmation_message (handle, - (const struct GNUNET_DHT_ClientPutConfirmationMessage*) msg); - break; -#if ENABLE_MALICIOUS - case GNUNET_MESSAGE_TYPE_DHT_CLIENT_ACT_MALICIOUS_OK: - if(msize != sizeof (struct GNUNET_DHT_ClientActMaliciousConfirmationMessage)) - { - GNUNET_break (0); - break; - } - ret = process_act_malicious_confirmation_message (handle, - (const struct GNUNET_DHT_ClientActMaliciousConfirmationMessage*) msg); - break; -#endif - default: - GNUNET_break(0); LOG (GNUNET_ERROR_TYPE_WARNING, - "Unknown DHT message type: %hu (%hu) size: %hu\n", - ntohs (msg->type), msg->type, msize); - break; - } - if (GNUNET_OK != ret) - { - GNUNET_break (0); - do_disconnect (handle); - return; + "Failed to connect to the DHT service!\n"); + return GNUNET_NO; } + return GNUNET_YES; } @@ -1069,9 +898,12 @@ GNUNET_DHT_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, handle = GNUNET_new (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, GNUNET_YES); + handle->uid_gen + = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, + UINT64_MAX); + handle->active_requests + = GNUNET_CONTAINER_multihashmap_create (ht_len, + GNUNET_YES); if (GNUNET_NO == try_connect (handle)) { GNUNET_DHT_disconnect (handle); @@ -1089,92 +921,33 @@ GNUNET_DHT_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, void GNUNET_DHT_disconnect (struct GNUNET_DHT_Handle *handle) { - struct PendingMessage *pm; struct GNUNET_DHT_PutHandle *ph; - GNUNET_assert (NULL != handle); GNUNET_assert (0 == GNUNET_CONTAINER_multihashmap_size (handle->active_requests)); - if (NULL != handle->th) - { - GNUNET_CLIENT_notify_transmit_ready_cancel (handle->th); - handle->th = NULL; - } - while (NULL != (pm = handle->pending_head)) - { - GNUNET_assert (GNUNET_YES == pm->in_pending_queue); - GNUNET_CONTAINER_DLL_remove (handle->pending_head, handle->pending_tail, - pm); - pm->in_pending_queue = GNUNET_NO; - GNUNET_assert (GNUNET_YES == pm->free_on_send); - if (NULL != pm->cont) - pm->cont (pm->cont_cls); - GNUNET_free (pm); - } while (NULL != (ph = handle->put_head)) { - GNUNET_break (NULL == ph->pending); if (NULL != ph->cont) - ph->cont (ph->cont_cls, GNUNET_SYSERR); + ph->cont (ph->cont_cls, + GNUNET_SYSERR); GNUNET_DHT_put_cancel (ph); } - - if (NULL != handle->client) + if (NULL != handle->mq) { - GNUNET_CLIENT_disconnect (handle->client); - handle->client = NULL; + GNUNET_MQ_destroy (handle->mq); + handle->mq = NULL; } if (NULL != handle->reconnect_task) + { GNUNET_SCHEDULER_cancel (handle->reconnect_task); + handle->reconnect_task = NULL; + } GNUNET_CONTAINER_multihashmap_destroy (handle->active_requests); GNUNET_free (handle); } /** - * Timeout for the transmission of a fire&forget-request. Clean it up. - * - * @param cls the `struct GNUNET_DHT_PutHandle *` - */ -static void -timeout_put_request (void *cls) -{ - struct GNUNET_DHT_PutHandle *ph = cls; - struct GNUNET_DHT_Handle *handle = ph->dht_handle; - - ph->timeout_task = NULL; - if (NULL != ph->pending) - { - GNUNET_CONTAINER_DLL_remove (handle->pending_head, handle->pending_tail, - ph->pending); - ph->pending->in_pending_queue = GNUNET_NO; - GNUNET_free (ph->pending); - } - if (NULL != ph->cont) - ph->cont (ph->cont_cls, GNUNET_NO); - GNUNET_CONTAINER_DLL_remove (handle->put_head, - handle->put_tail, - ph); - GNUNET_free (ph); -} - - -/** - * Function called whenever the PUT message leaves the queue. Sets - * the message pointer in the put handle to NULL. - * - * @param cls the `struct GNUNET_DHT_PutHandle` - */ -static void -mark_put_message_gone (void *cls) -{ - struct GNUNET_DHT_PutHandle *ph = cls; - - ph->pending = NULL; -} - - -/** * Perform a PUT operation storing data in the DHT. FIXME: we should * change the protocol to get a confirmation for the PUT from the DHT * and call 'cont' only after getting the confirmation; otherwise, the @@ -1190,26 +963,25 @@ mark_put_message_gone (void *cls) * @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) * You must not call #GNUNET_DHT_disconnect in this continuation * @param cont_cls closure for @a cont */ struct GNUNET_DHT_PutHandle * GNUNET_DHT_put (struct GNUNET_DHT_Handle *handle, - const struct GNUNET_HashCode * key, + const struct GNUNET_HashCode *key, uint32_t desired_replication_level, enum GNUNET_DHT_RouteOption options, - enum GNUNET_BLOCK_Type type, size_t size, - const void *data, + enum GNUNET_BLOCK_Type type, + size_t size, + const void *data, struct GNUNET_TIME_Absolute exp, - struct GNUNET_TIME_Relative timeout, - GNUNET_DHT_PutContinuation cont, + GNUNET_DHT_PutContinuation cont, void *cont_cls) { + struct GNUNET_MQ_Envelope *env; struct GNUNET_DHT_ClientPutMessage *put_msg; size_t msize; - struct PendingMessage *pending; struct GNUNET_DHT_PutHandle *ph; msize = sizeof (struct GNUNET_DHT_ClientPutMessage) + size; @@ -1219,36 +991,30 @@ GNUNET_DHT_put (struct GNUNET_DHT_Handle *handle, GNUNET_break (0); return NULL; } + if (NULL == handle->mq) + return NULL; ph = GNUNET_new (struct GNUNET_DHT_PutHandle); ph->dht_handle = handle; - ph->timeout_task = GNUNET_SCHEDULER_add_delayed (timeout, &timeout_put_request, ph); ph->cont = cont; ph->cont_cls = cont_cls; ph->unique_id = ++handle->uid_gen; - pending = GNUNET_malloc (sizeof (struct PendingMessage) + msize); - ph->pending = pending; - put_msg = (struct GNUNET_DHT_ClientPutMessage *) &pending[1]; - pending->msg = &put_msg->header; - pending->handle = handle; - pending->cont = &mark_put_message_gone; - pending->cont_cls = ph; - pending->free_on_send = GNUNET_YES; - put_msg->header.size = htons (msize); - put_msg->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_CLIENT_PUT); - put_msg->type = htonl (type); + GNUNET_CONTAINER_DLL_insert_tail (handle->put_head, + handle->put_tail, + ph); + env = GNUNET_MQ_msg_extra (put_msg, + size, + GNUNET_MESSAGE_TYPE_DHT_CLIENT_PUT); + put_msg->type = htonl ((uint32_t) type); put_msg->options = htonl ((uint32_t) options); put_msg->desired_replication_level = htonl (desired_replication_level); put_msg->unique_id = ph->unique_id; put_msg->expiration = GNUNET_TIME_absolute_hton (exp); put_msg->key = *key; - memcpy (&put_msg[1], data, size); - GNUNET_CONTAINER_DLL_insert (handle->pending_head, handle->pending_tail, - pending); - pending->in_pending_queue = GNUNET_YES; - GNUNET_CONTAINER_DLL_insert_tail (handle->put_head, - handle->put_tail, - ph); - process_pending_messages (handle); + memcpy (&put_msg[1], + data, + size); + GNUNET_MQ_send (handle->mq, + env); return ph; } @@ -1269,19 +1035,6 @@ GNUNET_DHT_put_cancel (struct GNUNET_DHT_PutHandle *ph) { struct GNUNET_DHT_Handle *handle = ph->dht_handle; - if (NULL != ph->pending) - { - GNUNET_CONTAINER_DLL_remove (handle->pending_head, - handle->pending_tail, - ph->pending); - GNUNET_free (ph->pending); - ph->pending = NULL; - } - if (ph->timeout_task != NULL) - { - GNUNET_SCHEDULER_cancel (ph->timeout_task); - ph->timeout_task = NULL; - } GNUNET_CONTAINER_DLL_remove (handle->put_head, handle->put_tail, ph); @@ -1302,21 +1055,22 @@ GNUNET_DHT_put_cancel (struct GNUNET_DHT_PutHandle *ph) * @param xquery extended query data (can be NULL, depending on type) * @param xquery_size number of bytes in @a xquery * @param iter function to call on each result - * @param iter_cls closure for iter + * @param iter_cls closure for @a iter * @return handle to stop the async get */ struct GNUNET_DHT_GetHandle * GNUNET_DHT_get_start (struct GNUNET_DHT_Handle *handle, - enum GNUNET_BLOCK_Type type, const struct GNUNET_HashCode * key, + enum GNUNET_BLOCK_Type type, + const struct GNUNET_HashCode *key, uint32_t desired_replication_level, - enum GNUNET_DHT_RouteOption options, const void *xquery, - size_t xquery_size, GNUNET_DHT_GetIterator iter, + enum GNUNET_DHT_RouteOption options, + const void *xquery, + size_t xquery_size, + GNUNET_DHT_GetIterator iter, void *iter_cls) { - struct GNUNET_DHT_ClientGetMessage *get_msg; - struct GNUNET_DHT_GetHandle *get_handle; + struct GNUNET_DHT_GetHandle *gh; size_t msize; - struct PendingMessage *pending; msize = sizeof (struct GNUNET_DHT_ClientGetMessage) + xquery_size; if ((msize >= GNUNET_SERVER_MAX_MESSAGE_SIZE) || @@ -1325,37 +1079,31 @@ GNUNET_DHT_get_start (struct GNUNET_DHT_Handle *handle, GNUNET_break (0); return NULL; } - LOG (GNUNET_ERROR_TYPE_DEBUG, "Sending query for %s to DHT %p\n", - GNUNET_h2s (key), handle); - pending = GNUNET_malloc (sizeof (struct PendingMessage) + msize); - get_msg = (struct GNUNET_DHT_ClientGetMessage *) &pending[1]; - pending->msg = &get_msg->header; - pending->handle = handle; - pending->free_on_send = GNUNET_NO; - get_msg->header.size = htons (msize); - get_msg->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET); - get_msg->options = htonl ((uint32_t) options); - get_msg->desired_replication_level = htonl (desired_replication_level); - get_msg->type = htonl (type); - get_msg->key = *key; - get_msg->unique_id = ++handle->uid_gen; - memcpy (&get_msg[1], xquery, xquery_size); - GNUNET_CONTAINER_DLL_insert (handle->pending_head, handle->pending_tail, - pending); - pending->in_pending_queue = GNUNET_YES; - get_handle = GNUNET_new (struct GNUNET_DHT_GetHandle); - get_handle->key = *key; - get_handle->dht_handle = handle; - get_handle->iter = iter; - get_handle->iter_cls = iter_cls; - get_handle->message = pending; - get_handle->unique_id = get_msg->unique_id; + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Sending query for %s to DHT %p\n", + GNUNET_h2s (key), + handle); + gh = GNUNET_malloc (sizeof (struct GNUNET_DHT_GetHandle) + + xquery_size); + gh->iter = iter; + gh->iter_cls = iter_cls; + gh->dht_handle = handle; + gh->key = *key; + gh->unique_id = ++handle->uid_gen; + gh->xquery_size = xquery_size; + gh->desired_replication_level = desired_replication_level; + gh->type = type; + gh->options = options; + memcpy (&gh[1], + xquery, + xquery_size); GNUNET_CONTAINER_multihashmap_put (handle->active_requests, - &get_handle->key, - get_handle, + &gh->key, + gh, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); - process_pending_messages (handle); - return get_handle; + if (NULL != handle->mq) + send_get (gh); + return gh; } @@ -1375,8 +1123,10 @@ GNUNET_DHT_get_filter_known_results (struct GNUNET_DHT_GetHandle *get_handle, const struct GNUNET_HashCode *results) { unsigned int needed; + unsigned int had; - needed = get_handle->seen_results_end + num_results; + had = get_handle->seen_results_end; + needed = had + num_results; if (needed > get_handle->seen_results_size) GNUNET_array_grow (get_handle->seen_results, get_handle->seen_results_size, @@ -1385,8 +1135,9 @@ GNUNET_DHT_get_filter_known_results (struct GNUNET_DHT_GetHandle *get_handle, results, num_results * sizeof (struct GNUNET_HashCode)); get_handle->seen_results_end += num_results; - queue_filter_messages (get_handle); - process_pending_messages (get_handle->dht_handle); + if (NULL != get_handle->dht_handle->mq) + send_get_known_results (get_handle, + had); } @@ -1398,52 +1149,33 @@ GNUNET_DHT_get_filter_known_results (struct GNUNET_DHT_GetHandle *get_handle, void GNUNET_DHT_get_stop (struct GNUNET_DHT_GetHandle *get_handle) { - struct GNUNET_DHT_Handle *handle; - const struct GNUNET_DHT_ClientGetMessage *get_msg; - struct GNUNET_DHT_ClientGetStopMessage *stop_msg; - struct PendingMessage *pending; + struct GNUNET_DHT_Handle *handle = get_handle->dht_handle; - handle = get_handle->message->handle; - get_msg = - (const struct GNUNET_DHT_ClientGetMessage *) get_handle->message->msg; LOG (GNUNET_ERROR_TYPE_DEBUG, "Sending STOP for %s to DHT via %p\n", - GNUNET_h2s (&get_msg->key), handle); - /* generate STOP */ - pending = - GNUNET_malloc (sizeof (struct PendingMessage) + - sizeof (struct GNUNET_DHT_ClientGetStopMessage)); - stop_msg = (struct GNUNET_DHT_ClientGetStopMessage *) &pending[1]; - pending->msg = &stop_msg->header; - pending->handle = handle; - pending->free_on_send = GNUNET_YES; - stop_msg->header.size = - htons (sizeof (struct GNUNET_DHT_ClientGetStopMessage)); - stop_msg->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET_STOP); - stop_msg->reserved = htonl (0); - stop_msg->unique_id = get_msg->unique_id; - stop_msg->key = get_msg->key; - GNUNET_CONTAINER_DLL_insert (handle->pending_head, handle->pending_tail, - pending); - pending->in_pending_queue = GNUNET_YES; - - /* remove 'GET' from active status */ + GNUNET_h2s (&get_handle->key), + handle); + if (NULL != handle->mq) + { + struct GNUNET_MQ_Envelope *env; + struct GNUNET_DHT_ClientGetStopMessage *stop_msg; + + env = GNUNET_MQ_msg (stop_msg, + GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET_STOP); + stop_msg->reserved = htonl (0); + stop_msg->unique_id = get_handle->unique_id; + stop_msg->key = get_handle->key; + GNUNET_MQ_send (handle->mq, + env); + } GNUNET_assert (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (handle->active_requests, &get_handle->key, get_handle)); - if (GNUNET_YES == get_handle->message->in_pending_queue) - { - GNUNET_CONTAINER_DLL_remove (handle->pending_head, handle->pending_tail, - get_handle->message); - get_handle->message->in_pending_queue = GNUNET_NO; - } - GNUNET_free (get_handle->message); GNUNET_array_grow (get_handle->seen_results, get_handle->seen_results_end, 0); GNUNET_free (get_handle); - process_pending_messages (handle); } @@ -1468,141 +1200,62 @@ GNUNET_DHT_monitor_start (struct GNUNET_DHT_Handle *handle, GNUNET_DHT_MonitorPutCB put_cb, void *cb_cls) { - struct GNUNET_DHT_MonitorHandle *h; - struct GNUNET_DHT_MonitorStartStopMessage *m; - struct PendingMessage *pending; - - h = GNUNET_new (struct GNUNET_DHT_MonitorHandle); - GNUNET_CONTAINER_DLL_insert(handle->monitor_head, handle->monitor_tail, h); - - h->get_cb = get_cb; - h->get_resp_cb = get_resp_cb; - h->put_cb = put_cb; - h->cb_cls = cb_cls; - h->type = type; - h->dht_handle = handle; + struct GNUNET_DHT_MonitorHandle *mh; + + mh = GNUNET_new (struct GNUNET_DHT_MonitorHandle); + mh->get_cb = get_cb; + mh->get_resp_cb = get_resp_cb; + mh->put_cb = put_cb; + mh->cb_cls = cb_cls; + mh->type = type; + mh->dht_handle = handle; if (NULL != key) { - h->key = GNUNET_new (struct GNUNET_HashCode); - *h->key = *key; - } - - pending = GNUNET_malloc (sizeof (struct GNUNET_DHT_MonitorStartStopMessage) + - sizeof (struct PendingMessage)); - m = (struct GNUNET_DHT_MonitorStartStopMessage *) &pending[1]; - pending->msg = &m->header; - pending->handle = handle; - pending->free_on_send = GNUNET_YES; - m->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_MONITOR_START); - m->header.size = htons (sizeof (struct GNUNET_DHT_MonitorStartStopMessage)); - m->type = htonl(type); - m->get = htons(NULL != get_cb); - m->get_resp = htons(NULL != get_resp_cb); - m->put = htons(NULL != put_cb); - if (NULL != key) { - m->filter_key = htons(1); - memcpy (&m->key, key, sizeof(struct GNUNET_HashCode)); + mh->key = GNUNET_new (struct GNUNET_HashCode); + *mh->key = *key; } - GNUNET_CONTAINER_DLL_insert (handle->pending_head, handle->pending_tail, - pending); - pending->in_pending_queue = GNUNET_YES; - process_pending_messages (handle); - - return h; + GNUNET_CONTAINER_DLL_insert (handle->monitor_head, + handle->monitor_tail, + mh); + if (NULL != handle->mq) + send_monitor_start (mh); + return mh; } /** * Stop monitoring. * - * @param handle The handle to the monitor request returned by monitor_start. + * @param mh The handle to the monitor request returned by monitor_start. * * On return get_handle will no longer be valid, caller must not use again!!! */ void -GNUNET_DHT_monitor_stop (struct GNUNET_DHT_MonitorHandle *handle) +GNUNET_DHT_monitor_stop (struct GNUNET_DHT_MonitorHandle *mh) { + struct GNUNET_DHT_Handle *handle = mh->dht_handle; struct GNUNET_DHT_MonitorStartStopMessage *m; - struct PendingMessage *pending; - - GNUNET_CONTAINER_DLL_remove (handle->dht_handle->monitor_head, - handle->dht_handle->monitor_tail, - handle); - - pending = GNUNET_malloc (sizeof (struct GNUNET_DHT_MonitorStartStopMessage) + - sizeof (struct PendingMessage)); - m = (struct GNUNET_DHT_MonitorStartStopMessage *) &pending[1]; - pending->msg = &m->header; - pending->handle = handle->dht_handle; - pending->free_on_send = GNUNET_YES; - m->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_MONITOR_STOP); - m->header.size = htons (sizeof (struct GNUNET_DHT_MonitorStartStopMessage)); - m->type = htonl(handle->type); - m->get = htons (NULL != handle->get_cb); - m->get_resp = htons(NULL != handle->get_resp_cb); - m->put = htons (NULL != handle->put_cb); - if (NULL != handle->key) + struct GNUNET_MQ_Envelope *env; + + GNUNET_CONTAINER_DLL_remove (handle->monitor_head, + handle->monitor_tail, + mh); + env = GNUNET_MQ_msg (m, + GNUNET_MESSAGE_TYPE_DHT_MONITOR_STOP); + m->type = htonl (mh->type); + m->get = htons (NULL != mh->get_cb); + m->get_resp = htons(NULL != mh->get_resp_cb); + m->put = htons (NULL != mh->put_cb); + if (NULL != mh->key) { m->filter_key = htons (1); - m->key = *handle->key; - } - GNUNET_CONTAINER_DLL_insert (handle->dht_handle->pending_head, - handle->dht_handle->pending_tail, - pending); - pending->in_pending_queue = GNUNET_YES; - process_pending_messages (handle->dht_handle); - - GNUNET_free_non_null (handle->key); - GNUNET_free (handle); -} - - -#if ENABLE_MALICIOUS -/** - * Turn the DHT service to act malicious. - * - * @param handle the DHT handle - * @param action 1 to make the service malicious; 0 to make it benign - * @param cont continuation to call when done (transmitting request to service) - * @param cont_cls closure for @a cont - */ -struct GNUNET_DHT_ActMaliciousHandle * -GNUNET_DHT_act_malicious (struct GNUNET_DHT_Handle *handle, - unsigned int action, - GNUNET_DHT_PutContinuation cont, - void *cont_cls) -{ - struct GNUNET_DHT_ActMaliciousMessage *amm; - struct GNUNET_DHT_ActMaliciousHandle *mh; - struct PendingMessage *pending; - size_t msize; - - msize = sizeof(struct GNUNET_DHT_ActMaliciousMessage); - if (msize >= GNUNET_SERVER_MAX_MESSAGE_SIZE) - { - GNUNET_break(0); - return NULL; + m->key = *mh->key; } - mh = GNUNET_new (struct GNUNET_DHT_ActMaliciousHandle); - mh->dht_handle = handle; - mh->cont = cont; - mh->cont_cls = cont_cls; - pending = GNUNET_malloc (sizeof (struct PendingMessage) + msize); - amm = (struct GNUNET_DHT_ActMaliciousMessage *)&pending[1]; - pending->msg = &amm->header; - pending->handle = handle; - pending->free_on_send = GNUNET_YES; - amm->header.size = htons (msize); - amm->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_ACT_MALICIOUS); - amm->action = action; - handle->mh = mh; - GNUNET_CONTAINER_DLL_insert (handle->pending_head, handle->pending_tail, - pending); - pending->in_pending_queue = GNUNET_YES; - process_pending_messages (handle); - return mh; + GNUNET_MQ_send (handle->mq, + env); + GNUNET_free_non_null (mh->key); + GNUNET_free (mh); } -#endif /* end of dht_api.c */ diff --git a/src/dht/gnunet-dht-put.c b/src/dht/gnunet-dht-put.c index 972369e10..1f3df1d35 100644 --- a/src/dht/gnunet-dht-put.c +++ b/src/dht/gnunet-dht-put.c @@ -42,11 +42,6 @@ struct GNUNET_HashCode key; static char *query_key; /** - * User supplied timeout value - */ -static unsigned long long timeout_request = 5; - -/** * User supplied expiration value */ static unsigned long long expiration_seconds = 3600; @@ -148,7 +143,6 @@ run (void *cls, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c) { - struct GNUNET_TIME_Relative timeout; struct GNUNET_TIME_Absolute expiration; cfg = c; @@ -170,8 +164,6 @@ run (void *cls, GNUNET_CRYPTO_hash (query_key, strlen (query_key), &key); - timeout = - GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, timeout_request); expiration = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, @@ -179,12 +171,16 @@ run (void *cls, if (verbose) FPRINTF (stderr, _("Issuing put request for `%s' with data `%s'!\n"), query_key, data); - GNUNET_DHT_put (dht_handle, &key, replication, + GNUNET_DHT_put (dht_handle, + &key, + replication, (demultixplex_everywhere) ? GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE : GNUNET_DHT_RO_NONE, query_type, - strlen (data), data, expiration, timeout, &message_sent_cont, + strlen (data), + data, + expiration, + &message_sent_cont, NULL); - } @@ -210,9 +206,6 @@ static struct GNUNET_GETOPT_CommandLineOption options[] = { {'t', "type", "TYPE", gettext_noop ("the type to insert data as"), 1, &GNUNET_GETOPT_set_uint, &query_type}, - {'T', "timeout", "TIMEOUT", - gettext_noop ("how long to execute this query before giving up?"), - 1, &GNUNET_GETOPT_set_ulong, &timeout_request}, {'V', "verbose", NULL, gettext_noop ("be verbose (print progress information)"), 0, &GNUNET_GETOPT_set_one, &verbose}, @@ -230,10 +223,9 @@ static struct GNUNET_GETOPT_CommandLineOption options[] = { int main (int argc, char *const *argv) { - if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv)) + if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, + &argc, &argv)) return 2; - - return (GNUNET_OK == GNUNET_PROGRAM_run (argc, argv, "gnunet-dht-put", gettext_noop diff --git a/src/dht/gnunet-service-xdht.c b/src/dht/gnunet-service-xdht.c index 8a60a8d9d..e7b2c50c4 100644 --- a/src/dht/gnunet-service-xdht.c +++ b/src/dht/gnunet-service-xdht.c @@ -59,13 +59,6 @@ const struct GNUNET_CONFIGURATION_Handle *GDS_cfg; */ extern unsigned int track_topology; -#if ENABLE_MALICIOUS -/** - * Should this peer act malicious? - */ -unsigned int malicious; -#endif - /** * Task run during shutdown. diff --git a/src/dht/gnunet-service-xdht_clients.c b/src/dht/gnunet-service-xdht_clients.c index bc5504ebe..afd14c78d 100644 --- a/src/dht/gnunet-service-xdht_clients.c +++ b/src/dht/gnunet-service-xdht_clients.c @@ -1295,42 +1295,6 @@ handle_dht_local_monitor_stop (void *cls, struct GNUNET_SERVER_Client *client, } -#if ENABLE_MALICIOUS -/** - * Handler for act malicious message. - * - * @param cls closure for the service - * @param client the client we received this message from - * @param message the actual message received - * - */ -static void -handle_dht_act_malicious (void *cls, struct GNUNET_SERVER_Client *client, - const struct GNUNET_MessageHeader *message) -{ - const struct GNUNET_DHT_ActMaliciousMessage *msg; - struct PendingMessage *pm; - struct GNUNET_DHT_ClientActMaliciousConfirmationMessage *conf; - unsigned int malicious_action; - - msg = (const struct GNUNET_DHT_ActMaliciousMessage *)message; - malicious_action = msg->action; - - if(GNUNET_OK == GDS_NEIGHBOURS_act_malicious (malicious_action)) - { - pm = GNUNET_malloc (sizeof (struct PendingMessage) + - sizeof (struct GNUNET_DHT_ClientActMaliciousConfirmationMessage)); - conf = (struct GNUNET_DHT_ClientActMaliciousConfirmationMessage *) &pm[1]; - conf->header.size = htons (sizeof (struct GNUNET_DHT_ClientActMaliciousConfirmationMessage)); - conf->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_CLIENT_ACT_MALICIOUS_OK); - pm->msg = &conf->header; - add_pending_message (find_active_client (client), pm); - GNUNET_SERVER_receive_done (client, GNUNET_OK); - } -} -#endif - - /** * Functions with this signature are called whenever a client * is disconnected on the network level. @@ -1406,11 +1370,6 @@ GDS_CLIENTS_init (struct GNUNET_SERVER_Handle *server) sizeof (struct GNUNET_DHT_MonitorStartStopMessage)}, {&handle_dht_local_get_result_seen, NULL, GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET_RESULTS_KNOWN, 0}, - #if ENABLE_MALICIOUS - {&handle_dht_act_malicious, NULL, - GNUNET_MESSAGE_TYPE_DHT_ACT_MALICIOUS, - sizeof (struct GNUNET_DHT_ActMaliciousMessage)}, - #endif {NULL, NULL, 0, 0} }; forward_map = GNUNET_CONTAINER_multihashmap_create (1024, GNUNET_NO); diff --git a/src/dht/gnunet-service-xdht_neighbours.c b/src/dht/gnunet-service-xdht_neighbours.c index 6f3137f8a..314f6d13d 100644 --- a/src/dht/gnunet-service-xdht_neighbours.c +++ b/src/dht/gnunet-service-xdht_neighbours.c @@ -939,12 +939,6 @@ static struct GNUNET_TIME_Relative notify_successor_retry_time; unsigned int track_topology; /** - * Should I be a malicious peer and drop the PUT/GET packets? - * if 0 then NOT malicious. - */ -unsigned int act_malicious; - -/** * Count of fingers found. Ideally we should have O(logn) fingers for a * stable network. */ @@ -1068,19 +1062,6 @@ process_friend_queue (struct FriendInfo *peer) } -#if ENABLE_MALICIOUS -/** - * Set the ENABLE_MALICIOUS value to malicious. - * @param malicious - */ -int -GDS_NEIGHBOURS_act_malicious (unsigned int malicious) -{ - act_malicious = malicious; - return GNUNET_OK; -} -#endif - /** * Construct a trail setup message and forward it to target_friend * @param source_peer Peer which wants to setup the trail @@ -2291,38 +2272,6 @@ GDS_NEIGHBOURS_handle_put (const struct GNUNET_HashCode *key, } /* In case we are sending the request to a finger, then send across all of its trail.*/ -#if ENABLE_MALICIOUS - if (0 != GNUNET_CRYPTO_cmp_peer_identity (&successor.best_known_destination, - &successor.next_hop)) - { - struct FingerInfo *next_hop_finger; - unsigned int i; - - next_hop_finger = &finger_table[successor.finger_table_index]; - for (i = 0; i < next_hop_finger->trails_count; i++) - { - if (GNUNET_YES == next_hop_finger->trail_list[i].is_present) - { - if(0 == next_hop_finger->trail_list[i].trail_length) - { - GDS_NEIGHBOURS_send_put (key, block_type, options, desired_replication_level, - best_known_dest, intermediate_trail_id, &next_hop, - 0, 1, &my_identity, expiration_time, - data, data_size); - return; - } - next_hop = next_hop_finger->trail_list[i].trail_head->peer; - GDS_NEIGHBOURS_send_put (key, block_type, options, desired_replication_level, - best_known_dest, - next_hop_finger->trail_list[i].trail_id, - &next_hop, 0, 1, &my_identity, - expiration_time, - data, data_size); - } - } - return; - } -#endif GDS_NEIGHBOURS_send_put (key, block_type, options, desired_replication_level, best_known_dest, intermediate_trail_id, &next_hop, 0, 1, &my_identity, expiration_time, @@ -2436,38 +2385,6 @@ GDS_NEIGHBOURS_handle_get(const struct GNUNET_HashCode *key, return; } -#if ENABLE_MALICIOUS - struct GNUNET_PeerIdentity next_hop; - if (0 != GNUNET_CRYPTO_cmp_peer_identity (&successor.best_known_destination, - &successor.next_hop)) - { - struct FingerInfo *next_hop_finger; - unsigned int i; - - next_hop_finger = &finger_table[successor.finger_table_index]; - for (i = 0; i < next_hop_finger->trails_count; i++) - { - if (GNUNET_YES == next_hop_finger->trail_list[i].is_present) - { - if(0 == next_hop_finger->trail_list[i].trail_length) - { - GDS_NEIGHBOURS_send_get (key, block_type, options, - desired_replication_level, - best_known_dest,intermediate_trail_id, - &successor.next_hop, - 0, 1, &my_identity); - return; - } - next_hop = next_hop_finger->trail_list[i].trail_head->peer; - GDS_NEIGHBOURS_send_get (key, block_type, options, desired_replication_level, - best_known_dest, - next_hop_finger->trail_list[i].trail_id, - &next_hop, 0, 1, &my_identity); - } - } - return; - } -#endif GDS_NEIGHBOURS_send_get (key, block_type, options, desired_replication_level, best_known_dest,intermediate_trail_id, &successor.next_hop, 0, 1, &my_identity); @@ -3686,13 +3603,6 @@ handle_dht_p2p_put (void *cls, const struct GNUNET_PeerIdentity *peer, GNUNET_break_op (0); return GNUNET_OK; } -#if ENABLE_MALICIOUS - if(1 == act_malicious) - { - DEBUG("\n I AM MALICIOUS PUT_REQUEST_DROPPED for key = %ss",GNUNET_h2s(&put->key)); - return GNUNET_OK; - } -#endif GNUNET_STATISTICS_update (GDS_stats, gettext_noop ("# Bytes received from other peers"), (int64_t) msize, @@ -3818,45 +3728,6 @@ handle_dht_p2p_put (void *cls, const struct GNUNET_PeerIdentity *peer, &(put->key),putlen, pp, ntohl (put->block_type), payload_size, payload); } - else - { -#if ENABLE_MALICIOUS - if (0 != GNUNET_CRYPTO_cmp_peer_identity (&successor.best_known_destination, - &successor.next_hop)) - { - struct FingerInfo *next_hop_finger; - unsigned int i; - - next_hop_finger = &finger_table[successor.finger_table_index]; - for (i = 0; i < next_hop_finger->trails_count; i++) - { - if (GNUNET_YES == next_hop_finger->trail_list[i].is_present) - { - if(0 == next_hop_finger->trail_list[i].trail_length) - { - GDS_NEIGHBOURS_send_put (&put->key, - ntohl (put->block_type),ntohl (put->options), - ntohl (put->desired_replication_level), - best_known_dest, intermediate_trail_id, &next_hop, - hop_count, putlen, pp, - GNUNET_TIME_absolute_ntoh (put->expiration_time), - payload, payload_size); - return GNUNET_OK; - } - next_hop = next_hop_finger->trail_list[i].trail_head->peer; - GDS_NEIGHBOURS_send_put (&put->key, - ntohl (put->block_type),ntohl (put->options), - ntohl (put->desired_replication_level), - best_known_dest, - next_hop_finger->trail_list[i].trail_id, - &next_hop, hop_count, putlen, pp, - GNUNET_TIME_absolute_ntoh (put->expiration_time), - payload, payload_size); - } - } - return GNUNET_OK; - } -#endif GDS_NEIGHBOURS_send_put (&put->key, ntohl (put->block_type),ntohl (put->options), ntohl (put->desired_replication_level), @@ -3917,13 +3788,6 @@ handle_dht_p2p_get (void *cls, const struct GNUNET_PeerIdentity *peer, return GNUNET_YES; } -#if ENABLE_MALICIOUS - if(1 == act_malicious) - { - DEBUG("I am malicious,GET_REQUEST_DROPPED for key = %s. \n",GNUNET_h2s(&get->key)); - return GNUNET_OK; - } -#endif current_best_known_dest = get->best_known_destination; received_intermediate_trail_id = get->intermediate_trail_id; get_path = (const struct GNUNET_PeerIdentity *)&get[1]; @@ -3997,37 +3861,6 @@ handle_dht_p2p_get (void *cls, const struct GNUNET_PeerIdentity *peer, else { -#if ENABLE_MALICIOUS - if (0 != GNUNET_CRYPTO_cmp_peer_identity (&successor.best_known_destination, - &successor.next_hop)) - { - struct FingerInfo *next_hop_finger; - unsigned int i; - - next_hop_finger = &finger_table[successor.finger_table_index]; - for (i = 0; i < next_hop_finger->trails_count; i++) - { - if(0 == next_hop_finger->trail_list[i].trail_length) - { - GDS_NEIGHBOURS_send_get (&(get->key), get->block_type, get->options, - get->desired_replication_level, best_known_dest, - intermediate_trail_id, &next_hop, hop_count, - get_length, gp); - return GNUNET_OK; - } - if (GNUNET_YES == next_hop_finger->trail_list[i].is_present) - { - next_hop = next_hop_finger->trail_list[i].trail_head->peer; - GDS_NEIGHBOURS_send_get (&(get->key), get->block_type, get->options, - get->desired_replication_level, best_known_dest, - next_hop_finger->trail_list[i].trail_id, - &next_hop, hop_count, - get_length, gp); - } - } - return GNUNET_OK; - } -#endif GDS_NEIGHBOURS_send_get (&(get->key), get->block_type, get->options, get->desired_replication_level, best_known_dest, intermediate_trail_id, &next_hop, hop_count, @@ -6168,10 +6001,6 @@ GDS_NEIGHBOURS_init (void) {NULL, 0, 0} }; -#if ENABLE_MALICIOUS - act_malicious = 0; -#endif - core_api = GNUNET_CORE_connect (GDS_cfg, NULL, &core_init, &handle_core_connect, &handle_core_disconnect, NULL, GNUNET_NO, NULL, diff --git a/src/dht/gnunet-service-xdht_neighbours.h b/src/dht/gnunet-service-xdht_neighbours.h index fae07822f..8a99254dd 100644 --- a/src/dht/gnunet-service-xdht_neighbours.h +++ b/src/dht/gnunet-service-xdht_neighbours.h @@ -32,15 +32,6 @@ #include "gnunet_dht_service.h" -#if ENABLE_MALICIOUS -/** - * Set the ENABLE_MALICIOUS value to malicious. - * @param malicious - */ -int -GDS_NEIGHBOURS_act_malicious (unsigned int malicious); -#endif - /** * Handle the put request from the client. * @param key Key for the content diff --git a/src/dht/gnunet_dht_profiler.c b/src/dht/gnunet_dht_profiler.c index 065ea5d1b..3dd93287d 100644 --- a/src/dht/gnunet_dht_profiler.c +++ b/src/dht/gnunet_dht_profiler.c @@ -755,16 +755,17 @@ delayed_put (void *cls) GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, ac->put_data, ac->put_data_size); GNUNET_CRYPTO_hash (ac->put_data, ac->put_data_size, &ac->hash); - DEBUG ("PUT_REQUEST_START key %s \n", GNUNET_h2s((struct GNUNET_HashCode *)ac->put_data)); - ac->dht_put = GNUNET_DHT_put (ac->dht, &ac->hash, + DEBUG ("PUT_REQUEST_START key %s\n", + GNUNET_h2s((struct GNUNET_HashCode *)ac->put_data)); + ac->dht_put = GNUNET_DHT_put (ac->dht, + &ac->hash, replication, GNUNET_DHT_RO_RECORD_ROUTE, GNUNET_BLOCK_TYPE_TEST, ac->put_data_size, ac->put_data, GNUNET_TIME_UNIT_FOREVER_ABS, /* expiration time */ - timeout, /* PUT timeout */ - put_cont, ac); /* continuation and its closure */ + &put_cont, ac); /* continuation and its closure */ n_puts++; } diff --git a/src/dht/test_dht_api.c b/src/dht/test_dht_api.c index 2507ff080..99f17699c 100644 --- a/src/dht/test_dht_api.c +++ b/src/dht/test_dht_api.c @@ -209,7 +209,7 @@ run (void *cls, GNUNET_DHT_put (dht_handle, &hash, 1, GNUNET_DHT_RO_NONE, GNUNET_BLOCK_TYPE_TEST, data_size, data, GNUNET_TIME_relative_to_absolute (TOTAL_TIMEOUT), - TOTAL_TIMEOUT, &test_get, NULL); + &test_get, NULL); GNUNET_free (data); } diff --git a/src/dht/test_dht_monitor.c b/src/dht/test_dht_monitor.c index 0212c900b..5e6fc074a 100644 --- a/src/dht/test_dht_monitor.c +++ b/src/dht/test_dht_monitor.c @@ -216,7 +216,6 @@ do_puts (void *cls) GNUNET_BLOCK_TYPE_TEST, sizeof (value), &value, GNUNET_TIME_UNIT_FOREVER_ABS, - GNUNET_TIME_UNIT_FOREVER_REL, NULL, NULL); } put_task = GNUNET_SCHEDULER_add_delayed (PUT_FREQUENCY, diff --git a/src/dht/test_dht_topo.c b/src/dht/test_dht_topo.c index 23ed21717..205f6b99a 100644 --- a/src/dht/test_dht_topo.c +++ b/src/dht/test_dht_topo.c @@ -340,7 +340,6 @@ do_puts (void *cls) GNUNET_BLOCK_TYPE_TEST, sizeof (value), &value, GNUNET_TIME_UNIT_FOREVER_ABS, - GNUNET_TIME_UNIT_FOREVER_REL, NULL, NULL); } put_task = GNUNET_SCHEDULER_add_delayed (PUT_FREQUENCY, diff --git a/src/exit/gnunet-daemon-exit.c b/src/exit/gnunet-daemon-exit.c index 7b9f7d5c9..854d12006 100644 --- a/src/exit/gnunet-daemon-exit.c +++ b/src/exit/gnunet-daemon-exit.c @@ -3480,7 +3480,6 @@ do_dht_put (void *cls) sizeof (struct GNUNET_DNS_Advertisement), &dns_advertisement, expiration, - GNUNET_TIME_UNIT_FOREVER_REL, &dht_put_cont, NULL); } diff --git a/src/fs/gnunet-service-fs_put.c b/src/fs/gnunet-service-fs_put.c index 045b640db..3517c7b24 100644 --- a/src/fs/gnunet-service-fs_put.c +++ b/src/fs/gnunet-service-fs_put.c @@ -199,9 +199,14 @@ process_dht_put_content (void *cls, GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Retrieved block `%s' of type %u for DHT PUT\n", GNUNET_h2s (key), type); - po->dht_put = GNUNET_DHT_put (GSF_dht, key, DEFAULT_PUT_REPLICATION, - GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, type, size, data, - expiration, GNUNET_TIME_UNIT_FOREVER_REL, + po->dht_put = GNUNET_DHT_put (GSF_dht, + key, + DEFAULT_PUT_REPLICATION, + GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, + type, + size, + data, + expiration, &delay_dht_put_blocks, po); } diff --git a/src/gns/gnunet-service-gns.c b/src/gns/gnunet-service-gns.c index 682d8f5f7..5e1b5830f 100644 --- a/src/gns/gnunet-service-gns.c +++ b/src/gns/gnunet-service-gns.c @@ -510,7 +510,6 @@ perform_dht_put (const struct GNUNET_CRYPTO_EcdsaPrivateKey *key, block_size, block, expire, - DHT_OPERATION_TIMEOUT, &dht_put_continuation, pc_arg); GNUNET_free (block); diff --git a/src/include/gnunet_dht_service.h b/src/include/gnunet_dht_service.h index 1fdd63ee0..d798482e3 100644 --- a/src/include/gnunet_dht_service.h +++ b/src/include/gnunet_dht_service.h @@ -1,6 +1,6 @@ /* This file is part of GNUnet - Copyright (C) 2004-2013 GNUnet e.V. + Copyright (C) 2004-2013, 2016 GNUnet e.V. GNUnet is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published @@ -152,8 +152,9 @@ struct GNUNET_DHT_PutHandle; * after the PUT message was transmitted * (so we don't know if it was received or not) */ -typedef void (*GNUNET_DHT_PutContinuation)(void *cls, - int success); +typedef void +(*GNUNET_DHT_PutContinuation)(void *cls, + int success); /** @@ -168,7 +169,6 @@ typedef void (*GNUNET_DHT_PutContinuation)(void *cls, * @param size number of bytes in @a 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) * You must not call #GNUNET_DHT_disconnect in this continuation * @param cont_cls closure for @a cont @@ -181,9 +181,9 @@ GNUNET_DHT_put (struct GNUNET_DHT_Handle *handle, uint32_t desired_replication_level, enum GNUNET_DHT_RouteOption options, enum GNUNET_BLOCK_Type type, - size_t size, const void *data, + size_t size, + const void *data, struct GNUNET_TIME_Absolute exp, - struct GNUNET_TIME_Relative timeout, GNUNET_DHT_PutContinuation cont, void *cont_cls); @@ -220,15 +220,17 @@ GNUNET_DHT_put_cancel (struct GNUNET_DHT_PutHandle *ph); * @param size number of bytes in @a data * @param data pointer to the result data */ -typedef void (*GNUNET_DHT_GetIterator) (void *cls, - struct GNUNET_TIME_Absolute exp, - const struct GNUNET_HashCode *key, - const struct GNUNET_PeerIdentity *get_path, - unsigned int get_path_length, - const struct GNUNET_PeerIdentity *put_path, - unsigned int put_path_length, - enum GNUNET_BLOCK_Type type, - size_t size, const void *data); +typedef void +(*GNUNET_DHT_GetIterator) (void *cls, + struct GNUNET_TIME_Absolute exp, + const struct GNUNET_HashCode *key, + const struct GNUNET_PeerIdentity *get_path, + unsigned int get_path_length, + const struct GNUNET_PeerIdentity *put_path, + unsigned int put_path_length, + enum GNUNET_BLOCK_Type type, + size_t size, + const void *data); /** @@ -245,7 +247,6 @@ typedef void (*GNUNET_DHT_GetIterator) (void *cls, * @param xquery_size number of bytes in @a xquery * @param iter function to call on each result * @param iter_cls closure for @a iter - * * @return handle to stop the async get */ struct GNUNET_DHT_GetHandle * @@ -254,8 +255,10 @@ GNUNET_DHT_get_start (struct GNUNET_DHT_Handle *handle, const struct GNUNET_HashCode *key, uint32_t desired_replication_level, enum GNUNET_DHT_RouteOption options, - const void *xquery, size_t xquery_size, - GNUNET_DHT_GetIterator iter, void *iter_cls); + const void *xquery, + size_t xquery_size, + GNUNET_DHT_GetIterator iter, + void *iter_cls); /** @@ -265,7 +268,7 @@ GNUNET_DHT_get_start (struct GNUNET_DHT_Handle *handle, * @param get_handle get operation for which results should be filtered * @param num_results number of results to be blocked that are * provided in this call (size of the @a results array) - * @param results array of hash codes over the 'data' of the results + * @param results array of hash codes over the `data` of the results * to be blocked */ void @@ -277,9 +280,6 @@ GNUNET_DHT_get_filter_known_results (struct GNUNET_DHT_GetHandle *get_handle, * Stop async DHT-get. Frees associated resources. * * @param get_handle 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); @@ -304,14 +304,16 @@ struct GNUNET_DHT_MonitorHandle; * @param desired_replication_level Desired replication level. * @param key Key of the requested data. */ -typedef void (*GNUNET_DHT_MonitorGetCB) (void *cls, - enum GNUNET_DHT_RouteOption options, - enum GNUNET_BLOCK_Type type, - uint32_t hop_count, - uint32_t desired_replication_level, - unsigned int path_length, - const struct GNUNET_PeerIdentity *path, - const struct GNUNET_HashCode * key); +typedef void +(*GNUNET_DHT_MonitorGetCB) (void *cls, + enum GNUNET_DHT_RouteOption options, + enum GNUNET_BLOCK_Type type, + uint32_t hop_count, + uint32_t desired_replication_level, + unsigned int path_length, + const struct GNUNET_PeerIdentity *path, + const struct GNUNET_HashCode *key); + /** * Callback called on each GET reply going through the DHT. @@ -327,16 +329,18 @@ typedef void (*GNUNET_DHT_MonitorGetCB) (void *cls, * @param data Pointer to the result data. * @param size Number of bytes in @a data. */ -typedef void (*GNUNET_DHT_MonitorGetRespCB) (void *cls, - enum GNUNET_BLOCK_Type type, - const struct GNUNET_PeerIdentity *get_path, - unsigned int get_path_length, - const struct GNUNET_PeerIdentity *put_path, - unsigned int put_path_length, - struct GNUNET_TIME_Absolute exp, - const struct GNUNET_HashCode *key, - const void *data, - size_t size); +typedef void +(*GNUNET_DHT_MonitorGetRespCB) (void *cls, + enum GNUNET_BLOCK_Type type, + const struct GNUNET_PeerIdentity *get_path, + unsigned int get_path_length, + const struct GNUNET_PeerIdentity *put_path, + unsigned int put_path_length, + struct GNUNET_TIME_Absolute exp, + const struct GNUNET_HashCode *key, + const void *data, + size_t size); + /** * Callback called on each PUT request going through the DHT. @@ -351,19 +355,22 @@ typedef void (*GNUNET_DHT_MonitorGetRespCB) (void *cls, * @param exp Expiration time of the data. * @param key Key under which data is to be stored. * @param data Pointer to the data carried. - * @param size Number of bytes in data. + * @param size Number of bytes in @a data. */ -typedef void (*GNUNET_DHT_MonitorPutCB) (void *cls, - enum GNUNET_DHT_RouteOption options, - enum GNUNET_BLOCK_Type type, - uint32_t hop_count, - uint32_t desired_replication_level, - unsigned int path_length, - const struct GNUNET_PeerIdentity *path, - struct GNUNET_TIME_Absolute exp, - const struct GNUNET_HashCode *key, - const void *data, - size_t size); +typedef void +(*GNUNET_DHT_MonitorPutCB) (void *cls, + enum GNUNET_DHT_RouteOption options, + enum GNUNET_BLOCK_Type type, + uint32_t hop_count, + uint32_t desired_replication_level, + unsigned int path_length, + const struct GNUNET_PeerIdentity *path, + struct GNUNET_TIME_Absolute exp, + const struct GNUNET_HashCode *key, + const void *data, + size_t size); + + /** * Start monitoring the local DHT service. @@ -389,44 +396,15 @@ GNUNET_DHT_monitor_start (struct GNUNET_DHT_Handle *handle, /** * Stop monitoring. - * On return handle will no longer be valid, caller must not use again!!! + * On return handle will no longer be valid, caller must not use it anymore. * - * @param handle The handle to the monitor request returned by monitor_start. + * @param handle The handle to the monitor request returned by + * #GNUNET_DHT_monitor_start(). */ void GNUNET_DHT_monitor_stop (struct GNUNET_DHT_MonitorHandle *handle); -#if ENABLE_MALICIOUS -/** - * Type of a Malicious continuation. You must not call - * #GNUNET_DHT_disconnect in this continuation. - * - * @param cls closure - * @param success #GNUNET_OK if the set malicious request was transmitted, - * #GNUNET_NO on timeout, - * #GNUNET_SYSERR on disconnect from service - * after the PUT message was transmitted - * (so we don't know if it was received or not) - */ -typedef void (*GNUNET_DHT_ActMaliciousContinuation)(void *cls, - int success); - -/** - * Turn the DHT service to act malicious - * - * @param handle the DHT handle - * @param action 1 to make the service malicious; 0 to make it benign - FIXME: perhaps make this an enum of known malicious behaviors? - */ -struct GNUNET_DHT_ActMaliciousHandle * -GNUNET_DHT_act_malicious (struct GNUNET_DHT_Handle *handle, - unsigned int action, - GNUNET_DHT_PutContinuation cont, - void *cont_cls); -#endif - - #if 0 /* keep Emacsens' auto-indent happy */ { #endif diff --git a/src/regex/regex_internal_dht.c b/src/regex/regex_internal_dht.c index f820e5905..47fae90d6 100644 --- a/src/regex/regex_internal_dht.c +++ b/src/regex/regex_internal_dht.c @@ -151,7 +151,6 @@ regex_iterator (void *cls, size, &ab, GNUNET_TIME_relative_to_absolute (DHT_TTL), - DHT_TTL, NULL, NULL); } block = REGEX_BLOCK_create (proof, @@ -165,7 +164,6 @@ regex_iterator (void *cls, GNUNET_BLOCK_TYPE_REGEX, size, block, GNUNET_TIME_relative_to_absolute (DHT_TTL), - DHT_TTL, NULL, NULL); GNUNET_STATISTICS_update (h->stats, "# regex blocks stored", |