From 54c98ba960690442aaf982e7a39045ad42d67547 Mon Sep 17 00:00:00 2001 From: Matthias Wachs Date: Sun, 29 Dec 2013 17:08:38 +0000 Subject: fixing file indent --- .../gnunet-service-transport_manipulation.c | 997 ++++++++++----------- 1 file changed, 487 insertions(+), 510 deletions(-) (limited to 'src/transport/gnunet-service-transport_manipulation.c') diff --git a/src/transport/gnunet-service-transport_manipulation.c b/src/transport/gnunet-service-transport_manipulation.c index 0d087c3bd..4521047c9 100644 --- a/src/transport/gnunet-service-transport_manipulation.c +++ b/src/transport/gnunet-service-transport_manipulation.c @@ -1,22 +1,22 @@ /* - This file is part of GNUnet. - (C) 2010-2013 Christian Grothoff (and other contributing authors) - - GNUnet is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published - by the Free Software Foundation; either version 3, or (at your - option) any later version. - - GNUnet is distributed in the hope that it will be useful, but - WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - General Public License for more details. - - You should have received a copy of the GNU General Public License - along with GNUnet; see the file COPYING. If not, write to the - Free Software Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. -*/ + This file is part of GNUnet. + (C) 2010-2013 Christian Grothoff (and other contributing authors) + + GNUnet is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation; either version 3, or (at your + option) any later version. + + GNUnet is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GNUnet; see the file COPYING. If not, write to the + Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. + */ /** * @file transport/gnunet-service-transport_manipulation.c @@ -36,12 +36,9 @@ enum TRAFFIC_METRIC_DIRECTION { - TM_SEND = 0, - TM_RECEIVE = 1, - TM_BOTH = 2 + TM_SEND = 0, TM_RECEIVE = 1, TM_BOTH = 2 }; - /** * Struct containing information about manipulations to a specific peer */ @@ -52,25 +49,25 @@ struct TM_Peer; */ struct PropManipulationEntry { - /** - * Next in DLL - */ - struct PropManipulationEntry *next; - - /** - * Previous in DLL - */ - struct PropManipulationEntry *prev; - - /** - * ATS type in HBO - */ - uint32_t type; - - /** - * Value in HBO - */ - uint32_t metrics[TM_BOTH]; + /** + * Next in DLL + */ + struct PropManipulationEntry *next; + + /** + * Previous in DLL + */ + struct PropManipulationEntry *prev; + + /** + * ATS type in HBO + */ + uint32_t type; + + /** + * Value in HBO + */ + uint32_t metrics[TM_BOTH]; }; @@ -79,107 +76,104 @@ struct PropManipulationEntry */ struct TM_Peer { - /** - * Peer ID - */ - struct GNUNET_PeerIdentity peer; - - struct PropManipulationEntry *head; - struct PropManipulationEntry *tail; - - /** - * Peer specific manipulation metrics - */ - uint32_t metrics [TM_BOTH][GNUNET_ATS_QualityPropertiesCount]; - - /** - * Task to schedule delayed sendding - */ - GNUNET_SCHEDULER_TaskIdentifier send_delay_task; - - /** - * Send queue DLL head - */ - struct DelayQueueEntry *send_head; - - /** - * Send queue DLL tail - */ - struct DelayQueueEntry *send_tail; + /** + * Peer ID + */ + struct GNUNET_PeerIdentity peer; + + struct PropManipulationEntry *head; + struct PropManipulationEntry *tail; + + /** + * Peer specific manipulation metrics + */ + uint32_t metrics[TM_BOTH][GNUNET_ATS_QualityPropertiesCount]; + + /** + * Task to schedule delayed sendding + */ + GNUNET_SCHEDULER_TaskIdentifier send_delay_task; + + /** + * Send queue DLL head + */ + struct DelayQueueEntry *send_head; + + /** + * Send queue DLL tail + */ + struct DelayQueueEntry *send_tail; }; - struct GST_ManipulationHandle { - /** - * Hashmap contain all peers currently manipulated - */ - struct GNUNET_CONTAINER_MultiPeerMap *peers; - - /** - * Peer containing information for general manipulation - */ - struct TM_Peer general; + /** + * Hashmap contain all peers currently manipulated + */ + struct GNUNET_CONTAINER_MultiPeerMap *peers; + + /** + * Peer containing information for general manipulation + */ + struct TM_Peer general; }; - - /** * Entry in the delay queue for an outbound delayed message */ struct DelayQueueEntry { - /** - * Next in DLL - */ - struct DelayQueueEntry *prev; - - /** - * Previous in DLL - */ - struct DelayQueueEntry *next; - - /** - * Peer this entry is belonging to - * if (NULL == tmp): enqueued in generic DLL and scheduled by generic_send_delay_task - * else: enqueued in tmp->send_head and tmp->send_tail and scheduled by tmp->send_delay_task - */ - struct TM_Peer *tmp; - - /** - * Peer ID - */ - struct GNUNET_PeerIdentity id; - - /** - * Absolute time when to send - */ - struct GNUNET_TIME_Absolute sent_at; - - /** - * The message - */ - void *msg; - - /** - * The message size - */ - size_t msg_size; - - /** - * Message timeout - */ - struct GNUNET_TIME_Relative timeout; - - /** - * Transports send continuation - */ - GST_NeighbourSendContinuation cont; - - /** - * Transports send continuation cls - */ - void *cont_cls; + /** + * Next in DLL + */ + struct DelayQueueEntry *prev; + + /** + * Previous in DLL + */ + struct DelayQueueEntry *next; + + /** + * Peer this entry is belonging to + * if (NULL == tmp): enqueued in generic DLL and scheduled by generic_send_delay_task + * else: enqueued in tmp->send_head and tmp->send_tail and scheduled by tmp->send_delay_task + */ + struct TM_Peer *tmp; + + /** + * Peer ID + */ + struct GNUNET_PeerIdentity id; + + /** + * Absolute time when to send + */ + struct GNUNET_TIME_Absolute sent_at; + + /** + * The message + */ + void *msg; + + /** + * The message size + */ + size_t msg_size; + + /** + * Message timeout + */ + struct GNUNET_TIME_Relative timeout; + + /** + * Transports send continuation + */ + GST_NeighbourSendContinuation cont; + + /** + * Transports send continuation cls + */ + void *cont_cls; }; struct GST_ManipulationHandle man_handle; @@ -200,53 +194,53 @@ struct DelayQueueEntry *generic_dqe_tail; GNUNET_SCHEDULER_TaskIdentifier generic_send_delay_task; static void -set_metric (struct TM_Peer *dest, int direction, uint32_t type, uint32_t value) +set_metric(struct TM_Peer *dest, int direction, uint32_t type, uint32_t value) { - struct PropManipulationEntry *cur; - for (cur = dest->head; NULL != cur; cur = cur->next) - { - if (cur->type == type) - break; - } - if (NULL == cur) - { - cur = GNUNET_new (struct PropManipulationEntry); - GNUNET_CONTAINER_DLL_insert (dest->head, dest->tail, cur); - cur->type = type; - cur->metrics[TM_SEND] = UINT32_MAX; - cur->metrics[TM_RECEIVE] = UINT32_MAX; - } - - - switch (direction) { - case TM_BOTH: - cur->metrics[TM_SEND] = value; - cur->metrics[TM_RECEIVE] = value; - break; - case TM_SEND: - cur->metrics[TM_SEND] = value; - break; - case TM_RECEIVE: - cur->metrics[TM_RECEIVE] = value; - break; - default: - break; - } + struct PropManipulationEntry *cur; + for (cur = dest->head; NULL != cur; cur = cur->next) + { + if (cur->type == type) + break; + } + if (NULL == cur) + { + cur = GNUNET_new (struct PropManipulationEntry); + GNUNET_CONTAINER_DLL_insert(dest->head, dest->tail, cur); + cur->type = type; + cur->metrics[TM_SEND] = UINT32_MAX; + cur->metrics[TM_RECEIVE] = UINT32_MAX; + } + + switch (direction) + { + case TM_BOTH: + cur->metrics[TM_SEND] = value; + cur->metrics[TM_RECEIVE] = value; + break; + case TM_SEND: + cur->metrics[TM_SEND] = value; + break; + case TM_RECEIVE: + cur->metrics[TM_RECEIVE] = value; + break; + default: + break; + } } static uint32_t -find_metric (struct TM_Peer *dest, uint32_t type, int direction) +find_metric(struct TM_Peer *dest, uint32_t type, int direction) { - struct PropManipulationEntry *cur; + struct PropManipulationEntry *cur; - for (cur = dest->head; NULL != cur; cur = cur->next) - { - if (cur->type == type) - return cur->metrics[direction]; + for (cur = dest->head; NULL != cur; cur = cur->next) + { + if (cur->type == type) + return cur->metrics[direction]; - } - return UINT32_MAX; + } + return UINT32_MAX; } /** @@ -254,19 +248,18 @@ find_metric (struct TM_Peer *dest, uint32_t type, int direction) */ static void -free_metric (struct TM_Peer *dest) +free_metric(struct TM_Peer *dest) { - struct PropManipulationEntry *cur; - struct PropManipulationEntry *next; - - for (cur = dest->head; NULL != cur; cur = next) - { - next = cur->next; - GNUNET_CONTAINER_DLL_remove (dest->head, dest->tail, cur); - GNUNET_free (cur); - } -} + struct PropManipulationEntry *cur; + struct PropManipulationEntry *next; + for (cur = dest->head; NULL != cur; cur = next) + { + next = cur->next; + GNUNET_CONTAINER_DLL_remove(dest->head, dest->tail, cur); + GNUNET_free(cur); + } +} /** * Set traffic metric to manipulate @@ -276,123 +269,128 @@ free_metric (struct TM_Peer *dest) * @param message containing information */ void -GST_manipulation_set_metric (void *cls, struct GNUNET_SERVER_Client *client, +GST_manipulation_set_metric(void *cls, struct GNUNET_SERVER_Client *client, const struct GNUNET_MessageHeader *message) { - struct TrafficMetricMessage *tm = (struct TrafficMetricMessage *) message; - struct GNUNET_PeerIdentity dummy; - struct GNUNET_ATS_Information *ats; - struct TM_Peer *tmp; - uint32_t type; - uint32_t value; - uint16_t direction; - int c; - int c2; - - if (0 == ntohs (tm->ats_count)) - GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); - - direction = TM_BOTH; - switch (ntohs(tm->direction)) { - case 1: - direction = TM_SEND; - break; - case 2: - direction = TM_RECEIVE; - break; - case 3: - direction = TM_BOTH; - break; - default: - break; - } - - memset (&dummy, '\0', sizeof (struct GNUNET_PeerIdentity)); - if (0 == memcmp (&tm->peer, &dummy, sizeof (struct GNUNET_PeerIdentity))) - { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received traffic metrics for all peers \n"); - - ats = (struct GNUNET_ATS_Information *) &tm[1]; - for (c = 0; c < ntohs (tm->ats_count); c++) - { - type = htonl (ats[c].type); - value = htonl (ats[c].value); - set_metric (&man_handle.general, direction, type, value); - } - return; - } - - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received traffic metrics for peer `%s'\n", - GNUNET_i2s(&tm->peer)); - - if (NULL == (tmp = GNUNET_CONTAINER_multipeermap_get (man_handle.peers, &tm->peer))) - { - tmp = GNUNET_new (struct TM_Peer); - tmp->peer = (tm->peer); - for (c = 0; c < TM_BOTH; c++) - { - for (c2 = 0; c2 < GNUNET_ATS_QualityPropertiesCount; c2++) - { - tmp->metrics[c][c2] = UINT32_MAX; - } - } - GNUNET_CONTAINER_multipeermap_put (man_handle.peers, - &tm->peer, tmp, - GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST); - } - - ats = (struct GNUNET_ATS_Information *) &tm[1]; - for (c = 0; c < ntohs (tm->ats_count); c++) - { - type = htonl (ats[c].type); - value = htonl (ats[c].value); - set_metric (tmp, direction, type, value); - } - - GNUNET_SERVER_receive_done (client, GNUNET_OK); + struct TrafficMetricMessage *tm = (struct TrafficMetricMessage *) message; + struct GNUNET_PeerIdentity dummy; + struct GNUNET_ATS_Information *ats; + struct TM_Peer *tmp; + uint32_t type; + uint32_t value; + uint16_t direction; + int c; + int c2; + + if (0 == ntohs(tm->ats_count)) + GNUNET_SERVER_receive_done(client, GNUNET_SYSERR); + + direction = TM_BOTH; + switch (ntohs(tm->direction)) + { + case 1: + direction = TM_SEND; + break; + case 2: + direction = TM_RECEIVE; + break; + case 3: + direction = TM_BOTH; + break; + default: + break; + } + + memset(&dummy, '\0', sizeof(struct GNUNET_PeerIdentity)); + if (0 == memcmp(&tm->peer, &dummy, sizeof(struct GNUNET_PeerIdentity))) + { + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Received traffic metrics for all peers \n"); + + ats = (struct GNUNET_ATS_Information *) &tm[1]; + for (c = 0; c < ntohs(tm->ats_count); c++) + { + type = htonl(ats[c].type); + value = htonl(ats[c].value); + set_metric(&man_handle.general, direction, type, value); + } + return; + } + + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Received traffic metrics for peer `%s'\n", GNUNET_i2s(&tm->peer)); + + if (NULL + == (tmp = GNUNET_CONTAINER_multipeermap_get(man_handle.peers, &tm->peer))) + { + tmp = GNUNET_new (struct TM_Peer); + tmp->peer = (tm->peer); + for (c = 0; c < TM_BOTH; c++) + { + for (c2 = 0; c2 < GNUNET_ATS_QualityPropertiesCount; c2++) + { + tmp->metrics[c][c2] = UINT32_MAX; + } + } + GNUNET_CONTAINER_multipeermap_put(man_handle.peers, &tm->peer, tmp, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST); + } + + ats = (struct GNUNET_ATS_Information *) &tm[1]; + for (c = 0; c < ntohs(tm->ats_count); c++) + { + type = htonl(ats[c].type); + value = htonl(ats[c].value); + set_metric(tmp, direction, type, value); + } + + GNUNET_SERVER_receive_done(client, GNUNET_OK); } static void -send_delayed (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +send_delayed(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { - struct DelayQueueEntry *dqe = cls; - struct DelayQueueEntry *next; - struct TM_Peer *tmp = dqe->tmp; - struct GNUNET_TIME_Relative delay; - - if (NULL != tmp) - { - GNUNET_break (GNUNET_YES == GST_neighbours_test_connected (&dqe->id)); - tmp->send_delay_task = GNUNET_SCHEDULER_NO_TASK; - GNUNET_CONTAINER_DLL_remove (tmp->send_head, tmp->send_tail, dqe); - GST_neighbours_send (&dqe->id, dqe->msg, dqe->msg_size, dqe->timeout, dqe->cont, dqe->cont_cls); - - next = tmp->send_head; - if (NULL != next) - { - /* More delayed messages */ - delay = GNUNET_TIME_absolute_get_remaining (next->sent_at); - tmp->send_delay_task = GNUNET_SCHEDULER_add_delayed (delay, &send_delayed, next); - } - } - else - { - /* Remove from generic queue */ - GNUNET_break (GNUNET_YES == GST_neighbours_test_connected (&dqe->id)); - generic_send_delay_task = GNUNET_SCHEDULER_NO_TASK; - GNUNET_CONTAINER_DLL_remove (generic_dqe_head, generic_dqe_tail, dqe); - GST_neighbours_send (&dqe->id, dqe->msg, dqe->msg_size, dqe->timeout, dqe->cont, dqe->cont_cls); - next = generic_dqe_head; - if (NULL != next) - { - /* More delayed messages */ - delay = GNUNET_TIME_absolute_get_remaining (next->sent_at); - generic_send_delay_task = GNUNET_SCHEDULER_add_delayed (delay, &send_delayed, next); - } - } - GNUNET_free (dqe); -} + struct DelayQueueEntry *dqe = cls; + struct DelayQueueEntry *next; + struct TM_Peer *tmp = dqe->tmp; + struct GNUNET_TIME_Relative delay; + if (NULL != tmp) + { + GNUNET_break(GNUNET_YES == GST_neighbours_test_connected (&dqe->id)); + tmp->send_delay_task = GNUNET_SCHEDULER_NO_TASK; + GNUNET_CONTAINER_DLL_remove(tmp->send_head, tmp->send_tail, dqe); + GST_neighbours_send(&dqe->id, dqe->msg, dqe->msg_size, dqe->timeout, + dqe->cont, dqe->cont_cls); + + next = tmp->send_head; + if (NULL != next) + { + /* More delayed messages */ + delay = GNUNET_TIME_absolute_get_remaining(next->sent_at); + tmp->send_delay_task = GNUNET_SCHEDULER_add_delayed(delay, + &send_delayed, next); + } + } + else + { + /* Remove from generic queue */ + GNUNET_break(GNUNET_YES == GST_neighbours_test_connected (&dqe->id)); + generic_send_delay_task = GNUNET_SCHEDULER_NO_TASK; + GNUNET_CONTAINER_DLL_remove(generic_dqe_head, generic_dqe_tail, dqe); + GST_neighbours_send(&dqe->id, dqe->msg, dqe->msg_size, dqe->timeout, + dqe->cont, dqe->cont_cls); + next = generic_dqe_head; + if (NULL != next) + { + /* More delayed messages */ + delay = GNUNET_TIME_absolute_get_remaining(next->sent_at); + generic_send_delay_task = GNUNET_SCHEDULER_add_delayed(delay, + &send_delayed, next); + } + } + GNUNET_free(dqe); +} /** * Adapter function between transport's send function and transport plugins @@ -405,7 +403,7 @@ send_delayed (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) * @param cont_cls cls for continuation */ void -GST_manipulation_send (const struct GNUNET_PeerIdentity *target, const void *msg, +GST_manipulation_send(const struct GNUNET_PeerIdentity *target, const void *msg, size_t msg_size, struct GNUNET_TIME_Relative timeout, GST_NeighbourSendContinuation cont, void *cont_cls) { @@ -413,67 +411,71 @@ GST_manipulation_send (const struct GNUNET_PeerIdentity *target, const void *msg struct DelayQueueEntry *dqe; struct GNUNET_TIME_Relative delay; - if (NULL != (tmp = GNUNET_CONTAINER_multipeermap_get (man_handle.peers, target))) - { - GNUNET_break (GNUNET_YES == GST_neighbours_test_connected(target)); - /* Manipulate here */ - /* Delay */ - if (UINT32_MAX != find_metric(tmp, GNUNET_ATS_QUALITY_NET_DELAY, TM_SEND)) + if (NULL + != (tmp = GNUNET_CONTAINER_multipeermap_get(man_handle.peers, target))) + { + GNUNET_break(GNUNET_YES == GST_neighbours_test_connected(target)); + /* Manipulate here */ + /* Delay */ + if (UINT32_MAX != find_metric(tmp, GNUNET_ATS_QUALITY_NET_DELAY, TM_SEND)) + { + /* We have a delay */ + delay.rel_value_us = find_metric(tmp, GNUNET_ATS_QUALITY_NET_DELAY, + TM_SEND); + dqe = GNUNET_malloc (sizeof (struct DelayQueueEntry) + msg_size); + dqe->id = *target; + dqe->tmp = tmp; + dqe->sent_at = GNUNET_TIME_absolute_add(GNUNET_TIME_absolute_get(), + delay); + dqe->cont = cont; + dqe->cont_cls = cont_cls; + dqe->msg = &dqe[1]; + dqe->msg_size = msg_size; + dqe->timeout = timeout; + memcpy(dqe->msg, msg, msg_size); + GNUNET_CONTAINER_DLL_insert_tail(tmp->send_head, tmp->send_tail, dqe); + if (GNUNET_SCHEDULER_NO_TASK == tmp->send_delay_task) + tmp->send_delay_task = GNUNET_SCHEDULER_add_delayed(delay, + &send_delayed, dqe); + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Delaying %u byte message to peer `%s' with generic delay for %ms\n", msg_size, GNUNET_i2s (target), GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES)); + return; + } + } + else if (UINT32_MAX + != find_metric(&man_handle.general, GNUNET_ATS_QUALITY_NET_DELAY, + TM_SEND)) { + GNUNET_break(GNUNET_YES == GST_neighbours_test_connected(target)); /* We have a delay */ - delay.rel_value_us = find_metric (tmp, GNUNET_ATS_QUALITY_NET_DELAY, TM_SEND); + delay.rel_value_us = find_metric(&man_handle.general, + GNUNET_ATS_QUALITY_NET_DELAY, TM_SEND); dqe = GNUNET_malloc (sizeof (struct DelayQueueEntry) + msg_size); dqe->id = *target; - dqe->tmp = tmp; - dqe->sent_at = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get(), delay); + dqe->tmp = NULL; + dqe->sent_at = GNUNET_TIME_absolute_add(GNUNET_TIME_absolute_get(), + delay); dqe->cont = cont; dqe->cont_cls = cont_cls; dqe->msg = &dqe[1]; dqe->msg_size = msg_size; dqe->timeout = timeout; - memcpy (dqe->msg, msg, msg_size); - GNUNET_CONTAINER_DLL_insert_tail (tmp->send_head, tmp->send_tail, dqe); - if (GNUNET_SCHEDULER_NO_TASK == tmp->send_delay_task) - tmp->send_delay_task =GNUNET_SCHEDULER_add_delayed (delay, &send_delayed, dqe); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Delaying %u byte message to peer `%s' with generic delay for %ms\n", - msg_size, GNUNET_i2s (target), - GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES)); + memcpy(dqe->msg, msg, msg_size); + GNUNET_CONTAINER_DLL_insert_tail(generic_dqe_head, generic_dqe_tail, dqe); + if (GNUNET_SCHEDULER_NO_TASK == generic_send_delay_task) + { + generic_send_delay_task = GNUNET_SCHEDULER_add_delayed(delay, + &send_delayed, dqe); + } + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Delaying %u byte message to peer `%s' with peer specific delay for %s\n", msg_size, GNUNET_i2s (target), GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES)); return; } - } - else if (UINT32_MAX != find_metric (&man_handle.general, GNUNET_ATS_QUALITY_NET_DELAY, TM_SEND)) - { - GNUNET_break (GNUNET_YES == GST_neighbours_test_connected(target)); - /* We have a delay */ - delay.rel_value_us = find_metric (&man_handle.general, GNUNET_ATS_QUALITY_NET_DELAY, TM_SEND); - dqe = GNUNET_malloc (sizeof (struct DelayQueueEntry) + msg_size); - dqe->id = *target; - dqe->tmp = NULL; - dqe->sent_at = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get(), delay); - dqe->cont = cont; - dqe->cont_cls = cont_cls; - dqe->msg = &dqe[1]; - dqe->msg_size = msg_size; - dqe->timeout = timeout; - memcpy (dqe->msg, msg, msg_size); - GNUNET_CONTAINER_DLL_insert_tail (generic_dqe_head, generic_dqe_tail, dqe); - if (GNUNET_SCHEDULER_NO_TASK == generic_send_delay_task) - { - generic_send_delay_task = GNUNET_SCHEDULER_add_delayed (delay, &send_delayed, dqe); - } - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Delaying %u byte message to peer `%s' with peer specific delay for %s\n", - msg_size, GNUNET_i2s (target), - GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES)); - return; - } /* Normal sending */ - GST_neighbours_send (target, msg, msg_size, timeout, cont, cont_cls); + GST_neighbours_send(target, msg, msg_size, timeout, cont, cont_cls); } - /** * Function that will be called to manipulate ATS information according to * current manipulation settings @@ -485,36 +487,34 @@ GST_manipulation_send (const struct GNUNET_PeerIdentity *target, const void *msg * @param ats_count the number of ats information */ struct GNUNET_ATS_Information * -GST_manipulation_manipulate_metrics (const struct GNUNET_PeerIdentity *peer, - const struct GNUNET_HELLO_Address *address, - struct Session *session, - const struct GNUNET_ATS_Information *ats, - uint32_t ats_count) +GST_manipulation_manipulate_metrics(const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_HELLO_Address *address, struct Session *session, + const struct GNUNET_ATS_Information *ats, uint32_t ats_count) { - struct GNUNET_ATS_Information *ats_new = GNUNET_malloc (sizeof (struct GNUNET_ATS_Information) *ats_count); - struct TM_Peer *tmp; - uint32_t m_tmp; - uint32_t g_tmp; - int d; - tmp = GNUNET_CONTAINER_multipeermap_get (man_handle.peers, peer); - - for (d = 0; d < ats_count; d++) - { - ats_new[d] = ats[d]; - m_tmp = UINT32_MAX; - if (NULL != tmp) - m_tmp = find_metric (tmp, ntohl(ats[d].type), TM_RECEIVE); - g_tmp = find_metric (&man_handle.general, ntohl(ats[d].type), TM_RECEIVE); - - if (UINT32_MAX != g_tmp) - ats_new[d].value = htonl(g_tmp); - if (UINT32_MAX != m_tmp) - ats_new[d].value = htonl(m_tmp); - } - - return ats_new; -} + struct GNUNET_ATS_Information *ats_new = + GNUNET_malloc (sizeof (struct GNUNET_ATS_Information) *ats_count); + struct TM_Peer *tmp; + uint32_t m_tmp; + uint32_t g_tmp; + int d; + tmp = GNUNET_CONTAINER_multipeermap_get(man_handle.peers, peer); + + for (d = 0; d < ats_count; d++) + { + ats_new[d] = ats[d]; + m_tmp = UINT32_MAX; + if (NULL != tmp) + m_tmp = find_metric(tmp, ntohl(ats[d].type), TM_RECEIVE); + g_tmp = find_metric(&man_handle.general, ntohl(ats[d].type), TM_RECEIVE); + + if (UINT32_MAX != g_tmp) + ats_new[d].value = htonl(g_tmp); + if (UINT32_MAX != m_tmp) + ats_new[d].value = htonl(m_tmp); + } + return ats_new; +} /** * Adapter function between transport plugins and transport receive function @@ -529,47 +529,43 @@ GST_manipulation_manipulate_metrics (const struct GNUNET_PeerIdentity *peer, * @return manipulated delay for next receive */ struct GNUNET_TIME_Relative -GST_manipulation_recv (void *cls, - const struct GNUNET_PeerIdentity *peer, - const struct GNUNET_MessageHeader *message, - struct Session *session, - const char *sender_address, - uint16_t sender_address_len) +GST_manipulation_recv(void *cls, const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_MessageHeader *message, struct Session *session, + const char *sender_address, uint16_t sender_address_len) { - struct TM_Peer *tmp; - uint32_t p_recv_delay; - uint32_t g_recv_delay; - struct GNUNET_TIME_Relative quota_delay; - struct GNUNET_TIME_Relative m_delay; - - g_recv_delay = find_metric (&man_handle.general, GNUNET_ATS_QUALITY_NET_DELAY, TM_RECEIVE); - if ((g_recv_delay >= GNUNET_TIME_UNIT_ZERO.rel_value_us) && (UINT32_MAX != g_recv_delay)) - m_delay.rel_value_us = g_recv_delay; /* Global delay */ - else - m_delay = GNUNET_TIME_UNIT_ZERO; - - if (NULL != (tmp = GNUNET_CONTAINER_multipeermap_get (man_handle.peers, peer))) - { - /* Manipulate receive delay */ - p_recv_delay = find_metric (tmp, GNUNET_ATS_QUALITY_NET_DELAY, TM_RECEIVE); - if (UINT32_MAX != p_recv_delay) - m_delay.rel_value_us = p_recv_delay; /* Peer specific delay */ - } - - quota_delay = GST_receive_callback (cls, peer, message, - session, sender_address, sender_address_len); - - if (quota_delay.rel_value_us > m_delay.rel_value_us) - m_delay = quota_delay; - - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Delaying next receive for peer `%s' for %s\n", - GNUNET_i2s (peer), - GNUNET_STRINGS_relative_time_to_string (m_delay, GNUNET_YES)); - return m_delay; + struct TM_Peer *tmp; + uint32_t p_recv_delay; + uint32_t g_recv_delay; + struct GNUNET_TIME_Relative quota_delay; + struct GNUNET_TIME_Relative m_delay; + + g_recv_delay = find_metric(&man_handle.general, GNUNET_ATS_QUALITY_NET_DELAY, + TM_RECEIVE); + if ((g_recv_delay >= GNUNET_TIME_UNIT_ZERO.rel_value_us) + && (UINT32_MAX != g_recv_delay)) + m_delay.rel_value_us = g_recv_delay; /* Global delay */ + else + m_delay = GNUNET_TIME_UNIT_ZERO; -} + if (NULL != (tmp = GNUNET_CONTAINER_multipeermap_get(man_handle.peers, peer))) + { + /* Manipulate receive delay */ + p_recv_delay = find_metric(tmp, GNUNET_ATS_QUALITY_NET_DELAY, TM_RECEIVE); + if (UINT32_MAX != p_recv_delay) + m_delay.rel_value_us = p_recv_delay; /* Peer specific delay */ + } + quota_delay = GST_receive_callback(cls, peer, message, session, + sender_address, sender_address_len); + + if (quota_delay.rel_value_us > m_delay.rel_value_us) + m_delay = quota_delay; + + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Delaying next receive for peer `%s' for %s\n", GNUNET_i2s (peer), GNUNET_STRINGS_relative_time_to_string (m_delay, GNUNET_YES)); + return m_delay; + +} /** * Initialize traffic manipulation @@ -577,102 +573,85 @@ GST_manipulation_recv (void *cls, * @param GST_cfg configuration handle */ void -GST_manipulation_init (const struct GNUNET_CONFIGURATION_Handle *GST_cfg) +GST_manipulation_init(const struct GNUNET_CONFIGURATION_Handle *GST_cfg) { unsigned long long tmp; struct GNUNET_TIME_Relative delay; - if ( (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (GST_cfg, - "transport", - "MANIPULATE_DISTANCE_IN", - &tmp)) && - (tmp > 0) ) - { - GNUNET_log (GNUNET_ERROR_TYPE_INFO, - "Setting inbound distance_in to %llu\n", - (unsigned long long) tmp); - set_metric (&man_handle.general, TM_RECEIVE, GNUNET_ATS_QUALITY_NET_DISTANCE, tmp); - } - - if ( (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (GST_cfg, - "transport", - "MANIPULATE_DISTANCE_OUT", - &tmp)) && - (tmp > 0) ) - { - GNUNET_log (GNUNET_ERROR_TYPE_INFO, - "Setting outbound distance_in to %llu\n", - (unsigned long long) tmp); - set_metric (&man_handle.general, TM_SEND, - GNUNET_ATS_QUALITY_NET_DISTANCE, tmp); - } - - if ( (GNUNET_OK == GNUNET_CONFIGURATION_get_value_time (GST_cfg, - "transport", - "MANIPULATE_DELAY_IN", - &delay)) && - (delay.rel_value_us > 0) ) - { - GNUNET_log (GNUNET_ERROR_TYPE_INFO, - "Delaying inbound traffic for %s\n", - GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES)); - set_metric (&man_handle.general, TM_RECEIVE, - GNUNET_ATS_QUALITY_NET_DELAY, - delay.rel_value_us); - } - if ( (GNUNET_OK == GNUNET_CONFIGURATION_get_value_time (GST_cfg, - "transport", - "MANIPULATE_DELAY_OUT", - &delay)) && - (delay.rel_value_us > 0) ) - { - GNUNET_log (GNUNET_ERROR_TYPE_INFO, - "Delaying outbound traffic for %s\n", - GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES)); - set_metric (&man_handle.general, - TM_SEND, - GNUNET_ATS_QUALITY_NET_DELAY, - delay.rel_value_us); - } - man_handle.peers = GNUNET_CONTAINER_multipeermap_create (10, GNUNET_NO); -} + if ((GNUNET_OK + == GNUNET_CONFIGURATION_get_value_number(GST_cfg, "transport", + "MANIPULATE_DISTANCE_IN", &tmp)) && (tmp > 0)) + { + GNUNET_log(GNUNET_ERROR_TYPE_INFO, + "Setting inbound distance_in to %llu\n", (unsigned long long) tmp); + set_metric(&man_handle.general, TM_RECEIVE, + GNUNET_ATS_QUALITY_NET_DISTANCE, tmp); + } + if ((GNUNET_OK + == GNUNET_CONFIGURATION_get_value_number(GST_cfg, "transport", + "MANIPULATE_DISTANCE_OUT", &tmp)) && (tmp > 0)) + { + GNUNET_log(GNUNET_ERROR_TYPE_INFO, + "Setting outbound distance_in to %llu\n", (unsigned long long) tmp); + set_metric(&man_handle.general, TM_SEND, GNUNET_ATS_QUALITY_NET_DISTANCE, + tmp); + } + + if ((GNUNET_OK + == GNUNET_CONFIGURATION_get_value_time(GST_cfg, "transport", + "MANIPULATE_DELAY_IN", &delay)) && (delay.rel_value_us > 0)) + { + GNUNET_log(GNUNET_ERROR_TYPE_INFO, + "Delaying inbound traffic for %s\n", GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES)); + set_metric(&man_handle.general, TM_RECEIVE, GNUNET_ATS_QUALITY_NET_DELAY, + delay.rel_value_us); + } + if ((GNUNET_OK + == GNUNET_CONFIGURATION_get_value_time(GST_cfg, "transport", + "MANIPULATE_DELAY_OUT", &delay)) && (delay.rel_value_us > 0)) + { + GNUNET_log(GNUNET_ERROR_TYPE_INFO, + "Delaying outbound traffic for %s\n", GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES)); + set_metric(&man_handle.general, TM_SEND, GNUNET_ATS_QUALITY_NET_DELAY, + delay.rel_value_us); + } + man_handle.peers = GNUNET_CONTAINER_multipeermap_create(10, GNUNET_NO); +} static int -free_tmps (void *cls, - const struct GNUNET_PeerIdentity *key, - void *value) +free_tmps(void *cls, const struct GNUNET_PeerIdentity *key, void *value) { struct DelayQueueEntry *dqe; struct DelayQueueEntry *next; if (NULL != value) - { - struct TM_Peer *tmp = (struct TM_Peer *) value; - - if (GNUNET_YES != GNUNET_CONTAINER_multipeermap_remove (man_handle.peers, key, value)) - GNUNET_break (0); - free_metric (tmp); - next = tmp->send_head; - while (NULL != (dqe = next)) - { - next = dqe->next; - GNUNET_CONTAINER_DLL_remove (tmp->send_head, tmp->send_tail, dqe); - if (NULL != dqe->cont) - dqe->cont (dqe->cont_cls, GNUNET_SYSERR, dqe->msg_size, 0); - GNUNET_free (dqe); - } - if (GNUNET_SCHEDULER_NO_TASK != tmp->send_delay_task) - { - GNUNET_SCHEDULER_cancel (tmp->send_delay_task); - tmp->send_delay_task = GNUNET_SCHEDULER_NO_TASK; - } - GNUNET_free (tmp); - } + { + struct TM_Peer *tmp = (struct TM_Peer *) value; + + if (GNUNET_YES + != GNUNET_CONTAINER_multipeermap_remove(man_handle.peers, key, value)) + GNUNET_break(0); + free_metric(tmp); + next = tmp->send_head; + while (NULL != (dqe = next)) + { + next = dqe->next; + GNUNET_CONTAINER_DLL_remove(tmp->send_head, tmp->send_tail, dqe); + if (NULL != dqe->cont) + dqe->cont(dqe->cont_cls, GNUNET_SYSERR, dqe->msg_size, 0); + GNUNET_free(dqe); + } + if (GNUNET_SCHEDULER_NO_TASK != tmp->send_delay_task) + { + GNUNET_SCHEDULER_cancel(tmp->send_delay_task); + tmp->send_delay_task = GNUNET_SCHEDULER_NO_TASK; + } + GNUNET_free(tmp); + } return GNUNET_OK; } - /** * Notify manipulation about disconnect so it can discard queued messages * @@ -725,36 +704,34 @@ GST_manipulation_peer_disconnect(const struct GNUNET_PeerIdentity *peer) } } - /** * Stop traffic manipulation */ void -GST_manipulation_stop () +GST_manipulation_stop() { - struct DelayQueueEntry *cur; - struct DelayQueueEntry *next; - GNUNET_CONTAINER_multipeermap_iterate (man_handle.peers, &free_tmps,NULL); - GNUNET_CONTAINER_multipeermap_destroy (man_handle.peers); - - next = generic_dqe_head; - while (NULL != (cur = next)) - { - next = cur->next; - GNUNET_CONTAINER_DLL_remove (generic_dqe_head, generic_dqe_tail, cur); - if (NULL != cur->cont) - cur->cont (cur->cont_cls, GNUNET_SYSERR, cur->msg_size, 0); - GNUNET_free (cur); - } - if (GNUNET_SCHEDULER_NO_TASK != generic_send_delay_task) - { - GNUNET_SCHEDULER_cancel (generic_send_delay_task); - generic_send_delay_task = GNUNET_SCHEDULER_NO_TASK; - } - - free_metric (&man_handle.general); - man_handle.peers = NULL; -} + struct DelayQueueEntry *cur; + struct DelayQueueEntry *next; + GNUNET_CONTAINER_multipeermap_iterate(man_handle.peers, &free_tmps, NULL); + GNUNET_CONTAINER_multipeermap_destroy(man_handle.peers); + next = generic_dqe_head; + while (NULL != (cur = next)) + { + next = cur->next; + GNUNET_CONTAINER_DLL_remove(generic_dqe_head, generic_dqe_tail, cur); + if (NULL != cur->cont) + cur->cont(cur->cont_cls, GNUNET_SYSERR, cur->msg_size, 0); + GNUNET_free(cur); + } + if (GNUNET_SCHEDULER_NO_TASK != generic_send_delay_task) + { + GNUNET_SCHEDULER_cancel(generic_send_delay_task); + generic_send_delay_task = GNUNET_SCHEDULER_NO_TASK; + } + + free_metric(&man_handle.general); + man_handle.peers = NULL; +} /* end of file gnunet-service-transport_manipulation.c */ -- cgit v1.2.3