1 files changed, 309 insertions, 320 deletions

diff --git a/src/fs/gnunet-service-fs_pe.c b/src/fs/gnunet-service-fs_pe.c
index 5e85bfdb7..3c1112333 100644
--- a/src/fs/gnunet-service-fs_pe.c
+++ b/src/fs/gnunet-service-fs_pe.c
@@ -11,12 +11,12 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 
 /**
  * @file fs/gnunet-service-fs_pe.c
@@ -63,9 +63,7 @@ struct PeerPlan;
  * to be able to lookup all plan entries corresponding
  * to a given pending request.)
  */
-struct GSF_PendingRequestPlanBijection
-{
-
+struct GSF_PendingRequestPlanBijection {
   /**
    * This is a doubly-linked list.
    */
@@ -97,7 +95,6 @@ struct GSF_PendingRequestPlanBijection
    * and one of the origins of the request).
    */
   struct GSF_PendingRequest *pr;
-
 };
 
 
@@ -107,9 +104,7 @@ struct GSF_PendingRequestPlanBijection
  * with one entry in each heap of each `struct PeerPlan`.  Each
  * entry tracks information relevant for this request and this peer.
  */
-struct GSF_RequestPlan
-{
-
+struct GSF_RequestPlan {
   /**
    * This is a doubly-linked list.
    */
@@ -161,15 +156,13 @@ struct GSF_RequestPlan
    * How often did we transmit this request to this peer?
    */
   unsigned int transmission_counter;
-
 };
 
 
 /**
  * Transmission plan for a peer.
  */
-struct PeerPlan
-{
+struct PeerPlan {
   /**
    * Heap with pending queries (`struct GSF_RequestPlan`), higher weights mean higher priority.
    */
@@ -202,7 +195,6 @@ struct PeerPlan
    * Current message under transmission for the plan.
    */
   struct GNUNET_MQ_Envelope *env;
-
 };
 
 
@@ -235,9 +227,9 @@ static unsigned long long plan_count;
  * @return the associated query
  */
 static const struct GNUNET_HashCode *
-get_rp_key (struct GSF_RequestPlan *rp)
+get_rp_key(struct GSF_RequestPlan *rp)
 {
-  return &GSF_pending_request_get_data_ (rp->pe_head->pr)->query;
+  return &GSF_pending_request_get_data_(rp->pe_head->pr)->query;
 }
 
 
@@ -248,8 +240,8 @@ get_rp_key (struct GSF_RequestPlan *rp)
  * @param rp request to plan
  */
 static void
-plan (struct PeerPlan *pp,
-      struct GSF_RequestPlan *rp)
+plan(struct PeerPlan *pp,
+     struct GSF_RequestPlan *rp)
 {
 #define N ((double)128.0)
   /**
@@ -260,28 +252,28 @@ plan (struct PeerPlan *pp,
   struct GSF_PendingRequestData *prd;
   struct GNUNET_TIME_Relative delay;
 
-  GNUNET_assert (rp->pp == pp);
-  GNUNET_STATISTICS_set (GSF_stats,
-                         gettext_noop ("# average retransmission delay (ms)"),
-                         total_delay * 1000LL / plan_count, GNUNET_NO);
-  prd = GSF_pending_request_get_data_ (rp->pe_head->pr);
+  GNUNET_assert(rp->pp == pp);
+  GNUNET_STATISTICS_set(GSF_stats,
+                        gettext_noop("# average retransmission delay (ms)"),
+                        total_delay * 1000LL / plan_count, GNUNET_NO);
+  prd = GSF_pending_request_get_data_(rp->pe_head->pr);
 
   if (rp->transmission_counter < 8)
     delay =
-        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
-                                       rp->transmission_counter);
+      GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS,
+                                    rp->transmission_counter);
   else if (rp->transmission_counter < 32)
     delay =
-        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
-                                       8 +
-                                       (1LL << (rp->transmission_counter - 8)));
+      GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS,
+                                    8 +
+                                    (1LL << (rp->transmission_counter - 8)));
   else
     delay =
-        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
-                                       8 + (1LL << 24));
+      GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS,
+                                    8 + (1LL << 24));
   delay.rel_value_us =
-    GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
-                              delay.rel_value_us + 1);
+    GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK,
+                             delay.rel_value_us + 1);
   /* Add 0.01 to avg_delay to avoid division-by-zero later */
   avg_delay = (((avg_delay * (N - 1.0)) + delay.rel_value_us) / N) + 0.01;
 
@@ -307,36 +299,36 @@ plan (struct PeerPlan *pp,
    * Note: M_PI_4 = PI/4 = arctan(1)
    */
   rp->priority =
-      round ((GSF_current_priorities +
-              1.0) * atan (delay.rel_value_us / avg_delay)) / M_PI_4;
+    round((GSF_current_priorities +
+           1.0) * atan(delay.rel_value_us / avg_delay)) / M_PI_4;
   /* Note: usage of 'round' and 'atan' requires -lm */
 
   if (rp->transmission_counter != 0)
     delay.rel_value_us += TTL_DECREMENT * 1000;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Considering (re)transmission number %u in %s\n",
-              (unsigned int) rp->transmission_counter,
-              GNUNET_STRINGS_relative_time_to_string (delay,
-                                                      GNUNET_YES));
-  rp->earliest_transmission = GNUNET_TIME_relative_to_absolute (delay);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Earliest (re)transmission for `%s' in %us\n",
-              GNUNET_h2s (&prd->query),
-              rp->transmission_counter);
-  GNUNET_assert (rp->hn == NULL);
-  if (0 == GNUNET_TIME_absolute_get_remaining (rp->earliest_transmission).rel_value_us)
-    rp->hn = GNUNET_CONTAINER_heap_insert (pp->priority_heap,
-                                           rp,
-                                           rp->priority);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Considering (re)transmission number %u in %s\n",
+             (unsigned int)rp->transmission_counter,
+             GNUNET_STRINGS_relative_time_to_string(delay,
+                                                    GNUNET_YES));
+  rp->earliest_transmission = GNUNET_TIME_relative_to_absolute(delay);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Earliest (re)transmission for `%s' in %us\n",
+             GNUNET_h2s(&prd->query),
+             rp->transmission_counter);
+  GNUNET_assert(rp->hn == NULL);
+  if (0 == GNUNET_TIME_absolute_get_remaining(rp->earliest_transmission).rel_value_us)
+    rp->hn = GNUNET_CONTAINER_heap_insert(pp->priority_heap,
+                                          rp,
+                                          rp->priority);
   else
     rp->hn =
-        GNUNET_CONTAINER_heap_insert (pp->delay_heap,
-                                      rp,
-                                      rp->earliest_transmission.abs_value_us);
-  GNUNET_assert (GNUNET_YES ==
-                 GNUNET_CONTAINER_multihashmap_contains_value (pp->plan_map,
-                                                               get_rp_key (rp),
-                                                               rp));
+      GNUNET_CONTAINER_heap_insert(pp->delay_heap,
+                                   rp,
+                                   rp->earliest_transmission.abs_value_us);
+  GNUNET_assert(GNUNET_YES ==
+                GNUNET_CONTAINER_multihashmap_contains_value(pp->plan_map,
+                                                             get_rp_key(rp),
+                                                             rp));
 #undef N
 }
 
@@ -348,7 +340,7 @@ plan (struct PeerPlan *pp,
  * @return pending request with highest TTL
  */
 struct GSF_PendingRequest *
-get_latest (const struct GSF_RequestPlan *rp)
+get_latest(const struct GSF_RequestPlan *rp)
 {
   struct GSF_PendingRequest *ret;
   struct GSF_PendingRequestPlanBijection *bi;
@@ -359,18 +351,18 @@ get_latest (const struct GSF_RequestPlan *rp)
   if (NULL == bi)
     return NULL; /* should never happen */
   ret = bi->pr;
-  rprd = GSF_pending_request_get_data_ (ret);
+  rprd = GSF_pending_request_get_data_(ret);
   for (bi = bi->next_PE; NULL != bi; bi = bi->next_PE)
-  {
-    GNUNET_break (GNUNET_YES ==
-                  GSF_pending_request_test_active_ (bi->pr));
-    prd = GSF_pending_request_get_data_ (bi->pr);
-    if (prd->ttl.abs_value_us > rprd->ttl.abs_value_us)
     {
-      ret = bi->pr;
-      rprd = prd;
+      GNUNET_break(GNUNET_YES ==
+                   GSF_pending_request_test_active_(bi->pr));
+      prd = GSF_pending_request_get_data_(bi->pr);
+      if (prd->ttl.abs_value_us > rprd->ttl.abs_value_us)
+        {
+          ret = bi->pr;
+          rprd = prd;
+        }
     }
-  }
   return ret;
 }
 
@@ -381,102 +373,100 @@ get_latest (const struct GSF_RequestPlan *rp)
  * @param cls the `struct PeerPlan`
  */
 static void
-schedule_peer_transmission (void *cls)
+schedule_peer_transmission(void *cls)
 {
   struct PeerPlan *pp = cls;
   struct GSF_RequestPlan *rp;
   struct GNUNET_TIME_Relative delay;
 
   if (NULL != pp->task)
-  {
-    pp->task = NULL;
-  }
+    {
+      pp->task = NULL;
+    }
   else
-  {
-    GNUNET_assert (NULL != pp->env);
-    pp->env = NULL;
-  }
+    {
+      GNUNET_assert(NULL != pp->env);
+      pp->env = NULL;
+    }
   /* move ready requests to priority queue */
-  while ((NULL != (rp = GNUNET_CONTAINER_heap_peek (pp->delay_heap))) &&
+  while ((NULL != (rp = GNUNET_CONTAINER_heap_peek(pp->delay_heap))) &&
          (0 == GNUNET_TIME_absolute_get_remaining
-          (rp->earliest_transmission).rel_value_us))
-  {
-    GNUNET_assert (rp == GNUNET_CONTAINER_heap_remove_root (pp->delay_heap));
-    rp->hn = GNUNET_CONTAINER_heap_insert (pp->priority_heap,
-                                           rp,
-                                           rp->priority);
-  }
-  if (0 == GNUNET_CONTAINER_heap_get_size (pp->priority_heap))
-  {
-    /* priority heap (still) empty, check for delay... */
-    rp = GNUNET_CONTAINER_heap_peek (pp->delay_heap);
-    if (NULL == rp)
+            (rp->earliest_transmission).rel_value_us))
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "No active requests for plan %p.\n",
-                  pp);
-      return;                   /* both queues empty */
+      GNUNET_assert(rp == GNUNET_CONTAINER_heap_remove_root(pp->delay_heap));
+      rp->hn = GNUNET_CONTAINER_heap_insert(pp->priority_heap,
+                                            rp,
+                                            rp->priority);
+    }
+  if (0 == GNUNET_CONTAINER_heap_get_size(pp->priority_heap))
+    {
+      /* priority heap (still) empty, check for delay... */
+      rp = GNUNET_CONTAINER_heap_peek(pp->delay_heap);
+      if (NULL == rp)
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                     "No active requests for plan %p.\n",
+                     pp);
+          return;               /* both queues empty */
+        }
+      delay = GNUNET_TIME_absolute_get_remaining(rp->earliest_transmission);
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Sleeping for %s before retrying requests on plan %p.\n",
+                 GNUNET_STRINGS_relative_time_to_string(delay,
+                                                        GNUNET_YES),
+                 pp);
+      GNUNET_STATISTICS_set(GSF_stats,
+                            gettext_noop("# delay heap timeout (ms)"),
+                            delay.rel_value_us / 1000LL, GNUNET_NO);
+
+      pp->task
+        = GNUNET_SCHEDULER_add_at(rp->earliest_transmission,
+                                  &schedule_peer_transmission,
+                                  pp);
+      return;
     }
-    delay = GNUNET_TIME_absolute_get_remaining (rp->earliest_transmission);
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Sleeping for %s before retrying requests on plan %p.\n",
-                GNUNET_STRINGS_relative_time_to_string (delay,
-                                                        GNUNET_YES),
-                pp);
-    GNUNET_STATISTICS_set (GSF_stats,
-                           gettext_noop ("# delay heap timeout (ms)"),
-                           delay.rel_value_us / 1000LL, GNUNET_NO);
-
-    pp->task
-      = GNUNET_SCHEDULER_add_at (rp->earliest_transmission,
-                                 &schedule_peer_transmission,
-                                 pp);
-    return;
-  }
 #if INSANE_STATISTICS
-  GNUNET_STATISTICS_update (GSF_stats,
-                            gettext_noop ("# query plans executed"),
-                            1,
-                            GNUNET_NO);
+  GNUNET_STATISTICS_update(GSF_stats,
+                           gettext_noop("# query plans executed"),
+                           1,
+                           GNUNET_NO);
 #endif
   /* process from priority heap */
-  rp = GNUNET_CONTAINER_heap_remove_root (pp->priority_heap);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Executing query plan %p\n",
-              rp);
-  GNUNET_assert (NULL != rp);
+  rp = GNUNET_CONTAINER_heap_remove_root(pp->priority_heap);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Executing query plan %p\n",
+             rp);
+  GNUNET_assert(NULL != rp);
   rp->hn = NULL;
-  rp->last_transmission = GNUNET_TIME_absolute_get ();
+  rp->last_transmission = GNUNET_TIME_absolute_get();
   rp->transmission_counter++;
   total_delay++;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Executing plan %p executed %u times, planning retransmission\n",
-              rp,
-              rp->transmission_counter);
-  GNUNET_assert (NULL == pp->env);
-  pp->env = GSF_pending_request_get_message_ (get_latest (rp));
-  GNUNET_MQ_notify_sent (pp->env,
-                         &schedule_peer_transmission,
-                         pp);
-  GSF_peer_transmit_ (pp->cp,
-                      GNUNET_YES,
-                      rp->priority,
-                      pp->env);
-  GNUNET_STATISTICS_update (GSF_stats,
-                            gettext_noop ("# query messages sent to other peers"),
-                            1,
-                            GNUNET_NO);
-  plan (pp,
-        rp);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Executing plan %p executed %u times, planning retransmission\n",
+             rp,
+             rp->transmission_counter);
+  GNUNET_assert(NULL == pp->env);
+  pp->env = GSF_pending_request_get_message_(get_latest(rp));
+  GNUNET_MQ_notify_sent(pp->env,
+                        &schedule_peer_transmission,
+                        pp);
+  GSF_peer_transmit_(pp->cp,
+                     GNUNET_YES,
+                     rp->priority,
+                     pp->env);
+  GNUNET_STATISTICS_update(GSF_stats,
+                           gettext_noop("# query messages sent to other peers"),
+                           1,
+                           GNUNET_NO);
+  plan(pp,
+       rp);
 }
 
 
 /**
  * Closure for merge_pr().
  */
-struct MergeContext
-{
-
+struct MergeContext {
   /**
    * Request we are trying to merge.
    */
@@ -486,7 +476,6 @@ struct MergeContext
    * Set to #GNUNET_YES if we succeeded to merge.
    */
   int merged;
-
 };
 
 
@@ -501,9 +490,9 @@ struct MergeContext
  *         #GNUNET_NO if not (merge success)
  */
 static int
-merge_pr (void *cls,
-          const struct GNUNET_HashCode *query,
-          void *element)
+merge_pr(void *cls,
+         const struct GNUNET_HashCode *query,
+         void *element)
 {
   struct MergeContext *mpr = cls;
   struct GSF_RequestPlan *rp = element;
@@ -511,44 +500,44 @@ merge_pr (void *cls,
   struct GSF_PendingRequestPlanBijection *bi;
   struct GSF_PendingRequest *latest;
 
-  GNUNET_break (GNUNET_YES ==
-                GSF_pending_request_test_active_ (mpr->pr));
+  GNUNET_break(GNUNET_YES ==
+               GSF_pending_request_test_active_(mpr->pr));
   if (GNUNET_OK !=
-      GSF_pending_request_is_compatible_ (mpr->pr,
-                                          rp->pe_head->pr))
+      GSF_pending_request_is_compatible_(mpr->pr,
+                                         rp->pe_head->pr))
     return GNUNET_YES;
   /* merge new request with existing request plan */
-  bi = GNUNET_new (struct GSF_PendingRequestPlanBijection);
+  bi = GNUNET_new(struct GSF_PendingRequestPlanBijection);
   bi->rp = rp;
   bi->pr = mpr->pr;
-  prd = GSF_pending_request_get_data_ (mpr->pr);
-  GNUNET_CONTAINER_MDLL_insert (PR,
-                                prd->pr_head,
-                                prd->pr_tail,
-                                bi);
-  GNUNET_CONTAINER_MDLL_insert (PE,
-                                rp->pe_head,
-                                rp->pe_tail,
-                                bi);
+  prd = GSF_pending_request_get_data_(mpr->pr);
+  GNUNET_CONTAINER_MDLL_insert(PR,
+                               prd->pr_head,
+                               prd->pr_tail,
+                               bi);
+  GNUNET_CONTAINER_MDLL_insert(PE,
+                               rp->pe_head,
+                               rp->pe_tail,
+                               bi);
   mpr->merged = GNUNET_YES;
 #if INSANE_STATISTICS
-  GNUNET_STATISTICS_update (GSF_stats,
-                            gettext_noop ("# requests merged"),
-                            1,
-                            GNUNET_NO);
+  GNUNET_STATISTICS_update(GSF_stats,
+                           gettext_noop("# requests merged"),
+                           1,
+                           GNUNET_NO);
 #endif
-  latest = get_latest (rp);
-  if (GSF_pending_request_get_data_ (latest)->ttl.abs_value_us <
+  latest = get_latest(rp);
+  if (GSF_pending_request_get_data_(latest)->ttl.abs_value_us <
       prd->ttl.abs_value_us)
-  {
+    {
 #if INSANE_STATISTICS
-    GNUNET_STATISTICS_update (GSF_stats,
-                              gettext_noop ("# requests refreshed"),
-                              1,
-                              GNUNET_NO);
+      GNUNET_STATISTICS_update(GSF_stats,
+                               gettext_noop("# requests refreshed"),
+                               1,
+                               GNUNET_NO);
 #endif
-    rp->transmission_counter = 0;       /* reset */
-  }
+      rp->transmission_counter = 0;     /* reset */
+    }
   return GNUNET_NO;
 }
 
@@ -560,8 +549,8 @@ merge_pr (void *cls,
  * @param pr request with the entry
  */
 void
-GSF_plan_add_ (struct GSF_ConnectedPeer *cp,
-               struct GSF_PendingRequest *pr)
+GSF_plan_add_(struct GSF_ConnectedPeer *cp,
+              struct GSF_PendingRequest *pr)
 {
   const struct GNUNET_PeerIdentity *id;
   struct PeerPlan *pp;
@@ -570,66 +559,66 @@ GSF_plan_add_ (struct GSF_ConnectedPeer *cp,
   struct GSF_PendingRequestPlanBijection *bi;
   struct MergeContext mpc;
 
-  GNUNET_assert (GNUNET_YES ==
-                 GSF_pending_request_test_active_ (pr));
-  GNUNET_assert (NULL != cp);
-  id = GSF_connected_peer_get_identity2_ (cp);
-  pp = GNUNET_CONTAINER_multipeermap_get (plans, id);
+  GNUNET_assert(GNUNET_YES ==
+                GSF_pending_request_test_active_(pr));
+  GNUNET_assert(NULL != cp);
+  id = GSF_connected_peer_get_identity2_(cp);
+  pp = GNUNET_CONTAINER_multipeermap_get(plans, id);
   if (NULL == pp)
-  {
-    pp = GNUNET_new (struct PeerPlan);
-    pp->plan_map = GNUNET_CONTAINER_multihashmap_create (128, GNUNET_NO);
-    pp->priority_heap =
-        GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MAX);
-    pp->delay_heap =
-        GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
-    pp->cp = cp;
-    GNUNET_assert (GNUNET_OK ==
-                   GNUNET_CONTAINER_multipeermap_put (plans,
+    {
+      pp = GNUNET_new(struct PeerPlan);
+      pp->plan_map = GNUNET_CONTAINER_multihashmap_create(128, GNUNET_NO);
+      pp->priority_heap =
+        GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MAX);
+      pp->delay_heap =
+        GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MIN);
+      pp->cp = cp;
+      GNUNET_assert(GNUNET_OK ==
+                    GNUNET_CONTAINER_multipeermap_put(plans,
                                                       id,
                                                       pp,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-    pp->task = GNUNET_SCHEDULER_add_now (&schedule_peer_transmission,
-                                         pp);
-  }
+      pp->task = GNUNET_SCHEDULER_add_now(&schedule_peer_transmission,
+                                          pp);
+    }
   mpc.merged = GNUNET_NO;
   mpc.pr = pr;
-  prd = GSF_pending_request_get_data_ (pr);
-  GNUNET_CONTAINER_multihashmap_get_multiple (pp->plan_map,
-                                              &prd->query,
-                                              &merge_pr,
-                                              &mpc);
+  prd = GSF_pending_request_get_data_(pr);
+  GNUNET_CONTAINER_multihashmap_get_multiple(pp->plan_map,
+                                             &prd->query,
+                                             &merge_pr,
+                                             &mpc);
   if (GNUNET_NO != mpc.merged)
     return;
   plan_count++;
-  GNUNET_STATISTICS_update (GSF_stats,
-                            gettext_noop ("# query plan entries"),
-                            1,
-                            GNUNET_NO);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Planning transmission of query `%s' to peer `%s'\n",
-              GNUNET_h2s (&prd->query),
-              GNUNET_i2s (id));
-  rp = GNUNET_new (struct GSF_RequestPlan);
-  bi = GNUNET_new (struct GSF_PendingRequestPlanBijection);
+  GNUNET_STATISTICS_update(GSF_stats,
+                           gettext_noop("# query plan entries"),
+                           1,
+                           GNUNET_NO);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Planning transmission of query `%s' to peer `%s'\n",
+             GNUNET_h2s(&prd->query),
+             GNUNET_i2s(id));
+  rp = GNUNET_new(struct GSF_RequestPlan);
+  bi = GNUNET_new(struct GSF_PendingRequestPlanBijection);
   bi->rp = rp;
   bi->pr = pr;
-  GNUNET_CONTAINER_MDLL_insert (PR,
-                                prd->pr_head,
-                                prd->pr_tail,
-                                bi);
-  GNUNET_CONTAINER_MDLL_insert (PE,
-                                rp->pe_head,
-                                rp->pe_tail,
-                                bi);
+  GNUNET_CONTAINER_MDLL_insert(PR,
+                               prd->pr_head,
+                               prd->pr_tail,
+                               bi);
+  GNUNET_CONTAINER_MDLL_insert(PE,
+                               rp->pe_head,
+                               rp->pe_tail,
+                               bi);
   rp->pp = pp;
-  GNUNET_assert (GNUNET_YES ==
-                 GNUNET_CONTAINER_multihashmap_put (pp->plan_map,
-                                                    get_rp_key (rp),
-                                                    rp,
-                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
-  plan (pp,
-        rp);
+  GNUNET_assert(GNUNET_YES ==
+                GNUNET_CONTAINER_multihashmap_put(pp->plan_map,
+                                                  get_rp_key(rp),
+                                                  rp,
+                                                  GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+  plan(pp,
+       rp);
 }
 
 
@@ -640,7 +629,7 @@ GSF_plan_add_ (struct GSF_ConnectedPeer *cp,
  * @param cp connected peer
  */
 void
-GSF_plan_notify_peer_disconnect_ (const struct GSF_ConnectedPeer *cp)
+GSF_plan_notify_peer_disconnect_(const struct GSF_ConnectedPeer *cp)
 {
   const struct GNUNET_PeerIdentity *id;
   struct PeerPlan *pp;
@@ -648,70 +637,70 @@ GSF_plan_notify_peer_disconnect_ (const struct GSF_ConnectedPeer *cp)
   struct GSF_PendingRequestData *prd;
   struct GSF_PendingRequestPlanBijection *bi;
 
-  id = GSF_connected_peer_get_identity2_ (cp);
-  pp = GNUNET_CONTAINER_multipeermap_get (plans, id);
+  id = GSF_connected_peer_get_identity2_(cp);
+  pp = GNUNET_CONTAINER_multipeermap_get(plans, id);
   if (NULL == pp)
     return;                     /* nothing was ever planned for this peer */
-  GNUNET_assert (GNUNET_YES ==
-                 GNUNET_CONTAINER_multipeermap_remove (plans, id,
-                                                       pp));
+  GNUNET_assert(GNUNET_YES ==
+                GNUNET_CONTAINER_multipeermap_remove(plans, id,
+                                                     pp));
   if (NULL != pp->task)
-  {
-    GNUNET_SCHEDULER_cancel (pp->task);
-    pp->task = NULL;
-  }
-  while (NULL != (rp = GNUNET_CONTAINER_heap_remove_root (pp->priority_heap)))
-  {
-    GNUNET_break (GNUNET_YES ==
-                  GNUNET_CONTAINER_multihashmap_remove (pp->plan_map,
-                                                        get_rp_key (rp),
-                                                        rp));
-    while (NULL != (bi = rp->pe_head))
     {
-      GNUNET_CONTAINER_MDLL_remove (PE,
-                                    rp->pe_head,
-                                    rp->pe_tail,
-                                    bi);
-      prd = GSF_pending_request_get_data_ (bi->pr);
-      GNUNET_CONTAINER_MDLL_remove (PR,
-                                    prd->pr_head,
-                                    prd->pr_tail,
-                                    bi);
-      GNUNET_free (bi);
+      GNUNET_SCHEDULER_cancel(pp->task);
+      pp->task = NULL;
     }
-    plan_count--;
-    GNUNET_free (rp);
-  }
-  GNUNET_CONTAINER_heap_destroy (pp->priority_heap);
-  while (NULL != (rp = GNUNET_CONTAINER_heap_remove_root (pp->delay_heap)))
-  {
-    GNUNET_break (GNUNET_YES ==
-                  GNUNET_CONTAINER_multihashmap_remove (pp->plan_map,
-                                                        get_rp_key (rp),
+  while (NULL != (rp = GNUNET_CONTAINER_heap_remove_root(pp->priority_heap)))
+    {
+      GNUNET_break(GNUNET_YES ==
+                   GNUNET_CONTAINER_multihashmap_remove(pp->plan_map,
+                                                        get_rp_key(rp),
                                                         rp));
-    while (NULL != (bi = rp->pe_head))
+      while (NULL != (bi = rp->pe_head))
+        {
+          GNUNET_CONTAINER_MDLL_remove(PE,
+                                       rp->pe_head,
+                                       rp->pe_tail,
+                                       bi);
+          prd = GSF_pending_request_get_data_(bi->pr);
+          GNUNET_CONTAINER_MDLL_remove(PR,
+                                       prd->pr_head,
+                                       prd->pr_tail,
+                                       bi);
+          GNUNET_free(bi);
+        }
+      plan_count--;
+      GNUNET_free(rp);
+    }
+  GNUNET_CONTAINER_heap_destroy(pp->priority_heap);
+  while (NULL != (rp = GNUNET_CONTAINER_heap_remove_root(pp->delay_heap)))
     {
-      prd = GSF_pending_request_get_data_ (bi->pr);
-      GNUNET_CONTAINER_MDLL_remove (PE,
-                                    rp->pe_head,
-                                    rp->pe_tail,
-                                    bi);
-      GNUNET_CONTAINER_MDLL_remove (PR,
-                                    prd->pr_head,
-                                    prd->pr_tail,
-                                    bi);
-      GNUNET_free (bi);
+      GNUNET_break(GNUNET_YES ==
+                   GNUNET_CONTAINER_multihashmap_remove(pp->plan_map,
+                                                        get_rp_key(rp),
+                                                        rp));
+      while (NULL != (bi = rp->pe_head))
+        {
+          prd = GSF_pending_request_get_data_(bi->pr);
+          GNUNET_CONTAINER_MDLL_remove(PE,
+                                       rp->pe_head,
+                                       rp->pe_tail,
+                                       bi);
+          GNUNET_CONTAINER_MDLL_remove(PR,
+                                       prd->pr_head,
+                                       prd->pr_tail,
+                                       bi);
+          GNUNET_free(bi);
+        }
+      plan_count--;
+      GNUNET_free(rp);
     }
-    plan_count--;
-    GNUNET_free (rp);
-  }
-  GNUNET_STATISTICS_set (GSF_stats,
-                         gettext_noop ("# query plan entries"),
-                         plan_count,
-                         GNUNET_NO);
-  GNUNET_CONTAINER_heap_destroy (pp->delay_heap);
-  GNUNET_CONTAINER_multihashmap_destroy (pp->plan_map);
-  GNUNET_free (pp);
+  GNUNET_STATISTICS_set(GSF_stats,
+                        gettext_noop("# query plan entries"),
+                        plan_count,
+                        GNUNET_NO);
+  GNUNET_CONTAINER_heap_destroy(pp->delay_heap);
+  GNUNET_CONTAINER_multihashmap_destroy(pp->plan_map);
+  GNUNET_free(pp);
 }
 
 
@@ -725,23 +714,23 @@ GSF_plan_notify_peer_disconnect_ (const struct GSF_ConnectedPeer *cp)
  * @return #GNUNET_YES if @a result was changed, #GNUNET_NO otherwise.
  */
 int
-GSF_request_plan_reference_get_last_transmission_ (struct GSF_PendingRequestPlanBijection *pr_head,
-                                                   struct GSF_ConnectedPeer *sender,
-                                                   struct GNUNET_TIME_Absolute *result)
+GSF_request_plan_reference_get_last_transmission_(struct GSF_PendingRequestPlanBijection *pr_head,
+                                                  struct GSF_ConnectedPeer *sender,
+                                                  struct GNUNET_TIME_Absolute *result)
 {
   struct GSF_PendingRequestPlanBijection *bi;
 
   for (bi = pr_head; NULL != bi; bi = bi->next_PR)
-  {
-    if (bi->rp->pp->cp == sender)
     {
-      if (0 == bi->rp->last_transmission.abs_value_us)
-        *result = GNUNET_TIME_UNIT_FOREVER_ABS;
-      else
-        *result = bi->rp->last_transmission;
-      return GNUNET_YES;
+      if (bi->rp->pp->cp == sender)
+        {
+          if (0 == bi->rp->last_transmission.abs_value_us)
+            *result = GNUNET_TIME_UNIT_FOREVER_ABS;
+          else
+            *result = bi->rp->last_transmission;
+          return GNUNET_YES;
+        }
     }
-  }
   return GNUNET_NO;
 }
 
@@ -753,41 +742,41 @@ GSF_request_plan_reference_get_last_transmission_ (struct GSF_PendingRequestPlan
  * @param pr request that is done
  */
 void
-GSF_plan_notify_request_done_ (struct GSF_PendingRequest *pr)
+GSF_plan_notify_request_done_(struct GSF_PendingRequest *pr)
 {
   struct GSF_RequestPlan *rp;
   struct GSF_PendingRequestData *prd;
   struct GSF_PendingRequestPlanBijection *bi;
 
-  prd = GSF_pending_request_get_data_ (pr);
+  prd = GSF_pending_request_get_data_(pr);
   while (NULL != (bi = prd->pr_head))
-  {
-    rp = bi->rp;
-    GNUNET_CONTAINER_MDLL_remove (PR,
-                                  prd->pr_head,
-                                  prd->pr_tail,
-                                  bi);
-    GNUNET_CONTAINER_MDLL_remove (PE,
-                                  rp->pe_head,
-                                  rp->pe_tail,
-                                  bi);
-    GNUNET_assert (bi->pr == pr);
-    if (NULL == rp->pe_head)
     {
-      GNUNET_CONTAINER_heap_remove_node (rp->hn);
-      plan_count--;
-      GNUNET_break (GNUNET_YES ==
-                    GNUNET_CONTAINER_multihashmap_remove (rp->pp->plan_map,
-                                                          &prd->query,
-                                                          rp));
-      GNUNET_free (rp);
+      rp = bi->rp;
+      GNUNET_CONTAINER_MDLL_remove(PR,
+                                   prd->pr_head,
+                                   prd->pr_tail,
+                                   bi);
+      GNUNET_CONTAINER_MDLL_remove(PE,
+                                   rp->pe_head,
+                                   rp->pe_tail,
+                                   bi);
+      GNUNET_assert(bi->pr == pr);
+      if (NULL == rp->pe_head)
+        {
+          GNUNET_CONTAINER_heap_remove_node(rp->hn);
+          plan_count--;
+          GNUNET_break(GNUNET_YES ==
+                       GNUNET_CONTAINER_multihashmap_remove(rp->pp->plan_map,
+                                                            &prd->query,
+                                                            rp));
+          GNUNET_free(rp);
+        }
+      GNUNET_free(bi);
     }
-    GNUNET_free (bi);
-  }
-  GNUNET_STATISTICS_set (GSF_stats,
-                         gettext_noop ("# query plan entries"),
-                         plan_count,
-                         GNUNET_NO);
+  GNUNET_STATISTICS_set(GSF_stats,
+                        gettext_noop("# query plan entries"),
+                        plan_count,
+                        GNUNET_NO);
 }
 
 
@@ -795,10 +784,10 @@ GSF_plan_notify_request_done_ (struct GSF_PendingRequest *pr)
  * Initialize plan subsystem.
  */
 void
-GSF_plan_init ()
+GSF_plan_init()
 {
-  plans = GNUNET_CONTAINER_multipeermap_create (256,
-                                                GNUNET_YES);
+  plans = GNUNET_CONTAINER_multipeermap_create(256,
+                                               GNUNET_YES);
 }
 
 
@@ -806,10 +795,10 @@ GSF_plan_init ()
  * Shutdown plan subsystem.
  */
 void
-GSF_plan_done ()
+GSF_plan_done()
 {
-  GNUNET_assert (0 == GNUNET_CONTAINER_multipeermap_size (plans));
-  GNUNET_CONTAINER_multipeermap_destroy (plans);
+  GNUNET_assert(0 == GNUNET_CONTAINER_multipeermap_size(plans));
+  GNUNET_CONTAINER_multipeermap_destroy(plans);
 }