From 502af2167f7c218366666ca4944bd7cc54b5b19a Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Mon, 15 Aug 2011 21:46:35 +0000 Subject: indentation --- src/dv/dv.h | 15 +- src/dv/dv_api.c | 347 +++--- src/dv/gnunet-service-dv.c | 2271 ++++++++++++++++++++++------------------ src/dv/plugin_transport_dv.c | 157 +-- src/dv/test_transport_api_dv.c | 1154 ++++++++++---------- 5 files changed, 2149 insertions(+), 1795 deletions(-) (limited to 'src/dv') diff --git a/src/dv/dv.h b/src/dv/dv.h index 10b531ced..3c62a22bc 100644 --- a/src/dv/dv.h +++ b/src/dv/dv.h @@ -37,8 +37,8 @@ #define DEBUG_MESSAGE_DROP GNUNET_NO typedef void (*GNUNET_DV_MessageReceivedHandler) (void *cls, - struct GNUNET_PeerIdentity *sender, - char *msg, + struct GNUNET_PeerIdentity * + sender, char *msg, size_t msg_len, uint32_t distance, char *sender_address, @@ -257,16 +257,17 @@ typedef struct } p2p_dv_MESSAGE_Disconnect; -struct GNUNET_DV_Handle * -GNUNET_DV_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, - GNUNET_DV_MessageReceivedHandler receive_handler, - void *receive_handler_cls); +struct GNUNET_DV_Handle *GNUNET_DV_connect (const struct + GNUNET_CONFIGURATION_Handle *cfg, + GNUNET_DV_MessageReceivedHandler + receive_handler, + void *receive_handler_cls); /** * Disconnect from the DV service * * @param handle the current handle to the service to disconnect */ -void GNUNET_DV_disconnect(struct GNUNET_DV_Handle *handle); +void GNUNET_DV_disconnect (struct GNUNET_DV_Handle *handle); #endif diff --git a/src/dv/dv_api.c b/src/dv/dv_api.c index d954d718b..7a250b5a6 100644 --- a/src/dv/dv_api.c +++ b/src/dv/dv_api.c @@ -152,11 +152,10 @@ struct SendCallbackContext * @param hash set to uid (extended with zeros) */ static void -hash_from_uid (uint32_t uid, - GNUNET_HashCode *hash) +hash_from_uid (uint32_t uid, GNUNET_HashCode * hash) { - memset (hash, 0, sizeof(GNUNET_HashCode)); - *((uint32_t*)hash) = uid; + memset (hash, 0, sizeof (GNUNET_HashCode)); + *((uint32_t *) hash) = uid; } /** @@ -181,7 +180,7 @@ try_connect (struct GNUNET_DV_Handle *ret) return GNUNET_NO; } -static void process_pending_message(struct GNUNET_DV_Handle *handle); +static void process_pending_message (struct GNUNET_DV_Handle *handle); /** * Send complete, schedule next @@ -193,10 +192,11 @@ static void finish (struct GNUNET_DV_Handle *handle, int code) { struct PendingMessages *pos = handle->current; + handle->current = NULL; process_pending_message (handle); - GNUNET_free(pos->msg); + GNUNET_free (pos->msg); GNUNET_free (pos); } @@ -218,31 +218,35 @@ transmit_pending (void *cls, size_t size, void *buf) #if DEBUG_DV if (handle->current != NULL) - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "DV API: Transmit pending called with message type %d\n", ntohs(handle->current->msg->header.type)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "DV API: Transmit pending called with message type %d\n", + ntohs (handle->current->msg->header.type)); #endif if (buf == NULL) - { + { #if DEBUG_DV - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "DV API: Transmit pending FAILED!\n\n\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "DV API: Transmit pending FAILED!\n\n\n"); #endif - finish(handle, GNUNET_SYSERR); - return 0; - } + finish (handle, GNUNET_SYSERR); + return 0; + } handle->th = NULL; ret = 0; if (handle->current != NULL) { - tsize = ntohs(handle->current->msg->header.size); + tsize = ntohs (handle->current->msg->header.size); if (size >= tsize) { - memcpy(buf, handle->current->msg, tsize); + memcpy (buf, handle->current->msg, tsize); #if DEBUG_DV - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "DV API: Copied %d bytes into buffer!\n\n\n", tsize); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "DV API: Copied %d bytes into buffer!\n\n\n", tsize); #endif - finish(handle, GNUNET_OK); + finish (handle, GNUNET_OK); return tsize; } @@ -256,39 +260,44 @@ transmit_pending (void *cls, size_t size, void *buf) * * @param handle handle to the distance vector service */ -static void process_pending_message(struct GNUNET_DV_Handle *handle) +static void +process_pending_message (struct GNUNET_DV_Handle *handle) { if (handle->current != NULL) return; /* action already pending */ if (GNUNET_YES != try_connect (handle)) - { - finish (handle, GNUNET_SYSERR); - return; - } + { + finish (handle, GNUNET_SYSERR); + return; + } /* schedule next action */ handle->current = handle->pending_list; if (NULL == handle->current) - { - return; - } + { + return; + } handle->pending_list = handle->pending_list->next; handle->current->next = NULL; if (NULL == (handle->th = GNUNET_CLIENT_notify_transmit_ready (handle->client, - ntohs(handle->current->msg->header.size), - handle->current->msg->timeout, + ntohs + (handle->current-> + msg->header.size), + handle->current-> + msg->timeout, GNUNET_YES, - &transmit_pending, handle))) - { + &transmit_pending, + handle))) + { #if DEBUG_DV - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Failed to transmit request to dv service.\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Failed to transmit request to dv service.\n"); #endif - finish (handle, GNUNET_SYSERR); - } + finish (handle, GNUNET_SYSERR); + } } /** @@ -297,31 +306,32 @@ static void process_pending_message(struct GNUNET_DV_Handle *handle) * @param handle handle to the specified DV api * @param msg the message to add to the list */ -static void add_pending(struct GNUNET_DV_Handle *handle, struct GNUNET_DV_SendMessage *msg) +static void +add_pending (struct GNUNET_DV_Handle *handle, struct GNUNET_DV_SendMessage *msg) { struct PendingMessages *new_message; struct PendingMessages *pos; struct PendingMessages *last; - new_message = GNUNET_malloc(sizeof(struct PendingMessages)); + new_message = GNUNET_malloc (sizeof (struct PendingMessages)); new_message->msg = msg; if (handle->pending_list != NULL) + { + pos = handle->pending_list; + while (pos != NULL) { - pos = handle->pending_list; - while(pos != NULL) - { - last = pos; - pos = pos->next; - } - last->next = new_message; + last = pos; + pos = pos->next; } + last->next = new_message; + } else - { - handle->pending_list = new_message; - } + { + handle->pending_list = new_message; + } - process_pending_message(handle); + process_pending_message (handle); } /** @@ -331,8 +341,8 @@ static void add_pending(struct GNUNET_DV_Handle *handle, struct GNUNET_DV_SendMe * @param cls the handle to the DV API * @param msg the message that was received */ -void handle_message_receipt (void *cls, - const struct GNUNET_MessageHeader * msg) +void +handle_message_receipt (void *cls, const struct GNUNET_MessageHeader *msg) { struct GNUNET_DV_Handle *handle = cls; struct GNUNET_DV_MessageReceived *received_msg; @@ -348,65 +358,75 @@ void handle_message_receipt (void *cls, if (msg == NULL) { #if DEBUG_DV_MESSAGES - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "DV_API receive: connection closed\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "DV_API receive: connection closed\n"); #endif - return; /* Connection closed? */ + return; /* Connection closed? */ } - GNUNET_assert((ntohs(msg->type) == GNUNET_MESSAGE_TYPE_TRANSPORT_DV_RECEIVE) || (ntohs(msg->type) == GNUNET_MESSAGE_TYPE_TRANSPORT_DV_SEND_RESULT)); + GNUNET_assert ((ntohs (msg->type) == GNUNET_MESSAGE_TYPE_TRANSPORT_DV_RECEIVE) + || (ntohs (msg->type) == + GNUNET_MESSAGE_TYPE_TRANSPORT_DV_SEND_RESULT)); - switch (ntohs(msg->type)) + switch (ntohs (msg->type)) { case GNUNET_MESSAGE_TYPE_TRANSPORT_DV_RECEIVE: - if (ntohs(msg->size) < sizeof(struct GNUNET_DV_MessageReceived)) + if (ntohs (msg->size) < sizeof (struct GNUNET_DV_MessageReceived)) return; - received_msg = (struct GNUNET_DV_MessageReceived *)msg; - packed_msg_len = ntohl(received_msg->msg_len); - sender_address_len = ntohs(msg->size) - packed_msg_len - sizeof(struct GNUNET_DV_MessageReceived); - GNUNET_assert(sender_address_len > 0); - sender_address = GNUNET_malloc(sender_address_len); - memcpy(sender_address, &received_msg[1], sender_address_len); - packed_msg_start = (char *)&received_msg[1]; - packed_msg = GNUNET_malloc(packed_msg_len); - memcpy(packed_msg, &packed_msg_start[sender_address_len], packed_msg_len); + received_msg = (struct GNUNET_DV_MessageReceived *) msg; + packed_msg_len = ntohl (received_msg->msg_len); + sender_address_len = + ntohs (msg->size) - packed_msg_len - + sizeof (struct GNUNET_DV_MessageReceived); + GNUNET_assert (sender_address_len > 0); + sender_address = GNUNET_malloc (sender_address_len); + memcpy (sender_address, &received_msg[1], sender_address_len); + packed_msg_start = (char *) &received_msg[1]; + packed_msg = GNUNET_malloc (packed_msg_len); + memcpy (packed_msg, &packed_msg_start[sender_address_len], packed_msg_len); #if DEBUG_DV_MESSAGES - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "DV_API receive: packed message type: %d or %d\n", ntohs(((struct GNUNET_MessageHeader *)packed_msg)->type), ((struct GNUNET_MessageHeader *)packed_msg)->type); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "DV_API receive: message sender reported as %s\n", GNUNET_i2s(&received_msg->sender)); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "DV_API receive: distance is %u\n", ntohl(received_msg->distance)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "DV_API receive: packed message type: %d or %d\n", + ntohs (((struct GNUNET_MessageHeader *) packed_msg)->type), + ((struct GNUNET_MessageHeader *) packed_msg)->type); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "DV_API receive: message sender reported as %s\n", + GNUNET_i2s (&received_msg->sender)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "DV_API receive: distance is %u\n", + ntohl (received_msg->distance)); #endif - handle->receive_handler(handle->receive_cls, - &received_msg->sender, - packed_msg, - packed_msg_len, - ntohl(received_msg->distance), - sender_address, - sender_address_len); + handle->receive_handler (handle->receive_cls, + &received_msg->sender, + packed_msg, + packed_msg_len, + ntohl (received_msg->distance), + sender_address, sender_address_len); - GNUNET_free(sender_address); + GNUNET_free (sender_address); break; case GNUNET_MESSAGE_TYPE_TRANSPORT_DV_SEND_RESULT: - if (ntohs(msg->size) < sizeof(struct GNUNET_DV_SendResultMessage)) + if (ntohs (msg->size) < sizeof (struct GNUNET_DV_SendResultMessage)) return; - send_result_msg = (struct GNUNET_DV_SendResultMessage *)msg; - hash_from_uid(ntohl(send_result_msg->uid), &uidhash); - send_ctx = GNUNET_CONTAINER_multihashmap_get(handle->send_callbacks, &uidhash); + send_result_msg = (struct GNUNET_DV_SendResultMessage *) msg; + hash_from_uid (ntohl (send_result_msg->uid), &uidhash); + send_ctx = + GNUNET_CONTAINER_multihashmap_get (handle->send_callbacks, &uidhash); if ((send_ctx != NULL) && (send_ctx->cont != NULL)) + { + if (ntohl (send_result_msg->result) == 0) + { + send_ctx->cont (send_ctx->cont_cls, &send_ctx->target, GNUNET_OK); + } + else { - if (ntohl(send_result_msg->result) == 0) - { - send_ctx->cont(send_ctx->cont_cls, &send_ctx->target, GNUNET_OK); - } - else - { - send_ctx->cont(send_ctx->cont_cls, &send_ctx->target, GNUNET_SYSERR); - } + send_ctx->cont (send_ctx->cont_cls, &send_ctx->target, GNUNET_SYSERR); } - GNUNET_free_non_null(send_ctx); + } + GNUNET_free_non_null (send_ctx); break; default: break; @@ -432,48 +452,52 @@ void handle_message_receipt (void *cls, * @param cont_cls closure for continuation * */ -int GNUNET_DV_send (struct GNUNET_DV_Handle *dv_handle, - const struct GNUNET_PeerIdentity *target, - const char *msgbuf, - size_t msgbuf_size, - unsigned int priority, - struct GNUNET_TIME_Relative timeout, - const void *addr, - size_t addrlen, - GNUNET_TRANSPORT_TransmitContinuation - cont, void *cont_cls) +int +GNUNET_DV_send (struct GNUNET_DV_Handle *dv_handle, + const struct GNUNET_PeerIdentity *target, + const char *msgbuf, + size_t msgbuf_size, + unsigned int priority, + struct GNUNET_TIME_Relative timeout, + const void *addr, + size_t addrlen, + GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls) { struct GNUNET_DV_SendMessage *msg; struct SendCallbackContext *send_ctx; char *end_of_message; GNUNET_HashCode uidhash; int msize; + #if DEBUG_DV_MESSAGES - dv_handle->uid_gen = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, UINT32_MAX); + dv_handle->uid_gen = + GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, UINT32_MAX); #else dv_handle->uid_gen++; #endif - msize = sizeof(struct GNUNET_DV_SendMessage) + addrlen + msgbuf_size; - msg = GNUNET_malloc(msize); - msg->header.size = htons(msize); - msg->header.type = htons(GNUNET_MESSAGE_TYPE_TRANSPORT_DV_SEND); - memcpy(&msg->target, target, sizeof(struct GNUNET_PeerIdentity)); - msg->priority = htonl(priority); + msize = sizeof (struct GNUNET_DV_SendMessage) + addrlen + msgbuf_size; + msg = GNUNET_malloc (msize); + msg->header.size = htons (msize); + msg->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DV_SEND); + memcpy (&msg->target, target, sizeof (struct GNUNET_PeerIdentity)); + msg->priority = htonl (priority); msg->timeout = timeout; - msg->addrlen = htonl(addrlen); - msg->uid = htonl(dv_handle->uid_gen); - memcpy(&msg[1], addr, addrlen); - end_of_message = (char *)&msg[1]; + msg->addrlen = htonl (addrlen); + msg->uid = htonl (dv_handle->uid_gen); + memcpy (&msg[1], addr, addrlen); + end_of_message = (char *) &msg[1]; end_of_message = &end_of_message[addrlen]; - memcpy(end_of_message, msgbuf, msgbuf_size); - add_pending(dv_handle, msg); - send_ctx = GNUNET_malloc(sizeof(struct SendCallbackContext)); + memcpy (end_of_message, msgbuf, msgbuf_size); + add_pending (dv_handle, msg); + send_ctx = GNUNET_malloc (sizeof (struct SendCallbackContext)); send_ctx->cont = cont; send_ctx->cont_cls = cont_cls; - memcpy(&send_ctx->target, target, sizeof(struct GNUNET_PeerIdentity)); - hash_from_uid(dv_handle->uid_gen, &uidhash); - GNUNET_CONTAINER_multihashmap_put(dv_handle->send_callbacks, &uidhash, send_ctx, GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE); + memcpy (&send_ctx->target, target, sizeof (struct GNUNET_PeerIdentity)); + hash_from_uid (dv_handle->uid_gen, &uidhash); + GNUNET_CONTAINER_multihashmap_put (dv_handle->send_callbacks, &uidhash, + send_ctx, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE); return GNUNET_OK; } @@ -494,23 +518,25 @@ transmit_start (void *cls, size_t size, void *buf) struct StartContext *start_context = cls; struct GNUNET_DV_Handle *handle = start_context->handle; size_t tsize; + #if DEBUG_DV - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "DV API: sending start request to service\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "DV API: sending start request to service\n"); #endif if (buf == NULL) - { - GNUNET_free(start_context->message); - GNUNET_free(start_context); - GNUNET_DV_disconnect(handle); - return 0; - } + { + GNUNET_free (start_context->message); + GNUNET_free (start_context); + GNUNET_DV_disconnect (handle); + return 0; + } - tsize = ntohs(start_context->message->size); + tsize = ntohs (start_context->message->size); if (size >= tsize) { - memcpy(buf, start_context->message, tsize); - GNUNET_free(start_context->message); - GNUNET_free(start_context); + memcpy (buf, start_context->message, tsize); + GNUNET_free (start_context->message); + GNUNET_free (start_context); GNUNET_CLIENT_receive (handle->client, &handle_message_receipt, handle, GNUNET_TIME_UNIT_FOREVER_REL); @@ -533,42 +559,44 @@ transmit_start (void *cls, size_t size, void *buf) */ struct GNUNET_DV_Handle * GNUNET_DV_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, - GNUNET_DV_MessageReceivedHandler receive_handler, - void *receive_handler_cls) + GNUNET_DV_MessageReceivedHandler receive_handler, + void *receive_handler_cls) { struct GNUNET_DV_Handle *handle; struct GNUNET_MessageHeader *start_message; struct StartContext *start_context; - handle = GNUNET_malloc(sizeof(struct GNUNET_DV_Handle)); + + handle = GNUNET_malloc (sizeof (struct GNUNET_DV_Handle)); handle->cfg = cfg; handle->pending_list = NULL; handle->current = NULL; handle->th = NULL; - handle->client = GNUNET_CLIENT_connect("dv", cfg); + handle->client = GNUNET_CLIENT_connect ("dv", cfg); handle->receive_handler = receive_handler; handle->receive_cls = receive_handler_cls; if (handle->client == NULL) - { - GNUNET_free(handle); - return NULL; - } + { + GNUNET_free (handle); + return NULL; + } - start_message = GNUNET_malloc(sizeof(struct GNUNET_MessageHeader)); - start_message->size = htons(sizeof(struct GNUNET_MessageHeader)); - start_message->type = htons(GNUNET_MESSAGE_TYPE_DV_START); + start_message = GNUNET_malloc (sizeof (struct GNUNET_MessageHeader)); + start_message->size = htons (sizeof (struct GNUNET_MessageHeader)); + start_message->type = htons (GNUNET_MESSAGE_TYPE_DV_START); - start_context = GNUNET_malloc(sizeof(struct StartContext)); + start_context = GNUNET_malloc (sizeof (struct StartContext)); start_context->handle = handle; start_context->message = start_message; GNUNET_CLIENT_notify_transmit_ready (handle->client, - sizeof(struct GNUNET_MessageHeader), - GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 60), - GNUNET_YES, - &transmit_start, start_context); + sizeof (struct GNUNET_MessageHeader), + GNUNET_TIME_relative_multiply + (GNUNET_TIME_UNIT_SECONDS, 60), + GNUNET_YES, &transmit_start, + start_context); - handle->send_callbacks = GNUNET_CONTAINER_multihashmap_create(100); + handle->send_callbacks = GNUNET_CONTAINER_multihashmap_create (100); return handle; } @@ -578,29 +606,30 @@ GNUNET_DV_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, * * @param handle the current handle to the service to disconnect */ -void GNUNET_DV_disconnect(struct GNUNET_DV_Handle *handle) +void +GNUNET_DV_disconnect (struct GNUNET_DV_Handle *handle) { struct PendingMessages *pos; - GNUNET_assert(handle != NULL); + GNUNET_assert (handle != NULL); - if (handle->th != NULL) /* We have a live transmit request in the Aether */ - { - GNUNET_CLIENT_notify_transmit_ready_cancel (handle->th); - handle->th = NULL; - } - if (handle->current != NULL) /* We are trying to send something now, clean it up */ - GNUNET_free(handle->current); - while (NULL != (pos = handle->pending_list)) /* Remove all pending sends from the list */ - { - handle->pending_list = pos->next; - GNUNET_free(pos); - } - if (handle->client != NULL) /* Finally, disconnect from the service */ - { - GNUNET_CLIENT_disconnect (handle->client, GNUNET_NO); - handle->client = NULL; - } + if (handle->th != NULL) /* We have a live transmit request in the Aether */ + { + GNUNET_CLIENT_notify_transmit_ready_cancel (handle->th); + handle->th = NULL; + } + if (handle->current != NULL) /* We are trying to send something now, clean it up */ + GNUNET_free (handle->current); + while (NULL != (pos = handle->pending_list)) /* Remove all pending sends from the list */ + { + handle->pending_list = pos->next; + GNUNET_free (pos); + } + if (handle->client != NULL) /* Finally, disconnect from the service */ + { + GNUNET_CLIENT_disconnect (handle->client, GNUNET_NO); + handle->client = NULL; + } GNUNET_free (handle); } diff --git a/src/dv/gnunet-service-dv.c b/src/dv/gnunet-service-dv.c index 3f52ddf2c..4b68f69b1 100644 --- a/src/dv/gnunet-service-dv.c +++ b/src/dv/gnunet-service-dv.c @@ -158,7 +158,7 @@ struct PendingMessage /** * Actual message to be sent; // avoid allocation */ - const struct GNUNET_MessageHeader *msg; // msg = (cast) &pm[1]; // memcpy (&pm[1], data, len); + const struct GNUNET_MessageHeader *msg; // msg = (cast) &pm[1]; // memcpy (&pm[1], data, len); }; @@ -568,7 +568,7 @@ static const struct GNUNET_CONFIGURATION_Handle *cfg; * this client will never change, although if the plugin dies * and returns for some reason it may happen. */ -static struct GNUNET_SERVER_Client * client_handle; +static struct GNUNET_SERVER_Client *client_handle; /** * Task to run when we shut down, cleaning up all our trash @@ -582,7 +582,7 @@ static char *my_short_id; /** * Transmit handle to the plugin. */ -static struct GNUNET_CONNECTION_TransmitHandle * plugin_transmit_handle; +static struct GNUNET_CONNECTION_TransmitHandle *plugin_transmit_handle; /** * Head of DLL for client messages @@ -602,7 +602,7 @@ static struct GNUNET_PEERINFO_Handle *peerinfo_handle; /** * Transmit handle to core service. */ -static struct GNUNET_CORE_TransmitHandle * core_transmit_handle; +static struct GNUNET_CORE_TransmitHandle *core_transmit_handle; /** * Head of DLL for core messages @@ -682,18 +682,18 @@ find_destination (void *cls, * respective neighbor. */ static int -find_specific_id (void *cls, - const GNUNET_HashCode *key, - void *value) +find_specific_id (void *cls, const GNUNET_HashCode * key, void *value) { struct FindIDContext *fdc = cls; struct DistantNeighbor *dn = value; - if (memcmp(&dn->referrer->identity, fdc->via, sizeof(struct GNUNET_PeerIdentity)) == 0) - { - fdc->tid = dn->referrer_id; - return GNUNET_NO; - } + if (memcmp + (&dn->referrer->identity, fdc->via, + sizeof (struct GNUNET_PeerIdentity)) == 0) + { + fdc->tid = dn->referrer_id; + return GNUNET_NO; + } return GNUNET_YES; } @@ -704,18 +704,17 @@ find_specific_id (void *cls, * want to remove those that may be accessible via a different * route. */ -static int find_distant_peer (void *cls, - const GNUNET_HashCode * key, - void *value) +static int +find_distant_peer (void *cls, const GNUNET_HashCode * key, void *value) { struct FindDestinationContext *fdc = cls; struct DistantNeighbor *distant = value; if (fdc->tid == distant->referrer_id) - { - fdc->dest = distant; - return GNUNET_NO; - } + { + fdc->dest = distant; + return GNUNET_NO; + } return GNUNET_YES; } @@ -730,8 +729,8 @@ static int find_distant_peer (void *cls, * @param buf where the callee should write the message * @return number of bytes written to buf */ -size_t transmit_to_plugin (void *cls, - size_t size, void *buf) +size_t +transmit_to_plugin (void *cls, size_t size, void *buf) { char *cbuf = buf; struct PendingMessage *reply; @@ -739,31 +738,35 @@ size_t transmit_to_plugin (void *cls, size_t msize; if (buf == NULL) - { - /* client disconnected */ + { + /* client disconnected */ #if DEBUG_DV_MESSAGES - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "%s: %s buffer was NULL (client disconnect?)\n", my_short_id, "transmit_to_plugin"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "%s: %s buffer was NULL (client disconnect?)\n", my_short_id, + "transmit_to_plugin"); #endif - return 0; - } + return 0; + } plugin_transmit_handle = NULL; off = 0; - while ( (NULL != (reply = plugin_pending_head)) && - (size >= off + (msize = ntohs (reply->msg->size)))) - { - GNUNET_CONTAINER_DLL_remove (plugin_pending_head, - plugin_pending_tail, - reply); - memcpy (&cbuf[off], reply->msg, msize); - GNUNET_free (reply); - off += msize; - } + while ((NULL != (reply = plugin_pending_head)) && + (size >= off + (msize = ntohs (reply->msg->size)))) + { + GNUNET_CONTAINER_DLL_remove (plugin_pending_head, + plugin_pending_tail, reply); + memcpy (&cbuf[off], reply->msg, msize); + GNUNET_free (reply); + off += msize; + } if (plugin_pending_head != NULL) plugin_transmit_handle = GNUNET_SERVER_notify_transmit_ready (client_handle, - ntohs(plugin_pending_head->msg->size), + ntohs + (plugin_pending_head->msg-> + size), GNUNET_TIME_UNIT_FOREVER_REL, - &transmit_to_plugin, NULL); + &transmit_to_plugin, + NULL); return off; } @@ -778,11 +781,11 @@ size_t transmit_to_plugin (void *cls, * @param distant_neighbor the original sender of the message * @param cost the cost to the original sender of the message */ -void send_to_plugin(const struct GNUNET_PeerIdentity * sender, - const struct GNUNET_MessageHeader *message, - size_t message_size, - struct GNUNET_PeerIdentity *distant_neighbor, - size_t cost) +void +send_to_plugin (const struct GNUNET_PeerIdentity *sender, + const struct GNUNET_MessageHeader *message, + size_t message_size, + struct GNUNET_PeerIdentity *distant_neighbor, size_t cost) { struct GNUNET_DV_MessageReceived *received_msg; struct PendingMessage *pending_message; @@ -792,85 +795,96 @@ void send_to_plugin(const struct GNUNET_PeerIdentity * sender, int size; #if DEBUG_DV - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "send_to_plugin called with peer %s as sender\n", GNUNET_i2s(distant_neighbor)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "send_to_plugin called with peer %s as sender\n", + GNUNET_i2s (distant_neighbor)); #endif - if (memcmp(sender, distant_neighbor, sizeof(struct GNUNET_PeerIdentity)) != 0) + if (memcmp (sender, distant_neighbor, sizeof (struct GNUNET_PeerIdentity)) != + 0) { - sender_address_len = sizeof(struct GNUNET_PeerIdentity) * 2; - sender_address = GNUNET_malloc(sender_address_len); - memcpy(sender_address, distant_neighbor, sizeof(struct GNUNET_PeerIdentity)); - memcpy(&sender_address[sizeof(struct GNUNET_PeerIdentity)], sender, sizeof(struct GNUNET_PeerIdentity)); + sender_address_len = sizeof (struct GNUNET_PeerIdentity) * 2; + sender_address = GNUNET_malloc (sender_address_len); + memcpy (sender_address, distant_neighbor, + sizeof (struct GNUNET_PeerIdentity)); + memcpy (&sender_address[sizeof (struct GNUNET_PeerIdentity)], sender, + sizeof (struct GNUNET_PeerIdentity)); } else { - sender_address_len = sizeof(struct GNUNET_PeerIdentity); - sender_address = GNUNET_malloc(sender_address_len); - memcpy(sender_address, sender, sizeof(struct GNUNET_PeerIdentity)); + sender_address_len = sizeof (struct GNUNET_PeerIdentity); + sender_address = GNUNET_malloc (sender_address_len); + memcpy (sender_address, sender, sizeof (struct GNUNET_PeerIdentity)); } - size = sizeof(struct GNUNET_DV_MessageReceived) + sender_address_len + message_size; - received_msg = GNUNET_malloc(size); - received_msg->header.size = htons(size); - received_msg->header.type = htons(GNUNET_MESSAGE_TYPE_TRANSPORT_DV_RECEIVE); - received_msg->distance = htonl(cost); - received_msg->msg_len = htonl(message_size); + size = + sizeof (struct GNUNET_DV_MessageReceived) + sender_address_len + + message_size; + received_msg = GNUNET_malloc (size); + received_msg->header.size = htons (size); + received_msg->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DV_RECEIVE); + received_msg->distance = htonl (cost); + received_msg->msg_len = htonl (message_size); /* Set the sender in this message to be the original sender! */ - memcpy(&received_msg->sender, distant_neighbor, sizeof(struct GNUNET_PeerIdentity)); + memcpy (&received_msg->sender, distant_neighbor, + sizeof (struct GNUNET_PeerIdentity)); /* Copy the intermediate sender to the end of the message, this is how the transport identifies this peer */ - memcpy(&received_msg[1], sender_address, sender_address_len); - GNUNET_free(sender_address); + memcpy (&received_msg[1], sender_address, sender_address_len); + GNUNET_free (sender_address); /* Copy the actual message after the sender */ - packed_msg_start = (char *)&received_msg[1]; + packed_msg_start = (char *) &received_msg[1]; packed_msg_start = &packed_msg_start[sender_address_len]; - memcpy(packed_msg_start, message, message_size); - pending_message = GNUNET_malloc(sizeof(struct PendingMessage) + size); - pending_message->msg = (struct GNUNET_MessageHeader *)&pending_message[1]; - memcpy(&pending_message[1], received_msg, size); - GNUNET_free(received_msg); + memcpy (packed_msg_start, message, message_size); + pending_message = GNUNET_malloc (sizeof (struct PendingMessage) + size); + pending_message->msg = (struct GNUNET_MessageHeader *) &pending_message[1]; + memcpy (&pending_message[1], received_msg, size); + GNUNET_free (received_msg); - GNUNET_CONTAINER_DLL_insert_after(plugin_pending_head, plugin_pending_tail, plugin_pending_tail, pending_message); + GNUNET_CONTAINER_DLL_insert_after (plugin_pending_head, plugin_pending_tail, + plugin_pending_tail, pending_message); if (client_handle != NULL) + { + if (plugin_transmit_handle == NULL) { - if (plugin_transmit_handle == NULL) - { - plugin_transmit_handle = GNUNET_SERVER_notify_transmit_ready (client_handle, - size, GNUNET_TIME_UNIT_FOREVER_REL, - &transmit_to_plugin, NULL); - } + plugin_transmit_handle = + GNUNET_SERVER_notify_transmit_ready (client_handle, size, + GNUNET_TIME_UNIT_FOREVER_REL, + &transmit_to_plugin, NULL); } + } else - { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed to queue message for plugin, client_handle not yet set (how?)!\n"); - } + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Failed to queue message for plugin, client_handle not yet set (how?)!\n"); + } } /* Declare here so retry_core_send is aware of it */ -size_t core_transmit_notify (void *cls, - size_t size, void *buf); +size_t core_transmit_notify (void *cls, size_t size, void *buf); /** * Try to send another message from our core sending list */ static void -try_core_send (void *cls, - const struct GNUNET_SCHEDULER_TaskContext *tc) +try_core_send (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { struct PendingMessage *pending; + pending = core_pending_head; if (core_transmit_handle != NULL) - return; /* Message send already in progress */ + return; /* Message send already in progress */ if ((pending != NULL) && (coreAPI != NULL)) core_transmit_handle = GNUNET_CORE_notify_transmit_ready (coreAPI, - GNUNET_YES, - pending->importance, - pending->timeout, - &pending->recipient, - pending->msg_size, - &core_transmit_notify, NULL); + GNUNET_YES, + pending->importance, + pending->timeout, + &pending->recipient, + pending->msg_size, + &core_transmit_notify, + NULL); } @@ -885,8 +899,8 @@ try_core_send (void *cls, * @param buf where the callee should write the message * @return number of bytes written to buf */ -size_t core_transmit_notify (void *cls, - size_t size, void *buf) +size_t +core_transmit_notify (void *cls, size_t size, void *buf) { char *cbuf = buf; struct PendingMessage *pending; @@ -895,58 +909,65 @@ size_t core_transmit_notify (void *cls, size_t msize; if (buf == NULL) - { - /* client disconnected */ + { + /* client disconnected */ #if DEBUG_DV - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "`%s': buffer was NULL\n", "DHT"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "`%s': buffer was NULL\n", "DHT"); #endif - return 0; - } + return 0; + } core_transmit_handle = NULL; off = 0; pending = core_pending_head; - if ( (pending != NULL) && - (size >= (msize = ntohs (pending->msg->size)))) - { + if ((pending != NULL) && (size >= (msize = ntohs (pending->msg->size)))) + { #if DEBUG_DV - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "`%s' : transmit_notify (core) called with size %d\n", "dv service", msize); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "`%s' : transmit_notify (core) called with size %d\n", + "dv service", msize); #endif - GNUNET_CONTAINER_DLL_remove (core_pending_head, - core_pending_tail, - pending); - if (pending->send_result != NULL) /* Will only be non-null if a real client asked for this send */ + GNUNET_CONTAINER_DLL_remove (core_pending_head, core_pending_tail, pending); + if (pending->send_result != NULL) /* Will only be non-null if a real client asked for this send */ + { + client_reply = + GNUNET_malloc (sizeof (struct PendingMessage) + + sizeof (struct GNUNET_DV_SendResultMessage)); + client_reply->msg = (struct GNUNET_MessageHeader *) &client_reply[1]; + memcpy (&client_reply[1], pending->send_result, + sizeof (struct GNUNET_DV_SendResultMessage)); + GNUNET_free (pending->send_result); + + GNUNET_CONTAINER_DLL_insert_after (plugin_pending_head, + plugin_pending_tail, + plugin_pending_tail, client_reply); + if (client_handle != NULL) + { + if (plugin_transmit_handle == NULL) + { + plugin_transmit_handle = + GNUNET_SERVER_notify_transmit_ready (client_handle, + sizeof (struct + GNUNET_DV_SendResultMessage), + GNUNET_TIME_UNIT_FOREVER_REL, + &transmit_to_plugin, NULL); + } + else { - client_reply = GNUNET_malloc(sizeof(struct PendingMessage) + sizeof(struct GNUNET_DV_SendResultMessage)); - client_reply->msg = (struct GNUNET_MessageHeader *)&client_reply[1]; - memcpy(&client_reply[1], pending->send_result, sizeof(struct GNUNET_DV_SendResultMessage)); - GNUNET_free(pending->send_result); - - GNUNET_CONTAINER_DLL_insert_after(plugin_pending_head, plugin_pending_tail, plugin_pending_tail, client_reply); - if (client_handle != NULL) - { - if (plugin_transmit_handle == NULL) - { - plugin_transmit_handle = GNUNET_SERVER_notify_transmit_ready (client_handle, - sizeof(struct GNUNET_DV_SendResultMessage), - GNUNET_TIME_UNIT_FOREVER_REL, - &transmit_to_plugin, NULL); - } - else - { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed to queue message for plugin, must be one in progress already!!\n"); - } - } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Failed to queue message for plugin, must be one in progress already!!\n"); } - memcpy (&cbuf[off], pending->msg, msize); - GNUNET_free (pending); - off += msize; + } } - /*reply = core_pending_head;*/ + memcpy (&cbuf[off], pending->msg, msize); + GNUNET_free (pending); + off += msize; + } + /*reply = core_pending_head; */ - GNUNET_SCHEDULER_add_now(&try_core_send, NULL); + GNUNET_SCHEDULER_add_now (&try_core_send, NULL); /*if (reply != NULL) - core_transmit_handle = GNUNET_CORE_notify_transmit_ready(coreAPI, GNUNET_YES, reply->importance, reply->timeout, &reply->recipient, reply->msg_size, &core_transmit_notify, NULL);*/ + * core_transmit_handle = GNUNET_CORE_notify_transmit_ready(coreAPI, GNUNET_YES, reply->importance, reply->timeout, &reply->recipient, reply->msg_size, &core_transmit_notify, NULL); */ return off; } @@ -971,6 +992,7 @@ send_message_via (const struct GNUNET_PeerIdentity *sender, struct DistantNeighbor *source; struct PendingMessage *pending_message; struct FindIDContext find_context; + #if DEBUG_DV char shortname[5]; #endif @@ -980,70 +1002,76 @@ send_message_via (const struct GNUNET_PeerIdentity *sender, find_context.dest = send_context->distant_peer; find_context.via = recipient; find_context.tid = 0; - GNUNET_CONTAINER_multihashmap_get_multiple (extended_neighbors, &send_context->distant_peer->hashPubKey, + GNUNET_CONTAINER_multihashmap_get_multiple (extended_neighbors, + &send_context-> + distant_peer->hashPubKey, &find_specific_id, &find_context); if (find_context.tid == 0) - { - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "%s: find_specific_id failed to find peer!\n", my_short_id); - /* target unknown to us, drop! */ - return GNUNET_SYSERR; - } + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "%s: find_specific_id failed to find peer!\n", my_short_id); + /* target unknown to us, drop! */ + return GNUNET_SYSERR; + } recipient_id = find_context.tid; - if (0 == (memcmp (&my_identity, - sender, sizeof (struct GNUNET_PeerIdentity)))) + if (0 == (memcmp (&my_identity, sender, sizeof (struct GNUNET_PeerIdentity)))) { sender_id = 0; source = GNUNET_CONTAINER_multihashmap_get (extended_neighbors, - &sender->hashPubKey); + &sender->hashPubKey); if (source != NULL) - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "%s: send_message_via found %s, myself in extended peer list???\n", my_short_id, GNUNET_i2s(&source->identity)); + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "%s: send_message_via found %s, myself in extended peer list???\n", + my_short_id, GNUNET_i2s (&source->identity)); } else { source = GNUNET_CONTAINER_multihashmap_get (extended_neighbors, &sender->hashPubKey); if (source == NULL) - { - /* sender unknown to us, drop! */ - return GNUNET_SYSERR; - } + { + /* sender unknown to us, drop! */ + return GNUNET_SYSERR; + } sender_id = source->our_id; } - pending_message = GNUNET_malloc(sizeof(struct PendingMessage) + msg_size); - pending_message->msg = (struct GNUNET_MessageHeader *)&pending_message[1]; + pending_message = GNUNET_malloc (sizeof (struct PendingMessage) + msg_size); + pending_message->msg = (struct GNUNET_MessageHeader *) &pending_message[1]; pending_message->send_result = send_context->send_result; - memcpy(&pending_message->recipient, recipient, sizeof(struct GNUNET_PeerIdentity)); + memcpy (&pending_message->recipient, recipient, + sizeof (struct GNUNET_PeerIdentity)); pending_message->msg_size = msg_size; pending_message->importance = send_context->importance; pending_message->timeout = send_context->timeout; - toSend = (p2p_dv_MESSAGE_Data *)pending_message->msg; + toSend = (p2p_dv_MESSAGE_Data *) pending_message->msg; toSend->header.size = htons (msg_size); toSend->header.type = htons (GNUNET_MESSAGE_TYPE_DV_DATA); toSend->sender = htonl (sender_id); toSend->recipient = htonl (recipient_id); #if DEBUG_DV_MESSAGES - toSend->uid = send_context->uid; /* Still sent around in network byte order */ + toSend->uid = send_context->uid; /* Still sent around in network byte order */ #else - toSend->uid = htonl(0); + toSend->uid = htonl (0); #endif memcpy (&toSend[1], send_context->message, send_context->message_size); #if DEBUG_DV - memcpy(&shortname, GNUNET_i2s(send_context->distant_peer), 4); + memcpy (&shortname, GNUNET_i2s (send_context->distant_peer), 4); shortname[4] = '\0'; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s: Notifying core of send to destination `%s' via `%s' size %u\n", "DV", &shortname, GNUNET_i2s(recipient), msg_size); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "%s: Notifying core of send to destination `%s' via `%s' size %u\n", + "DV", &shortname, GNUNET_i2s (recipient), msg_size); #endif GNUNET_CONTAINER_DLL_insert_after (core_pending_head, core_pending_tail, - core_pending_tail, - pending_message); + core_pending_tail, pending_message); - GNUNET_SCHEDULER_add_now(try_core_send, NULL); + GNUNET_SCHEDULER_add_now (try_core_send, NULL); return GNUNET_YES; } @@ -1059,17 +1087,15 @@ send_message_via (const struct GNUNET_PeerIdentity *sender, * @return GNUNET_YES to continue iteration, GNUNET_NO to stop */ static int -find_least_cost_peer (void *cls, - const GNUNET_HashCode *key, - void *value) +find_least_cost_peer (void *cls, const GNUNET_HashCode * key, void *value) { struct FindLeastCostContext *find_context = cls; struct DistantNeighbor *dn = value; if (dn->cost < find_context->least_cost) - { - find_context->target = dn; - } + { + find_context->target = dn; + } if (dn->cost == DIRECT_NEIGHBOR_COST) return GNUNET_NO; return GNUNET_YES; @@ -1088,14 +1114,13 @@ find_least_cost_peer (void *cls, * @param timeout how long to possibly delay sending this message */ static int -send_message (const struct GNUNET_PeerIdentity * recipient, - const struct GNUNET_PeerIdentity * sender, - const struct DistantNeighbor * specific_neighbor, - const struct GNUNET_MessageHeader * message, +send_message (const struct GNUNET_PeerIdentity *recipient, + const struct GNUNET_PeerIdentity *sender, + const struct DistantNeighbor *specific_neighbor, + const struct GNUNET_MessageHeader *message, size_t message_size, unsigned int importance, - unsigned int uid, - struct GNUNET_TIME_Relative timeout) + unsigned int uid, struct GNUNET_TIME_Relative timeout) { p2p_dv_MESSAGE_Data *toSend; unsigned int msg_size; @@ -1106,6 +1131,7 @@ send_message (const struct GNUNET_PeerIdentity * recipient, struct DistantNeighbor *source; struct PendingMessage *pending_message; struct FindLeastCostContext find_least_ctx; + #if DEBUG_DV_PEER_NUMBERS struct GNUNET_CRYPTO_HashAsciiEncoded encPeerFrom; struct GNUNET_CRYPTO_HashAsciiEncoded encPeerTo; @@ -1122,84 +1148,97 @@ send_message (const struct GNUNET_PeerIdentity * recipient, * over all known peers, just those that apply. */ GNUNET_CONTAINER_multihashmap_get_multiple (extended_neighbors, - &recipient->hashPubKey, &find_least_cost_peer, &find_least_ctx); + &recipient->hashPubKey, + &find_least_cost_peer, + &find_least_ctx); target = find_least_ctx.target; if (target == NULL) - { - /* target unknown to us, drop! */ - return GNUNET_SYSERR; - } + { + /* target unknown to us, drop! */ + return GNUNET_SYSERR; + } recipient_id = target->referrer_id; source = GNUNET_CONTAINER_multihashmap_get (extended_neighbors, &sender->hashPubKey); if (source == NULL) + { + if (0 != (memcmp (&my_identity, + sender, sizeof (struct GNUNET_PeerIdentity)))) { - if (0 != (memcmp (&my_identity, - sender, sizeof (struct GNUNET_PeerIdentity)))) - { - /* sender unknown to us, drop! */ - return GNUNET_SYSERR; - } - sender_id = 0; /* 0 == us */ + /* sender unknown to us, drop! */ + return GNUNET_SYSERR; } + sender_id = 0; /* 0 == us */ + } else - { - /* find out the number that we use when we gossip about - the sender */ - sender_id = source->our_id; - } + { + /* find out the number that we use when we gossip about + * the sender */ + sender_id = source->our_id; + } #if DEBUG_DV_PEER_NUMBERS GNUNET_CRYPTO_hash_to_enc (&source->identity.hashPubKey, &encPeerFrom); - GNUNET_CRYPTO_hash_to_enc (&target->referrer->identity.hashPubKey, &encPeerVia); + GNUNET_CRYPTO_hash_to_enc (&target->referrer->identity.hashPubKey, + &encPeerVia); encPeerFrom.encoding[4] = '\0'; encPeerVia.encoding[4] = '\0'; #endif - if ((sender_id != 0) && (0 == memcmp(&source->identity, &target->referrer->identity, sizeof(struct GNUNET_PeerIdentity)))) - { - return 0; - } + if ((sender_id != 0) && + (0 == + memcmp (&source->identity, &target->referrer->identity, + sizeof (struct GNUNET_PeerIdentity)))) + { + return 0; + } cost = target->cost; - pending_message = GNUNET_malloc(sizeof(struct PendingMessage) + msg_size); - pending_message->msg = (struct GNUNET_MessageHeader *)&pending_message[1]; + pending_message = GNUNET_malloc (sizeof (struct PendingMessage) + msg_size); + pending_message->msg = (struct GNUNET_MessageHeader *) &pending_message[1]; pending_message->send_result = NULL; pending_message->importance = importance; pending_message->timeout = timeout; - memcpy(&pending_message->recipient, &target->referrer->identity, sizeof(struct GNUNET_PeerIdentity)); + memcpy (&pending_message->recipient, &target->referrer->identity, + sizeof (struct GNUNET_PeerIdentity)); pending_message->msg_size = msg_size; - toSend = (p2p_dv_MESSAGE_Data *)pending_message->msg; + toSend = (p2p_dv_MESSAGE_Data *) pending_message->msg; toSend->header.size = htons (msg_size); toSend->header.type = htons (GNUNET_MESSAGE_TYPE_DV_DATA); toSend->sender = htonl (sender_id); toSend->recipient = htonl (recipient_id); #if DEBUG_DV_MESSAGES - toSend->uid = htonl(uid); + toSend->uid = htonl (uid); #else - toSend->uid = htonl(0); + toSend->uid = htonl (0); #endif #if DEBUG_DV_PEER_NUMBERS GNUNET_CRYPTO_hash_to_enc (&target->identity.hashPubKey, &encPeerTo); encPeerTo.encoding[4] = '\0'; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s: Sending DATA message. Sender id %u, source %s, destination %s, via %s\n", GNUNET_i2s(&my_identity), sender_id, &encPeerFrom, &encPeerTo, &encPeerVia); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "%s: Sending DATA message. Sender id %u, source %s, destination %s, via %s\n", + GNUNET_i2s (&my_identity), sender_id, &encPeerFrom, &encPeerTo, + &encPeerVia); #endif memcpy (&toSend[1], message, message_size); - if ((source != NULL) && (source->pkey == NULL)) /* Test our hypothesis about message failures! */ - { - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "%s: Sending message, but anticipate recipient will not know sender!!!\n\n\n", my_short_id); - } + if ((source != NULL) && (source->pkey == NULL)) /* Test our hypothesis about message failures! */ + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "%s: Sending message, but anticipate recipient will not know sender!!!\n\n\n", + my_short_id); + } GNUNET_CONTAINER_DLL_insert_after (core_pending_head, core_pending_tail, - core_pending_tail, - pending_message); + core_pending_tail, pending_message); #if DEBUG_DV - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s: Notifying core of send size %d to destination `%s'\n", "DV SEND MESSAGE", msg_size, GNUNET_i2s(recipient)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "%s: Notifying core of send size %d to destination `%s'\n", + "DV SEND MESSAGE", msg_size, GNUNET_i2s (recipient)); #endif - GNUNET_SCHEDULER_add_now(try_core_send, NULL); + GNUNET_SCHEDULER_add_now (try_core_send, NULL); return (int) cost; } @@ -1227,14 +1266,13 @@ struct CheckPeerContext * iterate, * GNUNET_NO if not. */ -int checkPeerID (void *cls, - const GNUNET_HashCode * key, - void *value) +int +checkPeerID (void *cls, const GNUNET_HashCode * key, void *value) { struct CheckPeerContext *ctx = cls; struct DistantNeighbor *distant = value; - if (memcmp(key, &ctx->sender_id, sizeof(unsigned int)) == 0) + if (memcmp (key, &ctx->sender_id, sizeof (unsigned int)) == 0) { ctx->peer = distant; return GNUNET_NO; @@ -1253,22 +1291,30 @@ int checkPeerID (void *cls, * @param client the TokenizedMessageContext which contains message information * @param message the actual message */ -void tokenized_message_handler (void *cls, - void *client, - const struct GNUNET_MessageHeader *message) +void +tokenized_message_handler (void *cls, + void *client, + const struct GNUNET_MessageHeader *message) { struct TokenizedMessageContext *ctx = client; + GNUNET_break_op (ntohs (message->type) != GNUNET_MESSAGE_TYPE_DV_GOSSIP); GNUNET_break_op (ntohs (message->type) != GNUNET_MESSAGE_TYPE_DV_DATA); - if ( (ntohs (message->type) != GNUNET_MESSAGE_TYPE_DV_GOSSIP) && - (ntohs (message->type) != GNUNET_MESSAGE_TYPE_DV_DATA) ) + if ((ntohs (message->type) != GNUNET_MESSAGE_TYPE_DV_GOSSIP) && + (ntohs (message->type) != GNUNET_MESSAGE_TYPE_DV_DATA)) { #if DEBUG_DV_MESSAGES GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "%s: Receives %s message for me, uid %u, size %d, type %d cost %u from %s!\n", my_short_id, "DV DATA", ctx->uid, ntohs(message->size), ntohs(message->type), ctx->distant->cost, GNUNET_i2s(&ctx->distant->identity)); -#endif - GNUNET_assert(memcmp(ctx->peer, &ctx->distant->identity, sizeof(struct GNUNET_PeerIdentity)) != 0); - send_to_plugin(ctx->peer, message, ntohs(message->size), &ctx->distant->identity, ctx->distant->cost); + "%s: Receives %s message for me, uid %u, size %d, type %d cost %u from %s!\n", + my_short_id, "DV DATA", ctx->uid, ntohs (message->size), + ntohs (message->type), ctx->distant->cost, + GNUNET_i2s (&ctx->distant->identity)); +#endif + GNUNET_assert (memcmp + (ctx->peer, &ctx->distant->identity, + sizeof (struct GNUNET_PeerIdentity)) != 0); + send_to_plugin (ctx->peer, message, ntohs (message->size), + &ctx->distant->identity, ctx->distant->cost); } } @@ -1282,23 +1328,23 @@ struct DelayedMessageContext uint32_t uid; }; -void send_message_delayed (void *cls, - const struct GNUNET_SCHEDULER_TaskContext *tc) +void +send_message_delayed (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { struct DelayedMessageContext *msg_ctx = cls; + if (msg_ctx != NULL) - { - send_message(&msg_ctx->dest, - &msg_ctx->sender, - NULL, - msg_ctx->message, - msg_ctx->message_size, - default_dv_priority, - msg_ctx->uid, - GNUNET_TIME_relative_get_forever()); - GNUNET_free(msg_ctx->message); - GNUNET_free(msg_ctx); - } + { + send_message (&msg_ctx->dest, + &msg_ctx->sender, + NULL, + msg_ctx->message, + msg_ctx->message_size, + default_dv_priority, + msg_ctx->uid, GNUNET_TIME_relative_get_forever ()); + GNUNET_free (msg_ctx->message); + GNUNET_free (msg_ctx); + } } #endif @@ -1311,15 +1357,15 @@ void send_message_delayed (void *cls, static uint32_t get_atsi_distance (const struct GNUNET_TRANSPORT_ATS_Information *atsi) { - while ( (ntohl (atsi->type) != GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR) && - (ntohl (atsi->type) != GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE) ) + while ((ntohl (atsi->type) != GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR) && + (ntohl (atsi->type) != GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE)) atsi++; if (ntohl (atsi->type) == GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR) - { - GNUNET_break (0); - /* FIXME: we do not have distance data? Assume direct neighbor. */ - return DIRECT_NEIGHBOR_COST; - } + { + GNUNET_break (0); + /* FIXME: we do not have distance data? Assume direct neighbor. */ + return DIRECT_NEIGHBOR_COST; + } return ntohl (atsi->value); } @@ -1332,17 +1378,18 @@ get_atsi_distance (const struct GNUNET_TRANSPORT_ATS_Information *atsi) static struct GNUNET_TIME_Relative get_atsi_latency (const struct GNUNET_TRANSPORT_ATS_Information *atsi) { - while ( (ntohl (atsi->type) != GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR) && - (ntohl (atsi->type) != GNUNET_TRANSPORT_ATS_QUALITY_NET_DELAY) ) + while ((ntohl (atsi->type) != GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR) && + (ntohl (atsi->type) != GNUNET_TRANSPORT_ATS_QUALITY_NET_DELAY)) atsi++; if (ntohl (atsi->type) == GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR) - { - GNUNET_break (0); - /* how can we not have latency data? */ - return GNUNET_TIME_UNIT_SECONDS; - } + { + GNUNET_break (0); + /* how can we not have latency data? */ + return GNUNET_TIME_UNIT_SECONDS; + } /* FIXME: Multiply by GNUNET_TIME_UNIT_MILLISECONDS (1) to get as a GNUNET_TIME_Relative */ - return GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, ntohl (atsi->value)); + return GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, + ntohl (atsi->value)); } /** @@ -1356,11 +1403,11 @@ get_atsi_latency (const struct GNUNET_TRANSPORT_ATS_Information *atsi) * @param message the message * @param atsi transport ATS information (latency, distance, etc.) */ -static int +static int handle_dv_data_message (void *cls, - const struct GNUNET_PeerIdentity * peer, - const struct GNUNET_MessageHeader * message, - const struct GNUNET_TRANSPORT_ATS_Information *atsi) + const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_MessageHeader *message, + const struct GNUNET_TRANSPORT_ATS_Information *atsi) { const p2p_dv_MESSAGE_Data *incoming = (const p2p_dv_MESSAGE_Data *) message; const struct GNUNET_MessageHeader *packed_message; @@ -1374,6 +1421,7 @@ handle_dv_data_message (void *cls, struct TokenizedMessageContext tkm_ctx; int i; int found_pos; + #if DELAY_FORWARDS struct DelayedMessageContext *delayed_context; #endif @@ -1386,29 +1434,35 @@ handle_dv_data_message (void *cls, int ret; size_t packed_message_size; char *cbuf; - uint32_t distance; /* Distance information */ - struct GNUNET_TIME_Relative latency; /* Latency information */ + uint32_t distance; /* Distance information */ + struct GNUNET_TIME_Relative latency; /* Latency information */ - packed_message_size = ntohs(incoming->header.size) - sizeof(p2p_dv_MESSAGE_Data); + packed_message_size = + ntohs (incoming->header.size) - sizeof (p2p_dv_MESSAGE_Data); #if DEBUG_DV GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "%s: Receives DATA message from %s size %d, packed size %d!\n", my_short_id, GNUNET_i2s(peer) , ntohs(incoming->header.size), packed_message_size); + "%s: Receives DATA message from %s size %d, packed size %d!\n", + my_short_id, GNUNET_i2s (peer), ntohs (incoming->header.size), + packed_message_size); #endif - if (ntohs (incoming->header.size) < sizeof (p2p_dv_MESSAGE_Data) + sizeof (struct GNUNET_MessageHeader)) - { + if (ntohs (incoming->header.size) < + sizeof (p2p_dv_MESSAGE_Data) + sizeof (struct GNUNET_MessageHeader)) + { #if DEBUG_DV GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "`%s': Message sizes don't add up, total size %u, expected at least %u!\n", "dv service", ntohs(incoming->header.size), sizeof (p2p_dv_MESSAGE_Data) + sizeof (struct GNUNET_MessageHeader)); + "`%s': Message sizes don't add up, total size %u, expected at least %u!\n", + "dv service", ntohs (incoming->header.size), + sizeof (p2p_dv_MESSAGE_Data) + + sizeof (struct GNUNET_MessageHeader)); #endif - return GNUNET_SYSERR; - } + return GNUNET_SYSERR; + } /* Iterate over ATS_Information to get distance and latency */ - latency = get_atsi_latency(atsi); - distance = get_atsi_distance(atsi); - dn = GNUNET_CONTAINER_multihashmap_get (direct_neighbors, - &peer->hashPubKey); + latency = get_atsi_latency (atsi); + distance = get_atsi_distance (atsi); + dn = GNUNET_CONTAINER_multihashmap_get (direct_neighbors, &peer->hashPubKey); if (dn == NULL) return GNUNET_OK; @@ -1418,7 +1472,8 @@ handle_dv_data_message (void *cls, { checkPeerCtx.sender_id = sid; checkPeerCtx.peer = NULL; - GNUNET_CONTAINER_multihashmap_iterate(extended_neighbors, &checkPeerID, &checkPeerCtx); + GNUNET_CONTAINER_multihashmap_iterate (extended_neighbors, &checkPeerID, + &checkPeerCtx); pos = checkPeerCtx.peer; } else @@ -1433,154 +1488,177 @@ handle_dv_data_message (void *cls, #endif if (pos == NULL) - { + { #if DEBUG_DV_MESSAGES - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "%s: unknown sender (%u), Message uid %u from %s!\n", my_short_id, ntohl(incoming->sender), ntohl(incoming->uid), GNUNET_i2s(&dn->identity)); - pos = dn->referee_head; - while ((NULL != pos) && (pos->referrer_id != sid)) - { - sender_id = strdup(GNUNET_i2s(&pos->identity)); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "I know sender %u %s\n", pos->referrer_id, sender_id); - GNUNET_free(sender_id); - pos = pos->next; - } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "%s: unknown sender (%u), Message uid %u from %s!\n", + my_short_id, ntohl (incoming->sender), ntohl (incoming->uid), + GNUNET_i2s (&dn->identity)); + pos = dn->referee_head; + while ((NULL != pos) && (pos->referrer_id != sid)) + { + sender_id = strdup (GNUNET_i2s (&pos->identity)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "I know sender %u %s\n", + pos->referrer_id, sender_id); + GNUNET_free (sender_id); + pos = pos->next; + } #endif - found_pos = -1; - for (i = 0; i< MAX_OUTSTANDING_MESSAGES; i++) - { - if (dn->pending_messages[i].sender_id == 0) - { - found_pos = i; - break; - } - } + found_pos = -1; + for (i = 0; i < MAX_OUTSTANDING_MESSAGES; i++) + { + if (dn->pending_messages[i].sender_id == 0) + { + found_pos = i; + break; + } + } - if (found_pos == -1) - { - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, - "%s: Too many unknown senders (%u), ignoring message! Message uid %llu from %s!\n", my_short_id, ntohl(incoming->sender), ntohl(incoming->uid), GNUNET_i2s(&dn->identity)); - } - else - { - dn->pending_messages[found_pos].message = GNUNET_malloc(ntohs (message->size)); - memcpy(dn->pending_messages[found_pos].message, message, ntohs(message->size)); - dn->pending_messages[found_pos].distance = distance; - dn->pending_messages[found_pos].latency = latency; - memcpy(&dn->pending_messages[found_pos].sender, peer, sizeof(struct GNUNET_PeerIdentity)); - dn->pending_messages[found_pos].sender_id = sid; - } - /* unknown sender */ - return GNUNET_OK; + if (found_pos == -1) + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "%s: Too many unknown senders (%u), ignoring message! Message uid %llu from %s!\n", + my_short_id, ntohl (incoming->sender), ntohl (incoming->uid), + GNUNET_i2s (&dn->identity)); } + else + { + dn->pending_messages[found_pos].message = + GNUNET_malloc (ntohs (message->size)); + memcpy (dn->pending_messages[found_pos].message, message, + ntohs (message->size)); + dn->pending_messages[found_pos].distance = distance; + dn->pending_messages[found_pos].latency = latency; + memcpy (&dn->pending_messages[found_pos].sender, peer, + sizeof (struct GNUNET_PeerIdentity)); + dn->pending_messages[found_pos].sender_id = sid; + } + /* unknown sender */ + return GNUNET_OK; + } original_sender = &pos->identity; tid = ntohl (incoming->recipient); if (tid == 0) + { + /* 0 == us */ + cbuf = (char *) &incoming[1]; + + tkm_ctx.peer = peer; + tkm_ctx.distant = pos; + tkm_ctx.uid = ntohl (incoming->uid); + if (GNUNET_OK != GNUNET_SERVER_mst_receive (coreMST, + &tkm_ctx, + cbuf, + packed_message_size, + GNUNET_NO, GNUNET_NO)) { - /* 0 == us */ - cbuf = (char *)&incoming[1]; - - tkm_ctx.peer = peer; - tkm_ctx.distant = pos; - tkm_ctx.uid = ntohl(incoming->uid); - if (GNUNET_OK != GNUNET_SERVER_mst_receive (coreMST, - &tkm_ctx, - cbuf, - packed_message_size, - GNUNET_NO, - GNUNET_NO)) - { - GNUNET_break_op(0); - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "%s: %s Received corrupt data, discarding!", my_short_id, "DV SERVICE"); - } - return GNUNET_OK; + GNUNET_break_op (0); + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "%s: %s Received corrupt data, discarding!", my_short_id, + "DV SERVICE"); } + return GNUNET_OK; + } else - { - packed_message = (struct GNUNET_MessageHeader *)&incoming[1]; - } + { + packed_message = (struct GNUNET_MessageHeader *) &incoming[1]; + } /* FIXME: this is the *only* per-request operation we have in DV - that is O(n) in relation to the number of connected peers; a - hash-table lookup could easily solve this (minor performance - issue) */ + * that is O(n) in relation to the number of connected peers; a + * hash-table lookup could easily solve this (minor performance + * issue) */ fdc.tid = tid; fdc.dest = NULL; - GNUNET_CONTAINER_heap_iterate (neighbor_max_heap, - &find_destination, &fdc); + GNUNET_CONTAINER_heap_iterate (neighbor_max_heap, &find_destination, &fdc); #if DEBUG_DV - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "%s: Receives %s message for someone else!\n", "dv", "DV DATA"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "%s: Receives %s message for someone else!\n", "dv", "DV DATA"); #endif if (fdc.dest == NULL) - { + { #if DEBUG_DV_MESSAGES - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "%s: Receives %s message uid %u for someone we don't know (id %u)!\n", my_short_id, "DV DATA", ntohl(incoming->uid), tid); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "%s: Receives %s message uid %u for someone we don't know (id %u)!\n", + my_short_id, "DV DATA", ntohl (incoming->uid), tid); #endif - return GNUNET_OK; - } + return GNUNET_OK; + } destination = &fdc.dest->identity; if (0 == memcmp (destination, peer, sizeof (struct GNUNET_PeerIdentity))) - { - /* FIXME: create stat: routing loop-discard! */ + { + /* FIXME: create stat: routing loop-discard! */ #if DEBUG_DV_MESSAGES - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "%s: DROPPING MESSAGE uid %u type %d, routing loop! Message immediately from %s!\n", my_short_id, ntohl(incoming->uid), ntohs(packed_message->type), GNUNET_i2s(&dn->identity)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "%s: DROPPING MESSAGE uid %u type %d, routing loop! Message immediately from %s!\n", + my_short_id, ntohl (incoming->uid), + ntohs (packed_message->type), GNUNET_i2s (&dn->identity)); #endif - return GNUNET_OK; - } + return GNUNET_OK; + } /* At this point we have a message, and we need to forward it on to the * next DV hop. */ #if DEBUG_DV_MESSAGES GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "%s: FORWARD %s message for %s, uid %u, size %d type %d, cost %u!\n", my_short_id, "DV DATA", GNUNET_i2s(destination), ntohl(incoming->uid), ntohs(packed_message->size), ntohs(packed_message->type), pos->cost); + "%s: FORWARD %s message for %s, uid %u, size %d type %d, cost %u!\n", + my_short_id, "DV DATA", GNUNET_i2s (destination), + ntohl (incoming->uid), ntohs (packed_message->size), + ntohs (packed_message->type), pos->cost); #endif #if DELAY_FORWARDS - if (GNUNET_TIME_absolute_get_duration(pos->last_gossip).abs_value < GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 2).abs_value) - { - delayed_context = GNUNET_malloc(sizeof(struct DelayedMessageContext)); - memcpy(&delayed_context->dest, destination, sizeof(struct GNUNET_PeerIdentity)); - memcpy(&delayed_context->sender, original_sender, sizeof(struct GNUNET_PeerIdentity)); - delayed_context->message = GNUNET_malloc(packed_message_size); - memcpy(delayed_context->message, packed_message, packed_message_size); - delayed_context->message_size = packed_message_size; - delayed_context->uid = ntohl(incoming->uid); - GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 2500), &send_message_delayed, delayed_context); - return GNUNET_OK; - } + if (GNUNET_TIME_absolute_get_duration (pos->last_gossip).abs_value < + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 2).abs_value) + { + delayed_context = GNUNET_malloc (sizeof (struct DelayedMessageContext)); + memcpy (&delayed_context->dest, destination, + sizeof (struct GNUNET_PeerIdentity)); + memcpy (&delayed_context->sender, original_sender, + sizeof (struct GNUNET_PeerIdentity)); + delayed_context->message = GNUNET_malloc (packed_message_size); + memcpy (delayed_context->message, packed_message, packed_message_size); + delayed_context->message_size = packed_message_size; + delayed_context->uid = ntohl (incoming->uid); + GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply + (GNUNET_TIME_UNIT_MILLISECONDS, 2500), + &send_message_delayed, delayed_context); + return GNUNET_OK; + } else #endif - { - ret = send_message(destination, - original_sender, - NULL, - packed_message, - packed_message_size, - default_dv_priority, - ntohl(incoming->uid), - GNUNET_TIME_relative_get_forever()); - } + { + ret = send_message (destination, + original_sender, + NULL, + packed_message, + packed_message_size, + default_dv_priority, + ntohl (incoming->uid), + GNUNET_TIME_relative_get_forever ()); + } if (ret != GNUNET_SYSERR) return GNUNET_OK; else - { + { #if DEBUG_MESSAGE_DROP - char *direct_id = GNUNET_strdup(GNUNET_i2s(&dn->identity)); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "%s: DROPPING MESSAGE type %d, forwarding failed! Message immediately from %s!\n", GNUNET_i2s(&my_identity), ntohs(((struct GNUNET_MessageHeader *)&incoming[1])->type), direct_id); - GNUNET_free (direct_id); + char *direct_id = GNUNET_strdup (GNUNET_i2s (&dn->identity)); + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "%s: DROPPING MESSAGE type %d, forwarding failed! Message immediately from %s!\n", + GNUNET_i2s (&my_identity), + ntohs (((struct GNUNET_MessageHeader *) &incoming[1])->type), + direct_id); + GNUNET_free (direct_id); #endif - return GNUNET_SYSERR; - } + return GNUNET_SYSERR; + } } #if DEBUG_DV @@ -1594,19 +1672,24 @@ handle_dv_data_message (void *cls, * iterate, * GNUNET_NO if not. */ -int print_neighbors (void *cls, - const GNUNET_HashCode * key, - void *abs_value) +int +print_neighbors (void *cls, const GNUNET_HashCode * key, void *abs_value) { struct DistantNeighbor *distant_neighbor = abs_value; char my_shortname[5]; char referrer_shortname[5]; - memcpy(&my_shortname, GNUNET_i2s(&my_identity), 4); + + memcpy (&my_shortname, GNUNET_i2s (&my_identity), 4); my_shortname[4] = '\0'; - memcpy(&referrer_shortname, GNUNET_i2s(&distant_neighbor->referrer->identity), 4); + memcpy (&referrer_shortname, + GNUNET_i2s (&distant_neighbor->referrer->identity), 4); referrer_shortname[4] = '\0'; - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "`%s' %s: Peer `%s', distance %d, referrer `%s' pkey: %s\n", &my_shortname, "DV", GNUNET_i2s(&distant_neighbor->identity), distant_neighbor->cost, &referrer_shortname, distant_neighbor->pkey == NULL ? "no" : "yes"); + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "`%s' %s: Peer `%s', distance %d, referrer `%s' pkey: %s\n", + &my_shortname, "DV", GNUNET_i2s (&distant_neighbor->identity), + distant_neighbor->cost, &referrer_shortname, + distant_neighbor->pkey == NULL ? "no" : "yes"); return GNUNET_YES; } #endif @@ -1616,13 +1699,13 @@ int print_neighbors (void *cls, * peers. Will run until called with reason shutdown. */ static void -neighbor_send_task (void *cls, - const struct GNUNET_SCHEDULER_TaskContext *tc) +neighbor_send_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { struct NeighborSendContext *send_context = cls; + #if DEBUG_DV_GOSSIP_SEND - char * encPeerAbout; - char * encPeerTo; + char *encPeerAbout; + char *encPeerTo; #endif struct DistantNeighbor *about; struct DirectNeighbor *to; @@ -1631,41 +1714,41 @@ neighbor_send_task (void *cls, p2p_dv_MESSAGE_NeighborInfo *message; struct PendingMessage *pending_message; - if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0) - { + if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0) + { #if DEBUG_DV_GOSSIP - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "%s: Called with reason shutdown, shutting down!\n", - GNUNET_i2s(&my_identity)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "%s: Called with reason shutdown, shutting down!\n", + GNUNET_i2s (&my_identity)); #endif - return; - } + return; + } if (send_context->fast_gossip_list_head != NULL) - { - about_list = send_context->fast_gossip_list_head; - about = about_list->about; - GNUNET_CONTAINER_DLL_remove(send_context->fast_gossip_list_head, - send_context->fast_gossip_list_tail, - about_list); - GNUNET_free(about_list); - } + { + about_list = send_context->fast_gossip_list_head; + about = about_list->about; + GNUNET_CONTAINER_DLL_remove (send_context->fast_gossip_list_head, + send_context->fast_gossip_list_tail, + about_list); + GNUNET_free (about_list); + } else - { - /* FIXME: this may become a problem, because the heap walk has only one internal "walker". This means - * that if two neighbor_send_tasks are operating in lockstep (which is quite possible, given default - * values for all connected peers) there may be a serious bias as to which peers get gossiped about! - * Probably the *best* way to fix would be to have an opaque pointer to the walk position passed as - * part of the walk_get_next call. Then the heap would have to keep a list of walks, or reset the walk - * whenever a modification has been detected. Yuck either way. Perhaps we could iterate over the heap - * once to get a list of peers to gossip about and gossip them over time... But then if one goes away - * in the mean time that becomes nasty. For now we'll just assume that the walking is done - * asynchronously enough to avoid major problems (-; - * - * NOTE: probably fixed once we decided send rate based on allowed bandwidth. - */ - about = GNUNET_CONTAINER_heap_walk_get_next (neighbor_min_heap); - } + { + /* FIXME: this may become a problem, because the heap walk has only one internal "walker". This means + * that if two neighbor_send_tasks are operating in lockstep (which is quite possible, given default + * values for all connected peers) there may be a serious bias as to which peers get gossiped about! + * Probably the *best* way to fix would be to have an opaque pointer to the walk position passed as + * part of the walk_get_next call. Then the heap would have to keep a list of walks, or reset the walk + * whenever a modification has been detected. Yuck either way. Perhaps we could iterate over the heap + * once to get a list of peers to gossip about and gossip them over time... But then if one goes away + * in the mean time that becomes nasty. For now we'll just assume that the walking is done + * asynchronously enough to avoid major problems (-; + * + * NOTE: probably fixed once we decided send rate based on allowed bandwidth. + */ + about = GNUNET_CONTAINER_heap_walk_get_next (neighbor_min_heap); + } to = send_context->toNeighbor; if ((about != NULL) && (to != about->referrer /* split horizon */ ) && @@ -1674,61 +1757,69 @@ neighbor_send_task (void *cls, #endif (to != NULL) && (0 != memcmp (&about->identity, - &to->identity, sizeof (struct GNUNET_PeerIdentity))) && + &to->identity, sizeof (struct GNUNET_PeerIdentity))) && (about->pkey != NULL)) - { + { #if DEBUG_DV_GOSSIP_SEND - encPeerAbout = GNUNET_strdup(GNUNET_i2s(&about->identity)); - encPeerTo = GNUNET_strdup(GNUNET_i2s(&to->identity)); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "%s: Sending info about peer %s id %u to directly connected peer %s\n", - GNUNET_i2s(&my_identity), - encPeerAbout, about->our_id, encPeerTo); - GNUNET_free(encPeerAbout); - GNUNET_free(encPeerTo); -#endif - about->last_gossip = GNUNET_TIME_absolute_get(); - pending_message = GNUNET_malloc(sizeof(struct PendingMessage) + sizeof(p2p_dv_MESSAGE_NeighborInfo)); - pending_message->msg = (struct GNUNET_MessageHeader *)&pending_message[1]; - pending_message->importance = default_dv_priority; - pending_message->timeout = GNUNET_TIME_relative_get_forever(); - memcpy(&pending_message->recipient, &to->identity, sizeof(struct GNUNET_PeerIdentity)); - pending_message->msg_size = sizeof(p2p_dv_MESSAGE_NeighborInfo); - message = (p2p_dv_MESSAGE_NeighborInfo *)pending_message->msg; - message->header.size = htons (sizeof (p2p_dv_MESSAGE_NeighborInfo)); - message->header.type = htons (GNUNET_MESSAGE_TYPE_DV_GOSSIP); - message->cost = htonl (about->cost); - message->neighbor_id = htonl (about->our_id); - - memcpy (&message->pkey, about->pkey, sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)); - memcpy (&message->neighbor, - &about->identity, sizeof (struct GNUNET_PeerIdentity)); - - GNUNET_CONTAINER_DLL_insert_after (core_pending_head, - core_pending_tail, - core_pending_tail, - pending_message); - - GNUNET_SCHEDULER_add_now(try_core_send, NULL); - /*if (core_transmit_handle == NULL) - core_transmit_handle = GNUNET_CORE_notify_transmit_ready(coreAPI, GNUNET_YES, default_dv_priority, GNUNET_TIME_relative_get_forever(), &to->identity, sizeof(p2p_dv_MESSAGE_NeighborInfo), &core_transmit_notify, NULL);*/ + encPeerAbout = GNUNET_strdup (GNUNET_i2s (&about->identity)); + encPeerTo = GNUNET_strdup (GNUNET_i2s (&to->identity)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "%s: Sending info about peer %s id %u to directly connected peer %s\n", + GNUNET_i2s (&my_identity), + encPeerAbout, about->our_id, encPeerTo); + GNUNET_free (encPeerAbout); + GNUNET_free (encPeerTo); +#endif + about->last_gossip = GNUNET_TIME_absolute_get (); + pending_message = + GNUNET_malloc (sizeof (struct PendingMessage) + + sizeof (p2p_dv_MESSAGE_NeighborInfo)); + pending_message->msg = (struct GNUNET_MessageHeader *) &pending_message[1]; + pending_message->importance = default_dv_priority; + pending_message->timeout = GNUNET_TIME_relative_get_forever (); + memcpy (&pending_message->recipient, &to->identity, + sizeof (struct GNUNET_PeerIdentity)); + pending_message->msg_size = sizeof (p2p_dv_MESSAGE_NeighborInfo); + message = (p2p_dv_MESSAGE_NeighborInfo *) pending_message->msg; + message->header.size = htons (sizeof (p2p_dv_MESSAGE_NeighborInfo)); + message->header.type = htons (GNUNET_MESSAGE_TYPE_DV_GOSSIP); + message->cost = htonl (about->cost); + message->neighbor_id = htonl (about->our_id); + + memcpy (&message->pkey, about->pkey, + sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)); + memcpy (&message->neighbor, &about->identity, + sizeof (struct GNUNET_PeerIdentity)); + + GNUNET_CONTAINER_DLL_insert_after (core_pending_head, + core_pending_tail, + core_pending_tail, pending_message); + + GNUNET_SCHEDULER_add_now (try_core_send, NULL); + /*if (core_transmit_handle == NULL) + * core_transmit_handle = GNUNET_CORE_notify_transmit_ready(coreAPI, GNUNET_YES, default_dv_priority, GNUNET_TIME_relative_get_forever(), &to->identity, sizeof(p2p_dv_MESSAGE_NeighborInfo), &core_transmit_notify, NULL); */ - } + } - if (send_context->fast_gossip_list_head != NULL) /* If there are other peers in the fast list, schedule right away */ - { + if (send_context->fast_gossip_list_head != NULL) /* If there are other peers in the fast list, schedule right away */ + { #if DEBUG_DV_PEER_NUMBERS - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "DV SERVICE: still in fast send mode\n"); + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "DV SERVICE: still in fast send mode\n"); #endif - send_context->task = GNUNET_SCHEDULER_add_now(&neighbor_send_task, send_context); - } + send_context->task = + GNUNET_SCHEDULER_add_now (&neighbor_send_task, send_context); + } else - { + { #if DEBUG_DV_PEER_NUMBERS - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "DV SERVICE: entering slow send mode\n"); + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "DV SERVICE: entering slow send mode\n"); #endif - send_context->task = GNUNET_SCHEDULER_add_delayed(GNUNET_DV_DEFAULT_SEND_INTERVAL, &neighbor_send_task, send_context); - } + send_context->task = + GNUNET_SCHEDULER_add_delayed (GNUNET_DV_DEFAULT_SEND_INTERVAL, + &neighbor_send_task, send_context); + } return; } @@ -1755,7 +1846,7 @@ handle_start (void *cls, client_handle = client; - GNUNET_SERVER_client_keep(client_handle); + GNUNET_SERVER_client_keep (client_handle); GNUNET_SERVER_receive_done (client, GNUNET_OK); } @@ -1771,18 +1862,17 @@ handle_start (void *cls, * iterate, * GNUNET_NO if not. */ -int send_iterator (void *cls, - const GNUNET_HashCode * key, - void *abs_value) +int +send_iterator (void *cls, const GNUNET_HashCode * key, void *abs_value) { struct DV_SendContext *send_context = cls; struct DistantNeighbor *distant_neighbor = abs_value; - if (memcmp(distant_neighbor->referrer, send_context->direct_peer, sizeof(struct GNUNET_PeerIdentity)) == 0) /* They match, send and free */ - { - send_message_via(&my_identity, distant_neighbor, send_context); - return GNUNET_NO; - } + if (memcmp (distant_neighbor->referrer, send_context->direct_peer, sizeof (struct GNUNET_PeerIdentity)) == 0) /* They match, send and free */ + { + send_message_via (&my_identity, distant_neighbor, send_context); + return GNUNET_NO; + } return GNUNET_YES; } #endif @@ -1795,9 +1885,10 @@ int send_iterator (void *cls, * @param client identification of the client * @param message the actual message */ -void handle_dv_send_message (void *cls, - struct GNUNET_SERVER_Client * client, - const struct GNUNET_MessageHeader * message) +void +handle_dv_send_message (void *cls, + struct GNUNET_SERVER_Client *client, + const struct GNUNET_MessageHeader *message) { struct GNUNET_DV_SendMessage *send_msg; struct GNUNET_DV_SendResultMessage *send_result_msg; @@ -1811,6 +1902,7 @@ void handle_dv_send_message (void *cls, int offset; static struct GNUNET_CRYPTO_HashAsciiEncoded dest_hash; struct DV_SendContext *send_context; + #if DEBUG_DV_MESSAGES char *cbuf; struct GNUNET_MessageHeader *packed_message; @@ -1820,7 +1912,8 @@ void handle_dv_send_message (void *cls, { client_handle = client; GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "%s: Setting initial client handle, never received `%s' message?\n", "dv", "START"); + "%s: Setting initial client handle, never received `%s' message?\n", + "dv", "START"); } else if (client_handle != client) { @@ -1832,55 +1925,67 @@ void handle_dv_send_message (void *cls, #endif } - GNUNET_assert(ntohs(message->size) > sizeof(struct GNUNET_DV_SendMessage)); - send_msg = (struct GNUNET_DV_SendMessage *)message; + GNUNET_assert (ntohs (message->size) > sizeof (struct GNUNET_DV_SendMessage)); + send_msg = (struct GNUNET_DV_SendMessage *) message; - address_len = ntohl(send_msg->addrlen); - GNUNET_assert(address_len == sizeof(struct GNUNET_PeerIdentity) * 2); - message_size = ntohs(message->size) - sizeof(struct GNUNET_DV_SendMessage) - address_len; - destination = GNUNET_malloc(sizeof(struct GNUNET_PeerIdentity)); - direct = GNUNET_malloc(sizeof(struct GNUNET_PeerIdentity)); - message_buf = GNUNET_malloc(message_size); + address_len = ntohl (send_msg->addrlen); + GNUNET_assert (address_len == sizeof (struct GNUNET_PeerIdentity) * 2); + message_size = + ntohs (message->size) - sizeof (struct GNUNET_DV_SendMessage) - + address_len; + destination = GNUNET_malloc (sizeof (struct GNUNET_PeerIdentity)); + direct = GNUNET_malloc (sizeof (struct GNUNET_PeerIdentity)); + message_buf = GNUNET_malloc (message_size); - temp_pos = (char *)&send_msg[1]; /* Set pointer to end of message */ - offset = 0; /* Offset starts at zero */ + temp_pos = (char *) &send_msg[1]; /* Set pointer to end of message */ + offset = 0; /* Offset starts at zero */ - memcpy(destination, &temp_pos[offset], sizeof(struct GNUNET_PeerIdentity)); - offset += sizeof(struct GNUNET_PeerIdentity); + memcpy (destination, &temp_pos[offset], sizeof (struct GNUNET_PeerIdentity)); + offset += sizeof (struct GNUNET_PeerIdentity); - memcpy(direct, &temp_pos[offset], sizeof(struct GNUNET_PeerIdentity)); - offset += sizeof(struct GNUNET_PeerIdentity); + memcpy (direct, &temp_pos[offset], sizeof (struct GNUNET_PeerIdentity)); + offset += sizeof (struct GNUNET_PeerIdentity); - memcpy(message_buf, &temp_pos[offset], message_size); - if (memcmp(&send_msg->target, destination, sizeof(struct GNUNET_PeerIdentity)) != 0) - { - GNUNET_CRYPTO_hash_to_enc (&destination->hashPubKey, &dest_hash); /* GNUNET_i2s won't properly work, need to hash one ourselves */ - dest_hash.encoding[4] = '\0'; - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "%s: asked to send message to `%s', but address is for `%s'!", "DV SERVICE", GNUNET_i2s(&send_msg->target), (const char *)&dest_hash.encoding); - } + memcpy (message_buf, &temp_pos[offset], message_size); + if (memcmp + (&send_msg->target, destination, + sizeof (struct GNUNET_PeerIdentity)) != 0) + { + GNUNET_CRYPTO_hash_to_enc (&destination->hashPubKey, &dest_hash); /* GNUNET_i2s won't properly work, need to hash one ourselves */ + dest_hash.encoding[4] = '\0'; + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "%s: asked to send message to `%s', but address is for `%s'!", + "DV SERVICE", GNUNET_i2s (&send_msg->target), + (const char *) &dest_hash.encoding); + } #if DEBUG_DV_MESSAGES - cbuf = (char *)message_buf; + cbuf = (char *) message_buf; offset = 0; - while(offset < message_size) - { - packed_message = (struct GNUNET_MessageHeader *)&cbuf[offset]; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s: DV PLUGIN SEND uid %u type %d to %s\n", my_short_id, ntohl(send_msg->uid), ntohs(packed_message->type), GNUNET_i2s(destination)); - offset += ntohs(packed_message->size); - } - /*GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s: DV PLUGIN SEND uid %u type %d to %s\n", my_short_id, ntohl(send_msg->uid), ntohs(message_buf->type), GNUNET_i2s(destination));*/ + while (offset < message_size) + { + packed_message = (struct GNUNET_MessageHeader *) &cbuf[offset]; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "%s: DV PLUGIN SEND uid %u type %d to %s\n", my_short_id, + ntohl (send_msg->uid), ntohs (packed_message->type), + GNUNET_i2s (destination)); + offset += ntohs (packed_message->size); + } + /*GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s: DV PLUGIN SEND uid %u type %d to %s\n", my_short_id, ntohl(send_msg->uid), ntohs(message_buf->type), GNUNET_i2s(destination)); */ #endif - GNUNET_CRYPTO_hash_to_enc (&destination->hashPubKey, &dest_hash); /* GNUNET_i2s won't properly work, need to hash one ourselves */ + GNUNET_CRYPTO_hash_to_enc (&destination->hashPubKey, &dest_hash); /* GNUNET_i2s won't properly work, need to hash one ourselves */ dest_hash.encoding[4] = '\0'; - send_context = GNUNET_malloc(sizeof(struct DV_SendContext)); + send_context = GNUNET_malloc (sizeof (struct DV_SendContext)); - send_result_msg = GNUNET_malloc(sizeof(struct GNUNET_DV_SendResultMessage)); - send_result_msg->header.size = htons(sizeof(struct GNUNET_DV_SendResultMessage)); - send_result_msg->header.type = htons(GNUNET_MESSAGE_TYPE_TRANSPORT_DV_SEND_RESULT); + send_result_msg = GNUNET_malloc (sizeof (struct GNUNET_DV_SendResultMessage)); + send_result_msg->header.size = + htons (sizeof (struct GNUNET_DV_SendResultMessage)); + send_result_msg->header.type = + htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DV_SEND_RESULT); send_result_msg->uid = send_msg->uid; /* No need to ntohl->htonl this */ - send_context->importance = ntohl(send_msg->priority); + send_context->importance = ntohl (send_msg->priority); send_context->timeout = send_msg->timeout; send_context->direct_peer = direct; send_context->distant_peer = destination; @@ -1891,84 +1996,111 @@ void handle_dv_send_message (void *cls, send_context->uid = send_msg->uid; #endif - if (send_message_via(&my_identity, direct, send_context) != GNUNET_YES) + if (send_message_via (&my_identity, direct, send_context) != GNUNET_YES) + { + send_result_msg->result = htons (1); + pending_message = + GNUNET_malloc (sizeof (struct PendingMessage) + + sizeof (struct GNUNET_DV_SendResultMessage)); + pending_message->msg = (struct GNUNET_MessageHeader *) &pending_message[1]; + memcpy (&pending_message[1], send_result_msg, + sizeof (struct GNUNET_DV_SendResultMessage)); + GNUNET_free (send_result_msg); + + GNUNET_CONTAINER_DLL_insert_after (plugin_pending_head, plugin_pending_tail, + plugin_pending_tail, pending_message); + + if (client_handle != NULL) { - send_result_msg->result = htons(1); - pending_message = GNUNET_malloc(sizeof(struct PendingMessage) + sizeof(struct GNUNET_DV_SendResultMessage)); - pending_message->msg = (struct GNUNET_MessageHeader *)&pending_message[1]; - memcpy(&pending_message[1], send_result_msg, sizeof(struct GNUNET_DV_SendResultMessage)); - GNUNET_free(send_result_msg); - - GNUNET_CONTAINER_DLL_insert_after(plugin_pending_head, plugin_pending_tail, plugin_pending_tail, pending_message); - - if (client_handle != NULL) - { - if (plugin_transmit_handle == NULL) - { - plugin_transmit_handle = GNUNET_SERVER_notify_transmit_ready (client_handle, - sizeof(struct GNUNET_DV_SendResultMessage), - GNUNET_TIME_UNIT_FOREVER_REL, - &transmit_to_plugin, NULL); - } - else - { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed to queue message for plugin, must be one in progress already!!\n"); - } - } - GNUNET_CRYPTO_hash_to_enc (&destination->hashPubKey, &dest_hash); /* GNUNET_i2s won't properly work, need to hash one ourselves */ - dest_hash.encoding[4] = '\0'; - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "%s DV SEND failed to send message to destination `%s' via `%s'\n", my_short_id, (const char *)&dest_hash.encoding, GNUNET_i2s(direct)); + if (plugin_transmit_handle == NULL) + { + plugin_transmit_handle = + GNUNET_SERVER_notify_transmit_ready (client_handle, + sizeof (struct + GNUNET_DV_SendResultMessage), + GNUNET_TIME_UNIT_FOREVER_REL, + &transmit_to_plugin, NULL); + } + else + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Failed to queue message for plugin, must be one in progress already!!\n"); + } } + GNUNET_CRYPTO_hash_to_enc (&destination->hashPubKey, &dest_hash); /* GNUNET_i2s won't properly work, need to hash one ourselves */ + dest_hash.encoding[4] = '\0'; + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "%s DV SEND failed to send message to destination `%s' via `%s'\n", + my_short_id, (const char *) &dest_hash.encoding, + GNUNET_i2s (direct)); + } /* In bizarro world GNUNET_SYSERR indicates that we succeeded */ #if UNSIMPLER - if (GNUNET_SYSERR != GNUNET_CONTAINER_multihashmap_get_multiple(extended_neighbors, &destination->hashPubKey, &send_iterator, send_context)) + if (GNUNET_SYSERR != + GNUNET_CONTAINER_multihashmap_get_multiple (extended_neighbors, + &destination->hashPubKey, + &send_iterator, send_context)) + { + send_result_msg->result = htons (1); + pending_message = + GNUNET_malloc (sizeof (struct PendingMessage) + + sizeof (struct GNUNET_DV_SendResultMessage)); + pending_message->msg = (struct GNUNET_MessageHeader *) &pending_message[1]; + memcpy (&pending_message[1], send_result_msg, + sizeof (struct GNUNET_DV_SendResultMessage)); + GNUNET_free (send_result_msg); + + GNUNET_CONTAINER_DLL_insert_after (plugin_pending_head, plugin_pending_tail, + plugin_pending_tail, pending_message); + + if (client_handle != NULL) { - send_result_msg->result = htons(1); - pending_message = GNUNET_malloc(sizeof(struct PendingMessage) + sizeof(struct GNUNET_DV_SendResultMessage)); - pending_message->msg = (struct GNUNET_MessageHeader *)&pending_message[1]; - memcpy(&pending_message[1], send_result_msg, sizeof(struct GNUNET_DV_SendResultMessage)); - GNUNET_free(send_result_msg); - - GNUNET_CONTAINER_DLL_insert_after(plugin_pending_head, plugin_pending_tail, plugin_pending_tail, pending_message); - - if (client_handle != NULL) - { - if (plugin_transmit_handle == NULL) - { - plugin_transmit_handle = GNUNET_SERVER_notify_transmit_ready (client_handle, - sizeof(struct GNUNET_DV_SendResultMessage), - GNUNET_TIME_UNIT_FOREVER_REL, - &transmit_to_plugin, NULL); - } - else - { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed to queue message for plugin, must be one in progress already!!\n"); - } - } - GNUNET_CRYPTO_hash_to_enc (&destination->hashPubKey, &dest_hash); /* GNUNET_i2s won't properly work, need to hash one ourselves */ - dest_hash.encoding[4] = '\0'; - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "%s DV SEND failed to send message to destination `%s' via `%s'\n", my_short_id, (const char *)&dest_hash.encoding, GNUNET_i2s(direct)); + if (plugin_transmit_handle == NULL) + { + plugin_transmit_handle = + GNUNET_SERVER_notify_transmit_ready (client_handle, + sizeof (struct + GNUNET_DV_SendResultMessage), + GNUNET_TIME_UNIT_FOREVER_REL, + &transmit_to_plugin, NULL); + } + else + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Failed to queue message for plugin, must be one in progress already!!\n"); + } } + GNUNET_CRYPTO_hash_to_enc (&destination->hashPubKey, &dest_hash); /* GNUNET_i2s won't properly work, need to hash one ourselves */ + dest_hash.encoding[4] = '\0'; + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "%s DV SEND failed to send message to destination `%s' via `%s'\n", + my_short_id, (const char *) &dest_hash.encoding, + GNUNET_i2s (direct)); + } #endif - GNUNET_free(message_buf); - GNUNET_free(send_context); - GNUNET_free(direct); - GNUNET_free(destination); + GNUNET_free (message_buf); + GNUNET_free (send_context); + GNUNET_free (direct); + GNUNET_free (destination); - GNUNET_SERVER_receive_done(client, GNUNET_OK); + GNUNET_SERVER_receive_done (client, GNUNET_OK); } /** Forward declarations **/ static int handle_dv_gossip_message (void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_MessageHeader *message, - const struct GNUNET_TRANSPORT_ATS_Information *atsi); + const struct + GNUNET_TRANSPORT_ATS_Information *atsi); static int handle_dv_disconnect_message (void *cls, const struct GNUNET_PeerIdentity *peer, - const struct GNUNET_MessageHeader *message, - const struct GNUNET_TRANSPORT_ATS_Information *atsi); + const struct GNUNET_MessageHeader + *message, + const struct + GNUNET_TRANSPORT_ATS_Information + *atsi); /** End forward declarations **/ @@ -2006,14 +2138,14 @@ distant_neighbor_free (struct DistantNeighbor *referee) referrer = referee->referrer; if (referrer != NULL) - { - GNUNET_CONTAINER_DLL_remove (referrer->referee_head, - referrer->referee_tail, referee); - } + { + GNUNET_CONTAINER_DLL_remove (referrer->referee_head, + referrer->referee_tail, referee); + } GNUNET_CONTAINER_heap_remove_node (referee->max_loc); GNUNET_CONTAINER_heap_remove_node (referee->min_loc); GNUNET_CONTAINER_multihashmap_remove_all (extended_neighbors, - &referee->identity.hashPubKey); + &referee->identity.hashPubKey); GNUNET_free_non_null (referee->pkey); GNUNET_free (referee); } @@ -2032,18 +2164,20 @@ direct_neighbor_free (struct DirectNeighbor *direct) send_context = direct->send_context; if (send_context->task != GNUNET_SCHEDULER_NO_TASK) - GNUNET_SCHEDULER_cancel(send_context->task); + GNUNET_SCHEDULER_cancel (send_context->task); about_list = send_context->fast_gossip_list_head; while (about_list != NULL) - { - GNUNET_CONTAINER_DLL_remove(send_context->fast_gossip_list_head, send_context->fast_gossip_list_tail, about_list); - prev_about = about_list; - about_list = about_list->next; - GNUNET_free(prev_about); - } - GNUNET_free(send_context); - GNUNET_free(direct); + { + GNUNET_CONTAINER_DLL_remove (send_context->fast_gossip_list_head, + send_context->fast_gossip_list_tail, + about_list); + prev_about = about_list; + about_list = about_list->next; + GNUNET_free (prev_about); + } + GNUNET_free (send_context); + GNUNET_free (direct); } /** @@ -2056,9 +2190,9 @@ direct_neighbor_free (struct DirectNeighbor *direct) * * @return GNUNET_YES to continue iteration, GNUNET_NO to stop */ -static int schedule_disconnect_messages (void *cls, - const GNUNET_HashCode * key, - void *value) +static int +schedule_disconnect_messages (void *cls, + const GNUNET_HashCode * key, void *value) { struct DisconnectContext *disconnect_context = cls; struct DirectNeighbor *disconnected = disconnect_context->direct; @@ -2066,28 +2200,32 @@ static int schedule_disconnect_messages (void *cls, struct PendingMessage *pending_message; p2p_dv_MESSAGE_Disconnect *disconnect_message; - if (memcmp(¬ify->identity, &disconnected->identity, sizeof(struct GNUNET_PeerIdentity)) == 0) - return GNUNET_YES; /* Don't send disconnect message to peer that disconnected! */ + if (memcmp + (¬ify->identity, &disconnected->identity, + sizeof (struct GNUNET_PeerIdentity)) == 0) + return GNUNET_YES; /* Don't send disconnect message to peer that disconnected! */ - pending_message = GNUNET_malloc(sizeof(struct PendingMessage) + sizeof(p2p_dv_MESSAGE_Disconnect)); - pending_message->msg = (struct GNUNET_MessageHeader *)&pending_message[1]; + pending_message = + GNUNET_malloc (sizeof (struct PendingMessage) + + sizeof (p2p_dv_MESSAGE_Disconnect)); + pending_message->msg = (struct GNUNET_MessageHeader *) &pending_message[1]; pending_message->importance = default_dv_priority; - pending_message->timeout = GNUNET_TIME_relative_get_forever(); - memcpy(&pending_message->recipient, ¬ify->identity, sizeof(struct GNUNET_PeerIdentity)); - pending_message->msg_size = sizeof(p2p_dv_MESSAGE_Disconnect); - disconnect_message = (p2p_dv_MESSAGE_Disconnect *)pending_message->msg; + pending_message->timeout = GNUNET_TIME_relative_get_forever (); + memcpy (&pending_message->recipient, ¬ify->identity, + sizeof (struct GNUNET_PeerIdentity)); + pending_message->msg_size = sizeof (p2p_dv_MESSAGE_Disconnect); + disconnect_message = (p2p_dv_MESSAGE_Disconnect *) pending_message->msg; disconnect_message->header.size = htons (sizeof (p2p_dv_MESSAGE_Disconnect)); disconnect_message->header.type = htons (GNUNET_MESSAGE_TYPE_DV_DISCONNECT); - disconnect_message->peer_id = htonl(disconnect_context->distant->our_id); + disconnect_message->peer_id = htonl (disconnect_context->distant->our_id); GNUNET_CONTAINER_DLL_insert_after (core_pending_head, core_pending_tail, - core_pending_tail, - pending_message); + core_pending_tail, pending_message); - GNUNET_SCHEDULER_add_now(try_core_send, NULL); + GNUNET_SCHEDULER_add_now (try_core_send, NULL); /*if (core_transmit_handle == NULL) - core_transmit_handle = GNUNET_CORE_notify_transmit_ready(coreAPI, GNUNET_YES, default_dv_priority, GNUNET_TIME_relative_get_forever(), ¬ify->identity, sizeof(p2p_dv_MESSAGE_Disconnect), &core_transmit_notify, NULL);*/ + * core_transmit_handle = GNUNET_CORE_notify_transmit_ready(coreAPI, GNUNET_YES, default_dv_priority, GNUNET_TIME_relative_get_forever(), ¬ify->identity, sizeof(p2p_dv_MESSAGE_Disconnect), &core_transmit_notify, NULL); */ return GNUNET_YES; } @@ -2101,12 +2239,12 @@ static int schedule_disconnect_messages (void *cls, * * @return GNUNET_YES to continue iteration, GNUNET_NO to stop */ -static int free_extended_neighbors (void *cls, - const GNUNET_HashCode * key, - void *value) +static int +free_extended_neighbors (void *cls, const GNUNET_HashCode * key, void *value) { struct DistantNeighbor *distant = value; - distant_neighbor_free(distant); + + distant_neighbor_free (distant); return GNUNET_YES; } @@ -2119,12 +2257,12 @@ static int free_extended_neighbors (void *cls, * * @return GNUNET_YES to continue iteration, GNUNET_NO to stop */ -static int free_direct_neighbors (void *cls, - const GNUNET_HashCode * key, - void *value) +static int +free_direct_neighbors (void *cls, const GNUNET_HashCode * key, void *value) { struct DirectNeighbor *direct = value; - direct_neighbor_free(direct); + + direct_neighbor_free (direct); return GNUNET_YES; } @@ -2136,52 +2274,56 @@ static int free_direct_neighbors (void *cls, * @param tc unused */ static void -shutdown_task (void *cls, - const struct GNUNET_SCHEDULER_TaskContext *tc) +shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { #if DEBUG_DV - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "calling CORE_DISCONNECT\n"); - GNUNET_CONTAINER_multihashmap_iterate(extended_neighbors, &print_neighbors, NULL); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "calling CORE_DISCONNECT\n"); + GNUNET_CONTAINER_multihashmap_iterate (extended_neighbors, &print_neighbors, + NULL); #endif - GNUNET_CONTAINER_multihashmap_iterate(extended_neighbors, &free_extended_neighbors, NULL); - GNUNET_CONTAINER_multihashmap_destroy(extended_neighbors); - GNUNET_CONTAINER_multihashmap_iterate(direct_neighbors, &free_direct_neighbors, NULL); - GNUNET_CONTAINER_multihashmap_destroy(direct_neighbors); + GNUNET_CONTAINER_multihashmap_iterate (extended_neighbors, + &free_extended_neighbors, NULL); + GNUNET_CONTAINER_multihashmap_destroy (extended_neighbors); + GNUNET_CONTAINER_multihashmap_iterate (direct_neighbors, + &free_direct_neighbors, NULL); + GNUNET_CONTAINER_multihashmap_destroy (direct_neighbors); - GNUNET_CONTAINER_heap_destroy(neighbor_max_heap); - GNUNET_CONTAINER_heap_destroy(neighbor_min_heap); + GNUNET_CONTAINER_heap_destroy (neighbor_max_heap); + GNUNET_CONTAINER_heap_destroy (neighbor_min_heap); GNUNET_CORE_disconnect (coreAPI); coreAPI = NULL; - GNUNET_PEERINFO_disconnect(peerinfo_handle); - GNUNET_SERVER_mst_destroy(coreMST); - GNUNET_free_non_null(my_short_id); + GNUNET_PEERINFO_disconnect (peerinfo_handle); + GNUNET_SERVER_mst_destroy (coreMST); + GNUNET_free_non_null (my_short_id); #if DEBUG_DV - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "CORE_DISCONNECT completed\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "CORE_DISCONNECT completed\n"); #endif } /** * To be called on core init/fail. */ -void core_init (void *cls, - struct GNUNET_CORE_Handle * server, - const struct GNUNET_PeerIdentity *identity, - const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded * publicKey) +void +core_init (void *cls, + struct GNUNET_CORE_Handle *server, + const struct GNUNET_PeerIdentity *identity, + const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *publicKey) { if (server == NULL) - { - GNUNET_SCHEDULER_cancel(cleanup_task); - GNUNET_SCHEDULER_add_now(&shutdown_task, NULL); - return; - } + { + GNUNET_SCHEDULER_cancel (cleanup_task); + GNUNET_SCHEDULER_add_now (&shutdown_task, NULL); + return; + } #if DEBUG_DV GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "%s: Core connection initialized, I am peer: %s\n", "dv", GNUNET_i2s(identity)); + "%s: Core connection initialized, I am peer: %s\n", "dv", + GNUNET_i2s (identity)); #endif - memcpy(&my_identity, identity, sizeof(struct GNUNET_PeerIdentity)); - my_short_id = GNUNET_strdup(GNUNET_i2s(&my_identity)); + memcpy (&my_identity, identity, sizeof (struct GNUNET_PeerIdentity)); + my_short_id = GNUNET_strdup (GNUNET_i2s (&my_identity)); coreAPI = server; } @@ -2197,17 +2339,18 @@ void core_init (void *cls, * iterate, * GNUNET_NO if not. */ -static int add_pkey_to_extended (void *cls, - const GNUNET_HashCode * key, - void *abs_value) +static int +add_pkey_to_extended (void *cls, const GNUNET_HashCode * key, void *abs_value) { struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *pkey = cls; struct DistantNeighbor *distant_neighbor = abs_value; if (distant_neighbor->pkey == NULL) { - distant_neighbor->pkey = GNUNET_malloc(sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)); - memcpy(distant_neighbor->pkey, pkey, sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)); + distant_neighbor->pkey = + GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)); + memcpy (distant_neighbor->pkey, pkey, + sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)); } return GNUNET_YES; @@ -2224,20 +2367,21 @@ static int add_pkey_to_extended (void *cls, * iterate, * GNUNET_NO if not. */ -static int update_matching_neighbors (void *cls, - const GNUNET_HashCode * key, - void *value) +static int +update_matching_neighbors (void *cls, const GNUNET_HashCode * key, void *value) { - struct NeighborUpdateInfo * update_info = cls; + struct NeighborUpdateInfo *update_info = cls; struct DistantNeighbor *distant_neighbor = value; - if (update_info->referrer == distant_neighbor->referrer) /* Direct neighbor matches, update it's info and return GNUNET_NO */ + if (update_info->referrer == distant_neighbor->referrer) /* Direct neighbor matches, update it's info and return GNUNET_NO */ { /* same referrer, cost change! */ GNUNET_CONTAINER_heap_update_cost (neighbor_max_heap, - update_info->neighbor->max_loc, update_info->cost); + update_info->neighbor->max_loc, + update_info->cost); GNUNET_CONTAINER_heap_update_cost (neighbor_min_heap, - update_info->neighbor->min_loc, update_info->cost); + update_info->neighbor->min_loc, + update_info->cost); update_info->neighbor->last_activity = update_info->now; update_info->neighbor->cost = update_info->cost; update_info->neighbor->referrer_id = update_info->referrer_peer_id; @@ -2259,54 +2403,59 @@ static int update_matching_neighbors (void *cls, * * @return GNUNET_YES to continue iteration, GNUNET_NO otherwise */ -static int add_distant_all_direct_neighbors (void *cls, - const GNUNET_HashCode * key, - void *value) +static int +add_distant_all_direct_neighbors (void *cls, + const GNUNET_HashCode * key, void *value) { - struct DirectNeighbor *direct = (struct DirectNeighbor *)value; - struct DistantNeighbor *distant = (struct DistantNeighbor *)cls; + struct DirectNeighbor *direct = (struct DirectNeighbor *) value; + struct DistantNeighbor *distant = (struct DistantNeighbor *) cls; struct NeighborSendContext *send_context = direct->send_context; struct FastGossipNeighborList *gossip_entry; + #if DEBUG_DV char *encPeerAbout; char *encPeerTo; #endif if (distant == NULL) - { - return GNUNET_YES; - } + { + return GNUNET_YES; + } - if (memcmp(&direct->identity, &distant->identity, sizeof(struct GNUNET_PeerIdentity)) == 0) - { - return GNUNET_YES; /* Don't gossip to a peer about itself! */ - } + if (memcmp + (&direct->identity, &distant->identity, + sizeof (struct GNUNET_PeerIdentity)) == 0) + { + return GNUNET_YES; /* Don't gossip to a peer about itself! */ + } #if SUPPORT_HIDING if (distant->hidden == GNUNET_YES) - return GNUNET_YES; /* This peer should not be gossipped about (hidden) */ + return GNUNET_YES; /* This peer should not be gossipped about (hidden) */ #endif - gossip_entry = GNUNET_malloc(sizeof(struct FastGossipNeighborList)); + gossip_entry = GNUNET_malloc (sizeof (struct FastGossipNeighborList)); gossip_entry->about = distant; - GNUNET_CONTAINER_DLL_insert_after(send_context->fast_gossip_list_head, - send_context->fast_gossip_list_tail, - send_context->fast_gossip_list_tail, - gossip_entry); + GNUNET_CONTAINER_DLL_insert_after (send_context->fast_gossip_list_head, + send_context->fast_gossip_list_tail, + send_context->fast_gossip_list_tail, + gossip_entry); #if DEBUG_DV - encPeerAbout = GNUNET_strdup(GNUNET_i2s(&distant->identity)); - encPeerTo = GNUNET_strdup(GNUNET_i2s(&direct->identity)); + encPeerAbout = GNUNET_strdup (GNUNET_i2s (&distant->identity)); + encPeerTo = GNUNET_strdup (GNUNET_i2s (&direct->identity)); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s: Fast send info about peer %s id %u for directly connected peer %s\n", - GNUNET_i2s(&my_identity), - encPeerAbout, distant->our_id, encPeerTo); - GNUNET_free(encPeerAbout); - GNUNET_free(encPeerTo); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "%s: Fast send info about peer %s id %u for directly connected peer %s\n", + GNUNET_i2s (&my_identity), encPeerAbout, distant->our_id, + encPeerTo); + GNUNET_free (encPeerAbout); + GNUNET_free (encPeerTo); #endif /*if (send_context->task != GNUNET_SCHEDULER_NO_TASK) - GNUNET_SCHEDULER_cancel(send_context->task);*/ + * GNUNET_SCHEDULER_cancel(send_context->task); */ - send_context->task = GNUNET_SCHEDULER_add_now(&neighbor_send_task, send_context); + send_context->task = + GNUNET_SCHEDULER_add_now (&neighbor_send_task, send_context); return GNUNET_YES; } @@ -2333,24 +2482,27 @@ generate_hello_address (void *cls, size_t max, void *buf) return 0; /* Hello "address" will be concatenation of distant peer and direct peer identities */ - size = 2 * sizeof(struct GNUNET_PeerIdentity); - GNUNET_assert(max >= size); + size = 2 * sizeof (struct GNUNET_PeerIdentity); + GNUNET_assert (max >= size); - addr_buffer = GNUNET_malloc(size); + addr_buffer = GNUNET_malloc (size); offset = 0; /* Copy the distant peer identity to buffer */ - memcpy(addr_buffer, &hello_context->distant_peer, sizeof(struct GNUNET_PeerIdentity)); - offset += sizeof(struct GNUNET_PeerIdentity); + memcpy (addr_buffer, &hello_context->distant_peer, + sizeof (struct GNUNET_PeerIdentity)); + offset += sizeof (struct GNUNET_PeerIdentity); /* Copy the direct peer identity to buffer */ - memcpy(&addr_buffer[offset], hello_context->direct_peer, sizeof(struct GNUNET_PeerIdentity)); - ret = GNUNET_HELLO_add_address ("dv", - GNUNET_TIME_relative_to_absolute - (GNUNET_TIME_UNIT_HOURS), addr_buffer, size, - buf, max); + memcpy (&addr_buffer[offset], hello_context->direct_peer, + sizeof (struct GNUNET_PeerIdentity)); + ret = + GNUNET_HELLO_add_address ("dv", + GNUNET_TIME_relative_to_absolute + (GNUNET_TIME_UNIT_HOURS), addr_buffer, size, + buf, max); hello_context->addresses_to_add--; - GNUNET_free(addr_buffer); + GNUNET_free (addr_buffer); return ret; } @@ -2370,8 +2522,8 @@ generate_hello_address (void *cls, size_t max, void *buf) * not added) */ static struct DistantNeighbor * -addUpdateNeighbor (const struct GNUNET_PeerIdentity * peer, - struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *pkey, +addUpdateNeighbor (const struct GNUNET_PeerIdentity *peer, + struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *pkey, unsigned int referrer_peer_id, struct DirectNeighbor *referrer, unsigned int cost) { @@ -2388,6 +2540,7 @@ addUpdateNeighbor (const struct GNUNET_PeerIdentity * peer, #if DEBUG_DV_PEER_NUMBERS char *encAbout; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "%s Received sender id (%u)!\n", "DV SERVICE", referrer_peer_id); #endif @@ -2395,7 +2548,7 @@ addUpdateNeighbor (const struct GNUNET_PeerIdentity * peer, now = GNUNET_TIME_absolute_get (); neighbor = GNUNET_CONTAINER_multihashmap_get (extended_neighbors, &peer->hashPubKey); - neighbor_update = GNUNET_malloc(sizeof(struct NeighborUpdateInfo)); + neighbor_update = GNUNET_malloc (sizeof (struct NeighborUpdateInfo)); neighbor_update->neighbor = neighbor; neighbor_update->cost = cost; neighbor_update->now = now; @@ -2403,163 +2556,189 @@ addUpdateNeighbor (const struct GNUNET_PeerIdentity * peer, neighbor_update->referrer_peer_id = referrer_peer_id; if (neighbor != NULL) - { + { #if USE_PEER_ID - memcpy(&our_id, &neighbor->identity, sizeof(unsigned int)); + memcpy (&our_id, &neighbor->identity, sizeof (unsigned int)); #else - our_id = neighbor->our_id; + our_id = neighbor->our_id; #endif - } + } else - { + { #if USE_PEER_ID - memcpy(&our_id, peer, sizeof(unsigned int)); + memcpy (&our_id, peer, sizeof (unsigned int)); #else - our_id = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, RAND_MAX - 1) + 1; + our_id = + GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, + RAND_MAX - 1) + 1; #endif - } + } /* Either we do not know this peer, or we already do but via a different immediate peer */ if ((neighbor == NULL) || - (GNUNET_CONTAINER_multihashmap_get_multiple(extended_neighbors, - &peer->hashPubKey, - &update_matching_neighbors, - neighbor_update) != GNUNET_SYSERR)) - { + (GNUNET_CONTAINER_multihashmap_get_multiple (extended_neighbors, + &peer->hashPubKey, + &update_matching_neighbors, + neighbor_update) != + GNUNET_SYSERR)) + { #if AT_MOST_ONE - if ((neighbor != NULL) && (cost < neighbor->cost)) /* New cost is less than old, remove old */ - { - distant_neighbor_free(neighbor); - } - else if (neighbor != NULL) /* Only allow one DV connection to each peer */ - { - return NULL; - } + if ((neighbor != NULL) && (cost < neighbor->cost)) /* New cost is less than old, remove old */ + { + distant_neighbor_free (neighbor); + } + else if (neighbor != NULL) /* Only allow one DV connection to each peer */ + { + return NULL; + } #endif - /* new neighbor! */ - if (cost > fisheye_depth) - { - /* too costly */ - GNUNET_free(neighbor_update); - return NULL; - } + /* new neighbor! */ + if (cost > fisheye_depth) + { + /* too costly */ + GNUNET_free (neighbor_update); + return NULL; + } #if DEBUG_DV_PEER_NUMBERS - encAbout = GNUNET_strdup(GNUNET_i2s(peer)); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "%s: %s Chose NEW id (%u) for peer %s!\n", GNUNET_i2s(&my_identity), "DV SERVICE", our_id, encAbout); - GNUNET_free(encAbout); + encAbout = GNUNET_strdup (GNUNET_i2s (peer)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "%s: %s Chose NEW id (%u) for peer %s!\n", + GNUNET_i2s (&my_identity), "DV SERVICE", our_id, encAbout); + GNUNET_free (encAbout); #endif - if (max_table_size <= - GNUNET_CONTAINER_multihashmap_size (extended_neighbors)) - { - /* remove most expensive entry */ - max = GNUNET_CONTAINER_heap_peek (neighbor_max_heap); - GNUNET_assert(max != NULL); - if (cost > max->cost) - { - /* new entry most expensive, don't create */ - GNUNET_free(neighbor_update); - return NULL; - } - if (max->cost > 1) - { - /* only free if this is not a direct connection; - we could theoretically have more direct - connections than DV entries allowed total! */ - distant_neighbor_free (max); - } - } - - neighbor = GNUNET_malloc (sizeof (struct DistantNeighbor)); - GNUNET_CONTAINER_DLL_insert (referrer->referee_head, - referrer->referee_tail, neighbor); - neighbor->max_loc = GNUNET_CONTAINER_heap_insert (neighbor_max_heap, - neighbor, cost); - neighbor->min_loc = GNUNET_CONTAINER_heap_insert (neighbor_min_heap, - neighbor, cost); - neighbor->referrer = referrer; - memcpy (&neighbor->identity, peer, sizeof (struct GNUNET_PeerIdentity)); - if (pkey != NULL) /* pkey will be null on direct neighbor addition */ + if (max_table_size <= + GNUNET_CONTAINER_multihashmap_size (extended_neighbors)) + { + /* remove most expensive entry */ + max = GNUNET_CONTAINER_heap_peek (neighbor_max_heap); + GNUNET_assert (max != NULL); + if (cost > max->cost) { - neighbor->pkey = GNUNET_malloc(sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)); - memcpy (neighbor->pkey, pkey, sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)); + /* new entry most expensive, don't create */ + GNUNET_free (neighbor_update); + return NULL; } - else - neighbor->pkey = pkey; - - neighbor->last_activity = now; - neighbor->cost = cost; - neighbor->referrer_id = referrer_peer_id; - neighbor->our_id = our_id; - neighbor->hidden = - (cost == DIRECT_NEIGHBOR_COST) ? (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 4) == - 0) : GNUNET_NO; - - GNUNET_CONTAINER_multihashmap_put (extended_neighbors, &peer->hashPubKey, - neighbor, - GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); - if (referrer_peer_id != 0) + if (max->cost > 1) + { + /* only free if this is not a direct connection; + * we could theoretically have more direct + * connections than DV entries allowed total! */ + distant_neighbor_free (max); + } + } + + neighbor = GNUNET_malloc (sizeof (struct DistantNeighbor)); + GNUNET_CONTAINER_DLL_insert (referrer->referee_head, + referrer->referee_tail, neighbor); + neighbor->max_loc = GNUNET_CONTAINER_heap_insert (neighbor_max_heap, + neighbor, cost); + neighbor->min_loc = GNUNET_CONTAINER_heap_insert (neighbor_min_heap, + neighbor, cost); + neighbor->referrer = referrer; + memcpy (&neighbor->identity, peer, sizeof (struct GNUNET_PeerIdentity)); + if (pkey != NULL) /* pkey will be null on direct neighbor addition */ + { + neighbor->pkey = + GNUNET_malloc (sizeof + (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)); + memcpy (neighbor->pkey, pkey, + sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)); + } + else + neighbor->pkey = pkey; + + neighbor->last_activity = now; + neighbor->cost = cost; + neighbor->referrer_id = referrer_peer_id; + neighbor->our_id = our_id; + neighbor->hidden = + (cost == + DIRECT_NEIGHBOR_COST) + ? (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 4) == + 0) : GNUNET_NO; + + GNUNET_CONTAINER_multihashmap_put (extended_neighbors, &peer->hashPubKey, + neighbor, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); + if (referrer_peer_id != 0) + { + for (i = 0; i < MAX_OUTSTANDING_MESSAGES; i++) + { + if (referrer->pending_messages[i].sender_id == referrer_peer_id) /* We have a queued message from just learned about peer! */ { - for (i = 0; i< MAX_OUTSTANDING_MESSAGES; i++) - { - if (referrer->pending_messages[i].sender_id == referrer_peer_id) /* We have a queued message from just learned about peer! */ - { #if DEBUG_DV_MESSAGES - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s: learned about peer %llu from which we have a previous unknown message, processing!\n", my_short_id, referrer_peer_id); -#endif - struct GNUNET_TRANSPORT_ATS_Information atsi[3]; - atsi[0].type = htonl (GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE); - atsi[0].value = htonl (referrer->pending_messages[i].distance); - atsi[1].type = htonl (GNUNET_TRANSPORT_ATS_QUALITY_NET_DELAY); - atsi[1].value = htonl ((uint32_t)referrer->pending_messages[i].latency.rel_value); - atsi[2].type = htonl (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR); - atsi[2].value = htonl (0); - handle_dv_data_message(NULL, - &referrer->pending_messages[i].sender, - referrer->pending_messages[i].message, - (const struct GNUNET_TRANSPORT_ATS_Information *)&atsi); - GNUNET_free(referrer->pending_messages[i].message); - referrer->pending_messages[i].sender_id = 0; - } - } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "%s: learned about peer %llu from which we have a previous unknown message, processing!\n", + my_short_id, referrer_peer_id); +#endif + struct GNUNET_TRANSPORT_ATS_Information atsi[3]; + + atsi[0].type = htonl (GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE); + atsi[0].value = htonl (referrer->pending_messages[i].distance); + atsi[1].type = htonl (GNUNET_TRANSPORT_ATS_QUALITY_NET_DELAY); + atsi[1].value = + htonl ((uint32_t) referrer->pending_messages[i]. + latency.rel_value); + atsi[2].type = htonl (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR); + atsi[2].value = htonl (0); + handle_dv_data_message (NULL, + &referrer->pending_messages[i].sender, + referrer->pending_messages[i].message, + (const struct GNUNET_TRANSPORT_ATS_Information + *) &atsi); + GNUNET_free (referrer->pending_messages[i].message); + referrer->pending_messages[i].sender_id = 0; } - if ((cost != DIRECT_NEIGHBOR_COST) && (neighbor->pkey != NULL)) - { - /* Added neighbor, now send HELLO to transport */ - hello_context = GNUNET_malloc(sizeof(struct HelloContext)); - hello_context->direct_peer = &referrer->identity; - memcpy(&hello_context->distant_peer, peer, sizeof(struct GNUNET_PeerIdentity)); - hello_context->addresses_to_add = 1; - hello_msg = GNUNET_HELLO_create(pkey, &generate_hello_address, hello_context); - GNUNET_assert(memcmp(hello_context->direct_peer, &hello_context->distant_peer, sizeof(struct GNUNET_PeerIdentity)) != 0); - addr1 = GNUNET_strdup(GNUNET_i2s(hello_context->direct_peer)); - addr2 = GNUNET_strdup(GNUNET_i2s(&hello_context->distant_peer)); + } + } + if ((cost != DIRECT_NEIGHBOR_COST) && (neighbor->pkey != NULL)) + { + /* Added neighbor, now send HELLO to transport */ + hello_context = GNUNET_malloc (sizeof (struct HelloContext)); + hello_context->direct_peer = &referrer->identity; + memcpy (&hello_context->distant_peer, peer, + sizeof (struct GNUNET_PeerIdentity)); + hello_context->addresses_to_add = 1; + hello_msg = + GNUNET_HELLO_create (pkey, &generate_hello_address, hello_context); + GNUNET_assert (memcmp + (hello_context->direct_peer, &hello_context->distant_peer, + sizeof (struct GNUNET_PeerIdentity)) != 0); + addr1 = GNUNET_strdup (GNUNET_i2s (hello_context->direct_peer)); + addr2 = GNUNET_strdup (GNUNET_i2s (&hello_context->distant_peer)); #if DEBUG_DV - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s: GIVING HELLO size %d for %s via %s to TRANSPORT\n", my_short_id, GNUNET_HELLO_size(hello_msg), addr2, addr1); -#endif - GNUNET_free(addr1); - GNUNET_free(addr2); - send_to_plugin(hello_context->direct_peer, GNUNET_HELLO_get_header(hello_msg), GNUNET_HELLO_size(hello_msg), &hello_context->distant_peer, cost); - GNUNET_free(hello_context); - GNUNET_free(hello_msg); - } - + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "%s: GIVING HELLO size %d for %s via %s to TRANSPORT\n", + my_short_id, GNUNET_HELLO_size (hello_msg), addr2, addr1); +#endif + GNUNET_free (addr1); + GNUNET_free (addr2); + send_to_plugin (hello_context->direct_peer, + GNUNET_HELLO_get_header (hello_msg), + GNUNET_HELLO_size (hello_msg), + &hello_context->distant_peer, cost); + GNUNET_free (hello_context); + GNUNET_free (hello_msg); } + + } else - { + { #if DEBUG_DV_GOSSIP - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "%s: Already know peer %s distance %d, referrer id %d!\n", "dv", GNUNET_i2s(peer), cost, referrer_peer_id); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "%s: Already know peer %s distance %d, referrer id %d!\n", "dv", + GNUNET_i2s (peer), cost, referrer_peer_id); #endif - } + } #if DEBUG_DV - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "%s: Size of extended_neighbors is %d\n", "dv", GNUNET_CONTAINER_multihashmap_size(extended_neighbors)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "%s: Size of extended_neighbors is %d\n", "dv", + GNUNET_CONTAINER_multihashmap_size (extended_neighbors)); #endif - GNUNET_free(neighbor_update); + GNUNET_free (neighbor_update); return neighbor; } @@ -2576,19 +2755,22 @@ addUpdateNeighbor (const struct GNUNET_PeerIdentity * peer, * @param message the message * @param atsi performance data */ -static int handle_dv_disconnect_message (void *cls, - const struct GNUNET_PeerIdentity *peer, - const struct GNUNET_MessageHeader *message, - const struct GNUNET_TRANSPORT_ATS_Information *atsi) +static int +handle_dv_disconnect_message (void *cls, + const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_MessageHeader *message, + const struct GNUNET_TRANSPORT_ATS_Information + *atsi) { struct DirectNeighbor *referrer; struct DistantNeighbor *distant; - p2p_dv_MESSAGE_Disconnect *enc_message = (p2p_dv_MESSAGE_Disconnect *)message; + p2p_dv_MESSAGE_Disconnect *enc_message = + (p2p_dv_MESSAGE_Disconnect *) message; if (ntohs (message->size) < sizeof (p2p_dv_MESSAGE_Disconnect)) - { - return GNUNET_SYSERR; /* invalid message */ - } + { + return GNUNET_SYSERR; /* invalid message */ + } referrer = GNUNET_CONTAINER_multihashmap_get (direct_neighbors, &peer->hashPubKey); @@ -2597,15 +2779,15 @@ static int handle_dv_disconnect_message (void *cls, distant = referrer->referee_head; while (distant != NULL) + { + if (distant->referrer_id == ntohl (enc_message->peer_id)) { - if (distant->referrer_id == ntohl(enc_message->peer_id)) - { - distant_neighbor_free(distant); - distant = referrer->referee_head; - } - else - distant = distant->next; + distant_neighbor_free (distant); + distant = referrer->referee_head; } + else + distant = distant->next; + } return GNUNET_OK; } @@ -2623,30 +2805,33 @@ static int handle_dv_disconnect_message (void *cls, * @param message the message * @param atsi performance data */ -static int +static int handle_dv_gossip_message (void *cls, - const struct GNUNET_PeerIdentity *peer, - const struct GNUNET_MessageHeader *message, - const struct GNUNET_TRANSPORT_ATS_Information *atsi) + const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_MessageHeader *message, + const struct GNUNET_TRANSPORT_ATS_Information *atsi) { struct DirectNeighbor *referrer; - p2p_dv_MESSAGE_NeighborInfo *enc_message = (p2p_dv_MESSAGE_NeighborInfo *)message; + p2p_dv_MESSAGE_NeighborInfo *enc_message = + (p2p_dv_MESSAGE_NeighborInfo *) message; if (ntohs (message->size) < sizeof (p2p_dv_MESSAGE_NeighborInfo)) - { - return GNUNET_SYSERR; /* invalid message */ - } + { + return GNUNET_SYSERR; /* invalid message */ + } #if DEBUG_DV_GOSSIP_RECEIPT - char * encPeerAbout; - char * encPeerFrom; + char *encPeerAbout; + char *encPeerFrom; - encPeerAbout = GNUNET_strdup(GNUNET_i2s(&enc_message->neighbor)); - encPeerFrom = GNUNET_strdup(GNUNET_i2s(peer)); + encPeerAbout = GNUNET_strdup (GNUNET_i2s (&enc_message->neighbor)); + encPeerFrom = GNUNET_strdup (GNUNET_i2s (peer)); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "%s: Received %s message from peer %s about peer %s id %u distance %d!\n", GNUNET_i2s(&my_identity), "DV GOSSIP", encPeerFrom, encPeerAbout, ntohl(enc_message->neighbor_id), ntohl (enc_message->cost) + 1); - GNUNET_free(encPeerAbout); - GNUNET_free(encPeerFrom); + "%s: Received %s message from peer %s about peer %s id %u distance %d!\n", + GNUNET_i2s (&my_identity), "DV GOSSIP", encPeerFrom, encPeerAbout, + ntohl (enc_message->neighbor_id), ntohl (enc_message->cost) + 1); + GNUNET_free (encPeerAbout); + GNUNET_free (encPeerFrom); #endif referrer = GNUNET_CONTAINER_multihashmap_get (direct_neighbors, @@ -2673,29 +2858,29 @@ handle_dv_gossip_message (void *cls, * * @return GNUNET_YES to continue iteration, GNUNET_NO otherwise */ -static int -add_all_extended_peers (void *cls, - const GNUNET_HashCode * key, - void *value) +static int +add_all_extended_peers (void *cls, const GNUNET_HashCode * key, void *value) { - struct NeighborSendContext *send_context = (struct NeighborSendContext *)cls; - struct DistantNeighbor *distant = (struct DistantNeighbor *)value; + struct NeighborSendContext *send_context = (struct NeighborSendContext *) cls; + struct DistantNeighbor *distant = (struct DistantNeighbor *) value; struct FastGossipNeighborList *gossip_entry; - if (memcmp(&send_context->toNeighbor->identity, &distant->identity, sizeof(struct GNUNET_PeerIdentity)) == 0) - return GNUNET_YES; /* Don't gossip to a peer about itself! */ + if (memcmp + (&send_context->toNeighbor->identity, &distant->identity, + sizeof (struct GNUNET_PeerIdentity)) == 0) + return GNUNET_YES; /* Don't gossip to a peer about itself! */ #if SUPPORT_HIDING if (distant->hidden == GNUNET_YES) - return GNUNET_YES; /* This peer should not be gossipped about (hidden) */ + return GNUNET_YES; /* This peer should not be gossipped about (hidden) */ #endif - gossip_entry = GNUNET_malloc(sizeof(struct FastGossipNeighborList)); + gossip_entry = GNUNET_malloc (sizeof (struct FastGossipNeighborList)); gossip_entry->about = distant; - GNUNET_CONTAINER_DLL_insert_after(send_context->fast_gossip_list_head, - send_context->fast_gossip_list_tail, - send_context->fast_gossip_list_tail, - gossip_entry); + GNUNET_CONTAINER_DLL_insert_after (send_context->fast_gossip_list_head, + send_context->fast_gossip_list_tail, + send_context->fast_gossip_list_tail, + gossip_entry); return GNUNET_YES; } @@ -2711,19 +2896,21 @@ add_all_extended_peers (void *cls, * iterate, * GNUNET_NO if not. */ -static int +static int gossip_all_to_all_iterator (void *cls, - const GNUNET_HashCode * key, - void *abs_value) + const GNUNET_HashCode * key, void *abs_value) { struct DirectNeighbor *direct = abs_value; - GNUNET_CONTAINER_multihashmap_iterate (extended_neighbors, &add_all_extended_peers, direct->send_context); + GNUNET_CONTAINER_multihashmap_iterate (extended_neighbors, + &add_all_extended_peers, + direct->send_context); if (direct->send_context->task != GNUNET_SCHEDULER_NO_TASK) - GNUNET_SCHEDULER_cancel(direct->send_context->task); + GNUNET_SCHEDULER_cancel (direct->send_context->task); - direct->send_context->task = GNUNET_SCHEDULER_add_now(&neighbor_send_task, direct->send_context); + direct->send_context->task = + GNUNET_SCHEDULER_add_now (&neighbor_send_task, direct->send_context); return GNUNET_YES; } @@ -2734,14 +2921,14 @@ gossip_all_to_all_iterator (void *cls, * @param tc unused */ static void -gossip_all_to_all (void *cls, - const struct GNUNET_SCHEDULER_TaskContext *tc) +gossip_all_to_all (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { - GNUNET_CONTAINER_multihashmap_iterate (direct_neighbors, &gossip_all_to_all_iterator, NULL); + GNUNET_CONTAINER_multihashmap_iterate (direct_neighbors, + &gossip_all_to_all_iterator, NULL); - GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5), - &gossip_all_to_all, - NULL); + GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply + (GNUNET_TIME_UNIT_SECONDS, 5), + &gossip_all_to_all, NULL); } #endif @@ -2756,50 +2943,55 @@ gossip_all_to_all (void *cls, * * @return GNUNET_YES to continue iteration, GNUNET_NO otherwise */ -static int -add_all_direct_neighbors (void *cls, - const GNUNET_HashCode * key, - void *value) +static int +add_all_direct_neighbors (void *cls, const GNUNET_HashCode * key, void *value) { - struct DirectNeighbor *direct = (struct DirectNeighbor *)value; - struct DirectNeighbor *to = (struct DirectNeighbor *)cls; + struct DirectNeighbor *direct = (struct DirectNeighbor *) value; + struct DirectNeighbor *to = (struct DirectNeighbor *) cls; struct DistantNeighbor *distant; struct NeighborSendContext *send_context = direct->send_context; struct FastGossipNeighborList *gossip_entry; char *direct_id; - distant = GNUNET_CONTAINER_multihashmap_get(extended_neighbors, &to->identity.hashPubKey); + distant = + GNUNET_CONTAINER_multihashmap_get (extended_neighbors, + &to->identity.hashPubKey); if (distant == NULL) - { - return GNUNET_YES; - } + { + return GNUNET_YES; + } - if (memcmp(&direct->identity, &to->identity, sizeof(struct GNUNET_PeerIdentity)) == 0) - { - return GNUNET_YES; /* Don't gossip to a peer about itself! */ - } + if (memcmp + (&direct->identity, &to->identity, + sizeof (struct GNUNET_PeerIdentity)) == 0) + { + return GNUNET_YES; /* Don't gossip to a peer about itself! */ + } #if SUPPORT_HIDING if (distant->hidden == GNUNET_YES) - return GNUNET_YES; /* This peer should not be gossipped about (hidden) */ + return GNUNET_YES; /* This peer should not be gossipped about (hidden) */ #endif - direct_id = GNUNET_strdup(GNUNET_i2s(&direct->identity)); + direct_id = GNUNET_strdup (GNUNET_i2s (&direct->identity)); #if DEBUG_DV_GOSSIP - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "%s: adding peer %s to fast send list for %s\n", my_short_id, GNUNET_i2s(&distant->identity), direct_id); + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "%s: adding peer %s to fast send list for %s\n", my_short_id, + GNUNET_i2s (&distant->identity), direct_id); #endif - GNUNET_free(direct_id); - gossip_entry = GNUNET_malloc(sizeof(struct FastGossipNeighborList)); + GNUNET_free (direct_id); + gossip_entry = GNUNET_malloc (sizeof (struct FastGossipNeighborList)); gossip_entry->about = distant; - GNUNET_CONTAINER_DLL_insert_after(send_context->fast_gossip_list_head, - send_context->fast_gossip_list_tail, - send_context->fast_gossip_list_tail, - gossip_entry); + GNUNET_CONTAINER_DLL_insert_after (send_context->fast_gossip_list_head, + send_context->fast_gossip_list_tail, + send_context->fast_gossip_list_tail, + gossip_entry); if (send_context->task != GNUNET_SCHEDULER_NO_TASK) - GNUNET_SCHEDULER_cancel(send_context->task); + GNUNET_SCHEDULER_cancel (send_context->task); - send_context->task = GNUNET_SCHEDULER_add_now(&neighbor_send_task, send_context); + send_context->task = + GNUNET_SCHEDULER_add_now (&neighbor_send_task, send_context); //tc.reason = GNUNET_SCHEDULER_REASON_TIMEOUT; //neighbor_send_task(send_context, &tc); return GNUNET_YES; @@ -2817,73 +3009,97 @@ add_all_direct_neighbors (void *cls, static void process_peerinfo (void *cls, const struct GNUNET_PeerIdentity *peer, - const struct GNUNET_HELLO_Message *hello, - const char *err_msg) + const struct GNUNET_HELLO_Message *hello, const char *err_msg) { struct PeerIteratorContext *peerinfo_iterator = cls; struct DirectNeighbor *neighbor = peerinfo_iterator->neighbor; struct DistantNeighbor *distant = peerinfo_iterator->distant; + #if DEBUG_DV_PEER_NUMBERS char *neighbor_pid; #endif int sent; + if (err_msg != NULL) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - _("Error in communication with PEERINFO service\n")); - /* return; */ + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + _("Error in communication with PEERINFO service\n")); + /* return; */ } if (peer == NULL) + { + if (distant->pkey == NULL) { - if (distant->pkey == NULL) - { #if DEBUG_DV - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Failed to get peerinfo information for this peer, retrying!\n"); -#endif - peerinfo_iterator->ic = GNUNET_PEERINFO_iterate(peerinfo_handle, - &peerinfo_iterator->neighbor->identity, - GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 3), - &process_peerinfo, - peerinfo_iterator); - } - else - { - GNUNET_free(peerinfo_iterator); - } - return; + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "Failed to get peerinfo information for this peer, retrying!\n"); +#endif + peerinfo_iterator->ic = GNUNET_PEERINFO_iterate (peerinfo_handle, + &peerinfo_iterator->neighbor-> + identity, + GNUNET_TIME_relative_multiply + (GNUNET_TIME_UNIT_SECONDS, + 3), &process_peerinfo, + peerinfo_iterator); } + else + { + GNUNET_free (peerinfo_iterator); + } + return; + } - if (memcmp(&neighbor->identity, peer, sizeof(struct GNUNET_PeerIdentity) != 0)) + if (memcmp + (&neighbor->identity, peer, sizeof (struct GNUNET_PeerIdentity) != 0)) return; - if ((hello != NULL) && (GNUNET_HELLO_get_key (hello, &neighbor->pkey) == GNUNET_OK)) + if ((hello != NULL) && + (GNUNET_HELLO_get_key (hello, &neighbor->pkey) == GNUNET_OK)) + { + if (distant->pkey == NULL) { - if (distant->pkey == NULL) - { - distant->pkey = GNUNET_malloc(sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)); - memcpy(distant->pkey, &neighbor->pkey, sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)); - } + distant->pkey = + GNUNET_malloc (sizeof + (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)); + memcpy (distant->pkey, &neighbor->pkey, + sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)); + } - sent = GNUNET_CONTAINER_multihashmap_iterate (extended_neighbors, &add_all_extended_peers, neighbor->send_context); - if (stats != NULL) - { - GNUNET_STATISTICS_update (stats, "# distant peers gossiped to direct neighbors", sent, GNUNET_NO); - } + sent = + GNUNET_CONTAINER_multihashmap_iterate (extended_neighbors, + &add_all_extended_peers, + neighbor->send_context); + if (stats != NULL) + { + GNUNET_STATISTICS_update (stats, + "# distant peers gossiped to direct neighbors", + sent, GNUNET_NO); + } #if DEBUG_DV_PEER_NUMBERS - neighbor_pid = GNUNET_strdup(GNUNET_i2s(&neighbor->identity)); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s: Gossipped %d extended peers to %s\n", GNUNET_i2s(&my_identity), sent, neighbor_pid); -#endif - sent = GNUNET_CONTAINER_multihashmap_iterate (direct_neighbors, &add_all_direct_neighbors, neighbor); - if (stats != NULL) - { - GNUNET_STATISTICS_update (stats, "# direct peers gossiped to direct neighbors", sent, GNUNET_NO); - } + neighbor_pid = GNUNET_strdup (GNUNET_i2s (&neighbor->identity)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "%s: Gossipped %d extended peers to %s\n", + GNUNET_i2s (&my_identity), sent, neighbor_pid); +#endif + sent = + GNUNET_CONTAINER_multihashmap_iterate (direct_neighbors, + &add_all_direct_neighbors, + neighbor); + if (stats != NULL) + { + GNUNET_STATISTICS_update (stats, + "# direct peers gossiped to direct neighbors", + sent, GNUNET_NO); + } #if DEBUG_DV_PEER_NUMBERS - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s: Gossipped about %s to %d direct peers\n", GNUNET_i2s(&my_identity), neighbor_pid, sent); - GNUNET_free(neighbor_pid); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "%s: Gossipped about %s to %d direct peers\n", + GNUNET_i2s (&my_identity), neighbor_pid, sent); + GNUNET_free (neighbor_pid); #endif - neighbor->send_context->task = GNUNET_SCHEDULER_add_now(&neighbor_send_task, neighbor->send_context); - } + neighbor->send_context->task = + GNUNET_SCHEDULER_add_now (&neighbor_send_task, neighbor->send_context); + } } @@ -2894,10 +3110,10 @@ process_peerinfo (void *cls, * @param peer peer identity this notification is about * @param atsi performance data */ -static void +static void handle_core_connect (void *cls, - const struct GNUNET_PeerIdentity * peer, - const struct GNUNET_TRANSPORT_ATS_Information *atsi) + const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_TRANSPORT_ATS_Information *atsi) { struct DirectNeighbor *neighbor; struct DistantNeighbor *about; @@ -2907,54 +3123,69 @@ handle_core_connect (void *cls, uint32_t distance; /* Check for connect to self message */ - if (0 == memcmp(&my_identity, peer, sizeof(struct GNUNET_PeerIdentity))) + if (0 == memcmp (&my_identity, peer, sizeof (struct GNUNET_PeerIdentity))) return; distance = get_atsi_distance (atsi); if ((distance == DIRECT_NEIGHBOR_COST) && - (GNUNET_CONTAINER_multihashmap_get(direct_neighbors, &peer->hashPubKey) == NULL)) + (GNUNET_CONTAINER_multihashmap_get (direct_neighbors, &peer->hashPubKey) + == NULL)) { - peerinfo_iterator = GNUNET_malloc(sizeof(struct PeerIteratorContext)); + peerinfo_iterator = GNUNET_malloc (sizeof (struct PeerIteratorContext)); neighbor = GNUNET_malloc (sizeof (struct DirectNeighbor)); - neighbor->send_context = GNUNET_malloc(sizeof(struct NeighborSendContext)); + neighbor->send_context = + GNUNET_malloc (sizeof (struct NeighborSendContext)); neighbor->send_context->toNeighbor = neighbor; memcpy (&neighbor->identity, peer, sizeof (struct GNUNET_PeerIdentity)); - GNUNET_assert(GNUNET_SYSERR != GNUNET_CONTAINER_multihashmap_put (direct_neighbors, - &peer->hashPubKey, - neighbor, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); + GNUNET_assert (GNUNET_SYSERR != + GNUNET_CONTAINER_multihashmap_put (direct_neighbors, + &peer->hashPubKey, + neighbor, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); about = addUpdateNeighbor (peer, NULL, 0, neighbor, DIRECT_NEIGHBOR_COST); peerinfo_iterator->distant = about; peerinfo_iterator->neighbor = neighbor; peerinfo_iterator->ic = GNUNET_PEERINFO_iterate (peerinfo_handle, peer, - GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 3), - &process_peerinfo, + GNUNET_TIME_relative_multiply + (GNUNET_TIME_UNIT_SECONDS, + 3), &process_peerinfo, peerinfo_iterator); if ((about != NULL) && (about->pkey == NULL)) - { + { #if DEBUG_DV - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Newly added peer %s has NULL pkey!\n", GNUNET_i2s(peer)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Newly added peer %s has NULL pkey!\n", GNUNET_i2s (peer)); #endif - } + } else if (about != NULL) - { - GNUNET_free(peerinfo_iterator); - } + { + GNUNET_free (peerinfo_iterator); + } } else { - about = GNUNET_CONTAINER_multihashmap_get(extended_neighbors, &peer->hashPubKey); - if ((GNUNET_CONTAINER_multihashmap_get(direct_neighbors, &peer->hashPubKey) == NULL) && (about != NULL)) - { - sent = GNUNET_CONTAINER_multihashmap_iterate(direct_neighbors, &add_distant_all_direct_neighbors, about); - if (stats != NULL) - GNUNET_STATISTICS_update (stats, "# direct peers gossiped to new direct neighbors", sent, GNUNET_NO); - } + about = + GNUNET_CONTAINER_multihashmap_get (extended_neighbors, + &peer->hashPubKey); + if ((GNUNET_CONTAINER_multihashmap_get (direct_neighbors, &peer->hashPubKey) + == NULL) && (about != NULL)) + { + sent = + GNUNET_CONTAINER_multihashmap_iterate (direct_neighbors, + &add_distant_all_direct_neighbors, + about); + if (stats != NULL) + GNUNET_STATISTICS_update (stats, + "# direct peers gossiped to new direct neighbors", + sent, GNUNET_NO); + } #if DEBUG_DV GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "%s: Distance (%d) greater than %d or already know about peer (%s), not re-adding!\n", "dv", distance, DIRECT_NEIGHBOR_COST, GNUNET_i2s(peer)); + "%s: Distance (%d) greater than %d or already know about peer (%s), not re-adding!\n", + "dv", distance, DIRECT_NEIGHBOR_COST, GNUNET_i2s (peer)); #endif return; } @@ -2966,8 +3197,8 @@ handle_core_connect (void *cls, * @param cls closure * @param peer peer identity this notification is about */ -void handle_core_disconnect (void *cls, - const struct GNUNET_PeerIdentity * peer) +void +handle_core_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer) { struct DirectNeighbor *neighbor; struct DistantNeighbor *referee; @@ -2981,28 +3212,31 @@ void handle_core_disconnect (void *cls, #endif /* Check for disconnect from self message */ - if (0 == memcmp(&my_identity, peer, sizeof(struct GNUNET_PeerIdentity))) + if (0 == memcmp (&my_identity, peer, sizeof (struct GNUNET_PeerIdentity))) return; neighbor = - GNUNET_CONTAINER_multihashmap_get (direct_neighbors, &peer->hashPubKey); + GNUNET_CONTAINER_multihashmap_get (direct_neighbors, &peer->hashPubKey); if (neighbor == NULL) - { - return; - } + { + return; + } pending_pos = core_pending_head; while (NULL != pending_pos) + { + if (0 == + memcmp (&pending_pos->recipient, &neighbor->identity, + sizeof (struct GNUNET_PeerIdentity))) { - if (0 == memcmp(&pending_pos->recipient, &neighbor->identity, sizeof(struct GNUNET_PeerIdentity))) - { - GNUNET_CONTAINER_DLL_remove(core_pending_head, core_pending_tail, pending_pos); - pending_pos = core_pending_head; - } - else - pending_pos = pending_pos->next; + GNUNET_CONTAINER_DLL_remove (core_pending_head, core_pending_tail, + pending_pos); + pending_pos = core_pending_head; } + else + pending_pos = pending_pos->next; + } while (NULL != (referee = neighbor->referee_head)) distant_neighbor_free (referee); @@ -3010,24 +3244,28 @@ void handle_core_disconnect (void *cls, fdc.dest = NULL; fdc.tid = 0; - GNUNET_CONTAINER_multihashmap_iterate (extended_neighbors, &find_distant_peer, &fdc); + GNUNET_CONTAINER_multihashmap_iterate (extended_neighbors, &find_distant_peer, + &fdc); if (fdc.dest != NULL) - { - disconnect_context.direct = neighbor; - disconnect_context.distant = fdc.dest; - GNUNET_CONTAINER_multihashmap_iterate (direct_neighbors, &schedule_disconnect_messages, &disconnect_context); - } + { + disconnect_context.direct = neighbor; + disconnect_context.distant = fdc.dest; + GNUNET_CONTAINER_multihashmap_iterate (direct_neighbors, + &schedule_disconnect_messages, + &disconnect_context); + } GNUNET_assert (neighbor->referee_tail == NULL); if (GNUNET_NO == GNUNET_CONTAINER_multihashmap_remove (direct_neighbors, - &peer->hashPubKey, neighbor)) - { - GNUNET_break(0); - } + &peer->hashPubKey, + neighbor)) + { + GNUNET_break (0); + } if ((neighbor->send_context != NULL) && (neighbor->send_context->task != GNUNET_SCHEDULER_NO_TASK)) - GNUNET_SCHEDULER_cancel(neighbor->send_context->task); + GNUNET_SCHEDULER_cancel (neighbor->send_context->task); GNUNET_free (neighbor); } @@ -3045,6 +3283,7 @@ run (void *cls, const struct GNUNET_CONFIGURATION_Handle *c) { unsigned long long max_hosts; + cfg = c; /* FIXME: Read from config, or calculate, or something other than this! */ @@ -3052,58 +3291,59 @@ run (void *cls, max_table_size = DEFAULT_DV_SIZE; fisheye_depth = DEFAULT_FISHEYE_DEPTH; - if (GNUNET_CONFIGURATION_have_value(cfg, "dv", "max_direct_connections")) - GNUNET_assert(GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, "dv", "max_direct_connections", &max_hosts)); + if (GNUNET_CONFIGURATION_have_value (cfg, "dv", "max_direct_connections")) + GNUNET_assert (GNUNET_OK == + GNUNET_CONFIGURATION_get_value_number (cfg, "dv", + "max_direct_connections", + &max_hosts)); - if (GNUNET_CONFIGURATION_have_value(cfg, "dv", "max_total_connections")) - GNUNET_assert(GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, "dv", "max_total_connections", &max_table_size)); + if (GNUNET_CONFIGURATION_have_value (cfg, "dv", "max_total_connections")) + GNUNET_assert (GNUNET_OK == + GNUNET_CONFIGURATION_get_value_number (cfg, "dv", + "max_total_connections", + &max_table_size)); - if (GNUNET_CONFIGURATION_have_value(cfg, "dv", "fisheye_depth")) - GNUNET_assert(GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, "dv", "fisheye_depth", &fisheye_depth)); + if (GNUNET_CONFIGURATION_have_value (cfg, "dv", "fisheye_depth")) + GNUNET_assert (GNUNET_OK == + GNUNET_CONFIGURATION_get_value_number (cfg, "dv", + "fisheye_depth", + &fisheye_depth)); neighbor_min_heap = - GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN); + GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN); neighbor_max_heap = - GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MAX); + GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MAX); direct_neighbors = GNUNET_CONTAINER_multihashmap_create (max_hosts); extended_neighbors = - GNUNET_CONTAINER_multihashmap_create (max_table_size * 3); + GNUNET_CONTAINER_multihashmap_create (max_table_size * 3); GNUNET_SERVER_add_handlers (server, plugin_handlers); - coreAPI = - GNUNET_CORE_connect (cfg, - 1, - NULL, /* FIXME: anything we want to pass around? */ - &core_init, - &handle_core_connect, - &handle_core_disconnect, - NULL, - NULL, - GNUNET_NO, - NULL, - GNUNET_NO, - core_handlers); + coreAPI = GNUNET_CORE_connect (cfg, 1, NULL, /* FIXME: anything we want to pass around? */ + &core_init, + &handle_core_connect, + &handle_core_disconnect, + NULL, + NULL, + GNUNET_NO, NULL, GNUNET_NO, core_handlers); if (coreAPI == NULL) return; - coreMST = GNUNET_SERVER_mst_create (&tokenized_message_handler, - NULL); + coreMST = GNUNET_SERVER_mst_create (&tokenized_message_handler, NULL); - peerinfo_handle = GNUNET_PEERINFO_connect(cfg); + peerinfo_handle = GNUNET_PEERINFO_connect (cfg); - if (peerinfo_handle == NULL) - { - GNUNET_CORE_disconnect(coreAPI); - return; - } + if (peerinfo_handle == NULL) + { + GNUNET_CORE_disconnect (coreAPI); + return; + } /* Scheduled the task to clean up when shutdown is called */ cleanup_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, - &shutdown_task, - NULL); + &shutdown_task, NULL); } @@ -3121,6 +3361,5 @@ main (int argc, char *const *argv) GNUNET_SERVICE_run (argc, argv, "dv", - GNUNET_SERVICE_OPTION_NONE, - &run, NULL)) ? 0 : 1; + GNUNET_SERVICE_OPTION_NONE, &run, NULL)) ? 0 : 1; } diff --git a/src/dv/plugin_transport_dv.c b/src/dv/plugin_transport_dv.c index 697ca0c4c..2803e347e 100644 --- a/src/dv/plugin_transport_dv.c +++ b/src/dv/plugin_transport_dv.c @@ -144,38 +144,40 @@ struct Plugin /** * Handler for messages received from the DV service. */ -void handle_dv_message_received (void *cls, - struct GNUNET_PeerIdentity *sender, - char *msg, - size_t msg_len, - uint32_t distance, - char *sender_address, - size_t sender_address_len) +void +handle_dv_message_received (void *cls, + struct GNUNET_PeerIdentity *sender, + char *msg, + size_t msg_len, + uint32_t distance, + char *sender_address, size_t sender_address_len) { struct Plugin *plugin = cls; + #if DEBUG_DV_MESSAGES char *my_id; - my_id = GNUNET_strdup(GNUNET_i2s(plugin->env->my_identity)); + + my_id = GNUNET_strdup (GNUNET_i2s (plugin->env->my_identity)); GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "plugin_transport_dv", _("%s Received message from %s of type %d, distance %u!\n"), - my_id, GNUNET_i2s(sender), ntohs(((struct GNUNET_MessageHeader *)msg)->type), distance); - GNUNET_free_non_null(my_id); + my_id, GNUNET_i2s (sender), + ntohs (((struct GNUNET_MessageHeader *) msg)->type), + distance); + GNUNET_free_non_null (my_id); #endif struct GNUNET_TRANSPORT_ATS_Information ats[2]; + ats[0].type = htonl (GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE); ats[0].value = htonl (distance); ats[1].type = htonl (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR); ats[1].value = htonl (0); - plugin->env->receive(plugin->env->cls, - sender, - (struct GNUNET_MessageHeader *)msg, - (const struct GNUNET_TRANSPORT_ATS_Information *) &ats, - 2, - NULL, - sender_address, - sender_address_len); + plugin->env->receive (plugin->env->cls, + sender, + (struct GNUNET_MessageHeader *) msg, + (const struct GNUNET_TRANSPORT_ATS_Information *) &ats, + 2, NULL, sender_address, sender_address_len); } @@ -218,26 +220,20 @@ dv_plugin_send (void *cls, size_t msgbuf_size, unsigned int priority, struct GNUNET_TIME_Relative timeout, - struct Session *session, + struct Session *session, const void *addr, size_t addrlen, int force_address, - GNUNET_TRANSPORT_TransmitContinuation - cont, void *cont_cls) + GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls) { int ret = 0; struct Plugin *plugin = cls; - ret = GNUNET_DV_send(plugin->dv_handle, - target, - msgbuf, - msgbuf_size, - priority, - timeout, - addr, - addrlen, - cont, - cont_cls); + ret = GNUNET_DV_send (plugin->dv_handle, + target, + msgbuf, + msgbuf_size, + priority, timeout, addr, addrlen, cont, cont_cls); return ret; } @@ -252,8 +248,7 @@ dv_plugin_send (void *cls, * @param target peer from which to disconnect */ static void -dv_plugin_disconnect (void *cls, - const struct GNUNET_PeerIdentity *target) +dv_plugin_disconnect (void *cls, const struct GNUNET_PeerIdentity *target) { // struct Plugin *plugin = cls; // TODO: Add message type to send to dv service to "disconnect" a peer @@ -287,23 +282,28 @@ dv_plugin_address_pretty_printer (void *cls, char *dest_peer; char *via_peer; char *print_string; - char *addr_buf = (char *)addr; + char *addr_buf = (char *) addr; - if (addrlen != sizeof(struct GNUNET_PeerIdentity) * 2) - { - asc (asc_cls, NULL); - } + if (addrlen != sizeof (struct GNUNET_PeerIdentity) * 2) + { + asc (asc_cls, NULL); + } else - { - dest_peer = GNUNET_strdup(GNUNET_i2s((struct GNUNET_PeerIdentity *)addr)); - via_peer = GNUNET_strdup(GNUNET_i2s((struct GNUNET_PeerIdentity *)&addr_buf[sizeof(struct GNUNET_PeerIdentity)])); - GNUNET_asprintf(&print_string, "DV Peer `%s' via peer`%s'", dest_peer, via_peer); - asc (asc_cls, print_string); - asc (asc_cls, NULL); - GNUNET_free(via_peer); - GNUNET_free(dest_peer); - GNUNET_free(print_string); - } + { + dest_peer = + GNUNET_strdup (GNUNET_i2s ((struct GNUNET_PeerIdentity *) addr)); + via_peer = + GNUNET_strdup (GNUNET_i2s + ((struct GNUNET_PeerIdentity *) + &addr_buf[sizeof (struct GNUNET_PeerIdentity)])); + GNUNET_asprintf (&print_string, "DV Peer `%s' via peer`%s'", dest_peer, + via_peer); + asc (asc_cls, print_string); + asc (asc_cls, NULL); + GNUNET_free (via_peer); + GNUNET_free (dest_peer); + GNUNET_free (print_string); + } } /** @@ -315,9 +315,8 @@ dv_plugin_address_pretty_printer (void *cls, * * @return string representing the DV address */ -static const char *address_to_string (void *cls, - const void *addr, - size_t addrlen) +static const char * +address_to_string (void *cls, const void *addr, size_t addrlen) { static char return_buffer[2 * 4 + 2]; // Two four character peer identity prefixes a ':' and '\0' @@ -325,23 +324,22 @@ static const char *address_to_string (void *cls, struct GNUNET_CRYPTO_HashAsciiEncoded via_hash; struct GNUNET_PeerIdentity *peer; struct GNUNET_PeerIdentity *via; - char *addr_buf = (char *)addr; + char *addr_buf = (char *) addr; - if (addrlen == (2 * sizeof(struct GNUNET_PeerIdentity))) - { - peer = (struct GNUNET_PeerIdentity *)addr_buf; - via = (struct GNUNET_PeerIdentity *)&addr_buf[sizeof(struct GNUNET_PeerIdentity)]; - - GNUNET_CRYPTO_hash_to_enc (&peer->hashPubKey, &peer_hash); - peer_hash.encoding[4] = '\0'; - GNUNET_CRYPTO_hash_to_enc (&via->hashPubKey, &via_hash); - via_hash.encoding[4] = '\0'; - GNUNET_snprintf (return_buffer, - sizeof (return_buffer), - "%s:%s", - &peer_hash, - &via_hash); - } + if (addrlen == (2 * sizeof (struct GNUNET_PeerIdentity))) + { + peer = (struct GNUNET_PeerIdentity *) addr_buf; + via = + (struct GNUNET_PeerIdentity *) + &addr_buf[sizeof (struct GNUNET_PeerIdentity)]; + + GNUNET_CRYPTO_hash_to_enc (&peer->hashPubKey, &peer_hash); + peer_hash.encoding[4] = '\0'; + GNUNET_CRYPTO_hash_to_enc (&via->hashPubKey, &via_hash); + via_hash.encoding[4] = '\0'; + GNUNET_snprintf (return_buffer, + sizeof (return_buffer), "%s:%s", &peer_hash, &via_hash); + } else return NULL; @@ -365,17 +363,23 @@ static const char *address_to_string (void *cls, * */ static int -dv_plugin_check_address (void *cls, - const void *addr, size_t addrlen) +dv_plugin_check_address (void *cls, const void *addr, size_t addrlen) { struct Plugin *plugin = cls; + /* Verify that the first peer of this address matches our peer id! */ - if ((addrlen != (2 * sizeof(struct GNUNET_PeerIdentity))) || (0 != memcmp(addr, plugin->env->my_identity, sizeof(struct GNUNET_PeerIdentity)))) + if ((addrlen != (2 * sizeof (struct GNUNET_PeerIdentity))) || + (0 != + memcmp (addr, plugin->env->my_identity, + sizeof (struct GNUNET_PeerIdentity)))) { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s: Address not correct size or identity doesn't match ours!\n", GNUNET_i2s(plugin->env->my_identity)); - if (addrlen == (2 * sizeof(struct GNUNET_PeerIdentity))) + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "%s: Address not correct size or identity doesn't match ours!\n", + GNUNET_i2s (plugin->env->my_identity)); + if (addrlen == (2 * sizeof (struct GNUNET_PeerIdentity))) { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Peer in address is %s\n", GNUNET_i2s(addr)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer in address is %s\n", + GNUNET_i2s (addr)); } return GNUNET_SYSERR; } @@ -396,11 +400,12 @@ libgnunet_plugin_transport_dv_init (void *cls) plugin = GNUNET_malloc (sizeof (struct Plugin)); plugin->env = env; - plugin->dv_handle = GNUNET_DV_connect(env->cfg, &handle_dv_message_received, plugin); + plugin->dv_handle = + GNUNET_DV_connect (env->cfg, &handle_dv_message_received, plugin); if (plugin->dv_handle == NULL) { - GNUNET_free(plugin); + GNUNET_free (plugin); return NULL; } @@ -425,7 +430,7 @@ libgnunet_plugin_transport_dv_done (void *cls) struct Plugin *plugin = api->cls; if (plugin->dv_handle != NULL) - GNUNET_DV_disconnect(plugin->dv_handle); + GNUNET_DV_disconnect (plugin->dv_handle); GNUNET_free (plugin); GNUNET_free (api); diff --git a/src/dv/test_transport_api_dv.c b/src/dv/test_transport_api_dv.c index 8b42c4311..5d9d367e1 100644 --- a/src/dv/test_transport_api_dv.c +++ b/src/dv/test_transport_api_dv.c @@ -93,11 +93,12 @@ static int transmit_ready_called; static enum GNUNET_TESTING_Topology topology; -static enum GNUNET_TESTING_Topology blacklist_topology = GNUNET_TESTING_TOPOLOGY_NONE; /* Don't do any blacklisting */ +static enum GNUNET_TESTING_Topology blacklist_topology = GNUNET_TESTING_TOPOLOGY_NONE; /* Don't do any blacklisting */ static enum GNUNET_TESTING_Topology connection_topology = GNUNET_TESTING_TOPOLOGY_NONE; /* NONE actually means connect all allowed peers */ -static enum GNUNET_TESTING_TopologyOption connect_topology_option = GNUNET_TESTING_TOPOLOGY_OPTION_ALL; +static enum GNUNET_TESTING_TopologyOption connect_topology_option = + GNUNET_TESTING_TOPOLOGY_OPTION_ALL; static double connect_topology_option_modifier = 0.0; @@ -167,25 +168,23 @@ static struct TestMessageContext *other_test_messages; /** * Check whether peers successfully shut down. */ -void shutdown_callback (void *cls, - const char *emsg) +void +shutdown_callback (void *cls, const char *emsg) { if (emsg != NULL) - { + { #if VERBOSE - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Shutdown of peers failed!\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutdown of peers failed!\n"); #endif - if (ok == 0) - ok = 666; - } + if (ok == 0) + ok = 666; + } else - { + { #if VERBOSE - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "All peers successfully shut down!\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "All peers successfully shut down!\n"); #endif - } + } } static void @@ -203,100 +202,102 @@ finish_testing () #endif peer_pos = all_peers; while (peer_pos != NULL) - { - if (peer_pos->peer_handle != NULL) - GNUNET_CORE_disconnect(peer_pos->peer_handle); - free_peer_pos = peer_pos; - peer_pos = peer_pos->next; - GNUNET_free(free_peer_pos); - } + { + if (peer_pos->peer_handle != NULL) + GNUNET_CORE_disconnect (peer_pos->peer_handle); + free_peer_pos = peer_pos; + peer_pos = peer_pos->next; + GNUNET_free (free_peer_pos); + } all_peers = NULL; pos = test_messages; while (pos != NULL) + { + if (pos->peer1handle != NULL) { - if (pos->peer1handle != NULL) - { - GNUNET_CORE_disconnect(pos->peer1handle); - pos->peer1handle = NULL; - } - if (pos->peer2handle != NULL) - { - GNUNET_CORE_disconnect(pos->peer2handle); - pos->peer2handle = NULL; - } - free_pos = pos; - pos = pos->next; - if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK) - { - GNUNET_SCHEDULER_cancel(free_pos->disconnect_task); - } - GNUNET_free(free_pos); + GNUNET_CORE_disconnect (pos->peer1handle); + pos->peer1handle = NULL; } + if (pos->peer2handle != NULL) + { + GNUNET_CORE_disconnect (pos->peer2handle); + pos->peer2handle = NULL; + } + free_pos = pos; + pos = pos->next; + if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK) + { + GNUNET_SCHEDULER_cancel (free_pos->disconnect_task); + } + GNUNET_free (free_pos); + } pos = other_test_messages; while (pos != NULL) + { + if (pos->peer1handle != NULL) + { + GNUNET_CORE_disconnect (pos->peer1handle); + pos->peer1handle = NULL; + } + if (pos->peer2handle != NULL) + { + GNUNET_CORE_disconnect (pos->peer2handle); + pos->peer2handle = NULL; + } + free_pos = pos; + pos = pos->next; + if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK) { - if (pos->peer1handle != NULL) - { - GNUNET_CORE_disconnect(pos->peer1handle); - pos->peer1handle = NULL; - } - if (pos->peer2handle != NULL) - { - GNUNET_CORE_disconnect(pos->peer2handle); - pos->peer2handle = NULL; - } - free_pos = pos; - pos = pos->next; - if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK) - { - GNUNET_SCHEDULER_cancel(free_pos->disconnect_task); - } - GNUNET_free(free_pos); + GNUNET_SCHEDULER_cancel (free_pos->disconnect_task); } + GNUNET_free (free_pos); + } #if VERBOSE - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "transmit_ready's scheduled %d, failed %d, transmit_ready's called %d\n", transmit_ready_scheduled, transmit_ready_failed, transmit_ready_called); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "transmit_ready's scheduled %d, failed %d, transmit_ready's called %d\n", + transmit_ready_scheduled, transmit_ready_failed, + transmit_ready_called); #endif #if VERBOSE - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Calling daemons_stop\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Calling daemons_stop\n"); #endif GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL); #if VERBOSE - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "daemons_stop finished\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "daemons_stop finished\n"); #endif if (dotOutFile != NULL) - { - fprintf(dotOutFile, "}"); - fclose(dotOutFile); - } + { + fprintf (dotOutFile, "}"); + fclose (dotOutFile); + } ok = 0; } static void -disconnect_cores (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) +disconnect_cores (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { struct TestMessageContext *pos = cls; /* Disconnect from the respective cores */ #if VERBOSE GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Disconnecting from peer 1 `%4s'\n", GNUNET_i2s (&pos->peer1->id)); + "Disconnecting from peer 1 `%4s'\n", + GNUNET_i2s (&pos->peer1->id)); #endif if (pos->peer1handle != NULL) - GNUNET_CORE_disconnect(pos->peer1handle); + GNUNET_CORE_disconnect (pos->peer1handle); #if VERBOSE GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Disconnecting from peer 2 `%4s'\n", GNUNET_i2s (&pos->peer2->id)); + "Disconnecting from peer 2 `%4s'\n", + GNUNET_i2s (&pos->peer2->id)); #endif if (pos->peer2handle != NULL) - GNUNET_CORE_disconnect(pos->peer2handle); + GNUNET_CORE_disconnect (pos->peer2handle); /* Set handles to NULL so test case can be ended properly */ pos->peer1handle = NULL; pos->peer2handle = NULL; @@ -306,84 +307,85 @@ disconnect_cores (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) } static void -end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) +end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { char *msg = cls; + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "End badly was called (%s)... stopping daemons.\n", msg); struct TestMessageContext *pos; struct TestMessageContext *free_pos; - struct PeerContext * peer_pos; - struct PeerContext * free_peer_pos; + struct PeerContext *peer_pos; + struct PeerContext *free_peer_pos; peer_pos = all_peers; while (peer_pos != NULL) - { - if (peer_pos->peer_handle != NULL) - GNUNET_CORE_disconnect(peer_pos->peer_handle); - free_peer_pos = peer_pos; - peer_pos = peer_pos->next; - GNUNET_free(free_peer_pos); - } + { + if (peer_pos->peer_handle != NULL) + GNUNET_CORE_disconnect (peer_pos->peer_handle); + free_peer_pos = peer_pos; + peer_pos = peer_pos->next; + GNUNET_free (free_peer_pos); + } all_peers = NULL; pos = test_messages; while (pos != NULL) + { + if (pos->peer1handle != NULL) { - if (pos->peer1handle != NULL) - { - GNUNET_CORE_disconnect(pos->peer1handle); - pos->peer1handle = NULL; - } - if (pos->peer2handle != NULL) - { - GNUNET_CORE_disconnect(pos->peer2handle); - pos->peer2handle = NULL; - } - free_pos = pos; - pos = pos->next; - GNUNET_free(free_pos); + GNUNET_CORE_disconnect (pos->peer1handle); + pos->peer1handle = NULL; } + if (pos->peer2handle != NULL) + { + GNUNET_CORE_disconnect (pos->peer2handle); + pos->peer2handle = NULL; + } + free_pos = pos; + pos = pos->next; + GNUNET_free (free_pos); + } pos = other_test_messages; while (pos != NULL) + { + if (pos->peer1handle != NULL) { - if (pos->peer1handle != NULL) - { - GNUNET_CORE_disconnect(pos->peer1handle); - pos->peer1handle = NULL; - } - if (pos->peer2handle != NULL) - { - GNUNET_CORE_disconnect(pos->peer2handle); - pos->peer2handle = NULL; - } - free_pos = pos; - pos = pos->next; - if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK) - { - GNUNET_SCHEDULER_cancel(free_pos->disconnect_task); - } - GNUNET_free(free_pos); + GNUNET_CORE_disconnect (pos->peer1handle); + pos->peer1handle = NULL; } - - if (pg != NULL) + if (pos->peer2handle != NULL) + { + GNUNET_CORE_disconnect (pos->peer2handle); + pos->peer2handle = NULL; + } + free_pos = pos; + pos = pos->next; + if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK) { - GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL); - ok = 7331; /* Opposite of leet */ + GNUNET_SCHEDULER_cancel (free_pos->disconnect_task); } + GNUNET_free (free_pos); + } + + if (pg != NULL) + { + GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL); + ok = 7331; /* Opposite of leet */ + } else ok = 401; /* Never got peers started */ if (dotOutFile != NULL) - { - fprintf(dotOutFile, "}"); - fclose(dotOutFile); - } + { + fprintf (dotOutFile, "}"); + fclose (dotOutFile); + } } static void -send_other_messages (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc); +send_other_messages (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc); /** * Get distance information from 'atsi'. @@ -394,15 +396,15 @@ send_other_messages (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc); static uint32_t get_atsi_distance (const struct GNUNET_TRANSPORT_ATS_Information *atsi) { - while ( (ntohl (atsi->type) != GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR) && - (ntohl (atsi->type) != GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE) ) + while ((ntohl (atsi->type) != GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR) && + (ntohl (atsi->type) != GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE)) atsi++; if (ntohl (atsi->type) == GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR) - { - GNUNET_break (0); - /* FIXME: we do not have distance data? Assume direct neighbor. */ - return 1; - } + { + GNUNET_break (0); + /* FIXME: we do not have distance data? Assume direct neighbor. */ + return 1; + } return ntohl (atsi->value); } @@ -413,62 +415,74 @@ process_mtype (void *cls, const struct GNUNET_TRANSPORT_ATS_Information *atsi) { struct TestMessageContext *pos = cls; - struct GNUNET_TestMessage *msg = (struct GNUNET_TestMessage *)message; + struct GNUNET_TestMessage *msg = (struct GNUNET_TestMessage *) message; + #if VERBOSE uint32_t distance; #endif - if (pos->uid != ntohl(msg->uid)) + if (pos->uid != ntohl (msg->uid)) return GNUNET_OK; #if VERBOSE - distance = get_atsi_distance(atsi); + distance = get_atsi_distance (atsi); #endif - GNUNET_assert(0 == memcmp(peer, &pos->peer1->id, sizeof(struct GNUNET_PeerIdentity))); + GNUNET_assert (0 == + memcmp (peer, &pos->peer1->id, + sizeof (struct GNUNET_PeerIdentity))); if (total_other_expected_messages == 0) - { - total_messages_received++; + { + total_messages_received++; #if VERBOSE - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Received message from `%4s', type %d, uid %u, distance %u.\n", GNUNET_i2s (peer), ntohs(message->type), ntohl(msg->uid), distance); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Total messages received %d, expected %d.\n", total_messages_received, expected_messages); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received message from `%4s', type %d, uid %u, distance %u.\n", + GNUNET_i2s (peer), ntohs (message->type), ntohl (msg->uid), + distance); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Total messages received %d, expected %d.\n", + total_messages_received, expected_messages); #endif - } + } else - { - total_other_messages++; + { + total_other_messages++; #if VERBOSE - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Received message from `%4s', type %d, uid %u, distance %u.\n", GNUNET_i2s (peer), ntohs(message->type), ntohl(msg->uid), distance); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Total messages received %d, expected %d.\n", total_other_messages, total_other_expected_messages); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received message from `%4s', type %d, uid %u, distance %u.\n", + GNUNET_i2s (peer), ntohs (message->type), ntohl (msg->uid), + distance); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Total messages received %d, expected %d.\n", + total_other_messages, total_other_expected_messages); #endif - } - - if ((total_messages_received == expected_messages) && (total_other_messages == 0)) - { - GNUNET_SCHEDULER_cancel (die_task); - die_task = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT, - &end_badly, "waiting for DV peers to connect!"); - /* - if ((num_peers == 3) && (total_other_expected_messages == 2)) - { - GNUNET_SCHEDULER_add_now (&send_other_messages, NULL); - } - else - { - GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 20), &send_other_messages, NULL); - }*/ - } - else if ((total_other_expected_messages > 0) && (total_other_messages == total_other_expected_messages)) - { - GNUNET_SCHEDULER_cancel (die_task); - GNUNET_SCHEDULER_add_now (&finish_testing, NULL); - } + } + + if ((total_messages_received == expected_messages) && + (total_other_messages == 0)) + { + GNUNET_SCHEDULER_cancel (die_task); + die_task = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT, + &end_badly, + "waiting for DV peers to connect!"); + /* + * if ((num_peers == 3) && (total_other_expected_messages == 2)) + * { + * GNUNET_SCHEDULER_add_now (&send_other_messages, NULL); + * } + * else + * { + * GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 20), &send_other_messages, NULL); + * } */ + } + else if ((total_other_expected_messages > 0) && + (total_other_messages == total_other_expected_messages)) + { + GNUNET_SCHEDULER_cancel (die_task); + GNUNET_SCHEDULER_add_now (&finish_testing, NULL); + } else - { - pos->disconnect_task = GNUNET_SCHEDULER_add_now(&disconnect_cores, pos); - } + { + pos->disconnect_task = GNUNET_SCHEDULER_add_now (&disconnect_cores, pos); + } return GNUNET_OK; } @@ -483,11 +497,13 @@ transmit_ready (void *cls, size_t size, void *buf) m = (struct GNUNET_TestMessage *) buf; m->header.type = htons (MTYPE); m->header.size = htons (sizeof (struct GNUNET_TestMessage)); - m->uid = htonl(pos->uid); + m->uid = htonl (pos->uid); transmit_ready_called++; #if VERBOSE GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "transmit ready for peer %s\ntransmit_ready's scheduled %d, transmit_ready's called %d\n", GNUNET_i2s(&pos->peer1->id), transmit_ready_scheduled, transmit_ready_called); + "transmit ready for peer %s\ntransmit_ready's scheduled %d, transmit_ready's called %d\n", + GNUNET_i2s (&pos->peer1->id), transmit_ready_scheduled, + transmit_ready_called); #endif return sizeof (struct GNUNET_TestMessage); } @@ -510,47 +526,50 @@ static struct GNUNET_CORE_MessageHandler handlers[] = { * @param peer peer identity this notification is about * @param atsi performance data for the connection */ -static void connect_notify_peer2 (void *cls, - const struct - GNUNET_PeerIdentity *peer, - const struct GNUNET_TRANSPORT_ATS_Information *atsi) +static void +connect_notify_peer2 (void *cls, + const struct + GNUNET_PeerIdentity *peer, + const struct GNUNET_TRANSPORT_ATS_Information *atsi) { struct TestMessageContext *pos = cls; - if (0 == memcmp(&pos->peer1->id, peer, sizeof(struct GNUNET_PeerIdentity))) - { + if (0 == memcmp (&pos->peer1->id, peer, sizeof (struct GNUNET_PeerIdentity))) + { #if VERBOSE - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Core connection from `%s' to `%4s' verfied, sending message!\n", - GNUNET_i2s(&pos->peer2->id), GNUNET_h2s (&peer->hashPubKey)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Core connection from `%s' to `%4s' verfied, sending message!\n", + GNUNET_i2s (&pos->peer2->id), GNUNET_h2s (&peer->hashPubKey)); #endif - if (NULL == GNUNET_CORE_notify_transmit_ready (pos->peer1handle, - GNUNET_YES, - 0, - TIMEOUT, - &pos->peer2->id, - sizeof (struct GNUNET_TestMessage), - &transmit_ready, pos)) - { - /* This probably shouldn't happen, but it does (timing issue?) */ - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, - "RECEIVED NULL when asking core (1) for transmission to peer `%4s'\n", - GNUNET_i2s (&pos->peer2->id)); - transmit_ready_failed++; - total_other_expected_messages--; - } - else - { - transmit_ready_scheduled++; - } + if (NULL == GNUNET_CORE_notify_transmit_ready (pos->peer1handle, + GNUNET_YES, + 0, + TIMEOUT, + &pos->peer2->id, + sizeof (struct + GNUNET_TestMessage), + &transmit_ready, pos)) + { + /* This probably shouldn't happen, but it does (timing issue?) */ + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "RECEIVED NULL when asking core (1) for transmission to peer `%4s'\n", + GNUNET_i2s (&pos->peer2->id)); + transmit_ready_failed++; + total_other_expected_messages--; } + else + { + transmit_ready_scheduled++; + } + } } static void init_notify_peer2 (void *cls, struct GNUNET_CORE_Handle *server, const struct GNUNET_PeerIdentity *my_identity, - const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *publicKey) + const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded + *publicKey) { #if VERBOSE GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, @@ -568,39 +587,42 @@ init_notify_peer2 (void *cls, * @param peer peer identity this notification is about * @param atsi performance data for the connection */ -static void connect_notify_peer1 (void *cls, - const struct - GNUNET_PeerIdentity *peer, - const struct GNUNET_TRANSPORT_ATS_Information *atsi) +static void +connect_notify_peer1 (void *cls, + const struct + GNUNET_PeerIdentity *peer, + const struct GNUNET_TRANSPORT_ATS_Information *atsi) { struct TestMessageContext *pos = cls; - if (0 == memcmp(&pos->peer2->id, peer, sizeof(struct GNUNET_PeerIdentity))) - { + if (0 == memcmp (&pos->peer2->id, peer, sizeof (struct GNUNET_PeerIdentity))) + { #if VERBOSE - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Core connection from `%s' to `%4s' verified.\n", - GNUNET_i2s(&pos->peer1->id), GNUNET_h2s (&peer->hashPubKey)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Core connection from `%s' to `%4s' verified.\n", + GNUNET_i2s (&pos->peer1->id), GNUNET_h2s (&peer->hashPubKey)); #endif - /* - * Connect to the receiving peer - */ - pos->peer2handle = GNUNET_CORE_connect (pos->peer2->cfg, - 1, - pos, - &init_notify_peer2, - &connect_notify_peer2, - NULL, - NULL, NULL, - GNUNET_YES, NULL, GNUNET_YES, handlers); - } + /* + * Connect to the receiving peer + */ + pos->peer2handle = GNUNET_CORE_connect (pos->peer2->cfg, + 1, + pos, + &init_notify_peer2, + &connect_notify_peer2, + NULL, + NULL, NULL, + GNUNET_YES, NULL, GNUNET_YES, + handlers); + } } static void init_notify_peer1 (void *cls, struct GNUNET_CORE_Handle *server, const struct GNUNET_PeerIdentity *my_identity, - const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *publicKey) + const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded + *publicKey) { total_server_connections++; #if VERBOSE @@ -612,129 +634,142 @@ init_notify_peer1 (void *cls, static void -send_test_messages (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) +send_test_messages (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { struct TestMessageContext *pos = cls; - if (( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0) || (cls == NULL)) + if (((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0) || (cls == NULL)) return; if (die_task == GNUNET_SCHEDULER_NO_TASK) - { - die_task = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT, - &end_badly, "from create topology (timeout)"); - } + { + die_task = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT, + &end_badly, + "from create topology (timeout)"); + } if (total_server_connections >= MAX_OUTSTANDING_CONNECTIONS) - { - GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1), - &send_test_messages, pos); - return; /* Otherwise we'll double schedule messages here! */ - } + { + GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply + (GNUNET_TIME_UNIT_SECONDS, 1), + &send_test_messages, pos); + return; /* Otherwise we'll double schedule messages here! */ + } #if VERBOSE - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Attempting to send test message from %s to %s\n", pos->peer1->shortname, pos->peer2->shortname); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Attempting to send test message from %s to %s\n", + pos->peer1->shortname, pos->peer2->shortname); #endif /* * Connect to the sending peer */ pos->peer1handle = GNUNET_CORE_connect (pos->peer1->cfg, - 1, + 1, pos, &init_notify_peer1, &connect_notify_peer1, NULL, NULL, NULL, - GNUNET_NO, NULL, GNUNET_NO, no_handlers); + GNUNET_NO, NULL, GNUNET_NO, + no_handlers); - GNUNET_assert(pos->peer1handle != NULL); + GNUNET_assert (pos->peer1handle != NULL); if (total_server_connections < MAX_OUTSTANDING_CONNECTIONS) - { - GNUNET_SCHEDULER_add_now (&send_test_messages, pos->next); - } + { + GNUNET_SCHEDULER_add_now (&send_test_messages, pos->next); + } else - { - GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1), - &send_test_messages, pos->next); - } + { + GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply + (GNUNET_TIME_UNIT_SECONDS, 1), + &send_test_messages, pos->next); + } } static void -send_other_messages (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) +send_other_messages (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { struct TestMessageContext *pos; struct TestMessageContext *free_pos; struct PeerContext *peer_pos; + #if TEST_ALL struct PeerContext *inner_peer_pos; struct TestMessageContext *temp_context; #endif peer_pos = all_peers; while (peer_pos != NULL) + { + if (peer_pos->peer_handle != NULL) { - if (peer_pos->peer_handle != NULL) - { - GNUNET_CORE_disconnect(peer_pos->peer_handle); - peer_pos->peer_handle = NULL; - } + GNUNET_CORE_disconnect (peer_pos->peer_handle); + peer_pos->peer_handle = NULL; + } #if TEST_ALL - inner_peer_pos = all_peers; - while (inner_peer_pos != NULL) - { - if (inner_peer_pos != peer_pos) - { - temp_total_other_messages++; - temp_context = GNUNET_malloc(sizeof(struct TestMessageContext)); - temp_context->peer1 = peer_pos->daemon; - temp_context->peer2 = inner_peer_pos->daemon; - temp_context->next = other_test_messages; - temp_context->uid = total_connections + temp_total_other_messages; - temp_context->disconnect_task = GNUNET_SCHEDULER_NO_TASK; - other_test_messages = temp_context; - } - inner_peer_pos = inner_peer_pos->next; - } -#endif - peer_pos = peer_pos->next; + inner_peer_pos = all_peers; + while (inner_peer_pos != NULL) + { + if (inner_peer_pos != peer_pos) + { + temp_total_other_messages++; + temp_context = GNUNET_malloc (sizeof (struct TestMessageContext)); + temp_context->peer1 = peer_pos->daemon; + temp_context->peer2 = inner_peer_pos->daemon; + temp_context->next = other_test_messages; + temp_context->uid = total_connections + temp_total_other_messages; + temp_context->disconnect_task = GNUNET_SCHEDULER_NO_TASK; + other_test_messages = temp_context; + } + inner_peer_pos = inner_peer_pos->next; } +#endif + peer_pos = peer_pos->next; + } all_peers = NULL; pos = test_messages; while (pos != NULL) + { + if (pos->peer1handle != NULL) + { + GNUNET_CORE_disconnect (pos->peer1handle); + pos->peer1handle = NULL; + } + if (pos->peer2handle != NULL) { - if (pos->peer1handle != NULL) - { - GNUNET_CORE_disconnect(pos->peer1handle); - pos->peer1handle = NULL; - } - if (pos->peer2handle != NULL) - { - GNUNET_CORE_disconnect(pos->peer2handle); - pos->peer2handle = NULL; - } - free_pos = pos; - pos = pos->next; - if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK) - { - GNUNET_SCHEDULER_cancel(free_pos->disconnect_task); - } - GNUNET_free(free_pos); + GNUNET_CORE_disconnect (pos->peer2handle); + pos->peer2handle = NULL; } + free_pos = pos; + pos = pos->next; + if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK) + { + GNUNET_SCHEDULER_cancel (free_pos->disconnect_task); + } + GNUNET_free (free_pos); + } test_messages = NULL; total_other_expected_messages = temp_total_other_messages; if (total_other_expected_messages == 0) - { - GNUNET_SCHEDULER_add_now (&end_badly, "send_other_messages had 0 messages to send, no DV connections made!"); - } + { + GNUNET_SCHEDULER_add_now (&end_badly, + "send_other_messages had 0 messages to send, no DV connections made!"); + } #if VERBOSE - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Preparing to send %d other test messages\n", total_other_expected_messages); + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "Preparing to send %d other test messages\n", + total_other_expected_messages); #endif GNUNET_SCHEDULER_add_now (&send_test_messages, other_test_messages); - GNUNET_SCHEDULER_cancel(die_task); - die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 250), &end_badly, "from send_other_messages"); + GNUNET_SCHEDULER_cancel (die_task); + die_task = + GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply + (GNUNET_TIME_UNIT_SECONDS, 250), &end_badly, + "from send_other_messages"); } static void @@ -749,68 +784,73 @@ topology_callback (void *cls, const char *emsg) { struct TestMessageContext *temp_context; + if (emsg == NULL) - { - total_connections++; + { + total_connections++; #if VERBOSE - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "connected peer %s to peer %s, distance %u\n", - first_daemon->shortname, - second_daemon->shortname, - distance); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "connected peer %s to peer %s, distance %u\n", + first_daemon->shortname, second_daemon->shortname, distance); #endif - temp_context = GNUNET_malloc(sizeof(struct TestMessageContext)); - temp_context->peer1 = first_daemon; - temp_context->peer2 = second_daemon; - temp_context->next = test_messages; - temp_context->uid = total_connections; - temp_context->disconnect_task = GNUNET_SCHEDULER_NO_TASK; - test_messages = temp_context; - expected_messages++; - } + temp_context = GNUNET_malloc (sizeof (struct TestMessageContext)); + temp_context->peer1 = first_daemon; + temp_context->peer2 = second_daemon; + temp_context->next = test_messages; + temp_context->uid = total_connections; + temp_context->disconnect_task = GNUNET_SCHEDULER_NO_TASK; + test_messages = temp_context; + expected_messages++; + } #if VERBOSE else - { - failed_connections++; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed to connect peer %s to peer %s with error :\n%s\n", - first_daemon->shortname, - second_daemon->shortname, emsg); - } + { + failed_connections++; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Failed to connect peer %s to peer %s with error :\n%s\n", + first_daemon->shortname, second_daemon->shortname, emsg); + } #endif if (total_connections == expected_connections) - { + { #if VERBOSE - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Created %u total connections, which is our target number! Calling send messages.\n", - total_connections); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Created %u total connections, which is our target number! Calling send messages.\n", + total_connections); #endif + GNUNET_SCHEDULER_cancel (die_task); + die_task = GNUNET_SCHEDULER_NO_TASK; + GNUNET_SCHEDULER_add_now (&send_test_messages, test_messages); + } + else if (total_connections + failed_connections == expected_connections) + { + if (failed_connections < + (unsigned int) (fail_percentage * total_connections)) + { GNUNET_SCHEDULER_cancel (die_task); die_task = GNUNET_SCHEDULER_NO_TASK; GNUNET_SCHEDULER_add_now (&send_test_messages, test_messages); } - else if (total_connections + failed_connections == expected_connections) + else { - if (failed_connections < (unsigned int)(fail_percentage * total_connections)) - { - GNUNET_SCHEDULER_cancel (die_task); - die_task = GNUNET_SCHEDULER_NO_TASK; - GNUNET_SCHEDULER_add_now (&send_test_messages, test_messages); - } - else - { - GNUNET_SCHEDULER_cancel (die_task); - die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from topology_callback (too many failed connections)"); - } + GNUNET_SCHEDULER_cancel (die_task); + die_task = + GNUNET_SCHEDULER_add_now (&end_badly, + "from topology_callback (too many failed connections)"); } + } else - { + { #if VERBOSE - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Have %d total connections, %d failed connections, Want %d (at least %d)\n", - total_connections, failed_connections, expected_connections, expected_connections - (unsigned int)(fail_percentage * expected_connections)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Have %d total connections, %d failed connections, Want %d (at least %d)\n", + total_connections, failed_connections, expected_connections, + expected_connections - + (unsigned int) (fail_percentage * expected_connections)); #endif - } + } } static void @@ -818,50 +858,56 @@ connect_topology () { expected_connections = -1; if ((pg != NULL) && (peers_left == 0)) - { - expected_connections = GNUNET_TESTING_connect_topology (pg, - connection_topology, - connect_topology_option, - connect_topology_option_modifier, - TIMEOUT, - 12, - NULL, NULL); + { + expected_connections = GNUNET_TESTING_connect_topology (pg, + connection_topology, + connect_topology_option, + connect_topology_option_modifier, + TIMEOUT, + 12, NULL, NULL); #if VERBOSE - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Have %d expected connections\n", expected_connections); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Have %d expected connections\n", expected_connections); #endif - } + } GNUNET_SCHEDULER_cancel (die_task); if (expected_connections == GNUNET_SYSERR) - { - die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from connect topology (bad return)"); - } + { + die_task = + GNUNET_SCHEDULER_add_now (&end_badly, + "from connect topology (bad return)"); + } die_task = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT, - &end_badly, "from connect topology (timeout)"); + &end_badly, + "from connect topology (timeout)"); } static void create_topology () { - peers_left = num_peers; /* Reset counter */ - if (GNUNET_TESTING_create_topology (pg, topology, blacklist_topology, blacklist_transports) != GNUNET_SYSERR) - { + peers_left = num_peers; /* Reset counter */ + if (GNUNET_TESTING_create_topology + (pg, topology, blacklist_topology, blacklist_transports) != GNUNET_SYSERR) + { #if VERBOSE - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Topology set up, now starting peers!\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Topology set up, now starting peers!\n"); #endif - GNUNET_TESTING_daemons_continue_startup(pg); - } + GNUNET_TESTING_daemons_continue_startup (pg); + } else - { - GNUNET_SCHEDULER_cancel (die_task); - die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from create topology (bad return)"); - } + { + GNUNET_SCHEDULER_cancel (die_task); + die_task = + GNUNET_SCHEDULER_add_now (&end_badly, + "from create topology (bad return)"); + } GNUNET_SCHEDULER_cancel (die_task); die_task = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT, - &end_badly, "from continue startup (timeout)"); + &end_badly, + "from continue startup (timeout)"); } /** @@ -872,126 +918,134 @@ create_topology () * @param latency reported latency of the connection with 'other' * @param distance reported distance (DV) to 'other' */ -static void all_connect_handler (void *cls, - const struct - GNUNET_PeerIdentity * peer, - const struct GNUNET_TRANSPORT_ATS_Information *atsi) +static void +all_connect_handler (void *cls, + const struct + GNUNET_PeerIdentity *peer, + const struct GNUNET_TRANSPORT_ATS_Information *atsi) { struct GNUNET_TESTING_Daemon *d = cls; struct GNUNET_TESTING_Daemon *second_daemon; char *second_shortname; + #if !TEST_ALL struct TestMessageContext *temp_context; #endif uint32_t distance; - if (0 == memcmp(&d->id, peer, sizeof(struct GNUNET_PeerIdentity))) + if (0 == memcmp (&d->id, peer, sizeof (struct GNUNET_PeerIdentity))) return; - second_shortname = GNUNET_strdup (GNUNET_i2s(peer)); - distance = get_atsi_distance(atsi); + second_shortname = GNUNET_strdup (GNUNET_i2s (peer)); + distance = get_atsi_distance (atsi); #if VERBOSE - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "connected peer %s to peer %s, distance %u\n", - d->shortname, - second_shortname, - distance); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "connected peer %s to peer %s, distance %u\n", + d->shortname, second_shortname, distance); #endif - second_daemon = GNUNET_CONTAINER_multihashmap_get(peer_daemon_hash, &peer->hashPubKey); + second_daemon = + GNUNET_CONTAINER_multihashmap_get (peer_daemon_hash, &peer->hashPubKey); if (second_daemon == NULL) - { - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, - "Couldn't find second peer!\n"); - GNUNET_free(second_shortname); - return; - } + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Couldn't find second peer!\n"); + GNUNET_free (second_shortname); + return; + } #if !TEST_ALL if (distance > 1) - { - temp_total_other_messages++; - temp_context = GNUNET_malloc(sizeof(struct TestMessageContext)); - temp_context->peer1 = d; - temp_context->peer2 = second_daemon; - temp_context->next = other_test_messages; - temp_context->uid = total_connections + temp_total_other_messages; - temp_context->disconnect_task = GNUNET_SCHEDULER_NO_TASK; - other_test_messages = temp_context; - } + { + temp_total_other_messages++; + temp_context = GNUNET_malloc (sizeof (struct TestMessageContext)); + temp_context->peer1 = d; + temp_context->peer2 = second_daemon; + temp_context->next = other_test_messages; + temp_context->uid = total_connections + temp_total_other_messages; + temp_context->disconnect_task = GNUNET_SCHEDULER_NO_TASK; + other_test_messages = temp_context; + } #endif if (dotOutFile != NULL) - { - if (distance == 1) - fprintf(dotOutFile, "\tn%s -- n%s;\n", d->shortname, second_shortname); - else if (distance == 2) - fprintf(dotOutFile, "\tn%s -- n%s [color=blue];\n", d->shortname, second_shortname); - else if (distance == 3) - fprintf(dotOutFile, "\tn%s -- n%s [color=red];\n", d->shortname, second_shortname); - else if (distance == 4) - fprintf(dotOutFile, "\tn%s -- n%s [color=green];\n", d->shortname, second_shortname); - else - fprintf(dotOutFile, "\tn%s -- n%s [color=brown];\n", d->shortname, second_shortname); - } - GNUNET_free(second_shortname); + { + if (distance == 1) + fprintf (dotOutFile, "\tn%s -- n%s;\n", d->shortname, second_shortname); + else if (distance == 2) + fprintf (dotOutFile, "\tn%s -- n%s [color=blue];\n", d->shortname, + second_shortname); + else if (distance == 3) + fprintf (dotOutFile, "\tn%s -- n%s [color=red];\n", d->shortname, + second_shortname); + else if (distance == 4) + fprintf (dotOutFile, "\tn%s -- n%s [color=green];\n", d->shortname, + second_shortname); + else + fprintf (dotOutFile, "\tn%s -- n%s [color=brown];\n", d->shortname, + second_shortname); + } + GNUNET_free (second_shortname); if (temp_total_other_messages == num_additional_messages) - { - GNUNET_SCHEDULER_add_now (&send_other_messages, NULL); - } + { + GNUNET_SCHEDULER_add_now (&send_other_messages, NULL); + } } static void peers_started_callback (void *cls, - const struct GNUNET_PeerIdentity *id, - const struct GNUNET_CONFIGURATION_Handle *cfg, - struct GNUNET_TESTING_Daemon *d, const char *emsg) + const struct GNUNET_PeerIdentity *id, + const struct GNUNET_CONFIGURATION_Handle *cfg, + struct GNUNET_TESTING_Daemon *d, const char *emsg) { struct PeerContext *new_peer; + if (emsg != NULL) - { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed to start daemon with error: `%s'\n", - emsg); - return; - } + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Failed to start daemon with error: `%s'\n", emsg); + return; + } GNUNET_assert (id != NULL); #if VERBOSE GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Started daemon %llu out of %llu\n", (num_peers - peers_left) + 1, num_peers); #endif - GNUNET_assert(GNUNET_SYSERR != GNUNET_CONTAINER_multihashmap_put(peer_daemon_hash, &id->hashPubKey, d, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); - - new_peer = GNUNET_malloc(sizeof(struct PeerContext)); - new_peer->peer_handle = GNUNET_CORE_connect(cfg, - 1, - d, NULL, - &all_connect_handler, - NULL, NULL, NULL, - GNUNET_NO, NULL, GNUNET_NO, - no_handlers); + GNUNET_assert (GNUNET_SYSERR != + GNUNET_CONTAINER_multihashmap_put (peer_daemon_hash, + &id->hashPubKey, d, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); + + new_peer = GNUNET_malloc (sizeof (struct PeerContext)); + new_peer->peer_handle = GNUNET_CORE_connect (cfg, + 1, + d, NULL, + &all_connect_handler, + NULL, NULL, NULL, + GNUNET_NO, NULL, GNUNET_NO, + no_handlers); new_peer->daemon = d; new_peer->next = all_peers; all_peers = new_peer; peers_left--; if (peers_left == 0) - { + { #if VERBOSE - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "All %d daemons started, now creating topology!\n", - num_peers); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "All %d daemons started, now creating topology!\n", num_peers); #endif - GNUNET_SCHEDULER_cancel (die_task); - /* Set up task in case topology creation doesn't finish - * within a reasonable amount of time */ - die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply - (GNUNET_TIME_UNIT_MINUTES, 5), - &end_badly, "from peers_started_callback"); - - connect_topology (); - ok = 0; - } + GNUNET_SCHEDULER_cancel (die_task); + /* Set up task in case topology creation doesn't finish + * within a reasonable amount of time */ + die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply + (GNUNET_TIME_UNIT_MINUTES, 5), + &end_badly, + "from peers_started_callback"); + + connect_topology (); + ok = 0; + } } /** @@ -1004,37 +1058,36 @@ peers_started_callback (void *cls, */ static void hostkey_callback (void *cls, - const struct GNUNET_PeerIdentity *id, - struct GNUNET_TESTING_Daemon *d, - const char *emsg) + const struct GNUNET_PeerIdentity *id, + struct GNUNET_TESTING_Daemon *d, const char *emsg) { if (emsg != NULL) - { - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Hostkey callback received error: %s\n", emsg); - } + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "Hostkey callback received error: %s\n", emsg); + } #if VERBOSE - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Hostkey created for peer `%s'\n", - GNUNET_i2s(id)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Hostkey created for peer `%s'\n", GNUNET_i2s (id)); #endif - peers_left--; - if (peers_left == 0) - { + peers_left--; + if (peers_left == 0) + { #if VERBOSE - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "All %d hostkeys created, now creating topology!\n", - num_peers); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "All %d hostkeys created, now creating topology!\n", num_peers); #endif - GNUNET_SCHEDULER_cancel (die_task); - /* Set up task in case topology creation doesn't finish - * within a reasonable amount of time */ - die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply - (GNUNET_TIME_UNIT_MINUTES, 5), - &end_badly, "from hostkey_callback"); - GNUNET_SCHEDULER_add_now(&create_topology, NULL); - ok = 0; - } + GNUNET_SCHEDULER_cancel (die_task); + /* Set up task in case topology creation doesn't finish + * within a reasonable amount of time */ + die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply + (GNUNET_TIME_UNIT_MINUTES, 5), + &end_badly, + "from hostkey_callback"); + GNUNET_SCHEDULER_add_now (&create_topology, NULL); + ok = 0; + } } static void @@ -1042,117 +1095,141 @@ run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg) { - char * topology_str; - char * connect_topology_str; - char * blacklist_topology_str; - char * connect_topology_option_str; - char * connect_topology_option_modifier_string; + char *topology_str; + char *connect_topology_str; + char *blacklist_topology_str; + char *connect_topology_option_str; + char *connect_topology_option_modifier_string; + ok = 1; dotOutFile = fopen (dotOutFileName, "w"); if (dotOutFile != NULL) - { - fprintf (dotOutFile, "strict graph G {\n"); - } + { + fprintf (dotOutFile, "strict graph G {\n"); + } #if VERBOSE GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting daemons based on config file %s\n", cfgfile); #endif - if (GNUNET_YES != GNUNET_CONFIGURATION_get_value_string(cfg, "paths", "servicehome", &test_directory)) - { - ok = 404; - return; - } + if (GNUNET_YES != + GNUNET_CONFIGURATION_get_value_string (cfg, "paths", "servicehome", + &test_directory)) + { + ok = 404; + return; + } if ((GNUNET_YES == - GNUNET_CONFIGURATION_get_value_string(cfg, "testing", "topology", - &topology_str)) && (GNUNET_NO == GNUNET_TESTING_topology_get(&topology, topology_str))) - { - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, - "Invalid topology `%s' given for section %s option %s\n", topology_str, "TESTING", "TOPOLOGY"); - topology = GNUNET_TESTING_TOPOLOGY_CLIQUE; /* Defaults to NONE, so set better default here */ - } + GNUNET_CONFIGURATION_get_value_string (cfg, "testing", "topology", + &topology_str)) && + (GNUNET_NO == GNUNET_TESTING_topology_get (&topology, topology_str))) + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "Invalid topology `%s' given for section %s option %s\n", + topology_str, "TESTING", "TOPOLOGY"); + topology = GNUNET_TESTING_TOPOLOGY_CLIQUE; /* Defaults to NONE, so set better default here */ + } if ((GNUNET_YES == - GNUNET_CONFIGURATION_get_value_string(cfg, "testing", "connect_topology", - &connect_topology_str)) && (GNUNET_NO == GNUNET_TESTING_topology_get(&connection_topology, connect_topology_str))) - { - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, - "Invalid connect topology `%s' given for section %s option %s\n", connect_topology_str, "TESTING", "CONNECT_TOPOLOGY"); - } - GNUNET_free_non_null(connect_topology_str); + GNUNET_CONFIGURATION_get_value_string (cfg, "testing", + "connect_topology", + &connect_topology_str)) && + (GNUNET_NO == + GNUNET_TESTING_topology_get (&connection_topology, + connect_topology_str))) + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "Invalid connect topology `%s' given for section %s option %s\n", + connect_topology_str, "TESTING", "CONNECT_TOPOLOGY"); + } + GNUNET_free_non_null (connect_topology_str); if ((GNUNET_YES == - GNUNET_CONFIGURATION_get_value_string(cfg, "testing", "connect_topology_option", - &connect_topology_option_str)) && (GNUNET_NO == GNUNET_TESTING_topology_option_get(&connect_topology_option, connect_topology_option_str))) - { - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, - "Invalid connect topology option `%s' given for section %s option %s\n", connect_topology_option_str, "TESTING", "CONNECT_TOPOLOGY_OPTION"); - connect_topology_option = GNUNET_TESTING_TOPOLOGY_OPTION_ALL; /* Defaults to NONE, set to ALL */ - } - GNUNET_free_non_null(connect_topology_option_str); + GNUNET_CONFIGURATION_get_value_string (cfg, "testing", + "connect_topology_option", + &connect_topology_option_str)) && + (GNUNET_NO == + GNUNET_TESTING_topology_option_get (&connect_topology_option, + connect_topology_option_str))) + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "Invalid connect topology option `%s' given for section %s option %s\n", + connect_topology_option_str, "TESTING", + "CONNECT_TOPOLOGY_OPTION"); + connect_topology_option = GNUNET_TESTING_TOPOLOGY_OPTION_ALL; /* Defaults to NONE, set to ALL */ + } + GNUNET_free_non_null (connect_topology_option_str); if (GNUNET_YES == - GNUNET_CONFIGURATION_get_value_string (cfg, "testing", "connect_topology_option_modifier", - &connect_topology_option_modifier_string)) + GNUNET_CONFIGURATION_get_value_string (cfg, "testing", + "connect_topology_option_modifier", + &connect_topology_option_modifier_string)) + { + if (sscanf + (connect_topology_option_modifier_string, "%lf", + &connect_topology_option_modifier) != 1) { - if (sscanf(connect_topology_option_modifier_string, "%lf", &connect_topology_option_modifier) != 1) - { - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, - _("Invalid value `%s' for option `%s' in section `%s': expected float\n"), - connect_topology_option_modifier_string, - "connect_topology_option_modifier", - "TESTING"); - } - GNUNET_free (connect_topology_option_modifier_string); + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + _ + ("Invalid value `%s' for option `%s' in section `%s': expected float\n"), + connect_topology_option_modifier_string, + "connect_topology_option_modifier", "TESTING"); } + GNUNET_free (connect_topology_option_modifier_string); + } - if (GNUNET_YES != GNUNET_CONFIGURATION_get_value_string (cfg, "testing", "blacklist_transports", - &blacklist_transports)) + if (GNUNET_YES != + GNUNET_CONFIGURATION_get_value_string (cfg, "testing", + "blacklist_transports", + &blacklist_transports)) blacklist_transports = NULL; if ((GNUNET_YES == - GNUNET_CONFIGURATION_get_value_string(cfg, "testing", "blacklist_topology", - &blacklist_topology_str)) && (GNUNET_NO == GNUNET_TESTING_topology_get(&blacklist_topology, blacklist_topology_str))) - { - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, - "Invalid topology `%s' given for section %s option %s\n", topology_str, "TESTING", "BLACKLIST_TOPOLOGY"); - } - GNUNET_free_non_null(topology_str); - GNUNET_free_non_null(blacklist_topology_str); + GNUNET_CONFIGURATION_get_value_string (cfg, "testing", + "blacklist_topology", + &blacklist_topology_str)) && + (GNUNET_NO == + GNUNET_TESTING_topology_get (&blacklist_topology, + blacklist_topology_str))) + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "Invalid topology `%s' given for section %s option %s\n", + topology_str, "TESTING", "BLACKLIST_TOPOLOGY"); + } + GNUNET_free_non_null (topology_str); + GNUNET_free_non_null (blacklist_topology_str); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg, "testing", "num_peers", &num_peers)) num_peers = DEFAULT_NUM_PEERS; if (GNUNET_SYSERR == - GNUNET_CONFIGURATION_get_value_number (cfg, "testing", "additional_messages", + GNUNET_CONFIGURATION_get_value_number (cfg, "testing", + "additional_messages", &num_additional_messages)) num_additional_messages = DEFAULT_ADDITIONAL_MESSAGES; main_cfg = cfg; - GNUNET_assert(num_peers > 0 && num_peers < (unsigned int)-1); + GNUNET_assert (num_peers > 0 && num_peers < (unsigned int) -1); peers_left = num_peers; /* Set up a task to end testing if peer start fails */ die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5), - &end_badly, "didn't start all daemons in reasonable amount of time!!!"); + &end_badly, + "didn't start all daemons in reasonable amount of time!!!"); - peer_daemon_hash = GNUNET_CONTAINER_multihashmap_create(peers_left); - pg = GNUNET_TESTING_daemons_start (cfg, - peers_left, /* Total number of peers */ - peers_left, /* Number of outstanding connections */ - peers_left, /* Number of parallel ssh connections, or peers being started at once */ + peer_daemon_hash = GNUNET_CONTAINER_multihashmap_create (peers_left); + pg = GNUNET_TESTING_daemons_start (cfg, peers_left, /* Total number of peers */ + peers_left, /* Number of outstanding connections */ + peers_left, /* Number of parallel ssh connections, or peers being started at once */ TIMEOUT, &hostkey_callback, NULL, &peers_started_callback, - NULL, - &topology_callback, - NULL, - NULL); + NULL, &topology_callback, NULL, NULL); } @@ -1160,7 +1237,8 @@ static int check () { int ret; - char *const argv[] = {"test-transport-dv", + + char *const argv[] = { "test-transport-dv", "-c", "test_transport_dv_data.conf", #if VERBOSE @@ -1172,12 +1250,13 @@ check () GNUNET_GETOPT_OPTION_END }; ret = GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, - argv, "test-transport-dv", "nohelp", - options, &run, &ok); + argv, "test-transport-dv", "nohelp", + options, &run, &ok); if (ret != GNUNET_OK) - { - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "`test-transport-dv': Failed with error code %d\n", ret); - } + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "`test-transport-dv': Failed with error code %d\n", ret); + } return ok; } @@ -1199,9 +1278,10 @@ main (int argc, char *argv[]) * of by the testing framework. */ if (GNUNET_DISK_directory_remove (test_directory) != GNUNET_OK) - { - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Failed to remove testing directory %s\n", test_directory); - } + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "Failed to remove testing directory %s\n", test_directory); + } return ret; } -- cgit v1.2.3