5 files changed, 619 insertions, 633 deletions

diff --git a/src/fragmentation/defragmentation.c b/src/fragmentation/defragmentation.c
index bbe6f3741..d68a98c52 100644
--- a/src/fragmentation/defragmentation.c
+++ b/src/fragmentation/defragmentation.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 src/fragmentation/defragmentation.c
  * @brief library to help defragment messages
@@ -29,8 +29,7 @@
 /**
  * Timestamps for fragments.
  */
-struct FragTimes
-{
+struct FragTimes {
   /**
    * The time the fragment was received.
    */
@@ -49,8 +48,7 @@ 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.
    */
@@ -128,16 +126,13 @@ struct MessageContext
    * Was the last fragment we got a duplicate?
    */
   int16_t last_duplicate;
-
 };
 
 
 /**
  * Defragmentation context (one per connection).
  */
-struct GNUNET_DEFRAGMENT_Context
-{
-
+struct GNUNET_DEFRAGMENT_Context {
   /**
    * For statistics.
    */
@@ -190,7 +185,6 @@ struct GNUNET_DEFRAGMENT_Context
    * Maximum message size for each fragment.
    */
   uint16_t mtu;
-
 };
 
 
@@ -208,15 +202,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;
@@ -234,23 +228,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_SCHEDULER_cancel (mc->ack_task);
-      mc->ack_task = NULL;
+      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_free (mc);
-  }
-  GNUNET_assert (0 == dc->list_size);
-  GNUNET_free (dc);
+  GNUNET_assert(0 == dc->list_size);
+  GNUNET_free(dc);
 }
 
 
@@ -260,25 +254,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);
 }
 
 
@@ -287,28 +281,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 */
 
@@ -321,13 +315,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 */
 
@@ -346,7 +340,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;
@@ -359,15 +353,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;
@@ -380,7 +374,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;
@@ -388,21 +382,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);
 }
 
 
@@ -416,8 +410,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;
@@ -435,40 +429,40 @@ 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 (msize < sizeof (struct GNUNET_MessageHeader))
-  {
-    GNUNET_break_op (0);
-    return GNUNET_SYSERR;
-  }
-  fid = ntohl (fh->fragment_id);
-  foff = ntohs (fh->offset);
+  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);
   if (foff >= msize)
-  {
-    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;
+    }
+  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));
   last = 0;
   for (mc = dc->head; NULL != mc; mc = mc->next)
     if (mc->fragment_id > fid)
@@ -477,68 +471,68 @@ GNUNET_DEFRAGMENT_process_fragment (struct GNUNET_DEFRAGMENT_Context *dc,
   mc = dc->head;
   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;
-  }
+  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 ((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;
@@ -549,41 +543,41 @@ GNUNET_DEFRAGMENT_process_fragment (struct GNUNET_DEFRAGMENT_Context *dc,
       bc = 0;
 
   /* 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);
-  }
+  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);
+    }
   /* 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);
-  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;
-  }
+    {
+      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;
+    }
   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 9fca6eef0..5f31f9094 100644
--- a/src/fragmentation/fragmentation.c
+++ b/src/fragmentation/fragmentation.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 src/fragmentation/fragmentation.c
  * @brief library to help fragment messages
@@ -31,14 +31,13 @@
 /**
  * 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.
    */
@@ -134,7 +133,6 @@ struct GNUNET_FRAGMENT_Context
    * Target fragment size.
    */
   uint16_t mtu;
-
 };
 
 
@@ -145,20 +143,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))
+  if (sizeof(struct FragmentAcknowledgement) !=
+      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;
 }
 
@@ -169,7 +167,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];
@@ -182,108 +180,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);
-  if (bit == size / (fc->mtu - sizeof (struct FragmentHeader)))
+  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);
-  if (bit == size / (fc->mtu - sizeof (struct FragmentHeader)))
-    fsize = size % (fc->mtu - sizeof (struct FragmentHeader));
+  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,
+    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);
 }
 
 
@@ -308,53 +306,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;
 }
 
@@ -367,15 +365,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);
 }
 
 
@@ -391,8 +389,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;
@@ -401,97 +399,97 @@ 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)
-    return GNUNET_SYSERR;       /* not our ACK */
-  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++)
-    {
-      if (1 == (fc->acks_mask & (1ULL << i)))
-      {
-        snd_cnt++;
-        if (0 == (abits & (1ULL << i)))
-          ack_cnt++;
-      }
-    }
-    if (0 == ack_cnt)
+  if (sizeof(struct FragmentAcknowledgement) != ntohs(msg->size))
     {
-      /* complete loss */
-      fc->msg_delay = GNUNET_TIME_relative_saturating_multiply (fc->msg_delay,
-                                                                snd_cnt);
+      GNUNET_break_op(0);
+      return GNUNET_SYSERR;
     }
-    else if (snd_cnt > ack_cnt)
+  fa = (const struct FragmentAcknowledgement *)msg;
+  if (ntohl(fa->fragment_id) != fc->fragment_id)
+    return GNUNET_SYSERR;       /* not our ACK */
+  abits = GNUNET_ntohll(fa->bits);
+  if ((GNUNET_YES == fc->wack) &&
+      (0 != fc->num_transmissions))
     {
-      /* some loss, slow down proportionally */
-      fc->msg_delay.rel_value_us = ((fc->msg_delay.rel_value_us * ack_cnt) / snd_cnt);
+      /* 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);
     }
-    else if (snd_cnt == ack_cnt)
+  GNUNET_STATISTICS_update(fc->stats,
+                           _("# fragment acknowledgements received"),
+                           1,
+                           GNUNET_NO);
+  if (abits != (fc->acks & abits))
     {
-      fc->msg_delay.rel_value_us =
-        (ndelay.rel_value_us / fc->num_transmissions + 3 * fc->msg_delay.rel_value_us) / 5;
+      /* ID collission or message reordering, count! This should be rare! */
+      GNUNET_STATISTICS_update(fc->stats,
+                               _("# bits removed from fragmentation ACKs"), 1,
+                               GNUNET_NO);
     }
-    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
     {
-      /* 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);
+      /* 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;
     }
-    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;
 }
 
@@ -507,18 +505,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 9816e2116..3578cadca 100644
--- a/src/fragmentation/fragmentation.h
+++ b/src/fragmentation/fragmentation.h
@@ -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 src/fragmentation/fragmentation.h
  * @brief library to help fragment messages
@@ -33,9 +33,7 @@ GNUNET_NETWORK_STRUCT_BEGIN
  * Header for a message fragment.  Followed by the
  * original message.
  */
-struct FragmentHeader
-{
-
+struct FragmentHeader {
   /**
    * Message header.
    */
@@ -56,16 +54,13 @@ struct FragmentHeader
    * message.  Will be a multiple of the MTU.
    */
   uint16_t offset GNUNET_PACKED;
-
 };
 
 
 /**
  * Message fragment acknowledgement.
  */
-struct FragmentAcknowledgement
-{
-
+struct FragmentAcknowledgement {
   /**
    * Message header.
    */
@@ -82,7 +77,6 @@ struct FragmentAcknowledgement
    * have not yet been received).
    */
   uint64_t bits GNUNET_PACKED;
-
 };
 GNUNET_NETWORK_STRUCT_END
 
diff --git a/src/fragmentation/test_fragmentation.c b/src/fragmentation/test_fragmentation.c
index a49f6d71a..51ae2bb60 100644
--- a/src/fragmentation/test_fragmentation.c
+++ b/src/fragmentation/test_fragmentation.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 fragmentation/test_fragmentation.c
  * @brief test for fragmentation.c
@@ -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 ");    /* duplciate ACK */
+          fprintf(stderr, "%s", "AA ");  /* duplciate 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 d8e598484..6db9c55a9 100644
--- a/src/fragmentation/test_fragmentation_parallel.c
+++ b/src/fragmentation/test_fragmentation_parallel.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 fragmentation/test_fragmentation.c
  * @brief test for fragmentation.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);
-  for (i = 0; i < sizeof (buf); i++)
-    buf[i] = (char) i;
-  msg = (struct GNUNET_MessageHeader *) buf;
+  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;
   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;
 }