From c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207 Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Sat, 5 Oct 2019 15:09:28 +0200 Subject: global reindent, now with uncrustify hook enabled --- src/dht/gnunet-service-dht_clients.c | 1388 +++++++++++++++++----------------- 1 file changed, 705 insertions(+), 683 deletions(-) (limited to 'src/dht/gnunet-service-dht_clients.c') diff --git a/src/dht/gnunet-service-dht_clients.c b/src/dht/gnunet-service-dht_clients.c index 48017bfb4..932b04d9b 100644 --- a/src/dht/gnunet-service-dht_clients.c +++ b/src/dht/gnunet-service-dht_clients.c @@ -38,9 +38,10 @@ /** * Should routing details be logged to stderr (for debugging)? */ -#define LOG_TRAFFIC(kind, ...) GNUNET_log_from(kind, "dht-traffic", __VA_ARGS__) +#define LOG_TRAFFIC(kind, ...) GNUNET_log_from (kind, "dht-traffic", \ + __VA_ARGS__) -#define LOG(kind, ...) GNUNET_log_from(kind, "dht-clients", __VA_ARGS__) +#define LOG(kind, ...) GNUNET_log_from (kind, "dht-clients", __VA_ARGS__) /** @@ -54,7 +55,8 @@ struct ClientHandle; /** * Entry in the local forwarding map for a client's GET request. */ -struct ClientQueryRecord { +struct ClientQueryRecord +{ /** * The key this request was about */ @@ -136,7 +138,8 @@ struct ClientQueryRecord { /** * Struct containing paremeters of monitoring requests. */ -struct ClientMonitorRecord { +struct ClientMonitorRecord +{ /** * Next element in DLL. */ @@ -184,7 +187,8 @@ struct ClientMonitorRecord { * handle to connect to it, and any pending messages * that need to be sent to it. */ -struct ClientHandle { +struct ClientHandle +{ /** * Linked list of active queries of this client. */ @@ -258,23 +262,23 @@ static struct GNUNET_SCHEDULER_Task *retry_task; * @param record record to remove */ static void -remove_client_record(struct ClientQueryRecord *record) +remove_client_record (struct ClientQueryRecord *record) { struct ClientHandle *ch = record->ch; - GNUNET_CONTAINER_DLL_remove(ch->cqr_head, - ch->cqr_tail, - record); - GNUNET_assert(GNUNET_YES == - GNUNET_CONTAINER_multihashmap_remove(forward_map, - &record->key, - record)); + GNUNET_CONTAINER_DLL_remove (ch->cqr_head, + ch->cqr_tail, + record); + GNUNET_assert (GNUNET_YES == + GNUNET_CONTAINER_multihashmap_remove (forward_map, + &record->key, + record)); if (NULL != record->hnode) - GNUNET_CONTAINER_heap_remove_node(record->hnode); - GNUNET_array_grow(record->seen_replies, - record->seen_replies_count, - 0); - GNUNET_free(record); + GNUNET_CONTAINER_heap_remove_node (record->hnode); + GNUNET_array_grow (record->seen_replies, + record->seen_replies_count, + 0); + GNUNET_free (record); } @@ -288,13 +292,13 @@ remove_client_record(struct ClientQueryRecord *record) * @return our `struct ClientHandle` for @a client */ static void * -client_connect_cb(void *cls, - struct GNUNET_SERVICE_Client *client, - struct GNUNET_MQ_Handle *mq) +client_connect_cb (void *cls, + struct GNUNET_SERVICE_Client *client, + struct GNUNET_MQ_Handle *mq) { struct ClientHandle *ch; - ch = GNUNET_new(struct ClientHandle); + ch = GNUNET_new (struct ClientHandle); ch->client = client; ch->mq = mq; return ch; @@ -310,40 +314,40 @@ client_connect_cb(void *cls, * @param app_ctx our `struct ClientHandle` for @a client */ static void -client_disconnect_cb(void *cls, - struct GNUNET_SERVICE_Client *client, - void *app_ctx) +client_disconnect_cb (void *cls, + struct GNUNET_SERVICE_Client *client, + void *app_ctx) { struct ClientHandle *ch = app_ctx; struct ClientQueryRecord *cqr; struct ClientMonitorRecord *monitor; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Local client %p disconnects\n", - ch); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Local client %p disconnects\n", + ch); monitor = monitor_head; while (NULL != monitor) + { + if (monitor->ch == ch) { - if (monitor->ch == ch) - { - struct ClientMonitorRecord *next; - - next = monitor->next; - GNUNET_free_non_null(monitor->key); - GNUNET_CONTAINER_DLL_remove(monitor_head, - monitor_tail, - monitor); - GNUNET_free(monitor); - monitor = next; - } - else - { - monitor = monitor->next; - } + struct ClientMonitorRecord *next; + + next = monitor->next; + GNUNET_free_non_null (monitor->key); + GNUNET_CONTAINER_DLL_remove (monitor_head, + monitor_tail, + monitor); + GNUNET_free (monitor); + monitor = next; } + else + { + monitor = monitor->next; + } + } while (NULL != (cqr = ch->cqr_head)) - remove_client_record(cqr); - GNUNET_free(ch); + remove_client_record (cqr); + GNUNET_free (ch); } @@ -353,52 +357,54 @@ client_disconnect_cb(void *cls, * message and initiating the routing operation. */ static void -transmit_request(struct ClientQueryRecord *cqr) +transmit_request (struct ClientQueryRecord *cqr) { struct GNUNET_BLOCK_Group *bg; struct GNUNET_CONTAINER_BloomFilter *peer_bf; - GNUNET_STATISTICS_update(GDS_stats, - gettext_noop("# GET requests from clients injected"), - 1, - GNUNET_NO); - bg = GNUNET_BLOCK_group_create(GDS_block_context, - cqr->type, - GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, - UINT32_MAX), - NULL, - 0, - "seen-set-size", - cqr->seen_replies_count, - NULL); - GNUNET_BLOCK_group_set_seen(bg, - cqr->seen_replies, - cqr->seen_replies_count); + GNUNET_STATISTICS_update (GDS_stats, + gettext_noop ( + "# GET requests from clients injected"), + 1, + GNUNET_NO); + bg = GNUNET_BLOCK_group_create (GDS_block_context, + cqr->type, + GNUNET_CRYPTO_random_u32 ( + GNUNET_CRYPTO_QUALITY_WEAK, + UINT32_MAX), + NULL, + 0, + "seen-set-size", + cqr->seen_replies_count, + NULL); + GNUNET_BLOCK_group_set_seen (bg, + cqr->seen_replies, + cqr->seen_replies_count); peer_bf - = GNUNET_CONTAINER_bloomfilter_init(NULL, - DHT_BLOOM_SIZE, - GNUNET_CONSTANTS_BLOOMFILTER_K); - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Initiating GET for %s, replication %u, already have %u replies\n", - GNUNET_h2s(&cqr->key), - cqr->replication, - cqr->seen_replies_count); - GDS_NEIGHBOURS_handle_get(cqr->type, - cqr->msg_options, - cqr->replication, - 0 /* hop count */, - &cqr->key, - cqr->xquery, - cqr->xquery_size, - bg, - peer_bf); - GNUNET_BLOCK_group_destroy(bg); - GNUNET_CONTAINER_bloomfilter_free(peer_bf); + = GNUNET_CONTAINER_bloomfilter_init (NULL, + DHT_BLOOM_SIZE, + GNUNET_CONSTANTS_BLOOMFILTER_K); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Initiating GET for %s, replication %u, already have %u replies\n", + GNUNET_h2s (&cqr->key), + cqr->replication, + cqr->seen_replies_count); + GDS_NEIGHBOURS_handle_get (cqr->type, + cqr->msg_options, + cqr->replication, + 0 /* hop count */, + &cqr->key, + cqr->xquery, + cqr->xquery_size, + bg, + peer_bf); + GNUNET_BLOCK_group_destroy (bg); + GNUNET_CONTAINER_bloomfilter_free (peer_bf); /* exponential back-off for retries. * max GNUNET_TIME_STD_EXPONENTIAL_BACKOFF_THRESHOLD (15 min) */ - cqr->retry_frequency = GNUNET_TIME_STD_BACKOFF(cqr->retry_frequency); - cqr->retry_time = GNUNET_TIME_relative_to_absolute(cqr->retry_frequency); + cqr->retry_frequency = GNUNET_TIME_STD_BACKOFF (cqr->retry_frequency); + cqr->retry_time = GNUNET_TIME_relative_to_absolute (cqr->retry_frequency); } @@ -410,34 +416,34 @@ transmit_request(struct ClientQueryRecord *cqr) * @param cls unused */ static void -transmit_next_request_task(void *cls) +transmit_next_request_task (void *cls) { struct ClientQueryRecord *cqr; struct GNUNET_TIME_Relative delay; retry_task = NULL; - while (NULL != (cqr = GNUNET_CONTAINER_heap_remove_root(retry_heap))) + while (NULL != (cqr = GNUNET_CONTAINER_heap_remove_root (retry_heap))) + { + cqr->hnode = NULL; + delay = GNUNET_TIME_absolute_get_remaining (cqr->retry_time); + if (delay.rel_value_us > 0) { - cqr->hnode = NULL; - delay = GNUNET_TIME_absolute_get_remaining(cqr->retry_time); - if (delay.rel_value_us > 0) - { - cqr->hnode - = GNUNET_CONTAINER_heap_insert(retry_heap, - cqr, - cqr->retry_time.abs_value_us); - retry_task - = GNUNET_SCHEDULER_add_at(cqr->retry_time, - &transmit_next_request_task, - NULL); - return; - } - transmit_request(cqr); cqr->hnode - = GNUNET_CONTAINER_heap_insert(retry_heap, - cqr, - cqr->retry_time.abs_value_us); + = GNUNET_CONTAINER_heap_insert (retry_heap, + cqr, + cqr->retry_time.abs_value_us); + retry_task + = GNUNET_SCHEDULER_add_at (cqr->retry_time, + &transmit_next_request_task, + NULL); + return; } + transmit_request (cqr); + cqr->hnode + = GNUNET_CONTAINER_heap_insert (retry_heap, + cqr, + cqr->retry_time.abs_value_us); + } } @@ -449,8 +455,8 @@ transmit_next_request_task(void *cls) * @return #GNUNET_OK (always) */ static int -check_dht_local_put(void *cls, - const struct GNUNET_DHT_ClientPutMessage *dht_msg) +check_dht_local_put (void *cls, + const struct GNUNET_DHT_ClientPutMessage *dht_msg) { /* always well-formed */ return GNUNET_OK; @@ -464,71 +470,72 @@ check_dht_local_put(void *cls, * @param dht_msg the actual message received */ static void -handle_dht_local_put(void *cls, - const struct GNUNET_DHT_ClientPutMessage *dht_msg) +handle_dht_local_put (void *cls, + const struct GNUNET_DHT_ClientPutMessage *dht_msg) { struct ClientHandle *ch = cls; struct GNUNET_CONTAINER_BloomFilter *peer_bf; uint16_t size; - size = ntohs(dht_msg->header.size); - GNUNET_STATISTICS_update(GDS_stats, - gettext_noop("# PUT requests received from clients"), - 1, - GNUNET_NO); - LOG_TRAFFIC(GNUNET_ERROR_TYPE_DEBUG, - "CLIENT-PUT %s\n", - GNUNET_h2s_full(&dht_msg->key)); + size = ntohs (dht_msg->header.size); + GNUNET_STATISTICS_update (GDS_stats, + gettext_noop ( + "# PUT requests received from clients"), + 1, + GNUNET_NO); + LOG_TRAFFIC (GNUNET_ERROR_TYPE_DEBUG, + "CLIENT-PUT %s\n", + GNUNET_h2s_full (&dht_msg->key)); /* give to local clients */ - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Handling local PUT of %u-bytes for query %s\n", - size - sizeof(struct GNUNET_DHT_ClientPutMessage), - GNUNET_h2s(&dht_msg->key)); - GDS_CLIENTS_handle_reply(GNUNET_TIME_absolute_ntoh(dht_msg->expiration), - &dht_msg->key, - 0, - NULL, - 0, - NULL, - ntohl(dht_msg->type), - size - sizeof(struct GNUNET_DHT_ClientPutMessage), - &dht_msg[1]); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Handling local PUT of %u-bytes for query %s\n", + size - sizeof(struct GNUNET_DHT_ClientPutMessage), + GNUNET_h2s (&dht_msg->key)); + GDS_CLIENTS_handle_reply (GNUNET_TIME_absolute_ntoh (dht_msg->expiration), + &dht_msg->key, + 0, + NULL, + 0, + NULL, + ntohl (dht_msg->type), + size - sizeof(struct GNUNET_DHT_ClientPutMessage), + &dht_msg[1]); /* store locally */ - GDS_DATACACHE_handle_put(GNUNET_TIME_absolute_ntoh(dht_msg->expiration), - &dht_msg->key, - 0, - NULL, - ntohl(dht_msg->type), - size - sizeof(struct GNUNET_DHT_ClientPutMessage), - &dht_msg[1]); - /* route to other peers */ - peer_bf - = GNUNET_CONTAINER_bloomfilter_init(NULL, - DHT_BLOOM_SIZE, - GNUNET_CONSTANTS_BLOOMFILTER_K); - GDS_NEIGHBOURS_handle_put(ntohl(dht_msg->type), - ntohl(dht_msg->options), - ntohl(dht_msg->desired_replication_level), - GNUNET_TIME_absolute_ntoh(dht_msg->expiration), - 0 /* hop count */, - peer_bf, + GDS_DATACACHE_handle_put (GNUNET_TIME_absolute_ntoh (dht_msg->expiration), &dht_msg->key, 0, NULL, - &dht_msg[1], - size - sizeof(struct GNUNET_DHT_ClientPutMessage)); - GDS_CLIENTS_process_put(ntohl(dht_msg->options), - ntohl(dht_msg->type), - 0, - ntohl(dht_msg->desired_replication_level), - 1, - GDS_NEIGHBOURS_get_id(), - GNUNET_TIME_absolute_ntoh(dht_msg->expiration), - &dht_msg->key, - &dht_msg[1], - size - sizeof(struct GNUNET_DHT_ClientPutMessage)); - GNUNET_CONTAINER_bloomfilter_free(peer_bf); - GNUNET_SERVICE_client_continue(ch->client); + ntohl (dht_msg->type), + size - sizeof(struct GNUNET_DHT_ClientPutMessage), + &dht_msg[1]); + /* route to other peers */ + peer_bf + = GNUNET_CONTAINER_bloomfilter_init (NULL, + DHT_BLOOM_SIZE, + GNUNET_CONSTANTS_BLOOMFILTER_K); + GDS_NEIGHBOURS_handle_put (ntohl (dht_msg->type), + ntohl (dht_msg->options), + ntohl (dht_msg->desired_replication_level), + GNUNET_TIME_absolute_ntoh (dht_msg->expiration), + 0 /* hop count */, + peer_bf, + &dht_msg->key, + 0, + NULL, + &dht_msg[1], + size - sizeof(struct GNUNET_DHT_ClientPutMessage)); + GDS_CLIENTS_process_put (ntohl (dht_msg->options), + ntohl (dht_msg->type), + 0, + ntohl (dht_msg->desired_replication_level), + 1, + GDS_NEIGHBOURS_get_id (), + GNUNET_TIME_absolute_ntoh (dht_msg->expiration), + &dht_msg->key, + &dht_msg[1], + size - sizeof(struct GNUNET_DHT_ClientPutMessage)); + GNUNET_CONTAINER_bloomfilter_free (peer_bf); + GNUNET_SERVICE_client_continue (ch->client); } @@ -540,8 +547,8 @@ handle_dht_local_put(void *cls, * @return #GNUNET_OK (always) */ static int -check_dht_local_get(void *cls, - const struct GNUNET_DHT_ClientGetMessage *get) +check_dht_local_get (void *cls, + const struct GNUNET_DHT_ClientGetMessage *get) { /* always well-formed */ return GNUNET_OK; @@ -563,25 +570,25 @@ check_dht_local_get(void *cls, * @param data_size number of bytes in @a data */ static void -handle_local_result(void *cls, - enum GNUNET_BLOCK_Type type, - struct GNUNET_TIME_Absolute expiration_time, - const struct GNUNET_HashCode *key, - unsigned int put_path_length, - const struct GNUNET_PeerIdentity *put_path, - unsigned int get_path_length, - const struct GNUNET_PeerIdentity *get_path, - const void *data, - size_t data_size) +handle_local_result (void *cls, + enum GNUNET_BLOCK_Type type, + struct GNUNET_TIME_Absolute expiration_time, + const struct GNUNET_HashCode *key, + unsigned int put_path_length, + const struct GNUNET_PeerIdentity *put_path, + unsigned int get_path_length, + const struct GNUNET_PeerIdentity *get_path, + const void *data, + size_t data_size) { // FIXME: this needs some clean up: inline the function, // possibly avoid even looking up the client! - GDS_CLIENTS_handle_reply(expiration_time, - key, - 0, NULL, - put_path_length, put_path, - type, - data_size, data); + GDS_CLIENTS_handle_reply (expiration_time, + key, + 0, NULL, + put_path_length, put_path, + type, + data_size, data); } @@ -592,8 +599,8 @@ handle_local_result(void *cls, * @param message the actual message received */ static void -handle_dht_local_get(void *cls, - const struct GNUNET_DHT_ClientGetMessage *get) +handle_dht_local_get (void *cls, + const struct GNUNET_DHT_ClientGetMessage *get) { struct ClientHandle *ch = cls; struct ClientQueryRecord *cqr; @@ -601,71 +608,72 @@ handle_dht_local_get(void *cls, const char *xquery; uint16_t size; - size = ntohs(get->header.size); + size = ntohs (get->header.size); xquery_size = size - sizeof(struct GNUNET_DHT_ClientGetMessage); - xquery = (const char *)&get[1]; - GNUNET_STATISTICS_update(GDS_stats, - gettext_noop - ("# GET requests received from clients"), 1, - GNUNET_NO); - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Received GET request for %s from local client %p, xq: %.*s\n", - GNUNET_h2s(&get->key), - ch->client, - xquery_size, - xquery); - LOG_TRAFFIC(GNUNET_ERROR_TYPE_DEBUG, - "CLIENT-GET %s\n", - GNUNET_h2s_full(&get->key)); - - cqr = GNUNET_malloc(sizeof(struct ClientQueryRecord) + xquery_size); + xquery = (const char *) &get[1]; + GNUNET_STATISTICS_update (GDS_stats, + gettext_noop + ("# GET requests received from clients"), 1, + GNUNET_NO); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Received GET request for %s from local client %p, xq: %.*s\n", + GNUNET_h2s (&get->key), + ch->client, + xquery_size, + xquery); + LOG_TRAFFIC (GNUNET_ERROR_TYPE_DEBUG, + "CLIENT-GET %s\n", + GNUNET_h2s_full (&get->key)); + + cqr = GNUNET_malloc (sizeof(struct ClientQueryRecord) + xquery_size); cqr->key = get->key; cqr->ch = ch; - cqr->xquery = (void *)&cqr[1]; - GNUNET_memcpy(&cqr[1], xquery, xquery_size); - cqr->hnode = GNUNET_CONTAINER_heap_insert(retry_heap, cqr, 0); + cqr->xquery = (void *) &cqr[1]; + GNUNET_memcpy (&cqr[1], xquery, xquery_size); + cqr->hnode = GNUNET_CONTAINER_heap_insert (retry_heap, cqr, 0); cqr->retry_frequency = GNUNET_TIME_UNIT_SECONDS; - cqr->retry_time = GNUNET_TIME_absolute_get(); + cqr->retry_time = GNUNET_TIME_absolute_get (); cqr->unique_id = get->unique_id; cqr->xquery_size = xquery_size; - cqr->replication = ntohl(get->desired_replication_level); - cqr->msg_options = ntohl(get->options); - cqr->type = ntohl(get->type); - GNUNET_CONTAINER_DLL_insert(ch->cqr_head, - ch->cqr_tail, - cqr); - GNUNET_CONTAINER_multihashmap_put(forward_map, - &cqr->key, - cqr, - GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); - GDS_CLIENTS_process_get(ntohl(get->options), - ntohl(get->type), - 0, - ntohl(get->desired_replication_level), - 1, - GDS_NEIGHBOURS_get_id(), - &get->key); + cqr->replication = ntohl (get->desired_replication_level); + cqr->msg_options = ntohl (get->options); + cqr->type = ntohl (get->type); + GNUNET_CONTAINER_DLL_insert (ch->cqr_head, + ch->cqr_tail, + cqr); + GNUNET_CONTAINER_multihashmap_put (forward_map, + &cqr->key, + cqr, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); + GDS_CLIENTS_process_get (ntohl (get->options), + ntohl (get->type), + 0, + ntohl (get->desired_replication_level), + 1, + GDS_NEIGHBOURS_get_id (), + &get->key); /* start remote requests */ if (NULL != retry_task) - GNUNET_SCHEDULER_cancel(retry_task); - retry_task = GNUNET_SCHEDULER_add_now(&transmit_next_request_task, - NULL); + GNUNET_SCHEDULER_cancel (retry_task); + retry_task = GNUNET_SCHEDULER_add_now (&transmit_next_request_task, + NULL); /* perform local lookup */ - GDS_DATACACHE_handle_get(&get->key, - cqr->type, - cqr->xquery, - xquery_size, - NULL, - &handle_local_result, - ch); - GNUNET_SERVICE_client_continue(ch->client); + GDS_DATACACHE_handle_get (&get->key, + cqr->type, + cqr->xquery, + xquery_size, + NULL, + &handle_local_result, + ch); + GNUNET_SERVICE_client_continue (ch->client); } /** * Closure for #find_by_unique_id(). */ -struct FindByUniqueIdContext { +struct FindByUniqueIdContext +{ /** * Where to store the result, if found. */ @@ -686,9 +694,9 @@ struct FindByUniqueIdContext { * @return #GNUNET_YES to continue iteration (result not yet found) */ static int -find_by_unique_id(void *cls, - const struct GNUNET_HashCode *key, - void *value) +find_by_unique_id (void *cls, + const struct GNUNET_HashCode *key, + void *value) { struct FindByUniqueIdContext *fui_ctx = cls; struct ClientQueryRecord *cqr = value; @@ -708,19 +716,22 @@ find_by_unique_id(void *cls, * @return #GNUNET_OK if @a seen is well-formed */ static int -check_dht_local_get_result_seen(void *cls, - const struct GNUNET_DHT_ClientGetResultSeenMessage *seen) +check_dht_local_get_result_seen (void *cls, + const struct + GNUNET_DHT_ClientGetResultSeenMessage *seen) { uint16_t size; unsigned int hash_count; - size = ntohs(seen->header.size); - hash_count = (size - sizeof(struct GNUNET_DHT_ClientGetResultSeenMessage)) / sizeof(struct GNUNET_HashCode); - if (size != sizeof(struct GNUNET_DHT_ClientGetResultSeenMessage) + hash_count * sizeof(struct GNUNET_HashCode)) - { - GNUNET_break(0); - return GNUNET_SYSERR; - } + size = ntohs (seen->header.size); + hash_count = (size - sizeof(struct GNUNET_DHT_ClientGetResultSeenMessage)) + / sizeof(struct GNUNET_HashCode); + if (size != sizeof(struct GNUNET_DHT_ClientGetResultSeenMessage) + + hash_count * sizeof(struct GNUNET_HashCode)) + { + GNUNET_break (0); + return GNUNET_SYSERR; + } return GNUNET_OK; } @@ -732,8 +743,9 @@ check_dht_local_get_result_seen(void *cls, * @param message the actual message received */ static void -handle_dht_local_get_result_seen(void *cls, - const struct GNUNET_DHT_ClientGetResultSeenMessage *seen) +handle_dht_local_get_result_seen (void *cls, + const struct + GNUNET_DHT_ClientGetResultSeenMessage *seen) { struct ClientHandle *ch = cls; uint16_t size; @@ -743,36 +755,38 @@ handle_dht_local_get_result_seen(void *cls, struct FindByUniqueIdContext fui_ctx; struct ClientQueryRecord *cqr; - size = ntohs(seen->header.size); - hash_count = (size - sizeof(struct GNUNET_DHT_ClientGetResultSeenMessage)) / sizeof(struct GNUNET_HashCode); - hc = (const struct GNUNET_HashCode*)&seen[1]; + size = ntohs (seen->header.size); + hash_count = (size - sizeof(struct GNUNET_DHT_ClientGetResultSeenMessage)) + / sizeof(struct GNUNET_HashCode); + hc = (const struct GNUNET_HashCode*) &seen[1]; fui_ctx.unique_id = seen->unique_id; fui_ctx.cqr = NULL; - GNUNET_CONTAINER_multihashmap_get_multiple(forward_map, - &seen->key, - &find_by_unique_id, - &fui_ctx); + GNUNET_CONTAINER_multihashmap_get_multiple (forward_map, + &seen->key, + &find_by_unique_id, + &fui_ctx); if (NULL == (cqr = fui_ctx.cqr)) - { - GNUNET_break(0); - GNUNET_SERVICE_client_drop(ch->client); - return; - } + { + GNUNET_break (0); + GNUNET_SERVICE_client_drop (ch->client); + return; + } /* finally, update 'seen' list */ old_count = cqr->seen_replies_count; - GNUNET_array_grow(cqr->seen_replies, - cqr->seen_replies_count, - cqr->seen_replies_count + hash_count); - GNUNET_memcpy(&cqr->seen_replies[old_count], - hc, - sizeof(struct GNUNET_HashCode) * hash_count); + GNUNET_array_grow (cqr->seen_replies, + cqr->seen_replies_count, + cqr->seen_replies_count + hash_count); + GNUNET_memcpy (&cqr->seen_replies[old_count], + hc, + sizeof(struct GNUNET_HashCode) * hash_count); } /** * Closure for #remove_by_unique_id(). */ -struct RemoveByUniqueIdContext { +struct RemoveByUniqueIdContext +{ /** * Client that issued the removal request. */ @@ -795,20 +809,20 @@ struct RemoveByUniqueIdContext { * @return #GNUNET_YES (we should continue to iterate) */ static int -remove_by_unique_id(void *cls, - const struct GNUNET_HashCode *key, - void *value) +remove_by_unique_id (void *cls, + const struct GNUNET_HashCode *key, + void *value) { const struct RemoveByUniqueIdContext *ctx = cls; struct ClientQueryRecord *cqr = value; if (cqr->unique_id != ctx->unique_id) return GNUNET_YES; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Removing client %p's record for key %s (by unique id)\n", - ctx->ch->client, - GNUNET_h2s(key)); - remove_client_record(cqr); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Removing client %p's record for key %s (by unique id)\n", + ctx->ch->client, + GNUNET_h2s (key)); + remove_client_record (cqr); return GNUNET_YES; } @@ -822,27 +836,28 @@ remove_by_unique_id(void *cls, * */ static void -handle_dht_local_get_stop(void *cls, - const struct GNUNET_DHT_ClientGetStopMessage *dht_stop_msg) +handle_dht_local_get_stop (void *cls, + const struct + GNUNET_DHT_ClientGetStopMessage *dht_stop_msg) { struct ClientHandle *ch = cls; struct RemoveByUniqueIdContext ctx; - GNUNET_STATISTICS_update(GDS_stats, - gettext_noop - ("# GET STOP requests received from clients"), 1, - GNUNET_NO); - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Received GET STOP request for %s from local client %p\n", - GNUNET_h2s(&dht_stop_msg->key), - ch->client); + GNUNET_STATISTICS_update (GDS_stats, + gettext_noop + ("# GET STOP requests received from clients"), 1, + GNUNET_NO); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Received GET STOP request for %s from local client %p\n", + GNUNET_h2s (&dht_stop_msg->key), + ch->client); ctx.ch = ch; ctx.unique_id = dht_stop_msg->unique_id; - GNUNET_CONTAINER_multihashmap_get_multiple(forward_map, - &dht_stop_msg->key, - &remove_by_unique_id, - &ctx); - GNUNET_SERVICE_client_continue(ch->client); + GNUNET_CONTAINER_multihashmap_get_multiple (forward_map, + &dht_stop_msg->key, + &remove_by_unique_id, + &ctx); + GNUNET_SERVICE_client_continue (ch->client); } @@ -854,33 +869,33 @@ handle_dht_local_get_stop(void *cls, * */ static void -handle_dht_local_monitor(void *cls, - const struct GNUNET_DHT_MonitorStartStopMessage *msg) +handle_dht_local_monitor (void *cls, + const struct GNUNET_DHT_MonitorStartStopMessage *msg) { struct ClientHandle *ch = cls; struct ClientMonitorRecord *r; - r = GNUNET_new(struct ClientMonitorRecord); + r = GNUNET_new (struct ClientMonitorRecord); r->ch = ch; - r->type = ntohl(msg->type); - r->get = ntohs(msg->get); - r->get_resp = ntohs(msg->get_resp); - r->put = ntohs(msg->put); - if (0 == ntohs(msg->filter_key)) - { - r->key = NULL; - } + r->type = ntohl (msg->type); + r->get = ntohs (msg->get); + r->get_resp = ntohs (msg->get_resp); + r->put = ntohs (msg->put); + if (0 == ntohs (msg->filter_key)) + { + r->key = NULL; + } else - { - r->key = GNUNET_new(struct GNUNET_HashCode); - GNUNET_memcpy(r->key, - &msg->key, - sizeof(struct GNUNET_HashCode)); - } - GNUNET_CONTAINER_DLL_insert(monitor_head, - monitor_tail, - r); - GNUNET_SERVICE_client_continue(ch->client); + { + r->key = GNUNET_new (struct GNUNET_HashCode); + GNUNET_memcpy (r->key, + &msg->key, + sizeof(struct GNUNET_HashCode)); + } + GNUNET_CONTAINER_DLL_insert (monitor_head, + monitor_tail, + r); + GNUNET_SERVICE_client_continue (ch->client); } @@ -891,49 +906,51 @@ handle_dht_local_monitor(void *cls, * @param msg the actual message received */ static void -handle_dht_local_monitor_stop(void *cls, - const struct GNUNET_DHT_MonitorStartStopMessage *msg) +handle_dht_local_monitor_stop (void *cls, + const struct + GNUNET_DHT_MonitorStartStopMessage *msg) { struct ClientHandle *ch = cls; struct ClientMonitorRecord *r; int keys_match; - GNUNET_SERVICE_client_continue(ch->client); + GNUNET_SERVICE_client_continue (ch->client); for (r = monitor_head; NULL != r; r = r->next) + { + if (NULL == r->key) { - if (NULL == r->key) - { - keys_match = (0 == ntohs(msg->filter_key)); - } - else - { - keys_match = ((0 != ntohs(msg->filter_key)) && - (!memcmp(r->key, - &msg->key, - sizeof(struct GNUNET_HashCode)))); - } - if ((ch == r->ch) && - (ntohl(msg->type) == r->type) && - (r->get == msg->get) && - (r->get_resp == msg->get_resp) && - (r->put == msg->put) && - keys_match) - { - GNUNET_CONTAINER_DLL_remove(monitor_head, - monitor_tail, - r); - GNUNET_free_non_null(r->key); - GNUNET_free(r); - return; /* Delete only ONE entry */ - } + keys_match = (0 == ntohs (msg->filter_key)); } + else + { + keys_match = ((0 != ntohs (msg->filter_key)) && + (! memcmp (r->key, + &msg->key, + sizeof(struct GNUNET_HashCode)))); + } + if ((ch == r->ch) && + (ntohl (msg->type) == r->type) && + (r->get == msg->get) && + (r->get_resp == msg->get_resp) && + (r->put == msg->put) && + keys_match) + { + GNUNET_CONTAINER_DLL_remove (monitor_head, + monitor_tail, + r); + GNUNET_free_non_null (r->key); + GNUNET_free (r); + return; /* Delete only ONE entry */ + } + } } /** * Closure for #forward_reply() */ -struct ForwardReplyContext { +struct ForwardReplyContext +{ /** * Expiration time of the reply. */ @@ -988,9 +1005,9 @@ struct ForwardReplyContext { * if the result is mal-formed, #GNUNET_NO */ static int -forward_reply(void *cls, - const struct GNUNET_HashCode *key, - void *value) +forward_reply (void *cls, + const struct GNUNET_HashCode *key, + void *value) { struct ForwardReplyContext *frc = cls; struct ClientQueryRecord *record = value; @@ -1001,124 +1018,127 @@ forward_reply(void *cls, struct GNUNET_HashCode ch; struct GNUNET_PeerIdentity *paths; - LOG_TRAFFIC(GNUNET_ERROR_TYPE_DEBUG, - "CLIENT-RESULT %s\n", - GNUNET_h2s_full(key)); + LOG_TRAFFIC (GNUNET_ERROR_TYPE_DEBUG, + "CLIENT-RESULT %s\n", + GNUNET_h2s_full (key)); if ((record->type != GNUNET_BLOCK_TYPE_ANY) && (record->type != frc->type)) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Record type mismatch, not passing request for key %s to local client\n", + GNUNET_h2s (key)); + GNUNET_STATISTICS_update (GDS_stats, + gettext_noop + ( + "# Key match, type mismatches in REPLY to CLIENT"), + 1, GNUNET_NO); + return GNUNET_YES; /* type mismatch */ + } + GNUNET_CRYPTO_hash (frc->data, frc->data_size, &ch); + for (unsigned int i = 0; i < record->seen_replies_count; i++) + if (0 == memcmp (&record->seen_replies[i], + &ch, + sizeof(struct GNUNET_HashCode))) { - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Record type mismatch, not passing request for key %s to local client\n", - GNUNET_h2s(key)); - GNUNET_STATISTICS_update(GDS_stats, - gettext_noop - ("# Key match, type mismatches in REPLY to CLIENT"), - 1, GNUNET_NO); - return GNUNET_YES; /* type mismatch */ + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Duplicate reply, not passing request for key %s to local client\n", + GNUNET_h2s (key)); + GNUNET_STATISTICS_update (GDS_stats, + gettext_noop + ( + "# Duplicate REPLIES to CLIENT request dropped"), + 1, GNUNET_NO); + return GNUNET_YES; /* duplicate */ } - GNUNET_CRYPTO_hash(frc->data, frc->data_size, &ch); - for (unsigned int i = 0; i < record->seen_replies_count; i++) - if (0 == memcmp(&record->seen_replies[i], - &ch, - sizeof(struct GNUNET_HashCode))) - { - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Duplicate reply, not passing request for key %s to local client\n", - GNUNET_h2s(key)); - GNUNET_STATISTICS_update(GDS_stats, - gettext_noop - ("# Duplicate REPLIES to CLIENT request dropped"), - 1, GNUNET_NO); - return GNUNET_YES; /* duplicate */ - } eval - = GNUNET_BLOCK_evaluate(GDS_block_context, - record->type, - NULL, - GNUNET_BLOCK_EO_NONE, - key, - record->xquery, - record->xquery_size, - frc->data, - frc->data_size); - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Evaluation result is %d for key %s for local client's query\n", - (int)eval, - GNUNET_h2s(key)); + = GNUNET_BLOCK_evaluate (GDS_block_context, + record->type, + NULL, + GNUNET_BLOCK_EO_NONE, + key, + record->xquery, + record->xquery_size, + frc->data, + frc->data_size); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Evaluation result is %d for key %s for local client's query\n", + (int) eval, + GNUNET_h2s (key)); switch (eval) - { - case GNUNET_BLOCK_EVALUATION_OK_LAST: - do_free = GNUNET_YES; - break; - - case GNUNET_BLOCK_EVALUATION_OK_MORE: - GNUNET_array_append(record->seen_replies, - record->seen_replies_count, - ch); - do_free = GNUNET_NO; - break; - - case GNUNET_BLOCK_EVALUATION_OK_DUPLICATE: - /* should be impossible to encounter here */ - GNUNET_break(0); - return GNUNET_YES; - - case GNUNET_BLOCK_EVALUATION_RESULT_INVALID: - GNUNET_break_op(0); - return GNUNET_NO; - - case GNUNET_BLOCK_EVALUATION_REQUEST_VALID: - GNUNET_break(0); - return GNUNET_NO; - - case GNUNET_BLOCK_EVALUATION_REQUEST_INVALID: - GNUNET_break(0); - return GNUNET_NO; - - case GNUNET_BLOCK_EVALUATION_RESULT_IRRELEVANT: - return GNUNET_YES; - - case GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED: - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, - _("Unsupported block type (%u) in request!\n"), record->type); - return GNUNET_NO; - - default: - GNUNET_break(0); - return GNUNET_NO; - } - GNUNET_STATISTICS_update(GDS_stats, - gettext_noop("# RESULTS queued for clients"), - 1, - GNUNET_NO); - env = GNUNET_MQ_msg_extra(reply, - frc->data_size + - (frc->get_path_length + frc->put_path_length) * sizeof(struct GNUNET_PeerIdentity), - GNUNET_MESSAGE_TYPE_DHT_CLIENT_RESULT); - reply->type = htonl(frc->type); - reply->get_path_length = htonl(frc->get_path_length); - reply->put_path_length = htonl(frc->put_path_length); + { + case GNUNET_BLOCK_EVALUATION_OK_LAST: + do_free = GNUNET_YES; + break; + + case GNUNET_BLOCK_EVALUATION_OK_MORE: + GNUNET_array_append (record->seen_replies, + record->seen_replies_count, + ch); + do_free = GNUNET_NO; + break; + + case GNUNET_BLOCK_EVALUATION_OK_DUPLICATE: + /* should be impossible to encounter here */ + GNUNET_break (0); + return GNUNET_YES; + + case GNUNET_BLOCK_EVALUATION_RESULT_INVALID: + GNUNET_break_op (0); + return GNUNET_NO; + + case GNUNET_BLOCK_EVALUATION_REQUEST_VALID: + GNUNET_break (0); + return GNUNET_NO; + + case GNUNET_BLOCK_EVALUATION_REQUEST_INVALID: + GNUNET_break (0); + return GNUNET_NO; + + case GNUNET_BLOCK_EVALUATION_RESULT_IRRELEVANT: + return GNUNET_YES; + + case GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED: + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + _ ("Unsupported block type (%u) in request!\n"), record->type); + return GNUNET_NO; + + default: + GNUNET_break (0); + return GNUNET_NO; + } + GNUNET_STATISTICS_update (GDS_stats, + gettext_noop ("# RESULTS queued for clients"), + 1, + GNUNET_NO); + env = GNUNET_MQ_msg_extra (reply, + frc->data_size + + (frc->get_path_length + frc->put_path_length) + * sizeof(struct GNUNET_PeerIdentity), + GNUNET_MESSAGE_TYPE_DHT_CLIENT_RESULT); + reply->type = htonl (frc->type); + reply->get_path_length = htonl (frc->get_path_length); + reply->put_path_length = htonl (frc->put_path_length); reply->unique_id = record->unique_id; - reply->expiration = GNUNET_TIME_absolute_hton(frc->expiration); + reply->expiration = GNUNET_TIME_absolute_hton (frc->expiration); reply->key = *key; - paths = (struct GNUNET_PeerIdentity *)&reply[1]; - GNUNET_memcpy(paths, - frc->put_path, - sizeof(struct GNUNET_PeerIdentity) * frc->put_path_length); - GNUNET_memcpy(&paths[frc->put_path_length], - frc->get_path, - sizeof(struct GNUNET_PeerIdentity) * frc->get_path_length); - GNUNET_memcpy(&paths[frc->get_path_length + frc->put_path_length], - frc->data, - frc->data_size); - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Sending reply to query %s for client %p\n", - GNUNET_h2s(key), - record->ch->client); - GNUNET_MQ_send(record->ch->mq, - env); + paths = (struct GNUNET_PeerIdentity *) &reply[1]; + GNUNET_memcpy (paths, + frc->put_path, + sizeof(struct GNUNET_PeerIdentity) * frc->put_path_length); + GNUNET_memcpy (&paths[frc->put_path_length], + frc->get_path, + sizeof(struct GNUNET_PeerIdentity) * frc->get_path_length); + GNUNET_memcpy (&paths[frc->get_path_length + frc->put_path_length], + frc->data, + frc->data_size); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Sending reply to query %s for client %p\n", + GNUNET_h2s (key), + record->ch->client); + GNUNET_MQ_send (record->ch->mq, + env); if (GNUNET_YES == do_free) - remove_client_record(record); + remove_client_record (record); return GNUNET_YES; } @@ -1139,38 +1159,40 @@ forward_reply(void *cls, * @param data application payload data */ void -GDS_CLIENTS_handle_reply(struct GNUNET_TIME_Absolute expiration, - const struct GNUNET_HashCode *key, - unsigned int get_path_length, - const struct GNUNET_PeerIdentity *get_path, - unsigned int put_path_length, - const struct GNUNET_PeerIdentity *put_path, - enum GNUNET_BLOCK_Type type, - size_t data_size, - const void *data) +GDS_CLIENTS_handle_reply (struct GNUNET_TIME_Absolute expiration, + const struct GNUNET_HashCode *key, + unsigned int get_path_length, + const struct GNUNET_PeerIdentity *get_path, + unsigned int put_path_length, + const struct GNUNET_PeerIdentity *put_path, + enum GNUNET_BLOCK_Type type, + size_t data_size, + const void *data) { struct ForwardReplyContext frc; size_t msize; - msize = sizeof(struct GNUNET_DHT_ClientResultMessage) + data_size + - (get_path_length + put_path_length) * sizeof(struct GNUNET_PeerIdentity); + msize = sizeof(struct GNUNET_DHT_ClientResultMessage) + data_size + + (get_path_length + put_path_length) * sizeof(struct + GNUNET_PeerIdentity); if (msize >= GNUNET_MAX_MESSAGE_SIZE) - { - GNUNET_break(0); - return; - } - if (NULL == GNUNET_CONTAINER_multihashmap_get(forward_map, - key)) - { - LOG(GNUNET_ERROR_TYPE_DEBUG, - "No matching client for reply for key %s\n", - GNUNET_h2s(key)); - GNUNET_STATISTICS_update(GDS_stats, - gettext_noop("# REPLIES ignored for CLIENTS (no match)"), - 1, - GNUNET_NO); - return; /* no matching request, fast exit! */ - } + { + GNUNET_break (0); + return; + } + if (NULL == GNUNET_CONTAINER_multihashmap_get (forward_map, + key)) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "No matching client for reply for key %s\n", + GNUNET_h2s (key)); + GNUNET_STATISTICS_update (GDS_stats, + gettext_noop ( + "# REPLIES ignored for CLIENTS (no match)"), + 1, + GNUNET_NO); + return; /* no matching request, fast exit! */ + } frc.expiration = expiration; frc.get_path = get_path; frc.put_path = put_path; @@ -1179,13 +1201,13 @@ GDS_CLIENTS_handle_reply(struct GNUNET_TIME_Absolute expiration, frc.get_path_length = get_path_length; frc.put_path_length = put_path_length; frc.type = type; - LOG(GNUNET_ERROR_TYPE_DEBUG, - "Forwarding reply for key %s to client\n", - GNUNET_h2s(key)); - GNUNET_CONTAINER_multihashmap_get_multiple(forward_map, - key, - &forward_reply, - &frc); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Forwarding reply for key %s to client\n", + GNUNET_h2s (key)); + GNUNET_CONTAINER_multihashmap_get_multiple (forward_map, + key, + &forward_reply, + &frc); } @@ -1202,13 +1224,13 @@ GDS_CLIENTS_handle_reply(struct GNUNET_TIME_Absolute expiration, * @param key Key of the requested data. */ void -GDS_CLIENTS_process_get(uint32_t 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) +GDS_CLIENTS_process_get (uint32_t 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) { struct ClientMonitorRecord *m; struct ClientHandle **cl; @@ -1217,49 +1239,49 @@ GDS_CLIENTS_process_get(uint32_t options, cl = NULL; cl_size = 0; for (m = monitor_head; NULL != m; m = m->next) + { + if (((GNUNET_BLOCK_TYPE_ANY == m->type) || + (m->type == type)) && + ((NULL == m->key) || + (0 == memcmp (key, + m->key, + sizeof(struct GNUNET_HashCode))))) { - if (((GNUNET_BLOCK_TYPE_ANY == m->type) || - (m->type == type)) && - ((NULL == m->key) || - (0 == memcmp(key, - m->key, - sizeof(struct GNUNET_HashCode))))) - { - struct GNUNET_MQ_Envelope *env; - struct GNUNET_DHT_MonitorGetMessage *mmsg; - struct GNUNET_PeerIdentity *msg_path; - size_t msize; - unsigned int i; - - /* Don't send duplicates */ - for (i = 0; i < cl_size; i++) - if (cl[i] == m->ch) - break; - if (i < cl_size) - continue; - GNUNET_array_append(cl, - cl_size, - m->ch); - - msize = path_length * sizeof(struct GNUNET_PeerIdentity); - env = GNUNET_MQ_msg_extra(mmsg, - msize, - GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET); - mmsg->options = htonl(options); - mmsg->type = htonl(type); - mmsg->hop_count = htonl(hop_count); - mmsg->desired_replication_level = htonl(desired_replication_level); - mmsg->get_path_length = htonl(path_length); - mmsg->key = *key; - msg_path = (struct GNUNET_PeerIdentity *)&mmsg[1]; - GNUNET_memcpy(msg_path, - path, - path_length * sizeof(struct GNUNET_PeerIdentity)); - GNUNET_MQ_send(m->ch->mq, - env); - } + struct GNUNET_MQ_Envelope *env; + struct GNUNET_DHT_MonitorGetMessage *mmsg; + struct GNUNET_PeerIdentity *msg_path; + size_t msize; + unsigned int i; + + /* Don't send duplicates */ + for (i = 0; i < cl_size; i++) + if (cl[i] == m->ch) + break; + if (i < cl_size) + continue; + GNUNET_array_append (cl, + cl_size, + m->ch); + + msize = path_length * sizeof(struct GNUNET_PeerIdentity); + env = GNUNET_MQ_msg_extra (mmsg, + msize, + GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET); + mmsg->options = htonl (options); + mmsg->type = htonl (type); + mmsg->hop_count = htonl (hop_count); + mmsg->desired_replication_level = htonl (desired_replication_level); + mmsg->get_path_length = htonl (path_length); + mmsg->key = *key; + msg_path = (struct GNUNET_PeerIdentity *) &mmsg[1]; + GNUNET_memcpy (msg_path, + path, + path_length * sizeof(struct GNUNET_PeerIdentity)); + GNUNET_MQ_send (m->ch->mq, + env); } - GNUNET_free_non_null(cl); + } + GNUNET_free_non_null (cl); } @@ -1278,15 +1300,15 @@ GDS_CLIENTS_process_get(uint32_t options, * @param size Number of bytes in @a data. */ void -GDS_CLIENTS_process_get_resp(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) +GDS_CLIENTS_process_get_resp (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) { struct ClientMonitorRecord *m; struct ClientHandle **cl; @@ -1295,53 +1317,53 @@ GDS_CLIENTS_process_get_resp(enum GNUNET_BLOCK_Type type, cl = NULL; cl_size = 0; for (m = monitor_head; NULL != m; m = m->next) + { + if (((GNUNET_BLOCK_TYPE_ANY == m->type) ||(m->type == type) ) && + ((NULL == m->key) || + (memcmp (key, m->key, sizeof(struct GNUNET_HashCode)) == 0) )) { - if ((GNUNET_BLOCK_TYPE_ANY == m->type || m->type == type) && - (NULL == m->key || - memcmp(key, m->key, sizeof(struct GNUNET_HashCode)) == 0)) - { - struct GNUNET_MQ_Envelope *env; - struct GNUNET_DHT_MonitorGetRespMessage *mmsg; - struct GNUNET_PeerIdentity *path; - size_t msize; - unsigned int i; - - /* Don't send duplicates */ - for (i = 0; i < cl_size; i++) - if (cl[i] == m->ch) - break; - if (i < cl_size) - continue; - GNUNET_array_append(cl, - cl_size, - m->ch); - - msize = size; - msize += (get_path_length + put_path_length) - * sizeof(struct GNUNET_PeerIdentity); - env = GNUNET_MQ_msg_extra(mmsg, - msize, - GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET_RESP); - mmsg->type = htonl(type); - mmsg->put_path_length = htonl(put_path_length); - mmsg->get_path_length = htonl(get_path_length); - mmsg->expiration_time = GNUNET_TIME_absolute_hton(exp); - mmsg->key = *key; - path = (struct GNUNET_PeerIdentity *)&mmsg[1]; - GNUNET_memcpy(path, - put_path, - put_path_length * sizeof(struct GNUNET_PeerIdentity)); - GNUNET_memcpy(path, - get_path, - get_path_length * sizeof(struct GNUNET_PeerIdentity)); - GNUNET_memcpy(&path[get_path_length], - data, - size); - GNUNET_MQ_send(m->ch->mq, - env); - } + struct GNUNET_MQ_Envelope *env; + struct GNUNET_DHT_MonitorGetRespMessage *mmsg; + struct GNUNET_PeerIdentity *path; + size_t msize; + unsigned int i; + + /* Don't send duplicates */ + for (i = 0; i < cl_size; i++) + if (cl[i] == m->ch) + break; + if (i < cl_size) + continue; + GNUNET_array_append (cl, + cl_size, + m->ch); + + msize = size; + msize += (get_path_length + put_path_length) + * sizeof(struct GNUNET_PeerIdentity); + env = GNUNET_MQ_msg_extra (mmsg, + msize, + GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET_RESP); + mmsg->type = htonl (type); + mmsg->put_path_length = htonl (put_path_length); + mmsg->get_path_length = htonl (get_path_length); + mmsg->expiration_time = GNUNET_TIME_absolute_hton (exp); + mmsg->key = *key; + path = (struct GNUNET_PeerIdentity *) &mmsg[1]; + GNUNET_memcpy (path, + put_path, + put_path_length * sizeof(struct GNUNET_PeerIdentity)); + GNUNET_memcpy (path, + get_path, + get_path_length * sizeof(struct GNUNET_PeerIdentity)); + GNUNET_memcpy (&path[get_path_length], + data, + size); + GNUNET_MQ_send (m->ch->mq, + env); } - GNUNET_free_non_null(cl); + } + GNUNET_free_non_null (cl); } @@ -1361,16 +1383,16 @@ GDS_CLIENTS_process_get_resp(enum GNUNET_BLOCK_Type type, * @param size Number of bytes in data. */ void -GDS_CLIENTS_process_put(uint32_t 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) +GDS_CLIENTS_process_put (uint32_t 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) { struct ClientMonitorRecord *m; struct ClientHandle **cl; @@ -1379,51 +1401,51 @@ GDS_CLIENTS_process_put(uint32_t options, cl = NULL; cl_size = 0; for (m = monitor_head; NULL != m; m = m->next) + { + if (((GNUNET_BLOCK_TYPE_ANY == m->type) ||(m->type == type) ) && + ((NULL == m->key) || + (memcmp (key, m->key, sizeof(struct GNUNET_HashCode)) == 0) )) { - if ((GNUNET_BLOCK_TYPE_ANY == m->type || m->type == type) && - (NULL == m->key || - memcmp(key, m->key, sizeof(struct GNUNET_HashCode)) == 0)) - { - struct GNUNET_MQ_Envelope *env; - struct GNUNET_DHT_MonitorPutMessage *mmsg; - struct GNUNET_PeerIdentity *msg_path; - size_t msize; - unsigned int i; - - /* Don't send duplicates */ - for (i = 0; i < cl_size; i++) - if (cl[i] == m->ch) - break; - if (i < cl_size) - continue; - GNUNET_array_append(cl, - cl_size, - m->ch); - - msize = size; - msize += path_length * sizeof(struct GNUNET_PeerIdentity); - env = GNUNET_MQ_msg_extra(mmsg, - msize, - GNUNET_MESSAGE_TYPE_DHT_MONITOR_PUT); - mmsg->options = htonl(options); - mmsg->type = htonl(type); - mmsg->hop_count = htonl(hop_count); - mmsg->desired_replication_level = htonl(desired_replication_level); - mmsg->put_path_length = htonl(path_length); - mmsg->key = *key; - mmsg->expiration_time = GNUNET_TIME_absolute_hton(exp); - msg_path = (struct GNUNET_PeerIdentity *)&mmsg[1]; - GNUNET_memcpy(msg_path, - path, - path_length * sizeof(struct GNUNET_PeerIdentity)); - GNUNET_memcpy(&msg_path[path_length], - data, - size); - GNUNET_MQ_send(m->ch->mq, - env); - } + struct GNUNET_MQ_Envelope *env; + struct GNUNET_DHT_MonitorPutMessage *mmsg; + struct GNUNET_PeerIdentity *msg_path; + size_t msize; + unsigned int i; + + /* Don't send duplicates */ + for (i = 0; i < cl_size; i++) + if (cl[i] == m->ch) + break; + if (i < cl_size) + continue; + GNUNET_array_append (cl, + cl_size, + m->ch); + + msize = size; + msize += path_length * sizeof(struct GNUNET_PeerIdentity); + env = GNUNET_MQ_msg_extra (mmsg, + msize, + GNUNET_MESSAGE_TYPE_DHT_MONITOR_PUT); + mmsg->options = htonl (options); + mmsg->type = htonl (type); + mmsg->hop_count = htonl (hop_count); + mmsg->desired_replication_level = htonl (desired_replication_level); + mmsg->put_path_length = htonl (path_length); + mmsg->key = *key; + mmsg->expiration_time = GNUNET_TIME_absolute_hton (exp); + msg_path = (struct GNUNET_PeerIdentity *) &mmsg[1]; + GNUNET_memcpy (msg_path, + path, + path_length * sizeof(struct GNUNET_PeerIdentity)); + GNUNET_memcpy (&msg_path[path_length], + data, + size); + GNUNET_MQ_send (m->ch->mq, + env); } - GNUNET_free_non_null(cl); + } + GNUNET_free_non_null (cl); } @@ -1433,13 +1455,13 @@ GDS_CLIENTS_process_put(uint32_t options, * @param server the initialized server */ static void -GDS_CLIENTS_init() +GDS_CLIENTS_init () { forward_map - = GNUNET_CONTAINER_multihashmap_create(1024, - GNUNET_YES); + = GNUNET_CONTAINER_multihashmap_create (1024, + GNUNET_YES); retry_heap - = GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MIN); + = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN); } @@ -1447,13 +1469,13 @@ GDS_CLIENTS_init() * Shutdown client subsystem. */ static void -GDS_CLIENTS_stop() +GDS_CLIENTS_stop () { if (NULL != retry_task) - { - GNUNET_SCHEDULER_cancel(retry_task); - retry_task = NULL; - } + { + GNUNET_SCHEDULER_cancel (retry_task); + retry_task = NULL; + } } @@ -1471,51 +1493,51 @@ GDS_CLIENTS_stop() &client_connect_cb, \ &client_disconnect_cb, \ NULL, \ - GNUNET_MQ_hd_var_size(dht_local_put, \ - GNUNET_MESSAGE_TYPE_DHT_CLIENT_PUT, \ - struct GNUNET_DHT_ClientPutMessage, \ - NULL), \ - GNUNET_MQ_hd_var_size(dht_local_get, \ - GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET, \ - struct GNUNET_DHT_ClientGetMessage, \ - NULL), \ - GNUNET_MQ_hd_fixed_size(dht_local_get_stop, \ - GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET_STOP, \ - struct GNUNET_DHT_ClientGetStopMessage, \ - NULL), \ - GNUNET_MQ_hd_fixed_size(dht_local_monitor, \ - GNUNET_MESSAGE_TYPE_DHT_MONITOR_START, \ - struct GNUNET_DHT_MonitorStartStopMessage, \ - NULL), \ - GNUNET_MQ_hd_fixed_size(dht_local_monitor_stop, \ - GNUNET_MESSAGE_TYPE_DHT_MONITOR_STOP, \ - struct GNUNET_DHT_MonitorStartStopMessage, \ - NULL), \ - GNUNET_MQ_hd_var_size(dht_local_get_result_seen, \ - GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET_RESULTS_KNOWN, \ - struct GNUNET_DHT_ClientGetResultSeenMessage, \ - NULL), \ - GNUNET_MQ_handler_end()) + GNUNET_MQ_hd_var_size (dht_local_put, \ + GNUNET_MESSAGE_TYPE_DHT_CLIENT_PUT, \ + struct GNUNET_DHT_ClientPutMessage, \ + NULL), \ + GNUNET_MQ_hd_var_size (dht_local_get, \ + GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET, \ + struct GNUNET_DHT_ClientGetMessage, \ + NULL), \ + GNUNET_MQ_hd_fixed_size (dht_local_get_stop, \ + GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET_STOP, \ + struct GNUNET_DHT_ClientGetStopMessage, \ + NULL), \ + GNUNET_MQ_hd_fixed_size (dht_local_monitor, \ + GNUNET_MESSAGE_TYPE_DHT_MONITOR_START, \ + struct GNUNET_DHT_MonitorStartStopMessage, \ + NULL), \ + GNUNET_MQ_hd_fixed_size (dht_local_monitor_stop, \ + GNUNET_MESSAGE_TYPE_DHT_MONITOR_STOP, \ + struct GNUNET_DHT_MonitorStartStopMessage, \ + NULL), \ + GNUNET_MQ_hd_var_size (dht_local_get_result_seen, \ + GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET_RESULTS_KNOWN, \ + struct GNUNET_DHT_ClientGetResultSeenMessage, \ + NULL), \ + GNUNET_MQ_handler_end ()) /** * MINIMIZE heap size (way below 128k) since this process doesn't need much. */ void __attribute__ ((destructor)) -GDS_CLIENTS_done() +GDS_CLIENTS_done () { if (NULL != retry_heap) - { - GNUNET_assert(0 == GNUNET_CONTAINER_heap_get_size(retry_heap)); - GNUNET_CONTAINER_heap_destroy(retry_heap); - retry_heap = NULL; - } + { + GNUNET_assert (0 == GNUNET_CONTAINER_heap_get_size (retry_heap)); + GNUNET_CONTAINER_heap_destroy (retry_heap); + retry_heap = NULL; + } if (NULL != forward_map) - { - GNUNET_assert(0 == GNUNET_CONTAINER_multihashmap_size(forward_map)); - GNUNET_CONTAINER_multihashmap_destroy(forward_map); - forward_map = NULL; - } + { + GNUNET_assert (0 == GNUNET_CONTAINER_multihashmap_size (forward_map)); + GNUNET_CONTAINER_multihashmap_destroy (forward_map); + forward_map = NULL; + } } /* end of gnunet-service-dht_clients.c */ -- cgit v1.2.3