global reindent, now with uncrustify hook enabled

5 files changed, 610 insertions, 598 deletions

diff --git a/src/fragmentation/defragmentation.c b/src/fragmentation/defragmentation.c
index d68a98c52..5dd935d7d 100644
--- a/src/fragmentation/defragmentation.c
+++ b/src/fragmentation/defragmentation.c
@@ -29,7 +29,8 @@
 /**
  * Timestamps for fragments.
  */
-struct FragTimes {
+struct FragTimes
+{
   /**
    * The time the fragment was received.
    */
@@ -48,7 +49,8 @@ struct FragTimes {
  * handle 'stray' messages that are received 'late'.  A message
  * context is ONLY discarded when the queue gets too big.
  */
-struct MessageContext {
+struct MessageContext
+{
   /**
    * This is a DLL.
    */
@@ -81,7 +83,7 @@ struct MessageContext {
    * Task scheduled for transmitting the next ACK to the
    * other peer.
    */
-  struct GNUNET_SCHEDULER_Task * ack_task;
+  struct GNUNET_SCHEDULER_Task *ack_task;
 
   /**
    * When did we receive which fragment? Used to calculate
@@ -132,7 +134,8 @@ struct MessageContext {
 /**
  * Defragmentation context (one per connection).
  */
-struct GNUNET_DEFRAGMENT_Context {
+struct GNUNET_DEFRAGMENT_Context
+{
   /**
    * For statistics.
    */
@@ -202,15 +205,15 @@ struct GNUNET_DEFRAGMENT_Context {
  * @return the defragmentation context
  */
 struct GNUNET_DEFRAGMENT_Context *
-GNUNET_DEFRAGMENT_context_create(struct GNUNET_STATISTICS_Handle *stats,
-                                 uint16_t mtu, unsigned int num_msgs,
-                                 void *cls,
-                                 GNUNET_FRAGMENT_MessageProcessor proc,
-                                 GNUNET_DEFRAGMENT_AckProcessor ackp)
+GNUNET_DEFRAGMENT_context_create (struct GNUNET_STATISTICS_Handle *stats,
+                                  uint16_t mtu, unsigned int num_msgs,
+                                  void *cls,
+                                  GNUNET_FRAGMENT_MessageProcessor proc,
+                                  GNUNET_DEFRAGMENT_AckProcessor ackp)
 {
   struct GNUNET_DEFRAGMENT_Context *dc;
 
-  dc = GNUNET_new(struct GNUNET_DEFRAGMENT_Context);
+  dc = GNUNET_new (struct GNUNET_DEFRAGMENT_Context);
   dc->stats = stats;
   dc->cls = cls;
   dc->proc = proc;
@@ -228,23 +231,23 @@ GNUNET_DEFRAGMENT_context_create(struct GNUNET_STATISTICS_Handle *stats,
  * @param dc defragmentation context
  */
 void
-GNUNET_DEFRAGMENT_context_destroy(struct GNUNET_DEFRAGMENT_Context *dc)
+GNUNET_DEFRAGMENT_context_destroy (struct GNUNET_DEFRAGMENT_Context *dc)
 {
   struct MessageContext *mc;
 
   while (NULL != (mc = dc->head))
+  {
+    GNUNET_CONTAINER_DLL_remove (dc->head, dc->tail, mc);
+    dc->list_size--;
+    if (NULL != mc->ack_task)
     {
-      GNUNET_CONTAINER_DLL_remove(dc->head, dc->tail, mc);
-      dc->list_size--;
-      if (NULL != mc->ack_task)
-        {
-          GNUNET_SCHEDULER_cancel(mc->ack_task);
-          mc->ack_task = NULL;
-        }
-      GNUNET_free(mc);
+      GNUNET_SCHEDULER_cancel (mc->ack_task);
+      mc->ack_task = NULL;
     }
-  GNUNET_assert(0 == dc->list_size);
-  GNUNET_free(dc);
+    GNUNET_free (mc);
+  }
+  GNUNET_assert (0 == dc->list_size);
+  GNUNET_free (dc);
 }
 
 
@@ -254,25 +257,25 @@ GNUNET_DEFRAGMENT_context_destroy(struct GNUNET_DEFRAGMENT_Context *dc)
  * @param cls the message context
  */
 static void
-send_ack(void *cls)
+send_ack (void *cls)
 {
   struct MessageContext *mc = cls;
   struct GNUNET_DEFRAGMENT_Context *dc = mc->dc;
   struct FragmentAcknowledgement fa;
 
   mc->ack_task = NULL;
-  fa.header.size = htons(sizeof(struct FragmentAcknowledgement));
-  fa.header.type = htons(GNUNET_MESSAGE_TYPE_FRAGMENT_ACK);
-  fa.fragment_id = htonl(mc->fragment_id);
-  fa.bits = GNUNET_htonll(mc->bits);
-  GNUNET_STATISTICS_update(mc->dc->stats,
-                           _("# acknowledgements sent for fragment"),
-                           1,
-                           GNUNET_NO);
+  fa.header.size = htons (sizeof(struct FragmentAcknowledgement));
+  fa.header.type = htons (GNUNET_MESSAGE_TYPE_FRAGMENT_ACK);
+  fa.fragment_id = htonl (mc->fragment_id);
+  fa.bits = GNUNET_htonll (mc->bits);
+  GNUNET_STATISTICS_update (mc->dc->stats,
+                            _ ("# acknowledgements sent for fragment"),
+                            1,
+                            GNUNET_NO);
   mc->last_duplicate = GNUNET_NO; /* clear flag */
-  dc->ackp(dc->cls,
-           mc->fragment_id,
-           &fa.header);
+  dc->ackp (dc->cls,
+            mc->fragment_id,
+            &fa.header);
 }
 
 
@@ -281,28 +284,28 @@ send_ack(void *cls)
  * Copyright (C) 2000 Brian Gough
  */
 static void
-gsl_fit_mul(const double *x, const size_t xstride, const double *y,
-            const size_t ystride, const size_t n, double *c1, double *cov_11,
-            double *sumsq)
+gsl_fit_mul (const double *x, const size_t xstride, const double *y,
+             const size_t ystride, const size_t n, double *c1, double *cov_11,
+             double *sumsq)
 {
   double m_x = 0, m_y = 0, m_dx2 = 0, m_dxdy = 0;
 
   size_t i;
 
   for (i = 0; i < n; i++)
-    {
-      m_x += (x[i * xstride] - m_x) / (i + 1.0);
-      m_y += (y[i * ystride] - m_y) / (i + 1.0);
-    }
+  {
+    m_x += (x[i * xstride] - m_x) / (i + 1.0);
+    m_y += (y[i * ystride] - m_y) / (i + 1.0);
+  }
 
   for (i = 0; i < n; i++)
-    {
-      const double dx = x[i * xstride] - m_x;
-      const double dy = y[i * ystride] - m_y;
+  {
+    const double dx = x[i * xstride] - m_x;
+    const double dy = y[i * ystride] - m_y;
 
-      m_dx2 += (dx * dx - m_dx2) / (i + 1.0);
-      m_dxdy += (dx * dy - m_dxdy) / (i + 1.0);
-    }
+    m_dx2 += (dx * dx - m_dx2) / (i + 1.0);
+    m_dxdy += (dx * dy - m_dxdy) / (i + 1.0);
+  }
 
   /* In terms of y =  b x */
 
@@ -315,13 +318,13 @@ gsl_fit_mul(const double *x, const size_t xstride, const double *y,
     /* Compute chi^2 = \sum (y_i -  b * x_i)^2 */
 
     for (i = 0; i < n; i++)
-      {
-        const double dx = x[i * xstride] - m_x;
-        const double dy = y[i * ystride] - m_y;
-        const double d = (m_y - b * m_x) + dy - b * dx;
+    {
+      const double dx = x[i * xstride] - m_x;
+      const double dy = y[i * ystride] - m_y;
+      const double d = (m_y - b * m_x) + dy - b * dx;
 
-        d2 += d * d;
-      }
+      d2 += d * d;
+    }
 
     s2 = d2 / (n - 1.0);        /* chisq per degree of freedom */
 
@@ -340,7 +343,7 @@ gsl_fit_mul(const double *x, const size_t xstride, const double *y,
  * @return average delay between time stamps (based on least-squares fit)
  */
 static struct GNUNET_TIME_Relative
-estimate_latency(struct MessageContext *mc)
+estimate_latency (struct MessageContext *mc)
 {
   struct FragTimes *first;
   size_t total = mc->frag_times_write_offset - mc->frag_times_start_offset;
@@ -353,15 +356,15 @@ estimate_latency(struct MessageContext *mc)
   struct GNUNET_TIME_Relative ret;
 
   first = &mc->frag_times[mc->frag_times_start_offset];
-  GNUNET_assert(total > 1);
+  GNUNET_assert (total > 1);
   for (i = 0; i < total; i++)
-    {
-      x[i] = (double)i;
-      y[i] = (double)(first[i].time.abs_value_us - first[0].time.abs_value_us);
-    }
-  gsl_fit_mul(x, 1, y, 1, total, &c1, &cov11, &sumsq);
-  c1 += sqrt(sumsq);            /* add 1 std dev */
-  ret.rel_value_us = (uint64_t)c1;
+  {
+    x[i] = (double) i;
+    y[i] = (double) (first[i].time.abs_value_us - first[0].time.abs_value_us);
+  }
+  gsl_fit_mul (x, 1, y, 1, total, &c1, &cov11, &sumsq);
+  c1 += sqrt (sumsq);            /* add 1 std dev */
+  ret.rel_value_us = (uint64_t) c1;
   if (0 == ret.rel_value_us)
     ret = GNUNET_TIME_UNIT_MICROSECONDS;        /* always at least 1 */
   return ret;
@@ -374,7 +377,7 @@ estimate_latency(struct MessageContext *mc)
  * @param dc defragmentation context
  */
 static void
-discard_oldest_mc(struct GNUNET_DEFRAGMENT_Context *dc)
+discard_oldest_mc (struct GNUNET_DEFRAGMENT_Context *dc)
 {
   struct MessageContext *old;
   struct MessageContext *pos;
@@ -382,21 +385,21 @@ discard_oldest_mc(struct GNUNET_DEFRAGMENT_Context *dc)
   old = NULL;
   pos = dc->head;
   while (NULL != pos)
-    {
-      if ((old == NULL) ||
-          (old->last_update.abs_value_us > pos->last_update.abs_value_us))
-        old = pos;
-      pos = pos->next;
-    }
-  GNUNET_assert(NULL != old);
-  GNUNET_CONTAINER_DLL_remove(dc->head, dc->tail, old);
+  {
+    if ((old == NULL) ||
+        (old->last_update.abs_value_us > pos->last_update.abs_value_us))
+      old = pos;
+    pos = pos->next;
+  }
+  GNUNET_assert (NULL != old);
+  GNUNET_CONTAINER_DLL_remove (dc->head, dc->tail, old);
   dc->list_size--;
   if (NULL != old->ack_task)
-    {
-      GNUNET_SCHEDULER_cancel(old->ack_task);
-      old->ack_task = NULL;
-    }
-  GNUNET_free(old);
+  {
+    GNUNET_SCHEDULER_cancel (old->ack_task);
+    old->ack_task = NULL;
+  }
+  GNUNET_free (old);
 }
 
 
@@ -410,8 +413,8 @@ discard_oldest_mc(struct GNUNET_DEFRAGMENT_Context *dc)
  *         #GNUNET_SYSERR on error
  */
 int
-GNUNET_DEFRAGMENT_process_fragment(struct GNUNET_DEFRAGMENT_Context *dc,
-                                   const struct GNUNET_MessageHeader *msg)
+GNUNET_DEFRAGMENT_process_fragment (struct GNUNET_DEFRAGMENT_Context *dc,
+                                    const struct GNUNET_MessageHeader *msg)
 {
   struct MessageContext *mc;
   const struct FragmentHeader *fh;
@@ -429,40 +432,41 @@ GNUNET_DEFRAGMENT_process_fragment(struct GNUNET_DEFRAGMENT_Context *dc,
   int duplicate;
   int last;
 
-  if (ntohs(msg->size) < sizeof(struct FragmentHeader))
-    {
-      GNUNET_break_op(0);
-      return GNUNET_SYSERR;
-    }
-  if (ntohs(msg->size) > dc->mtu)
-    {
-      GNUNET_break_op(0);
-      return GNUNET_SYSERR;
-    }
-  fh = (const struct FragmentHeader *)msg;
-  msize = ntohs(fh->total_size);
+  if (ntohs (msg->size) < sizeof(struct FragmentHeader))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  if (ntohs (msg->size) > dc->mtu)
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  fh = (const struct FragmentHeader *) msg;
+  msize = ntohs (fh->total_size);
   if (msize < sizeof(struct GNUNET_MessageHeader))
-    {
-      GNUNET_break_op(0);
-      return GNUNET_SYSERR;
-    }
-  fid = ntohl(fh->fragment_id);
-  foff = ntohs(fh->offset);
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  fid = ntohl (fh->fragment_id);
+  foff = ntohs (fh->offset);
   if (foff >= msize)
-    {
-      GNUNET_break_op(0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
   if (0 != (foff % (dc->mtu - sizeof(struct FragmentHeader))))
-    {
-      GNUNET_break_op(0);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_STATISTICS_update(dc->stats,
-                           _("# fragments received"),
-                           1,
-                           GNUNET_NO);
-  num_fragments = (ntohs(msg->size) + dc->mtu - sizeof(struct FragmentHeader) - 1) / (dc->mtu - sizeof(struct FragmentHeader));
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_STATISTICS_update (dc->stats,
+                            _ ("# fragments received"),
+                            1,
+                            GNUNET_NO);
+  num_fragments = (ntohs (msg->size) + dc->mtu - sizeof(struct FragmentHeader)
+                   - 1) / (dc->mtu - sizeof(struct FragmentHeader));
   last = 0;
   for (mc = dc->head; NULL != mc; mc = mc->next)
     if (mc->fragment_id > fid)
@@ -472,67 +476,68 @@ GNUNET_DEFRAGMENT_process_fragment(struct GNUNET_DEFRAGMENT_Context *dc,
   while ((NULL != mc) && (fid != mc->fragment_id))
     mc = mc->next;
   bit = foff / (dc->mtu - sizeof(struct FragmentHeader));
-  if (bit * (dc->mtu - sizeof(struct FragmentHeader)) + ntohs(msg->size) -
-      sizeof(struct FragmentHeader) > msize)
-    {
-      /* payload extends past total message size */
-      GNUNET_break_op(0);
-      return GNUNET_SYSERR;
-    }
+  if (bit * (dc->mtu - sizeof(struct FragmentHeader)) + ntohs (msg->size)
+      - sizeof(struct FragmentHeader) > msize)
+  {
+    /* payload extends past total message size */
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
   if ((NULL != mc) && (msize != mc->total_size))
-    {
-      /* inconsistent message size */
-      GNUNET_break_op(0);
-      return GNUNET_SYSERR;
-    }
-  now = GNUNET_TIME_absolute_get();
+  {
+    /* inconsistent message size */
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  now = GNUNET_TIME_absolute_get ();
   if (NULL == mc)
-    {
-      mc = GNUNET_malloc(sizeof(struct MessageContext) + msize);
-      mc->msg = (const struct GNUNET_MessageHeader *)&mc[1];
-      mc->dc = dc;
-      mc->total_size = msize;
-      mc->fragment_id = fid;
-      mc->last_update = now;
-      n = (msize + dc->mtu - sizeof(struct FragmentHeader) - 1) / (dc->mtu -
-                                                                   sizeof(struct
+  {
+    mc = GNUNET_malloc (sizeof(struct MessageContext) + msize);
+    mc->msg = (const struct GNUNET_MessageHeader *) &mc[1];
+    mc->dc = dc;
+    mc->total_size = msize;
+    mc->fragment_id = fid;
+    mc->last_update = now;
+    n = (msize + dc->mtu - sizeof(struct FragmentHeader) - 1) / (dc->mtu
+                                                                 - sizeof(struct
                                                                           FragmentHeader));
-      if (n == 64)
-        mc->bits = UINT64_MAX;  /* set all 64 bit */
-      else
-        mc->bits = (1LLU << n) - 1;      /* set lowest 'bits' bit */
-      if (dc->list_size >= dc->num_msgs)
-        discard_oldest_mc(dc);
-      GNUNET_CONTAINER_DLL_insert(dc->head,
-                                  dc->tail,
-                                  mc);
-      dc->list_size++;
-    }
+    if (n == 64)
+      mc->bits = UINT64_MAX;    /* set all 64 bit */
+    else
+      mc->bits = (1LLU << n) - 1;        /* set lowest 'bits' bit */
+    if (dc->list_size >= dc->num_msgs)
+      discard_oldest_mc (dc);
+    GNUNET_CONTAINER_DLL_insert (dc->head,
+                                 dc->tail,
+                                 mc);
+    dc->list_size++;
+  }
 
   /* copy data to 'mc' */
   if (0 != (mc->bits & (1LLU << bit)))
-    {
-      mc->bits -= 1LLU << bit;
-      mbuf = (char *)&mc[1];
-      GNUNET_memcpy(&mbuf[bit * (dc->mtu - sizeof(struct FragmentHeader))], &fh[1],
-                    ntohs(msg->size) - sizeof(struct FragmentHeader));
-      mc->last_update = now;
-      if (bit < mc->last_bit)
-        mc->frag_times_start_offset = mc->frag_times_write_offset;
-      mc->last_bit = bit;
-      mc->frag_times[mc->frag_times_write_offset].time = now;
-      mc->frag_times[mc->frag_times_write_offset].bit = bit;
-      mc->frag_times_write_offset++;
-      duplicate = GNUNET_NO;
-    }
+  {
+    mc->bits -= 1LLU << bit;
+    mbuf = (char *) &mc[1];
+    GNUNET_memcpy (&mbuf[bit * (dc->mtu - sizeof(struct FragmentHeader))],
+                   &fh[1],
+                   ntohs (msg->size) - sizeof(struct FragmentHeader));
+    mc->last_update = now;
+    if (bit < mc->last_bit)
+      mc->frag_times_start_offset = mc->frag_times_write_offset;
+    mc->last_bit = bit;
+    mc->frag_times[mc->frag_times_write_offset].time = now;
+    mc->frag_times[mc->frag_times_write_offset].bit = bit;
+    mc->frag_times_write_offset++;
+    duplicate = GNUNET_NO;
+  }
   else
-    {
-      duplicate = GNUNET_YES;
-      GNUNET_STATISTICS_update(dc->stats,
-                               _("# duplicate fragments received"),
-                               1,
-                               GNUNET_NO);
-    }
+  {
+    duplicate = GNUNET_YES;
+    GNUNET_STATISTICS_update (dc->stats,
+                              _ ("# duplicate fragments received"),
+                              1,
+                              GNUNET_NO);
+  }
 
   /* count number of missing fragments after the current one */
   bc = 0;
@@ -545,39 +550,39 @@ GNUNET_DEFRAGMENT_process_fragment(struct GNUNET_DEFRAGMENT_Context *dc,
   /* notify about complete message */
   if ((GNUNET_NO == duplicate) &&
       (0 == mc->bits))
-    {
-      GNUNET_STATISTICS_update(dc->stats,
-                               _("# messages defragmented"),
-                               1,
-                               GNUNET_NO);
-      /* message complete, notify! */
-      dc->proc(dc->cls, mc->msg);
-    }
+  {
+    GNUNET_STATISTICS_update (dc->stats,
+                              _ ("# messages defragmented"),
+                              1,
+                              GNUNET_NO);
+    /* message complete, notify! */
+    dc->proc (dc->cls, mc->msg);
+  }
   /* send ACK */
   if (mc->frag_times_write_offset - mc->frag_times_start_offset > 1)
-    {
-      dc->latency = estimate_latency(mc);
-    }
-  delay = GNUNET_TIME_relative_saturating_multiply(dc->latency,
-                                                   bc + 1);
+  {
+    dc->latency = estimate_latency (mc);
+  }
+  delay = GNUNET_TIME_relative_saturating_multiply (dc->latency,
+                                                    bc + 1);
   if ((last + fid == num_fragments) ||
       (0 == mc->bits) ||
       (GNUNET_YES == duplicate))
-    {
-      /* message complete or duplicate or last missing fragment in
-         linear sequence; ACK now! */
-      delay = GNUNET_TIME_UNIT_ZERO;
-    }
+  {
+    /* message complete or duplicate or last missing fragment in
+       linear sequence; ACK now! */
+    delay = GNUNET_TIME_UNIT_ZERO;
+  }
   if (NULL != mc->ack_task)
-    GNUNET_SCHEDULER_cancel(mc->ack_task);
-  mc->ack_task = GNUNET_SCHEDULER_add_delayed(delay,
-                                              &send_ack,
-                                              mc);
+    GNUNET_SCHEDULER_cancel (mc->ack_task);
+  mc->ack_task = GNUNET_SCHEDULER_add_delayed (delay,
+                                               &send_ack,
+                                               mc);
   if (GNUNET_YES == duplicate)
-    {
-      mc->last_duplicate = GNUNET_YES;
-      return GNUNET_NO;
-    }
+  {
+    mc->last_duplicate = GNUNET_YES;
+    return GNUNET_NO;
+  }
   return GNUNET_YES;
 }
 
diff --git a/src/fragmentation/fragmentation.c b/src/fragmentation/fragmentation.c
index 5f31f9094..3a7da37e8 100644
--- a/src/fragmentation/fragmentation.c
+++ b/src/fragmentation/fragmentation.c
@@ -31,13 +31,15 @@
 /**
  * Absolute minimum delay we impose between sending and expecting ACK to arrive.
  */
-#define MIN_ACK_DELAY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 1)
+#define MIN_ACK_DELAY GNUNET_TIME_relative_multiply ( \
+    GNUNET_TIME_UNIT_MILLISECONDS, 1)
 
 
 /**
  * Fragmentation context.
  */
-struct GNUNET_FRAGMENT_Context {
+struct GNUNET_FRAGMENT_Context
+{
   /**
    * Statistics to use.
    */
@@ -143,20 +145,20 @@ struct GNUNET_FRAGMENT_Context {
  * @return ack in human-readable format
  */
 const char *
-GNUNET_FRAGMENT_print_ack(const struct GNUNET_MessageHeader *ack)
+GNUNET_FRAGMENT_print_ack (const struct GNUNET_MessageHeader *ack)
 {
   static char buf[128];
   const struct FragmentAcknowledgement *fa;
 
   if (sizeof(struct FragmentAcknowledgement) !=
-      htons(ack->size))
+      htons (ack->size))
     return "<malformed ack>";
-  fa = (const struct FragmentAcknowledgement *)ack;
-  GNUNET_snprintf(buf,
-                  sizeof(buf),
-                  "%u-%llX",
-                  ntohl(fa->fragment_id),
-                  GNUNET_ntohll(fa->bits));
+  fa = (const struct FragmentAcknowledgement *) ack;
+  GNUNET_snprintf (buf,
+                   sizeof(buf),
+                   "%u-%llX",
+                   ntohl (fa->fragment_id),
+                   GNUNET_ntohll (fa->bits));
   return buf;
 }
 
@@ -167,7 +169,7 @@ GNUNET_FRAGMENT_print_ack(const struct GNUNET_MessageHeader *ack)
  * @param cls the `struct GNUNET_FRAGMENT_Context`
  */
 static void
-transmit_next(void *cls)
+transmit_next (void *cls)
 {
   struct GNUNET_FRAGMENT_Context *fc = cls;
   char msg[fc->mtu];
@@ -180,108 +182,108 @@ transmit_next(void *cls)
   int wrap;
 
   fc->task = NULL;
-  GNUNET_assert(GNUNET_NO == fc->proc_busy);
+  GNUNET_assert (GNUNET_NO == fc->proc_busy);
   if (0 == fc->acks)
     return;                     /* all done */
   /* calculate delay */
   wrap = 0;
   while (0 == (fc->acks & (1LLU << fc->next_transmission)))
-    {
-      fc->next_transmission = (fc->next_transmission + 1) % 64;
-      wrap |= (0 == fc->next_transmission);
-    }
+  {
+    fc->next_transmission = (fc->next_transmission + 1) % 64;
+    wrap |= (0 == fc->next_transmission);
+  }
   bit = fc->next_transmission;
-  size = ntohs(fc->msg->size);
+  size = ntohs (fc->msg->size);
   if (bit == size / (fc->mtu - sizeof(struct FragmentHeader)))
     fsize =
-      (size % (fc->mtu - sizeof(struct FragmentHeader))) +
-      sizeof(struct FragmentHeader);
+      (size % (fc->mtu - sizeof(struct FragmentHeader)))
+      + sizeof(struct FragmentHeader);
   else
     fsize = fc->mtu;
   if (NULL != fc->tracker)
-    delay = GNUNET_BANDWIDTH_tracker_get_delay(fc->tracker,
-                                               fsize);
+    delay = GNUNET_BANDWIDTH_tracker_get_delay (fc->tracker,
+                                                fsize);
   else
     delay = GNUNET_TIME_UNIT_ZERO;
   if (delay.rel_value_us > 0)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Fragmentation logic delays transmission of next fragment by %s\n",
-                 GNUNET_STRINGS_relative_time_to_string(delay,
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Fragmentation logic delays transmission of next fragment by %s\n",
+                GNUNET_STRINGS_relative_time_to_string (delay,
                                                         GNUNET_YES));
-      fc->task = GNUNET_SCHEDULER_add_delayed(delay,
-                                              &transmit_next,
-                                              fc);
-      return;
-    }
+    fc->task = GNUNET_SCHEDULER_add_delayed (delay,
+                                             &transmit_next,
+                                             fc);
+    return;
+  }
   fc->next_transmission = (fc->next_transmission + 1) % 64;
   wrap |= (0 == fc->next_transmission);
   while (0 == (fc->acks & (1LLU << fc->next_transmission)))
-    {
-      fc->next_transmission = (fc->next_transmission + 1) % 64;
-      wrap |= (0 == fc->next_transmission);
-    }
+  {
+    fc->next_transmission = (fc->next_transmission + 1) % 64;
+    wrap |= (0 == fc->next_transmission);
+  }
 
   /* assemble fragmentation message */
-  mbuf = (const char *)&fc[1];
-  fh = (struct FragmentHeader *)msg;
-  fh->header.size = htons(fsize);
-  fh->header.type = htons(GNUNET_MESSAGE_TYPE_FRAGMENT);
-  fh->fragment_id = htonl(fc->fragment_id);
+  mbuf = (const char *) &fc[1];
+  fh = (struct FragmentHeader *) msg;
+  fh->header.size = htons (fsize);
+  fh->header.type = htons (GNUNET_MESSAGE_TYPE_FRAGMENT);
+  fh->fragment_id = htonl (fc->fragment_id);
   fh->total_size = fc->msg->size;       /* already in big-endian */
-  fh->offset = htons((fc->mtu - sizeof(struct FragmentHeader)) * bit);
-  GNUNET_memcpy(&fh[1], &mbuf[bit * (fc->mtu - sizeof(struct FragmentHeader))],
-                fsize - sizeof(struct FragmentHeader));
+  fh->offset = htons ((fc->mtu - sizeof(struct FragmentHeader)) * bit);
+  GNUNET_memcpy (&fh[1], &mbuf[bit * (fc->mtu - sizeof(struct FragmentHeader))],
+                 fsize - sizeof(struct FragmentHeader));
   if (NULL != fc->tracker)
-    GNUNET_BANDWIDTH_tracker_consume(fc->tracker, fsize);
-  GNUNET_STATISTICS_update(fc->stats,
-                           _("# fragments transmitted"),
-                           1,
-                           GNUNET_NO);
+    GNUNET_BANDWIDTH_tracker_consume (fc->tracker, fsize);
+  GNUNET_STATISTICS_update (fc->stats,
+                            _ ("# fragments transmitted"),
+                            1,
+                            GNUNET_NO);
   if (0 != fc->last_round.abs_value_us)
-    GNUNET_STATISTICS_update(fc->stats,
-                             _("# fragments retransmitted"),
-                             1,
-                             GNUNET_NO);
+    GNUNET_STATISTICS_update (fc->stats,
+                              _ ("# fragments retransmitted"),
+                              1,
+                              GNUNET_NO);
 
   /* select next message to calculate delay */
   bit = fc->next_transmission;
-  size = ntohs(fc->msg->size);
+  size = ntohs (fc->msg->size);
   if (bit == size / (fc->mtu - sizeof(struct FragmentHeader)))
     fsize = size % (fc->mtu - sizeof(struct FragmentHeader));
   else
     fsize = fc->mtu;
   if (NULL != fc->tracker)
-    delay = GNUNET_BANDWIDTH_tracker_get_delay(fc->tracker,
-                                               fsize);
+    delay = GNUNET_BANDWIDTH_tracker_get_delay (fc->tracker,
+                                                fsize);
   else
     delay = GNUNET_TIME_UNIT_ZERO;
   if (fc->num_rounds < 64)
-    delay = GNUNET_TIME_relative_max(delay,
-                                     GNUNET_TIME_relative_saturating_multiply
-                                       (fc->msg_delay,
-                                       (1ULL << fc->num_rounds)));
+    delay = GNUNET_TIME_relative_max (delay,
+                                      GNUNET_TIME_relative_saturating_multiply
+                                        (fc->msg_delay,
+                                        (1ULL << fc->num_rounds)));
   else
     delay = GNUNET_TIME_UNIT_FOREVER_REL;
   if (wrap)
-    {
-      /* full round transmitted wait 2x delay for ACK before going again */
-      fc->num_rounds++;
-      delay = GNUNET_TIME_relative_saturating_multiply(fc->ack_delay, 2);
-      /* never use zero, need some time for ACK always */
-      delay = GNUNET_TIME_relative_max(MIN_ACK_DELAY, delay);
-      fc->wack = GNUNET_YES;
-      fc->last_round = GNUNET_TIME_absolute_get();
-      GNUNET_STATISTICS_update(fc->stats,
-                               _("# fragments wrap arounds"),
-                               1,
-                               GNUNET_NO);
-    }
+  {
+    /* full round transmitted wait 2x delay for ACK before going again */
+    fc->num_rounds++;
+    delay = GNUNET_TIME_relative_saturating_multiply (fc->ack_delay, 2);
+    /* never use zero, need some time for ACK always */
+    delay = GNUNET_TIME_relative_max (MIN_ACK_DELAY, delay);
+    fc->wack = GNUNET_YES;
+    fc->last_round = GNUNET_TIME_absolute_get ();
+    GNUNET_STATISTICS_update (fc->stats,
+                              _ ("# fragments wrap arounds"),
+                              1,
+                              GNUNET_NO);
+  }
   fc->proc_busy = GNUNET_YES;
-  fc->delay_until = GNUNET_TIME_relative_to_absolute(delay);
+  fc->delay_until = GNUNET_TIME_relative_to_absolute (delay);
   fc->num_transmissions++;
-  fc->proc(fc->proc_cls,
-           &fh->header);
+  fc->proc (fc->proc_cls,
+            &fh->header);
 }
 
 
@@ -306,53 +308,53 @@ transmit_next(void *cls)
  * @return the fragmentation context
  */
 struct GNUNET_FRAGMENT_Context *
-GNUNET_FRAGMENT_context_create(struct GNUNET_STATISTICS_Handle *stats,
-                               uint16_t mtu,
-                               struct GNUNET_BANDWIDTH_Tracker *tracker,
-                               struct GNUNET_TIME_Relative msg_delay,
-                               struct GNUNET_TIME_Relative ack_delay,
-                               const struct GNUNET_MessageHeader *msg,
-                               GNUNET_FRAGMENT_MessageProcessor proc,
-                               void *proc_cls)
+GNUNET_FRAGMENT_context_create (struct GNUNET_STATISTICS_Handle *stats,
+                                uint16_t mtu,
+                                struct GNUNET_BANDWIDTH_Tracker *tracker,
+                                struct GNUNET_TIME_Relative msg_delay,
+                                struct GNUNET_TIME_Relative ack_delay,
+                                const struct GNUNET_MessageHeader *msg,
+                                GNUNET_FRAGMENT_MessageProcessor proc,
+                                void *proc_cls)
 {
   struct GNUNET_FRAGMENT_Context *fc;
   size_t size;
   uint64_t bits;
 
-  GNUNET_STATISTICS_update(stats,
-                           _("# messages fragmented"),
-                           1,
-                           GNUNET_NO);
-  GNUNET_assert(mtu >= 1024 + sizeof(struct FragmentHeader));
-  size = ntohs(msg->size);
-  GNUNET_STATISTICS_update(stats,
-                           _("# total size of fragmented messages"),
-                           size, GNUNET_NO);
-  GNUNET_assert(size >= sizeof(struct GNUNET_MessageHeader));
-  fc = GNUNET_malloc(sizeof(struct GNUNET_FRAGMENT_Context) + size);
+  GNUNET_STATISTICS_update (stats,
+                            _ ("# messages fragmented"),
+                            1,
+                            GNUNET_NO);
+  GNUNET_assert (mtu >= 1024 + sizeof(struct FragmentHeader));
+  size = ntohs (msg->size);
+  GNUNET_STATISTICS_update (stats,
+                            _ ("# total size of fragmented messages"),
+                            size, GNUNET_NO);
+  GNUNET_assert (size >= sizeof(struct GNUNET_MessageHeader));
+  fc = GNUNET_malloc (sizeof(struct GNUNET_FRAGMENT_Context) + size);
   fc->stats = stats;
   fc->mtu = mtu;
   fc->tracker = tracker;
   fc->ack_delay = ack_delay;
   fc->msg_delay = msg_delay;
-  fc->msg = (const struct GNUNET_MessageHeader *)&fc[1];
+  fc->msg = (const struct GNUNET_MessageHeader *) &fc[1];
   fc->proc = proc;
   fc->proc_cls = proc_cls;
   fc->fragment_id =
-    GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK,
-                             UINT32_MAX);
-  GNUNET_memcpy(&fc[1], msg, size);
+    GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                              UINT32_MAX);
+  GNUNET_memcpy (&fc[1], msg, size);
   bits =
-    (size + mtu - sizeof(struct FragmentHeader) - 1) / (mtu -
-                                                        sizeof(struct
-                                                               FragmentHeader));
-  GNUNET_assert(bits <= 64);
+    (size + mtu - sizeof(struct FragmentHeader) - 1) / (mtu
+                                                        - sizeof(struct
+                                                                 FragmentHeader));
+  GNUNET_assert (bits <= 64);
   if (bits == 64)
     fc->acks_mask = UINT64_MAX; /* set all 64 bit */
   else
     fc->acks_mask = (1LLU << bits) - 1;  /* set lowest 'bits' bit */
   fc->acks = fc->acks_mask;
-  fc->task = GNUNET_SCHEDULER_add_now(&transmit_next, fc);
+  fc->task = GNUNET_SCHEDULER_add_now (&transmit_next, fc);
   return fc;
 }
 
@@ -365,15 +367,15 @@ GNUNET_FRAGMENT_context_create(struct GNUNET_STATISTICS_Handle *stats,
  * @param fc fragmentation context
  */
 void
-GNUNET_FRAGMENT_context_transmission_done(struct GNUNET_FRAGMENT_Context *fc)
+GNUNET_FRAGMENT_context_transmission_done (struct GNUNET_FRAGMENT_Context *fc)
 {
-  GNUNET_assert(fc->proc_busy == GNUNET_YES);
+  GNUNET_assert (fc->proc_busy == GNUNET_YES);
   fc->proc_busy = GNUNET_NO;
-  GNUNET_assert(fc->task == NULL);
+  GNUNET_assert (fc->task == NULL);
   fc->task =
-    GNUNET_SCHEDULER_add_at(fc->delay_until,
-                            &transmit_next,
-                            fc);
+    GNUNET_SCHEDULER_add_at (fc->delay_until,
+                             &transmit_next,
+                             fc);
 }
 
 
@@ -389,8 +391,8 @@ GNUNET_FRAGMENT_context_transmission_done(struct GNUNET_FRAGMENT_Context *fc)
  *         #GNUNET_SYSERR if this ack is not valid for this fc
  */
 int
-GNUNET_FRAGMENT_process_ack(struct GNUNET_FRAGMENT_Context *fc,
-                            const struct GNUNET_MessageHeader *msg)
+GNUNET_FRAGMENT_process_ack (struct GNUNET_FRAGMENT_Context *fc,
+                             const struct GNUNET_MessageHeader *msg)
 {
   const struct FragmentAcknowledgement *fa;
   uint64_t abits;
@@ -399,97 +401,100 @@ GNUNET_FRAGMENT_process_ack(struct GNUNET_FRAGMENT_Context *fc,
   unsigned int snd_cnt;
   unsigned int i;
 
-  if (sizeof(struct FragmentAcknowledgement) != ntohs(msg->size))
-    {
-      GNUNET_break_op(0);
-      return GNUNET_SYSERR;
-    }
-  fa = (const struct FragmentAcknowledgement *)msg;
-  if (ntohl(fa->fragment_id) != fc->fragment_id)
+  if (sizeof(struct FragmentAcknowledgement) != ntohs (msg->size))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  fa = (const struct FragmentAcknowledgement *) msg;
+  if (ntohl (fa->fragment_id) != fc->fragment_id)
     return GNUNET_SYSERR;       /* not our ACK */
-  abits = GNUNET_ntohll(fa->bits);
+  abits = GNUNET_ntohll (fa->bits);
   if ((GNUNET_YES == fc->wack) &&
       (0 != fc->num_transmissions))
+  {
+    /* normal ACK, can update running average of delay... */
+    fc->wack = GNUNET_NO;
+    ndelay = GNUNET_TIME_absolute_get_duration (fc->last_round);
+    fc->ack_delay.rel_value_us =
+      (ndelay.rel_value_us / fc->num_transmissions + 3
+       * fc->ack_delay.rel_value_us) / 4;
+    /* calculate ratio msg sent vs. msg acked */
+    ack_cnt = 0;
+    snd_cnt = 0;
+    for (i = 0; i < 64; i++)
     {
-      /* normal ACK, can update running average of delay... */
-      fc->wack = GNUNET_NO;
-      ndelay = GNUNET_TIME_absolute_get_duration(fc->last_round);
-      fc->ack_delay.rel_value_us =
-        (ndelay.rel_value_us / fc->num_transmissions + 3 * fc->ack_delay.rel_value_us) / 4;
-      /* calculate ratio msg sent vs. msg acked */
-      ack_cnt = 0;
-      snd_cnt = 0;
-      for (i = 0; i < 64; i++)
-        {
-          if (1 == (fc->acks_mask & (1ULL << i)))
-            {
-              snd_cnt++;
-              if (0 == (abits & (1ULL << i)))
-                ack_cnt++;
-            }
-        }
-      if (0 == ack_cnt)
-        {
-          /* complete loss */
-          fc->msg_delay = GNUNET_TIME_relative_saturating_multiply(fc->msg_delay,
-                                                                   snd_cnt);
-        }
-      else if (snd_cnt > ack_cnt)
-        {
-          /* some loss, slow down proportionally */
-          fc->msg_delay.rel_value_us = ((fc->msg_delay.rel_value_us * ack_cnt) / snd_cnt);
-        }
-      else if (snd_cnt == ack_cnt)
-        {
-          fc->msg_delay.rel_value_us =
-            (ndelay.rel_value_us / fc->num_transmissions + 3 * fc->msg_delay.rel_value_us) / 5;
-        }
-      fc->num_transmissions = 0;
-      fc->msg_delay = GNUNET_TIME_relative_min(fc->msg_delay,
-                                               GNUNET_TIME_UNIT_SECONDS);
-      fc->ack_delay = GNUNET_TIME_relative_min(fc->ack_delay,
-                                               GNUNET_TIME_UNIT_SECONDS);
+      if (1 == (fc->acks_mask & (1ULL << i)))
+      {
+        snd_cnt++;
+        if (0 == (abits & (1ULL << i)))
+          ack_cnt++;
+      }
     }
-  GNUNET_STATISTICS_update(fc->stats,
-                           _("# fragment acknowledgements received"),
-                           1,
-                           GNUNET_NO);
-  if (abits != (fc->acks & abits))
+    if (0 == ack_cnt)
+    {
+      /* complete loss */
+      fc->msg_delay = GNUNET_TIME_relative_saturating_multiply (fc->msg_delay,
+                                                                snd_cnt);
+    }
+    else if (snd_cnt > ack_cnt)
+    {
+      /* some loss, slow down proportionally */
+      fc->msg_delay.rel_value_us = ((fc->msg_delay.rel_value_us * ack_cnt)
+                                    / snd_cnt);
+    }
+    else if (snd_cnt == ack_cnt)
     {
-      /* ID collission or message reordering, count! This should be rare! */
-      GNUNET_STATISTICS_update(fc->stats,
-                               _("# bits removed from fragmentation ACKs"), 1,
-                               GNUNET_NO);
+      fc->msg_delay.rel_value_us =
+        (ndelay.rel_value_us / fc->num_transmissions + 3
+         * fc->msg_delay.rel_value_us) / 5;
     }
+    fc->num_transmissions = 0;
+    fc->msg_delay = GNUNET_TIME_relative_min (fc->msg_delay,
+                                              GNUNET_TIME_UNIT_SECONDS);
+    fc->ack_delay = GNUNET_TIME_relative_min (fc->ack_delay,
+                                              GNUNET_TIME_UNIT_SECONDS);
+  }
+  GNUNET_STATISTICS_update (fc->stats,
+                            _ ("# fragment acknowledgements received"),
+                            1,
+                            GNUNET_NO);
+  if (abits != (fc->acks & abits))
+  {
+    /* ID collission or message reordering, count! This should be rare! */
+    GNUNET_STATISTICS_update (fc->stats,
+                              _ ("# bits removed from fragmentation ACKs"), 1,
+                              GNUNET_NO);
+  }
   fc->acks = abits & fc->acks_mask;
   if (0 != fc->acks)
+  {
+    /* more to transmit, do so right now (if tracker permits...) */
+    if (fc->task != NULL)
+    {
+      /* schedule next transmission now, no point in waiting... */
+      GNUNET_SCHEDULER_cancel (fc->task);
+      fc->task = GNUNET_SCHEDULER_add_now (&transmit_next, fc);
+    }
+    else
     {
-      /* more to transmit, do so right now (if tracker permits...) */
-      if (fc->task != NULL)
-        {
-          /* schedule next transmission now, no point in waiting... */
-          GNUNET_SCHEDULER_cancel(fc->task);
-          fc->task = GNUNET_SCHEDULER_add_now(&transmit_next, fc);
-        }
-      else
-        {
-          /* only case where there is no task should be if we're waiting
-           * for the right to transmit again (proc_busy set to YES) */
-          GNUNET_assert(GNUNET_YES == fc->proc_busy);
-        }
-      return GNUNET_NO;
+      /* only case where there is no task should be if we're waiting
+       * for the right to transmit again (proc_busy set to YES) */
+      GNUNET_assert (GNUNET_YES == fc->proc_busy);
     }
+    return GNUNET_NO;
+  }
 
   /* all done */
-  GNUNET_STATISTICS_update(fc->stats,
-                           _("# fragmentation transmissions completed"),
-                           1,
-                           GNUNET_NO);
+  GNUNET_STATISTICS_update (fc->stats,
+                            _ ("# fragmentation transmissions completed"),
+                            1,
+                            GNUNET_NO);
   if (NULL != fc->task)
-    {
-      GNUNET_SCHEDULER_cancel(fc->task);
-      fc->task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (fc->task);
+    fc->task = NULL;
+  }
   return GNUNET_OK;
 }
 
@@ -505,18 +510,18 @@ GNUNET_FRAGMENT_process_ack(struct GNUNET_FRAGMENT_Context *fc,
  *         last message, set to FOREVER if the message was not fully transmitted (OUT only)
  */
 void
-GNUNET_FRAGMENT_context_destroy(struct GNUNET_FRAGMENT_Context *fc,
-                                struct GNUNET_TIME_Relative *msg_delay,
-                                struct GNUNET_TIME_Relative *ack_delay)
+GNUNET_FRAGMENT_context_destroy (struct GNUNET_FRAGMENT_Context *fc,
+                                 struct GNUNET_TIME_Relative *msg_delay,
+                                 struct GNUNET_TIME_Relative *ack_delay)
 {
   if (fc->task != NULL)
-    GNUNET_SCHEDULER_cancel(fc->task);
+    GNUNET_SCHEDULER_cancel (fc->task);
   if (NULL != ack_delay)
     *ack_delay = fc->ack_delay;
   if (NULL != msg_delay)
-    *msg_delay = GNUNET_TIME_relative_saturating_multiply(fc->msg_delay,
-                                                          fc->num_rounds);
-  GNUNET_free(fc);
+    *msg_delay = GNUNET_TIME_relative_saturating_multiply (fc->msg_delay,
+                                                           fc->num_rounds);
+  GNUNET_free (fc);
 }
 
 
diff --git a/src/fragmentation/fragmentation.h b/src/fragmentation/fragmentation.h
index 3578cadca..2d7abd4f7 100644
--- a/src/fragmentation/fragmentation.h
+++ b/src/fragmentation/fragmentation.h
@@ -33,7 +33,8 @@ GNUNET_NETWORK_STRUCT_BEGIN
  * Header for a message fragment.  Followed by the
  * original message.
  */
-struct FragmentHeader {
+struct FragmentHeader
+{
   /**
    * Message header.
    */
@@ -60,7 +61,8 @@ struct FragmentHeader {
 /**
  * Message fragment acknowledgement.
  */
-struct FragmentAcknowledgement {
+struct FragmentAcknowledgement
+{
   /**
    * Message header.
    */
diff --git a/src/fragmentation/test_fragmentation.c b/src/fragmentation/test_fragmentation.c
index b983ec2c5..4c71e0195 100644
--- a/src/fragmentation/test_fragmentation.c
+++ b/src/fragmentation/test_fragmentation.c
@@ -60,7 +60,7 @@ static struct GNUNET_BANDWIDTH_Tracker trackers[NUM_MSGS];
 
 static struct GNUNET_FRAGMENT_Context *frag;
 
-static struct GNUNET_SCHEDULER_Task * shutdown_task;
+static struct GNUNET_SCHEDULER_Task *shutdown_task;
 
 static struct GNUNET_TIME_Relative msg_delay;
 
@@ -68,52 +68,52 @@ static struct GNUNET_TIME_Relative ack_delay;
 
 
 static void
-do_shutdown(void *cls)
+do_shutdown (void *cls)
 {
   ret = 0;
   shutdown_task = NULL;
-  GNUNET_DEFRAGMENT_context_destroy(defrag);
+  GNUNET_DEFRAGMENT_context_destroy (defrag);
   defrag = NULL;
   if (NULL != frag)
-    {
-      GNUNET_FRAGMENT_context_destroy(frag, &msg_delay, &ack_delay);
-      frag = NULL;
-    }
-  fprintf(stderr,
-          "\nFinal message-delay: %s\n",
-          GNUNET_STRINGS_relative_time_to_string(msg_delay,
-                                                 GNUNET_YES));
-  fprintf(stderr,
-          "Final ack-delay: %s\n",
-          GNUNET_STRINGS_relative_time_to_string(ack_delay,
-                                                 GNUNET_YES));
+  {
+    GNUNET_FRAGMENT_context_destroy (frag, &msg_delay, &ack_delay);
+    frag = NULL;
+  }
+  fprintf (stderr,
+           "\nFinal message-delay: %s\n",
+           GNUNET_STRINGS_relative_time_to_string (msg_delay,
+                                                   GNUNET_YES));
+  fprintf (stderr,
+           "Final ack-delay: %s\n",
+           GNUNET_STRINGS_relative_time_to_string (ack_delay,
+                                                   GNUNET_YES));
 }
 
 
 static void
-proc_msgs(void *cls, const struct GNUNET_MessageHeader *hdr)
+proc_msgs (void *cls, const struct GNUNET_MessageHeader *hdr)
 {
   static unsigned int total;
   unsigned int i;
   const char *buf;
 
 #if DETAILS
-  fprintf(stderr, "%s", "M! ");          /* message complete, good! */
+  fprintf (stderr, "%s", "M! ");          /* message complete, good! */
 #endif
-  buf = (const char *)hdr;
-  for (i = sizeof(struct GNUNET_MessageHeader); i < ntohs(hdr->size); i++)
-    GNUNET_assert(buf[i] == (char)i);
+  buf = (const char *) hdr;
+  for (i = sizeof(struct GNUNET_MessageHeader); i < ntohs (hdr->size); i++)
+    GNUNET_assert (buf[i] == (char) i);
   total++;
-#if !DETAILS
+#if ! DETAILS
   if (0 == (total % (NUM_MSGS / 100)))
-    fprintf(stderr, "%s", ".");
+    fprintf (stderr, "%s", ".");
 #endif
   /* tolerate 10% loss, i.e. due to duplicate fragment IDs */
   if ((total >= NUM_MSGS - (NUM_MSGS / 10)) && (ret != 0))
-    {
-      if (NULL == shutdown_task)
-        shutdown_task = GNUNET_SCHEDULER_add_now(&do_shutdown, NULL);
-    }
+  {
+    if (NULL == shutdown_task)
+      shutdown_task = GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
+  }
 }
 
 
@@ -121,45 +121,45 @@ proc_msgs(void *cls, const struct GNUNET_MessageHeader *hdr)
  * Process fragment (by passing to defrag).
  */
 static void
-proc_frac(void *cls, const struct GNUNET_MessageHeader *hdr)
+proc_frac (void *cls, const struct GNUNET_MessageHeader *hdr)
 {
   struct GNUNET_FRAGMENT_Context **fc = cls;
   int ret;
 
-  GNUNET_FRAGMENT_context_transmission_done(*fc);
-  if (0 == GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, DROPRATE))
-    {
-      frag_drops++;
+  GNUNET_FRAGMENT_context_transmission_done (*fc);
+  if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, DROPRATE))
+  {
+    frag_drops++;
 #if DETAILS
-      fprintf(stderr, "%s", "DF ");    /* dropped Frag */
+    fprintf (stderr, "%s", "DF ");     /* dropped Frag */
 #endif
-      return;                   /* random drop */
-    }
+    return;                     /* random drop */
+  }
   if (NULL == defrag)
-    {
-      fprintf(stderr, "%s", "?E ");      /* Error: frag after shutdown!? */
-      return;
-    }
-  ret = GNUNET_DEFRAGMENT_process_fragment(defrag, hdr);
+  {
+    fprintf (stderr, "%s", "?E ");       /* Error: frag after shutdown!? */
+    return;
+  }
+  ret = GNUNET_DEFRAGMENT_process_fragment (defrag, hdr);
   if (ret == GNUNET_NO)
-    {
+  {
 #if DETAILS
-      fprintf(stderr, "%s", "FF ");      /* duplicate fragment */
+    fprintf (stderr, "%s", "FF ");       /* duplicate fragment */
 #endif
-      dups++;
-    }
+    dups++;
+  }
   else if (ret == GNUNET_OK)
-    {
+  {
 #if DETAILS
-      fprintf(stderr, "%s", "F! ");      /* good fragment */
+    fprintf (stderr, "%s", "F! ");       /* good fragment */
 #endif
-      fragc++;
-    }
+    fragc++;
+  }
 }
 
 
 static void
-next_transmission()
+next_transmission ()
 {
   static unsigned int i;
   struct GNUNET_MessageHeader *msg;
@@ -167,32 +167,32 @@ next_transmission()
   unsigned int j;
 
   if (0 == i)
-    {
-      for (j = 0; j < sizeof(buf); j++)
-        buf[j] = (char)j;
-    }
+  {
+    for (j = 0; j < sizeof(buf); j++)
+      buf[j] = (char) j;
+  }
   else
-    {
-      GNUNET_FRAGMENT_context_destroy(frag,
-                                      &msg_delay,
-                                      &ack_delay);
-      frag = NULL;
-    }
+  {
+    GNUNET_FRAGMENT_context_destroy (frag,
+                                     &msg_delay,
+                                     &ack_delay);
+    frag = NULL;
+  }
   if (i == NUM_MSGS)
     return;
 #if DETAILS
-  fprintf(stderr, "%s", "T! ");          /* sending message */
+  fprintf (stderr, "%s", "T! ");          /* sending message */
 #endif
-  msg = (struct GNUNET_MessageHeader *)buf;
-  msg->type = htons((uint16_t)i);
+  msg = (struct GNUNET_MessageHeader *) buf;
+  msg->type = htons ((uint16_t) i);
   msg->size =
-    htons(sizeof(struct GNUNET_MessageHeader) + (17 * i) % (32 * 1024));
-  frag = GNUNET_FRAGMENT_context_create(NULL /* no stats */,
-                                        MTU, &trackers[i],
-                                        msg_delay,
-                                        ack_delay,
-                                        msg,
-                                        &proc_frac, &frag);
+    htons (sizeof(struct GNUNET_MessageHeader) + (17 * i) % (32 * 1024));
+  frag = GNUNET_FRAGMENT_context_create (NULL /* no stats */,
+                                         MTU, &trackers[i],
+                                         msg_delay,
+                                         ack_delay,
+                                         msg,
+                                         &proc_frac, &frag);
   i++;
 }
 
@@ -201,46 +201,46 @@ next_transmission()
  * Process ACK (by passing to fragmenter)
  */
 static void
-proc_acks(void *cls,
-          uint32_t msg_id,
-          const struct GNUNET_MessageHeader *hdr)
+proc_acks (void *cls,
+           uint32_t msg_id,
+           const struct GNUNET_MessageHeader *hdr)
 {
   unsigned int i;
   int ret;
 
-  if (0 == GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, DROPRATE))
-    {
-      ack_drops++;
+  if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, DROPRATE))
+  {
+    ack_drops++;
 #if DETAILS
-      fprintf(stderr, "%s", "DA ");    /* dropped ACK */
+    fprintf (stderr, "%s", "DA ");     /* dropped ACK */
 #endif
-      return;                   /* random drop */
-    }
+    return;                     /* random drop */
+  }
   for (i = 0; i < NUM_MSGS; i++)
+  {
+    if (NULL == frag)
+      continue;
+    ret = GNUNET_FRAGMENT_process_ack (frag, hdr);
+    if (ret == GNUNET_OK)
     {
-      if (NULL == frag)
-        continue;
-      ret = GNUNET_FRAGMENT_process_ack(frag, hdr);
-      if (ret == GNUNET_OK)
-        {
 #if DETAILS
-          fprintf(stderr, "%s", "GA ");  /* good ACK */
+      fprintf (stderr, "%s", "GA ");     /* good ACK */
 #endif
-          next_transmission();
-          acks++;
-          return;
-        }
-      if (ret == GNUNET_NO)
-        {
+      next_transmission ();
+      acks++;
+      return;
+    }
+    if (ret == GNUNET_NO)
+    {
 #if DETAILS
-          fprintf(stderr, "%s", "AA ");  /* duplicate ACK */
+      fprintf (stderr, "%s", "AA ");     /* duplicate ACK */
 #endif
-          acks++;
-          return;
-        }
+      acks++;
+      return;
     }
+  }
 #if DETAILS
-  fprintf(stderr, "%s", "?A ");          /* BAD: ack that nobody feels responsible for... */
+  fprintf (stderr, "%s", "?A ");          /* BAD: ack that nobody feels responsible for... */
 #endif
 }
 
@@ -249,22 +249,22 @@ proc_acks(void *cls,
  * Main function run with scheduler.
  */
 static void
-run(void *cls,
-    char *const *args,
-    const char *cfgfile,
-    const struct GNUNET_CONFIGURATION_Handle *cfg)
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
-  defrag = GNUNET_DEFRAGMENT_context_create(NULL, MTU,
-                                            3,
-                                            NULL,
-                                            &proc_msgs,
-                                            &proc_acks);
-  next_transmission();
+  defrag = GNUNET_DEFRAGMENT_context_create (NULL, MTU,
+                                             3,
+                                             NULL,
+                                             &proc_msgs,
+                                             &proc_acks);
+  next_transmission ();
 }
 
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
   struct GNUNET_GETOPT_CommandLineOption options[] = {
     GNUNET_GETOPT_OPTION_END
@@ -281,23 +281,23 @@ main(int argc, char *argv[])
 
   msg_delay = GNUNET_TIME_UNIT_MILLISECONDS;
   ack_delay = GNUNET_TIME_UNIT_SECONDS;
-  GNUNET_log_setup("test-fragmentation",
-                   "WARNING",
-                   NULL);
+  GNUNET_log_setup ("test-fragmentation",
+                    "WARNING",
+                    NULL);
   for (i = 0; i < NUM_MSGS; i++)
-    GNUNET_BANDWIDTH_tracker_init(&trackers[i], NULL, NULL,
-                                  GNUNET_BANDWIDTH_value_init((i + 1) * 1024),
-                                  100);
-  GNUNET_PROGRAM_run(5,
-                     argv_prog,
-                     "test-fragmentation", "nohelp",
-                     options,
-                     &run, NULL);
-  fprintf(stderr,
-          "\nHad %u good fragments, %u duplicate fragments, %u acks and %u simulated drops of acks\n",
-          fragc,
-          dups,
-          acks,
-          ack_drops);
+    GNUNET_BANDWIDTH_tracker_init (&trackers[i], NULL, NULL,
+                                   GNUNET_BANDWIDTH_value_init ((i + 1) * 1024),
+                                   100);
+  GNUNET_PROGRAM_run (5,
+                      argv_prog,
+                      "test-fragmentation", "nohelp",
+                      options,
+                      &run, NULL);
+  fprintf (stderr,
+           "\nHad %u good fragments, %u duplicate fragments, %u acks and %u simulated drops of acks\n",
+           fragc,
+           dups,
+           acks,
+           ack_drops);
   return ret;
 }
diff --git a/src/fragmentation/test_fragmentation_parallel.c b/src/fragmentation/test_fragmentation_parallel.c
index 6db9c55a9..000ca60d2 100644
--- a/src/fragmentation/test_fragmentation_parallel.c
+++ b/src/fragmentation/test_fragmentation_parallel.c
@@ -64,48 +64,48 @@ static struct GNUNET_SCHEDULER_Task *shutdown_task;
 
 
 static void
-do_shutdown(void *cls)
+do_shutdown (void *cls)
 {
   unsigned int i;
 
   ret = 0;
   shutdown_task = NULL;
-  GNUNET_DEFRAGMENT_context_destroy(defrag);
+  GNUNET_DEFRAGMENT_context_destroy (defrag);
   defrag = NULL;
   for (i = 0; i < NUM_MSGS; i++)
-    {
-      if (frags[i] == NULL)
-        continue;
-      GNUNET_FRAGMENT_context_destroy(frags[i], NULL, NULL);
-      frags[i] = NULL;
-    }
+  {
+    if (frags[i] == NULL)
+      continue;
+    GNUNET_FRAGMENT_context_destroy (frags[i], NULL, NULL);
+    frags[i] = NULL;
+  }
 }
 
 
 static void
-proc_msgs(void *cls, const struct GNUNET_MessageHeader *hdr)
+proc_msgs (void *cls, const struct GNUNET_MessageHeader *hdr)
 {
   static unsigned int total;
   unsigned int i;
   const char *buf;
 
 #if DETAILS
-  fprintf(stderr, "%s", "!");          /* message complete, good! */
+  fprintf (stderr, "%s", "!");          /* message complete, good! */
 #endif
-  buf = (const char *)hdr;
-  for (i = sizeof(struct GNUNET_MessageHeader); i < ntohs(hdr->size); i++)
-    GNUNET_assert(buf[i] == (char)i);
+  buf = (const char *) hdr;
+  for (i = sizeof(struct GNUNET_MessageHeader); i < ntohs (hdr->size); i++)
+    GNUNET_assert (buf[i] == (char) i);
   total++;
-#if !DETAILS
+#if ! DETAILS
   if (0 == (total % (NUM_MSGS / 100)))
-    fprintf(stderr, "%s", ".");
+    fprintf (stderr, "%s", ".");
 #endif
   /* tolerate 10% loss, i.e. due to duplicate fragment IDs */
   if ((total >= NUM_MSGS - (NUM_MSGS / 10)) && (ret != 0))
-    {
-      if (NULL == shutdown_task)
-        shutdown_task = GNUNET_SCHEDULER_add_now(&do_shutdown, NULL);
-    }
+  {
+    if (NULL == shutdown_task)
+      shutdown_task = GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
+  }
 }
 
 
@@ -113,42 +113,42 @@ proc_msgs(void *cls, const struct GNUNET_MessageHeader *hdr)
  * Process ACK (by passing to fragmenter)
  */
 static void
-proc_acks(void *cls, uint32_t msg_id, const struct GNUNET_MessageHeader *hdr)
+proc_acks (void *cls, uint32_t msg_id, const struct GNUNET_MessageHeader *hdr)
 {
   unsigned int i;
   int ret;
 
-  if (0 == GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, DROPRATE))
-    {
-      ack_drops++;
-      return;                   /* random drop */
-    }
+  if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, DROPRATE))
+  {
+    ack_drops++;
+    return;                     /* random drop */
+  }
   for (i = 0; i < NUM_MSGS; i++)
+  {
+    if (frags[i] == NULL)
+      continue;
+    ret = GNUNET_FRAGMENT_process_ack (frags[i], hdr);
+    if (ret == GNUNET_OK)
     {
-      if (frags[i] == NULL)
-        continue;
-      ret = GNUNET_FRAGMENT_process_ack(frags[i], hdr);
-      if (ret == GNUNET_OK)
-        {
 #if DETAILS
-          fprintf(stderr, "%s", "@");  /* good ACK */
+      fprintf (stderr, "%s", "@");     /* good ACK */
 #endif
-          GNUNET_FRAGMENT_context_destroy(frags[i], NULL, NULL);
-          frags[i] = NULL;
-          acks++;
-          return;
-        }
-      if (ret == GNUNET_NO)
-        {
+      GNUNET_FRAGMENT_context_destroy (frags[i], NULL, NULL);
+      frags[i] = NULL;
+      acks++;
+      return;
+    }
+    if (ret == GNUNET_NO)
+    {
 #if DETAILS
-          fprintf(stderr, "%s", "@");  /* good ACK */
+      fprintf (stderr, "%s", "@");     /* good ACK */
 #endif
-          acks++;
-          return;
-        }
+      acks++;
+      return;
     }
+  }
 #if DETAILS
-  fprintf(stderr, "%s", "_");          /* BAD: ack that nobody feels responsible for... */
+  fprintf (stderr, "%s", "_");          /* BAD: ack that nobody feels responsible for... */
 #endif
 }
 
@@ -157,37 +157,37 @@ proc_acks(void *cls, uint32_t msg_id, const struct GNUNET_MessageHeader *hdr)
  * Process fragment (by passing to defrag).
  */
 static void
-proc_frac(void *cls, const struct GNUNET_MessageHeader *hdr)
+proc_frac (void *cls, const struct GNUNET_MessageHeader *hdr)
 {
   struct GNUNET_FRAGMENT_Context **fc = cls;
   int ret;
 
-  GNUNET_FRAGMENT_context_transmission_done(*fc);
-  if (0 == GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, DROPRATE))
-    {
-      frag_drops++;
-      return;                   /* random drop */
-    }
+  GNUNET_FRAGMENT_context_transmission_done (*fc);
+  if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, DROPRATE))
+  {
+    frag_drops++;
+    return;                     /* random drop */
+  }
   if (NULL == defrag)
-    {
-      fprintf(stderr, "%s", "E");      /* Error: frag after shutdown!? */
-      return;
-    }
-  ret = GNUNET_DEFRAGMENT_process_fragment(defrag, hdr);
+  {
+    fprintf (stderr, "%s", "E");       /* Error: frag after shutdown!? */
+    return;
+  }
+  ret = GNUNET_DEFRAGMENT_process_fragment (defrag, hdr);
   if (ret == GNUNET_NO)
-    {
+  {
 #if DETAILS
-      fprintf(stderr, "%s", "?");      /* duplicate fragment */
+    fprintf (stderr, "%s", "?");       /* duplicate fragment */
 #endif
-      dups++;
-    }
+    dups++;
+  }
   else if (ret == GNUNET_OK)
-    {
+  {
 #if DETAILS
-      fprintf(stderr, "%s", ".");      /* good fragment */
+    fprintf (stderr, "%s", ".");       /* good fragment */
 #endif
-      fragc++;
-    }
+    fragc++;
+  }
 }
 
 
@@ -195,35 +195,35 @@ proc_frac(void *cls, const struct GNUNET_MessageHeader *hdr)
  * Main function run with scheduler.
  */
 static void
-run(void *cls, char *const *args, const char *cfgfile,
-    const struct GNUNET_CONFIGURATION_Handle *cfg)
+run (void *cls, char *const *args, const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   unsigned int i;
   struct GNUNET_MessageHeader *msg;
   char buf[MTU + 32 * 1024];
 
-  defrag = GNUNET_DEFRAGMENT_context_create(NULL, MTU, NUM_MSGS         /* enough space for all */
-                                            , NULL, &proc_msgs, &proc_acks);
+  defrag = GNUNET_DEFRAGMENT_context_create (NULL, MTU, NUM_MSGS         /* enough space for all */
+                                             , NULL, &proc_msgs, &proc_acks);
   for (i = 0; i < sizeof(buf); i++)
-    buf[i] = (char)i;
-  msg = (struct GNUNET_MessageHeader *)buf;
+    buf[i] = (char) i;
+  msg = (struct GNUNET_MessageHeader *) buf;
   for (i = 0; i < NUM_MSGS; i++)
-    {
-      msg->type = htons((uint16_t)i);
-      msg->size =
-        htons(sizeof(struct GNUNET_MessageHeader) + (17 * i) % (32 * 1024));
-      frags[i] = GNUNET_FRAGMENT_context_create(NULL /* no stats */,
-                                                MTU, &trackers[i],
-                                                GNUNET_TIME_UNIT_MILLISECONDS,
-                                                GNUNET_TIME_UNIT_SECONDS,
-                                                msg,
-                                                &proc_frac, &frags[i]);
-    }
+  {
+    msg->type = htons ((uint16_t) i);
+    msg->size =
+      htons (sizeof(struct GNUNET_MessageHeader) + (17 * i) % (32 * 1024));
+    frags[i] = GNUNET_FRAGMENT_context_create (NULL /* no stats */,
+                                               MTU, &trackers[i],
+                                               GNUNET_TIME_UNIT_MILLISECONDS,
+                                               GNUNET_TIME_UNIT_SECONDS,
+                                               msg,
+                                               &proc_frac, &frags[i]);
+  }
 }
 
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
   struct GNUNET_GETOPT_CommandLineOption options[] = {
     GNUNET_GETOPT_OPTION_END
@@ -238,17 +238,17 @@ main(int argc, char *argv[])
   };
   unsigned int i;
 
-  GNUNET_log_setup("test-fragmentation",
-                   "WARNING",
-                   NULL);
+  GNUNET_log_setup ("test-fragmentation",
+                    "WARNING",
+                    NULL);
   for (i = 0; i < NUM_MSGS; i++)
-    GNUNET_BANDWIDTH_tracker_init(&trackers[i], NULL, NULL,
-                                  GNUNET_BANDWIDTH_value_init((i + 1) * 1024),
-                                  100);
-  GNUNET_PROGRAM_run(5, argv_prog, "test-fragmentation", "nohelp", options,
-                     &run, NULL);
-  fprintf(stderr,
-          "\nHad %u good fragments, %u duplicate fragments, %u acks and %u simulated drops of acks\n",
-          fragc, dups, acks, ack_drops);
+    GNUNET_BANDWIDTH_tracker_init (&trackers[i], NULL, NULL,
+                                   GNUNET_BANDWIDTH_value_init ((i + 1) * 1024),
+                                   100);
+  GNUNET_PROGRAM_run (5, argv_prog, "test-fragmentation", "nohelp", options,
+                      &run, NULL);
+  fprintf (stderr,
+           "\nHad %u good fragments, %u duplicate fragments, %u acks and %u simulated drops of acks\n",
+           fragc, dups, acks, ack_drops);
   return ret;
 }