fixing file indent

1 files changed, 487 insertions, 510 deletions

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 */